Return to subdir.c CVS log

Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp

Annotation of 42BSD/usr.bin/uucp/subdir.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)subdir.c   5.1 (Berkeley) 7/2/83";
        !             3: #endif
        !             4: 
        !             5: #include "uucp.h"
        !             6: #ifdef UUDIR
        !             7: /*
        !             8:  * By Tom Truscott, March 1983
        !             9:  * THIS VERSION OF SYSKLUDGE IS FOR USE ONLY
        !            10:  * WITH THE 'UUDIR' VERSION OF UUCP.
        !            11:  *
        !            12:  * There once was a separate 'uudir' package to retrofit
        !            13:  * versions of uucp, but that is no longer recommended.
        !            14:  *
        !            15:  * Prefix table.
        !            16:  * If a prefix is "abc", for example,
        !            17:  * then any file Spool/abc... is mapped to Spool/abc/abc... .
        !            18:  * The first prefix found is used, so D.foo should preceed D. in table.
        !            19:  *
        !            20:  * Each prefix must be a subdirectory of Spool, owned by uucp!
        !            21:  * Remember: use cron to uuclean these directories daily,
        !            22:  * and check them manual every now and then.  Beware complacency!
        !            23:  */
        !            24: 
        !            25: static char *prefix[] = {
        !            26:        DLocalX,        /* Outbound 'xqt' request files */
        !            27:        DLocal,         /* Outbound data files */
        !            28:        "D.",           /* Other "D." files (remember the "."!) */
        !            29:        "C.",           /* "C." subdirectory */
        !            30:        "X.",           /* "X." subdirectory */
        !            31:        "TM.",          /* Temporaries for inbound files */
        !            32:        0
        !            33: };
        !            34: 
        !            35: /*
        !            36:  * filename mapping kludges to put uucp work files in other directories.
        !            37:  */
        !            38: 
        !            39: #define        BUFLEN  50
        !            40: /* assert(strlen(Spool)+1+14+1+14 <= BUFLEN) */
        !            41: 
        !            42: static char fn1[BUFLEN], fn2[BUFLEN];  /* remapped filename areas */
        !            43: static int     inspool;                /* true iff working dir is Spool */
        !            44: 
        !            45: /*
        !            46:  * return (possibly) remapped string s
        !            47:  */
        !            48: char *
        !            49: SubFile(as)
        !            50: char *as;
        !            51: {
        !            52:        register char *s, **p;
        !            53:        register int n;
        !            54:        static char *tptr = NULL;
        !            55: 
        !            56:        /* Alternate buffers so "link(subfile(a), subfile(b))" works */
        !            57:        if (tptr != fn1)
        !            58:                tptr = fn1;
        !            59:        else
        !            60:                tptr = fn2;
        !            61: 
        !            62:        s = as;
        !            63:        tptr[0] = '\0';
        !            64: 
        !            65:        /* if s begins with Spool/, copy that to tptr and advance s */
        !            66:        if (strncmp(s, Spool, n = strlen(Spool)) == 0 && s[n] == '/') {
        !            67:                if (!inspool) {
        !            68:                        strcpy(tptr, Spool);
        !            69:                        strcat(tptr, "/");
        !            70:                }
        !            71:                s += n + 1;
        !            72:        }
        !            73:        else
        !            74:                if (!inspool)
        !            75:                        return(as);
        !            76: 
        !            77:        /* look for first prefix which matches, and make subdirectory */
        !            78:        for (p = &prefix[0]; *p; p++) {
        !            79:                if (strncmp(s, *p, n = strlen(*p))==0 && s[n] && s[n] != '/') {
        !            80:                        strcat(tptr, *p);
        !            81:                        strcat(tptr, "/");
        !            82:                        strcat(tptr, s);
        !            83:                        return(tptr);
        !            84:                }
        !            85:        }
        !            86:        return(as);
        !            87: }
        !            88: 
        !            89: /*
        !            90:  * save away filename
        !            91:  */
        !            92: SubChDir(s)
        !            93: register char *s;
        !            94: {
        !            95:        inspool = (strcmp(s, Spool) == 0);
        !            96:        return(chdir(s));
        !            97: }
        !            98: 
        !            99: /*
        !           100:  * return possibly corrected directory for searching
        !           101:  */
        !           102: char *
        !           103: SubDir(d, pre)
        !           104: register char *d, pre;
        !           105: {
        !           106:        if (strcmp(d, Spool) == 0)
        !           107:                if (pre == CMDPRE)
        !           108:                        return("/usr/spool/uucp/C.");
        !           109:                else if (pre == XQTPRE)
        !           110:                        return("/usr/spool/uucp/X.");
        !           111:        return(d);
        !           112: }
        !           113: #else
        !           114: static int subdir_here;                /* quiet 'ranlib' command */
        !           115: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.