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 #define CONFIG_NOEXTERNS
  38 #include "pazpar2_config.h"
  39
  40
  41 static char confdir[256] = ".";
  42
  43 struct conf_config *config = 0;
  44
  45
  46 static
  47 struct conf_metadata * conf_metadata_assign(NMEM nmem,
  48                                             struct conf_metadata * metadata,
  49                                             const char *name,
  50                                             enum conf_metadata_type type,
  51                                             enum conf_metadata_merge merge,
  52                                             enum conf_setting_type setting,
  53                                             int brief,
  54                                             int termlist,
  55                                             int rank,
  56                                             int sortkey_offset,
  57                                             enum conf_metadata_mergekey mt)
  58 {
  59     if (!nmem || !metadata || !name)
  60         return 0;
  61
  62     metadata->name = nmem_strdup(nmem, name);
  63
  64     metadata->type = type;
  65
  66     // enforcing that type_year is always range_merge
  67     if (metadata->type == Metadata_type_year)
  68         metadata->merge = Metadata_merge_range;
  69     else
  70         metadata->merge = merge;
  71
  72     metadata->setting = setting;
  73     metadata->brief = brief;
  74     metadata->termlist = termlist;
  75     metadata->rank = rank;
  76     metadata->sortkey_offset = sortkey_offset;
  77     metadata->mergekey = mt;
  78     return metadata;
  79 }
  80
  81
  82 static
  83 struct conf_sortkey * conf_sortkey_assign(NMEM nmem,
  84                                           struct conf_sortkey * sortkey,
  85                                           const char *name,
  86                                           enum conf_sortkey_type type)
  87 {
  88     if (!nmem || !sortkey || !name)
  89         return 0;
  90
  91     sortkey->name = nmem_strdup(nmem, name);
  92     sortkey->type = type;
  93
  94     return sortkey;
  95 }
  96
  97
  98 struct conf_service * conf_service_create(int num_metadata, int num_sortkeys,
  99     const char *service_id)
 100 {
 101     struct conf_service * service = 0;
 102     NMEM nmem = nmem_create();
 103
 104     //assert(nmem);
 105
 106     service = nmem_malloc(nmem, sizeof(struct conf_service));
 107     service->nmem = nmem;
 108     service->next = 0;
 109
 110     service->id = service_id ? nmem_strdup(nmem, service_id) : 0;
 111     service->num_metadata = num_metadata;
 112     service->metadata = 0;
 113     if (service->num_metadata)
 114       service->metadata
 115           = nmem_malloc(nmem,
 116                         sizeof(struct conf_metadata) * service->num_metadata);
 117     service->num_sortkeys = num_sortkeys;
 118     service->sortkeys = 0;
 119     if (service->num_sortkeys)
 120         service->sortkeys
 121             = nmem_malloc(nmem,
 122                           sizeof(struct conf_sortkey) * service->num_sortkeys);
 123     service->dictionary = 0;
 124     return service;
 125 }
 126
 127 struct conf_metadata* conf_service_add_metadata(struct conf_service *service,
 128                                                 int field_id,
 129                                                 const char *name,
 130                                                 enum conf_metadata_type type,
 131                                                 enum conf_metadata_merge merge,
 132                                                 enum conf_setting_type setting,
 133                                                 int brief,
 134                                                 int termlist,
 135                                                 int rank,
 136                                                 int sortkey_offset,
 137                                                 enum conf_metadata_mergekey mt)
 138 {
 139     struct conf_metadata * md = 0;
 140
 141     if (!service || !service->metadata || !service->num_metadata
 142         || field_id < 0  || !(field_id < service->num_metadata))
 143         return 0;
 144
 145     //md = &((service->metadata)[field_id]);
 146     md = service->metadata + field_id;
 147     md = conf_metadata_assign(service->nmem, md, name, type, merge, setting,
 148                               brief, termlist, rank, sortkey_offset,
 149                               mt);
 150     return md;
 151 }
 152
 153
 154 struct conf_sortkey * conf_service_add_sortkey(struct conf_service *service,
 155                                                int field_id,
 156                                                const char *name,
 157                                                enum conf_sortkey_type type)
 158 {
 159     struct conf_sortkey * sk = 0;
 160
 161     if (!service || !service->sortkeys || !service->num_sortkeys
 162         || field_id < 0  || !(field_id < service->num_sortkeys))
 163         return 0;
 164
 165     //sk = &((service->sortkeys)[field_id]);
 166     sk = service->sortkeys + field_id;
 167     sk = conf_sortkey_assign(service->nmem, sk, name, type);
 168
 169     return sk;
 170 }
 171
 172
 173 int conf_service_metadata_field_id(struct conf_service *service,
 174                                    const char * name)
 175 {
 176     int i = 0;
 177
 178     if (!service || !service->metadata || !service->num_metadata)
 179         return -1;
 180
 181     for(i = 0; i < service->num_metadata; i++) {
 182         if (!strcmp(name, (service->metadata[i]).name))
 183             return i;
 184     }
 185
 186     return -1;
 187 }
 188
 189
 190 int conf_service_sortkey_field_id(struct conf_service *service,
 191                                   const char * name)
 192 {
 193     int i = 0;
 194
 195     if (!service || !service->sortkeys || !service->num_sortkeys)
 196         return -1;
 197
 198     for(i = 0; i < service->num_sortkeys; i++) {
 199         if (!strcmp(name, (service->sortkeys[i]).name))
 200             return i;
 201     }
 202
 203     return -1;
 204 }
 205
 206
 207
 208 /* Code to parse configuration file */
 209 /* ==================================================== */
 210
 211 static struct conf_service *parse_service(xmlNode *node, const char *service_id)
 212 {
 213     xmlNode *n;
 214     int md_node = 0;
 215     int sk_node = 0;
 216
 217     struct conf_service *service = 0;
 218     int num_metadata = 0;
 219     int num_sortkeys = 0;
 220
 221     // count num_metadata and num_sortkeys
 222     for (n = node->children; n; n = n->next)
 223         if (n->type == XML_ELEMENT_NODE && !strcmp((const char *)
 224                                                    n->name, "metadata"))
 225         {
 226             xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 227             num_metadata++;
 228             if (sortkey && strcmp((const char *) sortkey, "no"))
 229                 num_sortkeys++;
 230             xmlFree(sortkey);
 231         }
 232
 233     service = conf_service_create(num_metadata, num_sortkeys, service_id);
 234
 235     for (n = node->children; n; n = n->next)
 236     {
 237         if (n->type != XML_ELEMENT_NODE)
 238             continue;
 239         if (!strcmp((const char *) n->name, (const char *) "metadata"))
 240         {
 241             xmlChar *xml_name = xmlGetProp(n, (xmlChar *) "name");
 242             xmlChar *xml_brief = xmlGetProp(n, (xmlChar *) "brief");
 243             xmlChar *xml_sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 244             xmlChar *xml_merge = xmlGetProp(n, (xmlChar *) "merge");
 245             xmlChar *xml_type = xmlGetProp(n, (xmlChar *) "type");
 246             xmlChar *xml_termlist = xmlGetProp(n, (xmlChar *) "termlist");
 247             xmlChar *xml_rank = xmlGetProp(n, (xmlChar *) "rank");
 248             xmlChar *xml_setting = xmlGetProp(n, (xmlChar *) "setting");
 249             xmlChar *xml_mergekey = xmlGetProp(n, (xmlChar *) "mergekey");
 250
 251             enum conf_metadata_type type = Metadata_type_generic;
 252             enum conf_metadata_merge merge = Metadata_merge_no;
 253             enum conf_setting_type setting = Metadata_setting_no;
 254             enum conf_sortkey_type sk_type = Metadata_sortkey_relevance;
 255             enum conf_metadata_mergekey mergekey_type = Metadata_mergekey_no;
 256             int brief = 0;
 257             int termlist = 0;
 258             int rank = 0;
 259             int sortkey_offset = 0;
 260
 261             // now do the parsing logic
 262             if (!xml_name)
 263             {
 264                 yaz_log(YLOG_FATAL, "Must specify name in metadata element");
 265                 return 0;
 266             }
 267             if (xml_brief)
 268             {
 269                 if (!strcmp((const char *) xml_brief, "yes"))
 270                     brief = 1;
 271                  else if (strcmp((const char *) xml_brief, "no"))
 272                 {
 273                     yaz_log(YLOG_FATAL, "metadata/brief must be yes or no");
 274                     return 0;
 275                 }
 276             }
 277             else
 278                 brief = 0;
 279
 280             if (xml_termlist)
 281             {
 282                 if (!strcmp((const char *) xml_termlist, "yes"))
 283                     termlist = 1;
 284                 else if (strcmp((const char *) xml_termlist, "no"))
 285                 {
 286                     yaz_log(YLOG_FATAL, "metadata/termlist must be yes or no");
 287                     return 0;
 288                 }
 289             }
 290             else
 291                 termlist = 0;
 292
 293             if (xml_rank)
 294                 rank = atoi((const char *) xml_rank);
 295             else
 296                 rank = 0;
 297
 298             if (xml_type)
 299             {
 300                 if (!strcmp((const char *) xml_type, "generic"))
 301                     type = Metadata_type_generic;
 302                 else if (!strcmp((const char *) xml_type, "year"))
 303                     type = Metadata_type_year;
 304                 else if (!strcmp((const char *) xml_type, "date"))
 305                     type = Metadata_type_date;
 306                 else
 307                 {
 308                     yaz_log(YLOG_FATAL,
 309                             "Unknown value for metadata/type: %s", xml_type);
 310                     return 0;
 311                 }
 312             }
 313             else
 314                 type = Metadata_type_generic;
 315
 316             if (xml_merge)
 317             {
 318                 if (!strcmp((const char *) xml_merge, "no"))
 319                     merge = Metadata_merge_no;
 320                 else if (!strcmp((const char *) xml_merge, "unique"))
 321                     merge = Metadata_merge_unique;
 322                 else if (!strcmp((const char *) xml_merge, "longest"))
 323                     merge = Metadata_merge_longest;
 324                 else if (!strcmp((const char *) xml_merge, "range"))
 325                     merge = Metadata_merge_range;
 326                 else if (!strcmp((const char *) xml_merge, "all"))
 327                     merge = Metadata_merge_all;
 328                 else
 329                 {
 330                     yaz_log(YLOG_FATAL,
 331                             "Unknown value for metadata/merge: %s", xml_merge);
 332                     return 0;
 333                 }
 334             }
 335             else
 336                 merge = Metadata_merge_no;
 337
 338             if (xml_setting)
 339             {
 340                 if (!strcmp((const char *) xml_setting, "no"))
 341                     setting = Metadata_setting_no;
 342                 else if (!strcmp((const char *) xml_setting, "postproc"))
 343                     setting = Metadata_setting_postproc;
 344                 else if (!strcmp((const char *) xml_setting, "parameter"))
 345                     setting = Metadata_setting_parameter;
 346                 else
 347                 {
 348                     yaz_log(YLOG_FATAL,
 349                         "Unknown value for medadata/setting: %s", xml_setting);
 350                     return 0;
 351                 }
 352             }
 353
 354             // add a sortkey if so specified
 355             if (xml_sortkey && strcmp((const char *) xml_sortkey, "no"))
 356             {
 357                 if (merge == Metadata_merge_no)
 358                 {
 359                     yaz_log(YLOG_FATAL,
 360                             "Can't specify sortkey on a non-merged field");
 361                     return 0;
 362                 }
 363                 if (!strcmp((const char *) xml_sortkey, "numeric"))
 364                     sk_type = Metadata_sortkey_numeric;
 365                 else if (!strcmp((const char *) xml_sortkey, "skiparticle"))
 366                     sk_type = Metadata_sortkey_skiparticle;
 367                 else
 368                 {
 369                     yaz_log(YLOG_FATAL,
 370                             "Unknown sortkey in metadata element: %s",
 371                             xml_sortkey);
 372                     return 0;
 373                 }
 374                 sortkey_offset = sk_node;
 375
 376                 conf_service_add_sortkey(
 377 service, sk_node,
 378                                          (const char *) xml_name, sk_type);
 379
 380                 sk_node++;
 381             }
 382             else
 383                 sortkey_offset = -1;
 384
 385             if (xml_mergekey && strcmp((const char *) xml_mergekey, "no"))
 386             {
 387                 mergekey_type = Metadata_mergekey_yes;
 388             }
 389
 390
 391             // metadata known, assign values
 392             conf_service_add_metadata(service, md_node,
 393                                       (const char *) xml_name,
 394                                       type, merge, setting,
 395                                       brief, termlist, rank, sortkey_offset,
 396                                       mergekey_type);
 397
 398             xmlFree(xml_name);
 399             xmlFree(xml_brief);
 400             xmlFree(xml_sortkey);
 401             xmlFree(xml_merge);
 402             xmlFree(xml_type);
 403             xmlFree(xml_termlist);
 404             xmlFree(xml_rank);
 405             xmlFree(xml_setting);
 406             md_node++;
 407         }
 408         else
 409         {
 410             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 411             return 0;
 412         }
 413     }
 414     return service;
 415 }
 416
 417 static char *parse_settings(NMEM nmem, xmlNode *node)
 418 {
 419     xmlChar *src = xmlGetProp(node, (xmlChar *) "src");
 420     char *r;
 421
 422     if (src)
 423     {
 424         if (yaz_is_abspath((const char *) src))
 425             r = nmem_strdup(nmem, (const char *) src);
 426         else
 427         {
 428             r = nmem_malloc(nmem,
 429                             strlen(confdir) + strlen((const char *) src) + 2);
 430             sprintf(r, "%s/%s", confdir, src);
 431         }
 432     }
 433     else
 434     {
 435         yaz_log(YLOG_FATAL, "Must specify src in targetprofile");
 436         return 0;
 437     }
 438     xmlFree(src);
 439     return r;
 440 }
 441
 442 static struct conf_server *parse_server(NMEM nmem, xmlNode *node)
 443 {
 444     xmlNode *n;
 445     struct conf_server *server = nmem_malloc(nmem, sizeof(struct conf_server));
 446
 447     server->host = 0;
 448     server->port = 0;
 449     server->proxy_host = 0;
 450     server->proxy_port = 0;
 451     server->myurl = 0;
 452     server->service = 0;
 453     server->next = 0;
 454     server->settings = 0;
 455     server->relevance_pct = 0;
 456     server->sort_pct = 0;
 457     server->mergekey_pct = 0;
 458
 459     for (n = node->children; n; n = n->next)
 460     {
 461         if (n->type != XML_ELEMENT_NODE)
 462             continue;
 463         if (!strcmp((const char *) n->name, "listen"))
 464         {
 465             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 466             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 467             if (port)
 468                 server->port = atoi((const char *) port);
 469             if (host)
 470                 server->host = nmem_strdup(nmem, (const char *) host);
 471             xmlFree(port);
 472             xmlFree(host);
 473         }
 474         else if (!strcmp((const char *) n->name, "proxy"))
 475         {
 476             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 477             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 478             xmlChar *myurl = xmlGetProp(n, (xmlChar *) "myurl");
 479             if (port)
 480                 server->proxy_port = atoi((const char *) port);
 481             if (host)
 482                 server->proxy_host = nmem_strdup(nmem, (const char *) host);
 483             if (myurl)
 484                 server->myurl = nmem_strdup(nmem, (const char *) myurl);
 485             xmlFree(port);
 486             xmlFree(host);
 487             xmlFree(myurl);
 488         }
 489         else if (!strcmp((const char *) n->name, "settings"))
 490         {
 491             if (server->settings)
 492             {
 493                 yaz_log(YLOG_FATAL, "Can't repeat 'settings'");
 494                 return 0;
 495             }
 496             if (!(server->settings = parse_settings(nmem, n)))
 497                 return 0;
 498         }
 499         else if (!strcmp((const char *) n->name, "relevance"))
 500         {
 501             server->relevance_pct = pp2_charset_create_xml(n);
 502             if (!server->relevance_pct)
 503                 return 0;
 504         }
 505         else if (!strcmp((const char *) n->name, "sort"))
 506         {
 507             server->sort_pct = pp2_charset_create_xml(n);
 508             if (!server->sort_pct)
 509                 return 0;
 510         }
 511         else if (!strcmp((const char *) n->name, "mergekey"))
 512         {
 513             server->mergekey_pct = pp2_charset_create_xml(n);
 514             if (!server->mergekey_pct)
 515                 return 0;
 516         }
 517         else if (!strcmp((const char *) n->name, "service"))
 518         {
 519             const char *service_id = (const char *)
 520                 xmlGetProp(n, (xmlChar *) "id");
 521
 522             struct conf_service **sp = &server->service;
 523             for (; *sp; sp = &(*sp)->next)
 524                 if ((*sp)->id && service_id &&
 525                     0 == strcmp((*sp)->id, service_id))
 526                 {
 527                     yaz_log(YLOG_FATAL, "Duplicate service: %s", service_id);
 528                     break;
 529                 }
 530                 else if (!(*sp)->id && !service_id)
 531                 {
 532                     yaz_log(YLOG_FATAL, "Duplicate unnamed service");
 533                     break;
 534                 }
 535
 536             if (*sp)  /* service already exist */
 537                 return 0;
 538             else
 539             {
 540                 struct conf_service *s = parse_service(n, service_id);
 541                 if (s)
 542                     *sp = s;
 543             }
 544         }
 545         else
 546         {
 547             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 548             return 0;
 549         }
 550     }
 551     if (!server->relevance_pct)
 552         server->relevance_pct = pp2_charset_create(0);
 553     if (!server->sort_pct)
 554         server->sort_pct = pp2_charset_create(0);
 555     if (!server->mergekey_pct)
 556         server->mergekey_pct = pp2_charset_create(0);
 557     return server;
 558 }
 559
 560 xsltStylesheet *conf_load_stylesheet(const char *fname)
 561 {
 562     char path[256];
 563     if (yaz_is_abspath(fname))
 564         yaz_snprintf(path, sizeof(path), fname);
 565     else
 566         yaz_snprintf(path, sizeof(path), "%s/%s", confdir, fname);
 567     return xsltParseStylesheetFile((xmlChar *) path);
 568 }
 569
 570 static struct conf_targetprofiles *parse_targetprofiles(NMEM nmem,
 571                                                         xmlNode *node)
 572 {
 573     struct conf_targetprofiles *r = nmem_malloc(nmem, sizeof(*r));
 574     xmlChar *type = xmlGetProp(node, (xmlChar *) "type");
 575     xmlChar *src = xmlGetProp(node, (xmlChar *) "src");
 576
 577     memset(r, 0, sizeof(*r));
 578
 579     if (type)
 580     {
 581         if (!strcmp((const char *) type, "local"))
 582             r->type = Targetprofiles_local;
 583         else
 584         {
 585             yaz_log(YLOG_FATAL, "Unknown targetprofile type");
 586             return 0;
 587         }
 588     }
 589     else
 590     {
 591         yaz_log(YLOG_FATAL, "Must specify type for targetprofile");
 592         return 0;
 593     }
 594
 595     if (src)
 596         r->src = nmem_strdup(nmem, (const char *) src);
 597     else
 598     {
 599         yaz_log(YLOG_FATAL, "Must specify src in targetprofile");
 600         return 0;
 601     }
 602     xmlFree(type);
 603     xmlFree(src);
 604     return r;
 605 }
 606
 607 struct conf_service *locate_service(const char *service_id)
 608 {
 609     struct conf_service *s = config->servers->service;
 610     for (; s; s = s->next)
 611         if (s->id && service_id && 0 == strcmp(s->id, service_id))
 612             return s;
 613         else if (!s->id && !service_id)
 614             return s;
 615     return 0;
 616 }
 617
 618
 619 static struct conf_config *parse_config(xmlNode *root)
 620 {
 621     NMEM nmem = nmem_create();
 622     xmlNode *n;
 623     struct conf_config *r = nmem_malloc(nmem, sizeof(struct conf_config));
 624
 625     r->nmem = nmem;
 626     r->servers = 0;
 627     r->targetprofiles = 0;
 628
 629     for (n = root->children; n; n = n->next)
 630     {
 631         if (n->type != XML_ELEMENT_NODE)
 632             continue;
 633         if (!strcmp((const char *) n->name, "server"))
 634         {
 635             struct conf_server *tmp = parse_server(nmem, n);
 636             if (!tmp)
 637                 return 0;
 638             tmp->next = r->servers;
 639             r->servers = tmp;
 640         }
 641         else if (!strcmp((const char *) n->name, "targetprofiles"))
 642         {
 643             // It would be fun to be able to fix this sometime
 644             if (r->targetprofiles)
 645             {
 646                 yaz_log(YLOG_FATAL, "Can't repeat targetprofiles");
 647                 return 0;
 648             }
 649             if (!(r->targetprofiles = parse_targetprofiles(nmem, n)))
 650                 return 0;
 651         }
 652         else
 653         {
 654             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 655             return 0;
 656         }
 657     }
 658     return r;
 659 }
 660
 661 int read_config(const char *fname)
 662 {
 663     xmlDoc *doc = xmlParseFile(fname);
 664     const char *p;
 665
 666     xmlSubstituteEntitiesDefault(1);
 667     xmlLoadExtDtdDefaultValue = 1;
 668     if (!doc)
 669     {
 670         yaz_log(YLOG_FATAL, "Failed to read %s", fname);
 671         exit(1);
 672     }
 673     if ((p = strrchr(fname,
 674 #ifdef WIN32
 675                      '\\'
 676 #else
 677                      '/'
 678 #endif
 679              )))
 680     {
 681         int len = p - fname;
 682         if (len >= sizeof(confdir))
 683             len = sizeof(confdir)-1;
 684         strncpy(confdir, fname, len);
 685         confdir[len] = '\0';
 686     }
 687     config = parse_config(xmlDocGetRootElement(doc));
 688     xmlFreeDoc(doc);
 689
 690     if (config)
 691         return 1;
 692     else
 693         return 0;
 694 }
 695
 696
 697 /*
 698  * Local variables:
 699  * c-basic-offset: 4
 700  * c-file-style: "Stroustrup"
 701  * indent-tabs-mode: nil
 702  * End:
 703  * vim: shiftwidth=4 tabstop=8 expandtab
 704  */
 705