Return to clocktime.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp

Annotation of embedaddon/ntp/libntp/clocktime.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * clocktime - compute the NTP date from a day of year, hour, minute
        !             3:  *            and second.
        !             4:  */
        !             5: #include "ntp_fp.h"
        !             6: #include "ntp_unixtime.h"
        !             7: #include "ntp_stdlib.h"
        !             8: 
        !             9: /*
        !            10:  * Hacks to avoid excercising the multiplier.  I have no pride.
        !            11:  */
        !            12: #define        MULBY10(x)      (((x)<<3) + ((x)<<1))
        !            13: #define        MULBY60(x)      (((x)<<6) - ((x)<<2))   /* watch overflow */
        !            14: #define        MULBY24(x)      (((x)<<4) + ((x)<<3))
        !            15: 
        !            16: /*
        !            17:  * Two days, in seconds.
        !            18:  */
        !            19: #define        TWODAYS         (2*24*60*60)
        !            20: 
        !            21: /*
        !            22:  * We demand that the time be within CLOSETIME seconds of the receive
        !            23:  * time stamp.  This is about 4 hours, which hopefully should be
        !            24:  * wide enough to collect most data, while close enough to keep things
        !            25:  * from getting confused.
        !            26:  */
        !            27: #define        CLOSETIME       (4*60*60)
        !            28: 
        !            29: 
        !            30: int
        !            31: clocktime(
        !            32:        int yday,
        !            33:        int hour,
        !            34:        int minute,
        !            35:        int second,
        !            36:        int tzoff,
        !            37:        u_long rec_ui,
        !            38:        u_long *yearstart,
        !            39:        u_int32 *ts_ui
        !            40:        )
        !            41: {
        !            42:        register long tmp;
        !            43:        register u_long date;
        !            44:        register u_long yst;
        !            45: 
        !            46:        /*
        !            47:         * Compute the offset into the year in seconds.  Note that
        !            48:         * this could come out to be a negative number.
        !            49:         */
        !            50:        tmp = (long)(MULBY24((yday-1)) + hour + tzoff);
        !            51:        tmp = MULBY60(tmp) + (long)minute;
        !            52:        tmp = MULBY60(tmp) + (long)second;
        !            53: 
        !            54:        /*
        !            55:         * Initialize yearstart, if necessary.
        !            56:         */
        !            57:        yst = *yearstart;
        !            58:        if (yst == 0) {
        !            59:                yst = calyearstart(rec_ui);
        !            60:                *yearstart = yst;
        !            61:        }
        !            62: 
        !            63:        /*
        !            64:         * Now the fun begins.  We demand that the received clock time
        !            65:         * be within CLOSETIME of the receive timestamp, but
        !            66:         * there is uncertainty about the year the timestamp is in.
        !            67:         * Use the current year start for the first check, this should
        !            68:         * work most of the time.
        !            69:         */
        !            70:        date = (u_long)(tmp + (long)yst);
        !            71:        if (date < (rec_ui + CLOSETIME) &&
        !            72:            date > (rec_ui - CLOSETIME)) {
        !            73:                *ts_ui = date;
        !            74:                return 1;
        !            75:        }
        !            76: 
        !            77:        /*
        !            78:         * Trouble.  Next check is to see if the year rolled over and, if
        !            79:         * so, try again with the new year's start.
        !            80:         */
        !            81:        yst = calyearstart(rec_ui);
        !            82:        if (yst != *yearstart) {
        !            83:                date = (u_long)((long)yst + tmp);
        !            84:                *ts_ui = date;
        !            85:                if (date < (rec_ui + CLOSETIME) &&
        !            86:                    date > (rec_ui - CLOSETIME)) {
        !            87:                        *yearstart = yst;
        !            88:                        return 1;
        !            89:                }
        !            90:        }
        !            91: 
        !            92:        /*
        !            93:         * Here we know the year start matches the current system
        !            94:         * time.  One remaining possibility is that the time code
        !            95:         * is in the year previous to that of the system time.  This
        !            96:         * is only worth checking if the receive timestamp is less
        !            97:         * than a couple of days into the new year.
        !            98:         */
        !            99:        if ((rec_ui - yst) < TWODAYS) {
        !           100:                yst = calyearstart(yst - TWODAYS);
        !           101:                if (yst != *yearstart) {
        !           102:                        date = (u_long)(tmp + (long)yst);
        !           103:                        if (date < (rec_ui + CLOSETIME) &&
        !           104:                            date > (rec_ui - CLOSETIME)) {
        !           105:                                *yearstart = yst;
        !           106:                                *ts_ui = date;
        !           107:                                return 1;
        !           108:                        }
        !           109:                }
        !           110:        }
        !           111: 
        !           112:        /*
        !           113:         * One last possibility is that the time stamp is in the year
        !           114:         * following the year the system is in.  Try this one before
        !           115:         * giving up.
        !           116:         */
        !           117:        yst = calyearstart(rec_ui + TWODAYS);
        !           118:        if (yst != *yearstart) {
        !           119:                date = (u_long)((long)yst + tmp);
        !           120:                if (date < (rec_ui + CLOSETIME) &&
        !           121:                    date > (rec_ui - CLOSETIME)) {
        !           122:                        *yearstart = yst;
        !           123:                        *ts_ui = date;
        !           124:                        return 1;
        !           125:                }
        !           126:        }
        !           127: 
        !           128:        /*
        !           129:         * Give it up.
        !           130:         */
        !           131:        return 0;
        !           132: }