1 /* This file is part of the YAZ toolkit.
2 * Copyright (C) 1995-2010 Index Data
3 * See the file LICENSE for details.
7 * \brief Implements ZOOM Z39.50 handling
15 #include <yaz/yaz-util.h>
16 #include <yaz/xmalloc.h>
17 #include <yaz/otherinfo.h>
19 #include <yaz/pquery.h>
20 #include <yaz/marcdisp.h>
21 #include <yaz/diagbib1.h>
22 #include <yaz/charneg.h>
24 #include <yaz/query-charset.h>
25 #include <yaz/copy_types.h>
26 #include <yaz/snprintf.h>
27 #include <yaz/facet.h>
29 #include <yaz/shptr.h>
32 * This wrapper is just for logging failed lookups. It would be nicer
33 * if it could cause failure when a lookup fails, but that's hard.
35 static Odr_oid *zoom_yaz_str_to_z3950oid(ZOOM_connection c,
36 oid_class oid_class, const char *str) {
37 Odr_oid *res = yaz_string_to_oid_odr(yaz_oid_std(), oid_class, str,
40 yaz_log(YLOG_WARN, "%p OID lookup (%d, '%s') failed",
41 c, (int) oid_class, str);
45 static Z_APDU *create_es_package(ZOOM_package p, const Odr_oid *oid)
48 Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
49 Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
51 str = ZOOM_options_get(p->options, "package-name");
53 req->packageName = odr_strdup(p->odr_out, str);
55 str = ZOOM_options_get(p->options, "user-id");
57 req->userId = odr_strdup_null(p->odr_out, str);
59 req->packageType = odr_oiddup(p->odr_out, oid);
61 str = ZOOM_options_get(p->options, "function");
64 if (!strcmp (str, "create"))
65 *req->function = Z_ExtendedServicesRequest_create;
66 if (!strcmp (str, "delete"))
67 *req->function = Z_ExtendedServicesRequest_delete;
68 if (!strcmp (str, "modify"))
69 *req->function = Z_ExtendedServicesRequest_modify;
72 str = ZOOM_options_get(p->options, "waitAction");
75 if (!strcmp (str, "wait"))
76 *req->waitAction = Z_ExtendedServicesRequest_wait;
77 if (!strcmp (str, "waitIfPossible"))
78 *req->waitAction = Z_ExtendedServicesRequest_waitIfPossible;
79 if (!strcmp (str, "dontWait"))
80 *req->waitAction = Z_ExtendedServicesRequest_dontWait;
81 if (!strcmp (str, "dontReturnPackage"))
82 *req->waitAction = Z_ExtendedServicesRequest_dontReturnPackage;
87 static const char *ill_array_lookup(void *clientData, const char *idx)
89 ZOOM_package p = (ZOOM_package) clientData;
90 return ZOOM_options_get(p->options, idx+4);
93 static Z_External *encode_ill_request(ZOOM_package p)
98 struct ill_get_ctl ctl;
100 ctl.odr = p->odr_out;
102 ctl.f = ill_array_lookup;
104 req = ill_get_ILLRequest(&ctl, "ill", 0);
106 if (!ill_Request(out, &req, 0, 0))
108 int ill_request_size;
109 char *ill_request_buf = odr_getbuf(out, &ill_request_size, 0);
111 odr_setbuf(out, ill_request_buf, ill_request_size, 1);
116 int illRequest_size = 0;
117 char *illRequest_buf = odr_getbuf(out, &illRequest_size, 0);
119 r = (Z_External *) odr_malloc(out, sizeof(*r));
120 r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
121 r->indirect_reference = 0;
123 r->which = Z_External_single;
125 r->u.single_ASN1_type =
126 odr_create_Odr_oct(out,
127 (unsigned char *)illRequest_buf,
133 static Z_ItemOrder *encode_item_order(ZOOM_package p)
135 Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc(p->odr_out, sizeof(*req));
139 req->which = Z_IOItemOrder_esRequest;
140 req->u.esRequest = (Z_IORequest *)
141 odr_malloc(p->odr_out,sizeof(Z_IORequest));
143 /* to keep part ... */
144 req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
145 odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
146 req->u.esRequest->toKeep->supplDescription = 0;
147 req->u.esRequest->toKeep->contact = (Z_IOContact *)
148 odr_malloc(p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
150 str = ZOOM_options_get(p->options, "contact-name");
151 req->u.esRequest->toKeep->contact->name =
152 odr_strdup_null(p->odr_out, str);
154 str = ZOOM_options_get(p->options, "contact-phone");
155 req->u.esRequest->toKeep->contact->phone =
156 odr_strdup_null(p->odr_out, str);
158 str = ZOOM_options_get(p->options, "contact-email");
159 req->u.esRequest->toKeep->contact->email =
160 odr_strdup_null(p->odr_out, str);
162 req->u.esRequest->toKeep->addlBilling = 0;
164 /* not to keep part ... */
165 req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
166 odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
168 str = ZOOM_options_get(p->options, "itemorder-setname");
173 req->u.esRequest->notToKeep->resultSetItem = 0;
176 req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
177 odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
179 req->u.esRequest->notToKeep->resultSetItem->resultSetId =
180 odr_strdup(p->odr_out, str);
181 req->u.esRequest->notToKeep->resultSetItem->item =
182 odr_intdup(p->odr_out, 0);
184 str = ZOOM_options_get(p->options, "itemorder-item");
185 *req->u.esRequest->notToKeep->resultSetItem->item =
186 (str ? atoi(str) : 1);
189 str = ZOOM_options_getl(p->options, "doc", &len);
192 req->u.esRequest->notToKeep->itemRequest =
193 z_ext_record_xml(p->odr_out, str, len);
196 req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
201 Z_APDU *create_admin_package(ZOOM_package p, int type,
202 Z_ESAdminOriginPartToKeep **toKeepP,
203 Z_ESAdminOriginPartNotToKeep **notToKeepP)
205 Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_admin);
208 Z_ESAdminOriginPartToKeep *toKeep;
209 Z_ESAdminOriginPartNotToKeep *notToKeep;
210 Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
211 const char *first_db = "Default";
213 char **db = ZOOM_connection_get_databases(p->connection,
219 r->direct_reference = odr_oiddup(p->odr_out, yaz_oid_extserv_admin);
221 r->indirect_reference = 0;
222 r->which = Z_External_ESAdmin;
224 r->u.adminService = (Z_Admin *)
225 odr_malloc(p->odr_out, sizeof(*r->u.adminService));
226 r->u.adminService->which = Z_Admin_esRequest;
227 r->u.adminService->u.esRequest = (Z_AdminEsRequest *)
228 odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest));
230 toKeep = r->u.adminService->u.esRequest->toKeep =
231 (Z_ESAdminOriginPartToKeep *)
232 odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest->toKeep));
233 toKeep->which = type;
234 toKeep->databaseName = odr_strdup(p->odr_out, first_db);
235 toKeep->u.create = odr_nullval();
236 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
238 r->u.adminService->u.esRequest->notToKeep = notToKeep =
239 (Z_ESAdminOriginPartNotToKeep *)
240 odr_malloc(p->odr_out,
241 sizeof(*r->u.adminService->u.esRequest->notToKeep));
242 notToKeep->which = Z_ESAdminOriginPartNotToKeep_recordsWillFollow;
243 notToKeep->u.recordsWillFollow = odr_nullval();
247 *notToKeepP = notToKeep;
252 static Z_APDU *create_xmlupdate_package(ZOOM_package p)
254 Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_xml_es);
255 Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
256 Z_External *ext = (Z_External *) odr_malloc(p->odr_out, sizeof(*ext));
258 const char *doc = ZOOM_options_getl(p->options, "doc", &len);
266 req->taskSpecificParameters = ext;
267 ext->direct_reference = req->packageType;
269 ext->indirect_reference = 0;
271 ext->which = Z_External_octet;
272 ext->u.single_ASN1_type =
273 odr_create_Odr_oct(p->odr_out, (const unsigned char *) doc, len);
277 static Z_APDU *create_update_package(ZOOM_package p)
280 const char *first_db = "Default";
282 char **db = ZOOM_connection_get_databases(p->connection, p->options,
283 &num_db, p->odr_out);
284 const char *action = ZOOM_options_get(p->options, "action");
285 int recordIdOpaque_len;
286 const char *recordIdOpaque = ZOOM_options_getl(p->options, "recordIdOpaque",
287 &recordIdOpaque_len);
288 const char *recordIdNumber = ZOOM_options_get(p->options, "recordIdNumber");
290 const char *record_buf = ZOOM_options_getl(p->options, "record",
292 int recordOpaque_len;
293 const char *recordOpaque_buf = ZOOM_options_getl(p->options, "recordOpaque",
295 const char *syntax_str = ZOOM_options_get(p->options, "syntax");
296 const char *version = ZOOM_options_get(p->options, "updateVersion");
298 const char *correlationInfo_note =
299 ZOOM_options_get(p->options, "correlationInfo.note");
300 const char *correlationInfo_id =
301 ZOOM_options_get(p->options, "correlationInfo.id");
303 Odr_oid *syntax_oid = 0;
304 const Odr_oid *package_oid = yaz_oid_extserv_database_update;
310 if (!record_buf && !recordOpaque_buf)
314 syntax_str = "SUTRS";
319 syntax_oid = yaz_string_to_oid_odr(yaz_oid_std(),
320 CLASS_RECSYN, syntax_str,
332 package_oid = yaz_oid_extserv_database_update_first_version;
333 /* old update does not support specialUpdate */
335 action = "recordInsert";
339 action = "specialUpdate";
340 package_oid = yaz_oid_extserv_database_update_second_version;
344 action = "specialUpdate";
345 package_oid = yaz_oid_extserv_database_update;
351 if (!strcmp(action, "recordInsert"))
352 action_no = Z_IUOriginPartToKeep_recordInsert;
353 else if (!strcmp(action, "recordReplace"))
354 action_no = Z_IUOriginPartToKeep_recordReplace;
355 else if (!strcmp(action, "recordDelete"))
356 action_no = Z_IUOriginPartToKeep_recordDelete;
357 else if (!strcmp(action, "elementUpdate"))
358 action_no = Z_IUOriginPartToKeep_elementUpdate;
359 else if (!strcmp(action, "specialUpdate"))
360 action_no = Z_IUOriginPartToKeep_specialUpdate;
364 apdu = create_es_package(p, package_oid);
367 Z_IUOriginPartToKeep *toKeep;
368 Z_IUSuppliedRecords *notToKeep;
369 Z_External *r = (Z_External *)
370 odr_malloc(p->odr_out, sizeof(*r));
371 const char *elementSetName =
372 ZOOM_options_get(p->options, "elementSetName");
374 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
376 r->direct_reference = odr_oiddup(p->odr_out, package_oid);
378 r->which = Z_External_update;
379 r->indirect_reference = 0;
380 r->u.update = (Z_IUUpdate *)
381 odr_malloc(p->odr_out, sizeof(*r->u.update));
383 r->u.update->which = Z_IUUpdate_esRequest;
384 r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
385 odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
386 toKeep = r->u.update->u.esRequest->toKeep =
387 (Z_IUOriginPartToKeep *)
388 odr_malloc(p->odr_out, sizeof(*toKeep));
390 toKeep->databaseName = odr_strdup(p->odr_out, first_db);
393 toKeep->elementSetName = odr_strdup_null(p->odr_out, elementSetName);
395 toKeep->actionQualifier = 0;
396 toKeep->action = odr_intdup(p->odr_out, action_no);
398 notToKeep = r->u.update->u.esRequest->notToKeep =
399 (Z_IUSuppliedRecords *)
400 odr_malloc(p->odr_out, sizeof(*notToKeep));
402 notToKeep->elements = (Z_IUSuppliedRecords_elem **)
403 odr_malloc(p->odr_out, sizeof(*notToKeep->elements));
404 notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
405 odr_malloc(p->odr_out, sizeof(**notToKeep->elements));
406 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
409 notToKeep->elements[0]->u.opaque =
410 odr_create_Odr_oct(p->odr_out,
411 (const unsigned char *) recordIdOpaque,
414 else if (recordIdNumber)
416 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;
418 notToKeep->elements[0]->u.number =
419 odr_intdup(p->odr_out, atoi(recordIdNumber));
422 notToKeep->elements[0]->u.opaque = 0;
423 notToKeep->elements[0]->supplementalId = 0;
424 if (correlationInfo_note || correlationInfo_id)
426 Z_IUCorrelationInfo *ci;
427 ci = notToKeep->elements[0]->correlationInfo =
428 (Z_IUCorrelationInfo *) odr_malloc(p->odr_out, sizeof(*ci));
429 ci->note = odr_strdup_null(p->odr_out, correlationInfo_note);
430 ci->id = correlationInfo_id ?
431 odr_intdup(p->odr_out, atoi(correlationInfo_id)) : 0;
434 notToKeep->elements[0]->correlationInfo = 0;
435 if (recordOpaque_buf)
437 notToKeep->elements[0]->record =
438 z_ext_record_oid_any(p->odr_out, syntax_oid,
439 recordOpaque_buf, recordOpaque_len);
443 notToKeep->elements[0]->record =
444 z_ext_record_oid(p->odr_out, syntax_oid,
445 record_buf, record_len);
450 ODR print = odr_createmem(ODR_PRINT);
452 z_APDU(print, &apdu, 0, 0);
459 static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
462 for (i = 0; i<200; i++)
466 Z_OtherInformation **oi;
471 sprintf(buf, "otherInfo%d", i);
472 val = ZOOM_options_get(c->options, buf);
475 cp = strchr(val, ':');
479 if (len >= sizeof(buf))
481 memcpy(buf, val, len);
484 oid = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_USERINFO,
490 yaz_oi_set_string_oid(oi, out, oid, 1, cp+1);
496 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
501 Z_OtherInformation **oi;
503 yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_cookie,
508 Z_OtherInformation **oi;
510 yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_client_ip,
513 otherInfo_attach(c, a, out);
514 if (!z_APDU(out, &a, 0, 0))
516 FILE *outf = fopen("/tmp/apdu.txt", "a");
519 ODR odr_pr = odr_createmem(ODR_PRINT);
520 fprintf(outf, "a=%p\n", a);
521 odr_setprint(odr_pr, outf);
522 z_APDU(odr_pr, &a, 0, 0);
525 yaz_log(c->log_api, "%p encoding_APDU: encoding failed", c);
526 ZOOM_set_error(c, ZOOM_ERROR_ENCODE, 0);
531 z_APDU(c->odr_print, &a, 0, 0);
532 yaz_log(c->log_details, "%p encoding_APDU encoding OK", c);
536 static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
540 if (encode_APDU(c, a, c->odr_out))
541 return zoom_complete;
542 yaz_log(c->log_details, "%p send APDU type=%d", c, a->which);
543 c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
544 event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
545 ZOOM_connection_put_event(c, event);
546 odr_reset(c->odr_out);
547 return ZOOM_send_buf(c);
550 zoom_ret ZOOM_connection_Z3950_send_init(ZOOM_connection c)
552 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
553 Z_InitRequest *ireq = apdu->u.initRequest;
554 Z_IdAuthentication *auth = (Z_IdAuthentication *)
555 odr_malloc(c->odr_out, sizeof(*auth));
557 ODR_MASK_SET(ireq->options, Z_Options_search);
558 ODR_MASK_SET(ireq->options, Z_Options_present);
559 ODR_MASK_SET(ireq->options, Z_Options_scan);
560 ODR_MASK_SET(ireq->options, Z_Options_sort);
561 ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
562 ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
564 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
565 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
566 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
568 ireq->implementationId =
569 odr_prepend(c->odr_out,
570 ZOOM_options_get(c->options, "implementationId"),
571 ireq->implementationId);
573 ireq->implementationName =
574 odr_prepend(c->odr_out,
575 ZOOM_options_get(c->options, "implementationName"),
576 odr_prepend(c->odr_out, "ZOOM-C",
577 ireq->implementationName));
579 ireq->implementationVersion =
580 odr_prepend(c->odr_out,
581 ZOOM_options_get(c->options, "implementationVersion"),
582 ireq->implementationVersion);
584 *ireq->maximumRecordSize = c->maximum_record_size;
585 *ireq->preferredMessageSize = c->preferred_message_size;
587 if (c->group || c->password)
589 Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
590 pass->groupId = odr_strdup_null(c->odr_out, c->group);
591 pass->userId = odr_strdup_null(c->odr_out, c->user);
592 pass->password = odr_strdup_null(c->odr_out, c->password);
593 auth->which = Z_IdAuthentication_idPass;
594 auth->u.idPass = pass;
595 ireq->idAuthentication = auth;
599 auth->which = Z_IdAuthentication_open;
600 auth->u.open = odr_strdup(c->odr_out, c->user);
601 ireq->idAuthentication = auth;
605 yaz_oi_set_string_oid(&ireq->otherInfo, c->odr_out,
606 yaz_oid_userinfo_proxy, 1, c->host_port);
608 if (c->charset || c->lang)
610 Z_OtherInformation **oi;
611 Z_OtherInformationUnit *oi_unit;
613 yaz_oi_APDU(apdu, &oi);
615 if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
617 ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
618 oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
619 oi_unit->information.externallyDefinedInfo =
620 yaz_set_proposal_charneg_list(c->odr_out, " ",
621 c->charset, c->lang, 1);
625 return send_APDU(c, apdu);
628 zoom_ret ZOOM_connection_Z3950_send_search(ZOOM_connection c)
631 int lslb, ssub, mspn;
633 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
634 Z_SearchRequest *search_req = apdu->u.searchRequest;
635 const char *elementSetName;
636 const char *smallSetElementSetName;
637 const char *mediumSetElementSetName;
641 assert(c->tasks->which == ZOOM_TASK_SEARCH);
643 r = c->tasks->u.search.resultset;
645 yaz_log(c->log_details, "%p ZOOM_connection_send_search set=%p", c, r);
648 ZOOM_options_get(r->options, "elementSetName");
649 smallSetElementSetName =
650 ZOOM_options_get(r->options, "smallSetElementSetName");
651 mediumSetElementSetName =
652 ZOOM_options_get(r->options, "mediumSetElementSetName");
654 if (!smallSetElementSetName)
655 smallSetElementSetName = elementSetName;
657 if (!mediumSetElementSetName)
658 mediumSetElementSetName = elementSetName;
660 facets = ZOOM_options_get(r->options, "facets");
662 Z_FacetList *facet_list = yaz_pqf_parse_facet_list(c->odr_out, facets);
664 Z_OtherInformation **oi;
665 yaz_oi_APDU(apdu, &oi);
667 yaz_oi_set_facetlist(oi, c->odr_out, facet_list);
675 /* prepare query for the search request */
676 search_req->query = ZOOM_query_get_Z_Query(r->query);
677 if (!search_req->query)
679 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
680 return zoom_complete;
682 if (search_req->query->which == Z_Query_type_1 ||
683 search_req->query->which == Z_Query_type_101)
685 const char *cp = ZOOM_options_get(r->options, "rpnCharset");
688 yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
692 search_req->query = yaz_copy_Z_Query(search_req->query,
695 r = yaz_query_charset_convert_rpnquery_check(
696 search_req->query->u.type_1,
700 { /* query could not be char converted */
701 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
702 return zoom_complete;
707 search_req->databaseNames = r->databaseNames;
708 search_req->num_databaseNames = r->num_databaseNames;
710 /* get syntax (no need to provide unless piggyback is in effect) */
711 syntax = c->tasks->u.search.syntax;
713 lslb = ZOOM_options_get_int(r->options, "largeSetLowerBound", -1);
714 ssub = ZOOM_options_get_int(r->options, "smallSetUpperBound", -1);
715 mspn = ZOOM_options_get_int(r->options, "mediumSetPresentNumber", -1);
716 if (lslb != -1 && ssub != -1 && mspn != -1)
718 /* So're a Z39.50 expert? Let's hope you don't do sort */
719 *search_req->largeSetLowerBound = lslb;
720 *search_req->smallSetUpperBound = ssub;
721 *search_req->mediumSetPresentNumber = mspn;
723 else if (c->tasks->u.search.start == 0 && c->tasks->u.search.count > 0
724 && r->piggyback && !r->r_sort_spec && !r->schema)
726 /* Regular piggyback - do it unless we're going to do sort */
727 *search_req->largeSetLowerBound = 2000000000;
728 *search_req->smallSetUpperBound = 1;
729 *search_req->mediumSetPresentNumber =
730 r->step>0 ? r->step : c->tasks->u.search.count;
734 /* non-piggyback. Need not provide elementsets or syntaxes .. */
735 smallSetElementSetName = 0;
736 mediumSetElementSetName = 0;
739 if (smallSetElementSetName && *smallSetElementSetName)
741 Z_ElementSetNames *esn = (Z_ElementSetNames *)
742 odr_malloc(c->odr_out, sizeof(*esn));
744 esn->which = Z_ElementSetNames_generic;
745 esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
746 search_req->smallSetElementSetNames = esn;
748 if (mediumSetElementSetName && *mediumSetElementSetName)
750 Z_ElementSetNames *esn =(Z_ElementSetNames *)
751 odr_malloc(c->odr_out, sizeof(*esn));
753 esn->which = Z_ElementSetNames_generic;
754 esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
755 search_req->mediumSetElementSetNames = esn;
758 search_req->preferredRecordSyntax =
759 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
763 if (c->support_named_resultsets)
767 /* find the lowest unused ordinal so that we re-use
768 result sets on the server. */
769 for (ord = 1; ; ord++)
771 #if ZOOM_RESULT_LISTS
773 sprintf(setname, "%d", ord);
774 for (rsp = c->resultsets; rsp; rsp = rsp->next)
775 if (rsp->resultset->setname && !strcmp(rsp->resultset->setname, setname))
781 sprintf(setname, "%d", ord);
782 for (rp = c->resultsets; rp; rp = rp->next)
783 if (rp->setname && !strcmp(rp->setname, setname))
790 r->setname = xstrdup(setname);
791 yaz_log(c->log_details, "%p ZOOM_connection_send_search: "
792 "allocating set %s", c, r->setname);
796 yaz_log(c->log_details, "%p ZOOM_connection_send_search: using "
798 r->setname = xstrdup("default");
800 ZOOM_options_set(r->options, "setname", r->setname);
802 search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
803 return send_APDU(c, apdu);
806 zoom_ret ZOOM_connection_Z3950_send_scan(ZOOM_connection c)
809 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
810 Z_ScanRequest *req = apdu->u.scanRequest;
813 yaz_log(c->log_details, "%p send_scan", c);
815 return zoom_complete;
816 assert (c->tasks->which == ZOOM_TASK_SCAN);
817 scan = c->tasks->u.scan.scan;
819 z_query = ZOOM_query_get_Z_Query(scan->query);
821 /* Z39.50 scan can only carry RPN */
822 if (z_query->which == Z_Query_type_1 ||
823 z_query->which == Z_Query_type_101)
825 Z_RPNQuery *rpn = z_query->u.type_1;
826 const char *cp = ZOOM_options_get(scan->options, "rpnCharset");
829 yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
832 rpn = yaz_copy_z_RPNQuery(rpn, c->odr_out);
834 yaz_query_charset_convert_rpnquery(
835 rpn, c->odr_out, cd);
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)
845 req->termListAndStartPoint =
846 rpn->RPNStructure->u.simple->u.attributesPlusTerm;
850 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
851 return zoom_complete;
856 ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
857 return zoom_complete;
860 *req->numberOfTermsRequested =
861 ZOOM_options_get_int(scan->options, "number", 20);
863 req->preferredPositionInResponse =
864 odr_intdup(c->odr_out,
865 ZOOM_options_get_int(scan->options, "position", 1));
868 odr_intdup(c->odr_out,
869 ZOOM_options_get_int(scan->options, "stepSize", 0));
871 req->databaseNames = scan->databaseNames;
872 req->num_databaseNames = scan->num_databaseNames;
874 return send_APDU(c, apdu);
878 ZOOM_package_send(ZOOM_package p, const char *type)
885 odr_reset(p->odr_out);
888 if (!strcmp(type, "itemorder"))
890 apdu = create_es_package(p, yaz_oid_extserv_item_order);
893 Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
895 r->direct_reference =
896 odr_oiddup(p->odr_out, yaz_oid_extserv_item_order);
898 r->which = Z_External_itemOrder;
899 r->indirect_reference = 0;
900 r->u.itemOrder = encode_item_order(p);
902 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
905 else if (!strcmp(type, "create")) /* create database */
907 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_create,
910 else if (!strcmp(type, "drop")) /* drop database */
912 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_drop,
915 else if (!strcmp(type, "commit")) /* commit changes */
917 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_commit,
920 else if (!strcmp(type, "update")) /* update record(s) */
922 apdu = create_update_package(p);
924 else if (!strcmp(type, "xmlupdate"))
926 apdu = create_xmlupdate_package(p);
930 if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
934 ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_PACKAGE);
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);
943 while (ZOOM_event(1, &c))
951 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
954 static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
956 char oid_name_buf[OID_STR_MAX];
957 const char *oid_name;
960 oid_name = yaz_oid_to_string_buf(r->diagnosticSetId, 0, oid_name_buf);
963 case Z_DefaultDiagFormat_v2Addinfo:
964 addinfo = r->u.v2Addinfo;
966 case Z_DefaultDiagFormat_v3Addinfo:
967 addinfo = r->u.v3Addinfo;
972 ZOOM_set_dset_error(c, *r->condition, oid_name, addinfo, 0);
975 static void response_diag(ZOOM_connection c, Z_DiagRec *p)
977 if (p->which != Z_DiagRec_defaultFormat)
978 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
980 response_default_diag(c, p->u.defaultFormat);
983 static int es_response_taskpackage_update(ZOOM_connection c,
984 Z_IUUpdateTaskPackage *utp)
986 if (utp && utp->targetPart)
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");
993 case Z_IUTargetPart_partial:
994 ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "partial");
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]);
1002 // NOTE: Individual record status, surrogate diagnostics, and supplemental diagnostics ARE NOT REPORTED.
1007 static int es_response_taskpackage(ZOOM_connection c,
1008 Z_TaskPackage *taskPackage)
1011 Odr_oct *id = taskPackage->targetReference;
1013 ZOOM_options_setl(c->tasks->u.package->options,
1014 "targetReference", (char*) id->buf, id->len);
1017 switch ( *taskPackage->taskStatus ) {
1018 case Z_TaskPackage_pending:
1019 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "pending");
1021 case Z_TaskPackage_active:
1022 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "active");
1024 case Z_TaskPackage_complete:
1025 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "complete");
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]);
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);
1044 static int handle_Z3950_es_response(ZOOM_connection c,
1045 Z_ExtendedServicesResponse *res)
1047 if (!c->tasks || c->tasks->which != ZOOM_TASK_PACKAGE)
1049 switch (*res->operationStatus) {
1050 case Z_ExtendedServicesResponse_done:
1051 ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "done");
1053 case Z_ExtendedServicesResponse_accepted:
1054 ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "accepted");
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]);
1062 if (res->taskPackage &&
1063 res->taskPackage->which == Z_External_extendedService)
1065 Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
1066 es_response_taskpackage(c, taskPackage);
1068 if (res->taskPackage &&
1069 res->taskPackage->which == Z_External_octet)
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);
1078 static void interpret_init_diag(ZOOM_connection c,
1079 Z_DiagnosticFormat *diag)
1083 Z_DiagnosticFormat_s *ds = diag->elements[0];
1084 if (ds->which == Z_DiagnosticFormat_s_defaultDiagRec)
1085 response_default_diag(c, ds->u.defaultDiagRec);
1090 static void interpret_otherinformation_field(ZOOM_connection c,
1091 Z_OtherInformation *ui)
1094 for (i = 0; i < ui->num_elements; i++)
1096 Z_OtherInformationUnit *unit = ui->list[i];
1097 if (unit->which == Z_OtherInfo_externallyDefinedInfo &&
1098 unit->information.externallyDefinedInfo &&
1099 unit->information.externallyDefinedInfo->which ==
1102 interpret_init_diag(c, unit->information.externallyDefinedInfo->u.diag1);
1107 static char *get_term_cstr(ODR odr, Z_Term *term) {
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);
1113 case Z_Term_characterString:
1114 return odr_strdup(odr, term->u.characterString);
1119 static ZOOM_facet_field get_zoom_facet_field(ODR odr, Z_FacetField *facet) {
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);
1139 static void handle_facet_result(ZOOM_connection c, ZOOM_resultset r,
1140 Z_OtherInformation *o)
1143 for (i = 0; o && i < o->num_elements; i++)
1145 if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1147 Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1148 if (ext->which == Z_External_userFacets)
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++)
1158 r->facets[j] = get_zoom_facet_field(r->odr, fl->elements[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]);
1168 static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
1171 switch (term->which)
1173 case Z_Term_general:
1174 ZOOM_options_setl(opt, name,
1175 (const char *)(term->u.general->buf),
1176 term->u.general->len);
1178 case Z_Term_characterString:
1179 ZOOM_options_set(opt, name, term->u.characterString);
1181 case Z_Term_numeric:
1182 ZOOM_options_set_int(opt, name, *term->u.numeric);
1187 static void handle_queryExpression(ZOOM_options opt, const char *name,
1188 Z_QueryExpression *exp)
1194 case Z_QueryExpression_term:
1195 if (exp->u.term && exp->u.term->queryTerm)
1197 sprintf(opt_name, "%s.term", name);
1198 handle_queryExpressionTerm(opt, opt_name, exp->u.term->queryTerm);
1201 case Z_QueryExpression_query:
1207 static void handle_search_result(ZOOM_connection c, ZOOM_resultset resultset,
1208 Z_OtherInformation *o)
1211 for (i = 0; o && i < o->num_elements; i++)
1213 if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1215 Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1217 if (ext->which == Z_External_searchResult1)
1220 Z_SearchInfoReport *sr = ext->u.searchResult1;
1223 ZOOM_options_set_int(
1224 resultset->options, "searchresult.size", sr->num);
1226 for (j = 0; j < sr->num; j++)
1228 Z_SearchInfoReport_s *ent =
1229 ext->u.searchResult1->elements[j];
1232 sprintf(pref, "searchresult.%d", j);
1234 if (ent->subqueryId)
1237 sprintf(opt_name, "%s.id", pref);
1238 ZOOM_options_set(resultset->options, opt_name,
1241 if (ent->subqueryExpression)
1244 sprintf(opt_name, "%s.subquery", pref);
1245 handle_queryExpression(resultset->options, opt_name,
1246 ent->subqueryExpression);
1248 if (ent->subqueryInterpretation)
1251 sprintf(opt_name, "%s.interpretation", pref);
1252 handle_queryExpression(resultset->options, opt_name,
1253 ent->subqueryInterpretation);
1255 if (ent->subqueryRecommendation)
1258 sprintf(opt_name, "%s.recommendation", pref);
1259 handle_queryExpression(resultset->options, opt_name,
1260 ent->subqueryRecommendation);
1262 if (ent->subqueryCount)
1265 sprintf(opt_name, "%s.count", pref);
1266 ZOOM_options_set_int(resultset->options, opt_name,
1267 *ent->subqueryCount);
1275 static void handle_Z3950_search_response(ZOOM_connection c,
1276 Z_SearchResponse *sr)
1278 ZOOM_resultset resultset;
1281 if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1284 event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
1285 ZOOM_connection_put_event(c, event);
1287 resultset = c->tasks->u.search.resultset;
1289 if (sr->resultSetStatus)
1291 ZOOM_options_set_int(resultset->options, "resultSetStatus",
1292 *sr->resultSetStatus);
1294 if (sr->presentStatus)
1296 ZOOM_options_set_int(resultset->options, "presentStatus",
1297 *sr->presentStatus);
1299 handle_search_result(c, resultset, sr->additionalSearchInfo);
1301 handle_facet_result(c, resultset, sr->additionalSearchInfo);
1303 resultset->size = *sr->resultCount;
1304 handle_Z3950_records(c, sr->records, 0);
1307 static void handle_Z3950_sort_response(ZOOM_connection c, Z_SortResponse *res)
1309 if (res->diagnostics && res->num_diagnostics > 0)
1310 response_diag(c, res->diagnostics[0]);
1313 static int handle_Z3950_scan_response(ZOOM_connection c, Z_ScanResponse *res)
1315 NMEM nmem = odr_extract_mem(c->odr_in);
1318 if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
1320 scan = c->tasks->u.scan.scan;
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);
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);
1340 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
1343 ZOOM_resultset resultset;
1345 const char *syntax = 0, *elementSetName = 0;
1349 switch (c->tasks->which)
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;
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;
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)
1372 if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
1373 response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
1375 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1379 if (*count + *start > resultset->size)
1380 *count = resultset->size - *start;
1383 if (sr && sr->which == Z_Records_DBOSD)
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++)
1391 ZOOM_record_cache_add(resultset, p->records[i], i + *start,
1392 syntax, elementSetName,
1399 yaz_log(c->log_details,
1400 "handle_records resultset=%p start=%d count=%d",
1401 resultset, *start, *count);
1403 /* transfer our response to search_nmem .. we need it later */
1404 nmem_transfer(odr_getmem(resultset->odr), nmem);
1406 if (present_phase && p->num_records == 0)
1408 /* present response and we didn't get any records! */
1409 Z_NamePlusRecord *myrec =
1410 zget_surrogateDiagRec(
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);
1418 else if (present_phase)
1420 /* present response and we didn't get any records! */
1421 Z_NamePlusRecord *myrec =
1422 zget_surrogateDiagRec(
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);
1432 static void handle_Z3950_present_response(ZOOM_connection c,
1433 Z_PresentResponse *pr)
1435 handle_Z3950_records(c, pr->records, 1);
1438 static void set_init_option(const char *name, void *clientData)
1440 ZOOM_connection c = (ZOOM_connection) clientData;
1443 sprintf(buf, "init_opt_%.70s", name);
1444 ZOOM_connection_option_set(c, buf, "1");
1448 zoom_ret send_Z3950_sort(ZOOM_connection c, ZOOM_resultset resultset)
1451 resultset->r_sort_spec = 0;
1452 if (resultset->r_sort_spec)
1454 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
1455 Z_SortRequest *req = apdu->u.sortRequest;
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);
1467 return zoom_complete;
1470 zoom_ret send_Z3950_present(ZOOM_connection c)
1473 Z_PresentRequest *req = 0;
1475 const char *syntax = 0;
1476 const char *elementSetName = 0;
1477 ZOOM_resultset resultset;
1482 yaz_log(c->log_details, "%p send_present no tasks", c);
1483 return zoom_complete;
1486 switch (c->tasks->which)
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;
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;
1503 return zoom_complete;
1505 yaz_log(c->log_details, "%p send_present start=%d count=%d",
1508 if (*start < 0 || *count < 0 || *start + *count > resultset->size)
1510 ZOOM_set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
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);
1518 for (i = 0; i < *count; i++)
1521 ZOOM_record_cache_lookup(resultset, i + *start,
1522 syntax, elementSetName);
1527 ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
1528 ZOOM_connection_put_event(c, event);
1536 yaz_log(c->log_details, "%p send_present skip=%d no more to fetch", c, i);
1537 return zoom_complete;
1540 apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
1541 req = apdu->u.presentRequest;
1544 yaz_log(c->log_details, "%p send_present skip=%d", c, i);
1546 *req->resultSetStartPoint = *start + 1;
1548 if (resultset->step > 0 && resultset->step < *count)
1549 *req->numberOfRecordsRequested = resultset->step;
1551 *req->numberOfRecordsRequested = *count;
1553 if (*req->numberOfRecordsRequested + *start > resultset->size)
1554 *req->numberOfRecordsRequested = resultset->size - *start;
1555 assert(*req->numberOfRecordsRequested > 0);
1557 if (syntax && *syntax)
1558 req->preferredRecordSyntax =
1559 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
1561 if (resultset->schema && *resultset->schema)
1563 Z_RecordComposition *compo = (Z_RecordComposition *)
1564 odr_malloc(c->odr_out, sizeof(*compo));
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;
1574 compo->u.complex->generic = (Z_Specification *)
1575 odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));
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);
1581 if (!compo->u.complex->generic->schema.oid)
1583 /* OID wasn't a schema! Try record syntax instead. */
1585 compo->u.complex->generic->schema.oid = (Odr_oid *)
1586 zoom_yaz_str_to_z3950oid (c, CLASS_RECSYN, resultset->schema);
1588 if (elementSetName && *elementSetName)
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);
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;
1604 else if (elementSetName && *elementSetName)
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));
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;
1617 req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
1618 return send_APDU(c, apdu);
1621 static zoom_ret send_Z3950_sort_present(ZOOM_connection c)
1623 zoom_ret r = zoom_complete;
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);
1632 void ZOOM_handle_Z3950_apdu(ZOOM_connection c, Z_APDU *apdu)
1634 Z_InitResponse *initrs;
1636 ZOOM_connection_set_mask(c, 0);
1637 yaz_log(c->log_details, "%p handle_Z3950_apdu apdu->which=%d",
1639 switch (apdu->which)
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 : "");
1664 /* Make initrs->options available as ZOOM-level options */
1665 yaz_init_opt_decode(initrs->options, set_init_option, (void*) c);
1667 if (!*initrs->result)
1669 Z_External *uif = initrs->userInformationField;
1671 ZOOM_set_error(c, ZOOM_ERROR_INIT, 0); /* default error */
1673 if (uif && uif->which == Z_External_userInfo1)
1674 interpret_otherinformation_field(c, uif->u.userInfo1);
1679 yaz_oi_get_string_oid(&apdu->u.initResponse->otherInfo,
1680 yaz_oid_userinfo_cookie, 1, 0);
1681 xfree(c->cookie_in);
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;
1690 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1691 ZOOM_connection_remove_task(c);
1693 ZOOM_connection_exec_task(c);
1695 if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
1697 NMEM tmpmem = nmem_create();
1698 Z_CharSetandLanguageNegotiation *p =
1699 yaz_get_charneg_record(initrs->otherInfo);
1703 char *charset = NULL, *lang = NULL;
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",
1710 charset ? charset : "none", lang ? lang : "none", sel);
1712 ZOOM_connection_option_set(c, "negotiation-charset",
1715 ZOOM_connection_option_set(c, "negotiation-lang",
1718 ZOOM_connection_option_set(
1719 c, "negotiation-charset-in-effect-for-records",
1720 (sel != 0) ? "1" : "0");
1721 nmem_destroy(tmpmem);
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);
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);
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);
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);
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);
1754 yaz_log(c->log_api, "%p handle_Z3950_apdu Close PDU", c);
1755 if (!ZOOM_test_reconnect(c))
1757 ZOOM_set_error(c, ZOOM_ERROR_CONNECTION_LOST, c->host_port);
1758 ZOOM_connection_close(c);
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);
1771 * c-file-style: "Stroustrup"
1772 * indent-tabs-mode: nil
1774 * vim: shiftwidth=4 tabstop=8 expandtab