src/xml.c

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