env: common: Drop env_get_addr()
[platform/kernel/u-boot.git] / env / common.c
1 /*
2  * (C) Copyright 2000-2010
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
6  * Andreas Heppel <aheppel@sysgo.de>
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10
11 #include <common.h>
12 #include <command.h>
13 #include <environment.h>
14 #include <linux/stddef.h>
15 #include <search.h>
16 #include <errno.h>
17 #include <malloc.h>
18
19 DECLARE_GLOBAL_DATA_PTR;
20
21 /************************************************************************
22  * Default settings to be used when no valid environment is found
23  */
24 #include <env_default.h>
25
26 struct hsearch_data env_htab = {
27         .change_ok = env_flags_validate,
28 };
29
30 __weak uchar env_get_char_spec(int index)
31 {
32         return *((uchar *)(gd->env_addr + index));
33 }
34
35 static uchar env_get_char_init(int index)
36 {
37         /* if crc was bad, use the default environment */
38         if (gd->env_valid)
39                 return env_get_char_spec(index);
40         else
41                 return default_environment[index];
42 }
43
44 static uchar env_get_char_memory(int index)
45 {
46         if (gd->env_valid)
47                 return *(uchar *)(gd->env_addr + index);
48         else
49                 return default_environment[index];
50 }
51
52 uchar env_get_char(int index)
53 {
54         /* if relocated to RAM */
55         if (gd->flags & GD_FLG_RELOC)
56                 return env_get_char_memory(index);
57         else
58                 return env_get_char_init(index);
59 }
60
61 /*
62  * Read an environment variable as a boolean
63  * Return -1 if variable does not exist (default to true)
64  */
65 int getenv_yesno(const char *var)
66 {
67         char *s = getenv(var);
68
69         if (s == NULL)
70                 return -1;
71         return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
72                 1 : 0;
73 }
74
75 /*
76  * Look up the variable from the default environment
77  */
78 char *getenv_default(const char *name)
79 {
80         char *ret_val;
81         unsigned long really_valid = gd->env_valid;
82         unsigned long real_gd_flags = gd->flags;
83
84         /* Pretend that the image is bad. */
85         gd->flags &= ~GD_FLG_ENV_READY;
86         gd->env_valid = 0;
87         ret_val = getenv(name);
88         gd->env_valid = really_valid;
89         gd->flags = real_gd_flags;
90         return ret_val;
91 }
92
93 void set_default_env(const char *s)
94 {
95         int flags = 0;
96
97         if (sizeof(default_environment) > ENV_SIZE) {
98                 puts("*** Error - default environment is too large\n\n");
99                 return;
100         }
101
102         if (s) {
103                 if (*s == '!') {
104                         printf("*** Warning - %s, "
105                                 "using default environment\n\n",
106                                 s + 1);
107                 } else {
108                         flags = H_INTERACTIVE;
109                         puts(s);
110                 }
111         } else {
112                 puts("Using default environment\n\n");
113         }
114
115         if (himport_r(&env_htab, (char *)default_environment,
116                         sizeof(default_environment), '\0', flags, 0,
117                         0, NULL) == 0)
118                 error("Environment import failed: errno = %d\n", errno);
119
120         gd->flags |= GD_FLG_ENV_READY;
121         gd->flags |= GD_FLG_ENV_DEFAULT;
122 }
123
124
125 /* [re]set individual variables to their value in the default environment */
126 int set_default_vars(int nvars, char * const vars[])
127 {
128         /*
129          * Special use-case: import from default environment
130          * (and use \0 as a separator)
131          */
132         return himport_r(&env_htab, (const char *)default_environment,
133                                 sizeof(default_environment), '\0',
134                                 H_NOCLEAR | H_INTERACTIVE, 0, nvars, vars);
135 }
136
137 #ifdef CONFIG_ENV_AES
138 #include <uboot_aes.h>
139 /**
140  * env_aes_cbc_get_key() - Get AES-128-CBC key for the environment
141  *
142  * This function shall return 16-byte array containing AES-128 key used
143  * to encrypt and decrypt the environment. This function must be overridden
144  * by the implementer as otherwise the environment encryption will not
145  * work.
146  */
147 __weak uint8_t *env_aes_cbc_get_key(void)
148 {
149         return NULL;
150 }
151
152 static int env_aes_cbc_crypt(env_t *env, const int enc)
153 {
154         unsigned char *data = env->data;
155         uint8_t *key;
156         uint8_t key_exp[AES_EXPAND_KEY_LENGTH];
157         uint32_t aes_blocks;
158
159         key = env_aes_cbc_get_key();
160         if (!key)
161                 return -EINVAL;
162
163         /* First we expand the key. */
164         aes_expand_key(key, key_exp);
165
166         /* Calculate the number of AES blocks to encrypt. */
167         aes_blocks = ENV_SIZE / AES_KEY_LENGTH;
168
169         if (enc)
170                 aes_cbc_encrypt_blocks(key_exp, data, data, aes_blocks);
171         else
172                 aes_cbc_decrypt_blocks(key_exp, data, data, aes_blocks);
173
174         return 0;
175 }
176 #else
177 static inline int env_aes_cbc_crypt(env_t *env, const int enc)
178 {
179         return 0;
180 }
181 #endif
182
183 /*
184  * Check if CRC is valid and (if yes) import the environment.
185  * Note that "buf" may or may not be aligned.
186  */
187 int env_import(const char *buf, int check)
188 {
189         env_t *ep = (env_t *)buf;
190         int ret;
191
192         if (check) {
193                 uint32_t crc;
194
195                 memcpy(&crc, &ep->crc, sizeof(crc));
196
197                 if (crc32(0, ep->data, ENV_SIZE) != crc) {
198                         set_default_env("!bad CRC");
199                         return 0;
200                 }
201         }
202
203         /* Decrypt the env if desired. */
204         ret = env_aes_cbc_crypt(ep, 0);
205         if (ret) {
206                 error("Failed to decrypt env!\n");
207                 set_default_env("!import failed");
208                 return ret;
209         }
210
211         if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0,
212                         0, NULL)) {
213                 gd->flags |= GD_FLG_ENV_READY;
214                 return 1;
215         }
216
217         error("Cannot import environment: errno = %d\n", errno);
218
219         set_default_env("!import failed");
220
221         return 0;
222 }
223
224 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
225 static unsigned char env_flags;
226
227 int env_import_redund(const char *buf1, const char *buf2)
228 {
229         int crc1_ok, crc2_ok;
230         env_t *ep, *tmp_env1, *tmp_env2;
231
232         tmp_env1 = (env_t *)buf1;
233         tmp_env2 = (env_t *)buf2;
234
235         crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
236                         tmp_env1->crc;
237         crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
238                         tmp_env2->crc;
239
240         if (!crc1_ok && !crc2_ok) {
241                 set_default_env("!bad CRC");
242                 return 0;
243         } else if (crc1_ok && !crc2_ok) {
244                 gd->env_valid = 1;
245         } else if (!crc1_ok && crc2_ok) {
246                 gd->env_valid = 2;
247         } else {
248                 /* both ok - check serial */
249                 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
250                         gd->env_valid = 2;
251                 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
252                         gd->env_valid = 1;
253                 else if (tmp_env1->flags > tmp_env2->flags)
254                         gd->env_valid = 1;
255                 else if (tmp_env2->flags > tmp_env1->flags)
256                         gd->env_valid = 2;
257                 else /* flags are equal - almost impossible */
258                         gd->env_valid = 1;
259         }
260
261         if (gd->env_valid == 1)
262                 ep = tmp_env1;
263         else
264                 ep = tmp_env2;
265
266         env_flags = ep->flags;
267         return env_import((char *)ep, 0);
268 }
269 #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
270
271 /* Export the environment and generate CRC for it. */
272 int env_export(env_t *env_out)
273 {
274         char *res;
275         ssize_t len;
276         int ret;
277
278         res = (char *)env_out->data;
279         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
280         if (len < 0) {
281                 error("Cannot export environment: errno = %d\n", errno);
282                 return 1;
283         }
284
285         /* Encrypt the env if desired. */
286         ret = env_aes_cbc_crypt(env_out, 1);
287         if (ret)
288                 return ret;
289
290         env_out->crc = crc32(0, env_out->data, ENV_SIZE);
291
292 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
293         env_out->flags = ++env_flags; /* increase the serial */
294 #endif
295
296         return 0;
297 }
298
299 void env_relocate(void)
300 {
301 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
302         env_reloc();
303         env_htab.change_ok += gd->reloc_off;
304 #endif
305         if (gd->env_valid == 0) {
306 #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
307                 /* Environment not changable */
308                 set_default_env(NULL);
309 #else
310                 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
311                 set_default_env("!bad CRC");
312 #endif
313         } else {
314                 env_relocate_spec();
315         }
316 }
317
318 #if defined(CONFIG_AUTO_COMPLETE) && !defined(CONFIG_SPL_BUILD)
319 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
320 {
321         ENTRY *match;
322         int found, idx;
323
324         idx = 0;
325         found = 0;
326         cmdv[0] = NULL;
327
328         while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
329                 int vallen = strlen(match->key) + 1;
330
331                 if (found >= maxv - 2 || bufsz < vallen)
332                         break;
333
334                 cmdv[found++] = buf;
335                 memcpy(buf, match->key, vallen);
336                 buf += vallen;
337                 bufsz -= vallen;
338         }
339
340         qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
341
342         if (idx)
343                 cmdv[found++] = "...";
344
345         cmdv[found] = NULL;
346         return found;
347 }
348 #endif