src/zoom-c.c

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