Return to systat.c CVS log

Up to [Research Unix] / researchv10no / cmd / uucp

Annotation of researchv10no/cmd/uucp/systat.c, revision 1.1

1.1     ! root        1: /*     /sccs/src/cmd/uucp/s.systat.c
        !             2:        systat.c        1.3     8/30/84 17:37:44
        !             3: */
        !             4: #include "uucp.h"
        !             5: VERSION(@(#)systat.c   1.3);
        !             6: 
        !             7: #define STATNAME(f, n) ((void)sprintf(f, "%s/%s", STATDIR, n))
        !             8: #define S_SIZE 100
        !             9: 
        !            10: /*
        !            11:  * make system status entry
        !            12:  *     name -> system name
        !            13:  *     text -> text string to read
        !            14:  *     type -> ?
        !            15:  * return:
        !            16:  *     none
        !            17:  */
        !            18: void
        !            19: systat(name, type, text, retry)
        !            20: register int type;
        !            21: char *name, *text;
        !            22: long retry;
        !            23: {
        !            24:        register FILE *fp;
        !            25:        int count;
        !            26:        char filename[MAXFULLNAME], line[S_SIZE];
        !            27:        time_t prestime;
        !            28:        long presretry = 0;
        !            29:        char *vec[5];
        !            30: 
        !            31:        line[0] = '\0';
        !            32:        (void) time(&prestime);
        !            33:        count = 0;
        !            34:        STATNAME(filename, name);
        !            35: 
        !            36:        fp = fopen(filename, "r");
        !            37:        if (fp != NULL) {
        !            38:                if (fgets(line, S_SIZE, fp) != NULL)
        !            39:                        if (getargs(line, vec, 4) == 4) {
        !            40:                            count = atoi(vec[1]);
        !            41:                            presretry = atol(vec[3]);
        !            42:                        }
        !            43:                if (count <= 0)
        !            44:                        count = 0;
        !            45:                fclose(fp);
        !            46:        }
        !            47: 
        !            48:        switch (type) {
        !            49:                /* if there is already a status file - don't change */
        !            50:        case SS_TIME_WRONG:
        !            51:        case SS_LOCKED_DEVICE:
        !            52:        case SS_CANT_ACCESS_DEVICE:
        !            53:                if (count > 1)
        !            54:                    return;
        !            55:                break;
        !            56: 
        !            57:        case SS_ASSERT_ERROR:
        !            58:                retry = 55*60;          /* wait an hour after assertion fails */
        !            59:                break;
        !            60: 
        !            61:        case SS_OK:                     /* delete record of OK transfers */
        !            62:                unlink(filename);
        !            63:                return;
        !            64: 
        !            65:        case SS_INPROGRESS:             /* preserve current record */
        !            66:                retry = presretry;
        !            67:                break;
        !            68: 
        !            69:                /* Startup failure means protocol mismatch--some administrative
        !            70:                 * action must be taken
        !            71:                 */
        !            72:        case SS_STARTUP:
        !            73:                retry = MAXRETRYTIME;
        !            74:                count = 0;
        !            75:                break;
        !            76: 
        !            77:        default:        /*  increment count and set up retry time */
        !            78:                count++;
        !            79:                if (!retry) {   /* use exponential backoff */
        !            80:                    if (presretry < RETRYTIME)
        !            81:                        retry = RETRYTIME;
        !            82:                    else {
        !            83:                        retry = presretry + presretry;
        !            84:                        if (retry > MAXRETRYTIME)
        !            85:                            retry = MAXRETRYTIME;
        !            86:                    }
        !            87:                }
        !            88:                else {  /* use specified time */
        !            89:                    if (retry < RETRYTIME)
        !            90:                        retry = RETRYTIME;
        !            91:                }
        !            92:                break;
        !            93:        }
        !            94: 
        !            95:        fp = fopen(filename, "w");
        !            96:        /* can't ASSERT since assert() calls systat() */
        !            97:        if (fp == NULL) {
        !            98:            errent(Ct_OPEN, filename, errno, sccsid, __FILE__, __LINE__);
        !            99:            cleanup(FAIL);
        !           100:        }
        !           101:        (void) chmod(filename, 0666);
        !           102:        (void) fprintf(fp, "%d %d %ld %ld %s %s\n",
        !           103:                type, count, prestime, retry, text, name);
        !           104:        (void) fclose(fp);
        !           105:        return;
        !           106: }
        !           107: 
        !           108: /*
        !           109:  * check system status for call
        !           110:  *     name -> system to check 
        !           111:  * return:  
        !           112:  *     0       -> ok
        !           113:  *     >0      -> system status
        !           114:  */
        !           115: callok(name)
        !           116: char *name;
        !           117: {
        !           118:        register FILE *fp;
        !           119:        register int t;
        !           120:        long retrytime;
        !           121:        int count, type;
        !           122:        char filename[MAXFULLNAME], line[S_SIZE];
        !           123:        time_t lasttime, prestime;
        !           124: 
        !           125:        STATNAME(filename, name);
        !           126:        fp = fopen(filename, "r");
        !           127:        if (fp == NULL)
        !           128:                return(SS_OK);
        !           129: 
        !           130:        if (fgets(line, S_SIZE, fp) == NULL) {
        !           131: 
        !           132:                /* no data */
        !           133:                fclose(fp);
        !           134:                (void) unlink(filename);
        !           135:                return(SS_OK);
        !           136:        }
        !           137: 
        !           138:        fclose(fp);
        !           139:        (void) time(&prestime);
        !           140:        sscanf(line, "%d%d%ld%ld", &type, &count, &lasttime, &retrytime);
        !           141:        t = type;
        !           142: 
        !           143:        switch(t) {
        !           144:        case SS_SEQBAD:
        !           145:        case SS_LOGIN_FAILED:
        !           146:        case SS_DIAL_FAILED:
        !           147:        case SS_BAD_LOG_MCH:
        !           148:        case SS_BADSYSTEM:
        !           149:        case SS_CANT_ACCESS_DEVICE:
        !           150:        case SS_WRONG_MCH:
        !           151:        case SS_RLOCKED:
        !           152:        case SS_RUNKNOWN:
        !           153:        case SS_RLOGIN:
        !           154:        case SS_UNKNOWN_RESPONSE:
        !           155:        case SS_CHAT_FAILED:
        !           156:        case SS_ASSERT_ERROR:
        !           157:        case SS_CONVERSATION:
        !           158:                if (prestime - lasttime < retrytime) {
        !           159:                        logent("RETRY TIME NOT REACHED", "NO CALL");
        !           160:                        DEBUG(4, "RETRY TIME (%ld) NOT REACHED\n", retrytime);
        !           161:                        return(type);
        !           162:                }
        !           163: 
        !           164:                return(SS_OK);
        !           165:        default:
        !           166:                return(SS_OK);
        !           167:        }
        !           168: }

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