src/xml.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014
   3     Ben Kibbey <bjk@luxsci.net>
   4
   5     This file is part of pwmd.
   6
   7     Pwmd is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     Pwmd is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <err.h>
  28 #include <string.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <ctype.h>
  32 #include <libxml/xmlwriter.h>
  33 #include <wctype.h>
  34 #include <sys/types.h>
  35 #include <pwd.h>
  36
  37 #ifndef _
  38 #include "gettext.h"
  39 #define _(msgid) gettext(msgid)
  40 #endif
  41
  42 #include "pwmd-error.h"
  43 #include "util-misc.h"
  44 #include "xml.h"
  45 #include "mem.h"
  46 #include "rcfile.h"
  47
  48 extern void log_write (const char *fmt, ...);
  49
  50 /*
  51  * 'element' must be allocated.
  52  */
  53 int
  54 is_literal_element (char **element)
  55 {
  56   char *p;
  57
  58   if (!element || !*element)
  59     return 0;
  60
  61   if (*(*element) == '!')
  62     {
  63       char *c;
  64
  65       for (p = *element, c = p + 1; *c; c++)
  66         *p++ = *c;
  67
  68       *p = 0;
  69       return 1;
  70     }
  71
  72   return 0;
  73 }
  74
  75 int
  76 valid_xml_attribute (const char *str)
  77 {
  78   return valid_xml_element ((xmlChar *)str);
  79 }
  80
  81 int
  82 valid_xml_element (xmlChar *str)
  83 {
  84   wchar_t *wc;
  85   size_t len, c;
  86
  87   if (!str || !*str || *str == '!')
  88     return 0;
  89
  90   wc = str_to_wchar ((const char *)str);
  91   len = wcslen (wc);
  92
  93   for (c = 0; c < len; c++)
  94     {
  95       if (iswspace(wc[c]))
  96         {
  97           xfree (wc);
  98           return 0;
  99         }
 100     }
 101
 102   xfree (wc);
 103   return 1;
 104 }
 105
 106 int
 107 valid_element_path (char **path, int with_content)
 108 {
 109   char **dup = NULL, **p;
 110
 111   if (!path || !*path)
 112     return 0;
 113
 114   /* Save some memory by not duplicating the element content. */
 115   if (with_content)
 116     {
 117       int i, t = strv_length (path);
 118
 119       for (i = 0; i < t - 1; i++)
 120         {
 121           char **tmp = xrealloc (dup, (i + 2) * sizeof (char *));
 122
 123           if (!tmp)
 124             {
 125               strv_free (dup);
 126               return 0;
 127             }
 128
 129           dup = tmp;
 130           dup[i] = str_dup (path[i]);
 131           dup[i + 1] = NULL;
 132         }
 133     }
 134   else
 135     dup = strv_dup (path);
 136
 137   if (!dup)
 138     return 0;
 139
 140   for (p = dup; *p && *(*p); p++)
 141     {
 142       is_literal_element (&(*p));
 143       if (!valid_xml_element ((xmlChar *) * p))
 144         {
 145           strv_free (dup);
 146           return 0;
 147         }
 148     }
 149
 150   strv_free (dup);
 151   return 1;
 152 }
 153
 154 gpg_error_t
 155 attr_ctime (xmlNodePtr n)
 156 {
 157   char *buf = str_asprintf ("%li", time (NULL));
 158   gpg_error_t rc;
 159
 160   if (!buf)
 161     return GPG_ERR_ENOMEM;
 162
 163   rc = add_attribute (n, "_ctime", buf);
 164   xfree (buf);
 165   return rc;
 166 }
 167
 168 // FIXME add parameter to want RW or RO access to the XML node.
 169 static gpg_error_t
 170 acl_check (struct client_s *client, xmlNodePtr n)
 171 {
 172   gpg_error_t rc = GPG_ERR_EPERM;
 173   xmlChar *acl = node_has_attribute (n, (xmlChar *) "_acl");
 174   char **users = acl ? str_split((char *)acl, ",", 0) : NULL;
 175   char **p;
 176   int allowed = 0;
 177
 178   if (!acl || !users || !*users)
 179     {
 180       strv_free(users);
 181       return peer_is_self(client);
 182     }
 183
 184   if (!peer_is_self(client))
 185     return 0;
 186
 187   for (p = users; *p; p++)
 188     {
 189 #ifdef WITH_GNUTLS
 190       rc = acl_check_common (client, *p,
 191                              client->thd->remote ? 0 : client->thd->peer->uid,
 192                              client->thd->remote ? 0 : client->thd->peer->gid,
 193                              &allowed);
 194 #else
 195       rc = acl_check_common (client, *p, client->thd->peer->uid,
 196                              client->thd->peer->gid, &allowed);
 197 #endif
 198     }
 199
 200   xmlFree(acl);
 201   strv_free(users);
 202   if (rc)
 203     return rc;
 204
 205   return allowed ? 0 : GPG_ERR_EPERM;
 206 }
 207
 208 static char *
 209 create_acl_user (struct client_s *client)
 210 {
 211 #ifdef WITH_GNUTLS
 212   if (client->thd->remote)
 213     return str_asprintf ("#%s", client->thd->tls->fp);
 214 #endif
 215
 216   return get_username (client->thd->peer->uid);
 217 }
 218
 219 static gpg_error_t
 220 create_new_element (struct client_s *client, xmlNodePtr parent,
 221                     const char *name, xmlNodePtr * result)
 222 {
 223   xmlNodePtr n;
 224   gpg_error_t rc;
 225
 226   rc = acl_check(client, parent);
 227   if (rc)
 228     return rc;
 229
 230   n = xmlNewNode (NULL, (xmlChar *) "element");
 231   if (!n)
 232     return GPG_ERR_ENOMEM;
 233
 234   rc = add_attribute (n, "_name", name);
 235   if (!rc)
 236     rc = attr_ctime (n);
 237
 238   if (!rc)
 239     {
 240       xmlNodePtr p = xmlAddChild (parent, n);
 241       char *user = create_acl_user (client);
 242
 243       if (result)
 244         *result = p;
 245
 246       rc = add_attribute(p, "_acl", user);
 247       xfree (user);
 248     }
 249   else
 250     xmlFreeNode (n);
 251
 252   return rc;
 253 }
 254
 255 gpg_error_t
 256 new_root_element (struct client_s *client, xmlDocPtr doc, char *name)
 257 {
 258   xmlNodePtr root = xmlDocGetRootElement (doc);
 259   char *p = name;
 260
 261   if (!p || !root)
 262     return GPG_ERR_BAD_DATA;
 263
 264   if (*p == '!')
 265     p++;
 266
 267   if (!valid_xml_element ((xmlChar *) p))
 268     return GPG_ERR_INV_VALUE;
 269
 270   return create_new_element (client, root, p, NULL);
 271 }
 272
 273 static xmlDocPtr
 274 create_dtd ()
 275 {
 276   xmlDocPtr doc;
 277   xmlTextWriterPtr wr = xmlNewTextWriterDoc (&doc, 0);
 278
 279   if (!wr)
 280     return NULL;
 281
 282   if (xmlTextWriterStartDocument (wr, NULL, "UTF-8", "yes"))
 283     goto fail;
 284
 285   if (xmlTextWriterStartDTD (wr, (xmlChar *) "pwmd", NULL, NULL) == -1)
 286     goto fail;
 287
 288   if (xmlTextWriterWriteDTDElement (wr, (xmlChar *) "pwmd",
 289                                     (xmlChar *) "(element)") == -1)
 290     goto fail;
 291
 292   xmlTextWriterEndDTDElement (wr);
 293
 294   if (xmlTextWriterWriteDTDAttlist (wr, (xmlChar *) "element",
 295                                     (xmlChar *) "_name CDATA #REQUIRED") ==
 296       -1)
 297     goto fail;
 298
 299   xmlTextWriterEndDTDAttlist (wr);
 300   xmlTextWriterEndDTD (wr);
 301
 302   if (xmlTextWriterStartElement (wr, (xmlChar *) "pwmd"))
 303     goto fail;
 304
 305   xmlTextWriterEndElement (wr);
 306   xmlTextWriterEndDocument (wr);
 307   xmlFreeTextWriter (wr);
 308   return doc;
 309
 310 fail:
 311   xmlTextWriterEndDocument (wr);
 312   xmlFreeTextWriter (wr);
 313   xmlFreeDoc (doc);
 314   return NULL;
 315 }
 316
 317 xmlDocPtr
 318 new_document ()
 319 {
 320   return create_dtd ();
 321 }
 322
 323 xmlNodePtr
 324 find_element_node (xmlNodePtr node)
 325 {
 326   xmlNodePtr n = node;
 327
 328   if (n && n->type == XML_ELEMENT_NODE)
 329     return n;
 330
 331   for (n = node; n; n = n->next)
 332     {
 333       if (n->type == XML_ELEMENT_NODE)
 334         return n;
 335     }
 336
 337   return NULL;
 338 }
 339
 340 static xmlNodePtr
 341 resolve_path (struct client_s *client, xmlDocPtr doc, xmlChar * path,
 342               char ***result, gpg_error_t * rc)
 343 {
 344   xmlNodePtr n;
 345   char **req;
 346
 347   req = str_split ((char *) path, "\t", 0);
 348   if (!req)
 349     {
 350       *rc = GPG_ERR_ENOMEM;
 351       return NULL;
 352     }
 353
 354   n = find_root_element (client, doc, &req, rc, NULL, 0, 0);
 355   if (!n)
 356     {
 357       strv_free (req);
 358       return NULL;
 359     }
 360
 361   if (req[1])
 362     n = find_elements (client, doc, n->children, req + 1, rc, NULL, NULL, NULL,
 363                        0, 0, NULL, 0);
 364
 365   if (*rc)
 366     strv_free (req);
 367   else
 368     *result = req;
 369
 370   return n;
 371 }
 372
 373 /*
 374  * Lists root element names; the value of the attribute "_name" of an element
 375  * "element". If there's a target attribute both literal and non-literal
 376  * element names will be added. This is the primary reason why XML entities
 377  * cannot be used. There wouldn't be a way to get the literal an non-literal
 378  * element paths.
 379  */
 380 gpg_error_t
 381 list_root_elements (struct client_s *client, xmlDocPtr doc,
 382                     struct string_s ** result, int verbose, int with_target)
 383 {
 384   xmlNodePtr n = NULL;
 385   struct slist_s *list = NULL;
 386   int total, i;
 387   struct string_s *string;
 388   gpg_error_t rc = 0;
 389
 390   n = xmlDocGetRootElement (doc);
 391   if (!n || !n->children)
 392     return GPG_ERR_NO_DATA;
 393
 394   for (n = n->children; n; n = n->next)
 395     {
 396       xmlAttrPtr a;
 397       xmlChar *val, *target;
 398       struct slist_s *tlist;
 399       char *tmp;
 400
 401       if (n->type != XML_ELEMENT_NODE)
 402         continue;
 403
 404       a = xmlHasProp (n, (xmlChar *) "_name");
 405       if (!a || !a->children->content)
 406         continue;
 407
 408       val = xmlNodeGetContent (a->children);
 409       if (!val)
 410         {
 411           rc = GPG_ERR_ENOMEM;
 412           goto fail;
 413         }
 414
 415       tmp =
 416         str_asprintf ("!%s%s", (char *) val,
 417                       verbose ? find_element_node (n->children) ? " +" : "" :
 418                       "");
 419
 420       if (!tmp)
 421         {
 422           xmlFree (val);
 423           rc = GPG_ERR_ENOMEM;
 424           goto fail;
 425         }
 426
 427       tlist = slist_append (list, tmp);
 428       if (!tlist)
 429         {
 430           xmlFree (val);
 431           rc = GPG_ERR_ENOMEM;
 432           goto fail;
 433         }
 434
 435       list = tlist;
 436       target = node_has_attribute (n, (xmlChar *) "target");
 437       if (target)
 438         {
 439           char *t = NULL;
 440
 441           if (verbose)
 442             {
 443               char **req = NULL;
 444               xmlNodePtr tnode = resolve_path (client, doc, target, &req, &rc);
 445
 446               if (rc == GPG_ERR_ELEMENT_NOT_FOUND || rc == GPG_ERR_ELOOP
 447                   || rc == GPG_ERR_EPERM)
 448                 {
 449                   t = str_asprintf ("%s %s", (char *) val,
 450                                     rc == GPG_ERR_ELOOP ? "O" :
 451                                     rc == GPG_ERR_EPERM ? "P" : "E");
 452                   rc = 0;
 453                 }
 454               else if (!rc)
 455                 {
 456                   struct string_s *realpath = NULL;
 457
 458                   if (with_target)
 459                     {
 460                       rc = build_realpath (client, doc, (char *) target,
 461                                            &realpath);
 462                       if (rc)
 463                         {
 464                           strv_free (req);
 465                           xmlFree (val);
 466                           xmlFree (target);
 467                           goto fail;
 468                         }
 469
 470                       realpath = string_prepend (realpath, "T ");
 471                     }
 472
 473                   t = str_asprintf ("%s%s%s%s", (char *) val,
 474                                     (tnode
 475                                      && find_element_node (tnode->children))
 476                                     || realpath ? " " : "", tnode
 477                                     && find_element_node (tnode->children) ?
 478                                     "+" : "", realpath ? realpath->str : "");
 479
 480                   if (realpath)
 481                     string_free (realpath, 1);
 482                 }
 483
 484               if (req)
 485                 strv_free (req);
 486             }
 487           else
 488             t = str_dup ((char *) val);
 489
 490           if (!t || rc)
 491             {
 492               xmlFree (val);
 493               xmlFree (target);
 494               rc = rc ? rc : GPG_ERR_ENOMEM;
 495               goto fail;
 496             }
 497
 498           tlist = slist_append (list, t);
 499           if (!tlist)
 500             {
 501               xmlFree (val);
 502               xfree (t);
 503               xmlFree (target);
 504               rc = GPG_ERR_ENOMEM;
 505               goto fail;
 506             }
 507
 508           list = tlist;
 509         }
 510
 511       xmlFree (val);
 512       xmlFree (target);
 513     }
 514
 515   total = slist_length (list);
 516   if (!total)
 517     return GPG_ERR_NO_DATA;
 518
 519   string = string_new (NULL);
 520   if (!string)
 521     {
 522       rc = GPG_ERR_ENOMEM;
 523       goto fail;
 524     }
 525
 526   for (i = 0; i < total; i++)
 527     {
 528       char *val = slist_nth_data (list, i);
 529
 530       string_append_printf (string, "%s\n", val);
 531     }
 532
 533   string = string_truncate (string, string->len - 1);
 534   *result = string;
 535
 536 fail:
 537   total = slist_length (list);
 538   for (i = 0; i < total; i++)
 539     xfree (slist_nth_data (list, i));
 540
 541   slist_free (list);
 542   return rc;
 543 }
 544
 545 /*
 546  * Prevents a sibling element past the current element path with the same
 547  * element name.
 548  */
 549 static xmlNodePtr
 550 find_stop_node (xmlNodePtr node)
 551 {
 552   xmlNodePtr n;
 553
 554   for (n = node->parent->children; n; n = n->next)
 555     {
 556       if (n == node)
 557         return n->next;
 558     }
 559
 560   return NULL;
 561 }
 562
 563 xmlNodePtr
 564 create_target_elements_cb (struct client_s *client,
 565                            xmlNodePtr node, char **path, gpg_error_t *rc,
 566                            void *data)
 567 {
 568   int i;
 569   char **req = path;
 570   xmlNodePtr parent = data;
 571
 572   for (i = 0; req[i] && *req[i]; i++)
 573     {
 574       xmlNodePtr n;
 575
 576       if (parent && node == parent)
 577         {
 578           *rc = GPG_ERR_CONFLICT;
 579           return NULL;
 580         }
 581
 582       is_literal_element (&req[i]);
 583
 584       if ((n = find_element (client, node, req[i],
 585                              find_stop_node (node), rc)) == NULL ||
 586           (n && n->parent == node->parent))
 587         {
 588
 589           if (!*rc)
 590             *rc = create_new_element (client, node, req[i], &node);
 591
 592           if (*rc)
 593             return NULL;
 594         }
 595       else
 596         node = n;
 597     }
 598
 599   return node;
 600 }
 601
 602 xmlNodePtr
 603 find_text_node (xmlNodePtr node)
 604 {
 605   xmlNodePtr n = node;
 606
 607   if (n && n->type == XML_TEXT_NODE)
 608     return n;
 609
 610   for (n = node; n; n = n->next)
 611     {
 612       if (n->type == XML_TEXT_NODE)
 613         return n;
 614     }
 615
 616   return NULL;
 617 }
 618
 619 xmlNodePtr
 620 create_elements_cb (struct client_s *client, xmlNodePtr node, char **elements,
 621                     gpg_error_t * rc, void *data)
 622 {
 623   int i;
 624   char **req = elements;
 625
 626   if (node->type == XML_TEXT_NODE)
 627     node = node->parent;
 628
 629   for (i = 0; req[i] && *req[i]; i++)
 630     {
 631       xmlNodePtr n;
 632
 633       /*
 634        * Strip the first '!' if needed. If there's another, it's an
 635        * rc. The syntax has already been checked before calling this
 636        * function.
 637        */
 638       is_literal_element (&req[i]);
 639       n = find_element (client, node, req[i], find_stop_node (node), rc);
 640       if (*rc)
 641         return NULL;
 642
 643       /*
 644        * If the found element has the same parent as the current element,
 645        * they are siblings and the new element needs to be created as a
 646        * child of the current element (node).
 647        */
 648       if (n && n->parent == node->parent)
 649         n = NULL;
 650
 651       if (!n)
 652         {
 653           *rc = create_new_element (client, node, req[i], &node);
 654           if (*rc)
 655             return NULL;
 656         }
 657       else
 658         node = n;
 659     }
 660
 661   return node;
 662 }
 663
 664 /* The root element is really req[0]. It is need as a pointer in case there is
 665  * a target attribute so it can be updated. */
 666 xmlNodePtr
 667 find_root_element (struct client_s *client, xmlDocPtr doc, char ***req,
 668                    gpg_error_t * rc, int *target, int recursion_depth,
 669                    int stop)
 670 {
 671   xmlNodePtr n = xmlDocGetRootElement (doc);
 672   int depth = 0;
 673   char *root = str_dup (*req[0]);
 674   int literal = is_literal_element (&root);
 675
 676   if (!root)
 677     {
 678       *rc = GPG_ERR_ENOMEM;
 679       return NULL;
 680     }
 681
 682   *rc = 0;
 683   recursion_depth++;
 684
 685   if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth)
 686     {
 687       xmlChar *t = xmlGetNodePath (n);
 688
 689       log_write ("%s: %s", pwmd_strerror (GPG_ERR_ELOOP), t);
 690       xmlFree (t);
 691       xfree (root);
 692       *rc = GPG_ERR_ELOOP;
 693       return NULL;
 694     }
 695
 696   while (n)
 697     {
 698       if (n->type == XML_ELEMENT_NODE)
 699         {
 700           if (depth == 0 && xmlStrEqual (n->name, (xmlChar *) "pwmd"))
 701             {
 702               n = n->children;
 703               depth++;
 704               continue;
 705             }
 706
 707           if (depth == 1 && xmlStrEqual (n->name, (xmlChar *) "element"))
 708             {
 709               xmlChar *content = node_has_attribute (n, (xmlChar *) "_name");
 710
 711               if (!content)
 712                 continue;
 713
 714               if (xmlStrEqual (content, (xmlChar *) root))
 715                 {
 716                   char **nreq, **tmp = NULL;
 717
 718                   *rc = acl_check(client, n);
 719                   if (*rc)
 720                     {
 721                       xmlFree (content);
 722                       xfree (root);
 723                       return NULL;
 724                     }
 725
 726                   if (literal == 1)
 727                     {
 728                       xmlFree (content);
 729                       xfree (root);
 730                       return n;
 731                     }
 732
 733                   xmlFree (content);
 734                   content = node_has_attribute (n, (xmlChar *) "target");
 735
 736                   if (target)
 737                     *target = 1;
 738
 739                   if (!content || stop)
 740                     {
 741                       if (content)
 742                         xmlFree (content);
 743
 744                       xfree (root);
 745                       return n;
 746                     }
 747
 748                   if (strchr ((char *) content, '\t'))
 749                     {
 750                       nreq = str_split ((char *) content, "\t", 0);
 751                       xmlFree (content);
 752
 753 #if 0
 754                       /*
 755                        * FIXME ENOMEM
 756                        */
 757                       if (!nreq)
 758                         {
 759                           *rc = GPG_ERR_ENOMEM;
 760                           return NULL;
 761                         }
 762 #endif
 763
 764                       tmp = *req;
 765                       tmp = strv_catv (nreq, tmp + 1);
 766                       strv_free (nreq);
 767
 768                       if (!tmp)
 769                         {
 770                           xfree (root);
 771                           *rc = GPG_ERR_ENOMEM;
 772                           return NULL;
 773                         }
 774
 775                       strv_free (*req);
 776                       *req = tmp;
 777                     }
 778                   else
 779                     {
 780                       if (strv_printf (&tmp, "%s", content) == 0)
 781                         {
 782                           xmlFree (content);
 783                           xfree (root);
 784                           *rc = GPG_ERR_ENOMEM;
 785                           return NULL;
 786                         }
 787
 788                       xmlFree (content);
 789                       nreq = *req;
 790                       nreq = strv_catv (tmp, nreq + 1);
 791                       strv_free (tmp);
 792
 793                       if (!nreq)
 794                         {
 795                           *rc = GPG_ERR_ENOMEM;
 796                           xfree (root);
 797                           return NULL;
 798                         }
 799
 800                       strv_free (*req);
 801                       *req = nreq;
 802                     }
 803
 804                   xfree (root);
 805                   n =
 806                     find_root_element (client, doc, req, rc, target,
 807                                        recursion_depth, 0);
 808                   return n;
 809                 }
 810
 811               xmlFree (content);
 812             }
 813         }
 814
 815       n = n->next;
 816     }
 817
 818   xfree (root);
 819   *rc = GPG_ERR_ELEMENT_NOT_FOUND;
 820   return NULL;
 821 }
 822
 823 xmlNodePtr
 824 find_element (struct client_s *client, xmlNodePtr node, char *element,
 825               xmlNodePtr stop, gpg_error_t *rc)
 826 {
 827   xmlNodePtr n;
 828
 829   *rc = 0;
 830
 831   if (!node || !element)
 832     return NULL;
 833
 834   for (n = node; n; n = n->next)
 835     {
 836       if (n->type != XML_ELEMENT_NODE)
 837         continue;
 838
 839       if (n == stop)
 840         break;
 841
 842       xmlChar *a = node_has_attribute (n, (xmlChar *) "_name");
 843
 844       if (a && xmlStrEqual (a, (xmlChar *) element))
 845         {
 846           xmlFree (a);
 847
 848           *rc = acl_check(client, n);
 849           if (*rc)
 850               n = NULL;
 851
 852           return n;
 853         }
 854
 855       xmlFree (a);
 856     }
 857
 858   return NULL;
 859 }
 860
 861 xmlChar *
 862 node_has_attribute (xmlNodePtr n, xmlChar * attr)
 863 {
 864   xmlAttrPtr a = xmlHasProp (n, attr);
 865
 866   if (!a)
 867     return NULL;
 868
 869   if (!a->children || !a->children->content)
 870     return NULL;
 871
 872   return xmlGetProp (n, attr);
 873 }
 874
 875 static int
 876 element_to_literal (char **element)
 877 {
 878   char *p = str_asprintf ("!%s", *element);
 879
 880   if (!p)
 881     return 0;
 882
 883   xfree (*element);
 884   *element = p;
 885   return 1;
 886 }
 887
 888 /* Resolves elements in 'req' one at a time. It's recursive in case of
 889  * "target" attributes. */
 890 xmlNodePtr
 891 find_elements (struct client_s *client, xmlDocPtr doc, xmlNodePtr node,
 892                char **req, gpg_error_t * rc, int *target,
 893                xmlNodePtr (*found_fn) (struct client_s *, xmlNodePtr, char **,
 894                                        gpg_error_t *, char **, void *),
 895                xmlNodePtr (*not_found_fn) (struct client_s *, xmlNodePtr,
 896                                            char **, gpg_error_t *, void *),
 897                int is_list_command, int recursion_depth, void *data, int stop)
 898 {
 899   xmlNodePtr n, last, last_node;
 900   char **p;
 901   int found = 0;
 902
 903   *rc = 0;
 904   recursion_depth++;
 905
 906   if (max_recursion_depth >= 1 && recursion_depth > max_recursion_depth)
 907     {
 908       xmlChar *t = xmlGetNodePath (node);
 909
 910       log_write ("%s: %s", pwmd_strerror (GPG_ERR_ELOOP), t);
 911       xmlFree (t);
 912       recursion_depth--;
 913       *rc = GPG_ERR_ELOOP;
 914       return NULL;
 915     }
 916
 917   for (last_node = last = n = node, p = req; *p; p++)
 918     {
 919       xmlNodePtr tmp;
 920       char *t;
 921       int literal;
 922
 923       if (!*(*p))
 924         {
 925           *rc = GPG_ERR_ELEMENT_NOT_FOUND;
 926           return NULL;
 927         }
 928
 929       t = str_dup (*p);
 930       if (!t)
 931         {
 932           *rc = GPG_ERR_ENOMEM;
 933           return NULL;
 934         }
 935
 936       literal = is_literal_element (&t);
 937       n = find_element (client, last, t, NULL, rc);
 938       xfree (t);
 939
 940       if (*rc && *rc != GPG_ERR_ELEMENT_NOT_FOUND)
 941         return NULL;
 942
 943       if (!n)
 944         {
 945           if (not_found_fn)
 946             return not_found_fn (client, found ? last_node : last_node->parent,
 947                                  p, rc, data);
 948
 949           if (!*rc)
 950             *rc = GPG_ERR_ELEMENT_NOT_FOUND;
 951
 952           return NULL;
 953         }
 954
 955       last = n->children;
 956       last_node = n;
 957       found = 1;
 958
 959       if (literal == 0)
 960         {
 961           xmlChar *content = node_has_attribute (n, (xmlChar *) "target");
 962           char **nreq = NULL, **nnreq;
 963
 964           if (!content)
 965             {
 966               if (is_list_command == 1)
 967                 {
 968                   if (element_to_literal (&(*p)) == 0)
 969                     {
 970                       *rc = GPG_ERR_ENOMEM;
 971                       return NULL;
 972                     }
 973                 }
 974
 975               continue;
 976             }
 977
 978           if (target)
 979             *target = 1;
 980
 981           if (!*(p + 1) && stop)
 982             {
 983               xmlFree (content);
 984               return n;
 985             }
 986
 987           if (strchr ((char *) content, '\t') != NULL)
 988             {
 989               if ((nreq = str_split ((char *) content, "\t", 0)) == NULL)
 990                 {
 991                   xmlFree (content);
 992                   *rc = GPG_ERR_INV_VALUE;
 993                   return NULL;
 994                 }
 995             }
 996           else
 997             {
 998               if ((nreq = str_split ((char *) content, " ", 0)) == NULL)
 999                 {
1000                   xmlFree (content);
1001                   *rc = GPG_ERR_INV_VALUE;
1002                   return NULL;
1003                 }
1004             }
1005
1006           xmlFree (content);
1007           tmp = find_root_element (client, doc, &nreq, rc, target, 0, 0);
1008
1009           if (!tmp)
1010             {
1011               strv_free (nreq);
1012               return NULL;
1013             }
1014
1015           if (found_fn)
1016             {
1017               found_fn (client, tmp, nreq, rc, p + 1, data);
1018
1019               if (*rc)
1020                 {
1021                   strv_free (nreq);
1022                   return NULL;
1023                 }
1024             }
1025
1026           if (!*(nreq + 1) && !*(p + 1))
1027             {
1028               strv_free (nreq);
1029               return tmp;
1030             }
1031
1032           nnreq = strv_catv (nreq + 1, p + 1);
1033           strv_free (nreq);
1034
1035           // FIXME ENOMEM
1036           if (!nnreq || !*nnreq)
1037             {
1038               if (nnreq)
1039                 strv_free (nnreq);
1040
1041               return tmp;
1042             }
1043
1044           if (tmp->children)
1045             n = find_elements (client, doc, tmp->children, nnreq, rc, NULL,
1046                                found_fn, not_found_fn, is_list_command,
1047                                recursion_depth, data, stop);
1048           else
1049             {
1050               strv_free (nnreq);
1051
1052               if (not_found_fn)
1053                 return not_found_fn (client, tmp, p + 1, rc, data);
1054
1055               *rc = GPG_ERR_ELEMENT_NOT_FOUND;
1056               return NULL;
1057             }
1058
1059           if (*(p + 1))
1060             {
1061               char **zz = p + 1, **qq = nnreq;
1062
1063               if (strv_length (nnreq) > strv_length (p + 1))
1064                 qq = nnreq + 1;
1065
1066               for (; *qq && *zz; zz++)
1067                 {
1068                   xfree (*zz);
1069                   *zz = str_dup (*qq++);
1070
1071                   if (!*zz)
1072                     {
1073                       *rc = GPG_ERR_ENOMEM;
1074                       n = NULL;
1075                       break;
1076                     }
1077                 }
1078             }
1079
1080           strv_free (nnreq);
1081           return n;
1082         }
1083     }
1084
1085   return n;
1086 }
1087
1088 static int
1089 update_element_list (struct element_list_s *elements)
1090 {
1091   char *line;
1092   struct slist_s *l;
1093
1094   if (!elements || !elements->elements)
1095     return 1;
1096
1097   line = strv_join ("\t", elements->elements);
1098
1099   if (!line)
1100     return 0;
1101
1102   strv_free (elements->elements);
1103   elements->elements = NULL;
1104   l = slist_append (elements->list, line);
1105
1106   if (!l)
1107     return 0;
1108
1109   elements->list = l;
1110   return 1;
1111 }
1112
1113 static gpg_error_t
1114 path_list_recurse (struct client_s *client, xmlDocPtr doc, xmlNodePtr node,
1115                    struct element_list_s *elements)
1116 {
1117   gpg_error_t rc = 0;
1118   xmlNodePtr n;
1119   gpg_error_t error_flag = 0;
1120
1121   for (n = node; n; n = n->next)
1122     {
1123       xmlChar *target = NULL;
1124       xmlChar *a = node_has_attribute (n, (xmlChar *) "_name");
1125       int err = 0;
1126
1127       rc = 0;
1128       if (!a)
1129         continue;
1130
1131       if (n->type != XML_ELEMENT_NODE)
1132         goto children;
1133
1134       rc = acl_check(client, n);
1135
1136       if (elements->verbose)
1137         {
1138           if (strv_printf
1139               (&elements->elements, "%s\t!%s%s%s", elements->prefix, a,
1140                !rc && find_element_node (n->children) ? " +" : "",
1141                rc == GPG_ERR_EPERM ? " P" : "") == 0)
1142             {
1143               xmlFree (a);
1144               return GPG_ERR_ENOMEM;
1145             }
1146         }
1147       else
1148         if (strv_printf (&elements->elements, "%s\t!%s", elements->prefix, a)
1149             == 0)
1150         {
1151           xmlFree (a);
1152           return GPG_ERR_ENOMEM;
1153         }
1154
1155       if (update_element_list (elements) == 0)
1156         {
1157           xmlFree (a);
1158           return GPG_ERR_ENOMEM;
1159         }
1160
1161
1162       if (rc)
1163         {
1164           xmlFree (a);
1165           return rc == GPG_ERR_EPERM ? 0 : rc;
1166         }
1167
1168       target = node_has_attribute (n, (xmlChar *) "target");
1169       if (target)
1170         {
1171           char *tmp;
1172           char *save = elements->prefix;
1173           int r = elements->resolving;
1174           char **req = NULL;
1175           xmlNodePtr tnode;
1176           struct string_s *realpath = NULL;
1177
1178           tnode = resolve_path (client, doc, target, &req, &rc);
1179           if (rc == GPG_ERR_ELOOP || rc == GPG_ERR_ELEMENT_NOT_FOUND
1180               || rc == GPG_ERR_EPERM)
1181             {
1182               if (rc == GPG_ERR_ELOOP)
1183                 {
1184                   xmlChar *t = xmlGetNodePath (n);
1185
1186                   log_write ("%s: %s", pwmd_strerror (GPG_ERR_ELOOP), t);
1187                   xmlFree (t);
1188                 }
1189
1190               if (elements->verbose)
1191                 {
1192                   strv_printf (&elements->elements, "%s\t%s %s",
1193                                elements->prefix, a,
1194                                rc == GPG_ERR_ELOOP ? "O" :
1195                                rc == GPG_ERR_EPERM ? "P" : "E");
1196                   error_flag = err = rc;
1197                   rc = 0;
1198                   goto update;
1199                 }
1200             }
1201
1202           if (!elements->verbose && rc)
1203             {
1204               xmlFree (a);
1205               xmlFree (target);
1206               return rc;
1207             }
1208
1209           if (elements->with_target)
1210             {
1211               rc = build_realpath (client, doc, (char *) target, &realpath);
1212               if (rc)
1213                 {
1214                   xmlFree (a);
1215                   xmlFree (target);
1216                   return rc;
1217                 }
1218
1219               realpath = string_prepend (realpath, "T ");
1220             }
1221
1222           if (elements->verbose)
1223             {
1224               if (!strv_printf (&elements->elements, "%s\t%s%s%s%s",
1225                                 elements->prefix, a,
1226                                 (tnode && find_element_node (tnode->children))
1227                                 || realpath ? " " : "", tnode
1228                                 && find_element_node (tnode->children) ? "+" :
1229                                 "", realpath ? realpath->str : ""))
1230                 {
1231                   xmlFree (a);
1232                   xmlFree (target);
1233                   return GPG_ERR_ENOMEM;
1234                 }
1235             }
1236           else
1237             if (!strv_printf
1238                 (&elements->elements, "%s\t%s", elements->prefix, a))
1239             {
1240               xmlFree (a);
1241               xmlFree (target);
1242               return GPG_ERR_ENOMEM;
1243             }
1244
1245         update:
1246           if (realpath)
1247             string_free (realpath, 1);
1248
1249           tmp = strv_join ("\t", elements->elements);
1250
1251           if (!tmp)
1252             {
1253               xmlFree (a);
1254               xmlFree (target);
1255               return GPG_ERR_ENOMEM;
1256             }
1257
1258           if (update_element_list (elements) == 0)
1259             {
1260               xfree (tmp);
1261               xmlFree (a);
1262               xmlFree (target);
1263               return GPG_ERR_ENOMEM;
1264             }
1265
1266           if (!err && elements->recurse)
1267             {
1268               /* Prune element flags. */
1269               if (elements->verbose && strchr (tmp, ' '))
1270                 {
1271                   char *p;
1272
1273                   for (p = tmp; *p; p++)
1274                     {
1275                       if (*p == ' ')
1276                         {
1277                           *p = 0;
1278                           break;
1279                         }
1280                     }
1281                 }
1282
1283               elements->prefix = tmp;
1284               elements->resolving = 1;
1285               rc = create_path_list (client, doc, elements, (char *) target);
1286               elements->resolving = r;
1287               elements->prefix = save;
1288
1289               if (rc && gpg_err_code (rc) != GPG_ERR_ELOOP)
1290                 {
1291                   xfree (tmp);
1292                   xmlFree (target);
1293                   xmlFree (a);
1294                   return rc;
1295                 }
1296
1297               error_flag = err = rc;
1298               rc = 0;
1299             }
1300
1301           xfree (tmp);
1302           xmlFree (target);
1303         }
1304
1305     children:
1306       if (n->children && elements->recurse && err != GPG_ERR_ELOOP)
1307         {
1308           char *tmp = str_asprintf ("%s\t!%s", elements->prefix, a);
1309           char *save = elements->prefix;
1310
1311           if (!tmp)
1312             {
1313               xmlFree (a);
1314               return GPG_ERR_ENOMEM;
1315             }
1316
1317           elements->prefix = tmp;
1318           rc = path_list_recurse (client, doc, n->children, elements);
1319           xfree (elements->prefix);
1320           elements->prefix = save;
1321
1322           if (rc)
1323             {
1324               xmlFree (a);
1325               return rc;
1326             }
1327         }
1328
1329       xmlFree (a);
1330     }
1331
1332   return error_flag == GPG_ERR_ELOOP ? error_flag : rc;
1333 }
1334
1335 gpg_error_t
1336 add_attribute (xmlNodePtr node, const char *name, const char *value)
1337 {
1338   char *buf;
1339   gpg_error_t rc;
1340
1341   if (name && !xmlSetProp (node, (xmlChar *) name, (xmlChar *) value))
1342     return GPG_ERR_BAD_DATA;
1343
1344   if (name && xmlStrEqual ((xmlChar *) name, (xmlChar *) "_mtime"))
1345     return 0;
1346
1347   buf = str_asprintf ("%li", time (NULL));
1348   rc = add_attribute (node, "_mtime", buf);
1349   xfree (buf);
1350   return rc;
1351 }
1352
1353 /*
1354  * From the element path 'path', find sub-nodes and append them to the list.
1355  */
1356 gpg_error_t
1357 create_path_list (struct client_s *client, xmlDocPtr doc,
1358                   struct element_list_s * elements, char *path)
1359 {
1360   gpg_error_t rc;
1361   char **req, **req_orig;
1362   xmlNodePtr n;
1363   int a_target = 0;
1364
1365   req = str_split (path, "\t", 0);
1366   if (!req)
1367     {
1368       req = str_split (path, " ", 0);
1369       if (!req)
1370         return GPG_ERR_SYNTAX;
1371     }
1372
1373   req_orig = strv_dup (req);
1374   if (!req_orig)
1375     {
1376       rc = GPG_ERR_ENOMEM;
1377       goto fail;
1378     }
1379
1380   n = find_root_element (client, doc, &req, &rc, &a_target, 0, 0);
1381   if ((rc == GPG_ERR_ELEMENT_NOT_FOUND || rc == GPG_ERR_ELOOP
1382        || rc == GPG_ERR_EPERM)
1383       && elements->verbose && a_target)
1384     {
1385       if (rc != GPG_ERR_EPERM)
1386         rc = 0;
1387
1388       goto done;
1389     }
1390
1391   if (rc == GPG_ERR_EPERM)
1392     goto done;
1393
1394   if (!n && rc == GPG_ERR_ELEMENT_NOT_FOUND && elements->resolving == 1)
1395     {
1396       rc = 0;
1397       goto fail;
1398     }
1399   else if (!n)
1400     goto fail;
1401
1402   if (a_target == 1)
1403     {
1404       xfree (*req);
1405       *req = str_dup (*req_orig);
1406     }
1407
1408   if (*(req + 1))
1409     {
1410       int e_target = 0;
1411
1412       n =
1413         find_elements (client, doc, n->children, req + 1, &rc, &e_target,
1414                        NULL, NULL, 1, 0, NULL, 0);
1415
1416       if (!n && rc == GPG_ERR_ELEMENT_NOT_FOUND && elements->resolving == 1)
1417         {
1418           rc = 0;
1419           goto fail;
1420         }
1421       else if (!n)
1422         goto fail;
1423     }
1424
1425 done:
1426   if (!elements->prefix)
1427     {
1428       /*
1429        * FIXME
1430        *
1431        * If any req_orig element contains no target the element should be
1432        * prefixed with the literal character. Not really crucial if the
1433        * client isn't human because child elements are prefixed for the
1434        * current path. But may be confusing if editing by hand.
1435        */
1436       elements->prefix = strv_join ("\t", req_orig);
1437
1438       if (!elements->prefix)
1439         {
1440           rc = GPG_ERR_ENOMEM;
1441           goto fail;
1442         }
1443
1444       if (elements->verbose)
1445         {
1446           int ret;
1447           struct string_s *realpath = NULL;
1448           gpg_error_t allowed = rc;
1449
1450           rc = 0;
1451
1452           if (!allowed && a_target && elements->with_target)
1453             {
1454               rc = build_realpath (client, doc, path, &realpath);
1455               if (rc)
1456                 goto fail;
1457
1458               realpath = string_prepend (realpath, "T ");
1459             }
1460
1461           ret = strv_printf (&elements->elements, "%s%s%s%s%s",
1462                              elements->prefix,
1463                              (!allowed && n && find_element_node (n->children))
1464                              || realpath ? " " : "",
1465                              (!allowed && n && find_element_node (n->children)) ? "+" : "",
1466                              !allowed && realpath ? realpath->str : "",
1467                              allowed ? " P" : "");
1468           string_free (realpath, 1);
1469           if (!ret)
1470             {
1471               rc = GPG_ERR_ENOMEM;
1472               goto fail;
1473             }
1474         }
1475       else if (strv_printf (&elements->elements, "%s", elements->prefix) == 0)
1476         {
1477           rc = GPG_ERR_ENOMEM;
1478           goto fail;
1479         }
1480
1481       if (update_element_list (elements) == 0)
1482         {
1483           rc = GPG_ERR_ENOMEM;
1484           goto fail;
1485         }
1486     }
1487
1488   rc = path_list_recurse (client, doc, n ? n->children : n, elements);
1489
1490 fail:
1491   if (req_orig)
1492     strv_free (req_orig);
1493
1494   strv_free (req);
1495   return rc;
1496 }
1497
1498 gpg_error_t
1499 recurse_xpath_nodeset (struct client_s *client, xmlDocPtr doc,
1500                        xmlNodeSetPtr nodes, xmlChar * value,
1501                        xmlBufferPtr * result, int cmd, const xmlChar * attr)
1502 {
1503   int i = value ? nodes->nodeNr - 1 : 0;
1504   xmlBufferPtr buf;
1505
1506   buf = xmlBufferCreate ();
1507
1508   if (!buf)
1509     return GPG_ERR_ENOMEM;
1510
1511   for (; value ? i >= 0 : i < nodes->nodeNr; value ? i-- : i++)
1512     {
1513       xmlNodePtr n = nodes->nodeTab[i];
1514       gpg_error_t rc;
1515
1516       if (!n)
1517         continue;
1518
1519       if (!value && !attr)
1520         {
1521           if (xmlNodeDump (buf, doc, n, 0, 0) == -1)
1522             {
1523               *result = buf;
1524               return GPG_ERR_BAD_DATA;
1525             }
1526
1527           continue;
1528         }
1529
1530       if (!attr)
1531         {
1532           xmlNodeSetContent (n, value);
1533           rc = update_element_mtime (n);
1534
1535           if (rc)
1536             return rc;
1537         }
1538       else
1539         {
1540           if (!cmd)
1541             rc = add_attribute (n, (char *) attr, (char *) value);
1542           else
1543             rc = delete_attribute (client, n, attr);
1544
1545           if (rc)
1546             return rc;
1547         }
1548     }
1549
1550   *result = buf;
1551   return 0;
1552 }
1553
1554 static gpg_error_t
1555 convert_root_element (struct client_s *client, xmlNodePtr n)
1556 {
1557   xmlChar *a = xmlGetProp (n, (xmlChar *) "_name");
1558   gpg_error_t rc;
1559
1560   if (a)
1561     {
1562       xmlFree (a);
1563       xmlChar *t = xmlGetNodePath (n);
1564
1565       log_write (_
1566                  ("An existing \"_name\" attribute already exists. Please rename this attribute before converting. Path is: %s"),
1567                  t);
1568       xmlFree (t);
1569       return GPG_ERR_AMBIGUOUS_NAME;
1570     }
1571
1572   a = xmlGetProp (n, (xmlChar *) "name");
1573
1574   if (a)
1575     {
1576       rc = add_attribute (n, "_name", (char *) a);
1577       xmlFree (a);
1578
1579       if (rc)
1580         return rc;
1581
1582       rc = delete_attribute (client, n, (xmlChar *) "name");
1583
1584       if (rc)
1585         return rc;
1586
1587       xmlNodeSetName (n, (xmlChar *) "element");
1588     }
1589
1590   return 0;
1591 }
1592
1593 gpg_error_t
1594 delete_attribute (struct client_s *client, xmlNodePtr n, const xmlChar * name)
1595 {
1596   xmlAttrPtr a;
1597   gpg_error_t rc = 0;
1598
1599   if ((a = xmlHasProp (n, name)) == NULL)
1600     return GPG_ERR_NOT_FOUND;
1601
1602   if (xmlRemoveProp (a) == -1)
1603     return GPG_ERR_BAD_DATA;
1604
1605   if (client && xmlStrEqual (name, (xmlChar *) "_acl"))
1606     {
1607       char *user = create_acl_user (client);
1608
1609       rc = add_attribute (n, (char *) "_acl", user);
1610       xfree (user);
1611
1612       if (rc)
1613         return rc;
1614     }
1615
1616   return update_element_mtime (n);
1617 }
1618
1619 static gpg_error_t
1620 convert_elements_recurse (struct client_s *client, xmlDocPtr doc,
1621                           xmlNodePtr n, unsigned depth)
1622 {
1623   gpg_error_t rc;
1624
1625   depth++;
1626
1627   for (n = n->children; n; n = n->next)
1628     {
1629       if (n->type == XML_ELEMENT_NODE)
1630         {
1631           if (depth > 1)
1632             {
1633               xmlChar *a = NULL;
1634
1635               if (xmlStrEqual (n->name, (xmlChar *) "element"))
1636                 {
1637                   xmlChar *t = xmlGetNodePath (n);
1638
1639                   log_write (_
1640                              ("An existing \"element\" already exists. Please rename this element before converting. Path is: %s"),
1641                              t);
1642                   xmlFree (t);
1643                   return GPG_ERR_AMBIGUOUS_NAME;
1644                 }
1645
1646               a = xmlGetProp (n, (xmlChar *) "_name");
1647               if (a)
1648                 {
1649                   xmlFree (a);
1650                   xmlChar *t = xmlGetNodePath (n);
1651
1652                   log_write (_
1653                              ("An existing \"_name\" attribute already exists. Please rename this attribute before converting. Path is: %s"),
1654                              t);
1655                   xmlFree (t);
1656                   return GPG_ERR_AMBIGUOUS_NAME;
1657                 }
1658
1659               xmlChar *tmp = xmlStrdup (n->name);
1660
1661               if (!tmp)
1662                 return GPG_ERR_ENOMEM;
1663
1664               xmlNodeSetName (n, (xmlChar *) "element");
1665               rc = add_attribute (n, "_name", (char *) tmp);
1666               xmlFree (tmp);
1667
1668               if (rc)
1669                 return rc;
1670             }
1671           else
1672             {
1673               rc = convert_root_element (client, n);
1674
1675               if (rc)
1676                 return rc;
1677             }
1678         }
1679
1680       if (n->children)
1681         {
1682           rc = convert_elements_recurse (client, doc, n, depth);
1683
1684           if (rc)
1685             return rc;
1686         }
1687     }
1688
1689   return 0;
1690 }
1691
1692 /* Renames ALL elements to the new "element" name. Existing element names are
1693  * stored as an attribute "_name". This was introduced in pwmd 2.12 so
1694  * elements can contain common characters that the XML parser barfs on (an
1695  * email address for example. */
1696 gpg_error_t
1697 convert_pre_212_elements (xmlDocPtr doc)
1698 {
1699   xmlNodePtr n = xmlDocGetRootElement (doc);
1700
1701   log_write (_("Converting pre 2.12 data file..."));
1702   return convert_elements_recurse (NULL, doc, n, 0);
1703 }
1704
1705 gpg_error_t
1706 validate_import (xmlNodePtr node)
1707 {
1708   gpg_error_t rc = 0;
1709
1710   if (!node)
1711     return 0;
1712
1713   for (xmlNodePtr n = node; n; n = n->next)
1714     {
1715       if (n->type == XML_ELEMENT_NODE)
1716         {
1717           if (xmlStrEqual (n->name, (xmlChar *) "element"))
1718             {
1719               xmlChar *a = xmlGetProp (n, (xmlChar *) "_name");
1720
1721               if (!a)
1722                 {
1723                   xmlChar *t = xmlGetNodePath (n);
1724
1725                   log_write (_("Missing attribute '_name' at %s."), t);
1726                   xmlFree (t);
1727                   return GPG_ERR_INV_VALUE;
1728                 }
1729
1730               if (!valid_xml_element (a))
1731                 {
1732                   xmlChar *t = xmlGetNodePath (n);
1733
1734                   log_write (_("'%s' is not a valid element name at %s."), a,
1735                              t);
1736                   xmlFree (a);
1737                   xmlFree (t);
1738                   return GPG_ERR_INV_VALUE;
1739                 }
1740
1741               xmlFree (a);
1742               a = xmlGetProp (n, (xmlChar *) "_ctime");
1743               if (!a)
1744                 attr_ctime (n);
1745
1746               xmlFree (a);
1747               a = xmlGetProp (n, (xmlChar *) "_mtime");
1748               if (!a)
1749                 update_element_mtime (n);
1750               xmlFree (a);
1751             }
1752           else
1753             {
1754               xmlChar *t = xmlGetNodePath (n);
1755
1756               log_write (_("Warning: unknown element '%s' at %s. Ignoring."),
1757                          n->name, t);
1758               xmlFree (t);
1759               continue;
1760             }
1761         }
1762
1763       if (n->children)
1764         {
1765           rc = validate_import (n->children);
1766
1767           if (rc)
1768             return rc;
1769         }
1770     }
1771
1772   return rc;
1773 }
1774
1775 gpg_error_t
1776 update_element_mtime (xmlNodePtr n)
1777 {
1778   return add_attribute (n, NULL, NULL);
1779 }
1780
1781 gpg_error_t
1782 unlink_node (xmlNodePtr n)
1783 {
1784   gpg_error_t rc = 0;
1785
1786   if (!n)
1787     return rc;
1788
1789   if (n->parent)
1790     rc = update_element_mtime (n->parent);
1791
1792   xmlUnlinkNode (n);
1793   return rc;
1794 }
1795
1796 gpg_error_t
1797 parse_doc (const char *xml, size_t len, xmlDocPtr *result)
1798 {
1799   xmlDocPtr doc;
1800
1801   xmlResetLastError ();
1802   doc = xmlReadMemory (xml, len, NULL, "UTF-8", XML_PARSE_NOBLANKS);
1803   if (!doc && xmlGetLastError ())
1804     return GPG_ERR_BAD_DATA;
1805
1806   *result = doc;
1807   return !doc ? GPG_ERR_ENOMEM : 0;
1808 }
1809
1810 static xmlNodePtr
1811 realpath_elements_cb (struct client_s *client, xmlNodePtr node, char **target,
1812                       gpg_error_t * rc, char **req_orig, void *data)
1813 {
1814   char *path = *(char **) data;
1815   char *tmp = NULL, *result;
1816
1817   if (path)
1818     {
1819       xfree (path);
1820       *(char **) data = NULL;
1821     }
1822
1823   path = strv_join ("\t", target);
1824
1825   if (!path)
1826     {
1827       *rc = GPG_ERR_ENOMEM;
1828       return NULL;
1829     }
1830
1831   if (req_orig)
1832     {
1833       tmp = strv_join ("\t", req_orig);
1834
1835       if (!tmp)
1836         {
1837           xfree (path);
1838           *rc = GPG_ERR_ENOMEM;
1839           return NULL;
1840         }
1841     }
1842
1843   if (tmp && *tmp)
1844     result = str_asprintf ("%s\t%s", path, tmp);
1845   else
1846     result = str_dup (path);
1847
1848   if (!result)
1849     {
1850       *rc = GPG_ERR_ENOMEM;
1851       xfree (path);
1852       xfree (tmp);
1853       return NULL;
1854     }
1855
1856   xfree (path);
1857   xfree (tmp);
1858   *(char **) data = result;
1859   return node;
1860 }
1861
1862 gpg_error_t
1863 build_realpath (struct client_s *client, xmlDocPtr doc, char *line,
1864                 struct string_s ** result)
1865 {
1866   gpg_error_t rc;
1867   char **req;
1868   char *t;
1869   int i;
1870   xmlNodePtr n;
1871   struct string_s *string;
1872   char *rp = NULL;
1873
1874   if (strchr (line, '\t') != NULL)
1875     {
1876       if ((req = str_split (line, "\t", 0)) == NULL)
1877         return GPG_ERR_SYNTAX;
1878     }
1879   else
1880     {
1881       if ((req = str_split (line, " ", 0)) == NULL)
1882         return GPG_ERR_SYNTAX;
1883     }
1884
1885   n = find_root_element (client, doc, &req, &rc, NULL, 0, 0);
1886   if (!n)
1887     {
1888       strv_free (req);
1889       return rc;
1890     }
1891
1892   rp = strv_join ("\t", req);
1893   if (!rp)
1894     {
1895       strv_free (req);
1896       return GPG_ERR_ENOMEM;
1897     }
1898
1899   if (req[1])
1900     {
1901       n = find_elements (client, doc, n->children, req + 1, &rc, NULL,
1902                          realpath_elements_cb, NULL, 0, 0, &rp, 0);
1903       if (!n)
1904         {
1905           xfree (rp);
1906           strv_free (req);
1907           return rc;
1908         }
1909     }
1910
1911   string = string_new (rp);
1912   xfree (rp);
1913   strv_free (req);
1914   if (!string)
1915     return GPG_ERR_ENOMEM;
1916
1917 again:
1918   for (i = 0, t = string->str + i; *t; t++, i++)
1919     {
1920       if ((!i && *t != '!') || (*t == '\t' && *(t + 1) && *(t + 1) != '!'))
1921         {
1922           struct string_s *s = string_insert_c (string, !i ? i++ : ++i, '!');
1923
1924           if (!s)
1925             {
1926               string_free (string, 1);
1927               return GPG_ERR_ENOMEM;
1928             }
1929
1930           string = s;
1931           goto again;
1932         }
1933     }
1934
1935   *result = string;
1936   return rc;
1937 }
1938
1939 #if 0
1940 static char *
1941 node_to_element_path (xmlNodePtr node)
1942 {
1943   xmlNodePtr n;
1944   struct string_s *str = string_new ("");
1945   char *result;
1946
1947   for (n = node; n; n = n->parent)
1948     {
1949       xmlNodePtr child;
1950
1951       for (child = n; child; child = child->next)
1952         {
1953           if (child->type != XML_ELEMENT_NODE)
1954             continue;
1955
1956           xmlChar *name = node_has_attribute (n, (xmlChar *) "_name");
1957           if (name)
1958             {
1959               str = string_prepend (str, (char *) name);
1960               xmlFree (name);
1961               name = node_has_attribute (n, (xmlChar *) "target");
1962               if (name)
1963                 str = string_prepend (str, "\t");
1964               else
1965                 str = string_prepend (str, "\t!");
1966               xmlFree (name);
1967             }
1968           break;
1969         }
1970     }
1971
1972   str = string_erase (str, 0, 1);
1973   result = str->str;
1974   string_free (str, 0);
1975   return result;
1976 }
1977 #endif
1978
1979 /*
1980  * Recurse the element tree beginning at 'node' and find elements who point
1981  * back to 'src' or 'dst'. Also follows target attributes.
1982  */
1983 static gpg_error_t
1984 find_child_to_target (struct client_s *client, xmlDocPtr doc, xmlNodePtr node,
1985                       xmlNodePtr src, xmlNodePtr dst, unsigned depth,
1986                       int is_target)
1987 {
1988   xmlNodePtr n;
1989   gpg_error_t rc = 0;
1990
1991   if (max_recursion_depth >= 1 && depth > max_recursion_depth)
1992     return gpg_error (GPG_ERR_ELOOP);
1993
1994   for (n = node; n; n = n->next)
1995     {
1996       xmlChar *target;
1997
1998       if (n->type != XML_ELEMENT_NODE)
1999         continue;
2000
2001       if (n == src || n == dst)
2002         return GPG_ERR_ELOOP;
2003
2004       target = node_has_attribute (n, (xmlChar *) "target");
2005       if (target)
2006         {
2007           xmlNodePtr tmp;
2008           char **result = NULL;
2009
2010           tmp = resolve_path (client, doc, target, &result, &rc);
2011           xmlFree (target);
2012           strv_free (result);
2013           if (!rc)
2014             {
2015               rc = find_child_to_target (client, doc, tmp, src, dst, ++depth,
2016                                          1);
2017               depth--;
2018             }
2019
2020           if (rc && gpg_err_code (rc) != GPG_ERR_ELEMENT_NOT_FOUND)
2021             return rc;
2022
2023           if (is_target)
2024             break;
2025
2026           continue;
2027         }
2028
2029       if (n->children)
2030         {
2031           rc = find_child_to_target (client, doc, n->children, src, dst,
2032                                      ++depth,0);
2033           depth--;
2034           if (rc)
2035             return rc;
2036         }
2037
2038       if (is_target)
2039         break;
2040     }
2041
2042   return rc;
2043 }
2044
2045 static gpg_error_t
2046 find_child_of_parent (xmlDocPtr doc, xmlNodePtr src, xmlNodePtr dst)
2047 {
2048   xmlNodePtr n;
2049   gpg_error_t rc = 0;
2050
2051   for (n = src; n; n = n->next)
2052     {
2053       if (n->type != XML_ELEMENT_NODE)
2054         continue;
2055
2056       if (n == dst)
2057         {
2058           rc = GPG_ERR_ELOOP;
2059           break;
2060         }
2061
2062       rc = find_child_of_parent (doc, n->children, dst);
2063     }
2064
2065   return rc;
2066 }
2067
2068 static gpg_error_t
2069 find_parent_of_child (xmlDocPtr doc, xmlNodePtr node, xmlNodePtr dst)
2070 {
2071   xmlNodePtr n;
2072   gpg_error_t rc = 0;
2073
2074   for (n = node; n; n = n->parent)
2075     {
2076       if (n->type != XML_ELEMENT_NODE)
2077         {
2078           xmlNodePtr tmp;
2079
2080           for (tmp = n->next; tmp; n = n->next)
2081             {
2082               if (n->type != XML_ELEMENT_NODE)
2083                 continue;
2084
2085               if (tmp == dst)
2086                 return GPG_ERR_ELOOP;
2087             }
2088         }
2089
2090       if (n == dst)
2091         return GPG_ERR_ELOOP;
2092     }
2093
2094   return rc;
2095 }
2096
2097 gpg_error_t
2098 validate_target_attribute (struct client_s *client, xmlDocPtr doc,
2099                            const char *src, xmlNodePtr dst_node)
2100 {
2101   gpg_error_t rc;
2102   xmlNodePtr src_node;
2103   char **src_req = NULL;
2104
2105   src_node = resolve_path (client, doc, (xmlChar *) src, &src_req, &rc);
2106   if (rc)
2107     goto fail;
2108
2109   /* A destination element is a child of the source element. */
2110   rc = find_child_of_parent (doc, src_node->children, dst_node);
2111   if (rc)
2112     goto fail;
2113
2114   /* The destination element is a parent of the source element. */
2115   rc = find_parent_of_child (doc, src_node->parent, dst_node);
2116   if (rc)
2117     goto fail;
2118
2119   /* A destination child element contains a target to the source element. */
2120   rc = find_child_to_target (client, doc, dst_node->children, src_node,
2121                              dst_node, 0, 0);
2122   if (rc)
2123     goto fail;
2124
2125 fail:
2126   strv_free (src_req);
2127   return rc;
2128 }
2129
2130 /* The owner of the element is the first user listed in the _acl attribute
2131  * list. acl_check() should be called before calling this function. An empty
2132  * ACL is an error if the client is not invoking_user.
2133  */
2134 gpg_error_t
2135 is_element_owner (struct client_s *client, xmlNodePtr n)
2136 {
2137   xmlChar *acl = node_has_attribute (n, (xmlChar *) "_acl");
2138   char **users;
2139   gpg_error_t rc = GPG_ERR_EPERM;
2140
2141   if (!acl || !*acl)
2142     {
2143       xmlFree (acl);
2144       return 0;
2145     }
2146
2147   users = str_split((char *)acl, ",", 0);
2148   if (users && *users)
2149     {
2150       char *user;
2151
2152 #ifdef WITH_GNUTLS
2153       if (client->thd->remote)
2154         user = str_asprintf ("#%s", client->thd->tls->fp);
2155       else
2156         user = get_username (client->thd->peer->uid);
2157 #else
2158       user = get_username (client->thd->peer->uid);
2159 #endif
2160
2161       rc = !strcmp (*users, user) ? 0 : GPG_ERR_EPERM;
2162       xfree (user);
2163     }
2164
2165   strv_free (users);
2166   return rc;
2167 }