#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_unixtime.h"
#include "ntp_refclock.h"
#include "ntp_stdlib.h"
#ifdef REFCLOCK
#ifdef TTYCLK
#include <sys/clkdefs.h>
#endif
#ifdef HAVE_PPSCLOCK_H
#include <sys/ppsclock.h>
#endif
#ifdef HAVE_PPSAPI
#include <sys/timepps.h>
#endif
#define MAXUNIT 4
#ifndef CLKLDISC
#define CLKLDISC 10
#endif
#if defined(PPS) || defined(HAVE_PPSAPI)
int fdpps;
#endif
static struct peer *typeunit[REFCLK_MAX + 1][MAXUNIT];
#ifdef QSORT_USES_VOID_P
static int refclock_cmpl_fp P((const void *, const void *));
#else
static int refclock_cmpl_fp P((const double *, const double *));
#endif
#ifdef HAVE_PPSAPI
extern int pps_assert;
extern int pps_hardpps;
#endif
void
refclock_report(
struct peer *peer,
int code
)
{
struct refclockproc *pp;
if (!(pp = peer->procptr))
return;
if (code == CEVNT_BADREPLY)
pp->badformat++;
if (code == CEVNT_BADTIME)
pp->baddata++;
if (code == CEVNT_TIMEOUT)
pp->noreply++;
if (pp->currentstatus != code) {
pp->currentstatus = code;
pp->lastevent = code;
if (code == CEVNT_FAULT)
msyslog(LOG_ERR,
"clock %s event '%s' (0x%02x)",
refnumtoa(peer->srcadr.sin_addr.s_addr),
ceventstr(code), code);
else {
NLOG(NLOG_CLOCKEVENT)
msyslog(LOG_INFO,
"clock %s event '%s' (0x%02x)",
refnumtoa(peer->srcadr.sin_addr.s_addr),
ceventstr(code), code);
}
}
#ifdef DEBUG
if (debug)
printf("clock %s event '%s' (0x%02x)\n",
refnumtoa(peer->srcadr.sin_addr.s_addr),
ceventstr(code), code);
#endif
}
void
init_refclock(void)
{
int i, j;
for (i = 0; i < (int)num_refclock_conf; i++) {
if (refclock_conf[i]->clock_init != noentry)
(refclock_conf[i]->clock_init)();
for (j = 0; j < MAXUNIT; j++)
typeunit[i][j] = 0;
}
}
int
refclock_newpeer(
struct peer *peer
)
{
struct refclockproc *pp;
u_char clktype;
int unit;
if (!ISREFCLOCKADR(&peer->srcadr)) {
msyslog(LOG_ERR,
"refclock_newpeer: clock address %s invalid",
ntoa(&peer->srcadr));
return (0);
}
clktype = (u_char)REFCLOCKTYPE(&peer->srcadr);
unit = REFCLOCKUNIT(&peer->srcadr);
if (clktype >= num_refclock_conf || unit > MAXUNIT ||
refclock_conf[clktype]->clock_start == noentry) {
msyslog(LOG_ERR,
"refclock_newpeer: clock type %d invalid\n",
clktype);
return (0);
}
refclock_unpeer(peer);
if (!(pp = (struct refclockproc *)emalloc(sizeof(struct refclockproc))))
return (0);
memset((char *)pp, 0, sizeof(struct refclockproc));
typeunit[clktype][unit] = peer;
peer->procptr = pp;
peer->refclktype = clktype;
peer->refclkunit = unit;
peer->flags |= FLAG_REFCLOCK;
peer->stratum = STRATUM_REFCLOCK;
peer->refid = peer->srcadr.sin_addr.s_addr;
peer->maxpoll = peer->minpoll;
pp->type = clktype;
pp->timestarted = current_time;
pp->nstages = NSTAGE;
pp->nskeep = NSTAGE * 3 / 5;
if (peer->dstadr == any_interface && loopback_interface != 0)
peer->dstadr = loopback_interface;
switch (peer->hmode) {
case MODE_ACTIVE:
peer->pmode = MODE_PASSIVE;
break;
default:
peer->pmode = MODE_SERVER;
break;
}
if (!((refclock_conf[clktype]->clock_start)(unit, peer))) {
free(pp);
return (0);
}
peer->hpoll = peer->minpoll;
peer->ppoll = peer->maxpoll;
if (peer->stratum <= 1)
peer->refid = pp->refid;
else
peer->refid = peer->srcadr.sin_addr.s_addr;
return (1);
}
void
refclock_unpeer(
struct peer *peer
)
{
u_char clktype;
int unit;
if (!peer->procptr)
return;
clktype = peer->refclktype;
unit = peer->refclkunit;
if (refclock_conf[clktype]->clock_shutdown != noentry)
(refclock_conf[clktype]->clock_shutdown)(unit, peer);
free(peer->procptr);
peer->procptr = 0;
}
void
refclock_transmit(
struct peer *peer
)
{
struct refclockproc *pp;
u_char clktype;
int unit;
int hpoll;
pp = peer->procptr;
clktype = peer->refclktype;
unit = peer->refclkunit;
peer->sent++;
hpoll = peer->hpoll;
if (peer->burst == 0) {
u_char oreach;
#ifdef DEBUG
if (debug)
printf("refclock_transmit: at %ld %s\n",
current_time, ntoa(&(peer->srcadr)));
#endif
oreach = peer->reach;
if (oreach & 0x01)
peer->valid++;
if (oreach & 0x80)
peer->valid--;
peer->reach <<= 1;
if (peer->reach == 0) {
if (oreach != 0) {
report_event(EVNT_UNREACH, peer);
peer->timereachable = current_time;
peer_clear(peer);
}
} else {
if ((oreach & 0x03) == 0) {
clock_filter(peer, 0., 0., MAXDISPERSE);
clock_select();
}
if (peer->valid <= 2) {
hpoll--;
} else if (peer->valid > NTP_SHIFT - 2)
hpoll++;
if (peer->flags & FLAG_BURST)
peer->burst = pp->nstages;
}
peer->outdate = current_time;
}
get_systime(&peer->xmt);
if (refclock_conf[clktype]->clock_poll != noentry)
(refclock_conf[clktype]->clock_poll)(unit, peer);
if (peer->burst > 0)
peer->burst--;
poll_update(peer, hpoll);
}
#ifdef QSORT_USES_VOID_P
static int
refclock_cmpl_fp(
const void *p1,
const void *p2
)
{
const double *dp1 = (const double *)p1;
const double *dp2 = (const double *)p2;
if (*dp1 < *dp2)
return (-1);
if (*dp1 > *dp2)
return (1);
return (0);
}
#else
static int
refclock_cmpl_fp(
const double *dp1,
const double *dp2
)
{
if (*dp1 < *dp2)
return (-1);
if (*dp1 > *dp2)
return (1);
return (0);
}
#endif
int
refclock_process_offset(
struct refclockproc *pp,
l_fp offset,
l_fp lastrec,
double fudge
)
{
double doffset;
pp->lastref = offset;
pp->lastrec = lastrec;
pp->variance = 0;
L_SUB(&offset, &lastrec);
LFPTOD(&offset, doffset);
pp->filter[pp->coderecv++ % pp->nstages] = doffset + fudge;
return (1);
}
int
refclock_process(
struct refclockproc *pp
)
{
l_fp offset;
if (!clocktime(pp->day, pp->hour, pp->minute, pp->second, GMT,
pp->lastrec.l_ui, &pp->yearstart, &offset.l_ui))
return (0);
if (pp->usec) {
TVUTOTSF(pp->usec, offset.l_uf);
} else {
MSUTOTSF(pp->msec, offset.l_uf);
}
return refclock_process_offset(pp, offset, pp->lastrec, pp->fudgetime1);
}
void
refclock_sample(
struct refclockproc *pp
)
{
int i, j, k;
double offset, disp;
double off[MAXSTAGE];
for (j = 0; j < pp->nstages && (u_int)j < pp->coderecv; j++)
off[j] = pp->filter[j];
qsort((char *)off, (u_int)j, sizeof(double), refclock_cmpl_fp);
i = 0;
k = j;
if (k > pp->nskeep)
k = pp->nskeep;
while ((j - i) > k) {
offset = off[(j + i) / 2];
if (off[j - 1] - offset < offset - off[i])
i++;
else
j--;
}
offset = disp = 0;
for (; i < j; i++) {
offset += off[i];
disp += SQUARE(off[i]);
}
offset /= k;
pp->offset = offset;
pp->variance += disp / k - SQUARE(offset);
#ifdef DEBUG
if (debug)
printf(
"refclock_sample: offset %.6f disp %.6f std %.6f\n",
pp->offset, pp->disp, SQRT(pp->variance));
#endif
}
void
refclock_receive(
struct peer *peer
)
{
struct refclockproc *pp;
#ifdef DEBUG
if (debug)
printf("refclock_receive: at %lu %s\n",
current_time, ntoa(&peer->srcadr));
#endif
peer->received++;
pp = peer->procptr;
peer->processed++;
peer->timereceived = current_time;
peer->leap = pp->leap;
if (peer->leap == LEAP_NOTINSYNC) {
refclock_report(peer, CEVNT_FAULT);
return;
}
if (peer->reach == 0)
report_event(EVNT_REACH, peer);
peer->reach |= 1;
peer->reftime = peer->org = pp->lastrec;
peer->rootdispersion = pp->disp + SQRT(pp->variance);
get_systime(&peer->rec);
refclock_sample(pp);
clock_filter(peer, pp->offset, 0., 0.);
clock_select();
record_peer_stats(&peer->srcadr, ctlpeerstatus(peer),
peer->offset, peer->delay, CLOCK_PHI * (current_time -
peer->epoch), SQRT(peer->variance));
}
int
refclock_gtlin(
struct recvbuf *rbufp,
char *lineptr,
int bmax,
l_fp *tsptr
)
{
char *dpt, *dpend, *dp;
int i;
l_fp trtmp, tstmp;
char c;
#ifdef TIOCDCDTIMESTAMP
struct timeval dcd_time;
#endif
#ifdef HAVE_PPSAPI
pps_info_t pi;
struct timespec *tsp;
double a;
#endif
dpt = (char *)&rbufp->recv_space;
dpend = dpt + rbufp->recv_length;
trtmp = rbufp->recv_time;
#ifdef HAVE_PPSAPI
if ((rbufp->fd == fdpps) && (time_pps_fetch(fdpps, &pi) >= 0)) {
if(pps_assert)
tsp = &pi.assert_timestamp;
else
tsp = &pi.clear_timestamp;
a = tsp->tv_nsec;
a /= 1e9;
tstmp.l_uf = a * 4294967296.0;
tstmp.l_ui = tsp->tv_sec;
tstmp.l_ui += JAN_1970;
L_SUB(&trtmp, &tstmp);
if (trtmp.l_ui == 0) {
#ifdef DEBUG
if (debug > 1) {
printf(
"refclock_gtlin: fd %d time_pps_fetch %s",
fdpps, lfptoa(&tstmp, 6));
printf(" sigio %s\n", lfptoa(&trtmp, 6));
}
#endif
trtmp = tstmp;
goto gotit;
} else
trtmp = rbufp->recv_time;
}
#endif
#ifdef TIOCDCDTIMESTAMP
if(ioctl(rbufp->fd, TIOCDCDTIMESTAMP, &dcd_time) != -1) {
TVTOTS(&dcd_time, &tstmp);
tstmp.l_ui += JAN_1970;
L_SUB(&trtmp, &tstmp);
if (trtmp.l_ui == 0) {
#ifdef DEBUG
if (debug > 1) {
printf(
"refclock_gtlin: fd %d DCDTIMESTAMP %s",
rbufp->fd, lfptoa(&tstmp, 6));
printf(" sigio %s\n", lfptoa(&trtmp, 6));
}
#endif
trtmp = tstmp;
goto gotit;
} else
trtmp = rbufp->recv_time;
}
else
#endif
if (dpend >= dpt + 8) {
if (buftvtots(dpend - 8, &tstmp)) {
L_SUB(&trtmp, &tstmp);
if (trtmp.l_ui == 0) {
#ifdef DEBUG
if (debug > 1) {
printf(
"refclock_gtlin: fd %d ldisc %s",
rbufp->fd, lfptoa(&trtmp, 6));
get_systime(&trtmp);
L_SUB(&trtmp, &tstmp);
printf(" sigio %s\n", lfptoa(&trtmp, 6));
}
#endif
dpend -= 8;
trtmp = tstmp;
} else
trtmp = rbufp->recv_time;
}
}
#if defined(HAVE_PPSAPI) || defined(TIOCDCDTIMESTAMP)
gotit:
#endif
if (dpend - dpt > bmax - 1)
dpend = dpt + bmax - 1;
for (dp = lineptr; dpt < dpend; dpt++) {
c = *dpt & 0x7f;
if (c >= ' ')
*dp++ = c;
}
i = dp - lineptr;
if (i > 0)
*dp = '\0';
#ifdef DEBUG
if (debug > 1 && i > 0)
printf("refclock_gtlin: fd %d time %s timecode %d %s\n",
rbufp->fd, ulfptoa(&trtmp, 6), i, lineptr);
#endif
*tsptr = trtmp;
return (i);
}
#ifndef SYS_VXWORKS
#if defined(HAVE_TERMIOS) || defined(HAVE_SYSV_TTYS) || defined(HAVE_BSD_TTYS)
int
refclock_open(
char *dev,
int speed,
int flags
)
{
int fd, i;
#ifdef HAVE_TERMIOS
struct termios ttyb, *ttyp;
#endif
#ifdef HAVE_SYSV_TTYS
struct termio ttyb, *ttyp;
#endif
#ifdef HAVE_BSD_TTYS
struct sgttyb ttyb, *ttyp;
#endif
#ifdef TIOCMGET
u_long ltemp;
#endif
#ifdef O_NONBLOCK
fd = open(dev, O_RDWR | O_NONBLOCK, 0777);
#else
fd = open(dev, O_RDWR, 0777);
#endif
if (fd == -1) {
msyslog(LOG_ERR, "refclock_open: %s: %m", dev);
return (0);
}
ttyp = &ttyb;
#ifdef HAVE_TERMIOS
if (tcgetattr(fd, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_open: fd %d tcgetattr %m", fd);
return (0);
}
ttyp->c_iflag = IGNBRK | IGNPAR | ICRNL;
ttyp->c_oflag = 0;
ttyp->c_cflag = CS8 | CLOCAL | CREAD;
(void)cfsetispeed(&ttyb, (u_int)speed);
(void)cfsetospeed(&ttyb, (u_int)speed);
ttyp->c_lflag = ICANON;
for (i = 0; i < NCCS; ++i)
{
ttyp->c_cc[i] = '\0';
}
if (flags & LDISC_RAW) {
ttyp->c_iflag = 0;
ttyp->c_lflag = 0;
ttyp->c_cc[VMIN] = 1;
}
#ifdef TIOCMGET
ltemp = 0;
if (ioctl(fd, TIOCMGET, (char *)<emp) < 0)
msyslog(LOG_ERR,
"refclock_open: fd %d TIOCMGET failed: %m", fd);
#ifdef DEBUG
if (debug)
printf("refclock_open: fd %d modem status %lx\n",
fd, ltemp);
#endif
if (ltemp & TIOCM_DSR)
ttyp->c_cflag &= ~CLOCAL;
#endif
if (tcsetattr(fd, TCSANOW, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_open: fd %d TCSANOW failed: %m", fd);
return (0);
}
if (tcflush(fd, TCIOFLUSH) < 0) {
msyslog(LOG_ERR,
"refclock_open: fd %d TCIOFLUSH failed: %m", fd);
return (0);
}
#endif
#ifdef HAVE_SYSV_TTYS
if (ioctl(fd, TCGETA, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_open: fd %d TCGETA failed: %m", fd);
return (0);
}
ttyp->c_iflag = IGNBRK | IGNPAR | ICRNL;
ttyp->c_oflag = 0;
ttyp->c_cflag = speed | CS8 | CLOCAL | CREAD;
ttyp->c_lflag = ICANON;
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\0';
if (flags & LDISC_RAW) {
ttyp->c_iflag = 0;
ttyp->c_lflag = 0;
}
#ifdef TIOCMGET
ltemp = 0;
if (ioctl(fd, TIOCMGET, (char *)<emp) < 0)
msyslog(LOG_ERR,
"refclock_open: fd %d TIOCMGET failed: %m", fd);
#ifdef DEBUG
if (debug)
printf("refclock_open: fd %d modem status %lx\n",
fd, ltemp);
#endif
if (ltemp & TIOCM_DSR)
ttyp->c_cflag &= ~CLOCAL;
#endif
if (ioctl(fd, TCSETA, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_open: fd %d TCSETA failed: %m", fd);
return (0);
}
#endif
#ifdef HAVE_BSD_TTYS
if (ioctl(fd, TIOCGETP, (char *)ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_open: fd %d TIOCGETP %m", fd);
return (0);
}
ttyp->sg_ispeed = ttyp->sg_ospeed = speed;
ttyp->sg_flags = EVENP | ODDP | CRMOD;
if (ioctl(fd, TIOCSETP, (char *)ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_open: TIOCSETP failed: %m");
return (0);
}
#endif
if (!refclock_ioctl(fd, flags)) {
(void)close(fd);
msyslog(LOG_ERR,
"refclock_open: fd %d ioctl fails", fd);
return (0);
}
if (strcmp(dev, pps_device) == 0)
(void)refclock_ioctl(fd, LDISC_PPS);
return (fd);
}
#endif
#endif
int
refclock_ioctl(
int fd,
int flags
)
{
#ifndef SYS_VXWORKS
#if defined(HAVE_TERMIOS) || defined(HAVE_SYSV_TTYS) || defined(HAVE_BSD_TTYS)
#ifdef HAVE_TERMIOS
struct termios ttyb, *ttyp;
#endif
#ifdef HAVE_SYSV_TTYS
struct termio ttyb, *ttyp;
#endif
#ifdef HAVE_BSD_TTYS
struct sgttyb ttyb, *ttyp;
#endif
#ifdef DEBUG
if (debug)
printf("refclock_ioctl: fd %d flags %x\n", fd, flags);
#endif
if (flags == 0)
return (1);
#if !(defined(HAVE_TERMIOS) || defined(HAVE_BSD_TTYS))
if (flags & (LDISC_CLK | LDISC_PPS | LDISC_ACTS)) {
msyslog(LOG_ERR,
"refclock_ioctl: unsupported terminal interface");
return (0);
}
#endif
ttyp = &ttyb;
#ifdef STREAM
#ifdef TTYCLK
if (flags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS)) {
if (ioctl(fd, I_PUSH, "clk") < 0) {
msyslog(LOG_NOTICE,
"refclock_ioctl: I_PUSH clk failed: %m");
} else {
char *str;
if (flags & LDISC_CLKPPS)
str = "\377";
else if (flags & LDISC_ACTS)
str = "*";
else
str = "\n";
if (ioctl(fd, CLK_SETSTR, str) < 0)
msyslog(LOG_ERR,
"refclock_ioctl: CLK_SETSTR failed: %m");
}
}
if (flags & LDISC_ACTS) {
(void)tcgetattr(fd, ttyp);
ttyp->c_cc[VEOL] = '*';
(void)tcsetattr(fd, TCSANOW, ttyp);
}
#endif
#ifdef PPS
if (flags & LDISC_PPS) {
int one = 1;
if (fdpps > 0) {
msyslog(LOG_ERR,
"refclock_ioctl: ppsclock already configured");
return (0);
}
#ifdef HAVE_TIOCSPPS
if ((ioctl(fd, TIOCSPPS, &one) < 0)) {
msyslog(LOG_NOTICE,
"refclock_ioctl: TIOCSPPS failed: %m");
}
#else
if ((ioctl(fd, I_PUSH, "ppsclock") < 0)) {
msyslog(LOG_NOTICE,
"refclock_ioctl: I_PUSH ppsclock failed: %m");
}
#endif
else {
fdpps = fd;
}
}
#else
if (flags & LDISC_PPS)
msyslog(LOG_NOTICE,
"refclock_ioctl: ppsclock line discipline requested but unavailable");
#endif
#else
#ifdef HAVE_TERMIOS
#ifdef TTYCLK
if (flags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS)) {
(void)tcgetattr(fd, ttyp);
ttyp->c_lflag = 0;
if (flags & LDISC_CLKPPS)
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\377';
else if (flags & LDISC_ACTS) {
ttyp->c_cc[VERASE] = '*';
ttyp->c_cc[VKILL] = '#';
} else
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\n';
ttyp->c_line = CLKLDISC;
(void)tcsetattr(fd, TCSANOW, ttyp);
(void)tcflush(fd, TCIOFLUSH);
}
#endif
#ifdef HAVE_PPSAPI
if (flags & LDISC_PPS) {
pps_params_t pp;
int mode;
if (fdpps > 0) {
msyslog(LOG_ERR,
"refclock_ioctl: ppsclock already configured");
return (0);
}
if (time_pps_create(fd, &fdpps) < 0) {
msyslog(LOG_ERR,
"refclock_ioctl: time_pps_create failed");
fdpps = 0;
return (0);
}
if (time_pps_getcap(fdpps, &mode) < 0) {
msyslog(LOG_ERR,
"refclock_ioctl: time_pps_getcap failed");
fdpps = 0;
return (0);
}
if(pps_assert)
pp.mode = PPS_CAPTUREASSERT;
else
pp.mode = PPS_CAPTURECLEAR;
if(pps_hardpps) {
if(pps_assert)
pp.mode |= PPS_HARDPPSONASSERT;
else
pp.mode |= PPS_HARDPPSONCLEAR;
}
if (time_pps_setparams(fdpps, &pp) < 0) {
msyslog(LOG_ERR,
"refclock_ioctl: time_pps_setparams failed");
fdpps = 0;
return (0);
}
}
#endif
#endif
#ifdef HAVE_BSD_TTYS
#ifdef TTYCLK
if (flags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS)) {
int ldisc = CLKLDISC;
(void)ioctl(fd, TIOCGETP, (char *)ttyp);
if (flags & LDISC_CLKPPS)
ttyp->sg_erase = ttyp->sg_kill = '\377';
else if (flags & LDISC_ACTS) {
ttyp->sg_erase = '*';
ttyp->sg_kill = '#';
} else
ttyp->sg_erase = ttyp->sg_kill = '\r';
ttyp->sg_flags = RAW;
(void)ioctl(fd, TIOCSETP, ttyp);
ioctl(fd, TIOCSETD, (char *)&ldisc);
}
#endif
#endif
#endif
#endif
#endif
return (1);
}
void
refclock_control(
struct sockaddr_in *srcadr,
struct refclockstat *in,
struct refclockstat *out
)
{
struct peer *peer;
struct refclockproc *pp;
u_char clktype;
int unit;
if (!ISREFCLOCKADR(srcadr))
return;
clktype = (u_char)REFCLOCKTYPE(srcadr);
unit = REFCLOCKUNIT(srcadr);
if (clktype >= num_refclock_conf || unit > MAXUNIT)
return;
if (!(peer = typeunit[clktype][unit]))
return;
pp = peer->procptr;
if (in != 0) {
if (in->haveflags & CLK_HAVETIME1)
pp->fudgetime1 = in->fudgetime1;
if (in->haveflags & CLK_HAVETIME2)
pp->fudgetime2 = in->fudgetime2;
if (in->haveflags & CLK_HAVEVAL1)
peer->stratum = (u_char) in->fudgeval1;
if (in->haveflags & CLK_HAVEVAL2)
pp->refid = in->fudgeval2;
if (peer->stratum <= 1)
peer->refid = pp->refid;
else
peer->refid = peer->srcadr.sin_addr.s_addr;
if (in->haveflags & CLK_HAVEFLAG1) {
pp->sloppyclockflag &= ~CLK_FLAG1;
pp->sloppyclockflag |= in->flags & CLK_FLAG1;
}
if (in->haveflags & CLK_HAVEFLAG2) {
pp->sloppyclockflag &= ~CLK_FLAG2;
pp->sloppyclockflag |= in->flags & CLK_FLAG2;
}
if (in->haveflags & CLK_HAVEFLAG3) {
pp->sloppyclockflag &= ~CLK_FLAG3;
pp->sloppyclockflag |= in->flags & CLK_FLAG3;
}
if (in->haveflags & CLK_HAVEFLAG4) {
pp->sloppyclockflag &= ~CLK_FLAG4;
pp->sloppyclockflag |= in->flags & CLK_FLAG4;
}
}
if (out != 0) {
out->haveflags = CLK_HAVETIME1 | CLK_HAVEVAL1 |
CLK_HAVEVAL2 | CLK_HAVEFLAG4;
out->fudgetime1 = pp->fudgetime1;
out->fudgetime2 = pp->fudgetime2;
out->fudgeval1 = peer->stratum;
out->fudgeval2 = pp->refid;
out->flags = (u_char) pp->sloppyclockflag;
out->timereset = current_time - pp->timestarted;
out->polls = pp->polls;
out->noresponse = pp->noreply;
out->badformat = pp->badformat;
out->baddata = pp->baddata;
out->lastevent = pp->lastevent;
out->currentstatus = pp->currentstatus;
out->type = pp->type;
out->clockdesc = pp->clockdesc;
out->lencode = pp->lencode;
out->p_lastcode = pp->a_lastcode;
}
if (refclock_conf[clktype]->clock_control != noentry)
(refclock_conf[clktype]->clock_control)(unit, in, out, peer);
}
void
refclock_buginfo(
struct sockaddr_in *srcadr,
struct refclockbug *bug
)
{
struct peer *peer;
struct refclockproc *pp;
u_char clktype;
int unit;
int i;
if (!ISREFCLOCKADR(srcadr))
return;
clktype = (u_char) REFCLOCKTYPE(srcadr);
unit = REFCLOCKUNIT(srcadr);
if (clktype >= num_refclock_conf || unit > MAXUNIT)
return;
if (!(peer = typeunit[clktype][unit]))
return;
pp = peer->procptr;
bug->nvalues = 8;
bug->svalues = 0x0000003f;
bug->values[0] = pp->year;
bug->values[1] = pp->day;
bug->values[2] = pp->hour;
bug->values[3] = pp->minute;
bug->values[4] = pp->second;
bug->values[5] = pp->msec;
bug->values[6] = pp->yearstart;
bug->values[7] = pp->coderecv;
bug->ntimes = pp->nstages + 3;
if (bug->ntimes > NCLKBUGTIMES)
bug->ntimes = NCLKBUGTIMES;
bug->stimes = 0xfffffffc;
bug->times[0] = pp->lastref;
bug->times[1] = pp->lastrec;
for (i = 2; i < (int)bug->ntimes; i++)
DTOLFP(pp->filter[i - 2], &bug->times[i]);
if (refclock_conf[clktype]->clock_buginfo != noentry)
(refclock_conf[clktype]->clock_buginfo)(unit, bug, peer);
}
#endif