1 /* This file is part of the YAZ toolkit.
2 * Copyright (C) Index Data
3 * See the file LICENSE for details.
4 */
5 /**
6 * \file zoom-z3950.c
7 * \brief Implements ZOOM Z39.50 handling
8 */
9 #if HAVE_CONFIG_H
10 #include <config.h>
11 #endif
12
13 #include <assert.h>
14 #include <string.h>
15 #include <errno.h>
16 #include "zoom-p.h"
17
18 #include <yaz/yaz-util.h>
19 #include <yaz/xmalloc.h>
20 #include <yaz/otherinfo.h>
21 #include <yaz/log.h>
22 #include <yaz/pquery.h>
23 #include <yaz/marcdisp.h>
24 #include <yaz/diagbib1.h>
25 #include <yaz/charneg.h>
26 #include <yaz/ill.h>
27 #include <yaz/query-charset.h>
28 #include <yaz/copy_types.h>
29 #include <yaz/snprintf.h>
30 #include <yaz/facet.h>
31
32 #include <yaz/shptr.h>
33
34 /*
35 * This wrapper is just for logging failed lookups. It would be nicer
36 * if it could cause failure when a lookup fails, but that's hard.
37 */
zoom_yaz_str_to_z3950oid(ZOOM_connection c,oid_class oid_class,const char * str)38 static Odr_oid *zoom_yaz_str_to_z3950oid(ZOOM_connection c,
39 oid_class oid_class, const char *str)
40 {
41 Odr_oid *res = yaz_string_to_oid_odr(yaz_oid_std(), oid_class, str,
42 c->odr_out);
43 if (res == 0)
44 yaz_log(YLOG_WARN, "%p OID lookup (%d, '%s') failed",
45 c, (int) oid_class, str);
46 return res;
47 }
48
create_es_package(ZOOM_package p,const Odr_oid * oid)49 static Z_APDU *create_es_package(ZOOM_package p, const Odr_oid *oid)
50 {
51 const char *str;
52 Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
53 Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
54
55 str = ZOOM_options_get(p->options, "package-name");
56 if (str && *str)
57 req->packageName = odr_strdup(p->odr_out, str);
58
59 str = ZOOM_options_get(p->options, "user-id");
60 if (str)
61 req->userId = odr_strdup_null(p->odr_out, str);
62
63 req->packageType = odr_oiddup(p->odr_out, oid);
64
65 str = ZOOM_options_get(p->options, "function");
66 if (str)
67 {
68 if (!strcmp (str, "create"))
69 *req->function = Z_ExtendedServicesRequest_create;
70 if (!strcmp (str, "delete"))
71 *req->function = Z_ExtendedServicesRequest_delete;
72 if (!strcmp (str, "modify"))
73 *req->function = Z_ExtendedServicesRequest_modify;
74 }
75
76 str = ZOOM_options_get(p->options, "waitAction");
77 if (str)
78 {
79 if (!strcmp (str, "wait"))
80 *req->waitAction = Z_ExtendedServicesRequest_wait;
81 if (!strcmp (str, "waitIfPossible"))
82 *req->waitAction = Z_ExtendedServicesRequest_waitIfPossible;
83 if (!strcmp (str, "dontWait"))
84 *req->waitAction = Z_ExtendedServicesRequest_dontWait;
85 if (!strcmp (str, "dontReturnPackage"))
86 *req->waitAction = Z_ExtendedServicesRequest_dontReturnPackage;
87 }
88 return apdu;
89 }
90
ill_array_lookup(void * clientData,const char * idx)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
encode_ill_request(ZOOM_package p)97 static Z_External *encode_ill_request(ZOOM_package p)
98 {
99 ODR out = p->odr_out;
100 ILL_Request *req;
101 Z_External *r = 0;
102 struct ill_get_ctl ctl;
103
104 ctl.odr = p->odr_out;
105 ctl.clientData = p;
106 ctl.f = ill_array_lookup;
107
108 req = ill_get_ILLRequest(&ctl, "ill", 0);
109
110 if (!ill_Request(out, &req, 0, 0))
111 {
112 int ill_request_size;
113 char *ill_request_buf = odr_getbuf(out, &ill_request_size, 0);
114 if (ill_request_buf)
115 odr_setbuf(out, ill_request_buf, ill_request_size, 1);
116 return 0;
117 }
118 else
119 {
120 int illRequest_size = 0;
121 char *illRequest_buf = odr_getbuf(out, &illRequest_size, 0);
122
123 r = (Z_External *) odr_malloc(out, sizeof(*r));
124 r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
125 r->indirect_reference = 0;
126 r->descriptor = 0;
127 r->which = Z_External_single;
128
129 r->u.single_ASN1_type =
130 odr_create_Odr_oct(out, illRequest_buf, illRequest_size);
131 }
132 return r;
133 }
134
encode_item_order(ZOOM_package p)135 static Z_ItemOrder *encode_item_order(ZOOM_package p)
136 {
137 Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc(p->odr_out, sizeof(*req));
138 const char *str;
139 int len;
140
141 req->which = Z_IOItemOrder_esRequest;
142 req->u.esRequest = (Z_IORequest *)
143 odr_malloc(p->odr_out,sizeof(Z_IORequest));
144
145 /* to keep part ... */
146 req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
147 odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
148 req->u.esRequest->toKeep->supplDescription = 0;
149 req->u.esRequest->toKeep->contact = (Z_IOContact *)
150 odr_malloc(p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
151
152 str = ZOOM_options_get(p->options, "contact-name");
153 req->u.esRequest->toKeep->contact->name =
154 odr_strdup_null(p->odr_out, str);
155
156 str = ZOOM_options_get(p->options, "contact-phone");
157 req->u.esRequest->toKeep->contact->phone =
158 odr_strdup_null(p->odr_out, str);
159
160 str = ZOOM_options_get(p->options, "contact-email");
161 req->u.esRequest->toKeep->contact->email =
162 odr_strdup_null(p->odr_out, str);
163
164 req->u.esRequest->toKeep->addlBilling = 0;
165 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 ... */
171 req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
172 odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));
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 {
182 req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
183 odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));
184
185 req->u.esRequest->notToKeep->resultSetItem->resultSetId =
186 odr_strdup(p->odr_out, str);
187 req->u.esRequest->notToKeep->resultSetItem->item =
188 odr_intdup(p->odr_out, 0);
189
190 str = ZOOM_options_get(p->options, "itemorder-item");
191 *req->u.esRequest->notToKeep->resultSetItem->item =
192 (str ? atoi(str) : 1);
193 }
194
195 str = ZOOM_options_getl(p->options, "doc", &len);
196 if (str)
197 {
198 req->u.esRequest->notToKeep->itemRequest =
199 z_ext_record_xml(p->odr_out, str, len);
200 }
201 else
202 req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
203
204 return req;
205 }
206
create_admin_package(ZOOM_package p,int type,Z_ESAdminOriginPartToKeep ** toKeepP,Z_ESAdminOriginPartNotToKeep ** notToKeepP)207 Z_APDU *create_admin_package(ZOOM_package p, int type,
208 Z_ESAdminOriginPartToKeep **toKeepP,
209 Z_ESAdminOriginPartNotToKeep **notToKeepP)
210 {
211 Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_admin);
212 if (apdu)
213 {
214 Z_ESAdminOriginPartToKeep *toKeep;
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;
219 char **db = ZOOM_connection_get_databases(p->connection,
220 p->options, &num_db,
221 p->odr_out);
222 if (num_db > 0)
223 first_db = db[0];
224
225 r->direct_reference = odr_oiddup(p->odr_out, yaz_oid_extserv_admin);
226 r->descriptor = 0;
227 r->indirect_reference = 0;
228 r->which = Z_External_ESAdmin;
229
230 r->u.adminService = (Z_Admin *)
231 odr_malloc(p->odr_out, sizeof(*r->u.adminService));
232 r->u.adminService->which = Z_Admin_esRequest;
233 r->u.adminService->u.esRequest = (Z_AdminEsRequest *)
234 odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest));
235
236 toKeep = r->u.adminService->u.esRequest->toKeep =
237 (Z_ESAdminOriginPartToKeep *)
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();
242 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
243
244 r->u.adminService->u.esRequest->notToKeep = notToKeep =
245 (Z_ESAdminOriginPartNotToKeep *)
246 odr_malloc(p->odr_out,
247 sizeof(*r->u.adminService->u.esRequest->notToKeep));
248 notToKeep->which = Z_ESAdminOriginPartNotToKeep_recordsWillFollow;
249 notToKeep->u.recordsWillFollow = odr_nullval();
250 if (toKeepP)
251 *toKeepP = toKeep;
252 if (notToKeepP)
253 *notToKeepP = notToKeep;
254 }
255 return apdu;
256 }
257
create_xmlupdate_package(ZOOM_package p)258 static Z_APDU *create_xmlupdate_package(ZOOM_package p)
259 {
260 Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_xml_es);
261 Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
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
create_update_package(ZOOM_package p)282 static Z_APDU *create_update_package(ZOOM_package p)
283 {
284 Z_APDU *apdu = 0;
285 const char *first_db = "Default";
286 int num_db;
287 char **db = ZOOM_connection_get_databases(p->connection, p->options,
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 {
331 ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_SYNTAX, syntax_str);
332 return 0;
333 }
334
335 if (num_db > 0)
336 first_db = db[0];
337
338 switch (*version)
339 {
340 case '1':
341 package_oid = yaz_oid_extserv_database_update_first_version;
342 /* old update does not support specialUpdate */
343 if (!action)
344 action = "recordInsert";
345 break;
346 case '2':
347 if (!action)
348 action = "specialUpdate";
349 package_oid = yaz_oid_extserv_database_update_second_version;
350 break;
351 case '3':
352 if (!action)
353 action = "specialUpdate";
354 package_oid = yaz_oid_extserv_database_update;
355 break;
356 default:
357 ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_VERSION, version);
358 return 0;
359 }
360
361 if (!strcmp(action, "recordInsert"))
362 action_no = Z_IUOriginPartToKeep_recordInsert;
363 else if (!strcmp(action, "recordReplace"))
364 action_no = Z_IUOriginPartToKeep_recordReplace;
365 else if (!strcmp(action, "recordDelete"))
366 action_no = Z_IUOriginPartToKeep_recordDelete;
367 else if (!strcmp(action, "elementUpdate"))
368 action_no = Z_IUOriginPartToKeep_elementUpdate;
369 else if (!strcmp(action, "specialUpdate"))
370 action_no = Z_IUOriginPartToKeep_specialUpdate;
371 else
372 {
373 ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_ACTION, action);
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
387 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
388
389 r->direct_reference = odr_oiddup(p->odr_out, package_oid);
390 r->descriptor = 0;
391 r->which = Z_External_update;
392 r->indirect_reference = 0;
393 r->u.update = (Z_IUUpdate *)
394 odr_malloc(p->odr_out, sizeof(*r->u.update));
395
396 r->u.update->which = Z_IUUpdate_esRequest;
397 r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
398 odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
399 toKeep = r->u.update->u.esRequest->toKeep =
400 (Z_IUOriginPartToKeep *)
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 =
412 (Z_IUSuppliedRecords *)
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));
419 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
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 {
428 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;
429
430 notToKeep->elements[0]->u.number =
431 odr_intdup(p->odr_out, atoi(recordIdNumber));
432 }
433 else if (recordIdString)
434 {
435 notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_string;
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 {
444 Z_IUCorrelationInfo *ci;
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
otherInfo_attach(ZOOM_connection c,Z_APDU * a,ODR out)477 static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
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
502 oid = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_USERINFO,
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
encode_APDU(ZOOM_connection c,Z_APDU * a,ODR out)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);
521 yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_cookie,
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);
528 yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_client_ip,
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);
544 ZOOM_set_error(c, ZOOM_ERROR_ENCODE, 0);
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
send_APDU(ZOOM_connection c,Z_APDU * a)556 static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
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);
564 event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
565 ZOOM_connection_put_event(c, event);
566 odr_reset(c->odr_out);
567 return ZOOM_send_buf(c);
568 }
569
ZOOM_connection_Z3950_send_init(ZOOM_connection c)570 zoom_ret ZOOM_connection_Z3950_send_init(ZOOM_connection c)
571 {
572 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
573 Z_InitRequest *ireq = apdu->u.initRequest;
574 Z_IdAuthentication *auth = (Z_IdAuthentication *)
575 odr_malloc(c->odr_out, sizeof(*auth));
576
577 ODR_MASK_SET(ireq->options, Z_Options_search);
578 ODR_MASK_SET(ireq->options, Z_Options_present);
579 ODR_MASK_SET(ireq->options, Z_Options_scan);
580 ODR_MASK_SET(ireq->options, Z_Options_sort);
581 ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
582 ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);
583
584 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
585 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
586 ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
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
604 *ireq->maximumRecordSize = c->maximum_record_size;
605 *ireq->preferredMessageSize = c->preferred_message_size;
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);
613 auth->which = Z_IdAuthentication_idPass;
614 auth->u.idPass = pass;
615 ireq->idAuthentication = auth;
616 }
617 else if (c->user)
618 {
619 auth->which = Z_IdAuthentication_open;
620 auth->u.open = odr_strdup(c->odr_out, c->user);
621 ireq->idAuthentication = auth;
622 }
623 if (c->proxy_mode)
624 {
625 yaz_oi_set_string_oid(&ireq->otherInfo, c->odr_out,
626 yaz_oid_userinfo_proxy, 1, c->host_port);
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 {
637 ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
638 oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
639 oi_unit->information.externallyDefinedInfo =
640 yaz_set_proposal_charneg_list(c->odr_out, " ",
641 c->charset, c->lang, 1);
642 }
643 }
644 assert(apdu);
645 return send_APDU(c, apdu);
646 }
647
Z3950_send_search(ZOOM_connection c)648 static zoom_ret Z3950_send_search(ZOOM_connection c)
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
664 apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
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 =
684 yaz_pqf_parse_facet_list(c->odr_out, r->req_facets);
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 {
701 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
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
717 r = yaz_query_charset_convert_rpnquery_check(
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 */
723 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
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 {
765 Z_ElementSetNames *esn = (Z_ElementSetNames *)
766 odr_malloc(c->odr_out, sizeof(*esn));
767
768 esn->which = Z_ElementSetNames_generic;
769 esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
770 search_req->smallSetElementSetNames = esn;
771 }
772 if (mediumSetElementSetName && *mediumSetElementSetName)
773 {
774 Z_ElementSetNames *esn =(Z_ElementSetNames *)
775 odr_malloc(c->odr_out, sizeof(*esn));
776
777 esn->which = Z_ElementSetNames_generic;
778 esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
779 search_req->mediumSetElementSetNames = esn;
780 }
781 if (syntax)
782 search_req->preferredRecordSyntax =
783 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
784
785 if (!r->setname)
786 {
787 if (c->support_named_resultsets)
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
ZOOM_connection_Z3950_send_scan(ZOOM_connection c)819 zoom_ret ZOOM_connection_Z3950_send_scan(ZOOM_connection c)
820 {
821 ZOOM_scanset scan;
822 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
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
847 yaz_query_charset_convert_rpnquery(
848 rpn, c->odr_out, cd);
849 yaz_iconv_close(cd);
850 }
851 }
852 req->attributeSet = rpn->attributeSetId;
853 if (!req->attributeSet)
854 req->attributeSet = odr_oiddup(c->odr_out, yaz_oid_attset_bib_1);
855 if (rpn->RPNStructure->which == Z_RPNStructure_simple &&
856 rpn->RPNStructure->u.simple->which == Z_Operand_APT)
857 {
858 req->termListAndStartPoint =
859 rpn->RPNStructure->u.simple->u.attributesPlusTerm;
860 }
861 else
862 {
863 ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
864 return zoom_complete;
865 }
866 }
867 else
868 {
869 ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
870 return zoom_complete;
871 }
872
873 *req->numberOfTermsRequested =
874 ZOOM_options_get_int(scan->options, "number", 20);
875
876 req->preferredPositionInResponse =
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;
885 req->num_databaseNames = scan->num_databaseNames;
886
887 return send_APDU(c, apdu);
888 }
889
890 ZOOM_API(void)
ZOOM_package_send(ZOOM_package p,const char * type)891 ZOOM_package_send(ZOOM_package p, const char *type)
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 {
903 apdu = create_es_package(p, yaz_oid_extserv_item_order);
904 if (apdu)
905 {
906 Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
907
908 r->direct_reference =
909 odr_oiddup(p->odr_out, yaz_oid_extserv_item_order);
910 r->descriptor = 0;
911 r->which = Z_External_itemOrder;
912 r->indirect_reference = 0;
913 r->u.itemOrder = encode_item_order(p);
914
915 apdu->u.extendedServicesRequest->taskSpecificParameters = r;
916 }
917 }
918 else if (!strcmp(type, "create")) /* create database */
919 {
920 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_create,
921 0, 0);
922 }
923 else if (!strcmp(type, "drop")) /* drop database */
924 {
925 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_drop,
926 0, 0);
927 }
928 else if (!strcmp(type, "commit")) /* commit changes */
929 {
930 apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_commit,
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
947 ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_PACKAGE);
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
963 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
964 int present_phase);
965
response_default_diag(ZOOM_connection c,Z_DefaultDiagFormat * r)966 static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
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 {
975 case Z_DefaultDiagFormat_v2Addinfo:
976 addinfo = r->u.v2Addinfo;
977 break;
978 case Z_DefaultDiagFormat_v3Addinfo:
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
response_diag(ZOOM_connection c,Z_DiagRec * p)987 static void response_diag(ZOOM_connection c, Z_DiagRec *p)
988 {
989 if (p->which != Z_DiagRec_defaultFormat)
990 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
991 else
992 response_default_diag(c, p->u.defaultFormat);
993 }
994
es_response_taskpackage_update(ZOOM_connection c,Z_IUUpdateTaskPackage * utp)995 static int es_response_taskpackage_update(ZOOM_connection c,
996 Z_IUUpdateTaskPackage *utp)
997 {
998 if (utp && utp->targetPart)
999 {
1000 Z_IUTargetPart *targetPart = utp->targetPart;
1001 switch (*targetPart->updateStatus)
1002 {
1003 case Z_IUTargetPart_success:
1004 ZOOM_options_set(c->tasks->u.package->options,
1005 "updateStatus", "success");
1006 break;
1007 case Z_IUTargetPart_partial:
1008 ZOOM_options_set(c->tasks->u.package->options,
1009 "updateStatus", "partial");
1010 break;
1011 case Z_IUTargetPart_failure:
1012 ZOOM_options_set(c->tasks->u.package->options,
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
es_response_taskpackage_update0(ZOOM_connection c,Z_IU0UpdateTaskPackage * utp)1024 static int es_response_taskpackage_update0(ZOOM_connection c,
1025 Z_IU0UpdateTaskPackage *utp)
1026 {
1027 if (utp && utp->targetPart)
1028 {
1029 Z_IU0TargetPart *targetPart = utp->targetPart;
1030 switch (*targetPart->updateStatus)
1031 {
1032 case Z_IU0TargetPart_success:
1033 ZOOM_options_set(c->tasks->u.package->options,
1034 "updateStatus", "success");
1035 break;
1036 case Z_IU0TargetPart_partial:
1037 ZOOM_options_set(c->tasks->u.package->options,
1038 "updateStatus", "partial");
1039 break;
1040 case Z_IU0TargetPart_failure:
1041 ZOOM_options_set(c->tasks->u.package->options,
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
es_response_taskpackage(ZOOM_connection c,Z_TaskPackage * taskPackage)1053 static int es_response_taskpackage(ZOOM_connection c,
1054 Z_TaskPackage *taskPackage)
1055 {
1056 Odr_oct *id = taskPackage->targetReference;
1057 if (id)
1058 ZOOM_options_setl(c->tasks->u.package->options,
1059 "targetReference", (char*) id->buf, id->len);
1060 switch (*taskPackage->taskStatus)
1061 {
1062 case Z_TaskPackage_pending:
1063 ZOOM_options_set(c->tasks->u.package->options,
1064 "taskStatus", "pending");
1065 break;
1066 case Z_TaskPackage_active:
1067 ZOOM_options_set(c->tasks->u.package->options,
1068 "taskStatus", "active");
1069 break;
1070 case Z_TaskPackage_complete:
1071 ZOOM_options_set(c->tasks->u.package->options,
1072 "taskStatus", "complete");
1073 break;
1074 case Z_TaskPackage_aborted:
1075 ZOOM_options_set(c->tasks->u.package->options,
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;
1087 es_response_taskpackage_update(c, utp);
1088 }
1089 if (taskPackage->taskSpecificParameters->which == Z_External_update0)
1090 {
1091 Z_IU0UpdateTaskPackage *utp =
1092 taskPackage->taskSpecificParameters->u.update0->u.taskPackage;
1093 es_response_taskpackage_update0(c, utp);
1094 }
1095 return 1;
1096 }
1097
handle_Z3950_es_response(ZOOM_connection c,Z_ExtendedServicesResponse * res)1098 static void handle_Z3950_es_response(ZOOM_connection c,
1099 Z_ExtendedServicesResponse *res)
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 {
1112 ZOOM_options_set_int(c->tasks->u.package->options,
1113 "esError", c->error);
1114 ZOOM_options_set(c->tasks->u.package->options,
1115 "esAddinfo", c->addinfo);
1116 /* treat only diagnostics as error when operationStatus = failure */
1117 if (*res->operationStatus != Z_ExtendedServicesResponse_failure)
1118 ZOOM_set_error(c, ZOOM_ERROR_NONE, 0);
1119 }
1120 }
1121 switch (*res->operationStatus)
1122 {
1123 case Z_ExtendedServicesResponse_done:
1124 opStatus = "done";
1125 break;
1126 case Z_ExtendedServicesResponse_accepted:
1127 opStatus = "accepted";
1128 break;
1129 case Z_ExtendedServicesResponse_failure:
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 &&
1137 res->taskPackage->which == Z_External_extendedService)
1138 {
1139 Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
1140 es_response_taskpackage(c, taskPackage);
1141 }
1142 if (res->taskPackage &&
1143 res->taskPackage->which == Z_External_octet)
1144 {
1145 Odr_oct *doc = res->taskPackage->u.octet_aligned;
1146 ZOOM_options_setl(c->tasks->u.package->options,
1147 "xmlUpdateDoc", (char*) doc->buf, doc->len);
1148 }
1149 }
1150
get_term_cstr(ODR odr,Z_Term * term)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;
1158 case Z_Term_characterString:
1159 return odr_strdup(odr, term->u.characterString);
1160 }
1161 return 0;
1162 }
1163
get_zoom_facet_field(ODR odr,Z_FacetField * facet)1164 static ZOOM_facet_field get_zoom_facet_field(ODR odr, Z_FacetField *facet)
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 */
ZOOM_handle_facet_list(ZOOM_resultset r,Z_FacetList * fl)1190 void ZOOM_handle_facet_list(ZOOM_resultset r, Z_FacetList *fl)
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 *)
1207 ZOOM_facet_field_name(r->res_facets[j]);
1208 }
1209 }
1210
ZOOM_handle_facet_result(ZOOM_connection c,ZOOM_resultset r,Z_OtherInformation * o)1211 void ZOOM_handle_facet_result(ZOOM_connection c, ZOOM_resultset r,
1212 Z_OtherInformation *o)
1213 {
1214 int i;
1215 for (i = 0; o && i < o->num_elements; i++)
1216 {
1217 if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1218 {
1219 Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1220 if (ext->which == Z_External_userFacets)
1221 {
1222 ZOOM_handle_facet_list(r, ext->u.facetList);
1223 }
1224 }
1225 }
1226 }
1227
handle_queryExpressionTerm(ZOOM_options opt,const char * name,Z_Term * term)1228 static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
1229 Z_Term *term)
1230 {
1231 switch (term->which)
1232 {
1233 case Z_Term_general:
1234 ZOOM_options_setl(opt, name,
1235 term->u.general->buf, term->u.general->len);
1236 break;
1237 case Z_Term_characterString:
1238 ZOOM_options_set(opt, name, term->u.characterString);
1239 break;
1240 case Z_Term_numeric:
1241 ZOOM_options_set_int(opt, name, *term->u.numeric);
1242 break;
1243 }
1244 }
1245
handle_queryExpression(ZOOM_options opt,const char * name,Z_QueryExpression * exp)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 {
1253 case Z_QueryExpression_term:
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;
1260 case Z_QueryExpression_query:
1261 break;
1262 }
1263 }
1264
1265
ZOOM_handle_search_result(ZOOM_connection c,ZOOM_resultset resultset,Z_OtherInformation * o)1266 void ZOOM_handle_search_result(ZOOM_connection c, ZOOM_resultset resultset,
1267 Z_OtherInformation *o)
1268 {
1269 int i;
1270 for (i = 0; o && i < o->num_elements; i++)
1271 {
1272 if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1273 {
1274 Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1275
1276 if (ext->which == Z_External_searchResult1)
1277 {
1278 int j;
1279 Z_SearchInfoReport *sr = ext->u.searchResult1;
1280
1281 if (sr->num)
1282 ZOOM_options_set_int(
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
handle_Z3950_search_response(ZOOM_connection c,Z_SearchResponse * sr)1338 static void handle_Z3950_search_response(ZOOM_connection c,
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 {
1352 event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
1353 ZOOM_connection_put_event(c, event);
1354 }
1355 if (sr->resultSetStatus)
1356 {
1357 if (*sr->resultSetStatus == Z_SearchResponse_estimate)
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);
1369 ZOOM_handle_search_result(c, resultset, sr->additionalSearchInfo);
1370
1371 ZOOM_handle_facet_result(c, resultset, sr->additionalSearchInfo);
1372
1373 resultset->size = *sr->resultCount;
1374
1375 ZOOM_memcached_hitcount(c, resultset, sr->additionalSearchInfo,
1376 resultCountPrecision);
1377 resultset->live_set = 2;
1378 handle_Z3950_records(c, sr->records, 0);
1379 }
1380
handle_Z3950_sort_response(ZOOM_connection c,Z_SortResponse * res)1381 static void handle_Z3950_sort_response(ZOOM_connection c, Z_SortResponse *res)
1382 {
1383 if (res->diagnostics && res->num_diagnostics > 0)
1384 {
1385 response_diag(c, res->diagnostics[0]);
1386 ZOOM_connection_remove_tasks(c);
1387 }
1388 }
1389
handle_Z3950_scan_response(ZOOM_connection c,Z_ScanResponse * res)1390 static void handle_Z3950_scan_response(ZOOM_connection c, Z_ScanResponse *res)
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)
1400 response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
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
handle_Z3950_records(ZOOM_connection c,Z_Records * sr,int present_phase)1416 static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
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 {
1435 response_default_diag(c, sr->u.nonSurrogateDiagnostic);
1436 ZOOM_connection_remove_tasks(c);
1437 }
1438 else if (sr && sr->which == Z_Records_multipleNSD)
1439 {
1440 if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
1441 response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
1442 else
1443 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1444 ZOOM_connection_remove_tasks(c);
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);
1456 Z_NamePlusRecordList *p =
1457 sr->u.databaseOrSurDiagnostics;
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 =
1478 zget_surrogateDiagRec(
1479 resultset->odr, 0,
1480 YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
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 =
1491 zget_surrogateDiagRec(
1492 resultset->odr, 0,
1493 YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
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
handle_Z3950_present_response(ZOOM_connection c,Z_PresentResponse * pr)1502 static void handle_Z3950_present_response(ZOOM_connection c,
1503 Z_PresentResponse *pr)
1504 {
1505 handle_Z3950_records(c, pr->records, 1);
1506 }
1507
set_init_option(const char * name,void * clientData)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
send_Z3950_sort(ZOOM_connection c,ZOOM_resultset resultset)1517 zoom_ret send_Z3950_sort(ZOOM_connection c, ZOOM_resultset resultset)
1518 {
1519 if (c->error)
1520 resultset->r_sort_spec = 0;
1521 if (resultset->r_sort_spec)
1522 {
1523 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
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;
1529 req->inputResultSetNames = (Z_InternationalString **)
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
Z3950_send_present(ZOOM_connection c)1541 static zoom_ret Z3950_send_present(ZOOM_connection c)
1542 {
1543 Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
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 =
1565 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);
1566
1567 if (schema && *schema)
1568 {
1569 Z_RecordComposition *compo = (Z_RecordComposition *)
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 *)
1585 zoom_yaz_str_to_z3950oid(c, CLASS_SCHEMA, schema);
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 *)
1592 zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, schema);
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 =
1599 Z_ElementSpec_elementSetName;
1600 compo->u.complex->generic->elementSpec->u.elementSetName =
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 {
1612 Z_ElementSetNames *esn = (Z_ElementSetNames *)
1613 odr_malloc(c->odr_out, sizeof(*esn));
1614 Z_RecordComposition *compo = (Z_RecordComposition *)
1615 odr_malloc(c->odr_out, sizeof(*compo));
1616
1617 esn->which = Z_ElementSetNames_generic;
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
ZOOM_connection_Z3950_search(ZOOM_connection c)1627 zoom_ret ZOOM_connection_Z3950_search(ZOOM_connection c)
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 {
1653 ZOOM_set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
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
send_Z3950_sort_present(ZOOM_connection c)1688 static zoom_ret send_Z3950_sort_present(ZOOM_connection c)
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)
1695 r = ZOOM_connection_Z3950_search(c);
1696 return r;
1697 }
1698
ZOOM_handle_Z3950_apdu(ZOOM_connection c,Z_APDU * apdu)1699 void ZOOM_handle_Z3950_apdu(ZOOM_connection c, Z_APDU *apdu)
1700 {
1701 Z_InitResponse *initrs;
1702
1703 ZOOM_connection_set_mask(c, 0);
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 =
1745 yaz_oi_get_string_oid(&apdu->u.initResponse->otherInfo,
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);
1751 if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
1752 ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
1753 c->support_named_resultsets = 1;
1754 if (c->tasks)
1755 {
1756 assert(c->tasks->which == ZOOM_TASK_CONNECT);
1757 ZOOM_connection_remove_task(c);
1758 }
1759 ZOOM_connection_exec_task(c);
1760 }
1761 if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
1762 {
1763 NMEM tmpmem = nmem_create();
1764 Z_CharSetandLanguageNegotiation *p =
1765 yaz_get_charneg_record(initrs->otherInfo);
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
1784 ZOOM_connection_option_set(
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);
1793 handle_Z3950_search_response(c, apdu->u.searchResponse);
1794 if (send_Z3950_sort_present(c) == zoom_complete)
1795 ZOOM_connection_remove_task(c);
1796 break;
1797 case Z_APDU_presentResponse:
1798 yaz_log(c->log_api, "%p handle_Z3950_apdu Present response", c);
1799 handle_Z3950_present_response(c, apdu->u.presentResponse);
1800 if (ZOOM_connection_Z3950_search(c) == zoom_complete)
1801 ZOOM_connection_remove_task(c);
1802 break;
1803 case Z_APDU_sortResponse:
1804 yaz_log(c->log_api, "%p handle_Z3950_apdu Sort response", c);
1805 handle_Z3950_sort_response(c, apdu->u.sortResponse);
1806 if (ZOOM_connection_Z3950_search(c) == zoom_complete)
1807 ZOOM_connection_remove_task(c);
1808 break;
1809 case Z_APDU_scanResponse:
1810 yaz_log(c->log_api, "%p handle_Z3950_apdu Scan response", c);
1811 handle_Z3950_scan_response(c, apdu->u.scanResponse);
1812 ZOOM_connection_remove_task(c);
1813 break;
1814 case Z_APDU_extendedServicesResponse:
1815 yaz_log(c->log_api, "%p handle_Z3950_apdu Extended Services response", c);
1816 handle_Z3950_es_response(c, apdu->u.extendedServicesResponse);
1817 ZOOM_connection_remove_task(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 {
1823 ZOOM_set_dset_error(c, ZOOM_ERROR_CONNECTION_LOST, "ZOOM", c->host_port, apdu->u.close->diagnosticInformation);
1824 ZOOM_connection_close(c);
1825 }
1826 break;
1827 default:
1828 yaz_log(c->log_api, "%p Received unknown PDU", c);
1829 ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
1830 ZOOM_connection_close(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
1843