1 /* 2 * Copyright (c) 1985, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #ifndef lint 31 #if 0 32 static char sccsid[] = "@(#)interactive.c 8.5 (Berkeley) 5/1/95"; 33 #endif 34 #endif /* not lint */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include <sys/param.h> 40 #include <sys/stat.h> 41 42 #include <ufs/ufs/dinode.h> 43 #include <ufs/ufs/dir.h> 44 #include <protocols/dumprestore.h> 45 46 #include <ctype.h> 47 #include <glob.h> 48 #include <limits.h> 49 #include <setjmp.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 54 #include "restore.h" 55 #include "extern.h" 56 57 #define round(a, b) (((a) + (b) - 1) / (b) * (b)) 58 59 /* 60 * Things to handle interruptions. 61 */ 62 static int runshell; 63 static jmp_buf reset; 64 static char *nextarg = NULL; 65 66 /* 67 * Structure and routines associated with listing directories. 68 */ 69 struct afile { 70 ino_t fnum; /* inode number of file */ 71 char *fname; /* file name */ 72 short len; /* name length */ 73 char prefix; /* prefix character */ 74 char postfix; /* postfix character */ 75 }; 76 struct arglist { 77 int freeglob; /* glob structure needs to be freed */ 78 int argcnt; /* next globbed argument to return */ 79 glob_t glob; /* globbing information */ 80 char *cmd; /* the current command */ 81 }; 82 83 static char *copynext(char *, char *); 84 static int fcmp(const void *, const void *); 85 static void formatf(struct afile *, int); 86 static void getcmd(char *, char *, char *, int, struct arglist *); 87 struct dirent *glob_readdir(void *); 88 static int glob_stat(const char *, struct stat *); 89 static void mkentry(char *, struct direct *, struct afile *); 90 static void printlist(char *, char *); 91 92 /* 93 * Read and execute commands from the terminal. 94 */ 95 void 96 runcmdshell(void) 97 { 98 struct entry *np; 99 ino_t ino; 100 struct arglist arglist; 101 char curdir[MAXPATHLEN]; 102 char name[MAXPATHLEN]; 103 char cmd[BUFSIZ]; 104 105 arglist.freeglob = 0; 106 arglist.argcnt = 0; 107 arglist.glob.gl_flags = GLOB_ALTDIRFUNC; 108 arglist.glob.gl_opendir = rst_opendir; 109 arglist.glob.gl_readdir = glob_readdir; 110 arglist.glob.gl_closedir = rst_closedir; 111 arglist.glob.gl_lstat = glob_stat; 112 arglist.glob.gl_stat = glob_stat; 113 canon("/", curdir, sizeof(curdir)); 114 loop: 115 if (setjmp(reset) != 0) { 116 if (arglist.freeglob != 0) { 117 arglist.freeglob = 0; 118 arglist.argcnt = 0; 119 globfree(&arglist.glob); 120 } 121 nextarg = NULL; 122 volno = 0; 123 } 124 runshell = 1; 125 getcmd(curdir, cmd, name, sizeof(name), &arglist); 126 switch (cmd[0]) { 127 /* 128 * Add elements to the extraction list. 129 */ 130 case 'a': 131 if (strncmp(cmd, "add", strlen(cmd)) != 0) 132 goto bad; 133 ino = dirlookup(name); 134 if (ino == 0) 135 break; 136 if (mflag) 137 pathcheck(name); 138 treescan(name, ino, addfile); 139 break; 140 /* 141 * Change working directory. 142 */ 143 case 'c': 144 if (strncmp(cmd, "cd", strlen(cmd)) != 0) 145 goto bad; 146 ino = dirlookup(name); 147 if (ino == 0) 148 break; 149 if (inodetype(ino) == LEAF) { 150 fprintf(stderr, "%s: not a directory\n", name); 151 break; 152 } 153 (void) strcpy(curdir, name); 154 break; 155 /* 156 * Delete elements from the extraction list. 157 */ 158 case 'd': 159 if (strncmp(cmd, "delete", strlen(cmd)) != 0) 160 goto bad; 161 np = lookupname(name); 162 if (np == NULL || (np->e_flags & NEW) == 0) { 163 fprintf(stderr, "%s: not on extraction list\n", name); 164 break; 165 } 166 treescan(name, np->e_ino, deletefile); 167 break; 168 /* 169 * Extract the requested list. 170 */ 171 case 'e': 172 if (strncmp(cmd, "extract", strlen(cmd)) != 0) 173 goto bad; 174 createfiles(); 175 createlinks(); 176 setdirmodes(0); 177 if (dflag) 178 checkrestore(); 179 volno = 0; 180 break; 181 /* 182 * List available commands. 183 */ 184 case 'h': 185 if (strncmp(cmd, "help", strlen(cmd)) != 0) 186 goto bad; 187 case '?': 188 fprintf(stderr, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", 189 "Available commands are:\n", 190 "\tls [arg] - list directory\n", 191 "\tcd arg - change directory\n", 192 "\tpwd - print current directory\n", 193 "\tadd [arg] - add `arg' to list of", 194 " files to be extracted\n", 195 "\tdelete [arg] - delete `arg' from", 196 " list of files to be extracted\n", 197 "\textract - extract requested files\n", 198 "\tsetmodes - set modes of requested directories\n", 199 "\tquit - immediately exit program\n", 200 "\twhat - list dump header information\n", 201 "\tverbose - toggle verbose flag", 202 " (useful with ``ls'')\n", 203 "\thelp or `?' - print this list\n", 204 "If no `arg' is supplied, the current", 205 " directory is used\n"); 206 break; 207 /* 208 * List a directory. 209 */ 210 case 'l': 211 if (strncmp(cmd, "ls", strlen(cmd)) != 0) 212 goto bad; 213 printlist(name, curdir); 214 break; 215 /* 216 * Print current directory. 217 */ 218 case 'p': 219 if (strncmp(cmd, "pwd", strlen(cmd)) != 0) 220 goto bad; 221 if (curdir[1] == '\0') 222 fprintf(stderr, "/\n"); 223 else 224 fprintf(stderr, "%s\n", &curdir[1]); 225 break; 226 /* 227 * Quit. 228 */ 229 case 'q': 230 if (strncmp(cmd, "quit", strlen(cmd)) != 0) 231 goto bad; 232 return; 233 case 'x': 234 if (strncmp(cmd, "xit", strlen(cmd)) != 0) 235 goto bad; 236 return; 237 /* 238 * Toggle verbose mode. 239 */ 240 case 'v': 241 if (strncmp(cmd, "verbose", strlen(cmd)) != 0) 242 goto bad; 243 if (vflag) { 244 fprintf(stderr, "verbose mode off\n"); 245 vflag = 0; 246 break; 247 } 248 fprintf(stderr, "verbose mode on\n"); 249 vflag++; 250 break; 251 /* 252 * Just restore requested directory modes. 253 */ 254 case 's': 255 if (strncmp(cmd, "setmodes", strlen(cmd)) != 0) 256 goto bad; 257 setdirmodes(FORCE); 258 break; 259 /* 260 * Print out dump header information. 261 */ 262 case 'w': 263 if (strncmp(cmd, "what", strlen(cmd)) != 0) 264 goto bad; 265 printdumpinfo(); 266 break; 267 /* 268 * Turn on debugging. 269 */ 270 case 'D': 271 if (strncmp(cmd, "Debug", strlen(cmd)) != 0) 272 goto bad; 273 if (dflag) { 274 fprintf(stderr, "debugging mode off\n"); 275 dflag = 0; 276 break; 277 } 278 fprintf(stderr, "debugging mode on\n"); 279 dflag++; 280 break; 281 /* 282 * Unknown command. 283 */ 284 default: 285 bad: 286 fprintf(stderr, "%s: unknown command; type ? for help\n", cmd); 287 break; 288 } 289 goto loop; 290 } 291 292 /* 293 * Read and parse an interactive command. 294 * The first word on the line is assigned to "cmd". If 295 * there are no arguments on the command line, then "curdir" 296 * is returned as the argument. If there are arguments 297 * on the line they are returned one at a time on each 298 * successive call to getcmd. Each argument is first assigned 299 * to "name". If it does not start with "/" the pathname in 300 * "curdir" is prepended to it. Finally "canon" is called to 301 * eliminate any embedded ".." components. 302 */ 303 static void 304 getcmd(char *curdir, char *cmd, char *name, int size, struct arglist *ap) 305 { 306 char *cp; 307 static char input[BUFSIZ]; 308 char output[BUFSIZ]; 309 # define rawname input /* save space by reusing input buffer */ 310 311 /* 312 * Check to see if still processing arguments. 313 */ 314 if (ap->argcnt > 0) 315 goto retnext; 316 if (nextarg != NULL) 317 goto getnext; 318 /* 319 * Read a command line and trim off trailing white space. 320 */ 321 do { 322 fprintf(stderr, "restore > "); 323 (void) fflush(stderr); 324 if (fgets(input, BUFSIZ, terminal) == NULL) { 325 strcpy(cmd, "quit"); 326 return; 327 } 328 } while (input[0] == '\n'); 329 for (cp = &input[strlen(input) - 2]; *cp == ' ' || *cp == '\t'; cp--) 330 /* trim off trailing white space and newline */; 331 *++cp = '\0'; 332 /* 333 * Copy the command into "cmd". 334 */ 335 cp = copynext(input, cmd); 336 ap->cmd = cmd; 337 /* 338 * If no argument, use curdir as the default. 339 */ 340 if (*cp == '\0') { 341 (void) strncpy(name, curdir, size); 342 name[size - 1] = '\0'; 343 return; 344 } 345 nextarg = cp; 346 /* 347 * Find the next argument. 348 */ 349 getnext: 350 cp = copynext(nextarg, rawname); 351 if (*cp == '\0') 352 nextarg = NULL; 353 else 354 nextarg = cp; 355 /* 356 * If it is an absolute pathname, canonicalize it and return it. 357 */ 358 if (rawname[0] == '/') { 359 canon(rawname, name, size); 360 } else { 361 /* 362 * For relative pathnames, prepend the current directory to 363 * it then canonicalize and return it. 364 */ 365 snprintf(output, sizeof(output), "%s/%s", curdir, rawname); 366 canon(output, name, size); 367 } 368 switch (glob(name, GLOB_ALTDIRFUNC, NULL, &ap->glob)) { 369 case GLOB_NOSPACE: 370 fprintf(stderr, "%s: out of memory\n", ap->cmd); 371 break; 372 case GLOB_NOMATCH: 373 fprintf(stderr, "%s %s: no such file or directory\n", ap->cmd, name); 374 break; 375 } 376 if (ap->glob.gl_pathc == 0) 377 return; 378 ap->freeglob = 1; 379 ap->argcnt = ap->glob.gl_pathc; 380 381 retnext: 382 strncpy(name, ap->glob.gl_pathv[ap->glob.gl_pathc - ap->argcnt], size); 383 name[size - 1] = '\0'; 384 if (--ap->argcnt == 0) { 385 ap->freeglob = 0; 386 globfree(&ap->glob); 387 } 388 # undef rawname 389 } 390 391 /* 392 * Strip off the next token of the input. 393 */ 394 static char * 395 copynext(char *input, char *output) 396 { 397 char *cp, *bp; 398 char quote; 399 400 for (cp = input; *cp == ' ' || *cp == '\t'; cp++) 401 /* skip to argument */; 402 bp = output; 403 while (*cp != ' ' && *cp != '\t' && *cp != '\0') { 404 /* 405 * Handle back slashes. 406 */ 407 if (*cp == '\\') { 408 if (*++cp == '\0') { 409 fprintf(stderr, 410 "command lines cannot be continued\n"); 411 continue; 412 } 413 *bp++ = *cp++; 414 continue; 415 } 416 /* 417 * The usual unquoted case. 418 */ 419 if (*cp != '\'' && *cp != '"') { 420 *bp++ = *cp++; 421 continue; 422 } 423 /* 424 * Handle single and double quotes. 425 */ 426 quote = *cp++; 427 while (*cp != quote && *cp != '\0') 428 *bp++ = *cp++; 429 if (*cp++ == '\0') { 430 fprintf(stderr, "missing %c\n", quote); 431 cp--; 432 continue; 433 } 434 } 435 *bp = '\0'; 436 return (cp); 437 } 438 439 /* 440 * Canonicalize file names to always start with ``./'' and 441 * remove any embedded "." and ".." components. 442 */ 443 void 444 canon(char *rawname, char *canonname, int len) 445 { 446 char *cp, *np; 447 448 if (strcmp(rawname, ".") == 0 || strncmp(rawname, "./", 2) == 0) 449 (void) strcpy(canonname, ""); 450 else if (rawname[0] == '/') 451 (void) strcpy(canonname, "."); 452 else 453 (void) strcpy(canonname, "./"); 454 if (strlen(canonname) + strlen(rawname) >= len) { 455 fprintf(stderr, "canonname: not enough buffer space\n"); 456 done(1); 457 } 458 459 (void) strcat(canonname, rawname); 460 /* 461 * Eliminate multiple and trailing '/'s 462 */ 463 for (cp = np = canonname; *np != '\0'; cp++) { 464 *cp = *np++; 465 while (*cp == '/' && *np == '/') 466 np++; 467 } 468 *cp = '\0'; 469 if (*--cp == '/') 470 *cp = '\0'; 471 /* 472 * Eliminate extraneous "." and ".." from pathnames. 473 */ 474 for (np = canonname; *np != '\0'; ) { 475 np++; 476 cp = np; 477 while (*np != '/' && *np != '\0') 478 np++; 479 if (np - cp == 1 && *cp == '.') { 480 cp--; 481 (void) strcpy(cp, np); 482 np = cp; 483 } 484 if (np - cp == 2 && strncmp(cp, "..", 2) == 0) { 485 cp--; 486 while (cp > &canonname[1] && *--cp != '/') 487 /* find beginning of name */; 488 (void) strcpy(cp, np); 489 np = cp; 490 } 491 } 492 } 493 494 /* 495 * Do an "ls" style listing of a directory 496 */ 497 static void 498 printlist(char *name, char *basename) 499 { 500 struct afile *fp, *list, *listp; 501 struct direct *dp; 502 struct afile single; 503 RST_DIR *dirp; 504 int entries, len, namelen; 505 char locname[MAXPATHLEN + 1]; 506 507 dp = pathsearch(name); 508 if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) || 509 (!vflag && dp->d_ino == WINO)) 510 return; 511 if ((dirp = rst_opendir(name)) == NULL) { 512 entries = 1; 513 list = &single; 514 mkentry(name, dp, list); 515 len = strlen(basename) + 1; 516 if (strlen(name) - len > single.len) { 517 freename(single.fname); 518 single.fname = savename(&name[len]); 519 single.len = strlen(single.fname); 520 } 521 } else { 522 entries = 0; 523 while ((dp = rst_readdir(dirp))) 524 entries++; 525 rst_closedir(dirp); 526 list = (struct afile *)malloc(entries * sizeof(struct afile)); 527 if (list == NULL) { 528 fprintf(stderr, "ls: out of memory\n"); 529 return; 530 } 531 if ((dirp = rst_opendir(name)) == NULL) 532 panic("directory reopen failed\n"); 533 fprintf(stderr, "%s:\n", name); 534 entries = 0; 535 listp = list; 536 (void) strncpy(locname, name, MAXPATHLEN); 537 (void) strncat(locname, "/", MAXPATHLEN); 538 namelen = strlen(locname); 539 while ((dp = rst_readdir(dirp))) { 540 if (dp == NULL) 541 break; 542 if (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) 543 continue; 544 if (!vflag && (dp->d_ino == WINO || 545 strcmp(dp->d_name, ".") == 0 || 546 strcmp(dp->d_name, "..") == 0)) 547 continue; 548 locname[namelen] = '\0'; 549 if (namelen + dp->d_namlen >= MAXPATHLEN) { 550 fprintf(stderr, "%s%s: name exceeds %d char\n", 551 locname, dp->d_name, MAXPATHLEN); 552 } else { 553 (void) strncat(locname, dp->d_name, 554 (int)dp->d_namlen); 555 mkentry(locname, dp, listp++); 556 entries++; 557 } 558 } 559 rst_closedir(dirp); 560 if (entries == 0) { 561 fprintf(stderr, "\n"); 562 free(list); 563 return; 564 } 565 qsort((char *)list, entries, sizeof(struct afile), fcmp); 566 } 567 formatf(list, entries); 568 if (dirp != NULL) { 569 for (fp = listp - 1; fp >= list; fp--) 570 freename(fp->fname); 571 fprintf(stderr, "\n"); 572 free(list); 573 } 574 } 575 576 /* 577 * Read the contents of a directory. 578 */ 579 static void 580 mkentry(char *name, struct direct *dp, struct afile *fp) 581 { 582 char *cp; 583 struct entry *np; 584 585 fp->fnum = dp->d_ino; 586 fp->fname = savename(dp->d_name); 587 for (cp = fp->fname; *cp; cp++) 588 if (!vflag && !isprint((unsigned char)*cp)) 589 *cp = '?'; 590 fp->len = cp - fp->fname; 591 if (dflag && TSTINO(fp->fnum, dumpmap) == 0) 592 fp->prefix = '^'; 593 else if ((np = lookupname(name)) != NULL && (np->e_flags & NEW)) 594 fp->prefix = '*'; 595 else 596 fp->prefix = ' '; 597 switch(dp->d_type) { 598 599 default: 600 fprintf(stderr, "Warning: undefined file type %d\n", 601 dp->d_type); 602 /* FALLTHROUGH */ 603 case DT_REG: 604 fp->postfix = ' '; 605 break; 606 607 case DT_LNK: 608 fp->postfix = '@'; 609 break; 610 611 case DT_FIFO: 612 case DT_SOCK: 613 fp->postfix = '='; 614 break; 615 616 case DT_CHR: 617 case DT_BLK: 618 fp->postfix = '#'; 619 break; 620 621 case DT_WHT: 622 fp->postfix = '%'; 623 break; 624 625 case DT_UNKNOWN: 626 case DT_DIR: 627 if (inodetype(dp->d_ino) == NODE) 628 fp->postfix = '/'; 629 else 630 fp->postfix = ' '; 631 break; 632 } 633 return; 634 } 635 636 /* 637 * Print out a pretty listing of a directory 638 */ 639 static void 640 formatf(struct afile *list, int nentry) 641 { 642 struct afile *fp, *endlist; 643 int width, bigino, haveprefix, havepostfix; 644 int i, j, w, precision, columns, lines; 645 646 width = 0; 647 haveprefix = 0; 648 havepostfix = 0; 649 bigino = ROOTINO; 650 endlist = &list[nentry]; 651 for (fp = &list[0]; fp < endlist; fp++) { 652 if (bigino < fp->fnum) 653 bigino = fp->fnum; 654 if (width < fp->len) 655 width = fp->len; 656 if (fp->prefix != ' ') 657 haveprefix = 1; 658 if (fp->postfix != ' ') 659 havepostfix = 1; 660 } 661 if (haveprefix) 662 width++; 663 if (havepostfix) 664 width++; 665 if (vflag) { 666 for (precision = 0, i = bigino; i > 0; i /= 10) 667 precision++; 668 width += precision + 1; 669 } 670 width++; 671 columns = 81 / width; 672 if (columns == 0) 673 columns = 1; 674 lines = (nentry + columns - 1) / columns; 675 for (i = 0; i < lines; i++) { 676 for (j = 0; j < columns; j++) { 677 fp = &list[j * lines + i]; 678 if (vflag) { 679 fprintf(stderr, "%*d ", precision, fp->fnum); 680 fp->len += precision + 1; 681 } 682 if (haveprefix) { 683 putc(fp->prefix, stderr); 684 fp->len++; 685 } 686 fprintf(stderr, "%s", fp->fname); 687 if (havepostfix) { 688 putc(fp->postfix, stderr); 689 fp->len++; 690 } 691 if (fp + lines >= endlist) { 692 fprintf(stderr, "\n"); 693 break; 694 } 695 for (w = fp->len; w < width; w++) 696 putc(' ', stderr); 697 } 698 } 699 } 700 701 /* 702 * Skip over directory entries that are not on the tape 703 * 704 * First have to get definition of a dirent. 705 */ 706 #undef DIRBLKSIZ 707 #include <dirent.h> 708 #undef d_ino 709 710 struct dirent * 711 glob_readdir(void *dirp) 712 { 713 struct direct *dp; 714 static struct dirent adirent; 715 716 while ((dp = rst_readdir(dirp)) != NULL) { 717 if (!vflag && dp->d_ino == WINO) 718 continue; 719 if (dflag || TSTINO(dp->d_ino, dumpmap)) 720 break; 721 } 722 if (dp == NULL) 723 return (NULL); 724 adirent.d_fileno = dp->d_ino; 725 adirent.d_namlen = dp->d_namlen; 726 memmove(adirent.d_name, dp->d_name, dp->d_namlen + 1); 727 return (&adirent); 728 } 729 730 /* 731 * Return st_mode information in response to stat or lstat calls 732 */ 733 static int 734 glob_stat(const char *name, struct stat *stp) 735 { 736 struct direct *dp; 737 738 dp = pathsearch(name); 739 if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) || 740 (!vflag && dp->d_ino == WINO)) 741 return (-1); 742 if (inodetype(dp->d_ino) == NODE) 743 stp->st_mode = IFDIR; 744 else 745 stp->st_mode = IFREG; 746 return (0); 747 } 748 749 /* 750 * Comparison routine for qsort. 751 */ 752 static int 753 fcmp(const void *f1, const void *f2) 754 { 755 return (strcoll(((struct afile *)f1)->fname, 756 ((struct afile *)f2)->fname)); 757 } 758 759 /* 760 * respond to interrupts 761 */ 762 void 763 onintr(int signo __unused) 764 { 765 if (command == 'i' && runshell) 766 longjmp(reset, 1); 767 if (reply("restore interrupted, continue") == FAIL) 768 done(1); 769 } 770