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