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 /*
 284  * Alot like create_elements_cb() but doesn't use the last element of 'req' as
 285  * content but as an element.
 286  */
 287 xmlNodePtr create_target_elements_cb(xmlNodePtr node, gchar **path,
 288         gpg_error_t *error, void *data)
 289 {
 290     gint i;
 291     char **req = path;
 292
 293     if (xmlStrEqual(node->name, (xmlChar *)*req))
 294         req++;
 295
 296     for (i = 0; req[i]; i++) {
 297         xmlNodePtr n;
 298
 299         if ((n = find_element(node, req[i])) == NULL) {
 300             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 301
 302             if (!n) {
 303                 *error = gpg_error_from_errno(ENOMEM);
 304                 return NULL;
 305             }
 306
 307             node = xmlAddChild(node, n);
 308
 309             if (!node) {
 310                 *error = gpg_error_from_errno(ENOMEM);
 311                 return NULL;
 312             }
 313         }
 314         else
 315             node = n;
 316     }
 317
 318     return node;
 319 }
 320
 321 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 322         gpg_error_t *error, void *data)
 323 {
 324     gint i;
 325     gchar **req = elements;
 326
 327     if (node->type == XML_TEXT_NODE)
 328         node = node->parent;
 329
 330     if (node->name && xmlStrEqual(node->name, (xmlChar *)*req))
 331         req++;
 332
 333     for (i = 0; req[i]; i++) {
 334         xmlNodePtr n;
 335
 336         if (req[i+1]) {
 337             /*
 338              * Strip the first '!' if needed. If there's another, it's an
 339              * error. The syntax has already been checked before calling this
 340              * function.
 341              */
 342             is_literal_element(&req[i]);
 343         }
 344
 345         /*
 346          * The value of the element tree.
 347          */
 348         if (!req[i+1]) {
 349             if (node->children) {
 350                 n = node->children->next ? xmlCopyNode(node->children->next, 1) :
 351                     xmlCopyNode(node->children, 1);
 352
 353                 if (!n) {
 354                     *error = gpg_error_from_errno(ENOMEM);
 355                     return NULL;
 356                 }
 357
 358                 if (n->content) {
 359                     xmlFree(n->content);
 360                     n->content = NULL;
 361                 }
 362             }
 363             else
 364                 n = NULL;
 365
 366             if (req[i])
 367                 xmlNodeSetContent(node, (xmlChar *)req[i]);
 368             else if (node->content) {
 369                 xmlFree(node->content);
 370                 node->content = NULL;
 371             }
 372
 373             if (n) {
 374                 if (!xmlAddChild(node, n)) {
 375                     *error = gpg_error_from_errno(ENOMEM);
 376                     return NULL;
 377                 }
 378             }
 379
 380             break;
 381         }
 382
 383         n = find_element(node, req[i]);
 384
 385         if (!n) {
 386             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 387
 388             if (!n) {
 389                 *error = gpg_error_from_errno(ENOMEM);
 390                 return NULL;
 391             }
 392
 393             node = xmlAddChild(node, n);
 394
 395             if (!node) {
 396                 *error = gpg_error_from_errno(ENOMEM);
 397                 return NULL;
 398             }
 399         }
 400         else
 401             node = n;
 402     }
 403
 404     return node;
 405 }
 406
 407 xmlNodePtr find_account(xmlDocPtr doc, gchar ***req, gpg_error_t *error,
 408         gboolean *target, gint recursion_depth)
 409 {
 410     xmlNodePtr n;
 411     gint depth = 0;
 412     gchar *account = g_strdup(*req[0]);
 413     gboolean literal = is_literal_element(&account);
 414
 415     if (!account) {
 416         *error = gpg_error_from_errno(ENOMEM);
 417         return NULL;
 418     }
 419
 420     *error = 0;
 421     recursion_depth++;
 422
 423     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 424         *error = EPWMD_LOOP;
 425         return NULL;
 426     }
 427
 428     for (n = doc->children; n;) {
 429         if (n->type == XML_ELEMENT_NODE) {
 430             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"accounts")) {
 431                 n = n->children;
 432                 depth++;
 433                 continue;
 434             }
 435
 436             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"account")) {
 437                 xmlChar *content = node_has_attribute(n, (xmlChar *)"name");
 438
 439                 if (!content)
 440                     continue;
 441
 442                 if (xmlStrEqual(content, (xmlChar *)account)) {
 443                     gchar **nreq, **tmp = NULL;
 444
 445                     if (literal == TRUE) {
 446                         g_free(account);
 447                         return n;
 448                     }
 449
 450                     content = node_has_attribute(n, (xmlChar *)"target");
 451
 452                     if (!content) {
 453                         g_free(account);
 454                         return n;
 455                     }
 456
 457                     if (strchr((gchar *)content, '\t')) {
 458                         nreq = split_input_line((gchar *)content, "\t", 0);
 459
 460 #if 0
 461                         /*
 462                          * FIXME ENOMEM
 463                          */
 464                         if (!nreq) {
 465                             *error = gpg_error_from_errno(ENOMEM);
 466                             return NULL;
 467                         }
 468 #endif
 469
 470                         tmp = *req;
 471                         tmp = append_element_path(nreq, tmp+1);
 472                         g_strfreev(nreq);
 473
 474                         if (!tmp) {
 475                             *error = gpg_error_from_errno(ENOMEM);
 476                             return NULL;
 477                         }
 478
 479                         g_strfreev(*req);
 480                         *req = tmp;
 481                     }
 482                     else {
 483                         if (strv_printf(&tmp, "%s", content) == FALSE) {
 484                             *error = gpg_error_from_errno(ENOMEM);
 485                             return NULL;
 486                         }
 487
 488                         nreq = *req;
 489                         nreq = append_element_path(tmp, nreq+1);
 490                         g_strfreev(tmp);
 491
 492                         if (!nreq) {
 493                             *error = gpg_error_from_errno(ENOMEM);
 494                             return NULL;
 495                         }
 496
 497                         g_strfreev(*req);
 498                         *req = nreq;
 499                     }
 500
 501                     if (target)
 502                         *target = TRUE;
 503
 504                     g_free(account);
 505                     n = find_account(doc, req, error, target, recursion_depth);
 506                     return n;
 507                 }
 508             }
 509         }
 510
 511         n = n->next;
 512     }
 513
 514     g_free(account);
 515     *error = EPWMD_ELEMENT_NOT_FOUND;
 516     return NULL;
 517 }
 518
 519 xmlNodePtr find_sibling(xmlNodePtr node, gchar *element)
 520 {
 521     xmlNodePtr n;
 522
 523     if (!node || !element)
 524         return NULL;
 525
 526     for (n = node; n; n = n->next) {
 527         if (n->type != XML_ELEMENT_NODE)
 528             continue;
 529
 530         if (xmlStrEqual(n->name, (xmlChar *)element))
 531             return n;
 532     }
 533
 534     return NULL;
 535 }
 536
 537 xmlNodePtr find_element(xmlNodePtr node, gchar *element)
 538 {
 539     if (!node || !element)
 540         return NULL;
 541
 542     return find_sibling(node, element);
 543 }
 544
 545 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 546 {
 547     xmlAttrPtr a = xmlHasProp(n, attr);
 548
 549     if (!a)
 550         return NULL;
 551
 552     if (!a->children || !a->children->content)
 553         return NULL;
 554
 555     return a->children->content;
 556 }
 557
 558 static gboolean element_to_literal(gchar **element)
 559 {
 560     gchar *p = g_strdup_printf("!%s", *element);
 561
 562     if (!p)
 563         return FALSE;
 564
 565     g_free(*element);
 566     *element = p;
 567     return TRUE;
 568 }
 569
 570 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 571         gchar **req, gpg_error_t *error, gboolean *target,
 572         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 573         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 574         gboolean is_list_command, gint recursion_depth, void *data)
 575 {
 576     xmlNodePtr n, last, last_node;
 577     gchar **p;
 578     gint found = 0;
 579
 580     *error = 0;
 581     recursion_depth++;
 582
 583     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 584         recursion_depth--;
 585         *error = EPWMD_LOOP;
 586         return NULL;
 587     }
 588
 589     for (last_node = last = n = node, p = req; *p; p++) {
 590         xmlNodePtr tmp;
 591         gchar *t = g_strdup(*p);
 592         gboolean literal;
 593
 594         if (!t) {
 595             *error = gpg_error_from_errno(ENOMEM);
 596             return NULL;
 597         }
 598
 599         literal = is_literal_element(&t);
 600         n = find_element(last, t);
 601         g_free(t);
 602
 603         if (!n) {
 604             if (not_found_fn)
 605                 return not_found_fn(found ? last_node : last_node->parent, p, error, data);
 606
 607             *error = EPWMD_ELEMENT_NOT_FOUND;
 608             return NULL;
 609         }
 610
 611         last = n->children;
 612         last_node = n;
 613         found = 1;
 614
 615         if (literal == FALSE) {
 616             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
 617             gchar **nreq = NULL, **nnreq;
 618
 619             if (!content) {
 620                 if (is_list_command == TRUE) {
 621                     if (element_to_literal(&(*p)) == FALSE) {
 622                         *error = gpg_error_from_errno(ENOMEM);
 623                         return NULL;
 624                     }
 625                 }
 626
 627                 continue;
 628             }
 629
 630             if (strchr((gchar *)content, '\t') != NULL) {
 631                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 632                     *error = EPWMD_INVALID_ELEMENT;
 633                     return NULL;
 634                 }
 635             }
 636             else {
 637                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 638                     *error = EPWMD_INVALID_ELEMENT;
 639                     return NULL;
 640                 }
 641             }
 642
 643             tmp = find_account(doc, &nreq, error, target, 0);
 644
 645             if (!tmp) {
 646                 g_strfreev(nreq);
 647                 return NULL;
 648             }
 649
 650             if (found_fn)
 651                 found_fn(n, nreq, error, data);
 652
 653             nnreq = append_element_path(nreq+1, p+1);
 654             g_strfreev(nreq);
 655
 656             // FIXME ENOMEM
 657             if (!nnreq || !*nnreq) {
 658                 if (nnreq)
 659                     g_strfreev(nnreq);
 660
 661                 return tmp;
 662             }
 663
 664             if (target)
 665                 *target = TRUE;
 666
 667             n = find_elements(doc, tmp->children, nnreq, error, NULL, found_fn,
 668                     not_found_fn, is_list_command, recursion_depth, data);
 669
 670             if (*(p+1)) {
 671                 gchar **zz = p+1, **qq = nnreq;
 672
 673                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 674                     qq = nnreq+1;
 675
 676                 for (; *qq && *zz; zz++) {
 677                     g_free(*zz);
 678                     *zz = g_strdup(*qq++);
 679
 680                     if (!*zz) {
 681                         *error = gpg_error_from_errno(ENOMEM);
 682                         n = NULL;
 683                         break;
 684                     }
 685                 }
 686             }
 687
 688             g_strfreev(nnreq);
 689             return n;
 690         }
 691     }
 692
 693     return n;
 694 }
 695
 696 gboolean node_has_child_element(xmlNodePtr node)
 697 {
 698     xmlNodePtr n;
 699
 700     if (!node)
 701         return FALSE;
 702
 703     for (n = node; n; n = n->next) {
 704         if (n->type == XML_ELEMENT_NODE)
 705             return TRUE;
 706
 707         if (n->children)
 708             return node_has_child_element(n->children);
 709     }
 710
 711     return FALSE;
 712 }