X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fsrw.c;h=3c77116b825955c56db4ee6b6862964d9dde1cc1;hp=e3f4d72288d850ca85c4cb769085cadbc47cfeed;hb=43a7aff23f364fd3fac6e9746c53cda01be13738;hpb=67f0b922040d236afc88b8d247acca84e5fa0d73

diff --git a/src/srw.c b/src/srw.c
index e3f4d72..3c77116 100644
--- a/src/srw.c
+++ b/src/srw.c
@@ -1,8 +1,12 @@
 /*
- * Copyright (c) 2002-2003, Index Data.
+ * Copyright (C) 1995-2005, Index Data ApS
  * See the file LICENSE for details.
  *
- * $Id: srw.c,v 1.12 2004-01-05 14:05:56 adam Exp $
+ * $Id: srw.c,v 1.36 2005-08-22 20:34:21 adam Exp $
+ */
+/**
+ * \file srw.c
+ * \brief Implements SRW/SRU package encoding and decoding
  */
 
 #include <yaz/srw.h>
@@ -18,7 +22,7 @@ static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len)
         xmlDocPtr doc = xmlParseMemory(val,len);
         if (doc)
         {
-            xmlNodePtr c = xmlNewChild(ptr, 0, elem, 0);
+            xmlNodePtr c = xmlNewChild(ptr, 0, BAD_CAST elem, 0);
             xmlNodePtr t = xmlDocGetRootElement(doc);
             xmlAddChild(c, xmlCopyNode(t,1));
             xmlFreeDoc(doc);
@@ -26,39 +30,40 @@ static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len)
     }
 }
 
-xmlNodePtr 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 t;
     }
     return 0;
 }
 
-xmlNodePtr add_xsd_string(xmlNodePtr ptr, const char *elem, char *val)
+xmlNodePtr add_xsd_string(xmlNodePtr ptr, const char *elem, const char *val)
 {
     if (val)
-        return xmlNewChild(ptr, 0, elem, val);
+        return xmlNewTextChild(ptr, 0, BAD_CAST elem,
+                               BAD_CAST val);
     return 0;
 }
 
-static void add_xsd_integer(xmlNodePtr ptr, const char *elem, int *val)
+static void add_xsd_integer(xmlNodePtr ptr, const char *elem, const int *val)
 {
     if (val)
     {
         char str[30];
         sprintf(str, "%d", *val);
-        xmlNewChild(ptr, 0, elem, str);
+        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;
 }
@@ -91,10 +96,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;
 }
 
@@ -113,12 +121,14 @@ static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o,
     if (!match_element(ptr, elem))
         return 0;
     ptr = ptr->children;
+    while (ptr && (ptr->type == XML_TEXT_NODE || ptr->type == XML_COMMENT_NODE))
+        ptr = ptr->next;
     if (!ptr)
         return 0;
     buf = xmlBufferCreate();
-
+    
     xmlNodeDump(buf, ptr->doc, ptr, 0, 0);
-
+    
     *val = odr_malloc(o, buf->use+1);
     memcpy (*val, buf->content, buf->use);
     (*val)[buf->use] = '\0';
@@ -130,7 +140,6 @@ 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)
 {
@@ -158,70 +167,70 @@ 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, atoi((const char *) ptr->content));
     return 1;
 }
 
 static int yaz_srw_record(ODR o, xmlNodePtr pptr, Z_SRW_record *rec,
-			  void *client_data, const char *ns)
+                          void *client_data, const char *ns)
 {
     if (o->direction == ODR_DECODE)
     {
-	int pack = Z_SRW_recordPacking_string;
-	xmlNodePtr ptr;
-	rec->recordSchema = 0;
-	rec->recordData_buf = 0;
-	rec->recordData_len = 0;
-	rec->recordPosition = 0;
-	for (ptr = pptr->children; ptr; ptr = ptr->next)
-	{
-	    char *spack = 0;
-	    
-	    if (match_xsd_string(ptr, "recordSchema", o, 
-				 &rec->recordSchema))
-		;
-	    else if (match_xsd_string(ptr, "recordPacking", o, &spack))
-	    {
-		if (pack && !strcmp(spack, "xml"))
-		    pack = Z_SRW_recordPacking_XML;
-		if (pack && !strcmp(spack, "string"))
-		    pack = Z_SRW_recordPacking_string;
-	    }
-	    else if (match_xsd_integer(ptr, "recordPosition", o, 
-				       &rec->recordPosition))
-		;
-	    else 
-	    {
-		if (pack == Z_SRW_recordPacking_XML)
-		    match_xsd_XML_n(ptr, "recordData", o, 
-				    &rec->recordData_buf,
-				    &rec->recordData_len);
-		if (pack == Z_SRW_recordPacking_string)
-		    match_xsd_string_n(ptr, "recordData", o, 
-				       &rec->recordData_buf,
-				       &rec->recordData_len);
-	    }
-	}
-	rec->recordPacking = pack;
+        int pack = Z_SRW_recordPacking_string;
+        xmlNodePtr ptr;
+        rec->recordSchema = 0;
+        rec->recordData_buf = 0;
+        rec->recordData_len = 0;
+        rec->recordPosition = 0;
+        for (ptr = pptr->children; ptr; ptr = ptr->next)
+        {
+            char *spack = 0;
+            
+            if (match_xsd_string(ptr, "recordSchema", o, 
+                                 &rec->recordSchema))
+                ;
+            else if (match_xsd_string(ptr, "recordPacking", o, &spack))
+            {
+                if (spack && !strcmp(spack, "xml"))
+                    pack = Z_SRW_recordPacking_XML;
+                if (spack && !strcmp(spack, "string"))
+                    pack = Z_SRW_recordPacking_string;
+            }
+            else if (match_xsd_integer(ptr, "recordPosition", o, 
+                                       &rec->recordPosition))
+                ;
+            else 
+            {
+                if (pack == Z_SRW_recordPacking_XML)
+                    match_xsd_XML_n(ptr, "recordData", o, 
+                                    &rec->recordData_buf,
+                                    &rec->recordData_len);
+                if (pack == Z_SRW_recordPacking_string)
+                    match_xsd_string_n(ptr, "recordData", o, 
+                                       &rec->recordData_buf,
+                                       &rec->recordData_len);
+            }
+        }
+        rec->recordPacking = pack;
     }
     else if (o->direction == ODR_ENCODE)
     {
-	xmlNodePtr ptr = pptr;
-	add_xsd_string(ptr, "recordSchema", rec->recordSchema);
-	switch(rec->recordPacking)
-	{
-	case Z_SRW_recordPacking_string:
-	    add_xsd_string(ptr, "recordPacking", "string");
-	    add_xsd_string_n(ptr, "recordData", rec->recordData_buf,
-			     rec->recordData_len);
-	    break;
-	case Z_SRW_recordPacking_XML:
-	    add_xsd_string(ptr, "recordPacking", "xml");
-	    add_XML_n(ptr, "recordData", rec->recordData_buf,
-		      rec->recordData_len);
-	    break;
-	}
-	add_xsd_integer(ptr, "recordPosition", rec->recordPosition);
+        xmlNodePtr ptr = pptr;
+        add_xsd_string(ptr, "recordSchema", rec->recordSchema);
+        switch(rec->recordPacking)
+        {
+        case Z_SRW_recordPacking_string:
+            add_xsd_string(ptr, "recordPacking", "string");
+            add_xsd_string_n(ptr, "recordData", rec->recordData_buf,
+                             rec->recordData_len);
+            break;
+        case Z_SRW_recordPacking_XML:
+            add_xsd_string(ptr, "recordPacking", "xml");
+            add_XML_n(ptr, "recordData", rec->recordData_buf,
+                      rec->recordData_len);
+            break;
+        }
+        add_xsd_integer(ptr, "recordPosition", rec->recordPosition);
     }
     return 0;
 }
@@ -237,17 +246,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));
+        for (i = 0, ptr = pptr->children; ptr; ptr = ptr->next)
         {
             if (ptr->type == XML_ELEMENT_NODE &&
-                !strcmp(ptr->name, "record"))
-		yaz_srw_record(o, ptr, (*recs)+i, client_data, ns);
+                !xmlStrcmp(ptr->name, BAD_CAST "record"))
+            {
+                yaz_srw_record(o, ptr, (*recs)+i, client_data, ns);
+                i++;
+            }
         }
     }
     else if (o->direction == ODR_ENCODE)
@@ -255,8 +267,9 @@ 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);
-	    yaz_srw_record(o, rptr, (*recs)+i, client_data, ns);
+            xmlNodePtr rptr = xmlNewChild(pptr, 0, BAD_CAST "record",
+                                          0);
+            yaz_srw_record(o, rptr, (*recs)+i, client_data, ns);
         }
     }
     return 0;
@@ -273,33 +286,38 @@ 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 "diagnostic"))
                 (*num)++;
         }
         if (!*num)
             return 1;
-        *recs = odr_malloc(o, *num * sizeof(**recs));
-	for (i = 0; i < *num; i++)
-	{
-            (*recs)[i].code = 0;
+        *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->children; ptr; ptr = ptr->next)
         {
             if (ptr->type == XML_ELEMENT_NODE &&
-                !strcmp(ptr->name, "diagnostic"))
+                !xmlStrcmp(ptr->name, BAD_CAST "diagnostic"))
             {
                 xmlNodePtr rptr;
-                (*recs)[i].code = 0;
+                (*recs)[i].uri = 0;
                 (*recs)[i].details = 0;
+                (*recs)[i].message = 0;
                 for (rptr = ptr->children; rptr; rptr = rptr->next)
                 {
-                    if (match_xsd_integer(rptr, "code", o, 
-                                               &(*recs)[i].code))
+                    if (match_xsd_string(rptr, "uri", o, 
+                                         &(*recs)[i].uri))
                         ;
                     else if (match_xsd_string(rptr, "details", o, 
                                               &(*recs)[i].details))
                         ;
+                    else if (match_xsd_string(rptr, "message", o, 
+                                              &(*recs)[i].message))
+                        ;
                 }
                 i++;
             }
@@ -308,12 +326,25 @@ static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs,
     else if (o->direction == ODR_ENCODE)
     {
         int i;
-	xmlNsPtr ns_diag =
-	    xmlNewNs(pptr, "http://www.loc.gov/zing/srw/diagnostics/", "diag");
+        xmlNsPtr ns_diag =
+            xmlNewNs(pptr, BAD_CAST
+                     "http://www.loc.gov/zing/srw/diagnostic/", 0);
         for (i = 0; i < *num; i++)
         {
-            xmlNodePtr rptr = xmlNewChild(pptr, ns_diag, "diagnostic", 0);
-            add_xsd_integer(rptr, "code", (*recs)[i].code);
+            const char *std_diag = "info:srw/diagnostic/1/";
+            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 && 
+                     !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);
+            }
             add_xsd_string(rptr, "details", (*recs)[i].details);
         }
     }
@@ -321,38 +352,43 @@ static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs,
 }
 
 static int yaz_srw_term(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm *term,
-			void *client_data, const char *ns)
+                        void *client_data, const char *ns)
 {
     if (o->direction == ODR_DECODE)
     {
-	xmlNodePtr ptr;
-	term->value = 0;
-	term->numberOfRecords = 0;
-	term->displayTerm = 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))
-		;
-	}
+        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 if (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, "value", term->numberOfRecords);
-	add_xsd_string(ptr, "displayTerm", term->displayTerm);
+        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)
+                         int *num, void *client_data, const char *ns)
 {
     if (o->direction == ODR_DECODE)
     {
@@ -362,17 +398,17 @@ static int yaz_srw_terms(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm **terms,
         for (ptr = pptr->children; ptr; ptr = ptr->next)
         {
             if (ptr->type == XML_ELEMENT_NODE &&
-                !strcmp(ptr->name, "term"))
+                !xmlStrcmp(ptr->name, BAD_CAST "term"))
                 (*num)++;
         }
         if (!*num)
             return 1;
-        *terms = odr_malloc(o, *num * sizeof(**terms));
+        *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 &&
-                !strcmp(ptr->name, "term"))
-		yaz_srw_term(o, ptr, (*terms)+i, client_data, ns);
+                !xmlStrcmp(ptr->name, BAD_CAST "term"))
+                yaz_srw_term(o, ptr, (*terms)+i, client_data, ns);
         }
     }
     else if (o->direction == ODR_ENCODE)
@@ -380,8 +416,8 @@ static int yaz_srw_terms(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm **terms,
         int i;
         for (i = 0; i < *num; i++)
         {
-            xmlNodePtr rptr = xmlNewChild(pptr, 0, "term", 0);
-	    yaz_srw_term(o, rptr, (*terms)+i, client_data, ns);
+            xmlNodePtr rptr = xmlNewChild(pptr, 0, BAD_CAST "term", 0);
+            yaz_srw_term(o, rptr, (*terms)+i, client_data, ns);
         }
     }
     return 0;
@@ -390,30 +426,31 @@ static int yaz_srw_terms(ODR o, xmlNodePtr pptr, Z_SRW_scanTerm **terms,
 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;
+        Z_SRW_PDU **p = handler_data;
         xmlNodePtr method = pptr->children;
 
         while (method && method->type == XML_TEXT_NODE)
             method = method->next;
         
-	if (!method)
-	    return -1;
+        if (!method)
+            return -1;
         if (method->type != XML_ELEMENT_NODE)
             return -1;
 
-	*p = odr_malloc(o, sizeof(**p));
-	(*p)->srw_version = odr_strdup(o, "1.1");
-	
-        if (!strcmp(method->name, "searchRetrieveRequest"))
+        *p = (Z_SRW_PDU *) odr_malloc(o, sizeof(**p));
+        (*p)->srw_version = odr_strdup(o, "1.1");
+        
+        if (!xmlStrcmp(method->name, BAD_CAST "searchRetrieveRequest"))
         {
             xmlNodePtr ptr = method->children;
             Z_SRW_searchRetrieveRequest *req;
 
             (*p)->which = Z_SRW_searchRetrieve_request;
-            req = (*p)->u.request = odr_malloc(o, sizeof(*req));
+            req = (*p)->u.request = (Z_SRW_searchRetrieveRequest *)
+                odr_malloc(o, sizeof(*req));
             req->query_type = Z_SRW_query_type_cql;
             req->query.cql = 0;
             req->sort_type = Z_SRW_sort_type_none;
@@ -422,14 +459,17 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
             req->maximumRecords = 0;
             req->recordSchema = 0;
             req->recordPacking = 0;
-	    req->recordXPath = 0;
-	    req->resultSetTTL = 0;
-	    req->stylesheet = 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, 
+                if (match_xsd_string(ptr, "version", o,
+                                     &(*p)->srw_version))
+                    ;
+                else 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, 
@@ -438,46 +478,44 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
                 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))
+                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, "recordPacking", o,
                                           &req->recordPacking))
                     ;
+                else if (match_xsd_string(ptr, "recordSchema", o, 
+                                          &req->recordSchema))
+                    ;
                 else if (match_xsd_string(ptr, "recordXPath", o,
                                           &req->recordXPath))
                     ;
-                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, "resultSetTTL", o,
+                                           &req->database))
                     ;
+                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, "resultSetTTL", o,
-                                           &req->database))
-                    ;
-                else if (match_xsd_string(ptr, "version", o,
-                                           &(*p)->srw_version))
-                    ;
                 /* missing is xQuery, xSortKeys .. */
             }
         }
-        else if (!strcmp(method->name, "searchRetrieveResponse"))
+        else if (!xmlStrcmp(method->name, BAD_CAST "searchRetrieveResponse"))
         {
             xmlNodePtr ptr = method->children;
             Z_SRW_searchRetrieveResponse *res;
 
             (*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->resultSetId = 0;
@@ -490,7 +528,10 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
 
             for (; ptr; ptr = ptr->next)
             {
-                if (match_xsd_integer(ptr, "numberOfRecords", o, 
+                if (match_xsd_string(ptr, "version", o,
+                                     &(*p)->srw_version))
+                    ;
+                else if (match_xsd_integer(ptr, "numberOfRecords", o, 
                                       &res->numberOfRecords))
                     ;
                 else if (match_xsd_string(ptr, "resultSetId", o, 
@@ -503,147 +544,162 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
                     yaz_srw_records(o, ptr, &res->records,
                                     &res->num_records, client_data,
                                     ns);
+                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_xsd_string(ptr, "version", o,
-                                           &(*p)->srw_version))
-                    ;
             }
         }
-        else if (!strcmp(method->name, "explainRequest"))
+        else if (!xmlStrcmp(method->name, BAD_CAST "explainRequest"))
         {
             Z_SRW_explainRequest *req;
-	    xmlNodePtr ptr = method->children;
+            xmlNodePtr ptr = method->children;
             
             (*p)->which = Z_SRW_explain_request;
-            req = (*p)->u.explain_request = odr_malloc(o, sizeof(*req));
-	    req->recordPacking = 0;
-	    req->database = 0;
-	    for (; ptr; ptr = ptr->next)
-	    {
-		if (match_xsd_string(ptr, "database", o,
-				     &req->database))
-                    ;
-		else if (match_xsd_string(ptr, "recordPacking", o,
-				     &req->recordPacking))
-		    ;
-                else if (match_xsd_string(ptr, "version", o,
+            req = (*p)->u.explain_request = (Z_SRW_explainRequest *)
+                odr_malloc(o, sizeof(*req));
+            req->recordPacking = 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_string(ptr, "stylesheet", o,
+                                          &req->stylesheet))
+                    ;
+                else if (match_xsd_string(ptr, "recordPacking", o,
+                                     &req->recordPacking))
+                    ;
+                else if (match_xsd_string(ptr, "database", o,
+                                     &req->database))
+                    ;
+            }
         }
-        else if (!strcmp(method->name, "explainResponse"))
+        else if (!xmlStrcmp(method->name, BAD_CAST "explainResponse"))
         {
             Z_SRW_explainResponse *res;
             xmlNodePtr ptr = method->children;
 
             (*p)->which = Z_SRW_explain_response;
-            res = (*p)->u.explain_response = odr_malloc(o, sizeof(*res));
+            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)
-	    {
-		if (match_element(ptr, "record"))
-		    yaz_srw_record(o, ptr, &res->record, client_data, ns);
-                else if (match_xsd_string(ptr, "version", o,
-					  &(*p)->srw_version))
-		    ;
-		else if (match_element(ptr, "diagnostics"))
+            for (; ptr; ptr = ptr->next)
+            {
+                if (match_xsd_string(ptr, "version", o,
+                                           &(*p)->srw_version))
+                    ;
+                else if (match_element(ptr, "record"))
+                    yaz_srw_record(o, ptr, &res->record, client_data, ns);
+                else if (match_element(ptr, "diagnostics"))
                     yaz_srw_diagnostics(o, ptr, &res->diagnostics,
                                         &res->num_diagnostics,
                                         client_data, ns);
-		;
-	    }
+                ;
+            }
         }
-        else if (!strcmp(method->name, "scanRequest"))
+        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 = odr_malloc(o, sizeof(*req));
-	    req->database = 0;
-	    req->scanClause = 0;
-	    req->stylesheet = 0;
-	    req->responsePosition = 0;
-	    req->maximumTerms = 0;
-	    
-	    for (; ptr; ptr = ptr->next)
-	    {
-		if (match_xsd_string(ptr, "version", o,
-				     &(*p)->srw_version))
-		    ;
-		else if (match_xsd_string(ptr, "scanClause", o,
-				     &req->scanClause))
-		    ;
-		else if (match_xsd_string(ptr, "database", o,
-					  &req->database))
+            req = (*p)->u.scan_request = (Z_SRW_scanRequest *)
+                odr_malloc(o, sizeof(*req));
+            req->query_type = Z_SRW_query_type_cql;
+            req->scanClause.cql = 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_string(ptr, "scanClause", o,
+                                     &req->scanClause.cql))
                     ;
-		else if (match_xsd_string(ptr, "stylesheet", o,
-					  &req->stylesheet))
-		    ;
-		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, "pScanClause", o,
+                                          &req->scanClause.pqf))
+                {
+                    req->query_type = Z_SRW_query_type_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 if (match_xsd_string(ptr, "database", o,
+                                          &req->database))
                     ;
-	    }
+            }
         }
-        else if (!strcmp(method->name, "scanResponse"))
+        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 = 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_element(ptr, "terms"))
+            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_element(ptr, "terms"))
                     yaz_srw_terms(o, ptr, &res->terms,
-				  &res->num_terms, client_data,
-				  ns);
-		else if (match_element(ptr, "diagnostics"))
+                                  &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 if (match_xsd_string(ptr, "version", o,
-					  &(*p)->srw_version))
-		    ;
-	    }
+            }
         }
         else
-	{
-	    *p = 0;
+        {
+            *p = 0;
             return -1;
-	}
+        }
     }
     else if (o->direction == ODR_ENCODE)
     {
         Z_SRW_PDU **p = handler_data;
-	xmlNsPtr ns_srw;
-	
+        xmlNsPtr ns_srw;
+        
         if ((*p)->which == Z_SRW_searchRetrieve_request)
         {
             Z_SRW_searchRetrieveRequest *req = (*p)->u.request;
             xmlNodePtr ptr = xmlNewChild(pptr, 0,
-                                         "searchRetrieveRequest", 0);
-	    ns_srw = xmlNewNs(ptr, ns, "zs");
-	    xmlSetNs(ptr, ns_srw);
+                                         BAD_CAST "searchRetrieveRequest", 0);
+            ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs");
+            xmlSetNs(ptr, ns_srw);
 
-	    if ((*p)->srw_version)
-		add_xsd_string(ptr, "version", (*p)->srw_version);
+            if ((*p)->srw_version)
+                add_xsd_string(ptr, "version", (*p)->srw_version);
             switch(req->query_type)
             {
             case Z_SRW_query_type_cql:
@@ -656,6 +712,12 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
                 add_xsd_string(ptr, "pQuery", req->query.pqf);
                 break;
             }
+            add_xsd_integer(ptr, "startRecord", req->startRecord);
+            add_xsd_integer(ptr, "maximumRecords", req->maximumRecords);
+            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:
@@ -667,102 +729,115 @@ 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, "recordXPath", req->recordXPath);
-            add_xsd_string(ptr, "database", req->database);
-            add_xsd_integer(ptr, "resultSetTTL", req->resultSetTTL);
             add_xsd_string(ptr, "stylesheet", req->stylesheet);
+            add_xsd_string(ptr, "database", req->database);
         }
         else if ((*p)->which == Z_SRW_searchRetrieve_response)
         {
             Z_SRW_searchRetrieveResponse *res = (*p)->u.response;
             xmlNodePtr ptr = xmlNewChild(pptr, 0,
-                                         "searchRetrieveResponse", 0);
-	    ns_srw = xmlNewNs(ptr, ns, "zs");
-	    xmlSetNs(ptr, ns_srw);
+                                         BAD_CAST "searchRetrieveResponse", 0);
+            ns_srw = xmlNewNs(ptr, BAD_CAST ns, BAD_CAST "zs");
+            xmlSetNs(ptr, ns_srw);
 
-	    if ((*p)->srw_version)
-		add_xsd_string(ptr, "version", (*p)->srw_version);
+            if ((*p)->srw_version)
+                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);
             if (res->num_records)
             {
-                xmlNodePtr rptr = xmlNewChild(ptr, 0, "records", 0);
+                xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "records", 0);
                 yaz_srw_records(o, rptr, &res->records, &res->num_records,
                                 client_data, ns);
             }
+            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);
         }
         else if ((*p)->which == Z_SRW_explain_request)
         {
-            xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainRequest", 0);
-	    ns_srw = xmlNewNs(ptr, ns, "zs");
-	    xmlSetNs(ptr, ns_srw);
+            Z_SRW_explainRequest *req = (*p)->u.explain_request;
+            xmlNodePtr 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);
+            add_xsd_string(ptr, "version", (*p)->srw_version);
+            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);
-	    ns_srw = xmlNewNs(ptr, ns, "zs");
-	    xmlSetNs(ptr, ns_srw);
-
-	    add_xsd_string(ptr, "version", (*p)->srw_version);
-	    if (1)
-	    {
-		xmlNodePtr ptr1 = xmlNewChild(ptr, 0, "record", 0);
-		yaz_srw_record(o, ptr1, &res->record, client_data, ns);
-	    }
-	    if (res->num_diagnostics)
-	    {
-		xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0);
-		yaz_srw_diagnostics(o, rptr, &res->diagnostics,
+            xmlNodePtr 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, 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 if ((*p)->which == Z_SRW_scan_request)
         {
             Z_SRW_scanRequest *req = (*p)->u.scan_request;
-            xmlNodePtr ptr = xmlNewChild(pptr, 0, "scanRequest", 0);
-	    ns_srw = xmlNewNs(ptr, ns, "zs");
-	    xmlSetNs(ptr, ns_srw);
-
-	    add_xsd_string(ptr, "version", (*p)->srw_version);
-	    add_xsd_string(ptr, "scanClause", req->scanClause);
-	    add_xsd_integer(ptr, "responsePosition", req->responsePosition);
-	    add_xsd_integer(ptr, "maximumTerms", req->maximumTerms);
-	    add_xsd_string(ptr, "stylesheet", req->stylesheet);
+            xmlNodePtr 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(ptr, "version", (*p)->srw_version);
+            switch(req->query_type)
+            {
+            case Z_SRW_query_type_cql:
+                add_xsd_string(ptr, "scanClause", req->scanClause.cql);
+                break;
+            case Z_SRW_query_type_pqf:
+                add_xsd_string(ptr, "pScanClause", req->scanClause.pqf);
+                break;
+            }
+            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;
-            xmlNodePtr ptr = xmlNewChild(pptr, 0, "scanResponse", 0);
-	    ns_srw = xmlNewNs(ptr, ns, "zs");
-	    xmlSetNs(ptr, ns_srw);
+            xmlNodePtr 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);
+            add_xsd_string(ptr, "version", (*p)->srw_version);
 
             if (res->num_terms)
             {
-                xmlNodePtr rptr = xmlNewChild(ptr, 0, "terms", 0);
+                xmlNodePtr rptr = xmlNewChild(ptr, 0, BAD_CAST "terms", 0);
                 yaz_srw_terms(o, rptr, &res->terms, &res->num_terms,
-			      client_data, ns);
+                              client_data, ns);
             }
-	    if (res->num_diagnostics)
-	    {
-		xmlNodePtr rptr = xmlNewChild(ptr, 0, "diagnostics", 0);
-		yaz_srw_diagnostics(o, rptr, &res->diagnostics,
+            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);
             }
         }
@@ -776,3 +851,11 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data,
 #endif
 
 
+/*
+ * Local variables:
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ * vim: shiftwidth=4 tabstop=8 expandtab
+ */
+