usr.sbin/timed/timed/timed.c

   1 /*-
   2  * Copyright (c) 1985, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#) Copyright (c) 1985, 1993 The Regents of the University of California.  All rights reserved.
  34  * @(#)timed.c  8.1 (Berkeley) 6/6/93
  35  * $FreeBSD: src/usr.sbin/timed/timed/timed.c,v 1.9 1999/08/28 01:20:19 peter Exp $
  36  */
  37
  38 #define TSPTYPES
  39 #include "globals.h"
  40 #include <net/if.h>
  41 #include <sys/file.h>
  42 #include <sys/ioctl.h>
  43 #include <setjmp.h>
  44 #include "pathnames.h"
  45 #include <math.h>
  46 #include <sys/types.h>
  47 #include <sys/times.h>
  48
  49 int trace = 0;
  50 int sock, sock_raw = -1;
  51 int status = 0;
  52 u_short sequence;                       /* sequence number */
  53 long delay1;
  54 long delay2;
  55
  56 int nslavenets;                         /* nets were I could be a slave */
  57 int nmasternets;                        /* nets were I could be a master */
  58 int nignorednets;                       /* ignored nets */
  59 int nnets;                              /* nets I am connected to */
  60
  61 FILE *fd;                               /* trace file FD */
  62
  63 jmp_buf jmpenv;
  64
  65 struct netinfo *nettab = NULL;
  66 struct netinfo *slavenet;
  67 int Mflag;
  68 int justquit = 0;
  69 int debug;
  70
  71 static struct nets {
  72         char    *name;
  73         long    net;
  74         struct nets *next;
  75 } *nets = NULL;
  76
  77 struct hosttbl hosttbl[NHOSTS+1];       /* known hosts */
  78
  79 static struct goodhost {                /* hosts that we trust */
  80         char    name[MAXHOSTNAMELEN];
  81         struct goodhost *next;
  82         char    perm;
  83 } *goodhosts;
  84
  85 static char *goodgroup;                 /* net group of trusted hosts */
  86 static void checkignorednets(void);
  87 static void pickslavenet(struct netinfo *);
  88 static void add_good_host(char *, int);
  89 static void usage(void);
  90
  91 /*
  92  * The timedaemons synchronize the clocks of hosts in a local area network.
  93  * One daemon runs as master, all the others as slaves. The master
  94  * performs the task of computing clock differences and sends correction
  95  * values to the slaves.
  96  * Slaves start an election to choose a new master when the latter disappears
  97  * because of a machine crash, network partition, or when killed.
  98  * A resolution protocol is used to kill all but one of the masters
  99  * that happen to exist in segments of a partitioned network when the
 100  * network partition is fixed.
 101  *
 102  * Authors: Riccardo Gusella & Stefano Zatti
 103  *
 104  * overhauled at Silicon Graphics
 105  */
 106 int
 107 main(int argc, char *argv[])
 108 {
 109         int on;
 110         int ret;
 111         int nflag, iflag;
 112         struct timeval ntime;
 113         struct servent *srvp;
 114         char buf[BUFSIZ], *cp, *cplim;
 115         struct ifconf ifc;
 116         struct ifreq ifreq, ifreqf, *ifr;
 117         struct netinfo *ntp;
 118         struct netinfo *ntip;
 119         struct netinfo *savefromnet;
 120         struct netent *nentp;
 121         struct nets *nt;
 122         struct sockaddr_in server;
 123         u_short port;
 124         char c;
 125
 126         on = 1;
 127         nflag = OFF;
 128         iflag = OFF;
 129         ntip = NULL;
 130
 131         opterr = 0;
 132         while ((c = getopt(argc, argv, "Mtdn:i:F:G:P:")) != -1) {
 133                 switch (c) {
 134                 case 'M':
 135                         Mflag = 1;
 136                         break;
 137
 138                 case 't':
 139                         trace = 1;
 140                         break;
 141
 142                 case 'n':
 143                         if (iflag) {
 144                                 errx(1, "-i and -n make no sense together");
 145                         } else {
 146                                 nflag = ON;
 147                                 addnetname(optarg);
 148                         }
 149                         break;
 150
 151                 case 'i':
 152                         if (nflag) {
 153                                 errx(1, "-i and -n make no sense together");
 154                         } else {
 155                                 iflag = ON;
 156                                 addnetname(optarg);
 157                         }
 158                         break;
 159
 160                 case 'F':
 161                         add_good_host(optarg,1);
 162                         while (optind < argc && argv[optind][0] != '-')
 163                                 add_good_host(argv[optind++], 1);
 164                         break;
 165
 166                 case 'd':
 167                         debug = 1;
 168                         break;
 169                 case 'G':
 170                         if (goodgroup != NULL)
 171                                 errx(1, "only one net group");
 172                         goodgroup = optarg;
 173                         break;
 174                 default:
 175                         usage();
 176                         break;
 177                 }
 178         }
 179         if (optind < argc)
 180                 usage();
 181
 182         /* If we care about which machine is the master, then we must
 183          *      be willing to be a master
 184          */
 185         if (NULL != goodgroup || NULL != goodhosts)
 186                 Mflag = 1;
 187
 188         if (gethostname(hostname, sizeof(hostname) - 1) < 0)
 189                 err(1, "gethostname");
 190         self.l_bak = &self;
 191         self.l_fwd = &self;
 192         self.h_bak = &self;
 193         self.h_fwd = &self;
 194         self.head = 1;
 195         self.good = 1;
 196
 197         if (goodhosts != NULL)          /* trust ourself */
 198                 add_good_host(hostname,1);
 199
 200         srvp = getservbyname("timed", "udp");
 201         if (srvp == NULL)
 202                 errx(1, "unknown service 'timed/udp'");
 203         port = srvp->s_port;
 204         bzero(&server, sizeof(struct sockaddr_in));
 205         server.sin_port = srvp->s_port;
 206         server.sin_family = AF_INET;
 207         sock = socket(AF_INET, SOCK_DGRAM, 0);
 208         if (sock < 0)
 209                 err(1, "socket");
 210         if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&on,
 211                                                         sizeof(on)) < 0)
 212                 err(1, "setsockopt");
 213         if (bind(sock, (struct sockaddr*)&server, sizeof(server))) {
 214                 if (errno == EADDRINUSE)
 215                         warnx("time daemon already running");
 216                 else
 217                         warn("bind");
 218                 exit(1);
 219         }
 220
 221         /* choose a unique seed for random number generation */
 222         gettimeofday(&ntime, 0);
 223         srandom(ntime.tv_sec + ntime.tv_usec);
 224
 225         sequence = random();     /* initial seq number */
 226
 227         /* rounds kernel variable time to multiple of 5 ms. */
 228         ntime.tv_sec = 0;
 229         ntime.tv_usec = -((ntime.tv_usec/1000) % 5) * 1000;
 230         adjtime(&ntime, NULL);
 231
 232         for (nt = nets; nt; nt = nt->next) {
 233                 nentp = getnetbyname(nt->name);
 234                 if (nentp == NULL) {
 235                         nt->net = inet_network(nt->name);
 236                         if (nt->net != (long)INADDR_NONE)
 237                                 nentp = getnetbyaddr(nt->net, AF_INET);
 238                 }
 239                 if (nentp != NULL) {
 240                         nt->net = nentp->n_net;
 241                 } else if (nt->net == (long)INADDR_NONE) {
 242                         errx(1, "unknown net %s", nt->name);
 243                 } else if (nt->net == (long)INADDR_ANY) {
 244                         errx(1, "bad net %s", nt->name);
 245                 } else {
 246                         warnx("warning: %s unknown in /etc/networks",
 247                                 nt->name);
 248                 }
 249
 250                 if (0 == (nt->net & 0xff000000))
 251                     nt->net <<= 8;
 252                 if (0 == (nt->net & 0xff000000))
 253                     nt->net <<= 8;
 254                 if (0 == (nt->net & 0xff000000))
 255                     nt->net <<= 8;
 256         }
 257         ifc.ifc_len = sizeof(buf);
 258         ifc.ifc_buf = buf;
 259         if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0)
 260                 err(1, "get interface configuration");
 261         ntp = NULL;
 262
 263 #define size(p) max((p).sa_len, sizeof(p))
 264         cplim = buf + ifc.ifc_len; /*skip over if's with big ifr_addr's */
 265         for (cp = buf; cp < cplim;
 266                         cp += sizeof (ifr->ifr_name) + size(ifr->ifr_addr)) {
 267                 ifr = (struct ifreq *)cp;
 268                 if (ifr->ifr_addr.sa_family != AF_INET)
 269                         continue;
 270                 if (!ntp)
 271                         ntp = (struct netinfo*)malloc(sizeof(struct netinfo));
 272                 bzero(ntp,sizeof(*ntp));
 273                 ntp->my_addr=((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr;
 274                 ntp->status = NOMASTER;
 275                 ifreq = *ifr;
 276                 ifreqf = *ifr;
 277
 278                 if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifreqf) < 0) {
 279                         warn("get interface flags");
 280                         continue;
 281                 }
 282                 if ((ifreqf.ifr_flags & IFF_UP) == 0)
 283                         continue;
 284                 if ((ifreqf.ifr_flags & IFF_BROADCAST) == 0 &&
 285                     (ifreqf.ifr_flags & IFF_POINTOPOINT) == 0) {
 286                         continue;
 287                 }
 288
 289
 290                 if (ioctl(sock, SIOCGIFNETMASK, (char *)&ifreq) < 0) {
 291                         warn("get netmask");
 292                         continue;
 293                 }
 294                 ntp->mask = ((struct sockaddr_in *)
 295                         &ifreq.ifr_addr)->sin_addr.s_addr;
 296
 297                 if (ifreqf.ifr_flags & IFF_BROADCAST) {
 298                         if (ioctl(sock, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
 299                                 warn("get broadaddr");
 300                                 continue;
 301                         }
 302                         ntp->dest_addr = *(struct sockaddr_in *)&ifreq.ifr_broadaddr;
 303                         /* What if the broadcast address is all ones?
 304                          * So we cannot just mask ntp->dest_addr.  */
 305                         ntp->net = ntp->my_addr;
 306                         ntp->net.s_addr &= ntp->mask;
 307                 } else {
 308                         if (ioctl(sock, SIOCGIFDSTADDR,
 309                                                 (char *)&ifreq) < 0) {
 310                                 warn("get destaddr");
 311                                 continue;
 312                         }
 313                         ntp->dest_addr = *(struct sockaddr_in *)&ifreq.ifr_dstaddr;
 314                         ntp->net = ntp->dest_addr.sin_addr;
 315                 }
 316
 317                 ntp->dest_addr.sin_port = port;
 318
 319                 for (nt = nets; nt; nt = nt->next) {
 320                         if (ntp->net.s_addr == htonl(nt->net))
 321                                 break;
 322                 }
 323                 if ((nflag && !nt) || (iflag && nt))
 324                         continue;
 325
 326                 ntp->next = NULL;
 327                 if (nettab == NULL) {
 328                         nettab = ntp;
 329                 } else {
 330                         ntip->next = ntp;
 331                 }
 332                 ntip = ntp;
 333                 ntp = NULL;
 334         }
 335         if (ntp)
 336                 free((char *)ntp);
 337         if (nettab == NULL)
 338                 errx(1, "no network usable");
 339
 340
 341         /* microseconds to delay before responding to a broadcast */
 342         delay1 = casual(1, 100*1000);
 343
 344         /* election timer delay in secs. */
 345         delay2 = casual(MINTOUT, MAXTOUT);
 346
 347
 348         if (!debug)
 349                 daemon(debug, 0);
 350
 351         if (trace)
 352                 traceon();
 353         openlog("timed", LOG_CONS|LOG_PID, LOG_DAEMON);
 354
 355         /*
 356          * keep returning here
 357          */
 358         ret = setjmp(jmpenv);
 359         savefromnet = fromnet;
 360         setstatus();
 361
 362         if (Mflag) {
 363                 switch (ret) {
 364
 365                 case 0:
 366                         checkignorednets();
 367                         pickslavenet(0);
 368                         break;
 369                 case 1:
 370                         /* Just lost our master */
 371                         if (slavenet != NULL)
 372                                 slavenet->status = election(slavenet);
 373                         if (!slavenet || slavenet->status == MASTER) {
 374                                 checkignorednets();
 375                                 pickslavenet(0);
 376                         } else {
 377                                 makeslave(slavenet);    /* prune extras */
 378                         }
 379                         break;
 380
 381                 case 2:
 382                         /* Just been told to quit */
 383                         justquit = 1;
 384                         pickslavenet(savefromnet);
 385                         break;
 386                 }
 387
 388                 setstatus();
 389                 if (!(status & MASTER) && sock_raw != -1) {
 390                         /* sock_raw is not being used now */
 391                         close(sock_raw);
 392                         sock_raw = -1;
 393                 }
 394
 395                 if (status == MASTER)
 396                         master();
 397                 else
 398                         slave();
 399
 400         } else {
 401                 if (sock_raw != -1) {
 402                         close(sock_raw);
 403                         sock_raw = -1;
 404                 }
 405
 406                 if (ret) {
 407                         /* we just lost our master or were told to quit */
 408                         justquit = 1;
 409                 }
 410                 for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
 411                         if (ntp->status == MASTER) {
 412                                 rmnetmachs(ntp);
 413                                 ntp->status = NOMASTER;
 414                         }
 415                 }
 416                 checkignorednets();
 417                 pickslavenet(0);
 418                 setstatus();
 419
 420                 slave();
 421         }
 422         /* NOTREACHED */
 423         return(0);
 424 }
 425
 426 static void
 427 usage(void)
 428 {
 429
 430 #ifdef HAVENIS
 431         fprintf(stderr,
 432 "usage: timed [-dtM] [-i net|-n net] [-F host1 host2 ...] [-G netgp]\n");
 433 #else
 434         fprintf(stderr,
 435 "usage: timed [-dtM] [-i net|-n net] [-F host1 host2 ...]\n");
 436 #endif /* HAVENIS */
 437         exit(1);
 438 }
 439
 440 /*
 441  * suppress an upstart, untrustworthy, self-appointed master
 442  */
 443 void
 444 suppress(struct sockaddr_in *addr, char *name, struct netinfo *net)
 445 {
 446         struct sockaddr_in tgt;
 447         char tname[MAXHOSTNAMELEN];
 448         struct tsp msg;
 449         static struct timeval wait;
 450
 451         if (trace)
 452                 fprintf(fd, "suppress: %s\n", name);
 453         tgt = *addr;
 454         strlcpy(tname, name, sizeof(tname));
 455
 456         while (0 != readmsg(TSP_ANY, ANYADDR, &wait, net)) {
 457                 if (trace)
 458                         fprintf(fd, "suppress:\tdiscarded packet from %s\n",
 459                                     name);
 460         }
 461
 462         syslog(LOG_NOTICE, "suppressing false master %s", tname);
 463         msg.tsp_type = TSP_QUIT;
 464         strlcpy(msg.tsp_name, hostname, sizeof(msg.tsp_name));
 465         acksend(&msg, &tgt, tname, TSP_ACK, 0, 1);
 466 }
 467
 468 void
 469 lookformaster(struct netinfo *ntp)
 470 {
 471         struct tsp resp, conflict, *answer;
 472         struct timeval ntime;
 473         char mastername[MAXHOSTNAMELEN];
 474         struct sockaddr_in masteraddr;
 475
 476         get_goodgroup(0);
 477         ntp->status = SLAVE;
 478
 479         /* look for master */
 480         resp.tsp_type = TSP_MASTERREQ;
 481         strlcpy(resp.tsp_name, hostname, sizeof(resp.tsp_name));
 482         answer = acksend(&resp, &ntp->dest_addr, ANYADDR,
 483                          TSP_MASTERACK, ntp, 0);
 484         if (answer != NULL && !good_host_name(answer->tsp_name)) {
 485                 suppress(&from, answer->tsp_name, ntp);
 486                 ntp->status = NOMASTER;
 487                 answer = NULL;
 488         }
 489         if (answer == NULL) {
 490                 /*
 491                  * Various conditions can cause conflict: races between
 492                  * two just started timedaemons when no master is
 493                  * present, or timedaemons started during an election.
 494                  * A conservative approach is taken.  Give up and became a
 495                  * slave, postponing election of a master until first
 496                  * timer expires.
 497                  */
 498                 ntime.tv_sec = ntime.tv_usec = 0;
 499                 answer = readmsg(TSP_MASTERREQ, ANYADDR, &ntime, ntp);
 500                 if (answer != NULL) {
 501                         if (!good_host_name(answer->tsp_name)) {
 502                                 suppress(&from, answer->tsp_name, ntp);
 503                                 ntp->status = NOMASTER;
 504                         }
 505                         return;
 506                 }
 507
 508                 ntime.tv_sec = ntime.tv_usec = 0;
 509                 answer = readmsg(TSP_MASTERUP, ANYADDR, &ntime, ntp);
 510                 if (answer != NULL) {
 511                         if (!good_host_name(answer->tsp_name)) {
 512                                 suppress(&from, answer->tsp_name, ntp);
 513                                 ntp->status = NOMASTER;
 514                         }
 515                         return;
 516                 }
 517
 518                 ntime.tv_sec = ntime.tv_usec = 0;
 519                 answer = readmsg(TSP_ELECTION, ANYADDR, &ntime, ntp);
 520                 if (answer != NULL) {
 521                         if (!good_host_name(answer->tsp_name)) {
 522                                 suppress(&from, answer->tsp_name, ntp);
 523                                 ntp->status = NOMASTER;
 524                         }
 525                         return;
 526                 }
 527
 528                 if (Mflag)
 529                         ntp->status = MASTER;
 530                 else
 531                         ntp->status = NOMASTER;
 532                 return;
 533         }
 534
 535         ntp->status = SLAVE;
 536         strlcpy(mastername, answer->tsp_name, sizeof(mastername));
 537         masteraddr = from;
 538
 539         /*
 540          * If network has been partitioned, there might be other
 541          * masters; tell the one we have just acknowledged that
 542          * it has to gain control over the others.
 543          */
 544         ntime.tv_sec = 0;
 545         ntime.tv_usec = 300000;
 546         answer = readmsg(TSP_MASTERACK, ANYADDR, &ntime, ntp);
 547         /*
 548          * checking also not to send CONFLICT to ack'ed master
 549          * due to duplicated MASTERACKs
 550          */
 551         if (answer != NULL &&
 552             strcmp(answer->tsp_name, mastername) != 0) {
 553                 conflict.tsp_type = TSP_CONFLICT;
 554                 strlcpy(conflict.tsp_name, hostname, sizeof(conflict.tsp_name));
 555                 if (!acksend(&conflict, &masteraddr, mastername,
 556                              TSP_ACK, 0, 0)) {
 557                         syslog(LOG_ERR,
 558                                "error on sending TSP_CONFLICT");
 559                 }
 560         }
 561 }
 562
 563 /*
 564  * based on the current network configuration, set the status, and count
 565  * networks;
 566  */
 567 void
 568 setstatus(void)
 569 {
 570         struct netinfo *ntp;
 571
 572         status = 0;
 573         nmasternets = nslavenets = nnets = nignorednets = 0;
 574         if (trace)
 575                 fprintf(fd, "Net status:\n");
 576         for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
 577                 switch ((int)ntp->status) {
 578                 case MASTER:
 579                         nmasternets++;
 580                         break;
 581                 case SLAVE:
 582                         nslavenets++;
 583                         break;
 584                 case NOMASTER:
 585                 case IGNORE:
 586                         nignorednets++;
 587                         break;
 588                 }
 589                 if (trace) {
 590                         fprintf(fd, "\t%-16s", inet_ntoa(ntp->net));
 591                         switch ((int)ntp->status) {
 592                         case NOMASTER:
 593                                 fprintf(fd, "NOMASTER\n");
 594                                 break;
 595                         case MASTER:
 596                                 fprintf(fd, "MASTER\n");
 597                                 break;
 598                         case SLAVE:
 599                                 fprintf(fd, "SLAVE\n");
 600                                 break;
 601                         case IGNORE:
 602                                 fprintf(fd, "IGNORE\n");
 603                                 break;
 604                         default:
 605                                 fprintf(fd, "invalid state %d\n",
 606                                         (int)ntp->status);
 607                                 break;
 608                         }
 609                 }
 610                 nnets++;
 611                 status |= ntp->status;
 612         }
 613         status &= ~IGNORE;
 614         if (trace)
 615                 fprintf(fd,
 616                     "\tnets=%d masters=%d slaves=%d ignored=%d delay2=%ld\n",
 617                     nnets, nmasternets, nslavenets, nignorednets, delay2);
 618 }
 619
 620 void
 621 makeslave(struct netinfo *net)
 622 {
 623         struct netinfo *ntp;
 624
 625         for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
 626                 if (ntp->status == SLAVE && ntp != net)
 627                         ntp->status = IGNORE;
 628         }
 629         slavenet = net;
 630 }
 631
 632 /*
 633  * Try to become master over ignored nets..
 634  */
 635 static void
 636 checkignorednets(void)
 637 {
 638         struct netinfo *ntp;
 639
 640         for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
 641                 if (!Mflag && ntp->status == SLAVE)
 642                         break;
 643
 644                 if (ntp->status == IGNORE || ntp->status == NOMASTER) {
 645                         lookformaster(ntp);
 646                         if (!Mflag && ntp->status == SLAVE)
 647                                 break;
 648                 }
 649         }
 650 }
 651
 652 /*
 653  * choose a good network on which to be a slave
 654  *      The ignored networks must have already been checked.
 655  *      Take a hint about for a good network.
 656  */
 657 static void
 658 pickslavenet(struct netinfo *ntp)
 659 {
 660
 661         if (slavenet != NULL && slavenet->status == SLAVE) {
 662                 makeslave(slavenet);            /* prune extras */
 663                 return;
 664         }
 665
 666         if (ntp == NULL || ntp->status != SLAVE) {
 667                 for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
 668                         if (ntp->status == SLAVE)
 669                                 break;
 670                 }
 671         }
 672         makeslave(ntp);
 673 }
 674
 675 /*
 676  * returns a random number in the range [inf, sup]
 677  */
 678 long
 679 casual(long inf, long sup)
 680 {
 681         double value;
 682
 683         value = ((double)(random() & 0x7fffffff)) / (0x7fffffff*1.0);
 684         return(inf + (sup - inf)*value);
 685 }
 686
 687 char *
 688 date(void)
 689 {
 690         struct  timeval tv;
 691         time_t  tv_sec;
 692
 693         gettimeofday(&tv, NULL);
 694         tv_sec = tv.tv_sec;
 695         return (ctime(&tv_sec));
 696 }
 697
 698 void
 699 addnetname(char *name)
 700 {
 701         struct nets **netlist = &nets;
 702
 703         while (*netlist)
 704                 netlist = &((*netlist)->next);
 705         *netlist = (struct nets *)malloc(sizeof **netlist);
 706         if (*netlist == NULL)
 707                 errx(1, "malloc failed");
 708         bzero((char *)*netlist, sizeof(**netlist));
 709         (*netlist)->name = name;
 710 }
 711
 712 /* note a host as trustworthy */
 713 static void
 714 add_good_host(char *name,
 715               int perm)         /* 1=not part of the netgroup */
 716 {
 717         struct goodhost *ghp;
 718         struct hostent *hentp;
 719
 720         ghp = (struct goodhost*)malloc(sizeof(*ghp));
 721         if (!ghp) {
 722                 syslog(LOG_ERR, "malloc failed");
 723                 exit(1);
 724         }
 725
 726         bzero((char*)ghp, sizeof(*ghp));
 727         strlcpy(&ghp->name[0], name, sizeof(ghp->name));
 728         ghp->next = goodhosts;
 729         ghp->perm = perm;
 730         goodhosts = ghp;
 731
 732         hentp = gethostbyname(name);
 733         if (NULL == hentp && perm)
 734                 warnx("unknown host %s", name);
 735 }
 736
 737
 738 /* update our image of the net-group of trustworthy hosts
 739  */
 740 void
 741 get_goodgroup(int force)
 742 {
 743 # define NG_DELAY (30*60*CLK_TCK)       /* 30 minutes */
 744         static unsigned long last_update = -NG_DELAY;
 745         unsigned long new_update;
 746         struct goodhost *ghp, **ghpp;
 747 #ifdef HAVENIS
 748         struct hosttbl *htp;
 749         char *mach, *usr, *dom;
 750 #endif /* HAVENIS */
 751         struct tms tm;
 752
 753
 754         /* if no netgroup, then we are finished */
 755         if (goodgroup == NULL || !Mflag)
 756                 return;
 757
 758         /* Do not chatter with the netgroup master too often.
 759          */
 760         new_update = times(&tm);
 761         if (new_update < last_update + NG_DELAY
 762             && !force)
 763                 return;
 764         last_update = new_update;
 765
 766         /* forget the old temporary entries */
 767         ghpp = &goodhosts;
 768         while (NULL != (ghp = *ghpp)) {
 769                 if (!ghp->perm) {
 770                         *ghpp = ghp->next;
 771                         free((char*)ghp);
 772                 } else {
 773                         ghpp = &ghp->next;
 774                 }
 775         }
 776
 777 #ifdef HAVENIS
 778         /* quit now if we are not one of the trusted masters
 779          */
 780         if (!innetgr(goodgroup, &hostname[0], 0,0)) {
 781                 if (trace)
 782                         fprintf(fd, "get_goodgroup: %s not in %s\n",
 783                                       &hostname[0], goodgroup);
 784                 return;
 785         }
 786         if (trace)
 787                 fprintf(fd, "get_goodgroup: %s in %s\n",
 788                                   &hostname[0], goodgroup);
 789
 790         /* mark the entire netgroup as trusted */
 791         setnetgrent(goodgroup);
 792         while (getnetgrent(&mach,&usr,&dom)) {
 793                 if (NULL != mach)
 794                         add_good_host(mach,0);
 795         }
 796         endnetgrent();
 797
 798         /* update list of slaves */
 799         for (htp = self.l_fwd; htp != &self; htp = htp->l_fwd) {
 800                 htp->good = good_host_name(&htp->name[0]);
 801         }
 802 #endif /* HAVENIS */
 803 }
 804
 805
 806 /* see if a machine is trustworthy
 807  */
 808 int                                     /* 1=trust hp to change our date */
 809 good_host_name(char *name)
 810 {
 811         struct goodhost *ghp = goodhosts;
 812         char c;
 813
 814         if (!ghp || !Mflag)             /* trust everyone if no one named */
 815                 return 1;
 816
 817         c = *name;
 818         do {
 819                 if (c == ghp->name[0]
 820                     && !strcasecmp(name, ghp->name))
 821                         return 1;       /* found him, so say so */
 822         } while (NULL != (ghp = ghp->next));
 823
 824         if (!strcasecmp(name,hostname)) /* trust ourself */
 825                 return 1;
 826
 827         return 0;                       /* did not find him */
 828 }