Annotation of embedaddon/ntp/ntpd/check_y2k.c, revision 1.1.1.1
1.1 misho 1: /* check_y2k.c -- test ntp code constructs for Y2K correctness Y2KFixes [*/
2:
3: /*
4: Code invoked by `make check`. Not part of ntpd and not to be
5: installed.
6:
7: On any code I even wonder about, I've cut and pasted the code
8: here and ran it as a test case just to be sure.
9:
10: For code not in "ntpd" proper, we have tried to call most
11: repaired functions from herein to properly test them
12: (something never done before!). This has found several bugs,
13: not normal Y2K bugs, that will strike in Y2K so repair them
14: we did.
15:
16: Program exits with 0 on success, 1 on Y2K failure (stdout messages).
17: Exit of 2 indicates internal logic bug detected OR failure of
18: what should be our correct formulas.
19:
20: While "make check" should only check logic for source within that
21: specific directory, this check goes outside the scope of the local
22: directory. It's not a perfect world (besides, there is a lot of
23: interdependence here, and it really needs to be tested in
24: a controled order).
25: */
26:
27: /* { definitions lifted from ntpd.c to allow us to complie with
28: "#include ntp.h". I have not taken the time to reduce the clutter. */
29:
30: #ifdef HAVE_CONFIG_H
31: # include <config.h>
32: #endif
33:
34: #include "ntpd.h"
35:
36: #ifdef HAVE_UNISTD_H
37: # include <unistd.h>
38: #endif
39: #ifdef HAVE_SYS_STAT_H
40: # include <sys/stat.h>
41: #endif
42: #include <stdio.h>
43: #include <errno.h>
44: #ifndef SYS_WINNT
45: # if !defined(VMS) /*wjm*/
46: # include <sys/param.h>
47: # endif /* VMS */
48: # if HAVE_SYS_SIGNAL_H
49: # include <sys/signal.h>
50: # endif /* HAVE_SYS_SIGNAL_H */
51: # include <sys/signal.h>
52: # ifdef HAVE_SYS_IOCTL_H
53: # include <sys/ioctl.h>
54: # endif /* HAVE_SYS_IOCTL_H */
55: # if !defined(VMS) /*wjm*/
56: # include <sys/resource.h>
57: # endif /* VMS */
58: #else
59: # include <signal.h>
60: # include <process.h>
61: # include <io.h>
62: # include "../libntp/log.h"
63: #endif /* SYS_WINNT */
64: #if defined(HAVE_RTPRIO)
65: # ifdef HAVE_SYS_RESOURCE_H
66: # include <sys/resource.h>
67: # endif
68: # ifdef HAVE_SYS_LOCK_H
69: # include <sys/lock.h>
70: # endif
71: # include <sys/rtprio.h>
72: #else
73: # ifdef HAVE_PLOCK
74: # ifdef HAVE_SYS_LOCK_H
75: # include <sys/lock.h>
76: # endif
77: # endif
78: #endif
79: #if defined(HAVE_SCHED_SETSCHEDULER)
80: # ifdef HAVE_SCHED_H
81: # include <sched.h>
82: # else
83: # ifdef HAVE_SYS_SCHED_H
84: # include <sys/sched.h>
85: # endif
86: # endif
87: #endif
88: #if defined(HAVE_SYS_MMAN_H)
89: # include <sys/mman.h>
90: #endif
91:
92: #ifdef HAVE_TERMIOS_H
93: # include <termios.h>
94: #endif
95:
96: #ifdef SYS_DOMAINOS
97: # include <apollo/base.h>
98: #endif /* SYS_DOMAINOS */
99:
100: /* } end definitions lifted from ntpd.c */
101:
102: #include "ntp_calendar.h"
103: #include "parse.h"
104:
105: #define GoodLeap(Year) (((Year)%4 || (!((Year)%100) && (Year)%400)) ? 0 : 13 )
106:
107: volatile int debug = 0; /* debugging requests for parse stuff */
108: char const *progname = "check_y2k";
109:
110: long
111: Days ( int Year ) /* return number of days since year "0" */
112: {
113: long Return;
114: /* this is a known to be good algorithm */
115: Return = Year * 365; /* first aproximation to the value */
116: if ( Year >= 1 )
117: { /* see notes in libparse/parse.c if you want a PROPER
118: * **generic algorithm. */
119: Return += (Year+3) / 4; /* add in (too many) leap days */
120: Return -= (Year-1) / 100; /* reduce by (too many) centurys */
121: Return += (Year-1) / 400; /* get final answer */
122: }
123:
124: return Return;
125: }
126:
127: static int year0 = 1900; /* sarting year for NTP time */
128: static int yearend; /* ending year we test for NTP time.
129: * 32-bit systems: through 2036, the
130: **year in which NTP time overflows.
131: * 64-bit systems: a reasonable upper
132: **limit (well, maybe somewhat beyond
133: **reasonable, but well before the
134: **max time, by which time the earth
135: **will be dead.) */
136: static time_t Time;
137: static struct tm LocalTime;
138:
139: #define Error(year) if ( (year)>=2036 && LocalTime.tm_year < 110 ) \
140: Warnings++; else Fatals++
141:
142: int
143: main( void )
144: {
145: int Fatals;
146: int Warnings;
147: int year;
148:
149: Time = time( (time_t *)NULL )
150: #ifdef TESTTIMEOFFSET
151: + test_time_offset
152: #endif
153: ;
154: LocalTime = *localtime( &Time );
155:
156: year = ( sizeof( u_long ) > 4 ) /* save max span using year as temp */
157: ? ( 400 * 3 ) /* three greater gregorian cycles */
158: : ((int)(0x7FFFFFFF / 365.242 / 24/60/60)* 2 ); /*32-bit limit*/
159: /* NOTE: will automacially expand test years on
160: * 64 bit machines.... this may cause some of the
161: * existing ntp logic to fail for years beyond
162: * 2036 (the current 32-bit limit). If all checks
163: * fail ONLY beyond year 2036 you may ignore such
164: * errors, at least for a decade or so. */
165: yearend = year0 + year;
166:
167: puts( " internal self check" );
168: { /* verify our own logic used to verify repairs */
169: unsigned long days;
170:
171: if ( year0 >= yearend )
172: {
173: fprintf( stdout, "year0=%d NOT LESS THAN yearend=%d (span=%d)\n",
174: (int)year0, (int)yearend, (int)year );
175: exit(2);
176: }
177:
178: {
179: int save_year;
180:
181: save_year = LocalTime.tm_year; /* save current year */
182:
183: year = 1980;
184: LocalTime.tm_year = year - 1900;
185: Fatals = Warnings = 0;
186: Error(year); /* should increment Fatals */
187: if ( Fatals == 0 )
188: {
189: fprintf( stdout,
190: "%4d: %s(%d): FATAL DID NOT INCREMENT (Fatals=%d Warnings=%d)\n",
191: (int)year, __FILE__, __LINE__, (int)Fatals, (int)Warnings );
192: exit(2);
193: }
194:
195: year = 2100; /* test year > limit but CURRENT year < limit */
196: Fatals = Warnings = 0;
197: Error(year); /* should increment Fatals */
198: if ( Warnings == 0 )
199: {
200: fprintf( stdout,
201: "%4d: %s(%d): WARNING DID NOT INCREMENT (Fatals=%d Warnings=%d)\n",
202: (int)year, __FILE__, __LINE__, (int)Fatals, (int)Warnings );
203: exit(2);
204: }
205: Fatals = Warnings = 0;
206: LocalTime.tm_year = year - 1900; /* everything > limit */
207: Error(1980); /* should increment Fatals */
208: if ( Fatals == 0 )
209: {
210: fprintf( stdout,
211: "%4d: %s(%d): FATALS DID NOT INCREMENT (Fatals=%d Warnings=%d)\n",
212: (int)year, __FILE__, __LINE__, (int)Fatals, (int)Warnings );
213: exit(2);
214: }
215:
216: LocalTime.tm_year = save_year;
217: }
218:
219: days = 365+1; /* days in year 0 + 1 more day */
220: for ( year = 1; year <= 2500; year++ )
221: {
222: long Test;
223: Test = Days( year );
224: if ( days != Test )
225: {
226: fprintf( stdout, "%04d: Days() DAY COUNT ERROR: s/b=%ld was=%ld\n",
227: year, (long)days, (long)Test );
228: exit(2); /* would throw off many other tests */
229: }
230:
231: Test = julian0(year); /* compare with julian0() macro */
232: if ( days != Test )
233: {
234: fprintf( stdout, "%04d: julian0() DAY COUNT ERROR: s/b=%ld was=%ld\n",
235: year, (long)days, (long)Test );
236: exit(2); /* would throw off many other tests */
237: }
238:
239: days += 365;
240: if ( isleap_4(year) ) days++;
241: }
242:
243: if ( isleap_4(1999) )
244: {
245: fprintf( stdout, "isleap_4(1999) REPORTED TRUE\n" );
246: exit(2);
247: }
248: if ( !isleap_4(2000) )
249: {
250: fprintf( stdout, "isleap_4(2000) REPORTED FALSE\n" );
251: exit(2);
252: }
253: if ( isleap_4(2001) )
254: {
255: fprintf( stdout, "isleap_4(1999) REPORTED TRUE\n" );
256: exit(2);
257: }
258:
259: if ( !isleap_tm(2000-1900) )
260: {
261: fprintf( stdout, "isleap_tm(100) REPORTED FALSE\n" );
262: exit(2);
263: }
264: }
265:
266: Fatals = Warnings = 0;
267:
268: puts( " include/ntp.h" );
269: { /* test our new isleap_*() #define "functions" */
270:
271: for ( year = 1400; year <= 2200; year++ )
272: {
273: int LeapSw;
274: int IsLeapSw;
275:
276: LeapSw = GoodLeap(year);
277: IsLeapSw = isleap_4(year);
278:
279: if ( !!LeapSw != !!IsLeapSw )
280: {
281: Error(year);
282: fprintf( stdout,
283: " %4d %2d %3d *** ERROR\n", year, LeapSw, IsLeapSw );
284: break;
285: }
286:
287: IsLeapSw = isleap_tm(year-1900);
288:
289: if ( !!LeapSw != !!IsLeapSw )
290: {
291: Error(year);
292: fprintf( stdout,
293: " %4d %2d %3d *** ERROR\n", year, LeapSw, IsLeapSw );
294: break;
295: }
296: }
297: }
298:
299: puts( " include/ntp_calendar.h" );
300: { /* I belive this is good, but just to be sure... */
301:
302: /* we are testing this #define */
303: #define is_leapyear(y) (y%4 == 0 && !(y%100 == 0 && !(y%400 == 0)))
304:
305: for ( year = 1400; year <= 2200; year++ )
306: {
307: int LeapSw;
308:
309: LeapSw = GoodLeap(year);
310:
311: if ( !(!LeapSw) != !(!is_leapyear(year)) )
312: {
313: Error(year);
314: fprintf( stdout,
315: " %4d %2d *** ERROR\n", year, LeapSw );
316: break;
317: }
318: }
319: }
320:
321:
322: puts( " libparse/parse.c" );
323: {
324: long Days1970; /* days from 1900 to 1970 */
325:
326: struct ParseTime /* womp up a test structure to all cut/paste code */
327: {
328: int year;
329: } Clock_Time, *clock_time;
330:
331: clock_time = &Clock_Time;
332:
333: /* first test this #define */
334: #define days_per_year(x) ((x) % 4 ? 365 : ((x % 400) ? ((x % 100) ? 366 : 365) : 366))
335:
336: for ( year = 1400; year <= 2200; year++ )
337: {
338: int LeapSw;
339: int DayCnt;
340:
341: LeapSw = GoodLeap(year);
342: DayCnt = (int)days_per_year(year);
343:
344: if ( ( LeapSw ? 366 : 365 ) != DayCnt )
345: {
346: Error(year);
347: fprintf( stdout,
348: " days_per_year() %4d %2d %3d *** ERROR\n",
349: year, LeapSw, DayCnt );
350: break;
351: }
352: }
353:
354: /* test (what is now julian0) calculations */
355:
356: Days1970 = Days( 1970 ); /* get days since 1970 using a known good */
357:
358: for ( year = 1970; year < yearend; year++ )
359: {
360: unsigned long t;
361: long DaysYear ;
362:
363: clock_time->year = year;
364:
365: /* here is the code we are testing, cut and pasted out of the source */
366: #if 0 /* old BUGGY code that has Y2K (and many other) failures */
367: /* ghealton: this logic FAILED with great frequency when run
368: * over a period of time, including for year 2000. True, it
369: * had more successes than failures, but that's not really good
370: * enough for critical time distribution software.
371: * It is so awful I wonder if it has had a history of failure
372: * and fixes? */
373: t = (clock_time->year - 1970) * 365;
374: t += (clock_time->year >> 2) - (1970 >> 2);
375: t -= clock_time->year / 100 - 1970 / 100;
376: t += clock_time->year / 400 - 1970 / 400;
377:
378: /* (immediate feare of rounding errors on integer
379: * **divisions proved well founded) */
380:
381: #else
382: /* my replacement, based on Days() above */
383: t = julian0(year) - julian0(1970);
384: #endif
385:
386: /* compare result in t against trusted calculations */
387: DaysYear = Days( year ); /* get days to this year */
388: if ( t != DaysYear - Days1970 )
389: {
390: Error(year);
391: fprintf( stdout,
392: " %4d 1970=%-8ld %4d=%-8ld %-3ld t=%-8ld *** ERROR ***\n",
393: year, (long)Days1970,
394: year,
395: (long)DaysYear,
396: (long)(DaysYear - Days1970),
397: (long)t );
398: }
399: }
400:
401: #if 1 /* { */
402: {
403: debug = 1; /* enable debugging */
404: for ( year = 1970; year < yearend; year++ )
405: { /* (limited by theory unix 2038 related bug lives by, but
406: * ends in yearend) */
407: clocktime_t ct;
408: time_t Observed;
409: time_t Expected;
410: u_long Flag;
411: unsigned long t;
412:
413: ct.day = 1;
414: ct.month = 1;
415: ct.year = year;
416: ct.hour = ct.minute = ct.second = ct.usecond = 0;
417: ct.utcoffset = 0;
418: ct.utctime = 0;
419: ct.flags = 0;
420:
421: Flag = 0;
422: Observed = parse_to_unixtime( &ct, &Flag );
423: if ( ct.year != year )
424: {
425: fprintf( stdout,
426: "%04d: parse_to_unixtime(,%d) CORRUPTED ct.year: was %d\n",
427: (int)year, (int)Flag, (int)ct.year );
428: Error(year);
429: break;
430: }
431: t = julian0(year) - julian0(1970); /* Julian day from 1970 */
432: Expected = t * 24 * 60 * 60;
433: if ( Observed != Expected || Flag )
434: { /* time difference */
435: fprintf( stdout,
436: "%04d: parse_to_unixtime(,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
437: year, (int)Flag,
438: (unsigned long)Observed, (unsigned long)Expected,
439: ((long)Observed - (long)Expected) );
440: Error(year);
441: break;
442: }
443:
444: if ( year >= YEAR_PIVOT+1900 )
445: {
446: /* check year % 100 code we put into parse_to_unixtime() */
447: ct.utctime = 0;
448: ct.year = year % 100;
449: Flag = 0;
450:
451: Observed = parse_to_unixtime( &ct, &Flag );
452:
453: if ( Observed != Expected || Flag )
454: { /* time difference */
455: fprintf( stdout,
456: "%04d: parse_to_unixtime(%d,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
457: year, (int)ct.year, (int)Flag,
458: (unsigned long)Observed, (unsigned long)Expected,
459: ((long)Observed - (long)Expected) );
460: Error(year);
461: break;
462: }
463:
464: /* check year - 1900 code we put into parse_to_unixtime() */
465: ct.utctime = 0;
466: ct.year = year - 1900;
467: Flag = 0;
468:
469: Observed = parse_to_unixtime( &ct, &Flag );
470:
471: if ( Observed != Expected || Flag )
472: { /* time difference */
473: fprintf( stdout,
474: "%04d: parse_to_unixtime(%d,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
475: year, (int)ct.year, (int)Flag,
476: (unsigned long)Observed, (unsigned long)Expected,
477: ((long)Observed - (long)Expected) );
478: Error(year);
479: break;
480: }
481:
482:
483: }
484: }
485: #endif /* } */
486: }
487: }
488:
489: puts( " libntp/caljulian.c" );
490: { /* test caljulian() */
491: struct calendar ot;
492: u_long ntp_time; /* NTP time */
493:
494: year = year0; /* calculate the basic year */
495: printf( " starting year %04d\n", (int)year0 );
496: printf( " ending year %04d\n", (int)yearend );
497:
498:
499: ntp_time = julian0( year0 ); /* NTP starts in 1900-01-01 */
500: #if DAY_NTP_STARTS == 693596
501: ntp_time -= 365; /* BIAS required for successful test */
502: #endif
503: if ( DAY_NTP_STARTS != ntp_time )
504: {
505: Error(year);
506: fprintf( stdout,
507: "%04d: DAY_NTP_STARTS (%ld) NOT TRUE VALUE OF %ld (%ld)\n",
508: (int)year0,
509: (long)DAY_NTP_STARTS, (long)ntp_time,
510: (long)DAY_NTP_STARTS - (long)ntp_time );
511: }
512:
513: for ( ; year < yearend; year++ )
514: {
515:
516: /* 01-01 for the current year */
517: ntp_time = Days( year ) - Days( year0 ); /* days into NTP time */
518: ntp_time *= 24 * 60 * 60; /* convert into seconds */
519: caljulian( ntp_time, &ot ); /* convert January 1 */
520: if ( ot.year != year
521: || ot.month != 1
522: || ot.monthday != 1 )
523: {
524: Error(year);
525: fprintf( stdout, "%lu: EXPECTED %04d-01-01: FOUND %04d-%02d-%02d\n",
526: (unsigned long)ntp_time,
527: year,
528: (int)ot.year, (int)ot.month, (int)ot.monthday );
529: break;
530: }
531:
532: ntp_time += (31 + 28-1) * ( 24 * 60 * 60 ); /* advance to 02-28 */
533: caljulian( ntp_time, &ot ); /* convert Feb 28 */
534: if ( ot.year != year
535: || ot.month != 2
536: || ot.monthday != 28 )
537: {
538: Error(year);
539: fprintf( stdout, "%lu: EXPECTED %04d-02-28: FOUND %04d-%02d-%02d\n",
540: (unsigned long)ntp_time,
541: year,
542: (int)ot.year, (int)ot.month, (int)ot.monthday );
543: break;
544: }
545:
546: {
547: int m; /* expected month */
548: int d; /* expected day */
549:
550: m = isleap_4(year) ? 2 : 3;
551: d = isleap_4(year) ? 29 : 1;
552:
553: ntp_time += ( 24 * 60 * 60 ); /* advance to the next day */
554: caljulian( ntp_time, &ot ); /* convert this day */
555: if ( ot.year != year
556: || ot.month != m
557: || ot.monthday != d )
558: {
559: Error(year);
560: fprintf( stdout, "%lu: EXPECTED %04d-%02d-%02d: FOUND %04d-%02d-%02d\n",
561: (unsigned long)ntp_time,
562: year, m, d,
563: (int)ot.year, (int)ot.month, (int)ot.monthday );
564: break;
565: }
566:
567: }
568: }
569: }
570:
571: puts( " libntp/caltontp.c" );
572: { /* test caltontp() */
573: struct calendar ot;
574: u_long ntp_time; /* NTP time */
575:
576: year = year0; /* calculate the basic year */
577: printf( " starting year %04d\n", (int)year0 );
578: printf( " ending year %04d\n", (int)yearend );
579:
580:
581: for ( ; year < yearend; year++ )
582: {
583: u_long ObservedNtp;
584:
585: /* 01-01 for the current year */
586: ot.year = year;
587: ot.month = ot.monthday = 1; /* unused, but set anyway JIC */
588: ot.yearday = 1; /* this is the magic value used by caltontp() */
589: ot.hour = ot.minute = ot.second = 0;
590:
591: ntp_time = Days( year ) - Days( year0 ); /* days into NTP time */
592: ntp_time *= 24 * 60 * 60; /* convert into seconds */
593: ObservedNtp = caltontp( &ot );
594: if ( ntp_time != ObservedNtp )
595: {
596: Error(year);
597: fprintf( stdout, "%d: EXPECTED %lu: FOUND %lu (%ld)\n",
598: (int)year,
599: (unsigned long)ntp_time, (unsigned long)ObservedNtp ,
600: (long)ntp_time - (long)ObservedNtp );
601:
602: break;
603: }
604:
605: /* now call caljulian as a type of failsafe supercheck */
606: caljulian( ObservedNtp, &ot ); /* convert January 1 */
607: if ( ot.year != year
608: || ot.month != 1
609: || ot.monthday != 1 )
610: {
611: Error(year);
612: fprintf( stdout, "%lu: caljulian FAILSAFE EXPECTED %04d-01-01: FOUND %04d-%02d-%02d\n",
613: (unsigned long)ObservedNtp,
614: year,
615: (int)ot.year, (int)ot.month, (int)ot.monthday );
616: break;
617: }
618: }
619: }
620:
621: if ( Warnings > 0 )
622: fprintf( stdout, "%d WARNINGS\n", Warnings );
623: if ( Fatals > 0 )
624: fprintf( stdout, "%d FATAL ERRORS\n", Fatals );
625: return Fatals ? 1 : 0;
626: }
627: /* Y2KFixes ] */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to check_y2k.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd