Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/external/bsd/ntp/dist/ntpq/libntpq.c

793 lines
22 KiB
C
Raw Blame History

/* $NetBSD: libntpq.c,v 1.1.1.1 2009/12/13 16:56:28 kardel Exp $ */
/*****************************************************************************
*
* libntpq.c
*
* This is the wrapper library for ntpq, the NTP query utility.
* This library reuses the sourcecode from ntpq and exports a number
* of useful functions in a library that can be linked against applications
* that need to query the status of a running ntpd. The whole
* communcation is based on mode 6 packets.
*
****************************************************************************/
#define _LIBNTPQC
#define NO_MAIN_ALLOWED 1
/* #define BUILD_AS_LIB Already provided by the Makefile */
#include "ntpq.c"
#include "libntpq.h"
/* Function Prototypes */
int ntpq_openhost(char *);
int ntpq_closehost(void);
int ntpq_queryhost(unsigned short VARSET, unsigned short association, char *resultbuf, int maxlen);
int ntpq_stripquotes ( char *resultbuf, char *srcbuf, int datalen, int maxlen );
int ntpq_queryhost_peervars(unsigned short association, char *resultbuf, int maxlen);
int ntpq_getvar( char *resultbuf, int datalen, const char *varname, char *varvalue, int maxlen);
int ntpq_get_peervar( const char *varname, char *varvalue, int maxlen);
int ntpq_read_associations ( unsigned short resultbuf[], int max_entries );
int ntpq_read_sysvars( char *resultbuf, int maxsize );
int ntpq_get_assoc_allvars( int associd );
int ntpq_get_sysvars( void );
int ntpq_get_assocs ( void );
int ntpq_read_assoc_peervars( int associd, char *resultbuf, int maxsize );
int ntpq_read_assoc_clockvars( int associd, char *resultbuf, int maxsize );
int ntpq_get_assoc_number ( int associd );
int ntpq_get_assoc_peervars( int associd );
int ntpq_get_assoc_clockvars( int associd );
int ntpq_get_assoc_clocktype ( int assoc_number );
const char *Version = "libntpq 0.3beta";
/* global variables used for holding snapshots of data */
char peervars[NTPQ_BUFLEN];
int peervarlen = 0;
int peervar_assoc = 0;
char clockvars[NTPQ_BUFLEN];
int clockvarlen = 0;
int clockvar_assoc = 0;
char sysvars[NTPQ_BUFLEN];
int sysvarlen = 0;
char *ntpq_resultbuffer[NTPQ_BUFLEN];
unsigned short ntpq_associations[MAXASSOC];
struct ntpq_varlist ntpq_varlist[MAXLIST];
/*****************************************************************************
*
* ntpq_stripquotes
*
* Parses a given character buffer srcbuf and removes all quoted
* characters. The resulting string is copied to the specified
* resultbuf character buffer. E.g. \" will be translated into "
*
****************************************************************************
* Parameters:
* resultbuf char* The resulting string without quoted
* characters
* srcbuf char* The buffer holding the original string
* datalen int The number of bytes stored in srcbuf
* maxlen int Max. number of bytes for resultbuf
*
* Returns:
* int number of chars that have been copied to
* resultbuf
****************************************************************************/
int ntpq_stripquotes ( char *resultbuf, char *srcbuf, int datalen, int maxlen )
{
char* tmpbuf = srcbuf;
while ( *tmpbuf != 0 )
{
if ( *tmpbuf == '\"' )
{
tmpbuf++;
continue;
}
if ( *tmpbuf == '\\' )
{
tmpbuf++;
switch ( *tmpbuf )
{
/* ignore if end of string */
case 0:
continue;
/* skip and do not copy */
case '\"': /* quotes */
case 'n': /*newline*/
case 'r': /*carriage return*/
case 'g': /*bell*/
case 't': /*tab*/
tmpbuf++;
continue;
}
}
*resultbuf++ = *tmpbuf++;
}
*resultbuf = 0;
return strlen(resultbuf);
}
/*****************************************************************************
*
* ntpq_getvar
*
* This function parses a given buffer for a variable/value pair and
* copies the value of the requested variable into the specified
* varvalue buffer.
*
* It returns the number of bytes copied or zero for an empty result
* (=no matching variable found or empty value)
*
****************************************************************************
* Parameters:
* resultbuf char* The resulting string without quoted
* characters
* datalen int The number of bytes stored in
* resultbuf
* varname char* Name of the required variable
* varvalue char* Where the value of the variable should
* be stored
* maxlen int Max. number of bytes for varvalue
*
* Returns:
* int number of chars that have been copied to
* varvalue
****************************************************************************/
int ntpq_getvar( char *resultbuf, int datalen, const char *varname, char *varvalue, int maxlen)
{
char *name;
char *value = NULL;
while (nextvar(&datalen, &resultbuf, &name, &value)) {
if ( strcmp(varname, name) == 0 ) {
ntpq_stripquotes(varvalue,value,strlen(value),maxlen);
return strlen(varvalue);
}
}
return 0;
}
/*****************************************************************************
*
* ntpq_queryhost
*
* Sends a mode 6 query packet to the current open host (see
* ntpq_openhost) and stores the requested variable set in the specified
* character buffer.
* It returns the number of bytes read or zero for an empty result
* (=no answer or empty value)
*
****************************************************************************
* Parameters:
* VARSET u_short Which variable set should be
* read (PEERVARS or CLOCKVARS)
* association int The association ID that should be read
* 0 represents the ntpd instance itself
* resultbuf char* The resulting string without quoted
* characters
* maxlen int Max. number of bytes for varvalue
*
* Returns:
* int number of bytes that have been copied to
* resultbuf
* - OR -
* 0 (zero) if no reply has been received or
* another failure occured
****************************************************************************/
int ntpq_queryhost(unsigned short VARSET, unsigned short association, char *resultbuf, int maxlen)
{
char *datap;
int res;
int dsize;
u_short rstatus;
if ( numhosts > 0 )
res = doquery(VARSET,association,0,0, (char *)0, &rstatus, &dsize, &datap);
else
return 0;
if ( ( res != 0) || ( dsize == 0 ) ) /* no data */
return 0;
if ( dsize > maxlen)
dsize = maxlen;
/* fill result resultbuf */
memcpy(resultbuf, datap, dsize);
return dsize;
}
/*****************************************************************************
*
* ntpq_openhost
*
* Sets up a connection to the ntpd instance of a specified host. Note:
* There is no real "connection" established because NTP solely works
* based on UDP.
*
****************************************************************************
* Parameters:
* hostname char* Hostname/IP of the host running ntpd
*
* Returns:
* int 1 if the host connection could be set up, i.e.
* name resolution was succesful and/or IP address
* has been validated
* - OR -
* 0 (zero) if a failure occured
****************************************************************************/
int ntpq_openhost(char *hostname)
{
if ( openhost(hostname) )
{
numhosts = 1;
} else {
numhosts = 0;
}
return numhosts;
}
/*****************************************************************************
*
* ntpq_closehost
*
* Cleans up a connection by closing the used socket. Should be called
* when no further queries are required for the currently used host.
*
****************************************************************************
* Parameters:
* - none -
*
* Returns:
* int 0 (zero) if no host has been opened before
* - OR -
* the resultcode from the closesocket function call
****************************************************************************/
int ntpq_closehost(void)
{
if ( numhosts )
return closesocket(sockfd);
return 0;
}
/*****************************************************************************
*
* ntpq_read_associations
*
* This function queries the ntp host for its associations and returns the
* number of associations found.
*
* It takes an u_short array as its first parameter, this array holds the
* IDs of the associations,
* the function will not write more entries than specified with the
* max_entries parameter.
*
* However, if more than max_entries associations were found, the return
* value of this function will reflect the real number, even if not all
* associations have been stored in the array.
*
****************************************************************************
* Parameters:
* resultbuf u_short*Array that should hold the list of
* association IDs
* maxentries int maximum number of association IDs that can
* be stored in resultbuf
*
* Returns:
* int number of association IDs stored in resultbuf
* - OR -
* 0 (zero) if a failure occured or no association has
* been returned.
****************************************************************************/
int ntpq_read_associations ( u_short resultbuf[], int max_entries )
{
int i = 0;
if (ntpq_dogetassoc()) {
if(numassoc < max_entries)
max_entries = numassoc;
for (i=0;i<max_entries;i++)
resultbuf[i] = assoc_cache[i].assid;
return numassoc;
}
return 0;
}
/*****************************************************************************
*
* ntpq_get_assocs
*
* This function reads the associations of a previously selected (with
* ntpq_openhost) NTP host into its own (global) array and returns the
* number of associations found.
*
* The obtained association IDs can be read by using the ntpq_get_assoc_id
* function.
*
****************************************************************************
* Parameters:
* - none -
*
* Returns:
* int number of association IDs stored in resultbuf
* - OR -
* 0 (zero) if a failure occured or no association has
* been returned.
****************************************************************************/
int ntpq_get_assocs ( void )
{
return ntpq_read_associations( ntpq_associations, MAXASSOC );
}
/*****************************************************************************
*
* ntpq_get_assoc_number
*
* This function returns for a given Association ID the association number
* in the internal association array, which is filled by the ntpq_get_assocs
* function.
*
****************************************************************************
* Parameters:
* associd int requested associaton ID
*
* Returns:
* int the number of the association array element that is
* representing the given association ID
* - OR -
* -1 if a failure occured or no matching association
* ID has been found
****************************************************************************/
int ntpq_get_assoc_number ( int associd )
{
int i = 0;
for (i=0;i<numassoc;i++) {
if (assoc_cache[i].assid == associd)
return i;
}
return (-1);
}
/*****************************************************************************
*
* ntpq_read_assoc_peervars
*
* This function reads the peervars variable-set of a specified association
* from a NTP host and writes it to the result buffer specified, honoring
* the maxsize limit.
*
* It returns the number of bytes written or 0 when the variable-set is
* empty or failed to read.
*
****************************************************************************
* Parameters:
* associd int requested associaton ID
* resultbuf char* character buffer where the variable set
* should be stored
* maxsize int the maximum number of bytes that can be
* written to resultbuf
*
* Returns:
* int number of chars that have been copied to
* resultbuf
* - OR -
* 0 (zero) if an error occured
****************************************************************************/
int ntpq_read_assoc_peervars( int associd, char *resultbuf, int maxsize )
{
char *datap;
int res;
int dsize;
u_short rstatus;
l_fp rec;
l_fp ts;
char value[NTPQ_BUFLEN];
res = doquery(CTL_OP_READVAR, associd, 0, 0, (char *)0, &rstatus,
&dsize, &datap);
if (res != 0)
return 0;
get_systime(&ts);
if (dsize == 0) {
if (numhosts > 1)
(void) fprintf(stderr, "server=%s ", currenthost);
(void) fprintf(stderr,
"***No information returned for association %d\n",
associd);
return 0;
} else {
if ( dsize > maxsize )
dsize = maxsize;
memcpy(resultbuf,datap,dsize);
resultbuf[dsize]=0x0;
ntpq_getvar(resultbuf, dsize, "rec", value, sizeof (value) );
if (!decodets(value, &rec))
L_CLR(&rec);
memcpy(resultbuf,value,maxsize);
resultbuf[dsize]=0x0;
dsize=strlen(resultbuf);
}
return dsize;
}
/*****************************************************************************
*
* ntpq_read_sysvars
*
* This function reads the sysvars variable-set from a NTP host and writes it
* to the result buffer specified, honoring the maxsize limit.
*
* It returns the number of bytes written or 0 when the variable-set is empty
* or could not be read.
*
****************************************************************************
* Parameters:
* resultbuf char* character buffer where the variable set
* should be stored
* maxsize int the maximum number of bytes that can be
* written to resultbuf
*
* Returns:
* int number of chars that have been copied to
* resultbuf
* - OR -
* 0 (zero) if an error occured
****************************************************************************/
int ntpq_read_sysvars( char *resultbuf, int maxsize )
{
char *datap;
int res;
int dsize;
u_short rstatus;
res = doquery(CTL_OP_READVAR, 0, 0, 0, (char *)0, &rstatus,
&dsize, &datap);
if (res != 0)
return 0;
if (dsize == 0) {
if (numhosts > 1)
(void) fprintf(stderr, "server=%s ", currenthost);
(void) fprintf(stderr,
"***No sysvar information returned \n");
return 0;
} else {
if ( dsize > maxsize )
dsize = maxsize;
memcpy(resultbuf,datap,dsize);
}
return dsize;
}
/*****************************************************************************
* ntpq_get_assoc_allvars
*
* With this function all association variables for the specified association
* ID can be requested from a NTP host. They are stored internally and can be
* read by using the ntpq_get_peervar or ntpq_get_clockvar functions.
*
* Basically this is only a combination of the ntpq_get_assoc_peervars and
* ntpq_get_assoc_clockvars functions.
*
* It returns 1 if both variable-sets (peervars and clockvars) were
* received successfully. If one variable-set or both of them weren't
* received,
*
****************************************************************************
* Parameters:
* associd int requested associaton ID
*
* Returns:
* int nonzero if at least one variable set could be read
* - OR -
* 0 (zero) if an error occured and both variable sets
* could not be read
****************************************************************************/
int ntpq_get_assoc_allvars( int associd )
{
return ( ntpq_get_assoc_peervars ( associd ) & ntpq_get_assoc_clockvars( associd ) );
}
/*****************************************************************************
*
* ntpq_get_sysvars
*
* The system variables of a NTP host can be requested by using this function
* and afterwards using ntpq_get_sysvar to read the single variable values.
*
****************************************************************************
* Parameters:
* - none -
*
* Returns:
* int nonzero if the variable set could be read
* - OR -
* 0 (zero) if an error occured and the sysvars
* could not be read
****************************************************************************/
int ntpq_get_sysvars( void )
{
sysvarlen = ( ntpq_read_sysvars( sysvars, sizeof(sysvars )) );
if ( sysvarlen <= 0 ) {
return 0;
} else {
return 1;
}
}
/*****************************************************************************
*
* ntp_get_peervar
*
* This function uses the variable-set which was read by using
* ntp_get_peervars and searches for a variable specified with varname. If
* such a variable exists, it writes its value into
* varvalue (maxlen specifies the size of this target buffer).
*
****************************************************************************
* Parameters:
* varname char* requested variable name
* varvalue char* the buffer where the value should go into
* maxlen int maximum number of bytes that can be copied to
* varvalue
*
* Returns:
* int number of bytes copied to varvalue
* - OR -
* 0 (zero) if an error occured or the variable could
* not be found
****************************************************************************/
int ntpq_get_peervar( const char *varname, char *varvalue, int maxlen)
{
return ( ntpq_getvar(peervars,peervarlen,varname,varvalue,maxlen) );
}
/*****************************************************************************
*
* ntpq_get_assoc_peervars
*
* This function requests the peer variables of the specified association
* from a NTP host. In order to access the variable values, the function
* ntpq_get_peervar must be used.
*
****************************************************************************
* Parameters:
* associd int requested associaton ID
*
* Returns:
* int 1 (one) if the peervars have been read
* - OR -
* 0 (zero) if an error occured and the variable set
* could not be read
****************************************************************************/
int ntpq_get_assoc_peervars( int associd )
{
peervarlen = ( ntpq_read_assoc_peervars( associd, peervars, sizeof(peervars )) );
if ( peervarlen <= 0 ) {
peervar_assoc = 0;
return 0;
} else {
peervar_assoc = associd;
return 1;
}
}
/*****************************************************************************
*
* ntp_read_assoc_clockvars
*
* This function reads the clockvars variable-set of a specified association
* from a NTP host and writes it to the result buffer specified, honoring
* the maxsize limit.
*
* It returns the number of bytes written or 0 when the variable-set is
* empty or failed to read.
*
****************************************************************************
* Parameters:
* associd int requested associaton ID
* resultbuf char* character buffer where the variable set
* should be stored
* maxsize int the maximum number of bytes that can be
* written to resultbuf
*
* Returns:
* int number of chars that have been copied to
* resultbuf
* - OR -
* 0 (zero) if an error occured
****************************************************************************/
int ntpq_read_assoc_clockvars( int associd, char *resultbuf, int maxsize )
{
char *datap;
int res;
int dsize;
u_short rstatus;
res = ntpq_doquerylist(ntpq_varlist, CTL_OP_READCLOCK, associd, 0, &rstatus, &dsize, &datap);
if (res != 0)
return 0;
if (dsize == 0) {
if (numhosts > 1) /* no information returned from server */
return 0;
} else {
if ( dsize > maxsize )
dsize = maxsize;
memcpy(resultbuf,datap,dsize);
}
return dsize;
}
/*****************************************************************************
*
* ntpq_get_assoc_clocktype
*
* This function returns a clocktype value for a given association number
* (not ID!):
*
* NTP_CLOCKTYPE_UNKNOWN Unknown clock type
* NTP_CLOCKTYPE_BROADCAST Broadcast server
* NTP_CLOCKTYPE_LOCAL Local clock
* NTP_CLOCKTYPE_UNICAST Unicast server
* NTP_CLOCKTYPE_MULTICAST Multicast server
*
****************************************************************************/
int ntpq_get_assoc_clocktype ( int assoc_number )
{
int type = 0;
int i, rc = 0;
sockaddr_u dum_store;
char value[LENHOSTNAME];
char resultbuf[1024];
if ( assoc_number < 0 || assoc_number > numassoc ) {
return -1;
} else {
if ( peervar_assoc != assoc_cache[assoc_number].assid ) {
i=ntpq_read_assoc_peervars(assoc_cache[assoc_number].assid, resultbuf, sizeof(resultbuf));
if ( i <= 0 ) {
return -1;
}
rc = ntpq_getvar(resultbuf, i, "dstadr", value, LENHOSTNAME );
} else {
rc = ntpq_get_peervar("dstadr",value,LENHOSTNAME);
}
if ( rc ) {
if (decodenetnum(value, &dum_store)) {
type = ntpq_decodeaddrtype(&dum_store);
return type;
}
}
return -1;
}
return -1;
}
/*****************************************************************************
*
* ntpq_get_assoc_clockvars
*
* With this function the clock variables of the specified association are
* requested from a NTP host. This makes only sense for associations with
* the type 'l' (Local Clock) and you should check this with
* ntpq_get_assoc_clocktype for each association, before you use this function
* on it.
*
****************************************************************************
* Parameters:
* associd int requested associaton ID
*
* Returns:
* int 1 (one) if the clockvars have been read
* - OR -
* 0 (zero) if an error occured and the variable set
* could not be read
****************************************************************************/
int ntpq_get_assoc_clockvars( int associd )
{
if ( ntpq_get_assoc_clocktype(ntpq_get_assoc_number(associd)) != NTP_CLOCKTYPE_LOCAL )
return 0;
clockvarlen = ( ntpq_read_assoc_clockvars( associd, clockvars, sizeof(clockvars )) );
if ( clockvarlen <= 0 ) {
clockvar_assoc = 0;
return 0;
} else {
clockvar_assoc = associd;
return 1;
}
}
Reference in New Issue View Git Blame Copy Permalink