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