source: rtems/cpukit/libmisc/shell/shell.c @ 3fe2155

Last change on this file since 3fe2155 was 3fe2155, checked in by Sebastian Huber <sebastian.huber@…>, on Feb 1, 2019 at 9:00:36 AM

Remove superfluous <rtems/system.h> includes

  • Property mode set to 100644
File size: 28.0 KB
Line 
1/*
2 *
3 *  Instantatiate a new terminal shell.
4 *
5 *  Author:
6 *
7 *   WORK: fernando.ruiz@ctv.es
8 *   HOME: correo@fernando-ruiz.com
9 *
10 *  The license and distribution terms for this file may be
11 *  found in the file LICENSE in this distribution or at
12 *  http://www.rtems.org/license/LICENSE.
13 */
14
15#ifdef HAVE_CONFIG_H
16#include "config.h"
17#endif
18
19#include <stdio.h>
20#include <time.h>
21
22#include <rtems.h>
23#include <rtems/error.h>
24#include <rtems/libio.h>
25#include <rtems/libio_.h>
26#include <rtems/shell.h>
27#include <rtems/shellconfig.h>
28#include <rtems/console.h>
29#include "internal.h"
30
31#include <termios.h>
32#include <string.h>
33#include <stdlib.h>
34#include <ctype.h>
35#include <sys/stat.h>
36#include <unistd.h>
37#include <errno.h>
38#include <pwd.h>
39#include <pthread.h>
40#include <assert.h>
41
42const rtems_shell_env_t rtems_global_shell_env = {
43  .magic         = rtems_build_name('S', 'E', 'N', 'V'),
44  .devname       = CONSOLE_DEVICE_NAME,
45  .taskname      = "SHGL",
46  .exit_shell    = false,
47  .forever       = true,
48  .errorlevel    = -1,
49  .echo          = false,
50  .cwd           = "/",
51  .input         = NULL,
52  .output        = NULL,
53  .output_append = false,
54  .wake_on_end   = RTEMS_ID_NONE,
55  .login_check   = NULL
56};
57
58static pthread_once_t rtems_shell_once = PTHREAD_ONCE_INIT;
59
60static pthread_key_t rtems_shell_current_env_key;
61
62/*
63 *  Initialize the shell user/process environment information
64 */
65static rtems_shell_env_t *rtems_shell_init_env(
66  rtems_shell_env_t *shell_env_p
67)
68{
69  rtems_shell_env_t *shell_env;
70
71  shell_env = malloc(sizeof(rtems_shell_env_t));
72  if ( !shell_env )
73    return NULL;
74  if ( !shell_env_p ) {
75    *shell_env = rtems_global_shell_env;
76    shell_env->taskname = NULL;
77  } else {
78    *shell_env = *shell_env_p;
79  }
80
81  return shell_env;
82}
83
84/*
85 *  Completely free a shell_env_t and all associated memory
86 */
87static void rtems_shell_env_free(
88  void *ptr
89)
90{
91  rtems_shell_env_t *shell_env;
92  shell_env = (rtems_shell_env_t *) ptr;
93
94  if ( !ptr )
95    return;
96
97  if ( shell_env->input )
98    free((void *)shell_env->input);
99  if ( shell_env->output )
100    free((void *)shell_env->output);
101  free( ptr );
102}
103
104static void rtems_shell_create_file(const char *name, const char *content)
105{
106  FILE *fp = fopen(name, "wx");
107
108  if (fp != NULL) {
109    fputs(content, fp);
110    fclose(fp);
111  }
112}
113
114static void rtems_shell_init_commands(void)
115{
116  rtems_shell_cmd_t * const *c;
117  rtems_shell_alias_t * const *a;
118
119  for ( c = rtems_shell_Initial_commands ; *; c++ ) {
120    rtems_shell_add_cmd_struct( *c );
121  }
122
123  for ( a = rtems_shell_Initial_aliases ; *; a++ ) {
124    rtems_shell_alias_cmd( (*a)->name, (*a)->alias );
125  }
126}
127
128static void rtems_shell_init_once(void)
129{
130  struct passwd pwd;
131  struct passwd *pwd_res;
132
133  pthread_key_create(&rtems_shell_current_env_key, rtems_shell_env_free);
134
135  /* dummy call to init /etc dir */
136  getpwuid_r(0, &pwd, NULL, 0, &pwd_res);
137
138  rtems_shell_create_file("etc/issue",
139                          "\n"
140                          "Welcome to @V\\n"
141                          "Login into @S\\n");
142
143  rtems_shell_create_file("/etc/issue.net",
144                          "\n"
145                          "Welcome to %v\n"
146                          "running on %m\n");
147
148  rtems_shell_init_commands();
149  rtems_shell_register_monitor_commands();
150}
151
152void rtems_shell_init_environment(void)
153{
154  assert(pthread_once(&rtems_shell_once, rtems_shell_init_once) == 0);
155}
156
157/*
158 *  Return the current shell environment
159 */
160rtems_shell_env_t *rtems_shell_get_current_env(void)
161{
162  return (rtems_shell_env_t *) pthread_getspecific(rtems_shell_current_env_key);
163}
164
165/*
166 *  Duplication the current shell environment and if none is set
167 *  clear it.
168 */
169void rtems_shell_dup_current_env(rtems_shell_env_t *copy)
170{
171  rtems_shell_env_t *env = rtems_shell_get_current_env();
172  if (env) {
173    *copy = *env;
174  }
175  else {
176    memset(copy, 0, sizeof(rtems_shell_env_t));
177    copy->magic    = rtems_build_name('S', 'E', 'N', 'V');
178    copy->devname  = CONSOLE_DEVICE_NAME;
179    copy->taskname = "RTSH";
180  }
181}
182
183/*
184 *  Get a line of user input with modest features
185 */
186static int rtems_shell_line_editor(
187  char       *cmds[],
188  int         count,
189  int         size,
190  const char *prompt,
191  FILE       *in,
192  FILE       *out
193)
194{
195  unsigned int extended_key;
196  int          c;
197  int          col;
198  int          last_col;
199  int          output;
200  char         line[size];
201  char         new_line[size];
202  int          up;
203  int          cmd = -1;
204  int          inserting = 1;
205
206  output = (out && isatty(fileno(in)));
207
208  col = last_col = 0;
209
210  tcdrain(fileno(in));
211  if (out)
212    tcdrain(fileno(out));
213
214  if (output && prompt)
215    fprintf(out, "\r%s", prompt);
216
217  line[0] = 0;
218  new_line[0] = 0;
219
220  for (;;) {
221
222    if (output)
223      fflush(out);
224
225    extended_key = rtems_shell_getchar(in);
226
227    if (extended_key == EOF)
228      return -2;
229
230    c = extended_key & RTEMS_SHELL_KEYS_NORMAL_MASK;
231
232    /*
233     * Make the extended_key usable as a boolean.
234     */
235    extended_key &= ~RTEMS_SHELL_KEYS_NORMAL_MASK;
236
237    up = 0;
238
239    if (extended_key)
240    {
241      switch (c)
242      {
243        case RTEMS_SHELL_KEYS_END:
244          if (output)
245            fprintf(out, "%s", line + col);
246          col = (int) strlen (line);
247          break;
248
249        case RTEMS_SHELL_KEYS_HOME:
250          if (output) {
251            if (prompt)
252              fprintf(out,"\r%s", prompt);
253          }
254          col = 0;
255          break;
256
257        case RTEMS_SHELL_KEYS_LARROW:
258          c = 2;
259          extended_key = 0;
260          break;
261
262        case RTEMS_SHELL_KEYS_RARROW:
263          c = 6;
264          extended_key = 0;
265          break;
266
267        case RTEMS_SHELL_KEYS_UARROW:
268          c = 16;
269          extended_key = 0;
270          break;
271
272        case RTEMS_SHELL_KEYS_DARROW:
273          c = 14;
274          extended_key = 0;
275          break;
276
277        case RTEMS_SHELL_KEYS_DEL:
278          if (line[col] != '\0')
279          {
280            int end;
281            int bs;
282            strcpy (&line[col], &line[col + 1]);
283            if (output) {
284              fprintf(out,"\r%s%s ", prompt, line);
285              end = (int) strlen (line);
286              for (bs = 0; bs < ((end - col) + 1); bs++)
287                fputc('\b', out);
288            }
289          }
290          break;
291
292        case RTEMS_SHELL_KEYS_INS:
293          inserting = inserting ? 0 : 1;
294          break;
295      }
296    }
297    if (!extended_key)
298    {
299      switch (c)
300      {
301        case 1:                         /*Control-a*/
302          if (output) {
303            if (prompt)
304              fprintf(out,"\r%s", prompt);
305          }
306          col = 0;
307          break;
308
309        case 2:                         /* Control-B */
310          if (col > 0)
311          {
312            col--;
313            if (output)
314              fputc('\b', out);
315          }
316          break;
317
318        case 4:                         /* Control-D */
319          if (strlen(line)) {
320            if (col < strlen(line)) {
321              strcpy (line + col, line + col + 1);
322              if (output) {
323                int bs;
324                fprintf(out,"%s \b", line + col);
325                for (bs = 0; bs < ((int) strlen (line) - col); bs++)
326                  fputc('\b', out);
327              }
328            }
329            break;
330          }
331          /* Fall through */
332
333        case EOF:
334          if (output)
335            fputc('\n', out);
336          return -2;
337
338        case 5:                         /*Control-e*/
339          if (output)
340            fprintf(out, "%s", line + col);
341          col = (int) strlen (line);
342          break;
343
344        case 6:                         /* Control-F */
345          if ((col < size) && (line[col] != '\0')) {
346            if (output)
347              fputc(line[col], out);
348            col++;
349          }
350          break;
351
352        case 7:                         /* Control-G */
353          if (output) {
354            /*
355             * The (int) cast is needed because the width specifier (%*)
356             * must be an int, but strlen() returns a size_t. Without
357             * the case, the result is a printf() format warning.
358             */
359            fprintf(out,"\r%s%*c", prompt, (int) strlen (line), ' ');
360            fprintf(out,"\r%s\x7", prompt);
361          }
362          memset (line, '\0', strlen(line));
363          col = 0;
364          break;
365
366        case 11:                        /*Control-k*/
367          if (line[col]) {
368            if (output) {
369              int end = strlen(line);
370              int bs;
371              fprintf(out,"%*c", end - col, ' ');
372              for (bs = 0; bs < (end - col); bs++)
373                fputc('\b', out);
374            }
375            line[col] = '\0';
376          }
377          break;
378
379        case '\f':
380          if (output) {
381            int end;
382            int bs;
383            fputc('\f',out);
384            fprintf(out,"\r%s%s", prompt, line);
385            end = (int) strlen (line);
386            for (bs = 0; bs < (end - col); bs++)
387              fputc('\b', out);
388          }
389          break;
390
391        case '\b':
392        case '\x7f':
393          if (col > 0)
394          {
395            int bs;
396            col--;
397            strcpy (line + col, line + col + 1);
398            if (output) {
399              fprintf(out,"\b%s \b", line + col);
400              for (bs = 0; bs < ((int) strlen (line) - col); bs++)
401                fputc('\b', out);
402            }
403          }
404          break;
405
406        case '\n':
407        case '\r':
408        {
409          /*
410           * Process the command.
411           */
412          if (output)
413            fprintf(out,"\n");
414
415          /*
416           * Only process the command if we have a command and it is not
417           * repeated in the history.
418           */
419          if (strlen(line) == 0) {
420            cmd = -1;
421          } else {
422            if ((cmd < 0) || (strcmp(line, cmds[cmd]) != 0)) {
423              if (count > 1)
424                memmove(cmds[1], cmds[0], (count - 1) * size);
425              memmove (cmds[0], line, size);
426              cmd = 0;
427            } else {
428              if ((cmd > 1) && (strcmp(line, cmds[cmd]) == 0)) {
429                memmove(cmds[1], cmds[0], cmd * size);
430                memmove (cmds[0], line, size);
431                cmd = 0;
432              }
433            }
434          }
435        }
436        return cmd;
437
438        case 16:                         /* Control-P */
439          if ((cmd >= (count - 1)) || (strlen(cmds[cmd + 1]) == 0)) {
440            if (output)
441              fputc('\x7', out);
442            break;
443          }
444
445          up = 1;
446          /* drop through */
447
448        case 14:                        /* Control-N */
449        {
450          int last_cmd = cmd;
451          int clen = strlen (line);
452
453          if (prompt)
454            clen += strlen(prompt);
455
456          if (up) {
457            cmd++;
458          } else {
459            if (cmd < 0) {
460              if (output)
461                fprintf(out, "\x7");
462              break;
463            }
464            else
465              cmd--;
466          }
467
468          if ((last_cmd < 0) || (strcmp(cmds[last_cmd], line) != 0))
469            memcpy (new_line, line, size);
470
471          if (cmd < 0)
472            memcpy (line, new_line, size);
473          else
474            memcpy (line, cmds[cmd], size);
475
476          col = strlen (line);
477
478          if (output) {
479            fprintf(out,"\r%s%*c", prompt, clen, ' ');
480            fprintf(out,"\r%s%s", prompt, line);
481          }
482        }
483        break;
484
485        case 20:                        /* Control-T */
486          if (col > 0)
487          {
488            char tmp;
489            if (col == strlen(line)) {
490              col--;
491              if (output)
492                fprintf(out,"\b");
493            }
494            tmp           = line[col];
495            line[col]     = line[col - 1];
496            line[col - 1] = tmp;
497            if (output)
498              fprintf(out,"\b%c%c", line[col - 1], line[col]);
499            col++;
500          } else {
501            if (output)
502              fputc('\x7', out);
503          }
504          break;
505
506        case 21:                        /* Control-U */
507          if (col > 0)
508          {
509            int clen = strlen (line);
510
511            strcpy (line, line + col);
512            if (output) {
513              fprintf(out,"\r%s%*c", prompt, clen, ' ');
514              fprintf(out,"\r%s%s", prompt, line);
515            }
516            col = 0;
517          }
518          break;
519
520        default:
521          if ((col < (size - 1)) && (c >= ' ') && (c <= '~')) {
522            int end = strlen (line);
523            if (inserting && (col < end) && (end < size)) {
524              int ch, bs;
525              for (ch = end + 1; ch > col; ch--)
526                line[ch] = line[ch - 1];
527              if (output) {
528                fprintf(out, "%s", line + col);
529                for (bs = 0; bs < (end - col + 1); bs++)
530                  fputc('\b', out);
531              }
532            }
533            line[col++] = c;
534            if (col > end)
535              line[col] = '\0';
536            if (output)
537              fputc(c, out);
538          }
539          break;
540      }
541    }
542  }
543  return -2;
544}
545
546static bool rtems_shell_login(rtems_shell_env_t *env, FILE * in,FILE * out)
547{
548  FILE              *fd;
549  int               c;
550  time_t            t;
551
552  if (out) {
553    if ((env->devname[5]!='p')||
554        (env->devname[6]!='t')||
555        (env->devname[7]!='y')) {
556      fd = fopen("/etc/issue","r");
557      if (fd) {
558        while ((c=fgetc(fd))!=EOF) {
559          if (c=='@')  {
560            switch(c=fgetc(fd)) {
561              case 'L':
562                fprintf(out,"%s", env->devname);
563                break;
564              case 'B':
565                fprintf(out,"0");
566                break;
567              case 'T':
568              case 'D':
569                time(&t);
570                fprintf(out,"%s",ctime(&t));
571                break;
572              case 'S':
573                fprintf(out,"RTEMS");
574                break;
575              case 'V':
576                fprintf(out,"%s\n%s",_RTEMS_version, _Copyright_Notice);
577                break;
578              case '@':
579                fprintf(out,"@");
580                break;
581              default :
582                fprintf(out,"@%c",c);
583                break;
584            }
585          } else if (c=='\\')  {
586            switch(c=fgetc(fd)) {
587              case '\\': fprintf(out,"\\"); break;
588              case 'b':  fprintf(out,"\b"); break;
589              case 'f':  fprintf(out,"\f"); break;
590              case 'n':  fprintf(out,"\n"); break;
591              case 'r':  fprintf(out,"\r"); break;
592              case 's':  fprintf(out," ");  break;
593              case 't':  fprintf(out,"\t"); break;
594              case '@':  fprintf(out,"@");  break;
595            }
596          } else {
597            fputc(c,out);
598          }
599        }
600        fclose(fd);
601      }
602    } else {
603      fd = fopen("/etc/issue.net","r");
604      if (fd) {
605        while ((c=fgetc(fd))!=EOF) {
606          if (c=='%')  {
607            switch(c=fgetc(fd)) {
608              case 't':
609                fprintf(out,"%s", env->devname);
610                break;
611              case 'h':
612                fprintf(out,"0");
613                break;
614              case 'D':
615                fprintf(out," ");
616                break;
617              case 'd':
618                time(&t);
619                fprintf(out,"%s",ctime(&t));
620                break;
621              case 's':
622                fprintf(out,"RTEMS");
623                break;
624              case 'm':
625                fprintf(out,"(" CPU_NAME "/" CPU_MODEL_NAME ")");
626                break;
627              case 'r':
628                fprintf(out,_RTEMS_version);
629                break;
630              case 'v':
631                fprintf(out,"%s\n%s",_RTEMS_version,_Copyright_Notice);
632                break;
633              case '%':fprintf(out,"%%");
634                break;
635              default:
636                fprintf(out,"%%%c",c);
637                break;
638            }
639          } else {
640            fputc(c,out);
641          }
642        }
643        fclose(fd);
644      }
645    }
646  }
647
648  return rtems_shell_login_prompt(in, out, env->devname, env->login_check);
649}
650
651#if defined(SHELL_DEBUG)
652void rtems_shell_print_env(
653  rtems_shell_env_t * shell_env
654)
655{
656  if ( !shell_env ) {
657    printk( "shell_env is NULL\n" );
658    return;
659  }
660  printk( "shell_env=%p\n"
661    "shell_env->magic=0x%08x\t"
662    "shell_env->devname=%s\n"
663    "shell_env->taskname=%s\t"
664    "shell_env->exit_shell=%d\t"
665    "shell_env->forever=%d\n",
666    shell_env->magic,
667    shell_env->devname,
668    ((shell_env->taskname) ? shell_env->taskname : "NOT SET"),
669    shell_env->exit_shell,
670    shell_env->forever
671  );
672}
673#endif
674
675static rtems_task rtems_shell_task(rtems_task_argument task_argument)
676{
677  rtems_shell_env_t *shell_env = (rtems_shell_env_t*) task_argument;
678  rtems_id           wake_on_end = shell_env->wake_on_end;
679  rtems_shell_main_loop( shell_env );
680  if (wake_on_end != RTEMS_INVALID_ID)
681    rtems_event_send (wake_on_end, RTEMS_EVENT_1);
682  rtems_task_exit();
683}
684
685static bool rtems_shell_init_user_env(void)
686{
687  rtems_status_code sc;
688
689  /* Make sure we have a private user environment */
690  sc = rtems_libio_set_private_env();
691  if (sc != RTEMS_SUCCESSFUL) {
692    rtems_error(sc, "rtems_libio_set_private_env():");
693    return false;
694  }
695
696  /* Make an effective root user */
697  seteuid(0);
698  setegid(0);
699
700  return chroot("/") == 0;
701}
702
703#define RTEMS_SHELL_MAXIMUM_ARGUMENTS (128)
704#define RTEMS_SHELL_CMD_SIZE          (128)
705#define RTEMS_SHELL_CMD_COUNT         (32)
706#define RTEMS_SHELL_PROMPT_SIZE       (128)
707
708bool rtems_shell_main_loop(
709  rtems_shell_env_t *shell_env_arg
710)
711{
712  rtems_shell_env_t *shell_env;
713  int                eno;
714  struct termios     term;
715  struct termios     previous_term;
716  char              *prompt = NULL;
717  int                cmd;
718  int                cmd_count = 1; /* assume a script and so only 1 command line */
719  char              *cmds[RTEMS_SHELL_CMD_COUNT];
720  char              *cmd_argv;
721  int                argc;
722  char              *argv[RTEMS_SHELL_MAXIMUM_ARGUMENTS];
723  bool               result = true;
724  bool               input_file = false;
725  int                line = 0;
726  FILE              *stdinToClose = NULL;
727  FILE              *stdoutToClose = NULL;
728
729  rtems_shell_init_environment();
730
731  shell_env = rtems_shell_init_env(shell_env_arg);
732  if (shell_env == NULL) {
733    rtems_error(0, "rtems_shell_init_env");
734    return false;
735  }
736
737  eno = pthread_setspecific(rtems_shell_current_env_key, shell_env);
738  if (eno != 0) {
739    rtems_error(0, "pthread_setspecific(shell_current_env_key)");
740    return false;
741  }
742
743  if (!rtems_shell_init_user_env()) {
744    rtems_error(0, "rtems_shell_init_user_env");
745    return false;
746  }
747
748  fileno(stdout);
749
750  /* fprintf( stderr,
751     "-%s-%s-\n", shell_env->input, shell_env->output );
752  */
753
754  if (shell_env->output && strcmp(shell_env->output, "stdout") != 0) {
755    if (strcmp(shell_env->output, "stderr") == 0) {
756      stdout = stderr;
757    } else if (strcmp(shell_env->output, "/dev/null") == 0) {
758      fclose (stdout);
759    } else {
760      FILE *output = fopen(shell_env_arg->output,
761                           shell_env_arg->output_append ? "a" : "w");
762      if (!output) {
763        fprintf(stderr, "shell: open output %s failed: %s\n",
764                shell_env_arg->output, strerror(errno));
765        return false;
766      }
767      stdout = output;
768      stdoutToClose = output;
769    }
770  }
771
772  if (shell_env->input && strcmp(shell_env_arg->input, "stdin") != 0) {
773    FILE *input = fopen(shell_env_arg->input, "r");
774    if (!input) {
775      fprintf(stderr, "shell: open input %s failed: %s\n",
776              shell_env_arg->input, strerror(errno));
777      return false;
778    }
779    stdin = input;
780    stdinToClose = input;
781    shell_env->forever = false;
782    input_file =true;
783  }
784  else {
785    /* make a raw terminal,Linux Manuals */
786    if (tcgetattr(fileno(stdin), &previous_term) >= 0) {
787      term = previous_term;
788      term.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
789      term.c_oflag &= ~OPOST;
790      term.c_oflag |= (OPOST|ONLCR); /* But with cr+nl on output */
791      term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
792      term.c_cflag  |= CLOCAL | CREAD;
793      term.c_cc[VMIN]  = 1;
794      term.c_cc[VTIME] = 0;
795      if (tcsetattr (fileno(stdin), TCSADRAIN, &term) < 0) {
796        fprintf(stderr,
797                "shell:cannot set terminal attributes(%s)\n",shell_env->devname);
798      }
799    }
800    cmd_count = RTEMS_SHELL_CMD_COUNT;
801    prompt = malloc(RTEMS_SHELL_PROMPT_SIZE);
802    if (!prompt)
803        fprintf(stderr,
804                "shell:cannot allocate prompt memory\n");
805  }
806
807  setvbuf(stdin,NULL,_IONBF,0); /* Not buffered*/
808  setvbuf(stdout,NULL,_IONBF,0); /* Not buffered*/
809
810  /*
811   * Allocate the command line buffers.
812   */
813  cmd_argv = malloc (RTEMS_SHELL_CMD_SIZE);
814  if (!cmd_argv) {
815    fprintf(stderr, "no memory for command line buffers\n" );
816  }
817
818  cmds[0] = calloc (cmd_count, RTEMS_SHELL_CMD_SIZE);
819  if (!cmds[0]) {
820    fprintf(stderr, "no memory for command line buffers\n" );
821  }
822
823  if (cmd_argv && cmds[0]) {
824
825    memset (cmds[0], 0, cmd_count * RTEMS_SHELL_CMD_SIZE);
826
827    for (cmd = 1; cmd < cmd_count; cmd++) {
828      cmds[cmd] = cmds[cmd - 1] + RTEMS_SHELL_CMD_SIZE;
829    }
830
831    do {
832      result = rtems_shell_init_user_env();
833
834      if (result) {
835        /*
836         *  By using result here, we can fall to the bottom of the
837         *  loop when the connection is dropped during login and
838         *  keep on trucking.
839         */
840        if (shell_env->login_check != NULL) {
841          result = rtems_shell_login(shell_env, stdin,stdout);
842        } else {
843          setuid(shell_env->uid);
844          setgid(shell_env->gid);
845          seteuid(shell_env->uid);
846          setegid(shell_env->gid);
847          rtems_current_user_env_getgroups();
848
849          result = true;
850        }
851      }
852
853      if (result)  {
854        const char *c;
855        memset (cmds[0], 0, cmd_count * RTEMS_SHELL_CMD_SIZE);
856        if (!input_file) {
857          rtems_shell_cat_file(stdout,"/etc/motd");
858          fprintf(stdout, "\n"
859                  "RTEMS Shell on %s. Use 'help' to list commands.\n",
860                  shell_env->devname);
861        }
862
863        if (input_file)
864          chdir(shell_env->cwd);
865        else
866          chdir("/"); /* XXX: chdir to getpwent homedir */
867
868        shell_env->exit_shell = false;
869
870        for (;;) {
871          int cmd;
872
873          /* Prompt section */
874          if (prompt) {
875            rtems_shell_get_prompt(shell_env, prompt,
876                                   RTEMS_SHELL_PROMPT_SIZE);
877          }
878
879          /* getcmd section */
880          cmd = rtems_shell_line_editor(cmds, cmd_count,
881                                        RTEMS_SHELL_CMD_SIZE, prompt,
882                                        stdin, stdout);
883
884          if (cmd == -1)
885            continue; /* empty line */
886
887          if (cmd == -2)
888            break; /*EOF*/
889
890          line++;
891
892          if (shell_env->echo)
893            fprintf(stdout, "%d: %s\n", line, cmds[cmd]);
894
895          /* evaluate cmd section */
896          c = cmds[cmd];
897          while (*c) {
898            if (!isblank((unsigned char)*c))
899              break;
900            c++;
901          }
902
903          if (*c == '\0')   /* empty line */
904            continue;
905
906          if (*c == '#') {  /* comment character */
907            cmds[cmd][0] = 0;
908            continue;
909          }
910
911          if (!strcmp(cmds[cmd],"bye") || !strcmp(cmds[cmd],"exit")) {
912            fprintf(stdout, "Shell exiting\n" );
913            break;
914          }
915
916          /* exec cmd section */
917          /* TODO:
918           *  To avoid user crash catch the signals.
919           *  Open a new stdio files with posibility of redirection *
920           *  Run in a new shell task background. (unix &)
921           *  Resuming. A little bash.
922           */
923          memcpy (cmd_argv, cmds[cmd], RTEMS_SHELL_CMD_SIZE);
924          if (!rtems_shell_make_args(cmd_argv, &argc, argv,
925                                     RTEMS_SHELL_MAXIMUM_ARGUMENTS)) {
926            shell_env->errorlevel = rtems_shell_execute_cmd(argv[0], argc, argv);
927          }
928
929          /* end exec cmd section */
930          if (shell_env->exit_shell)
931            break;
932        }
933
934        fflush( stdout );
935        fflush( stderr );
936      }
937    } while (result && shell_env->forever);
938
939  }
940
941  if (cmds[0])
942    free (cmds[0]);
943  if (cmd_argv)
944    free (cmd_argv);
945  if (prompt)
946    free (prompt);
947
948  if (stdinToClose) {
949    fclose( stdinToClose );
950  } else {
951    if (tcsetattr(fileno(stdin), TCSADRAIN, &previous_term) < 0) {
952      fprintf(
953        stderr,
954        "shell: cannot reset terminal attributes (%s)\n",
955        shell_env->devname
956      );
957    }
958  }
959  if ( stdoutToClose )
960    fclose( stdoutToClose );
961  return result;
962}
963
964/* ----------------------------------------------- */
965static rtems_status_code rtems_shell_run (
966  const char *task_name,
967  size_t task_stacksize,
968  rtems_task_priority task_priority,
969  const char *devname,
970  bool forever,
971  bool wait,
972  const char *input,
973  const char *output,
974  bool output_append,
975  rtems_id wake_on_end,
976  bool echo,
977  rtems_shell_login_check_t login_check
978)
979{
980  rtems_id           task_id;
981  rtems_status_code  sc;
982  rtems_shell_env_t *shell_env;
983  rtems_name         name;
984
985  if ( task_name && strlen(task_name) >= 4)
986    name = rtems_build_name(
987      task_name[0], task_name[1], task_name[2], task_name[3]);
988  else
989    name = rtems_build_name( 'S', 'E', 'N', 'V' );
990
991  sc = rtems_task_create(
992    name,
993    task_priority,
994    task_stacksize,
995    RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
996    RTEMS_LOCAL | RTEMS_FLOATING_POINT,
997    &task_id
998  );
999  if (sc != RTEMS_SUCCESSFUL) {
1000    rtems_error(sc,"creating task %s in shell_init()",task_name);
1001    return sc;
1002  }
1003
1004  shell_env = rtems_shell_init_env( NULL );
1005  if ( !shell_env )  {
1006   rtems_error(RTEMS_NO_MEMORY,
1007               "allocating shell_env %s in shell_init()",task_name);
1008   return RTEMS_NO_MEMORY;
1009  }
1010  shell_env->devname       = devname;
1011  shell_env->taskname      = task_name;
1012  shell_env->exit_shell    = false;
1013  shell_env->forever       = forever;
1014  shell_env->echo          = echo;
1015  shell_env->input         = strdup (input);
1016  shell_env->output        = strdup (output);
1017  shell_env->output_append = output_append;
1018  shell_env->wake_on_end   = wake_on_end;
1019  shell_env->login_check   = login_check;
1020  shell_env->uid           = getuid();
1021  shell_env->gid           = getgid();
1022
1023  getcwd(shell_env->cwd, sizeof(shell_env->cwd));
1024
1025  sc = rtems_task_start(task_id, rtems_shell_task,
1026                          (rtems_task_argument) shell_env);
1027  if (sc != RTEMS_SUCCESSFUL) {
1028    rtems_error(sc,"starting task %s in shell_init()",task_name);
1029    return sc;
1030  }
1031
1032  if (wait) {
1033    rtems_event_set out;
1034    sc = rtems_event_receive (RTEMS_EVENT_1, RTEMS_WAIT, 0, &out);
1035  }
1036
1037  return 0;
1038}
1039
1040rtems_status_code rtems_shell_init(
1041  const char *task_name,
1042  size_t task_stacksize,
1043  rtems_task_priority task_priority,
1044  const char *devname,
1045  bool forever,
1046  bool wait,
1047  rtems_shell_login_check_t login_check
1048)
1049{
1050  rtems_id to_wake = RTEMS_ID_NONE;
1051
1052  if ( wait )
1053    to_wake = rtems_task_self();
1054
1055  return rtems_shell_run(
1056    task_name,               /* task_name */
1057    task_stacksize,          /* task_stacksize */
1058    task_priority,           /* task_priority */
1059    devname,                 /* devname */
1060    forever,                 /* forever */
1061    wait,                    /* wait */
1062    "stdin",                 /* input */
1063    "stdout",                /* output */
1064    false,                   /* output_append */
1065    to_wake,                 /* wake_on_end */
1066    false,                   /* echo */
1067    login_check              /* login check */
1068  );
1069}
1070
1071rtems_status_code   rtems_shell_script (
1072  const char          *task_name,
1073  size_t               task_stacksize,
1074  rtems_task_priority  task_priority,
1075  const char*          input,
1076  const char*          output,
1077  bool                 output_append,
1078  bool                 wait,
1079  bool                 echo
1080)
1081{
1082  rtems_id          current_task = RTEMS_INVALID_ID;
1083  rtems_status_code sc;
1084
1085  if (wait) {
1086    sc = rtems_task_ident (RTEMS_SELF, RTEMS_LOCAL, &current_task);
1087    if (sc != RTEMS_SUCCESSFUL)
1088      return sc;
1089  }
1090
1091  sc = rtems_shell_run(
1092    task_name,       /* task_name */
1093    task_stacksize,  /* task_stacksize */
1094    task_priority,   /* task_priority */
1095    NULL,            /* devname */
1096    0,               /* forever */
1097    wait,            /* wait */
1098    input,           /* input */
1099    output,          /* output */
1100    output_append,   /* output_append */
1101    current_task,    /* wake_on_end */
1102    echo,            /* echo */
1103    NULL             /* login check */
1104  );
1105  if (sc != RTEMS_SUCCESSFUL)
1106    return sc;
1107
1108  return sc;
1109}
Note: See TracBrowser for help on using the repository browser.