Return to systat.c CVS log

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

Annotation of 43BSD/usr.bin/uucp/systat.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)systat.c   5.4 (Berkeley) 6/23/85";
        !             3: #endif
        !             4: 
        !             5: #include "uucp.h"
        !             6: 
        !             7: #define STATNAME(f, n) sprintf(f, "%s/%s/%s", Spool, "STST", n)
        !             8: #define S_SIZE 100
        !             9: 
        !            10: /*LINTLIBRARY*/
        !            11: 
        !            12: /*
        !            13:  *     make system status entry
        !            14:  *     return codes:  none
        !            15:  */
        !            16: systat(name, type, text)
        !            17: char *name, *text;
        !            18: int type;
        !            19: {
        !            20:        char filename[MAXFULLNAME], line[S_SIZE];
        !            21:        int count, oldtype;
        !            22:        register FILE *fp;
        !            23:        time_t prestime, rtry;
        !            24: 
        !            25:        if (type == 0)
        !            26:                return;
        !            27:        line[0] = '\0';
        !            28:        time(&prestime);
        !            29:        count = 0;
        !            30:        STATNAME(filename, name);
        !            31: 
        !            32:        fp = fopen(filename, "r");
        !            33:        if (fp != NULL) {
        !            34:                fgets(line, S_SIZE, fp);
        !            35:                sscanf(line, "%d %d", &oldtype, &count);
        !            36:                if (count <= 0)
        !            37:                        count = 0;
        !            38:                fclose(fp);
        !            39:                /* If merely 'wrong time', don't change existing STST */
        !            40:                if (type == SS_WRONGTIME && oldtype != SS_INPROGRESS)
        !            41:                        return;
        !            42:        }
        !            43: 
        !            44:        rtry = Retrytime;
        !            45:        /* if failures repeat, don't try so often,
        !            46:         * to forstall a 'MAX RECALLS' situation.
        !            47:         */
        !            48:        if (type == SS_FAIL) {
        !            49:                count++;
        !            50:                if (count > 5) {
        !            51:                        rtry = rtry * (count-5);
        !            52:                        if (rtry > ONEDAY/2)
        !            53:                                rtry = ONEDAY/2;
        !            54:                }
        !            55:        }
        !            56: 
        !            57: 
        !            58: #ifdef VMS
        !            59:        unlink(filename);
        !            60: #endif VMS
        !            61:        fp = fopen(filename, "w");
        !            62:        ASSERT(fp != NULL, "SYSTAT OPEN FAIL", filename, 0);
        !            63:        fprintf(fp, "%d %d %ld %ld %s %s\n", type, count, prestime, rtry, text, name);
        !            64:        fclose(fp);
        !            65:        return;
        !            66: }
        !            67: 
        !            68: /***
        !            69:  *     rmstat(name)    remove system status entry
        !            70:  *     char *name;
        !            71:  *
        !            72:  *     return codes:  none
        !            73:  */
        !            74: 
        !            75: rmstat(name)
        !            76: char *name;
        !            77: {
        !            78:        char filename[MAXFULLNAME];
        !            79: 
        !            80:        STATNAME(filename, name);
        !            81:        unlink(filename);
        !            82: }
        !            83: 
        !            84: /*
        !            85:  *     check system status for call
        !            86:  *
        !            87:  *     return codes  0 - ok | >0 system status
        !            88:  */
        !            89: 
        !            90: callok(name)
        !            91: char *name;
        !            92: {
        !            93:        char filename[MAXFULLNAME], line[S_SIZE];
        !            94:        register FILE *fp;
        !            95:        time_t lasttime, prestime, retrytime;
        !            96:        long t1, t2;
        !            97:        int count, type;
        !            98: 
        !            99:        STATNAME(filename, name);
        !           100:        fp = fopen(filename, "r");
        !           101:        if (fp == NULL)
        !           102:                return(SS_OK);
        !           103: 
        !           104:        if (fgets(line, S_SIZE, fp) == NULL) {
        !           105:                /*  no data  */
        !           106:                fclose(fp);
        !           107:                unlink(filename);
        !           108:                return(SS_OK);
        !           109:        }
        !           110: 
        !           111:        fclose(fp);
        !           112:        time(&prestime);
        !           113:        sscanf(line, "%d%d%ld%ld", &type, &count, &t1, &t2);
        !           114:        lasttime = t1;
        !           115:        retrytime = t2;
        !           116: 
        !           117:        switch(type) {
        !           118:        case SS_BADSEQ:
        !           119:        case SS_CALLBACK:
        !           120:        case SS_NODEVICE:
        !           121:        case SS_INPROGRESS:     /*let LCK take care of it */
        !           122:                return(SS_OK);
        !           123: 
        !           124:        case SS_FAIL:
        !           125:                if (count > MAXRECALLS) {
        !           126:                        logent("MAX RECALLS", "NO CALL");
        !           127:                        DEBUG(4, "MAX RECALL COUNT %d\n", count);
        !           128:                        if (Debug) {
        !           129:                                logent("debugging", "continuing anyway");
        !           130:                                return SS_OK;
        !           131:                        }
        !           132:                        return type;
        !           133:                }
        !           134: 
        !           135:                if (prestime - lasttime < retrytime) {
        !           136:                        logent("RETRY TIME NOT REACHED", "NO CALL");
        !           137:                        DEBUG(4, "RETRY TIME (%ld) NOT REACHED\n", retrytime);
        !           138:                        if (Debug) {
        !           139:                                logent("debugging", "continuing anyway");
        !           140:                                return SS_OK;
        !           141:                        }
        !           142:                        return type;
        !           143:                }
        !           144: 
        !           145:                return SS_OK;
        !           146:        default:
        !           147:                return SS_OK;
        !           148:        }
        !           149: }

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