src/zoom-c.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2013 Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /**
   6  * \file zoom-c.c
   7  * \brief Implements ZOOM C interface.
   8  */
   9 #if HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12
  13 #include <assert.h>
  14 #include <string.h>
  15 #include <errno.h>
  16 #include "zoom-p.h"
  17
  18 #include <yaz/yaz-util.h>
  19 #include <yaz/xmalloc.h>
  20 #include <yaz/otherinfo.h>
  21 #include <yaz/log.h>
  22 #include <yaz/diagbib1.h>
  23 #include <yaz/charneg.h>
  24 #include <yaz/query-charset.h>
  25 #include <yaz/snprintf.h>
  26 #include <yaz/facet.h>
  27
  28 #include <yaz/shptr.h>
  29
  30 #if SHPTR
  31 YAZ_SHPTR_TYPE(WRBUF)
  32 #endif
  33
  34 static int log_api0 = 0;
  35 static int log_details0 = 0;
  36
  37 static void resultset_destroy(ZOOM_resultset r);
  38 static zoom_ret do_write_ex(ZOOM_connection c, char *buf_out, int len_out);
  39
  40 static void initlog(void)
  41 {
  42     static int log_level_initialized = 0;
  43
  44     if (!log_level_initialized)
  45     {
  46         log_api0 = yaz_log_module_level("zoom");
  47         log_details0 = yaz_log_module_level("zoomdetails");
  48         log_level_initialized = 1;
  49     }
  50 }
  51
  52 void ZOOM_connection_remove_tasks(ZOOM_connection c);
  53
  54 void ZOOM_set_dset_error(ZOOM_connection c, int error,
  55                          const char *dset,
  56                          const char *addinfo, const char *addinfo2)
  57 {
  58     char *cp;
  59
  60     xfree(c->addinfo);
  61     c->addinfo = 0;
  62     c->error = error;
  63     if (!c->diagset || strcmp(dset, c->diagset))
  64     {
  65         xfree(c->diagset);
  66         c->diagset = xstrdup(dset);
  67         /* remove integer part from SRW diagset .. */
  68         if ((cp = strrchr(c->diagset, '/')))
  69             *cp = '\0';
  70     }
  71     if (addinfo && addinfo2)
  72     {
  73         c->addinfo = (char*) xmalloc(strlen(addinfo) + strlen(addinfo2) + 3);
  74         strcpy(c->addinfo, addinfo);
  75         strcat(c->addinfo, ": ");
  76         strcat(c->addinfo, addinfo2);
  77     }
  78     else if (addinfo)
  79         c->addinfo = xstrdup(addinfo);
  80     if (error != ZOOM_ERROR_NONE)
  81     {
  82         yaz_log(c->log_api, "%p set_dset_error %s %s:%d %s %s",
  83                 c, c->host_port ? c->host_port : "<>", dset, error,
  84                 addinfo ? addinfo : "",
  85                 addinfo2 ? addinfo2 : "");
  86         ZOOM_connection_remove_tasks(c);
  87     }
  88 }
  89
  90 int ZOOM_uri_to_code(const char *uri)
  91 {
  92     int code = 0;
  93     const char *cp;
  94     if ((cp = strrchr(uri, '/')))
  95         code = atoi(cp+1);
  96     return code;
  97 }
  98
  99
 100
 101 void ZOOM_set_error(ZOOM_connection c, int error, const char *addinfo)
 102 {
 103     ZOOM_set_dset_error(c, error, "ZOOM", addinfo, 0);
 104 }
 105
 106 static void clear_error(ZOOM_connection c)
 107 {
 108     /*
 109      * If an error is tied to an operation then it's ok to clear: for
 110      * example, a diagnostic returned from a search is cleared by a
 111      * subsequent search.  However, problems such as Connection Lost
 112      * or Init Refused are not cleared, because they are not
 113      * recoverable: doing another search doesn't help.
 114      */
 115
 116     ZOOM_connection_remove_events(c);
 117     switch (c->error)
 118     {
 119     case ZOOM_ERROR_CONNECT:
 120     case ZOOM_ERROR_MEMORY:
 121     case ZOOM_ERROR_DECODE:
 122     case ZOOM_ERROR_CONNECTION_LOST:
 123     case ZOOM_ERROR_INIT:
 124     case ZOOM_ERROR_INTERNAL:
 125     case ZOOM_ERROR_UNSUPPORTED_PROTOCOL:
 126         break;
 127     default:
 128         ZOOM_set_error(c, ZOOM_ERROR_NONE, 0);
 129     }
 130 }
 131
 132 void ZOOM_connection_show_task(ZOOM_task task)
 133 {
 134     switch(task->which)
 135     {
 136     case ZOOM_TASK_SEARCH:
 137         yaz_log(YLOG_LOG, "search p=%p", task);
 138         break;
 139     case ZOOM_TASK_RETRIEVE:
 140         yaz_log(YLOG_LOG, "retrieve p=%p", task);
 141         break;
 142     case ZOOM_TASK_CONNECT:
 143         yaz_log(YLOG_LOG, "connect p=%p", task);
 144         break;
 145     case ZOOM_TASK_SCAN:
 146         yaz_log(YLOG_LOG, "scan p=%p", task);
 147         break;
 148     }
 149 }
 150
 151 void ZOOM_connection_show_tasks(ZOOM_connection c)
 152 {
 153     ZOOM_task task;
 154     yaz_log(YLOG_LOG, "connection p=%p tasks", c);
 155     for (task = c->tasks; task; task = task->next)
 156         ZOOM_connection_show_task(task);
 157 }
 158
 159 ZOOM_task ZOOM_connection_add_task(ZOOM_connection c, int which)
 160 {
 161     ZOOM_task *taskp = &c->tasks;
 162     while (*taskp)
 163         taskp = &(*taskp)->next;
 164     *taskp = (ZOOM_task) xmalloc(sizeof(**taskp));
 165     (*taskp)->running = 0;
 166     (*taskp)->which = which;
 167     (*taskp)->next = 0;
 168     clear_error(c);
 169     return *taskp;
 170 }
 171
 172 ZOOM_API(int) ZOOM_connection_is_idle(ZOOM_connection c)
 173 {
 174     return c->tasks ? 0 : 1;
 175 }
 176
 177 ZOOM_task ZOOM_connection_insert_task(ZOOM_connection c, int which)
 178 {
 179     ZOOM_task task = (ZOOM_task) xmalloc(sizeof(*task));
 180
 181     task->next = c->tasks;
 182     c->tasks = task;
 183
 184     task->running = 0;
 185     task->which = which;
 186     return task;
 187 }
 188
 189 void ZOOM_connection_remove_task(ZOOM_connection c)
 190 {
 191     ZOOM_task task = c->tasks;
 192
 193     if (task)
 194     {
 195         c->tasks = task->next;
 196         switch (task->which)
 197         {
 198         case ZOOM_TASK_SEARCH:
 199             resultset_destroy(task->u.search.resultset);
 200             xfree(task->u.search.syntax);
 201             xfree(task->u.search.elementSetName);
 202             break;
 203         case ZOOM_TASK_RETRIEVE:
 204             resultset_destroy(task->u.retrieve.resultset);
 205             xfree(task->u.retrieve.syntax);
 206             xfree(task->u.retrieve.elementSetName);
 207             break;
 208         case ZOOM_TASK_CONNECT:
 209             break;
 210         case ZOOM_TASK_SCAN:
 211             ZOOM_scanset_destroy(task->u.scan.scan);
 212             break;
 213         case ZOOM_TASK_PACKAGE:
 214             ZOOM_package_destroy(task->u.package);
 215             break;
 216         case ZOOM_TASK_SORT:
 217             resultset_destroy(task->u.sort.resultset);
 218             ZOOM_query_destroy(task->u.sort.q);
 219             break;
 220         default:
 221             assert(0);
 222         }
 223         xfree(task);
 224
 225         if (!c->tasks)
 226         {
 227             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_END);
 228             ZOOM_connection_put_event(c, event);
 229         }
 230     }
 231 }
 232
 233 void ZOOM_connection_remove_tasks(ZOOM_connection c)
 234 {
 235     while (c->tasks)
 236         ZOOM_connection_remove_task(c);
 237 }
 238
 239 static void odr_wrbuf_write(ODR o, void *handle, int type,
 240                             const char *buf, int len)
 241 {
 242     WRBUF w = (WRBUF) handle;
 243     wrbuf_write(w, buf, len);
 244 }
 245
 246 ZOOM_API(ZOOM_connection)
 247     ZOOM_connection_create(ZOOM_options options)
 248 {
 249     ZOOM_connection c = (ZOOM_connection) xmalloc(sizeof(*c));
 250
 251     initlog();
 252
 253     c->log_api = log_api0;
 254     c->log_details = log_details0;
 255
 256     yaz_log(c->log_api, "%p ZOOM_connection_create", c);
 257
 258     c->proto = PROTO_Z3950;
 259     c->cs = 0;
 260     ZOOM_connection_set_mask(c, 0);
 261     c->reconnect_ok = 0;
 262     c->state = STATE_IDLE;
 263     c->addinfo = 0;
 264     c->diagset = 0;
 265     ZOOM_set_error(c, ZOOM_ERROR_NONE, 0);
 266     c->buf_in = 0;
 267     c->len_in = 0;
 268     c->buf_out = 0;
 269     c->len_out = 0;
 270     c->resultsets = 0;
 271
 272     c->options = ZOOM_options_create_with_parent(options);
 273
 274     c->host_port = 0;
 275     c->proxy = 0;
 276     c->tproxy = 0;
 277
 278     c->charset = c->lang = 0;
 279
 280     c->cookie_out = 0;
 281     c->cookie_in = 0;
 282     c->client_IP = 0;
 283     c->tasks = 0;
 284
 285     c->user = 0;
 286     c->group = 0;
 287     c->password = 0;
 288
 289     c->maximum_record_size = 0;
 290     c->preferred_message_size = 0;
 291
 292     c->odr_in = odr_createmem(ODR_DECODE);
 293     c->odr_out = odr_createmem(ODR_ENCODE);
 294     c->odr_print = 0;
 295     c->odr_save = 0;
 296
 297     c->async = 0;
 298     c->support_named_resultsets = 0;
 299     c->last_event = ZOOM_EVENT_NONE;
 300
 301     c->m_queue_front = 0;
 302     c->m_queue_back = 0;
 303
 304     c->sru_version = 0;
 305     c->no_redirects = 0;
 306     c->saveAPDU_wrbuf = 0;
 307     return c;
 308 }
 309
 310 ZOOM_API(void) ZOOM_connection_save_apdu_wrbuf(ZOOM_connection c, WRBUF w)
 311 {
 312     if (c->odr_save)
 313     {
 314         odr_destroy(c->odr_save);
 315         c->odr_save = 0;
 316     }
 317     if (w)
 318     {
 319         c->odr_save = odr_createmem(ODR_PRINT);
 320         odr_set_stream(c->odr_save, w, odr_wrbuf_write, 0);
 321     }
 322 }
 323
 324 /* set database names. Take local databases (if set); otherwise
 325    take databases given in ZURL (if set); otherwise use Default */
 326 char **ZOOM_connection_get_databases(ZOOM_connection con, ZOOM_options options,
 327                                      int *num, ODR odr)
 328 {
 329     char **databaseNames;
 330     const char *cp = ZOOM_options_get(options, "databaseName");
 331
 332     if ((!cp || !*cp) && con->host_port)
 333         cs_get_host_args(con->host_port, &cp);
 334     if (!cp || !*cp)
 335         cp = "Default";
 336     nmem_strsplit(odr_getmem(odr), "+", cp,  &databaseNames, num);
 337     return databaseNames;
 338 }
 339
 340 ZOOM_API(ZOOM_connection)
 341     ZOOM_connection_new(const char *host, int portnum)
 342 {
 343     ZOOM_connection c = ZOOM_connection_create(0);
 344
 345     ZOOM_connection_connect(c, host, portnum);
 346     return c;
 347 }
 348
 349 static zoom_sru_mode get_sru_mode_from_string(const char *s)
 350 {
 351     if (!s || !*s)
 352         return zoom_sru_soap;
 353     if (!yaz_matchstr(s, "soap"))
 354         return zoom_sru_soap;
 355     else if (!yaz_matchstr(s, "get"))
 356         return zoom_sru_get;
 357     else if (!yaz_matchstr(s, "post"))
 358         return zoom_sru_post;
 359     else if (!yaz_matchstr(s, "solr"))
 360         return zoom_sru_solr;
 361     return zoom_sru_error;
 362 }
 363
 364 ZOOM_API(void)
 365     ZOOM_connection_connect(ZOOM_connection c,
 366                             const char *host, int portnum)
 367 {
 368     const char *val;
 369
 370     initlog();
 371
 372     yaz_log(c->log_api, "%p ZOOM_connection_connect host=%s portnum=%d",
 373             c, host ? host : "null", portnum);
 374
 375     ZOOM_set_error(c, ZOOM_ERROR_NONE, 0);
 376     ZOOM_connection_remove_tasks(c);
 377
 378     if (c->odr_print)
 379     {
 380         odr_setprint(c->odr_print, 0); /* prevent destroy from fclose'ing */
 381         odr_destroy(c->odr_print);
 382     }
 383     if (ZOOM_options_get_bool(c->options, "apdulog", 0))
 384     {
 385         c->odr_print = odr_createmem(ODR_PRINT);
 386         odr_setprint(c->odr_print, yaz_log_file());
 387     }
 388     else
 389         c->odr_print = 0;
 390
 391     if (c->cs)
 392     {
 393         yaz_log(c->log_details, "%p ZOOM_connection_connect reconnect ok", c);
 394         c->reconnect_ok = 1;
 395         return;
 396     }
 397     yaz_log(c->log_details, "%p ZOOM_connection_connect connect", c);
 398     xfree(c->proxy);
 399     c->proxy = 0;
 400     val = ZOOM_options_get(c->options, "proxy");
 401     if (val && *val)
 402     {
 403         yaz_log(c->log_details, "%p ZOOM_connection_connect proxy=%s", c, val);
 404         c->proxy = xstrdup(val);
 405     }
 406
 407     xfree(c->tproxy);
 408     c->tproxy = 0;
 409     val = ZOOM_options_get(c->options, "tproxy");
 410     if (val && *val)
 411     {
 412         yaz_log(c->log_details, "%p ZOOM_connection_connect tproxy=%s", c, val);
 413         c->tproxy = xstrdup(val);
 414     }
 415
 416     xfree(c->charset);
 417     c->charset = 0;
 418     val = ZOOM_options_get(c->options, "charset");
 419     if (val && *val)
 420     {
 421         yaz_log(c->log_details, "%p ZOOM_connection_connect charset=%s", c, val);
 422         c->charset = xstrdup(val);
 423     }
 424
 425     xfree(c->lang);
 426     val = ZOOM_options_get(c->options, "lang");
 427     if (val && *val)
 428     {
 429         yaz_log(c->log_details, "%p ZOOM_connection_connect lang=%s", c, val);
 430         c->lang = xstrdup(val);
 431     }
 432     else
 433         c->lang = 0;
 434
 435     if (host)
 436     {
 437         xfree(c->host_port);
 438         if (portnum)
 439         {
 440             char hostn[128];
 441             sprintf(hostn, "%.80s:%d", host, portnum);
 442             c->host_port = xstrdup(hostn);
 443         }
 444         else
 445             c->host_port = xstrdup(host);
 446     }
 447
 448     {
 449         /*
 450          * If the "<scheme>:" part of the host string is preceded by one
 451          * or more comma-separated <name>=<value> pairs, these are taken
 452          * to be options to be set on the connection object.  Among other
 453          * applications, this facility can be used to embed authentication
 454          * in a host string:
 455          *          user=admin,password=secret,tcp:localhost:9999
 456          */
 457         char *remainder = c->host_port;
 458         char *pcolon = strchr(remainder, ':');
 459         char *pcomma;
 460         char *pequals;
 461         while ((pcomma = strchr(remainder, ',')) != 0 &&
 462                (pcolon == 0 || pcomma < pcolon))
 463         {
 464             *pcomma = '\0';
 465             if ((pequals = strchr(remainder, '=')) != 0)
 466             {
 467                 *pequals = '\0';
 468                 ZOOM_connection_option_set(c, remainder, pequals+1);
 469             }
 470             remainder = pcomma+1;
 471         }
 472
 473         if (remainder != c->host_port)
 474         {
 475             remainder = xstrdup(remainder);
 476             xfree(c->host_port);
 477             c->host_port = remainder;
 478         }
 479     }
 480
 481     val = ZOOM_options_get(c->options, "sru");
 482     c->sru_mode = get_sru_mode_from_string(val);
 483
 484     xfree(c->sru_version);
 485     val = ZOOM_options_get(c->options, "sru_version");
 486     c->sru_version = xstrdup(val ? val : "1.2");
 487
 488     ZOOM_options_set(c->options, "host", c->host_port);
 489
 490     xfree(c->cookie_out);
 491     c->cookie_out = 0;
 492     val = ZOOM_options_get(c->options, "cookie");
 493     if (val && *val)
 494     {
 495         yaz_log(c->log_details, "%p ZOOM_connection_connect cookie=%s", c, val);
 496         c->cookie_out = xstrdup(val);
 497     }
 498
 499     xfree(c->client_IP);
 500     c->client_IP = 0;
 501     val = ZOOM_options_get(c->options, "clientIP");
 502     if (val && *val)
 503     {
 504         yaz_log(c->log_details, "%p ZOOM_connection_connect clientIP=%s",
 505                 c, val);
 506         c->client_IP = xstrdup(val);
 507     }
 508
 509     xfree(c->group);
 510     c->group = 0;
 511     val = ZOOM_options_get(c->options, "group");
 512     if (val && *val)
 513         c->group = xstrdup(val);
 514
 515     xfree(c->user);
 516     c->user = 0;
 517     val = ZOOM_options_get(c->options, "user");
 518     if (val && *val)
 519         c->user = xstrdup(val);
 520
 521     xfree(c->password);
 522     c->password = 0;
 523     val = ZOOM_options_get(c->options, "password");
 524     if (!val)
 525         val = ZOOM_options_get(c->options, "pass");
 526
 527     if (val && *val)
 528         c->password = xstrdup(val);
 529
 530     c->maximum_record_size =
 531         ZOOM_options_get_int(c->options, "maximumRecordSize", 64*1024*1024);
 532     c->preferred_message_size =
 533         ZOOM_options_get_int(c->options, "preferredMessageSize", 64*1024*1024);
 534
 535     c->async = ZOOM_options_get_bool(c->options, "async", 0);
 536
 537     if (c->sru_mode == zoom_sru_error)
 538     {
 539         ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_PROTOCOL, val);
 540         ZOOM_connection_remove_tasks(c);
 541         return;
 542     }
 543
 544     yaz_log(c->log_details, "%p ZOOM_connection_connect async=%d", c, c->async);
 545     ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 546
 547     if (!c->async)
 548     {
 549         while (ZOOM_event(1, &c))
 550             ;
 551     }
 552 }
 553
 554 ZOOM_API(void) ZOOM_resultset_release(ZOOM_resultset r)
 555 {
 556 #if ZOOM_RESULT_LISTS
 557 #else
 558     if (r->connection)
 559     {
 560         /* remove ourselves from the resultsets in connection */
 561         ZOOM_resultset *rp = &r->connection->resultsets;
 562         while (1)
 563         {
 564             assert(*rp);   /* we must be in this list!! */
 565             if (*rp == r)
 566             {   /* OK, we're here - take us out of it */
 567                 *rp = (*rp)->next;
 568                 break;
 569             }
 570             rp = &(*rp)->next;
 571         }
 572         r->connection = 0;
 573     }
 574 #endif
 575 }
 576
 577 ZOOM_API(void)
 578     ZOOM_connection_destroy(ZOOM_connection c)
 579 {
 580 #if ZOOM_RESULT_LISTS
 581     ZOOM_resultsets list;
 582 #else
 583     ZOOM_resultset r;
 584 #endif
 585     if (!c)
 586         return;
 587     yaz_log(c->log_api, "%p ZOOM_connection_destroy", c);
 588     if (c->cs)
 589         cs_close(c->cs);
 590
 591 #if ZOOM_RESULT_LISTS
 592     /* Remove the connection's usage of resultsets */
 593     list = c->resultsets;
 594     while (list) {
 595         ZOOM_resultsets removed = list;
 596         ZOOM_resultset_destroy(list->resultset);
 597         list = list->next;
 598         xfree(removed);
 599     }
 600 #else
 601     for (r = c->resultsets; r; r = r->next)
 602         r->connection = 0;
 603 #endif
 604
 605     xfree(c->buf_in);
 606     xfree(c->addinfo);
 607     xfree(c->diagset);
 608     odr_destroy(c->odr_in);
 609     odr_destroy(c->odr_out);
 610     if (c->odr_save)
 611         odr_destroy(c->odr_save);
 612     if (c->odr_print)
 613     {
 614         odr_setprint(c->odr_print, 0); /* prevent destroy from fclose'ing */
 615         odr_destroy(c->odr_print);
 616     }
 617     ZOOM_options_destroy(c->options);
 618     ZOOM_connection_remove_tasks(c);
 619     ZOOM_connection_remove_events(c);
 620     xfree(c->host_port);
 621     xfree(c->proxy);
 622     xfree(c->tproxy);
 623     xfree(c->charset);
 624     xfree(c->lang);
 625     xfree(c->cookie_out);
 626     xfree(c->cookie_in);
 627     xfree(c->client_IP);
 628     xfree(c->user);
 629     xfree(c->group);
 630     xfree(c->password);
 631     xfree(c->sru_version);
 632     wrbuf_destroy(c->saveAPDU_wrbuf);
 633     xfree(c);
 634 }
 635
 636 void ZOOM_resultset_addref(ZOOM_resultset r)
 637 {
 638     if (r)
 639     {
 640         yaz_mutex_enter(r->mutex);
 641         (r->refcount)++;
 642         yaz_log(log_details0, "%p ZOOM_resultset_addref count=%d",
 643                 r, r->refcount);
 644         yaz_mutex_leave(r->mutex);
 645     }
 646 }
 647
 648 static int g_resultsets = 0;
 649 static YAZ_MUTEX g_resultset_mutex = 0;
 650
 651 /* TODO We need to initialize this before running threaded:
 652  * call resultset_use(0)  */
 653
 654 static int resultset_use(int delta) {
 655     int resultset_count;
 656     if (g_resultset_mutex == 0)
 657         yaz_mutex_create(&g_resultset_mutex);
 658     yaz_mutex_enter(g_resultset_mutex);
 659     g_resultsets += delta;
 660     resultset_count = g_resultsets;
 661     yaz_mutex_leave(g_resultset_mutex);
 662     return resultset_count;
 663 }
 664
 665 int resultsets_count(void) {
 666     return resultset_use(0);
 667 }
 668
 669 ZOOM_resultset ZOOM_resultset_create(void)
 670 {
 671     int i;
 672     ZOOM_resultset r = (ZOOM_resultset) xmalloc(sizeof(*r));
 673
 674     initlog();
 675
 676     yaz_log(log_details0, "%p ZOOM_resultset_create", r);
 677     r->refcount = 1;
 678     r->size = 0;
 679     r->odr = odr_createmem(ODR_ENCODE);
 680     r->piggyback = 1;
 681     r->setname = 0;
 682     r->schema = 0;
 683     r->step = 0;
 684     for (i = 0; i<RECORD_HASH_SIZE; i++)
 685         r->record_hash[i] = 0;
 686     r->r_sort_spec = 0;
 687     r->query = 0;
 688     r->connection = 0;
 689     r->databaseNames = 0;
 690     r->num_databaseNames = 0;
 691     r->facets = 0;
 692     r->num_facets = 0;
 693     r->facets_names = 0;
 694     r->mutex = 0;
 695     yaz_mutex_create(&r->mutex);
 696 #if SHPTR
 697     {
 698         WRBUF w = wrbuf_alloc();
 699         YAZ_SHPTR_INIT(r->record_wrbuf, w);
 700     }
 701 #endif
 702     resultset_use(1);
 703     return r;
 704 }
 705
 706 ZOOM_API(ZOOM_resultset)
 707     ZOOM_connection_search_pqf(ZOOM_connection c, const char *q)
 708 {
 709     ZOOM_resultset r;
 710     ZOOM_query s = ZOOM_query_create();
 711
 712     ZOOM_query_prefix(s, q);
 713
 714     r = ZOOM_connection_search(c, s);
 715     ZOOM_query_destroy(s);
 716     return r;
 717 }
 718
 719 ZOOM_API(ZOOM_resultset)
 720     ZOOM_connection_search(ZOOM_connection c, ZOOM_query q)
 721 {
 722     ZOOM_resultset r = ZOOM_resultset_create();
 723     ZOOM_task task;
 724     const char *cp;
 725     int start, count;
 726     const char *syntax, *elementSetName;
 727 #if ZOOM_RESULT_LISTS
 728     ZOOM_resultsets set;
 729 #endif
 730
 731     yaz_log(c->log_api, "%p ZOOM_connection_search set %p query %p", c, r, q);
 732     r->r_sort_spec = ZOOM_query_get_sortspec(q);
 733     r->query = q;
 734
 735     r->options = ZOOM_options_create_with_parent(c->options);
 736
 737     start = ZOOM_options_get_int(r->options, "start", 0);
 738     count = ZOOM_options_get_int(r->options, "count", 0);
 739     {
 740         /* If "presentChunk" is defined use that; otherwise "step" */
 741         const char *cp = ZOOM_options_get(r->options, "presentChunk");
 742         r->step = ZOOM_options_get_int(r->options,
 743                                        (cp != 0 ? "presentChunk": "step"), 0);
 744     }
 745     r->piggyback = ZOOM_options_get_bool(r->options, "piggyback", 1);
 746     cp = ZOOM_options_get(r->options, "setname");
 747     if (cp)
 748         r->setname = xstrdup(cp);
 749     cp = ZOOM_options_get(r->options, "schema");
 750     if (cp)
 751         r->schema = xstrdup(cp);
 752
 753     r->databaseNames = ZOOM_connection_get_databases(c, c->options, &r->num_databaseNames,
 754                                          r->odr);
 755
 756     r->connection = c;
 757
 758 #if ZOOM_RESULT_LISTS
 759     yaz_log(log_details, "%p ZOOM_connection_search: Adding new resultset (%p) to resultsets (%p) ", c, r, c->resultsets);
 760     set = xmalloc(sizeof(*set));
 761     ZOOM_resultset_addref(r);
 762     set->resultset = r;
 763     set->next = c->resultsets;
 764     c->resultsets = set;
 765 #else
 766     r->next = c->resultsets;
 767     c->resultsets = r;
 768 #endif
 769     if (c->host_port && c->proto == PROTO_HTTP)
 770     {
 771         if (!c->cs)
 772         {
 773             yaz_log(c->log_details, "ZOOM_connection_search: no comstack");
 774             ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 775         }
 776         else
 777         {
 778             yaz_log(c->log_details, "ZOOM_connection_search: reconnect");
 779             c->reconnect_ok = 1;
 780         }
 781     }
 782
 783     task = ZOOM_connection_add_task(c, ZOOM_TASK_SEARCH);
 784     task->u.search.resultset = r;
 785     task->u.search.start = start;
 786     task->u.search.count = count;
 787     task->u.search.recv_search_fired = 0;
 788
 789     syntax = ZOOM_options_get(r->options, "preferredRecordSyntax");
 790     task->u.search.syntax = syntax ? xstrdup(syntax) : 0;
 791     elementSetName = ZOOM_options_get(r->options, "elementSetName");
 792     task->u.search.elementSetName = elementSetName
 793         ? xstrdup(elementSetName) : 0;
 794
 795     ZOOM_resultset_addref(r);
 796
 797     ZOOM_query_addref(q);
 798
 799     if (!c->async)
 800     {
 801         while (ZOOM_event(1, &c))
 802             ;
 803     }
 804     return r;
 805 }
 806
 807 ZOOM_API(void)
 808     ZOOM_resultset_sort(ZOOM_resultset r,
 809                          const char *sort_type, const char *sort_spec)
 810 {
 811     (void) ZOOM_resultset_sort1(r, sort_type, sort_spec);
 812 }
 813
 814 ZOOM_API(int)
 815     ZOOM_resultset_sort1(ZOOM_resultset r,
 816                          const char *sort_type, const char *sort_spec)
 817 {
 818     ZOOM_connection c = r->connection;
 819     ZOOM_task task;
 820     ZOOM_query newq;
 821
 822     newq = ZOOM_query_create();
 823     if (ZOOM_query_sortby(newq, sort_spec) < 0)
 824         return -1;
 825
 826     yaz_log(c->log_api, "%p ZOOM_resultset_sort r=%p sort_type=%s sort_spec=%s",
 827             r, r, sort_type, sort_spec);
 828     if (!c)
 829         return 0;
 830
 831     if (c->host_port && c->proto == PROTO_HTTP)
 832     {
 833         if (!c->cs)
 834         {
 835             yaz_log(c->log_details, "%p ZOOM_resultset_sort: no comstack", r);
 836             ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 837         }
 838         else
 839         {
 840             yaz_log(c->log_details, "%p ZOOM_resultset_sort: prepare reconnect",
 841                     r);
 842             c->reconnect_ok = 1;
 843         }
 844     }
 845
 846     ZOOM_resultset_cache_reset(r);
 847     task = ZOOM_connection_add_task(c, ZOOM_TASK_SORT);
 848     task->u.sort.resultset = r;
 849     task->u.sort.q = newq;
 850
 851     ZOOM_resultset_addref(r);
 852
 853     if (!c->async)
 854     {
 855         while (ZOOM_event(1, &c))
 856             ;
 857     }
 858
 859     return 0;
 860 }
 861
 862 ZOOM_API(void)
 863     ZOOM_resultset_destroy(ZOOM_resultset r)
 864 {
 865     resultset_destroy(r);
 866 }
 867
 868 static void resultset_destroy(ZOOM_resultset r)
 869 {
 870     if (!r)
 871         return;
 872     yaz_mutex_enter(r->mutex);
 873     (r->refcount)--;
 874     yaz_log(log_details0, "%p ZOOM_resultset_destroy r=%p count=%d",
 875             r, r, r->refcount);
 876     if (r->refcount == 0)
 877     {
 878         yaz_mutex_leave(r->mutex);
 879
 880         yaz_log(log_details0, "%p ZOOM_connection resultset_destroy: Deleting resultset (%p) ", r->connection, r);
 881         ZOOM_resultset_cache_reset(r);
 882         ZOOM_resultset_release(r);
 883         ZOOM_query_destroy(r->query);
 884         ZOOM_options_destroy(r->options);
 885         odr_destroy(r->odr);
 886         xfree(r->setname);
 887         xfree(r->schema);
 888         yaz_mutex_destroy(&r->mutex);
 889 #if SHPTR
 890         YAZ_SHPTR_DEC(r->record_wrbuf, wrbuf_destroy);
 891 #endif
 892         resultset_use(-1);
 893         xfree(r);
 894     }
 895     else
 896         yaz_mutex_leave(r->mutex);
 897 }
 898
 899 ZOOM_API(size_t)
 900     ZOOM_resultset_size(ZOOM_resultset r)
 901 {
 902     return r->size;
 903 }
 904
 905 int ZOOM_test_reconnect(ZOOM_connection c)
 906 {
 907     ZOOM_Event event;
 908
 909     if (!c->reconnect_ok)
 910         return 0;
 911     ZOOM_connection_close(c);
 912     c->reconnect_ok = 0;
 913     c->tasks->running = 0;
 914     ZOOM_connection_insert_task(c, ZOOM_TASK_CONNECT);
 915
 916     event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
 917     ZOOM_connection_put_event(c, event);
 918
 919     return 1;
 920 }
 921
 922 static void ZOOM_resultset_retrieve(ZOOM_resultset r,
 923                                     int force_sync, int start, int count)
 924 {
 925     ZOOM_task task;
 926     ZOOM_connection c;
 927     const char *cp;
 928     const char *syntax, *elementSetName;
 929
 930     if (!r)
 931         return;
 932     yaz_log(log_details0, "%p ZOOM_resultset_retrieve force_sync=%d start=%d"
 933             " count=%d", r, force_sync, start, count);
 934     c = r->connection;
 935     if (!c)
 936         return;
 937
 938     if (c->host_port && c->proto == PROTO_HTTP)
 939     {
 940         if (!c->cs)
 941         {
 942             yaz_log(log_details0, "%p ZOOM_resultset_retrieve: no comstack", r);
 943             ZOOM_connection_add_task(c, ZOOM_TASK_CONNECT);
 944         }
 945         else
 946         {
 947             yaz_log(log_details0, "%p ZOOM_resultset_retrieve: prepare "
 948                     "reconnect", r);
 949             c->reconnect_ok = 1;
 950         }
 951     }
 952     task = ZOOM_connection_add_task(c, ZOOM_TASK_RETRIEVE);
 953     task->u.retrieve.resultset = r;
 954     task->u.retrieve.start = start;
 955     task->u.retrieve.count = count;
 956
 957     syntax = ZOOM_options_get(r->options, "preferredRecordSyntax");
 958     task->u.retrieve.syntax = syntax ? xstrdup(syntax) : 0;
 959     elementSetName = ZOOM_options_get(r->options, "elementSetName");
 960     task->u.retrieve.elementSetName = elementSetName
 961         ? xstrdup(elementSetName) : 0;
 962
 963     cp = ZOOM_options_get(r->options, "schema");
 964     if (cp)
 965     {
 966         if (!r->schema || strcmp(r->schema, cp))
 967         {
 968             xfree(r->schema);
 969             r->schema = xstrdup(cp);
 970         }
 971     }
 972
 973     ZOOM_resultset_addref(r);
 974
 975     if (!r->connection->async || force_sync)
 976         while (r->connection && ZOOM_event(1, &r->connection))
 977             ;
 978 }
 979
 980 ZOOM_API(void)
 981     ZOOM_resultset_records(ZOOM_resultset r, ZOOM_record *recs,
 982                            size_t start, size_t count)
 983 {
 984     int force_present = 0;
 985
 986     if (!r)
 987         return ;
 988     yaz_log(log_api0, "%p ZOOM_resultset_records r=%p start=%ld count=%ld",
 989             r, r, (long) start, (long) count);
 990     if (count && recs)
 991         force_present = 1;
 992     ZOOM_resultset_retrieve(r, force_present, start, count);
 993     if (force_present)
 994     {
 995         size_t i;
 996         for (i = 0; i< count; i++)
 997             recs[i] = ZOOM_resultset_record_immediate(r, i+start);
 998     }
 999 }
1000
1001 ZOOM_API(size_t)
1002     ZOOM_resultset_facets_size(ZOOM_resultset r) {
1003     return r->num_facets;
1004 }
1005
1006 ZOOM_API(ZOOM_facet_field)
1007     ZOOM_resultset_get_facet_field(ZOOM_resultset r, const char *name) {
1008     int num = r->num_facets;
1009     ZOOM_facet_field *facets = r->facets;
1010     int index;
1011     for (index = 0; index < num; index++) {
1012         if (!strcmp(facets[index]->facet_name, name)) {
1013             return facets[index];
1014         }
1015     }
1016     return 0;
1017 }
1018
1019 ZOOM_API(ZOOM_facet_field)
1020     ZOOM_resultset_get_facet_field_by_index(ZOOM_resultset r, int index) {
1021     int num = r->num_facets;
1022     ZOOM_facet_field *facets = r->facets;
1023     if (index >= 0 && index < num) {
1024         return facets[index];
1025     }
1026     return 0;
1027 }
1028
1029 ZOOM_API(ZOOM_facet_field *)
1030     ZOOM_resultset_facets(ZOOM_resultset r)
1031 {
1032     return r->facets;
1033 }
1034
1035 ZOOM_API(const char**)
1036     ZOOM_resultset_facets_names(ZOOM_resultset r)
1037 {
1038     return (const char **) r->facets_names;
1039 }
1040
1041 ZOOM_API(const char*)
1042     ZOOM_facet_field_name(ZOOM_facet_field field)
1043 {
1044     return field->facet_name;
1045 }
1046
1047 ZOOM_API(size_t)
1048     ZOOM_facet_field_term_count(ZOOM_facet_field field)
1049 {
1050     return field->num_terms;
1051 }
1052
1053 ZOOM_API(const char*)
1054     ZOOM_facet_field_get_term(ZOOM_facet_field field, size_t idx, int *freq) {
1055     *freq = field->facet_terms[idx].frequency;
1056     return field->facet_terms[idx].term;
1057 }
1058
1059
1060 static void get_cert(ZOOM_connection c)
1061 {
1062     char *cert_buf;
1063     int cert_len;
1064
1065     if (cs_get_peer_certificate_x509(c->cs, &cert_buf, &cert_len))
1066     {
1067         ZOOM_connection_option_setl(c, "sslPeerCert",
1068                                     cert_buf, cert_len);
1069         xfree(cert_buf);
1070     }
1071 }
1072
1073 static zoom_ret do_connect_host(ZOOM_connection c,
1074                                 const char *logical_url);
1075
1076 static zoom_ret do_connect(ZOOM_connection c)
1077 {
1078     return do_connect_host(c, c->host_port);
1079 }
1080
1081 static zoom_ret do_connect_host(ZOOM_connection c, const char *logical_url)
1082 {
1083     void *add;
1084
1085     if (c->cs)
1086         cs_close(c->cs);
1087     c->cs = cs_create_host_proxy(logical_url, 0, &add,
1088                                  c->tproxy ? c->tproxy : c->proxy);
1089
1090     if (c->cs && c->cs->protocol == PROTO_HTTP)
1091     {
1092 #if YAZ_HAVE_XML2
1093         c->proto = PROTO_HTTP;
1094 #else
1095         ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_PROTOCOL, "SRW");
1096         ZOOM_connection_close(c);
1097         return zoom_complete;
1098 #endif
1099     }
1100     if (c->cs)
1101     {
1102         int ret = cs_connect(c->cs, add);
1103         if (ret == 0)
1104         {
1105             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
1106             ZOOM_connection_put_event(c, event);
1107             get_cert(c);
1108             if (c->proto == PROTO_Z3950)
1109                 ZOOM_connection_Z3950_send_init(c);
1110             else
1111             {
1112                 /* no init request for SRW .. */
1113                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1114                 ZOOM_connection_remove_task(c);
1115                 ZOOM_connection_set_mask(c, 0);
1116                 ZOOM_connection_exec_task(c);
1117             }
1118             c->state = STATE_ESTABLISHED;
1119             return zoom_pending;
1120         }
1121         else if (ret > 0)
1122         {
1123             int mask = ZOOM_SELECT_EXCEPT;
1124             if (c->cs->io_pending & CS_WANT_WRITE)
1125                 mask += ZOOM_SELECT_WRITE;
1126             if (c->cs->io_pending & CS_WANT_READ)
1127                 mask += ZOOM_SELECT_READ;
1128             ZOOM_connection_set_mask(c, mask);
1129             c->state = STATE_CONNECTING;
1130             return zoom_pending;
1131         }
1132     }
1133     c->state = STATE_IDLE;
1134     ZOOM_set_error(c, ZOOM_ERROR_CONNECT, logical_url);
1135     return zoom_complete;
1136 }
1137
1138 /* returns 1 if PDU was sent OK (still pending )
1139    0 if PDU was not sent OK (nothing to wait for)
1140 */
1141
1142 ZOOM_API(ZOOM_record)
1143     ZOOM_resultset_record_immediate(ZOOM_resultset s,size_t pos)
1144 {
1145     const char *syntax =
1146         ZOOM_options_get(s->options, "preferredRecordSyntax");
1147     const char *elementSetName =
1148         ZOOM_options_get(s->options, "elementSetName");
1149
1150     return ZOOM_record_cache_lookup(s, pos, syntax, elementSetName);
1151 }
1152
1153 ZOOM_API(ZOOM_record)
1154     ZOOM_resultset_record(ZOOM_resultset r, size_t pos)
1155 {
1156     ZOOM_record rec = ZOOM_resultset_record_immediate(r, pos);
1157
1158     if (!rec)
1159     {
1160         /*
1161          * MIKE: I think force_sync should always be zero, but I don't
1162          * want to make this change until I get the go-ahead from
1163          * Adam, in case something depends on the old synchronous
1164          * behaviour.
1165          */
1166         int force_sync = 1;
1167         if (getenv("ZOOM_RECORD_NO_FORCE_SYNC")) force_sync = 0;
1168         ZOOM_resultset_retrieve(r, force_sync, pos, 1);
1169         rec = ZOOM_resultset_record_immediate(r, pos);
1170     }
1171     return rec;
1172 }
1173
1174 ZOOM_API(ZOOM_scanset)
1175     ZOOM_connection_scan(ZOOM_connection c, const char *start)
1176 {
1177     ZOOM_scanset s;
1178     ZOOM_query q = ZOOM_query_create();
1179
1180     ZOOM_query_prefix(q, start);
1181
1182     s = ZOOM_connection_scan1(c, q);
1183     ZOOM_query_destroy(q);
1184     return s;
1185
1186 }
1187
1188 ZOOM_API(ZOOM_scanset)
1189     ZOOM_connection_scan1(ZOOM_connection c, ZOOM_query q)
1190 {
1191     ZOOM_scanset scan = 0;
1192     Z_Query *z_query = ZOOM_query_get_Z_Query(q);
1193
1194     if (!z_query)
1195         return 0;
1196     scan = (ZOOM_scanset) xmalloc(sizeof(*scan));
1197     scan->connection = c;
1198     scan->odr = odr_createmem(ODR_DECODE);
1199     scan->options = ZOOM_options_create_with_parent(c->options);
1200     scan->refcount = 1;
1201     scan->scan_response = 0;
1202     scan->srw_scan_response = 0;
1203
1204     scan->query = q;
1205     ZOOM_query_addref(q);
1206     scan->databaseNames = ZOOM_connection_get_databases(c, c->options,
1207                                             &scan->num_databaseNames,
1208                                             scan->odr);
1209
1210     if (1)
1211     {
1212         ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_SCAN);
1213         task->u.scan.scan = scan;
1214
1215         (scan->refcount)++;
1216         if (!c->async)
1217         {
1218             while (ZOOM_event(1, &c))
1219                 ;
1220         }
1221     }
1222     return scan;
1223 }
1224
1225 ZOOM_API(void)
1226     ZOOM_scanset_destroy(ZOOM_scanset scan)
1227 {
1228     if (!scan)
1229         return;
1230     (scan->refcount)--;
1231     if (scan->refcount == 0)
1232     {
1233         ZOOM_query_destroy(scan->query);
1234
1235         odr_destroy(scan->odr);
1236
1237         ZOOM_options_destroy(scan->options);
1238         xfree(scan);
1239     }
1240 }
1241
1242 static zoom_ret send_package(ZOOM_connection c)
1243 {
1244     ZOOM_Event event;
1245
1246     yaz_log(c->log_details, "%p send_package", c);
1247     if (!c->tasks)
1248         return zoom_complete;
1249     assert (c->tasks->which == ZOOM_TASK_PACKAGE);
1250
1251     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
1252     ZOOM_connection_put_event(c, event);
1253
1254     c->buf_out = c->tasks->u.package->buf_out;
1255     c->len_out = c->tasks->u.package->len_out;
1256
1257     return ZOOM_send_buf(c);
1258 }
1259
1260 ZOOM_API(size_t)
1261     ZOOM_scanset_size(ZOOM_scanset scan)
1262 {
1263     if (!scan)
1264         return 0;
1265
1266     if (scan->scan_response && scan->scan_response->entries)
1267         return scan->scan_response->entries->num_entries;
1268     else if (scan->srw_scan_response)
1269         return scan->srw_scan_response->num_terms;
1270     return 0;
1271 }
1272
1273 static void ZOOM_scanset_term_x(ZOOM_scanset scan, size_t pos,
1274                                 size_t *occ,
1275                                 const char **value_term, size_t *value_len,
1276                                 const char **disp_term, size_t *disp_len)
1277 {
1278     size_t noent = ZOOM_scanset_size(scan);
1279
1280     *value_term = 0;
1281     *value_len = 0;
1282
1283     *disp_term = 0;
1284     *disp_len = 0;
1285
1286     *occ = 0;
1287     if (pos >= noent)
1288         return;
1289     if (scan->scan_response)
1290     {
1291         Z_ScanResponse *res = scan->scan_response;
1292         if (res->entries->entries[pos]->which == Z_Entry_termInfo)
1293         {
1294             Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
1295
1296             *value_term = (const char *) t->term->u.general->buf;
1297             *value_len = t->term->u.general->len;
1298             if (t->displayTerm)
1299             {
1300                 *disp_term = t->displayTerm;
1301                 *disp_len = strlen(*disp_term);
1302             }
1303             else if (t->term->which == Z_Term_general)
1304             {
1305                 *disp_term = (const char *) t->term->u.general->buf;
1306                 *disp_len = t->term->u.general->len;
1307             }
1308             *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
1309         }
1310     }
1311     if (scan->srw_scan_response)
1312     {
1313         Z_SRW_scanResponse *res = scan->srw_scan_response;
1314         Z_SRW_scanTerm *t = res->terms + pos;
1315         if (t)
1316         {
1317             *value_term = t->value;
1318             *value_len = strlen(*value_term);
1319
1320             if (t->displayTerm)
1321                 *disp_term = t->displayTerm;
1322             else
1323                 *disp_term = t->value;
1324             *disp_len = strlen(*disp_term);
1325             *occ = t->numberOfRecords ? *t->numberOfRecords : 0;
1326         }
1327     }
1328 }
1329
1330 ZOOM_API(const char *)
1331     ZOOM_scanset_term(ZOOM_scanset scan, size_t pos,
1332                       size_t *occ, size_t *len)
1333 {
1334     const char *value_term = 0;
1335     size_t value_len = 0;
1336     const char *disp_term = 0;
1337     size_t disp_len = 0;
1338
1339     ZOOM_scanset_term_x(scan, pos, occ, &value_term, &value_len,
1340                         &disp_term, &disp_len);
1341
1342     *len = value_len;
1343     return value_term;
1344 }
1345
1346 ZOOM_API(const char *)
1347     ZOOM_scanset_display_term(ZOOM_scanset scan, size_t pos,
1348                               size_t *occ, size_t *len)
1349 {
1350     const char *value_term = 0;
1351     size_t value_len = 0;
1352     const char *disp_term = 0;
1353     size_t disp_len = 0;
1354
1355     ZOOM_scanset_term_x(scan, pos, occ, &value_term, &value_len,
1356                         &disp_term, &disp_len);
1357
1358     *len = disp_len;
1359     return disp_term;
1360 }
1361
1362 ZOOM_API(const char *)
1363     ZOOM_scanset_option_get(ZOOM_scanset scan, const char *key)
1364 {
1365     return ZOOM_options_get(scan->options, key);
1366 }
1367
1368 ZOOM_API(void)
1369     ZOOM_scanset_option_set(ZOOM_scanset scan, const char *key,
1370                             const char *val)
1371 {
1372     ZOOM_options_set(scan->options, key, val);
1373 }
1374
1375
1376 ZOOM_API(ZOOM_package)
1377     ZOOM_connection_package(ZOOM_connection c, ZOOM_options options)
1378 {
1379     ZOOM_package p = (ZOOM_package) xmalloc(sizeof(*p));
1380
1381     p->connection = c;
1382     p->odr_out = odr_createmem(ODR_ENCODE);
1383     p->options = ZOOM_options_create_with_parent2(options, c->options);
1384     p->refcount = 1;
1385     p->buf_out = 0;
1386     p->len_out = 0;
1387     return p;
1388 }
1389
1390 ZOOM_API(void)
1391     ZOOM_package_destroy(ZOOM_package p)
1392 {
1393     if (!p)
1394         return;
1395     (p->refcount)--;
1396     if (p->refcount == 0)
1397     {
1398         odr_destroy(p->odr_out);
1399         xfree(p->buf_out);
1400
1401         ZOOM_options_destroy(p->options);
1402         xfree(p);
1403     }
1404 }
1405
1406 ZOOM_API(const char *)
1407     ZOOM_package_option_get(ZOOM_package p, const char *key)
1408 {
1409     return ZOOM_options_get(p->options, key);
1410 }
1411
1412 ZOOM_API(const char *)
1413     ZOOM_package_option_getl(ZOOM_package p, const char *key, int *lenp)
1414 {
1415     return ZOOM_options_getl(p->options, key, lenp);
1416 }
1417
1418 ZOOM_API(void)
1419     ZOOM_package_option_set(ZOOM_package p, const char *key,
1420                             const char *val)
1421 {
1422     ZOOM_options_set(p->options, key, val);
1423 }
1424
1425 ZOOM_API(void)
1426     ZOOM_package_option_setl(ZOOM_package p, const char *key,
1427                              const char *val, int len)
1428 {
1429     ZOOM_options_setl(p->options, key, val, len);
1430 }
1431
1432 ZOOM_API(int)
1433     ZOOM_connection_exec_task(ZOOM_connection c)
1434 {
1435     ZOOM_task task = c->tasks;
1436     zoom_ret ret = zoom_complete;
1437
1438     if (!task)
1439         return 0;
1440     yaz_log(c->log_details, "%p ZOOM_connection_exec_task type=%d run=%d",
1441             c, task->which, task->running);
1442     if (c->error != ZOOM_ERROR_NONE)
1443     {
1444         yaz_log(c->log_details, "%p ZOOM_connection_exec_task "
1445                 "removing tasks because of error = %d", c, c->error);
1446         ZOOM_connection_remove_tasks(c);
1447         return 0;
1448     }
1449     if (task->running)
1450     {
1451         yaz_log(c->log_details, "%p ZOOM_connection_exec_task "
1452                 "task already running", c);
1453         return 0;
1454     }
1455     task->running = 1;
1456     ret = zoom_complete;
1457     if (c->cs || task->which == ZOOM_TASK_CONNECT)
1458     {
1459         switch (task->which)
1460         {
1461         case ZOOM_TASK_SEARCH:
1462             if (c->proto == PROTO_HTTP)
1463                 ret = ZOOM_connection_srw_send_search(c);
1464             else
1465                 ret = ZOOM_connection_Z3950_send_search(c);
1466             break;
1467         case ZOOM_TASK_RETRIEVE:
1468             if (c->proto == PROTO_HTTP)
1469                 ret = ZOOM_connection_srw_send_search(c);
1470             else
1471                 ret = send_Z3950_present(c);
1472             break;
1473         case ZOOM_TASK_CONNECT:
1474             ret = do_connect(c);
1475             break;
1476         case ZOOM_TASK_SCAN:
1477             if (c->proto == PROTO_HTTP)
1478                 ret = ZOOM_connection_srw_send_scan(c);
1479             else
1480                 ret = ZOOM_connection_Z3950_send_scan(c);
1481             break;
1482         case ZOOM_TASK_PACKAGE:
1483             ret = send_package(c);
1484             break;
1485         case ZOOM_TASK_SORT:
1486             c->tasks->u.sort.resultset->r_sort_spec =
1487                 ZOOM_query_get_sortspec(c->tasks->u.sort.q);
1488             ret = send_Z3950_sort(c, c->tasks->u.sort.resultset);
1489             break;
1490         }
1491     }
1492     else
1493     {
1494         yaz_log(c->log_details, "%p ZOOM_connection_exec_task "
1495                 "remove tasks because no connection exist", c);
1496         ZOOM_connection_remove_tasks(c);
1497     }
1498     if (ret == zoom_complete)
1499     {
1500         yaz_log(c->log_details, "%p ZOOM_connection_exec_task "
1501                 "task removed (complete)", c);
1502         ZOOM_connection_remove_task(c);
1503         return 0;
1504     }
1505     yaz_log(c->log_details, "%p ZOOM_connection_exec_task "
1506             "task pending", c);
1507     return 1;
1508 }
1509
1510 #if YAZ_HAVE_XML2
1511
1512 static zoom_ret send_HTTP_redirect(ZOOM_connection c, const char *uri,
1513                                   Z_HTTP_Response *cookie_hres)
1514 {
1515     struct Z_HTTP_Header *h;
1516     char *combined_cookies = 0;
1517     int combined_cookies_len = 0;
1518     Z_GDU *gdu = z_get_HTTP_Request_uri(c->odr_out, uri, 0, c->proxy ? 1 : 0);
1519
1520     gdu->u.HTTP_Request->method = odr_strdup(c->odr_out, "GET");
1521     z_HTTP_header_add(c->odr_out, &gdu->u.HTTP_Request->headers, "Accept",
1522                       "text/xml");
1523
1524     for (h = cookie_hres->headers; h; h = h->next)
1525     {
1526         if (!strcmp(h->name, "Set-Cookie"))
1527         {
1528             char *cp;
1529
1530             if (!(cp = strchr(h->value, ';')))
1531                 cp = h->value + strlen(h->value);
1532             if (cp - h->value >= 1) {
1533                 combined_cookies = xrealloc(combined_cookies, combined_cookies_len + cp - h->value + 3);
1534                 memcpy(combined_cookies+combined_cookies_len, h->value, cp - h->value);
1535                 combined_cookies[combined_cookies_len + cp - h->value] = '\0';
1536                 strcat(combined_cookies,"; ");
1537                 combined_cookies_len = strlen(combined_cookies);
1538             }
1539         }
1540     }
1541
1542     if (combined_cookies_len)
1543     {
1544         z_HTTP_header_add(c->odr_out, &gdu->u.HTTP_Request->headers,
1545                           "Cookie", combined_cookies);
1546         xfree(combined_cookies);
1547     }
1548
1549     if (c->user && c->password)
1550     {
1551         z_HTTP_header_add_basic_auth(c->odr_out, &gdu->u.HTTP_Request->headers,
1552                                      c->user, c->password);
1553     }
1554     return ZOOM_send_GDU(c, gdu);
1555 }
1556
1557 zoom_ret ZOOM_send_GDU(ZOOM_connection c, Z_GDU *gdu)
1558 {
1559     ZOOM_Event event;
1560
1561     int r = z_GDU(c->odr_out, &gdu, 0, 0);
1562     if (!r)
1563         return zoom_complete;
1564     if (c->odr_print)
1565         z_GDU(c->odr_print, &gdu, 0, 0);
1566     if (c->odr_save)
1567         z_GDU(c->odr_save, &gdu, 0, 0);
1568     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
1569     odr_reset(c->odr_out);
1570
1571     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
1572     ZOOM_connection_put_event(c, event);
1573
1574     return ZOOM_send_buf(c);
1575 }
1576
1577 #if YAZ_HAVE_XML2
1578 void ZOOM_set_HTTP_error(ZOOM_connection c, int error,
1579                          const char *addinfo, const char *addinfo2)
1580 {
1581     ZOOM_set_dset_error(c, error, "HTTP", addinfo, addinfo2);
1582 }
1583 #endif
1584
1585
1586 static void handle_http(ZOOM_connection c, Z_HTTP_Response *hres)
1587 {
1588     zoom_ret cret = zoom_complete;
1589     int ret = -1;
1590     char *addinfo = 0;
1591     const char *connection_head = z_HTTP_header_lookup(hres->headers,
1592                                                        "Connection");
1593     const char *location;
1594
1595     ZOOM_connection_set_mask(c, 0);
1596     yaz_log(c->log_details, "%p handle_http", c);
1597
1598     if ((hres->code == 301 || hres->code == 302) && c->sru_mode == zoom_sru_get
1599         && (location = z_HTTP_header_lookup(hres->headers, "Location")))
1600     {
1601         c->no_redirects++;
1602         if (c->no_redirects > 10)
1603         {
1604             ZOOM_set_HTTP_error(c, hres->code, 0, 0);
1605             c->no_redirects = 0;
1606             ZOOM_connection_close(c);
1607         }
1608         else
1609         {
1610             /* since redirect may change host we just reconnect. A smarter
1611                implementation might check whether it's the same server */
1612             do_connect_host(c, location);
1613             send_HTTP_redirect(c, location, hres);
1614             /* we're OK for now. Operation is not really complete */
1615             return;
1616         }
1617     }
1618     else
1619     {
1620         ret = ZOOM_handle_sru(c, hres, &cret, &addinfo);
1621         if (ret == 0)
1622         {
1623             if (c->no_redirects) /* end of redirect. change hosts again */
1624                 ZOOM_connection_close(c);
1625         }
1626         c->no_redirects = 0;
1627     }
1628     if (ret)
1629     {
1630         if (hres->code != 200)
1631             ZOOM_set_HTTP_error(c, hres->code, 0, 0);
1632         else
1633         {
1634             yaz_log(YLOG_LOG, "set error... addinfo=%s", addinfo ?
1635                     addinfo : "NULL");
1636             ZOOM_set_error(c, ZOOM_ERROR_DECODE, addinfo);
1637         }
1638         ZOOM_connection_close(c);
1639     }
1640     if (cret == zoom_complete)
1641     {
1642         yaz_log(c->log_details, "removing tasks in handle_http");
1643         ZOOM_connection_remove_task(c);
1644     }
1645     {
1646         int must_close = 0;
1647         if (!strcmp(hres->version, "1.0"))
1648         {
1649             /* HTTP 1.0: only if Keep-Alive we stay alive.. */
1650             if (!connection_head || strcmp(connection_head, "Keep-Alive"))
1651                 must_close = 1;
1652         }
1653         else
1654         {
1655             /* HTTP 1.1: only if no close we stay alive.. */
1656             if (connection_head && !strcmp(connection_head, "close"))
1657                 must_close = 1;
1658         }
1659         if (must_close)
1660         {
1661             ZOOM_connection_close(c);
1662             if (c->tasks)
1663             {
1664                 c->tasks->running = 0;
1665                 ZOOM_connection_insert_task(c, ZOOM_TASK_CONNECT);
1666                 c->reconnect_ok = 0;
1667             }
1668         }
1669         else
1670             c->reconnect_ok = 1; /* if the server closes anyway */
1671     }
1672 }
1673 #endif
1674
1675 static int do_read(ZOOM_connection c)
1676 {
1677     int r, more;
1678     ZOOM_Event event;
1679
1680     event = ZOOM_Event_create(ZOOM_EVENT_RECV_DATA);
1681     ZOOM_connection_put_event(c, event);
1682
1683     r = cs_get(c->cs, &c->buf_in, &c->len_in);
1684     more = cs_more(c->cs);
1685     yaz_log(c->log_details, "%p do_read len=%d more=%d", c, r, more);
1686     if (r == 1)
1687         return 0;
1688     if (r <= 0)
1689     {
1690         if (!ZOOM_test_reconnect(c))
1691         {
1692             ZOOM_set_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
1693             ZOOM_connection_close(c);
1694         }
1695     }
1696     else
1697     {
1698         Z_GDU *gdu;
1699         ZOOM_Event event;
1700
1701         odr_reset(c->odr_in);
1702         odr_setbuf(c->odr_in, c->buf_in, r, 0);
1703         event = ZOOM_Event_create(ZOOM_EVENT_RECV_APDU);
1704         ZOOM_connection_put_event(c, event);
1705
1706         if (!z_GDU(c->odr_in, &gdu, 0, 0))
1707         {
1708             int x;
1709             int err = odr_geterrorx(c->odr_in, &x);
1710             char msg[100];
1711             const char *element = odr_getelement(c->odr_in);
1712             yaz_snprintf(msg, sizeof(msg),
1713                     "ODR code %d:%d element=%s offset=%d",
1714                     err, x, element ? element : "<unknown>",
1715                     odr_offset(c->odr_in));
1716             ZOOM_set_error(c, ZOOM_ERROR_DECODE, msg);
1717             if (c->log_api)
1718             {
1719                 FILE *ber_file = yaz_log_file();
1720                 if (ber_file)
1721                     odr_dumpBER(ber_file, c->buf_in, r);
1722             }
1723             ZOOM_connection_close(c);
1724         }
1725         else
1726         {
1727             if (c->odr_print)
1728                 z_GDU(c->odr_print, &gdu, 0, 0);
1729             if (c->odr_save)
1730                 z_GDU(c->odr_save, &gdu, 0, 0);
1731             if (gdu->which == Z_GDU_Z3950)
1732                 ZOOM_handle_Z3950_apdu(c, gdu->u.z3950);
1733             else if (gdu->which == Z_GDU_HTTP_Response)
1734             {
1735 #if YAZ_HAVE_XML2
1736                 handle_http(c, gdu->u.HTTP_Response);
1737 #else
1738                 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1739                 ZOOM_connection_close(c);
1740 #endif
1741             }
1742         }
1743     }
1744     return 1;
1745 }
1746
1747 static zoom_ret do_write_ex(ZOOM_connection c, char *buf_out, int len_out)
1748 {
1749     int r;
1750     ZOOM_Event event;
1751
1752     event = ZOOM_Event_create(ZOOM_EVENT_SEND_DATA);
1753     ZOOM_connection_put_event(c, event);
1754
1755     yaz_log(c->log_details, "%p do_write_ex len=%d", c, len_out);
1756     if ((r = cs_put(c->cs, buf_out, len_out)) < 0)
1757     {
1758         yaz_log(c->log_details, "%p do_write_ex write failed", c);
1759         if (ZOOM_test_reconnect(c))
1760         {
1761             return zoom_pending;
1762         }
1763         if (c->state == STATE_CONNECTING)
1764             ZOOM_set_error(c, ZOOM_ERROR_CONNECT, c->host_port);
1765         else
1766             ZOOM_set_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
1767         ZOOM_connection_close(c);
1768         return zoom_complete;
1769     }
1770     else if (r == 1)
1771     {
1772         int mask = ZOOM_SELECT_EXCEPT;
1773         if (c->cs->io_pending & CS_WANT_WRITE)
1774             mask += ZOOM_SELECT_WRITE;
1775         if (c->cs->io_pending & CS_WANT_READ)
1776             mask += ZOOM_SELECT_READ;
1777         ZOOM_connection_set_mask(c, mask);
1778         yaz_log(c->log_details, "%p do_write_ex write incomplete mask=%d",
1779                 c, c->mask);
1780     }
1781     else
1782     {
1783         ZOOM_connection_set_mask(c, ZOOM_SELECT_READ|ZOOM_SELECT_EXCEPT);
1784         yaz_log(c->log_details, "%p do_write_ex write complete mask=%d",
1785                 c, c->mask);
1786     }
1787     return zoom_pending;
1788 }
1789
1790 zoom_ret ZOOM_send_buf(ZOOM_connection c)
1791 {
1792     return do_write_ex(c, c->buf_out, c->len_out);
1793 }
1794
1795
1796 ZOOM_API(const char *)
1797     ZOOM_connection_option_get(ZOOM_connection c, const char *key)
1798 {
1799     if (!strcmp(key, "APDU"))
1800     {
1801         return c->saveAPDU_wrbuf ? wrbuf_cstr(c->saveAPDU_wrbuf) : "";
1802     }
1803     else
1804         return ZOOM_options_get(c->options, key);
1805 }
1806
1807 ZOOM_API(const char *)
1808     ZOOM_connection_option_getl(ZOOM_connection c, const char *key, int *lenp)
1809 {
1810     if (!strcmp(key, "APDU"))
1811     {
1812         if (c->saveAPDU_wrbuf)
1813         {
1814             *lenp = wrbuf_len(c->saveAPDU_wrbuf);
1815             return wrbuf_cstr(c->saveAPDU_wrbuf);
1816         }
1817         else
1818         {
1819             *lenp = 0;
1820             return "";
1821         }
1822     }
1823     else
1824         return ZOOM_options_getl(c->options, key, lenp);
1825 }
1826
1827 ZOOM_API(void)
1828     ZOOM_connection_option_set(ZOOM_connection c, const char *key,
1829                                const char *val)
1830 {
1831     if (!strcmp(key, "saveAPDU"))
1832     {
1833         if (val && strcmp(val, "0"))
1834         {
1835             if (!c->saveAPDU_wrbuf)
1836                 c->saveAPDU_wrbuf = wrbuf_alloc();
1837             else
1838                 wrbuf_rewind(c->saveAPDU_wrbuf);
1839         }
1840         else
1841         {
1842             wrbuf_destroy(c->saveAPDU_wrbuf);
1843             c->saveAPDU_wrbuf = 0;
1844         }
1845         ZOOM_connection_save_apdu_wrbuf(c, c->saveAPDU_wrbuf);
1846     }
1847     else
1848         ZOOM_options_set(c->options, key, val);
1849 }
1850
1851 ZOOM_API(void)
1852     ZOOM_connection_option_setl(ZOOM_connection c, const char *key,
1853                                 const char *val, int len)
1854 {
1855     ZOOM_options_setl(c->options, key, val, len);
1856 }
1857
1858 ZOOM_API(const char *)
1859     ZOOM_resultset_option_get(ZOOM_resultset r, const char *key)
1860 {
1861     return ZOOM_options_get(r->options, key);
1862 }
1863
1864 ZOOM_API(void)
1865     ZOOM_resultset_option_set(ZOOM_resultset r, const char *key,
1866                               const char *val)
1867 {
1868     ZOOM_options_set(r->options, key, val);
1869 }
1870
1871
1872 ZOOM_API(int)
1873     ZOOM_connection_errcode(ZOOM_connection c)
1874 {
1875     return ZOOM_connection_error(c, 0, 0);
1876 }
1877
1878 ZOOM_API(const char *)
1879     ZOOM_connection_errmsg(ZOOM_connection c)
1880 {
1881     const char *msg;
1882     ZOOM_connection_error(c, &msg, 0);
1883     return msg;
1884 }
1885
1886 ZOOM_API(const char *)
1887     ZOOM_connection_addinfo(ZOOM_connection c)
1888 {
1889     const char *addinfo;
1890     ZOOM_connection_error(c, 0, &addinfo);
1891     return addinfo;
1892 }
1893
1894 ZOOM_API(const char *)
1895     ZOOM_connection_diagset(ZOOM_connection c)
1896 {
1897     const char *diagset;
1898     ZOOM_connection_error_x(c, 0, 0, &diagset);
1899     return diagset;
1900 }
1901
1902 ZOOM_API(const char *)
1903     ZOOM_diag_str(int error)
1904 {
1905     switch (error)
1906     {
1907     case ZOOM_ERROR_NONE:
1908         return "No error";
1909     case ZOOM_ERROR_CONNECT:
1910         return "Connect failed";
1911     case ZOOM_ERROR_MEMORY:
1912         return "Out of memory";
1913     case ZOOM_ERROR_ENCODE:
1914         return "Encoding failed";
1915     case ZOOM_ERROR_DECODE:
1916         return "Decoding failed";
1917     case ZOOM_ERROR_CONNECTION_LOST:
1918         return "Connection lost";
1919     case ZOOM_ERROR_INIT:
1920         return "Init rejected";
1921     case ZOOM_ERROR_INTERNAL:
1922         return "Internal failure";
1923     case ZOOM_ERROR_TIMEOUT:
1924         return "Timeout";
1925     case ZOOM_ERROR_UNSUPPORTED_PROTOCOL:
1926         return "Unsupported protocol";
1927     case ZOOM_ERROR_UNSUPPORTED_QUERY:
1928         return "Unsupported query type";
1929     case ZOOM_ERROR_INVALID_QUERY:
1930         return "Invalid query";
1931     case ZOOM_ERROR_CQL_PARSE:
1932         return "CQL parsing error";
1933     case ZOOM_ERROR_CQL_TRANSFORM:
1934         return "CQL transformation error";
1935     case ZOOM_ERROR_CCL_CONFIG:
1936         return "CCL configuration error";
1937     case ZOOM_ERROR_CCL_PARSE:
1938         return "CCL parsing error";
1939     case ZOOM_ERROR_ES_INVALID_ACTION:
1940         return "Extended Service. invalid action";
1941     case ZOOM_ERROR_ES_INVALID_VERSION:
1942         return "Extended Service. invalid version";
1943     case ZOOM_ERROR_ES_INVALID_SYNTAX:
1944         return "Extended Service. invalid syntax";
1945     default:
1946         return diagbib1_str(error);
1947     }
1948 }
1949
1950 ZOOM_API(int)
1951     ZOOM_connection_error_x(ZOOM_connection c, const char **cp,
1952                             const char **addinfo, const char **diagset)
1953 {
1954     int error = c->error;
1955     if (cp)
1956     {
1957         if (!c->diagset || !strcmp(c->diagset, "ZOOM"))
1958             *cp = ZOOM_diag_str(error);
1959         else if (!strcmp(c->diagset, "HTTP"))
1960             *cp = z_HTTP_errmsg(c->error);
1961         else if (!strcmp(c->diagset, "Bib-1"))
1962             *cp = ZOOM_diag_str(error);
1963         else if (!strcmp(c->diagset, "info:srw/diagnostic/1"))
1964             *cp = yaz_diag_srw_str(c->error);
1965         else
1966             *cp = "Unknown error and diagnostic set";
1967     }
1968     if (addinfo)
1969         *addinfo = c->addinfo ? c->addinfo : "";
1970     if (diagset)
1971         *diagset = c->diagset ? c->diagset : "";
1972     return c->error;
1973 }
1974
1975 ZOOM_API(int)
1976     ZOOM_connection_error(ZOOM_connection c, const char **cp,
1977                           const char **addinfo)
1978 {
1979     return ZOOM_connection_error_x(c, cp, addinfo, 0);
1980 }
1981
1982 static void ZOOM_connection_do_io(ZOOM_connection c, int mask)
1983 {
1984     ZOOM_Event event = 0;
1985     int r = cs_look(c->cs);
1986     yaz_log(c->log_details, "%p ZOOM_connection_do_io mask=%d cs_look=%d",
1987             c, mask, r);
1988
1989     if (r == CS_NONE)
1990     {
1991         event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
1992         ZOOM_set_error(c, ZOOM_ERROR_CONNECT, c->host_port);
1993         ZOOM_connection_close(c);
1994         ZOOM_connection_put_event(c, event);
1995     }
1996     else if (r == CS_CONNECT)
1997     {
1998         int ret = ret = cs_rcvconnect(c->cs);
1999         yaz_log(c->log_details, "%p ZOOM_connection_do_io "
2000                 "cs_rcvconnect returned %d", c, ret);
2001         if (ret == 1)
2002         {
2003             int mask = ZOOM_SELECT_EXCEPT;
2004             if (c->cs->io_pending & CS_WANT_WRITE)
2005                 mask += ZOOM_SELECT_WRITE;
2006             if (c->cs->io_pending & CS_WANT_READ)
2007                 mask += ZOOM_SELECT_READ;
2008             ZOOM_connection_set_mask(c, mask);
2009             event = ZOOM_Event_create(ZOOM_EVENT_NONE);
2010             ZOOM_connection_put_event(c, event);
2011         }
2012         else if (ret == 0)
2013         {
2014             event = ZOOM_Event_create(ZOOM_EVENT_CONNECT);
2015             ZOOM_connection_put_event(c, event);
2016             get_cert(c);
2017             if (c->proto == PROTO_Z3950)
2018                 ZOOM_connection_Z3950_send_init(c);
2019             else
2020             {
2021                 /* no init request for SRW .. */
2022                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
2023                 ZOOM_connection_remove_task(c);
2024                 ZOOM_connection_set_mask(c, 0);
2025                 ZOOM_connection_exec_task(c);
2026             }
2027             c->state = STATE_ESTABLISHED;
2028         }
2029         else
2030         {
2031             ZOOM_set_error(c, ZOOM_ERROR_CONNECT, c->host_port);
2032             ZOOM_connection_close(c);
2033         }
2034     }
2035     else
2036     {
2037         if (mask & ZOOM_SELECT_EXCEPT)
2038         {
2039             if (!ZOOM_test_reconnect(c))
2040             {
2041                 ZOOM_set_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
2042                 ZOOM_connection_close(c);
2043             }
2044             return;
2045         }
2046         if (mask & ZOOM_SELECT_READ)
2047             do_read(c);
2048         if (c->cs && (mask & ZOOM_SELECT_WRITE))
2049             ZOOM_send_buf(c);
2050     }
2051 }
2052
2053 ZOOM_API(int)
2054     ZOOM_connection_last_event(ZOOM_connection cs)
2055 {
2056     if (!cs)
2057         return ZOOM_EVENT_NONE;
2058     return cs->last_event;
2059 }
2060
2061
2062 ZOOM_API(int) ZOOM_connection_fire_event_timeout(ZOOM_connection c)
2063 {
2064     if (c->mask)
2065     {
2066         ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_TIMEOUT);
2067         /* timeout and this connection was waiting */
2068         ZOOM_set_error(c, ZOOM_ERROR_TIMEOUT, 0);
2069         ZOOM_connection_close(c);
2070         ZOOM_connection_put_event(c, event);
2071     }
2072     return 0;
2073 }
2074
2075 ZOOM_API(int)
2076     ZOOM_connection_process(ZOOM_connection c)
2077 {
2078     ZOOM_Event event;
2079     if (!c)
2080         return 0;
2081
2082     event = ZOOM_connection_get_event(c);
2083     if (event)
2084     {
2085         ZOOM_Event_destroy(event);
2086         return 1;
2087     }
2088     ZOOM_connection_exec_task(c);
2089     event = ZOOM_connection_get_event(c);
2090     if (event)
2091     {
2092         ZOOM_Event_destroy(event);
2093         return 1;
2094     }
2095     return 0;
2096 }
2097
2098 ZOOM_API(int)
2099     ZOOM_event_nonblock(int no, ZOOM_connection *cs)
2100 {
2101     int i;
2102
2103     yaz_log(log_details0, "ZOOM_process_event(no=%d,cs=%p)", no, cs);
2104
2105     for (i = 0; i<no; i++)
2106     {
2107         ZOOM_connection c = cs[i];
2108
2109         if (c && ZOOM_connection_process(c))
2110             return i+1;
2111     }
2112     return 0;
2113 }
2114
2115 ZOOM_API(int) ZOOM_connection_fire_event_socket(ZOOM_connection c, int mask)
2116 {
2117     if (c->mask && mask)
2118         ZOOM_connection_do_io(c, mask);
2119     return 0;
2120 }
2121
2122 ZOOM_API(int) ZOOM_connection_get_socket(ZOOM_connection c)
2123 {
2124     if (c->cs)
2125         return cs_fileno(c->cs);
2126     return -1;
2127 }
2128
2129 ZOOM_API(int) ZOOM_connection_set_mask(ZOOM_connection c, int mask)
2130 {
2131     c->mask = mask;
2132     if (!c->cs)
2133         return -1;
2134     return 0;
2135 }
2136
2137 ZOOM_API(int) ZOOM_connection_get_mask(ZOOM_connection c)
2138 {
2139     if (c->cs)
2140         return c->mask;
2141     return 0;
2142 }
2143
2144 ZOOM_API(int) ZOOM_connection_get_timeout(ZOOM_connection c)
2145 {
2146     return ZOOM_options_get_int(c->options, "timeout", 30);
2147 }
2148
2149 ZOOM_API(void) ZOOM_connection_close(ZOOM_connection c)
2150 {
2151     if (c->cs)
2152         cs_close(c->cs);
2153     c->cs = 0;
2154     ZOOM_connection_set_mask(c, 0);
2155     c->state = STATE_IDLE;
2156 }
2157
2158 /*
2159  * Local variables:
2160  * c-basic-offset: 4
2161  * c-file-style: "Stroustrup"
2162  * indent-tabs-mode: nil
2163  * End:
2164  * vim: shiftwidth=4 tabstop=8 expandtab
2165  */
2166