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
|
/* sntp.c - sntp client and server
*
* Copyright 2019 Rob Landley <rob@landley.net>
*
* See https://www.ietf.org/rfc/rfc4330.txt
modes: oneshot display, oneshot set, persist, serve, multi
USE_SNTP(NEWTOY(sntp, "M:m:Sp:asdDqr#<4>17=10[!as]", TOYFLAG_USR|TOYFLAG_BIN))
config SNTP
bool "sntp"
default y
help
usage: sntp [-saSdDqm] [-r SHIFT] [-m ADDRESS] [-p PORT] [SERVER]
Simple Network Time Protocol client. Query SERVER and display time.
-p Use PORT (default 123)
-s Set system clock suddenly
-a Adjust system clock gradually
-S Serve time instead of querying (bind to SERVER address if specified)
-m Wait for updates from multicast ADDRESS (RFC 4330 says use 224.0.1.1)
-M Multicast server on ADDRESS
-d Daemonize (run in background re-querying )
-D Daemonize but stay in foreground: re-query time every 1000 seconds
-r Retry shift (every 1<<SHIFT seconds)
-q Quiet (don't display time)
*/
#define FOR_sntp
#include "toys.h"
GLOBALS(
long r;
char *p, *m, *M;
)
// Seconds from 1900 to 1970, including appropriate leap days
#define SEVENTIES 2208988800L
// Get time and return ntptime (saving timespec in pointer if not null)
// NTP time is high 32 bits = seconds since 1970 (blame RFC 868), low 32 bits
// fraction of a second.
// diff is how far off we think our clock is from reality (in nanoseconds)
static unsigned long long lunchtime(struct timespec *television, long long diff)
{
struct timespec tv;
clock_gettime(CLOCK_REALTIME, &tv);
if (diff) nanomove(&tv, diff);
if (television) *television = tv;
// Unix time is 1970 but RFCs 868 and 958 said 1900 so add seconds 1900->1970
// If they'd done a 34/30 bit split the Y2036 problem would be centuries
// from now and still give us nanosecond accuracy, but no...
return ((tv.tv_sec+SEVENTIES)<<32)+(((long long)tv.tv_nsec)<<32)/1000000000;
}
// convert ntptime back to struct timespec.
static void doublyso(unsigned long long now, struct timespec *tv)
{
// Y2036 fixup: if time wrapped, it's in the future
tv->tv_sec = (now>>32) + (1LL<<32)*!(now&(1LL<<63));
tv->tv_sec -= SEVENTIES; // Force signed math for Y2038 fixup
tv->tv_nsec = ((now&0xFFFFFFFF)*1000000000)>>32;
}
void sntp_main(void)
{
struct timespec tv, tv2;
unsigned long long *pktime = (void *)toybuf, now, then, before = before;
long long diff = 0;
struct addrinfo *ai;
union socksaddr sa;
int fd, tries = 0;
if (!(FLAG(S)||FLAG(m)) && !*toys.optargs)
error_exit("Need -Sm or SERVER address");
// Lookup address and open server or client UDP socket
if (!TT.p || !*TT.p) TT.p = "123";
ai = xgetaddrinfo(*toys.optargs, TT.p, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
AI_PASSIVE*!*toys.optargs);
if (FLAG(d) && daemon(0, 0)) perror_exit("daemonize");
// Act as server if necessary
if (FLAG(S)|FLAG(m)) {
fd = xbindany(ai);
if (TT.m) {
struct ip_mreq group;
// subscribe to multicast group
memset(&group, 0, sizeof(group));
group.imr_multiaddr.s_addr = inet_addr(TT.m);
xsetsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group));
}
} else fd = xsocket(ai->ai_family, SOCK_DGRAM, IPPROTO_UDP);
// -Sm = loop waiting for input
// -Dd = loop polling time and waiting until next poll period
// Otherwise poll up to 3 times to get 2 responses, then exit
// loop sending/receiving packets
for (;;) {
now = millitime();
// Figure out if we're in server and multicast modes don't poll
if (FLAG(m) || FLAG(S)) then = -1;
// daemon and oneshot modes send a packet each time through outer loop
else {
then = now + 3000;
if (FLAG(d) || FLAG(D)) then = now + (1<<TT.r)*1000;
// Send NTP query packet
memset(toybuf, 0, 48);
*toybuf = 0xe3; // li = 3 (unsynchronized), version = 4, mode = 3 (client)
toybuf[2] = 8; // poll frequency 1<<8 = 256 seconds
pktime[5] = SWAP_BE64(before = lunchtime(&tv, diff));
xsendto(fd, toybuf, 48, ai->ai_addr);
}
// Loop receiving packets until it's time to send the next one.
for (;;) {
int strike;
// Wait to receive a packet
if (then>0 && then<(now = millitime())) break;;
strike = xrecvwait(fd, toybuf, sizeof(toybuf), &sa, then-now);
if (strike<1) {
if (!(FLAG(S)||FLAG(m)||FLAG(D)||FLAG(d)) && ++tries == 3)
error_exit("no reply from %s", *toys.optargs);
break;
}
if (strike<48) continue;
// Validate packet
if (!FLAG(S) || FLAG(m)) {
char buf[128];
int mode = 7&*toybuf;
// Is source address what we expect?
xstrncpy(buf, ntop(ai->ai_addr), 128);
strike = strcmp(buf, ntop((void *)&sa));
// Does this reply's originate timestamp match the packet we sent?
if (!FLAG(S) && !FLAG(m) && before != SWAP_BE64(pktime[3])) continue;
// Ignore packets from wrong address or with wrong mode
if (strike && !FLAG(S)) continue;
if (!((FLAG(m) && mode==5) || (FLAG(S) && mode==3) ||
(!FLAG(m) && !FLAG(S) && mode==4))) continue;
}
// If received a -S request packet, send server packet
if (strike) {
char *buf = toybuf+48;
*buf = 0x24; // LI 0 VN 4 mode 4.
buf[1] = 3; // stratum 3
buf[2] = 10; // recommended retry every 1<<10=1024 seconds
buf[3] = 250; // precision -6, minimum allowed
strcpy(buf+12, "LOCL");
pktime[6+3] = pktime[5]; // send back reference time they sent us
// everything else is current time
pktime[6+2] = pktime[6+4] = pktime[6+5] = SWAP_BE64(lunchtime(0, 0));
xsendto(fd, buf, 48, (void *)&sa);
// Got a time packet from a recognized server
} else {
int unset = !diff;
// First packet: figure out how far off our clock is from what server
// said and try again. Don't set clock, just record offset to use
// generating second reuest. (We know this time is in the past
// because transmission took time, but it's a start. And if time is
// miraculously exact, don't loop.)
lunchtime(&tv2, diff);
diff = nanodiff(&tv, &tv2);
if (unset && diff) break;
// Second packet: determine midpoint of packet transit time according
// to local clock, assuming each direction took same time so midpoint
// is time server reported. The first television was the adjusted time
// we sent the packet at, tv2 is what server replied, so now diff
// is round trip time.
// What time did the server say and how far off are we?
nanomove(&tv, diff/2);
doublyso(SWAP_BE64(pktime[5]), &tv2);
diff = nanodiff(&tv, &tv2);
if (FLAG(s)) {
// Do read/adjust/set to lose as little time as possible.
clock_gettime(CLOCK_REALTIME, &tv2);
nanomove(&tv2, diff);
if (clock_settime(CLOCK_REALTIME, &tv2))
perror_exit("clock_settime");
} else if (FLAG(a)) {
struct timeval why;
// call adjtime() to move the clock gradually, copying nanoseconds
// into gratuitous microseconds structure for sad historical reasons
memset(&tv2, 0, sizeof(tv2));
nanomove(&tv2, diff);
why.tv_sec = tv2.tv_sec;
why.tv_usec = tv2.tv_nsec/1000;
if (adjtime(&why, 0)) perror_exit("adjtime");
}
// Display the time and offset
if (!FLAG(q)) {
format_iso_time(toybuf, sizeof(toybuf)-1, &tv2);
printf("%s offset %c%lld.%09lld secs\n", toybuf, (diff<0) ? '-' : '+',
llabs(diff/1000000000), llabs(diff%1000000000));
}
// If we're not in daemon mode, we're done. (Can't get here for -S.)
if (!FLAG(d) && !FLAG(D)) return;
}
}
}
}
|
