netsocket.c

DM642上的TCP/IP代码 LWIP 是TCP/ IP 在嵌入式系统中应用很多的代码

#include "NetSocket.h"
#include "Socketkernel.h"
#include "ETH.h"
#include "ip.h"
#include "udp.h"
#include "skbuff.h"
#include "tcp/tcp.h"


static struct SOCKTASK Task[TASKMAX];
static int socket_init_flag=0;
static Uint32 local_ip = 0;

int net_handle(unsigned char *pBuf,unsigned int Len)
{
	struct sk_buff skb;
	struct ethhdr *eth_hdr;	
	Uint32 i;	

    skb_init(&skb,pBuf);
    
	eth_hdr = (struct ethhdr *)(skb.data);	
					
	skb_pull(&skb, ETH_HLEN);
	
	i=eth_hdr->h_proto[1];
	i=(i<<8);
	i=i+eth_hdr->h_proto[0];
	i=ntohs(i);			
	if (i == ETH_P_ARP)
	{				
		arp_rcv_packet(&skb);
	}			
	else if(i== ETH_P_IP)
	{						
		ip_rcv_packet(&skb);
	}
	
	return 0;
}

int  net_init(Uint32 IP_ADDRESS)
{
     unsigned char eth_addr[ETH_ALEN];
     Uint32 i;
     for(i=0;i<TASKMAX;i++)
     {
         memset(Task[i],0,sizeof(struct SOCKTASK));
     }
     
     eth_init();
	 eth_get_addr(eth_addr);
	 arp_init();
	 ip_init(IP_ADDRESS);	
	 udp_init();
	 arp_add_entry(eth_addr, (Uint8 *)(&IP_ADDRESS));
	 mem_init();
	 memp_init();
	 netif_init();
	 pbuf_init();
	 tcp_init();
	 local_ip = IP_ADDRESS;
	 socket_init_flag=1;
	 
	 return 0;
}

int  config_ip(Uint32 IP_ADDRESS)
{
     Uint32 i;
     
     local_ip = IP_ADDRESS;
     
     for(i=0;i<TASKMAX;i++)
     {
         if(Task[i].idle_tag==1)
         {
             Task[i].ip_address=local_ip;
         }  
     } 
     
     return 0;
}

SOCKET  socket (int af, int type, int protocol)
{
    Uint32 i;
    
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    for(i=0;i<TASKMAX;i++)
    {
        if(Task[i].idle_tag==0)
        {
             break;
        }  
    }
    
    if(i==TASKMAX)
    {
        return -1;
    }
    
    Task[i].idle_tag=1; 
    
    if(protocol==0)
    {
        Task[i].protocol=UDP; 
    }
    else
    {
        Task[i].protocol=protocol; 
    }
    
    return i;
}

SOCKET accept(SOCKET s, struct sockaddr  *addr, int  *addrlen)
{
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    return 0;
}

int bind(SOCKET s, const struct sockaddr_in  *addr, int namelen)
{
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    if(s<0)
    {
        return -1;
    }
    
    Task[s].sin_port=addr->sin_port;
    
    if(addr->sin_addr.s_addr==INADDR_ANY)
    {
        Task[s].ip_address=local_ip;
    }
    else
    {
        Task[s].ip_address=addr->sin_addr.s_addr;
    }
   
    return 0;
}


int listen(SOCKET s,int backlog)
{
     struct tcp_pcb pcb;
     
     if(socket_init_flag==0)
     {
        return -1;
     }
     if(s<0)
     {
        return -1;
     }
     memset(&pcb,0,sizeof(struct tcp_pcb));
     pcb.local_ip=Task[s].ip_address;
     pcb.local_port=Task[s].sin_port;
     tcp_listen(&pcb);    
     return 0;
     
}

int MsgAsyncSelect(SOCKET s,int Message,void (*fp)(void))
{
    if(socket_init_flag==0)
    {
         return -1;
    }
    
    if(s<0)
    {
       return -1;
    }
    
    Task[s].Msg=Task[s].Msg|Message;
    Task[s].fp=fp;
    return 0;
}

int MsgAsynEvent(int Message)
{
    Uint32 i;
    if(socket_init_flag==0)
    {
         return -1;
    }
    
    for(i=0;i<TASKMAX;i++)
    {
        if(Task[i].idle_tag==1)
        {
             if(0!=(Message&Task[i].Msg))
             {
                 (*(Task[i].fp))();
             }
        }  
    }
    return 0;
}


int closesocket (SOCKET s)
{   
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    if(s<0)
    {
       return -1;
    }
    
    memset(Task[s],0,sizeof(struct SOCKTASK));   
 
    return 0;
}

int connect (SOCKET s, const struct sockaddr  *name, int namelen)
{
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    return 0;
}

int  recv (SOCKET s, char  * buf, int len, int flags)
{
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    return 0;
}

int  recvfrom (SOCKET s, char * buf, int len, int flags, \
               struct sockaddr_in *from, int *fromlen)
{
    extern Uint8  *pgRcvBuff;
    struct iphdr  *ip_hdr;
    struct udphdr *udp_hdr;
    Uint8  *pTmp;
    Uint32 i;
    
    
    if(socket_init_flag==0)
    {
        return -1;
    }
    
    if(s<0)
    {
       return -1;
    }
    
    if(pgRcvBuff==0)
    {
       return -1;
    }
    
    ip_hdr = (struct iphdr *)pgRcvBuff;
	i=ip_hdr->saddr[3];
	i=(i<<8);
	i=i+ip_hdr->saddr[2];
	i=(i<<8);
	i=i+ip_hdr->saddr[1];
	i=(i<<8);
	i=i+ip_hdr->saddr[0];
	from->sin_addr.s_addr=ntohl(i);
	
	pTmp=pgRcvBuff+sizeof(struct iphdr);
    udp_hdr=(struct udphdr *)pTmp;
   
    from->sin_port=ntohs(udp_hdr->source);
	
	if(udp_hdr->dest!=ntohs(Task[s].sin_port))
	{
	    return -1;
	}
	
	pTmp=pTmp+sizeof(struct udphdr);
	
	*fromlen=ntohs(udp_hdr->len)-sizeof(struct udphdr);
	
	if(len<*fromlen)
	{ 
	    memcpy(buf,pTmp,len);
	    
	    pgRcvBuff=0;
	    
	    return len;
	}
	else
	{
	    memcpy(buf,pTmp,*fromlen);
	    
	    pgRcvBuff=0;
	    
	    return *fromlen;
	}
	
}
         
int  send (SOCKET s, const char * buf, int len, int flags)
{   
    if(socket_init_flag==0)
    {
        return -1;
    }
    	
    return 0;
}

int  sendto (SOCKET s, const char * buf, int len, int flags, \
                       const struct sockaddr_in  *to, int tolen)
{
    Uint8   *DesData;
    struct  sk_buff skb;
    Uint32  TrueLen;
    
 
    if(alloc_skb(&skb,ETH_FRAME_LEN)==-1)
    {
        return -1;
    }
	udp_skb_reserve(&skb);
	
	TrueLen=(skb.truesize>len)?len:SOCKFRAMESIZE;  
	DesData=(Uint8 *)skb_put(&skb,TrueLen);
	memcpy(DesData,buf,TrueLen); 
	
	if(udp_send(&skb,to->sin_addr.s_addr,Task[s].sin_port, to->sin_port)==-1)
	{
	    free_skb(&skb);
	    return -1;
	}
	
    return TrueLen;
}