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