dns_task.c.svn-base

域名解析器的实现

/***************************************************************************************
 *		Copyright c 2000 D-Link Corporation		All rights reserved.
 *
 *		This is unpublished proprietary source code of D-Link Corporation
 *
 *		The copyright notice above does not evidence any actual or intended 
 *		publication of such source code.
 ***************************************************************************************
 */
/* include files declaration */
#ifdef WIN32
#include <l3/port/inc/la3_mem.h>
#endif /* WIN32 */
#include <l3/inc/phase2.h>
#include <l3/port/inc/la3_port.h>

#include <l3/ap/dnsr/h/dns.h>
#include <l3/ap/dnsr/h/dnsr_if.h>
#include <l3/ap/dnsr/h/dnsr_db.h>
#include <l3/ip/inc/la3_ip.h>

/*-----------------------------------------------------------------------
 * Constants
 *-----------------------------------------------------------------------
 */
#define DNSR_EVT    0x2

/*-----------------------------------------------------------------------
 * Local Variables
 *-----------------------------------------------------------------------
 */  
/* Global variables */
static BOOLEAN_T               bDnsrReady;
static BOOLEAN_T               bDnsrReset;
#if 0
static OS_TASK_T           taskDNSR;
static OS_EVENT_T    dnsrEvent ; 
static LA3_OS_SEMAPHORE_T      dnsrSEMA;
#if L3_INC_BPR
static UI8_T                   DNSR_Stack[LA3_DNSR_TASK_STACK_SIZE];
#endif
#else
static OS_TASK_T       *taskDNSR;
static OS_EVENT_T        *dnsrEvent;
static void                 *dnsrSEMA;
#endif
/* Global config */
static struct dns_cfg          dns_config_db;
/* socket structure */
static I32_T 	               DnsrSocket;                         /* socket */
static BOOLEAN_T               socket_enabled = FALSE;


/*-----------------------------------------------------------------------
 * Functions
 *-----------------------------------------------------------------------
 */  
void DNSR_Task(UI32_T argc, void *argv) ;

static BOOLEAN_T _dnsr_socket_binding(void)
{
    struct sockaddr_in      src_addr;	

    if (socket_enabled)
        return FALSE;
        
    if ((DnsrSocket = socket(AF_INET4, SOCK_DGRAM,0)) < 0 )
    {
        /* fail to open a socket */
#if DNSR_DEBUG
            DBG_L3_Printf(" Fail to open a client Socket!!!\n");
#endif
        
        return FALSE;
    }
    
    memset((I8_T *)&src_addr, 0, sizeof(struct sockaddr_in));
    src_addr.sin_addr = 0;
    src_addr.sin_family = AF_INET4;
    src_addr.sin_port = DNS_NAMESERVER_PORT;
    
    if(bind(DnsrSocket, (struct sockaddr *)&src_addr, sizeof(src_addr)) < 0)
    {    	    	
   	    DBG_L3_Printf("LA3_DNSR: Initial bind error !!!!\n");
        return FALSE;
    }
        
    socket_enabled = TRUE;
    
    return TRUE;
}

/*
 * Shutdown DNS code by cleaning up all allocated storage.
 */

static void _dnsr_shutdown(void)
{                            
    s_close(DnsrSocket);                    /* close socket */  
    socket_enabled = FALSE;
}

static UI32_T Update_DNSR_Time(void)
{
    UI32_T cache_time ,query_time ;
    
    /* check cache status */
    cache_time = dns_check_cache();
    /* check the query list timeout */
    query_time = dnsr_check_query_id();  
    
    
    return ((query_time < cache_time ) ? query_time : cache_time) ;                    
} /* Update_DNSR_Time */


void DNSR_Task(UI32_T argc, void *argv)
{
    OS_STATUS_T         Status;    
    PENDING_DNSR_MSG_PTR    pMsg;
    UI8_T                   rcvbuff[DNSR_MAX_DATA_LEN];
    int                     rcvLen;     
    struct sockaddr         addrRemote;
    int                     addrlen;        
    fd_set                  readfds;    
    UI32_T                  suspendtime=OS_SUSPEND,ret_event,time;        
    struct dns_header       hdr;
    struct timeval          timeout;
    BOOLEAN_T               b_timeout;

    
    if (argc)   {}
    if (argv)   {}
    while (!LA3_IP_Get_TaskStatus())
        OS_Task_Sleep(10000); /* sleep 1 sec */
        
#ifdef WIN32
    {
        LA3_MEM_Register("DNSR", (UI32_T) OS_Task_GetCurrent());
    }
#endif

    /* Create BPR event group. */
#if 0
    Status = LA3_OS_Create_Event_Group(&dnsrEvent, "DNSR_EVENT");
    if (Status != OS_SUCCESS) 
    {
        DBG_L3_Printf("DNSR_Task: LA3_OS_Create_Event_Group failed!!\n") ;
        return ;
    } 
    /* create semaphore for arp table access protection */
    Status = LA3_OS_Create_Semaphore(&dnsrSEMA, "SEM_DNSR", 1, OS_FIFO);
    if (Status != OS_SUCCESS)
    {
        DBG_L3_Printf("DNSR_Task LA3_OS_Create_Semaphore: fail !!\n");
        return;
    }   
#else
    dnsrEvent = OS_Event_Create("DNSRelay");

	dnsrSEMA = OS_Semaphore_Create(BINARY_SEMAPHORE,1, "DNSR");
#endif

    
    /* initialize and allocate resources that DNSR needs */
    dnsr_init();    
        
    bDnsrReady = TRUE;  
    
    DBG_L3_Printf("DNSR_Task: Ready.\n");
          
    while(bDnsrReset == FALSE)
    {                                                    
        /* 
         * Wait event to 'enable' the DNS Relay Agent
         */
#if 0         
        Status = LA3_OS_Retrieve_Events(&dnsrEvent,
                                    (OS_STATUS_T) DNSR_EVT,
                                    OS_OR_CONSUME, 
                                    &ret_event, 
                                    suspendtime);    
#else
        Status = OS_Event_Retrieve(
                dnsrEvent, 
                DNSR_EVT,
                OS_OR_CONSUME,
                &ret_event,
                suspendtime);
#endif
                                    
        if (Status == OS_SUCCESS)
        {            
            if (dns_config_db.dns_stat) /* status is Enabled */
            {
                suspendtime = OS_NO_SUSPEND;            
                _dnsr_socket_binding();                    
            }            
            else
            {
                suspendtime = OS_SUSPEND;
                _dnsr_shutdown();    
            }                        
            continue;
        }                                    
                                    
        /* check timeout */                                    
        if ((time = Update_DNSR_Time()) < 0xffffffff)                                             
        {
            /* status is timeout */        
            b_timeout = TRUE;
            timeout.tv_sec  = time/1000; /* change unit msec to sec */
            timeout.tv_usec = (time%1000)*1000; /* change msec to usec */               
        }
        else
        {            
            b_timeout = FALSE;
            timeout.tv_sec = 0;            
            timeout.tv_usec = 0;
        }                    
        
        FD_ZERO(&readfds);
        FD_SET(DnsrSocket, &readfds);  
                
        if (b_timeout)
        {
            if (select(DnsrSocket+1, &readfds, (fd_set *)0, (fd_set *)0, &timeout) <= 0)                    
                continue;
        }
        else
        {
            if (select(DnsrSocket+1, &readfds, (fd_set *)0, (fd_set *)0, NULL) <= 0)                    
                continue;            
        }                            
                        
        /* test the bit for fd */
        if (!FD_ISSET(DnsrSocket,&readfds))
            continue;
        
        /* recieve pkt from socket API */
        addrlen = sizeof(addrRemote);
        rcvLen = recvfrom(DnsrSocket, &rcvbuff[0], sizeof(rcvbuff), 0,
                          (struct sockaddr *)&addrRemote, &addrlen);
                          
        /* check whether is have invaild length */
        if (rcvLen <=0 || rcvLen > DNSR_MAX_DATA_LEN)                  
            continue;
        
        if((pMsg = OS_mem_alloc(sizeof(PENDING_DNSR_MSG))) == NULL)
        {
#if DNSR_DEBUG
            DBG_L3_Printf("dnsr_rcv_callback: allocate memory failed!!\n") ;
#endif              
            continue;
        }                   
        memset(pMsg,0x0, sizeof(PENDING_DNSR_MSG));
        /* copy the pkt to the buffer */
        memcpy(&pMsg->udp_data[0], &rcvbuff[0], rcvLen);
        pMsg->udp_len   = rcvLen;
        memcpy(&pMsg->client, &addrRemote, sizeof(addrRemote));
            
                                
        if (dns_decode_header(pMsg->udp_data, pMsg->udp_len, &hdr) != DNS_ERROR_OK)
        {
#if DNSR_DEBUG
            DBG_L3_Printf("dns decode header error!!!\n") ;        
            DBG_L3_Printf("OS_mem_free: pMsg=%x\n", pMsg);
#endif

            OS_mem_free(pMsg);      
            continue ;    
        }
                                                                    
        if (hdr.resp)   
        {
            /* Receive DNS reply packet */
#if DNSR_DEBUG
            DBG_L3_Printf("DNSR_Task: dns_response_rx.\n") ;
#endif                    
            dns_response_rx(pMsg,&hdr);
        }
        else   
        {            
#if DNSR_DEBUG
            DBG_L3_Printf("DNSR_Task: dns_request_receive.\n");
#endif                    
            /* Receive DNS request packet */
            dns_request_receive(pMsg,&hdr);
        }            
    } /* while */
        
    _dnsr_shutdown();    
    /* signal LA3_DNSR_Terminate() to leave while loop */
    bDnsrReady = FALSE ;
    
    DBG_L3_Printf("DNSR_Task Terminate !!\n") ;
    
} /* DNSR_Task */


void LA3_DNSR_Init(void)
{
#if L3_INC_DNSR    
        
    /* reinitialize EEPROM */
    DNSR_DB_Init();    
    
    /* initialize TASK global status */
    bDnsrReady      = FALSE;
    bDnsrReset      = FALSE;    
    taskDNSR = OS_Task_Create(
        "DNS-R", 
        DNSR_Task, 
        0,
        NULL,
        LA3_DNSR_TASK_STACK_SIZE, /* stack size */
        LA3_DNSR_TASK_PRIORITY, 
        0,
        OS_NO_PREEMPT,
        OS_START
        );
            
#endif
    return;            
}

void LA3_DNSR_Terminate(void)
{   
    OS_STATUS_T status;
    
    DNSR_Set_Status(FALSE);

#if 0    
    status = LA3_OS_Set_Events(&dnsrEvent, (OS_STATUS_T) DNSR_EVT, OS_OR);
#else
    status = OS_Event_Set(
        dnsrEvent,
        DNSR_EVT,
        OS_OR);
#endif

    if(status != OS_SUCCESS) 
    {
        DBG_L3_Printf("LA3_DNSR_Terminate: LA3_OS_Set_Events failed!!\n") ;
    }
    
    /* Inform DNSR_Task to terminate */
    bDnsrReset = TRUE; 

    /* Wait DNSR_Task to terminate */
    while (bDnsrReady)
        OS_Task_Sleep(1000);
    
}


/*------------------------------------------------------------------------
 * void  DNSR_Restore_Config()
 * Purpose: restore config from EEPROM
 *          
 * Parameters:
 *    Input:
 *    Output:
 * returns :
 *------------------------------------------------------------------------
 */
void DNSR_Restore_Config(void)
{
    UI8_T i;
    DNSR_DB_Static_Table_T tmp;
    UI8_T              enable = FALSE;
        
    dns_config_db.n_servers				    = MAX_NAME_SERVER;
    dns_config_db.max_tries_per_server      = 1;        
    dns_config_db.max_ttl		            = MAX_DNS_CACHE_TTL;