1 /* $NetBSD: rwhod.c,v 1.39 2011/08/31 13:32:41 joerg Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __COPYRIGHT("@(#) Copyright (c) 1983, 1993\ 35 The Regents of the University of California. All rights reserved."); 36 #endif /* not lint */ 37 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "@(#)rwhod.c 8.1 (Berkeley) 6/6/93"; 41 #else 42 __RCSID("$NetBSD: rwhod.c,v 1.39 2011/08/31 13:32:41 joerg Exp $"); 43 #endif 44 #endif /* not lint */ 45 46 #include <sys/param.h> 47 #include <sys/socket.h> 48 #include <sys/stat.h> 49 #include <sys/signal.h> 50 #include <sys/ioctl.h> 51 #include <sys/sysctl.h> 52 53 #include <net/if.h> 54 #include <net/if_dl.h> 55 #include <net/route.h> 56 #include <netinet/in.h> 57 #include <protocols/rwhod.h> 58 #include <arpa/inet.h> 59 60 #include <ctype.h> 61 #include <err.h> 62 #include <errno.h> 63 #include <fcntl.h> 64 #include <netdb.h> 65 #include <paths.h> 66 #include <poll.h> 67 #include <stdio.h> 68 #include <stdlib.h> 69 #include <string.h> 70 #include <syslog.h> 71 #include <unistd.h> 72 #include <util.h> 73 74 #include "utmpentry.h" 75 76 #define CHECK_INTERVAL (3 * 60) 77 78 /* Time interval limit; ruptime will think that we are down > than this */ 79 #define MAX_INTERVAL (11 * 60) 80 81 82 static char myname[MAXHOSTNAMELEN + 1]; 83 84 /* 85 * We communicate with each neighbor in a list constructed at the time we're 86 * started up. Neighbors are currently directly connected via a hardware 87 * interface. 88 */ 89 struct neighbor { 90 struct neighbor *n_next; 91 char *n_name; /* interface name */ 92 struct sockaddr *n_addr; /* who to send to */ 93 int n_addrlen; /* size of address */ 94 int n_flags; /* should forward?, interface flags */ 95 }; 96 97 static struct neighbor *neighbors; 98 static struct whod mywd; 99 static struct servent *sp; 100 static volatile sig_atomic_t onsighup; 101 102 #define WHDRSIZE (sizeof(mywd) - sizeof(mywd.wd_we)) 103 104 static int configure(int); 105 static void getboottime(void); 106 static void send_host_information(int); 107 static void sighup(int); 108 static void handleread(int); 109 __dead static void quit(const char *); 110 static void rt_xaddrs(void *, void *, struct rt_addrinfo *); 111 static int drop_privs(char *); 112 static void usage(void) __dead; 113 static int verify(const char *); 114 #ifdef DEBUG 115 static char *interval(int, const char *); 116 static ssize_t Sendto(int, const void *, size_t, int, 117 const struct sockaddr *, socklen_t); 118 #else 119 #define Sendto sendto 120 #endif 121 122 int 123 main(int argc, char *argv[]) 124 { 125 int s, ch; 126 int time_interval = 180; /* Default time (180 seconds) */ 127 char *cp, *ep; 128 socklen_t on = 1; 129 struct sockaddr_in sasin; 130 struct pollfd pfd[1]; 131 struct timeval delta, next, now; 132 char *newuser = NULL; 133 134 setprogname(argv[0]); 135 136 if (getuid()) 137 errx(EXIT_FAILURE, "not super user"); 138 139 while ((ch = getopt(argc, argv, "i:u:")) != -1) { 140 switch (ch) { 141 case 'i': 142 time_interval = (int)strtol(optarg, &ep, 10); 143 144 switch (*ep) { 145 case '\0': 146 break; 147 case 'm': 148 case 'M': 149 /* Time in minutes. */ 150 time_interval *= 60; 151 if (ep[1] == '\0') 152 break; 153 /*FALLTHROUGH*/ 154 default: 155 errx(1, "Invalid argument: `%s'", optarg); 156 } 157 158 if (time_interval <= 0) 159 errx(1, "Interval must be greater than 0"); 160 161 if (time_interval > MAX_INTERVAL) 162 errx(1, "Interval cannot be greater than" 163 " %d minutes", MAX_INTERVAL / 60); 164 break; 165 166 case 'u': 167 newuser = optarg; 168 break; 169 170 default: 171 usage(); 172 } 173 } 174 175 sp = getservbyname("who", "udp"); 176 if (sp == NULL) 177 errx(EXIT_FAILURE, "udp/who: unknown service"); 178 #ifndef DEBUG 179 (void)daemon(1, 0); 180 (void)pidfile(NULL); 181 #endif 182 if (chdir(_PATH_RWHODIR) < 0) 183 err(EXIT_FAILURE, "%s", _PATH_RWHODIR); 184 (void)signal(SIGHUP, sighup); 185 openlog(getprogname(), LOG_PID, LOG_DAEMON); 186 /* 187 * Establish host name as returned by system. 188 */ 189 if (gethostname(myname, sizeof(myname) - 1) < 0) { 190 syslog(LOG_ERR, "gethostname: %m"); 191 exit(EXIT_FAILURE); 192 } 193 myname[sizeof(myname) - 1] = '\0'; 194 if ((cp = strchr(myname, '.')) != NULL) 195 *cp = '\0'; 196 (void)strncpy(mywd.wd_hostname, myname, sizeof(mywd.wd_hostname) - 1); 197 getboottime(); 198 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 199 syslog(LOG_ERR, "socket: %m"); 200 exit(EXIT_FAILURE); 201 } 202 if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0) { 203 syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m"); 204 exit(EXIT_FAILURE); 205 } 206 (void)memset(&sasin, 0, sizeof(sasin)); 207 sasin.sin_family = AF_INET; 208 sasin.sin_port = sp->s_port; 209 if (bind(s, (struct sockaddr *)&sasin, sizeof(sasin)) < 0) { 210 syslog(LOG_ERR, "bind: %m"); 211 exit(EXIT_FAILURE); 212 } 213 if (!configure(s)) 214 exit(EXIT_FAILURE); 215 216 if (newuser) 217 if (!drop_privs(newuser)) 218 exit(EXIT_FAILURE); 219 220 send_host_information(s); 221 delta.tv_sec = time_interval; 222 delta.tv_usec = 0; 223 gettimeofday(&now, NULL); 224 timeradd(&now, &delta, &next); 225 226 pfd[0].fd = s; 227 pfd[0].events = POLLIN; 228 229 for (;;) { 230 int n; 231 232 n = poll(pfd, 1, 1000); 233 234 if (onsighup) { 235 onsighup = 0; 236 getboottime(); 237 } 238 239 if (n == 1) 240 handleread(s); 241 242 (void)gettimeofday(&now, NULL); 243 if (timercmp(&now, &next, >)) { 244 send_host_information(s); 245 timeradd(&now, &delta, &next); 246 } 247 } 248 249 /* NOTREACHED */ 250 return 0; 251 } 252 253 static void 254 sighup(int signo __unused) 255 { 256 onsighup = 1; 257 } 258 259 static void 260 handleread(int s) 261 { 262 struct sockaddr_in from; 263 struct stat st; 264 char path[64]; 265 struct whod wd; 266 int cc, whod; 267 socklen_t len = sizeof(from); 268 269 cc = recvfrom(s, (char *)&wd, sizeof(struct whod), 0, 270 (struct sockaddr *)&from, &len); 271 if (cc <= 0) { 272 if (cc < 0 && errno != EINTR) 273 syslog(LOG_WARNING, "recv: %m"); 274 return; 275 } 276 if (from.sin_port != sp->s_port) { 277 syslog(LOG_WARNING, "%d: bad from port", 278 ntohs(from.sin_port)); 279 return; 280 } 281 if (cc < (int)WHDRSIZE) { 282 syslog(LOG_WARNING, "Short packet from %s", 283 inet_ntoa(from.sin_addr)); 284 return; 285 } 286 287 if (wd.wd_vers != WHODVERSION) 288 return; 289 if (wd.wd_type != WHODTYPE_STATUS) 290 return; 291 /* 292 * Ensure null termination of the name within the packet. 293 * Otherwise we might overflow or read past the end. 294 */ 295 wd.wd_hostname[sizeof(wd.wd_hostname)-1] = 0; 296 if (!verify(wd.wd_hostname)) { 297 syslog(LOG_WARNING, "malformed host name from %s", 298 inet_ntoa(from.sin_addr)); 299 return; 300 } 301 (void)snprintf(path, sizeof(path), "whod.%s", wd.wd_hostname); 302 /* 303 * Rather than truncating and growing the file each time, 304 * use ftruncate if size is less than previous size. 305 */ 306 whod = open(path, O_WRONLY | O_CREAT, 0644); 307 if (whod < 0) { 308 syslog(LOG_WARNING, "%s: %m", path); 309 return; 310 } 311 #if ENDIAN != BIG_ENDIAN 312 { 313 int i, n = (cc - WHDRSIZE) / sizeof(struct whoent); 314 struct whoent *we; 315 316 /* undo header byte swapping before writing to file */ 317 wd.wd_sendtime = ntohl(wd.wd_sendtime); 318 for (i = 0; i < 3; i++) 319 wd.wd_loadav[i] = ntohl(wd.wd_loadav[i]); 320 wd.wd_boottime = ntohl(wd.wd_boottime); 321 we = wd.wd_we; 322 for (i = 0; i < n; i++) { 323 we->we_idle = ntohl(we->we_idle); 324 we->we_utmp.out_time = 325 ntohl(we->we_utmp.out_time); 326 we++; 327 } 328 } 329 #endif 330 wd.wd_recvtime = time(NULL); 331 (void)write(whod, (char *)&wd, cc); 332 if (fstat(whod, &st) < 0 || st.st_size > cc) 333 (void)ftruncate(whod, cc); 334 (void)close(whod); 335 } 336 337 /* 338 * Check out host name for unprintables 339 * and other funnies before allowing a file 340 * to be created. Sorry, but blanks aren't allowed. 341 */ 342 static int 343 verify(const char *name) 344 { 345 int size = 0; 346 347 while (*name) { 348 if (!isascii((unsigned char)*name) || 349 !(isalnum((unsigned char)*name) || 350 ispunct((unsigned char)*name))) 351 return 0; 352 name++, size++; 353 } 354 return size > 0; 355 } 356 357 static void 358 send_host_information(int s) 359 { 360 struct neighbor *np; 361 struct whoent *we = mywd.wd_we, *wlast; 362 int i, cc, utmpent = 0; 363 struct stat stb; 364 double avenrun[3]; 365 time_t now; 366 static struct utmpentry *ohead = NULL; 367 struct utmpentry *ep; 368 static int count = 0; 369 370 now = time(NULL); 371 if (count % 10 == 0) 372 getboottime(); 373 count++; 374 375 (void)getutentries(NULL, &ep); 376 /* XXX probably should expose utmp mtime, check that instead */ 377 if (ep != ohead) { 378 wlast = &mywd.wd_we[1024 / sizeof(struct whoent) - 1]; 379 for (; ep; ep = ep->next) { 380 (void)strncpy(we->we_utmp.out_line, ep->line, 381 sizeof(we->we_utmp.out_line)); 382 (void)strncpy(we->we_utmp.out_name, ep->name, 383 sizeof(we->we_utmp.out_name)); 384 we->we_utmp.out_time = htonl(ep->tv.tv_sec); 385 if (we >= wlast) 386 break; 387 we++; 388 } 389 utmpent = we - mywd.wd_we; 390 } 391 392 /* 393 * The test on utmpent looks silly---after all, if no one is 394 * logged on, why worry about efficiency?---but is useful on 395 * (e.g.) compute servers. 396 */ 397 if (utmpent && chdir(_PATH_DEV)) { 398 syslog(LOG_ERR, "chdir(%s): %m", _PATH_DEV); 399 exit(EXIT_FAILURE); 400 } 401 we = mywd.wd_we; 402 for (i = 0; i < utmpent; i++) { 403 if (stat(we->we_utmp.out_line, &stb) >= 0) 404 we->we_idle = htonl(now - stb.st_atime); 405 we++; 406 } 407 (void)getloadavg(avenrun, sizeof(avenrun)/sizeof(avenrun[0])); 408 for (i = 0; i < 3; i++) 409 mywd.wd_loadav[i] = htonl((u_long)(avenrun[i] * 100)); 410 cc = (char *)we - (char *)&mywd; 411 mywd.wd_sendtime = htonl(time(0)); 412 mywd.wd_vers = WHODVERSION; 413 mywd.wd_type = WHODTYPE_STATUS; 414 for (np = neighbors; np != NULL; np = np->n_next) 415 (void)Sendto(s, (char *)&mywd, cc, 0, 416 np->n_addr, np->n_addrlen); 417 if (utmpent && chdir(_PATH_RWHODIR)) { 418 syslog(LOG_ERR, "chdir(%s): %m", _PATH_RWHODIR); 419 exit(EXIT_FAILURE); 420 } 421 } 422 423 static void 424 getboottime(void) 425 { 426 int mib[2]; 427 size_t size; 428 struct timeval tm; 429 430 mib[0] = CTL_KERN; 431 mib[1] = KERN_BOOTTIME; 432 size = sizeof(tm); 433 if (sysctl(mib, 2, &tm, &size, NULL, 0) == -1) { 434 syslog(LOG_ERR, "cannot get boottime: %m"); 435 exit(EXIT_FAILURE); 436 } 437 mywd.wd_boottime = htonl(tm.tv_sec); 438 } 439 440 static void 441 quit(const char *msg) 442 { 443 syslog(LOG_ERR, "%s", msg); 444 exit(EXIT_FAILURE); 445 } 446 447 #define ROUNDUP(a) \ 448 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) 449 #define ADVANCE(x, n) ((char *)(x) + ROUNDUP((n)->sa_len)) 450 451 static void 452 rt_xaddrs(void *cp, void *cplim, struct rt_addrinfo *rtinfo) 453 { 454 struct sockaddr *sa; 455 int i; 456 457 (void)memset(rtinfo->rti_info, 0, sizeof(rtinfo->rti_info)); 458 for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) { 459 if ((rtinfo->rti_addrs & (1 << i)) == 0) 460 continue; 461 rtinfo->rti_info[i] = sa = (struct sockaddr *)cp; 462 cp = ADVANCE(cp, sa); 463 } 464 } 465 466 /* 467 * Figure out device configuration and select 468 * networks which deserve status information. 469 */ 470 static int 471 configure(int s) 472 { 473 struct neighbor *np; 474 struct if_msghdr *ifm; 475 struct ifa_msghdr *ifam; 476 struct sockaddr_dl *sdl; 477 size_t needed; 478 int mib[6], flags = 0, len; 479 char *buf, *lim, *next; 480 struct rt_addrinfo info; 481 struct sockaddr_in dstaddr; 482 483 mib[0] = CTL_NET; 484 mib[1] = PF_ROUTE; 485 mib[2] = 0; 486 mib[3] = AF_INET; 487 mib[4] = NET_RT_IFLIST; 488 mib[5] = 0; 489 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 490 quit("route-sysctl-estimate"); 491 if ((buf = malloc(needed)) == NULL) 492 quit("malloc"); 493 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 494 quit("actual retrieval of interface table"); 495 lim = buf + needed; 496 497 sdl = NULL; /* XXX just to keep gcc -Wall happy */ 498 for (next = buf; next < lim; next += ifm->ifm_msglen) { 499 ifm = (struct if_msghdr *)next; 500 if (ifm->ifm_type == RTM_IFINFO) { 501 sdl = (struct sockaddr_dl *)(ifm + 1); 502 flags = ifm->ifm_flags; 503 continue; 504 } 505 if ((flags & IFF_UP) == 0 || 506 (flags & (IFF_BROADCAST|IFF_POINTOPOINT)) == 0) 507 continue; 508 if (ifm->ifm_type != RTM_NEWADDR) 509 quit("out of sync parsing NET_RT_IFLIST"); 510 ifam = (struct ifa_msghdr *)ifm; 511 info.rti_addrs = ifam->ifam_addrs; 512 rt_xaddrs((ifam + 1), ifam->ifam_msglen + (char *)ifam, &info); 513 /* gag, wish we could get rid of Internet dependencies */ 514 if (info.rti_info[RTAX_BRD] == NULL || 515 info.rti_info[RTAX_BRD]->sa_family != AF_INET) 516 continue; 517 (void)memcpy(&dstaddr, info.rti_info[RTAX_BRD], 518 sizeof(dstaddr)); 519 #define IPADDR_SA(x) ((struct sockaddr_in *)(x))->sin_addr.s_addr 520 #define PORT_SA(x) ((struct sockaddr_in *)(x))->sin_port 521 PORT_SA(&dstaddr) = sp->s_port; 522 for (np = neighbors; np != NULL; np = np->n_next) 523 if (memcmp(sdl->sdl_data, np->n_name, 524 sdl->sdl_nlen) == 0 && 525 IPADDR_SA(np->n_addr) == IPADDR_SA(&dstaddr)) 526 break; 527 if (np != NULL) 528 continue; 529 len = sizeof(*np) + dstaddr.sin_len + sdl->sdl_nlen + 1; 530 np = (struct neighbor *)malloc(len); 531 if (np == NULL) 532 quit("malloc of neighbor structure"); 533 (void)memset(np, 0, len); 534 np->n_flags = flags; 535 np->n_addr = (struct sockaddr *)(np + 1); 536 np->n_addrlen = dstaddr.sin_len; 537 np->n_name = np->n_addrlen + (char *)np->n_addr; 538 np->n_next = neighbors; 539 neighbors = np; 540 (void)memcpy(np->n_addr, &dstaddr, np->n_addrlen); 541 (void)memcpy(np->n_name, sdl->sdl_data, sdl->sdl_nlen); 542 } 543 free(buf); 544 return (1); 545 } 546 547 #ifdef DEBUG 548 static ssize_t 549 Sendto(int s, const void *buf, size_t cc, int flags, const struct sockaddr *to, 550 socklen_t tolen) 551 { 552 struct whod *w = (struct whod *)buf; 553 struct whoent *we; 554 struct sockaddr_in *sasin = (struct sockaddr_in *)to; 555 ssize_t ret; 556 557 ret = sendto(s, buf, cc, flags, to, tolen); 558 559 printf("sendto %s.%d\n", inet_ntoa(sasin->sin_addr), 560 ntohs(sasin->sin_port)); 561 printf("hostname %s %s\n", w->wd_hostname, 562 interval(ntohl(w->wd_sendtime) - ntohl(w->wd_boottime), " up")); 563 printf("load %4.2f, %4.2f, %4.2f\n", 564 ntohl(w->wd_loadav[0]) / 100.0, ntohl(w->wd_loadav[1]) / 100.0, 565 ntohl(w->wd_loadav[2]) / 100.0); 566 cc -= WHDRSIZE; 567 for (we = w->wd_we, cc /= sizeof(struct whoent); cc > 0; cc--, we++) { 568 time_t t = ntohl(we->we_utmp.out_time); 569 printf("%-8.8s %s:%s %.12s", we->we_utmp.out_name, 570 w->wd_hostname, we->we_utmp.out_line, ctime(&t)+4); 571 we->we_idle = ntohl(we->we_idle) / 60; 572 if (we->we_idle) { 573 if (we->we_idle >= 100*60) 574 we->we_idle = 100*60 - 1; 575 if (we->we_idle >= 60) 576 printf(" %2d", we->we_idle / 60); 577 else 578 printf(" "); 579 printf(":%02d", we->we_idle % 60); 580 } 581 printf("\n"); 582 } 583 return ret; 584 } 585 586 static char * 587 interval(int time, const char *updown) 588 { 589 static char resbuf[32]; 590 int days, hours, minutes; 591 592 if (time < 0 || time > 3*30*24*60*60) { 593 (void)snprintf(resbuf, sizeof(resbuf), " %s ??:??", updown); 594 return (resbuf); 595 } 596 minutes = (time + 59) / 60; /* round to minutes */ 597 hours = minutes / 60; minutes %= 60; 598 days = hours / 24; hours %= 24; 599 if (days) 600 (void)snprintf(resbuf, sizeof(resbuf), "%s %2d+%02d:%02d", 601 updown, days, hours, minutes); 602 else 603 (void)snprintf(resbuf, sizeof(resbuf), "%s %2d:%02d", 604 updown, hours, minutes); 605 return resbuf; 606 } 607 #endif 608 609 static int 610 drop_privs(char *newuser) 611 { 612 struct passwd *pw; 613 gid_t gidset[1]; 614 615 pw = getpwnam(newuser); 616 if (pw == NULL) { 617 syslog(LOG_ERR, "no user %.100s", newuser); 618 return 0; 619 } 620 621 endpwent(); 622 623 gidset[0] = pw->pw_gid; 624 if (setgroups(1, gidset) == -1) { 625 syslog(LOG_ERR, "setgroups: %m"); 626 return 0; 627 } 628 629 if (setgid(pw->pw_gid) == -1) { 630 syslog(LOG_ERR, "setgid: %m"); 631 return 0; 632 } 633 634 if (setuid(pw->pw_uid) == -1) { 635 syslog(LOG_ERR, "setuid: %m"); 636 return 0; 637 } 638 639 return 1; 640 } 641 642 static void 643 usage(void) 644 { 645 (void)fprintf(stderr, "Usage: %s [-i interval] [-u user]\n", getprogname()); 646 exit(EXIT_FAILURE); 647 } 648