Prepare v2024.10
[platform/kernel/u-boot.git] / env / common.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2000-2010
4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5  *
6  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
7  * Andreas Heppel <aheppel@sysgo.de>
8  */
9
10 #include <bootstage.h>
11 #include <command.h>
12 #include <env.h>
13 #include <env_internal.h>
14 #include <log.h>
15 #include <sort.h>
16 #include <asm/global_data.h>
17 #include <linux/printk.h>
18 #include <linux/stddef.h>
19 #include <search.h>
20 #include <errno.h>
21 #include <malloc.h>
22 #include <u-boot/crc.h>
23 #include <dm/ofnode.h>
24 #include <net.h>
25 #include <watchdog.h>
26
27 DECLARE_GLOBAL_DATA_PTR;
28
29 /************************************************************************
30  * Default settings to be used when no valid environment is found
31  */
32 #include <env_default.h>
33
34 struct hsearch_data env_htab = {
35         .change_ok = env_flags_validate,
36 };
37
38 /*
39  * This variable is incremented each time we set an environment variable so we
40  * can be check via env_get_id() to see if the environment has changed or not.
41  * This makes it possible to reread an environment variable only if the
42  * environment was changed, typically used by networking code.
43  */
44 static int env_id = 1;
45
46 int env_get_id(void)
47 {
48         return env_id;
49 }
50
51 void env_inc_id(void)
52 {
53         env_id++;
54 }
55
56 int env_do_env_set(int flag, int argc, char *const argv[], int env_flag)
57 {
58         int   i, len;
59         char  *name, *value, *s;
60         struct env_entry e, *ep;
61
62         debug("Initial value for argc=%d\n", argc);
63
64 #if !IS_ENABLED(CONFIG_SPL_BUILD) && IS_ENABLED(CONFIG_CMD_NVEDIT_EFI)
65         if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e')
66                 return do_env_set_efi(NULL, flag, --argc, ++argv);
67 #endif
68
69         while (argc > 1 && **(argv + 1) == '-') {
70                 char *arg = *++argv;
71
72                 --argc;
73                 while (*++arg) {
74                         switch (*arg) {
75                         case 'f':               /* force */
76                                 env_flag |= H_FORCE;
77                                 break;
78                         default:
79                                 return CMD_RET_USAGE;
80                         }
81                 }
82         }
83         debug("Final value for argc=%d\n", argc);
84         name = argv[1];
85
86         if (strchr(name, '=')) {
87                 printf("## Error: illegal character '=' "
88                        "in variable name \"%s\"\n", name);
89                 return 1;
90         }
91
92         env_inc_id();
93
94         /* Delete only ? */
95         if (argc < 3 || argv[2] == NULL) {
96                 int rc = hdelete_r(name, &env_htab, env_flag);
97
98                 /* If the variable didn't exist, don't report an error */
99                 return rc && rc != -ENOENT ? 1 : 0;
100         }
101
102         /*
103          * Insert / replace new value
104          */
105         for (i = 2, len = 0; i < argc; ++i)
106                 len += strlen(argv[i]) + 1;
107
108         value = malloc(len);
109         if (value == NULL) {
110                 printf("## Can't malloc %d bytes\n", len);
111                 return 1;
112         }
113         for (i = 2, s = value; i < argc; ++i) {
114                 char *v = argv[i];
115
116                 while ((*s++ = *v++) != '\0')
117                         ;
118                 *(s - 1) = ' ';
119         }
120         if (s != value)
121                 *--s = '\0';
122
123         e.key   = name;
124         e.data  = value;
125         hsearch_r(e, ENV_ENTER, &ep, &env_htab, env_flag);
126         free(value);
127         if (!ep) {
128                 printf("## Error inserting \"%s\" variable, errno=%d\n",
129                         name, errno);
130                 return 1;
131         }
132
133         return 0;
134 }
135
136 int env_set(const char *varname, const char *varvalue)
137 {
138         const char * const argv[4] = { "setenv", varname, varvalue, NULL };
139
140         /* before import into hashtable */
141         if (!(gd->flags & GD_FLG_ENV_READY))
142                 return 1;
143
144         if (varvalue == NULL || varvalue[0] == '\0')
145                 return env_do_env_set(0, 2, (char * const *)argv, H_PROGRAMMATIC);
146         else
147                 return env_do_env_set(0, 3, (char * const *)argv, H_PROGRAMMATIC);
148 }
149
150 /**
151  * Set an environment variable to an integer value
152  *
153  * @param varname       Environment variable to set
154  * @param value         Value to set it to
155  * Return: 0 if ok, 1 on error
156  */
157 int env_set_ulong(const char *varname, ulong value)
158 {
159         /* TODO: this should be unsigned */
160         char *str = simple_itoa(value);
161
162         return env_set(varname, str);
163 }
164
165 /**
166  * Set an environment variable to an value in hex
167  *
168  * @param varname       Environment variable to set
169  * @param value         Value to set it to
170  * Return: 0 if ok, 1 on error
171  */
172 int env_set_hex(const char *varname, ulong value)
173 {
174         char str[17];
175
176         sprintf(str, "%lx", value);
177         return env_set(varname, str);
178 }
179
180 ulong env_get_hex(const char *varname, ulong default_val)
181 {
182         const char *s;
183         ulong value;
184         char *endp;
185
186         s = env_get(varname);
187         if (s)
188                 value = hextoul(s, &endp);
189         if (!s || endp == s)
190                 return default_val;
191
192         return value;
193 }
194
195 int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr)
196 {
197         string_to_enetaddr(env_get(name), enetaddr);
198         return is_valid_ethaddr(enetaddr);
199 }
200
201 int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr)
202 {
203         char buf[ARP_HLEN_ASCII + 1];
204
205         if (eth_env_get_enetaddr(name, (uint8_t *)buf))
206                 return -EEXIST;
207
208         sprintf(buf, "%pM", enetaddr);
209
210         return env_set(name, buf);
211 }
212
213 /*
214  * Look up variable from environment,
215  * return address of storage for that variable,
216  * or NULL if not found
217  */
218 char *env_get(const char *name)
219 {
220         if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
221                 struct env_entry e, *ep;
222
223                 schedule();
224
225                 e.key   = name;
226                 e.data  = NULL;
227                 hsearch_r(e, ENV_FIND, &ep, &env_htab, 0);
228
229                 return ep ? ep->data : NULL;
230         }
231
232         /* restricted capabilities before import */
233         if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) >= 0)
234                 return (char *)(gd->env_buf);
235
236         return NULL;
237 }
238
239 /*
240  * Like env_get, but prints an error if envvar isn't defined in the
241  * environment.  It always returns what env_get does, so it can be used in
242  * place of env_get without changing error handling otherwise.
243  */
244 char *from_env(const char *envvar)
245 {
246         char *ret;
247
248         ret = env_get(envvar);
249
250         if (!ret)
251                 printf("missing environment variable: %s\n", envvar);
252
253         return ret;
254 }
255
256 static int env_get_from_linear(const char *env, const char *name, char *buf,
257                                unsigned len)
258 {
259         const char *p, *end;
260         size_t name_len;
261
262         if (name == NULL || *name == '\0')
263                 return -1;
264
265         name_len = strlen(name);
266
267         for (p = env; *p != '\0'; p = end + 1) {
268                 const char *value;
269                 unsigned res;
270
271                 for (end = p; *end != '\0'; ++end)
272                         if (end - env >= CONFIG_ENV_SIZE)
273                                 return -1;
274
275                 if (strncmp(name, p, name_len) || p[name_len] != '=')
276                         continue;
277                 value = &p[name_len + 1];
278
279                 res = end - value;
280                 memcpy(buf, value, min(len, res + 1));
281
282                 if (len <= res) {
283                         buf[len - 1] = '\0';
284                         printf("env_buf [%u bytes] too small for value of \"%s\"\n",
285                                len, name);
286                 }
287
288                 return res;
289         }
290
291         return -1;
292 }
293
294 /*
295  * Look up variable from environment for restricted C runtime env.
296  */
297 int env_get_f(const char *name, char *buf, unsigned len)
298 {
299         const char *env;
300
301         if (gd->env_valid == ENV_INVALID)
302                 env = default_environment;
303         else
304                 env = (const char *)gd->env_addr;
305
306         return env_get_from_linear(env, name, buf, len);
307 }
308
309 /**
310  * Decode the integer value of an environment variable and return it.
311  *
312  * @param name          Name of environment variable
313  * @param base          Number base to use (normally 10, or 16 for hex)
314  * @param default_val   Default value to return if the variable is not
315  *                      found
316  * Return: the decoded value, or default_val if not found
317  */
318 ulong env_get_ulong(const char *name, int base, ulong default_val)
319 {
320         /*
321          * We can use env_get() here, even before relocation, since the
322          * environment variable value is an integer and thus short.
323          */
324         const char *str = env_get(name);
325
326         return str ? simple_strtoul(str, NULL, base) : default_val;
327 }
328
329 /*
330  * Read an environment variable as a boolean
331  * Return -1 if variable does not exist (default to true)
332  */
333 int env_get_yesno(const char *var)
334 {
335         char *s = env_get(var);
336
337         if (s == NULL)
338                 return -1;
339         return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
340                 1 : 0;
341 }
342
343 bool env_get_autostart(void)
344 {
345         return env_get_yesno("autostart") == 1;
346 }
347
348 /*
349  * Look up the variable from the default environment
350  */
351 char *env_get_default(const char *name)
352 {
353         int ret;
354
355         ret = env_get_default_into(name, (char *)(gd->env_buf),
356                                    sizeof(gd->env_buf));
357         if (ret >= 0)
358                 return (char *)(gd->env_buf);
359
360         return NULL;
361 }
362
363 /*
364  * Look up the variable from the default environment and store its value in buf
365  */
366 int env_get_default_into(const char *name, char *buf, unsigned int len)
367 {
368         return env_get_from_linear(default_environment, name, buf, len);
369 }
370
371 void env_set_default(const char *s, int flags)
372 {
373         if (s) {
374                 if ((flags & H_INTERACTIVE) == 0) {
375                         printf("*** Warning - %s, "
376                                 "using default environment\n\n", s);
377                 } else {
378                         puts(s);
379                 }
380         } else {
381                 debug("Using default environment\n");
382         }
383
384         flags |= H_DEFAULT;
385         if (himport_r(&env_htab, default_environment,
386                         sizeof(default_environment), '\0', flags, 0,
387                         0, NULL) == 0) {
388                 pr_err("## Error: Environment import failed: errno = %d\n",
389                        errno);
390                 return;
391         }
392
393         gd->flags |= GD_FLG_ENV_READY;
394         gd->flags |= GD_FLG_ENV_DEFAULT;
395 }
396
397 /* [re]set individual variables to their value in the default environment */
398 int env_set_default_vars(int nvars, char * const vars[], int flags)
399 {
400         /*
401          * Special use-case: import from default environment
402          * (and use \0 as a separator)
403          */
404         flags |= H_NOCLEAR | H_DEFAULT;
405         return himport_r(&env_htab, default_environment,
406                                 sizeof(default_environment), '\0',
407                                 flags, 0, nvars, vars);
408 }
409
410 /*
411  * Check if CRC is valid and (if yes) import the environment.
412  * Note that "buf" may or may not be aligned.
413  */
414 int env_import(const char *buf, int check, int flags)
415 {
416         env_t *ep = (env_t *)buf;
417
418         if (check) {
419                 uint32_t crc;
420
421                 memcpy(&crc, &ep->crc, sizeof(crc));
422
423                 if (crc32(0, ep->data, ENV_SIZE) != crc) {
424                         env_set_default("bad CRC", 0);
425                         return -ENOMSG; /* needed for env_load() */
426                 }
427         }
428
429         if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
430                         0, NULL)) {
431                 gd->flags |= GD_FLG_ENV_READY;
432                 return 0;
433         }
434
435         pr_err("Cannot import environment: errno = %d\n", errno);
436
437         env_set_default("import failed", 0);
438
439         return -EIO;
440 }
441
442 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
443 static unsigned char env_flags;
444
445 int env_check_redund(const char *buf1, int buf1_read_fail,
446                      const char *buf2, int buf2_read_fail)
447 {
448         int crc1_ok = 0, crc2_ok = 0;
449         env_t *tmp_env1, *tmp_env2;
450
451         tmp_env1 = (env_t *)buf1;
452         tmp_env2 = (env_t *)buf2;
453
454         if (buf1_read_fail && buf2_read_fail) {
455                 puts("*** Error - No Valid Environment Area found\n");
456                 return -EIO;
457         } else if (buf1_read_fail || buf2_read_fail) {
458                 puts("*** Warning - some problems detected ");
459                 puts("reading environment; recovered successfully\n");
460         }
461
462         if (!buf1_read_fail)
463                 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
464                                 tmp_env1->crc;
465         if (!buf2_read_fail)
466                 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
467                                 tmp_env2->crc;
468
469         if (!crc1_ok && !crc2_ok) {
470                 gd->env_valid = ENV_INVALID;
471                 return -ENOMSG; /* needed for env_load() */
472         } else if (crc1_ok && !crc2_ok) {
473                 gd->env_valid = ENV_VALID;
474         } else if (!crc1_ok && crc2_ok) {
475                 gd->env_valid = ENV_REDUND;
476         } else {
477                 /* both ok - check serial */
478                 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
479                         gd->env_valid = ENV_REDUND;
480                 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
481                         gd->env_valid = ENV_VALID;
482                 else if (tmp_env1->flags > tmp_env2->flags)
483                         gd->env_valid = ENV_VALID;
484                 else if (tmp_env2->flags > tmp_env1->flags)
485                         gd->env_valid = ENV_REDUND;
486                 else /* flags are equal - almost impossible */
487                         gd->env_valid = ENV_VALID;
488         }
489
490         return 0;
491 }
492
493 int env_import_redund(const char *buf1, int buf1_read_fail,
494                       const char *buf2, int buf2_read_fail,
495                       int flags)
496 {
497         env_t *ep;
498         int ret;
499
500         ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
501
502         if (ret == -EIO) {
503                 env_set_default("bad env area", 0);
504                 return -EIO;
505         } else if (ret == -ENOMSG) {
506                 env_set_default("bad CRC", 0);
507                 return -ENOMSG;
508         }
509
510         if (gd->env_valid == ENV_VALID)
511                 ep = (env_t *)buf1;
512         else
513                 ep = (env_t *)buf2;
514
515         env_flags = ep->flags;
516
517         return env_import((char *)ep, 0, flags);
518 }
519 #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
520
521 /* Export the environment and generate CRC for it. */
522 int env_export(env_t *env_out)
523 {
524         char *res;
525         ssize_t len;
526
527         res = (char *)env_out->data;
528         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
529         if (len < 0) {
530                 pr_err("Cannot export environment: errno = %d\n", errno);
531                 return 1;
532         }
533
534         env_out->crc = crc32(0, env_out->data, ENV_SIZE);
535
536 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
537         env_out->flags = ++env_flags; /* increase the serial */
538 #endif
539
540         return 0;
541 }
542
543 void env_relocate(void)
544 {
545         if (gd->env_valid == ENV_INVALID) {
546 #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
547                 /* Environment not changable */
548                 env_set_default(NULL, 0);
549 #else
550                 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
551                 env_set_default("bad CRC", 0);
552 #endif
553         } else {
554                 env_load();
555         }
556 }
557
558 #ifdef CONFIG_AUTO_COMPLETE
559 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
560                  bool dollar_comp)
561 {
562         struct env_entry *match;
563         int found, idx;
564
565         if (dollar_comp) {
566                 /*
567                  * When doing $ completion, the first character should
568                  * obviously be a '$'.
569                  */
570                 if (var[0] != '$')
571                         return 0;
572
573                 var++;
574
575                 /*
576                  * The second one, if present, should be a '{', as some
577                  * configuration of the u-boot shell expand ${var} but not
578                  * $var.
579                  */
580                 if (var[0] == '{')
581                         var++;
582                 else if (var[0] != '\0')
583                         return 0;
584         }
585
586         idx = 0;
587         found = 0;
588         cmdv[0] = NULL;
589
590         while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
591                 int vallen = strlen(match->key) + 1;
592
593                 if (found >= maxv - 2 ||
594                     bufsz < vallen + (dollar_comp ? 3 : 0))
595                         break;
596
597                 cmdv[found++] = buf;
598
599                 /* Add the '${' prefix to each var when doing $ completion. */
600                 if (dollar_comp) {
601                         strcpy(buf, "${");
602                         buf += 2;
603                         bufsz -= 3;
604                 }
605
606                 memcpy(buf, match->key, vallen);
607                 buf += vallen;
608                 bufsz -= vallen;
609
610                 if (dollar_comp) {
611                         /*
612                          * This one is a bit odd: vallen already contains the
613                          * '\0' character but we need to add the '}' suffix,
614                          * hence the buf - 1 here. strcpy() will add the '\0'
615                          * character just after '}'. buf is then incremented
616                          * to account for the extra '}' we just added.
617                          */
618                         strcpy(buf - 1, "}");
619                         buf++;
620                 }
621         }
622
623         qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
624
625         if (idx)
626                 cmdv[found++] = dollar_comp ? "${...}" : "...";
627
628         cmdv[found] = NULL;
629         return found;
630 }
631 #endif
632
633 #ifdef CONFIG_ENV_IMPORT_FDT
634 void env_import_fdt(void)
635 {
636         const char *path;
637         struct ofprop prop;
638         ofnode node;
639         int res;
640
641         path = env_get("env_fdt_path");
642         if (!path || !path[0])
643                 return;
644
645         node = ofnode_path(path);
646         if (!ofnode_valid(node)) {
647                 printf("Warning: device tree node '%s' not found\n", path);
648                 return;
649         }
650
651         for (res = ofnode_first_property(node, &prop);
652              !res;
653              res = ofnode_next_property(&prop)) {
654                 const char *name, *val;
655
656                 val = ofprop_get_property(&prop, &name, NULL);
657                 env_set(name, val);
658         }
659 }
660 #endif