2 * Copyright (c) 2002-2003, Index Data.
3 * See the file LICENSE for details.
5 * $Id: srw.c,v 1.13 2003-04-17 19:43:32 adam Exp $
11 #include <libxml/parser.h>
12 #include <libxml/tree.h>
14 static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len)
18 xmlDocPtr doc = xmlParseMemory(val,len);
21 xmlNodePtr c = xmlNewChild(ptr, 0, elem, 0);
22 xmlNodePtr t = xmlDocGetRootElement(doc);
23 xmlAddChild(c, xmlCopyNode(t,1));
29 static void add_xsd_string_n(xmlNodePtr ptr, const char *elem, char *val,
34 xmlNodePtr c = xmlNewChild(ptr, 0, elem, 0);
35 xmlNodePtr t = xmlNewTextLen(val, len);
40 static void add_xsd_string(xmlNodePtr ptr, const char *elem, char *val)
43 xmlNewChild(ptr, 0, elem, val);
46 static void add_xsd_integer(xmlNodePtr ptr, const char *elem, int *val)
51 sprintf(str, "%d", *val);
52 xmlNewChild(ptr, 0, elem, str);
56 static int match_element(xmlNodePtr ptr, const char *elem)
58 if (ptr->type == XML_ELEMENT_NODE && !strcmp(ptr->name, elem))
65 static int match_xsd_string_n(xmlNodePtr ptr, const char *elem, ODR o,
69 struct _xmlAttr *attr;
71 if (!match_element(ptr, elem))
74 for (attr = ptr->properties; attr; attr = attr->next)
75 if (!strcmp(attr->name, "type") &&
76 attr->children && attr->children->type == XML_TEXT_NODE)
78 const char *t = strchr(attr->children->content, ':');
82 t = attr->children->content;
83 if (!strcmp(t, "string"))
90 if (!ptr || ptr->type != XML_TEXT_NODE)
92 *val = odr_strdup(o, ptr->content);
94 *len = strlen(ptr->content);
99 static int match_xsd_string(xmlNodePtr ptr, const char *elem, ODR o,
102 return match_xsd_string_n(ptr, elem, o, val, 0);
105 static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o,
106 char **val, int *len)
110 if (!match_element(ptr, elem))
112 printf ("match_xsd_XML_n: %s\n", elem);
116 printf ("match_xsd_XML: no TEXT node\n");
119 buf = xmlBufferCreate();
121 xmlNodeDump(buf, ptr->doc, ptr, 0, 0);
123 *val = odr_malloc(o, buf->use+1);
124 memcpy (*val, buf->content, buf->use);
125 (*val)[buf->use] = '\0';
132 printf ("match_XML_string: OK content=%s\n", *val);
137 static int match_xsd_integer(xmlNodePtr ptr, const char *elem, ODR o, int **val)
140 struct _xmlAttr *attr;
142 if (!match_element(ptr, elem))
145 for (attr = ptr->properties; attr; attr = attr->next)
146 if (!strcmp(attr->name, "type") &&
147 attr->children && attr->children->type == XML_TEXT_NODE)
149 const char *t = strchr(attr->children->content, ':');
153 t = attr->children->content;
154 if (!strcmp(t, "integer"))
161 if (!ptr || ptr->type != XML_TEXT_NODE)
163 *val = odr_intdup(o, atoi(ptr->content));
167 static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs,
168 int *num, void *client_data, const char *ns)
170 if (o->direction == ODR_DECODE)
175 for (ptr = pptr->children; ptr; ptr = ptr->next)
177 if (ptr->type == XML_ELEMENT_NODE &&
178 !strcmp(ptr->name, "record"))
183 *recs = odr_malloc(o, *num * sizeof(**recs));
184 for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++)
186 if (ptr->type == XML_ELEMENT_NODE &&
187 !strcmp(ptr->name, "record"))
190 (*recs)[i].recordSchema = 0;
191 (*recs)[i].recordPacking = Z_SRW_recordPacking_string;
192 (*recs)[i].recordData_buf = 0;
193 (*recs)[i].recordData_len = 0;
194 (*recs)[i].recordPosition = 0;
195 for (rptr = ptr->children; rptr; rptr = rptr->next)
197 if (match_xsd_string(rptr, "recordSchema", o,
198 &(*recs)[i].recordSchema))
200 else if (match_xsd_string_n(rptr, "recordData", o,
201 &(*recs)[i].recordData_buf,
202 &(*recs)[i].recordData_len))
204 else if (match_xsd_XML_n(rptr, "recordXML", o,
205 &(*recs)[i].recordData_buf,
206 &(*recs)[i].recordData_len))
207 (*recs)[i].recordPacking = Z_SRW_recordPacking_XML;
208 else if (match_xsd_integer(rptr, "recordPosition", o,
209 &(*recs)[i].recordPosition))
215 else if (o->direction == ODR_ENCODE)
218 for (i = 0; i < *num; i++)
220 xmlNodePtr rptr = xmlNewChild(pptr, 0, "record", 0);
221 add_xsd_string(rptr, "recordSchema", (*recs)[i].recordSchema);
222 switch((*recs)[i].recordPacking)
224 case Z_SRW_recordPacking_string:
225 add_xsd_string_n(rptr, "recordData", (*recs)[i].recordData_buf,
226 (*recs)[i].recordData_len);
228 case Z_SRW_recordPacking_XML:
229 add_XML_n(rptr, "recordXML", (*recs)[i].recordData_buf,
230 (*recs)[i].recordData_len);
233 add_xsd_integer(rptr, "recordPosition", (*recs)[i].recordPosition);
239 static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs,
240 int *num, void *client_data, const char *ns)
242 if (o->direction == ODR_DECODE)
247 for (ptr = pptr->children; ptr; ptr = ptr->next)
249 if (ptr->type == XML_ELEMENT_NODE &&
250 !strcmp(ptr->name, "diagnostic"))
255 *recs = odr_malloc(o, *num * sizeof(**recs));
256 for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++)
258 if (ptr->type == XML_ELEMENT_NODE &&
259 !strcmp(ptr->name, "diagnostic"))
263 (*recs)[i].details = 0;
264 for (rptr = ptr->children; rptr; rptr = rptr->next)
266 if (match_xsd_integer(rptr, "code", o,
269 else if (match_xsd_string(rptr, "details", o,
270 &(*recs)[i].details))
277 else if (o->direction == ODR_ENCODE)
280 for (i = 0; i < *num; i++)
282 xmlNodePtr rptr = xmlNewChild(pptr, 0, "diagnostic", 0);
283 add_xsd_integer(rptr, "code", (*recs)[i].code);
284 add_xsd_string(rptr, "details", (*recs)[i].details);
291 int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
292 void *client_data, const char *ns)
294 xmlNodePtr pptr = vptr;
295 if (o->direction == ODR_DECODE)
297 xmlNodePtr method = pptr->children;
299 while (method && method->type == XML_TEXT_NODE)
300 method = method->next;
302 if (!method || method->type != XML_ELEMENT_NODE)
304 if (!strcmp(method->name, "searchRetrieveRequest"))
306 Z_SRW_PDU **p = handler_data;
307 xmlNodePtr ptr = method->children;
308 Z_SRW_searchRetrieveRequest *req;
310 *p = odr_malloc(o, sizeof(**p));
311 (*p)->which = Z_SRW_searchRetrieve_request;
312 req = (*p)->u.request = odr_malloc(o, sizeof(*req));
313 req->query_type = Z_SRW_query_type_cql;
315 req->sort_type = Z_SRW_sort_type_none;
317 req->startRecord = 0;
318 req->maximumRecords = 0;
319 req->recordSchema = 0;
320 req->recordPacking = 0;
323 for (; ptr; ptr = ptr->next)
325 if (match_xsd_string(ptr, "query", o,
327 req->query_type = Z_SRW_query_type_cql;
328 else if (match_xsd_string(ptr, "pQuery", o,
330 req->query_type = Z_SRW_query_type_pqf;
331 else if (match_xsd_string(ptr, "xQuery", o,
333 req->query_type = Z_SRW_query_type_xcql;
334 else if (match_xsd_string(ptr, "sortKeys", o,
335 &req->sort.sortKeys))
336 req->sort_type = Z_SRW_sort_type_sort;
337 else if (match_xsd_string(ptr, "recordSchema", o,
340 else if (match_xsd_string(ptr, "recordPacking", o,
341 &req->recordPacking))
343 else if (match_xsd_integer(ptr, "startRecord", o,
346 else if (match_xsd_integer(ptr, "maximumRecords", o,
347 &req->maximumRecords))
349 else if (match_xsd_string(ptr, "database", o,
352 /* missing is xQuery, xSortKeys .. */
355 else if (!strcmp(method->name, "searchRetrieveResponse"))
357 Z_SRW_PDU **p = handler_data;
358 xmlNodePtr ptr = method->children;
359 Z_SRW_searchRetrieveResponse *res;
361 *p = odr_malloc(o, sizeof(**p));
362 (*p)->which = Z_SRW_searchRetrieve_response;
363 res = (*p)->u.response = odr_malloc(o, sizeof(*res));
365 res->numberOfRecords = 0;
366 res->resultSetId = 0;
367 res->resultSetIdleTime = 0;
369 res->num_records = 0;
370 res->diagnostics = 0;
371 res->num_diagnostics = 0;
372 res->nextRecordPosition = 0;
374 for (; ptr; ptr = ptr->next)
376 if (match_xsd_integer(ptr, "numberOfRecords", o,
377 &res->numberOfRecords))
379 else if (match_xsd_string(ptr, "resultSetId", o,
382 else if (match_xsd_integer(ptr, "resultSetIdleTime", o,
383 &res->resultSetIdleTime))
385 else if (match_element(ptr, "records"))
386 yaz_srw_records(o, ptr, &res->records,
387 &res->num_records, client_data,
389 else if (match_element(ptr, "diagnostics"))
390 yaz_srw_diagnostics(o, ptr, &res->diagnostics,
391 &res->num_diagnostics,
393 else if (match_xsd_integer(ptr, "nextRecordPosition", o,
394 &res->nextRecordPosition))
398 else if (!strcmp(method->name, "explainRequest"))
400 Z_SRW_PDU **p = handler_data;
401 Z_SRW_explainRequest *req;
403 *p = odr_malloc(o, sizeof(**p));
404 (*p)->which = Z_SRW_explain_request;
405 req = (*p)->u.explain_request = odr_malloc(o, sizeof(*req));
408 else if (!strcmp(method->name, "explainResponse"))
410 Z_SRW_PDU **p = handler_data;
411 Z_SRW_explainResponse *res;
412 xmlNodePtr ptr = method->children;
414 *p = odr_malloc(o, sizeof(**p));
415 (*p)->which = Z_SRW_explain_response;
416 res = (*p)->u.explain_response = odr_malloc(o, sizeof(*res));
417 res->explainData_buf = 0;
418 res->explainData_len = 0;
419 res->explainPacking = Z_SRW_recordPacking_string;
420 for (; ptr; ptr = ptr->next)
422 match_xsd_string_n(ptr, "Explain", o,
423 &res->explainData_buf,
424 &res->explainData_len);
431 else if (o->direction == ODR_ENCODE)
433 Z_SRW_PDU **p = handler_data;
434 if ((*p)->which == Z_SRW_searchRetrieve_request)
436 Z_SRW_searchRetrieveRequest *req = (*p)->u.request;
437 xmlNodePtr ptr = xmlNewChild(pptr, 0,
438 "searchRetrieveRequest", 0);
439 xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs");
441 xmlSetNs(ptr, ns_srw);
443 switch(req->query_type)
445 case Z_SRW_query_type_cql:
446 add_xsd_string(ptr, "query", req->query.cql);
448 case Z_SRW_query_type_xcql:
449 add_xsd_string(ptr, "xQuery", req->query.xcql);
451 case Z_SRW_query_type_pqf:
452 add_xsd_string(ptr, "pQuery", req->query.pqf);
455 switch(req->sort_type)
457 case Z_SRW_sort_type_none:
459 case Z_SRW_sort_type_sort:
460 add_xsd_string(ptr, "sortKeys", req->sort.sortKeys);
462 case Z_SRW_sort_type_xSort:
463 add_xsd_string(ptr, "xSortKeys", req->sort.xSortKeys);
466 add_xsd_integer(ptr, "startRecord", req->startRecord);
467 add_xsd_integer(ptr, "maximumRecords", req->maximumRecords);
468 add_xsd_string(ptr, "recordSchema", req->recordSchema);
469 add_xsd_string(ptr, "recordPacking", req->recordPacking);
470 add_xsd_string(ptr, "database", req->database);
472 else if ((*p)->which == Z_SRW_searchRetrieve_response)
474 Z_SRW_searchRetrieveResponse *res = (*p)->u.response;
475 xmlNodePtr ptr = xmlNewChild(pptr, 0,
476 "searchRetrieveResponse", 0);
477 xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs");
479 xmlSetNs(ptr, ns_srw);
480 add_xsd_integer(ptr, "numberOfRecords", res->numberOfRecords);
481 add_xsd_string(ptr, "resultSetId", res->resultSetId);
482 add_xsd_integer(ptr, "resultSetIdleTime", res->resultSetIdleTime);
483 if (res->num_records)
485 xmlNodePtr rptr = xmlNewChild(ptr, 0, "records", 0);
486 yaz_srw_records(o, rptr, &res->records, &res->num_records,
489 if (res->num_diagnostics)
491 xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0);
492 yaz_srw_diagnostics(o, rptr, &res->diagnostics,
493 &res->num_diagnostics, client_data, ns);
495 add_xsd_integer(ptr, "nextRecordPosition", res->nextRecordPosition);
497 else if ((*p)->which == Z_SRW_explain_request)
499 Z_SRW_explainRequest *req = (*p)->u.explain_request;
500 xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainRequest", 0);
501 xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs");
503 xmlSetNs(ptr, ns_srw);
505 else if ((*p)->which == Z_SRW_explain_response)
507 Z_SRW_explainResponse *res = (*p)->u.explain_response;
508 xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainResponse", 0);
509 xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs");
511 xmlSetNs(ptr, ns_srw);
513 add_xsd_string_n(ptr, "Explain", res->explainData_buf,
514 res->explainData_len);
523 Z_SRW_PDU *yaz_srw_get(ODR o, int which)
525 Z_SRW_PDU *sr = odr_malloc(o, sizeof(*o));
529 case Z_SRW_searchRetrieve_request:
530 sr->u.request = (Z_SRW_searchRetrieveRequest *)
531 odr_malloc(o, sizeof(*sr->u.request));
532 sr->u.request->query_type = Z_SRW_query_type_cql;
533 sr->u.request->query.cql = 0;
534 sr->u.request->sort_type = Z_SRW_sort_type_none;
535 sr->u.request->sort.none = 0;
536 sr->u.request->startRecord = 0;
537 sr->u.request->maximumRecords = 0;
538 sr->u.request->recordSchema = 0;
539 sr->u.request->recordPacking = 0;
540 sr->u.request->database = 0;
542 case Z_SRW_searchRetrieve_response:
543 sr->u.response = (Z_SRW_searchRetrieveResponse *)
544 odr_malloc(o, sizeof(*sr->u.response));
545 sr->u.response->numberOfRecords = 0;
546 sr->u.response->resultSetId = 0;
547 sr->u.response->resultSetIdleTime = 0;
548 sr->u.response->records = 0;
549 sr->u.response->num_records = 0;
550 sr->u.response->diagnostics = 0;
551 sr->u.response->num_diagnostics = 0;
552 sr->u.response->nextRecordPosition = 0;
554 case Z_SRW_explain_request:
555 sr->u.explain_request = (Z_SRW_explainRequest *)
556 odr_malloc(o, sizeof(*sr->u.explain_request));
557 sr->u.explain_request->dummy = 0;
559 case Z_SRW_explain_response:
560 sr->u.explain_response = (Z_SRW_explainResponse *)
561 odr_malloc(o, sizeof(*sr->u.explain_response));
562 sr->u.explain_response->explainPacking = 0;
563 sr->u.explain_response->explainData_buf = 0;
564 sr->u.explain_response->explainData_len = 0;
575 } yaz_srw_codes [] = {
576 {1, "Permanent system error"},
577 {2, "System temporarily unavailable"},
578 {3, "Authentication error"},
579 /* Diagnostics Relating to CQL */
580 {10, "Illegal query"},
581 {11, "Unsupported query type (XCQL vs CQL)"},
582 {12, "Too many characters in query"},
583 {13, "Unbalanced or illegal use of parentheses"},
584 {14, "Unbalanced or illegal use of quotes"},
585 {15, "Illegal or unsupported index set"},
586 {16, "Illegal or unsupported index"},
587 {17, "Illegal or unsupported combination of index and index set"},
588 {18, "Illegal or unsupported combination of indexes"},
589 {19, "Illegal or unsupported relation"},
590 {20, "Illegal or unsupported relation modifier"},
591 {21, "Illegal or unsupported combination of relation modifers"},
592 {22, "Illegal or unsupported combination of relation and index"},
593 {23, "Too many characters in term"},
594 {24, "Illegal combination of relation and term"},
595 {25, "Special characters not quoted in term"},
596 {26, "Non special character escaped in term"},
597 {27, "Empty term unsupported"},
598 {28, "Masking character not supported"},
599 {29, "Masked words too short"},
600 {30, "Too many masking characters in term"},
601 {31, "Anchoring character not supported"},
602 {32, "Anchoring character in illegal or unsupported position"},
603 {33, "Combination of proximity/adjacency and masking characters not supported"},
604 {34, "Combination of proximity/adjacency and anchoring characters not supported"},
605 {35, "Terms only exclusion (stop) words"},
606 {36, "Term in invalid format for index or relation"},
607 {37, "Illegal or unsupported boolean operator"},
608 {38, "Too many boolean operators in query"},
609 {39, "Proximity not supported"},
610 {40, "Illegal or unsupported proximity relation"},
611 {41, "Illegal or unsupported proximity distance"},
612 {42, "Illegal or unsupported proximity unit"},
613 {43, "Illegal or unsupported proximity ordering"},
614 {44, "Illegal or unsupported combination of proximity modifiers"},
615 {45, "Index set name (prefix) assigned to multiple identifiers"},
616 /* Diagnostics Relating to Result Sets */
617 {50, "Result sets not supported"},
618 {51, "Result set does not exist"},
619 {52, "Result set temporarily unavailable"},
620 {53, "Result sets only supported for retrieval"},
621 {54, "Retrieval may only occur from an existing result set"},
622 {55, "Combination of result sets with search terms not supported"},
623 {56, "Only combination of single result set with search terms supported"},
624 {57, "Result set created but no records available"},
625 {58, "Result set created with unpredictable partial results available"},
626 {59, "Result set created with valid partial results available"},
627 /* Diagnostics Relating to Records */
628 {60, "Too many records retrieved"},
629 {61, "First record position out of range"},
630 {62, "Negative number of records requested"},
631 {63, "System error in retrieving records"},
632 {64, "Record temporarily unavailable"},
633 {65, "Record does not exist"},
634 {66, "Unknown schema for retrieval"},
635 {67, "Record not available in this schema"},
636 {68, "Not authorised to send record"},
637 {69, "Not authorised to send record in this schema"},
638 {70, "Record too large to send"},
639 /* Diagnostics Relating to Sorting */
640 {80, "Sort not supported"},
641 {81, "Unsupported sort type (sortKeys vs xSortKeys)"},
642 {82, "Illegal or unsupported sort sequence"},
643 {83, "Too many records"},
644 {84, "Too many sort keys"},
645 {85, "Duplicate sort keys"},
646 {86, "Incompatible record formats"},
647 {87, "Unsupported schema for sort"},
648 {88, "Unsupported tag path for sort"},
649 {89, "Tag path illegal or unsupported for schema"},
650 {90, "Illegal or unsupported direction value"},
651 {91, "Illegal or unsupported case value"},
652 {92, "Illegal or unsupported missing value action"},
653 /* Diagnostics Relating to Explain */
654 {100, "Explain not supported"},
655 {101, "Explain request type not supported (SOAP vs GET)"},
656 {102, "Explain record temporarily unavailable"},
660 const char *yaz_diag_srw_str (int code)
663 for (i = 0; yaz_srw_codes[i].code; i++)
664 if (yaz_srw_codes[i].code == code)
665 return yaz_srw_codes[i].msg;
671 static int srw_bib1_map[] = {
700 24, 63, /* bad map */
701 25, 63, /* bad map */
702 26, 63, /* bad map */
710 100, 1, /* bad map */
758 205, 1, /* bad map */
759 206, 1, /* bad map */
761 208, 1, /* bad map */
772 218, 1, /* bad map */
773 219, 1, /* bad map */
774 220, 1, /* bad map */
775 221, 1, /* bad map */
776 222, 1, /* bad map */
777 223, 1, /* bad map */
778 224, 1, /* bad map */
779 225, 1, /* bad map */
780 226, 1, /* bad map */
782 228, 1, /* bad map */
787 233, 1, /* bad map */
788 234, 1, /* bad map */
794 240, 1, /* bad map */
795 241, 1, /* bad map */
797 243, 1, /* bad map */
802 1001, 1, /* bad map */
803 1002, 1, /* bad map */
804 1003, 1, /* bad map */
805 1004, 1, /* bad map */
806 1005, 1, /* bad map */
807 1006, 1, /* bad map */
839 int yaz_diag_bib1_to_srw (int code)
841 const int *p = srw_bib1_map;
851 int yaz_diag_srw_to_bib1(int code)
853 const int *p = srw_bib1_map;