X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fsrw.c;h=7f0cd29aac4ebc7193c605b159b961c2ec82274f;hp=2405c4c0fbfb5834c8ac5a4db98447ccd4fab04a;hb=d2ed898832ae354c17254ff52c70c92278518efe;hpb=0698a93c2bb1b8e7fa7a63d906bb863ffdac40e9 diff --git a/src/srw.c b/src/srw.c index 2405c4c..7f0cd29 100644 --- a/src/srw.c +++ b/src/srw.c @@ -1,24 +1,35 @@ -/* - * Copyright (c) 2002-2003, Index Data. +/* This file is part of the YAZ toolkit. + * Copyright (C) 1995-2013 Index Data * See the file LICENSE for details. - * - * $Id: srw.c,v 1.2 2003-12-18 17:05:20 mike Exp $ */ +/** + * \file srw.c + * \brief Implements SRW/SRU package encoding and decoding + */ +#if HAVE_CONFIG_H +#include +#endif -#include +#include -#if HAVE_XML2 +#include +#include +#if YAZ_HAVE_XML2 #include #include +#include +#include +#include "sru-p.h" -static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len) +static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len, + xmlNsPtr ns_ptr) { if (val) { xmlDocPtr doc = xmlParseMemory(val,len); if (doc) { - xmlNodePtr c = xmlNewChild(ptr, 0, elem, 0); + xmlNodePtr c = xmlNewChild(ptr, ns_ptr, BAD_CAST elem, 0); xmlNodePtr t = xmlDocGetRootElement(doc); xmlAddChild(c, xmlCopyNode(t,1)); xmlFreeDoc(doc); @@ -26,37 +37,54 @@ static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len) } } -static void add_xsd_string_n(xmlNodePtr ptr, const char *elem, char *val, - int len) +xmlNodePtr add_xsd_string_n(xmlNodePtr ptr, const char *elem, const char *val, + int len) { if (val) { - xmlNodePtr c = xmlNewChild(ptr, 0, elem, 0); - xmlNodePtr t = xmlNewTextLen(val, len); + xmlNodePtr c = xmlNewChild(ptr, 0, BAD_CAST elem, 0); + xmlNodePtr t = xmlNewTextLen(BAD_CAST val, len); xmlAddChild(c, t); + return t; } + return 0; } -static void add_xsd_string(xmlNodePtr ptr, const char *elem, char *val) +xmlNodePtr add_xsd_string_ns(xmlNodePtr ptr, const char *elem, const char *val, + xmlNsPtr ns_ptr) { if (val) - xmlNewChild(ptr, 0, elem, val); + { + xmlNodePtr c = xmlNewChild(ptr, ns_ptr, BAD_CAST elem, 0); + xmlNodePtr t = xmlNewText(BAD_CAST val); + xmlAddChild(c, t); + return t; + } + return 0; } -static void add_xsd_integer(xmlNodePtr ptr, const char *elem, int *val) +xmlNodePtr add_xsd_string(xmlNodePtr ptr, const char *elem, const char *val) +{ + return add_xsd_string_ns(ptr, elem, val, 0); +} + +void add_xsd_integer(xmlNodePtr ptr, const char *elem, + const Odr_int *val) { if (val) { - char str[30]; - sprintf(str, "%d", *val); - xmlNewChild(ptr, 0, elem, str); + char str[40]; + sprintf(str, ODR_INT_PRINTF, *val); + xmlNewTextChild(ptr, 0, BAD_CAST elem, BAD_CAST str); } } static int match_element(xmlNodePtr ptr, const char *elem) { - if (ptr->type == XML_ELEMENT_NODE && !strcmp(ptr->name, elem)) + if (ptr->type == XML_ELEMENT_NODE && !xmlStrcmp(ptr->name, BAD_CAST elem)) + { return 1; + } return 0; } @@ -88,10 +116,13 @@ static int match_xsd_string_n(xmlNodePtr ptr, const char *elem, ODR o, #endif ptr = ptr->children; if (!ptr || ptr->type != XML_TEXT_NODE) - return 0; - *val = odr_strdup(o, ptr->content); + { + *val = ""; + return 1; + } + *val = odr_strdup(o, (const char *) ptr->content); if (len) - *len = strlen(ptr->content); + *len = xmlStrlen(ptr->content); return 1; } @@ -102,22 +133,43 @@ static int match_xsd_string(xmlNodePtr ptr, const char *elem, ODR o, return match_xsd_string_n(ptr, elem, o, val, 0); } -static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o, - char **val, int *len) +static int match_xsd_XML_n2(xmlNodePtr ptr, const char *elem, ODR o, + char **val, int *len, int fixup_root) { xmlBufferPtr buf; + int no_root_nodes = 0; if (!match_element(ptr, elem)) return 0; - ptr = ptr->children; - if (!ptr) - return 0; + buf = xmlBufferCreate(); - xmlNodeDump(buf, ptr->doc, ptr, 0, 0); + /* Copy each element nodes at top. + In most cases there is only one root node.. At least one server + http://www.theeuropeanlibrary.org/sru/sru.pl + has multiple root nodes in recordData. + */ + for (ptr = ptr->children; ptr; ptr = ptr->next) + { + if (ptr->type == XML_ELEMENT_NODE) + { + /* copy node to get NS right (bug #740). */ + xmlNode *tmp = xmlCopyNode(ptr, 1); + + xmlNodeDump(buf, tmp->doc, tmp, 0, 0); - *val = odr_malloc(o, buf->use+1); - memcpy (*val, buf->content, buf->use); + xmlFreeNode(tmp); + no_root_nodes++; + } + } + if (no_root_nodes != 1 && fixup_root) + { + /* does not appear to be an XML document. Make it so */ + xmlBufferAddHead(buf, (const xmlChar *) "", -1); + xmlBufferAdd(buf, (const xmlChar *) "", -1); + } + *val = (char *) odr_malloc(o, buf->use + 1); + memcpy(*val, buf->content, buf->use); (*val)[buf->use] = '\0'; if (len) @@ -128,8 +180,14 @@ static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o, return 1; } - -static int match_xsd_integer(xmlNodePtr ptr, const char *elem, ODR o, int **val) +static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o, + char **val, int *len) +{ + return match_xsd_XML_n2(ptr, elem, o, val, len, 0); +} + +static int match_xsd_integer(xmlNodePtr ptr, const char *elem, ODR o, + Odr_int **val) { #if CHECK_TYPE struct _xmlAttr *attr; @@ -155,12 +213,144 @@ static int match_xsd_integer(xmlNodePtr ptr, const char *elem, ODR o, int **val) ptr = ptr->children; if (!ptr || ptr->type != XML_TEXT_NODE) return 0; - *val = odr_intdup(o, atoi(ptr->content)); + *val = odr_intdup(o, odr_atoi((const char *) ptr->content)); return 1; } +char *yaz_negotiate_sru_version(char *input_ver) +{ + if (!input_ver) + return "2.0"; + if (!strcmp(input_ver, "1.1")) + return "1.1"; + if (!strncmp(input_ver, "1.", 2)) + return "1.2"; + if (!strncmp(input_ver, "2.", 2)) + return "2.0"; + return 0; +} + +static int yaz_srw_record(ODR o, xmlNodePtr pptr, Z_SRW_record *rec, + Z_SRW_extra_record **extra, + void *client_data, int version2) +{ + if (o->direction == ODR_DECODE) + { + Z_SRW_extra_record ex; + + char *spack = 0; + xmlNodePtr ptr; +#ifdef Z_SRW_packed + rec->packing = 0; +#endif + rec->recordSchema = 0; + rec->recordData_buf = 0; + rec->recordData_len = 0; + rec->recordPosition = 0; + *extra = 0; + + ex.extraRecordData_buf = 0; + ex.extraRecordData_len = 0; + ex.recordIdentifier = 0; + + for (ptr = pptr->children; ptr; ptr = ptr->next) + { + + if (match_xsd_string(ptr, "recordSchema", o, + &rec->recordSchema)) + ; + else if (match_xsd_string(ptr, "recordPacking", o, &spack)) + ; /* can't rely on it: in SRU 2.0 it's different semantics */ + else if (match_xsd_integer(ptr, "recordPosition", o, + &rec->recordPosition)) + ; + else if (match_element(ptr, "recordData")) + { + /* we assume XML packing, if any element nodes exist below + recordData. Unfortunately, in SRU 2.0 recordPacking + means something different */ + xmlNode *p = ptr->children; + for (; p; p = p->next) + if (p->type == XML_ELEMENT_NODE) + break; + if (p) + { + match_xsd_XML_n2( + ptr, "recordData", o, + &rec->recordData_buf, &rec->recordData_len, 1); + rec->recordPacking = Z_SRW_recordPacking_XML; + } + else + { + match_xsd_string_n( + ptr, "recordData", o, + &rec->recordData_buf, &rec->recordData_len); + rec->recordPacking = Z_SRW_recordPacking_string; + } + } + else if (match_xsd_XML_n(ptr, "extraRecordData", o, + &ex.extraRecordData_buf, + &ex.extraRecordData_len) ) + ; + else + match_xsd_string(ptr, "recordIdentifier", o, + &ex.recordIdentifier); + } + if (ex.extraRecordData_buf || ex.recordIdentifier) + { + *extra = (Z_SRW_extra_record *) + odr_malloc(o, sizeof(Z_SRW_extra_record)); + memcpy(*extra, &ex, sizeof(Z_SRW_extra_record)); + } + } + else if (o->direction == ODR_ENCODE) + { + xmlNodePtr ptr = pptr; + int pack = rec->recordPacking; + const char *spack = yaz_srw_pack_to_str(pack); + + add_xsd_string(ptr, "recordSchema", rec->recordSchema); + if (spack) + { + if (version2) + add_xsd_string(ptr, "recordXMLEscaping", spack); + else + add_xsd_string(ptr, "recordPacking", spack); + } + switch (pack) + { + case Z_SRW_recordPacking_string: + add_xsd_string_n(ptr, "recordData", rec->recordData_buf, + rec->recordData_len); + break; + case Z_SRW_recordPacking_XML: + add_XML_n(ptr, "recordData", rec->recordData_buf, + rec->recordData_len, 0); + break; + case Z_SRW_recordPacking_URL: + add_xsd_string_n(ptr, "recordData", rec->recordData_buf, + rec->recordData_len); + break; + } + if (rec->recordPosition) + add_xsd_integer(ptr, "recordPosition", rec->recordPosition ); + if (extra && *extra) + { + if ((*extra)->recordIdentifier) + add_xsd_string(ptr, "recordIdentifier", + (*extra)->recordIdentifier); + if ((*extra)->extraRecordData_buf) + add_XML_n(ptr, "extraRecordData", + (*extra)->extraRecordData_buf, + (*extra)->extraRecordData_len, 0); + } + } + return 0; +} + static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs, - int *num, void *client_data, const char *ns) + Z_SRW_extra_record ***extra, + int *num, void *client_data, int version2) { if (o->direction == ODR_DECODE) { @@ -170,40 +360,20 @@ static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs, for (ptr = pptr->children; ptr; ptr = ptr->next) { if (ptr->type == XML_ELEMENT_NODE && - !strcmp(ptr->name, "record")) + !xmlStrcmp(ptr->name, BAD_CAST "record")) (*num)++; } if (!*num) return 1; - *recs = odr_malloc(o, *num * sizeof(**recs)); - for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++) + *recs = (Z_SRW_record *) odr_malloc(o, *num * sizeof(**recs)); + *extra = (Z_SRW_extra_record **) odr_malloc(o, *num * sizeof(**extra)); + for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next) { if (ptr->type == XML_ELEMENT_NODE && - !strcmp(ptr->name, "record")) - { - xmlNodePtr rptr; - (*recs)[i].recordSchema = 0; - (*recs)[i].recordPacking = Z_SRW_recordPacking_string; - (*recs)[i].recordData_buf = 0; - (*recs)[i].recordData_len = 0; - (*recs)[i].recordPosition = 0; - for (rptr = ptr->children; rptr; rptr = rptr->next) - { - if (match_xsd_string(rptr, "recordSchema", o, - &(*recs)[i].recordSchema)) - ; - else if (match_xsd_string_n(rptr, "recordData", o, - &(*recs)[i].recordData_buf, - &(*recs)[i].recordData_len)) - ; - else if (match_xsd_XML_n(rptr, "recordXML", o, - &(*recs)[i].recordData_buf, - &(*recs)[i].recordData_len)) - (*recs)[i].recordPacking = Z_SRW_recordPacking_XML; - else if (match_xsd_integer(rptr, "recordPosition", o, - &(*recs)[i].recordPosition)) - ; - } + !xmlStrcmp(ptr->name, BAD_CAST "record")) + { + yaz_srw_record(o, ptr, *recs + i, *extra + i, client_data, 0); + i++; } } } @@ -212,27 +382,45 @@ static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs, int i; for (i = 0; i < *num; i++) { - xmlNodePtr rptr = xmlNewChild(pptr, 0, "record", 0); - add_xsd_string(rptr, "recordSchema", (*recs)[i].recordSchema); - switch((*recs)[i].recordPacking) - { - case Z_SRW_recordPacking_string: - add_xsd_string_n(rptr, "recordData", (*recs)[i].recordData_buf, - (*recs)[i].recordData_len); - break; - case Z_SRW_recordPacking_XML: - add_XML_n(rptr, "recordXML", (*recs)[i].recordData_buf, - (*recs)[i].recordData_len); - break; - } - add_xsd_integer(rptr, "recordPosition", (*recs)[i].recordPosition); + xmlNodePtr rptr = xmlNewChild(pptr, 0, BAD_CAST "record", + 0); + yaz_srw_record(o, rptr, (*recs)+i, (*extra ? *extra + i : 0), + client_data, version2); } } return 0; } -static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs, - int *num, void *client_data, const char *ns) +static int yaz_srw_version(ODR o, xmlNodePtr pptr, Z_SRW_recordVersion *rec, + void *client_data, const char *ns) +{ + if (o->direction == ODR_DECODE) + { + xmlNodePtr ptr; + rec->versionType = 0; + rec->versionValue = 0; + for (ptr = pptr->children; ptr; ptr = ptr->next) + { + + if (match_xsd_string(ptr, "versionType", o, + &rec->versionType)) + ; + else + match_xsd_string(ptr, "versionValue", o, &rec->versionValue); + } + } + else if (o->direction == ODR_ENCODE) + { + xmlNodePtr ptr = pptr; + add_xsd_string(ptr, "versionType", rec->versionType); + add_xsd_string(ptr, "versionValue", rec->versionValue); + } + return 0; +} + +static int yaz_srw_versions(ODR o, xmlNodePtr pptr, + Z_SRW_recordVersion **vers, + int *num, void *client_data, const char *ns) { if (o->direction == ODR_DECODE) { @@ -242,122 +430,434 @@ static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs, for (ptr = pptr->children; ptr; ptr = ptr->next) { if (ptr->type == XML_ELEMENT_NODE && - !strcmp(ptr->name, "diagnostic")) + !xmlStrcmp(ptr->name, BAD_CAST "recordVersion")) (*num)++; } if (!*num) return 1; - *recs = odr_malloc(o, *num * sizeof(**recs)); - for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++) + *vers = (Z_SRW_recordVersion *) odr_malloc(o, *num * sizeof(**vers)); + for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next) { if (ptr->type == XML_ELEMENT_NODE && - !strcmp(ptr->name, "diagnostic")) + !xmlStrcmp(ptr->name, BAD_CAST "recordVersion")) { - xmlNodePtr rptr; - (*recs)[i].code = 0; - (*recs)[i].details = 0; - for (rptr = ptr->children; rptr; rptr = rptr->next) + yaz_srw_version(o, ptr, *vers + i, client_data, ns); + i++; + } + } + } + else if (o->direction == ODR_ENCODE) + { + int i; + for (i = 0; i < *num; i++) + { + xmlNodePtr rptr = xmlNewChild(pptr, 0, BAD_CAST "version", + 0); + yaz_srw_version(o, rptr, (*vers)+i, client_data, ns); + } + } + return 0; +} + +Z_FacetTerm *yaz_sru_proxy_get_facet_term_count(ODR odr, xmlNodePtr node) +{ + Odr_int freq; + xmlNodePtr child; + WRBUF wrbuf = wrbuf_alloc(); + Z_FacetTerm *facet_term; + const char *freq_string = yaz_element_attribute_value_get( + node, "facetvalue", "est_representation"); + if (freq_string) + freq = odr_atoi(freq_string); + else + freq = -1; + + for (child = node->children; child ; child = child->next) + { + if (child->type == XML_TEXT_NODE) + wrbuf_puts(wrbuf, (const char *) child->content); + } + facet_term = facet_term_create_cstr(odr, wrbuf_cstr(wrbuf), freq); + wrbuf_destroy(wrbuf); + return facet_term; +} + +static Z_FacetField *yaz_sru_proxy_decode_facet_field(ODR odr, xmlNodePtr ptr) +{ + Z_AttributeList *list; + Z_FacetField *facet_field; + int num_terms = 0; + int index = 0; + xmlNodePtr node; + /* USE attribute */ + const char* name = yaz_element_attribute_value_get(ptr, "facet", "code"); + yaz_log(YLOG_DEBUG, "sru-proxy facet type: %s", name); + + list = yaz_use_attribute_create(odr, name); + for (node = ptr->children; node; node = node->next) { + if (match_element(node, "facetvalue")) + num_terms++; + } + facet_field = facet_field_create(odr, list, num_terms); + index = 0; + for (node = ptr->children; node; node = node->next) + { + if (match_element(node, "facetvalue")) + { + facet_field_term_set(odr, facet_field, + yaz_sru_proxy_get_facet_term_count(odr, node), + index); + index++; + } + } + return facet_field; +} + +static int yaz_sru_proxy_decode_facets(ODR o, xmlNodePtr root, + Z_FacetList **facetList) +{ + xmlNodePtr ptr; + + for (ptr = root->children; ptr; ptr = ptr->next) + { + if (match_element(ptr, "facets")) + { + xmlNodePtr node; + Z_FacetList *facet_list; + int num_facets = 0; + for (node = ptr->children; node; node= node->next) + { + if (node->type == XML_ELEMENT_NODE) + num_facets++; + } + facet_list = facet_list_create(o, num_facets); + num_facets = 0; + for (node = ptr->children; node; node= node->next) + { + if (match_element(node, "facet")) { - if (match_xsd_integer(rptr, "code", o, - &(*recs)[i].code)) - ; - else if (match_xsd_string(rptr, "details", o, - &(*recs)[i].details)) - ; + facet_list_field_set( + o, facet_list, + yaz_sru_proxy_decode_facet_field(o, node), num_facets); + num_facets++; } - i++; } + *facetList = facet_list; + break; + } + } + return 0; +} + + + +static int yaz_srw_decode_diagnostics(ODR o, xmlNodePtr pptr, + Z_SRW_diagnostic **recs, int *num, + void *client_data, const char *ns) +{ + int i; + xmlNodePtr ptr; + *num = 0; + for (ptr = pptr; ptr; ptr = ptr->next) + { + if (ptr->type == XML_ELEMENT_NODE && + !xmlStrcmp(ptr->name, BAD_CAST "diagnostic")) + (*num)++; + } + if (!*num) + return 1; + *recs = (Z_SRW_diagnostic *) odr_malloc(o, *num * sizeof(**recs)); + for (i = 0; i < *num; i++) + { + (*recs)[i].uri = 0; + (*recs)[i].details = 0; + (*recs)[i].message = 0; + } + for (i = 0, ptr = pptr; ptr; ptr = ptr->next) + { + if (ptr->type == XML_ELEMENT_NODE && + !xmlStrcmp(ptr->name, BAD_CAST "diagnostic")) + { + xmlNodePtr rptr; + (*recs)[i].uri = 0; + (*recs)[i].details = 0; + (*recs)[i].message = 0; + for (rptr = ptr->children; rptr; rptr = rptr->next) + { + if (match_xsd_string(rptr, "uri", o, + &(*recs)[i].uri)) + ; + else if (match_xsd_string(rptr, "details", o, + &(*recs)[i].details)) + ; + else + match_xsd_string(rptr, "message", o, &(*recs)[i].message); + } + i++; } } + return 0; +} + +int sru_decode_surrogate_diagnostics(const char *buf, size_t len, + Z_SRW_diagnostic **diag, + int *num, ODR odr) +{ + int ret = 0; + xmlDocPtr doc = xmlParseMemory(buf, len); + if (doc) + { + xmlNodePtr ptr = xmlDocGetRootElement(doc); + while (ptr && ptr->type != XML_ELEMENT_NODE) + ptr = ptr->next; + if (ptr && ptr->ns + && !xmlStrcmp(ptr->ns->href, + BAD_CAST "http://www.loc.gov/zing/srw/diagnostic/")) + { + ret = yaz_srw_decode_diagnostics(odr, ptr, diag, num, 0, 0); + } + xmlFreeDoc(doc); + } + return ret; +} + +static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs, + int *num, void *client_data, const char *ns) +{ + if (o->direction == ODR_DECODE) + { + return yaz_srw_decode_diagnostics(o, pptr->children, recs, num, client_data, ns); + } else if (o->direction == ODR_ENCODE) { int i; + xmlNsPtr ns_diag = + xmlNewNs(pptr, BAD_CAST YAZ_XMLNS_DIAG_v1_1, BAD_CAST "diag" ); for (i = 0; i < *num; i++) { - xmlNodePtr rptr = xmlNewChild(pptr, 0, "diagnostic", 0); - add_xsd_integer(rptr, "code", (*recs)[i].code); + const char *std_diag = "info:srw/diagnostic/1/"; + const char *ucp_diag = "info:srw/diagnostic/12/"; + xmlNodePtr rptr = xmlNewChild(pptr, ns_diag, + BAD_CAST "diagnostic", 0); + add_xsd_string(rptr, "uri", (*recs)[i].uri); + if ((*recs)[i].message) + add_xsd_string(rptr, "message", (*recs)[i].message); + else if ((*recs)[i].uri ) + { + if (!strncmp((*recs)[i].uri, std_diag, strlen(std_diag))) + { + int no = atoi((*recs)[i].uri + strlen(std_diag)); + const char *message = yaz_diag_srw_str(no); + if (message) + add_xsd_string(rptr, "message", message); + } + else if (!strncmp((*recs)[i].uri, ucp_diag, strlen(ucp_diag))) + { + int no = atoi((*recs)[i].uri + strlen(ucp_diag)); + const char *message = yaz_diag_sru_update_str(no); + if (message) + add_xsd_string(rptr, "message", message); + } + } add_xsd_string(rptr, "details", (*recs)[i].details); } } return 0; } +static int yaz_srw_term(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm *term, + void *client_data, const char *ns) +{ + if (o->direction == ODR_DECODE) + { + xmlNodePtr ptr; + term->value = 0; + term->numberOfRecords = 0; + term->displayTerm = 0; + term->whereInList = 0; + for (ptr = pptr->children; ptr; ptr = ptr->next) + { + if (match_xsd_string(ptr, "value", o, &term->value)) + ; + else if (match_xsd_integer(ptr, "numberOfRecords", o, + &term->numberOfRecords)) + ; + else if (match_xsd_string(ptr, "displayTerm", o, + &term->displayTerm)) + ; + else + match_xsd_string(ptr, "whereInList", o, &term->whereInList); + } + } + else if (o->direction == ODR_ENCODE) + { + xmlNodePtr ptr = pptr; + add_xsd_string(ptr, "value", term->value); + add_xsd_integer(ptr, "numberOfRecords", term->numberOfRecords); + add_xsd_string(ptr, "displayTerm", term->displayTerm); + add_xsd_string(ptr, "whereInList", term->whereInList); + } + return 0; +} + +static int yaz_srw_terms(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm **terms, + int *num, void *client_data, const char *ns) +{ + if (o->direction == ODR_DECODE) + { + int i; + xmlNodePtr ptr; + *num = 0; + for (ptr = pptr->children; ptr; ptr = ptr->next) + { + if (ptr->type == XML_ELEMENT_NODE && + !xmlStrcmp(ptr->name, BAD_CAST "term")) + (*num)++; + } + if (!*num) + return 1; + *terms = (Z_SRW_scanTerm *) odr_malloc(o, *num * sizeof(**terms)); + for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next, i++) + { + if (ptr->type == XML_ELEMENT_NODE && + !xmlStrcmp(ptr->name, BAD_CAST "term")) + yaz_srw_term(o, ptr, (*terms)+i, client_data, ns); + } + } + else if (o->direction == ODR_ENCODE) + { + int i; + for (i = 0; i < *num; i++) + { + xmlNodePtr rptr = xmlNewChild(pptr, 0, BAD_CAST "term", 0); + yaz_srw_term(o, rptr, (*terms)+i, client_data, ns); + } + } + return 0; +} int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data, void *client_data, const char *ns) { - xmlNodePtr pptr = vptr; + xmlNodePtr pptr = (xmlNodePtr) vptr; if (o->direction == ODR_DECODE) { + Z_SRW_PDU **p = handler_data; xmlNodePtr method = pptr->children; + char *neg_version; while (method && method->type == XML_TEXT_NODE) method = method->next; - - if (!method || method->type != XML_ELEMENT_NODE) + + if (!method) + return -1; + if (method->type != XML_ELEMENT_NODE) return -1; - if (!strcmp(method->name, "searchRetrieveRequest")) + + *p = yaz_srw_get_core_v_2_0(o); + + if (!xmlStrcmp(method->name, BAD_CAST "searchRetrieveRequest")) { - Z_SRW_PDU **p = handler_data; xmlNodePtr ptr = method->children; Z_SRW_searchRetrieveRequest *req; + char *recordPacking = 0; + char *recordXMLEscaping = 0; + const char *facetLimit = 0; - *p = odr_malloc(o, sizeof(**p)); (*p)->which = Z_SRW_searchRetrieve_request; - req = (*p)->u.request = odr_malloc(o, sizeof(*req)); - req->query_type = Z_SRW_query_type_cql; - req->query.cql = 0; + req = (*p)->u.request = (Z_SRW_searchRetrieveRequest *) + odr_malloc(o, sizeof(*req)); + req->queryType = "cql"; + req->query = 0; req->sort_type = Z_SRW_sort_type_none; req->sort.none = 0; req->startRecord = 0; req->maximumRecords = 0; req->recordSchema = 0; req->recordPacking = 0; + req->packing = 0; + req->recordXPath = 0; + req->resultSetTTL = 0; + req->stylesheet = 0; req->database = 0; for (; ptr; ptr = ptr->next) { - if (match_xsd_string(ptr, "query", o, - &req->query.cql)) - req->query_type = Z_SRW_query_type_cql; - else if (match_xsd_string(ptr, "pQuery", o, - &req->query.pqf)) - req->query_type = Z_SRW_query_type_pqf; - else if (match_xsd_string(ptr, "xQuery", o, - &req->query.xcql)) - req->query_type = Z_SRW_query_type_xcql; - else if (match_xsd_string(ptr, "sortKeys", o, - &req->sort.sortKeys)) - req->sort_type = Z_SRW_sort_type_sort; - else if (match_xsd_string(ptr, "recordSchema", o, - &req->recordSchema)) + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) ; - else if (match_xsd_string(ptr, "recordPacking", o, - &req->recordPacking)) + else if (match_xsd_string(ptr, "queryType", o, + &req->queryType)) ; + else if (match_xsd_string(ptr, "query", o, + &req->query)) + ; + else if (match_xsd_string(ptr, "pQuery", o, + &req->query)) + req->queryType = "pqf"; + else if (match_xsd_string(ptr, "xQuery", o, + &req->query)) + req->queryType = "xcql"; else if (match_xsd_integer(ptr, "startRecord", o, &req->startRecord)) ; else if (match_xsd_integer(ptr, "maximumRecords", o, &req->maximumRecords)) ; - else if (match_xsd_string(ptr, "database", o, - &req->database)) + else if (match_xsd_string(ptr, "recordPacking", o, + &recordPacking)) + ; + else if (match_xsd_string(ptr, "recordXMLEscaping", o, + &recordXMLEscaping)) + ; + else if (match_xsd_string(ptr, "recordSchema", o, + &req->recordSchema)) + ; + else if (match_xsd_string(ptr, "recordXPath", o, + &req->recordXPath)) ; - /* missing is xQuery, xSortKeys .. */ + else if (match_xsd_integer(ptr, "resultSetTTL", o, + &req->resultSetTTL)) + ; + else if (match_xsd_string(ptr, "sortKeys", o, + &req->sort.sortKeys)) + req->sort_type = Z_SRW_sort_type_sort; + else if (match_xsd_string(ptr, "stylesheet", o, + &req->stylesheet)) + ; + else if (match_xsd_string(ptr, "database", o, &req->database)) + ; + else if (match_xsd_string(ptr, "facetLimit", o, + (char**) &facetLimit)) + ; + } + if (!req->query) + { + /* should put proper diagnostic here */ + return -1; + } + if (!strcmp((*p)->srw_version, "2.0")) + { + req->recordPacking = recordXMLEscaping; + req->packing = recordPacking; + } + else + { + req->recordPacking = recordPacking; } + yaz_sru_facet_request(o, &req->facetList, &facetLimit); } - else if (!strcmp(method->name, "searchRetrieveResponse")) + else if (!xmlStrcmp(method->name, BAD_CAST "searchRetrieveResponse")) { - Z_SRW_PDU **p = handler_data; xmlNodePtr ptr = method->children; Z_SRW_searchRetrieveResponse *res; - *p = odr_malloc(o, sizeof(**p)); (*p)->which = Z_SRW_searchRetrieve_response; - res = (*p)->u.response = odr_malloc(o, sizeof(*res)); + res = (*p)->u.response = (Z_SRW_searchRetrieveResponse *) + odr_malloc(o, sizeof(*res)); res->numberOfRecords = 0; + res->resultCountPrecision = 0; res->resultSetId = 0; res->resultSetIdleTime = 0; res->records = 0; @@ -365,89 +865,247 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data, res->diagnostics = 0; res->num_diagnostics = 0; res->nextRecordPosition = 0; + res->facetList = 0; + res->suggestions = 0; for (; ptr; ptr = ptr->next) { - if (match_xsd_integer(ptr, "numberOfRecords", o, - &res->numberOfRecords)) + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_XML_n(ptr, "extraResponseData", o, + &(*p)->extraResponseData_buf, + &(*p)->extraResponseData_len)) + ; + else if (match_xsd_integer(ptr, "numberOfRecords", o, + &res->numberOfRecords)) ; - else if (match_xsd_string(ptr, "resultSetId", o, + else if (match_xsd_string(ptr, "resultCountPrecision", o, + &res->resultCountPrecision)) + ; + else if (match_xsd_string(ptr, "resultSetId", o, &res->resultSetId)) ; - else if (match_xsd_integer(ptr, "resultSetIdleTime", o, + else if (match_xsd_integer(ptr, "resultSetIdleTime", o, + &res->resultSetIdleTime)) + ; + else if (match_xsd_integer(ptr, "resultSetTTL", o, &res->resultSetIdleTime)) ; else if (match_element(ptr, "records")) yaz_srw_records(o, ptr, &res->records, - &res->num_records, client_data, - ns); + &res->extra_records, + &res->num_records, client_data, 0); + else if (match_xsd_integer(ptr, "nextRecordPosition", o, + &res->nextRecordPosition)) + ; else if (match_element(ptr, "diagnostics")) yaz_srw_diagnostics(o, ptr, &res->diagnostics, &res->num_diagnostics, client_data, ns); - else if (match_xsd_integer(ptr, "nextRecordPosition", o, - &res->nextRecordPosition)) - ; + else if (match_element(ptr, "facet_analysis")) + yaz_sru_proxy_decode_facets(o, ptr, &res->facetList); + else if (match_element(ptr, "facetedResults")) + yaz_sru_facet_response(o, &res->facetList, ptr); } } - else if (!strcmp(method->name, "explainRequest")) + else if (!xmlStrcmp(method->name, BAD_CAST "explainRequest")) { - Z_SRW_PDU **p = handler_data; Z_SRW_explainRequest *req; - - *p = odr_malloc(o, sizeof(**p)); + xmlNodePtr ptr = method->children; + (*p)->which = Z_SRW_explain_request; - req = (*p)->u.explain_request = odr_malloc(o, sizeof(*req)); - req->dummy = 0; + req = (*p)->u.explain_request = (Z_SRW_explainRequest *) + odr_malloc(o, sizeof(*req)); + req->recordPacking = 0; + req->packing = 0; + req->database = 0; + req->stylesheet = 0; + for (; ptr; ptr = ptr->next) + { + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_XML_n(ptr, "extraResponseData", o, + &(*p)->extraResponseData_buf, + &(*p)->extraResponseData_len)) + ; + else if (match_xsd_string(ptr, "stylesheet", o, + &req->stylesheet)) + ; + else if (match_xsd_string(ptr, "recordPacking", o, + &req->recordPacking)) + ; + else + match_xsd_string(ptr, "database", o, &req->database); + } } - else if (!strcmp(method->name, "explainResponse")) + else if (!xmlStrcmp(method->name, BAD_CAST "explainResponse")) { - Z_SRW_PDU **p = handler_data; Z_SRW_explainResponse *res; xmlNodePtr ptr = method->children; - *p = odr_malloc(o, sizeof(**p)); (*p)->which = Z_SRW_explain_response; - res = (*p)->u.explain_response = odr_malloc(o, sizeof(*res)); - res->explainData_buf = 0; - res->explainData_len = 0; - res->explainPacking = Z_SRW_recordPacking_string; + res = (*p)->u.explain_response = (Z_SRW_explainResponse*) + odr_malloc(o, sizeof(*res)); + res->diagnostics = 0; + res->num_diagnostics = 0; + res->record.recordSchema = 0; + res->record.recordData_buf = 0; + res->record.recordData_len = 0; + res->record.recordPosition = 0; + for (; ptr; ptr = ptr->next) { - match_xsd_string_n(ptr, "Explain", o, - &res->explainData_buf, - &res->explainData_len); + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_XML_n(ptr, "extraResponseData", o, + &(*p)->extraResponseData_buf, + &(*p)->extraResponseData_len)) + ; + else if (match_element(ptr, "record")) + yaz_srw_record(o, ptr, &res->record, &res->extra_record, + client_data, 0); + else if (match_element(ptr, "diagnostics")) + yaz_srw_diagnostics(o, ptr, &res->diagnostics, + &res->num_diagnostics, + client_data, ns); + ; + } + } + else if (!xmlStrcmp(method->name, BAD_CAST "scanRequest")) + { + Z_SRW_scanRequest *req; + xmlNodePtr ptr = method->children; + + (*p)->which = Z_SRW_scan_request; + req = (*p)->u.scan_request = (Z_SRW_scanRequest *) + odr_malloc(o, sizeof(*req)); + req->queryType = "cql"; + req->scanClause = 0; + req->responsePosition = 0; + req->maximumTerms = 0; + req->stylesheet = 0; + req->database = 0; + + for (; ptr; ptr = ptr->next) + { + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_XML_n(ptr, "extraResponseData", o, + &(*p)->extraResponseData_buf, + &(*p)->extraResponseData_len)) + ; + else if (match_xsd_string(ptr, "scanClause", o, + &req->scanClause)) + ; + else if (match_xsd_string(ptr, "pScanClause", o, + &req->scanClause)) + { + req->queryType = "pqf"; + } + else if (match_xsd_integer(ptr, "responsePosition", o, + &req->responsePosition)) + ; + else if (match_xsd_integer(ptr, "maximumTerms", o, + &req->maximumTerms)) + ; + else if (match_xsd_string(ptr, "stylesheet", o, + &req->stylesheet)) + ; + else + match_xsd_string(ptr, "database", o, &req->database); + } + } + else if (!xmlStrcmp(method->name, BAD_CAST "scanResponse")) + { + Z_SRW_scanResponse *res; + xmlNodePtr ptr = method->children; + + (*p)->which = Z_SRW_scan_response; + res = (*p)->u.scan_response = (Z_SRW_scanResponse *) + odr_malloc(o, sizeof(*res)); + res->terms = 0; + res->num_terms = 0; + res->diagnostics = 0; + res->num_diagnostics = 0; + + for (; ptr; ptr = ptr->next) + { + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_XML_n(ptr, "extraResponseData", o, + &(*p)->extraResponseData_buf, + &(*p)->extraResponseData_len)) + ; + else if (match_element(ptr, "terms")) + yaz_srw_terms(o, ptr, &res->terms, + &res->num_terms, client_data, + ns); + else if (match_element(ptr, "diagnostics")) + yaz_srw_diagnostics(o, ptr, &res->diagnostics, + &res->num_diagnostics, + client_data, ns); } } else + { + *p = 0; return -1; - + } + neg_version = yaz_negotiate_sru_version((*p)->srw_version); + if (neg_version) + (*p)->srw_version = neg_version; } else if (o->direction == ODR_ENCODE) { Z_SRW_PDU **p = handler_data; + xmlNsPtr ns_srw; + xmlNodePtr ptr = 0; + int version2 = !(*p)->srw_version || + strcmp((*p)->srw_version, "2.") > 0; if ((*p)->which == Z_SRW_searchRetrieve_request) { Z_SRW_searchRetrieveRequest *req = (*p)->u.request; - xmlNodePtr ptr = xmlNewChild(pptr, 0, - "searchRetrieveRequest", 0); - xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); - + const char *queryType = req->queryType; + if (version2) + ns = "http://docs.oasis-open.org/ns/search-ws/sruRequest"; + ptr = xmlNewChild(pptr, 0, BAD_CAST "searchRetrieveRequest", 0); + ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs"); xmlSetNs(ptr, ns_srw); - switch(req->query_type) + add_xsd_string(ptr, "version", (*p)->srw_version); + if (version2) { - case Z_SRW_query_type_cql: - add_xsd_string(ptr, "query", req->query.cql); - break; - case Z_SRW_query_type_xcql: - add_xsd_string(ptr, "xQuery", req->query.xcql); - break; - case Z_SRW_query_type_pqf: - add_xsd_string(ptr, "pQuery", req->query.pqf); - break; + if (queryType) + add_xsd_string(ptr, "queryType", queryType); + add_xsd_string(ptr, "query", req->query); } - switch(req->sort_type) + else + { + if (!queryType || !strcmp(queryType, "cql")) + add_xsd_string(ptr, "query", req->query); + else if (!strcmp(queryType, "xcql")) + add_xsd_string(ptr, "xQuery", req->query); + else if (!strcmp(queryType, "pqf")) + add_xsd_string(ptr, "pQuery", req->query); + } + add_xsd_integer(ptr, "startRecord", req->startRecord); + add_xsd_integer(ptr, "maximumRecords", req->maximumRecords); + if (version2) + { + add_xsd_string(ptr, "recordXMLEscaping", req->recordPacking); + add_xsd_string(ptr, "recordPacking", req->packing); + } + else + add_xsd_string(ptr, "recordPacking", req->recordPacking); + add_xsd_string(ptr, "recordSchema", req->recordSchema); + add_xsd_string(ptr, "recordXPath", req->recordXPath); + add_xsd_integer(ptr, "resultSetTTL", req->resultSetTTL); + switch (req->sort_type) { case Z_SRW_sort_type_none: break; @@ -458,398 +1116,382 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data, add_xsd_string(ptr, "xSortKeys", req->sort.xSortKeys); break; } - add_xsd_integer(ptr, "startRecord", req->startRecord); - add_xsd_integer(ptr, "maximumRecords", req->maximumRecords); - add_xsd_string(ptr, "recordSchema", req->recordSchema); - add_xsd_string(ptr, "recordPacking", req->recordPacking); + add_xsd_string(ptr, "stylesheet", req->stylesheet); add_xsd_string(ptr, "database", req->database); + { + const char *limit = 0; + yaz_sru_facet_request(o, &req->facetList, &limit); + add_xsd_string(ptr, "facetLimit", limit); + } } else if ((*p)->which == Z_SRW_searchRetrieve_response) { Z_SRW_searchRetrieveResponse *res = (*p)->u.response; - xmlNodePtr ptr = xmlNewChild(pptr, 0, - "searchRetrieveResponse", 0); - xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); - + if (version2) + ns = "http://docs.oasis-open.org/ns/search-ws/sruResponse"; + ptr = xmlNewChild(pptr, 0, BAD_CAST "searchRetrieveResponse", 0); + ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs"); xmlSetNs(ptr, ns_srw); + + add_xsd_string(ptr, "version", (*p)->srw_version); add_xsd_integer(ptr, "numberOfRecords", res->numberOfRecords); add_xsd_string(ptr, "resultSetId", res->resultSetId); - add_xsd_integer(ptr, "resultSetIdleTime", res->resultSetIdleTime); + add_xsd_integer(ptr, + version2 ? "resultSetTTL" : "resultSetIdleTime" , + res->resultSetIdleTime); if (res->num_records) { - xmlNodePtr rptr = xmlNewChild(ptr, 0, "records", 0); - yaz_srw_records(o, rptr, &res->records, &res->num_records, - client_data, ns); + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "records", 0); + yaz_srw_records(o, rptr, &res->records, &res->extra_records, + &res->num_records, + client_data, version2); } + add_xsd_integer(ptr, "nextRecordPosition", + res->nextRecordPosition); if (res->num_diagnostics) { - xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0); + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "diagnostics", + 0); yaz_srw_diagnostics(o, rptr, &res->diagnostics, &res->num_diagnostics, client_data, ns); } - add_xsd_integer(ptr, "nextRecordPosition", res->nextRecordPosition); + if (res->resultCountPrecision) + add_xsd_string(ptr, "resultCountPrecision", + res->resultCountPrecision); + yaz_sru_facet_response(o, &res->facetList, ptr); } else if ((*p)->which == Z_SRW_explain_request) { - xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainRequest", 0); - xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); - + Z_SRW_explainRequest *req = (*p)->u.explain_request; + ptr = xmlNewChild(pptr, 0, BAD_CAST "explainRequest", 0); + ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs"); xmlSetNs(ptr, ns_srw); + + add_xsd_string(ptr, "version", (*p)->srw_version); + if (version2) + { + add_xsd_string(ptr, "recordXMLEscaping", req->recordPacking); + add_xsd_string(ptr, "recordPacking", req->packing); + } + else + add_xsd_string(ptr, "recordPacking", req->recordPacking); + add_xsd_string(ptr, "stylesheet", req->stylesheet); + add_xsd_string(ptr, "database", req->database); } else if ((*p)->which == Z_SRW_explain_response) { Z_SRW_explainResponse *res = (*p)->u.explain_response; - xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainResponse", 0); - xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); + ptr = xmlNewChild(pptr, 0, BAD_CAST "explainResponse", 0); + ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs"); + xmlSetNs(ptr, ns_srw); + add_xsd_string(ptr, "version", (*p)->srw_version); + if (1) + { + xmlNodePtr ptr1 = xmlNewChild(ptr, 0, BAD_CAST "record", 0); + yaz_srw_record(o, ptr1, &res->record, &res->extra_record, + client_data, version2); + } + if (res->num_diagnostics) + { + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "diagnostics", + 0); + yaz_srw_diagnostics(o, rptr, &res->diagnostics, + &res->num_diagnostics, client_data, ns); + } + } + else if ((*p)->which == Z_SRW_scan_request) + { + Z_SRW_scanRequest *req = (*p)->u.scan_request; + const char *queryType = req->queryType; + if (version2) + ns = "http://docs.oasis-open.org/ns/search-ws/scan"; + ptr = xmlNewChild(pptr, 0, BAD_CAST "scanRequest", 0); + ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs"); xmlSetNs(ptr, ns_srw); - add_xsd_string_n(ptr, "Explain", res->explainData_buf, - res->explainData_len); + add_xsd_string(ptr, "version", (*p)->srw_version); + + if (version2) + { + if (queryType && strcmp(queryType, "cql")) + add_xsd_string(ptr, "queryType", queryType); + add_xsd_string(ptr, "scanClause", req->scanClause); + } + else + { + if (!queryType || !strcmp(queryType, "cql")) + add_xsd_string(ptr, "scanClause", req->scanClause); + else if (!strcmp(queryType, "pqf")) + add_xsd_string(ptr, "pScanClause", req->scanClause); + } + add_xsd_integer(ptr, "responsePosition", req->responsePosition); + add_xsd_integer(ptr, "maximumTerms", req->maximumTerms); + add_xsd_string(ptr, "stylesheet", req->stylesheet); + add_xsd_string(ptr, "database", req->database); + } + else if ((*p)->which == Z_SRW_scan_response) + { + Z_SRW_scanResponse *res = (*p)->u.scan_response; + if (version2) + ns = "http://docs.oasis-open.org/ns/search-ws/scan"; + ptr = xmlNewChild(pptr, 0, BAD_CAST "scanResponse", 0); + ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs"); + xmlSetNs(ptr, ns_srw); + + add_xsd_string(ptr, "version", (*p)->srw_version); + if (res->num_terms) + { + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "terms", 0); + yaz_srw_terms(o, rptr, &res->terms, &res->num_terms, + client_data, ns); + } + if (res->num_diagnostics) + { + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "diagnostics", + 0); + yaz_srw_diagnostics(o, rptr, &res->diagnostics, + &res->num_diagnostics, client_data, ns); + } } else return -1; + if (ptr && (*p)->extraResponseData_len) + add_XML_n(ptr, "extraResponseData", + (*p)->extraResponseData_buf, + (*p)->extraResponseData_len, ns_srw); + } return 0; } -Z_SRW_PDU *yaz_srw_get(ODR o, int which) +int yaz_ucp_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data, + void *client_data, const char *ns_ucp_str) { - Z_SRW_PDU *sr = odr_malloc(o, sizeof(*o)); - sr->which = which; - switch(which) - { - case Z_SRW_searchRetrieve_request: - sr->u.request = (Z_SRW_searchRetrieveRequest *) - odr_malloc(o, sizeof(*sr->u.request)); - sr->u.request->query_type = Z_SRW_query_type_cql; - sr->u.request->query.cql = 0; - sr->u.request->sort_type = Z_SRW_sort_type_none; - sr->u.request->sort.none = 0; - sr->u.request->startRecord = 0; - sr->u.request->maximumRecords = 0; - sr->u.request->recordSchema = 0; - sr->u.request->recordPacking = 0; - sr->u.request->database = 0; - break; - case Z_SRW_searchRetrieve_response: - sr->u.response = (Z_SRW_searchRetrieveResponse *) - odr_malloc(o, sizeof(*sr->u.response)); - sr->u.response->numberOfRecords = 0; - sr->u.response->resultSetId = 0; - sr->u.response->resultSetIdleTime = 0; - sr->u.response->records = 0; - sr->u.response->num_records = 0; - sr->u.response->diagnostics = 0; - sr->u.response->num_diagnostics = 0; - sr->u.response->nextRecordPosition = 0; - break; - case Z_SRW_explain_request: - sr->u.explain_request = (Z_SRW_explainRequest *) - odr_malloc(o, sizeof(*sr->u.explain_request)); - sr->u.explain_request->dummy = 0; - break; - case Z_SRW_explain_response: - sr->u.explain_response = (Z_SRW_explainResponse *) - odr_malloc(o, sizeof(*sr->u.explain_response)); - sr->u.explain_response->explainPacking = 0; - sr->u.explain_response->explainData_buf = 0; - sr->u.explain_response->explainData_len = 0; - } - return sr; -} + xmlNodePtr pptr = (xmlNodePtr) vptr; + const char *ns_srw_str = YAZ_XMLNS_SRU_v1_1; + if (o->direction == ODR_DECODE) + { + Z_SRW_PDU **p = handler_data; + xmlNodePtr method = pptr->children; -#endif + while (method && method->type == XML_TEXT_NODE) + method = method->next; + if (!method) + return -1; + if (method->type != XML_ELEMENT_NODE) + return -1; -static struct { - int code; - const char *msg; -} yaz_srw_codes [] = { -{1, "Permanent system error"}, -{2, "System temporarily unavailable"}, -{3, "Authentication error"}, -/* Diagnostics Relating to CQL */ -{10, "Illegal query"}, -{11, "Unsupported query type (XCQL vs CQL)"}, -{12, "Too many characters in query"}, -{13, "Unbalanced or illegal use of parentheses"}, -{14, "Unbalanced or illegal use of quotes"}, -{15, "Illegal or unsupported context set"}, -{16, "Illegal or unsupported index"}, -{17, "Illegal or unsupported combination of index and context set"}, -{18, "Illegal or unsupported combination of indexes"}, -{19, "Illegal or unsupported relation"}, -{20, "Illegal or unsupported relation modifier"}, -{21, "Illegal or unsupported combination of relation modifers"}, -{22, "Illegal or unsupported combination of relation and index"}, -{23, "Too many characters in term"}, -{24, "Illegal combination of relation and term"}, -{25, "Special characters not quoted in term"}, -{26, "Non special character escaped in term"}, -{27, "Empty term unsupported"}, -{28, "Masking character not supported"}, -{29, "Masked words too short"}, -{30, "Too many masking characters in term"}, -{31, "Anchoring character not supported"}, -{32, "Anchoring character in illegal or unsupported position"}, -{33, "Combination of proximity/adjacency and masking characters not supported"}, -{34, "Combination of proximity/adjacency and anchoring characters not supported"}, -{35, "Terms only exclusion (stop) words"}, -{36, "Term in invalid format for index or relation"}, -{37, "Illegal or unsupported boolean operator"}, -{38, "Too many boolean operators in query"}, -{39, "Proximity not supported"}, -{40, "Illegal or unsupported proximity relation"}, -{41, "Illegal or unsupported proximity distance"}, -{42, "Illegal or unsupported proximity unit"}, -{43, "Illegal or unsupported proximity ordering"}, -{44, "Illegal or unsupported combination of proximity modifiers"}, -{45, "context set name (prefix) assigned to multiple identifiers"}, -/* Diagnostics Relating to Result Sets */ -{50, "Result sets not supported"}, -{51, "Result set does not exist"}, -{52, "Result set temporarily unavailable"}, -{53, "Result sets only supported for retrieval"}, -{54, "Retrieval may only occur from an existing result set"}, -{55, "Combination of result sets with search terms not supported"}, -{56, "Only combination of single result set with search terms supported"}, -{57, "Result set created but no records available"}, -{58, "Result set created with unpredictable partial results available"}, -{59, "Result set created with valid partial results available"}, -/* Diagnostics Relating to Records */ -{60, "Too many records retrieved"}, -{61, "First record position out of range"}, -{62, "Negative number of records requested"}, -{63, "System error in retrieving records"}, -{64, "Record temporarily unavailable"}, -{65, "Record does not exist"}, -{66, "Unknown schema for retrieval"}, -{67, "Record not available in this schema"}, -{68, "Not authorised to send record"}, -{69, "Not authorised to send record in this schema"}, -{70, "Record too large to send"}, -/* Diagnostics Relating to Sorting */ -{80, "Sort not supported"}, -{81, "Unsupported sort type (sortKeys vs xSortKeys)"}, -{82, "Illegal or unsupported sort sequence"}, -{83, "Too many records"}, -{84, "Too many sort keys"}, -{85, "Duplicate sort keys"}, -{86, "Incompatible record formats"}, -{87, "Unsupported schema for sort"}, -{88, "Unsupported tag path for sort"}, -{89, "Tag path illegal or unsupported for schema"}, -{90, "Illegal or unsupported direction value"}, -{91, "Illegal or unsupported case value"}, -{92, "Illegal or unsupported missing value action"}, -/* Diagnostics Relating to Explain */ -{100, "Explain not supported"}, -{101, "Explain request type not supported (SOAP vs GET)"}, -{102, "Explain record temporarily unavailable"}, -{0, 0} -}; - -const char *yaz_diag_srw_str (int code) -{ - int i; - for (i = 0; yaz_srw_codes[i].code; i++) - if (yaz_srw_codes[i].code == code) - return yaz_srw_codes[i].msg; - return 0; -} + *p = yaz_srw_get_core_v_2_0(o); + if (!xmlStrcmp(method->name, BAD_CAST "updateRequest")) + { + xmlNodePtr ptr = method->children; + Z_SRW_updateRequest *req; + char *oper = 0; -/* bib1:srw */ -static int srw_bib1_map[] = { - 1, 1, - 2, 2, - 3, 11, - 4, 35, - 5, 12, - 6, 38, - 7, 30, - 8, 32, - 9, 29, - 10, 10, - 11, 12, - 11, 23, - 12, 60, - 13, 61, - 13, 62, - 14, 63, - 14, 64, - 14, 65, - 15, 68, - 15, 69, - 16, 70, - 17, 70, - 18, 50, - 19, 55, - 20, 56, - 21, 52, - 22, 50, - 23, 1, /* bad map */ - 24, 63, /* bad map */ - 25, 63, /* bad map */ - 26, 63, /* bad map */ - 27, 51, - 28, 52, - 29, 52, - 30, 51, - 31, 57, - 32, 58, - 33, 59, - 100, 1, /* bad map */ - 101, 3, - 102, 3, - 103, 3, - 104, 3, - 105, 3, - 106, 66, - 107, 11, - 108, 10, - 108, 13, - 108, 14, - 108, 25, - 108, 26, - 108, 27, - 108, 45, - - 109, 1, - 110, 37, - 111, 1, - 112, 58, - 113, 10, - 114, 16, - 115, 16, - 116, 16, - 117, 19, - 118, 22, - 119, 32, - 119, 31, - 120, 28, - 121, 15, - 122, 32, - 123, 22, - 123, 17, - 123, 18, - 124, 24, - 125, 36, - 126, 36, - 127, 36, - 128, 51, - 129, 39, - 130, 43, - 131, 40, - 132, 42, - 201, 44, - 201, 33, - 201, 34, - 202, 41, - 203, 43, - 205, 1, /* bad map */ - 206, 1, /* bad map */ - 207, 89, - 208, 1, /* bad map */ - 209, 80, - 210, 80, - 210, 81, - 211, 84, - 212, 85, - 213, 92, - 214, 90, - 215, 91, - 216, 92, - 217, 63, - 218, 1, /* bad map */ - 219, 1, /* bad map */ - 220, 1, /* bad map */ - 221, 1, /* bad map */ - 222, 1, /* bad map */ - 223, 1, /* bad map */ - 224, 1, /* bad map */ - 225, 1, /* bad map */ - 226, 1, /* bad map */ - 227, 66, - 228, 1, /* bad map */ - 229, 36, - 230, 83, - 231, 89, - 232, 1, - 233, 1, /* bad map */ - 234, 1, /* bad map */ - 235, 2, - 236, 3, - 237, 82, - 238, 67, - 239, 66, - 240, 1, /* bad map */ - 241, 1, /* bad map */ - 242, 70, - 243, 1, /* bad map */ - 244, 66, - 245, 10, - 246, 10, - 247, 10, - 1001, 1, /* bad map */ - 1002, 1, /* bad map */ - 1003, 1, /* bad map */ - 1004, 1, /* bad map */ - 1005, 1, /* bad map */ - 1006, 1, /* bad map */ - 1007, 100, - 1008, 1, - 1009, 1, - 1010, 3, - 1011, 3, - 1012, 3, - 1013, 3, - 1014, 3, - 1015, 3, - 1015, 3, - 1016, 3, - 1017, 3, - 1018, 2, - 1019, 2, - 1020, 2, - 1021, 3, - 1022, 3, - 1023, 3, - 1024, 16, - 1025, 3, - 1026, 64, - 1027, 1, - 1028, 65, - 1029, 1, - 1040, 1, - /* 1041-1065 */ - 1066, 66, - 1066, 67, - 0 -}; - -int yaz_diag_bib1_to_srw (int code) -{ - const int *p = srw_bib1_map; - while (*p) - { - if (code == p[0]) - return p[1]; - p += 2; - } - return 1; -} + (*p)->which = Z_SRW_update_request; + req = (*p)->u.update_request = (Z_SRW_updateRequest *) + odr_malloc(o, sizeof(*req)); + req->database = 0; + req->operation = 0; + req->recordId = 0; + req->recordVersions = 0; + req->num_recordVersions = 0; + req->record = 0; + req->extra_record = 0; + req->extraRequestData_buf = 0; + req->extraRequestData_len = 0; + req->stylesheet = 0; -int yaz_diag_srw_to_bib1(int code) -{ - const int *p = srw_bib1_map; - while (*p) + for (; ptr; ptr = ptr->next) + { + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_string(ptr, "action", o, + &oper)){ + if (oper) + { + if (!strcmp(oper, "info:srw/action/1/delete")) + req->operation = "delete"; + else if (!strcmp(oper,"info:srw/action/1/replace" )) + req->operation = "replace"; + else if (!strcmp(oper, "info:srw/action/1/create")) + req->operation = "insert"; + } + } + else if (match_xsd_string(ptr, "recordIdentifier", o, + &req->recordId)) + ; + else if (match_element(ptr, "recordVersions" ) ) + yaz_srw_versions( o, ptr, &req->recordVersions, + &req->num_recordVersions, client_data, + ns_ucp_str); + else if (match_element(ptr, "record")) + { + req->record = yaz_srw_get_record(o); + yaz_srw_record(o, ptr, req->record, &req->extra_record, + client_data, 0); + } + else if (match_xsd_string(ptr, "stylesheet", o, + &req->stylesheet)) + ; + else + match_xsd_string(ptr, "database", o, &req->database); + } + } + else if (!xmlStrcmp(method->name, BAD_CAST "updateResponse")) + { + xmlNodePtr ptr = method->children; + Z_SRW_updateResponse *res; + + (*p)->which = Z_SRW_update_response; + res = (*p)->u.update_response = (Z_SRW_updateResponse *) + odr_malloc(o, sizeof(*res)); + + res->operationStatus = 0; + res->recordId = 0; + res->recordVersions = 0; + res->num_recordVersions = 0; + res->diagnostics = 0; + res->num_diagnostics = 0; + res->record = 0; + res->extra_record = 0; + res->extraResponseData_buf = 0; + res->extraResponseData_len = 0; + + for (; ptr; ptr = ptr->next) + { + if (match_xsd_string(ptr, "version", o, + &(*p)->srw_version)) + ; + else if (match_xsd_string(ptr, "operationStatus", o, + &res->operationStatus )) + ; + else if (match_xsd_string(ptr, "recordIdentifier", o, + &res->recordId)) + ; + else if (match_element(ptr, "recordVersions" )) + yaz_srw_versions(o, ptr, &res->recordVersions, + &res->num_recordVersions, + client_data, ns_ucp_str); + else if (match_element(ptr, "record")) + { + res->record = yaz_srw_get_record(o); + yaz_srw_record(o, ptr, res->record, &res->extra_record, + client_data, 0); + } + else if (match_element(ptr, "diagnostics")) + yaz_srw_diagnostics(o, ptr, &res->diagnostics, + &res->num_diagnostics, + client_data, ns_ucp_str); + } + } + else if (!xmlStrcmp(method->name, BAD_CAST "explainUpdateRequest")) + { + } + else if (!xmlStrcmp(method->name, BAD_CAST "explainUpdateResponse")) + { + } + else + { + *p = 0; + return -1; + } + } + else if (o->direction == ODR_ENCODE) { - if (code == p[1]) - return p[0]; - p += 2; + Z_SRW_PDU **p = handler_data; + xmlNsPtr ns_ucp, ns_srw; + + if ((*p)->which == Z_SRW_update_request) + { + Z_SRW_updateRequest *req = (*p)->u.update_request; + xmlNodePtr ptr = xmlNewChild(pptr, 0, BAD_CAST "updateRequest", 0); + ns_ucp = xmlNewNs(ptr, BAD_CAST ns_ucp_str, BAD_CAST "zu"); + xmlSetNs(ptr, ns_ucp); + ns_srw = xmlNewNs(ptr, BAD_CAST ns_srw_str, BAD_CAST "zs"); + + add_xsd_string_ns(ptr, "version", (*p)->srw_version, ns_srw); + add_xsd_string(ptr, "action", req->operation); + add_xsd_string(ptr, "recordIdentifier", req->recordId ); + if (req->recordVersions) + yaz_srw_versions( o, ptr, &req->recordVersions, + &req->num_recordVersions, + client_data, ns_ucp_str); + if (req->record && req->record->recordData_len) + { + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "record", 0); + xmlSetNs(rptr, ns_srw); + yaz_srw_record(o, rptr, req->record, &req->extra_record, + client_data, 0); + } + if (req->extraRequestData_len) + { + add_XML_n(ptr, "extraRequestData", + req->extraRequestData_buf, + req->extraRequestData_len, ns_srw); + } + add_xsd_string(ptr, "stylesheet", req->stylesheet); + add_xsd_string(ptr, "database", req->database); + } + else if ((*p)->which == Z_SRW_update_response) + { + Z_SRW_updateResponse *res = (*p)->u.update_response; + xmlNodePtr ptr = xmlNewChild(pptr, 0, (xmlChar *) + "updateResponse", 0); + ns_ucp = xmlNewNs(ptr, BAD_CAST ns_ucp_str, BAD_CAST "zu"); + xmlSetNs(ptr, ns_ucp); + ns_srw = xmlNewNs(ptr, BAD_CAST ns_srw_str, BAD_CAST "zs"); + + add_xsd_string_ns(ptr, "version", (*p)->srw_version, ns_srw); + add_xsd_string(ptr, "operationStatus", res->operationStatus ); + add_xsd_string(ptr, "recordIdentifier", res->recordId ); + if (res->recordVersions) + yaz_srw_versions(o, ptr, &res->recordVersions, + &res->num_recordVersions, + client_data, ns_ucp_str); + if (res->record && res->record->recordData_len) + { + xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "record", 0); + xmlSetNs(rptr, ns_srw); + yaz_srw_record(o, rptr, res->record, &res->extra_record, + client_data, 0); + } + if (res->num_diagnostics) + { + xmlNsPtr ns_diag = + xmlNewNs(pptr, BAD_CAST YAZ_XMLNS_DIAG_v1_1, + BAD_CAST "diag" ); + + xmlNodePtr rptr = xmlNewChild(ptr, ns_diag, BAD_CAST "diagnostics", 0); + yaz_srw_diagnostics(o, rptr, &res->diagnostics, + &res->num_diagnostics, client_data, + ns_ucp_str); + } + if (res->extraResponseData_len) + add_XML_n(ptr, "extraResponseData", + res->extraResponseData_buf, + res->extraResponseData_len, ns_srw); + } + else + return -1; } - return 1; + return 0; } + +#endif + + +/* + * Local variables: + * c-basic-offset: 4 + * c-file-style: "Stroustrup" + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +