/*
* 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;
}
}
}
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 main function of `master' is to periodically compute the differences
* (deltas) between its clock and the clocks of the slaves, to compute the
* network average delta, and to send to the slaves the differences between
* their individual deltas and the network delta.
* While waiting, it receives messages from the slaves (i.e. requests for
* master's name, remote requests to set the network time, ...), and
* takes the appropriate action.
*/
int
master()
{
struct hosttbl *htp;
long pollingtime;
#define POLLRATE 4
int polls;
struct timeval wait, ntime;
time_t tsp_time_sec;
struct tsp *msg, *answer, to;
char newdate[32];
struct sockaddr_in taddr;
char tname[MAXHOSTNAMELEN];
struct netinfo *ntp;
int i;
syslog(LOG_NOTICE, "This machine is master");
if (trace)
fprintf(fd, "This machine is master\n");
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == MASTER)
masterup(ntp);
}
(void)gettimeofday(&ntime, 0);
pollingtime = ntime.tv_sec+3;
if (justquit)
polls = 0;
else
polls = POLLRATE-1;
/* Process all outstanding messages before spending the long time necessary
* to update all timers.
*/
loop:
(void)gettimeofday(&ntime, 0);
wait.tv_sec = pollingtime - ntime.tv_sec;
if (wait.tv_sec < 0)
wait.tv_sec = 0;
wait.tv_usec = 0;
msg = readmsg(TSP_ANY, ANYADDR, &wait, 0);
if (!msg) {
(void)gettimeofday(&ntime, 0);
if (ntime.tv_sec >= pollingtime) {
pollingtime = ntime.tv_sec + SAMPLEINTVL;
get_goodgroup(0);
/* If a bogus master told us to quit, we can have decided to ignore a
* network. Therefore, periodically try to take over everything.
*/
polls = (polls + 1) % POLLRATE;
if (0 == polls && nignorednets > 0) {
trace_msg("Looking for nets to re-master\n");
for (ntp = nettab; ntp; ntp = ntp->next) {
if (ntp->status == IGNORE
|| ntp->status == NOMASTER) {
lookformaster(ntp);
if (ntp->status == MASTER) {
masterup(ntp);
polls = POLLRATE-1;
}
}
if (ntp->status == MASTER
&& --ntp->quit_count < 0)
ntp->quit_count = 0;
}
if (polls != 0)
setstatus();
}
synch(0L);
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
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);
}
}
}
} else {
switch (msg->tsp_type) {
case TSP_MASTERREQ:
break;
case TSP_SLAVEUP:
newslave(msg);
break;
case TSP_SETDATE:
/*
* XXX check to see it is from ourself
*/
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 date change by %s to %s",
msg->tsp_name, newdate);
spreadtime();
break;
}
mchgdate(msg);
(void)gettimeofday(&ntime, 0);
pollingtime = ntime.tv_sec + SAMPLEINTVL;
break;
case TSP_SETDATEREQ:
if (!fromnet || 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 (htp == 0) {
syslog(LOG_ERR,
"attempted SET DATEREQ by uncontrolled %s to %s",
msg->tsp_name, newdate);
break;
}
if (htp->seq == msg->tsp_seq)
break;
htp->seq = msg->tsp_seq;
if (!htp->good) {
syslog(LOG_NOTICE,
"attempted SET DATEREQ by untrusted %s to %s",
msg->tsp_name, newdate);
spreadtime();
break;
}
mchgdate(msg);
(void)gettimeofday(&ntime, 0);
pollingtime = ntime.tv_sec + SAMPLEINTVL;
break;
case TSP_MSITE:
xmit(TSP_ACK, msg->tsp_seq, &from);
break;
case TSP_MSITEREQ:
break;
case TSP_TRACEON:
traceon();
break;
case TSP_TRACEOFF:
traceoff("Tracing ended at %s\n");
break;
case TSP_ELECTION:
if (!fromnet)
break;
if (fromnet->status == MASTER) {
pollingtime = 0;
(void)addmach(msg->tsp_name, &from,fromnet);
}
taddr = from;
(void)strcpy(tname, msg->tsp_name);
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
answer = acksend(&to, &taddr, tname,
TSP_ACK, 0, 1);
if (answer == NULL) {
syslog(LOG_ERR, "election error by %s",
tname);
}
break;
case TSP_CONFLICT:
/*
* After a network partition, there can be
* more than one master: the first slave to
* come up will notify here the situation.
*/
if (!fromnet || fromnet->status != MASTER)
break;
(void)strcpy(to.tsp_name, hostname);
/* The other master often gets into the same state,
* with boring results if we stay at it forever.
*/
ntp = fromnet; /* (acksend() can leave fromnet=0 */
for (i = 0; i < 3; i++) {
to.tsp_type = TSP_RESOLVE;
(void)strcpy(to.tsp_name, hostname);
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;
msg = acksend(&to, &htp->addr, htp->name,
TSP_ACK, 0, htp->noanswer);
if (msg == NULL) {
syslog(LOG_ERR,
"no response from %s to CONFLICT-QUIT",
htp->name);
}
}
masterup(ntp);
pollingtime = 0;
break;
case TSP_RESOLVE:
if (!fromnet || fromnet->status != MASTER)
break;
/*
* do not want to call synch() while waiting
* to be killed!
*/
(void)gettimeofday(&ntime, (struct timezone *)0);
pollingtime = ntime.tv_sec + SAMPLEINTVL;
break;
case TSP_QUIT:
doquit(msg); /* become a slave */
break;
case TSP_LOOP:
if (!fromnet || fromnet->status != MASTER
|| !strcmp(msg->tsp_name, hostname))
break;
/*
* We should not have received this from a net
* we are master on. There must be two masters.
*/
htp = addmach(msg->tsp_name, &from,fromnet);
to.tsp_type = TSP_QUIT;
(void)strcpy(to.tsp_name, hostname);
answer = acksend(&to, &htp->addr, htp->name,
TSP_ACK, 0, 1);
if (!answer) {
syslog(LOG_WARNING,
"loop breakage: no reply from %s=%s to QUIT",
htp->name, inet_ntoa(htp->addr.sin_addr));
(void)remmach(htp);
}
case TSP_TEST:
if (trace) {
fprintf(fd,
"\tnets = %d, masters = %d, slaves = %d, ignored = %d\n",
nnets, nmasternets, nslavenets, nignorednets);
setstatus();
}
pollingtime = 0;
polls = POLLRATE-1;
break;
default:
if (trace) {
fprintf(fd, "garbage message: ");
print(msg, &from);
}
break;
}
}
goto loop;
}
/* update our image of the net-group of trustworthy hosts
*/
void
get_goodgroup(int force)
{
# define NG_DELAY (30*60*CLK_TCK) /* 30 minutes */
static unsigned long last_update = -NG_DELAY;
unsigned long new_update;
struct goodhost *ghp, **ghpp;
#ifdef HAVENIS
struct hosttbl *htp;
char *mach, *usr, *dom;
#endif /* HAVENIS */
struct tms tm;
/* if no netgroup, then we are finished */
if (goodgroup == NULL || !Mflag)
return;
/* Do not chatter with the netgroup master too often.
*/
new_update = times(&tm);
if (new_update < last_update + NG_DELAY
&& !force)
return;
last_update = new_update;
/* forget the old temporary entries */
ghpp = &goodhosts;
while ((ghp = *ghpp) != NULL) {
if (!ghp->perm) {
*ghpp = ghp->next;
free(ghp);
} else {
ghpp = &ghp->next;
}
}
#ifdef HAVENIS
/* quit now if we are not one of the trusted masters
*/
if (!innetgr(goodgroup, &hostname[0], 0,0)) {
if (trace)
(void)fprintf(fd, "get_goodgroup: %s not in %s\n",
&hostname[0], goodgroup);
return;
}
if (trace)
(void)fprintf(fd, "get_goodgroup: %s in %s\n",
&hostname[0], goodgroup);
/* mark the entire netgroup as trusted */
(void)setnetgrent(goodgroup);
while (getnetgrent(&mach,&usr,&dom)) {
if (mach != NULL)
add_good_host(mach,0);
}
(void)endnetgrent();
/* update list of slaves */
for (htp = self.l_fwd; htp != &self; htp = htp->l_fwd) {
htp->good = good_host_name(&htp->name[0]);
}
#endif /* HAVENIS */
}
void
lookformaster(struct netinfo *ntp)
{
struct tsp resp, conflict, *answer;
struct timeval ntime;
char mastername[MAXHOSTNAMELEN];
struct sockaddr_in masteraddr;
get_goodgroup(0);
ntp->status = SLAVE;
/* look for master */
resp.tsp_type = TSP_MASTERREQ;
(void)strcpy(resp.tsp_name, hostname);
answer = acksend(&resp, &ntp->dest_addr, ANYADDR,
TSP_MASTERACK, ntp, 0);
if (answer != NULL && !good_host_name(answer->tsp_name)) {
suppress(&from, answer->tsp_name, ntp);
ntp->status = NOMASTER;
answer = NULL;
}
if (answer == NULL) {
/*
* Various conditions can cause conflict: races between
* two just started timedaemons when no master is
* present, or timedaemons started during an election.
* A conservative approach is taken. Give up and became a
* slave, postponing election of a master until first
* timer expires.
*/
ntime.tv_sec = ntime.tv_usec = 0;
answer = readmsg(TSP_MASTERREQ, ANYADDR, &ntime, ntp);
if (answer != NULL) {
if (!good_host_name(answer->tsp_name)) {
suppress(&from, answer->tsp_name, ntp);
ntp->status = NOMASTER;
}
return;
}
ntime.tv_sec = ntime.tv_usec = 0;
answer = readmsg(TSP_MASTERUP, ANYADDR, &ntime, ntp);
if (answer != NULL) {
if (!good_host_name(answer->tsp_name)) {
suppress(&from, answer->tsp_name, ntp);
ntp->status = NOMASTER;
}
return;
}
ntime.tv_sec = ntime.tv_usec = 0;
answer = readmsg(TSP_ELECTION, ANYADDR, &ntime, ntp);
if (answer != NULL) {
if (!good_host_name(answer->tsp_name)) {
suppress(&from, answer->tsp_name, ntp);
ntp->status = NOMASTER;
}
return;
}
if (Mflag)
ntp->status = MASTER;
else
ntp->status = NOMASTER;
return;
}
ntp->status = SLAVE;
(void)strcpy(mastername, answer->tsp_name);
masteraddr = from;
/*
* If network has been partitioned, there might be other
* masters; tell the one we have just acknowledged that
* it has to gain control over the others.
*/
ntime.tv_sec = 0;
ntime.tv_usec = 300000;
answer = readmsg(TSP_MASTERACK, ANYADDR, &ntime, ntp);
/*
* checking also not to send CONFLICT to ack'ed master
* due to duplicated MASTERACKs
*/
if (answer != NULL &&
strcmp(answer->tsp_name, mastername) != 0) {
conflict.tsp_type = TSP_CONFLICT;
(void)strcpy(conflict.tsp_name, hostname);
if (!acksend(&conflict, &masteraddr, mastername,
TSP_ACK, 0, 0)) {
syslog(LOG_ERR,
"error on sending TSP_CONFLICT");
}
}
}
/*
* add a host to the list of controlled machines if not already there
*/
struct hosttbl *
addmach(char *name, struct sockaddr_in *addr, struct netinfo *ntp)
{
struct hosttbl *ret, *p, *b, *f;
ret = findhost(name);
if (ret == 0) {
if (slvcount >= NHOSTS) {
if (trace) {
fprintf(fd, "no more slots in host table\n");
prthp(CLK_TCK);
}
syslog(LOG_ERR, "no more slots in host table");
Mflag = 0;
longjmp(jmpenv, 2); /* give up and be a slave */
}
/* if our home hash slot is occupied, find a free entry
* in the hash table
*/
if (newhost_hash->name[0] != '\0') {
do {
ret = lasthfree;
if (++lasthfree > &hosttbl[NHOSTS])
lasthfree = &hosttbl[1];
} while (ret->name[0] != '\0');
if (!newhost_hash->head) {
/* Move an interloper using our home. Use
* scratch pointers in case the new head is
* pointing to itself.
*/
f = newhost_hash->h_fwd;
b = newhost_hash->h_bak;
f->h_bak = ret;
b->h_fwd = ret;
f = newhost_hash->l_fwd;
b = newhost_hash->l_bak;
f->l_bak = ret;
b->l_fwd = ret;
bcopy(newhost_hash,ret,sizeof(*ret));
ret = newhost_hash;
ret->head = 1;
ret->h_fwd = ret;
ret->h_bak = ret;
} else {
/* link to an existing chain in our home
*/
ret->head = 0;
p = newhost_hash->h_bak;
ret->h_fwd = newhost_hash;
ret->h_bak = p;
p->h_fwd = ret;
newhost_hash->h_bak = ret;
}
} else {
ret = newhost_hash;
ret->head = 1;
ret->h_fwd = ret;
ret->h_bak = ret;
}
ret->addr = *addr;
ret->ntp = ntp;
(void)strncpy(ret->name, name, sizeof(ret->name));
ret->good = good_host_name(name);
ret->l_fwd = &self;
ret->l_bak = self.l_bak;
self.l_bak->l_fwd = ret;
self.l_bak = ret;
slvcount++;
ret->noanswer = 0;
ret->need_set = 1;
} else {
ret->noanswer = (ret->noanswer != 0);
}
/* need to clear sequence number anyhow */
ret->seq = 0;
return(ret);
}
/*
* `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;
}
}
}