![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to src.tar CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / odist|
Return to src.tar CVS log | Up to [Research Unix] / researchv10no / cmd / odist |
1.1 ! root 1: TODO 644 3513 4 417 5032703557 4565 finish new setuid scheme ! 2: write document ! 3: add security configuration file support ! 4: (idea: receive reads this file, which looks like: ! 5: local-user remote-system remote-user remote-file actions...) ! 6: set up two-pass install/remove scheme ! 7: make a backup package before installation ! 8: ������ ape/ 755 3513 4 0 5032703607 4567 ape/Future/ 755 3513 4 0 5031447510 6036 ape/Future/conf.c 644 3513 4 4652 5016334717 7232 #include <ctype.h> ! 9: #include <regexp.h> /* FIXME: use Posix interface. */ ! 10: #include <stdio.h> ! 11: #include <stdlib.h> ! 12: #include <string.h> ! 13: #include "conf.h" ! 14: #include "dist.h" ! 15: ! 16: static char * ! 17: gettok(char *tok, char *src) ! 18: { ! 19: while (!isspace(*src)) { ! 20: if (!*src) ! 21: break; ! 22: *tok++ = *src++; ! 23: } ! 24: while (isspace(*src)) ! 25: ++src; ! 26: return src; ! 27: } ! 28: ! 29: /* return the next line of the config file matching the given args. ! 30: and argument can be NULL and will be assumed to match. the return ! 31: value is in a static data area. */ ! 32: struct conf * ! 33: confread(FILE *fp, char *host, char *user, char *file) ! 34: { ! 35: static char confline[MAXLINE]; ! 36: static char confhost[MAXLINE], confuser[MAXLINE], conffile[MAXLINE]; ! 37: char *next; ! 38: static struct conf conf = { confhost, confuser, conffile }; ! 39: int len, flag; ! 40: regexp *re; ! 41: regsubexp match[1]; ! 42: ! 43: for (;;) { ! 44: if (!fgets(confline, MAXLINE, fp)) ! 45: return NULL; ! 46: if (confline[0] == '#') ! 47: continue; ! 48: len = strlen(confline); ! 49: if (confline[len - 1] != '\n') { ! 50: if (feof(fp)) ! 51: eprintf("readconf: incomplete last line!"); ! 52: else ! 53: eprintf("readconf: line too long or embedded NUL!"); ! 54: exit(1); ! 55: } ! 56: next = gettok(confhost, confline); ! 57: next = gettok(confuser, next); ! 58: conf.cmds = gettok(conffile, next); ! 59: if (host) { ! 60: re = regcomp(confhost); ! 61: flag = regexec(re, host, match, 1); ! 62: free(re); ! 63: if (!flag || match[0].ep - match[0].sp != strlen(host)) ! 64: continue; ! 65: } ! 66: if (user) { ! 67: re = regcomp(confuser); ! 68: flag = regexec(re, user, match, 1); ! 69: free(re); ! 70: if (!flag || match[0].ep - match[0].sp != strlen(user)) ! 71: continue; ! 72: } ! 73: if (file) { ! 74: re = regcomp(conffile); ! 75: flag = regexec(re, file, match, 1); ! 76: free(re); ! 77: if (!flag || match[0].ep - match[0].sp != strlen(file)) ! 78: continue; ! 79: } ! 80: return &conf; ! 81: } ! 82: } ! 83: ! 84: /* call functions associated with the commands in the given string ! 85: return the total of the return values */ ! 86: int ! 87: confexec(char *cmdstr, struct confcmds cmdtab[]) ! 88: { ! 89: char cmd[MAXLINE], arg[MAXLINE]; ! 90: int i, np, ret; ! 91: ! 92: ret = 0; ! 93: while (*cmdstr) { ! 94: for (i = 0; isalnum(*cmdstr); ++cmdstr) ! 95: cmd[i++] = *cmdstr; ! 96: cmd[i] = 0; ! 97: if (*cmdstr == '(') ! 98: for (i = 0, np = 1, ++cmdstr; *cmdstr && np; ++cmdstr) { ! 99: if (*cmdstr == '(') ! 100: ++np; ! 101: if (*cmdstr == ')' && !--np) ! 102: continue; ! 103: arg[i++] = *cmdstr; ! 104: } ! 105: for (i = 0; cmdtab[i].name; ++i) ! 106: if (!strcmp(cmd, cmdtab[i].name)) { ! 107: ret += (*cmdtab[i].func)(arg); ! 108: break; ! 109: } ! 110: while (*cmdstr && !isalnum(*cmdstr)) ! 111: ++cmdstr; ! 112: } ! 113: return ret; ! 114: } ! 115: t i, np, ret; ! 116: ! 117: ret = 0; ! 118: while (*cmdstr) { ! 119: for (i = 0; isalnum(*cmdstr); ++cmdstr) ! 120: ape/Future/conf.h 644 3513 4 676 5016334663 7221 /* structure corresponding to line of the config file */ ! 121: struct conf { ! 122: char *host; /* regexp */ ! 123: char *user; /* regexp */ ! 124: char *file; /* regexp */ ! 125: char *cmds; /* cmd+cmd+cmd... */ ! 126: }; ! 127: ! 128: extern struct conf *confread(FILE *fp, char *host, char *user, char *file); ! 129: ! 130: /* configuration command name and associated function to call */ ! 131: struct confcmds { ! 132: char *name; ! 133: int (*func)(char *); ! 134: }; ! 135: ! 136: extern int confexec(char *cmdstr, struct confcmds *cmdtab); ! 137: = 0; ! 138: while (*cmdstr) { ! 139: for (i = 0; isalnum(*cmdstr); ++cmdstr) ! 140: ape/dist.sh 644 3513 4 4306 5032703266 6157 #! /bin/sh - ! 141: ! 142: umask 022 ! 143: ! 144: LDIR=%LDIR% ! 145: SDIR=%SDIR% ! 146: QPREFIX=Q. ! 147: ! 148: PATH=$LDIR:/bin:/usr/bin:/usr/ucb:/usr/bsd ! 149: export PATH ! 150: ! 151: DEST=$LDIR/destinations ! 152: ! 153: showq=0 ! 154: recv=0 ! 155: notify=0 ! 156: systems= ! 157: usage='usage: dist [-q|-r] [system|-[Ff] file] [-n] [files...]' ! 158: ! 159: while [ $# -gt 0 ] ! 160: do ! 161: case "$1" in ! 162: -q) ! 163: showq=1 ! 164: ;; ! 165: -r) ! 166: recv=1 ! 167: ;; ! 168: -n) ! 169: notify=1 ! 170: ;; ! 171: -[Ff]) ! 172: if [ $# -lt 2 ] ! 173: then ! 174: echo "$usage" 1>&2 ! 175: exit 1 ! 176: fi ! 177: if [ x$1 = x-f -a -r "$2" ] ! 178: then ! 179: systems=`cat "$2" 2>/dev/null` ! 180: elif [ -r $DEST/"$2" ] ! 181: then ! 182: systems=`cat $DEST/"$2" 2>/dev/null` ! 183: else ! 184: echo "dist: can't open '$2'" 1>&2 ! 185: exit 1 ! 186: fi ! 187: shift ! 188: ;; ! 189: *) ! 190: if [ "x$systems" != x ] ! 191: then ! 192: break ! 193: fi ! 194: systems="$1" ! 195: ;; ! 196: esac ! 197: shift ! 198: done ! 199: ! 200: if [ $recv = 1 ] ! 201: then ! 202: if [ x"$systems" = x ] ! 203: then ! 204: echo dist: no systems specified 1>&2 ! 205: exit 1 ! 206: else ! 207: for sys in $systems ! 208: do ! 209: echo $sys: ! 210: connect $sys transmit io receive || exit 1 ! 211: done ! 212: exit 0 ! 213: fi ! 214: fi ! 215: ! 216: if [ $showq = 1 ] ! 217: then ! 218: if [ x"$systems" = x ] ! 219: then ! 220: showq ! 221: exit 0 ! 222: else ! 223: for sys in $systems ! 224: do ! 225: echo $sys: ! 226: connect $sys showq i /bin/cat ! 227: done ! 228: exit 0 ! 229: fi ! 230: fi ! 231: ! 232: if [ $# = 0 ] ! 233: then ! 234: echo "$usage" 1>&2 ! 235: exit 1 ! 236: fi ! 237: ! 238: # construct spool directory ! 239: for d in `echo $$ | awk '{for (i = 0; i < 1000; ++i) printf "%3d%d\n", i, $1}'` ! 240: do ! 241: if [ ! -f $SDIR/$QPREFIX$d ] ! 242: then ! 243: dir=$QPREFIX$d ! 244: mkdir $SDIR/$dir && break ! 245: echo "dist: can't make spool directory" 1>&2 ! 246: exit 1 ! 247: fi ! 248: done ! 249: ! 250: data=$SDIR/$dir/data ! 251: ctl=$SDIR/$dir/tempctl ! 252: files=$SDIR/$dir/files ! 253: ! 254: # use canonical system names. ! 255: canon $systems | awk '{for (i = 1; i <= NF; ++i) printf "%d %s\n", ++n, $i}' > $ctl ! 256: ! 257: mkpkg "$@" > $data ! 258: ! 259: pwd=`pwd` ! 260: for f in "$@" ! 261: do ! 262: case "$f" in ! 263: -*) # flag to mkpkg ! 264: ;; ! 265: /*) ! 266: echo "$f" ! 267: ;; ! 268: *) ! 269: echo "$pwd/$f" ! 270: ;; ! 271: esac ! 272: done | sort > $files ! 273: ! 274: # rename the ctl file to its real name; at this point the package ! 275: # is now available for shipment. ! 276: mv $ctl $SDIR/$dir/ctl ! 277: ! 278: # supersede old jobs containing the same files ! 279: cd $SDIR ! 280: for d in $QPREFIX* ! 281: do ! 282: test $d = $dir && continue ! 283: test -w $d || continue ! 284: if [ `comm -23 $d/files $dir/files | wc -c` = 0 ] ! 285: then ! 286: sort +1 $d/ctl $dir/ctl | uniq -d -2 | ! 287: while read num sys ! 288: do ! 289: echo superseded by $dir > $d/$num.done ! 290: done ! 291: fi ! 292: done ! 293: ! 294: # clean up any jobs we completely superseded. ! 295: cleanq ! 296: ! 297: done | sort > $files ! 298: ! 299: # rename the ctl file to its real name; at this point the package ! 300: # is now available for shipment. ! 301: mv $ctl $SDIR/$dir/ctl ! 302: ! 303: # supersede old jobs containing the same files ! 304: cd $SDIR ! 305: for d in $QPREFIX* ! 306: do ! 307: test $d = $dir && continue ! 308: test -w $d || continue ! 309: if [ `comm -23 $d/files $dir/files | ape/mkfile 644 3513 4 2060 5031455043 6041 <../mkconf.$SYS ! 310: <../mkrules.$SYS ! 311: ! 312: CFLAGS=-g ! 313: BPROG=dist ! 314: LPROG=receive transmit showq cleanq genmail nightly ! 315: LSUID=transmit cleanq ! 316: ! 317: LIBOBJ=chat.$O chkperm.$O crc.$O eprintf.$O path.$O scanq.$O tryperm.$O ! 318: ! 319: %.$O: %.c ! 320: $CC -DLDIR='"'$LDIR'"' -DSDIR='"'$SDIR'"' -c $stem.c ! 321: ! 322: %: %.$SH ! 323: sed -e s@%LDIR%@$LDIR@ -e s@%SDIR%@$SDIR@ $stem.$SH > $target || rm -f $target ! 324: chmod +x $target ! 325: ! 326: compile:V: $BPROG $LPROG ! 327: ! 328: install:V: compile ! 329: test -d $LDIR || mkdir $LDIR ! 330: test -d $SDIR || mkdir $SDIR && chmod 777 $SDIR ! 331: cp $BPROG $BDIR ! 332: cp $LPROG $LDIR ! 333: (cd $LDIR; chown root $LSUID; chmod 4755 $LSUID) ! 334: ! 335: receive: receive.$O lib.a ../$SYS/lib.a ! 336: $CC -o receive receive.$O lib.a ../$SYS/lib.a $CCLIB ! 337: ! 338: transmit: transmit.$O lib.a ../$SYS/lib.a ! 339: $CC -o transmit transmit.$O lib.a ../$SYS/lib.a $CCLIB ! 340: ! 341: showq: showq.$O lib.a ../$SYS/lib.a ! 342: $CC -o showq showq.$O lib.a ../$SYS/lib.a $CCLIB ! 343: ! 344: cleanq: cleanq.$O lib.a ../$SYS/lib.a ! 345: $CC -o cleanq cleanq.$O lib.a ../$SYS/lib.a $CCLIB ! 346: ! 347: lib.a: ${LIBOBJ:%=lib.a(%)} ! 348: $RL lib.a ! 349: ! 350: lib.a(%): % ! 351: ar r lib.a $stem ! 352: ! 353: clean:V: ! 354: rm -f $BPROG $LPROG *.[$OS] lib.a ! 355: UID; chmod 4755 $LSUID) ! 356: ! 357: receive: receive.$O lib.a ../$SYS/lib.a ! 358: $CC -o receive receive.$O lib.a ../$SYS/lib.a $CCLIB ! 359: ! 360: transmit: transmit.$O lib.a ../$SYS/lib.a ! 361: $CC -o transmit transmit.$O lib.a ../$SYS/lib.a $CCLIB ! 362: ! 363: showq: showq.$O lib.a ../$SYS/lib.a ! 364: $CC -o showq showq.$O lib.a ../$SYS/lib.a $CCLIB ! 365: ! 366: cleanq: cleanq.$O lib.a ../$SYS/lib.a ! 367: $CC -o cleanq cleanq.$O lib.a ../$SYS/lib.a $CCLIB ! 368: ! 369: lib.a: ${LIBOBJ:%=lib.a(%)} ! 370: $RL lib.a ! 371: ! 372: lib.a(%): % ! 373: ar r lib.a $stape/scanq.c 644 3513 4 3466 5032142073 6130 #include <dirent.h> ! 374: #include <limits.h> ! 375: #include <stdio.h> ! 376: #include <stdlib.h> ! 377: #include <string.h> ! 378: #include <unistd.h> ! 379: #include "dist.h" ! 380: ! 381: static char * ! 382: copy(char *s) ! 383: { ! 384: char *r; ! 385: ! 386: r = malloc(strlen(s) + 1); ! 387: if (r) ! 388: strcpy(r, s); ! 389: return r; ! 390: } ! 391: ! 392: static void ! 393: removeq(char *name) ! 394: { ! 395: DIR *dp; ! 396: struct dirent *d; ! 397: char file[2 * MAXNAME + 1]; ! 398: ! 399: name = copy(name); /* readdir bug?!? */ ! 400: if (fork() == 0) { ! 401: setuid(getuid()); ! 402: execl(LDIR "/genmail", "genmail", "-f", name, (char *) 0); ! 403: exit(0); ! 404: } else ! 405: wait(0); ! 406: if (!(dp = opendir(name))) ! 407: return; ! 408: while (d = readdir(dp)) { ! 409: if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) ! 410: continue; ! 411: sprintf(file, "%s/%.*s", name, MAXNAME, d->d_name); ! 412: remove(file); ! 413: } ! 414: closedir(dp); ! 415: rmdir(name); ! 416: free(name); ! 417: } ! 418: ! 419: void ! 420: scanq(char *remsys, void (*func)(char *, int, char *)) ! 421: { ! 422: DIR *dp; ! 423: struct dirent *d; ! 424: FILE *fp; ! 425: char sys[MAXLINE], cansys[MAXLINE], file[MAXNAME]; ! 426: int num, zapq; ! 427: ! 428: if (remsys) ! 429: canon(remsys, cansys); ! 430: ! 431: if (chdir(SDIR) < 0) { ! 432: eprintf("can't chdir %s", SDIR); ! 433: exit(1); ! 434: } ! 435: ! 436: if (!(dp = opendir("."))) { ! 437: eprintf("can't read spool directory!"); ! 438: exit(1); ! 439: } ! 440: ! 441: while (d = readdir(dp)) ! 442: if (strncmp(d->d_name, QPREFIX, strlen(QPREFIX)) == 0) { ! 443: zapq = 1; ! 444: if (chdir(d->d_name) < 0) { ! 445: eprintf("can't chdir %s/%s", SDIR, d->d_name); ! 446: continue; ! 447: } ! 448: if (fp = fopen(CTL, "r")) { ! 449: while (fscanf(fp, "%d%s", &num, sys) == 2) { ! 450: sprintf(file, "%d.%s", num, DONE); ! 451: if (access(file, F_OK) == 0) ! 452: continue; ! 453: if (remsys && strcmp(sys, cansys) != 0) { ! 454: zapq = 0; ! 455: continue; ! 456: } ! 457: if (func) ! 458: (*func)(d->d_name, num, sys); ! 459: if (access(file, F_OK) != 0) ! 460: zapq = 0; ! 461: } ! 462: fclose(fp); ! 463: } else ! 464: eprintf("can't read %s/%s", d->d_name, CTL); ! 465: chdir(".."); ! 466: if (zapq) ! 467: removeq(d->d_name); ! 468: } ! 469: ! 470: closedir(dp); ! 471: } ! 472: if (fp = fopen(CTL, "r")) { ! 473: while (fscanf(fp, "%d%s", &num, sys) == 2) { ! 474: sprintf(file, "%d.%s", num, DONE); ! 475: if (access(file, F_OK) == 0) ! 476: continue; ! 477: if (remsys && strcmp(sys, caape/eprintf.c 644 3513 4 1030 5020312715 6452 #include <stdarg.h> ! 478: #include <stdio.h> ! 479: #include <time.h> ! 480: #include <unistd.h> ! 481: #include "dist.h" ! 482: ! 483: char *prog; ! 484: ! 485: void ! 486: eprintf(char *fmt, ...) ! 487: { ! 488: time_t now; ! 489: char mesg[MAXLINE]; ! 490: va_list ap; ! 491: static int fd = -1; ! 492: ! 493: time(&now); ! 494: sprintf(mesg, "%s[%d %.24s]: ", prog, getpid(), ctime(&now)); ! 495: va_start(ap, fmt); ! 496: vsprintf(mesg + strlen(mesg), fmt, ap); ! 497: strcat(mesg, "\n"); ! 498: write(2, mesg, strlen(mesg)); ! 499: if (fd < 0) ! 500: fd = open(SDIR "/log", 1); ! 501: lseek(fd, 0L, 2); /* we really want O_APPEND mode, but... */ ! 502: write(fd, mesg, strlen(mesg)); ! 503: } ! 504: lude <stdio.h> ! 505: #include <time.h> ! 506: #include <unistd.h> ! 507: #include "dist.h" ! 508: ! 509: char *prog; ! 510: ! 511: void ! 512: eprintf(char *fmt, ...) ! 513: { ! 514: time_t now; ! 515: char mesg[MAXLINE]; ! 516: va_list ap; ! 517: static int fd = -1; ! 518: ! 519: time(&now); ! 520: sprintf(mesg, "%s[%d %.24s]: ", prog, getpid(), ctime(&now)); ! 521: va_start(ap, fmt); ! 522: vsprintf(mesg + strlen(mesg), fmt, ap); ! 523: strcat(mesg, "\n"); ! 524: write(2, mesg, strlen(mesg)); ! 525: if (fd < 0) ! 526: fd = open(SDIR "/log", 1); ! 527: lseek(fd, 0L, 2); /* we really want O_APPEND mode, but... */ ! 528: write(fd,ape/receive.c 644 3513 4 3406 5032661703 6445 #include <stddef.h> ! 529: #include <stdio.h> ! 530: #include <sys/types.h> ! 531: #include <sys/stat.h> ! 532: #include <fcntl.h> ! 533: #include <unistd.h> ! 534: #include "dist.h" ! 535: ! 536: void ! 537: recvjob(void) ! 538: { ! 539: char data[MAXNAME], errs[MAXNAME], mesg[MAXLINE]; ! 540: int dfd, efd, attempt, status; ! 541: ! 542: if (!getline(mesg)) ! 543: exit(0); ! 544: ! 545: if (sscanf(mesg, "begin job %s", data) != 1) { ! 546: eprintf("job header munged: mesg = %s", mesg); ! 547: exit(1); ! 548: } ! 549: ! 550: sprintf(data, "data.%d", getpid()); ! 551: remove(data); ! 552: dfd = creat(data, 0600); /* ape deficiency */ ! 553: close(dfd); ! 554: dfd = open(data, O_RDWR); ! 555: if (dfd < 0) { ! 556: eprintf("can't create data file %s", data); ! 557: exit(1); ! 558: } ! 559: ! 560: if (!recvfile(dfd)) { ! 561: remove(data); ! 562: eprintf("recvfile failed"); ! 563: exit(1); ! 564: } ! 565: ! 566: /* see if file system permissions will likely allow inspkg to succeed */ ! 567: lseek(dfd, 0L, 0); ! 568: attempt = tryperm(dfd); ! 569: sprintf(mesg, "client attempt=%d\n", attempt); ! 570: write(1, mesg, strlen(mesg)); ! 571: ! 572: if (attempt) { ! 573: sprintf(errs, "errs.%d", getpid()); ! 574: efd = creat(errs, 0600); /* more ape bogosity */ ! 575: close(efd); ! 576: efd = open(errs, O_RDWR); ! 577: if (efd < 0) { ! 578: eprintf("can't create errs file %s", errs); ! 579: exit(1); ! 580: } ! 581: ! 582: if (fork()) { ! 583: status = 0xFF; /* evilly catch wait failures */ ! 584: wait(&status); ! 585: if (status & 0xFF) { ! 586: sprintf(mesg, "inspkg: exit %d\n", status & 0xFF); ! 587: write(efd, mesg, strlen(mesg)); ! 588: } ! 589: } else { ! 590: lseek(dfd, 0L, 0); ! 591: dup2(dfd, 0); ! 592: dup2(efd, 1); ! 593: dup2(efd, 2); ! 594: close(dfd); ! 595: close(efd); ! 596: execl(LDIR "/inspkg", "inspkg", 0); ! 597: eprintf("can't exec inspkg"); ! 598: exit(1); ! 599: } ! 600: ! 601: lseek(efd, 0L, 0); ! 602: if (!sendfile(efd)) { ! 603: remove(data); ! 604: remove(errs); ! 605: eprintf("can't send error log"); ! 606: exit(1); ! 607: } ! 608: } ! 609: ! 610: close(dfd); ! 611: remove(data); ! 612: close(efd); ! 613: remove(errs); ! 614: } ! 615: ! 616: int ! 617: main(int argc, char *argv[]) ! 618: { ! 619: prog = argv[0]; ! 620: for (;;) ! 621: recvjob(); ! 622: } ! 623: write(efd, mesg, strlen(mesg)); ! 624: } ! 625: } else { ! 626: lseek(dfd, 0L, 0); ! 627: dup2(dfd, 0); ! 628: dup2(efd, 1); ! 629: dup2(efd, 2); ! 630: close(dfd); ! 631: close(efd); ! 632: execl(LDIR "/inspkg", "inspkg", 0); ! 633: eprintf("can't exec inspkg"); ! 634: exit(1); ! 635: } ! 636: ! 637: lseek(eape/tryperm.c 644 3513 4 6311 5027736536 6536 #include <ctype.h> ! 638: #include <stddef.h> ! 639: #include <stdlib.h> ! 640: #include <stdio.h> ! 641: #include <string.h> ! 642: #include <sys/types.h> ! 643: #include <sys/stat.h> ! 644: #include <fcntl.h> ! 645: #include <unistd.h> ! 646: #include "../pkg/ar.h" ! 647: #include "dist.h" ! 648: ! 649: /* determine if we can create the given pathname. not a generally useful ! 650: function since it destroys the pathname in the process... */ ! 651: static int ! 652: cancreate(char *path, int recurse) ! 653: { ! 654: char *slash; ! 655: ! 656: for (;;) { ! 657: slash = strrchr(path, '/'); ! 658: if (! slash) ! 659: return 0; /* supposed to be absolute */ ! 660: *slash = '\0'; ! 661: if (!*path) ! 662: break; ! 663: if (access(path, W_OK) == 0) ! 664: return 1; ! 665: if (!recurse) /* for remove we check only one directory */ ! 666: return 0; ! 667: if (access(path, F_OK) == 0) ! 668: return 0; ! 669: } ! 670: return access("/", W_OK) == 0; ! 671: } ! 672: ! 673: /* ! 674: * try the instructions of the package on the given fd against the ! 675: * permissions currently in the file system. return 1 if we think we ! 676: * ought to go ahead and try inspkg. ! 677: */ ! 678: int ! 679: tryperm(int fd) ! 680: { ! 681: char armag[SARMAG]; ! 682: struct ar_hdr arhdr; ! 683: long size; ! 684: char temp[L_tmpnam]; ! 685: int tfd; ! 686: FILE *tfp; ! 687: int cmd, c, nf, retval; ! 688: char *path; ! 689: ! 690: /* return 1 so inspkg will be called and barf for us */ ! 691: if (read(fd, armag, sizeof armag) != SARMAG || strncmp(armag, ARMAG, SARMAG)) ! 692: return 1; ! 693: if (read(fd, (char *) &arhdr, sizeof arhdr) != sizeof arhdr) ! 694: return 1; ! 695: size = strtol(arhdr.ar_size, 0, 10); ! 696: tmpnam(temp); ! 697: close(creat(temp, 0600)); /* ape deficiency */ ! 698: tfd = open(temp, O_RDWR); ! 699: if (tfd < 0) { ! 700: eprintf("can't create temp file %s for tryperm", temp); ! 701: remove(temp); /* just in case something's *real* weird */ ! 702: exit(1); ! 703: } ! 704: if (fdcopy(tfd, fd, size, 0) != size) { ! 705: close(tfd); ! 706: remove(temp); ! 707: eprintf("can't extract Instructions in tryperm"); ! 708: return 1; /* inspkg will (presumably) barf for us */ ! 709: } ! 710: lseek(tfd, 0L, 0); ! 711: tfp = fdopen(tfd, "r"); ! 712: ! 713: /* now that we have the instructions file, do the real meat. */ ! 714: retval = 1; ! 715: while ((cmd = getc(tfp)) != EOF) { ! 716: switch (cmd) { ! 717: case 'b': /* b <mode> <dmaj> <dmin> <uid> <gid> <path> */ ! 718: case 'c': /* c <mode> <dmaj> <dmin> <uid> <gid> <path> */ ! 719: nf = 6; ! 720: break; ! 721: case 'd': /* d <mode> <uid> <gid> <path> */ ! 722: case 'f': /* f <component> <uid> <gid> <path> */ ! 723: nf = 4; ! 724: break; ! 725: case 'l': /* l <path1> <path2> */ ! 726: case 's': /* s <path1> <path2> */ ! 727: nf = 2; ! 728: break; ! 729: case 'r': /* r <path> */ ! 730: case 'x': /* x <command> */ ! 731: case 'X': /* X <path> */ ! 732: nf = 1; ! 733: break; ! 734: default: ! 735: goto reterr; ! 736: } ! 737: ! 738: /* get the last field of the line */ ! 739: while (nf--) { ! 740: while ((c = getc(tfp)) != EOF) ! 741: if (!isspace(c)) ! 742: break; ! 743: if (c == EOF) ! 744: goto reterr; ! 745: ungetc(c, tfp); ! 746: path = getpath(tfp); ! 747: } ! 748: ! 749: /* eat the newline */ ! 750: if (getc(tfp) != '\n') ! 751: goto reterr; ! 752: ! 753: switch (cmd) { ! 754: case 'X': ! 755: case 'x': ! 756: break; ! 757: ! 758: case 'r': ! 759: if (access(path, F_OK) != 0) ! 760: break; ! 761: if (cancreate(path, 0)) ! 762: break; ! 763: retval = 0; ! 764: goto out; ! 765: ! 766: default: ! 767: if (cancreate(path, 1)) ! 768: break; ! 769: retval = 0; ! 770: goto out; ! 771: } ! 772: } ! 773: ! 774: out: ! 775: fclose(tfp); ! 776: remove(temp); ! 777: return retval; ! 778: ! 779: reterr: ! 780: /* there was some kind of bug in the format of the package. return 1 ! 781: and later on inspkg will generate an appropriate error message to ! 782: be returned to the remote system */ ! 783: fclose(tfp); ! 784: remove(temp); ! 785: return 1; ! 786: } ! 787: ase 'x': ! 788: break; ! 789: ! 790: case 'r': ! 791: if (access(path, F_OK) != 0) ! 792: break; ! 793: if (cancreate(path, 0)) ! 794: break; ! 795: retval = 0; ! 796: goto out; ! 797: ! 798: default: ! 799: if (cancreate(path, 1)) ! 800: break; ! 801: retval = 0; ! 802: goto out; ! 803: } ! 804: } ! 805: ! 806: out: ! 807: fclose(tfp); ! 808: remove(temp); ! 809: return retval; ! 810: ! 811: reterr: ! 812: /* there was some kindape/dist.h 644 3513 4 1530 5030707254 5767 #define QPREFIX "Q." ! 813: #define CTL "ctl" ! 814: #define DATA "data" ! 815: #define BUSY "busy" ! 816: #define DONE "done" ! 817: #define FILES "files" ! 818: ! 819: #define MAXLINE 256 ! 820: #define MAXNAME 20 ! 821: ! 822: /* system dependent */ ! 823: extern void canon(char *sys, char cansys[]); ! 824: extern int lcreat(char *name, int mode); ! 825: ! 826: /* chat.c */ ! 827: extern int getline(char line[]); ! 828: extern long fdcopy(int dfd, int sfd, long size, unsigned long *crc); ! 829: extern int recvfile(int fd); ! 830: extern int sendfile(int fd); ! 831: ! 832: /* chkperm.c */ ! 833: extern int chkperm(int fd); ! 834: ! 835: /* crc.c */ ! 836: extern void crcinit(int *aux); ! 837: extern unsigned long crcincr(unsigned char *, size_t, unsigned long, int *); ! 838: ! 839: /* eprintf.c */ ! 840: extern char *prog; ! 841: extern void eprintf(char *fmt, ...); ! 842: ! 843: /* path.c */ ! 844: extern char *getpath(FILE *); ! 845: ! 846: /* scanq.c */ ! 847: extern void scanq(char *remsys, void (*func)(char *, int, char *)); ! 848: ! 849: /* tryperm.c */ ! 850: extern int tryperm(int fd); ! 851: , int sfd, long size, unsigned long *crc); ! 852: extern int recvfile(int fd); ! 853: extern int sendfile(int fd); ! 854: ! 855: /* chkperm.c */ ! 856: extern int chkperm(int fd); ! 857: ! 858: /* crc.c */ ! 859: extern voape/chat.c 644 3513 4 3611 5027732160 5740 #include <stddef.h> ! 860: #include <stdio.h> ! 861: #include <unistd.h> ! 862: #include "dist.h" ! 863: ! 864: #define MIN(A, B) ((A) < (B) ? (A) : (B)) ! 865: ! 866: int ! 867: getline(char line[]) ! 868: { ! 869: int i; ! 870: ! 871: i = 0; ! 872: do ! 873: if (read(0, line + i, 1) != 1) ! 874: return 0; ! 875: while (line[i++] != '\n' && i < MAXLINE - 1); ! 876: if (line[i - 1] != '\n') ! 877: return 0; ! 878: line[i] = 0; ! 879: return 1; ! 880: } ! 881: ! 882: long ! 883: fdcopy(int dst, int src, long size, unsigned long *crc) ! 884: { ! 885: char buf[4096]; ! 886: long cc, total; ! 887: int aux; ! 888: ! 889: total = 0; ! 890: if (crc) { ! 891: crcinit(&aux); ! 892: *crc = 0; ! 893: } ! 894: while (total < size) { ! 895: if ((cc = read(src, buf, MIN(sizeof buf, size - total))) <= 0) ! 896: break; ! 897: if (crc) ! 898: *crc = crcincr((unsigned char *) buf, cc, *crc, &aux); ! 899: if (write(dst, buf, cc) != cc) ! 900: break; ! 901: total += cc; ! 902: } ! 903: return total; ! 904: } ! 905: ! 906: int ! 907: sendfile(int fd) ! 908: { ! 909: long len; ! 910: char mesg[MAXLINE]; ! 911: unsigned long crc; ! 912: ! 913: /* size header */ ! 914: len = lseek(fd, 0L, 2); ! 915: lseek(fd, 0L, 0); ! 916: sprintf(mesg, "file length=%ld\n", len); ! 917: write(1, mesg, strlen(mesg)); ! 918: ! 919: /* body */ ! 920: if (fdcopy(1, fd, len, &crc) != len) { ! 921: eprintf("sendfile fdcopy failure"); ! 922: return 0; ! 923: } ! 924: ! 925: /* crc footer */ ! 926: sprintf(mesg, "file crc=%lu\n", crc); ! 927: write(1, mesg, strlen(mesg)); ! 928: ! 929: /* acknowledge */ ! 930: if (!getline(mesg) || strcmp(mesg, "ok\n") != 0) { ! 931: eprintf("sendfile acknowledgement failure"); ! 932: return 0; ! 933: } ! 934: ! 935: return 1; ! 936: } ! 937: ! 938: int ! 939: recvfile(int fd) ! 940: { ! 941: long len; ! 942: char mesg[MAXLINE]; ! 943: unsigned long crc, trycrc; ! 944: ! 945: /* size header */ ! 946: if (!getline(mesg) || sscanf(mesg, "file length=%ld\n", &len) != 1) { ! 947: eprintf("recvfile header munged"); ! 948: return 0; ! 949: } ! 950: ! 951: /* body */ ! 952: if (fdcopy(fd, 0, len, &crc) != len) { ! 953: eprintf("recvfile fdcopy failure"); ! 954: return 0; ! 955: } ! 956: ! 957: /* crc footer */ ! 958: if (!getline(mesg) || sscanf(mesg, "file crc=%lu\n", &trycrc) != 1) { ! 959: eprintf("recvfile footer munged"); ! 960: return 0; ! 961: } ! 962: if (crc != trycrc) { ! 963: eprintf("recvfile crc failure"); ! 964: return 0; ! 965: } ! 966: ! 967: /* acknowledge */ ! 968: sprintf(mesg, "ok\n"); ! 969: write(1, mesg, strlen(mesg)); ! 970: return 1; ! 971: } ! 972: || sscanf(mesg, "file length=%ld\n", &len) != 1) { ! 973: eprintf("recvfile header munged"); ! 974: return 0; ! 975: } ! 976: ! 977: /* body */ ! 978: iape/chkperm.c 644 3513 4 135 5030710456 6426 #include <stddef.h> ! 979: #include <stdio.h> ! 980: #include "dist.h" ! 981: ! 982: int ! 983: chkperm(int fd) ! 984: { ! 985: return 1; ! 986: } ! 987: /* crc footer */ ! 988: if (!getline(mesg) || sscanf(mesg, "file crc=%lu\n", &trycrc) != 1) { ! 989: eprintf("recvfile footer munged"); ! 990: return 0; ! 991: } ! 992: if (crc != trycrc) { ! 993: eprintf("recvfile crc failure"); ! 994: return 0; ! 995: } ! 996: ! 997: /* acknowledge */ ! 998: sprintf(mesg, "ok\n"); ! 999: write(1, mesg, strlen(mesg)); ! 1000: return 1; ! 1001: } ! 1002: || sscanf(mesg, "file length=%ld\n", &len) != 1) { ! 1003: eprintf("recvfile header munged"); ! 1004: return 0; ! 1005: } ! 1006: ! 1007: /* body */ ! 1008: iape/transmit.c 644 3513 4 2347 5025030057 6661 #include <stdio.h> ! 1009: #include <sys/types.h> ! 1010: #include <sys/stat.h> ! 1011: #include <fcntl.h> ! 1012: #include <unistd.h> ! 1013: #include "dist.h" ! 1014: ! 1015: static void ! 1016: sendjob(char *job, int num, char *sys) ! 1017: { ! 1018: char busy[MAXNAME], done[MAXNAME], mesg[MAXLINE]; ! 1019: int fd, attempt; ! 1020: ! 1021: sprintf(busy, "%d.%s", num, BUSY); ! 1022: sprintf(done, "%d.%s", num, DONE); ! 1023: ! 1024: fd = lcreat(busy, 0600); ! 1025: if (fd < 0) ! 1026: return; ! 1027: dup2(fd, 2); ! 1028: close(fd); ! 1029: ! 1030: /* avoid race condition */ ! 1031: if (access(done, F_OK) == 0) ! 1032: goto out; ! 1033: ! 1034: fd = open(DATA, O_RDONLY); ! 1035: if (fd < 0) ! 1036: goto out; ! 1037: ! 1038: if (!chkperm(fd)) { ! 1039: close(fd); ! 1040: goto out; ! 1041: } ! 1042: ! 1043: sprintf(mesg, "begin job %s\n", job); ! 1044: write(1, mesg, strlen(mesg)); ! 1045: ! 1046: if (!sendfile(fd)) ! 1047: goto err; ! 1048: ! 1049: if (!getline(mesg) || sscanf(mesg, "client attempt=%d\n", &attempt) != 1) ! 1050: goto err; ! 1051: if (!attempt) ! 1052: goto out; ! 1053: ! 1054: if (!recvfile(2)) ! 1055: goto err; ! 1056: ! 1057: rename(busy, done); ! 1058: ! 1059: fd = open("/dev/null", O_WRONLY); ! 1060: dup2(fd, 2); ! 1061: close(fd); ! 1062: return; ! 1063: ! 1064: out: ! 1065: /* continue with the next job */ ! 1066: remove(busy); ! 1067: return; ! 1068: ! 1069: err: ! 1070: /* failure that's too hard to resynchronize */ ! 1071: eprintf("sendjob really barfed"); ! 1072: remove(busy); ! 1073: exit(1); ! 1074: } ! 1075: ! 1076: int ! 1077: main(int argc, char *argv[]) ! 1078: { ! 1079: prog = argv[0]; ! 1080: if (argc < 2) { ! 1081: eprintf("usage: transmit system"); ! 1082: return 1; ! 1083: } ! 1084: scanq(argv[1], sendjob); ! 1085: return 0; ! 1086: } ! 1087: = 1) ! 1088: goto err; ! 1089: if (!attempt) ! 1090: goto out; ! 1091: ! 1092: if (!recvfile(2)) ! 1093: goto err; ! 1094: ! 1095: rename(busy, done); ! 1096: ! 1097: fd = open("/dev/null", O_WRONLY); ! 1098: dup2(fd, 2); ! 1099: close(fd); ! 1100: return; ! 1101: ! 1102: out: ! 1103: /* continue with the next job */ ! 1104: remove(busy); ! 1105: return; ! 1106: ! 1107: err: ! 1108: /* failure that's too hard to resynchroape/showq.c 644 3513 4 352 5030710545 6136 #include <stddef.h> ! 1109: #include <stdio.h> ! 1110: #include "dist.h" ! 1111: ! 1112: static void ! 1113: showq(char *job, int num, char *sys) ! 1114: { ! 1115: printf("%s: %d %s\n", job, num, sys); ! 1116: } ! 1117: ! 1118: int ! 1119: main(int argc, char *argv[]) ! 1120: { ! 1121: prog = argv[0]; ! 1122: scanq(0, showq); ! 1123: return 0; ! 1124: } ! 1125: ) ! 1126: goto err; ! 1127: if (!attempt) ! 1128: goto out; ! 1129: ! 1130: if (!recvfile(2)) ! 1131: goto err; ! 1132: ! 1133: rename(busy, done); ! 1134: ! 1135: fd = open("/dev/null", O_WRONLY); ! 1136: dup2(fd, 2); ! 1137: close(fd); ! 1138: return; ! 1139: ! 1140: out: ! 1141: /* continue with the next job */ ! 1142: remove(busy); ! 1143: return; ! 1144: ! 1145: err: ! 1146: /* failure that's too hard to resynchroape/TODO 644 3513 4 330 5023514043 5312 Pervasive error checking: ! 1147: ! 1148: * dist.sh ! 1149: check exit code of mkpkg and other programs; don't ! 1150: make a valid queue entry unless everything went perfectly. ! 1151: * scanq.c transmit.c: ! 1152: inspect for places that need error checking ! 1153: wq); ! 1154: return 0; ! 1155: } ! 1156: ) ! 1157: goto err; ! 1158: if (!attempt) ! 1159: goto out; ! 1160: ! 1161: if (!recvfile(2)) ! 1162: goto err; ! 1163: ! 1164: rename(busy, done); ! 1165: ! 1166: fd = open("/dev/null", O_WRONLY); ! 1167: dup2(fd, 2); ! 1168: close(fd); ! 1169: return; ! 1170: ! 1171: out: ! 1172: /* continue with the next job */ ! 1173: remove(busy); ! 1174: return; ! 1175: ! 1176: err: ! 1177: /* failure that's too hard to resynchroape/path.c 644 3513 4 4341 5027737356 5772 /* brutally hacked from ../pkg/path.c */ ! 1178: ! 1179: #include <ctype.h> ! 1180: #include <stdio.h> ! 1181: #include <stdlib.h> ! 1182: #include "dist.h" ! 1183: ! 1184: #define CHUNK 64 ! 1185: ! 1186: static char *r; ! 1187: static unsigned size; ! 1188: ! 1189: static char * ! 1190: ralloc(char *ptr, size_t size) ! 1191: { ! 1192: char *result; ! 1193: ! 1194: if (!ptr) ! 1195: result = malloc(size); ! 1196: else ! 1197: result = realloc(ptr, size); ! 1198: if (!result) { ! 1199: eprintf("out of memory in getpath"); ! 1200: exit(1); ! 1201: } ! 1202: return result; ! 1203: } ! 1204: ! 1205: char * ! 1206: getpath (FILE *file) ! 1207: { ! 1208: register int c; ! 1209: register int len = 0; ! 1210: ! 1211: c = getc (file); ! 1212: ! 1213: while (!isspace(c) && c != EOF) { ! 1214: register int i = 0, n = 0; ! 1215: ! 1216: /* determine the next input character */ ! 1217: if (c == '\\') { ! 1218: c = getc (file); ! 1219: switch (c) { ! 1220: ! 1221: case '\\': ! 1222: break; ! 1223: ! 1224: case 'n': ! 1225: c = '\n'; ! 1226: break; ! 1227: ! 1228: case 'r': ! 1229: c = '\r'; ! 1230: break; ! 1231: ! 1232: case 't': ! 1233: c = '\t'; ! 1234: break; ! 1235: ! 1236: case 'b': ! 1237: c = '\b'; ! 1238: break; ! 1239: ! 1240: case 'f': ! 1241: c = '\f'; ! 1242: break; ! 1243: ! 1244: case 'v': ! 1245: c = '\v'; ! 1246: break; ! 1247: ! 1248: case ' ': ! 1249: /* c = ' '; */ ! 1250: break; ! 1251: ! 1252: default: ! 1253: while (c >= '0' && c <= '7' && i < 3) { ! 1254: n = (n << 3) + c - '0'; ! 1255: i++; ! 1256: c = getc (file); ! 1257: } ! 1258: ungetc (c, file); ! 1259: c = n; ! 1260: break; ! 1261: } ! 1262: } ! 1263: ! 1264: /* ensure there's room in the buffer */ ! 1265: if (len >= size) ! 1266: r = ralloc (r, size += CHUNK); ! 1267: ! 1268: /* put the character in the buffer */ ! 1269: r[len++] = c; ! 1270: ! 1271: /* read the next character */ ! 1272: c = getc (file); ! 1273: } ! 1274: ! 1275: /* unless we hit eof, we read one character too far. */ ! 1276: if (c != EOF) ! 1277: ungetc (c, file); ! 1278: ! 1279: /* put a final null into the buffer */ ! 1280: if (len >= size) ! 1281: r = ralloc (r, size += CHUNK); ! 1282: r[len] = '\0'; ! 1283: ! 1284: return r; ! 1285: } ! 1286: ! 1287: void ! 1288: putpath (FILE *file, char *path) ! 1289: { ! 1290: register char *p = path; ! 1291: register int c; ! 1292: ! 1293: while ((c = *p++) != NULL) { ! 1294: switch (c) { ! 1295: ! 1296: case '\n': ! 1297: fprintf (file, "\\n"); ! 1298: break; ! 1299: ! 1300: case '\r': ! 1301: fprintf (file, "\\r"); ! 1302: break; ! 1303: ! 1304: case '\b': ! 1305: fprintf (file, "\\b"); ! 1306: break; ! 1307: ! 1308: case '\t': ! 1309: fprintf (file, "\\t"); ! 1310: break; ! 1311: ! 1312: case '\f': ! 1313: fprintf (file, "\\f"); ! 1314: break; ! 1315: ! 1316: case '\v': ! 1317: fprintf (file, "\\v"); ! 1318: break; ! 1319: ! 1320: case '\\': ! 1321: fprintf (file, "\\\\"); ! 1322: break; ! 1323: ! 1324: case ' ': ! 1325: fprintf (file, "\\ "); ! 1326: break; ! 1327: ! 1328: default: ! 1329: if (iscntrl (c)) ! 1330: fprintf (file, ! 1331: *p >= '0' && *p <= '7'? "\\%.3o": "\\%o", ! 1332: c); ! 1333: else ! 1334: putc (c, file); ! 1335: break; ! 1336: } ! 1337: } ! 1338: } ! 1339: e '\r': ! 1340: fprintf (file, "\\r"); ! 1341: break; ! 1342: ! 1343: case '\b': ! 1344: fprintf (file, "\\b"); ! 1345: break; ! 1346: ! 1347: case '\t': ! 1348: fprintf (file, "\\t"); ! 1349: break; ! 1350: ! 1351: case '\f': ! 1352: fprintf (file, "\\f"); ! 1353: break; ! 1354: ! 1355: case '\v': ! 1356: fprintf (file, "\\v"); ! 1357: break; ! 1358: ! 1359: case '\\': ! 1360: fprintf (file, "\\\\")ape/crc.c 644 3513 4 7124 5030710503 5562 #include <stddef.h> ! 1361: #include <stdio.h> ! 1362: #include "dist.h" ! 1363: ! 1364: /* CRC table for cksum from IEEE 1003.2 draft 11. */ ! 1365: const unsigned long crctab[] = { ! 1366: 0x7FFFFFFF, 0x77073096, 0xEE0E612C, 0x990951BA, ! 1367: 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, ! 1368: 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, ! 1369: 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, ! 1370: 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, ! 1371: 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, ! 1372: 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, ! 1373: 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, ! 1374: 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, ! 1375: 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, ! 1376: 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, ! 1377: 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, ! 1378: 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, ! 1379: 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, ! 1380: 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, ! 1381: 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, ! 1382: 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, ! 1383: 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, ! 1384: 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, ! 1385: 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, ! 1386: 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, ! 1387: 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, ! 1388: 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, ! 1389: 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, ! 1390: 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, ! 1391: 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, ! 1392: 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, ! 1393: 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, ! 1394: 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, ! 1395: 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, ! 1396: 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, ! 1397: 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, ! 1398: 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, ! 1399: 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, ! 1400: 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, ! 1401: 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, ! 1402: 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, ! 1403: 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, ! 1404: 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, ! 1405: 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, ! 1406: 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, ! 1407: 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, ! 1408: 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, ! 1409: 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, ! 1410: 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, ! 1411: 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, ! 1412: 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, ! 1413: 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, ! 1414: 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, ! 1415: 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, ! 1416: 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, ! 1417: 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, ! 1418: 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, ! 1419: 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, ! 1420: 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, ! 1421: 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, ! 1422: 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, ! 1423: 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, ! 1424: 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, ! 1425: 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, ! 1426: 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, ! 1427: 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, ! 1428: 0xB3667A2E, 0xC4619AB8, 0x5D681B02, 0x2A6F2B94, ! 1429: 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D, ! 1430: }; ! 1431: ! 1432: void ! 1433: crcinit(int *aux) ! 1434: { ! 1435: *aux = 0; ! 1436: } ! 1437: ! 1438: /* incrementally compute crc for part of a block */ ! 1439: unsigned long ! 1440: crcincr(unsigned char *addr, size_t size, unsigned long crc, int *aux) ! 1441: { ! 1442: int i; ! 1443: ! 1444: while (size--) { ! 1445: i = (crc >> 24) ^ *addr++; ! 1446: if (i == 0) { ! 1447: i = (*aux)++; ! 1448: if (*aux >= sizeof crctab / sizeof crctab[0]) ! 1449: *aux = 0; ! 1450: } ! 1451: crc = (crc << 8) ^ crctab[i]; ! 1452: } ! 1453: return crc; ! 1454: } ! 1455: , 0x54DE5729, 0x23D967BF, ! 1456: 0xB3667A2E, 0xC4619AB8, 0x5D681B02, 0x2A6F2B94, ! 1457: 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D, ! 1458: }; ! 1459: ! 1460: void ! 1461: crcinit(int *aux) ! 1462: { ! 1463: *aux = 0; ! 1464: } ! 1465: ! 1466: /* incrementally compute crc for part of a block */ ! 1467: unsigned long ! 1468: crcincr(unsigned char *addr, size_t size, unsigned long crc, int *aux) ! 1469: { ! 1470: int i; ! 1471: ! 1472: while (size--) { ! 1473: i = (crc >> 24) ^ *addr++; ! 1474: if (i == 0) { ! 1475: i = (*aux)++; ! 1476: if (*aux >= sizeof crctab / siape/genmail.sh 644 3513 4 1605 5031142116 6615 #! /bin/sh - ! 1477: # send mail to a user for the given job ! 1478: # option -f: say this is the final report ! 1479: exec 2>> %SDIR%/log ! 1480: ! 1481: PATH=%LDIR%:/bin:/usr/bin:/usr/ucb:/usr/bsd ! 1482: cd %SDIR% ! 1483: ! 1484: if [ "x$1" = x-f ] ! 1485: then ! 1486: shift ! 1487: final=1 ! 1488: else ! 1489: final=0 ! 1490: fi ! 1491: ! 1492: if [ $# != 1 ] ! 1493: then ! 1494: exit 1 ! 1495: fi ! 1496: ! 1497: user=`ls -ld $1 | awk '{print $3}'` ! 1498: host=`hostname` ! 1499: ! 1500: trap 'rm -f /tmp/genmail.$$' 0 1 2 3 ! 1501: rm -f /tmp/genmail.$$ ! 1502: ! 1503: if [ $final = 0 ] ! 1504: then ! 1505: echo current status report of dist job $host!$1 ! 1506: else ! 1507: echo final status report of dist job $host!$1 ! 1508: fi > /tmp/genmail.$$ ! 1509: ! 1510: while read num sys ! 1511: do ! 1512: if [ -f $1/$num.mail ] ! 1513: then ! 1514: : ! 1515: else ! 1516: if [ -s $1/$num.done ] ! 1517: then ! 1518: echo $sys completed with errors: ! 1519: sed 's/^/ /' $1/$num.done ! 1520: touch $1/$num.mail ! 1521: elif [ -f $1/$num.done ] ! 1522: then ! 1523: echo $sys completed successfully. ! 1524: touch $1/$num.mail ! 1525: else ! 1526: echo $sys not completed. ! 1527: fi ! 1528: fi ! 1529: done < $1/ctl >> /tmp/genmail.$$ ! 1530: ! 1531: mail $user < /tmp/genmail.$$ ! 1532: ] ! 1533: then ! 1534: echo current status report of dist job $host!$1 ! 1535: else ! 1536: echo final status report of dist job $host!$1 ! 1537: fi > /tmp/genmape/nightly.sh 644 3513 4 173 5021521457 6646 #! /bin/sh - ! 1538: # nightly shell script to send mail for unfinished jobs ! 1539: cd %SDIR% ! 1540: for job in Q.* ! 1541: do ! 1542: %LDIR%/genmail $job ! 1543: done ! 1544: d with errors: ! 1545: sed 's/^/ /' $1/$num.done ! 1546: touch $1/$num.mail ! 1547: elif [ -f $1/$num.done ] ! 1548: then ! 1549: echo $sys completed successfully. ! 1550: touch $1/$num.mail ! 1551: else ! 1552: echo $sys not completed. ! 1553: fi ! 1554: fi ! 1555: done < $1/ctl >> /tmp/genmail.$$ ! 1556: ! 1557: mail $user < /tmp/genmail.$$ ! 1558: ] ! 1559: then ! 1560: echo current status report of dist job $host!$1 ! 1561: else ! 1562: echo final status report of dist job $host!$1 ! 1563: fi > /tmp/genmape/cleanq.c 644 3513 4 211 5031454571 6237 #include <stddef.h> ! 1564: #include <stdio.h> ! 1565: #include "dist.h" ! 1566: ! 1567: int ! 1568: main(int argc, char *argv[]) ! 1569: { ! 1570: prog = argv[0]; ! 1571: scanq(0, 0); ! 1572: return 0; ! 1573: } ! 1574: ! 1575: sed 's/^/ /' $1/$num.done ! 1576: touch $1/$num.mail ! 1577: elif [ -f $1/$num.done ] ! 1578: then ! 1579: echo $sys completed successfully. ! 1580: touch $1/$num.mail ! 1581: else ! 1582: echo $sys not completed. ! 1583: fi ! 1584: fi ! 1585: done < $1/ctl >> /tmp/genmail.$$ ! 1586: ! 1587: mail $user < /tmp/genmail.$$ ! 1588: ] ! 1589: then ! 1590: echo current status report of dist job $host!$1 ! 1591: else ! 1592: echo final status report of dist job $host!$1 ! 1593: fi > /tmp/genmdoc.ms 644 3513 4 1177 5032532571 5223 .TL ! 1594: A System for Automatic Source Distribution ! 1595: .AU ! 1596: Mike Haertel ! 1597: .AI ! 1598: AT&T Bell Laboratories ! 1599: Murray Hill, NJ 07974 ! 1600: .AB ! 1601: .\" ! 1602: .\" "Single Heterogeneous network seeks automatic software distribution mechanism..." ! 1603: .\" \(em Greg Lindahl ! 1604: .\" ! 1605: With the advent of wildly heterogeneous networks, automatic software ! 1606: distribution has become a nightmare. Binaries are useless, and source ! 1607: code often fails to recompile across ostensibly standard systems. ! 1608: Finally, security is, as always, a concern, especially when the automatic ! 1609: installation of priviliged system software is desired. We describe ! 1610: yet another attempt to address some of these issues. ! 1611: .AE ! 1612: Single Heterogeneous network seeks automatic software distribution mechanism..." ! 1613: .\" \(em Greg Lindahl ! 1614: .\" ! 1615: With the advent of wildly heterogeneous networks, automatic software ! 1616: distribution has become a nightmare. Binaries are useless, and source ! 1617: code often fails to recompile across ostensibly standard systems. ! 1618: Finally, security is, as always, a concern, especially when the automatigenmkfile.sh 644 3513 4 721 5031150727 6362 #! /bin/sh ! 1619: echo "<mkconf.$1" > mkfile ! 1620: ! 1621: cat << 'EOF' >> mkfile ! 1622: DIRS=ape pkg $SYS ! 1623: ! 1624: %-compile:V: paths.h ! 1625: cd $stem; mk compile ! 1626: ! 1627: %-install:V: %-compile ! 1628: cd $stem; mk install ! 1629: ! 1630: %-clean:V: ! 1631: cd $stem; mk clean ! 1632: ! 1633: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 1634: ! 1635: compile:V: ${DIRS:%=%-compile} ! 1636: ! 1637: install:V: ${DIRS:%=%-install} ! 1638: ! 1639: clean:V: ${DIRS:%=%-clean} ! 1640: rm -f paths.h ! 1641: ! 1642: paths.h: mkconf.$SYS ! 1643: echo '#define LDIR "'$LDIR'"' > paths.h ! 1644: echo '#define SDIR "'$SDIR'"' >> paths.h ! 1645: EOF ! 1646: always, a concern, especially when the automatiman/ 755 3513 4 0 5031450027 4567 man/dist.1 644 3513 4 3344 5031462000 5677 .TH DIST 1 ! 1647: .SH NAME ! 1648: dist \(mi distribute files to remote systems ! 1649: .SH SYNOPSIS ! 1650: .\".BI "dist [ " system " | -[Ff] " file " ] [ -n ] " files ! 1651: .BI "dist [ " system " | -[Ff] " file " ] " files ! 1652: .PP ! 1653: .B "dist -q [" ! 1654: .I system ! 1655: .B "| -[Ff]" ! 1656: .I file ! 1657: .B "]" ! 1658: .PP ! 1659: .B "dist -r [" ! 1660: .I system ! 1661: .B "| -[Ff]" ! 1662: .I file ! 1663: .B "]" ! 1664: .SH DESCRIPTION ! 1665: .I Dist ! 1666: distributes files to other systems, where they are installed ! 1667: under the same names. ! 1668: .I Dist ! 1669: operates by packaging the files with ! 1670: .IR mkpkg (1), ! 1671: and queuing the resulting package in a spool directory to be ! 1672: picked up by the remote systems. ! 1673: .PP ! 1674: The remote systems' names are given as a single argument, containing ! 1675: the system names (in the format of ! 1676: .IR ipc (3)) ! 1677: separated by white space; alternatively, the ! 1678: .B -f ! 1679: option may be used to specify a file containing a list of system names. ! 1680: The ! 1681: .B -F ! 1682: option is identical to ! 1683: .B -f ! 1684: except ! 1685: .I dist ! 1686: looks for the file in a standard directory. ! 1687: .PP ! 1688: The ! 1689: .I dist ! 1690: command has two forms of use. In the first form, ! 1691: .I dist ! 1692: packages a group of files and queues them for transmission. ! 1693: .\"If the ! 1694: .\".B -n ! 1695: .\"option is specified, the remote systems are notified that the package ! 1696: .\"is available. ! 1697: The ! 1698: .I file ! 1699: arguments may be either file names or options for ! 1700: .IR mkpkg (1). ! 1701: .PP ! 1702: When ! 1703: .B -q ! 1704: is given, ! 1705: .I dist ! 1706: queries the named systems and displays the contents of their transmission ! 1707: queues; if no systems are given the local queue is displayed ! 1708: by default. ! 1709: .PP ! 1710: When ! 1711: .B -r ! 1712: is given, ! 1713: .I dist ! 1714: calls the named system and installs any packages it has queued for ! 1715: the local system. ! 1716: .SH EXAMPLES ! 1717: Distribute a new binary for grep to all vaxes: ! 1718: .IP ! 1719: .B "dist -F vaxes /bin/grep" ! 1720: .SH FILES ! 1721: .B /usr/lib/dist/* ! 1722: .br ! 1723: .B /usr/lib/dist/destinations/* ! 1724: .br ! 1725: .B /usr/spool/dist/* ! 1726: .SH "SEE ALSO" ! 1727: .IR mkpkg (1), ! 1728: .IR dist (5), ! 1729: .IR dist (8) ! 1730: I dist ! 1731: queries the named systems and displays the contents of their transmission ! 1732: queues; if no systems are given the local queue is displayed ! 1733: by default. ! 1734: .PP ! 1735: When ! 1736: .B -r ! 1737: is given, ! 1738: .I dist ! 1739: calls the named system and installs any packages it has queued for ! 1740: the local system. ! 1741: .SH EXAMPLESman/dist.5 644 3513 4 3634 5017041737 5723 .TH DIST 5 ! 1742: .SH NAME ! 1743: dist \(mi spool directory structure for ! 1744: .B dist ! 1745: .SH SYNOPSIS ! 1746: .ds sd /usr/spool/dist ! 1747: .B \*(sd/Q.*/ ! 1748: .PP ! 1749: .B \*(sd/Q.*/ctl ! 1750: .PP ! 1751: .B \*(sd/Q.*/data ! 1752: .PP ! 1753: .B \*(sd/Q.*/files ! 1754: .PP ! 1755: .B \*(sd/Q.*/[1-9]*.busy ! 1756: .PP ! 1757: .B \*(sd/Q.*/[1-9]*.done ! 1758: .SH DESCRIPTION ! 1759: The ! 1760: .I dist ! 1761: spool directory contains distributions queued for transmission ! 1762: to remote systems, and is also used as the working directory when ! 1763: unpacking distributions received from remote systems. ! 1764: .PP ! 1765: Each job has its own subdirectory ! 1766: of the spool directory. Several files with conventional names ! 1767: appear in this per-job directory, as well as files with ! 1768: generated names containing status information for each remote ! 1769: system in the job. ! 1770: .PP ! 1771: The files in a job's spool directory include: ! 1772: .TP ! 1773: .B ctl ! 1774: The control file contains a list of identifying numbers ! 1775: and remote system names. The identifying number ! 1776: is used in file names containing status information for corresponding ! 1777: remote system, since network names may not be legal file names. ! 1778: The file contains a sequence of lines; each line contains ! 1779: an identifying number, a space, and the corresponding remote system name. ! 1780: .TP ! 1781: .B data ! 1782: The data file contains the output of ! 1783: .IR mkpkg (1) ! 1784: for the distribution. ! 1785: .TP ! 1786: .B files ! 1787: A list of file names specified in the command line ! 1788: that created the job. This is mainly used as a key ! 1789: for superseding jobs: if a new job is created that ! 1790: contains a superset of the files of some old ! 1791: job, the old job is marked as completed for all remote ! 1792: systems it has in common with the new job. ! 1793: .TP ! 1794: .B [1-9]*.busy ! 1795: An empty lock file indicating that the identified system ! 1796: is currently receiving the distribution. ! 1797: .TP ! 1798: .B [1-9]*.done ! 1799: Status file indicating that the identified system is ! 1800: finished with the distribution. This file is empty ! 1801: if and only if the distribution was successfully installed; ! 1802: otherwise it contains any error messages from the remote ! 1803: system. ! 1804: .SH FILES ! 1805: .B \*(sd/* ! 1806: .SH "SEE ALSO" ! 1807: .IR dist (1), ! 1808: .IR dist (8) ! 1809: b is marked as completed for all remote ! 1810: systems it has in common with the new job. ! 1811: .TP ! 1812: .B [1-9]*.busman/dist.8 644 3513 4 7340 5017051644 5722 .TH DIST 8 ! 1813: .ds ld /usr/lib/dist ! 1814: .SH NAME ! 1815: connect, dispatch \(mi generic network client and server ! 1816: .PP ! 1817: query, receive, notify \(mi network clients ! 1818: .PP ! 1819: answer, transmit, notified \(mi network servers ! 1820: .SH SYNOPSIS ! 1821: .B \*(ld/connect ! 1822: .I remote-system remote-cmd io local-cmd local-args ! 1823: .PP ! 1824: .B \*(ld/query ! 1825: .PP ! 1826: .B \*(ld/receive ! 1827: .I package-id ! 1828: .PP ! 1829: .B \*(ld/notify ! 1830: .I package-id ! 1831: .PP ! 1832: .B \*(ld/dispatch ! 1833: .I remote-system remote-user ! 1834: .PP ! 1835: .B \*(ld/answer ! 1836: .I remote-system remote-user ! 1837: .PP ! 1838: .B \*(ld/transmit ! 1839: .I remote-system remote-user ! 1840: .PP ! 1841: .B \*(ld/notified ! 1842: .I remote-system remote-user ! 1843: .SH DESCRIPTION ! 1844: These programs act behind the scenes on behalf of ! 1845: .IR dist (1). ! 1846: .I Connect ! 1847: and ! 1848: .I dispatch ! 1849: deal with all the details of establishing and authenticating connections ! 1850: on the network. The remaining programs are independent of the underlying ! 1851: network. ! 1852: .PP ! 1853: .I Connect ! 1854: encapsulates all the details of making a call on the underlying network. ! 1855: Its arguments are mostly self explanatory. ! 1856: .I Remote-cmd ! 1857: must be one of ! 1858: .BR answer ", " transmit ", or " notified "." ! 1859: If ! 1860: .I io ! 1861: is ! 1862: .BR i , ! 1863: the standard input of the local command is connected ! 1864: to the standard output of the remote command. If ! 1865: .B i ! 1866: is not specified, the local command inherits its local ! 1867: standard input, and the remote command has its standard ! 1868: output directed to a log file. ! 1869: Similarly, ! 1870: .B o ! 1871: means the standard output of the local command is connected ! 1872: to the standard input of the remote command. If ! 1873: .B o ! 1874: is not specified, the local command inherits its local ! 1875: standard output, and the remote command has its standard ! 1876: input attached to ! 1877: .BR /dev/null . ! 1878: Legal possibilities are ! 1879: .BR i , ! 1880: .BR o , ! 1881: and ! 1882: .BR io. ! 1883: .PP ! 1884: .I Dispatch ! 1885: is intended to be called by a generic network daemon ! 1886: such as ! 1887: .IR svcmgr (8). ! 1888: It talks to ! 1889: .I connect ! 1890: and takes care of establishing the appropriate standard input and ! 1891: output before calling ! 1892: .IR answer , ! 1893: .IR transmit , ! 1894: or ! 1895: .IR notified . ! 1896: .I Dispatch ! 1897: expects arguments giving the remote system, remote user, and remote ! 1898: address, and passes these to whatever program it calls. ! 1899: .PP ! 1900: .I Query ! 1901: is a simple program called by ! 1902: .I connect ! 1903: with its standard input attached to the remote ! 1904: .IR answer . ! 1905: .I Query ! 1906: displays a formatted version of the queue list from the remote machine. ! 1907: (It may even turn out to be the same as ! 1908: .BR /bin/cat .) ! 1909: .PP ! 1910: .I Receive ! 1911: is a more complicated program that is called by ! 1912: .I connect ! 1913: with both its input and output attached to the remote ! 1914: .IR transmit . ! 1915: .I Receive ! 1916: performs actual software installation and sends a transcript of any ! 1917: errors back to the remote system. ! 1918: .PP ! 1919: .I Notify ! 1920: is a simple program called by ! 1921: .I connect ! 1922: with its standard output attached to the remote ! 1923: .IR notified . ! 1924: .I Notify ! 1925: sends an announcement of the availability of some specific package. ! 1926: .PP ! 1927: All of the servers read a configuration file, ! 1928: .BR \*(ld/conf , ! 1929: to determine how to handle installation on behalf ! 1930: of a given remote system and user. The file consists of lines ! 1931: containing patterns and actions. Empty lines or lines beginning ! 1932: with a '\c ! 1933: .BR "#" "'" ! 1934: are ignored. The first three fields (separated by white space) ! 1935: of each line are regular ! 1936: expressions to be matched the remote system name, remote user name, ! 1937: and file name respectively. The first line in which all three match ! 1938: will be chosen. ! 1939: The remainder of the line contains ! 1940: the associated actions. ! 1941: Each action is an alphanumeric name, optionally followed immediately ! 1942: by a parenthesized argument. ! 1943: .PP ! 1944: Someday the actions will be enumerated here, but I don't know what ! 1945: they are yet. ! 1946: .SH EXAMPLES ! 1947: A simple configuration file: ! 1948: .EX ! 1949: .ta \w'00000000'u +\w'00000000'u +\w'00000000'u +\w'00000000'u +\w'00000000'u +\w'00000000'u ! 1950: # system user pathname action ! 1951: # we are willing to distribute stuff to coma and pyxis. ! 1952: (coma|pyxis) .* .* accept(yes) ! 1953: \&.* .* .* accept(no) ! 1954: .EE ! 1955: .SH "SEE ALSO" ! 1956: .IR dist (1), ! 1957: .IR dist (5) ! 1958: ach action is an alphanumeric name, optionally followed immediately ! 1959: by a parenthesized argument. ! 1960: .PP ! 1961: Someday the actions will be enumerated here, but I don't know what ! 1962: they are yet. ! 1963: .SH EXAMPLES ! 1964: A simple configuration file: ! 1965: .EX ! 1966: .ta \w'00000000'u +\w'00000000'u +\w'00000000'u +\w'00000000mkconf.bsd 644 3513 4 106 5031147027 6030 SYS=bsd ! 1967: BDIR=/usr/mjh/bin ! 1968: LDIR=/usr/mjh/dist ! 1969: SDIR=/usr/mjh/dist/spool ! 1970: pkg $SYS ! 1971: ! 1972: %-compile:V: paths.h ! 1973: cd $stem; mk compile ! 1974: ! 1975: %-install:V: %-compile ! 1976: cd $stem; mk install ! 1977: ! 1978: %-clean:V: ! 1979: cd $stem; mk clean ! 1980: ! 1981: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 1982: ! 1983: compile:V: ${DIRS:%=%-compile} ! 1984: ! 1985: install:V: ${DIRS:%=%-install} ! 1986: ! 1987: clean:V: ${DIRS:%=%-clean} ! 1988: rm -f paths.h ! 1989: ! 1990: paths.h: mkconf.$SYS ! 1991: echo '#define LDIR "'$LDIR'"' > paths.h ! 1992: echo '#define SDIR "'$SDIR'"' >> paths.h ! 1993: EOF ! 1994: always, a concern, especially when the automatimkconf.sysv 644 3513 4 73 5031452264 6251 SYS=sysv ! 1995: BDIR=/v/bin ! 1996: LDIR=/v/lib/dist ! 1997: SDIR=/usr/spool/dist ! 1998: dist/spool ! 1999: pkg $SYS ! 2000: ! 2001: %-compile:V: paths.h ! 2002: cd $stem; mk compile ! 2003: ! 2004: %-install:V: %-compile ! 2005: cd $stem; mk install ! 2006: ! 2007: %-clean:V: ! 2008: cd $stem; mk clean ! 2009: ! 2010: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 2011: ! 2012: compile:V: ${DIRS:%=%-compile} ! 2013: ! 2014: install:V: ${DIRS:%=%-install} ! 2015: ! 2016: clean:V: ${DIRS:%=%-clean} ! 2017: rm -f paths.h ! 2018: ! 2019: paths.h: mkconf.$SYS ! 2020: echo '#define LDIR "'$LDIR'"' > paths.h ! 2021: echo '#define SDIR "'$SDIR'"' >> paths.h ! 2022: EOF ! 2023: always, a concern, especially when the automatimkconf.v10 644 3513 4 76 5031450436 5655 SYS=v10 ! 2024: BDIR=/usr/bin ! 2025: LDIR=/usr/lib/dist ! 2026: SDIR=/usr/spool/dist ! 2027: t/spool ! 2028: pkg $SYS ! 2029: ! 2030: %-compile:V: paths.h ! 2031: cd $stem; mk compile ! 2032: ! 2033: %-install:V: %-compile ! 2034: cd $stem; mk install ! 2035: ! 2036: %-clean:V: ! 2037: cd $stem; mk clean ! 2038: ! 2039: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 2040: ! 2041: compile:V: ${DIRS:%=%-compile} ! 2042: ! 2043: install:V: ${DIRS:%=%-install} ! 2044: ! 2045: clean:V: ${DIRS:%=%-clean} ! 2046: rm -f paths.h ! 2047: ! 2048: paths.h: mkconf.$SYS ! 2049: echo '#define LDIR "'$LDIR'"' > paths.h ! 2050: echo '#define SDIR "'$SDIR'"' >> paths.h ! 2051: EOF ! 2052: always, a concern, especially when the automatimkrules.bsd 644 3513 4 57 5031147365 6227 CC=cc -g ! 2053: CCLIB= ! 2054: O=o ! 2055: OS=o ! 2056: SH=sh ! 2057: AR=ar ! 2058: RL=ranlib ! 2059: usr/spool/dist ! 2060: t/spool ! 2061: pkg $SYS ! 2062: ! 2063: %-compile:V: paths.h ! 2064: cd $stem; mk compile ! 2065: ! 2066: %-install:V: %-compile ! 2067: cd $stem; mk install ! 2068: ! 2069: %-clean:V: ! 2070: cd $stem; mk clean ! 2071: ! 2072: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 2073: ! 2074: compile:V: ${DIRS:%=%-compile} ! 2075: ! 2076: install:V: ${DIRS:%=%-install} ! 2077: ! 2078: clean:V: ${DIRS:%=%-clean} ! 2079: rm -f paths.h ! 2080: ! 2081: paths.h: mkconf.$SYS ! 2082: echo '#define LDIR "'$LDIR'"' > paths.h ! 2083: echo '#define SDIR "'$SDIR'"' >> paths.h ! 2084: EOF ! 2085: always, a concern, especially when the automatimkrules.sysv 644 3513 4 64 5031457630 6460 CC=cc -g -I../sysv ! 2086: CCLIB= ! 2087: O=o ! 2088: OS=o ! 2089: SH=sh ! 2090: AR=ar ! 2091: RL=: ! 2092: pool/dist ! 2093: t/spool ! 2094: pkg $SYS ! 2095: ! 2096: %-compile:V: paths.h ! 2097: cd $stem; mk compile ! 2098: ! 2099: %-install:V: %-compile ! 2100: cd $stem; mk install ! 2101: ! 2102: %-clean:V: ! 2103: cd $stem; mk clean ! 2104: ! 2105: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 2106: ! 2107: compile:V: ${DIRS:%=%-compile} ! 2108: ! 2109: install:V: ${DIRS:%=%-install} ! 2110: ! 2111: clean:V: ${DIRS:%=%-clean} ! 2112: rm -f paths.h ! 2113: ! 2114: paths.h: mkconf.$SYS ! 2115: echo '#define LDIR "'$LDIR'"' > paths.h ! 2116: echo '#define SDIR "'$SDIR'"' >> paths.h ! 2117: EOF ! 2118: always, a concern, especially when the automatimkrules.v10 644 3513 4 166 5032136552 6103 CC=/usr/ape/apebin/pcc -g -D_POSIX_SOURCE -D_RESEARCH_SOURCE ! 2119: CCLIB=/usr/ape/lib/libv.a ! 2120: O=o ! 2121: OS=o ! 2122: SH=sh ! 2123: AR=ar ! 2124: RL=ranlib ! 2125: mpile ! 2126: ! 2127: %-install:V: %-compile ! 2128: cd $stem; mk install ! 2129: ! 2130: %-clean:V: ! 2131: cd $stem; mk clean ! 2132: ! 2133: ape-compile pkg-compile:Pexit 1: $SYS-compile ! 2134: ! 2135: compile:V: ${DIRS:%=%-compile} ! 2136: ! 2137: install:V: ${DIRS:%=%-install} ! 2138: ! 2139: clean:V: ${DIRS:%=%-clean} ! 2140: rm -f paths.h ! 2141: ! 2142: paths.h: mkconf.$SYS ! 2143: echo '#define LDIR "'$LDIR'"' > paths.h ! 2144: echo '#define SDIR "'$SDIR'"' >> paths.h ! 2145: EOF ! 2146: always, a concern, especially when the automatinotes/ 755 3513 4 0 5031450036 5144 notes/IDEAS 644 3513 4 1446 5013610625 6010 Use APE everywhere. Keep inspkg, mkpkg, seal, and unseal essential unchanged ! 2147: from old ASD stuff. ! 2148: ! 2149: Client distributee calls distributor rather than vice versa; ! 2150: eliminate the need for trust. ! 2151: ! 2152: Eliminate the crypto stuff; nobody uses it. Either that or figure out ! 2153: a good way to put it in avoiding the problem Dennis mentioned about ! 2154: delayed replies. ! 2155: ! 2156: What about user ids and group ids? There seem to be some hacks ! 2157: for when running setuid under Unix. Does any of that mean anything ! 2158: real, or is it just feeping creaturism? ! 2159: ! 2160: Take out the feature for shipping special files--there is no ! 2161: real support of special files in APE, and we want to run under ! 2162: that everywhere. If you really want to you can ship a script ! 2163: to make special files on the remote machine anyway. (How calvinist ! 2164: are you feeling, Andrew asks?) ! 2165: the problem Dennis mentioned about ! 2166: delayed replies. ! 2167: ! 2168: What about user ids and group ids? There seem to be some hacks ! 2169: for when running setuid under Unix. Does any of that mean anything ! 2170: real, or is it just feeping creanotes/PLAN 644 3513 4 6110 5012057047 5710 The ship system will live in two places, the library directory $L (typically ! 2171: /usr/lib/ship) and the spool directory $S (typically /usr/spool/ship). ! 2172: Operations are of two classes: client functions and server functions. ! 2173: A single machine may operate as both a client and a server. The whole ! 2174: setup is controlled by a single configuration file, $L/conf. ! 2175: ! 2176: The configuration file consists of a sequence of pattern lines interspersed ! 2177: with definitions pertaining to clients or servers matching the patterns. ! 2178: ! 2179: Patterns are of the form 'key: match (match ...) (key: match ...)'; the whole ! 2180: pattern may be prefixed by an exclamation point to negate it. Definitions ! 2181: are of the form var=value, in shell syntax, and appear one to a line prefixed ! 2182: by a tab character. ! 2183: ! 2184: Each match is a restricted globbing expression, of the form understood by the shell. ! 2185: ! 2186: Client and server programs scan the configuration file in order, choosing ! 2187: only the first configuration that applies to a given situation. ! 2188: ! 2189: Lines beginning with a # are comments. ! 2190: ! 2191: For example, the following excerpt might occur in the configuration file of ! 2192: a sources repository machine. ! 2193: ! 2194: # We accept connections from client1, client2, and client3. ! 2195: client: client1 client2 client3 ! 2196: accept=yes ! 2197: client: * ! 2198: accept=no ! 2199: # We periodically poll server1, which sends us some stuff now and then. ! 2200: poll: server1 ! 2201: poll=hourly ! 2202: # The user fred on server1 is a klutz. ! 2203: server: server1 user: fred ! 2204: accept=no ! 2205: # We also don't accept stuff from guests. ! 2206: server: server1 group: guest ! 2207: accept=no ! 2208: # This line applies if none of the rejections above do. ! 2209: server: server1 ! 2210: accept=yes ! 2211: ! 2212: For each configuration (server, client, poll, or other to be invented), some ! 2213: assignments may be optional and others mandatory. For example, for client: ! 2214: and server: configurations, the 'accept=' assignment is probably mandatory. ! 2215: However, for clients the 'notify=' (do we notify them when we have a new package ! 2216: for them, or do we wait for them to call?) is optional and defaults (probably) ! 2217: to 'no'. ! 2218: ! 2219: One uniform option understood by all configuration types is the 'transport=' ! 2220: option, which specifies a program to use to place the network call. On most ! 2221: machines this will probably be subsumed by the networking library, but some ! 2222: might require special treatment. ! 2223: ! 2224: There should be some sort of mechanism for file inclusion. This would allow ! 2225: system administrators to delegate administration of some aspects of the system ! 2226: to other users without actually granting write permission for the $L/conf file. ! 2227: ! 2228: Some specific programs include: ! 2229: ! 2230: $L/poll - a program run periodically on clients to poll appropriate servers ! 2231: $L/client - a program run on the client to accept a shipment from a particular server ! 2232: $L/server - the program run on the server that actually makes shipments ! 2233: $L/notify - a program run on the server to notify clients ! 2234: $L/notified - notify's peer on clients ! 2235: ! 2236: The spool directory will be organized to have one subdirectory for each ! 2237: unfinished job. Each job's subdirectory will contain a data file and ! 2238: control files for each client. This organization makes it easy to ! 2239: atomically access and modify the status of any ongoing job. ! 2240: program run on the client to accept a shipment from a particular server ! 2241: $L/server - the program run on the server that actually makes shipments ! 2242: $L/notify - a program run on the server to notify clients ! 2243: $L/notified - notify's peer on clients ! 2244: ! 2245: The spool directory will be organized to have one subdirectory for each ! 2246: unfinished job. Each job's subdirectory will contain a data file and ! 2247: control files for each client. This organization makesnotes/PLAN2 644 3513 4 6620 5015021031 5763 The nasd (pronounced "nasty") system will live in two places, the library ! 2248: directory $L (typically /usr/lib/nasd) and the spool directory $S (typically ! 2249: /usr/spool/nasd). ! 2250: ! 2251: Operations are of two classes: client functions, and server functions. ! 2252: A machine may act as both a client and a server. ! 2253: ! 2254: The user interface to the system is the 'dist' command (details to be worked out, ! 2255: but mostly like ship, except the destination is taken from argument(s) rather than ! 2256: the environment). ! 2257: ! 2258: Several programs work behind the scenes: ! 2259: ! 2260: $L/connect - make a network connection and call $L/query, $L/receive, or $L/notify ! 2261: $L/query - query a server for pending jobs ! 2262: $L/receive - request a package from a server and optionally install it ! 2263: $L/notify - notify a client that a package is a available ! 2264: ! 2265: $L/dispatch - dispatch incoming network connections to $L/answer, $L/send, or $L/notice ! 2266: $L/answer - the server for query ! 2267: $L/send - the server for receive ! 2268: $L/notice - the server for notify ! 2269: ! 2270: The network programs are organized so they can work on a batch network as well ! 2271: as an interactive network. $L/query, $L/receive expect only input from the ! 2272: network connection; $L/connect passes any initial arguments to the remote server. ! 2273: $L/notify produces only output for the network connection. ! 2274: ! 2275: $L/dispatch, $L/answer, $L/send, and $L/notice are similarly organized. ! 2276: ! 2277: The whole thing is driven by a configuration file $L/conf describing the ! 2278: allowed operations to be requested by remote machines. The format of the ! 2279: file is as follows: Lines beginning with a # are comments and are ignored. ! 2280: Other lines are of the form: ! 2281: ! 2282: service system user pathname action ! 2283: ! 2284: Service is "server" or "client"; system, user, and pathname are regular ! 2285: expressions, and action is a list of actions, separated by +. A sample ! 2286: configuration file might be: ! 2287: ! 2288: # service system user pathname action ! 2289: ! 2290: # we are willing to distribute stuff to coma and pyxis. ! 2291: server (coma|pyxis) .* .* accept(yes) ! 2292: server .* .* .* accept(no) ! 2293: ! 2294: # we don't like fred ! 2295: client .* fred .* accept(no) ! 2296: # we also refuse to accept stuff from root as a matter of principle ! 2297: client .* root .* accept(no) ! 2298: # stuff from bowell!mjh is installed in /usr/bin as root. ! 2299: client bowell mjh /usr/bin/.* accept(yes)+user(root) ! 2300: # we accept files in /usr/pub from anyone on alice, but we don't ! 2301: # execute random commands for them ! 2302: client alice .* /usr/pub/.* accept(yes)+cmds(no) ! 2303: ! 2304: The configuration file is scanned for the first match to get actions. If no ! 2305: match is found the request is rejected. Some actions, such as "accept", must ! 2306: always be provided; others, such as "cmds" have defaults or are otherwise ! 2307: # service system user pathname action ! 2308: ! 2309: # we are willing to distribute stuff to coma and pyxis. ! 2310: transmit (coma|pyxis) .* .* accept(yes) ! 2311: transmit .* .* .* accept(no) ! 2312: ! 2313: # we don't like fred ! 2314: receive .* fred .* accept(no) ! 2315: # we also refuse to accept stuff from root as a matter of principle ! 2316: receive .* root .* accept(no) ! 2317: # stuff from bowell!mjh is installed in /usr/bin as root. ! 2318: receive bowell mjh /usr/bin/.* accept(yes)+user(root) ! 2319: # we accept files in /usr/pub from anyone on alice, but we don't ! 2320: # execute random commands for them ! 2321: receive alice .* /usr/pub/.* accept(yes)+cmds(no) ! 2322: ! 2323: The configuration file is scanned for the first match to get actions. If no ! 2324: match is found the request is rejected. Some actions, such as "accept", must ! 2325: always be provided; others, such as "cmds" have defaults or are otherwise ! 2326: unnecessary. ! 2327: stuff from bowell!mjh is installed in /usr/bin as root. ! 2328: receive bowell mjh /usr/bin/.* accept(yes)+user(rootnotes/PLAN2+ 644 3513 4 0 5012311223 5742 notes/STRATEGY 644 3513 4 2401 5022742334 6420 The client loop: ! 2329: ! 2330: * for each package it receives, it checks if file system permissions ! 2331: will permit that package to be installed. if not, it rejects the ! 2332: package and the server will retransmit it at a later date. ! 2333: * it makes a backup package. ! 2334: * it actually installs the package. if installation fails, it installs ! 2335: the backup package and reports errors to the server. ! 2336: ! 2337: The server loop: ! 2338: * for each queued package matching the remote system name, check if ! 2339: the current user has read access to each component of the package. ! 2340: if not, continue with the next package. ! 2341: * transmit the package. ! 2342: * wait for the client to check file system permissions against the package. ! 2343: the client may decide not to try installing it. if so, defer the package ! 2344: until later, and continue with the next package. ! 2345: * the client has decided to install the package. record the error ! 2346: transcript the client returns (if any), and mark the package as done ! 2347: for that system. (if it was the last outstanding system for the given ! 2348: package, send mail to the owner of the package saying it was done.) ! 2349: ! 2350: spool directory management: ! 2351: * the spool directory and all files therein are owned by daemon. ! 2352: the queue maker and the file server run setuid daemon so they can ! 2353: make and remove queue entries respectively. ! 2354: ue with the next package. ! 2355: * the client has decided to install the package. record the error ! 2356: transcript the client returns (if any), and mark the package as done ! 2357: for that system. (if it was the last outstanding system for the given ! 2358: package, send mailnotes/TODO 644 3513 4 511 5020574003 5675 Figure out which regexp library to use. POSIX mandates one. ! 2359: Perhaps I should write it. ! 2360: ! 2361: Use alarm() on network reads and writes. ! 2362: ! 2363: Write educated mkfiles. ! 2364: ! 2365: Replace NAME_MAX with something that might be less ! 2366: pessimly large, considering that we have control over ! 2367: all file names in use. ! 2368: ! 2369: Add cleanq to the man page. ! 2370: Also add canon. ! 2371: ge. record the error ! 2372: transcript the client returns (if any), and mark the package as done ! 2373: for that system. (if it was the last outstanding system for the given ! 2374: package, send mailpkg/ 755 3513 4 0 5032703620 4576 pkg/HISTORY 644 3513 4 3472 5013610562 5756 04/20/82 Initial version. ! 2375: 05/24/82 Added -b option for backup, created local versions ! 2376: of tmpnam and ftw functions. ! 2377: 06/10/82 Handle strange characters in names. ! 2378: 08/04/82 Packaging a nonexistent file arranges to delete ! 2379: the file during installation. ! 2380: 03/02/83 Handle character uid/gid not present on host ! 2381: 05/02/83 Added seal, unseal. ! 2382: 05/03/83 Split asd command into mkpkg, inspkg; general cleanup ! 2383: 05/12/83 In asdrcv, make separate keyfiles and permfiles. ! 2384: 05/15/83 Seal and unseal now handle lines beginning with "From" ! 2385: 08/26/83 Handle \ in file names properly ! 2386: 08/27/83 Ship is now a real command (well, a shell script...) ! 2387: Asdrcv now looks in /etc/asd/keys and /etc/asd/perm. ! 2388: 09/10/83 It is now possible to package and install special files. ! 2389: 09/15/83 Asdrcv no longer passes -v to inspkg. ! 2390: 09/23/83 Renamed tmpnam to tmpname to avoid conflicts. ! 2391: 09/24/83 Change SIG_TYP to Sig_typ and declare it ("portability"). ! 2392: 04/08/85 Change BMASK to BYTEMASK to avoid clashes with system. ! 2393: 04/10/85 Robustness changes in ship.sh ! 2394: 06/29/85 Makefile now conforms to reality again. ! 2395: 09/10/85 Handle symbolic links in package.c, inspkg.c, mkdir.c ! 2396: 09/10/85 Path.c accounts for \v ! 2397: 09/25/85 added -x and -X to mkpkg and inspkg for execution after installation ! 2398: 09/25/85 asdrcv now sends back stdout as well as stderr ! 2399: 01/29/86 ftw.c now closes directory before calling FTW_DP ! 2400: 05/29/86 numuid() and numgid() return real rather than ! 2401: effective uid and gid on failure ! 2402: 07/04/86 adapted to UNIX PC ! 2403: 07/25/86 reworked system configuration stuff ! 2404: 09/06/86 removed duplicate free() in inspkg.c ! 2405: 09/11/86 arguments to struid() and strgid() should be unsigned ! 2406: 09/25/86 allow imbedded '.' and '-' in machine and user names ! 2407: 11/18/86 inspkg checks for error returns when closing files ! 2408: 01/20/89 more portable installation procedure ! 2409: 01/20/89 remove a special file before trying to install it ! 2410: lling FTW_DP ! 2411: 05/29/86 numuid() and numgid() return real rather than ! 2412: effective uid and gid on failure ! 2413: 07/04/86 adapted to UNIX PC ! 2414: 07/25/86 reworked system configuration stuff ! 2415: 09/06/86 removed duplipkg/TODO 644 3513 4 276 5013610563 5342 Fix up the #include files so they aren't so redundantly included. ! 2416: ! 2417: Make schk() and nchk() more informative. ! 2418: ! 2419: Look into Sig_type. ! 2420: ! 2421: Declare all the externs from "asd.h" in appropriate places. ! 2422: when closing files ! 2423: 01/20/89 more portable installation procedure ! 2424: 01/20/89 remove a special file before trying to install it ! 2425: lling FTW_DP ! 2426: 05/29/86 numuid() and numgid() return real rather than ! 2427: effective uid and gid on failure ! 2428: 07/04/86 adapted to UNIX PC ! 2429: 07/25/86 reworked system configuration stuff ! 2430: 09/06/86 removed duplipkg/alloc.c 644 3513 4 1014 5013610563 6117 /* ! 2431: * storage allocator ! 2432: * ! 2433: * calls malloc or realloc and aborts if unsuccessful ! 2434: */ ! 2435: ! 2436: #include "asd.h" ! 2437: #include <stdio.h> ! 2438: #include <stdlib.h> ! 2439: #include <string.h> ! 2440: ! 2441: void * ! 2442: alloc (size_t n) ! 2443: { ! 2444: register void *p; ! 2445: ! 2446: p = malloc (n); ! 2447: schk (p); ! 2448: return p; ! 2449: } ! 2450: ! 2451: void * ! 2452: ralloc (void *s, size_t n) ! 2453: { ! 2454: register void *p; ! 2455: ! 2456: if (s == NULL) ! 2457: return alloc (n); ! 2458: ! 2459: p = realloc (s, n); ! 2460: schk (p); ! 2461: return p; ! 2462: } ! 2463: ! 2464: /* return a copy of a string */ ! 2465: char * ! 2466: copy (char *s) ! 2467: { ! 2468: register char *r; ! 2469: r = alloc (strlen (s) + 1); ! 2470: strcpy (r, s); ! 2471: return r; ! 2472: } ! 2473: e allocator ! 2474: * ! 2475: * calls malloc or realloc and aborts if unsuccessful ! 2476: */ ! 2477: ! 2478: #include "asd.h" ! 2479: #include <stdio.h> ! 2480: #include <stdlib.h> ! 2481: #include <string.h> ! 2482: ! 2483: void * ! 2484: alloc (size_t n) ! 2485: { ! 2486: register void *p; ! 2487: ! 2488: p = malloc (n); ! 2489: schk (p); ! 2490: return p; ! 2491: } ! 2492: ! 2493: void * ! 2494: ralloc (void *s, size_t n) ! 2495: { ! 2496: register void *p; ! 2497: ! 2498: if (s == NULL) ! 2499: return alloc (n); ! 2500: ! 2501: p = realloc (s, n); ! 2502: schk (p); ! 2503: return p; ! 2504: } ! 2505: ! 2506: /* return a copy of a string */ ! 2507: char * ! 2508: copy (char *s) ! 2509: { ! 2510: register char *r; ! 2511: r = alloc (strlen (s) + 1); ! 2512: strcpy (r, s); ! 2513: pkg/ar.h 644 3513 4 324 5013610563 5417 #define ARMAG "!<arch>\n" ! 2514: #define SARMAG 8 ! 2515: ! 2516: #define ARFMAG "`\n" ! 2517: ! 2518: struct ar_hdr { ! 2519: char ar_name[16]; ! 2520: char ar_date[12]; ! 2521: char ar_uid[6]; ! 2522: char ar_gid[6]; ! 2523: char ar_mode[8]; ! 2524: char ar_size[10]; ! 2525: char ar_fmag[2]; ! 2526: }; ! 2527: = malloc (n); ! 2528: schk (p); ! 2529: return p; ! 2530: } ! 2531: ! 2532: void * ! 2533: ralloc (void *s, size_t n) ! 2534: { ! 2535: register void *p; ! 2536: ! 2537: if (s == NULL) ! 2538: return alloc (n); ! 2539: ! 2540: p = realloc (s, n); ! 2541: schk (p); ! 2542: return p; ! 2543: } ! 2544: ! 2545: /* return a copy of a string */ ! 2546: char * ! 2547: copy (char *s) ! 2548: { ! 2549: register char *r; ! 2550: r = alloc (strlen (s) + 1); ! 2551: strcpy (r, s); ! 2552: pkg/args.c 644 3513 4 6462 5013610564 5776 #include "asd.h" ! 2553: #include <libv.h> ! 2554: #include <string.h> ! 2555: ! 2556: int bflag; /* -b make a backup package */ ! 2557: int kflag; /* -k crypto key (deprecated) */ ! 2558: int Kflag; /* -K crypto key from file (deprecated) */ ! 2559: int nflag; /* -n don't actually install files */ ! 2560: int vflag; /* -v verbose output */ ! 2561: char *xstr; /* -x command to execute */ ! 2562: char *Xstr; /* -X file to execute */ ! 2563: struct replist *replist; /* -D substitutions */ ! 2564: ! 2565: int ! 2566: getargs (int argc, char **argv, char *optkey, int (*func)(FILE *, char *)) ! 2567: { ! 2568: register int c; ! 2569: int rc = 0; ! 2570: char *keyfile; ! 2571: ! 2572: while ((c = getopt (argc, argv, optkey)) != EOF) { ! 2573: register struct replist *rl; ! 2574: register char *p, *q; ! 2575: ! 2576: switch (c) { ! 2577: ! 2578: case 'b': ! 2579: bflag++; ! 2580: break; ! 2581: ! 2582: case 'k': ! 2583: kflag++; ! 2584: break; ! 2585: ! 2586: case 'n': ! 2587: nflag++; ! 2588: break; ! 2589: ! 2590: case 'v': ! 2591: vflag++; ! 2592: break; ! 2593: ! 2594: case 'x': ! 2595: if (xstr) { ! 2596: fprintf (stderr, "duplicate -x ignored\n"); ! 2597: rc++; ! 2598: } else if (Xstr) { ! 2599: fprintf (stderr, "cannot have both -x and -X\n"); ! 2600: rc++; ! 2601: } else ! 2602: xstr = optarg; ! 2603: break; ! 2604: ! 2605: case 'X': ! 2606: if (Xstr) { ! 2607: fprintf (stderr, "duplicate -X ignored\n"); ! 2608: rc++; ! 2609: } else if (xstr) { ! 2610: fprintf (stderr, "cannot have both -x and -X\n"); ! 2611: rc++; ! 2612: } else ! 2613: Xstr = copy (transname (optarg)); ! 2614: break; ! 2615: ! 2616: case 'D': ! 2617: p = strchr (optarg, '='); ! 2618: if (p == NULL) { ! 2619: fprintf (stderr, "invalid option %s\n", optarg); ! 2620: exit (1); ! 2621: } ! 2622: rl = new (struct replist); ! 2623: ! 2624: /* copy the pathname to rl->source */ ! 2625: rl->source = alloc ((unsigned) (p - optarg + 1)); ! 2626: p = rl->source; ! 2627: q = optarg; ! 2628: while (*q != '=') ! 2629: *p++ = *q++; ! 2630: *p = '\0'; ! 2631: ! 2632: /* now expand rl->source */ ! 2633: p = rl->source; ! 2634: rl->source = copy (fullname (p)); ! 2635: free (p); ! 2636: ! 2637: /* expand rl->dest */ ! 2638: rl->dest = copy (fullname (q + 1)); ! 2639: ! 2640: /* link rl into the chain */ ! 2641: rl->link = replist; ! 2642: replist = rl; ! 2643: break; ! 2644: ! 2645: case 'K': ! 2646: Kflag++; ! 2647: keyfile = optarg; ! 2648: break; ! 2649: ! 2650: case '?': ! 2651: default: ! 2652: rc++; ! 2653: break; ! 2654: } ! 2655: } ! 2656: ! 2657: if (rc) { ! 2658: fprintf (stderr, "%s: bad argument\n", argv[0]); ! 2659: exit (rc); ! 2660: } ! 2661: ! 2662: if (kflag && Kflag) { ! 2663: fprintf (stderr, "%s: cannot specify both k and K\n", argv[0]); ! 2664: exit (1); ! 2665: } ! 2666: ! 2667: /* read key from terminal if requested */ ! 2668: if (kflag) { ! 2669: register char *p; ! 2670: p = getpass ("Key:"); ! 2671: ! 2672: /* a null key is treated as no key at all */ ! 2673: if (p && *p) ! 2674: setup (p); ! 2675: else ! 2676: kflag = 0; ! 2677: } ! 2678: ! 2679: /* read key from file if requested */ ! 2680: if (Kflag) { ! 2681: char key[100]; ! 2682: register FILE *kf; ! 2683: register char *p; ! 2684: ! 2685: /* try to open the file */ ! 2686: kf = fopen (keyfile, "r"); ! 2687: if (kf == NULL) { ! 2688: perror (keyfile); ! 2689: exit (1); ! 2690: } ! 2691: ! 2692: /* read the first line */ ! 2693: p = fgets (key, sizeof (key), kf); ! 2694: ! 2695: fclose (kf); ! 2696: ! 2697: /* if EOF, assume no key */ ! 2698: if (p == NULL) { ! 2699: Kflag = 0; ! 2700: } else { ! 2701: ! 2702: /* delete the trailing newline */ ! 2703: p = key; ! 2704: while (*p != '\n' && *p != '\0') ! 2705: p++; ! 2706: *p = '\0'; ! 2707: ! 2708: /* if the key is empty, assume no key */ ! 2709: if (key[0] == '\0') ! 2710: Kflag = 0; ! 2711: else ! 2712: setup (key); ! 2713: } ! 2714: } ! 2715: ! 2716: if (func) { ! 2717: /* process the arguments */ ! 2718: if (optind >= argc) ! 2719: rc = (*func) (stdin, "standard input"); ! 2720: else { ! 2721: register int i; ! 2722: for (i = optind; i < argc; i++) { ! 2723: register char *fn = argv[i]; ! 2724: register FILE *f = fopen (fn, "r"); ! 2725: if (f) { ! 2726: rc += (*func) (f, argv[i]); ! 2727: fclose (f); ! 2728: } else { ! 2729: fprintf (stderr, "%s: can't open %s\n", argv[0], fn); ! 2730: rc++; ! 2731: } ! 2732: } ! 2733: } ! 2734: } ! 2735: ! 2736: return rc; ! 2737: } ! 2738: ssume no key */ ! 2739: if (key[0] == '\0') ! 2740: Kflag = 0; ! 2741: else ! 2742: setup (key); ! 2743: } ! 2744: } ! 2745: ! 2746: if (func) { ! 2747: /* process the arguments */ ! 2748: if (optind >= argc) ! 2749: rc = (*func) (stdin, "standard input"); ! 2750: else { ! 2751: pkg/asd.h 644 3513 4 4124 5014037413 5604 #include "ar.h" ! 2752: #include <stddef.h> ! 2753: #include <stdio.h> ! 2754: #include <stdlib.h> ! 2755: #include <sys/types.h> ! 2756: #include <sys/stat.h> ! 2757: #include <signal.h> ! 2758: #include <ctype.h> ! 2759: #include <errno.h> ! 2760: ! 2761: #if 0 ! 2762: /* system-dependent stuff */ ! 2763: #ifdef unix ! 2764: #ifndef major ! 2765: #include <sys/sysmacros.h> ! 2766: #endif ! 2767: #endif ! 2768: #endif ! 2769: ! 2770: /* longest archive component name we will generate */ ! 2771: #define MAXCOMP 14 ! 2772: ! 2773: /* macro to allocate storage of a given type */ ! 2774: #define new(t) ((t *) alloc (sizeof (t))) ! 2775: ! 2776: /* some systems define SIG_TYP, others don't, so we make our own */ ! 2777: #ifdef __STDC__ ! 2778: typedef void (*Sig_typ)(int); ! 2779: #else ! 2780: typedef int (*Sig_typ)(); ! 2781: #endif ! 2782: ! 2783: struct replist { ! 2784: char *source; ! 2785: char *dest; ! 2786: struct replist *link; ! 2787: }; ! 2788: ! 2789: extern struct replist *replist; ! 2790: ! 2791: /* structures to deal with archive headers */ ! 2792: struct ar_hdr ar_hdr; ! 2793: struct hdr { ! 2794: long size; ! 2795: int mode; ! 2796: long date; ! 2797: }; ! 2798: extern struct hdr hdr; ! 2799: ! 2800: /* alloc.c */ ! 2801: extern void *alloc(size_t); ! 2802: extern void *ralloc(void *, size_t); ! 2803: extern char *copy(char *); ! 2804: ! 2805: /* args.c */ ! 2806: extern int bflag; ! 2807: extern int kflag; ! 2808: extern int Kflag; ! 2809: extern int nflag; ! 2810: extern int vflag; ! 2811: extern char *xstr; ! 2812: extern char *Xstr; ! 2813: extern int getargs(int, char **, char *, int (*)(FILE *, char *)); ! 2814: ! 2815: /* chk.c */ ! 2816: extern void nchk(int); ! 2817: extern void schk(void *); ! 2818: ! 2819: /* crypt.c */ ! 2820: extern void resetN12(void); ! 2821: extern void setup(char *); ! 2822: extern void mangle(char *, char *); ! 2823: ! 2824: /* data.c */ ! 2825: extern char *hextab; ! 2826: extern char *instr; ! 2827: ! 2828: /* fullname.c */ ! 2829: extern char *fullname(char *); ! 2830: ! 2831: /* gid.c */ ! 2832: extern char *gidstr(gid_t); ! 2833: extern gid_t gidnum(char *); ! 2834: ! 2835: /* header.c */ ! 2836: extern long cvlong(char *, size_t, int); ! 2837: extern long read_header(char *, FILE *); ! 2838: extern void next_header(FILE *); ! 2839: extern char *getfield(FILE *); ! 2840: extern void geteol(FILE *); ! 2841: ! 2842: /* mkdir.c */ ! 2843: extern int mkd(char *); ! 2844: extern int rmdir(char *); ! 2845: extern int rmall(char *); ! 2846: ! 2847: /* package.c */ ! 2848: extern void pkgstart(void); ! 2849: extern void pkgfile(char *); ! 2850: extern int pkgend(void); ! 2851: ! 2852: /* path.c */ ! 2853: extern char *getpath(FILE *); ! 2854: extern void putpath(FILE *, char *); ! 2855: ! 2856: /* pwd.c */ ! 2857: extern char *pwd(void); ! 2858: ! 2859: /* transname.c */ ! 2860: extern char *transname(char *); ! 2861: ! 2862: /* uid.c */ ! 2863: extern char *uidstr(uid_t); ! 2864: extern uid_t uidnum(char *); ! 2865: id next_header(FILE *); ! 2866: extern char *getfield(FILE *); ! 2867: extern void geteol(FILE *); ! 2868: ! 2869: /* mkdir.c */ ! 2870: extern int mkd(char *); ! 2871: extern int rmdir(char *); ! 2872: extern int rmall(char *); ! 2873: ! 2874: /* package.c */ ! 2875: extern void pkgstart(void); ! 2876: extern void pkgfile(char *); ! 2877: extern int pkgend(void); ! 2878: ! 2879: /* path.c */ ! 2880: extern char *getpath(FILE *); ! 2881: extern void putpath(FILE *, char *); ! 2882: ! 2883: /* pwd.c */ ! 2884: extern char *pwd(void); ! 2885: ! 2886: /* transname.c */ ! 2887: extern char *transpkg/chk.c 644 3513 4 472 5013610565 5563 #include "asd.h" ! 2888: #include <stdio.h> ! 2889: ! 2890: /* ! 2891: * little subroutines to check return codes ! 2892: */ ! 2893: ! 2894: void ! 2895: nchk (int n) ! 2896: { ! 2897: if (n < 0) { ! 2898: fprintf (stderr, "unexpected error return -- help!\n"); ! 2899: exit (1); ! 2900: } ! 2901: } ! 2902: ! 2903: void ! 2904: schk (void *s) ! 2905: { ! 2906: if (s == NULL) { ! 2907: fprintf (stderr, "unexpected error return -- help!\n"); ! 2908: exit (1); ! 2909: } ! 2910: } ! 2911: pkgfile(char *); ! 2912: extern int pkgend(void); ! 2913: ! 2914: /* path.c */ ! 2915: extern char *getpath(FILE *); ! 2916: extern void putpath(FILE *, char *); ! 2917: ! 2918: /* pwd.c */ ! 2919: extern char *pwd(void); ! 2920: ! 2921: /* transname.c */ ! 2922: extern char *transpkg/crypt.c 644 3513 4 3604 5013610566 6200 /* ! 2923: * encryption service routines ! 2924: */ ! 2925: ! 2926: #include "asd.h" ! 2927: #include <stdio.h> ! 2928: #include <stdlib.h> ! 2929: #include <string.h> ! 2930: #include <sys/types.h> ! 2931: #include <sys/wait.h> ! 2932: #include <unistd.h> ! 2933: ! 2934: /* encryption parameters and tables */ ! 2935: #define ROTORSZ 256 ! 2936: #define MASK 0377 ! 2937: static char t1[ROTORSZ]; ! 2938: static char t2[ROTORSZ]; ! 2939: static char t3[ROTORSZ]; ! 2940: static char t4[ROTORSZ]; ! 2941: ! 2942: /* current rotor settings */ ! 2943: static int N1, N2; ! 2944: ! 2945: void ! 2946: resetN12(void) ! 2947: { ! 2948: N1 = N2 = 0; ! 2949: } ! 2950: ! 2951: void ! 2952: setup(char *pw) ! 2953: { ! 2954: int ic, i, k, temp, pf[2]; ! 2955: unsigned random; ! 2956: char buf[13]; ! 2957: long seed; ! 2958: int pid; ! 2959: ! 2960: resetN12(); ! 2961: ! 2962: strncpy(buf, pw, 8); ! 2963: while (*pw) ! 2964: *pw++ = '\0'; ! 2965: buf[8] = buf[0]; ! 2966: buf[9] = buf[1]; ! 2967: pipe(pf); ! 2968: ! 2969: switch (pid = fork()) { ! 2970: ! 2971: case -1: ! 2972: fprintf (stderr, "seal: cannot fork\n"); ! 2973: exit (1); ! 2974: ! 2975: case 0: ! 2976: close(0); ! 2977: close(1); ! 2978: dup(pf[0]); ! 2979: dup(pf[1]); ! 2980: execl("/usr/lib/makekey", "-", 0); ! 2981: execl("/lib/makekey", "-", 0); ! 2982: exit(1); ! 2983: ! 2984: default: ! 2985: write(pf[1], buf, 10); ! 2986: while (wait ((int *) NULL) != pid) ! 2987: ; ! 2988: } ! 2989: ! 2990: if (read(pf[0], buf, 13) != 13) { ! 2991: fprintf(stderr, "seal: cannot generate key\n"); ! 2992: exit(1); ! 2993: } ! 2994: seed = 123; ! 2995: for (i=0; i<13; i++) ! 2996: seed = seed*buf[i] + i; ! 2997: for(i=0;i<ROTORSZ;i++) ! 2998: t1[i] = i; ! 2999: for(i=0;i<ROTORSZ;i++) { ! 3000: seed = 5*seed + buf[i%13]; ! 3001: random = seed % 65521; ! 3002: k = ROTORSZ-1 - i; ! 3003: ic = (random&MASK)%(k+1); ! 3004: random >>= 8; ! 3005: temp = t1[k]; ! 3006: t1[k] = t1[ic]; ! 3007: t1[ic] = temp; ! 3008: if(t3[k]!=0) continue; ! 3009: ic = (random&MASK) % k; ! 3010: while(t3[ic]!=0) ic = (ic+1) % k; ! 3011: t3[k] = ic; ! 3012: t3[ic] = k; ! 3013: } ! 3014: for(i=0;i<ROTORSZ;i++){ ! 3015: t2[t1[i]&MASK] = i; ! 3016: t4[i] = (t1[i] + t3[i]) & 0377; ! 3017: } ! 3018: } ! 3019: ! 3020: void ! 3021: mangle (char *buf, char *limit) ! 3022: { ! 3023: register int i; ! 3024: register char *p; ! 3025: register int n1 = N1, n2 = N2; ! 3026: int n3; ! 3027: ! 3028: p = buf; ! 3029: ! 3030: while(p < limit) { ! 3031: i = *p; ! 3032: n3 = t4[n1]; ! 3033: i = t2[(t3[(t1[(i+n3)&MASK]+n2)&MASK]-n2)&MASK]-n3; ! 3034: *p++ = i; ! 3035: n1++; ! 3036: if(n1==ROTORSZ) { ! 3037: n1 = 0; ! 3038: n2++; ! 3039: if(n2==ROTORSZ) n2 = 0; ! 3040: } ! 3041: } ! 3042: N1 = n1; ! 3043: N2 = n2; ! 3044: } ! 3045: dom&MASK) % k; ! 3046: while(t3[ic]!=0) ic = (ic+1) % k; ! 3047: t3[k] = ic; ! 3048: t3[ic] = k; ! 3049: } ! 3050: for(i=0;i<ROTORSZ;i++){ ! 3051: t2[t1[i]&MASK] pkg/data.c 644 3513 4 156 5013610566 5727 /* ! 3052: * Initializations ! 3053: */ ! 3054: ! 3055: #include "asd.h" ! 3056: ! 3057: char *hextab = "0123456789abcdef"; ! 3058: char *instr = "Instructions"; ! 3059: char *p; ! 3060: register int n1 = N1, n2 = N2; ! 3061: int n3; ! 3062: ! 3063: p = buf; ! 3064: ! 3065: while(p < limit) { ! 3066: i = *p; ! 3067: n3 = t4[n1]; ! 3068: i = t2[(t3[(t1[(i+n3)&MASK]+n2)&MASK]-n2)&MASK]-n3; ! 3069: *p++ = i; ! 3070: n1++; ! 3071: if(n1==ROTORSZ) { ! 3072: n1 = 0; ! 3073: n2++; ! 3074: if(n2==ROTORSZ) n2 = 0; ! 3075: } ! 3076: } ! 3077: N1 = n1; ! 3078: N2 = n2; ! 3079: } ! 3080: dom&MASK) % k; ! 3081: while(t3[ic]!=0) ic = (ic+1) % k; ! 3082: t3[k] = ic; ! 3083: t3[ic] = k; ! 3084: } ! 3085: for(i=0;i<ROTORSZ;i++){ ! 3086: t2[t1[i]&MASK] pkg/fullname.c 644 3513 4 1461 5013610567 6642 /* ! 3087: * fullname -- return the full pathname corresponding to the ! 3088: * abbreviated pathname given as argument. Returned value ! 3089: * is in a buffer that will stay around no longer than its ! 3090: * argument or the next call to fullname, whichever is earlier. ! 3091: */ ! 3092: ! 3093: #include "asd.h" ! 3094: #include <string.h> ! 3095: ! 3096: char * ! 3097: fullname (char *s) ! 3098: { ! 3099: register char *t; ! 3100: static char *r; ! 3101: static int size; ! 3102: register unsigned n; ! 3103: ! 3104: /* if first char is slash, absolute path */ ! 3105: if (s[0] == '/') ! 3106: return s; ! 3107: ! 3108: /* strip leading './' */ ! 3109: while (s[0] == '.' && s[1] == '/') ! 3110: s += 2; ! 3111: ! 3112: t = pwd(); ! 3113: ! 3114: /* null string or "." means current directory */ ! 3115: if (s[0] == '\0' || strcmp (s, ".") == 0) ! 3116: return t; ! 3117: ! 3118: n = strlen (s) + strlen (t) + 2; ! 3119: if (n > size) { ! 3120: r = ralloc (r, n); ! 3121: size = n; ! 3122: } ! 3123: ! 3124: strcpy (r, t); ! 3125: strcat (r, "/"); ! 3126: strcat (r, s); ! 3127: ! 3128: return r; ! 3129: } ! 3130: (char *s) ! 3131: { ! 3132: register char *t; ! 3133: static char *r; ! 3134: static int size; ! 3135: register unsigned n; ! 3136: ! 3137: /* if first char is slash, absolute path */ ! 3138: if (s[0] == '/') ! 3139: return s; ! 3140: ! 3141: /* strip leading './' */ ! 3142: while (s[0] ==pkg/gid.c 644 3513 4 2533 5013610570 5575 #include "asd.h" ! 3143: #include <grp.h> ! 3144: #include <stdio.h> ! 3145: #include <stdlib.h> ! 3146: #include <string.h> ! 3147: #include <unistd.h> ! 3148: ! 3149: #define CHUNK 16 ! 3150: ! 3151: static struct gtab { ! 3152: unsigned gid; ! 3153: char *name; ! 3154: } *gtab; ! 3155: ! 3156: static int size, salloc; ! 3157: ! 3158: char * ! 3159: gidstr (gid_t gid) ! 3160: { ! 3161: register int i; ! 3162: static char buf[12]; ! 3163: struct group *g; ! 3164: ! 3165: /* search the cache for the gid */ ! 3166: for (i = 0; i < size; i++) ! 3167: if (gtab[i].gid == gid) ! 3168: return gtab[i].name; ! 3169: ! 3170: /* try to find it in the system's database */ ! 3171: if (g = getgrgid(gid)) { ! 3172: if (size % CHUNK == 0) ! 3173: gtab = (struct gtab *) ralloc((char *) gtab, salloc += CHUNK); ! 3174: gtab[size].gid = g->gr_gid; ! 3175: gtab[size].name = copy(g->gr_name); ! 3176: ++size; ! 3177: return gtab[size - 1].name; ! 3178: } ! 3179: ! 3180: /* failure, invent a string */ ! 3181: sprintf (buf, "#%u", gid); ! 3182: return buf; ! 3183: } ! 3184: ! 3185: gid_t ! 3186: gidnum (char *name) ! 3187: { ! 3188: register int i; ! 3189: struct group *g; ! 3190: ! 3191: /* if it starts with a #, use the number */ ! 3192: if (name[0] == '#') ! 3193: return atoi (name + 1); ! 3194: ! 3195: /* search the cache */ ! 3196: for (i = 0; i < size; i++) ! 3197: if (strcmp (gtab[i].name, name) == 0) ! 3198: return gtab[i].gid; ! 3199: ! 3200: /* try to find it in the system's database */ ! 3201: if (g = getgrnam(name)) { ! 3202: if (size % CHUNK == 0) ! 3203: gtab = (struct gtab *) ralloc((char *) gtab, salloc += CHUNK); ! 3204: gtab[size].gid = g->gr_gid; ! 3205: gtab[size].name = copy(g->gr_name); ! 3206: ++size; ! 3207: return gtab[size - 1].gid; ! 3208: } ! 3209: ! 3210: ! 3211: /* failure, invent a value */ ! 3212: return getgid(); ! 3213: } ! 3214: , use the number */ ! 3215: if (name[0] == '#') ! 3216: return atoi (name + 1); ! 3217: ! 3218: /* search the cache */ ! 3219: for (i = 0; i < size; i++) ! 3220: if (strcmp (gtab[i].name, name) == 0) ! 3221: repkg/header.c 644 3513 4 4144 5013610570 6262 /* ! 3222: * various subroutines to deal with archive headers ! 3223: */ ! 3224: ! 3225: #include "asd.h" ! 3226: #include <ctype.h> ! 3227: #include <stdio.h> ! 3228: #include <string.h> ! 3229: ! 3230: struct hdr hdr; ! 3231: ! 3232: /* ! 3233: * convert p to a long value. maximum input length is len, ! 3234: * input is to be interpreted in base b. No negative values. ! 3235: */ ! 3236: long ! 3237: cvlong (char *p, size_t len, int base) ! 3238: { ! 3239: register int i; ! 3240: register long r; ! 3241: ! 3242: r = 0; ! 3243: i = len; ! 3244: ! 3245: do { ! 3246: register int c = *p++; ! 3247: if (isdigit (c)) ! 3248: r = r * base + c - '0'; ! 3249: } while (--i > 0); ! 3250: ! 3251: return r; ! 3252: } ! 3253: ! 3254: long ! 3255: read_header (char *name, FILE *file) ! 3256: { ! 3257: register int n; ! 3258: register int i; ! 3259: register char *p, *q; ! 3260: ! 3261: n = fread ((char *) &ar_hdr, sizeof (ar_hdr), 1, file); ! 3262: if (n != 1) { ! 3263: fprintf (stderr, "can't read %s\n", name); ! 3264: exit (1); ! 3265: } ! 3266: ! 3267: if (strncmp (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag)) != 0) { ! 3268: fprintf (stderr, "input phase error on %s\n", name); ! 3269: exit (1); ! 3270: } ! 3271: ! 3272: /* check the component name, allowing for trailing blanks */ ! 3273: p = name; ! 3274: q = ar_hdr.ar_name; ! 3275: for (i = 0; i < sizeof (ar_hdr.ar_name); i++) { ! 3276: if (*q++ != (*p? *p++: ' ')) { ! 3277: fprintf (stderr, "expected %s, got %.*s\n", ! 3278: name, sizeof (ar_hdr.ar_name), ar_hdr.ar_name); ! 3279: } ! 3280: } ! 3281: ! 3282: /* crack the archive header and put the information in "hdr" */ ! 3283: hdr.size = cvlong (ar_hdr.ar_size, sizeof (ar_hdr.ar_size), 10); ! 3284: hdr.mode = cvlong (ar_hdr.ar_mode, sizeof (ar_hdr.ar_mode), 8); ! 3285: hdr.date = cvlong (ar_hdr.ar_date, sizeof (ar_hdr.ar_date), 10); ! 3286: ! 3287: return hdr.size; ! 3288: } ! 3289: ! 3290: /* advance to the start of the next archive header */ ! 3291: void ! 3292: next_header(FILE *f) ! 3293: { ! 3294: if (hdr.size & 1) ! 3295: getc(f); ! 3296: } ! 3297: ! 3298: /* skip leading white space, return a field */ ! 3299: char * ! 3300: getfield (FILE *f) ! 3301: { ! 3302: register char c; ! 3303: ! 3304: /* skip leading white space */ ! 3305: do c = getc (f); ! 3306: while (isspace (c) && c != '\n'); ! 3307: ! 3308: /* if we hit a newline, something's wrong */ ! 3309: if (c == '\n') { ! 3310: fprintf (stderr, "unexpected newline\n"); ! 3311: exit (1); ! 3312: } ! 3313: ! 3314: /* return the nonblank, read a "pathname" and return it */ ! 3315: ungetc (c, f); ! 3316: return getpath (f); ! 3317: } ! 3318: ! 3319: /* insist on an end of line right here */ ! 3320: void ! 3321: geteol (FILE *f) ! 3322: { ! 3323: register int c; ! 3324: ! 3325: c = getc (f); ! 3326: if (c != '\n') { ! 3327: fprintf (stderr, "expected newline, got %c\n", c); ! 3328: exit (1); ! 3329: } ! 3330: } ! 3331: ister char c; ! 3332: ! 3333: /* skip leading white space */ ! 3334: do c = getc (f); ! 3335: while (isspace (c) && c != '\n'); ! 3336: ! 3337: /* if we hit a newline, something's wrong */ ! 3338: if (c == '\n') { ! 3339: fprintf (stderr, "unexpected newline\n"); ! 3340: exit (1); ! 3341: } ! 3342: ! 3343: /* return the nonblank, read a "pathname" and return it */ ! 3344: ungetc (c, f); ! 3345: return getpath (f); ! 3346: } ! 3347: ! 3348: /* insist on an end of line right here */ ! 3349: void ! 3350: geteol (FILE *f) ! 3351: { ! 3352: register int c; ! 3353: ! 3354: c pkg/inspkg.c 644 3513 4 25371 5013610572 6354 #include "asd.h" ! 3355: #include <libv.h> ! 3356: #include <string.h> ! 3357: #include <sys/types.h> ! 3358: #include <sys/wait.h> ! 3359: #include <unistd.h> ! 3360: #include <utime.h> ! 3361: ! 3362: #define CHUNK 64 ! 3363: ! 3364: /* type codes for installation subroutine */ ! 3365: #define BACKUP 0 ! 3366: #define INSTALL 1 ! 3367: ! 3368: static void readtemp(int, FILE *); ! 3369: ! 3370: /* ! 3371: * The following declarations and functions manipulate ! 3372: * a list of directory names. This list is used to decide ! 3373: * which files should be backed up and which have already been. ! 3374: */ ! 3375: ! 3376: struct list { ! 3377: char *name; ! 3378: struct list *next; ! 3379: }; ! 3380: ! 3381: static struct list *dirs; ! 3382: ! 3383: /* is the name given a subdirectory of the name on the list? */ ! 3384: static int ! 3385: subsumed (char *name) ! 3386: { ! 3387: register struct list *item; ! 3388: register char *p, *q; ! 3389: ! 3390: for (item = dirs; item; item = item->next) { ! 3391: p = item->name; ! 3392: q = name; ! 3393: while (*p && *p == *q) ! 3394: p++, q++; ! 3395: if (*p == '\0' && (*q == '/' || *q == '\0')) ! 3396: return 1; ! 3397: } ! 3398: ! 3399: return 0; ! 3400: } ! 3401: ! 3402: /* add the name given to the list */ ! 3403: static void ! 3404: addlist (char *name) ! 3405: { ! 3406: register struct list *l; ! 3407: ! 3408: l = new (struct list); ! 3409: l->next = dirs; ! 3410: l->name = copy (name); ! 3411: dirs = l; ! 3412: } ! 3413: ! 3414: /* clear the entire list */ ! 3415: static void ! 3416: clearlist(void) ! 3417: { ! 3418: register struct list *l; ! 3419: ! 3420: while (l = dirs) { ! 3421: dirs = l->next; ! 3422: free (l->name); ! 3423: free ((char *) l); ! 3424: } ! 3425: } ! 3426: ! 3427: static char tfname[L_tmpnam]; ! 3428: static void delete(int); ! 3429: ! 3430: /* process a single archive in a concatenation */ ! 3431: static int ! 3432: doarch (FILE *file) ! 3433: { ! 3434: register FILE *tf; ! 3435: Sig_typ sigsav; ! 3436: register long size; ! 3437: register int c; ! 3438: char armag[SARMAG]; ! 3439: ! 3440: /* Make sure the file is an archive */ ! 3441: if (fread (armag, sizeof (*armag), SARMAG, file) != SARMAG) { ! 3442: fprintf (stderr, "inspkg: unexpected EOF\n"); ! 3443: exit (1); ! 3444: } ! 3445: if (strncmp (armag, ARMAG, SARMAG) != 0) { ! 3446: fprintf (stderr, "inspkg: input not a package\n"); ! 3447: exit (1); ! 3448: } ! 3449: ! 3450: /* establish a temporary file */ ! 3451: (void) tmpnam (tfname); ! 3452: tf = fopen (tfname, "w"); ! 3453: sigsav = signal (SIGINT, SIG_IGN); ! 3454: if (sigsav != SIG_IGN) ! 3455: signal (SIGINT, delete); ! 3456: chmod (tfname, 0600); ! 3457: ! 3458: /* copy the installation instructions to the temp file */ ! 3459: size = read_header (instr, file); ! 3460: while (--size >= 0) { ! 3461: c = getc (file); ! 3462: if (c == EOF) { ! 3463: fprintf (stderr, "inspkg: premature EOF\n"); ! 3464: exit (1); ! 3465: } ! 3466: if (putc (c, tf) == EOF) { ! 3467: perror ("inspkg: Instructions"); ! 3468: exit (1); ! 3469: } ! 3470: } ! 3471: if (fclose (tf) == EOF) { ! 3472: perror ("inspkg: Instructions fclose"); ! 3473: exit (1); ! 3474: } ! 3475: ! 3476: next_header (file); ! 3477: ! 3478: /* create the optional backup package */ ! 3479: if (bflag) { ! 3480: pkgstart(); ! 3481: readtemp (BACKUP, file); ! 3482: pkgend(); ! 3483: clearlist(); ! 3484: } ! 3485: ! 3486: /* do the actual work */ ! 3487: readtemp (INSTALL, file); ! 3488: ! 3489: /* delete the temporary file */ ! 3490: nchk (unlink (tfname)); ! 3491: signal (SIGINT, sigsav); ! 3492: ! 3493: return 0; ! 3494: } ! 3495: ! 3496: /* ! 3497: * install the given file ! 3498: */ ! 3499: static int ! 3500: process (FILE *file, char *fname) ! 3501: { ! 3502: register int c, rc = 0; ! 3503: ! 3504: if (vflag) ! 3505: fprintf (stderr, "%s:\n", fname); ! 3506: ! 3507: while ((c = getc (file)) != EOF) { ! 3508: ungetc (c, file); ! 3509: rc += doarch (file); ! 3510: } ! 3511: ! 3512: return rc; ! 3513: } ! 3514: ! 3515: int ! 3516: main (int argc, char **argv) ! 3517: { ! 3518: static char errbuf[BUFSIZ]; ! 3519: ! 3520: setbuf (stderr, errbuf); ! 3521: umask (0); ! 3522: return getargs (argc, argv, "nvbD:", process); ! 3523: } ! 3524: ! 3525: /* ! 3526: * Make a pass through the temp file. ! 3527: */ ! 3528: static void ! 3529: readtemp (int code, FILE *file) ! 3530: { ! 3531: register FILE *tf; ! 3532: register int c; ! 3533: ! 3534: /* we're done writing the temp file, time to read it */ ! 3535: tf = fopen (tfname, "r"); ! 3536: schk ((char *) tf); ! 3537: ! 3538: /* ! 3539: * The main loop -- one iteration per line ! 3540: * We are careful in use and reuse of storage here; ! 3541: * if you change this code make sure you understand ! 3542: * the times at which getfield and transname ! 3543: * recycle storage or strange things will happen. ! 3544: */ ! 3545: while ((c = getc (tf)) != EOF) { ! 3546: char *param, *path, *path2; ! 3547: register FILE *outfd; ! 3548: int uid, gid, mode, dmajor, dminor, dev; ! 3549: register long size; ! 3550: char component[MAXCOMP+1]; ! 3551: ! 3552: switch (c) { ! 3553: ! 3554: #if 0 ! 3555: /* special files */ ! 3556: case 'b': ! 3557: case 'c': ! 3558: /* read the parameters */ ! 3559: param = getfield (tf); ! 3560: mode = cvlong (param, strlen (param), 8) | ! 3561: (c == 'c'? S_IFCHR: S_IFBLK); ! 3562: param = getfield (tf); ! 3563: dmajor = cvlong (param, strlen (param), 10); ! 3564: param = getfield (tf); ! 3565: dminor = cvlong (param, strlen (param), 10); ! 3566: dev = makedev (dmajor, dminor); ! 3567: uid = uidnum (getfield (tf)); ! 3568: gid = gidnum (getfield (tf)); ! 3569: path = transname (getfield (tf)); ! 3570: geteol (tf); ! 3571: ! 3572: switch (code) { ! 3573: ! 3574: case BACKUP: ! 3575: if (!subsumed (path)) { ! 3576: pkgfile (path); ! 3577: addlist (path); ! 3578: } ! 3579: break; ! 3580: ! 3581: case INSTALL: ! 3582: if (vflag) { ! 3583: fprintf (stderr, "special file "); ! 3584: putpath (stderr, path); ! 3585: fprintf (stderr, "\n"); ! 3586: } ! 3587: ! 3588: if (!nflag) { ! 3589: rmall (path); ! 3590: if (mknod (path, mode, dev) >= 0) ! 3591: chown (path, uid, gid); ! 3592: else ! 3593: perror (path); ! 3594: } ! 3595: break; ! 3596: } ! 3597: break; ! 3598: #endif ! 3599: ! 3600: /* directory */ ! 3601: case 'd': ! 3602: /* read the parameters */ ! 3603: param = getfield (tf); ! 3604: mode = cvlong (param, strlen (param), 8); ! 3605: uid = uidnum (getfield (tf)); ! 3606: gid = gidnum (getfield (tf)); ! 3607: path = transname (getfield (tf)); ! 3608: geteol (tf); ! 3609: ! 3610: switch (code) { ! 3611: ! 3612: case BACKUP: ! 3613: if (!subsumed (path)) { ! 3614: pkgfile (path); ! 3615: addlist (path); ! 3616: } ! 3617: break; ! 3618: ! 3619: case INSTALL: ! 3620: /* make the directory */ ! 3621: if (vflag) { ! 3622: fprintf (stderr, "directory "); ! 3623: putpath (stderr, path); ! 3624: putc ('\n', stderr); ! 3625: } ! 3626: if (!nflag) { ! 3627: rmall (path); ! 3628: mkd (path); ! 3629: chmod (path, mode); ! 3630: chown (path, uid, gid); ! 3631: chmod (path, mode); ! 3632: } ! 3633: break; ! 3634: } ! 3635: ! 3636: break; ! 3637: ! 3638: /* file */ ! 3639: case 'f': ! 3640: /* read parameters */ ! 3641: param = getfield (tf); ! 3642: if (strlen (param) > MAXCOMP) { ! 3643: fprintf (stderr, ! 3644: "inspkg: impossibly long component name\n"); ! 3645: delete(0); ! 3646: exit (1); ! 3647: } ! 3648: strcpy (component, param); ! 3649: uid = uidnum (getfield (tf)); ! 3650: gid = gidnum (getfield (tf)); ! 3651: path = transname (getfield (tf)); ! 3652: geteol (tf); ! 3653: ! 3654: switch (code) { ! 3655: ! 3656: case BACKUP: ! 3657: if (!subsumed (path)) ! 3658: pkgfile (path); ! 3659: break; ! 3660: ! 3661: case INSTALL: ! 3662: /* read the corresponding archive header */ ! 3663: size = read_header (component, file); ! 3664: ! 3665: if (vflag) { ! 3666: fprintf (stderr, "file "); ! 3667: putpath (stderr, path); ! 3668: putc ('\n', stderr); ! 3669: } ! 3670: ! 3671: /* create and open the file */ ! 3672: if (!nflag) { ! 3673: rmall (path); ! 3674: umask (077); ! 3675: outfd = fopen (path, "w"); ! 3676: umask (0); ! 3677: if (outfd == NULL) { ! 3678: fprintf (stderr, ! 3679: "inspkg: cannot create "); ! 3680: putpath (stderr, path); ! 3681: putc ('\n', stderr); ! 3682: } ! 3683: } ! 3684: if (nflag || outfd == NULL) { ! 3685: outfd = fopen ("/dev/null", "w"); ! 3686: schk ((char *) outfd); ! 3687: } ! 3688: ! 3689: /* copy the file, advance input */ ! 3690: while (--size >= 0) ! 3691: putc (getc (file), outfd); ! 3692: next_header (file); ! 3693: ! 3694: /* check successful completion, close output */ ! 3695: fflush (outfd); ! 3696: if (feof (file) || ferror (file) || ! 3697: ferror (outfd)) { ! 3698: fprintf (stderr, "inspkg: can't write "); ! 3699: putpath (stderr, path); ! 3700: putc ('\n', stderr); ! 3701: } ! 3702: if (fclose (outfd) == EOF) { ! 3703: fprintf (stderr, "inspkg: can't close "); ! 3704: putpath (stderr, path); ! 3705: fprintf (stderr, ": "); ! 3706: perror (""); ! 3707: } ! 3708: ! 3709: /* ! 3710: * Update output modification times ! 3711: * and change mode and owner. ! 3712: * This is done here to cater to systems ! 3713: * that allow people to give files away. ! 3714: * The chmod is done twice because ! 3715: * systems that let you give files away ! 3716: * won't let you change the mode after ! 3717: * you've done so, and some other systems ! 3718: * turn off the setuid bit as a side ! 3719: * effect of chown, so the second chmod ! 3720: * will restore that bit. ! 3721: */ ! 3722: if (!nflag) { ! 3723: struct utimbuf utb; ! 3724: utb.actime = utb.modtime = hdr.date; ! 3725: utime (path, &utb); ! 3726: chmod (path, hdr.mode & 07777); ! 3727: chown (path, uid, gid); ! 3728: chmod (path, hdr.mode & 07777); ! 3729: } ! 3730: ! 3731: break; ! 3732: } ! 3733: break; ! 3734: ! 3735: /* symbolic link */ ! 3736: case 's': ! 3737: /* read parameters */ ! 3738: path = copy (transname (getfield (tf))); ! 3739: path2 = transname (getfield (tf)); ! 3740: geteol (tf); ! 3741: ! 3742: switch (code) { ! 3743: case BACKUP: ! 3744: if (!subsumed (path2)) ! 3745: pkgfile (path2); ! 3746: break; ! 3747: ! 3748: case INSTALL: ! 3749: /* log it if requested */ ! 3750: if (vflag) { ! 3751: fprintf (stderr, "symlink "); ! 3752: putpath (stderr, path2); ! 3753: fprintf (stderr, " to "); ! 3754: putpath (stderr, path); ! 3755: putc ('\n', stderr); ! 3756: } ! 3757: #ifdef S_ISLNK ! 3758: ! 3759: /* make the link */ ! 3760: if (!nflag) { ! 3761: rmall (path2); ! 3762: if (symlink (path, path2) < 0) ! 3763: perror (path2); ! 3764: } ! 3765: #else ! 3766: fprintf(stderr, "This system does not support symbolic links\n"); ! 3767: #endif ! 3768: ! 3769: break; ! 3770: } ! 3771: free (path); ! 3772: break; ! 3773: ! 3774: /* link */ ! 3775: case 'l': ! 3776: /* read parameters */ ! 3777: path = copy (transname (getfield (tf))); ! 3778: path2 = transname (getfield (tf)); ! 3779: geteol (tf); ! 3780: ! 3781: switch (code) { ! 3782: ! 3783: case BACKUP: ! 3784: if (!subsumed (path2)) ! 3785: pkgfile (path2); ! 3786: break; ! 3787: ! 3788: case INSTALL: ! 3789: /* log it if requested */ ! 3790: if (vflag) { ! 3791: fprintf (stderr, "link "); ! 3792: putpath (stderr, path); ! 3793: fprintf (stderr, " to "); ! 3794: putpath (stderr, path2); ! 3795: putc ('\n', stderr); ! 3796: } ! 3797: ! 3798: /* make the link */ ! 3799: if (!nflag) { ! 3800: struct stat sb, sb2; ! 3801: ! 3802: /* are we about to link x to x? */ ! 3803: if (stat (path, &sb) < 0 ! 3804: || stat (path2, &sb2) < 0 ! 3805: || sb.st_dev != sb2.st_dev ! 3806: || sb.st_ino != sb2.st_ino) { ! 3807: rmall (path2); ! 3808: if (link (path, path2) < 0) ! 3809: perror (path2); ! 3810: } ! 3811: } ! 3812: ! 3813: break; ! 3814: } ! 3815: free (path); ! 3816: break; ! 3817: ! 3818: /* remove */ ! 3819: case 'r': ! 3820: /* get parameters */ ! 3821: path = transname (getfield (tf)); ! 3822: geteol (tf); ! 3823: ! 3824: switch (code) { ! 3825: ! 3826: case BACKUP: ! 3827: if (!subsumed (path)) ! 3828: pkgfile (path); ! 3829: break; ! 3830: ! 3831: case INSTALL: ! 3832: if (vflag) { ! 3833: fprintf (stderr, "remove file "); ! 3834: putpath (stderr, path); ! 3835: putc ('\n', stderr); ! 3836: } ! 3837: if (!nflag) ! 3838: rmall (path); ! 3839: break; ! 3840: } ! 3841: ! 3842: break; ! 3843: ! 3844: case 'x': ! 3845: xstr = getfield (tf); ! 3846: geteol (tf); ! 3847: if (code == INSTALL) { ! 3848: if (vflag) { ! 3849: fprintf (stderr, "execute: "); ! 3850: putpath (stderr, xstr); ! 3851: fprintf (stderr, "\n"); ! 3852: } ! 3853: if (!nflag) { ! 3854: fflush (stderr); ! 3855: system (xstr); ! 3856: } ! 3857: } ! 3858: xstr = NULL; ! 3859: break; ! 3860: ! 3861: case 'X': ! 3862: Xstr = transname (getfield (tf)); ! 3863: geteol (tf); ! 3864: if (code == INSTALL) { ! 3865: if (vflag) { ! 3866: fprintf (stderr, "exec file: "); ! 3867: putpath (stderr, Xstr); ! 3868: fprintf (stderr, "\n"); ! 3869: } ! 3870: if (!nflag) { ! 3871: int status, pid, w; ! 3872: Sig_typ istat, qstat; ! 3873: ! 3874: fflush (stderr); ! 3875: if ((pid = fork()) == 0) { ! 3876: execl (Xstr, Xstr, (char *)0); ! 3877: execl ("/bin/sh", "sh", Xstr, (char *) 0); ! 3878: putpath (stderr, Xstr); ! 3879: fprintf (stderr, ": "); ! 3880: fflush (stderr); ! 3881: perror (""); ! 3882: _exit(127); ! 3883: } ! 3884: istat = signal (SIGINT, SIG_IGN); ! 3885: qstat = signal (SIGQUIT, SIG_IGN); ! 3886: while ((w=wait(&status)) != pid && w != -1) ! 3887: ; ! 3888: signal(SIGINT, istat); ! 3889: signal(SIGQUIT, qstat); ! 3890: } ! 3891: } ! 3892: Xstr = NULL; ! 3893: break; ! 3894: ! 3895: default: ! 3896: fprintf (stderr, "inspkg: invalid package\n"); ! 3897: delete(0); ! 3898: exit (1); ! 3899: } ! 3900: } ! 3901: ! 3902: if (ferror (tf)) ! 3903: perror ("inspkg: internal temp file"); ! 3904: ! 3905: fclose (tf); ! 3906: ! 3907: } ! 3908: ! 3909: static void ! 3910: delete(int sigarg) ! 3911: { ! 3912: unlink (tfname); ! 3913: exit (3); ! 3914: } ! 3915: perror (""); ! 3916: _exit(127); ! 3917: } ! 3918: istat = signal (SIGINT, SIG_IGN); ! 3919: qstat = signal (SIGQUIT, SIG_IGN); ! 3920: while ((w=wait(&status)) != pid && w != -1) ! 3921: ; ! 3922: signal(SIGINT, istat); ! 3923: signal(SIGQUIT, qstat); ! 3924: } ! 3925: } ! 3926: Xstr = NULL; ! 3927: pkg/mkcsum.c 644 3513 4 436 5013610572 6313 #include "seal.h" ! 3928: ! 3929: unsigned long ! 3930: mkcsum (unsigned long csum, char *start, char *limit) ! 3931: { ! 3932: register int c; ! 3933: ! 3934: while (start < limit) { ! 3935: c = (unsigned char) *start++; ! 3936: if (csum & 1) ! 3937: csum = (csum >> 1) | CSHIBIT; ! 3938: else ! 3939: ! 3940: csum >>= 1; ! 3941: csum += c; ! 3942: csum &= CSMASK; ! 3943: } ! 3944: return csum; ! 3945: } ! 3946: } ! 3947: istat = signal (SIGINT, SIG_IGN); ! 3948: qstat = signal (SIGQUIT, SIG_IGN); ! 3949: while ((w=wait(&status)) != pid && w != -1) ! 3950: ; ! 3951: signal(SIGINT, istat); ! 3952: signal(SIGQUIT, qstat); ! 3953: } ! 3954: } ! 3955: Xstr = NULL; ! 3956: pkg/mkdir.c 644 3513 4 4363 5031450263 6144 #include "asd.h" ! 3957: #include <sys/wait.h> ! 3958: #include <unistd.h> ! 3959: #include "ftw.h" ! 3960: ! 3961: #ifndef S_ISLNK ! 3962: #ifdef S_IFLNK ! 3963: #define S_ISLNK(M) (((M)&S_IFMT) == S_IFLNK) ! 3964: #endif ! 3965: #define S_ISREG(M) (((M)&S_IFMT) == S_IFREG) ! 3966: #define S_ISDIR(M) (((M)&S_IFMT) == S_IFDIR) ! 3967: #define S_ISCHR(M) (((M)&S_IFMT) == S_IFCHR) ! 3968: #define S_ISBLK(M) (((M)&S_IFMT) == S_IFBLK) ! 3969: #endif ! 3970: ! 3971: /* ! 3972: * mkd function -- tries to make a directory whose name is "d". ! 3973: * returns 0 if successful or if d already exists and is a ! 3974: * directory. On failure, returns mkdir's return code. ! 3975: */ ! 3976: ! 3977: int ! 3978: mkd (char *d) ! 3979: { ! 3980: register int pid, w; ! 3981: int status; ! 3982: struct stat sb; ! 3983: ! 3984: if (stat (d, &sb) >= 0) ! 3985: return !S_ISDIR(sb.st_mode); ! 3986: ! 3987: switch (pid = fork()) { ! 3988: case 0: ! 3989: /* we might be executed from a setuid program */ ! 3990: setgid (getegid()); ! 3991: setuid (geteuid()); ! 3992: execl ("/bin/mkdir", "mkdir", d, 0); ! 3993: /* No break */ ! 3994: case -1: ! 3995: return 1; ! 3996: ! 3997: default: ! 3998: do w = wait (&status); ! 3999: while (w != pid && w > 0); ! 4000: if (w == pid) ! 4001: return status; ! 4002: return w; ! 4003: } ! 4004: } ! 4005: ! 4006: ! 4007: static int ! 4008: rm (char *name, struct stat *sb, int type, struct FTW *ftw) ! 4009: { ! 4010: register int r; ! 4011: ! 4012: switch (type) { ! 4013: ! 4014: case FTW_F: ! 4015: case FTW_SL: ! 4016: r = unlink (name); ! 4017: if (r < 0) { ! 4018: perror (name); ! 4019: return r; ! 4020: } ! 4021: break; ! 4022: ! 4023: case FTW_D: ! 4024: break; ! 4025: ! 4026: case FTW_DNR: ! 4027: fprintf (stderr, "cannot read directory %s\n", name); ! 4028: exit (1); ! 4029: ! 4030: case FTW_NS: ! 4031: fprintf (stderr, "cannot stat %s\n", name); ! 4032: exit (1); ! 4033: ! 4034: case FTW_DP: ! 4035: r = rmdir (name); ! 4036: if (r != 0) { ! 4037: fprintf (stderr, ! 4038: "trouble removing directory %s\n", name); ! 4039: return r; ! 4040: } ! 4041: } ! 4042: ! 4043: return 0; ! 4044: } ! 4045: ! 4046: /* ! 4047: * rmdir function -- tries to remove a directory whose name is "d". ! 4048: * returns 0 if successful. On failure, returns rmdir's return code. ! 4049: */ ! 4050: ! 4051: int ! 4052: rmdir (char *d) ! 4053: { ! 4054: register int pid, w; ! 4055: int status; ! 4056: struct stat sb; ! 4057: ! 4058: if (stat (d, &sb) >= 0 && !S_ISDIR(sb.st_mode)) ! 4059: return -1; ! 4060: ! 4061: switch (pid = fork()) { ! 4062: case 0: ! 4063: /* we might be executed from a setuid program */ ! 4064: setgid (getegid()); ! 4065: setuid (geteuid()); ! 4066: execl ("/bin/rmdir", "rmdir", d, 0); ! 4067: /* No break */ ! 4068: case -1: ! 4069: return 1; ! 4070: ! 4071: default: ! 4072: do w = wait (&status); ! 4073: while (w != pid && w > 0); ! 4074: if (w == pid) ! 4075: return status; ! 4076: return w; ! 4077: } ! 4078: } ! 4079: ! 4080: /* rmall (s) recursively removes the object named s */ ! 4081: int ! 4082: rmall (char *s) ! 4083: { ! 4084: if (access(s, 0) < 0) ! 4085: return 0; ! 4086: return ftw (s, rm, 8); ! 4087: } ! 4088: &sb) >= 0 && !S_ISDIR(sb.st_mode)) ! 4089: return -1; ! 4090: ! 4091: switch (pid = fork()) { ! 4092: case 0: ! 4093: /* we might be executed from a setuid program */ ! 4094: setgid (getegid()); ! 4095: setuid (geteuid()); ! 4096: execl ("/bin/rmdir", "rmdir", d, 0); ! 4097: /* No break */ ! 4098: case -1: ! 4099: return 1; ! 4100: ! 4101: default: ! 4102: pkg/mkfile 644 3513 4 1607 5031450307 6061 <../mkconf.$SYS ! 4103: <../mkrules.$SYS ! 4104: ! 4105: LPROG=mkpkg inspkg seal unseal ! 4106: LIB=lib-$O.a ! 4107: LIBOBJ=alloc.$O args.$O chk.$O crypt.$O data.$O ftw.$O fullname.$O \ ! 4108: gid.$O header.$O mkcsum.$O mkdir.$O package.$O path.$O pwd.$O \ ! 4109: transname.$O uid.$O ! 4110: ! 4111: compile:V: $LPROG ! 4112: ! 4113: install:V: compile ! 4114: test -d $LDIR || mkdir $LDIR ! 4115: cp $LPROG $LDIR ! 4116: ! 4117: mkpkg: mkpkg.$O $LIB ! 4118: $CC -o $target $prereq $CCLIB ! 4119: ! 4120: inspkg: inspkg.$O $LIB ! 4121: $CC -o $target $prereq $CCLIB ! 4122: ! 4123: seal: seal.$O $LIB ! 4124: $CC -o $target $prereq $CCLIB ! 4125: ! 4126: unseal: unseal.$O $LIB ! 4127: $CC -o $target $prereq $CCLIB ! 4128: ! 4129: lib-$O.a: $LIBOBJ ! 4130: rm -f lib-$O.a ! 4131: ar r lib-$O.a $LIBOBJ ! 4132: $RL lib-$O.a ! 4133: ! 4134: # Need to check these. ! 4135: alloc.$O args.$O data.$O fullname.$O gid.$O: asd.h ar.h ! 4136: header.$O inspkg.$O mkdir.$O: asd.h ar.h ! 4137: mkpkg.$O package.$O path.$O pwd.$O seal.$O: asd.h ar.h ! 4138: transname.$O uid.$O unseal.$O: asd.h ar.h ! 4139: mkcsum.$O seal.$O unseal.$O: seal.h ! 4140: ! 4141: clean:V: ! 4142: rm -f *.[$OS] lib-[$OS].a $LPROG ! 4143: $LIB ! 4144: $CC -o $target $prereq $CCLIB ! 4145: ! 4146: seal: seal.$O $LIB ! 4147: $CC -o $target $prereq $CCLIB ! 4148: ! 4149: unseal: unseal.$O $LIB ! 4150: $CC -o $tpkg/mkpkg.c 644 3513 4 453 5013610574 6126 #include "asd.h" ! 4151: #include <libv.h> ! 4152: #include <stdio.h> ! 4153: ! 4154: int ! 4155: main (int argc, char **argv) ! 4156: { ! 4157: register int i; ! 4158: static char errbuf[BUFSIZ]; ! 4159: ! 4160: setbuf (stderr, errbuf); ! 4161: ! 4162: getargs (argc, argv, "vx:X:D:", 0); ! 4163: ! 4164: pkgstart(); ! 4165: for (i = optind; i < argc; i++) ! 4166: pkgfile (argv[i]); ! 4167: ! 4168: i = pkgend(); ! 4169: ! 4170: return i; ! 4171: } ! 4172: asd.h ar.h ! 4173: mkcsum.$O seal.$O unseal.$O: seal.h ! 4174: ! 4175: clean:V: ! 4176: rm -f *.[$OS] lib-[$OS].a $LPROG ! 4177: $LIB ! 4178: $CC -o $target $prereq $CCLIB ! 4179: ! 4180: seal: seal.$O $LIB ! 4181: $CC -o $target $prereq $CCLIB ! 4182: ! 4183: unseal: unseal.$O $LIB ! 4184: $CC -o $tpkg/package.c 644 3513 4 23235 5032702500 6443 #include "asd.h" ! 4185: #include <string.h> ! 4186: #include <time.h> ! 4187: #include <unistd.h> ! 4188: #include "ftw.h" ! 4189: ! 4190: FILE *tf; ! 4191: static Sig_typ sigsav; ! 4192: static int rc; ! 4193: static char tfname[L_tmpnam]; ! 4194: static struct stat outsb; ! 4195: static struct pack *pkhead, *pktail; ! 4196: ! 4197: /* ! 4198: * The following structure helps keep track of things being packaged. ! 4199: * iname is the internal name of the component -- in other words, ! 4200: * the archive element name. ename is the (short) pathname of the ! 4201: * file. The structures are chained by the "link" field. All the ! 4202: * other fields are copies of things returned by "stat" and are ! 4203: * used mostly to make sure nothing changed while we were packaging. ! 4204: * head and tail point to the first and last items in the chain. ! 4205: * The first item is known to refer to the "Instructions" component. ! 4206: */ ! 4207: struct pack { ! 4208: char *iname; ! 4209: char *ename; ! 4210: struct pack *link; ! 4211: dev_t dev; ! 4212: ino_t ino; ! 4213: int uid, gid, mode; ! 4214: time_t time; ! 4215: off_t size; ! 4216: }; ! 4217: ! 4218: /* ! 4219: * Prepare to build a package. The package will appear on stdout. ! 4220: * The argument is nonzero if remarks are to be read. ! 4221: */ ! 4222: ! 4223: static void ! 4224: delete(int arg) ! 4225: { ! 4226: unlink (tfname); ! 4227: exit (3); ! 4228: } ! 4229: ! 4230: void ! 4231: pkgstart(void) ! 4232: { ! 4233: struct stat pks; ! 4234: ! 4235: rc = 0; ! 4236: ! 4237: nchk (fstat (fileno (stdout), &outsb)); ! 4238: ! 4239: /* establish a temporary file to hold the instruction information */ ! 4240: tmpnam (tfname); ! 4241: tf = fopen (tfname, "w"); ! 4242: sigsav = signal (SIGINT, SIG_IGN); ! 4243: if (sigsav != SIG_IGN) ! 4244: signal (SIGINT, delete); ! 4245: nchk (chmod (tfname, 0644)); ! 4246: schk ((char *) tf); ! 4247: ! 4248: /* create the initial element in the component chain */ ! 4249: pkhead = pktail = new (struct pack); ! 4250: pkhead->iname = copy (instr); ! 4251: pkhead->ename = copy (tfname); ! 4252: pkhead->time = 0; ! 4253: pkhead->link = NULL; ! 4254: pkhead->uid = getuid(); ! 4255: nchk (fstat (fileno(tf), &pks)); ! 4256: pkhead->gid = pks.st_gid; ! 4257: pkhead->mode = 0100644; ! 4258: } ! 4259: ! 4260: static int consider(char *, struct stat *, int, struct FTW *); ! 4261: ! 4262: /* ! 4263: * put a file (or directory) into a package ! 4264: */ ! 4265: void ! 4266: pkgfile (char *file) ! 4267: { ! 4268: register int x; ! 4269: struct stat sb; ! 4270: ! 4271: /* if the file is truly not present, generate a remove request */ ! 4272: #ifdef S_IFLNK ! 4273: if (lstat (file, &sb) < 0 && errno == ENOENT) { ! 4274: #else ! 4275: if (stat (file, &sb) < 0 && errno == ENOENT) { ! 4276: #endif ! 4277: fprintf (tf, "r "); ! 4278: putpath (tf, transname (file)); ! 4279: putc ('\n', tf); ! 4280: } else { ! 4281: x = ftw (file, consider, 8); ! 4282: if (x != 0) { ! 4283: rc++; ! 4284: if (x == -1) ! 4285: perror (file); ! 4286: } ! 4287: } ! 4288: } ! 4289: ! 4290: /* ! 4291: * we are done building a package. This writes the actual file ! 4292: * contents, so make sure the files are still around ! 4293: */ ! 4294: int ! 4295: pkgend(void) ! 4296: { ! 4297: register struct pack *pack; ! 4298: struct stat s; ! 4299: ! 4300: /* write 'x' or 'X' execution item if requested */ ! 4301: if (xstr) { ! 4302: fprintf (tf, "x "); ! 4303: putpath (tf, xstr); ! 4304: fprintf (tf, "\n"); ! 4305: } ! 4306: if (Xstr) { ! 4307: fprintf (tf, "X "); ! 4308: putpath (tf, Xstr); ! 4309: fprintf (tf, "\n"); ! 4310: } ! 4311: ! 4312: /* we now know how long the first component is */ ! 4313: pkhead->size = ftell (tf); ! 4314: ! 4315: /* we no longer need to write the temporary file */ ! 4316: fclose (tf); ! 4317: ! 4318: /* describe the temp file correctly so it will pass later checks */ ! 4319: if (pkhead->time == 0) ! 4320: (void) time (&pkhead->time); ! 4321: nchk (stat (tfname, &s)); ! 4322: pkhead->dev = s.st_dev; ! 4323: pkhead->ino = s.st_ino; ! 4324: ! 4325: /* ! 4326: * write the files out into an archive ! 4327: */ ! 4328: ! 4329: /* first the archive header */ ! 4330: printf (ARMAG); ! 4331: ! 4332: /* ! 4333: * run through the list, creating the archive components ! 4334: * and deleting the list entries. One iteration per component. ! 4335: * We know there is at least one component, because the ! 4336: * "Instructions" component must be represented. ! 4337: */ ! 4338: do { ! 4339: struct ar_hdr ah; ! 4340: char buf[30]; ! 4341: register int c; ! 4342: ! 4343: /* "pack" is the package component under consideration */ ! 4344: pack = pkhead; ! 4345: ! 4346: if (pack->iname) { /* non-regular file entry, no data */ ! 4347: ! 4348: /* log it if requested */ ! 4349: if (vflag) ! 4350: fprintf (stderr, "package %s\n", ! 4351: strcmp (pack->iname, instr)? pack->ename: instr); ! 4352: ! 4353: /* write the archive element header */ ! 4354: ! 4355: # define ent(a,x) sprintf(buf, "%-*s", sizeof(ah.a), x); \ ! 4356: strncpy (ah.a, buf, sizeof (ah.a)) ! 4357: ent (ar_name, pack->iname); ! 4358: ent (ar_fmag, ARFMAG); ! 4359: # undef ent ! 4360: ! 4361: # define ent(a,x) sprintf(buf, "%*ld", sizeof(ah.a), (long) x); \ ! 4362: strncpy (ah.a, buf, sizeof (ah.a)) ! 4363: ent (ar_date, pack->time); ! 4364: ent (ar_uid, pack->uid); ! 4365: ent (ar_gid, pack->gid); ! 4366: ent (ar_size, pack->size); ! 4367: # undef ent ! 4368: ! 4369: # define ent(a,x) sprintf(buf, "%*o", sizeof(ah.a), x); \ ! 4370: strncpy (ah.a, buf, sizeof (ah.a)) ! 4371: ent (ar_mode, pack->mode); ! 4372: # undef ent ! 4373: ! 4374: fwrite ((char *) &ah, sizeof (ah), 1, stdout); ! 4375: ! 4376: /* write the archive element itself */ ! 4377: tf = fopen (pack->ename, "r"); ! 4378: if (tf == NULL) { ! 4379: perror (pack->iname); ! 4380: exit (1); ! 4381: } ! 4382: ! 4383: while ((c = getc (tf)) != EOF) ! 4384: putchar (c); ! 4385: ! 4386: /* if things now don't match, complain */ ! 4387: if (fstat (fileno (tf), &s) < 0 || s.st_size != pack->size || ! 4388: (s.st_mtime != pack->time && strcmp (pack->iname, instr)) || ! 4389: s.st_dev != pack->dev || s.st_ino != pack->ino || ! 4390: s.st_uid != pack->uid || s.st_gid != pack->gid || ! 4391: (s.st_mode & 07777) != (pack->mode & 07777)) { ! 4392: fprintf (stderr, "phase error on %s\n", ! 4393: pack->ename); ! 4394: rc++; ! 4395: } ! 4396: ! 4397: fclose (tf); ! 4398: ! 4399: if (pack->size & 1) ! 4400: putchar ('\n'); ! 4401: } ! 4402: ! 4403: /* delete the element, move on to the next */ ! 4404: if (pack->iname) free (pack->iname); ! 4405: free (pack->ename); ! 4406: pkhead = pack->link; ! 4407: free ((char *) pack); ! 4408: } while (pkhead); ! 4409: ! 4410: /* zap the tail pointer for general cleanliness */ ! 4411: pktail = NULL; ! 4412: ! 4413: nchk (unlink (tfname)); ! 4414: signal (SIGINT, sigsav); ! 4415: ! 4416: return rc; ! 4417: } ! 4418: ! 4419: static void hdrsub(char *, struct stat *); ! 4420: static char *iname(char *); ! 4421: ! 4422: /* internal function for package creation */ ! 4423: static int ! 4424: consider (char *name, struct stat *buf, int type, struct FTW *ftw) ! 4425: { ! 4426: register struct pack *pack; ! 4427: register int mode; ! 4428: char *biname; ! 4429: #ifdef S_ISLNK ! 4430: char *slname; ! 4431: #endif ! 4432: ! 4433: switch (type) { ! 4434: case FTW_D: ! 4435: fprintf (tf, "d %-*.4o ", MAXCOMP, buf->st_mode & 07777); ! 4436: hdrsub (name, buf); ! 4437: fprintf (tf, "\n"); ! 4438: break; ! 4439: ! 4440: case FTW_SL: ! 4441: if (ftw->level == 0) { ! 4442: ftw->quit = FTW_FOLLOW; ! 4443: return 0; ! 4444: } ! 4445: /* fall through */ ! 4446: ! 4447: case FTW_F: ! 4448: mode = buf->st_mode; ! 4449: ! 4450: /* Has this file already appeared? If so, it's a link */ ! 4451: for (pack = pkhead->link; pack; pack = pack->link) { ! 4452: if (buf->st_dev == pack->dev && ! 4453: buf->st_ino == pack->ino) { ! 4454: fprintf (tf, "l %s ", transname (pack->ename)); ! 4455: fprintf (tf, "%s\n", transname (name)); ! 4456: return 0; ! 4457: } ! 4458: } ! 4459: ! 4460: if (S_ISREG(mode)) { ! 4461: /* refuse to package the standard output */ ! 4462: if (buf->st_dev == outsb.st_dev && ! 4463: buf->st_ino == outsb.st_ino) { ! 4464: fprintf (stderr, "skipping output file %s\n", ! 4465: fullname (name)); ! 4466: return 0; ! 4467: } ! 4468: biname = iname (name); ! 4469: fprintf (tf, "f "); ! 4470: putpath (tf, biname); ! 4471: fprintf (tf, " "); ! 4472: hdrsub (name, buf); ! 4473: fprintf (tf, "\n"); ! 4474: } ! 4475: #ifdef S_ISLNK ! 4476: else if (S_ISLNK(mode)) { ! 4477: slname = alloc((unsigned)buf->st_size+1); ! 4478: slname[buf->st_size] = '\0'; ! 4479: if (readlink(name, slname, buf->st_size) != ! 4480: buf->st_size) { ! 4481: perror(name); ! 4482: return (0); ! 4483: } ! 4484: fprintf (tf, "s %s ", transname (slname)); ! 4485: fprintf (tf, "%s\n", transname (name)); ! 4486: biname = NULL; ! 4487: } ! 4488: #endif ! 4489: #if 0 /* We don't handle special files any more. */ ! 4490: else if (S_ISBLK(mode) || S_ISCHR(mode)) { ! 4491: fprintf (tf, "%c %#o %d %d ", ! 4492: mode == S_IFBLK? 'b': 'c', ! 4493: buf->st_mode & 07777, ! 4494: major (buf->st_rdev), ! 4495: minor (buf->st_rdev)); ! 4496: hdrsub (name, buf); ! 4497: fprintf (tf, "\n"); ! 4498: biname = NULL; ! 4499: } ! 4500: #endif ! 4501: else { ! 4502: fprintf (stderr, "%s: unrecognized file type\n", ! 4503: fullname (name)); ! 4504: break; ! 4505: } ! 4506: ! 4507: ! 4508: /* package the file */ ! 4509: pack = new (struct pack); ! 4510: pack->ename = copy (name); ! 4511: pack->dev = buf->st_dev; ! 4512: pack->ino = buf->st_ino; ! 4513: pack->uid = buf->st_uid; ! 4514: pack->gid = buf->st_gid; ! 4515: pack->time = buf->st_mtime; ! 4516: if (pack->time > pkhead->time) ! 4517: pkhead->time = pack->time; ! 4518: pack->size = buf->st_size; ! 4519: pack->mode = buf->st_mode; ! 4520: pack->link = NULL; ! 4521: pack->iname = biname; ! 4522: pktail->link = pack; ! 4523: pktail = pack; ! 4524: break; ! 4525: ! 4526: case FTW_DNR: ! 4527: fprintf (stderr, "cannot read directory %s\n", name); ! 4528: return 1; ! 4529: ! 4530: case FTW_NS: ! 4531: fprintf (stderr, "cannot stat %s\n", name); ! 4532: return 1; ! 4533: ! 4534: case FTW_DP: ! 4535: break; ! 4536: ! 4537: default: ! 4538: fprintf (stderr, "impossible code %d from ftw\n", type); ! 4539: exit (1); ! 4540: } ! 4541: return 0; ! 4542: } ! 4543: ! 4544: static void ! 4545: hdrsub (char *name, struct stat *buf) ! 4546: { ! 4547: putpath (tf, uidstr (buf->st_uid)); ! 4548: putc ('\t', tf); ! 4549: putpath (tf, gidstr (buf->st_gid)); ! 4550: putc ('\t', tf); ! 4551: putpath (tf, transname (name)); ! 4552: } ! 4553: ! 4554: /* ! 4555: * generate a unique internal name for a file ! 4556: */ ! 4557: static char * ! 4558: iname (char *s) ! 4559: { ! 4560: register char *p; ! 4561: register char *lastcomp; ! 4562: register struct pack *pack; ! 4563: char trial[MAXCOMP+1]; ! 4564: ! 4565: /* point lastcomp at the last pathname component */ ! 4566: lastcomp = s; ! 4567: for (p = s; *p; p++) { ! 4568: if (*p == '/') ! 4569: lastcomp = p + 1; ! 4570: } ! 4571: ! 4572: /* if the name is acceptably short, modify it slightly */ ! 4573: if (strlen (lastcomp) <= MAXCOMP) { ! 4574: ! 4575: char prefix[MAXCOMP+1], suffix[MAXCOMP+1], num[30]; ! 4576: register int n; ! 4577: ! 4578: /* split the name, remove unprintables */ ! 4579: strcpy (prefix, lastcomp); ! 4580: for (p = prefix; *p; p++) ! 4581: if (*p == ' ' || !isprint (*p)) ! 4582: *p = '$'; ! 4583: suffix[0] = '\0'; ! 4584: p = strrchr (prefix, '.'); ! 4585: if (p != NULL) { ! 4586: strcpy (suffix, p); ! 4587: *p = '\0'; ! 4588: } ! 4589: ! 4590: /* generate trial names until we run out of space */ ! 4591: for (n = 0, num[0] = '\0'; ! 4592: strlen(prefix) + strlen(suffix) + strlen(num) <= MAXCOMP; ! 4593: n++, sprintf (num, "%.0d", n)) { ! 4594: ! 4595: /* generate the trial name */ ! 4596: strcpy (trial, prefix); ! 4597: strcat (trial, num); ! 4598: strcat (trial, suffix); ! 4599: ! 4600: /* if the name is unique, we're done */ ! 4601: pack = pkhead; ! 4602: while (pack != NULL && strcmp (pack->iname, trial) != 0) ! 4603: pack = pack->link; ! 4604: if (pack == NULL) ! 4605: return copy(trial); ! 4606: ! 4607: } ! 4608: } ! 4609: ! 4610: /* punt -- generate a completely new name */ ! 4611: do { ! 4612: static int tempno; ! 4613: ! 4614: tempno++; ! 4615: sprintf (trial, "Temp%d", tempno); ! 4616: pack = pkhead; ! 4617: while (pack != NULL && strcmp (trial, pack->iname) != 0) ! 4618: pack = pack->link; ! 4619: } while (pack != NULL); ! 4620: return copy(trial); ! 4621: } ! 4622: at (trial, num); ! 4623: strcat (trial, suffix); ! 4624: ! 4625: /* if the name is unique, we're done */ ! 4626: pack = pkhead; ! 4627: while (pack != NULL && strcmp (pack->iname, trial) != 0) ! 4628: pack = pack->link; ! 4629: if (pack == NULL) ! 4630: return copy(trial); ! 4631: ! 4632: } ! 4633: } ! 4634: ! 4635: /* punt -- generate a completely new name */ ! 4636: do { ! 4637: static int tempno; ! 4638: ! 4639: tempno++; ! 4640: sprintf (trial, "Temp%d"pkg/path.c 644 3513 4 6137 5013610576 6000 /* ! 4641: * getpath (file) - read a path name ! 4642: * putpath (file, path) - write a path name ! 4643: * ! 4644: * These subroutines cater to the possibility of unprintable ! 4645: * characters in the path names being read or written, by ! 4646: * using the same sort of \ conventions commonly found in ! 4647: * C character constants. The result of getpath is a pointer ! 4648: * to a static buffer whose contents will stay around no longer ! 4649: * than the next call to getpath. When getpath is called, the ! 4650: * character about to be read from the input file must be the ! 4651: * first character of the path name. ! 4652: * ! 4653: * There are a few problems, mostly relating to bugs and language ! 4654: * changes, to watch out for in these routines. First of all, ! 4655: * we assume that \v is known by the C compiler, even though ! 4656: * it is not mentioned in Kernighan and Ritchie. The reason for ! 4657: * this is that if we do not make this assumption, we run into ! 4658: * a common bug in the handling of iscntrl(). Although the ! 4659: * manuals all say that if c is a white-space character that is ! 4660: * not a blank, then iscntrl(c) is true, several versions of the ! 4661: * C library disagree with the documentation. Thus we try to ! 4662: * list all the white-space characters explicitly. ! 4663: */ ! 4664: ! 4665: #include "asd.h" ! 4666: #include <ctype.h> ! 4667: #include <stdio.h> ! 4668: ! 4669: #define CHUNK 64 ! 4670: ! 4671: static char *r; ! 4672: static unsigned size; ! 4673: ! 4674: char * ! 4675: getpath (FILE *file) ! 4676: { ! 4677: register int c; ! 4678: register int len = 0; ! 4679: ! 4680: c = getc (file); ! 4681: ! 4682: while (!isspace(c) && c != EOF) { ! 4683: register int i = 0, n = 0; ! 4684: ! 4685: /* determine the next input character */ ! 4686: if (c == '\\') { ! 4687: c = getc (file); ! 4688: switch (c) { ! 4689: ! 4690: case '\\': ! 4691: break; ! 4692: ! 4693: case 'n': ! 4694: c = '\n'; ! 4695: break; ! 4696: ! 4697: case 'r': ! 4698: c = '\r'; ! 4699: break; ! 4700: ! 4701: case 't': ! 4702: c = '\t'; ! 4703: break; ! 4704: ! 4705: case 'b': ! 4706: c = '\b'; ! 4707: break; ! 4708: ! 4709: case 'f': ! 4710: c = '\f'; ! 4711: break; ! 4712: ! 4713: case 'v': ! 4714: c = '\v'; ! 4715: break; ! 4716: ! 4717: case ' ': ! 4718: /* c = ' '; */ ! 4719: break; ! 4720: ! 4721: default: ! 4722: while (c >= '0' && c <= '7' && i < 3) { ! 4723: n = (n << 3) + c - '0'; ! 4724: i++; ! 4725: c = getc (file); ! 4726: } ! 4727: ungetc (c, file); ! 4728: c = n; ! 4729: break; ! 4730: } ! 4731: } ! 4732: ! 4733: /* ensure there's room in the buffer */ ! 4734: if (len >= size) ! 4735: r = ralloc (r, size += CHUNK); ! 4736: ! 4737: /* put the character in the buffer */ ! 4738: r[len++] = c; ! 4739: ! 4740: /* read the next character */ ! 4741: c = getc (file); ! 4742: } ! 4743: ! 4744: /* unless we hit eof, we read one character too far. */ ! 4745: if (c != EOF) ! 4746: ungetc (c, file); ! 4747: ! 4748: /* put a final null into the buffer */ ! 4749: if (len >= size) ! 4750: r = ralloc (r, size += CHUNK); ! 4751: r[len] = '\0'; ! 4752: ! 4753: return r; ! 4754: } ! 4755: ! 4756: void ! 4757: putpath (FILE *file, char *path) ! 4758: { ! 4759: register char *p = path; ! 4760: register int c; ! 4761: ! 4762: while ((c = *p++) != NULL) { ! 4763: switch (c) { ! 4764: ! 4765: case '\n': ! 4766: fprintf (file, "\\n"); ! 4767: break; ! 4768: ! 4769: case '\r': ! 4770: fprintf (file, "\\r"); ! 4771: break; ! 4772: ! 4773: case '\b': ! 4774: fprintf (file, "\\b"); ! 4775: break; ! 4776: ! 4777: case '\t': ! 4778: fprintf (file, "\\t"); ! 4779: break; ! 4780: ! 4781: case '\f': ! 4782: fprintf (file, "\\f"); ! 4783: break; ! 4784: ! 4785: case '\v': ! 4786: fprintf (file, "\\v"); ! 4787: break; ! 4788: ! 4789: case '\\': ! 4790: fprintf (file, "\\\\"); ! 4791: break; ! 4792: ! 4793: case ' ': ! 4794: fprintf (file, "\\ "); ! 4795: break; ! 4796: ! 4797: default: ! 4798: if (iscntrl (c)) ! 4799: fprintf (file, ! 4800: *p >= '0' && *p <= '7'? "\\%.3o": "\\%o", ! 4801: c); ! 4802: else ! 4803: putc (c, file); ! 4804: break; ! 4805: } ! 4806: } ! 4807: } ! 4808: e '\r': ! 4809: fprintf (file, "\\r"); ! 4810: break; ! 4811: ! 4812: case '\b': ! 4813: fprintf (file, "\\b"); ! 4814: break; ! 4815: ! 4816: case '\t': ! 4817: fprintf (file, "\\t"); ! 4818: break; ! 4819: ! 4820: case '\f': ! 4821: fprintf (file, "\\f"); ! 4822: break; ! 4823: ! 4824: case '\v': ! 4825: fprintf (file, "\\v"); ! 4826: break; ! 4827: ! 4828: case '\\': ! 4829: fprintf (file, "\\\\"); ! 4830: break; ! 4831: ! 4832: case ' ': ! 4833: fprintf (file, "\\ "); ! 4834: break; ! 4835: ! 4836: default: ! 4837: if (iscntrl (c)) ! 4838: fprintf (file, ! 4839: *p >= pkg/pwd.c 644 3513 4 1113 5013610576 5623 /* ! 4840: * pwd() - return the name of the current directory. ! 4841: * We assume that the current directory never changes. ! 4842: */ ! 4843: ! 4844: #include "asd.h" ! 4845: #include <libv.h> ! 4846: #include <stdio.h> ! 4847: ! 4848: #define CHUNK 64 ! 4849: ! 4850: char * ! 4851: pwd(void) ! 4852: { ! 4853: register FILE *f; ! 4854: static char *r; ! 4855: static unsigned size; ! 4856: register int n, c; ! 4857: ! 4858: if (r == NULL) { ! 4859: f = popen ("pwd", "r"); ! 4860: schk ((char *) f); ! 4861: ! 4862: n = 0; ! 4863: while ((c = getc (f)) != EOF) { ! 4864: if (n >= size) { ! 4865: size += CHUNK; ! 4866: r = ralloc (r, size); ! 4867: } ! 4868: r[n++] = c; ! 4869: } ! 4870: ! 4871: /* replace the trailing newline by a null */ ! 4872: r[n - 1] = '\0'; ! 4873: ! 4874: pclose (f); ! 4875: } ! 4876: ! 4877: return r; ! 4878: } ! 4879: he current directory never changes. ! 4880: */ ! 4881: ! 4882: #include "asd.h" ! 4883: #include <libv.h> ! 4884: #include <stdio.h> ! 4885: ! 4886: #define CHUNK 64 ! 4887: ! 4888: char * ! 4889: pwd(void) ! 4890: { ! 4891: register FILE *f; ! 4892: static char *r; ! 4893: static unsigned size; ! 4894: register int n, c; ! 4895: ! 4896: if (r == NULL) { ! 4897: f = popen ("pwd", "r"); ! 4898: schk ((char *) f); ! 4899: ! 4900: n = 0; ! 4901: while ((c = getc (f)) != EOF) { ! 4902: if (n >= size) { ! 4903: size += CHUNK; ! 4904: r = ralloc (r, size); ! 4905: } ! 4906: r[n++] = c; ! 4907: } ! 4908: ! 4909: /* replace the trailipkg/seal.c 644 3513 4 5522 5013610577 5766 /* ! 4910: * seal - prepare a package for shipment ! 4911: */ ! 4912: ! 4913: #include "asd.h" ! 4914: #include "seal.h" ! 4915: #include <ctype.h> ! 4916: #include <string.h> ! 4917: ! 4918: static long length; ! 4919: static unsigned long checksum; ! 4920: ! 4921: /* ! 4922: * convert the characters in the range (in,inend] to ! 4923: * storage starting at "out" -- return the number of ! 4924: * output characters. ! 4925: */ ! 4926: ! 4927: static int ! 4928: hrform (char *in, char *inend, char *out) ! 4929: { ! 4930: register char *r = out; ! 4931: ! 4932: /* special handling for the first character(s) */ ! 4933: if (in < inend) { ! 4934: if (*in == '.' || *in == '!' || ! 4935: (*in == 'F' && strncmp (in, "From", 4) == 0)) ! 4936: *r++ = '\\'; ! 4937: ! 4938: do { ! 4939: register int ch = (unsigned char) *in++; ! 4940: ! 4941: if (isprint (ch)) { ! 4942: if (ch == '\\') ! 4943: *r++ = '\\'; ! 4944: *r++ = ch; ! 4945: } else { ! 4946: if (ch == ' ' || ch == '\t' || ch == '\n') ! 4947: *r++ = ch; ! 4948: else { ! 4949: *r++ = '\\'; ! 4950: *r++ = hextab[(ch >> 4) & 0xf]; ! 4951: *r++ = hextab[ch & 0xf]; ! 4952: } ! 4953: } ! 4954: } while (in < inend); ! 4955: ! 4956: if (r[-1] != '\n') { ! 4957: *r++ = '\\'; ! 4958: *r++ = '\n'; ! 4959: } ! 4960: } ! 4961: ! 4962: return r - out; ! 4963: } ! 4964: ! 4965: static int ! 4966: mrform (char *in, char *inend, char *out) ! 4967: { ! 4968: char *r; ! 4969: register int len; ! 4970: ! 4971: len = inend - in; ! 4972: if (len <= 0) ! 4973: return 0; ! 4974: ! 4975: r = out; ! 4976: ! 4977: *r++ = '.'; ! 4978: ! 4979: do { ! 4980: register unsigned long bits; ! 4981: register int n, outn; ! 4982: register char *rr; ! 4983: ! 4984: n = len; ! 4985: if (n > INCPW) ! 4986: n = INCPW; ! 4987: len -= n; ! 4988: outn = n + OUTCPW - INCPW; ! 4989: ! 4990: bits = 0; ! 4991: do bits = (bits << BPC) | (*in++ & BYTEMASK); ! 4992: while (--n > 0); ! 4993: ! 4994: rr = r = r + outn; ! 4995: do { ! 4996: *--rr = RADBASE + bits % RADIX; ! 4997: bits /= RADIX; ! 4998: } while (--outn > 0); ! 4999: } while (len > 0); ! 5000: ! 5001: *r++ = '\n'; ! 5002: ! 5003: return r - out; ! 5004: } ! 5005: ! 5006: ! 5007: static int ! 5008: seal (FILE *f, char *fname) ! 5009: { ! 5010: static int first = 1; ! 5011: ! 5012: if (first) { ! 5013: first = 0; ! 5014: printf ("!<seal>\n"); ! 5015: } ! 5016: ! 5017: do { ! 5018: char line[MAXLINE]; ! 5019: char outline[MAXLINE*3+10]; ! 5020: register char *p, *endl; ! 5021: register int ch; ! 5022: ! 5023: /* read a line, possibly short */ ! 5024: p = line; ! 5025: endl = line + MAXLINE; ! 5026: ! 5027: do { ! 5028: ch = getc (f); ! 5029: if (ch == EOF) ! 5030: break; ! 5031: *p++ = ch; ! 5032: } while (ch != '\n' && p < endl); ! 5033: ! 5034: endl = p; ! 5035: ! 5036: /* ! 5037: * endl now points one past the last char ! 5038: * in the line we have read. If we didn't ! 5039: * get any characters at all, we're done. ! 5040: */ ! 5041: ! 5042: if (line == endl) ! 5043: return ferror (f) != 0; ! 5044: ! 5045: length += endl - line; ! 5046: ! 5047: /* now convert the line to external form */ ! 5048: ch = hrform (line, endl, outline); ! 5049: if (ch > (endl - line + INCPW - 1) / INCPW * OUTCPW + 2) ! 5050: ch = mrform (line, endl, outline); ! 5051: p = outline; ! 5052: ! 5053: /* if encrypting, do so */ ! 5054: if (kflag || Kflag) ! 5055: mangle (line, endl); ! 5056: ! 5057: /* accumulate the (possibly encrypted) checksum */ ! 5058: checksum = mkcsum (checksum, line, endl); ! 5059: ! 5060: while (--ch >= 0) ! 5061: putchar (*p++); ! 5062: } while (!feof (f) && !ferror (f)); ! 5063: ! 5064: return ferror (f) != 0; ! 5065: } ! 5066: ! 5067: int ! 5068: main (int argc, char **argv) ! 5069: { ! 5070: int rc = 0; ! 5071: static char stdbuf[BUFSIZ]; ! 5072: ! 5073: setbuf (stdout, stdbuf); ! 5074: ! 5075: length = 0; ! 5076: checksum = 0; ! 5077: ! 5078: rc = getargs (argc, argv, "kK:", seal); ! 5079: ! 5080: printf ("!end %ld %lu\n", length, checksum); ! 5081: ! 5082: return rc; ! 5083: } ! 5084: if encrypting, do so */ ! 5085: if (kflag || Kflag) ! 5086: mangle (line, endl); ! 5087: ! 5088: /* accumulate the (possibly encrypted) checksum */ ! 5089: checksum = mkcsum (checksum, line, endl); ! 5090: ! 5091: whpkg/seal.h 644 3513 4 515 5013610577 5750 /* ! 5092: * common parameters for seal and unseal ! 5093: */ ! 5094: ! 5095: #define MAXLINE 100 ! 5096: #define MAXULINE 200 ! 5097: #define RADBASE (' ' + 1) ! 5098: #define INCPW 4 ! 5099: #define OUTCPW 5 ! 5100: #define RADIX 94 ! 5101: #define BPC 8 ! 5102: #define BYTEMASK 0xff ! 5103: #define CSMASK 0xffffffffL ! 5104: #define CSHIBIT 0x80000000L ! 5105: ! 5106: /* mkcsum.c */ ! 5107: extern unsigned long mkcsum(unsigned long, char *, char *); ! 5108: c; ! 5109: } ! 5110: if encrypting, do so */ ! 5111: if (kflag || Kflag) ! 5112: mangle (line, endl); ! 5113: ! 5114: /* accumulate the (possibly encrypted) checksum */ ! 5115: checksum = mkcsum (checksum, line, endl); ! 5116: ! 5117: whpkg/transname.c 644 3513 4 1701 5013610600 7010 /* ! 5118: * transname - take a pathname, expand it, and translate it ! 5119: * according to the replist. The result is in a buffer ! 5120: * that will stay around no longer than the next call ! 5121: * to transname. If no translation, transname will ! 5122: * just return fullname applied to its argument. ! 5123: */ ! 5124: ! 5125: #include "asd.h" ! 5126: #include <string.h> ! 5127: ! 5128: char * ! 5129: transname (char *s) ! 5130: { ! 5131: register struct replist *rl; ! 5132: static char *res; ! 5133: static int size; ! 5134: register int n; ! 5135: ! 5136: s = fullname (s); ! 5137: ! 5138: /* look for substitution */ ! 5139: for (rl = replist; rl; rl = rl->link) { ! 5140: register char *p = rl->source; ! 5141: register char *q = s; ! 5142: ! 5143: /* comparison loop */ ! 5144: while (*p != '\0' && *p == *q) { ! 5145: p++; ! 5146: q++; ! 5147: } ! 5148: ! 5149: if (*p == '\0') { ! 5150: /* comparison successful */ ! 5151: n = strlen (rl->dest) + strlen (q) + 1; ! 5152: if (n > size) { ! 5153: size = n; ! 5154: res = ralloc (res, (unsigned) n); ! 5155: } ! 5156: strcpy (res, rl->dest); ! 5157: strcat (res, q); ! 5158: return res; ! 5159: } ! 5160: } ! 5161: ! 5162: /* search loop failed, return expanded input */ ! 5163: return s; ! 5164: } ! 5165: ! 5166: ! 5167: /* look for substitution */ ! 5168: for (rl = replist; rl; rl = rl-pkg/uid.c 644 3513 4 2535 5013610601 5610 #include "asd.h" ! 5169: #include <pwd.h> ! 5170: #include <stdio.h> ! 5171: #include <stdlib.h> ! 5172: #include <string.h> ! 5173: #include <unistd.h> ! 5174: ! 5175: ! 5176: #define CHUNK 16 ! 5177: ! 5178: static struct utab { ! 5179: unsigned uid; ! 5180: char *name; ! 5181: } *utab; ! 5182: ! 5183: static int size, salloc; ! 5184: ! 5185: char * ! 5186: uidstr (uid_t uid) ! 5187: { ! 5188: register int i; ! 5189: static char buf[12]; ! 5190: struct passwd *p; ! 5191: ! 5192: /* search the cache for the uid */ ! 5193: for (i = 0; i < size; i++) ! 5194: if (utab[i].uid == uid) ! 5195: return utab[i].name; ! 5196: ! 5197: /* try to find it in the system's database */ ! 5198: if (p = getpwuid(uid)) { ! 5199: if (size % CHUNK == 0) ! 5200: utab = (struct utab *) ralloc((char *) utab, salloc += CHUNK); ! 5201: utab[size].uid = p->pw_uid; ! 5202: utab[size].name = copy(p->pw_name); ! 5203: ++size; ! 5204: return utab[size - 1].name; ! 5205: } ! 5206: ! 5207: /* failure, invent a string */ ! 5208: sprintf (buf, "#%u", uid); ! 5209: return buf; ! 5210: } ! 5211: ! 5212: uid_t ! 5213: uidnum (char *name) ! 5214: { ! 5215: register int i; ! 5216: struct passwd *p; ! 5217: ! 5218: /* if it starts with a #, use the number */ ! 5219: if (name[0] == '#') ! 5220: return atoi (name + 1); ! 5221: ! 5222: /* try to find it in the system's database */ ! 5223: if (p = getpwnam(name)) { ! 5224: if (size % CHUNK == 0) ! 5225: utab = (struct utab *) ralloc((char *) utab, salloc += CHUNK); ! 5226: utab[size].uid = p->pw_uid; ! 5227: utab[size].name = copy(p->pw_name); ! 5228: ++size; ! 5229: return utab[size - 1].uid; ! 5230: } ! 5231: ! 5232: /* search the cache */ ! 5233: for (i = 0; i < size; i++) ! 5234: if (strcmp (utab[i].name, name) == 0) ! 5235: return utab[i].uid; ! 5236: ! 5237: /* failure, invent a value */ ! 5238: return getuid(); ! 5239: } ! 5240: #, use the number */ ! 5241: if (name[0] == '#') ! 5242: return atoi (name + 1); ! 5243: ! 5244: /* try to find it in the system's database */ ! 5245: if (p = getpwnam(name)) { ! 5246: if (size % CHUNK =pkg/unseal.c 644 3513 4 10352 5013610601 6332 /* ! 5247: * unseal - disclose and verify the contents of a sealed package ! 5248: */ ! 5249: ! 5250: #include "asd.h" ! 5251: #include "seal.h" ! 5252: #include <ctype.h> ! 5253: #include <string.h> ! 5254: #include <unistd.h> ! 5255: ! 5256: static FILE *outfd; ! 5257: static char outf[L_tmpnam]; ! 5258: static char line[MAXULINE]; ! 5259: ! 5260: static unsigned long length, checksum; ! 5261: ! 5262: static char * ! 5263: csverify (char *p, unsigned long value) ! 5264: { ! 5265: register unsigned long n = 0; ! 5266: ! 5267: while (isspace (*p)) ! 5268: p++; ! 5269: ! 5270: if (!isdigit (*p)) ! 5271: return NULL; ! 5272: ! 5273: do n = n * 10 + *p++ - '0'; ! 5274: while (isdigit (*p)); ! 5275: ! 5276: if (!isspace (*p)) ! 5277: return NULL; ! 5278: ! 5279: if (n != value) ! 5280: return NULL; ! 5281: ! 5282: return p; ! 5283: } ! 5284: ! 5285: int ! 5286: docksum (char *line, unsigned long length, unsigned long checksum) ! 5287: { ! 5288: register char *p = line + 5; ! 5289: ! 5290: p = csverify (p, length); ! 5291: if (p == NULL) { ! 5292: fprintf (stderr, "unseal: invalid length\n"); ! 5293: return 1; ! 5294: } ! 5295: p = csverify (p, checksum); ! 5296: if (p == NULL) { ! 5297: fprintf (stderr, "unseal: invalid checksum\n"); ! 5298: return 1; ! 5299: } ! 5300: return 0; ! 5301: } ! 5302: ! 5303: static int ! 5304: unhex (int c) ! 5305: { ! 5306: register char *p; ! 5307: ! 5308: p = hextab; ! 5309: while (*p && *p != c) ! 5310: p++; ! 5311: if (*p) ! 5312: return p - hextab; ! 5313: return -1; ! 5314: } ! 5315: ! 5316: static int ! 5317: hrout (char *line, char *out) ! 5318: { ! 5319: register char *p, *q; ! 5320: register int ch; ! 5321: ! 5322: p = line; ! 5323: q = out; ! 5324: ! 5325: while ((ch = *p++) != '\0') { ! 5326: if (ch != '\\') { ! 5327: *q++ = ch; ! 5328: } else { ! 5329: ch = *p++; ! 5330: if (ch == '\\' || ch == '.' || ch == '!' || ch == 'F') { ! 5331: *q++ = ch; ! 5332: } else if (ch != '\n') { ! 5333: register int n = 0, i = 1; ! 5334: ! 5335: do { ! 5336: ch = unhex (ch); ! 5337: if (ch < 0) { ! 5338: fprintf (stderr, ! 5339: "bad hex char: %s", line); ! 5340: return -1; ! 5341: } ! 5342: n = (n << 4) | ch; ! 5343: if (i) ! 5344: ch = *p++; ! 5345: } while (--i >= 0); ! 5346: ! 5347: *q++ = n; ! 5348: } ! 5349: } ! 5350: } ! 5351: ! 5352: return q - out; ! 5353: } ! 5354: ! 5355: static int ! 5356: mrout (char *line, char *out) ! 5357: { ! 5358: register char *p = line + 1; ! 5359: char *q = out; ! 5360: ! 5361: while (*p != '\n' && *p != '\0') { ! 5362: register unsigned long bits; ! 5363: register int n; ! 5364: register char *rq; ! 5365: ! 5366: n = 0; ! 5367: bits = 0; ! 5368: do { ! 5369: register int ch = *p++; ! 5370: if (ch == '\n') ! 5371: break; ! 5372: if (ch < RADBASE || ch >= RADBASE + RADIX) { ! 5373: fprintf (stderr, "bad input char: %s", line); ! 5374: return -1; ! 5375: } ! 5376: bits = bits * RADIX + ch - RADBASE; ! 5377: n++; ! 5378: } while (n < OUTCPW); ! 5379: ! 5380: n -= OUTCPW - INCPW; ! 5381: if (n <= 0) { ! 5382: fprintf (stderr, "non-positive output count: %s", line); ! 5383: return -1; ! 5384: } ! 5385: ! 5386: rq = q = q + n; ! 5387: do { ! 5388: *--rq = bits; ! 5389: bits >>= BPC; ! 5390: } while (--n > 0); ! 5391: } ! 5392: ! 5393: return q - out; ! 5394: } ! 5395: ! 5396: static int ! 5397: dodata (char *line) ! 5398: { ! 5399: char out[MAXULINE * 2]; ! 5400: int r; ! 5401: ! 5402: r = (*(line[0] == '.'? mrout : hrout)) (line, out); ! 5403: if (r < 0) ! 5404: return 1; ! 5405: fwrite (out, sizeof(*out), r, outfd); ! 5406: length += r; ! 5407: ! 5408: if (kflag || Kflag) ! 5409: mangle (out, out + r); ! 5410: ! 5411: checksum = mkcsum (checksum, out, out + r); ! 5412: ! 5413: return 0; ! 5414: } ! 5415: ! 5416: static int ! 5417: unseal (FILE *f, char *fname) ! 5418: { ! 5419: int intext = 0, rc = 0, nulltext = 1; ! 5420: ! 5421: length = checksum = 0; ! 5422: resetN12(); ! 5423: ! 5424: while (fgets (line, MAXULINE, f) != NULL) { ! 5425: ! 5426: /* check for a control line, which starts with "!" */ ! 5427: if (line[0] == '!') { ! 5428: if (intext) { ! 5429: /* only thing allowed is !end */ ! 5430: if (strncmp (line + 1, "end ", 4) == 0) { ! 5431: rc += docksum (line, length, checksum); ! 5432: intext = 0; ! 5433: } else { ! 5434: fprintf (stderr, "invalid control line %s", line); ! 5435: rc++; ! 5436: } ! 5437: } else { ! 5438: /* look for header, else quietly ignore */ ! 5439: if (strcmp (line + 1, "<seal>\n") == 0) { ! 5440: intext++; ! 5441: nulltext = 0; ! 5442: } ! 5443: } ! 5444: /* data lines are quietly ignored if not in text */ ! 5445: } else if (intext) { ! 5446: rc += dodata (line); ! 5447: } ! 5448: } ! 5449: ! 5450: if (nulltext) { ! 5451: fprintf (stderr, "unseal: no contents\n"); ! 5452: rc++; ! 5453: } ! 5454: ! 5455: if (intext) { ! 5456: fprintf (stderr, "unseal: no checksum\n"); ! 5457: rc++; ! 5458: } ! 5459: ! 5460: return rc; ! 5461: } ! 5462: ! 5463: int ! 5464: main (int argc, char **argv) ! 5465: { ! 5466: int rc = 0; ! 5467: int c; ! 5468: static char stdbuf[BUFSIZ]; ! 5469: ! 5470: setbuf (stdout, stdbuf); ! 5471: ! 5472: umask (077); ! 5473: tmpnam (outf); ! 5474: outfd = fopen (outf, "w+"); ! 5475: if (outfd == NULL) { ! 5476: fprintf (stderr, "unseal: can't create temp file\n"); ! 5477: exit (1); ! 5478: } ! 5479: ! 5480: /* don't leave dregs */ ! 5481: unlink (outf); ! 5482: ! 5483: rc = getargs (argc, argv, "kK:", unseal); ! 5484: ! 5485: /* if successful, copy the temp file to the output */ ! 5486: if (rc == 0) { ! 5487: register FILE *in = outfd, *out = stdout; ! 5488: register int ch; ! 5489: ! 5490: rewind (in); ! 5491: ! 5492: while ((ch = getc (in)) != EOF) ! 5493: putc (ch, out); ! 5494: ! 5495: fflush (out); ! 5496: ! 5497: if (ferror (in)) { ! 5498: fprintf (stderr, "unseal: error reading temp file\n"); ! 5499: rc++; ! 5500: } ! 5501: ! 5502: if (ferror (out)) { ! 5503: fprintf (stderr, "unseal: error writing stdout\n"); ! 5504: rc++; ! 5505: } ! 5506: } ! 5507: ! 5508: return rc; ! 5509: } ! 5510: * don't leave dregs */ ! 5511: unlink (outf); ! 5512: ! 5513: rc = getargs (argc, argv, "kK:", unseal); ! 5514: ! 5515: /* if successful, copy the temp file to the output */ ! 5516: if (rc == 0) { ! 5517: register FILE *in = outfd, *out = stdout; ! 5518: register int ch; ! 5519: ! 5520: rewind (in); ! 5521: ! 5522: while ((ch = getc (in)) != EOF) ! 5523: putc pkg/libx.a 644 3513 4 44 5013644572 5732 674187646 f (ferror (in)) { ! 5524: fprintf (stderr, "unseal: error reading temp file\n"); ! 5525: rc++; ! 5526: } ! 5527: ! 5528: if (ferror (out)) { ! 5529: fprintf (stderr, "unseal: error writing stdout\n"); ! 5530: rc++; ! 5531: } ! 5532: } ! 5533: ! 5534: return rc; ! 5535: } ! 5536: * don't leave dregs */ ! 5537: unlink (outf); ! 5538: ! 5539: rc = getargs (argc, argv, "kK:", unseal); ! 5540: ! 5541: /* if successful, copy the temp file to the output */ ! 5542: if (rc == 0) { ! 5543: register FILE *in = outfd, *out = stdout; ! 5544: register int ch; ! 5545: ! 5546: rewind (in); ! 5547: ! 5548: while ((ch = getc (in)) != EOF) ! 5549: putc pkg/INSTRUCTIONS 644 3513 4 2022 5027730714 6556 The format of the Instructions file in a package archive ! 5550: is as follows. ! 5551: ! 5552: Each instruction is a line by itself. Each instruction consists of a ! 5553: single character instruction code followed by a number of fields. Fields ! 5554: do not contain spaces. ! 5555: ! 5556: Various standard kinds of fields are: ! 5557: <command> shell command (via putpath()) ! 5558: <component> archive component name (via putpath()) ! 5559: <mode> octal permissions ! 5560: <dmajor>, <dminor> major and minor decimal device numbers ! 5561: <uid>, <gid> user and group names (via putpath()) ! 5562: <path> path name (via putpath()) ! 5563: ! 5564: b <mode> <dmajor> <dminor> <uid> <gid> <path> ! 5565: block device ! 5566: c <mode> <dmajor> <dminor> <uid> <gid> <path> ! 5567: character device ! 5568: d <mode> <uid> <gid> <path> ! 5569: directory ! 5570: f <component> <uid> <gid> <path> ! 5571: ordinary file (rest of the information is in the archive component) ! 5572: l <path1> <path2> ! 5573: hard link -- <path2> is the link to be created. ! 5574: s <path1> <path2> ! 5575: symbolic link -- <path2> is the link to be created. ! 5576: r <path> ! 5577: file to be removed ! 5578: x <command> ! 5579: command to be executed ! 5580: X <path> ! 5581: file to be executed ! 5582: a putpath()) ! 5583: ! 5584: b <mode> <dmajor> <dminor> <uid> <gid> <path> ! 5585: block device ! 5586: c <mode> <dmajor> <dminor> <uid> <gid> <path> ! 5587: character device ! 5588: d <mode> <uid> <gid> <path> ! 5589: directory ! 5590: f <component> <uid> <gid> <path> ! 5591: ordinary file (rest of the information is in the archive component) ! 5592: l <path1> <path2> ! 5593: hard link -- <path2> is the link to be created. ! 5594: s <path1> <path2> ! 5595: symbolic link -- <path2> is the link to be created. ! 5596: r <path> ! 5597: file to be removed ! 5598: x <command> ! 5599: command to be executed ! 5600: X <path> ! 5601: fipkg/ftw.c 644 3513 4 24531 5031452625 5661 /* ! 5602: * ftw - file tree walk ! 5603: * ! 5604: * int ftw (path, fn, depth) char *path; int (*fn)(); int depth; ! 5605: * ! 5606: * Given a path name, ftw starts from the file given by that path ! 5607: * name and visits each file and directory in the tree beneath ! 5608: * that file. If a single file has multiple links within the ! 5609: * structure, it will be visited once for each such link. ! 5610: * For each object visited, fn is called with four arguments. ! 5611: * The fourth can often be ignored; it is a pointer, say S, ! 5612: * declared "struct FTW *S", discussed in more detail below. ! 5613: * The first contains the path name of the object, the second ! 5614: * contains a pointer to a stat buffer which will usually hold ! 5615: * appropriate information for the object and the third contains ! 5616: * an integer value giving additional information about the ! 5617: * object, as follows: ! 5618: * ! 5619: * FTW_F The object is a file for which stat was ! 5620: * successful. It does not guarantee that the ! 5621: * file can actually be read. ! 5622: * ! 5623: * FTW_D The object is a directory for which stat and ! 5624: * open for read were both successful. This is ! 5625: * a preorder visit -- objects in the directory ! 5626: * are yet to be visited. ! 5627: * ! 5628: * FTW_DNR The object is a directory for which stat ! 5629: * succeeded, but which cannot be read. Because ! 5630: * the directory cannot be read, fn will not be ! 5631: * called for any descendants of this directory. ! 5632: * ! 5633: * FTW_DP The object is a directory for which stat and ! 5634: * open for read were both successful. This is ! 5635: * a postorder visit -- everything in the directory ! 5636: * has already been visited. ! 5637: * ! 5638: * FTW_NS Lstat failed on the object. If errno is EACCES, ! 5639: * then the failure stems from lack of ! 5640: * appropriate permission. This indication will ! 5641: * be given, for example, for each file in a directory ! 5642: * with read but no execute permission. Whenever ! 5643: * stat fails, it is not possible to determine ! 5644: * whether this object is a file or a directory. ! 5645: * The stat buffer passed to fn will contain garbage. ! 5646: * ! 5647: * FTW_SL The object is a symbolic link. Set S->quit ! 5648: * (a component of the structure pointed to by ! 5649: * the fourth parameter to fn) to FTW_FOLLOW to ! 5650: * have the link followed and the object to which ! 5651: * it points visited. ! 5652: * ! 5653: * FTW_NSL Lstat succeeded, but stat failed on the object. ! 5654: * This is only possible when following a symbolic ! 5655: * link. ! 5656: * ! 5657: * Among the components of the structure to which the fourth ! 5658: * parameter, S, to fn points is S->quit. If the caller sets ! 5659: * S->quit to FTW_SKR, then no more files in the current directory ! 5660: * will be visited. (The current directory is the one containing ! 5661: * the object being visited.) If the third parameter to fn is ! 5662: * FTW_D and the caller sets S->quit to FTW_SKD, then this directory ! 5663: * (the one named in the first parameter to fn) will be skipped. ! 5664: * ! 5665: * Other components pointed to by the fourth parameter S are ! 5666: * the current recursion level S->level (top level = 0) and ! 5667: * the offset S->base in the pathname of the current object ! 5668: * (the first parameter to fn) of the object's base name. ! 5669: * By expanding the definition of struct FTW given below and ! 5670: * including the files included below, one can arrange for ! 5671: * S to point to a larger structure, components of which can ! 5672: * be initialized (for example) on calls to fn with third ! 5673: * parameter FTW_D. ! 5674: * ! 5675: * If fn returns nonzero, ftw stops and returns the same value ! 5676: * to its caller. Ftw only initiates a nonzero return if malloc ! 5677: * fails; in this case ftw sets errno to ENOMEM and returns -1. ! 5678: * ! 5679: * The third argument to ftw does not limit the depth to which ! 5680: * ftw will go. Rather, it limits the depth to which ftw will ! 5681: * go before it starts recycling file descriptors. In general, ! 5682: * it is necessary to use a file descriptor for each level of the ! 5683: * tree, but they can be recycled for deep trees by saving the position, ! 5684: * closing, re-opening, and seeking. It is possible to start ! 5685: * recycling file descriptors by sensing when we have run out, but ! 5686: * in general this will not be terribly useful if fn expects to be ! 5687: * able to open files. We could also figure out how many file descriptors ! 5688: * are available and guarantee a certain number to fn, but we would not ! 5689: * know how many to guarantee, and we do not want to impose the extra ! 5690: * overhead on a caller who knows how many are available without ! 5691: * having to figure it out. ! 5692: * ! 5693: * It is possible for ftw to die with a memory fault in the event ! 5694: * of a file system so deeply nested that the stack overflows. ! 5695: */ ! 5696: ! 5697: #include <sys/types.h> ! 5698: #include <dirent.h> ! 5699: #include <sys/stat.h> ! 5700: #include "ftw.h" ! 5701: /* ! 5702: * Struct FTW (whose definition starts at the end of ftw.h) must ! 5703: * must include at least the integers quit, base, and level. ! 5704: */ ! 5705: ! 5706: #define FTW_PATHLEN0 1000 ! 5707: #define FTW_PATHINC 1000 ! 5708: ! 5709: #ifndef S_ISLNK ! 5710: #define lstat stat ! 5711: #endif ! 5712: ! 5713: #ifndef ENOMEM ! 5714: #include <errno.h> ! 5715: #endif ! 5716: ! 5717: extern int errno; ! 5718: ! 5719: /* ! 5720: * Each generation of ftw1 (the real ftw) allocates one copy, R, of the ! 5721: * following structure; it passes a pointer to this structure when it ! 5722: * recursively invokes itself. These structures are chained together, ! 5723: * so that if it becomes necessary to recycle file descriptors, then ! 5724: * the oldest descriptor (the one at the shallowest depth still open) ! 5725: * can be recycled. ! 5726: */ ! 5727: ! 5728: struct FTW_rec { ! 5729: struct FTW_rec *prev; ! 5730: long here; /* seek to here when reopening at this level */ ! 5731: DIR *fd; /* file descriptor at this level */ ! 5732: }; ! 5733: ! 5734: /* ! 5735: * One instance, T, of the following structure is allocated by ftw; a ! 5736: * pointer to it is passed to all generations of ftw1 (the real ftw). ! 5737: * T could often be a global variable, but this way the parameter fn ! 5738: * can invoke ftw for an independent tree walk. ! 5739: * Component T->path points to storage for the object path-names; ! 5740: * this storage may be relocated by realloc if T->path needs to be ! 5741: * more than T->pathlast characters long. ! 5742: * T->path[T->pathnext] is the next free character in the pathnames. ! 5743: * T->depth = parameter depth to ftw. T->lastout is the deepest level at ! 5744: * which a file descriptor has been recycled. ! 5745: */ ! 5746: ! 5747: struct FTW_top { ! 5748: int (*fn)(); ! 5749: char *path; ! 5750: unsigned pathlast, pathnext; ! 5751: int lastout; ! 5752: int depth; ! 5753: }; ! 5754: ! 5755: static ftw_1_(); ! 5756: ! 5757: int ! 5758: ftw (path, fn, depth) ! 5759: char *path; ! 5760: int (*fn)(); ! 5761: int depth; ! 5762: { ! 5763: struct FTW_top T; ! 5764: struct FTW_rec R; ! 5765: struct FTW S; ! 5766: int rc; ! 5767: char *malloc(), *strcpy(); ! 5768: ! 5769: T.depth = depth; ! 5770: T.lastout = -1; ! 5771: T.fn = fn; ! 5772: S.quit = 0; ! 5773: S.level = -1; ! 5774: ! 5775: /* initialize S.base, T.pathnext... */ ! 5776: { ! 5777: register char c, *p, *q; ! 5778: for (p = q = path; c = *p; p++) if (c == '/') q = p + 1; ! 5779: S.base = q - path; ! 5780: T.pathnext = p - path; ! 5781: } ! 5782: ! 5783: T.pathlast = T.pathnext + FTW_PATHLEN0; ! 5784: T.path = malloc(T.pathlast); ! 5785: if (!T.path) { errno = ENOMEM; return -1; } ! 5786: strcpy(T.path, path); ! 5787: rc = ftw_1_(&R, &T, 0, &S); ! 5788: free(T.path); ! 5789: return rc; ! 5790: } ! 5791: ! 5792: int ! 5793: static ! 5794: ftw_1_ (R, T, level, S1) ! 5795: register struct FTW_rec *R; ! 5796: register struct FTW_top *T; ! 5797: int level; ! 5798: struct FTW *S1; ! 5799: { ! 5800: int rc, n; ! 5801: DIR *fd; ! 5802: struct dirent *dirp; ! 5803: char *component, *path; ! 5804: struct stat sb; ! 5805: struct FTW_rec mr; ! 5806: unsigned nextsave; ! 5807: struct FTW S; ! 5808: char *realloc(); ! 5809: long lseek(); ! 5810: ! 5811: mr.prev = R; ! 5812: path = T->path; ! 5813: S.level = level; ! 5814: S.quit = 0; ! 5815: S.base = S1->base; ! 5816: ! 5817: /* Try to get file status. If unsuccessful, errno will say why. */ ! 5818: if (lstat(path, &sb) < 0) { ! 5819: rc = (*T->fn) (path, &sb, FTW_NS, &S); ! 5820: S1->quit = S.quit; ! 5821: return rc; ! 5822: }; ! 5823: ! 5824: /* ! 5825: * The stat succeeded, so we know the object exists. ! 5826: * If not a directory, call the user function and return. ! 5827: */ ! 5828: #ifdef S_ISLNK ! 5829: if (S_ISLNK(sb.st_mode )) { ! 5830: rc = (*T->fn) (path, &sb, FTW_SL, &S); ! 5831: S1->quit = S.quit; ! 5832: if (rc || S.quit == FTW_SKR) return rc; ! 5833: if (S.quit != FTW_FOLLOW) return 0; ! 5834: S1->quit = S.quit = 0; ! 5835: if (stat(path, &sb) < 0) { ! 5836: rc = (*T->fn) (path, &sb, FTW_NSL, &S); ! 5837: S1->quit = S.quit; ! 5838: return rc; ! 5839: }; ! 5840: } ! 5841: #endif ! 5842: ! 5843: if (!S_ISDIR(sb.st_mode)) { ! 5844: rc = (*T->fn) (path, &sb, FTW_F, &S); ! 5845: S1->quit = S.quit; ! 5846: return rc; ! 5847: } ! 5848: ! 5849: /* ! 5850: * The object was a directory. ! 5851: * ! 5852: * Open a file to read the directory ! 5853: */ ! 5854: mr.fd = fd = opendir(path); ! 5855: ! 5856: /* ! 5857: * Call the user function, telling it whether ! 5858: * the directory can be read. If it can't be read ! 5859: * call the user function or indicate an error, ! 5860: * depending on the reason it couldn't be read. ! 5861: */ ! 5862: if (!fd) { ! 5863: rc = (*T->fn) (path, &sb, FTW_DNR, &S); ! 5864: S1->quit = S.quit; ! 5865: return rc; ! 5866: } ! 5867: ! 5868: /* We could read the directory. Call user function. */ ! 5869: rc = (*T->fn) (path, &sb, FTW_D, &S); ! 5870: if (rc != 0) ! 5871: goto rtrn; ! 5872: if (S.quit == FTW_SKD) goto rtrn; ! 5873: if (S.quit == FTW_SKR) {S1->quit = FTW_SKR; goto rtrn;} ! 5874: ! 5875: /* Make sure path is big enough to hold generated pathnames. */ ! 5876: ! 5877: n = nextsave = T->pathnext; ! 5878: if (n + MAXNAMLEN + 1 >= T->pathlast) { ! 5879: T->pathlast += FTW_PATHINC; ! 5880: path = T->path = realloc(T->path, T->pathlast); ! 5881: if (!path) { ! 5882: errno = ENOMEM; ! 5883: rc = -1; ! 5884: goto rtrn; ! 5885: } ! 5886: } ! 5887: ! 5888: /* Create a prefix to which we will append component names */ ! 5889: ! 5890: if (n > 0 && path[n-1] != '/') path[n++] = '/'; ! 5891: component = path + n; ! 5892: ! 5893: /* ! 5894: * Read the directory one component at a time. ! 5895: * We must ignore "." and "..", but other than that, ! 5896: * just create a path name and call self to check it out. ! 5897: */ ! 5898: while (dirp = readdir(fd)) { ! 5899: if (dirp->d_ino != 0 ! 5900: && strcmp (dirp->d_name, ".") != 0 ! 5901: && strcmp (dirp->d_name, "..") != 0) { ! 5902: int i; ! 5903: struct FTW_rec *pr; ! 5904: ! 5905: /* Append the component name to the working path */ ! 5906: strcpy(component, dirp->d_name); ! 5907: T->pathnext = n + strlen(dirp->d_name); ! 5908: ! 5909: /* ! 5910: * If we are about to exceed our depth, ! 5911: * remember where we are and close the file. ! 5912: */ ! 5913: if (level - T->lastout >= T->depth) { ! 5914: pr = &mr; ! 5915: i = T->lastout++; ! 5916: while (++i < level) pr = pr->prev; ! 5917: pr->here = telldir(pr->fd); ! 5918: closedir(pr->fd); ! 5919: } ! 5920: ! 5921: /* ! 5922: * Do a recursive call to process the file. ! 5923: */ ! 5924: S.quit = 0; ! 5925: S.base = n; ! 5926: rc = ftw_1_(&mr, T, level+1, &S); ! 5927: if (rc != 0 || S.quit == FTW_SKR) { ! 5928: if (level > T->lastout) closedir(fd); ! 5929: T->pathnext = nextsave; ! 5930: return rc; ! 5931: } ! 5932: ! 5933: /* ! 5934: * If we closed the file, try to reopen it. ! 5935: */ ! 5936: if (level <= T->lastout) { ! 5937: char c = path[nextsave]; ! 5938: path[nextsave] = 0; ! 5939: T->lastout = level - 1; ! 5940: mr.fd = fd = opendir(path); ! 5941: if (!fd) { ! 5942: rc = (*T->fn) (path, &sb, FTW_DNR, &S); ! 5943: S1->quit = S.quit; ! 5944: T->pathnext = nextsave; ! 5945: return rc; ! 5946: } ! 5947: path[nextsave] = c; ! 5948: seekdir(fd, mr.here); ! 5949: } ! 5950: } ! 5951: } ! 5952: T->pathnext = nextsave; ! 5953: path[nextsave] = 0; ! 5954: ! 5955: /* ! 5956: * We got out of the subdirectory loop. Call the user ! 5957: * function again at the end and clean up. ! 5958: */ ! 5959: ! 5960: rc = (*T->fn) (path, &sb, FTW_DP, &S); ! 5961: S1->quit = S.quit; ! 5962: rtrn: ! 5963: closedir(fd); ! 5964: return rc; ! 5965: } ! 5966: T->lastout = level - 1; ! 5967: mr.fd = fd = opendir(path); ! 5968: if (!fd) { ! 5969: rc = (*T->fn) (path, &sb, FTW_DNR, &S); ! 5970: S1->quit = S.quit; ! 5971: T->pathnext = nextspkg/ftw.h 644 3513 4 1462 5031452570 5643 #ifndef __FTW ! 5972: #define __FTW ! 5973: ! 5974: /* ! 5975: * Codes for the third argument to the user-supplied function ! 5976: * which is passed as the second argument to ftw... ! 5977: */ ! 5978: ! 5979: #define FTW_F 0 /* file */ ! 5980: #define FTW_D 1 /* directory */ ! 5981: #define FTW_DNR 2 /* directory without read permission */ ! 5982: #define FTW_NS 3 /* unknown type, stat failed */ ! 5983: #define FTW_DP 4 /* directory, postorder visit */ ! 5984: #define FTW_SL 5 /* symbolic link */ ! 5985: #define FTW_NSL 6 /* stat failed (errno = ENOENT) on symbolic link */ ! 5986: ! 5987: /* Values the user-supplied function may wish to assign to ! 5988: component quit of struct FTW... ! 5989: */ ! 5990: ! 5991: #define FTW_SKD 1 /* skip this directory (2nd par = FTW_D) */ ! 5992: #define FTW_SKR 2 /* skip rest of current directory */ ! 5993: #define FTW_FOLLOW 3 /* follow symbolic link */ ! 5994: ! 5995: struct FTW { int quit, base, level; ! 5996: #ifndef FTW_more_to_come ! 5997: }; ! 5998: #endif ! 5999: ! 6000: #endif ! 6001: failed */ ! 6002: #define FTW_DP 4 /* directory, postorder visit */ ! 6003: #define FTW_SL 5 /* symbolic link */ ! 6004: #define FTW_NSL 6 /* stat failed (errno = ENOENT) on symbolic link */ ! 6005: ! 6006: /* Values the user-supplied function plan9/ 755 3513 4 0 5031450043 5035 sysv/ 755 3513 4 0 5031457617 5034 sysv/lcreat.c 644 3513 4 172 5031151403 6477 #include <fcntl.h> ! 6007: ! 6008: int ! 6009: lcreat(char *name, int mode) ! 6010: { ! 6011: return open(name, O_EXCL | O_CREAT | O_TRUNC | O_WRONLY, mode); ! 6012: } ! 6013: #define �< �< ����9 of 05031457617 ctory �< ����9 _FOL00000005034 low symbolic link */ ! 6014: ! 6015: struct FTW { int quit, base, level; ! 6016: #ifndef FTW_more_to_come ! 6017: }; ! 6018: #endif ! 6019: ! 6020: #endif ! 6021: failed */ ! 6022: #define FTW_DP 4 /* directory, postorder visit */ ! 6023: #define FTW_SL 5 /* symbo link */ ! 6024: ��� �/������D5 & ��� �/ ����D5 ��& e� #����� .$����$ e� sysv/canon.c 644 3513 4 531 5031141175 6327 #include <string.h> ! 6025: ! 6026: /* reduce tcp and dk names to their final component */ ! 6027: void ! 6028: canon(char *sys, char cansys[]) ! 6029: { ! 6030: if (strncmp(sys, "dk!", 3) == 0) ! 6031: sys += 3; ! 6032: if (strncmp(sys, "tcp!", 4) == 0) ! 6033: sys += 4; ! 6034: if (strrchr(sys, '/')) ! 6035: sys = strrchr(sys, '/') + 1; ! 6036: strcpy(cansys, sys); ! 6037: if (strrchr(cansys, '.')) ! 6038: *strchr(cansys, '.') = '\0'; ! 6039: } ! 6040: y, postorder visit */ ! 6041: #define FTW_SL 5 /* symbo link */ ! 6042: ��� �/������D5 & ��� �/ ����D5 ��& e� #����� .$����$ e� sysv/canonmain.c 644 3513 4 176 5031141232 7173 main(int argc, char **argv) ! 6043: { ! 6044: char cansys[256]; ! 6045: ! 6046: while (--argc) { ! 6047: canon(*++argv, cansys); ! 6048: puts(cansys); ! 6049: } ! 6050: return 0; ! 6051: } ! 6052: p(sys, "dk!", 3) == 0) ! 6053: sys += 3; ! 6054: if (strncmp(sys, "tcp!", 4) == 0) ! 6055: sys += 4; ! 6056: if (strrchr(sys, '/')) ! 6057: sys = strrchr(sys, '/') + 1; ! 6058: strcpy(cansys, sys); ! 6059: if (strrchr(cansys, '.')) ! 6060: *strchr(cansys, '.') = '\0'; ! 6061: } ! 6062: y, postorder visit */ ! 6063: #define FTW_SL 5 /* symbo link */ ! 6064: ��� �/������D5 & ��� �/ ����D5 ��& e� #����� .$����$ e� sysv/connect.c 644 3513 4 3221 5031146510 6677 /* usage: connect hostname (answer|send|notice) (in|out) program [ args ... ] */ ! 6065: /* TODO: should librarify the bit for opening an rsh-authenticated connection. */ ! 6066: ! 6067: #include <sys/types.h> ! 6068: #include <sys/socket.h> ! 6069: #include <netinet/in.h> ! 6070: #include <netdb.h> ! 6071: #include <pwd.h> ! 6072: #include <stdio.h> ! 6073: #include <string.h> ! 6074: #include "../paths.h" ! 6075: ! 6076: int ! 6077: main(int argc, char *argv[]) ! 6078: { ! 6079: int fd; ! 6080: struct hostent *host; ! 6081: struct servent *serv; ! 6082: struct passwd *pw; ! 6083: int lport; ! 6084: struct sockaddr_in sin; ! 6085: char byte; ! 6086: ! 6087: if (argc < 5) ! 6088: exit(1); ! 6089: ! 6090: host = gethostbyname(argv[1]); ! 6091: if (!host) { ! 6092: fprintf(stderr, "connect: can't get host '%s'\n", argv[1]); ! 6093: exit(1); ! 6094: } ! 6095: ! 6096: serv = getservbyname("dist", "tcp"); ! 6097: if (!serv) { ! 6098: fprintf(stderr, "connect: can't get 'dist' port number\n"); ! 6099: exit(1); ! 6100: } ! 6101: ! 6102: pw = getpwuid(getuid()); /* we assume unique uid/name map */ ! 6103: if (!pw) { ! 6104: fprintf(stderr, "connect: can't get user name\n"); ! 6105: exit(1); ! 6106: } ! 6107: ! 6108: chdir(LDIR); ! 6109: ! 6110: lport = 1023; ! 6111: fd = rresvport(&lport); ! 6112: if (fd < 0) { ! 6113: perror("connect: getting socket"); ! 6114: exit(1); ! 6115: } ! 6116: ! 6117: sin.sin_family = host->h_addrtype; ! 6118: memcpy(&sin.sin_addr, host->h_addr, host->h_length); ! 6119: sin.sin_port = serv->s_port; ! 6120: if (connect(fd, &sin, sizeof sin) < 0) { ! 6121: perror("connect: opening connection"); ! 6122: exit(1); ! 6123: } ! 6124: ! 6125: write(fd, "", 1); /* a NUL byte */ ! 6126: write(fd, pw->pw_name, strlen(pw->pw_name) + 1); ! 6127: write(fd, pw->pw_name, strlen(pw->pw_name) + 1); ! 6128: if (read(fd, &byte, 1) != 1 || byte != '\0') { ! 6129: fprintf(stderr, "connect: rsh authentication failed\n"); ! 6130: exit(1); ! 6131: } ! 6132: ! 6133: write(fd, argv[2], strlen(argv[2]) + 1); ! 6134: ! 6135: if (strchr(argv[3], 'i')) ! 6136: dup2(fd, 0); ! 6137: if (strchr(argv[3], 'o')) ! 6138: dup2(fd, 1); ! 6139: close(fd); ! 6140: execv(argv[4], &argv[4]); ! 6141: } ! 6142: (fd, &sin, sizeof sin) < 0) { ! 6143: perror("connect: opening connection"); ! 6144: exit(1); ! 6145: } ! 6146: ! 6147: write(fd, "", 1); /* a NUL byte */ ! 6148: write(fd, pw->pw_name, strlen(pw->pw_name) + 1); ! 6149: write(fd, pw->pw_name, strlen(pw->pw_name) + 1); ! 6150: if (read(fd, &byte, 1) != 1 || byte != '\0') { ! 6151: fprintf(stderr, "connect: rsh authentication failed\n"); ! 6152: exit(1); ! 6153: } ! 6154: ! 6155: write(fd, argv[2], strsysv/dispatch.c 644 3513 4 1700 5031146670 7054 /* usage: dispatch <ipc args> */ ! 6156: /* TODO: connect input to /dev/null if peer wants no output, ! 6157: connect output to logfile if peer wants no input. */ ! 6158: ! 6159: #include <sys/types.h> ! 6160: #include <sys/sockets.h> ! 6161: #include <netinet/in.h> ! 6162: #include <netdb.h> ! 6163: #include <string.h> ! 6164: #include "../paths.h" ! 6165: ! 6166: int ! 6167: main(int argc, char *argv[]) ! 6168: { ! 6169: char c, d; ! 6170: char *args[3]; ! 6171: int fd; ! 6172: ! 6173: if (chdir(LDIR) < 0) ! 6174: return 1; ! 6175: ! 6176: /* TODO: at this point, perform rshd style authentication check, ! 6177: set the appropriate user id, and all that. See what kind of ! 6178: args we can get from inetd. */ ! 6179: ! 6180: if (read(0, &c, 1) != 1) ! 6181: return 1; ! 6182: do ! 6183: if (read(0, &d, 1) != 1) ! 6184: return 1; ! 6185: while (d); ! 6186: ! 6187: fd = open("/dev/null", 1); ! 6188: dup2(fd, 2); ! 6189: if (fd > 2) ! 6190: close(fd); ! 6191: ! 6192: switch (c) { ! 6193: case 's': ! 6194: args[0] = "showq"; ! 6195: execv("showq", args); ! 6196: break; ! 6197: case 't': ! 6198: args[0] = "transmit"; ! 6199: execv("transmit", args); ! 6200: break; ! 6201: case 'n': ! 6202: args[0] = "notice"; ! 6203: execv("notice", args); ! 6204: break; ! 6205: } ! 6206: ! 6207: return 1; ! 6208: } ! 6209: tion check, ! 6210: set the appropriate user id, and all that. See sysv/mkfile 644 3513 4 1012 5031452776 6306 <../mkconf.sysv ! 6211: ! 6212: CC=cc ! 6213: LPROG=connect canon #dispatch ! 6214: LIBS=lib.a ! 6215: LIBOBJ=canon.o lcreat.o ! 6216: ! 6217: %: %.sh ! 6218: cp $stem.sh $target ! 6219: chmod +x $target ! 6220: ! 6221: connect: connect.o ! 6222: $CC $CFLAGS -o connect connect.o ! 6223: ! 6224: dispatch: dispatch.o ! 6225: $CC $CFLAGS -o dispatch dispatch.o ! 6226: ! 6227: canon: canonmain.o lib.a ! 6228: $CC $CFLAGS -o canon canonmain.o lib.a ! 6229: ! 6230: compile:V: $LPROG $LIBS ! 6231: ! 6232: install:V: ! 6233: test -d $LDIR || mkdir $LDIR ! 6234: cp $LPROG $LDIR ! 6235: chown root $LDIR/connect && chmod 4755 $LDIR/connect ! 6236: ! 6237: lib.a: $LIBOBJ ! 6238: ar r lib.a $LIBOBJ ! 6239: ! 6240: clean:V: ! 6241: rm -f $LPROG $LIBS *.o ! 6242: .sysv ! 6243: ! 6244: CC=cc ! 6245: LPROG=connect canon #dispatch ! 6246: LIBS=lib.a ! 6247: LIBOBJ=canon.o lcreat.o ! 6248: ! 6249: %: %.sh ! 6250: cp $stem.sh $target ! 6251: chmod +x $target ! 6252: ! 6253: connect: connect.o ! 6254: $CC $CFLAGS -o connect connect.o ! 6255: ! 6256: dispatch: dispatch.o ! 6257: $CC $CFLAGS -o dispatch dispatch.o ! 6258: ! 6259: canon: canonmain.o lib.a ! 6260: $CC $CFLAGS -o canon canonmain.o lib.a ! 6261: ! 6262: compile:V: $LPROG $LIBS ! 6263: ! 6264: install:V: ! 6265: test -d $LDIR || mkdir $LDIR ! 6266: cp $LPROG $LDIR ! 6267: chown root $LDIR/connect && chmod 4755 $LDIR/connect ! 6268: ! 6269: lib.a: $LIBOBJ ! 6270: ar r lib.a $LIBOBJ ! 6271: ! 6272: clean:V: ! 6273: rm -f $LPROG sysv/libv.h 644 3513 4 50 5031457617 6161 extern int optind; ! 6274: extern char *optarg; ! 6275: on #dispatch ! 6276: LIBS=lib.a ! 6277: LIBOBJ=canon.o lcreat.o ! 6278: ! 6279: %: %.sh ! 6280: cp $stem.sh $target ! 6281: chmod +x $target ! 6282: ! 6283: connect: connect.o ! 6284: $CC $CFLAGS -o connect connect.o ! 6285: ! 6286: dispatch: dispatch.o ! 6287: $CC $CFLAGS -o dispatch dispatch.o ! 6288: ! 6289: canon: canonmain.o lib.a ! 6290: $CC $CFLAGS -o canon canonmain.o lib.a ! 6291: ! 6292: compile:V: $LPROG $LIBS ! 6293: ! 6294: install:V: ! 6295: test -d $LDIR || mkdir $LDIR ! 6296: cp $LPROG $LDIR ! 6297: chown root $LDIR/connect && chmod 4755 $LDIR/connect ! 6298: ! 6299: lib.a: $LIBOBJ ! 6300: ar r lib.a $LIBOBJ ! 6301: ! 6302: clean:V: ! 6303: rm -f $LPROG v10/ 755 3513 4 0 5032703620 4423 v10/mkfile 644 3513 4 766 5030710404 5667 <../mkconf.v10 ! 6304: ! 6305: CC=lcc ! 6306: LPROG=connect dispatch canon hostname ! 6307: LIBS=lib.a ! 6308: LIBOBJ=canon.o lcreat.o ! 6309: ! 6310: %: %.sh ! 6311: cp $stem.sh $target ! 6312: chmod +x $target ! 6313: ! 6314: connect: connect.o ! 6315: $CC $CFLAGS -o connect connect.o -lipc ! 6316: ! 6317: dispatch: dispatch.o ! 6318: $CC $CFLAGS -o dispatch dispatch.o -lipc ! 6319: ! 6320: canon: canonmain.o lib.a ! 6321: $CC $CFLAGS -o canon canonmain.o lib.a ! 6322: ! 6323: compile:V: $LPROG $LIBS ! 6324: ! 6325: install:V: ! 6326: test -d $LDIR || mkdir $LDIR ! 6327: cp $LPROG $LDIR ! 6328: ! 6329: lib.a: $LIBOBJ ! 6330: ar r lib.a $LIBOBJ ! 6331: ranlib lib.a ! 6332: ! 6333: clean:V: ! 6334: rm -f $LPROG $LIBS *.o ! 6335: �$ e� v10/connect.c 644 3513 4 1000 5030753426 6303 /* usage: connect hostname (answer|send|notice) (in|out) program [ args ... ] */ ! 6336: ! 6337: #include <ipc.h> ! 6338: #include <string.h> ! 6339: #include "../paths.h" ! 6340: ! 6341: int ! 6342: main(int argc, char *argv[]) ! 6343: { ! 6344: int fd; ! 6345: ! 6346: if (argc < 5) ! 6347: return 1; ! 6348: ! 6349: chdir(LDIR); ! 6350: ! 6351: fd = ipcopen(ipcpath(argv[1], "dk", "dist"), "heavy bsdauth"); ! 6352: if (fd < 0) { ! 6353: perror(argv[1]); ! 6354: return 1; ! 6355: } ! 6356: ! 6357: write(fd, argv[2], strlen(argv[2]) + 1); ! 6358: ! 6359: if (strchr(argv[3], 'i')) ! 6360: dup2(fd, 0); ! 6361: if (strchr(argv[3], 'o')) ! 6362: dup2(fd, 1); ! 6363: close(fd); ! 6364: execv(argv[4], &argv[4]); ! 6365: } ! 6366: v10/dispatch.c 644 3513 4 1475 5024760412 6465 /* usage: dispatch <ipc args> */ ! 6367: /* TODO: connect input to /dev/null if peer wants no output, ! 6368: connect output to logfile if peer wants no input. */ ! 6369: ! 6370: #include <ipc.h> ! 6371: #include <string.h> ! 6372: #include "../paths.h" ! 6373: ! 6374: int ! 6375: main(int argc, char *argv[]) ! 6376: { ! 6377: char c, d; ! 6378: char *args[3]; ! 6379: int fd; ! 6380: ! 6381: if (chdir(LDIR) < 0) ! 6382: return 1; ! 6383: ! 6384: (args[1] = strchr(argv[1], '=')) && ++args[1]; ! 6385: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6386: args[3] = 0; ! 6387: ! 6388: if (read(0, &c, 1) != 1) ! 6389: return 1; ! 6390: do ! 6391: if (read(0, &d, 1) != 1) ! 6392: return 1; ! 6393: while (d); ! 6394: ! 6395: fd = open("/dev/null", 1); ! 6396: dup2(fd, 2); ! 6397: if (fd > 2) ! 6398: close(fd); ! 6399: ! 6400: switch (c) { ! 6401: case 's': ! 6402: args[0] = "showq"; ! 6403: execv("showq", args); ! 6404: break; ! 6405: case 't': ! 6406: args[0] = "transmit"; ! 6407: execv("transmit", args); ! 6408: break; ! 6409: case 'n': ! 6410: args[0] = "notice"; ! 6411: execv("notice", args); ! 6412: break; ! 6413: } ! 6414: ! 6415: return 1; ! 6416: } ! 6417: ; ! 6418: ! 6419: (args[1] = strchr(argv[1], '=')) && ++args[1]; ! 6420: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6421: args[3] = 0; ! 6422: ! 6423: if (read(0, &c, 1) != 1) ! 6424: return 1; ! 6425: do ! 6426: if (read(0, &d, 1) != 1) ! 6427: return 1;v10/lcreat.c 644 3513 4 443 5020263747 6117 int ! 6428: lcreat(char *name, int mode) ! 6429: { ! 6430: char temp[14]; ! 6431: int fd; ! 6432: ! 6433: sprintf(temp, "lcreat.%d", getpid()); /* only works in same file system */ ! 6434: fd = creat(temp, mode); ! 6435: if (fd < 0) ! 6436: return fd; ! 6437: if (link(temp, name) < 0) { ! 6438: close(fd); ! 6439: unlink(temp); ! 6440: return -1; ! 6441: } ! 6442: unlink(temp); ! 6443: return fd; ! 6444: } ! 6445: break; ! 6446: } ! 6447: ! 6448: return 1; ! 6449: } ! 6450: ; ! 6451: ! 6452: (args[1] = strchr(argv[1], '=')) && ++args[1]; ! 6453: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6454: args[3] = 0; ! 6455: ! 6456: if (read(0, &c, 1) != 1) ! 6457: return 1; ! 6458: do ! 6459: if (read(0, &d, 1) != 1) ! 6460: return 1;v10/canon.c 644 3513 4 531 5030711060 5724 #include <string.h> ! 6461: ! 6462: /* reduce tcp and dk names to their final component */ ! 6463: void ! 6464: canon(char *sys, char cansys[]) ! 6465: { ! 6466: if (strncmp(sys, "dk!", 3) == 0) ! 6467: sys += 3; ! 6468: if (strncmp(sys, "tcp!", 4) == 0) ! 6469: sys += 4; ! 6470: if (strrchr(sys, '/')) ! 6471: sys = strrchr(sys, '/') + 1; ! 6472: strcpy(cansys, sys); ! 6473: if (strrchr(cansys, '.')) ! 6474: *strchr(cansys, '.') = '\0'; ! 6475: } ! 6476: ], '=')) && ++args[1]; ! 6477: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6478: args[3] = 0; ! 6479: ! 6480: if (read(0, &c, 1) != 1) ! 6481: return 1; ! 6482: do ! 6483: if (read(0, &d, 1) != 1) ! 6484: return 1;v10/canonmain.c 644 3513 4 176 5030712000 6571 main(int argc, char **argv) ! 6485: { ! 6486: char cansys[256]; ! 6487: ! 6488: while (--argc) { ! 6489: canon(*++argv, cansys); ! 6490: puts(cansys); ! 6491: } ! 6492: return 0; ! 6493: } ! 6494: p(sys, "dk!", 3) == 0) ! 6495: sys += 3; ! 6496: if (strncmp(sys, "tcp!", 4) == 0) ! 6497: sys += 4; ! 6498: if (strrchr(sys, '/')) ! 6499: sys = strrchr(sys, '/') + 1; ! 6500: strcpy(cansys, sys); ! 6501: if (strrchr(cansys, '.')) ! 6502: *strchr(cansys, '.') = '\0'; ! 6503: } ! 6504: ], '=')) && ++args[1]; ! 6505: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6506: args[3] = 0; ! 6507: ! 6508: if (read(0, &c, 1) != 1) ! 6509: return 1; ! 6510: do ! 6511: if (read(0, &d, 1) != 1) ! 6512: return 1;v10/hostname.sh 644 3513 4 35 5021475777 6641 #! /bin/sh - ! 6513: cat /etc/whoami ! 6514: ! 6515: char cansys[256]; ! 6516: ! 6517: while (--argc) { ! 6518: canon(*++argv, cansys); ! 6519: puts(cansys); ! 6520: } ! 6521: return 0; ! 6522: } ! 6523: p(sys, "dk!", 3) == 0) ! 6524: sys += 3; ! 6525: if (strncmp(sys, "tcp!", 4) == 0) ! 6526: sys += 4; ! 6527: if (strrchr(sys, '/')) ! 6528: sys = strrchr(sys, '/') + 1; ! 6529: strcpy(cansys, sys); ! 6530: if (strrchr(cansys, '.')) ! 6531: *strchr(cansys, '.') = '\0'; ! 6532: } ! 6533: ], '=')) && ++args[1]; ! 6534: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6535: args[3] = 0; ! 6536: ! 6537: if (read(0, &c, 1) != 1) ! 6538: return 1; ! 6539: do ! 6540: if (read(0, &d, 1) != 1) ! 6541: return 1; sysv/libv.h 644 3513 4 50 5031457617 6161 extern int optind; ! 6542: extern char *optarg; ! 6543: on #dispatch ! 6544: LIBS=lib.a ! 6545: LIBOBJ=canon.o lcreat.o ! 6546: ! 6547: %: %.sh ! 6548: cp $stem.sh $target ! 6549: chmod +x $target ! 6550: ! 6551: connect: connect.o ! 6552: $CC $CFLAGS -o connect connect.o ! 6553: ! 6554: dispatch: dispatch.o ! 6555: $CC $CFLAGS -o dispatch dispatch.o ! 6556: ! 6557: canon: canonmain.o lib.a ! 6558: $CC $CFLAGS -o canon canonmain.o lib.a ! 6559: ! 6560: compile:V: $LPROG $LIBS ! 6561: ! 6562: install:V: ! 6563: test -d $LDIR || mkdir $LDIR ! 6564: cp $LPROG $LDIR ! 6565: chown root $LDIR/connect && chmod 4755 $LDIR/connect ! 6566: ! 6567: lib.a: $LIBOBJ ! 6568: ar r lib.a $LIBOBJ ! 6569: ! 6570: clean:V: ! 6571: rm -f $LPROG v10/ 755 3513 4 0 5032703620 4423 v10/mkfile 644 3513 4 766 5030710404 5667 <../mkconf.v10 ! 6572: ! 6573: CC=lcc ! 6574: LPROG=connect dispatch canon hostname ! 6575: LIBS=lib.a ! 6576: LIBOBJ=canon.o lcreat.o ! 6577: ! 6578: %: %.sh ! 6579: cp $stem.sh $target ! 6580: chmod +x $target ! 6581: ! 6582: connect: connect.o ! 6583: $CC $CFLAGS -o connect connect.o -lipc ! 6584: ! 6585: dispatch: dispatch.o ! 6586: $CC $CFLAGS -o dispatch dispatch.o -lipc ! 6587: ! 6588: canon: canonmain.o lib.a ! 6589: $CC $CFLAGS -o canon canonmain.o lib.a ! 6590: ! 6591: compile:V: $LPROG $LIBS ! 6592: ! 6593: install:V: ! 6594: test -d $LDIR || mkdir $LDIR ! 6595: cp $LPROG $LDIR ! 6596: ! 6597: lib.a: $LIBOBJ ! 6598: ar r lib.a $LIBOBJ ! 6599: ranlib lib.a ! 6600: ! 6601: clean:V: ! 6602: rm -f $LPROG $LIBS *.o ! 6603: �$ e� v10/connect.c 644 3513 4 1000 5030753426 6303 /* usage: connect hostname (answer|send|notice) (in|out) program [ args ... ] */ ! 6604: ! 6605: #include <ipc.h> ! 6606: #include <string.h> ! 6607: #include "../paths.h" ! 6608: ! 6609: int ! 6610: main(int argc, char *argv[]) ! 6611: { ! 6612: int fd; ! 6613: ! 6614: if (argc < 5) ! 6615: return 1; ! 6616: ! 6617: chdir(LDIR); ! 6618: ! 6619: fd = ipcopen(ipcpath(argv[1], "dk", "dist"), "heavy bsdauth"); ! 6620: if (fd < 0) { ! 6621: perror(argv[1]); ! 6622: return 1; ! 6623: } ! 6624: ! 6625: write(fd, argv[2], strlen(argv[2]) + 1); ! 6626: ! 6627: if (strchr(argv[3], 'i')) ! 6628: dup2(fd, 0); ! 6629: if (strchr(argv[3], 'o')) ! 6630: dup2(fd, 1); ! 6631: close(fd); ! 6632: execv(argv[4], &argv[4]); ! 6633: } ! 6634: v10/dispatch.c 644 3513 4 1475 5024760412 6465 /* usage: dispatch <ipc args> */ ! 6635: /* TODO: connect input to /dev/null if peer wants no output, ! 6636: connect output to logfile if peer wants no input. */ ! 6637: ! 6638: #include <ipc.h> ! 6639: #include <string.h> ! 6640: #include "../paths.h" ! 6641: ! 6642: int ! 6643: main(int argc, char *argv[]) ! 6644: { ! 6645: char c, d; ! 6646: char *args[3]; ! 6647: int fd; ! 6648: ! 6649: if (chdir(LDIR) < 0) ! 6650: return 1; ! 6651: ! 6652: (args[1] = strchr(argv[1], '=')) && ++args[1]; ! 6653: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6654: args[3] = 0; ! 6655: ! 6656: if (read(0, &c, 1) != 1) ! 6657: return 1; ! 6658: do ! 6659: if (read(0, &d, 1) != 1) ! 6660: return 1; ! 6661: while (d); ! 6662: ! 6663: fd = open("/dev/null", 1); ! 6664: dup2(fd, 2); ! 6665: if (fd > 2) ! 6666: close(fd); ! 6667: ! 6668: switch (c) { ! 6669: case 's': ! 6670: args[0] = "showq"; ! 6671: execv("showq", args); ! 6672: break; ! 6673: case 't': ! 6674: args[0] = "transmit"; ! 6675: execv("transmit", args); ! 6676: break; ! 6677: case 'n': ! 6678: args[0] = "notice"; ! 6679: execv("notice", args); ! 6680: break; ! 6681: } ! 6682: ! 6683: return 1; ! 6684: } ! 6685: ; ! 6686: ! 6687: (args[1] = strchr(argv[1], '=')) && ++args[1]; ! 6688: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6689: args[3] = 0; ! 6690: ! 6691: if (read(0, &c, 1) != 1) ! 6692: return 1; ! 6693: do ! 6694: if (read(0, &d, 1) != 1) ! 6695: return 1;v10/lcreat.c 644 3513 4 443 5020263747 6117 int ! 6696: lcreat(char *name, int mode) ! 6697: { ! 6698: char temp[14]; ! 6699: int fd; ! 6700: ! 6701: sprintf(temp, "lcreat.%d", getpid()); /* only works in same file system */ ! 6702: fd = creat(temp, mode); ! 6703: if (fd < 0) ! 6704: return fd; ! 6705: if (link(temp, name) < 0) { ! 6706: close(fd); ! 6707: unlink(temp); ! 6708: return -1; ! 6709: } ! 6710: unlink(temp); ! 6711: return fd; ! 6712: } ! 6713: break; ! 6714: } ! 6715: ! 6716: return 1; ! 6717: } ! 6718: ; ! 6719: ! 6720: (args[1] = strchr(argv[1], '=')) && ++args[1]; ! 6721: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6722: args[3] = 0; ! 6723: ! 6724: if (read(0, &c, 1) != 1) ! 6725: return 1; ! 6726: do ! 6727: if (read(0, &d, 1) != 1) ! 6728: return 1;v10/canon.c 644 3513 4 531 5030711060 5724 #include <string.h> ! 6729: ! 6730: /* reduce tcp and dk names to their final component */ ! 6731: void ! 6732: canon(char *sys, char cansys[]) ! 6733: { ! 6734: if (strncmp(sys, "dk!", 3) == 0) ! 6735: sys += 3; ! 6736: if (strncmp(sys, "tcp!", 4) == 0) ! 6737: sys += 4; ! 6738: if (strrchr(sys, '/')) ! 6739: sys = strrchr(sys, '/') + 1; ! 6740: strcpy(cansys, sys); ! 6741: if (strrchr(cansys, '.')) ! 6742: *strchr(cansys, '.') = '\0'; ! 6743: } ! 6744: ], '=')) && ++args[1]; ! 6745: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6746: args[3] = 0; ! 6747: ! 6748: if (read(0, &c, 1) != 1) ! 6749: return 1; ! 6750: do ! 6751: if (read(0, &d, 1) != 1) ! 6752: return 1;v10/canonmain.c 644 3513 4 176 5030712000 6571 main(int argc, char **argv) ! 6753: { ! 6754: char cansys[256]; ! 6755: ! 6756: while (--argc) { ! 6757: canon(*++argv, cansys); ! 6758: puts(cansys); ! 6759: } ! 6760: return 0; ! 6761: } ! 6762: p(sys, "dk!", 3) == 0) ! 6763: sys += 3; ! 6764: if (strncmp(sys, "tcp!", 4) == 0) ! 6765: sys += 4; ! 6766: if (strrchr(sys, '/')) ! 6767: sys = strrchr(sys, '/') + 1; ! 6768: strcpy(cansys, sys); ! 6769: if (strrchr(cansys, '.')) ! 6770: *strchr(cansys, '.') = '\0'; ! 6771: } ! 6772: ], '=')) && ++args[1]; ! 6773: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6774: args[3] = 0; ! 6775: ! 6776: if (read(0, &c, 1) != 1) ! 6777: return 1; ! 6778: do ! 6779: if (read(0, &d, 1) != 1) ! 6780: return 1;v10/hostname.sh 644 3513 4 35 5021475777 6641 #! /bin/sh - ! 6781: cat /etc/whoami ! 6782: ! 6783: char cansys[256]; ! 6784: ! 6785: while (--argc) { ! 6786: canon(*++argv, cansys); ! 6787: puts(cansys); ! 6788: } ! 6789: return 0; ! 6790: } ! 6791: p(sys, "dk!", 3) == 0) ! 6792: sys += 3; ! 6793: if (strncmp(sys, "tcp!", 4) == 0) ! 6794: sys += 4; ! 6795: if (strrchr(sys, '/')) ! 6796: sys = strrchr(sys, '/') + 1; ! 6797: strcpy(cansys, sys); ! 6798: if (strrchr(cansys, '.')) ! 6799: *strchr(cansys, '.') = '\0'; ! 6800: } ! 6801: ], '=')) && ++args[1]; ! 6802: (args[2] = strchr(argv[2], '=')) && ++args[2]; ! 6803: args[3] = 0; ! 6804: ! 6805: if (read(0, &c, 1) != 1) ! 6806: return 1; ! 6807: do ! 6808: if (read(0, &d, 1) != 1) ! 6809: return 1;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.