1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
/*
* prettydate - convert a time stamp to something readable
*/
#include <config.h>
#include <stdio.h>
#include "ntp_fp.h"
#include "ntp_unixtime.h" /* includes <sys/time.h> */
#include "lib_strbuf.h"
#include "ntp_stdlib.h"
#include "ntp_assert.h"
#include "ntp_calendar.h"
#if SIZEOF_TIME_T < 4
# error sizeof(time_t) < 4 -- this will not work!
#endif
static char *common_prettydate(l_fp *, int);
const char * const months[12] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
const char * const daynames[7] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
/* Helper function to handle possible wraparound of the ntp epoch.
*
* Works by periodic extension of the ntp time stamp in the UN*X epoch.
* If the 'time_t' is 32 bit, use solar cycle warping to get the value
* in a suitable range. Also uses solar cycle warping to work around
* really buggy implementations of 'gmtime()' / 'localtime()' that
* cannot work with a negative time value, that is, times before
* 1970-01-01. (MSVCRT...)
*
* Apart from that we're assuming that the localtime/gmtime library
* functions have been updated so that they work...
*
* An explanation: The julian calendar repeats ever 28 years, because
* it's the LCM of 7 and 1461, the week and leap year cycles. This is
* called a 'solar cycle'. The gregorian calendar does the same as
* long as no centennial year (divisible by 100, but not 400) goes in
* the way. So between 1901 and 2099 (inclusive) we can warp time
* stamps by 28 years to make them suitable for localtime() and
* gmtime() if we have trouble. Of course this will play hubbubb with
* the DST zone switches, so we should do it only if necessary; but as
* we NEED a proper conversion to dates via gmtime() we should try to
* cope with as many idiosyncrasies as possible.
*
*/
/*
* solar cycle in unsigned secs and years, and the cycle limits.
*/
#define SOLAR_CYCLE_SECS 0x34AADC80UL /* 7*1461*86400*/
#define SOLAR_CYCLE_YEARS 28
#define MINFOLD -3
#define MAXFOLD 3
static struct tm *
get_struct_tm(
const vint64 *stamp,
int local)
{
struct tm *tm = NULL;
int32 folds = 0;
time_t ts;
#ifdef HAVE_INT64
int64 tl;
ts = tl = stamp->q_s;
/*
* If there is chance of truncation, try to fix it. Let the
* compiler find out if this can happen at all.
*/
while (ts != tl) { /* truncation? */
if (tl < 0) {
if (--folds < MINFOLD)
return NULL;
tl += SOLAR_CYCLE_SECS;
} else {
if (++folds > MAXFOLD)
return NULL;
tl -= SOLAR_CYCLE_SECS;
}
ts = tl; /* next try... */
}
#else
/*
* since we do not have 64-bit scalars, it's not likely we have
* 64-bit time_t. Assume 32 bits and properly reduce the value.
*/
u_int32 hi, lo;
hi = stamp->D_s.hi;
lo = stamp->D_s.lo;
while ((hi && ~hi) || ((hi ^ lo) & 0x80000000u)) {
if (M_ISNEG(hi, lo)) {
if (--folds < MINFOLD)
return NULL;
M_ADD(hi, lo, 0, SOLAR_CYCLE_SECS);
} else {
if (++folds > MAXFOLD)
return NULL;
M_SUB(hi, lo, 0, SOLAR_CYCLE_SECS);
}
}
ts = (int32)lo;
#endif
/*
* 'ts' should be a suitable value by now. Just go ahead, but
* with care:
*
* There are some pathological implementations of 'gmtime()'
* and 'localtime()' out there. No matter if we have 32-bit or
* 64-bit 'time_t', try to fix this by solar cycle warping
* again...
*
* At least the MSDN says that the (Microsoft) Windoze
* versions of 'gmtime()' and 'localtime()' will bark on time
* stamps < 0.
*/
while ((tm = (*(local ? localtime : gmtime))(&ts)) == NULL)
if (ts < 0) {
if (--folds < MINFOLD)
return NULL;
ts += SOLAR_CYCLE_SECS;
} else if (ts >= (time_t)SOLAR_CYCLE_SECS) {
if (++folds > MAXFOLD)
return NULL;
ts -= SOLAR_CYCLE_SECS;
} else
return NULL; /* That's truly pathological! */
/* 'tm' surely not NULL here! */
INSIST(tm != NULL);
if (folds != 0) {
tm->tm_year += folds * SOLAR_CYCLE_YEARS;
if (tm->tm_year <= 0 || tm->tm_year >= 200)
return NULL; /* left warp range... can't help here! */
}
return tm;
}
static char *
common_prettydate(
l_fp *ts,
int local
)
{
static const char pfmt0[] =
"%08lx.%08lx %s, %s %2d %4d %2d:%02d:%02d.%03u";
static const char pfmt1[] =
"%08lx.%08lx [%s, %s %2d %4d %2d:%02d:%02d.%03u UTC]";
char *bp;
struct tm *tm;
u_int msec;
u_int32 ntps;
vint64 sec;
LIB_GETBUF(bp);
if (ts->l_ui == 0 && ts->l_uf == 0) {
strlcpy (bp, "(no time)", LIB_BUFLENGTH);
return (bp);
}
/* get & fix milliseconds */
ntps = ts->l_ui;
msec = ts->l_uf / 4294967; /* fract / (2 ** 32 / 1000) */
if (msec >= 1000u) {
msec -= 1000u;
ntps++;
}
sec = ntpcal_ntp_to_time(ntps, NULL);
tm = get_struct_tm(&sec, local);
if (!tm) {
/*
* get a replacement, but always in UTC, using
* ntpcal_time_to_date()
*/
struct calendar jd;
ntpcal_time_to_date(&jd, &sec);
snprintf(bp, LIB_BUFLENGTH, local ? pfmt1 : pfmt0,
(u_long)ts->l_ui, (u_long)ts->l_uf,
daynames[jd.weekday], months[jd.month-1],
jd.monthday, jd.year, jd.hour,
jd.minute, jd.second, msec);
} else
snprintf(bp, LIB_BUFLENGTH, pfmt0,
(u_long)ts->l_ui, (u_long)ts->l_uf,
daynames[tm->tm_wday], months[tm->tm_mon],
tm->tm_mday, 1900 + tm->tm_year, tm->tm_hour,
tm->tm_min, tm->tm_sec, msec);
return bp;
}
char *
prettydate(
l_fp *ts
)
{
return common_prettydate(ts, 1);
}
char *
gmprettydate(
l_fp *ts
)
{
return common_prettydate(ts, 0);
}
struct tm *
ntp2unix_tm(
u_int32 ntp, int local
)
{
vint64 vl;
vl = ntpcal_ntp_to_time(ntp, NULL);
return get_struct_tm(&vl, local);
}
|
