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/srw.h>
  25 #include <yaz/cql.h>
  26 #include <yaz/ccl.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         return 0;
 328
 329     if (num_db > 0)
 330         first_db = db[0];
 331
 332     switch(*version)
 333     {
 334     case '1':
 335         package_oid = yaz_oid_extserv_database_update_first_version;
 336         /* old update does not support specialUpdate */
 337         if (!action)
 338             action = "recordInsert";
 339         break;
 340     case '2':
 341         if (!action)
 342             action = "specialUpdate";
 343         package_oid = yaz_oid_extserv_database_update_second_version;
 344         break;
 345     case '3':
 346         if (!action)
 347             action = "specialUpdate";
 348         package_oid = yaz_oid_extserv_database_update;
 349         break;
 350     default:
 351         return 0;
 352     }
 353
 354     if (!strcmp(action, "recordInsert"))
 355         action_no = Z_IUOriginPartToKeep_recordInsert;
 356     else if (!strcmp(action, "recordReplace"))
 357         action_no = Z_IUOriginPartToKeep_recordReplace;
 358     else if (!strcmp(action, "recordDelete"))
 359         action_no = Z_IUOriginPartToKeep_recordDelete;
 360     else if (!strcmp(action, "elementUpdate"))
 361         action_no = Z_IUOriginPartToKeep_elementUpdate;
 362     else if (!strcmp(action, "specialUpdate"))
 363         action_no = Z_IUOriginPartToKeep_specialUpdate;
 364     else
 365         return 0;
 366
 367     apdu = create_es_package(p, package_oid);
 368     if (apdu)
 369     {
 370         Z_IUOriginPartToKeep *toKeep;
 371         Z_IUSuppliedRecords *notToKeep;
 372         Z_External *r = (Z_External *)
 373             odr_malloc(p->odr_out, sizeof(*r));
 374         const char *elementSetName =
 375             ZOOM_options_get(p->options, "elementSetName");
 376
 377         apdu->u.extendedServicesRequest->taskSpecificParameters = r;
 378
 379         r->direct_reference = odr_oiddup(p->odr_out, package_oid);
 380         r->descriptor = 0;
 381         r->which = Z_External_update;
 382         r->indirect_reference = 0;
 383         r->u.update = (Z_IUUpdate *)
 384             odr_malloc(p->odr_out, sizeof(*r->u.update));
 385
 386         r->u.update->which = Z_IUUpdate_esRequest;
 387         r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
 388             odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
 389         toKeep = r->u.update->u.esRequest->toKeep =
 390             (Z_IUOriginPartToKeep *)
 391             odr_malloc(p->odr_out, sizeof(*toKeep));
 392
 393         toKeep->databaseName = odr_strdup(p->odr_out, first_db);
 394         toKeep->schema = 0;
 395
 396         toKeep->elementSetName = odr_strdup_null(p->odr_out, elementSetName);
 397
 398         toKeep->actionQualifier = 0;
 399         toKeep->action = odr_intdup(p->odr_out, action_no);
 400
 401         notToKeep = r->u.update->u.esRequest->notToKeep =
 402             (Z_IUSuppliedRecords *)
 403             odr_malloc(p->odr_out, sizeof(*notToKeep));
 404         notToKeep->num = 1;
 405         notToKeep->elements = (Z_IUSuppliedRecords_elem **)
 406             odr_malloc(p->odr_out, sizeof(*notToKeep->elements));
 407         notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
 408             odr_malloc(p->odr_out, sizeof(**notToKeep->elements));
 409         notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
 410         if (recordIdOpaque)
 411         {
 412             notToKeep->elements[0]->u.opaque =
 413                 odr_create_Odr_oct(p->odr_out,
 414                                    (const unsigned char *) recordIdOpaque,
 415                                    recordIdOpaque_len);
 416         }
 417         else if (recordIdNumber)
 418         {
 419             notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;
 420
 421             notToKeep->elements[0]->u.number =
 422                 odr_intdup(p->odr_out, atoi(recordIdNumber));
 423         }
 424         else
 425             notToKeep->elements[0]->u.opaque = 0;
 426         notToKeep->elements[0]->supplementalId = 0;
 427         if (correlationInfo_note || correlationInfo_id)
 428         {
 429             Z_IUCorrelationInfo *ci;
 430             ci = notToKeep->elements[0]->correlationInfo =
 431                 (Z_IUCorrelationInfo *) odr_malloc(p->odr_out, sizeof(*ci));
 432             ci->note = odr_strdup_null(p->odr_out, correlationInfo_note);
 433             ci->id = correlationInfo_id ?
 434                 odr_intdup(p->odr_out, atoi(correlationInfo_id)) : 0;
 435         }
 436         else
 437             notToKeep->elements[0]->correlationInfo = 0;
 438         if (recordOpaque_buf)
 439         {
 440             notToKeep->elements[0]->record =
 441                 z_ext_record_oid_any(p->odr_out, syntax_oid,
 442                                  recordOpaque_buf, recordOpaque_len);
 443         }
 444         else
 445         {
 446             notToKeep->elements[0]->record =
 447                 z_ext_record_oid(p->odr_out, syntax_oid,
 448                                  record_buf, record_len);
 449         }
 450     }
 451     if (0 && apdu)
 452     {
 453         ODR print = odr_createmem(ODR_PRINT);
 454
 455         z_APDU(print, &apdu, 0, 0);
 456         odr_destroy(print);
 457     }
 458     return apdu;
 459 }
 460
 461
 462 static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
 463 {
 464     int i;
 465     for (i = 0; i<200; i++)
 466     {
 467         size_t len;
 468         Odr_oid *oid;
 469         Z_OtherInformation **oi;
 470         char buf[80];
 471         const char *val;
 472         const char *cp;
 473
 474         sprintf(buf, "otherInfo%d", i);
 475         val = ZOOM_options_get(c->options, buf);
 476         if (!val)
 477             break;
 478         cp = strchr(val, ':');
 479         if (!cp)
 480             continue;
 481         len = cp - val;
 482         if (len >= sizeof(buf))
 483             len = sizeof(buf)-1;
 484         memcpy(buf, val, len);
 485         buf[len] = '\0';
 486
 487         oid = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_USERINFO,
 488                                     buf, out);
 489         if (!oid)
 490             continue;
 491
 492         yaz_oi_APDU(a, &oi);
 493         yaz_oi_set_string_oid(oi, out, oid, 1, cp+1);
 494     }
 495 }
 496
 497
 498
 499 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
 500 {
 501     assert(a);
 502     if (c->cookie_out)
 503     {
 504         Z_OtherInformation **oi;
 505         yaz_oi_APDU(a, &oi);
 506         yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_cookie,
 507                               1, c->cookie_out);
 508     }
 509     if (c->client_IP)
 510     {
 511         Z_OtherInformation **oi;
 512         yaz_oi_APDU(a, &oi);
 513         yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_client_ip,
 514                               1, c->client_IP);
 515     }
 516     otherInfo_attach(c, a, out);
 517     if (!z_APDU(out, &a, 0, 0))
 518     {
 519         FILE *outf = fopen("/tmp/apdu.txt", "a");
 520         if (a && outf)
 521         {
 522             ODR odr_pr = odr_createmem(ODR_PRINT);
 523             fprintf(outf, "a=%p\n", a);
 524             odr_setprint(odr_pr, outf);
 525             z_APDU(odr_pr, &a, 0, 0);
 526             odr_destroy(odr_pr);
 527         }
 528         yaz_log(c->log_api, "%p encoding_APDU: encoding failed", c);
 529         ZOOM_set_error(c, ZOOM_ERROR_ENCODE, 0);
 530         odr_reset(out);
 531         return -1;
 532     }
 533     if (c->odr_print)
 534         z_APDU(c->odr_print, &a, 0, 0);
 535     yaz_log(c->log_details, "%p encoding_APDU encoding OK", c);
 536     return 0;
 537 }
 538
 539 static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
 540 {
 541     ZOOM_Event event;
 542     assert(a);
 543     if (encode_APDU(c, a, c->odr_out))
 544         return zoom_complete;
 545     yaz_log(c->log_details, "%p send APDU type=%d", c, a->which);
 546     c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
 547     event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
 548     ZOOM_connection_put_event(c, event);
 549     odr_reset(c->odr_out);
 550     return ZOOM_send_buf(c);
 551 }
 552
 553 zoom_ret ZOOM_connection_Z3950_send_init(ZOOM_connection c)
 554 {
 555     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
 556     Z_InitRequest *ireq = apdu->u.initRequest;
 557     Z_IdAuthentication *auth = (Z_IdAuthentication *)
 558         odr_malloc(c->odr_out, sizeof(*auth));
 559
 560     ODR_MASK_SET(ireq->options, Z_Options_search);
 561     ODR_MASK_SET(ireq->options, Z_Options_present);
 562     ODR_MASK_SET(ireq->options, Z_Options_scan);
 563     ODR_MASK_SET(ireq->options, Z_Options_sort);
 564     ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
 565     ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
 566
 567     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
 568     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
 569     ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
 570
 571     ireq->implementationId =
 572         odr_prepend(c->odr_out,
 573                     ZOOM_options_get(c->options, "implementationId"),
 574                     ireq->implementationId);
 575
 576     ireq->implementationName =
 577         odr_prepend(c->odr_out,
 578                     ZOOM_options_get(c->options, "implementationName"),
 579                     odr_prepend(c->odr_out, "ZOOM-C",
 580                                 ireq->implementationName));
 581
 582     ireq->implementationVersion =
 583         odr_prepend(c->odr_out,
 584                     ZOOM_options_get(c->options, "implementationVersion"),
 585                                 ireq->implementationVersion);
 586
 587     *ireq->maximumRecordSize = c->maximum_record_size;
 588     *ireq->preferredMessageSize = c->preferred_message_size;
 589
 590     if (c->group || c->password)
 591     {
 592         Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
 593         pass->groupId = odr_strdup_null(c->odr_out, c->group);
 594         pass->userId = odr_strdup_null(c->odr_out, c->user);
 595         pass->password = odr_strdup_null(c->odr_out, c->password);
 596         auth->which = Z_IdAuthentication_idPass;
 597         auth->u.idPass = pass;
 598         ireq->idAuthentication = auth;
 599     }
 600     else if (c->user)
 601     {
 602         auth->which = Z_IdAuthentication_open;
 603         auth->u.open = odr_strdup(c->odr_out, c->user);
 604         ireq->idAuthentication = auth;
 605     }
 606     if (c->proxy)
 607     {
 608         yaz_oi_set_string_oid(&ireq->otherInfo, c->odr_out,
 609                               yaz_oid_userinfo_proxy, 1, c->host_port);
 610     }
 611     if (c->charset || c->lang)
 612     {
 613         Z_OtherInformation **oi;
 614         Z_OtherInformationUnit *oi_unit;
 615
 616         yaz_oi_APDU(apdu, &oi);
 617
 618         if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
 619         {
 620             ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
 621             oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
 622             oi_unit->information.externallyDefinedInfo =
 623                 yaz_set_proposal_charneg_list(c->odr_out, " ",
 624                                               c->charset, c->lang, 1);
 625         }
 626     }
 627     assert(apdu);
 628     return send_APDU(c, apdu);
 629 }
 630
 631 zoom_ret ZOOM_connection_Z3950_send_search(ZOOM_connection c)
 632 {
 633     ZOOM_resultset r;
 634     int lslb, ssub, mspn;
 635     const char *syntax;
 636     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
 637     Z_SearchRequest *search_req = apdu->u.searchRequest;
 638     const char *elementSetName;
 639     const char *smallSetElementSetName;
 640     const char *mediumSetElementSetName;
 641     const char *facets;
 642
 643     assert(c->tasks);
 644     assert(c->tasks->which == ZOOM_TASK_SEARCH);
 645
 646     r = c->tasks->u.search.resultset;
 647
 648     yaz_log(c->log_details, "%p ZOOM_connection_send_search set=%p", c, r);
 649
 650     elementSetName =
 651         ZOOM_options_get(r->options, "elementSetName");
 652     smallSetElementSetName  =
 653         ZOOM_options_get(r->options, "smallSetElementSetName");
 654     mediumSetElementSetName =
 655         ZOOM_options_get(r->options, "mediumSetElementSetName");
 656
 657     if (!smallSetElementSetName)
 658         smallSetElementSetName = elementSetName;
 659
 660     if (!mediumSetElementSetName)
 661         mediumSetElementSetName = elementSetName;
 662
 663     facets = ZOOM_options_get(r->options, "facets");
 664     if (facets) {
 665         Z_FacetList *facet_list = yaz_pqf_parse_facet_list(c->odr_out, facets);
 666         if (facet_list) {
 667             Z_OtherInformation **oi;
 668             yaz_oi_APDU(apdu, &oi);
 669             if (facet_list) {
 670                 yaz_oi_set_facetlist(oi, c->odr_out, facet_list);
 671             }
 672         }
 673     }
 674
 675     assert(r);
 676     assert(r->query);
 677
 678     /* prepare query for the search request */
 679     search_req->query = r->query->z_query;
 680     if (!search_req->query)
 681     {
 682         ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
 683         return zoom_complete;
 684     }
 685     if (r->query->z_query->which == Z_Query_type_1 ||
 686         r->query->z_query->which == Z_Query_type_101)
 687     {
 688         const char *cp = ZOOM_options_get(r->options, "rpnCharset");
 689         if (cp)
 690         {
 691             yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
 692             if (cd)
 693             {
 694                 int r;
 695                 search_req->query = yaz_copy_Z_Query(search_req->query,
 696                                                      c->odr_out);
 697
 698                 r = yaz_query_charset_convert_rpnquery_check(
 699                     search_req->query->u.type_1,
 700                     c->odr_out, cd);
 701                 yaz_iconv_close(cd);
 702                 if (r)
 703                 {  /* query could not be char converted */
 704                     ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
 705                     return zoom_complete;
 706                 }
 707             }
 708         }
 709     }
 710     search_req->databaseNames = r->databaseNames;
 711     search_req->num_databaseNames = r->num_databaseNames;
 712
 713     /* get syntax (no need to provide unless piggyback is in effect) */
 714     syntax = c->tasks->u.search.syntax;
 715
 716     lslb = ZOOM_options_get_int(r->options, "largeSetLowerBound", -1);
 717     ssub = ZOOM_options_get_int(r->options, "smallSetUpperBound", -1);
 718     mspn = ZOOM_options_get_int(r->options, "mediumSetPresentNumber", -1);
 719     if (lslb != -1 && ssub != -1 && mspn != -1)
 720     {
 721         /* So're a Z39.50 expert? Let's hope you don't do sort */
 722         *search_req->largeSetLowerBound = lslb;
 723         *search_req->smallSetUpperBound = ssub;
 724         *search_req->mediumSetPresentNumber = mspn;
 725     }
 726     else if (c->tasks->u.search.start == 0 && c->tasks->u.search.count > 0
 727              && r->piggyback && !r->r_sort_spec && !r->schema)
 728     {
 729         /* Regular piggyback - do it unless we're going to do sort */
 730         *search_req->largeSetLowerBound = 2000000000;
 731         *search_req->smallSetUpperBound = 1;
 732         *search_req->mediumSetPresentNumber =
 733             r->step>0 ? r->step : c->tasks->u.search.count;
 734     }
 735     else
 736     {
 737         /* non-piggyback. Need not provide elementsets or syntaxes .. */
 738         smallSetElementSetName = 0;
 739         mediumSetElementSetName = 0;
 740         syntax = 0;
 741     }
 742     if (smallSetElementSetName && *smallSetElementSetName)
 743     {
 744         Z_ElementSetNames *esn = (Z_ElementSetNames *)
 745             odr_malloc(c->odr_out, sizeof(*esn));
 746
 747         esn->which = Z_ElementSetNames_generic;
 748         esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
 749         search_req->smallSetElementSetNames = esn;
 750     }
 751     if (mediumSetElementSetName && *mediumSetElementSetName)
 752     {
 753         Z_ElementSetNames *esn =(Z_ElementSetNames *)
 754             odr_malloc(c->odr_out, sizeof(*esn));
 755
 756         esn->which = Z_ElementSetNames_generic;
 757         esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
 758         search_req->mediumSetElementSetNames = esn;
 759     }
 760     if (syntax)
 761         search_req->preferredRecordSyntax =
 762             zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
 763
 764     if (!r->setname)
 765     {
 766         if (c->support_named_resultsets)
 767         {
 768             char setname[14];
 769             int ord;
 770             /* find the lowest unused ordinal so that we re-use
 771                result sets on the server. */
 772             for (ord = 1; ; ord++)
 773             {
 774 #if ZOOM_RESULT_LISTS
 775                 ZOOM_resultsets rsp;
 776                 sprintf(setname, "%d", ord);
 777                 for (rsp = c->resultsets; rsp; rsp = rsp->next)
 778                     if (rsp->resultset->setname && !strcmp(rsp->resultset->setname, setname))
 779                         break;
 780                 if (!rsp)
 781                     break;
 782 #else
 783                 ZOOM_resultset rp;
 784                 sprintf(setname, "%d", ord);
 785                 for (rp = c->resultsets; rp; rp = rp->next)
 786                     if (rp->setname && !strcmp(rp->setname, setname))
 787                         break;
 788                 if (!rp)
 789                     break;
 790 #endif
 791
 792             }
 793             r->setname = xstrdup(setname);
 794             yaz_log(c->log_details, "%p ZOOM_connection_send_search: "
 795                     "allocating set %s", c, r->setname);
 796         }
 797         else
 798         {
 799             yaz_log(c->log_details, "%p ZOOM_connection_send_search: using "
 800                     "default set", c);
 801             r->setname = xstrdup("default");
 802         }
 803         ZOOM_options_set(r->options, "setname", r->setname);
 804     }
 805     search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
 806     return send_APDU(c, apdu);
 807 }
 808
 809 zoom_ret ZOOM_connection_Z3950_send_scan(ZOOM_connection c)
 810 {
 811     ZOOM_scanset scan;
 812     Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
 813     Z_ScanRequest *req = apdu->u.scanRequest;
 814
 815     yaz_log(c->log_details, "%p send_scan", c);
 816     if (!c->tasks)
 817         return zoom_complete;
 818     assert (c->tasks->which == ZOOM_TASK_SCAN);
 819     scan = c->tasks->u.scan.scan;
 820
 821     /* Z39.50 scan can only carry RPN */
 822     if (scan->query->z_query->which == Z_Query_type_1 ||
 823         scan->query->z_query->which == Z_Query_type_101)
 824     {
 825         Z_RPNQuery *rpn = scan->query->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 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                 int j;
1151                 Z_FacetList *fl = ext->u.facetList;
1152                 r->num_facets   = fl->num;
1153                 yaz_log(YLOG_DEBUG, "Facets found: %d", fl->num);
1154                 r->facets       =  odr_malloc(r->odr, r->num_facets * sizeof(*r->facets));
1155                 r->facets_names =  odr_malloc(r->odr, r->num_facets * sizeof(*r->facets_names));
1156                 for (j = 0; j < fl->num; j++)
1157                 {
1158                     r->facets[j] = get_zoom_facet_field(r->odr, fl->elements[j]);
1159                     if (!r->facets[j])
1160                         yaz_log(YLOG_DEBUG, "Facet field missing on index %d !", j);
1161                     r->facets_names[j] = (char *) ZOOM_facet_field_name(r->facets[j]);
1162                 }
1163             }
1164         }
1165     }
1166 }
1167
1168 static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
1169                                        Z_Term *term)
1170 {
1171     switch (term->which)
1172     {
1173     case Z_Term_general:
1174         ZOOM_options_setl(opt, name,
1175                           (const char *)(term->u.general->buf),
1176                           term->u.general->len);
1177         break;
1178     case Z_Term_characterString:
1179         ZOOM_options_set(opt, name, term->u.characterString);
1180         break;
1181     case Z_Term_numeric:
1182         ZOOM_options_set_int(opt, name, *term->u.numeric);
1183         break;
1184     }
1185 }
1186
1187 static void handle_queryExpression(ZOOM_options opt, const char *name,
1188                                    Z_QueryExpression *exp)
1189 {
1190     char opt_name[80];
1191
1192     switch (exp->which)
1193     {
1194     case Z_QueryExpression_term:
1195         if (exp->u.term && exp->u.term->queryTerm)
1196         {
1197             sprintf(opt_name, "%s.term", name);
1198             handle_queryExpressionTerm(opt, opt_name, exp->u.term->queryTerm);
1199         }
1200         break;
1201     case Z_QueryExpression_query:
1202         break;
1203     }
1204 }
1205
1206
1207 static void handle_search_result(ZOOM_connection c, ZOOM_resultset resultset,
1208                                 Z_OtherInformation *o)
1209 {
1210     int i;
1211     for (i = 0; o && i < o->num_elements; i++)
1212     {
1213         if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1214         {
1215             Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1216
1217             if (ext->which == Z_External_searchResult1)
1218             {
1219                 int j;
1220                 Z_SearchInfoReport *sr = ext->u.searchResult1;
1221
1222                 if (sr->num)
1223                     ZOOM_options_set_int(
1224                         resultset->options, "searchresult.size", sr->num);
1225
1226                 for (j = 0; j < sr->num; j++)
1227                 {
1228                     Z_SearchInfoReport_s *ent =
1229                         ext->u.searchResult1->elements[j];
1230                     char pref[80];
1231
1232                     sprintf(pref, "searchresult.%d", j);
1233
1234                     if (ent->subqueryId)
1235                     {
1236                         char opt_name[80];
1237                         sprintf(opt_name, "%s.id", pref);
1238                         ZOOM_options_set(resultset->options, opt_name,
1239                                          ent->subqueryId);
1240                     }
1241                     if (ent->subqueryExpression)
1242                     {
1243                         char opt_name[80];
1244                         sprintf(opt_name, "%s.subquery", pref);
1245                         handle_queryExpression(resultset->options, opt_name,
1246                                                ent->subqueryExpression);
1247                     }
1248                     if (ent->subqueryInterpretation)
1249                     {
1250                         char opt_name[80];
1251                         sprintf(opt_name, "%s.interpretation", pref);
1252                         handle_queryExpression(resultset->options, opt_name,
1253                                                ent->subqueryInterpretation);
1254                     }
1255                     if (ent->subqueryRecommendation)
1256                     {
1257                         char opt_name[80];
1258                         sprintf(opt_name, "%s.recommendation", pref);
1259                         handle_queryExpression(resultset->options, opt_name,
1260                                                ent->subqueryRecommendation);
1261                     }
1262                     if (ent->subqueryCount)
1263                     {
1264                         char opt_name[80];
1265                         sprintf(opt_name, "%s.count", pref);
1266                         ZOOM_options_set_int(resultset->options, opt_name,
1267                                              *ent->subqueryCount);
1268                     }
1269                 }
1270             }
1271         }
1272     }
1273 }
1274
1275 static void handle_Z3950_search_response(ZOOM_connection c,
1276                                          Z_SearchResponse *sr)
1277 {
1278     ZOOM_resultset resultset;
1279     ZOOM_Event event;
1280
1281     if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1282         return ;
1283
1284     event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
1285     ZOOM_connection_put_event(c, event);
1286
1287     resultset = c->tasks->u.search.resultset;
1288
1289     if (sr->resultSetStatus)
1290     {
1291         ZOOM_options_set_int(resultset->options, "resultSetStatus",
1292                              *sr->resultSetStatus);
1293     }
1294     if (sr->presentStatus)
1295     {
1296         ZOOM_options_set_int(resultset->options, "presentStatus",
1297                              *sr->presentStatus);
1298     }
1299     handle_search_result(c, resultset, sr->additionalSearchInfo);
1300
1301     handle_facet_result(c, resultset, sr->additionalSearchInfo);
1302
1303     resultset->size = *sr->resultCount;
1304     handle_Z3950_records(c, sr->records, 0);
1305 }
1306
1307 static void handle_Z3950_sort_response(ZOOM_connection c, Z_SortResponse *res)
1308 {
1309     if (res->diagnostics && res->num_diagnostics > 0)
1310         response_diag(c, res->diagnostics[0]);
1311 }
1312
1313 static int handle_Z3950_scan_response(ZOOM_connection c, Z_ScanResponse *res)
1314 {
1315     NMEM nmem = odr_extract_mem(c->odr_in);
1316     ZOOM_scanset scan;
1317
1318     if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
1319         return 0;
1320     scan = c->tasks->u.scan.scan;
1321
1322     if (res->entries && res->entries->nonsurrogateDiagnostics)
1323         response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
1324     scan->scan_response = res;
1325     scan->srw_scan_response = 0;
1326     nmem_transfer(odr_getmem(scan->odr), nmem);
1327     if (res->stepSize)
1328         ZOOM_options_set_int(scan->options, "stepSize", *res->stepSize);
1329     if (res->positionOfTerm)
1330         ZOOM_options_set_int(scan->options, "position", *res->positionOfTerm);
1331     if (res->scanStatus)
1332         ZOOM_options_set_int(scan->options, "scanStatus", *res->scanStatus);
1333     if (res->numberOfEntriesReturned)
1334         ZOOM_options_set_int(scan->options, "number",
1335                              *res->numberOfEntriesReturned);
1336     nmem_destroy(nmem);
1337     return 1;
1338 }
1339
1340 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
1341                                  int present_phase)
1342 {
1343     ZOOM_resultset resultset;
1344     int *start, *count;
1345     const char *syntax = 0, *elementSetName = 0;
1346
1347     if (!c->tasks)
1348         return ;
1349     switch (c->tasks->which)
1350     {
1351     case ZOOM_TASK_SEARCH:
1352         resultset = c->tasks->u.search.resultset;
1353         start = &c->tasks->u.search.start;
1354         count = &c->tasks->u.search.count;
1355         syntax = c->tasks->u.search.syntax;
1356         elementSetName = c->tasks->u.search.elementSetName;
1357         break;
1358     case ZOOM_TASK_RETRIEVE:
1359         resultset = c->tasks->u.retrieve.resultset;
1360         start = &c->tasks->u.retrieve.start;
1361         count = &c->tasks->u.retrieve.count;
1362         syntax = c->tasks->u.retrieve.syntax;
1363         elementSetName = c->tasks->u.retrieve.elementSetName;
1364         break;
1365     default:
1366         return;
1367     }
1368     if (sr && sr->which == Z_Records_NSD)
1369         response_default_diag(c, sr->u.nonSurrogateDiagnostic);
1370     else if (sr && sr->which == Z_Records_multipleNSD)
1371     {
1372         if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
1373             response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
1374         else
1375             ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1376     }
1377     else
1378     {
1379         if (*count + *start > resultset->size)
1380             *count = resultset->size - *start;
1381         if (*count < 0)
1382             *count = 0;
1383         if (sr && sr->which == Z_Records_DBOSD)
1384         {
1385             int i;
1386             NMEM nmem = odr_extract_mem(c->odr_in);
1387             Z_NamePlusRecordList *p =
1388                 sr->u.databaseOrSurDiagnostics;
1389             for (i = 0; i<p->num_records; i++)
1390             {
1391                 ZOOM_record_cache_add(resultset, p->records[i], i + *start,
1392                                       syntax, elementSetName,
1393                                       elementSetName, 0);
1394             }
1395             *count -= i;
1396             if (*count < 0)
1397                 *count = 0;
1398             *start += i;
1399             yaz_log(c->log_details,
1400                     "handle_records resultset=%p start=%d count=%d",
1401                     resultset, *start, *count);
1402
1403             /* transfer our response to search_nmem .. we need it later */
1404             nmem_transfer(odr_getmem(resultset->odr), nmem);
1405             nmem_destroy(nmem);
1406             if (present_phase && p->num_records == 0)
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 phase and no records");
1414                 ZOOM_record_cache_add(resultset, myrec, *start,
1415                                       syntax, elementSetName, 0, 0);
1416             }
1417         }
1418         else if (present_phase)
1419         {
1420             /* present response and we didn't get any records! */
1421             Z_NamePlusRecord *myrec =
1422                 zget_surrogateDiagRec(
1423                     resultset->odr, 0,
1424                     YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
1425                     "ZOOM C generated: Present response and no records");
1426             ZOOM_record_cache_add(resultset, myrec, *start,
1427                                   syntax, elementSetName, 0, 0);
1428         }
1429     }
1430 }
1431
1432 static void handle_Z3950_present_response(ZOOM_connection c,
1433                                           Z_PresentResponse *pr)
1434 {
1435     handle_Z3950_records(c, pr->records, 1);
1436 }
1437
1438 static void set_init_option(const char *name, void *clientData)
1439 {
1440     ZOOM_connection c = (ZOOM_connection) clientData;
1441     char buf[80];
1442
1443     sprintf(buf, "init_opt_%.70s", name);
1444     ZOOM_connection_option_set(c, buf, "1");
1445 }
1446
1447
1448 zoom_ret send_Z3950_sort(ZOOM_connection c, ZOOM_resultset resultset)
1449 {
1450     if (c->error)
1451         resultset->r_sort_spec = 0;
1452     if (resultset->r_sort_spec)
1453     {
1454         Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
1455         Z_SortRequest *req = apdu->u.sortRequest;
1456
1457         req->num_inputResultSetNames = 1;
1458         req->inputResultSetNames = (Z_InternationalString **)
1459             odr_malloc(c->odr_out, sizeof(*req->inputResultSetNames));
1460         req->inputResultSetNames[0] =
1461             odr_strdup(c->odr_out, resultset->setname);
1462         req->sortedResultSetName = odr_strdup(c->odr_out, resultset->setname);
1463         req->sortSequence = resultset->r_sort_spec;
1464         resultset->r_sort_spec = 0;
1465         return send_APDU(c, apdu);
1466     }
1467     return zoom_complete;
1468 }
1469
1470 zoom_ret send_Z3950_present(ZOOM_connection c)
1471 {
1472     Z_APDU *apdu = 0;
1473     Z_PresentRequest *req = 0;
1474     int i = 0;
1475     const char *syntax = 0;
1476     const char *elementSetName = 0;
1477     ZOOM_resultset  resultset;
1478     int *start, *count;
1479
1480     if (!c->tasks)
1481     {
1482         yaz_log(c->log_details, "%p send_present no tasks", c);
1483         return zoom_complete;
1484     }
1485
1486     switch (c->tasks->which)
1487     {
1488     case ZOOM_TASK_SEARCH:
1489         resultset = c->tasks->u.search.resultset;
1490         start = &c->tasks->u.search.start;
1491         count = &c->tasks->u.search.count;
1492         syntax = c->tasks->u.search.syntax;
1493         elementSetName = c->tasks->u.search.elementSetName;
1494         break;
1495     case ZOOM_TASK_RETRIEVE:
1496         resultset = c->tasks->u.retrieve.resultset;
1497         start = &c->tasks->u.retrieve.start;
1498         count = &c->tasks->u.retrieve.count;
1499         syntax = c->tasks->u.retrieve.syntax;
1500         elementSetName = c->tasks->u.retrieve.elementSetName;
1501         break;
1502     default:
1503         return zoom_complete;
1504     }
1505     yaz_log(c->log_details, "%p send_present start=%d count=%d",
1506             c, *start, *count);
1507
1508     if (*start < 0 || *count < 0 || *start + *count > resultset->size)
1509     {
1510         ZOOM_set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
1511                        "", 0);
1512     }
1513     if (c->error)                  /* don't continue on error */
1514         return zoom_complete;
1515     yaz_log(c->log_details, "send_present resultset=%p start=%d count=%d",
1516             resultset, *start, *count);
1517
1518     for (i = 0; i < *count; i++)
1519     {
1520         ZOOM_record rec =
1521             ZOOM_record_cache_lookup(resultset, i + *start,
1522                                      syntax, elementSetName);
1523         if (!rec)
1524             break;
1525         else
1526         {
1527             ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
1528             ZOOM_connection_put_event(c, event);
1529         }
1530     }
1531     *start += i;
1532     *count -= i;
1533
1534     if (*count == 0)
1535     {
1536         yaz_log(c->log_details, "%p send_present skip=%d no more to fetch", c, i);
1537         return zoom_complete;
1538     }
1539
1540     apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
1541     req = apdu->u.presentRequest;
1542
1543     if (i)
1544         yaz_log(c->log_details, "%p send_present skip=%d", c, i);
1545
1546     *req->resultSetStartPoint = *start + 1;
1547
1548     if (resultset->step > 0 && resultset->step < *count)
1549         *req->numberOfRecordsRequested = resultset->step;
1550     else
1551         *req->numberOfRecordsRequested = *count;
1552
1553     if (*req->numberOfRecordsRequested + *start > resultset->size)
1554         *req->numberOfRecordsRequested = resultset->size - *start;
1555     assert(*req->numberOfRecordsRequested > 0);
1556
1557     if (syntax && *syntax)
1558         req->preferredRecordSyntax =
1559             zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
1560
1561     if (resultset->schema && *resultset->schema)
1562     {
1563         Z_RecordComposition *compo = (Z_RecordComposition *)
1564             odr_malloc(c->odr_out, sizeof(*compo));
1565
1566         req->recordComposition = compo;
1567         compo->which = Z_RecordComp_complex;
1568         compo->u.complex = (Z_CompSpec *)
1569             odr_malloc(c->odr_out, sizeof(*compo->u.complex));
1570         compo->u.complex->selectAlternativeSyntax = (bool_t *)
1571             odr_malloc(c->odr_out, sizeof(bool_t));
1572         *compo->u.complex->selectAlternativeSyntax = 0;
1573
1574         compo->u.complex->generic = (Z_Specification *)
1575             odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));
1576
1577         compo->u.complex->generic->which = Z_Schema_oid;
1578         compo->u.complex->generic->schema.oid = (Odr_oid *)
1579             zoom_yaz_str_to_z3950oid (c, CLASS_SCHEMA, resultset->schema);
1580
1581         if (!compo->u.complex->generic->schema.oid)
1582         {
1583             /* OID wasn't a schema! Try record syntax instead. */
1584
1585             compo->u.complex->generic->schema.oid = (Odr_oid *)
1586                 zoom_yaz_str_to_z3950oid (c, CLASS_RECSYN, resultset->schema);
1587         }
1588         if (elementSetName && *elementSetName)
1589         {
1590             compo->u.complex->generic->elementSpec = (Z_ElementSpec *)
1591                 odr_malloc(c->odr_out, sizeof(Z_ElementSpec));
1592             compo->u.complex->generic->elementSpec->which =
1593                 Z_ElementSpec_elementSetName;
1594             compo->u.complex->generic->elementSpec->u.elementSetName =
1595                 odr_strdup(c->odr_out, elementSetName);
1596         }
1597         else
1598             compo->u.complex->generic->elementSpec = 0;
1599         compo->u.complex->num_dbSpecific = 0;
1600         compo->u.complex->dbSpecific = 0;
1601         compo->u.complex->num_recordSyntax = 0;
1602         compo->u.complex->recordSyntax = 0;
1603     }
1604     else if (elementSetName && *elementSetName)
1605     {
1606         Z_ElementSetNames *esn = (Z_ElementSetNames *)
1607             odr_malloc(c->odr_out, sizeof(*esn));
1608         Z_RecordComposition *compo = (Z_RecordComposition *)
1609             odr_malloc(c->odr_out, sizeof(*compo));
1610
1611         esn->which = Z_ElementSetNames_generic;
1612         esn->u.generic = odr_strdup(c->odr_out, elementSetName);
1613         compo->which = Z_RecordComp_simple;
1614         compo->u.simple = esn;
1615         req->recordComposition = compo;
1616     }
1617     req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
1618     return send_APDU(c, apdu);
1619 }
1620
1621 static zoom_ret send_Z3950_sort_present(ZOOM_connection c)
1622 {
1623     zoom_ret r = zoom_complete;
1624
1625     if (c->tasks && c->tasks->which == ZOOM_TASK_SEARCH)
1626         r = send_Z3950_sort(c, c->tasks->u.search.resultset);
1627     if (r == zoom_complete)
1628         r = send_Z3950_present(c);
1629     return r;
1630 }
1631
1632 void ZOOM_handle_Z3950_apdu(ZOOM_connection c, Z_APDU *apdu)
1633 {
1634     Z_InitResponse *initrs;
1635
1636     ZOOM_connection_set_mask(c, 0);
1637     yaz_log(c->log_details, "%p handle_Z3950_apdu apdu->which=%d",
1638             c, apdu->which);
1639     switch (apdu->which)
1640     {
1641     case Z_APDU_initResponse:
1642         yaz_log(c->log_api, "%p handle_Z3950_apdu: Received Init response", c);
1643         initrs = apdu->u.initResponse;
1644         ZOOM_connection_option_set(c, "serverImplementationId",
1645                                    initrs->implementationId ?
1646                                    initrs->implementationId : "");
1647         ZOOM_connection_option_set(c, "serverImplementationName",
1648                                    initrs->implementationName ?
1649                                    initrs->implementationName : "");
1650         ZOOM_connection_option_set(c, "serverImplementationVersion",
1651                                    initrs->implementationVersion ?
1652                                    initrs->implementationVersion : "");
1653         /* Set the three old options too, for old applications */
1654         ZOOM_connection_option_set(c, "targetImplementationId",
1655                                    initrs->implementationId ?
1656                                    initrs->implementationId : "");
1657         ZOOM_connection_option_set(c, "targetImplementationName",
1658                                    initrs->implementationName ?
1659                                    initrs->implementationName : "");
1660         ZOOM_connection_option_set(c, "targetImplementationVersion",
1661                                    initrs->implementationVersion ?
1662                                    initrs->implementationVersion : "");
1663
1664         /* Make initrs->options available as ZOOM-level options */
1665         yaz_init_opt_decode(initrs->options, set_init_option, (void*) c);
1666
1667         if (!*initrs->result)
1668         {
1669             Z_External *uif = initrs->userInformationField;
1670
1671             ZOOM_set_error(c, ZOOM_ERROR_INIT, 0); /* default error */
1672
1673             if (uif && uif->which == Z_External_userInfo1)
1674                 interpret_otherinformation_field(c, uif->u.userInfo1);
1675         }
1676         else
1677         {
1678             char *cookie =
1679                 yaz_oi_get_string_oid(&apdu->u.initResponse->otherInfo,
1680                                       yaz_oid_userinfo_cookie, 1, 0);
1681             xfree(c->cookie_in);
1682             c->cookie_in = 0;
1683             if (cookie)
1684                 c->cookie_in = xstrdup(cookie);
1685             if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
1686                 ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
1687                 c->support_named_resultsets = 1;
1688             if (c->tasks)
1689             {
1690                 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1691                 ZOOM_connection_remove_task(c);
1692             }
1693             ZOOM_connection_exec_task(c);
1694         }
1695         if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
1696         {
1697             NMEM tmpmem = nmem_create();
1698             Z_CharSetandLanguageNegotiation *p =
1699                 yaz_get_charneg_record(initrs->otherInfo);
1700
1701             if (p)
1702             {
1703                 char *charset = NULL, *lang = NULL;
1704                 int sel;
1705
1706                 yaz_get_response_charneg(tmpmem, p, &charset, &lang, &sel);
1707                 yaz_log(c->log_details, "%p handle_Z3950_apdu target accepted: "
1708                         "charset %s, language %s, select %d",
1709                         c,
1710                         charset ? charset : "none", lang ? lang : "none", sel);
1711                 if (charset)
1712                     ZOOM_connection_option_set(c, "negotiation-charset",
1713                                                charset);
1714                 if (lang)
1715                     ZOOM_connection_option_set(c, "negotiation-lang",
1716                                                lang);
1717
1718                 ZOOM_connection_option_set(
1719                     c,  "negotiation-charset-in-effect-for-records",
1720                     (sel != 0) ? "1" : "0");
1721                 nmem_destroy(tmpmem);
1722             }
1723         }
1724         break;
1725     case Z_APDU_searchResponse:
1726         yaz_log(c->log_api, "%p handle_Z3950_apdu Search response", c);
1727         handle_Z3950_search_response(c, apdu->u.searchResponse);
1728         if (send_Z3950_sort_present(c) == zoom_complete)
1729             ZOOM_connection_remove_task(c);
1730         break;
1731     case Z_APDU_presentResponse:
1732         yaz_log(c->log_api, "%p handle_Z3950_apdu Present response", c);
1733         handle_Z3950_present_response(c, apdu->u.presentResponse);
1734         if (send_Z3950_present(c) == zoom_complete)
1735             ZOOM_connection_remove_task(c);
1736         break;
1737     case Z_APDU_sortResponse:
1738         yaz_log(c->log_api, "%p handle_Z3950_apdu Sort response", c);
1739         handle_Z3950_sort_response(c, apdu->u.sortResponse);
1740         if (send_Z3950_present(c) == zoom_complete)
1741             ZOOM_connection_remove_task(c);
1742         break;
1743     case Z_APDU_scanResponse:
1744         yaz_log(c->log_api, "%p handle_Z3950_apdu Scan response", c);
1745         handle_Z3950_scan_response(c, apdu->u.scanResponse);
1746         ZOOM_connection_remove_task(c);
1747         break;
1748     case Z_APDU_extendedServicesResponse:
1749         yaz_log(c->log_api, "%p handle_Z3950_apdu Extended Services response", c);
1750         handle_Z3950_es_response(c, apdu->u.extendedServicesResponse);
1751         ZOOM_connection_remove_task(c);
1752         break;
1753     case Z_APDU_close:
1754         yaz_log(c->log_api, "%p handle_Z3950_apdu Close PDU", c);
1755         if (!ZOOM_test_reconnect(c))
1756         {
1757             ZOOM_set_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
1758             ZOOM_connection_close(c);
1759         }
1760         break;
1761     default:
1762         yaz_log(c->log_api, "%p Received unknown PDU", c);
1763         ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1764         ZOOM_connection_close(c);
1765     }
1766 }
1767
1768 /*
1769  * Local variables:
1770  * c-basic-offset: 4
1771  * c-file-style: "Stroustrup"
1772  * indent-tabs-mode: nil
1773  * End:
1774  * vim: shiftwidth=4 tabstop=8 expandtab
1775  */
1776