blob: c11fb3123615b5834837854dd60ce2c1c32b206c [file] [log] [blame]
Simon Glass66ded172014-04-10 20:01:28 -06001/*
2 * (C) Copyright 2000
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8#include <common.h>
Jeroen Hofstee39e12302014-07-13 22:57:58 +02009#include <autoboot.h>
Simon Glass0098e172014-04-10 20:01:30 -060010#include <bootretry.h>
Simon Glass66ded172014-04-10 20:01:28 -060011#include <cli.h>
Simon Glass24b852a2015-11-08 23:47:45 -070012#include <console.h>
Simon Glass66ded172014-04-10 20:01:28 -060013#include <fdtdec.h>
14#include <menu.h>
15#include <post.h>
Stefan Roese8f0b1e22015-05-18 14:08:24 +020016#include <u-boot/sha256.h>
Simon Glass66ded172014-04-10 20:01:28 -060017
18DECLARE_GLOBAL_DATA_PTR;
19
20#define MAX_DELAY_STOP_STR 32
21
22#ifndef DEBUG_BOOTKEYS
23#define DEBUG_BOOTKEYS 0
24#endif
25#define debug_bootkeys(fmt, args...) \
26 debug_cond(DEBUG_BOOTKEYS, fmt, ##args)
27
Simon Glassaffb2152014-04-10 20:01:35 -060028/* Stored value of bootdelay, used by autoboot_command() */
29static int stored_bootdelay;
30
Stefan Roese8f0b1e22015-05-18 14:08:24 +020031#if defined(CONFIG_AUTOBOOT_KEYED)
32#if defined(CONFIG_AUTOBOOT_STOP_STR_SHA256)
33
34/*
35 * Use a "constant-length" time compare function for this
36 * hash compare:
37 *
38 * https://crackstation.net/hashing-security.htm
Simon Glass66ded172014-04-10 20:01:28 -060039 */
Stefan Roese8f0b1e22015-05-18 14:08:24 +020040static int slow_equals(u8 *a, u8 *b, int len)
41{
42 int diff = 0;
43 int i;
44
45 for (i = 0; i < len; i++)
46 diff |= a[i] ^ b[i];
47
48 return diff == 0;
49}
50
51static int passwd_abort(uint64_t etime)
52{
53 const char *sha_env_str = getenv("bootstopkeysha256");
54 u8 sha_env[SHA256_SUM_LEN];
55 u8 sha[SHA256_SUM_LEN];
56 char presskey[MAX_DELAY_STOP_STR];
57 const char *algo_name = "sha256";
58 u_int presskey_len = 0;
59 int abort = 0;
60 int size;
61 int ret;
62
63 if (sha_env_str == NULL)
64 sha_env_str = CONFIG_AUTOBOOT_STOP_STR_SHA256;
65
66 /*
67 * Generate the binary value from the environment hash value
68 * so that we can compare this value with the computed hash
69 * from the user input
70 */
71 ret = hash_parse_string(algo_name, sha_env_str, sha_env);
72 if (ret) {
73 printf("Hash %s not supported!\n", algo_name);
74 return 0;
75 }
76
77 /*
78 * We don't know how long the stop-string is, so we need to
79 * generate the sha256 hash upon each input character and
80 * compare the value with the one saved in the environment
81 */
82 do {
83 if (tstc()) {
84 /* Check for input string overflow */
85 if (presskey_len >= MAX_DELAY_STOP_STR)
86 return 0;
87
88 presskey[presskey_len++] = getc();
89
90 /* Calculate sha256 upon each new char */
91 hash_block(algo_name, (const void *)presskey,
92 presskey_len, sha, &size);
93
94 /* And check if sha matches saved value in env */
95 if (slow_equals(sha, sha_env, SHA256_SUM_LEN))
96 abort = 1;
97 }
98 } while (!abort && get_ticks() <= etime);
99
100 return abort;
101}
102#else
103static int passwd_abort(uint64_t etime)
Simon Glass66ded172014-04-10 20:01:28 -0600104{
105 int abort = 0;
Simon Glass66ded172014-04-10 20:01:28 -0600106 struct {
107 char *str;
108 u_int len;
109 int retry;
110 }
111 delaykey[] = {
Jeroen Hofstee9e546ee2014-06-16 00:17:33 +0200112 { .str = getenv("bootdelaykey"), .retry = 1 },
Jeroen Hofstee9e546ee2014-06-16 00:17:33 +0200113 { .str = getenv("bootstopkey"), .retry = 0 },
Simon Glass66ded172014-04-10 20:01:28 -0600114 };
115
116 char presskey[MAX_DELAY_STOP_STR];
117 u_int presskey_len = 0;
118 u_int presskey_max = 0;
119 u_int i;
120
Simon Glass66ded172014-04-10 20:01:28 -0600121# ifdef CONFIG_AUTOBOOT_DELAY_STR
122 if (delaykey[0].str == NULL)
123 delaykey[0].str = CONFIG_AUTOBOOT_DELAY_STR;
124# endif
Simon Glass66ded172014-04-10 20:01:28 -0600125# ifdef CONFIG_AUTOBOOT_STOP_STR
Stefan Roese2d908fa2015-05-18 14:08:22 +0200126 if (delaykey[1].str == NULL)
127 delaykey[1].str = CONFIG_AUTOBOOT_STOP_STR;
Simon Glass66ded172014-04-10 20:01:28 -0600128# endif
129
130 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i++) {
131 delaykey[i].len = delaykey[i].str == NULL ?
132 0 : strlen(delaykey[i].str);
133 delaykey[i].len = delaykey[i].len > MAX_DELAY_STOP_STR ?
134 MAX_DELAY_STOP_STR : delaykey[i].len;
135
136 presskey_max = presskey_max > delaykey[i].len ?
137 presskey_max : delaykey[i].len;
138
139 debug_bootkeys("%s key:<%s>\n",
140 delaykey[i].retry ? "delay" : "stop",
141 delaykey[i].str ? delaykey[i].str : "NULL");
142 }
143
144 /* In order to keep up with incoming data, check timeout only
145 * when catch up.
146 */
147 do {
148 if (tstc()) {
149 if (presskey_len < presskey_max) {
150 presskey[presskey_len++] = getc();
151 } else {
152 for (i = 0; i < presskey_max - 1; i++)
153 presskey[i] = presskey[i + 1];
154
155 presskey[i] = getc();
156 }
157 }
158
159 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i++) {
160 if (delaykey[i].len > 0 &&
161 presskey_len >= delaykey[i].len &&
162 memcmp(presskey + presskey_len -
163 delaykey[i].len, delaykey[i].str,
164 delaykey[i].len) == 0) {
165 debug_bootkeys("got %skey\n",
166 delaykey[i].retry ? "delay" :
167 "stop");
168
Simon Glass66ded172014-04-10 20:01:28 -0600169 /* don't retry auto boot */
170 if (!delaykey[i].retry)
171 bootretry_dont_retry();
Simon Glass66ded172014-04-10 20:01:28 -0600172 abort = 1;
173 }
174 }
175 } while (!abort && get_ticks() <= etime);
176
Stefan Roese8f0b1e22015-05-18 14:08:24 +0200177 return abort;
178}
179#endif
180
181/***************************************************************************
182 * Watch for 'delay' seconds for autoboot stop or autoboot delay string.
183 * returns: 0 - no key string, allow autoboot 1 - got key string, abort
184 */
185static int abortboot_keyed(int bootdelay)
186{
187 int abort;
188 uint64_t etime = endtick(bootdelay);
189
190#ifndef CONFIG_ZERO_BOOTDELAY_CHECK
191 if (bootdelay == 0)
192 return 0;
193#endif
194
195# ifdef CONFIG_AUTOBOOT_PROMPT
196 /*
197 * CONFIG_AUTOBOOT_PROMPT includes the %d for all boards.
198 * To print the bootdelay value upon bootup.
199 */
200 printf(CONFIG_AUTOBOOT_PROMPT, bootdelay);
201# endif
202
203 abort = passwd_abort(etime);
Simon Glass66ded172014-04-10 20:01:28 -0600204 if (!abort)
205 debug_bootkeys("key timeout\n");
206
207#ifdef CONFIG_SILENT_CONSOLE
208 if (abort)
209 gd->flags &= ~GD_FLG_SILENT;
210#endif
211
212 return abort;
213}
214
215# else /* !defined(CONFIG_AUTOBOOT_KEYED) */
216
217#ifdef CONFIG_MENUKEY
218static int menukey;
219#endif
220
221static int abortboot_normal(int bootdelay)
222{
223 int abort = 0;
224 unsigned long ts;
225
226#ifdef CONFIG_MENUPROMPT
227 printf(CONFIG_MENUPROMPT);
228#else
229 if (bootdelay >= 0)
230 printf("Hit any key to stop autoboot: %2d ", bootdelay);
231#endif
232
233#if defined CONFIG_ZERO_BOOTDELAY_CHECK
234 /*
235 * Check if key already pressed
236 * Don't check if bootdelay < 0
237 */
238 if (bootdelay >= 0) {
239 if (tstc()) { /* we got a key press */
240 (void) getc(); /* consume input */
241 puts("\b\b\b 0");
242 abort = 1; /* don't auto boot */
243 }
244 }
245#endif
246
247 while ((bootdelay > 0) && (!abort)) {
248 --bootdelay;
249 /* delay 1000 ms */
250 ts = get_timer(0);
251 do {
252 if (tstc()) { /* we got a key press */
253 abort = 1; /* don't auto boot */
254 bootdelay = 0; /* no more delay */
255# ifdef CONFIG_MENUKEY
256 menukey = getc();
257# else
258 (void) getc(); /* consume input */
259# endif
260 break;
261 }
262 udelay(10000);
263 } while (!abort && get_timer(ts) < 1000);
264
265 printf("\b\b\b%2d ", bootdelay);
266 }
267
268 putc('\n');
269
270#ifdef CONFIG_SILENT_CONSOLE
271 if (abort)
272 gd->flags &= ~GD_FLG_SILENT;
273#endif
274
275 return abort;
276}
277# endif /* CONFIG_AUTOBOOT_KEYED */
278
279static int abortboot(int bootdelay)
280{
281#ifdef CONFIG_AUTOBOOT_KEYED
282 return abortboot_keyed(bootdelay);
283#else
284 return abortboot_normal(bootdelay);
285#endif
286}
287
Simon Glass66ded172014-04-10 20:01:28 -0600288static void process_fdt_options(const void *blob)
289{
Simon Glassaffb2152014-04-10 20:01:35 -0600290#if defined(CONFIG_OF_CONTROL)
Simon Glass66ded172014-04-10 20:01:28 -0600291 ulong addr;
292
293 /* Add an env variable to point to a kernel payload, if available */
294 addr = fdtdec_get_config_int(gd->fdt_blob, "kernel-offset", 0);
295 if (addr)
296 setenv_addr("kernaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
297
298 /* Add an env variable to point to a root disk, if available */
299 addr = fdtdec_get_config_int(gd->fdt_blob, "rootdisk-offset", 0);
300 if (addr)
301 setenv_addr("rootaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
Simon Glass66ded172014-04-10 20:01:28 -0600302#endif /* CONFIG_OF_CONTROL */
Simon Glassaffb2152014-04-10 20:01:35 -0600303}
Simon Glass66ded172014-04-10 20:01:28 -0600304
Simon Glassaffb2152014-04-10 20:01:35 -0600305const char *bootdelay_process(void)
Simon Glass66ded172014-04-10 20:01:28 -0600306{
Simon Glass66ded172014-04-10 20:01:28 -0600307 char *s;
308 int bootdelay;
309#ifdef CONFIG_BOOTCOUNT_LIMIT
310 unsigned long bootcount = 0;
311 unsigned long bootlimit = 0;
312#endif /* CONFIG_BOOTCOUNT_LIMIT */
313
314#ifdef CONFIG_BOOTCOUNT_LIMIT
315 bootcount = bootcount_load();
316 bootcount++;
317 bootcount_store(bootcount);
318 setenv_ulong("bootcount", bootcount);
319 bootlimit = getenv_ulong("bootlimit", 10, 0);
320#endif /* CONFIG_BOOTCOUNT_LIMIT */
321
322 s = getenv("bootdelay");
323 bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
324
325#ifdef CONFIG_OF_CONTROL
326 bootdelay = fdtdec_get_config_int(gd->fdt_blob, "bootdelay",
327 bootdelay);
328#endif
329
330 debug("### main_loop entered: bootdelay=%d\n\n", bootdelay);
331
332#if defined(CONFIG_MENU_SHOW)
333 bootdelay = menu_show(bootdelay);
334#endif
Simon Glassb26440f2014-04-10 20:01:31 -0600335 bootretry_init_cmd_timeout();
Simon Glass66ded172014-04-10 20:01:28 -0600336
337#ifdef CONFIG_POST
338 if (gd->flags & GD_FLG_POSTFAIL) {
339 s = getenv("failbootcmd");
340 } else
341#endif /* CONFIG_POST */
342#ifdef CONFIG_BOOTCOUNT_LIMIT
343 if (bootlimit && (bootcount > bootlimit)) {
344 printf("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\n",
345 (unsigned)bootlimit);
346 s = getenv("altbootcmd");
347 } else
348#endif /* CONFIG_BOOTCOUNT_LIMIT */
349 s = getenv("bootcmd");
Simon Glass66ded172014-04-10 20:01:28 -0600350
351 process_fdt_options(gd->fdt_blob);
Simon Glassaffb2152014-04-10 20:01:35 -0600352 stored_bootdelay = bootdelay;
Simon Glass66ded172014-04-10 20:01:28 -0600353
Simon Glassaffb2152014-04-10 20:01:35 -0600354 return s;
355}
Simon Glass66ded172014-04-10 20:01:28 -0600356
Simon Glassaffb2152014-04-10 20:01:35 -0600357void autoboot_command(const char *s)
358{
Simon Glass66ded172014-04-10 20:01:28 -0600359 debug("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
360
Simon Glassaffb2152014-04-10 20:01:35 -0600361 if (stored_bootdelay != -1 && s && !abortboot(stored_bootdelay)) {
Simon Glass66ded172014-04-10 20:01:28 -0600362#if defined(CONFIG_AUTOBOOT_KEYED) && !defined(CONFIG_AUTOBOOT_KEYED_CTRLC)
363 int prev = disable_ctrlc(1); /* disable Control C checking */
364#endif
365
366 run_command_list(s, -1, 0);
367
368#if defined(CONFIG_AUTOBOOT_KEYED) && !defined(CONFIG_AUTOBOOT_KEYED_CTRLC)
369 disable_ctrlc(prev); /* restore Control C checking */
370#endif
371 }
372
373#ifdef CONFIG_MENUKEY
374 if (menukey == CONFIG_MENUKEY) {
375 s = getenv("menucmd");
376 if (s)
377 run_command_list(s, -1, 0);
378 }
379#endif /* CONFIG_MENUKEY */
380}