dns_client_lib.c

DNS 的实现代码

{
    ATMOS_MQID     qid;
    ATMOS_MESSAGE  msg;
    int            rc;

    MSG_D_DNS_GET_NAMESERVER(dmsg, &msg);
    if ((qid = findqueue(DNSCLIENT_QUEUE_NAME)) == 0) {
        printf("%C could not acquire the %s queue handle\n", DNSCLIENT_QUEUE_NAME);
	return ESRCH;
    }
    dmsg->error = ESUCCESS;
    dmsg->index = index;
    dmsg->nsaddr_str = (char *)nsaddr_str;
    if ((rc = sendmessage(&msg, MSG_N_DNS_GET_NAMESERVER, qid)) != ESUCCESS) {
        printf("%C error attempting to send get nameserver message\n");
	return rc;
    }
    awaitspecificmessage(&msg);
    return dmsg->error;

}   /* end dns_client_get_nameserver() */


/*
 * dns_client_get_searchlist_entry()
 *
 * this routine retrieves an searchlist entry from the existing list.
 * It is an API analog to the 'show' console command.
 *
 * the caller must provide a buffer with enough space to
 * store any searchlist entry (NAMEMAX+1; see dns_resolv.h).
 *
 * return:  ESUCCESS (searchlist entry in string buffer), or
 *          EINVAL (searchlist entry not found)
 */

int
dns_client_get_searchlist_entry(int index, char *slent_str)
{
    ATMOS_MQID     qid;
    ATMOS_MESSAGE  msg;
    int            rc;

    MSG_D_DNS_GET_SEARCHLIST_ENTRY(dmsg, &msg);
    if ((qid = findqueue(DNSCLIENT_QUEUE_NAME)) == 0) {
        printf("%C could not acquire the %s queue handle\n", DNSCLIENT_QUEUE_NAME);
	return ESRCH;
    }
    dmsg->error = ESUCCESS;
    dmsg->index = index;
    dmsg->slent_str = (char *)slent_str;
    if ((rc = sendmessage(&msg, MSG_N_DNS_GET_SEARCHLIST_ENTRY, qid)) != ESUCCESS) {
        printf("%C error attempting to send new searchlist message\n");
	return rc;
    }
    awaitspecificmessage(&msg);
    return dmsg->error;

}   /* end dns_client_get_searchlist_entry() */

/* dns_freehostent --
 *     Helper routine moved from dns_client_resource.c.
 *
 *     This routine releases memory occupied by 'hostent' structure.
 *     This structure in its turn consists of pointers which also
 *     need to be released. However, we always check that the pointers
 *     being released are not NULL. This fact is extensively used
 *     in dns_getipnodeby() functions.
 *
 * PARAMETERS
 *     p_hent - host entry to release
 *
 * RETURNS
 *     N/A
 */
void
dns_freehostent(struct hostent *p_hent)
{
    if (p_hent == NULL)
        return;

    /* release h_name */
    if (p_hent->h_name)
    {
        free((void *)(p_hent->h_name));
    }

    /* release aliases */
    if (p_hent->h_aliases)
    {
        char **tmp;
        char  *h_alias;

        for (tmp = p_hent->h_aliases, h_alias = *tmp;
             h_alias != NULL;
             tmp++, h_alias = *tmp)
        {
            free(h_alias);
        }

        free(p_hent->h_aliases);
    }

    /* release address list */
    if (p_hent->h_addr_list)
    {
        char **tmp;
        char  *p_addr;

        for (tmp = p_hent->h_addr_list, p_addr = *tmp;
             p_addr != NULL;
             tmp++, p_addr = *tmp)
        {
            free(p_addr);
        }

        free(p_hent->h_addr_list);
    }

    free(p_hent);

    return;

} /* dns_freehostent */

/*
 * dns_resolve_NAPTR()
 *
 * this routine constructs and sends a DNS_GET_RR message to the
 * dns_client.  we wait for a return message so the routine blocks until
 * the dns_client completes.
 *
 * return:  ESUCCESS, or
 *          error value from returned message.
 */

int
dns_resolve_NAPTR(const char *domain_name, BOOL use_cache, U8 *nptr, U32 *len)
{
    ATMOS_MESSAGE  msg;
    MSG_D_DNS_GET_RR(dmsg, &msg);

    if ( dns_u_resolve_NAPTR(domain_name, use_cache, nptr, len, &msg) == ESUCCESS ) {
        awaitspecificmessage(&msg);
        return dmsg->error;
    }
    else
    {
        return ETRYAGAIN;
    }
}   /* end dns_resolve_NAPTR() */

/*
 * dns_resolve_SRV()
 *
 * this routine constructs and sends a DNS_GET_RR message to the
 * dns_client.  we wait for a return message so the routine blocks until
 * the dns_client completes.
 *
 * return:  ESUCCESS, or
 *          error value from returned message.
 */

int
dns_resolve_SRV(const char *domain_name, BOOL use_cache, U8 *sptr, U32 *len,  U8 *dnsMsg)
{
    ATMOS_MESSAGE  msg;
    MSG_D_DNS_GET_RR(dmsg, &msg);

    if ( dns_u_resolve_SRV(domain_name, use_cache, sptr, len, dnsMsg, &msg) == ESUCCESS )
	{
        awaitspecificmessage(&msg);
        return dmsg->error;
    }
    else
        return ETRYAGAIN;

}   /* end dns_resolve_SRV() */

/*
 * dns_flush_XX_cache()
 *
 * this routine constructs and sends a DNS_FLUSH_XX_CACHE message to the
 * dns_client.  we wait for a return message so the routine blocks until
 * the dns_client completes.
 *
 * return:  ESUCCESS, or
 *          error value from returned message.
 */

int
dns_flush_XX_cache()
{
    ATMOS_MQID     qid;
    ATMOS_MESSAGE  msg;
    int            rc;

    MSG_D_DNS_FLUSH_XX_CACHE(dmsg, &msg);
    dmsg->error = ESUCCESS;
    if ((qid = findqueue(DNSCLIENT_QUEUE_NAME)) == 0)
	{
        return ETRYAGAIN;
    }
    if ((rc = sendmessage(&msg, MSG_N_DNS_FLUSH_XX_CACHE, qid)) != ESUCCESS)
	{
        return ETRYAGAIN;
    }
    awaitspecificmessage(&msg);
    return dmsg->error;

}   /* end dns_flush_XX_cache() */


/*
 * dns_flush_XX_cache_byname()
 *
 * this routine constructs and sends a DNS_FLUSH_XX_CACHE_BYNAME message to the
 * dns_client.  we wait for a return message so the routine blocks until
 * the dns_client completes.
 *
 * return:  ESUCCESS, or
 *          error value from returned message.
 */

int
dns_flush_XX_cache_byname(const char *dname)
{
    ATMOS_MQID     qid;
    ATMOS_MESSAGE  msg;
    int            rc;

    MSG_D_DNS_FLUSH_XX_CACHE_BYNAME(dmsg, &msg);
    if ((qid = findqueue(DNSCLIENT_QUEUE_NAME)) == 0)
	{
        return ETRYAGAIN;
    }
    dmsg->error = ESUCCESS;
    dmsg->dname = (char *)dname;
    if ((rc = sendmessage(&msg, MSG_N_DNS_FLUSH_XX_CACHE_BYNAME, qid)) != ESUCCESS)
	{
        return ETRYAGAIN;
    }
    awaitspecificmessage(&msg);
    return dmsg->error;

}   /* end dns_flush_XX_cache_byname() */


/*
 * dns_u_resolve_NAPTR()
 *
 * this routine constructs and sends a DNS_GET_RR message to the
 * dns_client.
 *
 * return:  ESUCCESS, or
 *          error value
 */

int
dns_u_resolve_NAPTR(
const char          *domain_name,
BOOL                use_cache,
U8                  *nptr,
U32                 *len,
ATMOS_MESSAGE       *msg )
{
    ATMOS_MQID     qid;
    int            err=0;

    MSG_D_DNS_GET_RR(dmsg, msg);

    if ((qid = findqueue(DNSCLIENT_QUEUE_NAME)) == 0)
	{
        return ETRYAGAIN;
    }

    dmsg->dname = (char *)domain_name;
    dmsg->use_cache = use_cache;
    dmsg->rrptr = nptr;
    dmsg->len = len;
    dmsg->qtype = QT_NAPTR;
    dmsg->error = ESUCCESS;


    err = sendmessage(msg, MSG_N_DNS_GET_RR, qid);

    return err;

}   /* end dns_u_resolve_NAPTR() */

/*
 * dns_u_resolve_SRV()
 *
 * this routine constructs and sends a DNS_GET_RR message to the
 * dns_client.
 *
 * return:  ESUCCESS, or
 *          error value
 */

int
dns_u_resolve_SRV(
const char          *domain_name,
BOOL                use_cache,
U8                  *sptr,
U32                 *len,
U8			   *dnsMsg,
ATMOS_MESSAGE       *msg )
{
    ATMOS_MQID     qid;

    MSG_D_DNS_GET_RR(dmsg, msg);

    if ((qid = findqueue(DNSCLIENT_QUEUE_NAME)) == 0) {
        return ETRYAGAIN;
    }

    dmsg->dname = (char *)domain_name;
    dmsg->use_cache = use_cache;
    dmsg->rrptr = sptr;
    dmsg->qtype = QT_SRV;
    dmsg->len = len;
    dmsg->dnsMsg = dnsMsg;
    dmsg->error = ESUCCESS;

    return sendmessage(msg, MSG_N_DNS_GET_RR, qid);

}   /* end dns_u_resolve_SRV() */

/*
 * dname_expand()
 *
 * this routine will get the domain name from the DNS message.  the domain
 * name in a DNS message has the following format:
 *
 * --------------------------------
 * |8|hostname|9|someplace|3|com|0|
 * --------------------------------
 *
 * the numbers indicate how many characters for the following label and the
 * zero indicates the end of the domain name. This routine does not take care
 * of name compression.
 *
 * return:  number of bytes used in parsing, or
 *         -1 to indicate an error.
 */

int
dname_expand(U8 *data, U8 *dname, U32 length, U8 *dnsMsg)
{
    int   nread;
    U8    ccnt, cnt, offset;
    U8    *cptr;
    char  label[LABELMAX + 1];
    char  domainName[NAMEMAX];

    if(NULL == data || NULL == dname)
    {
        return -1;
    }

    nread = 0;
    cnt = 0;
    cptr = data;
    ccnt = *cptr;
    memset(domainName, 0, NAMEMAX);
    while ( ccnt > 0 ) {
        if ( CMPBITSET(ccnt) )
        {
               if (dnsMsg == NULL)
               {
                   return -1; /* dont handle compressed names, if no dns msg passed */
               }
               offset = cptr[1];
               cptr = (dnsMsg+offset);
        }

        cnt = *cptr;
        if ( cnt > LABELMAX )
            return -1;
        memset(label, 0, LABELMAX+1);
        memcpy(label, cptr+1, cnt);
        label[cnt] = DOT;
        label[cnt+1] = '\0';
        ccnt = cnt + 1;

        if ( (S8 )ccnt < 0 )            /* the cast is okay because max = 63 */
            return -1;                  /* so a valid value can't be -1 */

        strcat(domainName, label);
        nread += ccnt;

        cptr += ccnt;
        ccnt = *cptr;
    }
    nread++;
    if(strlen(domainName) >= length)
    {
        return -1; /* Not enough buffer space. */
    }

    strcpy(dname, domainName);

    return nread;

}   /* end dname_expand() */