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