X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=src%2Fpazpar2_config.c;h=290a39a7ea25a47ecf3ea90c39a701172eec5817;hb=24ad8ea356d71c764af19897e2719670a94a3a05;hp=6e7652c4aab67faa45c2d3f6afe1e4987e4c4c31;hpb=8961ed761e348e972f00d015284ce75c16b1648c;p=pazpar2-moved-to-github.git

diff --git a/src/pazpar2_config.c b/src/pazpar2_config.c
index 6e7652c..290a39a 100644
--- a/src/pazpar2_config.c
+++ b/src/pazpar2_config.c
@@ -1,5 +1,5 @@
 /* This file is part of Pazpar2.
-   Copyright (C) 2006-2012 Index Data
+   Copyright (C) Index Data
 
 Pazpar2 is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
@@ -26,6 +26,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include <libxml/parser.h>
 #include <libxml/tree.h>
+#include <libxml/xinclude.h>
 
 #include <yaz/yaz-util.h>
 #include <yaz/nmem.h>
@@ -52,9 +53,10 @@ struct conf_config
     struct conf_server *servers;
 
     int no_threads;
+    int max_sockets;
     WRBUF confdir;
+    char *path;
     iochan_man_t iochan_man;
-    database_hosts_t database_hosts;
 };
 
 struct service_xslt
@@ -64,52 +66,34 @@ struct service_xslt
     struct service_xslt *next;
 };
 
-static void conf_metadata_assign(NMEM nmem,
-                                 struct conf_metadata * metadata,
-                                 const char *name,
-                                 enum conf_metadata_type type,
-                                 enum conf_metadata_merge merge,
-                                 enum conf_setting_type setting,
-                                 int brief,
-                                 int termlist,
-                                 const char *rank,
-                                 int sortkey_offset,
-                                 enum conf_metadata_mergekey mt,
-                                 const char *facetrule,
-                                 const char *limitmap)
+static char *xml_context(const xmlNode *ptr, char *res, size_t len)
 {
-    assert(nmem && metadata && name);
+    xmlAttr *attr = ptr->properties;
+    size_t off = len - 1;
 
-    metadata->name = nmem_strdup(nmem, name);
-
-    metadata->type = type;
-
-    // enforcing that type_year is always range_merge
-    if (metadata->type == Metadata_type_year)
-        metadata->merge = Metadata_merge_range;
-    else
-        metadata->merge = merge;
-
-    metadata->setting = setting;
-    metadata->brief = brief;
-    metadata->termlist = termlist;
-    metadata->rank = nmem_strdup_null(nmem, rank);
-    metadata->sortkey_offset = sortkey_offset;
-    metadata->mergekey = mt;
-    metadata->facetrule = nmem_strdup_null(nmem, facetrule);
-    metadata->limitmap = nmem_strdup_null(nmem, limitmap);
-}
+    res[off] = '\0';
+    for (; attr; attr = attr->next)
+    {
+        size_t l = strlen((const char *) attr->name);
+        if (off <= l + 1)
+            break;
+        off = off - l;
+        memcpy(res + off, attr->name, l);
+        res[--off] = '@';
+    }
+    while (ptr && ptr->type == XML_ELEMENT_NODE)
+    {
+        size_t l = strlen((const char *) ptr->name);
+        if (off <= l + 1)
+            break;
 
+        off = off - l;
+        memcpy(res + off, ptr->name, l);
+        res[--off] = '/';
 
-static void conf_sortkey_assign(NMEM nmem,
-                                struct conf_sortkey * sortkey,
-                                const char *name,
-                                enum conf_sortkey_type type)
-{
-    assert(nmem && sortkey && name);
-
-    sortkey->name = nmem_strdup(nmem, name);
-    sortkey->type = type;
+        ptr = ptr->parent;
+    }
+    return res + off;
 }
 
 struct conf_service *service_init(struct conf_server *server,
@@ -133,10 +117,15 @@ struct conf_service *service_init(struct conf_server *server,
     service->z3950_session_timeout = 180;
     service->z3950_operation_timeout = 30;
     service->rank_cluster = 1;
+    service->rank_debug = 0;
+    service->rank_follow = 0.0;
+    service->rank_lead = 0.0;
+    service->rank_length = 2;
 
     service->charsets = 0;
 
     service->id = service_id ? nmem_strdup(nmem, service_id) : 0;
+
     // Setup a dictionary from server.
     service->dictionary = 0;
 
@@ -156,13 +145,14 @@ struct conf_service *service_init(struct conf_server *server,
             = nmem_malloc(nmem,
                           sizeof(struct conf_metadata) * service->num_metadata);
     service->num_sortkeys = num_sortkeys;
+
+    service->default_sort = nmem_strdup(nmem, "relevance");
     service->sortkeys = 0;
     if (service->num_sortkeys)
         service->sortkeys
             = nmem_malloc(nmem,
                           sizeof(struct conf_sortkey) * service->num_sortkeys);
-
-
+    service->xml_node = 0;
     return service;
 }
 
@@ -179,38 +169,63 @@ static struct conf_metadata* conf_service_add_metadata(
     int sortkey_offset,
     enum conf_metadata_mergekey mt,
     const char *facetrule,
-    const char *limitmap
+    const char *limitmap,
+    const char *limitcluster,
+    const char *icurule
     )
 {
     struct conf_metadata * md = 0;
+    NMEM nmem = service->nmem;
 
-    if (!service || !service->metadata || !service->num_metadata
+    if (!service->metadata || !service->num_metadata
         || field_id < 0  || !(field_id < service->num_metadata))
         return 0;
 
     md = service->metadata + field_id;
-    conf_metadata_assign(service->nmem, md, name, type, merge, setting,
-                         brief, termlist, rank, sortkey_offset,
-                         mt, facetrule, limitmap);
+    assert(nmem && md && name);
+
+    md->name = nmem_strdup(nmem, name);
+
+    md->type = type;
+
+    // enforcing that type_year is always range_merge
+    if (md->type == Metadata_type_year)
+        md->merge = Metadata_merge_range;
+    else
+        md->merge = merge;
+
+    md->setting = setting;
+    md->brief = brief;
+    md->termlist = termlist;
+    md->rank = nmem_strdup_null(nmem, rank);
+    md->sortkey_offset = sortkey_offset;
+    md->mergekey = mt;
+    md->facetrule = nmem_strdup_null(nmem, facetrule);
+    md->limitmap = nmem_strdup_null(nmem, limitmap);
+    md->limitcluster = nmem_strdup_null(nmem, limitcluster);
+    md->icurule = nmem_strdup_null(nmem, icurule);
     return md;
 }
 
-static struct conf_sortkey * conf_service_add_sortkey(
+static struct conf_sortkey *conf_service_add_sortkey(
     struct conf_service *service,
     int field_id,
     const char *name,
-    enum conf_sortkey_type type)
+    enum conf_metadata_type type)
 {
-    struct conf_sortkey * sk = 0;
+    struct conf_sortkey *sk = 0;
+    NMEM nmem = service->nmem;
 
-    if (!service || !service->sortkeys || !service->num_sortkeys
+    if (!service->sortkeys || !service->num_sortkeys
         || field_id < 0 || !(field_id < service->num_sortkeys))
         return 0;
 
-    //sk = &((service->sortkeys)[field_id]);
     sk = service->sortkeys + field_id;
-    conf_sortkey_assign(service->nmem, sk, name, type);
 
+    assert(nmem && sk && name);
+
+    sk->name = nmem_strdup(nmem, name);
+    sk->type = type;
     return sk;
 }
 
@@ -244,13 +259,20 @@ int conf_service_sortkey_field_id(struct conf_service *service,
 
 static void conf_dir_path(struct conf_config *config, WRBUF w, const char *src)
 {
-    if (config->confdir && wrbuf_len(config->confdir) > 0 &&
-        !yaz_is_abspath(src))
+    char full_path[1024];
+    if (yaz_filepath_resolve(src, config->path,
+                             wrbuf_len(config->confdir) > 0 ?
+                             wrbuf_cstr(config->confdir) : ".",
+                             full_path))
     {
-        wrbuf_printf(w, "%s/%s", wrbuf_cstr(config->confdir), src);
+        wrbuf_puts(w, full_path);
     }
     else
+    {
+        yaz_log(YLOG_WARN, "File not found: fname=%s path=%s base=%s", src,
+                config->path, wrbuf_cstr(config->confdir));
         wrbuf_puts(w, src);
+    }
 }
 
 void service_destroy(struct conf_service *service)
@@ -270,8 +292,6 @@ void service_destroy(struct conf_service *service)
 
 void service_incref(struct conf_service *service)
 {
-    yaz_log(YLOG_LOG, "service_incref. p=%p cnt=%d", service,
-            service->ref_count);
     pazpar2_incref(&service->ref_count, service->mutex);
 }
 
@@ -295,9 +315,14 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
     xmlChar *xml_setting = 0;
     xmlChar *xml_mergekey = 0;
     xmlChar *xml_limitmap = 0;
+    xmlChar *xml_limitcluster = 0;
     xmlChar *xml_icu_chain = 0;
+    xmlChar *xml_icurule = 0;
 
     struct _xmlAttr *attr;
+
+    assert(service);
+
     for (attr = n->properties; attr; attr = attr->next)
     {
         if (!xmlStrcmp(attr->name, BAD_CAST "name") &&
@@ -333,6 +358,12 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
         else if (!xmlStrcmp(attr->name, BAD_CAST "limitmap") &&
                  attr->children && attr->children->type == XML_TEXT_NODE)
             xml_limitmap = attr->children->content;
+        else if (!xmlStrcmp(attr->name, BAD_CAST "limitcluster") &&
+                 attr->children && attr->children->type == XML_TEXT_NODE)
+            xml_limitcluster = attr->children->content;
+        else if (!xmlStrcmp(attr->name, BAD_CAST "icurule") &&
+                 attr->children && attr->children->type == XML_TEXT_NODE)
+            xml_icurule = attr->children->content;
         else
         {
             yaz_log(YLOG_FATAL, "Unknown metadata attribute '%s'", attr->name);
@@ -376,6 +407,8 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
             type = Metadata_type_year;
         else if (!strcmp((const char *) xml_type, "date"))
             type = Metadata_type_date;
+        else if (!strcmp((const char *) xml_type, "float"))
+            type = Metadata_type_float;
         else
         {
             yaz_log(YLOG_FATAL,
@@ -396,6 +429,8 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
             merge = Metadata_merge_range;
         else if (!strcmp((const char *) xml_merge, "all"))
             merge = Metadata_merge_all;
+        else if (!strcmp((const char *) xml_merge, "first"))
+            merge = Metadata_merge_first;
         else
         {
             yaz_log(YLOG_FATAL,
@@ -415,7 +450,7 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
         else
         {
             yaz_log(YLOG_FATAL,
-                    "Unknown value for medadata/setting: %s", xml_setting);
+                    "Unknown value for metadata/setting: %s", xml_setting);
             return -1;
         }
     }
@@ -423,17 +458,29 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
     // add a sortkey if so specified
     if (xml_sortkey && strcmp((const char *) xml_sortkey, "no"))
     {
-        enum conf_sortkey_type sk_type;
+        enum conf_metadata_type sk_type = type;
         if (merge == Metadata_merge_no)
         {
             yaz_log(YLOG_FATAL,
                     "Can't specify sortkey on a non-merged field");
             return -1;
         }
+        if (!strcmp((const char *) xml_sortkey, "yes"))
+            ;
         if (!strcmp((const char *) xml_sortkey, "numeric"))
-            sk_type = Metadata_sortkey_numeric;
+            ;
         else if (!strcmp((const char *) xml_sortkey, "skiparticle"))
-            sk_type = Metadata_sortkey_skiparticle;
+        {
+            if (sk_type == Metadata_type_generic)
+                sk_type = Metadata_type_skiparticle;
+            else
+            {
+                yaz_log(YLOG_FATAL,
+                        "skiparticle only supported for type=generic: %s",
+                    xml_type);
+                return -1;
+            }
+        }
         else
         {
             yaz_log(YLOG_FATAL,
@@ -473,11 +520,26 @@ static int parse_metadata(struct conf_service *service, xmlNode *n,
                               (const char *) xml_rank, sortkey_offset,
                               mergekey_type,
                               (const char *) xml_icu_chain,
-                              (const char *) xml_limitmap);
+                              (const char *) xml_limitmap,
+                              (const char *) xml_limitcluster,
+                              (const char *) xml_icurule
+        );
     (*md_node)++;
     return 0;
 }
 
+
+static void count_metadata(xmlNode *n, int *num_metadata, int *num_sortkeys)
+{
+    xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
+    (*num_metadata)++;
+
+    if (sortkey && strcmp((const char *) sortkey, "no"))
+        (*num_sortkeys)++;
+    xmlFree(sortkey);
+}
+
+
 static struct conf_service *service_create_static(struct conf_server *server,
                                                   xmlNode *node,
                                                   const char *service_id)
@@ -496,11 +558,18 @@ static struct conf_service *service_create_static(struct conf_server *server,
         if (n->type == XML_ELEMENT_NODE && !strcmp((const char *)
                                                    n->name, "metadata"))
         {
-            xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
-            num_metadata++;
-            if (sortkey && strcmp((const char *) sortkey, "no"))
-                num_sortkeys++;
-            xmlFree(sortkey);
+            if (n->children) // This is a <metadata> container, look at its contents.
+            {
+                xmlNode *m;
+                for (m = n->children; m; m = m->next)
+                {
+                    if (m->type == XML_ELEMENT_NODE &&
+                            !strcmp((const char *) m->name, "metadata"))
+                        count_metadata(m, &num_metadata, &num_sortkeys);
+                }
+            }
+            else // This is a metadata-element proper, count it right away.
+                count_metadata(n, &num_metadata, &num_sortkeys);
         }
 
     service = service_init(server, num_metadata, num_sortkeys, service_id);
@@ -588,8 +657,8 @@ static struct conf_service *service_create_static(struct conf_server *server,
         {
             if (!service->charsets)
                 service->charsets = pp2_charset_fact_create();
-            if (pp2_charset_fact_define(service->charsets,
-                                        n->children, (const char *) n->name))
+            if (pp2_charset_fact_define(service->charsets, n,
+                                        (const char *) n->name))
             {
                 yaz_log(YLOG_FATAL, "ICU chain definition error");
                 return 0;
@@ -597,41 +666,103 @@ static struct conf_service *service_create_static(struct conf_server *server,
         }
         else if (!strcmp((const char *) n->name, (const char *) "metadata"))
         {
-            if (parse_metadata(service, n, &md_node, &sk_node))
-                return 0;
+            if (n->children) // This is a <metadata> container, look at its content.
+            {
+                xmlNode *m;
+                for (m = n->children; m; m = m->next)
+                    if ((!strcmp((const char *) m->name, (const char *) "metadata")))
+                        if (parse_metadata(service, m, &md_node, &sk_node))
+                            return 0;
+            }
+            else // This is a metadata-element proper, count it right away.
+                if (parse_metadata(service, n, &md_node, &sk_node))
+                    return 0;
         }
         else if (!strcmp((const char *) n->name, (const char *) "xslt"))
         {
             if (service_xslt_config(service, n))
                 return 0;
         }
-        else if (!strcmp((const char *) n->name, (const char *) "set"))
+        else if (!strcmp((const char *) n->name, "rank"))
         {
-            xmlChar *name= xmlGetProp(n, (xmlChar *) "name");
-            xmlChar *value = xmlGetProp(n, (xmlChar *) "value");
-            if (service->dictionary && name && value) {
-                yaz_log(YLOG_DEBUG, "service set: %s=%s (Not implemented)", (char *) name, (char *) value);
-                //service_aply_setting(service, name, value);
+            char *rank_cluster = (char *) xmlGetProp(n, (xmlChar *) "cluster");
+            char *rank_debug = (char *) xmlGetProp(n, (xmlChar *) "debug");
+            char *rank_follow = (char *) xmlGetProp(n, (xmlChar *) "follow");
+            char *rank_lead = (char *) xmlGetProp(n, (xmlChar *) "lead");
+            char *rank_length= (char *) xmlGetProp(n, (xmlChar *) "length");
+            if (rank_cluster)
+            {
+                if (!strcmp(rank_cluster, "yes"))
+                    service->rank_cluster = 1;
+                else if (!strcmp(rank_cluster, "no"))
+                    service->rank_cluster = 0;
+                else
+                {
+                    yaz_log(YLOG_FATAL, "service: rank@cluster boolean");
+                    return 0;
+                }
+            }
+            if (rank_debug)
+            {
+                if (!strcmp(rank_debug, "yes"))
+                    service->rank_debug = 1;
+                else if (!strcmp(rank_debug, "no"))
+                    service->rank_debug = 0;
+                else
+                {
+                    yaz_log(YLOG_FATAL, "service: rank@debug boolean");
+                    return 0;
+                }
+            }
+            if (rank_follow)
+            {
+                service->rank_follow = atof(rank_follow);
+            }
+            if (rank_lead)
+            {
+                service->rank_lead = atof(rank_lead);
+            }
+            if (rank_length)
+            {
+                if (!strcmp(rank_length, "linear"))
+                    service->rank_length = 2;
+                else if (!strcmp(rank_length, "log"))
+                    service->rank_length = 1;
+                else if (!strcmp(rank_length, "none"))
+                    service->rank_length = 0;
+                else
+                {
+                    yaz_log(YLOG_FATAL, "service: rank@length linear|log|none");
+                    return 0;
+                }
             }
+            xmlFree(rank_cluster);
+            xmlFree(rank_debug);
+            xmlFree(rank_follow);
+            xmlFree(rank_lead);
+            xmlFree(rank_length);
         }
-        else if (!strcmp((const char *) n->name, "rank"))
+        else if (!strcmp((const char *) n->name, "sort-default"))
         {
-            char *rank_cluster = (char *) xmlGetProp(n, (xmlChar *) "cluster");
+            char *default_sort = (char *) xmlGetProp(n, (xmlChar *) "field");
 
-            if (rank_cluster && !strcmp(rank_cluster, "yes"))
-                service->rank_cluster = 1;
-            else if (rank_cluster && !strcmp(rank_cluster, "no"))
-                service->rank_cluster = 0;
+            if (default_sort && strcmp(default_sort, "")) {
+                service->default_sort = nmem_strdup(service->nmem, default_sort);
+                yaz_log(YLOG_LOG, "service %s: default sort order configured to: %s",
+                        service_id ? service_id : "unnamed", default_sort);
+            }
             else
             {
-                yaz_log(YLOG_FATAL, "service: rank@cluster boolean");
+                yaz_log(YLOG_FATAL, "default sort order is invalid: %s", default_sort);
                 return 0;
             }
-            xmlFree(rank_cluster);
+            xmlFree(default_sort);
         }
         else
         {
-            yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
+            char tmp[80];
+            yaz_log(YLOG_FATAL, "Bad element: %s . Context: %s", n->name,
+                    xml_context(n, tmp, sizeof tmp));
             return 0;
         }
     }
@@ -668,6 +799,14 @@ static struct conf_service *service_create_static(struct conf_server *server,
             }
         }
     }
+
+    {
+        xmlBufferPtr buf = xmlBufferCreate();
+        xmlNodeDump(buf, node->doc, node, 0, 0);
+        service->xml_node =
+            nmem_strdupn(service->nmem, (const char *) buf->content, buf->use);
+        xmlBufferFree(buf);
+    }
     return service;
 }
 
@@ -730,7 +869,7 @@ static struct conf_server *server_create(struct conf_config *config,
     struct conf_server *server = nmem_malloc(nmem, sizeof(struct conf_server));
     xmlChar *server_id = xmlGetProp(node, (xmlChar *) "id");
 
-    server->host = 0;
+    server->host = "@";
     server->port = 0;
     server->proxy_host = 0;
     server->proxy_port = 0;
@@ -741,7 +880,6 @@ static struct conf_server *server_create(struct conf_config *config,
     server->charsets = 0;
     server->http_server = 0;
     server->iochan_man = 0;
-    server->database_hosts = config->database_hosts;
     server->settings_fname = 0;
 
     if (server_id)
@@ -759,10 +897,12 @@ static struct conf_server *server_create(struct conf_config *config,
         {
             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
+
             if (port)
-                server->port = atoi((const char *) port);
+                server->port = nmem_strdup(nmem, (const char *) port);
             if (host)
                 server->host = nmem_strdup(nmem, (const char *) host);
+
             xmlFree(port);
             xmlFree(host);
         }
@@ -819,8 +959,8 @@ static struct conf_server *server_create(struct conf_config *config,
         {
             if (!server->charsets)
                 server->charsets = pp2_charset_fact_create();
-            if (pp2_charset_fact_define(server->charsets,
-                                        n->children, (const char *) n->name))
+            if (pp2_charset_fact_define(server->charsets, n,
+                                        (const char *) n->name))
             {
                 yaz_log(YLOG_FATAL, "ICU chain definition error");
                 return 0;
@@ -866,6 +1006,11 @@ static struct conf_server *server_create(struct conf_config *config,
             return 0;
         }
     }
+    if (!server->port)
+    {
+        yaz_log(YLOG_FATAL, "No listening port given");
+        return 0;
+    }
     if (server->service)
     {
         struct conf_service *s;
@@ -897,9 +1042,151 @@ struct conf_service *locate_service(struct conf_server *server,
     return s;
 }
 
+static void info_service_metadata(struct conf_service *service, WRBUF w)
+{
+    int i;
+    struct conf_metadata *md;
+
+    if (service->num_metadata)
+    {
+        for (i = 0; i < service->num_metadata; i++)
+        {
+            md = &(service->metadata[i]);
+            wrbuf_puts(w, "   <metadata");
+            if (md->name) {
+                wrbuf_puts(w, " name=\"");
+                wrbuf_xmlputs(w, md->name);
+                wrbuf_puts(w, "\"");
+            }
+            if (md->brief) {
+                wrbuf_puts(w, " brief=\"yes\"");
+            }
+            if (md->termlist) {
+                wrbuf_puts(w, " termlist=\"yes\"");
+            }
+            if (md->rank) {
+                wrbuf_puts(w, " rank=\"");
+                wrbuf_xmlputs(w, md->rank);
+                wrbuf_puts(w, "\"");
+            }
+            if (md->sortkey_offset > 0) {
+                wrbuf_puts(w, " sortkey=\"");
+                switch (service->sortkeys[md->sortkey_offset].type)
+                {
+                case Metadata_type_relevance:
+                    wrbuf_puts(w, "relevance");
+                    break;
+                case Metadata_type_skiparticle:
+                    wrbuf_puts(w, "skiparticle");
+                    break;
+                case Metadata_type_position:
+                    wrbuf_puts(w, "position");
+                    break;
+                case Metadata_type_retrieval:
+                    wrbuf_puts(w, "retrieval");
+                    break;
+                default:
+                    wrbuf_puts(w, "yes");
+                    break;
+                }
+                wrbuf_puts(w, "\"");
+            }
+            switch (md->type)
+            {
+            case Metadata_type_generic:
+            case Metadata_type_skiparticle:
+                break;
+            case Metadata_type_year:
+                wrbuf_puts(w, " type=\"year\"");
+                break;
+            case Metadata_type_date:
+                wrbuf_puts(w, " type=\"date\"");
+                break;
+            case Metadata_type_float:
+                wrbuf_puts(w, " type=\"float\"");
+                break;
+            default:
+                break;
+            }
+            switch (md->merge)
+            {
+            case Metadata_merge_no:
+                break;
+            case Metadata_merge_unique:
+                wrbuf_puts(w, " merge=\"unique\"");
+                break;
+            case Metadata_merge_longest:
+                wrbuf_puts(w, " merge=\"longest\"");
+                break;
+            case Metadata_merge_range:
+                wrbuf_puts(w, " merge=\"range\"");
+                break;
+            case Metadata_merge_all:
+                wrbuf_puts(w, " merge=\"all\"");
+                break;
+            case Metadata_merge_first:
+                wrbuf_puts(w, " merge=\"first\"");
+                break;
+            }
+            switch (md->mergekey)
+            {
+            case Metadata_mergekey_no:
+                break;
+            case Metadata_mergekey_optional:
+                wrbuf_puts(w, " mergekey=\"optional\"");
+                break;
+            case Metadata_mergekey_required:
+                wrbuf_puts(w, " mergekey=\"required\"");
+                break;
+            }
+            wrbuf_puts(w, " />\n");
+        }
+    }
+}
+
+static void info_service_databases(struct conf_service *service, WRBUF w)
+{
+
+    if (service->databases)
+    {
+        struct database *db;
+        wrbuf_puts(w, "   <databases>\n");
+        for (db = service->databases; db; db = db->next)
+        {
+            int i;
+            wrbuf_puts(w, "    <database");
+            if (db->id)
+            {
+                wrbuf_puts(w, " id=\"");
+                wrbuf_printf(w, "%s", db->id);
+                wrbuf_puts(w, "\"");
+            }
+            wrbuf_puts(w, ">\n");
+            for (i = 0; i < db->num_settings; i++)
+            {
+                struct setting *s = db->settings[i];
+                for (; s; s = s->next)
+                {
+                    wrbuf_puts(w, "     <setting name=\"");
+                    wrbuf_xmlputs(w, s->name);
+                    wrbuf_puts(w, "\"");
+                    wrbuf_puts(w, " value=\"");
+                    wrbuf_xmlputs(w, s->value);
+                    wrbuf_puts(w, "\"");
+                    wrbuf_puts(w, " />\n");
+                }
+            }
+            wrbuf_puts(w, "    </database>\n");
+        }
+        wrbuf_puts(w, "   </databases>\n");
+    }
+}
+
 void info_services(struct conf_server *server, WRBUF w)
 {
     struct conf_service *s = server->service;
+    int i;
+
     wrbuf_puts(w, " <services>\n");
     for (; s; s = s->next)
     {
@@ -910,9 +1197,33 @@ void info_services(struct conf_server *server, WRBUF w)
             wrbuf_xmlputs(w, s->id);
             wrbuf_puts(w, "\"");
         }
-        wrbuf_puts(w, "/>");
-
-        wrbuf_puts(w, "\n");
+        wrbuf_puts(w, ">\n");
+        if (s->settings)
+        {
+            for (i = 0; i < s->settings->num_settings; i++)
+            {
+                struct setting *S = s->settings->settings[i];
+                for (; S; S = S->next)
+                {
+                    wrbuf_puts(w, "   <setting name=\"");
+                    wrbuf_xmlputs(w,  S->name);
+                    wrbuf_puts(w, "\"");
+                    wrbuf_puts(w, " value=\"");
+                    wrbuf_xmlputs(w, S->value);
+                    wrbuf_puts(w, "\"");
+                    if (S->target)
+                    {
+                        wrbuf_puts(w, " target=\"");
+                        wrbuf_xmlputs(w, S->target);
+                        wrbuf_puts(w, "\"");
+                    }
+                    wrbuf_puts(w, " />\n");
+                }
+            }
+        }
+        info_service_metadata(s, w);
+        info_service_databases(s, w);
+        wrbuf_puts(w, "  </service>\n");
     }
     wrbuf_puts(w, " </services>\n");
 }
@@ -942,6 +1253,24 @@ static int parse_config(struct conf_config *config, xmlNode *root)
                 xmlFree(number);
             }
         }
+        else if (!strcmp((const char *) n->name, "sockets"))
+        {
+            xmlChar *number = xmlGetProp(n, (xmlChar *) "max");
+            if (number)
+            {
+                config->max_sockets = atoi((const char *) number);
+                xmlFree(number);
+            }
+        }
+        else if (!strcmp((const char *) n->name, "file"))
+        {
+            xmlChar *path = xmlGetProp(n, (xmlChar *) "path");
+            if (path)
+            {
+                config->path = nmem_strdup(config->nmem, (const char *) path);
+                xmlFree(path);
+            }
+        }
         else if (!strcmp((const char *) n->name, "targetprofiles"))
         {
             yaz_log(YLOG_FATAL, "targetprofiles unsupported here. Must be part of service");
@@ -957,9 +1286,12 @@ static int parse_config(struct conf_config *config, xmlNode *root)
     return 0;
 }
 
-struct conf_config *config_create(const char *fname, int verbose)
+struct conf_config *config_create(const char *fname)
 {
-    xmlDoc *doc = xmlParseFile(fname);
+    xmlDoc *doc = xmlReadFile(fname,
+                              NULL,
+                              XML_PARSE_XINCLUDE
+                              + XML_PARSE_NSCLEAN + XML_PARSE_NONET);
     xmlNode *n;
     const char *p;
     int r;
@@ -975,11 +1307,20 @@ struct conf_config *config_create(const char *fname, int verbose)
         return 0;
     }
 
+    // Perform XInclude.
+    r = xmlXIncludeProcess(doc);
+    if (r == -1)
+    {
+        yaz_log(YLOG_FATAL, "XInclude processing failed");
+        return 0;
+    }
+
     config->nmem = nmem;
     config->servers = 0;
+    config->path = nmem_strdup(nmem, ".");
     config->no_threads = 0;
+    config->max_sockets = 0;
     config->iochan_man = 0;
-    config->database_hosts = database_hosts_create();
 
     config->confdir = wrbuf_alloc();
     if ((p = strrchr(fname,
@@ -999,16 +1340,15 @@ struct conf_config *config_create(const char *fname, int verbose)
     r = yaz_xml_include_simple(n, wrbuf_cstr(config->confdir));
     if (r == 0) /* OK */
     {
-        if (verbose)
-        {
-            yaz_log(YLOG_LOG, "Configuration %s after include processing",
-                    fname);
+#ifndef WIN32
+        yaz_log(YLOG_LOG, "Configuration %s after include processing",
+                fname);
 #if LIBXML_VERSION >= 20600
-            xmlDocFormatDump(yaz_log_file(), doc, 0);
+        xmlDocFormatDump(yaz_log_file(), doc, 0);
 #else
-            xmlDocDump(yaz_log_file(), doc);
+        xmlDocDump(yaz_log_file(), doc);
+#endif
 #endif
-        }
         r = parse_config(config, n);
     }
     xmlFreeDoc(doc);
@@ -1031,7 +1371,6 @@ void server_destroy(struct conf_server *server)
         s = s_next;
     }
     pp2_charset_fact_destroy(server->charsets);
-    yaz_log(YLOG_LOG, "server_destroy server=%p", server);
     http_server_destroy(server->http_server);
 }
 
@@ -1046,7 +1385,6 @@ void config_destroy(struct conf_config *config)
             struct conf_server *s_next = server->next;
             server_destroy(server);
             server = s_next;
-            database_hosts_destroy(&config->database_hosts);
         }
         wrbuf_destroy(config->confdir);
         nmem_destroy(config->nmem);
@@ -1084,31 +1422,30 @@ int config_start_listeners(struct conf_config *conf,
 {
     struct conf_server *ser;
 
-    conf->iochan_man = iochan_man_create(conf->no_threads);
+    conf->iochan_man = iochan_man_create(conf->no_threads, conf->max_sockets);
     for (ser = conf->servers; ser; ser = ser->next)
     {
-        WRBUF w = wrbuf_alloc();
+        WRBUF w;
         int r;
 
         ser->iochan_man = conf->iochan_man;
         if (listener_override)
         {
-            wrbuf_puts(w, listener_override);
-            listener_override = 0; /* only first server is overriden */
-        }
-        else
-        {
-            if (ser->host)
-                wrbuf_puts(w, ser->host);
-            if (ser->port)
+            const char *cp = strrchr(listener_override, ':');
+            if (cp)
             {
-                if (wrbuf_len(w))
-                    wrbuf_puts(w, ":");
-                wrbuf_printf(w, "%d", ser->port);
+                ser->host = nmem_strdupn(conf->nmem, listener_override,
+                                         cp - listener_override);
+                ser->port = nmem_strdup(conf->nmem, cp + 1);
             }
+            else
+            {
+                ser->host = "@";
+                ser->port = nmem_strdup(conf->nmem, listener_override);
+            }
+            listener_override = 0; /* only first server is overriden */
         }
-        r = http_init(wrbuf_cstr(w), ser, record_fname);
-        wrbuf_destroy(w);
+        r = http_init(ser, record_fname);
         if (r)
             return -1;