Return to gename.c CVS log

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

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

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)gename.c   5.2 (Berkeley) 7/19/83";
        !             3: #endif
        !             4: 
        !             5: #include "uucp.h"
        !             6: #include <sys/types.h>
        !             7: 
        !             8: #define SEQLEN 4
        !             9: 
        !            10: /*******
        !            11:  *     gename(pre, sys, grade, file)   generate file name
        !            12:  *     char grade, *sys, pre, *file;
        !            13:  *
        !            14:  *     return codes:  none
        !            15:  */
        !            16: 
        !            17: gename(pre, sys, grade, file)
        !            18: char pre, *sys, grade, *file;
        !            19: {
        !            20:        static char sqnum[5];
        !            21: 
        !            22:        getseq(sqnum);
        !            23:        sprintf(file, "%c.%.7s%c%.*s", pre, sys, grade, SEQLEN, sqnum);
        !            24:        DEBUG(4, "file - %s\n", file);
        !            25:        return;
        !            26: }
        !            27: 
        !            28: 
        !            29: #define SLOCKTIME 10L
        !            30: #define SLOCKTRIES 5
        !            31: 
        !            32: /*******
        !            33:  *     getseq(snum)    get next sequence number
        !            34:  *     char *snum;
        !            35:  *
        !            36:  *     return codes:  none
        !            37:  */
        !            38: 
        !            39: static
        !            40: getseq(snum)
        !            41: register char *snum;
        !            42: {
        !            43:        /*
        !            44:         * the alphabet can be anything, but if it's not in ascii order,
        !            45:         * sequence ordering is not preserved
        !            46:         */
        !            47:        char    *alphabet =
        !            48:            "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        !            49:        register int i, fd;
        !            50:        static char *lastchar;
        !            51: 
        !            52:        if (lastchar == NULL || (snum[SEQLEN-1] = *(lastchar++)) == '\0') {
        !            53:                for (i = 0; i < SLOCKTRIES; i++) {
        !            54:                        if (!ulockf(SEQLOCK, (time_t)SLOCKTIME))
        !            55:                                break;
        !            56:                        sleep(5);
        !            57:                }
        !            58: 
        !            59:                ASSERT(i < SLOCKTRIES, "CAN NOT GET", "SEQLOCK", 0);
        !            60: 
        !            61:                if ((fd = open(SEQFILE, 2)) >= 0) {
        !            62:                        int alphalen;
        !            63:                        register char   *p;
        !            64:                        char *index();
        !            65: 
        !            66:                        alphalen = strlen(alphabet);
        !            67:                        read(fd, snum, SEQLEN);
        !            68:                        /* increment the penultimate character */
        !            69:                        for (i = SEQLEN - 2; i >= 0; --i) {
        !            70:                                if ((p = index(alphabet, snum[i])) == NULL) {
        !            71:                                        /* drastic but effective */
        !            72:                                        snum[i] = alphabet[alphalen - 1];
        !            73:                                        DEBUG(6, "bad seqf: %s\n", snum);
        !            74:                                }
        !            75:                                if (++p < &alphabet[alphalen]) {
        !            76:                                        snum[i] = *p;
        !            77:                                        break;
        !            78:                                } else          /* carry */
        !            79:                                        snum[i] = alphabet[0];  /* continue */
        !            80:                        }
        !            81:                        snum[SEQLEN-1] = alphabet[0];
        !            82:                } else {
        !            83:                        if ((fd = creat(SEQFILE, 0666)) < 0)
        !            84:                                return(FAIL);
        !            85:                        for (i = 0; i < SEQLEN; i++)
        !            86:                                snum[i] = alphabet[0];
        !            87:                }
        !            88: 
        !            89:                lseek(fd, 0L, 0);
        !            90:                write(fd, snum, SEQLEN);
        !            91:                close(fd);
        !            92:                rmlock(SEQLOCK);
        !            93:                lastchar = alphabet + 1;
        !            94:        }
        !            95:        return(0);
        !            96: }

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