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