Line data Source code
1 : /*
2 : * Trivial smb.conf parsing code
3 : *
4 : * Copyright Volker Lendecke <vl@samba.org> 2014
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions
8 : * are met:
9 : * 1. Redistributions of source code must retain the above copyright
10 : * notice, and the entire permission notice in its entirety,
11 : * including the disclaimer of warranties.
12 : * 2. Redistributions in binary form must reproduce the above copyright
13 : * notice, this list of conditions and the following disclaimer in the
14 : * documentation and/or other materials provided with the distribution.
15 : * 3. The name of the author may not be used to endorse or promote
16 : * products derived from this software without specific prior
17 : * written permission.
18 : *
19 : * ALTERNATIVELY, this product may be distributed under the terms of
20 : * the GNU Public License Version 3 or later, in which case the
21 : * provisions of the GPL are required INSTEAD OF the above restrictions.
22 : * (This clause is necessary due to a potential bad interaction between the
23 : * GPL and the restrictions contained in a BSD-style copyright.)
24 : *
25 : * THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESS OR IMPLIED
26 : * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 : * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
29 : * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
30 : * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
31 : * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
33 : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
35 : * OF THE POSSIBILITY OF SUCH DAMAGE.
36 : */
37 :
38 : #include <stdio.h>
39 : #include <stdlib.h>
40 : #include <stdbool.h>
41 : #include <ctype.h>
42 : #include <errno.h>
43 : #include <string.h>
44 : #include "tini.h"
45 :
46 1197299312 : static bool c_isspace(char c)
47 : {
48 1197299312 : unsigned char uc = c;
49 1197299312 : if (c != uc) {
50 5004 : return false;
51 : }
52 1197294308 : return isspace(uc);
53 : }
54 :
55 29080722 : static int next_content(FILE *f)
56 : {
57 55686 : int c;
58 :
59 55414405 : for (c = fgetc(f); c != EOF; c = fgetc(f)) {
60 55191254 : if (!c_isspace(c)) {
61 24688661 : break;
62 : }
63 30455124 : if (c == '\n') {
64 4114037 : break;
65 : }
66 : }
67 :
68 29080722 : return c;
69 : }
70 :
71 579271 : static int next_end_of_line(FILE *f)
72 : {
73 1507 : int c;
74 :
75 25390931 : for (c = fgetc(f); c != EOF; c = fgetc(f)) {
76 25390931 : if (c == '\n') {
77 577764 : break;
78 : }
79 : }
80 579271 : return c;
81 : }
82 :
83 1040559113 : static bool make_space(char **buf, size_t *buflen, size_t position)
84 : {
85 2076032 : char *tmp;
86 :
87 1040559113 : if (position < *buflen) {
88 1038404449 : return true;
89 : }
90 78688 : tmp = realloc(*buf, (*buflen) * 2);
91 78688 : if (tmp == NULL) {
92 0 : return false;
93 : }
94 78688 : *buf = tmp;
95 78688 : *buflen *= 2;
96 78688 : return true;
97 : }
98 :
99 : /*
100 : * Get a conf line into *pbuf (which must be a malloc'ed buffer already).
101 : *
102 : * Ignores leading spaces
103 : * Ignores comment lines
104 : * Ignores empty lines
105 : * Takes care of continuation lines
106 : * Zaps multiple spaces into one
107 : */
108 :
109 24380010 : static int get_line(FILE *f, char **pbuf, size_t *pbuflen)
110 : {
111 46775 : int c;
112 46775 : char *buf;
113 46775 : size_t buflen, pos;
114 :
115 24380010 : buf = *pbuf;
116 24380010 : buflen = *pbuflen;
117 24380010 : pos = 0;
118 :
119 26483153 : next_line:
120 :
121 29080722 : c = next_content(f);
122 29080722 : if (c == EOF) {
123 222338 : return ENOENT;
124 : }
125 :
126 28857571 : if ((c == '#') || (c == ';')) {
127 : /*
128 : * Line starting with a comment, skip
129 : */
130 579271 : c = next_end_of_line(f);
131 579271 : if (c == EOF) {
132 0 : return ENOENT;
133 : }
134 579271 : goto next_line;
135 : }
136 :
137 28278300 : if (c == '\n') {
138 : /*
139 : * Blank line, skip
140 : */
141 4121441 : goto next_line;
142 : }
143 :
144 1040985278 : for ( ; c != EOF ; c = fgetc(f)) {
145 :
146 1040984322 : if (c == '\n') {
147 :
148 24155903 : if ((pos > 0) && (buf[pos-1] == '\\')) {
149 : /*
150 : * Line ends in "\". Continuation.
151 : */
152 0 : pos -= 1;
153 0 : continue;
154 : }
155 :
156 24155903 : if ((pos > 1) && (buf[pos-2] == '\\') &&
157 0 : c_isspace(buf[pos-1])) {
158 : /*
159 : * Line ends in "\ ". Mind that we zap
160 : * multiple spaces into one. Continuation.
161 : */
162 0 : pos -= 2;
163 0 : continue;
164 : }
165 :
166 : /*
167 : * No continuation, done with the line
168 : */
169 24109941 : break;
170 : }
171 :
172 1016828419 : if ((pos > 0) && c_isspace(buf[pos-1]) && c_isspace(c)) {
173 : /*
174 : * Zap multiple spaces to one
175 : */
176 426165 : continue;
177 : }
178 :
179 1016402254 : if (!make_space(&buf, &buflen, pos)) {
180 0 : return ENOMEM;
181 : }
182 1016402254 : buf[pos++] = c;
183 : }
184 :
185 24156859 : if (!make_space(&buf, &buflen, pos)) {
186 0 : return ENOMEM;
187 : }
188 24156859 : buf[pos++] = '\0';
189 :
190 24156859 : *pbuf = buf;
191 24156859 : return 0;
192 : }
193 :
194 3819005 : static bool parse_section(
195 : char *buf, bool (*sfunc)(const char *section, void *private_data),
196 : void *private_data)
197 : {
198 4050 : char *p, *q;
199 :
200 3819005 : p = buf+1; /* skip [ */
201 :
202 3819005 : q = strchr(p, ']');
203 3819005 : if (q == NULL) {
204 0 : return false;
205 : }
206 3819005 : *q = '\0';
207 :
208 3819005 : return sfunc(p, private_data);
209 : }
210 :
211 40673852 : static char *trim_one_space(char *buf)
212 : {
213 83824 : size_t len;
214 :
215 40673852 : if (c_isspace(buf[0])) {
216 20176315 : buf += 1;
217 : }
218 40673852 : len = strlen(buf);
219 40673852 : if (len == 0) {
220 90044 : return buf;
221 : }
222 40583808 : if (c_isspace(buf[len-1])) {
223 20256690 : buf[len-1] = '\0';
224 : }
225 :
226 40499984 : return buf;
227 : }
228 :
229 20337854 : static bool parse_param(char *buf,
230 : bool allow_empty_value,
231 : bool (*pfunc)(const char *name, const char *value,
232 : void *private_data),
233 : void *private_data)
234 : {
235 41912 : char *equals;
236 41912 : char *name;
237 41912 : const char *value;
238 41912 : size_t len;
239 20337854 : bool no_value = false;
240 :
241 20337854 : equals = strchr(buf, '=');
242 20337854 : if (equals != NULL) {
243 20336926 : *equals = '\0';
244 : } else {
245 928 : if (allow_empty_value) {
246 0 : no_value = true;
247 : } else {
248 928 : return true;
249 : }
250 : }
251 :
252 20336926 : name = trim_one_space(buf);
253 20336926 : len = strlen(buf);
254 20336926 : if (len == 0) {
255 0 : return false;
256 : }
257 :
258 20336926 : if (no_value) {
259 0 : value = "";
260 : } else {
261 20336926 : value = trim_one_space(equals+1);
262 : }
263 :
264 20336926 : return pfunc(name, value, private_data);
265 : }
266 :
267 223163 : bool tini_parse(FILE *f,
268 : bool allow_empty_value,
269 : bool (*sfunc)(const char *section, void *private_data),
270 : bool (*pfunc)(const char *name, const char *value,
271 : void *private_data),
272 : void *private_data)
273 : {
274 813 : char *buf;
275 813 : size_t buflen;
276 :
277 223163 : buflen = 256;
278 :
279 223163 : buf = malloc(buflen);
280 223163 : if (buf == NULL) {
281 0 : return false;
282 : }
283 :
284 24157660 : while (true) {
285 46775 : int ret;
286 46775 : bool ok;
287 :
288 24380010 : ret = get_line(f, &buf, &buflen);
289 :
290 24380010 : if (ret == ENOENT) {
291 : /* No lines anymore */
292 222338 : break;
293 : }
294 :
295 24156859 : if (ret != 0) {
296 : /* Real error */
297 0 : free(buf);
298 0 : return false;
299 : }
300 :
301 24156859 : switch(buf[0]) {
302 0 : case 0:
303 0 : continue;
304 : break;
305 3819005 : case '[':
306 3819005 : ok = parse_section(buf, sfunc, private_data);
307 3819005 : break;
308 20337854 : default:
309 20337854 : ok = parse_param(buf, allow_empty_value, pfunc, private_data);
310 20337854 : break;
311 : }
312 :
313 24156859 : if (!ok) {
314 12 : free(buf);
315 12 : return false;
316 : }
317 : }
318 223151 : free(buf);
319 223151 : return true;
320 : }
|
