?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add rfcomm_sppd(1) - RFCOMM Serial Port Profile daemon.
[dragonfly.git] / contrib / ntpd / ntp.c
blob6ea9482d9a559ec3d5adc2fd039608601b795e93
1 /* $OpenBSD: src/usr.sbin/ntpd/ntp.c,v 1.57 2005/04/18 14:12:50 henning Exp $ */
2
3 /*
4 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
5 * Copyright (c) 2004 Alexander Guy <alexander.guy@andern.org>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
16 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
17 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 #include <sys/param.h>
21 #include <sys/time.h>
22 #include <sys/stat.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <paths.h>
26 #include <poll.h>
27 #include <pwd.h>
28 #include <signal.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <time.h>
32 #include <unistd.h>
33
34 #include "ntpd.h"
35 #include "ntp.h"
36
37 #define PFD_PIPE_MAIN 0
38 #define PFD_MAX 1
39
40 volatile sig_atomic_t ntp_quit = 0;
41 struct imsgbuf *ibuf_main;
42 struct ntpd_conf *conf;
43 u_int peer_cnt;
44
45 void ntp_sighdlr(int);
46 int ntp_dispatch_imsg(void);
47 void peer_add(struct ntp_peer *);
48 void peer_remove(struct ntp_peer *);
49 int offset_compare(const void *, const void *);
50
51 void
52 ntp_sighdlr(int sig)
53 {
54 switch (sig) {
55 case SIGINT:
56 case SIGTERM:
57 ntp_quit = 1;
58 break;
59 }
60 }
61
62 pid_t
63 ntp_main(int pipe_prnt[2], struct ntpd_conf *nconf)
64 {
65 int a, b, nfds, i, j, idx_peers, timeout, nullfd;
66 u_int pfd_elms = 0, idx2peer_elms = 0;
67 u_int listener_cnt, new_cnt, sent_cnt, trial_cnt;
68 pid_t pid;
69 struct pollfd *pfd = NULL;
70 struct passwd *pw;
71 struct servent *se;
72 struct listen_addr *la;
73 struct ntp_peer *p;
74 struct ntp_peer **idx2peer = NULL;
75 struct timespec tp;
76 struct stat stb;
77 time_t nextaction;
78 void *newp;
79
80 switch (pid = fork()) {
81 case -1:
82 fatal("cannot fork");
83 break;
84 case 0:
85 break;
86 default:
87 return (pid);
88 }
89
90 if ((se = getservbyname("ntp", "udp")) == NULL)
91 fatal("getservbyname");
92
93 if ((pw = getpwnam(NTPD_USER)) == NULL)
94 fatal("getpwnam");
95
96 if ((nullfd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1)
97 fatal(NULL);
98
99 if (stat(pw->pw_dir, &stb) == -1)
100 fatal("stat");
101 if (stb.st_uid != 0 || (stb.st_mode & (S_IWGRP|S_IWOTH)) != 0)
102 fatal("bad privsep dir permissions");
103 if (chroot(pw->pw_dir) == -1)
104 fatal("chroot");
105 if (chdir("/") == -1)
106 fatal("chdir(\"/\")");
107
108 if (!nconf->debug) {
109 dup2(nullfd, STDIN_FILENO);
110 dup2(nullfd, STDOUT_FILENO);
111 dup2(nullfd, STDERR_FILENO);
112 }
113 close(nullfd);
114
115 setproctitle("ntp engine");
116
117 conf = nconf;
118 setup_listeners(se, conf, &listener_cnt);
119
120 if (setgroups(1, &pw->pw_gid) ||
121 setegid(pw->pw_gid) || setgid(pw->pw_gid) ||
122 seteuid(pw->pw_uid) || setuid(pw->pw_uid))
123 fatal("can't drop privileges");
124
125 endpwent();
126 endservent();
127
128 signal(SIGTERM, ntp_sighdlr);
129 signal(SIGINT, ntp_sighdlr);
130 signal(SIGPIPE, SIG_IGN);
131 signal(SIGHUP, SIG_IGN);
132
133 close(pipe_prnt[0]);
134 if ((ibuf_main = malloc(sizeof(struct imsgbuf))) == NULL)
135 fatal(NULL);
136 imsg_init(ibuf_main, pipe_prnt[1]);
137
138 TAILQ_FOREACH(p, &conf->ntp_peers, entry)
139 client_peer_init(p);
140
141 bzero(&conf->status, sizeof(conf->status));
142 conf->status.leap = LI_ALARM;
143 clock_getres(CLOCK_REALTIME, &tp);
144 b = 1000000000 / tp.tv_nsec; /* convert to Hz */
145 for (a = 0; b > 1; a--, b >>= 1)
146 ;
147 conf->status.precision = a;
148 conf->scale = 1;
149
150 log_info("ntp engine ready");
151
152 peer_cnt = 0;
153 TAILQ_FOREACH(p, &conf->ntp_peers, entry)
154 peer_cnt++;
155
156 while (ntp_quit == 0) {
157 if (peer_cnt > idx2peer_elms) {
158 if ((newp = realloc(idx2peer, sizeof(void *) *
159 peer_cnt)) == NULL) {
160 /* panic for now */
161 log_warn("could not resize idx2peer from %u -> "
162 "%u entries", idx2peer_elms, peer_cnt);
163 fatalx("exiting");
164 }
165 idx2peer = newp;
166 idx2peer_elms = peer_cnt;
167 }
168
169 new_cnt = PFD_MAX + peer_cnt + listener_cnt;
170 if (new_cnt > pfd_elms) {
171 if ((newp = realloc(pfd, sizeof(struct pollfd) *
172 new_cnt)) == NULL) {
173 /* panic for now */
174 log_warn("could not resize pfd from %u -> "
175 "%u entries", pfd_elms, new_cnt);
176 fatalx("exiting");
177 }
178 pfd = newp;
179 pfd_elms = new_cnt;
180 }
181
182 bzero(pfd, sizeof(struct pollfd) * pfd_elms);
183 bzero(idx2peer, sizeof(void *) * idx2peer_elms);
184 nextaction = time(NULL) + 3600;
185 pfd[PFD_PIPE_MAIN].fd = ibuf_main->fd;
186 pfd[PFD_PIPE_MAIN].events = POLLIN;
187
188 i = 1;
189 TAILQ_FOREACH(la, &conf->listen_addrs, entry) {
190 pfd[i].fd = la->fd;
191 pfd[i].events = POLLIN;
192 i++;
193 }
194
195 idx_peers = i;
196 sent_cnt = trial_cnt = 0;
197 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
198 if (p->next > 0 && p->next < nextaction)
199 nextaction = p->next;
200 if (p->next > 0 && p->next <= time(NULL)) {
201 trial_cnt++;
202 if (client_query(p) == 0)
203 sent_cnt++;
204 }
205
206 if (p->deadline > 0 && p->deadline < nextaction)
207 nextaction = p->deadline;
208 if (p->deadline > 0 && p->deadline <= time(NULL)) {
209 timeout = error_interval();
210 log_debug("no reply from %s received in time, "
211 "next query %ds", log_sockaddr(
212 (struct sockaddr *)&p->addr->ss), timeout);
213 if (p->trustlevel >= TRUSTLEVEL_BADPEER &&
214 (p->trustlevel /= 2) < TRUSTLEVEL_BADPEER)
215 log_info("peer %s now invalid",
216 log_sockaddr(
217 (struct sockaddr *)&p->addr->ss));
218 client_nextaddr(p);
219 set_next(p, timeout);
220 }
221
222 if (p->state == STATE_QUERY_SENT) {
223 pfd[i].fd = p->query->fd;
224 pfd[i].events = POLLIN;
225 idx2peer[i - idx_peers] = p;
226 i++;
227 }
228 }
229
230 if (trial_cnt > 0 && sent_cnt == 0 && conf->settime)
231 priv_settime(0); /* no good peers, don't wait */
232
233 if (ibuf_main->w.queued > 0)
234 pfd[PFD_PIPE_MAIN].events |= POLLOUT;
235
236 timeout = nextaction - time(NULL);
237 if (timeout < 0)
238 timeout = 0;
239
240 if ((nfds = poll(pfd, i, timeout * 1000)) == -1)
241 if (errno != EINTR) {
242 log_warn("poll error");
243 ntp_quit = 1;
244 }
245
246 if (nfds > 0 && (pfd[PFD_PIPE_MAIN].revents & POLLOUT))
247 if (msgbuf_write(&ibuf_main->w) < 0) {
248 log_warn("pipe write error (to parent)");
249 ntp_quit = 1;
250 }
251
252 if (nfds > 0 && pfd[PFD_PIPE_MAIN].revents & (POLLIN|POLLERR)) {
253 nfds--;
254 if (ntp_dispatch_imsg() == -1)
255 ntp_quit = 1;
256 }
257
258 for (j = 1; nfds > 0 && j < idx_peers; j++)
259 if (pfd[j].revents & (POLLIN|POLLERR)) {
260 nfds--;
261 if (server_dispatch(pfd[j].fd, conf) == -1)
262 ntp_quit = 1;
263 }
264
265 for (; nfds > 0 && j < i; j++)
266 if (pfd[j].revents & (POLLIN|POLLERR)) {
267 nfds--;
268 if (client_dispatch(idx2peer[j - idx_peers],
269 conf->settime) == -1)
270 ntp_quit = 1;
271 }
272 }
273
274 msgbuf_write(&ibuf_main->w);
275 msgbuf_clear(&ibuf_main->w);
276 free(ibuf_main);
277
278 log_info("ntp engine exiting");
279 _exit(0);
280 }
281
282 int
283 ntp_dispatch_imsg(void)
284 {
285 struct imsg imsg;
286 int n;
287 struct ntp_peer *peer, *npeer;
288 u_int16_t dlen;
289 u_char *p;
290 struct ntp_addr *h;
291
292 if ((n = imsg_read(ibuf_main)) == -1)
293 return (-1);
294
295 if (n == 0) { /* connection closed */
296 log_warnx("ntp_dispatch_imsg in ntp engine: pipe closed");
297 return (-1);
298 }
299
300 for (;;) {
301 if ((n = imsg_get(ibuf_main, &imsg)) == -1)
302 return (-1);
303
304 if (n == 0)
305 break;
306
307 switch (imsg.hdr.type) {
308 case IMSG_HOST_DNS:
309 TAILQ_FOREACH(peer, &conf->ntp_peers, entry)
310 if (peer->id == imsg.hdr.peerid)
311 break;
312 if (peer == NULL) {
313 log_warnx("IMSG_HOST_DNS with invalid peerID");
314 break;
315 }
316 if (peer->addr != NULL) {
317 log_warnx("IMSG_HOST_DNS but addr != NULL!");
318 break;
319 }
320 dlen = imsg.hdr.len - IMSG_HEADER_SIZE;
321 p = (u_char *)imsg.data;
322 while (dlen >= sizeof(struct sockaddr_storage)) {
323 if ((h = calloc(1, sizeof(struct ntp_addr))) ==
324 NULL)
325 fatal(NULL);
326 memcpy(&h->ss, p, sizeof(h->ss));
327 p += sizeof(h->ss);
328 dlen -= sizeof(h->ss);
329 if (peer->addr_head.pool) {
330 npeer = new_peer();
331 h->next = NULL;
332 npeer->addr = h;
333 npeer->addr_head.a = h;
334 client_peer_init(npeer);
335 peer_add(npeer);
336 } else {
337 h->next = peer->addr;
338 peer->addr = h;
339 peer->addr_head.a = peer->addr;
340 }
341 }
342 if (dlen != 0)
343 fatalx("IMSG_HOST_DNS: dlen != 0");
344 if (peer->addr_head.pool)
345 peer_remove(peer);
346 else
347 client_addr_init(peer);
348 break;
349 default:
350 break;
351 }
352 imsg_free(&imsg);
353 }
354 return (0);
355 }
356
357 void
358 peer_add(struct ntp_peer *p)
359 {
360 TAILQ_INSERT_TAIL(&conf->ntp_peers, p, entry);
361 peer_cnt++;
362 }
363
364 void
365 peer_remove(struct ntp_peer *p)
366 {
367 TAILQ_REMOVE(&conf->ntp_peers, p, entry);
368 free(p);
369 peer_cnt--;
370 }
371
372 void
373 priv_adjtime(void)
374 {
375 struct ntp_peer *p;
376 int offset_cnt = 0, i = 0;
377 struct ntp_peer **peers;
378 double offset_median;
379
380 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
381 if (p->trustlevel < TRUSTLEVEL_BADPEER)
382 continue;
383 if (!p->update.good)
384 return;
385 offset_cnt++;
386 }
387
388 if ((peers = calloc(offset_cnt, sizeof(struct ntp_peer *))) == NULL)
389 fatal("calloc ntp_adjtime");
390
391 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
392 if (p->trustlevel < TRUSTLEVEL_BADPEER)
393 continue;
394 peers[i++] = p;
395 }
396
397 qsort(peers, offset_cnt, sizeof(struct ntp_peer *), offset_compare);
398
399 if (offset_cnt > 0) {
400 if (offset_cnt > 1 && offset_cnt % 2 == 0) {
401 offset_median =
402 (peers[offset_cnt / 2 - 1]->update.offset +
403 peers[offset_cnt / 2]->update.offset) / 2;
404 conf->status.rootdelay =
405 (peers[offset_cnt / 2 - 1]->update.delay +
406 peers[offset_cnt / 2]->update.delay) / 2;
407 conf->status.stratum = MAX(
408 peers[offset_cnt / 2 - 1]->update.status.stratum,
409 peers[offset_cnt / 2]->update.status.stratum);
410 } else {
411 offset_median = peers[offset_cnt / 2]->update.offset;
412 conf->status.rootdelay =
413 peers[offset_cnt / 2]->update.delay;
414 conf->status.stratum =
415 peers[offset_cnt / 2]->update.status.stratum;
416 }
417
418 imsg_compose(ibuf_main, IMSG_ADJTIME, 0, 0,
419 &offset_median, sizeof(offset_median));
420
421 conf->status.reftime = gettime();
422 conf->status.leap = LI_NOWARNING;
423 conf->status.stratum++; /* one more than selected peer */
424 update_scale(offset_median);
425
426 if (peers[offset_cnt / 2]->addr->ss.ss_family == AF_INET)
427 conf->status.refid = ((struct sockaddr_in *)
428 &peers[offset_cnt / 2]->addr->ss)->sin_addr.s_addr;
429 }
430
431 free(peers);
432
433 TAILQ_FOREACH(p, &conf->ntp_peers, entry)
434 p->update.good = 0;
435 }
436
437 int
438 offset_compare(const void *aa, const void *bb)
439 {
440 const struct ntp_peer * const *a;
441 const struct ntp_peer * const *b;
442
443 a = aa;
444 b = bb;
445
446 if ((*a)->update.offset < (*b)->update.offset)
447 return (-1);
448 else if ((*a)->update.offset > (*b)->update.offset)
449 return (1);
450 else
451 return (0);
452 }
453
454 void
455 priv_settime(double offset)
456 {
457 struct ntp_peer *p;
458
459 imsg_compose(ibuf_main, IMSG_SETTIME, 0, 0, &offset, sizeof(offset));
460 conf->settime = 0;
461
462 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
463 if (p->next)
464 p->next -= offset;
465 if (p->deadline)
466 p->deadline -= offset;
467 }
468 }
469
470 void
471 priv_host_dns(char *name, u_int32_t peerid)
472 {
473 u_int16_t dlen;
474
475 dlen = strlen(name) + 1;
476 imsg_compose(ibuf_main, IMSG_HOST_DNS, peerid, 0, name, dlen);
477 }
478
479 void
480 update_scale(double offset)
481 {
482 if (offset < 0)
483 offset = -offset;
484
485 if (offset > QSCALE_OFF_MAX)
486 conf->scale = 1;
487 else if (offset < QSCALE_OFF_MIN)
488 conf->scale = QSCALE_OFF_MAX / QSCALE_OFF_MIN;
489 else
490 conf->scale = QSCALE_OFF_MAX / offset;
491 }
492
493 time_t
494 scale_interval(time_t requested)
495 {
496 time_t interval, r;
497
498 interval = requested * conf->scale;
499 r = arc4random() % MAX(5, interval / 10);
500 return (interval + r);
501 }
502
503 time_t
504 error_interval(void)
505 {
506 time_t interval, r;
507
508 interval = INTERVAL_QUERY_PATHETIC * QSCALE_OFF_MAX / QSCALE_OFF_MIN;
509 r = arc4random() % (interval / 10);
510 return (interval + r);
511 }
512
DragonFly BSD