Return to systat.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / uucp

Annotation of 40BSD/cmd/uucp/systat.c, revision 1.1

1.1     ! root        1: #include "uucp.h"
        !             2: #include <sys/types.h>
        !             3: 
        !             4: #define STATNAME(f, n) sprintf(f, "%s/%s.%.7s", Spool, "STST", n)
        !             5: #define S_SIZE 100
        !             6: 
        !             7: /*******
        !             8:  *     systat(name, type, text)        make system status entry
        !             9:  *     char *name, *text;
        !            10:  *     int type.
        !            11:  *
        !            12:  *     return codes:  none
        !            13:  */
        !            14: 
        !            15: systat(name, type, text)
        !            16: char *name, *text;
        !            17: int type;
        !            18: {
        !            19:        char filename[MAXFULLNAME], line[S_SIZE];
        !            20:        int count;
        !            21:        FILE *fp;
        !            22:        time_t prestime;
        !            23: 
        !            24:        if (type == 0)
        !            25:                return;
        !            26:        line[0] = '\0';
        !            27:        time(&prestime);
        !            28:        count = 0;
        !            29:        STATNAME(filename, name);
        !            30: 
        !            31:        fp = fopen(filename, "r");
        !            32:        if (fp != NULL) {
        !            33:                fgets(line, S_SIZE, fp);
        !            34:                sscanf(&line[2], "%d", &count);
        !            35:                if (count <= 0)
        !            36:                        count = 0;
        !            37:                fclose(fp);
        !            38:        }
        !            39: 
        !            40:        if (type == SS_FAIL)
        !            41:                count++;
        !            42: 
        !            43:        fp = fopen(filename, "w");
        !            44:        ASSERT(fp != NULL, "SYSTAT OPEN FAIL %s", "");
        !            45:        chmod(filename, 0666);
        !            46:        fprintf(fp, "%d %d %D %s %s\n", type, count, prestime, text, name);
        !            47:        fclose(fp);
        !            48:        return;
        !            49: }
        !            50: 
        !            51: /***
        !            52:  *     rmstat(name)    remove system status entry
        !            53:  *     char *name;
        !            54:  *
        !            55:  *     return codes:  none
        !            56:  */
        !            57: 
        !            58: rmstat(name)
        !            59: char *name;
        !            60: {
        !            61:        char filename[MAXFULLNAME];
        !            62: 
        !            63:        STATNAME(filename, name);
        !            64:        unlink(filename);
        !            65: }
        !            66: 
        !            67: /***
        !            68:  *     callok(name)    check system status for call
        !            69:  *     char *name;
        !            70:  *
        !            71:  *     return codes  0 - ok | >0 system status
        !            72:  */
        !            73: 
        !            74: callok(name)
        !            75: char *name;
        !            76: {
        !            77:        char filename[MAXFULLNAME], line[S_SIZE];
        !            78:        FILE *fp;
        !            79:        time_t lasttime, prestime;
        !            80:        int count, type;
        !            81: 
        !            82:        STATNAME(filename, name);
        !            83:        fp = fopen(filename, "r");
        !            84:        if (fp == NULL)
        !            85:                return(SS_OK);
        !            86: 
        !            87:        if (fgets(line, S_SIZE, fp) == NULL) {
        !            88:                /*  no data  */
        !            89:                fclose(fp);
        !            90:                unlink(filename);
        !            91:                return(SS_OK);
        !            92:        }
        !            93: 
        !            94:        fclose(fp);
        !            95:        time(&prestime);
        !            96:        sscanf(line, "%d%d%D", &type, &count, &lasttime);
        !            97: 
        !            98:        switch(type) {
        !            99:        case SS_BADSEQ:
        !           100:        case SS_CALLBACK:
        !           101:                return(SS_OK);
        !           102:        case SS_NODEVICE:
        !           103:                return(SS_OK);
        !           104: 
        !           105:        case SS_INPROGRESS:
        !           106:                if (prestime - lasttime < INPROGTIME) {
        !           107:                        DEBUG(4, "CALL IN PROGRESS %s\n", "");
        !           108:                        return(type);
        !           109:                }
        !           110:                else
        !           111:                        return(SS_OK);
        !           112: 
        !           113: 
        !           114:        case SS_FAIL:
        !           115:                if (count > MAXRECALLS) {
        !           116:                        logent("MAX RECALLS", "NO CALL");
        !           117:                        DEBUG(4, "MAX RECALL COUNT %d\n", count);
        !           118:                        return(type);
        !           119:                }
        !           120: 
        !           121:                if (prestime - lasttime < RETRYTIME) {
        !           122:                        logent("RETRY TIME NOT REACHED", "NO CALL");
        !           123:                        DEBUG(4, "RETRY TIME (%d) NOT REACHED\n", RETRYTIME);
        !           124:                        return(type);
        !           125:                }
        !           126: 
        !           127:                return(SS_OK);
        !           128:        default:
        !           129:                return(SS_OK);
        !           130:        }
        !           131: }

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