Return to systat.c CVS log

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

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

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

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