blob: 8beb8e6aa4af6cc7d58748e022c936d940fe10bc [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk05706fd2002-09-28 17:48:27 +00002/*
Wolfgang Denkea882ba2010-06-20 23:33:59 +02003 * (C) Copyright 2000-2010
wdenk05706fd2002-09-28 17:48:27 +00004 * 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>
wdenk05706fd2002-09-28 17:48:27 +00008 */
9
10#include <common.h>
Simon Glass52f24232020-05-10 11:40:00 -060011#include <bootstage.h>
wdenk05706fd2002-09-28 17:48:27 +000012#include <command.h>
Simon Glass3f989e7b2019-08-01 09:46:44 -060013#include <env.h>
Simon Glassf3998fd2019-08-02 09:44:25 -060014#include <env_internal.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060015#include <log.h>
Simon Glass8bef79b2019-11-14 12:57:19 -070016#include <sort.h>
Simon Glass401d1c42020-10-30 21:38:53 -060017#include <asm/global_data.h>
wdenk05706fd2002-09-28 17:48:27 +000018#include <linux/stddef.h>
Wolfgang Denkea882ba2010-06-20 23:33:59 +020019#include <search.h>
20#include <errno.h>
wdenk05706fd2002-09-28 17:48:27 +000021#include <malloc.h>
Simon Glass3db71102019-11-14 12:57:16 -070022#include <u-boot/crc.h>
Rasmus Villemoes95fd9772021-04-21 11:06:54 +020023#include <dm/ofnode.h>
Marek Behúnf2315662021-10-17 17:36:38 +020024#include <net.h>
25#include <watchdog.h>
wdenk05706fd2002-09-28 17:48:27 +000026
Wolfgang Denkd87080b2006-03-31 18:32:53 +020027DECLARE_GLOBAL_DATA_PTR;
28
wdenk05706fd2002-09-28 17:48:27 +000029/************************************************************************
30 * Default settings to be used when no valid environment is found
31 */
Joe Hershbergerddd84182012-10-12 08:48:51 +000032#include <env_default.h>
wdenk05706fd2002-09-28 17:48:27 +000033
Gerlando Falautoc5983592012-08-24 00:11:39 +000034struct hsearch_data env_htab = {
Joe Hershberger25980902012-12-11 22:16:31 -060035 .change_ok = env_flags_validate,
Gerlando Falautoc5983592012-08-24 00:11:39 +000036};
Mike Frysinger2eb15732010-12-08 06:26:04 -050037
Joe Hershbergerec8a2522012-12-11 22:16:22 -060038/*
Marek Behúnf2315662021-10-17 17:36:38 +020039 * This env_set() function is defined in cmd/nvedit.c, since it calls
40 * _do_env_set(), whis is a static function in that file.
41 *
42 * int env_set(const char *varname, const char *varvalue);
43 */
44
45/**
46 * Set an environment variable to an integer value
47 *
48 * @param varname Environment variable to set
49 * @param value Value to set it to
Heinrich Schuchardt185f8122022-01-19 18:05:50 +010050 * Return: 0 if ok, 1 on error
Marek Behúnf2315662021-10-17 17:36:38 +020051 */
52int env_set_ulong(const char *varname, ulong value)
53{
54 /* TODO: this should be unsigned */
55 char *str = simple_itoa(value);
56
57 return env_set(varname, str);
58}
59
60/**
61 * Set an environment variable to an value in hex
62 *
63 * @param varname Environment variable to set
64 * @param value Value to set it to
Heinrich Schuchardt185f8122022-01-19 18:05:50 +010065 * Return: 0 if ok, 1 on error
Marek Behúnf2315662021-10-17 17:36:38 +020066 */
67int env_set_hex(const char *varname, ulong value)
68{
69 char str[17];
70
71 sprintf(str, "%lx", value);
72 return env_set(varname, str);
73}
74
75ulong env_get_hex(const char *varname, ulong default_val)
76{
77 const char *s;
78 ulong value;
79 char *endp;
80
81 s = env_get(varname);
82 if (s)
83 value = hextoul(s, &endp);
84 if (!s || endp == s)
85 return default_val;
86
87 return value;
88}
89
90int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr)
91{
92 string_to_enetaddr(env_get(name), enetaddr);
93 return is_valid_ethaddr(enetaddr);
94}
95
96int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr)
97{
98 char buf[ARP_HLEN_ASCII + 1];
99
100 if (eth_env_get_enetaddr(name, (uint8_t *)buf))
101 return -EEXIST;
102
103 sprintf(buf, "%pM", enetaddr);
104
105 return env_set(name, buf);
106}
107
108/*
109 * Look up variable from environment,
110 * return address of storage for that variable,
111 * or NULL if not found
112 */
113char *env_get(const char *name)
114{
115 if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
116 struct env_entry e, *ep;
117
Stefan Roese29caf932022-09-02 14:10:46 +0200118 schedule();
Marek Behúnf2315662021-10-17 17:36:38 +0200119
120 e.key = name;
121 e.data = NULL;
122 hsearch_r(e, ENV_FIND, &ep, &env_htab, 0);
123
124 return ep ? ep->data : NULL;
125 }
126
127 /* restricted capabilities before import */
Marek Behúne8459c12021-11-04 00:23:22 +0100128 if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) >= 0)
Marek Behúnf2315662021-10-17 17:36:38 +0200129 return (char *)(gd->env_buf);
130
131 return NULL;
132}
133
134/*
135 * Like env_get, but prints an error if envvar isn't defined in the
136 * environment. It always returns what env_get does, so it can be used in
137 * place of env_get without changing error handling otherwise.
138 */
139char *from_env(const char *envvar)
140{
141 char *ret;
142
143 ret = env_get(envvar);
144
145 if (!ret)
146 printf("missing environment variable: %s\n", envvar);
147
148 return ret;
149}
150
Marek Behún4e7c8b22021-11-04 00:23:23 +0100151static int env_get_from_linear(const char *env, const char *name, char *buf,
152 unsigned len)
Marek Behúnf2315662021-10-17 17:36:38 +0200153{
Marek Behún4e7c8b22021-11-04 00:23:23 +0100154 const char *p, *end;
Marek Behúnf2315662021-10-17 17:36:38 +0200155 size_t name_len;
156
157 if (name == NULL || *name == '\0')
158 return -1;
159
160 name_len = strlen(name);
161
Marek Behúnf2315662021-10-17 17:36:38 +0200162 for (p = env; *p != '\0'; p = end + 1) {
163 const char *value;
164 unsigned res;
165
166 for (end = p; *end != '\0'; ++end)
167 if (end - env >= CONFIG_ENV_SIZE)
168 return -1;
169
170 if (strncmp(name, p, name_len) || p[name_len] != '=')
171 continue;
172 value = &p[name_len + 1];
173
174 res = end - value;
175 memcpy(buf, value, min(len, res + 1));
176
177 if (len <= res) {
178 buf[len - 1] = '\0';
179 printf("env_buf [%u bytes] too small for value of \"%s\"\n",
180 len, name);
181 }
182
183 return res;
184 }
185
186 return -1;
187}
188
Marek Behún4e7c8b22021-11-04 00:23:23 +0100189/*
190 * Look up variable from environment for restricted C runtime env.
191 */
192int env_get_f(const char *name, char *buf, unsigned len)
193{
194 const char *env;
195
196 if (gd->env_valid == ENV_INVALID)
197 env = default_environment;
198 else
199 env = (const char *)gd->env_addr;
200
201 return env_get_from_linear(env, name, buf, len);
202}
203
Marek Behúnf2315662021-10-17 17:36:38 +0200204/**
205 * Decode the integer value of an environment variable and return it.
206 *
207 * @param name Name of environment variable
208 * @param base Number base to use (normally 10, or 16 for hex)
209 * @param default_val Default value to return if the variable is not
210 * found
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100211 * Return: the decoded value, or default_val if not found
Marek Behúnf2315662021-10-17 17:36:38 +0200212 */
213ulong env_get_ulong(const char *name, int base, ulong default_val)
214{
215 /*
216 * We can use env_get() here, even before relocation, since the
217 * environment variable value is an integer and thus short.
218 */
219 const char *str = env_get(name);
220
221 return str ? simple_strtoul(str, NULL, base) : default_val;
222}
223
224/*
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600225 * Read an environment variable as a boolean
226 * Return -1 if variable does not exist (default to true)
227 */
Simon Glassbfebc8c2017-08-03 12:22:13 -0600228int env_get_yesno(const char *var)
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600229{
Simon Glass00caae62017-08-03 12:22:12 -0600230 char *s = env_get(var);
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600231
232 if (s == NULL)
233 return -1;
234 return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
235 1 : 0;
236}
237
Simon Glass78398652021-10-21 21:08:52 -0600238bool env_get_autostart(void)
239{
240 return env_get_yesno("autostart") == 1;
241}
242
Joe Hershberger267541f2012-12-11 22:16:34 -0600243/*
244 * Look up the variable from the default environment
245 */
Simon Glass723806c2017-08-03 12:22:15 -0600246char *env_get_default(const char *name)
Joe Hershberger267541f2012-12-11 22:16:34 -0600247{
Marek Behún4e7c8b22021-11-04 00:23:23 +0100248 if (env_get_from_linear(default_environment, name,
249 (char *)(gd->env_buf),
250 sizeof(gd->env_buf)) >= 0)
251 return (char *)(gd->env_buf);
Joe Hershberger267541f2012-12-11 22:16:34 -0600252
Marek Behún4e7c8b22021-11-04 00:23:23 +0100253 return NULL;
Joe Hershberger267541f2012-12-11 22:16:34 -0600254}
255
Simon Glass0ac7d722019-08-01 09:47:00 -0600256void env_set_default(const char *s, int flags)
Harald Welte5bb12db2008-07-07 15:40:39 +0800257{
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200258 if (s) {
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300259 if ((flags & H_INTERACTIVE) == 0) {
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200260 printf("*** Warning - %s, "
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300261 "using default environment\n\n", s);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200262 } else {
263 puts(s);
264 }
265 } else {
Maxime Ripard58ae9992018-01-23 21:16:57 +0100266 debug("Using default environment\n");
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200267 }
268
Marek Vasutef9bef22020-07-07 20:51:34 +0200269 flags |= H_DEFAULT;
Marek Behúnc5cbbe32021-10-22 15:47:24 +0200270 if (himport_r(&env_htab, default_environment,
Alexander Hollerecd14462014-07-14 17:49:55 +0200271 sizeof(default_environment), '\0', flags, 0,
Marek Behúnc9db4c52021-11-04 00:23:21 +0100272 0, NULL) == 0) {
Quentin Schulz6c90f622018-07-09 19:16:25 +0200273 pr_err("## Error: Environment import failed: errno = %d\n",
274 errno);
Marek Behúnc9db4c52021-11-04 00:23:21 +0100275 return;
276 }
Igor Grinberg27aafe92011-11-07 01:14:11 +0000277
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200278 gd->flags |= GD_FLG_ENV_READY;
Michal Simek340b0e32016-05-30 16:06:54 +0200279 gd->flags |= GD_FLG_ENV_DEFAULT;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200280}
281
Gerlando Falautob64b7c32012-08-24 00:11:41 +0000282
283/* [re]set individual variables to their value in the default environment */
Simon Glass0b9d8a02019-08-01 09:46:56 -0600284int env_set_default_vars(int nvars, char * const vars[], int flags)
Gerlando Falautob64b7c32012-08-24 00:11:41 +0000285{
286 /*
287 * Special use-case: import from default environment
288 * (and use \0 as a separator)
289 */
Marek Vasutef9bef22020-07-07 20:51:34 +0200290 flags |= H_NOCLEAR | H_DEFAULT;
Marek Behúnc5cbbe32021-10-22 15:47:24 +0200291 return himport_r(&env_htab, default_environment,
Joe Hershbergerc4e00572012-12-11 22:16:19 -0600292 sizeof(default_environment), '\0',
Yaniv Levinsky477f8112018-06-24 19:16:55 +0300293 flags, 0, nvars, vars);
Gerlando Falautob64b7c32012-08-24 00:11:41 +0000294}
295
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200296/*
297 * Check if CRC is valid and (if yes) import the environment.
298 * Note that "buf" may or may not be aligned.
299 */
Marek Vasut890feec2020-07-07 20:51:35 +0200300int env_import(const char *buf, int check, int flags)
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200301{
302 env_t *ep = (env_t *)buf;
303
304 if (check) {
305 uint32_t crc;
306
307 memcpy(&crc, &ep->crc, sizeof(crc));
308
309 if (crc32(0, ep->data, ENV_SIZE) != crc) {
Simon Glass0ac7d722019-08-01 09:47:00 -0600310 env_set_default("bad CRC", 0);
Sam Protsenko49d04c52019-01-18 21:19:03 +0200311 return -ENOMSG; /* needed for env_load() */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200312 }
313 }
314
Marek Vasut890feec2020-07-07 20:51:35 +0200315 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
Joe Hershbergerc4e00572012-12-11 22:16:19 -0600316 0, NULL)) {
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200317 gd->flags |= GD_FLG_ENV_READY;
Simon Goldschmidt42a18202018-01-31 14:47:10 +0100318 return 0;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200319 }
320
Masahiro Yamada9b643e32017-09-16 14:10:41 +0900321 pr_err("Cannot import environment: errno = %d\n", errno);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200322
Simon Glass0ac7d722019-08-01 09:47:00 -0600323 env_set_default("import failed", 0);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200324
Simon Goldschmidt42a18202018-01-31 14:47:10 +0100325 return -EIO;
Harald Welte5bb12db2008-07-07 15:40:39 +0800326}
327
Fiach Antaw76768f52017-01-25 18:53:11 +1000328#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
329static unsigned char env_flags;
330
Heiko Schocher12295332020-10-10 10:28:04 +0200331int env_check_redund(const char *buf1, int buf1_read_fail,
332 const char *buf2, int buf2_read_fail)
Fiach Antaw76768f52017-01-25 18:53:11 +1000333{
Brandon Maierb9c30522020-12-17 17:19:18 -0600334 int crc1_ok = 0, crc2_ok = 0;
Heiko Schocher12295332020-10-10 10:28:04 +0200335 env_t *tmp_env1, *tmp_env2;
Fiach Antaw76768f52017-01-25 18:53:11 +1000336
337 tmp_env1 = (env_t *)buf1;
338 tmp_env2 = (env_t *)buf2;
339
Simon Goldschmidt31f044b2018-01-31 14:47:11 +0100340 if (buf1_read_fail && buf2_read_fail) {
341 puts("*** Error - No Valid Environment Area found\n");
Brandon Maierb9c30522020-12-17 17:19:18 -0600342 return -EIO;
Simon Goldschmidt31f044b2018-01-31 14:47:11 +0100343 } else if (buf1_read_fail || buf2_read_fail) {
344 puts("*** Warning - some problems detected ");
345 puts("reading environment; recovered successfully\n");
346 }
347
Brandon Maierb9c30522020-12-17 17:19:18 -0600348 if (!buf1_read_fail)
349 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
350 tmp_env1->crc;
351 if (!buf2_read_fail)
352 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
353 tmp_env2->crc;
Fiach Antaw76768f52017-01-25 18:53:11 +1000354
355 if (!crc1_ok && !crc2_ok) {
Sam Protsenko49d04c52019-01-18 21:19:03 +0200356 return -ENOMSG; /* needed for env_load() */
Fiach Antaw76768f52017-01-25 18:53:11 +1000357 } else if (crc1_ok && !crc2_ok) {
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600358 gd->env_valid = ENV_VALID;
Fiach Antaw76768f52017-01-25 18:53:11 +1000359 } else if (!crc1_ok && crc2_ok) {
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600360 gd->env_valid = ENV_REDUND;
Fiach Antaw76768f52017-01-25 18:53:11 +1000361 } else {
362 /* both ok - check serial */
363 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600364 gd->env_valid = ENV_REDUND;
Fiach Antaw76768f52017-01-25 18:53:11 +1000365 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600366 gd->env_valid = ENV_VALID;
Fiach Antaw76768f52017-01-25 18:53:11 +1000367 else if (tmp_env1->flags > tmp_env2->flags)
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600368 gd->env_valid = ENV_VALID;
Fiach Antaw76768f52017-01-25 18:53:11 +1000369 else if (tmp_env2->flags > tmp_env1->flags)
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600370 gd->env_valid = ENV_REDUND;
Fiach Antaw76768f52017-01-25 18:53:11 +1000371 else /* flags are equal - almost impossible */
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600372 gd->env_valid = ENV_VALID;
Fiach Antaw76768f52017-01-25 18:53:11 +1000373 }
374
Heiko Schocher12295332020-10-10 10:28:04 +0200375 return 0;
376}
377
378int env_import_redund(const char *buf1, int buf1_read_fail,
379 const char *buf2, int buf2_read_fail,
380 int flags)
381{
382 env_t *ep;
383 int ret;
384
385 ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
386
387 if (ret == -EIO) {
388 env_set_default("bad env area", 0);
389 return -EIO;
Heiko Schocher12295332020-10-10 10:28:04 +0200390 } else if (ret == -ENOMSG) {
391 env_set_default("bad CRC", 0);
392 return -ENOMSG;
393 }
394
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600395 if (gd->env_valid == ENV_VALID)
Heiko Schocher12295332020-10-10 10:28:04 +0200396 ep = (env_t *)buf1;
Fiach Antaw76768f52017-01-25 18:53:11 +1000397 else
Heiko Schocher12295332020-10-10 10:28:04 +0200398 ep = (env_t *)buf2;
Fiach Antaw76768f52017-01-25 18:53:11 +1000399
400 env_flags = ep->flags;
Heiko Schocher12295332020-10-10 10:28:04 +0200401
Marek Vasut890feec2020-07-07 20:51:35 +0200402 return env_import((char *)ep, 0, flags);
Fiach Antaw76768f52017-01-25 18:53:11 +1000403}
404#endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
405
Robert P. J. Dayfc0b5942016-09-07 14:27:59 -0400406/* Export the environment and generate CRC for it. */
Marek Vasut7ce15262014-03-05 19:59:50 +0100407int env_export(env_t *env_out)
408{
409 char *res;
410 ssize_t len;
411
412 res = (char *)env_out->data;
413 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
414 if (len < 0) {
Masahiro Yamada9b643e32017-09-16 14:10:41 +0900415 pr_err("Cannot export environment: errno = %d\n", errno);
Marek Vasut7ce15262014-03-05 19:59:50 +0100416 return 1;
417 }
Marek Vasuta4223b72014-03-05 19:59:51 +0100418
Marek Vasut7ce15262014-03-05 19:59:50 +0100419 env_out->crc = crc32(0, env_out->data, ENV_SIZE);
420
Fiach Antaw76768f52017-01-25 18:53:11 +1000421#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
422 env_out->flags = ++env_flags; /* increase the serial */
423#endif
424
Marek Vasut7ce15262014-03-05 19:59:50 +0100425 return 0;
426}
427
Igor Grinberg27aafe92011-11-07 01:14:11 +0000428void env_relocate(void)
wdenk05706fd2002-09-28 17:48:27 +0000429{
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200430#if defined(CONFIG_NEEDS_MANUAL_RELOC)
Heiko Schocher60f7da12010-10-05 14:17:00 +0200431 env_reloc();
Siva Durga Prasad Paladugu7bcdf192018-04-13 07:57:21 +0200432 env_fix_drivers();
Tom Rinid90fc9c2019-10-04 12:21:33 -0400433 env_htab.change_ok += gd->reloc_off;
Heiko Schocher60f7da12010-10-05 14:17:00 +0200434#endif
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600435 if (gd->env_valid == ENV_INVALID) {
Ilya Yanok7ac2fe22012-09-18 00:22:50 +0000436#if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
437 /* Environment not changable */
Simon Glass0ac7d722019-08-01 09:47:00 -0600438 env_set_default(NULL, 0);
wdenk05706fd2002-09-28 17:48:27 +0000439#else
Simon Glass770605e2012-02-13 13:51:18 +0000440 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
Simon Glass0ac7d722019-08-01 09:47:00 -0600441 env_set_default("bad CRC", 0);
Lei Wend2590792010-10-10 12:36:40 +0800442#endif
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200443 } else {
Simon Glass310fb142017-08-03 12:22:07 -0600444 env_load();
wdenk05706fd2002-09-28 17:48:27 +0000445 }
wdenk05706fd2002-09-28 17:48:27 +0000446}
wdenk04a85b32004-04-15 18:22:41 +0000447
Boris Brezillon03dcf172018-12-05 09:26:50 +0100448#ifdef CONFIG_AUTO_COMPLETE
449int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
450 bool dollar_comp)
wdenk04a85b32004-04-15 18:22:41 +0000451{
Simon Glassdd2408c2019-08-02 09:44:18 -0600452 struct env_entry *match;
Mike Frysinger560d4242010-12-17 16:51:59 -0500453 int found, idx;
wdenk04a85b32004-04-15 18:22:41 +0000454
Boris Brezillon03dcf172018-12-05 09:26:50 +0100455 if (dollar_comp) {
456 /*
457 * When doing $ completion, the first character should
458 * obviously be a '$'.
459 */
460 if (var[0] != '$')
461 return 0;
462
463 var++;
464
465 /*
466 * The second one, if present, should be a '{', as some
467 * configuration of the u-boot shell expand ${var} but not
468 * $var.
469 */
470 if (var[0] == '{')
471 var++;
472 else if (var[0] != '\0')
473 return 0;
474 }
475
Mike Frysinger560d4242010-12-17 16:51:59 -0500476 idx = 0;
wdenk04a85b32004-04-15 18:22:41 +0000477 found = 0;
478 cmdv[0] = NULL;
479
Boris Brezillon03dcf172018-12-05 09:26:50 +0100480
Mike Frysinger560d4242010-12-17 16:51:59 -0500481 while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
482 int vallen = strlen(match->key) + 1;
wdenk04a85b32004-04-15 18:22:41 +0000483
Boris Brezillon03dcf172018-12-05 09:26:50 +0100484 if (found >= maxv - 2 ||
485 bufsz < vallen + (dollar_comp ? 3 : 0))
wdenk04a85b32004-04-15 18:22:41 +0000486 break;
Mike Frysinger560d4242010-12-17 16:51:59 -0500487
wdenk04a85b32004-04-15 18:22:41 +0000488 cmdv[found++] = buf;
Boris Brezillon03dcf172018-12-05 09:26:50 +0100489
490 /* Add the '${' prefix to each var when doing $ completion. */
491 if (dollar_comp) {
492 strcpy(buf, "${");
493 buf += 2;
494 bufsz -= 3;
495 }
496
Mike Frysinger560d4242010-12-17 16:51:59 -0500497 memcpy(buf, match->key, vallen);
498 buf += vallen;
499 bufsz -= vallen;
Boris Brezillon03dcf172018-12-05 09:26:50 +0100500
501 if (dollar_comp) {
502 /*
503 * This one is a bit odd: vallen already contains the
504 * '\0' character but we need to add the '}' suffix,
505 * hence the buf - 1 here. strcpy() will add the '\0'
506 * character just after '}'. buf is then incremented
507 * to account for the extra '}' we just added.
508 */
509 strcpy(buf - 1, "}");
510 buf++;
511 }
wdenk04a85b32004-04-15 18:22:41 +0000512 }
513
Mike Frysinger560d4242010-12-17 16:51:59 -0500514 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
515
516 if (idx)
Boris Brezillon03dcf172018-12-05 09:26:50 +0100517 cmdv[found++] = dollar_comp ? "${...}" : "...";
Igor Grinberg27aafe92011-11-07 01:14:11 +0000518
wdenk04a85b32004-04-15 18:22:41 +0000519 cmdv[found] = NULL;
520 return found;
521}
522#endif
Rasmus Villemoes95fd9772021-04-21 11:06:54 +0200523
524#ifdef CONFIG_ENV_IMPORT_FDT
525void env_import_fdt(void)
526{
527 const char *path;
528 struct ofprop prop;
529 ofnode node;
530 int res;
531
532 path = env_get("env_fdt_path");
533 if (!path || !path[0])
534 return;
535
536 node = ofnode_path(path);
537 if (!ofnode_valid(node)) {
538 printf("Warning: device tree node '%s' not found\n", path);
539 return;
540 }
541
Simon Glass4b1f5712022-09-06 20:27:13 -0600542 for (res = ofnode_first_property(node, &prop);
Rasmus Villemoes95fd9772021-04-21 11:06:54 +0200543 !res;
Simon Glass4b1f5712022-09-06 20:27:13 -0600544 res = ofnode_next_property(&prop)) {
Rasmus Villemoes95fd9772021-04-21 11:06:54 +0200545 const char *name, *val;
546
Simon Glass92432242022-09-06 20:27:14 -0600547 val = ofprop_get_property(&prop, &name, NULL);
Rasmus Villemoes95fd9772021-04-21 11:06:54 +0200548 env_set(name, val);
549 }
550}
551#endif