src/config.c

   1 /* $Id: config.c,v 1.31 2007-04-26 10:19:05 marc Exp $
   2    Copyright (c) 2006-2007, Index Data.
   3
   4 This file is part of Pazpar2.
   5
   6 Pazpar2 is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Pazpar2; see the file LICENSE.  If not, write to the
  18 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.
  20  */
  21
  22 /* $Id: config.c,v 1.31 2007-04-26 10:19:05 marc Exp $ */
  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 #if HAVE_CONFIG_H
  33 #include <cconfig.h>
  34 #endif
  35
  36 #include <yaz/yaz-util.h>
  37 #include <yaz/nmem.h>
  38
  39 #define CONFIG_NOEXTERNS
  40 #include "config.h"
  41
  42 static NMEM nmem = 0;
  43 static char confdir[256] = ".";
  44
  45 struct conf_config *config = 0;
  46
  47
  48 struct conf_metadata * conf_metadata_assign(NMEM nmem,
  49                                             struct conf_metadata * metadata,
  50                                             const char *name,
  51                                             enum conf_metadata_type type,
  52                                             enum conf_metadata_merge merge,
  53                                             int brief,
  54                                             int termlist,
  55                                             int rank,
  56                                             int sortkey_offset)
  57 {
  58     if (!nmem || !metadata || !name)
  59         return 0;
  60
  61     metadata->name = nmem_strdup(nmem, name);
  62     metadata->type = type;
  63     metadata->merge = merge;
  64     metadata->brief = brief;
  65     metadata->termlist = termlist;
  66     metadata->rank = rank;
  67     metadata->sortkey_offset = sortkey_offset;
  68
  69     return metadata;
  70 }
  71
  72
  73 struct conf_sortkey * conf_sortkey_assign(NMEM nmem,
  74                                           struct conf_sortkey * sortkey,
  75                                           const char *name,
  76                                           enum conf_sortkey_type type)
  77 {
  78     if (!nmem || !sortkey || !name)
  79         return 0;
  80
  81     sortkey->name = nmem_strdup(nmem, name);
  82     sortkey->type = type;
  83
  84     return sortkey;
  85 }
  86
  87
  88 struct conf_service * conf_service_create(NMEM nmem,
  89                                           int num_metadata, int num_sortkeys)
  90 {
  91     struct conf_service * service = 0;
  92
  93     //assert(nmem);
  94
  95     service = nmem_malloc(nmem, sizeof(struct conf_service));
  96
  97     service->num_metadata = num_metadata;
  98     service->metadata = 0;
  99     if (service->num_metadata)
 100       service->metadata
 101           = nmem_malloc(nmem,
 102                         sizeof(struct conf_metadata) * service->num_metadata);
 103     service->num_sortkeys = num_sortkeys;
 104     service->sortkeys = 0;
 105     if (service->num_sortkeys)
 106         service->sortkeys
 107             = nmem_malloc(nmem,
 108                           sizeof(struct conf_sortkey) * service->num_sortkeys);
 109     return service;
 110 }
 111
 112 struct conf_metadata* conf_service_add_metadata(NMEM nmem,
 113                                                 struct conf_service *service,
 114                                                 int field_id,
 115                                                 const char *name,
 116                                                 enum conf_metadata_type type,
 117                                                 enum conf_metadata_merge merge,
 118                                                 int brief,
 119                                                 int termlist,
 120                                                 int rank,
 121                                                 int sortkey_offset)
 122 {
 123     struct conf_metadata * md = 0;
 124
 125     if (!service || !service->metadata || !service->num_metadata
 126         || field_id < 0  || !(field_id < service->num_metadata))
 127         return 0;
 128
 129     //md = &((service->metadata)[field_id]);
 130     md = service->metadata + field_id;
 131     md = conf_metadata_assign(nmem, md, name, type, merge,
 132                              brief, termlist, rank, sortkey_offset);
 133     return md;
 134 }
 135
 136
 137 struct conf_sortkey * conf_service_add_sortkey(NMEM nmem,
 138                                                struct conf_service *service,
 139                                                int field_id,
 140                                                const char *name,
 141                                                enum conf_sortkey_type type)
 142 {
 143     struct conf_sortkey * sk = 0;
 144
 145     if (!service || !service->sortkeys || !service->num_sortkeys
 146         || field_id < 0  || !(field_id < service->num_sortkeys))
 147         return 0;
 148
 149     //sk = &((service->sortkeys)[field_id]);
 150     sk = service->sortkeys + field_id;
 151     sk = conf_sortkey_assign(nmem, sk, name, type);
 152
 153     return sk;
 154 }
 155
 156
 157 int conf_service_metadata_field_id(struct conf_service *service,
 158                                    const char * name)
 159 {
 160     int i = 0;
 161
 162     if (!service || !service->metadata || !service->num_metadata)
 163         return -1;
 164
 165     for(i = 0; i < service->num_metadata; i++) {
 166         if (!strcmp(name, (service->metadata[i]).name))
 167             return i;
 168     }
 169
 170     return -1;
 171 };
 172
 173
 174 int conf_service_sortkey_field_id(struct conf_service *service,
 175                                   const char * name)
 176 {
 177     int i = 0;
 178
 179     if (!service || !service->sortkeys || !service->num_sortkeys)
 180         return -1;
 181
 182     for(i = 0; i < service->num_sortkeys; i++) {
 183         if (!strcmp(name, (service->sortkeys[i]).name))
 184             return i;
 185     }
 186
 187     return -1;
 188 };
 189
 190
 191
 192 /* Code to parse configuration file */
 193 /* ==================================================== */
 194
 195 static struct conf_service *parse_service(xmlNode *node)
 196 {
 197     xmlNode *n;
 198     int md_node = 0;
 199     int sk_node = 0;
 200
 201     struct conf_service *service = 0;
 202     int num_metadata = 0;
 203     int num_sortkeys = 0;
 204
 205     // count num_metadata and num_sortkeys
 206     for (n = node->children; n; n = n->next)
 207         if (n->type == XML_ELEMENT_NODE && !strcmp((const char *)
 208                                                    n->name, "metadata"))
 209         {
 210             xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 211             num_metadata++;
 212             if (sortkey && strcmp((const char *) sortkey, "no"))
 213                 num_sortkeys++;
 214             xmlFree(sortkey);
 215         }
 216
 217     service = conf_service_create(nmem, num_metadata, num_sortkeys);
 218
 219     for (n = node->children; n; n = n->next)
 220     {
 221         if (n->type != XML_ELEMENT_NODE)
 222             continue;
 223         if (!strcmp((const char *) n->name, (const char *) "metadata"))
 224         {
 225             xmlChar *xml_name = xmlGetProp(n, (xmlChar *) "name");
 226             xmlChar *xml_brief = xmlGetProp(n, (xmlChar *) "brief");
 227             xmlChar *xml_sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 228             xmlChar *xml_merge = xmlGetProp(n, (xmlChar *) "merge");
 229             xmlChar *xml_type = xmlGetProp(n, (xmlChar *) "type");
 230             xmlChar *xml_termlist = xmlGetProp(n, (xmlChar *) "termlist");
 231             xmlChar *xml_rank = xmlGetProp(n, (xmlChar *) "rank");
 232
 233             enum conf_metadata_type type = Metadata_type_generic;
 234             enum conf_metadata_merge merge = Metadata_merge_no;
 235             int brief = 0;
 236             int termlist = 0;
 237             int rank = 0;
 238             int sortkey_offset = 0;
 239             enum conf_sortkey_type sk_type = Metadata_sortkey_relevance;
 240
 241             // now do the parsing logic
 242             if (!xml_name)
 243             {
 244                 yaz_log(YLOG_FATAL, "Must specify name in metadata element");
 245                 return 0;
 246             }
 247             if (xml_brief)
 248             {
 249                 if (!strcmp((const char *) xml_brief, "yes"))
 250                     brief = 1;
 251                  else if (strcmp((const char *) xml_brief, "no"))
 252                 {
 253                     yaz_log(YLOG_FATAL, "metadata/brief must be yes or no");
 254                     return 0;
 255                 }
 256             }
 257             else
 258                 brief = 0;
 259
 260             if (xml_termlist)
 261             {
 262                 if (!strcmp((const char *) xml_termlist, "yes"))
 263                     termlist = 1;
 264                 else if (strcmp((const char *) xml_termlist, "no"))
 265                 {
 266                     yaz_log(YLOG_FATAL, "metadata/termlist must be yes or no");
 267                     return 0;
 268                 }
 269             }
 270             else
 271                 termlist = 0;
 272
 273             if (xml_rank)
 274                 rank = atoi((const char *) xml_rank);
 275             else
 276                 rank = 0;
 277
 278             if (xml_type)
 279             {
 280                 if (!strcmp((const char *) xml_type, "generic"))
 281                     type = Metadata_type_generic;
 282                 else if (!strcmp((const char *) xml_type, "year"))
 283                     type = Metadata_type_year;
 284                 else
 285                 {
 286                     yaz_log(YLOG_FATAL, "Unknown value for metadata/type: %s", xml_type);
 287                     return 0;
 288                 }
 289             }
 290             else
 291                 type = Metadata_type_generic;
 292
 293             if (xml_merge)
 294             {
 295                 if (!strcmp((const char *) xml_merge, "no"))
 296                     merge = Metadata_merge_no;
 297                 else if (!strcmp((const char *) xml_merge, "unique"))
 298                     merge = Metadata_merge_unique;
 299                 else if (!strcmp((const char *) xml_merge, "longest"))
 300                     merge = Metadata_merge_longest;
 301                 else if (!strcmp((const char *) xml_merge, "range"))
 302                     merge = Metadata_merge_range;
 303                 else if (!strcmp((const char *) xml_merge, "all"))
 304                     merge = Metadata_merge_all;
 305                 else
 306                 {
 307                     yaz_log(YLOG_FATAL,
 308                             "Unknown value for metadata/merge: %s", xml_merge);
 309                     return 0;
 310                 }
 311             }
 312             else
 313                 merge = Metadata_merge_no;
 314
 315             // add a sortkey if so specified
 316             if (xml_sortkey && strcmp((const char *) xml_sortkey, "no"))
 317             {
 318                 if (merge == Metadata_merge_no)
 319                 {
 320                     yaz_log(YLOG_FATAL,
 321                             "Can't specify sortkey on a non-merged field");
 322                     return 0;
 323                 }
 324                 if (!strcmp((const char *) xml_sortkey, "numeric"))
 325                     sk_type = Metadata_sortkey_numeric;
 326                 else if (!strcmp((const char *) xml_sortkey, "skiparticle"))
 327                     sk_type = Metadata_sortkey_skiparticle;
 328                 else
 329                 {
 330                     yaz_log(YLOG_FATAL,
 331                             "Unknown sortkey in metadata element: %s",
 332                             xml_sortkey);
 333                     return 0;
 334                 }
 335                 sortkey_offset = sk_node;
 336
 337                 conf_service_add_sortkey(nmem, service, sk_node,
 338                                          (const char *) xml_name, sk_type);
 339
 340                 sk_node++;
 341             }
 342             else
 343                 sortkey_offset = -1;
 344
 345             // metadata known, assign values
 346             conf_service_add_metadata(nmem, service, md_node,
 347                                       (const char *) xml_name,
 348                                       type, merge,
 349                                       brief, termlist, rank, sortkey_offset);
 350
 351             xmlFree(xml_name);
 352             xmlFree(xml_brief);
 353             xmlFree(xml_sortkey);
 354             xmlFree(xml_merge);
 355             xmlFree(xml_type);
 356             xmlFree(xml_termlist);
 357             xmlFree(xml_rank);
 358             md_node++;
 359         }
 360         else
 361         {
 362             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 363             return 0;
 364         }
 365     }
 366     return service;
 367 }
 368
 369 static char *parse_settings(xmlNode *node)
 370 {
 371     xmlChar *src = xmlGetProp(node, (xmlChar *) "src");
 372     char *r;
 373
 374     if (src)
 375         r = nmem_strdup(nmem, (const char *) src);
 376     else
 377     {
 378         yaz_log(YLOG_FATAL, "Must specify src in targetprofile");
 379         return 0;
 380     }
 381     xmlFree(src);
 382     return r;
 383 }
 384
 385 static struct conf_server *parse_server(xmlNode *node)
 386 {
 387     xmlNode *n;
 388     struct conf_server *r = nmem_malloc(nmem, sizeof(struct conf_server));
 389
 390     r->host = 0;
 391     r->port = 0;
 392     r->proxy_host = 0;
 393     r->proxy_port = 0;
 394     r->myurl = 0;
 395     r->zproxy_host = 0;
 396     r->zproxy_port = 0;
 397     r->service = 0;
 398     r->next = 0;
 399     r->settings = 0;
 400
 401     for (n = node->children; n; n = n->next)
 402     {
 403         if (n->type != XML_ELEMENT_NODE)
 404             continue;
 405         if (!strcmp((const char *) n->name, "listen"))
 406         {
 407             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 408             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 409             if (port)
 410                 r->port = atoi((const char *) port);
 411             if (host)
 412                 r->host = nmem_strdup(nmem, (const char *) host);
 413             xmlFree(port);
 414             xmlFree(host);
 415         }
 416         else if (!strcmp((const char *) n->name, "proxy"))
 417         {
 418             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 419             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 420             xmlChar *myurl = xmlGetProp(n, (xmlChar *) "myurl");
 421             if (port)
 422                 r->proxy_port = atoi((const char *) port);
 423             if (host)
 424                 r->proxy_host = nmem_strdup(nmem, (const char *) host);
 425             if (myurl)
 426                 r->myurl = nmem_strdup(nmem, (const char *) myurl);
 427 #ifdef GAGA
 428             else
 429             {
 430                 yaz_log(YLOG_FATAL, "Must specify @myurl for proxy");
 431                 return 0;
 432             }
 433 #endif
 434             xmlFree(port);
 435             xmlFree(host);
 436             xmlFree(myurl);
 437         }
 438         else if (!strcmp((const char *) n->name, "zproxy"))
 439         {
 440             xmlChar *port = 0;
 441             xmlChar *host = 0;
 442
 443             port = xmlGetProp(n, (xmlChar *) "port");
 444             host = xmlGetProp(n, (xmlChar *) "host");
 445
 446             if (port)
 447                 r->zproxy_port = atoi((const char *) port);
 448             if (host)
 449                 r->zproxy_host = nmem_strdup(nmem, (const char *) host);
 450
 451             xmlFree(port);
 452             xmlFree(host);
 453         }
 454         else if (!strcmp((const char *) n->name, "settings"))
 455         {
 456             if (r->settings)
 457             {
 458                 yaz_log(YLOG_FATAL, "Can't repeat 'settings'");
 459                 return 0;
 460             }
 461             if (!(r->settings = parse_settings(n)))
 462                 return 0;
 463         }
 464         else if (!strcmp((const char *) n->name, "service"))
 465         {
 466             struct conf_service *s = parse_service(n);
 467             if (!s)
 468                 return 0;
 469             r->service = s;
 470         }
 471         else
 472         {
 473             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 474             return 0;
 475         }
 476     }
 477     return r;
 478 }
 479
 480 xsltStylesheet *conf_load_stylesheet(const char *fname)
 481 {
 482     char path[256];
 483     sprintf(path, "%s/%s", confdir, fname);
 484     return xsltParseStylesheetFile((xmlChar *) path);
 485 }
 486
 487 static struct conf_targetprofiles *parse_targetprofiles(xmlNode *node)
 488 {
 489     struct conf_targetprofiles *r = nmem_malloc(nmem, sizeof(*r));
 490     xmlChar *type = xmlGetProp(node, (xmlChar *) "type");
 491     xmlChar *src = xmlGetProp(node, (xmlChar *) "src");
 492
 493     memset(r, 0, sizeof(*r));
 494
 495     if (type)
 496     {
 497         if (!strcmp((const char *) type, "local"))
 498             r->type = Targetprofiles_local;
 499         else
 500         {
 501             yaz_log(YLOG_FATAL, "Unknown targetprofile type");
 502             return 0;
 503         }
 504     }
 505     else
 506     {
 507         yaz_log(YLOG_FATAL, "Must specify type for targetprofile");
 508         return 0;
 509     }
 510
 511     if (src)
 512         r->src = nmem_strdup(nmem, (const char *) src);
 513     else
 514     {
 515         yaz_log(YLOG_FATAL, "Must specify src in targetprofile");
 516         return 0;
 517     }
 518     xmlFree(type);
 519     xmlFree(src);
 520     return r;
 521 }
 522
 523 static struct conf_config *parse_config(xmlNode *root)
 524 {
 525     xmlNode *n;
 526     struct conf_config *r = nmem_malloc(nmem, sizeof(struct conf_config));
 527
 528     r->servers = 0;
 529     r->targetprofiles = 0;
 530
 531     for (n = root->children; n; n = n->next)
 532     {
 533         if (n->type != XML_ELEMENT_NODE)
 534             continue;
 535         if (!strcmp((const char *) n->name, "server"))
 536         {
 537             struct conf_server *tmp = parse_server(n);
 538             if (!tmp)
 539                 return 0;
 540             tmp->next = r->servers;
 541             r->servers = tmp;
 542         }
 543         else if (!strcmp((const char *) n->name, "targetprofiles"))
 544         {
 545             // It would be fun to be able to fix this sometime
 546             if (r->targetprofiles)
 547             {
 548                 yaz_log(YLOG_FATAL, "Can't repeat targetprofiles");
 549                 return 0;
 550             }
 551             if (!(r->targetprofiles = parse_targetprofiles(n)))
 552                 return 0;
 553         }
 554         else
 555         {
 556             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 557             return 0;
 558         }
 559     }
 560     return r;
 561 }
 562
 563 int read_config(const char *fname)
 564 {
 565     xmlDoc *doc = xmlParseFile(fname);
 566     const char *p;
 567
 568     if (!nmem)  // Initialize
 569     {
 570         nmem = nmem_create();
 571         xmlSubstituteEntitiesDefault(1);
 572         xmlLoadExtDtdDefaultValue = 1;
 573     }
 574     if (!doc)
 575     {
 576         yaz_log(YLOG_FATAL, "Failed to read %s", fname);
 577         exit(1);
 578     }
 579     if ((p = strrchr(fname, '/')))
 580     {
 581         int len = p - fname;
 582         strncpy(confdir, fname, len);
 583         confdir[len] = '\0';
 584     }
 585     config = parse_config(xmlDocGetRootElement(doc));
 586     xmlFreeDoc(doc);
 587
 588     if (config)
 589         return 1;
 590     else
 591         return 0;
 592 }
 593
 594
 595 /*
 596  * Local variables:
 597  * c-basic-offset: 4
 598  * indent-tabs-mode: nil
 599  * End:
 600  * vim: shiftwidth=4 tabstop=8 expandtab
 601  */