ntp_control.c

网络时间协议NTP 源码 版本v4.2.0b 该源码用于linux平台下

		while (*cp != '\0')
			cp++;
	} while(i != start);
	ctl_putdata(buffer, (unsigned)(cp - buffer), 0);
}


/*
 * ctl_putsys - output a system variable
 */
static void
ctl_putsys(
	int varid
	)
{
	l_fp tmp;
	char str[256];
#ifdef OPENSSL
	struct cert_info *cp;
	char cbuf[256];
#endif /* OPENSSL */

	switch (varid) {

	case CS_LEAP:
		ctl_putuint(sys_var[CS_LEAP].text, sys_leap);
		break;

	case CS_STRATUM:
		ctl_putuint(sys_var[CS_STRATUM].text, sys_stratum);
		break;

	case CS_PRECISION:
		ctl_putint(sys_var[CS_PRECISION].text, sys_precision);
		break;

	case CS_ROOTDELAY:
		ctl_putdbl(sys_var[CS_ROOTDELAY].text, sys_rootdelay *
		    1e3);
		break;

	case CS_ROOTDISPERSION:
		ctl_putdbl(sys_var[CS_ROOTDISPERSION].text,
		    sys_rootdispersion * 1e3);
		break;

	case CS_REFID:
		if (sys_stratum > 1 && sys_stratum < STRATUM_UNSPEC)
			ctl_putadr(sys_var[CS_REFID].text, sys_refid, NULL);
		else
			ctl_putid(sys_var[CS_REFID].text,
			    (char *)&sys_refid);
		break;

	case CS_REFTIME:
		ctl_putts(sys_var[CS_REFTIME].text, &sys_reftime);
		break;

	case CS_POLL:
		ctl_putuint(sys_var[CS_POLL].text, sys_poll);
		break;

	case CS_PEERID:
		if (sys_peer == NULL)
			ctl_putuint(sys_var[CS_PEERID].text, 0);
		else
			ctl_putuint(sys_var[CS_PEERID].text,
				sys_peer->associd);
		break;

	case CS_STATE:
		ctl_putuint(sys_var[CS_STATE].text, (unsigned)state);
		break;

	case CS_OFFSET:
		ctl_putdbl(sys_var[CS_OFFSET].text, last_offset * 1e3);
		break;

	case CS_DRIFT:
		ctl_putdbl(sys_var[CS_DRIFT].text, drift_comp * 1e6);
		break;

	case CS_JITTER:
		ctl_putdbl(sys_var[CS_JITTER].text, sys_jitter * 1e3);
		break;

	case CS_ERROR:
		ctl_putdbl(sys_var[CS_ERROR].text, clock_jitter * 1e3);
		break;

	case CS_CLOCK:
		get_systime(&tmp);
		ctl_putts(sys_var[CS_CLOCK].text, &tmp);
		break;

	case CS_PROCESSOR:
#ifndef HAVE_UNAME
		ctl_putstr(sys_var[CS_PROCESSOR].text, str_processor,
		    sizeof(str_processor) - 1);
#else
		ctl_putstr(sys_var[CS_PROCESSOR].text,
		    utsnamebuf.machine, strlen(utsnamebuf.machine));
#endif /* HAVE_UNAME */
		break;

	case CS_SYSTEM:
#ifndef HAVE_UNAME
		ctl_putstr(sys_var[CS_SYSTEM].text, str_system,
		    sizeof(str_system) - 1);
#else
		sprintf(str, "%s/%s", utsnamebuf.sysname, utsnamebuf.release);
		ctl_putstr(sys_var[CS_SYSTEM].text, str, strlen(str));
#endif /* HAVE_UNAME */
		break;

	case CS_VERSION:
		ctl_putstr(sys_var[CS_VERSION].text, Version,
		    strlen(Version));
		break;

	case CS_STABIL:
		ctl_putdbl(sys_var[CS_STABIL].text, clock_stability *
		    1e6);
		break;

	case CS_VARLIST:
		{
			char buf[CTL_MAX_DATA_LEN];
			register char *s, *t, *be;
			register const char *ss;
			register int i;
			register struct ctl_var *k;

			s = buf;
			be = buf + sizeof(buf) -
			    strlen(sys_var[CS_VARLIST].text) - 4;
			if (s > be)
				break;	/* really long var name */

			strcpy(s, sys_var[CS_VARLIST].text);
			strcat(s, "=\"");
			s += strlen(s);
			t = s;
			for (k = sys_var; !(k->flags &EOV); k++) {
				if (k->flags & PADDING)
					continue;
				i = strlen(k->text);
				if (s+i+1 >= be)
				break;

				if (s != t)
				*s++ = ',';
				strcpy(s, k->text);
				s += i;
			}

			for (k = ext_sys_var; k && !(k->flags &EOV);
			    k++) {
				if (k->flags & PADDING)
					continue;

				ss = k->text;
				if (!ss)
					continue;

				while (*ss && *ss != '=')
					ss++;
				i = ss - k->text;
				if (s + i + 1 >= be)
					break;

				if (s != t)
				*s++ = ',';
				strncpy(s, k->text,
				    (unsigned)i);
				s += i;
			}
			if (s+2 >= be)
				break;

			*s++ = '"';
			*s = '\0';

			ctl_putdata(buf, (unsigned)( s - buf ),
			    0);
		}
		break;

#ifdef OPENSSL
	case CS_FLAGS:
		if (crypto_flags) {
			ctl_puthex(sys_var[CS_FLAGS].text, crypto_flags);
		}
		break;

	case CS_DIGEST:
		if (crypto_flags) {
			const EVP_MD *dp;

			dp = EVP_get_digestbynid(crypto_flags >> 16);
			strcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)));
			ctl_putstr(sys_var[CS_DIGEST].text, str,
			    strlen(str));
		}
		break;

	case CS_HOST:
		if (sys_hostname != NULL)
			ctl_putstr(sys_var[CS_HOST].text, sys_hostname,
			    strlen(sys_hostname));
		break;

	case CS_CERTIF:
		for (cp = cinfo; cp != NULL; cp = cp->link) {
			sprintf(cbuf, "%s %s 0x%x", cp->subject,
			    cp->issuer, cp->flags);
			ctl_putstr(sys_var[CS_CERTIF].text, cbuf,
			    strlen(cbuf));
			ctl_putfs(sys_var[CS_REVOKE].text, cp->last);
		}
		break;

	case CS_PUBLIC:
		if (hostval.fstamp != 0)
			ctl_putfs(sys_var[CS_PUBLIC].text,
			    ntohl(hostval.tstamp));
		break;

	case CS_REVTIME:
		if (hostval.tstamp != 0)
			ctl_putfs(sys_var[CS_REVTIME].text,
			    ntohl(hostval.tstamp));
		break;

	case CS_IDENT:
		if (iffpar_pkey != NULL)
			ctl_putstr(sys_var[CS_IDENT].text,
			    iffpar_file, strlen(iffpar_file));
		if (gqpar_pkey != NULL)
			ctl_putstr(sys_var[CS_IDENT].text,
			    gqpar_file, strlen(gqpar_file));
		if (mvpar_pkey != NULL)
			ctl_putstr(sys_var[CS_IDENT].text,
			    mvpar_file, strlen(mvpar_file));
		break;

	case CS_LEAPTAB:
		if (tai_leap.fstamp != 0)
			ctl_putfs(sys_var[CS_LEAPTAB].text,
			    ntohl(tai_leap.fstamp));
		break;

	case CS_TAI:
		ctl_putuint(sys_var[CS_TAI].text, sys_tai);
		break;
#endif /* OPENSSL */
	}
}


/*
 * ctl_putpeer - output a peer variable
 */
static void
ctl_putpeer(
	int varid,
	struct peer *peer
	)
{
	int temp;
#ifdef OPENSSL
	char str[256];
	struct autokey *ap;
#endif /* OPENSSL */

	switch (varid) {

	case CP_CONFIG:
		ctl_putuint(peer_var[CP_CONFIG].text,
		    (unsigned)((peer->flags & FLAG_CONFIG) != 0));
		break;

	case CP_AUTHENABLE:
		ctl_putuint(peer_var[CP_AUTHENABLE].text,
		    (unsigned)((peer->flags & FLAG_AUTHENABLE) != 0));
		break;

	case CP_AUTHENTIC:
		ctl_putuint(peer_var[CP_AUTHENTIC].text,
		    (unsigned)((peer->flags & FLAG_AUTHENTIC) != 0));
		break;

	case CP_SRCADR:
		ctl_putadr(peer_var[CP_SRCADR].text, 0,
		    &peer->srcadr);
		break;

	case CP_SRCPORT:
		ctl_putuint(peer_var[CP_SRCPORT].text,
		    ntohs(((struct sockaddr_in*)&peer->srcadr)->sin_port));
		break;

	case CP_DSTADR:
		ctl_putadr(peer_var[CP_DSTADR].text, 0,
		    &(peer->dstadr->sin));
		break;

	case CP_DSTPORT:
		ctl_putuint(peer_var[CP_DSTPORT].text,
		    (u_long)(peer->dstadr ?
		    ntohs(((struct sockaddr_in*)&peer->dstadr->sin)->sin_port) : 0));
		break;

	case CP_LEAP:
		ctl_putuint(peer_var[CP_LEAP].text, peer->leap);
		break;

	case CP_HMODE:
		ctl_putuint(peer_var[CP_HMODE].text, peer->hmode);
		break;

	case CP_STRATUM:
		ctl_putuint(peer_var[CP_STRATUM].text, peer->stratum);
		break;

	case CP_PPOLL:
		ctl_putuint(peer_var[CP_PPOLL].text, peer->ppoll);
		break;

	case CP_HPOLL:
		ctl_putuint(peer_var[CP_HPOLL].text, peer->hpoll);
		break;

	case CP_PRECISION:
		ctl_putint(peer_var[CP_PRECISION].text,
		    peer->precision);
		break;

	case CP_ROOTDELAY:
		ctl_putdbl(peer_var[CP_ROOTDELAY].text,
		    peer->rootdelay * 1e3);
		break;

	case CP_ROOTDISPERSION:
		ctl_putdbl(peer_var[CP_ROOTDISPERSION].text,
		    peer->rootdispersion * 1e3);
		break;

	case CP_REFID:
		if (peer->flags & FLAG_REFCLOCK) {
			ctl_putid(peer_var[CP_REFID].text,
			   (char *)&peer->refid);
		} else {
			if (peer->stratum > 1 && peer->stratum <
			    STRATUM_UNSPEC)
				ctl_putadr(peer_var[CP_REFID].text,
				    peer->refid, NULL);
			else
				ctl_putid(peer_var[CP_REFID].text,
				    (char *)&peer->refid);
		}
		break;

	case CP_REFTIME:
		ctl_putts(peer_var[CP_REFTIME].text, &peer->reftime);
		break;

	case CP_ORG:
		ctl_putts(peer_var[CP_ORG].text, &peer->org);
		break;

	case CP_REC:
		ctl_putts(peer_var[CP_REC].text, &peer->rec);
		break;

	case CP_XMT:
		ctl_putts(peer_var[CP_XMT].text, &peer->xmt);
		break;

	case CP_REACH:
		ctl_puthex(peer_var[CP_REACH].text, peer->reach);
		break;

	case CP_FLASH:
		temp = peer->flash;
		ctl_puthex(peer_var[CP_FLASH].text, temp);
		break;

	case CP_TTL:
		ctl_putint(peer_var[CP_TTL].text, sys_ttl[peer->ttl]);
		break;

	case CP_UNREACH:
		ctl_putuint(peer_var[CP_UNREACH].text, peer->unreach);
		break;

	case CP_TIMER:
		ctl_putuint(peer_var[CP_TIMER].text,
		    peer->nextdate - current_time);
		break;

	case CP_DELAY:
		ctl_putdbl(peer_var[CP_DELAY].text, peer->delay * 1e3);
		break;

	case CP_OFFSET:
		ctl_putdbl(peer_var[CP_OFFSET].text, peer->offset *
		    1e3);
		break;

	case CP_JITTER:
		ctl_putdbl(peer_var[CP_JITTER].text, peer->jitter * 1e3);
		break;

	case CP_DISPERSION:
		ctl_putdbl(peer_var[CP_DISPERSION].text, peer->disp *
		    1e3);
		break;

	case CP_KEYID:
		ctl_putuint(peer_var[CP_KEYID].text, peer->keyid);
		break;

	case CP_FILTDELAY:
		ctl_putarray(peer_var[CP_FILTDELAY].text,
		    peer->filter_delay, (int)peer->filter_nextpt);
		break;

	case CP_FILTOFFSET:
		ctl_putarray(peer_var[CP_FILTOFFSET].text,
		    peer->filter_offset, (int)peer->filter_nextpt);
		break;

	case CP_FILTERROR:
		ctl_putarray(peer_var[CP_FILTERROR].text,
		    peer->filter_disp, (int)peer->filter_nextpt);
		break;

	case CP_PMODE:
		ctl_putuint(peer_var[CP_PMODE].text, peer->pmode);
		break;

	case CP_RECEIVED:
		ctl_putuint(peer_var[CP_RECEIVED].text, peer->received);
		break;

	case CP_SENT:
		ctl_putuint(peer_var[CP_SENT].text, peer->sent);
		break;

	case CP_VARLIST:
		{
			char buf[CTL_MAX_DATA_LEN];
			register char *s, *t, *be;
			register int i;
			register struct ctl_var *k;

			s = buf;
			be = buf + sizeof(buf) -
			    strlen(peer_var[CP_VARLIST].text) - 4;
			if (s > be)
				break;	/* really long var name */

			strcpy(s, peer_var[CP_VARLIST].text);
			strcat(s, "=\"");
			s += strlen(s);
			t = s;
			for (k = peer_var; !(k->flags &EOV); k++) {
				if (k->flags & PADDING)
					continue;

				i = strlen(k->text);
				if (s + i + 1 >= be)
				break;

				if (s != t)
					*s++ = ',';
				strcpy(s, k->text);
				s += i;
			}
			if (s+2 >= be)
				break;

			*s++ = '"';
			*s = '\0';
			ctl_putdata(buf, (unsigned)(s - buf), 0);
		}
		break;
#ifdef OPENSSL
	case CP_FLAGS:
		if (peer->crypto)
			ctl_puthex(peer_var[CP_FLAGS].text, peer->crypto);
		break;

	case CP_DIGEST:
		if (peer->crypto) {
			const EVP_MD *dp;

			dp = EVP_get_digestbynid(peer->crypto >> 16);
			strcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)));
			ctl_putstr(peer_var[CP_DIGEST].text, str,
       	                     strlen(str));
		}
		break;

	case CP_HOST:
		if (peer->subject != NULL)
			ctl_putstr(peer_var[CP_HOST].text,
			    peer->subject, strlen(peer->subject));
		break;

	case CP_VALID:		/* not used */
		break;

	case CP_IDENT:
		if (peer->issuer != NULL)
			ctl_putstr(peer_var[CP_IDENT].text,
			    peer->issuer, strlen(peer->issuer));
		break;

	case CP_INITSEQ:
		if ((ap = (struct autokey *)peer->recval.ptr) == NULL)
			break;
		ctl_putint(peer_var[CP_INITSEQ].text, ap->seq);
		ctl_puthex(peer_var[CP_INITKEY].text, ap->key);
		ctl_putfs(peer_var[CP_INITTSP].text,
		    ntohl(peer->recval.tstamp));
		break;
#endif /* OPENSSL */
	}
}


#ifdef REFCLOCK
/*
 * ctl_putclock - output clock variables
 */
static void
ctl_putclock(
	int varid,
	struct refclockstat *clock_stat,
	int mustput
	)
{
	switch(varid) {

	case CC_TYPE:
		if (mustput || clock_stat->clockdesc == NULL
			|| *(clock_stat->clockdesc) == '\0') {
			ctl_putuint(clock_var[CC_TYPE].text, clock_stat->type);
		}
		break;
	case CC_TIMECODE:
		ctl_putstr(clock_var[CC_TIMECODE].text,
		    clock_stat->p_lastcode,
		    (unsigned)clock_stat->lencode);
		break;

	case CC_POLL:
		ctl_putuint(clock_var[CC_POLL].text, clock_stat->polls);
		break;

	case CC_NOREPLY:
		ctl_putuint(clock_var[CC_NOREPLY].text,
		    clock_stat->noresponse);
		break;

	case CC_BADFORMAT:
		ctl_putuint(clock_var[CC_BADFORMAT].text,
		    clock_stat->badformat);
		break;

	case CC_BADDATA:
		ctl_putuint(clock_var[CC_BADDATA].text,
		    clock_stat->baddata);
		break;

	case CC_FUDGETIME1:
		if (mustput || (clock_stat->haveflags & CLK_HAVETIME1))
			ctl_putdbl(clock_var[CC_FUDGETIME1].text,
			    clock_stat->fudgetime1 * 1e3);
		break;

	case CC_FUDGETIME2:
		if (mustput || (clock_stat->haveflags & CLK_HAVETIME2)) 			ctl_putdbl(clock_var[CC_FUDGETIME2].text,
			    clock_stat->fudgetime2 * 1e3);
		break;

	case CC_FUDGEVAL1:
		if (mustput || (clock_stat->haveflags & CLK_HAVEVAL1))
			ctl_putint(clock_var[CC_FUDGEVAL1].text,
			    clock_stat->fudgeval1);
		break;

	case CC_FUDGEVAL2:
		if (mustput || (clock_stat->haveflags & CLK_HAVEVAL2)) {
			if (clock_stat->fudgeval1 > 1)
				ctl_putadr(clock_var[CC_FUDGEVAL2].text,