src/zoom-c.c

   1 /*
   2  * Copyright (C) 1995-2007, Index Data ApS
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: zoom-c.c,v 1.106 2007-01-10 13:25:46 adam Exp $
   6  */
   7 /**
   8  * \file zoom-c.c
   9  * \brief Implements ZOOM C interface.
  10  */
  11
  12 #include <assert.h>
  13 #include <string.h>
  14 #include <errno.h>
  15 #include "zoom-p.h"
  16
  17 #include <yaz/yaz-util.h>
  18 #include <yaz/xmalloc.h>
  19 #include <yaz/otherinfo.h>
  20 #include <yaz/log.h>
  21 #include <yaz/pquery.h>
  22 #include <yaz/marcdisp.h>
  23 #include <yaz/diagbib1.h>
  24 #include <yaz/charneg.h>
  25 #include <yaz/ill.h>
  26 #include <yaz/srw.h>
  27 #include <yaz/cql.h>
  28 #include <yaz/ccl.h>
  29
  30 static int log_api = 0;
  31 static int log_details = 0;
  32
  33 typedef enum {
  34     zoom_pending,
  35     zoom_complete
  36 } zoom_ret;
  37
  38 static zoom_ret ZOOM_connection_send_init(ZOOM_connection c);
  39 static zoom_ret do_write_ex(ZOOM_connection c, char *buf_out, int len_out);
  40 static char *cql2pqf(ZOOM_connection c, const char *cql);
  41
  42 static void initlog(void)
  43 {
  44     static int log_level_initialized = 0;
  45     if (!log_level_initialized)
  46     {
  47         log_api = yaz_log_module_level("zoom");
  48         log_details = yaz_log_module_level("zoomdetails");
  49         log_level_initialized = 1;
  50     }
  51 }
  52
  53 static ZOOM_Event ZOOM_Event_create(int kind)
  54 {
  55     ZOOM_Event event = (ZOOM_Event) xmalloc(sizeof(*event));
  56     event->kind = kind;
  57     event->next = 0;
  58     event->prev = 0;
  59     yaz_log(log_details, "ZOOM_Event_create(kind=%d)", kind);
  60     return event;
  61 }
  62
  63 static void ZOOM_Event_destroy(ZOOM_Event event)
  64 {
  65     xfree(event);
  66 }
  67
  68 static void ZOOM_connection_put_event(ZOOM_connection c, ZOOM_Event event)
  69 {
  70     if (c->m_queue_back)
  71     {
  72         c->m_queue_back->prev = event;
  73         assert(c->m_queue_front);
  74     }
  75     else
  76     {
  77         assert(!c->m_queue_front);
  78         c->m_queue_front = event;
  79     }
  80     event->next = c->m_queue_back;
  81     event->prev = 0;
  82     c->m_queue_back = event;
  83 }
  84
  85 static ZOOM_Event ZOOM_connection_get_event(ZOOM_connection c)
  86 {
  87     ZOOM_Event event = c->m_queue_front;
  88     if (!event)
  89     {
  90         c->last_event = ZOOM_EVENT_NONE;
  91         return 0;
  92     }
  93     assert(c->m_queue_back);
  94     c->m_queue_front = event->prev;
  95     if (c->m_queue_front)
  96     {
  97         assert(c->m_queue_back);
  98         c->m_queue_front->next = 0;
  99     }
 100     else
 101         c->m_queue_back = 0;
 102     c->last_event = event->kind;
 103     return event;
 104 }
 105
 106 int ZOOM_connection_peek_event(ZOOM_connection c)
 107 {
 108     ZOOM_Event event = c->m_queue_front;
 109
 110     return event ? event->kind : ZOOM_EVENT_NONE;
 111 }
 112
 113 static void set_dset_error(ZOOM_connection c, int error,
 114                            const char *dset,
 115                            const char *addinfo, const char *addinfo2)
 116 {
 117     char *cp;
 118
 119     xfree(c->addinfo);
 120     c->addinfo = 0;
 121     c->error = error;
 122     if (!c->diagset || strcmp(dset, c->diagset))
 123     {
 124         xfree(c->diagset);
 125         c->diagset = xstrdup(dset);
 126         /* remove integer part from SRW diagset .. */
 127         if ((cp = strrchr(c->diagset, '/')))
 128             *cp = '\0';
 129     }
 130     if (addinfo && addinfo2)
 131     {
 132         c->addinfo = (char*) xmalloc(strlen(addinfo) + strlen(addinfo2) + 2);
 133         strcpy(c->addinfo, addinfo);
 134         strcat(c->addinfo, addinfo2);
 135     }
 136     else if (addinfo)
 137         c->addinfo = xstrdup(addinfo);
 138     if (error)
 139         yaz_log(log_api, "%p set_dset_error %s %s:%d %s %s",
 140                 c, c->host_port ? c->host_port : "<>", dset, error,
 141                 addinfo ? addinfo : "",
 142                 addinfo2 ? addinfo2 : "");
 143 }
 144
 145 #if YAZ_HAVE_XML2
 146 static void set_HTTP_error(ZOOM_connection c, int error,
 147                            const char *addinfo, const char *addinfo2)
 148 {
 149     set_dset_error(c, error, "HTTP", addinfo, addinfo2);
 150 }
 151 #endif
 152
 153 static void set_ZOOM_error(ZOOM_connection c, int error,
 154                            const char *addinfo)
 155 {
 156     set_dset_error(c, error, "ZOOM", addinfo, 0);
 157 }
 158
 159 static void clear_error(ZOOM_connection c)
 160 {
 161     /*
 162      * If an error is tied to an operation then it's ok to clear: for
 163      * example, a diagnostic returned from a search is cleared by a
 164      * subsequent search.  However, problems such as Connection Lost
 165      * or Init Refused are not cleared, because they are not
 166      * recoverable: doing another search doesn't help.
 167      */
 168     switch (c->error)
 169     {
 170     case ZOOM_ERROR_CONNECT:
 171     case ZOOM_ERROR_MEMORY:
 172     case ZOOM_ERROR_DECODE:
 173     case ZOOM_ERROR_CONNECTION_LOST:
 174     case ZOOM_ERROR_INIT:
 175     case ZOOM_ERROR_INTERNAL:
 176     case ZOOM_ERROR_UNSUPPORTED_PROTOCOL:
 177         break;
 178     default:
 179         set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
 180     }
 181 }
 182
 183 void ZOOM_connection_show_task(ZOOM_task task)
 184 {
 185     switch(task->which)
 186     {
 187     case ZOOM_TASK_SEARCH:
 188         yaz_log(YLOG_LOG, "search p=%p", task);
 189         break;
 190     case ZOOM_TASK_RETRIEVE:
 191         yaz_log(YLOG_LOG, "retrieve p=%p", task);
 192         break;
 193     case ZOOM_TASK_CONNECT:
 194         yaz_log(YLOG_LOG, "connect p=%p", task);
 195         break;
 196     case ZOOM_TASK_SCAN:
 197         yaz_log(YLOG_LOG, "scant p=%p", task);
 198         break;
 199     }
 200 }
 201
 202 void ZOOM_connection_show_tasks(ZOOM_connection c)
 203 {
 204     ZOOM_task task;
 205     yaz_log(YLOG_LOG, "connection p=%p tasks", c);
 206     for (task = c->tasks; task; task = task->next)
 207         ZOOM_connection_show_task(task);
 208 }
 209
 210 ZOOM_task ZOOM_connection_add_task(ZOOM_connection c, int which)
 211 {
 212     ZOOM_task *taskp = &c->tasks;
 213     while (*taskp)
 214         taskp = &(*taskp)->next;
 215     *taskp = (ZOOM_task) xmalloc(sizeof(**taskp));
 216     (*taskp)->running = 0;
 217     (*taskp)->which = which;
 218     (*taskp)->next = 0;
 219     clear_error(c);
 220     return *taskp;
 221 }
 222
 223 ZOOM_API(int) ZOOM_connection_is_idle(ZOOM_connection c)
 224 {
 225     return c->tasks ? 0 : 1;
 226 }
 227
 228 ZOOM_task ZOOM_connection_insert_task(ZOOM_connection c, int which)
 229 {
 230     ZOOM_task task = (ZOOM_task) xmalloc(sizeof(*task));
 231
 232     task->next = c->tasks;
 233     c->tasks = task;
 234
 235     task->running = 0;
 236     task->which = which;
 237     clear_error(c);
 238     return task;
 239 }
 240
 241 void ZOOM_connection_remove_task(ZOOM_connection c)
 242 {
 243     ZOOM_task task = c->tasks;
 244
 245     if (task)
 246     {
 247         c->tasks = task->next;
 248         switch (task->which)
 249         {
 250         case ZOOM_TASK_SEARCH:
 251             ZOOM_resultset_destroy(task->u.search.resultset);
 252             xfree(task->u.search.syntax);
 253             xfree(task->u.search.elementSetName);
 254             break;
 255         case ZOOM_TASK_RETRIEVE:
 256             ZOOM_resultset_destroy(task->u.retrieve.resultset);
 257             xfree(task->u.retrieve.syntax);
 258             xfree(task->u.retrieve.elementSetName);
 259             break;
 260         case ZOOM_TASK_CONNECT:
 261             break;
 262         case ZOOM_TASK_SCAN:
 263             ZOOM_scanset_destroy(task->u.scan.scan);
 264             break;
 265         case ZOOM_TASK_PACKAGE:
 266             ZOOM_package_destroy(task->u.package);
 267             break;
 268         case ZOOM_TASK_SORT:
 269             ZOOM_resultset_destroy(task->u.sort.resultset);
 270             ZOOM_query_destroy(task->u.sort.q);
 271             break;
 272         default:
 273             assert(0);
 274         }
 275         xfree(task);
 276
 277         if (!c->tasks)
 278         {
 279             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_END);
 280             ZOOM_connection_put_event(c, event);
 281         }
 282     }
 283 }
 284
 285 static int ZOOM_connection_exec_task(ZOOM_connection c);
 286
 287 void ZOOM_connection_remove_tasks(ZOOM_connection c)
 288 {
 289     while (c->tasks)
 290         ZOOM_connection_remove_task(c);
 291 }
 292
 293 static ZOOM_record record_cache_lookup(ZOOM_resultset r, int pos,
 294                                        const char *syntax,
 295                                        const char *elementSetName);
 296
 297 ZOOM_API(ZOOM_connection)
 298     ZOOM_connection_create(ZOOM_options options)
 299 {
 300     ZOOM_connection c = (ZOOM_connection) xmalloc(sizeof(*c));
 301
 302     initlog();
 303
 304     yaz_log(log_api, "%p ZOOM_connection_create", c);
 305
 306     c->proto = PROTO_Z3950;
 307     c->cs = 0;
 308     ZOOM_connection_set_mask(c, 0);
 309     c->reconnect_ok = 0;
 310     c->state = STATE_IDLE;
 311     c->addinfo = 0;
 312     c->diagset = 0;
 313     set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
 314     c->buf_in = 0;
 315     c->len_in = 0;
 316     c->buf_out = 0;
 317     c->len_out = 0;
 318     c->resultsets = 0;
 319
 320     c->options = ZOOM_options_create_with_parent(options);
 321
 322     c->host_port = 0;
 323     c->path = 0;
 324     c->proxy = 0;
 325
 326     c->charset = c->lang = 0;
 327
 328     c->cookie_out = 0;
 329     c->cookie_in = 0;
 330     c->client_IP = 0;
 331     c->tasks = 0;
 332
 333     c->odr_in = odr_createmem(ODR_DECODE);
 334     c->odr_out = odr_createmem(ODR_ENCODE);
 335
 336     c->async = 0;
 337     c->support_named_resultsets = 0;
 338     c->last_event = ZOOM_EVENT_NONE;
 339
 340     c->m_queue_front = 0;
 341     c->m_queue_back = 0;
 342     return c;
 343 }
 344
 345
 346 /* set database names. Take local databases (if set); otherwise
 347    take databases given in ZURL (if set); otherwise use Default */
 348 static char **set_DatabaseNames(ZOOM_connection con, ZOOM_options options,
 349                                 int *num, ODR odr)
 350 {
 351     char **databaseNames;
 352     const char *cp = ZOOM_options_get(options, "databaseName");
 353
 354     if ((!cp || !*cp) && con->host_port)
 355     {
 356         if (strncmp(con->host_port, "unix:", 5) == 0)
 357             cp = strchr(con->host_port+5, ':');
 358         else
 359             cp = strchr(con->host_port, '/');
 360         if (cp)
 361             cp++;
 362     }
 363     if (!cp)
 364         cp = "Default";
 365     nmem_strsplit(odr->mem, "+", cp,  &databaseNames, num);
 366     return databaseNames;
 367 }
 368
 369 ZOOM_API(ZOOM_connection)
 370     ZOOM_connection_new(const char *host, int portnum)
 371 {
 372     ZOOM_connection c = ZOOM_connection_create(0);
 373
 374     ZOOM_connection_connect(c, host, portnum);
 375     return c;
 376 }
 377
 378 static zoom_sru_mode get_sru_mode_from_string(const char *s)
 379 {
 380     if (!s || !*s)
 381         return zoom_sru_soap;
 382     if (!yaz_matchstr(s, "soap"))
 383         return zoom_sru_soap;
 384     else if (!yaz_matchstr(s, "get"))
 385         return zoom_sru_get;
 386     else if (!yaz_matchstr(s, "post"))
 387         return zoom_sru_post;
 388     return zoom_sru_error;
 389 }
 390
 391 ZOOM_API(void)
 392     ZOOM_connection_connect(ZOOM_connection c,
 393                             const char *host, int portnum)
 394 {
 395     const char *val;
 396     ZOOM_task task;
 397
 398     initlog();
 399
 400     yaz_log(log_api, "%p ZOOM_connection_connect host=%s portnum=%d",
 401             c, host, portnum);
 402
 403     set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
 404     ZOOM_connection_remove_tasks(c);
 405
 406     if (c->cs)
 407     {
 408         yaz_log(log_details, "%p ZOOM_connection_connect reconnect ok", c);
 409         c->reconnect_ok = 1;
 410         return;
 411     }
 412     yaz_log(log_details, "%p ZOOM_connection_connect connect", c);
 413     xfree(c->proxy);
 414     val = ZOOM_options_get(c->options, "proxy");
 415     if (val && *val)
 416     {
 417         yaz_log(log_details, "%p ZOOM_connection_connect proxy=%s", c, val);
 418         c->proxy = xstrdup(val);
 419     }
 420     else
 421         c->proxy = 0;
 422
 423     xfree(c->charset);
 424     val = ZOOM_options_get(c->options, "charset");
 425     if (val && *val)
 426     {
 427         yaz_log(log_details, "%p ZOOM_connection_connect charset=%s", c, val);
 428         c->charset = xstrdup(val);
 429     }
 430     else
 431         c->charset = 0;
 432
 433     xfree(c->lang);
 434     val = ZOOM_options_get(c->options, "lang");
 435     if (val && *val)
 436     {
 437         yaz_log(log_details, "%p ZOOM_connection_connect lang=%s", c, val);
 438         c->lang = xstrdup(val);
 439     }
 440     else
 441         c->lang = 0;
 442
 443     xfree(c->host_port);
 444     if (portnum)
 445     {
 446         char hostn[128];
 447         sprintf(hostn, "%.80s:%d", host, portnum);
 448         c->host_port = xstrdup(hostn);
 449     }
 450     else
 451         c->host_port = xstrdup(host);
 452
 453     {
 454         /*
 455          * If the "<scheme>:" part of the host string is preceded by one
 456          * or more comma-separated <name>=<value> pairs, these are taken
 457          * to be options to be set on the connection object.  Among other
 458          * applications, this facility can be used to embed authentication
 459          * in a host string:
 460          *          user=admin,password=secret,tcp:localhost:9999
 461          */
 462         char *remainder = c->host_port;
 463         char *pcolon = strchr(remainder, ':');
 464         char *pcomma;
 465         char *pequals;
 466         while ((pcomma = strchr(remainder, ',')) != 0 &&
 467                (pcolon == 0 || pcomma < pcolon)) {
 468             *pcomma = '\0';
 469             if ((pequals = strchr(remainder, '=')) != 0) {
 470                 *pequals = '\0';
 471                 /*printf("# setting '%s'='%s'\n", remainder, pequals+1);*/
 472                 ZOOM_connection_option_set(c, remainder, pequals+1);
 473             }
 474             remainder = pcomma+1;
 475         }
 476
 477         if (remainder != c->host_port) {
 478             xfree(c->host_port);
 479             c->host_port = xstrdup(remainder);
 480             /*printf("# reset hp='%s'\n", remainder);*/
 481         }
 482     }
 483
 484     val = ZOOM_options_get(c->options, "sru");
 485     c->sru_mode = get_sru_mode_from_string(val);
 486
 487     ZOOM_options_set(c->options, "host", c->host_port);
 488
 489     val = ZOOM_options_get(c->options, "cookie");
 490     if (val && *val)
 491     {
 492         yaz_log(log_details, "%p ZOOM_connection_connect cookie=%s", c, val);
 493         c->cookie_out = xstrdup(val);
 494     }
 495
 496     val = ZOOM_options_get(c->options, "clientIP");
 497     if (val && *val)
 498     {
 499         yaz_log(log_details, "%p ZOOM_connection_connect clientIP=%s",
 500                 c, val);
 501         c->client_IP = xstrdup(val);
 502     }
 503
 504     c->async = ZOOM_options_get_bool(c->options, "async", 0);
 505     yaz_log(log_details, "%p ZOOM_connection_connect async=%d", c, c->async);
 506
 507     task = ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 508
 509     if (!c->async)
 510     {
 511         while (ZOOM_event(1, &c))
 512             ;
 513     }
 514 }
 515
 516 ZOOM_API(ZOOM_query)
 517     ZOOM_query_create(void)
 518 {
 519     ZOOM_query s = (ZOOM_query) xmalloc(sizeof(*s));
 520
 521     yaz_log(log_details, "%p ZOOM_query_create", s);
 522     s->refcount = 1;
 523     s->z_query = 0;
 524     s->sort_spec = 0;
 525     s->odr = odr_createmem(ODR_ENCODE);
 526     s->query_string = 0;
 527
 528     return s;
 529 }
 530
 531 ZOOM_API(void)
 532     ZOOM_query_destroy(ZOOM_query s)
 533 {
 534     if (!s)
 535         return;
 536
 537     (s->refcount)--;
 538     yaz_log(log_details, "%p ZOOM_query_destroy count=%d", s, s->refcount);
 539     if (s->refcount == 0)
 540     {
 541         odr_destroy(s->odr);
 542         xfree(s);
 543     }
 544 }
 545
 546 ZOOM_API(int)
 547     ZOOM_query_prefix(ZOOM_query s, const char *str)
 548 {
 549     s->query_string = odr_strdup(s->odr, str);
 550     s->z_query = (Z_Query *) odr_malloc(s->odr, sizeof(*s->z_query));
 551     s->z_query->which = Z_Query_type_1;
 552     s->z_query->u.type_1 =  p_query_rpn(s->odr, PROTO_Z3950, str);
 553     if (!s->z_query->u.type_1)
 554     {
 555         yaz_log(log_details, "%p ZOOM_query_prefix str=%s failed", s, str);
 556         s->z_query = 0;
 557         return -1;
 558     }
 559     yaz_log(log_details, "%p ZOOM_query_prefix str=%s", s, str);
 560     return 0;
 561 }
 562
 563 ZOOM_API(int)
 564     ZOOM_query_cql(ZOOM_query s, const char *str)
 565 {
 566     Z_External *ext;
 567
 568     s->query_string = odr_strdup(s->odr, str);
 569
 570     ext = (Z_External *) odr_malloc(s->odr, sizeof(*ext));
 571     ext->direct_reference = odr_getoidbystr(s->odr, "1.2.840.10003.16.2");
 572     ext->indirect_reference = 0;
 573     ext->descriptor = 0;
 574     ext->which = Z_External_CQL;
 575     ext->u.cql = s->query_string;
 576
 577     s->z_query = (Z_Query *) odr_malloc(s->odr, sizeof(*s->z_query));
 578     s->z_query->which = Z_Query_type_104;
 579     s->z_query->u.type_104 =  ext;
 580
 581     yaz_log(log_details, "%p ZOOM_query_cql str=%s", s, str);
 582
 583     return 0;
 584 }
 585
 586 /*
 587  * Translate the CQL string client-side into RPN which is passed to
 588  * the server.  This is useful for server's that don't themselves
 589  * support CQL, for which ZOOM_query_cql() is useless.  `conn' is used
 590  * only as a place to stash diagnostics if compilation fails; if this
 591  * information is not needed, a null pointer may be used.
 592  */
 593 ZOOM_API(int)
 594     ZOOM_query_cql2rpn(ZOOM_query s, const char *str, ZOOM_connection conn)
 595 {
 596     char *rpn;
 597     int ret;
 598     ZOOM_connection freeme = 0;
 599
 600     yaz_log(log_details, "%p ZOOM_query_cql2rpn str=%s conn=%p", s, str, conn);
 601     if (conn == 0)
 602         conn = freeme = ZOOM_connection_create(0);
 603
 604     rpn = cql2pqf(conn, str);
 605     if (freeme != 0)
 606         ZOOM_connection_destroy(freeme);
 607     if (rpn == 0)
 608         return -1;
 609
 610     ret = ZOOM_query_prefix(s, rpn);
 611     xfree(rpn);
 612     return ret;
 613 }
 614
 615 /*
 616  * Analogous in every way to ZOOM_query_cql2rpn(), except that there
 617  * is no analogous ZOOM_query_ccl() that just sends uninterpreted CCL
 618  * to the server, as the YAZ GFS doesn't know how to handle this.
 619  */
 620 ZOOM_API(int)
 621     ZOOM_query_ccl2rpn(ZOOM_query s, const char *str, const char *config,
 622                        int *ccl_error, const char **error_string,
 623                        int *error_pos)
 624 {
 625     int ret;
 626     struct ccl_rpn_node *rpn;
 627     CCL_bibset bibset = ccl_qual_mk();
 628
 629     if (config)
 630         ccl_qual_buf(bibset, config);
 631
 632     rpn = ccl_find_str(bibset, str, ccl_error, error_pos);
 633     if (!rpn)
 634     {
 635         *error_string = ccl_err_msg(*ccl_error);
 636         ret = -1;
 637     }
 638     else
 639     {
 640         WRBUF wr = wrbuf_alloc();
 641         ccl_pquery(wr, rpn);
 642         ccl_rpn_delete(rpn);
 643         ret = ZOOM_query_prefix(s, wrbuf_buf(wr));
 644         wrbuf_free(wr, 1);
 645     }
 646     ccl_qual_rm(&bibset);
 647     return ret;
 648 }
 649
 650 ZOOM_API(int)
 651     ZOOM_query_sortby(ZOOM_query s, const char *criteria)
 652 {
 653     s->sort_spec = yaz_sort_spec(s->odr, criteria);
 654     if (!s->sort_spec)
 655     {
 656         yaz_log(log_details, "%p ZOOM_query_sortby criteria=%s failed",
 657                 s, criteria);
 658         return -1;
 659     }
 660     yaz_log(log_details, "%p ZOOM_query_sortby criteria=%s", s, criteria);
 661     return 0;
 662 }
 663
 664 static zoom_ret do_write(ZOOM_connection c);
 665
 666 ZOOM_API(void)
 667     ZOOM_connection_destroy(ZOOM_connection c)
 668 {
 669     ZOOM_resultset r;
 670     if (!c)
 671         return;
 672     yaz_log(log_api, "%p ZOOM_connection_destroy", c);
 673     if (c->cs)
 674         cs_close(c->cs);
 675     for (r = c->resultsets; r; r = r->next)
 676         r->connection = 0;
 677
 678     xfree(c->buf_in);
 679     xfree(c->addinfo);
 680     xfree(c->diagset);
 681     odr_destroy(c->odr_in);
 682     odr_destroy(c->odr_out);
 683     ZOOM_options_destroy(c->options);
 684     ZOOM_connection_remove_tasks(c);
 685     xfree(c->host_port);
 686     xfree(c->path);
 687     xfree(c->proxy);
 688     xfree(c->charset);
 689     xfree(c->lang);
 690     xfree(c->cookie_out);
 691     xfree(c->cookie_in);
 692     xfree(c->client_IP);
 693     xfree(c);
 694 }
 695
 696 void ZOOM_resultset_addref(ZOOM_resultset r)
 697 {
 698     if (r)
 699     {
 700         (r->refcount)++;
 701         yaz_log(log_details, "%p ZOOM_resultset_addref count=%d",
 702                 r, r->refcount);
 703     }
 704 }
 705
 706 ZOOM_resultset ZOOM_resultset_create(void)
 707 {
 708     int i;
 709     ZOOM_resultset r = (ZOOM_resultset) xmalloc(sizeof(*r));
 710
 711     initlog();
 712
 713     yaz_log(log_details, "%p ZOOM_resultset_create", r);
 714     r->refcount = 1;
 715     r->size = 0;
 716     r->odr = odr_createmem(ODR_ENCODE);
 717     r->piggyback = 1;
 718     r->setname = 0;
 719     r->schema = 0;
 720     r->step = 0;
 721     for (i = 0; i<RECORD_HASH_SIZE; i++)
 722         r->record_hash[i] = 0;
 723     r->r_sort_spec = 0;
 724     r->query = 0;
 725     r->connection = 0;
 726     r->next = 0;
 727     r->databaseNames = 0;
 728     r->num_databaseNames = 0;
 729     return r;
 730 }
 731
 732 ZOOM_API(ZOOM_resultset)
 733     ZOOM_connection_search_pqf(ZOOM_connection c, const char *q)
 734 {
 735     ZOOM_resultset r;
 736     ZOOM_query s = ZOOM_query_create();
 737
 738     ZOOM_query_prefix(s, q);
 739
 740     r = ZOOM_connection_search(c, s);
 741     ZOOM_query_destroy(s);
 742     return r;
 743 }
 744
 745 ZOOM_API(ZOOM_resultset)
 746     ZOOM_connection_search(ZOOM_connection c, ZOOM_query q)
 747 {
 748     ZOOM_resultset r = ZOOM_resultset_create();
 749     ZOOM_task task;
 750     const char *cp;
 751     int start, count;
 752     const char *syntax, *elementSetName;
 753
 754     yaz_log(log_api, "%p ZOOM_connection_search set %p query %p", c, r, q);
 755     r->r_sort_spec = q->sort_spec;
 756     r->query = q;
 757
 758     r->options = ZOOM_options_create_with_parent(c->options);
 759
 760     start = ZOOM_options_get_int(r->options, "start", 0);
 761     count = ZOOM_options_get_int(r->options, "count", 0);
 762     {
 763         /* If "presentChunk" is defined use that; otherwise "step" */
 764         const char *cp = ZOOM_options_get(r->options, "presentChunk");
 765         r->step = ZOOM_options_get_int(r->options,
 766                                        (cp != 0 ? "presentChunk": "step"), 0);
 767     }
 768     r->piggyback = ZOOM_options_get_bool(r->options, "piggyback", 1);
 769     cp = ZOOM_options_get(r->options, "setname");
 770     if (cp)
 771         r->setname = xstrdup(cp);
 772     cp = ZOOM_options_get(r->options, "schema");
 773     if (cp)
 774         r->schema = xstrdup(cp);
 775
 776     r->databaseNames = set_DatabaseNames(c, c->options, &r->num_databaseNames,
 777                                          r->odr);
 778
 779     r->connection = c;
 780
 781     r->next = c->resultsets;
 782     c->resultsets = r;
 783
 784     if (c->host_port && c->proto == PROTO_HTTP)
 785     {
 786         if (!c->cs)
 787         {
 788             yaz_log(log_details, "ZOOM_connection_search: no comstack");
 789             ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 790         }
 791         else
 792         {
 793             yaz_log(log_details, "ZOOM_connection_search: reconnect");
 794             c->reconnect_ok = 1;
 795         }
 796     }
 797
 798     task = ZOOM_connection_add_task(c, ZOOM_TASK_SEARCH);
 799     task->u.search.resultset = r;
 800     task->u.search.start = start;
 801     task->u.search.count = count;
 802
 803     syntax = ZOOM_options_get(r->options, "preferredRecordSyntax");
 804     task->u.search.syntax = syntax ? xstrdup(syntax) : 0;
 805     elementSetName = ZOOM_options_get(r->options, "elementSetName");
 806     task->u.search.elementSetName = elementSetName
 807         ? xstrdup(elementSetName) : 0;
 808
 809     ZOOM_resultset_addref(r);
 810
 811     (q->refcount)++;
 812
 813     if (!c->async)
 814     {
 815         while (ZOOM_event(1, &c))
 816             ;
 817     }
 818     return r;
 819 }
 820
 821 /*
 822  * This is the old result-set sorting API, which is maintained only
 823  * for the sake of binary compatibility.  There is no reason ever to
 824  * use this rather than ZOOM_resultset_sort1().
 825  */
 826 ZOOM_API(void)
 827     ZOOM_resultset_sort(ZOOM_resultset r,
 828                         const char *sort_type, const char *sort_spec)
 829 {
 830     (void) ZOOM_resultset_sort1(r, sort_type, sort_spec);
 831 }
 832
 833 ZOOM_API(int)
 834     ZOOM_resultset_sort1(ZOOM_resultset r,
 835                          const char *sort_type, const char *sort_spec)
 836 {
 837     ZOOM_connection c = r->connection;
 838     ZOOM_task task;
 839     ZOOM_query newq;
 840
 841     newq = ZOOM_query_create();
 842     if (ZOOM_query_sortby(newq, sort_spec) < 0)
 843         return -1;
 844
 845     yaz_log(log_api, "%p ZOOM_resultset_sort r=%p sort_type=%s sort_spec=%s",
 846             r, r, sort_type, sort_spec);
 847     if (!c)
 848         return 0;
 849
 850     if (c->host_port && c->proto == PROTO_HTTP)
 851     {
 852         if (!c->cs)
 853         {
 854             yaz_log(log_details, "%p ZOOM_resultset_sort: no comstack", r);
 855             ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 856         }
 857         else
 858         {
 859             yaz_log(log_details, "%p ZOOM_resultset_sort: prepare reconnect",
 860                     r);
 861             c->reconnect_ok = 1;
 862         }
 863     }
 864
 865     ZOOM_resultset_cache_reset(r);
 866     task = ZOOM_connection_add_task(c, ZOOM_TASK_SORT);
 867     task->u.sort.resultset = r;
 868     task->u.sort.q = newq;
 869
 870     ZOOM_resultset_addref(r);
 871
 872     if (!c->async)
 873     {
 874         while (ZOOM_event(1, &c))
 875             ;
 876     }
 877
 878     return 0;
 879 }
 880
 881 ZOOM_API(void)
 882     ZOOM_resultset_cache_reset(ZOOM_resultset r)
 883 {
 884     int i;
 885     for (i = 0; i<RECORD_HASH_SIZE; i++)
 886     {
 887         ZOOM_record_cache rc;
 888         for (rc = r->record_hash[i]; rc; rc = rc->next)
 889         {
 890             if (rc->rec.wrbuf_marc)
 891                 wrbuf_free(rc->rec.wrbuf_marc, 1);
 892             if (rc->rec.wrbuf_iconv)
 893                 wrbuf_free(rc->rec.wrbuf_iconv, 1);
 894             if (rc->rec.wrbuf_opac)
 895                 wrbuf_free(rc->rec.wrbuf_opac, 1);
 896         }
 897         r->record_hash[i] = 0;
 898     }
 899 }
 900
 901 ZOOM_API(void)
 902     ZOOM_resultset_destroy(ZOOM_resultset r)
 903 {
 904     if (!r)
 905         return;
 906     (r->refcount)--;
 907     yaz_log(log_details, "%p ZOOM_resultset_destroy r=%p count=%d",
 908             r, r, r->refcount);
 909     if (r->refcount == 0)
 910     {
 911         ZOOM_resultset_cache_reset(r);
 912
 913         if (r->connection)
 914         {
 915             /* remove ourselves from the resultsets in connection */
 916             ZOOM_resultset *rp = &r->connection->resultsets;
 917             while (1)
 918             {
 919                 assert(*rp);   /* we must be in this list!! */
 920                 if (*rp == r)
 921                 {   /* OK, we're here - take us out of it */
 922                     *rp = (*rp)->next;
 923                     break;
 924                 }
 925                 rp = &(*rp)->next;
 926             }
 927         }
 928         ZOOM_query_destroy(r->query);
 929         ZOOM_options_destroy(r->options);
 930         odr_destroy(r->odr);
 931         xfree(r->setname);
 932         xfree(r->schema);
 933         xfree(r);
 934     }
 935 }
 936
 937 ZOOM_API(size_t)
 938     ZOOM_resultset_size(ZOOM_resultset r)
 939 {
 940     yaz_log(log_details, "ZOOM_resultset_size r=%p count=%d",
 941             r, r->size);
 942     return r->size;
 943 }
 944
 945 static void do_close(ZOOM_connection c)
 946 {
 947     if (c->cs)
 948         cs_close(c->cs);
 949     c->cs = 0;
 950     ZOOM_connection_set_mask(c, 0);
 951     c->state = STATE_IDLE;
 952 }
 953
 954 static int ZOOM_test_reconnect(ZOOM_connection c)
 955 {
 956     if (!c->reconnect_ok)
 957         return 0;
 958     do_close(c);
 959     c->reconnect_ok = 0;
 960     c->tasks->running = 0;
 961     ZOOM_connection_insert_task(c, ZOOM_TASK_CONNECT);
 962     return 1;
 963 }
 964
 965 static void ZOOM_resultset_retrieve(ZOOM_resultset r,
 966                                     int force_sync, int start, int count)
 967 {
 968     ZOOM_task task;
 969     ZOOM_connection c;
 970     const char *cp;
 971     const char *syntax, *elementSetName;
 972
 973     if (!r)
 974         return;
 975     yaz_log(log_details, "%p ZOOM_resultset_retrieve force_sync=%d start=%d"
 976             " count=%d", r, force_sync, start, count);
 977     c = r->connection;
 978     if (!c)
 979         return;
 980
 981     if (c->host_port && c->proto == PROTO_HTTP)
 982     {
 983         if (!c->cs)
 984         {
 985             yaz_log(log_details, "%p ZOOM_resultset_retrieve: no comstack", r);
 986             ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 987         }
 988         else
 989         {
 990             yaz_log(log_details, "%p ZOOM_resultset_retrieve: prepare "
 991                     "reconnect", r);
 992             c->reconnect_ok = 1;
 993         }
 994     }
 995     task = ZOOM_connection_add_task(c, ZOOM_TASK_RETRIEVE);
 996     task->u.retrieve.resultset = r;
 997     task->u.retrieve.start = start;
 998     task->u.retrieve.count = count;
 999
1000     syntax = ZOOM_options_get(r->options, "preferredRecordSyntax");
1001     task->u.retrieve.syntax = syntax ? xstrdup(syntax) : 0;
1002     elementSetName = ZOOM_options_get(r->options, "elementSetName");
1003     task->u.retrieve.elementSetName = elementSetName
1004         ? xstrdup(elementSetName) : 0;
1005
1006     cp = ZOOM_options_get(r->options, "schema");
1007     if (cp)
1008     {
1009         if (!r->schema || strcmp(r->schema, cp))
1010         {
1011             xfree(r->schema);
1012             r->schema = xstrdup(cp);
1013         }
1014     }
1015
1016     ZOOM_resultset_addref(r);
1017
1018     if (!r->connection->async || force_sync)
1019         while (r->connection && ZOOM_event(1, &r->connection))
1020             ;
1021 }
1022
1023 ZOOM_API(void)
1024     ZOOM_resultset_records(ZOOM_resultset r, ZOOM_record *recs,
1025                            size_t start, size_t count)
1026 {
1027     int force_present = 0;
1028
1029     if (!r)
1030         return ;
1031     yaz_log(log_api, "%p ZOOM_resultset_records r=%p start=%ld count=%ld",
1032             r, r, (long) start, (long) count);
1033     if (count && recs)
1034         force_present = 1;
1035     ZOOM_resultset_retrieve(r, force_present, start, count);
1036     if (force_present)
1037     {
1038         size_t i;
1039         for (i = 0; i< count; i++)
1040             recs[i] = ZOOM_resultset_record_immediate(r, i+start);
1041     }
1042 }
1043
1044 static void get_cert(ZOOM_connection c)
1045 {
1046     char *cert_buf;
1047     int cert_len;
1048
1049     if (cs_get_peer_certificate_x509(c->cs, &cert_buf, &cert_len))
1050     {
1051         ZOOM_connection_option_setl(c, "sslPeerCert",
1052                                     cert_buf, cert_len);
1053         xfree(cert_buf);
1054     }
1055 }
1056
1057 static zoom_ret do_connect(ZOOM_connection c)
1058 {
1059     void *add;
1060     const char *effective_host;
1061
1062     if (c->proxy)
1063         effective_host = c->proxy;
1064     else
1065         effective_host = c->host_port;
1066
1067     yaz_log(log_details, "%p do_connect effective_host=%s", c, effective_host);
1068
1069     if (c->cs)
1070         cs_close(c->cs);
1071     c->cs = cs_create_host(effective_host, 0, &add);
1072
1073     if (c->cs && c->cs->protocol == PROTO_HTTP)
1074     {
1075 #if YAZ_HAVE_XML2
1076         const char *path = 0;
1077
1078         c->proto = PROTO_HTTP;
1079         cs_get_host_args(c->host_port, &path);
1080         xfree(c->path);
1081         c->path = (char*) xmalloc(strlen(path)+2);
1082         c->path[0] = '/';
1083         strcpy(c->path+1, path);
1084 #else
1085         set_ZOOM_error(c, ZOOM_ERROR_UNSUPPORTED_PROTOCOL, "SRW");
1086         do_close(c);
1087         return zoom_complete;
1088 #endif
1089     }
1090     if (c->cs)
1091     {
1092         int ret = cs_connect(c->cs, add);
1093         if (ret == 0)
1094         {
1095             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
1096             ZOOM_connection_put_event(c, event);
1097             get_cert(c);
1098             if (c->proto == PROTO_Z3950)
1099                 ZOOM_connection_send_init(c);
1100             else
1101             {
1102                 /* no init request for SRW .. */
1103                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1104                 ZOOM_connection_remove_task(c);
1105                 ZOOM_connection_set_mask(c, 0);
1106                 ZOOM_connection_exec_task(c);
1107             }
1108             c->state = STATE_ESTABLISHED;
1109             return zoom_pending;
1110         }
1111         else if (ret > 0)
1112         {
1113             int mask = ZOOM_SELECT_EXCEPT;
1114             if (c->cs->io_pending & CS_WANT_WRITE)
1115                 mask += ZOOM_SELECT_WRITE;
1116             if (c->cs->io_pending & CS_WANT_READ)
1117                 mask += ZOOM_SELECT_READ;
1118             ZOOM_connection_set_mask(c, mask);
1119             c->state = STATE_CONNECTING;
1120             return zoom_pending;
1121         }
1122     }
1123     c->state = STATE_IDLE;
1124     set_ZOOM_error(c, ZOOM_ERROR_CONNECT, c->host_port);
1125     return zoom_complete;
1126 }
1127
1128 static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
1129 {
1130     int i;
1131     for (i = 0; i<200; i++)
1132     {
1133         size_t len;
1134         Z_OtherInformation **oi;
1135         char buf[80];
1136         const char *val;
1137         const char *cp;
1138         int oidval;
1139
1140         sprintf(buf, "otherInfo%d", i);
1141         val = ZOOM_options_get(c->options, buf);
1142         if (!val)
1143             break;
1144         cp = strchr(val, ':');
1145         if (!cp)
1146             continue;
1147         len = cp - val;
1148         if (len >= sizeof(buf))
1149             len = sizeof(buf)-1;
1150         memcpy(buf, val, len);
1151         buf[len] = '\0';
1152         oidval = oid_getvalbyname(buf);
1153         if (oidval == VAL_NONE)
1154             continue;
1155
1156         yaz_oi_APDU(a, &oi);
1157         yaz_oi_set_string_oidval(oi, out, oidval, 1, cp+1);
1158     }
1159 }
1160
1161 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
1162 {
1163     assert(a);
1164     if (c->cookie_out)
1165     {
1166         Z_OtherInformation **oi;
1167         yaz_oi_APDU(a, &oi);
1168         yaz_oi_set_string_oidval(oi, out, VAL_COOKIE, 1, c->cookie_out);
1169     }
1170     if (c->client_IP)
1171     {
1172         Z_OtherInformation **oi;
1173         yaz_oi_APDU(a, &oi);
1174         yaz_oi_set_string_oidval(oi, out, VAL_CLIENT_IP, 1, c->client_IP);
1175     }
1176     otherInfo_attach(c, a, out);
1177     if (!z_APDU(out, &a, 0, 0))
1178     {
1179         FILE *outf = fopen("/tmp/apdu.txt", "a");
1180         if (a && outf)
1181         {
1182             ODR odr_pr = odr_createmem(ODR_PRINT);
1183             fprintf(outf, "a=%p\n", a);
1184             odr_setprint(odr_pr, outf);
1185             z_APDU(odr_pr, &a, 0, 0);
1186             odr_destroy(odr_pr);
1187         }
1188         yaz_log(log_api, "%p encoding_APDU: encoding failed", c);
1189         set_ZOOM_error(c, ZOOM_ERROR_ENCODE, 0);
1190         odr_reset(out);
1191         return -1;
1192     }
1193     yaz_log(log_details, "%p encoding_APDU encoding OK", c);
1194     return 0;
1195 }
1196
1197 static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
1198 {
1199     ZOOM_Event event;
1200     assert(a);
1201     if (encode_APDU(c, a, c->odr_out))
1202         return zoom_complete;
1203     yaz_log(log_details, "%p send APDU type=%d", c, a->which);
1204     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
1205     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
1206     ZOOM_connection_put_event(c, event);
1207     odr_reset(c->odr_out);
1208     return do_write(c);
1209 }
1210
1211 /* returns 1 if PDU was sent OK (still pending )
1212    0 if PDU was not sent OK (nothing to wait for)
1213 */
1214
1215 static zoom_ret ZOOM_connection_send_init(ZOOM_connection c)
1216 {
1217     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
1218     Z_InitRequest *ireq = apdu->u.initRequest;
1219     Z_IdAuthentication *auth = (Z_IdAuthentication *)
1220         odr_malloc(c->odr_out, sizeof(*auth));
1221     const char *auth_groupId = ZOOM_options_get(c->options, "group");
1222     const char *auth_userId = ZOOM_options_get(c->options, "user");
1223     const char *auth_password = ZOOM_options_get(c->options, "password");
1224     char *version;
1225
1226     /* support the pass for backwards compatibility */
1227     if (!auth_password)
1228         auth_password = ZOOM_options_get(c->options, "pass");
1229
1230     ODR_MASK_SET(ireq->options, Z_Options_search);
1231     ODR_MASK_SET(ireq->options, Z_Options_present);
1232     ODR_MASK_SET(ireq->options, Z_Options_scan);
1233     ODR_MASK_SET(ireq->options, Z_Options_sort);
1234     ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
1235     ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
1236
1237     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
1238     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
1239     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
1240
1241     /* Index Data's Z39.50 Implementor Id is 81 */
1242     ireq->implementationId =
1243         odr_prepend(c->odr_out,
1244                     ZOOM_options_get(c->options, "implementationId"),
1245                     odr_prepend(c->odr_out, "81", ireq->implementationId));
1246
1247     ireq->implementationName =
1248         odr_prepend(c->odr_out,
1249                     ZOOM_options_get(c->options, "implementationName"),
1250                     odr_prepend(c->odr_out, "ZOOM-C",
1251                                 ireq->implementationName));
1252
1253     version = odr_strdup(c->odr_out, "$Revision: 1.106 $");
1254     if (strlen(version) > 10)   /* check for unexpanded CVS strings */
1255         version[strlen(version)-2] = '\0';
1256     ireq->implementationVersion =
1257         odr_prepend(c->odr_out,
1258                     ZOOM_options_get(c->options, "implementationVersion"),
1259                     odr_prepend(c->odr_out, &version[11],
1260                                 ireq->implementationVersion));
1261
1262     *ireq->maximumRecordSize =
1263         ZOOM_options_get_int(c->options, "maximumRecordSize", 1024*1024);
1264     *ireq->preferredMessageSize =
1265         ZOOM_options_get_int(c->options, "preferredMessageSize", 1024*1024);
1266
1267     if (auth_groupId || auth_password)
1268     {
1269         Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
1270         int i = 0;
1271         pass->groupId = 0;
1272         if (auth_groupId && *auth_groupId)
1273         {
1274             pass->groupId = (char *)
1275                 odr_malloc(c->odr_out, strlen(auth_groupId)+1);
1276             strcpy(pass->groupId, auth_groupId);
1277             i++;
1278         }
1279         pass->userId = 0;
1280         if (auth_userId && *auth_userId)
1281         {
1282             pass->userId = (char *)
1283                 odr_malloc(c->odr_out, strlen(auth_userId)+1);
1284             strcpy(pass->userId, auth_userId);
1285             i++;
1286         }
1287         pass->password = 0;
1288         if (auth_password && *auth_password)
1289         {
1290             pass->password = (char *)
1291                 odr_malloc(c->odr_out, strlen(auth_password)+1);
1292             strcpy(pass->password, auth_password);
1293             i++;
1294         }
1295         if (i)
1296         {
1297             auth->which = Z_IdAuthentication_idPass;
1298             auth->u.idPass = pass;
1299             ireq->idAuthentication = auth;
1300         }
1301     }
1302     else if (auth_userId)
1303     {
1304         auth->which = Z_IdAuthentication_open;
1305         auth->u.open = (char *)
1306             odr_malloc(c->odr_out, strlen(auth_userId)+1);
1307         strcpy(auth->u.open, auth_userId);
1308         ireq->idAuthentication = auth;
1309     }
1310     if (c->proxy)
1311         yaz_oi_set_string_oidval(&ireq->otherInfo, c->odr_out,
1312                                  VAL_PROXY, 1, c->host_port);
1313     if (c->charset || c->lang)
1314     {
1315         Z_OtherInformation **oi;
1316         Z_OtherInformationUnit *oi_unit;
1317
1318         yaz_oi_APDU(apdu, &oi);
1319
1320         if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
1321         {
1322             ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
1323             oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
1324             oi_unit->information.externallyDefinedInfo =
1325                 yaz_set_proposal_charneg_list(c->odr_out, " ",
1326                                               c->charset, c->lang, 1);
1327         }
1328     }
1329     assert(apdu);
1330     return send_APDU(c, apdu);
1331 }
1332
1333 #if YAZ_HAVE_XML2
1334 static zoom_ret send_srw(ZOOM_connection c, Z_SRW_PDU *sr)
1335 {
1336     Z_GDU *gdu;
1337     ZOOM_Event event;
1338
1339     gdu = z_get_HTTP_Request_host_path(c->odr_out, c->host_port, c->path);
1340
1341     if (c->sru_mode == zoom_sru_get)
1342     {
1343         yaz_sru_get_encode(gdu->u.HTTP_Request, sr, c->odr_out, c->charset);
1344     }
1345     else if (c->sru_mode == zoom_sru_post)
1346     {
1347         yaz_sru_post_encode(gdu->u.HTTP_Request, sr, c->odr_out, c->charset);
1348     }
1349     else if (c->sru_mode == zoom_sru_soap)
1350     {
1351         yaz_sru_soap_encode(gdu->u.HTTP_Request, sr, c->odr_out, c->charset);
1352     }
1353     if (!z_GDU(c->odr_out, &gdu, 0, 0))
1354         return zoom_complete;
1355     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
1356
1357     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
1358     ZOOM_connection_put_event(c, event);
1359     odr_reset(c->odr_out);
1360     return do_write(c);
1361 }
1362 #endif
1363
1364 #if YAZ_HAVE_XML2
1365 static zoom_ret ZOOM_connection_srw_send_search(ZOOM_connection c)
1366 {
1367     int i;
1368     int *start, *count;
1369     ZOOM_resultset resultset = 0;
1370     Z_SRW_PDU *sr = 0;
1371     const char *option_val = 0;
1372
1373     if (c->error)                  /* don't continue on error */
1374         return zoom_complete;
1375     assert(c->tasks);
1376     switch(c->tasks->which)
1377     {
1378     case ZOOM_TASK_SEARCH:
1379         resultset = c->tasks->u.search.resultset;
1380         resultset->setname = xstrdup("default");
1381         ZOOM_options_set(resultset->options, "setname", resultset->setname);
1382         start = &c->tasks->u.search.start;
1383         count = &c->tasks->u.search.count;
1384         break;
1385     case ZOOM_TASK_RETRIEVE:
1386         resultset = c->tasks->u.retrieve.resultset;
1387
1388         start = &c->tasks->u.retrieve.start;
1389         count = &c->tasks->u.retrieve.count;
1390
1391         if (*start >= resultset->size)
1392             return zoom_complete;
1393         if (*start + *count > resultset->size)
1394             *count = resultset->size - *start;
1395
1396         for (i = 0; i < *count; i++)
1397         {
1398             ZOOM_record rec =
1399                 record_cache_lookup(resultset, i + *start,
1400                                     c->tasks->u.retrieve.syntax,
1401                                     c->tasks->u.retrieve.elementSetName);
1402             if (!rec)
1403                 break;
1404             else
1405             {
1406                 ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
1407                 ZOOM_connection_put_event(c, event);
1408             }
1409         }
1410         *start += i;
1411         *count -= i;
1412
1413         if (*count == 0)
1414             return zoom_complete;
1415         break;
1416     default:
1417         return zoom_complete;
1418     }
1419     assert(resultset->query);
1420
1421     sr = yaz_srw_get(c->odr_out, Z_SRW_searchRetrieve_request);
1422
1423     if (resultset->query->z_query->which == Z_Query_type_104
1424         && resultset->query->z_query->u.type_104->which == Z_External_CQL)
1425     {
1426         sr->u.request->query_type = Z_SRW_query_type_cql;
1427         sr->u.request->query.cql =resultset->query->z_query->u.type_104->u.cql;
1428     }
1429     else if (resultset->query->z_query->which == Z_Query_type_1 &&
1430              resultset->query->z_query->u.type_1)
1431     {
1432         sr->u.request->query_type = Z_SRW_query_type_pqf;
1433         sr->u.request->query.pqf = resultset->query->query_string;
1434     }
1435     else
1436     {
1437         set_ZOOM_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
1438         return zoom_complete;
1439     }
1440     sr->u.request->startRecord = odr_intdup(c->odr_out, *start + 1);
1441     sr->u.request->maximumRecords = odr_intdup(
1442         c->odr_out, resultset->step>0 ? resultset->step : *count);
1443     sr->u.request->recordSchema = resultset->schema;
1444
1445     option_val = ZOOM_resultset_option_get(resultset, "recordPacking");
1446     if (option_val)
1447         sr->u.request->recordPacking = odr_strdup(c->odr_out, option_val);
1448
1449     option_val = ZOOM_resultset_option_get(resultset, "extraArgs");
1450     if (option_val)
1451         sr->extra_args = odr_strdup(c->odr_out, option_val);
1452     return send_srw(c, sr);
1453 }
1454 #else
1455 static zoom_ret ZOOM_connection_srw_send_search(ZOOM_connection c)
1456 {
1457     return zoom_complete;
1458 }
1459 #endif
1460
1461 static zoom_ret ZOOM_connection_send_search(ZOOM_connection c)
1462 {
1463     ZOOM_resultset r;
1464     int lslb, ssub, mspn;
1465     const char *syntax;
1466     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
1467     Z_SearchRequest *search_req = apdu->u.searchRequest;
1468     const char *elementSetName;
1469     const char *smallSetElementSetName;
1470     const char *mediumSetElementSetName;
1471
1472     assert(c->tasks);
1473     assert(c->tasks->which == ZOOM_TASK_SEARCH);
1474
1475     r = c->tasks->u.search.resultset;
1476
1477     yaz_log(log_details, "%p ZOOM_connection_send_search set=%p", c, r);
1478
1479     elementSetName =
1480         ZOOM_options_get(r->options, "elementSetName");
1481     smallSetElementSetName  =
1482         ZOOM_options_get(r->options, "smallSetElementSetName");
1483     mediumSetElementSetName =
1484         ZOOM_options_get(r->options, "mediumSetElementSetName");
1485
1486     if (!smallSetElementSetName)
1487         smallSetElementSetName = elementSetName;
1488
1489     if (!mediumSetElementSetName)
1490         mediumSetElementSetName = elementSetName;
1491
1492     assert(r);
1493     assert(r->query);
1494
1495     /* prepare query for the search request */
1496     search_req->query = r->query->z_query;
1497     if (!search_req->query)
1498     {
1499         set_ZOOM_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
1500         return zoom_complete;
1501     }
1502
1503     search_req->databaseNames = r->databaseNames;
1504     search_req->num_databaseNames = r->num_databaseNames;
1505
1506     /* get syntax (no need to provide unless piggyback is in effect) */
1507     syntax = c->tasks->u.search.syntax;
1508
1509     lslb = ZOOM_options_get_int(r->options, "largeSetLowerBound", -1);
1510     ssub = ZOOM_options_get_int(r->options, "smallSetUpperBound", -1);
1511     mspn = ZOOM_options_get_int(r->options, "mediumSetPresentNumber", -1);
1512     if (lslb != -1 && ssub != -1 && mspn != -1)
1513     {
1514         /* So're a Z39.50 expert? Let's hope you don't do sort */
1515         *search_req->largeSetLowerBound = lslb;
1516         *search_req->smallSetUpperBound = ssub;
1517         *search_req->mediumSetPresentNumber = mspn;
1518     }
1519     else if (c->tasks->u.search.start == 0 && c->tasks->u.search.count > 0
1520              && r->piggyback && !r->r_sort_spec && !r->schema)
1521     {
1522         /* Regular piggyback - do it unless we're going to do sort */
1523         *search_req->largeSetLowerBound = 2000000000;
1524         *search_req->smallSetUpperBound = 1;
1525         *search_req->mediumSetPresentNumber =
1526             r->step>0 ? r->step : c->tasks->u.search.count;
1527     }
1528     else
1529     {
1530         /* non-piggyback. Need not provide elementsets or syntaxes .. */
1531         smallSetElementSetName = 0;
1532         mediumSetElementSetName = 0;
1533         syntax = 0;
1534     }
1535     if (smallSetElementSetName && *smallSetElementSetName)
1536     {
1537         Z_ElementSetNames *esn = (Z_ElementSetNames *)
1538             odr_malloc(c->odr_out, sizeof(*esn));
1539
1540         esn->which = Z_ElementSetNames_generic;
1541         esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
1542         search_req->smallSetElementSetNames = esn;
1543     }
1544     if (mediumSetElementSetName && *mediumSetElementSetName)
1545     {
1546         Z_ElementSetNames *esn =(Z_ElementSetNames *)
1547             odr_malloc(c->odr_out, sizeof(*esn));
1548
1549         esn->which = Z_ElementSetNames_generic;
1550         esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
1551         search_req->mediumSetElementSetNames = esn;
1552     }
1553     if (syntax)
1554         search_req->preferredRecordSyntax =
1555             yaz_str_to_z3950oid(c->odr_out, CLASS_RECSYN, syntax);
1556
1557     if (!r->setname)
1558     {
1559         if (c->support_named_resultsets)
1560         {
1561             char setname[14];
1562             int ord;
1563             /* find the lowest unused ordinal so that we re-use
1564                result sets on the server. */
1565             for (ord = 1; ; ord++)
1566             {
1567                 ZOOM_resultset rp;
1568                 sprintf(setname, "%d", ord);
1569                 for (rp = c->resultsets; rp; rp = rp->next)
1570                     if (rp->setname && !strcmp(rp->setname, setname))
1571                         break;
1572                 if (!rp)
1573                     break;
1574             }
1575             r->setname = xstrdup(setname);
1576             yaz_log(log_details, "%p ZOOM_connection_send_search: allocating "
1577                     "set %s", c, r->setname);
1578         }
1579         else
1580         {
1581             yaz_log(log_details, "%p ZOOM_connection_send_search: using "
1582                     "default set", c);
1583             r->setname = xstrdup("default");
1584         }
1585         ZOOM_options_set(r->options, "setname", r->setname);
1586     }
1587     search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
1588     return send_APDU(c, apdu);
1589 }
1590
1591 static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
1592 {
1593     int oclass;
1594     char *addinfo = 0;
1595
1596     switch (r->which)
1597     {
1598     case Z_DefaultDiagFormat_v2Addinfo:
1599         addinfo = r->u.v2Addinfo;
1600         break;
1601     case Z_DefaultDiagFormat_v3Addinfo:
1602         addinfo = r->u.v3Addinfo;
1603         break;
1604     }
1605     xfree(c->addinfo);
1606     c->addinfo = 0;
1607     set_dset_error(c, *r->condition,
1608                    yaz_z3950oid_to_str(r->diagnosticSetId, &oclass),
1609                    addinfo, 0);
1610 }
1611
1612 static void response_diag(ZOOM_connection c, Z_DiagRec *p)
1613 {
1614     if (p->which != Z_DiagRec_defaultFormat)
1615         set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
1616     else
1617         response_default_diag(c, p->u.defaultFormat);
1618 }
1619
1620 ZOOM_API(ZOOM_record)
1621     ZOOM_record_clone(ZOOM_record srec)
1622 {
1623     char *buf;
1624     int size;
1625     ODR odr_enc;
1626     ZOOM_record nrec;
1627
1628     odr_enc = odr_createmem(ODR_ENCODE);
1629     if (!z_NamePlusRecord(odr_enc, &srec->npr, 0, 0))
1630         return 0;
1631     buf = odr_getbuf(odr_enc, &size, 0);
1632
1633     nrec = (ZOOM_record) xmalloc(sizeof(*nrec));
1634     nrec->odr = odr_createmem(ODR_DECODE);
1635     nrec->wrbuf_marc = 0;
1636     nrec->wrbuf_iconv = 0;
1637     nrec->wrbuf_opac = 0;
1638     odr_setbuf(nrec->odr, buf, size, 0);
1639     z_NamePlusRecord(nrec->odr, &nrec->npr, 0, 0);
1640
1641     odr_destroy(odr_enc);
1642     return nrec;
1643 }
1644
1645 ZOOM_API(ZOOM_record)
1646     ZOOM_resultset_record_immediate(ZOOM_resultset s,size_t pos)
1647 {
1648     const char *syntax =
1649         ZOOM_options_get(s->options, "preferredRecordSyntax");
1650     const char *elementSetName =
1651         ZOOM_options_get(s->options, "elementSetName");
1652
1653     return record_cache_lookup(s, pos, syntax, elementSetName);
1654 }
1655
1656 ZOOM_API(ZOOM_record)
1657     ZOOM_resultset_record(ZOOM_resultset r, size_t pos)
1658 {
1659     ZOOM_record rec = ZOOM_resultset_record_immediate(r, pos);
1660
1661     if (!rec)
1662     {
1663         /*
1664          * MIKE: I think force_sync should always be zero, but I don't
1665          * want to make this change until I get the go-ahead from
1666          * Adam, in case something depends on the old synchronous
1667          * behaviour.
1668          */
1669         int force_sync = 1;
1670         if (getenv("ZOOM_RECORD_NO_FORCE_SYNC")) force_sync = 0;
1671         ZOOM_resultset_retrieve(r, force_sync, pos, 1);
1672         rec = ZOOM_resultset_record_immediate(r, pos);
1673     }
1674     return rec;
1675 }
1676
1677 ZOOM_API(void)
1678     ZOOM_record_destroy(ZOOM_record rec)
1679 {
1680     if (!rec)
1681         return;
1682     if (rec->wrbuf_marc)
1683         wrbuf_free(rec->wrbuf_marc, 1);
1684     if (rec->wrbuf_iconv)
1685         wrbuf_free(rec->wrbuf_iconv, 1);
1686     if (rec->wrbuf_opac)
1687         wrbuf_free(rec->wrbuf_opac, 1);
1688     odr_destroy(rec->odr);
1689     xfree(rec);
1690 }
1691
1692 static const char *marc_iconv_return(ZOOM_record rec, int marc_type,
1693                                      int *len,
1694                                      const char *buf, int sz,
1695                                      const char *record_charset)
1696 {
1697     char to[40];
1698     char from[40];
1699     yaz_iconv_t cd = 0;
1700     yaz_marc_t mt = yaz_marc_create();
1701
1702     *from = '\0';
1703     strcpy(to, "UTF-8");
1704     if (record_charset && *record_charset)
1705     {
1706         /* Use "from,to" or just "from" */
1707         const char *cp = strchr(record_charset, ',');
1708         int clen = strlen(record_charset);
1709         if (cp && cp[1])
1710         {
1711             strncpy( to, cp+1, sizeof(to)-1);
1712             to[sizeof(to)-1] = '\0';
1713             clen = cp - record_charset;
1714         }
1715         if (clen > sizeof(from)-1)
1716             clen = sizeof(from)-1;
1717
1718         if (clen)
1719             strncpy(from, record_charset, clen);
1720         from[clen] = '\0';
1721     }
1722
1723     if (*from && *to)
1724     {
1725         cd = yaz_iconv_open(to, from);
1726         yaz_marc_iconv(mt, cd);
1727     }
1728
1729     yaz_marc_xml(mt, marc_type);
1730     if (!rec->wrbuf_marc)
1731         rec->wrbuf_marc = wrbuf_alloc();
1732     wrbuf_rewind(rec->wrbuf_marc);
1733     if (yaz_marc_decode_wrbuf(mt, buf, sz, rec->wrbuf_marc) > 0)
1734     {
1735         yaz_marc_destroy(mt);
1736         if (cd)
1737             yaz_iconv_close(cd);
1738         if (len)
1739             *len = wrbuf_len(rec->wrbuf_marc);
1740         return wrbuf_buf(rec->wrbuf_marc);
1741     }
1742     yaz_marc_destroy(mt);
1743     if (cd)
1744         yaz_iconv_close(cd);
1745     return 0;
1746 }
1747
1748 static const char *record_iconv_return(ZOOM_record rec, int *len,
1749                                        const char *buf, int sz,
1750                                        const char *record_charset)
1751 {
1752     char to[40];
1753     char from[40];
1754     yaz_iconv_t cd = 0;
1755
1756     *from = '\0';
1757     strcpy(to, "UTF-8");
1758     if (record_charset && *record_charset)
1759     {
1760         /* Use "from,to" or just "from" */
1761         const char *cp = strchr(record_charset, ',');
1762         int clen = strlen(record_charset);
1763         if (cp && cp[1])
1764         {
1765             strncpy( to, cp+1, sizeof(to)-1);
1766             to[sizeof(to)-1] = '\0';
1767             clen = cp - record_charset;
1768         }
1769         if (clen > sizeof(from)-1)
1770             clen = sizeof(from)-1;
1771
1772         if (clen)
1773             strncpy(from, record_charset, clen);
1774         from[clen] = '\0';
1775     }
1776
1777     if (*from && *to && (cd = yaz_iconv_open(to, from)))
1778     {
1779         char outbuf[12];
1780         size_t inbytesleft = sz;
1781         const char *inp = buf;
1782
1783         if (!rec->wrbuf_iconv)
1784             rec->wrbuf_iconv = wrbuf_alloc();
1785
1786         wrbuf_rewind(rec->wrbuf_iconv);
1787
1788         while (inbytesleft)
1789         {
1790             size_t outbytesleft = sizeof(outbuf);
1791             char *outp = outbuf;
1792             size_t r = yaz_iconv(cd, (char**) &inp,
1793                                  &inbytesleft,
1794                                  &outp, &outbytesleft);
1795             if (r == (size_t) (-1))
1796             {
1797                 int e = yaz_iconv_error(cd);
1798                 if (e != YAZ_ICONV_E2BIG)
1799                     break;
1800             }
1801             wrbuf_write(rec->wrbuf_iconv, outbuf, outp - outbuf);
1802         }
1803         wrbuf_puts(rec->wrbuf_iconv, "");
1804         buf = wrbuf_buf(rec->wrbuf_iconv);
1805         sz = wrbuf_len(rec->wrbuf_iconv);
1806         yaz_iconv_close(cd);
1807     }
1808     if (len)
1809         *len = sz;
1810     return buf;
1811 }
1812
1813 ZOOM_API(int)
1814     ZOOM_record_error(ZOOM_record rec, const char **cp,
1815                       const char **addinfo, const char **diagset)
1816 {
1817     Z_NamePlusRecord *npr;
1818
1819     if (!rec)
1820         return 0;
1821     npr = rec->npr;
1822     if (npr && npr->which == Z_NamePlusRecord_surrogateDiagnostic)
1823     {
1824         Z_DiagRec *diag_rec = npr->u.surrogateDiagnostic;
1825         int error = YAZ_BIB1_UNSPECIFIED_ERROR;
1826         const char *add = 0;
1827
1828         if (diag_rec->which == Z_DiagRec_defaultFormat)
1829         {
1830             Z_DefaultDiagFormat *ddf = diag_rec->u.defaultFormat;
1831             int oclass;
1832
1833             error = *ddf->condition;
1834             switch (ddf->which)
1835             {
1836             case Z_DefaultDiagFormat_v2Addinfo:
1837                 add = ddf->u.v2Addinfo;
1838                 break;
1839             case Z_DefaultDiagFormat_v3Addinfo:
1840                 add = ddf->u.v3Addinfo;
1841                 break;
1842             }
1843             if (diagset)
1844                 *diagset = yaz_z3950oid_to_str(ddf->diagnosticSetId, &oclass);
1845         }
1846         else
1847         {
1848             if (diagset)
1849                 *diagset = "Bib-1";
1850         }
1851         if (addinfo)
1852             *addinfo = add ? add : "";
1853         if (cp)
1854             *cp = diagbib1_str(error);
1855         return error;
1856     }
1857     return 0;
1858 }
1859
1860 ZOOM_API(const char *)
1861     ZOOM_record_get(ZOOM_record rec, const char *type_spec, int *len)
1862 {
1863     char type[40];
1864     char charset[40];
1865     char xpath[512];
1866     const char *cp;
1867     int i;
1868     Z_NamePlusRecord *npr;
1869
1870     if (len)
1871         *len = 0; /* default return */
1872
1873     if (!rec)
1874         return 0;
1875     npr = rec->npr;
1876     if (!npr)
1877         return 0;
1878
1879     cp = type_spec;
1880     for (i = 0; cp[i] && i < sizeof(type)-1; i++)
1881     {
1882         if (cp[i] == ';' || cp[i] == ' ')
1883             break;
1884         type[i] = cp[i];
1885     }
1886     type[i] = '\0';
1887     charset[0] = '\0';
1888     while (type_spec[i] == ';')
1889     {
1890         i++;
1891         while (type_spec[i] == ' ')
1892             i++;
1893         if (!strncmp(type_spec+i, "charset=", 8))
1894         {
1895             int j = 0;
1896             i = i + 8; /* skip charset= */
1897             for (j = 0; type_spec[i]  && j < sizeof(charset)-1; i++, j++)
1898             {
1899                 if (type_spec[i] == ';' || type_spec[i] == ' ')
1900                     break;
1901                 charset[j] = cp[i];
1902             }
1903             charset[j] = '\0';
1904         }
1905         else if (!strncmp(type_spec+i, "xpath=", 6))
1906         {
1907             int j = 0;
1908             i = i + 6;
1909             for (j = 0; type_spec[i] && j < sizeof(xpath)-1; i++, j++)
1910                 xpath[j] = cp[i];
1911             xpath[j] = '\0';
1912         }
1913         while (type_spec[i] == ' ')
1914             i++;
1915     }
1916     if (!strcmp(type, "database"))
1917     {
1918         if (len)
1919             *len = (npr->databaseName ? strlen(npr->databaseName) : 0);
1920         return npr->databaseName;
1921     }
1922     else if (!strcmp(type, "syntax"))
1923     {
1924         const char *desc = 0;
1925         if (npr->which == Z_NamePlusRecord_databaseRecord)
1926         {
1927             Z_External *r = (Z_External *) npr->u.databaseRecord;
1928             oident *ent = oid_getentbyoid(r->direct_reference);
1929             if (ent)
1930                 desc = ent->desc;
1931         }
1932         if (!desc)
1933             desc = "none";
1934         if (len)
1935             *len = strlen(desc);
1936         return desc;
1937     }
1938     if (npr->which != Z_NamePlusRecord_databaseRecord)
1939         return 0;
1940
1941     /* from now on - we have a database record .. */
1942     if (!strcmp(type, "render"))
1943     {
1944         Z_External *r = (Z_External *) npr->u.databaseRecord;
1945         oident *ent = oid_getentbyoid(r->direct_reference);
1946
1947         /* render bibliographic record .. */
1948         if (r->which == Z_External_OPAC)
1949         {
1950             r = r->u.opac->bibliographicRecord;
1951             if (!r)
1952                 return 0;
1953             ent = oid_getentbyoid(r->direct_reference);
1954         }
1955         if (r->which == Z_External_sutrs)
1956             return record_iconv_return(rec, len,
1957                                        (char*) r->u.sutrs->buf,
1958                                        r->u.sutrs->len,
1959                                        charset);
1960         else if (r->which == Z_External_octet)
1961         {
1962             const char *ret_buf;
1963             switch (ent->value)
1964             {
1965             case VAL_SOIF:
1966             case VAL_HTML:
1967             case VAL_SUTRS:
1968                 break;
1969             case VAL_TEXT_XML:
1970             case VAL_APPLICATION_XML:
1971                 break;
1972             default:
1973                 ret_buf = marc_iconv_return(
1974                     rec, YAZ_MARC_LINE, len,
1975                     (const char *) r->u.octet_aligned->buf,
1976                     r->u.octet_aligned->len,
1977                     charset);
1978                 if (ret_buf)
1979                     return ret_buf;
1980             }
1981             return record_iconv_return(rec, len,
1982                                        (const char *) r->u.octet_aligned->buf,
1983                                        r->u.octet_aligned->len,
1984                                        charset);
1985         }
1986         else if (r->which == Z_External_grs1)
1987         {
1988             if (!rec->wrbuf_marc)
1989                 rec->wrbuf_marc = wrbuf_alloc();
1990             wrbuf_rewind(rec->wrbuf_marc);
1991             yaz_display_grs1(rec->wrbuf_marc, r->u.grs1, 0);
1992             return record_iconv_return(rec, len,
1993                                        wrbuf_buf(rec->wrbuf_marc),
1994                                        wrbuf_len(rec->wrbuf_marc),
1995                                        charset);
1996         }
1997         return 0;
1998     }
1999     else if (!strcmp(type, "xml"))
2000     {
2001         Z_External *r = (Z_External *) npr->u.databaseRecord;
2002         oident *ent = oid_getentbyoid(r->direct_reference);
2003
2004         /* render bibliographic record .. */
2005         if (r->which == Z_External_OPAC)
2006         {
2007             r = r->u.opac->bibliographicRecord;
2008             if (!r)
2009                 return 0;
2010             ent = oid_getentbyoid(r->direct_reference);
2011         }
2012
2013         if (r->which == Z_External_sutrs)
2014             return record_iconv_return(rec, len,
2015                                        (const char *) r->u.sutrs->buf,
2016                                        r->u.sutrs->len,
2017                                        charset);
2018         else if (r->which == Z_External_octet)
2019         {
2020             const char *ret_buf;
2021             int marc_decode_type = YAZ_MARC_MARCXML;
2022
2023             switch (ent->value)
2024             {
2025             case VAL_SOIF:
2026             case VAL_HTML:
2027             case VAL_SUTRS:
2028                 break;
2029             case VAL_TEXT_XML:
2030             case VAL_APPLICATION_XML:
2031                 break;
2032             default:
2033                 ret_buf = marc_iconv_return(
2034                     rec, marc_decode_type, len,
2035                     (const char *) r->u.octet_aligned->buf,
2036                     r->u.octet_aligned->len,
2037                     charset);
2038                 if (ret_buf)
2039                     return ret_buf;
2040             }
2041             return record_iconv_return(rec, len,
2042                                        (const char *) r->u.octet_aligned->buf,
2043                                        r->u.octet_aligned->len,
2044                                        charset);
2045         }
2046         else if (r->which == Z_External_grs1)
2047         {
2048             if (len) *len = 5;
2049             return "GRS-1";
2050         }
2051         return 0;
2052     }
2053     else if (!strcmp(type, "raw"))
2054     {
2055         Z_External *r = (Z_External *) npr->u.databaseRecord;
2056
2057         if (r->which == Z_External_sutrs)
2058         {
2059             if (len) *len = r->u.sutrs->len;
2060             return (const char *) r->u.sutrs->buf;
2061         }
2062         else if (r->which == Z_External_octet)
2063         {
2064             if (len) *len = r->u.octet_aligned->len;
2065             return (const char *) r->u.octet_aligned->buf;
2066         }
2067         else /* grs-1, explain, OPAC, ... */
2068         {
2069             if (len) *len = -1;
2070             return (const char *) npr->u.databaseRecord;
2071         }
2072         return 0;
2073     }
2074     else if (!strcmp (type, "ext"))
2075     {
2076         if (len) *len = -1;
2077         return (const char *) npr->u.databaseRecord;
2078     }
2079     else if (!strcmp (type, "opac"))
2080
2081     {
2082         Z_External *r = (Z_External *) npr->u.databaseRecord;
2083         if (r->which == Z_External_OPAC)
2084         {
2085             if (!rec->wrbuf_opac)
2086                 rec->wrbuf_opac = wrbuf_alloc();
2087             wrbuf_rewind(rec->wrbuf_opac);
2088             yaz_display_OPAC(rec->wrbuf_opac, r->u.opac, 0);
2089             return record_iconv_return(rec, len,
2090                                        wrbuf_buf(rec->wrbuf_opac),
2091                                        wrbuf_len(rec->wrbuf_opac),
2092                                        charset);
2093         }
2094     }
2095     return 0;
2096 }
2097
2098 static int strcmp_null(const char *v1, const char *v2)
2099 {
2100     if (!v1 && !v2)
2101         return 0;
2102     if (!v1 || !v2)
2103         return -1;
2104     return strcmp(v1, v2);
2105 }
2106
2107 static size_t record_hash(int pos)
2108 {
2109     if (pos < 0)
2110         pos = 0;
2111     return pos % RECORD_HASH_SIZE;
2112 }
2113
2114 static void record_cache_add(ZOOM_resultset r, Z_NamePlusRecord *npr,
2115                              int pos,
2116                              const char *syntax, const char *elementSetName)
2117 {
2118     ZOOM_record_cache rc;
2119
2120     ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
2121     ZOOM_connection_put_event(r->connection, event);
2122
2123     for (rc = r->record_hash[record_hash(pos)]; rc; rc = rc->next)
2124     {
2125         if (pos == rc->pos)
2126         {
2127             if (strcmp_null(r->schema, rc->schema))
2128                 continue;
2129             if (strcmp_null(elementSetName,rc->elementSetName))
2130                 continue;
2131             if (strcmp_null(syntax, rc->syntax))
2132                 continue;
2133             /* not destroying rc->npr (it's handled by nmem )*/
2134             rc->rec.npr = npr;
2135             /* keeping wrbuf_marc too */
2136             return;
2137         }
2138     }
2139     rc = (ZOOM_record_cache) odr_malloc(r->odr, sizeof(*rc));
2140     rc->rec.npr = npr;
2141     rc->rec.odr = 0;
2142     rc->rec.wrbuf_marc = 0;
2143     rc->rec.wrbuf_iconv = 0;
2144     rc->rec.wrbuf_opac = 0;
2145     if (elementSetName)
2146         rc->elementSetName = odr_strdup(r->odr, elementSetName);
2147     else
2148         rc->elementSetName = 0;
2149
2150     if (syntax)
2151         rc->syntax = odr_strdup(r->odr, syntax);
2152     else
2153         rc->syntax = 0;
2154
2155     if (r->schema)
2156         rc->schema = odr_strdup(r->odr, r->schema);
2157     else
2158         rc->schema = 0;
2159
2160     rc->pos = pos;
2161     rc->next = r->record_hash[record_hash(pos)];
2162     r->record_hash[record_hash(pos)] = rc;
2163 }
2164
2165 static ZOOM_record record_cache_lookup(ZOOM_resultset r, int pos,
2166                                        const char *syntax,
2167                                        const char *elementSetName)
2168 {
2169     ZOOM_record_cache rc;
2170
2171     for (rc = r->record_hash[record_hash(pos)]; rc; rc = rc->next)
2172     {
2173         if (pos == rc->pos)
2174         {
2175             if (strcmp_null(r->schema, rc->schema))
2176                 continue;
2177             if (strcmp_null(elementSetName,rc->elementSetName))
2178                 continue;
2179             if (strcmp_null(syntax, rc->syntax))
2180                 continue;
2181             return &rc->rec;
2182         }
2183     }
2184     return 0;
2185 }
2186
2187 static void handle_records(ZOOM_connection c, Z_Records *sr,
2188                            int present_phase)
2189 {
2190     ZOOM_resultset resultset;
2191     int *start, *count;
2192     const char *syntax = 0, *elementSetName = 0;
2193
2194     if (!c->tasks)
2195         return ;
2196     switch (c->tasks->which)
2197     {
2198     case ZOOM_TASK_SEARCH:
2199         resultset = c->tasks->u.search.resultset;
2200         start = &c->tasks->u.search.start;
2201         count = &c->tasks->u.search.count;
2202         syntax = c->tasks->u.search.syntax;
2203         elementSetName = c->tasks->u.search.elementSetName;
2204         break;
2205     case ZOOM_TASK_RETRIEVE:
2206         resultset = c->tasks->u.retrieve.resultset;
2207         start = &c->tasks->u.retrieve.start;
2208         count = &c->tasks->u.retrieve.count;
2209         syntax = c->tasks->u.retrieve.syntax;
2210         elementSetName = c->tasks->u.retrieve.elementSetName;
2211         break;
2212     default:
2213         return;
2214     }
2215     if (sr && sr->which == Z_Records_NSD)
2216         response_default_diag(c, sr->u.nonSurrogateDiagnostic);
2217     else if (sr && sr->which == Z_Records_multipleNSD)
2218     {
2219         if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
2220             response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
2221         else
2222             set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
2223     }
2224     else
2225     {
2226         if (*count + *start > resultset->size)
2227             *count = resultset->size - *start;
2228         if (*count < 0)
2229             *count = 0;
2230         if (sr && sr->which == Z_Records_DBOSD)
2231         {
2232             int i;
2233             NMEM nmem = odr_extract_mem(c->odr_in);
2234             Z_NamePlusRecordList *p =
2235                 sr->u.databaseOrSurDiagnostics;
2236             for (i = 0; i<p->num_records; i++)
2237             {
2238                 record_cache_add(resultset, p->records[i], i + *start,
2239                                  syntax, elementSetName);
2240             }
2241             *count -= i;
2242             if (*count < 0)
2243                 *count = 0;
2244             *start += i;
2245             yaz_log(log_details,
2246                     "handle_records resultset=%p start=%d count=%d",
2247                     resultset, *start, *count);
2248
2249             /* transfer our response to search_nmem .. we need it later */
2250             nmem_transfer(resultset->odr->mem, nmem);
2251             nmem_destroy(nmem);
2252             if (present_phase && p->num_records == 0)
2253             {
2254                 /* present response and we didn't get any records! */
2255                 Z_NamePlusRecord *myrec =
2256                     zget_surrogateDiagRec(resultset->odr, 0, 14, 0);
2257                 record_cache_add(resultset, myrec, *start,
2258                                  syntax, elementSetName);
2259             }
2260         }
2261         else if (present_phase)
2262         {
2263             /* present response and we didn't get any records! */
2264             Z_NamePlusRecord *myrec =
2265                 zget_surrogateDiagRec(resultset->odr, 0, 14, 0);
2266             record_cache_add(resultset, myrec, *start, syntax, elementSetName);
2267         }
2268     }
2269 }
2270
2271 static void handle_present_response(ZOOM_connection c, Z_PresentResponse *pr)
2272 {
2273     handle_records(c, pr->records, 1);
2274 }
2275
2276 static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
2277                                        Z_Term *term)
2278 {
2279     switch (term->which)
2280     {
2281     case Z_Term_general:
2282         ZOOM_options_setl(opt, name,
2283                           (const char *)(term->u.general->buf),
2284                           term->u.general->len);
2285         break;
2286     case Z_Term_characterString:
2287         ZOOM_options_set(opt, name, term->u.characterString);
2288         break;
2289     case Z_Term_numeric:
2290         ZOOM_options_set_int(opt, name, *term->u.numeric);
2291         break;
2292     }
2293 }
2294
2295 static void handle_queryExpression(ZOOM_options opt, const char *name,
2296                                    Z_QueryExpression *exp)
2297 {
2298     char opt_name[80];
2299
2300     switch (exp->which)
2301     {
2302     case Z_QueryExpression_term:
2303         if (exp->u.term && exp->u.term->queryTerm)
2304         {
2305             sprintf(opt_name, "%s.term", name);
2306             handle_queryExpressionTerm(opt, opt_name, exp->u.term->queryTerm);
2307         }
2308         break;
2309     case Z_QueryExpression_query:
2310         break;
2311     }
2312 }
2313
2314 static void handle_searchResult(ZOOM_connection c, ZOOM_resultset resultset,
2315                                 Z_OtherInformation *o)
2316 {
2317     int i;
2318     for (i = 0; o && i < o->num_elements; i++)
2319     {
2320         if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
2321         {
2322             Z_External *ext = o->list[i]->information.externallyDefinedInfo;
2323
2324             if (ext->which == Z_External_searchResult1)
2325             {
2326                 int j;
2327                 Z_SearchInfoReport *sr = ext->u.searchResult1;
2328
2329                 if (sr->num)
2330                     ZOOM_options_set_int(
2331                         resultset->options, "searchresult.size", sr->num);
2332
2333                 for (j = 0; j < sr->num; j++)
2334                 {
2335                     Z_SearchInfoReport_s *ent =
2336                         ext->u.searchResult1->elements[j];
2337                     char pref[80];
2338
2339                     sprintf(pref, "searchresult.%d", j);
2340
2341                     if (ent->subqueryId)
2342                     {
2343                         char opt_name[80];
2344                         sprintf(opt_name, "%s.id", pref);
2345                         ZOOM_options_set(resultset->options, opt_name,
2346                                          ent->subqueryId);
2347                     }
2348                     if (ent->subqueryExpression)
2349                     {
2350                         char opt_name[80];
2351                         sprintf(opt_name, "%s.subquery", pref);
2352                         handle_queryExpression(resultset->options, opt_name,
2353                                                ent->subqueryExpression);
2354                     }
2355                     if (ent->subqueryInterpretation)
2356                     {
2357                         char opt_name[80];
2358                         sprintf(opt_name, "%s.interpretation", pref);
2359                         handle_queryExpression(resultset->options, opt_name,
2360                                                ent->subqueryInterpretation);
2361                     }
2362                     if (ent->subqueryRecommendation)
2363                     {
2364                         char opt_name[80];
2365                         sprintf(opt_name, "%s.recommendation", pref);
2366                         handle_queryExpression(resultset->options, opt_name,
2367                                                ent->subqueryRecommendation);
2368                     }
2369                     if (ent->subqueryCount)
2370                     {
2371                         char opt_name[80];
2372                         sprintf(opt_name, "%s.count", pref);
2373                         ZOOM_options_set_int(resultset->options, opt_name,
2374                                              *ent->subqueryCount);
2375                     }
2376                 }
2377             }
2378         }
2379     }
2380 }
2381
2382 static void handle_search_response(ZOOM_connection c, Z_SearchResponse *sr)
2383 {
2384     ZOOM_resultset resultset;
2385     ZOOM_Event event;
2386
2387     if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
2388         return ;
2389
2390     event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
2391     ZOOM_connection_put_event(c, event);
2392
2393     resultset = c->tasks->u.search.resultset;
2394
2395     handle_searchResult(c, resultset, sr->additionalSearchInfo);
2396
2397     resultset->size = *sr->resultCount;
2398     handle_records(c, sr->records, 0);
2399 }
2400
2401 static void sort_response(ZOOM_connection c, Z_SortResponse *res)
2402 {
2403     if (res->diagnostics && res->num_diagnostics > 0)
2404         response_diag(c, res->diagnostics[0]);
2405 }
2406
2407 static int scan_response(ZOOM_connection c, Z_ScanResponse *res)
2408 {
2409     NMEM nmem = odr_extract_mem(c->odr_in);
2410     ZOOM_scanset scan;
2411
2412     if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
2413         return 0;
2414     scan = c->tasks->u.scan.scan;
2415
2416     if (res->entries && res->entries->nonsurrogateDiagnostics)
2417         response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
2418     scan->scan_response = res;
2419     nmem_transfer(scan->odr->mem, nmem);
2420     if (res->stepSize)
2421         ZOOM_options_set_int(scan->options, "stepSize", *res->stepSize);
2422     if (res->positionOfTerm)
2423         ZOOM_options_set_int(scan->options, "position", *res->positionOfTerm);
2424     if (res->scanStatus)
2425         ZOOM_options_set_int(scan->options, "scanStatus", *res->scanStatus);
2426     if (res->numberOfEntriesReturned)
2427         ZOOM_options_set_int(scan->options, "number",
2428                              *res->numberOfEntriesReturned);
2429     nmem_destroy(nmem);
2430     return 1;
2431 }
2432
2433 static zoom_ret send_sort(ZOOM_connection c,
2434                           ZOOM_resultset resultset)
2435 {
2436     if (c->error)
2437         resultset->r_sort_spec = 0;
2438     if (resultset->r_sort_spec)
2439     {
2440         Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
2441         Z_SortRequest *req = apdu->u.sortRequest;
2442
2443         req->num_inputResultSetNames = 1;
2444         req->inputResultSetNames = (Z_InternationalString **)
2445             odr_malloc(c->odr_out, sizeof(*req->inputResultSetNames));
2446         req->inputResultSetNames[0] =
2447             odr_strdup(c->odr_out, resultset->setname);
2448         req->sortedResultSetName = odr_strdup(c->odr_out, resultset->setname);
2449         req->sortSequence = resultset->r_sort_spec;
2450         resultset->r_sort_spec = 0;
2451         return send_APDU(c, apdu);
2452     }
2453     return zoom_complete;
2454 }
2455
2456 static zoom_ret send_present(ZOOM_connection c)
2457 {
2458     Z_APDU *apdu = 0;
2459     Z_PresentRequest *req = 0;
2460     int i = 0;
2461     const char *syntax = 0;
2462     const char *elementSetName = 0;
2463     ZOOM_resultset  resultset;
2464     int *start, *count;
2465
2466     if (!c->tasks)
2467     {
2468         yaz_log(log_details, "%p send_present no tasks", c);
2469         return zoom_complete;
2470     }
2471
2472     switch (c->tasks->which)
2473     {
2474     case ZOOM_TASK_SEARCH:
2475         resultset = c->tasks->u.search.resultset;
2476         start = &c->tasks->u.search.start;
2477         count = &c->tasks->u.search.count;
2478         syntax = c->tasks->u.search.syntax;
2479         elementSetName = c->tasks->u.search.elementSetName;
2480         break;
2481     case ZOOM_TASK_RETRIEVE:
2482         resultset = c->tasks->u.retrieve.resultset;
2483         start = &c->tasks->u.retrieve.start;
2484         count = &c->tasks->u.retrieve.count;
2485         syntax = c->tasks->u.retrieve.syntax;
2486         elementSetName = c->tasks->u.retrieve.elementSetName;
2487         break;
2488     default:
2489         return zoom_complete;
2490     }
2491     yaz_log(log_details, "%p send_present start=%d count=%d",
2492             c, *start, *count);
2493
2494     if (*start < 0 || *count < 0 || *start + *count > resultset->size)
2495     {
2496         set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
2497                        "", 0);
2498     }
2499     if (c->error)                  /* don't continue on error */
2500         return zoom_complete;
2501     yaz_log(log_details, "send_present resultset=%p start=%d count=%d",
2502             resultset, *start, *count);
2503
2504     for (i = 0; i < *count; i++)
2505     {
2506         ZOOM_record rec =
2507             record_cache_lookup(resultset, i + *start, syntax, elementSetName);
2508         if (!rec)
2509             break;
2510         else
2511         {
2512             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
2513             ZOOM_connection_put_event(c, event);
2514         }
2515     }
2516     *start += i;
2517     *count -= i;
2518
2519     if (*count == 0)
2520     {
2521         yaz_log(log_details, "%p send_present skip=%d no more to fetch", c, i);
2522         return zoom_complete;
2523     }
2524
2525     apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
2526     req = apdu->u.presentRequest;
2527
2528     if (i)
2529         yaz_log(log_details, "%p send_present skip=%d", c, i);
2530
2531     *req->resultSetStartPoint = *start + 1;
2532     *req->numberOfRecordsRequested = resultset->step>0 ?
2533         resultset->step : *count;
2534     if (*req->numberOfRecordsRequested + *start > resultset->size)
2535         *req->numberOfRecordsRequested = resultset->size - *start;
2536     assert(*req->numberOfRecordsRequested > 0);
2537
2538     if (syntax && *syntax)
2539         req->preferredRecordSyntax =
2540             yaz_str_to_z3950oid(c->odr_out, CLASS_RECSYN, syntax);
2541
2542     if (resultset->schema && *resultset->schema)
2543     {
2544         Z_RecordComposition *compo = (Z_RecordComposition *)
2545             odr_malloc(c->odr_out, sizeof(*compo));
2546
2547         req->recordComposition = compo;
2548         compo->which = Z_RecordComp_complex;
2549         compo->u.complex = (Z_CompSpec *)
2550             odr_malloc(c->odr_out, sizeof(*compo->u.complex));
2551         compo->u.complex->selectAlternativeSyntax = (bool_t *)
2552             odr_malloc(c->odr_out, sizeof(bool_t));
2553         *compo->u.complex->selectAlternativeSyntax = 0;
2554
2555         compo->u.complex->generic = (Z_Specification *)
2556             odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));
2557
2558         compo->u.complex->generic->which = Z_Schema_oid;
2559         compo->u.complex->generic->schema.oid = (Odr_oid *)
2560             yaz_str_to_z3950oid (c->odr_out, CLASS_SCHEMA, resultset->schema);
2561
2562         if (!compo->u.complex->generic->schema.oid)
2563         {
2564             /* OID wasn't a schema! Try record syntax instead. */
2565
2566             compo->u.complex->generic->schema.oid = (Odr_oid *)
2567                 yaz_str_to_z3950oid (c->odr_out, CLASS_RECSYN, resultset->schema);
2568         }
2569         if (elementSetName && *elementSetName)
2570         {
2571             compo->u.complex->generic->elementSpec = (Z_ElementSpec *)
2572                 odr_malloc(c->odr_out, sizeof(Z_ElementSpec));
2573             compo->u.complex->generic->elementSpec->which =
2574                 Z_ElementSpec_elementSetName;
2575             compo->u.complex->generic->elementSpec->u.elementSetName =
2576                 odr_strdup(c->odr_out, elementSetName);
2577         }
2578         else
2579             compo->u.complex->generic->elementSpec = 0;
2580         compo->u.complex->num_dbSpecific = 0;
2581         compo->u.complex->dbSpecific = 0;
2582         compo->u.complex->num_recordSyntax = 0;
2583         compo->u.complex->recordSyntax = 0;
2584     }
2585     else if (elementSetName && *elementSetName)
2586     {
2587         Z_ElementSetNames *esn = (Z_ElementSetNames *)
2588             odr_malloc(c->odr_out, sizeof(*esn));
2589         Z_RecordComposition *compo = (Z_RecordComposition *)
2590             odr_malloc(c->odr_out, sizeof(*compo));
2591
2592         esn->which = Z_ElementSetNames_generic;
2593         esn->u.generic = odr_strdup(c->odr_out, elementSetName);
2594         compo->which = Z_RecordComp_simple;
2595         compo->u.simple = esn;
2596         req->recordComposition = compo;
2597     }
2598     req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
2599     return send_APDU(c, apdu);
2600 }
2601
2602 ZOOM_API(ZOOM_scanset)
2603     ZOOM_connection_scan(ZOOM_connection c, const char *start)
2604 {
2605     ZOOM_scanset s;
2606     ZOOM_query q = ZOOM_query_create();
2607
2608     ZOOM_query_prefix(q, start);
2609
2610     s = ZOOM_connection_scan1(c, q);
2611     ZOOM_query_destroy(q);
2612     return s;
2613
2614 }
2615
2616 ZOOM_API(ZOOM_scanset)
2617     ZOOM_connection_scan1(ZOOM_connection c, ZOOM_query q)
2618 {
2619     char *start;
2620     char *freeme = 0;
2621     ZOOM_scanset scan = 0;
2622
2623     /*
2624      * We need to check the query-type, so we can recognise CQL and
2625      * CCL and compile them into a form that we can use here.  The
2626      * ZOOM_query structure has no explicit `type' member, but
2627      * inspection of the ZOOM_query_prefix() and ZOOM_query_cql()
2628      * functions shows how the structure is set up in each case.
2629      */
2630     if (!q->z_query)
2631         return 0;
2632     else if (q->z_query->which == Z_Query_type_1)
2633     {
2634         yaz_log(log_api, "%p ZOOM_connection_scan1 q=%p PQF '%s'",
2635                 c, q, q->query_string);
2636         start = q->query_string;
2637     }
2638     else if (q->z_query->which == Z_Query_type_104)
2639     {
2640         yaz_log(log_api, "%p ZOOM_connection_scan1 q=%p CQL '%s'",
2641                 c, q, q->query_string);
2642         start = freeme = cql2pqf(c, q->query_string);
2643         if (start == 0)
2644             return 0;
2645     }
2646     else
2647     {
2648         yaz_log(YLOG_FATAL, "%p ZOOM_connection_scan1 q=%p unknown type '%s'",
2649                 c, q, q->query_string);
2650         abort();
2651     }
2652
2653     scan = (ZOOM_scanset) xmalloc(sizeof(*scan));
2654     scan->connection = c;
2655     scan->odr = odr_createmem(ODR_DECODE);
2656     scan->options = ZOOM_options_create_with_parent(c->options);
2657     scan->refcount = 1;
2658     scan->scan_response = 0;
2659     scan->termListAndStartPoint =
2660         p_query_scan(scan->odr, PROTO_Z3950, &scan->attributeSet, start);
2661     xfree(freeme);
2662
2663     scan->databaseNames = set_DatabaseNames(c, c->options,
2664                                             &scan->num_databaseNames,
2665                                             scan->odr);
2666     if (scan->termListAndStartPoint != 0)
2667     {
2668         ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_SCAN);
2669         task->u.scan.scan = scan;
2670
2671         (scan->refcount)++;
2672         if (!c->async)
2673         {
2674             while (ZOOM_event(1, &c))
2675                 ;
2676         }
2677     }
2678     return scan;
2679 }
2680
2681 ZOOM_API(void)
2682     ZOOM_scanset_destroy(ZOOM_scanset scan)
2683 {
2684     if (!scan)
2685         return;
2686     (scan->refcount)--;
2687     if (scan->refcount == 0)
2688     {
2689         odr_destroy(scan->odr);
2690
2691         ZOOM_options_destroy(scan->options);
2692         xfree(scan);
2693     }
2694 }
2695
2696 static zoom_ret send_package(ZOOM_connection c)
2697 {
2698     ZOOM_Event event;
2699
2700     yaz_log(log_details, "%p send_package", c);
2701     if (!c->tasks)
2702         return zoom_complete;
2703     assert (c->tasks->which == ZOOM_TASK_PACKAGE);
2704
2705     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
2706     ZOOM_connection_put_event(c, event);
2707
2708     c->buf_out = c->tasks->u.package->buf_out;
2709     c->len_out = c->tasks->u.package->len_out;
2710
2711     return do_write(c);
2712 }
2713
2714 static zoom_ret send_scan(ZOOM_connection c)
2715 {
2716     ZOOM_scanset scan;
2717     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
2718     Z_ScanRequest *req = apdu->u.scanRequest;
2719
2720     yaz_log(log_details, "%p send_scan", c);
2721     if (!c->tasks)
2722         return zoom_complete;
2723     assert (c->tasks->which == ZOOM_TASK_SCAN);
2724     scan = c->tasks->u.scan.scan;
2725
2726     req->termListAndStartPoint = scan->termListAndStartPoint;
2727     req->attributeSet = scan->attributeSet;
2728
2729     *req->numberOfTermsRequested =
2730         ZOOM_options_get_int(scan->options, "number", 10);
2731
2732     req->preferredPositionInResponse =
2733         odr_intdup(c->odr_out,
2734                    ZOOM_options_get_int(scan->options, "position", 1));
2735
2736     req->stepSize =
2737         odr_intdup(c->odr_out,
2738                    ZOOM_options_get_int(scan->options, "stepSize", 0));
2739
2740     req->databaseNames = scan->databaseNames;
2741     req->num_databaseNames = scan->num_databaseNames;
2742
2743     return send_APDU(c, apdu);
2744 }
2745
2746 ZOOM_API(size_t)
2747     ZOOM_scanset_size(ZOOM_scanset scan)
2748 {
2749     if (!scan || !scan->scan_response || !scan->scan_response->entries)
2750         return 0;
2751     return scan->scan_response->entries->num_entries;
2752 }
2753
2754 ZOOM_API(const char *)
2755     ZOOM_scanset_term(ZOOM_scanset scan, size_t pos,
2756                       int *occ, int *len)
2757 {
2758     const char *term = 0;
2759     size_t noent = ZOOM_scanset_size(scan);
2760     Z_ScanResponse *res = scan->scan_response;
2761
2762     *len = 0;
2763     *occ = 0;
2764     if (pos >= noent)
2765         return 0;
2766     if (res->entries->entries[pos]->which == Z_Entry_termInfo)
2767     {
2768         Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
2769
2770         if (t->term->which == Z_Term_general)
2771         {
2772             term = (const char *) t->term->u.general->buf;
2773             *len = t->term->u.general->len;
2774         }
2775         *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
2776     }
2777     return term;
2778 }
2779
2780 ZOOM_API(const char *)
2781     ZOOM_scanset_display_term(ZOOM_scanset scan, size_t pos,
2782                               int *occ, int *len)
2783 {
2784     const char *term = 0;
2785     size_t noent = ZOOM_scanset_size(scan);
2786     Z_ScanResponse *res = scan->scan_response;
2787
2788     *len = 0;
2789     *occ = 0;
2790     if (pos >= noent)
2791         return 0;
2792     if (res->entries->entries[pos]->which == Z_Entry_termInfo)
2793     {
2794         Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
2795
2796         if (t->displayTerm)
2797         {
2798             term = t->displayTerm;
2799             *len = strlen(term);
2800         }
2801         else if (t->term->which == Z_Term_general)
2802         {
2803             term = (const char *) t->term->u.general->buf;
2804             *len = t->term->u.general->len;
2805         }
2806         *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
2807     }
2808     return term;
2809 }
2810
2811 ZOOM_API(const char *)
2812     ZOOM_scanset_option_get(ZOOM_scanset scan, const char *key)
2813 {
2814     return ZOOM_options_get(scan->options, key);
2815 }
2816
2817 ZOOM_API(void)
2818     ZOOM_scanset_option_set(ZOOM_scanset scan, const char *key,
2819                             const char *val)
2820 {
2821     ZOOM_options_set(scan->options, key, val);
2822 }
2823
2824 static Z_APDU *create_es_package(ZOOM_package p, int type)
2825 {
2826     const char *str;
2827     Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
2828     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
2829
2830     *req->function = Z_ExtendedServicesRequest_create;
2831
2832     str = ZOOM_options_get(p->options, "package-name");
2833     if (str && *str)
2834         req->packageName = nmem_strdup(p->odr_out->mem, str);
2835
2836     str = ZOOM_options_get(p->options, "user-id");
2837     if (str)
2838         req->userId = nmem_strdup(p->odr_out->mem, str);
2839
2840     req->packageType = yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
2841                                               type);
2842
2843     str = ZOOM_options_get(p->options, "function");
2844     if (str)
2845     {
2846         if (!strcmp (str, "create"))
2847             *req->function = 1;
2848         if (!strcmp (str, "delete"))
2849             *req->function = 2;
2850         if (!strcmp (str, "modify"))
2851             *req->function = 3;
2852     }
2853     return apdu;
2854 }
2855
2856 static const char *ill_array_lookup(void *clientData, const char *idx)
2857 {
2858     ZOOM_package p = (ZOOM_package) clientData;
2859     return ZOOM_options_get(p->options, idx+4);
2860 }
2861
2862 static Z_External *encode_ill_request(ZOOM_package p)
2863 {
2864     ODR out = p->odr_out;
2865     ILL_Request *req;
2866     Z_External *r = 0;
2867     struct ill_get_ctl ctl;
2868
2869     ctl.odr = p->odr_out;
2870     ctl.clientData = p;
2871     ctl.f = ill_array_lookup;
2872
2873     req = ill_get_ILLRequest(&ctl, "ill", 0);
2874
2875     if (!ill_Request(out, &req, 0, 0))
2876     {
2877         int ill_request_size;
2878         char *ill_request_buf = odr_getbuf(out, &ill_request_size, 0);
2879         if (ill_request_buf)
2880             odr_setbuf(out, ill_request_buf, ill_request_size, 1);
2881         return 0;
2882     }
2883     else
2884     {
2885         oident oid;
2886         int illRequest_size = 0;
2887         char *illRequest_buf = odr_getbuf(out, &illRequest_size, 0);
2888
2889         oid.proto = PROTO_GENERAL;
2890         oid.oclass = CLASS_GENERAL;
2891         oid.value = VAL_ISO_ILL_1;
2892
2893         r = (Z_External *) odr_malloc(out, sizeof(*r));
2894         r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid));
2895         r->indirect_reference = 0;
2896         r->descriptor = 0;
2897         r->which = Z_External_single;
2898
2899         r->u.single_ASN1_type =
2900             odr_create_Odr_oct(out,
2901                                (unsigned char *)illRequest_buf,
2902                                illRequest_size);
2903     }
2904     return r;
2905 }
2906
2907 static Z_ItemOrder *encode_item_order(ZOOM_package p)
2908 {
2909     Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc(p->odr_out, sizeof(*req));
2910     const char *str;
2911
2912     req->which = Z_IOItemOrder_esRequest;
2913     req->u.esRequest = (Z_IORequest *)
2914         odr_malloc(p->odr_out,sizeof(Z_IORequest));
2915
2916     /* to keep part ... */
2917     req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
2918         odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
2919     req->u.esRequest->toKeep->supplDescription = 0;
2920     req->u.esRequest->toKeep->contact = (Z_IOContact *)
2921         odr_malloc(p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
2922
2923     str = ZOOM_options_get(p->options, "contact-name");
2924     req->u.esRequest->toKeep->contact->name = str ?
2925         nmem_strdup(p->odr_out->mem, str) : 0;
2926
2927     str = ZOOM_options_get(p->options, "contact-phone");
2928     req->u.esRequest->toKeep->contact->phone = str ?
2929         nmem_strdup(p->odr_out->mem, str) : 0;
2930
2931     str = ZOOM_options_get(p->options, "contact-email");
2932     req->u.esRequest->toKeep->contact->email = str ?
2933         nmem_strdup(p->odr_out->mem, str) : 0;
2934
2935     req->u.esRequest->toKeep->addlBilling = 0;
2936
2937     /* not to keep part ... */
2938     req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
2939         odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
2940
2941     str = ZOOM_options_get(p->options, "itemorder-setname");
2942     if (!str)
2943         str = "default";
2944
2945     if (!*str)
2946         req->u.esRequest->notToKeep->resultSetItem = 0;
2947     else
2948     {
2949         req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
2950             odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
2951
2952         req->u.esRequest->notToKeep->resultSetItem->resultSetId =
2953             nmem_strdup(p->odr_out->mem, str);
2954         req->u.esRequest->notToKeep->resultSetItem->item =
2955             (int *) odr_malloc(p->odr_out, sizeof(int));
2956
2957         str = ZOOM_options_get(p->options, "itemorder-item");
2958         *req->u.esRequest->notToKeep->resultSetItem->item =
2959             (str ? atoi(str) : 1);
2960     }
2961     req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
2962
2963     return req;
2964 }
2965
2966 Z_APDU *create_admin_package(ZOOM_package p, int type,
2967                              Z_ESAdminOriginPartToKeep **toKeepP,
2968                              Z_ESAdminOriginPartNotToKeep **notToKeepP)
2969 {
2970     Z_APDU *apdu = create_es_package(p, VAL_ADMINSERVICE);
2971     if (apdu)
2972     {
2973         Z_ESAdminOriginPartToKeep  *toKeep;
2974         Z_ESAdminOriginPartNotToKeep  *notToKeep;
2975         Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
2976         const char *first_db = "Default";
2977         int num_db;
2978         char **db = set_DatabaseNames(p->connection, p->options, &num_db,
2979                                       p->odr_out);
2980         if (num_db > 0)
2981             first_db = db[0];
2982
2983         r->direct_reference =
2984             yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
2985                                    VAL_ADMINSERVICE);
2986         r->descriptor = 0;
2987         r->indirect_reference = 0;
2988         r->which = Z_External_ESAdmin;
2989
2990         r->u.adminService = (Z_Admin *)
2991             odr_malloc(p->odr_out, sizeof(*r->u.adminService));
2992         r->u.adminService->which = Z_Admin_esRequest;
2993         r->u.adminService->u.esRequest = (Z_AdminEsRequest *)
2994             odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest));
2995
2996         toKeep = r->u.adminService->u.esRequest->toKeep =
2997             (Z_ESAdminOriginPartToKeep *)
2998             odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest->toKeep));
2999         toKeep->which = type;
3000         toKeep->databaseName = odr_strdup(p->odr_out, first_db);
3001         toKeep->u.create = odr_nullval();
3002         apdu->u.extendedServicesRequest->taskSpecificParameters = r;
3003
3004         r->u.adminService->u.esRequest->notToKeep = notToKeep =
3005             (Z_ESAdminOriginPartNotToKeep *)
3006             odr_malloc(p->odr_out,
3007                        sizeof(*r->u.adminService->u.esRequest->notToKeep));
3008         notToKeep->which = Z_ESAdminOriginPartNotToKeep_recordsWillFollow;
3009         notToKeep->u.recordsWillFollow = odr_nullval();
3010         if (toKeepP)
3011             *toKeepP = toKeep;
3012         if (notToKeepP)
3013             *notToKeepP = notToKeep;
3014     }
3015     return apdu;
3016 }
3017
3018 static Z_APDU *create_xmlupdate_package(ZOOM_package p)
3019 {
3020     Z_APDU *apdu = create_es_package(p, VAL_XMLES);
3021     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
3022     Z_External *ext = (Z_External *) odr_malloc(p->odr_out, sizeof(*ext));
3023     const char *doc = ZOOM_options_get(p->options, "doc");
3024
3025     if (!doc)
3026         doc = "";
3027
3028     req->taskSpecificParameters = ext;
3029     ext->direct_reference = req->packageType;
3030     ext->descriptor = 0;
3031     ext->indirect_reference = 0;
3032
3033     ext->which = Z_External_octet;
3034     ext->u.single_ASN1_type =
3035         odr_create_Odr_oct(p->odr_out, (const unsigned char *) doc,
3036                            strlen(doc));
3037     return apdu;
3038 }
3039
3040 static Z_APDU *create_update_package(ZOOM_package p)
3041 {
3042     Z_APDU *apdu = 0;
3043     const char *first_db = "Default";
3044     int num_db;
3045     char **db = set_DatabaseNames(p->connection, p->options, &num_db, p->odr_out);
3046     const char *action = ZOOM_options_get(p->options, "action");
3047     const char *recordIdOpaque = ZOOM_options_get(p->options, "recordIdOpaque");
3048     const char *recordIdNumber = ZOOM_options_get(p->options, "recordIdNumber");
3049     const char *record_buf = ZOOM_options_get(p->options, "record");
3050     const char *syntax_str = ZOOM_options_get(p->options, "syntax");
3051     int syntax_oid = VAL_NONE;
3052     int action_no = -1;
3053
3054     if (syntax_str)
3055         syntax_oid = oid_getvalbyname(syntax_str);
3056     if (!record_buf)
3057     {
3058         record_buf = "void";
3059         syntax_oid = VAL_SUTRS;
3060     }
3061     if (syntax_oid == VAL_NONE)
3062         syntax_oid = VAL_TEXT_XML;
3063
3064     if (num_db > 0)
3065         first_db = db[0];
3066
3067     if (!action)
3068         action = "specialUpdate";
3069
3070     if (!strcmp(action, "recordInsert"))
3071         action_no = Z_IUOriginPartToKeep_recordInsert;
3072     else if (!strcmp(action, "recordReplace"))
3073         action_no = Z_IUOriginPartToKeep_recordReplace;
3074     else if (!strcmp(action, "recordDelete"))
3075         action_no = Z_IUOriginPartToKeep_recordDelete;
3076     else if (!strcmp(action, "elementUpdate"))
3077         action_no = Z_IUOriginPartToKeep_elementUpdate;
3078     else if (!strcmp(action, "specialUpdate"))
3079         action_no = Z_IUOriginPartToKeep_specialUpdate;
3080     else
3081         return 0;
3082
3083     apdu = create_es_package(p, VAL_DBUPDATE);
3084     if (apdu)
3085     {
3086         Z_IUOriginPartToKeep *toKeep;
3087         Z_IUSuppliedRecords *notToKeep;
3088         Z_External *r = (Z_External *)
3089             odr_malloc(p->odr_out, sizeof(*r));
3090
3091         apdu->u.extendedServicesRequest->taskSpecificParameters = r;
3092
3093         r->direct_reference =
3094             yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
3095                                    VAL_DBUPDATE);
3096         r->descriptor = 0;
3097         r->which = Z_External_update;
3098         r->indirect_reference = 0;
3099         r->u.update = (Z_IUUpdate *)
3100             odr_malloc(p->odr_out, sizeof(*r->u.update));
3101
3102         r->u.update->which = Z_IUUpdate_esRequest;
3103         r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
3104             odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
3105         toKeep = r->u.update->u.esRequest->toKeep =
3106             (Z_IUOriginPartToKeep *)
3107             odr_malloc(p->odr_out, sizeof(*toKeep));
3108
3109         toKeep->databaseName = odr_strdup(p->odr_out, first_db);
3110         toKeep->schema = 0;
3111         toKeep->elementSetName = 0;
3112         toKeep->actionQualifier = 0;
3113         toKeep->action = odr_intdup(p->odr_out, action_no);
3114
3115         notToKeep = r->u.update->u.esRequest->notToKeep =
3116             (Z_IUSuppliedRecords *)
3117             odr_malloc(p->odr_out, sizeof(*notToKeep));
3118         notToKeep->num = 1;
3119         notToKeep->elements = (Z_IUSuppliedRecords_elem **)
3120             odr_malloc(p->odr_out, sizeof(*notToKeep->elements));
3121         notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
3122             odr_malloc(p->odr_out, sizeof(**notToKeep->elements));
3123         notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
3124         if (recordIdOpaque)
3125         {
3126             notToKeep->elements[0]->u.opaque =
3127                 odr_create_Odr_oct(p->odr_out,
3128                                    (const unsigned char *) recordIdOpaque,
3129                                    strlen(recordIdOpaque));
3130         }
3131         else if (recordIdNumber)
3132         {
3133             notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;
3134
3135             notToKeep->elements[0]->u.number =
3136                 odr_intdup(p->odr_out, atoi(recordIdNumber));
3137         }
3138         else
3139             notToKeep->elements[0]->u.opaque = 0;
3140         notToKeep->elements[0]->supplementalId = 0;
3141         notToKeep->elements[0]->correlationInfo = 0;
3142         notToKeep->elements[0]->record =
3143             z_ext_record(p->odr_out, syntax_oid,
3144                          record_buf, strlen(record_buf));
3145     }
3146     if (0 && apdu)
3147     {
3148         ODR print = odr_createmem(ODR_PRINT);
3149
3150         z_APDU(print, &apdu, 0, 0);
3151         odr_destroy(print);
3152     }
3153     return apdu;
3154 }
3155
3156 ZOOM_API(void)
3157     ZOOM_package_send(ZOOM_package p, const char *type)
3158 {
3159     Z_APDU *apdu = 0;
3160     ZOOM_connection c;
3161     if (!p)
3162         return;
3163     c = p->connection;
3164     odr_reset(p->odr_out);
3165     xfree(p->buf_out);
3166     p->buf_out = 0;
3167     if (!strcmp(type, "itemorder"))
3168     {
3169         apdu = create_es_package(p, VAL_ITEMORDER);
3170         if (apdu)
3171         {
3172             Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
3173
3174             r->direct_reference =
3175                 yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
3176                                        VAL_ITEMORDER);
3177             r->descriptor = 0;
3178             r->which = Z_External_itemOrder;
3179             r->indirect_reference = 0;
3180             r->u.itemOrder = encode_item_order(p);
3181
3182             apdu->u.extendedServicesRequest->taskSpecificParameters = r;
3183         }
3184     }
3185     else if (!strcmp(type, "create"))  /* create database */
3186     {
3187         apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_create,
3188                                     0, 0);
3189     }
3190     else if (!strcmp(type, "drop"))  /* drop database */
3191     {
3192         apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_drop,
3193                                     0, 0);
3194     }
3195     else if (!strcmp(type, "commit"))  /* commit changes */
3196     {
3197         apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_commit,
3198                                     0, 0);
3199     }
3200     else if (!strcmp(type, "update")) /* update record(s) */
3201     {
3202         apdu = create_update_package(p);
3203     }
3204     else if (!strcmp(type, "xmlupdate"))
3205     {
3206         apdu = create_xmlupdate_package(p);
3207     }
3208     if (apdu)
3209     {
3210         if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
3211         {
3212             char *buf;
3213
3214             ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_PACKAGE);
3215             task->u.package = p;
3216             buf = odr_getbuf(p->odr_out, &p->len_out, 0);
3217             p->buf_out = (char *) xmalloc(p->len_out);
3218             memcpy(p->buf_out, buf, p->len_out);
3219
3220             (p->refcount)++;
3221             if (!c->async)
3222             {
3223                 while (ZOOM_event(1, &c))
3224                     ;
3225             }
3226         }
3227     }
3228 }
3229
3230 ZOOM_API(ZOOM_package)
3231     ZOOM_connection_package(ZOOM_connection c, ZOOM_options options)
3232 {
3233     ZOOM_package p = (ZOOM_package) xmalloc(sizeof(*p));
3234
3235     p->connection = c;
3236     p->odr_out = odr_createmem(ODR_ENCODE);
3237     p->options = ZOOM_options_create_with_parent2(options, c->options);
3238     p->refcount = 1;
3239     p->buf_out = 0;
3240     p->len_out = 0;
3241     return p;
3242 }
3243
3244 ZOOM_API(void)
3245     ZOOM_package_destroy(ZOOM_package p)
3246 {
3247     if (!p)
3248         return;
3249     (p->refcount)--;
3250     if (p->refcount == 0)
3251     {
3252         odr_destroy(p->odr_out);
3253         xfree(p->buf_out);
3254
3255         ZOOM_options_destroy(p->options);
3256         xfree(p);
3257     }
3258 }
3259
3260 ZOOM_API(const char *)
3261     ZOOM_package_option_get(ZOOM_package p, const char *key)
3262 {
3263     return ZOOM_options_get(p->options, key);
3264 }
3265
3266
3267 ZOOM_API(void)
3268     ZOOM_package_option_set(ZOOM_package p, const char *key,
3269                             const char *val)
3270 {
3271     ZOOM_options_set(p->options, key, val);
3272 }
3273
3274 static int ZOOM_connection_exec_task(ZOOM_connection c)
3275 {
3276     ZOOM_task task = c->tasks;
3277     zoom_ret ret = zoom_complete;
3278
3279     if (!task)
3280         return 0;
3281     yaz_log(log_details, "%p ZOOM_connection_exec_task type=%d run=%d",
3282             c, task->which, task->running);
3283     if (c->error != ZOOM_ERROR_NONE)
3284     {
3285         yaz_log(log_details, "%p ZOOM_connection_exec_task "
3286                 "removing tasks because of error = %d", c, c->error);
3287         ZOOM_connection_remove_tasks(c);
3288         return 0;
3289     }
3290     if (task->running)
3291     {
3292         yaz_log(log_details, "%p ZOOM_connection_exec_task "
3293                 "task already running", c);
3294         return 0;
3295     }
3296     task->running = 1;
3297     ret = zoom_complete;
3298     if (c->cs || task->which == ZOOM_TASK_CONNECT)
3299     {
3300         switch (task->which)
3301         {
3302         case ZOOM_TASK_SEARCH:
3303             if (c->proto == PROTO_HTTP)
3304                 ret = ZOOM_connection_srw_send_search(c);
3305             else
3306                 ret = ZOOM_connection_send_search(c);
3307             break;
3308         case ZOOM_TASK_RETRIEVE:
3309             if (c->proto == PROTO_HTTP)
3310                 ret = ZOOM_connection_srw_send_search(c);
3311             else
3312                 ret = send_present(c);
3313             break;
3314         case ZOOM_TASK_CONNECT:
3315             ret = do_connect(c);
3316             break;
3317         case ZOOM_TASK_SCAN:
3318             ret = send_scan(c);
3319             break;
3320         case ZOOM_TASK_PACKAGE:
3321             ret = send_package(c);
3322             break;
3323         case ZOOM_TASK_SORT:
3324             c->tasks->u.sort.resultset->r_sort_spec =
3325                 c->tasks->u.sort.q->sort_spec;
3326             ret = send_sort(c, c->tasks->u.sort.resultset);
3327             break;
3328         }
3329     }
3330     else
3331     {
3332         yaz_log(log_details, "%p ZOOM_connection_exec_task "
3333                 "remove tasks because no connection exist", c);
3334         ZOOM_connection_remove_tasks(c);
3335     }
3336     if (ret == zoom_complete)
3337     {
3338         yaz_log(log_details, "%p ZOOM_connection_exec_task "
3339                 "task removed (complete)", c);
3340         ZOOM_connection_remove_task(c);
3341         return 0;
3342     }
3343     yaz_log(log_details, "%p ZOOM_connection_exec_task "
3344             "task pending", c);
3345     return 1;
3346 }
3347
3348 static zoom_ret send_sort_present(ZOOM_connection c)
3349 {
3350     zoom_ret r = zoom_complete;
3351
3352     if (c->tasks && c->tasks->which == ZOOM_TASK_SEARCH)
3353         r = send_sort(c, c->tasks->u.search.resultset);
3354     if (r == zoom_complete)
3355         r = send_present(c);
3356     return r;
3357 }
3358
3359 static int es_response(ZOOM_connection c,
3360                        Z_ExtendedServicesResponse *res)
3361 {
3362     if (!c->tasks || c->tasks->which != ZOOM_TASK_PACKAGE)
3363         return 0;
3364     if (res->diagnostics && res->num_diagnostics > 0)
3365         response_diag(c, res->diagnostics[0]);
3366     if (res->taskPackage &&
3367         res->taskPackage->which == Z_External_extendedService)
3368     {
3369         Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
3370         Odr_oct *id = taskPackage->targetReference;
3371
3372         if (id)
3373             ZOOM_options_setl(c->tasks->u.package->options,
3374                               "targetReference", (char*) id->buf, id->len);
3375     }
3376     if (res->taskPackage &&
3377         res->taskPackage->which == Z_External_octet)
3378     {
3379         Odr_oct *doc = res->taskPackage->u.octet_aligned;
3380         ZOOM_options_setl(c->tasks->u.package->options,
3381                           "xmlUpdateDoc", (char*) doc->buf, doc->len);
3382     }
3383     return 1;
3384 }
3385
3386 static void interpret_init_diag(ZOOM_connection c,
3387                                 Z_DiagnosticFormat *diag)
3388 {
3389     if (diag->num > 0)
3390     {
3391         Z_DiagnosticFormat_s *ds = diag->elements[0];
3392         if (ds->which == Z_DiagnosticFormat_s_defaultDiagRec)
3393             response_default_diag(c, ds->u.defaultDiagRec);
3394     }
3395 }
3396
3397
3398 static void interpret_otherinformation_field(ZOOM_connection c,
3399                                              Z_OtherInformation *ui)
3400 {
3401     int i;
3402     for (i = 0; i < ui->num_elements; i++)
3403     {
3404         Z_OtherInformationUnit *unit = ui->list[i];
3405         if (unit->which == Z_OtherInfo_externallyDefinedInfo &&
3406             unit->information.externallyDefinedInfo &&
3407             unit->information.externallyDefinedInfo->which ==
3408             Z_External_diag1)
3409         {
3410             interpret_init_diag(c, unit->information.externallyDefinedInfo->u.diag1);
3411         }
3412     }
3413 }
3414
3415
3416 static void set_init_option(const char *name, void *clientData) {
3417     ZOOM_connection c = clientData;
3418     char buf[80];
3419
3420     sprintf(buf, "init_opt_%.70s", name);
3421     ZOOM_connection_option_set(c, buf, "1");
3422 }
3423
3424
3425 static void recv_apdu(ZOOM_connection c, Z_APDU *apdu)
3426 {
3427     Z_InitResponse *initrs;
3428
3429     ZOOM_connection_set_mask(c, 0);
3430     yaz_log(log_details, "%p recv_apdu apdu->which=%d", c, apdu->which);
3431     switch(apdu->which)
3432     {
3433     case Z_APDU_initResponse:
3434         yaz_log(log_api, "%p recv_apd: Received Init response", c);
3435         initrs = apdu->u.initResponse;
3436         ZOOM_connection_option_set(c, "serverImplementationId",
3437                                    initrs->implementationId ?
3438                                    initrs->implementationId : "");
3439         ZOOM_connection_option_set(c, "serverImplementationName",
3440                                    initrs->implementationName ?
3441                                    initrs->implementationName : "");
3442         ZOOM_connection_option_set(c, "serverImplementationVersion",
3443                                    initrs->implementationVersion ?
3444                                    initrs->implementationVersion : "");
3445         /* Set the three old options too, for old applications */
3446         ZOOM_connection_option_set(c, "targetImplementationId",
3447                                    initrs->implementationId ?
3448                                    initrs->implementationId : "");
3449         ZOOM_connection_option_set(c, "targetImplementationName",
3450                                    initrs->implementationName ?
3451                                    initrs->implementationName : "");
3452         ZOOM_connection_option_set(c, "targetImplementationVersion",
3453                                    initrs->implementationVersion ?
3454                                    initrs->implementationVersion : "");
3455
3456         /* Make initrs->options available as ZOOM-level options */
3457         yaz_init_opt_decode(initrs->options, set_init_option, (void*) c);
3458
3459         if (!*initrs->result)
3460         {
3461             Z_External *uif = initrs->userInformationField;
3462
3463             set_ZOOM_error(c, ZOOM_ERROR_INIT, 0); /* default error */
3464
3465             if (uif && uif->which == Z_External_userInfo1)
3466                 interpret_otherinformation_field(c, uif->u.userInfo1);
3467         }
3468         else
3469         {
3470             char *cookie =
3471                 yaz_oi_get_string_oidval(&apdu->u.initResponse->otherInfo,
3472                                          VAL_COOKIE, 1, 0);
3473             xfree(c->cookie_in);
3474             c->cookie_in = 0;
3475             if (cookie)
3476                 c->cookie_in = xstrdup(cookie);
3477             if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
3478                 ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
3479                 c->support_named_resultsets = 1;
3480             if (c->tasks)
3481             {
3482                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
3483                 ZOOM_connection_remove_task(c);
3484             }
3485             ZOOM_connection_exec_task(c);
3486         }
3487         if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
3488         {
3489             NMEM tmpmem = nmem_create();
3490             Z_CharSetandLanguageNegotiation *p =
3491                 yaz_get_charneg_record(initrs->otherInfo);
3492
3493             if (p)
3494             {
3495                 char *charset = NULL, *lang = NULL;
3496                 int sel;
3497
3498                 yaz_get_response_charneg(tmpmem, p, &charset, &lang, &sel);
3499                 yaz_log(log_details, "%p recv_apdu target accepted: "
3500                         "charset %s, language %s, select %d",
3501                         c,
3502                         charset ? charset : "none", lang ? lang : "none", sel);
3503                 if (charset)
3504                     ZOOM_connection_option_set(c, "negotiation-charset",
3505                                                charset);
3506                 if (lang)
3507                     ZOOM_connection_option_set(c, "negotiation-lang",
3508                                                lang);
3509
3510                 ZOOM_connection_option_set(
3511                     c,  "negotiation-charset-in-effect-for-records",
3512                     (sel != 0) ? "1" : "0");
3513                 nmem_destroy(tmpmem);
3514             }
3515         }
3516         break;
3517     case Z_APDU_searchResponse:
3518         yaz_log(log_api, "%p recv_apdu Search response", c);
3519         handle_search_response(c, apdu->u.searchResponse);
3520         if (send_sort_present(c) == zoom_complete)
3521             ZOOM_connection_remove_task(c);
3522         break;
3523     case Z_APDU_presentResponse:
3524         yaz_log(log_api, "%p recv_apdu Present response", c);
3525         handle_present_response(c, apdu->u.presentResponse);
3526         if (send_present(c) == zoom_complete)
3527             ZOOM_connection_remove_task(c);
3528         break;
3529     case Z_APDU_sortResponse:
3530         yaz_log(log_api, "%p recv_apdu Sort response", c);
3531         sort_response(c, apdu->u.sortResponse);
3532         if (send_present(c) == zoom_complete)
3533             ZOOM_connection_remove_task(c);
3534         break;
3535     case Z_APDU_scanResponse:
3536         yaz_log(log_api, "%p recv_apdu Scan response", c);
3537         scan_response(c, apdu->u.scanResponse);
3538         ZOOM_connection_remove_task(c);
3539         break;
3540     case Z_APDU_extendedServicesResponse:
3541         yaz_log(log_api, "%p recv_apdu Extended Services response", c);
3542         es_response(c, apdu->u.extendedServicesResponse);
3543         ZOOM_connection_remove_task(c);
3544         break;
3545     case Z_APDU_close:
3546         yaz_log(log_api, "%p recv_apdu Close PDU", c);
3547         if (!ZOOM_test_reconnect(c))
3548         {
3549             set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
3550             do_close(c);
3551         }
3552         break;
3553     default:
3554         yaz_log(log_api, "%p Received unknown PDU", c);
3555         set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
3556         do_close(c);
3557     }
3558 }
3559
3560 #if YAZ_HAVE_XML2
3561 static void handle_srw_response(ZOOM_connection c,
3562                                 Z_SRW_searchRetrieveResponse *res)
3563 {
3564     ZOOM_resultset resultset = 0;
3565     int i;
3566     NMEM nmem;
3567     ZOOM_Event event;
3568     int *start;
3569     const char *syntax, *elementSetName;
3570
3571     if (!c->tasks)
3572         return;
3573
3574     switch(c->tasks->which)
3575     {
3576     case ZOOM_TASK_SEARCH:
3577         resultset = c->tasks->u.search.resultset;
3578         start = &c->tasks->u.search.start;
3579         syntax = c->tasks->u.search.syntax;
3580         elementSetName = c->tasks->u.search.elementSetName;
3581         break;
3582     case ZOOM_TASK_RETRIEVE:
3583         resultset = c->tasks->u.retrieve.resultset;
3584         start = &c->tasks->u.retrieve.start;
3585         syntax = c->tasks->u.retrieve.syntax;
3586         elementSetName = c->tasks->u.retrieve.elementSetName;
3587         break;
3588     default:
3589         return;
3590     }
3591     event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
3592     ZOOM_connection_put_event(c, event);
3593
3594     resultset->size = 0;
3595
3596     yaz_log(log_details, "%p handle_srw_response got SRW response OK", c);
3597
3598     if (res->numberOfRecords)
3599         resultset->size = *res->numberOfRecords;
3600
3601     for (i = 0; i<res->num_records; i++)
3602     {
3603         int pos;
3604
3605         Z_NamePlusRecord *npr = (Z_NamePlusRecord *)
3606             odr_malloc(c->odr_in, sizeof(Z_NamePlusRecord));
3607
3608         if (res->records[i].recordPosition &&
3609             *res->records[i].recordPosition > 0)
3610             pos = *res->records[i].recordPosition - 1;
3611         else
3612             pos = *start + i;
3613
3614         npr->databaseName = 0;
3615         npr->which = Z_NamePlusRecord_databaseRecord;
3616         npr->u.databaseRecord = (Z_External *)
3617             odr_malloc(c->odr_in, sizeof(Z_External));
3618         npr->u.databaseRecord->descriptor = 0;
3619         npr->u.databaseRecord->direct_reference =
3620             yaz_oidval_to_z3950oid(c->odr_in, CLASS_RECSYN, VAL_TEXT_XML);
3621         npr->u.databaseRecord->which = Z_External_octet;
3622
3623         npr->u.databaseRecord->u.octet_aligned = (Odr_oct *)
3624             odr_malloc(c->odr_in, sizeof(Odr_oct));
3625         npr->u.databaseRecord->u.octet_aligned->buf = (unsigned char*)
3626             res->records[i].recordData_buf;
3627         npr->u.databaseRecord->u.octet_aligned->len =
3628             npr->u.databaseRecord->u.octet_aligned->size =
3629             res->records[i].recordData_len;
3630         record_cache_add(resultset, npr, pos, syntax, elementSetName);
3631     }
3632     if (res->num_diagnostics > 0)
3633     {
3634         const char *uri = res->diagnostics[0].uri;
3635         if (uri)
3636         {
3637             int code = 0;
3638             const char *cp;
3639             if ((cp = strrchr(uri, '/')))
3640                 code = atoi(cp+1);
3641             set_dset_error(c, code, uri,
3642                            res->diagnostics[0].details, 0);
3643         }
3644     }
3645     nmem = odr_extract_mem(c->odr_in);
3646     nmem_transfer(resultset->odr->mem, nmem);
3647     nmem_destroy(nmem);
3648 }
3649 #endif
3650
3651 #if YAZ_HAVE_XML2
3652 static void handle_http(ZOOM_connection c, Z_HTTP_Response *hres)
3653 {
3654     int ret = -1;
3655     const char *content_type = z_HTTP_header_lookup(hres->headers,
3656                                                     "Content-Type");
3657     const char *connection_head = z_HTTP_header_lookup(hres->headers,
3658                                                        "Connection");
3659     ZOOM_connection_set_mask(c, 0);
3660     yaz_log(log_details, "%p handle_http", c);
3661
3662     if (content_type && !yaz_strcmp_del("text/xml", content_type, "; "))
3663     {
3664         Z_SOAP *soap_package = 0;
3665         ODR o = c->odr_in;
3666         Z_SOAP_Handler soap_handlers[2] = {
3667             {YAZ_XMLNS_SRU_v1_1, 0, (Z_SOAP_fun) yaz_srw_codec},
3668             {0, 0, 0}
3669         };
3670         ret = z_soap_codec(o, &soap_package,
3671                            &hres->content_buf, &hres->content_len,
3672                            soap_handlers);
3673         if (!ret && soap_package->which == Z_SOAP_generic &&
3674             soap_package->u.generic->no == 0)
3675         {
3676             Z_SRW_PDU *sr = (Z_SRW_PDU*) soap_package->u.generic->p;
3677             if (sr->which == Z_SRW_searchRetrieve_response)
3678                 handle_srw_response(c, sr->u.response);
3679             else
3680                 ret = -1;
3681         }
3682         else if (!ret && (soap_package->which == Z_SOAP_fault
3683                           || soap_package->which == Z_SOAP_error))
3684         {
3685             set_HTTP_error(c, hres->code,
3686                            soap_package->u.fault->fault_code,
3687                            soap_package->u.fault->fault_string);
3688         }
3689         else
3690             ret = -1;
3691     }
3692     if (ret)
3693     {
3694         if (hres->code != 200)
3695             set_HTTP_error(c, hres->code, 0, 0);
3696         else
3697             set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
3698         do_close(c);
3699     }
3700     ZOOM_connection_remove_task(c);
3701     if (!strcmp(hres->version, "1.0"))
3702     {
3703         /* HTTP 1.0: only if Keep-Alive we stay alive.. */
3704         if (!connection_head || strcmp(connection_head, "Keep-Alive"))
3705             do_close(c);
3706     }
3707     else
3708     {
3709         /* HTTP 1.1: only if no close we stay alive .. */
3710         if (connection_head && !strcmp(connection_head, "close"))
3711             do_close(c);
3712     }
3713 }
3714 #endif
3715
3716 static int do_read(ZOOM_connection c)
3717 {
3718     int r, more;
3719     ZOOM_Event event;
3720
3721     event = ZOOM_Event_create(ZOOM_EVENT_RECV_DATA);
3722     ZOOM_connection_put_event(c, event);
3723
3724     r = cs_get(c->cs, &c->buf_in, &c->len_in);
3725     more = cs_more(c->cs);
3726     yaz_log(log_details, "%p do_read len=%d more=%d", c, r, more);
3727     if (r == 1)
3728         return 0;
3729     if (r <= 0)
3730     {
3731         if (ZOOM_test_reconnect(c))
3732         {
3733             yaz_log(log_details, "%p do_read reconnect read", c);
3734         }
3735         else
3736         {
3737             set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
3738             do_close(c);
3739         }
3740     }
3741     else
3742     {
3743         Z_GDU *gdu;
3744         ZOOM_Event event;
3745
3746         odr_reset(c->odr_in);
3747         odr_setbuf(c->odr_in, c->buf_in, r, 0);
3748         event = ZOOM_Event_create(ZOOM_EVENT_RECV_APDU);
3749         ZOOM_connection_put_event(c, event);
3750
3751         if (!z_GDU(c->odr_in, &gdu, 0, 0))
3752         {
3753             int x;
3754             int err = odr_geterrorx(c->odr_in, &x);
3755             char msg[60];
3756             const char *element = odr_getelement(c->odr_in);
3757             sprintf(msg, "ODR code %d:%d element=%-20s",
3758                     err, x, element ? element : "<unknown>");
3759             set_ZOOM_error(c, ZOOM_ERROR_DECODE, msg);
3760             do_close(c);
3761         }
3762         else if (gdu->which == Z_GDU_Z3950)
3763             recv_apdu(c, gdu->u.z3950);
3764         else if (gdu->which == Z_GDU_HTTP_Response)
3765         {
3766 #if YAZ_HAVE_XML2
3767             handle_http(c, gdu->u.HTTP_Response);
3768 #else
3769             set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
3770             do_close(c);
3771 #endif
3772         }
3773         c->reconnect_ok = 0;
3774     }
3775     return 1;
3776 }
3777
3778 static zoom_ret do_write_ex(ZOOM_connection c, char *buf_out, int len_out)
3779 {
3780     int r;
3781     ZOOM_Event event;
3782
3783     event = ZOOM_Event_create(ZOOM_EVENT_SEND_DATA);
3784     ZOOM_connection_put_event(c, event);
3785
3786     yaz_log(log_details, "%p do_write_ex len=%d", c, len_out);
3787     if ((r = cs_put(c->cs, buf_out, len_out)) < 0)
3788     {
3789         yaz_log(log_details, "%p do_write_ex write failed", c);
3790         if (ZOOM_test_reconnect(c))
3791         {
3792             return zoom_pending;
3793         }
3794         if (c->state == STATE_CONNECTING)
3795             set_ZOOM_error(c, ZOOM_ERROR_CONNECT, c->host_port);
3796         else
3797             set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
3798         do_close(c);
3799         return zoom_complete;
3800     }
3801     else if (r == 1)
3802     {
3803         int mask = ZOOM_SELECT_EXCEPT;
3804         if (c->cs->io_pending & CS_WANT_WRITE)
3805             mask += ZOOM_SELECT_WRITE;
3806         if (c->cs->io_pending & CS_WANT_READ)
3807             mask += ZOOM_SELECT_READ;
3808         ZOOM_connection_set_mask(c, mask);
3809         yaz_log(log_details, "%p do_write_ex write incomplete mask=%d",
3810                 c, c->mask);
3811     }
3812     else
3813     {
3814         ZOOM_connection_set_mask(c, ZOOM_SELECT_READ|ZOOM_SELECT_EXCEPT);
3815         yaz_log(log_details, "%p do_write_ex write complete mask=%d",
3816                 c, c->mask);
3817     }
3818     return zoom_pending;
3819 }
3820
3821 static zoom_ret do_write(ZOOM_connection c)
3822 {
3823     return do_write_ex(c, c->buf_out, c->len_out);
3824 }
3825
3826
3827 ZOOM_API(const char *)
3828     ZOOM_connection_option_get(ZOOM_connection c, const char *key)
3829 {
3830     return ZOOM_options_get(c->options, key);
3831 }
3832
3833 ZOOM_API(const char *)
3834     ZOOM_connection_option_getl(ZOOM_connection c, const char *key, int *lenp)
3835 {
3836     return ZOOM_options_getl(c->options, key, lenp);
3837 }
3838
3839 ZOOM_API(void)
3840     ZOOM_connection_option_set(ZOOM_connection c, const char *key,
3841                                const char *val)
3842 {
3843     ZOOM_options_set(c->options, key, val);
3844 }
3845
3846 ZOOM_API(void)
3847     ZOOM_connection_option_setl(ZOOM_connection c, const char *key,
3848                                 const char *val, int len)
3849 {
3850     ZOOM_options_setl(c->options, key, val, len);
3851 }
3852
3853 ZOOM_API(const char *)
3854     ZOOM_resultset_option_get(ZOOM_resultset r, const char *key)
3855 {
3856     return ZOOM_options_get(r->options, key);
3857 }
3858
3859 ZOOM_API(void)
3860     ZOOM_resultset_option_set(ZOOM_resultset r, const char *key,
3861                               const char *val)
3862 {
3863     ZOOM_options_set(r->options, key, val);
3864 }
3865
3866
3867 ZOOM_API(int)
3868     ZOOM_connection_errcode(ZOOM_connection c)
3869 {
3870     return ZOOM_connection_error(c, 0, 0);
3871 }
3872
3873 ZOOM_API(const char *)
3874     ZOOM_connection_errmsg(ZOOM_connection c)
3875 {
3876     const char *msg;
3877     ZOOM_connection_error(c, &msg, 0);
3878     return msg;
3879 }
3880
3881 ZOOM_API(const char *)
3882     ZOOM_connection_addinfo(ZOOM_connection c)
3883 {
3884     const char *addinfo;
3885     ZOOM_connection_error(c, 0, &addinfo);
3886     return addinfo;
3887 }
3888
3889 ZOOM_API(const char *)
3890     ZOOM_connection_diagset(ZOOM_connection c)
3891 {
3892     const char *diagset;
3893     ZOOM_connection_error_x(c, 0, 0, &diagset);
3894     return diagset;
3895 }
3896
3897 ZOOM_API(const char *)
3898     ZOOM_diag_str(int error)
3899 {
3900     switch (error)
3901     {
3902     case ZOOM_ERROR_NONE:
3903         return "No error";
3904     case ZOOM_ERROR_CONNECT:
3905         return "Connect failed";
3906     case ZOOM_ERROR_MEMORY:
3907         return "Out of memory";
3908     case ZOOM_ERROR_ENCODE:
3909         return "Encoding failed";
3910     case ZOOM_ERROR_DECODE:
3911         return "Decoding failed";
3912     case ZOOM_ERROR_CONNECTION_LOST:
3913         return "Connection lost";
3914     case ZOOM_ERROR_INIT:
3915         return "Init rejected";
3916     case ZOOM_ERROR_INTERNAL:
3917         return "Internal failure";
3918     case ZOOM_ERROR_TIMEOUT:
3919         return "Timeout";
3920     case ZOOM_ERROR_UNSUPPORTED_PROTOCOL:
3921         return "Unsupported protocol";
3922     case ZOOM_ERROR_UNSUPPORTED_QUERY:
3923         return "Unsupported query type";
3924     case ZOOM_ERROR_INVALID_QUERY:
3925         return "Invalid query";
3926     case ZOOM_ERROR_CQL_PARSE:
3927         return "CQL parsing error";
3928     case ZOOM_ERROR_CQL_TRANSFORM:
3929         return "CQL transformation error";
3930     case ZOOM_ERROR_CCL_CONFIG:
3931         return "CCL configuration error";
3932     case ZOOM_ERROR_CCL_PARSE:
3933         return "CCL parsing error";
3934     default:
3935         return diagbib1_str(error);
3936     }
3937 }
3938
3939 ZOOM_API(int)
3940     ZOOM_connection_error_x(ZOOM_connection c, const char **cp,
3941                             const char **addinfo, const char **diagset)
3942 {
3943     int error = c->error;
3944     if (cp)
3945     {
3946         if (!c->diagset || !strcmp(c->diagset, "ZOOM"))
3947             *cp = ZOOM_diag_str(error);
3948         else if (!strcmp(c->diagset, "HTTP"))
3949             *cp = z_HTTP_errmsg(c->error);
3950         else if (!strcmp(c->diagset, "Bib-1"))
3951             *cp = ZOOM_diag_str(error);
3952         else if (!strcmp(c->diagset, "info:srw/diagnostic/1"))
3953             *cp = yaz_diag_srw_str(c->error);
3954         else
3955             *cp = "Unknown error and diagnostic set";
3956     }
3957     if (addinfo)
3958         *addinfo = c->addinfo ? c->addinfo : "";
3959     if (diagset)
3960         *diagset = c->diagset ? c->diagset : "";
3961     return c->error;
3962 }
3963
3964 ZOOM_API(int)
3965     ZOOM_connection_error(ZOOM_connection c, const char **cp,
3966                           const char **addinfo)
3967 {
3968     return ZOOM_connection_error_x(c, cp, addinfo, 0);
3969 }
3970
3971 static void ZOOM_connection_do_io(ZOOM_connection c, int mask)
3972 {
3973     ZOOM_Event event = 0;
3974     int r = cs_look(c->cs);
3975     yaz_log(log_details, "%p ZOOM_connection_do_io mask=%d cs_look=%d",
3976             c, mask, r);
3977
3978     if (r == CS_NONE)
3979     {
3980         event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
3981         set_ZOOM_error(c, ZOOM_ERROR_CONNECT, c->host_port);
3982         do_close(c);
3983         ZOOM_connection_put_event(c, event);
3984     }
3985     else if (r == CS_CONNECT)
3986     {
3987         int ret = ret = cs_rcvconnect(c->cs);
3988         yaz_log(log_details, "%p ZOOM_connection_do_io "
3989                 "cs_rcvconnect returned %d", c, ret);
3990         if (ret == 1)
3991         {
3992             int mask = ZOOM_SELECT_EXCEPT;
3993             if (c->cs->io_pending & CS_WANT_WRITE)
3994                 mask += ZOOM_SELECT_WRITE;
3995             if (c->cs->io_pending & CS_WANT_READ)
3996                 mask += ZOOM_SELECT_READ;
3997             ZOOM_connection_set_mask(c, mask);
3998         }
3999         else if (ret == 0)
4000         {
4001             event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
4002             ZOOM_connection_put_event(c, event);
4003             get_cert(c);
4004             if (c->proto == PROTO_Z3950)
4005                 ZOOM_connection_send_init(c);
4006             else
4007             {
4008                 /* no init request for SRW .. */
4009                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
4010                 ZOOM_connection_remove_task(c);
4011                 ZOOM_connection_set_mask(c, 0);
4012                 ZOOM_connection_exec_task(c);
4013             }
4014             c->state = STATE_ESTABLISHED;
4015         }
4016         else
4017         {
4018             set_ZOOM_error(c, ZOOM_ERROR_CONNECT, c->host_port);
4019             do_close(c);
4020         }
4021     }
4022     else
4023     {
4024         if (mask & ZOOM_SELECT_EXCEPT)
4025         {
4026             if (ZOOM_test_reconnect(c))
4027             {
4028                 event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
4029                 ZOOM_connection_put_event(c, event);
4030             }
4031             else
4032             {
4033                 set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
4034                 do_close(c);
4035             }
4036             return;
4037         }
4038         if (mask & ZOOM_SELECT_READ)
4039             do_read(c);
4040         if (c->cs && (mask & ZOOM_SELECT_WRITE))
4041             do_write(c);
4042     }
4043 }
4044
4045 ZOOM_API(int)
4046     ZOOM_connection_last_event(ZOOM_connection cs)
4047 {
4048     if (!cs)
4049         return ZOOM_EVENT_NONE;
4050     return cs->last_event;
4051 }
4052
4053
4054 /*
4055  * Returns an xmalloc()d string containing RPN that corresponds to the
4056  * CQL passed in.  On error, sets the Connection object's error state
4057  * and returns a null pointer.
4058  * ### We could cache CQL parser and/or transformer in Connection.
4059  */
4060 static char *cql2pqf(ZOOM_connection c, const char *cql)
4061 {
4062     CQL_parser parser;
4063     int error;
4064     struct cql_node *node;
4065     const char *cqlfile;
4066     static cql_transform_t trans;
4067     char pqfbuf[512];
4068
4069     parser = cql_parser_create();
4070     if ((error = cql_parser_string(parser, cql)) != 0) {
4071         cql_parser_destroy(parser);
4072         set_ZOOM_error(c, ZOOM_ERROR_CQL_PARSE, cql);
4073         return 0;
4074     }
4075
4076     node = cql_parser_result(parser);
4077     /* ### Do not call cql_parser_destroy() yet: it destroys `node'! */
4078
4079     cqlfile = ZOOM_connection_option_get(c, "cqlfile");
4080     if (cqlfile == 0) {
4081         cql_parser_destroy(parser);
4082         cql_node_destroy(node);
4083         set_ZOOM_error(c, ZOOM_ERROR_CQL_TRANSFORM, "no CQL transform file");
4084         return 0;
4085     }
4086
4087     if ((trans = cql_transform_open_fname(cqlfile)) == 0) {
4088         char buf[512];
4089         cql_parser_destroy(parser);
4090         cql_node_destroy(node);
4091         sprintf(buf, "can't open CQL transform file '%.200s': %.200s",
4092                 cqlfile, strerror(errno));
4093         set_ZOOM_error(c, ZOOM_ERROR_CQL_TRANSFORM, buf);
4094         return 0;
4095     }
4096
4097     error = cql_transform_buf(trans, node, pqfbuf, sizeof pqfbuf);
4098     cql_parser_destroy(parser);
4099     cql_node_destroy(node);
4100     if (error != 0) {
4101         char buf[512];
4102         const char *addinfo;
4103         error = cql_transform_error(trans, &addinfo);
4104         cql_transform_close(trans);
4105         sprintf(buf, "%.200s (addinfo=%.200s)", cql_strerror(error), addinfo);
4106         set_ZOOM_error(c, ZOOM_ERROR_CQL_TRANSFORM, buf);
4107         return 0;
4108     }
4109
4110     cql_transform_close(trans);
4111     return xstrdup(pqfbuf);
4112 }
4113
4114 ZOOM_API(int) ZOOM_connection_fire_event_timeout(ZOOM_connection c)
4115 {
4116     if (c->mask)
4117     {
4118         ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_TIMEOUT);
4119         /* timeout and this connection was waiting */
4120         set_ZOOM_error(c, ZOOM_ERROR_TIMEOUT, 0);
4121         do_close(c);
4122         ZOOM_connection_put_event(c, event);
4123     }
4124     return 0;
4125 }
4126
4127 ZOOM_API(int)
4128     ZOOM_process_event(int no, ZOOM_connection *cs)
4129 {
4130     int i;
4131
4132     yaz_log(log_details, "ZOOM_event_poll(no=%d,cs=%p)", no, cs);
4133
4134     for (i = 0; i<no; i++)
4135     {
4136         ZOOM_connection c = cs[i];
4137         ZOOM_Event event;
4138
4139 #if 0
4140         if (c)
4141             ZOOM_connection_show_tasks(c);
4142 #endif
4143
4144         if (c && (event = ZOOM_connection_get_event(c)))
4145         {
4146             ZOOM_Event_destroy(event);
4147             return i+1;
4148         }
4149     }
4150     for (i = 0; i<no; i++)
4151     {
4152         ZOOM_connection c = cs[i];
4153         if (c)
4154         {
4155             ZOOM_Event event;
4156             ZOOM_connection_exec_task(c);
4157             if ((event = ZOOM_connection_get_event(c)))
4158             {
4159                 ZOOM_Event_destroy(event);
4160                 return i+1;
4161             }
4162         }
4163     }
4164     return 0;
4165 }
4166
4167 ZOOM_API(int) ZOOM_connection_fire_event_socket(ZOOM_connection c, int mask)
4168 {
4169     if (c->mask && mask)
4170         ZOOM_connection_do_io(c, mask);
4171     return 0;
4172 }
4173
4174 ZOOM_API(int) ZOOM_connection_get_socket(ZOOM_connection c)
4175 {
4176     if (c->cs)
4177         return cs_fileno(c->cs);
4178     return -1;
4179 }
4180
4181 ZOOM_API(int) ZOOM_connection_set_mask(ZOOM_connection c, int mask)
4182 {
4183     c->mask = mask;
4184     if (!c->cs)
4185         return -1;
4186     return 0;
4187 }
4188
4189 ZOOM_API(int) ZOOM_connection_get_mask(ZOOM_connection c)
4190 {
4191     if (c->cs)
4192         return c->mask;
4193     return 0;
4194 }
4195
4196 ZOOM_API(int) ZOOM_connection_get_timeout(ZOOM_connection c)
4197 {
4198     return ZOOM_options_get_int(c->options, "timeout", 30);
4199 }
4200
4201 /*
4202  * Local variables:
4203  * c-basic-offset: 4
4204  * indent-tabs-mode: nil
4205  * End:
4206  * vim: shiftwidth=4 tabstop=8 expandtab
4207  */
4208