dns_recu.c.svn-base

域名解析器的实现

/* include files declaration */
#include <l3/inc/phase2.h>
#include <l3/ap/dnsr/h/dns.h>
#include <l3/ap/dnsr/h/dnsr_if.h>

/*-----------------------------------------------------------------------
 * Local Variables
 *-----------------------------------------------------------------------
 */  
/* Global variables */
static struct static_dns_tab   dns_host_tab[MAX_STATIC_DNS_NUM];   /* static "name <-> ip" mapping table */

struct dns_qrr {
  unsigned char *name;          /* RR name */
  UI16_T  class;               /* DNS class of RR */
  UI16_T  type;                /* DNS type of RR */
};

/*-----------------------------------------------------------------------
 * Functions
 *-----------------------------------------------------------------------
 */  
    
/* if two domain name match
   return 1;
   else
   return 0;             */
static UI8_T dns_name_match(UI8_T *name1, UI8_T *name2)
{
    int i;

    if (name1==NULL || name2==NULL)
        return 0;
    if (strlen((const char*)name1)!=strlen((const char*)name2))
        return 0;
    /* hawa:change to use strcmp to compare both strings */
    for (i=0;i<255;i++)
    {
        if (name1[i]==0x0)
            break;
        if (name1[i] == name2[i] )                
            continue;
        else
        {
            if (name1[i] > name2[i] )                
            {
                if ( (name1[i] >=0x61 && name1[i] <=0x7a )&& (name1[i]-0x20) == name2[i])
                    continue;
                else
                    return 0;                        
            }                        
            else
            {
                if ((name2[i] >=0x61 && name2[i] <=0x7a )&& (name2[i]-0x20) == name1[i])
                    continue;
                else
                    return 0;                                        
            }                        
        }                                
    }                        
    
    #if DNSR_DEBUG
        DBG_L3_Printf("find matched domain name in host table!\n");
    #endif
    
    return 1;
} /* dns_name_match */

static UI32_T dns_find_ip_at_table(unsigned char *name)
{
    int i;

    for (i = 0 ; i < MAX_STATIC_DNS_NUM ; i++)
    {
        if (dns_host_tab[i].stat)
	    {
		    /*if (dns_name_match(dns_full_name_tab[i], name) == 1)*/
		    if (dns_name_match(dns_host_tab[i].dns_name, name) == 1)
                return SWAP32(dns_host_tab[i].ip_addr);
	    }
    }

    #if DNSR_DEBUG
      DBG_L3_Printf("find no ip match %s\n", name);
    #endif

    return 0 ;
} /* dns_find_ip_at_table */


static UI32_T victor_read_addr(UI8_T *p)
{
    UI8_T digit[3];
    I16_T idx;     
    UI32_T addr=0;  
    UI32_T temp=0;

    I16_T i,j;
     
     
    for (i=0;i<4;i++)
    {                 
        idx=0;              
        while(*p!='.')
        {   
            if (idx>=3)
            return 0;            
            digit[idx]=*p;
            p++;
            idx++;     
        }
        p++;         

        for (j=0;j<idx;j++)
        {
            if (idx-j==3)            
                temp+=(digit[j]-48)*100;
            else if (idx-j==2)      
                temp+=(digit[j]-48)*10;
            else if (idx-j==1)      
                temp+=(digit[j]-48);            
        }
        
        for (j=0;j<i;j++)
            temp*=0x100;     
        addr+=temp;
        temp=0;
    } /* for loop */
    
#if DNSR_DEBUG
        DBG_L3_Printf("addr = %d.%d.%d.%d\n",
                   addr/0x1000000,
                   addr%0x1000000/0x10000,
                   addr%0x10000/0x100,
                   addr%0x100);
#endif                   
                   
    return addr; /* host ordering   */
};

static I8_T *dns_find_name_at_table(UI8_T *ipstring)
{
    UI32_T addr;
    int i;

    addr = victor_read_addr(ipstring);
    if (addr==0)
        return 0;

    for (i=0;i<MAX_STATIC_DNS_NUM;i++)
    {
        if (dns_host_tab[i].stat)
            if (SWAP32(dns_host_tab[i].ip_addr) == addr)
                return (I8_T*)&dns_host_tab[i].dns_name[0];/*dns_full_name_tab[i];*/
    }

    return 0;   
};
/*------------------------------------------------------------------------
 * BOOLEAN_T  dns_static_host_init()
 * Purpose: intialize Static DNS Table
 *
 *          
 * Parameters:
 *    Input:
 *    Output:
 * returns :
 *------------------------------------------------------------------------
 */                    
void dns_static_host_init(void)
{
    memset(&dns_host_tab[0], 0, sizeof(struct static_dns_tab)*MAX_STATIC_DNS_NUM);                   
}    
/*------------------------------------------------------------------------
 * BOOLEAN_T  dns_set_static_host()
 * Purpose: Set Static DNS Table
 *
 *          
 * Parameters:
 *    Input:
 *    Output:
 * returns :
 *------------------------------------------------------------------------
 */                    
BOOLEAN_T dns_set_static_host(UI32_T addr,UI8_T *name,UI32_T name_size,BOOLEAN_T status ,UI32_T index)
{
    if (index >=DNSR_MAX_STATIC_TAB)	
        return FALSE;
        
	dns_host_tab[index].ip_addr = addr;        
	memcpy(dns_host_tab[index].dns_name, name ,name_size);        
	dns_host_tab[index].stat = status; 
	
	return TRUE;
}    

/*------------------------------------------------------------------------
 * dns_cache_ip_lookup()
 * Purpose: look up cache by name
 *          Returns status code.
 * Parameters:
 *    Input:
 *    Output:
 * returns :
 *------------------------------------------------------------------------
 */                       
static UI32_T dns_cache_ip_lookup(unsigned char *namebuf,PENDING_DNSR_MSG_PTR pMsg)
{
    struct  dns_rr *msg_rrs[DNS_MAX_RRS_PER_MSG];
    int     i,n_rrs;        
    UI32_T  ip_addr=0;        
    
    /*
     * Look in the cache.  Stop looping if we get anything but
     * a name error.
     */                        
    if ((n_rrs=dns_lookup(namebuf, pMsg->qclass, pMsg->qtype, msg_rrs, DNS_MAX_RRS_PER_MSG))<=0)        
        return 0 ;
        
        
    /* translate msg_rrs to ip */
    /*
     * Find all the A RRs, eliminating duplicates.
     */
    for (i = 0; i < n_rrs; ++i) 
    {
        if (msg_rrs[i]->class != DNS_C_IN ||
            msg_rrs[i]->type != DNS_T_A ||
            msg_rrs[i]->rdcount != 4)
            continue;
            
        ip_addr = dns_decode_bits32(msg_rrs[i]->rdata);            
        break;
    } /* for loop */
    
    return ip_addr;        
} /* dns_find_ip_at_table */
/*------------------------------------------------------------------------
 * dns_cache_name_lookup()
 * Purpose: lookup cache by ip
 *          
 * Parameters:
 *    Input:
 *    Output:
 * returns :
 *------------------------------------------------------------------------
 */                       
static I8_T *dns_cache_name_lookup(unsigned char *namebuf,int *ret_namelen,PENDING_DNSR_MSG_PTR pMsg)
{
    struct  dns_rr *msg_rrs[DNS_MAX_RRS_PER_MSG];    
    int     i,n_rrs;            
    char    name[DNS_MAX_DOMAIN_NAME];
    
    memset(&name[0],0x0,sizeof(name));
	/*
     * Look in the cache.  Stop looping if we get anything but
     * a name error.
     */                            
    if ((n_rrs=dns_lookup(namebuf, pMsg->qclass, pMsg->qtype, msg_rrs, DNS_MAX_RRS_PER_MSG))<=0)        
        return 0 ;
        
    /* translate msg_rrs to domain name */        
    /*
     * Find all the A RRs, eliminating duplicates.
     */
    for (i = 0; i < n_rrs; ++i) 
    {
        if (msg_rrs[i]->class != DNS_C_IN ||
            msg_rrs[i]->type != DNS_T_PTR)
            continue;
            
        /* check the max length of DNS name */
        if (msg_rrs[i]->rdcount >DNS_MAX_RRS_PER_MSG)
            return 0;
        memcpy(name, msg_rrs[i]->rdata, msg_rrs[i]->rdcount);    
        *ret_namelen = msg_rrs[i]->rdcount;
        return (I8_T*)&name[0];                
    } /* for loop */
    
    return 0;            
}
/*------------------------------------------------------------------------
 * BOOLEAN_T  dns_response_tx()
 * Purpose: direct to response DNS request packet without sending packet 
 *          to server
 *          
 * Parameters:
 *    Input:
 *    Output:
 * returns :
 *------------------------------------------------------------------------
 */                    
BOOLEAN_T dns_response_tx(PENDING_DNSR_MSG_PTR pMsg,   
                     int len, unsigned long addrs[],                     
                     unsigned char *name,
                     unsigned long ttls[]                     
                     )
{
    unsigned char *p,*pkt=NULL;
    int i,pkt_len=0;
            
    
    /* addr or name answers */
    switch (pMsg->qtype)
    {
      case DNS_T_A:  
        if((pkt = OS_mem_alloc(pMsg->qsec_len+DNS_HDR_LENGTH+16*len)) == NULL)
        {
#if DNSR_DEBUG
            DBG_L3_Printf("dns_response_tx: allocate memory failed!!\n") ;
#endif             
            return FALSE;
        }                             
            
            
        pkt_len =  pMsg->qsec_len+DNS_HDR_LENGTH+16*len;   
        dns_encode_bits32((unsigned char *)pkt + DNS_HDR_FLAGS,
                            DNS_FLD(pMsg->query_id, DNS_HDR_ID) | DNS_HDR_RD 
                            | DNS_HDR_RESP | DNS_HDR_RA);
        dns_encode_bits16((unsigned char *)pkt + DNS_HDR_QDCOUNT, 1);
        dns_encode_bits16((unsigned char *)pkt + DNS_HDR_ANCOUNT, 1);
        dns_encode_bits16((unsigned char *)pkt + DNS_HDR_NSCOUNT, 0);
        dns_encode_bits16((unsigned char *)pkt + DNS_HDR_ARCOUNT, 0);
        memcpy(pkt+DNS_HDR_LENGTH, pMsg->qsec_ptr, pMsg->qsec_len);                         
        p = (unsigned char *)pkt+DNS_HDR_LENGTH+pMsg->qsec_len;

        for (i = 0 ; i < len ; i++)   /* n addresses for answers */
        {
            dns_encode_bits16(p,0xc00c);
            p += 2;
            dns_encode_bits16(p, pMsg->qtype);
            p += 2;
            dns_encode_bits16(p, pMsg->qclass);
            p += 2;
            dns_encode_bits32(p, ttls[i]);              
            p += 4;
            dns_encode_bits16(p, 4);
            p += 2;
            dns_encode_bits32(p, addrs[i]);
            p += 4;
        } /* for loop */
        break;