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