Return to time.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / nntp / server

Annotation of 43BSD/contrib/nntp/server/time.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char    *sccsid = "@(#)time.c   1.4     (Berkeley) 3/20/86";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Collection of routines for dealing with ASCII time strings.
        !             7:  * These may actually be useful in their own right.
        !             8:  */
        !             9: 
        !            10: #include <stdio.h>
        !            11: #include <sys/types.h>
        !            12: #include <sys/time.h>
        !            13: #include <ctype.h>
        !            14: #include <strings.h>
        !            15: 
        !            16: /*
        !            17:  * dtol -- convert date to long integer.  This is not implicitly
        !            18:  * local time, or any other kind of time, for that matter.  If you
        !            19:  * pass it a date you think is GMT, you wind up with that number of
        !            20:  * seconds...
        !            21:  *
        !            22:  *     Parameters:             "date_ascii" is in the form "yymmddhhmmss".
        !            23:  *
        !            24:  *     Returns:                Long integer containing number
        !            25:  *                             of seconds since 000000 Jan 1, 1970,
        !            26:  *                             and "date".  -1 on error.
        !            27:  *
        !            28:  *     Side effects:           None.
        !            29:  */
        !            30: 
        !            31: #define twodigtoi(x)   (((*x++) - '0') + (*x++ - '0')*10)
        !            32: #define        dysize(y)       ((y % 4 ? 365 : 366))
        !            33: 
        !            34: static int     dmsize[12] =
        !            35:     { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        !            36: 
        !            37: long
        !            38: dtol(date_ascii)
        !            39: char   *date_ascii;
        !            40: {
        !            41:        char    date[32], *date_str;
        !            42:        char    *lhs, *rhs;
        !            43:        char    temp;
        !            44:        long    seconds;
        !            45:        int     year, month, day, hour, mins, secs;
        !            46:        int     len, i;
        !            47: 
        !            48:        len = strlen(date_ascii);
        !            49:        if (len != sizeof("yymmddhhmmss")-1)
        !            50:                return (-1);
        !            51: 
        !            52:        (void) strcpy(date, date_ascii);
        !            53:        date_str = date;
        !            54: 
        !            55: #ifdef debug
        !            56:        printf("date_str = %s\n", date_str);
        !            57: #endif
        !            58:        rhs = date_str + len - 1;
        !            59:        lhs = date_str;
        !            60: 
        !            61:        for (; lhs < rhs; ++lhs, --rhs) {
        !            62:                temp = *lhs;
        !            63:                *lhs = *rhs;
        !            64:                *rhs = temp;
        !            65:                if (!isdigit(temp) || !isdigit(*lhs))
        !            66:                        return (-1);
        !            67:        }
        !            68: 
        !            69:        lhs = date_str;
        !            70: #ifdef debug
        !            71:        printf("date_str = %s\n", date_str);
        !            72: #endif
        !            73: 
        !            74:        secs = twodigtoi(lhs);
        !            75:        mins = twodigtoi(lhs);
        !            76:        hour = twodigtoi(lhs);
        !            77:        day = twodigtoi(lhs);
        !            78:        month = twodigtoi(lhs);
        !            79:        year = twodigtoi(lhs);
        !            80: 
        !            81:        if (month < 1 || month > 12 ||
        !            82:            day < 1 || day > 31 ||
        !            83:            mins < 0 || mins > 59 ||
        !            84:            secs < 0 || secs > 59)
        !            85:                return (-1);
        !            86:        if (hour == 24) {
        !            87:                hour = 0;
        !            88:                day++;
        !            89:        }
        !            90:        if (hour < 0 || hour > 23)
        !            91:                return (-1);
        !            92:        seconds = 0;
        !            93:        year += 1900;
        !            94:        for (i = 1970; i < year; i++)
        !            95:                seconds += dysize(i);
        !            96:        /* Leap year */
        !            97:        if (dysize(year) == 366 && month >= 3)
        !            98:                seconds++;
        !            99:        while (--month)
        !           100:                seconds += dmsize[month-1];
        !           101:        seconds += day-1;
        !           102:        seconds = 24 * seconds + hour;
        !           103:        seconds = 60 * seconds + mins;
        !           104:        seconds = 60 * seconds + secs;
        !           105: 
        !           106:        return (seconds);
        !           107: }
        !           108: 
        !           109: 
        !           110: /*
        !           111:  * ltod -- convert long integer to date string.
        !           112:  *
        !           113:  *     Parameters:             "date" is in the number of seconds
        !           114:  *                             since the epoch.
        !           115:  *
        !           116:  *     Returns:                Pointer to static data in the form
        !           117:  *                             yymmddhhmmss\0.
        !           118:  *
        !           119:  *     Side effects:           None.
        !           120:  */
        !           121: 
        !           122: char *
        !           123: ltod(date)
        !           124: long   date;
        !           125: {
        !           126:        static char     timebuf[32];
        !           127:        struct tm       *tp;
        !           128: 
        !           129:        tp = gmtime(&date);
        !           130: 
        !           131:        sprintf(timebuf, "%02d%02d%02d%02d%02d%02d",
        !           132:                tp->tm_year,
        !           133:                tp->tm_mon + 1,         /* 0 to 11??? How silly. */
        !           134:                tp->tm_mday,
        !           135:                tp->tm_hour,
        !           136:                tp->tm_min,
        !           137:                tp->tm_sec);
        !           138: 
        !           139:        return (timebuf);
        !           140: }
        !           141: 
        !           142: 
        !           143: /*
        !           144:  * local_to_gmt -- convert a local time (in form of number of
        !           145:  * seconds since you-know-when) to GMT.
        !           146:  *
        !           147:  *     Parameters:     "date" is date we want converted, in
        !           148:  *                     seconds since 000000 1 Jan 1970.
        !           149:  *
        !           150:  *     Returns:        Number of seconds corrected for local
        !           151:  *                     and dst.
        !           152:  */
        !           153: 
        !           154: long
        !           155: local_to_gmt(date)
        !           156: long   date;
        !           157: {
        !           158:        struct  timeval tv;
        !           159:        struct  timezone tz;
        !           160: 
        !           161:        (void) gettimeofday(&tv, &tz);
        !           162:        date += (long) tz.tz_minuteswest * 60;
        !           163: 
        !           164:        /* now fix up local daylight time */
        !           165:        if (localtime((time_t *)&date)->tm_isdst)
        !           166:                date -= 60*60;
        !           167: 
        !           168:        return (date);
        !           169: }
        !           170: 
        !           171: /*
        !           172:  * gmt_to_local -- take a GMT time expressed in seconds since
        !           173:  * the epoch, and convert it to local time.
        !           174:  *
        !           175:  *     Parameters:     "date" is the number of seconds...
        !           176:  *
        !           177:  *     Returns:        Number of seconds corrected to reflect
        !           178:  *                     local time and dst.
        !           179:  */
        !           180: 
        !           181: long
        !           182: gmt_to_local(date)
        !           183: long   date;
        !           184: {
        !           185:        struct  timeval tv;
        !           186:        struct  timezone tz;
        !           187: 
        !           188:        (void) gettimeofday(&tv, &tz);
        !           189:        date -= (long) tz.tz_minuteswest * 60;
        !           190: 
        !           191:        /* now fix up local daylight time */
        !           192:        if (localtime((time_t *)&date)->tm_isdst)
        !           193:                date += 60*60;
        !           194: 
        !           195:        return (date);
        !           196: }

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