1 /* $OpenBSD: control.c,v 1.27 2024/11/21 13:38:14 claudio Exp $ */
2
3 /*
4 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
5 * Copyright (c) 2012 Mike Miller <mmiller@mgm51.com>
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 USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 #include <errno.h>
25 #include <math.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <fcntl.h>
31 #include <err.h>
32
33 #include "ntpd.h"
34
35 #define CONTROL_BACKLOG 5
36
37 #define square(x) ((x) * (x))
38
39 int
control_check(char * path)40 control_check(char *path)
41 {
42 struct sockaddr_un sun;
43 int fd;
44
45 bzero(&sun, sizeof(sun));
46 sun.sun_family = AF_UNIX;
47 strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
48
49 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
50 log_debug("control_check: socket check");
51 return (-1);
52 }
53
54 if (connect(fd, (struct sockaddr *)&sun, sizeof(sun)) == 0) {
55 log_debug("control_check: socket in use");
56 close(fd);
57 return (-1);
58 }
59
60 close(fd);
61
62 return (0);
63 }
64
65 int
control_init(char * path)66 control_init(char *path)
67 {
68 struct sockaddr_un sa;
69 int fd;
70 mode_t old_umask;
71
72 if ((fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)) == -1) {
73 log_warn("control_init: socket");
74 return (-1);
75 }
76
77 memset(&sa, 0, sizeof(sa));
78 sa.sun_family = AF_UNIX;
79 if (strlcpy(sa.sun_path, path, sizeof(sa.sun_path)) >=
80 sizeof(sa.sun_path))
81 errx(1, "ctl socket name too long");
82
83 if (unlink(path) == -1)
84 if (errno != ENOENT) {
85 log_warn("control_init: unlink %s", path);
86 close(fd);
87 return (-1);
88 }
89
90 old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
91 if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
92 log_warn("control_init: bind: %s", path);
93 close(fd);
94 umask(old_umask);
95 return (-1);
96 }
97 umask(old_umask);
98
99 if (chmod(path, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) == -1) {
100 log_warn("control_init: chmod");
101 close(fd);
102 (void)unlink(path);
103 return (-1);
104 }
105
106 session_socket_nonblockmode(fd);
107
108 return (fd);
109 }
110
111 int
control_listen(int fd)112 control_listen(int fd)
113 {
114 if (fd != -1 && listen(fd, CONTROL_BACKLOG) == -1) {
115 log_warn("control_listen: listen");
116 return (-1);
117 }
118
119 return (0);
120 }
121
122 void
control_shutdown(int fd)123 control_shutdown(int fd)
124 {
125 close(fd);
126 }
127
128 int
control_accept(int listenfd)129 control_accept(int listenfd)
130 {
131 int connfd;
132 socklen_t len;
133 struct sockaddr_un sa;
134 struct ctl_conn *ctl_conn;
135
136 len = sizeof(sa);
137 if ((connfd = accept(listenfd,
138 (struct sockaddr *)&sa, &len)) == -1) {
139 if (errno != EWOULDBLOCK && errno != EINTR)
140 log_warn("control_accept: accept");
141 return (0);
142 }
143
144 session_socket_nonblockmode(connfd);
145
146 if ((ctl_conn = calloc(1, sizeof(struct ctl_conn))) == NULL) {
147 log_warn("control_accept");
148 close(connfd);
149 return (0);
150 }
151
152 if (imsgbuf_init(&ctl_conn->ibuf, connfd) == -1) {
153 log_warn("control_accept");
154 close(connfd);
155 free(ctl_conn);
156 return (0);
157 }
158
159 TAILQ_INSERT_TAIL(&ctl_conns, ctl_conn, entry);
160
161 return (1);
162 }
163
164 struct ctl_conn *
control_connbyfd(int fd)165 control_connbyfd(int fd)
166 {
167 struct ctl_conn *c;
168
169 TAILQ_FOREACH(c, &ctl_conns, entry) {
170 if (c->ibuf.fd == fd)
171 break;
172 }
173
174 return (c);
175 }
176
177 int
control_close(int fd)178 control_close(int fd)
179 {
180 struct ctl_conn *c;
181
182 if ((c = control_connbyfd(fd)) == NULL) {
183 log_warn("control_close: fd %d: not found", fd);
184 return (0);
185 }
186
187 imsgbuf_clear(&c->ibuf);
188 TAILQ_REMOVE(&ctl_conns, c, entry);
189
190 close(c->ibuf.fd);
191 free(c);
192
193 return (1);
194 }
195
196 int
control_dispatch_msg(struct pollfd * pfd,u_int * ctl_cnt)197 control_dispatch_msg(struct pollfd *pfd, u_int *ctl_cnt)
198 {
199 struct imsg imsg;
200 struct ctl_conn *c;
201 struct ntp_peer *p;
202 struct ntp_sensor *s;
203 struct ctl_show_status c_status;
204 struct ctl_show_peer c_peer;
205 struct ctl_show_sensor c_sensor;
206 int cnt;
207 ssize_t n;
208
209 if ((c = control_connbyfd(pfd->fd)) == NULL) {
210 log_warn("control_dispatch_msg: fd %d: not found", pfd->fd);
211 return (0);
212 }
213
214 if (pfd->revents & POLLOUT)
215 if (imsgbuf_write(&c->ibuf) == -1) {
216 *ctl_cnt -= control_close(pfd->fd);
217 return (1);
218 }
219
220 if (!(pfd->revents & POLLIN))
221 return (0);
222
223 if (imsgbuf_read(&c->ibuf) != 1) {
224 *ctl_cnt -= control_close(pfd->fd);
225 return (1);
226 }
227
228 for (;;) {
229 if ((n = imsg_get(&c->ibuf, &imsg)) == -1) {
230 *ctl_cnt -= control_close(pfd->fd);
231 return (1);
232 }
233 if (n == 0)
234 break;
235
236 switch (imsg.hdr.type) {
237 case IMSG_CTL_SHOW_STATUS:
238 build_show_status(&c_status);
239 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_STATUS, 0, 0, -1,
240 &c_status, sizeof (c_status));
241 break;
242 case IMSG_CTL_SHOW_PEERS:
243 cnt = 0;
244 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
245 build_show_peer(&c_peer, p);
246 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS,
247 0, 0, -1, &c_peer, sizeof(c_peer));
248 cnt++;
249 }
250 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS_END,
251 0, 0, -1, &cnt, sizeof(cnt));
252 break;
253 case IMSG_CTL_SHOW_SENSORS:
254 cnt = 0;
255 TAILQ_FOREACH(s, &conf->ntp_sensors, entry) {
256 build_show_sensor(&c_sensor, s);
257 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_SENSORS,
258 0, 0, -1, &c_sensor, sizeof(c_sensor));
259 cnt++;
260 }
261 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_SENSORS_END,
262 0, 0, -1, &cnt, sizeof(cnt));
263 break;
264 case IMSG_CTL_SHOW_ALL:
265 build_show_status(&c_status);
266 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_STATUS, 0, 0, -1,
267 &c_status, sizeof (c_status));
268
269 cnt = 0;
270 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
271 build_show_peer(&c_peer, p);
272 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS,
273 0, 0, -1, &c_peer, sizeof(c_peer));
274 cnt++;
275 }
276 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS_END,
277 0, 0, -1, &cnt, sizeof(cnt));
278
279 cnt = 0;
280 TAILQ_FOREACH(s, &conf->ntp_sensors, entry) {
281 build_show_sensor(&c_sensor, s);
282 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_SENSORS,
283 0, 0, -1, &c_sensor, sizeof(c_sensor));
284 cnt++;
285 }
286 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_SENSORS_END,
287 0, 0, -1, &cnt, sizeof(cnt));
288
289 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_ALL_END,
290 0, 0, -1, NULL, 0);
291 break;
292 default:
293 break;
294 }
295 imsg_free(&imsg);
296 }
297 return (0);
298 }
299
300 void
session_socket_nonblockmode(int fd)301 session_socket_nonblockmode(int fd)
302 {
303 int flags;
304
305 if ((flags = fcntl(fd, F_GETFL)) == -1)
306 fatal("fcntl F_GETFL");
307
308 flags |= O_NONBLOCK;
309
310 if ((flags = fcntl(fd, F_SETFL, flags)) == -1)
311 fatal("fcntl F_SETFL");
312 }
313
314 void
build_show_status(struct ctl_show_status * cs)315 build_show_status(struct ctl_show_status *cs)
316 {
317 struct ntp_peer *p;
318 struct ntp_sensor *s;
319
320 cs->peercnt = cs->valid_peers = 0;
321 cs->sensorcnt = cs->valid_sensors = 0;
322
323 TAILQ_FOREACH(p, &conf->ntp_peers, entry) {
324 cs->peercnt++;
325 if (p->trustlevel >= TRUSTLEVEL_BADPEER)
326 cs->valid_peers++;
327 }
328 TAILQ_FOREACH(s, &conf->ntp_sensors, entry) {
329 cs->sensorcnt++;
330 if (s->update.good)
331 cs->valid_sensors++;
332 }
333
334 cs->synced = conf->status.synced;
335 cs->stratum = conf->status.stratum;
336 cs->clock_offset = getoffset() * 1000.0;
337 cs->constraints = !TAILQ_EMPTY(&conf->constraints);
338 cs->constraint_median = conf->constraint_median;
339 cs->constraint_last = conf->constraint_last;
340 cs->constraint_errors = conf->constraint_errors;
341 }
342
343 void
build_show_peer(struct ctl_show_peer * cp,struct ntp_peer * p)344 build_show_peer(struct ctl_show_peer *cp, struct ntp_peer *p)
345 {
346 const char *a = "not resolved";
347 const char *pool = "", *addr_head_name = "";
348 const char *auth = "";
349 int shift, best = -1, validdelaycnt = 0, jittercnt = 0;
350 time_t now;
351
352 now = getmonotime();
353
354 if (p->addr) {
355 a = log_ntp_addr(p->addr);
356 if (p->addr->notauth)
357 auth = " (non-dnssec lookup)";
358 }
359 if (p->addr_head.pool)
360 pool = "from pool ";
361
362 if (0 != strcmp(a, p->addr_head.name) || p->addr_head.pool)
363 addr_head_name = p->addr_head.name;
364
365 snprintf(cp->peer_desc, sizeof(cp->peer_desc),
366 "%s %s%s%s", a, pool, addr_head_name, auth);
367
368 cp->offset = cp->delay = 0.0;
369 for (shift = 0; shift < OFFSET_ARRAY_SIZE; shift++) {
370 if (p->reply[shift].delay > 0.0) {
371 cp->offset += p->reply[shift].offset;
372 cp->delay += p->reply[shift].delay;
373
374 if (best == -1 ||
375 p->reply[shift].delay < p->reply[best].delay)
376 best = shift;
377
378 validdelaycnt++;
379 }
380 }
381
382 if (validdelaycnt > 1) {
383 cp->offset /= validdelaycnt;
384 cp->delay /= validdelaycnt;
385 }
386
387 cp->jitter = 0.0;
388 if (best != -1) {
389 for (shift = 0; shift < OFFSET_ARRAY_SIZE; shift++) {
390 if (p->reply[shift].delay > 0.0 && shift != best) {
391 cp->jitter += square(p->reply[shift].delay -
392 p->reply[best].delay);
393 jittercnt++;
394 }
395 }
396 if (jittercnt > 1)
397 cp->jitter /= jittercnt;
398 cp->jitter = sqrt(cp->jitter);
399 }
400
401 if (p->shift == 0)
402 shift = OFFSET_ARRAY_SIZE - 1;
403 else
404 shift = p->shift - 1;
405
406 if (conf->status.synced == 1 &&
407 p->reply[shift].status.send_refid == conf->status.refid)
408 cp->syncedto = 1;
409 else
410 cp->syncedto = 0;
411
412 /* milliseconds to reduce number of leading zeroes */
413 cp->offset *= 1000.0;
414 cp->delay *= 1000.0;
415 cp->jitter *= 1000.0;
416
417 cp->weight = p->weight;
418 cp->trustlevel = p->trustlevel;
419 cp->stratum = p->reply[shift].status.stratum;
420 cp->next = p->next - now < 0 ? 0 : p->next - now;
421 cp->poll = p->poll;
422 }
423
424 void
build_show_sensor(struct ctl_show_sensor * cs,struct ntp_sensor * s)425 build_show_sensor(struct ctl_show_sensor *cs, struct ntp_sensor *s)
426 {
427 time_t now;
428 u_int8_t shift;
429 u_int32_t refid;
430
431 now = getmonotime();
432
433 memcpy(&refid, SENSOR_DEFAULT_REFID, sizeof(refid));
434 refid = refid == s->refid ? 0 : s->refid;
435
436 snprintf(cs->sensor_desc, sizeof(cs->sensor_desc),
437 "%s %.4s", s->device, (char *)&refid);
438
439 if (s->shift == 0)
440 shift = SENSOR_OFFSETS - 1;
441 else
442 shift = s->shift - 1;
443
444 if (conf->status.synced == 1 &&
445 s->offsets[shift].status.send_refid == conf->status.refid)
446 cs->syncedto = 1;
447 else
448 cs->syncedto = 0;
449
450 cs->weight = s->weight;
451 cs->good = s->update.good;
452 cs->stratum = s->offsets[shift].status.stratum;
453 cs->next = s->next - now < 0 ? 0 : s->next - now;
454 cs->poll = SENSOR_QUERY_INTERVAL;
455 cs->offset = s->offsets[shift].offset * 1000.0;
456 cs->correction = (double)s->correction / 1000.0;
457 }
458