src/xml.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2010 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  02110-1301  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 #include <libxml/xmlwriter.h>
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35
  36 #include "pwmd_error.h"
  37 #include "misc.h"
  38 #include "xml.h"
  39
  40 static xmlNodePtr find_element(xmlNodePtr node, gchar *element, xmlNodePtr stop);
  41
  42 /*
  43  * 'element' must be allocated.
  44  */
  45 gboolean is_literal_element(gchar **element)
  46 {
  47     gchar *p;
  48
  49     if (!element || !*element)
  50         return FALSE;
  51
  52     if (*(*element) == '!') {
  53         gchar *c;
  54
  55         for (p = *element, c = p+1; *c; c++)
  56             *p++ = *c;
  57
  58         *p = 0;
  59         return TRUE;
  60     }
  61
  62     return FALSE;
  63 }
  64
  65 /*
  66  * Fails if 'element' begins with punctuation or digit or contains whitespace.
  67  *
  68  * I'm not sure about using g_unichar_isspace() rather than isspace()?
  69  */
  70 gboolean valid_xml_element(xmlChar *element)
  71 {
  72     gunichar c;
  73     glong len;
  74     gchar *p = (gchar *)element;
  75
  76     if (!element || !*element)
  77         return FALSE;
  78
  79     len = g_utf8_strlen(p, -1) - 1;
  80     c = g_utf8_get_char(p++);
  81
  82     if (g_unichar_ispunct(c) == TRUE || g_unichar_isdigit(c) == TRUE ||
  83             g_unichar_isspace(c) == TRUE)
  84         return FALSE;
  85
  86     while (*p && len--) {
  87         c = g_utf8_get_char(p++);
  88
  89         if (g_unichar_isspace(c))
  90             return FALSE;
  91     }
  92
  93     return TRUE;
  94 }
  95
  96 gpg_error_t new_root_element(xmlDocPtr doc, gchar *name)
  97 {
  98     xmlNodePtr root = xmlDocGetRootElement(doc);
  99     xmlAttrPtr a;
 100     xmlNodePtr n;
 101     gchar *p = name;
 102
 103     if (!p || !root)
 104         return EPWMD_LIBXML_ERROR;
 105
 106     if (*p == '!')
 107         p++;
 108
 109     if (!valid_xml_element((xmlChar *)p))
 110         return EPWMD_INVALID_ELEMENT;
 111
 112     n = xmlNewNode(NULL, (xmlChar *)"root");
 113     n = xmlAddChild(root, n);
 114     a = xmlNewProp(n, (xmlChar *)"name", (xmlChar *)p);
 115     return 0;
 116 }
 117
 118 xmlDocPtr create_dtd()
 119 {
 120     xmlDocPtr doc;
 121     xmlTextWriterPtr wr = xmlNewTextWriterDoc(&doc, 0);
 122
 123     if (!wr)
 124         return NULL;
 125
 126     if (xmlTextWriterStartDocument(wr, NULL, NULL, NULL))
 127         goto fail;
 128
 129     if (xmlTextWriterStartDTD(wr, (xmlChar *)"pwmd", NULL, NULL) == -1)
 130         goto fail;
 131
 132     if (xmlTextWriterWriteDTDElement(wr, (xmlChar *)"pwmd",
 133                 (xmlChar *)"(root)") == -1)
 134         goto fail;
 135
 136     xmlTextWriterEndDTDElement(wr);
 137
 138     if (xmlTextWriterWriteDTDAttlist(wr, (xmlChar *)"root",
 139             (xmlChar *)"name CDATA #REQUIRED") == -1)
 140         goto fail;
 141
 142     xmlTextWriterEndDTDAttlist(wr);
 143     xmlTextWriterEndDTD(wr);
 144
 145     if (xmlTextWriterStartElement(wr, (xmlChar *)"pwmd"))
 146         goto fail;
 147
 148     xmlTextWriterEndElement(wr);
 149     xmlTextWriterEndDocument(wr);
 150     xmlFreeTextWriter(wr);
 151     return doc;
 152
 153 fail:
 154     xmlTextWriterEndDocument(wr);
 155     xmlFreeTextWriter(wr);
 156     xmlFreeDoc(doc);
 157     return NULL;
 158 }
 159
 160 xmlChar *new_document()
 161 {
 162     xmlChar *xml;
 163     gint len;
 164     xmlDocPtr doc = create_dtd();
 165
 166     if (!doc)
 167         return NULL;
 168
 169     xmlDocDumpMemory(doc, &xml, &len);
 170     xmlFreeDoc(doc);
 171     return xml;
 172 }
 173
 174 /*
 175  * Lists root element names; the value of the attribute "name" of an element
 176  * "root". If there's a target attribute both literal and non-literal element
 177  * names will be added. This is the primary reason why XML entities cannot be
 178  * used. There wouldn't be a way to get the literal an non-literal element
 179  * paths.
 180  */
 181 gpg_error_t list_root_elements(xmlDocPtr doc, GString **result)
 182 {
 183     xmlNodePtr n = NULL;
 184     GSList *list = NULL;
 185     gint total, i;
 186     GString *string;
 187     gpg_error_t rc = 0;
 188
 189     n = xmlDocGetRootElement(doc);
 190
 191     if (!n || !n->children)
 192         return EPWMD_EMPTY_ELEMENT;
 193
 194     for (n = n->children; n; n = n->next) {
 195         xmlAttrPtr a;
 196         xmlChar *val, *target;
 197         GSList *tlist;
 198         gchar *tmp;
 199
 200         if (n->type != XML_ELEMENT_NODE)
 201             continue;
 202
 203         a = xmlHasProp(n, (xmlChar *)"name");
 204
 205         if (!a || !a->children->content)
 206             continue;
 207
 208         val = xmlNodeGetContent(a->children);
 209
 210         if (!val) {
 211             rc = gpg_error_from_errno(ENOMEM);
 212             goto fail;
 213         }
 214
 215         tmp = g_strdup_printf("!%s", (gchar *)val);
 216
 217         if (!tmp) {
 218             xmlFree(val);
 219             rc = gpg_error_from_errno(ENOMEM);
 220             goto fail;
 221         }
 222
 223         tlist = g_slist_append(list, tmp);
 224
 225         if (!tlist) {
 226             xmlFree(val);
 227             rc = gpg_error_from_errno(ENOMEM);
 228             goto fail;
 229         }
 230
 231         list = tlist;
 232         target = node_has_attribute(n, (xmlChar *)"target");
 233
 234         if (target) {
 235             gchar *t = g_strdup((gchar *)val);
 236
 237             if (!t) {
 238                 xmlFree(val);
 239                 xmlFree(target);
 240                 rc = gpg_error_from_errno(ENOMEM);
 241                 goto fail;
 242             }
 243
 244             tlist = g_slist_append(list, t);
 245
 246             if (!tlist) {
 247                 g_free(t);
 248                 xmlFree(target);
 249                 rc = gpg_error_from_errno(ENOMEM);
 250                 goto fail;
 251             }
 252
 253             list = tlist;
 254         }
 255
 256         xmlFree(val);
 257         xmlFree(target);
 258     }
 259
 260     total = g_slist_length(list);
 261
 262     if (!total)
 263         return EPWMD_EMPTY_ELEMENT;
 264
 265     string = g_string_new(NULL);
 266
 267     if (!string) {
 268         rc = gpg_error_from_errno(ENOMEM);
 269         goto fail;
 270     }
 271
 272     for (i = 0; i < total; i++) {
 273         gchar *val = g_slist_nth_data(list, i);
 274
 275         g_string_append_printf(string, "%s\n", val);
 276     }
 277
 278     string = g_string_truncate(string, string->len - 1);
 279     *result = string;
 280
 281 fail:
 282     total = g_slist_length(list);
 283
 284     for (i = 0; i < total; i++)
 285         g_free(g_slist_nth_data(list, i));
 286
 287     g_slist_free(list);
 288     return rc;
 289 }
 290
 291 /*
 292  * Prevents a sibling element past the current element path with the same
 293  * element name.
 294  */
 295 static xmlNodePtr find_stop_node(xmlNodePtr node)
 296 {
 297     xmlNodePtr n;
 298
 299     for (n = node->parent->children; n; n = n->next) {
 300         if (n == node)
 301             return n->next;
 302     }
 303
 304     return NULL;
 305 }
 306
 307 /*
 308  * Alot like create_elements_cb() but doesn't use the last element of 'req' as
 309  * content but as an element.
 310  */
 311 xmlNodePtr create_target_elements_cb(xmlNodePtr node, gchar **path,
 312         gpg_error_t *rc, void *data)
 313 {
 314     gint i;
 315     char **req = path;
 316
 317     if (xmlStrEqual(node->name, (xmlChar *)*req))
 318         req++;
 319
 320     for (i = 0; req[i]; i++) {
 321         xmlNodePtr n;
 322
 323         if ((n = find_element(node, req[i], find_stop_node(node))) == NULL ||
 324                 (n && n->parent == node->parent)) {
 325             is_literal_element(&req[i]);
 326
 327             if (!valid_xml_element((xmlChar *)req[i])) {
 328                 *rc = EPWMD_INVALID_ELEMENT;
 329                 return NULL;
 330             }
 331
 332             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 333
 334             if (!n) {
 335                 *rc = gpg_error_from_errno(ENOMEM);
 336                 return NULL;
 337             }
 338
 339             node = xmlAddChild(node, n);
 340
 341             if (!node) {
 342                 *rc = gpg_error_from_errno(ENOMEM);
 343                 return NULL;
 344             }
 345         }
 346         else
 347             node = n;
 348     }
 349
 350     return node;
 351 }
 352
 353 xmlNodePtr find_text_node(xmlNodePtr node)
 354 {
 355     xmlNodePtr n = node;
 356
 357     if (n && n->type == XML_TEXT_NODE)
 358         return n;
 359
 360     for (n = node; n; n = n->next) {
 361         if (n->type == XML_TEXT_NODE)
 362             return n;
 363     }
 364
 365     return NULL;
 366 }
 367
 368 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 369         gpg_error_t *rc, void *data)
 370 {
 371     gint i;
 372     gchar **req = elements;
 373
 374     if (node->type == XML_TEXT_NODE)
 375         node = node->parent;
 376
 377     if (node->name && xmlStrEqual(node->name, (xmlChar *)*req))
 378         req++;
 379
 380     for (i = 0; req[i]; i++) {
 381         xmlNodePtr n;
 382
 383         if (req[i+1]) {
 384             /*
 385              * Strip the first '!' if needed. If there's another, it's an
 386              * rc. The syntax has already been checked before calling this
 387              * function.
 388              */
 389             is_literal_element(&req[i]);
 390         }
 391
 392         /*
 393          * The value of the element tree.
 394          */
 395         if (!req[i+1]) {
 396             n = find_text_node(node->children);
 397
 398             if (!n)
 399                 /* Use AddContent here to prevent overwriting any children. */
 400                 xmlNodeAddContent(node, (xmlChar *)req[i]);
 401             else if (n && !*req[i])
 402                 xmlNodeSetContent(n, NULL);
 403             else
 404                 xmlNodeSetContent(n, (xmlChar *)req[i]);
 405
 406             break;
 407         }
 408
 409         n = find_element(node, req[i], find_stop_node(node));
 410
 411         /*
 412          * If the found element has the same parent as the current element,
 413          * they are siblings and the new element needs to be created as a
 414          * child of the current element (node).
 415          */
 416         if (n && n->parent == node->parent)
 417             n = NULL;
 418
 419         if (!n) {
 420             if (!valid_xml_element((xmlChar *)req[i])) {
 421                 *rc = EPWMD_INVALID_ELEMENT;
 422                 return NULL;
 423             }
 424
 425             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 426
 427             if (!n) {
 428                 *rc = gpg_error_from_errno(ENOMEM);
 429                 return NULL;
 430             }
 431
 432             node = xmlAddChild(node, n);
 433
 434             if (!node) {
 435                 *rc = gpg_error_from_errno(ENOMEM);
 436                 return NULL;
 437             }
 438         }
 439         else
 440             node = n;
 441     }
 442
 443     return node;
 444 }
 445
 446 /* The root element is really req[0]. It is need as a pointer in case there is
 447  * a target attribute so it can be updated. */
 448 xmlNodePtr find_root_element(xmlDocPtr doc, gchar ***req, gpg_error_t *rc,
 449         gboolean *target, gint recursion_depth, gboolean stop)
 450 {
 451     xmlNodePtr n = xmlDocGetRootElement(doc);
 452     gint depth = 0;
 453     gchar *root = g_strdup(*req[0]);
 454     gboolean literal = is_literal_element(&root);
 455
 456     if (!root) {
 457         *rc = gpg_error_from_errno(ENOMEM);
 458         return NULL;
 459     }
 460
 461     *rc = 0;
 462     recursion_depth++;
 463
 464     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 465         xmlChar *t = xmlGetNodePath(n);
 466
 467         log_write("%s: %s", pwmd_strerror(EPWMD_LOOP), t);
 468         xmlFree(t);
 469         g_free(root);
 470         *rc = EPWMD_LOOP;
 471         return NULL;
 472     }
 473
 474     while (n) {
 475         if (n->type == XML_ELEMENT_NODE) {
 476             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"pwmd")) {
 477                 n = n->children;
 478                 depth++;
 479                 continue;
 480             }
 481
 482             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"root")) {
 483                 xmlChar *content = node_has_attribute(n, (xmlChar *)"name");
 484
 485                 if (!content)
 486                     continue;
 487
 488                 if (xmlStrEqual(content, (xmlChar *)root)) {
 489                     gchar **nreq, **tmp = NULL;
 490
 491                     if (literal == TRUE) {
 492                         xmlFree(content);
 493                         g_free(root);
 494                         return n;
 495                     }
 496
 497                     xmlFree(content);
 498                     content = node_has_attribute(n, (xmlChar *)"target");
 499
 500                     if (target)
 501                         *target = TRUE;
 502
 503                     if (!content || stop) {
 504                         if (content)
 505                             xmlFree(content);
 506
 507                         g_free(root);
 508                         return n;
 509                     }
 510
 511                     if (strchr((gchar *)content, '\t')) {
 512                         nreq = split_input_line((gchar *)content, "\t", 0);
 513                         xmlFree(content);
 514
 515 #if 0
 516                         /*
 517                          * FIXME ENOMEM
 518                          */
 519                         if (!nreq) {
 520                             *rc = gpg_error_from_errno(ENOMEM);
 521                             return NULL;
 522                         }
 523 #endif
 524
 525                         tmp = *req;
 526                         tmp = strvcatv(nreq, tmp+1);
 527                         g_strfreev(nreq);
 528
 529                         if (!tmp) {
 530                             g_free(root);
 531                             *rc = gpg_error_from_errno(ENOMEM);
 532                             return NULL;
 533                         }
 534
 535                         g_strfreev(*req);
 536                         *req = tmp;
 537                     }
 538                     else {
 539                         if (strv_printf(&tmp, "%s", content) == FALSE) {
 540                             xmlFree(content);
 541                             g_free(root);
 542                             *rc = gpg_error_from_errno(ENOMEM);
 543                             return NULL;
 544                         }
 545
 546                         xmlFree(content);
 547                         nreq = *req;
 548                         nreq = strvcatv(tmp, nreq+1);
 549                         g_strfreev(tmp);
 550
 551                         if (!nreq) {
 552                             *rc = gpg_error_from_errno(ENOMEM);
 553                             g_free(root);
 554                             return NULL;
 555                         }
 556
 557                         g_strfreev(*req);
 558                         *req = nreq;
 559                     }
 560
 561                     g_free(root);
 562                     n = find_root_element(doc, req, rc, target, recursion_depth, FALSE);
 563                     return n;
 564                 }
 565
 566                 xmlFree(content);
 567             }
 568         }
 569
 570         n = n->next;
 571     }
 572
 573     g_free(root);
 574     *rc = EPWMD_ELEMENT_NOT_FOUND;
 575     return NULL;
 576 }
 577
 578 static xmlNodePtr find_element(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 579 {
 580     xmlNodePtr n;
 581
 582     if (!node || !element)
 583         return NULL;
 584
 585     for (n = node; n; n = n->next) {
 586         if (n->type != XML_ELEMENT_NODE)
 587             continue;
 588
 589         if (n == stop)
 590             break;
 591
 592         if (xmlStrEqual(n->name, (xmlChar *)element))
 593             return n;
 594     }
 595
 596     return NULL;
 597 }
 598
 599 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 600 {
 601     xmlAttrPtr a = xmlHasProp(n, attr);
 602
 603     if (!a)
 604         return NULL;
 605
 606     if (!a->children || !a->children->content)
 607         return NULL;
 608
 609     return xmlGetProp(n, attr);
 610 }
 611
 612 static gboolean element_to_literal(gchar **element)
 613 {
 614     gchar *p = g_strdup_printf("!%s", *element);
 615
 616     if (!p)
 617         return FALSE;
 618
 619     g_free(*element);
 620     *element = p;
 621     return TRUE;
 622 }
 623
 624 /* Resolves elements in 'req' one at a time. It's recursive in case of
 625  * "target" attributes. */
 626 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 627         gchar **req, gpg_error_t *rc, gboolean *target,
 628         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, gchar **, void *),
 629         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 630         gboolean is_list_command, gint recursion_depth, void *data, gboolean stop)
 631 {
 632     xmlNodePtr n, last, last_node;
 633     gchar **p;
 634     gint found = 0;
 635
 636     *rc = 0;
 637     recursion_depth++;
 638
 639     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 640         xmlChar *t = xmlGetNodePath(node);
 641
 642         log_write("%s: %s", pwmd_strerror(EPWMD_LOOP), t);
 643         xmlFree(t);
 644         recursion_depth--;
 645         *rc = EPWMD_LOOP;
 646         return NULL;
 647     }
 648
 649     for (last_node = last = n = node, p = req; *p; p++) {
 650         xmlNodePtr tmp;
 651         gchar *t = g_strdup(*p);
 652         gboolean literal;
 653
 654         if (!t) {
 655             *rc = gpg_error_from_errno(ENOMEM);
 656             return NULL;
 657         }
 658
 659         literal = is_literal_element(&t);
 660         n = find_element(last, t, NULL);
 661         g_free(t);
 662
 663         if (!n) {
 664             if (not_found_fn)
 665                 return not_found_fn(found ? last_node : last_node->parent, p, rc, data);
 666
 667             *rc = EPWMD_ELEMENT_NOT_FOUND;
 668             return NULL;
 669         }
 670
 671         last = n->children;
 672         last_node = n;
 673         found = 1;
 674
 675         if (literal == FALSE) {
 676             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
 677             gchar **nreq = NULL, **nnreq;
 678
 679             if (!content) {
 680                 if (is_list_command == TRUE) {
 681                     if (element_to_literal(&(*p)) == FALSE) {
 682                         *rc = gpg_error_from_errno(ENOMEM);
 683                         return NULL;
 684                     }
 685                 }
 686
 687                 continue;
 688             }
 689
 690             if (target)
 691                 *target = TRUE;
 692
 693             if (!*(p+1) && stop) {
 694                 xmlFree(content);
 695                 return n;
 696             }
 697
 698             if (strchr((gchar *)content, '\t') != NULL) {
 699                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 700                     xmlFree(content);
 701                     *rc = EPWMD_INVALID_ELEMENT;
 702                     return NULL;
 703                 }
 704             }
 705             else {
 706                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 707                     xmlFree(content);
 708                     *rc = EPWMD_INVALID_ELEMENT;
 709                     return NULL;
 710                 }
 711             }
 712
 713             xmlFree(content);
 714             tmp = find_root_element(doc, &nreq, rc, target, 0, FALSE);
 715
 716             if (!tmp) {
 717                 g_strfreev(nreq);
 718                 return NULL;
 719             }
 720
 721             if (found_fn) {
 722                 found_fn(tmp, nreq, rc, p+1, data);
 723
 724                 if (*rc) {
 725                     g_strfreev(nreq);
 726                     return NULL;
 727                 }
 728             }
 729
 730             nnreq = strvcatv(nreq+1, p+1);
 731             g_strfreev(nreq);
 732
 733             // FIXME ENOMEM
 734             if (!nnreq || !*nnreq) {
 735                 if (nnreq)
 736                     g_strfreev(nnreq);
 737
 738                 return tmp;
 739             }
 740
 741             n = find_elements(doc, tmp->children, nnreq, rc, NULL, found_fn,
 742                     not_found_fn, is_list_command, recursion_depth, data, stop);
 743
 744             if (*(p+1)) {
 745                 gchar **zz = p+1, **qq = nnreq;
 746
 747                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 748                     qq = nnreq+1;
 749
 750                 for (; *qq && *zz; zz++) {
 751                     g_free(*zz);
 752                     *zz = g_strdup(*qq++);
 753
 754                     if (!*zz) {
 755                         *rc = gpg_error_from_errno(ENOMEM);
 756                         n = NULL;
 757                         break;
 758                     }
 759                 }
 760             }
 761
 762             g_strfreev(nnreq);
 763             return n;
 764         }
 765     }
 766
 767     return n;
 768 }
 769
 770 static gboolean update_element_list(struct element_list_s *elements)
 771 {
 772     gchar *line;
 773     GSList *l;
 774
 775     if (!elements || !elements->elements)
 776         return TRUE;
 777
 778     line = g_strjoinv("\t", elements->elements);
 779
 780     if (!line)
 781         return FALSE;
 782
 783     g_strfreev(elements->elements);
 784     elements->elements = NULL;
 785     l = g_slist_append(elements->list, line);
 786
 787     if (!l)
 788         return FALSE;
 789
 790     elements->list = l;
 791     return TRUE;
 792 }
 793
 794 static gpg_error_t path_list_recurse(xmlDocPtr doc, xmlNodePtr node,
 795         struct element_list_s *elements)
 796 {
 797     gpg_error_t rc = 0;
 798     xmlNodePtr n;
 799
 800     for (n = node; n; n = n->next) {
 801         xmlChar *target = NULL;
 802
 803         if (n->type != XML_ELEMENT_NODE)
 804             goto children;
 805
 806         if (strv_printf(&elements->elements, "%s\t!%s", elements->prefix, n->name) == FALSE)
 807             return gpg_err_code_from_errno(ENOMEM);
 808
 809         if (update_element_list(elements) == FALSE)
 810             return gpg_err_code_from_errno(ENOMEM);
 811
 812         target = node_has_attribute(n, (xmlChar *)"target");
 813
 814         if (target) {
 815             gchar *tmp;
 816             gchar *save = elements->prefix;
 817             gboolean r = elements->resolving;
 818
 819             elements->depth++;
 820
 821             if (max_recursion_depth >= 1 && elements->depth > max_recursion_depth) {
 822                 xmlChar *t = xmlGetNodePath(n);
 823                 log_write("%s: %s", pwmd_strerror(EPWMD_LOOP), t);
 824                 xmlFree(t);
 825                 xmlFree(target);
 826                 return EPWMD_LOOP;
 827             }
 828
 829             if (strv_printf(&elements->elements, "%s\t%s", elements->prefix, n->name) == FALSE) {
 830                 xmlFree(target);
 831                 return gpg_err_code_from_errno(ENOMEM);
 832             }
 833
 834             tmp = g_strjoinv("\t", elements->elements);
 835
 836             if (!tmp) {
 837                 xmlFree(target);
 838                 return gpg_err_code_from_errno(ENOMEM);
 839             }
 840
 841             if (update_element_list(elements) == FALSE) {
 842                 xmlFree(target);
 843                 return gpg_err_code_from_errno(ENOMEM);
 844             }
 845
 846             elements->prefix = tmp;
 847             elements->resolving = TRUE;
 848             rc = create_path_list(doc, elements, (gchar *)target);
 849             xmlFree(target);
 850             elements->resolving = r;
 851             elements->depth--;
 852             g_free(tmp);
 853             elements->prefix = save;
 854
 855             if (rc)
 856                 return rc;
 857         }
 858
 859 children:
 860         if (n->children) {
 861             gchar *tmp = g_strdup_printf("%s\t!%s", elements->prefix, n->name);
 862             gchar *save = elements->prefix;
 863
 864             if (!tmp)
 865                 return gpg_err_code_from_errno(ENOMEM);
 866
 867             elements->prefix = tmp;
 868             rc = path_list_recurse(doc, n->children, elements);
 869             g_free(elements->prefix);
 870             elements->prefix = save;
 871
 872             if (rc)
 873                 return rc;
 874         }
 875     }
 876
 877     return rc;
 878 }
 879
 880 gpg_error_t add_attribute(xmlNodePtr node, const gchar *name,
 881         const gchar *value)
 882 {
 883     xmlAttrPtr a;
 884
 885     if ((a = xmlHasProp(node, (xmlChar *)name)) == NULL) {
 886         a = xmlNewProp(node, (xmlChar *)name, (xmlChar *)value);
 887
 888         if (!a)
 889             return EPWMD_LIBXML_ERROR;
 890     }
 891     else
 892         xmlNodeSetContent(a->children, (xmlChar *)value);
 893
 894     return 0;
 895 }
 896
 897 gpg_error_t update_timestamp(xmlDocPtr doc)
 898 {
 899     xmlNodePtr n = xmlDocGetRootElement(doc);
 900     gchar *t = g_strdup_printf("%li", time(NULL));
 901     gpg_error_t rc;
 902
 903     rc = add_attribute(n, "age", t);
 904     g_free(t);
 905     return rc;
 906 }
 907
 908 /*
 909  * From the element path 'path', find sub-nodes and append them to the list.
 910  */
 911 gpg_error_t create_path_list(xmlDocPtr doc, struct element_list_s *elements,
 912         gchar *path)
 913 {
 914     gpg_error_t rc;
 915     gchar **req, **req_orig;
 916     xmlNodePtr n;
 917     gboolean a_target = FALSE;
 918
 919     req = split_input_line(path, "\t", 0);
 920
 921     if (!req) {
 922         req = split_input_line(path, " ", 0);
 923
 924         if (!req)
 925             return EPWMD_COMMAND_SYNTAX;
 926     }
 927
 928     req_orig = g_strdupv(req);
 929
 930     if (!req_orig) {
 931         rc = gpg_err_code_from_errno(ENOMEM);
 932         goto fail;
 933     }
 934
 935     n = find_root_element(doc, &req, &rc, &a_target, 0, FALSE);
 936
 937     if (!n && rc == EPWMD_ELEMENT_NOT_FOUND && elements->resolving == TRUE) {
 938         rc = 0;
 939         goto fail;
 940     }
 941     else if (!n)
 942         goto fail;
 943
 944     if (a_target == TRUE) {
 945         g_free(*req);
 946         *req = g_strdup(*req_orig);
 947     }
 948
 949     if (*(req+1)) {
 950         gboolean e_target = FALSE;
 951
 952         n = find_elements(doc, n->children, req+1, &rc, &e_target, NULL, NULL, TRUE, 0, NULL, FALSE);
 953
 954         if (!n && rc == EPWMD_ELEMENT_NOT_FOUND && elements->resolving == TRUE) {
 955             rc = 0;
 956             goto fail;
 957         }
 958         else if (!n)
 959             goto fail;
 960     }
 961
 962     if (!elements->prefix) {
 963         /*
 964          * FIXME
 965          *
 966          * If any req_orig element contains no target the element should be
 967          * prefixed with the literal character. Not really crucial if the
 968          * client isn't human because child elements are prefixed for the
 969          * current path. But may be confusing if editing by hand.
 970          */
 971         elements->prefix = g_strjoinv("\t", req_orig);
 972
 973         if (!elements->prefix) {
 974             rc = gpg_err_code_from_errno(ENOMEM);
 975             goto fail;
 976         }
 977
 978         if (strv_printf(&elements->elements, "%s", elements->prefix) == FALSE) {
 979             rc = gpg_err_code_from_errno(ENOMEM);
 980             goto fail;
 981         }
 982
 983         if (update_element_list(elements) == FALSE) {
 984             rc = gpg_err_code_from_errno(ENOMEM);
 985             goto fail;
 986         }
 987     }
 988
 989     rc = path_list_recurse(doc, n->children, elements);
 990
 991 fail:
 992     if (req_orig)
 993         g_strfreev(req_orig);
 994
 995     g_strfreev(req);
 996     return rc;
 997 }
 998
 999 gpg_error_t recurse_xpath_nodeset(xmlDocPtr doc, xmlNodeSetPtr nodes,
1000         xmlChar *value, xmlBufferPtr *result)
1001 {
1002     gint i = value ? nodes->nodeNr - 1 : 0;
1003     xmlBufferPtr buf;
1004
1005     buf = xmlBufferCreate();
1006
1007     if (!buf)
1008         return gpg_err_code_from_errno(ENOMEM);
1009
1010     for (; value ? i >= 0 : i < nodes->nodeNr; value ? i-- : i++) {
1011         xmlNodePtr n = nodes->nodeTab[i];
1012
1013         if (!n)
1014             continue;
1015
1016         if (!value) {
1017             if (xmlNodeDump(buf, doc, n, 0, 0) == -1) {
1018                 *result = buf;
1019                 return EPWMD_LIBXML_ERROR;
1020             }
1021
1022             continue;
1023         }
1024
1025         xmlNodeSetContent(n, value);
1026     }
1027
1028     *result =  buf;
1029     return 0;
1030 }
1031
1032 /* Updates the DTD and renames the root "accounts" and "account" elements. */
1033 gpg_error_t convert_xml(gchar **xml, goffset *len)
1034 {
1035     gpg_error_t rc = EPWMD_LIBXML_ERROR;
1036     xmlDocPtr doc, new = NULL;
1037     xmlNodePtr n;
1038
1039     doc = xmlReadMemory(*xml, *len, NULL, "UTF-8", XML_PARSE_NOBLANKS);
1040
1041     if (!doc)
1042         return EPWMD_LIBXML_ERROR;
1043
1044     gcry_free(*xml);
1045     *xml = NULL;
1046     n = xmlDocGetRootElement(doc);
1047     xmlNodeSetName(n, (xmlChar *)"pwmd");
1048
1049     for (n = n->children; n; n = n->next) {
1050         if (xmlStrcmp(n->name, (xmlChar *)"account") == 0)
1051             xmlNodeSetName(n, (xmlChar *)"root");
1052     }
1053
1054     new = create_dtd();
1055
1056     if (!new)
1057         goto fail;
1058
1059     n = xmlDocGetRootElement(doc);
1060     xmlDocSetRootElement(new, n);
1061     xmlDocDumpMemory(new, (xmlChar **)xml, (gint *)len);
1062     xmlDocSetRootElement(new, xmlCopyNode(n, 0));
1063     rc = 0;
1064
1065 fail:
1066     if (new)
1067         xmlFreeDoc(new);
1068
1069     xmlFreeDoc(doc);
1070     return rc;
1071 }