src/xml.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2011 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 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <err.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <ctype.h>
  31 #include <glib.h>
  32 #include <gcrypt.h>
  33 #include <libxml/xmlwriter.h>
  34 #include "pwmd_error.h"
  35 #include "misc.h"
  36 #include "xml.h"
  37
  38 extern void log_write(const gchar *fmt, ...);
  39
  40 /*
  41  * 'element' must be allocated.
  42  */
  43 gboolean is_literal_element(gchar **element)
  44 {
  45     gchar *p;
  46
  47     if (!element || !*element)
  48         return FALSE;
  49
  50     if (*(*element) == '!') {
  51         gchar *c;
  52
  53         for (p = *element, c = p+1; *c; c++)
  54             *p++ = *c;
  55
  56         *p = 0;
  57         return TRUE;
  58     }
  59
  60     return FALSE;
  61 }
  62
  63 gboolean valid_xml_element(xmlChar *element)
  64 {
  65     gchar *p = (gchar *)element;
  66
  67     if (!element || *element == '!')
  68         return FALSE;
  69
  70     for (; *p; p++) {
  71         if (g_ascii_isspace(*p))
  72             return FALSE;
  73     }
  74
  75     return TRUE;
  76 }
  77
  78 gpg_error_t new_root_element(xmlDocPtr doc, gchar *name)
  79 {
  80     xmlNodePtr root = xmlDocGetRootElement(doc);
  81     xmlNodePtr n;
  82     gchar *p = name;
  83
  84     if (!p || !root)
  85         return EPWMD_LIBXML_ERROR;
  86
  87     if (*p == '!')
  88         p++;
  89
  90     if (!valid_xml_element((xmlChar *)p))
  91         return GPG_ERR_INV_VALUE;
  92
  93     n = xmlNewNode(NULL, (xmlChar *)"element");
  94     n = xmlAddChild(root, n);
  95     return add_attribute(n, "_name", p);
  96 }
  97
  98 xmlDocPtr create_dtd()
  99 {
 100     xmlDocPtr doc;
 101     xmlTextWriterPtr wr = xmlNewTextWriterDoc(&doc, 0);
 102
 103     if (!wr)
 104         return NULL;
 105
 106     if (xmlTextWriterStartDocument(wr, NULL, NULL, NULL))
 107         goto fail;
 108
 109     if (xmlTextWriterStartDTD(wr, (xmlChar *)"pwmd", NULL, NULL) == -1)
 110         goto fail;
 111
 112     if (xmlTextWriterWriteDTDElement(wr, (xmlChar *)"pwmd",
 113                 (xmlChar *)"(element)") == -1)
 114         goto fail;
 115
 116     xmlTextWriterEndDTDElement(wr);
 117
 118     if (xmlTextWriterWriteDTDAttlist(wr, (xmlChar *)"element",
 119             (xmlChar *)"_name CDATA #REQUIRED") == -1)
 120         goto fail;
 121
 122     xmlTextWriterEndDTDAttlist(wr);
 123     xmlTextWriterEndDTD(wr);
 124
 125     if (xmlTextWriterStartElement(wr, (xmlChar *)"pwmd"))
 126         goto fail;
 127
 128     xmlTextWriterEndElement(wr);
 129     xmlTextWriterEndDocument(wr);
 130     xmlFreeTextWriter(wr);
 131     return doc;
 132
 133 fail:
 134     xmlTextWriterEndDocument(wr);
 135     xmlFreeTextWriter(wr);
 136     xmlFreeDoc(doc);
 137     return NULL;
 138 }
 139
 140 xmlChar *new_document()
 141 {
 142     xmlChar *xml;
 143     gint len;
 144     xmlDocPtr doc = create_dtd();
 145
 146     if (!doc)
 147         return NULL;
 148
 149     xmlDocDumpMemory(doc, &xml, &len);
 150     xmlFreeDoc(doc);
 151     return xml;
 152 }
 153
 154 xmlNodePtr find_element_node(xmlNodePtr node)
 155 {
 156     xmlNodePtr n = node;
 157
 158     if (n && n->type == XML_ELEMENT_NODE)
 159         return n;
 160
 161     for (n = node; n; n = n->next) {
 162         if (n->type == XML_ELEMENT_NODE)
 163             return n;
 164     }
 165
 166     return NULL;
 167 }
 168
 169 /*
 170  * Lists root element names; the value of the attribute "_name" of an element
 171  * "element". If there's a target attribute both literal and non-literal
 172  * element names will be added. This is the primary reason why XML entities
 173  * cannot be used. There wouldn't be a way to get the literal an non-literal
 174  * element paths.
 175  */
 176 gpg_error_t list_root_elements(xmlDocPtr doc, GString **result,
 177         gboolean verbose)
 178 {
 179     xmlNodePtr n = NULL;
 180     GSList *list = NULL;
 181     gint total, i;
 182     GString *string;
 183     gpg_error_t rc = 0;
 184
 185     n = xmlDocGetRootElement(doc);
 186
 187     if (!n || !n->children)
 188         return GPG_ERR_NO_VALUE;
 189
 190     for (n = n->children; n; n = n->next) {
 191         xmlAttrPtr a;
 192         xmlChar *val, *target;
 193         GSList *tlist;
 194         gchar *tmp;
 195
 196         if (n->type != XML_ELEMENT_NODE)
 197             continue;
 198
 199         a = xmlHasProp(n, (xmlChar *)"_name");
 200
 201         if (!a || !a->children->content)
 202             continue;
 203
 204         val = xmlNodeGetContent(a->children);
 205
 206         if (!val) {
 207             rc = GPG_ERR_ENOMEM;
 208             goto fail;
 209         }
 210
 211         tmp = g_strdup_printf("!%s%s", (gchar *)val, verbose ? find_element_node(n->children) ? " 1" : " 0" : "");
 212
 213         if (!tmp) {
 214             xmlFree(val);
 215             rc = GPG_ERR_ENOMEM;
 216             goto fail;
 217         }
 218
 219         tlist = g_slist_append(list, tmp);
 220
 221         if (!tlist) {
 222             xmlFree(val);
 223             rc = GPG_ERR_ENOMEM;
 224             goto fail;
 225         }
 226
 227         list = tlist;
 228         target = node_has_attribute(n, (xmlChar *)"target");
 229
 230         if (target) {
 231             gchar *t;
 232
 233             if (verbose) {
 234                 gchar **req = split_input_line((gchar *)target, "\t", 0);
 235                 xmlNodePtr tnode = find_root_element(doc, &req, &rc, NULL, 0, FALSE);
 236
 237                 if (tnode && req[1]) {
 238                     tnode = find_elements(doc, tnode->children, req+1, &rc,
 239                             NULL, NULL, NULL, FALSE, 0, NULL, FALSE);
 240                 }
 241
 242                 g_strfreev(req);
 243                 t = g_strdup_printf("%s%s", (gchar *)val,
 244                         tnode && find_element_node(tnode->children) ? " 1" : " 0");
 245             }
 246             else
 247                 t = g_strdup((gchar *)val);
 248
 249             if (!t) {
 250                 xmlFree(val);
 251                 xmlFree(target);
 252                 rc = GPG_ERR_ENOMEM;
 253                 goto fail;
 254             }
 255
 256             tlist = g_slist_append(list, t);
 257
 258             if (!tlist) {
 259                 g_free(t);
 260                 xmlFree(target);
 261                 rc = GPG_ERR_ENOMEM;
 262                 goto fail;
 263             }
 264
 265             list = tlist;
 266         }
 267
 268         xmlFree(val);
 269         xmlFree(target);
 270     }
 271
 272     total = g_slist_length(list);
 273
 274     if (!total)
 275         return GPG_ERR_NO_VALUE;
 276
 277     string = g_string_new(NULL);
 278
 279     if (!string) {
 280         rc = GPG_ERR_ENOMEM;
 281         goto fail;
 282     }
 283
 284     for (i = 0; i < total; i++) {
 285         gchar *val = g_slist_nth_data(list, i);
 286
 287         g_string_append_printf(string, "%s\n", val);
 288     }
 289
 290     string = g_string_truncate(string, string->len - 1);
 291     *result = string;
 292
 293 fail:
 294     total = g_slist_length(list);
 295
 296     for (i = 0; i < total; i++)
 297         g_free(g_slist_nth_data(list, i));
 298
 299     g_slist_free(list);
 300     return rc;
 301 }
 302
 303 /*
 304  * Prevents a sibling element past the current element path with the same
 305  * element name.
 306  */
 307 static xmlNodePtr find_stop_node(xmlNodePtr node)
 308 {
 309     xmlNodePtr n;
 310
 311     for (n = node->parent->children; n; n = n->next) {
 312         if (n == node)
 313             return n->next;
 314     }
 315
 316     return NULL;
 317 }
 318
 319 /*
 320  * Alot like create_elements_cb() but doesn't use the last element of 'req' as
 321  * content but as an element.
 322  */
 323 xmlNodePtr create_target_elements_cb(xmlNodePtr node, gchar **path,
 324         gpg_error_t *rc, void *data)
 325 {
 326     gint i;
 327     char **req = path;
 328
 329     for (i = 0; req[i]; i++) {
 330         xmlNodePtr n;
 331
 332         if ((n = find_element(node, req[i], find_stop_node(node))) == NULL ||
 333                 (n && n->parent == node->parent)) {
 334             is_literal_element(&req[i]);
 335
 336             if (!valid_xml_element((xmlChar *)req[i])) {
 337                 *rc = GPG_ERR_INV_VALUE;
 338                 return NULL;
 339             }
 340
 341             //n = xmlNewNode(NULL, (xmlChar *)req[i]);
 342             n = xmlNewNode(NULL, (xmlChar *)"element");
 343
 344             if (!n) {
 345                 *rc = GPG_ERR_ENOMEM;
 346                 return NULL;
 347             }
 348
 349             add_attribute(n, "_name", req[i]);
 350             node = xmlAddChild(node, n);
 351
 352             if (!node) {
 353                 *rc = GPG_ERR_ENOMEM;
 354                 return NULL;
 355             }
 356         }
 357         else
 358             node = n;
 359     }
 360
 361     return node;
 362 }
 363
 364 xmlNodePtr find_text_node(xmlNodePtr node)
 365 {
 366     xmlNodePtr n = node;
 367
 368     if (n && n->type == XML_TEXT_NODE)
 369         return n;
 370
 371     for (n = node; n; n = n->next) {
 372         if (n->type == XML_TEXT_NODE)
 373             return n;
 374     }
 375
 376     return NULL;
 377 }
 378
 379 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 380         gpg_error_t *rc, void *data)
 381 {
 382     gint i;
 383     gchar **req = elements;
 384
 385     if (node->type == XML_TEXT_NODE)
 386         node = node->parent;
 387
 388     xmlChar *a = node_has_attribute(node, (xmlChar *)"_name");
 389
 390     if (a)
 391         xmlFree(a);
 392
 393     for (i = 0; req[i]; i++) {
 394         xmlNodePtr n;
 395
 396         if (req[i+1]) {
 397             /*
 398              * Strip the first '!' if needed. If there's another, it's an
 399              * rc. The syntax has already been checked before calling this
 400              * function.
 401              */
 402             is_literal_element(&req[i]);
 403         }
 404
 405         /*
 406          * The value of the element tree.
 407          */
 408         if (!req[i+1]) {
 409             n = find_text_node(node->children);
 410
 411             if (!n)
 412                 /* Use AddContent here to prevent overwriting any children. */
 413                 xmlNodeAddContent(node, (xmlChar *)req[i]);
 414             else if (n && !*req[i])
 415                 xmlNodeSetContent(n, NULL);
 416             else
 417                 xmlNodeSetContent(n, (xmlChar *)req[i]);
 418
 419             break;
 420         }
 421
 422         n = find_element(node, req[i], find_stop_node(node));
 423
 424         /*
 425          * If the found element has the same parent as the current element,
 426          * they are siblings and the new element needs to be created as a
 427          * child of the current element (node).
 428          */
 429         if (n && n->parent == node->parent)
 430             n = NULL;
 431
 432         if (!n) {
 433             if (!valid_xml_element((xmlChar *)req[i])) {
 434                 *rc = GPG_ERR_INV_VALUE;
 435                 return NULL;
 436             }
 437
 438             //n = xmlNewNode(NULL, (xmlChar *)req[i]);
 439             n = xmlNewNode(NULL, (xmlChar *)"element");
 440
 441             if (!n) {
 442                 *rc = GPG_ERR_ENOMEM;
 443                 return NULL;
 444             }
 445
 446             *rc = add_attribute(n, "_name", req[i]);
 447
 448             if (*rc)
 449                 return NULL;
 450
 451             node = xmlAddChild(node, n);
 452
 453             if (!node) {
 454                 *rc = GPG_ERR_ENOMEM;
 455                 return NULL;
 456             }
 457         }
 458         else
 459             node = n;
 460     }
 461
 462     return node;
 463 }
 464
 465 /* The root element is really req[0]. It is need as a pointer in case there is
 466  * a target attribute so it can be updated. */
 467 xmlNodePtr find_root_element(xmlDocPtr doc, gchar ***req, gpg_error_t *rc,
 468         gboolean *target, gint recursion_depth, gboolean stop)
 469 {
 470     xmlNodePtr n = xmlDocGetRootElement(doc);
 471     gint depth = 0;
 472     gchar *root = g_strdup(*req[0]);
 473     gboolean literal = is_literal_element(&root);
 474
 475     if (!root) {
 476         *rc = GPG_ERR_ENOMEM;
 477         return NULL;
 478     }
 479
 480     *rc = 0;
 481     recursion_depth++;
 482
 483     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 484         xmlChar *t = xmlGetNodePath(n);
 485
 486         log_write("%s: %s", pwmd_strerror(GPG_ERR_ELOOP), t);
 487         xmlFree(t);
 488         g_free(root);
 489         *rc = GPG_ERR_ELOOP;
 490         return NULL;
 491     }
 492
 493     while (n) {
 494         if (n->type == XML_ELEMENT_NODE) {
 495             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"pwmd")) {
 496                 n = n->children;
 497                 depth++;
 498                 continue;
 499             }
 500
 501             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"element")) {
 502                 xmlChar *content = node_has_attribute(n, (xmlChar *)"_name");
 503
 504                 if (!content)
 505                     continue;
 506
 507                 if (xmlStrEqual(content, (xmlChar *)root)) {
 508                     gchar **nreq, **tmp = NULL;
 509
 510                     if (literal == TRUE) {
 511                         xmlFree(content);
 512                         g_free(root);
 513                         return n;
 514                     }
 515
 516                     xmlFree(content);
 517                     content = node_has_attribute(n, (xmlChar *)"target");
 518
 519                     if (target)
 520                         *target = TRUE;
 521
 522                     if (!content || stop) {
 523                         if (content)
 524                             xmlFree(content);
 525
 526                         g_free(root);
 527                         return n;
 528                     }
 529
 530                     if (strchr((gchar *)content, '\t')) {
 531                         nreq = split_input_line((gchar *)content, "\t", 0);
 532                         xmlFree(content);
 533
 534 #if 0
 535                         /*
 536                          * FIXME ENOMEM
 537                          */
 538                         if (!nreq) {
 539                             *rc = GPG_ERR_ENOMEM;
 540                             return NULL;
 541                         }
 542 #endif
 543
 544                         tmp = *req;
 545                         tmp = strvcatv(nreq, tmp+1);
 546                         g_strfreev(nreq);
 547
 548                         if (!tmp) {
 549                             g_free(root);
 550                             *rc = GPG_ERR_ENOMEM;
 551                             return NULL;
 552                         }
 553
 554                         g_strfreev(*req);
 555                         *req = tmp;
 556                     }
 557                     else {
 558                         if (strv_printf(&tmp, "%s", content) == FALSE) {
 559                             xmlFree(content);
 560                             g_free(root);
 561                             *rc = GPG_ERR_ENOMEM;
 562                             return NULL;
 563                         }
 564
 565                         xmlFree(content);
 566                         nreq = *req;
 567                         nreq = strvcatv(tmp, nreq+1);
 568                         g_strfreev(tmp);
 569
 570                         if (!nreq) {
 571                             *rc = GPG_ERR_ENOMEM;
 572                             g_free(root);
 573                             return NULL;
 574                         }
 575
 576                         g_strfreev(*req);
 577                         *req = nreq;
 578                     }
 579
 580                     g_free(root);
 581                     n = find_root_element(doc, req, rc, target, recursion_depth, FALSE);
 582                     return n;
 583                 }
 584
 585                 xmlFree(content);
 586             }
 587         }
 588
 589         n = n->next;
 590     }
 591
 592     g_free(root);
 593     *rc = GPG_ERR_ELEMENT_NOT_FOUND;
 594     return NULL;
 595 }
 596
 597 xmlNodePtr find_element(xmlNodePtr node, gchar *element, xmlNodePtr stop)
 598 {
 599     xmlNodePtr n;
 600
 601     if (!node || !element)
 602         return NULL;
 603
 604     for (n = node; n; n = n->next) {
 605         if (n->type != XML_ELEMENT_NODE)
 606             continue;
 607
 608         if (n == stop)
 609             break;
 610
 611         xmlChar *a = node_has_attribute(n, (xmlChar *)"_name");
 612
 613         if (a && xmlStrEqual(a, (xmlChar *)element)) {
 614             xmlFree(a);
 615             return n;
 616         }
 617
 618         xmlFree(a);
 619     }
 620
 621     return NULL;
 622 }
 623
 624 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 625 {
 626     xmlAttrPtr a = xmlHasProp(n, attr);
 627
 628     if (!a)
 629         return NULL;
 630
 631     if (!a->children || !a->children->content)
 632         return NULL;
 633
 634     return xmlGetProp(n, attr);
 635 }
 636
 637 static gboolean element_to_literal(gchar **element)
 638 {
 639     gchar *p = g_strdup_printf("!%s", *element);
 640
 641     if (!p)
 642         return FALSE;
 643
 644     g_free(*element);
 645     *element = p;
 646     return TRUE;
 647 }
 648
 649 /* Resolves elements in 'req' one at a time. It's recursive in case of
 650  * "target" attributes. */
 651 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 652         gchar **req, gpg_error_t *rc, gboolean *target,
 653         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, gchar **, void *),
 654         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 655         gboolean is_list_command, gint recursion_depth, void *data, gboolean stop)
 656 {
 657     xmlNodePtr n, last, last_node;
 658     gchar **p;
 659     gint found = 0;
 660
 661     *rc = 0;
 662     recursion_depth++;
 663
 664     if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth) {
 665         xmlChar *t = xmlGetNodePath(node);
 666
 667         log_write("%s: %s", pwmd_strerror(GPG_ERR_ELOOP), t);
 668         xmlFree(t);
 669         recursion_depth--;
 670         *rc = GPG_ERR_ELOOP;
 671         return NULL;
 672     }
 673
 674     for (last_node = last = n = node, p = req; *p; p++) {
 675         xmlNodePtr tmp;
 676         gchar *t = g_strdup(*p);
 677         gboolean literal;
 678
 679         if (!t) {
 680             *rc = GPG_ERR_ENOMEM;
 681             return NULL;
 682         }
 683
 684         literal = is_literal_element(&t);
 685         n = find_element(last, t, NULL);
 686         g_free(t);
 687
 688         if (!n) {
 689             if (not_found_fn)
 690                 return not_found_fn(found ? last_node : last_node->parent, p, rc, data);
 691
 692             *rc = GPG_ERR_ELEMENT_NOT_FOUND;
 693             return NULL;
 694         }
 695
 696         last = n->children;
 697         last_node = n;
 698         found = 1;
 699
 700         if (literal == FALSE) {
 701             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
 702             gchar **nreq = NULL, **nnreq;
 703
 704             if (!content) {
 705                 if (is_list_command == TRUE) {
 706                     if (element_to_literal(&(*p)) == FALSE) {
 707                         *rc = GPG_ERR_ENOMEM;
 708                         return NULL;
 709                     }
 710                 }
 711
 712                 continue;
 713             }
 714
 715             if (target)
 716                 *target = TRUE;
 717
 718             if (!*(p+1) && stop) {
 719                 xmlFree(content);
 720                 return n;
 721             }
 722
 723             if (strchr((gchar *)content, '\t') != NULL) {
 724                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 725                     xmlFree(content);
 726                     *rc = GPG_ERR_INV_VALUE;
 727                     return NULL;
 728                 }
 729             }
 730             else {
 731                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 732                     xmlFree(content);
 733                     *rc = GPG_ERR_INV_VALUE;
 734                     return NULL;
 735                 }
 736             }
 737
 738             xmlFree(content);
 739             tmp = find_root_element(doc, &nreq, rc, target, 0, FALSE);
 740
 741             if (!tmp) {
 742                 g_strfreev(nreq);
 743                 return NULL;
 744             }
 745
 746             if (found_fn) {
 747                 found_fn(tmp, nreq, rc, p+1, data);
 748
 749                 if (*rc) {
 750                     g_strfreev(nreq);
 751                     return NULL;
 752                 }
 753             }
 754
 755             nnreq = strvcatv(nreq+1, p+1);
 756             g_strfreev(nreq);
 757
 758             // FIXME ENOMEM
 759             if (!nnreq || !*nnreq) {
 760                 if (nnreq)
 761                     g_strfreev(nnreq);
 762
 763                 return tmp;
 764             }
 765
 766             n = find_elements(doc, tmp->children, nnreq, rc, NULL, found_fn,
 767                     not_found_fn, is_list_command, recursion_depth, data, stop);
 768
 769             if (*(p+1)) {
 770                 gchar **zz = p+1, **qq = nnreq;
 771
 772                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 773                     qq = nnreq+1;
 774
 775                 for (; *qq && *zz; zz++) {
 776                     g_free(*zz);
 777                     *zz = g_strdup(*qq++);
 778
 779                     if (!*zz) {
 780                         *rc = GPG_ERR_ENOMEM;
 781                         n = NULL;
 782                         break;
 783                     }
 784                 }
 785             }
 786
 787             g_strfreev(nnreq);
 788             return n;
 789         }
 790     }
 791
 792     return n;
 793 }
 794
 795 static gboolean update_element_list(struct element_list_s *elements)
 796 {
 797     gchar *line;
 798     GSList *l;
 799
 800     if (!elements || !elements->elements)
 801         return TRUE;
 802
 803     line = g_strjoinv("\t", elements->elements);
 804
 805     if (!line)
 806         return FALSE;
 807
 808     g_strfreev(elements->elements);
 809     elements->elements = NULL;
 810     l = g_slist_append(elements->list, line);
 811
 812     if (!l)
 813         return FALSE;
 814
 815     elements->list = l;
 816     return TRUE;
 817 }
 818
 819 static gpg_error_t path_list_recurse(xmlDocPtr doc, xmlNodePtr node,
 820         struct element_list_s *elements)
 821 {
 822     gpg_error_t rc = 0;
 823     xmlNodePtr n;
 824
 825     for (n = node; n; n = n->next) {
 826         xmlChar *target = NULL;
 827         xmlChar *a = node_has_attribute(n, (xmlChar *)"_name");
 828
 829         if (!a)
 830             continue;
 831
 832         if (n->type != XML_ELEMENT_NODE)
 833             goto children;
 834
 835         if (elements->verbose) {
 836             if (strv_printf(&elements->elements, "%s\t!%s%s", elements->prefix, a, find_element_node(n->children) ? " 1" : " 0") == FALSE) {
 837                 xmlFree(a);
 838                 return GPG_ERR_ENOMEM;
 839             }
 840         }
 841         else if (strv_printf(&elements->elements, "%s\t!%s", elements->prefix, a) == FALSE) {
 842             xmlFree(a);
 843             return GPG_ERR_ENOMEM;
 844         }
 845
 846         if (update_element_list(elements) == FALSE) {
 847             xmlFree(a);
 848             return GPG_ERR_ENOMEM;
 849         }
 850
 851         target = node_has_attribute(n, (xmlChar *)"target");
 852
 853         if (target) {
 854             gchar *tmp;
 855             gchar *save = elements->prefix;
 856             gboolean r = elements->resolving;
 857
 858             elements->depth++;
 859
 860             if (max_recursion_depth >= 1 && elements->depth > max_recursion_depth) {
 861                 xmlChar *t = xmlGetNodePath(n);
 862
 863                 log_write("%s: %s", pwmd_strerror(GPG_ERR_ELOOP), t);
 864                 xmlFree(t);
 865                 xmlFree(target);
 866                 xmlFree(a);
 867                 return GPG_ERR_ELOOP;
 868             }
 869
 870             if (elements->verbose) {
 871                 gchar **req = split_input_line((gchar *)target, "\t", 0);
 872                 xmlNodePtr tnode = find_root_element(doc, &req, &rc, NULL, 0, FALSE);
 873
 874                 if (!tnode) {
 875                     g_strfreev(req);
 876                     xmlFree(a);
 877                     xmlFree(target);
 878                     return rc;
 879                 }
 880
 881                 tnode = find_elements(doc, tnode->children, req+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL, FALSE);
 882                 g_strfreev(req);
 883
 884                 if (!tnode) {
 885                     xmlFree(a);
 886                     xmlFree(target);
 887                     return rc;
 888                 }
 889
 890                 if (strv_printf(&elements->elements, "%s\t%s%s", elements->prefix, a, find_element_node(tnode->children) ? " 1" : " 0") == FALSE) {
 891                     xmlFree(a);
 892                     xmlFree(target);
 893                     return GPG_ERR_ENOMEM;
 894                 }
 895             }
 896             else if (strv_printf(&elements->elements, "%s\t%s", elements->prefix, a) == FALSE) {
 897                 xmlFree(a);
 898                 xmlFree(target);
 899                 return GPG_ERR_ENOMEM;
 900             }
 901
 902             tmp = g_strjoinv("\t", elements->elements);
 903
 904             if (!tmp) {
 905                 xmlFree(a);
 906                 xmlFree(target);
 907                 return GPG_ERR_ENOMEM;
 908             }
 909
 910             if (update_element_list(elements) == FALSE) {
 911                 g_free(tmp);
 912                 xmlFree(a);
 913                 xmlFree(target);
 914                 return GPG_ERR_ENOMEM;
 915             }
 916
 917             if (elements->recurse) {
 918                 if (elements->verbose)
 919                     tmp[strlen(tmp)-2] = 0;
 920
 921                 elements->prefix = tmp;
 922                 elements->resolving = TRUE;
 923                 rc = create_path_list(doc, elements, (gchar *)target);
 924                 xmlFree(target);
 925                 elements->resolving = r;
 926                 elements->depth--;
 927                 g_free(tmp);
 928                 elements->prefix = save;
 929
 930                 if (rc) {
 931                     xmlFree(a);
 932                     return rc;
 933                 }
 934             }
 935         }
 936
 937 children:
 938         if (n->children && elements->recurse) {
 939             gchar *tmp = g_strdup_printf("%s\t!%s", elements->prefix, a);
 940             gchar *save = elements->prefix;
 941
 942             if (!tmp) {
 943                 xmlFree(a);
 944                 return GPG_ERR_ENOMEM;
 945             }
 946
 947             elements->prefix = tmp;
 948             rc = path_list_recurse(doc, n->children, elements);
 949             g_free(elements->prefix);
 950             elements->prefix = save;
 951
 952             if (rc) {
 953                 xmlFree(a);
 954                 return rc;
 955             }
 956         }
 957
 958         xmlFree(a);
 959     }
 960
 961     return rc;
 962 }
 963
 964 gpg_error_t add_attribute(xmlNodePtr node, const gchar *name,
 965         const gchar *value)
 966 {
 967     gchar *buf;
 968     gpg_error_t rc;
 969
 970     if (name && !xmlSetProp(node, (xmlChar *)name, (xmlChar *)value))
 971         return EPWMD_LIBXML_ERROR;
 972
 973     if (name && xmlStrEqual((xmlChar *)name, (xmlChar *)"_mtime"))
 974         return 0;
 975
 976     buf = g_strdup_printf("%li", time(NULL));
 977     rc = add_attribute(node, "_mtime", buf);
 978     g_free(buf);
 979     return rc;
 980 }
 981
 982 /*
 983  * From the element path 'path', find sub-nodes and append them to the list.
 984  */
 985 gpg_error_t create_path_list(xmlDocPtr doc, struct element_list_s *elements,
 986         gchar *path)
 987 {
 988     gpg_error_t rc;
 989     gchar **req, **req_orig;
 990     xmlNodePtr n;
 991     gboolean a_target = FALSE;
 992
 993     req = split_input_line(path, "\t", 0);
 994
 995     if (!req) {
 996         req = split_input_line(path, " ", 0);
 997
 998         if (!req)
 999             return GPG_ERR_SYNTAX;
1000     }
1001
1002     req_orig = g_strdupv(req);
1003
1004     if (!req_orig) {
1005         rc = GPG_ERR_ENOMEM;
1006         goto fail;
1007     }
1008
1009     n = find_root_element(doc, &req, &rc, &a_target, 0, FALSE);
1010
1011     if (!n && rc == GPG_ERR_ELEMENT_NOT_FOUND && elements->resolving == TRUE) {
1012         rc = 0;
1013         goto fail;
1014     }
1015     else if (!n)
1016         goto fail;
1017
1018     if (a_target == TRUE) {
1019         g_free(*req);
1020         *req = g_strdup(*req_orig);
1021     }
1022
1023     if (*(req+1)) {
1024         gboolean e_target = FALSE;
1025
1026         n = find_elements(doc, n->children, req+1, &rc, &e_target, NULL, NULL, TRUE, 0, NULL, FALSE);
1027
1028         if (!n && rc == GPG_ERR_ELEMENT_NOT_FOUND && elements->resolving == TRUE) {
1029             rc = 0;
1030             goto fail;
1031         }
1032         else if (!n)
1033             goto fail;
1034     }
1035
1036     if (!elements->prefix) {
1037         /*
1038          * FIXME
1039          *
1040          * If any req_orig element contains no target the element should be
1041          * prefixed with the literal character. Not really crucial if the
1042          * client isn't human because child elements are prefixed for the
1043          * current path. But may be confusing if editing by hand.
1044          */
1045         elements->prefix = g_strjoinv("\t", req_orig);
1046
1047         if (!elements->prefix) {
1048             rc = GPG_ERR_ENOMEM;
1049             goto fail;
1050         }
1051
1052         if (elements->verbose) {
1053             if (strv_printf(&elements->elements, "%s%s", elements->prefix, find_element_node(n->children) ? " 1" : " 0") == FALSE) {
1054                 rc = GPG_ERR_ENOMEM;
1055                 goto fail;
1056             }
1057         }
1058         else if (strv_printf(&elements->elements, "%s", elements->prefix) == FALSE) {
1059             rc = GPG_ERR_ENOMEM;
1060             goto fail;
1061         }
1062
1063         if (update_element_list(elements) == FALSE) {
1064             rc = GPG_ERR_ENOMEM;
1065             goto fail;
1066         }
1067     }
1068
1069     rc = path_list_recurse(doc, n->children, elements);
1070
1071 fail:
1072     if (req_orig)
1073         g_strfreev(req_orig);
1074
1075     g_strfreev(req);
1076     return rc;
1077 }
1078
1079 gpg_error_t recurse_xpath_nodeset(xmlDocPtr doc, xmlNodeSetPtr nodes,
1080         xmlChar *value, xmlBufferPtr *result, gboolean cmd, const xmlChar *attr)
1081 {
1082     gint i = value ? nodes->nodeNr - 1 : 0;
1083     xmlBufferPtr buf;
1084
1085     buf = xmlBufferCreate();
1086
1087     if (!buf)
1088         return GPG_ERR_ENOMEM;
1089
1090     for (; value ? i >= 0 : i < nodes->nodeNr; value ? i-- : i++) {
1091         xmlNodePtr n = nodes->nodeTab[i];
1092         gpg_error_t rc;
1093
1094         if (!n)
1095             continue;
1096
1097         if (!value && !attr) {
1098             if (xmlNodeDump(buf, doc, n, 0, 0) == -1) {
1099                 *result = buf;
1100                 return EPWMD_LIBXML_ERROR;
1101             }
1102
1103             continue;
1104         }
1105
1106         if (!attr) {
1107             xmlNodeSetContent(n, value);
1108             rc = update_element_mtime(n);
1109
1110             if (rc)
1111                 return rc;
1112         }
1113         else {
1114             if (!cmd)
1115                 rc = add_attribute(n, (gchar *)attr, (gchar *)value);
1116             else
1117                 rc = delete_attribute(n, attr);
1118
1119             if (rc)
1120                 return rc;
1121         }
1122     }
1123
1124     *result = buf;
1125     return 0;
1126 }
1127
1128 /* Common between a version 1 data file and version < 2.12. */
1129 static gpg_error_t convert_root_element(xmlNodePtr n)
1130 {
1131     xmlChar *a = xmlGetProp(n, (xmlChar *)"_name");
1132     gpg_error_t rc;
1133
1134     if (a) {
1135         xmlFree(a);
1136         xmlChar *t = xmlGetNodePath(n);
1137
1138         log_write(N_("An existing \"_name\" attribute already exists. Please rename this attribute before converting. Path is: %s"), t);
1139         xmlFree(t);
1140         return GPG_ERR_AMBIGUOUS_NAME;
1141     }
1142
1143     a = xmlGetProp(n, (xmlChar *)"name");
1144
1145     if (a) {
1146         rc = add_attribute(n, "_name", (gchar *)a);
1147         xmlFree(a);
1148
1149         if (rc)
1150             return rc;
1151
1152         rc = delete_attribute(n, (xmlChar *)"name");
1153
1154         if (rc)
1155             return rc;
1156
1157         xmlNodeSetName(n, (xmlChar *)"element");
1158     }
1159
1160     return 0;
1161 }
1162
1163 /* For a version 1 data file. */
1164 static gpg_error_t convert_elements_recurse_v1(xmlNodePtr n)
1165 {
1166     for (; n; n = n->next) {
1167         gpg_error_t rc;
1168
1169         if (n->type == XML_ELEMENT_NODE &&
1170                 !xmlStrEqual(n->name, (xmlChar *)"_element")) {
1171             xmlChar *a = xmlGetProp(n, (xmlChar *)"_name");
1172
1173             if (a) {
1174                 xmlFree(a);
1175                 xmlChar *t = xmlGetNodePath(n);
1176
1177                 log_write(N_("An existing \"_name\" attribute already exists. Please rename this attribute before converting. Path is: %s"), t);
1178                 xmlFree(t);
1179                 return GPG_ERR_AMBIGUOUS_NAME;
1180             }
1181
1182             rc = add_attribute(n, "_name", (gchar *)n->name);
1183
1184             if (rc)
1185                 return rc;
1186
1187             xmlNodeSetName(n, (xmlChar *)"element");
1188         }
1189
1190         rc = convert_elements_recurse_v1(n->children);
1191
1192         if (rc)
1193             return rc;
1194     }
1195
1196     return 0;
1197 }
1198
1199 /* Updates the DTD and renames the root "accounts" and "account" elements from
1200  * a version 1 data file. */
1201 gpg_error_t convert_xml(gchar **xml, goffset *len)
1202 {
1203     gpg_error_t rc = EPWMD_LIBXML_ERROR;
1204     xmlDocPtr doc, new = NULL;
1205     xmlNodePtr n;
1206
1207     doc = xmlReadMemory(*xml, *len, NULL, "UTF-8", XML_PARSE_NOBLANKS);
1208
1209     if (!doc)
1210         return EPWMD_LIBXML_ERROR;
1211
1212     gcry_free(*xml);
1213     *xml = NULL;
1214     n = xmlDocGetRootElement(doc);
1215     xmlNodeSetName(n, (xmlChar *)"pwmd");
1216
1217     for (n = n->children; n; n = n->next) {
1218         if (xmlStrEqual(n->name, (xmlChar *)"account")) {
1219             rc = convert_root_element(n);
1220
1221             if (rc) {
1222                 xmlFreeDoc(doc);
1223                 return rc;
1224             }
1225
1226             rc = convert_elements_recurse_v1(n->children);
1227
1228             if (rc) {
1229                 xmlFreeDoc(doc);
1230                 return rc;
1231             }
1232         }
1233     }
1234
1235     new = create_dtd();
1236
1237     if (!new)
1238         goto fail;
1239
1240     n = xmlDocGetRootElement(doc);
1241     xmlDocSetRootElement(new, n);
1242     xmlDocDumpMemory(new, (xmlChar **)xml, (gint *)len);
1243     xmlDocSetRootElement(new, xmlCopyNode(n, 0));
1244     rc = 0;
1245
1246 fail:
1247     if (new)
1248         xmlFreeDoc(new);
1249
1250     xmlFreeDoc(doc);
1251     return rc;
1252 }
1253
1254 gpg_error_t delete_attribute(xmlNodePtr n, const xmlChar *name)
1255 {
1256     xmlAttrPtr a;
1257
1258     if ((a = xmlHasProp(n, name)) == NULL)
1259         return GPG_ERR_NOT_FOUND;
1260
1261     if (xmlRemoveProp(a) == -1)
1262         return EPWMD_LIBXML_ERROR;
1263
1264     return update_element_mtime(n);
1265 }
1266
1267 static gpg_error_t convert_elements_recurse(xmlDocPtr doc, xmlNodePtr n,
1268         guint depth)
1269 {
1270     gpg_error_t rc;
1271
1272     depth++;
1273
1274     for (n = n->children; n; n = n->next) {
1275         if (n->type == XML_ELEMENT_NODE) {
1276             xmlChar *a = NULL;
1277
1278             if (depth > 1) {
1279                 if (xmlStrEqual(n->name, (xmlChar *)"element")) {
1280                     xmlChar *t = xmlGetNodePath(n);
1281
1282                     log_write(N_("An existing \"element\" already exists. Please rename this element before converting. Path is: %s"), t);
1283                     xmlFree(t);
1284                     return GPG_ERR_AMBIGUOUS_NAME;
1285                 }
1286
1287                 a = xmlGetProp(n, (xmlChar *)"_name");
1288
1289                 if (a) {
1290                     xmlFree(a);
1291                     xmlChar *t = xmlGetNodePath(n);
1292
1293                     log_write(N_("An existing \"_name\" attribute already exists. Please rename this attribute before converting. Path is: %s"), t);
1294                     xmlFree(t);
1295                     return GPG_ERR_AMBIGUOUS_NAME;
1296                 }
1297
1298                 xmlChar *tmp = xmlStrdup(n->name);
1299
1300                 if (!tmp)
1301                     return GPG_ERR_ENOMEM;
1302
1303                 xmlNodeSetName(n, (xmlChar *)"element");
1304                 rc = add_attribute(n, "_name", (gchar *)tmp);
1305                 xmlFree(tmp);
1306
1307                 if (rc)
1308                     return rc;
1309             }
1310             else {
1311                 rc = convert_root_element(n);
1312
1313                 if (rc)
1314                     return rc;
1315             }
1316         }
1317
1318         if (n->children) {
1319             rc = convert_elements_recurse(doc, n, depth);
1320
1321             if (rc)
1322                 return rc;
1323         }
1324     }
1325
1326     return 0;
1327 }
1328
1329 /* Renames ALL elements to the new "element" name. Existing element names are
1330  * stored as an attribute "_name". This was introduced in pwmd 2.12 so
1331  * elements can contain common characters that the XML parser barfs on (an
1332  * email address for example. */
1333 gpg_error_t convert_elements(xmlDocPtr doc)
1334 {
1335     xmlNodePtr n = xmlDocGetRootElement(doc);
1336     gpg_error_t rc;
1337
1338     log_write(N_("Converting pre 2.12 data file..."));
1339     rc = convert_elements_recurse(doc, n, 0);
1340
1341     if (!rc)
1342         log_write(N_("Finished converting. Please SAVE to update."));
1343
1344     return rc;
1345 }
1346
1347 gpg_error_t validate_import(xmlNodePtr node)
1348 {
1349     gpg_error_t rc;
1350
1351     if (!node)
1352         return 0;
1353
1354     for (xmlNodePtr n = node; n; n = n->next) {
1355         if (n->type == XML_ELEMENT_NODE) {
1356             if (xmlStrEqual(n->name, (xmlChar *)"element")) {
1357                 xmlChar *a = xmlGetProp(n, (xmlChar *)"_name");
1358
1359                 if (!a) {
1360                     xmlChar *t = xmlGetNodePath(n);
1361
1362                     log_write(N_("Missing attribute '_name' at %s."), t);
1363                     xmlFree(t);
1364                     return GPG_ERR_INV_VALUE;
1365                 }
1366
1367                 if (!valid_xml_element(a)) {
1368                     xmlChar *t = xmlGetNodePath(n);
1369
1370                     log_write(N_("'%s' is not a valid element name at %s."), a, t);
1371                     xmlFree(a);
1372                     xmlFree(t);
1373                     return GPG_ERR_INV_VALUE;
1374                 }
1375
1376                 xmlFree(a);
1377             }
1378             else {
1379                 xmlChar *t = xmlGetNodePath(n);
1380
1381                 log_write(N_("Warning: unknown element '%s' at %s. Ignoring."), n->name, t);
1382                 xmlFree(t);
1383                 continue;
1384             }
1385         }
1386
1387         if (n->children) {
1388             rc = validate_import(n->children);
1389
1390             if (rc)
1391                 return rc;
1392         }
1393     }
1394
1395     return rc;
1396 }
1397
1398 gpg_error_t update_element_mtime(xmlNodePtr n)
1399 {
1400     return add_attribute(n, NULL, NULL);
1401 }
1402
1403 gpg_error_t unlink_node(xmlNodePtr n)
1404 {
1405     gpg_error_t rc = 0;
1406
1407     if (!n)
1408         return rc;
1409
1410     if (n->parent)
1411         rc = update_element_mtime(n->parent);
1412
1413     xmlUnlinkNode(n);
1414     return rc;
1415 }