usr.sbin/rwhod/rwhod.c

   1 /*-
   2  * Copyright (c) 1983, 1993 The Regents of the University of California.
   3  * Copyright (c) 2013 Mariusz Zaborski <oshogbo@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 4. Neither the name of the University nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #ifndef lint
  32 static const char copyright[] =
  33 "@(#) Copyright (c) 1983, 1993\n\
  34         The Regents of the University of California.  All rights reserved.\n";
  35 #endif /* not lint */
  36
  37 #if 0
  38 #ifndef lint
  39 static char sccsid[] = "@(#)rwhod.c     8.1 (Berkeley) 6/6/93";
  40 #endif /* not lint */
  41 #endif
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include <sys/capsicum.h>
  47 #include <sys/param.h>
  48 #include <sys/socket.h>
  49 #include <sys/stat.h>
  50 #include <sys/signal.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/sysctl.h>
  53 #include <sys/procdesc.h>
  54 #include <sys/wait.h>
  55
  56 #include <net/if.h>
  57 #include <net/if_dl.h>
  58 #include <net/route.h>
  59 #include <netinet/in.h>
  60 #include <arpa/inet.h>
  61 #include <protocols/rwhod.h>
  62
  63 #include <ctype.h>
  64 #include <err.h>
  65 #include <errno.h>
  66 #include <fcntl.h>
  67 #include <grp.h>
  68 #include <netdb.h>
  69 #include <paths.h>
  70 #include <pwd.h>
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <syslog.h>
  75 #include <timeconv.h>
  76 #include <utmpx.h>
  77 #include <unistd.h>
  78
  79 #define UNPRIV_USER             "daemon"
  80 #define UNPRIV_GROUP            "daemon"
  81
  82 #define NO_MULTICAST            0         /* multicast modes */
  83 #define PER_INTERFACE_MULTICAST 1
  84 #define SCOPED_MULTICAST        2
  85
  86 #define MAX_MULTICAST_SCOPE     32        /* "site-wide", by convention */
  87
  88 #define INADDR_WHOD_GROUP (u_long)0xe0000103      /* 224.0.1.3 */
  89                                                   /* (belongs in protocols/rwhod.h) */
  90
  91 int     insecure_mode;
  92 int     quiet_mode;
  93 int     iff_flag = IFF_POINTOPOINT;
  94 int     multicast_mode = NO_MULTICAST;
  95 int     multicast_scope;
  96 struct  sockaddr_in multicast_addr =
  97         { sizeof(multicast_addr), AF_INET, 0, { 0 }, { 0 } };
  98
  99 /*
 100  * Sleep interval. Don't forget to change the down time check in ruptime
 101  * if this is changed.
 102  */
 103 #define SL_INTERVAL (3 * 60)
 104
 105 char    myname[MAXHOSTNAMELEN];
 106
 107 /*
 108  * We communicate with each neighbor in a list constructed at the time we're
 109  * started up.  Neighbors are currently directly connected via a hardware
 110  * interface.
 111  */
 112 struct  neighbor {
 113         struct  neighbor *n_next;
 114         char             *n_name;               /* interface name */
 115         struct  sockaddr *n_addr;               /* who to send to */
 116         int               n_addrlen;            /* size of address */
 117         int               n_flags;              /* should forward?, interface flags */
 118 };
 119
 120 struct  neighbor *neighbors;
 121 struct  whod mywd;
 122 struct  servent *sp;
 123 int     s;
 124 int     fdp;
 125 pid_t   pid_child_receiver;
 126
 127 #define WHDRSIZE        (int)(sizeof(mywd) - sizeof(mywd.wd_we))
 128
 129 int     configure(int so);
 130 void    getboottime(int signo __unused);
 131 void    receiver_process(void);
 132 void    rt_xaddrs(caddr_t cp, caddr_t cplim, struct rt_addrinfo *rtinfo);
 133 void    run_as(uid_t *uid, gid_t *gid);
 134 void    quit(const char *msg);
 135 void    sender_process(void);
 136 int     verify(char *name, int maxlen);
 137 static void usage(void);
 138
 139 #ifdef DEBUG
 140 char    *interval(int time, char *updown);
 141 void    Sendto(int s, const void *buf, size_t cc, int flags,
 142             const struct sockaddr *to, int tolen);
 143 #define  sendto Sendto
 144 #endif
 145
 146 /*
 147  * This version of Berkeley's rwhod has been modified to use IP multicast
 148  * datagrams, under control of a new command-line option:
 149  *
 150  *      rwhod -m        causes rwhod to use IP multicast (instead of
 151  *                      broadcast or unicast) on all interfaces that have
 152  *                      the IFF_MULTICAST flag set in their "ifnet" structs
 153  *                      (excluding the loopback interface).  The multicast
 154  *                      reports are sent with a time-to-live of 1, to prevent
 155  *                      forwarding beyond the directly-connected subnet(s).
 156  *
 157  *      rwhod -m <ttl>  causes rwhod to send IP multicast datagrams with a
 158  *                      time-to-live of <ttl>, via a SINGLE interface rather
 159  *                      than all interfaces.  <ttl> must be between 0 and
 160  *                      MAX_MULTICAST_SCOPE, defined below.  Note that "-m 1"
 161  *                      is different than "-m", in that "-m 1" specifies
 162  *                      transmission on one interface only.
 163  *
 164  * When "-m" is used without a <ttl> argument, the program accepts multicast
 165  * rwhod reports from all multicast-capable interfaces.  If a <ttl> argument
 166  * is given, it accepts multicast reports from only one interface, the one
 167  * on which reports are sent (which may be controlled via the host's routing
 168  * table).  Regardless of the "-m" option, the program accepts broadcast or
 169  * unicast reports from all interfaces.  Thus, this program will hear the
 170  * reports of old, non-multicasting rwhods, but, if multicasting is used,
 171  * those old rwhods won't hear the reports generated by this program.
 172  *
 173  *                  -- Steve Deering, Stanford University, February 1989
 174  */
 175 int
 176 main(int argc, char *argv[])
 177 {
 178         int on;
 179         char *cp;
 180         struct sockaddr_in soin;
 181         uid_t unpriv_uid;
 182         gid_t unpriv_gid;
 183
 184         on = 1;
 185         if (getuid())
 186                 errx(1, "not super user");
 187
 188         run_as(&unpriv_uid, &unpriv_gid);
 189
 190         argv++;
 191         argc--;
 192         while (argc > 0 && *argv[0] == '-') {
 193                 if (strcmp(*argv, "-m") == 0) {
 194                         if (argc > 1 && isdigit(*(argv + 1)[0])) {
 195                                 argv++;
 196                                 argc--;
 197                                 multicast_mode  = SCOPED_MULTICAST;
 198                                 multicast_scope = atoi(*argv);
 199                                 if (multicast_scope > MAX_MULTICAST_SCOPE) {
 200                                         errx(1, "ttl must not exceed %u",
 201                                             MAX_MULTICAST_SCOPE);
 202                                 }
 203                         } else {
 204                                 multicast_mode = PER_INTERFACE_MULTICAST;
 205                         }
 206                 } else if (strcmp(*argv, "-i") == 0) {
 207                         insecure_mode = 1;
 208                 } else if (strcmp(*argv, "-l") == 0) {
 209                         quiet_mode = 1;
 210                 } else if (strcmp(*argv, "-p") == 0) {
 211                         iff_flag = 0;
 212                 } else {
 213                         usage();
 214                 }
 215                 argv++;
 216                 argc--;
 217         }
 218         if (argc > 0)
 219                 usage();
 220 #ifndef DEBUG
 221         daemon(1, 0);
 222 #endif
 223         (void) signal(SIGHUP, getboottime);
 224         openlog("rwhod", LOG_PID | LOG_NDELAY, LOG_DAEMON);
 225         sp = getservbyname("who", "udp");
 226         if (sp == NULL) {
 227                 syslog(LOG_ERR, "who/udp: unknown service");
 228                 exit(1);
 229         }
 230         if (chdir(_PATH_RWHODIR) < 0) {
 231                 syslog(LOG_ERR, "%s: %m", _PATH_RWHODIR);
 232                 exit(1);
 233         }
 234         /*
 235          * Establish host name as returned by system.
 236          */
 237         if (gethostname(myname, sizeof(myname) - 1) < 0) {
 238                 syslog(LOG_ERR, "gethostname: %m");
 239                 exit(1);
 240         }
 241         if ((cp = strchr(myname, '.')) != NULL)
 242                 *cp = '\0';
 243         strlcpy(mywd.wd_hostname, myname, sizeof(mywd.wd_hostname));
 244         getboottime(0);
 245         if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 246                 syslog(LOG_ERR, "socket: %m");
 247                 exit(1);
 248         }
 249         if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0) {
 250                 syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
 251                 exit(1);
 252         }
 253         memset(&soin, 0, sizeof(soin));
 254         soin.sin_len = sizeof(soin);
 255         soin.sin_family = AF_INET;
 256         soin.sin_port = sp->s_port;
 257         if (bind(s, (struct sockaddr *)&soin, sizeof(soin)) < 0) {
 258                 syslog(LOG_ERR, "bind: %m");
 259                 exit(1);
 260         }
 261         if (setgid(unpriv_gid) != 0) {
 262                 syslog(LOG_ERR, "setgid: %m");
 263                 exit(1);
 264         }
 265         if (setgroups(1, &unpriv_gid) != 0) {   /* XXX BOGUS groups[0] = egid */
 266                 syslog(LOG_ERR, "setgroups: %m");
 267                 exit(1);
 268         }
 269         if (setuid(unpriv_uid) != 0) {
 270                 syslog(LOG_ERR, "setuid: %m");
 271                 exit(1);
 272         }
 273         if (!configure(s))
 274                 exit(1);
 275         if (!quiet_mode) {
 276                 pid_child_receiver = pdfork(&fdp, 0);
 277                 if (pid_child_receiver == 0) {
 278                         receiver_process();
 279                 } else if (pid_child_receiver > 0) {
 280                         sender_process();
 281                 } else if (pid_child_receiver == -1) {
 282                         if (errno == ENOSYS) {
 283                                 syslog(LOG_ERR,
 284                                     "The pdfork(2) system call is not available; recompile the kernel with options PROCDESC");
 285                         } else {
 286                                 syslog(LOG_ERR, "pdfork: %m");
 287                         }
 288                         exit(1);
 289                 }
 290         } else {
 291                 receiver_process();
 292         }
 293 }
 294
 295 static void
 296 usage(void)
 297 {
 298
 299         fprintf(stderr, "usage: rwhod [-i] [-p] [-l] [-m [ttl]]\n");
 300         exit(1);
 301 }
 302
 303 void
 304 run_as(uid_t *uid, gid_t *gid)
 305 {
 306         struct passwd *pw;
 307         struct group *gr;
 308
 309         pw = getpwnam(UNPRIV_USER);
 310         if (pw == NULL) {
 311                 syslog(LOG_ERR, "getpwnam(%s): %m", UNPRIV_USER);
 312                 exit(1);
 313         }
 314         *uid = pw->pw_uid;
 315
 316         gr = getgrnam(UNPRIV_GROUP);
 317         if (gr == NULL) {
 318                 syslog(LOG_ERR, "getgrnam(%s): %m", UNPRIV_GROUP);
 319                 exit(1);
 320         }
 321         *gid = gr->gr_gid;
 322 }
 323
 324 /*
 325  * Check out host name for unprintables
 326  * and other funnies before allowing a file
 327  * to be created.  Sorry, but blanks aren't allowed.
 328  */
 329 int
 330 verify(char *name, int maxlen)
 331 {
 332         int size;
 333
 334         size = 0;
 335         while (*name != '\0' && size < maxlen - 1) {
 336                 if (!isascii((unsigned char)*name) ||
 337                     !(isalnum((unsigned char)*name) ||
 338                     ispunct((unsigned char)*name))) {
 339                         return (0);
 340                 }
 341                 name++;
 342                 size++;
 343         }
 344         *name = '\0';
 345         return (size > 0);
 346 }
 347
 348 void
 349 receiver_process(void)
 350 {
 351         struct sockaddr_in from;
 352         struct stat st;
 353         cap_rights_t rights;
 354         char path[64];
 355         int dirfd;
 356         struct whod wd;
 357         socklen_t len;
 358         int cc, whod;
 359         time_t t;
 360
 361         len = sizeof(from);
 362         dirfd = open(".", O_RDONLY | O_DIRECTORY);
 363         if (dirfd < 0) {
 364                 syslog(LOG_WARNING, "%s: %m", _PATH_RWHODIR);
 365                 exit(1);
 366         }
 367         cap_rights_init(&rights, CAP_CREATE, CAP_FSTAT, CAP_FTRUNCATE,
 368             CAP_LOOKUP, CAP_SEEK, CAP_WRITE);
 369         if (cap_rights_limit(dirfd, &rights) < 0 && errno != ENOSYS) {
 370                 syslog(LOG_WARNING, "cap_rights_limit: %m");
 371                 exit(1);
 372         }
 373         if (cap_enter() < 0 && errno != ENOSYS) {
 374                 syslog(LOG_ERR, "cap_enter: %m");
 375                 exit(1);
 376         }
 377         for (;;) {
 378                 cc = recvfrom(s, &wd, sizeof(wd), 0, (struct sockaddr *)&from,
 379                     &len);
 380                 if (cc <= 0) {
 381                         if (cc < 0 && errno != EINTR)
 382                                 syslog(LOG_WARNING, "recv: %m");
 383                         continue;
 384                 }
 385                 if (from.sin_port != sp->s_port && !insecure_mode) {
 386                         syslog(LOG_WARNING, "%d: bad source port from %s",
 387                             ntohs(from.sin_port), inet_ntoa(from.sin_addr));
 388                         continue;
 389                 }
 390                 if (cc < WHDRSIZE) {
 391                         syslog(LOG_WARNING, "short packet from %s",
 392                             inet_ntoa(from.sin_addr));
 393                         continue;
 394                 }
 395                 if (wd.wd_vers != WHODVERSION)
 396                         continue;
 397                 if (wd.wd_type != WHODTYPE_STATUS)
 398                         continue;
 399                 if (!verify(wd.wd_hostname, sizeof(wd.wd_hostname))) {
 400                         syslog(LOG_WARNING, "malformed host name from %s",
 401                             inet_ntoa(from.sin_addr));
 402                         continue;
 403                 }
 404                 (void) snprintf(path, sizeof(path), "whod.%s", wd.wd_hostname);
 405                 /*
 406                  * Rather than truncating and growing the file each time,
 407                  * use ftruncate if size is less than previous size.
 408                  */
 409                 whod = openat(dirfd, path, O_WRONLY | O_CREAT, 0644);
 410                 if (whod < 0) {
 411                         syslog(LOG_WARNING, "%s: %m", path);
 412                         continue;
 413                 }
 414                 cap_rights_init(&rights, CAP_FSTAT, CAP_FTRUNCATE, CAP_WRITE);
 415                 if (cap_rights_limit(whod, &rights) < 0 && errno != ENOSYS) {
 416                         syslog(LOG_WARNING, "cap_rights_limit: %m");
 417                         exit(1);
 418                 }
 419 #if ENDIAN != BIG_ENDIAN
 420                 {
 421                         struct whoent *we;
 422                         int i, n;
 423
 424                         n = (cc - WHDRSIZE) / sizeof(struct whoent);
 425                         /* undo header byte swapping before writing to file */
 426                         wd.wd_sendtime = ntohl(wd.wd_sendtime);
 427                         for (i = 0; i < 3; i++)
 428                                 wd.wd_loadav[i] = ntohl(wd.wd_loadav[i]);
 429                         wd.wd_boottime = ntohl(wd.wd_boottime);
 430                         we = wd.wd_we;
 431                         for (i = 0; i < n; i++) {
 432                                 we->we_idle = ntohl(we->we_idle);
 433                                 we->we_utmp.out_time =
 434                                     ntohl(we->we_utmp.out_time);
 435                                 we++;
 436                         }
 437                 }
 438 #endif
 439                 (void) time(&t);
 440                 wd.wd_recvtime = _time_to_int(t);
 441                 (void) write(whod, (char *)&wd, cc);
 442                 if (fstat(whod, &st) < 0 || st.st_size > cc)
 443                         ftruncate(whod, cc);
 444                 (void) close(whod);
 445         }
 446         (void) close(dirfd);
 447 }
 448
 449 void
 450 sender_process(void)
 451 {
 452         int sendcount;
 453         double avenrun[3];
 454         time_t now;
 455         int i, cc, status;
 456         struct utmpx *ut;
 457         struct stat stb;
 458         struct neighbor *np;
 459         struct whoent *we, *wend;
 460
 461         sendcount = 0;
 462         for (;;) {
 463                 we = mywd.wd_we;
 464                 now = time(NULL);
 465                 if (sendcount % 10 == 0)
 466                         getboottime(0);
 467                 sendcount++;
 468                 wend = &mywd.wd_we[1024 / sizeof(struct whoent)];
 469                 setutxent();
 470                 while ((ut = getutxent()) != NULL && we < wend) {
 471                         if (ut->ut_type != USER_PROCESS)
 472                                 continue;
 473                         strncpy(we->we_utmp.out_line, ut->ut_line,
 474                             sizeof(we->we_utmp.out_line));
 475                         strncpy(we->we_utmp.out_name, ut->ut_user,
 476                             sizeof(we->we_utmp.out_name));
 477                         we->we_utmp.out_time =
 478                             htonl(_time_to_time32(ut->ut_tv.tv_sec));
 479                         we++;
 480                 }
 481                 endutxent();
 482
 483                 if (chdir(_PATH_DEV) < 0) {
 484                         syslog(LOG_ERR, "chdir(%s): %m", _PATH_DEV);
 485                         exit(1);
 486                 }
 487                 wend = we;
 488                 for (we = mywd.wd_we; we < wend; we++) {
 489                         if (stat(we->we_utmp.out_line, &stb) >= 0)
 490                                 we->we_idle = htonl(now - stb.st_atime);
 491                         we++;
 492                 }
 493                 (void) getloadavg(avenrun,
 494                     sizeof(avenrun) / sizeof(avenrun[0]));
 495                 for (i = 0; i < 3; i++)
 496                         mywd.wd_loadav[i] = htonl((u_long)(avenrun[i] * 100));
 497                 cc = (char *)wend - (char *)&mywd;
 498                 mywd.wd_sendtime = htonl(_time_to_time32(time(NULL)));
 499                 mywd.wd_vers = WHODVERSION;
 500                 mywd.wd_type = WHODTYPE_STATUS;
 501                 if (multicast_mode == SCOPED_MULTICAST) {
 502                         (void) sendto(s, (char *)&mywd, cc, 0,
 503                             (struct sockaddr *)&multicast_addr,
 504                             sizeof(multicast_addr));
 505                 } else {
 506                         for (np = neighbors; np != NULL; np = np->n_next) {
 507                                 if (multicast_mode == PER_INTERFACE_MULTICAST &&
 508                                     (np->n_flags & IFF_MULTICAST) != 0) {
 509                                         /*
 510                                          * Select the outgoing interface for the
 511                                          * multicast.
 512                                          */
 513                                         if (setsockopt(s, IPPROTO_IP,
 514                                             IP_MULTICAST_IF,
 515                                             &(((struct sockaddr_in *)np->n_addr)->sin_addr),
 516                                             sizeof(struct in_addr)) < 0) {
 517                                                 syslog(LOG_ERR,
 518                                                     "setsockopt IP_MULTICAST_IF: %m");
 519                                                 exit(1);
 520                                         }
 521                                         (void) sendto(s, (char *)&mywd, cc, 0,
 522                                             (struct sockaddr *)&multicast_addr,
 523                                             sizeof(multicast_addr));
 524                                 } else {
 525                                         (void) sendto(s, (char *)&mywd, cc, 0,
 526                                             np->n_addr, np->n_addrlen);
 527                                 }
 528                         }
 529                 }
 530                 if (chdir(_PATH_RWHODIR) < 0) {
 531                         syslog(LOG_ERR, "chdir(%s): %m", _PATH_RWHODIR);
 532                         exit(1);
 533                 }
 534                 if (waitpid(pid_child_receiver, &status, WNOHANG) ==
 535                     pid_child_receiver) {
 536                         break;
 537                 }
 538                 sleep(SL_INTERVAL);
 539         }
 540 }
 541
 542 void
 543 getboottime(int signo __unused)
 544 {
 545         int mib[2];
 546         size_t size;
 547         struct timeval tm;
 548
 549         mib[0] = CTL_KERN;
 550         mib[1] = KERN_BOOTTIME;
 551         size = sizeof(tm);
 552         if (sysctl(mib, 2, &tm, &size, NULL, 0) == -1) {
 553                 syslog(LOG_ERR, "cannot get boottime: %m");
 554                 exit(1);
 555         }
 556         mywd.wd_boottime = htonl(_time_to_time32(tm.tv_sec));
 557 }
 558
 559 void
 560 quit(const char *msg)
 561 {
 562
 563         syslog(LOG_ERR, "%s", msg);
 564         exit(1);
 565 }
 566
 567 void
 568 rt_xaddrs(caddr_t cp, caddr_t cplim, struct rt_addrinfo *rtinfo)
 569 {
 570         struct sockaddr *sa;
 571         int i;
 572
 573         memset(rtinfo->rti_info, 0, sizeof(rtinfo->rti_info));
 574         for (i = 0; i < RTAX_MAX && cp < cplim; i++) {
 575                 if ((rtinfo->rti_addrs & (1 << i)) == 0)
 576                         continue;
 577                 sa = (struct sockaddr *)cp;
 578                 rtinfo->rti_info[i] = sa;
 579                 cp += SA_SIZE(sa);
 580         }
 581 }
 582
 583 /*
 584  * Figure out device configuration and select
 585  * networks which deserve status information.
 586  */
 587 int
 588 configure(int so)
 589 {
 590         struct neighbor *np;
 591         struct if_msghdr *ifm;
 592         struct ifa_msghdr *ifam;
 593         struct sockaddr_dl *sdl;
 594         size_t needed;
 595         int mib[6], flags, lflags, len;
 596         char *buf, *lim, *next;
 597         struct rt_addrinfo info;
 598
 599         flags = 0;
 600         if (multicast_mode != NO_MULTICAST) {
 601                 multicast_addr.sin_addr.s_addr = htonl(INADDR_WHOD_GROUP);
 602                 multicast_addr.sin_port = sp->s_port;
 603         }
 604
 605         if (multicast_mode == SCOPED_MULTICAST) {
 606                 struct ip_mreq mreq;
 607                 unsigned char ttl;
 608
 609                 mreq.imr_multiaddr.s_addr = htonl(INADDR_WHOD_GROUP);
 610                 mreq.imr_interface.s_addr = htonl(INADDR_ANY);
 611                 if (setsockopt(so, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 612                     &mreq, sizeof(mreq)) < 0) {
 613                         syslog(LOG_ERR,
 614                             "setsockopt IP_ADD_MEMBERSHIP: %m");
 615                         return (0);
 616                 }
 617                 ttl = multicast_scope;
 618                 if (setsockopt(so, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
 619                     sizeof(ttl)) < 0) {
 620                         syslog(LOG_ERR,
 621                             "setsockopt IP_MULTICAST_TTL: %m");
 622                         return (0);
 623                 }
 624                 return (1);
 625         }
 626
 627         mib[0] = CTL_NET;
 628         mib[1] = PF_ROUTE;
 629         mib[2] = 0;
 630         mib[3] = AF_INET;
 631         mib[4] = NET_RT_IFLIST;
 632         mib[5] = 0;
 633         if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
 634                 quit("route-sysctl-estimate");
 635         if ((buf = malloc(needed)) == NULL)
 636                 quit("malloc");
 637         if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
 638                 quit("actual retrieval of interface table");
 639         lim = buf + needed;
 640
 641         sdl = NULL;             /* XXX just to keep gcc -Wall happy */
 642         for (next = buf; next < lim; next += ifm->ifm_msglen) {
 643                 ifm = (struct if_msghdr *)next;
 644                 if (ifm->ifm_type == RTM_IFINFO) {
 645                         sdl = (struct sockaddr_dl *)(ifm + 1);
 646                         flags = ifm->ifm_flags;
 647                         continue;
 648                 }
 649                 if ((flags & IFF_UP) == 0)
 650                         continue;
 651                 lflags = IFF_BROADCAST | iff_flag;
 652                 if (multicast_mode == PER_INTERFACE_MULTICAST)
 653                         lflags |= IFF_MULTICAST;
 654                 if ((flags & lflags) == 0)
 655                         continue;
 656                 if (ifm->ifm_type != RTM_NEWADDR)
 657                         quit("out of sync parsing NET_RT_IFLIST");
 658                 ifam = (struct ifa_msghdr *)ifm;
 659                 info.rti_addrs = ifam->ifam_addrs;
 660                 rt_xaddrs((char *)(ifam + 1), ifam->ifam_msglen + (char *)ifam,
 661                     &info);
 662                 /* gag, wish we could get rid of Internet dependencies */
 663 #define dstaddr         info.rti_info[RTAX_BRD]
 664 #define ifaddr          info.rti_info[RTAX_IFA]
 665 #define IPADDR_SA(x)    ((struct sockaddr_in *)(x))->sin_addr.s_addr
 666 #define PORT_SA(x)      ((struct sockaddr_in *)(x))->sin_port
 667                 if (dstaddr == 0 || dstaddr->sa_family != AF_INET)
 668                         continue;
 669                 PORT_SA(dstaddr) = sp->s_port;
 670                 for (np = neighbors; np != NULL; np = np->n_next) {
 671                         if (memcmp(sdl->sdl_data, np->n_name,
 672                             sdl->sdl_nlen) == 0 &&
 673                             IPADDR_SA(np->n_addr) == IPADDR_SA(dstaddr)) {
 674                                 break;
 675                         }
 676                 }
 677                 if (np != NULL)
 678                         continue;
 679                 len = sizeof(*np) + dstaddr->sa_len + sdl->sdl_nlen + 1;
 680                 np = malloc(len);
 681                 if (np == NULL)
 682                         quit("malloc of neighbor structure");
 683                 memset(np, 0, len);
 684                 np->n_flags = flags;
 685                 np->n_addr = (struct sockaddr *)(np + 1);
 686                 np->n_addrlen = dstaddr->sa_len;
 687                 np->n_name = np->n_addrlen + (char *)np->n_addr;
 688                 memcpy((char *)np->n_addr, (char *)dstaddr, np->n_addrlen);
 689                 memcpy(np->n_name, sdl->sdl_data, sdl->sdl_nlen);
 690                 if (multicast_mode == PER_INTERFACE_MULTICAST &&
 691                     (flags & IFF_MULTICAST) != 0 &&
 692                     (flags & IFF_LOOPBACK) == 0) {
 693                         struct ip_mreq mreq;
 694
 695                         memcpy((char *)np->n_addr, (char *)ifaddr,
 696                             np->n_addrlen);
 697                         mreq.imr_multiaddr.s_addr = htonl(INADDR_WHOD_GROUP);
 698                         mreq.imr_interface.s_addr =
 699                             ((struct sockaddr_in *)np->n_addr)->sin_addr.s_addr;
 700                         if (setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 701                             &mreq, sizeof(mreq)) < 0) {
 702                                 syslog(LOG_ERR,
 703                                     "setsockopt IP_ADD_MEMBERSHIP: %m");
 704 #if 0
 705                                 /* Fall back to broadcast on this if. */
 706                                 np->n_flags &= ~IFF_MULTICAST;
 707 #else
 708                                 free(np);
 709                                 continue;
 710 #endif
 711                         }
 712                 }
 713                 np->n_next = neighbors;
 714                 neighbors = np;
 715         }
 716         free(buf);
 717         return (1);
 718 }
 719
 720 #ifdef DEBUG
 721 void
 722 Sendto(int s, const void *buf, size_t cc, int flags, const struct sockaddr *to,
 723     int tolen)
 724 {
 725         struct whod *w;
 726         struct whoent *we;
 727         struct sockaddr_in *sin;
 728
 729         w = (struct whod *)buf;
 730         sin = (struct sockaddr_in *)to;
 731         printf("sendto %x.%d\n", ntohl(sin->sin_addr.s_addr),
 732             ntohs(sin->sin_port));
 733         printf("hostname %s %s\n", w->wd_hostname,
 734             interval(ntohl(w->wd_sendtime) - ntohl(w->wd_boottime), "  up"));
 735         printf("load %4.2f, %4.2f, %4.2f\n",
 736             ntohl(w->wd_loadav[0]) / 100.0, ntohl(w->wd_loadav[1]) / 100.0,
 737             ntohl(w->wd_loadav[2]) / 100.0);
 738         cc -= WHDRSIZE;
 739         for (we = w->wd_we, cc /= sizeof(struct whoent); cc > 0; cc--, we++) {
 740                 time_t t = _time32_to_time(ntohl(we->we_utmp.out_time));
 741
 742                 printf("%-8.8s %s:%s %.12s", we->we_utmp.out_name,
 743                     w->wd_hostname, we->we_utmp.out_line, ctime(&t) + 4);
 744                 we->we_idle = ntohl(we->we_idle) / 60;
 745                 if (we->we_idle != 0) {
 746                         if (we->we_idle >= 100 * 60)
 747                                 we->we_idle = 100 * 60 - 1;
 748                         if (we->we_idle >= 60)
 749                                 printf(" %2d", we->we_idle / 60);
 750                         else
 751                                 printf("   ");
 752                         printf(":%02d", we->we_idle % 60);
 753                 }
 754                 printf("\n");
 755         }
 756 }
 757
 758 char *
 759 interval(int time, char *updown)
 760 {
 761         static char resbuf[32];
 762         int days, hours, minutes;
 763
 764         if (time < 0 || time > 3 * 30 * 24 * 60 * 60) {
 765                 (void) sprintf(resbuf, "   %s ??:??", updown);
 766                 return (resbuf);
 767         }
 768         minutes = (time + 59) / 60;             /* round to minutes */
 769         hours = minutes / 60;
 770         minutes %= 60;
 771         days = hours / 24;
 772         hours %= 24;
 773         if (days > 0) {
 774                 (void) sprintf(resbuf, "%s %2d+%02d:%02d",
 775                     updown, days, hours, minutes);
 776         } else {
 777                 (void) sprintf(resbuf, "%s    %2d:%02d",
 778                     updown, hours, minutes);
 779         }
 780         return (resbuf);
 781 }
 782 #endif