src/pazpar2_config.c

   1 /* This file is part of Pazpar2.
   2    Copyright (C) 2006-2011 Index Data
   3
   4 Pazpar2 is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 */
  19
  20 #if HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <string.h>
  25 #include <assert.h>
  26
  27 #include <libxml/parser.h>
  28 #include <libxml/tree.h>
  29
  30 #include <yaz/yaz-util.h>
  31 #include <yaz/nmem.h>
  32 #include <yaz/snprintf.h>
  33 #include <yaz/tpath.h>
  34 #include <yaz/xml_include.h>
  35
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #if HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41 #include "ppmutex.h"
  42 #include "incref.h"
  43 #include "pazpar2_config.h"
  44 #include "settings.h"
  45 #include "eventl.h"
  46 #include "http.h"
  47
  48 struct conf_config
  49 {
  50     NMEM nmem; /* for conf_config and servers memory */
  51     struct conf_server *servers;
  52
  53     int no_threads;
  54     WRBUF confdir;
  55     iochan_man_t iochan_man;
  56     database_hosts_t database_hosts;
  57 };
  58
  59
  60 static void conf_metadata_assign(NMEM nmem,
  61                                  struct conf_metadata * metadata,
  62                                  const char *name,
  63                                  enum conf_metadata_type type,
  64                                  enum conf_metadata_merge merge,
  65                                  enum conf_setting_type setting,
  66                                  int brief,
  67                                  int termlist,
  68                                  int rank,
  69                                  int sortkey_offset,
  70                                  enum conf_metadata_mergekey mt,
  71                                  const char *facetrule)
  72 {
  73     assert(nmem && metadata && name);
  74
  75     metadata->name = nmem_strdup(nmem, name);
  76
  77     metadata->type = type;
  78
  79     // enforcing that type_year is always range_merge
  80     if (metadata->type == Metadata_type_year)
  81         metadata->merge = Metadata_merge_range;
  82     else
  83         metadata->merge = merge;
  84
  85     metadata->setting = setting;
  86     metadata->brief = brief;
  87     metadata->termlist = termlist;
  88     metadata->rank = rank;
  89     metadata->sortkey_offset = sortkey_offset;
  90     metadata->mergekey = mt;
  91     metadata->facetrule = nmem_strdup_null(nmem, facetrule);
  92 }
  93
  94
  95 static void conf_sortkey_assign(NMEM nmem,
  96                                 struct conf_sortkey * sortkey,
  97                                 const char *name,
  98                                 enum conf_sortkey_type type)
  99 {
 100     assert(nmem && sortkey && name);
 101
 102     sortkey->name = nmem_strdup(nmem, name);
 103     sortkey->type = type;
 104 }
 105
 106
 107 static struct conf_service *service_init(struct conf_server *server,
 108                                          int num_metadata, int num_sortkeys,
 109                                          const char *service_id)
 110 {
 111     struct conf_service * service = 0;
 112     NMEM nmem = nmem_create();
 113
 114     service = nmem_malloc(nmem, sizeof(struct conf_service));
 115     service->mutex = 0;
 116     service->ref_count = 1;
 117     service->nmem = nmem;
 118     service->next = 0;
 119     service->databases = 0;
 120     service->server = server;
 121     service->session_timeout = 60; /* default session timeout */
 122     service->z3950_session_timeout = 180;
 123     service->z3950_operation_timeout = 30;
 124
 125     service->charsets = 0;
 126
 127     service->id = service_id ? nmem_strdup(nmem, service_id) : 0;
 128     service->num_metadata = num_metadata;
 129     service->metadata = 0;
 130     if (service->num_metadata)
 131       service->metadata
 132           = nmem_malloc(nmem,
 133                         sizeof(struct conf_metadata) * service->num_metadata);
 134     service->num_sortkeys = num_sortkeys;
 135     service->sortkeys = 0;
 136     if (service->num_sortkeys)
 137         service->sortkeys
 138             = nmem_malloc(nmem,
 139                           sizeof(struct conf_sortkey) * service->num_sortkeys);
 140     service->dictionary = 0;
 141     return service;
 142 }
 143
 144 static struct conf_metadata* conf_service_add_metadata(
 145     struct conf_service *service,
 146     int field_id,
 147     const char *name,
 148     enum conf_metadata_type type,
 149     enum conf_metadata_merge merge,
 150     enum conf_setting_type setting,
 151     int brief,
 152     int termlist,
 153     int rank,
 154     int sortkey_offset,
 155     enum conf_metadata_mergekey mt,
 156     const char *facetrule)
 157 {
 158     struct conf_metadata * md = 0;
 159
 160     if (!service || !service->metadata || !service->num_metadata
 161         || field_id < 0  || !(field_id < service->num_metadata))
 162         return 0;
 163
 164     md = service->metadata + field_id;
 165     conf_metadata_assign(service->nmem, md, name, type, merge, setting,
 166                          brief, termlist, rank, sortkey_offset,
 167                          mt, facetrule);
 168     return md;
 169 }
 170
 171
 172 static struct conf_sortkey * conf_service_add_sortkey(
 173     struct conf_service *service,
 174     int field_id,
 175     const char *name,
 176     enum conf_sortkey_type type)
 177 {
 178     struct conf_sortkey * sk = 0;
 179
 180     if (!service || !service->sortkeys || !service->num_sortkeys
 181         || field_id < 0  || !(field_id < service->num_sortkeys))
 182         return 0;
 183
 184     //sk = &((service->sortkeys)[field_id]);
 185     sk = service->sortkeys + field_id;
 186     conf_sortkey_assign(service->nmem, sk, name, type);
 187
 188     return sk;
 189 }
 190
 191
 192 int conf_service_metadata_field_id(struct conf_service *service,
 193                                    const char * name)
 194 {
 195     int i = 0;
 196
 197     if (!service || !service->metadata || !service->num_metadata)
 198         return -1;
 199
 200     for(i = 0; i < service->num_metadata; i++) {
 201         if (!strcmp(name, (service->metadata[i]).name))
 202             return i;
 203     }
 204
 205     return -1;
 206 }
 207
 208
 209 int conf_service_sortkey_field_id(struct conf_service *service,
 210                                   const char * name)
 211 {
 212     int i = 0;
 213
 214     if (!service || !service->sortkeys || !service->num_sortkeys)
 215         return -1;
 216
 217     for(i = 0; i < service->num_sortkeys; i++) {
 218         if (!strcmp(name, (service->sortkeys[i]).name))
 219             return i;
 220     }
 221
 222     return -1;
 223 }
 224
 225 static void conf_dir_path(struct conf_config *config, WRBUF w, const char *src)
 226 {
 227     if (config->confdir && wrbuf_len(config->confdir) > 0 &&
 228         !yaz_is_abspath(src))
 229     {
 230         wrbuf_printf(w, "%s/%s", wrbuf_cstr(config->confdir), src);
 231     }
 232     else
 233         wrbuf_puts(w, src);
 234 }
 235
 236 void service_destroy(struct conf_service *service)
 237 {
 238     if (service)
 239     {
 240         if (!pazpar2_decref(&service->ref_count, service->mutex))
 241         {
 242             pp2_charset_fact_destroy(service->charsets);
 243             yaz_mutex_destroy(&service->mutex);
 244             nmem_destroy(service->nmem);
 245         }
 246     }
 247 }
 248
 249 void service_incref(struct conf_service *service)
 250 {
 251     yaz_log(YLOG_LOG, "service_incref. p=%p cnt=%d", service,
 252             service->ref_count);
 253     pazpar2_incref(&service->ref_count, service->mutex);
 254 }
 255
 256 static int parse_metadata(struct conf_service *service, xmlNode *n,
 257                           int *md_node, int *sk_node)
 258 {
 259     enum conf_metadata_type type = Metadata_type_generic;
 260     enum conf_metadata_merge merge = Metadata_merge_no;
 261     enum conf_setting_type setting = Metadata_setting_no;
 262     enum conf_metadata_mergekey mergekey_type = Metadata_mergekey_no;
 263     int brief = 0;
 264     int termlist = 0;
 265     int rank = 0;
 266     int sortkey_offset = 0;
 267     xmlChar *xml_name = 0;
 268     xmlChar *xml_brief = 0;
 269     xmlChar *xml_sortkey = 0;
 270     xmlChar *xml_merge = 0;
 271     xmlChar *xml_type = 0;
 272     xmlChar *xml_termlist = 0;
 273     xmlChar *xml_rank = 0;
 274     xmlChar *xml_setting = 0;
 275     xmlChar *xml_mergekey = 0;
 276     xmlChar *xml_icu_chain = 0;
 277     struct _xmlAttr *attr;
 278     for (attr = n->properties; attr; attr = attr->next)
 279     {
 280         if (!xmlStrcmp(attr->name, BAD_CAST "name") &&
 281             attr->children && attr->children->type == XML_TEXT_NODE)
 282             xml_name = attr->children->content;
 283         else if (!xmlStrcmp(attr->name, BAD_CAST "brief") &&
 284                  attr->children && attr->children->type == XML_TEXT_NODE)
 285             xml_brief = attr->children->content;
 286         else if (!xmlStrcmp(attr->name, BAD_CAST "sortkey") &&
 287                  attr->children && attr->children->type == XML_TEXT_NODE)
 288             xml_sortkey = attr->children->content;
 289         else if (!xmlStrcmp(attr->name, BAD_CAST "merge") &&
 290                  attr->children && attr->children->type == XML_TEXT_NODE)
 291             xml_merge = attr->children->content;
 292         else if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
 293                  attr->children && attr->children->type == XML_TEXT_NODE)
 294             xml_type = attr->children->content;
 295         else if (!xmlStrcmp(attr->name, BAD_CAST "termlist") &&
 296                  attr->children && attr->children->type == XML_TEXT_NODE)
 297             xml_termlist = attr->children->content;
 298         else if (!xmlStrcmp(attr->name, BAD_CAST "rank") &&
 299                  attr->children && attr->children->type == XML_TEXT_NODE)
 300             xml_rank = attr->children->content;
 301         else if (!xmlStrcmp(attr->name, BAD_CAST "setting") &&
 302                  attr->children && attr->children->type == XML_TEXT_NODE)
 303             xml_setting = attr->children->content;
 304         else if (!xmlStrcmp(attr->name, BAD_CAST "mergekey") &&
 305                  attr->children && attr->children->type == XML_TEXT_NODE)
 306             xml_mergekey = attr->children->content;
 307         else if (!xmlStrcmp(attr->name, BAD_CAST "facetrule") &&
 308                  attr->children && attr->children->type == XML_TEXT_NODE)
 309             xml_icu_chain = attr->children->content;
 310         else
 311         {
 312             yaz_log(YLOG_FATAL, "Unknown metadata attribute '%s'", attr->name);
 313             return -1;
 314         }
 315     }
 316
 317     // now do the parsing logic
 318     if (!xml_name)
 319     {
 320         yaz_log(YLOG_FATAL, "Must specify name in metadata element");
 321         return -1;
 322     }
 323     if (xml_brief)
 324     {
 325         if (!strcmp((const char *) xml_brief, "yes"))
 326             brief = 1;
 327         else if (strcmp((const char *) xml_brief, "no"))
 328         {
 329             yaz_log(YLOG_FATAL, "metadata/brief must be yes or no");
 330             return -1;
 331         }
 332     }
 333
 334     if (xml_termlist)
 335     {
 336         if (!strcmp((const char *) xml_termlist, "yes"))
 337             termlist = 1;
 338         else if (strcmp((const char *) xml_termlist, "no"))
 339         {
 340             yaz_log(YLOG_FATAL, "metadata/termlist must be yes or no");
 341             return -1;
 342         }
 343     }
 344
 345     if (xml_rank)
 346         rank = atoi((const char *) xml_rank);
 347
 348     if (xml_type)
 349     {
 350         if (!strcmp((const char *) xml_type, "generic"))
 351             type = Metadata_type_generic;
 352         else if (!strcmp((const char *) xml_type, "year"))
 353             type = Metadata_type_year;
 354         else if (!strcmp((const char *) xml_type, "date"))
 355             type = Metadata_type_date;
 356         else
 357         {
 358             yaz_log(YLOG_FATAL,
 359                     "Unknown value for metadata/type: %s", xml_type);
 360             return -1;
 361         }
 362     }
 363
 364     if (xml_merge)
 365     {
 366         if (!strcmp((const char *) xml_merge, "no"))
 367             merge = Metadata_merge_no;
 368         else if (!strcmp((const char *) xml_merge, "unique"))
 369             merge = Metadata_merge_unique;
 370         else if (!strcmp((const char *) xml_merge, "longest"))
 371             merge = Metadata_merge_longest;
 372         else if (!strcmp((const char *) xml_merge, "range"))
 373             merge = Metadata_merge_range;
 374         else if (!strcmp((const char *) xml_merge, "all"))
 375             merge = Metadata_merge_all;
 376         else
 377         {
 378             yaz_log(YLOG_FATAL,
 379                     "Unknown value for metadata/merge: %s", xml_merge);
 380             return -1;
 381         }
 382     }
 383
 384     if (xml_setting)
 385     {
 386         if (!strcmp((const char *) xml_setting, "no"))
 387             setting = Metadata_setting_no;
 388         else if (!strcmp((const char *) xml_setting, "postproc"))
 389             setting = Metadata_setting_postproc;
 390         else if (!strcmp((const char *) xml_setting, "parameter"))
 391             setting = Metadata_setting_parameter;
 392         else
 393         {
 394             yaz_log(YLOG_FATAL,
 395                     "Unknown value for medadata/setting: %s", xml_setting);
 396             return -1;
 397         }
 398     }
 399
 400     // add a sortkey if so specified
 401     if (xml_sortkey && strcmp((const char *) xml_sortkey, "no"))
 402     {
 403         enum conf_sortkey_type sk_type;
 404         if (merge == Metadata_merge_no)
 405         {
 406             yaz_log(YLOG_FATAL,
 407                     "Can't specify sortkey on a non-merged field");
 408             return -1;
 409         }
 410         if (!strcmp((const char *) xml_sortkey, "numeric"))
 411             sk_type = Metadata_sortkey_numeric;
 412         else if (!strcmp((const char *) xml_sortkey, "skiparticle"))
 413             sk_type = Metadata_sortkey_skiparticle;
 414         else
 415         {
 416             yaz_log(YLOG_FATAL,
 417                     "Unknown sortkey in metadata element: %s",
 418                     xml_sortkey);
 419             return -1;
 420         }
 421         sortkey_offset = *sk_node;
 422
 423         conf_service_add_sortkey(service, *sk_node,
 424                                  (const char *) xml_name, sk_type);
 425         (*sk_node)++;
 426     }
 427     else
 428         sortkey_offset = -1;
 429
 430     if (xml_mergekey)
 431     {
 432         if (!strcmp((const char *) xml_mergekey, "required"))
 433             mergekey_type = Metadata_mergekey_required;
 434         else if (!strcmp((const char *) xml_mergekey, "optional"))
 435             mergekey_type = Metadata_mergekey_optional;
 436         else if (!strcmp((const char *) xml_mergekey, "no"))
 437             mergekey_type = Metadata_mergekey_no;
 438         else
 439         {
 440             yaz_log(YLOG_FATAL, "Unknown value for mergekey: %s", xml_mergekey);
 441             return -1;
 442         }
 443     }
 444
 445     // metadata known, assign values
 446     conf_service_add_metadata(service, *md_node,
 447                               (const char *) xml_name,
 448                               type, merge, setting,
 449                               brief, termlist, rank, sortkey_offset,
 450                               mergekey_type, (const char *) xml_icu_chain);
 451     (*md_node)++;
 452     return 0;
 453 }
 454
 455 static struct conf_service *service_create_static(struct conf_server *server,
 456                                                   xmlNode *node,
 457                                                   const char *service_id)
 458 {
 459     xmlNode *n;
 460     int md_node = 0;
 461     int sk_node = 0;
 462
 463     struct conf_service *service = 0;
 464     int num_metadata = 0;
 465     int num_sortkeys = 0;
 466     int got_settings = 0;
 467
 468     // count num_metadata and num_sortkeys
 469     for (n = node->children; n; n = n->next)
 470         if (n->type == XML_ELEMENT_NODE && !strcmp((const char *)
 471                                                    n->name, "metadata"))
 472         {
 473             xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 474             num_metadata++;
 475             if (sortkey && strcmp((const char *) sortkey, "no"))
 476                 num_sortkeys++;
 477             xmlFree(sortkey);
 478         }
 479
 480     service = service_init(server, num_metadata, num_sortkeys, service_id);
 481
 482     for (n = node->children; n; n = n->next)
 483     {
 484         if (n->type != XML_ELEMENT_NODE)
 485             continue;
 486         if (!strcmp((const char *) n->name, "timeout"))
 487         {
 488             xmlChar *src = xmlGetProp(n, (xmlChar *) "session");
 489             if (src)
 490             {
 491                 service->session_timeout = atoi((const char *) src);
 492                 xmlFree(src);
 493                 if (service->session_timeout < 9)
 494                 {
 495                     yaz_log(YLOG_FATAL, "session timeout out of range");
 496                     return 0;
 497                 }
 498             }
 499             src = xmlGetProp(n, (xmlChar *) "z3950_operation");
 500             if (src)
 501             {
 502                 service->z3950_operation_timeout = atoi((const char *) src);
 503                 xmlFree(src);
 504                 if (service->z3950_session_timeout < 9)
 505                 {
 506                     yaz_log(YLOG_FATAL, "Z39.50 operation timeout out of range");
 507                     return 0;
 508                 }
 509             }
 510             src = xmlGetProp(n, (xmlChar *) "z3950_session");
 511             if (src)
 512             {
 513                 service->z3950_session_timeout = atoi((const char *) src);
 514                 xmlFree(src);
 515                 if (service->z3950_session_timeout < 9)
 516                 {
 517                     yaz_log(YLOG_FATAL, "Z39.50 session timeout out of range");
 518                     return 0;
 519                 }
 520             }
 521         }
 522         else if (!strcmp((const char *) n->name, "settings"))
 523             got_settings++;
 524         else if (!strcmp((const char *) n->name, "icu_chain"))
 525         {
 526             if (!service->charsets)
 527                 service->charsets = pp2_charset_fact_create();
 528             if (pp2_charset_fact_define(service->charsets, n, 0))
 529             {
 530                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 531                 return 0;
 532             }
 533         }
 534         else if (!strcmp((const char *) n->name, "relevance")
 535                  || !strcmp((const char *) n->name, "sort")
 536                  || !strcmp((const char *) n->name, "mergekey")
 537                  || !strcmp((const char *) n->name, "facet"))
 538
 539         {
 540             if (!service->charsets)
 541                 service->charsets = pp2_charset_fact_create();
 542             if (pp2_charset_fact_define(service->charsets,
 543                                         n->children, (const char *) n->name))
 544             {
 545                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 546                 return 0;
 547             }
 548         }
 549         else if (!strcmp((const char *) n->name, (const char *) "metadata"))
 550         {
 551             if (parse_metadata(service, n, &md_node, &sk_node))
 552                 return 0;
 553         }
 554         else
 555         {
 556             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 557             return 0;
 558         }
 559     }
 560     if (got_settings)
 561     {
 562         int pass;
 563         /* metadata has been read.. Consider now settings */
 564         init_settings(service);
 565         for (pass = 1; pass <= 2; pass++)
 566         {
 567             for (n = node->children; n; n = n->next)
 568             {
 569                 if (n->type != XML_ELEMENT_NODE)
 570                     continue;
 571                 if (!strcmp((const char *) n->name, "settings"))
 572                 {
 573                     xmlChar *src = xmlGetProp(n, (xmlChar *) "src");
 574                     if (src)
 575                     {
 576                         WRBUF w = wrbuf_alloc();
 577                         conf_dir_path(server->config, w, (const char *) src);
 578                         settings_read_file(service, wrbuf_cstr(w), pass);
 579                         wrbuf_destroy(w);
 580                         xmlFree(src);
 581                     }
 582                     else
 583                     {
 584                         settings_read_node(service, n, pass);
 585                     }
 586                 }
 587             }
 588         }
 589     }
 590     return service;
 591 }
 592
 593 static void inherit_server_settings(struct conf_service *s)
 594 {
 595     struct conf_server *server = s->server;
 596     if (!s->dictionary) /* service has no config settings ? */
 597     {
 598         if (server->settings_fname)
 599         {
 600             /* inherit settings from server */
 601             init_settings(s);
 602             settings_read_file(s, server->settings_fname, 1);
 603             settings_read_file(s, server->settings_fname, 2);
 604         }
 605         else
 606         {
 607             yaz_log(YLOG_WARN, "service '%s' has no settings",
 608                     s->id ? s->id : "unnamed");
 609             init_settings(s);
 610         }
 611     }
 612
 613     /* use relevance/sort/mergekey/facet from server if not defined
 614        for this service.. */
 615     if (!s->charsets)
 616     {
 617         if (server->charsets)
 618         {
 619             s->charsets = server->charsets;
 620             pp2_charset_fact_incref(s->charsets);
 621         }
 622         else
 623         {
 624             s->charsets = pp2_charset_fact_create();
 625         }
 626     }
 627 }
 628
 629 struct conf_service *service_create(struct conf_server *server,
 630                                     xmlNode *node)
 631 {
 632     struct conf_service *service = service_create_static(server,
 633                                                          node, 0);
 634     if (service)
 635     {
 636         inherit_server_settings(service);
 637         resolve_databases(service);
 638         assert(service->mutex == 0);
 639         pazpar2_mutex_create(&service->mutex, "conf");
 640     }
 641     return service;
 642 }
 643
 644 static struct conf_server *server_create(struct conf_config *config,
 645                                          NMEM nmem, xmlNode *node)
 646 {
 647     xmlNode *n;
 648     struct conf_server *server = nmem_malloc(nmem, sizeof(struct conf_server));
 649     xmlChar *server_id = xmlGetProp(node, (xmlChar *) "id");
 650
 651     server->host = 0;
 652     server->port = 0;
 653     server->proxy_host = 0;
 654     server->proxy_port = 0;
 655     server->myurl = 0;
 656     server->service = 0;
 657     server->config = config;
 658     server->next = 0;
 659     server->charsets = 0;
 660     server->http_server = 0;
 661     server->iochan_man = 0;
 662     server->database_hosts = 0;
 663     server->settings_fname = 0;
 664
 665     if (server_id)
 666     {
 667         server->server_id = nmem_strdup(nmem, (const char *)server_id);
 668         xmlFree(server_id);
 669     }
 670     else
 671         server->server_id = 0;
 672     for (n = node->children; n; n = n->next)
 673     {
 674         if (n->type != XML_ELEMENT_NODE)
 675             continue;
 676         if (!strcmp((const char *) n->name, "listen"))
 677         {
 678             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 679             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 680             if (port)
 681                 server->port = atoi((const char *) port);
 682             if (host)
 683                 server->host = nmem_strdup(nmem, (const char *) host);
 684             xmlFree(port);
 685             xmlFree(host);
 686         }
 687         else if (!strcmp((const char *) n->name, "proxy"))
 688         {
 689             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 690             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 691             xmlChar *myurl = xmlGetProp(n, (xmlChar *) "myurl");
 692             if (port)
 693                 server->proxy_port = atoi((const char *) port);
 694             if (host)
 695                 server->proxy_host = nmem_strdup(nmem, (const char *) host);
 696             if (myurl)
 697                 server->myurl = nmem_strdup(nmem, (const char *) myurl);
 698             xmlFree(port);
 699             xmlFree(host);
 700             xmlFree(myurl);
 701         }
 702         else if (!strcmp((const char *) n->name, "settings"))
 703         {
 704             xmlChar *src = xmlGetProp(n, (xmlChar *) "src");
 705             WRBUF w;
 706             if (!src)
 707             {
 708                 yaz_log(YLOG_FATAL, "Missing src attribute for settings");
 709                 return 0;
 710             }
 711             if (server->settings_fname)
 712             {
 713                 xmlFree(src);
 714                 yaz_log(YLOG_FATAL, "Can't repeat 'settings'");
 715                 return 0;
 716             }
 717             w = wrbuf_alloc();
 718             conf_dir_path(config, w, (const char *) src);
 719             server->settings_fname = nmem_strdup(nmem, wrbuf_cstr(w));
 720             wrbuf_destroy(w);
 721             xmlFree(src);
 722         }
 723         else if (!strcmp((const char *) n->name, "icu_chain"))
 724         {
 725             if (!server->charsets)
 726                 server->charsets = pp2_charset_fact_create();
 727             if (pp2_charset_fact_define(server->charsets, n, 0))
 728             {
 729                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 730                 return 0;
 731             }
 732         }
 733         else if (!strcmp((const char *) n->name, "relevance")
 734                  || !strcmp((const char *) n->name, "sort")
 735                  || !strcmp((const char *) n->name, "mergekey")
 736                  || !strcmp((const char *) n->name, "facet"))
 737         {
 738             if (!server->charsets)
 739                 server->charsets = pp2_charset_fact_create();
 740             if (pp2_charset_fact_define(server->charsets,
 741                                         n->children, (const char *) n->name))
 742             {
 743                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 744                 return 0;
 745             }
 746         }
 747         else if (!strcmp((const char *) n->name, "service"))
 748         {
 749             char *service_id = (char *)
 750                 xmlGetProp(n, (xmlChar *) "id");
 751
 752             struct conf_service **sp = &server->service;
 753             for (; *sp; sp = &(*sp)->next)
 754                 if ((*sp)->id && service_id &&
 755                     0 == strcmp((*sp)->id, service_id))
 756                 {
 757                     yaz_log(YLOG_FATAL, "Duplicate service: %s", service_id);
 758                     break;
 759                 }
 760                 else if (!(*sp)->id && !service_id)
 761                 {
 762                     yaz_log(YLOG_FATAL, "Duplicate unnamed service");
 763                     break;
 764                 }
 765
 766             if (*sp)  /* service already exist */
 767             {
 768                 xmlFree(service_id);
 769                 return 0;
 770             }
 771             else
 772             {
 773                 struct conf_service *s = service_create_static(server, n,
 774                                                                service_id);
 775                 xmlFree(service_id);
 776                 if (!s)
 777                     return 0;
 778                 *sp = s;
 779             }
 780         }
 781         else
 782         {
 783             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 784             return 0;
 785         }
 786     }
 787     if (server->service)
 788     {
 789         struct conf_service *s;
 790         for (s = server->service; s; s = s->next)
 791             inherit_server_settings(s);
 792     }
 793     return server;
 794 }
 795
 796 WRBUF conf_get_fname(struct conf_config *config, const char *fname)
 797 {
 798     WRBUF w = wrbuf_alloc();
 799
 800     conf_dir_path(config, w, fname);
 801     return w;
 802 }
 803
 804 struct conf_service *locate_service(struct conf_server *server,
 805                                     const char *service_id)
 806 {
 807     struct conf_service *s = server->service;
 808     for (; s; s = s->next)
 809         if (s->id && service_id && 0 == strcmp(s->id, service_id))
 810             break;
 811         else if (!s->id && !service_id)
 812             break;
 813     if (s)
 814         service_incref(s);
 815     return s;
 816 }
 817
 818 void info_services(struct conf_server *server, WRBUF w)
 819 {
 820     struct conf_service *s = server->service;
 821     wrbuf_puts(w, " <services>\n");
 822     for (; s; s = s->next)
 823     {
 824         wrbuf_puts(w, "  <service");
 825         if (s->id)
 826         {
 827             wrbuf_puts(w, " id=\"");
 828             wrbuf_xmlputs(w, s->id);
 829             wrbuf_puts(w, "\"");
 830         }
 831         wrbuf_puts(w, "/>");
 832
 833         wrbuf_puts(w, "\n");
 834     }
 835     wrbuf_puts(w, " </services>\n");
 836 }
 837
 838 static int parse_config(struct conf_config *config, xmlNode *root)
 839 {
 840     xmlNode *n;
 841
 842     for (n = root->children; n; n = n->next)
 843     {
 844         if (n->type != XML_ELEMENT_NODE)
 845             continue;
 846         if (!strcmp((const char *) n->name, "server"))
 847         {
 848             struct conf_server *tmp = server_create(config, config->nmem, n);
 849             if (!tmp)
 850                 return -1;
 851             tmp->next = config->servers;
 852             config->servers = tmp;
 853         }
 854         else if (!strcmp((const char *) n->name, "threads"))
 855         {
 856             xmlChar *number = xmlGetProp(n, (xmlChar *) "number");
 857             if (number)
 858             {
 859                 config->no_threads = atoi((const char *) number);
 860                 xmlFree(number);
 861             }
 862         }
 863         else if (!strcmp((const char *) n->name, "targetprofiles"))
 864         {
 865             yaz_log(YLOG_FATAL, "targetprofiles unsupported here. Must be part of service");
 866             return -1;
 867
 868         }
 869         else
 870         {
 871             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 872             return -1;
 873         }
 874     }
 875     return 0;
 876 }
 877
 878 struct conf_config *config_create(const char *fname, int verbose)
 879 {
 880     xmlDoc *doc = xmlParseFile(fname);
 881     xmlNode *n;
 882     const char *p;
 883     int r;
 884     NMEM nmem = nmem_create();
 885     struct conf_config *config = nmem_malloc(nmem, sizeof(struct conf_config));
 886
 887     xmlSubstituteEntitiesDefault(1);
 888     xmlLoadExtDtdDefaultValue = 1;
 889     if (!doc)
 890     {
 891         yaz_log(YLOG_FATAL, "Failed to read %s", fname);
 892         nmem_destroy(nmem);
 893         return 0;
 894     }
 895
 896     config->nmem = nmem;
 897     config->servers = 0;
 898     config->no_threads = 0;
 899     config->iochan_man = 0;
 900     config->database_hosts = 0;
 901
 902     config->confdir = wrbuf_alloc();
 903     if ((p = strrchr(fname,
 904 #ifdef WIN32
 905                      '\\'
 906 #else
 907                      '/'
 908 #endif
 909              )))
 910     {
 911         int len = p - fname;
 912         wrbuf_write(config->confdir, fname, len);
 913     }
 914     wrbuf_puts(config->confdir, "");
 915
 916     n = xmlDocGetRootElement(doc);
 917     r = yaz_xml_include_simple(n, wrbuf_cstr(config->confdir));
 918     if (r == 0) /* OK */
 919     {
 920         if (verbose)
 921         {
 922             yaz_log(YLOG_LOG, "Configuration %s after include processing",
 923                     fname);
 924 #if LIBXML_VERSION >= 20600
 925             xmlDocFormatDump(yaz_log_file(), doc, 0);
 926 #else
 927             xmlDocDump(yaz_log_file(), doc);
 928 #endif
 929         }
 930         r = parse_config(config, n);
 931     }
 932     xmlFreeDoc(doc);
 933
 934     if (r)
 935     {
 936         config_destroy(config);
 937         return 0;
 938     }
 939     return config;
 940 }
 941
 942 void server_destroy(struct conf_server *server)
 943 {
 944     struct conf_service *s = server->service;
 945     while (s)
 946     {
 947         struct conf_service *s_next = s->next;
 948         service_destroy(s);
 949         s = s_next;
 950     }
 951     pp2_charset_fact_destroy(server->charsets);
 952     yaz_log(YLOG_LOG, "server_destroy server=%p", server);
 953     http_server_destroy(server->http_server);
 954 }
 955
 956 void config_destroy(struct conf_config *config)
 957 {
 958     if (config)
 959     {
 960         struct conf_server *server = config->servers;
 961         iochan_man_destroy(&config->iochan_man);
 962         while (server)
 963         {
 964             struct conf_server *s_next = server->next;
 965             server_destroy(server);
 966             server = s_next;
 967         }
 968         database_hosts_destroy(&config->database_hosts);
 969
 970         wrbuf_destroy(config->confdir);
 971         nmem_destroy(config->nmem);
 972     }
 973 }
 974
 975 void config_stop_listeners(struct conf_config *conf)
 976 {
 977     struct conf_server *ser;
 978     for (ser = conf->servers; ser; ser = ser->next)
 979         http_close_server(ser);
 980 }
 981
 982 void config_process_events(struct conf_config *conf)
 983 {
 984     struct conf_server *ser;
 985
 986     conf->database_hosts = database_hosts_create();
 987     for (ser = conf->servers; ser; ser = ser->next)
 988     {
 989         struct conf_service *s = ser->service;
 990
 991         ser->database_hosts = conf->database_hosts;
 992
 993         for (;s ; s = s->next)
 994         {
 995             resolve_databases(s);
 996             assert(s->mutex == 0);
 997             pazpar2_mutex_create(&s->mutex, "service");
 998         }
 999         http_mutex_init(ser);
1000     }
1001     iochan_man_events(conf->iochan_man);
1002 }
1003
1004 int config_start_listeners(struct conf_config *conf,
1005                            const char *listener_override,
1006                            const char *record_fname)
1007 {
1008     struct conf_server *ser;
1009
1010     conf->iochan_man = iochan_man_create(conf->no_threads);
1011     for (ser = conf->servers; ser; ser = ser->next)
1012     {
1013         WRBUF w = wrbuf_alloc();
1014         int r;
1015
1016         ser->iochan_man = conf->iochan_man;
1017         if (listener_override)
1018         {
1019             wrbuf_puts(w, listener_override);
1020             listener_override = 0; /* only first server is overriden */
1021         }
1022         else
1023         {
1024             if (ser->host)
1025                 wrbuf_puts(w, ser->host);
1026             if (ser->port)
1027             {
1028                 if (wrbuf_len(w))
1029                     wrbuf_puts(w, ":");
1030                 wrbuf_printf(w, "%d", ser->port);
1031             }
1032         }
1033         r = http_init(wrbuf_cstr(w), ser, record_fname);
1034         wrbuf_destroy(w);
1035         if (r)
1036             return -1;
1037
1038         w = wrbuf_alloc();
1039         if (ser->proxy_host || ser->proxy_port)
1040         {
1041             if (ser->proxy_host)
1042                 wrbuf_puts(w, ser->proxy_host);
1043             if (ser->proxy_port)
1044             {
1045                 if (wrbuf_len(w))
1046                     wrbuf_puts(w, ":");
1047                 wrbuf_printf(w, "%d", ser->proxy_port);
1048             }
1049         }
1050         if (wrbuf_len(w))
1051             http_set_proxyaddr(wrbuf_cstr(w), ser);
1052         wrbuf_destroy(w);
1053     }
1054     return 0;
1055 }
1056
1057 /*
1058  * Local variables:
1059  * c-basic-offset: 4
1060  * c-file-style: "Stroustrup"
1061  * indent-tabs-mode: nil
1062  * End:
1063  * vim: shiftwidth=4 tabstop=8 expandtab
1064  */
1065