src/config1.c

   1 /* Gnome Music Player Client (GMPC)
   2  * Copyright (C) 2004-2011 Qball Cow <qball@sarine.nl>
   3  * Project homepage: http://gmpc.wikia.com/
   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 along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <glib.h>
  24 #include <glib/gstdio.h>
  25 #ifndef WIN32
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #endif
  29 #include "config1.h"
  30
  31 #define LOG_DOMAIN "Config"
  32
  33 typedef enum _ConfigNodeType
  34 {
  35     TYPE_CATEGORY,
  36     TYPE_ITEM,
  37     TYPE_ITEM_MULTIPLE
  38 } ConfigNodeType;
  39 /**
  40  * A config node
  41  * 24byte large
  42  */
  43 typedef struct _config_node
  44 {
  45     struct _config_node *next;
  46     struct _config_node *prev;
  47     struct _config_node *parent;
  48     gchar *name;
  49     ConfigNodeType type;
  50     /* Save some extra memory by using a union
  51      *  It is actually effective because we build a resonable large tree using this
  52      */
  53     union
  54     {
  55                                  /* TYPE_CATEGORY */
  56         struct _config_node *children;
  57         gchar *value;            /* TYPE_ITEM* */
  58     };
  59 } config_node;
  60
  61 typedef struct _config_obj
  62 {
  63     gchar *url;
  64     /*  GMutex *lock;*/
  65     config_node *root;
  66     int total_size;
  67     guint save_timeout;
  68 } _config_obj;
  69
  70 static void __int_cfg_set_single_value_as_string(config_obj * cfg, const char *class, const char *sclass,
  71 const char *ssclass, const char *key, const char *value);
  72 static gboolean cfg_save_real(config_obj *);
  73 static void __int_cfg_remove_node(config_obj *, config_node *);
  74 static config_node *cfg_get_class_multiple(config_obj * cfg, config_node * root, const char *class);
  75 static void __int_cfg_do_special_cleanup(config_obj * cfg, config_node * node);
  76 static config_node *cfg_add_class(config_obj *, config_node *, const char *);
  77 static config_node *cfg_new_node(void);
  78 static void cfg_add_child(config_node *, config_node *);
  79 static void cfg_save_delayed(config_obj * cfg);
  80
  81 static void cfg_open_parse_file(config_obj * cfgo, FILE * fp)
  82 {
  83     char buffer[1024];
  84     int len = 0;
  85     int c, version = 0;
  86     config_node *cur = NULL;
  87     config_node *multiple = NULL;
  88     int firstchar = 0;
  89     while ((c = fgetc(fp)) != EOF)
  90     {
  91         if (c == '2' && !firstchar)
  92         {
  93             version = 2;
  94         }
  95         firstchar = 1;
  96         if (c == '[')
  97         {
  98             len = 0;
  99             c = fgetc(fp);
 100             while (c != ']' && c != EOF && len < 1023)
 101             {
 102                 buffer[len] = c;
 103                 len++;
 104                 c = fgetc(fp);
 105             }
 106             buffer[len] = '\0';
 107             if (len > 0 && len < 256)
 108             {
 109                 //                printf("add class: %s -> %s\n", buffer, (cur )?cur->name:"");
 110                 cur = cfg_add_class(cfgo, (version < 2) ? NULL : cur, buffer);
 111             } else if (len == 0)
 112             {
 113                 if (version < 2)
 114                 {
 115                     cur = NULL;
 116                 } else if (cur)
 117                 {
 118                     cur = cur->parent;
 119                 }
 120             }
 121             /* seek end of line */
 122             while (c != EOF && c != '\n')
 123                 c = fgetc(fp);
 124         }
 125         if (cur && c == '{')
 126         {
 127             len = 0;
 128             c = fgetc(fp);
 129             while (c != '}' && c != EOF && len < 1023)
 130             {
 131                 buffer[len] = c;
 132                 len++;
 133                 c = fgetc(fp);
 134             }
 135             buffer[len] = '\0';
 136             if (len > 0 && len < 256)
 137             {
 138                 config_node *child = cfg_new_node();
 139                 child->type = TYPE_ITEM_MULTIPLE;
 140                 child->name = g_strndup(buffer, len);
 141                 child->parent = cur;
 142                 child->children = NULL;
 143                 cfg_add_child(cur, child);
 144                 multiple = child;
 145                 cfgo->total_size += len + sizeof(config_node);
 146
 147             }
 148             if (len == 0)
 149             {
 150                 multiple = NULL;
 151             }
 152             /* seek end of line */
 153             while (c != EOF && c != '\n')
 154                 c = fgetc(fp);
 155         }
 156
 157         /* next, ignore commants  and there must be a category */
 158         else if (cur && (c == '#' || c == '/' || c == '\n' || c == ';'))
 159         {
 160             while (c != EOF && c != '\n')
 161                 c = fgetc(fp);
 162         } else if (cur)
 163         {
 164             config_node *new = NULL;
 165             len = 0;
 166             while (c != '=' && c != EOF)
 167             {
 168                 buffer[len] = c;
 169                 len++;
 170                 c = fgetc(fp);
 171             }
 172             if (len < 256 && len > 0)
 173             {
 174                 int quote = 0;
 175
 176                 /* write key name */
 177                 new = cfg_new_node();
 178                 new->parent = cur;
 179                 new->type = TYPE_ITEM;
 180                 new->name = g_strndup(buffer, len);
 181                 cfgo->total_size += len + sizeof(config_node);
 182                 /* Get value */
 183                 len = 0;
 184                 /* skip spaces */
 185                 while ((c = fgetc(fp)) == ' ') ;
 186                 /* we got a quoted string */
 187                 if (c == '"')
 188                 {
 189                     quote = 1;
 190                     c = fgetc(fp);
 191                 }
 192                 do
 193                 {
 194                     /* add escaped char */
 195                     if (c == '\\')
 196                     {
 197                         c = fgetc(fp);
 198                         if (c == 'n')
 199                         {
 200                             buffer[len] = '\n';
 201                             len++;
 202                         } else
 203                         {
 204                             buffer[len] = c;
 205                             len++;
 206                         }
 207                     }
 208                     /* We have a quoted string, and the closing quote comes */
 209                     else if (c == '"' && quote)
 210                         quote = -1;
 211                     else
 212                     {
 213                         buffer[len] = c;
 214                         len++;
 215                     }
 216                     c = fgetc(fp);
 217                 } while ((c != '\n' || quote) && c != EOF && quote >= 0 && len < 1023);
 218                 new->value = g_strndup(buffer, len);
 219                 cfgo->total_size += len;
 220                 if (multiple)
 221                 {
 222                     cfg_add_child(multiple, new);
 223                 } else
 224                 {
 225                     cfg_add_child(cur, new);
 226                 }
 227             }
 228             /* seek end of line */
 229             while (c != EOF && c != '\n')
 230                 c = fgetc(fp);
 231         } else
 232         while (c != EOF && c != '\n')
 233             c = fgetc(fp);
 234
 235     }
 236 }
 237
 238
 239 config_obj *cfg_open(gchar * url)
 240 {
 241     config_obj *cfgo = NULL;
 242     /* check if there is an url passed */
 243     if (url == NULL)
 244     {
 245         return NULL;
 246     }
 247
 248     cfgo = g_malloc(sizeof(config_obj));
 249     /* check if malloc went ok */
 250     if (cfgo == NULL)
 251     {
 252         return NULL;
 253     }
 254     /*  cfgo->lock = g_mutex_new();
 255         g_mutex_lock(cfgo->lock);
 256         */
 257     cfgo->url = g_strdup(url);
 258     cfgo->root = NULL;
 259     cfgo->total_size = sizeof(config_obj) /*+sizeof(&cfgo->lock) */  + strlen(cfgo->url);
 260     cfgo->save_timeout = 0;
 261
 262     if (g_file_test(cfgo->url, G_FILE_TEST_EXISTS))
 263     {
 264         FILE *fp = g_fopen(cfgo->url, "r");
 265         if (fp)
 266         {
 267             cfg_open_parse_file(cfgo, fp);
 268             fclose(fp);
 269         }
 270     }
 271     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Config %s: allocated: %i\n", cfgo->url, cfgo->total_size);
 272     /*
 273        g_mutex_unlock(cfgo->lock);
 274      */
 275     return cfgo;
 276 }
 277
 278
 279 void cfg_close(config_obj * cfgo)
 280 {
 281     if (cfgo == NULL)
 282     {
 283         return;
 284     }
 285     cfg_save_real(cfgo);
 286     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Closing config '%s' with %i bytes allocated\n", cfgo->url, cfgo->total_size);
 287     /*
 288        g_mutex_lock(cfgo->lock);
 289      */
 290     if (cfgo->url != NULL)
 291     {
 292         cfgo->total_size -= strlen(cfgo->url);
 293         cfg_free_string(cfgo->url);
 294     }
 295     while (cfgo->root)
 296         __int_cfg_remove_node(cfgo, cfgo->root);
 297     /*
 298        g_mutex_unlock(cfgo->lock);
 299      */
 300     cfgo->total_size -= /*sizeof(&cfgo->lock)+ */ sizeof(config_obj);
 301     /*  g_mutex_free(cfgo->lock);*/
 302     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Memory remaining: %i\n", cfgo->total_size);
 303     g_free(cfgo);
 304     cfgo = NULL;
 305 }
 306
 307
 308 static config_node *cfg_new_node(void)
 309 {
 310     config_node *newnode = g_slice_new(config_node);
 311     newnode->type = TYPE_CATEGORY;
 312     newnode->name = NULL;
 313     newnode->next = NULL;
 314     newnode->prev = NULL;
 315     newnode->parent = NULL;
 316     newnode->value = NULL;
 317     newnode->children = NULL;
 318     return newnode;
 319 }
 320
 321
 322 static config_node *cfg_add_class(config_obj * cfg, config_node * parent, const char *class)
 323 {
 324     config_node *newnode = cfg_new_node();
 325     newnode->type = TYPE_CATEGORY;
 326     newnode->name = g_strdup(class);
 327     newnode->parent = parent;
 328     cfg->total_size += sizeof(config_node) + strlen(class);
 329     if (!parent)
 330     {
 331         if (cfg->root == NULL)
 332         {
 333             cfg->root = newnode;
 334         } else
 335         {
 336             config_node *temp = cfg->root;
 337             while (temp->next != NULL)
 338                 temp = temp->next;
 339             temp->next = newnode;
 340             newnode->prev = temp;
 341         }
 342     } else
 343     {
 344         if (parent->children == NULL)
 345         {
 346             parent->children = newnode;
 347         } else
 348         {
 349             config_node *temp = parent->children;
 350             /* get last node */
 351             while (temp->next != NULL)
 352                 temp = temp->next;
 353             temp->next = newnode;
 354             newnode->prev = temp;
 355         }
 356     }
 357
 358     return newnode;
 359 }
 360
 361
 362 void cfg_add_child(config_node * parent, config_node * child)
 363 {
 364     if (parent == NULL || child == NULL)
 365         return;
 366     if (parent->type == TYPE_ITEM)
 367         return;
 368     if (parent->children == NULL)
 369     {
 370         parent->children = child;
 371         child->parent = parent;
 372     } else
 373     {
 374         config_node *temp = parent->children;
 375
 376         /* get last node */
 377         while (temp->next != NULL)
 378             temp = temp->next;
 379         temp->next = child;
 380         child->prev = temp;
 381         child->parent = parent;
 382     }
 383 }
 384
 385
 386 static void cfg_save_category(config_obj * cfg, config_node * node, FILE * fp)
 387 {
 388     config_node *temp = NULL;
 389
 390     if (node == NULL)
 391         return;
 392     /* find the first */
 393     while (node->prev != NULL)
 394         node = node->prev;
 395     /* save some stuff */
 396     for (temp = node; temp != NULL; temp = temp->next)
 397     {
 398         if (temp->type == TYPE_CATEGORY)
 399         {
 400             fputs("\n[", fp);
 401             fputs(temp->name, fp);
 402             fputs("]\n", fp);
 403             cfg_save_category(cfg, temp->children, fp);
 404             fputs("[]\n", fp);
 405         }
 406         if (temp->type == TYPE_ITEM_MULTIPLE)
 407         {
 408             fputs("\n{", fp);
 409             fputs(temp->name, fp);
 410             fputs("}\n", fp);
 411             cfg_save_category(cfg, temp->children, fp);
 412             fputs("{}\n\n", fp);
 413         } else if (temp->type == TYPE_ITEM)
 414         {
 415             int i = 0;
 416             int length = (temp->value) ? strlen(temp->value) : 0;
 417             fputs(temp->name, fp);
 418             fputs("=\"", fp);
 419             for (i = 0; i < length; i++)
 420             {
 421                 if (temp->value[i] == '"')
 422                 {
 423                     fputs("\\\"", fp);
 424                 } else if (temp->value[i] == '\\')
 425                 {
 426                     fputs("\\\\", fp);
 427                 } else if (temp->value[i] == '\n')
 428                 {
 429                     fputs("\\n", fp);
 430                 } else
 431                 {
 432                     putc(temp->value[i], fp);
 433                 }
 434             }
 435             fputs("\"\n", fp);
 436         }
 437     }
 438 }
 439
 440
 441 static gboolean cfg_save_real(config_obj * cfgo)
 442 {
 443     if (cfgo == NULL)
 444     {
 445         return FALSE;
 446     }
 447
 448     if (cfgo->save_timeout)
 449     {
 450         g_source_remove(cfgo->save_timeout);
 451         cfgo->save_timeout = 0;
 452     } else
 453     {
 454         return FALSE;
 455     }
 456     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Save triggered:%s", cfgo->url);
 457     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Saving config file: %s (%i bytes)", cfgo->url, cfgo->total_size);
 458     if (cfgo->root != NULL)
 459     {
 460         FILE *fp = g_fopen(cfgo->url, "w");
 461         if (!fp)
 462             return FALSE;
 463         fputs("2\n", fp);
 464         cfg_save_category(cfgo, cfgo->root, fp);
 465         fclose(fp);
 466         #ifndef WIN32
 467         chmod(cfgo->url, 0600);
 468         #endif
 469
 470     }
 471     return FALSE;
 472 }
 473
 474
 475 static config_node *cfg_get_class(config_obj * cfg, const char *class)
 476 {
 477     return cfg_get_class_multiple(cfg, NULL, class);
 478 }
 479
 480
 481 static config_node *cfg_get_class_multiple(config_obj * cfg, config_node * root, const char *class)
 482 {
 483     config_node *node = NULL;
 484     if (root != NULL)
 485     {
 486         node = root->children;
 487
 488     } else
 489     {
 490         node = cfg->root;
 491     }
 492     if (node == NULL)
 493         return NULL;
 494     /* find the first */
 495     while (node->prev != NULL)
 496         node = node->prev;
 497
 498     for (; node != NULL; node = node->next)
 499     {
 500         if (node->type == TYPE_CATEGORY && !strcmp(node->name, class))
 501         {
 502             return node;
 503         }
 504     }
 505
 506     return NULL;
 507 }
 508
 509
 510 static config_node *cfg_get_single_value(config_obj * cfg, const char *class, const char *sclass, const char *ssclass,
 511 const char *key)
 512 {
 513     /* take children */
 514     config_node *cur = NULL;
 515     cur = cfg_get_class(cfg, class);
 516     if (cur == NULL || cur->children == NULL)
 517     {
 518         return NULL;
 519     }
 520     if (sclass)
 521     {
 522         cur = cfg_get_class_multiple(cfg, cur, sclass);
 523         if (cur == NULL || cur->children == NULL)
 524             return NULL;
 525     }
 526     if (ssclass)
 527     {
 528         cur = cfg_get_class_multiple(cfg, cur, ssclass);
 529         if (cur == NULL || cur->children == NULL)
 530             return NULL;
 531     }
 532     cur = cur->children;
 533     for (; cur != NULL; cur = cur->next)
 534     {
 535         if (!strcmp(cur->name, key))
 536         {
 537             return cur;
 538         }
 539     }
 540     return NULL;
 541 }
 542
 543
 544 /*void cfg_free_string(char *string)
 545 {
 546     if(string != NULL)
 547     {
 548         q_free(string);
 549     }
 550 }
 551 */
 552 static char *__int_cfg_get_single_value_as_string(config_obj * cfg, const char *class, const char *sclass,
 553 const char *ssclass, const char *key)
 554 {
 555     config_node *cur = cfg_get_single_value(cfg, class, sclass, ssclass, key);
 556     if (cur != NULL)
 557     {
 558         if (cur->type == TYPE_ITEM)
 559         {
 560             return g_strdup((char *)cur->value);
 561         }
 562     }
 563     return NULL;
 564 }
 565
 566
 567 char *cfg_get_single_value_as_string(config_obj * cfg, const char *class, const char *key)
 568 {
 569     return cfg_get_single_value_as_string_mm(cfg, class, NULL, NULL, key);
 570 }
 571
 572
 573 char *cfg_get_single_value_as_string_with_default(config_obj * cfg, const char *class, const char *key, const char *def)
 574 {
 575     return cfg_get_single_value_as_string_with_default_mm(cfg, class, NULL, NULL, key, def);
 576 }
 577
 578
 579 static int __int_cfg_get_single_value_as_int_mm(config_obj * cfg, const char *class, const char *sclass,
 580 const char *ssclass, const char *key)
 581 {
 582     config_node *cur = NULL;
 583     int retv = CFG_INT_NOT_DEFINED;
 584
 585     cur = cfg_get_single_value(cfg, class, sclass, ssclass, key);
 586     if (cur != NULL)
 587     {
 588         if (cur->type == TYPE_ITEM)
 589         {
 590             retv = (int)g_ascii_strtoull(cur->value, NULL, 0);
 591         }
 592     }
 593
 594     return retv;
 595 }
 596
 597
 598 int cfg_get_single_value_as_int(config_obj * cfg, const char *class, const char *key)
 599 {
 600     int retv = 0;
 601     /*  g_mutex_lock(cfg->lock);*/
 602     retv = __int_cfg_get_single_value_as_int_mm(cfg, class, NULL, NULL, key);
 603     /*  g_mutex_unlock(cfg->lock);*/
 604     return retv;
 605 }
 606
 607
 608 void cfg_set_single_value_as_int(config_obj * cfg, const char *class, const char *key, int value)
 609 {
 610     cfg_set_single_value_as_int_mm(cfg, class, NULL, NULL, key, value);
 611 }
 612
 613
 614 static void __int_cfg_set_single_value_as_int(config_obj * cfg, const char *class, const char *sclass,
 615 const char *ssclass, const char *key, int value)
 616 {
 617     gchar *temp = NULL;
 618     temp = g_strdup_printf("%i", value);
 619     __int_cfg_set_single_value_as_string(cfg, class, sclass, ssclass, key, temp);
 620     cfg_free_string(temp);
 621 }
 622
 623
 624 int cfg_get_single_value_as_int_with_default(config_obj * cfg, const char *class, const char *key, int def)
 625 {
 626     return cfg_get_single_value_as_int_with_default_mm(cfg, class, NULL, NULL, key, def);
 627 }
 628
 629
 630 /* float */
 631 static float __int_cfg_get_single_value_as_float(config_obj * cfg, const char *class, const char *sclass,
 632 const char *ssclass, const char *key)
 633 {
 634     float result = 0;
 635     config_node *cur = NULL;
 636     cur = cfg_get_single_value(cfg, class, sclass, ssclass, key);
 637
 638     if (cur == NULL)
 639     {
 640         return CFG_INT_NOT_DEFINED;
 641     }
 642     /* make it return an error */
 643     result = g_ascii_strtod(cur->value, NULL);
 644     return result;
 645 }
 646
 647
 648 float cfg_get_single_value_as_float(config_obj * cfg, const char *class, const char *key)
 649 {
 650     float retv = 0;
 651     /*  g_mutex_lock(cfg->lock);*/
 652     retv = __int_cfg_get_single_value_as_float(cfg, class, NULL, NULL, key);
 653     /*  g_mutex_unlock(cfg->lock);*/
 654     return retv;
 655 }
 656
 657
 658 float cfg_get_single_value_as_float_mm(config_obj * cfg, const char *class, const char *sclass, const char *ssclass,
 659 const char *key)
 660 {
 661     float retv = 0;
 662     /*  g_mutex_lock(cfg->lock);*/
 663     retv = __int_cfg_get_single_value_as_float(cfg, class, sclass, ssclass, key);
 664     /*  g_mutex_unlock(cfg->lock);*/
 665     return retv;
 666 }
 667
 668
 669 void cfg_set_single_value_as_float(config_obj * cfg, const char *class, const char *key, float value)
 670 {
 671     char *value1 = NULL;
 672     /*  g_mutex_lock(cfg->lock);*/
 673     value1 = g_strdup_printf("%f", value);
 674     __int_cfg_set_single_value_as_string(cfg, class, NULL, NULL, key, value1);
 675     cfg_free_string(value1);
 676     /*  g_mutex_unlock(cfg->lock);*/
 677 }
 678
 679
 680 float cfg_get_single_value_as_float_with_default(config_obj * cfg, const char *class, const char *key, float def)
 681 {
 682     float retv = 0;
 683     /*  g_mutex_lock(cfg->lock);*/
 684     retv = __int_cfg_get_single_value_as_float(cfg, class, NULL, NULL, key);
 685     if (retv == CFG_INT_NOT_DEFINED)
 686     {
 687         char *value1 = g_strdup_printf("%f", def);
 688         __int_cfg_set_single_value_as_string(cfg, class, NULL, NULL, key, value1);
 689         cfg_free_string(value1);
 690         retv = __int_cfg_get_single_value_as_float(cfg, class, NULL, NULL, key);
 691     }
 692     /*  g_mutex_unlock(cfg->lock);*/
 693     /* make it return an error */
 694     return retv;
 695 }
 696
 697
 698 static void __int_cfg_remove_node(config_obj * cfg, config_node * node)
 699 {
 700     if (node->type != TYPE_ITEM)
 701     {
 702         while (node->children)
 703         {
 704             __int_cfg_remove_node(cfg, node->children);
 705         }
 706     }
 707     /*  only child, and I have a parent */
 708     if (node->next == NULL && node->prev == NULL && node->parent)
 709     {
 710         /* remove from list */
 711         if (node->parent->type != TYPE_ITEM)
 712         {
 713             node->parent->children = NULL;
 714         }
 715     }
 716     /* remove node from linked list */
 717     if (node->prev != NULL)
 718     {
 719         if (node->parent && node->parent->children == node)
 720         {
 721             node->parent->children = node->prev;
 722         }
 723         node->prev->next = node->next;
 724     }
 725     if (node->next != NULL)
 726     {
 727         if (node->parent && node->parent->children == node)
 728         {
 729             node->parent->children = node->next;
 730         }
 731         node->next->prev = node->prev;
 732     }
 733     if (node == cfg->root)
 734     {
 735         if (node->prev)
 736         {
 737             cfg->root = node->prev;
 738         } else if (node->next)
 739         {
 740             cfg->root = node->next;
 741         } else
 742         {
 743             cfg->root = NULL;
 744         }
 745     }
 746     cfg->total_size -= sizeof(config_node);
 747     if (node->name)
 748     {
 749         cfg->total_size -= strlen(node->name);
 750         cfg_free_string(node->name);
 751     }
 752     if (node->value)
 753     {
 754         cfg->total_size -= strlen(node->value);
 755         cfg_free_string(node->value);
 756     }
 757     g_slice_free(config_node, node);
 758 }
 759
 760
 761 void cfg_del_single_value_mm(config_obj * cfg, const char *class, const char *sclass, const char *ssclass,
 762 const char *key)
 763 {
 764     config_node *node = NULL;
 765     /*  g_mutex_lock(cfg->lock);*/
 766     node = cfg_get_single_value(cfg, class, sclass, ssclass, key);
 767     if (node != NULL)
 768     {
 769         __int_cfg_remove_node(cfg, node);
 770         cfg_save_delayed(cfg);
 771         g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "triggered save delay: del: %s, %s", class, key);
 772     }
 773     /*  g_mutex_unlock(cfg->lock);*/
 774 }
 775
 776
 777 void cfg_del_single_value(config_obj * cfg, const char *class, const char *key)
 778 {
 779     cfg_del_single_value_mm(cfg, class, NULL, NULL, key);
 780 }
 781
 782
 783 void cfg_remove_class(config_obj * cfg, const char *class)
 784 {
 785     config_node *node = NULL;
 786     if (cfg == NULL || class == NULL)
 787         return;
 788
 789     /*  g_mutex_lock(cfg->lock);*/
 790     node = cfg_get_class(cfg, class);
 791     if (node)
 792     {
 793         __int_cfg_remove_node(cfg, node);
 794     }
 795     cfg_save_delayed(cfg);
 796     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "triggered save delay: del: %s", class);
 797     /*    g_mutex_unlock(cfg->lock);*/
 798 }
 799
 800
 801 static void __int_cfg_set_single_value_as_string(config_obj * cfg, const char *class, const char *sclass,
 802 const char *ssclass, const char *key, const char *value)
 803 {
 804     config_node *newnode = cfg_get_single_value(cfg, class, sclass, ssclass, key);
 805     if (newnode == NULL)
 806     {
 807         config_node *node = cfg_get_class(cfg, class);
 808         if (node == NULL)
 809         {
 810             node = cfg_add_class(cfg, NULL, class);
 811             if (node == NULL)
 812                 return;
 813         }
 814         if (sclass)
 815         {
 816             config_node *nnode = cfg_get_class_multiple(cfg, node, sclass);
 817             if (nnode == NULL)
 818             {
 819                 nnode = cfg_add_class(cfg, node, sclass);
 820                 if (nnode == NULL)
 821                     return;
 822             }
 823             node = nnode;
 824         }
 825         if (ssclass)
 826         {
 827             config_node *nnode = cfg_get_class_multiple(cfg, node, ssclass);
 828             if (nnode == NULL)
 829             {
 830                 nnode = cfg_add_class(cfg, node, ssclass);
 831                 if (nnode == NULL)
 832                     return;
 833             }
 834             node = nnode;
 835         }
 836         newnode = cfg_new_node();
 837         newnode->name = g_strdup(key);
 838         cfg->total_size += sizeof(config_node) + strlen(key);
 839         cfg_add_child(node, newnode);
 840
 841     } else if ((value == NULL && newnode->value == NULL) ||
 842         (value != NULL && newnode->value != NULL && strlen(newnode->value) == strlen(value)
 843         && !memcmp(newnode->value, value, strlen(newnode->value))))
 844     {
 845         /* Check if the content is the same, if it is, do nothing */
 846         return;
 847     }
 848     newnode->type = TYPE_ITEM;
 849     if (newnode->value)
 850     {
 851         cfg->total_size -= strlen(newnode->value);
 852         cfg_free_string(newnode->value);
 853     }
 854     if (value)
 855     {
 856         newnode->value = g_strdup(value);
 857         cfg->total_size += strlen(value);
 858     } else
 859     {
 860         newnode->value = NULL;
 861     }
 862     cfg_save_delayed(cfg);
 863     g_log(LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "triggered save delay: set: %s,%s -> %s", class, key, value);
 864 }
 865
 866
 867 void cfg_set_single_value_as_string(config_obj * cfg, const char *class, const char *key, const char *value)
 868 {
 869     /*  g_mutex_lock(cfg->lock);*/
 870     __int_cfg_set_single_value_as_string(cfg, class, NULL, NULL, key, value);
 871     /*  g_mutex_unlock(cfg->lock);*/
 872 }
 873
 874
 875 /* multiple values */
 876
 877 static config_node *cfg_get_multiple_value(config_obj * cfg, const char *class, const char *key, const char *id)
 878 {
 879     config_node *node = cfg_get_single_value(cfg, class, NULL, NULL, key);
 880     if (node == NULL)
 881     {
 882         return NULL;
 883     }
 884     if (node->type != TYPE_ITEM_MULTIPLE)
 885     {
 886         return NULL;
 887     }
 888     if (node->children == NULL)
 889     {
 890         return NULL;
 891     }
 892     /* first */
 893     node = node->children;
 894     while (node->prev != NULL)
 895         node = node->prev;
 896     /* get item */
 897     for (; node != NULL; node = node->next)
 898     {
 899         if (!strcmp(node->name, id))
 900         {
 901             return node;
 902         }
 903     }
 904     return NULL;
 905 }
 906
 907
 908 void cfg_del_multiple_value(config_obj * cfg, const char *class, const char *key, const char *id)
 909 {
 910     config_node *cur = NULL;
 911     /*  g_mutex_lock(cfg->lock);*/
 912     cur = cfg_get_multiple_value(cfg, class, key, id);
 913     if (cur != NULL)
 914     {
 915         __int_cfg_remove_node(cfg, cur);
 916         cfg_save_delayed(cfg);
 917     }
 918     /*  g_mutex_unlock(cfg->lock);*/
 919 }
 920
 921
 922 void cfg_set_multiple_value_as_string(config_obj * cfg, const char *class, const char *key, const char *id,
 923 const char *value)
 924 {
 925     config_node *cur = NULL;
 926     /*  g_mutex_lock(cfg->lock);*/
 927     cur = cfg_get_multiple_value(cfg, class, key, id);
 928     if (cur != NULL)
 929     {
 930         if (strlen(cur->value) == strlen(value) && !memcmp(cur->value, value, strlen(cur->value)))
 931         {
 932             return;
 933         }
 934         if (cur->value)
 935         {
 936             cfg->total_size -= strlen(cur->value);
 937             cfg_free_string(cur->value);
 938         }
 939
 940         cur->value = g_strdup(value);
 941         cfg->total_size += strlen(cur->value);
 942         cfg_save_delayed(cfg);
 943     } else
 944     {
 945         config_node *node = cfg_get_single_value(cfg, class, NULL, NULL, key);
 946         if (node == NULL)
 947         {
 948             node = cfg_get_class(cfg, class);
 949             if (node == NULL)
 950             {
 951                 node = cfg_add_class(cfg, NULL, class);
 952             }
 953             cur = cfg_new_node();
 954             cur->name = g_strdup(key);
 955             cur->type = TYPE_ITEM_MULTIPLE;
 956             cfg_add_child(node, cur);
 957             cfg->total_size += sizeof(config_node) + strlen(key);
 958             node = cur;
 959         }
 960         if (node->type != TYPE_ITEM_MULTIPLE)
 961             return;
 962         cur = cfg_new_node();
 963         cur->type = TYPE_ITEM;
 964         cur->name = g_strdup(id);
 965         cur->value = g_strdup(value);
 966         cfg->total_size += sizeof(config_node) + strlen(id) + strlen(value);;
 967         cfg_add_child(node, cur);
 968         cfg_save_delayed(cfg);
 969     }
 970     /*  g_mutex_unlock(cfg->lock);*/
 971 }
 972
 973
 974 conf_mult_obj *cfg_get_multiple_as_string(config_obj * cfg, const char *class, const char *key)
 975 {
 976     conf_mult_obj *list = NULL;
 977     config_node *cur = NULL;
 978     /*  g_mutex_lock(cfg->lock);*/
 979     cur = cfg_get_single_value(cfg, class, NULL, NULL, key);
 980     if (cur && cur->type == TYPE_ITEM_MULTIPLE && cur->children != NULL)
 981     {
 982         cur = cur->children;
 983         /* get first */
 984         while (cur->prev != NULL)
 985             cur = cur->prev;
 986         do
 987         {
 988             conf_mult_obj *temp = g_slice_new0(conf_mult_obj);
 989             temp->value = g_strdup(cur->value);
 990             temp->key = g_strdup(cur->name);
 991             temp->next = list;
 992             if (temp->next)
 993                 temp->next->prev = temp;
 994             list = temp;
 995             cur = cur->next;
 996         } while (cur != NULL);
 997     }
 998     /*  g_mutex_unlock(cfg->lock);*/
 999     return list;
1000 }
1001
1002
1003 void cfg_free_multiple(conf_mult_obj * data)
1004 {
1005     conf_mult_obj *list = data;
1006     if (list == NULL)
1007         return;
1008     /* go to first */
1009     while (list->prev != NULL)
1010     {
1011         list = list->prev;
1012     }
1013     while (list != NULL)
1014     {
1015         if (list->value)
1016             cfg_free_string(list->value);
1017         if (list->key)
1018             cfg_free_string(list->key);
1019         if (list->next != NULL)
1020         {
1021             if (list->prev)
1022                 g_slice_free(conf_mult_obj, list->prev);
1023             list = list->next;
1024         } else
1025         {
1026             g_slice_free(conf_mult_obj, list->prev);
1027             g_slice_free(conf_mult_obj, list);
1028             list = NULL;
1029         }
1030     }
1031 }
1032
1033
1034 conf_mult_obj *cfg_get_class_list(config_obj * data)
1035 {
1036     conf_mult_obj *list = NULL;
1037     config_node *root = NULL;
1038     if (!data)
1039         return NULL;
1040     if (!data->root)
1041         return NULL;
1042     /*  g_mutex_lock(data->lock);*/
1043     root = data->root;
1044     while (root->prev != NULL)
1045         root = root->prev;
1046     do
1047     {
1048         if (root->type == TYPE_CATEGORY)
1049         {
1050             conf_mult_obj *temp = g_slice_new0(conf_mult_obj);
1051             temp->value = NULL;
1052             temp->key = g_strdup(root->name);
1053             temp->next = list;
1054             if (temp->next)
1055                 temp->next->prev = temp;
1056             list = temp;
1057         }
1058         root = root->next;
1059     } while (root != NULL);
1060     while (list->prev != NULL)
1061         list = list->prev;
1062     /*  g_mutex_unlock(data->lock);*/
1063
1064     return list;
1065 }
1066
1067
1068 conf_mult_obj *cfg_get_key_list(config_obj * data, const char *class)
1069 {
1070     conf_mult_obj *list = NULL;
1071     config_node *root = NULL;
1072     if (data == NULL)
1073         return NULL;
1074     if (data->root == NULL)
1075         return NULL;
1076     /*  g_mutex_lock(data->lock);*/
1077     root = cfg_get_class(data, class);
1078     if (!root || !root->children)
1079     {
1080         /*              g_mutex_unlock(data->lock);*/
1081         return NULL;
1082     }
1083     root = root->children;
1084     while (root->prev != NULL)
1085         root = root->prev;
1086     do
1087     {
1088         if (root->type == TYPE_ITEM)
1089         {
1090             conf_mult_obj *temp = g_slice_new0(conf_mult_obj);
1091             temp->value = g_strdup(root->value);
1092             temp->key = g_strdup(root->name);
1093             temp->next = list;
1094             if (temp->next)
1095                 temp->next->prev = temp;
1096             list = temp;
1097         }
1098         root = root->next;
1099     } while (root != NULL);
1100     while (list && list->prev != NULL)
1101         list = list->prev;
1102     /*  g_mutex_unlock(data->lock);*/
1103     return list;
1104 }
1105
1106
1107 static void __int_cfg_do_special_cleanup(config_obj * cfg, config_node * node)
1108 {
1109     config_node *item, *root = NULL;
1110     if (!cfg || !cfg->root)
1111         return;
1112     if (node == NULL)
1113         root = cfg->root;
1114     else
1115         root = node;
1116     if (!root)
1117         return;
1118     while (root)
1119     {
1120         if (root->type == TYPE_CATEGORY)
1121         {
1122             if (root->children)
1123                 __int_cfg_do_special_cleanup(cfg, root->children);
1124             if (root->children == NULL)
1125             {
1126                 item = NULL;
1127                 if (root->prev)
1128                     item = root->prev;
1129                 else if (root->next)
1130                     item = root->next;
1131                 __int_cfg_remove_node(cfg, root);
1132                 root = item;
1133             } else
1134             root = root->next;
1135         } else if (root->type == TYPE_ITEM)
1136         {
1137             if (root->value == NULL || root->value[0] == '\0' || strlen(root->value) == 0)
1138             {
1139                 config_node *inode = root;
1140                 root = inode->prev;
1141                 if (!root)
1142                     root = inode->next;
1143                 __int_cfg_remove_node(cfg, inode);
1144                 if (!root)
1145                     return;
1146             } else
1147             root = root->next;
1148         } else if (root)
1149         root = root->next;
1150     }
1151 }
1152
1153
1154 void cfg_do_special_cleanup(config_obj * cfg)
1155 {
1156     if (!cfg || !cfg->root)
1157         return;
1158
1159     /*  g_mutex_lock(cfg->lock);*/
1160     __int_cfg_do_special_cleanup(cfg, NULL);
1161     cfg_save_delayed(cfg);
1162     /*  g_mutex_unlock(cfg->lock);*/
1163 }
1164
1165
1166 /**
1167  * Full api for use with metadata
1168  */
1169
1170 /**
1171  * String
1172  */
1173 void cfg_set_single_value_as_string_mm(config_obj * cfg, const char *class, const char *sclass, const char *ssclass,
1174 const char *key, const char *value)
1175 {
1176     /*  g_mutex_lock(cfg->lock);*/
1177     __int_cfg_set_single_value_as_string(cfg, class, sclass, ssclass, key, value);
1178     /*  g_mutex_unlock(cfg->lock);*/
1179 }
1180
1181
1182 char *cfg_get_single_value_as_string_mm(config_obj * cfg, const char *class, const char *sclass, const char *ssclass,
1183 const char *key)
1184 {
1185     char *retv = NULL;
1186     /*  g_mutex_lock(cfg->lock);*/
1187     retv = __int_cfg_get_single_value_as_string(cfg, class, sclass, ssclass, key);
1188     /*  g_mutex_unlock(cfg->lock);*/
1189     return retv;
1190 }
1191
1192
1193 char *cfg_get_single_value_as_string_with_default_mm(config_obj * cfg, const char *class, const char *sclass,
1194 const char *ssclass, const char *key, const char *def)
1195 {
1196     char *retv = NULL;
1197     /*          g_mutex_lock(cfg->lock);*/
1198     retv = __int_cfg_get_single_value_as_string(cfg, class, sclass, ssclass, key);
1199     if (retv == NULL)
1200     {
1201         __int_cfg_set_single_value_as_string(cfg, class, sclass, ssclass, key, def);
1202         retv = __int_cfg_get_single_value_as_string(cfg, class, sclass, ssclass, key);
1203     }
1204     /*  g_mutex_unlock(cfg->lock);*/
1205     return retv;
1206 }
1207
1208
1209 /**
1210  * Int
1211  */
1212 void cfg_set_single_value_as_int_mm(config_obj * cfg, const char *class, const char *sclass, const char *ssclass,
1213 const char *key, int value)
1214 {
1215     gchar *temp = NULL;
1216     /*  g_mutex_lock(cfg->lock);*/
1217     temp = g_strdup_printf("%i", value);
1218     __int_cfg_set_single_value_as_string(cfg, class, sclass, ssclass, key, temp);
1219     cfg_free_string(temp);
1220     /*  g_mutex_unlock(cfg->lock);*/
1221 }
1222
1223
1224 int cfg_get_single_value_as_int_with_default_mm(config_obj * cfg, const char *class, const char *sclass,
1225 const char *ssclass, const char *key, int def)
1226 {
1227     int retv = CFG_INT_NOT_DEFINED;
1228     /*  g_mutex_lock(cfg->lock);                */
1229     retv = __int_cfg_get_single_value_as_int_mm(cfg, class, sclass, ssclass, key);
1230     if (retv == CFG_INT_NOT_DEFINED)
1231     {
1232         __int_cfg_set_single_value_as_int(cfg, class, sclass, ssclass, key, def);
1233         retv = __int_cfg_get_single_value_as_int_mm(cfg, class, sclass, ssclass, key);
1234     }
1235     /*  g_mutex_unlock(cfg->lock);              */
1236     return retv;
1237 }
1238
1239
1240 static void cfg_save_delayed(config_obj * cfg)
1241 {
1242     if (cfg->save_timeout)
1243     {
1244         g_source_remove(cfg->save_timeout);
1245         cfg->save_timeout = 0;
1246     }
1247     cfg->save_timeout = g_timeout_add_seconds(5, (GSourceFunc) cfg_save_real, cfg);
1248 }