apps/shell/shell.c

   1 /**
   2  * \addtogroup shell
   3  * @{
   4  */
   5
   6 /*
   7  * Copyright (c) 2008, Swedish Institute of Computer Science.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the Institute nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * This file is part of the Contiki operating system.
  35  *
  36  * $Id: shell.c,v 1.13 2009/03/02 20:44:15 adamdunkels Exp $
  37  */
  38
  39 /**
  40  * \file
  41  *         The shell application
  42  * \author
  43  *         Adam Dunkels <adam@sics.se>
  44  */
  45
  46 #include "contiki.h"
  47 #include "contiki-lib.h"
  48
  49 #include "net/rime.h"
  50
  51 #include "shell.h"
  52
  53 #include <ctype.h>
  54 #include <string.h>
  55 #include <stdio.h>
  56
  57 LIST(commands);
  58
  59 int shell_event_input;
  60
  61 static struct process *front_process;
  62
  63 static unsigned long time_offset;
  64
  65 PROCESS(shell_process, "Shell");
  66 PROCESS(shell_server_process, "Shell server");
  67 /*---------------------------------------------------------------------------*/
  68 PROCESS(help_command_process, "help");
  69 SHELL_COMMAND(help_command, "help", "help: shows this help",
  70               &help_command_process);
  71 SHELL_COMMAND(question_command, "?", "?: shows this help",
  72               &help_command_process);
  73 PROCESS(shell_killall_process, "killall");
  74 SHELL_COMMAND(killall_command, "killall", "killall: stop all running commands",
  75               &shell_killall_process);
  76 PROCESS(shell_kill_process, "kill");
  77 SHELL_COMMAND(kill_command, "kill", "kill <command>: stop a specific command",
  78               &shell_kill_process);
  79 PROCESS(shell_null_process, "null");
  80 SHELL_COMMAND(null_command,
  81               "null",
  82               "null: discard input",
  83               &shell_null_process);
  84 /*---------------------------------------------------------------------------*/
  85 PROCESS_THREAD(shell_null_process, ev, data)
  86 {
  87   struct shell_input *input;
  88   PROCESS_BEGIN();
  89   while(1) {
  90     PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
  91     input = data;
  92
  93     if(input->len1 + input->len2 == 0) {
  94       PROCESS_EXIT();
  95     }
  96   }
  97   PROCESS_END();
  98 }
  99 /*---------------------------------------------------------------------------*/
 100 static void
 101 command_kill(struct shell_command *c)
 102 {
 103   if(c != NULL) {
 104     shell_output_str(&killall_command, "Stopping command ", c->command);
 105     process_exit(c->process);
 106   }
 107 }
 108 /*---------------------------------------------------------------------------*/
 109 static void
 110 killall(void)
 111 {
 112   struct shell_command *c;
 113   for(c = list_head(commands);
 114       c != NULL;
 115       c = c->next) {
 116     if(c != &killall_command && process_is_running(c->process)) {
 117       command_kill(c);
 118     }
 119   }
 120 }
 121 /*---------------------------------------------------------------------------*/
 122 PROCESS_THREAD(shell_killall_process, ev, data)
 123 {
 124
 125   PROCESS_BEGIN();
 126
 127   killall();
 128
 129   PROCESS_END();
 130 }
 131 /*---------------------------------------------------------------------------*/
 132 PROCESS_THREAD(shell_kill_process, ev, data)
 133 {
 134   struct shell_command *c;
 135   char *name;
 136   PROCESS_BEGIN();
 137
 138   name = data;
 139   if(name == NULL || strlen(name) == 0) {
 140     shell_output_str(&kill_command,
 141                      "kill <command>: command name must be given", "");
 142   }
 143
 144   for(c = list_head(commands);
 145       c != NULL;
 146       c = c->next) {
 147     if(strcmp(name, c->command) == 0 &&
 148        c != &kill_command &&
 149        process_is_running(c->process)) {
 150       command_kill(c);
 151       PROCESS_EXIT();
 152     }
 153   }
 154
 155   shell_output_str(&kill_command, "Command not found: ", name);
 156
 157   PROCESS_END();
 158 }
 159 /*---------------------------------------------------------------------------*/
 160 PROCESS_THREAD(help_command_process, ev, data)
 161 {
 162   struct shell_command *c;
 163   PROCESS_BEGIN();
 164
 165   shell_output_str(&help_command, "Available commands:", "");
 166   for(c = list_head(commands);
 167       c != NULL;
 168       c = c->next) {
 169     shell_output_str(&help_command, c->description, "");
 170   }
 171
 172   PROCESS_END();
 173 }
 174 /*---------------------------------------------------------------------------*/
 175 static void
 176 replace_braces(char *commandline)
 177 {
 178   char *ptr;
 179   int level = 0;
 180
 181   for(ptr = commandline; *ptr != 0; ++ptr) {
 182     if(*ptr == '{') {
 183       if(level == 0) {
 184         *ptr = ' ';
 185       }
 186       ++level;
 187     } else if(*ptr == '}') {
 188       --level;
 189       if(level == 0) {
 190         *ptr = ' ';
 191       }
 192     }
 193   }
 194 }
 195 /*---------------------------------------------------------------------------*/
 196 static char *
 197 find_pipe(char *commandline)
 198 {
 199   char *ptr;
 200   int level = 0;
 201
 202   for(ptr = commandline; *ptr != 0; ++ptr) {
 203     if(*ptr == '{') {
 204       ++level;
 205     } else if(*ptr == '}') {
 206       --level;
 207     } else if(*ptr == '|') {
 208       if(level == 0) {
 209         return ptr;
 210       }
 211     }
 212   }
 213   return NULL;
 214 }
 215 /*---------------------------------------------------------------------------*/
 216 static struct shell_command *
 217 start_command(char *commandline, struct shell_command *child)
 218 {
 219   char *next, *args;
 220   int command_len;
 221   struct shell_command *c;
 222
 223   /* Shave off any leading spaces. */
 224   while(*commandline == ' ') {
 225     commandline++;
 226   }
 227
 228   /* Find the next command in a pipeline and start it. */
 229   next = find_pipe(commandline);
 230   if(next != NULL) {
 231     *next = 0;
 232     child = start_command(next + 1, child);
 233   }
 234
 235   /* Separate the command arguments, and remove braces. */
 236   replace_braces(commandline);
 237   args = strchr(commandline, ' ');
 238   if(args != NULL) {
 239     args++;
 240   }
 241
 242   /* Shave off any trailing spaces. */
 243   command_len = (int)strlen(commandline);
 244   while(command_len > 0 && commandline[command_len - 1] == ' ') {
 245     commandline[command_len - 1] = 0;
 246     command_len--;
 247   }
 248
 249   if(args == NULL) {
 250     command_len = (int)strlen(commandline);
 251     args = &commandline[command_len];
 252   } else {
 253     command_len = (int)(args - commandline - 1);
 254   }
 255
 256
 257
 258   /* Go through list of commands to find a match for the first word in
 259      the command line. */
 260   for(c = list_head(commands);
 261       c != NULL &&
 262         !(strncmp(c->command, commandline, command_len) == 0 &&
 263           c->command[command_len] == 0);
 264       c = c->next);
 265
 266   if(c == NULL) {
 267     shell_output_str(NULL, commandline, ": command not found (try 'help')");
 268     command_kill(child);
 269     c = NULL;
 270   } else if(process_is_running(c->process) || child == c) {
 271     shell_output_str(NULL, commandline, ": command already running");
 272     c->child = NULL;
 273     c = NULL;
 274   } else {
 275     c->child = child;
 276     /*    printf("shell: start_command starting '%s'\n", c->process->name);*/
 277     /* Start a new process for the command. */
 278     process_start(c->process, args);
 279   }
 280
 281   return c;
 282 }
 283 /*---------------------------------------------------------------------------*/
 284 int
 285 shell_start_command(char *commandline, int commandline_len,
 286                     struct shell_command *child,
 287                     struct process **started_process)
 288 {
 289   struct shell_command *c;
 290   int background = 0;
 291
 292   if(commandline_len == 0) {
 293     if(started_process != NULL) {
 294       *started_process = NULL;
 295     }
 296     return SHELL_NOTHING;
 297   }
 298
 299   if(commandline[commandline_len - 1] == '&') {
 300     commandline[commandline_len - 1] = 0;
 301     background = 1;
 302     commandline_len--;
 303   }
 304
 305   c = start_command(commandline, child);
 306
 307   /* Return a pointer to the started process, so that the caller can
 308      wait for the process to complete. */
 309   if(c != NULL && started_process != NULL) {
 310     *started_process = c->process;
 311     if(background) {
 312       return SHELL_BACKGROUND;
 313     } else {
 314       return SHELL_FOREGROUND;
 315     }
 316   }
 317   return SHELL_NOTHING;
 318 }
 319 /*---------------------------------------------------------------------------*/
 320 static void
 321 input_to_child_command(struct shell_command *c,
 322                        char *data1, int len1,
 323                        const char *data2, int len2)
 324 {
 325   struct shell_input input;
 326   if(process_is_running(c->process)) {
 327     input.data1 = data1;
 328     input.len1 = len1;
 329     input.data2 = data2;
 330     input.len2 = len2;
 331     process_post_synch(c->process, shell_event_input, &input);
 332   }
 333 }
 334 /*---------------------------------------------------------------------------*/
 335 void
 336 shell_input(char *commandline, int commandline_len)
 337 {
 338   struct shell_input input;
 339
 340   /*  printf("shell_input front_process '%s'\n", front_process->name);*/
 341
 342   if(commandline[0] == '~' &&
 343      commandline[1] == 'K') {
 344     /*    process_start(&shell_killall_process, commandline);*/
 345     if(front_process != &shell_process) {
 346       process_exit(front_process);
 347     }
 348   } else {
 349     if(process_is_running(front_process)) {
 350       input.data1 = commandline;
 351       input.len1 = commandline_len;
 352       input.data2 = "";
 353       input.len2 = 0;
 354       process_post_synch(front_process, shell_event_input, &input);
 355     }
 356   }
 357 }
 358 /*---------------------------------------------------------------------------*/
 359 void
 360 shell_output_str(struct shell_command *c, char *text1, const char *text2)
 361 {
 362   if(c != NULL && c->child != NULL) {
 363     input_to_child_command(c->child, text1, (int)strlen(text1),
 364                            text2, (int)strlen(text2));
 365   } else {
 366     shell_default_output(text1, (int)strlen(text1),
 367                          text2, (int)strlen(text2));
 368   }
 369 }
 370 /*---------------------------------------------------------------------------*/
 371 void
 372 shell_output(struct shell_command *c,
 373              void *data1, int len1,
 374              const void *data2, int len2)
 375 {
 376   if(c != NULL && c->child != NULL) {
 377     input_to_child_command(c->child, data1, len1, data2, len2);
 378   } else {
 379     shell_default_output(data1, len1, data2, len2);
 380   }
 381 }
 382 /*---------------------------------------------------------------------------*/
 383 void
 384 shell_unregister_command(struct shell_command *c)
 385 {
 386   list_remove(commands, c);
 387 }
 388 /*---------------------------------------------------------------------------*/
 389 void
 390 shell_register_command(struct shell_command *c)
 391 {
 392   struct shell_command *i, *p;
 393
 394   p = NULL;
 395   for(i = list_head(commands);
 396       i != NULL &&
 397         strcmp(i->command, c->command) < 0;
 398       i = i->next) {
 399     p = i;
 400   }
 401   if(p == NULL) {
 402     list_push(commands, c);
 403   } else if(i == NULL) {
 404     list_add(commands, c);
 405   } else {
 406     list_insert(commands, p, c);
 407   }
 408 }
 409 /*---------------------------------------------------------------------------*/
 410 PROCESS_THREAD(shell_process, ev, data)
 411 {
 412   static struct process *started_process;
 413   PROCESS_BEGIN();
 414
 415   /* Let the system start up before showing the prompt. */
 416   PROCESS_PAUSE();
 417
 418   while(1) {
 419     shell_prompt("Contiki> ");
 420
 421     PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
 422     {
 423       struct shell_input *input = data;
 424       int ret;
 425
 426       ret = shell_start_command(input->data1, input->len1, NULL,
 427                                 &started_process);
 428
 429       if(started_process != NULL &&
 430          ret == SHELL_FOREGROUND &&
 431          process_is_running(started_process)) {
 432         front_process = started_process;
 433         PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_EXITED &&
 434                                  data == started_process);
 435       }
 436       front_process = &shell_process;
 437     }
 438   }
 439
 440   PROCESS_END();
 441 }
 442 /*---------------------------------------------------------------------------*/
 443 PROCESS_THREAD(shell_server_process, ev, data)
 444 {
 445   struct process *p;
 446   struct shell_command *c;
 447   static struct etimer etimer;
 448   PROCESS_BEGIN();
 449
 450   etimer_set(&etimer, CLOCK_SECOND * 10);
 451   while(1) {
 452     PROCESS_WAIT_EVENT();
 453     if(ev == PROCESS_EVENT_EXITED) {
 454       p = data;
 455       /*      printf("process exited '%s' (front '%s')\n", p->name,
 456               front_process->name);*/
 457       for(c = list_head(commands);
 458           c != NULL && c->process != p;
 459           c = c->next);
 460       while(c != NULL) {
 461         if(c->child != NULL && c->child->process != NULL) {
 462           /*      printf("Killing '%s'\n", c->process->name);*/
 463           input_to_child_command(c->child, "", 0, "", 0);
 464           /*      process_exit(c->process);*/
 465         }
 466         c = c->child;
 467       }
 468     } else if(ev == PROCESS_EVENT_TIMER) {
 469       etimer_reset(&etimer);
 470       shell_set_time(shell_time());
 471     }
 472   }
 473
 474   PROCESS_END();
 475 }
 476 /*---------------------------------------------------------------------------*/
 477 void
 478 shell_init(void)
 479 {
 480   list_init(commands);
 481   shell_register_command(&help_command);
 482   shell_register_command(&question_command);
 483   shell_register_command(&killall_command);
 484   shell_register_command(&kill_command);
 485   shell_register_command(&null_command);
 486
 487   shell_event_input = process_alloc_event();
 488
 489   process_start(&shell_process, NULL);
 490   process_start(&shell_server_process, NULL);
 491
 492   front_process = &shell_process;
 493 }
 494 /*---------------------------------------------------------------------------*/
 495 unsigned long
 496 shell_strtolong(const char *str, const char **retstr)
 497 {
 498   int i;
 499   unsigned long num = 0;
 500   const char *strptr = str;
 501
 502   if(str == NULL) {
 503     return 0;
 504   }
 505
 506   while(*strptr == ' ') {
 507     ++strptr;
 508   }
 509
 510   for(i = 0; i < 10 && isdigit(strptr[i]); ++i) {
 511     num = num * 10 + strptr[i] - '0';
 512   }
 513   if(retstr != NULL) {
 514     if(i == 0) {
 515       *retstr = str;
 516     } else {
 517       *retstr = strptr + i;
 518     }
 519   }
 520
 521   return num;
 522 }
 523 /*---------------------------------------------------------------------------*/
 524 unsigned long
 525 shell_time(void)
 526 {
 527   return clock_seconds() + time_offset;
 528 }
 529 /*---------------------------------------------------------------------------*/
 530 void
 531 shell_set_time(unsigned long seconds)
 532 {
 533   time_offset = seconds - clock_seconds();
 534 }
 535 /*---------------------------------------------------------------------------*/
 536 void
 537 shell_start(void)
 538 {
 539   shell_output_str(NULL, "Contiki command shell", "");
 540   shell_output_str(NULL, "Type '?' and return for help", "");
 541   shell_prompt("Contiki> ");
 542 }
 543 /*---------------------------------------------------------------------------*/
 544 void
 545 shell_quit(void)
 546 {
 547   killall();
 548   process_exit(&shell_process);
 549   process_exit(&shell_server_process);
 550 }
 551 /*---------------------------------------------------------------------------*/
 552
 553 /** @} */