![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uumkdir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / src|
Return to uumkdir.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / src |
1.1 ! root 1: /* ! 2: * uumkdir.c ! 3: * ! 4: * Makes directories for uucico to write in. ! 5: * ! 6: */ ! 7: ! 8: #include <sys/stat.h> ! 9: #include <sys/dir.h> ! 10: #include <sys/ino.h> ! 11: #include <pwd.h> ! 12: #include <signal.h> ! 13: #include <errno.h> ! 14: #include "dcp.h" ! 15: ! 16: #ifndef NULL ! 17: #define NULL ((char*) 0) ! 18: #endif ! 19: ! 20: #ifndef TRUE ! 21: #define TRUE (0 == 0) ! 22: #endif ! 23: ! 24: #define MAXDIR 32 ! 25: #define equal(s1, s2) (strcmp(s1, s2) == 0) ! 26: ! 27: /* ! 28: * Masks by types of permissions. ! 29: */ ! 30: #define AEXEC (S_IEXEC|(S_IEXEC>>3)|(S_IEXEC>>6)) ! 31: #define AREAD (S_IREAD|(S_IREAD>>3)|(S_IREAD>>6)) ! 32: #define AWRITE (S_IWRITE|(S_IWRITE>>3)|(S_IWRITE>>6)) ! 33: #define ASUID (S_ISUID|S_ISGID) ! 34: #define ATEXT S_ISVTX ! 35: ! 36: /* ! 37: * Masks by types of users. ! 38: */ ! 39: #define AOWN (S_ISUID|S_ISVTX|S_IREAD|S_IWRITE|S_IEXEC) ! 40: #define AGRP (S_ISGID|S_ISVTX|(S_IREAD>>3)|(S_IWRITE>>3)|(S_IEXEC>>3)) ! 41: #define AOTH (S_ISVTX|(S_IREAD>>6)|(S_IWRITE>>6)|(S_IEXEC>>6)) ! 42: #define AALL (AOWN|AGRP|AOTH) ! 43: ! 44: typedef ! 45: struct inpdir_s { ! 46: char * dir; /* dir string entered */ ! 47: char * start; /* start of new dir in string */ ! 48: char * end; /* end of dir string */ ! 49: char * p; /* end of current parent string */ ! 50: char * c; /* end of current child string */ ! 51: } inpdir_t; ! 52: ! 53: char usage[] = "Usage: uumkdir [ -m mode ] [ -p ] dir ...\n"; ! 54: char badsm[] = "uumkdir: badly formed symbolic mode\n"; ! 55: char badom[] = "uumkdir: badly formed octal mode\n"; ! 56: ! 57: long int new; /* bit-wise child dir condition */ ! 58: short uid; /* user ID */ ! 59: int interrupted; /* interrupt flag */ ! 60: int endflag; /* end od dir string flag */ ! 61: int pflag; /* p option flag */ ! 62: int mflag; /* m option flag */ ! 63: int mode = 0755; /* initial mode setup for m option */ ! 64: ! 65: extern char *malloc(); ! 66: extern char *strcpy(); ! 67: extern char *strncpy(); ! 68: extern char *strcat(); ! 69: ! 70: /* ! 71: * Interrupts are handled to prevent the formation of mangled directories. ! 72: */ ! 73: ! 74: main(argc, argv) ! 75: int argc; ! 76: register char ** argv; ! 77: ! 78: { ! 79: register int status = 0; /* condition of mkdir: ! 80: 0 - success, 1 - error */ ! 81: inpdir_t dirs; /* structure with dir string info */ ! 82: char * end; /* pointer to end of dir string */ ! 83: ! 84: extern void fatal(); ! 85: extern int catch(); ! 86: extern int readmode(); ! 87: extern int mkpath(); ! 88: extern int error(); ! 89: ! 90: if ( (setuid(0) < 0) || (setgid(0) < 0) ) ! 91: fatal("uumkdir must be executed setuid root\n"); ! 92: ! 93: catch(SIGINT); ! 94: catch(SIGHUP); ! 95: signal(SIGQUIT, SIG_IGN); ! 96: ! 97: while((--argc > 0) && ((*++argv)[0] == '-')) { ! 98: switch((*argv)[1]) { ! 99: case 'p': ! 100: if (pflag) ! 101: fatal(usage); ! 102: pflag = TRUE; ! 103: break; ! 104: case 'm': ! 105: if (mflag || (--argc <= 0)) ! 106: fatal(usage); ! 107: uid = getuid(); ! 108: mflag = TRUE; ! 109: mode = readmode(*++argv, mode); ! 110: break; ! 111: case 'v': ! 112: case 'V': ! 113: fatal("uumkdir: Version %s", VERSION); ! 114: default: ! 115: fatal(usage); ! 116: } ! 117: } ! 118: if (argc <= 0) ! 119: fatal(usage); ! 120: else { ! 121: for(; *argv ; ++argv) { ! 122: if (dirs.dir) ! 123: free(dirs.dir); ! 124: for(end = *argv ; *end != '\0' ; ++end) ! 125: ; ! 126: do { ! 127: if (end == *argv) { ! 128: error("bad argument (empty string)", 0); ! 129: exit(1); ! 130: } ! 131: } while(*--end == '/'); ! 132: *++end = '\0'; ! 133: if ((dirs.dir = malloc(end - *argv + 1)) == NULL) { ! 134: error("out of memory ", 0); ! 135: exit(1); ! 136: } ! 137: strcpy(dirs.dir, *argv); ! 138: dirs.end = dirs.dir + (end - *argv); ! 139: if (mkpath(&dirs) < 0) ! 140: status = 1; /* error */ ! 141: if (interrupted) ! 142: exit(1); ! 143: } ! 144: } ! 145: exit(status); ! 146: } ! 147: ! 148: /** ! 149: * int ! 150: * mkpath(pdir) ! 151: * inpdir_t * pdir; ! 152: * ! 153: * Input: pdir - pointer to structure. ! 154: * ! 155: * Action: Create new directory and all necessary directories ! 156: * to new directory. ! 157: * ! 158: * Return: 0 if all directory creations are successful, else -1. ! 159: * ! 160: * Note: All directories created before an error is ! 161: * encountered are not removed from user's file. ! 162: */ ! 163: ! 164: int ! 165: mkpath(pdir) ! 166: inpdir_t * pdir; ! 167: { ! 168: register char * childnam; /* dir name of child */ ! 169: register char * child; /* path name of child */ ! 170: register char * parent; /* path name of parent */ ! 171: register int n; ! 172: int err; /* error response from dir creation */ ! 173: int numdir; /* number of directories minus first ! 174: parent specified in full path name */ ! 175: extern char * getparent(); ! 176: extern char * getchild(); ! 177: extern char * getpath(); ! 178: extern int mkdir(); ! 179: extern int setmod(); ! 180: extern int error(); ! 181: ! 182: numdir = 0; ! 183: new = 0L; ! 184: endflag = !TRUE; ! 185: ! 186: if ((child = malloc(pdir->end - pdir->dir + 1)) == NULL) ! 187: return(error("out of memory ", 0)); ! 188: parent = getparent(pdir); ! 189: n = pdir->start - pdir->dir; ! 190: strncpy(child, pdir->dir, n); ! 191: child[n] = '\0'; ! 192: do { ! 193: ++numdir; ! 194: if ((int)(childnam = getchild(pdir)) < 0) { ! 195: error("can't get dir name ", pdir->dir, 0); ! 196: break; ! 197: } ! 198: child = getpath(pdir, child); ! 199: if (pdir->c == pdir->end) { ! 200: /* Last child declared cannot be "." or "..". */ ! 201: if (equal(childnam, ".") || equal(childnam, "..")) { ! 202: error(pdir->dir," not allowed", 0); ! 203: break; ! 204: } ! 205: /* Signal end of dir string. */ ! 206: endflag = TRUE; ! 207: if (mkdir(parent, child) == -1) ! 208: break; ! 209: /* Signal new dir. */ ! 210: new = (new << 1) | 1L; ! 211: numdir += MAXDIR; ! 212: } else { ! 213: new = (new << 1) | 0L; ! 214: if (!equal(childnam, ".") && !equal(childnam, "..")) { ! 215: if ((err = mkdir(parent, child)) == -1) ! 216: break; ! 217: else if (err == 0) ! 218: new |= 1L; ! 219: } ! 220: } ! 221: /* Get next parent. */ ! 222: parent = getpath(pdir, parent); ! 223: pdir->p = pdir->c; ! 224: } while(numdir <= MAXDIR); ! 225: /* Set user-selected mode if available. */ ! 226: if (mflag) { ! 227: if (setmod(parent, numdir, pdir->start, (pdir->p - 1)) < 0) ! 228: return(-1); ! 229: } ! 230: if (numdir > MAXDIR) ! 231: return(0); ! 232: else ! 233: return(-1); ! 234: } ! 235: ! 236: /** ! 237: * int ! 238: * setmod(ch, ndir, start, p) ! 239: * char * ch; ! 240: * char * start; ! 241: * char * p; ! 242: * int ndir; ! 243: * ! 244: * Input: ch - string holding all new dir names. ! 245: * start - start of new dir. ! 246: * p - end of new dir. ! 247: * ndir - number of directories tested. ! 248: * ! 249: * Action: Set mode of all new directories created. ! 250: * ! 251: * Return: 0 if all mode setups are successful, else -1. ! 252: * ! 253: * Note: None. ! 254: */ ! 255: ! 256: int ! 257: setmod(ch, ndir, start, p) ! 258: char * ch; ! 259: char * start; ! 260: char * p; ! 261: int ndir; ! 262: { ! 263: char * c; /* pointer to end of dir string */ ! 264: /* Get pointer to end of string. */ ! 265: for(c = ch ; *c != '\0' ; ++c) ! 266: ; ! 267: if (ndir > MAXDIR) ! 268: ndir -= (MAXDIR - 1); ! 269: /* Reset to mode desired. */ ! 270: while(--ndir > 0) { ! 271: /* Change dir mode if new directory. */ ! 272: if ((new & 01L) == 1L) ! 273: if (chmod(ch, mode) < 0) { ! 274: write(2, ch, (c - ch)); ! 275: write(2, ": ", 2); ! 276: write(2, sys_errlist[ errno ], ! 277: strlen(sys_errlist[ errno ])); ! 278: write(2, "\n", 1); ! 279: return(-1); ! 280: } ! 281: new = new >> 1; ! 282: /* Remove current dir name from string. */ ! 283: for(++p ; (--p >= start) && (*p != '/') ; *--c = '\0') ! 284: ; ! 285: /* Remove trailing slashes. */ ! 286: for(++p ; (--p >= start) && (*p == '/') ; *--c = '\0') ! 287: ; ! 288: } ! 289: return(0); ! 290: } ! 291: ! 292: /** ! 293: * char * ! 294: * getparent(pdir) ! 295: * inpdir_t * pdir; ! 296: * ! 297: * Input: pdir - pointer to structure. ! 298: * ! 299: * Action: Get parent to directory currently working on. ! 300: * ! 301: * Return: Pointer to parent string. ! 302: * ! 303: * Note: None. ! 304: */ ! 305: ! 306: char * ! 307: getparent(pdir) ! 308: inpdir_t * pdir; ! 309: { ! 310: int found; /* 0: parent found, -1: parent not found */ ! 311: int size; /* size of dir string in structure */ ! 312: char * par; /* pointer to parent string */ ! 313: char * tail; /* pointer to end of parent string */ ! 314: extern int error(); ! 315: ! 316: size = pdir->end - pdir->dir; ! 317: if ((par = malloc(size + 3)) == NULL) { ! 318: error("out of memory ", 0); ! 319: exit(1); ! 320: } ! 321: /* Copy structure string to parent and set tail to end of ! 322: * parent string. ! 323: */ ! 324: strcpy(par, pdir->dir); ! 325: tail = par + size; ! 326: /* Search for parent string. */ ! 327: do { ! 328: /* Remove last dir name in string. */ ! 329: for(; (--tail >= par) && (*tail != '/') ; *tail = '\0') ! 330: ; ! 331: /* Remove trailing slashes. */ ! 332: for(++tail ; (--tail > par) && (*tail == '/') ; *tail = '\0') ! 333: ; ! 334: /** Substitute "." for null path. */ ! 335: if (++tail == par) { ! 336: *tail = '.'; ! 337: *(tail + 1) = '/'; ! 338: } ! 339: if ((found = access(par, 03)) == -1) ! 340: switch(errno) { ! 341: case ENOENT: ! 342: break; ! 343: case EACCES: ! 344: error("no permission to mkdir in ", par, 0); ! 345: exit(1); ! 346: default: ! 347: error("can't make ", pdir->dir, 0); ! 348: exit(1); ! 349: } ! 350: } while((found == -1) && pflag); ! 351: /* Set start of first child and pointer to end of first parent. */ ! 352: pdir->start = pdir->p = pdir->dir + (tail - par); ! 353: return(par); ! 354: } ! 355: ! 356: /** ! 357: * char * ! 358: * getchild(pdir) ! 359: * inpdir_t * pdir; ! 360: * ! 361: * Input: pdir - pointer to structure. ! 362: * ! 363: * Action: Get current child dir name. ! 364: * ! 365: * Return: Pointer to child dir name. ! 366: * ! 367: * Note: If dir name found exceeds DIRSIZ in length, it will be ! 368: * truncated to DIRSIZ. ! 369: */ ! 370: ! 371: char * ! 372: getchild(pdir) ! 373: inpdir_t * pdir; ! 374: { ! 375: static char nam[ DIRSIZ + 1 ]; /* dir name of child */ ! 376: char * c; /* pointer to end of child name */ ! 377: int i, j; /* working counters */ ! 378: /* Increment to start of next dir name. */ ! 379: for(i = 0, c = pdir->p ; (c < pdir->end) && (*c == '/') ; ++i, ++c) ! 380: ; ! 381: /* Increment to end of dir name. */ ! 382: for(j = 0 ; (c < pdir->end) && (*c != '/') ; ++j, ++c) ! 383: ; ! 384: pdir->c = c; ! 385: /* Copy up to DIRSIZ length of child dir name to static memory. */ ! 386: if (j > DIRSIZ) ! 387: j = DIRSIZ; ! 388: strncpy(nam, pdir->p + i, j); ! 389: nam[j] = '\0'; ! 390: return(nam); ! 391: } ! 392: ! 393: /** ! 394: * char * ! 395: * getpath(pdir, dir) ! 396: * inpdir_t * pdir; ! 397: * char * dir; ! 398: * ! 399: * Input: pdir - pointer to structure. ! 400: * dir - current path name. ! 401: * Action: Get current path name of child. ! 402: * Return: Pointer to current path name. ! 403: * Note: None. ! 404: */ ! 405: ! 406: char * ! 407: getpath(pdir, dir) ! 408: inpdir_t * pdir; ! 409: char * dir; ! 410: { ! 411: strncat(dir, pdir->p, (pdir->c - pdir->p)); ! 412: return(strcat(dir, "\0")); ! 413: } ! 414: ! 415: /** ! 416: * int ! 417: * mkdir(parent, child) ! 418: * char * parent; ! 419: * char * child; ! 420: * ! 421: * Input: parent - pointer to dir path name to parent. ! 422: * child - pointer to dir path name to child. ! 423: * Action: Make a directory. If the parent exists and is writeable, ! 424: * the directory and its "." and ".." links are created. ! 425: * Return: 0 if successful, 1 if dir existed already and dir is ! 426: * not the last dir in string. Else -1. ! 427: * Note: None. ! 428: */ ! 429: ! 430: int ! 431: mkdir(parent, child) ! 432: char * parent; ! 433: char * child; ! 434: { ! 435: extern char * concat(); ! 436: extern int linkerr(); ! 437: extern int error(); ! 438: struct passwd *pw; ! 439: ! 440: /* Test if parent file is accessible by user. */ ! 441: if (access(parent, 03)) ! 442: switch(errno) { ! 443: case ENOENT: ! 444: error("parent dir ", parent, " doesn't exist", 0); ! 445: return(-1); ! 446: case EACCES: ! 447: error("no permission to mkdir in ", parent, 0); ! 448: return(-1); ! 449: default: ! 450: return(error("can't make ", child, 0)); ! 451: } ! 452: /* Creat new directory. */ ! 453: if (mknod(child, IFDIR | 0777, 0)) { ! 454: switch(errno) { ! 455: case EEXIST: ! 456: if (endflag) ! 457: return(error(child, " already exists", 0)); ! 458: else ! 459: return(1); ! 460: case EPERM: ! 461: return(error("not the super-user", 0)); ! 462: default: ! 463: return(error("can't make ", child, 0)); ! 464: } ! 465: } ! 466: if (link(child, concat(child, "/."))) ! 467: return(linkerr(child, ".")); ! 468: if (link(parent, concat(child, "/.."))) ! 469: return(linkerr(child, "..")); ! 470: /* Set ownership of directory to user. */ ! 471: if ((pw = getpwnam("uucp")) == NULL) ! 472: return -1; ! 473: if (chown(child, pw->pw_uid, pw->pw_gid) < 0) ! 474: return -1; ! 475: return(0); ! 476: } ! 477: ! 478: /** ! 479: * char * ! 480: * concat(s1, s2) ! 481: * char * s1, * s2; ! 482: * Input: s1, s2 - strings to be concatenated. ! 483: * Action: Join string s2 to string s1 to form a new string. ! 484: * Return: Pointer to start of concatenation of `s1' and `s2'. ! 485: * Note: None. ! 486: */ ! 487: ! 488: char * ! 489: concat(s1, s2) ! 490: char * s1; ! 491: char * s2; ! 492: { ! 493: static char * str; ! 494: if (str) ! 495: free(str); ! 496: /* Allocate memory space for concatenated string. */ ! 497: if ((str = malloc(strlen(s1) + strlen(s2) + 1)) == NULL) { ! 498: error("out of memory", 0); ! 499: exit(1); ! 500: } ! 501: strcpy(str, s1); ! 502: return(strcat(str, s2)); ! 503: } ! 504: ! 505: /** ! 506: * int ! 507: * linkerr(dir, name) ! 508: * char * dir; ! 509: * char * name; ! 510: * ! 511: * input: dir - directory where linking failed. ! 512: * name - type of link failed, "." or "..". ! 513: * Action: Recover from link failure. In the event that "." or ".." ! 514: * cannot be created, remove all traces of the directory. ! 515: * return: -1. ! 516: * Note: none. ! 517: */ ! 518: ! 519: int ! 520: linkerr(dir, name) ! 521: char * dir; ! 522: char * name; ! 523: { ! 524: extern char * concat(); ! 525: extern int error(); ! 526: ! 527: unlink(concat(dir, "/.")); ! 528: unlink(concat(dir, "/..")); ! 529: unlink(dir); ! 530: return(error("link to '", name, "' failed", 0)); ! 531: } ! 532: ! 533: /** ! 534: * int ! 535: * onintr() ! 536: * ! 537: * Input: None. ! 538: * Action: Reset SIGINT and SIGHUP and set interrupt counter. ! 539: * Return: Pointer to previous action on success, else -1. ! 540: * Note: None. ! 541: */ ! 542: ! 543: int ! 544: onintr() ! 545: { ! 546: signal(SIGINT, SIG_IGN); ! 547: signal(SIGHUP, SIG_IGN); ! 548: ++interrupted; ! 549: } ! 550: ! 551: /** ! 552: * int ! 553: * catch(sig) ! 554: * ! 555: * Input: sig - signal caught. ! 556: * Action: Reset signals. ! 557: * Return: Pointer to previous action on success, else -1. ! 558: * Note: None. ! 559: */ ! 560: ! 561: int ! 562: catch(sig) ! 563: { ! 564: extern int onintr(); ! 565: if (signal(sig, SIG_IGN) == SIG_DFL) ! 566: signal(sig, onintr); ! 567: } ! 568: ! 569: /** ! 570: * int ! 571: * error(arg1) ! 572: * char * arg1; ! 573: * ! 574: * Input: arg1 - error message string. ! 575: * Action: Display error message. ! 576: * Return: -1. ! 577: * Note: None. ! 578: */ ! 579: ! 580: int ! 581: error(arg1) ! 582: char * arg1; ! 583: { ! 584: register char ** p; ! 585: write(2, "mkdir: ", 7); ! 586: for(p = &arg1 ; *p != 0 ; ++p) ! 587: write(2, *p, strlen(*p)); ! 588: write(2, "\n", 1); ! 589: return(-1); ! 590: } ! 591: ! 592: /** ! 593: * int ! 594: * readmode(s, mode) ! 595: * char * s; ! 596: * int mode; ! 597: * ! 598: * Input: s - string containing setting changes. ! 599: * mode - current setting of permission. ! 600: * Action: Read in the symbolic mode and set the variables `who', `op', ! 601: * and `mode'. Knows about the old octal modes as well. ! 602: * Return: New mode. ! 603: * Note: None. ! 604: */ ! 605: ! 606: int ! 607: readmode(s, mode) ! 608: register char * s; ! 609: int mode; ! 610: { ! 611: register int c; ! 612: register int op; ! 613: register int m1, m2; ! 614: extern void fatal(); ! 615: extern void checkmode(); ! 616: extern int getumask(); ! 617: extern int mrepl(); ! 618: ! 619: if ((*s >= '0') && (*s <= '7')) { ! 620: mode = 0; ! 621: while(*s != '\0') { ! 622: if ((*s < '0') || (*s > '7')) ! 623: fatal(badom); ! 624: mode = (mode << 3) | (*s++)-'0'; ! 625: } ! 626: checkmode(mode); ! 627: return(mode); ! 628: } ! 629: newsym: ! 630: for(m1 = 0 ;;) { ! 631: switch(*s++) { ! 632: case 'u': m1 |= AOWN; continue; ! 633: case 'g': m1 |= AGRP; continue; ! 634: case 'o': m1 |= AOTH; continue; ! 635: case 'a': m1 |= AALL; continue; ! 636: default : s--; break; ! 637: } ! 638: break; ! 639: } ! 640: if (m1 == 0) ! 641: m1 = AALL & ~getumask(); ! 642: newop: ! 643: if (((c = *s++) == '=') || (c == '+') || (c == '-')) ! 644: op = c; ! 645: else ! 646: fatal(badsm); ! 647: for(m2 = 0 ;;) { ! 648: switch(*s++) { ! 649: case 'r': m2 |= AREAD; continue; ! 650: case 'w': m2 |= AWRITE; continue; ! 651: case 'x': m2 |= AEXEC; continue; ! 652: case 's': m2 |= ASUID; continue; ! 653: case 't': m2 |= ATEXT; continue; ! 654: case 'u': m2 |= mrepl(mode & AOWN); continue; ! 655: case 'g': m2 |= mrepl((mode & AGRP) << 3); continue; ! 656: case 'o': m2 |= mrepl((mode & AOTH) << 6); continue; ! 657: default : s--; break; ! 658: } ! 659: break; ! 660: } ! 661: switch(op) { ! 662: case '-': mode &= ~(m1 & m2); break; ! 663: case '+': mode |= m1 & m2; break; ! 664: case '=': mode = (mode & ~m1) | (m1 & m2); break; ! 665: } ! 666: if (*s == '\0') { ! 667: checkmode(mode); ! 668: return(mode); ! 669: } ! 670: if ((*s == '+') || (*s == '-') || (*s == '=')) ! 671: goto newop; ! 672: if (*s++ == ',') ! 673: goto newsym; ! 674: fatal(badsm); ! 675: } ! 676: ! 677: /** ! 678: * int ! 679: * getumask() ! 680: * ! 681: * Input: None. ! 682: * ! 683: * Action: Get the value of the umask setting. ! 684: * ! 685: * Return: ???? ! 686: * ! 687: * Note: None. ! 688: */ ! 689: ! 690: int ! 691: getumask() ! 692: ! 693: { ! 694: register int omask; ! 695: ! 696: omask = umask(0); ! 697: umask(omask); ! 698: return(omask); ! 699: } ! 700: ! 701: /** ! 702: * void ! 703: * checkmode(mode) ! 704: * int mode; ! 705: * ! 706: * Input: mode - current setup of permission. ! 707: * Action: Check the mode to see if any problem bits are on. ! 708: * For now, this is S_ISVTX for non-super-users. ! 709: * Return: None. ! 710: * Note: None. ! 711: */ ! 712: ! 713: void ! 714: checkmode(mode) ! 715: register int mode; ! 716: { ! 717: static char stickwarn[] = ! 718: "mkdir: Warning: non-super user may not set sticky bit\n"; ! 719: if ((uid != 0) && (mode & S_ISVTX)) { ! 720: write(2, stickwarn, 54); ! 721: exit(1); ! 722: } ! 723: } ! 724: ! 725: /** ! 726: * int ! 727: * mrepl(m) ! 728: * int m; ! 729: * Input: m - mode setting to be replicated. ! 730: * Action: Replicate the 3-bits of the mode from the owner ! 731: * position to all positions. ! 732: * Return: Replicated mode setup. ! 733: * Note: None. ! 734: */ ! 735: ! 736: int ! 737: mrepl(m) ! 738: register int m; ! 739: { ! 740: register int m1; ! 741: ! 742: m1 = m & AOWN; ! 743: m = m1 | (m1 >> 3) | (m1 >> 6); ! 744: if (m1 & S_ISUID) ! 745: m |= S_ISGID; ! 746: return(m); ! 747: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.