2 * Copyright (c) 2002-2003, Index Data.
3 * See the file LICENSE for details.
5 * $Id: srw.c,v 1.8 2003-12-30 00:12:50 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 xmlNodePtr 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);
42 xmlNodePtr add_xsd_string(xmlNodePtr ptr, const char *elem, char *val)
45 return xmlNewChild(ptr, 0, elem, val);
49 static void add_xsd_integer(xmlNodePtr ptr, const char *elem, int *val)
54 sprintf(str, "%d", *val);
55 xmlNewChild(ptr, 0, elem, str);
59 static int match_element(xmlNodePtr ptr, const char *elem)
61 if (ptr->type == XML_ELEMENT_NODE && !strcmp(ptr->name, elem))
68 static int match_xsd_string_n(xmlNodePtr ptr, const char *elem, ODR o,
72 struct _xmlAttr *attr;
74 if (!match_element(ptr, elem))
77 for (attr = ptr->properties; attr; attr = attr->next)
78 if (!strcmp(attr->name, "type") &&
79 attr->children && attr->children->type == XML_TEXT_NODE)
81 const char *t = strchr(attr->children->content, ':');
85 t = attr->children->content;
86 if (!strcmp(t, "string"))
93 if (!ptr || ptr->type != XML_TEXT_NODE)
95 *val = odr_strdup(o, ptr->content);
97 *len = strlen(ptr->content);
102 static int match_xsd_string(xmlNodePtr ptr, const char *elem, ODR o,
105 return match_xsd_string_n(ptr, elem, o, val, 0);
108 static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o,
109 char **val, int *len)
113 if (!match_element(ptr, elem))
118 buf = xmlBufferCreate();
120 xmlNodeDump(buf, ptr->doc, ptr, 0, 0);
122 *val = odr_malloc(o, buf->use+1);
123 memcpy (*val, buf->content, buf->use);
124 (*val)[buf->use] = '\0';
135 static int match_xsd_integer(xmlNodePtr ptr, const char *elem, ODR o, int **val)
138 struct _xmlAttr *attr;
140 if (!match_element(ptr, elem))
143 for (attr = ptr->properties; attr; attr = attr->next)
144 if (!strcmp(attr->name, "type") &&
145 attr->children && attr->children->type == XML_TEXT_NODE)
147 const char *t = strchr(attr->children->content, ':');
151 t = attr->children->content;
152 if (!strcmp(t, "integer"))
159 if (!ptr || ptr->type != XML_TEXT_NODE)
161 *val = odr_intdup(o, atoi(ptr->content));
165 static int yaz_srw_record(ODR o, xmlNodePtr pptr, Z_SRW_record *rec,
166 void *client_data, const char *ns)
168 if (o->direction == ODR_DECODE)
170 int pack = Z_SRW_recordPacking_string;
172 rec->recordSchema = 0;
173 rec->recordData_buf = 0;
174 rec->recordData_len = 0;
175 rec->recordPosition = 0;
176 for (ptr = pptr->children; ptr; ptr = ptr->next)
180 if (match_xsd_string(ptr, "recordSchema", o,
183 else if (match_xsd_string(ptr, "recordPacking", o, &spack))
185 if (pack && !strcmp(spack, "xml"))
186 pack = Z_SRW_recordPacking_XML;
187 if (pack && !strcmp(spack, "string"))
188 pack = Z_SRW_recordPacking_string;
190 else if (match_xsd_integer(ptr, "recordPosition", o,
191 &rec->recordPosition))
195 if (pack == Z_SRW_recordPacking_XML)
196 match_xsd_XML_n(ptr, "recordData", o,
197 &rec->recordData_buf,
198 &rec->recordData_len);
199 if (pack == Z_SRW_recordPacking_string)
200 match_xsd_string_n(ptr, "recordData", o,
201 &rec->recordData_buf,
202 &rec->recordData_len);
205 rec->recordPacking = pack;
207 else if (o->direction == ODR_ENCODE)
209 xmlNodePtr ptr = pptr;
210 add_xsd_string(ptr, "recordSchema", rec->recordSchema);
211 switch(rec->recordPacking)
213 case Z_SRW_recordPacking_string:
214 add_xsd_string(ptr, "recordPacking", "string");
215 add_xsd_string_n(ptr, "recordData", rec->recordData_buf,
216 rec->recordData_len);
218 case Z_SRW_recordPacking_XML:
219 add_xsd_string(ptr, "recordPacking", "xml");
220 add_XML_n(ptr, "recordData", rec->recordData_buf,
221 rec->recordData_len);
224 add_xsd_integer(ptr, "recordPosition", rec->recordPosition);
228 static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs,
229 int *num, void *client_data, const char *ns)
231 if (o->direction == ODR_DECODE)
236 for (ptr = pptr->children; ptr; ptr = ptr->next)
238 if (ptr->type == XML_ELEMENT_NODE &&
239 !strcmp(ptr->name, "record"))
244 *recs = odr_malloc(o, *num * sizeof(**recs));
245 for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++)
247 if (ptr->type == XML_ELEMENT_NODE &&
248 !strcmp(ptr->name, "record"))
249 yaz_srw_record(o, ptr, (*recs)+i, client_data, ns);
252 else if (o->direction == ODR_ENCODE)
255 for (i = 0; i < *num; i++)
257 xmlNodePtr rptr = xmlNewChild(pptr, 0, "record", 0);
258 yaz_srw_record(o, rptr, (*recs)+i, client_data, ns);
264 static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs,
265 int *num, void *client_data, const char *ns)
267 if (o->direction == ODR_DECODE)
272 for (ptr = pptr->children; ptr; ptr = ptr->next)
274 if (ptr->type == XML_ELEMENT_NODE &&
275 !strcmp(ptr->name, "diagnostic"))
280 *recs = odr_malloc(o, *num * sizeof(**recs));
281 for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++)
283 if (ptr->type == XML_ELEMENT_NODE &&
284 !strcmp(ptr->name, "diagnostic"))
288 (*recs)[i].details = 0;
289 for (rptr = ptr->children; rptr; rptr = rptr->next)
291 if (match_xsd_integer(rptr, "code", o,
294 else if (match_xsd_string(rptr, "details", o,
295 &(*recs)[i].details))
302 else if (o->direction == ODR_ENCODE)
306 xmlNewNs(pptr, "http://www.loc.gov/zing/srw/diagnostics/", "diag");
307 for (i = 0; i < *num; i++)
309 xmlNodePtr rptr = xmlNewChild(pptr, ns_diag, "diagnostic", 0);
310 add_xsd_integer(rptr, "code", (*recs)[i].code);
311 add_xsd_string(rptr, "details", (*recs)[i].details);
317 static int yaz_srw_term(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm *term,
318 void *client_data, const char *ns)
320 if (o->direction == ODR_DECODE)
324 term->numberOfRecords = 0;
325 term->displayTerm = 0;
326 for (ptr = pptr->children; ptr; ptr = ptr->next)
330 if (match_xsd_string(ptr, "value", o, &term->value))
332 else if (match_xsd_integer(ptr, "numberOfRecords", o,
333 &term->numberOfRecords))
335 else if (match_xsd_string(ptr, "displayTerm", o,
340 else if (o->direction == ODR_ENCODE)
342 xmlNodePtr ptr = pptr;
343 add_xsd_string(ptr, "value", term->value);
344 add_xsd_integer(ptr, "value", term->numberOfRecords);
345 add_xsd_string(ptr, "displayTerm", term->displayTerm);
349 static int yaz_srw_terms(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm **terms,
350 int *num, void *client_data, const char *ns)
352 if (o->direction == ODR_DECODE)
357 for (ptr = pptr->children; ptr; ptr = ptr->next)
359 if (ptr->type == XML_ELEMENT_NODE &&
360 !strcmp(ptr->name, "term"))
365 *terms = odr_malloc(o, *num * sizeof(**terms));
366 for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++)
368 if (ptr->type == XML_ELEMENT_NODE &&
369 !strcmp(ptr->name, "term"))
370 yaz_srw_term(o, ptr, (*terms)+i, client_data, ns);
373 else if (o->direction == ODR_ENCODE)
376 for (i = 0; i < *num; i++)
378 xmlNodePtr rptr = xmlNewChild(pptr, 0, "term", 0);
379 yaz_srw_term(o, rptr, (*terms)+i, client_data, ns);
385 int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
386 void *client_data, const char *ns)
388 xmlNodePtr pptr = vptr;
389 if (o->direction == ODR_DECODE)
391 Z_SRW_PDU **p = handler_data;
392 xmlNodePtr method = pptr->children;
394 while (method && method->type == XML_TEXT_NODE)
395 method = method->next;
399 if (method->type != XML_ELEMENT_NODE)
402 *p = odr_malloc(o, sizeof(**p));
403 (*p)->srw_version = odr_strdup(o, "1.1");
405 if (!strcmp(method->name, "searchRetrieveRequest"))
407 xmlNodePtr ptr = method->children;
408 Z_SRW_searchRetrieveRequest *req;
410 (*p)->which = Z_SRW_searchRetrieve_request;
411 req = (*p)->u.request = odr_malloc(o, sizeof(*req));
412 req->query_type = Z_SRW_query_type_cql;
414 req->sort_type = Z_SRW_sort_type_none;
416 req->startRecord = 0;
417 req->maximumRecords = 0;
418 req->recordSchema = 0;
419 req->recordPacking = 0;
420 req->recordXPath = 0;
421 req->resultSetTTL = 0;
425 for (; ptr; ptr = ptr->next)
427 if (match_xsd_string(ptr, "query", o,
429 req->query_type = Z_SRW_query_type_cql;
430 else if (match_xsd_string(ptr, "pQuery", o,
432 req->query_type = Z_SRW_query_type_pqf;
433 else if (match_xsd_string(ptr, "xQuery", o,
435 req->query_type = Z_SRW_query_type_xcql;
436 else if (match_xsd_string(ptr, "sortKeys", o,
437 &req->sort.sortKeys))
438 req->sort_type = Z_SRW_sort_type_sort;
439 else if (match_xsd_string(ptr, "recordSchema", o,
442 else if (match_xsd_string(ptr, "recordPacking", o,
443 &req->recordPacking))
445 else if (match_xsd_string(ptr, "recordXPath", o,
448 else if (match_xsd_integer(ptr, "startRecord", o,
451 else if (match_xsd_integer(ptr, "maximumRecords", o,
452 &req->maximumRecords))
454 else if (match_xsd_string(ptr, "stylesheet", o,
457 else if (match_xsd_string(ptr, "database", o,
460 else if (match_xsd_string(ptr, "resultSetTTL", o,
463 else if (match_xsd_string(ptr, "version", o,
466 /* missing is xQuery, xSortKeys .. */
469 else if (!strcmp(method->name, "searchRetrieveResponse"))
471 xmlNodePtr ptr = method->children;
472 Z_SRW_searchRetrieveResponse *res;
474 (*p)->which = Z_SRW_searchRetrieve_response;
475 res = (*p)->u.response = odr_malloc(o, sizeof(*res));
477 res->numberOfRecords = 0;
478 res->resultSetId = 0;
479 res->resultSetIdleTime = 0;
481 res->num_records = 0;
482 res->diagnostics = 0;
483 res->num_diagnostics = 0;
484 res->nextRecordPosition = 0;
486 for (; ptr; ptr = ptr->next)
488 if (match_xsd_integer(ptr, "numberOfRecords", o,
489 &res->numberOfRecords))
491 else if (match_xsd_string(ptr, "resultSetId", o,
494 else if (match_xsd_integer(ptr, "resultSetIdleTime", o,
495 &res->resultSetIdleTime))
497 else if (match_element(ptr, "records"))
498 yaz_srw_records(o, ptr, &res->records,
499 &res->num_records, client_data,
501 else if (match_element(ptr, "diagnostics"))
502 yaz_srw_diagnostics(o, ptr, &res->diagnostics,
503 &res->num_diagnostics,
505 else if (match_xsd_integer(ptr, "nextRecordPosition", o,
506 &res->nextRecordPosition))
508 else if (match_xsd_string(ptr, "version", o,
513 else if (!strcmp(method->name, "explainRequest"))
515 Z_SRW_explainRequest *req;
516 xmlNodePtr ptr = method->children;
518 (*p)->which = Z_SRW_explain_request;
519 req = (*p)->u.explain_request = odr_malloc(o, sizeof(*req));
520 req->recordPacking = 0;
522 for (; ptr; ptr = ptr->next)
524 if (match_xsd_string(ptr, "database", o,
527 else if (match_xsd_string(ptr, "recordPacking", o,
528 &req->recordPacking))
530 else if (match_xsd_string(ptr, "version", o,
535 else if (!strcmp(method->name, "explainResponse"))
537 Z_SRW_explainResponse *res;
538 xmlNodePtr ptr = method->children;
540 (*p)->which = Z_SRW_explain_response;
541 res = (*p)->u.explain_response = odr_malloc(o, sizeof(*res));
542 res->diagnostics = 0;
543 res->num_diagnostics = 0;
545 for (; ptr; ptr = ptr->next)
547 if (match_element(ptr, "record"))
548 yaz_srw_record(o, ptr, &res->record, client_data, ns);
549 else if (match_xsd_string(ptr, "version", o,
552 else if (match_element(ptr, "diagnostics"))
553 yaz_srw_diagnostics(o, ptr, &res->diagnostics,
554 &res->num_diagnostics,
559 else if (!strcmp(method->name, "scanRequest"))
561 Z_SRW_scanRequest *req;
562 xmlNodePtr ptr = method->children;
564 (*p)->which = Z_SRW_scan_request;
565 req = (*p)->u.scan_request = odr_malloc(o, sizeof(*req));
569 req->responsePosition = 0;
570 req->maximumTerms = 0;
572 for (; ptr; ptr = ptr->next)
574 if (match_xsd_string(ptr, "version", o,
577 else if (match_xsd_string(ptr, "scanClause", o,
580 else if (match_xsd_string(ptr, "database", o,
583 else if (match_xsd_string(ptr, "stylesheet", o,
586 else if (match_xsd_integer(ptr, "responsePosition", o,
587 &req->responsePosition))
589 else if (match_xsd_integer(ptr, "maximumTerms", o,
594 else if (!strcmp(method->name, "scanResponse"))
596 Z_SRW_scanResponse *res;
597 xmlNodePtr ptr = method->children;
599 (*p)->which = Z_SRW_scan_response;
600 res = (*p)->u.scan_response = odr_malloc(o, sizeof(*res));
603 res->diagnostics = 0;
604 res->num_diagnostics = 0;
606 for (; ptr; ptr = ptr->next)
608 if (match_element(ptr, "terms"))
609 yaz_srw_terms(o, ptr, &res->terms,
610 &res->num_terms, client_data,
612 else if (match_element(ptr, "diagnostics"))
613 yaz_srw_diagnostics(o, ptr, &res->diagnostics,
614 &res->num_diagnostics,
616 else if (match_xsd_string(ptr, "version", o,
627 else if (o->direction == ODR_ENCODE)
629 Z_SRW_PDU **p = handler_data;
632 if ((*p)->which == Z_SRW_searchRetrieve_request)
634 Z_SRW_searchRetrieveRequest *req = (*p)->u.request;
635 xmlNodePtr ptr = xmlNewChild(pptr, 0,
636 "searchRetrieveRequest", 0);
637 ns_srw = xmlNewNs(ptr, ns, "zs");
638 xmlSetNs(ptr, ns_srw);
640 if ((*p)->srw_version)
641 add_xsd_string(ptr, "version", (*p)->srw_version);
642 switch(req->query_type)
644 case Z_SRW_query_type_cql:
645 add_xsd_string(ptr, "query", req->query.cql);
647 case Z_SRW_query_type_xcql:
648 add_xsd_string(ptr, "xQuery", req->query.xcql);
650 case Z_SRW_query_type_pqf:
651 add_xsd_string(ptr, "pQuery", req->query.pqf);
654 switch(req->sort_type)
656 case Z_SRW_sort_type_none:
658 case Z_SRW_sort_type_sort:
659 add_xsd_string(ptr, "sortKeys", req->sort.sortKeys);
661 case Z_SRW_sort_type_xSort:
662 add_xsd_string(ptr, "xSortKeys", req->sort.xSortKeys);
665 add_xsd_integer(ptr, "startRecord", req->startRecord);
666 add_xsd_integer(ptr, "maximumRecords", req->maximumRecords);
667 add_xsd_string(ptr, "recordSchema", req->recordSchema);
668 add_xsd_string(ptr, "recordPacking", req->recordPacking);
669 add_xsd_string(ptr, "recordXPath", req->recordXPath);
670 add_xsd_string(ptr, "database", req->database);
671 add_xsd_integer(ptr, "resultSetTTL", req->resultSetTTL);
672 add_xsd_string(ptr, "stylesheet", req->stylesheet);
674 else if ((*p)->which == Z_SRW_searchRetrieve_response)
676 Z_SRW_searchRetrieveResponse *res = (*p)->u.response;
677 xmlNodePtr ptr = xmlNewChild(pptr, 0,
678 "searchRetrieveResponse", 0);
679 ns_srw = xmlNewNs(ptr, ns, "zs");
680 xmlSetNs(ptr, ns_srw);
682 if ((*p)->srw_version)
683 add_xsd_string(ptr, "version", (*p)->srw_version);
684 add_xsd_integer(ptr, "numberOfRecords", res->numberOfRecords);
685 add_xsd_string(ptr, "resultSetId", res->resultSetId);
686 add_xsd_integer(ptr, "resultSetIdleTime", res->resultSetIdleTime);
687 if (res->num_records)
689 xmlNodePtr rptr = xmlNewChild(ptr, 0, "records", 0);
690 yaz_srw_records(o, rptr, &res->records, &res->num_records,
693 if (res->num_diagnostics)
695 xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0);
696 yaz_srw_diagnostics(o, rptr, &res->diagnostics,
697 &res->num_diagnostics, client_data, ns);
699 add_xsd_integer(ptr, "nextRecordPosition", res->nextRecordPosition);
701 else if ((*p)->which == Z_SRW_explain_request)
703 xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainRequest", 0);
704 ns_srw = xmlNewNs(ptr, ns, "zs");
705 xmlSetNs(ptr, ns_srw);
707 add_xsd_string(ptr, "version", (*p)->srw_version);
709 else if ((*p)->which == Z_SRW_explain_response)
711 Z_SRW_explainResponse *res = (*p)->u.explain_response;
712 xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainResponse", 0);
713 ns_srw = xmlNewNs(ptr, ns, "zs");
714 xmlSetNs(ptr, ns_srw);
716 add_xsd_string(ptr, "version", (*p)->srw_version);
719 xmlNodePtr ptr1 = xmlNewChild(ptr, 0, "record", 0);
720 yaz_srw_record(o, ptr1, &res->record, client_data, ns);
722 if (res->num_diagnostics)
724 xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0);
725 yaz_srw_diagnostics(o, rptr, &res->diagnostics,
726 &res->num_diagnostics, client_data, ns);
729 else if ((*p)->which == Z_SRW_scan_request)
731 Z_SRW_scanRequest *req = (*p)->u.scan_request;
732 xmlNodePtr ptr = xmlNewChild(pptr, 0, "scanRequest", 0);
733 ns_srw = xmlNewNs(ptr, ns, "zs");
734 xmlSetNs(ptr, ns_srw);
736 add_xsd_string(ptr, "version", (*p)->srw_version);
737 add_xsd_string(ptr, "scanClause", req->scanClause);
738 add_xsd_integer(ptr, "responsePosition", req->responsePosition);
739 add_xsd_integer(ptr, "maximumTerms", req->maximumTerms);
740 add_xsd_string(ptr, "stylesheet", req->stylesheet);
742 else if ((*p)->which == Z_SRW_scan_response)
744 Z_SRW_scanResponse *res = (*p)->u.scan_response;
745 xmlNodePtr ptr = xmlNewChild(pptr, 0, "scanResponse", 0);
746 ns_srw = xmlNewNs(ptr, ns, "zs");
747 xmlSetNs(ptr, ns_srw);
749 add_xsd_string(ptr, "version", (*p)->srw_version);
753 xmlNodePtr rptr = xmlNewChild(ptr, 0, "terms", 0);
754 yaz_srw_terms(o, rptr, &res->terms, &res->num_terms,
757 if (res->num_diagnostics)
759 xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0);
760 yaz_srw_diagnostics(o, rptr, &res->diagnostics,
761 &res->num_diagnostics, client_data, ns);
771 Z_SRW_PDU *yaz_srw_get(ODR o, int which)
773 Z_SRW_PDU *sr = odr_malloc(o, sizeof(*o));
775 sr->srw_version = odr_strdup(o, "1.1");
779 case Z_SRW_searchRetrieve_request:
780 sr->u.request = (Z_SRW_searchRetrieveRequest *)
781 odr_malloc(o, sizeof(*sr->u.request));
782 sr->u.request->query_type = Z_SRW_query_type_cql;
783 sr->u.request->query.cql = 0;
784 sr->u.request->sort_type = Z_SRW_sort_type_none;
785 sr->u.request->sort.none = 0;
786 sr->u.request->startRecord = 0;
787 sr->u.request->maximumRecords = 0;
788 sr->u.request->recordSchema = 0;
789 sr->u.request->recordPacking = 0;
790 sr->u.request->recordXPath = 0;
791 sr->u.request->database = 0;
792 sr->u.request->resultSetTTL = 0;
793 sr->u.request->stylesheet = 0;
795 case Z_SRW_searchRetrieve_response:
796 sr->u.response = (Z_SRW_searchRetrieveResponse *)
797 odr_malloc(o, sizeof(*sr->u.response));
798 sr->u.response->numberOfRecords = 0;
799 sr->u.response->resultSetId = 0;
800 sr->u.response->resultSetIdleTime = 0;
801 sr->u.response->records = 0;
802 sr->u.response->num_records = 0;
803 sr->u.response->diagnostics = 0;
804 sr->u.response->num_diagnostics = 0;
805 sr->u.response->nextRecordPosition = 0;
807 case Z_SRW_explain_request:
808 sr->u.explain_request = (Z_SRW_explainRequest *)
809 odr_malloc(o, sizeof(*sr->u.explain_request));
810 sr->u.explain_request->recordPacking = 0;
811 sr->u.explain_request->database = 0;
813 case Z_SRW_explain_response:
814 sr->u.explain_response = (Z_SRW_explainResponse *)
815 odr_malloc(o, sizeof(*sr->u.explain_response));
816 sr->u.explain_response->record.recordData_buf = 0;
817 sr->u.explain_response->record.recordData_len = 0;
818 sr->u.explain_response->record.recordSchema = 0;
819 sr->u.explain_response->record.recordPosition = 0;
820 sr->u.explain_response->record.recordPacking =
821 Z_SRW_recordPacking_string;
822 sr->u.explain_response->diagnostics = 0;
823 sr->u.explain_response->num_diagnostics = 0;
834 } yaz_srw_codes [] = {
835 {1, "Permanent system error"},
836 {2, "System temporarily unavailable"},
837 {3, "Authentication error"},
838 /* Diagnostics Relating to CQL */
839 {10, "Illegal query"},
840 {11, "Unsupported query type (XCQL vs CQL)"},
841 {12, "Too many characters in query"},
842 {13, "Unbalanced or illegal use of parentheses"},
843 {14, "Unbalanced or illegal use of quotes"},
844 {15, "Illegal or unsupported context set"},
845 {16, "Illegal or unsupported index"},
846 {17, "Illegal or unsupported combination of index and context set"},
847 {18, "Illegal or unsupported combination of indexes"},
848 {19, "Illegal or unsupported relation"},
849 {20, "Illegal or unsupported relation modifier"},
850 {21, "Illegal or unsupported combination of relation modifers"},
851 {22, "Illegal or unsupported combination of relation and index"},
852 {23, "Too many characters in term"},
853 {24, "Illegal combination of relation and term"},
854 {25, "Special characters not quoted in term"},
855 {26, "Non special character escaped in term"},
856 {27, "Empty term unsupported"},
857 {28, "Masking character not supported"},
858 {29, "Masked words too short"},
859 {30, "Too many masking characters in term"},
860 {31, "Anchoring character not supported"},
861 {32, "Anchoring character in illegal or unsupported position"},
862 {33, "Combination of proximity/adjacency and masking characters not supported"},
863 {34, "Combination of proximity/adjacency and anchoring characters not supported"},
864 {35, "Terms only exclusion (stop) words"},
865 {36, "Term in invalid format for index or relation"},
866 {37, "Illegal or unsupported boolean operator"},
867 {38, "Too many boolean operators in query"},
868 {39, "Proximity not supported"},
869 {40, "Illegal or unsupported proximity relation"},
870 {41, "Illegal or unsupported proximity distance"},
871 {42, "Illegal or unsupported proximity unit"},
872 {43, "Illegal or unsupported proximity ordering"},
873 {44, "Illegal or unsupported combination of proximity modifiers"},
874 {45, "context set name (prefix) assigned to multiple identifiers"},
875 /* Diagnostics Relating to Result Sets */
876 {50, "Result sets not supported"},
877 {51, "Result set does not exist"},
878 {52, "Result set temporarily unavailable"},
879 {53, "Result sets only supported for retrieval"},
880 {54, "Retrieval may only occur from an existing result set"},
881 {55, "Combination of result sets with search terms not supported"},
882 {56, "Only combination of single result set with search terms supported"},
883 {57, "Result set created but no records available"},
884 {58, "Result set created with unpredictable partial results available"},
885 {59, "Result set created with valid partial results available"},
886 /* Diagnostics Relating to Records */
887 {60, "Too many records retrieved"},
888 {61, "First record position out of range"},
889 {62, "Negative number of records requested"},
890 {63, "System error in retrieving records"},
891 {64, "Record temporarily unavailable"},
892 {65, "Record does not exist"},
893 {66, "Unknown schema for retrieval"},
894 {67, "Record not available in this schema"},
895 {68, "Not authorised to send record"},
896 {69, "Not authorised to send record in this schema"},
897 {70, "Record too large to send"},
898 /* Diagnostics Relating to Sorting */
899 {80, "Sort not supported"},
900 {81, "Unsupported sort type (sortKeys vs xSortKeys)"},
901 {82, "Illegal or unsupported sort sequence"},
902 {83, "Too many records"},
903 {84, "Too many sort keys"},
904 {85, "Duplicate sort keys"},
905 {86, "Incompatible record formats"},
906 {87, "Unsupported schema for sort"},
907 {88, "Unsupported tag path for sort"},
908 {89, "Tag path illegal or unsupported for schema"},
909 {90, "Illegal or unsupported direction value"},
910 {91, "Illegal or unsupported case value"},
911 {92, "Illegal or unsupported missing value action"},
912 /* Diagnostics Relating to Explain */
913 {100, "Explain not supported"},
914 {101, "Explain request type not supported (SOAP vs GET)"},
915 {102, "Explain record temporarily unavailable"},
919 const char *yaz_diag_srw_str (int code)
922 for (i = 0; yaz_srw_codes[i].code; i++)
923 if (yaz_srw_codes[i].code == code)
924 return yaz_srw_codes[i].msg;
930 static int srw_bib1_map[] = {
959 24, 63, /* bad map */
960 25, 63, /* bad map */
961 26, 63, /* bad map */
969 100, 1, /* bad map */
1017 205, 1, /* bad map */
1018 206, 1, /* bad map */
1020 208, 1, /* bad map */
1031 218, 1, /* bad map */
1032 219, 1, /* bad map */
1033 220, 1, /* bad map */
1034 221, 1, /* bad map */
1035 222, 1, /* bad map */
1036 223, 1, /* bad map */
1037 224, 1, /* bad map */
1038 225, 1, /* bad map */
1039 226, 1, /* bad map */
1041 228, 1, /* bad map */
1046 233, 1, /* bad map */
1047 234, 1, /* bad map */
1053 240, 1, /* bad map */
1054 241, 1, /* bad map */
1056 243, 1, /* bad map */
1061 1001, 1, /* bad map */
1062 1002, 1, /* bad map */
1063 1003, 1, /* bad map */
1064 1004, 1, /* bad map */
1065 1005, 1, /* bad map */
1066 1006, 1, /* bad map */
1098 int yaz_diag_bib1_to_srw (int code)
1100 const int *p = srw_bib1_map;
1110 int yaz_diag_srw_to_bib1(int code)
1112 const int *p = srw_bib1_map;