Return to date.c CVS log

Up to [Research Unix] / researchv9 / cmd

Annotation of researchv9/cmd/date.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)date.c      4.1 (Berkeley) 10/1/80";
        !             2: #include <stdio.h>
        !             3: /*
        !             4:  * date : print date
        !             5:  * date YYMMDDHHMM[.SS] : set date, if allowed
        !             6:  * date -u ... : date in GMT
        !             7:  */
        !             8: #include <time.h>
        !             9: #include <sys/types.h>
        !            10: #include <sys/timeb.h>
        !            11: #include <utmp.h>
        !            12: long   timbuf;
        !            13: char   *ap, *ep, *sp;
        !            14: int    uflag;
        !            15: int    nflag;
        !            16: 
        !            17: char   *timezone();
        !            18: static int     dmsize[12] =
        !            19: {
        !            20:        31,
        !            21:        28,
        !            22:        31,
        !            23:        30,
        !            24:        31,
        !            25:        30,
        !            26:        31,
        !            27:        31,
        !            28:        30,
        !            29:        31,
        !            30:        30,
        !            31:        31
        !            32: };
        !            33: 
        !            34: struct utmp wtmp[2] = { {"|", "", 0}, {"{", "", 0}};
        !            35: 
        !            36: char   *ctime();
        !            37: char   *asctime();
        !            38: struct tm *localtime();
        !            39: struct tm *gmtime();
        !            40: 
        !            41: usage()
        !            42: {
        !            43:        printf("Usage: date [-u] [-n] YYMMDDHHMM[.SS]\n");
        !            44: }
        !            45: 
        !            46: main(argc, argv)
        !            47: char *argv[];
        !            48: {
        !            49:        register char *tzn;
        !            50:        struct timeb info;
        !            51:        int wf, rc;
        !            52:        extern char _sobuf[];
        !            53:        extern long atol();
        !            54: 
        !            55:        setbuf(stdout, _sobuf);
        !            56:        rc = 0;
        !            57:        ftime(&info);
        !            58:        while((argc>1) && (argv[1][0]=='-'))
        !            59:                switch(argv[1][1])
        !            60:                {
        !            61:                case 'u':       uflag++; argc--; argv++; break;
        !            62:                case 'n':       nflag++; argc--; argv++; break;
        !            63:                default:        usage(); exit(1);
        !            64:                }
        !            65:        if(argc > 1) {
        !            66:                ap = argv[1];
        !            67:                if(nflag)
        !            68:                        timbuf = atol(ap);
        !            69:                else {
        !            70:                        if (gtime()) {
        !            71:                                printf("date: bad conversion\n");
        !            72:                                exit(1);
        !            73:                        }
        !            74:                }
        !            75:                /* convert to GMT assuming local time */
        !            76:                if (uflag==0) {
        !            77:                        timbuf += (long)info.timezone*60;
        !            78:                        /* now fix up local daylight time */
        !            79:                        if(localtime(&timbuf)->tm_isdst)
        !            80:                                timbuf -= 60*60;
        !            81:                }
        !            82:                time(&wtmp[0].ut_time);
        !            83:                if(stime(&timbuf) < 0) {
        !            84:                        rc++;
        !            85:                        printf("date: no permission\n");
        !            86:                } else if ((wf = open("/usr/adm/wtmp", 1)) >= 0) {
        !            87:                        time(&wtmp[1].ut_time);
        !            88:                        lseek(wf, 0L, 2);
        !            89:                        write(wf, (char *)wtmp, sizeof(wtmp));
        !            90:                        close(wf);
        !            91:                }
        !            92:        }
        !            93:        if (rc==0)
        !            94:                time(&timbuf);
        !            95:        if(uflag) {
        !            96:                ap = asctime(gmtime(&timbuf));
        !            97:                tzn = "GMT";
        !            98:        } else {
        !            99:                struct tm *tp;
        !           100:                tp = localtime(&timbuf);
        !           101:                ap = asctime(tp);
        !           102:                tzn = timezone(info.timezone, tp->tm_isdst);
        !           103:        }
        !           104:        if(nflag) {
        !           105:                /* fix up daylight saving and timezone */
        !           106:                if(uflag == 0) {
        !           107:                        timbuf -= (long)info.timezone*60;
        !           108:                        if(localtime(&timbuf)->tm_isdst)
        !           109:                                timbuf += 60*60;
        !           110:                }
        !           111:                printf("%ld\n", timbuf);
        !           112:        } else {
        !           113:                printf("%.20s", ap);
        !           114:                if (tzn)
        !           115:                        printf("%s", tzn);
        !           116:                printf("%s", ap+19);
        !           117:        }
        !           118:        exit(rc);
        !           119: }
        !           120: 
        !           121: gtime()
        !           122: {
        !           123:        register int i, year, month;
        !           124:        int day, hour, mins, secs;
        !           125:        struct tm *L;
        !           126:        char x;
        !           127: 
        !           128:        ep=ap;
        !           129:        while(*ep) ep++;
        !           130:        sp=ap;
        !           131:        while(sp<ep) {
        !           132:                x = *sp;
        !           133:                *sp++ = *--ep;
        !           134:                *ep = x;
        !           135:        }
        !           136:        sp=ap;
        !           137:        time(&timbuf);
        !           138:        L=localtime(&timbuf);
        !           139:        secs = gp(-1);
        !           140:        if(*sp!='.') {
        !           141:                mins=secs;
        !           142:                secs=0;
        !           143:        } else {sp++;
        !           144:                mins = gp(-1);
        !           145:        }
        !           146:        hour = gp(-1);
        !           147:        day = gp(L->tm_mday);
        !           148:        month = gp(L->tm_mon+1);
        !           149:        year = gp(L->tm_year);
        !           150:        if(*sp)
        !           151:                return(1);
        !           152:        if( month<1 || month>12 ||
        !           153:            day<1 || day>31 ||
        !           154:            mins<0 || mins>59 ||
        !           155:            secs<0 || secs>59)
        !           156:                return(1);
        !           157:        if (hour==24) {
        !           158:                hour=0; day++;
        !           159:        }
        !           160:        if (hour<0 || hour>23)
        !           161:                return(1);
        !           162:        timbuf = 0;
        !           163:        year += 1900;
        !           164:        for(i=1970; i<year; i++)
        !           165:                timbuf += dysize(i);
        !           166:        /* Leap year */
        !           167:        if (dysize(year)==366 && month >= 3)
        !           168:                timbuf++;
        !           169:        while(--month)
        !           170:                timbuf += dmsize[month-1];
        !           171:        timbuf += day-1;
        !           172:        timbuf = 24*timbuf + hour;
        !           173:        timbuf = 60*timbuf + mins;
        !           174:        timbuf = 60*timbuf + secs;
        !           175:        return(0);
        !           176: 
        !           177: }
        !           178: 
        !           179: gp(dfault)
        !           180: {
        !           181:        register int c, d;
        !           182: 
        !           183:        if(*sp==0)
        !           184:                return(dfault);
        !           185:        c = (*sp++)-'0';
        !           186:        d = (*sp ? (*sp++)-'0' : 0);
        !           187:        if(c<0 || c>9 || d<0 || d>9)
        !           188:                return(-1);
        !           189:        return(c+10*d);
        !           190: }

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