src/pazpar2_config.c

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