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, t;
 164     GSList *list = NULL;
 165     gint total, i;
 166     GString *string;
 167
 168     for (t = doc->children; t; t = t->next) {
 169         if (t->type == XML_ELEMENT_NODE) {
 170             if (xmlStrEqual(t->name, (xmlChar *)"accounts")) {
 171                 n = t;
 172                 break;
 173             }
 174         }
 175     }
 176
 177     if (!n || !n->children)
 178         return EPWMD_EMPTY_ELEMENT;
 179
 180     for (n = n->children; n; n = n->next) {
 181         xmlAttrPtr a;
 182         gchar *tmp;
 183         GSList *tlist;
 184
 185         if (n->type != XML_ELEMENT_NODE)
 186             continue;
 187
 188         a = xmlHasProp(n, (xmlChar *)"name");
 189
 190         if (!a || !a->children->content)
 191             continue;
 192
 193         tmp = g_strdup((gchar *)a->children->content);
 194
 195         if (!tmp) {
 196             g_slist_free(list);
 197             return gpg_error_from_errno(ENOMEM);
 198         }
 199
 200         tlist = g_slist_append(list, tmp);
 201
 202         if (!tlist) {
 203             g_slist_free(list);
 204             return gpg_error_from_errno(ENOMEM);
 205         }
 206
 207         list = tlist;
 208     }
 209
 210     total = g_slist_length(list);
 211
 212     if (!total)
 213         return EPWMD_EMPTY_ELEMENT;
 214
 215     string = g_string_new(NULL);
 216
 217     if (!string) {
 218         g_slist_free(list);
 219         return gpg_error_from_errno(ENOMEM);
 220     }
 221
 222     for (i = 0; i < total; i++) {
 223         gchar *tmp = g_slist_nth_data(list, i);
 224
 225         g_string_append_printf(string, "%s\n", tmp);
 226         g_free(tmp);
 227     }
 228
 229     string = g_string_truncate(string, string->len - 1);
 230     g_slist_free(list);
 231     *result = string;
 232     return 0;
 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             is_literal_element(&req[i]);
 313             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 314
 315             if (!n) {
 316                 *error = gpg_error_from_errno(ENOMEM);
 317                 return NULL;
 318             }
 319
 320             node = xmlAddChild(node, n);
 321
 322             if (!node) {
 323                 *error = gpg_error_from_errno(ENOMEM);
 324                 return NULL;
 325             }
 326         }
 327         else
 328             node = n;
 329     }
 330
 331     return node;
 332 }
 333
 334 xmlNodePtr find_text_node(xmlNodePtr node)
 335 {
 336     xmlNodePtr n = node;
 337
 338     if (n && n->type == XML_TEXT_NODE)
 339         return n;
 340
 341     for (n = node; n; n = n->next) {
 342         if (n->type == XML_TEXT_NODE)
 343             return n;
 344     }
 345
 346     return NULL;
 347 }
 348
 349 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 350         gpg_error_t *error, void *data)
 351 {
 352     gint i;
 353     gchar **req = elements;
 354
 355     if (node->type == XML_TEXT_NODE)
 356         node = node->parent;
 357
 358     if (node->name && xmlStrEqual(node->name, (xmlChar *)*req))
 359         req++;
 360
 361     for (i = 0; req[i]; i++) {
 362         xmlNodePtr n;
 363
 364         if (req[i+1]) {
 365             /*
 366              * Strip the first '!' if needed. If there's another, it's an
 367              * error. The syntax has already been checked before calling this
 368              * function.
 369              */
 370             is_literal_element(&req[i]);
 371         }
 372
 373         /*
 374          * The value of the element tree.
 375          */
 376         if (!req[i+1]) {
 377             n = find_text_node(node->children);
 378
 379             if (!n)
 380                 /* Use AddContent here to prevent overwriting any children. */
 381                 xmlNodeAddContent(node, (xmlChar *)req[i]);
 382             else if (n && !*req[i])
 383                 xmlNodeSetContent(n, NULL);
 384             else
 385                 xmlNodeSetContent(n, (xmlChar *)req[i]);
 386
 387             break;
 388         }
 389
 390         n = find_element(node, req[i], find_stop_node(node));
 391
 392         if (!n) {
 393             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 394
 395             if (!n) {
 396                 *error = gpg_error_from_errno(ENOMEM);
 397                 return NULL;
 398             }
 399
 400             node = xmlAddChild(node, n);
 401
 402             if (!node) {
 403                 *error = gpg_error_from_errno(ENOMEM);
 404                 return NULL;
 405             }
 406         }
 407         else
 408             node = n;
 409     }
 410
 411     return node;
 412 }
 413
 414 xmlNodePtr find_account(xmlDocPtr doc, gchar ***req, gpg_error_t *error,
 415         gboolean *target, gint recursion_depth)
 416 {
 417     xmlNodePtr n;
 418     gint depth = 0;
 419     gchar *account = g_strdup(*req[0]);
 420     gboolean literal = is_literal_element(&account);
 421
 422     if (!account) {
 423         *error = gpg_error_from_errno(ENOMEM);
 424         return NULL;
 425     }
 426
 427     *error = 0;
 428     recursion_depth++;
 429
 430     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 431         *error = EPWMD_LOOP;
 432         return NULL;
 433     }
 434
 435     for (n = doc->children; n;) {
 436         if (n->type == XML_ELEMENT_NODE) {
 437             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"accounts")) {
 438                 n = n->children;
 439                 depth++;
 440                 continue;
 441             }
 442
 443             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"account")) {
 444                 xmlChar *content = node_has_attribute(n, (xmlChar *)"name");
 445
 446                 if (!content)
 447                     continue;
 448
 449                 if (xmlStrEqual(content, (xmlChar *)account)) {
 450                     gchar **nreq, **tmp = NULL;
 451
 452                     if (literal == TRUE) {
 453                         g_free(account);
 454                         return n;
 455                     }
 456
 457                     content = node_has_attribute(n, (xmlChar *)"target");
 458
 459                     if (!content) {
 460                         g_free(account);
 461                         return n;
 462                     }
 463
 464                     if (strchr((gchar *)content, '\t')) {
 465                         nreq = split_input_line((gchar *)content, "\t", 0);
 466
 467 #if 0
 468                         /*
 469                          * FIXME ENOMEM
 470                          */
 471                         if (!nreq) {
 472                             *error = gpg_error_from_errno(ENOMEM);
 473                             return NULL;
 474                         }
 475 #endif
 476
 477                         tmp = *req;
 478                         tmp = append_element_path(nreq, tmp+1);
 479                         g_strfreev(nreq);
 480
 481                         if (!tmp) {
 482                             *error = gpg_error_from_errno(ENOMEM);
 483                             return NULL;
 484                         }
 485
 486                         g_strfreev(*req);
 487                         *req = tmp;
 488                     }
 489                     else {
 490                         if (strv_printf(&tmp, "%s", content) == FALSE) {
 491                             *error = gpg_error_from_errno(ENOMEM);
 492                             return NULL;
 493                         }
 494
 495                         nreq = *req;
 496                         nreq = append_element_path(tmp, nreq+1);
 497                         g_strfreev(tmp);
 498
 499                         if (!nreq) {
 500                             *error = gpg_error_from_errno(ENOMEM);
 501                             return NULL;
 502                         }
 503
 504                         g_strfreev(*req);
 505                         *req = nreq;
 506                     }
 507
 508                     if (target)
 509                         *target = TRUE;
 510
 511                     g_free(account);
 512                     n = find_account(doc, req, error, target, recursion_depth);
 513                     return n;
 514                 }
 515             }
 516         }
 517
 518         n = n->next;
 519     }
 520
 521     g_free(account);
 522     *error = EPWMD_ELEMENT_NOT_FOUND;
 523     return NULL;
 524 }
 525
 526 xmlNodePtr find_sibling(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 527 {
 528     xmlNodePtr n;
 529
 530     if (!node || !element)
 531         return NULL;
 532
 533     for (n = node; n; n = n->next) {
 534         if (n->type != XML_ELEMENT_NODE)
 535             continue;
 536
 537         if (n == stop)
 538             break;
 539
 540         if (xmlStrEqual(n->name, (xmlChar *)element))
 541             return n;
 542     }
 543
 544     return NULL;
 545 }
 546
 547 xmlNodePtr find_element(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 548 {
 549     if (!node || !element)
 550         return NULL;
 551
 552     return find_sibling(node, element, stop);
 553 }
 554
 555 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 556 {
 557     xmlAttrPtr a = xmlHasProp(n, attr);
 558
 559     if (!a)
 560         return NULL;
 561
 562     if (!a->children || !a->children->content)
 563         return NULL;
 564
 565     return a->children->content;
 566 }
 567
 568 static gboolean element_to_literal(gchar **element)
 569 {
 570     gchar *p = g_strdup_printf("!%s", *element);
 571
 572     if (!p)
 573         return FALSE;
 574
 575     g_free(*element);
 576     *element = p;
 577     return TRUE;
 578 }
 579
 580 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 581         gchar **req, gpg_error_t *error, gboolean *target,
 582         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 583         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 584         gboolean is_list_command, gint recursion_depth, void *data)
 585 {
 586     xmlNodePtr n, last, last_node;
 587     gchar **p;
 588     gint found = 0;
 589
 590     *error = 0;
 591     recursion_depth++;
 592
 593     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 594         recursion_depth--;
 595         *error = EPWMD_LOOP;
 596         return NULL;
 597     }
 598
 599     for (last_node = last = n = node, p = req; *p; p++) {
 600         xmlNodePtr tmp;
 601         gchar *t = g_strdup(*p);
 602         gboolean literal;
 603
 604         if (!t) {
 605             *error = gpg_error_from_errno(ENOMEM);
 606             return NULL;
 607         }
 608
 609         literal = is_literal_element(&t);
 610         n = find_element(last, t, NULL);
 611         g_free(t);
 612
 613         if (!n) {
 614             if (not_found_fn)
 615                 return not_found_fn(found ? last_node : last_node->parent, p, error, data);
 616
 617             *error = EPWMD_ELEMENT_NOT_FOUND;
 618             return NULL;
 619         }
 620
 621         last = n->children;
 622         last_node = n;
 623         found = 1;
 624
 625         if (literal == FALSE) {
 626             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
 627             gchar **nreq = NULL, **nnreq;
 628
 629             if (!content) {
 630                 if (is_list_command == TRUE) {
 631                     if (element_to_literal(&(*p)) == FALSE) {
 632                         *error = gpg_error_from_errno(ENOMEM);
 633                         return NULL;
 634                     }
 635                 }
 636
 637                 continue;
 638             }
 639
 640             if (strchr((gchar *)content, '\t') != NULL) {
 641                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 642                     *error = EPWMD_INVALID_ELEMENT;
 643                     return NULL;
 644                 }
 645             }
 646             else {
 647                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 648                     *error = EPWMD_INVALID_ELEMENT;
 649                     return NULL;
 650                 }
 651             }
 652
 653             tmp = find_account(doc, &nreq, error, target, 0);
 654
 655             if (!tmp) {
 656                 g_strfreev(nreq);
 657                 return NULL;
 658             }
 659
 660             if (found_fn)
 661                 found_fn(n, nreq, error, data);
 662
 663             nnreq = append_element_path(nreq+1, p+1);
 664             g_strfreev(nreq);
 665
 666             // FIXME ENOMEM
 667             if (!nnreq || !*nnreq) {
 668                 if (nnreq)
 669                     g_strfreev(nnreq);
 670
 671                 return tmp;
 672             }
 673
 674             if (target)
 675                 *target = TRUE;
 676
 677             n = find_elements(doc, tmp->children, nnreq, error, NULL, found_fn,
 678                     not_found_fn, is_list_command, recursion_depth, data);
 679
 680             if (*(p+1)) {
 681                 gchar **zz = p+1, **qq = nnreq;
 682
 683                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 684                     qq = nnreq+1;
 685
 686                 for (; *qq && *zz; zz++) {
 687                     g_free(*zz);
 688                     *zz = g_strdup(*qq++);
 689
 690                     if (!*zz) {
 691                         *error = gpg_error_from_errno(ENOMEM);
 692                         n = NULL;
 693                         break;
 694                     }
 695                 }
 696             }
 697
 698             g_strfreev(nnreq);
 699             return n;
 700         }
 701     }
 702
 703     return n;
 704 }
 705
 706 gboolean node_has_child_element(xmlNodePtr node)
 707 {
 708     xmlNodePtr n;
 709
 710     if (!node)
 711         return FALSE;
 712
 713     for (n = node; n; n = n->next) {
 714         if (n->type == XML_ELEMENT_NODE)
 715             return TRUE;
 716
 717         if (n->children)
 718             return node_has_child_element(n->children);
 719     }
 720
 721     return FALSE;
 722 }