src/pazpar2_config.c

   1 /* This file is part of Pazpar2.
   2    Copyright (C) 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 #include <libxml/xinclude.h>
  30
  31 #include <yaz/yaz-util.h>
  32 #include <yaz/nmem.h>
  33 #include <yaz/snprintf.h>
  34 #include <yaz/tpath.h>
  35 #include <yaz/xml_include.h>
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #if HAVE_UNISTD_H
  40 #include <unistd.h>
  41 #endif
  42 #include "ppmutex.h"
  43 #include "incref.h"
  44 #include "pazpar2_config.h"
  45 #include "service_xslt.h"
  46 #include "settings.h"
  47 #include "eventl.h"
  48 #include "http.h"
  49
  50 struct conf_config
  51 {
  52     NMEM nmem; /* for conf_config and servers memory */
  53     struct conf_server *servers;
  54
  55     int no_threads;
  56     WRBUF confdir;
  57     char *path;
  58     iochan_man_t iochan_man;
  59     database_hosts_t database_hosts;
  60 };
  61
  62 struct service_xslt
  63 {
  64     char *id;
  65     xsltStylesheetPtr xsp;
  66     struct service_xslt *next;
  67 };
  68
  69 static char *xml_context(const xmlNode *ptr, char *res, size_t len)
  70 {
  71     xmlAttr *attr = ptr->properties;
  72     size_t off = len - 1;
  73
  74     res[off] = '\0';
  75     for (; attr; attr = attr->next)
  76     {
  77         size_t l = strlen((const char *) attr->name);
  78         if (off <= l + 1)
  79             break;
  80         off = off - l;
  81         memcpy(res + off, attr->name, l);
  82         res[--off] = '@';
  83     }
  84     while (ptr && ptr->type == XML_ELEMENT_NODE)
  85     {
  86         size_t l = strlen((const char *) ptr->name);
  87         if (off <= l + 1)
  88             break;
  89
  90         off = off - l;
  91         memcpy(res + off, ptr->name, l);
  92         res[--off] = '/';
  93
  94         ptr = ptr->parent;
  95     }
  96     return res + off;
  97 }
  98
  99 struct conf_service *service_init(struct conf_server *server,
 100                                          int num_metadata, int num_sortkeys,
 101                                          const char *service_id)
 102 {
 103     struct conf_service * service = 0;
 104     NMEM nmem = nmem_create();
 105
 106
 107     service = nmem_malloc(nmem, sizeof(struct conf_service));
 108     service->mutex = 0;
 109     service->ref_count = 1;
 110     service->nmem = nmem;
 111     service->next = 0;
 112     service->databases = 0;
 113     service->xslt_list = 0;
 114     service->ccl_bibset = 0;
 115     service->server = server;
 116     service->session_timeout = 60; /* default session timeout */
 117     service->z3950_session_timeout = 180;
 118     service->z3950_operation_timeout = 30;
 119     service->rank_cluster = 1;
 120     service->rank_debug = 0;
 121     service->rank_follow = 0.0;
 122     service->rank_lead = 0.0;
 123     service->rank_length = 2;
 124
 125     service->charsets = 0;
 126
 127     service->id = service_id ? nmem_strdup(nmem, service_id) : 0;
 128
 129     // Setup a dictionary from server.
 130     service->dictionary = 0;
 131
 132     service->settings = nmem_malloc(nmem, sizeof(*service->settings));
 133     service->settings->num_settings = PZ_MAX_EOF;
 134     service->settings->settings = nmem_malloc(nmem, sizeof(struct setting*) * service->settings->num_settings);
 135     memset(service->settings->settings, 0, sizeof(struct setting*) * service->settings->num_settings);
 136     //  inherit_server_settings_values(service);
 137
 138     service->next = 0;
 139
 140     service->num_metadata = num_metadata;
 141
 142     service->metadata = 0;
 143     if (service->num_metadata)
 144         service->metadata
 145             = nmem_malloc(nmem,
 146                           sizeof(struct conf_metadata) * service->num_metadata);
 147     service->num_sortkeys = num_sortkeys;
 148
 149     service->default_sort = nmem_strdup(nmem, "relevance");
 150     service->sortkeys = 0;
 151     if (service->num_sortkeys)
 152         service->sortkeys
 153             = nmem_malloc(nmem,
 154                           sizeof(struct conf_sortkey) * service->num_sortkeys);
 155     service->xml_node = 0;
 156     return service;
 157 }
 158
 159 static struct conf_metadata* conf_service_add_metadata(
 160     struct conf_service *service,
 161     int field_id,
 162     const char *name,
 163     enum conf_metadata_type type,
 164     enum conf_metadata_merge merge,
 165     enum conf_setting_type setting,
 166     int brief,
 167     int termlist,
 168     const char *rank,
 169     int sortkey_offset,
 170     enum conf_metadata_mergekey mt,
 171     const char *facetrule,
 172     const char *limitmap,
 173     const char *limitcluster
 174     )
 175 {
 176     struct conf_metadata * md = 0;
 177     NMEM nmem = service->nmem;
 178
 179     if (!service->metadata || !service->num_metadata
 180         || field_id < 0  || !(field_id < service->num_metadata))
 181         return 0;
 182
 183     md = service->metadata + field_id;
 184     assert(nmem && md && name);
 185
 186     md->name = nmem_strdup(nmem, name);
 187
 188     md->type = type;
 189
 190     // enforcing that type_year is always range_merge
 191     if (md->type == Metadata_type_year)
 192         md->merge = Metadata_merge_range;
 193     else
 194         md->merge = merge;
 195
 196     md->setting = setting;
 197     md->brief = brief;
 198     md->termlist = termlist;
 199     md->rank = nmem_strdup_null(nmem, rank);
 200     md->sortkey_offset = sortkey_offset;
 201     md->mergekey = mt;
 202     md->facetrule = nmem_strdup_null(nmem, facetrule);
 203     md->limitmap = nmem_strdup_null(nmem, limitmap);
 204     md->limitcluster = nmem_strdup_null(nmem, limitcluster);
 205     return md;
 206 }
 207
 208 static struct conf_sortkey *conf_service_add_sortkey(
 209     struct conf_service *service,
 210     int field_id,
 211     const char *name,
 212     enum conf_metadata_type type)
 213 {
 214     struct conf_sortkey *sk = 0;
 215     NMEM nmem = service->nmem;
 216
 217     if (!service->sortkeys || !service->num_sortkeys
 218         || field_id < 0 || !(field_id < service->num_sortkeys))
 219         return 0;
 220
 221     sk = service->sortkeys + field_id;
 222
 223     assert(nmem && sk && name);
 224
 225     sk->name = nmem_strdup(nmem, name);
 226     sk->type = type;
 227     return sk;
 228 }
 229
 230 int conf_service_metadata_field_id(struct conf_service *service,
 231                                    const char * name)
 232 {
 233     int i = 0;
 234
 235     if (!service || !service->metadata || !service->num_metadata)
 236         return -1;
 237
 238     for (i = 0; i < service->num_metadata; i++)
 239         if (!strcmp(name, (service->metadata[i]).name))
 240             return i;
 241     return -1;
 242 }
 243
 244 int conf_service_sortkey_field_id(struct conf_service *service,
 245                                   const char * name)
 246 {
 247     int i = 0;
 248
 249     if (!service || !service->sortkeys || !service->num_sortkeys)
 250         return -1;
 251
 252     for (i = 0; i < service->num_sortkeys; i++)
 253         if (!strcmp(name, (service->sortkeys[i]).name))
 254             return i;
 255     return -1;
 256 }
 257
 258 static void conf_dir_path(struct conf_config *config, WRBUF w, const char *src)
 259 {
 260     char full_path[1024];
 261     if (yaz_filepath_resolve(src, config->path,
 262                              wrbuf_len(config->confdir) > 0 ?
 263                              wrbuf_cstr(config->confdir) : ".",
 264                              full_path))
 265     {
 266         wrbuf_puts(w, full_path);
 267     }
 268     else
 269     {
 270         yaz_log(YLOG_WARN, "File not found: fname=%s path=%s base=%s", src,
 271                 config->path, wrbuf_cstr(config->confdir));
 272         wrbuf_puts(w, src);
 273     }
 274 }
 275
 276 void service_destroy(struct conf_service *service)
 277 {
 278     if (service)
 279     {
 280         if (!pazpar2_decref(&service->ref_count, service->mutex))
 281         {
 282             service_xslt_destroy(service);
 283             pp2_charset_fact_destroy(service->charsets);
 284             ccl_qual_rm(&service->ccl_bibset);
 285             yaz_mutex_destroy(&service->mutex);
 286             nmem_destroy(service->nmem);
 287         }
 288     }
 289 }
 290
 291 void service_incref(struct conf_service *service)
 292 {
 293     pazpar2_incref(&service->ref_count, service->mutex);
 294 }
 295
 296 static int parse_metadata(struct conf_service *service, xmlNode *n,
 297                           int *md_node, int *sk_node)
 298 {
 299     enum conf_metadata_type type = Metadata_type_generic;
 300     enum conf_metadata_merge merge = Metadata_merge_no;
 301     enum conf_setting_type setting = Metadata_setting_no;
 302     enum conf_metadata_mergekey mergekey_type = Metadata_mergekey_no;
 303     int brief = 0;
 304     int termlist = 0;
 305     int sortkey_offset = 0;
 306     xmlChar *xml_name = 0;
 307     xmlChar *xml_brief = 0;
 308     xmlChar *xml_sortkey = 0;
 309     xmlChar *xml_merge = 0;
 310     xmlChar *xml_type = 0;
 311     xmlChar *xml_termlist = 0;
 312     xmlChar *xml_rank = 0;
 313     xmlChar *xml_setting = 0;
 314     xmlChar *xml_mergekey = 0;
 315     xmlChar *xml_limitmap = 0;
 316     xmlChar *xml_limitcluster = 0;
 317     xmlChar *xml_icu_chain = 0;
 318
 319     struct _xmlAttr *attr;
 320
 321     assert(service);
 322
 323     for (attr = n->properties; attr; attr = attr->next)
 324     {
 325         if (!xmlStrcmp(attr->name, BAD_CAST "name") &&
 326             attr->children && attr->children->type == XML_TEXT_NODE)
 327             xml_name = attr->children->content;
 328         else if (!xmlStrcmp(attr->name, BAD_CAST "brief") &&
 329                  attr->children && attr->children->type == XML_TEXT_NODE)
 330             xml_brief = attr->children->content;
 331         else if (!xmlStrcmp(attr->name, BAD_CAST "sortkey") &&
 332                  attr->children && attr->children->type == XML_TEXT_NODE)
 333             xml_sortkey = attr->children->content;
 334         else if (!xmlStrcmp(attr->name, BAD_CAST "merge") &&
 335                  attr->children && attr->children->type == XML_TEXT_NODE)
 336             xml_merge = attr->children->content;
 337         else if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
 338                  attr->children && attr->children->type == XML_TEXT_NODE)
 339             xml_type = attr->children->content;
 340         else if (!xmlStrcmp(attr->name, BAD_CAST "termlist") &&
 341                  attr->children && attr->children->type == XML_TEXT_NODE)
 342             xml_termlist = attr->children->content;
 343         else if (!xmlStrcmp(attr->name, BAD_CAST "rank") &&
 344                  attr->children && attr->children->type == XML_TEXT_NODE)
 345             xml_rank = attr->children->content;
 346         else if (!xmlStrcmp(attr->name, BAD_CAST "setting") &&
 347                  attr->children && attr->children->type == XML_TEXT_NODE)
 348             xml_setting = attr->children->content;
 349         else if (!xmlStrcmp(attr->name, BAD_CAST "mergekey") &&
 350                  attr->children && attr->children->type == XML_TEXT_NODE)
 351             xml_mergekey = attr->children->content;
 352         else if (!xmlStrcmp(attr->name, BAD_CAST "facetrule") &&
 353                  attr->children && attr->children->type == XML_TEXT_NODE)
 354             xml_icu_chain = attr->children->content;
 355         else if (!xmlStrcmp(attr->name, BAD_CAST "limitmap") &&
 356                  attr->children && attr->children->type == XML_TEXT_NODE)
 357             xml_limitmap = attr->children->content;
 358         else if (!xmlStrcmp(attr->name, BAD_CAST "limitcluster") &&
 359                  attr->children && attr->children->type == XML_TEXT_NODE)
 360             xml_limitcluster = attr->children->content;
 361         else
 362         {
 363             yaz_log(YLOG_FATAL, "Unknown metadata attribute '%s'", attr->name);
 364             return -1;
 365         }
 366     }
 367
 368     // now do the parsing logic
 369     if (!xml_name)
 370     {
 371         yaz_log(YLOG_FATAL, "Must specify name in metadata element");
 372         return -1;
 373     }
 374     if (xml_brief)
 375     {
 376         if (!strcmp((const char *) xml_brief, "yes"))
 377             brief = 1;
 378         else if (strcmp((const char *) xml_brief, "no"))
 379         {
 380             yaz_log(YLOG_FATAL, "metadata/brief must be yes or no");
 381             return -1;
 382         }
 383     }
 384
 385     if (xml_termlist)
 386     {
 387         if (!strcmp((const char *) xml_termlist, "yes"))
 388             termlist = 1;
 389         else if (strcmp((const char *) xml_termlist, "no"))
 390         {
 391             yaz_log(YLOG_FATAL, "metadata/termlist must be yes or no");
 392             return -1;
 393         }
 394     }
 395
 396     if (xml_type)
 397     {
 398         if (!strcmp((const char *) xml_type, "generic"))
 399             type = Metadata_type_generic;
 400         else if (!strcmp((const char *) xml_type, "year"))
 401             type = Metadata_type_year;
 402         else if (!strcmp((const char *) xml_type, "date"))
 403             type = Metadata_type_date;
 404         else if (!strcmp((const char *) xml_type, "float"))
 405             type = Metadata_type_float;
 406         else
 407         {
 408             yaz_log(YLOG_FATAL,
 409                     "Unknown value for metadata/type: %s", xml_type);
 410             return -1;
 411         }
 412     }
 413
 414     if (xml_merge)
 415     {
 416         if (!strcmp((const char *) xml_merge, "no"))
 417             merge = Metadata_merge_no;
 418         else if (!strcmp((const char *) xml_merge, "unique"))
 419             merge = Metadata_merge_unique;
 420         else if (!strcmp((const char *) xml_merge, "longest"))
 421             merge = Metadata_merge_longest;
 422         else if (!strcmp((const char *) xml_merge, "range"))
 423             merge = Metadata_merge_range;
 424         else if (!strcmp((const char *) xml_merge, "all"))
 425             merge = Metadata_merge_all;
 426         else if (!strcmp((const char *) xml_merge, "first"))
 427             merge = Metadata_merge_first;
 428         else
 429         {
 430             yaz_log(YLOG_FATAL,
 431                     "Unknown value for metadata/merge: %s", xml_merge);
 432             return -1;
 433         }
 434     }
 435
 436     if (xml_setting)
 437     {
 438         if (!strcmp((const char *) xml_setting, "no"))
 439             setting = Metadata_setting_no;
 440         else if (!strcmp((const char *) xml_setting, "postproc"))
 441             setting = Metadata_setting_postproc;
 442         else if (!strcmp((const char *) xml_setting, "parameter"))
 443             setting = Metadata_setting_parameter;
 444         else
 445         {
 446             yaz_log(YLOG_FATAL,
 447                     "Unknown value for metadata/setting: %s", xml_setting);
 448             return -1;
 449         }
 450     }
 451
 452     // add a sortkey if so specified
 453     if (xml_sortkey && strcmp((const char *) xml_sortkey, "no"))
 454     {
 455         enum conf_metadata_type sk_type = type;
 456         if (merge == Metadata_merge_no)
 457         {
 458             yaz_log(YLOG_FATAL,
 459                     "Can't specify sortkey on a non-merged field");
 460             return -1;
 461         }
 462         if (!strcmp((const char *) xml_sortkey, "yes"))
 463             ;
 464         if (!strcmp((const char *) xml_sortkey, "numeric"))
 465             ;
 466         else if (!strcmp((const char *) xml_sortkey, "skiparticle"))
 467         {
 468             if (sk_type == Metadata_type_generic)
 469                 sk_type = Metadata_type_skiparticle;
 470             else
 471             {
 472                 yaz_log(YLOG_FATAL,
 473                         "skiparticle only supported for type=generic: %s",
 474                     xml_type);
 475                 return -1;
 476             }
 477         }
 478         else
 479         {
 480             yaz_log(YLOG_FATAL,
 481                     "Unknown sortkey in metadata element: %s",
 482                     xml_sortkey);
 483             return -1;
 484         }
 485         sortkey_offset = *sk_node;
 486
 487         conf_service_add_sortkey(service, *sk_node,
 488                                  (const char *) xml_name, sk_type);
 489         (*sk_node)++;
 490     }
 491     else
 492         sortkey_offset = -1;
 493
 494     if (xml_mergekey)
 495     {
 496         if (!strcmp((const char *) xml_mergekey, "required"))
 497             mergekey_type = Metadata_mergekey_required;
 498         else if (!strcmp((const char *) xml_mergekey, "optional"))
 499             mergekey_type = Metadata_mergekey_optional;
 500         else if (!strcmp((const char *) xml_mergekey, "no"))
 501             mergekey_type = Metadata_mergekey_no;
 502         else
 503         {
 504             yaz_log(YLOG_FATAL, "Unknown value for mergekey: %s", xml_mergekey);
 505             return -1;
 506         }
 507     }
 508
 509     // metadata known, assign values
 510     conf_service_add_metadata(service, *md_node,
 511                               (const char *) xml_name,
 512                               type, merge, setting,
 513                               brief, termlist,
 514                               (const char *) xml_rank, sortkey_offset,
 515                               mergekey_type,
 516                               (const char *) xml_icu_chain,
 517                               (const char *) xml_limitmap,
 518                               (const char *) xml_limitcluster);
 519     (*md_node)++;
 520     return 0;
 521 }
 522
 523
 524 static void count_metadata(xmlNode *n, int *num_metadata, int *num_sortkeys)
 525 {
 526     xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 527     (*num_metadata)++;
 528
 529     if (sortkey && strcmp((const char *) sortkey, "no"))
 530         (*num_sortkeys)++;
 531     xmlFree(sortkey);
 532 }
 533
 534
 535 static struct conf_service *service_create_static(struct conf_server *server,
 536                                                   xmlNode *node,
 537                                                   const char *service_id)
 538 {
 539     xmlNode *n;
 540     int md_node = 0;
 541     int sk_node = 0;
 542
 543     struct conf_service *service = 0;
 544     int num_metadata = 0;
 545     int num_sortkeys = 0;
 546     int got_settings = 0;
 547
 548     // count num_metadata and num_sortkeys
 549     for (n = node->children; n; n = n->next)
 550         if (n->type == XML_ELEMENT_NODE && !strcmp((const char *)
 551                                                    n->name, "metadata"))
 552         {
 553             if (n->children) // This is a <metadata> container, look at its contents.
 554             {
 555                 xmlNode *m;
 556                 for (m = n->children; m; m = m->next)
 557                 {
 558                     if (m->type == XML_ELEMENT_NODE &&
 559                             !strcmp((const char *) m->name, "metadata"))
 560                         count_metadata(m, &num_metadata, &num_sortkeys);
 561                 }
 562             }
 563             else // This is a metadata-element proper, count it right away.
 564                 count_metadata(n, &num_metadata, &num_sortkeys);
 565         }
 566
 567     service = service_init(server, num_metadata, num_sortkeys, service_id);
 568
 569     for (n = node->children; n; n = n->next)
 570     {
 571         if (n->type != XML_ELEMENT_NODE)
 572             continue;
 573         if (!strcmp((const char *) n->name, "timeout"))
 574         {
 575             xmlChar *src = xmlGetProp(n, (xmlChar *) "session");
 576             if (src)
 577             {
 578                 service->session_timeout = atoi((const char *) src);
 579                 xmlFree(src);
 580                 if (service->session_timeout < 9)
 581                 {
 582                     yaz_log(YLOG_FATAL, "session timeout out of range");
 583                     return 0;
 584                 }
 585             }
 586             src = xmlGetProp(n, (xmlChar *) "z3950_operation");
 587             if (src)
 588             {
 589                 service->z3950_operation_timeout = atoi((const char *) src);
 590                 xmlFree(src);
 591                 if (service->z3950_session_timeout < 9)
 592                 {
 593                     yaz_log(YLOG_FATAL, "Z39.50 operation timeout out of range");
 594                     return 0;
 595                 }
 596             }
 597             src = xmlGetProp(n, (xmlChar *) "z3950_session");
 598             if (src)
 599             {
 600                 service->z3950_session_timeout = atoi((const char *) src);
 601                 xmlFree(src);
 602                 if (service->z3950_session_timeout < 9)
 603                 {
 604                     yaz_log(YLOG_FATAL, "Z39.50 session timeout out of range");
 605                     return 0;
 606                 }
 607             }
 608         }
 609         else if (!strcmp((const char *) n->name, "ccldirective"))
 610         {
 611             char *name;
 612             char *value;
 613             if (!service->ccl_bibset)
 614                 service->ccl_bibset = ccl_qual_mk();
 615             name = (char *) xmlGetProp(n, (xmlChar *) "name");
 616             if (!name)
 617             {
 618                 yaz_log(YLOG_FATAL, "ccldirective: missing @name");
 619                 return 0;
 620             }
 621             value = (char *) xmlGetProp(n, (xmlChar *) "value");
 622             if (!value)
 623             {
 624                 xmlFree(name);
 625                 yaz_log(YLOG_FATAL, "ccldirective: missing @value");
 626                 return 0;
 627             }
 628             ccl_qual_add_special(service->ccl_bibset, name, value);
 629             xmlFree(value);
 630             xmlFree(name);
 631         }
 632         else if (!strcmp((const char *) n->name, "settings"))
 633             got_settings++;
 634         else if (!strcmp((const char *) n->name, "icu_chain"))
 635         {
 636             if (!service->charsets)
 637                 service->charsets = pp2_charset_fact_create();
 638             if (pp2_charset_fact_define(service->charsets, n, 0))
 639             {
 640                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 641                 return 0;
 642             }
 643         }
 644         else if (!strcmp((const char *) n->name, "relevance")
 645                  || !strcmp((const char *) n->name, "sort")
 646                  || !strcmp((const char *) n->name, "mergekey")
 647                  || !strcmp((const char *) n->name, "facet"))
 648
 649         {
 650             if (!service->charsets)
 651                 service->charsets = pp2_charset_fact_create();
 652             if (pp2_charset_fact_define(service->charsets, n,
 653                                         (const char *) n->name))
 654             {
 655                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 656                 return 0;
 657             }
 658         }
 659         else if (!strcmp((const char *) n->name, (const char *) "metadata"))
 660         {
 661             if (n->children) // This is a <metadata> container, look at its content.
 662             {
 663                 xmlNode *m;
 664                 for (m = n->children; m; m = m->next)
 665                     if ((!strcmp((const char *) m->name, (const char *) "metadata")))
 666                         if (parse_metadata(service, m, &md_node, &sk_node))
 667                             return 0;
 668             }
 669             else // This is a metadata-element proper, count it right away.
 670                 if (parse_metadata(service, n, &md_node, &sk_node))
 671                     return 0;
 672         }
 673         else if (!strcmp((const char *) n->name, (const char *) "xslt"))
 674         {
 675             if (service_xslt_config(service, n))
 676                 return 0;
 677         }
 678         else if (!strcmp((const char *) n->name, "rank"))
 679         {
 680             char *rank_cluster = (char *) xmlGetProp(n, (xmlChar *) "cluster");
 681             char *rank_debug = (char *) xmlGetProp(n, (xmlChar *) "debug");
 682             char *rank_follow = (char *) xmlGetProp(n, (xmlChar *) "follow");
 683             char *rank_lead = (char *) xmlGetProp(n, (xmlChar *) "lead");
 684             char *rank_length= (char *) xmlGetProp(n, (xmlChar *) "length");
 685             if (rank_cluster)
 686             {
 687                 if (!strcmp(rank_cluster, "yes"))
 688                     service->rank_cluster = 1;
 689                 else if (!strcmp(rank_cluster, "no"))
 690                     service->rank_cluster = 0;
 691                 else
 692                 {
 693                     yaz_log(YLOG_FATAL, "service: rank@cluster boolean");
 694                     return 0;
 695                 }
 696             }
 697             if (rank_debug)
 698             {
 699                 if (!strcmp(rank_debug, "yes"))
 700                     service->rank_debug = 1;
 701                 else if (!strcmp(rank_debug, "no"))
 702                     service->rank_debug = 0;
 703                 else
 704                 {
 705                     yaz_log(YLOG_FATAL, "service: rank@debug boolean");
 706                     return 0;
 707                 }
 708             }
 709             if (rank_follow)
 710             {
 711                 service->rank_follow = atof(rank_follow);
 712             }
 713             if (rank_lead)
 714             {
 715                 service->rank_lead = atof(rank_lead);
 716             }
 717             if (rank_length)
 718             {
 719                 if (!strcmp(rank_length, "linear"))
 720                     service->rank_length = 2;
 721                 else if (!strcmp(rank_length, "log"))
 722                     service->rank_length = 1;
 723                 else if (!strcmp(rank_length, "none"))
 724                     service->rank_length = 0;
 725                 else
 726                 {
 727                     yaz_log(YLOG_FATAL, "service: rank@length linear|log|none");
 728                     return 0;
 729                 }
 730             }
 731             xmlFree(rank_cluster);
 732             xmlFree(rank_debug);
 733             xmlFree(rank_follow);
 734             xmlFree(rank_lead);
 735             xmlFree(rank_length);
 736         }
 737         else if (!strcmp((const char *) n->name, "sort-default"))
 738         {
 739             char *default_sort = (char *) xmlGetProp(n, (xmlChar *) "field");
 740
 741             if (default_sort && strcmp(default_sort, "")) {
 742                 service->default_sort = nmem_strdup(service->nmem, default_sort);
 743                 yaz_log(YLOG_LOG, "service %s: default sort order configured to: %s",
 744                         service_id ? service_id : "unnamed", default_sort);
 745             }
 746             else
 747             {
 748                 yaz_log(YLOG_FATAL, "default sort order is invalid: %s", default_sort);
 749                 return 0;
 750             }
 751             xmlFree(default_sort);
 752         }
 753         else
 754         {
 755             char tmp[80];
 756             yaz_log(YLOG_FATAL, "Bad element: %s . Context: %s", n->name,
 757                     xml_context(n, tmp, sizeof tmp));
 758             return 0;
 759         }
 760     }
 761     if (got_settings)
 762     {
 763         int pass;
 764         /* metadata has been read.. Consider now settings */
 765         init_settings(service);
 766         for (pass = 1; pass <= 2; pass++)
 767         {
 768             for (n = node->children; n; n = n->next)
 769             {
 770                 if (n->type != XML_ELEMENT_NODE)
 771                     continue;
 772                 if (!strcmp((const char *) n->name, "settings"))
 773                 {
 774                     int ret;
 775                     xmlChar *src = xmlGetProp(n, (xmlChar *) "src");
 776                     if (src)
 777                     {
 778                         WRBUF w = wrbuf_alloc();
 779                         conf_dir_path(server->config, w, (const char *) src);
 780                         ret = settings_read_file(service, wrbuf_cstr(w), pass);
 781                         wrbuf_destroy(w);
 782                         xmlFree(src);
 783                     }
 784                     else
 785                     {
 786                         ret = settings_read_node(service, n, pass);
 787                     }
 788                     if (ret)
 789                         return 0;
 790                 }
 791             }
 792         }
 793     }
 794
 795     {
 796         xmlBufferPtr buf = xmlBufferCreate();
 797         xmlNodeDump(buf, node->doc, node, 0, 0);
 798         service->xml_node =
 799             nmem_strdupn(service->nmem, (const char *) buf->content, buf->use);
 800         xmlBufferFree(buf);
 801     }
 802     return service;
 803 }
 804
 805 static int inherit_server_settings(struct conf_service *s)
 806 {
 807     int ret = 0;
 808     struct conf_server *server = s->server;
 809     if (!s->dictionary) /* service has no config settings ? */
 810     {
 811         if (server->settings_fname)
 812         {
 813             /* inherit settings from server */
 814             init_settings(s);
 815             if (settings_read_file(s, server->settings_fname, 1))
 816                 ret = -1;
 817             if (settings_read_file(s, server->settings_fname, 2))
 818                 ret = -1;
 819         }
 820         else
 821         {
 822             yaz_log(YLOG_WARN, "server '%s' has no settings", s->id ? s->id : "unnamed");
 823             init_settings(s);
 824         }
 825     }
 826
 827     /* use relevance/sort/mergekey/facet from server if not defined
 828        for this service.. */
 829     if (!s->charsets)
 830     {
 831         if (server->charsets)
 832         {
 833             s->charsets = server->charsets;
 834             pp2_charset_fact_incref(s->charsets);
 835         }
 836         else
 837         {
 838             s->charsets = pp2_charset_fact_create();
 839         }
 840     }
 841     return ret;
 842 }
 843
 844 struct conf_service *service_create(struct conf_server *server,
 845                                     xmlNode *node)
 846 {
 847     struct conf_service *service = service_create_static(server, node, 0);
 848     if (service)
 849     {
 850         inherit_server_settings(service);
 851         assert(service->mutex == 0);
 852         pazpar2_mutex_create(&service->mutex, "conf");
 853     }
 854     return service;
 855 }
 856
 857 static struct conf_server *server_create(struct conf_config *config,
 858                                          NMEM nmem, xmlNode *node)
 859 {
 860     xmlNode *n;
 861     struct conf_server *server = nmem_malloc(nmem, sizeof(struct conf_server));
 862     xmlChar *server_id = xmlGetProp(node, (xmlChar *) "id");
 863
 864     server->host = "@";
 865     server->port = 0;
 866     server->proxy_host = 0;
 867     server->proxy_port = 0;
 868     server->myurl = 0;
 869     server->service = 0;
 870     server->config = config;
 871     server->next = 0;
 872     server->charsets = 0;
 873     server->http_server = 0;
 874     server->iochan_man = 0;
 875     server->database_hosts = config->database_hosts;
 876     server->settings_fname = 0;
 877
 878     if (server_id)
 879     {
 880         server->server_id = nmem_strdup(nmem, (const char *)server_id);
 881         xmlFree(server_id);
 882     }
 883     else
 884         server->server_id = 0;
 885     for (n = node->children; n; n = n->next)
 886     {
 887         if (n->type != XML_ELEMENT_NODE)
 888             continue;
 889         if (!strcmp((const char *) n->name, "listen"))
 890         {
 891             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 892             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 893
 894             if (port)
 895                 server->port = nmem_strdup(nmem, (const char *) port);
 896             if (host)
 897                 server->host = nmem_strdup(nmem, (const char *) host);
 898
 899             xmlFree(port);
 900             xmlFree(host);
 901         }
 902         else if (!strcmp((const char *) n->name, "proxy"))
 903         {
 904             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 905             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 906             xmlChar *myurl = xmlGetProp(n, (xmlChar *) "myurl");
 907             if (port)
 908                 server->proxy_port = atoi((const char *) port);
 909             if (host)
 910                 server->proxy_host = nmem_strdup(nmem, (const char *) host);
 911             if (myurl)
 912                 server->myurl = nmem_strdup(nmem, (const char *) myurl);
 913             xmlFree(port);
 914             xmlFree(host);
 915             xmlFree(myurl);
 916         }
 917         else if (!strcmp((const char *) n->name, "settings"))
 918         {
 919             xmlChar *src = xmlGetProp(n, (xmlChar *) "src");
 920             WRBUF w;
 921             if (!src)
 922             {
 923                 yaz_log(YLOG_FATAL, "Missing src attribute for settings");
 924                 return 0;
 925             }
 926             if (server->settings_fname)
 927             {
 928                 xmlFree(src);
 929                 yaz_log(YLOG_FATAL, "Can't repeat 'settings'");
 930                 return 0;
 931             }
 932             w = wrbuf_alloc();
 933             conf_dir_path(config, w, (const char *) src);
 934             server->settings_fname = nmem_strdup(nmem, wrbuf_cstr(w));
 935             wrbuf_destroy(w);
 936             xmlFree(src);
 937         }
 938         else if (!strcmp((const char *) n->name, "icu_chain"))
 939         {
 940             if (!server->charsets)
 941                 server->charsets = pp2_charset_fact_create();
 942             if (pp2_charset_fact_define(server->charsets, n, 0))
 943             {
 944                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 945                 return 0;
 946             }
 947         }
 948         else if (!strcmp((const char *) n->name, "relevance")
 949                  || !strcmp((const char *) n->name, "sort")
 950                  || !strcmp((const char *) n->name, "mergekey")
 951                  || !strcmp((const char *) n->name, "facet"))
 952         {
 953             if (!server->charsets)
 954                 server->charsets = pp2_charset_fact_create();
 955             if (pp2_charset_fact_define(server->charsets, n,
 956                                         (const char *) n->name))
 957             {
 958                 yaz_log(YLOG_FATAL, "ICU chain definition error");
 959                 return 0;
 960             }
 961         }
 962         else if (!strcmp((const char *) n->name, "service"))
 963         {
 964             char *service_id = (char *)
 965                 xmlGetProp(n, (xmlChar *) "id");
 966
 967             struct conf_service **sp = &server->service;
 968             for (; *sp; sp = &(*sp)->next)
 969                 if ((*sp)->id && service_id &&
 970                     0 == strcmp((*sp)->id, service_id))
 971                 {
 972                     yaz_log(YLOG_FATAL, "Duplicate service: %s", service_id);
 973                     break;
 974                 }
 975                 else if (!(*sp)->id && !service_id)
 976                 {
 977                     yaz_log(YLOG_FATAL, "Duplicate unnamed service");
 978                     break;
 979                 }
 980
 981             if (*sp)  /* service already exist */
 982             {
 983                 xmlFree(service_id);
 984                 return 0;
 985             }
 986             else
 987             {
 988                 struct conf_service *s = service_create_static(server, n,
 989                                                                service_id);
 990                 xmlFree(service_id);
 991                 if (!s)
 992                     return 0;
 993                 *sp = s;
 994             }
 995         }
 996         else
 997         {
 998             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 999             return 0;
1000         }
1001     }
1002     if (!server->port)
1003     {
1004         yaz_log(YLOG_FATAL, "No listening port given");
1005         return 0;
1006     }
1007     if (server->service)
1008     {
1009         struct conf_service *s;
1010         for (s = server->service; s; s = s->next)
1011             inherit_server_settings(s);
1012     }
1013     return server;
1014 }
1015
1016 WRBUF conf_get_fname(struct conf_config *config, const char *fname)
1017 {
1018     WRBUF w = wrbuf_alloc();
1019
1020     conf_dir_path(config, w, fname);
1021     return w;
1022 }
1023
1024 struct conf_service *locate_service(struct conf_server *server,
1025                                     const char *service_id)
1026 {
1027     struct conf_service *s = server->service;
1028     for (; s; s = s->next)
1029         if (s->id && service_id && 0 == strcmp(s->id, service_id))
1030             break;
1031         else if (!s->id && !service_id)
1032             break;
1033     if (s)
1034         service_incref(s);
1035     return s;
1036 }
1037
1038 static void info_service_metadata(struct conf_service *service, WRBUF w)
1039 {
1040     int i;
1041     struct conf_metadata *md;
1042
1043     if (service->num_metadata)
1044     {
1045         for (i = 0; i < service->num_metadata; i++)
1046         {
1047             md = &(service->metadata[i]);
1048             wrbuf_puts(w, "   <metadata");
1049             if (md->name) {
1050                 wrbuf_puts(w, " name=\"");
1051                 wrbuf_xmlputs(w, md->name);
1052                 wrbuf_puts(w, "\"");
1053             }
1054             if (md->brief) {
1055                 wrbuf_puts(w, " brief=\"yes\"");
1056             }
1057             if (md->termlist) {
1058                 wrbuf_puts(w, " termlist=\"yes\"");
1059             }
1060             if (md->rank) {
1061                 wrbuf_puts(w, " rank=\"");
1062                 wrbuf_xmlputs(w, md->rank);
1063                 wrbuf_puts(w, "\"");
1064             }
1065             if (md->sortkey_offset > 0) {
1066                 wrbuf_puts(w, " sortkey=\"");
1067                 switch (service->sortkeys[md->sortkey_offset].type)
1068                 {
1069                 case Metadata_type_relevance:
1070                     wrbuf_puts(w, "relevance");
1071                     break;
1072                 case Metadata_type_skiparticle:
1073                     wrbuf_puts(w, "skiparticle");
1074                     break;
1075                 case Metadata_type_position:
1076                     wrbuf_puts(w, "position");
1077                     break;
1078                 default:
1079                     wrbuf_puts(w, "yes");
1080                     break;
1081                 }
1082                 wrbuf_puts(w, "\"");
1083             }
1084             switch (md->type)
1085             {
1086             case Metadata_type_generic:
1087             case Metadata_type_skiparticle:
1088                 break;
1089             case Metadata_type_year:
1090                 wrbuf_puts(w, " type=\"year\"");
1091                 break;
1092             case Metadata_type_date:
1093                 wrbuf_puts(w, " type=\"date\"");
1094                 break;
1095             case Metadata_type_float:
1096                 wrbuf_puts(w, " type=\"float\"");
1097                 break;
1098             case Metadata_type_relevance:
1099             case Metadata_type_position:
1100                 break;
1101             }
1102             switch (md->merge)
1103             {
1104             case Metadata_merge_no:
1105                 break;
1106             case Metadata_merge_unique:
1107                 wrbuf_puts(w, " merge=\"unique\"");
1108                 break;
1109             case Metadata_merge_longest:
1110                 wrbuf_puts(w, " merge=\"longest\"");
1111                 break;
1112             case Metadata_merge_range:
1113                 wrbuf_puts(w, " merge=\"range\"");
1114                 break;
1115             case Metadata_merge_all:
1116                 wrbuf_puts(w, " merge=\"all\"");
1117                 break;
1118             case Metadata_merge_first:
1119                 wrbuf_puts(w, " merge=\"first\"");
1120                 break;
1121             }
1122             switch (md->mergekey)
1123             {
1124             case Metadata_mergekey_no:
1125                 break;
1126             case Metadata_mergekey_optional:
1127                 wrbuf_puts(w, " mergekey=\"optional\"");
1128                 break;
1129             case Metadata_mergekey_required:
1130                 wrbuf_puts(w, " mergekey=\"required\"");
1131                 break;
1132             }
1133             wrbuf_puts(w, " />\n");
1134         }
1135     }
1136 }
1137
1138 static void info_service_databases(struct conf_service *service, WRBUF w)
1139 {
1140     struct database *db;
1141     struct setting *s;
1142     int i;
1143
1144     if (service->databases)
1145     {
1146         wrbuf_puts(w, "   <databases>\n");
1147         for(db = service->databases; db; db = db->next)
1148         {
1149             wrbuf_puts(w, "    <database");
1150             if (db->id)
1151             {
1152                 wrbuf_puts(w, " id=\"");
1153                 wrbuf_printf(w, "%s", db->id);
1154                 wrbuf_puts(w, "\"");
1155             }
1156             wrbuf_puts(w, ">\n");
1157             for (i = 0; i < db->num_settings; i++)
1158             {
1159                 s = db->settings[i];
1160                 while (s != NULL)
1161                 {
1162                     wrbuf_puts(w, "     <setting");
1163                     wrbuf_puts(w, " name=\"");
1164                     wrbuf_xmlputs(w, s->name);
1165                     wrbuf_puts(w, "\"");
1166                     wrbuf_puts(w, " value=\"");
1167                     wrbuf_xmlputs(w, s->value);
1168                     wrbuf_puts(w, "\"");
1169                     wrbuf_puts(w, " />\n");
1170                     s = s->next;
1171                 }
1172             }
1173             wrbuf_puts(w, "    </database>\n");
1174         }
1175         wrbuf_puts(w, "   </databases>\n");
1176     }
1177 }
1178
1179 void info_services(struct conf_server *server, WRBUF w)
1180 {
1181     struct conf_service *s = server->service;
1182     int i;
1183     struct setting *S;
1184
1185     wrbuf_puts(w, " <services>\n");
1186     for (; s; s = s->next)
1187     {
1188         wrbuf_puts(w, "  <service");
1189         if (s->id)
1190         {
1191             wrbuf_puts(w, " id=\"");
1192             wrbuf_xmlputs(w, s->id);
1193             wrbuf_puts(w, "\"");
1194         }
1195         wrbuf_puts(w, ">\n");
1196         if (s->settings)
1197         {
1198             for (i=0; i<s->settings->num_settings; i++)
1199             {
1200                 S = s->settings->settings[i];
1201                 while (S != NULL) {
1202                     wrbuf_puts(w, "   <setting");
1203                     wrbuf_puts(w, " name=\"");
1204                     wrbuf_xmlputs(w,  S->name);
1205                     wrbuf_puts(w, "\"");
1206                     wrbuf_puts(w, " value=\"");
1207                     wrbuf_xmlputs(w, S->value);
1208                     wrbuf_puts(w, "\"");
1209                     if (S->target) {
1210                         wrbuf_puts(w, " target=\"");
1211                         wrbuf_xmlputs(w, S->target);
1212                         wrbuf_puts(w, "\"");
1213                     }
1214
1215                     wrbuf_puts(w, " />\n");
1216
1217                     S = S->next;
1218                 }
1219             }
1220         }
1221         info_service_metadata(s, w);
1222         info_service_databases(s, w);
1223         wrbuf_puts(w, "  </service>");
1224
1225         wrbuf_puts(w, "\n");
1226     }
1227     wrbuf_puts(w, " </services>\n");
1228 }
1229
1230 static int parse_config(struct conf_config *config, xmlNode *root)
1231 {
1232     xmlNode *n;
1233
1234     for (n = root->children; n; n = n->next)
1235     {
1236         if (n->type != XML_ELEMENT_NODE)
1237             continue;
1238         if (!strcmp((const char *) n->name, "server"))
1239         {
1240             struct conf_server *tmp = server_create(config, config->nmem, n);
1241             if (!tmp)
1242                 return -1;
1243             tmp->next = config->servers;
1244             config->servers = tmp;
1245         }
1246         else if (!strcmp((const char *) n->name, "threads"))
1247         {
1248             xmlChar *number = xmlGetProp(n, (xmlChar *) "number");
1249             if (number)
1250             {
1251                 config->no_threads = atoi((const char *) number);
1252                 xmlFree(number);
1253             }
1254         }
1255         else if (!strcmp((const char *) n->name, "file"))
1256         {
1257             xmlChar *path = xmlGetProp(n, (xmlChar *) "path");
1258             if (path)
1259             {
1260                 config->path = nmem_strdup(config->nmem, (const char *) path);
1261                 xmlFree(path);
1262             }
1263         }
1264         else if (!strcmp((const char *) n->name, "targetprofiles"))
1265         {
1266             yaz_log(YLOG_FATAL, "targetprofiles unsupported here. Must be part of service");
1267             return -1;
1268
1269         }
1270         else
1271         {
1272             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
1273             return -1;
1274         }
1275     }
1276     return 0;
1277 }
1278
1279 struct conf_config *config_create(const char *fname)
1280 {
1281     xmlDoc *doc = xmlReadFile(fname,
1282                               NULL,
1283                               XML_PARSE_XINCLUDE
1284                               + XML_PARSE_NSCLEAN + XML_PARSE_NONET);
1285     xmlNode *n;
1286     const char *p;
1287     int r;
1288     NMEM nmem = nmem_create();
1289     struct conf_config *config = nmem_malloc(nmem, sizeof(struct conf_config));
1290
1291     xmlSubstituteEntitiesDefault(1);
1292     xmlLoadExtDtdDefaultValue = 1;
1293     if (!doc)
1294     {
1295         yaz_log(YLOG_FATAL, "Failed to read %s", fname);
1296         nmem_destroy(nmem);
1297         return 0;
1298     }
1299
1300     // Perform XInclude.
1301     r = xmlXIncludeProcess(doc);
1302     if (r == -1)
1303     {
1304         yaz_log(YLOG_FATAL, "XInclude processing failed");
1305         return 0;
1306     }
1307
1308     config->nmem = nmem;
1309     config->servers = 0;
1310     config->path = nmem_strdup(nmem, ".");
1311     config->no_threads = 0;
1312     config->iochan_man = 0;
1313     config->database_hosts = database_hosts_create();
1314
1315     config->confdir = wrbuf_alloc();
1316     if ((p = strrchr(fname,
1317 #ifdef WIN32
1318                      '\\'
1319 #else
1320                      '/'
1321 #endif
1322              )))
1323     {
1324         int len = p - fname;
1325         wrbuf_write(config->confdir, fname, len);
1326     }
1327     wrbuf_puts(config->confdir, "");
1328
1329     n = xmlDocGetRootElement(doc);
1330     r = yaz_xml_include_simple(n, wrbuf_cstr(config->confdir));
1331     if (r == 0) /* OK */
1332     {
1333         yaz_log(YLOG_LOG, "Configuration %s after include processing",
1334                 fname);
1335 #if LIBXML_VERSION >= 20600
1336         xmlDocFormatDump(yaz_log_file(), doc, 0);
1337 #else
1338         xmlDocDump(yaz_log_file(), doc);
1339 #endif
1340         r = parse_config(config, n);
1341     }
1342     xmlFreeDoc(doc);
1343
1344     if (r)
1345     {
1346         config_destroy(config);
1347         return 0;
1348     }
1349     return config;
1350 }
1351
1352 void server_destroy(struct conf_server *server)
1353 {
1354     struct conf_service *s = server->service;
1355     while (s)
1356     {
1357         struct conf_service *s_next = s->next;
1358         service_destroy(s);
1359         s = s_next;
1360     }
1361     pp2_charset_fact_destroy(server->charsets);
1362     http_server_destroy(server->http_server);
1363 }
1364
1365 void config_destroy(struct conf_config *config)
1366 {
1367     if (config)
1368     {
1369         struct conf_server *server = config->servers;
1370         iochan_man_destroy(&config->iochan_man);
1371         while (server)
1372         {
1373             struct conf_server *s_next = server->next;
1374             server_destroy(server);
1375             server = s_next;
1376             database_hosts_destroy(&config->database_hosts);
1377         }
1378         wrbuf_destroy(config->confdir);
1379         nmem_destroy(config->nmem);
1380     }
1381 }
1382
1383 void config_stop_listeners(struct conf_config *conf)
1384 {
1385     struct conf_server *ser;
1386     for (ser = conf->servers; ser; ser = ser->next)
1387         http_close_server(ser);
1388 }
1389
1390 void config_process_events(struct conf_config *conf)
1391 {
1392     struct conf_server *ser;
1393
1394     for (ser = conf->servers; ser; ser = ser->next)
1395     {
1396         struct conf_service *s = ser->service;
1397
1398         for (;s ; s = s->next)
1399         {
1400             assert(s->mutex == 0);
1401             pazpar2_mutex_create(&s->mutex, "service");
1402         }
1403         http_mutex_init(ser);
1404     }
1405     iochan_man_events(conf->iochan_man);
1406 }
1407
1408 int config_start_listeners(struct conf_config *conf,
1409                            const char *listener_override,
1410                            const char *record_fname)
1411 {
1412     struct conf_server *ser;
1413
1414     conf->iochan_man = iochan_man_create(conf->no_threads);
1415     for (ser = conf->servers; ser; ser = ser->next)
1416     {
1417         WRBUF w;
1418         int r;
1419
1420         ser->iochan_man = conf->iochan_man;
1421         if (listener_override)
1422         {
1423             const char *cp = strrchr(listener_override, ':');
1424             if (cp)
1425             {
1426                 ser->host = nmem_strdupn(conf->nmem, listener_override,
1427                                          cp - listener_override);
1428                 ser->port = nmem_strdup(conf->nmem, cp + 1);
1429             }
1430             else
1431             {
1432                 ser->host = "@";
1433                 ser->port = nmem_strdup(conf->nmem, listener_override);
1434             }
1435             listener_override = 0; /* only first server is overriden */
1436         }
1437         r = http_init(ser, record_fname);
1438         if (r)
1439             return -1;
1440
1441         w = wrbuf_alloc();
1442         if (ser->proxy_host || ser->proxy_port)
1443         {
1444             if (ser->proxy_host)
1445                 wrbuf_puts(w, ser->proxy_host);
1446             if (ser->proxy_port)
1447             {
1448                 if (wrbuf_len(w))
1449                     wrbuf_puts(w, ":");
1450                 wrbuf_printf(w, "%d", ser->proxy_port);
1451             }
1452         }
1453         if (wrbuf_len(w))
1454             http_set_proxyaddr(wrbuf_cstr(w), ser);
1455         wrbuf_destroy(w);
1456     }
1457     return 0;
1458 }
1459
1460 /*
1461  * Local variables:
1462  * c-basic-offset: 4
1463  * c-file-style: "Stroustrup"
1464  * indent-tabs-mode: nil
1465  * End:
1466  * vim: shiftwidth=4 tabstop=8 expandtab
1467  */
1468