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