src/zoom-c.c

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