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