src/commands.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 <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <ctype.h>
  28 #include <glib.h>
  29 #include <glib/gprintf.h>
  30 #include <gcrypt.h>
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35
  36 #include "xml.h"
  37 #include "common.h"
  38 #include "pwmd_error.h"
  39 #include "commands.h"
  40
  41 gboolean encrypt_xml(gcry_cipher_hd_t gh, void *outbuf, gsize outsize,
  42         void *inbuf, gsize insize)
  43 {
  44     if ((gcryerrno = gcry_cipher_encrypt(gh, outbuf, outsize, inbuf, insize))) {
  45         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
  46         return FALSE;
  47     }
  48
  49     return TRUE;
  50 }
  51
  52 gboolean decrypt_xml(gcry_cipher_hd_t gh, void *outbuf, gsize outsize,
  53         void *inbuf, gsize insize)
  54 {
  55     if ((gcryerrno = gcry_cipher_decrypt(gh, outbuf, outsize, inbuf, insize))) {
  56         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
  57         return FALSE;
  58     }
  59
  60     return TRUE;
  61 }
  62
  63 static gboolean parse_xml(struct client_s *client)
  64 {
  65     xmlErrorPtr xml_error;
  66
  67     switch (open_xml(client->xml, client->len, &client->doc, &client->reader)) {
  68         case 1:
  69             xml_error = xmlGetLastError();
  70             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
  71             send_error(client, EPWMD_LIBXML_ERROR);
  72             return FALSE;
  73         case 2:
  74             xml_error = xmlGetLastError();
  75             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
  76             send_error(client, EPWMD_LIBXML_ERROR);
  77             return FALSE;
  78         default:
  79             break;
  80     }
  81
  82     return TRUE;
  83 }
  84
  85 static gboolean valid_filename(const gchar *filename)
  86 {
  87     const gchar *p;
  88
  89     if (!filename || !*filename)
  90         return FALSE;
  91
  92     for (p = filename; *p; p++) {
  93         if (g_ascii_isalnum(*p) == FALSE)
  94             return FALSE;
  95     }
  96
  97     return TRUE;
  98 }
  99
 100 static gboolean cache_reset_timeout(const guchar *md5filename)
 101 {
 102     void *p;
 103     file_cache_t f;
 104     glong len;
 105
 106     for (p = shm_data, len = 0; len <= cache_size;) {
 107         memcpy(&f, p, sizeof(file_cache_t));
 108
 109         if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 110             f.elapsed = 0;
 111             f.when = f.timeout;
 112             memcpy(p, &f, sizeof(file_cache_t));
 113             return TRUE;
 114         }
 115
 116         p += sizeof(file_cache_t);
 117         len += sizeof(file_cache_t);
 118
 119         if (len + sizeof(file_cache_t) > cache_size)
 120             break;
 121     }
 122
 123     return FALSE;
 124 }
 125
 126 gboolean cache_set_timeout(const guchar *md5filename, glong timeout)
 127 {
 128     void *p;
 129     file_cache_t f;
 130     glong len;
 131
 132     for (p = shm_data, len = 0; len <= cache_size;) {
 133         memcpy(&f, p, sizeof(file_cache_t));
 134
 135         if (md5filename) {
 136             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 137                 f.elapsed = 0;
 138                 f.when = f.timeout = timeout;
 139                 memcpy(p, &f, sizeof(file_cache_t));
 140                 return TRUE;
 141             }
 142         }
 143         else {
 144             f.elapsed = 0;
 145             f.when = f.timeout = timeout;
 146             memcpy(p, &f, sizeof(file_cache_t));
 147         }
 148
 149         p += sizeof(file_cache_t);
 150         len += sizeof(file_cache_t);
 151
 152         if (len + sizeof(file_cache_t) > cache_size)
 153             break;
 154     }
 155
 156     return (md5filename) ? FALSE : TRUE;
 157 }
 158
 159 static gboolean cache_update_key(const guchar *md5filename, const guchar *shakey)
 160 {
 161     void *p;
 162     file_cache_t f;
 163     glong len;
 164
 165     for (p = shm_data, len = 0; len <= cache_size;) {
 166         memcpy(&f, p, sizeof(file_cache_t));
 167
 168         if (f.used == TRUE) {
 169             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
 170                 memcpy(&f.key, shakey, sizeof(f.key));
 171                 memcpy(p, &f, sizeof(file_cache_t));
 172                 return TRUE;
 173             }
 174         }
 175
 176         p += sizeof(file_cache_t);
 177         len += sizeof(file_cache_t);
 178
 179         if (len + sizeof(file_cache_t) > cache_size)
 180             break;
 181     }
 182
 183     return cache_add_file(md5filename, shakey);
 184 }
 185
 186 static gint cache_valid_key(const guchar *key, gsize len)
 187 {
 188     gint b;
 189
 190     for (b = 0; b < len; b++) {
 191         if (key[b])
 192             return TRUE;
 193     }
 194
 195     return FALSE;
 196 }
 197
 198 static gboolean cache_get_key(const guchar *md5file, guchar *shakey)
 199 {
 200     void *p;
 201     file_cache_t f;
 202     glong len;
 203
 204     for (p = shm_data, len = 0; len <= cache_size;) {
 205         memcpy(&f, p, sizeof(file_cache_t));
 206
 207         /*
 208          * The slot may be used but not yet contain a key.
 209          */
 210         if (f.used == TRUE) {
 211             if (memcmp(&f.filename, md5file, sizeof(f.filename)) == 0) {
 212                 if (cache_valid_key(f.key, sizeof(f.key)) == FALSE)
 213                     return FALSE;
 214
 215                 memcpy(shakey, &f.key, sizeof(f.key));
 216                 return TRUE;
 217             }
 218         }
 219
 220         p += sizeof(file_cache_t);
 221         len += sizeof(file_cache_t);
 222
 223         if (len + sizeof(file_cache_t) > cache_size)
 224             break;
 225     }
 226
 227     return FALSE;
 228 }
 229
 230 gint open_file(const gchar *filename, struct stat *st)
 231 {
 232     gint fd;
 233
 234     if ((fd = open(filename, O_RDONLY)) == -1)
 235         return -1;
 236
 237     if (stat(filename, st) == -1) {
 238         close(fd);
 239         return -1;
 240     }
 241
 242     return fd;
 243 }
 244
 245 gboolean open_command(struct client_s *client, gchar **req)
 246 {
 247     gint fd;
 248     struct stat st;
 249     gchar *inbuf;
 250     const gchar *filename = req[0];
 251     guchar shakey[gcrykeysize];
 252     guchar tkey[gcrykeysize];
 253     gint cached = 0;
 254     gsize insize = 0;
 255     guint iter;
 256     gint timeout;
 257     gchar filebuf[PATH_MAX], *p, *p2;
 258     gint error;
 259     struct file_header_s {
 260         guint iter;
 261         guchar iv[gcryblocksize];
 262     } file_header;
 263
 264     if (!filename || !*filename) {
 265         send_error(client, EPWMD_COMMAND_SYNTAX);
 266         return FALSE;
 267     }
 268
 269     if (valid_filename(filename) == FALSE) {
 270         send_error(client, EPWMD_INVALID_FILENAME);
 271         return FALSE;
 272     }
 273
 274     p = get_key_file_string("default", "data_directory");
 275     p2 = expand_homedir(p);
 276     g_free(p);
 277     snprintf(filebuf, sizeof(filebuf), "%s/%s", p2, filename);
 278     g_free(p2);
 279
 280     if (stat(filebuf, &st) == 0) {
 281         if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
 282             log_write("%s: %s", filename, pwmd_strerror(EPWMD_NOT_A_FILE));
 283             send_to_client(client, "ERR %03i %s\n", EPWMD_NOT_A_FILE, pwmd_strerror(EPWMD_NOT_A_FILE));
 284             return FALSE;
 285         }
 286
 287         client->mtime = st.st_mtime;
 288     }
 289
 290     gcry_md_hash_buffer(GCRY_MD_MD5, client->md5file, filename, strlen(filename));
 291
 292     /*
 293      * New files don't need a key.
 294      */
 295     if (access(filebuf, R_OK|W_OK) != 0) {
 296         if (errno != ENOENT) {
 297             error = errno;
 298             log_write("%s: %s", filename, strerror(errno));
 299             send_to_client(client, "ERR %03i %s: %s\n", EPWMD_ERROR, filename,
 300                     strerror(error));
 301             return FALSE;
 302         }
 303 new_doc:
 304         if ((client->xml = new_document()) == NULL) {
 305             error = errno;
 306             log_write("%s", strerror(errno));
 307             send_to_client(client, "ERR %03i malloc(): %s\n", EPWMD_ERROR,
 308                     strerror(error));
 309             return FALSE;
 310         }
 311
 312         client->len = strlen(client->xml);
 313
 314         if (cache_add_file(client->md5file, NULL) == FALSE) {
 315             log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(EPWMD_MAX_SLOTS));
 316             send_error(client, EPWMD_MAX_SLOTS);
 317             return FALSE;
 318         }
 319
 320         client->filename = g_strdup(filename);
 321         return parse_xml(client);
 322     }
 323
 324     if ((fd = open_file(filebuf, &st)) == -1) {
 325         error = errno;
 326         log_write("%s: %s", filename, strerror(errno));
 327         send_to_client(client, "ERR %03i %s: %s\n", EPWMD_ERROR, filename, strerror(error));
 328         return FALSE;
 329     }
 330
 331     if (st.st_size == 0)
 332         goto new_doc;
 333
 334     if (cache_get_key(client->md5file, shakey) == TRUE)
 335         cached = 1;
 336     else {
 337         /*
 338          * No key specified and no matching filename found in the cache.
 339          */
 340         if (!req[1] || !*req[1]) {
 341             close(fd);
 342             send_error(client, EPWMD_KEY);
 343             return FALSE;
 344         }
 345     }
 346
 347     insize = st.st_size - sizeof(struct file_header_s);
 348     read(fd, &file_header, sizeof(struct file_header_s));
 349     inbuf = gcry_malloc(insize);
 350     read(fd, inbuf, insize);
 351     close(fd);
 352
 353 again:
 354     if (!cached) {
 355         gcry_md_hash_buffer(GCRY_MD_SHA256, shakey, req[1], strlen(req[1]));
 356         memset(req[1], 0, strlen(req[1]));
 357     }
 358
 359     if ((gcryerrno = gcry_cipher_setiv(client->gh, file_header.iv,
 360                     sizeof(file_header.iv)))) {
 361         gcry_free(inbuf);
 362         memset(shakey, 0, sizeof(shakey));
 363         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 364         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 365         return FALSE;
 366     }
 367
 368     if ((gcryerrno = gcry_cipher_setkey(client->gh, shakey, gcrykeysize))) {
 369         gcry_free(inbuf);
 370         memset(shakey, 0, sizeof(shakey));
 371         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 372         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 373         return FALSE;
 374     }
 375
 376     if (decrypt_xml(client->gh, inbuf, insize, NULL, 0) == FALSE) {
 377         if (cached) {
 378             cached = 0;
 379             goto again;
 380         }
 381
 382         memset(shakey, 0, sizeof(shakey));
 383         gcry_free(inbuf);
 384         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 385         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 386         return FALSE;
 387     }
 388
 389     memcpy(tkey, shakey, sizeof(tkey));
 390     tkey[0] ^= 1;
 391
 392     if ((gcryerrno = gcry_cipher_setkey(client->gh, tkey, gcrykeysize))) {
 393         memset(tkey, 0, sizeof(tkey));
 394         gcry_free(inbuf);
 395         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 396         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 397         return FALSE;
 398     }
 399
 400     iter = file_header.iter;
 401
 402     while (iter-- > 0) {
 403         if ((gcryerrno = gcry_cipher_setiv(client->gh, file_header.iv,
 404                         sizeof(file_header.iv)))) {
 405             memset(tkey, 0, sizeof(tkey));
 406             gcry_free(inbuf);
 407             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 408             send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 409             return FALSE;
 410         }
 411
 412         if (decrypt_xml(client->gh, inbuf, insize, NULL, 0) == FALSE) {
 413             if (cached) {
 414                 cached = 0;
 415                 goto again;
 416             }
 417
 418             memset(tkey, 0, sizeof(tkey));
 419             gcry_free(inbuf);
 420             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 421             send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 422             return FALSE;
 423         }
 424     }
 425
 426     memset(tkey, 0, sizeof(tkey));
 427     client->xml = inbuf;
 428     client->len = insize;
 429
 430     if (g_strncasecmp(client->xml, "<?xml version=\"1.0\"?>", 21) != 0) {
 431         send_error(client, EPWMD_BADKEY);
 432         return FALSE;
 433     }
 434
 435     if (!cached) {
 436         if (cache_add_file(client->md5file, shakey) == FALSE) {
 437             memset(shakey, 0, sizeof(shakey));
 438             log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(EPWMD_MAX_SLOTS));
 439             send_error(client, EPWMD_MAX_SLOTS);
 440             return FALSE;
 441         }
 442     }
 443
 444     memset(shakey, 0, sizeof(shakey));
 445     client->filename = g_strdup(filename);
 446
 447     if (!cached) {
 448         timeout = get_key_file_integer(client->filename, "cache_timeout");
 449         cache_set_timeout(client->md5file, timeout);
 450     }
 451
 452     return parse_xml(client);
 453 }
 454
 455 /*
 456  * client->reader should be at the position in the document where the element
 457  * search should start. It won't search past the closing account element.
 458  */
 459 static gboolean find_elements(struct client_s *client, xmlTextReaderPtr reader,
 460         gchar **req, gint quiet)
 461 {
 462     gint i;
 463
 464     if (!req || !req[0]) {
 465         if (!quiet)
 466             send_error(client, EPWMD_COMMAND_SYNTAX);
 467         return FALSE;
 468     }
 469
 470     for (i = 0; req[i]; i++) {
 471         if (find_element(reader, req[i], req[i+1] != NULL) == FALSE) {
 472             if (!quiet)
 473                 send_error(client, EPWMD_ELEMENT_NOT_FOUND);
 474
 475             return FALSE;
 476         }
 477     }
 478
 479     return TRUE;
 480 }
 481
 482 gboolean do_xml_encrypt(struct client_s *client, gcry_cipher_hd_t gh,
 483         const gchar *filename, const xmlChar *data, size_t insize,
 484         const guchar *shakey, guint iter)
 485 {
 486     gsize len = insize;
 487     gint fd;
 488     void *inbuf;
 489     guchar tkey[gcrykeysize];
 490     gchar *p;
 491     gint error;
 492     struct file_header_s {
 493         guint iter;
 494         guchar iv[gcryblocksize];
 495     } file_header;
 496
 497     if (insize / gcryblocksize) {
 498         len = (insize / gcryblocksize) * gcryblocksize;
 499
 500         if (insize % gcryblocksize)
 501             len += gcryblocksize;
 502     }
 503
 504     inbuf = gcry_calloc(1, len);
 505     memcpy(inbuf, data, insize);
 506     insize = len;
 507     gcry_create_nonce(file_header.iv, sizeof(file_header.iv));
 508     memcpy(tkey, shakey, sizeof(tkey));
 509     tkey[0] ^= 1;
 510
 511     if ((gcryerrno = gcry_cipher_setkey(gh, tkey, gcrykeysize))) {
 512         gcry_free(inbuf);
 513         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 514         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 515         return FALSE;
 516     }
 517
 518     file_header.iter = iter;
 519
 520     while (iter-- > 0) {
 521         if ((gcryerrno = gcry_cipher_setiv(gh, file_header.iv,
 522                         sizeof(file_header.iv)))) {
 523             gcry_free(inbuf);
 524             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 525             send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 526             return FALSE;
 527         }
 528
 529         if (encrypt_xml(gh, inbuf, insize, NULL, 0)
 530                 == FALSE) {
 531             gcry_free(inbuf);
 532             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 533             send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 534             return FALSE;
 535         }
 536     }
 537
 538     if ((gcryerrno = gcry_cipher_setiv(gh, file_header.iv,
 539                     sizeof(file_header.iv)))) {
 540         gcry_free(inbuf);
 541         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 542         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 543         return FALSE;
 544     }
 545
 546     if ((gcryerrno = gcry_cipher_setkey(gh, shakey, gcrykeysize))) {
 547         gcry_free(inbuf);
 548         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 549         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 550         return FALSE;
 551     }
 552
 553     if (encrypt_xml(gh, inbuf, insize, NULL, 0)
 554             == FALSE) {
 555         gcry_free(inbuf);
 556         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(gcryerrno));
 557         send_to_client(client, "ERR %03i gcrypt: %s\n", EPWMD_ERROR, gcry_strerror(gcryerrno));
 558         return FALSE;
 559     }
 560
 561     if (filename) {
 562         if ((fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0600)) == -1) {
 563             error = errno;
 564             gcry_free(inbuf);
 565             p = strrchr(filename, '/');
 566             p++;
 567             log_write("%s: %s", p, strerror(errno));
 568             send_to_client(client, "ERR %03i %s: %s\n", EPWMD_ERROR, p, strerror(error));
 569             return FALSE;
 570         }
 571     }
 572     else
 573         /*
 574          * xml_import() from command line.
 575          */
 576         fd = STDOUT_FILENO;
 577
 578     write(fd, &file_header, sizeof(struct file_header_s));
 579     write(fd, inbuf, insize);
 580
 581     if (filename)
 582         close(fd);
 583
 584     gcry_free(inbuf);
 585     return TRUE;
 586 }
 587
 588 gboolean save_command(struct client_s *client, const gchar *filename, gchar *key)
 589 {
 590     xmlChar *xmlbuf;
 591     gint len;
 592     gint update = 1;
 593     guchar shakey[gcrykeysize];
 594     gint iter;
 595     struct stat st;
 596     gchar filebuf[PATH_MAX], *p, *p2;
 597     gboolean reset_timeout;
 598
 599     p = get_key_file_string("default", "data_directory");
 600     p2 = expand_homedir(p);
 601     g_free(p);
 602     snprintf(filebuf, sizeof(filebuf), "%s/%s", p2, filename);
 603     g_free(p2);
 604
 605     if (stat(filebuf, &st) == 0 && client->mtime) {
 606         if (client->mtime != st.st_mtime) {
 607             log_write("%s: %s", filename, pwmd_strerror(EPWMD_FILE_MODIFIED));
 608             send_error(client, EPWMD_FILE_MODIFIED);
 609             return FALSE;
 610         }
 611     }
 612
 613     if (!key || !key) {
 614         if (cache_get_key(client->md5file, shakey) == FALSE) {
 615             send_error(client, EPWMD_KEY);
 616             return FALSE;
 617         }
 618
 619         update = 0;
 620     }
 621     else {
 622         gcry_md_hash_buffer(GCRY_MD_SHA256, shakey, key, strlen(key));
 623         memset(key, 0, strlen(key));
 624     }
 625
 626     xmlDocDumpFormatMemory(client->doc, &xmlbuf, &len, 0);
 627
 628     if ((iter = get_key_file_integer(client->filename, "iterations")) == -1)
 629         iter = 0;
 630
 631     if (do_xml_encrypt(client, client->gh, filebuf, xmlbuf, len, shakey,
 632                 iter) == FALSE) {
 633         memset(shakey, 0, sizeof(shakey));
 634         xmlFree(xmlbuf);
 635         return FALSE;
 636     }
 637
 638     xmlFree(xmlbuf);
 639     stat(filebuf, &st);
 640     client->mtime = st.st_mtime;
 641
 642     if (!update) {
 643         memset(shakey, 0, sizeof(shakey));
 644
 645         if ((reset_timeout = get_key_file_boolean(client->filename,
 646                 "cache_reset_timeout")) == TRUE)
 647             cache_reset_timeout(client->md5file);
 648
 649         log_write("%s\n", reset_timeout == FALSE?"ack":"ackack");
 650         return TRUE;
 651     }
 652
 653     if (cache_update_key(client->md5file, shakey) == FALSE) {
 654         memset(shakey, 0, sizeof(shakey));
 655         log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(EPWMD_MAX_SLOTS));
 656         send_error(client, EPWMD_MAX_SLOTS);
 657         return FALSE;
 658     }
 659
 660     memset(shakey, 0, sizeof(shakey));
 661     cache_reset_timeout(client->md5file);
 662     return TRUE;
 663 }
 664
 665 static gboolean contains_whitespace(const gchar *str)
 666 {
 667     const gchar *p = str;
 668
 669     for (; *p; p++) {
 670         if (g_ascii_isspace(*p) == TRUE) {
 671             return TRUE;
 672         }
 673     }
 674
 675     return FALSE;
 676 }
 677
 678 /*
 679  * the 'reader' should be at the element of the document where the elements
 680  * 'req' are to be created.
 681  */
 682 static gboolean create_elements(struct client_s *client, xmlTextReaderPtr reader,
 683         gchar **req, gint novalue)
 684 {
 685     gint i;
 686     gboolean ret = TRUE;
 687     xmlNodePtr r;
 688
 689     r = xmlTextReaderCurrentNode(reader);
 690
 691     if (xmlTextReaderDepth(reader) > 1)
 692         r = r->parent;
 693
 694     for (i = 0; req[i]; i++) {
 695         xmlNodePtr n;
 696
 697         /*
 698          * Whitespace is allowed in values or attributes but not in element
 699          * names.
 700          */
 701         if (req[i+1] && valid_xml_element((xmlChar *)req[i]) == FALSE) {
 702             send_error(client, EPWMD_INVALID_ELEMENT);
 703             return FALSE;
 704         }
 705
 706         /*
 707          * The value of the element tree.
 708          */
 709         if (!req[i+1] && !novalue) {
 710             /*
 711              * Prevent creating 'text' elements in the root of the account.
 712              */
 713             if (i < 1) {
 714                 send_error(client, EPWMD_ROOT_TEXT_ELEMENT);
 715                 return FALSE;
 716             }
 717
 718             /*
 719              * FIXME ?? overwriting an element tree with a text element:
 720              *
 721              * STORE account element element2 value
 722              * STORE account element value
 723              *
 724              * would remove the existing element tree. This may be a bug or
 725              * feature.
 726              */
 727             xmlNodeSetContent(r, (xmlChar *)req[i]);
 728             break;
 729         }
 730
 731         if ((n = find_node(r, (xmlChar *)req[i])) == NULL) {
 732             n = xmlNewNode(NULL, (xmlChar *)req[i]);
 733             r = xmlAddChild(r, n);
 734         }
 735         else
 736             r = n;
 737
 738         if (!req[i+1] && novalue)
 739             return TRUE;
 740     }
 741
 742     return ret;
 743 }
 744
 745 /*
 746  * FIXME reuse reader handle
 747  */
 748 static gboolean reset_reader(xmlDocPtr doc, xmlTextReaderPtr *reader)
 749 {
 750     if (reader) {
 751         xmlFreeTextReader(*reader);
 752         *reader = NULL;
 753     }
 754
 755     if ((*reader = xmlReaderWalker(doc)) == NULL)
 756         return FALSE;
 757
 758     return TRUE;
 759 }
 760
 761 static void delete_node(xmlNodePtr n)
 762 {
 763     xmlUnlinkNode(n);
 764     xmlFreeNode(n);
 765 }
 766
 767 gboolean delete_command(struct client_s *client, gchar **req)
 768 {
 769     gint i = 1;
 770     xmlNodePtr n;
 771     xmlErrorPtr xml_error;
 772
 773     if (reset_reader(client->doc, &client->reader) == FALSE) {
 774         xml_error = xmlGetLastError();
 775         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
 776         send_error(client, EPWMD_LIBXML_ERROR);
 777         return FALSE;
 778     }
 779
 780     if (find_account(client->reader, req[0]) == FALSE) {
 781         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
 782         return FALSE;
 783     }
 784
 785     n = xmlTextReaderCurrentNode(client->reader);
 786
 787     /*
 788      * No sub-node defined. Remove the entire node (account).
 789      */
 790     if (!req[i]) {
 791         if (n)
 792             delete_node(n);
 793         return TRUE;
 794     }
 795
 796     /*
 797      * Remove matching sub-nodes starting from the root of the account.
 798      */
 799     while (req[i] && find_element(client->reader, req[i++], req[i] != NULL) == TRUE)
 800         n = xmlTextReaderCurrentNode(client->reader);
 801
 802     if (n && xmlStrcmp(n->name, (xmlChar *)req[i-1]) == 0 &&
 803                 xmlTextReaderNodeType(client->reader) == XML_READER_TYPE_ELEMENT)
 804         delete_node(n);
 805     else {
 806         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
 807         return FALSE;
 808     }
 809
 810     return TRUE;
 811 }
 812
 813 gboolean store_command(struct client_s *client, gchar **req)
 814 {
 815     xmlErrorPtr xml_error;
 816
 817 again:
 818     if (reset_reader(client->doc, &client->reader) == FALSE) {
 819         xml_error = xmlGetLastError();
 820         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
 821         send_error(client, EPWMD_LIBXML_ERROR);
 822         return FALSE;
 823     }
 824
 825     if (!req[0]) {
 826         send_error(client, EPWMD_COMMAND_SYNTAX);
 827         return FALSE;
 828     }
 829
 830     if (find_account(client->reader, req[0]) == FALSE) {
 831         if (contains_whitespace(req[0]) == TRUE) {
 832             send_error(client, EPWMD_INVALID_ELEMENT);
 833             return FALSE;
 834         }
 835
 836         if (new_account(client->doc, req[0]) == FALSE) {
 837             send_error(client, EPWMD_ERROR);
 838             return FALSE;
 839         }
 840
 841         goto again;
 842     }
 843
 844     xmlTextReaderNext(client->reader);
 845     return create_elements(client, client->reader, req+1, 0);
 846 }
 847
 848 static gboolean do_get_command(struct client_s *client, xmlTextReaderPtr *reader,
 849         gchar **req, xmlChar **content, gint quiet, gint list)
 850 {
 851     xmlNodePtr n;
 852     xmlAttrPtr a;
 853     gchar **nreq;
 854     gboolean ret;
 855     xmlChar *p;
 856     xmlErrorPtr xml_error;
 857
 858     if (reset_reader(client->doc, reader) == FALSE) {
 859         if (!quiet) {
 860             xml_error = xmlGetLastError();
 861             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
 862             send_error(client, EPWMD_LIBXML_ERROR);
 863         }
 864
 865         return FALSE;
 866     }
 867
 868     if (find_account(*reader, req[0]) == FALSE) {
 869         if (!quiet && !list)
 870             send_error(client, EPWMD_ELEMENT_NOT_FOUND);
 871         return FALSE;
 872     }
 873
 874     /*
 875      * May be an account with only a TARGET attribute.
 876      */
 877     if (req[1]) {
 878         if (find_elements(client, *reader, req + 1, (list) ? 1 : quiet) == FALSE)
 879             return FALSE;
 880     }
 881
 882     if ((n = xmlTextReaderCurrentNode(*reader)) == NULL) {
 883         if (!quiet) {
 884             xml_error = xmlGetLastError();
 885             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
 886             send_error(client, EPWMD_LIBXML_ERROR);
 887         }
 888
 889         return FALSE;
 890     }
 891
 892     /*
 893      * If the current element has a TARGET attribute, the value of the
 894      * attribute is an element path somewhere else in the document. Use this
 895      * value and not any TEXT element value. The value may be another element
 896      * with a TARGET attribute and this function will recurse until a non-TARGET
 897      * attribute in the element is found.
 898      */
 899     if ((a = xmlHasProp(n, (xmlChar *)"target")) != NULL) {
 900         if ((p = xmlNodeGetContent(a->children)) != NULL) {
 901             if (strchr((gchar *)p, '\t') != NULL) {
 902                 if ((nreq = split_input_line((gchar *)p, "\t", 0)) == NULL) {
 903                     xmlFree(p);
 904
 905                     if (!quiet)
 906                         send_error(client, EPWMD_INVALID_ELEMENT);
 907                     return FALSE;
 908                 }
 909             }
 910             else {
 911                 if ((nreq = split_input_line((gchar *)p, " ", 0)) == NULL) {
 912                     xmlFree(p);
 913
 914                     if (!quiet)
 915                         send_error(client, EPWMD_INVALID_ELEMENT);
 916                     return FALSE;
 917                 }
 918             }
 919
 920             xmlFree(p);
 921             ret = do_get_command(client, reader, nreq, content, quiet, list);
 922             g_strfreev(nreq);
 923             return ret;
 924         }
 925     }
 926
 927     switch (xmlTextReaderNext(*reader)) {
 928         case -1:
 929             if (!quiet) {
 930                 xml_error = xmlGetLastError();
 931                 log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
 932                 send_error(client, EPWMD_LIBXML_ERROR);
 933             }
 934
 935             return FALSE;
 936         case 0:
 937             if (!quiet)
 938                 send_error(client, EPWMD_EMPTY_ELEMENT);
 939             return FALSE;
 940         default:
 941             break;
 942     }
 943
 944     switch (xmlTextReaderNodeType(*reader)) {
 945         case XML_READER_TYPE_END_ELEMENT:
 946             /*
 947              * May be an empty element after an ATTR DELETE TARGET command.
 948              */
 949             return TRUE;
 950         case XML_READER_TYPE_TEXT:
 951             break;
 952         case -1:
 953             if (!quiet) {
 954                 xml_error = xmlGetLastError();
 955                 log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
 956                 send_error(client, EPWMD_LIBXML_ERROR);
 957             }
 958
 959             return FALSE;
 960         default:
 961             if (!quiet) {
 962                 if (n->children && !list)
 963                     send_error(client, EPWMD_TRAILING_ELEMENT);
 964                 else if (!n->children && !list)
 965                     send_error(client, EPWMD_INVALID_ELEMENT);
 966             }
 967             return FALSE;
 968     }
 969
 970     if ((*content = xmlNodeGetContent(n)) == NULL) {
 971         if (!quiet)
 972             send_error(client, EPWMD_EMPTY_ELEMENT);
 973         return FALSE;
 974     }
 975
 976     return TRUE;
 977 }
 978
 979 /*
 980  * Retrieves the value associated with the element tree 'req'.
 981  */
 982 gboolean get_command(struct client_s *client, xmlTextReaderPtr *reader,
 983         gchar **req, gint quiet)
 984 {
 985     xmlChar *content = NULL;
 986
 987     if (do_get_command(client, reader, req, &content, quiet, 0) == FALSE)
 988         return FALSE;
 989
 990     if (!content) {
 991         if (!quiet)
 992             send_error(client, EPWMD_EMPTY_ELEMENT);
 993
 994         return FALSE;
 995     }
 996
 997     send_to_client(client, "BEGIN %li\n%s\nOK \n", xmlStrlen(content), content);
 998     xmlFree(content);
 999     return TRUE;
1000 }
1001
1002 #ifdef DEBUG
1003 static gchar *element_path_to_req(const gchar *account, xmlChar *path,
1004         const xmlChar *content)
1005 #else
1006 static gchar *element_path_to_req(const gchar *account, xmlChar *path)
1007 #endif
1008 {
1009     xmlChar *p = path;
1010     gint n;
1011     gchar *buf;
1012
1013     if (!p)
1014         return NULL;
1015
1016     for (n = 0; *p && n < 3; p++) {
1017         if (*p == '/')
1018             n++;
1019     }
1020
1021     if (strstr((gchar *)p, "text()") != NULL)
1022         p[xmlStrlen(p) - 7] = 0;
1023
1024     for (n = 0; p[n]; n++) {
1025         if (p[n] == '/')
1026             p[n] = '\t';
1027     }
1028
1029 #ifdef DEBUG
1030     buf = g_strdup_printf("%s\t%s\t%s", account, p, content);
1031 #else
1032     buf = g_strdup_printf("%s\t%s", account, p);
1033 #endif
1034     return buf;
1035 }
1036
1037 static gboolean append_to_array(gchar ***array, gint *total, const gchar *str)
1038 {
1039     gchar **a;
1040     gint t = *total;
1041
1042     if ((a = g_realloc(*array, (t + 2) * sizeof(gchar *))) == NULL)
1043         return FALSE;
1044
1045     a[t++] = g_strdup(str);
1046     a[t] = NULL;
1047     *total = t;
1048     *array = a;
1049     return TRUE;
1050 }
1051
1052 gboolean list_command(struct client_s *client, gchar *str)
1053 {
1054     gchar *dst = NULL;
1055     gchar *p = str;
1056     gchar **elements = NULL;
1057     gint pwmd_errno = -1;
1058     gchar *account;
1059     gint total = 0;
1060     xmlChar *path = NULL;
1061     xmlAttrPtr a;
1062     xmlNodePtr n;
1063     xmlChar *content;
1064     xmlTextReaderPtr r = NULL;
1065     gchar **req = NULL, **nreq;
1066     gboolean ret;
1067     gint type;
1068     gchar *line;
1069     xmlErrorPtr xml_error;
1070     gint depth = 0;
1071
1072     if (reset_reader(client->doc, &client->reader) == FALSE) {
1073         xml_error = xmlGetLastError();
1074         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1075         send_error(client, EPWMD_LIBXML_ERROR);
1076         return FALSE;
1077     }
1078
1079     if (strchr(p, ' ') == NULL) {
1080 list_only:
1081         if (list_accounts(client->reader, &dst, &pwmd_errno) == FALSE) {
1082             send_error(client, pwmd_errno);
1083             return FALSE;
1084         }
1085         else {
1086             send_to_client(client, "BEGIN %i\n%s\nOK \n",
1087                     g_utf8_strlen(dst, -1), dst);
1088             memset(dst, 0, strlen(dst));
1089             g_free(dst);
1090         }
1091
1092         return TRUE;
1093     }
1094
1095     p = str + 5;
1096
1097     while (*p && isspace(*p))
1098         p++;
1099
1100     if (!*p)
1101         goto list_only;
1102
1103     if (strchr(p, '\t') != NULL) {
1104         if ((req = split_input_line(p, "\t", 0)) == NULL) {
1105             send_error(client, EPWMD_COMMAND_SYNTAX);
1106             return FALSE;
1107         }
1108
1109         if (find_account(client->reader, req[0]) == FALSE) {
1110             send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1111             return FALSE;
1112         }
1113
1114         if (find_elements(client, client->reader, req + 1, 0) == FALSE) {
1115             g_strfreev(req);
1116             return FALSE;
1117         }
1118
1119         depth = xmlTextReaderDepth(client->reader);
1120     }
1121     else {
1122         if (find_account(client->reader, p) == FALSE) {
1123             send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1124             return FALSE;
1125         }
1126     }
1127
1128     if ((n = xmlTextReaderCurrentNode(client->reader)) == NULL) {
1129         xml_error = xmlGetLastError();
1130         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1131         send_error(client, EPWMD_LIBXML_ERROR);
1132         return FALSE;
1133     }
1134
1135     if ((a = xmlHasProp(n, (xmlChar *)"target")) != NULL) {
1136         if (reset_reader(client->doc, &client->reader) == FALSE) {
1137             send_error(client, EPWMD_LIBXML_ERROR);
1138             return FALSE;
1139         }
1140
1141         if ((content = xmlNodeGetContent(a->children)) != NULL) {
1142             if (find_account(client->reader, (gchar *)content) == FALSE) {
1143                 xmlFree(content);
1144                 send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1145                 return FALSE;
1146             }
1147
1148             xmlFree(content);
1149         }
1150     }
1151
1152     account = (req) ? g_strdup(req[0]) : g_strdup(p);
1153
1154     if (req)
1155         g_strfreev(req);
1156
1157     while (xmlTextReaderNext(client->reader) == 1) {
1158 again:
1159         if ((n = xmlTextReaderCurrentNode(client->reader)) == NULL) {
1160             xml_error = xmlGetLastError();
1161             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1162             send_error(client, EPWMD_LIBXML_ERROR);
1163             return FALSE;
1164         }
1165
1166         if (xmlTextReaderDepth(client->reader) == 1 &&
1167                 xmlStrcmp(n->name, (xmlChar *)"account") == 0 &&
1168                 xmlTextReaderNodeType(client->reader) == XML_READER_TYPE_END_ELEMENT)
1169             break;
1170
1171         if (depth && depth == xmlTextReaderDepth(client->reader) &&
1172                 xmlTextReaderNodeType(client->reader) == XML_READER_TYPE_END_ELEMENT)
1173             break;
1174
1175         /*
1176          * If the current element has a TARGET attribute, the value of the
1177          * attribute is an element path somewhere else in the document. Use this
1178          * value and not any TEXT element value.
1179          */
1180         type = xmlTextReaderNodeType(client->reader);
1181         a = xmlHasProp(n, (xmlChar *)"target");
1182
1183         if (type == XML_READER_TYPE_ELEMENT && a) {
1184             if ((content = xmlNodeGetContent(a->children)) != NULL) {
1185                 path = xmlGetNodePath(n);
1186
1187                 if ((nreq = split_input_line((gchar *)content, "\t", 0)) == NULL) {
1188                     if (elements)
1189                         g_strfreev(elements);
1190
1191                     xmlFree(path);
1192                     xmlFree(content);
1193                     send_error(client, EPWMD_INVALID_ELEMENT);
1194                     return FALSE;
1195                 }
1196
1197                 xmlFree(content);
1198                 r = NULL;
1199
1200                 if ((ret = do_get_command(client, &r, nreq, &content, 0, 1)) == TRUE) {
1201                     if (content && *content) {
1202 #ifdef DEBUG
1203                         line = element_path_to_req(account, path, content);
1204 #else
1205                         line = element_path_to_req(account, path);
1206 #endif
1207                         xmlFree(content);
1208
1209                         if (append_to_array(&elements, &total, line) == FALSE) {
1210                             if (elements)
1211                                 g_strfreev(elements);
1212
1213                             xmlFree(path);
1214                             memset(line, 0, g_utf8_strlen(line, -1));
1215                             g_free(line);
1216                             g_strfreev(nreq);
1217                             xmlFreeTextReader(r);
1218                             send_error(client, EPWMD_ERROR);
1219                             return FALSE;
1220                         }
1221
1222                         memset(line, 0, g_utf8_strlen(line, -1));
1223                         g_free(line);
1224                     }
1225
1226                     if (xmlTextReaderNext(client->reader) == 1) {
1227                         if (xmlTextReaderNodeType(client->reader) !=
1228                                 XML_READER_TYPE_TEXT) {
1229                             g_strfreev(nreq);
1230                             xmlFreeTextReader(r);
1231                             xmlFree(path);
1232                             goto again;
1233                         }
1234                     }
1235                 }
1236
1237                 g_strfreev(nreq);
1238                 xmlFreeTextReader(r);
1239                 xmlFree(path);
1240                 continue;
1241             }
1242         }
1243
1244         if (type == XML_READER_TYPE_TEXT) {
1245             xmlChar *np = xmlGetNodePath(n);
1246
1247 #ifdef DEBUG
1248             content = xmlNodeGetContent(n);
1249             line = element_path_to_req(account, np, content);
1250             xmlFree(content);
1251 #else
1252             line = element_path_to_req(account, np);
1253 #endif
1254             xmlFree(np);
1255             append_to_array(&elements, &total, line);
1256             memset(line, 0, g_utf8_strlen(line, -1));
1257             g_free(line);
1258         }
1259     }
1260
1261     if (!elements) {
1262         send_error(client, EPWMD_EMPTY_ELEMENT);
1263         g_free(account);
1264         return FALSE;
1265     }
1266
1267     g_free(account);
1268     line = g_strjoinv("\n", elements);
1269     send_to_client(client, "BEGIN %li\n%s\nOK \n",
1270             g_utf8_strlen(line, -1), line);
1271     g_strfreev(elements);
1272     g_free(line);
1273     return TRUE;
1274 }
1275
1276 /*
1277  * The client->reader handle should be at the element in the document where
1278  * the attribute will be created or modified.
1279  */
1280 static gboolean add_attribute(struct client_s *client, const gchar *name, const gchar *value)
1281 {
1282     xmlAttrPtr a;
1283     xmlNodePtr n;
1284     xmlErrorPtr xml_error;
1285
1286     if ((n = xmlTextReaderCurrentNode(client->reader)) == NULL) {
1287         xml_error = xmlGetLastError();
1288         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1289         send_error(client, EPWMD_LIBXML_ERROR);
1290         return FALSE;
1291     }
1292
1293     if ((a = xmlHasProp(n, (xmlChar *)name)) == NULL)
1294         a = xmlNewProp(n, (xmlChar *)name, (xmlChar *)value);
1295     else
1296         xmlNodeSetContent(a->children, (xmlChar *)value);
1297
1298     return TRUE;
1299 }
1300
1301 /*
1302  * req[0] - element path
1303  */
1304 static gboolean attribute_list(struct client_s *client, gchar **req)
1305 {
1306     gchar **attrlist = NULL;
1307     gint i = 0;
1308     gchar **epath = NULL;
1309     xmlAttrPtr a;
1310     xmlNodePtr n, an;
1311     gchar *line;
1312     xmlErrorPtr xml_error;
1313
1314     if (!req || !req[0]) {
1315         send_error(client, EPWMD_COMMAND_SYNTAX);
1316         return FALSE;
1317     }
1318
1319     if ((epath = split_input_line(req[0], "\t", 0)) == NULL) {
1320         /*
1321          * The first argument may be only an account.
1322          */
1323         if ((epath = split_input_line(req[0], " ", 0)) == NULL) {
1324             send_error(client, EPWMD_COMMAND_SYNTAX);
1325             return FALSE;
1326         }
1327     }
1328
1329     if (reset_reader(client->doc, &client->reader) == FALSE) {
1330         xml_error = xmlGetLastError();
1331         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1332         send_error(client, EPWMD_LIBXML_ERROR);
1333         goto blah;
1334     }
1335
1336     if (find_account(client->reader, epath[0]) == FALSE) {
1337         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1338         goto blah;
1339     }
1340
1341     if (epath[1]) {
1342         if ((find_elements(client, client->reader, epath+1, 0)) == FALSE)
1343             goto blah;
1344     }
1345
1346     if ((n = xmlTextReaderCurrentNode(client->reader)) == NULL) {
1347         xml_error = xmlGetLastError();
1348         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1349         send_error(client, EPWMD_LIBXML_ERROR);
1350         goto blah;
1351     }
1352
1353     for (a = n->properties; a; a = a->next) {
1354         if ((attrlist = g_realloc(attrlist, (i + 2) * sizeof(gchar *))) == NULL) {
1355             log_write("%s(%i): g_realloc() failed", __FILE__, __LINE__);
1356             send_error(client, EPWMD_ERROR);
1357             goto blah;
1358         }
1359
1360         an = a->children;
1361         attrlist[i++] = g_strdup_printf("%s\t%s", (gchar *)a->name, (gchar *)an->content);
1362         attrlist[i] = NULL;
1363     }
1364
1365     if (!attrlist) {
1366         send_error(client, EPWMD_EMPTY_ELEMENT);
1367         goto blah;
1368     }
1369
1370     line = g_strjoinv("\n", attrlist);
1371     send_to_client(client, "BEGIN %li\n%s\n", g_utf8_strlen(line, -1), line);
1372     g_free(line);
1373     g_strfreev(epath);
1374     g_strfreev(attrlist);
1375     return TRUE;
1376 blah:
1377     g_strfreev(epath);
1378     return FALSE;
1379 }
1380
1381 /*
1382  * req[0] - attribute
1383  * req[1] - element path
1384  */
1385 static gboolean attribute_delete(struct client_s *client, gchar **req)
1386 {
1387     xmlAttrPtr a;
1388     xmlNodePtr n;
1389     gchar **epath = NULL;
1390     xmlErrorPtr xml_error;
1391
1392     if (!req || !req[0] || !req[1]) {
1393         send_error(client, EPWMD_COMMAND_SYNTAX);
1394         return FALSE;
1395     }
1396
1397     if ((epath = split_input_line(req[1], "\t", 0)) == NULL) {
1398         /*
1399          * The first argument may be only an account.
1400          */
1401         if ((epath = split_input_line(req[1], " ", 0)) == NULL) {
1402             send_error(client, EPWMD_COMMAND_SYNTAX);
1403             return FALSE;
1404         }
1405     }
1406
1407     /*
1408      * Don't remove the NAME attribute for the account element.
1409      */
1410     if (!epath[1] && g_ascii_strcasecmp(req[0], "NAME") == 0) {
1411         send_error(client, EPWMD_ATTR_SYNTAX);
1412         goto blah;
1413     }
1414
1415     if (reset_reader(client->doc, &client->reader) == FALSE) {
1416         xml_error = xmlGetLastError();
1417         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1418         send_error(client, EPWMD_LIBXML_ERROR);
1419         goto blah;
1420     }
1421
1422     if (find_account(client->reader, epath[0]) == FALSE) {
1423         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1424         goto blah;
1425     }
1426
1427     if (epath[1]) {
1428         if ((find_elements(client, client->reader, epath+1, 0)) == FALSE)
1429             goto blah;
1430     }
1431
1432     if ((n = xmlTextReaderCurrentNode(client->reader)) == NULL) {
1433         xml_error = xmlGetLastError();
1434         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1435         send_error(client, EPWMD_LIBXML_ERROR);
1436         goto blah;
1437     }
1438
1439     if ((a = xmlHasProp(n, (xmlChar *)req[0])) == NULL) {
1440         send_error(client, EPWMD_ATTR_NOT_FOUND);
1441         goto blah;
1442     }
1443
1444     if (xmlRemoveProp(a) == -1) {
1445         xml_error = xmlGetLastError();
1446         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1447         send_error(client, EPWMD_LIBXML_ERROR);
1448         goto blah;
1449     }
1450
1451     g_strfreev(epath);
1452     return TRUE;
1453 blah:
1454     g_strfreev(epath);
1455     return FALSE;
1456 }
1457
1458 /*
1459  * req[0] - source element path
1460  * req[1] - destination element path
1461  */
1462 static gboolean target_attribute(struct client_s *client, gchar **req)
1463 {
1464     gchar **src, **dst, *line;
1465     xmlErrorPtr xml_error;
1466
1467     if (!req || !req[0] || !req[1]) {
1468         send_error(client, EPWMD_COMMAND_SYNTAX);
1469         return FALSE;
1470     }
1471
1472     if ((src = split_input_line(req[0], "\t", 0)) == NULL) {
1473         /*
1474          * The first argument may be only an account.
1475          */
1476         if ((src = split_input_line(req[0], " ", 0)) == NULL) {
1477             send_error(client, EPWMD_COMMAND_SYNTAX);
1478             return FALSE;
1479         }
1480     }
1481
1482     if ((dst = split_input_line(req[1], "\t", 0)) == NULL) {
1483         /*
1484          * The first argument may be only an account.
1485          */
1486         if ((dst = split_input_line(req[1], " ", 0)) == NULL) {
1487             send_error(client, EPWMD_COMMAND_SYNTAX);
1488             g_strfreev(src);
1489             goto blah;
1490         }
1491     }
1492
1493     /*
1494      * Prevent an element tree pointing to only and account. Accounts require
1495      * at least one element. Accounts pointing to accounts are allowed.
1496      */
1497     if ((!src[1] && dst[1]) || (!dst[1] && src[1])) {
1498         send_error(client, EPWMD_ATTR_SYNTAX);
1499         g_strfreev(src);
1500         g_strfreev(dst);
1501         goto blah;
1502     }
1503
1504     if (reset_reader(client->doc, &client->reader) == FALSE) {
1505         xml_error = xmlGetLastError();
1506         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1507         send_error(client, EPWMD_LIBXML_ERROR);
1508         g_strfreev(src);
1509         g_strfreev(dst);
1510         goto blah;
1511     }
1512
1513     /*
1514      * Make sure the destination element path exists.
1515      */
1516     if (find_account(client->reader, dst[0]) == FALSE) {
1517         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1518         g_strfreev(src);
1519         g_strfreev(dst);
1520         goto blah;
1521     }
1522
1523     if (dst[1]) {
1524         if (find_elements(client, client->reader, dst+1, 0) == FALSE) {
1525             g_strfreev(src);
1526             g_strfreev(dst);
1527             goto blah;
1528         }
1529     }
1530
1531     if (reset_reader(client->doc, &client->reader) == FALSE) {
1532         xml_error = xmlGetLastError();
1533         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1534         send_error(client, EPWMD_LIBXML_ERROR);
1535         g_strfreev(src);
1536         g_strfreev(dst);
1537         goto blah;
1538     }
1539
1540     /*
1541      * If the source element tree doesn't exist, create it.
1542      */
1543     if (find_account(client->reader, src[0]) == FALSE) {
1544         if (new_account(client->doc, src[0]) == FALSE) {
1545             xml_error = xmlGetLastError();
1546             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1547             send_error(client, EPWMD_LIBXML_ERROR);
1548             g_strfreev(src);
1549             g_strfreev(dst);
1550             goto blah;
1551         }
1552
1553         if (reset_reader(client->doc, &client->reader) == FALSE) {
1554             xml_error = xmlGetLastError();
1555             log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1556             send_error(client, EPWMD_LIBXML_ERROR);
1557             g_strfreev(src);
1558             g_strfreev(dst);
1559             goto blah;
1560         }
1561
1562         if (find_account(client->reader, src[0]) == FALSE) {
1563             send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1564             g_strfreev(src);
1565             g_strfreev(dst);
1566             goto blah;
1567         }
1568     }
1569
1570     if (src[1]) {
1571         if (find_elements(client, client->reader, src+1, 1) == FALSE) {
1572             if (reset_reader(client->doc, &client->reader) == FALSE) {
1573                 xml_error = xmlGetLastError();
1574                 log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1575                 send_error(client, EPWMD_LIBXML_ERROR);
1576                 g_strfreev(src);
1577                 g_strfreev(dst);
1578                 goto blah;
1579             }
1580
1581             if (find_account(client->reader, src[0]) == FALSE) {
1582                 send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1583                 g_strfreev(src);
1584                 g_strfreev(dst);
1585                 goto blah;
1586             }
1587
1588             xmlTextReaderNext(client->reader);
1589
1590             if (create_elements(client, client->reader, src+1, 1) == FALSE) {
1591                 g_strfreev(src);
1592                 g_strfreev(dst);
1593                 goto blah;
1594             }
1595
1596             if (reset_reader(client->doc, &client->reader) == FALSE) {
1597                 xml_error = xmlGetLastError();
1598                 log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1599                 send_error(client, EPWMD_LIBXML_ERROR);
1600                 g_strfreev(src);
1601                 g_strfreev(dst);
1602                 goto blah;
1603             }
1604
1605             if (find_account(client->reader, src[0]) == FALSE) {
1606                 send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1607                 g_strfreev(src);
1608                 g_strfreev(dst);
1609                 goto blah;
1610             }
1611
1612             if (find_elements(client, client->reader, src+1, 0) == FALSE) {
1613                 g_strfreev(src);
1614                 g_strfreev(dst);
1615                 goto blah;
1616             }
1617         }
1618     }
1619
1620     line = g_strjoinv("\t", dst);
1621
1622     if (add_attribute(client, "target", line) == FALSE) {
1623         g_free(line);
1624         g_strfreev(src);
1625         g_strfreev(dst);
1626         goto blah;
1627     }
1628
1629     g_strfreev(src);
1630     g_strfreev(dst);
1631     g_free(line);
1632     return TRUE;
1633 blah:
1634     g_strfreev(src);
1635     g_strfreev(dst);
1636     return FALSE;
1637 }
1638
1639 /*
1640  * req[0] - account name
1641  * req[1] - new name
1642  */
1643 static gboolean name_attribute(struct client_s *client, gchar **req)
1644 {
1645     xmlErrorPtr xml_error;
1646
1647     if (reset_reader(client->doc, &client->reader) == FALSE) {
1648         xml_error = xmlGetLastError();
1649         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1650         send_error(client, EPWMD_LIBXML_ERROR);
1651         return FALSE;
1652     }
1653
1654     if (find_account(client->reader, req[0]) == FALSE) {
1655         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1656         return FALSE;
1657     }
1658
1659     if (strcmp(req[0], req[1]) == 0)
1660         return TRUE;
1661
1662     if (reset_reader(client->doc, &client->reader) == FALSE) {
1663         xml_error = xmlGetLastError();
1664         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1665         send_error(client, EPWMD_LIBXML_ERROR);
1666         return FALSE;
1667     }
1668
1669     /*
1670      * Will not overwrite an existing account.
1671      */
1672     if (find_account(client->reader, req[1]) == TRUE) {
1673         send_error(client, EPWMD_ACCOUNT_EXISTS);
1674         return FALSE;
1675     }
1676
1677     if (reset_reader(client->doc, &client->reader) == FALSE) {
1678         xml_error = xmlGetLastError();
1679         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1680         send_error(client, EPWMD_LIBXML_ERROR);
1681         return FALSE;
1682     }
1683
1684     if (find_account(client->reader, req[0]) == FALSE) {
1685         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1686         return FALSE;
1687     }
1688
1689     /*
1690      * Whitespace not allowed in account names.
1691      */
1692     if (contains_whitespace(req[1]) == TRUE) {
1693         send_error(client, EPWMD_ATTR_SYNTAX);
1694         return FALSE;
1695     }
1696
1697     return add_attribute(client, "name", req[1]);
1698 }
1699
1700 /*
1701  * req[0] - attribute
1702  * req[1] - element path
1703  *
1704  * If the element has a "target" attribute it won't be "followed".
1705  */
1706 static gboolean attribute_get(struct client_s *client, gchar **req)
1707 {
1708     xmlNodePtr n;
1709     xmlChar *a;
1710     gchar **nreq = NULL;
1711     xmlErrorPtr xml_error;
1712
1713     if (!req || !req[0] || !req[1]) {
1714         send_error(client, EPWMD_COMMAND_SYNTAX);
1715         return FALSE;
1716     }
1717
1718     if (strchr(req[1], '\t')) {
1719         if ((nreq = split_input_line(req[1], "\t", 0)) == NULL) {
1720             send_error(client, EPWMD_COMMAND_SYNTAX);
1721             return FALSE;
1722         }
1723     }
1724     else {
1725         if ((nreq = split_input_line(req[1], " ", 0)) == NULL) {
1726             send_error(client, EPWMD_COMMAND_SYNTAX);
1727             return FALSE;
1728         }
1729     }
1730
1731     if (reset_reader(client->doc, &client->reader) == FALSE) {
1732         xml_error = xmlGetLastError();
1733         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1734         g_strfreev(nreq);
1735         send_error(client, EPWMD_LIBXML_ERROR);
1736         return FALSE;
1737     }
1738
1739     if (find_account(client->reader, nreq[0]) == FALSE) {
1740         g_strfreev(nreq);
1741         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1742         return FALSE;
1743     }
1744
1745     if (nreq[1]) {
1746         if (find_elements(client, client->reader, nreq + 1, 0) == FALSE) {
1747             g_strfreev(nreq);
1748             return FALSE;
1749         }
1750     }
1751
1752     g_strfreev(nreq);
1753
1754     if ((n = xmlTextReaderCurrentNode(client->reader)) == NULL) {
1755         xml_error = xmlGetLastError();
1756         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1757         send_error(client, EPWMD_LIBXML_ERROR);
1758         return FALSE;
1759     }
1760
1761     if ((a = xmlGetProp(n, (xmlChar *)req[0])) == NULL) {
1762         send_error(client, EPWMD_ATTR_NOT_FOUND);
1763         return FALSE;
1764     }
1765
1766     send_to_client(client, "BEGIN %li\n%s\n", xmlStrlen(a), a);
1767     xmlFree(a);
1768     return TRUE;
1769 }
1770
1771 /*
1772  * req[0] - attribute
1773  * req[1] - element path
1774  * req[2] - value
1775  */
1776 static gboolean attribute_set(struct client_s *client, gchar **req)
1777 {
1778     gchar **epath = NULL;
1779     xmlErrorPtr xml_error;
1780
1781     if (!req || !req[0] || !req[1] || !req[2]) {
1782         send_error(client, EPWMD_COMMAND_SYNTAX);
1783         return FALSE;
1784     }
1785
1786     /*
1787      * Reserved attribute names.
1788      */
1789     if (g_ascii_strcasecmp(req[0], "NAME") == 0) {
1790         /*
1791          * Only reserved for the account element. Not the rest of the
1792          * document.
1793          */
1794         if (strchr(req[1], '\t') == NULL)
1795             return name_attribute(client, req + 1);
1796     }
1797     else if (g_ascii_strcasecmp(req[0], "TARGET") == 0)
1798         return target_attribute(client, req + 1);
1799
1800     if ((epath = split_input_line(req[1], "\t", 0)) == NULL) {
1801         /*
1802          * The first argument may be only an account.
1803          */
1804         if ((epath = split_input_line(req[1], " ", 0)) == NULL) {
1805             send_error(client, EPWMD_COMMAND_SYNTAX);
1806             return FALSE;
1807         }
1808     }
1809
1810     if (reset_reader(client->doc, &client->reader) == FALSE) {
1811         xml_error = xmlGetLastError();
1812         log_write("%s(%i): %s", __FILE__, __LINE__, xml_error->message);
1813         send_error(client, EPWMD_LIBXML_ERROR);
1814         goto blah;
1815     }
1816
1817     if (find_account(client->reader, epath[0]) == FALSE) {
1818         send_error(client, EPWMD_ELEMENT_NOT_FOUND);
1819         goto blah;
1820     }
1821
1822     if (epath[1]) {
1823         if ((find_elements(client, client->reader, epath+1, 0)) == FALSE)
1824             goto blah;
1825     }
1826
1827     g_strfreev(epath);
1828     return add_attribute(client, req[0], req[2]);
1829 blah:
1830     g_strfreev(epath);
1831     return FALSE;
1832 }
1833
1834 /*
1835  * req[0] - command
1836  * req[1] - attribute name or element path if command is LIST
1837  * req[2] - element path
1838  * req[2] - element path or value
1839  */
1840 gboolean attr_command(struct client_s *client, gchar **req)
1841 {
1842     if (!req || !req[0] || !req[1]) {
1843         send_error(client, EPWMD_COMMAND_SYNTAX);
1844         return FALSE;
1845     }
1846
1847     if (g_ascii_strcasecmp(req[0], "SET") == 0)
1848         return attribute_set(client, req+1);
1849     if (g_ascii_strcasecmp(req[0], "GET") == 0)
1850         return attribute_get(client, req+1);
1851     else if (g_ascii_strcasecmp(req[0], "DELETE") == 0)
1852         return attribute_delete(client, req+1);
1853     else if (g_ascii_strcasecmp(req[0], "LIST") == 0)
1854         return attribute_list(client, req+1);
1855     else
1856         send_error(client, EPWMD_COMMAND_SYNTAX);
1857
1858     return FALSE;
1859 }
1860
1861 gboolean cache_test(const guchar *md5filename, gint reset)
1862 {
1863     void *p;
1864     file_cache_t f;
1865     glong len;
1866
1867     for (p = shm_data, len = 0; len <= cache_size;) {
1868         memcpy(&f, p, sizeof(file_cache_t));
1869
1870         if (reset == 2) {
1871             memset(&f, 0, sizeof(file_cache_t));
1872             memcpy(p, &f, sizeof(file_cache_t));
1873             p += sizeof(file_cache_t);
1874             len += sizeof(file_cache_t);
1875
1876             if (len + sizeof(file_cache_t) > cache_size)
1877                 break;
1878             continue;
1879         }
1880
1881         if (f.used == TRUE) {
1882             if (memcmp((gchar *)f.filename, (gchar *)md5filename, sizeof(f.filename)) == 0) {
1883                 if (reset == 1) {
1884                     memset(&f, 0, sizeof(file_cache_t));
1885                     memcpy(p, &f, sizeof(file_cache_t));
1886                     return TRUE;
1887                 }
1888
1889                 return cache_valid_key(f.key, sizeof(f.key));
1890             }
1891         }
1892
1893         p += sizeof(file_cache_t);
1894         len += sizeof(file_cache_t);
1895
1896         if (len + sizeof(file_cache_t) > cache_size)
1897             break;
1898     }
1899
1900     return (reset == 2) ? TRUE : FALSE;
1901 }
1902
1903 static gboolean file_exists(const gchar *filename)
1904 {
1905     struct stat st;
1906     gchar filebuf[PATH_MAX], *p, *p2;
1907
1908     p = get_key_file_string("default", "data_directory");
1909     p2 = expand_homedir(p);
1910     g_free(p);
1911     snprintf(filebuf, sizeof(filebuf), "%s/%s", p2, filename);
1912     g_free(p2);
1913
1914     if (access(filebuf, R_OK) == -1)
1915         return FALSE;
1916
1917     stat(filebuf, &st);
1918
1919     if (st.st_size == 0)
1920         return FALSE;
1921
1922     return TRUE;
1923 }
1924
1925 gboolean cache_command(struct client_s *client, gchar **req)
1926 {
1927     guchar md5file[16];
1928     glong timeout;
1929     gchar *p;
1930
1931     if (g_ascii_strcasecmp(req[0], "CLEAR") == 0) {
1932         if (!req[1]) {
1933             send_error(client, EPWMD_COMMAND_SYNTAX);
1934             return FALSE;
1935         }
1936
1937         gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[1], strlen(req[1]));
1938
1939         if (cache_test(md5file, 1) == FALSE) {
1940             send_error(client, EPWMD_CACHE_NOT_FOUND);
1941             return FALSE;
1942         }
1943
1944         return TRUE;
1945     }
1946     else if (g_ascii_strcasecmp(req[0], "CLEARALL") == 0) {
1947         cache_test(client->md5file, 2);
1948         return TRUE;
1949     }
1950     else if (g_ascii_strcasecmp(req[0], "ISCACHED") == 0) {
1951         if (!req[1]) {
1952             send_error(client, EPWMD_COMMAND_SYNTAX);
1953             return FALSE;
1954         }
1955
1956         if (file_exists(req[1]) == FALSE) {
1957             send_error(client, EPWMD_FILE_NOT_FOUND);
1958             return FALSE;
1959         }
1960
1961         gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[1], strlen(req[1]));
1962
1963         if (cache_test(md5file, 0) == FALSE) {
1964             send_error(client, EPWMD_CACHE_NOT_FOUND);
1965             return FALSE;
1966         }
1967
1968         return TRUE;
1969     }
1970     else if (g_ascii_strcasecmp(req[0], "TIMEOUT") == 0) {
1971         if (!req[1] || !req[2]) {
1972             send_error(client, EPWMD_COMMAND_SYNTAX);
1973             return FALSE;
1974         }
1975
1976         errno = 0;
1977         timeout = strtol(req[1], &p, 10);
1978
1979         if (errno != 0 || *p != 0) {
1980             send_error(client, EPWMD_COMMAND_SYNTAX);
1981             return FALSE;
1982         }
1983
1984         if (file_exists(req[2]) == FALSE) {
1985             send_error(client, EPWMD_FILE_NOT_FOUND);
1986             return FALSE;
1987         }
1988
1989         gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[2], strlen(req[2]));
1990
1991         if (cache_set_timeout(md5file, timeout) == FALSE) {
1992             send_error(client, EPWMD_CACHE_NOT_FOUND);
1993             return FALSE;
1994         }
1995
1996         return TRUE;
1997     }
1998     else
1999         send_error(client, EPWMD_COMMAND_SYNTAX);
2000
2001     return FALSE;
2002 }
2003
2004 gboolean help_command(struct client_s *client, const gchar *what)
2005 {
2006     gchar *line;
2007
2008     if (!what || !*what)
2009         line =
2010             "NFO Try 'HELP COMMAND' for command help\n"
2011             "NFO OPEN LIST GET STORE DELETE ATTR CACHE SAVE DUMP QUIT\n";
2012     else if (g_ascii_strcasecmp(what, "GET") == 0)
2013         line =
2014             "NFO syntax: GET account <TAB> element [<TAB> element ...]\n"
2015             "NFO <account> is the account to work on and <element>\n"
2016             "NFO is the element wanted.\n"
2017             "NFO -\n"
2018             "NFO Example: GET isp <TAB> imap <TAB> port\n"
2019             "NFO          GET isp <TAB> username\n";
2020     else if (g_ascii_strcasecmp(what, "QUIT") == 0)
2021         line =
2022             "NFO syntax: QUIT\n"
2023             "NFO close the connection\n";
2024     else if (g_ascii_strcasecmp(what, "DELETE") == 0)
2025         line =
2026             "NFO syntax: DELETE account <TAB> element [<TAB> element ...]\n";
2027     else if (g_ascii_strcasecmp(what, "STORE") == 0)
2028         line =
2029             "NFO syntax: STORE account <TAB> element [<TAB> element ...] <TAB> value\n"
2030             "NFO <account> is the account to work on and <element>\n"
2031             "NFO is the element to create or modify\n"
2032             "NFO -\n"
2033             "NFO Example: STORE isp <TAB> imap <TAB> port <TAB> 993\n"
2034             "NFO          STORE isp <TAB> username <TAB> someuser\n";
2035     else if (g_ascii_strcasecmp(what, "OPEN") == 0)
2036         line =
2037             "NFO syntax: OPEN <filename> [<key>]\n"
2038             "NFO opens a (new) file\n";
2039     else if (g_ascii_strcasecmp(what, "LIST") == 0)
2040         line =
2041             "NFO syntax: LIST [account]\n"
2042             "NFO shows available accounts or account elements\n";
2043     else if (g_ascii_strcasecmp(what, "ATTR") == 0)
2044         line =
2045             "NFO syntax: ATTR SET|GET|DELETE|LIST [ATTRIBUTE] arg1 [arg2]\n"
2046             "NFO    ATTR SET    NAME      account                    value\n"
2047             "NFO    ATTR SET    TARGET    account[<TAB>element[...]] account[<TAB>element[...]\n"
2048             "NFO    ATTR SET    attribute account[<TAB>element[...]] attribute_value\n"
2049             "NFO    ATTR DELETE attribute account[<TAB>element[...]]\n"
2050             "NFO    ATTR GET    attribute account[<TAB>element[...]]\n"
2051             "NFO    ATTR LIST   account[<TAB>element[...]]\n";
2052     else if (g_ascii_strcasecmp(what, "SAVE") == 0)
2053         line =
2054             "NFO syntax: SAVE [<key>]\n"
2055             "NFO save any changes to the opened file using <key>\n";
2056     else if (g_ascii_strcasecmp(what, "CACHE") == 0)
2057         line =
2058             "NFO syntax: CACHE [CLEARALL | [CLEAR | ISCACHED <filename>] |\n"
2059             "NFO                TIMEOUT <seconds> <filename>]\n"
2060             "NFO tests or clears the cache entry for <filename>\n";
2061     else if (g_ascii_strcasecmp(what, "DUMP") == 0)
2062         line =
2063             "NFO syntax: DUMP\n"
2064             "NFO shows the in memory XML document\n";
2065     else {
2066         send_error(client, EPWMD_COMMAND_SYNTAX);
2067         return FALSE;
2068     }
2069
2070     send_to_client(client, "%sOK \n", line);
2071     return TRUE;
2072 }
2073
2074 gboolean dump_command(struct client_s *client)
2075 {
2076     xmlChar *xml;
2077     gssize len;
2078
2079     xmlDocDumpFormatMemory(client->doc, &xml, &len, 1);
2080     send_to_client(client, "BEGIN %li\n%s", len, xml);
2081     xmlFree(xml);
2082     return TRUE;
2083 }