rte_cfgfile.c revision 8b25d1ad
1/*-
2 *   BSD LICENSE
3 *
4 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5 *   All rights reserved.
6 *
7 *   Redistribution and use in source and binary forms, with or without
8 *   modification, are permitted provided that the following conditions
9 *   are met:
10 *
11 *     * Redistributions of source code must retain the above copyright
12 *       notice, this list of conditions and the following disclaimer.
13 *     * Redistributions in binary form must reproduce the above copyright
14 *       notice, this list of conditions and the following disclaimer in
15 *       the documentation and/or other materials provided with the
16 *       distribution.
17 *     * Neither the name of Intel Corporation nor the names of its
18 *       contributors may be used to endorse or promote products derived
19 *       from this software without specific prior written permission.
20 *
21 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <ctype.h>
38#include <rte_string_fns.h>
39
40#include "rte_cfgfile.h"
41
42struct rte_cfgfile_section {
43	char name[CFG_NAME_LEN];
44	int num_entries;
45	struct rte_cfgfile_entry *entries[0];
46};
47
48struct rte_cfgfile {
49	int flags;
50	int num_sections;
51	struct rte_cfgfile_section *sections[0];
52};
53
54/** when we resize a file structure, how many extra entries
55 * for new sections do we add in */
56#define CFG_ALLOC_SECTION_BATCH 8
57/** when we resize a section structure, how many extra entries
58 * for new entries do we add in */
59#define CFG_ALLOC_ENTRY_BATCH 16
60
61static unsigned
62_strip(char *str, unsigned len)
63{
64	int newlen = len;
65	if (len == 0)
66		return 0;
67
68	if (isspace(str[len-1])) {
69		/* strip trailing whitespace */
70		while (newlen > 0 && isspace(str[newlen - 1]))
71			str[--newlen] = '\0';
72	}
73
74	if (isspace(str[0])) {
75		/* strip leading whitespace */
76		int i, start = 1;
77		while (isspace(str[start]) && start < newlen)
78			start++
79			; /* do nothing */
80		newlen -= start;
81		for (i = 0; i < newlen; i++)
82			str[i] = str[i+start];
83		str[i] = '\0';
84	}
85	return newlen;
86}
87
88struct rte_cfgfile *
89rte_cfgfile_load(const char *filename, int flags)
90{
91	int allocated_sections = CFG_ALLOC_SECTION_BATCH;
92	int allocated_entries = 0;
93	int curr_section = -1;
94	int curr_entry = -1;
95	char buffer[256] = {0};
96	int lineno = 0;
97	struct rte_cfgfile *cfg = NULL;
98
99	FILE *f = fopen(filename, "r");
100	if (f == NULL)
101		return NULL;
102
103	cfg = malloc(sizeof(*cfg) + sizeof(cfg->sections[0]) *
104		allocated_sections);
105	if (cfg == NULL)
106		goto error2;
107
108	memset(cfg->sections, 0, sizeof(cfg->sections[0]) * allocated_sections);
109
110	while (fgets(buffer, sizeof(buffer), f) != NULL) {
111		char *pos = NULL;
112		size_t len = strnlen(buffer, sizeof(buffer));
113		lineno++;
114		if ((len >= sizeof(buffer) - 1) && (buffer[len-1] != '\n')) {
115			printf("Error line %d - no \\n found on string. "
116					"Check if line too long\n", lineno);
117			goto error1;
118		}
119		pos = memchr(buffer, ';', sizeof(buffer));
120		if (pos != NULL) {
121			*pos = '\0';
122			len = pos -  buffer;
123		}
124
125		len = _strip(buffer, len);
126		if (buffer[0] != '[' && memchr(buffer, '=', len) == NULL)
127			continue;
128
129		if (buffer[0] == '[') {
130			/* section heading line */
131			char *end = memchr(buffer, ']', len);
132			if (end == NULL) {
133				printf("Error line %d - no terminating '['"
134					"character found\n", lineno);
135				goto error1;
136			}
137			*end = '\0';
138			_strip(&buffer[1], end - &buffer[1]);
139
140			/* close off old section and add start new one */
141			if (curr_section >= 0)
142				cfg->sections[curr_section]->num_entries =
143					curr_entry + 1;
144			curr_section++;
145
146			/* resize overall struct if we don't have room for more
147			sections */
148			if (curr_section == allocated_sections) {
149				allocated_sections += CFG_ALLOC_SECTION_BATCH;
150				struct rte_cfgfile *n_cfg = realloc(cfg,
151					sizeof(*cfg) + sizeof(cfg->sections[0])
152					* allocated_sections);
153				if (n_cfg == NULL) {
154					printf("Error - no more memory\n");
155					goto error1;
156				}
157				cfg = n_cfg;
158			}
159
160			/* allocate space for new section */
161			allocated_entries = CFG_ALLOC_ENTRY_BATCH;
162			curr_entry = -1;
163			cfg->sections[curr_section] = malloc(
164				sizeof(*cfg->sections[0]) +
165				sizeof(cfg->sections[0]->entries[0]) *
166				allocated_entries);
167			if (cfg->sections[curr_section] == NULL) {
168				printf("Error - no more memory\n");
169				goto error1;
170			}
171
172			snprintf(cfg->sections[curr_section]->name,
173					sizeof(cfg->sections[0]->name),
174					"%s", &buffer[1]);
175		} else {
176			/* value line */
177			if (curr_section < 0) {
178				printf("Error line %d - value outside of"
179					"section\n", lineno);
180				goto error1;
181			}
182
183			struct rte_cfgfile_section *sect =
184				cfg->sections[curr_section];
185			char *split[2];
186			if (rte_strsplit(buffer, sizeof(buffer), split, 2, '=')
187				!= 2) {
188				printf("Error at line %d - cannot split "
189					"string\n", lineno);
190				goto error1;
191			}
192
193			curr_entry++;
194			if (curr_entry == allocated_entries) {
195				allocated_entries += CFG_ALLOC_ENTRY_BATCH;
196				struct rte_cfgfile_section *n_sect = realloc(
197					sect, sizeof(*sect) +
198					sizeof(sect->entries[0]) *
199					allocated_entries);
200				if (n_sect == NULL) {
201					printf("Error - no more memory\n");
202					goto error1;
203				}
204				sect = cfg->sections[curr_section] = n_sect;
205			}
206
207			sect->entries[curr_entry] = malloc(
208				sizeof(*sect->entries[0]));
209			if (sect->entries[curr_entry] == NULL) {
210				printf("Error - no more memory\n");
211				goto error1;
212			}
213
214			struct rte_cfgfile_entry *entry = sect->entries[
215				curr_entry];
216			snprintf(entry->name, sizeof(entry->name), "%s",
217				split[0]);
218			snprintf(entry->value, sizeof(entry->value), "%s",
219				split[1]);
220			_strip(entry->name, strnlen(entry->name,
221				sizeof(entry->name)));
222			_strip(entry->value, strnlen(entry->value,
223				sizeof(entry->value)));
224		}
225	}
226	fclose(f);
227	cfg->flags = flags;
228	cfg->num_sections = curr_section + 1;
229	/* curr_section will still be -1 if we have an empty file */
230	if (curr_section >= 0)
231		cfg->sections[curr_section]->num_entries = curr_entry + 1;
232	return cfg;
233
234error1:
235	cfg->num_sections = curr_section + 1;
236	rte_cfgfile_close(cfg);
237error2:
238	fclose(f);
239	return NULL;
240}
241
242
243int rte_cfgfile_close(struct rte_cfgfile *cfg)
244{
245	int i, j;
246
247	if (cfg == NULL)
248		return -1;
249
250	for (i = 0; i < cfg->num_sections; i++) {
251		if (cfg->sections[i] != NULL) {
252			if (cfg->sections[i]->num_entries) {
253				for (j = 0; j < cfg->sections[i]->num_entries;
254					j++) {
255					if (cfg->sections[i]->entries[j] !=
256						NULL)
257						free(cfg->sections[i]->
258							entries[j]);
259				}
260			}
261			free(cfg->sections[i]);
262		}
263	}
264	free(cfg);
265
266	return 0;
267}
268
269int
270rte_cfgfile_num_sections(struct rte_cfgfile *cfg, const char *sectionname,
271size_t length)
272{
273	int i;
274	int num_sections = 0;
275	for (i = 0; i < cfg->num_sections; i++) {
276		if (strncmp(cfg->sections[i]->name, sectionname, length) == 0)
277			num_sections++;
278	}
279	return num_sections;
280}
281
282int
283rte_cfgfile_sections(struct rte_cfgfile *cfg, char *sections[],
284	int max_sections)
285{
286	int i;
287
288	for (i = 0; i < cfg->num_sections && i < max_sections; i++)
289		snprintf(sections[i], CFG_NAME_LEN, "%s",
290		cfg->sections[i]->name);
291
292	return i;
293}
294
295static const struct rte_cfgfile_section *
296_get_section(struct rte_cfgfile *cfg, const char *sectionname)
297{
298	int i;
299	for (i = 0; i < cfg->num_sections; i++) {
300		if (strncmp(cfg->sections[i]->name, sectionname,
301				sizeof(cfg->sections[0]->name)) == 0)
302			return cfg->sections[i];
303	}
304	return NULL;
305}
306
307int
308rte_cfgfile_has_section(struct rte_cfgfile *cfg, const char *sectionname)
309{
310	return _get_section(cfg, sectionname) != NULL;
311}
312
313int
314rte_cfgfile_section_num_entries(struct rte_cfgfile *cfg,
315	const char *sectionname)
316{
317	const struct rte_cfgfile_section *s = _get_section(cfg, sectionname);
318	if (s == NULL)
319		return -1;
320	return s->num_entries;
321}
322
323
324int
325rte_cfgfile_section_entries(struct rte_cfgfile *cfg, const char *sectionname,
326		struct rte_cfgfile_entry *entries, int max_entries)
327{
328	int i;
329	const struct rte_cfgfile_section *sect = _get_section(cfg, sectionname);
330	if (sect == NULL)
331		return -1;
332	for (i = 0; i < max_entries && i < sect->num_entries; i++)
333		entries[i] = *sect->entries[i];
334	return i;
335}
336
337int
338rte_cfgfile_section_entries_by_index(struct rte_cfgfile *cfg, int index,
339		char *sectionname,
340		struct rte_cfgfile_entry *entries, int max_entries)
341{
342	int i;
343	const struct rte_cfgfile_section *sect;
344
345	if (index < 0 || index >= cfg->num_sections)
346		return -1;
347
348	sect = cfg->sections[index];
349	snprintf(sectionname, CFG_NAME_LEN, "%s", sect->name);
350	for (i = 0; i < max_entries && i < sect->num_entries; i++)
351		entries[i] = *sect->entries[i];
352	return i;
353}
354
355const char *
356rte_cfgfile_get_entry(struct rte_cfgfile *cfg, const char *sectionname,
357		const char *entryname)
358{
359	int i;
360	const struct rte_cfgfile_section *sect = _get_section(cfg, sectionname);
361	if (sect == NULL)
362		return NULL;
363	for (i = 0; i < sect->num_entries; i++)
364		if (strncmp(sect->entries[i]->name, entryname, CFG_NAME_LEN)
365			== 0)
366			return sect->entries[i]->value;
367	return NULL;
368}
369
370int
371rte_cfgfile_has_entry(struct rte_cfgfile *cfg, const char *sectionname,
372		const char *entryname)
373{
374	return rte_cfgfile_get_entry(cfg, sectionname, entryname) != NULL;
375}
376