/*
* choose a good network on which to be a slave
* The ignored networks must have already been checked.
* Take a hint about for a good network.
*/
static void
pickslavenet(struct netinfo *ntp)
{
if (slavenet != NULL && slavenet->status == SLAVE) {
makeslave(slavenet); /* prune extras */
return;
}
if (ntp == NULL || ntp->status != SLAVE) {
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == SLAVE)
break;
}
}
makeslave(ntp);
}
int
slave()
{
int tries;
long electiontime, refusetime, looktime, looptime, adjtime;
u_short seq;
long fastelection;
#define FASTTOUT 3
struct in_addr cadr;
struct timeval otime;
struct sockaddr_in taddr;
char tname[MAXHOSTNAMELEN];
struct tsp *msg, to;
struct timeval ntime, wait, tmptv;
time_t tsp_time_sec;
struct tsp *answer;
int timeout();
char olddate[32];
char newdate[32];
struct netinfo *ntp;
struct hosttbl *htp;
struct utmpx utx;
old_slavenet = 0;
seq = 0;
refusetime = 0;
adjtime = 0;
(void)gettimeofday(&ntime, NULL);
electiontime = ntime.tv_sec + delay2;
fastelection = ntime.tv_sec + FASTTOUT;
if (justquit)
looktime = electiontime;
else
looktime = fastelection;
looptime = fastelection;
if (slavenet)
xmit(TSP_SLAVEUP, 0, &slavenet->dest_addr);
if (status & MASTER) {
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == MASTER)
masterup(ntp);
}
}
loop:
get_goodgroup(0);
(void)gettimeofday(&ntime, NULL);
if (ntime.tv_sec > electiontime) {
if (trace)
fprintf(fd, "election timer expired\n");
longjmp(jmpenv, 1);
}
if (ntime.tv_sec >= looktime) {
if (trace)
fprintf(fd, "Looking for nets to master\n");
if (Mflag && nignorednets > 0) {
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == IGNORE
|| ntp->status == NOMASTER) {
lookformaster(ntp);
if (ntp->status == MASTER) {
masterup(ntp);
} else if (ntp->status == MASTER) {
ntp->status = NOMASTER;
}
}
if (ntp->status == MASTER
&& --ntp->quit_count < 0)
ntp->quit_count = 0;
}
makeslave(slavenet); /* prune extras */
setstatus();
}
(void)gettimeofday(&ntime, NULL);
looktime = ntime.tv_sec + delay2;
}
if (ntime.tv_sec >= looptime) {
if (trace)
fprintf(fd, "Looking for loops\n");
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == MASTER) {
to.tsp_type = TSP_LOOP;
to.tsp_vers = TSPVERSION;
to.tsp_seq = sequence++;
to.tsp_hopcnt = MAX_HOPCNT;
(void)strcpy(to.tsp_name, hostname);
bytenetorder(&to);
if (sendto(sock, (char *)&to, sizeof(struct tsp), 0,
(struct sockaddr*)&ntp->dest_addr,
sizeof(ntp->dest_addr)) < 0) {
trace_sendto_err(ntp->dest_addr.sin_addr);
}
}
}
(void)gettimeofday(&ntime, NULL);
looptime = ntime.tv_sec + delay2;
}
wait.tv_sec = min(electiontime,min(looktime,looptime)) - ntime.tv_sec;
if (wait.tv_sec < 0)
wait.tv_sec = 0;
wait.tv_sec += FASTTOUT;
wait.tv_usec = 0;
msg = readmsg(TSP_ANY, ANYADDR, &wait, 0);
if (msg != NULL) {
/*
* filter stuff not for us
*/
switch (msg->tsp_type) {
case TSP_SETDATE:
case TSP_TRACEOFF:
case TSP_TRACEON:
/*
* XXX check to see they are from ourself
*/
break;
case TSP_TEST:
case TSP_MSITE:
break;
case TSP_MASTERUP:
if (!fromnet) {
if (trace) {
fprintf(fd, "slave ignored: ");
print(msg, &from);
}
goto loop;
}
break;
default:
if (!fromnet
|| fromnet->status == IGNORE
|| fromnet->status == NOMASTER) {
if (trace) {
fprintf(fd, "slave ignored: ");
print(msg, &from);
}
goto loop;
}
break;
}
/*
* now process the message
*/
switch (msg->tsp_type) {
case TSP_ADJTIME:
if (fromnet != slavenet)
break;
if (!good_host_name(msg->tsp_name)) {
syslog(LOG_NOTICE,
"attempted time adjustment by %s",
msg->tsp_name);
suppress(&from, msg->tsp_name, fromnet);
break;
}
/*
* Speed up loop detection in case we have a loop.
* Otherwise the clocks can race until the loop
* is found.
*/
(void)gettimeofday(&otime, NULL);
if (adjtime < otime.tv_sec)
looptime -= (looptime-otime.tv_sec)/2 + 1;
setmaster(msg);
if (seq != msg->tsp_seq) {
seq = msg->tsp_seq;
synch(tvtomsround(msg->tsp_time));
}
(void)gettimeofday(&ntime, NULL);
electiontime = ntime.tv_sec + delay2;
fastelection = ntime.tv_sec + FASTTOUT;
adjtime = ntime.tv_sec + SAMPLEINTVL*2;
break;
case TSP_SETTIME:
if (fromnet != slavenet)
break;
if (seq == msg->tsp_seq)
break;
seq = msg->tsp_seq;
/* adjust time for residence on the queue */
(void)gettimeofday(&otime, NULL);
adj_msg_time(msg,&otime);
/*
* the following line is necessary due to syslog
* calling ctime() which clobbers the static buffer
*/
(void)strcpy(olddate, date());
tsp_time_sec = msg->tsp_time.tv_sec;
(void)strcpy(newdate, ctime(&tsp_time_sec));
if (!good_host_name(msg->tsp_name)) {
syslog(LOG_NOTICE,
"attempted time setting by untrusted %s to %s",
msg->tsp_name, newdate);
suppress(&from, msg->tsp_name, fromnet);
break;
}
setmaster(msg);
tmptv.tv_sec = msg->tsp_time.tv_sec;
tmptv.tv_usec = msg->tsp_time.tv_usec;
timevalsub(&ntime, &tmptv, &otime);
if (ntime.tv_sec < MAXADJ && ntime.tv_sec > -MAXADJ) {
/*
* do not change the clock if we can adjust it
*/
synch(tvtomsround(ntime));
} else {
utx.ut_type = OLD_TIME;
gettimeofday(&utx.ut_tv, NULL);
pututxline(&utx);
(void)settimeofday(&tmptv, 0);
utx.ut_type = NEW_TIME;
gettimeofday(&utx.ut_tv, NULL);
pututxline(&utx);
syslog(LOG_NOTICE,
"date changed by %s from %s",
msg->tsp_name, olddate);
if (status & MASTER)
spreadtime();
}
(void)gettimeofday(&ntime, NULL);
electiontime = ntime.tv_sec + delay2;
fastelection = ntime.tv_sec + FASTTOUT;
/* This patches a bad protocol bug. Imagine a system with several networks,
* where there are a pair of redundant gateways between a pair of networks,
* each running timed. Assume that we start with a third machine mastering
* one of the networks, and one of the gateways mastering the other.
* Imagine that the third machine goes away and the non-master gateway
* decides to replace it. If things are timed just 'right,' we will have
* each gateway mastering one network for a little while. If a SETTIME
* message gets into the network at that time, perhaps from the newly
* masterful gateway as it was taking control, the SETTIME will loop
* forever. Each time a gateway receives it on its slave side, it will
* call spreadtime to forward it on its mastered network. We are now in
* a permanent loop, since the SETTIME msgs will keep any clock
* in the network from advancing. Normally, the 'LOOP' stuff will detect
* and correct the situation. However, with the clocks stopped, the
* 'looptime' timer cannot expire. While they are in this state, the
* masters will try to saturate the network with SETTIME packets.
*/
looptime = ntime.tv_sec + (looptime-otime.tv_sec)/2-1;
break;
case TSP_MASTERUP:
if (slavenet && fromnet != slavenet)
break;
if (!good_host_name(msg->tsp_name)) {
suppress(&from, msg->tsp_name, fromnet);
if (electiontime > fastelection)
electiontime = fastelection;
break;
}
makeslave(fromnet);
setmaster(msg);
setstatus();
answerdelay();
xmit(TSP_SLAVEUP, 0, &from);
(void)gettimeofday(&ntime, NULL);
electiontime = ntime.tv_sec + delay2;
fastelection = ntime.tv_sec + FASTTOUT;
refusetime = 0;
break;
case TSP_MASTERREQ:
if (fromnet->status != SLAVE)
break;
(void)gettimeofday(&ntime, NULL);
electiontime = ntime.tv_sec + delay2;
break;
case TSP_SETDATE:
tsp_time_sec = msg->tsp_time.tv_sec;
(void)strcpy(newdate, ctime(&tsp_time_sec));
schgdate(msg, newdate);
break;
case TSP_SETDATEREQ:
if (fromnet->status != MASTER)
break;
tsp_time_sec = msg->tsp_time.tv_sec;
(void)strcpy(newdate, ctime(&tsp_time_sec));
htp = findhost(msg->tsp_name);
if (0 == htp) {
syslog(LOG_WARNING,
"DATEREQ from uncontrolled machine");
break;
}
if (!htp->good) {
syslog(LOG_WARNING,
"attempted date change by untrusted %s to %s",
htp->name, newdate);
spreadtime();
break;
}
schgdate(msg, newdate);
break;
case TSP_TRACEON:
traceon();
break;
case TSP_TRACEOFF:
traceoff("Tracing ended at %s\n");
break;
case TSP_SLAVEUP:
newslave(msg);
break;
case TSP_ELECTION:
if (fromnet->status == SLAVE) {
(void)gettimeofday(&ntime, NULL);
electiontime = ntime.tv_sec + delay2;
fastelection = ntime.tv_sec + FASTTOUT;
seq = 0;
if (!good_host_name(msg->tsp_name)) {
syslog(LOG_NOTICE,
"suppress election of %s",
msg->tsp_name);
to.tsp_type = TSP_QUIT;
electiontime = fastelection;
} else if (cadr.s_addr != from.sin_addr.s_addr
&& ntime.tv_sec < refusetime) {
/* if the candidate has to repeat itself, the old code would refuse it
* the second time. That would prevent elections.
*/
to.tsp_type = TSP_REFUSE;
} else {
cadr.s_addr = from.sin_addr.s_addr;
to.tsp_type = TSP_ACCEPT;
refusetime = ntime.tv_sec + 30;
}
taddr = from;
(void)strcpy(tname, msg->tsp_name);
(void)strcpy(to.tsp_name, hostname);
answerdelay();
if (!acksend(&to, &taddr, tname,
TSP_ACK, 0, 0))
syslog(LOG_WARNING,
"no answer from candidate %s\n",
tname);
} else { /* fromnet->status == MASTER */
htp = addmach(msg->tsp_name, &from,fromnet);
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
if (!acksend(&to, &htp->addr, htp->name,
TSP_ACK, 0, htp->noanswer)) {
syslog(LOG_ERR,
"no reply from %s to ELECTION-QUIT",
htp->name);
(void)remmach(htp);
}
}
break;
case TSP_CONFLICT:
if (fromnet->status != MASTER)
break;
/*
* After a network partition, there can be
* more than one master: the first slave to
* come up will notify here the situation.
*/
(void)strcpy(to.tsp_name, hostname);
/* The other master often gets into the same state,
* with boring results.
*/
ntp = fromnet; /* (acksend() can leave fromnet=0 */
for (tries = 0; tries < 3; tries++) {
to.tsp_type = TSP_RESOLVE;
answer = acksend(&to, &ntp->dest_addr,
ANYADDR, TSP_MASTERACK,
ntp, 0);
if (answer == NULL)
break;
htp = addmach(answer->tsp_name,&from,ntp);
to.tsp_type = TSP_QUIT;
answer = acksend(&to, &htp->addr, htp->name,
TSP_ACK, 0, htp->noanswer);
if (!answer) {
syslog(LOG_WARNING,
"conflict error: no reply from %s to QUIT",
htp->name);
(void)remmach(htp);
}
}
masterup(ntp);
break;
case TSP_MSITE:
if (!slavenet)
break;
taddr = from;
to.tsp_type = TSP_MSITEREQ;
to.tsp_vers = TSPVERSION;
to.tsp_seq = 0;
(void)strcpy(to.tsp_name, hostname);
answer = acksend(&to, &slavenet->dest_addr,
ANYADDR, TSP_ACK,
slavenet, 0);
if (answer != NULL
&& good_host_name(answer->tsp_name)) {
setmaster(answer);
to.tsp_type = TSP_ACK;
(void)strcpy(to.tsp_name, answer->tsp_name);
bytenetorder(&to);
if (sendto(sock, (char *)&to,
sizeof(struct tsp), 0,
(struct sockaddr*)&taddr,
sizeof(taddr)) < 0) {
trace_sendto_err(taddr.sin_addr);
}
}
break;
case TSP_MSITEREQ:
break;
case TSP_ACCEPT:
case TSP_REFUSE:
case TSP_RESOLVE:
break;
case TSP_QUIT:
doquit(msg); /* become a slave */
break;
case TSP_TEST:
electiontime = 0;
break;
case TSP_LOOP:
/* looking for loops of masters */
if (!(status & MASTER))
break;
if (fromnet->status == SLAVE) {
if (!strcmp(msg->tsp_name, hostname)) {
/*
* Someone forwarded our message back to
* us. There must be a loop. Tell the
* master of this network to quit.
*
* The other master often gets into
* the same state, with boring results.
*/
ntp = fromnet;
for (tries = 0; tries < 3; tries++) {
to.tsp_type = TSP_RESOLVE;
answer = acksend(&to, &ntp->dest_addr,
ANYADDR, TSP_MASTERACK,
ntp,0);
if (answer == NULL)
break;
taddr = from;
(void)strcpy(tname, answer->tsp_name);
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
if (!acksend(&to, &taddr, tname,
TSP_ACK, 0, 1)) {
syslog(LOG_ERR,
"no reply from %s to slave LOOP-QUIT",
tname);
} else {
electiontime = 0;
}
}
(void)gettimeofday(&ntime, NULL);
looptime = ntime.tv_sec + FASTTOUT;
} else {
if (msg->tsp_hopcnt-- < 1)
break;
bytenetorder(msg);
for (ntp = nettab; ntp != 0; ntp = ntp->next) {
if (ntp->status == MASTER
&& 0 > sendto(sock, (char *)msg,
sizeof(struct tsp), 0,
(struct sockaddr*)&ntp->dest_addr,
sizeof(ntp->dest_addr)))
trace_sendto_err(ntp->dest_addr.sin_addr);
}
}
} else { /* fromnet->status == MASTER */
/*
* We should not have received this from a net
* we are master on. There must be two masters,
* unless the packet was really from us.
*/
if (from.sin_addr.s_addr
== fromnet->my_addr.s_addr) {
if (trace)
fprintf(fd,"discarding forwarded LOOP\n");
break;
}
/*
* The other master often gets into the same
* state, with boring results.
*/
ntp = fromnet;
for (tries = 0; tries < 3; tries++) {
to.tsp_type = TSP_RESOLVE;
answer = acksend(&to, &ntp->dest_addr,
ANYADDR, TSP_MASTERACK,
ntp,0);
if (!answer)
break;
htp = addmach(answer->tsp_name,
&from,ntp);
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
if (!acksend(&to,&htp->addr,htp->name,
TSP_ACK, 0, htp->noanswer)) {
syslog(LOG_ERR,
"no reply from %s to master LOOP-QUIT",
htp->name);
(void)remmach(htp);
}
}
(void)gettimeofday(&ntime, NULL);
looptime = ntime.tv_sec + FASTTOUT;
}
break;
default:
if (trace) {
fprintf(fd, "garbage message: ");
print(msg, &from);
}
break;
}
}
goto loop;
}
/*
* 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);
}
slave()
{
int length;
int senddateack;
long electiontime, refusetime, looktime;
u_short seq;
char candidate[MAXHOSTNAMELEN];
struct tsp *msg, to, *readmsg();
struct sockaddr_in saveaddr, msaveaddr;
struct timeval wait;
struct timeval time, otime;
struct tsp *answer, *acksend();
int timeout();
char *date();
long casual();
int bytenetorder();
char olddate[32];
struct sockaddr_in server;
register struct netinfo *ntp;
int ind;
struct tsp resp;
extern int Mflag;
extern int justquit;
#ifdef MEASURE
extern FILE *fp;
#endif
if (slavenet) {
resp.tsp_type = TSP_SLAVEUP;
resp.tsp_vers = TSPVERSION;
(void)strcpy(resp.tsp_name, hostname);
bytenetorder(&resp);
if (sendto(sock, (char *)&resp, sizeof(struct tsp), 0,
&slavenet->dest_addr, sizeof(struct sockaddr_in)) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
}
if (status & MASTER) {
#ifdef MEASURE
if (fp == NULL) {
fp = fopen("/usr/adm/timed.masterlog", "w");
setlinebuf(fp);
}
#endif
syslog(LOG_INFO, "THIS MACHINE IS A SUBMASTER");
if (trace) {
fprintf(fd, "THIS MACHINE IS A SUBMASTER\n");
}
for (ntp = nettab; ntp != NULL; ntp = ntp->next)
if (ntp->status == MASTER)
masterup(ntp);
} else {
syslog(LOG_INFO, "THIS MACHINE IS A SLAVE");
if (trace) {
fprintf(fd, "THIS MACHINE IS A SLAVE\n");
}
}
seq = 0;
senddateack = OFF;
refusetime = 0;
(void)gettimeofday(&time, (struct timezone *)0);
electiontime = time.tv_sec + delay2;
if (Mflag)
if (justquit)
looktime = time.tv_sec + delay2;
else
looktime = 1;
else
looktime = 0;
loop:
length = sizeof(struct sockaddr_in);
(void)gettimeofday(&time, (struct timezone *)0);
if (time.tv_sec > electiontime) {
if (trace)
fprintf(fd, "election timer expired\n");
longjmp(jmpenv, 1);
}
if (looktime && time.tv_sec > looktime) {
if (trace)
fprintf(fd, "Looking for nets to master and loops\n");
if (nignorednets > 0) {
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == IGNORE) {
lookformaster(ntp);
if (ntp->status == MASTER)
masterup(ntp);
else
ntp->status = IGNORE;
}
}
setstatus();
#ifdef MEASURE
/*
* Check to see if we just became master
* (file not open)
*/
if (fp == NULL) {
fp = fopen("/usr/adm/timed.masterlog", "w");
setlinebuf(fp);
}
#endif
}
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == MASTER) {
to.tsp_type = TSP_LOOP;
to.tsp_vers = TSPVERSION;
to.tsp_seq = sequence++;
to.tsp_hopcnt = 10;
(void)strcpy(to.tsp_name, hostname);
bytenetorder(&to);
if (sendto(sock, (char *)&to, sizeof(struct tsp), 0,
&ntp->dest_addr, sizeof(struct sockaddr_in)) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
}
}
(void)gettimeofday(&time, (struct timezone *)0);
looktime = time.tv_sec + delay2;
}
wait.tv_sec = electiontime - time.tv_sec + 10;
wait.tv_usec = 0;
msg = readmsg(TSP_ANY, (char *)ANYADDR, &wait, (struct netinfo *)NULL);
if (msg != NULL) {
switch (msg->tsp_type) {
case TSP_SETDATE:
#ifdef TESTING
case TSP_TEST:
#endif
case TSP_MSITE:
case TSP_TRACEOFF:
case TSP_TRACEON:
break;
case TSP_MASTERUP:
if (fromnet == NULL) {
if (trace) {
fprintf(fd, "slave ignored: ");
print(msg, &from);
}
goto loop;
}
break;
default:
if (fromnet == NULL || fromnet->status == IGNORE) {
if (trace) {
fprintf(fd, "slave ignored: ");
print(msg, &from);
}
goto loop;
}
break;
}
switch (msg->tsp_type) {
case TSP_ADJTIME:
if (fromnet->status != SLAVE)
break;
(void)gettimeofday(&time, (struct timezone *)0);
electiontime = time.tv_sec + delay2;
if (seq != msg->tsp_seq) {
seq = msg->tsp_seq;
if ((status & SUBMASTER) == SUBMASTER) {
synch((msg->tsp_time.tv_sec * 1000) +
(msg->tsp_time.tv_usec / 1000));
} else {
adjclock(&(msg->tsp_time));
}
}
break;
case TSP_SETTIME:
if (fromnet->status != SLAVE)
break;
if (seq == msg->tsp_seq)
break;
seq = msg->tsp_seq;
(void)strcpy(olddate, date());
(void)gettimeofday(&otime, (struct timezone *)0);
(void)settimeofday(&msg->tsp_time,
(struct timezone *)0);
syslog(LOG_NOTICE, "date changed by %s from: %s",
msg->tsp_name, olddate);
logwtmp(otime, msg->tsp_time);
if ((status & SUBMASTER) == SUBMASTER)
spreadtime();
(void)gettimeofday(&time, (struct timezone *)0);
electiontime = time.tv_sec + delay2;
if (senddateack == ON) {
senddateack = OFF;
msg->tsp_type = TSP_DATEACK;
(void)strcpy(msg->tsp_name, hostname);
bytenetorder(msg);
length = sizeof(struct sockaddr_in);
if (sendto(sock, (char *)msg,
sizeof(struct tsp), 0,
&saveaddr, length) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
}
break;
case TSP_MASTERUP:
if (slavenet && fromnet != slavenet)
break;
makeslave(fromnet);
setstatus();
msg->tsp_type = TSP_SLAVEUP;
msg->tsp_vers = TSPVERSION;
(void)strcpy(msg->tsp_name, hostname);
bytenetorder(msg);
answerdelay();
length = sizeof(struct sockaddr_in);
if (sendto(sock, (char *)msg, sizeof(struct tsp), 0,
&from, length) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
backoff = 1;
delay2 = casual((long)MINTOUT, (long)MAXTOUT);
(void)gettimeofday(&time, (struct timezone *)0);
electiontime = time.tv_sec + delay2;
refusetime = 0;
break;
case TSP_MASTERREQ:
if (fromnet->status != SLAVE)
break;
(void)gettimeofday(&time, (struct timezone *)0);
electiontime = time.tv_sec + delay2;
break;
case TSP_SETDATE:
saveaddr = from;
msg->tsp_type = TSP_SETDATEREQ;
msg->tsp_vers = TSPVERSION;
(void)strcpy(msg->tsp_name, hostname);
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == SLAVE)
break;
}
if (ntp == NULL)
break;
answer = acksend(msg, &ntp->dest_addr, (char *)ANYADDR,
TSP_DATEACK, ntp);
if (answer != NULL) {
msg->tsp_type = TSP_ACK;
bytenetorder(msg);
length = sizeof(struct sockaddr_in);
if (sendto(sock, (char *)msg,
sizeof(struct tsp), 0, &saveaddr,
length) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
senddateack = ON;
}
break;
case TSP_SETDATEREQ:
saveaddr = from;
if (status != SUBMASTER || fromnet->status != MASTER)
break;
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == SLAVE)
break;
}
ind = findhost(msg->tsp_name);
if (ind < 0) {
syslog(LOG_WARNING,
"DATEREQ from uncontrolled machine");
break;
}
syslog(LOG_DEBUG,
"forwarding date change request for %s",
msg->tsp_name);
(void)strcpy(msg->tsp_name, hostname);
answer = acksend(msg, &ntp->dest_addr, (char *)ANYADDR,
TSP_DATEACK, ntp);
if (answer != NULL) {
msg->tsp_type = TSP_DATEACK;
bytenetorder(msg);
length = sizeof(struct sockaddr_in);
if (sendto(sock, (char *)msg,
sizeof(struct tsp), 0, &saveaddr,
length) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
}
break;
case TSP_TRACEON:
if (!(trace)) {
fd = fopen(tracefile, "w");
setlinebuf(fd);
fprintf(fd, "Tracing started on: %s\n\n",
date());
}
trace = ON;
break;
case TSP_TRACEOFF:
if (trace) {
fprintf(fd, "Tracing ended on: %s\n", date());
(void)fclose(fd);
}
#ifdef GPROF
moncontrol(0);
_mcleanup();
moncontrol(1);
#endif
trace = OFF;
break;
case TSP_SLAVEUP:
if ((status & MASTER) && fromnet->status == MASTER) {
ind = addmach(msg->tsp_name, &from);
newslave(ind, msg->tsp_seq);
}
break;
case TSP_ELECTION:
if (fromnet->status == SLAVE) {
(void)gettimeofday(&time, (struct timezone *)0);
electiontime = time.tv_sec + delay2;
seq = 0; /* reset sequence number */
if (time.tv_sec < refusetime)
msg->tsp_type = TSP_REFUSE;
else {
msg->tsp_type = TSP_ACCEPT;
refusetime = time.tv_sec + 30;
}
(void)strcpy(candidate, msg->tsp_name);
(void)strcpy(msg->tsp_name, hostname);
answerdelay();
server = from;
answer = acksend(msg, &server, candidate, TSP_ACK,
(struct netinfo *)NULL);
if (answer == NULL)
syslog(LOG_WARNING,
"no answer from master candidate\n");
} else { /* fromnet->status == MASTER */
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
server = from;
answer = acksend(&to, &server, msg->tsp_name,
TSP_ACK, (struct netinfo *)NULL);
if (answer == NULL) {
syslog(LOG_WARNING,
"election error: no reply to QUIT");
} else {
(void) addmach(msg->tsp_name, &from);
}
}
break;
case TSP_CONFLICT:
if (fromnet->status != MASTER)
break;
/*
* After a network partition, there can be
* more than one master: the first slave to
* come up will notify here the situation.
*/
(void)strcpy(to.tsp_name, hostname);
if (fromnet == NULL)
break;
for(;;) {
to.tsp_type = TSP_RESOLVE;
answer = acksend(&to, &fromnet->dest_addr,
(char *)ANYADDR, TSP_MASTERACK, fromnet);
if (answer == NULL)
break;
to.tsp_type = TSP_QUIT;
server = from;
msg = acksend(&to, &server, answer->tsp_name,
TSP_ACK, (struct netinfo *)NULL);
if (msg == NULL) {
syslog(LOG_WARNING,
"conflict error: no reply to QUIT");
} else {
(void) addmach(answer->tsp_name, &from);
}
}
masterup(fromnet);
break;
case TSP_MSITE:
if (!slavenet)
break;
msaveaddr = from;
msg->tsp_type = TSP_MSITEREQ;
msg->tsp_vers = TSPVERSION;
(void)strcpy(msg->tsp_name, hostname);
answer = acksend(msg, &slavenet->dest_addr,
(char *)ANYADDR, TSP_ACK, slavenet);
if (answer != NULL) {
msg->tsp_type = TSP_ACK;
length = sizeof(struct sockaddr_in);
bytenetorder(msg);
if (sendto(sock, (char *)msg,
sizeof(struct tsp), 0,
&msaveaddr, length) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
}
break;
case TSP_ACCEPT:
case TSP_REFUSE:
break;
case TSP_RESOLVE:
break;
case TSP_QUIT:
/* become slave */
#ifdef MEASURE
if (fp != NULL) {
(void)fclose(fp);
fp = NULL;
}
#endif
longjmp(jmpenv, 2);
break;
#ifdef TESTING
case TSP_TEST:
electiontime = 0;
break;
#endif
case TSP_MSITEREQ:
if (status & MASTER)
break;
if (trace) {
fprintf(fd, "garbage: ");
print(msg, &from);
}
break;
case TSP_LOOP:
/* looking for loops of masters */
if ( !(status & MASTER))
break;
if (fromnet->status == SLAVE) {
if ( !strcmp(msg->tsp_name, hostname)) {
for(;;) {
to.tsp_type = TSP_RESOLVE;
answer = acksend(&to, &fromnet->dest_addr,
(char *)ANYADDR, TSP_MASTERACK,
fromnet);
if (answer == NULL)
break;
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
server = from;
answer = acksend(&to, &server,
answer->tsp_name, TSP_ACK,
(struct netinfo *)NULL);
if (answer == NULL) {
syslog(LOG_ERR, "loop kill error");
} else {
electiontime = 0;
}
}
} else {
if (msg->tsp_hopcnt-- <= 0)
break;
bytenetorder(msg);
ntp = nettab;
for (; ntp != NULL; ntp = ntp->next)
if (ntp->status == MASTER)
if (sendto(sock, (char *)msg,
sizeof(struct tsp), 0,
&ntp->dest_addr, length) < 0) {
syslog(LOG_ERR, "sendto: %m");
exit(1);
}
}
} else {
/*
* We should not have received this from a net
* we are master on. There must be two masters
* in this case.
*/
if (fromnet->my_addr.s_addr == from.sin_addr.s_addr)
break;
for (;;) {
to.tsp_type = TSP_RESOLVE;
answer = acksend(&to, &fromnet->dest_addr,
(char *)ANYADDR, TSP_MASTERACK,
fromnet);
if (answer == NULL)
break;
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
server = from;
answer = acksend(&to, &server, answer->tsp_name,
TSP_ACK, (struct netinfo *)NULL);
if (answer == NULL) {
syslog(LOG_ERR, "loop kill error2");
} else {
(void)addmach(msg->tsp_name, &from);
}
}
}
break;
default:
if (trace) {
fprintf(fd, "garbage: ");
print(msg, &from);
}
break;
}
}
goto loop;
}
