Return to ntp_unixtime.h CVS log

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

Annotation of embedaddon/ntp/include/ntp_unixtime.h, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * ntp_unixtime.h - contains constants and macros for converting between
                      3:  *                 NTP time stamps (l_fp) and Unix times (struct timeval)
                      4:  */
                      5: 
                      6: #include "ntp_types.h"
                      7: 
                      8: #ifdef SIM
                      9: #include "ntpsim.h"
                     10: #endif
                     11: 
                     12: #ifdef SIM
                     13: #   define GETTIMEOFDAY(a, b) (node_gettime(&ntp_node, a))
                     14: #   define SETTIMEOFDAY(a, b) (node_settime(&ntp_node, a))
                     15: #   define ADJTIMEOFDAY(a, b) (node_adjtime(&ntp_node, a, b))
                     16: #else
                     17: #   define ADJTIMEOFDAY(a, b) (adjtime(a, b))
                     18: /* gettimeofday() takes two args in BSD and only one in SYSV */
                     19: # if defined(HAVE_SYS_TIMERS_H) && defined(HAVE_GETCLOCK)
                     20: #  include <sys/timers.h>
                     21: int getclock (int clock_type, struct timespec *tp);
                     22: /* Don't #define GETTIMEOFDAY because we shouldn't be using it in this case. */
                     23: #   define SETTIMEOFDAY(a, b) (settimeofday(a, b))
                     24: # else /* not (HAVE_SYS_TIMERS_H && HAVE_GETCLOCK) */
                     25: #  ifdef SYSV_TIMEOFDAY
                     26: #   define GETTIMEOFDAY(a, b) (gettimeofday(a))
                     27: #   define SETTIMEOFDAY(a, b) (settimeofday(a))
                     28: #  else /* ! SYSV_TIMEOFDAY */
                     29: #if defined SYS_CYGWIN32
                     30: #   define GETTIMEOFDAY(a, b) (gettimeofday(a, b))
                     31: #   define SETTIMEOFDAY(a, b) (settimeofday_NT(a))
                     32: #else
                     33: #   define GETTIMEOFDAY(a, b) (gettimeofday(a, b))
                     34: #   define SETTIMEOFDAY(a, b) (settimeofday(a, b))
                     35: #endif
                     36: #  endif /* SYSV_TIMEOFDAY */
                     37: # endif /* not (HAVE_SYS_TIMERS_H && HAVE_GETCLOCK) */
                     38: #endif /* SIM */
                     39: 
                     40: /*
                     41:  * Time of day conversion constant.  Ntp's time scale starts in 1900,
                     42:  * Unix in 1970.
                     43:  */
                     44: #define        JAN_1970        0x83aa7e80      /* 2208988800 1970 - 1900 in seconds */
                     45: 
                     46: /*
                     47:  * These constants are used to round the time stamps computed from
                     48:  * a struct timeval to the microsecond (more or less).  This keeps
                     49:  * things neat.
                     50:  */
                     51: #define        TS_MASK         0xfffff000      /* mask to usec, for time stamps */
                     52: #define        TS_ROUNDBIT     0x00000800      /* round at this bit */
                     53: 
                     54: 
                     55: /*
                     56:  * Convert usec to a time stamp fraction.  If you use this the program
                     57:  * must include the following declarations:
                     58:  */
                     59: extern u_long ustotslo[];
                     60: extern u_long ustotsmid[];
                     61: extern u_long ustotshi[];
                     62: 
                     63: #define        TVUTOTSF(tvu, tsf) \
                     64:        (tsf) = ustotslo[(tvu) & 0xff] \
                     65:            + ustotsmid[((tvu) >> 8) & 0xff] \
                     66:            + ustotshi[((tvu) >> 16) & 0xf]
                     67: 
                     68: /*
                     69:  * Convert a struct timeval to a time stamp.
                     70:  */
                     71: #define TVTOTS(tv, ts) \
                     72:        do { \
                     73:                (ts)->l_ui = (u_long)(tv)->tv_sec; \
                     74:                TVUTOTSF((tv)->tv_usec, (ts)->l_uf); \
                     75:        } while(0)
                     76: 
                     77: #define sTVTOTS(tv, ts) \
                     78:        do { \
                     79:                int isneg = 0; \
                     80:                long usec; \
                     81:                (ts)->l_ui = (tv)->tv_sec; \
                     82:                usec = (tv)->tv_usec; \
                     83:                if (((tv)->tv_sec < 0) || ((tv)->tv_usec < 0)) { \
                     84:                        usec = -usec; \
                     85:                        (ts)->l_ui = -(ts)->l_ui; \
                     86:                        isneg = 1; \
                     87:                } \
                     88:                TVUTOTSF(usec, (ts)->l_uf); \
                     89:                if (isneg) { \
                     90:                        L_NEG((ts)); \
                     91:                } \
                     92:        } while(0)
                     93: 
                     94: /*
                     95:  * TV_SHIFT is used to turn the table result into a usec value.  To round,
                     96:  * add in TV_ROUNDBIT before shifting
                     97:  */
                     98: #define        TV_SHIFT        3
                     99: #define        TV_ROUNDBIT     0x4
                    100: 
                    101: 
                    102: /*
                    103:  * Convert a time stamp fraction to microseconds.  The time stamp
                    104:  * fraction is assumed to be unsigned.  To use this in a program, declare:
                    105:  */
                    106: extern long tstouslo[];
                    107: extern long tstousmid[];
                    108: extern long tstoushi[];
                    109: 
                    110: #define        TSFTOTVU(tsf, tvu) \
                    111:        (tvu) = (tstoushi[((tsf) >> 24) & 0xff] \
                    112:            + tstousmid[((tsf) >> 16) & 0xff] \
                    113:            + tstouslo[((tsf) >> 9) & 0x7f] \
                    114:            + TV_ROUNDBIT) >> TV_SHIFT
                    115: /*
                    116:  * Convert a time stamp to a struct timeval.  The time stamp
                    117:  * has to be positive.
                    118:  */
                    119: #define        TSTOTV(ts, tv) \
                    120:        do { \
                    121:                (tv)->tv_sec = (ts)->l_ui; \
                    122:                TSFTOTVU((ts)->l_uf, (tv)->tv_usec); \
                    123:                if ((tv)->tv_usec == 1000000) { \
                    124:                        (tv)->tv_sec++; \
                    125:                        (tv)->tv_usec = 0; \
                    126:                } \
                    127:        } while (0)
                    128: 
                    129: /*
                    130:  * Convert milliseconds to a time stamp fraction.  This shouldn't be
                    131:  * here, but it is convenient since the guys who use the definition will
                    132:  * often be including this file anyway.
                    133:  */
                    134: extern u_long msutotsflo[];
                    135: extern u_long msutotsfhi[];
                    136: 
                    137: #define        MSUTOTSF(msu, tsf) \
                    138:        (tsf) = msutotsfhi[((msu) >> 5) & 0x1f] + msutotsflo[(msu) & 0x1f]