X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fretrieval.c;h=b65a3f39f0ae18b8b89eaf9107e7b6015c500bb7;hp=4c2ee60d9ffeb72111a0eaf9be08a8941579a4db;hb=f24766f1e9fc5404fc0b512af8607d7f7054f4be;hpb=d305f63028800611fd05a3bfc54db24e2634d7ad

diff --git a/src/retrieval.c b/src/retrieval.c
index 4c2ee60..b65a3f3 100644
--- a/src/retrieval.c
+++ b/src/retrieval.c
@@ -1,8 +1,6 @@
-/*
- * Copyright (C) 2005-2006, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) Index Data
  * See the file LICENSE for details.
- *
- * $Id: retrieval.c,v 1.3 2006-05-07 14:48:25 adam Exp $
  */
 /**
  * \file retrieval.c
@@ -19,14 +17,14 @@
 #include <yaz/xmalloc.h>
 #include <yaz/nmem.h>
 #include <yaz/tpath.h>
+#include <yaz/match_glob.h>
 #include <yaz/proto.h>
+#include <yaz/oid_db.h>
 
-#if HAVE_XSLT
+#if YAZ_HAVE_XML2
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <libxml/xinclude.h>
-#include <libxslt/xsltutils.h>
-#include <libxslt/transform.h>
 
 /** \brief The internal structure for yaz_retrieval_t */
 struct yaz_retrieval_struct {
@@ -53,14 +51,15 @@ struct yaz_retrieval_struct {
 struct yaz_retrieval_elem {
     /** \brief schema identifier */
     const char *identifier;
-    /** \brief schema short-hand (such sa "dc") */
-    const char *schema;
+    /** \brief schema name , short-hand such as "dc" */
+    const char *name;
     /** \brief record syntax */
-    int *syntax;
-    /** \brief backend schema */
-    const char *backend_schema;
+    Odr_oid *syntax;
+
+    /** \brief backend name */
+    const char *backend_name;
     /** \brief backend syntax */
-    int *backend_syntax;
+    Odr_oid *backend_syntax;
 
     /** \brief record conversion */
     yaz_record_conv_t record_conv;
@@ -73,9 +72,9 @@ static void yaz_retrieval_reset(yaz_retrieval_t p);
 
 yaz_retrieval_t yaz_retrieval_create()
 {
-    yaz_retrieval_t p = xmalloc(sizeof(*p));
+    yaz_retrieval_t p = (yaz_retrieval_t) xmalloc(sizeof(*p));
     p->odr = odr_createmem(ODR_ENCODE);
-    p->nmem = p->odr->mem;
+    p->nmem = odr_getmem(p->odr);
     p->wr_error = wrbuf_alloc();
     p->list = 0;
     p->path = 0;
@@ -89,7 +88,7 @@ void yaz_retrieval_destroy(yaz_retrieval_t p)
     {
         yaz_retrieval_reset(p);
         odr_destroy(p->odr);
-        wrbuf_free(p->wr_error, 1);
+        wrbuf_destroy(p->wr_error);
         xfree(p->path);
         xfree(p);
     }
@@ -109,16 +108,17 @@ void yaz_retrieval_reset(yaz_retrieval_t p)
 }
 
 /** \brief parse retrieval XML config */
-static int conf_retrieval(yaz_retrieval_t p, const xmlNode *ptr)
+static int conf_retrieval(yaz_retrieval_t p, const xmlNode *ptr,
+                          struct yaz_record_conv_type *types)
 {
-
     struct _xmlAttr *attr;
-    struct yaz_retrieval_elem *el = nmem_malloc(p->nmem, sizeof(*el));
+    struct yaz_retrieval_elem *el = (struct yaz_retrieval_elem *)
+        nmem_malloc(p->nmem, sizeof(*el));
 
     el->syntax = 0;
     el->identifier = 0;
-    el->schema = 0;
-    el->backend_schema = 0;
+    el->name = 0;
+    el->backend_name = 0;
     el->backend_syntax = 0;
 
     el->next = 0;
@@ -128,63 +128,112 @@ static int conf_retrieval(yaz_retrieval_t p, const xmlNode *ptr)
         if (!xmlStrcmp(attr->name, BAD_CAST "syntax") &&
             attr->children && attr->children->type == XML_TEXT_NODE)
         {
-            el->syntax = yaz_str_to_z3950oid(
-                p->odr, CLASS_RECSYN,
-                (const char *) attr->children->content);
+            el->syntax = yaz_string_to_oid_odr(
+                yaz_oid_std(),
+                CLASS_RECSYN,
+                (const char *) attr->children->content,
+                p->odr);
             if (!el->syntax)
             {
-                wrbuf_printf(p->wr_error, "Bad syntax '%s'",
+                wrbuf_printf(p->wr_error, "Element <retrieval>: "
+                             " unknown attribute value syntax='%s'",
                              (const char *) attr->children->content);
                 return -1;
             }
         }
         else if (!xmlStrcmp(attr->name, BAD_CAST "identifier") &&
-            attr->children && attr->children->type == XML_TEXT_NODE)
-            el->identifier =
-                nmem_strdup(p->nmem, (const char *) attr->children->content);
-        else if (!xmlStrcmp(attr->name, BAD_CAST "schema") &&
                  attr->children && attr->children->type == XML_TEXT_NODE)
-            el->schema = 
+            el->identifier =
                 nmem_strdup(p->nmem, (const char *) attr->children->content);
-        else if (!xmlStrcmp(attr->name, BAD_CAST "backendschema") &&
+        else if (!xmlStrcmp(attr->name, BAD_CAST "name") &&
                  attr->children && attr->children->type == XML_TEXT_NODE)
-            el->backend_schema = 
+            el->name =
                 nmem_strdup(p->nmem, (const char *) attr->children->content);
-        else if (!xmlStrcmp(attr->name, BAD_CAST "backendsyntax") &&
-                 attr->children && attr->children->type == XML_TEXT_NODE)
-        {
-            el->backend_syntax = yaz_str_to_z3950oid(
-                p->odr, CLASS_RECSYN,
-                (const char *) attr->children->content);
-            if (!el->backend_syntax)
-            {
-                wrbuf_printf(p->wr_error, "Bad backendsyntax '%s'",
-                             (const char *) attr->children->content);
-                return -1;
-            }
-        }
         else
         {
-            wrbuf_printf(p->wr_error, "Bad attribute '%s'.", attr->name);
+            wrbuf_printf(p->wr_error, "Element <retrieval>: "
+                         " expected attributes 'syntax', identifier' or "
+                         "'name', got '%s'", attr->name);
             return -1;
         }
     }
+
     if (!el->syntax)
     {
-        wrbuf_printf(p->wr_error, "Missing 'syntax' attribute.", attr->name);
+        wrbuf_printf(p->wr_error, "Missing 'syntax' attribute");
         return -1;
     }
 
-    el->record_conv = 0; /* OK to have no 'convert' sub content */
+    /* parsing backend element */
+
+    el->record_conv = 0; /* OK to have no 'backend' sub content */
     for (ptr = ptr->children; ptr; ptr = ptr->next)
     {
-        if (ptr->type == XML_ELEMENT_NODE)
+        if (ptr->type != XML_ELEMENT_NODE)
+            continue;
+        if (strcmp((const char *) ptr->name, "backend"))
+        {
+            wrbuf_printf(p->wr_error, "Element <retrieval>: expected"
+                         " zero or one element <backend>, got <%s>",
+                         (const char *) ptr->name);
+            return -1;
+        }
+        else
         {
+            struct _xmlAttr *attr;
+            if (el->record_conv)
+            {
+                wrbuf_printf(p->wr_error, "Element <retrieval>: "
+                             "only one <backend> allowed");
+                yaz_record_conv_destroy(el->record_conv);
+                return -1;
+            }
+            /* parsing attributees */
+            for (attr = ptr->properties; attr; attr = attr->next)
+            {
+                if (!xmlStrcmp(attr->name, BAD_CAST "name")
+                         && attr->children
+                         && attr->children->type == XML_TEXT_NODE)
+                    el->backend_name
+                        = nmem_strdup(p->nmem,
+                                      (const char *) attr->children->content);
+
+                else if (!xmlStrcmp(attr->name, BAD_CAST "syntax")
+                         && attr->children
+                         && attr->children->type == XML_TEXT_NODE)
+                {
+                    el->backend_syntax
+                        = yaz_string_to_oid_odr(
+                            yaz_oid_std(),
+                            CLASS_RECSYN,
+                            (const char *) attr->children->content,
+                            p->odr);
+                    if (!el->backend_syntax)
+                    {
+                        wrbuf_printf(p->wr_error,
+                                     "Element <backend syntax='%s'>: "
+                                     "attribute 'syntax' has invalid "
+                                     "value '%s'",
+                                     attr->children->content,
+                                     attr->children->content);
+                        return -1;
+                    }
+                }
+                else
+                {
+                    wrbuf_printf(p->wr_error, "Element <backend>: expected "
+                                 "attributes 'syntax' or 'name, got '%s'",
+                                 attr->name);
+                    return -1;
+                }
+            }
+
+             /* parsing internal of record conv */
             el->record_conv = yaz_record_conv_create();
-            
+
             yaz_record_conv_set_path(el->record_conv, p->path);
-        
-            if (yaz_record_conv_configure(el->record_conv, ptr))
+
+            if (yaz_record_conv_configure_t(el->record_conv, ptr, types))
             {
                 wrbuf_printf(p->wr_error, "%s",
                              yaz_record_conv_get_error(el->record_conv));
@@ -193,16 +242,15 @@ static int conf_retrieval(yaz_retrieval_t p, const xmlNode *ptr)
             }
         }
     }
-    
+
     *p->list_p = el;
     p->list_p = &el->next;
     return 0;
 }
 
-int yaz_retrieval_configure(yaz_retrieval_t p, const void *ptr_v)
+int yaz_retrieval_configure_t(yaz_retrieval_t p, const xmlNode *ptr,
+                              struct yaz_record_conv_type *types)
 {
-    const xmlNode *ptr = ptr_v; 
-
     yaz_retrieval_reset(p);
 
     if (ptr && ptr->type == XML_ELEMENT_NODE &&
@@ -214,48 +262,63 @@ int yaz_retrieval_configure(yaz_retrieval_t p, const void *ptr_v)
                 continue;
             if (!strcmp((const char *) ptr->name, "retrieval"))
             {
-                if (conf_retrieval(p, ptr))
+                if (conf_retrieval(p, ptr, types))
                     return -1;
             }
             else
             {
-                wrbuf_printf(p->wr_error, "Bad element '%s'."
-                             " Expected 'retrieval'", ptr->name);
+                wrbuf_printf(p->wr_error, "Element <retrievalinfo>: "
+                             "expected element <retrieval>, got <%s>",
+                             ptr->name);
                 return -1;
             }
         }
     }
     else
     {
-        wrbuf_printf(p->wr_error, "Missing 'retrievalinfo' element");
+        wrbuf_printf(p->wr_error, "Expected element <retrievalinfo>");
         return -1;
     }
     return 0;
 }
 
+int yaz_retrieval_configure(yaz_retrieval_t p, const xmlNode *ptr)
+{
+    return yaz_retrieval_configure_t(p, ptr, 0);
+}
+
 int yaz_retrieval_request(yaz_retrieval_t p,
-                          const char *schema, int *syntax,
-                          const char **match_schema, int **match_syntax,
+                          const char *schema, Odr_oid *syntax,
+                          const char **match_schema, Odr_oid **match_syntax,
                           yaz_record_conv_t *rc,
                           const char **backend_schema,
-                          int **backend_syntax)
+                          Odr_oid **backend_syntax)
 {
     struct yaz_retrieval_elem *el = p->list;
-
     int syntax_matches = 0;
     int schema_matches = 0;
+    struct yaz_retrieval_elem *el_best = 0;
+
+    wrbuf_rewind(p->wr_error);
+    if (!el)
+        return 0;
     for(; el; el = el->next)
     {
         int schema_ok = 0;
         int syntax_ok = 0;
 
-        if (schema && el->schema && !strcmp(schema, el->schema))
-            schema_ok = 1;
-        if (schema && el->identifier && !strcmp(schema, el->identifier))
-            schema_ok = 1;
         if (!schema)
             schema_ok = 1;
-        
+        else
+        {
+            if (el->name && yaz_match_glob(el->name, schema))
+                schema_ok = 2;
+            if (el->identifier && !strcmp(schema, el->identifier))
+                schema_ok = 2;
+            if (!el->name && !el->identifier)
+                schema_ok = 1;
+        }
+
         if (syntax && el->syntax && !oid_oidcmp(syntax, el->syntax))
             syntax_ok = 1;
         if (!syntax)
@@ -267,29 +330,57 @@ int yaz_retrieval_request(yaz_retrieval_t p,
             schema_matches++;
         if (syntax_ok && schema_ok)
         {
-            *match_syntax = el->syntax;
-            *match_schema = el->schema;
-            if (backend_schema)
-                *backend_schema = el->backend_schema;
-            if (backend_syntax)
+            if (!el_best || schema_ok == 2)
+                el_best = el;
+        }
+    }
+    if (el_best)
+    {
+        el = el_best;
+        *match_syntax = el->syntax;
+        if (el->identifier)
+            *match_schema = el->identifier;
+        else
+            *match_schema = 0;
+        if (backend_schema)
+        {
+            if (el->backend_name)
+            {
+                if (*el->backend_name)
+                    *backend_schema = el->backend_name;
+            }
+            else if (el->name)
+                *backend_schema = el->name;
+            else
+                *backend_schema = schema;
+        }
+        if (backend_syntax)
+        {
+            if (el->backend_syntax)
                 *backend_syntax = el->backend_syntax;
-            if (rc)
-                *rc = el->record_conv;
-            return 0;
+            else
+                *backend_syntax = el->syntax;
         }
+        if (rc)
+            *rc = el->record_conv;
+        return 0;
     }
-    if (syntax_matches && !schema_matches)
-        return 1;
-    if (!syntax_matches && schema_matches)
+    if (!syntax_matches && syntax)
+    {
+        char buf[OID_STR_MAX];
+        wrbuf_printf(p->wr_error, "%s", oid_oid_to_dotstring(syntax, buf));
         return 2;
-    if (!syntax_matches && !schema_matches)
-        return 3;
-    return 4;
+    }
+    if (schema)
+        wrbuf_printf(p->wr_error, "%s", schema);
+    if (!schema_matches)
+        return 1;
+    return 3;
 }
 
 const char *yaz_retrieval_get_error(yaz_retrieval_t p)
 {
-    return wrbuf_buf(p->wr_error);
+    return wrbuf_cstr(p->wr_error);
 }
 
 void yaz_retrieval_set_path(yaz_retrieval_t p, const char *path)
@@ -305,6 +396,7 @@ void yaz_retrieval_set_path(yaz_retrieval_t p, const char *path)
 /*
  * Local variables:
  * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
  * indent-tabs-mode: nil
  * End:
  * vim: shiftwidth=4 tabstop=8 expandtab