librhcm/xmlconfig.c

   1 /*
   2   Copyright Red Hat, Inc. 2002-2003
   3
   4   The Red Hat Cluster Manager API Library is free software; you can
   5   redistribute it and/or modify it under the terms of the GNU Lesser
   6   General Public License as published by the Free Software Foundation;
   7   either version 2.1 of the License, or (at your option) any later
   8   version.
   9
  10   The Red Hat Cluster Manager API Library is distributed in the hope
  11   that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13   PURPOSE.  See the GNU Lesser General Public License for more details.
  14
  15   You should have received a copy of the GNU Lesser General Public
  16   License along with this library; if not, write to the Free Software
  17   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18   USA.
  19  */
  20 /** @file
  21  * Configuration Library using libxml2 Doc Tree.
  22  *
  23  * XXX Needs Doxygenification.
  24  */
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <libxml/xmlmemory.h>
  30 #include <libxml/parser.h>
  31 #include <sys/queue.h>
  32 #include <signal.h>
  33 #include <sys/param.h>
  34 #include <sys/types.h>
  35 #include <regex.h>                      /* Regular Expression Matching */
  36 #include <fnmatch.h>                    /* Glob pattern matching */
  37 #include <xmlconfig.h>
  38 #include <fcntl.h>
  39 #include <errno.h>
  40
  41
  42 struct _uint_stack {
  43         struct _uint_stack *uis_next;
  44         unsigned int uis_val;
  45 };
  46
  47
  48 static inline int
  49 _uis_push(struct _uint_stack **stack, int val)
  50 {
  51         struct _uint_stack *new;
  52
  53         if (!stack)
  54                 return -1;
  55
  56         if (!(new = malloc(sizeof(*new))))
  57                 return -1;
  58
  59         new->uis_next = *stack;
  60         new->uis_val = val;
  61         *stack = new;
  62
  63         return 0;
  64 }
  65
  66
  67 static inline int
  68 _uis_pop(struct _uint_stack **stack)
  69 {
  70         struct _uint_stack *del;
  71         int rv;
  72
  73         if (!*stack)
  74                 return -1;
  75
  76         del = *stack;
  77         *stack = (*stack)->uis_next;
  78         rv = del->uis_val;
  79         free(del);
  80
  81         return rv;
  82 }
  83
  84
  85 static inline void
  86 _uis_kill(struct _uint_stack **stack)
  87 {
  88         while (_uis_pop(stack) != -1);
  89 }
  90
  91
  92 static inline xmlAttrPtr
  93 _xmlGetAttrPtr(xmlNodePtr cur, const char *prop)
  94 {
  95         xmlAttrPtr attr = cur->properties;
  96
  97         for (; attr; attr = attr->next)
  98                 if (!strcasecmp((char *)attr->name, prop))
  99                         return attr;
 100
 101         return NULL;
 102 }
 103
 104
 105 static inline int
 106 _is_regex(const char *token)
 107 {
 108         return (strcspn(token,"([.*|+])") != strlen(token));
 109 }
 110
 111
 112 /**
 113  * construct a list of all tokens in our XML tree in the form:
 114  * "tag%subtag%subtag1%abc123%property"
 115  * TODO optimize, optimize, optimize...
 116  */
 117 int
 118 xtree_tl_build(xmlDocPtr xtree, struct _token_list_head *head,
 119                const char *m_pat, int m_type)
 120 {
 121         xmlNodePtr cur = xmlDocGetRootElement(xtree);
 122         xmlAttrPtr attr = NULL;
 123         char token[MAX_TOKEN_LEN], *prop;
 124         unsigned int pos = 0, tmp;
 125         struct _uint_stack *stack = NULL;
 126         struct _token_list_node *tnode;
 127         int count = 0;
 128
 129         MATCH_INIT(m_pat, m_type);
 130
 131         if (!head || !cur) {
 132                 MATCH_FREE(m_pat, m_type);
 133                 return -1;
 134         }
 135
 136         TAILQ_INIT(head);
 137
 138         cur = cur->xmlChildrenNode;
 139         while (cur) {
 140                 if (cur->type == XML_TEXT_NODE)
 141                         goto next;
 142
 143                 strncpy(token + pos, (char *)cur->name, sizeof(token) - pos);
 144                 prop = (char *)xmlGetProp(cur, (xmlChar *)"id");
 145                 if (prop) {
 146                         strncat(token + strlen(token), prop,
 147                                 MIN(strlen(prop) + 1,
 148                                     sizeof(token) - strlen(token)));
 149                         xmlFree(prop);
 150                 }
 151
 152                 if (cur->xmlChildrenNode) {
 153                         _uis_push(&stack, pos);
 154                         cur = cur->xmlChildrenNode;
 155                         strncat(token + strlen(token), "%",
 156                                 MIN(2, sizeof(token) - strlen(token)));
 157                         pos = strlen(token);
 158                         continue;
 159                 }
 160
 161                 /* Here we tack on the properties */
 162                 tmp = strlen(token);
 163                 strncat(token + tmp, "%", MIN(2, sizeof(token) - tmp));
 164 nochild:
 165                 tmp = strlen(token);
 166                 attr = cur->properties;
 167                 while (attr) {
 168                         if (!strcasecmp((char *)attr->name,"id")) {
 169                                 attr = attr->next;
 170                                 continue;
 171                         }
 172
 173                         strncpy(token + tmp, (char *)attr->name,
 174                                 MIN(strlen((char *)attr->name) + 1,
 175                                     sizeof(token) - tmp));
 176
 177                         if (!MATCH(token, m_pat, m_type)) {
 178                                 attr = attr->next;
 179                                 continue;
 180                         }
 181
 182                         if (!(tnode = malloc(sizeof(*tnode)))) {
 183                                 perror("malloc");
 184                                 MATCH_FREE(m_pat, m_type);
 185                                 _uis_kill(&stack);
 186                                 return -1;
 187                         }
 188
 189                         memset(tnode,0,sizeof(*tnode));
 190
 191                         if (!(tnode->tl_token = strdup(token))) {
 192                                 perror("strdup");
 193                                 MATCH_FREE(m_pat, m_type);
 194                                 _uis_kill(&stack);
 195                                 free(tnode);
 196                                 return -1;
 197                         }
 198
 199                         if (!(tnode->tl_value =
 200                               strdup((char *)attr->children->content))) {
 201                                 perror("strdup");
 202                                 MATCH_FREE(m_pat, m_type);
 203                                 _uis_kill(&stack);
 204                                 free(tnode->tl_token);
 205                                 free(tnode);
 206                                 return -1;
 207                         }
 208
 209                         tnode->tl_terminal = attr;
 210
 211                         TAILQ_INSERT_TAIL(head, tnode, tl_chain);
 212                         count++;
 213                         attr = attr->next;
 214                 }
 215                 token[tmp] = 0;
 216
 217 next:
 218                 if (cur->next) {
 219                         cur = cur->next;
 220                         continue;
 221                 }
 222
 223                 if (pos) {
 224                         token[pos] = 0;
 225                         pos = _uis_pop(&stack);
 226                         cur = cur->parent;
 227                         goto nochild;
 228                 }
 229
 230                 break;
 231         }
 232
 233         _uis_kill(&stack);
 234         MATCH_FREE(m_pat,m_type);
 235         return count;
 236 }
 237
 238
 239 void
 240 xtree_tl_free(struct _token_list_head *head)
 241 {
 242         struct _token_list_node *cur, *back;
 243
 244         cur = head->tqh_first;
 245         while (cur) {
 246                 back = cur;
 247                 cur = cur->tl_chain.tqe_next;
 248
 249                 TAILQ_REMOVE(head, back, tl_chain);
 250                 free(back->tl_token);
 251                 free(back->tl_value);
 252                 free(back);
 253         }
 254
 255         head->tqh_first = NULL;
 256 }
 257
 258
 259 static char *
 260 _extract_int(char *chunk, char *rv, int rv_size)
 261 {
 262         int id_loc;
 263         char *id;
 264
 265         if ((id_loc = strcspn(chunk,"0123456789")) < strlen(chunk)) {
 266                 id = chunk + id_loc;
 267                 strncpy(rv, id, rv_size);
 268                 *id = 0;
 269                 return rv;
 270         }
 271
 272         return NULL;
 273 }
 274
 275
 276 static int
 277 _has_attributes(xmlNodePtr node)
 278 {
 279         xmlAttrPtr attr = node->properties;
 280
 281         while (attr) {
 282                 if ((attr->type == XML_ATTRIBUTE_NODE) &&
 283                     strcasecmp((char *)attr->name,"id"))
 284                         return 1;
 285                 attr = attr->next;
 286         }
 287
 288         return 0;
 289 }
 290
 291
 292 static int
 293 _has_children(xmlNodePtr node)
 294 {
 295         xmlNodePtr cur = node->xmlChildrenNode;
 296
 297         while (cur) {
 298                 if (node->type == XML_ELEMENT_NODE)
 299                         return 1;
 300                 cur = cur->next;
 301         }
 302
 303         return 0;
 304 }
 305
 306
 307 int
 308 _xtree_del(xmlAttrPtr attr)
 309 {
 310         xmlNodePtr cur, pp;
 311
 312         if (!attr)
 313                 return 0;
 314
 315         cur = attr->parent;
 316         xmlRemoveProp(attr);
 317
 318         /* Ok, check if that was our last property/child */
 319         while (!_has_children(cur) && !_has_attributes(cur)) {
 320                 pp = cur->parent;
 321                 xmlUnlinkNode(cur);
 322                 xmlFreeNode(cur);
 323                 cur = pp;
 324         }
 325
 326         return 0;
 327 }
 328
 329
 330 xmlAttrPtr
 331 _xtree_find(xmlDocPtr xtree, const char *token)
 332 {
 333         char            *tok = NULL,
 334                         *part = NULL,
 335                         *nextpart = NULL,
 336                         *id = NULL,
 337                         *id_check = NULL,
 338                         buf[16];
 339         xmlNodePtr      cur = xmlDocGetRootElement(xtree),
 340                         last_parent = NULL;
 341         xmlAttrPtr      rv = NULL;
 342
 343         /* duplicate our inbound token, so we can tokenize it */
 344         if (!cur || (!(tok = malloc(strlen(token)+1))))
 345                 return NULL;
 346
 347         /* Set up */
 348         strcpy(tok,token);
 349         last_parent = cur;
 350         cur = cur->xmlChildrenNode;
 351         part = tok;
 352
 353         while ((nextpart = strchr(part,'%')) && cur) {
 354                 *nextpart = 0;                  /* remove '%' */
 355                 nextpart++;
 356                 id = _extract_int(part, buf, sizeof(buf));
 357
 358                 while (cur) {                   /* check for drop-to-child */
 359                         if (xmlStrcmp(cur->name, (xmlChar *)part) != 0) {
 360                                 cur = cur->next;
 361                                 continue;
 362                         }
 363
 364                         if (id) {
 365                                 /* compare the ID */
 366                                 id_check = (char *)xmlGetProp(cur,
 367                                                               (xmlChar *)"id");
 368
 369                                 if (id_check && strcasecmp(id, id_check)) {
 370                                         cur = cur->next;
 371                                         xmlFree(id_check);
 372                                         continue;
 373                                 }
 374
 375                                 if (id_check)
 376                                         xmlFree(id_check);
 377                                 id = NULL;
 378                         }
 379
 380                         last_parent = cur;
 381                         cur = cur->xmlChildrenNode;
 382                         break;
 383                 }
 384
 385                 /*
 386                  * if id is till set here, we have an id from above, but it
 387                  * wasn't found.
 388                  */
 389                 if (id)
 390                         break;
 391
 392                 part = nextpart;
 393         }
 394
 395         /* clean up, etc. */
 396         if (!nextpart) {
 397                 if (id)                 /* ID not found! */
 398                         rv = NULL;
 399                 else                    /* xml node property */
 400                         rv = _xmlGetAttrPtr(last_parent, part);
 401         }
 402
 403         free(tok);
 404
 405         return rv;
 406 }
 407
 408
 409 /*
 410  * bottom-up deletion... ;)
 411  */
 412 int
 413 xtree_del(xmlDocPtr xtree, const char *token)
 414 {
 415         return _xtree_del(_xtree_find(xtree,token));
 416 }
 417
 418
 419 int
 420 xtree_set(xmlDocPtr xtree, const char *token, char *value)
 421 {
 422         char            *tok = NULL,
 423                         *part = NULL,
 424                         *nextpart = NULL,
 425                         *id_check = NULL,
 426                         *id = NULL,
 427                         child = 0,
 428                         buf[16],
 429                         sv;
 430         xmlNodePtr      cur = xmlDocGetRootElement(xtree),
 431                         last_parent = NULL,
 432                         newnode = NULL;
 433
 434         /* Reject regexps in this case */
 435         if (_is_regex(token))
 436                 return -1;
 437
 438         /* duplicate our inbound token, so we can hack it up */
 439         if (!cur || !strlen(token) || (!(tok = malloc(strlen(token)+1))))
 440                 return -1;
 441
 442         /* Set up */
 443         strncpy(tok, token, strlen(token)+1);
 444         last_parent = cur;
 445         cur = cur->xmlChildrenNode;
 446         part = tok;
 447
 448         nextpart = strchr(part, '%');
 449         while (nextpart) {
 450                 *nextpart = 0;                  /* remove '%' */
 451                 nextpart++;
 452
 453                 id = _extract_int(part, buf, sizeof(buf));
 454
 455                 while (cur) {                   /* check for drop-to-child */
 456
 457                         if (strcasecmp((char *)cur->name, part)) {
 458                                 cur = cur->next;
 459                                 continue;
 460                         }
 461
 462                         if (id) {
 463                                 /* compare the ID */
 464                                 id_check = (char *)xmlGetProp(cur,
 465                                                               (xmlChar *)"id");
 466
 467                                 if (strcasecmp(id, id_check)) {
 468                                         /* not the same */
 469                                         cur = cur->next;
 470                                         xmlFree(id_check);
 471                                         continue;
 472                                 }
 473
 474                                 id = NULL;
 475                                 xmlFree(id_check);
 476                         }
 477
 478                         last_parent = cur;
 479                         cur = cur->xmlChildrenNode;
 480                         part = nextpart;
 481                         child = 1;
 482                         break;
 483                 }
 484
 485                 /*
 486                  * Ok, we dropped to child successfully.  No IDs needed,
 487                  * just continue
 488                  */
 489                 if (child) {
 490                         child = 0;
 491                         nextpart = strchr(part, '%');
 492                         continue;
 493                 }
 494
 495                 /*
 496                  * ok, so we've run off the end of our token or the
 497                  * end of the XML tree.
 498                  */
 499                 if (!nextpart)
 500                         /* Attribute! */
 501                         break;
 502
 503                 /* New regular node.  Add it. */
 504                 sv = *nextpart;
 505                 *nextpart = 0;
 506                 newnode = xmlNewNode(NULL, (xmlChar *)part);
 507                 *nextpart = sv;
 508
 509                 cur = xmlAddChild(last_parent, newnode);
 510                 if (!cur) {
 511                         xmlFreeNode(newnode);
 512                         free(tok);
 513                         return -1;
 514                 }
 515
 516                 last_parent = cur;
 517                 cur = newnode->xmlChildrenNode; /* same as NULL */
 518
 519                 /* Don't forget to continue eating the token */
 520                 part = nextpart;
 521                 nextpart = strchr(part, '%');
 522
 523                 /* set id property if it exists */
 524                 if (id)
 525                         xmlSetProp(newnode, (xmlChar *)"id", (xmlChar *)id);
 526         }
 527
 528         /* Write out the property */
 529         if (!nextpart)
 530                 xmlSetProp(last_parent, (xmlChar *)part, (xmlChar *)value);
 531
 532         free(tok);
 533         return 0;
 534 }
 535
 536
 537 int
 538 xtree_get(xmlDocPtr xtree, const char *token, char *dflt, char **value)
 539 {
 540         xmlAttrPtr      attr;
 541
 542         /* Reject regexps in this case */
 543         if (_is_regex(token)) {
 544                 printf("token is regex\n");
 545                 return -1;
 546         }
 547
 548         attr = _xtree_find(xtree, token);
 549
 550         if (attr && attr->children->content &&
 551             strlen((char*)attr->children->content)) {
 552                 if (value)
 553                         *value = (char *)attr->children->content;
 554                 return 0;
 555         }
 556
 557         if (dflt) {
 558                 if (value)
 559                         *value = dflt;
 560                 return 0;
 561         }
 562
 563         return 1;
 564 }
 565
 566
 567 int
 568 xtree_readfile(const char *filename, xmlDocPtr *xtreep)
 569 {
 570         xmlNodePtr cur;
 571
 572         xmlKeepBlanksDefault(0);
 573         xmlIndentTreeOutput = 1;
 574
 575         *xtreep = xmlParseFile(filename);
 576
 577         if (!*xtreep)
 578                 return -1;
 579
 580         if (!((cur = xmlDocGetRootElement(*xtreep)))) {
 581                 xmlFreeDoc(*xtreep);
 582                 *xtreep = NULL;
 583                 return -1;
 584         }
 585
 586         return 0;
 587 }
 588
 589
 590 int
 591 xtree_readbuffer(const char *buffer, size_t size, xmlDocPtr *xtreep)
 592 {
 593         xmlNodePtr cur;
 594
 595         xmlKeepBlanksDefault(0);
 596         xmlIndentTreeOutput = 1;
 597
 598         *xtreep = xmlParseMemory(buffer, size);
 599
 600         if (!*xtreep) {
 601                 printf("parse failure %p %d\n", buffer, (int)size);
 602                 return -1;
 603         }
 604
 605         if (!((cur = xmlDocGetRootElement(*xtreep)))) {
 606                 printf("root element failure\n");
 607                 xmlFreeDoc(*xtreep);
 608                 *xtreep = NULL;
 609                 return -1;
 610         }
 611
 612         return 0;
 613 }
 614
 615
 616 int
 617 xtree_writefile(const char *filename, xmlDocPtr xtree)
 618 {
 619         char tmpfn[1024];
 620         int fd, tmpfd;
 621         xmlChar *buffer;
 622         struct flock flock;
 623         int n, remain, written, size = 0;
 624
 625         snprintf(tmpfn, sizeof(tmpfn), "%s.XXXXXX", filename);
 626         tmpfd = mkstemp(tmpfn);
 627         if (tmpfd == -1)
 628                 return -1;
 629
 630         memset(&flock, 0, sizeof(flock));
 631         flock.l_type = F_WRLCK;
 632
 633         fd = open(filename, O_WRONLY | O_CREAT | O_SYNC);
 634         if (fd == -1) {
 635                 n = errno;
 636                 close(tmpfd);
 637                 unlink(tmpfn);
 638                 errno = n;
 639                 return -1;
 640         }
 641
 642         while (fcntl(fd, F_SETLKW, &flock) == -1) {
 643                 if (errno == EINTR)
 644                         continue;
 645                 n = errno;
 646                 close(fd);
 647                 close(tmpfd);
 648                 unlink(tmpfn);
 649                 errno = n;
 650                 return -1;
 651         }
 652
 653         xmlDocDumpFormatMemory(xtree, (xmlChar **)&buffer, (int *)&size, 1);
 654
 655         written = 0;
 656         remain = size;
 657         while (remain) {
 658                 n = write(tmpfd, buffer + written, remain);
 659
 660                 if (n == -1) {
 661                         if (errno == EINTR)
 662                                 continue;
 663
 664                         free(buffer);
 665                         n = errno;
 666                         close(fd);
 667                         close(tmpfd);
 668                         unlink(tmpfn);
 669                         errno = n;
 670                         return -1;
 671                 }
 672
 673                 written += n;
 674                 remain -= n;
 675         }
 676
 677         xmlFree(buffer);
 678         if (rename(tmpfn, filename) == -1) {
 679                 n = errno;
 680                 close(fd);
 681                 close(tmpfd);
 682                 unlink(tmpfn);
 683                 errno = n;
 684                 return -1;
 685         }
 686
 687         close(fd);
 688         fsync(tmpfd);
 689         close(tmpfd);
 690         return 0;
 691 }
 692
 693
 694 int
 695 xtree_writebuffer(xmlDocPtr xtree, char **buffer, size_t *size)
 696 {
 697         *size = 0;
 698         xmlDocDumpFormatMemory(xtree, (xmlChar **)buffer, (int *)size, 1);
 699         return 0;
 700 }
 701
 702
 703 void
 704 tlist_dump(struct _token_list_head *lh)
 705 {
 706         struct _token_list_node *cur;
 707
 708         cur = lh->tqh_first;
 709         while (cur) {
 710                 printf("%s => %s\n", cur->tl_token,
 711                        cur->tl_terminal->children->content);
 712                 cur = cur->tl_chain.tqe_next;
 713         }
 714 }