Root/
1 | /* |
2 | * config.c |
3 | * |
4 | * Helper functions for parsing config items. |
5 | * Originally copied from GIT source. |
6 | * |
7 | * Copyright (C) Linus Torvalds, 2005 |
8 | * Copyright (C) Johannes Schindelin, 2005 |
9 | * |
10 | */ |
11 | #include "util.h" |
12 | #include "cache.h" |
13 | #include "exec_cmd.h" |
14 | |
15 | #define MAXNAME (256) |
16 | |
17 | #define DEBUG_CACHE_DIR ".debug" |
18 | |
19 | |
20 | char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */ |
21 | |
22 | static FILE *config_file; |
23 | static const char *config_file_name; |
24 | static int config_linenr; |
25 | static int config_file_eof; |
26 | |
27 | static const char *config_exclusive_filename; |
28 | |
29 | static int get_next_char(void) |
30 | { |
31 | int c; |
32 | FILE *f; |
33 | |
34 | c = '\n'; |
35 | if ((f = config_file) != NULL) { |
36 | c = fgetc(f); |
37 | if (c == '\r') { |
38 | /* DOS like systems */ |
39 | c = fgetc(f); |
40 | if (c != '\n') { |
41 | ungetc(c, f); |
42 | c = '\r'; |
43 | } |
44 | } |
45 | if (c == '\n') |
46 | config_linenr++; |
47 | if (c == EOF) { |
48 | config_file_eof = 1; |
49 | c = '\n'; |
50 | } |
51 | } |
52 | return c; |
53 | } |
54 | |
55 | static char *parse_value(void) |
56 | { |
57 | static char value[1024]; |
58 | int quote = 0, comment = 0, space = 0; |
59 | size_t len = 0; |
60 | |
61 | for (;;) { |
62 | int c = get_next_char(); |
63 | |
64 | if (len >= sizeof(value) - 1) |
65 | return NULL; |
66 | if (c == '\n') { |
67 | if (quote) |
68 | return NULL; |
69 | value[len] = 0; |
70 | return value; |
71 | } |
72 | if (comment) |
73 | continue; |
74 | if (isspace(c) && !quote) { |
75 | space = 1; |
76 | continue; |
77 | } |
78 | if (!quote) { |
79 | if (c == ';' || c == '#') { |
80 | comment = 1; |
81 | continue; |
82 | } |
83 | } |
84 | if (space) { |
85 | if (len) |
86 | value[len++] = ' '; |
87 | space = 0; |
88 | } |
89 | if (c == '\\') { |
90 | c = get_next_char(); |
91 | switch (c) { |
92 | case '\n': |
93 | continue; |
94 | case 't': |
95 | c = '\t'; |
96 | break; |
97 | case 'b': |
98 | c = '\b'; |
99 | break; |
100 | case 'n': |
101 | c = '\n'; |
102 | break; |
103 | /* Some characters escape as themselves */ |
104 | case '\\': case '"': |
105 | break; |
106 | /* Reject unknown escape sequences */ |
107 | default: |
108 | return NULL; |
109 | } |
110 | value[len++] = c; |
111 | continue; |
112 | } |
113 | if (c == '"') { |
114 | quote = 1-quote; |
115 | continue; |
116 | } |
117 | value[len++] = c; |
118 | } |
119 | } |
120 | |
121 | static inline int iskeychar(int c) |
122 | { |
123 | return isalnum(c) || c == '-' || c == '_'; |
124 | } |
125 | |
126 | static int get_value(config_fn_t fn, void *data, char *name, unsigned int len) |
127 | { |
128 | int c; |
129 | char *value; |
130 | |
131 | /* Get the full name */ |
132 | for (;;) { |
133 | c = get_next_char(); |
134 | if (config_file_eof) |
135 | break; |
136 | if (!iskeychar(c)) |
137 | break; |
138 | name[len++] = c; |
139 | if (len >= MAXNAME) |
140 | return -1; |
141 | } |
142 | name[len] = 0; |
143 | while (c == ' ' || c == '\t') |
144 | c = get_next_char(); |
145 | |
146 | value = NULL; |
147 | if (c != '\n') { |
148 | if (c != '=') |
149 | return -1; |
150 | value = parse_value(); |
151 | if (!value) |
152 | return -1; |
153 | } |
154 | return fn(name, value, data); |
155 | } |
156 | |
157 | static int get_extended_base_var(char *name, int baselen, int c) |
158 | { |
159 | do { |
160 | if (c == '\n') |
161 | return -1; |
162 | c = get_next_char(); |
163 | } while (isspace(c)); |
164 | |
165 | /* We require the format to be '[base "extension"]' */ |
166 | if (c != '"') |
167 | return -1; |
168 | name[baselen++] = '.'; |
169 | |
170 | for (;;) { |
171 | int ch = get_next_char(); |
172 | |
173 | if (ch == '\n') |
174 | return -1; |
175 | if (ch == '"') |
176 | break; |
177 | if (ch == '\\') { |
178 | ch = get_next_char(); |
179 | if (ch == '\n') |
180 | return -1; |
181 | } |
182 | name[baselen++] = ch; |
183 | if (baselen > MAXNAME / 2) |
184 | return -1; |
185 | } |
186 | |
187 | /* Final ']' */ |
188 | if (get_next_char() != ']') |
189 | return -1; |
190 | return baselen; |
191 | } |
192 | |
193 | static int get_base_var(char *name) |
194 | { |
195 | int baselen = 0; |
196 | |
197 | for (;;) { |
198 | int c = get_next_char(); |
199 | if (config_file_eof) |
200 | return -1; |
201 | if (c == ']') |
202 | return baselen; |
203 | if (isspace(c)) |
204 | return get_extended_base_var(name, baselen, c); |
205 | if (!iskeychar(c) && c != '.') |
206 | return -1; |
207 | if (baselen > MAXNAME / 2) |
208 | return -1; |
209 | name[baselen++] = tolower(c); |
210 | } |
211 | } |
212 | |
213 | static int perf_parse_file(config_fn_t fn, void *data) |
214 | { |
215 | int comment = 0; |
216 | int baselen = 0; |
217 | static char var[MAXNAME]; |
218 | |
219 | /* U+FEFF Byte Order Mark in UTF8 */ |
220 | static const unsigned char *utf8_bom = (unsigned char *) "\xef\xbb\xbf"; |
221 | const unsigned char *bomptr = utf8_bom; |
222 | |
223 | for (;;) { |
224 | int c = get_next_char(); |
225 | if (bomptr && *bomptr) { |
226 | /* We are at the file beginning; skip UTF8-encoded BOM |
227 | * if present. Sane editors won't put this in on their |
228 | * own, but e.g. Windows Notepad will do it happily. */ |
229 | if ((unsigned char) c == *bomptr) { |
230 | bomptr++; |
231 | continue; |
232 | } else { |
233 | /* Do not tolerate partial BOM. */ |
234 | if (bomptr != utf8_bom) |
235 | break; |
236 | /* No BOM at file beginning. Cool. */ |
237 | bomptr = NULL; |
238 | } |
239 | } |
240 | if (c == '\n') { |
241 | if (config_file_eof) |
242 | return 0; |
243 | comment = 0; |
244 | continue; |
245 | } |
246 | if (comment || isspace(c)) |
247 | continue; |
248 | if (c == '#' || c == ';') { |
249 | comment = 1; |
250 | continue; |
251 | } |
252 | if (c == '[') { |
253 | baselen = get_base_var(var); |
254 | if (baselen <= 0) |
255 | break; |
256 | var[baselen++] = '.'; |
257 | var[baselen] = 0; |
258 | continue; |
259 | } |
260 | if (!isalpha(c)) |
261 | break; |
262 | var[baselen] = tolower(c); |
263 | if (get_value(fn, data, var, baselen+1) < 0) |
264 | break; |
265 | } |
266 | die("bad config file line %d in %s", config_linenr, config_file_name); |
267 | } |
268 | |
269 | static int parse_unit_factor(const char *end, unsigned long *val) |
270 | { |
271 | if (!*end) |
272 | return 1; |
273 | else if (!strcasecmp(end, "k")) { |
274 | *val *= 1024; |
275 | return 1; |
276 | } |
277 | else if (!strcasecmp(end, "m")) { |
278 | *val *= 1024 * 1024; |
279 | return 1; |
280 | } |
281 | else if (!strcasecmp(end, "g")) { |
282 | *val *= 1024 * 1024 * 1024; |
283 | return 1; |
284 | } |
285 | return 0; |
286 | } |
287 | |
288 | static int perf_parse_long(const char *value, long *ret) |
289 | { |
290 | if (value && *value) { |
291 | char *end; |
292 | long val = strtol(value, &end, 0); |
293 | unsigned long factor = 1; |
294 | if (!parse_unit_factor(end, &factor)) |
295 | return 0; |
296 | *ret = val * factor; |
297 | return 1; |
298 | } |
299 | return 0; |
300 | } |
301 | |
302 | static void die_bad_config(const char *name) |
303 | { |
304 | if (config_file_name) |
305 | die("bad config value for '%s' in %s", name, config_file_name); |
306 | die("bad config value for '%s'", name); |
307 | } |
308 | |
309 | int perf_config_int(const char *name, const char *value) |
310 | { |
311 | long ret = 0; |
312 | if (!perf_parse_long(value, &ret)) |
313 | die_bad_config(name); |
314 | return ret; |
315 | } |
316 | |
317 | static int perf_config_bool_or_int(const char *name, const char *value, int *is_bool) |
318 | { |
319 | *is_bool = 1; |
320 | if (!value) |
321 | return 1; |
322 | if (!*value) |
323 | return 0; |
324 | if (!strcasecmp(value, "true") || !strcasecmp(value, "yes") || !strcasecmp(value, "on")) |
325 | return 1; |
326 | if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off")) |
327 | return 0; |
328 | *is_bool = 0; |
329 | return perf_config_int(name, value); |
330 | } |
331 | |
332 | int perf_config_bool(const char *name, const char *value) |
333 | { |
334 | int discard; |
335 | return !!perf_config_bool_or_int(name, value, &discard); |
336 | } |
337 | |
338 | const char *perf_config_dirname(const char *name, const char *value) |
339 | { |
340 | if (!name) |
341 | return NULL; |
342 | return value; |
343 | } |
344 | |
345 | static int perf_default_core_config(const char *var __used, const char *value __used) |
346 | { |
347 | /* Add other config variables here. */ |
348 | return 0; |
349 | } |
350 | |
351 | int perf_default_config(const char *var, const char *value, void *dummy __used) |
352 | { |
353 | if (!prefixcmp(var, "core.")) |
354 | return perf_default_core_config(var, value); |
355 | |
356 | /* Add other config variables here. */ |
357 | return 0; |
358 | } |
359 | |
360 | static int perf_config_from_file(config_fn_t fn, const char *filename, void *data) |
361 | { |
362 | int ret; |
363 | FILE *f = fopen(filename, "r"); |
364 | |
365 | ret = -1; |
366 | if (f) { |
367 | config_file = f; |
368 | config_file_name = filename; |
369 | config_linenr = 1; |
370 | config_file_eof = 0; |
371 | ret = perf_parse_file(fn, data); |
372 | fclose(f); |
373 | config_file_name = NULL; |
374 | } |
375 | return ret; |
376 | } |
377 | |
378 | static const char *perf_etc_perfconfig(void) |
379 | { |
380 | static const char *system_wide; |
381 | if (!system_wide) |
382 | system_wide = system_path(ETC_PERFCONFIG); |
383 | return system_wide; |
384 | } |
385 | |
386 | static int perf_env_bool(const char *k, int def) |
387 | { |
388 | const char *v = getenv(k); |
389 | return v ? perf_config_bool(k, v) : def; |
390 | } |
391 | |
392 | static int perf_config_system(void) |
393 | { |
394 | return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0); |
395 | } |
396 | |
397 | static int perf_config_global(void) |
398 | { |
399 | return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0); |
400 | } |
401 | |
402 | int perf_config(config_fn_t fn, void *data) |
403 | { |
404 | int ret = 0, found = 0; |
405 | const char *home = NULL; |
406 | |
407 | /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */ |
408 | if (config_exclusive_filename) |
409 | return perf_config_from_file(fn, config_exclusive_filename, data); |
410 | if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) { |
411 | ret += perf_config_from_file(fn, perf_etc_perfconfig(), |
412 | data); |
413 | found += 1; |
414 | } |
415 | |
416 | home = getenv("HOME"); |
417 | if (perf_config_global() && home) { |
418 | char *user_config = strdup(mkpath("%s/.perfconfig", home)); |
419 | struct stat st; |
420 | |
421 | if (user_config == NULL) { |
422 | warning("Not enough memory to process %s/.perfconfig, " |
423 | "ignoring it.", home); |
424 | goto out; |
425 | } |
426 | |
427 | if (stat(user_config, &st) < 0) |
428 | goto out_free; |
429 | |
430 | if (st.st_uid && (st.st_uid != geteuid())) { |
431 | warning("File %s not owned by current user or root, " |
432 | "ignoring it.", user_config); |
433 | goto out_free; |
434 | } |
435 | |
436 | if (!st.st_size) |
437 | goto out_free; |
438 | |
439 | ret += perf_config_from_file(fn, user_config, data); |
440 | found += 1; |
441 | out_free: |
442 | free(user_config); |
443 | } |
444 | out: |
445 | if (found == 0) |
446 | return -1; |
447 | return ret; |
448 | } |
449 | |
450 | /* |
451 | * Call this to report error for your variable that should not |
452 | * get a boolean value (i.e. "[my] var" means "true"). |
453 | */ |
454 | int config_error_nonbool(const char *var) |
455 | { |
456 | return error("Missing value for '%s'", var); |
457 | } |
458 | |
459 | struct buildid_dir_config { |
460 | char *dir; |
461 | }; |
462 | |
463 | static int buildid_dir_command_config(const char *var, const char *value, |
464 | void *data) |
465 | { |
466 | struct buildid_dir_config *c = data; |
467 | const char *v; |
468 | |
469 | /* same dir for all commands */ |
470 | if (!prefixcmp(var, "buildid.") && !strcmp(var + 8, "dir")) { |
471 | v = perf_config_dirname(var, value); |
472 | if (!v) |
473 | return -1; |
474 | strncpy(c->dir, v, MAXPATHLEN-1); |
475 | c->dir[MAXPATHLEN-1] = '\0'; |
476 | } |
477 | return 0; |
478 | } |
479 | |
480 | static void check_buildid_dir_config(void) |
481 | { |
482 | struct buildid_dir_config c; |
483 | c.dir = buildid_dir; |
484 | perf_config(buildid_dir_command_config, &c); |
485 | } |
486 | |
487 | void set_buildid_dir(void) |
488 | { |
489 | buildid_dir[0] = '\0'; |
490 | |
491 | /* try config file */ |
492 | check_buildid_dir_config(); |
493 | |
494 | /* default to $HOME/.debug */ |
495 | if (buildid_dir[0] == '\0') { |
496 | char *v = getenv("HOME"); |
497 | if (v) { |
498 | snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s", |
499 | v, DEBUG_CACHE_DIR); |
500 | } else { |
501 | strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1); |
502 | } |
503 | buildid_dir[MAXPATHLEN-1] = '\0'; |
504 | } |
505 | /* for communicating with external commands */ |
506 | setenv("PERF_BUILDID_DIR", buildid_dir, 1); |
507 | } |
508 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9