diff options
author | Lorry Tar Creator <lorry-tar-importer@baserock.org> | 2014-12-02 09:01:21 +0000 |
---|---|---|
committer | <> | 2014-12-04 16:11:25 +0000 |
commit | bdab5265fcbf3f472545073a23f8999749a9f2b9 (patch) | |
tree | c6018dd03dea906f8f1fb5f105f05b71a7dc250a /libntp/clocktime.c | |
download | ntp-d4b7cd9723cce9561fa15f74b90b85a3a61b5ef8.tar.gz |
Imported from /home/lorry/working-area/delta_ntp/ntp-dev-4.2.7p482.tar.gz.ntp-dev-4.2.7p482
Diffstat (limited to 'libntp/clocktime.c')
-rw-r--r-- | libntp/clocktime.c | 149 |
1 files changed, 149 insertions, 0 deletions
diff --git a/libntp/clocktime.c b/libntp/clocktime.c new file mode 100644 index 0000000..c1a3ba0 --- /dev/null +++ b/libntp/clocktime.c @@ -0,0 +1,149 @@ +/* + * clocktime - compute the NTP date from a day of year, hour, minute + * and second. + */ +#include <config.h> +#include "ntp_fp.h" +#include "ntp_unixtime.h" +#include "ntp_stdlib.h" +#include "ntp_calendar.h" + +/* + * We check that the time be within CLOSETIME seconds of the receive + * time stamp. This is about 4 hours, which hopefully should be wide + * enough to collect most data, while close enough to keep things from + * getting confused. + */ +#define CLOSETIME (4u*60u*60u) + +/* + * Since we try to match years, the result of a full search will not + * change when we are already less than a half year from the receive + * time stamp. Since the length of a year is variable we use a + * slightly narrower limit; this might require a full evaluation near + * the edge, but will make sure we always get the correct result. + */ +#define NEARTIME (182u * SECSPERDAY) + +/* + * local calendar helpers + */ +static int32 ntp_to_year(u_int32); +static u_int32 year_to_ntp(int32); + +/* + * Take a time spec given as day-of-year, hour, minute and second as + * well as a GMT offset in hours and convert it to a NTP time stamp in + * '*ts_ui'. The value will be in the range (rec_ui-0.5yrs) to + * (rec_ui+0.5yrs). A hint for the current start-of-year will be + * read from '*yearstart'. + * + * On return '*ts_ui' will always the best matching solution, and + * '*yearstart' will receive the associated start-of-year. + * + * The function will tell if the result in 'ts_ui' is in CLOSETIME + * (+/-4hrs) around the receive time by returning a non-zero value. + * + * Note: The function puts no constraints on the value ranges for the + * time specification, but evaluates the effective seconds in + * 32-bit arithmetic. + */ +int +clocktime( + int yday , /* day-of-year */ + int hour , /* hour of day */ + int minute , /* minute of hour */ + int second , /* second of minute */ + int tzoff , /* hours west of GMT */ + u_int32 rec_ui , /* pivot value */ + u_long *yearstart, /* cached start-of-year, should be fixed to u_int32 */ + u_int32 *ts_ui ) /* effective time stamp */ +{ + u_int32 ystt[3]; /* year start */ + u_int32 test[3]; /* result time stamp */ + u_int32 diff[3]; /* abs difference to receive */ + int32 y, tmp, idx, min; + + /* + * Compute the offset into the year in seconds. Note that + * this could come out to be a negative number. + */ + tmp = ((int32)second + + SECSPERMIN * ((int32)minute + + MINSPERHR * ((int32)hour + (int32)tzoff + + HRSPERDAY * ((int32)yday - 1)))); + /* + * Based on the cached year start, do a first attempt. Be + * happy and return if this gets us better than NEARTIME to + * the receive time stamp. Do this only if the cached year + * start is not zero, which will not happen after 1900 for the + * next few thousand years. + */ + if (*yearstart) { + /* -- get time stamp of potential solution */ + test[0] = (u_int32)(*yearstart) + tmp; + /* -- calc absolute difference to receive time */ + diff[0] = test[0] - rec_ui; + if (diff[0] >= 0x80000000u) + diff[0] = ~diff[0] + 1; + /* -- can't get closer if diff < NEARTIME */ + if (diff[0] < NEARTIME) { + *ts_ui = test[0]; + return diff[0] < CLOSETIME; + } + } + + /* + * Now the dance begins. Based on the receive time stamp and + * the seconds offset in 'tmp', we make an educated guess + * about the year to start with. This takes us on the spot + * with a fuzz of +/-1 year. + * + * We calculate the effective timestamps for the three years + * around the guess and select the entry with the minimum + * absolute difference to the receive time stamp. + */ + y = ntp_to_year(rec_ui - tmp); + for (idx = 0; idx < 3; idx++) { + /* -- get year start of potential solution */ + ystt[idx] = year_to_ntp(y + idx - 1); + /* -- get time stamp of potential solution */ + test[idx] = ystt[idx] + tmp; + /* -- calc absolute difference to receive time */ + diff[idx] = test[idx] - rec_ui; + if (diff[idx] >= 0x80000000u) + diff[idx] = ~diff[idx] + 1; + } + /* -*- assume current year fits best, then search best fit */ + for (min = 1, idx = 0; idx < 3; idx++) + if (diff[idx] < diff[min]) + min = idx; + /* -*- store results and update year start */ + *ts_ui = test[min]; + *yearstart = ystt[min]; + + /* -*- tell if we could get into CLOSETIME*/ + return diff[min] < CLOSETIME; +} + +static int32 +ntp_to_year( + u_int32 ntp) +{ + vint64 t; + ntpcal_split s; + + t = ntpcal_ntp_to_ntp(ntp, NULL); + s = ntpcal_daysplit(&t); + s = ntpcal_split_eradays(s.hi + DAY_NTP_STARTS - 1, NULL); + return s.hi + 1; +} + +static u_int32 +year_to_ntp( + int32 year) +{ + u_int32 days; + days = ntpcal_days_in_years(year-1) - DAY_NTP_STARTS + 1; + return days * SECSPERDAY; +} |