Return to settod.c CVS log

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

Annotation of researchv8dc/cmd/settod/settod.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <time.h>
        !             3: #include <errno.h>
        !             4: #include <sys/types.h>
        !             5: #include <sys/timeb.h>
        !             6: #include <sys/clock.h>
        !             7: #include <utmp.h>
        !             8: #include <signal.h>
        !             9: 
        !            10: #define CLOCK "mh/astro/clock"
        !            11: /* buffer to read time into and print it from */
        !            12: char buf[24]; /* HH:MM:SS.S     DD/MM/YY */
        !            13: 
        !            14: typedef unsigned long tod_t;
        !            15: 
        !            16: tod_t settod(), readnet();
        !            17: long labs();
        !            18: int sflag, vflag;
        !            19: 
        !            20: static char    dmsize[12] =
        !            21: {
        !            22:        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
        !            23: };
        !            24: 
        !            25: main (argc, argv)
        !            26:        int argc;
        !            27:        char **argv;
        !            28: {
        !            29:        tod_t ourtime, wwvtime;
        !            30:        long delta;
        !            31:        int c;
        !            32: 
        !            33:        while ((c = getopt (argc, argv, "vs")) != EOF) {
        !            34:                switch (c) {
        !            35:                case 's':
        !            36:                        sflag++;
        !            37:                        break;
        !            38:                case 'v':
        !            39:                        vflag++;
        !            40:                        break;
        !            41:                case '?':
        !            42:                        return 1;
        !            43:                }
        !            44:        }
        !            45: 
        !            46:        if (!sflag)
        !            47:                vflag++;
        !            48: 
        !            49:        wwvtime = readnet();
        !            50:        if (wwvtime) {
        !            51:                ourtime = settod(0L);
        !            52:                delta = wwvtime - ourtime;
        !            53: 
        !            54:                if (sflag) {
        !            55:                        if (settod (wwvtime) == -1)
        !            56:                                printf ("not super-user, hence not set\n");
        !            57:                }
        !            58: 
        !            59:                if (vflag) {
        !            60:                        printf("%.23s ", buf);
        !            61:                        if (delta == 0)
        !            62:                                printf ("exact\n");
        !            63:                        else
        !            64:                                printf ("%s %ld.%.2ld\n",
        !            65:                                    delta < 0? "retard": "advance",
        !            66:                                    labs (delta) / 100, labs (delta) % 100);
        !            67:                }
        !            68:        }
        !            69:        return 0;
        !            70: 
        !            71: }
        !            72: 
        !            73: tod_t
        !            74: readnet()
        !            75: {
        !            76:        int i, j, year, mon;
        !            77:        int day, hour, mins, secs, tenth;
        !            78:        int f;
        !            79:        int alcatch();
        !            80:        tod_t timbuf;
        !            81:        extern errno, sys_nerr;
        !            82:        extern char *sys_errlist[];
        !            83:        extern dkp_ld;
        !            84:        int retry = 30;         /* max number of retries */
        !            85: 
        !            86:        do {
        !            87:                int err;
        !            88:                signal(SIGALRM, alcatch);
        !            89:                alarm(15);
        !            90:                f = tdkdial(CLOCK, 2);
        !            91:                if (f < 0) {
        !            92:                        alarm(0);
        !            93:                        printf("settod: can't open clock\n");
        !            94:                        return(0);
        !            95:                }
        !            96:                if (dkproto(f, dkp_ld) < 0) {
        !            97:                        alarm(0);
        !            98:                        printf("settod: can't turn on DK proto\n");
        !            99:                        return(0);
        !           100:                }
        !           101:                do {
        !           102:                        if ((j = read(f, buf, 1)) <= 0)
        !           103:                                goto readerr;
        !           104:                } while ((buf[0]&0177) != '\r');
        !           105:                for (i=0; i<24; i += j) {
        !           106:                        if ((j = read(f, buf+i, 24-i)) <= 0)
        !           107:                                goto readerr;
        !           108:                }
        !           109:                alarm(0);
        !           110:                for (i=0; i<24; i++)
        !           111:                        buf[i] &= 0177;
        !           112:                /* accept '?' for tenths */
        !           113:                if (buf[9]=='?')
        !           114:                        buf[9] = '0';
        !           115:                if (sscanf(buf, "%d:%d:%d.%d    %d/%d/%d\r", &hour, &mins, &secs,
        !           116:                   &tenth, &mon, &day, &year) != 7)
        !           117:                        goto formerr;
        !           118:                if( mon<1 || mon>12 ||
        !           119:                    day<0 || day>31 ||  /* June 30, 1984 == July 0, 1984 !!?? */
        !           120:                    mins<0 || mins>59 ||
        !           121:                    secs<0 || secs>59 ||
        !           122:                    tenth<0 || tenth>9 ||
        !           123:                    hour<0 || hour>23)
        !           124:                        goto formerr;
        !           125:                /* leap year */
        !           126:                timbuf = 0;
        !           127:                if (year % 4 == 0 && mon >= 3)
        !           128:                        timbuf++;
        !           129:                while(--mon)
        !           130:                        timbuf += dmsize[mon-1];
        !           131:                timbuf += day-1;
        !           132:                timbuf = 24*timbuf + hour;
        !           133:                timbuf = 60*timbuf + mins;
        !           134:                timbuf = 60*timbuf + secs;
        !           135:                timbuf = 10*timbuf + tenth;
        !           136:                timbuf = timbuf * 10 + TODRZERO;
        !           137:                return timbuf;
        !           138:        formerr:
        !           139:                printf("settod: clock format error: %.24s\n", buf);
        !           140:                return(0);
        !           141:        readerr:
        !           142:                err = errno;
        !           143:                close(f);
        !           144:                alarm(0);
        !           145:                if (j < 0) {
        !           146:                        printf("settod: clock read ");
        !           147: 
        !           148:                        if (err == EINTR) {
        !           149:                                printf ("timeout\n");
        !           150:                                return 0;
        !           151:                        } else if (err < sys_nerr)
        !           152:                                printf("error: %s\n", sys_errlist[err]);
        !           153:                        else
        !           154:                                printf("error: %d\n", err);
        !           155:                }
        !           156:                sleep (1 + (int)((getpid() + time ((time_t) 0)) % 7));
        !           157:        } while (--retry >= 0);
        !           158:        return 0;
        !           159: }
        !           160: 
        !           161: alcatch() {}
        !           162: 
        !           163: long
        !           164: labs (n)
        !           165:        long n;
        !           166: {
        !           167:        if (n >= 0)
        !           168:                return n;
        !           169:        return -n;
        !           170: }

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