]>
Commit | Line | Data |
---|---|---|
a6826fbc WD |
1 | /* |
2 | * This implementation is based on code from uClibc-0.9.30.3 but was | |
3 | * modified and extended for use within U-Boot. | |
4 | * | |
5 | * Copyright (C) 2010 Wolfgang Denk <wd@denx.de> | |
6 | * | |
7 | * Original license header: | |
8 | * | |
9 | * Copyright (C) 1993, 1995, 1996, 1997, 2002 Free Software Foundation, Inc. | |
10 | * This file is part of the GNU C Library. | |
11 | * Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1993. | |
12 | * | |
13 | * The GNU C Library is free software; you can redistribute it and/or | |
14 | * modify it under the terms of the GNU Lesser General Public | |
15 | * License as published by the Free Software Foundation; either | |
16 | * version 2.1 of the License, or (at your option) any later version. | |
17 | * | |
18 | * The GNU C Library is distributed in the hope that it will be useful, | |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
21 | * Lesser General Public License for more details. | |
22 | * | |
23 | * You should have received a copy of the GNU Lesser General Public | |
24 | * License along with the GNU C Library; if not, write to the Free | |
25 | * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
26 | * 02111-1307 USA. | |
27 | */ | |
28 | ||
29 | #include <errno.h> | |
30 | #include <malloc.h> | |
31 | ||
32 | #ifdef USE_HOSTCC /* HOST build */ | |
33 | # include <string.h> | |
34 | # include <assert.h> | |
4d91a6ec | 35 | # include <ctype.h> |
a6826fbc WD |
36 | |
37 | # ifndef debug | |
38 | # ifdef DEBUG | |
39 | # define debug(fmt,args...) printf(fmt ,##args) | |
40 | # else | |
41 | # define debug(fmt,args...) | |
42 | # endif | |
43 | # endif | |
44 | #else /* U-Boot build */ | |
45 | # include <common.h> | |
46 | # include <linux/string.h> | |
4d91a6ec | 47 | # include <linux/ctype.h> |
a6826fbc WD |
48 | #endif |
49 | ||
fc5fc76b AB |
50 | #ifndef CONFIG_ENV_MIN_ENTRIES /* minimum number of entries */ |
51 | #define CONFIG_ENV_MIN_ENTRIES 64 | |
52 | #endif | |
ea882baf WD |
53 | #ifndef CONFIG_ENV_MAX_ENTRIES /* maximum number of entries */ |
54 | #define CONFIG_ENV_MAX_ENTRIES 512 | |
55 | #endif | |
56 | ||
a6826fbc WD |
57 | #include "search.h" |
58 | ||
59 | /* | |
60 | * [Aho,Sethi,Ullman] Compilers: Principles, Techniques and Tools, 1986 | |
071bc923 | 61 | * [Knuth] The Art of Computer Programming, part 3 (6.4) |
a6826fbc WD |
62 | */ |
63 | ||
a6826fbc WD |
64 | /* |
65 | * The reentrant version has no static variables to maintain the state. | |
66 | * Instead the interface of all functions is extended to take an argument | |
67 | * which describes the current status. | |
68 | */ | |
7afcf3a5 | 69 | |
a6826fbc | 70 | typedef struct _ENTRY { |
c81c1222 | 71 | int used; |
a6826fbc WD |
72 | ENTRY entry; |
73 | } _ENTRY; | |
74 | ||
75 | ||
7afcf3a5 JH |
76 | static void _hdelete(const char *key, struct hsearch_data *htab, ENTRY *ep, |
77 | int idx); | |
78 | ||
a6826fbc WD |
79 | /* |
80 | * hcreate() | |
81 | */ | |
82 | ||
83 | /* | |
84 | * For the used double hash method the table size has to be a prime. To | |
85 | * correct the user given table size we need a prime test. This trivial | |
86 | * algorithm is adequate because | |
87 | * a) the code is (most probably) called a few times per program run and | |
88 | * b) the number is small because the table must fit in the core | |
89 | * */ | |
90 | static int isprime(unsigned int number) | |
91 | { | |
92 | /* no even number will be passed */ | |
93 | unsigned int div = 3; | |
94 | ||
95 | while (div * div < number && number % div != 0) | |
96 | div += 2; | |
97 | ||
98 | return number % div != 0; | |
99 | } | |
100 | ||
a6826fbc WD |
101 | /* |
102 | * Before using the hash table we must allocate memory for it. | |
103 | * Test for an existing table are done. We allocate one element | |
104 | * more as the found prime number says. This is done for more effective | |
105 | * indexing as explained in the comment for the hsearch function. | |
106 | * The contents of the table is zeroed, especially the field used | |
107 | * becomes zero. | |
108 | */ | |
2eb1573f | 109 | |
a6826fbc WD |
110 | int hcreate_r(size_t nel, struct hsearch_data *htab) |
111 | { | |
112 | /* Test for correct arguments. */ | |
113 | if (htab == NULL) { | |
114 | __set_errno(EINVAL); | |
115 | return 0; | |
116 | } | |
117 | ||
118 | /* There is still another table active. Return with error. */ | |
119 | if (htab->table != NULL) | |
120 | return 0; | |
121 | ||
122 | /* Change nel to the first prime number not smaller as nel. */ | |
123 | nel |= 1; /* make odd */ | |
124 | while (!isprime(nel)) | |
125 | nel += 2; | |
126 | ||
127 | htab->size = nel; | |
128 | htab->filled = 0; | |
129 | ||
130 | /* allocate memory and zero out */ | |
131 | htab->table = (_ENTRY *) calloc(htab->size + 1, sizeof(_ENTRY)); | |
132 | if (htab->table == NULL) | |
133 | return 0; | |
134 | ||
135 | /* everything went alright */ | |
136 | return 1; | |
137 | } | |
138 | ||
139 | ||
140 | /* | |
141 | * hdestroy() | |
142 | */ | |
a6826fbc WD |
143 | |
144 | /* | |
145 | * After using the hash table it has to be destroyed. The used memory can | |
146 | * be freed and the local static variable can be marked as not used. | |
147 | */ | |
2eb1573f | 148 | |
c4e0057f | 149 | void hdestroy_r(struct hsearch_data *htab) |
a6826fbc WD |
150 | { |
151 | int i; | |
152 | ||
153 | /* Test for correct arguments. */ | |
154 | if (htab == NULL) { | |
155 | __set_errno(EINVAL); | |
156 | return; | |
157 | } | |
158 | ||
159 | /* free used memory */ | |
160 | for (i = 1; i <= htab->size; ++i) { | |
c81c1222 | 161 | if (htab->table[i].used > 0) { |
a6826fbc | 162 | ENTRY *ep = &htab->table[i].entry; |
c4e0057f | 163 | |
84b5e802 | 164 | free((void *)ep->key); |
a6826fbc WD |
165 | free(ep->data); |
166 | } | |
167 | } | |
168 | free(htab->table); | |
169 | ||
170 | /* the sign for an existing table is an value != NULL in htable */ | |
171 | htab->table = NULL; | |
172 | } | |
173 | ||
174 | /* | |
175 | * hsearch() | |
176 | */ | |
177 | ||
178 | /* | |
179 | * This is the search function. It uses double hashing with open addressing. | |
180 | * The argument item.key has to be a pointer to an zero terminated, most | |
181 | * probably strings of chars. The function for generating a number of the | |
182 | * strings is simple but fast. It can be replaced by a more complex function | |
183 | * like ajw (see [Aho,Sethi,Ullman]) if the needs are shown. | |
184 | * | |
185 | * We use an trick to speed up the lookup. The table is created by hcreate | |
186 | * with one more element available. This enables us to use the index zero | |
187 | * special. This index will never be used because we store the first hash | |
188 | * index in the field used where zero means not used. Every other value | |
189 | * means used. The used field can be used as a first fast comparison for | |
190 | * equality of the stored and the parameter value. This helps to prevent | |
191 | * unnecessary expensive calls of strcmp. | |
192 | * | |
193 | * This implementation differs from the standard library version of | |
194 | * this function in a number of ways: | |
195 | * | |
196 | * - While the standard version does not make any assumptions about | |
197 | * the type of the stored data objects at all, this implementation | |
198 | * works with NUL terminated strings only. | |
199 | * - Instead of storing just pointers to the original objects, we | |
200 | * create local copies so the caller does not need to care about the | |
201 | * data any more. | |
202 | * - The standard implementation does not provide a way to update an | |
203 | * existing entry. This version will create a new entry or update an | |
204 | * existing one when both "action == ENTER" and "item.data != NULL". | |
205 | * - Instead of returning 1 on success, we return the index into the | |
206 | * internal hash table, which is also guaranteed to be positive. | |
207 | * This allows us direct access to the found hash table slot for | |
208 | * example for functions like hdelete(). | |
209 | */ | |
210 | ||
a000b795 KP |
211 | /* |
212 | * hstrstr_r - return index to entry whose key and/or data contains match | |
213 | */ | |
214 | int hstrstr_r(const char *match, int last_idx, ENTRY ** retval, | |
215 | struct hsearch_data *htab) | |
216 | { | |
217 | unsigned int idx; | |
218 | ||
219 | for (idx = last_idx + 1; idx < htab->size; ++idx) { | |
220 | if (htab->table[idx].used <= 0) | |
221 | continue; | |
222 | if (strstr(htab->table[idx].entry.key, match) || | |
223 | strstr(htab->table[idx].entry.data, match)) { | |
224 | *retval = &htab->table[idx].entry; | |
225 | return idx; | |
226 | } | |
227 | } | |
228 | ||
229 | __set_errno(ESRCH); | |
230 | *retval = NULL; | |
231 | return 0; | |
232 | } | |
233 | ||
560d424b MF |
234 | int hmatch_r(const char *match, int last_idx, ENTRY ** retval, |
235 | struct hsearch_data *htab) | |
236 | { | |
237 | unsigned int idx; | |
238 | size_t key_len = strlen(match); | |
239 | ||
240 | for (idx = last_idx + 1; idx < htab->size; ++idx) { | |
af4d9074 | 241 | if (htab->table[idx].used <= 0) |
560d424b MF |
242 | continue; |
243 | if (!strncmp(match, htab->table[idx].entry.key, key_len)) { | |
244 | *retval = &htab->table[idx].entry; | |
245 | return idx; | |
246 | } | |
247 | } | |
248 | ||
249 | __set_errno(ESRCH); | |
250 | *retval = NULL; | |
251 | return 0; | |
252 | } | |
253 | ||
3d3b52f2 JH |
254 | /* |
255 | * Compare an existing entry with the desired key, and overwrite if the action | |
256 | * is ENTER. This is simply a helper function for hsearch_r(). | |
257 | */ | |
258 | static inline int _compare_and_overwrite_entry(ENTRY item, ACTION action, | |
259 | ENTRY **retval, struct hsearch_data *htab, int flag, | |
260 | unsigned int hval, unsigned int idx) | |
261 | { | |
262 | if (htab->table[idx].used == hval | |
263 | && strcmp(item.key, htab->table[idx].entry.key) == 0) { | |
264 | /* Overwrite existing value? */ | |
265 | if ((action == ENTER) && (item.data != NULL)) { | |
7afcf3a5 JH |
266 | /* check for permission */ |
267 | if (htab->change_ok != NULL && htab->change_ok( | |
268 | &htab->table[idx].entry, item.data, | |
269 | env_op_overwrite, flag)) { | |
270 | debug("change_ok() rejected setting variable " | |
271 | "%s, skipping it!\n", item.key); | |
272 | __set_errno(EPERM); | |
273 | *retval = NULL; | |
274 | return 0; | |
275 | } | |
276 | ||
3d3b52f2 JH |
277 | free(htab->table[idx].entry.data); |
278 | htab->table[idx].entry.data = strdup(item.data); | |
279 | if (!htab->table[idx].entry.data) { | |
280 | __set_errno(ENOMEM); | |
281 | *retval = NULL; | |
282 | return 0; | |
283 | } | |
284 | } | |
285 | /* return found entry */ | |
286 | *retval = &htab->table[idx].entry; | |
287 | return idx; | |
288 | } | |
289 | /* keep searching */ | |
290 | return -1; | |
291 | } | |
292 | ||
a6826fbc | 293 | int hsearch_r(ENTRY item, ACTION action, ENTRY ** retval, |
c4e0057f | 294 | struct hsearch_data *htab, int flag) |
a6826fbc WD |
295 | { |
296 | unsigned int hval; | |
297 | unsigned int count; | |
298 | unsigned int len = strlen(item.key); | |
299 | unsigned int idx; | |
c81c1222 | 300 | unsigned int first_deleted = 0; |
3d3b52f2 | 301 | int ret; |
a6826fbc WD |
302 | |
303 | /* Compute an value for the given string. Perhaps use a better method. */ | |
304 | hval = len; | |
305 | count = len; | |
306 | while (count-- > 0) { | |
307 | hval <<= 4; | |
308 | hval += item.key[count]; | |
309 | } | |
310 | ||
311 | /* | |
312 | * First hash function: | |
313 | * simply take the modul but prevent zero. | |
314 | */ | |
315 | hval %= htab->size; | |
316 | if (hval == 0) | |
317 | ++hval; | |
318 | ||
319 | /* The first index tried. */ | |
320 | idx = hval; | |
321 | ||
322 | if (htab->table[idx].used) { | |
323 | /* | |
071bc923 | 324 | * Further action might be required according to the |
a6826fbc WD |
325 | * action value. |
326 | */ | |
327 | unsigned hval2; | |
328 | ||
c81c1222 PB |
329 | if (htab->table[idx].used == -1 |
330 | && !first_deleted) | |
331 | first_deleted = idx; | |
332 | ||
3d3b52f2 JH |
333 | ret = _compare_and_overwrite_entry(item, action, retval, htab, |
334 | flag, hval, idx); | |
335 | if (ret != -1) | |
336 | return ret; | |
a6826fbc WD |
337 | |
338 | /* | |
339 | * Second hash function: | |
340 | * as suggested in [Knuth] | |
341 | */ | |
342 | hval2 = 1 + hval % (htab->size - 2); | |
343 | ||
344 | do { | |
345 | /* | |
071bc923 WD |
346 | * Because SIZE is prime this guarantees to |
347 | * step through all available indices. | |
a6826fbc WD |
348 | */ |
349 | if (idx <= hval2) | |
350 | idx = htab->size + idx - hval2; | |
351 | else | |
352 | idx -= hval2; | |
353 | ||
354 | /* | |
355 | * If we visited all entries leave the loop | |
356 | * unsuccessfully. | |
357 | */ | |
358 | if (idx == hval) | |
359 | break; | |
360 | ||
361 | /* If entry is found use it. */ | |
3d3b52f2 JH |
362 | ret = _compare_and_overwrite_entry(item, action, retval, |
363 | htab, flag, hval, idx); | |
364 | if (ret != -1) | |
365 | return ret; | |
a6826fbc WD |
366 | } |
367 | while (htab->table[idx].used); | |
368 | } | |
369 | ||
370 | /* An empty bucket has been found. */ | |
371 | if (action == ENTER) { | |
372 | /* | |
071bc923 WD |
373 | * If table is full and another entry should be |
374 | * entered return with error. | |
a6826fbc WD |
375 | */ |
376 | if (htab->filled == htab->size) { | |
377 | __set_errno(ENOMEM); | |
378 | *retval = NULL; | |
379 | return 0; | |
380 | } | |
381 | ||
382 | /* | |
383 | * Create new entry; | |
384 | * create copies of item.key and item.data | |
385 | */ | |
c81c1222 PB |
386 | if (first_deleted) |
387 | idx = first_deleted; | |
388 | ||
a6826fbc WD |
389 | htab->table[idx].used = hval; |
390 | htab->table[idx].entry.key = strdup(item.key); | |
391 | htab->table[idx].entry.data = strdup(item.data); | |
392 | if (!htab->table[idx].entry.key || | |
393 | !htab->table[idx].entry.data) { | |
394 | __set_errno(ENOMEM); | |
395 | *retval = NULL; | |
396 | return 0; | |
397 | } | |
398 | ||
399 | ++htab->filled; | |
400 | ||
7afcf3a5 JH |
401 | /* check for permission */ |
402 | if (htab->change_ok != NULL && htab->change_ok( | |
403 | &htab->table[idx].entry, item.data, env_op_create, flag)) { | |
404 | debug("change_ok() rejected setting variable " | |
405 | "%s, skipping it!\n", item.key); | |
406 | _hdelete(item.key, htab, &htab->table[idx].entry, idx); | |
407 | __set_errno(EPERM); | |
408 | *retval = NULL; | |
409 | return 0; | |
410 | } | |
411 | ||
a6826fbc WD |
412 | /* return new entry */ |
413 | *retval = &htab->table[idx].entry; | |
414 | return 1; | |
415 | } | |
416 | ||
417 | __set_errno(ESRCH); | |
418 | *retval = NULL; | |
419 | return 0; | |
420 | } | |
421 | ||
422 | ||
423 | /* | |
424 | * hdelete() | |
425 | */ | |
426 | ||
427 | /* | |
428 | * The standard implementation of hsearch(3) does not provide any way | |
429 | * to delete any entries from the hash table. We extend the code to | |
430 | * do that. | |
431 | */ | |
432 | ||
7afcf3a5 JH |
433 | static void _hdelete(const char *key, struct hsearch_data *htab, ENTRY *ep, |
434 | int idx) | |
435 | { | |
436 | /* free used ENTRY */ | |
437 | debug("hdelete: DELETING key \"%s\"\n", key); | |
438 | free((void *)ep->key); | |
439 | free(ep->data); | |
440 | htab->table[idx].used = -1; | |
441 | ||
442 | --htab->filled; | |
443 | } | |
444 | ||
c4e0057f | 445 | int hdelete_r(const char *key, struct hsearch_data *htab, int flag) |
a6826fbc WD |
446 | { |
447 | ENTRY e, *ep; | |
448 | int idx; | |
449 | ||
450 | debug("hdelete: DELETE key \"%s\"\n", key); | |
451 | ||
452 | e.key = (char *)key; | |
453 | ||
c4e0057f JH |
454 | idx = hsearch_r(e, FIND, &ep, htab, 0); |
455 | if (idx == 0) { | |
a6826fbc WD |
456 | __set_errno(ESRCH); |
457 | return 0; /* not found */ | |
458 | } | |
459 | ||
c4e0057f | 460 | /* Check for permission */ |
7afcf3a5 JH |
461 | if (htab->change_ok != NULL && |
462 | htab->change_ok(ep, NULL, env_op_delete, flag)) { | |
463 | debug("change_ok() rejected deleting variable " | |
464 | "%s, skipping it!\n", key); | |
c4e0057f JH |
465 | __set_errno(EPERM); |
466 | return 0; | |
467 | } | |
468 | ||
7afcf3a5 | 469 | _hdelete(key, htab, ep, idx); |
a6826fbc WD |
470 | |
471 | return 1; | |
472 | } | |
473 | ||
474 | /* | |
475 | * hexport() | |
476 | */ | |
477 | ||
7ac2fe2d | 478 | #ifndef CONFIG_SPL_BUILD |
a6826fbc WD |
479 | /* |
480 | * Export the data stored in the hash table in linearized form. | |
481 | * | |
482 | * Entries are exported as "name=value" strings, separated by an | |
483 | * arbitrary (non-NUL, of course) separator character. This allows to | |
484 | * use this function both when formatting the U-Boot environment for | |
485 | * external storage (using '\0' as separator), but also when using it | |
486 | * for the "printenv" command to print all variables, simply by using | |
487 | * as '\n" as separator. This can also be used for new features like | |
488 | * exporting the environment data as text file, including the option | |
489 | * for later re-import. | |
490 | * | |
491 | * The entries in the result list will be sorted by ascending key | |
492 | * values. | |
493 | * | |
494 | * If the separator character is different from NUL, then any | |
495 | * separator characters and backslash characters in the values will | |
496 | * be escaped by a preceeding backslash in output. This is needed for | |
497 | * example to enable multi-line values, especially when the output | |
498 | * shall later be parsed (for example, for re-import). | |
499 | * | |
500 | * There are several options how the result buffer is handled: | |
501 | * | |
502 | * *resp size | |
503 | * ----------- | |
504 | * NULL 0 A string of sufficient length will be allocated. | |
505 | * NULL >0 A string of the size given will be | |
506 | * allocated. An error will be returned if the size is | |
507 | * not sufficient. Any unused bytes in the string will | |
508 | * be '\0'-padded. | |
509 | * !NULL 0 The user-supplied buffer will be used. No length | |
510 | * checking will be performed, i. e. it is assumed that | |
511 | * the buffer size will always be big enough. DANGEROUS. | |
512 | * !NULL >0 The user-supplied buffer will be used. An error will | |
513 | * be returned if the size is not sufficient. Any unused | |
514 | * bytes in the string will be '\0'-padded. | |
515 | */ | |
516 | ||
a6826fbc WD |
517 | static int cmpkey(const void *p1, const void *p2) |
518 | { | |
519 | ENTRY *e1 = *(ENTRY **) p1; | |
520 | ENTRY *e2 = *(ENTRY **) p2; | |
521 | ||
522 | return (strcmp(e1->key, e2->key)); | |
523 | } | |
524 | ||
525 | ssize_t hexport_r(struct hsearch_data *htab, const char sep, | |
37f2fe74 WD |
526 | char **resp, size_t size, |
527 | int argc, char * const argv[]) | |
a6826fbc WD |
528 | { |
529 | ENTRY *list[htab->size]; | |
530 | char *res, *p; | |
531 | size_t totlen; | |
532 | int i, n; | |
533 | ||
534 | /* Test for correct arguments. */ | |
535 | if ((resp == NULL) || (htab == NULL)) { | |
536 | __set_errno(EINVAL); | |
537 | return (-1); | |
538 | } | |
539 | ||
ff856286 SG |
540 | debug("EXPORT table = %p, htab.size = %d, htab.filled = %d, " |
541 | "size = %zu\n", htab, htab->size, htab->filled, size); | |
a6826fbc WD |
542 | /* |
543 | * Pass 1: | |
544 | * search used entries, | |
545 | * save addresses and compute total length | |
546 | */ | |
547 | for (i = 1, n = 0, totlen = 0; i <= htab->size; ++i) { | |
548 | ||
c81c1222 | 549 | if (htab->table[i].used > 0) { |
a6826fbc | 550 | ENTRY *ep = &htab->table[i].entry; |
37f2fe74 WD |
551 | int arg, found = 0; |
552 | ||
553 | for (arg = 0; arg < argc; ++arg) { | |
554 | if (strcmp(argv[arg], ep->key) == 0) { | |
555 | found = 1; | |
556 | break; | |
557 | } | |
558 | } | |
559 | if ((argc > 0) && (found == 0)) | |
560 | continue; | |
a6826fbc WD |
561 | |
562 | list[n++] = ep; | |
563 | ||
564 | totlen += strlen(ep->key) + 2; | |
565 | ||
566 | if (sep == '\0') { | |
567 | totlen += strlen(ep->data); | |
568 | } else { /* check if escapes are needed */ | |
569 | char *s = ep->data; | |
570 | ||
571 | while (*s) { | |
572 | ++totlen; | |
573 | /* add room for needed escape chars */ | |
574 | if ((*s == sep) || (*s == '\\')) | |
575 | ++totlen; | |
576 | ++s; | |
577 | } | |
578 | } | |
579 | totlen += 2; /* for '=' and 'sep' char */ | |
580 | } | |
581 | } | |
582 | ||
583 | #ifdef DEBUG | |
584 | /* Pass 1a: print unsorted list */ | |
585 | printf("Unsorted: n=%d\n", n); | |
586 | for (i = 0; i < n; ++i) { | |
587 | printf("\t%3d: %p ==> %-10s => %s\n", | |
588 | i, list[i], list[i]->key, list[i]->data); | |
589 | } | |
590 | #endif | |
591 | ||
592 | /* Sort list by keys */ | |
593 | qsort(list, n, sizeof(ENTRY *), cmpkey); | |
594 | ||
595 | /* Check if the user supplied buffer size is sufficient */ | |
596 | if (size) { | |
597 | if (size < totlen + 1) { /* provided buffer too small */ | |
ff856286 SG |
598 | printf("Env export buffer too small: %zu, " |
599 | "but need %zu\n", size, totlen + 1); | |
a6826fbc WD |
600 | __set_errno(ENOMEM); |
601 | return (-1); | |
602 | } | |
603 | } else { | |
604 | size = totlen + 1; | |
605 | } | |
606 | ||
607 | /* Check if the user provided a buffer */ | |
608 | if (*resp) { | |
609 | /* yes; clear it */ | |
610 | res = *resp; | |
611 | memset(res, '\0', size); | |
612 | } else { | |
613 | /* no, allocate and clear one */ | |
614 | *resp = res = calloc(1, size); | |
615 | if (res == NULL) { | |
616 | __set_errno(ENOMEM); | |
617 | return (-1); | |
618 | } | |
619 | } | |
620 | /* | |
621 | * Pass 2: | |
622 | * export sorted list of result data | |
623 | */ | |
624 | for (i = 0, p = res; i < n; ++i) { | |
84b5e802 | 625 | const char *s; |
a6826fbc WD |
626 | |
627 | s = list[i]->key; | |
628 | while (*s) | |
629 | *p++ = *s++; | |
630 | *p++ = '='; | |
631 | ||
632 | s = list[i]->data; | |
633 | ||
634 | while (*s) { | |
635 | if ((*s == sep) || (*s == '\\')) | |
636 | *p++ = '\\'; /* escape */ | |
637 | *p++ = *s++; | |
638 | } | |
639 | *p++ = sep; | |
640 | } | |
641 | *p = '\0'; /* terminate result */ | |
642 | ||
643 | return size; | |
644 | } | |
7ac2fe2d | 645 | #endif |
a6826fbc WD |
646 | |
647 | ||
648 | /* | |
649 | * himport() | |
650 | */ | |
651 | ||
d5370feb GF |
652 | /* |
653 | * Check whether variable 'name' is amongst vars[], | |
654 | * and remove all instances by setting the pointer to NULL | |
655 | */ | |
656 | static int drop_var_from_set(const char *name, int nvars, char * vars[]) | |
348b1f1c GF |
657 | { |
658 | int i = 0; | |
d5370feb | 659 | int res = 0; |
348b1f1c GF |
660 | |
661 | /* No variables specified means process all of them */ | |
662 | if (nvars == 0) | |
663 | return 1; | |
664 | ||
665 | for (i = 0; i < nvars; i++) { | |
d5370feb GF |
666 | if (vars[i] == NULL) |
667 | continue; | |
668 | /* If we found it, delete all of them */ | |
669 | if (!strcmp(name, vars[i])) { | |
670 | vars[i] = NULL; | |
671 | res = 1; | |
672 | } | |
348b1f1c | 673 | } |
d5370feb GF |
674 | if (!res) |
675 | debug("Skipping non-listed variable %s\n", name); | |
348b1f1c | 676 | |
d5370feb | 677 | return res; |
348b1f1c GF |
678 | } |
679 | ||
a6826fbc WD |
680 | /* |
681 | * Import linearized data into hash table. | |
682 | * | |
683 | * This is the inverse function to hexport(): it takes a linear list | |
684 | * of "name=value" pairs and creates hash table entries from it. | |
685 | * | |
686 | * Entries without "value", i. e. consisting of only "name" or | |
687 | * "name=", will cause this entry to be deleted from the hash table. | |
688 | * | |
689 | * The "flag" argument can be used to control the behaviour: when the | |
690 | * H_NOCLEAR bit is set, then an existing hash table will kept, i. e. | |
691 | * new data will be added to an existing hash table; otherwise, old | |
692 | * data will be discarded and a new hash table will be created. | |
693 | * | |
694 | * The separator character for the "name=value" pairs can be selected, | |
695 | * so we both support importing from externally stored environment | |
696 | * data (separated by NUL characters) and from plain text files | |
697 | * (entries separated by newline characters). | |
698 | * | |
699 | * To allow for nicely formatted text input, leading white space | |
700 | * (sequences of SPACE and TAB chars) is ignored, and entries starting | |
701 | * (after removal of any leading white space) with a '#' character are | |
702 | * considered comments and ignored. | |
703 | * | |
704 | * [NOTE: this means that a variable name cannot start with a '#' | |
705 | * character.] | |
706 | * | |
707 | * When using a non-NUL separator character, backslash is used as | |
708 | * escape character in the value part, allowing for example for | |
709 | * multi-line values. | |
710 | * | |
711 | * In theory, arbitrary separator characters can be used, but only | |
712 | * '\0' and '\n' have really been tested. | |
713 | */ | |
714 | ||
a6826fbc | 715 | int himport_r(struct hsearch_data *htab, |
348b1f1c | 716 | const char *env, size_t size, const char sep, int flag, |
c4e0057f | 717 | int nvars, char * const vars[]) |
a6826fbc WD |
718 | { |
719 | char *data, *sp, *dp, *name, *value; | |
d5370feb GF |
720 | char *localvars[nvars]; |
721 | int i; | |
a6826fbc WD |
722 | |
723 | /* Test for correct arguments. */ | |
724 | if (htab == NULL) { | |
725 | __set_errno(EINVAL); | |
726 | return 0; | |
727 | } | |
728 | ||
729 | /* we allocate new space to make sure we can write to the array */ | |
730 | if ((data = malloc(size)) == NULL) { | |
ff856286 | 731 | debug("himport_r: can't malloc %zu bytes\n", size); |
a6826fbc WD |
732 | __set_errno(ENOMEM); |
733 | return 0; | |
734 | } | |
735 | memcpy(data, env, size); | |
736 | dp = data; | |
737 | ||
d5370feb GF |
738 | /* make a local copy of the list of variables */ |
739 | if (nvars) | |
740 | memcpy(localvars, vars, sizeof(vars[0]) * nvars); | |
741 | ||
a6826fbc WD |
742 | if ((flag & H_NOCLEAR) == 0) { |
743 | /* Destroy old hash table if one exists */ | |
744 | debug("Destroy Hash Table: %p table = %p\n", htab, | |
745 | htab->table); | |
746 | if (htab->table) | |
c4e0057f | 747 | hdestroy_r(htab); |
a6826fbc WD |
748 | } |
749 | ||
750 | /* | |
751 | * Create new hash table (if needed). The computation of the hash | |
752 | * table size is based on heuristics: in a sample of some 70+ | |
753 | * existing systems we found an average size of 39+ bytes per entry | |
754 | * in the environment (for the whole key=value pair). Assuming a | |
ea882baf WD |
755 | * size of 8 per entry (= safety factor of ~5) should provide enough |
756 | * safety margin for any existing environment definitions and still | |
a6826fbc WD |
757 | * allow for more than enough dynamic additions. Note that the |
758 | * "size" argument is supposed to give the maximum enviroment size | |
ea882baf WD |
759 | * (CONFIG_ENV_SIZE). This heuristics will result in |
760 | * unreasonably large numbers (and thus memory footprint) for | |
761 | * big flash environments (>8,000 entries for 64 KB | |
fc5fc76b AB |
762 | * envrionment size), so we clip it to a reasonable value. |
763 | * On the other hand we need to add some more entries for free | |
764 | * space when importing very small buffers. Both boundaries can | |
765 | * be overwritten in the board config file if needed. | |
a6826fbc WD |
766 | */ |
767 | ||
768 | if (!htab->table) { | |
fc5fc76b | 769 | int nent = CONFIG_ENV_MIN_ENTRIES + size / 8; |
ea882baf WD |
770 | |
771 | if (nent > CONFIG_ENV_MAX_ENTRIES) | |
772 | nent = CONFIG_ENV_MAX_ENTRIES; | |
a6826fbc WD |
773 | |
774 | debug("Create Hash Table: N=%d\n", nent); | |
775 | ||
776 | if (hcreate_r(nent, htab) == 0) { | |
777 | free(data); | |
778 | return 0; | |
779 | } | |
780 | } | |
781 | ||
782 | /* Parse environment; allow for '\0' and 'sep' as separators */ | |
783 | do { | |
784 | ENTRY e, *rv; | |
785 | ||
786 | /* skip leading white space */ | |
4d91a6ec | 787 | while (isblank(*dp)) |
a6826fbc WD |
788 | ++dp; |
789 | ||
790 | /* skip comment lines */ | |
791 | if (*dp == '#') { | |
792 | while (*dp && (*dp != sep)) | |
793 | ++dp; | |
794 | ++dp; | |
795 | continue; | |
796 | } | |
797 | ||
798 | /* parse name */ | |
799 | for (name = dp; *dp != '=' && *dp && *dp != sep; ++dp) | |
800 | ; | |
801 | ||
802 | /* deal with "name" and "name=" entries (delete var) */ | |
803 | if (*dp == '\0' || *(dp + 1) == '\0' || | |
804 | *dp == sep || *(dp + 1) == sep) { | |
805 | if (*dp == '=') | |
806 | *dp++ = '\0'; | |
807 | *dp++ = '\0'; /* terminate name */ | |
808 | ||
809 | debug("DELETE CANDIDATE: \"%s\"\n", name); | |
d5370feb | 810 | if (!drop_var_from_set(name, nvars, localvars)) |
348b1f1c | 811 | continue; |
a6826fbc | 812 | |
c4e0057f | 813 | if (hdelete_r(name, htab, flag) == 0) |
a6826fbc WD |
814 | debug("DELETE ERROR ##############################\n"); |
815 | ||
816 | continue; | |
817 | } | |
818 | *dp++ = '\0'; /* terminate name */ | |
819 | ||
820 | /* parse value; deal with escapes */ | |
821 | for (value = sp = dp; *dp && (*dp != sep); ++dp) { | |
822 | if ((*dp == '\\') && *(dp + 1)) | |
823 | ++dp; | |
824 | *sp++ = *dp; | |
825 | } | |
826 | *sp++ = '\0'; /* terminate value */ | |
827 | ++dp; | |
828 | ||
348b1f1c | 829 | /* Skip variables which are not supposed to be processed */ |
d5370feb | 830 | if (!drop_var_from_set(name, nvars, localvars)) |
348b1f1c GF |
831 | continue; |
832 | ||
a6826fbc WD |
833 | /* enter into hash table */ |
834 | e.key = name; | |
835 | e.data = value; | |
836 | ||
c4e0057f | 837 | hsearch_r(e, ENTER, &rv, htab, flag); |
a6826fbc | 838 | if (rv == NULL) { |
ea882baf WD |
839 | printf("himport_r: can't insert \"%s=%s\" into hash table\n", |
840 | name, value); | |
a6826fbc WD |
841 | return 0; |
842 | } | |
843 | ||
ea882baf WD |
844 | debug("INSERT: table %p, filled %d/%d rv %p ==> name=\"%s\" value=\"%s\"\n", |
845 | htab, htab->filled, htab->size, | |
846 | rv, name, value); | |
a6826fbc WD |
847 | } while ((dp < data + size) && *dp); /* size check needed for text */ |
848 | /* without '\0' termination */ | |
ea882baf | 849 | debug("INSERT: free(data = %p)\n", data); |
a6826fbc WD |
850 | free(data); |
851 | ||
d5370feb GF |
852 | /* process variables which were not considered */ |
853 | for (i = 0; i < nvars; i++) { | |
854 | if (localvars[i] == NULL) | |
855 | continue; | |
856 | /* | |
857 | * All variables which were not deleted from the variable list | |
858 | * were not present in the imported env | |
859 | * This could mean two things: | |
860 | * a) if the variable was present in current env, we delete it | |
861 | * b) if the variable was not present in current env, we notify | |
862 | * it might be a typo | |
863 | */ | |
c4e0057f | 864 | if (hdelete_r(localvars[i], htab, flag) == 0) |
d5370feb GF |
865 | printf("WARNING: '%s' neither in running nor in imported env!\n", localvars[i]); |
866 | else | |
867 | printf("WARNING: '%s' not in imported env, deleting it!\n", localvars[i]); | |
868 | } | |
869 | ||
ea882baf | 870 | debug("INSERT: done\n"); |
a6826fbc WD |
871 | return 1; /* everything OK */ |
872 | } |