1 /* This file is part of the YAZ toolkit.
2 * Copyright (C) 1995-2013 Index Data
3 * See the file LICENSE for details.
7 * \brief Implements ZOOM Z39.50 handling
18 #include <yaz/yaz-util.h>
19 #include <yaz/xmalloc.h>
20 #include <yaz/otherinfo.h>
22 #include <yaz/pquery.h>
23 #include <yaz/marcdisp.h>
24 #include <yaz/diagbib1.h>
25 #include <yaz/charneg.h>
27 #include <yaz/query-charset.h>
28 #include <yaz/copy_types.h>
29 #include <yaz/snprintf.h>
30 #include <yaz/facet.h>
32 #include <yaz/shptr.h>
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.
38 static Odr_oid *zoom_yaz_str_to_z3950oid(ZOOM_connection c,
39 oid_class oid_class, const char *str) {
40 Odr_oid *res = yaz_string_to_oid_odr(yaz_oid_std(), oid_class, str,
43 yaz_log(YLOG_WARN, "%p OID lookup (%d, '%s') failed",
44 c, (int) oid_class, str);
48 static Z_APDU *create_es_package(ZOOM_package p, const Odr_oid *oid)
51 Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
52 Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
54 str = ZOOM_options_get(p->options, "package-name");
56 req->packageName = odr_strdup(p->odr_out, str);
58 str = ZOOM_options_get(p->options, "user-id");
60 req->userId = odr_strdup_null(p->odr_out, str);
62 req->packageType = odr_oiddup(p->odr_out, oid);
64 str = ZOOM_options_get(p->options, "function");
67 if (!strcmp (str, "create"))
68 *req->function = Z_ExtendedServicesRequest_create;
69 if (!strcmp (str, "delete"))
70 *req->function = Z_ExtendedServicesRequest_delete;
71 if (!strcmp (str, "modify"))
72 *req->function = Z_ExtendedServicesRequest_modify;
75 str = ZOOM_options_get(p->options, "waitAction");
78 if (!strcmp (str, "wait"))
79 *req->waitAction = Z_ExtendedServicesRequest_wait;
80 if (!strcmp (str, "waitIfPossible"))
81 *req->waitAction = Z_ExtendedServicesRequest_waitIfPossible;
82 if (!strcmp (str, "dontWait"))
83 *req->waitAction = Z_ExtendedServicesRequest_dontWait;
84 if (!strcmp (str, "dontReturnPackage"))
85 *req->waitAction = Z_ExtendedServicesRequest_dontReturnPackage;
90 static const char *ill_array_lookup(void *clientData, const char *idx)
92 ZOOM_package p = (ZOOM_package) clientData;
93 return ZOOM_options_get(p->options, idx+4);
96 static Z_External *encode_ill_request(ZOOM_package p)
101 struct ill_get_ctl ctl;
103 ctl.odr = p->odr_out;
105 ctl.f = ill_array_lookup;
107 req = ill_get_ILLRequest(&ctl, "ill", 0);
109 if (!ill_Request(out, &req, 0, 0))
111 int ill_request_size;
112 char *ill_request_buf = odr_getbuf(out, &ill_request_size, 0);
114 odr_setbuf(out, ill_request_buf, ill_request_size, 1);
119 int illRequest_size = 0;
120 char *illRequest_buf = odr_getbuf(out, &illRequest_size, 0);
122 r = (Z_External *) odr_malloc(out, sizeof(*r));
123 r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
124 r->indirect_reference = 0;
126 r->which = Z_External_single;
128 r->u.single_ASN1_type =
129 odr_create_Odr_oct(out,
130 (unsigned char *)illRequest_buf,
136 static Z_ItemOrder *encode_item_order(ZOOM_package p)
138 Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc(p->odr_out, sizeof(*req));
142 req->which = Z_IOItemOrder_esRequest;
143 req->u.esRequest = (Z_IORequest *)
144 odr_malloc(p->odr_out,sizeof(Z_IORequest));
146 /* to keep part ... */
147 req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
148 odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
149 req->u.esRequest->toKeep->supplDescription = 0;
150 req->u.esRequest->toKeep->contact = (Z_IOContact *)
151 odr_malloc(p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
153 str = ZOOM_options_get(p->options, "contact-name");
154 req->u.esRequest->toKeep->contact->name =
155 odr_strdup_null(p->odr_out, str);
157 str = ZOOM_options_get(p->options, "contact-phone");
158 req->u.esRequest->toKeep->contact->phone =
159 odr_strdup_null(p->odr_out, str);
161 str = ZOOM_options_get(p->options, "contact-email");
162 req->u.esRequest->toKeep->contact->email =
163 odr_strdup_null(p->odr_out, str);
165 req->u.esRequest->toKeep->addlBilling = 0;
167 /* not to keep part ... */
168 req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
169 odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
171 str = ZOOM_options_get(p->options, "itemorder-setname");
176 req->u.esRequest->notToKeep->resultSetItem = 0;
179 req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
180 odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
182 req->u.esRequest->notToKeep->resultSetItem->resultSetId =
183 odr_strdup(p->odr_out, str);
184 req->u.esRequest->notToKeep->resultSetItem->item =
185 odr_intdup(p->odr_out, 0);
187 str = ZOOM_options_get(p->options, "itemorder-item");
188 *req->u.esRequest->notToKeep->resultSetItem->item =
189 (str ? atoi(str) : 1);
192 str = ZOOM_options_getl(p->options, "doc", &len);
195 req->u.esRequest->notToKeep->itemRequest =
196 z_ext_record_xml(p->odr_out, str, len);
199 req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
204 Z_APDU *create_admin_package(ZOOM_package p, int type,
205 Z_ESAdminOriginPartToKeep **toKeepP,
206 Z_ESAdminOriginPartNotToKeep **notToKeepP)
208 Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_admin);
211 Z_ESAdminOriginPartToKeep *toKeep;
212 Z_ESAdminOriginPartNotToKeep *notToKeep;
213 Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
214 const char *first_db = "Default";
216 char **db = ZOOM_connection_get_databases(p->connection,
222 r->direct_reference = odr_oiddup(p->odr_out, yaz_oid_extserv_admin);
224 r->indirect_reference = 0;
225 r->which = Z_External_ESAdmin;
227 r->u.adminService = (Z_Admin *)
228 odr_malloc(p->odr_out, sizeof(*r->u.adminService));
229 r->u.adminService->which = Z_Admin_esRequest;
230 r->u.adminService->u.esRequest = (Z_AdminEsRequest *)
231 odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest));
233 toKeep = r->u.adminService->u.esRequest->toKeep =
234 (Z_ESAdminOriginPartToKeep *)
235 odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest->toKeep));
236 toKeep->which = type;
237 toKeep->databaseName = odr_strdup(p->odr_out, first_db);
238 toKeep->u.create = odr_nullval();
239 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
241 r->u.adminService->u.esRequest->notToKeep = notToKeep =
242 (Z_ESAdminOriginPartNotToKeep *)
243 odr_malloc(p->odr_out,
244 sizeof(*r->u.adminService->u.esRequest->notToKeep));
245 notToKeep->which = Z_ESAdminOriginPartNotToKeep_recordsWillFollow;
246 notToKeep->u.recordsWillFollow = odr_nullval();
250 *notToKeepP = notToKeep;
255 static Z_APDU *create_xmlupdate_package(ZOOM_package p)
257 Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_xml_es);
258 Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
259 Z_External *ext = (Z_External *) odr_malloc(p->odr_out, sizeof(*ext));
261 const char *doc = ZOOM_options_getl(p->options, "doc", &len);
269 req->taskSpecificParameters = ext;
270 ext->direct_reference = req->packageType;
272 ext->indirect_reference = 0;
274 ext->which = Z_External_octet;
275 ext->u.single_ASN1_type =
276 odr_create_Odr_oct(p->odr_out, (const unsigned char *) doc, len);
280 static Z_APDU *create_update_package(ZOOM_package p)
283 const char *first_db = "Default";
285 char **db = ZOOM_connection_get_databases(p->connection, p->options,
286 &num_db, p->odr_out);
287 const char *action = ZOOM_options_get(p->options, "action");
288 int recordIdOpaque_len;
289 const char *recordIdOpaque = ZOOM_options_getl(p->options, "recordIdOpaque",
290 &recordIdOpaque_len);
291 const char *recordIdNumber = ZOOM_options_get(p->options, "recordIdNumber");
293 const char *record_buf = ZOOM_options_getl(p->options, "record",
295 int recordOpaque_len;
296 const char *recordOpaque_buf = ZOOM_options_getl(p->options, "recordOpaque",
298 const char *syntax_str = ZOOM_options_get(p->options, "syntax");
299 const char *version = ZOOM_options_get(p->options, "updateVersion");
301 const char *correlationInfo_note =
302 ZOOM_options_get(p->options, "correlationInfo.note");
303 const char *correlationInfo_id =
304 ZOOM_options_get(p->options, "correlationInfo.id");
306 Odr_oid *syntax_oid = 0;
307 const Odr_oid *package_oid = yaz_oid_extserv_database_update;
313 if (!record_buf && !recordOpaque_buf)
317 syntax_str = "SUTRS";
322 syntax_oid = yaz_string_to_oid_odr(yaz_oid_std(),
323 CLASS_RECSYN, syntax_str,
328 ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_SYNTAX, syntax_str);
338 package_oid = yaz_oid_extserv_database_update_first_version;
339 /* old update does not support specialUpdate */
341 action = "recordInsert";
345 action = "specialUpdate";
346 package_oid = yaz_oid_extserv_database_update_second_version;
350 action = "specialUpdate";
351 package_oid = yaz_oid_extserv_database_update;
354 ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_VERSION, version);
358 if (!strcmp(action, "recordInsert"))
359 action_no = Z_IUOriginPartToKeep_recordInsert;
360 else if (!strcmp(action, "recordReplace"))
361 action_no = Z_IUOriginPartToKeep_recordReplace;
362 else if (!strcmp(action, "recordDelete"))
363 action_no = Z_IUOriginPartToKeep_recordDelete;
364 else if (!strcmp(action, "elementUpdate"))
365 action_no = Z_IUOriginPartToKeep_elementUpdate;
366 else if (!strcmp(action, "specialUpdate"))
367 action_no = Z_IUOriginPartToKeep_specialUpdate;
370 ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_ACTION, action);
374 apdu = create_es_package(p, package_oid);
377 Z_IUOriginPartToKeep *toKeep;
378 Z_IUSuppliedRecords *notToKeep;
379 Z_External *r = (Z_External *)
380 odr_malloc(p->odr_out, sizeof(*r));
381 const char *elementSetName =
382 ZOOM_options_get(p->options, "elementSetName");
384 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
386 r->direct_reference = odr_oiddup(p->odr_out, package_oid);
388 r->which = Z_External_update;
389 r->indirect_reference = 0;
390 r->u.update = (Z_IUUpdate *)
391 odr_malloc(p->odr_out, sizeof(*r->u.update));
393 r->u.update->which = Z_IUUpdate_esRequest;
394 r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
395 odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
396 toKeep = r->u.update->u.esRequest->toKeep =
397 (Z_IUOriginPartToKeep *)
398 odr_malloc(p->odr_out, sizeof(*toKeep));
400 toKeep->databaseName = odr_strdup(p->odr_out, first_db);
403 toKeep->elementSetName = odr_strdup_null(p->odr_out, elementSetName);
405 toKeep->actionQualifier = 0;
406 toKeep->action = odr_intdup(p->odr_out, action_no);
408 notToKeep = r->u.update->u.esRequest->notToKeep =
409 (Z_IUSuppliedRecords *)
410 odr_malloc(p->odr_out, sizeof(*notToKeep));
412 notToKeep->elements = (Z_IUSuppliedRecords_elem **)
413 odr_malloc(p->odr_out, sizeof(*notToKeep->elements));
414 notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
415 odr_malloc(p->odr_out, sizeof(**notToKeep->elements));
416 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
419 notToKeep->elements[0]->u.opaque =
420 odr_create_Odr_oct(p->odr_out,
421 (const unsigned char *) recordIdOpaque,
424 else if (recordIdNumber)
426 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;
428 notToKeep->elements[0]->u.number =
429 odr_intdup(p->odr_out, atoi(recordIdNumber));
432 notToKeep->elements[0]->u.opaque = 0;
433 notToKeep->elements[0]->supplementalId = 0;
434 if (correlationInfo_note || correlationInfo_id)
436 Z_IUCorrelationInfo *ci;
437 ci = notToKeep->elements[0]->correlationInfo =
438 (Z_IUCorrelationInfo *) odr_malloc(p->odr_out, sizeof(*ci));
439 ci->note = odr_strdup_null(p->odr_out, correlationInfo_note);
440 ci->id = correlationInfo_id ?
441 odr_intdup(p->odr_out, atoi(correlationInfo_id)) : 0;
444 notToKeep->elements[0]->correlationInfo = 0;
445 if (recordOpaque_buf)
447 notToKeep->elements[0]->record =
448 z_ext_record_oid_any(p->odr_out, syntax_oid,
449 recordOpaque_buf, recordOpaque_len);
453 notToKeep->elements[0]->record =
454 z_ext_record_oid(p->odr_out, syntax_oid,
455 record_buf, record_len);
460 ODR print = odr_createmem(ODR_PRINT);
462 z_APDU(print, &apdu, 0, 0);
469 static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
472 for (i = 0; i<200; i++)
476 Z_OtherInformation **oi;
481 sprintf(buf, "otherInfo%d", i);
482 val = ZOOM_options_get(c->options, buf);
485 cp = strchr(val, ':');
489 if (len >= sizeof(buf))
491 memcpy(buf, val, len);
494 oid = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_USERINFO,
500 yaz_oi_set_string_oid(oi, out, oid, 1, cp+1);
506 static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
511 Z_OtherInformation **oi;
513 yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_cookie,
518 Z_OtherInformation **oi;
520 yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_client_ip,
523 otherInfo_attach(c, a, out);
524 if (!z_APDU(out, &a, 0, 0))
526 FILE *outf = fopen("/tmp/apdu.txt", "a");
529 ODR odr_pr = odr_createmem(ODR_PRINT);
530 fprintf(outf, "a=%p\n", a);
531 odr_setprint(odr_pr, outf);
532 z_APDU(odr_pr, &a, 0, 0);
535 yaz_log(c->log_api, "%p encoding_APDU: encoding failed", c);
536 ZOOM_set_error(c, ZOOM_ERROR_ENCODE, 0);
541 z_APDU(c->odr_print, &a, 0, 0);
543 z_APDU(c->odr_save, &a, 0, 0);
544 yaz_log(c->log_details, "%p encoding_APDU encoding OK", c);
548 static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
552 if (encode_APDU(c, a, c->odr_out))
553 return zoom_complete;
554 yaz_log(c->log_details, "%p send APDU type=%d", c, a->which);
555 c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
556 event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
557 ZOOM_connection_put_event(c, event);
558 odr_reset(c->odr_out);
559 return ZOOM_send_buf(c);
562 zoom_ret ZOOM_connection_Z3950_send_init(ZOOM_connection c)
564 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
565 Z_InitRequest *ireq = apdu->u.initRequest;
566 Z_IdAuthentication *auth = (Z_IdAuthentication *)
567 odr_malloc(c->odr_out, sizeof(*auth));
569 ODR_MASK_SET(ireq->options, Z_Options_search);
570 ODR_MASK_SET(ireq->options, Z_Options_present);
571 ODR_MASK_SET(ireq->options, Z_Options_scan);
572 ODR_MASK_SET(ireq->options, Z_Options_sort);
573 ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
574 ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
576 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
577 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
578 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
580 ireq->implementationId =
581 odr_prepend(c->odr_out,
582 ZOOM_options_get(c->options, "implementationId"),
583 ireq->implementationId);
585 ireq->implementationName =
586 odr_prepend(c->odr_out,
587 ZOOM_options_get(c->options, "implementationName"),
588 odr_prepend(c->odr_out, "ZOOM-C",
589 ireq->implementationName));
591 ireq->implementationVersion =
592 odr_prepend(c->odr_out,
593 ZOOM_options_get(c->options, "implementationVersion"),
594 ireq->implementationVersion);
596 *ireq->maximumRecordSize = c->maximum_record_size;
597 *ireq->preferredMessageSize = c->preferred_message_size;
599 if (c->group || c->password)
601 Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
602 pass->groupId = odr_strdup_null(c->odr_out, c->group);
603 pass->userId = odr_strdup_null(c->odr_out, c->user);
604 pass->password = odr_strdup_null(c->odr_out, c->password);
605 auth->which = Z_IdAuthentication_idPass;
606 auth->u.idPass = pass;
607 ireq->idAuthentication = auth;
611 auth->which = Z_IdAuthentication_open;
612 auth->u.open = odr_strdup(c->odr_out, c->user);
613 ireq->idAuthentication = auth;
617 yaz_oi_set_string_oid(&ireq->otherInfo, c->odr_out,
618 yaz_oid_userinfo_proxy, 1, c->host_port);
620 if (c->charset || c->lang)
622 Z_OtherInformation **oi;
623 Z_OtherInformationUnit *oi_unit;
625 yaz_oi_APDU(apdu, &oi);
627 if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
629 ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
630 oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
631 oi_unit->information.externallyDefinedInfo =
632 yaz_set_proposal_charneg_list(c->odr_out, " ",
633 c->charset, c->lang, 1);
637 return send_APDU(c, apdu);
640 zoom_ret ZOOM_connection_Z3950_send_search(ZOOM_connection c)
643 int lslb, ssub, mspn;
646 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
647 Z_SearchRequest *search_req = apdu->u.searchRequest;
648 const char *elementSetName;
649 const char *smallSetElementSetName;
650 const char *mediumSetElementSetName;
654 assert(c->tasks->which == ZOOM_TASK_SEARCH);
656 r = c->tasks->u.search.resultset;
658 yaz_log(c->log_details, "%p ZOOM_connection_send_search set=%p", c, r);
661 ZOOM_options_get(r->options, "elementSetName");
662 smallSetElementSetName =
663 ZOOM_options_get(r->options, "smallSetElementSetName");
664 mediumSetElementSetName =
665 ZOOM_options_get(r->options, "mediumSetElementSetName");
667 if (!smallSetElementSetName)
668 smallSetElementSetName = elementSetName;
670 if (!mediumSetElementSetName)
671 mediumSetElementSetName = elementSetName;
673 facets = ZOOM_options_get(r->options, "facets");
675 Z_FacetList *facet_list = yaz_pqf_parse_facet_list(c->odr_out, facets);
677 Z_OtherInformation **oi;
678 yaz_oi_APDU(apdu, &oi);
679 yaz_oi_set_facetlist(oi, c->odr_out, facet_list);
682 yaz_log(YLOG_WARN, "Unable to parse facets: %s", facets);
688 /* prepare query for the search request */
689 search_req->query = ZOOM_query_get_Z_Query(r->query);
690 if (!search_req->query)
692 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
693 return zoom_complete;
695 if (search_req->query->which == Z_Query_type_1 ||
696 search_req->query->which == Z_Query_type_101)
698 const char *cp = ZOOM_options_get(r->options, "rpnCharset");
701 yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
705 search_req->query = yaz_copy_Z_Query(search_req->query,
708 r = yaz_query_charset_convert_rpnquery_check(
709 search_req->query->u.type_1,
713 { /* query could not be char converted */
714 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
715 return zoom_complete;
720 search_req->databaseNames = r->databaseNames;
721 search_req->num_databaseNames = r->num_databaseNames;
723 /* get syntax (no need to provide unless piggyback is in effect) */
724 syntax = c->tasks->u.search.syntax;
726 schema = c->tasks->u.search.schema;
728 lslb = ZOOM_options_get_int(r->options, "largeSetLowerBound", -1);
729 ssub = ZOOM_options_get_int(r->options, "smallSetUpperBound", -1);
730 mspn = ZOOM_options_get_int(r->options, "mediumSetPresentNumber", -1);
731 if (lslb != -1 && ssub != -1 && mspn != -1)
733 /* So're a Z39.50 expert? Let's hope you don't do sort */
734 *search_req->largeSetLowerBound = lslb;
735 *search_req->smallSetUpperBound = ssub;
736 *search_req->mediumSetPresentNumber = mspn;
738 else if (c->tasks->u.search.start == 0 && c->tasks->u.search.count > 0
739 && r->piggyback && !r->r_sort_spec && !schema)
741 /* Regular piggyback - do it unless we're going to do sort */
742 *search_req->largeSetLowerBound = 2000000000;
743 *search_req->smallSetUpperBound = 1;
744 *search_req->mediumSetPresentNumber =
745 r->step>0 ? r->step : c->tasks->u.search.count;
749 /* non-piggyback. Need not provide elementsets or syntaxes .. */
750 smallSetElementSetName = 0;
751 mediumSetElementSetName = 0;
754 if (smallSetElementSetName && *smallSetElementSetName)
756 Z_ElementSetNames *esn = (Z_ElementSetNames *)
757 odr_malloc(c->odr_out, sizeof(*esn));
759 esn->which = Z_ElementSetNames_generic;
760 esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
761 search_req->smallSetElementSetNames = esn;
763 if (mediumSetElementSetName && *mediumSetElementSetName)
765 Z_ElementSetNames *esn =(Z_ElementSetNames *)
766 odr_malloc(c->odr_out, sizeof(*esn));
768 esn->which = Z_ElementSetNames_generic;
769 esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
770 search_req->mediumSetElementSetNames = esn;
773 search_req->preferredRecordSyntax =
774 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
778 if (c->support_named_resultsets)
782 /* find the lowest unused ordinal so that we re-use
783 result sets on the server. */
784 for (ord = 1; ; ord++)
786 #if ZOOM_RESULT_LISTS
788 sprintf(setname, "%d", ord);
789 for (rsp = c->resultsets; rsp; rsp = rsp->next)
790 if (rsp->resultset->setname && !strcmp(rsp->resultset->setname, setname))
796 sprintf(setname, "%d", ord);
797 for (rp = c->resultsets; rp; rp = rp->next)
798 if (rp->setname && !strcmp(rp->setname, setname))
805 r->setname = xstrdup(setname);
806 yaz_log(c->log_details, "%p ZOOM_connection_send_search: "
807 "allocating set %s", c, r->setname);
811 yaz_log(c->log_details, "%p ZOOM_connection_send_search: using "
813 r->setname = xstrdup("default");
815 ZOOM_options_set(r->options, "setname", r->setname);
817 search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
818 return send_APDU(c, apdu);
821 zoom_ret ZOOM_connection_Z3950_send_scan(ZOOM_connection c)
824 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
825 Z_ScanRequest *req = apdu->u.scanRequest;
828 yaz_log(c->log_details, "%p send_scan", c);
830 return zoom_complete;
831 assert (c->tasks->which == ZOOM_TASK_SCAN);
832 scan = c->tasks->u.scan.scan;
834 z_query = ZOOM_query_get_Z_Query(scan->query);
836 /* Z39.50 scan can only carry RPN */
837 if (z_query->which == Z_Query_type_1 ||
838 z_query->which == Z_Query_type_101)
840 Z_RPNQuery *rpn = z_query->u.type_1;
841 const char *cp = ZOOM_options_get(scan->options, "rpnCharset");
844 yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
847 rpn = yaz_copy_z_RPNQuery(rpn, c->odr_out);
849 yaz_query_charset_convert_rpnquery(
850 rpn, c->odr_out, cd);
854 req->attributeSet = rpn->attributeSetId;
855 if (!req->attributeSet)
856 req->attributeSet = odr_oiddup(c->odr_out, yaz_oid_attset_bib_1);
857 if (rpn->RPNStructure->which == Z_RPNStructure_simple &&
858 rpn->RPNStructure->u.simple->which == Z_Operand_APT)
860 req->termListAndStartPoint =
861 rpn->RPNStructure->u.simple->u.attributesPlusTerm;
865 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
866 return zoom_complete;
871 ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
872 return zoom_complete;
875 *req->numberOfTermsRequested =
876 ZOOM_options_get_int(scan->options, "number", 20);
878 req->preferredPositionInResponse =
879 odr_intdup(c->odr_out,
880 ZOOM_options_get_int(scan->options, "position", 1));
883 odr_intdup(c->odr_out,
884 ZOOM_options_get_int(scan->options, "stepSize", 0));
886 req->databaseNames = scan->databaseNames;
887 req->num_databaseNames = scan->num_databaseNames;
889 return send_APDU(c, apdu);
893 ZOOM_package_send(ZOOM_package p, const char *type)
900 odr_reset(p->odr_out);
903 if (!strcmp(type, "itemorder"))
905 apdu = create_es_package(p, yaz_oid_extserv_item_order);
908 Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
910 r->direct_reference =
911 odr_oiddup(p->odr_out, yaz_oid_extserv_item_order);
913 r->which = Z_External_itemOrder;
914 r->indirect_reference = 0;
915 r->u.itemOrder = encode_item_order(p);
917 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
920 else if (!strcmp(type, "create")) /* create database */
922 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_create,
925 else if (!strcmp(type, "drop")) /* drop database */
927 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_drop,
930 else if (!strcmp(type, "commit")) /* commit changes */
932 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_commit,
935 else if (!strcmp(type, "update")) /* update record(s) */
937 apdu = create_update_package(p);
939 else if (!strcmp(type, "xmlupdate"))
941 apdu = create_xmlupdate_package(p);
945 if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
949 ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_PACKAGE);
951 buf = odr_getbuf(p->odr_out, &p->len_out, 0);
952 p->buf_out = (char *) xmalloc(p->len_out);
953 memcpy(p->buf_out, buf, p->len_out);
958 while (ZOOM_event(1, &c))
965 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
968 static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
970 char oid_name_buf[OID_STR_MAX];
971 const char *oid_name;
974 oid_name = yaz_oid_to_string_buf(r->diagnosticSetId, 0, oid_name_buf);
977 case Z_DefaultDiagFormat_v2Addinfo:
978 addinfo = r->u.v2Addinfo;
980 case Z_DefaultDiagFormat_v3Addinfo:
981 addinfo = r->u.v3Addinfo;
986 ZOOM_set_dset_error(c, *r->condition, oid_name, addinfo, 0);
989 static void response_diag(ZOOM_connection c, Z_DiagRec *p)
991 if (p->which != Z_DiagRec_defaultFormat)
992 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
994 response_default_diag(c, p->u.defaultFormat);
997 static int es_response_taskpackage_update(ZOOM_connection c,
998 Z_IUUpdateTaskPackage *utp)
1000 if (utp && utp->targetPart)
1002 Z_IUTargetPart *targetPart = utp->targetPart;
1003 switch ( *targetPart->updateStatus ) {
1004 case Z_IUTargetPart_success:
1005 ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "success");
1007 case Z_IUTargetPart_partial:
1008 ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "partial");
1010 case Z_IUTargetPart_failure:
1011 ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "failure");
1012 if (targetPart->globalDiagnostics && targetPart->num_globalDiagnostics > 0)
1013 response_diag(c, targetPart->globalDiagnostics[0]);
1016 /* NOTE: Individual record status, surrogate diagnostics, and supplemental diagnostics ARE NOT REPORTED. */
1021 static int es_response_taskpackage(ZOOM_connection c,
1022 Z_TaskPackage *taskPackage)
1024 Odr_oct *id = taskPackage->targetReference;
1026 ZOOM_options_setl(c->tasks->u.package->options,
1027 "targetReference", (char*) id->buf, id->len);
1029 switch ( *taskPackage->taskStatus ) {
1030 case Z_TaskPackage_pending:
1031 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "pending");
1033 case Z_TaskPackage_active:
1034 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "active");
1036 case Z_TaskPackage_complete:
1037 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "complete");
1039 case Z_TaskPackage_aborted:
1040 ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "aborted");
1041 if ( taskPackage->num_packageDiagnostics && taskPackage->packageDiagnostics )
1042 response_diag(c, taskPackage->packageDiagnostics[0]);
1045 /* NOTE: Only Update implemented, no others. */
1046 if ( taskPackage->taskSpecificParameters->which == Z_External_update )
1048 Z_IUUpdateTaskPackage *utp = taskPackage->taskSpecificParameters->u.update->u.taskPackage;
1049 es_response_taskpackage_update(c, utp);
1055 static int handle_Z3950_es_response(ZOOM_connection c,
1056 Z_ExtendedServicesResponse *res)
1058 if (!c->tasks || c->tasks->which != ZOOM_TASK_PACKAGE)
1060 switch (*res->operationStatus)
1062 case Z_ExtendedServicesResponse_done:
1063 ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "done");
1065 case Z_ExtendedServicesResponse_accepted:
1066 ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "accepted");
1068 case Z_ExtendedServicesResponse_failure:
1069 ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "failure");
1070 if (res->diagnostics && res->num_diagnostics > 0)
1071 response_diag(c, res->diagnostics[0]);
1074 if (res->taskPackage &&
1075 res->taskPackage->which == Z_External_extendedService)
1077 Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
1078 es_response_taskpackage(c, taskPackage);
1080 if (res->taskPackage &&
1081 res->taskPackage->which == Z_External_octet)
1083 Odr_oct *doc = res->taskPackage->u.octet_aligned;
1084 ZOOM_options_setl(c->tasks->u.package->options,
1085 "xmlUpdateDoc", (char*) doc->buf, doc->len);
1090 static char *get_term_cstr(ODR odr, Z_Term *term) {
1092 switch (term->which) {
1093 case Z_Term_general:
1094 return odr_strdupn(odr, (const char *) term->u.general->buf, (size_t) term->u.general->len);
1096 case Z_Term_characterString:
1097 return odr_strdup(odr, term->u.characterString);
1102 static ZOOM_facet_field get_zoom_facet_field(ODR odr, Z_FacetField *facet) {
1104 struct yaz_facet_attr attr_values;
1105 ZOOM_facet_field facet_field = odr_malloc(odr, sizeof(*facet_field));
1106 yaz_facet_attr_init(&attr_values);
1107 yaz_facet_attr_get_z_attributes(facet->attributes, &attr_values);
1108 facet_field->facet_name = odr_strdup(odr, attr_values.useattr);
1109 facet_field->num_terms = facet->num_terms;
1110 yaz_log(YLOG_DEBUG, "ZOOM_facet_field %s %d terms %d", attr_values.useattr, attr_values.limit, facet->num_terms);
1111 facet_field->facet_terms = odr_malloc(odr, facet_field->num_terms * sizeof(*facet_field->facet_terms));
1112 for (term_index = 0 ; term_index < facet->num_terms; term_index++) {
1113 Z_FacetTerm *facetTerm = facet->terms[term_index];
1114 facet_field->facet_terms[term_index].frequency = *facetTerm->count;
1115 facet_field->facet_terms[term_index].term = get_term_cstr(odr, facetTerm->term);
1116 yaz_log(YLOG_DEBUG, " term[%d] %s %d",
1117 term_index, facet_field->facet_terms[term_index].term, facet_field->facet_terms[term_index].frequency);
1122 /* Can be share with SOLR/SRU/SRW requests */
1123 void ZOOM_handle_facet_list(ZOOM_resultset r, Z_FacetList *fl)
1126 r->num_facets = fl->num;
1127 yaz_log(YLOG_DEBUG, "Facets found: %d", fl->num);
1128 r->facets = odr_malloc(r->odr, r->num_facets * sizeof(*r->facets));
1129 r->facets_names = odr_malloc(r->odr, r->num_facets * sizeof(*r->facets_names));
1130 for (j = 0; j < fl->num; j++)
1132 r->facets[j] = get_zoom_facet_field(r->odr, fl->elements[j]);
1134 yaz_log(YLOG_DEBUG, "Facet field missing on index %d !", j);
1135 r->facets_names[j] = (char *) ZOOM_facet_field_name(r->facets[j]);
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)
1150 ZOOM_handle_facet_list(r, ext->u.facetList);
1156 static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
1159 switch (term->which)
1161 case Z_Term_general:
1162 ZOOM_options_setl(opt, name,
1163 (const char *)(term->u.general->buf),
1164 term->u.general->len);
1166 case Z_Term_characterString:
1167 ZOOM_options_set(opt, name, term->u.characterString);
1169 case Z_Term_numeric:
1170 ZOOM_options_set_int(opt, name, *term->u.numeric);
1175 static void handle_queryExpression(ZOOM_options opt, const char *name,
1176 Z_QueryExpression *exp)
1182 case Z_QueryExpression_term:
1183 if (exp->u.term && exp->u.term->queryTerm)
1185 sprintf(opt_name, "%s.term", name);
1186 handle_queryExpressionTerm(opt, opt_name, exp->u.term->queryTerm);
1189 case Z_QueryExpression_query:
1195 static void handle_search_result(ZOOM_connection c, ZOOM_resultset resultset,
1196 Z_OtherInformation *o)
1199 for (i = 0; o && i < o->num_elements; i++)
1201 if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1203 Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1205 if (ext->which == Z_External_searchResult1)
1208 Z_SearchInfoReport *sr = ext->u.searchResult1;
1211 ZOOM_options_set_int(
1212 resultset->options, "searchresult.size", sr->num);
1214 for (j = 0; j < sr->num; j++)
1216 Z_SearchInfoReport_s *ent =
1217 ext->u.searchResult1->elements[j];
1220 sprintf(pref, "searchresult.%d", j);
1222 if (ent->subqueryId)
1225 sprintf(opt_name, "%s.id", pref);
1226 ZOOM_options_set(resultset->options, opt_name,
1229 if (ent->subqueryExpression)
1232 sprintf(opt_name, "%s.subquery", pref);
1233 handle_queryExpression(resultset->options, opt_name,
1234 ent->subqueryExpression);
1236 if (ent->subqueryInterpretation)
1239 sprintf(opt_name, "%s.interpretation", pref);
1240 handle_queryExpression(resultset->options, opt_name,
1241 ent->subqueryInterpretation);
1243 if (ent->subqueryRecommendation)
1246 sprintf(opt_name, "%s.recommendation", pref);
1247 handle_queryExpression(resultset->options, opt_name,
1248 ent->subqueryRecommendation);
1250 if (ent->subqueryCount)
1253 sprintf(opt_name, "%s.count", pref);
1254 ZOOM_options_set_int(resultset->options, opt_name,
1255 *ent->subqueryCount);
1263 static void handle_Z3950_search_response(ZOOM_connection c,
1264 Z_SearchResponse *sr)
1266 ZOOM_resultset resultset;
1269 if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
1272 event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
1273 ZOOM_connection_put_event(c, event);
1275 resultset = c->tasks->u.search.resultset;
1277 if (sr->resultSetStatus)
1279 ZOOM_options_set_int(resultset->options, "resultSetStatus",
1280 *sr->resultSetStatus);
1282 if (sr->presentStatus)
1284 ZOOM_options_set_int(resultset->options, "presentStatus",
1285 *sr->presentStatus);
1287 handle_search_result(c, resultset, sr->additionalSearchInfo);
1289 handle_facet_result(c, resultset, sr->additionalSearchInfo);
1291 resultset->size = *sr->resultCount;
1292 handle_Z3950_records(c, sr->records, 0);
1295 static void handle_Z3950_sort_response(ZOOM_connection c, Z_SortResponse *res)
1297 if (res->diagnostics && res->num_diagnostics > 0)
1298 response_diag(c, res->diagnostics[0]);
1301 static int handle_Z3950_scan_response(ZOOM_connection c, Z_ScanResponse *res)
1303 NMEM nmem = odr_extract_mem(c->odr_in);
1306 if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
1308 scan = c->tasks->u.scan.scan;
1310 if (res->entries && res->entries->nonsurrogateDiagnostics)
1311 response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
1312 scan->scan_response = res;
1313 scan->srw_scan_response = 0;
1314 nmem_transfer(odr_getmem(scan->odr), nmem);
1316 ZOOM_options_set_int(scan->options, "stepSize", *res->stepSize);
1317 if (res->positionOfTerm)
1318 ZOOM_options_set_int(scan->options, "position", *res->positionOfTerm);
1319 if (res->scanStatus)
1320 ZOOM_options_set_int(scan->options, "scanStatus", *res->scanStatus);
1321 if (res->numberOfEntriesReturned)
1322 ZOOM_options_set_int(scan->options, "number",
1323 *res->numberOfEntriesReturned);
1328 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
1331 ZOOM_resultset resultset;
1333 const char *syntax = 0, *elementSetName = 0, *schema = 0;
1337 switch (c->tasks->which)
1339 case ZOOM_TASK_SEARCH:
1340 resultset = c->tasks->u.search.resultset;
1341 start = &c->tasks->u.search.start;
1342 count = &c->tasks->u.search.count;
1343 syntax = c->tasks->u.search.syntax;
1344 elementSetName = c->tasks->u.search.elementSetName;
1345 schema = c->tasks->u.search.schema;
1347 case ZOOM_TASK_RETRIEVE:
1348 resultset = c->tasks->u.retrieve.resultset;
1349 start = &c->tasks->u.retrieve.start;
1350 count = &c->tasks->u.retrieve.count;
1351 syntax = c->tasks->u.retrieve.syntax;
1352 elementSetName = c->tasks->u.retrieve.elementSetName;
1353 schema = c->tasks->u.retrieve.schema;
1358 if (sr && sr->which == Z_Records_NSD)
1359 response_default_diag(c, sr->u.nonSurrogateDiagnostic);
1360 else if (sr && sr->which == Z_Records_multipleNSD)
1362 if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
1363 response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
1365 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1369 if (*count + *start > resultset->size)
1370 *count = resultset->size - *start;
1373 if (sr && sr->which == Z_Records_DBOSD)
1376 NMEM nmem = odr_extract_mem(c->odr_in);
1377 Z_NamePlusRecordList *p =
1378 sr->u.databaseOrSurDiagnostics;
1379 for (i = 0; i<p->num_records; i++)
1381 ZOOM_record_cache_add(resultset, p->records[i], i + *start,
1382 syntax, elementSetName, schema, 0);
1388 yaz_log(c->log_details,
1389 "handle_records resultset=%p start=%d count=%d",
1390 resultset, *start, *count);
1392 /* transfer our response to search_nmem .. we need it later */
1393 nmem_transfer(odr_getmem(resultset->odr), nmem);
1395 if (present_phase && p->num_records == 0)
1397 /* present response and we didn't get any records! */
1398 Z_NamePlusRecord *myrec =
1399 zget_surrogateDiagRec(
1401 YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
1402 "ZOOM C generated. Present phase and no records");
1403 ZOOM_record_cache_add(resultset, myrec, *start,
1404 syntax, elementSetName, schema, 0);
1407 else if (present_phase)
1409 /* present response and we didn't get any records! */
1410 Z_NamePlusRecord *myrec =
1411 zget_surrogateDiagRec(
1413 YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
1414 "ZOOM C generated: Present response and no records");
1415 ZOOM_record_cache_add(resultset, myrec, *start,
1416 syntax, elementSetName, schema, 0);
1421 static void handle_Z3950_present_response(ZOOM_connection c,
1422 Z_PresentResponse *pr)
1424 handle_Z3950_records(c, pr->records, 1);
1427 static void set_init_option(const char *name, void *clientData)
1429 ZOOM_connection c = (ZOOM_connection) clientData;
1432 sprintf(buf, "init_opt_%.70s", name);
1433 ZOOM_connection_option_set(c, buf, "1");
1437 zoom_ret send_Z3950_sort(ZOOM_connection c, ZOOM_resultset resultset)
1440 resultset->r_sort_spec = 0;
1441 if (resultset->r_sort_spec)
1443 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
1444 Z_SortRequest *req = apdu->u.sortRequest;
1446 req->num_inputResultSetNames = 1;
1447 req->inputResultSetNames = (Z_InternationalString **)
1448 odr_malloc(c->odr_out, sizeof(*req->inputResultSetNames));
1449 req->inputResultSetNames[0] =
1450 odr_strdup(c->odr_out, resultset->setname);
1451 req->sortedResultSetName = odr_strdup(c->odr_out, resultset->setname);
1452 req->sortSequence = resultset->r_sort_spec;
1453 resultset->r_sort_spec = 0;
1454 return send_APDU(c, apdu);
1456 return zoom_complete;
1459 zoom_ret send_Z3950_present(ZOOM_connection c)
1462 Z_PresentRequest *req = 0;
1464 const char *syntax = 0;
1465 const char *elementSetName = 0;
1466 const char *schema = 0;
1467 ZOOM_resultset resultset;
1472 yaz_log(c->log_details, "%p send_present no tasks", c);
1473 return zoom_complete;
1476 switch (c->tasks->which)
1478 case ZOOM_TASK_SEARCH:
1479 resultset = c->tasks->u.search.resultset;
1480 start = &c->tasks->u.search.start;
1481 count = &c->tasks->u.search.count;
1482 syntax = c->tasks->u.search.syntax;
1483 elementSetName = c->tasks->u.search.elementSetName;
1484 schema = c->tasks->u.search.schema;
1486 case ZOOM_TASK_RETRIEVE:
1487 resultset = c->tasks->u.retrieve.resultset;
1488 start = &c->tasks->u.retrieve.start;
1489 count = &c->tasks->u.retrieve.count;
1490 syntax = c->tasks->u.retrieve.syntax;
1491 elementSetName = c->tasks->u.retrieve.elementSetName;
1492 schema = c->tasks->u.retrieve.schema;
1495 return zoom_complete;
1497 yaz_log(c->log_details, "%p send_present start=%d count=%d",
1500 if (*start < 0 || *count < 0 || *start + *count > resultset->size)
1502 ZOOM_set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
1505 if (c->error) /* don't continue on error */
1506 return zoom_complete;
1507 yaz_log(c->log_details, "send_present resultset=%p start=%d count=%d",
1508 resultset, *start, *count);
1510 for (i = 0; i < *count; i++)
1513 ZOOM_record_cache_lookup(resultset, i + *start,
1514 syntax, elementSetName, schema);
1519 ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
1520 ZOOM_connection_put_event(c, event);
1528 yaz_log(c->log_details, "%p send_present skip=%d no more to fetch", c, i);
1529 return zoom_complete;
1532 apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
1533 req = apdu->u.presentRequest;
1536 yaz_log(c->log_details, "%p send_present skip=%d", c, i);
1538 *req->resultSetStartPoint = *start + 1;
1540 if (resultset->step > 0 && resultset->step < *count)
1541 *req->numberOfRecordsRequested = resultset->step;
1543 *req->numberOfRecordsRequested = *count;
1545 if (*req->numberOfRecordsRequested + *start > resultset->size)
1546 *req->numberOfRecordsRequested = resultset->size - *start;
1547 assert(*req->numberOfRecordsRequested > 0);
1549 if (syntax && *syntax)
1550 req->preferredRecordSyntax =
1551 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
1553 if (schema && *schema)
1555 Z_RecordComposition *compo = (Z_RecordComposition *)
1556 odr_malloc(c->odr_out, sizeof(*compo));
1558 req->recordComposition = compo;
1559 compo->which = Z_RecordComp_complex;
1560 compo->u.complex = (Z_CompSpec *)
1561 odr_malloc(c->odr_out, sizeof(*compo->u.complex));
1562 compo->u.complex->selectAlternativeSyntax = (bool_t *)
1563 odr_malloc(c->odr_out, sizeof(bool_t));
1564 *compo->u.complex->selectAlternativeSyntax = 0;
1566 compo->u.complex->generic = (Z_Specification *)
1567 odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));
1569 compo->u.complex->generic->which = Z_Schema_oid;
1570 compo->u.complex->generic->schema.oid = (Odr_oid *)
1571 zoom_yaz_str_to_z3950oid(c, CLASS_SCHEMA, schema);
1573 if (!compo->u.complex->generic->schema.oid)
1575 /* OID wasn't a schema! Try record syntax instead. */
1577 compo->u.complex->generic->schema.oid = (Odr_oid *)
1578 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, schema);
1580 if (elementSetName && *elementSetName)
1582 compo->u.complex->generic->elementSpec = (Z_ElementSpec *)
1583 odr_malloc(c->odr_out, sizeof(Z_ElementSpec));
1584 compo->u.complex->generic->elementSpec->which =
1585 Z_ElementSpec_elementSetName;
1586 compo->u.complex->generic->elementSpec->u.elementSetName =
1587 odr_strdup(c->odr_out, elementSetName);
1590 compo->u.complex->generic->elementSpec = 0;
1591 compo->u.complex->num_dbSpecific = 0;
1592 compo->u.complex->dbSpecific = 0;
1593 compo->u.complex->num_recordSyntax = 0;
1594 compo->u.complex->recordSyntax = 0;
1596 else if (elementSetName && *elementSetName)
1598 Z_ElementSetNames *esn = (Z_ElementSetNames *)
1599 odr_malloc(c->odr_out, sizeof(*esn));
1600 Z_RecordComposition *compo = (Z_RecordComposition *)
1601 odr_malloc(c->odr_out, sizeof(*compo));
1603 esn->which = Z_ElementSetNames_generic;
1604 esn->u.generic = odr_strdup(c->odr_out, elementSetName);
1605 compo->which = Z_RecordComp_simple;
1606 compo->u.simple = esn;
1607 req->recordComposition = compo;
1609 req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
1610 return send_APDU(c, apdu);
1613 static zoom_ret send_Z3950_sort_present(ZOOM_connection c)
1615 zoom_ret r = zoom_complete;
1617 if (c->tasks && c->tasks->which == ZOOM_TASK_SEARCH)
1618 r = send_Z3950_sort(c, c->tasks->u.search.resultset);
1619 if (r == zoom_complete)
1620 r = send_Z3950_present(c);
1624 void ZOOM_handle_Z3950_apdu(ZOOM_connection c, Z_APDU *apdu)
1626 Z_InitResponse *initrs;
1628 ZOOM_connection_set_mask(c, 0);
1629 yaz_log(c->log_details, "%p handle_Z3950_apdu apdu->which=%d",
1631 switch (apdu->which)
1633 case Z_APDU_initResponse:
1634 yaz_log(c->log_api, "%p handle_Z3950_apdu: Received Init response", c);
1635 initrs = apdu->u.initResponse;
1636 ZOOM_connection_option_set(c, "serverImplementationId",
1637 initrs->implementationId ?
1638 initrs->implementationId : "");
1639 ZOOM_connection_option_set(c, "serverImplementationName",
1640 initrs->implementationName ?
1641 initrs->implementationName : "");
1642 ZOOM_connection_option_set(c, "serverImplementationVersion",
1643 initrs->implementationVersion ?
1644 initrs->implementationVersion : "");
1645 /* Set the three old options too, for old applications */
1646 ZOOM_connection_option_set(c, "targetImplementationId",
1647 initrs->implementationId ?
1648 initrs->implementationId : "");
1649 ZOOM_connection_option_set(c, "targetImplementationName",
1650 initrs->implementationName ?
1651 initrs->implementationName : "");
1652 ZOOM_connection_option_set(c, "targetImplementationVersion",
1653 initrs->implementationVersion ?
1654 initrs->implementationVersion : "");
1656 /* Make initrs->options available as ZOOM-level options */
1657 yaz_init_opt_decode(initrs->options, set_init_option, (void*) c);
1659 if (!*initrs->result)
1661 Z_DefaultDiagFormat *df = yaz_decode_init_diag(0, initrs);
1663 response_default_diag(c, df);
1665 ZOOM_set_error(c, ZOOM_ERROR_INIT, 0); /* default error */
1670 yaz_oi_get_string_oid(&apdu->u.initResponse->otherInfo,
1671 yaz_oid_userinfo_cookie, 1, 0);
1672 xfree(c->cookie_in);
1675 c->cookie_in = xstrdup(cookie);
1676 if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
1677 ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
1678 c->support_named_resultsets = 1;
1681 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1682 ZOOM_connection_remove_task(c);
1684 ZOOM_connection_exec_task(c);
1686 if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
1688 NMEM tmpmem = nmem_create();
1689 Z_CharSetandLanguageNegotiation *p =
1690 yaz_get_charneg_record(initrs->otherInfo);
1694 char *charset = NULL, *lang = NULL;
1697 yaz_get_response_charneg(tmpmem, p, &charset, &lang, &sel);
1698 yaz_log(c->log_details, "%p handle_Z3950_apdu target accepted: "
1699 "charset %s, language %s, select %d",
1701 charset ? charset : "none", lang ? lang : "none", sel);
1703 ZOOM_connection_option_set(c, "negotiation-charset",
1706 ZOOM_connection_option_set(c, "negotiation-lang",
1709 ZOOM_connection_option_set(
1710 c, "negotiation-charset-in-effect-for-records",
1711 (sel != 0) ? "1" : "0");
1712 nmem_destroy(tmpmem);
1716 case Z_APDU_searchResponse:
1717 yaz_log(c->log_api, "%p handle_Z3950_apdu Search response", c);
1718 handle_Z3950_search_response(c, apdu->u.searchResponse);
1719 if (send_Z3950_sort_present(c) == zoom_complete)
1720 ZOOM_connection_remove_task(c);
1722 case Z_APDU_presentResponse:
1723 yaz_log(c->log_api, "%p handle_Z3950_apdu Present response", c);
1724 handle_Z3950_present_response(c, apdu->u.presentResponse);
1725 if (send_Z3950_present(c) == zoom_complete)
1726 ZOOM_connection_remove_task(c);
1728 case Z_APDU_sortResponse:
1729 yaz_log(c->log_api, "%p handle_Z3950_apdu Sort response", c);
1730 handle_Z3950_sort_response(c, apdu->u.sortResponse);
1731 if (send_Z3950_present(c) == zoom_complete)
1732 ZOOM_connection_remove_task(c);
1734 case Z_APDU_scanResponse:
1735 yaz_log(c->log_api, "%p handle_Z3950_apdu Scan response", c);
1736 handle_Z3950_scan_response(c, apdu->u.scanResponse);
1737 ZOOM_connection_remove_task(c);
1739 case Z_APDU_extendedServicesResponse:
1740 yaz_log(c->log_api, "%p handle_Z3950_apdu Extended Services response", c);
1741 handle_Z3950_es_response(c, apdu->u.extendedServicesResponse);
1742 ZOOM_connection_remove_task(c);
1745 yaz_log(c->log_api, "%p handle_Z3950_apdu Close PDU", c);
1746 if (!ZOOM_test_reconnect(c))
1748 ZOOM_set_dset_error(c, ZOOM_ERROR_CONNECTION_LOST, "ZOOM", c->host_port, apdu->u.close->diagnosticInformation);
1749 ZOOM_connection_close(c);
1753 yaz_log(c->log_api, "%p Received unknown PDU", c);
1754 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1755 ZOOM_connection_close(c);
1762 * c-file-style: "Stroustrup"
1763 * indent-tabs-mode: nil
1765 * vim: shiftwidth=4 tabstop=8 expandtab