src/zoom-c.c

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