zutil/zoom-c.c

   1 /*
   2  * Copyright (c) 2000-2003, Index Data
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: zoom-c.c,v 1.18 2003-02-14 18:49:24 adam Exp $
   6  *
   7  * ZOOM layer for C, connections, result sets, queries.
   8  */
   9 #include <assert.h>
  10 #include <string.h>
  11 #include "zoom-p.h"
  12
  13 #include <yaz/xmalloc.h>
  14 #include <yaz/otherinfo.h>
  15 #include <yaz/log.h>
  16 #include <yaz/pquery.h>
  17 #include <yaz/marcdisp.h>
  18 #include <yaz/diagbib1.h>
  19 #include <yaz/charneg.h>
  20 #include <yaz/ill.h>
  21 #include <yaz/srw.h>
  22
  23 #if HAVE_SYS_POLL_H
  24 #include <sys/poll.h>
  25 #endif
  26
  27 typedef enum {
  28     zoom_pending,
  29     zoom_complete
  30 } zoom_ret;
  31
  32 static zoom_ret ZOOM_connection_send_init (ZOOM_connection c);
  33 static zoom_ret do_write_ex (ZOOM_connection c, char *buf_out, int len_out);
  34
  35 static ZOOM_Event ZOOM_Event_create (int kind)
  36 {
  37     ZOOM_Event event = (ZOOM_Event) xmalloc (sizeof(*event));
  38     event->kind = kind;
  39     event->next = 0;
  40     event->prev = 0;
  41     return event;
  42 }
  43
  44 static void ZOOM_Event_destroy (ZOOM_Event event)
  45 {
  46     xfree (event);
  47 }
  48
  49 static void ZOOM_connection_put_event (ZOOM_connection c, ZOOM_Event event)
  50 {
  51     if (c->m_queue_back)
  52     {
  53         c->m_queue_back->prev = event;
  54         assert (c->m_queue_front);
  55     }
  56     else
  57     {
  58         assert (!c->m_queue_front);
  59         c->m_queue_front = event;
  60     }
  61     event->next = c->m_queue_back;
  62     event->prev = 0;
  63     c->m_queue_back = event;
  64 }
  65
  66 static ZOOM_Event ZOOM_connection_get_event(ZOOM_connection c)
  67 {
  68     ZOOM_Event event = c->m_queue_front;
  69     if (!event)
  70         return 0;
  71     assert (c->m_queue_back);
  72     c->m_queue_front = event->prev;
  73     if (c->m_queue_front)
  74     {
  75         assert (c->m_queue_back);
  76         c->m_queue_front->next = 0;
  77     }
  78     else
  79         c->m_queue_back = 0;
  80     c->last_event = event->kind;
  81     return event;
  82 }
  83
  84 static void set_bib1_error (ZOOM_connection c, int error)
  85 {
  86     xfree (c->addinfo);
  87     c->addinfo = 0;
  88     c->error = error;
  89     c->diagset = "Bib-1";
  90 }
  91
  92 static void set_ZOOM_error (ZOOM_connection c, int error,
  93                             const char *addinfo)
  94 {
  95     xfree (c->addinfo);
  96     c->addinfo = 0;
  97     c->error = error;
  98     c->diagset = "ZOOM";
  99     if (addinfo)
 100         c->addinfo = xstrdup(addinfo);
 101 }
 102
 103 static void clear_error (ZOOM_connection c)
 104 {
 105
 106     switch (c->error)
 107     {
 108     case ZOOM_ERROR_CONNECT:
 109     case ZOOM_ERROR_MEMORY:
 110     case ZOOM_ERROR_DECODE:
 111     case ZOOM_ERROR_CONNECTION_LOST:
 112     case ZOOM_ERROR_INIT:
 113     case ZOOM_ERROR_INTERNAL:
 114     case ZOOM_ERROR_UNSUPPORTED_PROTOCOL:
 115         break;
 116     default:
 117         set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
 118     }
 119 }
 120
 121 ZOOM_task ZOOM_connection_add_task (ZOOM_connection c, int which)
 122 {
 123     ZOOM_task *taskp = &c->tasks;
 124     while (*taskp)
 125         taskp = &(*taskp)->next;
 126     *taskp = (ZOOM_task) xmalloc (sizeof(**taskp));
 127     (*taskp)->running = 0;
 128     (*taskp)->which = which;
 129     (*taskp)->next = 0;
 130     clear_error (c);
 131     return *taskp;
 132 }
 133
 134 ZOOM_task ZOOM_connection_insert_task (ZOOM_connection c, int which)
 135 {
 136     ZOOM_task task = (ZOOM_task) xmalloc (sizeof(*task));
 137
 138     task->next = c->tasks;
 139     c->tasks = task;
 140
 141     task->running = 0;
 142     task->which = which;
 143     clear_error (c);
 144     return task;
 145 }
 146
 147 void ZOOM_connection_remove_task (ZOOM_connection c)
 148 {
 149     ZOOM_task task = c->tasks;
 150
 151     if (task)
 152     {
 153         c->tasks = task->next;
 154         switch (task->which)
 155         {
 156         case ZOOM_TASK_SEARCH:
 157             ZOOM_resultset_destroy (task->u.search.resultset);
 158             break;
 159         case ZOOM_TASK_RETRIEVE:
 160             ZOOM_resultset_destroy (task->u.retrieve.resultset);
 161             break;
 162         case ZOOM_TASK_CONNECT:
 163             break;
 164         case ZOOM_TASK_SCAN:
 165             ZOOM_scanset_destroy (task->u.scan.scan);
 166             break;
 167         case ZOOM_TASK_PACKAGE:
 168             ZOOM_package_destroy (task->u.package);
 169             break;
 170         default:
 171             assert (0);
 172         }
 173         xfree (task);
 174     }
 175 }
 176
 177 static int ZOOM_connection_exec_task (ZOOM_connection c);
 178
 179 void ZOOM_connection_remove_tasks (ZOOM_connection c)
 180 {
 181     while (c->tasks)
 182         ZOOM_connection_remove_task(c);
 183 }
 184
 185 static ZOOM_record record_cache_lookup (ZOOM_resultset r, int pos);
 186
 187 ZOOM_API(ZOOM_connection)
 188 ZOOM_connection_create (ZOOM_options options)
 189 {
 190     ZOOM_connection c = (ZOOM_connection) xmalloc (sizeof(*c));
 191
 192     c->proto = PROTO_Z3950;
 193     c->cs = 0;
 194     c->mask = 0;
 195     c->reconnect_ok = 0;
 196     c->state = STATE_IDLE;
 197     c->addinfo = 0;
 198     set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
 199     c->buf_in = 0;
 200     c->len_in = 0;
 201     c->buf_out = 0;
 202     c->len_out = 0;
 203     c->resultsets = 0;
 204
 205     c->options = ZOOM_options_create_with_parent(options);
 206
 207     c->host_port = 0;
 208     c->path = 0;
 209     c->proxy = 0;
 210
 211     c->charset = c->lang = 0;
 212
 213     c->cookie_out = 0;
 214     c->cookie_in = 0;
 215     c->client_IP = 0;
 216     c->tasks = 0;
 217
 218     c->odr_in = odr_createmem (ODR_DECODE);
 219     c->odr_out = odr_createmem (ODR_ENCODE);
 220
 221     c->async = 0;
 222     c->support_named_resultsets = 0;
 223     c->last_event = ZOOM_EVENT_NONE;
 224
 225     c->m_queue_front = 0;
 226     c->m_queue_back = 0;
 227     return c;
 228 }
 229
 230 /* set database names. Take local databases (if set); otherwise
 231    take databases given in ZURL (if set); otherwise use Default */
 232 static char **set_DatabaseNames (ZOOM_connection con, ZOOM_options options,
 233                                  int *num)
 234 {
 235     char **databaseNames;
 236     const char *c;
 237     int no = 2;
 238     const char *cp = ZOOM_options_get (options, "databaseName");
 239
 240     if (!cp || !*cp)
 241     {
 242         if (strncmp (con->host_port, "unix:", 5) == 0)
 243             cp = strchr (con->host_port+5, ':');
 244         else
 245             cp = strchr (con->host_port, '/');
 246         if (cp)
 247             cp++;
 248     }
 249     if (cp)
 250     {
 251         c = cp;
 252         while ((c = strchr(c, '+')))
 253         {
 254             c++;
 255             no++;
 256         }
 257     }
 258     else
 259         cp = "Default";
 260     databaseNames = (char**)
 261         odr_malloc (con->odr_out, no * sizeof(*databaseNames));
 262     no = 0;
 263     while (*cp)
 264     {
 265         c = strchr (cp, '+');
 266         if (!c)
 267             c = cp + strlen(cp);
 268         else if (c == cp)
 269         {
 270             cp++;
 271             continue;
 272         }
 273         /* cp ptr to first char of db name, c is char
 274            following db name */
 275         databaseNames[no] = (char*) odr_malloc (con->odr_out, 1+c-cp);
 276         memcpy (databaseNames[no], cp, c-cp);
 277         databaseNames[no++][c-cp] = '\0';
 278         cp = c;
 279         if (*cp)
 280             cp++;
 281     }
 282     databaseNames[no] = NULL;
 283     *num = no;
 284     return databaseNames;
 285 }
 286
 287 ZOOM_API(ZOOM_connection)
 288 ZOOM_connection_new (const char *host, int portnum)
 289 {
 290     ZOOM_connection c = ZOOM_connection_create (0);
 291
 292     ZOOM_connection_connect (c, host, portnum);
 293     return c;
 294 }
 295
 296 ZOOM_API(void)
 297 ZOOM_connection_connect(ZOOM_connection c,
 298                         const char *host, int portnum)
 299 {
 300     const char *val;
 301     ZOOM_task task;
 302
 303     if (c->cs)
 304     {
 305         yaz_log (LOG_DEBUG, "reconnect");
 306         c->reconnect_ok = 1;
 307         return;
 308     }
 309     yaz_log(LOG_DEBUG, "connect");
 310     xfree (c->proxy);
 311     val = ZOOM_options_get (c->options, "proxy");
 312     if (val && *val)
 313         c->proxy = xstrdup (val);
 314     else
 315         c->proxy = 0;
 316
 317     xfree (c->charset);
 318     val = ZOOM_options_get (c->options, "charset");
 319     if (val && *val)
 320         c->charset = xstrdup (val);
 321     else
 322         c->charset = 0;
 323
 324     xfree (c->lang);
 325     val = ZOOM_options_get (c->options, "lang");
 326     if (val && *val)
 327         c->lang = xstrdup (val);
 328     else
 329         c->lang = 0;
 330
 331     xfree (c->host_port);
 332     xfree (c->path);
 333     if (portnum)
 334     {
 335         char hostn[128];
 336         sprintf (hostn, "%.80s:%d", host, portnum);
 337         c->host_port = xstrdup(hostn);
 338     }
 339     else
 340         c->host_port = xstrdup(host);
 341
 342     ZOOM_options_set(c->options, "host", c->host_port);
 343
 344     val = ZOOM_options_get (c->options, "cookie");
 345     if (val && *val)
 346         c->cookie_out = xstrdup (val);
 347
 348     val = ZOOM_options_get (c->options, "clientIP");
 349     if (val && *val)
 350         c->client_IP = xstrdup (val);
 351
 352     c->async = ZOOM_options_get_bool (c->options, "async", 0);
 353
 354     set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
 355
 356     task = ZOOM_connection_add_task (c, ZOOM_TASK_CONNECT);
 357
 358     if (!c->async)
 359     {
 360         while (ZOOM_event (1, &c))
 361             ;
 362     }
 363 }
 364
 365 ZOOM_API(ZOOM_query)
 366 ZOOM_query_create(void)
 367 {
 368     ZOOM_query s = (ZOOM_query) xmalloc (sizeof(*s));
 369
 370     s->refcount = 1;
 371     s->z_query = 0;
 372     s->sort_spec = 0;
 373     s->odr = odr_createmem (ODR_ENCODE);
 374
 375     return s;
 376 }
 377
 378 ZOOM_API(void)
 379 ZOOM_query_destroy(ZOOM_query s)
 380 {
 381     if (!s)
 382         return;
 383
 384     (s->refcount)--;
 385     yaz_log (LOG_DEBUG, "ZOOM_query_destroy count=%d", s->refcount);
 386     if (s->refcount == 0)
 387     {
 388         odr_destroy (s->odr);
 389         xfree (s);
 390     }
 391 }
 392
 393 ZOOM_API(int)
 394 ZOOM_query_prefix(ZOOM_query s, const char *str)
 395 {
 396     s->z_query = (Z_Query *) odr_malloc (s->odr, sizeof(*s->z_query));
 397     s->z_query->which = Z_Query_type_1;
 398     s->z_query->u.type_1 =  p_query_rpn(s->odr, PROTO_Z3950, str);
 399     if (!s->z_query->u.type_1)
 400         return -1;
 401     return 0;
 402 }
 403
 404 ZOOM_API(int)
 405 ZOOM_query_cql(ZOOM_query s, const char *str)
 406 {
 407     Z_External *ext;
 408
 409     ext = (Z_External *) odr_malloc(s->odr, sizeof(*ext));
 410     ext->direct_reference = odr_getoidbystr(s->odr, "1.2.840.10003.16.2");
 411     ext->indirect_reference = 0;
 412     ext->descriptor = 0;
 413     ext->which = Z_External_CQL;
 414     ext->u.cql = odr_strdup(s->odr, str);
 415
 416     s->z_query = (Z_Query *) odr_malloc (s->odr, sizeof(*s->z_query));
 417     s->z_query->which = Z_Query_type_104;
 418     s->z_query->u.type_104 =  ext;
 419     return 0;
 420 }
 421
 422 ZOOM_API(int)
 423 ZOOM_query_sortby(ZOOM_query s, const char *criteria)
 424 {
 425     s->sort_spec = yaz_sort_spec (s->odr, criteria);
 426     if (!s->sort_spec)
 427         return -1;
 428     return 0;
 429 }
 430
 431 static zoom_ret do_write(ZOOM_connection c);
 432
 433 ZOOM_API(void)
 434 ZOOM_connection_destroy(ZOOM_connection c)
 435 {
 436     ZOOM_resultset r;
 437     if (!c)
 438         return;
 439     if (c->cs)
 440         cs_close (c->cs);
 441     for (r = c->resultsets; r; r = r->next)
 442         r->connection = 0;
 443
 444     xfree (c->buf_in);
 445     xfree (c->addinfo);
 446     odr_destroy (c->odr_in);
 447     odr_destroy (c->odr_out);
 448     ZOOM_options_destroy (c->options);
 449     ZOOM_connection_remove_tasks (c);
 450     xfree (c->host_port);
 451     xfree (c->proxy);
 452     xfree (c->charset);
 453     xfree (c->lang);
 454     xfree (c->cookie_out);
 455     xfree (c->cookie_in);
 456     xfree (c->client_IP);
 457     xfree (c);
 458 }
 459
 460 void ZOOM_resultset_addref (ZOOM_resultset r)
 461 {
 462     if (r)
 463     {
 464         (r->refcount)++;
 465         yaz_log (LOG_DEBUG, "ZOOM_resultset_addref r=%p count=%d",
 466                  r, r->refcount);
 467     }
 468 }
 469 ZOOM_resultset ZOOM_resultset_create ()
 470 {
 471     ZOOM_resultset r = (ZOOM_resultset) xmalloc (sizeof(*r));
 472
 473     yaz_log (LOG_DEBUG, "ZOOM_resultset_create r = %p", r);
 474     r->refcount = 1;
 475     r->size = 0;
 476     r->odr = odr_createmem (ODR_ENCODE);
 477     r->start = 0;
 478     r->piggyback = 1;
 479     r->setname = 0;
 480     r->count = 0;
 481     r->record_cache = 0;
 482     r->r_sort_spec = 0;
 483     r->z_query = 0;
 484     r->search = 0;
 485     r->connection = 0;
 486     r->next = 0;
 487     return r;
 488 }
 489
 490 ZOOM_API(ZOOM_resultset)
 491 ZOOM_connection_search_pqf(ZOOM_connection c, const char *q)
 492 {
 493     ZOOM_resultset r;
 494     ZOOM_query s = ZOOM_query_create();
 495
 496     ZOOM_query_prefix (s, q);
 497
 498     r = ZOOM_connection_search (c, s);
 499     ZOOM_query_destroy (s);
 500     return r;
 501 }
 502
 503 ZOOM_API(ZOOM_resultset)
 504 ZOOM_connection_search(ZOOM_connection c, ZOOM_query q)
 505 {
 506     ZOOM_resultset r = ZOOM_resultset_create ();
 507     ZOOM_task task;
 508     const char *cp;
 509
 510     r->r_sort_spec = q->sort_spec;
 511     r->z_query = q->z_query;
 512     r->search = q;
 513
 514     r->options = ZOOM_options_create_with_parent(c->options);
 515
 516     r->start = ZOOM_options_get_int(r->options, "start", 0);
 517     r->count = ZOOM_options_get_int(r->options, "count", 0);
 518     r->piggyback = ZOOM_options_get_bool (r->options, "piggyback", 1);
 519     cp = ZOOM_options_get (r->options, "setname");
 520     if (cp)
 521         r->setname = xstrdup (cp);
 522
 523     r->connection = c;
 524
 525     r->next = c->resultsets;
 526     c->resultsets = r;
 527
 528     task = ZOOM_connection_add_task (c, ZOOM_TASK_SEARCH);
 529     task->u.search.resultset = r;
 530     ZOOM_resultset_addref (r);
 531
 532     (q->refcount)++;
 533
 534     if (!c->async)
 535     {
 536         while (ZOOM_event (1, &c))
 537             ;
 538     }
 539     return r;
 540 }
 541
 542 ZOOM_API(void)
 543 ZOOM_resultset_destroy(ZOOM_resultset r)
 544 {
 545     if (!r)
 546         return;
 547     (r->refcount)--;
 548     yaz_log (LOG_DEBUG, "ZOOM_resultset_destroy r = %p count=%d",
 549              r, r->refcount);
 550     if (r->refcount == 0)
 551     {
 552         ZOOM_record_cache rc;
 553
 554         for (rc = r->record_cache; rc; rc = rc->next)
 555             if (rc->rec.wrbuf_marc)
 556                 wrbuf_free (rc->rec.wrbuf_marc, 1);
 557         if (r->connection)
 558         {
 559             /* remove ourselves from the resultsets in connection */
 560             ZOOM_resultset *rp = &r->connection->resultsets;
 561             while (1)
 562             {
 563                 assert (*rp);   /* we must be in this list!! */
 564                 if (*rp == r)
 565                 {   /* OK, we're here - take us out of it */
 566                     *rp = (*rp)->next;
 567                     break;
 568                 }
 569                 rp = &(*rp)->next;
 570             }
 571         }
 572         ZOOM_query_destroy (r->search);
 573         ZOOM_options_destroy (r->options);
 574         odr_destroy (r->odr);
 575         xfree (r->setname);
 576         xfree (r);
 577     }
 578 }
 579
 580 ZOOM_API(size_t)
 581 ZOOM_resultset_size (ZOOM_resultset r)
 582 {
 583     return r->size;
 584 }
 585
 586 static void do_close (ZOOM_connection c)
 587 {
 588     if (c->cs)
 589         cs_close(c->cs);
 590     c->cs = 0;
 591     c->mask = 0;
 592     c->state = STATE_IDLE;
 593 }
 594
 595 static void ZOOM_resultset_retrieve (ZOOM_resultset r,
 596                                      int force_sync, int start, int count)
 597 {
 598     ZOOM_task task;
 599     ZOOM_connection c;
 600
 601     if (!r)
 602         return;
 603     c = r->connection;
 604     if (!c)
 605         return;
 606     task = ZOOM_connection_add_task (c, ZOOM_TASK_RETRIEVE);
 607     task->u.retrieve.resultset = r;
 608     task->u.retrieve.start = start;
 609     task->u.retrieve.count = count;
 610
 611     ZOOM_resultset_addref (r);
 612
 613     if (!r->connection->async || force_sync)
 614         while (r->connection && ZOOM_event (1, &r->connection))
 615             ;
 616 }
 617
 618 ZOOM_API(void)
 619 ZOOM_resultset_records (ZOOM_resultset r, ZOOM_record *recs,
 620                         size_t start, size_t count)
 621 {
 622     int force_present = 0;
 623
 624     if (!r)
 625         return ;
 626     if (count && recs)
 627         force_present = 1;
 628     ZOOM_resultset_retrieve (r, force_present, start, count);
 629     if (force_present)
 630     {
 631         size_t i;
 632         for (i = 0; i< count; i++)
 633             recs[i] = ZOOM_resultset_record_immediate (r, i+start);
 634     }
 635 }
 636
 637 static zoom_ret do_connect (ZOOM_connection c)
 638 {
 639     void *add;
 640     const char *effective_host;
 641
 642     if (c->proxy)
 643         effective_host = c->proxy;
 644     else
 645         effective_host = c->host_port;
 646
 647     yaz_log (LOG_DEBUG, "do_connect host=%s", effective_host);
 648
 649     assert (!c->cs);
 650
 651     if (memcmp(c->host_port, "http:", 5) == 0)
 652     {
 653 #if HAVE_XSLT
 654         const char *path;
 655         c->proto = PROTO_SRW;
 656         effective_host = c->host_port + 5;
 657         if (*effective_host == '/')
 658             effective_host++;
 659         if (*effective_host == '/')
 660             effective_host++;
 661         if (!(path = strchr(effective_host, '/')))
 662             path = "/";
 663         xfree(c->path);
 664         c->path = xstrdup(path);
 665 #else
 666         c->state = STATE_IDLE;
 667         set_ZOOM_error(c, ZOOM_ERROR_UNSUPPORTED_PROTOCOL, "SRW");
 668         return zoom_complete;
 669 #endif
 670     }
 671     c->cs = cs_create_host (effective_host, 0, &add);
 672
 673     if (c->cs)
 674     {
 675         int ret = cs_connect (c->cs, add);
 676         if (ret == 0)
 677         {
 678             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
 679             ZOOM_connection_put_event(c, event);
 680             if (c->proto == PROTO_Z3950)
 681                 ZOOM_connection_send_init(c);
 682             else
 683             {
 684                 /* no init request for SRW .. */
 685                 assert (c->tasks->which == ZOOM_TASK_CONNECT);
 686                 ZOOM_connection_remove_task (c);
 687                 c->mask = 0;
 688                 ZOOM_connection_exec_task (c);
 689             }
 690             c->state = STATE_ESTABLISHED;
 691             return zoom_pending;
 692         }
 693         else if (ret > 0)
 694         {
 695             c->state = STATE_CONNECTING;
 696             c->mask = ZOOM_SELECT_EXCEPT;
 697             if (c->cs->io_pending & CS_WANT_WRITE)
 698                 c->mask += ZOOM_SELECT_WRITE;
 699             if (c->cs->io_pending & CS_WANT_READ)
 700                 c->mask += ZOOM_SELECT_READ;
 701             return zoom_pending;
 702         }
 703     }
 704     c->state = STATE_IDLE;
 705     set_ZOOM_error(c, ZOOM_ERROR_CONNECT, effective_host);
 706     return zoom_complete;
 707 }
 708
 709 int z3950_connection_socket(ZOOM_connection c)
 710 {
 711     if (c->cs)
 712         return cs_fileno(c->cs);
 713     return -1;
 714 }
 715
 716 int z3950_connection_mask(ZOOM_connection c)
 717 {
 718     if (c->cs)
 719         return c->mask;
 720     return 0;
 721 }
 722
 723 static void otherInfo_attach (ZOOM_connection c, Z_APDU *a, ODR out)
 724 {
 725     int i;
 726     for (i = 0; i<200; i++)
 727     {
 728         size_t len;
 729         Z_OtherInformation **oi;
 730         char buf[80];
 731         const char *val;
 732         const char *cp;
 733         int oidval;
 734
 735         sprintf (buf, "otherInfo%d", i);
 736         val = ZOOM_options_get (c->options, buf);
 737         if (!val)
 738             break;
 739         cp = strchr (val, ':');
 740         if (!cp)
 741             continue;
 742         len = cp - val;
 743         if (len >= sizeof(buf))
 744             len = sizeof(buf)-1;
 745         memcpy (buf, val, len);
 746         buf[len] = '\0';
 747         oidval = oid_getvalbyname (buf);
 748         if (oidval == VAL_NONE)
 749             continue;
 750
 751         yaz_oi_APDU(a, &oi);
 752         yaz_oi_set_string_oidval(oi, out, oidval, 1, cp+1);
 753     }
 754 }
 755
 756 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
 757 {
 758     assert (a);
 759     if (c->cookie_out)
 760     {
 761         Z_OtherInformation **oi;
 762         yaz_oi_APDU(a, &oi);
 763         yaz_oi_set_string_oidval(oi, out, VAL_COOKIE, 1, c->cookie_out);
 764     }
 765     if (c->client_IP)
 766     {
 767         Z_OtherInformation **oi;
 768         yaz_oi_APDU(a, &oi);
 769         yaz_oi_set_string_oidval(oi, out, VAL_CLIENT_IP, 1, c->client_IP);
 770     }
 771     otherInfo_attach (c, a, out);
 772     if (!z_APDU(out, &a, 0, 0))
 773     {
 774         FILE *outf = fopen("/tmp/apdu.txt", "a");
 775         if (a && outf)
 776         {
 777             ODR odr_pr = odr_createmem(ODR_PRINT);
 778             fprintf (outf, "a=%p\n", a);
 779             odr_setprint(odr_pr, outf);
 780             z_APDU(odr_pr, &a, 0, 0);
 781             odr_destroy(odr_pr);
 782         }
 783         yaz_log (LOG_DEBUG, "encoding failed");
 784         set_ZOOM_error(c, ZOOM_ERROR_ENCODE, 0);
 785         odr_reset(out);
 786         return -1;
 787     }
 788
 789     return 0;
 790 }
 791
 792 static zoom_ret send_APDU (ZOOM_connection c, Z_APDU *a)
 793 {
 794     ZOOM_Event event;
 795     assert (a);
 796     if (encode_APDU(c, a, c->odr_out))
 797         return zoom_complete;
 798     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
 799     event = ZOOM_Event_create (ZOOM_EVENT_SEND_APDU);
 800     ZOOM_connection_put_event (c, event);
 801     odr_reset(c->odr_out);
 802     return do_write (c);
 803 }
 804
 805 /* returns 1 if PDU was sent OK (still pending )
 806            0 if PDU was not sent OK (nothing to wait for)
 807 */
 808
 809 static zoom_ret ZOOM_connection_send_init (ZOOM_connection c)
 810 {
 811     const char *impname;
 812     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
 813     Z_InitRequest *ireq = apdu->u.initRequest;
 814     Z_IdAuthentication *auth = (Z_IdAuthentication *)
 815         odr_malloc(c->odr_out, sizeof(*auth));
 816     const char *auth_groupId = ZOOM_options_get (c->options, "group");
 817     const char *auth_userId = ZOOM_options_get (c->options, "user");
 818     const char *auth_password = ZOOM_options_get (c->options, "pass");
 819
 820     ODR_MASK_SET(ireq->options, Z_Options_search);
 821     ODR_MASK_SET(ireq->options, Z_Options_present);
 822     ODR_MASK_SET(ireq->options, Z_Options_scan);
 823     ODR_MASK_SET(ireq->options, Z_Options_sort);
 824     ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
 825     ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
 826
 827     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
 828     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
 829     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
 830
 831     impname = ZOOM_options_get (c->options, "implementationName");
 832     ireq->implementationName =
 833         (char *) odr_malloc (c->odr_out, 15 + (impname ? strlen(impname) : 0));
 834     strcpy (ireq->implementationName, "");
 835     if (impname)
 836     {
 837         strcat (ireq->implementationName, impname);
 838         strcat (ireq->implementationName, "/");
 839     }
 840     strcat (ireq->implementationName, "ZOOM-C/YAZ");
 841
 842     *ireq->maximumRecordSize =
 843         ZOOM_options_get_int (c->options, "maximumRecordSize", 1024*1024);
 844     *ireq->preferredMessageSize =
 845         ZOOM_options_get_int (c->options, "preferredMessageSize", 1024*1024);
 846
 847     if (auth_groupId || auth_password)
 848     {
 849         Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
 850         int i = 0;
 851         pass->groupId = 0;
 852         if (auth_groupId && *auth_groupId)
 853         {
 854             pass->groupId = (char *)
 855                 odr_malloc(c->odr_out, strlen(auth_groupId)+1);
 856             strcpy(pass->groupId, auth_groupId);
 857             i++;
 858         }
 859         pass->userId = 0;
 860         if (auth_userId && *auth_userId)
 861         {
 862             pass->userId = (char *)
 863                 odr_malloc(c->odr_out, strlen(auth_userId)+1);
 864             strcpy(pass->userId, auth_userId);
 865             i++;
 866         }
 867         pass->password = 0;
 868         if (auth_password && *auth_password)
 869         {
 870             pass->password = (char *)
 871                 odr_malloc(c->odr_out, strlen(auth_password)+1);
 872             strcpy(pass->password, auth_password);
 873             i++;
 874         }
 875         if (i)
 876         {
 877             auth->which = Z_IdAuthentication_idPass;
 878             auth->u.idPass = pass;
 879             ireq->idAuthentication = auth;
 880         }
 881     }
 882     else if (auth_userId)
 883     {
 884         auth->which = Z_IdAuthentication_open;
 885         auth->u.open = (char *)
 886             odr_malloc(c->odr_out, strlen(auth_userId)+1);
 887         strcpy(auth->u.open, auth_userId);
 888         ireq->idAuthentication = auth;
 889     }
 890     if (c->proxy)
 891         yaz_oi_set_string_oidval(&ireq->otherInfo, c->odr_out,
 892                                  VAL_PROXY, 1, c->host_port);
 893     if (c->charset||c->lang)
 894     {
 895         Z_OtherInformation **oi;
 896         Z_OtherInformationUnit *oi_unit;
 897
 898         yaz_oi_APDU(apdu, &oi);
 899
 900         if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
 901         {
 902             ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
 903
 904             oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
 905             oi_unit->information.externallyDefinedInfo =
 906                 yaz_set_proposal_charneg
 907                 (c->odr_out,
 908                  (const char **)&c->charset, (c->charset) ? 1:0,
 909                  (const char **)&c->lang, (c->lang) ? 1:0, 1);
 910         }
 911     }
 912     assert (apdu);
 913     return send_APDU (c, apdu);
 914 }
 915
 916 static zoom_ret send_srw (ZOOM_connection c, Z_SRW_searchRetrieve *sr)
 917 {
 918     Z_SOAP_Handler h[2] = {
 919         {"http://www.loc.gov/zing/srw/v1.0/", 0, (Z_SOAP_fun) yaz_srw_codec},
 920         {0, 0, 0}
 921     };
 922     ODR o = odr_createmem(ODR_ENCODE);
 923     int ret;
 924     Z_SOAP *p = odr_malloc(o, sizeof(*p));
 925     Z_GDU *gdu;
 926     ZOOM_Event event;
 927
 928     gdu = z_get_HTTP_Request(c->odr_out);
 929     gdu->u.HTTP_Request->path = c->path;
 930     z_HTTP_header_add(c->odr_out, &gdu->u.HTTP_Request->headers,
 931                       "Content-Type", "text/xml");
 932     z_HTTP_header_add(c->odr_out, &gdu->u.HTTP_Request->headers,
 933                       "SOAPAction", "\"\"");
 934     p->which = Z_SOAP_generic;
 935     p->u.generic = odr_malloc(o, sizeof(*p->u.generic));
 936     p->u.generic->no = 0;
 937     p->u.generic->ns = 0;
 938     p->u.generic->p = sr;
 939     p->ns = "http://schemas.xmlsoap.org/soap/envelope/";
 940
 941     ret = z_soap_codec(o, &p,
 942                        &gdu->u.HTTP_Request->content_buf,
 943                        &gdu->u.HTTP_Request->content_len, h);
 944
 945     if (!z_GDU(c->odr_out, &gdu, 0, 0))
 946         return zoom_complete;
 947     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
 948
 949     odr_destroy(o);
 950
 951     event = ZOOM_Event_create (ZOOM_EVENT_SEND_APDU);
 952     ZOOM_connection_put_event (c, event);
 953     odr_reset(c->odr_out);
 954     return do_write (c);
 955 }
 956
 957 static zoom_ret ZOOM_connection_srw_send_search(ZOOM_connection c)
 958 {
 959     ZOOM_resultset resultset;
 960     Z_SRW_searchRetrieve *sr = yaz_srw_get(c->odr_out,
 961                                            Z_SRW_searchRetrieve_request);
 962
 963     assert (c->tasks);
 964     assert (c->tasks->which == ZOOM_TASK_SEARCH);
 965
 966     resultset = c->tasks->u.search.resultset;
 967     assert(resultset);
 968     assert (resultset->z_query);
 969
 970     if (resultset->z_query->which == Z_Query_type_104
 971         && resultset->z_query->u.type_104->which == Z_External_CQL)
 972         sr->u.request->query = resultset->z_query->u.type_104->u.cql;
 973     else
 974         sr->u.request->query = "dc.title = computer";
 975
 976     sr->u.request->startRecord = odr_intdup (c->odr_out, resultset->start + 1);
 977     sr->u.request->maximumRecords = odr_intdup (c->odr_out, resultset->count);
 978
 979     return send_srw(c, sr);
 980 }
 981
 982 static zoom_ret ZOOM_connection_send_search (ZOOM_connection c)
 983 {
 984     ZOOM_resultset r;
 985     int lslb, ssub, mspn;
 986     const char *syntax;
 987     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
 988     Z_SearchRequest *search_req = apdu->u.searchRequest;
 989     const char *elementSetName;
 990     const char *smallSetElementSetName;
 991     const char *mediumSetElementSetName;
 992     const char *schema;
 993
 994     assert (c->tasks);
 995     assert (c->tasks->which == ZOOM_TASK_SEARCH);
 996
 997     r = c->tasks->u.search.resultset;
 998
 999     elementSetName =
1000         ZOOM_options_get (r->options, "elementSetName");
1001     smallSetElementSetName  =
1002         ZOOM_options_get (r->options, "smallSetElementSetName");
1003     mediumSetElementSetName =
1004         ZOOM_options_get (r->options, "mediumSetElementSetName");
1005     schema =
1006         ZOOM_options_get (r->options, "schema");
1007
1008     if (!smallSetElementSetName)
1009         smallSetElementSetName = elementSetName;
1010
1011     if (!mediumSetElementSetName)
1012         mediumSetElementSetName = elementSetName;
1013
1014     assert (r);
1015     assert (r->z_query);
1016
1017     /* prepare query for the search request */
1018     search_req->query = r->z_query;
1019
1020     search_req->databaseNames =
1021         set_DatabaseNames (c, r->options, &search_req->num_databaseNames);
1022
1023     /* get syntax (no need to provide unless piggyback is in effect) */
1024     syntax = ZOOM_options_get (r->options, "preferredRecordSyntax");
1025
1026     lslb = ZOOM_options_get_int (r->options, "largeSetLowerBound", -1);
1027     ssub = ZOOM_options_get_int (r->options, "smallSetUpperBound", -1);
1028     mspn = ZOOM_options_get_int (r->options, "mediumSetPresentNumber", -1);
1029     if (lslb != -1 && ssub != -1 && mspn != -1)
1030     {
1031         /* So're a Z39.50 expert? Let's hope you don't do sort */
1032         *search_req->largeSetLowerBound = lslb;
1033         *search_req->smallSetUpperBound = ssub;
1034         *search_req->mediumSetPresentNumber = mspn;
1035     }
1036     else if (r->start == 0 && r->count > 0
1037              && r->piggyback && !r->r_sort_spec && !schema)
1038     {
1039         /* Regular piggyback - do it unless we're going to do sort */
1040         *search_req->largeSetLowerBound = 2000000000;
1041         *search_req->smallSetUpperBound = 0;
1042         *search_req->mediumSetPresentNumber = r->count;
1043         smallSetElementSetName = 0;
1044     }
1045     else
1046     {
1047         /* non-piggyback. Need not provide elementsets or syntaxes .. */
1048         smallSetElementSetName = 0;
1049         mediumSetElementSetName = 0;
1050         syntax = 0;
1051     }
1052     if (smallSetElementSetName && *smallSetElementSetName)
1053     {
1054         Z_ElementSetNames *esn = (Z_ElementSetNames *)
1055             odr_malloc (c->odr_out, sizeof(*esn));
1056
1057         esn->which = Z_ElementSetNames_generic;
1058         esn->u.generic = odr_strdup (c->odr_out, smallSetElementSetName);
1059         search_req->smallSetElementSetNames = esn;
1060     }
1061     if (mediumSetElementSetName && *mediumSetElementSetName)
1062     {
1063         Z_ElementSetNames *esn = (Z_ElementSetNames *)
1064             odr_malloc (c->odr_out, sizeof(*esn));
1065
1066         esn->which = Z_ElementSetNames_generic;
1067         esn->u.generic = odr_strdup (c->odr_out, mediumSetElementSetName);
1068         search_req->mediumSetElementSetNames = esn;
1069     }
1070     if (syntax)
1071         search_req->preferredRecordSyntax =
1072             yaz_str_to_z3950oid (c->odr_out, CLASS_RECSYN, syntax);
1073
1074     if (!r->setname)
1075     {
1076         if (c->support_named_resultsets)
1077         {
1078             char setname[14];
1079             int ord;
1080             /* find the lowest unused ordinal so that we re-use
1081                result sets on the server. */
1082             for (ord = 1; ; ord++)
1083             {
1084                 ZOOM_resultset rp;
1085                 sprintf (setname, "%d", ord);
1086                 for (rp = c->resultsets; rp; rp = rp->next)
1087                     if (rp->setname && !strcmp (rp->setname, setname))
1088                         break;
1089                 if (!rp)
1090                     break;
1091             }
1092             r->setname = xstrdup (setname);
1093             yaz_log (LOG_DEBUG, "allocating set %s", r->setname);
1094         }
1095         else
1096             r->setname = xstrdup ("default");
1097         ZOOM_options_set (r->options, "setname", r->setname);
1098     }
1099     search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
1100     /* send search request */
1101     return send_APDU (c, apdu);
1102 }
1103
1104 static void response_diag (ZOOM_connection c, Z_DiagRec *p)
1105 {
1106     int oclass;
1107     Z_DefaultDiagFormat *r;
1108     char *addinfo = 0;
1109
1110     xfree (c->addinfo);
1111     c->addinfo = 0;
1112     if (p->which != Z_DiagRec_defaultFormat)
1113     {
1114         set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
1115         return;
1116     }
1117     r = p->u.defaultFormat;
1118     c->diagset = yaz_z3950oid_to_str(r->diagnosticSetId, &oclass);
1119
1120     switch (r->which)
1121     {
1122     case Z_DefaultDiagFormat_v2Addinfo:
1123         addinfo = r->u.v2Addinfo;
1124         break;
1125     case Z_DefaultDiagFormat_v3Addinfo:
1126         addinfo = r->u.v3Addinfo;
1127         break;
1128     }
1129     if (addinfo)
1130         c->addinfo = xstrdup (addinfo);
1131     c->error = *r->condition;
1132 }
1133
1134 ZOOM_API(ZOOM_record)
1135 ZOOM_record_clone (ZOOM_record srec)
1136 {
1137     char *buf;
1138     int size;
1139     ODR odr_enc;
1140     ZOOM_record nrec;
1141
1142     odr_enc = odr_createmem(ODR_ENCODE);
1143     if (!z_NamePlusRecord (odr_enc, &srec->npr, 0, 0))
1144         return 0;
1145     buf = odr_getbuf (odr_enc, &size, 0);
1146
1147     nrec = (ZOOM_record) xmalloc (sizeof(*nrec));
1148     nrec->odr = odr_createmem(ODR_DECODE);
1149     nrec->wrbuf_marc = 0;
1150     odr_setbuf (nrec->odr, buf, size, 0);
1151     z_NamePlusRecord (nrec->odr, &nrec->npr, 0, 0);
1152
1153     odr_destroy (odr_enc);
1154     return nrec;
1155 }
1156
1157 ZOOM_API(ZOOM_record)
1158 ZOOM_resultset_record_immediate (ZOOM_resultset s,size_t pos)
1159 {
1160     return record_cache_lookup (s, pos);
1161 }
1162
1163 ZOOM_API(ZOOM_record)
1164 ZOOM_resultset_record (ZOOM_resultset r, size_t pos)
1165 {
1166     ZOOM_resultset_retrieve (r, 1, pos, 1);
1167     return ZOOM_resultset_record_immediate (r, pos);
1168 }
1169
1170 ZOOM_API(void)
1171 ZOOM_record_destroy (ZOOM_record rec)
1172 {
1173     if (!rec)
1174         return;
1175     if (rec->wrbuf_marc)
1176         wrbuf_free (rec->wrbuf_marc, 1);
1177     odr_destroy (rec->odr);
1178     xfree (rec);
1179 }
1180
1181 ZOOM_API(const char *)
1182 ZOOM_record_get (ZOOM_record rec, const char *type, int *len)
1183 {
1184     Z_NamePlusRecord *npr;
1185
1186     if (len)
1187         *len = 0; /* default return */
1188
1189     if (!rec)
1190         return 0;
1191     npr = rec->npr;
1192     if (!npr)
1193         return 0;
1194     if (!strcmp (type, "database"))
1195     {
1196         if (len)
1197             *len = (npr->databaseName ? strlen(npr->databaseName) : 0);
1198         return npr->databaseName;
1199     }
1200     else if (!strcmp (type, "syntax"))
1201     {
1202         const char *desc = 0;
1203         if (npr->which == Z_NamePlusRecord_databaseRecord)
1204         {
1205             Z_External *r = (Z_External *) npr->u.databaseRecord;
1206             oident *ent = oid_getentbyoid(r->direct_reference);
1207             if (ent)
1208                 desc = ent->desc;
1209         }
1210         if (!desc)
1211             desc = "none";
1212         if (len)
1213             *len = strlen(desc);
1214         return desc;
1215     }
1216     else if (!strcmp (type, "render") &&
1217              npr->which == Z_NamePlusRecord_databaseRecord)
1218     {
1219         Z_External *r = (Z_External *) npr->u.databaseRecord;
1220         oident *ent = oid_getentbyoid(r->direct_reference);
1221
1222         if (r->which == Z_External_sutrs)
1223         {
1224             if (len) *len = r->u.sutrs->len;
1225             return (const char *) r->u.sutrs->buf;
1226         }
1227         else if (r->which == Z_External_octet)
1228         {
1229             yaz_marc_t mt;
1230             switch (ent->value)
1231             {
1232             case VAL_SOIF:
1233             case VAL_HTML:
1234             case VAL_SUTRS:
1235                 break;
1236             case VAL_TEXT_XML:
1237             case VAL_APPLICATION_XML:
1238                 break;
1239             default:
1240                 if (!rec->wrbuf_marc)
1241                     rec->wrbuf_marc = wrbuf_alloc();
1242
1243                 mt = yaz_marc_create();
1244                 wrbuf_rewind (rec->wrbuf_marc);
1245                 if (yaz_marc_decode_wrbuf (
1246                         mt, (const char *) r->u.octet_aligned->buf,
1247                         r->u.octet_aligned->len,
1248                         rec->wrbuf_marc) > 0)
1249                 {
1250                     if (len)
1251                         *len = wrbuf_len(rec->wrbuf_marc);
1252                     yaz_marc_destroy(mt);
1253                     return wrbuf_buf(rec->wrbuf_marc);
1254                 }
1255                 yaz_marc_destroy(mt);
1256             }
1257             if (len)
1258                 *len = r->u.octet_aligned->len;
1259             return (const char *) r->u.octet_aligned->buf;
1260         }
1261         else if (r->which == Z_External_grs1)
1262         {
1263             if (!rec->wrbuf_marc)
1264                 rec->wrbuf_marc = wrbuf_alloc();
1265             wrbuf_rewind (rec->wrbuf_marc);
1266             yaz_display_grs1(rec->wrbuf_marc, r->u.grs1, 0);
1267             if (len)
1268                 *len = wrbuf_len(rec->wrbuf_marc);
1269             return wrbuf_buf(rec->wrbuf_marc);
1270         }
1271         return 0;
1272     }
1273     else if (npr->which == Z_NamePlusRecord_databaseRecord &&
1274              (!strcmp (type, "xml") || !strcmp(type, "oai")))
1275     {
1276         Z_External *r = (Z_External *) npr->u.databaseRecord;
1277         oident *ent = oid_getentbyoid(r->direct_reference);
1278
1279         if (r->which == Z_External_sutrs)
1280         {
1281             if (len) *len = r->u.sutrs->len;
1282             return (const char *) r->u.sutrs->buf;
1283         }
1284         else if (r->which == Z_External_octet)
1285         {
1286             yaz_marc_t mt;
1287             int marc_decode_type = YAZ_MARC_MARCXML;
1288
1289             if (!strcmp(type, "oai"))
1290                 marc_decode_type = YAZ_MARC_OAIMARC;
1291             switch (ent->value)
1292             {
1293             case VAL_SOIF:
1294             case VAL_HTML:
1295             case VAL_SUTRS:
1296                 break;
1297             case VAL_TEXT_XML:
1298             case VAL_APPLICATION_XML:
1299                 break;
1300             default:
1301                 if (!rec->wrbuf_marc)
1302                     rec->wrbuf_marc = wrbuf_alloc();
1303                 wrbuf_rewind (rec->wrbuf_marc);
1304                 mt = yaz_marc_create();
1305
1306                 yaz_marc_xml(mt, YAZ_MARC_MARCXML);
1307                 if (yaz_marc_decode_wrbuf (
1308                         mt, (const char *) r->u.octet_aligned->buf,
1309                         r->u.octet_aligned->len,
1310                         rec->wrbuf_marc) > 0)
1311                 {
1312                     if (len)
1313                         *len = wrbuf_len(rec->wrbuf_marc);
1314                     yaz_marc_destroy(mt);
1315                     return wrbuf_buf(rec->wrbuf_marc);
1316                 }
1317                 yaz_marc_destroy(mt);
1318             }
1319             if (len) *len = r->u.octet_aligned->len;
1320             return (const char *) r->u.octet_aligned->buf;
1321         }
1322         else if (r->which == Z_External_grs1)
1323         {
1324             if (len) *len = 5;
1325             return "GRS-1";
1326         }
1327         return 0;
1328     }
1329     else if (!strcmp (type, "raw"))
1330     {
1331         if (npr->which == Z_NamePlusRecord_databaseRecord)
1332         {
1333             Z_External *r = (Z_External *) npr->u.databaseRecord;
1334
1335             if (r->which == Z_External_sutrs)
1336             {
1337                 if (len) *len = r->u.sutrs->len;
1338                 return (const char *) r->u.sutrs->buf;
1339             }
1340             else if (r->which == Z_External_octet)
1341             {
1342                 if (len) *len = r->u.octet_aligned->len;
1343                 return (const char *) r->u.octet_aligned->buf;
1344             }
1345             else /* grs-1, explain, ... */
1346             {
1347                 if (len) *len = -1;
1348                 return (const char *) npr->u.databaseRecord;
1349             }
1350         }
1351         return 0;
1352     }
1353     else if (!strcmp (type, "ext"))
1354     {
1355         if (npr->which == Z_NamePlusRecord_databaseRecord)
1356             return (const char *) npr->u.databaseRecord;
1357         return 0;
1358     }
1359     return 0;
1360 }
1361
1362 static void record_cache_add (ZOOM_resultset r, Z_NamePlusRecord *npr, int pos)
1363 {
1364     ZOOM_record_cache rc;
1365     const char *elementSetName =
1366         ZOOM_resultset_option_get (r, "elementSetName");
1367     const char *syntax =
1368         ZOOM_resultset_option_get (r, "preferredRecordSyntax");
1369
1370     for (rc = r->record_cache; rc; rc = rc->next)
1371     {
1372         if (pos == rc->pos)
1373         {
1374             if ((!elementSetName && !rc->elementSetName)
1375                 || (elementSetName && rc->elementSetName &&
1376                     !strcmp (elementSetName, rc->elementSetName)))
1377             {
1378                 if ((!syntax && !rc->syntax)
1379                     || (syntax && rc->syntax &&
1380                         !strcmp (syntax, rc->syntax)))
1381                 {
1382                     /* not destroying rc->npr (it's handled by nmem )*/
1383                     rc->rec.npr = npr;
1384                     /* keeping wrbuf_marc too */
1385                     return;
1386                 }
1387             }
1388         }
1389     }
1390     rc = (ZOOM_record_cache) odr_malloc (r->odr, sizeof(*rc));
1391     rc->rec.npr = npr;
1392     rc->rec.odr = 0;
1393     rc->rec.wrbuf_marc = 0;
1394     if (elementSetName)
1395         rc->elementSetName = odr_strdup (r->odr, elementSetName);
1396     else
1397         rc->elementSetName = 0;
1398
1399     if (syntax)
1400         rc->syntax = odr_strdup (r->odr, syntax);
1401     else
1402         rc->syntax = 0;
1403
1404     rc->pos = pos;
1405     rc->next = r->record_cache;
1406     r->record_cache = rc;
1407 }
1408
1409 static ZOOM_record record_cache_lookup (ZOOM_resultset r, int pos)
1410 {
1411     ZOOM_record_cache rc;
1412     const char *elementSetName =
1413         ZOOM_resultset_option_get (r, "elementSetName");
1414     const char *syntax =
1415         ZOOM_resultset_option_get (r, "preferredRecordSyntax");
1416
1417     for (rc = r->record_cache; rc; rc = rc->next)
1418     {
1419         if (pos == rc->pos)
1420         {
1421             if ((!elementSetName && !rc->elementSetName)
1422                 || (elementSetName && rc->elementSetName &&
1423                     !strcmp (elementSetName, rc->elementSetName)))
1424             {
1425                 if ((!syntax && !rc->syntax)
1426                     || (syntax && rc->syntax &&
1427                         !strcmp (syntax, rc->syntax)))
1428                     return &rc->rec;
1429             }
1430         }
1431     }
1432     return 0;
1433 }
1434
1435 static void handle_records (ZOOM_connection c, Z_Records *sr,
1436                             int present_phase)
1437 {
1438     ZOOM_resultset resultset;
1439
1440     if (!c->tasks)
1441         return ;
1442     switch (c->tasks->which)
1443     {
1444     case ZOOM_TASK_SEARCH:
1445         resultset = c->tasks->u.search.resultset;
1446         break;
1447     case ZOOM_TASK_RETRIEVE:
1448         resultset = c->tasks->u.retrieve.resultset;
1449         break;
1450     default:
1451         return;
1452     }
1453     if (sr && sr->which == Z_Records_NSD)
1454     {
1455         Z_DiagRec dr, *dr_p = &dr;
1456         dr.which = Z_DiagRec_defaultFormat;
1457         dr.u.defaultFormat = sr->u.nonSurrogateDiagnostic;
1458
1459         response_diag (c, dr_p);
1460     }
1461     else if (sr && sr->which == Z_Records_multipleNSD)
1462     {
1463         if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
1464             response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
1465         else
1466             set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
1467     }
1468     else
1469     {
1470         if (resultset->count + resultset->start > resultset->size)
1471             resultset->count = resultset->size - resultset->start;
1472         if (resultset->count < 0)
1473             resultset->count = 0;
1474         if (sr && sr->which == Z_Records_DBOSD)
1475         {
1476             int i;
1477             NMEM nmem = odr_extract_mem (c->odr_in);
1478             Z_NamePlusRecordList *p =
1479                 sr->u.databaseOrSurDiagnostics;
1480             for (i = 0; i<p->num_records; i++)
1481             {
1482                 record_cache_add (resultset, p->records[i],
1483                                   i+ resultset->start);
1484             }
1485             /* transfer our response to search_nmem .. we need it later */
1486             nmem_transfer (resultset->odr->mem, nmem);
1487             nmem_destroy (nmem);
1488             if (present_phase && p->num_records == 0)
1489             {
1490                 /* present response and we didn't get any records! */
1491                 set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
1492             }
1493         }
1494         else if (present_phase)
1495         {
1496             /* present response and we didn't get any records! */
1497             set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
1498         }
1499     }
1500 }
1501
1502 static void handle_present_response (ZOOM_connection c, Z_PresentResponse *pr)
1503 {
1504     handle_records (c, pr->records, 1);
1505 }
1506
1507 static void handle_search_response (ZOOM_connection c, Z_SearchResponse *sr)
1508 {
1509     ZOOM_resultset resultset;
1510
1511     yaz_log (LOG_DEBUG, "got search response");
1512
1513     if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1514         return ;
1515
1516     resultset = c->tasks->u.search.resultset;
1517
1518     resultset->size = *sr->resultCount;
1519     handle_records (c, sr->records, 0);
1520 }
1521
1522 static void sort_response (ZOOM_connection c, Z_SortResponse *res)
1523 {
1524     if (res->diagnostics && res->num_diagnostics > 0)
1525         response_diag (c, res->diagnostics[0]);
1526 }
1527
1528 static int scan_response (ZOOM_connection c, Z_ScanResponse *res)
1529 {
1530     NMEM nmem = odr_extract_mem (c->odr_in);
1531     ZOOM_scanset scan;
1532
1533     if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
1534         return 0;
1535     scan = c->tasks->u.scan.scan;
1536
1537     if (res->entries && res->entries->nonsurrogateDiagnostics)
1538         response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
1539     scan->scan_response = res;
1540     nmem_transfer (scan->odr->mem, nmem);
1541     if (res->stepSize)
1542         ZOOM_options_set_int (scan->options, "stepSize", *res->stepSize);
1543     if (res->positionOfTerm)
1544         ZOOM_options_set_int (scan->options, "position", *res->positionOfTerm);
1545     if (res->scanStatus)
1546         ZOOM_options_set_int (scan->options, "scanStatus", *res->scanStatus);
1547     if (res->numberOfEntriesReturned)
1548         ZOOM_options_set_int (scan->options, "number",
1549                               *res->numberOfEntriesReturned);
1550     nmem_destroy (nmem);
1551     return 1;
1552 }
1553
1554 static zoom_ret send_sort (ZOOM_connection c)
1555 {
1556     ZOOM_resultset  resultset;
1557
1558     if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1559         return zoom_complete;
1560
1561     resultset = c->tasks->u.search.resultset;
1562
1563     if (c->error)
1564     {
1565         resultset->r_sort_spec = 0;
1566         return zoom_complete;
1567     }
1568     if (resultset->r_sort_spec)
1569     {
1570         Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
1571         Z_SortRequest *req = apdu->u.sortRequest;
1572
1573         req->num_inputResultSetNames = 1;
1574         req->inputResultSetNames = (Z_InternationalString **)
1575             odr_malloc (c->odr_out, sizeof(*req->inputResultSetNames));
1576         req->inputResultSetNames[0] =
1577             odr_strdup (c->odr_out, resultset->setname);
1578         req->sortedResultSetName = odr_strdup (c->odr_out, resultset->setname);
1579         req->sortSequence = resultset->r_sort_spec;
1580         resultset->r_sort_spec = 0;
1581         return send_APDU (c, apdu);
1582     }
1583     return zoom_complete;
1584 }
1585
1586 static zoom_ret send_present (ZOOM_connection c)
1587 {
1588     Z_APDU *apdu = 0;
1589     Z_PresentRequest *req = 0;
1590     int i = 0;
1591     const char *syntax = 0;
1592     const char *elementSetName = 0;
1593     const char *schema = 0;
1594     ZOOM_resultset  resultset;
1595
1596     if (!c->tasks)
1597         return zoom_complete;
1598
1599     switch (c->tasks->which)
1600     {
1601     case ZOOM_TASK_SEARCH:
1602         resultset = c->tasks->u.search.resultset;
1603         break;
1604     case ZOOM_TASK_RETRIEVE:
1605         resultset = c->tasks->u.retrieve.resultset;
1606         resultset->start = c->tasks->u.retrieve.start;
1607         resultset->count = c->tasks->u.retrieve.count;
1608
1609         if (resultset->start >= resultset->size)
1610             return zoom_complete;
1611         if (resultset->start + resultset->count > resultset->size)
1612             resultset->count = resultset->size - resultset->start;
1613         break;
1614     default:
1615         return zoom_complete;
1616     }
1617
1618     syntax = ZOOM_resultset_option_get (resultset, "preferredRecordSyntax");
1619     elementSetName = ZOOM_resultset_option_get (resultset, "elementSetName");
1620     schema = ZOOM_resultset_option_get (resultset, "schema");
1621
1622     if (c->error)                  /* don't continue on error */
1623         return zoom_complete;
1624     if (resultset->start < 0)
1625         return zoom_complete;
1626     for (i = 0; i<resultset->count; i++)
1627     {
1628         ZOOM_record rec =
1629             record_cache_lookup (resultset, i + resultset->start);
1630         if (!rec)
1631             break;
1632     }
1633     if (i == resultset->count)
1634         return zoom_complete;
1635
1636     apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
1637     req = apdu->u.presentRequest;
1638
1639     resultset->start += i;
1640     resultset->count -= i;
1641     *req->resultSetStartPoint = resultset->start + 1;
1642     *req->numberOfRecordsRequested = resultset->count;
1643     assert (*req->numberOfRecordsRequested > 0);
1644
1645     if (syntax && *syntax)
1646         req->preferredRecordSyntax =
1647             yaz_str_to_z3950oid (c->odr_out, CLASS_RECSYN, syntax);
1648
1649     if (schema && *schema)
1650     {
1651         Z_RecordComposition *compo = (Z_RecordComposition *)
1652             odr_malloc (c->odr_out, sizeof(*compo));
1653
1654         req->recordComposition = compo;
1655         compo->which = Z_RecordComp_complex;
1656         compo->u.complex = (Z_CompSpec *)
1657             odr_malloc(c->odr_out, sizeof(*compo->u.complex));
1658         compo->u.complex->selectAlternativeSyntax = (bool_t *)
1659             odr_malloc(c->odr_out, sizeof(bool_t));
1660         *compo->u.complex->selectAlternativeSyntax = 0;
1661
1662         compo->u.complex->generic = (Z_Specification *)
1663             odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));
1664
1665         compo->u.complex->generic->which = Z_Specification_oid;
1666         compo->u.complex->generic->u.oid = (Odr_oid *)
1667             yaz_str_to_z3950oid (c->odr_out, CLASS_SCHEMA, schema);
1668
1669         if (!compo->u.complex->generic->u.oid)
1670         {
1671             /* OID wasn't a schema! Try record syntax instead. */
1672
1673             compo->u.complex->generic->u.oid = (Odr_oid *)
1674                 yaz_str_to_z3950oid (c->odr_out, CLASS_RECSYN, schema);
1675         }
1676         if (elementSetName && *elementSetName)
1677         {
1678             compo->u.complex->generic->elementSpec = (Z_ElementSpec *)
1679                 odr_malloc(c->odr_out, sizeof(Z_ElementSpec));
1680             compo->u.complex->generic->elementSpec->which =
1681                 Z_ElementSpec_elementSetName;
1682             compo->u.complex->generic->elementSpec->u.elementSetName =
1683                 odr_strdup (c->odr_out, elementSetName);
1684         }
1685         else
1686             compo->u.complex->generic->elementSpec = 0;
1687         compo->u.complex->num_dbSpecific = 0;
1688         compo->u.complex->dbSpecific = 0;
1689         compo->u.complex->num_recordSyntax = 0;
1690         compo->u.complex->recordSyntax = 0;
1691     }
1692     else if (elementSetName && *elementSetName)
1693     {
1694         Z_ElementSetNames *esn = (Z_ElementSetNames *)
1695             odr_malloc (c->odr_out, sizeof(*esn));
1696         Z_RecordComposition *compo = (Z_RecordComposition *)
1697             odr_malloc (c->odr_out, sizeof(*compo));
1698
1699         esn->which = Z_ElementSetNames_generic;
1700         esn->u.generic = odr_strdup (c->odr_out, elementSetName);
1701         compo->which = Z_RecordComp_simple;
1702         compo->u.simple = esn;
1703         req->recordComposition = compo;
1704     }
1705     req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
1706     return send_APDU (c, apdu);
1707 }
1708
1709 ZOOM_API(ZOOM_scanset)
1710 ZOOM_connection_scan (ZOOM_connection c, const char *start)
1711 {
1712     ZOOM_scanset scan = (ZOOM_scanset) xmalloc (sizeof(*scan));
1713
1714     scan->connection = c;
1715     scan->odr = odr_createmem (ODR_DECODE);
1716     scan->options = ZOOM_options_create_with_parent (c->options);
1717     scan->refcount = 1;
1718     scan->scan_response = 0;
1719
1720     if ((scan->termListAndStartPoint =
1721          p_query_scan(scan->odr, PROTO_Z3950, &scan->attributeSet,
1722                       start)))
1723     {
1724         ZOOM_task task = ZOOM_connection_add_task (c, ZOOM_TASK_SCAN);
1725         task->u.scan.scan = scan;
1726
1727         (scan->refcount)++;
1728         if (!c->async)
1729         {
1730             while (ZOOM_event (1, &c))
1731                 ;
1732         }
1733     }
1734     return scan;
1735 }
1736
1737 ZOOM_API(void)
1738 ZOOM_scanset_destroy (ZOOM_scanset scan)
1739 {
1740     if (!scan)
1741         return;
1742     (scan->refcount)--;
1743     if (scan->refcount == 0)
1744     {
1745         odr_destroy (scan->odr);
1746
1747         ZOOM_options_destroy (scan->options);
1748         xfree (scan);
1749     }
1750 }
1751
1752 static zoom_ret send_package (ZOOM_connection c)
1753 {
1754     ZOOM_Event event;
1755     if (!c->tasks)
1756         return zoom_complete;
1757     assert (c->tasks->which == ZOOM_TASK_PACKAGE);
1758
1759     event = ZOOM_Event_create (ZOOM_EVENT_SEND_APDU);
1760     ZOOM_connection_put_event (c, event);
1761
1762     return do_write_ex (c, c->tasks->u.package->buf_out,
1763                         c->tasks->u.package->len_out);
1764 }
1765
1766 static zoom_ret send_scan (ZOOM_connection c)
1767 {
1768     ZOOM_scanset scan;
1769     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
1770     Z_ScanRequest *req = apdu->u.scanRequest;
1771     if (!c->tasks)
1772         return zoom_complete;
1773     assert (c->tasks->which == ZOOM_TASK_SCAN);
1774     scan = c->tasks->u.scan.scan;
1775
1776     req->termListAndStartPoint = scan->termListAndStartPoint;
1777     req->attributeSet = scan->attributeSet;
1778
1779     *req->numberOfTermsRequested =
1780         ZOOM_options_get_int(scan->options, "number", 10);
1781
1782     req->preferredPositionInResponse =
1783         odr_intdup (c->odr_out,
1784                     ZOOM_options_get_int(scan->options, "position", 1));
1785
1786     req->stepSize =
1787         odr_intdup (c->odr_out,
1788                     ZOOM_options_get_int(scan->options, "stepSize", 0));
1789
1790     req->databaseNames = set_DatabaseNames (c, scan->options,
1791                                             &req->num_databaseNames);
1792
1793     return send_APDU (c, apdu);
1794 }
1795
1796 ZOOM_API(size_t)
1797 ZOOM_scanset_size (ZOOM_scanset scan)
1798 {
1799     if (!scan || !scan->scan_response || !scan->scan_response->entries)
1800         return 0;
1801     return scan->scan_response->entries->num_entries;
1802 }
1803
1804 ZOOM_API(const char *)
1805 ZOOM_scanset_term (ZOOM_scanset scan, size_t pos,
1806                                int *occ, int *len)
1807 {
1808     const char *term = 0;
1809     size_t noent = ZOOM_scanset_size (scan);
1810     Z_ScanResponse *res = scan->scan_response;
1811
1812     *len = 0;
1813     *occ = 0;
1814     if (pos >= noent)
1815         return 0;
1816     if (res->entries->entries[pos]->which == Z_Entry_termInfo)
1817     {
1818         Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
1819
1820         if (t->term->which == Z_Term_general)
1821         {
1822             term = (const char *) t->term->u.general->buf;
1823             *len = t->term->u.general->len;
1824         }
1825         *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
1826     }
1827     return term;
1828 }
1829
1830 ZOOM_API(const char *)
1831 ZOOM_scanset_option_get (ZOOM_scanset scan, const char *key)
1832 {
1833     return ZOOM_options_get (scan->options, key);
1834 }
1835
1836 ZOOM_API(void)
1837 ZOOM_scanset_option_set (ZOOM_scanset scan, const char *key,
1838                               const char *val)
1839 {
1840     ZOOM_options_set (scan->options, key, val);
1841 }
1842
1843 static Z_APDU *create_es_package (ZOOM_package p, int type)
1844 {
1845     const char *str;
1846     Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
1847     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
1848
1849     *req->function = Z_ExtendedServicesRequest_create;
1850
1851     str = ZOOM_options_get(p->options, "package-name");
1852     if (str && *str)
1853         req->packageName = nmem_strdup (p->odr_out->mem, str);
1854
1855     str = ZOOM_options_get(p->options, "user-id");
1856     if (str)
1857         req->userId = nmem_strdup (p->odr_out->mem, str);
1858
1859     req->packageType = yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
1860                                               type);
1861
1862     str = ZOOM_options_get(p->options, "function");
1863     if (str)
1864     {
1865         if (!strcmp (str, "create"))
1866             *req->function = 1;
1867         if (!strcmp (str, "delete"))
1868             *req->function = 2;
1869         if (!strcmp (str, "modify"))
1870             *req->function = 3;
1871     }
1872     return apdu;
1873 }
1874
1875 static const char *ill_array_lookup (void *clientData, const char *idx)
1876 {
1877     ZOOM_package p = (ZOOM_package) clientData;
1878     return ZOOM_options_get (p->options, idx+4);
1879 }
1880
1881 static Z_External *encode_ill_request (ZOOM_package p)
1882 {
1883     ODR out = p->odr_out;
1884     ILL_Request *req;
1885     Z_External *r = 0;
1886     struct ill_get_ctl ctl;
1887
1888     ctl.odr = p->odr_out;
1889     ctl.clientData = p;
1890     ctl.f = ill_array_lookup;
1891
1892     req = ill_get_ILLRequest(&ctl, "ill", 0);
1893
1894     if (!ill_Request (out, &req, 0, 0))
1895     {
1896         int ill_request_size;
1897         char *ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
1898         if (ill_request_buf)
1899             odr_setbuf (out, ill_request_buf, ill_request_size, 1);
1900         return 0;
1901     }
1902     else
1903     {
1904         oident oid;
1905         int illRequest_size = 0;
1906         char *illRequest_buf = odr_getbuf (out, &illRequest_size, 0);
1907
1908         oid.proto = PROTO_GENERAL;
1909         oid.oclass = CLASS_GENERAL;
1910         oid.value = VAL_ISO_ILL_1;
1911
1912         r = (Z_External *) odr_malloc (out, sizeof(*r));
1913         r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid));
1914         r->indirect_reference = 0;
1915         r->descriptor = 0;
1916         r->which = Z_External_single;
1917
1918         r->u.single_ASN1_type = (Odr_oct *)
1919             odr_malloc (out, sizeof(*r->u.single_ASN1_type));
1920         r->u.single_ASN1_type->buf = (unsigned char*)
1921             odr_malloc (out, illRequest_size);
1922         r->u.single_ASN1_type->len = illRequest_size;
1923         r->u.single_ASN1_type->size = illRequest_size;
1924         memcpy (r->u.single_ASN1_type->buf, illRequest_buf, illRequest_size);
1925     }
1926     return r;
1927 }
1928
1929 static Z_ItemOrder *encode_item_order(ZOOM_package p)
1930 {
1931     Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc (p->odr_out, sizeof(*req));
1932     const char *str;
1933
1934     req->which=Z_IOItemOrder_esRequest;
1935     req->u.esRequest = (Z_IORequest *)
1936         odr_malloc(p->odr_out,sizeof(Z_IORequest));
1937
1938     /* to keep part ... */
1939     req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
1940         odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
1941     req->u.esRequest->toKeep->supplDescription = 0;
1942     req->u.esRequest->toKeep->contact = (Z_IOContact *)
1943         odr_malloc (p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
1944
1945     str = ZOOM_options_get(p->options, "contact-name");
1946     req->u.esRequest->toKeep->contact->name = str ?
1947         nmem_strdup (p->odr_out->mem, str) : 0;
1948
1949     str = ZOOM_options_get(p->options, "contact-phone");
1950     req->u.esRequest->toKeep->contact->phone = str ?
1951         nmem_strdup (p->odr_out->mem, str) : 0;
1952
1953     str = ZOOM_options_get(p->options, "contact-email");
1954     req->u.esRequest->toKeep->contact->email = str ?
1955         nmem_strdup (p->odr_out->mem, str) : 0;
1956
1957     req->u.esRequest->toKeep->addlBilling = 0;
1958
1959     /* not to keep part ... */
1960     req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
1961         odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
1962
1963     req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
1964         odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
1965
1966     str = ZOOM_options_get(p->options, "itemorder-setname");
1967     if (!str)
1968         str = "default";
1969     req->u.esRequest->notToKeep->resultSetItem->resultSetId =
1970         nmem_strdup (p->odr_out->mem, str);
1971     req->u.esRequest->notToKeep->resultSetItem->item =
1972         (int *) odr_malloc(p->odr_out, sizeof(int));
1973
1974     str = ZOOM_options_get(p->options, "itemorder-item");
1975     *req->u.esRequest->notToKeep->resultSetItem->item =
1976         (str ? atoi(str) : 1);
1977
1978     req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
1979
1980     return req;
1981 }
1982
1983 ZOOM_API(void)
1984     ZOOM_package_send (ZOOM_package p, const char *type)
1985 {
1986     Z_APDU *apdu = 0;
1987     ZOOM_connection c;
1988     if (!p)
1989         return;
1990     c = p->connection;
1991     odr_reset (p->odr_out);
1992     xfree (p->buf_out);
1993     p->buf_out = 0;
1994     if (!strcmp(type, "itemorder"))
1995     {
1996         Z_External *r;
1997         apdu = create_es_package (p, VAL_ITEMORDER);
1998         if (apdu)
1999         {
2000             r = (Z_External *) odr_malloc (p->odr_out, sizeof(*r));
2001
2002             r->direct_reference =
2003                 yaz_oidval_to_z3950oid(p->odr_out, CLASS_EXTSERV,
2004                                        VAL_ITEMORDER);
2005             r->descriptor = 0;
2006             r->which = Z_External_itemOrder;
2007             r->indirect_reference = 0;
2008             r->u.itemOrder = encode_item_order (p);
2009
2010             apdu->u.extendedServicesRequest->taskSpecificParameters = r;
2011         }
2012     }
2013     if (apdu)
2014     {
2015         if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
2016         {
2017             char *buf;
2018
2019             ZOOM_task task = ZOOM_connection_add_task (c, ZOOM_TASK_PACKAGE);
2020             task->u.package = p;
2021             buf = odr_getbuf(p->odr_out, &p->len_out, 0);
2022             p->buf_out = (char *) xmalloc (p->len_out);
2023             memcpy (p->buf_out, buf, p->len_out);
2024
2025             (p->refcount)++;
2026             if (!c->async)
2027             {
2028                 while (ZOOM_event (1, &c))
2029                     ;
2030             }
2031         }
2032     }
2033 }
2034
2035 ZOOM_API(ZOOM_package)
2036     ZOOM_connection_package (ZOOM_connection c, ZOOM_options options)
2037 {
2038     ZOOM_package p = (ZOOM_package) xmalloc (sizeof(*p));
2039
2040     p->connection = c;
2041     p->odr_out = odr_createmem (ODR_ENCODE);
2042     p->options = ZOOM_options_create_with_parent2 (options, c->options);
2043     p->refcount = 1;
2044     p->buf_out = 0;
2045     p->len_out = 0;
2046     return p;
2047 }
2048
2049 ZOOM_API(void)
2050     ZOOM_package_destroy(ZOOM_package p)
2051 {
2052     if (!p)
2053         return;
2054     (p->refcount)--;
2055     if (p->refcount == 0)
2056     {
2057         odr_destroy (p->odr_out);
2058         xfree (p->buf_out);
2059
2060         ZOOM_options_destroy (p->options);
2061         xfree (p);
2062     }
2063 }
2064
2065 ZOOM_API(const char *)
2066 ZOOM_package_option_get (ZOOM_package p, const char *key)
2067 {
2068     return ZOOM_options_get (p->options, key);
2069 }
2070
2071 #if HAVE_GSOAP
2072 static zoom_ret ZOOM_srw_search(ZOOM_connection c, ZOOM_resultset r,
2073                                 const char *cql)
2074 {
2075     int ret;
2076     struct xcql__operandType *xQuery = 0;
2077     char *action = 0;
2078     xsd__integer startRecord = r->start + 1;
2079     xsd__integer maximumRecord = r->count;
2080     const char *schema = ZOOM_resultset_option_get (r, "schema");
2081     struct zs__searchRetrieveResponse res;
2082     xsd__string recordPacking = 0;
2083
2084
2085     if (!schema)
2086         schema = "http://www.loc.gov/marcxml/";
2087
2088     ret = soap_call_zs__searchRetrieveRequest(c->soap, c->host_port,
2089                                               action,
2090                                               &r->z_query->u.type_104->u.cql,
2091                                               xQuery,
2092                                               0, 0,
2093                                               &startRecord, &maximumRecord,
2094                                               (char **) &schema,
2095                                               &recordPacking,
2096                                               &res);
2097     if (ret != SOAP_OK)
2098     {
2099         const char **s = soap_faultdetail(c->soap);
2100         xfree (c->addinfo);
2101         c->addinfo = 0;
2102         if (s && *s)
2103             c->addinfo = xstrdup(*s);
2104         c->diagset = "SOAP";
2105         c->error = ret;
2106     }
2107     else
2108     {
2109         if (res.diagnostics.__sizeDiagnostics > 0)
2110         {
2111             int i = 0;
2112             xfree (c->addinfo);
2113             c->addinfo = 0;
2114             c->diagset = "SRW";
2115             c->error = res.diagnostics.diagnostic[i]->code;
2116             if (res.diagnostics.diagnostic[i]->details)
2117                 c->addinfo =
2118                     xstrdup(res.diagnostics.diagnostic[i]->details);
2119
2120         }
2121         else
2122         {
2123             int i;
2124             r->size = res.numberOfRecords;
2125             if (res.resultSetId)
2126                 r->setname = xstrdup(res.resultSetId);
2127             for (i = 0; i < res.records.__sizeRecords; i++)
2128             {
2129                 char *rdata = res.records.record[i]->recordData;
2130                 if (rdata)
2131                 {
2132                     Z_NamePlusRecord *npr =
2133                         odr_malloc(r->odr, sizeof(*npr));
2134                     Z_External *ext =
2135                         z_ext_record(r->odr, VAL_TEXT_XML,
2136                                      rdata, strlen(rdata));
2137                     npr->databaseName = 0;
2138                     npr->which = Z_NamePlusRecord_databaseRecord;
2139                     npr->u.databaseRecord = ext;
2140                     record_cache_add (r, npr, r->start + i);
2141                 }
2142             }
2143         }
2144     }
2145     return zoom_complete;
2146 }
2147 #endif
2148
2149 ZOOM_API(void)
2150 ZOOM_package_option_set (ZOOM_package p, const char *key,
2151                               const char *val)
2152 {
2153     ZOOM_options_set (p->options, key, val);
2154 }
2155
2156 static int ZOOM_connection_exec_task (ZOOM_connection c)
2157 {
2158     ZOOM_task task = c->tasks;
2159     zoom_ret ret = zoom_complete;
2160
2161     if (!task)
2162     {
2163         yaz_log (LOG_DEBUG, "ZOOM_connection_exec_task task=<null>");
2164         return 0;
2165     }
2166     yaz_log (LOG_DEBUG, "ZOOM_connection_exec_task type=%d run=%d",
2167              task->which, task->running);
2168     if (c->error != ZOOM_ERROR_NONE)
2169     {
2170         yaz_log (LOG_DEBUG, "remove tasks because of error = %d", c->error);
2171         ZOOM_connection_remove_tasks (c);
2172         return 0;
2173     }
2174     if (task->running)
2175     {
2176         yaz_log (LOG_DEBUG, "task already running");
2177         return 0;
2178     }
2179     task->running = 1;
2180     ret = zoom_complete;
2181 #if 0
2182     if (c->proto == PROTO_SRW)
2183     {
2184         ZOOM_resultset resultset;
2185         switch (task->which)
2186         {
2187         case ZOOM_TASK_SEARCH:
2188             resultset = c->tasks->u.search.resultset;
2189             if (resultset->z_query &&
2190                 resultset->z_query->which == Z_Query_type_104
2191                 && resultset->z_query->u.type_104->which == Z_External_CQL)
2192                 ret = ZOOM_srw_search(c, resultset,
2193                                       resultset->z_query->u.type_104->u.cql);
2194             break;
2195         case ZOOM_TASK_RETRIEVE:
2196             resultset = c->tasks->u.retrieve.resultset;
2197             resultset->start = c->tasks->u.retrieve.start;
2198             resultset->count = c->tasks->u.retrieve.count;
2199
2200             if (resultset->start >= resultset->size)
2201                 return zoom_complete;
2202             if (resultset->start + resultset->count > resultset->size)
2203                 resultset->count = resultset->size - resultset->start;
2204
2205             if (resultset->z_query &&
2206                 resultset->z_query->which == Z_Query_type_104
2207                 && resultset->z_query->u.type_104->which == Z_External_CQL)
2208                 ret = ZOOM_srw_search(c, resultset,
2209                                       resultset->z_query->u.type_104->u.cql);
2210             break;
2211         }
2212 #endif
2213     if (c->cs || task->which == ZOOM_TASK_CONNECT)
2214     {
2215         switch (task->which)
2216         {
2217         case ZOOM_TASK_SEARCH:
2218             if (c->proto == PROTO_SRW)
2219                 ret = ZOOM_connection_srw_send_search(c);
2220             else
2221                 ret = ZOOM_connection_send_search(c);
2222             break;
2223         case ZOOM_TASK_RETRIEVE:
2224             ret = send_present (c);
2225             break;
2226         case ZOOM_TASK_CONNECT:
2227             ret = do_connect(c);
2228             break;
2229         case ZOOM_TASK_SCAN:
2230             ret = send_scan(c);
2231             break;
2232         case ZOOM_TASK_PACKAGE:
2233             ret = send_package(c);
2234             break;
2235         }
2236     }
2237     else
2238     {
2239         yaz_log (LOG_DEBUG, "remove tasks because no connection exist");
2240         ZOOM_connection_remove_tasks (c);
2241     }
2242     if (ret == zoom_complete)
2243     {
2244         yaz_log (LOG_DEBUG, "task removed (complete)");
2245         ZOOM_connection_remove_task (c);
2246         return 0;
2247     }
2248     yaz_log (LOG_DEBUG, "task pending");
2249     return 1;
2250 }
2251
2252 static zoom_ret send_sort_present (ZOOM_connection c)
2253 {
2254     zoom_ret r = send_sort (c);
2255     if (r == zoom_complete)
2256         r = send_present (c);
2257     return r;
2258 }
2259
2260 static int es_response (ZOOM_connection c,
2261                         Z_ExtendedServicesResponse *res)
2262 {
2263     if (!c->tasks || c->tasks->which != ZOOM_TASK_PACKAGE)
2264         return 0;
2265     if (res->diagnostics && res->num_diagnostics > 0)
2266         response_diag(c, res->diagnostics[0]);
2267     if (res->taskPackage &&
2268         res->taskPackage->which == Z_External_extendedService)
2269     {
2270         Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
2271         Odr_oct *id = taskPackage->targetReference;
2272
2273         if (id)
2274             ZOOM_options_setl (c->tasks->u.package->options,
2275                                "targetReference", (char*) id->buf, id->len);
2276     }
2277     return 1;
2278 }
2279
2280
2281 static void handle_apdu (ZOOM_connection c, Z_APDU *apdu)
2282 {
2283     Z_InitResponse *initrs;
2284
2285     c->mask = 0;
2286     yaz_log (LOG_DEBUG, "handle_apdu type=%d", apdu->which);
2287     switch(apdu->which)
2288     {
2289     case Z_APDU_initResponse:
2290         initrs = apdu->u.initResponse;
2291         ZOOM_connection_option_set(c, "targetImplementationId",
2292                                    initrs->implementationId ?
2293                                    initrs->implementationId : "");
2294         ZOOM_connection_option_set(c, "targetImplementationName",
2295                                    initrs->implementationName ?
2296                                    initrs->implementationName : "");
2297         ZOOM_connection_option_set(c, "targetImplementationVersion",
2298                                    initrs->implementationVersion ?
2299                                    initrs->implementationVersion : "");
2300         if (!*initrs->result)
2301         {
2302             set_ZOOM_error(c, ZOOM_ERROR_INIT, 0);
2303         }
2304         else
2305         {
2306             char *cookie =
2307                 yaz_oi_get_string_oidval (&apdu->u.initResponse->otherInfo,
2308                                           VAL_COOKIE, 1, 0);
2309             xfree (c->cookie_in);
2310             c->cookie_in = 0;
2311             if (cookie)
2312                 c->cookie_in = xstrdup(cookie);
2313             if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
2314                 ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
2315                 c->support_named_resultsets = 1;
2316             if (c->tasks)
2317             {
2318                 assert (c->tasks->which == ZOOM_TASK_CONNECT);
2319                 ZOOM_connection_remove_task (c);
2320             }
2321             ZOOM_connection_exec_task (c);
2322         }
2323         if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
2324         {
2325             NMEM tmpmem = nmem_create();
2326             Z_CharSetandLanguageNegotiation *p =
2327                 yaz_get_charneg_record(initrs->otherInfo);
2328
2329             if (p)
2330             {
2331                 char *charset=NULL, *lang=NULL;
2332                 int sel;
2333
2334                 yaz_get_response_charneg(tmpmem, p, &charset, &lang, &sel);
2335                 yaz_log(LOG_DEBUG, "Target accepted: charset %s, "
2336                         "language %s, select %d",
2337                         charset ? charset : "none", lang ? lang : "none", sel);
2338                 if (charset)
2339                     ZOOM_connection_option_set (c, "negotiation-charset",
2340                                                 charset);
2341                 if (lang)
2342                     ZOOM_connection_option_set (c, "negotiation-lang",
2343                                                 lang);
2344                 nmem_destroy(tmpmem);
2345             }
2346         }
2347         break;
2348     case Z_APDU_searchResponse:
2349         handle_search_response (c, apdu->u.searchResponse);
2350         if (send_sort_present (c) == zoom_complete)
2351             ZOOM_connection_remove_task (c);
2352         break;
2353     case Z_APDU_presentResponse:
2354         handle_present_response (c, apdu->u.presentResponse);
2355         if (send_present (c) == zoom_complete)
2356             ZOOM_connection_remove_task (c);
2357         break;
2358     case Z_APDU_sortResponse:
2359         sort_response (c, apdu->u.sortResponse);
2360         if (send_present (c) == zoom_complete)
2361             ZOOM_connection_remove_task (c);
2362         break;
2363     case Z_APDU_scanResponse:
2364         scan_response (c, apdu->u.scanResponse);
2365         ZOOM_connection_remove_task (c);
2366         break;
2367     case Z_APDU_extendedServicesResponse:
2368         es_response (c, apdu->u.extendedServicesResponse);
2369         ZOOM_connection_remove_task (c);
2370         break;
2371     case Z_APDU_close:
2372         if (c->reconnect_ok)
2373         {
2374             do_close(c);
2375             c->tasks->running = 0;
2376             ZOOM_connection_insert_task (c, ZOOM_TASK_CONNECT);
2377         }
2378         else
2379         {
2380             set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, 0);
2381             do_close(c);
2382         }
2383         break;
2384     default:
2385         set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
2386         do_close(c);
2387     }
2388 }
2389
2390 static void handle_http(ZOOM_connection c, Z_HTTP_Response *hres)
2391 {
2392     c->mask = 0;
2393     yaz_log (LOG_DEBUG, "handle_http");
2394     ZOOM_connection_remove_task(c);
2395 }
2396
2397 static int do_read (ZOOM_connection c)
2398 {
2399     int r;
2400     ZOOM_Event event;
2401
2402     event = ZOOM_Event_create (ZOOM_EVENT_RECV_DATA);
2403     ZOOM_connection_put_event (c, event);
2404
2405     yaz_log (LOG_DEBUG, "do_read len=%d", c->len_in);
2406
2407     r = cs_get (c->cs, &c->buf_in, &c->len_in);
2408     if (r == 1)
2409         return 0;
2410     if (r <= 0)
2411     {
2412         if (c->reconnect_ok)
2413         {
2414             do_close (c);
2415             c->reconnect_ok = 0;
2416             yaz_log (LOG_DEBUG, "reconnect read");
2417             c->tasks->running = 0;
2418             ZOOM_connection_insert_task (c, ZOOM_TASK_CONNECT);
2419         }
2420         else
2421         {
2422             set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, 0);
2423             do_close (c);
2424         }
2425     }
2426     else
2427     {
2428         Z_GDU *gdu;
2429         ZOOM_Event event;
2430         odr_reset (c->odr_in);
2431         odr_setbuf (c->odr_in, c->buf_in, r, 0);
2432         event = ZOOM_Event_create (ZOOM_EVENT_RECV_APDU);
2433         ZOOM_connection_put_event (c, event);
2434
2435         if (!z_GDU (c->odr_in, &gdu, 0, 0))
2436         {
2437             set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
2438             do_close (c);
2439         }
2440         else if (gdu->which == Z_GDU_Z3950)
2441             handle_apdu (c, gdu->u.z3950);
2442         else if (gdu->which == Z_GDU_HTTP_Response)
2443             handle_http (c, gdu->u.HTTP_Response);
2444         c->reconnect_ok = 0;
2445     }
2446     return 1;
2447 }
2448
2449 static zoom_ret do_write_ex (ZOOM_connection c, char *buf_out, int len_out)
2450 {
2451     int r;
2452     ZOOM_Event event;
2453
2454     event = ZOOM_Event_create(ZOOM_EVENT_SEND_DATA);
2455     ZOOM_connection_put_event (c, event);
2456
2457     yaz_log (LOG_DEBUG, "do_write_ex len=%d", len_out);
2458     if ((r=cs_put (c->cs, buf_out, len_out)) < 0)
2459     {
2460         if (c->reconnect_ok)
2461         {
2462             do_close (c);
2463             c->reconnect_ok = 0;
2464             yaz_log (LOG_DEBUG, "reconnect write");
2465             c->tasks->running = 0;
2466             ZOOM_connection_insert_task (c, ZOOM_TASK_CONNECT);
2467             return zoom_complete;
2468         }
2469         if (c->state == STATE_CONNECTING)
2470             set_ZOOM_error(c, ZOOM_ERROR_CONNECT, 0);
2471         else
2472             set_ZOOM_error(c, ZOOM_ERROR_CONNECTION_LOST, 0);
2473         do_close (c);
2474         return zoom_complete;
2475     }
2476     else if (r == 1)
2477     {
2478         c->mask = ZOOM_SELECT_EXCEPT;
2479         if (c->cs->io_pending & CS_WANT_WRITE)
2480             c->mask += ZOOM_SELECT_WRITE;
2481         if (c->cs->io_pending & CS_WANT_READ)
2482             c->mask += ZOOM_SELECT_READ;
2483         yaz_log (LOG_DEBUG, "do_write_ex 1 mask=%d", c->mask);
2484     }
2485     else
2486     {
2487         c->mask = ZOOM_SELECT_READ|ZOOM_SELECT_EXCEPT;
2488         yaz_log (LOG_DEBUG, "do_write_ex 2 mask=%d", c->mask);
2489     }
2490     return zoom_pending;
2491 }
2492
2493 static zoom_ret do_write(ZOOM_connection c)
2494 {
2495     return do_write_ex (c, c->buf_out, c->len_out);
2496 }
2497
2498
2499 ZOOM_API(const char *)
2500 ZOOM_connection_option_get (ZOOM_connection c, const char *key)
2501 {
2502     return ZOOM_options_get (c->options, key);
2503 }
2504
2505 ZOOM_API(void)
2506 ZOOM_connection_option_set (ZOOM_connection c, const char *key,
2507                                   const char *val)
2508 {
2509     ZOOM_options_set (c->options, key, val);
2510 }
2511
2512 ZOOM_API(const char *)
2513 ZOOM_resultset_option_get (ZOOM_resultset r, const char *key)
2514 {
2515     return ZOOM_options_get (r->options, key);
2516 }
2517
2518 ZOOM_API(void)
2519 ZOOM_resultset_option_set (ZOOM_resultset r, const char *key,
2520                                   const char *val)
2521 {
2522     ZOOM_options_set (r->options, key, val);
2523 }
2524
2525
2526 ZOOM_API(int)
2527 ZOOM_connection_errcode (ZOOM_connection c)
2528 {
2529     return ZOOM_connection_error (c, 0, 0);
2530 }
2531
2532 ZOOM_API(const char *)
2533 ZOOM_connection_errmsg (ZOOM_connection c)
2534 {
2535     const char *msg;
2536     ZOOM_connection_error (c, &msg, 0);
2537     return msg;
2538 }
2539
2540 ZOOM_API(const char *)
2541 ZOOM_connection_addinfo (ZOOM_connection c)
2542 {
2543     const char *addinfo;
2544     ZOOM_connection_error (c, 0, &addinfo);
2545     return addinfo;
2546 }
2547
2548 ZOOM_API(const char *)
2549 ZOOM_diag_str (int error)
2550 {
2551     switch (error)
2552     {
2553     case ZOOM_ERROR_NONE:
2554         return "No error";
2555     case ZOOM_ERROR_CONNECT:
2556         return "Connect failed";
2557     case ZOOM_ERROR_MEMORY:
2558         return "Out of memory";
2559     case ZOOM_ERROR_ENCODE:
2560         return "Encoding failed";
2561     case ZOOM_ERROR_DECODE:
2562         return "Decoding failed";
2563     case ZOOM_ERROR_CONNECTION_LOST:
2564         return "Connection lost";
2565     case ZOOM_ERROR_INIT:
2566         return "Init rejected";
2567     case ZOOM_ERROR_INTERNAL:
2568         return "Internal failure";
2569     case ZOOM_ERROR_TIMEOUT:
2570         return "Timeout";
2571     case ZOOM_ERROR_UNSUPPORTED_PROTOCOL:
2572         return "Unsupported protocol";
2573     default:
2574         return diagbib1_str (error);
2575     }
2576 }
2577
2578 ZOOM_API(int)
2579 ZOOM_connection_error_x (ZOOM_connection c, const char **cp,
2580                          const char **addinfo, const char **diagset)
2581 {
2582     int error = c->error;
2583     if (cp)
2584     {
2585         if (!c->diagset)
2586             *cp = ZOOM_diag_str(error);
2587 #if HAVE_GSOAP
2588         else if (!strcmp(c->diagset, "SRW"))
2589             *cp = yaz_srw_diag_str(error);
2590         else if (c->soap && !strcmp(c->diagset, "SOAP"))
2591         {
2592             const char **s = soap_faultstring(c->soap);
2593             if (s && *s)
2594                 *cp = *s;
2595             else
2596                 *cp = "unknown";
2597         }
2598 #endif
2599         else
2600             *cp = ZOOM_diag_str(error);
2601     }
2602     if (addinfo)
2603         *addinfo = c->addinfo ? c->addinfo : "";
2604     if (diagset)
2605         *diagset = c->diagset ? c->diagset : "";
2606     return c->error;
2607 }
2608
2609 ZOOM_API(int)
2610 ZOOM_connection_error (ZOOM_connection c, const char **cp,
2611                        const char **addinfo)
2612 {
2613     return ZOOM_connection_error_x(c, cp, addinfo, 0);
2614 }
2615
2616 static int ZOOM_connection_do_io(ZOOM_connection c, int mask)
2617 {
2618     ZOOM_Event event = 0;
2619     int r = cs_look(c->cs);
2620     yaz_log (LOG_DEBUG, "ZOOM_connection_do_io c=%p mask=%d cs_look=%d",
2621              c, mask, r);
2622
2623     if (r == CS_NONE)
2624     {
2625         event = ZOOM_Event_create (ZOOM_EVENT_CONNECT);
2626         set_ZOOM_error(c, ZOOM_ERROR_CONNECT, 0);
2627         do_close (c);
2628         ZOOM_connection_put_event (c, event);
2629     }
2630     else if (r == CS_CONNECT)
2631     {
2632         int ret;
2633         event = ZOOM_Event_create (ZOOM_EVENT_CONNECT);
2634
2635         ret = cs_rcvconnect (c->cs);
2636         yaz_log (LOG_DEBUG, "cs_rcvconnect returned %d", ret);
2637         if (ret == 1)
2638         {
2639             c->mask = ZOOM_SELECT_EXCEPT;
2640             if (c->cs->io_pending & CS_WANT_WRITE)
2641                 c->mask += ZOOM_SELECT_WRITE;
2642             if (c->cs->io_pending & CS_WANT_READ)
2643                 c->mask += ZOOM_SELECT_READ;
2644             ZOOM_connection_put_event (c, event);
2645         }
2646         else if (ret == 0)
2647         {
2648             ZOOM_connection_put_event (c, event);
2649             if (c->proto == PROTO_Z3950)
2650                 ZOOM_connection_send_init(c);
2651             else
2652             {
2653                 /* no init request for SRW .. */
2654                 assert (c->tasks->which == ZOOM_TASK_CONNECT);
2655                 ZOOM_connection_remove_task (c);
2656                 c->mask = 0;
2657                 ZOOM_connection_exec_task (c);
2658             }
2659             c->state = STATE_ESTABLISHED;
2660         }
2661         else
2662         {
2663             set_ZOOM_error(c, ZOOM_ERROR_CONNECT, 0);
2664             do_close (c);
2665             ZOOM_connection_put_event (c, event);
2666         }
2667     }
2668     else
2669     {
2670         if (mask & ZOOM_SELECT_READ)
2671             do_read (c);
2672         if (c->cs && (mask & ZOOM_SELECT_WRITE))
2673             do_write (c);
2674     }
2675     return 1;
2676 }
2677
2678 ZOOM_API(int)
2679 ZOOM_connection_last_event(ZOOM_connection cs)
2680 {
2681     if (!cs)
2682         return ZOOM_EVENT_NONE;
2683     return cs->last_event;
2684 }
2685
2686 ZOOM_API(int)
2687 ZOOM_event (int no, ZOOM_connection *cs)
2688 {
2689     int timeout = 5000;
2690 #if HAVE_SYS_POLL_H
2691     struct pollfd pollfds[1024];
2692     ZOOM_connection poll_cs[1024];
2693 #else
2694     struct timeval tv;
2695     fd_set input, output, except;
2696 #endif
2697     int i, r, nfds;
2698     int max_fd = 0;
2699
2700     for (i = 0; i<no; i++)
2701     {
2702         ZOOM_connection c = cs[i];
2703         ZOOM_Event event;
2704         if (c && (event = ZOOM_connection_get_event(c)))
2705         {
2706             ZOOM_Event_destroy (event);
2707             return i+1;
2708         }
2709     }
2710     for (i = 0; i<no; i++)
2711     {
2712         ZOOM_connection c = cs[i];
2713         ZOOM_Event event;
2714         if (c && ZOOM_connection_exec_task (c))
2715         {
2716             if ((event = ZOOM_connection_get_event(c)))
2717             {
2718                 ZOOM_Event_destroy (event);
2719                 return i+1;
2720             }
2721         }
2722     }
2723 #if HAVE_SYS_POLL_H
2724
2725 #else
2726     FD_ZERO (&input);
2727     FD_ZERO (&output);
2728     FD_ZERO (&except);
2729 #endif
2730     nfds = 0;
2731     for (i = 0; i<no; i++)
2732     {
2733         ZOOM_connection c = cs[i];
2734         int fd, mask;
2735         int this_timeout;
2736
2737         if (!c)
2738             continue;
2739         fd = z3950_connection_socket(c);
2740         mask = z3950_connection_mask(c);
2741
2742         if (fd == -1)
2743             continue;
2744         if (max_fd < fd)
2745             max_fd = fd;
2746
2747         this_timeout = ZOOM_options_get_int (c->options, "timeout", -1);
2748         if (this_timeout != -1 && this_timeout < timeout)
2749             timeout = this_timeout;
2750 #if HAVE_SYS_POLL_H
2751         if (mask)
2752         {
2753             short poll_events = 0;
2754
2755             if (mask & ZOOM_SELECT_READ)
2756                 poll_events += POLLIN;
2757             if (mask & ZOOM_SELECT_WRITE)
2758                 poll_events += POLLOUT;
2759             if (mask & ZOOM_SELECT_EXCEPT)
2760                 poll_events += POLLERR;
2761             pollfds[nfds].fd = fd;
2762             pollfds[nfds].events = poll_events;
2763             pollfds[nfds].revents = 0;
2764             poll_cs[nfds] = c;
2765             nfds++;
2766         }
2767 #else
2768         if (mask & ZOOM_SELECT_READ)
2769         {
2770             FD_SET (fd, &input);
2771             nfds++;
2772         }
2773         if (mask & ZOOM_SELECT_WRITE)
2774         {
2775             FD_SET (fd, &output);
2776             nfds++;
2777         }
2778         if (mask & ZOOM_SELECT_EXCEPT)
2779         {
2780             FD_SET (fd, &except);
2781             nfds++;
2782         }
2783 #endif
2784     }
2785     if (timeout >= 5000)
2786         timeout = 30;
2787
2788     if (!nfds)
2789         return 0;
2790
2791 #if HAVE_SYS_POLL_H
2792     r = poll (pollfds, nfds, timeout * 1000);
2793     for (i = 0; i<nfds; i++)
2794     {
2795         ZOOM_connection c = poll_cs[i];
2796         if (r && c->mask)
2797         {
2798             int mask = 0;
2799             if (pollfds[i].revents & POLLIN)
2800                 mask += ZOOM_SELECT_READ;
2801             if (pollfds[i].revents & POLLOUT)
2802                 mask += ZOOM_SELECT_WRITE;
2803             if (pollfds[i].revents & POLLERR)
2804                 mask += ZOOM_SELECT_EXCEPT;
2805             if (mask)
2806                 ZOOM_connection_do_io(c, mask);
2807         }
2808         else if (r == 0 && c->mask)
2809         {
2810             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_TIMEOUT);
2811             /* timeout and this connection was waiting */
2812             set_ZOOM_error(c, ZOOM_ERROR_TIMEOUT, 0);
2813             do_close (c);
2814             ZOOM_connection_put_event(c, event);
2815         }
2816     }
2817 #else
2818     tv.tv_sec = timeout;
2819     tv.tv_usec = 0;
2820     yaz_log (LOG_DEBUG, "select start");
2821     r = select (max_fd+1, &input, &output, &except, &tv);
2822     yaz_log (LOG_DEBUG, "select stop, returned r=%d", r);
2823     for (i = 0; i<no; i++)
2824     {
2825         ZOOM_connection c = cs[i];
2826         int fd, mask;
2827
2828         if (!c)
2829             continue;
2830         fd = z3950_connection_socket(c);
2831         mask = 0;
2832         if (r && c->mask)
2833         {
2834             /* no timeout and real socket */
2835             if (FD_ISSET(fd, &input))
2836                 mask += ZOOM_SELECT_READ;
2837             if (FD_ISSET(fd, &output))
2838                 mask += ZOOM_SELECT_WRITE;
2839             if (FD_ISSET(fd, &except))
2840                 mask += ZOOM_SELECT_EXCEPT;
2841             if (mask)
2842                 ZOOM_connection_do_io(c, mask);
2843         }
2844         if (r == 0 && c->mask)
2845         {
2846             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_TIMEOUT);
2847             /* timeout and this connection was waiting */
2848             set_ZOOM_error(c, ZOOM_ERROR_TIMEOUT, 0);
2849             do_close (c);
2850             yaz_log (LOG_DEBUG, "timeout");
2851             ZOOM_connection_put_event(c, event);
2852         }
2853     }
2854 #endif
2855     for (i = 0; i<no; i++)
2856     {
2857         ZOOM_connection c = cs[i];
2858         ZOOM_Event event;
2859         if (c && (event = ZOOM_connection_get_event(c)))
2860         {
2861             ZOOM_Event_destroy (event);
2862             return i+1;
2863         }
2864     }
2865     return 0;
2866 }