/*
* react to a TSP_QUIT:
*/
void
doquit(struct tsp *msg)
{
if (fromnet->status == MASTER) {
if (!good_host_name(msg->tsp_name)) {
if (fromnet->quit_count <= 0) {
syslog(LOG_NOTICE,"untrusted %s told us QUIT",
msg->tsp_name);
suppress(&from, msg->tsp_name, fromnet);
fromnet->quit_count = 1;
return;
}
syslog(LOG_NOTICE, "untrusted %s told us QUIT twice",
msg->tsp_name);
fromnet->quit_count = 2;
fromnet->status = NOMASTER;
} else {
fromnet->status = SLAVE;
}
rmnetmachs(fromnet);
longjmp(jmpenv, 2); /* give up and be a slave */
} else {
if (!good_host_name(msg->tsp_name)) {
syslog(LOG_NOTICE, "untrusted %s told us QUIT",
msg->tsp_name);
fromnet->quit_count = 2;
}
}
}
/*
* The timedaemons synchronize the clocks of hosts in a local area network.
* One daemon runs as master, all the others as slaves. The master
* performs the task of computing clock differences and sends correction
* values to the slaves.
* Slaves start an election to choose a new master when the latter disappears
* because of a machine crash, network partition, or when killed.
* A resolution protocol is used to kill all but one of the masters
* that happen to exist in segments of a partitioned network when the
* network partition is fixed.
*
* Authors: Riccardo Gusella & Stefano Zatti
*
* overhauled at Silicon Graphics
*/
int
main(int argc, char *argv[])
{
int on;
int ret;
int nflag, iflag;
struct timeval ntime;
struct servent *srvp;
char buf[BUFSIZ], *cp, *cplim;
struct ifconf ifc;
struct ifreq ifreq, ifreqf, *ifr;
register struct netinfo *ntp;
struct netinfo *ntip;
struct netinfo *savefromnet;
struct netent *nentp;
struct nets *nt;
struct sockaddr_in server;
u_short port;
int c;
#ifdef lint
ntip = NULL;
#endif
on = 1;
nflag = OFF;
iflag = OFF;
opterr = 0;
while ((c = getopt(argc, argv, "Mtdn:i:F:G:P:")) != -1) {
switch (c) {
case 'M':
Mflag = 1;
break;
case 't':
trace = 1;
break;
case 'n':
if (iflag) {
errx(1, "-i and -n make no sense together");
} else {
nflag = ON;
addnetname(optarg);
}
break;
case 'i':
if (nflag) {
errx(1, "-i and -n make no sense together");
} else {
iflag = ON;
addnetname(optarg);
}
break;
case 'F':
add_good_host(optarg,1);
while (optind < argc && argv[optind][0] != '-')
add_good_host(argv[optind++], 1);
break;
case 'd':
debug = 1;
break;
case 'G':
if (goodgroup != NULL)
errx(1, "only one net group");
goodgroup = optarg;
break;
default:
usage();
break;
}
}
if (optind < argc)
usage();
/* If we care about which machine is the master, then we must
* be willing to be a master
*/
if (goodgroup != NULL || goodhosts != NULL)
Mflag = 1;
if (gethostname(hostname, sizeof(hostname) - 1) < 0)
err(1, "gethostname");
self.l_bak = &self;
self.l_fwd = &self;
self.h_bak = &self;
self.h_fwd = &self;
self.head = 1;
self.good = 1;
if (goodhosts != NULL) /* trust ourself */
add_good_host(hostname,1);
srvp = getservbyname("timed", "udp");
if (srvp == NULL)
errx(1, "timed/udp: unknown service");
port = srvp->s_port;
bzero(&server, sizeof(struct sockaddr_in));
server.sin_port = srvp->s_port;
server.sin_family = AF_INET;
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
err(1, "socket");
if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&on,
sizeof(on)) < 0)
err(1, "setsockopt");
if (bind(sock, (struct sockaddr*)&server, sizeof(server))) {
if (errno == EADDRINUSE)
warnx("time daemon already running");
else
warn("bind");
exit(1);
}
sequence = arc4random(); /* initial seq number */
(void)gettimeofday(&ntime, NULL);
/* rounds kernel variable time to multiple of 5 ms. */
ntime.tv_sec = 0;
ntime.tv_usec = -((ntime.tv_usec/1000) % 5) * 1000;
(void)adjtime(&ntime, (struct timeval *)0);
for (nt = nets; nt; nt = nt->next) {
nentp = getnetbyname(nt->name);
if (nentp == NULL) {
nt->net = inet_network(nt->name);
if (nt->net != INADDR_NONE)
nentp = getnetbyaddr(nt->net, AF_INET);
}
if (nentp != NULL) {
nt->net = nentp->n_net;
} else if (nt->net == INADDR_NONE) {
errx(1, "unknown net %s", nt->name);
} else if (nt->net == INADDR_ANY) {
errx(1, "bad net %s", nt->name);
} else {
warnx("warning: %s unknown in /etc/networks",
nt->name);
}
if (0 == (nt->net & 0xff000000))
nt->net <<= 8;
if (0 == (nt->net & 0xff000000))
nt->net <<= 8;
if (0 == (nt->net & 0xff000000))
nt->net <<= 8;
}
ifc.ifc_len = sizeof(buf);
ifc.ifc_buf = buf;
if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0)
err(1, "get interface configuration");
ntp = NULL;
#define size(p) max((p).sa_len, sizeof(p))
cplim = buf + ifc.ifc_len; /*skip over if's with big ifr_addr's */
for (cp = buf; cp < cplim;
cp += sizeof (ifr->ifr_name) + size(ifr->ifr_addr)) {
ifr = (struct ifreq *)cp;
if (ifr->ifr_addr.sa_family != AF_INET)
continue;
if (!ntp)
ntp = (struct netinfo*)malloc(sizeof(struct netinfo));
bzero(ntp,sizeof(*ntp));
ntp->my_addr=((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr;
ntp->status = NOMASTER;
ifreq = *ifr;
ifreqf = *ifr;
if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifreqf) < 0) {
warn("get interface flags");
continue;
}
if ((ifreqf.ifr_flags & IFF_UP) == 0)
continue;
if ((ifreqf.ifr_flags & IFF_BROADCAST) == 0 &&
(ifreqf.ifr_flags & IFF_POINTOPOINT) == 0) {
continue;
}
if (ioctl(sock, SIOCGIFNETMASK, (char *)&ifreq) < 0) {
warn("get netmask");
continue;
}
ntp->mask = ((struct sockaddr_in *)
&ifreq.ifr_addr)->sin_addr.s_addr;
if (ifreqf.ifr_flags & IFF_BROADCAST) {
if (ioctl(sock, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
warn("get broadaddr");
continue;
}
ntp->dest_addr = *(struct sockaddr_in *)&ifreq.ifr_broadaddr;
/* What if the broadcast address is all ones?
* So we cannot just mask ntp->dest_addr. */
ntp->net = ntp->my_addr;
ntp->net.s_addr &= ntp->mask;
} else {
if (ioctl(sock, SIOCGIFDSTADDR,
(char *)&ifreq) < 0) {
warn("get destaddr");
continue;
}
ntp->dest_addr = *(struct sockaddr_in *)&ifreq.ifr_dstaddr;
ntp->net = ntp->dest_addr.sin_addr;
}
ntp->dest_addr.sin_port = port;
for (nt = nets; nt; nt = nt->next) {
if (ntp->net.s_addr == htonl(nt->net))
break;
}
if ((nflag && !nt) || (iflag && nt))
continue;
ntp->next = NULL;
if (nettab == NULL) {
nettab = ntp;
} else {
ntip->next = ntp;
}
ntip = ntp;
ntp = NULL;
}
if (ntp)
(void) free((char *)ntp);
if (nettab == NULL)
errx(1, "no network usable");
/* microseconds to delay before responding to a broadcast */
delay1 = casual(1, 100*1000);
/* election timer delay in secs. */
delay2 = casual(MINTOUT, MAXTOUT);
if (!debug)
daemon(debug, 0);
if (trace)
traceon();
openlog("timed", LOG_CONS|LOG_PID, LOG_DAEMON);
/*
* keep returning here
*/
ret = setjmp(jmpenv);
savefromnet = fromnet;
setstatus();
if (Mflag) {
switch (ret) {
case 0:
checkignorednets();
pickslavenet(0);
break;
case 1:
/* Just lost our master */
if (slavenet != NULL)
slavenet->status = election(slavenet);
if (!slavenet || slavenet->status == MASTER) {
checkignorednets();
pickslavenet(0);
} else {
makeslave(slavenet); /* prune extras */
}
break;
case 2:
/* Just been told to quit */
justquit = 1;
pickslavenet(savefromnet);
break;
}
setstatus();
if (!(status & MASTER) && sock_raw != -1) {
/* sock_raw is not being used now */
(void)close(sock_raw);
sock_raw = -1;
}
if (status == MASTER)
master();
else
slave();
} else {
if (sock_raw != -1) {
(void)close(sock_raw);
sock_raw = -1;
}
if (ret) {
/* we just lost our master or were told to quit */
justquit = 1;
}
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == MASTER) {
rmnetmachs(ntp);
ntp->status = NOMASTER;
}
}
checkignorednets();
pickslavenet(0);
setstatus();
slave();
}
/* NOTREACHED */
return(0);
}
/*
* `election' candidates a host as master: it is called by a slave
* which runs with the -M option set when its election timeout expires.
* Note the conservative approach: if a new timed comes up, or another
* candidate sends an election request, the candidature is withdrawn.
*/
int
election(struct netinfo *net)
{
struct tsp *resp, msg;
struct timeval then, wait;
struct tsp *answer;
struct hosttbl *htp;
char loop_lim = 0;
/* This code can get totally confused if it gets slightly behind. For
* example, if readmsg() has some QUIT messages waiting from the last
* round, we would send an ELECTION message, get the stale QUIT,
* and give up. This results in network storms when several machines
* do it at once.
*/
wait.tv_sec = 0;
wait.tv_usec = 0;
while (0 != readmsg(TSP_REFUSE, ANYADDR, &wait, net)) {
if (trace)
fprintf(fd, "election: discarded stale REFUSE\n");
}
while (0 != readmsg(TSP_QUIT, ANYADDR, &wait, net)) {
if (trace)
fprintf(fd, "election: discarded stale QUIT\n");
}
again:
syslog(LOG_INFO, "This machine is a candidate time master");
if (trace)
fprintf(fd, "This machine is a candidate time master\n");
msg.tsp_type = TSP_ELECTION;
msg.tsp_vers = TSPVERSION;
(void)strcpy(msg.tsp_name, hostname);
bytenetorder(&msg);
if (sendto(sock, (char *)&msg, sizeof(struct tsp), 0,
(struct sockaddr*)&net->dest_addr,
sizeof(struct sockaddr)) < 0) {
trace_sendto_err(net->dest_addr.sin_addr);
return(SLAVE);
}
(void)gettimeofday(&then, 0);
then.tv_sec += 3;
for (;;) {
(void)gettimeofday(&wait, 0);
timevalsub(&wait,&then,&wait);
resp = readmsg(TSP_ANY, ANYADDR, &wait, net);
if (!resp)
return(MASTER);
switch (resp->tsp_type) {
case TSP_ACCEPT:
(void)addmach(resp->tsp_name, &from,fromnet);
break;
case TSP_MASTERUP:
case TSP_MASTERREQ:
/*
* If another timedaemon is coming up at the same
* time, give up, and let it be the master.
*/
if (++loop_lim < 5
&& !good_host_name(resp->tsp_name)) {
(void)addmach(resp->tsp_name, &from,fromnet);
suppress(&from, resp->tsp_name, net);
goto again;
}
rmnetmachs(net);
return(SLAVE);
case TSP_QUIT:
case TSP_REFUSE:
/*
* Collision: change value of election timer
* using exponential backoff.
*
* Fooey.
* An exponential backoff on a delay starting at
* 6 to 15 minutes for a process that takes
* milliseconds is silly. It is particularly
* strange that the original code would increase
* the backoff without bound.
*/
rmnetmachs(net);
return(SLAVE);
case TSP_ELECTION:
/* no master for another round */
htp = addmach(resp->tsp_name,&from,fromnet);
msg.tsp_type = TSP_REFUSE;
(void)strcpy(msg.tsp_name, hostname);
answer = acksend(&msg, &htp->addr, htp->name,
TSP_ACK, 0, htp->noanswer);
if (!answer) {
syslog(LOG_ERR, "error in election from %s",
htp->name);
}
break;
case TSP_SLAVEUP:
(void)addmach(resp->tsp_name, &from,fromnet);
break;
case TSP_SETDATE:
case TSP_SETDATEREQ:
break;
default:
if (trace) {
fprintf(fd, "candidate: ");
print(resp, &from);
}
break;
}
}
}
