Return to systat.c CVS log

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

Annotation of researchv8dc/cmd/uucp/systat.c, revision 1.1.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:                /* reset count on successful call */
                     58:        case SS_OK:
                     59:        case SS_INPROGRESS:
                     60:        case SS_CONVERSATION:   /* failure during conversation - contact ok */
                     61:                retry = 0;
                     62:                count = 0;
                     63:                break;
                     64: 
                     65:                /* Startup failure means protocol mismatch--some administrative
                     66:                 * action must be taken
                     67:                 */
                     68:        case SS_STARTUP:
                     69:                retry = MAXRETRYTIME;
                     70:                count = 0;
                     71:                break;
                     72:        default:        /*  increment count and set up retry time */
                     73:                count++;
                     74:                if (!retry) {   /* use exponential backoff */
                     75:                    if (presretry < RETRYTIME)
                     76:                        retry = RETRYTIME;
                     77:                    else {
                     78:                        retry = presretry + presretry;
                     79:                        if (retry > MAXRETRYTIME)
                     80:                            retry = MAXRETRYTIME;
                     81:                    }
                     82:                }
                     83:                else {  /* use specified time */
                     84:                    if (retry < RETRYTIME)
                     85:                        retry = RETRYTIME;
                     86:                }
                     87:                break;
                     88:        }
                     89: 
                     90:        fp = fopen(filename, "w");
                     91:        /* can't ASSERT since assert() calls systat() */
                     92:        if (fp == NULL) {
                     93:            errent(Ct_OPEN, filename, errno, sccsid, __FILE__, __LINE__);
                     94:            cleanup(FAIL);
                     95:        }
                     96:        (void) chmod(filename, 0666);
                     97:        (void) fprintf(fp, "%d %d %ld %ld %s %s\n",
                     98:                type, count, prestime, retry, text, name);
                     99:        (void) fclose(fp);
                    100:        return;
                    101: }
                    102: 
                    103: /*
                    104:  * check system status for call
                    105:  *     name -> system to check 
                    106:  * return:  
                    107:  *     0       -> ok
                    108:  *     >0      -> system status
                    109:  */
                    110: callok(name)
                    111: char *name;
                    112: {
                    113:        register FILE *fp;
                    114:        register int t;
                    115:        long retrytime;
                    116:        int count, type;
                    117:        char filename[MAXFULLNAME], line[S_SIZE];
                    118:        time_t lasttime, prestime;
                    119: 
                    120:        STATNAME(filename, name);
                    121:        fp = fopen(filename, "r");
                    122:        if (fp == NULL)
                    123:                return(SS_OK);
                    124: 
                    125:        if (fgets(line, S_SIZE, fp) == NULL) {
                    126: 
                    127:                /* no data */
                    128:                fclose(fp);
                    129:                (void) unlink(filename);
                    130:                return(SS_OK);
                    131:        }
                    132: 
                    133:        fclose(fp);
                    134:        (void) time(&prestime);
                    135:        sscanf(line, "%d%d%ld%ld", &type, &count, &lasttime, &retrytime);
                    136:        t = type;
                    137: 
                    138:        switch(t) {
                    139:        case SS_SEQBAD:
                    140:        case SS_LOGIN_FAILED:
                    141:        case SS_DIAL_FAILED:
                    142:        case SS_BAD_LOG_MCH:
                    143:        case SS_BADSYSTEM:
                    144:        case SS_CANT_ACCESS_DEVICE:
                    145:        case SS_WRONG_MCH:
                    146:        case SS_RLOCKED:
                    147:        case SS_RUNKNOWN:
                    148:        case SS_RLOGIN:
                    149:        case SS_UNKNOWN_RESPONSE:
                    150:        case SS_CHAT_FAILED:
                    151: 
                    152:                if (prestime - lasttime < retrytime) {
                    153:                        logent("RETRY TIME NOT REACHED", "NO CALL");
                    154:                        DEBUG(4, "RETRY TIME (%ld) NOT REACHED\n", retrytime);
                    155:                        return(type);
                    156:                }
                    157: 
                    158:                return(SS_OK);
                    159:        default:
                    160:                return(SS_OK);
                    161:        }
                    162: }

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