src/zeerex.c

   1 /* $Id: zeerex.c,v 1.3 2007-02-08 19:26:33 adam Exp $ */
   2
   3 #include <string.h>
   4
   5 #include <yaz/yaz-util.h>
   6
   7 #include <libxml/parser.h>
   8 #include <libxml/tree.h>
   9
  10 #include "zeerex.h"
  11
  12 // Replace this with something that will take a callback
  13 static void fail(const char *s, xmlNode *n)
  14 {
  15     yaz_log(YLOG_WARN, "Zeerex Err '%s' in elem '%s/%s'", s, n->parent->name, n->name);
  16 }
  17
  18 // returns an nmem-allocated string if attr is present, or null
  19 static char *attrtostr(NMEM m, xmlNode *n, const char *name)
  20 {
  21     char *s = xmlGetProp(n, name);
  22     if (s)
  23     {
  24         char *r = nmem_strdup(m, s);
  25         xmlFree(s);
  26         return r;
  27     }
  28     else
  29         return 0;
  30 }
  31
  32 static int attrtoint(xmlNode *n, const char *name)
  33 {
  34     char *s = xmlGetProp(n, name);
  35     if (s)
  36     {
  37         int val = atoi(s);
  38         xmlFree(s);
  39         return val;
  40     }
  41     else
  42         return 0;
  43 }
  44
  45 static Zr_bool attrtobool(xmlNode *node, const char *name)
  46 {
  47     char *v = xmlGetProp(node, name);
  48     if (v)
  49     {
  50         Zr_bool res;
  51         if (!strcmp(v, "true"))
  52             res = Zr_bool_true;
  53         else if (!strcmp(v, "false"))
  54             res = Zr_bool_false;
  55         else
  56             res = Zr_bool_unknown;
  57         xmlFree(v);
  58         return res;
  59     }
  60     else
  61         return Zr_bool_unknown;
  62 }
  63
  64 static char *valuetostr(NMEM m, xmlNode *n)
  65 {
  66     char *val = xmlNodeGetContent(n);
  67     if (val)
  68     {
  69         char *res = nmem_strdup(m, val);
  70         xmlFree(val);
  71         return res;
  72     }
  73     else
  74         return 0;
  75 }
  76
  77 static int valuetoint(xmlNode *n)
  78 {
  79     char *s = xmlNodeGetContent(n);
  80     if (s)
  81     {
  82         int res = atoi(s);
  83         xmlFree(s);
  84         return res;
  85     }
  86     else
  87         return 0;
  88 }
  89
  90 static Zr_langstr *findlangstr(NMEM m, xmlNode *node, const char *name)
  91 {
  92     xmlNode *n;
  93     Zr_langstr *res = 0;
  94     for (n = node->children; n; n = n->next)
  95     {
  96         if (n->type == XML_ELEMENT_NODE && !strcmp(n->name, name))
  97         {
  98             Zr_langstr *new = nmem_malloc(m, sizeof(*new));
  99             memset(new, 0, sizeof(*new));
 100             new->primary = attrtobool(n, "primary");
 101             new->lang = attrtostr(m, n, "lang");
 102             new->str = valuetostr(m, n);
 103             new->next = res;
 104             res = new;
 105         }
 106     }
 107     return res;
 108 }
 109
 110 static struct zr_authentication *authentication(NMEM m, xmlNode *node)
 111 {
 112     xmlNode *n;
 113     struct zr_authentication *r = nmem_malloc(m, sizeof(*r));
 114     memset(r, 0, sizeof(*r));
 115     r->type = attrtostr(m, node, "type");
 116     for (n = node->children; n; n = n->next)
 117     {
 118         if (n->type != XML_ELEMENT_NODE)
 119             continue;
 120         if (!strcmp(n->name, "open"))
 121             r->open = valuetostr(m, n);
 122         else if (!strcmp(n->name, "user"))
 123             r->user = valuetostr(m, n);
 124         else if (!strcmp(n->name, "group"))
 125             r->group = valuetostr(m, n);
 126         else if (!strcmp(n->name, "password"))
 127             r->password = valuetostr(m, n);
 128         else
 129         {
 130             fail("Unexpected element", n);
 131             return 0;
 132         }
 133     }
 134     return r;
 135 }
 136
 137
 138 static struct zr_serverInfo *serverInfo(NMEM m, xmlNode *node)
 139 {
 140     xmlNode *n;
 141     struct zr_serverInfo *r = nmem_malloc(m, sizeof(*r));
 142     memset(r, 0, sizeof(*r));
 143
 144     r->protocol = attrtostr(m, n, "protocol");
 145     r->version = attrtostr(m, n, "version");
 146     r->transport = attrtostr(m, n, "transport");
 147     r->method = attrtostr(m, n, "method");
 148     for (n = node->children; n; n = n->next)
 149     {
 150         if (n->type != XML_ELEMENT_NODE)
 151             continue;
 152         if (!strcmp(n->name, "host"))
 153             r->host = valuetostr(m, n);
 154         else if (!strcmp(n->name, "port"))
 155             r->port = valuetoint(n);
 156         else if (!strcmp(n->name, "database"))
 157             r->database = valuetostr(m, n);
 158         else if (!strcmp(n->name, "authentication") && !(r->authentication =
 159                         authentication(m, n)))
 160             return 0;
 161         else
 162         {
 163             fail("Unexpected element", n);
 164             return 0;
 165         }
 166     }
 167     return r;
 168 }
 169
 170 static struct zr_agent *agent(NMEM m, xmlNode *node)
 171 {
 172     struct zr_agent *r = nmem_malloc(m, sizeof(*r));
 173     memset(r, 0, sizeof(*r));
 174     r->type = attrtostr(m, node, "type");
 175     r->identifier = attrtostr(m, node, "identifier");
 176     r->value = valuetostr(m, node);
 177     return r;
 178 }
 179
 180 static struct zr_implementation *implementation(NMEM m, xmlNode *node)
 181 {
 182     xmlNode *n;
 183     struct zr_implementation *r = nmem_malloc(m, sizeof(*r));
 184     memset(r, 0, sizeof(*r));
 185     r->identifier = attrtostr(m, node, "identifier");
 186     r->version = attrtostr(m, node, "version");
 187     r->title = findlangstr(m, node, "title");
 188     for (n = node->children; n; n = n->next)
 189     {
 190         if (n->type != XML_ELEMENT_NODE)
 191             continue;
 192         if (!strcmp(n->name, "agent"))
 193         {
 194             struct zr_agent *ag = agent(m, node);
 195             if (!ag)
 196                 return 0;
 197             ag->next = r->agents;
 198             r->agents = ag;
 199         }
 200     }
 201     return r;
 202 }
 203
 204 struct zr_databaseInfo *databaseInfo(NMEM m, xmlNode *node)
 205 {
 206     xmlNode *n;
 207     struct zr_databaseInfo *r = nmem_malloc(m, sizeof(*r));
 208     memset(r, 0, sizeof(*r));
 209
 210     r->title = findlangstr(m, node, "title");
 211     r->description = findlangstr(m, node, "description");
 212     r->history = findlangstr(m, node, "history");
 213     r->extent = findlangstr(m, node, "extent");
 214     r->restrictions = findlangstr(m, node, "restrictions");
 215     r->langUsage = findlangstr(m, node, "langUsage");
 216
 217     for (n = node->children; n; n = n->next)
 218     {
 219         if (n->type != XML_ELEMENT_NODE)
 220             continue;
 221         if (!strcmp(n->name, "agents"))
 222         {
 223             xmlNode *n2;
 224             for (n2 = n->children; n2; n2 = n2->next)
 225             {
 226                 if (n2->type != XML_ELEMENT_NODE)
 227                     continue;
 228                 if (strcmp(n2->name, "agent"))
 229                     continue;
 230                 else
 231                 {
 232                     struct zr_agent *ag = agent(m, n2);
 233                     if (!ag)
 234                         return 0;
 235                     ag->next = r->agents;
 236                     r->agents = ag;
 237                 }
 238             }
 239         }
 240         else if (!strcmp(n->name, "implementation") &&
 241                 !(r->implementation = implementation(m, n)))
 242             return 0;
 243         else if (!strcmp(n->name, "links"))
 244         {
 245             xmlNode *n2;
 246             for (n2 = n->children; n2; n2 = n2->next)
 247             {
 248                 if (!n2->type != XML_ELEMENT_NODE)
 249                     continue;
 250                 if (!strcmp(n2->name, "link"))
 251                     continue;
 252                 else
 253                 {
 254                     struct zr_link *li = nmem_malloc(m, sizeof(*li));
 255                     memset(li, 0, sizeof(*li));
 256                     li->type = attrtostr(m, n2, "type");
 257                     li->value = valuetostr(m, n2);
 258                     li->next = r->links;
 259                     r->links = li;
 260                 }
 261             }
 262         }
 263         else if (!strcmp(n->name, "history") && !r->lastUpdate)
 264             r->lastUpdate = attrtostr(m, n, "lastUpdate");
 265         else if (!strcmp(n->name, "extent") && !r->numberOfRecords)
 266             r->numberOfRecords = attrtoint(n, "numberOfRecords");
 267         else if (!strcmp(n->name, "langUsage") && !r->codes)
 268             r->codes = attrtostr(m, n, "codes");
 269     }
 270     return r;
 271 }
 272
 273 struct zr_metaInfo *metaInfo(NMEM m, xmlNode *node)
 274 {
 275     xmlNode *n;
 276     struct zr_metaInfo *r = nmem_malloc(m, sizeof(*r));
 277     memset(r, 0, sizeof(*r));
 278
 279     for (n = node->children; n; n = n->next)
 280     {
 281         if (!n->type == XML_ELEMENT_NODE)
 282             continue;
 283         if (!strcmp(n->name, "dateModified"))
 284             r->dateModified = valuetostr(m, n);
 285         else if (!strcmp(n->name, "dateAggregated"))
 286             r->dateAggregated = valuetostr(m, n);
 287         else if (!strcmp(n->name, "aggregatedFrom"))
 288             r->aggregatedFrom = valuetostr(m, n);
 289         else
 290         {
 291             fail("Unexpected element", n);
 292             return 0;
 293         }
 294     }
 295     return r;
 296 }
 297
 298 struct zr_set *set(NMEM m, xmlNode *node)
 299 {
 300     struct zr_set *r = nmem_malloc(m, sizeof(*r));
 301     memset(r, 0, sizeof(*r));
 302     r->name = attrtostr(m, node, "name");
 303     r->identifier = attrtostr(m, node, "identifier");
 304     r->title = findlangstr(m, node, "title");
 305     return r;
 306 }
 307
 308 struct zr_attr *attr(NMEM m, xmlNode *node)
 309 {
 310     struct zr_attr *r = nmem_malloc(m, sizeof(*r));
 311     memset(r, 0, sizeof(*r));
 312     r->type = attrtoint(node, "type");
 313     r->set = attrtostr(m, node, "set");
 314     return r;
 315 }
 316
 317 static struct zr_map *map(NMEM m, xmlNode *node)
 318 {
 319     xmlNode *n;
 320     struct zr_map *r = nmem_malloc(m, sizeof(*r));
 321     memset(r, 0, sizeof(*r));
 322
 323     r->lang = attrtostr(m, node, "lang");
 324     r->primary = attrtobool(node, "primary");
 325     for (n = node->children; n; n = n->next)
 326     {
 327         if (n->type != XML_ELEMENT_NODE)
 328             continue;
 329         if (!strcmp(n->name, "name"))
 330         {
 331             r->set = attrtostr(m, n, "set");
 332             r->name = valuetostr(m, n);
 333         }
 334         else if (!strcmp(n->name, "attr"))
 335         {
 336             struct zr_attr *new = attr(m, n);
 337             if (!new)
 338                 return 0;
 339             new->next = r->attrs;
 340             r->attrs = new;
 341         }
 342         else
 343         {
 344             fail("Unexpected element", n);
 345             return 0;
 346         }
 347     }
 348     return r;
 349 }
 350
 351 static Zr_setting *findsetting(NMEM m, xmlNode *node, char *name)
 352 {
 353     static Zr_setting *r = 0;
 354     xmlNode *n;
 355     for (n = node->children; n; n = n->next)
 356     {
 357         if (node->type == XML_ELEMENT_NODE && !strcmp(n->name, name))
 358         {
 359             xmlNode *n2;
 360             struct zr_setting *new = nmem_malloc(m, sizeof(*new));
 361             memset(new, 0, sizeof(*new));
 362             new->type = attrtostr(m, n, "type");
 363             for (n2 = n->children; n2; n2 = n2->next)
 364             {
 365                 if (n2->type == XML_ELEMENT_NODE && !strcmp(n2->name, "map"))
 366                 {
 367                     new->map = map(m, n2);
 368                     if (!new)
 369                         return 0;
 370                     break;
 371                 }
 372             }
 373             if (!new->map)
 374                 new->value = xmlNodeGetContent(n);
 375             new->next = r;
 376             r = new;
 377         }
 378     }
 379     return r;
 380 }
 381
 382 static struct zr_configInfo *configInfo(NMEM m, xmlNode *node)
 383 {
 384     struct zr_configInfo *r = nmem_malloc(m, sizeof(*r));
 385
 386     r->defaultv = findsetting(m, node, "default");
 387     r->setting = findsetting(m, node, "setting");
 388     r->supports = findsetting(m, node, "supports");
 389     return r;
 390 }
 391
 392 static struct zr_index *parse_index(NMEM m, xmlNode *node)
 393 {
 394     xmlNode *n;
 395     struct zr_index *r = nmem_malloc(m, sizeof(*r));
 396     memset(r, 0, sizeof(*r));
 397
 398     r->search = attrtobool(node, "search");
 399     r->scan = attrtobool(node, "scan");
 400     r->sort = attrtobool(node, "sort");
 401     r->id = attrtostr(m, node, "id");
 402     r->title = findlangstr(m, node, "title");
 403
 404     for (n = node->children; n; n = n->next)
 405     {
 406         if (!strcmp(n->name, "map"))
 407         {
 408             struct zr_map *new = map(m, n);
 409             if (!new)
 410                 return 0;
 411             new->next = r->maps;
 412             r->maps = new;
 413         }
 414         else if (!strcmp(n->name, "configInfo") && !(r->configInfo = configInfo(m, n)))
 415             return 0;
 416         else if (strcmp(n->name, "title"))
 417         {
 418             fail("Unknown child element", n);
 419             return 0;
 420         }
 421     }
 422     return r;
 423 }
 424
 425 static struct zr_sortKeyword *sortKeyword(NMEM m, xmlNode *node)
 426 {
 427     struct zr_sortKeyword *r = nmem_malloc(m, sizeof(*r));
 428     memset(r, 0, sizeof(*r));
 429     r->value = valuetostr(m, node);
 430     return r;
 431 }
 432
 433 static struct zr_indexInfo *indexInfo(NMEM m , xmlNode *node)
 434 {
 435     xmlNode *n;
 436     struct zr_indexInfo *r = nmem_malloc(m, sizeof(*r));
 437     memset(r, 0, sizeof(*r));
 438
 439     for (n = node->children; n; n = n->next)
 440     {
 441         if (n->type != XML_ELEMENT_NODE)
 442             continue;
 443         if (!strcmp(n->name, "set"))
 444         {
 445             struct zr_set *new = set(m, n);
 446             if (!new)
 447                 return 0;
 448             new->next = r->sets;
 449             r->sets = new;
 450         }
 451         else if (!strcmp(n->name, "index"))
 452         {
 453             struct zr_index *new = parse_index(m, n);
 454             if (!new)
 455                 return 0;
 456             new->next = r->indexes;
 457             r->indexes = new;
 458         }
 459         else if (!strcmp(n->name, "sortKeyword"))
 460         {
 461             struct zr_sortKeyword *new = sortKeyword(m, n);
 462             if (!new)
 463                 return 0;
 464             new->next = r->sortKeywords;
 465             r->sortKeywords = new;
 466         }
 467         else if (!strcmp(n->name, "sortKeyword") && !(r->configInfo = configInfo(m, n)))
 468             return 0;
 469         else
 470         {
 471             fail("Unknown child element", n);
 472             return 0;
 473         }
 474     }
 475     return r;
 476 }
 477
 478 static struct zr_elementSet *elementSet(NMEM m, xmlNode *node)
 479 {
 480     struct zr_elementSet *r = nmem_malloc(m, sizeof(*r));
 481     memset(r, 0, sizeof(*r));
 482     r->name = attrtostr(m, node, "name");
 483     r->identifier = attrtostr(m, node, "identifier");
 484     r->title = findlangstr(m, node, "title");
 485     return r;
 486 }
 487
 488 static struct zr_recordSyntax *recordSyntax(NMEM m, xmlNode *node)
 489 {
 490     xmlNode *n;
 491     struct zr_recordSyntax *r = nmem_malloc(m, sizeof(*r));
 492     struct zr_elementSet **elementp = &r->elementSets;
 493
 494     memset(r, 0, sizeof(*r));
 495     r->name = attrtostr(m, node, "name");
 496     r->identifier = attrtostr(m, node, "identifier");
 497     for (n = node->children; n; n = n->next)
 498     {
 499         if (n->type != XML_ELEMENT_NODE)
 500             continue;
 501         if (!strcmp(n->name, "elementSet"))
 502         {
 503             if (!(*elementp = elementSet(m, n)))
 504                 return 0;
 505             elementp = &(*elementp)->next;
 506         }
 507         else
 508         {
 509             fail("Unknown child element", n);
 510             return 0;
 511         }
 512     }
 513     return r;
 514 }
 515
 516 static struct zr_recordInfo *recordInfo(NMEM m, xmlNode *node)
 517 {
 518     xmlNode *n;
 519     struct zr_recordInfo *r = nmem_malloc(m, sizeof(*r));
 520     struct zr_recordSyntax **syntaxp = &r->recordSyntaxes;
 521
 522     memset(r, 0, sizeof(*r));
 523     for (n = node->children; n; n = n->next)
 524     {
 525         if (n->type != XML_ELEMENT_NODE)
 526             continue;
 527         if (!strcmp(n->name, "recordSyntax"))
 528         {
 529             if (!(*syntaxp = recordSyntax(m, n)))
 530                 return 0;
 531             syntaxp = &(*syntaxp)->next;
 532         }
 533         else
 534         {
 535             fail("Unknown child element", n);
 536             return 0;
 537         }
 538     }
 539     return r;
 540 }
 541
 542
 543 static struct zr_schema *schema(NMEM m, xmlNode *node)
 544 {
 545     struct zr_schema *r = nmem_malloc(m, sizeof(*r));
 546     memset(r, 0, sizeof(*r));
 547
 548     r->name = attrtostr(m, node, "name");
 549     r->identifier = attrtostr(m, node, "identifier");
 550     r->retrieve = attrtobool(node, "retrieve");
 551     r->sort = attrtobool(node, "sort");
 552     r->location = attrtostr(m, node, "location");
 553     r->title = findlangstr(m, node, "title");
 554     return r;
 555 }
 556
 557 static struct zr_schemaInfo *schemaInfo(NMEM m, xmlNode *node)
 558 {
 559     xmlNode *n;
 560     struct zr_schemaInfo *r = nmem_malloc(m, sizeof(*r));
 561     struct zr_schema **schemap = &r->schemas;
 562
 563     memset(r, 0, sizeof(*r));
 564     for (n = node->children; n; n = n->next)
 565     {
 566         if (n->type != XML_ELEMENT_NODE)
 567             continue;
 568         if (!strcmp(n->name, "schema"))
 569         {
 570             if (!(*schemap = schema(m, n)))
 571                 return 0;
 572             schemap = &(*schemap)->next;
 573         }
 574         else
 575         {
 576             fail("Unknown child element", n);
 577             return 0;
 578         }
 579     }
 580     return r;
 581 }
 582
 583 static struct zr_explain *explain(NMEM m, xmlNode *node)
 584 {
 585     xmlNode *n;
 586     struct zr_explain *r = nmem_malloc(m, sizeof(*r));
 587     memset(r, 0, sizeof(*r));
 588
 589     for (n = node->children; n; n = n->next)
 590     {
 591         if (n->type != XML_ELEMENT_NODE)
 592             continue;
 593         if (!strcmp(n->name, "serverInfo") && !(r->serverInfo = serverInfo(m, n)))
 594             return 0;
 595         else if (!strcmp(n->name, "databaseInfo") && !(r->databaseInfo = databaseInfo(m, n)))
 596             return 0;
 597         else if (!strcmp(n->name, "metaInfo") && !(r->metaInfo = metaInfo(m, n)))
 598             return 0;
 599         else if (!strcmp(n->name, "indexInfo") && !(r->indexInfo = indexInfo(m, n)))
 600             return 0;
 601         else if (!strcmp(n->name, "recordInfo") && !(r->recordInfo = recordInfo(m, n)))
 602             return 0;
 603         else if (!strcmp(n->name, "schemaInfo") && !(r->schemaInfo = schemaInfo(m, n)))
 604             return 0;
 605         else if (!strcmp(n->name, "configInfo") && !(r->configInfo = configInfo(m, n)))
 606            return 0;
 607         else
 608         {
 609             fail("Unknown child element", n);
 610             return 0;
 611         }
 612     }
 613     return r;
 614 }
 615
 616 struct zr_explain *zr_read_xml(NMEM m, xmlNode *n)
 617 {
 618     return explain(m, n);
 619 }
 620
 621 struct zr_explain *zr_read_file(NMEM m, const char *fn)
 622 {
 623     xmlDoc *doc = xmlParseFile(fn);
 624     struct zr_explain *r;
 625     if (!doc)
 626     {
 627         yaz_log(YLOG_WARN|YLOG_ERRNO, "Unable to open %s", fn);
 628         return 0;
 629     }
 630     r = explain(m, xmlDocGetRootElement(doc));
 631     xmlFree(doc);
 632     return r;
 633 }
 634
 635 /*
 636  * Local variables:
 637  * c-basic-offset: 4
 638  * indent-tabs-mode: nil
 639  * End:
 640  * vim: shiftwidth=4 tabstop=8 expandtab
 641  */