src/xml.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2007 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <err.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <ctype.h>
  28 #include <glib.h>
  29 #include <gcrypt.h>
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include "pwmd_error.h"
  36 #include "xml.h"
  37
  38 void log_write(const gchar *fmt, ...);
  39 gboolean strv_printf(gchar ***array, const gchar *fmt, ...);
  40
  41 gboolean is_literal_element_str(gchar *element)
  42 {
  43     if (!element || !*element)
  44         return FALSE;
  45
  46     return *element == '!' ? TRUE : FALSE;
  47 }
  48
  49 /*
  50  * 'element' must be allocated.
  51  */
  52 gboolean is_literal_element(gchar **element)
  53 {
  54     gchar *p;
  55
  56     if (!element || !*element)
  57         return FALSE;
  58
  59     if (*(*element) == '!') {
  60         gchar *c;
  61
  62         for (p = *element, c = p+1; *c; c++)
  63             *p++ = *c;
  64
  65         *p = 0;
  66         return TRUE;
  67     }
  68
  69     return FALSE;
  70 }
  71
  72 /*
  73  * Fails if 'element' begins with punctuation or digit or contains whitespace.
  74  *
  75  * I'm not sure about using g_unichar_isspace() rather than isspace()?
  76  */
  77 gboolean valid_xml_element(xmlChar *element)
  78 {
  79     gunichar c;
  80     glong len;
  81     gchar *p = (gchar *)element;
  82
  83     if (!element || !*element)
  84         return FALSE;
  85
  86     if (*p == '!')
  87         p++;
  88
  89     len = g_utf8_strlen(p, -1) - 1;
  90     c = g_utf8_get_char(p++);
  91
  92     if (g_unichar_ispunct(c) == TRUE || g_unichar_isdigit(c) == TRUE)
  93         return FALSE;
  94
  95     while (*p && len--) {
  96         c = g_utf8_get_char(p++);
  97
  98         if (g_unichar_isspace(c))
  99             return FALSE;
 100     }
 101
 102     return TRUE;
 103 }
 104
 105 gboolean valid_element_path(gchar **path, gboolean has_value)
 106 {
 107     gchar **p;
 108
 109     for (p = path; *p; p++) {
 110         /*
 111          * An empty element is valid and don't check the syntax of the
 112          * content.
 113          */
 114         if (has_value == TRUE && (!*(p+1) || !*p[0]))
 115             break;
 116
 117         if (valid_xml_element((xmlChar *)*p) == FALSE)
 118             return FALSE;
 119     }
 120
 121     return TRUE;
 122 }
 123
 124 gpg_error_t new_account(xmlDocPtr doc, gchar *name)
 125 {
 126     xmlNodePtr root = xmlDocGetRootElement(doc);
 127     xmlAttrPtr a;
 128     xmlNodePtr n;
 129     gchar *p = name;
 130
 131     if (!p || !root)
 132         return EPWMD_LIBXML_ERROR;
 133
 134     if (is_literal_element_str(p))
 135         p++;
 136
 137     n = xmlNewNode(NULL, (xmlChar *)"account");
 138     n = xmlAddChild(root, n);
 139     a = xmlNewProp(n, (xmlChar *)"name", (xmlChar *)p);
 140     return 0;
 141 }
 142
 143 xmlChar *new_document()
 144 {
 145     xmlChar *buf;
 146     const xmlChar *line = (xmlChar *)
 147             "<?xml version=\"1.0\"?>\n"
 148             "<!DOCTYPE accounts [\n"
 149             "<!ELEMENT accounts (account*)>\n"
 150             "<!ATTLIST account name CDATA #REQUIRED>\n"
 151             "]>\n"
 152             "<accounts/>";
 153
 154     buf = gcry_calloc(1, xmlStrlen(line) + 1);
 155     return buf ? xmlStrcat(buf, line) : NULL;
 156 }
 157
 158 /*
 159  * The "target" attribute is ignored here.
 160  */
 161 gpg_error_t list_accounts(xmlDocPtr doc, GString **result)
 162 {
 163     xmlNodePtr n = NULL;
 164     GSList *list = NULL;
 165     gint total, i;
 166     GString *string;
 167     gpg_error_t error = 0;
 168
 169     n = xmlDocGetRootElement(doc);
 170
 171     if (!n || !n->children)
 172         return EPWMD_EMPTY_ELEMENT;
 173
 174     for (n = n->children; n; n = n->next) {
 175         xmlAttrPtr a;
 176         xmlChar *val, *target;
 177         GSList *tlist;
 178         gchar *tmp;
 179
 180         if (n->type != XML_ELEMENT_NODE)
 181             continue;
 182
 183         a = xmlHasProp(n, (xmlChar *)"name");
 184
 185         if (!a || !a->children->content)
 186             continue;
 187
 188         val = xmlNodeGetContent(a->children);
 189
 190         if (!val) {
 191             error = gpg_error_from_errno(ENOMEM);
 192             goto fail;
 193         }
 194
 195         tmp = g_strdup_printf("!%s", (gchar *)val);
 196
 197         if (!tmp) {
 198             xmlFree(val);
 199             error = gpg_error_from_errno(ENOMEM);
 200             goto fail;
 201         }
 202
 203         tlist = g_slist_append(list, tmp);
 204
 205         if (!tlist) {
 206             xmlFree(val);
 207             error = gpg_error_from_errno(ENOMEM);
 208             goto fail;
 209         }
 210
 211         list = tlist;
 212         target = node_has_attribute(n, (xmlChar *)"target");
 213
 214         if (target) {
 215             gchar *t = g_strdup((gchar *)val);
 216
 217             if (!t) {
 218                 xmlFree(val);
 219                 error = gpg_error_from_errno(ENOMEM);
 220                 goto fail;
 221             }
 222
 223             tlist = g_slist_append(list, t);
 224
 225             if (!tlist) {
 226                 g_free(t);
 227                 error = gpg_error_from_errno(ENOMEM);
 228                 goto fail;
 229             }
 230
 231             list = tlist;
 232         }
 233
 234         xmlFree(val);
 235     }
 236
 237     total = g_slist_length(list);
 238
 239     if (!total)
 240         return EPWMD_EMPTY_ELEMENT;
 241
 242     string = g_string_new(NULL);
 243
 244     if (!string) {
 245         error = gpg_error_from_errno(ENOMEM);
 246         goto fail;
 247     }
 248
 249     for (i = 0; i < total; i++) {
 250         gchar *val = g_slist_nth_data(list, i);
 251
 252         g_string_append_printf(string, "%s\n", val);
 253     }
 254
 255     string = g_string_truncate(string, string->len - 1);
 256     *result = string;
 257
 258 fail:
 259     total = g_slist_length(list);
 260
 261     for (i = 0; i < total; i++)
 262         g_free(g_slist_nth_data(list, i));
 263
 264     g_slist_free(list);
 265     return error;
 266 }
 267
 268 // FIXME return a gboolean in case of memory allocation failure
 269 gchar **split_input_line(gchar *str, gchar *delim, gint n)
 270 {
 271     if (!str || !*str)
 272         return NULL;
 273
 274     return g_strsplit(str, delim, n);
 275 }
 276
 277 static gchar **append_element_path(gchar **dst, gchar **src)
 278 {
 279     gchar **p;
 280     gint i;
 281     gchar **d;
 282
 283     if (!src)
 284         return NULL;
 285
 286     d = g_strdupv(dst);
 287
 288     if (!d)
 289         return NULL;
 290
 291     i = g_strv_length(d);
 292
 293     for (p = src; *p; p++) {
 294         gchar **pa;
 295
 296         pa = g_realloc(d, (i + 2) * sizeof(gchar *));
 297
 298         if (!pa) {
 299             g_strfreev(d);
 300             return NULL;
 301         }
 302
 303         d = pa;
 304         d[i] = g_strdup(*p);
 305
 306         if (!d[i]) {
 307             g_strfreev(d);
 308             return NULL;
 309         }
 310
 311         d[++i] = NULL;
 312     }
 313
 314     return d;
 315 }
 316
 317 static xmlNodePtr find_stop_node(xmlNodePtr node)
 318 {
 319     xmlNodePtr n;
 320
 321     for (n = node->parent->children; n; n = n->next) {
 322         if (n == node)
 323             return n->next;
 324     }
 325
 326     return NULL;
 327 }
 328
 329 /*
 330  * Alot like create_elements_cb() but doesn't use the last element of 'req' as
 331  * content but as an element.
 332  */
 333 xmlNodePtr create_target_elements_cb(xmlNodePtr node, gchar **path,
 334         gpg_error_t *error, void *data)
 335 {
 336     gint i;
 337     char **req = path;
 338
 339     if (xmlStrEqual(node->name, (xmlChar *)*req))
 340         req++;
 341
 342     for (i = 0; req[i]; i++) {
 343         xmlNodePtr n;
 344
 345         if ((n = find_element(node, req[i], find_stop_node(node))) == NULL ||
 346                 (n && n->parent == node->parent)) {
 347             is_literal_element(&req[i]);
 348             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 349
 350             if (!n) {
 351                 *error = gpg_error_from_errno(ENOMEM);
 352                 return NULL;
 353             }
 354
 355             node = xmlAddChild(node, n);
 356
 357             if (!node) {
 358                 *error = gpg_error_from_errno(ENOMEM);
 359                 return NULL;
 360             }
 361         }
 362         else
 363             node = n;
 364     }
 365
 366     return node;
 367 }
 368
 369 xmlNodePtr find_text_node(xmlNodePtr node)
 370 {
 371     xmlNodePtr n = node;
 372
 373     if (n && n->type == XML_TEXT_NODE)
 374         return n;
 375
 376     for (n = node; n; n = n->next) {
 377         if (n->type == XML_TEXT_NODE)
 378             return n;
 379     }
 380
 381     return NULL;
 382 }
 383
 384 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 385         gpg_error_t *error, void *data)
 386 {
 387     gint i;
 388     gchar **req = elements;
 389
 390     if (node->type == XML_TEXT_NODE)
 391         node = node->parent;
 392
 393     if (node->name && xmlStrEqual(node->name, (xmlChar *)*req))
 394         req++;
 395
 396     for (i = 0; req[i]; i++) {
 397         xmlNodePtr n;
 398
 399         if (req[i+1]) {
 400             /*
 401              * Strip the first '!' if needed. If there's another, it's an
 402              * error. The syntax has already been checked before calling this
 403              * function.
 404              */
 405             is_literal_element(&req[i]);
 406         }
 407
 408         /*
 409          * The value of the element tree.
 410          */
 411         if (!req[i+1]) {
 412             n = find_text_node(node->children);
 413
 414             if (!n)
 415                 /* Use AddContent here to prevent overwriting any children. */
 416                 xmlNodeAddContent(node, (xmlChar *)req[i]);
 417             else if (n && !*req[i])
 418                 xmlNodeSetContent(n, NULL);
 419             else
 420                 xmlNodeSetContent(n, (xmlChar *)req[i]);
 421
 422             break;
 423         }
 424
 425         n = find_element(node, req[i], find_stop_node(node));
 426
 427         /*
 428          * If the found element has the same parent as the current element,
 429          * they are siblings and the new element needs to be created as a
 430          * child of the current element (node).
 431          */
 432         if (n && n->parent == node->parent)
 433             n = NULL;
 434
 435         if (!n) {
 436             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 437
 438             if (!n) {
 439                 *error = gpg_error_from_errno(ENOMEM);
 440                 return NULL;
 441             }
 442
 443             node = xmlAddChild(node, n);
 444
 445             if (!node) {
 446                 *error = gpg_error_from_errno(ENOMEM);
 447                 return NULL;
 448             }
 449         }
 450         else
 451             node = n;
 452     }
 453
 454     return node;
 455 }
 456
 457 xmlNodePtr find_account(xmlDocPtr doc, gchar ***req, gpg_error_t *error,
 458         gboolean *target, gint recursion_depth)
 459 {
 460     xmlNodePtr n = xmlDocGetRootElement(doc);
 461     gint depth = 0;
 462     gchar *account = g_strdup(*req[0]);
 463     gboolean literal = is_literal_element(&account);
 464
 465     if (!account) {
 466         *error = gpg_error_from_errno(ENOMEM);
 467         return NULL;
 468     }
 469
 470     *error = 0;
 471     recursion_depth++;
 472
 473     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 474         xmlChar *t = xmlGetNodePath(n);
 475
 476         log_write("%s: %s", pwmd_strerror(EPWMD_LOOP), t);
 477         xmlFree(t);
 478         *error = EPWMD_LOOP;
 479         return NULL;
 480     }
 481
 482     while (n) {
 483         if (n->type == XML_ELEMENT_NODE) {
 484             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"accounts")) {
 485                 n = n->children;
 486                 depth++;
 487                 continue;
 488             }
 489
 490             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"account")) {
 491                 xmlChar *content = node_has_attribute(n, (xmlChar *)"name");
 492
 493                 if (!content)
 494                     continue;
 495
 496                 if (xmlStrEqual(content, (xmlChar *)account)) {
 497                     gchar **nreq, **tmp = NULL;
 498
 499                     if (literal == TRUE) {
 500                         g_free(account);
 501                         return n;
 502                     }
 503
 504                     content = node_has_attribute(n, (xmlChar *)"target");
 505
 506                     if (!content) {
 507                         g_free(account);
 508                         return n;
 509                     }
 510
 511                     if (strchr((gchar *)content, '\t')) {
 512                         nreq = split_input_line((gchar *)content, "\t", 0);
 513
 514 #if 0
 515                         /*
 516                          * FIXME ENOMEM
 517                          */
 518                         if (!nreq) {
 519                             *error = gpg_error_from_errno(ENOMEM);
 520                             return NULL;
 521                         }
 522 #endif
 523
 524                         tmp = *req;
 525                         tmp = append_element_path(nreq, tmp+1);
 526                         g_strfreev(nreq);
 527
 528                         if (!tmp) {
 529                             *error = gpg_error_from_errno(ENOMEM);
 530                             return NULL;
 531                         }
 532
 533                         g_strfreev(*req);
 534                         *req = tmp;
 535                     }
 536                     else {
 537                         if (strv_printf(&tmp, "%s", content) == FALSE) {
 538                             *error = gpg_error_from_errno(ENOMEM);
 539                             return NULL;
 540                         }
 541
 542                         nreq = *req;
 543                         nreq = append_element_path(tmp, nreq+1);
 544                         g_strfreev(tmp);
 545
 546                         if (!nreq) {
 547                             *error = gpg_error_from_errno(ENOMEM);
 548                             return NULL;
 549                         }
 550
 551                         g_strfreev(*req);
 552                         *req = nreq;
 553                     }
 554
 555                     if (target)
 556                         *target = TRUE;
 557
 558                     g_free(account);
 559                     n = find_account(doc, req, error, target, recursion_depth);
 560                     return n;
 561                 }
 562             }
 563         }
 564
 565         n = n->next;
 566     }
 567
 568     g_free(account);
 569     *error = EPWMD_ELEMENT_NOT_FOUND;
 570     return NULL;
 571 }
 572
 573 xmlNodePtr find_sibling(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 574 {
 575     xmlNodePtr n;
 576
 577     if (!node || !element)
 578         return NULL;
 579
 580     for (n = node; n; n = n->next) {
 581         if (n->type != XML_ELEMENT_NODE)
 582             continue;
 583
 584         if (n == stop)
 585             break;
 586
 587         if (xmlStrEqual(n->name, (xmlChar *)element))
 588             return n;
 589     }
 590
 591     return NULL;
 592 }
 593
 594 xmlNodePtr find_element(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 595 {
 596     if (!node || !element)
 597         return NULL;
 598
 599     return find_sibling(node, element, stop);
 600 }
 601
 602 // FIXME: return xmlNodeGetContent(a->children).
 603 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 604 {
 605     xmlAttrPtr a = xmlHasProp(n, attr);
 606
 607     if (!a)
 608         return NULL;
 609
 610     if (!a->children || !a->children->content)
 611         return NULL;
 612
 613     return a->children->content;
 614 }
 615
 616 static gboolean element_to_literal(gchar **element)
 617 {
 618     gchar *p = g_strdup_printf("!%s", *element);
 619
 620     if (!p)
 621         return FALSE;
 622
 623     g_free(*element);
 624     *element = p;
 625     return TRUE;
 626 }
 627
 628 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 629         gchar **req, gpg_error_t *error, gboolean *target,
 630         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 631         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 632         gboolean is_list_command, gint recursion_depth, void *data)
 633 {
 634     xmlNodePtr n, last, last_node;
 635     gchar **p;
 636     gint found = 0;
 637
 638     *error = 0;
 639     recursion_depth++;
 640
 641     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 642         xmlChar *t = xmlGetNodePath(node);
 643
 644         log_write("%s: %s", pwmd_strerror(EPWMD_LOOP), t);
 645         xmlFree(t);
 646         recursion_depth--;
 647         *error = EPWMD_LOOP;
 648         return NULL;
 649     }
 650
 651     for (last_node = last = n = node, p = req; *p; p++) {
 652         xmlNodePtr tmp;
 653         gchar *t = g_strdup(*p);
 654         gboolean literal;
 655
 656         if (!t) {
 657             *error = gpg_error_from_errno(ENOMEM);
 658             return NULL;
 659         }
 660
 661         literal = is_literal_element(&t);
 662         n = find_element(last, t, NULL);
 663         g_free(t);
 664
 665         if (!n) {
 666             if (not_found_fn)
 667                 return not_found_fn(found ? last_node : last_node->parent, p, error, data);
 668
 669             *error = EPWMD_ELEMENT_NOT_FOUND;
 670             return NULL;
 671         }
 672
 673         last = n->children;
 674         last_node = n;
 675         found = 1;
 676
 677         if (literal == FALSE) {
 678             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
 679             gchar **nreq = NULL, **nnreq;
 680
 681             if (!content) {
 682                 if (is_list_command == TRUE) {
 683                     if (element_to_literal(&(*p)) == FALSE) {
 684                         *error = gpg_error_from_errno(ENOMEM);
 685                         return NULL;
 686                     }
 687                 }
 688
 689                 continue;
 690             }
 691
 692             if (strchr((gchar *)content, '\t') != NULL) {
 693                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 694                     *error = EPWMD_INVALID_ELEMENT;
 695                     return NULL;
 696                 }
 697             }
 698             else {
 699                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 700                     *error = EPWMD_INVALID_ELEMENT;
 701                     return NULL;
 702                 }
 703             }
 704
 705             tmp = find_account(doc, &nreq, error, target, 0);
 706
 707             if (!tmp) {
 708                 g_strfreev(nreq);
 709                 return NULL;
 710             }
 711
 712             if (found_fn)
 713                 found_fn(n, nreq, error, data);
 714
 715             nnreq = append_element_path(nreq+1, p+1);
 716             g_strfreev(nreq);
 717
 718             // FIXME ENOMEM
 719             if (!nnreq || !*nnreq) {
 720                 if (nnreq)
 721                     g_strfreev(nnreq);
 722
 723                 return tmp;
 724             }
 725
 726             if (target)
 727                 *target = TRUE;
 728
 729             n = find_elements(doc, tmp->children, nnreq, error, NULL, found_fn,
 730                     not_found_fn, is_list_command, recursion_depth, data);
 731
 732             if (*(p+1)) {
 733                 gchar **zz = p+1, **qq = nnreq;
 734
 735                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 736                     qq = nnreq+1;
 737
 738                 for (; *qq && *zz; zz++) {
 739                     g_free(*zz);
 740                     *zz = g_strdup(*qq++);
 741
 742                     if (!*zz) {
 743                         *error = gpg_error_from_errno(ENOMEM);
 744                         n = NULL;
 745                         break;
 746                     }
 747                 }
 748             }
 749
 750             g_strfreev(nnreq);
 751             return n;
 752         }
 753     }
 754
 755     return n;
 756 }
 757
 758 gboolean node_has_child_element(xmlNodePtr node)
 759 {
 760     xmlNodePtr n;
 761
 762     if (!node)
 763         return FALSE;
 764
 765     for (n = node; n; n = n->next) {
 766         if (n->type == XML_ELEMENT_NODE)
 767             return TRUE;
 768
 769         if (n->children)
 770             return node_has_child_element(n->children);
 771     }
 772
 773     return FALSE;
 774 }
 775
 776 static gboolean update_element_list(struct element_list_s *elements)
 777 {
 778     gchar *line;
 779     GSList *l;
 780
 781     if (!elements || !elements->elements)
 782         return TRUE;
 783
 784     line = g_strjoinv("\t", elements->elements);
 785
 786     if (!line)
 787         return FALSE;
 788
 789     g_strfreev(elements->elements);
 790     elements->elements = NULL;
 791     l = g_slist_append(elements->list, line);
 792
 793     if (!l)
 794         return FALSE;
 795
 796     elements->list = l;
 797     return TRUE;
 798 }
 799
 800 static gpg_error_t path_list_recurse(xmlDocPtr doc, xmlNodePtr node,
 801         struct element_list_s *elements)
 802 {
 803     gpg_error_t rc = 0;
 804     xmlNodePtr n;
 805
 806     for (n = node; n; n = n->next) {
 807         xmlChar *target = NULL;
 808
 809         if (n->type != XML_ELEMENT_NODE)
 810             goto children;
 811
 812         target = node_has_attribute(n, (xmlChar *)"target");
 813
 814         if (strv_printf(&elements->elements, "%s\t!%s", elements->prefix, n->name) == FALSE)
 815             return gpg_err_code_from_errno(ENOMEM);
 816
 817         if (update_element_list(elements) == FALSE)
 818             return gpg_err_code_from_errno(ENOMEM);
 819
 820         if (target) {
 821             gchar *tmp;
 822             gchar *save = elements->prefix;
 823             gboolean r = elements->resolving;
 824
 825             elements->depth++;
 826
 827             if (max_recursion_depth >= 1 && elements->depth > max_recursion_depth) {
 828                 xmlChar *t = xmlGetNodePath(n);
 829                 log_write("%s: %s", pwmd_strerror(EPWMD_LOOP), t);
 830                 xmlFree(t);
 831                 return EPWMD_LOOP;
 832             }
 833
 834             if (strv_printf(&elements->elements, "%s\t%s", elements->prefix, n->name) == FALSE)
 835                 return gpg_err_code_from_errno(ENOMEM);
 836
 837             tmp = g_strjoinv("\t", elements->elements);
 838
 839             if (!tmp)
 840                 return gpg_err_code_from_errno(ENOMEM);
 841
 842             if (update_element_list(elements) == FALSE)
 843                 return gpg_err_code_from_errno(ENOMEM);
 844
 845             elements->prefix = tmp;
 846             elements->resolving = TRUE;
 847             rc = create_path_list(doc, elements, (gchar *)target);
 848             elements->resolving = r;
 849             elements->depth--;
 850             g_free(tmp);
 851             elements->prefix = save;
 852
 853             if (rc)
 854                 return rc;
 855         }
 856
 857 children:
 858         if (n->children) {
 859             gchar *tmp = g_strdup_printf("%s\t!%s", elements->prefix, n->name);
 860             gchar *save = elements->prefix;
 861
 862             if (!tmp)
 863                 return gpg_err_code_from_errno(ENOMEM);
 864
 865             elements->prefix = tmp;
 866             rc = path_list_recurse(doc, n->children, elements);
 867             g_free(elements->prefix);
 868             elements->prefix = save;
 869
 870             if (rc)
 871                 return rc;
 872         }
 873     }
 874
 875     return rc;
 876 }
 877
 878 /*
 879  * From the element path 'path', find sub-nodes and append them to the list.
 880  */
 881 gpg_error_t create_path_list(xmlDocPtr doc, struct element_list_s *elements,
 882         gchar *path)
 883 {
 884     gpg_error_t rc;
 885     gchar **req, **req_orig;
 886     xmlNodePtr n;
 887     gboolean a_target = FALSE;
 888
 889     req = split_input_line(path, "\t", 0);
 890
 891     if (!req) {
 892         req = split_input_line(path, " ", 0);
 893
 894         if (!req)
 895             return EPWMD_COMMAND_SYNTAX;
 896     }
 897
 898     req_orig = g_strdupv(req);
 899
 900     if (!req_orig) {
 901         rc = gpg_err_code_from_errno(ENOMEM);
 902         goto fail;
 903     }
 904
 905     n = find_account(doc, &req, &rc, &a_target, 0);
 906
 907     if (!n && rc == EPWMD_ELEMENT_NOT_FOUND && elements->resolving == TRUE) {
 908         rc = 0;
 909         goto fail;
 910     }
 911     else if (!n)
 912         goto fail;
 913
 914     if (a_target == TRUE) {
 915         g_free(*req);
 916         *req = g_strdup(*req_orig);
 917     }
 918
 919     if (*(req+1)) {
 920         gboolean e_target = FALSE;
 921
 922         n = find_elements(doc, n->children, req+1, &rc, &e_target, NULL, NULL, TRUE, 0, NULL);
 923
 924         if (!n && rc == EPWMD_ELEMENT_NOT_FOUND && elements->resolving == TRUE) {
 925             rc = 0;
 926             goto fail;
 927         }
 928         else if (!n)
 929             goto fail;
 930     }
 931
 932     if (!elements->prefix) {
 933         /*
 934          * FIXME
 935          *
 936          * If any req_orig element contains no target the element should be prefixed with
 937          * the literal character. Not really crucial if the client isn't human
 938          * because sub-nodes/sub-elements are prefixed when needed.
 939          */
 940         elements->prefix = g_strjoinv("\t", req_orig);
 941
 942         if (!elements->prefix) {
 943             rc = gpg_err_code_from_errno(ENOMEM);
 944             goto fail;
 945         }
 946
 947         if (strv_printf(&elements->elements, "%s", elements->prefix) == FALSE) {
 948             rc = gpg_err_code_from_errno(ENOMEM);
 949             goto fail;
 950         }
 951
 952         if (update_element_list(elements) == FALSE) {
 953             rc = gpg_err_code_from_errno(ENOMEM);
 954             goto fail;
 955         }
 956     }
 957
 958     rc = path_list_recurse(doc, n->children, elements);
 959
 960 fail:
 961     if (req_orig)
 962         g_strfreev(req_orig);
 963
 964     g_strfreev(req);
 965     return rc;
 966 }