dist/ntpq/libntpq.c

/*****************************************************************************
 *
 *  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 LIBNTPQ_C
#define NO_MAIN_ALLOWED 1
/* #define BUILD_AS_LIB		Already provided by the Makefile */

#include "ntpq.c"
#include "libntpq.h"

/* Function Prototypes */


const char *Version = "libntpq 0.3beta";

/* global variables used for holding snapshots of data */
char peervars[NTPQ_BUFLEN];
int peervarlen = 0;
associd_t 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* dst = resultbuf;
	char* dep = resultbuf + maxlen - 1;
	char* src = srcbuf;
	char* sep = srcbuf + (datalen >= 0 ? datalen : 0);
	int   esc = 0;
	int   ch;

	if (maxlen <= 0)
		return 0;

	while ((dst != dep) && (src != sep) && (ch = (u_char)*src++) != 0) {
		if (esc) {
			esc = 0;
			switch (ch) {
				/* skip and do not copy */
				/* case '"':*/ /* quotes */
			case 'n': /*newline*/
			case 'r': /*carriage return*/
			case 'g': /*bell*/
			case 't': /*tab*/
				continue;
			default:
				break;
			}
		} else {
			switch (ch) {
			case '\\':
				esc = 1;
			case '"':
				continue;
			default:
				break;
			}
		}
		*dst++ = (char)ch;
	}
	*dst = '\0';
	return (int)(dst - 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		size_t	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		size_t	Max. number of bytes for varvalue
 *
 * Returns:
 *	size_t		number of chars that have been copied to
 *			varvalue
 ****************************************************************************/

size_t
ntpq_getvar(
	const char *	resultbuf,
	size_t		datalen,
	const char *	varname,
	char *		varvalue,
	size_t		maxlen)
{
	char *	name;
	char *	value;
	size_t	idatalen;

	value = NULL;
	idatalen = (int)datalen;

	while (nextvar(&idatalen, &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)
{
	const char *datap;
	int res;
	size_t	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
 *	fam		int	Address Family (AF_INET, AF_INET6, or 0)
 *
 * 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,
	int fam
	)
{
	if ( openhost(hostname, fam) )
	{
		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 ( associd_t associd )
{
	int i;

	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(
	associd_t	associd,
	char *		resultbuf,
	int		maxsize
	)
{
	const char *	datap;
	int		res;
	size_t		dsize;
	u_short		rstatus;

	res = doquery(CTL_OP_READVAR, associd, 0, 0, NULL, &rstatus,
		      &dsize, &datap);
	if (res != 0)
		return 0;
	if (dsize <= 0) {
		if (numhosts > 1)
			fprintf(stderr, "server=%s ", currenthost);
		fprintf(stderr,
			"***No information returned for association %d\n",
			associd);

		return 0;
	}
	if (dsize > maxsize)
		dsize = maxsize;
	memcpy(resultbuf, datap, dsize);

	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
 ****************************************************************************/
size_t
ntpq_read_sysvars(
	char *	resultbuf,
	size_t	maxsize
	)
{
	const char *	datap;
	int		res;
	size_t		dsize;
	u_short		rstatus;

	res = doquery(CTL_OP_READVAR, 0, 0, 0, NULL, &rstatus,
		      &dsize, &datap);

	if (res != 0)
		return 0;

	if (dsize == 0) {
		if (numhosts > 1)
			fprintf(stderr, "server=%s ", currenthost);
		fprintf(stderr, "***No sysvar information returned\n");

		return 0;
	} else {
		dsize = min(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( associd_t 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(
	associd_t associd
	)
{
	peervarlen = ntpq_read_assoc_peervars(associd, peervars,
					      sizeof(peervars));
	if (peervarlen <= 0) {
		peervar_assoc = 0;

		return 0;
	}
	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(
	associd_t	associd,
	char *		resultbuf,
	int		maxsize
	)
{
	const char *datap;
	int res;
	size_t 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_index
	)
{
	associd_t	associd;
	int		i;
	int		rc;
	sockaddr_u	dum_store;
	char		dstadr[LENHOSTNAME];
	char		resultbuf[NTPQ_BUFLEN];

	if (assoc_index < 0 || assoc_index >= numassoc)
		return -1;

	associd = assoc_cache[assoc_index].assid;
	if (associd == peervar_assoc) {
		rc = ntpq_get_peervar("dstadr", dstadr, sizeof(dstadr));
	} else {
		i = ntpq_read_assoc_peervars(associd, resultbuf,
					     sizeof(resultbuf));
		if (i <= 0)
			return -1;
		rc = ntpq_getvar(resultbuf, i, "dstadr", dstadr,
				 sizeof(dstadr));
	}

	if (0 != rc && decodenetnum(dstadr, &dum_store))
		return ntpq_decodeaddrtype(&dum_store);

	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( associd_t associd )
{
	if (NTP_CLOCKTYPE_LOCAL != ntpq_get_assoc_clocktype(
	    ntpq_get_assoc_number(associd)))
		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;
	}
}