]> git.ipfire.org Git - people/ms/u-boot.git/blob - common/main.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fdt: Correct global_data condition in main
[people/ms/u-boot.git] / common / main.c
1 /*
2 * (C) Copyright 2000
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * Add to readline cmdline-editing by
6 * (C) Copyright 2005
7 * JinHua Luo, GuangDong Linux Center, <luo.jinhua@gd-linux.com>
8 *
9 * See file CREDITS for list of people who contributed to this
10 * project.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation; either version 2 of
15 * the License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25 * MA 02111-1307 USA
26 */
27
28 /* #define DEBUG */
29
30 #include <common.h>
31 #include <watchdog.h>
32 #include <command.h>
33 #include <fdtdec.h>
34 #include <malloc.h>
35 #include <version.h>
36 #ifdef CONFIG_MODEM_SUPPORT
37 #include <malloc.h> /* for free() prototype */
38 #endif
39
40 #ifdef CONFIG_SYS_HUSH_PARSER
41 #include <hush.h>
42 #endif
43
44 #ifdef CONFIG_OF_CONTROL
45 #include <fdtdec.h>
46 #endif
47
48 #ifdef CONFIG_OF_LIBFDT
49 #include <fdt_support.h>
50 #endif /* CONFIG_OF_LIBFDT */
51
52 #include <post.h>
53 #include <linux/ctype.h>
54 #include <menu.h>
55
56 DECLARE_GLOBAL_DATA_PTR;
57
58 /*
59 * Board-specific Platform code can reimplement show_boot_progress () if needed
60 */
61 void inline __show_boot_progress (int val) {}
62 void show_boot_progress (int val) __attribute__((weak, alias("__show_boot_progress")));
63
64 #if defined(CONFIG_UPDATE_TFTP)
65 int update_tftp (ulong addr);
66 #endif /* CONFIG_UPDATE_TFTP */
67
68 #define MAX_DELAY_STOP_STR 32
69
70 #undef DEBUG_PARSER
71
72 char console_buffer[CONFIG_SYS_CBSIZE + 1]; /* console I/O buffer */
73
74 static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen);
75 static const char erase_seq[] = "\b \b"; /* erase sequence */
76 static const char tab_seq[] = " "; /* used to expand TABs */
77
78 #ifdef CONFIG_BOOT_RETRY_TIME
79 static uint64_t endtime = 0; /* must be set, default is instant timeout */
80 static int retry_time = -1; /* -1 so can call readline before main_loop */
81 #endif
82
83 #define endtick(seconds) (get_ticks() + (uint64_t)(seconds) * get_tbclk())
84
85 #ifndef CONFIG_BOOT_RETRY_MIN
86 #define CONFIG_BOOT_RETRY_MIN CONFIG_BOOT_RETRY_TIME
87 #endif
88
89 #ifdef CONFIG_MODEM_SUPPORT
90 int do_mdm_init = 0;
91 extern void mdm_init(void); /* defined in board.c */
92 #endif
93
94 /***************************************************************************
95 * Watch for 'delay' seconds for autoboot stop or autoboot delay string.
96 * returns: 0 - no key string, allow autoboot 1 - got key string, abort
97 */
98 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
99 # if defined(CONFIG_AUTOBOOT_KEYED)
100 #ifndef CONFIG_MENU
101 static inline
102 #endif
103 int abortboot(int bootdelay)
104 {
105 int abort = 0;
106 uint64_t etime = endtick(bootdelay);
107 struct {
108 char* str;
109 u_int len;
110 int retry;
111 }
112 delaykey [] = {
113 { str: getenv ("bootdelaykey"), retry: 1 },
114 { str: getenv ("bootdelaykey2"), retry: 1 },
115 { str: getenv ("bootstopkey"), retry: 0 },
116 { str: getenv ("bootstopkey2"), retry: 0 },
117 };
118
119 char presskey [MAX_DELAY_STOP_STR];
120 u_int presskey_len = 0;
121 u_int presskey_max = 0;
122 u_int i;
123
124 #ifndef CONFIG_ZERO_BOOTDELAY_CHECK
125 if (bootdelay == 0)
126 return 0;
127 #endif
128
129 # ifdef CONFIG_AUTOBOOT_PROMPT
130 printf(CONFIG_AUTOBOOT_PROMPT);
131 # endif
132
133 # ifdef CONFIG_AUTOBOOT_DELAY_STR
134 if (delaykey[0].str == NULL)
135 delaykey[0].str = CONFIG_AUTOBOOT_DELAY_STR;
136 # endif
137 # ifdef CONFIG_AUTOBOOT_DELAY_STR2
138 if (delaykey[1].str == NULL)
139 delaykey[1].str = CONFIG_AUTOBOOT_DELAY_STR2;
140 # endif
141 # ifdef CONFIG_AUTOBOOT_STOP_STR
142 if (delaykey[2].str == NULL)
143 delaykey[2].str = CONFIG_AUTOBOOT_STOP_STR;
144 # endif
145 # ifdef CONFIG_AUTOBOOT_STOP_STR2
146 if (delaykey[3].str == NULL)
147 delaykey[3].str = CONFIG_AUTOBOOT_STOP_STR2;
148 # endif
149
150 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i ++) {
151 delaykey[i].len = delaykey[i].str == NULL ?
152 0 : strlen (delaykey[i].str);
153 delaykey[i].len = delaykey[i].len > MAX_DELAY_STOP_STR ?
154 MAX_DELAY_STOP_STR : delaykey[i].len;
155
156 presskey_max = presskey_max > delaykey[i].len ?
157 presskey_max : delaykey[i].len;
158
159 # if DEBUG_BOOTKEYS
160 printf("%s key:<%s>\n",
161 delaykey[i].retry ? "delay" : "stop",
162 delaykey[i].str ? delaykey[i].str : "NULL");
163 # endif
164 }
165
166 /* In order to keep up with incoming data, check timeout only
167 * when catch up.
168 */
169 do {
170 if (tstc()) {
171 if (presskey_len < presskey_max) {
172 presskey [presskey_len ++] = getc();
173 }
174 else {
175 for (i = 0; i < presskey_max - 1; i ++)
176 presskey [i] = presskey [i + 1];
177
178 presskey [i] = getc();
179 }
180 }
181
182 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i ++) {
183 if (delaykey[i].len > 0 &&
184 presskey_len >= delaykey[i].len &&
185 memcmp (presskey + presskey_len - delaykey[i].len,
186 delaykey[i].str,
187 delaykey[i].len) == 0) {
188 # if DEBUG_BOOTKEYS
189 printf("got %skey\n",
190 delaykey[i].retry ? "delay" : "stop");
191 # endif
192
193 # ifdef CONFIG_BOOT_RETRY_TIME
194 /* don't retry auto boot */
195 if (! delaykey[i].retry)
196 retry_time = -1;
197 # endif
198 abort = 1;
199 }
200 }
201 } while (!abort && get_ticks() <= etime);
202
203 # if DEBUG_BOOTKEYS
204 if (!abort)
205 puts("key timeout\n");
206 # endif
207
208 #ifdef CONFIG_SILENT_CONSOLE
209 if (abort)
210 gd->flags &= ~GD_FLG_SILENT;
211 #endif
212
213 return abort;
214 }
215
216 # else /* !defined(CONFIG_AUTOBOOT_KEYED) */
217
218 #ifdef CONFIG_MENUKEY
219 static int menukey = 0;
220 #endif
221
222 #ifndef CONFIG_MENU
223 static inline
224 #endif
225 int abortboot(int bootdelay)
226 {
227 int abort = 0;
228
229 #ifdef CONFIG_MENUPROMPT
230 printf(CONFIG_MENUPROMPT);
231 #else
232 if (bootdelay >= 0)
233 printf("Hit any key to stop autoboot: %2d ", bootdelay);
234 #endif
235
236 #if defined CONFIG_ZERO_BOOTDELAY_CHECK
237 /*
238 * Check if key already pressed
239 * Don't check if bootdelay < 0
240 */
241 if (bootdelay >= 0) {
242 if (tstc()) { /* we got a key press */
243 (void) getc(); /* consume input */
244 puts ("\b\b\b 0");
245 abort = 1; /* don't auto boot */
246 }
247 }
248 #endif
249
250 while ((bootdelay > 0) && (!abort)) {
251 int i;
252
253 --bootdelay;
254 /* delay 100 * 10ms */
255 for (i=0; !abort && i<100; ++i) {
256 if (tstc()) { /* we got a key press */
257 abort = 1; /* don't auto boot */
258 bootdelay = 0; /* no more delay */
259 # ifdef CONFIG_MENUKEY
260 menukey = getc();
261 # else
262 (void) getc(); /* consume input */
263 # endif
264 break;
265 }
266 udelay(10000);
267 }
268
269 printf("\b\b\b%2d ", bootdelay);
270 }
271
272 putc('\n');
273
274 #ifdef CONFIG_SILENT_CONSOLE
275 if (abort)
276 gd->flags &= ~GD_FLG_SILENT;
277 #endif
278
279 return abort;
280 }
281 # endif /* CONFIG_AUTOBOOT_KEYED */
282 #endif /* CONFIG_BOOTDELAY >= 0 */
283
284 /*
285 * Runs the given boot command securely. Specifically:
286 * - Doesn't run the command with the shell (run_command or parse_string_outer),
287 * since that's a lot of code surface that an attacker might exploit.
288 * Because of this, we don't do any argument parsing--the secure boot command
289 * has to be a full-fledged u-boot command.
290 * - Doesn't check for keypresses before booting, since that could be a
291 * security hole; also disables Ctrl-C.
292 * - Doesn't allow the command to return.
293 *
294 * Upon any failures, this function will drop into an infinite loop after
295 * printing the error message to console.
296 */
297
298 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0) && \
299 defined(CONFIG_OF_CONTROL)
300 static void secure_boot_cmd(char *cmd)
301 {
302 cmd_tbl_t *cmdtp;
303 int rc;
304
305 if (!cmd) {
306 printf("## Error: Secure boot command not specified\n");
307 goto err;
308 }
309
310 /* Disable Ctrl-C just in case some command is used that checks it. */
311 disable_ctrlc(1);
312
313 /* Find the command directly. */
314 cmdtp = find_cmd(cmd);
315 if (!cmdtp) {
316 printf("## Error: \"%s\" not defined\n", cmd);
317 goto err;
318 }
319
320 /* Run the command, forcing no flags and faking argc and argv. */
321 rc = (cmdtp->cmd)(cmdtp, 0, 1, &cmd);
322
323 /* Shouldn't ever return from boot command. */
324 printf("## Error: \"%s\" returned (code %d)\n", cmd, rc);
325
326 err:
327 /*
328 * Not a whole lot to do here. Rebooting won't help much, since we'll
329 * just end up right back here. Just loop.
330 */
331 hang();
332 }
333
334 static void process_fdt_options(const void *blob)
335 {
336 ulong addr;
337
338 /* Add an env variable to point to a kernel payload, if available */
339 addr = fdtdec_get_config_int(gd->fdt_blob, "kernel-offset", 0);
340 if (addr)
341 setenv_addr("kernaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
342
343 /* Add an env variable to point to a root disk, if available */
344 addr = fdtdec_get_config_int(gd->fdt_blob, "rootdisk-offset", 0);
345 if (addr)
346 setenv_addr("rootaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
347 }
348 #endif /* CONFIG_OF_CONTROL */
349
350
351 /****************************************************************************/
352
353 void main_loop (void)
354 {
355 #ifndef CONFIG_SYS_HUSH_PARSER
356 static char lastcommand[CONFIG_SYS_CBSIZE] = { 0, };
357 int len;
358 int rc = 1;
359 int flag;
360 #endif
361 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0) && \
362 defined(CONFIG_OF_CONTROL)
363 char *env;
364 #endif
365 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
366 char *s;
367 int bootdelay;
368 #endif
369 #ifdef CONFIG_PREBOOT
370 char *p;
371 #endif
372 #ifdef CONFIG_BOOTCOUNT_LIMIT
373 unsigned long bootcount = 0;
374 unsigned long bootlimit = 0;
375 char *bcs;
376 char bcs_set[16];
377 #endif /* CONFIG_BOOTCOUNT_LIMIT */
378
379 #ifdef CONFIG_BOOTCOUNT_LIMIT
380 bootcount = bootcount_load();
381 bootcount++;
382 bootcount_store (bootcount);
383 sprintf (bcs_set, "%lu", bootcount);
384 setenv ("bootcount", bcs_set);
385 bcs = getenv ("bootlimit");
386 bootlimit = bcs ? simple_strtoul (bcs, NULL, 10) : 0;
387 #endif /* CONFIG_BOOTCOUNT_LIMIT */
388
389 #ifdef CONFIG_MODEM_SUPPORT
390 debug ("DEBUG: main_loop: do_mdm_init=%d\n", do_mdm_init);
391 if (do_mdm_init) {
392 char *str = strdup(getenv("mdm_cmd"));
393 setenv ("preboot", str); /* set or delete definition */
394 if (str != NULL)
395 free (str);
396 mdm_init(); /* wait for modem connection */
397 }
398 #endif /* CONFIG_MODEM_SUPPORT */
399
400 #ifdef CONFIG_VERSION_VARIABLE
401 {
402 setenv ("ver", version_string); /* set version variable */
403 }
404 #endif /* CONFIG_VERSION_VARIABLE */
405
406 #ifdef CONFIG_SYS_HUSH_PARSER
407 u_boot_hush_start ();
408 #endif
409
410 #if defined(CONFIG_HUSH_INIT_VAR)
411 hush_init_var ();
412 #endif
413
414 #ifdef CONFIG_PREBOOT
415 if ((p = getenv ("preboot")) != NULL) {
416 # ifdef CONFIG_AUTOBOOT_KEYED
417 int prev = disable_ctrlc(1); /* disable Control C checking */
418 # endif
419
420 run_command_list(p, -1, 0);
421
422 # ifdef CONFIG_AUTOBOOT_KEYED
423 disable_ctrlc(prev); /* restore Control C checking */
424 # endif
425 }
426 #endif /* CONFIG_PREBOOT */
427
428 #if defined(CONFIG_UPDATE_TFTP)
429 update_tftp (0UL);
430 #endif /* CONFIG_UPDATE_TFTP */
431
432 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
433 s = getenv ("bootdelay");
434 bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
435
436 debug ("### main_loop entered: bootdelay=%d\n\n", bootdelay);
437
438 #if defined(CONFIG_MENU_SHOW)
439 bootdelay = menu_show(bootdelay);
440 #endif
441 # ifdef CONFIG_BOOT_RETRY_TIME
442 init_cmd_timeout ();
443 # endif /* CONFIG_BOOT_RETRY_TIME */
444
445 #ifdef CONFIG_POST
446 if (gd->flags & GD_FLG_POSTFAIL) {
447 s = getenv("failbootcmd");
448 }
449 else
450 #endif /* CONFIG_POST */
451 #ifdef CONFIG_BOOTCOUNT_LIMIT
452 if (bootlimit && (bootcount > bootlimit)) {
453 printf ("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\n",
454 (unsigned)bootlimit);
455 s = getenv ("altbootcmd");
456 }
457 else
458 #endif /* CONFIG_BOOTCOUNT_LIMIT */
459 s = getenv ("bootcmd");
460 #ifdef CONFIG_OF_CONTROL
461 /* Allow the fdt to override the boot command */
462 env = fdtdec_get_config_string(gd->fdt_blob, "bootcmd");
463 if (env)
464 s = env;
465
466 process_fdt_options(gd->fdt_blob);
467
468 /*
469 * If the bootsecure option was chosen, use secure_boot_cmd().
470 * Always use 'env' in this case, since bootsecure requres that the
471 * bootcmd was specified in the FDT too.
472 */
473 if (fdtdec_get_config_int(gd->fdt_blob, "bootsecure", 0))
474 secure_boot_cmd(env);
475
476 #endif /* CONFIG_OF_CONTROL */
477
478 debug ("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
479
480 if (bootdelay != -1 && s && !abortboot(bootdelay)) {
481 # ifdef CONFIG_AUTOBOOT_KEYED
482 int prev = disable_ctrlc(1); /* disable Control C checking */
483 # endif
484
485 run_command_list(s, -1, 0);
486
487 # ifdef CONFIG_AUTOBOOT_KEYED
488 disable_ctrlc(prev); /* restore Control C checking */
489 # endif
490 }
491
492 # ifdef CONFIG_MENUKEY
493 if (menukey == CONFIG_MENUKEY) {
494 s = getenv("menucmd");
495 if (s)
496 run_command_list(s, -1, 0);
497 }
498 #endif /* CONFIG_MENUKEY */
499 #endif /* CONFIG_BOOTDELAY */
500
501 #if defined CONFIG_OF_CONTROL
502 set_working_fdt_addr((void *)gd->fdt_blob);
503 #endif /* CONFIG_OF_CONTROL */
504
505 /*
506 * Main Loop for Monitor Command Processing
507 */
508 #ifdef CONFIG_SYS_HUSH_PARSER
509 parse_file_outer();
510 /* This point is never reached */
511 for (;;);
512 #else
513 for (;;) {
514 #ifdef CONFIG_BOOT_RETRY_TIME
515 if (rc >= 0) {
516 /* Saw enough of a valid command to
517 * restart the timeout.
518 */
519 reset_cmd_timeout();
520 }
521 #endif
522 len = readline (CONFIG_SYS_PROMPT);
523
524 flag = 0; /* assume no special flags for now */
525 if (len > 0)
526 strcpy (lastcommand, console_buffer);
527 else if (len == 0)
528 flag |= CMD_FLAG_REPEAT;
529 #ifdef CONFIG_BOOT_RETRY_TIME
530 else if (len == -2) {
531 /* -2 means timed out, retry autoboot
532 */
533 puts ("\nTimed out waiting for command\n");
534 # ifdef CONFIG_RESET_TO_RETRY
535 /* Reinit board to run initialization code again */
536 do_reset (NULL, 0, 0, NULL);
537 # else
538 return; /* retry autoboot */
539 # endif
540 }
541 #endif
542
543 if (len == -1)
544 puts ("<INTERRUPT>\n");
545 else
546 rc = run_command(lastcommand, flag);
547
548 if (rc <= 0) {
549 /* invalid command or not repeatable, forget it */
550 lastcommand[0] = 0;
551 }
552 }
553 #endif /*CONFIG_SYS_HUSH_PARSER*/
554 }
555
556 #ifdef CONFIG_BOOT_RETRY_TIME
557 /***************************************************************************
558 * initialize command line timeout
559 */
560 void init_cmd_timeout(void)
561 {
562 char *s = getenv ("bootretry");
563
564 if (s != NULL)
565 retry_time = (int)simple_strtol(s, NULL, 10);
566 else
567 retry_time = CONFIG_BOOT_RETRY_TIME;
568
569 if (retry_time >= 0 && retry_time < CONFIG_BOOT_RETRY_MIN)
570 retry_time = CONFIG_BOOT_RETRY_MIN;
571 }
572
573 /***************************************************************************
574 * reset command line timeout to retry_time seconds
575 */
576 void reset_cmd_timeout(void)
577 {
578 endtime = endtick(retry_time);
579 }
580 #endif
581
582 #ifdef CONFIG_CMDLINE_EDITING
583
584 /*
585 * cmdline-editing related codes from vivi.
586 * Author: Janghoon Lyu <nandy@mizi.com>
587 */
588
589 #define putnstr(str,n) do { \
590 printf ("%.*s", (int)n, str); \
591 } while (0)
592
593 #define CTL_CH(c) ((c) - 'a' + 1)
594 #define CTL_BACKSPACE ('\b')
595 #define DEL ((char)255)
596 #define DEL7 ((char)127)
597 #define CREAD_HIST_CHAR ('!')
598
599 #define getcmd_putch(ch) putc(ch)
600 #define getcmd_getch() getc()
601 #define getcmd_cbeep() getcmd_putch('\a')
602
603 #define HIST_MAX 20
604 #define HIST_SIZE CONFIG_SYS_CBSIZE
605
606 static int hist_max;
607 static int hist_add_idx;
608 static int hist_cur = -1;
609 static unsigned hist_num;
610
611 static char *hist_list[HIST_MAX];
612 static char hist_lines[HIST_MAX][HIST_SIZE + 1]; /* Save room for NULL */
613
614 #define add_idx_minus_one() ((hist_add_idx == 0) ? hist_max : hist_add_idx-1)
615
616 static void hist_init(void)
617 {
618 int i;
619
620 hist_max = 0;
621 hist_add_idx = 0;
622 hist_cur = -1;
623 hist_num = 0;
624
625 for (i = 0; i < HIST_MAX; i++) {
626 hist_list[i] = hist_lines[i];
627 hist_list[i][0] = '\0';
628 }
629 }
630
631 static void cread_add_to_hist(char *line)
632 {
633 strcpy(hist_list[hist_add_idx], line);
634
635 if (++hist_add_idx >= HIST_MAX)
636 hist_add_idx = 0;
637
638 if (hist_add_idx > hist_max)
639 hist_max = hist_add_idx;
640
641 hist_num++;
642 }
643
644 static char* hist_prev(void)
645 {
646 char *ret;
647 int old_cur;
648
649 if (hist_cur < 0)
650 return NULL;
651
652 old_cur = hist_cur;
653 if (--hist_cur < 0)
654 hist_cur = hist_max;
655
656 if (hist_cur == hist_add_idx) {
657 hist_cur = old_cur;
658 ret = NULL;
659 } else
660 ret = hist_list[hist_cur];
661
662 return (ret);
663 }
664
665 static char* hist_next(void)
666 {
667 char *ret;
668
669 if (hist_cur < 0)
670 return NULL;
671
672 if (hist_cur == hist_add_idx)
673 return NULL;
674
675 if (++hist_cur > hist_max)
676 hist_cur = 0;
677
678 if (hist_cur == hist_add_idx) {
679 ret = "";
680 } else
681 ret = hist_list[hist_cur];
682
683 return (ret);
684 }
685
686 #ifndef CONFIG_CMDLINE_EDITING
687 static void cread_print_hist_list(void)
688 {
689 int i;
690 unsigned long n;
691
692 n = hist_num - hist_max;
693
694 i = hist_add_idx + 1;
695 while (1) {
696 if (i > hist_max)
697 i = 0;
698 if (i == hist_add_idx)
699 break;
700 printf("%s\n", hist_list[i]);
701 n++;
702 i++;
703 }
704 }
705 #endif /* CONFIG_CMDLINE_EDITING */
706
707 #define BEGINNING_OF_LINE() { \
708 while (num) { \
709 getcmd_putch(CTL_BACKSPACE); \
710 num--; \
711 } \
712 }
713
714 #define ERASE_TO_EOL() { \
715 if (num < eol_num) { \
716 printf("%*s", (int)(eol_num - num), ""); \
717 do { \
718 getcmd_putch(CTL_BACKSPACE); \
719 } while (--eol_num > num); \
720 } \
721 }
722
723 #define REFRESH_TO_EOL() { \
724 if (num < eol_num) { \
725 wlen = eol_num - num; \
726 putnstr(buf + num, wlen); \
727 num = eol_num; \
728 } \
729 }
730
731 static void cread_add_char(char ichar, int insert, unsigned long *num,
732 unsigned long *eol_num, char *buf, unsigned long len)
733 {
734 unsigned long wlen;
735
736 /* room ??? */
737 if (insert || *num == *eol_num) {
738 if (*eol_num > len - 1) {
739 getcmd_cbeep();
740 return;
741 }
742 (*eol_num)++;
743 }
744
745 if (insert) {
746 wlen = *eol_num - *num;
747 if (wlen > 1) {
748 memmove(&buf[*num+1], &buf[*num], wlen-1);
749 }
750
751 buf[*num] = ichar;
752 putnstr(buf + *num, wlen);
753 (*num)++;
754 while (--wlen) {
755 getcmd_putch(CTL_BACKSPACE);
756 }
757 } else {
758 /* echo the character */
759 wlen = 1;
760 buf[*num] = ichar;
761 putnstr(buf + *num, wlen);
762 (*num)++;
763 }
764 }
765
766 static void cread_add_str(char *str, int strsize, int insert, unsigned long *num,
767 unsigned long *eol_num, char *buf, unsigned long len)
768 {
769 while (strsize--) {
770 cread_add_char(*str, insert, num, eol_num, buf, len);
771 str++;
772 }
773 }
774
775 static int cread_line(const char *const prompt, char *buf, unsigned int *len,
776 int timeout)
777 {
778 unsigned long num = 0;
779 unsigned long eol_num = 0;
780 unsigned long wlen;
781 char ichar;
782 int insert = 1;
783 int esc_len = 0;
784 char esc_save[8];
785 int init_len = strlen(buf);
786 int first = 1;
787
788 if (init_len)
789 cread_add_str(buf, init_len, 1, &num, &eol_num, buf, *len);
790
791 while (1) {
792 #ifdef CONFIG_BOOT_RETRY_TIME
793 while (!tstc()) { /* while no incoming data */
794 if (retry_time >= 0 && get_ticks() > endtime)
795 return (-2); /* timed out */
796 WATCHDOG_RESET();
797 }
798 #endif
799 if (first && timeout) {
800 uint64_t etime = endtick(timeout);
801
802 while (!tstc()) { /* while no incoming data */
803 if (get_ticks() >= etime)
804 return -2; /* timed out */
805 WATCHDOG_RESET();
806 }
807 first = 0;
808 }
809
810 ichar = getcmd_getch();
811
812 if ((ichar == '\n') || (ichar == '\r')) {
813 putc('\n');
814 break;
815 }
816
817 /*
818 * handle standard linux xterm esc sequences for arrow key, etc.
819 */
820 if (esc_len != 0) {
821 if (esc_len == 1) {
822 if (ichar == '[') {
823 esc_save[esc_len] = ichar;
824 esc_len = 2;
825 } else {
826 cread_add_str(esc_save, esc_len, insert,
827 &num, &eol_num, buf, *len);
828 esc_len = 0;
829 }
830 continue;
831 }
832
833 switch (ichar) {
834
835 case 'D': /* <- key */
836 ichar = CTL_CH('b');
837 esc_len = 0;
838 break;
839 case 'C': /* -> key */
840 ichar = CTL_CH('f');
841 esc_len = 0;
842 break; /* pass off to ^F handler */
843 case 'H': /* Home key */
844 ichar = CTL_CH('a');
845 esc_len = 0;
846 break; /* pass off to ^A handler */
847 case 'A': /* up arrow */
848 ichar = CTL_CH('p');
849 esc_len = 0;
850 break; /* pass off to ^P handler */
851 case 'B': /* down arrow */
852 ichar = CTL_CH('n');
853 esc_len = 0;
854 break; /* pass off to ^N handler */
855 default:
856 esc_save[esc_len++] = ichar;
857 cread_add_str(esc_save, esc_len, insert,
858 &num, &eol_num, buf, *len);
859 esc_len = 0;
860 continue;
861 }
862 }
863
864 switch (ichar) {
865 case 0x1b:
866 if (esc_len == 0) {
867 esc_save[esc_len] = ichar;
868 esc_len = 1;
869 } else {
870 puts("impossible condition #876\n");
871 esc_len = 0;
872 }
873 break;
874
875 case CTL_CH('a'):
876 BEGINNING_OF_LINE();
877 break;
878 case CTL_CH('c'): /* ^C - break */
879 *buf = '\0'; /* discard input */
880 return (-1);
881 case CTL_CH('f'):
882 if (num < eol_num) {
883 getcmd_putch(buf[num]);
884 num++;
885 }
886 break;
887 case CTL_CH('b'):
888 if (num) {
889 getcmd_putch(CTL_BACKSPACE);
890 num--;
891 }
892 break;
893 case CTL_CH('d'):
894 if (num < eol_num) {
895 wlen = eol_num - num - 1;
896 if (wlen) {
897 memmove(&buf[num], &buf[num+1], wlen);
898 putnstr(buf + num, wlen);
899 }
900
901 getcmd_putch(' ');
902 do {
903 getcmd_putch(CTL_BACKSPACE);
904 } while (wlen--);
905 eol_num--;
906 }
907 break;
908 case CTL_CH('k'):
909 ERASE_TO_EOL();
910 break;
911 case CTL_CH('e'):
912 REFRESH_TO_EOL();
913 break;
914 case CTL_CH('o'):
915 insert = !insert;
916 break;
917 case CTL_CH('x'):
918 case CTL_CH('u'):
919 BEGINNING_OF_LINE();
920 ERASE_TO_EOL();
921 break;
922 case DEL:
923 case DEL7:
924 case 8:
925 if (num) {
926 wlen = eol_num - num;
927 num--;
928 memmove(&buf[num], &buf[num+1], wlen);
929 getcmd_putch(CTL_BACKSPACE);
930 putnstr(buf + num, wlen);
931 getcmd_putch(' ');
932 do {
933 getcmd_putch(CTL_BACKSPACE);
934 } while (wlen--);
935 eol_num--;
936 }
937 break;
938 case CTL_CH('p'):
939 case CTL_CH('n'):
940 {
941 char * hline;
942
943 esc_len = 0;
944
945 if (ichar == CTL_CH('p'))
946 hline = hist_prev();
947 else
948 hline = hist_next();
949
950 if (!hline) {
951 getcmd_cbeep();
952 continue;
953 }
954
955 /* nuke the current line */
956 /* first, go home */
957 BEGINNING_OF_LINE();
958
959 /* erase to end of line */
960 ERASE_TO_EOL();
961
962 /* copy new line into place and display */
963 strcpy(buf, hline);
964 eol_num = strlen(buf);
965 REFRESH_TO_EOL();
966 continue;
967 }
968 #ifdef CONFIG_AUTO_COMPLETE
969 case '\t': {
970 int num2, col;
971
972 /* do not autocomplete when in the middle */
973 if (num < eol_num) {
974 getcmd_cbeep();
975 break;
976 }
977
978 buf[num] = '\0';
979 col = strlen(prompt) + eol_num;
980 num2 = num;
981 if (cmd_auto_complete(prompt, buf, &num2, &col)) {
982 col = num2 - num;
983 num += col;
984 eol_num += col;
985 }
986 break;
987 }
988 #endif
989 default:
990 cread_add_char(ichar, insert, &num, &eol_num, buf, *len);
991 break;
992 }
993 }
994 *len = eol_num;
995 buf[eol_num] = '\0'; /* lose the newline */
996
997 if (buf[0] && buf[0] != CREAD_HIST_CHAR)
998 cread_add_to_hist(buf);
999 hist_cur = hist_add_idx;
1000
1001 return 0;
1002 }
1003
1004 #endif /* CONFIG_CMDLINE_EDITING */
1005
1006 /****************************************************************************/
1007
1008 /*
1009 * Prompt for input and read a line.
1010 * If CONFIG_BOOT_RETRY_TIME is defined and retry_time >= 0,
1011 * time out when time goes past endtime (timebase time in ticks).
1012 * Return: number of read characters
1013 * -1 if break
1014 * -2 if timed out
1015 */
1016 int readline (const char *const prompt)
1017 {
1018 /*
1019 * If console_buffer isn't 0-length the user will be prompted to modify
1020 * it instead of entering it from scratch as desired.
1021 */
1022 console_buffer[0] = '\0';
1023
1024 return readline_into_buffer(prompt, console_buffer, 0);
1025 }
1026
1027
1028 int readline_into_buffer(const char *const prompt, char *buffer, int timeout)
1029 {
1030 char *p = buffer;
1031 #ifdef CONFIG_CMDLINE_EDITING
1032 unsigned int len = CONFIG_SYS_CBSIZE;
1033 int rc;
1034 static int initted = 0;
1035
1036 /*
1037 * History uses a global array which is not
1038 * writable until after relocation to RAM.
1039 * Revert to non-history version if still
1040 * running from flash.
1041 */
1042 if (gd->flags & GD_FLG_RELOC) {
1043 if (!initted) {
1044 hist_init();
1045 initted = 1;
1046 }
1047
1048 if (prompt)
1049 puts (prompt);
1050
1051 rc = cread_line(prompt, p, &len, timeout);
1052 return rc < 0 ? rc : len;
1053
1054 } else {
1055 #endif /* CONFIG_CMDLINE_EDITING */
1056 char * p_buf = p;
1057 int n = 0; /* buffer index */
1058 int plen = 0; /* prompt length */
1059 int col; /* output column cnt */
1060 char c;
1061
1062 /* print prompt */
1063 if (prompt) {
1064 plen = strlen (prompt);
1065 puts (prompt);
1066 }
1067 col = plen;
1068
1069 for (;;) {
1070 #ifdef CONFIG_BOOT_RETRY_TIME
1071 while (!tstc()) { /* while no incoming data */
1072 if (retry_time >= 0 && get_ticks() > endtime)
1073 return (-2); /* timed out */
1074 WATCHDOG_RESET();
1075 }
1076 #endif
1077 WATCHDOG_RESET(); /* Trigger watchdog, if needed */
1078
1079 #ifdef CONFIG_SHOW_ACTIVITY
1080 while (!tstc()) {
1081 show_activity(0);
1082 WATCHDOG_RESET();
1083 }
1084 #endif
1085 c = getc();
1086
1087 /*
1088 * Special character handling
1089 */
1090 switch (c) {
1091 case '\r': /* Enter */
1092 case '\n':
1093 *p = '\0';
1094 puts ("\r\n");
1095 return (p - p_buf);
1096
1097 case '\0': /* nul */
1098 continue;
1099
1100 case 0x03: /* ^C - break */
1101 p_buf[0] = '\0'; /* discard input */
1102 return (-1);
1103
1104 case 0x15: /* ^U - erase line */
1105 while (col > plen) {
1106 puts (erase_seq);
1107 --col;
1108 }
1109 p = p_buf;
1110 n = 0;
1111 continue;
1112
1113 case 0x17: /* ^W - erase word */
1114 p=delete_char(p_buf, p, &col, &n, plen);
1115 while ((n > 0) && (*p != ' ')) {
1116 p=delete_char(p_buf, p, &col, &n, plen);
1117 }
1118 continue;
1119
1120 case 0x08: /* ^H - backspace */
1121 case 0x7F: /* DEL - backspace */
1122 p=delete_char(p_buf, p, &col, &n, plen);
1123 continue;
1124
1125 default:
1126 /*
1127 * Must be a normal character then
1128 */
1129 if (n < CONFIG_SYS_CBSIZE-2) {
1130 if (c == '\t') { /* expand TABs */
1131 #ifdef CONFIG_AUTO_COMPLETE
1132 /* if auto completion triggered just continue */
1133 *p = '\0';
1134 if (cmd_auto_complete(prompt, console_buffer, &n, &col)) {
1135 p = p_buf + n; /* reset */
1136 continue;
1137 }
1138 #endif
1139 puts (tab_seq+(col&07));
1140 col += 8 - (col&07);
1141 } else {
1142 ++col; /* echo input */
1143 putc (c);
1144 }
1145 *p++ = c;
1146 ++n;
1147 } else { /* Buffer full */
1148 putc ('\a');
1149 }
1150 }
1151 }
1152 #ifdef CONFIG_CMDLINE_EDITING
1153 }
1154 #endif
1155 }
1156
1157 /****************************************************************************/
1158
1159 static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen)
1160 {
1161 char *s;
1162
1163 if (*np == 0) {
1164 return (p);
1165 }
1166
1167 if (*(--p) == '\t') { /* will retype the whole line */
1168 while (*colp > plen) {
1169 puts (erase_seq);
1170 (*colp)--;
1171 }
1172 for (s=buffer; s<p; ++s) {
1173 if (*s == '\t') {
1174 puts (tab_seq+((*colp) & 07));
1175 *colp += 8 - ((*colp) & 07);
1176 } else {
1177 ++(*colp);
1178 putc (*s);
1179 }
1180 }
1181 } else {
1182 puts (erase_seq);
1183 (*colp)--;
1184 }
1185 (*np)--;
1186 return (p);
1187 }
1188
1189 /****************************************************************************/
1190
1191 int parse_line (char *line, char *argv[])
1192 {
1193 int nargs = 0;
1194
1195 #ifdef DEBUG_PARSER
1196 printf ("parse_line: \"%s\"\n", line);
1197 #endif
1198 while (nargs < CONFIG_SYS_MAXARGS) {
1199
1200 /* skip any white space */
1201 while (isblank(*line))
1202 ++line;
1203
1204 if (*line == '\0') { /* end of line, no more args */
1205 argv[nargs] = NULL;
1206 #ifdef DEBUG_PARSER
1207 printf ("parse_line: nargs=%d\n", nargs);
1208 #endif
1209 return (nargs);
1210 }
1211
1212 argv[nargs++] = line; /* begin of argument string */
1213
1214 /* find end of string */
1215 while (*line && !isblank(*line))
1216 ++line;
1217
1218 if (*line == '\0') { /* end of line, no more args */
1219 argv[nargs] = NULL;
1220 #ifdef DEBUG_PARSER
1221 printf ("parse_line: nargs=%d\n", nargs);
1222 #endif
1223 return (nargs);
1224 }
1225
1226 *line++ = '\0'; /* terminate current arg */
1227 }
1228
1229 printf ("** Too many args (max. %d) **\n", CONFIG_SYS_MAXARGS);
1230
1231 #ifdef DEBUG_PARSER
1232 printf ("parse_line: nargs=%d\n", nargs);
1233 #endif
1234 return (nargs);
1235 }
1236
1237 /****************************************************************************/
1238
1239 #ifndef CONFIG_SYS_HUSH_PARSER
1240 static void process_macros (const char *input, char *output)
1241 {
1242 char c, prev;
1243 const char *varname_start = NULL;
1244 int inputcnt = strlen (input);
1245 int outputcnt = CONFIG_SYS_CBSIZE;
1246 int state = 0; /* 0 = waiting for '$' */
1247
1248 /* 1 = waiting for '(' or '{' */
1249 /* 2 = waiting for ')' or '}' */
1250 /* 3 = waiting for ''' */
1251 #ifdef DEBUG_PARSER
1252 char *output_start = output;
1253
1254 printf ("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen (input),
1255 input);
1256 #endif
1257
1258 prev = '\0'; /* previous character */
1259
1260 while (inputcnt && outputcnt) {
1261 c = *input++;
1262 inputcnt--;
1263
1264 if (state != 3) {
1265 /* remove one level of escape characters */
1266 if ((c == '\\') && (prev != '\\')) {
1267 if (inputcnt-- == 0)
1268 break;
1269 prev = c;
1270 c = *input++;
1271 }
1272 }
1273
1274 switch (state) {
1275 case 0: /* Waiting for (unescaped) $ */
1276 if ((c == '\'') && (prev != '\\')) {
1277 state = 3;
1278 break;
1279 }
1280 if ((c == '$') && (prev != '\\')) {
1281 state++;
1282 } else {
1283 *(output++) = c;
1284 outputcnt--;
1285 }
1286 break;
1287 case 1: /* Waiting for ( */
1288 if (c == '(' || c == '{') {
1289 state++;
1290 varname_start = input;
1291 } else {
1292 state = 0;
1293 *(output++) = '$';
1294 outputcnt--;
1295
1296 if (outputcnt) {
1297 *(output++) = c;
1298 outputcnt--;
1299 }
1300 }
1301 break;
1302 case 2: /* Waiting for ) */
1303 if (c == ')' || c == '}') {
1304 int i;
1305 char envname[CONFIG_SYS_CBSIZE], *envval;
1306 int envcnt = input - varname_start - 1; /* Varname # of chars */
1307
1308 /* Get the varname */
1309 for (i = 0; i < envcnt; i++) {
1310 envname[i] = varname_start[i];
1311 }
1312 envname[i] = 0;
1313
1314 /* Get its value */
1315 envval = getenv (envname);
1316
1317 /* Copy into the line if it exists */
1318 if (envval != NULL)
1319 while ((*envval) && outputcnt) {
1320 *(output++) = *(envval++);
1321 outputcnt--;
1322 }
1323 /* Look for another '$' */
1324 state = 0;
1325 }
1326 break;
1327 case 3: /* Waiting for ' */
1328 if ((c == '\'') && (prev != '\\')) {
1329 state = 0;
1330 } else {
1331 *(output++) = c;
1332 outputcnt--;
1333 }
1334 break;
1335 }
1336 prev = c;
1337 }
1338
1339 if (outputcnt)
1340 *output = 0;
1341 else
1342 *(output - 1) = 0;
1343
1344 #ifdef DEBUG_PARSER
1345 printf ("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n",
1346 strlen (output_start), output_start);
1347 #endif
1348 }
1349
1350 /****************************************************************************
1351 * returns:
1352 * 1 - command executed, repeatable
1353 * 0 - command executed but not repeatable, interrupted commands are
1354 * always considered not repeatable
1355 * -1 - not executed (unrecognized, bootd recursion or too many args)
1356 * (If cmd is NULL or "" or longer than CONFIG_SYS_CBSIZE-1 it is
1357 * considered unrecognized)
1358 *
1359 * WARNING:
1360 *
1361 * We must create a temporary copy of the command since the command we get
1362 * may be the result from getenv(), which returns a pointer directly to
1363 * the environment data, which may change magicly when the command we run
1364 * creates or modifies environment variables (like "bootp" does).
1365 */
1366 static int builtin_run_command(const char *cmd, int flag)
1367 {
1368 char cmdbuf[CONFIG_SYS_CBSIZE]; /* working copy of cmd */
1369 char *token; /* start of token in cmdbuf */
1370 char *sep; /* end of token (separator) in cmdbuf */
1371 char finaltoken[CONFIG_SYS_CBSIZE];
1372 char *str = cmdbuf;
1373 char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */
1374 int argc, inquotes;
1375 int repeatable = 1;
1376 int rc = 0;
1377
1378 #ifdef DEBUG_PARSER
1379 printf ("[RUN_COMMAND] cmd[%p]=\"", cmd);
1380 puts (cmd ? cmd : "NULL"); /* use puts - string may be loooong */
1381 puts ("\"\n");
1382 #endif
1383
1384 clear_ctrlc(); /* forget any previous Control C */
1385
1386 if (!cmd || !*cmd) {
1387 return -1; /* empty command */
1388 }
1389
1390 if (strlen(cmd) >= CONFIG_SYS_CBSIZE) {
1391 puts ("## Command too long!\n");
1392 return -1;
1393 }
1394
1395 strcpy (cmdbuf, cmd);
1396
1397 /* Process separators and check for invalid
1398 * repeatable commands
1399 */
1400
1401 #ifdef DEBUG_PARSER
1402 printf ("[PROCESS_SEPARATORS] %s\n", cmd);
1403 #endif
1404 while (*str) {
1405
1406 /*
1407 * Find separator, or string end
1408 * Allow simple escape of ';' by writing "\;"
1409 */
1410 for (inquotes = 0, sep = str; *sep; sep++) {
1411 if ((*sep=='\'') &&
1412 (*(sep-1) != '\\'))
1413 inquotes=!inquotes;
1414
1415 if (!inquotes &&
1416 (*sep == ';') && /* separator */
1417 ( sep != str) && /* past string start */
1418 (*(sep-1) != '\\')) /* and NOT escaped */
1419 break;
1420 }
1421
1422 /*
1423 * Limit the token to data between separators
1424 */
1425 token = str;
1426 if (*sep) {
1427 str = sep + 1; /* start of command for next pass */
1428 *sep = '\0';
1429 }
1430 else
1431 str = sep; /* no more commands for next pass */
1432 #ifdef DEBUG_PARSER
1433 printf ("token: \"%s\"\n", token);
1434 #endif
1435
1436 /* find macros in this token and replace them */
1437 process_macros (token, finaltoken);
1438
1439 /* Extract arguments */
1440 if ((argc = parse_line (finaltoken, argv)) == 0) {
1441 rc = -1; /* no command at all */
1442 continue;
1443 }
1444
1445 if (cmd_process(flag, argc, argv, &repeatable))
1446 rc = -1;
1447
1448 /* Did the user stop this? */
1449 if (had_ctrlc ())
1450 return -1; /* if stopped then not repeatable */
1451 }
1452
1453 return rc ? rc : repeatable;
1454 }
1455 #endif
1456
1457 /*
1458 * Run a command using the selected parser.
1459 *
1460 * @param cmd Command to run
1461 * @param flag Execution flags (CMD_FLAG_...)
1462 * @return 0 on success, or != 0 on error.
1463 */
1464 int run_command(const char *cmd, int flag)
1465 {
1466 #ifndef CONFIG_SYS_HUSH_PARSER
1467 /*
1468 * builtin_run_command can return 0 or 1 for success, so clean up
1469 * its result.
1470 */
1471 if (builtin_run_command(cmd, flag) == -1)
1472 return 1;
1473
1474 return 0;
1475 #else
1476 return parse_string_outer(cmd,
1477 FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
1478 #endif
1479 }
1480
1481 #ifndef CONFIG_SYS_HUSH_PARSER
1482 /**
1483 * Execute a list of command separated by ; or \n using the built-in parser.
1484 *
1485 * This function cannot take a const char * for the command, since if it
1486 * finds newlines in the string, it replaces them with \0.
1487 *
1488 * @param cmd String containing list of commands
1489 * @param flag Execution flags (CMD_FLAG_...)
1490 * @return 0 on success, or != 0 on error.
1491 */
1492 static int builtin_run_command_list(char *cmd, int flag)
1493 {
1494 char *line, *next;
1495 int rcode = 0;
1496
1497 /*
1498 * Break into individual lines, and execute each line; terminate on
1499 * error.
1500 */
1501 line = next = cmd;
1502 while (*next) {
1503 if (*next == '\n') {
1504 *next = '\0';
1505 /* run only non-empty commands */
1506 if (*line) {
1507 debug("** exec: \"%s\"\n", line);
1508 if (builtin_run_command(line, 0) < 0) {
1509 rcode = 1;
1510 break;
1511 }
1512 }
1513 line = next + 1;
1514 }
1515 ++next;
1516 }
1517 if (rcode == 0 && *line)
1518 rcode = (builtin_run_command(line, 0) >= 0);
1519
1520 return rcode;
1521 }
1522 #endif
1523
1524 int run_command_list(const char *cmd, int len, int flag)
1525 {
1526 int need_buff = 1;
1527 char *buff = (char *)cmd; /* cast away const */
1528 int rcode = 0;
1529
1530 if (len == -1) {
1531 len = strlen(cmd);
1532 #ifdef CONFIG_SYS_HUSH_PARSER
1533 /* hush will never change our string */
1534 need_buff = 0;
1535 #else
1536 /* the built-in parser will change our string if it sees \n */
1537 need_buff = strchr(cmd, '\n') != NULL;
1538 #endif
1539 }
1540 if (need_buff) {
1541 buff = malloc(len + 1);
1542 if (!buff)
1543 return 1;
1544 memcpy(buff, cmd, len);
1545 buff[len] = '\0';
1546 }
1547 #ifdef CONFIG_SYS_HUSH_PARSER
1548 rcode = parse_string_outer(buff, FLAG_PARSE_SEMICOLON);
1549 #else
1550 /*
1551 * This function will overwrite any \n it sees with a \0, which
1552 * is why it can't work with a const char *. Here we are making
1553 * using of internal knowledge of this function, to avoid always
1554 * doing a malloc() which is actually required only in a case that
1555 * is pretty rare.
1556 */
1557 rcode = builtin_run_command_list(buff, flag);
1558 if (need_buff)
1559 free(buff);
1560 #endif
1561
1562 return rcode;
1563 }
1564
1565 /****************************************************************************/
1566
1567 #if defined(CONFIG_CMD_RUN)
1568 int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
1569 {
1570 int i;
1571
1572 if (argc < 2)
1573 return CMD_RET_USAGE;
1574
1575 for (i=1; i<argc; ++i) {
1576 char *arg;
1577
1578 if ((arg = getenv (argv[i])) == NULL) {
1579 printf ("## Error: \"%s\" not defined\n", argv[i]);
1580 return 1;
1581 }
1582
1583 if (run_command(arg, flag) != 0)
1584 return 1;
1585 }
1586 return 0;
1587 }
1588 #endif
"Das U-Boot" Source Tree