src/zoom-z3950.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /**
   6  * \file zoom-z3950.c
   7  * \brief Implements ZOOM Z39.50 handling
   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/pquery.h>
  23 #include <yaz/marcdisp.h>
  24 #include <yaz/diagbib1.h>
  25 #include <yaz/charneg.h>
  26 #include <yaz/ill.h>
  27 #include <yaz/query-charset.h>
  28 #include <yaz/copy_types.h>
  29 #include <yaz/snprintf.h>
  30 #include <yaz/facet.h>
  31
  32 #include <yaz/shptr.h>
  33
  34 /*
  35  * This wrapper is just for logging failed lookups.  It would be nicer
  36  * if it could cause failure when a lookup fails, but that's hard.
  37  */
  38 static Odr_oid *zoom_yaz_str_to_z3950oid(ZOOM_connection c,
  39                                      oid_class oid_class, const char *str)
  40 {
  41     Odr_oid *res = yaz_string_to_oid_odr(yaz_oid_std(), oid_class, str,
  42                                      c->odr_out);
  43     if (res == 0)
  44         yaz_log(YLOG_WARN, "%p OID lookup (%d, '%s') failed",
  45                 c, (int) oid_class, str);
  46     return res;
  47 }
  48
  49 static Z_APDU *create_es_package(ZOOM_package p, const Odr_oid *oid)
  50 {
  51     const char *str;
  52     Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
  53     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
  54
  55     str = ZOOM_options_get(p->options, "package-name");
  56     if (str && *str)
  57         req->packageName = odr_strdup(p->odr_out, str);
  58
  59     str = ZOOM_options_get(p->options, "user-id");
  60     if (str)
  61         req->userId = odr_strdup_null(p->odr_out, str);
  62
  63     req->packageType = odr_oiddup(p->odr_out, oid);
  64
  65     str = ZOOM_options_get(p->options, "function");
  66     if (str)
  67     {
  68         if (!strcmp (str, "create"))
  69             *req->function = Z_ExtendedServicesRequest_create;
  70         if (!strcmp (str, "delete"))
  71             *req->function = Z_ExtendedServicesRequest_delete;
  72         if (!strcmp (str, "modify"))
  73             *req->function = Z_ExtendedServicesRequest_modify;
  74     }
  75
  76     str = ZOOM_options_get(p->options, "waitAction");
  77     if (str)
  78     {
  79         if (!strcmp (str, "wait"))
  80             *req->waitAction = Z_ExtendedServicesRequest_wait;
  81         if (!strcmp (str, "waitIfPossible"))
  82             *req->waitAction = Z_ExtendedServicesRequest_waitIfPossible;
  83         if (!strcmp (str, "dontWait"))
  84             *req->waitAction = Z_ExtendedServicesRequest_dontWait;
  85         if (!strcmp (str, "dontReturnPackage"))
  86             *req->waitAction = Z_ExtendedServicesRequest_dontReturnPackage;
  87     }
  88     return apdu;
  89 }
  90
  91 static const char *ill_array_lookup(void *clientData, const char *idx)
  92 {
  93     ZOOM_package p = (ZOOM_package) clientData;
  94     return ZOOM_options_get(p->options, idx+4);
  95 }
  96
  97 static Z_External *encode_ill_request(ZOOM_package p)
  98 {
  99     ODR out = p->odr_out;
 100     ILL_Request *req;
 101     Z_External *r = 0;
 102     struct ill_get_ctl ctl;
 103
 104     ctl.odr = p->odr_out;
 105     ctl.clientData = p;
 106     ctl.f = ill_array_lookup;
 107
 108     req = ill_get_ILLRequest(&ctl, "ill", 0);
 109
 110     if (!ill_Request(out, &req, 0, 0))
 111     {
 112         int ill_request_size;
 113         char *ill_request_buf = odr_getbuf(out, &ill_request_size, 0);
 114         if (ill_request_buf)
 115             odr_setbuf(out, ill_request_buf, ill_request_size, 1);
 116         return 0;
 117     }
 118     else
 119     {
 120         int illRequest_size = 0;
 121         char *illRequest_buf = odr_getbuf(out, &illRequest_size, 0);
 122
 123         r = (Z_External *) odr_malloc(out, sizeof(*r));
 124         r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
 125         r->indirect_reference = 0;
 126         r->descriptor = 0;
 127         r->which = Z_External_single;
 128
 129         r->u.single_ASN1_type =
 130             odr_create_Odr_oct(out, illRequest_buf, illRequest_size);
 131     }
 132     return r;
 133 }
 134
 135 static Z_ItemOrder *encode_item_order(ZOOM_package p)
 136 {
 137     Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc(p->odr_out, sizeof(*req));
 138     const char *str;
 139     int len;
 140
 141     req->which = Z_IOItemOrder_esRequest;
 142     req->u.esRequest = (Z_IORequest *)
 143         odr_malloc(p->odr_out,sizeof(Z_IORequest));
 144
 145     /* to keep part ... */
 146     req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
 147         odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
 148     req->u.esRequest->toKeep->supplDescription = 0;
 149     req->u.esRequest->toKeep->contact = (Z_IOContact *)
 150         odr_malloc(p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
 151
 152     str = ZOOM_options_get(p->options, "contact-name");
 153     req->u.esRequest->toKeep->contact->name =
 154         odr_strdup_null(p->odr_out, str);
 155
 156     str = ZOOM_options_get(p->options, "contact-phone");
 157     req->u.esRequest->toKeep->contact->phone =
 158         odr_strdup_null(p->odr_out, str);
 159
 160     str = ZOOM_options_get(p->options, "contact-email");
 161     req->u.esRequest->toKeep->contact->email =
 162         odr_strdup_null(p->odr_out, str);
 163
 164     req->u.esRequest->toKeep->addlBilling = 0;
 165
 166     /* not to keep part ... */
 167     req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
 168         odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
 169
 170     str = ZOOM_options_get(p->options, "itemorder-setname");
 171     if (!str)
 172         str = "default";
 173
 174     if (!*str)
 175         req->u.esRequest->notToKeep->resultSetItem = 0;
 176     else
 177     {
 178         req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
 179             odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
 180
 181         req->u.esRequest->notToKeep->resultSetItem->resultSetId =
 182             odr_strdup(p->odr_out, str);
 183         req->u.esRequest->notToKeep->resultSetItem->item =
 184             odr_intdup(p->odr_out, 0);
 185
 186         str = ZOOM_options_get(p->options, "itemorder-item");
 187         *req->u.esRequest->notToKeep->resultSetItem->item =
 188             (str ? atoi(str) : 1);
 189     }
 190
 191     str = ZOOM_options_getl(p->options, "doc", &len);
 192     if (str)
 193     {
 194         req->u.esRequest->notToKeep->itemRequest =
 195             z_ext_record_xml(p->odr_out, str, len);
 196     }
 197     else
 198         req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
 199
 200     return req;
 201 }
 202
 203 Z_APDU *create_admin_package(ZOOM_package p, int type,
 204                              Z_ESAdminOriginPartToKeep **toKeepP,
 205                              Z_ESAdminOriginPartNotToKeep **notToKeepP)
 206 {
 207     Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_admin);
 208     if (apdu)
 209     {
 210         Z_ESAdminOriginPartToKeep  *toKeep;
 211         Z_ESAdminOriginPartNotToKeep  *notToKeep;
 212         Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
 213         const char *first_db = "Default";
 214         int num_db;
 215         char **db = ZOOM_connection_get_databases(p->connection,
 216                                                   p->options, &num_db,
 217                                                   p->odr_out);
 218         if (num_db > 0)
 219             first_db = db[0];
 220
 221         r->direct_reference = odr_oiddup(p->odr_out, yaz_oid_extserv_admin);
 222         r->descriptor = 0;
 223         r->indirect_reference = 0;
 224         r->which = Z_External_ESAdmin;
 225
 226         r->u.adminService = (Z_Admin *)
 227             odr_malloc(p->odr_out, sizeof(*r->u.adminService));
 228         r->u.adminService->which = Z_Admin_esRequest;
 229         r->u.adminService->u.esRequest = (Z_AdminEsRequest *)
 230             odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest));
 231
 232         toKeep = r->u.adminService->u.esRequest->toKeep =
 233             (Z_ESAdminOriginPartToKeep *)
 234             odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest->toKeep));
 235         toKeep->which = type;
 236         toKeep->databaseName = odr_strdup(p->odr_out, first_db);
 237         toKeep->u.create = odr_nullval();
 238         apdu->u.extendedServicesRequest->taskSpecificParameters = r;
 239
 240         r->u.adminService->u.esRequest->notToKeep = notToKeep =
 241             (Z_ESAdminOriginPartNotToKeep *)
 242             odr_malloc(p->odr_out,
 243                        sizeof(*r->u.adminService->u.esRequest->notToKeep));
 244         notToKeep->which = Z_ESAdminOriginPartNotToKeep_recordsWillFollow;
 245         notToKeep->u.recordsWillFollow = odr_nullval();
 246         if (toKeepP)
 247             *toKeepP = toKeep;
 248         if (notToKeepP)
 249             *notToKeepP = notToKeep;
 250     }
 251     return apdu;
 252 }
 253
 254 static Z_APDU *create_xmlupdate_package(ZOOM_package p)
 255 {
 256     Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_xml_es);
 257     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
 258     Z_External *ext = (Z_External *) odr_malloc(p->odr_out, sizeof(*ext));
 259     int len;
 260     const char *doc = ZOOM_options_getl(p->options, "doc", &len);
 261
 262     if (!doc)
 263     {
 264         doc = "";
 265         len = 0;
 266     }
 267
 268     req->taskSpecificParameters = ext;
 269     ext->direct_reference = req->packageType;
 270     ext->descriptor = 0;
 271     ext->indirect_reference = 0;
 272
 273     ext->which = Z_External_octet;
 274     ext->u.single_ASN1_type = odr_create_Odr_oct(p->odr_out, doc, len);
 275     return apdu;
 276 }
 277
 278 static Z_APDU *create_update_package(ZOOM_package p)
 279 {
 280     Z_APDU *apdu = 0;
 281     const char *first_db = "Default";
 282     int num_db;
 283     char **db = ZOOM_connection_get_databases(p->connection, p->options,
 284                                               &num_db, p->odr_out);
 285     const char *action = ZOOM_options_get(p->options, "action");
 286     int recordIdOpaque_len;
 287     const char *recordIdOpaque = ZOOM_options_getl(p->options, "recordIdOpaque",
 288         &recordIdOpaque_len);
 289     const char *recordIdNumber = ZOOM_options_get(p->options, "recordIdNumber");
 290     int record_len;
 291     const char *record_buf = ZOOM_options_getl(p->options, "record",
 292         &record_len);
 293     int recordOpaque_len;
 294     const char *recordOpaque_buf = ZOOM_options_getl(p->options, "recordOpaque",
 295         &recordOpaque_len);
 296     const char *syntax_str = ZOOM_options_get(p->options, "syntax");
 297     const char *version = ZOOM_options_get(p->options, "updateVersion");
 298
 299     const char *correlationInfo_note =
 300         ZOOM_options_get(p->options, "correlationInfo.note");
 301     const char *correlationInfo_id =
 302         ZOOM_options_get(p->options, "correlationInfo.id");
 303     int action_no = -1;
 304     Odr_oid *syntax_oid = 0;
 305     const Odr_oid *package_oid = yaz_oid_extserv_database_update;
 306
 307     if (!version)
 308         version = "3";
 309     if (!syntax_str)
 310         syntax_str = "xml";
 311     if (!record_buf && !recordOpaque_buf)
 312     {
 313         record_buf = "void";
 314         record_len = 4;
 315         syntax_str = "SUTRS";
 316     }
 317
 318     if (syntax_str)
 319     {
 320         syntax_oid = yaz_string_to_oid_odr(yaz_oid_std(),
 321                                            CLASS_RECSYN, syntax_str,
 322                                            p->odr_out);
 323     }
 324     if (!syntax_oid)
 325     {
 326         ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_SYNTAX, syntax_str);
 327         return 0;
 328     }
 329
 330     if (num_db > 0)
 331         first_db = db[0];
 332
 333     switch (*version)
 334     {
 335     case '1':
 336         package_oid = yaz_oid_extserv_database_update_first_version;
 337         /* old update does not support specialUpdate */
 338         if (!action)
 339             action = "recordInsert";
 340         break;
 341     case '2':
 342         if (!action)
 343             action = "specialUpdate";
 344         package_oid = yaz_oid_extserv_database_update_second_version;
 345         break;
 346     case '3':
 347         if (!action)
 348             action = "specialUpdate";
 349         package_oid = yaz_oid_extserv_database_update;
 350         break;
 351     default:
 352         ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_VERSION, version);
 353         return 0;
 354     }
 355
 356     if (!strcmp(action, "recordInsert"))
 357         action_no = Z_IUOriginPartToKeep_recordInsert;
 358     else if (!strcmp(action, "recordReplace"))
 359         action_no = Z_IUOriginPartToKeep_recordReplace;
 360     else if (!strcmp(action, "recordDelete"))
 361         action_no = Z_IUOriginPartToKeep_recordDelete;
 362     else if (!strcmp(action, "elementUpdate"))
 363         action_no = Z_IUOriginPartToKeep_elementUpdate;
 364     else if (!strcmp(action, "specialUpdate"))
 365         action_no = Z_IUOriginPartToKeep_specialUpdate;
 366     else
 367     {
 368         ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_ACTION, action);
 369         return 0;
 370     }
 371
 372     apdu = create_es_package(p, package_oid);
 373     if (apdu)
 374     {
 375         Z_IUOriginPartToKeep *toKeep;
 376         Z_IUSuppliedRecords *notToKeep;
 377         Z_External *r = (Z_External *)
 378             odr_malloc(p->odr_out, sizeof(*r));
 379         const char *elementSetName =
 380             ZOOM_options_get(p->options, "elementSetName");
 381
 382         apdu->u.extendedServicesRequest->taskSpecificParameters = r;
 383
 384         r->direct_reference = odr_oiddup(p->odr_out, package_oid);
 385         r->descriptor = 0;
 386         r->which = Z_External_update;
 387         r->indirect_reference = 0;
 388         r->u.update = (Z_IUUpdate *)
 389             odr_malloc(p->odr_out, sizeof(*r->u.update));
 390
 391         r->u.update->which = Z_IUUpdate_esRequest;
 392         r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
 393             odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
 394         toKeep = r->u.update->u.esRequest->toKeep =
 395             (Z_IUOriginPartToKeep *)
 396             odr_malloc(p->odr_out, sizeof(*toKeep));
 397
 398         toKeep->databaseName = odr_strdup(p->odr_out, first_db);
 399         toKeep->schema = 0;
 400
 401         toKeep->elementSetName = odr_strdup_null(p->odr_out, elementSetName);
 402
 403         toKeep->actionQualifier = 0;
 404         toKeep->action = odr_intdup(p->odr_out, action_no);
 405
 406         notToKeep = r->u.update->u.esRequest->notToKeep =
 407             (Z_IUSuppliedRecords *)
 408             odr_malloc(p->odr_out, sizeof(*notToKeep));
 409         notToKeep->num = 1;
 410         notToKeep->elements = (Z_IUSuppliedRecords_elem **)
 411             odr_malloc(p->odr_out, sizeof(*notToKeep->elements));
 412         notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
 413             odr_malloc(p->odr_out, sizeof(**notToKeep->elements));
 414         notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
 415         if (recordIdOpaque)
 416         {
 417             notToKeep->elements[0]->u.opaque =
 418                 odr_create_Odr_oct(p->odr_out, recordIdOpaque,
 419                                    recordIdOpaque_len);
 420         }
 421         else if (recordIdNumber)
 422         {
 423             notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;
 424
 425             notToKeep->elements[0]->u.number =
 426                 odr_intdup(p->odr_out, atoi(recordIdNumber));
 427         }
 428         else
 429             notToKeep->elements[0]->u.opaque = 0;
 430         notToKeep->elements[0]->supplementalId = 0;
 431         if (correlationInfo_note || correlationInfo_id)
 432         {
 433             Z_IUCorrelationInfo *ci;
 434             ci = notToKeep->elements[0]->correlationInfo =
 435                 (Z_IUCorrelationInfo *) odr_malloc(p->odr_out, sizeof(*ci));
 436             ci->note = odr_strdup_null(p->odr_out, correlationInfo_note);
 437             ci->id = correlationInfo_id ?
 438                 odr_intdup(p->odr_out, atoi(correlationInfo_id)) : 0;
 439         }
 440         else
 441             notToKeep->elements[0]->correlationInfo = 0;
 442         if (recordOpaque_buf)
 443         {
 444             notToKeep->elements[0]->record =
 445                 z_ext_record_oid_any(p->odr_out, syntax_oid,
 446                                  recordOpaque_buf, recordOpaque_len);
 447         }
 448         else
 449         {
 450             notToKeep->elements[0]->record =
 451                 z_ext_record_oid(p->odr_out, syntax_oid,
 452                                  record_buf, record_len);
 453         }
 454     }
 455     if (0 && apdu)
 456     {
 457         ODR print = odr_createmem(ODR_PRINT);
 458
 459         z_APDU(print, &apdu, 0, 0);
 460         odr_destroy(print);
 461     }
 462     return apdu;
 463 }
 464
 465
 466 static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
 467 {
 468     int i;
 469     for (i = 0; i < 200; i++)
 470     {
 471         size_t len;
 472         Odr_oid *oid;
 473         Z_OtherInformation **oi;
 474         char buf[80];
 475         const char *val;
 476         const char *cp;
 477
 478         sprintf(buf, "otherInfo%d", i);
 479         val = ZOOM_options_get(c->options, buf);
 480         if (!val)
 481             break;
 482         cp = strchr(val, ':');
 483         if (!cp)
 484             continue;
 485         len = cp - val;
 486         if (len >= sizeof(buf))
 487             len = sizeof(buf)-1;
 488         memcpy(buf, val, len);
 489         buf[len] = '\0';
 490
 491         oid = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_USERINFO,
 492                                     buf, out);
 493         if (!oid)
 494             continue;
 495
 496         yaz_oi_APDU(a, &oi);
 497         yaz_oi_set_string_oid(oi, out, oid, 1, cp+1);
 498     }
 499 }
 500
 501
 502
 503 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
 504 {
 505     assert(a);
 506     if (c->cookie_out)
 507     {
 508         Z_OtherInformation **oi;
 509         yaz_oi_APDU(a, &oi);
 510         yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_cookie,
 511                               1, c->cookie_out);
 512     }
 513     if (c->client_IP)
 514     {
 515         Z_OtherInformation **oi;
 516         yaz_oi_APDU(a, &oi);
 517         yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_client_ip,
 518                               1, c->client_IP);
 519     }
 520     otherInfo_attach(c, a, out);
 521     if (!z_APDU(out, &a, 0, 0))
 522     {
 523         FILE *outf = fopen("/tmp/apdu.txt", "a");
 524         if (a && outf)
 525         {
 526             ODR odr_pr = odr_createmem(ODR_PRINT);
 527             fprintf(outf, "a=%p\n", a);
 528             odr_setprint(odr_pr, outf);
 529             z_APDU(odr_pr, &a, 0, 0);
 530             odr_destroy(odr_pr);
 531         }
 532         yaz_log(c->log_api, "%p encoding_APDU: encoding failed", c);
 533         ZOOM_set_error(c, ZOOM_ERROR_ENCODE, 0);
 534         odr_reset(out);
 535         return -1;
 536     }
 537     if (c->odr_print)
 538         z_APDU(c->odr_print, &a, 0, 0);
 539     if (c->odr_save)
 540         z_APDU(c->odr_save, &a, 0, 0);
 541     yaz_log(c->log_details, "%p encoding_APDU encoding OK", c);
 542     return 0;
 543 }
 544
 545 static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
 546 {
 547     ZOOM_Event event;
 548     assert(a);
 549     if (encode_APDU(c, a, c->odr_out))
 550         return zoom_complete;
 551     yaz_log(c->log_details, "%p send APDU type=%d", c, a->which);
 552     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
 553     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
 554     ZOOM_connection_put_event(c, event);
 555     odr_reset(c->odr_out);
 556     return ZOOM_send_buf(c);
 557 }
 558
 559 zoom_ret ZOOM_connection_Z3950_send_init(ZOOM_connection c)
 560 {
 561     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
 562     Z_InitRequest *ireq = apdu->u.initRequest;
 563     Z_IdAuthentication *auth = (Z_IdAuthentication *)
 564         odr_malloc(c->odr_out, sizeof(*auth));
 565
 566     ODR_MASK_SET(ireq->options, Z_Options_search);
 567     ODR_MASK_SET(ireq->options, Z_Options_present);
 568     ODR_MASK_SET(ireq->options, Z_Options_scan);
 569     ODR_MASK_SET(ireq->options, Z_Options_sort);
 570     ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
 571     ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
 572
 573     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
 574     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
 575     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
 576
 577     ireq->implementationId =
 578         odr_prepend(c->odr_out,
 579                     ZOOM_options_get(c->options, "implementationId"),
 580                     ireq->implementationId);
 581
 582     ireq->implementationName =
 583         odr_prepend(c->odr_out,
 584                     ZOOM_options_get(c->options, "implementationName"),
 585                     odr_prepend(c->odr_out, "ZOOM-C",
 586                                 ireq->implementationName));
 587
 588     ireq->implementationVersion =
 589         odr_prepend(c->odr_out,
 590                     ZOOM_options_get(c->options, "implementationVersion"),
 591                                 ireq->implementationVersion);
 592
 593     *ireq->maximumRecordSize = c->maximum_record_size;
 594     *ireq->preferredMessageSize = c->preferred_message_size;
 595
 596     if (c->group || c->password)
 597     {
 598         Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
 599         pass->groupId = odr_strdup_null(c->odr_out, c->group);
 600         pass->userId = odr_strdup_null(c->odr_out, c->user);
 601         pass->password = odr_strdup_null(c->odr_out, c->password);
 602         auth->which = Z_IdAuthentication_idPass;
 603         auth->u.idPass = pass;
 604         ireq->idAuthentication = auth;
 605     }
 606     else if (c->user)
 607     {
 608         auth->which = Z_IdAuthentication_open;
 609         auth->u.open = odr_strdup(c->odr_out, c->user);
 610         ireq->idAuthentication = auth;
 611     }
 612     if (c->proxy)
 613     {
 614         yaz_oi_set_string_oid(&ireq->otherInfo, c->odr_out,
 615                               yaz_oid_userinfo_proxy, 1, c->host_port);
 616     }
 617     if (c->charset || c->lang)
 618     {
 619         Z_OtherInformation **oi;
 620         Z_OtherInformationUnit *oi_unit;
 621
 622         yaz_oi_APDU(apdu, &oi);
 623
 624         if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
 625         {
 626             ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
 627             oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
 628             oi_unit->information.externallyDefinedInfo =
 629                 yaz_set_proposal_charneg_list(c->odr_out, " ",
 630                                               c->charset, c->lang, 1);
 631         }
 632     }
 633     assert(apdu);
 634     return send_APDU(c, apdu);
 635 }
 636
 637 static zoom_ret Z3950_send_search(ZOOM_connection c)
 638 {
 639     ZOOM_resultset r;
 640     int lslb, ssub, mspn;
 641     const char *syntax;
 642     const char *schema;
 643     Z_APDU *apdu;
 644     Z_SearchRequest *search_req;
 645     const char *elementSetName;
 646     const char *smallSetElementSetName;
 647     const char *mediumSetElementSetName;
 648     const char *facets;
 649
 650     assert(c->tasks);
 651     assert(c->tasks->which == ZOOM_TASK_SEARCH);
 652     r = c->tasks->u.search.resultset;
 653
 654     apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
 655     search_req = apdu->u.searchRequest;
 656
 657     yaz_log(c->log_details, "%p ZOOM_connection_send_search set=%p", c, r);
 658
 659     elementSetName = c->tasks->u.search.elementSetName;
 660     smallSetElementSetName  =
 661         ZOOM_options_get(r->options, "smallSetElementSetName");
 662     mediumSetElementSetName =
 663         ZOOM_options_get(r->options, "mediumSetElementSetName");
 664
 665     if (!smallSetElementSetName)
 666         smallSetElementSetName = elementSetName;
 667
 668     if (!mediumSetElementSetName)
 669         mediumSetElementSetName = elementSetName;
 670
 671     if (r->req_facets)
 672     {
 673         Z_FacetList *facet_list =
 674             yaz_pqf_parse_facet_list(c->odr_out, r->req_facets);
 675         if (facet_list)
 676         {
 677             Z_OtherInformation **oi = &search_req->additionalSearchInfo;
 678             yaz_oi_set_facetlist(oi, c->odr_out, facet_list);
 679         }
 680         else
 681             yaz_log(YLOG_WARN, "Unable to parse facets: %s", facets);
 682     }
 683
 684     assert(r);
 685     assert(r->query);
 686
 687     /* prepare query for the search request */
 688     search_req->query = ZOOM_query_get_Z_Query(r->query);
 689     if (!search_req->query)
 690     {
 691         ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
 692         return zoom_complete;
 693     }
 694     if (search_req->query->which == Z_Query_type_1 ||
 695         search_req->query->which == Z_Query_type_101)
 696     {
 697         const char *cp = ZOOM_options_get(r->options, "rpnCharset");
 698         if (cp)
 699         {
 700             yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
 701             if (cd)
 702             {
 703                 int r;
 704                 search_req->query = yaz_copy_Z_Query(search_req->query,
 705                                                      c->odr_out);
 706
 707                 r = yaz_query_charset_convert_rpnquery_check(
 708                     search_req->query->u.type_1,
 709                     c->odr_out, cd);
 710                 yaz_iconv_close(cd);
 711                 if (r)
 712                 {  /* query could not be char converted */
 713                     ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
 714                     return zoom_complete;
 715                 }
 716             }
 717         }
 718     }
 719     search_req->databaseNames = r->databaseNames;
 720     search_req->num_databaseNames = r->num_databaseNames;
 721
 722     /* get syntax (no need to provide unless piggyback is in effect) */
 723     syntax = c->tasks->u.search.syntax;
 724
 725     schema = c->tasks->u.search.schema;
 726
 727     lslb = ZOOM_options_get_int(r->options, "largeSetLowerBound", -1);
 728     ssub = ZOOM_options_get_int(r->options, "smallSetUpperBound", -1);
 729     mspn = ZOOM_options_get_int(r->options, "mediumSetPresentNumber", -1);
 730     if (lslb != -1 && ssub != -1 && mspn != -1)
 731     {
 732         /* So're a Z39.50 expert? Let's hope you don't do sort */
 733         *search_req->largeSetLowerBound = lslb;
 734         *search_req->smallSetUpperBound = ssub;
 735         *search_req->mediumSetPresentNumber = mspn;
 736     }
 737     else if (c->tasks->u.search.start == 0 && c->tasks->u.search.count > 0
 738              && r->piggyback && !r->r_sort_spec && !schema)
 739     {
 740         /* Regular piggyback - do it unless we're going to do sort */
 741         *search_req->largeSetLowerBound = 2000000000;
 742         *search_req->smallSetUpperBound = 1;
 743         *search_req->mediumSetPresentNumber =
 744             r->step>0 ? r->step : c->tasks->u.search.count;
 745     }
 746     else
 747     {
 748         /* non-piggyback. Need not provide elementsets or syntaxes .. */
 749         smallSetElementSetName = 0;
 750         mediumSetElementSetName = 0;
 751         syntax = 0;
 752     }
 753     if (smallSetElementSetName && *smallSetElementSetName)
 754     {
 755         Z_ElementSetNames *esn = (Z_ElementSetNames *)
 756             odr_malloc(c->odr_out, sizeof(*esn));
 757
 758         esn->which = Z_ElementSetNames_generic;
 759         esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
 760         search_req->smallSetElementSetNames = esn;
 761     }
 762     if (mediumSetElementSetName && *mediumSetElementSetName)
 763     {
 764         Z_ElementSetNames *esn =(Z_ElementSetNames *)
 765             odr_malloc(c->odr_out, sizeof(*esn));
 766
 767         esn->which = Z_ElementSetNames_generic;
 768         esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
 769         search_req->mediumSetElementSetNames = esn;
 770     }
 771     if (syntax)
 772         search_req->preferredRecordSyntax =
 773             zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
 774
 775     if (!r->setname)
 776     {
 777         if (c->support_named_resultsets)
 778         {
 779             char setname[14];
 780             int ord;
 781             /* find the lowest unused ordinal so that we re-use
 782                result sets on the server. */
 783             for (ord = 1; ; ord++)
 784             {
 785                 ZOOM_resultset rp;
 786                 sprintf(setname, "%d", ord);
 787                 for (rp = c->resultsets; rp; rp = rp->next)
 788                     if (rp->setname && !strcmp(rp->setname, setname))
 789                         break;
 790                 if (!rp)
 791                     break;
 792             }
 793             r->setname = xstrdup(setname);
 794             yaz_log(c->log_details, "%p ZOOM_connection_send_search: "
 795                     "allocating set %s", c, r->setname);
 796         }
 797         else
 798         {
 799             yaz_log(c->log_details, "%p ZOOM_connection_send_search: using "
 800                     "default set", c);
 801             r->setname = xstrdup("default");
 802         }
 803         ZOOM_options_set(r->options, "setname", r->setname);
 804     }
 805     search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
 806     return send_APDU(c, apdu);
 807 }
 808
 809 zoom_ret ZOOM_connection_Z3950_send_scan(ZOOM_connection c)
 810 {
 811     ZOOM_scanset scan;
 812     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
 813     Z_ScanRequest *req = apdu->u.scanRequest;
 814     Z_Query *z_query;
 815
 816     yaz_log(c->log_details, "%p send_scan", c);
 817     if (!c->tasks)
 818         return zoom_complete;
 819     assert (c->tasks->which == ZOOM_TASK_SCAN);
 820     scan = c->tasks->u.scan.scan;
 821
 822     z_query = ZOOM_query_get_Z_Query(scan->query);
 823
 824     /* Z39.50 scan can only carry RPN */
 825     if (z_query->which == Z_Query_type_1 ||
 826         z_query->which == Z_Query_type_101)
 827     {
 828         Z_RPNQuery *rpn = z_query->u.type_1;
 829         const char *cp = ZOOM_options_get(scan->options, "rpnCharset");
 830         if (cp)
 831         {
 832             yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
 833             if (cd)
 834             {
 835                 rpn = yaz_copy_z_RPNQuery(rpn, c->odr_out);
 836
 837                 yaz_query_charset_convert_rpnquery(
 838                     rpn, c->odr_out, cd);
 839                 yaz_iconv_close(cd);
 840             }
 841         }
 842         req->attributeSet = rpn->attributeSetId;
 843         if (!req->attributeSet)
 844             req->attributeSet = odr_oiddup(c->odr_out, yaz_oid_attset_bib_1);
 845         if (rpn->RPNStructure->which == Z_RPNStructure_simple &&
 846             rpn->RPNStructure->u.simple->which == Z_Operand_APT)
 847         {
 848             req->termListAndStartPoint =
 849                 rpn->RPNStructure->u.simple->u.attributesPlusTerm;
 850         }
 851         else
 852         {
 853             ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
 854             return zoom_complete;
 855         }
 856     }
 857     else
 858     {
 859         ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
 860         return zoom_complete;
 861     }
 862
 863     *req->numberOfTermsRequested =
 864         ZOOM_options_get_int(scan->options, "number", 20);
 865
 866     req->preferredPositionInResponse =
 867         odr_intdup(c->odr_out,
 868                    ZOOM_options_get_int(scan->options, "position", 1));
 869
 870     req->stepSize =
 871         odr_intdup(c->odr_out,
 872                    ZOOM_options_get_int(scan->options, "stepSize", 0));
 873
 874     req->databaseNames = scan->databaseNames;
 875     req->num_databaseNames = scan->num_databaseNames;
 876
 877     return send_APDU(c, apdu);
 878 }
 879
 880 ZOOM_API(void)
 881     ZOOM_package_send(ZOOM_package p, const char *type)
 882 {
 883     Z_APDU *apdu = 0;
 884     ZOOM_connection c;
 885     if (!p)
 886         return;
 887     c = p->connection;
 888     odr_reset(p->odr_out);
 889     xfree(p->buf_out);
 890     p->buf_out = 0;
 891     if (!strcmp(type, "itemorder"))
 892     {
 893         apdu = create_es_package(p, yaz_oid_extserv_item_order);
 894         if (apdu)
 895         {
 896             Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
 897
 898             r->direct_reference =
 899                 odr_oiddup(p->odr_out, yaz_oid_extserv_item_order);
 900             r->descriptor = 0;
 901             r->which = Z_External_itemOrder;
 902             r->indirect_reference = 0;
 903             r->u.itemOrder = encode_item_order(p);
 904
 905             apdu->u.extendedServicesRequest->taskSpecificParameters = r;
 906         }
 907     }
 908     else if (!strcmp(type, "create"))  /* create database */
 909     {
 910         apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_create,
 911                                     0, 0);
 912     }
 913     else if (!strcmp(type, "drop"))  /* drop database */
 914     {
 915         apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_drop,
 916                                     0, 0);
 917     }
 918     else if (!strcmp(type, "commit"))  /* commit changes */
 919     {
 920         apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_commit,
 921                                     0, 0);
 922     }
 923     else if (!strcmp(type, "update")) /* update record(s) */
 924     {
 925         apdu = create_update_package(p);
 926     }
 927     else if (!strcmp(type, "xmlupdate"))
 928     {
 929         apdu = create_xmlupdate_package(p);
 930     }
 931     if (apdu)
 932     {
 933         if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
 934         {
 935             char *buf;
 936
 937             ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_PACKAGE);
 938             task->u.package = p;
 939             buf = odr_getbuf(p->odr_out, &p->len_out, 0);
 940             p->buf_out = (char *) xmalloc(p->len_out);
 941             memcpy(p->buf_out, buf, p->len_out);
 942
 943             (p->refcount)++;
 944             if (!c->async)
 945             {
 946                 while (ZOOM_event(1, &c))
 947                     ;
 948             }
 949         }
 950     }
 951 }
 952
 953 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
 954                                  int present_phase);
 955
 956 static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
 957 {
 958     char oid_name_buf[OID_STR_MAX];
 959     const char *oid_name;
 960     char *addinfo = 0;
 961
 962     oid_name = yaz_oid_to_string_buf(r->diagnosticSetId, 0, oid_name_buf);
 963     switch (r->which)
 964     {
 965     case Z_DefaultDiagFormat_v2Addinfo:
 966         addinfo = r->u.v2Addinfo;
 967         break;
 968     case Z_DefaultDiagFormat_v3Addinfo:
 969         addinfo = r->u.v3Addinfo;
 970         break;
 971     }
 972     xfree(c->addinfo);
 973     c->addinfo = 0;
 974     ZOOM_set_dset_error(c, *r->condition, oid_name, addinfo, 0);
 975 }
 976
 977 static void response_diag(ZOOM_connection c, Z_DiagRec *p)
 978 {
 979     if (p->which != Z_DiagRec_defaultFormat)
 980         ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
 981     else
 982         response_default_diag(c, p->u.defaultFormat);
 983 }
 984
 985 static int es_response_taskpackage_update(ZOOM_connection c,
 986                                           Z_IUUpdateTaskPackage *utp)
 987 {
 988     if (utp && utp->targetPart)
 989     {
 990         Z_IUTargetPart *targetPart = utp->targetPart;
 991         switch (*targetPart->updateStatus)
 992         {
 993         case Z_IUTargetPart_success:
 994             ZOOM_options_set(c->tasks->u.package->options,
 995                              "updateStatus", "success");
 996             break;
 997         case Z_IUTargetPart_partial:
 998             ZOOM_options_set(c->tasks->u.package->options,
 999                              "updateStatus", "partial");
1000             break;
1001         case Z_IUTargetPart_failure:
1002             ZOOM_options_set(c->tasks->u.package->options,
1003                              "updateStatus", "failure");
1004             if (targetPart->globalDiagnostics &&
1005                 targetPart->num_globalDiagnostics > 0)
1006                 response_diag(c, targetPart->globalDiagnostics[0]);
1007             break;
1008         }
1009         /* NOTE: Individual record status, surrogate diagnostics, and supplemental diagnostics ARE NOT REPORTED. */
1010     }
1011     return 1;
1012 }
1013
1014 static int es_response_taskpackage(ZOOM_connection c,
1015                                    Z_TaskPackage *taskPackage)
1016 {
1017     Odr_oct *id = taskPackage->targetReference;
1018     if (id)
1019         ZOOM_options_setl(c->tasks->u.package->options,
1020                           "targetReference", (char*) id->buf, id->len);
1021     switch (*taskPackage->taskStatus)
1022     {
1023     case Z_TaskPackage_pending:
1024         ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "pending");
1025         break;
1026     case Z_TaskPackage_active:
1027         ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "active");
1028         break;
1029     case Z_TaskPackage_complete:
1030         ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "complete");
1031         break;
1032     case Z_TaskPackage_aborted:
1033         ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "aborted");
1034         if (taskPackage->num_packageDiagnostics &&
1035             taskPackage->packageDiagnostics )
1036             response_diag(c, taskPackage->packageDiagnostics[0]);
1037         break;
1038     }
1039     /* NOTE: Only Update implemented, no others. */
1040     if (taskPackage->taskSpecificParameters->which == Z_External_update)
1041     {
1042         Z_IUUpdateTaskPackage *utp =
1043             taskPackage->taskSpecificParameters->u.update->u.taskPackage;
1044         es_response_taskpackage_update(c, utp);
1045     }
1046     return 1;
1047 }
1048
1049 static void handle_Z3950_es_response(ZOOM_connection c,
1050                                      Z_ExtendedServicesResponse *res)
1051 {
1052     if (!c->tasks)
1053         return;
1054     assert(c->tasks->which == ZOOM_TASK_PACKAGE);
1055     switch (*res->operationStatus)
1056     {
1057     case Z_ExtendedServicesResponse_done:
1058         ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "done");
1059         break;
1060     case Z_ExtendedServicesResponse_accepted:
1061         ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "accepted");
1062         break;
1063     case Z_ExtendedServicesResponse_failure:
1064         ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "failure");
1065         if (res->diagnostics && res->num_diagnostics > 0)
1066             response_diag(c, res->diagnostics[0]);
1067         break;
1068     }
1069     if (res->taskPackage &&
1070         res->taskPackage->which == Z_External_extendedService)
1071     {
1072         Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
1073         es_response_taskpackage(c, taskPackage);
1074     }
1075     if (res->taskPackage &&
1076         res->taskPackage->which == Z_External_octet)
1077     {
1078         Odr_oct *doc = res->taskPackage->u.octet_aligned;
1079         ZOOM_options_setl(c->tasks->u.package->options,
1080                           "xmlUpdateDoc", (char*) doc->buf, doc->len);
1081     }
1082 }
1083
1084 static char *get_term_cstr(ODR odr, Z_Term *term)
1085 {
1086     switch (term->which)
1087     {
1088     case Z_Term_general:
1089         return odr_strdupn(odr, term->u.general->buf, term->u.general->len);
1090         break;
1091     case Z_Term_characterString:
1092         return odr_strdup(odr, term->u.characterString);
1093     }
1094     return 0;
1095 }
1096
1097 static ZOOM_facet_field get_zoom_facet_field(ODR odr, Z_FacetField *facet)
1098 {
1099     int i;
1100     struct yaz_facet_attr attr_values;
1101     ZOOM_facet_field facet_field = odr_malloc(odr, sizeof(*facet_field));
1102     yaz_facet_attr_init(&attr_values);
1103     yaz_facet_attr_get_z_attributes(facet->attributes, &attr_values);
1104     facet_field->facet_name = odr_strdup(odr, attr_values.useattr);
1105     facet_field->num_terms = facet->num_terms;
1106     yaz_log(YLOG_DEBUG, "ZOOM_facet_field %s %d terms %d",
1107             attr_values.useattr, attr_values.limit, facet->num_terms);
1108     facet_field->facet_terms =
1109         odr_malloc(odr, facet->num_terms * sizeof(*facet_field->facet_terms));
1110     for (i = 0 ; i < facet->num_terms; i++)
1111     {
1112         Z_FacetTerm *facetTerm = facet->terms[i];
1113         facet_field->facet_terms[i].frequency = *facetTerm->count;
1114         facet_field->facet_terms[i].term = get_term_cstr(odr, facetTerm->term);
1115         yaz_log(YLOG_DEBUG, "    term[%d] %s %d",
1116                 i, facet_field->facet_terms[i].term,
1117                 facet_field->facet_terms[i].frequency);
1118     }
1119     return facet_field;
1120 }
1121
1122 /* Can be share with SOLR/SRU/SRW requests */
1123 void ZOOM_handle_facet_list(ZOOM_resultset r, Z_FacetList *fl)
1124 {
1125     int j;
1126     r->num_res_facets = fl->num;
1127     yaz_log(YLOG_DEBUG, "Facets found: %d", fl->num);
1128     r->res_facets =  odr_malloc(r->odr, fl->num * sizeof(*r->res_facets));
1129     r->facets_names =  odr_malloc(r->odr, fl->num * sizeof(*r->facets_names));
1130     for (j = 0; j < fl->num; j++)
1131     {
1132         r->res_facets[j] = get_zoom_facet_field(r->odr, fl->elements[j]);
1133         if (!r->res_facets[j])
1134         {
1135             r->facets_names[j] = 0;
1136             yaz_log(YLOG_DEBUG, "Facet field missing on index %d !", j);
1137         }
1138         else
1139             r->facets_names[j] = (char *)
1140                 ZOOM_facet_field_name(r->res_facets[j]);
1141     }
1142 }
1143
1144 static void handle_facet_result(ZOOM_connection c, ZOOM_resultset r,
1145                                 Z_OtherInformation *o)
1146 {
1147     int i;
1148     for (i = 0; o && i < o->num_elements; i++)
1149     {
1150         if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1151         {
1152             Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1153             if (ext->which == Z_External_userFacets)
1154             {
1155                 ZOOM_handle_facet_list(r, ext->u.facetList);
1156             }
1157         }
1158     }
1159 }
1160
1161 static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
1162                                        Z_Term *term)
1163 {
1164     switch (term->which)
1165     {
1166     case Z_Term_general:
1167         ZOOM_options_setl(opt, name,
1168                           term->u.general->buf, term->u.general->len);
1169         break;
1170     case Z_Term_characterString:
1171         ZOOM_options_set(opt, name, term->u.characterString);
1172         break;
1173     case Z_Term_numeric:
1174         ZOOM_options_set_int(opt, name, *term->u.numeric);
1175         break;
1176     }
1177 }
1178
1179 static void handle_queryExpression(ZOOM_options opt, const char *name,
1180                                    Z_QueryExpression *exp)
1181 {
1182     char opt_name[80];
1183
1184     switch (exp->which)
1185     {
1186     case Z_QueryExpression_term:
1187         if (exp->u.term && exp->u.term->queryTerm)
1188         {
1189             sprintf(opt_name, "%s.term", name);
1190             handle_queryExpressionTerm(opt, opt_name, exp->u.term->queryTerm);
1191         }
1192         break;
1193     case Z_QueryExpression_query:
1194         break;
1195     }
1196 }
1197
1198
1199 static void handle_search_result(ZOOM_connection c, ZOOM_resultset resultset,
1200                                 Z_OtherInformation *o)
1201 {
1202     int i;
1203     for (i = 0; o && i < o->num_elements; i++)
1204     {
1205         if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1206         {
1207             Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1208
1209             if (ext->which == Z_External_searchResult1)
1210             {
1211                 int j;
1212                 Z_SearchInfoReport *sr = ext->u.searchResult1;
1213
1214                 if (sr->num)
1215                     ZOOM_options_set_int(
1216                         resultset->options, "searchresult.size", sr->num);
1217
1218                 for (j = 0; j < sr->num; j++)
1219                 {
1220                     Z_SearchInfoReport_s *ent =
1221                         ext->u.searchResult1->elements[j];
1222                     char pref[80];
1223
1224                     sprintf(pref, "searchresult.%d", j);
1225
1226                     if (ent->subqueryId)
1227                     {
1228                         char opt_name[80];
1229                         sprintf(opt_name, "%s.id", pref);
1230                         ZOOM_options_set(resultset->options, opt_name,
1231                                          ent->subqueryId);
1232                     }
1233                     if (ent->subqueryExpression)
1234                     {
1235                         char opt_name[80];
1236                         sprintf(opt_name, "%s.subquery", pref);
1237                         handle_queryExpression(resultset->options, opt_name,
1238                                                ent->subqueryExpression);
1239                     }
1240                     if (ent->subqueryInterpretation)
1241                     {
1242                         char opt_name[80];
1243                         sprintf(opt_name, "%s.interpretation", pref);
1244                         handle_queryExpression(resultset->options, opt_name,
1245                                                ent->subqueryInterpretation);
1246                     }
1247                     if (ent->subqueryRecommendation)
1248                     {
1249                         char opt_name[80];
1250                         sprintf(opt_name, "%s.recommendation", pref);
1251                         handle_queryExpression(resultset->options, opt_name,
1252                                                ent->subqueryRecommendation);
1253                     }
1254                     if (ent->subqueryCount)
1255                     {
1256                         char opt_name[80];
1257                         sprintf(opt_name, "%s.count", pref);
1258                         ZOOM_options_set_int(resultset->options, opt_name,
1259                                              *ent->subqueryCount);
1260                     }
1261                 }
1262             }
1263         }
1264     }
1265 }
1266
1267 static void handle_Z3950_search_response(ZOOM_connection c,
1268                                          Z_SearchResponse *sr)
1269 {
1270     ZOOM_resultset resultset;
1271     ZOOM_Event event;
1272
1273     if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1274         return;
1275
1276     resultset = c->tasks->u.search.resultset;
1277
1278     if (resultset->live_set == 0)
1279     {
1280         event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
1281         ZOOM_connection_put_event(c, event);
1282     }
1283     if (sr->resultSetStatus)
1284     {
1285         ZOOM_options_set_int(resultset->options, "resultSetStatus",
1286                              *sr->resultSetStatus);
1287     }
1288     if (sr->presentStatus)
1289     {
1290         ZOOM_options_set_int(resultset->options, "presentStatus",
1291                              *sr->presentStatus);
1292     }
1293     handle_search_result(c, resultset, sr->additionalSearchInfo);
1294
1295     handle_facet_result(c, resultset, sr->additionalSearchInfo);
1296
1297     resultset->size = *sr->resultCount;
1298
1299     ZOOM_memcached_hitcount(c, resultset);
1300     resultset->live_set = 2;
1301     handle_Z3950_records(c, sr->records, 0);
1302 }
1303
1304 static void handle_Z3950_sort_response(ZOOM_connection c, Z_SortResponse *res)
1305 {
1306     if (res->diagnostics && res->num_diagnostics > 0)
1307         response_diag(c, res->diagnostics[0]);
1308 }
1309
1310 static void handle_Z3950_scan_response(ZOOM_connection c, Z_ScanResponse *res)
1311 {
1312     NMEM nmem = odr_extract_mem(c->odr_in);
1313     ZOOM_scanset scan;
1314
1315     if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
1316         return;
1317     scan = c->tasks->u.scan.scan;
1318
1319     if (res->entries && res->entries->nonsurrogateDiagnostics)
1320         response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
1321     scan->scan_response = res;
1322     scan->srw_scan_response = 0;
1323     nmem_transfer(odr_getmem(scan->odr), nmem);
1324     if (res->stepSize)
1325         ZOOM_options_set_int(scan->options, "stepSize", *res->stepSize);
1326     if (res->positionOfTerm)
1327         ZOOM_options_set_int(scan->options, "position", *res->positionOfTerm);
1328     if (res->scanStatus)
1329         ZOOM_options_set_int(scan->options, "scanStatus", *res->scanStatus);
1330     if (res->numberOfEntriesReturned)
1331         ZOOM_options_set_int(scan->options, "number",
1332                              *res->numberOfEntriesReturned);
1333     nmem_destroy(nmem);
1334 }
1335
1336 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
1337                                  int present_phase)
1338 {
1339     ZOOM_resultset resultset;
1340     int *start, *count;
1341     const char *syntax = 0, *elementSetName = 0, *schema = 0;
1342
1343     if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1344         return ;
1345
1346     resultset = c->tasks->u.search.resultset;
1347     start = &c->tasks->u.search.start;
1348     count = &c->tasks->u.search.count;
1349     syntax = c->tasks->u.search.syntax;
1350     elementSetName = c->tasks->u.search.elementSetName;
1351     schema =  c->tasks->u.search.schema;
1352
1353     if (sr && sr->which == Z_Records_NSD)
1354         response_default_diag(c, sr->u.nonSurrogateDiagnostic);
1355     else if (sr && sr->which == Z_Records_multipleNSD)
1356     {
1357         if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
1358             response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
1359         else
1360             ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1361     }
1362     else
1363     {
1364         if (*count + *start > resultset->size)
1365             *count = resultset->size - *start;
1366         if (*count < 0)
1367             *count = 0;
1368         if (sr && sr->which == Z_Records_DBOSD)
1369         {
1370             int i;
1371             NMEM nmem = odr_extract_mem(c->odr_in);
1372             Z_NamePlusRecordList *p =
1373                 sr->u.databaseOrSurDiagnostics;
1374             for (i = 0; i < p->num_records; i++)
1375             {
1376                 ZOOM_record_cache_add(resultset, p->records[i], i + *start,
1377                                       syntax, elementSetName, schema, 0);
1378             }
1379             *count -= i;
1380             if (*count < 0)
1381                 *count = 0;
1382             *start += i;
1383             yaz_log(c->log_details,
1384                     "handle_records resultset=%p start=%d count=%d",
1385                     resultset, *start, *count);
1386
1387             /* transfer our response to search_nmem .. we need it later */
1388             nmem_transfer(odr_getmem(resultset->odr), nmem);
1389             nmem_destroy(nmem);
1390             if (present_phase && p->num_records == 0)
1391             {
1392                 /* present response and we didn't get any records! */
1393                 Z_NamePlusRecord *myrec =
1394                     zget_surrogateDiagRec(
1395                         resultset->odr, 0,
1396                         YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
1397                         "ZOOM C generated. Present phase and no records");
1398                 ZOOM_record_cache_add(resultset, myrec, *start,
1399                                       syntax, elementSetName, schema, 0);
1400                 *count = 0;
1401             }
1402         }
1403         else if (present_phase)
1404         {
1405             /* present response and we didn't get any records! */
1406             Z_NamePlusRecord *myrec =
1407                 zget_surrogateDiagRec(
1408                     resultset->odr, 0,
1409                     YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
1410                     "ZOOM C generated: Present response and no records");
1411             ZOOM_record_cache_add(resultset, myrec, *start,
1412                                   syntax, elementSetName, schema, 0);
1413             *count = 0;
1414         }
1415     }
1416 }
1417
1418 static void handle_Z3950_present_response(ZOOM_connection c,
1419                                           Z_PresentResponse *pr)
1420 {
1421     handle_Z3950_records(c, pr->records, 1);
1422 }
1423
1424 static void set_init_option(const char *name, void *clientData)
1425 {
1426     ZOOM_connection c = (ZOOM_connection) clientData;
1427     char buf[80];
1428
1429     sprintf(buf, "init_opt_%.70s", name);
1430     ZOOM_connection_option_set(c, buf, "1");
1431 }
1432
1433 zoom_ret send_Z3950_sort(ZOOM_connection c, ZOOM_resultset resultset)
1434 {
1435     if (c->error)
1436         resultset->r_sort_spec = 0;
1437     if (resultset->r_sort_spec)
1438     {
1439         Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
1440         Z_SortRequest *req = apdu->u.sortRequest;
1441
1442         req->num_inputResultSetNames = 1;
1443         req->inputResultSetNames = (Z_InternationalString **)
1444             odr_malloc(c->odr_out, sizeof(*req->inputResultSetNames));
1445         req->inputResultSetNames[0] =
1446             odr_strdup(c->odr_out, resultset->setname);
1447         req->sortedResultSetName = odr_strdup(c->odr_out, resultset->setname);
1448         req->sortSequence = resultset->r_sort_spec;
1449         resultset->r_sort_spec = 0;
1450         return send_APDU(c, apdu);
1451     }
1452     return zoom_complete;
1453 }
1454
1455 static zoom_ret Z3950_send_present(ZOOM_connection c)
1456 {
1457     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
1458     Z_PresentRequest *req = apdu->u.presentRequest;
1459     ZOOM_resultset resultset = c->tasks->u.search.resultset;
1460     const char *syntax = c->tasks->u.search.syntax;
1461     const char *elementSetName = c->tasks->u.search.elementSetName;
1462     const char *schema = c->tasks->u.search.schema;
1463
1464     *req->resultSetStartPoint = c->tasks->u.search.start + 1;
1465
1466     if (resultset->step > 0 && resultset->step < c->tasks->u.search.count)
1467         *req->numberOfRecordsRequested = resultset->step;
1468     else
1469         *req->numberOfRecordsRequested = c->tasks->u.search.count;
1470
1471     if (*req->numberOfRecordsRequested + c->tasks->u.search.start > resultset->size)
1472         *req->numberOfRecordsRequested = resultset->size - c->tasks->u.search.start;
1473     assert(*req->numberOfRecordsRequested > 0);
1474
1475     if (syntax && *syntax)
1476         req->preferredRecordSyntax =
1477             zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
1478
1479     if (schema && *schema)
1480     {
1481         Z_RecordComposition *compo = (Z_RecordComposition *)
1482             odr_malloc(c->odr_out, sizeof(*compo));
1483
1484         req->recordComposition = compo;
1485         compo->which = Z_RecordComp_complex;
1486         compo->u.complex = (Z_CompSpec *)
1487             odr_malloc(c->odr_out, sizeof(*compo->u.complex));
1488         compo->u.complex->selectAlternativeSyntax = (bool_t *)
1489             odr_malloc(c->odr_out, sizeof(bool_t));
1490         *compo->u.complex->selectAlternativeSyntax = 0;
1491
1492         compo->u.complex->generic = (Z_Specification *)
1493             odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));
1494
1495         compo->u.complex->generic->which = Z_Schema_oid;
1496         compo->u.complex->generic->schema.oid = (Odr_oid *)
1497             zoom_yaz_str_to_z3950oid(c, CLASS_SCHEMA, schema);
1498
1499         if (!compo->u.complex->generic->schema.oid)
1500         {
1501             /* OID wasn't a schema! Try record syntax instead. */
1502
1503             compo->u.complex->generic->schema.oid = (Odr_oid *)
1504                 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, schema);
1505         }
1506         if (elementSetName && *elementSetName)
1507         {
1508             compo->u.complex->generic->elementSpec = (Z_ElementSpec *)
1509                 odr_malloc(c->odr_out, sizeof(Z_ElementSpec));
1510             compo->u.complex->generic->elementSpec->which =
1511                 Z_ElementSpec_elementSetName;
1512             compo->u.complex->generic->elementSpec->u.elementSetName =
1513                 odr_strdup(c->odr_out, elementSetName);
1514         }
1515         else
1516             compo->u.complex->generic->elementSpec = 0;
1517         compo->u.complex->num_dbSpecific = 0;
1518         compo->u.complex->dbSpecific = 0;
1519         compo->u.complex->num_recordSyntax = 0;
1520         compo->u.complex->recordSyntax = 0;
1521     }
1522     else if (elementSetName && *elementSetName)
1523     {
1524         Z_ElementSetNames *esn = (Z_ElementSetNames *)
1525             odr_malloc(c->odr_out, sizeof(*esn));
1526         Z_RecordComposition *compo = (Z_RecordComposition *)
1527             odr_malloc(c->odr_out, sizeof(*compo));
1528
1529         esn->which = Z_ElementSetNames_generic;
1530         esn->u.generic = odr_strdup(c->odr_out, elementSetName);
1531         compo->which = Z_RecordComp_simple;
1532         compo->u.simple = esn;
1533         req->recordComposition = compo;
1534     }
1535     req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
1536     return send_APDU(c, apdu);
1537 }
1538
1539 zoom_ret ZOOM_connection_Z3950_search(ZOOM_connection c)
1540 {
1541     int i = 0;
1542     const char *syntax = 0;
1543     const char *elementSetName = 0;
1544     const char *schema = 0;
1545     ZOOM_resultset resultset;
1546     int *start, *count;
1547
1548     if (!c->tasks)
1549         return zoom_complete;
1550     assert(c->tasks->which == ZOOM_TASK_SEARCH);
1551     resultset = c->tasks->u.search.resultset;
1552     start = &c->tasks->u.search.start;
1553     count = &c->tasks->u.search.count;
1554     syntax = c->tasks->u.search.syntax;
1555     elementSetName = c->tasks->u.search.elementSetName;
1556     schema =  c->tasks->u.search.schema;
1557
1558     yaz_log(c->log_details, "%p send_present start=%d count=%d",
1559             c, *start, *count);
1560
1561     ZOOM_memcached_search(c, resultset);
1562
1563     if (*start < 0 || *count < 0)
1564     {
1565         ZOOM_set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
1566                        "start/count < 0", 0);
1567     }
1568
1569     if (resultset->live_set)
1570     {
1571         if (*start >= resultset->size)
1572             return zoom_complete;
1573         if (*start + *count > resultset->size)
1574             *count = resultset->size - *start;
1575     }
1576
1577     if (c->error)                  /* don't continue on error */
1578         return zoom_complete;
1579     yaz_log(c->log_details, "send_present resultset=%p start=%d count=%d",
1580             resultset, *start, *count);
1581
1582     for (i = 0; i < *count; i++)
1583     {
1584         ZOOM_record rec =
1585             ZOOM_record_cache_lookup(resultset, i + *start,
1586                                      syntax, elementSetName, schema);
1587         if (!rec)
1588             break;
1589     }
1590     *start += i;
1591     *count -= i;
1592
1593     if (*count == 0 && resultset->live_set)
1594         return zoom_complete;
1595
1596     if (resultset->live_set == 2)
1597         return Z3950_send_present(c);
1598     else
1599         return Z3950_send_search(c);
1600 }
1601
1602 static zoom_ret send_Z3950_sort_present(ZOOM_connection c)
1603 {
1604     zoom_ret r = zoom_complete;
1605
1606     if (c->tasks && c->tasks->which == ZOOM_TASK_SEARCH)
1607         r = send_Z3950_sort(c, c->tasks->u.search.resultset);
1608     if (r == zoom_complete)
1609         r = ZOOM_connection_Z3950_search(c);
1610     return r;
1611 }
1612
1613 void ZOOM_handle_Z3950_apdu(ZOOM_connection c, Z_APDU *apdu)
1614 {
1615     Z_InitResponse *initrs;
1616
1617     ZOOM_connection_set_mask(c, 0);
1618     yaz_log(c->log_details, "%p handle_Z3950_apdu apdu->which=%d",
1619             c, apdu->which);
1620     switch (apdu->which)
1621     {
1622     case Z_APDU_initResponse:
1623         yaz_log(c->log_api, "%p handle_Z3950_apdu: Received Init response", c);
1624         initrs = apdu->u.initResponse;
1625         ZOOM_connection_option_set(c, "serverImplementationId",
1626                                    initrs->implementationId ?
1627                                    initrs->implementationId : "");
1628         ZOOM_connection_option_set(c, "serverImplementationName",
1629                                    initrs->implementationName ?
1630                                    initrs->implementationName : "");
1631         ZOOM_connection_option_set(c, "serverImplementationVersion",
1632                                    initrs->implementationVersion ?
1633                                    initrs->implementationVersion : "");
1634         /* Set the three old options too, for old applications */
1635         ZOOM_connection_option_set(c, "targetImplementationId",
1636                                    initrs->implementationId ?
1637                                    initrs->implementationId : "");
1638         ZOOM_connection_option_set(c, "targetImplementationName",
1639                                    initrs->implementationName ?
1640                                    initrs->implementationName : "");
1641         ZOOM_connection_option_set(c, "targetImplementationVersion",
1642                                    initrs->implementationVersion ?
1643                                    initrs->implementationVersion : "");
1644
1645         /* Make initrs->options available as ZOOM-level options */
1646         yaz_init_opt_decode(initrs->options, set_init_option, (void*) c);
1647
1648         if (!*initrs->result)
1649         {
1650             Z_DefaultDiagFormat *df = yaz_decode_init_diag(0, initrs);
1651             if (df)
1652                 response_default_diag(c, df);
1653             else
1654                 ZOOM_set_error(c, ZOOM_ERROR_INIT, 0); /* default error */
1655         }
1656         else
1657         {
1658             char *cookie =
1659                 yaz_oi_get_string_oid(&apdu->u.initResponse->otherInfo,
1660                                       yaz_oid_userinfo_cookie, 1, 0);
1661             xfree(c->cookie_in);
1662             c->cookie_in = 0;
1663             if (cookie)
1664                 c->cookie_in = xstrdup(cookie);
1665             if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
1666                 ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
1667                 c->support_named_resultsets = 1;
1668             if (c->tasks)
1669             {
1670                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1671                 ZOOM_connection_remove_task(c);
1672             }
1673             ZOOM_connection_exec_task(c);
1674         }
1675         if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
1676         {
1677             NMEM tmpmem = nmem_create();
1678             Z_CharSetandLanguageNegotiation *p =
1679                 yaz_get_charneg_record(initrs->otherInfo);
1680
1681             if (p)
1682             {
1683                 char *charset = NULL, *lang = NULL;
1684                 int sel;
1685
1686                 yaz_get_response_charneg(tmpmem, p, &charset, &lang, &sel);
1687                 yaz_log(c->log_details, "%p handle_Z3950_apdu target accepted: "
1688                         "charset %s, language %s, select %d",
1689                         c,
1690                         charset ? charset : "none", lang ? lang : "none", sel);
1691                 if (charset)
1692                     ZOOM_connection_option_set(c, "negotiation-charset",
1693                                                charset);
1694                 if (lang)
1695                     ZOOM_connection_option_set(c, "negotiation-lang",
1696                                                lang);
1697
1698                 ZOOM_connection_option_set(
1699                     c,  "negotiation-charset-in-effect-for-records",
1700                     (sel != 0) ? "1" : "0");
1701                 nmem_destroy(tmpmem);
1702             }
1703         }
1704         break;
1705     case Z_APDU_searchResponse:
1706         yaz_log(c->log_api, "%p handle_Z3950_apdu Search response", c);
1707         handle_Z3950_search_response(c, apdu->u.searchResponse);
1708         if (send_Z3950_sort_present(c) == zoom_complete)
1709             ZOOM_connection_remove_task(c);
1710         break;
1711     case Z_APDU_presentResponse:
1712         yaz_log(c->log_api, "%p handle_Z3950_apdu Present response", c);
1713         handle_Z3950_present_response(c, apdu->u.presentResponse);
1714         if (ZOOM_connection_Z3950_search(c) == zoom_complete)
1715             ZOOM_connection_remove_task(c);
1716         break;
1717     case Z_APDU_sortResponse:
1718         yaz_log(c->log_api, "%p handle_Z3950_apdu Sort response", c);
1719         handle_Z3950_sort_response(c, apdu->u.sortResponse);
1720         ZOOM_connection_remove_task(c);
1721         break;
1722     case Z_APDU_scanResponse:
1723         yaz_log(c->log_api, "%p handle_Z3950_apdu Scan response", c);
1724         handle_Z3950_scan_response(c, apdu->u.scanResponse);
1725         ZOOM_connection_remove_task(c);
1726         break;
1727     case Z_APDU_extendedServicesResponse:
1728         yaz_log(c->log_api, "%p handle_Z3950_apdu Extended Services response", c);
1729         handle_Z3950_es_response(c, apdu->u.extendedServicesResponse);
1730         ZOOM_connection_remove_task(c);
1731         break;
1732     case Z_APDU_close:
1733         yaz_log(c->log_api, "%p handle_Z3950_apdu Close PDU", c);
1734         if (!ZOOM_test_reconnect(c))
1735         {
1736             ZOOM_set_dset_error(c, ZOOM_ERROR_CONNECTION_LOST, "ZOOM", c->host_port, apdu->u.close->diagnosticInformation);
1737             ZOOM_connection_close(c);
1738         }
1739         break;
1740     default:
1741         yaz_log(c->log_api, "%p Received unknown PDU", c);
1742         ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1743         ZOOM_connection_close(c);
1744     }
1745 }
1746
1747 /*
1748  * Local variables:
1749  * c-basic-offset: 4
1750  * c-file-style: "Stroustrup"
1751  * indent-tabs-mode: nil
1752  * End:
1753  * vim: shiftwidth=4 tabstop=8 expandtab
1754  */
1755