git.ozlabs.org Git - ccan/blob - ccan/ciniparser/ciniparser.c

   1 /* Copyright (c) 2000-2007 by Nicolas Devillard.
   2  * Copyright (x) 2009 by Tim Post <tinkertim@gmail.com>
   3  * MIT License
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /** @addtogroup ciniparser
  25  * @{
  26  */
  27 /**
  28  *  @file ciniparser.c
  29  *  @author N. Devillard
  30  *  @date Sep 2007
  31  *  @version 3.0
  32  *  @brief Parser for ini files.
  33  */
  34
  35 #include <ctype.h>
  36 #include "ciniparser.h"
  37
  38 #define ASCIILINESZ      (1024)
  39 #define INI_INVALID_KEY  ((char*) NULL)
  40
  41 /**
  42  * This enum stores the status for each parsed line (internal use only).
  43  */
  44 typedef enum _line_status_ {
  45         LINE_UNPROCESSED,
  46         LINE_ERROR,
  47         LINE_EMPTY,
  48         LINE_COMMENT,
  49         LINE_SECTION,
  50         LINE_VALUE
  51 } line_status;
  52
  53
  54 /**
  55  * @brief Convert a string to lowercase.
  56  * @param s String to convert.
  57  * @return ptr to statically allocated string.
  58  *
  59  * This function returns a pointer to a statically allocated string
  60  * containing a lowercased version of the input string. Do not free
  61  * or modify the returned string! Since the returned string is statically
  62  * allocated, it will be modified at each function call (not re-entrant).
  63  */
  64 static char *strlwc(const char *s)
  65 {
  66         static char l[ASCIILINESZ+1];
  67         int i;
  68
  69         if (s == NULL)
  70                 return NULL;
  71
  72         memset(l, 0, ASCIILINESZ+1);
  73         i=0;
  74
  75         while (s[i] && i < ASCIILINESZ) {
  76                 l[i] = (char)tolower((int)s[i]);
  77                 i++;
  78         }
  79
  80         l[ASCIILINESZ] = (char) 0;
  81
  82         return l;
  83 }
  84
  85 /**
  86  * @brief Remove blanks at the beginning and the end of a string.
  87  * @param s String to parse.
  88  * @return ptr to statically allocated string.
  89  *
  90  * This function returns a pointer to a statically allocated string,
  91  * which is identical to the input string, except that all blank
  92  * characters at the end and the beg. of the string have been removed.
  93  * Do not free or modify the returned string! Since the returned string
  94  * is statically allocated, it will be modified at each function call
  95  * (not re-entrant).
  96  */
  97 static char *strstrip(char *s)
  98 {
  99         static char l[ASCIILINESZ+1];
 100         char *last;
 101
 102         if (s == NULL)
 103                 return NULL;
 104
 105         while (isspace((int)*s) && *s)
 106                 s++;
 107
 108         memset(l, 0, ASCIILINESZ+1);
 109         strcpy(l, s);
 110         last = l + strlen(l);
 111
 112         while (last > l) {
 113                 if (!isspace((int)*(last-1)))
 114                         break;
 115                 last --;
 116         }
 117
 118         *last = (char) 0;
 119
 120         return (char *) l;
 121 }
 122
 123 /**
 124  * @brief Load a single line from an INI file
 125  * @param input_line Input line, may be concatenated multi-line input
 126  * @param section Output space to store section
 127  * @param key Output space to store key
 128  * @param value Output space to store value
 129  * @return line_status value
 130  */
 131 static
 132 line_status ciniparser_line(char *input_line, char *section,
 133         char *key, char *value)
 134 {
 135         line_status sta;
 136         char line[ASCIILINESZ+1];
 137         int      len;
 138
 139         strcpy(line, strstrip(input_line));
 140         len = (int) strlen(line);
 141
 142         sta = LINE_UNPROCESSED;
 143         if (len < 1) {
 144                 /* Empty line */
 145                 sta = LINE_EMPTY;
 146         } else if (line[0] == '#') {
 147                 /* Comment line */
 148                 sta = LINE_COMMENT;
 149         } else if (line[0] == '[' && line[len-1] == ']') {
 150                 /* Section name */
 151                 sscanf(line, "[%[^]]", section);
 152                 strcpy(section, strstrip(section));
 153                 strcpy(section, strlwc(section));
 154                 sta = LINE_SECTION;
 155         } else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2
 156                    ||  sscanf (line, "%[^=] = '%[^\']'", key, value) == 2
 157                    ||  sscanf (line, "%[^=] = %[^;#]", key, value) == 2) {
 158                 /* Usual key=value, with or without comments */
 159                 strcpy(key, strstrip(key));
 160                 strcpy(key, strlwc(key));
 161                 strcpy(value, strstrip(value));
 162                 /*
 163                  * sscanf cannot handle '' or "" as empty values
 164                  * this is done here
 165                  */
 166                 if (!strcmp(value, "\"\"") || (!strcmp(value, "''"))) {
 167                         value[0] = 0;
 168                 }
 169                 sta = LINE_VALUE;
 170         } else if (sscanf(line, "%[^=] = %[;#]", key, value) == 2
 171                 ||  sscanf(line, "%[^=] %[=]", key, value) == 2) {
 172                 /*
 173                  * Special cases:
 174                  * key=
 175                  * key=;
 176                  * key=#
 177                  */
 178                 strcpy(key, strstrip(key));
 179                 strcpy(key, strlwc(key));
 180                 value[0] = 0;
 181                 sta = LINE_VALUE;
 182         } else {
 183                 /* Generate syntax error */
 184                 sta = LINE_ERROR;
 185         }
 186         return sta;
 187 }
 188
 189 /* The remaining public functions are documented in ciniparser.h */
 190
 191 int ciniparser_getnsec(dictionary *d)
 192 {
 193         int i;
 194         int nsec;
 195
 196         if (d == NULL)
 197                 return -1;
 198
 199         nsec = 0;
 200         for (i = 0; i < d->size; i++) {
 201                 if (d->key[i] == NULL)
 202                         continue;
 203                 if (strchr(d->key[i], ':') == NULL) {
 204                         nsec ++;
 205                 }
 206         }
 207
 208         return nsec;
 209 }
 210
 211 char *ciniparser_getsecname(dictionary *d, int n)
 212 {
 213         int i;
 214         int foundsec;
 215
 216         if (d == NULL || n < 0)
 217                 return NULL;
 218
 219         if (n == 0)
 220                 n ++;
 221
 222         foundsec = 0;
 223
 224         for (i = 0; i < d->size; i++) {
 225                 if (d->key[i] == NULL)
 226                         continue;
 227                 if (! strchr(d->key[i], ':')) {
 228                         foundsec++;
 229                         if (foundsec >= n)
 230                                 break;
 231                 }
 232         }
 233
 234         if (foundsec == n) {
 235                 return d->key[i];
 236         }
 237
 238         return (char *) NULL;
 239 }
 240
 241 void ciniparser_dump(dictionary *d, FILE *f)
 242 {
 243         int i;
 244
 245         if (d == NULL || f == NULL)
 246                 return;
 247
 248         for (i = 0; i < d->size; i++) {
 249                 if (d->key[i] == NULL)
 250                         continue;
 251                 if (d->val[i] != NULL) {
 252                         fprintf(f, "[%s]=[%s]\n", d->key[i], d->val[i]);
 253                 } else {
 254                         fprintf(f, "[%s]=UNDEF\n", d->key[i]);
 255                 }
 256         }
 257
 258         return;
 259 }
 260
 261 void ciniparser_dump_ini(dictionary *d, FILE *f)
 262 {
 263         int i, j;
 264         char keym[ASCIILINESZ+1];
 265         int nsec;
 266         char *secname;
 267         int seclen;
 268
 269         if (d == NULL || f == NULL)
 270                 return;
 271
 272         memset(keym, 0, ASCIILINESZ + 1);
 273
 274         nsec = ciniparser_getnsec(d);
 275         if (nsec < 1) {
 276                 /* No section in file: dump all keys as they are */
 277                 for (i = 0; i < d->size; i++) {
 278                         if (d->key[i] == NULL)
 279                                 continue;
 280                         fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
 281                 }
 282                 return;
 283         }
 284
 285         for (i = 0; i < nsec; i++) {
 286                 secname = ciniparser_getsecname(d, i);
 287                 seclen  = (int)strlen(secname);
 288                 fprintf(f, "\n[%s]\n", secname);
 289                 snprintf(keym, ASCIILINESZ + 1, "%s:", secname);
 290                 for (j = 0; j < d->size; j++) {
 291                         if (d->key[j] == NULL)
 292                                 continue;
 293                         if (!strncmp(d->key[j], keym, seclen+1)) {
 294                                 fprintf(f, "%-30s = %s\n",
 295                                         d->key[j]+seclen+1,
 296                                         d->val[j] ? d->val[j] : "");
 297                         }
 298                 }
 299         }
 300         fprintf(f, "\n");
 301
 302         return;
 303 }
 304
 305 char *ciniparser_getstring(dictionary *d, const char *key, char *def)
 306 {
 307         char *lc_key;
 308         char *sval;
 309
 310         if (d == NULL || key == NULL)
 311                 return def;
 312
 313         lc_key = strlwc(key);
 314         sval = dictionary_get(d, lc_key, def);
 315
 316         return sval;
 317 }
 318
 319 int ciniparser_getint(dictionary *d, const char *key, int notfound)
 320 {
 321         char *str;
 322
 323         str = ciniparser_getstring(d, key, INI_INVALID_KEY);
 324
 325         if (str == INI_INVALID_KEY)
 326                 return notfound;
 327
 328         return (int) strtol(str, NULL, 10);
 329 }
 330
 331 double ciniparser_getdouble(dictionary *d, char *key, double notfound)
 332 {
 333         char *str;
 334
 335         str = ciniparser_getstring(d, key, INI_INVALID_KEY);
 336
 337         if (str == INI_INVALID_KEY)
 338                 return notfound;
 339
 340         return atof(str);
 341 }
 342
 343 int ciniparser_getboolean(dictionary *d, const char *key, int notfound)
 344 {
 345         char *c;
 346         int ret;
 347
 348         c = ciniparser_getstring(d, key, INI_INVALID_KEY);
 349         if (c == INI_INVALID_KEY)
 350                 return notfound;
 351
 352         switch(c[0]) {
 353         case 'y': case 'Y': case '1': case 't': case 'T':
 354                 ret = 1;
 355                 break;
 356         case 'n': case 'N': case '0': case 'f': case 'F':
 357                 ret = 0;
 358                 break;
 359         default:
 360                 ret = notfound;
 361                 break;
 362         }
 363
 364         return ret;
 365 }
 366
 367 int ciniparser_find_entry(dictionary *ini, char *entry)
 368 {
 369         int found = 0;
 370
 371         if (ciniparser_getstring(ini, entry, INI_INVALID_KEY) != INI_INVALID_KEY) {
 372                 found = 1;
 373         }
 374
 375         return found;
 376 }
 377
 378 int ciniparser_set(dictionary *d, char *entry, char *val)
 379 {
 380         return dictionary_set(d, strlwc(entry), val);
 381 }
 382
 383 void ciniparser_unset(dictionary *ini, char *entry)
 384 {
 385         dictionary_unset(ini, strlwc(entry));
 386 }
 387
 388 dictionary *ciniparser_load(const char *ininame)
 389 {
 390         FILE *in;
 391         char line[ASCIILINESZ+1];
 392         char section[ASCIILINESZ+1];
 393         char key[ASCIILINESZ+1];
 394         char tmp[ASCIILINESZ+1];
 395         char val[ASCIILINESZ+1];
 396         int  last = 0, len, lineno = 0, errs = 0;
 397         dictionary *dict;
 398
 399         if ((in = fopen(ininame, "r")) == NULL) {
 400                 fprintf(stderr, "ciniparser: cannot open %s\n", ininame);
 401                 return NULL;
 402         }
 403
 404         dict = dictionary_new(0);
 405         if (!dict) {
 406                 fclose(in);
 407                 return NULL;
 408         }
 409
 410         memset(line, 0, ASCIILINESZ + 1);
 411         memset(section, 0, ASCIILINESZ + 1);
 412         memset(key, 0, ASCIILINESZ + 1);
 413         memset(val, 0, ASCIILINESZ + 1);
 414         last = 0;
 415
 416         while (fgets(line+last, ASCIILINESZ-last, in)!=NULL) {
 417                 lineno++;
 418                 len = (int) strlen(line)-1;
 419                 /* Safety check against buffer overflows */
 420                 if (line[len] != '\n') {
 421                         fprintf(stderr,
 422                                         "ciniparser: input line too long in %s (%d)\n",
 423                                         ininame,
 424                                         lineno);
 425                         dictionary_del(dict);
 426                         fclose(in);
 427                         return NULL;
 428                 }
 429
 430                 /* Get rid of \n and spaces at end of line */
 431                 while ((len >= 0) &&
 432                                 ((line[len] == '\n') || (isspace(line[len])))) {
 433                         line[len] = 0;
 434                         len--;
 435                 }
 436
 437                 /* Detect multi-line */
 438                 if (line[len] == '\\') {
 439                         /* Multi-line value */
 440                         last = len;
 441                         continue;
 442                 } else {
 443                         last = 0;
 444                 }
 445
 446                 switch (ciniparser_line(line, section, key, val)) {
 447                 case LINE_EMPTY:
 448                 case LINE_COMMENT:
 449                         break;
 450
 451                 case LINE_SECTION:
 452                         errs = dictionary_set(dict, section, NULL);
 453                         break;
 454
 455                 case LINE_VALUE:
 456                         snprintf(tmp, ASCIILINESZ + 1, "%s:%s", section, key);
 457                         errs = dictionary_set(dict, tmp, val);
 458                         break;
 459
 460                 case LINE_ERROR:
 461                         fprintf(stderr, "ciniparser: syntax error in %s (%d):\n",
 462                                         ininame, lineno);
 463                         fprintf(stderr, "-> %s\n", line);
 464                         errs++;
 465                         break;
 466
 467                 default:
 468                         break;
 469                 }
 470                 memset(line, 0, ASCIILINESZ);
 471                 last = 0;
 472                 if (errs < 0) {
 473                         fprintf(stderr, "ciniparser: memory allocation failure\n");
 474                         break;
 475                 }
 476         }
 477
 478         if (errs) {
 479                 dictionary_del(dict);
 480                 dict = NULL;
 481         }
 482
 483         fclose(in);
 484
 485         return dict;
 486 }
 487
 488 void ciniparser_freedict(dictionary *d)
 489 {
 490         dictionary_del(d);
 491 }
 492
 493 /** @}
 494  */