mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-17 10:26:15 +00:00
Code Issues Releases Activity
241a5629e6
freebsd/usr.sbin/xntpd/ntpq/ntpq_ops.c
Rodney W. Grimes 709e8f9ae1 Remove trailing whitespace.
1995-05-30 03:57:47 +00:00

1611 lines
33 KiB
C
Raw Blame History

/*
* ntpdc_ops.c - subroutines which are called to perform operations by xntpdc
*/
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/time.h>
#include <netdb.h>
#include "ntpq.h"
#include "ntp_stdlib.h"
extern char * chosts[];
extern char currenthost[];
extern int numhosts;
int maxhostlen;
/*
* Declarations for command handlers in here
*/
static int checkassocid P((u_long));
static char * strsave P((char *));
static struct varlist *findlistvar P((struct varlist *, char *));
static void doaddvlist P((struct varlist *, char *));
static void dormvlist P((struct varlist *, char *));
static void doclearvlist P((struct varlist *));
static void makequerydata P((struct varlist *, int *, char *));
static int doquerylist P((struct varlist *, int, int, int, u_short *, int *, char **));
static void doprintvlist P((struct varlist *, FILE *));
static void addvars P((struct parse *, FILE *));
static void rmvars P((struct parse *, FILE *));
static void clearvars P((struct parse *, FILE *));
static void showvars P((struct parse *, FILE *));
static int dolist P((struct varlist *, int, int, int, FILE *));
static void readlist P((struct parse *, FILE *));
static void writelist P((struct parse *, FILE *));
static void readvar P((struct parse *, FILE *));
static void writevar P((struct parse *, FILE *));
static void clocklist P((struct parse *, FILE *));
static void clockvar P((struct parse *, FILE *));
static int findassidrange P((u_long, u_long, int *, int *));
static void mreadlist P((struct parse *, FILE *));
static void mreadvar P((struct parse *, FILE *));
static int dogetassoc P((FILE *));
static void printassoc P((int, FILE *));
static void associations P((struct parse *, FILE *));
static void lassociations P((struct parse *, FILE *));
static void passociations P((struct parse *, FILE *));
static void lpassociations P((struct parse *, FILE *));
#ifdef UNUSED
static void radiostatus P((struct parse *, FILE *));
#endif /* UNUSED */
static void pstatus P((struct parse *, FILE *));
static char * fixup P((int, char *));
static char * when P((l_fp *, l_fp *, l_fp *));
static int doprintpeers P((struct varlist *, int, int, int, char *, FILE *));
static int dogetpeers P((struct varlist *, int, FILE *));
static void dopeers P((int, FILE *));
static void peers P((struct parse *, FILE *));
static void lpeers P((struct parse *, FILE *));
static void doopeers P((int, FILE *));
static void opeers P((struct parse *, FILE *));
static void lopeers P((struct parse *, FILE *));
/*
* Commands we understand. Ntpdc imports this.
*/
struct xcmd opcmds[] = {
{ "associations", associations, { NO, NO, NO, NO },
{ "", "", "", "" },
"print list of association ID's and statuses for the server's peers" },
{ "passociations", passociations, { NO, NO, NO, NO },
{ "", "", "", "" },
"print list of associations returned by last associations command" },
{ "lassociations", lassociations, { NO, NO, NO, NO },
{ "", "", "", "" },
"print list of associations including all client information" },
{ "lpassociations", lpassociations, { NO, NO, NO, NO },
{ "", "", "", "" },
"print last obtained list of associations, including client information" },
{ "addvars", addvars, { STR, NO, NO, NO },
{ "name[=value][,...]", "", "", "" },
"add variables to the variable list or change their values" },
{ "rmvars", rmvars, { STR, NO, NO, NO },
{ "name[,...]", "", "", "" },
"remove variables from the variable list" },
{ "clearvars", clearvars, { NO, NO, NO, NO },
{ "", "", "", "" },
"remove all variables from the variable list" },
{ "showvars", showvars, { NO, NO, NO, NO },
{ "", "", "", "" },
"print variables on the variable list" },
{ "readlist", readlist, { OPT|UINT, NO, NO, NO },
{ "assocID", "", "", "" },
"read the system or peer variables included in the variable list" },
{ "rl", readlist, { OPT|UINT, NO, NO, NO },
{ "assocID", "", "", "" },
"read the system or peer variables included in the variable list" },
{ "writelist", writelist, { OPT|UINT, NO, NO, NO },
{ "assocID", "", "", "" },
"write the system or peer variables included in the variable list" },
{ "readvar", readvar, { OPT|UINT, OPT|STR, NO, NO },
{ "assocID", "name=value[,...]", "", "" },
"read system or peer variables" },
{ "rv", readvar, { OPT|UINT, OPT|STR, NO, NO },
{ "assocID", "name=value[,...]", "", "" },
"read system or peer variables" },
{ "writevar", writevar, { UINT, STR, NO, NO },
{ "assocID", "name=value,[...]", "", "" },
"write system or peer variables" },
{ "mreadlist", mreadlist, { UINT, UINT, NO, NO },
{ "assocID", "assocID", "", "" },
"read the peer variables in the variable list for multiple peers" },
{ "mrl", mreadlist, { UINT, UINT, NO, NO },
{ "assocID", "assocID", "", "" },
"read the peer variables in the variable list for multiple peers" },
{ "mreadvar", mreadvar, { UINT, UINT, OPT|STR, NO },
{ "assocID", "assocID", "name=value[,...]", "" },
"read peer variables from multiple peers" },
{ "mrv", mreadvar, { UINT, UINT, OPT|STR, NO },
{ "assocID", "assocID", "name=value[,...]", "" },
"read peer variables from multiple peers" },
{ "clocklist", clocklist, { OPT|UINT, NO, NO, NO },
{ "assocID", "", "", "" },
"read the clock variables included in the variable list" },
{ "cl", clocklist, { OPT|UINT, NO, NO, NO },
{ "assocID", "", "", "" },
"read the clock variables included in the variable list" },
{ "clockvar", clockvar, { OPT|UINT, OPT|STR, NO, NO },
{ "assocID", "name=value[,...]", "", "" },
"read clock variables" },
{ "cv", clockvar, { OPT|UINT, OPT|STR, NO, NO },
{ "assocID", "name=value[,...]", "", "" },
"read clock variables" },
{ "pstatus", pstatus, { UINT, NO, NO, NO },
{ "assocID", "", "", "" },
"print status information returned for a peer" },
{ "peers", peers, { NO, NO, NO, NO },
{ "", "", "", "" },
"obtain and print a list of the server's peers" },
{ "lpeers", lpeers, { NO, NO, NO, NO },
{ "", "", "", "" },
"obtain and print a list of all peers and clients" },
{ "opeers", opeers, { NO, NO, NO, NO },
{ "", "", "", "" },
"print peer list the old way, with dstadr shown rather than refid" },
{ "lopeers", lopeers, { NO, NO, NO, NO },
{ "", "", "", "" },
"obtain and print a list of all peers and clients showing dstadr" },
{ 0, 0, { NO, NO, NO, NO },
{ "", "", "", "" }, "" }
};
/*
* Variable list data space
*/
#define MAXLIST 64 /* maximum number of variables in list */
#define LENHOSTNAME 256 /* host name is 256 characters long */
/*
* Old CTL_PST defines for version 2.
*/
#define OLD_CTL_PST_CONFIG 0x80
#define OLD_CTL_PST_AUTHENABLE 0x40
#define OLD_CTL_PST_AUTHENTIC 0x20
#define OLD_CTL_PST_REACH 0x10
#define OLD_CTL_PST_SANE 0x08
#define OLD_CTL_PST_DISP 0x04
#define OLD_CTL_PST_SEL_REJECT 0
#define OLD_CTL_PST_SEL_SELCAND 1
#define OLD_CTL_PST_SEL_SYNCCAND 2
#define OLD_CTL_PST_SEL_SYSPEER 3
char flash2[] = " .+* "; /* flash decode for version 2 */
char flash3[] = " x.-+#*o"; /* flash decode for peer status version 3 */
struct varlist {
char *name;
char *value;
} varlist[MAXLIST] = { { 0, 0 } };
/*
* Imported from ntpq.c
*/
extern int showhostnames;
extern int rawmode;
extern int debug;
extern struct servent *server_entry;
extern struct association assoc_cache[];
extern int numassoc;
extern u_char pktversion;
/*
* For quick string comparisons
*/
#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
/*
* checkassocid - return the association ID, checking to see if it is valid
*/
static int
checkassocid(value)
u_long value;
{
if (value == 0 || value >= 65536) {
(void) fprintf(stderr, "***Invalid association ID specified\n");
return 0;
}
return (int)value;
}
/*
* strsave - save a string
* XXX - should be in libntp.a
*/
static char *
strsave(str)
char *str;
{
char *cp;
u_int len;
len = strlen(str) + 1;
if ((cp = (char *)malloc(len)) == NULL) {
(void) fprintf(stderr, "Malloc failed!!\n");
exit(1);
}
memmove(cp, str, len);
return (cp);
}
/*
* findlistvar - look for the named variable in a list and return if found
*/
static struct varlist *
findlistvar(list, name)
struct varlist *list;
char *name;
{
register struct varlist *vl;
for (vl = list; vl < list + MAXLIST && vl->name != 0; vl++)
if (STREQ(name, vl->name))
return vl;
if (vl < list + MAXLIST)
return vl;
return (struct varlist *)0;
}
/*
* doaddvlist - add variable(s) to the variable list
*/
static void
doaddvlist(vlist, vars)
struct varlist *vlist;
char *vars;
{
register struct varlist *vl;
int len;
char *name;
char *value;
len = strlen(vars);
while (nextvar(&len, &vars, &name, &value)) {
vl = findlistvar(vlist, name);
if (vl == 0) {
(void) fprintf(stderr, "Variable list full\n");
return;
}
if (vl->name == 0) {
vl->name = strsave(name);
} else if (vl->value != 0) {
(void) free(vl->value);
vl->value = 0;
}
if (value != 0)
vl->value = strsave(value);
}
}
/*
* dormvlist - remove variable(s) from the variable list
*/
static void
dormvlist(vlist, vars)
struct varlist *vlist;
char *vars;
{
register struct varlist *vl;
int len;
char *name;
char *value;
len = strlen(vars);
while (nextvar(&len, &vars, &name, &value)) {
vl = findlistvar(vlist, name);
if (vl == 0 || vl->name == 0) {
(void) fprintf(stderr, "Variable `%s' not found\n",
name);
} else {
(void) free(vl->name);
if (vl->value != 0)
(void) free(vl->value);
for ( ; (vl+1) < (varlist+MAXLIST)
&& (vl+1)->name != 0; vl++) {
vl->name = (vl+1)->name;
vl->value = (vl+1)->value;
}
vl->name = vl->value = 0;
}
}
}
/*
* doclearvlist - clear a variable list
*/
static void
doclearvlist(vlist)
struct varlist *vlist;
{
register struct varlist *vl;
for (vl = vlist; vl < vlist + MAXLIST && vl->name != 0; vl++) {
(void) free(vl->name);
vl->name = 0;
if (vl->value != 0) {
(void) free(vl->value);
vl->value = 0;
}
}
}
/*
* makequerydata - form a data buffer to be included with a query
*/
static void
makequerydata(vlist, datalen, data)
struct varlist *vlist;
int *datalen;
char *data;
{
register struct varlist *vl;
register char *cp, *cpend;
register int namelen, valuelen;
register int totallen;
cp = data;
cpend = data + *datalen;
for (vl = vlist; vl < vlist + MAXLIST && vl->name != 0; vl++) {
namelen = strlen(vl->name);
if (vl->value == 0)
valuelen = 0;
else
valuelen = strlen(vl->value);
totallen = namelen + valuelen + (valuelen != 0) + (cp != data);
if (cp + totallen > cpend)
break;
if (cp != data)
*cp++ = ',';
memmove(cp, vl->name, namelen);
cp += namelen;
if (valuelen != 0) {
*cp++ = '=';
memmove(cp, vl->value, valuelen);
cp += valuelen;
}
}
*datalen = cp - data;
}
/*
* doquerylist - send a message including variables in a list
*/
static int
doquerylist(vlist, op, associd, auth, rstatus, dsize, datap)
struct varlist *vlist;
int op;
int associd;
int auth;
u_short *rstatus;
int *dsize;
char **datap;
{
char data[CTL_MAX_DATA_LEN];
int datalen;
datalen = sizeof(data);
makequerydata(vlist, &datalen, data);
return doquery(op, associd, auth, datalen, data, rstatus,
dsize, datap);
}
/*
* doprintvlist - print the variables on a list
*/
static void
doprintvlist(vlist, fp)
struct varlist *vlist;
FILE *fp;
{
register struct varlist *vl;
if (vlist->name == 0) {
(void) fprintf(fp, "No variables on list\n");
} else {
for (vl = vlist; vl < vlist + MAXLIST && vl->name != 0; vl++) {
if (vl->value == 0) {
(void) fprintf(fp, "%s\n", vl->name);
} else {
(void) fprintf(fp, "%s=%s\n",
vl->name, vl->value);
}
}
}
}
/*
* addvars - add variables to the variable list
*/
/*ARGSUSED*/
static void
addvars(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
doaddvlist(varlist, pcmd->argval[0].string);
}
/*
* rmvars - remove variables from the variable list
*/
/*ARGSUSED*/
static void
rmvars(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
dormvlist(varlist, pcmd->argval[0].string);
}
/*
* clearvars - clear the variable list
*/
/*ARGSUSED*/
static void
clearvars(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
doclearvlist(varlist);
}
/*
* showvars - show variables on the variable list
*/
/*ARGSUSED*/
static void
showvars(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
doprintvlist(varlist, fp);
}
/*
* dolist - send a request with the given list of variables
*/
static int
dolist(vlist, associd, op, type, fp)
struct varlist *vlist;
int associd;
int op;
int type;
FILE *fp;
{
char *datap;
int res;
int dsize;
u_short rstatus;
res = doquerylist(vlist, op, associd, 0, &rstatus, &dsize, &datap);
if (res != 0)
return 0;
if (dsize == 0) {
if (associd == 0)
(void) fprintf(fp, "No system%s variables returned\n",
(type == TYPE_CLOCK) ? " clock" : "");
else
(void) fprintf(fp,
"No information returned for%s association %u\n",
(type == TYPE_CLOCK) ? " clock" : "", associd);
return 1;
}
printvars(dsize, datap, (int)rstatus, type, fp);
return 1;
}
/*
* readlist - send a read variables request with the variables on the list
*/
static void
readlist(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
int associd;
if (pcmd->nargs == 0) {
associd = 0;
} else {
if (pcmd->argval[0].uval == 0)
associd = 0;
else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
}
(void) dolist(varlist, associd, CTL_OP_READVAR,
(associd == 0) ? TYPE_SYS : TYPE_PEER, fp);
}
/*
* writelist - send a write variables request with the variables on the list
*/
static void
writelist(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
char *datap;
int res;
int associd;
int dsize;
u_short rstatus;
if (pcmd->nargs == 0) {
associd = 0;
} else {
if (pcmd->argval[0].uval == 0)
associd = 0;
else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
}
res = doquerylist(varlist, CTL_OP_WRITEVAR, associd, 0, &rstatus,
&dsize, &datap);
if (res != 0)
return;
if (dsize == 0)
(void) fprintf(fp, "done! (no data returned)\n");
else
printvars(dsize, datap, (int)rstatus,
(associd != 0) ? TYPE_PEER : TYPE_SYS, fp);
return;
}
/*
* readvar - send a read variables request with the specified variables
*/
static void
readvar(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
int associd;
struct varlist tmplist[MAXLIST];
if (pcmd->nargs == 0 || pcmd->argval[0].uval == 0)
associd = 0;
else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
memset((char *)tmplist, 0, sizeof(tmplist));
if (pcmd->nargs >= 2)
doaddvlist(tmplist, pcmd->argval[1].string);
(void) dolist(tmplist, associd, CTL_OP_READVAR,
(associd == 0) ? TYPE_SYS : TYPE_PEER, fp);
doclearvlist(tmplist);
}
/*
* writevar - send a write variables request with the specified variables
*/
static void
writevar(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
char *datap;
int res;
int associd;
int dsize;
u_short rstatus;
struct varlist tmplist[MAXLIST];
if (pcmd->argval[0].uval == 0)
associd = 0;
else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
memset((char *)tmplist, 0, sizeof(tmplist));
doaddvlist(tmplist, pcmd->argval[1].string);
res = doquerylist(tmplist, CTL_OP_WRITEVAR, associd, 0, &rstatus,
&dsize, &datap);
doclearvlist(tmplist);
if (res != 0)
return;
if (dsize == 0)
(void) fprintf(fp, "done! (no data returned)\n");
else
printvars(dsize, datap, (int)rstatus,
(associd != 0) ? TYPE_PEER : TYPE_SYS, fp);
return;
}
/*
* clocklist - send a clock variables request with the variables on the list
*/
static void
clocklist(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
int associd;
if (pcmd->nargs == 0) {
associd = 0;
} else {
if (pcmd->argval[0].uval == 0)
associd = 0;
else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
}
(void) dolist(varlist, associd, CTL_OP_READCLOCK, TYPE_CLOCK, fp);
}
/*
* clockvar - send a clock variables request with the specified variables
*/
static void
clockvar(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
int associd;
struct varlist tmplist[MAXLIST];
if (pcmd->nargs == 0 || pcmd->argval[0].uval == 0)
associd = 0;
else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
memset((char *)tmplist, 0, sizeof(tmplist));
if (pcmd->nargs >= 2)
doaddvlist(tmplist, pcmd->argval[1].string);
(void) dolist(tmplist, associd, CTL_OP_READCLOCK, TYPE_CLOCK, fp);
doclearvlist(tmplist);
}
/*
* findassidrange - verify a range of association ID's
*/
static int
findassidrange(assid1, assid2, from, to)
u_long assid1;
u_long assid2;
int *from;
int *to;
{
register int i;
int f, t;
if (assid1 == 0 || assid1 > 65535) {
(void) fprintf(stderr,
"***Invalid association ID %lu specified\n", (u_long)assid1);
return 0;
}
if (assid2 == 0 || assid2 > 65535) {
(void) fprintf(stderr,
"***Invalid association ID %lu specified\n", (u_long)assid2);
return 0;
}
f = t = -1;
for (i = 0; i < numassoc; i++) {
if (assoc_cache[i].assid == assid1) {
f = i;
if (t != -1)
break;
}
if (assoc_cache[i].assid == assid2) {
t = i;
if (f != -1)
break;
}
}
if (f == -1 || t == -1) {
(void) fprintf(stderr,
"***Association ID %lu not found in list\n",
(f == -1) ? (u_long)assid1 : (u_long)assid2);
return 0;
}
if (f < t) {
*from = f;
*to = t;
} else {
*from = t;
*to = f;
}
return 1;
}
/*
* mreadlist - send a read variables request for multiple associations
*/
static void
mreadlist(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
int i;
int from;
int to;
if (!findassidrange(pcmd->argval[0].uval, pcmd->argval[1].uval,
&from, &to))
return;
for (i = from; i <= to; i++) {
if (i != from)
(void) fprintf(fp, "\n");
if (!dolist(varlist, (int)assoc_cache[i].assid,
CTL_OP_READVAR, TYPE_PEER, fp))
return;
}
return;
}
/*
* mreadvar - send a read variables request for multiple associations
*/
static void
mreadvar(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
int i;
int from;
int to;
struct varlist tmplist[MAXLIST];
if (!findassidrange(pcmd->argval[0].uval, pcmd->argval[1].uval,
&from, &to))
return;
memset((char *)tmplist, 0, sizeof(tmplist));
if (pcmd->nargs >= 3)
doaddvlist(tmplist, pcmd->argval[2].string);
for (i = from; i <= to; i++) {
if (i != from)
(void) fprintf(fp, "\n");
if (!dolist(varlist, (int)assoc_cache[i].assid,
CTL_OP_READVAR, TYPE_PEER, fp))
break;
}
doclearvlist(tmplist);
return;
}
/*
* dogetassoc - query the host for its list of associations
*/
static int
dogetassoc(fp)
FILE *fp;
{
u_short *datap;
int res;
int dsize;
u_short rstatus;
res = doquery(CTL_OP_READSTAT, 0, 0, 0, (char *)0, &rstatus,
&dsize, (char **)&datap);
if (res != 0)
return 0;
if (dsize == 0) {
(void) fprintf(fp, "No association ID's returned\n");
return 0;
}
if (dsize & 0x3) {
(void) fprintf(stderr,
"***Server returned %d octets, should be multiple of 4\n",
dsize);
return 0;
}
numassoc = 0;
while (dsize > 0) {
assoc_cache[numassoc].assid = ntohs(*datap);
datap++;
assoc_cache[numassoc].status = ntohs(*datap);
datap++;
if (++numassoc >= MAXASSOC)
break;
dsize -= sizeof(u_short) + sizeof(u_short);
}
sortassoc();
return 1;
}
/*
* printassoc - print the current list of associations
*/
static void
printassoc(showall, fp)
int showall;
FILE *fp;
{
register char *bp;
int i;
u_char statval;
int event;
u_long event_count;
char *conf;
char *reach;
char *auth;
char *condition = "";
char *last_event;
char *cnt;
char buf[128];
if (numassoc == 0) {
(void) fprintf(fp, "No association ID's in list\n");
return;
}
/*
* Output a header
*/
(void) fprintf(fp,
"ind assID status conf reach auth condition last_event cnt\n");
(void) fprintf(fp,
"===========================================================\n");
for (i = 0; i < numassoc; i++) {
statval = CTL_PEER_STATVAL(assoc_cache[i].status);
if (!showall && !(statval & (CTL_PST_CONFIG|CTL_PST_REACH)))
continue;
event = CTL_PEER_EVENT(assoc_cache[i].status);
event_count = CTL_PEER_NEVNT(assoc_cache[i].status);
if (statval & CTL_PST_CONFIG)
conf = "yes";
else
conf = "no";
if (statval & CTL_PST_REACH) {
reach = "yes";
if (statval & CTL_PST_AUTHENABLE) {
if (statval & CTL_PST_AUTHENTIC)
auth = "ok ";
else
auth = "bad";
} else
auth = "none";
if (pktversion == NTP_VERSION)
switch (statval & 0x7) {
case CTL_PST_SEL_REJECT:
condition = "insane";
break;
case CTL_PST_SEL_SANE:
condition = "falsetick";
break;
case CTL_PST_SEL_CORRECT:
condition = "eliminate";
break;
case CTL_PST_SEL_SELCAND:
condition = "outlyer";
break;
case CTL_PST_SEL_SYNCCAND:
condition = "synchr.";
break;
case CTL_PST_SEL_DISTSYSPEER:
condition = "dist.peer";
break;
case CTL_PST_SEL_SYSPEER:
condition = "sys.peer";
break;
case CTL_PST_SEL_PPS:
condition = "pps.peer";
break;
}
else
switch (statval & 0x3) {
case OLD_CTL_PST_SEL_REJECT:
if (!(statval & OLD_CTL_PST_SANE))
condition = "insane";
else if (!(statval & OLD_CTL_PST_DISP))
condition = "hi_disp";
else
condition = "";
break;
case OLD_CTL_PST_SEL_SELCAND:
condition = "sel_cand";
break;
case OLD_CTL_PST_SEL_SYNCCAND:
condition = "sync_cand";
break;
case OLD_CTL_PST_SEL_SYSPEER:
condition = "sys.peer";
break;
}
} else {
reach = "no";
auth = condition = "";
}
switch (PEER_EVENT|event) {
case EVNT_PEERIPERR:
last_event = "IP error";
break;
case EVNT_PEERAUTH:
last_event = "auth fail";
break;
case EVNT_UNREACH:
last_event = "lost reach";
break;
case EVNT_REACH:
last_event = "reachable";
break;
case EVNT_PEERCLOCK:
last_event = "clock expt";
break;
#if 0
case EVNT_PEERSTRAT:
last_event = "stratum chg";
break;
#endif
default:
last_event = "";
break;
}
if (event_count != 0)
cnt = uinttoa(event_count);
else
cnt = "";
(void) sprintf(buf,
"%3d %5u %04x %3.3s %4s %4.4s %9.9s %11s %2s",
i+1, assoc_cache[i].assid, assoc_cache[i].status,
conf, reach, auth, condition, last_event, cnt);
bp = &buf[strlen(buf)];
while (bp > buf && *(bp-1) == ' ')
*(--bp) = '\0';
(void) fprintf(fp, "%s\n", buf);
}
}
/*
* associations - get, record and print a list of associations
*/
/*ARGSUSED*/
static void
associations(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
if (dogetassoc(fp))
printassoc(0, fp);
}
/*
* lassociations - get, record and print a long list of associations
*/
/*ARGSUSED*/
static void
lassociations(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
if (dogetassoc(fp))
printassoc(1, fp);
}
/*
* passociations - print the association list
*/
/*ARGSUSED*/
static void
passociations(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
printassoc(0, fp);
}
/*
* lpassociations - print the long association list
*/
/*ARGSUSED*/
static void
lpassociations(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
printassoc(1, fp);
}
#ifdef UNUSED
/*
* radiostatus - print the radio status returned by the server
*/
/*ARGSUSED*/
static void
radiostatus(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
char *datap;
int res;
int dsize;
u_short rstatus;
res = doquery(CTL_OP_READCLOCK, 0, 0, 0, (char *)0, &rstatus,
&dsize, &datap);
if (res != 0)
return;
if (dsize == 0) {
(void) fprintf(fp, "No radio status string returned\n");
return;
}
asciize(dsize, datap, fp);
}
#endif /* UNUSED */
/*
* pstatus - print peer status returned by the server
*/
static void
pstatus(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
char *datap;
int res;
int associd;
int dsize;
u_short rstatus;
if ((associd = checkassocid(pcmd->argval[0].uval)) == 0)
return;
res = doquery(CTL_OP_READSTAT, associd, 0, 0, (char *)0, &rstatus,
&dsize, &datap);
if (res != 0)
return;
if (dsize == 0) {
(void) fprintf(fp,
"No information returned for association %u\n",
associd);
return;
}
printvars(dsize, datap, (int)rstatus, TYPE_PEER, fp);
}
/*
* fixup - fix up a string so we don't get a hanging decimal after it
*/
static char *
fixup(width, str)
int width;
char *str;
{
if (str[width-1] == '.')
str[width-1] = '\0';
return str;
}
/*
* when - print how long its been since his last packet arrived
*/
static char *
when(ts, rec, reftime)
l_fp *ts;
l_fp *rec;
l_fp *reftime;
{
long diff;
l_fp *lasttime;
static char buf[20];
if (rec->l_ui != 0)
lasttime = rec;
else if (reftime->l_ui != 0)
lasttime = reftime;
else
return "-";
diff = (long)(ts->l_ui - lasttime->l_ui);
if (diff <= 0) {
/*
* Time warp?
*/
diff = 1;
}
if (diff <= 2048) {
(void) sprintf(buf, "%ld", (long int)diff);
return buf;
}
diff = (diff + 29) / 60;
if (diff <= 300) {
(void) sprintf(buf, "%ldm", (long int)diff);
return buf;
}
diff = (diff + 29) / 60;
if (diff <= 96) {
(void) sprintf(buf, "%ldh", (long int)diff);
return buf;
}
diff = (diff + 11) / 24;
(void) sprintf(buf, "%ldd", (long int)diff);
return buf;
}
/*
* A list of variables required by the peers command
*/
struct varlist opeervarlist[] = {
{ "srcadr", 0 }, /* 0 */
{ "dstadr", 0 }, /* 1 */
{ "stratum", 0 }, /* 2 */
{ "hpoll", 0 }, /* 3 */
{ "ppoll", 0 }, /* 4 */
{ "reach", 0 }, /* 5 */
{ "delay", 0 }, /* 6 */
{ "offset", 0 }, /* 7 */
{ "dispersion", 0 }, /* 8 */
{ "rec", 0 }, /* 9 */
{ "reftime", 0 }, /* 10 */
{ "srcport", 0 }, /* 11 */
{ 0, 0 }
};
struct varlist peervarlist[] = {
{ "srcadr", 0 }, /* 0 */
{ "refid", 0 }, /* 1 */
{ "stratum", 0 }, /* 2 */
{ "hpoll", 0 }, /* 3 */
{ "ppoll", 0 }, /* 4 */
{ "reach", 0 }, /* 5 */
{ "delay", 0 }, /* 6 */
{ "offset", 0 }, /* 7 */
{ "dispersion", 0 }, /* 8 */
{ "rec", 0 }, /* 9 */
{ "reftime", 0 }, /* 10 */
{ "srcport", 0 }, /* 11 */
{ 0, 0 }
};
#define HAVE_SRCADR 0
#define HAVE_DSTADR 1
#define HAVE_REFID 1
#define HAVE_STRATUM 2
#define HAVE_HPOLL 3
#define HAVE_PPOLL 4
#define HAVE_REACH 5
#define HAVE_DELAY 6
#define HAVE_OFFSET 7
#define HAVE_DISPERSION 8
#define HAVE_REC 9
#define HAVE_REFTIME 10
#define HAVE_SRCPORT 11
#define MAXHAVE 12
/*
* Decode an incoming data buffer and print a line in the peer list
*/
static int
doprintpeers(pvl, associd, rstatus, datalen, data, fp)
struct varlist *pvl;
int associd;
int rstatus;
int datalen;
char *data;
FILE *fp;
{
char *name;
char *value;
int i;
int c;
u_long srcadr;
u_long dstadr;
u_long srcport;
char *dstadr_refid = "0.0.0.0";
u_long stratum;
long ppoll;
long hpoll;
u_long reach;
l_fp estdelay;
l_fp estoffset;
l_fp estdisp;
l_fp rec;
l_fp reftime;
l_fp ts;
u_char havevar[MAXHAVE];
u_long poll;
char type = '?';
char refid_string[10];
extern struct ctl_var peer_var[];
memset((char *)havevar, 0, sizeof(havevar));
gettstamp(&ts);
while (nextvar(&datalen, &data, &name, &value)) {
u_long dummy;
i = findvar(name, peer_var);
if (i == 0)
continue; /* don't know this one */
switch (i) {
case CP_SRCADR:
if (decodenetnum(value, &srcadr))
havevar[HAVE_SRCADR] = 1;
break;
case CP_DSTADR:
if (decodenetnum(value, &dummy)) {
dummy = ntohl(dummy);
type = ((dummy&0xf0000000)==0xe0000000) ? 'm' :
((dummy&0x000000ff)==0x000000ff) ? 'b' :
((dummy&0xffffffff)==0x7f000001) ? 'l' :
((dummy&0xffffffe0)==0x00000000) ? '-' :
'u';
}
if (pvl == opeervarlist) {
if (decodenetnum(value, &dstadr)) {
havevar[HAVE_DSTADR] = 1;
dstadr_refid = numtoa(dstadr);
}
}
break;
case CP_REFID:
if (pvl == peervarlist) {
havevar[HAVE_REFID] = 1;
if (*value == '\0') {
dstadr_refid = "0.0.0.0";
} else if (decodenetnum(value, &dstadr)) {
if (dstadr == 0)
dstadr_refid = "0.0.0.0";
else
dstadr_refid = nntohost(dstadr);
} else if ((int)strlen(value) <= 4) {
refid_string[0] = '.';
(void) strcpy(&refid_string[1], value);
i = strlen(refid_string);
refid_string[i] = '.';
refid_string[i+1] = '\0';
dstadr_refid = refid_string;
} else {
havevar[HAVE_REFID] = 0;
}
}
break;
case CP_STRATUM:
if (decodeuint(value, &stratum))
havevar[HAVE_STRATUM] = 1;
break;
case CP_HPOLL:
if (decodeint(value, &hpoll)) {
havevar[HAVE_HPOLL] = 1;
if (hpoll < 0)
hpoll = NTP_MINPOLL;
}
break;
case CP_PPOLL:
if (decodeint(value, &ppoll)) {
havevar[HAVE_PPOLL] = 1;
if (ppoll < 0)
ppoll = NTP_MINPOLL;
}
break;
case CP_REACH:
if (decodeuint(value, &reach))
havevar[HAVE_REACH] = 1;
break;
case CP_DELAY:
if (decodetime(value, &estdelay))
havevar[HAVE_DELAY] = 1;
break;
case CP_OFFSET:
if (decodetime(value, &estoffset))
havevar[HAVE_OFFSET] = 1;
break;
case CP_DISPERSION:
if (decodetime(value, &estdisp))
havevar[HAVE_DISPERSION] = 1;
break;
case CP_REC:
if (decodets(value, &rec))
havevar[HAVE_REC] = 1;
break;
case CP_SRCPORT:
if (decodeuint(value, &srcport))
havevar[HAVE_SRCPORT] = 1;
break;
case CP_REFTIME:
havevar[HAVE_REFTIME] = 1;
if (!decodets(value, &reftime))
L_CLR(&reftime);
break;
default:
break;
}
}
/*
* Check to see if the srcport is NTP's port. If not this probably
* isn't a valid peer association.
*/
if (havevar[HAVE_SRCPORT] && srcport != NTP_PORT)
return 1;
/*
* Check to see if we got all of them. If not, return an
* error.
*/
for (i = 0; i < MAXHAVE; i++)
if (!havevar[i]) {
(void) fprintf(stderr,
"***Remote host didn't return peer.%s for association %d\n",
pvl[i].name, associd);
return 0;
}
/*
* Got everything, format the line
*/
poll = 1<<max(min3(ppoll, hpoll, NTP_MAXPOLL), NTP_MINPOLL);
if (pktversion == NTP_VERSION)
c = flash3[CTL_PEER_STATVAL(rstatus) & 0x7];
else
c = flash2[CTL_PEER_STATVAL(rstatus) & 0x3];
if (numhosts > 1)
(void) fprintf(fp, "%-*s ", maxhostlen, currenthost);
(void) fprintf(fp,
"%c%-15.15s %-15.15s %2ld %c %4.4s %4ld %3lo %7.7s %8.7s %7.7s\n",
c, nntohost(srcadr), dstadr_refid, stratum, type,
when(&ts, &rec, &reftime), poll, reach,
fixup(7, lfptoms(&estdelay, 2)), fixup(8, lfptoms(&estoffset, 3)),
fixup(7, lfptoms(&estdisp, 2)));
return 1;
}
#undef HAVE_SRCADR
#undef HAVE_DSTADR
#undef HAVE_STRATUM
#undef HAVE_PPOLL
#undef HAVE_HPOLL
#undef HAVE_REACH
#undef HAVE_ESTDELAY
#undef HAVE_ESTOFFSET
#undef HAVE_ESTDISP
#undef HAVE_REFID
#undef HAVE_REC
#undef HAVE_SRCPORT
#undef HAVE_REFTIME
#undef MAXHAVE
/*
* dogetpeers - given an association ID, read and print the spreadsheet
* peer variables.
*/
static int
dogetpeers(pvl, associd, fp)
struct varlist *pvl;
int associd;
FILE *fp;
{
char *datap;
int res;
int dsize;
u_short rstatus;
#ifdef notdef
res = doquerylist(pvl, CTL_OP_READVAR, associd, 0, &rstatus,
&dsize, &datap);
#else
/*
* Damn fuzzballs
*/
res = doquery(CTL_OP_READVAR, associd, 0, 0, (char *)0, &rstatus,
&dsize, &datap);
#endif
if (res != 0)
return 0;
if (dsize == 0) {
(void) fprintf(stderr,
"***No information returned for association %d\n",
associd);
return 0;
}
return doprintpeers(pvl, associd, (int)rstatus, dsize, datap, fp);
}
/*
* peers - print a peer spreadsheet
*/
static void
dopeers(showall, fp)
int showall;
FILE *fp;
{
register int i;
char fullname[LENHOSTNAME];
u_long netnum;
if (!dogetassoc(fp))
return;
for (i = 0; i < numhosts; ++i)
{ if(getnetnum(chosts[i],&netnum,fullname))
if ((int)strlen(fullname) > maxhostlen)
maxhostlen = strlen(fullname);
}
if (numhosts > 1)
(void) fprintf(fp, "%-*.*s ", maxhostlen, maxhostlen, "host");
(void) fprintf(fp,
" remote refid st t when poll reach delay offset disp\n");
if (numhosts > 1)
for (i = 0; i <= maxhostlen; ++i)
(void) fprintf(fp, "=");
(void) fprintf(fp,
"==============================================================================\n");
for (i = 0; i < numassoc; i++) {
if (!showall &&
!(CTL_PEER_STATVAL(assoc_cache[i].status)
& (CTL_PST_CONFIG|CTL_PST_REACH)))
continue;
if (!dogetpeers(peervarlist, (int)assoc_cache[i].assid, fp)) {
return;
}
}
return;
}
/*
* peers - print a peer spreadsheet
*/
/*ARGSUSED*/
static void
peers(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
dopeers(0, fp);
}
/*
* lpeers - print a peer spreadsheet including all fuzzball peers
*/
/*ARGSUSED*/
static void
lpeers(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
dopeers(1, fp);
}
/*
* opeers - print a peer spreadsheet
*/
static void
doopeers(showall, fp)
int showall;
FILE *fp;
{
register int i;
if (!dogetassoc(fp))
return;
(void) fprintf(fp,
" remote local st t when poll reach delay offset disp\n");
(void) fprintf(fp,
"===========================================================================\n");
for (i = 0; i < numassoc; i++) {
if (!showall &&
!(CTL_PEER_STATVAL(assoc_cache[i].status)
& (CTL_PST_CONFIG|CTL_PST_REACH)))
continue;
if (!dogetpeers(opeervarlist, (int)assoc_cache[i].assid, fp)) {
return;
}
}
return;
}
/*
* opeers - print a peer spreadsheet the old way
*/
/*ARGSUSED*/
static void
opeers(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
doopeers(0, fp);
}
/*
* lopeers - print a peer spreadsheet including all fuzzball peers
*/
/*ARGSUSED*/
static void
lopeers(pcmd, fp)
struct parse *pcmd;
FILE *fp;
{
doopeers(1, fp);
}
Reference in New Issue View Git Blame Copy Permalink