Merge branch 'master' into sru_2_0
[yaz-moved-to-github.git] / src / srwutil.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2013 Index Data
3  * See the file LICENSE for details.
4  */
5 /**
6  * \file srwutil.c
7  * \brief Implements SRW/SRU utilities.
8  */
9 #if HAVE_CONFIG_H
10 #include <config.h>
11 #endif
12
13 #include <stdlib.h>
14 #include <assert.h>
15 #include <yaz/srw.h>
16 #include <yaz/matchstr.h>
17 #include <yaz/base64.h>
18 #include <yaz/yaz-iconv.h>
19 #include "sru-p.h"
20
21 #define MAX_SRU_PARAMETERS 30
22
23 static char *yaz_decode_sru_dbpath_odr(ODR n, const char *uri, size_t len)
24 {
25     return odr_strdupn(n, uri, len);
26 }
27
28 void yaz_encode_sru_dbpath_buf(char *dst, const char *db)
29 {
30     assert(db);
31     *dst = '/';
32     strcpy(dst+1, db);
33 }
34
35 char *yaz_encode_sru_dbpath_odr(ODR out, const char *db)
36 {
37     char *dst = odr_malloc(out, 3 * strlen(db) + 2);
38     yaz_encode_sru_dbpath_buf(dst, db);
39     return dst;
40 }
41
42 Z_AttributeList *yaz_use_attribute_create(ODR o, const char *name)
43 {
44     Z_AttributeList *attributes= (Z_AttributeList *)
45         odr_malloc(o, sizeof(*attributes));
46     Z_AttributeElement ** elements;
47     attributes->num_attributes = 1;
48     elements = (Z_AttributeElement**)
49         odr_malloc(o, attributes->num_attributes * sizeof(*elements));
50     elements[0] = (Z_AttributeElement*) odr_malloc(o,sizeof(**elements));
51     elements[0]->attributeType = odr_intdup(o, 1);
52     elements[0]->attributeSet = odr_nullval();
53     elements[0]->which = Z_AttributeValue_complex;
54     elements[0]->value.complex = (Z_ComplexAttribute *)
55         odr_malloc(o, sizeof(Z_ComplexAttribute));
56     elements[0]->value.complex->num_list = 1;
57     elements[0]->value.complex->list = (Z_StringOrNumeric **)
58         odr_malloc(o, 1 * sizeof(Z_StringOrNumeric *));
59     elements[0]->value.complex->list[0] = (Z_StringOrNumeric *)
60         odr_malloc(o, sizeof(Z_StringOrNumeric));
61     elements[0]->value.complex->list[0]->which = Z_StringOrNumeric_string;
62     elements[0]->value.complex->list[0]->u.string = odr_strdup(o, name);
63     elements[0]->value.complex->semanticAction = 0;
64     elements[0]->value.complex->num_semanticAction = 0;
65     attributes->attributes = elements;
66     return attributes;
67 }
68
69 #if YAZ_HAVE_XML2
70 const char *yaz_element_attribute_value_get(xmlNodePtr ptr,
71                                             const char *node_name,
72                                             const char *attribute_name)
73 {
74     struct _xmlAttr *attr;
75     // check if the node name matches
76     if (strcmp((const char*) ptr->name, node_name))
77         return 0;
78     // check if the attribute name and return the value
79     for (attr = ptr->properties; attr; attr = attr->next)
80         if (attr->children && attr->children->type == XML_TEXT_NODE)
81         {
82             if (!strcmp((const char *) attr->name, attribute_name))
83                 return (const char *) attr->children->content;
84         }
85     return 0;
86 }
87 #endif
88
89 int yaz_srw_check_content_type(Z_HTTP_Response *hres)
90 {
91     const char *content_type = z_HTTP_header_lookup(hres->headers,
92                                                     "Content-Type");
93     if (content_type)
94     {
95         if (!yaz_strcmp_del("text/xml", content_type, "; "))
96             return 1;
97         if (!yaz_strcmp_del("application/xml", content_type, "; "))
98             return 1;
99     }
100     return 0;
101 }
102
103 /**
104  * Look for authentication tokens in HTTP Basic parameters or in x-username/x-password
105  * parameters. Added by SH.
106  */
107 static void yaz_srw_decodeauth(Z_SRW_PDU *sr, Z_HTTP_Request *hreq,
108                                char *username, char *password, ODR decode)
109 {
110     const char *basic = z_HTTP_header_lookup(hreq->headers, "Authorization");
111
112     if (username)
113         sr->username = username;
114     if (password)
115         sr->password = password;
116
117     if (basic)
118     {
119         int len;
120         char out[256];
121         char ubuf[256] = "", pbuf[256] = "", *p;
122         if (strncmp(basic, "Basic ", 6))
123             return;
124         basic += 6;
125         len = strlen(basic);
126         if (!len || len > 256)
127             return;
128         yaz_base64decode(basic, out);
129         /* Format of out should be username:password at this point */
130         strcpy(ubuf, out);
131         if ((p = strchr(ubuf, ':')))
132         {
133             *(p++) = '\0';
134             if (*p)
135                 strcpy(pbuf, p);
136         }
137         if (*ubuf)
138             sr->username = odr_strdup(decode, ubuf);
139         if (*pbuf)
140             sr->password = odr_strdup(decode, pbuf);
141     }
142 }
143
144 void yaz_uri_val_int(const char *path, const char *name, ODR o, Odr_int **intp)
145 {
146     const char *v = yaz_uri_val(path, name, o);
147     if (v)
148         *intp = odr_intdup(o, atoi(v));
149 }
150
151 void yaz_mk_srw_diagnostic(ODR o, Z_SRW_diagnostic *d,
152                            const char *uri, const char *message,
153                            const char *details)
154 {
155     d->uri = odr_strdup(o, uri);
156     if (message)
157         d->message = odr_strdup(o, message);
158     else
159         d->message = 0;
160     if (details)
161         d->details = odr_strdup(o, details);
162     else
163         d->details = 0;
164 }
165
166 void yaz_mk_std_diagnostic(ODR o, Z_SRW_diagnostic *d,
167                            int code, const char *details)
168 {
169     char uri[40];
170
171     sprintf(uri, "info:srw/diagnostic/1/%d", code);
172     yaz_mk_srw_diagnostic(o, d, uri, 0, details);
173 }
174
175 void yaz_add_srw_diagnostic_uri(ODR o, Z_SRW_diagnostic **d,
176                                 int *num, const char *uri,
177                                 const char *message, const char *details)
178 {
179     Z_SRW_diagnostic *d_new;
180     d_new = (Z_SRW_diagnostic *) odr_malloc(o, (*num + 1)* sizeof(**d));
181     if (*num)
182         memcpy(d_new, *d, *num *sizeof(**d));
183     *d = d_new;
184
185     yaz_mk_srw_diagnostic(o, *d + *num, uri, message, details);
186     (*num)++;
187 }
188
189 void yaz_add_srw_diagnostic(ODR o, Z_SRW_diagnostic **d,
190                             int *num, int code, const char *addinfo)
191 {
192     char uri[40];
193
194     sprintf(uri, "info:srw/diagnostic/1/%d", code);
195     yaz_add_srw_diagnostic_uri(o, d, num, uri, 0, addinfo);
196 }
197
198
199 void yaz_add_sru_update_diagnostic(ODR o, Z_SRW_diagnostic **d,
200                                    int *num, int code, const char *addinfo)
201 {
202     char uri[40];
203
204     sprintf(uri, "info:srw/diagnostic/12/%d", code);
205     yaz_add_srw_diagnostic_uri(o, d, num, uri, 0, addinfo);
206 }
207
208
209 void yaz_mk_sru_surrogate(ODR o, Z_SRW_record *record, int pos,
210                           int code, const char *details)
211 {
212     const char *message = yaz_diag_srw_str(code);
213     int len = 200;
214     if (message)
215         len += strlen(message);
216     if (details)
217         len += strlen(details);
218
219     record->recordData_buf = (char *) odr_malloc(o, len);
220
221     sprintf(record->recordData_buf, "<diagnostic "
222             "xmlns=\"http://www.loc.gov/zing/srw/diagnostic/\">\n"
223             " <uri>info:srw/diagnostic/1/%d</uri>\n", code);
224     if (details)
225         sprintf(record->recordData_buf + strlen(record->recordData_buf),
226                 " <details>%s</details>\n", details);
227     if (message)
228         sprintf(record->recordData_buf + strlen(record->recordData_buf),
229                 " <message>%s</message>\n", message);
230     sprintf(record->recordData_buf + strlen(record->recordData_buf),
231             "</diagnostic>\n");
232     record->recordData_len = strlen(record->recordData_buf);
233     record->recordPosition = odr_intdup(o, pos);
234     record->recordSchema = "info:srw/schema/1/diagnostics-v1.1";
235 }
236
237 static void grab_charset(ODR o, const char *content_type, char **charset)
238 {
239     if (charset)
240     {
241         const char *charset_p = 0;
242         if (content_type && (charset_p = strstr(content_type, "; charset=")))
243         {
244             int i = 0;
245             charset_p += 10;
246             while (i < 20 && charset_p[i] &&
247                    !strchr("; \n\r", charset_p[i]))
248                 i++;
249             *charset = (char*) odr_malloc(o, i+1);
250             memcpy(*charset, charset_p, i);
251             (*charset)[i] = '\0';
252         }
253     }
254 }
255
256 int yaz_srw_decode(Z_HTTP_Request *hreq, Z_SRW_PDU **srw_pdu,
257                    Z_SOAP **soap_package, ODR decode, char **charset)
258 {
259     if (!strcmp(hreq->method, "POST"))
260     {
261         const char *content_type = z_HTTP_header_lookup(hreq->headers,
262                                                         "Content-Type");
263         if (content_type &&
264             (!yaz_strcmp_del("text/xml", content_type, "; ") ||
265              !yaz_strcmp_del("application/soap+xml", content_type, "; ") ||
266              !yaz_strcmp_del("text/plain", content_type, "; ")))
267         {
268             char *db = "Default";
269             const char *p0 = hreq->path, *p1;
270             int ret = -1;
271
272             static Z_SOAP_Handler soap_handlers[5] = {
273 #if YAZ_HAVE_XML2
274                 { YAZ_XMLNS_SRU_v1_1, 0, (Z_SOAP_fun) yaz_srw_codec },
275                 { YAZ_XMLNS_SRU_v1_0, 0, (Z_SOAP_fun) yaz_srw_codec },
276                 { YAZ_XMLNS_UPDATE_v0_9, 0, (Z_SOAP_fun) yaz_ucp_codec },
277                 { YAZ_XMLNS_SRU_v2_mask, 0, (Z_SOAP_fun) yaz_srw_codec },
278 #endif
279                 {0, 0, 0}
280             };
281
282             if (*p0 == '/')
283                 p0++;
284             p1 = strchr(p0, '?');
285             if (!p1)
286                 p1 = p0 + strlen(p0);
287             if (p1 != p0)
288                 db = yaz_decode_sru_dbpath_odr(decode, p0, p1 - p0);
289             grab_charset(decode, content_type, charset);
290
291             ret = z_soap_codec(decode, soap_package,
292                                &hreq->content_buf, &hreq->content_len,
293                                soap_handlers);
294             if (ret == 0 && (*soap_package)->which == Z_SOAP_generic)
295             {
296                 *srw_pdu = (Z_SRW_PDU*) (*soap_package)->u.generic->p;
297                 yaz_srw_decodeauth(*srw_pdu, hreq, 0, 0, decode);
298
299                 /* last entry in handlers - SRU 2.0 - is turned into
300                    offset 0.. due to other pieces relying on it */
301                 if ((*soap_package)->u.generic->no == 3)
302                     (*soap_package)->u.generic->no = 0;
303                 if ((*srw_pdu)->which == Z_SRW_searchRetrieve_request &&
304                     (*srw_pdu)->u.request->database == 0)
305                     (*srw_pdu)->u.request->database = db;
306
307                 if ((*srw_pdu)->which == Z_SRW_explain_request &&
308                     (*srw_pdu)->u.explain_request->database == 0)
309                     (*srw_pdu)->u.explain_request->database = db;
310
311                 if ((*srw_pdu)->which == Z_SRW_scan_request &&
312                     (*srw_pdu)->u.scan_request->database == 0)
313                     (*srw_pdu)->u.scan_request->database = db;
314
315                 if ((*srw_pdu)->which == Z_SRW_update_request &&
316                     (*srw_pdu)->u.update_request->database == 0)
317                     (*srw_pdu)->u.update_request->database = db;
318
319                 return 0;
320             }
321             return 1;
322         }
323     }
324     return 2;
325 }
326
327 #if YAZ_HAVE_XML2
328 static int yaz_sru_decode_integer(ODR odr, const char *pname,
329                                   const char *valstr, Odr_int **valp,
330                                   Z_SRW_diagnostic **diag, int *num_diag,
331                                   int min_value)
332 {
333     int ival;
334     if (!valstr)
335         return 0;
336     if (sscanf(valstr, "%d", &ival) != 1)
337     {
338         yaz_add_srw_diagnostic(odr, diag, num_diag,
339                                YAZ_SRW_UNSUPP_PARAMETER_VALUE, pname);
340         return 0;
341     }
342     if (min_value >= 0 && ival < min_value)
343     {
344         yaz_add_srw_diagnostic(odr, diag, num_diag,
345                                YAZ_SRW_UNSUPP_PARAMETER_VALUE, pname);
346         return 0;
347     }
348     *valp = odr_intdup(odr, ival);
349     return 1;
350 }
351 #endif
352
353 /**
354    http://www.loc.gov/z3950/agency/zing/srw/service.html
355 */
356 int yaz_sru_decode(Z_HTTP_Request *hreq, Z_SRW_PDU **srw_pdu,
357                    Z_SOAP **soap_package, ODR decode, char **charset,
358                    Z_SRW_diagnostic **diag, int *num_diag)
359 {
360 #if YAZ_HAVE_XML2
361     static Z_SOAP_Handler soap_handlers[2] = {
362         {YAZ_XMLNS_SRU_v1_1, 0, (Z_SOAP_fun) yaz_srw_codec},
363         {0, 0, 0}
364     };
365 #endif
366     const char *content_type = z_HTTP_header_lookup(hreq->headers,
367                                                     "Content-Type");
368
369     /*
370       SRU GET: ignore content type.
371       SRU POST: we support "application/x-www-form-urlencoded";
372       not  "multipart/form-data" .
373     */
374     if (!strcmp(hreq->method, "GET")
375         ||
376         (!strcmp(hreq->method, "POST") && content_type &&
377          !yaz_strcmp_del("application/x-www-form-urlencoded",
378                          content_type, "; ")))
379     {
380         char *db = "Default";
381         const char *p0 = hreq->path, *p1;
382 #if YAZ_HAVE_XML2
383         const char *operation = 0;
384         char *version = 0;
385         char *query = 0;
386         char *queryType = "cql";
387         char *username = 0;
388         char *password = 0;
389         char *sortKeys = 0;
390         char *stylesheet = 0;
391         char *scanClause = 0;
392         char *recordXPath = 0;
393         char *recordSchema = 0;
394         char *recordXMLEscaping = 0;
395         char *recordPacking = 0;
396         char *maximumRecords = 0;
397         char *startRecord = 0;
398         char *maximumTerms = 0;
399         char *responsePosition = 0;
400         const char *facetLimit = 0;
401         const char *facetStart = 0;
402         const char *facetSort = 0;
403         Z_SRW_extra_arg *extra_args = 0;
404 #endif
405         char **uri_name;
406         char **uri_val;
407
408         grab_charset(decode, content_type, charset);
409         if (charset && *charset == 0 && !strcmp(hreq->method, "GET"))
410             *charset = "UTF-8";
411
412         if (*p0 == '/')
413             p0++;
414         p1 = strchr(p0, '?');
415         if (!p1)
416             p1 = p0 + strlen(p0);
417         if (p1 != p0)
418             db = yaz_decode_sru_dbpath_odr(decode, p0, p1 - p0);
419         if (!strcmp(hreq->method, "POST"))
420             p1 = hreq->content_buf;
421         yaz_uri_to_array(p1, decode, &uri_name, &uri_val);
422 #if YAZ_HAVE_XML2
423         if (uri_name)
424         {
425             int i;
426             for (i = 0; uri_name[i]; i++)
427             {
428                 char *n = uri_name[i];
429                 char *v = uri_val[i];
430                 if (!strcmp(n, "query"))
431                     query = v;
432                 else if (!strcmp(n, "x-pquery"))
433                 {
434                     query = v;
435                     queryType = "pqf";
436                 }
437                 else if (!strcmp(n, "queryType"))
438                     queryType = v;
439                 else if (!strcmp(n, "x-username"))
440                     username = v;
441                 else if (!strcmp(n, "x-password"))
442                     password = v;
443                 else if (!strcmp(n, "operation"))
444                     operation = v;
445                 else if (!strcmp(n, "stylesheet"))
446                     stylesheet = v;
447                 else if (!strcmp(n, "sortKeys"))
448                     sortKeys = v;
449                 else if (!strcmp(n, "recordXPath"))
450                     recordXPath = v;
451                 else if (!strcmp(n, "recordSchema"))
452                     recordSchema = v;
453                 else if (!strcmp(n, "recordPacking"))
454                     recordPacking = v;
455                 else if (!strcmp(n, "recordXMLEscaping"))
456                     recordXMLEscaping = v;
457                 else if (!strcmp(n, "version"))
458                     version = v;
459                 else if (!strcmp(n, "scanClause"))
460                     scanClause = v;
461                 else if (!strcmp(n, "x-pScanClause"))
462                 {
463                     scanClause = v;
464                     queryType = "pqf";
465                 }
466                 else if (!strcmp(n, "maximumRecords"))
467                     maximumRecords = v;
468                 else if (!strcmp(n, "startRecord"))
469                     startRecord = v;
470                 else if (!strcmp(n, "maximumTerms"))
471                     maximumTerms = v;
472                 else if (!strcmp(n, "responsePosition"))
473                     responsePosition = v;
474                 else if (!strcmp(n, "facetLimit"))
475                     facetLimit = v;
476                 else if (!strcmp(n, "facetStart"))
477                     facetStart = v;
478                 else if (!strcmp(n, "facetSort"))
479                     facetSort = v;
480                 else if (!strcmp(n, "extraRequestData"))
481                     ; /* ignoring extraRequestData */
482                 else if (n[0] == 'x' && n[1] == '-')
483                 {
484                     Z_SRW_extra_arg **l = &extra_args;
485                     while (*l)
486                         l = &(*l)->next;
487                     *l = (Z_SRW_extra_arg *) odr_malloc(decode, sizeof(**l));
488                     (*l)->name = odr_strdup(decode, n);
489                     (*l)->value = odr_strdup(decode, v);
490                     (*l)->next = 0;
491                 }
492                 else
493                 {
494                     if (*num_diag < 10)
495                         yaz_add_srw_diagnostic(decode, diag, num_diag,
496                                                YAZ_SRW_UNSUPP_PARAMETER, n);
497                 }
498             }
499         }
500         if (!operation)
501         {
502             if (query)
503                 operation = "searchRetrieve";
504             else if (scanClause)
505                 operation = "scan";
506         }
507         version = yaz_negotiate_sru_version(version);
508
509         if (!version)
510         {   /* negotiation failed. */
511             yaz_add_srw_diagnostic(decode, diag, num_diag,
512                                    YAZ_SRW_UNSUPP_VERSION, "2.0");
513             version = "2.0";
514         }
515         if (!operation)
516         {
517             if (uri_name)
518                 yaz_add_srw_diagnostic(
519                     decode, diag, num_diag,
520                     YAZ_SRW_MANDATORY_PARAMETER_NOT_SUPPLIED, "operation");
521             operation = "explain";
522         }
523         if (strcmp(version, "2.0"))
524         {
525             if (recordXMLEscaping)
526             {
527                 yaz_add_srw_diagnostic(decode, diag, num_diag,
528                                        YAZ_SRW_UNSUPP_PARAMETER,
529                                        "recordXMLEscaping");
530
531             }
532             recordXMLEscaping = recordPacking;
533             recordPacking = "packed";
534         }
535         if (!recordXMLEscaping)
536             recordXMLEscaping = "xml";
537         if (!strcmp(operation, "searchRetrieve"))
538         {
539             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_searchRetrieve_request);
540
541             sr->srw_version = version;
542             sr->extra_args = extra_args;
543             *srw_pdu = sr;
544             yaz_srw_decodeauth(sr, hreq, username, password, decode);
545
546             sr->u.request->queryType = queryType;
547             sr->u.request->query = query;
548
549             if (!query)
550                 yaz_add_srw_diagnostic(
551                     decode, diag, num_diag,
552                     YAZ_SRW_MANDATORY_PARAMETER_NOT_SUPPLIED, "query");
553
554             if (sortKeys)
555             {
556                 sr->u.request->sort_type = Z_SRW_sort_type_sort;
557                 sr->u.request->sort.sortKeys = sortKeys;
558             }
559             sr->u.request->recordXPath = recordXPath;
560             sr->u.request->recordSchema = recordSchema;
561             sr->u.request->recordPacking = recordXMLEscaping;
562             sr->u.request->packing = recordPacking;
563             sr->u.request->stylesheet = stylesheet;
564             yaz_sru_facet_request(decode , &sr->u.request->facetList,
565                                   &facetLimit, &facetStart, &facetSort);
566
567             yaz_sru_decode_integer(decode, "maximumRecords", maximumRecords,
568                                    &sr->u.request->maximumRecords,
569                                    diag, num_diag, 0);
570
571             yaz_sru_decode_integer(decode, "startRecord", startRecord,
572                                    &sr->u.request->startRecord,
573                                    diag, num_diag, 1);
574
575             sr->u.request->database = db;
576
577             (*soap_package) = (Z_SOAP *)
578                 odr_malloc(decode, sizeof(**soap_package));
579             (*soap_package)->which = Z_SOAP_generic;
580
581             (*soap_package)->u.generic = (Z_SOAP_Generic *)
582                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
583
584             (*soap_package)->u.generic->p = sr;
585             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
586             (*soap_package)->u.generic->no = 0;
587
588             (*soap_package)->ns = "SRU";
589
590             return 0;
591         }
592         else if (!strcmp(operation, "explain"))
593         {
594             /* Transfer SRU explain parameters to common struct */
595             /* http://www.loc.gov/z3950/agency/zing/srw/explain.html */
596             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_explain_request);
597
598             sr->srw_version = version;
599             sr->extra_args = extra_args;
600             yaz_srw_decodeauth(sr, hreq, username, password, decode);
601             *srw_pdu = sr;
602             sr->u.explain_request->recordPacking = recordXMLEscaping;
603             sr->u.explain_request->packing = recordPacking;
604             sr->u.explain_request->database = db;
605
606             sr->u.explain_request->stylesheet = stylesheet;
607
608             (*soap_package) = (Z_SOAP *)
609                 odr_malloc(decode, sizeof(**soap_package));
610             (*soap_package)->which = Z_SOAP_generic;
611
612             (*soap_package)->u.generic = (Z_SOAP_Generic *)
613                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
614
615             (*soap_package)->u.generic->p = sr;
616             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
617             (*soap_package)->u.generic->no = 0;
618
619             (*soap_package)->ns = "SRU";
620
621             return 0;
622         }
623         else if (!strcmp(operation, "scan"))
624         {
625             /* Transfer SRU scan parameters to common struct */
626             /* http://www.loc.gov/z3950/agency/zing/srw/scan.html */
627             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_scan_request);
628
629             sr->srw_version = version;
630             sr->extra_args = extra_args;
631             *srw_pdu = sr;
632             yaz_srw_decodeauth(sr, hreq, username, password, decode);
633
634             sr->u.scan_request->queryType = queryType;
635             sr->u.scan_request->scanClause = scanClause;
636
637             if (!scanClause)
638                 yaz_add_srw_diagnostic(
639                     decode, diag, num_diag,
640                     YAZ_SRW_MANDATORY_PARAMETER_NOT_SUPPLIED, "scanClause");
641             sr->u.scan_request->database = db;
642
643             yaz_sru_decode_integer(decode, "maximumTerms",
644                                    maximumTerms,
645                                    &sr->u.scan_request->maximumTerms,
646                                    diag, num_diag, 0);
647
648             yaz_sru_decode_integer(decode, "responsePosition",
649                                    responsePosition,
650                                    &sr->u.scan_request->responsePosition,
651                                    diag, num_diag, 0);
652
653             sr->u.scan_request->stylesheet = stylesheet;
654
655             (*soap_package) = (Z_SOAP *)
656                 odr_malloc(decode, sizeof(**soap_package));
657             (*soap_package)->which = Z_SOAP_generic;
658
659             (*soap_package)->u.generic = (Z_SOAP_Generic *)
660                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
661
662             (*soap_package)->u.generic->p = sr;
663             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
664             (*soap_package)->u.generic->no = 0;
665
666             (*soap_package)->ns = "SRU";
667
668             return 0;
669         }
670         else
671         {
672             /* unsupported operation ... */
673             /* Act as if we received a explain request and throw diagnostic. */
674
675             Z_SRW_PDU *sr = yaz_srw_get(decode, Z_SRW_explain_request);
676
677             sr->srw_version = version;
678             *srw_pdu = sr;
679             sr->u.explain_request->recordPacking = recordPacking;
680             sr->u.explain_request->database = db;
681
682             sr->u.explain_request->stylesheet = stylesheet;
683
684             (*soap_package) = (Z_SOAP *)
685                 odr_malloc(decode, sizeof(**soap_package));
686             (*soap_package)->which = Z_SOAP_generic;
687
688             (*soap_package)->u.generic = (Z_SOAP_Generic *)
689                 odr_malloc(decode, sizeof(*(*soap_package)->u.generic));
690
691             (*soap_package)->u.generic->p = sr;
692             (*soap_package)->u.generic->ns = soap_handlers[0].ns;
693             (*soap_package)->u.generic->no = 0;
694
695             (*soap_package)->ns = "SRU";
696
697             yaz_add_srw_diagnostic(decode, diag, num_diag,
698                                    YAZ_SRW_UNSUPP_OPERATION, operation);
699             return 0;
700         }
701 #else
702         return 1;
703 #endif
704     }
705     return 2;
706 }
707
708 Z_SRW_extra_record *yaz_srw_get_extra_record(ODR o)
709 {
710     Z_SRW_extra_record *res = (Z_SRW_extra_record *)
711         odr_malloc(o, sizeof(*res));
712
713     res->extraRecordData_buf = 0;
714     res->extraRecordData_len = 0;
715     res->recordIdentifier = 0;
716     return res;
717 }
718
719
720 Z_SRW_record *yaz_srw_get_records(ODR o, int n)
721 {
722     Z_SRW_record *res = (Z_SRW_record *) odr_malloc(o, n * sizeof(*res));
723     int i;
724
725     for (i = 0; i<n; i++)
726     {
727         res[i].recordSchema = 0;
728         res[i].recordPacking = Z_SRW_recordPacking_string;
729         res[i].recordData_buf = 0;
730         res[i].recordData_len = 0;
731         res[i].recordPosition = 0;
732     }
733     return res;
734 }
735
736 Z_SRW_record *yaz_srw_get_record(ODR o)
737 {
738     return yaz_srw_get_records(o, 1);
739 }
740
741 static Z_SRW_PDU *yaz_srw_get_core_ver(ODR o, const char *version)
742 {
743     Z_SRW_PDU *p = (Z_SRW_PDU *) odr_malloc(o, sizeof(*p));
744     p->srw_version = odr_strdup(o, version);
745     p->username = 0;
746     p->password = 0;
747     p->extra_args = 0;
748     p->extraResponseData_buf = 0;
749     p->extraResponseData_len = 0;
750     return p;
751 }
752
753 Z_SRW_PDU *yaz_srw_get_core_v_2_0(ODR o)
754 {
755     return yaz_srw_get_core_ver(o, "2.0");
756 }
757
758 Z_SRW_PDU *yaz_srw_get(ODR o, int which)
759 {
760     return yaz_srw_get_pdu(o, which, "2.0");
761 }
762
763 Z_SRW_PDU *yaz_srw_get_pdu(ODR o, int which, const char *version)
764 {
765     Z_SRW_PDU *sr = yaz_srw_get_core_ver(o, version);
766
767     sr->which = which;
768     switch(which)
769     {
770     case Z_SRW_searchRetrieve_request:
771         sr->u.request = (Z_SRW_searchRetrieveRequest *)
772             odr_malloc(o, sizeof(*sr->u.request));
773         sr->u.request->queryType = "cql";
774         sr->u.request->query = 0;
775         sr->u.request->sort_type = Z_SRW_sort_type_none;
776         sr->u.request->sort.none = 0;
777         sr->u.request->startRecord = 0;
778         sr->u.request->maximumRecords = 0;
779         sr->u.request->recordSchema = 0;
780         sr->u.request->recordPacking = 0;
781         sr->u.request->packing = 0;
782         sr->u.request->recordXPath = 0;
783         sr->u.request->database = 0;
784         sr->u.request->resultSetTTL = 0;
785         sr->u.request->stylesheet = 0;
786         sr->u.request->facetList = 0;
787         break;
788     case Z_SRW_searchRetrieve_response:
789         sr->u.response = (Z_SRW_searchRetrieveResponse *)
790             odr_malloc(o, sizeof(*sr->u.response));
791         sr->u.response->numberOfRecords = 0;
792         sr->u.response->resultCountPrecision = 0;
793         sr->u.response->resultSetId = 0;
794         sr->u.response->resultSetIdleTime = 0;
795         sr->u.response->records = 0;
796         sr->u.response->num_records = 0;
797         sr->u.response->diagnostics = 0;
798         sr->u.response->num_diagnostics = 0;
799         sr->u.response->nextRecordPosition = 0;
800         sr->u.response->extra_records = 0;
801         sr->u.response->facetList = 0;
802         sr->u.response->suggestions = 0;
803         break;
804     case Z_SRW_explain_request:
805         sr->u.explain_request = (Z_SRW_explainRequest *)
806             odr_malloc(o, sizeof(*sr->u.explain_request));
807         sr->u.explain_request->recordPacking = 0;
808         sr->u.explain_request->packing = 0;
809         sr->u.explain_request->database = 0;
810         sr->u.explain_request->stylesheet = 0;
811         break;
812     case Z_SRW_explain_response:
813         sr->u.explain_response = (Z_SRW_explainResponse *)
814             odr_malloc(o, sizeof(*sr->u.explain_response));
815         sr->u.explain_response->record.recordData_buf = 0;
816         sr->u.explain_response->record.recordData_len = 0;
817         sr->u.explain_response->record.recordSchema = 0;
818         sr->u.explain_response->record.recordPosition = 0;
819         sr->u.explain_response->record.recordPacking =
820             Z_SRW_recordPacking_string;
821         sr->u.explain_response->diagnostics = 0;
822         sr->u.explain_response->num_diagnostics = 0;
823         sr->u.explain_response->extra_record = 0;
824         break;
825     case Z_SRW_scan_request:
826         sr->u.scan_request = (Z_SRW_scanRequest *)
827             odr_malloc(o, sizeof(*sr->u.scan_request));
828         sr->u.scan_request->database = 0;
829         sr->u.scan_request->stylesheet = 0;
830         sr->u.scan_request->maximumTerms = 0;
831         sr->u.scan_request->responsePosition = 0;
832         sr->u.scan_request->queryType = "cql";
833         sr->u.scan_request->scanClause = 0;
834         break;
835     case Z_SRW_scan_response:
836         sr->u.scan_response = (Z_SRW_scanResponse *)
837             odr_malloc(o, sizeof(*sr->u.scan_response));
838         sr->u.scan_response->terms = 0;
839         sr->u.scan_response->num_terms = 0;
840         sr->u.scan_response->diagnostics = 0;
841         sr->u.scan_response->num_diagnostics = 0;
842         break;
843     case Z_SRW_update_request:
844         sr->u.update_request = (Z_SRW_updateRequest *)
845             odr_malloc(o, sizeof(*sr->u.update_request));
846         sr->u.update_request->database = 0;
847         sr->u.update_request->stylesheet = 0;
848         sr->u.update_request->record = 0;
849         sr->u.update_request->recordId = 0;
850         sr->u.update_request->recordVersions = 0;
851         sr->u.update_request->num_recordVersions = 0;
852         sr->u.update_request->extra_record = 0;
853         sr->u.update_request->extraRequestData_buf = 0;
854         sr->u.update_request->extraRequestData_len = 0;
855         sr->u.request->database = 0;
856         break;
857     case Z_SRW_update_response:
858         sr->u.update_response = (Z_SRW_updateResponse *)
859             odr_malloc(o, sizeof(*sr->u.update_response));
860         sr->u.update_response->operationStatus = 0;
861         sr->u.update_response->recordId = 0;
862         sr->u.update_response->recordVersions = 0;
863         sr->u.update_response->num_recordVersions = 0;
864         sr->u.update_response->record = 0;
865         sr->u.update_response->extra_record = 0;
866         sr->u.update_response->extraResponseData_buf = 0;
867         sr->u.update_response->extraResponseData_len = 0;
868         sr->u.update_response->diagnostics = 0;
869         sr->u.update_response->num_diagnostics = 0;
870     }
871     return sr;
872 }
873
874 void yaz_add_name_value_int(ODR o, char **name, char **value, int *i,
875                             char *a_name, Odr_int *val)
876 {
877     if (val)
878     {
879         name[*i] = a_name;
880         value[*i] = (char *) odr_malloc(o, 40);
881         sprintf(value[*i], ODR_INT_PRINTF, *val);
882         (*i)++;
883     }
884 }
885
886 void yaz_add_name_value_str(ODR o, char **name, char **value,  int *i,
887                             char *a_name, char *val)
888 {
889     if (val)
890     {
891         name[*i] = a_name;
892         value[*i] = val;
893         (*i)++;
894     }
895 }
896
897 static int yaz_get_sru_parms(const Z_SRW_PDU *srw_pdu, ODR encode,
898                              char **name, char **value, int max_names)
899 {
900     int version2 = strcmp(srw_pdu->srw_version, "2.") > 0;
901     int i = 0;
902     char *queryType;
903     yaz_add_name_value_str(encode, name, value, &i, "version",
904                            srw_pdu->srw_version);
905     name[i] = "operation";
906     switch (srw_pdu->which)
907     {
908     case Z_SRW_searchRetrieve_request:
909         value[i++] = "searchRetrieve";
910         queryType = srw_pdu->u.request->queryType;
911         if (version2)
912         {
913             if (queryType && strcmp(queryType, "cql"))
914                 yaz_add_name_value_str(encode, name, value, &i, "queryType",
915                                        queryType);
916             yaz_add_name_value_str(encode, name, value, &i, "query",
917                                    srw_pdu->u.request->query);
918         }
919         else
920         {
921             if (!strcmp(queryType, "cql"))
922             {
923                 yaz_add_name_value_str(encode, name, value, &i, "query",
924                                        srw_pdu->u.request->query);
925             }
926             else if (!strcmp(queryType, "pqf"))
927             {
928                 yaz_add_name_value_str(encode, name, value, &i, "x-pquery",
929                                        srw_pdu->u.request->query);
930             }
931             else if (!strcmp(queryType, "xcql"))
932             {
933                 yaz_add_name_value_str(encode, name, value, &i, "x-cql",
934                                        srw_pdu->u.request->query);
935             }
936         }
937         switch (srw_pdu->u.request->sort_type)
938         {
939         case Z_SRW_sort_type_none:
940             break;
941         case Z_SRW_sort_type_sort:
942             yaz_add_name_value_str(encode, name, value, &i, "sortKeys",
943                                    srw_pdu->u.request->sort.sortKeys);
944             break;
945         }
946         yaz_add_name_value_int(encode, name, value, &i, "startRecord",
947                                srw_pdu->u.request->startRecord);
948         yaz_add_name_value_int(encode, name, value, &i, "maximumRecords",
949                                srw_pdu->u.request->maximumRecords);
950         yaz_add_name_value_str(encode, name, value, &i, "recordSchema",
951                                srw_pdu->u.request->recordSchema);
952         if (version2)
953         {
954             yaz_add_name_value_str(encode, name, value, &i, "recordXMLEscaping",
955                                    srw_pdu->u.request->recordPacking);
956             yaz_add_name_value_str(encode, name, value, &i, "recordPacking",
957                                    srw_pdu->u.request->packing);
958         }
959         else
960             yaz_add_name_value_str(encode, name, value, &i, "recordPacking",
961                                    srw_pdu->u.request->recordPacking);
962         yaz_add_name_value_str(encode, name, value, &i, "recordXPath",
963                                srw_pdu->u.request->recordXPath);
964         yaz_add_name_value_str(encode, name, value, &i, "stylesheet",
965                                srw_pdu->u.request->stylesheet);
966         yaz_add_name_value_int(encode, name, value, &i, "resultSetTTL",
967                                srw_pdu->u.request->resultSetTTL);
968         {
969             const char *facetLimit = 0;
970             const char *facetStart = 0;
971             const char *facetSort = 0;
972             yaz_sru_facet_request(encode, &srw_pdu->u.request->facetList,
973                                   &facetLimit, &facetStart, &facetSort);
974             yaz_add_name_value_str(encode, name, value, &i, "facetLimit",
975                                    (char *) facetLimit);
976             yaz_add_name_value_str(encode, name, value, &i, "facetStart",
977                                    (char *) facetStart);
978             yaz_add_name_value_str(encode, name, value, &i, "facetSort",
979                                    (char *) facetSort);
980         }
981         break;
982     case Z_SRW_explain_request:
983         value[i++] = "explain";
984
985         if (version2)
986         {
987             yaz_add_name_value_str(encode, name, value, &i, "recordXMLEscaping",
988                                    srw_pdu->u.explain_request->recordPacking);
989             yaz_add_name_value_str(encode, name, value, &i, "recordPacking",
990                                    srw_pdu->u.explain_request->packing);
991         }
992         else
993             yaz_add_name_value_str(encode, name, value, &i, "recordPacking",
994                                    srw_pdu->u.explain_request->recordPacking);
995         yaz_add_name_value_str(encode, name, value, &i, "stylesheet",
996                                srw_pdu->u.explain_request->stylesheet);
997         break;
998     case Z_SRW_scan_request:
999         value[i++] = "scan";
1000         queryType = srw_pdu->u.scan_request->queryType;
1001         if (version2)
1002         {
1003             if (queryType && strcmp(queryType, "cql"))
1004                 yaz_add_name_value_str(encode, name, value, &i, "queryType",
1005                                        queryType);
1006             yaz_add_name_value_str(encode, name, value, &i, "scanClause",
1007                                    srw_pdu->u.scan_request->scanClause);
1008         }
1009         else
1010         {
1011             if (!queryType || !strcmp(queryType, "cql"))
1012                 yaz_add_name_value_str(encode, name, value, &i, "scanClause",
1013                                        srw_pdu->u.scan_request->scanClause);
1014             else if (!strcmp(queryType, "pqf"))
1015                 yaz_add_name_value_str(encode, name, value, &i, "x-pScanClause",
1016                                        srw_pdu->u.scan_request->scanClause);
1017             else if (!strcmp(queryType, "xcql"))
1018                 yaz_add_name_value_str(encode, name, value, &i,
1019                                        "x-cqlScanClause",
1020                                        srw_pdu->u.scan_request->scanClause);
1021         }
1022         yaz_add_name_value_int(encode, name, value, &i, "responsePosition",
1023                                srw_pdu->u.scan_request->responsePosition);
1024         yaz_add_name_value_int(encode, name, value, &i, "maximumTerms",
1025                                srw_pdu->u.scan_request->maximumTerms);
1026         yaz_add_name_value_str(encode, name, value, &i, "stylesheet",
1027                                srw_pdu->u.scan_request->stylesheet);
1028         break;
1029     case Z_SRW_update_request:
1030         value[i++] = "update";
1031         break;
1032     default:
1033         return -1;
1034     }
1035     if (srw_pdu->extra_args)
1036     {
1037         Z_SRW_extra_arg *ea = srw_pdu->extra_args;
1038         for (; ea && i < max_names-1; ea = ea->next)
1039         {
1040             name[i] = ea->name;
1041             value[i] = ea->value;
1042             i++;
1043         }
1044     }
1045     name[i++] = 0;
1046
1047     return 0;
1048 }
1049
1050 int yaz_sru_get_encode(Z_HTTP_Request *hreq, Z_SRW_PDU *srw_pdu,
1051                        ODR encode, const char *charset)
1052 {
1053     char *name[MAX_SRU_PARAMETERS], *value[MAX_SRU_PARAMETERS]; /* definite upper limit for SRU params */
1054     char *uri_args;
1055     char *path;
1056
1057     z_HTTP_header_add_basic_auth(encode, &hreq->headers,
1058                                  srw_pdu->username, srw_pdu->password);
1059     if (yaz_get_sru_parms(srw_pdu, encode, name, value, MAX_SRU_PARAMETERS))
1060         return -1;
1061     yaz_array_to_uri(&uri_args, encode, name, value);
1062
1063     hreq->method = "GET";
1064
1065     path = (char *)
1066         odr_malloc(encode, strlen(hreq->path) + strlen(uri_args) + 4);
1067
1068     sprintf(path, "%s?%s", hreq->path, uri_args);
1069     hreq->path = path;
1070
1071     z_HTTP_header_add_content_type(encode, &hreq->headers,
1072                                    "text/xml", charset);
1073     return 0;
1074 }
1075
1076 int yaz_sru_post_encode(Z_HTTP_Request *hreq, Z_SRW_PDU *srw_pdu,
1077                         ODR encode, const char *charset)
1078 {
1079     char *name[MAX_SRU_PARAMETERS], *value[MAX_SRU_PARAMETERS]; /* definite upper limit for SRU params */
1080     char *uri_args;
1081
1082     z_HTTP_header_add_basic_auth(encode, &hreq->headers,
1083                                  srw_pdu->username, srw_pdu->password);
1084     if (yaz_get_sru_parms(srw_pdu, encode, name, value, MAX_SRU_PARAMETERS))
1085         return -1;
1086
1087     yaz_array_to_uri(&uri_args, encode, name, value);
1088
1089     hreq->method = "POST";
1090
1091     hreq->content_buf = uri_args;
1092     hreq->content_len = strlen(uri_args);
1093
1094     z_HTTP_header_add_content_type(encode, &hreq->headers,
1095                                    "application/x-www-form-urlencoded",
1096                                    charset);
1097     return 0;
1098 }
1099
1100 int yaz_sru_soap_encode(Z_HTTP_Request *hreq, Z_SRW_PDU *srw_pdu,
1101                         ODR odr, const char *charset)
1102 {
1103     Z_SOAP_Handler handlers[3] = {
1104 #if YAZ_HAVE_XML2
1105         {YAZ_XMLNS_SRU_v1_1, 0, (Z_SOAP_fun) yaz_srw_codec},
1106         {YAZ_XMLNS_UPDATE_v0_9, 0, (Z_SOAP_fun) yaz_ucp_codec},
1107 #endif
1108         {0, 0, 0}
1109     };
1110     Z_SOAP *p = (Z_SOAP*) odr_malloc(odr, sizeof(*p));
1111
1112     z_HTTP_header_add_basic_auth(odr, &hreq->headers,
1113                                  srw_pdu->username, srw_pdu->password);
1114     z_HTTP_header_add_content_type(odr,
1115                                    &hreq->headers,
1116                                    "text/xml", charset);
1117
1118     z_HTTP_header_add(odr, &hreq->headers,
1119                       "SOAPAction", "\"\"");
1120     p->which = Z_SOAP_generic;
1121     p->u.generic = (Z_SOAP_Generic *) odr_malloc(odr, sizeof(*p->u.generic));
1122     p->u.generic->no = 0;
1123     p->u.generic->ns = 0;
1124     p->u.generic->p = srw_pdu;
1125     p->ns = "http://schemas.xmlsoap.org/soap/envelope/";
1126
1127 #if YAZ_HAVE_XML2
1128     if (srw_pdu->which == Z_SRW_update_request ||
1129         srw_pdu->which == Z_SRW_update_response)
1130         p->u.generic->no = 1; /* second handler */
1131 #endif
1132     return z_soap_codec_enc(odr, &p,
1133                             &hreq->content_buf,
1134                             &hreq->content_len, handlers,
1135                             charset);
1136 }
1137
1138 Z_SRW_recordVersion *yaz_srw_get_record_versions(ODR odr, int num)
1139 {
1140     Z_SRW_recordVersion *ver
1141         = (Z_SRW_recordVersion *) odr_malloc(odr,num * sizeof(*ver));
1142     int i;
1143     for (i = 0; i < num; ++i)
1144     {
1145         ver[i].versionType = 0;
1146         ver[i].versionValue = 0;
1147     }
1148     return ver;
1149 }
1150
1151 const char *yaz_srw_pack_to_str(int pack)
1152 {
1153     switch(pack)
1154     {
1155     case Z_SRW_recordPacking_string:
1156         return "string";
1157     case Z_SRW_recordPacking_XML:
1158         return "xml";
1159     case Z_SRW_recordPacking_URL:
1160         return "url";
1161     }
1162     return 0;
1163 }
1164
1165 int yaz_srw_str_to_pack(const char *str)
1166 {
1167     if (!yaz_matchstr(str, "string"))
1168         return Z_SRW_recordPacking_string;
1169     if (!yaz_matchstr(str, "xml"))
1170         return Z_SRW_recordPacking_XML;
1171     if (!yaz_matchstr(str, "url"))
1172         return Z_SRW_recordPacking_URL;
1173     return -1;
1174 }
1175
1176 void yaz_encode_sru_extra(Z_SRW_PDU *sr, ODR odr, const char *extra_args)
1177 {
1178     if (extra_args)
1179     {
1180         char **name;
1181         char **val;
1182         Z_SRW_extra_arg **ea = &sr->extra_args;
1183         yaz_uri_to_array(extra_args, odr, &name, &val);
1184
1185         /** append rather than override */
1186         while (*ea)
1187             ea = &(*ea)->next;
1188         while (*name)
1189         {
1190             *ea = (Z_SRW_extra_arg *) odr_malloc(odr, sizeof(**ea));
1191             (*ea)->name = *name;
1192             (*ea)->value = *val;
1193             ea = &(*ea)->next;
1194             val++;
1195             name++;
1196         }
1197         *ea = 0;
1198     }
1199 }
1200
1201
1202 /*
1203  * Local variables:
1204  * c-basic-offset: 4
1205  * c-file-style: "Stroustrup"
1206  * indent-tabs-mode: nil
1207  * End:
1208  * vim: shiftwidth=4 tabstop=8 expandtab
1209  */
1210