ip网络层源码分析.txt

ip

struct ipfrag{
    int offset;//分片偏移
	int end;//最后个字节位置
    int len;//这个分片长度
	struct sk_buff*skb;//接收到的skb分片帧
	unsigned cahr*ptr;//指向分片数据
	struct ipfrag*next;
	struct ipfrag*prev;	
}

struct ipq{
    unsigned char* mac;//指向mac头
	struct iphdr*  iph;//指向ip头
	int  len;          //原整个数据长度
	short ihlen;       //ip头长度
	short maclen;      //mac头长度
	struct timer_list*timer;//此队列超时定时器
	struct ipfrag*fragment;//链接收到的帧
	struct  ipq*next;
	struct   ipq*prev;
	struct device*dev;//为了icmp回复的设备	
}

int ip_ioctl(struct sock*sk,int cmd,unsigned long arg)
{
   .....
}

ip选项处理函数
void ip_route_check(unsigned long daddr)
{...}
void strict_route(struct iphdr*iph,struct options*opt)
{...}
void loose_route(struct iphdr*iph,struct options*opt)
{...}

对待发送的数据包创建其需要的ip选项
int build_options(struct iphdr*iph,struct options*opt)
{
    //此版本不支持任何ip选项
	ptr=(unsigned char*)(iph+1);
	*ptr=0;
	return 4;
}


skb：待创建mac首部的skb
daddr:数据包下一站ip地址
len：ip首部及其负载长度
dev:发送设备接口
saddr：本地ip地址



int ip_send(struct sk_buff*skb,unsigned long daddr,int len,struct device*dev,unsigned long saddr)
{
    skb->dev=dev;
	skb->arp=1;//表示mac已经完成创建
    if(dev->hard_header)
	{
	    mac=dev->hard_header(skb->data,dev,ETH_P_IP,NULL,NULL,len,skb);
		if(mac<0)
		{
		    mac=-mac;
			skb->arp=0;//表示amc首部未创建
			skb->raddr=daddr;//下一跳路由地址			
		}
	}
	return mac;
}


int ip_build_header(struct sk_buff*skb,unsigned long saddr,unsigned long daddr,
                    struct device**dev,int type;struct options*opt,int len,int tos,int ttl)
{
    buff=skb->data;
	if(*dev==NULL)
	{
	    if(skb->localroute)//指定了是本地路由
		{
		    rt=ip_rt_local(daddr,optmem,&src); 
		}
		else
		    rt=ip_rt_route(daddr,optmem,&src); 
		if(rt==NULL)
            return -ENETUNREACH;
        dev=rt->rt_dev;
        if(LOOPBACK(saddr)&&!LOOPBACK(daddr))//源地址是回环地址但是远端地址不是则初始化源地址为src
        {
		    saddr=src;   
		}		
		raddr=rt->rt_gateway;
		opt=&optmem;	
	}
	else
	{
	    if(skb->localroute)//指定了是本地路由
		{
		    rt=ip_rt_local(daddr,optmem,&src); 
		}
		else
		    rt=ip_rt_route(daddr,optmem,&src); 
		if(rt==NULL)
            return -ENETUNREACH;
        dev=rt->rt_dev;
        if(LOOPBACK(saddr)&&!LOOPBACK(daddr))//源地址是回环地址但是远端地址不是则初始化源地址为src
        {
		    saddr=src;   
		}		
		raddr=(rt==NULL)?0:rt->rt_gateway; 
	}
	if(saddr==0)
	    saddr=src;
	if(raddr==0)
        raddr=daddr;//没有下一跳则初始化下一跳地址为目的主机地址
    tmp=ip_send(skb,raddr,len,*dev,saddr); //创建mac头
    buff+=tmp;
    len-=tmp;
    skb->dev=*dev;
    if(skb->sk)
        skb->sk->saddr=saddr;
    if(type==IPPROTO_RAW)
    {
	    return tmp; 
	}
	//初始化ip头
    iph=(struct iphdr*)buff;
    iph->version=4;
    iph->tos=tos;
    iph->frag_off=0;
    iph->ttl=ttl;
    iph->daddr=daddr;
    iph->saddr=saddr;
    iph->protocol=type;
    iph->ihl=5;//表示ip头为4*5
    skb->ip_hdr=iph;
    buiuld_options(iph,opt);
    return (20+tmp);//20ip头+tmp的mac头	     
}

struct options{
    struct route record_route;
	struct route loose_route;
	struct route strict_route;
	struct timestanmp  tstamp;
	unsigned short  security;
	unsigned short  compartment;
	unsigned short  handling;
	unsigned short  stream;
	unsigned tcc;

}

int  do_options(struct iphdr*iph,struct options*opt)//opt为解析出来的存储缓冲区
{
    //本版本不支持ipoptions
	return 0;

}

struct ipq*ipqueue=NULL;
创建一个ipfrag
struct ipfrag*ip_frag_create(int offset,int end,struct sk_buff*skb,unsigned char*ptr)
{
    fp=(struct ipfrag*)kamlloc(...);
	memset(...);
	//初始化ipfrag
	fp->offset=offset;
	fp->end=end;
	fp->len=end-offset;
	fp->skb=skb;
	fp->ptr=ptr;
	return fp;
}

根据ip首部查找分片所在队列
struct ipq*ip_find(struct iphdr*iph)
{
    for(qp=ipqueue;qp!=NULL;qplast=qp,qp=qp->next)
	{
	    if(iph->id==qp->iph->id&&iph->saddr==qp->iph->saddr&&iph->daddr==qp->iph->daddr&&iph->protocol==qp->iph->protocol)
		{//比对id、saddr、daddr、protocol;
		    del_timer(&qp->timer);
			return qp;
		} 
		
	}
	return NULL;
}

释放一个分片队列
void ip_free(struct ipq*qp)
{
    del_timer(&qp->timer);//要释放队列则删除定时器
	if(qp->prev==NULL)//说明此qp是首队列所以要移动ipqueue指向位置
	{
	    ipqueue=qp->next;
		if(ipqueue->prev!=NULL)
		     ipqueue->prev=NULL;
	} 
    else
    {
	    qp->prev->next=qp->next;
		if(qp->next!=NULL)//防止qp是队列最后一个元素
            qp->next->prev=qp->prev;		
	}	
	fp=qp->fragments;
	while(fp!=NULL)
	{
	    xp=fp->next;
		IS_SKB(fp->skb);
		kfree_skb(fp->skb,FREE_READ);
		kfree_s(fp,sizeof(struct ipfrag));
		fp=xp;
	}//释放一个分片队列中所有的已经收到的帧
	kfree_s(qp->iph,qp->ihlen+8)//释放qp队列中的ip头空间
	kfree_s(qp,sizeof(struct ipq));//释放ipq
}

处理分片重组超时
void ip_expire(unsigned long arg)
{
    qp=(struct ipq*)arg;
	if(qp->fragments!=NULL)//若存在已接收到分片则发送icmp告知对方
	    icmp_send(qp->fragments->skb,ICMP_TIME_EXCEEDED,ICMP_EXC_FRAGTIME,0,qp->dev);
	ip_free(qp);//释放pq	
}

创建ipq
struct ipq*ip_create(struct sk_buff*skb,struct iphdr*iph,sturct device*dev)
{
    qp=(struct ipq*)kamlloc(sizeof(struct ipq),...);
	memset(qp,0,sizeof(struct ipq));
	//分配mac地址空间
	maclen=((unsigned long )iph) -((unsigned long )skb->data);
	qp->mac=(unsigned char*)klamlloc(maclen,...);
	//分配iph头空间
	ihlen=(iph->ihl*sizeof(unsigned long));
	qp->iph=(struct iphdr*)kmalloc(ihlen+8,...);
	memcpy(qp->mac,skb->data,maclen);
	memcpy(qp->iph,iph,ihlen+8);
	//初始化
	qp->len=0;
	qp->ihlen=ihlen;
	qp->maclen=maclen;
	qp->fragments=NULL;
	qp->dev=dev;
	//初始化定时器
	qp->timer.expires=IP_FRAG_TIME;
	qp->timer.data=(unsigned long)qp;
	qp->timer.funtion=ip_expire;
	add_timer(&qp->timer);
	qp->prev=NULL;
	//插入ipqueue队列首
	qp->next=ipqueue;
	if(qp->next!=NULL)
	    qp->next->prev=qp;
	ipqueue=qp;
    return qp;		
}

检查是否所有分片都已到达
int ip_done(struct ipq *qp)
{
    if(qp->len==0)//当最后一个分片到达时会被初始化如果为0说明最后一个分片未到达
	   return 0;
	fp=qp->fragments;
    offset=0;    
	while(fp!=NULL)
	{
	    if(fp->offset>offset)//从小到大排列第一个offsset==0,
		//连续是第二个分片offset==第一个的end，所以大于则是出现断裂正常是相等
	        return 0;//未到达完全出现断续
	    offset=fp->end;
        fp=fp->next;		
	}
	return 1;//所有分片都已到达
}

重组所有分片
struct sk_buff*ip_glue(struct ipq*qp)
{
    //获取原数据包总长度
	len=qp->maclen+qp->ihlen+qp->len;
	skb=alloc_skb(len,...);
	skb->len=len-qp->maclen;//初始化skb的len为ip头及其负载长度之和
	skb->h.raw=skb->data;
	skb->free=1;
	ptr=(unsigned char*)skb->h.raw;
	memcpy(ptr,((unsigned char*)qp->mac),qp->maclen);
	ptr+=qp->maclen;
	memcpy(ptr,(()unsigned char*)qp->iph,qp->ihlen);
	ptr+=qp->ihlen;
	skb->h.raw+=qp->maclen;//初始化h.raw指向ip头
	fp=qp->fragments;
	count=0;
	while(fp!=NULL)
	{
	    if(count+fp->len>skb->len)
		{
		    .....//出错
		   return NULL;
		}
	    memcpy((ptr+fp->offset),fp->ptr,fp->len);//拷贝数据
        count+=fp->len;
        fp=fp->next;		
	}
	ip_free(qp);
	iph=skb->h.iph;
	iph->frag_off=0;
	iph->tot_len=htons((iph->ihl*sizeof(unsigned long ))+count);//ip头及其负载长度
	skb->ip_hdr=iph;
	return skb;
}

ip分片数据包处理总入口函数
struct sk_buff*ip_defrag(struct iphdr*iph,sturct sk_buff*skb,struct device*dev)
{
    qp=ip_find(iph);//查找是否已存在队列
	offset=ntohs(iph->frag_off);//标志占高三位偏移占低13位
	flags=offset&~IP_OFFSET;
	offset&=IP_OFFSET（0x1fff）;//获取偏移字段
	if((flags&IP_DF)==0&&(offset==0))//df为0且offset为0 则不是分片
	{
	    if(qp!=NULL)
		    ip_free(qp);
		return skb;
	}
	offset<<=3;//偏移字段是8字节倍数所以*8；
	if(qp!=NULL)
	{//更新定时器
	    del_timer(&qp->timer);
		qp->timer.expires=IP_FRAG_TIME;//30s
		qp->timer.data=(unsigned long )qp;
		qp->timer.function=ip_expire;
		add_timer(qp->timer);
		
	}
	else
	{
	    if(qp=ip_create(skb,iph,dev)==NULL)//是第一个到达的分片不一定是第一个分片
		{
		   skb->sk=NULL;
		   kfree_skb(skb,FREE_READ);
		   return NULL;
		}
	}
	ihl=(iph->ihl*sizeof(unsigned long));
	end=offset+ntohs(iph->tot_len-ihl);//计算此数据包ip负载长度 。最后一个数据偏移量+1
	ptr=skb->data+dev->hard_header_len+ihl;
	if((flags&IP_MF)==0)//MF标志位位0 表示这是个最后分片
	    qp->len=end;//最后个分片到达则可以获取 整个未分片的数据包负载长度
	prev=NULL;
    for(next=qp->fragments;next!=NULL;next=netx->next)
    {
	    if(next->offset>offset)//顺序插入小的在队列前面
		   break;
		prev=nex;   	   
	}	
	if(prev!=NULL&&offset<prev->end)//队列存在偏移量大于此分片的数据分片包
	{
	    i=prev->end-offset;//if语句保证i>0表示重复
		offset+=i;
		ptr+=i;//去除重复的
	}
	for(;next!=NULL;next=tfp)
	{
	    tfp=next->next;
		if(next>offset>=end)//下一个已接收的分片的起始值大于等于此数据包结束说明不存在数据重叠
		    break;
		//否则
		i=end->next->offset;
		next->len-=i;
		next->offset+=i;
		next->ptr+=i;
	    if(next->len<=0)//表示整个数据包数据都是重复
	    {
	        if(next->prev!=NULL)
		        next->prev->next=next->next;
			else
            qp->fragments=next->next//删除此数据包
            if(tfp->next!=NULL)//更新删除分片的下一个分片的prev
                 next->next->prev=next->prev;
			kfree_skb(next->skb,FREE_READ);
			kfree_s(next,sizeof(struct ipfrag));  				 
	    }
	}	
	tfp=NULL;
	tfp=ip_create_frag(offset,end,skb,ptr);
	tfp->prev=prev;
	tfp->next=next;
	if(prev!=NULL)
	    prev->next=tfp;
	if(next!=NULL)
        next->prev=tfp;
    if(ip_done(qp))
	{
	    skb2=ip_glue(qp);
		return skb2;
	}
	return NULL;    	
}

ip分片
如果是本地发送的数据包则is_frag是0
if(is_frag&1)为真说明是个中间分片
if(is_frag&2)为真说明是最后分片
void ip_fragment(struct sock*sk,sk_buff*skb,struct device*dev,int is_frag)
{
    raw=skb->data;
	iph=(struct iphdr*)(raw+dev->hard_header_len);
	skb->ip_hdr=iph;
	hlen=(iph->ihl*sizeof(unsigned long));
	left=ntohs(iph->tot_len)-hlen;
	hlen+=dev->hard_header_len;
	mtu=dev->mtu-hlen;
	ptr=raw+hlen;
	if(ntohs(iph->fragoff)&IP_DF)//设置了不允许分片
	{
	    icmp_send(skb,ICMP_DEST_UNRACH,ICMP_FRAG_NEEDED,dev->mtu,dev);
		return ;		
	}
	if(mtu<8)//网卡mtu设置过小
	{
	    icmp_send(skb,ICMP_DEST_UNRACH,ICMP_FRAG_NEEDED,dev->mtu,dev);
		return ;		
	}
	if(is_frag&3)
	    offset=(ntohs(iph->frag_off)&0x1fff)<<3;//读取原数据包的分片偏移
	else
        offset=0;
    while(left>0)
    {
	    if(len>mtu)
		   len=mtu;
		if(len<left)
        {
		   len/=8;//len只能是8的倍数的最大数
		   len*=8; 
		}		
		skb2=alloc_skb(len+hlen,..);
		skb2->arp=skb->arp;
		if(skb->free==0)
		   BUG_ON...
		skb2->free=1;
       	skb2->len=len+hlen;
        skb2->raw=(cahr*)skb2->data;
		if(sk)
		{
		    sk->wmem_alloc+=skb2—>mem_len;
			skb2->sk=sk;
		}
		skb2->raddr=skb->raddr;
		memcpy(skb2->raw,raw,hlen);//拷贝ip头+mac头
		memcpy(skb2->h.raw+hlen,ptr,len);//hlen为ip头+mac头
		left-=len;
		skb2->raw+=dev->hard_header_len;
		iph=(struct iphdr*)(skb2->h.raw);
		iph->frag_off=htons(offset>>3);
		if(left>0||(if_frag&1))//除了最后分片其他所有分片都要设置IP_MF
		    iph->frag_off|=htons(IP_MF);
		ptr+=len;	
		offset+=len;
		ip_queue_xmit(sk,dev,skb2,2);		
	}		
}


skb待转发数据包
dev接收skb的设备
if_frag分片包标志
void  ip_forward(struct sk_buff*skb,struct device*dev,int is_frag)
{
    。。。规则链检查
	iph=skb->h.iph;
	iph->ttl--;
	if(iph->ttl<=0)
	{
	    icmp_send(skb,ICMP_TIME_EXCEEDED,ICMP_EXC_TTL,0,dev);
		return ;
	}
	ip_send_check(skb);//由于ttl改变所以重新计算效验值
	rt=ip_rt_route(iph->daddr,NULL,NULL);
	if(rt==NULL)
	{
	    icmp_send(skb,ICMP_DST_UNREACH,,ICMP_NET_UNREACH,0,dev);
		return ;
	}
	raddr=rt->rt_gateway;
	if(raddr!=0)//说明是远程链路继续查找下一跳路由
	{
	    rt=ip_rt_route(raddr,NULL,NULL);
	    if(rt==NULL)
	    {
	        icmp_send(skb,ICMP_DST_UNREACH,,ICMP_NET_UNREACH,0,dev);
		    return ;
	    }
		if(rt->rt_gateway!=0)//此处应该是0不是0则可能是进入一个路由循环，处理简单是将
		    raddr=rt_gateway;			
	}
	else
	{
	    raddr=iph->daddr;//没有下一跳，
	}
	dev2=rt->rt_dev;
	if(dev2==dev&&(iph->saddr&dev->pa_mask)==(iph->daddr&dev->pa_mask))
	     icmp_send(skb,ICMP_REDIRECT,ICMP_REDIR_HOST);出口设备和接收设备是
		                        //同个设备且是同个网段则说明下一站在同个链路上
	if(dev2->flags&IFF_UP)
    {
	    skb2=alloc_skb(dev2->hard_header_len+skb->len,...);
		ptr=-skb->data;
		skb2->free=1;
		skb2->len=skb->len+dev->hard_header_len;
		skb2->h.raw=ptr;
		memcpy(ptr+dev2->hard_header_len,skb->h.raw,skb->len);
		ip_send(skb2,raddr,skb->len,dev2,dev2->pa_addr);//重新构造raddr的mac数据包头
		if(skb2->len>dev2->hard_header_len+dev2->mtu)
		{
		   ip_fragment(NULL,skb2,dev2,is_frag);//分片
		   kfree_skb(skb2,FREE_READ);
		}
		else
		{
		   dev_queue_xmit(skb2,dev2,..);
		}
	}	
}
struct packet_type
{
    unsigned short type;//协议号
	sturct device *dev;
	int (fun*)(sturct sk_buff*skb,struct device*dev,struct packet_type*);
	void*data;
	struct packet_type*next;
}

ptype_base保存所有的网络层协议

int ip_rcv(struct sk_buff*skb,struct device*dev,sturct packet_type*pt)
{
    ...变量初始化
    iph=skb->h.iph;
	skb->ip_hdr=iph;
	if(skb->len<sizeof(struct iphdr)||iph->ihl<5||iph->version!=4||ip_fast_csum((unsigned char*)iph,iph->ihl)!=0)
	{//参数效验
	    kfree_skb(skb,FREE_READ);
		return 0;
	}
	...iptables检测
	if(iph->ihl!=5)
	{//说明存在ip选项
	   memset((cahr*)&opt,0,sizeof(opt));
	   if(do_options(iph,&opt)!=0)
	        return 0
		opts_p=1;	
	}
	if(iph->frag_off)
	{
	    if(iph->frag_off&0x0020)
		    is_frag|=1;//中间分片
		if(iph->frag_off&0x1fff)
             is_frag|=2;		
	}
	if(iph->daddr!=skb->dev->pa_addr&&(brd=ip_chk_addr(iph->daddr))==0)
	{//目的地址不是接收设备的地址
	    if(skb->pkt_type!=PACKET_HOST||brd==IS_BROADCAST)//不支持广播转发
		{
		    kfree_skb(skb,FREE_READ);
			return 0;
		}
		ip_forward(skb,dev,is_frag);
		kfree_skb(skb,FREE_READ);
		return 0;
	}
	if(brd==IS_MULTICAST&&iph->daddr!=IGMP_ALL_hOSTS&&!(dev->flags&IFF_LOOPBACK))
	{
	    ip_mc=dev->ip_mc_list;
		do{
		    if(ip_mc==NULL)
			{
			    kfree_skb(skb,FREE_READ);
				return 0;
			}
			if(ip_mc->multiaddr==iph->daddr)
			{//是我们的多播组
			     break;	 
			}
			ip_mc=ip_mc->next;		
		}while(1)
	}
	if(is_frag)//分片数据包
	{
	    skb=ip_defrag(iph,skb,dev);
		if(skb==NULL)
		    return 0;//没有完全到达
		skb->dev=dev;
        iph=skb->h.iph;		
	}
	skb->ip_hdr=iph;
	skb->h.raw+=iph->ipl*4;//将iph->h.raw指向传输层首部
	hash=iph->protocol&(SOCK_ARRAY_SIZE-1);
	if((raw_sk=raw.prot.sock_array[hash])!=NULL)
	{
	    raw_sk=get_sock_raw(raw_sk,hash,iph->saddr,iph->daddr);
		if(raw_sk)
		{
		  do{
		    sknext=get_sock_raw(raw_sk->next,hash,iph->saddr,iph->daddr);
			if(sknext)
			    skb1=skb_clone(skb,...);
			else
                break;
            if(skb1)
                raw_rcv(raw_sk,skb1,dev,iph->saddr,iph->daddr);//递交给raw套接字
            raw_sk=sknext;				
		   while(raw_sk!=NULL);	
		}
	}
	hash=iph->protocol&(MAX_INET_PROTOS-1);
	for(ipprot=(sstruct inet_protocol*)inet_protos[hash];ipprot!=NULL;ipprot=(struct inet_protocol*)ipprot->next)
	{
	    if(ipprot->protocol!=iph->protocol)
		    continue;
		if(ipprot->copy||raw_sk)//存在同样的协议或者是存在raw_sk都要clone一份skb	
		{
		    skb2=skb_clone(skb,...);
			if(skb2=NULL)
			    continue;	
		}
		else
		    skb2=skb;
		flag=1;
        ipprot->handler(skb2,dev,opts_p? &opt:0,iph->daddr,(ntohl(iph->tot_len)-iph->ihl*4),
		                iph->saddr,0,ipprot);		
	}
	if(raw_sk!=NULL)//存在最后一个raw_sk没有调用rcv接收
	{
	    raw_rcv(raw_sk,skb,dev,iph->saddr,iph->daddr);
	}
	else if(!flag)//没有对应的协议
	{
	    if(brd!=IS_BROADCAST&&brd!=IS_MULTICAST)
		    icmp_send(skb,ICMP_DEST_UNRACH,ICMP_PORT_UNRACH,0,dev);
		kfree_skb(skb,FREE_WRITE);	
	}
	return 0;
}

本地数据包回送接口
void ip_loopback(struct device*old_dev,struct sk_buff*skb)
{
    dev=&loopback_dev;
	len=skb->len-old_dev->hard_header_len;//获取ip及其负载长度
	newskb=alloc_skb(len+dev->hard_header_len,...);//获取新的skb
	//初始化新的skb
	newskb->link3=NULL;
	newskb->sk=NULL;
	newskb->dev=dev;newskb->saddr=skb->saddr;
	newskb->daddr=skb->daddr;
	newskb->raddr=skb->raddr;
	newskb->free=1;
	newskb->lock=0;
	newskb->users=0;
	newskb->pkt_type=skb->pkt_type;
	newskb->len=len+dev->hard_header_len;
	newskb->ip_hdr=(struct iphdr*)(newskb->data+ip_send(newskb,skb->ip_hdr->daddr,len
	             ,dev,skb->ip_hdr->saddr));
	memcpy(newskb->ip_hdr,skb->ip_hdr,len);
    ip_queue_xmit(NULL,devnewskb,1);	
	
}

传输层网络发送接口
void ip_queue_xmit(sturct sock*sk,struct device*dev,sturct sk_buff*skb,int free)
{
    if(dev==NULL)
	    return ;
	IS_SKB(skb);
    skb->dev=dev;
    skb->when=jiffies;
    ptr=skb->data;
    ptr+=dev->hard_header_len;
    iph=(struct ip_hdr*)ptr;
    skb->ip_hdr=iph;
    iph->tot_len=ntohs(skb->len-dev->hard_header_len);
	...iptables检查
	if(free!=2)//free=2表示是个分片数据包
	    iph->ip=htons(ip_id_count++);
	else	
	    free=1;//是分片包则不更新iph中的id
	if(sk==NULL)
        free=1;//没有套接字不需要缓存
	skb->free=free;
    if(skb->len>dev->mtu+dev->hard_header_len)
    {
	    ip_fragment(sk,skb,dev,0);
		IS_SKB(skb);
		kfree_skb(skb,FREE_WRITE);
		return ;
	}	
	ip_send_check(iph);
	if(skb->next!=NULL)
	{
	    skb_unlink(skb);
	}
	if(!free)//缓存
	{
	    sk->packet_out++;
		if(skb->link3!=NULL)
		{
		    skb->link3=NULL;
		}
		if(sk->send_head==NULL)
		{
		    sk->send_tail=skb;
			sk->send_head=skb;
		}
		else
		{
		    sk->send_tail->link3=skb;
			sk->send_tail=skb;
		}
	}
	else
	    skb->sk=sk;
		
    if(MULTICAST(iph->daddr)&&!(dev->flags&IFF_LOOPBACK))//发送设备不是环回设备防止循环
    {
	    if(sk==NULL||sk->ip_mc_loop)
		{
		    if(iph->daddr==IGMP_ALL_HOST)
		        ip_loopback(dev,skb);//复制一份给本机
			else
            {   
			   imc=dev->ip_mac_list;
			   while(imc!=NULL)
			   {
			        if((imc->multiaddr)==iph->daddr)//多播拷贝
			        {
			            ip_loopback(dev,skb);
				        break;
			       }
			       imc=imc->next;	
               }			   
			} 			
		}
		if(skb->ip_hdr->ttl==0)
		{
		   kfree_skb(skb,FREE_READ);
		   return;
		}
	}
	if((dev->flags&IFF_BROADCAST)&&iph->daddr==dev->pa_brdaddr&&!(dev->flags&IFF_LOOPBACK))
	    ip_loopback(dev,skb);//广播复制一份给本机
    if(dev->flags&IFF_UP)
    {
	    if(sk!=NULL)
		    dev_queue_xmit(skb,dev,sk->priority);
		else
            dev_queue_xmit(skb,dev,SOPRI_NORMAL);
        			
	}	
	else
	{
	    if(free)
		   kfree_skb(skb,FREE_WRITE);
	}
    	
}

int ip_rt_event(unsigned long event,void*ptr)
{
    if(event==NETDEV_DOWEN)
	    ip_rt_flush(ptr);
	return NOTIFY_DONE;	
}

void ip_init(void)
{
   ip_packet_type.type=htons(ETH_P_IP);
   dev_add_pack(&ip_packet_type);
   ip_raw_init();
   ip_packet_init();
   ip_tcp_init();
   ip_udp_init();  
}