src/common/config/ini.c

   1 /*
   2  * inih -- simple .INI file parser
   3  *
   4  * The "inih" library is distributed under the New BSD license:
   5  *
   6  * Copyright (C) 2009 Brush Technology - All rights reserved.
   7  *
   8  * SPDX-License-Identifier: BSD-3-Clause
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  *
  13  *     * Redistributions of source code must retain the above copyright notice,
  14  *     this list of conditions and the following disclaimer.
  15  *     * Redistributions in binary form must reproduce the above copyright
  16  *     notice, this list of conditions and the following disclaimer in the
  17  *     documentation and/or other materials provided with the distribution.
  18  *     * Neither the name of Brush Technology nor the names of its contributors
  19  *     may be used to endorse or promote products derived from this software
  20  *     without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY BRUSH TECHNOLOGY ''AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  25  * EVENT SHALL BRUSH TECHNOLOGY BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  27  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  28  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * http://code.google.com/p/inih/
  34  */
  35
  36 #include <stdio.h>
  37 #include <ctype.h>
  38 #include <string.h>
  39 #include <common/common.h>
  40
  41 #include "ini.h"
  42
  43 #if !INI_USE_STACK
  44 #include <stdlib.h>
  45 #endif
  46
  47 #define MAX_SECTION 50
  48 #define MAX_NAME 50
  49
  50 /* Strip whitespace chars off end of given string, in place. Return s. */
  51 static char* rstrip(char* s)
  52 {
  53         char* p = s + strlen(s);
  54
  55         while (p > s && isspace((unsigned char)(*--p)))
  56                 *p = '\0';
  57         return s;
  58 }
  59
  60 /* Return pointer to first non-whitespace char in given string. */
  61 static char* lskip(const char* s)
  62 {
  63         while (*s && isspace((unsigned char)(*s)))
  64                 s++;
  65         return (char*)s;
  66 }
  67
  68 /*
  69  * Return pointer to first char c or ';' comment in given string, or pointer to
  70  * null at end of string if neither found. ';' must be prefixed by a whitespace
  71  * character to register as a comment.
  72  */
  73 static char* find_char_or_comment(const char* s, char c)
  74 {
  75         int was_whitespace = 0;
  76
  77         while (*s && *s != c && !(was_whitespace && *s == ';')) {
  78                 was_whitespace = isspace((unsigned char)(*s));
  79                 s++;
  80         }
  81         return (char*)s;
  82 }
  83
  84 /* Version of strncpy that ensures dest (size bytes) is null-terminated. */
  85 static char* strncpy0(char* dest, const char* src, size_t size)
  86 {
  87         strncpy(dest, src, size - 1);
  88         dest[size - 1] = '\0';
  89         return dest;
  90 }
  91
  92 /* See documentation in header file. */
  93 LTTNG_HIDDEN
  94 int ini_parse_file(FILE* file, ini_entry_handler handler, void* user)
  95 {
  96         /* Uses a fair bit of stack (use heap instead if you need to) */
  97 #if INI_USE_STACK
  98         char line[INI_MAX_LINE];
  99 #else
 100         char* line;
 101 #endif
 102         char section[MAX_SECTION] = "";
 103         char prev_name[MAX_NAME] = "";
 104
 105         char* start;
 106         char* end;
 107         char* name;
 108         char* value;
 109         int lineno = 0;
 110         int error = 0;
 111
 112 #if !INI_USE_STACK
 113         line = (char*)zmalloc(INI_MAX_LINE);
 114         if (!line) {
 115                 return -2;
 116         }
 117 #endif
 118
 119         /* Scan through file line by line */
 120         while (fgets(line, INI_MAX_LINE, file) != NULL) {
 121                 lineno++;
 122
 123                 start = line;
 124 #if INI_ALLOW_BOM
 125                 if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
 126                         (unsigned char)start[1] == 0xBB &&
 127                         (unsigned char)start[2] == 0xBF) {
 128                         start += 3;
 129                 }
 130 #endif
 131                 start = lskip(rstrip(start));
 132
 133                 if (*start == ';' || *start == '#') {
 134                         /*
 135                          * Per Python ConfigParser, allow '#' comments at
 136                          * start of line.
 137                          */
 138                 }
 139 #if INI_ALLOW_MULTILINE
 140                 else if (*prev_name && *start && start > line) {
 141                         /* Non-black line with leading whitespace, treat as
 142                          * continuation of previous name's value
 143                          * (as per Python ConfigParser).
 144                          */
 145                         if (handler(user, section, prev_name, start) < 0 &&
 146                                 !error) {
 147                                 error = lineno;
 148                         }
 149                 }
 150 #endif
 151                 else if (*start == '[') {
 152                         /* A "[section]" line */
 153                         end = find_char_or_comment(start + 1, ']');
 154                         if (*end == ']') {
 155                                 *end = '\0';
 156                                 strncpy0(section, start + 1, sizeof(section));
 157                                 *prev_name = '\0';
 158                         }
 159                         else if (!error) {
 160                                 /* No ']' found on section line */
 161                                 error = lineno;
 162                         }
 163                 }
 164                 else if (*start && *start != ';') {
 165                         /* Not a comment, must be a name[=:]value pair */
 166                         end = find_char_or_comment(start, '=');
 167                         if (*end != '=') {
 168                                 end = find_char_or_comment(start, ':');
 169                         }
 170                         if (*end == '=' || *end == ':') {
 171                                 *end = '\0';
 172                                 name = rstrip(start);
 173                                 value = lskip(end + 1);
 174                                 end = find_char_or_comment(value, '\0');
 175                                 if (*end == ';') {
 176                                         *end = '\0';
 177                                 }
 178
 179                                 rstrip(value);
 180
 181                                 /*
 182                                  * Valid name[=:]value pair found, call
 183                                  * handler
 184                                  */
 185                                 strncpy0(prev_name, name, sizeof(prev_name));
 186                                 if (handler(user, section, name, value) < 0 &&
 187                                         !error) {
 188                                         error = lineno;
 189                                 }
 190                         }
 191                         else if (!error) {
 192                                 /* No '=' or ':' found on name[=:]value line */
 193                                 error = lineno;
 194                         }
 195                 }
 196         }
 197
 198 #if !INI_USE_STACK
 199         free(line);
 200 #endif
 201
 202         return error;
 203 }
 204
 205 /* See documentation in header file. */
 206 LTTNG_HIDDEN
 207 int ini_parse(const char* filename, ini_entry_handler handler, void* user)
 208 {
 209         FILE* file;
 210         int error;
 211
 212         file = fopen(filename, "r");
 213         if (!file) {
 214                 return -1;
 215         }
 216
 217         error = ini_parse_file(file, handler, user);
 218         fclose(file);
 219         return error;
 220 }