src/zoom-z3950.c

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