src/zoom-c.c

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