1 /* $OpenBSD: control.c,v 1.10 2016/03/27 11:16:12 krw 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_init(char *path) 41 { 42 struct sockaddr_un sa; 43 int fd; 44 mode_t old_umask; 45 46 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { 47 log_warn("control_init: socket"); 48 return (-1); 49 } 50 51 memset(&sa, 0, sizeof(sa)); 52 sa.sun_family = AF_UNIX; 53 if (strlcpy(sa.sun_path, path, sizeof(sa.sun_path)) >= 54 sizeof(sa.sun_path)) 55 errx(1, "ctl socket name too long"); 56 57 if (unlink(path) == -1) 58 if (errno != ENOENT) { 59 log_warn("control_init: unlink %s", path); 60 close(fd); 61 return (-1); 62 } 63 64 old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH); 65 if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) { 66 log_warn("control_init: bind: %s", path); 67 close(fd); 68 umask(old_umask); 69 return (-1); 70 } 71 umask(old_umask); 72 73 if (chmod(path, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) == -1) { 74 log_warn("control_init: chmod"); 75 close(fd); 76 (void)unlink(path); 77 return (-1); 78 } 79 80 session_socket_nonblockmode(fd); 81 82 return (fd); 83 } 84 85 int 86 control_listen(int fd) 87 { 88 if (fd != -1 && listen(fd, CONTROL_BACKLOG) == -1) { 89 log_warn("control_listen: listen"); 90 return (-1); 91 } 92 93 return (0); 94 } 95 96 void 97 control_shutdown(int fd) 98 { 99 close(fd); 100 } 101 102 void 103 control_cleanup(const char *path) 104 { 105 if (path) 106 unlink(path); 107 } 108 109 int 110 control_accept(int listenfd) 111 { 112 int connfd; 113 socklen_t len; 114 struct sockaddr_un sa; 115 struct ctl_conn *ctl_conn; 116 117 len = sizeof(sa); 118 if ((connfd = accept(listenfd, 119 (struct sockaddr *)&sa, &len)) == -1) { 120 if (errno != EWOULDBLOCK && errno != EINTR) 121 log_warn("control_accept: accept"); 122 return (0); 123 } 124 125 session_socket_nonblockmode(connfd); 126 127 if ((ctl_conn = calloc(1, sizeof(struct ctl_conn))) == NULL) { 128 log_warn("control_accept"); 129 close(connfd); 130 return (0); 131 } 132 133 imsg_init(&ctl_conn->ibuf, connfd); 134 135 TAILQ_INSERT_TAIL(&ctl_conns, ctl_conn, entry); 136 137 return (1); 138 } 139 140 struct ctl_conn * 141 control_connbyfd(int fd) 142 { 143 struct ctl_conn *c; 144 145 for (c = TAILQ_FIRST(&ctl_conns); c != NULL && c->ibuf.fd != fd; 146 c = TAILQ_NEXT(c, entry)) 147 ; /* nothing */ 148 149 return (c); 150 } 151 152 int 153 control_close(int fd) 154 { 155 struct ctl_conn *c; 156 157 if ((c = control_connbyfd(fd)) == NULL) { 158 log_warn("control_close: fd %d: not found", fd); 159 return (0); 160 } 161 162 msgbuf_clear(&c->ibuf.w); 163 TAILQ_REMOVE(&ctl_conns, c, entry); 164 165 close(c->ibuf.fd); 166 free(c); 167 168 return (1); 169 } 170 171 int 172 control_dispatch_msg(struct pollfd *pfd, u_int *ctl_cnt) 173 { 174 struct imsg imsg; 175 struct ctl_conn *c; 176 struct ntp_peer *p; 177 struct ntp_sensor *s; 178 struct ctl_show_status c_status; 179 struct ctl_show_peer c_peer; 180 struct ctl_show_sensor c_sensor; 181 int cnt; 182 ssize_t n; 183 184 if ((c = control_connbyfd(pfd->fd)) == NULL) { 185 log_warn("control_dispatch_msg: fd %d: not found", pfd->fd); 186 return (0); 187 } 188 189 if (pfd->revents & POLLOUT) 190 if (msgbuf_write(&c->ibuf.w) <= 0 && errno != EAGAIN) { 191 *ctl_cnt -= control_close(pfd->fd); 192 return (1); 193 } 194 195 if (!(pfd->revents & POLLIN)) 196 return (0); 197 198 if (((n = imsg_read(&c->ibuf)) == -1 && errno != EAGAIN) || n == 0) { 199 *ctl_cnt -= control_close(pfd->fd); 200 return (1); 201 } 202 203 for (;;) { 204 if ((n = imsg_get(&c->ibuf, &imsg)) == -1) { 205 *ctl_cnt -= control_close(pfd->fd); 206 return (1); 207 } 208 if (n == 0) 209 break; 210 211 switch (imsg.hdr.type) { 212 case IMSG_CTL_SHOW_STATUS: 213 build_show_status(&c_status); 214 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_STATUS, 0, 0, -1, 215 &c_status, sizeof (c_status)); 216 break; 217 case IMSG_CTL_SHOW_PEERS: 218 cnt = 0; 219 TAILQ_FOREACH(p, &conf->ntp_peers, entry) { 220 build_show_peer(&c_peer, p); 221 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS, 222 0, 0, -1, &c_peer, sizeof(c_peer)); 223 cnt++; 224 } 225 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS_END, 226 0, 0, -1, &cnt, sizeof(cnt)); 227 break; 228 case IMSG_CTL_SHOW_SENSORS: 229 cnt = 0; 230 TAILQ_FOREACH(s, &conf->ntp_sensors, entry) { 231 build_show_sensor(&c_sensor, s); 232 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_SENSORS, 233 0, 0, -1, &c_sensor, sizeof(c_sensor)); 234 cnt++; 235 } 236 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_SENSORS_END, 237 0, 0, -1, &cnt, sizeof(cnt)); 238 break; 239 case IMSG_CTL_SHOW_ALL: 240 build_show_status(&c_status); 241 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_STATUS, 0, 0, -1, 242 &c_status, sizeof (c_status)); 243 244 cnt = 0; 245 TAILQ_FOREACH(p, &conf->ntp_peers, entry) { 246 build_show_peer(&c_peer, p); 247 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS, 248 0, 0, -1, &c_peer, sizeof(c_peer)); 249 cnt++; 250 } 251 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_PEERS_END, 252 0, 0, -1, &cnt, sizeof(cnt)); 253 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 264 imsg_compose(&c->ibuf, IMSG_CTL_SHOW_ALL_END, 265 0, 0, -1, NULL, 0); 266 break; 267 default: 268 break; 269 } 270 imsg_free(&imsg); 271 } 272 return (0); 273 } 274 275 void 276 session_socket_nonblockmode(int fd) 277 { 278 int flags; 279 280 if ((flags = fcntl(fd, F_GETFL)) == -1) 281 fatal("fcntl F_GETFL"); 282 283 flags |= O_NONBLOCK; 284 285 if ((flags = fcntl(fd, F_SETFL, flags)) == -1) 286 fatal("fcntl F_SETFL"); 287 } 288 289 void 290 build_show_status(struct ctl_show_status *cs) 291 { 292 struct ntp_peer *p; 293 struct ntp_sensor *s; 294 295 cs->peercnt = cs->valid_peers = 0; 296 cs->sensorcnt = cs->valid_sensors = 0; 297 298 TAILQ_FOREACH(p, &conf->ntp_peers, entry) { 299 cs->peercnt++; 300 if (p->trustlevel >= TRUSTLEVEL_BADPEER) 301 cs->valid_peers++; 302 } 303 TAILQ_FOREACH(s, &conf->ntp_sensors, entry) { 304 cs->sensorcnt++; 305 if (s->update.good) 306 cs->valid_sensors++; 307 } 308 309 cs->synced = conf->status.synced; 310 cs->stratum = conf->status.stratum; 311 cs->clock_offset = getoffset() * 1000.0; 312 cs->constraint_median = conf->constraint_median; 313 cs->constraint_last = conf->constraint_last; 314 cs->constraint_errors = conf->constraint_errors; 315 } 316 317 void 318 build_show_peer(struct ctl_show_peer *cp, struct ntp_peer *p) 319 { 320 const char *a = "not resolved"; 321 const char *pool = "", *addr_head_name = ""; 322 u_int8_t shift, best, validdelaycnt, jittercnt; 323 time_t now; 324 325 now = getmonotime(); 326 327 if (p->addr) 328 a = log_sockaddr((struct sockaddr *)&p->addr->ss); 329 if (p->addr_head.pool) 330 pool = "from pool "; 331 332 if (0 != strcmp(a, p->addr_head.name)) 333 addr_head_name = p->addr_head.name; 334 335 snprintf(cp->peer_desc, sizeof(cp->peer_desc), 336 "%s %s%s", a, pool, addr_head_name); 337 338 validdelaycnt = best = 0; 339 cp->offset = cp->delay = 0.0; 340 for (shift = 0; shift < OFFSET_ARRAY_SIZE; shift++) { 341 if (p->reply[shift].delay > 0.0) { 342 cp->offset += p->reply[shift].offset; 343 cp->delay += p->reply[shift].delay; 344 345 if (p->reply[shift].delay < p->reply[best].delay) 346 best = shift; 347 348 validdelaycnt++; 349 } 350 } 351 352 if (validdelaycnt > 1) { 353 cp->offset /= validdelaycnt; 354 cp->delay /= validdelaycnt; 355 } 356 357 jittercnt = 0; 358 cp->jitter = 0.0; 359 for (shift = 0; shift < OFFSET_ARRAY_SIZE; shift++) { 360 if (p->reply[shift].delay > 0.0 && shift != best) { 361 cp->jitter += square(p->reply[shift].delay - 362 p->reply[best].delay); 363 jittercnt++; 364 } 365 } 366 if (jittercnt > 1) 367 cp->jitter /= jittercnt; 368 cp->jitter = sqrt(cp->jitter); 369 370 if (p->shift == 0) 371 shift = OFFSET_ARRAY_SIZE - 1; 372 else 373 shift = p->shift - 1; 374 375 if (conf->status.synced == 1 && 376 p->reply[shift].status.send_refid == conf->status.refid) 377 cp->syncedto = 1; 378 else 379 cp->syncedto = 0; 380 381 /* milliseconds to reduce number of leading zeroes */ 382 cp->offset *= 1000.0; 383 cp->delay *= 1000.0; 384 cp->jitter *= 1000.0; 385 386 cp->weight = p->weight; 387 cp->trustlevel = p->trustlevel; 388 cp->stratum = p->reply[shift].status.stratum; 389 cp->next = p->next - now < 0 ? 0 : p->next - now; 390 cp->poll = p->poll; 391 } 392 393 void 394 build_show_sensor(struct ctl_show_sensor *cs, struct ntp_sensor *s) 395 { 396 time_t now; 397 u_int8_t shift; 398 u_int32_t refid; 399 400 now = getmonotime(); 401 402 memcpy(&refid, SENSOR_DEFAULT_REFID, sizeof(refid)); 403 refid = refid == s->refid ? 0 : s->refid; 404 405 snprintf(cs->sensor_desc, sizeof(cs->sensor_desc), 406 "%s %.4s", s->device, (char *)&refid); 407 408 if (s->shift == 0) 409 shift = SENSOR_OFFSETS - 1; 410 else 411 shift = s->shift - 1; 412 413 if (conf->status.synced == 1 && 414 s->offsets[shift].status.send_refid == conf->status.refid) 415 cs->syncedto = 1; 416 else 417 cs->syncedto = 0; 418 419 cs->weight = s->weight; 420 cs->good = s->update.good; 421 cs->stratum = s->offsets[shift].status.stratum; 422 cs->next = s->next - now < 0 ? 0 : s->next - now; 423 cs->poll = SENSOR_QUERY_INTERVAL; 424 cs->offset = s->offsets[shift].offset * 1000.0; 425 cs->correction = (double)s->correction / 1000.0; 426 } 427