src/xml.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2007 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <err.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <ctype.h>
  28 #include <glib.h>
  29 #include <gcrypt.h>
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include "pwmd_error.h"
  36 #include "xml.h"
  37
  38 void log_write(const gchar *fmt, ...);
  39 gboolean strv_printf(gchar ***array, const gchar *fmt, ...);
  40
  41 gboolean is_literal_element_str(gchar *element)
  42 {
  43     if (!element || !*element)
  44         return FALSE;
  45
  46     return *element == '!' ? TRUE : FALSE;
  47 }
  48
  49 /*
  50  * 'element' must be allocated.
  51  */
  52 gboolean is_literal_element(gchar **element)
  53 {
  54     gchar *p;
  55
  56     if (!element || !*element)
  57         return FALSE;
  58
  59     if (*(*element) == '!') {
  60         gchar *c;
  61
  62         for (p = *element, c = p+1; *c; c++)
  63             *p++ = *c;
  64
  65         *p = 0;
  66         return TRUE;
  67     }
  68
  69     return FALSE;
  70 }
  71
  72 /*
  73  * Fails if 'element' begins with punctuation or digit or contains whitespace.
  74  *
  75  * I'm not sure about using g_unichar_isspace() rather than isspace()?
  76  */
  77 gboolean valid_xml_element(xmlChar *element)
  78 {
  79     gunichar c;
  80     glong len;
  81     gchar *p = (gchar *)element;
  82
  83     if (!element || !*element)
  84         return FALSE;
  85
  86     if (*p == '!')
  87         p++;
  88
  89     len = g_utf8_strlen(p, -1) - 1;
  90     c = g_utf8_get_char(p++);
  91
  92     if (g_unichar_ispunct(c) == TRUE || g_unichar_isdigit(c) == TRUE)
  93         return FALSE;
  94
  95     while (*p && len--) {
  96         c = g_utf8_get_char(p++);
  97
  98         if (g_unichar_isspace(c))
  99             return FALSE;
 100     }
 101
 102     return TRUE;
 103 }
 104
 105 gboolean valid_element_path(gchar **path, gboolean has_value)
 106 {
 107     gchar **p;
 108
 109     for (p = path; *p; p++) {
 110         /*
 111          * An empty element is valid and don't check the syntax of the
 112          * content.
 113          */
 114         if (has_value == TRUE && (!*(p+1) || !*p[0]))
 115             break;
 116
 117         if (valid_xml_element((xmlChar *)*p) == FALSE)
 118             return FALSE;
 119     }
 120
 121     return TRUE;
 122 }
 123
 124 gpg_error_t new_account(xmlDocPtr doc, gchar *name)
 125 {
 126     xmlNodePtr root = xmlDocGetRootElement(doc);
 127     xmlAttrPtr a;
 128     xmlNodePtr n;
 129     gchar *p = name;
 130
 131     if (!p || !root)
 132         return EPWMD_LIBXML_ERROR;
 133
 134     if (is_literal_element_str(p))
 135         p++;
 136
 137     n = xmlNewNode(NULL, (xmlChar *)"account");
 138     n = xmlAddChild(root, n);
 139     a = xmlNewProp(n, (xmlChar *)"name", (xmlChar *)p);
 140     return 0;
 141 }
 142
 143 xmlChar *new_document()
 144 {
 145     xmlChar *buf;
 146     const xmlChar *line = (xmlChar *)
 147             "<?xml version=\"1.0\"?>\n"
 148             "<!DOCTYPE accounts [\n"
 149             "<!ELEMENT accounts (account*)>\n"
 150             "<!ATTLIST account name CDATA #REQUIRED>\n"
 151             "]>\n"
 152             "<accounts/>";
 153
 154     buf = gcry_calloc(1, xmlStrlen(line) + 1);
 155     return buf ? xmlStrcat(buf, line) : NULL;
 156 }
 157
 158 /*
 159  * The "target" attribute is ignored here.
 160  */
 161 gpg_error_t list_accounts(xmlDocPtr doc, GString **result)
 162 {
 163     xmlNodePtr n = NULL;
 164     GSList *list = NULL;
 165     gint total, i;
 166     GString *string;
 167     gpg_error_t error = 0;
 168
 169     n = xmlDocGetRootElement(doc);
 170
 171     if (!n || !n->children)
 172         return EPWMD_EMPTY_ELEMENT;
 173
 174     for (n = n->children; n; n = n->next) {
 175         xmlAttrPtr a;
 176         xmlChar *val;
 177         GSList *tlist;
 178
 179         if (n->type != XML_ELEMENT_NODE)
 180             continue;
 181
 182         a = xmlHasProp(n, (xmlChar *)"name");
 183
 184         if (!a || !a->children->content)
 185             continue;
 186
 187         val = xmlNodeGetContent(a->children);
 188
 189         if (!val) {
 190             error = gpg_error_from_errno(ENOMEM);
 191             goto fail;
 192         }
 193
 194         tlist = g_slist_append(list, (gchar *)val);
 195
 196         if (!tlist) {
 197             error = gpg_error_from_errno(ENOMEM);
 198             goto fail;
 199         }
 200
 201         list = tlist;
 202     }
 203
 204     total = g_slist_length(list);
 205
 206     if (!total)
 207         return EPWMD_EMPTY_ELEMENT;
 208
 209     string = g_string_new(NULL);
 210
 211     if (!string) {
 212         error = gpg_error_from_errno(ENOMEM);
 213         goto fail;
 214     }
 215
 216     for (i = 0; i < total; i++) {
 217         xmlChar *val = g_slist_nth_data(list, i);
 218
 219         g_string_append_printf(string, "%s\n", val);
 220     }
 221
 222     string = g_string_truncate(string, string->len - 1);
 223     *result = string;
 224
 225 fail:
 226     total = g_slist_length(list);
 227
 228     for (i = 0; i < total; i++)
 229         xmlFree(g_slist_nth_data(list, i));
 230
 231     g_slist_free(list);
 232     return error;
 233 }
 234
 235 gchar **split_input_line(gchar *str, gchar *delim, gint n)
 236 {
 237     if (!str || !*str)
 238         return NULL;
 239
 240     return g_strsplit(str, delim, n);
 241 }
 242
 243 static gchar **append_element_path(gchar **dst, gchar **src)
 244 {
 245     gchar **p;
 246     gint i;
 247     gchar **d;
 248
 249     if (!src)
 250         return NULL;
 251
 252     d = g_strdupv(dst);
 253
 254     if (!d)
 255         return NULL;
 256
 257     i = g_strv_length(d);
 258
 259     for (p = src; *p; p++) {
 260         gchar **pa;
 261
 262         pa = g_realloc(d, (i + 2) * sizeof(gchar *));
 263
 264         if (!pa) {
 265             g_strfreev(d);
 266             return NULL;
 267         }
 268
 269         d = pa;
 270         d[i] = g_strdup(*p);
 271
 272         if (!d[i]) {
 273             g_strfreev(d);
 274             return NULL;
 275         }
 276
 277         d[++i] = NULL;
 278     }
 279
 280     return d;
 281 }
 282
 283 static xmlNodePtr find_stop_node(xmlNodePtr node)
 284 {
 285     xmlNodePtr n;
 286
 287     for (n = node->parent->children; n; n = n->next) {
 288         if (n == node)
 289             return n->next;
 290     }
 291
 292     return NULL;
 293 }
 294
 295 /*
 296  * Alot like create_elements_cb() but doesn't use the last element of 'req' as
 297  * content but as an element.
 298  */
 299 xmlNodePtr create_target_elements_cb(xmlNodePtr node, gchar **path,
 300         gpg_error_t *error, void *data)
 301 {
 302     gint i;
 303     char **req = path;
 304
 305     if (xmlStrEqual(node->name, (xmlChar *)*req))
 306         req++;
 307
 308     for (i = 0; req[i]; i++) {
 309         xmlNodePtr n;
 310
 311         if ((n = find_element(node, req[i], find_stop_node(node))) == NULL ||
 312                 (n && n->parent == node->parent)) {
 313             is_literal_element(&req[i]);
 314             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 315
 316             if (!n) {
 317                 *error = gpg_error_from_errno(ENOMEM);
 318                 return NULL;
 319             }
 320
 321             node = xmlAddChild(node, n);
 322
 323             if (!node) {
 324                 *error = gpg_error_from_errno(ENOMEM);
 325                 return NULL;
 326             }
 327         }
 328         else
 329             node = n;
 330     }
 331
 332     return node;
 333 }
 334
 335 xmlNodePtr find_text_node(xmlNodePtr node)
 336 {
 337     xmlNodePtr n = node;
 338
 339     if (n && n->type == XML_TEXT_NODE)
 340         return n;
 341
 342     for (n = node; n; n = n->next) {
 343         if (n->type == XML_TEXT_NODE)
 344             return n;
 345     }
 346
 347     return NULL;
 348 }
 349
 350 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 351         gpg_error_t *error, void *data)
 352 {
 353     gint i;
 354     gchar **req = elements;
 355
 356     if (node->type == XML_TEXT_NODE)
 357         node = node->parent;
 358
 359     if (node->name && xmlStrEqual(node->name, (xmlChar *)*req))
 360         req++;
 361
 362     for (i = 0; req[i]; i++) {
 363         xmlNodePtr n;
 364
 365         if (req[i+1]) {
 366             /*
 367              * Strip the first '!' if needed. If there's another, it's an
 368              * error. The syntax has already been checked before calling this
 369              * function.
 370              */
 371             is_literal_element(&req[i]);
 372         }
 373
 374         /*
 375          * The value of the element tree.
 376          */
 377         if (!req[i+1]) {
 378             n = find_text_node(node->children);
 379
 380             if (!n)
 381                 /* Use AddContent here to prevent overwriting any children. */
 382                 xmlNodeAddContent(node, (xmlChar *)req[i]);
 383             else if (n && !*req[i])
 384                 xmlNodeSetContent(n, NULL);
 385             else
 386                 xmlNodeSetContent(n, (xmlChar *)req[i]);
 387
 388             break;
 389         }
 390
 391         n = find_element(node, req[i], find_stop_node(node));
 392
 393         /*
 394          * If the found element has the same parent as the current element,
 395          * they are siblings and the new element needs to be created as a
 396          * child of the current element (node).
 397          */
 398         if (n && n->parent == node->parent)
 399             n = NULL;
 400
 401         if (!n) {
 402             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 403
 404             if (!n) {
 405                 *error = gpg_error_from_errno(ENOMEM);
 406                 return NULL;
 407             }
 408
 409             node = xmlAddChild(node, n);
 410
 411             if (!node) {
 412                 *error = gpg_error_from_errno(ENOMEM);
 413                 return NULL;
 414             }
 415         }
 416         else
 417             node = n;
 418     }
 419
 420     return node;
 421 }
 422
 423 xmlNodePtr find_account(xmlDocPtr doc, gchar ***req, gpg_error_t *error,
 424         gboolean *target, gint recursion_depth)
 425 {
 426     xmlNodePtr n;
 427     gint depth = 0;
 428     gchar *account = g_strdup(*req[0]);
 429     gboolean literal = is_literal_element(&account);
 430
 431     if (!account) {
 432         *error = gpg_error_from_errno(ENOMEM);
 433         return NULL;
 434     }
 435
 436     *error = 0;
 437     recursion_depth++;
 438
 439     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 440         *error = EPWMD_LOOP;
 441         return NULL;
 442     }
 443
 444     for (n = doc->children; n;) {
 445         if (n->type == XML_ELEMENT_NODE) {
 446             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"accounts")) {
 447                 n = n->children;
 448                 depth++;
 449                 continue;
 450             }
 451
 452             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"account")) {
 453                 xmlChar *content = node_has_attribute(n, (xmlChar *)"name");
 454
 455                 if (!content)
 456                     continue;
 457
 458                 if (xmlStrEqual(content, (xmlChar *)account)) {
 459                     gchar **nreq, **tmp = NULL;
 460
 461                     if (literal == TRUE) {
 462                         g_free(account);
 463                         return n;
 464                     }
 465
 466                     content = node_has_attribute(n, (xmlChar *)"target");
 467
 468                     if (!content) {
 469                         g_free(account);
 470                         return n;
 471                     }
 472
 473                     if (strchr((gchar *)content, '\t')) {
 474                         nreq = split_input_line((gchar *)content, "\t", 0);
 475
 476 #if 0
 477                         /*
 478                          * FIXME ENOMEM
 479                          */
 480                         if (!nreq) {
 481                             *error = gpg_error_from_errno(ENOMEM);
 482                             return NULL;
 483                         }
 484 #endif
 485
 486                         tmp = *req;
 487                         tmp = append_element_path(nreq, tmp+1);
 488                         g_strfreev(nreq);
 489
 490                         if (!tmp) {
 491                             *error = gpg_error_from_errno(ENOMEM);
 492                             return NULL;
 493                         }
 494
 495                         g_strfreev(*req);
 496                         *req = tmp;
 497                     }
 498                     else {
 499                         if (strv_printf(&tmp, "%s", content) == FALSE) {
 500                             *error = gpg_error_from_errno(ENOMEM);
 501                             return NULL;
 502                         }
 503
 504                         nreq = *req;
 505                         nreq = append_element_path(tmp, nreq+1);
 506                         g_strfreev(tmp);
 507
 508                         if (!nreq) {
 509                             *error = gpg_error_from_errno(ENOMEM);
 510                             return NULL;
 511                         }
 512
 513                         g_strfreev(*req);
 514                         *req = nreq;
 515                     }
 516
 517                     if (target)
 518                         *target = TRUE;
 519
 520                     g_free(account);
 521                     n = find_account(doc, req, error, target, recursion_depth);
 522                     return n;
 523                 }
 524             }
 525         }
 526
 527         n = n->next;
 528     }
 529
 530     g_free(account);
 531     *error = EPWMD_ELEMENT_NOT_FOUND;
 532     return NULL;
 533 }
 534
 535 xmlNodePtr find_sibling(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 536 {
 537     xmlNodePtr n;
 538
 539     if (!node || !element)
 540         return NULL;
 541
 542     for (n = node; n; n = n->next) {
 543         if (n->type != XML_ELEMENT_NODE)
 544             continue;
 545
 546         if (n == stop)
 547             break;
 548
 549         if (xmlStrEqual(n->name, (xmlChar *)element))
 550             return n;
 551     }
 552
 553     return NULL;
 554 }
 555
 556 xmlNodePtr find_element(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 557 {
 558     if (!node || !element)
 559         return NULL;
 560
 561     return find_sibling(node, element, stop);
 562 }
 563
 564 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 565 {
 566     xmlAttrPtr a = xmlHasProp(n, attr);
 567
 568     if (!a)
 569         return NULL;
 570
 571     if (!a->children || !a->children->content)
 572         return NULL;
 573
 574     return a->children->content;
 575 }
 576
 577 static gboolean element_to_literal(gchar **element)
 578 {
 579     gchar *p = g_strdup_printf("!%s", *element);
 580
 581     if (!p)
 582         return FALSE;
 583
 584     g_free(*element);
 585     *element = p;
 586     return TRUE;
 587 }
 588
 589 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 590         gchar **req, gpg_error_t *error, gboolean *target,
 591         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 592         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 593         gboolean is_list_command, gint recursion_depth, void *data)
 594 {
 595     xmlNodePtr n, last, last_node;
 596     gchar **p;
 597     gint found = 0;
 598
 599     *error = 0;
 600     recursion_depth++;
 601
 602     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 603         recursion_depth--;
 604         *error = EPWMD_LOOP;
 605         return NULL;
 606     }
 607
 608     for (last_node = last = n = node, p = req; *p; p++) {
 609         xmlNodePtr tmp;
 610         gchar *t = g_strdup(*p);
 611         gboolean literal;
 612
 613         if (!t) {
 614             *error = gpg_error_from_errno(ENOMEM);
 615             return NULL;
 616         }
 617
 618         literal = is_literal_element(&t);
 619         n = find_element(last, t, NULL);
 620         g_free(t);
 621
 622         if (!n) {
 623             if (not_found_fn)
 624                 return not_found_fn(found ? last_node : last_node->parent, p, error, data);
 625
 626             *error = EPWMD_ELEMENT_NOT_FOUND;
 627             return NULL;
 628         }
 629
 630         last = n->children;
 631         last_node = n;
 632         found = 1;
 633
 634         if (literal == FALSE) {
 635             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
 636             gchar **nreq = NULL, **nnreq;
 637
 638             if (!content) {
 639                 if (is_list_command == TRUE) {
 640                     if (element_to_literal(&(*p)) == FALSE) {
 641                         *error = gpg_error_from_errno(ENOMEM);
 642                         return NULL;
 643                     }
 644                 }
 645
 646                 continue;
 647             }
 648
 649             if (strchr((gchar *)content, '\t') != NULL) {
 650                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 651                     *error = EPWMD_INVALID_ELEMENT;
 652                     return NULL;
 653                 }
 654             }
 655             else {
 656                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 657                     *error = EPWMD_INVALID_ELEMENT;
 658                     return NULL;
 659                 }
 660             }
 661
 662             tmp = find_account(doc, &nreq, error, target, 0);
 663
 664             if (!tmp) {
 665                 g_strfreev(nreq);
 666                 return NULL;
 667             }
 668
 669             if (found_fn)
 670                 found_fn(n, nreq, error, data);
 671
 672             nnreq = append_element_path(nreq+1, p+1);
 673             g_strfreev(nreq);
 674
 675             // FIXME ENOMEM
 676             if (!nnreq || !*nnreq) {
 677                 if (nnreq)
 678                     g_strfreev(nnreq);
 679
 680                 return tmp;
 681             }
 682
 683             if (target)
 684                 *target = TRUE;
 685
 686             n = find_elements(doc, tmp->children, nnreq, error, NULL, found_fn,
 687                     not_found_fn, is_list_command, recursion_depth, data);
 688
 689             if (*(p+1)) {
 690                 gchar **zz = p+1, **qq = nnreq;
 691
 692                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 693                     qq = nnreq+1;
 694
 695                 for (; *qq && *zz; zz++) {
 696                     g_free(*zz);
 697                     *zz = g_strdup(*qq++);
 698
 699                     if (!*zz) {
 700                         *error = gpg_error_from_errno(ENOMEM);
 701                         n = NULL;
 702                         break;
 703                     }
 704                 }
 705             }
 706
 707             g_strfreev(nnreq);
 708             return n;
 709         }
 710     }
 711
 712     return n;
 713 }
 714
 715 gboolean node_has_child_element(xmlNodePtr node)
 716 {
 717     xmlNodePtr n;
 718
 719     if (!node)
 720         return FALSE;
 721
 722     for (n = node; n; n = n->next) {
 723         if (n->type == XML_ELEMENT_NODE)
 724             return TRUE;
 725
 726         if (n->children)
 727             return node_has_child_element(n->children);
 728     }
 729
 730     return FALSE;
 731 }