Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 2 | /* |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 3 | * (C) Copyright 2000-2010 |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 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> |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 8 | */ |
| 9 | |
| 10 | #include <common.h> |
| 11 | #include <command.h> |
| 12 | #include <environment.h> |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 13 | #include <linux/stddef.h> |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 14 | #include <search.h> |
| 15 | #include <errno.h> |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 16 | #include <malloc.h> |
| 17 | |
Wolfgang Denk | d87080b | 2006-03-31 18:32:53 +0200 | [diff] [blame] | 18 | DECLARE_GLOBAL_DATA_PTR; |
| 19 | |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 20 | /************************************************************************ |
| 21 | * Default settings to be used when no valid environment is found |
| 22 | */ |
Joe Hershberger | ddd8418 | 2012-10-12 08:48:51 +0000 | [diff] [blame] | 23 | #include <env_default.h> |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 24 | |
Gerlando Falauto | c598359 | 2012-08-24 00:11:39 +0000 | [diff] [blame] | 25 | struct hsearch_data env_htab = { |
Patrick Delaunay | 7d47765 | 2019-04-18 17:32:49 +0200 | [diff] [blame] | 26 | #if CONFIG_IS_ENABLED(ENV_SUPPORT) |
| 27 | /* defined in flags.c, only compile with ENV_SUPPORT */ |
Joe Hershberger | 2598090 | 2012-12-11 22:16:31 -0600 | [diff] [blame] | 28 | .change_ok = env_flags_validate, |
Patrick Delaunay | 7d47765 | 2019-04-18 17:32:49 +0200 | [diff] [blame] | 29 | #endif |
Gerlando Falauto | c598359 | 2012-08-24 00:11:39 +0000 | [diff] [blame] | 30 | }; |
Mike Frysinger | 2eb1573 | 2010-12-08 06:26:04 -0500 | [diff] [blame] | 31 | |
Joe Hershberger | ec8a252 | 2012-12-11 22:16:22 -0600 | [diff] [blame] | 32 | /* |
| 33 | * Read an environment variable as a boolean |
| 34 | * Return -1 if variable does not exist (default to true) |
| 35 | */ |
Simon Glass | bfebc8c | 2017-08-03 12:22:13 -0600 | [diff] [blame] | 36 | int env_get_yesno(const char *var) |
Joe Hershberger | ec8a252 | 2012-12-11 22:16:22 -0600 | [diff] [blame] | 37 | { |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 38 | char *s = env_get(var); |
Joe Hershberger | ec8a252 | 2012-12-11 22:16:22 -0600 | [diff] [blame] | 39 | |
| 40 | if (s == NULL) |
| 41 | return -1; |
| 42 | return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ? |
| 43 | 1 : 0; |
| 44 | } |
| 45 | |
Joe Hershberger | 267541f | 2012-12-11 22:16:34 -0600 | [diff] [blame] | 46 | /* |
| 47 | * Look up the variable from the default environment |
| 48 | */ |
Simon Glass | 723806c | 2017-08-03 12:22:15 -0600 | [diff] [blame] | 49 | char *env_get_default(const char *name) |
Joe Hershberger | 267541f | 2012-12-11 22:16:34 -0600 | [diff] [blame] | 50 | { |
| 51 | char *ret_val; |
| 52 | unsigned long really_valid = gd->env_valid; |
| 53 | unsigned long real_gd_flags = gd->flags; |
| 54 | |
| 55 | /* Pretend that the image is bad. */ |
| 56 | gd->flags &= ~GD_FLG_ENV_READY; |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 57 | gd->env_valid = ENV_INVALID; |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 58 | ret_val = env_get(name); |
Joe Hershberger | 267541f | 2012-12-11 22:16:34 -0600 | [diff] [blame] | 59 | gd->env_valid = really_valid; |
| 60 | gd->flags = real_gd_flags; |
| 61 | return ret_val; |
| 62 | } |
| 63 | |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 64 | void set_default_env(const char *s, int flags) |
Harald Welte | 5bb12db | 2008-07-07 15:40:39 +0800 | [diff] [blame] | 65 | { |
| 66 | if (sizeof(default_environment) > ENV_SIZE) { |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 67 | puts("*** Error - default environment is too large\n\n"); |
Harald Welte | 5bb12db | 2008-07-07 15:40:39 +0800 | [diff] [blame] | 68 | return; |
| 69 | } |
| 70 | |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 71 | if (s) { |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 72 | if ((flags & H_INTERACTIVE) == 0) { |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 73 | printf("*** Warning - %s, " |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 74 | "using default environment\n\n", s); |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 75 | } else { |
| 76 | puts(s); |
| 77 | } |
| 78 | } else { |
Maxime Ripard | 58ae999 | 2018-01-23 21:16:57 +0100 | [diff] [blame] | 79 | debug("Using default environment\n"); |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 80 | } |
| 81 | |
Mike Frysinger | 2eb1573 | 2010-12-08 06:26:04 -0500 | [diff] [blame] | 82 | if (himport_r(&env_htab, (char *)default_environment, |
Alexander Holler | ecd1446 | 2014-07-14 17:49:55 +0200 | [diff] [blame] | 83 | sizeof(default_environment), '\0', flags, 0, |
Joe Hershberger | c4e0057 | 2012-12-11 22:16:19 -0600 | [diff] [blame] | 84 | 0, NULL) == 0) |
Quentin Schulz | 6c90f62 | 2018-07-09 19:16:25 +0200 | [diff] [blame] | 85 | pr_err("## Error: Environment import failed: errno = %d\n", |
| 86 | errno); |
Igor Grinberg | 27aafe9 | 2011-11-07 01:14:11 +0000 | [diff] [blame] | 87 | |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 88 | gd->flags |= GD_FLG_ENV_READY; |
Michal Simek | 340b0e3 | 2016-05-30 16:06:54 +0200 | [diff] [blame] | 89 | gd->flags |= GD_FLG_ENV_DEFAULT; |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 90 | } |
| 91 | |
Gerlando Falauto | b64b7c3 | 2012-08-24 00:11:41 +0000 | [diff] [blame] | 92 | |
| 93 | /* [re]set individual variables to their value in the default environment */ |
Yaniv Levinsky | 477f811 | 2018-06-24 19:16:55 +0300 | [diff] [blame] | 94 | int set_default_vars(int nvars, char * const vars[], int flags) |
Gerlando Falauto | b64b7c3 | 2012-08-24 00:11:41 +0000 | [diff] [blame] | 95 | { |
| 96 | /* |
| 97 | * Special use-case: import from default environment |
| 98 | * (and use \0 as a separator) |
| 99 | */ |
Yaniv Levinsky | 5a04264 | 2018-06-24 19:16:56 +0300 | [diff] [blame] | 100 | flags |= H_NOCLEAR; |
Gerlando Falauto | b64b7c3 | 2012-08-24 00:11:41 +0000 | [diff] [blame] | 101 | return himport_r(&env_htab, (const char *)default_environment, |
Joe Hershberger | c4e0057 | 2012-12-11 22:16:19 -0600 | [diff] [blame] | 102 | sizeof(default_environment), '\0', |
Yaniv Levinsky | 477f811 | 2018-06-24 19:16:55 +0300 | [diff] [blame] | 103 | flags, 0, nvars, vars); |
Gerlando Falauto | b64b7c3 | 2012-08-24 00:11:41 +0000 | [diff] [blame] | 104 | } |
| 105 | |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 106 | /* |
| 107 | * Check if CRC is valid and (if yes) import the environment. |
| 108 | * Note that "buf" may or may not be aligned. |
| 109 | */ |
| 110 | int env_import(const char *buf, int check) |
| 111 | { |
| 112 | env_t *ep = (env_t *)buf; |
| 113 | |
| 114 | if (check) { |
| 115 | uint32_t crc; |
| 116 | |
| 117 | memcpy(&crc, &ep->crc, sizeof(crc)); |
| 118 | |
| 119 | if (crc32(0, ep->data, ENV_SIZE) != crc) { |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 120 | set_default_env("bad CRC", 0); |
Sam Protsenko | 49d04c5 | 2019-01-18 21:19:03 +0200 | [diff] [blame] | 121 | return -ENOMSG; /* needed for env_load() */ |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 122 | } |
| 123 | } |
| 124 | |
Alexander Holler | ecd1446 | 2014-07-14 17:49:55 +0200 | [diff] [blame] | 125 | if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, |
Joe Hershberger | c4e0057 | 2012-12-11 22:16:19 -0600 | [diff] [blame] | 126 | 0, NULL)) { |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 127 | gd->flags |= GD_FLG_ENV_READY; |
Simon Goldschmidt | 42a1820 | 2018-01-31 14:47:10 +0100 | [diff] [blame] | 128 | return 0; |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 129 | } |
| 130 | |
Masahiro Yamada | 9b643e3 | 2017-09-16 14:10:41 +0900 | [diff] [blame] | 131 | pr_err("Cannot import environment: errno = %d\n", errno); |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 132 | |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 133 | set_default_env("import failed", 0); |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 134 | |
Simon Goldschmidt | 42a1820 | 2018-01-31 14:47:10 +0100 | [diff] [blame] | 135 | return -EIO; |
Harald Welte | 5bb12db | 2008-07-07 15:40:39 +0800 | [diff] [blame] | 136 | } |
| 137 | |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 138 | #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT |
| 139 | static unsigned char env_flags; |
| 140 | |
Simon Goldschmidt | 31f044b | 2018-01-31 14:47:11 +0100 | [diff] [blame] | 141 | int env_import_redund(const char *buf1, int buf1_read_fail, |
| 142 | const char *buf2, int buf2_read_fail) |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 143 | { |
| 144 | int crc1_ok, crc2_ok; |
| 145 | env_t *ep, *tmp_env1, *tmp_env2; |
| 146 | |
| 147 | tmp_env1 = (env_t *)buf1; |
| 148 | tmp_env2 = (env_t *)buf2; |
| 149 | |
Simon Goldschmidt | 31f044b | 2018-01-31 14:47:11 +0100 | [diff] [blame] | 150 | if (buf1_read_fail && buf2_read_fail) { |
| 151 | puts("*** Error - No Valid Environment Area found\n"); |
| 152 | } else if (buf1_read_fail || buf2_read_fail) { |
| 153 | puts("*** Warning - some problems detected "); |
| 154 | puts("reading environment; recovered successfully\n"); |
| 155 | } |
| 156 | |
| 157 | if (buf1_read_fail && buf2_read_fail) { |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 158 | set_default_env("bad env area", 0); |
Simon Goldschmidt | 31f044b | 2018-01-31 14:47:11 +0100 | [diff] [blame] | 159 | return -EIO; |
| 160 | } else if (!buf1_read_fail && buf2_read_fail) { |
| 161 | gd->env_valid = ENV_VALID; |
| 162 | return env_import((char *)tmp_env1, 1); |
| 163 | } else if (buf1_read_fail && !buf2_read_fail) { |
| 164 | gd->env_valid = ENV_REDUND; |
| 165 | return env_import((char *)tmp_env2, 1); |
| 166 | } |
| 167 | |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 168 | crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == |
| 169 | tmp_env1->crc; |
| 170 | crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == |
| 171 | tmp_env2->crc; |
| 172 | |
| 173 | if (!crc1_ok && !crc2_ok) { |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 174 | set_default_env("bad CRC", 0); |
Sam Protsenko | 49d04c5 | 2019-01-18 21:19:03 +0200 | [diff] [blame] | 175 | return -ENOMSG; /* needed for env_load() */ |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 176 | } else if (crc1_ok && !crc2_ok) { |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 177 | gd->env_valid = ENV_VALID; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 178 | } else if (!crc1_ok && crc2_ok) { |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 179 | gd->env_valid = ENV_REDUND; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 180 | } else { |
| 181 | /* both ok - check serial */ |
| 182 | if (tmp_env1->flags == 255 && tmp_env2->flags == 0) |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 183 | gd->env_valid = ENV_REDUND; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 184 | else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 185 | gd->env_valid = ENV_VALID; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 186 | else if (tmp_env1->flags > tmp_env2->flags) |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 187 | gd->env_valid = ENV_VALID; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 188 | else if (tmp_env2->flags > tmp_env1->flags) |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 189 | gd->env_valid = ENV_REDUND; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 190 | else /* flags are equal - almost impossible */ |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 191 | gd->env_valid = ENV_VALID; |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 192 | } |
| 193 | |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 194 | if (gd->env_valid == ENV_VALID) |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 195 | ep = tmp_env1; |
| 196 | else |
| 197 | ep = tmp_env2; |
| 198 | |
| 199 | env_flags = ep->flags; |
| 200 | return env_import((char *)ep, 0); |
| 201 | } |
| 202 | #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */ |
| 203 | |
Robert P. J. Day | fc0b594 | 2016-09-07 14:27:59 -0400 | [diff] [blame] | 204 | /* Export the environment and generate CRC for it. */ |
Marek Vasut | 7ce1526 | 2014-03-05 19:59:50 +0100 | [diff] [blame] | 205 | int env_export(env_t *env_out) |
| 206 | { |
| 207 | char *res; |
| 208 | ssize_t len; |
| 209 | |
| 210 | res = (char *)env_out->data; |
| 211 | len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL); |
| 212 | if (len < 0) { |
Masahiro Yamada | 9b643e3 | 2017-09-16 14:10:41 +0900 | [diff] [blame] | 213 | pr_err("Cannot export environment: errno = %d\n", errno); |
Marek Vasut | 7ce1526 | 2014-03-05 19:59:50 +0100 | [diff] [blame] | 214 | return 1; |
| 215 | } |
Marek Vasut | a4223b7 | 2014-03-05 19:59:51 +0100 | [diff] [blame] | 216 | |
Marek Vasut | 7ce1526 | 2014-03-05 19:59:50 +0100 | [diff] [blame] | 217 | env_out->crc = crc32(0, env_out->data, ENV_SIZE); |
| 218 | |
Fiach Antaw | 76768f5 | 2017-01-25 18:53:11 +1000 | [diff] [blame] | 219 | #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT |
| 220 | env_out->flags = ++env_flags; /* increase the serial */ |
| 221 | #endif |
| 222 | |
Marek Vasut | 7ce1526 | 2014-03-05 19:59:50 +0100 | [diff] [blame] | 223 | return 0; |
| 224 | } |
| 225 | |
Igor Grinberg | 27aafe9 | 2011-11-07 01:14:11 +0000 | [diff] [blame] | 226 | void env_relocate(void) |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 227 | { |
Wolfgang Denk | 2e5167c | 2010-10-28 20:00:11 +0200 | [diff] [blame] | 228 | #if defined(CONFIG_NEEDS_MANUAL_RELOC) |
Heiko Schocher | 60f7da1 | 2010-10-05 14:17:00 +0200 | [diff] [blame] | 229 | env_reloc(); |
Siva Durga Prasad Paladugu | 7bcdf19 | 2018-04-13 07:57:21 +0200 | [diff] [blame] | 230 | env_fix_drivers(); |
Patrick Delaunay | 7d47765 | 2019-04-18 17:32:49 +0200 | [diff] [blame] | 231 | |
| 232 | if (env_htab.change_ok) |
| 233 | env_htab.change_ok += gd->reloc_off; |
Heiko Schocher | 60f7da1 | 2010-10-05 14:17:00 +0200 | [diff] [blame] | 234 | #endif |
Simon Glass | 2d7cb5b | 2017-08-20 04:45:15 -0600 | [diff] [blame] | 235 | if (gd->env_valid == ENV_INVALID) { |
Ilya Yanok | 7ac2fe2 | 2012-09-18 00:22:50 +0000 | [diff] [blame] | 236 | #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD) |
| 237 | /* Environment not changable */ |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 238 | set_default_env(NULL, 0); |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 239 | #else |
Simon Glass | 770605e | 2012-02-13 13:51:18 +0000 | [diff] [blame] | 240 | bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 241 | set_default_env("bad CRC", 0); |
Lei Wen | d259079 | 2010-10-10 12:36:40 +0800 | [diff] [blame] | 242 | #endif |
Wolfgang Denk | ea882ba | 2010-06-20 23:33:59 +0200 | [diff] [blame] | 243 | } else { |
Simon Glass | 310fb14 | 2017-08-03 12:22:07 -0600 | [diff] [blame] | 244 | env_load(); |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 245 | } |
wdenk | 05706fd | 2002-09-28 17:48:27 +0000 | [diff] [blame] | 246 | } |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 247 | |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 248 | #ifdef CONFIG_AUTO_COMPLETE |
| 249 | int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf, |
| 250 | bool dollar_comp) |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 251 | { |
Mike Frysinger | 560d424 | 2010-12-17 16:51:59 -0500 | [diff] [blame] | 252 | ENTRY *match; |
| 253 | int found, idx; |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 254 | |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 255 | if (dollar_comp) { |
| 256 | /* |
| 257 | * When doing $ completion, the first character should |
| 258 | * obviously be a '$'. |
| 259 | */ |
| 260 | if (var[0] != '$') |
| 261 | return 0; |
| 262 | |
| 263 | var++; |
| 264 | |
| 265 | /* |
| 266 | * The second one, if present, should be a '{', as some |
| 267 | * configuration of the u-boot shell expand ${var} but not |
| 268 | * $var. |
| 269 | */ |
| 270 | if (var[0] == '{') |
| 271 | var++; |
| 272 | else if (var[0] != '\0') |
| 273 | return 0; |
| 274 | } |
| 275 | |
Mike Frysinger | 560d424 | 2010-12-17 16:51:59 -0500 | [diff] [blame] | 276 | idx = 0; |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 277 | found = 0; |
| 278 | cmdv[0] = NULL; |
| 279 | |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 280 | |
Mike Frysinger | 560d424 | 2010-12-17 16:51:59 -0500 | [diff] [blame] | 281 | while ((idx = hmatch_r(var, idx, &match, &env_htab))) { |
| 282 | int vallen = strlen(match->key) + 1; |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 283 | |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 284 | if (found >= maxv - 2 || |
| 285 | bufsz < vallen + (dollar_comp ? 3 : 0)) |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 286 | break; |
Mike Frysinger | 560d424 | 2010-12-17 16:51:59 -0500 | [diff] [blame] | 287 | |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 288 | cmdv[found++] = buf; |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 289 | |
| 290 | /* Add the '${' prefix to each var when doing $ completion. */ |
| 291 | if (dollar_comp) { |
| 292 | strcpy(buf, "${"); |
| 293 | buf += 2; |
| 294 | bufsz -= 3; |
| 295 | } |
| 296 | |
Mike Frysinger | 560d424 | 2010-12-17 16:51:59 -0500 | [diff] [blame] | 297 | memcpy(buf, match->key, vallen); |
| 298 | buf += vallen; |
| 299 | bufsz -= vallen; |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 300 | |
| 301 | if (dollar_comp) { |
| 302 | /* |
| 303 | * This one is a bit odd: vallen already contains the |
| 304 | * '\0' character but we need to add the '}' suffix, |
| 305 | * hence the buf - 1 here. strcpy() will add the '\0' |
| 306 | * character just after '}'. buf is then incremented |
| 307 | * to account for the extra '}' we just added. |
| 308 | */ |
| 309 | strcpy(buf - 1, "}"); |
| 310 | buf++; |
| 311 | } |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 312 | } |
| 313 | |
Mike Frysinger | 560d424 | 2010-12-17 16:51:59 -0500 | [diff] [blame] | 314 | qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar); |
| 315 | |
| 316 | if (idx) |
Boris Brezillon | 03dcf17 | 2018-12-05 09:26:50 +0100 | [diff] [blame] | 317 | cmdv[found++] = dollar_comp ? "${...}" : "..."; |
Igor Grinberg | 27aafe9 | 2011-11-07 01:14:11 +0000 | [diff] [blame] | 318 | |
wdenk | 04a85b3 | 2004-04-15 18:22:41 +0000 | [diff] [blame] | 319 | cmdv[found] = NULL; |
| 320 | return found; |
| 321 | } |
| 322 | #endif |