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