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 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 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 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 123 control_shutdown(int fd) 124 { 125 close(fd); 126 } 127 128 int 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 * 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 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 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 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 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 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 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