src/zoom-z3950.c

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