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 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #ifndef lint 35 /*static char sccsid[] = "from: @(#)interactive.c 8.1 (Berkeley) 6/5/93";*/ 36 static char *rcsid = "$Id: interactive.c,v 1.5 1994/09/23 14:27:54 mycroft Exp $"; 37 #endif /* not lint */ 38 39 #include <sys/param.h> 40 #include <sys/time.h> 41 #include <sys/stat.h> 42 43 #include <ufs/ffs/fs.h> 44 #include <ufs/ufs/dinode.h> 45 #include <ufs/ufs/dir.h> 46 #include <protocols/dumprestore.h> 47 48 #include <setjmp.h> 49 #include <glob.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 __P((char *, char *)); 84 static int fcmp __P((const void *, const void *)); 85 static void formatf __P((struct afile *, int)); 86 static void getcmd __P((char *, char *, char *, struct arglist *)); 87 struct dirent *glob_readdir __P((RST_DIR *dirp)); 88 static int glob_stat __P((const char *, struct stat *)); 89 static void mkentry __P((struct direct *, struct afile *)); 90 static void printlist __P((char *, char *)); 91 92 /* 93 * Read and execute commands from the terminal. 94 */ 95 void 96 runcmdshell() 97 { 98 register 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 = (void *)rst_opendir; 109 arglist.glob.gl_readdir = (void *)glob_readdir; 110 arglist.glob.gl_closedir = (void *)rst_closedir; 111 arglist.glob.gl_lstat = glob_stat; 112 arglist.glob.gl_stat = glob_stat; 113 canon("/", 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, &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(curdir, cmd, name, ap) 305 char *curdir, *cmd, *name; 306 struct arglist *ap; 307 { 308 register char *cp; 309 static char input[BUFSIZ]; 310 char output[BUFSIZ]; 311 # define rawname input /* save space by reusing input buffer */ 312 313 /* 314 * Check to see if still processing arguments. 315 */ 316 if (ap->argcnt > 0) 317 goto retnext; 318 if (nextarg != NULL) 319 goto getnext; 320 /* 321 * Read a command line and trim off trailing white space. 322 */ 323 do { 324 fprintf(stderr, "restore > "); 325 (void) fflush(stderr); 326 (void) fgets(input, BUFSIZ, terminal); 327 } while (!feof(terminal) && input[0] == '\n'); 328 if (feof(terminal)) { 329 (void) strcpy(cmd, "quit"); 330 return; 331 } 332 for (cp = &input[strlen(input) - 2]; *cp == ' ' || *cp == '\t'; cp--) 333 /* trim off trailing white space and newline */; 334 *++cp = '\0'; 335 /* 336 * Copy the command into "cmd". 337 */ 338 cp = copynext(input, cmd); 339 ap->cmd = cmd; 340 /* 341 * If no argument, use curdir as the default. 342 */ 343 if (*cp == '\0') { 344 (void) strcpy(name, curdir); 345 return; 346 } 347 nextarg = cp; 348 /* 349 * Find the next argument. 350 */ 351 getnext: 352 cp = copynext(nextarg, rawname); 353 if (*cp == '\0') 354 nextarg = NULL; 355 else 356 nextarg = cp; 357 /* 358 * If it is an absolute pathname, canonicalize it and return it. 359 */ 360 if (rawname[0] == '/') { 361 canon(rawname, name); 362 } else { 363 /* 364 * For relative pathnames, prepend the current directory to 365 * it then canonicalize and return it. 366 */ 367 (void) strcpy(output, curdir); 368 (void) strcat(output, "/"); 369 (void) strcat(output, rawname); 370 canon(output, name); 371 } 372 if (glob(name, GLOB_ALTDIRFUNC, NULL, &ap->glob) < 0) 373 fprintf(stderr, "%s: out of memory\n", ap->cmd); 374 if (ap->glob.gl_pathc == 0) 375 return; 376 ap->freeglob = 1; 377 ap->argcnt = ap->glob.gl_pathc; 378 379 retnext: 380 strcpy(name, ap->glob.gl_pathv[ap->glob.gl_pathc - ap->argcnt]); 381 if (--ap->argcnt == 0) { 382 ap->freeglob = 0; 383 globfree(&ap->glob); 384 } 385 # undef rawname 386 } 387 388 /* 389 * Strip off the next token of the input. 390 */ 391 static char * 392 copynext(input, output) 393 char *input, *output; 394 { 395 register char *cp, *bp; 396 char quote; 397 398 for (cp = input; *cp == ' ' || *cp == '\t'; cp++) 399 /* skip to argument */; 400 bp = output; 401 while (*cp != ' ' && *cp != '\t' && *cp != '\0') { 402 /* 403 * Handle back slashes. 404 */ 405 if (*cp == '\\') { 406 if (*++cp == '\0') { 407 fprintf(stderr, 408 "command lines cannot be continued\n"); 409 continue; 410 } 411 *bp++ = *cp++; 412 continue; 413 } 414 /* 415 * The usual unquoted case. 416 */ 417 if (*cp != '\'' && *cp != '"') { 418 *bp++ = *cp++; 419 continue; 420 } 421 /* 422 * Handle single and double quotes. 423 */ 424 quote = *cp++; 425 while (*cp != quote && *cp != '\0') 426 *bp++ = *cp++ | 0200; 427 if (*cp++ == '\0') { 428 fprintf(stderr, "missing %c\n", quote); 429 cp--; 430 continue; 431 } 432 } 433 *bp = '\0'; 434 return (cp); 435 } 436 437 /* 438 * Canonicalize file names to always start with ``./'' and 439 * remove any imbedded "." and ".." components. 440 */ 441 void 442 canon(rawname, canonname) 443 char *rawname, *canonname; 444 { 445 register char *cp, *np; 446 447 if (strcmp(rawname, ".") == 0 || strncmp(rawname, "./", 2) == 0) 448 (void) strcpy(canonname, ""); 449 else if (rawname[0] == '/') 450 (void) strcpy(canonname, "."); 451 else 452 (void) strcpy(canonname, "./"); 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(name, basename) 493 char *name; 494 char *basename; 495 { 496 register struct afile *fp, *list, *listp; 497 register struct direct *dp; 498 struct afile single; 499 RST_DIR *dirp; 500 int entries, len; 501 502 dp = pathsearch(name); 503 if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0)) 504 return; 505 if ((dirp = rst_opendir(name)) == NULL) { 506 entries = 1; 507 list = &single; 508 mkentry(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 while (dp = rst_readdir(dirp)) { 531 if (dp == NULL || dp->d_ino == 0) 532 break; 533 if (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) 534 continue; 535 if (vflag == 0 && 536 (strcmp(dp->d_name, ".") == 0 || 537 strcmp(dp->d_name, "..") == 0)) 538 continue; 539 mkentry(dp, listp++); 540 entries++; 541 } 542 rst_closedir(dirp); 543 if (entries == 0) { 544 fprintf(stderr, "\n"); 545 free(list); 546 return; 547 } 548 qsort((char *)list, entries, sizeof(struct afile), fcmp); 549 } 550 formatf(list, entries); 551 if (dirp != NULL) { 552 for (fp = listp - 1; fp >= list; fp--) 553 freename(fp->fname); 554 fprintf(stderr, "\n"); 555 free(list); 556 } 557 } 558 559 /* 560 * Read the contents of a directory. 561 */ 562 static void 563 mkentry(dp, fp) 564 struct direct *dp; 565 register struct afile *fp; 566 { 567 char *cp; 568 struct entry *np; 569 570 fp->fnum = dp->d_ino; 571 fp->fname = savename(dp->d_name); 572 for (cp = fp->fname; *cp; cp++) 573 if (!vflag && (*cp < ' ' || *cp >= 0177)) 574 *cp = '?'; 575 fp->len = cp - fp->fname; 576 if (dflag && TSTINO(fp->fnum, dumpmap) == 0) 577 fp->prefix = '^'; 578 else if ((np = lookupino(fp->fnum)) != NULL && (np->e_flags & NEW)) 579 fp->prefix = '*'; 580 else 581 fp->prefix = ' '; 582 switch(dp->d_type) { 583 584 default: 585 fprintf(stderr, "Warning: undefined file type %d\n", 586 dp->d_type); 587 /* fall through */ 588 case DT_REG: 589 fp->postfix = ' '; 590 break; 591 592 case DT_LNK: 593 fp->postfix = '@'; 594 break; 595 596 case DT_FIFO: 597 case DT_SOCK: 598 fp->postfix = '='; 599 break; 600 601 case DT_CHR: 602 case DT_BLK: 603 fp->postfix = '#'; 604 break; 605 606 case DT_UNKNOWN: 607 case DT_DIR: 608 if (inodetype(dp->d_ino) == NODE) 609 fp->postfix = '/'; 610 else 611 fp->postfix = ' '; 612 break; 613 } 614 return; 615 } 616 617 /* 618 * Print out a pretty listing of a directory 619 */ 620 static void 621 formatf(list, nentry) 622 register struct afile *list; 623 int nentry; 624 { 625 register struct afile *fp, *endlist; 626 int width, bigino, haveprefix, havepostfix; 627 int i, j, w, precision, columns, lines; 628 629 width = 0; 630 haveprefix = 0; 631 havepostfix = 0; 632 bigino = ROOTINO; 633 endlist = &list[nentry]; 634 for (fp = &list[0]; fp < endlist; fp++) { 635 if (bigino < fp->fnum) 636 bigino = fp->fnum; 637 if (width < fp->len) 638 width = fp->len; 639 if (fp->prefix != ' ') 640 haveprefix = 1; 641 if (fp->postfix != ' ') 642 havepostfix = 1; 643 } 644 if (haveprefix) 645 width++; 646 if (havepostfix) 647 width++; 648 if (vflag) { 649 for (precision = 0, i = bigino; i > 0; i /= 10) 650 precision++; 651 width += precision + 1; 652 } 653 width++; 654 columns = 81 / width; 655 if (columns == 0) 656 columns = 1; 657 lines = (nentry + columns - 1) / columns; 658 for (i = 0; i < lines; i++) { 659 for (j = 0; j < columns; j++) { 660 fp = &list[j * lines + i]; 661 if (vflag) { 662 fprintf(stderr, "%*d ", precision, fp->fnum); 663 fp->len += precision + 1; 664 } 665 if (haveprefix) { 666 putc(fp->prefix, stderr); 667 fp->len++; 668 } 669 fprintf(stderr, "%s", fp->fname); 670 if (havepostfix) { 671 putc(fp->postfix, stderr); 672 fp->len++; 673 } 674 if (fp + lines >= endlist) { 675 fprintf(stderr, "\n"); 676 break; 677 } 678 for (w = fp->len; w < width; w++) 679 putc(' ', stderr); 680 } 681 } 682 } 683 684 /* 685 * Skip over directory entries that are not on the tape 686 * 687 * First have to get definition of a dirent. 688 */ 689 #undef DIRBLKSIZ 690 #include <dirent.h> 691 #undef d_ino 692 693 struct dirent * 694 glob_readdir(dirp) 695 RST_DIR *dirp; 696 { 697 struct direct *dp; 698 static struct dirent adirent; 699 700 while ((dp = rst_readdir(dirp)) != NULL) { 701 if (dp->d_ino == 0) 702 continue; 703 if (dflag || TSTINO(dp->d_ino, dumpmap)) 704 break; 705 } 706 if (dp == NULL) 707 return (NULL); 708 adirent.d_fileno = dp->d_ino; 709 adirent.d_namlen = dp->d_namlen; 710 memcpy(adirent.d_name, dp->d_name, dp->d_namlen + 1); 711 return (&adirent); 712 } 713 714 /* 715 * Return st_mode information in response to stat or lstat calls 716 */ 717 static int 718 glob_stat(name, stp) 719 const char *name; 720 struct stat *stp; 721 { 722 register struct direct *dp; 723 724 dp = pathsearch(name); 725 if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0)) 726 return (-1); 727 if (inodetype(dp->d_ino) == NODE) 728 stp->st_mode = IFDIR; 729 else 730 stp->st_mode = IFREG; 731 return (0); 732 } 733 734 /* 735 * Comparison routine for qsort. 736 */ 737 static int 738 fcmp(f1, f2) 739 register const void *f1, *f2; 740 { 741 return (strcmp(((struct afile *)f1)->fname, 742 ((struct afile *)f2)->fname)); 743 } 744 745 /* 746 * respond to interrupts 747 */ 748 void 749 onintr(signo) 750 int signo; 751 { 752 if (command == 'i' && runshell) 753 longjmp(reset, 1); 754 if (reply("restore interrupted, continue") == FAIL) 755 done(1); 756 } 757