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 if (glob(name, GLOB_ALTDIRFUNC, NULL, &ap->glob) < 0) 369 fprintf(stderr, "%s: out of memory\n", ap->cmd); 370 if (ap->glob.gl_pathc == 0) 371 return; 372 ap->freeglob = 1; 373 ap->argcnt = ap->glob.gl_pathc; 374 375 retnext: 376 strncpy(name, ap->glob.gl_pathv[ap->glob.gl_pathc - ap->argcnt], size); 377 name[size - 1] = '\0'; 378 if (--ap->argcnt == 0) { 379 ap->freeglob = 0; 380 globfree(&ap->glob); 381 } 382 # undef rawname 383 } 384 385 /* 386 * Strip off the next token of the input. 387 */ 388 static char * 389 copynext(char *input, char *output) 390 { 391 char *cp, *bp; 392 char quote; 393 394 for (cp = input; *cp == ' ' || *cp == '\t'; cp++) 395 /* skip to argument */; 396 bp = output; 397 while (*cp != ' ' && *cp != '\t' && *cp != '\0') { 398 /* 399 * Handle back slashes. 400 */ 401 if (*cp == '\\') { 402 if (*++cp == '\0') { 403 fprintf(stderr, 404 "command lines cannot be continued\n"); 405 continue; 406 } 407 *bp++ = *cp++; 408 continue; 409 } 410 /* 411 * The usual unquoted case. 412 */ 413 if (*cp != '\'' && *cp != '"') { 414 *bp++ = *cp++; 415 continue; 416 } 417 /* 418 * Handle single and double quotes. 419 */ 420 quote = *cp++; 421 while (*cp != quote && *cp != '\0') 422 *bp++ = *cp++; 423 if (*cp++ == '\0') { 424 fprintf(stderr, "missing %c\n", quote); 425 cp--; 426 continue; 427 } 428 } 429 *bp = '\0'; 430 return (cp); 431 } 432 433 /* 434 * Canonicalize file names to always start with ``./'' and 435 * remove any embedded "." and ".." components. 436 */ 437 void 438 canon(char *rawname, char *canonname, int len) 439 { 440 char *cp, *np; 441 442 if (strcmp(rawname, ".") == 0 || strncmp(rawname, "./", 2) == 0) 443 (void) strcpy(canonname, ""); 444 else if (rawname[0] == '/') 445 (void) strcpy(canonname, "."); 446 else 447 (void) strcpy(canonname, "./"); 448 if (strlen(canonname) + strlen(rawname) >= len) { 449 fprintf(stderr, "canonname: not enough buffer space\n"); 450 done(1); 451 } 452 453 (void) strcat(canonname, rawname); 454 /* 455 * Eliminate multiple and trailing '/'s 456 */ 457 for (cp = np = canonname; *np != '\0'; cp++) { 458 *cp = *np++; 459 while (*cp == '/' && *np == '/') 460 np++; 461 } 462 *cp = '\0'; 463 if (*--cp == '/') 464 *cp = '\0'; 465 /* 466 * Eliminate extraneous "." and ".." from pathnames. 467 */ 468 for (np = canonname; *np != '\0'; ) { 469 np++; 470 cp = np; 471 while (*np != '/' && *np != '\0') 472 np++; 473 if (np - cp == 1 && *cp == '.') { 474 cp--; 475 (void) strcpy(cp, np); 476 np = cp; 477 } 478 if (np - cp == 2 && strncmp(cp, "..", 2) == 0) { 479 cp--; 480 while (cp > &canonname[1] && *--cp != '/') 481 /* find beginning of name */; 482 (void) strcpy(cp, np); 483 np = cp; 484 } 485 } 486 } 487 488 /* 489 * Do an "ls" style listing of a directory 490 */ 491 static void 492 printlist(char *name, char *basename) 493 { 494 struct afile *fp, *list, *listp; 495 struct direct *dp; 496 struct afile single; 497 RST_DIR *dirp; 498 int entries, len, namelen; 499 char locname[MAXPATHLEN + 1]; 500 501 dp = pathsearch(name); 502 if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) || 503 (!vflag && dp->d_ino == WINO)) 504 return; 505 if ((dirp = rst_opendir(name)) == NULL) { 506 entries = 1; 507 list = &single; 508 mkentry(name, dp, list); 509 len = strlen(basename) + 1; 510 if (strlen(name) - len > single.len) { 511 freename(single.fname); 512 single.fname = savename(&name[len]); 513 single.len = strlen(single.fname); 514 } 515 } else { 516 entries = 0; 517 while ((dp = rst_readdir(dirp))) 518 entries++; 519 rst_closedir(dirp); 520 list = (struct afile *)malloc(entries * sizeof(struct afile)); 521 if (list == NULL) { 522 fprintf(stderr, "ls: out of memory\n"); 523 return; 524 } 525 if ((dirp = rst_opendir(name)) == NULL) 526 panic("directory reopen failed\n"); 527 fprintf(stderr, "%s:\n", name); 528 entries = 0; 529 listp = list; 530 (void) strncpy(locname, name, MAXPATHLEN); 531 (void) strncat(locname, "/", MAXPATHLEN); 532 namelen = strlen(locname); 533 while ((dp = rst_readdir(dirp))) { 534 if (dp == NULL) 535 break; 536 if (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) 537 continue; 538 if (!vflag && (dp->d_ino == WINO || 539 strcmp(dp->d_name, ".") == 0 || 540 strcmp(dp->d_name, "..") == 0)) 541 continue; 542 locname[namelen] = '\0'; 543 if (namelen + dp->d_namlen >= MAXPATHLEN) { 544 fprintf(stderr, "%s%s: name exceeds %d char\n", 545 locname, dp->d_name, MAXPATHLEN); 546 } else { 547 (void) strncat(locname, dp->d_name, 548 (int)dp->d_namlen); 549 mkentry(locname, dp, listp++); 550 entries++; 551 } 552 } 553 rst_closedir(dirp); 554 if (entries == 0) { 555 fprintf(stderr, "\n"); 556 free(list); 557 return; 558 } 559 qsort((char *)list, entries, sizeof(struct afile), fcmp); 560 } 561 formatf(list, entries); 562 if (dirp != NULL) { 563 for (fp = listp - 1; fp >= list; fp--) 564 freename(fp->fname); 565 fprintf(stderr, "\n"); 566 free(list); 567 } 568 } 569 570 /* 571 * Read the contents of a directory. 572 */ 573 static void 574 mkentry(char *name, struct direct *dp, struct afile *fp) 575 { 576 char *cp; 577 struct entry *np; 578 579 fp->fnum = dp->d_ino; 580 fp->fname = savename(dp->d_name); 581 for (cp = fp->fname; *cp; cp++) 582 if (!vflag && !isprint((unsigned char)*cp)) 583 *cp = '?'; 584 fp->len = cp - fp->fname; 585 if (dflag && TSTINO(fp->fnum, dumpmap) == 0) 586 fp->prefix = '^'; 587 else if ((np = lookupname(name)) != NULL && (np->e_flags & NEW)) 588 fp->prefix = '*'; 589 else 590 fp->prefix = ' '; 591 switch(dp->d_type) { 592 593 default: 594 fprintf(stderr, "Warning: undefined file type %d\n", 595 dp->d_type); 596 /* FALLTHROUGH */ 597 case DT_REG: 598 fp->postfix = ' '; 599 break; 600 601 case DT_LNK: 602 fp->postfix = '@'; 603 break; 604 605 case DT_FIFO: 606 case DT_SOCK: 607 fp->postfix = '='; 608 break; 609 610 case DT_CHR: 611 case DT_BLK: 612 fp->postfix = '#'; 613 break; 614 615 case DT_WHT: 616 fp->postfix = '%'; 617 break; 618 619 case DT_UNKNOWN: 620 case DT_DIR: 621 if (inodetype(dp->d_ino) == NODE) 622 fp->postfix = '/'; 623 else 624 fp->postfix = ' '; 625 break; 626 } 627 return; 628 } 629 630 /* 631 * Print out a pretty listing of a directory 632 */ 633 static void 634 formatf(struct afile *list, int nentry) 635 { 636 struct afile *fp, *endlist; 637 int width, bigino, haveprefix, havepostfix; 638 int i, j, w, precision, columns, lines; 639 640 width = 0; 641 haveprefix = 0; 642 havepostfix = 0; 643 bigino = ROOTINO; 644 endlist = &list[nentry]; 645 for (fp = &list[0]; fp < endlist; fp++) { 646 if (bigino < fp->fnum) 647 bigino = fp->fnum; 648 if (width < fp->len) 649 width = fp->len; 650 if (fp->prefix != ' ') 651 haveprefix = 1; 652 if (fp->postfix != ' ') 653 havepostfix = 1; 654 } 655 if (haveprefix) 656 width++; 657 if (havepostfix) 658 width++; 659 if (vflag) { 660 for (precision = 0, i = bigino; i > 0; i /= 10) 661 precision++; 662 width += precision + 1; 663 } 664 width++; 665 columns = 81 / width; 666 if (columns == 0) 667 columns = 1; 668 lines = (nentry + columns - 1) / columns; 669 for (i = 0; i < lines; i++) { 670 for (j = 0; j < columns; j++) { 671 fp = &list[j * lines + i]; 672 if (vflag) { 673 fprintf(stderr, "%*d ", precision, fp->fnum); 674 fp->len += precision + 1; 675 } 676 if (haveprefix) { 677 putc(fp->prefix, stderr); 678 fp->len++; 679 } 680 fprintf(stderr, "%s", fp->fname); 681 if (havepostfix) { 682 putc(fp->postfix, stderr); 683 fp->len++; 684 } 685 if (fp + lines >= endlist) { 686 fprintf(stderr, "\n"); 687 break; 688 } 689 for (w = fp->len; w < width; w++) 690 putc(' ', stderr); 691 } 692 } 693 } 694 695 /* 696 * Skip over directory entries that are not on the tape 697 * 698 * First have to get definition of a dirent. 699 */ 700 #undef DIRBLKSIZ 701 #include <dirent.h> 702 #undef d_ino 703 704 struct dirent * 705 glob_readdir(void *dirp) 706 { 707 struct direct *dp; 708 static struct dirent adirent; 709 710 while ((dp = rst_readdir(dirp)) != NULL) { 711 if (!vflag && dp->d_ino == WINO) 712 continue; 713 if (dflag || TSTINO(dp->d_ino, dumpmap)) 714 break; 715 } 716 if (dp == NULL) 717 return (NULL); 718 adirent.d_fileno = dp->d_ino; 719 adirent.d_namlen = dp->d_namlen; 720 memmove(adirent.d_name, dp->d_name, dp->d_namlen + 1); 721 return (&adirent); 722 } 723 724 /* 725 * Return st_mode information in response to stat or lstat calls 726 */ 727 static int 728 glob_stat(const char *name, struct stat *stp) 729 { 730 struct direct *dp; 731 732 dp = pathsearch(name); 733 if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) || 734 (!vflag && dp->d_ino == WINO)) 735 return (-1); 736 if (inodetype(dp->d_ino) == NODE) 737 stp->st_mode = IFDIR; 738 else 739 stp->st_mode = IFREG; 740 return (0); 741 } 742 743 /* 744 * Comparison routine for qsort. 745 */ 746 static int 747 fcmp(const void *f1, const void *f2) 748 { 749 return (strcoll(((struct afile *)f1)->fname, 750 ((struct afile *)f2)->fname)); 751 } 752 753 /* 754 * respond to interrupts 755 */ 756 void 757 onintr(int signo __unused) 758 { 759 if (command == 'i' && runshell) 760 longjmp(reset, 1); 761 if (reply("restore interrupted, continue") == FAIL) 762 done(1); 763 } 764