src/xml.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2007 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <err.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <ctype.h>
  28 #include <glib.h>
  29 #include <gcrypt.h>
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include "pwmd_error.h"
  36 #include "xml.h"
  37
  38 void log_write(const gchar *fmt, ...);
  39 gboolean strv_printf(gchar ***array, const gchar *fmt, ...);
  40
  41 gboolean is_literal_element_str(gchar *element)
  42 {
  43     if (!element || !*element)
  44         return FALSE;
  45
  46     return *element == '!' ? TRUE : FALSE;
  47 }
  48
  49 /*
  50  * 'element' must be allocated.
  51  */
  52 gboolean is_literal_element(gchar **element)
  53 {
  54     gchar *p;
  55
  56     if (!element || !*element)
  57         return FALSE;
  58
  59     if (*(*element) == '!') {
  60         p = g_strdup(*element+1);
  61         g_free(*element);
  62         *element = p;
  63         return TRUE;
  64     }
  65
  66     return FALSE;
  67 }
  68
  69 /*
  70  * libxml doesn't seem to mind funny element names so we won't either.
  71  */
  72 gboolean valid_xml_element(xmlChar *element)
  73 {
  74     if (!element || !*element)
  75         return FALSE;
  76
  77     return TRUE;
  78 }
  79
  80 gpg_error_t new_account(xmlDocPtr doc, gchar *name)
  81 {
  82     xmlNodePtr root = xmlDocGetRootElement(doc);
  83     xmlAttrPtr a;
  84     xmlNodePtr n;
  85
  86     if (!name || !root)
  87         return EPWMD_LIBXML_ERROR;
  88
  89     /*
  90      * ! as the first character of an account name is bad. This character is
  91      * used to get an element path reguardless if there is a "target"
  92      * attribute.
  93      */
  94     if (*name == '!')
  95         return EPWMD_INVALID_ELEMENT;
  96
  97     n = xmlNewNode(NULL, (xmlChar *)"account");
  98     n = xmlAddChild(root, n);
  99     a = xmlNewProp(n, (xmlChar *)"name", (xmlChar *)name);
 100     return 0;
 101 }
 102
 103 gchar *new_document()
 104 {
 105     gchar *buf;
 106     const char *line =
 107             "<?xml version=\"1.0\"?>\n"
 108             "<!DOCTYPE accounts [\n"
 109             "<!ELEMENT accounts (account*)>\n"
 110             "<!ATTLIST account name CDATA #REQUIRED>\n"
 111             "]>\n"
 112             "<accounts/>";
 113
 114     if ((buf = gcry_malloc(strlen(line) + 1)) == NULL)
 115         return NULL;
 116
 117     strcpy(buf, line);
 118     return buf;
 119 }
 120
 121 gint sort_element_list(gconstpointer a, gconstpointer b)
 122 {
 123     gchar *ka, *kb;
 124     gint n;
 125
 126     ka = g_utf8_collate_key(a, -1);
 127     kb = g_utf8_collate_key(b, -1);
 128     n = strcmp(ka, kb);
 129     g_free(ka);
 130     g_free(kb);
 131     return n;
 132 }
 133
 134 /*
 135  * The "target" attribute is ignored here.
 136  */
 137 gpg_error_t list_accounts(xmlDocPtr doc, GString **result)
 138 {
 139     xmlNodePtr n = NULL, t;
 140     GSList *list = NULL;
 141     gchar *p;
 142     gint total, i;
 143     GString *string;
 144
 145     for (t = doc->children; t; t = t->next) {
 146         if (t->type == XML_ELEMENT_NODE) {
 147             if (xmlStrEqual(t->name, (xmlChar *)"accounts")) {
 148                 n = t;
 149                 break;
 150             }
 151         }
 152     }
 153
 154     if (!n || !n->children)
 155         return EPWMD_EMPTY_ELEMENT;
 156
 157     for (n = n->children; n; n = n->next) {
 158         xmlAttrPtr a;
 159
 160         if (n->type != XML_ELEMENT_NODE)
 161             continue;
 162
 163         a = xmlHasProp(n, (xmlChar *)"name");
 164
 165         if (!a || !a->children->content)
 166             continue;
 167
 168         list = g_slist_append(list, g_strdup(a->children->content));
 169     }
 170
 171     total = g_slist_length(list);
 172
 173     if (!total)
 174         return EPWMD_EMPTY_ELEMENT;
 175
 176     list = g_slist_sort(list, sort_element_list);
 177     string = g_string_new(NULL);
 178
 179     for (i = 0; i < total; i++) {
 180         gchar *tmp = g_slist_nth_data(list, i);
 181
 182         g_string_append_printf(string, "%s\n", tmp);
 183         g_free(tmp);
 184     }
 185
 186     g_slist_free(list);
 187     *result = string;
 188     return 0;
 189 }
 190
 191 gchar **split_input_line(gchar *str, gchar *delim, gint n)
 192 {
 193     if (!str || !*str)
 194         return NULL;
 195
 196     return g_strsplit(str, delim, n);
 197 }
 198
 199 static gchar **append_element_path(gchar **dst, gchar **src)
 200 {
 201     gchar **p;
 202     gint i;
 203     gchar **d;
 204
 205     if (!src)
 206         return NULL;
 207
 208     d = g_strdupv(dst);
 209     i = g_strv_length(d);
 210
 211     for (p = src; *p; p++) {
 212         d = g_realloc(d, (i + 2) * sizeof(gchar *));
 213         d[i++] = g_strdup(*p);
 214         d[i] = NULL;
 215     }
 216
 217     return d;
 218 }
 219
 220 /*
 221  * Alot like create_elements_cb() but doesn't use the last element of 'req' as
 222  * content but as an element.
 223  */
 224 xmlNodePtr create_target_elements_cb(xmlNodePtr node, gchar **path,
 225         gpg_error_t *error, void *data)
 226 {
 227     gint i;
 228     char **req = path;
 229
 230     if (xmlStrEqual(node->name, (xmlChar *)*req))
 231         req++;
 232
 233     for (i = 0; req[i]; i++) {
 234         xmlNodePtr n;
 235
 236         /*
 237          * Whitespace is allowed in values or attributes but not in element
 238          * names.
 239          */
 240         if (valid_xml_element((xmlChar *)req[i]) == FALSE) {
 241             *error = EPWMD_INVALID_ELEMENT;
 242             return NULL;
 243         }
 244
 245         if ((n = find_element(node, (xmlChar *)req[i])) == NULL) {
 246             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 247             node = xmlAddChild(node, n);
 248         }
 249         else
 250             node = n;
 251     }
 252
 253     return node;
 254 }
 255
 256 xmlNodePtr create_elements_cb(xmlNodePtr node, gchar **elements,
 257         gpg_error_t *error, void *data)
 258 {
 259     gint i;
 260     gchar **req = elements;
 261
 262     if (node->type == XML_TEXT_NODE)
 263         node = node->parent;
 264
 265     if (node->name && xmlStrEqual(node->name, (xmlChar *)*req))
 266         req++;
 267
 268     for (i = 0; req[i]; i++) {
 269         xmlNodePtr n;
 270
 271         /*
 272          * Whitespace is allowed in values or attributes but not in element
 273          * names.
 274          */
 275         if (req[i+1] && valid_xml_element((xmlChar *)req[i]) == FALSE) {
 276             *error = EPWMD_INVALID_ELEMENT;
 277             return NULL;
 278         }
 279
 280         /*
 281          * The value of the element tree.
 282          */
 283         if (!req[i+1]) {
 284             if (node->children) {
 285                 n = node->children->next ? xmlCopyNode(node->children->next, 1) :
 286                     xmlCopyNode(node->children, 1);
 287
 288                 if (n->content) {
 289                     xmlFree(n->content);
 290                     n->content = NULL;
 291                 }
 292             }
 293             else
 294                 n = NULL;
 295
 296             if (req[i])
 297                 xmlNodeSetContent(node, req[i]);
 298             else if (node->content) {
 299                 xmlFree(node->content);
 300                 node->content = NULL;
 301             }
 302
 303             if (n)
 304                 xmlAddChild(node, n);
 305
 306             break;
 307         }
 308
 309         n = find_element(node, req[i]);
 310
 311         if (!n) {
 312             n = xmlNewNode(NULL, req[i]);
 313             node = xmlAddChild(node, n);
 314         }
 315         else
 316             node = n;
 317     }
 318
 319     return node;
 320 }
 321
 322 xmlNodePtr find_account(xmlDocPtr doc, gchar ***req, gpg_error_t *error,
 323         gboolean *target)
 324 {
 325     xmlNodePtr n;
 326     gint depth = 0;
 327     gchar *account = g_strdup(*req[0]);
 328     gboolean literal = is_literal_element(&account);
 329
 330     *error = 0;
 331
 332     for (n = doc->children; n;) {
 333         if (n->type == XML_ELEMENT_NODE) {
 334             if (depth == 0 && xmlStrEqual(n->name, (xmlChar *)"accounts")) {
 335                 n = n->children;
 336                 depth++;
 337                 continue;
 338             }
 339
 340             if (depth == 1 && xmlStrEqual(n->name, (xmlChar *)"account")) {
 341                 xmlChar *content = node_has_attribute(n, "name");
 342
 343                 if (!content)
 344                     continue;
 345
 346                 if (xmlStrEqual(content, account)) {
 347                     gchar **nreq, **tmp = NULL;
 348
 349                     if (literal == TRUE) {
 350                         g_free(account);
 351                         return n;
 352                     }
 353
 354                     content = node_has_attribute(n, "target");
 355
 356                     if (!content) {
 357                         g_free(account);
 358                         return n;
 359                     }
 360
 361                     if (strchr((gchar *)content, '\t')) {
 362                         nreq = split_input_line((gchar *)content, "\t", 0);
 363                         tmp = *req;
 364                         tmp = append_element_path(nreq, tmp+1);
 365                         g_strfreev(nreq);
 366                         g_strfreev(*req);
 367                         *req = tmp;
 368                     }
 369                     else {
 370                         strv_printf(&tmp, "%s", content);
 371                         nreq = *req;
 372                         nreq = append_element_path(tmp, nreq+1);
 373                         g_strfreev(*req);
 374                         *req = nreq;
 375                     }
 376
 377                     if (target)
 378                         *target = TRUE;
 379
 380                     g_free(account);
 381                     return find_account(doc, req, error, target);
 382                 }
 383             }
 384         }
 385
 386         n = n->next;
 387     }
 388
 389     g_free(account);
 390     *error = EPWMD_ELEMENT_NOT_FOUND;
 391     return NULL;
 392 }
 393
 394 xmlNodePtr find_sibling(xmlNodePtr node, gchar *element)
 395 {
 396     xmlNodePtr n;
 397
 398     if (!node || !element)
 399         return NULL;
 400
 401     for (n = node; n; n = n->next) {
 402         if (n->type != XML_ELEMENT_NODE)
 403             continue;
 404
 405         if (xmlStrEqual(n->name, (xmlChar *)element))
 406             return n;
 407     }
 408
 409     return NULL;
 410 }
 411
 412 xmlNodePtr find_element(xmlNodePtr node, gchar *element)
 413 {
 414     if (!node || !element)
 415         return NULL;
 416
 417     return find_sibling(node, element);
 418 }
 419
 420 static void element_to_literal(gchar **element)
 421 {
 422     gchar *p = g_strdup_printf("!%s", *element);
 423     g_free(*element);
 424     *element = p;
 425 }
 426
 427 xmlChar *node_has_attribute(xmlNodePtr n, xmlChar *attr)
 428 {
 429     xmlAttrPtr a = xmlHasProp(n, attr);
 430
 431     if (!a)
 432         return NULL;
 433
 434     if (!a->children || !a->children->content)
 435         return NULL;
 436
 437     return a->children->content;
 438 }
 439
 440 xmlNodePtr find_elements(xmlDocPtr doc, xmlNodePtr node,
 441         gchar **req, gpg_error_t *error, gboolean *target,
 442         xmlNodePtr (*found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 443         xmlNodePtr (*not_found_fn)(xmlNodePtr, gchar **, gpg_error_t *, void *),
 444         void *data)
 445 {
 446     xmlNodePtr n, last, last_node;
 447     gchar **p;
 448     gint found = 0;
 449
 450     *error = 0;
 451
 452     for (last_node = last = n = node, p = req; *p; p++) {
 453         xmlNodePtr tmp;
 454         gchar *t = g_strdup(*p);
 455         gboolean literal = is_literal_element(&t);
 456
 457         n = find_element(last, t);
 458         g_free(t);
 459
 460         if (!n) {
 461             if (not_found_fn)
 462                 return not_found_fn(found ? last_node : last_node->parent, p, error, data);
 463
 464             *error = EPWMD_ELEMENT_NOT_FOUND;
 465             return NULL;
 466         }
 467
 468         last = n->children;
 469         last_node = n;
 470         found = 1;
 471
 472         if (literal == FALSE) {
 473             xmlChar *content = node_has_attribute(n, "target");
 474             gchar **nreq = NULL, **nnreq;
 475
 476             if (!content) {
 477                 element_to_literal(&(*p));
 478                 continue;
 479             }
 480
 481             if (strchr((gchar *)content, '\t') != NULL) {
 482                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
 483                     *error = EPWMD_INVALID_ELEMENT;
 484                     return NULL;
 485                 }
 486             }
 487             else {
 488                 if ((nreq = split_input_line((gchar *)content, " ", 0)) == NULL) {
 489                     *error = EPWMD_INVALID_ELEMENT;
 490                     return NULL;
 491                 }
 492             }
 493
 494             tmp = find_account(doc, &nreq, error, target);
 495
 496             if (!tmp) {
 497                 g_strfreev(nreq);
 498                 return NULL;
 499             }
 500
 501             if (found_fn)
 502                 found_fn(n, nreq, error, data);
 503
 504             nnreq = append_element_path(nreq+1, p+1);
 505             g_strfreev(nreq);
 506
 507             if (!nnreq || !*nnreq)
 508                 return tmp;
 509
 510             if (target)
 511                 *target = TRUE;
 512
 513             n = find_elements(doc, tmp->children, nnreq, error, NULL, found_fn,
 514                     not_found_fn, data);
 515
 516             if (*(p+1)) {
 517                 gchar **zz = p+1, **qq = nnreq;
 518
 519                 if (g_strv_length(nnreq) > g_strv_length(p+1))
 520                     qq = nnreq+1;
 521
 522                 for (; *qq && *zz; zz++) {
 523                     g_free(*zz);
 524                     *zz = g_strdup(*qq++);
 525                 }
 526             }
 527
 528             g_strfreev(nnreq);
 529             return n;
 530         }
 531     }
 532
 533     return n;
 534 }
 535
 536 gboolean node_has_child_element(xmlNodePtr node)
 537 {
 538     xmlNodePtr n;
 539
 540     if (!node)
 541         return FALSE;
 542
 543     for (n = node; n; n = n->next) {
 544         if (n->type == XML_ELEMENT_NODE)
 545             return TRUE;
 546
 547         if (n->children)
 548             return node_has_child_element(n->children);
 549     }
 550
 551     return FALSE;
 552 }