#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ntpd.h"
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#include <stdio.h>
#include <errno.h>
#ifndef SYS_WINNT
# if !defined(VMS)
# include <sys/param.h>
# endif
# if HAVE_SYS_SIGNAL_H
# include <sys/signal.h>
# endif
# include <sys/signal.h>
# ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
# endif
# if !defined(VMS)
# include <sys/resource.h>
# endif
#else
# include <signal.h>
# include <process.h>
# include <io.h>
# include "../libntp/log.h"
#endif
#if defined(HAVE_RTPRIO)
# ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
# endif
# ifdef HAVE_SYS_LOCK_H
# include <sys/lock.h>
# endif
# include <sys/rtprio.h>
#else
# ifdef HAVE_PLOCK
# ifdef HAVE_SYS_LOCK_H
# include <sys/lock.h>
# endif
# endif
#endif
#if defined(HAVE_SCHED_SETSCHEDULER)
# ifdef HAVE_SCHED_H
# include <sched.h>
# else
# ifdef HAVE_SYS_SCHED_H
# include <sys/sched.h>
# endif
# endif
#endif
#if defined(HAVE_SYS_MMAN_H)
# include <sys/mman.h>
#endif
#ifdef HAVE_TERMIOS_H
# include <termios.h>
#endif
#ifdef SYS_DOMAINOS
# include <apollo/base.h>
#endif
#include "ntp_calendar.h"
#include "parse.h"
#define GoodLeap(Year) (((Year)%4 || (!((Year)%100) && (Year)%400)) ? 0 : 13 )
char const *progname = "check_y2k";
long
Days ( int Year )
{
long Return;
Return = Year * 365;
if ( Year >= 1 )
{
Return += (Year+3) / 4;
Return -= (Year-1) / 100;
Return += (Year-1) / 400;
}
return Return;
}
static int year0 = 1900;
static int yearend;
static time_t Time;
static struct tm LocalTime;
#define Error(year) if ( (year)>=2036 && LocalTime.tm_year < 110 ) \
Warnings++; else Fatals++
int
main( void )
{
int Fatals;
int Warnings;
int year;
Time = time( (time_t *)NULL )
#ifdef TESTTIMEOFFSET
+ test_time_offset
#endif
;
LocalTime = *localtime( &Time );
year = ( sizeof( u_long ) > 4 )
? ( 400 * 3 )
: ((int)(0x7FFFFFFF / 365.242 / 24/60/60)* 2 );
yearend = year0 + year;
puts( " internal self check" );
{
unsigned long days;
if ( year0 >= yearend )
{
fprintf( stdout, "year0=%d NOT LESS THAN yearend=%d (span=%d)\n",
(int)year0, (int)yearend, (int)year );
exit(2);
}
{
int save_year;
save_year = LocalTime.tm_year;
year = 1980;
LocalTime.tm_year = year - 1900;
Fatals = Warnings = 0;
Error(year);
if ( Fatals == 0 )
{
fprintf( stdout,
"%4d: %s(%d): FATAL DID NOT INCREMENT (Fatals=%d Warnings=%d)\n",
(int)year, __FILE__, __LINE__, (int)Fatals, (int)Warnings );
exit(2);
}
year = 2100;
Fatals = Warnings = 0;
Error(year);
if ( Warnings == 0 )
{
fprintf( stdout,
"%4d: %s(%d): WARNING DID NOT INCREMENT (Fatals=%d Warnings=%d)\n",
(int)year, __FILE__, __LINE__, (int)Fatals, (int)Warnings );
exit(2);
}
Fatals = Warnings = 0;
LocalTime.tm_year = year - 1900;
Error(1980);
if ( Fatals == 0 )
{
fprintf( stdout,
"%4d: %s(%d): FATALS DID NOT INCREMENT (Fatals=%d Warnings=%d)\n",
(int)year, __FILE__, __LINE__, (int)Fatals, (int)Warnings );
exit(2);
}
LocalTime.tm_year = save_year;
}
days = 365+1;
for ( year = 1; year <= 2500; year++ )
{
long Test;
Test = Days( year );
if ( days != Test )
{
fprintf( stdout, "%04d: Days() DAY COUNT ERROR: s/b=%ld was=%ld\n",
year, (long)days, (long)Test );
exit(2);
}
Test = julian0(year);
if ( days != Test )
{
fprintf( stdout, "%04d: julian0() DAY COUNT ERROR: s/b=%ld was=%ld\n",
year, (long)days, (long)Test );
exit(2);
}
days += 365;
if ( isleap_4(year) ) days++;
}
if ( isleap_4(1999) )
{
fprintf( stdout, "isleap_4(1999) REPORTED TRUE\n" );
exit(2);
}
if ( !isleap_4(2000) )
{
fprintf( stdout, "isleap_4(2000) REPORTED FALSE\n" );
exit(2);
}
if ( isleap_4(2001) )
{
fprintf( stdout, "isleap_4(1999) REPORTED TRUE\n" );
exit(2);
}
if ( !isleap_tm(2000-1900) )
{
fprintf( stdout, "isleap_tm(100) REPORTED FALSE\n" );
exit(2);
}
}
Fatals = Warnings = 0;
puts( " include/ntp.h" );
{
for ( year = 1400; year <= 2200; year++ )
{
int LeapSw;
int IsLeapSw;
LeapSw = GoodLeap(year);
IsLeapSw = isleap_4(year);
if ( !!LeapSw != !!IsLeapSw )
{
Error(year);
fprintf( stdout,
" %4d %2d %3d *** ERROR\n", year, LeapSw, IsLeapSw );
break;
}
IsLeapSw = isleap_tm(year-1900);
if ( !!LeapSw != !!IsLeapSw )
{
Error(year);
fprintf( stdout,
" %4d %2d %3d *** ERROR\n", year, LeapSw, IsLeapSw );
break;
}
}
}
puts( " include/ntp_calendar.h" );
{
#define is_leapyear(y) (y%4 == 0 && !(y%100 == 0 && !(y%400 == 0)))
for ( year = 1400; year <= 2200; year++ )
{
int LeapSw;
LeapSw = GoodLeap(year);
if ( !(!LeapSw) != !(!is_leapyear(year)) )
{
Error(year);
fprintf( stdout,
" %4d %2d *** ERROR\n", year, LeapSw );
break;
}
}
}
puts( " libparse/parse.c" );
{
long Days1970;
struct ParseTime
{
int year;
} Clock_Time, *clock_time;
clock_time = &Clock_Time;
#define days_per_year(x) ((x) % 4 ? 365 : ((x % 400) ? ((x % 100) ? 366 : 365) : 366))
for ( year = 1400; year <= 2200; year++ )
{
int LeapSw;
int DayCnt;
LeapSw = GoodLeap(year);
DayCnt = (int)days_per_year(year);
if ( ( LeapSw ? 366 : 365 ) != DayCnt )
{
Error(year);
fprintf( stdout,
" days_per_year() %4d %2d %3d *** ERROR\n",
year, LeapSw, DayCnt );
break;
}
}
Days1970 = Days( 1970 );
for ( year = 1970; year < yearend; year++ )
{
unsigned long t;
long DaysYear ;
clock_time->year = year;
#if 0
t = (clock_time->year - 1970) * 365;
t += (clock_time->year >> 2) - (1970 >> 2);
t -= clock_time->year / 100 - 1970 / 100;
t += clock_time->year / 400 - 1970 / 400;
#else
t = julian0(year) - julian0(1970);
#endif
DaysYear = Days( year );
if ( t != DaysYear - Days1970 )
{
Error(year);
fprintf( stdout,
" %4d 1970=%-8ld %4d=%-8ld %-3ld t=%-8ld *** ERROR ***\n",
year, (long)Days1970,
year,
(long)DaysYear,
(long)(DaysYear - Days1970),
(long)t );
}
}
#if 1
{
debug = 1;
for ( year = 1970; year < yearend; year++ )
{
clocktime_t ct;
time_t Observed;
time_t Expected;
u_long Flag;
unsigned long t;
ct.day = 1;
ct.month = 1;
ct.year = year;
ct.hour = ct.minute = ct.second = ct.usecond = 0;
ct.utcoffset = 0;
ct.utctime = 0;
ct.flags = 0;
Flag = 0;
Observed = parse_to_unixtime( &ct, &Flag );
if ( ct.year != year )
{
fprintf( stdout,
"%04d: parse_to_unixtime(,%d) CORRUPTED ct.year: was %d\n",
(int)year, (int)Flag, (int)ct.year );
Error(year);
break;
}
t = julian0(year) - julian0(1970);
Expected = t * 24 * 60 * 60;
if ( Observed != Expected || Flag )
{
fprintf( stdout,
"%04d: parse_to_unixtime(,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
year, (int)Flag,
(unsigned long)Observed, (unsigned long)Expected,
((long)Observed - (long)Expected) );
Error(year);
break;
}
if ( year >= YEAR_PIVOT+1900 )
{
ct.utctime = 0;
ct.year = year % 100;
Flag = 0;
Observed = parse_to_unixtime( &ct, &Flag );
if ( Observed != Expected || Flag )
{
fprintf( stdout,
"%04d: parse_to_unixtime(%d,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
year, (int)ct.year, (int)Flag,
(unsigned long)Observed, (unsigned long)Expected,
((long)Observed - (long)Expected) );
Error(year);
break;
}
ct.utctime = 0;
ct.year = year - 1900;
Flag = 0;
Observed = parse_to_unixtime( &ct, &Flag );
if ( Observed != Expected || Flag )
{
fprintf( stdout,
"%04d: parse_to_unixtime(%d,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
year, (int)ct.year, (int)Flag,
(unsigned long)Observed, (unsigned long)Expected,
((long)Observed - (long)Expected) );
Error(year);
break;
}
}
}
#endif
}
}
puts( " libntp/caljulian.c" );
{
struct calendar ot;
u_long ntp_time;
year = year0;
printf( " starting year %04d\n", (int)year0 );
printf( " ending year %04d\n", (int)yearend );
ntp_time = julian0( year0 );
#if DAY_NTP_STARTS == 693596
ntp_time -= 365;
#endif
if ( DAY_NTP_STARTS != ntp_time )
{
Error(year);
fprintf( stdout,
"%04d: DAY_NTP_STARTS (%ld) NOT TRUE VALUE OF %ld (%ld)\n",
(int)year0,
(long)DAY_NTP_STARTS, (long)ntp_time,
(long)DAY_NTP_STARTS - (long)ntp_time );
}
for ( ; year < yearend; year++ )
{
ntp_time = Days( year ) - Days( year0 );
ntp_time *= 24 * 60 * 60;
caljulian( ntp_time, &ot );
if ( ot.year != year
|| ot.month != 1
|| ot.monthday != 1 )
{
Error(year);
fprintf( stdout, "%lu: EXPECTED %04d-01-01: FOUND %04d-%02d-%02d\n",
(unsigned long)ntp_time,
year,
(int)ot.year, (int)ot.month, (int)ot.monthday );
break;
}
ntp_time += (31 + 28-1) * ( 24 * 60 * 60 );
caljulian( ntp_time, &ot );
if ( ot.year != year
|| ot.month != 2
|| ot.monthday != 28 )
{
Error(year);
fprintf( stdout, "%lu: EXPECTED %04d-02-28: FOUND %04d-%02d-%02d\n",
(unsigned long)ntp_time,
year,
(int)ot.year, (int)ot.month, (int)ot.monthday );
break;
}
{
int m;
int d;
m = isleap_4(year) ? 2 : 3;
d = isleap_4(year) ? 29 : 1;
ntp_time += ( 24 * 60 * 60 );
caljulian( ntp_time, &ot );
if ( ot.year != year
|| ot.month != m
|| ot.monthday != d )
{
Error(year);
fprintf( stdout, "%lu: EXPECTED %04d-%02d-%02d: FOUND %04d-%02d-%02d\n",
(unsigned long)ntp_time,
year, m, d,
(int)ot.year, (int)ot.month, (int)ot.monthday );
break;
}
}
}
}
puts( " libntp/caltontp.c" );
{
struct calendar ot;
u_long ntp_time;
year = year0;
printf( " starting year %04d\n", (int)year0 );
printf( " ending year %04d\n", (int)yearend );
for ( ; year < yearend; year++ )
{
u_long ObservedNtp;
ot.year = year;
ot.month = ot.monthday = 1;
ot.yearday = 1;
ot.hour = ot.minute = ot.second = 0;
ntp_time = Days( year ) - Days( year0 );
ntp_time *= 24 * 60 * 60;
ObservedNtp = caltontp( &ot );
if ( ntp_time != ObservedNtp )
{
Error(year);
fprintf( stdout, "%d: EXPECTED %lu: FOUND %lu (%ld)\n",
(int)year,
(unsigned long)ntp_time, (unsigned long)ObservedNtp ,
(long)ntp_time - (long)ObservedNtp );
break;
}
caljulian( ObservedNtp, &ot );
if ( ot.year != year
|| ot.month != 1
|| ot.monthday != 1 )
{
Error(year);
fprintf( stdout, "%lu: caljulian FAILSAFE EXPECTED %04d-01-01: FOUND %04d-%02d-%02d\n",
(unsigned long)ObservedNtp,
year,
(int)ot.year, (int)ot.month, (int)ot.monthday );
break;
}
}
}
if ( Warnings > 0 )
fprintf( stdout, "%d WARNINGS\n", Warnings );
if ( Fatals > 0 )
fprintf( stdout, "%d FATAL ERRORS\n", Fatals );
return Fatals ? 1 : 0;
}