1 /* ----------------------------------------------------------------------- * 2 * 3 * Copyright 2008-2011 Gene Cumm - All Rights Reserved 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation, Inc., 53 Temple Place Ste 330, 8 * Boston MA 02111-1307, USA; either version 2 of the License, or 9 * (at your option) any later version; incorporated herein by reference. 10 * 11 * ----------------------------------------------------------------------- */ 12 13 /* 14 * rosh.c 15 * 16 * Read-Only shell; Simple shell system designed for SYSLINUX-derivitives. 17 * Provides minimal commands utilizing the console via stdout/stderr as the 18 * sole output devices. Designed to compile for Linux for testing/debugging. 19 */ 20 21 /* 22 * ToDos: 23 * prompt: Allow left/right arrow, home/end and more? 24 * commands Break into argv/argc-like array 25 * rosh_cfg: allow -s <file> to change config 26 * rosh_ls(): sorted; then multiple columns 27 * prompt: Possibly honor timeout on initial entry for usage as UI 28 * Also possibly honor totaltimeout 29 */ 30 31 /*#define DO_DEBUG 1 32 //*/ 33 /* Uncomment the above line for debugging output; Comment to remove */ 34 /*#define DO_DEBUG2 1 35 //*/ 36 /* Uncomment the above line for super-debugging output; Must have regular 37 * debugging enabled; Comment to remove. 38 */ 39 #include "rosh.h" 40 #include "version.h" 41 42 #define APP_LONGNAME "Read-Only Shell" 43 #define APP_NAME "rosh" 44 #define APP_AUTHOR "Gene Cumm" 45 #define APP_YEAR "2010" 46 #define APP_VER "beta-b090" 47 48 /* Print version information to stdout 49 */ 50 void rosh_version(int vtype) 51 { 52 char env[256]; 53 env[0] = 0; 54 printf("%s v %s; (c) %s %s.\n\tFrom Syslinux %s, %s\n", APP_LONGNAME, APP_VER, APP_YEAR, APP_AUTHOR, VERSION_STR, DATE); 55 switch (vtype) { 56 case 1: 57 rosh_get_env_ver(env, 256); 58 printf("\tRunning on %s\n", env); 59 } 60 } 61 62 /* Print beta message and if DO_DEBUG/DO_DEBUG2 are active 63 */ 64 void print_beta(void) 65 { 66 puts(rosh_beta_str); 67 ROSH_DEBUG("DO_DEBUG active\n"); 68 ROSH_DEBUG2("DO_DEBUG2 active\n"); 69 } 70 71 /* Search a string for first non-space (' ') character, starting at ipos 72 * istr input string to parse 73 * ipos input position to start at 74 */ 75 int rosh_search_nonsp(const char *istr, const int ipos) 76 { 77 int curpos; 78 char c; 79 80 curpos = ipos; 81 c = istr[curpos]; 82 while (c && isspace(c)) 83 c = istr[++curpos]; 84 return curpos; 85 } 86 87 /* Search a string for space (' '), returning the position of the next space 88 * or the '\0' at end of string 89 * istr input string to parse 90 * ipos input position to start at 91 */ 92 int rosh_search_sp(const char *istr, const int ipos) 93 { 94 int curpos; 95 char c; 96 97 curpos = ipos; 98 c = istr[curpos]; 99 while (c && !(isspace(c))) 100 c = istr[++curpos]; 101 return curpos; 102 } 103 104 /* Parse a string for the first non-space string, returning the end position 105 * from src 106 * dest string to contain the first non-space string 107 * src string to parse 108 * ipos Position to start in src 109 */ 110 int rosh_parse_sp_1(char *dest, const char *src, const int ipos) 111 { 112 int bpos, epos; /* beginning and ending position of source string 113 to copy to destination string */ 114 115 bpos = 0; 116 epos = 0; 117 /* //HERE-error condition checking */ 118 bpos = rosh_search_nonsp(src, ipos); 119 epos = rosh_search_sp(src, bpos); 120 if (epos > bpos) { 121 memcpy(dest, src + bpos, epos - bpos); 122 if (dest[epos - bpos] != 0) 123 dest[epos - bpos] = 0; 124 } else { 125 epos = strlen(src); 126 dest[0] = 0; 127 } 128 return epos; 129 } 130 131 /* 132 * parse_args1: Try 1 at parsing a string to an argc/argv pair. use free_args1 to free memory malloc'd 133 * 134 * Derived from com32/lib/sys/argv.c:__parse_argv() 135 * Copyright 2004-2009 H. Peter Anvin - All Rights Reserved 136 * Copyright 2009 Intel Corporation; author: H. Peter Anvin 137 */ 138 int parse_args1(char ***iargv, const char *istr) 139 { 140 int argc = 0; 141 const char *p; 142 char *q, *r, *args, **arg; 143 int sp = 1; //, qt = 0; /* Was a space; inside a quote */ 144 145 /* Scan 1: Length */ 146 /* I could eliminate this if I knew a max length, like strncpy() */ 147 int len = strlen(istr); 148 149 /* Scan 2: Copy, nullify and make argc */ 150 if (!(args = malloc(len + 1))) 151 goto fail_args; 152 q = args; 153 for (p = istr;; p++) { 154 if (*p <= ' ') { 155 if (!sp) { 156 sp = 1; 157 *q++ = '\0'; 158 } 159 } else { 160 if (sp) { 161 argc++; 162 sp = 0; 163 } 164 *q++ = *p; 165 } 166 if (!*p) 167 break; 168 } 169 170 q--; /* Point q to final null */ 171 /* Scan 3: Build array of pointers */ 172 if (!(*iargv = malloc((argc + 1) * sizeof(char *)))) 173 goto fail_args_ptr; 174 arg = *iargv; 175 arg[argc] = NULL; /* Nullify the last pointer */ 176 if (*args != '\0') 177 *arg++ = args; 178 for (r = args; r < q ; r++) { 179 if (*r == '\0') { 180 *arg++ = r + 1; 181 } 182 } 183 184 fail_args: 185 return argc; 186 fail_args_ptr: 187 free(args); 188 return 0; 189 } 190 191 /* Free argv created by parse_args1() 192 * argv Argument Values 193 */ 194 void free_args1(char ***argv) 195 { 196 char *s; 197 s = **argv; 198 free(*argv); 199 free(s); 200 } 201 202 /* Convert a string to an argc/argv pair 203 * str String to parse 204 * argv Argument Values 205 * returns Argument Count 206 */ 207 int rosh_str2argv(char ***argv, const char *str) 208 { 209 return parse_args1(argv, str); 210 } 211 212 /* Free an argv created by rosh_str2argv() 213 * argv Argument Values to free 214 */ 215 void rosh_free_argv(char ***argv) 216 { 217 free_args1(argv); 218 } 219 220 /* Print the contents of an argc/argv pair 221 * argc Argument Count 222 * argv Argument Values 223 */ 224 void rosh_pr_argv(int argc, char *argv[]) 225 { 226 int i; 227 for (i = 0; i < argc; i++) { 228 printf("%s%s", argv[i], (i < argc)? " " : ""); 229 } 230 puts(""); 231 } 232 233 /* Print the contents of an argc/argv pair verbosely 234 * argc Argument Count 235 * argv Argument Values 236 */ 237 void rosh_pr_argv_v(int argc, char *argv[]) 238 { 239 int i; 240 for (i = 0; i < argc; i++) { 241 printf("%4d '%s'\n", i, argv[i]); 242 } 243 } 244 245 /* Reset the getopt() environment 246 */ 247 void rosh_getopt_reset(void) 248 { 249 optind = 0; 250 optopt = 0; 251 } 252 253 /* Display help 254 * type Help type 255 * cmdstr Command for which help is requested 256 */ 257 void rosh_help(int type, const char *cmdstr) 258 { 259 switch (type) { 260 case 2: 261 if ((cmdstr == NULL) || (strcmp(cmdstr, "") == 0)) { 262 rosh_version(0); 263 puts(rosh_help_str2); 264 } else { 265 switch (cmdstr[0]) { 266 case 'c': 267 puts(rosh_help_cd_str); 268 break; 269 case 'l': 270 puts(rosh_help_ls_str); 271 break; 272 default: 273 printf(rosh_help_str_adv, cmdstr); 274 } 275 } 276 break; 277 case 1: 278 default: 279 if (cmdstr) 280 printf("%s: %s: unknown command\n", APP_NAME, cmdstr); 281 rosh_version(0); 282 puts(rosh_help_str1); 283 } 284 } 285 286 /* Handle most/all errors 287 * ierrno Input Error number 288 * cmdstr Command being executed to cause error 289 * filestr File/parameter causing error 290 */ 291 void rosh_error(const int ierrno, const char *cmdstr, const char *filestr) 292 { 293 printf("--ERROR: %s '%s': ", cmdstr, filestr); 294 switch (ierrno) { 295 case 0: 296 puts("NO ERROR"); 297 break; 298 case ENOENT: 299 puts("not found"); 300 /* SYSLinux-3.72 COM32 API returns this for a 301 directory or empty file */ 302 ROSH_COM32(" (COM32) could be a directory or empty file\n"); 303 break; 304 case EIO: 305 puts("I/O Error"); 306 break; 307 case EBADF: 308 puts("Bad File Descriptor"); 309 break; 310 case EACCES: 311 puts("Access DENIED"); 312 break; 313 case ENOTDIR: 314 puts("not a directory"); 315 ROSH_COM32(" (COM32) could be directory\n"); 316 break; 317 case EISDIR: 318 puts("IS a directory"); 319 break; 320 case ENOSYS: 321 puts("not implemented"); 322 break; 323 default: 324 printf("returns error; errno=%d\n", ierrno); 325 } 326 } /* rosh_error */ 327 328 /* Concatenate command line arguments into one string 329 * cmdstr Output command string 330 * cmdlen Length of cmdstr 331 * argc Argument Count 332 * argv Argument Values 333 * barg Beginning Argument 334 */ 335 int rosh_argcat(char *cmdstr, const int cmdlen, const int argc, char *argv[], 336 const int barg) 337 { 338 int i, arglen, curpos; /* index, argument length, current position 339 in cmdstr */ 340 curpos = 0; 341 cmdstr[0] = '\0'; /* Nullify string just to be sure */ 342 for (i = barg; i < argc; i++) { 343 arglen = strlen(argv[i]); 344 /* Theoretically, this should never be met in SYSLINUX */ 345 if ((curpos + arglen) > (cmdlen - 1)) 346 arglen = (cmdlen - 1) - curpos; 347 memcpy(cmdstr + curpos, argv[i], arglen); 348 curpos += arglen; 349 if (curpos >= (cmdlen - 1)) { 350 /* Hopefully, curpos should not be greater than 351 (cmdlen - 1) */ 352 /* Still need a '\0' at the last character */ 353 cmdstr[(cmdlen - 1)] = 0; 354 break; /* Escape out of the for() loop; 355 We can no longer process anything more */ 356 } else { 357 cmdstr[curpos] = ' '; 358 curpos += 1; 359 cmdstr[curpos] = 0; 360 } 361 } 362 /* If there's a ' ' at the end, remove it. This is normal unless 363 the maximum length is met/exceeded. */ 364 if (cmdstr[curpos - 1] == ' ') 365 cmdstr[--curpos] = 0; 366 return curpos; 367 } /* rosh_argcat */ 368 369 /* 370 * Prints a lot of the data in a struct termios 371 */ 372 /* 373 void rosh_print_tc(struct termios *tio) 374 { 375 printf(" -- termios: "); 376 printf(".c_iflag=%04X ", tio->c_iflag); 377 printf(".c_oflag=%04X ", tio->c_oflag); 378 printf(".c_cflag=%04X ", tio->c_cflag); 379 printf(".c_lflag=%04X ", tio->c_lflag); 380 printf(".c_cc[VTIME]='%d' ", tio->c_cc[VTIME]); 381 printf(".c_cc[VMIN]='%d'", tio->c_cc[VMIN]); 382 printf("\n"); 383 } 384 */ 385 386 /* 387 * Attempts to get a single key from the console 388 * returns key pressed 389 */ 390 int rosh_getkey(void) 391 { 392 int inc; 393 394 inc = KEY_NONE; 395 while (inc == KEY_NONE) 396 inc = get_key(stdin, 6000); 397 return inc; 398 } /* rosh_getkey */ 399 400 /* 401 * Qualifies a filename relative to the working directory 402 * filestr Filename to qualify 403 * pwdstr working directory 404 * returns qualified file name string 405 */ 406 void rosh_qualify_filestr(char *filestr, const char *ifilstr, 407 const char *pwdstr) 408 { 409 int filepos = 0; 410 if ((filestr) && (pwdstr) && (ifilstr)) { 411 if (ifilstr[0] != SEP) { 412 strcpy(filestr, pwdstr); 413 filepos = strlen(pwdstr); 414 if (filestr[filepos - 1] != SEP) 415 filestr[filepos++] = SEP; 416 } 417 strcpy(filestr + filepos, ifilstr); 418 ROSH_DEBUG("--'%s'\n", filestr); 419 } 420 } 421 422 /* Concatenate multiple files to stdout 423 * argc Argument Count 424 * argv Argument Values 425 */ 426 void rosh_cat(int argc, char *argv[]) 427 { 428 FILE *f; 429 char buf[ROSH_BUF_SZ]; 430 int i, numrd; 431 432 for (i = 0; i < argc; i++) { 433 printf("--File = '%s'\n", argv[i]); 434 errno = 0; 435 f = fopen(argv[i], "r"); 436 if (f != NULL) { 437 numrd = fread(buf, 1, ROSH_BUF_SZ, f); 438 while (numrd > 0) { 439 fwrite(buf, 1, numrd, stdout); 440 numrd = fread(buf, 1, ROSH_BUF_SZ, f); 441 } 442 fclose(f); 443 } else { 444 rosh_error(errno, "cat", argv[i]); 445 errno = 0; 446 } 447 } 448 } /* rosh_cat */ 449 450 /* Change PWD (Present Working Directory) 451 * argc Argument count 452 * argv Argument values 453 * ipwdstr Initial PWD 454 */ 455 void rosh_cd(int argc, char *argv[], const char *ipwdstr) 456 { 457 int rv = 0; 458 #ifdef DO_DEBUG 459 char filestr[ROSH_PATH_SZ]; 460 #endif /* DO_DEBUG */ 461 ROSH_DEBUG("CMD: \n"); 462 ROSH_DEBUG_ARGV_V(argc, argv); 463 errno = 0; 464 if (argc == 2) 465 rv = chdir(argv[1]); 466 else if (argc == 1) 467 rv = chdir(ipwdstr); 468 else 469 rosh_help(2, argv[0]); 470 if (rv != 0) { 471 if (argc == 2) 472 rosh_error(errno, "cd", argv[1]); 473 else 474 rosh_error(errno, "cd", ipwdstr); 475 errno = 0; 476 } else { 477 #ifdef DO_DEBUG 478 if (getcwd(filestr, ROSH_PATH_SZ)) 479 ROSH_DEBUG(" %s\n", filestr); 480 #endif /* DO_DEBUG */ 481 } 482 } /* rosh_cd */ 483 484 /* Print the syslinux config file name 485 */ 486 void rosh_cfg(void) 487 { 488 printf("CFG: '%s'\n", syslinux_config_file()); 489 } /* rosh_cfg */ 490 491 /* Echo a string back to the screen 492 * cmdstr command string to process 493 */ 494 void rosh_echo(const char *cmdstr) 495 { 496 int bpos = 0; 497 ROSH_DEBUG("CMD: '%s'\n", cmdstr); 498 bpos = rosh_search_nonsp(cmdstr, rosh_search_sp(cmdstr, 0)); 499 if (bpos > 1) { 500 ROSH_DEBUG(" bpos=%d\n", bpos); 501 printf("'%s'\n", cmdstr + bpos); 502 } else { 503 puts(""); 504 } 505 } /* rosh_echo */ 506 507 /* Process argc/argv to optarr 508 * argc Argument count 509 * argv Argument values 510 * optarr option array to populate 511 */ 512 void rosh_ls_arg_opt(int argc, char *argv[], int optarr[]) 513 { 514 int rv = 0; 515 516 optarr[0] = -1; 517 optarr[1] = -1; 518 optarr[2] = -1; 519 rosh_getopt_reset(); 520 while (rv != -1) { 521 ROSH_DEBUG2("getopt optind=%d rv=%d\n", optind, rv); 522 rv = getopt(argc, argv, rosh_ls_opt_str); 523 switch (rv) { 524 case 'l': 525 case 0: 526 optarr[0] = 1; 527 break; 528 case 'F': 529 case 1: 530 optarr[1] = 1; 531 break; 532 case 'i': 533 case 2: 534 optarr[2] = 1; 535 break; 536 case '?': 537 case -1: 538 default: 539 ROSH_DEBUG2("getopt optind=%d rv=%d\n", optind, rv); 540 break; 541 } 542 } 543 ROSH_DEBUG2(" end getopt optind=%d rv=%d\n", optind, rv); 544 ROSH_DEBUG2("\tIn rosh_ls_arg_opt() opt[0]=%d\topt[1]=%d\topt[2]=%d\n", optarr[0], optarr[1], 545 optarr[2]); 546 } /* rosh_ls_arg_opt */ 547 548 /* Retrieve the size of a file argument 549 * filestr directory name of directory entry 550 * de directory entry 551 */ 552 int rosh_ls_de_size(const char *filestr, struct dirent *de) 553 { 554 int de_size; 555 char filestr2[ROSH_PATH_SZ]; 556 int fd2, file2pos; 557 struct stat fdstat; 558 559 filestr2[0] = 0; 560 file2pos = -1; 561 if (filestr) { 562 file2pos = strlen(filestr); 563 memcpy(filestr2, filestr, file2pos); 564 filestr2[file2pos] = '/'; 565 } 566 strcpy(filestr2 + file2pos + 1, de->d_name); 567 fd2 = open(filestr2, O_RDONLY); 568 fstat(fd2, &fdstat); 569 fd2 = close(fd2); 570 de_size = (int)fdstat.st_size; 571 return de_size; 572 } /* rosh_ls_de_size */ 573 574 /* Retrieve the size and mode of a file 575 * filestr directory name of directory entry 576 * de directory entry 577 */ 578 int rosh_ls_de_size_mode(const char *filestr, struct dirent *de, mode_t * st_mode) 579 { 580 int de_size; 581 char filestr2[ROSH_PATH_SZ]; 582 int file2pos; 583 struct stat fdstat; 584 int status; 585 586 filestr2[0] = 0; 587 file2pos = -1; 588 memset(&fdstat, 0, sizeof fdstat); 589 ROSH_DEBUG2("ls:dsm(%s, %s) ", filestr, de->d_name); 590 if (filestr) { 591 /* FIXME: prevent string overflow */ 592 file2pos = strlen(filestr); 593 memcpy(filestr2, filestr, file2pos); 594 if (( filestr2[file2pos - 1] == SEP )) { 595 file2pos--; 596 } else { 597 filestr2[file2pos] = SEP; 598 } 599 } 600 strcpy(filestr2 + file2pos + 1, de->d_name); 601 errno = 0; 602 ROSH_DEBUG2("stat(%s) ", filestr2); 603 status = stat(filestr2, &fdstat); 604 (void)status; 605 ROSH_DEBUG2("\t--stat()=%d\terr=%d\n", status, errno); 606 if (errno) { 607 rosh_error(errno, "ls:szmd.stat", de->d_name); 608 errno = 0; 609 } 610 de_size = (int)fdstat.st_size; 611 *st_mode = fdstat.st_mode; 612 return de_size; 613 } /* rosh_ls_de_size_mode */ 614 615 /* Returns the Inode number if fdstat contains it 616 * fdstat struct to extract inode from if not COM32, for now 617 */ 618 long rosh_ls_d_ino(struct stat *fdstat) 619 { 620 long de_ino; 621 #ifdef __COM32__ 622 if (fdstat) 623 de_ino = -1; 624 else 625 de_ino = 0; 626 #else /* __COM32__ */ 627 de_ino = fdstat->st_ino; 628 #endif /* __COM32__ */ 629 return de_ino; 630 } 631 632 /* Convert a d_type to a single char in human readable format 633 * d_type d_type to convert 634 * returns human readable single character; a space if other 635 */ 636 char rosh_d_type2char_human(unsigned char d_type) 637 { 638 char ret; 639 switch (d_type) { 640 case DT_UNKNOWN: 641 ret = 'U'; 642 break; /* Unknown */ 643 case DT_FIFO: 644 ret = 'F'; 645 break; /* FIFO */ 646 case DT_CHR: 647 ret = 'C'; 648 break; /* Char Dev */ 649 case DT_DIR: 650 ret = 'D'; 651 break; /* Directory */ 652 case DT_BLK: 653 ret = 'B'; 654 break; /* Block Dev */ 655 case DT_REG: 656 ret = 'R'; 657 break; /* Regular File */ 658 case DT_LNK: 659 ret = 'L'; 660 break; /* Link, Symbolic */ 661 case DT_SOCK: 662 ret = 'S'; 663 break; /* Socket */ 664 case DT_WHT: 665 ret = 'W'; 666 break; /* UnionFS Whiteout */ 667 default: 668 ret = ' '; 669 } 670 return ret; 671 } /* rosh_d_type2char_human */ 672 673 /* Convert a d_type to a single char by ls's prefix standards for -l 674 * d_type d_type to convert 675 * returns ls style single character; a space if other 676 */ 677 char rosh_d_type2char_lspre(unsigned char d_type) 678 { 679 char ret; 680 switch (d_type) { 681 case DT_FIFO: 682 ret = 'p'; 683 break; 684 case DT_CHR: 685 ret = 'c'; 686 break; 687 case DT_DIR: 688 ret = 'd'; 689 break; 690 case DT_BLK: 691 ret = 'b'; 692 break; 693 case DT_REG: 694 ret = '-'; 695 break; 696 case DT_LNK: 697 ret = 'l'; 698 break; 699 case DT_SOCK: 700 ret = 's'; 701 break; 702 default: 703 ret = '?'; 704 } 705 return ret; 706 } /* rosh_d_type2char_lspre */ 707 708 /* Convert a d_type to a single char by ls's classify (-F) suffix standards 709 * d_type d_type to convert 710 * returns ls style single character; a space if other 711 */ 712 char rosh_d_type2char_lssuf(unsigned char d_type) 713 { 714 char ret; 715 switch (d_type) { 716 case DT_FIFO: 717 ret = '|'; 718 break; 719 case DT_DIR: 720 ret = '/'; 721 break; 722 case DT_LNK: 723 ret = '@'; 724 break; 725 case DT_SOCK: 726 ret = '='; 727 break; 728 default: 729 ret = ' '; 730 } 731 return ret; 732 } /* rosh_d_type2char_lssuf */ 733 734 /* Converts data in the "other" place of st_mode to a ls-style string 735 * st_mode Mode in other to analyze 736 * st_mode_str string to hold converted string 737 */ 738 void rosh_st_mode_am2str(mode_t st_mode, char *st_mode_str) 739 { 740 st_mode_str[0] = ((st_mode & S_IROTH) ? 'r' : '-'); 741 st_mode_str[1] = ((st_mode & S_IWOTH) ? 'w' : '-'); 742 st_mode_str[2] = ((st_mode & S_IXOTH) ? 'x' : '-'); 743 } 744 745 /* Converts st_mode to an ls-style string 746 * st_mode mode to convert 747 * st_mode_str string to hold converted string 748 */ 749 void rosh_st_mode2str(mode_t st_mode, char *st_mode_str) 750 { 751 st_mode_str[0] = rosh_d_type2char_lspre(IFTODT(st_mode)); 752 rosh_st_mode_am2str((st_mode & S_IRWXU) >> 6, st_mode_str + 1); 753 rosh_st_mode_am2str((st_mode & S_IRWXG) >> 3, st_mode_str + 4); 754 rosh_st_mode_am2str(st_mode & S_IRWXO, st_mode_str + 7); 755 st_mode_str[10] = 0; 756 } /* rosh_st_mode2str */ 757 758 /* Output a single entry 759 * filestr directory name to list 760 * de directory entry 761 * optarr Array of options 762 */ 763 void rosh_ls_arg_dir_de(const char *filestr, struct dirent *de, const int *optarr) 764 { 765 int de_size; 766 mode_t st_mode; 767 char st_mode_str[11]; 768 st_mode = 0; 769 ROSH_DEBUG2("+"); 770 if (optarr[2] > -1) 771 printf("%10d ", (int)(de->d_ino)); 772 if (optarr[0] > -1) { 773 de_size = rosh_ls_de_size_mode(filestr, de, &st_mode); 774 rosh_st_mode2str(st_mode, st_mode_str); 775 ROSH_DEBUG2("%04X ", st_mode); 776 printf("%s %10d ", st_mode_str, de_size); 777 } 778 ROSH_DEBUG("'"); 779 printf("%s", de->d_name); 780 ROSH_DEBUG("'"); 781 if (optarr[1] > -1) 782 printf("%c", rosh_d_type2char_lssuf(de->d_type)); 783 printf("\n"); 784 } /* rosh_ls_arg_dir_de */ 785 786 /* Output listing of a regular directory 787 * filestr directory name to list 788 * d the open DIR 789 * optarr Array of options 790 NOTE:This is where I could use qsort 791 */ 792 void rosh_ls_arg_dir(const char *filestr, DIR * d, const int *optarr) 793 { 794 struct dirent *de; 795 int filepos; 796 797 filepos = 0; 798 errno = 0; 799 while ((de = readdir(d))) { 800 filepos++; 801 rosh_ls_arg_dir_de(filestr, de, optarr); 802 } 803 if (errno) { 804 rosh_error(errno, "ls:arg_dir", filestr); 805 errno = 0; 806 } else { if (filepos == 0) 807 ROSH_DEBUG("0 files found"); 808 } 809 } /* rosh_ls_arg_dir */ 810 811 /* Simple directory listing for one argument (file/directory) based on 812 * filestr and pwdstr 813 * ifilstr input filename/directory name to list 814 * pwdstr Present Working Directory string 815 * optarr Option Array 816 */ 817 void rosh_ls_arg(const char *filestr, const int *optarr) 818 { 819 struct stat fdstat; 820 int status; 821 // char filestr[ROSH_PATH_SZ]; 822 // int filepos; 823 DIR *d; 824 struct dirent de; 825 826 /* Initialization; make filestr based on leading character of ifilstr 827 and pwdstr */ 828 // rosh_qualify_filestr(filestr, ifilstr, pwdstr); 829 fdstat.st_mode = 0; 830 fdstat.st_size = 0; 831 ROSH_DEBUG("\topt[0]=%d\topt[1]=%d\topt[2]=%d\n", optarr[0], optarr[1], 832 optarr[2]); 833 834 /* Now, the real work */ 835 errno = 0; 836 status = stat(filestr, &fdstat); 837 if (status == 0) { 838 if (S_ISDIR(fdstat.st_mode)) { 839 ROSH_DEBUG("PATH '%s' is a directory\n", filestr); 840 if ((d = opendir(filestr))) { 841 rosh_ls_arg_dir(filestr, d, optarr); 842 closedir(d); 843 } else { 844 rosh_error(errno, "ls", filestr); 845 errno = 0; 846 } 847 } else { 848 de.d_ino = rosh_ls_d_ino(&fdstat); 849 de.d_type = (IFTODT(fdstat.st_mode)); 850 strcpy(de.d_name, filestr); 851 if (S_ISREG(fdstat.st_mode)) { 852 ROSH_DEBUG("PATH '%s' is a regular file\n", filestr); 853 } else { 854 ROSH_DEBUG("PATH '%s' is some other file\n", filestr); 855 } 856 rosh_ls_arg_dir_de(NULL, &de, optarr); 857 /* if (ifilstr[0] == SEP) 858 rosh_ls_arg_dir_de(NULL, &de, optarr); 859 else 860 rosh_ls_arg_dir_de(pwdstr, &de, optarr);*/ 861 } 862 } else { 863 rosh_error(errno, "ls", filestr); 864 errno = 0; 865 } 866 return; 867 } /* rosh_ls_arg */ 868 869 /* Parse options that may be present in the cmdstr 870 * filestr Possible option string to parse 871 * optstr Current options 872 * returns 1 if filestr does not begin with '-' else 0 873 */ 874 int rosh_ls_parse_opt(const char *filestr, char *optstr) 875 { 876 int ret; 877 if (filestr[0] == '-') { 878 ret = 0; 879 if (optstr) 880 strcat(optstr, filestr + 1); 881 } else { 882 ret = 1; 883 } 884 ROSH_DEBUG("ParseOpt: '%s'\n\topt: '%s'\n\tret: %d\n", filestr, optstr, 885 ret); 886 return ret; 887 } /* rosh_ls_parse_opt */ 888 889 /* List Directory 890 * argc Argument count 891 * argv Argument values 892 */ 893 void rosh_ls(int argc, char *argv[]) 894 { 895 int optarr[3]; 896 int i; 897 898 rosh_ls_arg_opt(argc, argv, optarr); 899 ROSH_DEBUG2("In ls()\n"); 900 ROSH_DEBUG2_ARGV_V(argc, argv); 901 #ifdef DO_DEBUG 902 optarr[0] = 2; 903 #endif /* DO_DEBUG */ 904 ROSH_DEBUG2(" argc=%d; optind=%d\n", argc, optind); 905 if (optind >= argc) 906 rosh_ls_arg(".", optarr); 907 for (i = optind; i < argc; i++) { 908 rosh_ls_arg(argv[i], optarr); 909 } 910 } /* rosh_ls */ 911 912 /* Simple directory listing; calls rosh_ls() 913 * argc Argument count 914 * argv Argument values 915 */ 916 void rosh_dir(int argc, char *argv[]) 917 { 918 ROSH_DEBUG(" dir implemented as ls\n"); 919 rosh_ls(argc, argv); 920 } /* rosh_dir */ 921 922 /* Page through a buffer string 923 * buf Buffer to page through 924 */ 925 void rosh_more_buf(char *buf, int buflen, int rows, int cols, char *scrbuf) 926 { 927 char *bufp, *bufeol, *bufeol2; /* Pointer to current and next 928 end-of-line position in buffer */ 929 int bufpos, bufcnt; /* current position, count characters */ 930 int inc; 931 int i, numln; /* Index, Number of lines */ 932 int elpl; /* Extra lines per line read */ 933 934 (void)cols; 935 936 bufpos = 0; 937 bufp = buf + bufpos; 938 bufeol = bufp; 939 numln = rows - 1; 940 ROSH_DEBUG("--(%d)\n", buflen); 941 while (bufpos < buflen) { 942 for (i = 0; i < numln; i++) { 943 bufeol2 = strchr(bufeol, '\n'); 944 if (bufeol2 == NULL) { 945 bufeol = buf + buflen; 946 i = numln; 947 } else { 948 elpl = ((bufeol2 - bufeol - 1) / cols); 949 if (elpl < 0) 950 elpl = 0; 951 i += elpl; 952 ROSH_DEBUG2(" %d/%d ", elpl, i+1); 953 /* If this will not push too much, use it */ 954 /* but if it's the first line, use it */ 955 /* //HERE: We should probably snip the line off */ 956 if ((i < numln) || (i == elpl)) 957 bufeol = bufeol2 + 1; 958 } 959 } 960 ROSH_DEBUG2("\n"); 961 bufcnt = bufeol - bufp; 962 printf("--(%d/%d @%d)\n", bufcnt, buflen, bufpos); 963 memcpy(scrbuf, bufp, bufcnt); 964 scrbuf[bufcnt] = 0; 965 printf("%s", scrbuf); 966 bufp = bufeol; 967 bufpos += bufcnt; 968 if (bufpos == buflen) 969 break; 970 inc = rosh_getkey(); 971 numln = 1; 972 switch (inc) { 973 case KEY_CTRL('c'): 974 case 'q': 975 case 'Q': 976 bufpos = buflen; 977 break; 978 case ' ': 979 numln = rows - 1; 980 } 981 } 982 } /* rosh_more_buf */ 983 984 /* Page through a single file using the open file stream 985 * fd File Descriptor 986 */ 987 void rosh_more_fd(int fd, int rows, int cols, char *scrbuf) 988 { 989 struct stat fdstat; 990 char *buf; 991 int bufpos; 992 int numrd; 993 FILE *f; 994 995 fstat(fd, &fdstat); 996 if (S_ISREG(fdstat.st_mode)) { 997 buf = malloc((int)fdstat.st_size); 998 if (buf != NULL) { 999 f = fdopen(fd, "r"); 1000 bufpos = 0; 1001 numrd = fread(buf, 1, (int)fdstat.st_size, f); 1002 while (numrd > 0) { 1003 bufpos += numrd; 1004 numrd = fread(buf + bufpos, 1, 1005 ((int)fdstat.st_size - bufpos), f); 1006 } 1007 fclose(f); 1008 rosh_more_buf(buf, bufpos, rows, cols, scrbuf); 1009 } 1010 } else { 1011 } 1012 1013 } /* rosh_more_fd */ 1014 1015 /* Page through a file like the more command 1016 * argc Argument Count 1017 * argv Argument Values 1018 */ 1019 void rosh_more(int argc, char *argv[]) 1020 { 1021 int fd, i; 1022 /* char filestr[ROSH_PATH_SZ]; 1023 int cmdpos;*/ 1024 int rows, cols; 1025 char *scrbuf; 1026 int ret; 1027 1028 ROSH_DEBUG_ARGV_V(argc, argv); 1029 ret = getscreensize(1, &rows, &cols); 1030 if (ret) { 1031 ROSH_DEBUG("getscreensize() fail(%d); fall back\n", ret); 1032 ROSH_DEBUG("\tROWS='%d'\tCOLS='%d'\n", rows, cols); 1033 /* If either fail, go under normal size, just in case */ 1034 if (!rows) 1035 rows = 20; 1036 if (!cols) 1037 cols = 75; 1038 } 1039 ROSH_DEBUG("\tUSE ROWS='%d'\tCOLS='%d'\n", rows, cols); 1040 /* 32 bit align beginning of row and over allocate */ 1041 scrbuf = malloc(rows * ((cols+3)&(INT_MAX - 3))); 1042 if (!scrbuf) 1043 return; 1044 1045 if (argc) { 1046 /* There is no need to mess up the console if we don't have a 1047 file */ 1048 rosh_console_raw(); 1049 for (i = 0; i < argc; i++) { 1050 printf("--File = '%s'\n", argv[i]); 1051 errno = 0; 1052 fd = open(argv[i], O_RDONLY); 1053 if (fd != -1) { 1054 rosh_more_fd(fd, rows, cols, scrbuf); 1055 close(fd); 1056 } else { 1057 rosh_error(errno, "more", argv[i]); 1058 errno = 0; 1059 } 1060 } 1061 rosh_console_std(); 1062 } 1063 free(scrbuf); 1064 } /* rosh_more */ 1065 1066 /* Page a file with rewind 1067 * argc Argument Count 1068 * argv Argument Values 1069 */ 1070 void rosh_less(int argc, char *argv[]) 1071 { 1072 printf(" less implemented as more (for now)\n"); 1073 rosh_more(argc, argv); 1074 } /* rosh_less */ 1075 1076 /* Show PWD 1077 */ 1078 void rosh_pwd(void) 1079 { 1080 char pwdstr[ROSH_PATH_SZ]; 1081 errno = 0; 1082 if (getcwd(pwdstr, ROSH_PATH_SZ)) { 1083 printf("%s\n", pwdstr); 1084 } else { 1085 rosh_error(errno, "pwd", ""); 1086 errno = 0; 1087 } 1088 } /* rosh_pwd */ 1089 1090 /* Reboot; use warm reboot if one of certain options set 1091 * argc Argument count 1092 * argv Argument values 1093 */ 1094 void rosh_reboot(int argc, char *argv[]) 1095 { 1096 int rtype = 0; 1097 if (argc) { 1098 /* For now, just use the first */ 1099 switch (argv[0][0]) { 1100 case '1': 1101 case 's': 1102 case 'w': 1103 rtype = 1; 1104 break; 1105 case '-': 1106 switch (argv[0][1]) { 1107 case '1': 1108 case 's': 1109 case 'w': 1110 rtype = 1; 1111 break; 1112 } 1113 break; 1114 } 1115 } 1116 syslinux_reboot(rtype); 1117 } /* rosh_reboot */ 1118 1119 /* Run a boot string, calling syslinux_run_command 1120 * argc Argument count 1121 * argv Argument values 1122 */ 1123 void rosh_run(int argc, char *argv[]) 1124 { 1125 char cmdstr[ROSH_CMD_SZ]; 1126 int len; 1127 1128 len = rosh_argcat(cmdstr, ROSH_CMD_SZ, argc, argv, 0); 1129 if (len) { 1130 printf("--run: '%s'\n", cmdstr); 1131 syslinux_run_command(cmdstr); 1132 } else { 1133 printf(APP_NAME ":run: No arguments\n"); 1134 } 1135 } /* rosh_run */ 1136 1137 /* Process an argc/argv pair and call handling function 1138 * argc Argument count 1139 * argv Argument values 1140 * ipwdstr Initial Present Working Directory string 1141 * returns Whether to exit prompt 1142 */ 1143 char rosh_command(int argc, char *argv[], const char *ipwdstr) 1144 { 1145 char do_exit = false; 1146 int tlen; 1147 tlen = strlen(argv[0]); 1148 ROSH_DEBUG_ARGV_V(argc, argv); 1149 switch (argv[0][0]) { 1150 case 'e': 1151 case 'E': 1152 case 'q': 1153 case 'Q': 1154 switch (argv[0][1]) { 1155 case 0: 1156 case 'x': 1157 case 'X': 1158 case 'u': 1159 case 'U': 1160 if ((strncasecmp("exit", argv[0], tlen) == 0) || 1161 (strncasecmp("quit", argv[0], tlen) == 0)) 1162 do_exit = true; 1163 else 1164 rosh_help(1, argv[0]); 1165 break; 1166 case 'c': 1167 case 'C': 1168 if (strncasecmp("echo", argv[0], tlen) == 0) 1169 rosh_pr_argv(argc - 1, &argv[1]); 1170 else 1171 rosh_help(1, argv[0]); 1172 break; 1173 default: 1174 rosh_help(1, argv[0]); 1175 } 1176 break; 1177 case 'c': 1178 case 'C': /* run 'cd' 'cat' 'cfg' */ 1179 switch (argv[0][1]) { 1180 case 'a': 1181 case 'A': 1182 if (strncasecmp("cat", argv[0], tlen) == 0) 1183 rosh_cat(argc - 1, &argv[1]); 1184 else 1185 rosh_help(1, argv[0]); 1186 break; 1187 case 'd': 1188 case 'D': 1189 if (strncasecmp("cd", argv[0], tlen) == 0) 1190 rosh_cd(argc, argv, ipwdstr); 1191 else 1192 rosh_help(1, argv[0]); 1193 break; 1194 case 'f': 1195 case 'F': 1196 if (strncasecmp("cfg", argv[0], tlen) == 0) 1197 rosh_cfg(); 1198 else 1199 rosh_help(1, argv[0]); 1200 break; 1201 default: 1202 rosh_help(1, argv[0]); 1203 } 1204 break; 1205 case 'd': 1206 case 'D': /* run 'dir' */ 1207 if (strncasecmp("dir", argv[0], tlen) == 0) 1208 rosh_dir(argc - 1, &argv[1]); 1209 else 1210 rosh_help(1, argv[0]); 1211 break; 1212 case 'h': 1213 case 'H': 1214 case '?': 1215 if ((strncasecmp("help", argv[0], tlen) == 0) || (tlen == 1)) 1216 rosh_help(2, argv[1]); 1217 else 1218 rosh_help(1, NULL); 1219 break; 1220 case 'l': 1221 case 'L': /* run 'ls' 'less' */ 1222 switch (argv[0][1]) { 1223 case 0: 1224 case 's': 1225 case 'S': 1226 if (strncasecmp("ls", argv[0], tlen) == 0) 1227 rosh_ls(argc, argv); 1228 else 1229 rosh_help(1, argv[0]); 1230 break; 1231 case 'e': 1232 case 'E': 1233 if (strncasecmp("less", argv[0], tlen) == 0) 1234 rosh_less(argc - 1, &argv[1]); 1235 else 1236 rosh_help(1, argv[0]); 1237 break; 1238 default: 1239 rosh_help(1, argv[0]); 1240 } 1241 break; 1242 case 'm': 1243 case 'M': 1244 switch (argv[0][1]) { 1245 case 'a': 1246 case 'A': 1247 if (strncasecmp("man", argv[0], tlen) == 0) 1248 rosh_help(2, argv[1]); 1249 else 1250 rosh_help(1, argv[0]); 1251 break; 1252 case 'o': 1253 case 'O': 1254 if (strncasecmp("more", argv[0], tlen) == 0) 1255 rosh_more(argc - 1, &argv[1]); 1256 else 1257 rosh_help(1, argv[0]); 1258 break; 1259 default: 1260 rosh_help(1, argv[0]); 1261 } 1262 break; 1263 case 'p': 1264 case 'P': /* run 'pwd' */ 1265 if (strncasecmp("pwd", argv[0], tlen) == 0) 1266 rosh_pwd(); 1267 else 1268 rosh_help(1, argv[0]); 1269 break; 1270 case 'r': 1271 case 'R': /* run 'run' */ 1272 switch (argv[0][1]) { 1273 case 0: 1274 case 'e': 1275 case 'E': 1276 if (strncasecmp("reboot", argv[0], tlen) == 0) 1277 rosh_reboot(argc - 1, &argv[1]); 1278 else 1279 rosh_help(1, argv[0]); 1280 break; 1281 case 'u': 1282 case 'U': 1283 if (strncasecmp("run", argv[0], tlen) == 0) 1284 rosh_run(argc - 1, &argv[1]); 1285 else 1286 rosh_help(1, argv[0]); 1287 break; 1288 default: 1289 rosh_help(1, argv[0]); 1290 } 1291 break; 1292 case 'v': 1293 case 'V': 1294 if (strncasecmp("version", argv[0], tlen) == 0) 1295 rosh_version(1); 1296 else 1297 rosh_help(1, argv[0]); 1298 break; 1299 case 0: 1300 case '\n': 1301 break; 1302 default: 1303 rosh_help(1, argv[0]); 1304 } /* switch(argv[0][0]) */ 1305 return do_exit; 1306 } /* rosh_command */ 1307 1308 /* Process the prompt for commands as read from stdin and call rosh_command 1309 * to process command line string 1310 * icmdstr Initial command line string 1311 * returns Exit status 1312 */ 1313 int rosh_prompt(int iargc, char *iargv[]) 1314 { 1315 int rv; 1316 char cmdstr[ROSH_CMD_SZ]; 1317 char ipwdstr[ROSH_PATH_SZ]; 1318 char do_exit; 1319 char **argv; 1320 int argc; 1321 1322 rv = 0; 1323 do_exit = false; 1324 if (!getcwd(ipwdstr, ROSH_PATH_SZ)) 1325 strcpy(ipwdstr, "./"); 1326 if (iargc > 1) 1327 do_exit = rosh_command(iargc - 1, &iargv[1], ipwdstr); 1328 while (!(do_exit)) { 1329 /* Extra preceeding newline */ 1330 printf("\nrosh: "); 1331 /* Read a line from console */ 1332 if (fgets(cmdstr, ROSH_CMD_SZ, stdin)) { 1333 argc = rosh_str2argv(&argv, cmdstr); 1334 do_exit = rosh_command(argc, argv, ipwdstr); 1335 rosh_free_argv(&argv); 1336 } else { 1337 do_exit = false; 1338 } 1339 } 1340 return rv; 1341 } 1342 1343 int main(int argc, char *argv[]) 1344 { 1345 int rv; 1346 1347 /* Initialization */ 1348 rv = 0; 1349 rosh_console_std(); 1350 if (argc == 1) { 1351 rosh_version(0); 1352 print_beta(); 1353 } else { 1354 #ifdef DO_DEBUG 1355 char cmdstr[ROSH_CMD_SZ]; 1356 rosh_argcat(cmdstr, ROSH_CMD_SZ, argc, argv, 1); 1357 ROSH_DEBUG("arg='%s'\n", cmdstr); 1358 #endif 1359 } 1360 rv = rosh_prompt(argc, argv); 1361 printf("--Exiting '" APP_NAME "'\n"); 1362 return rv; 1363 } 1364
