src/zoom-c.c

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