/* resolvLib.c - DNS resolver library *//* Copyright 1984 - 2001 Wind River Systems, Inc */#include <copyright_wrs.h>/* modification history -------------------------01k,15oct01,rae  merge from truestack ver 01l, base 01j (SPRs 67238, 28659)01j,06oct98,jmp  moved doc to resolvLibDoc.c.01i,14dec97,jdi  doc: cleanup.01h,19aug97,jag  fixed man page problems in resolvInit() SPR#9173, fixed		 SPR#9174, SPR#9175. Deleted getHostInfo(), getbyaddrWrapper()01g,04aug97,kbw  fixed man page problems found in beta review01f,19may97,spm  added checks for NULL pointers to user interface (SPR #8603)01e,30apr97,kbw  fiddled man page text 01d,01apr97,kbw  fixed man page text, changed parameter name to "length"                 in resolvDNExpand 01c,01apr97,jag  removed unused variable resolvDefaultDomainName.  Added                 routines: resolvHostLibGetByAddr(), resolvHostLibGetByName().                 Added necessary man pages.01b,05feb97,jag  added debug function pointer in resolvInit. MAX_DOMAIN_NAME01a,12aug96,rjc  written*//*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!      WARNING      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!         DOCUMENTATION of this library is located in resolvLibDoc.c      If you modify any documented routine, please update resolvLibDoc.c.!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*//* includes */#include <vxWorks.h>#include <resolvLib.h>#include <semLib.h>#include <hostLib.h>#include <stdlib.h>#include <sockLib.h>#include <netinet/in.h>#include <inetLib.h>#include <stdio.h>#include <ctype.h>#include <errnoLib.h>#include <string.h>/* defines */#define  LOCAL_ENTRIES_TTL     60     /* Local entries have a ttl for 60 seconds */#define  ALIGNMENT              4     /* for word alignment */#define  MAX_DOMAIN_NAME      260     /* Max domain name including EOS marker */#define  MAX_HOSTLIB_BUF      512     /* hostLib interface functions buffer *//* macro to align ptr to buffer and decrement buffer size accordingly */#define ALIGN_BUF_PTR(pBuf, bufLen, alignment)     \     while ((UINT) (pBuf) % (alignment) != 0) \        {    \        ++ (pBuf);  \        -- (bufLen);  \        }/* typedefs *//* Globals *//* * Resolver state default settings.  Structure moved here from res_init.c */struct __res_state _res = 	{        RES_TIMEOUT,                    /* retransmition time interval */        4,                              /* number of times to retransmit */        RES_DEFAULT,                    /* options flags */        1,                              /* number of name servers */	};/* This variable point to the optional debug routine */FUNCPTR pdnsDebugFunc;/* locals */LOCAL RESOLV_PARAMS_S            resolvParams;        /* resolver settings */LOCAL STATUS resolvHostLibGetByAddr (int addr, char * pHostName);LOCAL int resolvHostLibGetByName (char * pHostName);/* externs */extern struct hostent *  _gethostbyname ();extern struct hostent *  _gethostbyaddr ();/* Ptrs defined in hostLib.c.  These ptrs are set by the resolver library */extern FUNCPTR _presolvHostLibGetByName;extern FUNCPTR _presolvHostLibGetByAddr;/********************************************************************************* hostEntFormat - Formats a char array as a structure of type hostent** This routine formarts a character array pointed to by <ppBuf> of the length * specified by <pBuflen>.  It creates a hostent structure in the buffer along* with the `h_aliases' and `h_addr_list' vectors big enough for <numAliases> * aliases and <numAddrs> addresses respectively. On a successful return * <ppBuf> and <pBuflen> specify the remaining unused part of the buffer.** NOMANUAL** RETURNS: A pointer to a hostent structure on success, or NULL if the* input buffer is too small.*/LOCAL struct hostent *  hostEntFormat    (    char **           ppBuf,      /* Pointer to character buffer pointer */    int *             pBufLen,    /* Pointer to the buffer length */    int               numAliases, /* Max # of host aliases expected */    int               numAddrs    /* Max # of host addresses expected */    )    {    char *            pTmp;    struct hostent *  pHostEnt;    pTmp =  *ppBuf;    if (((numAliases + 1 + numAddrs + 1) * sizeof (char *) +          sizeof (struct hostent) + 3 + 3) > *pBufLen)        {        return (NULL);        }    ALIGN_BUF_PTR (pTmp, *pBufLen, ALIGNMENT);    pHostEnt = (struct hostent *) pTmp;    pTmp += sizeof (struct hostent);    *pBufLen -= sizeof (struct hostent);     ALIGN_BUF_PTR (pTmp, *pBufLen, ALIGNMENT);    pHostEnt->h_aliases = (char **) pTmp;     pTmp += (numAliases + 1)* sizeof (char **);    *pBufLen -=  (numAliases + 1) * sizeof (char **);     pHostEnt->h_addr_list = (char **) pTmp;    pTmp += (numAddrs + 1)  * sizeof (char **);    *pBufLen -= (numAddrs + 1)  * sizeof (char **);    *ppBuf = pTmp;    return (pHostEnt);    }/********************************************************************************* resolvInit - initialize the resolver library ** This function initializes the resolver.  <pNameServer> is a single IP address* for a name server in dotted decimal notation.  <pDefaultDomainName> is the * default domain name to be appended to names without a dot.  The function * pointer <pdnsDebugRtn> is set to the resolver debug function.  Additional* name servers can be configured using the function resolvParamsSet().** RETURNS: OK or ERROR.** SEE ALSO:* resolvGetHostByName(), resolvGetHostByAddr(), resolvDNExpand(),* resolvDNComp(), resolvSend(), resolvParamsSet(), resolvParamsGet(),* resolvQuery()*/STATUS resolvInit    (    char *     pNameServer,	    /* pointer to Name server IP address */    char *     pDefaultDomainName,  /* default domain name */    FUNCPTR    pdnsDebugRtn         /* function ptr to debug routine */    )    {    int nserv = 0;           /* number of nameserver records read from file */    struct in_addr   ipAddr;    /* Initialize global pointer to the DNS debug routine */    pdnsDebugFunc = (FUNCPTR) NULL;    if (pdnsDebugRtn != NULL)	pdnsDebugFunc = pdnsDebugRtn;    _res.nsaddr.sin_addr.s_addr = INADDR_ANY;    _res.nsaddr.sin_family = AF_INET;    _res.nsaddr.sin_port = htons(NAMESERVER_PORT);    _res.ndots = 1;    _res.pfcode = 0;    strncpy (_res.lookups, "b", sizeof _res.lookups);        if (inet_aton (pNameServer, &ipAddr) == OK) 	{	_res.nsaddr_list [nserv].sin_addr = ipAddr;	_res.nsaddr_list [nserv].sin_family = AF_INET;	_res.nsaddr_list [nserv].sin_port = htons(NAMESERVER_PORT);	nserv++;	}    else	{	/* Illegal IP address for DNS server */	return (ERROR);	}    _res.nscount = nserv;	/* Number of name servers */    _res.dnsrch [0] = _res.defdname;    _res.options |= RES_INIT | RES_DEFNAMES | RES_DEBUG;    (void) strcpy (_res.defdname, pDefaultDomainName);    /* The resolver is initialized to query only the DNS server */    resolvParams.queryOrder = QUERY_DNS_ONLY;    /* Install pointers used by hostLib to access the resolver library */    _presolvHostLibGetByName = resolvHostLibGetByName;    _presolvHostLibGetByAddr = resolvHostLibGetByAddr;    return (OK);    }/********************************************************************************* resolvHostGetByName - queries the static host table for the host name** Retrieve host information installed by hostAdd() and install it in the* `hostent' structure referenced in <pHostEnt>.  This routine uses the * buffer referenced in <pBuf> to store hostname and network address * information.** NOMANUAL** RETURNS: A pointer to hostent, or NULL if the entry was not found.*/LOCAL struct hostent *  resolvHostGetByName     (    char *             pHostName,  /* pointer to the name of the host */    struct hostent *   pHostEnt,   /* ptr to hostent to hold the results */    char *             pBuf,       /* buffer to be used by hostnt */    int                bufLen      /* length of the buffer */    )    {    ALIGN_BUF_PTR (pBuf, bufLen, ALIGNMENT);    *(int*) pBuf =  hostTblSearchByName (pHostName);    if (*(int*)pBuf != ERROR)        {        pHostEnt->h_addr_list [0] = pBuf;        pHostEnt->h_addr_list [1] = NULL;	pHostEnt->h_addrtype = AF_INET;	pHostEnt->h_length = sizeof (int);        pBuf += sizeof (int);        pHostEnt->h_name = pBuf;        strcpy (pBuf, pHostName);        pHostEnt->h_ttl =  LOCAL_ENTRIES_TTL;        return (pHostEnt);        }    return (NULL);    }/********************************************************************************* resolvHostGetByAddr - queries the static host table for the IP address** Retrieve host information installed by hostAdd().  Copies the entry into* the hostent specified by <pHostEnt>, using the buffer specified by <pBuf> and* bufLen for storing hostname and network address info.** NOMANUAL** RETURNS: A pointer to hostent on sucess, or NULL.*/LOCAL struct hostent *  resolvHostGetByAddr     (    const char *       pAddr,    /* pointer to IP address in network order */    struct hostent *   pHostEnt, /* ptr to hostent to hold the results */    char *             pBuf,     /* buffer used by hostent */    int                bufLen    /* length of the buffer */    )    {    ALIGN_BUF_PTR (pBuf, bufLen, ALIGNMENT);    *(int*) pBuf = *(int*)pAddr;    pHostEnt->h_addr_list [0] = pBuf;    pHostEnt->h_addr_list [1] = NULL;    pBuf += 4;    if (hostTblSearchByAddr (*((int *)pAddr), pBuf) != OK)        {        return (NULL);        }    pHostEnt->h_name = pBuf;    pHostEnt->h_aliases [0] = NULL;    pHostEnt->h_ttl =  LOCAL_ENTRIES_TTL;    return (pHostEnt);    }/********************************************************************************* resolvGetHostByName - query the DNS server for the IP address of a host** This function returns a `hostent' structure. This structure is defined as* follows: ** .CS*     struct   hostent *     {*     char *   h_name;          /@ official name of host @/ *     char **  h_aliases;       /@ alias list @/*     int      h_addrtype;      /@ address type @/*     int      h_length;        /@ length of address @/ *     char **  h_addr_list;     /@ list of addresses from name server @/*     unsigned int h_ttl;       /@ Time to Live in Seconds for this entry @/*     }* .CE* The `h_aliases' and `h_addr_type' vectors are NULL-terminated.** Specify the host you want to query in <pHostname>.  Use <pBuf> and <bufLen> * to specify the location and size of a buffer to receive the `hostent' * structure and its associated contents.  Host addresses are returned in * network byte order.  Given the information this routine retrieves, the * <pBuf> buffer should be 512 bytes or larger.** RETURNS: A pointer to a `hostent' structure if the host is found, or * NULL if the parameters are invalid, the host is not found, or the * buffer is too small.** ERRNO:*  S_resolvLib_INVALID_PARAMETER*  S_resolvLib_BUFFER_2_SMALL*  S_resolvLib_TRY_AGAIN*  S_resolvLib_HOST_NOT_FOUND*  S_resolvLib_NO_DATA*  S_resolvLib_NO_RECOVERY* * SEE ALSO:* resolvInit(), resolvGetHostByAddr(), resolvDNExpand(),* resolvDNComp(), resolvSend(), resolvParamsSet(), resolvParamsGet(),* resolvMkQuery(), resolvQuery()*/struct hostent *  resolvGetHostByName    (    char *     pHostName,  /* ptr to the name of  the host */    char *     pHostBuf,   /* ptr to the buffer used by hostent structure */    int        bufLen      /* length of the buffer */     )    {    struct hostent *       pHostEnt;         /* Ptr to host entry */      /* Validate input parameters */    if (pHostName == NULL || pHostBuf == NULL)        {        errnoSet (S_resolvLib_INVALID_PARAMETER);        return (NULL);        }    /* Format input buffer for use as a hostent structure */    pHostEnt = hostEntFormat (&pHostBuf, &bufLen, MAXALIASES, MAXADDRS);    if (pHostEnt == NULL)        {        errno = S_resolvLib_BUFFER_2_SMALL;        return (NULL);        }    /* Check the hostLib static host table first ? */    if (resolvParams.queryOrder == QUERY_LOCAL_FIRST)        {        if (resolvHostGetByName (pHostName, pHostEnt, pHostBuf, bufLen) != NULL)            {            return (pHostEnt);            }        }    /*      * Ask the DNS Server to resolve the query.  In the case of queryOrder set     * to QUERY_ DNS_ONLY, this is the only query done.     */    if (_gethostbyname (pHostName,  pHostEnt, pHostBuf, bufLen))        {        return (pHostEnt);      /* Got an answer from the DNS server */        }    /* We need to check the hostLib static host table next */    if (resolvParams.queryOrder == QUERY_DNS_FIRST)        {        if (resolvHostGetByName (pHostName, pHostEnt, pHostBuf, bufLen) != NULL)            {            return (pHostEnt);            }        }     return (NULL);  /* Host IP Address Not Found */    }/********************************************************************************* resolvGetHostByAddr - query the DNS server for the host name of an IP address** This function returns a `hostent' structure, which is defined as follows:** .CS* struct   hostent *     {*     char *   h_name;            /@ official name of host @/*     char **  h_aliases;         /@ alias list @/*     int      h_addrtype;        /@ address type @/*     int      h_length;          /@ length of address @/*     char **  h_addr_list;       /@ list of addresses from name server @/*     unsigned int h_ttl;         /@ Time to Live in Seconds for this entry @/*     }* .CE* The `h_aliases' and `h_addr_type' vectors are NULL-terminated.** The <pinetAddr> parameter passes in the IP address (in network byte order)* for the host whose name you want to discover.  The <pBuf> and <bufLen> * parameters specify the location and size (512 bytes or more) of the buffer * that is to receive the hostent structure.  resolvGetHostByAddr() returns * host addresses are returned in network byte order. ** RETURNS: A pointer to a `hostent' structure if the host is found, or * NULL if the parameters are invalid, host is not found, or the buffer * is too small.* * ERRNO:*  S_resolvLib_INVALID_PARAMETER*  S_resolvLib_BUFFER_2_SMALL*  S_resolvLib_TRY_AGAIN*  S_resolvLib_HOST_NOT_FOUND*  S_resolvLib_NO_DATA*  S_resolvLib_NO_RECOVERY** SEE ALSO:* resolvGetHostByName(), resolvInit(), resolvDNExpand(),* resolvDNComp(), resolvSend(), resolvParamsSet(), resolvParamsGet(),* resolvMkQuery(), resolvQuery()*/struct hostent *     resolvGetHostByAddr     (    const char *       pInetAddr,