contrib/ntp/include/ntp_calendar.h

   1 /*
   2  * ntp_calendar.h - definitions for the calendar time-of-day routine
   3  */
   4 #ifndef NTP_CALENDAR_H
   5 #define NTP_CALENDAR_H
   6
   7 #include <time.h>
   8
   9 #include "ntp_types.h"
  10
  11 /* gregorian calendar date */
  12 struct calendar {
  13         uint16_t year;          /* year (A.D.) */
  14         uint16_t yearday;       /* day of year, 1 = January 1 */
  15         uint8_t  month;         /* month, 1 = January */
  16         uint8_t  monthday;      /* day of month */
  17         uint8_t  hour;          /* hour of day, midnight = 0 */
  18         uint8_t  minute;        /* minute of hour */
  19         uint8_t  second;        /* second of minute */
  20         uint8_t  weekday;       /* 0..7, 0=Sunday */
  21 };
  22
  23 /* ISO week calendar date */
  24 struct isodate {
  25         uint16_t year;          /* year (A.D.) */
  26         uint8_t  week;          /* 1..53, week in year */
  27         uint8_t  weekday;       /* 1..7, 1=Monday */
  28         uint8_t  hour;          /* hour of day, midnight = 0 */
  29         uint8_t  minute;        /* minute of hour */
  30         uint8_t  second;        /* second of minute */
  31 };
  32
  33 /* general split representation */
  34 typedef struct {
  35         int32_t hi;
  36         int32_t lo;
  37 } ntpcal_split;
  38
  39 typedef time_t (*systime_func_ptr)(time_t *);
  40
  41 /*
  42  * set the function for getting the system time. This is mostly used for
  43  * unit testing to provide a fixed / shifted time stamp. Setting the
  44  * value to NULL restores the original function, that is, 'time()',
  45  * which is also the automatic default.
  46  */
  47 extern systime_func_ptr ntpcal_set_timefunc(systime_func_ptr);
  48
  49 /*
  50  * days-of-week
  51  */
  52 #define CAL_SUNDAY      0
  53 #define CAL_MONDAY      1
  54 #define CAL_TUESDAY     2
  55 #define CAL_WEDNESDAY   3
  56 #define CAL_THURSDAY    4
  57 #define CAL_FRIDAY      5
  58 #define CAL_SATURDAY    6
  59 #define CAL_SUNDAY7     7       /* also sunday */
  60
  61 /*
  62  * Days in each month.  30 days hath September...
  63  */
  64 #define JAN     31
  65 #define FEB     28
  66 #define FEBLEAP 29
  67 #define MAR     31
  68 #define APR     30
  69 #define MAY     31
  70 #define JUN     30
  71 #define JUL     31
  72 #define AUG     31
  73 #define SEP     30
  74 #define OCT     31
  75 #define NOV     30
  76 #define DEC     31
  77
  78 /*
  79  * We deal in a 4 year cycle starting at March 1, 1900.  We assume
  80  * we will only want to deal with dates since then, and not to exceed
  81  * the rollover day in 2036.
  82  */
  83 #define SECSPERMIN      (60)                    /* seconds per minute */
  84 #define MINSPERHR       (60)                    /* minutes per hour */
  85 #define HRSPERDAY       (24)                    /* hours per day */
  86 #define DAYSPERWEEK     (7)                     /* days per week */
  87 #define DAYSPERYEAR     (365)                   /* days per year */
  88
  89 #define SECSPERHR       (SECSPERMIN * MINSPERHR)
  90 #define SECSPERDAY      (SECSPERHR * HRSPERDAY)
  91 #define SECSPERWEEK     (DAYSPERWEEK * SECSPERDAY)
  92 #define SECSPERYEAR     (365 * SECSPERDAY)      /* regular year */
  93 #define SECSPERLEAPYEAR (366 * SECSPERDAY)      /* leap year */
  94 #define SECSPERAVGYEAR  31556952                /* mean year length over 400yrs */
  95
  96 /*
  97  * Gross hacks.  I have illicit knowlege that there won't be overflows
  98  * here, the compiler often can't tell this.
  99  */
 100 #define TIMES60(val)    ((((val)<<4) - (val))<<2)       /* *(16 - 1) * 4 */
 101 #define TIMES24(val)    (((val)<<4) + ((val)<<3))       /* *16 + *8 */
 102 #define TIMES7(val)     (((val)<<3) - (val))            /* *8  - *1 */
 103 #define TIMESDPERC(val) (((val)<<10) + ((val)<<8) \
 104                         + ((val)<<7) + ((val)<<5) \
 105                         + ((val)<<4) + ((val)<<2) + (val))      /* *big* hack */
 106
 107
 108 extern  const char * const months[12];
 109 extern  const char * const daynames[7];
 110
 111 extern  void     caljulian      (uint32_t, struct calendar *);
 112 extern  uint32_t caltontp       (const struct calendar *);
 113
 114 /*
 115  * Convert between 'time_t' and 'vint64'
 116  */
 117 extern vint64 time_to_vint64(const time_t *);
 118 extern time_t vint64_to_time(const vint64 *);
 119
 120 /*
 121  * Get the build date & time. ATTENTION: The time zone is not specified!
 122  * This depends entirely on the C compilers' capabilities to properly
 123  * expand the '__TIME__' and '__DATE__' macros, as required by the C
 124  * standard.
 125  */
 126 extern int
 127 ntpcal_get_build_date(struct calendar * /* jd */);
 128
 129 /*
 130  * Convert a timestamp in NTP scale to a time_t value in the UN*X
 131  * scale with proper epoch unfolding around a given pivot or the
 132  * current system time.
 133  */
 134 extern vint64
 135 ntpcal_ntp_to_time(uint32_t /* ntp */, const time_t * /* pivot */);
 136
 137 /*
 138  * Convert a timestamp in NTP scale to a 64bit seconds value in the NTP
 139  * scale with proper epoch unfolding around a given pivot or the current
 140  * system time.
 141  * Note: The pivot must be given in UN*X time scale!
 142  */
 143 extern vint64
 144 ntpcal_ntp_to_ntp(uint32_t /* ntp */, const time_t * /* pivot */);
 145
 146 /*
 147  * Split a time stamp in seconds into elapsed days and elapsed seconds
 148  * since midnight.
 149  */
 150 extern ntpcal_split
 151 ntpcal_daysplit(const vint64 *);
 152
 153 /*
 154  * Merge a number of days and a number of seconds into seconds,
 155  * expressed in 64 bits to avoid overflow.
 156  */
 157 extern vint64
 158 ntpcal_dayjoin(int32_t /* days */, int32_t /* seconds */);
 159
 160 /* Get the number of leap years since epoch for the number of elapsed
 161  * full years
 162  */
 163 extern int32_t
 164 ntpcal_leapyears_in_years(int32_t /* years */);
 165
 166 /*
 167  * Convert elapsed years in Era into elapsed days in Era.
 168  */
 169 extern int32_t
 170 ntpcal_days_in_years(int32_t /* years */);
 171
 172 /*
 173  * Convert a number of elapsed month in a year into elapsed days
 174  * in year.
 175  *
 176  * The month will be normalized, and 'res.hi' will contain the
 177  * excessive years that must be considered when converting the years,
 178  * while 'res.lo' will contain the days since start of the
 179  * year. (Expect the resulting days to be negative, with a positive
 180  * excess! But then, we need no leap year flag, either...)
 181  */
 182 extern ntpcal_split
 183 ntpcal_days_in_months(int32_t /* months */);
 184
 185 /*
 186  * Convert ELAPSED years/months/days of gregorian calendar to elapsed
 187  * days in Gregorian epoch. No range checks done here!
 188  */
 189 extern int32_t
 190 ntpcal_edate_to_eradays(int32_t /* years */, int32_t /* months */, int32_t /* mdays */);
 191
 192 /*
 193  * Convert a time spec to seconds. No range checks done here!
 194  */
 195 extern int32_t
 196 ntpcal_etime_to_seconds(int32_t /* hours */, int32_t /* minutes */, int32_t /* seconds */);
 197
 198 /*
 199  * Convert ELAPSED years/months/days of gregorian calendar to elapsed
 200  * days in year.
 201  *
 202  * Note: This will give the true difference to the start of the given year,
 203  * even if months & days are off-scale.
 204  */
 205 extern int32_t
 206 ntpcal_edate_to_yeardays(int32_t /* years */, int32_t /* months */, int32_t /* mdays */);
 207
 208 /*
 209  * Convert the date part of a 'struct tm' (that is, year, month,
 210  * day-of-month) into the RataDie of that day.
 211  */
 212 extern int32_t
 213 ntpcal_tm_to_rd(const struct tm * /* utm */);
 214
 215 /*
 216  * Convert the date part of a 'struct calendar' (that is, year, month,
 217  * day-of-month) into the RataDie of that day.
 218  */
 219 extern int32_t
 220 ntpcal_date_to_rd(const struct calendar * /* jt */);
 221
 222 /*
 223  * Given the number of elapsed days in the calendar era, split this
 224  * number into the number of elapsed years in 'res.quot' and the
 225  * number of elapsed days of that year in 'res.rem'.
 226  *
 227  * if 'isleapyear' is not NULL, it will receive an integer that is 0
 228  * for regular years and a non-zero value for leap years.
 229  *
 230  * The input is limited to [-2^30, 2^30-1]. If the days exceed this
 231  * range, errno is set to EDOM and the result is saturated.
 232  */
 233 extern ntpcal_split
 234 ntpcal_split_eradays(int32_t /* days */, int/*BOOL*/ * /* isleapyear */);
 235
 236 /*
 237  * Given a number of elapsed days in a year and a leap year indicator,
 238  * split the number of elapsed days into the number of elapsed months
 239  * in 'res.quot' and the number of elapsed days of that month in
 240  * 'res.rem'.
 241  */
 242 extern ntpcal_split
 243 ntpcal_split_yeardays(int32_t /* eyd */, int/*BOOL*/ /* isleapyear */);
 244
 245 /*
 246  * Convert a RataDie number into the date part of a 'struct
 247  * calendar'. Return 0 if the year is regular year, !0 if the year is
 248  * a leap year.
 249  */
 250 extern int/*BOOL*/
 251 ntpcal_rd_to_date(struct calendar * /* jt */, int32_t /* rd */);
 252
 253 /*
 254  * Convert a RataDie number into the date part of a 'struct
 255  * tm'. Return 0 if the year is regular year, !0 if the year is a leap
 256  * year.
 257  */
 258 extern int/*BOOL*/
 259 ntpcal_rd_to_tm(struct tm * /* utm */, int32_t /* rd */);
 260
 261 /*
 262  * Take a value of seconds since midnight and split it into hhmmss in
 263  * a 'struct calendar'. Return excessive days.
 264  */
 265 extern int32_t
 266 ntpcal_daysec_to_date(struct calendar * /* jt */, int32_t /* secs */);
 267
 268 /*
 269  * Take the time part of a 'struct calendar' and return the seconds
 270  * since midnight.
 271  */
 272 extern int32_t
 273 ntpcal_date_to_daysec(const struct calendar *);
 274
 275 /*
 276  * Take a value of seconds since midnight and split it into hhmmss in
 277  * a 'struct tm'. Return excessive days.
 278  */
 279 extern int32_t
 280 ntpcal_daysec_to_tm(struct tm * /* utm */, int32_t /* secs */);
 281
 282 extern int32_t
 283 ntpcal_tm_to_daysec(const struct tm * /* utm */);
 284
 285 /*
 286  * convert a year number to rata die of year start
 287  */
 288 extern int32_t
 289 ntpcal_year_to_ystart(int32_t /* year */);
 290
 291 /*
 292  * For a given RataDie, get the RataDie of the associated year start,
 293  * that is, the RataDie of the last January,1st on or before that day.
 294  */
 295 extern int32_t
 296 ntpcal_rd_to_ystart(int32_t /* rd */);
 297
 298 /*
 299  * convert a RataDie to the RataDie of start of the calendar month.
 300  */
 301 extern int32_t
 302 ntpcal_rd_to_mstart(int32_t /* year */);
 303
 304
 305 extern int
 306 ntpcal_daysplit_to_date(struct calendar * /* jt */,
 307                         const ntpcal_split * /* ds */, int32_t /* dof */);
 308
 309 extern int
 310 ntpcal_daysplit_to_tm(struct tm * /* utm */, const ntpcal_split * /* ds */,
 311                       int32_t /* dof */);
 312
 313 extern int
 314 ntpcal_time_to_date(struct calendar * /* jd */, const vint64 * /* ts */);
 315
 316 extern int32_t
 317 ntpcal_periodic_extend(int32_t /* pivot */, int32_t /* value */,
 318                        int32_t /* cycle */);
 319
 320 extern int
 321 ntpcal_ntp64_to_date(struct calendar * /* jd */, const vint64 * /* ntp */);
 322
 323 extern int
 324 ntpcal_ntp_to_date(struct calendar * /* jd */,  uint32_t /* ntp */,
 325                    const time_t * /* pivot */);
 326
 327 extern vint64
 328 ntpcal_date_to_ntp64(const struct calendar * /* jd */);
 329
 330 extern uint32_t
 331 ntpcal_date_to_ntp(const struct calendar * /* jd */);
 332
 333 extern time_t
 334 ntpcal_date_to_time(const struct calendar * /* jd */);
 335
 336 /*
 337  * ISO week-calendar conversions
 338  */
 339 extern int32_t
 340 isocal_weeks_in_years(int32_t  /* years */);
 341
 342 /*
 343  * The input is limited to [-2^30, 2^30-1]. If the weeks exceed this
 344  * range, errno is set to EDOM and the result is saturated.
 345  */
 346 extern ntpcal_split
 347 isocal_split_eraweeks(int32_t /* weeks */);
 348
 349 extern int
 350 isocal_ntp64_to_date(struct isodate * /* id */, const vint64 * /* ntp */);
 351
 352 extern int
 353 isocal_ntp_to_date(struct isodate * /* id */, uint32_t /* ntp */,
 354                    const time_t * /* pivot */);
 355
 356 extern vint64
 357 isocal_date_to_ntp64(const struct isodate * /* id */);
 358
 359 extern uint32_t
 360 isocal_date_to_ntp(const struct isodate * /* id */);
 361
 362
 363 /*
 364  * day-of-week calculations
 365  *
 366  * Given a RataDie and a day-of-week, calculate a RDN that is reater-than,
 367  * greater-or equal, closest, less-or-equal or less-than the given RDN
 368  * and denotes the given day-of-week
 369  */
 370 extern int32_t
 371 ntpcal_weekday_gt(int32_t  /* rdn */, int32_t /* dow */);
 372
 373 extern int32_t
 374 ntpcal_weekday_ge(int32_t /* rdn */, int32_t /* dow */);
 375
 376 extern int32_t
 377 ntpcal_weekday_close(int32_t /* rdn */, int32_t  /* dow */);
 378
 379 extern int32_t
 380 ntpcal_weekday_le(int32_t /* rdn */, int32_t /* dow */);
 381
 382 extern int32_t
 383 ntpcal_weekday_lt(int32_t /* rdn */, int32_t /* dow */);
 384
 385
 386 /*
 387  * handling of base date spec
 388  */
 389 extern int32_t
 390 basedate_eval_buildstamp(void);
 391
 392 extern int32_t
 393 basedate_eval_string(const char *str);
 394
 395 extern int32_t
 396 basedate_set_day(int32_t dayno);
 397
 398 extern uint32_t
 399 basedate_get_day(void);
 400
 401 extern time_t
 402 basedate_get_eracenter(void);
 403
 404 extern time_t
 405 basedate_get_erabase(void);
 406
 407
 408 /*
 409  * Additional support stuff for Ed Rheingold's calendrical calculations
 410  */
 411
 412 /*
 413  * Start day of NTP time as days past the imaginary date 12/1/1 BC.
 414  * (This is the beginning of the Christian Era, or BCE.)
 415  */
 416 #define DAY_NTP_STARTS 693596
 417
 418 /*
 419  * Start day of the UNIX epoch. This is the Rata Die of 1970-01-01.
 420  */
 421 #define DAY_UNIX_STARTS 719163
 422
 423 /*
 424  * Difference between UN*X and NTP epoch (25567).
 425  */
 426 #define NTP_TO_UNIX_DAYS (DAY_UNIX_STARTS - DAY_NTP_STARTS)
 427
 428 /*
 429  * Days in a normal 4 year leap year calendar cycle (1461).
 430  */
 431 #define GREGORIAN_NORMAL_LEAP_CYCLE_DAYS        (3 * 365 + 366)
 432
 433 /*
 434  * Days in a normal 100 year leap year calendar (36524).  We lose a
 435  * leap day in years evenly divisible by 100 but not by 400.
 436  */
 437 #define GREGORIAN_NORMAL_CENTURY_DAYS   \
 438                         (25 * GREGORIAN_NORMAL_LEAP_CYCLE_DAYS - 1)
 439
 440 /*
 441  * The Gregorian calendar is based on a 400 year cycle. This is the
 442  * number of days in each cycle (146097).  We gain a leap day in years
 443  * divisible by 400 relative to the "normal" century.
 444  */
 445 #define GREGORIAN_CYCLE_DAYS (4 * GREGORIAN_NORMAL_CENTURY_DAYS + 1)
 446
 447 /*
 448  * Number of weeks in 400 years (20871).
 449  */
 450 #define GREGORIAN_CYCLE_WEEKS (GREGORIAN_CYCLE_DAYS / 7)
 451
 452 #define is_leapyear(y)  (!((y) % 4) && !(!((y) % 100) && (y) % 400))
 453
 454 #endif