2 * ntp_leapsec.c - leap second processing for NTPD
4 * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
5 * The contents of 'html/copyright.html' apply.
6 * ----------------------------------------------------------------------
7 * This is an attempt to get the leap second handling into a dedicated
8 * module to make the somewhat convoluted logic testable.
12 #include <sys/types.h>
16 #include "ntp_types.h"
18 #include "ntp_stdlib.h"
19 #include "ntp_calendar.h"
20 #include "ntp_leapsec.h"
22 #include "vint64ops.h"
23 #include "lib_strbuf.h"
27 static const char * const logPrefix = "leapsecond file";
29 /* ---------------------------------------------------------------------
30 * GCC is rather sticky with its 'const' attribute. We have to do it more
31 * explicit than with a cast if we want to get rid of a CONST qualifier.
32 * Greetings from the PASCAL world, where casting was only possible via
48 /* ---------------------------------------------------------------------
49 * Our internal data structure
51 #define MAX_HIST 10 /* history of leap seconds */
54 vint64 ttime; /* transition time (after the step, ntp scale) */
55 uint32_t stime; /* schedule limit (a month before transition) */
56 int16_t taiof; /* TAI offset on and after the transition */
57 uint8_t dynls; /* dynamic: inserted on peer/clock request */
59 typedef struct leap_info leap_info_t;
62 vint64 update; /* time of information update */
63 vint64 expire; /* table expiration time */
64 uint16_t size; /* number of infos in table */
65 int16_t base_tai; /* total leaps before first entry */
66 int16_t this_tai; /* current TAI offset */
67 int16_t next_tai; /* TAI offset after 'when' */
68 vint64 dtime; /* due time (current era end) */
69 vint64 ttime; /* nominal transition time (next era start) */
70 vint64 stime; /* schedule time (when we take notice) */
71 vint64 ebase; /* base time of this leap era */
72 uint8_t dynls; /* next leap is dynamic (by peer request) */
74 typedef struct leap_head leap_head_t;
77 leap_signature_t lsig;
79 leap_info_t info[MAX_HIST];
82 /* Where we store our tables */
83 static leap_table_t _ltab[2], *_lptr;
84 static int/*BOOL*/ _electric;
86 /* Forward decls of local helpers */
87 static int add_range(leap_table_t*, const leap_info_t*);
88 static char * get_line(leapsec_reader, void*, char*, size_t);
89 static char * skipws(const char*);
90 static int parsefail(const char * cp, const char * ep);
91 static void reload_limits(leap_table_t*, const vint64*);
92 static void fetch_leap_era(leap_era_t*, const leap_table_t*,
94 static int betweenu32(uint32_t, uint32_t, uint32_t);
95 static void reset_times(leap_table_t*);
96 static int leapsec_add(leap_table_t*, const vint64*, int);
97 static int leapsec_raw(leap_table_t*, const vint64 *, int, int);
98 static const char * lstostr(const vint64 * ts);
100 /* =====================================================================
101 * Get & Set the current leap table
104 /* ------------------------------------------------------------------ */
109 leap_table_t *p1, *p2;
112 if (p1 == &_ltab[0]) {
114 } else if (p1 == &_ltab[1]) {
124 memcpy(p2, p1, sizeof(leap_table_t));
131 /* ------------------------------------------------------------------ */
136 if (pt == &_ltab[0] || pt == &_ltab[1])
141 /* ------------------------------------------------------------------ */
150 _electric = (on != 0);
151 if (_electric == res)
154 if (_lptr == &_ltab[0] || _lptr == &_ltab[1])
160 /* =====================================================================
161 * API functions that operate on tables
164 /* ---------------------------------------------------------------------
165 * Clear all leap second data. Use it for init & cleanup
171 memset(&pt->lsig, 0, sizeof(pt->lsig));
172 memset(&pt->head, 0, sizeof(pt->head));
176 /* ---------------------------------------------------------------------
177 * Load a leap second file and check expiration on the go
186 char *cp, *ep, linebuf[50];
189 struct calendar build;
192 if (use_build_limit && ntpcal_get_build_date(&build)) {
193 /* don't prune everything -- permit the last 10yrs
197 limit = ntpcal_date_to_ntp64(&build);
199 memset(&limit, 0, sizeof(limit));
202 while (get_line(func, farg, linebuf, sizeof(linebuf))) {
208 pt->head.expire = strtouv64(cp, &ep, 10);
209 if (parsefail(cp, ep))
211 pt->lsig.etime = pt->head.expire.D_s.lo;
212 } else if (*cp == '$') {
214 pt->head.update = strtouv64(cp, &ep, 10);
215 if (parsefail(cp, ep))
218 } else if (isdigit((u_char)*cp)) {
219 ttime = strtouv64(cp, &ep, 10);
220 if (parsefail(cp, ep))
223 taiof = strtol(cp, &ep, 10);
224 if ( parsefail(cp, ep)
225 || taiof > SHRT_MAX || taiof < SHRT_MIN)
227 if (ucmpv64(&ttime, &limit) >= 0) {
228 if (!leapsec_raw(pt, &ttime,
232 pt->head.base_tai = (int16_t)taiof;
234 pt->lsig.ttime = ttime.D_s.lo;
235 pt->lsig.taiof = (int16_t)taiof;
247 /* ---------------------------------------------------------------------
248 * Dump a table in human-readable format. Use 'fprintf' and a FILE
249 * pointer if you want to get it printed into a stream.
253 const leap_table_t * pt ,
259 struct calendar atb, ttb;
261 ntpcal_ntp64_to_date(&ttb, &pt->head.expire);
262 (*func)(farg, "leap table (%u entries) expires at %04u-%02u-%02u:\n",
264 ttb.year, ttb.month, ttb.monthday);
267 ts = pt->info[idx].ttime;
268 ntpcal_ntp64_to_date(&ttb, &ts);
269 ts = subv64u32(&ts, pt->info[idx].stime);
270 ntpcal_ntp64_to_date(&atb, &ts);
272 (*func)(farg, "%04u-%02u-%02u [%c] (%04u-%02u-%02u) - %d\n",
273 ttb.year, ttb.month, ttb.monthday,
274 "-*"[pt->info[idx].dynls != 0],
275 atb.year, atb.month, atb.monthday,
276 pt->info[idx].taiof);
280 /* =====================================================================
281 * usecase driven API functions
288 const time_t * pivot)
291 vint64 ts64, last, next;
295 /* preset things we use later on... */
297 ts64 = ntpcal_ntp_to_ntp(ts32, pivot);
298 pt = leapsec_get_table(FALSE);
299 memset(qr, 0, sizeof(leap_result_t));
301 if (ucmpv64(&ts64, &pt->head.ebase) < 0) {
302 /* Most likely after leap frame reset. Could also be a
303 * backstep of the system clock. Anyway, get the new
306 reload_limits(pt, &ts64);
307 } else if (ucmpv64(&ts64, &pt->head.dtime) >= 0) {
308 /* Boundary crossed in forward direction. This might
309 * indicate a leap transition, so we prepare for that
312 * Some operations below are actually NOPs in electric
313 * mode, but having only one code path that works for
314 * both modes is easier to maintain.
316 * There's another quirk we must keep looking out for:
317 * If we just stepped the clock, the step might have
318 * crossed a leap boundary. As with backward steps, we
319 * do not want to raise the 'fired' event in that case.
320 * So we raise the 'fired' event only if we're close to
321 * the transition and just reload the limits otherwise.
323 last = addv64i32(&pt->head.dtime, 3); /* get boundary */
324 if (ucmpv64(&ts64, &last) >= 0) {
325 /* that was likely a query after a step */
326 reload_limits(pt, &ts64);
328 /* close enough for deeper examination */
329 last = pt->head.ttime;
330 qr->warped = (int16_t)(last.D_s.lo -
331 pt->head.dtime.D_s.lo);
332 next = addv64i32(&ts64, qr->warped);
333 reload_limits(pt, &next);
334 fired = ucmpv64(&pt->head.ebase, &last) == 0;
344 qr->tai_offs = pt->head.this_tai;
345 qr->ebase = pt->head.ebase;
346 qr->ttime = pt->head.ttime;
348 /* If before the next scheduling alert, we're done. */
349 if (ucmpv64(&ts64, &pt->head.stime) < 0)
352 /* now start to collect the remaining data */
353 due32 = pt->head.dtime.D_s.lo;
355 qr->tai_diff = pt->head.next_tai - pt->head.this_tai;
356 qr->ddist = due32 - ts32;
357 qr->dynamic = pt->head.dynls;
358 qr->proximity = LSPROX_SCHEDULE;
360 /* if not in the last day before transition, we're done. */
361 if (!betweenu32(due32 - SECSPERDAY, ts32, due32))
364 qr->proximity = LSPROX_ANNOUNCE;
365 if (!betweenu32(due32 - 10, ts32, due32))
368 /* The last 10s before the transition. Prepare for action! */
369 qr->proximity = LSPROX_ALERT;
373 /* ------------------------------------------------------------------ */
378 const time_t * pivot)
380 const leap_table_t * pt;
383 pt = leapsec_get_table(FALSE);
384 ts64 = ntpcal_ntp_to_ntp(ntpts, pivot);
385 fetch_leap_era(qr, pt, &ts64);
389 /* ------------------------------------------------------------------ */
394 const leap_table_t * pt;
396 memset(qr, 0, sizeof(leap_result_t));
397 pt = leapsec_get_table(FALSE);
399 qr->tai_offs = pt->head.this_tai;
400 qr->tai_diff = pt->head.next_tai - pt->head.this_tai;
401 qr->ebase = pt->head.ebase;
402 qr->ttime = pt->head.ttime;
403 qr->dynamic = pt->head.dynls;
405 return ucmpv64(&pt->head.ttime, &pt->head.stime) >= 0;
408 /* ------------------------------------------------------------------ */
409 /* Reset the current leap frame */
411 leapsec_reset_frame(void)
413 reset_times(leapsec_get_table(FALSE));
416 /* ------------------------------------------------------------------ */
417 /* load a file from a FILE pointer. Note: If hcheck is true, load
418 * only after successful signature check. The stream must be seekable
433 rcheck = leapsec_validate((leapsec_reader)getc, ifp);
437 case LSVALID_GOODHASH:
438 msyslog(LOG_NOTICE, "%s ('%s'): good hash signature",
443 msyslog(LOG_ERR, "%s ('%s'): no hash signature",
446 case LSVALID_BADHASH:
447 msyslog(LOG_ERR, "%s ('%s'): signature mismatch",
450 case LSVALID_BADFORMAT:
451 msyslog(LOG_ERR, "%s ('%s'): malformed hash signature",
455 msyslog(LOG_ERR, "%s ('%s'): unknown error code %d",
456 logPrefix, fname, rcheck);
463 pt = leapsec_get_table(TRUE);
464 if (!leapsec_load(pt, (leapsec_reader)getc, ifp, TRUE)) {
467 msyslog(LOG_ERR, "%s ('%s'): bad transition time",
471 msyslog(LOG_ERR, "%s ('%s'): times not ascending",
475 msyslog(LOG_ERR, "%s ('%s'): parsing error",
483 msyslog(LOG_NOTICE, "%s ('%s'): loaded, expire=%s last=%s ofs=%d",
484 logPrefix, fname, lstostr(&pt->head.expire),
485 lstostr(&pt->info[0].ttime), pt->info[0].taiof);
488 "%s ('%s'): loaded, expire=%s ofs=%d (no entries after build date)",
489 logPrefix, fname, lstostr(&pt->head.expire),
492 return leapsec_set_table(pt);
495 /* ------------------------------------------------------------------ */
499 struct stat * sb_old,
507 /* just do nothing if there is no leap file */
508 if ( !(fname && *fname) )
511 /* try to stat the leapfile */
512 if (0 != stat(fname, &sb_new)) {
514 msyslog(LOG_ERR, "%s ('%s'): stat failed: %m",
519 /* silently skip to postcheck if no new file found */
520 if (NULL != sb_old) {
522 && sb_old->st_mtime == sb_new.st_mtime
523 && sb_old->st_ctime == sb_new.st_ctime
529 /* try to open the leap file, complain if that fails
531 * [perlinger@ntp.org]
532 * coverity raises a TOCTOU (time-of-check/time-of-use) issue
533 * here, which is not entirely helpful: While there is indeed a
534 * possible race condition between the 'stat()' call above and
535 * the 'fopen)' call below, I intentionally want to omit the
536 * overhead of opening the file and calling 'fstat()', because
537 * in most cases the file would have be to closed anyway without
538 * reading the contents. I chose to disable the coverity
541 * So unless someone comes up with a reasonable argument why
542 * this could be a real issue, I'll just try to silence coverity
545 /* coverity[toctou] */
546 if ((fp = fopen(fname, "r")) == NULL) {
549 "%s ('%s'): open failed: %m",
554 rc = leapsec_load_stream(fp, fname, logall);
559 /* ------------------------------------------------------------------ */
562 leap_signature_t * psig)
564 const leap_table_t * pt;
566 pt = leapsec_get_table(FALSE);
567 memcpy(psig, &pt->lsig, sizeof(leap_signature_t));
570 /* ------------------------------------------------------------------ */
576 const leap_table_t * pt;
579 pt = leapsec_get_table(FALSE);
580 limit = ntpcal_ntp_to_ntp(when, tpiv);
581 return ucmpv64(&limit, &pt->head.expire) >= 0;
584 /* ------------------------------------------------------------------ */
590 const leap_table_t * pt;
593 pt = leapsec_get_table(FALSE);
594 limit = ntpcal_ntp_to_ntp(when, tpiv);
595 limit = subv64(&pt->head.expire, &limit);
596 return ntpcal_daysplit(&limit).hi;
599 /* ------------------------------------------------------------------ */
600 #if 0 /* currently unused -- possibly revived later */
606 const time_t * pivot)
617 et64 = ntpcal_ntp_to_ntp(etime, pivot);
618 tt64 = ntpcal_ntp_to_ntp(ttime, pivot);
619 pt = leapsec_get_table(TRUE);
621 if ( ucmpv64(&et64, &pt->head.expire) <= 0
622 || !leapsec_raw(pt, &tt64, total, FALSE) )
625 pt->lsig.etime = etime;
626 pt->lsig.ttime = ttime;
627 pt->lsig.taiof = (int16_t)total;
629 pt->head.expire = et64;
631 return leapsec_set_table(pt);
635 /* ------------------------------------------------------------------ */
640 const time_t * pivot )
645 pt = leapsec_get_table(TRUE);
646 now64 = ntpcal_ntp_to_ntp(ntpnow, pivot);
647 return ( leapsec_add(pt, &now64, (insert != 0))
648 && leapsec_set_table(pt));
651 /* ------------------------------------------------------------------ */
656 const time_t * pivot )
664 pt = leapsec_get_table(FALSE);
666 /* Bail out if the basic offset is not zero and the putative
667 * offset is bigger than 10s. That was in 1972 -- we don't want
668 * to go back that far!
670 if (pt->head.base_tai != 0 || tai_offset < 10)
673 /* If there's already data in the table, check if an update is
674 * possible. Update is impossible if there are static entries
675 * (since this indicates a valid leapsecond file) or if we're
676 * too close to a leapsecond transition: We do not know on what
677 * side the transition the sender might have been, so we use a
678 * dead zone around the transition.
681 /* Check for static entries */
682 for (idx = 0; idx != pt->head.size; idx++)
683 if ( ! pt->info[idx].dynls)
686 /* get the fulll time stamp and leap era for it */
687 now64 = ntpcal_ntp_to_ntp(ntpnow, pivot);
688 fetch_leap_era(&era, pt, &now64);
690 /* check the limits with 20s dead band */
691 era.ebase = addv64i32(&era.ebase, 20);
692 if (ucmpv64(&now64, &era.ebase) < 0)
695 era.ttime = addv64i32(&era.ttime, -20);
696 if (ucmpv64(&now64, &era.ttime) > 0)
699 /* Here we can proceed. Calculate the delta update. */
700 tai_offset -= era.taiof;
702 /* Shift the header info offsets. */
703 pt->head.base_tai += tai_offset;
704 pt->head.this_tai += tai_offset;
705 pt->head.next_tai += tai_offset;
707 /* Shift table entry offsets (if any) */
708 for (idx = 0; idx != pt->head.size; idx++)
709 pt->info[idx].taiof += tai_offset;
711 /* claim success... */
716 /* =====================================================================
720 /* [internal] Reset / init the time window in the leap processor to
721 * force reload on next query. Since a leap transition cannot take place
722 * at an odd second, the value chosen avoids spurious leap transition
723 * triggers. Making all three times equal forces a reload. Using the
724 * maximum value for unsigned 64 bits makes finding the next leap frame
731 memset(&pt->head.ebase, 0xFF, sizeof(vint64));
732 pt->head.stime = pt->head.ebase;
733 pt->head.ttime = pt->head.ebase;
734 pt->head.dtime = pt->head.ebase;
737 /* [internal] Add raw data to the table, removing old entries on the
738 * fly. This cannot fail currently.
743 const leap_info_t * pi)
745 /* If the table is full, make room by throwing out the oldest
746 * entry. But remember the accumulated leap seconds! Likewise,
747 * assume a positive leap insertion if this is the first entry
748 * in the table. This is not necessarily the best of all ideas,
749 * but it helps a great deal if a system does not have a leap
750 * table and gets updated from an upstream server.
752 if (pt->head.size == 0) {
753 pt->head.base_tai = pi->taiof - 1;
754 } else if (pt->head.size >= MAX_HIST) {
755 pt->head.size = MAX_HIST - 1;
756 pt->head.base_tai = pt->info[pt->head.size].taiof;
759 /* make room in lower end and insert item */
760 memmove(pt->info+1, pt->info, pt->head.size*sizeof(*pt->info));
764 /* invalidate the cached limit data -- we might have news ;-)
766 * This blocks a spurious transition detection. OTOH, if you add
767 * a value after the last query before a leap transition was
768 * expected to occur, this transition trigger is lost. But we
769 * can probably live with that.
775 /* [internal] given a reader function, read characters into a buffer
776 * until either EOL or EOF is reached. Makes sure that the buffer is
777 * always NUL terminated, but silently truncates excessive data. The
778 * EOL-marker ('\n') is *not* stored in the buffer.
780 * Returns the pointer to the buffer, unless EOF was reached when trying
781 * to read the first character of a line.
793 /* if we cannot even store the delimiter, declare failure */
794 if (buff == NULL || size == 0)
798 while (EOF != (ch = (*func)(farg)) && '\n' != ch)
803 /* discard trailing whitespace */
804 while (ptr != buff && isspace((u_char)ptr[-1]))
807 return (ptr == buff && ch == EOF) ? NULL : buff;
810 /* [internal] skips whitespace characters from a character buffer. */
815 while (isspace((u_char)*ptr))
817 return (char*)noconst(ptr);
820 /* [internal] check if a strtoXYZ ended at EOL or whitespace and
821 * converted something at all. Return TRUE if something went wrong.
829 || (*ep && *ep != '#' && !isspace((u_char)*ep));
832 /* [internal] reload the table limits around the given time stamp. This
833 * is where the real work is done when it comes to table lookup and
834 * evaluation. Some care has been taken to have correct code for dealing
835 * with boundary conditions and empty tables.
837 * In electric mode, transition and trip time are the same. In dumb
838 * mode, the difference of the TAI offsets must be taken into account
839 * and trip time and transition time become different. The difference
840 * becomes the warping distance when the trip time is reached.
849 /* Get full time and search the true lower bound. Use a
850 * simple loop here, since the number of entries does
851 * not warrant a binary search. This also works for an empty
852 * table, so there is no shortcut for that case.
854 for (idx = 0; idx != pt->head.size; idx++)
855 if (ucmpv64(ts, &pt->info[idx].ttime) >= 0)
858 /* get time limits with proper bound conditions. Note that the
859 * bounds of the table will be observed even if the table is
860 * empty -- no undefined condition must arise from this code.
862 if (idx >= pt->head.size) {
863 memset(&pt->head.ebase, 0x00, sizeof(vint64));
864 pt->head.this_tai = pt->head.base_tai;
866 pt->head.ebase = pt->info[idx].ttime;
867 pt->head.this_tai = pt->info[idx].taiof;
870 pt->head.next_tai = pt->info[idx].taiof;
871 pt->head.dynls = pt->info[idx].dynls;
872 pt->head.ttime = pt->info[idx].ttime;
875 pt->head.dtime = pt->head.ttime;
877 pt->head.dtime = addv64i32(
879 pt->head.next_tai - pt->head.this_tai);
881 pt->head.stime = subv64u32(
882 &pt->head.ttime, pt->info[idx].stime);
885 memset(&pt->head.ttime, 0xFF, sizeof(vint64));
886 pt->head.stime = pt->head.ttime;
887 pt->head.dtime = pt->head.ttime;
888 pt->head.next_tai = pt->head.this_tai;
893 /* [internal] fetch the leap era for a given time stamp.
894 * This is a cut-down version the algorithm used to reload the table
895 * limits, but it does not update any global state and provides just the
896 * era information for a given time stamp.
901 const leap_table_t * pt ,
906 /* Simple search loop, also works with empty table. */
907 for (idx = 0; idx != pt->head.size; idx++)
908 if (ucmpv64(ts, &pt->info[idx].ttime) >= 0)
910 /* fetch era data, keeping an eye on boundary conditions */
911 if (idx >= pt->head.size) {
912 memset(&into->ebase, 0x00, sizeof(vint64));
913 into->taiof = pt->head.base_tai;
915 into->ebase = pt->info[idx].ttime;
916 into->taiof = pt->info[idx].taiof;
919 into->ttime = pt->info[idx].ttime;
921 memset(&into->ttime, 0xFF, sizeof(vint64));
924 /* [internal] Take a time stamp and create a leap second frame for
925 * it. This will schedule a leap second for the beginning of the next
926 * month, midnight UTC. The 'insert' argument tells if a leap second is
927 * added (!=0) or removed (==0). We do not handle multiple inserts
930 * Returns 1 if the insert worked, 0 otherwise. (It's not possible to
931 * insert a leap second into the current history -- only appending
932 * towards the future is allowed!)
937 const vint64 * now64 ,
940 vint64 ttime, starttime;
944 /* Check against the table expiration and the latest available
945 * leap entry. Do not permit inserts, only appends, and only if
946 * the extend the table beyond the expiration!
948 if ( ucmpv64(now64, &pt->head.expire) < 0
949 || (pt->head.size && ucmpv64(now64, &pt->info[0].ttime) <= 0)) {
954 ntpcal_ntp64_to_date(&fts, now64);
955 /* To guard against dangling leap flags: do not accept leap
956 * second request on the 1st hour of the 1st day of the month.
958 if (fts.monthday == 1 && fts.hour == 0) {
963 /* Ok, do the remaining calculations */
968 starttime = ntpcal_date_to_ntp64(&fts);
970 ttime = ntpcal_date_to_ntp64(&fts);
973 li.stime = ttime.D_s.lo - starttime.D_s.lo;
974 li.taiof = (pt->head.size ? pt->info[0].taiof : pt->head.base_tai)
977 return add_range(pt, &li);
980 /* [internal] Given a time stamp for a leap insertion (the exact begin
981 * of the new leap era), create new leap frame and put it into the
982 * table. This is the work horse for reading a leap file and getting a
983 * leap second update via authenticated network packet.
988 const vint64 * ttime,
996 /* Check that we either extend the table or get a duplicate of
997 * the latest entry. The latter is a benevolent overwrite with
998 * identical data and could happen if we get an autokey message
999 * that extends the lifetime of the current leapsecond table.
1000 * Otherwise paranoia rulez!
1002 if (pt->head.size) {
1003 int cmp = ucmpv64(ttime, &pt->info[0].ttime);
1005 cmp -= (taiof != pt->info[0].taiof);
1014 ntpcal_ntp64_to_date(&fts, ttime);
1015 /* If this does not match the exact month start, bail out. */
1016 if (fts.monthday != 1 || fts.hour || fts.minute || fts.second) {
1020 fts.month--; /* was in range 1..12, no overflow here! */
1021 starttime = ntpcal_date_to_ntp64(&fts);
1023 li.stime = ttime->D_s.lo - starttime.D_s.lo;
1024 li.taiof = (int16_t)taiof;
1025 li.dynls = (dynls != 0);
1026 return add_range(pt, &li);
1029 /* [internal] Do a wrap-around save range inclusion check.
1030 * Returns TRUE if x in [lo,hi[ (intervall open on right side) with full
1031 * handling of an overflow / wrap-around.
1042 rc = (lo <= x) && (x < hi);
1044 rc = (lo <= x) || (x < hi);
1048 /* =====================================================================
1053 unsigned char hv[ISC_SHA1_DIGESTLENGTH];
1056 /* [internal] parse a digest line to get the hash signature
1057 * The NIST code creating the hash writes them out as 5 hex integers
1058 * without leading zeros. This makes reading them back as hex-encoded
1059 * BLOB impossible, because there might be less than 40 hex digits.
1061 * The solution is to read the values back as integers, and then do the
1062 * byte twiddle necessary to get it into an array of 20 chars. The
1063 * drawback is that it permits any acceptable number syntax provided by
1064 * 'scanf()' and 'strtoul()', including optional signs and '0x'
1072 int wi, di, num, len;
1073 unsigned long tmp[5];
1075 memset(mac, 0, sizeof(*mac));
1076 num = sscanf(cp, " %lx %lx %lx %lx %lx%n",
1077 &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4],
1079 if (num != 5 || cp[len] > ' ')
1082 /* now do the byte twiddle */
1083 for (wi=0; wi < 5; ++wi)
1084 for (di=3; di >= 0; --di) {
1085 mac->hv[wi*4 + di] =
1086 (unsigned char)(tmp[wi] & 0x0FF);
1092 /* [internal] add the digits of a data line to the hash, stopping at the
1093 * next hash ('#') character.
1100 unsigned char text[32]; // must be power of two!
1101 unsigned int tlen = 0;
1104 while ('\0' != (ch = *cp++) && '#' != ch)
1107 tlen &= (sizeof(text)-1);
1110 mdctx, text, sizeof(text));
1114 isc_sha1_update(mdctx, text, tlen);
1117 /* given a reader and a reader arg, calculate and validate the the hash
1118 * signature of a NIST leap second file.
1122 leapsec_reader func,
1126 sha1_digest rdig, ldig; /* remote / local digests */
1130 isc_sha1_init(&mdctx);
1131 while (get_line(func, farg, line, sizeof(line))) {
1132 if (!strncmp(line, "#h", 2))
1133 hlseen = do_leap_hash(&rdig, line+2);
1134 else if (!strncmp(line, "#@", 2))
1135 do_hash_data(&mdctx, line+2);
1136 else if (!strncmp(line, "#$", 2))
1137 do_hash_data(&mdctx, line+2);
1138 else if (isdigit((unsigned char)line[0]))
1139 do_hash_data(&mdctx, line);
1141 isc_sha1_final(&mdctx, ldig.hv);
1142 isc_sha1_invalidate(&mdctx);
1145 return LSVALID_NOHASH;
1147 return LSVALID_BADFORMAT;
1148 if (0 != memcmp(&rdig, &ldig, sizeof(sha1_digest)))
1149 return LSVALID_BADHASH;
1150 return LSVALID_GOODHASH;
1154 * lstostr - prettyprint NTP seconds
1165 if ( ! (ts->d_s.hi >= 0 && ntpcal_ntp64_to_date(&tm, ts) >= 0))
1166 snprintf(buf, LIB_BUFLENGTH, "%s", "9999-12-31T23:59:59Z");
1168 snprintf(buf, LIB_BUFLENGTH, "%04d-%02d-%02dT%02d:%02d:%02dZ",
1169 tm.year, tm.month, tm.monthday,
1170 tm.hour, tm.minute, tm.second);
1175 /* reset the global state for unit tests */
1177 leapsec_ut_pristine(void)
1179 memset(_ltab, 0, sizeof(_ltab));
1186 /* -*- that's all folks! -*- */