net/ipv4/ip_output.c




/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* The Internet Protocol (IP) output module.
*
* Version: @(#)ip.c 1.0.16b 9/1/93
*
* Authors: Ross Biro, <[e-mail]>
* Fred N. van Kempen, <[e-mail]>
* Donald Becker, <[e-mail]>
* Alan Cox, <[e-mail]>
* Richard Underwood
* Stefan Becker, <[e-mail]>
* Jorge Cwik, <[e-mail]>
* Arnt Gulbrandsen, <[e-mail]>
*
* See ip_input.c for original log
*
* Fixes:
* Alan Cox : Missing nonblock feature in ip_build_xmit.
* Mike Kilburn : htons() missing in ip_build_xmit.
* Bradford Johnson: Fix faulty handling of some frames when
* no route is found.
* Alexander Demenshin: Missing sk/skb free in ip_queue_xmit
* (in case if packet not accepted by
* output firewall rules)
*/

#include <asm/segment.h>
#include <asm/system.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/config.h>

#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>

#include <net/snmp.h>
#include <net/ip.h>
#include <net/protocol.h>
#include <net/route.h>
#include <net/tcp.h>
#include <net/udp.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/arp.h>
#include <net/icmp.h>
#include <net/raw.h>
#include <net/checksum.h>
#include <linux/igmp.h>
#include <linux/ip_fw.h>
#include <linux/firewall.h>
#include <linux/mroute.h>
#include <net/netlink.h>

/*
* Loop a packet back to the sender.
*/

static void ip_loopback(struct device *old_dev, struct sk_buff *skb)
{
struct device *dev=&loopback_dev;
int len=ntohs(skb->ip_hdr->tot_len);
struct sk_buff *newskb=dev_alloc_skb(len+dev->hard_header_len+15);

if(newskb==NULL)
return;

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;

/*
* Put a MAC header on the packet
*/
ip_send(NULL,newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr);
/*
* Add the rest of the data space.
*/
newskb->ip_hdr=(struct iphdr *)skb_put(newskb, len);
memcpy(newskb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));

/*
* Copy the data
*/
memcpy(newskb->ip_hdr,skb->ip_hdr,len);

/* Recurse. The device check against IFF_LOOPBACK will stop infinite recursion */

/*printk("Loopback output queued [%lX to %lX].\n", newskb->ip_hdr->saddr,newskb->ip_hdr->daddr);*/
ip_queue_xmit(NULL, dev, newskb, 1);
}



/*
* Take an skb, and fill in the MAC header.
*/

int ip_send(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
{
int mac = 0;

skb->dev = dev;
skb->arp = 1;
skb->protocol = htons(ETH_P_IP);
if (dev->hard_header)
{
/*
* Build a hardware header. Source address is our mac, destination unknown
* (rebuild header will sort this out)
*/
skb_reserve(skb,(dev->hard_header_len+15)&~15); /* 16 byte aligned IP headers are good */
if (rt && dev == rt->rt_dev && rt->rt_hh)
{
memcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
if (rt->rt_hh->hh_uptodate)
return dev->hard_header_len;
#if RT_CACHE_DEBUG >= 2
printk("ip_send: hh miss %08x via %08x\n", daddr, rt->rt_gateway);
#endif
skb->arp = 0;
skb->raddr = daddr;
return dev->hard_header_len;
}
mac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
if (mac < 0)
{
mac = -mac;
skb->arp = 0;
skb->raddr = daddr; /* next routing address */
}
}
return mac;
}

static int ip_send_room(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
{
int mac = 0;

skb->dev = dev;
skb->arp = 1;
skb->protocol = htons(ETH_P_IP);
if (dev->hard_header)
{
skb_reserve(skb,MAX_HEADER);
if (rt && dev == rt->rt_dev && rt->rt_hh)
{
memcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
if (rt->rt_hh->hh_uptodate)
return dev->hard_header_len;
#if RT_CACHE_DEBUG >= 2
printk("ip_send_room: hh miss %08x via %08x\n", daddr, rt->rt_gateway);
#endif
skb->arp = 0;
skb->raddr = daddr;
return dev->hard_header_len;
}
mac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
if (mac < 0)
{
mac = -mac;
skb->arp = 0;
skb->raddr = daddr; /* next routing address */
}
}
return mac;
}

int ip_id_count = 0;

/*
* This routine builds the appropriate hardware/IP headers for
* the routine. It assumes that if *dev != NULL then the
* protocol knows what it's doing, otherwise it uses the
* routing/ARP tables to select a device struct.
*/
int ip_build_header(struct sk_buff *skb, __u32 saddr, __u32 daddr,
struct device **dev, int type, struct options *opt,
int len, int tos, int ttl, struct rtable ** rp)
{
struct rtable *rt;
__u32 raddr;
int tmp;
struct iphdr *iph;
__u32 final_daddr = daddr;


if (opt && opt->srr)
daddr = opt->faddr;

/*
* See if we need to look up the device.
*/

#ifdef CONFIG_IP_MULTICAST
if(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
*dev=dev_get(skb->sk->ip_mc_name);
#endif
if (rp)
{
rt = ip_check_route(rp, daddr, skb->localroute);
/*
* If rp != NULL rt_put following below should not
* release route, so that...
*/
if (rt)
atomic_inc(&rt->rt_refcnt);
}
else
rt = ip_rt_route(daddr, skb->localroute);


if (*dev == NULL)
{
if (rt == NULL)
{
ip_statistics.IpOutNoRoutes++;
return(-ENETUNREACH);
}

*dev = rt->rt_dev;
}

if ((LOOPBACK(saddr) && !LOOPBACK(daddr)) || !saddr)
saddr = rt ? rt->rt_src : (*dev)->pa_addr;

raddr = rt ? rt->rt_gateway : daddr;

if (opt && opt->is_strictroute && rt && (rt->rt_flags & RTF_GATEWAY))
{
ip_rt_put(rt);
ip_statistics.IpOutNoRoutes++;
return -ENETUNREACH;
}

/*
* Now build the MAC header.
*/

if (type==IPPROTO_TCP)
tmp = ip_send_room(rt, skb, raddr, len, *dev, saddr);
else
tmp = ip_send(rt, skb, raddr, len, *dev, saddr);

ip_rt_put(rt);

/*
* Book keeping
*/

skb->dev = *dev;
skb->saddr = saddr;

/*
* Now build the IP header.
*/

/*
* If we are using IPPROTO_RAW, then we don't need an IP header, since
* one is being supplied to us by the user
*/

if(type == IPPROTO_RAW)
return (tmp);

/*
* Build the IP addresses
*/

if (opt)
iph=(struct iphdr *)skb_put(skb,sizeof(struct iphdr) + opt->optlen);
else
iph=(struct iphdr *)skb_put(skb,sizeof(struct iphdr));

iph->version = 4;
iph->ihl = 5;
iph->tos = tos;
iph->frag_off = 0;
iph->ttl = ttl;
iph->daddr = daddr;
iph->saddr = saddr;
iph->protocol = type;
skb->ip_hdr = iph;

if (!opt || !opt->optlen)
return sizeof(struct iphdr) + tmp;
iph->ihl += opt->optlen>>2;
ip_options_build(skb, opt, final_daddr, (*dev)->pa_addr, 0);
return iph->ihl*4 + tmp;
}


/*
* Generate a checksum for an outgoing IP datagram.
*/

void ip_send_check(struct iphdr *iph)
{
iph->check = 0;
iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
}


/*
* If a sender wishes the packet to remain unfreed
* we add it to his send queue. This arguably belongs
* in the TCP level since nobody else uses it. BUT
* remember IPng might change all the rules.
*/
static inline void add_to_send_queue(struct sock * sk, struct sk_buff * skb)
{
unsigned long flags;

/* The socket now has more outstanding blocks */
sk->packets_out++;

/* Protect the list for a moment */
save_flags(flags);
cli();

if (skb->link3 != NULL)
{
NETDEBUG(printk("ip.c: link3 != NULL\n"));
skb->link3 = NULL;
}
if (sk->send_head == NULL)
{
sk->send_tail = skb;
sk->send_head = skb;
sk->send_next = skb;
}
else
{
sk->send_tail->link3 = skb;
sk->send_tail = skb;
}
restore_flags(flags);
}


/*
* Queues a packet to be sent, and starts the transmitter
* if necessary. if free = 1 then we free the block after
* transmit, otherwise we don't. If free==2 we not only
* free the block but also don't assign a new ip seq number.
* This routine also needs to put in the total length,
* and compute the checksum
*/

void ip_queue_xmit(struct sock *sk, struct device *dev,
struct sk_buff *skb, int free)
{
unsigned int tot_len;
struct iphdr *iph;

IS_SKB(skb);

/*
* Do some book-keeping in the packet for later
*/

skb->sk = sk;
skb->dev = dev;
skb->when = jiffies;

/*
* Find the IP header and set the length. This is bad
* but once we get the skb data handling code in the
* hardware will push its header sensibly and we will
* set skb->ip_hdr to avoid this mess and the fixed
* header length problem
*/

iph = skb->ip_hdr;
tot_len = skb->len - (((unsigned char *)iph) - skb->data);
iph->tot_len = htons(tot_len);

switch (free) {
/* No reassigning numbers to fragments... */
default:
free = 1;
break;
case 0:
add_to_send_queue(sk, skb);
/* fall through */
case 1:
iph->id = htons(ip_id_count++);
}

skb->free = free;

/* Sanity check */
if (dev == NULL)
goto no_device;

#ifdef CONFIG_FIREWALL
if (call_out_firewall(PF_INET, skb->dev, iph, NULL) < FW_ACCEPT)
goto out;
#endif

/*
* Do we need to fragment. Again this is inefficient.
* We need to somehow lock the original buffer and use
* bits of it.
*/

if (tot_len > dev->mtu)
goto fragment;

/*
* Add an IP checksum
*/

ip_send_check(iph);

/*
* More debugging. You cannot queue a packet already on a list
* Spot this and moan loudly.
*/
if (skb->next != NULL)
{
NETDEBUG(printk("ip_queue_xmit: next != NULL\n"));
skb_unlink(skb);
}

/*
* If the indicated interface is up and running, send the packet.
*/

ip_statistics.IpOutRequests++;
#ifdef CONFIG_IP_ACCT
ip_fw_chk(iph,dev,NULL,ip_acct_chain,0,IP_FW_MODE_ACCT_OUT);
#endif

#ifdef CONFIG_IP_MULTICAST

/*
* Multicasts are looped back for other local users
*/

if (MULTICAST(iph->daddr) && !(dev->flags&IFF_LOOPBACK))
{
if(sk==NULL || sk->ip_mc_loop)
{
if(iph->daddr==IGMP_ALL_HOSTS || (dev->flags&IFF_ALLMULTI))
{
ip_loopback(dev,skb);
}
else
{
struct ip_mc_list *imc=dev->ip_mc_list;
while(imc!=NULL)
{
if(imc->multiaddr==iph->daddr)
{
ip_loopback(dev,skb);
break;
}
imc=imc->next;
}
}
}
/* Multicasts with ttl 0 must not go beyond the host */

if (iph->ttl==0)
goto out;
}
#endif
if ((dev->flags & IFF_BROADCAST) && !(dev->flags & IFF_LOOPBACK)
&& (iph->daddr==dev->pa_brdaddr || iph->daddr==0xFFFFFFFF))
ip_loopback(dev,skb);

if (dev->flags & IFF_UP)
{
/*
* If we have an owner use its priority setting,
* otherwise use NORMAL
*/
int priority = SOPRI_NORMAL;
if (sk)
priority = sk->priority;

dev_queue_xmit(skb, dev, priority);
return;
}
if(sk)
sk->err = ENETDOWN;
ip_statistics.IpOutDiscards++;
out:
if (free)
kfree_skb(skb, FREE_WRITE);
return;

no_device:
NETDEBUG(printk("IP: ip_queue_xmit dev = NULL\n"));
goto out;

fragment:
ip_fragment(sk,skb,dev,0);
goto out;
}


/*
* Build and send a packet, with as little as one copy
*
* Doesn't care much about ip options... option length can be
* different for fragment at 0 and other fragments.
*
* Note that the fragment at the highest offset is sent first,
* so the getfrag routine can fill in the TCP/UDP checksum header
* field in the last fragment it sends... actually it also helps
* the reassemblers, they can put most packets in at the head of
* the fragment queue, and they know the total size in advance. This
* last feature will measurable improve the Linux fragment handler.
*
* The callback has five args, an arbitrary pointer (copy of frag),
* the source IP address (may depend on the routing table), the
* destination address (char *), the offset to copy from, and the
* length to be copied.
*
*/

int ip_build_xmit(struct sock *sk,
void getfrag (const void *,
__u32,
char *,
unsigned int,
unsigned int),
const void *frag,
unsigned short int length,
__u32 daddr,
__u32 user_saddr,
struct options * opt,
int flags,
int type,
int noblock)
{
struct rtable *rt;
unsigned int fraglen, maxfraglen, fragheaderlen;
int offset, mf;
__u32 saddr;
unsigned short id;
struct iphdr *iph;
__u32 raddr;
struct device *dev = NULL;
struct hh_cache * hh=NULL;
int nfrags=0;
__u32 true_daddr = daddr;

if (opt && opt->srr && !sk->ip_hdrincl)
daddr = opt->faddr;

ip_statistics.IpOutRequests++;

#ifdef CONFIG_IP_MULTICAST
if(sk && MULTICAST(daddr) && *sk->ip_mc_name)
{
dev=dev_get(sk->ip_mc_name);
if(!dev)
return -ENODEV;
rt=NULL;
if (sk->saddr && (!LOOPBACK(sk->saddr) || LOOPBACK(daddr)))
saddr = sk->saddr;
else
saddr = dev->pa_addr;
}
else
{
#endif
rt = ip_check_route(&sk->ip_route_cache, daddr,
sk->localroute || (flags&MSG_DONTROUTE) ||
(opt && opt->is_strictroute));
if (rt == NULL)
{
ip_statistics.IpOutNoRoutes++;
return(-ENETUNREACH);
}
saddr = rt->rt_src;

hh = rt->rt_hh;

if (sk->saddr && (!LOOPBACK(sk->saddr) || LOOPBACK(daddr)))
saddr = sk->saddr;

dev=rt->rt_dev;
#ifdef CONFIG_IP_MULTICAST
}
if (rt && !dev)
dev = rt->rt_dev;
#endif
if (user_saddr)
saddr = user_saddr;

raddr = rt ? rt->rt_gateway : daddr;
/*
* Now compute the buffer space we require
*/

/*
* Try the simple case first. This leaves broadcast, multicast, fragmented frames, and by
* choice RAW frames within 20 bytes of maximum size(rare) to the long path
*/

if (!sk->ip_hdrincl) {
length += sizeof(struct iphdr);
if(opt) length += opt->optlen;
}

if(length <= dev->mtu && !MULTICAST(daddr) && daddr!=0xFFFFFFFF && daddr!=dev->pa_brdaddr)
{
int error;
struct sk_buff *skb=sock_alloc_send_skb(sk, length+15+dev->hard_header_len,0, noblock, &error);
if(skb==NULL)
{
ip_statistics.IpOutDiscards++;
return error;
}
skb->dev=dev;
skb->protocol = htons(ETH_P_IP);
skb->free=1;
skb->when=jiffies;
skb->sk=sk;
skb->arp=0;
skb->saddr=saddr;
skb->raddr = raddr;
skb_reserve(skb,(dev->hard_header_len+15)&~15);
if (hh)
{
skb->arp=1;
memcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
if (!hh->hh_uptodate)
{
skb->arp = 0;
#if RT_CACHE_DEBUG >= 2
printk("ip_build_xmit: hh miss %08x via %08x\n", rt->rt_dst, rt->rt_gateway);
#endif
}
}
else if(dev->hard_header)
{
if(dev->hard_header(skb,dev,ETH_P_IP,NULL,NULL,0)>0)
skb->arp=1;
}
else
skb->arp=1;
skb->ip_hdr=iph=(struct iphdr *)skb_put(skb,length);
dev_lock_list();
if(!sk->ip_hdrincl)
{
iph->version=4;
iph->ihl=5;
iph->tos=sk->ip_tos;
iph->tot_len = htons(length);
iph->id=htons(ip_id_count++);
iph->frag_off = 0;
iph->ttl=sk->ip_ttl;
iph->protocol=type;
iph->saddr=saddr;
iph->daddr=daddr;
if (opt)
{
iph->ihl += opt->optlen>>2;
ip_options_build(skb, opt,
true_daddr, dev->pa_addr, 0);
}
iph->check=0;
iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
getfrag(frag,saddr,((char *)iph)+iph->ihl*4,0, length-iph->ihl*4);
}
else
getfrag(frag,saddr,(void *)iph,0,length);
dev_unlock_list();
#ifdef CONFIG_FIREWALL
if(call_out_firewall(PF_INET, skb->dev, iph, NULL)< FW_ACCEPT)
{
kfree_skb(skb, FREE_WRITE);
return -EPERM;
}
#endif
#ifdef CONFIG_IP_ACCT
ip_fw_chk(iph,dev,NULL,ip_acct_chain,0,IP_FW_MODE_ACCT_OUT);
#endif
if(dev->flags&IFF_UP)
dev_queue_xmit(skb,dev,sk->priority);
else
{
ip_statistics.IpOutDiscards++;
kfree_skb(skb, FREE_WRITE);
}
return 0;
}
length -= sizeof(struct iphdr);
if (sk && !sk->ip_hdrincl && opt)
{
length -= opt->optlen;
fragheaderlen = dev->hard_header_len + sizeof(struct iphdr) + opt->optlen;
maxfraglen = ((dev->mtu-sizeof(struct iphdr)-opt->optlen) & ~7) + fragheaderlen;
}
else
{
fragheaderlen = dev->hard_header_len;
if(!sk->ip_hdrincl)
fragheaderlen += 20;

/*
* Fragheaderlen is the size of 'overhead' on each buffer. Now work
* out the size of the frames to send.
*/

maxfraglen = ((dev->mtu-20) & ~7) + fragheaderlen;
}

/*
* Start at the end of the frame by handling the remainder.
*/

offset = length - (length % (maxfraglen - fragheaderlen));

/*
* Amount of memory to allocate for final fragment.
*/

fraglen = length - offset + fragheaderlen;

if(length-offset==0)
{
fraglen = maxfraglen;
offset -= maxfraglen-fragheaderlen;
}


/*
* The last fragment will not have MF (more fragments) set.
*/

mf = 0;

/*
* Can't fragment raw packets
*/

if (sk->ip_hdrincl && offset > 0)
return(-EMSGSIZE);

/*
* Lock the device lists.
*/

dev_lock_list();

/*
* Get an identifier
*/

id = htons(ip_id_count++);

/*
* Being outputting the bytes.
*/

do
{
struct sk_buff * skb;
int error;
char *data;

/*
* Get the memory we require with some space left for alignment.
*/

skb = sock_alloc_send_skb(sk, fraglen+15, 0, noblock, &error);
if (skb == NULL)
{
ip_statistics.IpOutDiscards++;
if(nfrags>1)
ip_statistics.IpFragCreates++;
dev_unlock_list();
return(error);
}

/*
* Fill in the control structures
*/

skb->dev = dev;
skb->protocol = htons(ETH_P_IP);
skb->when = jiffies;
skb->free = 1; /* dubious, this one */
skb->sk = sk;
skb->arp = 0;
skb->saddr = saddr;
skb->raddr = raddr;
skb_reserve(skb,(dev->hard_header_len+15)&~15);
data = skb_put(skb, fraglen-dev->hard_header_len);

/*
* Save us ARP and stuff. In the optimal case we do no route lookup (route cache ok)
* no ARP lookup (arp cache ok) and output. The cache checks are still too slow but
* this can be fixed later. For gateway routes we ought to have a rt->.. header cache
* pointer to speed header cache builds for identical targets.
*/

if (hh)
{
skb->arp=1;
memcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
if (!hh->hh_uptodate)
{
skb->arp = 0;
#if RT_CACHE_DEBUG >= 2
printk("ip_build_xmit: hh miss %08x via %08x\n", rt->rt_dst, rt->rt_gateway);
#endif
}
}
else if (dev->hard_header)
{
if(dev->hard_header(skb, dev, ETH_P_IP,
NULL, NULL, 0)>0)
skb->arp=1;
}

/*
* Find where to start putting bytes.
*/

skb->ip_hdr = iph = (struct iphdr *)data;

/*
* Only write IP header onto non-raw packets
*/

if(!sk->ip_hdrincl)
{

iph->version = 4;
iph->ihl = 5; /* ugh */
if (opt) {
iph->ihl += opt->optlen>>2;
ip_options_build(skb, opt,
true_daddr, dev->pa_addr, offset);
}
iph->tos = sk->ip_tos;
iph->tot_len = htons(fraglen - fragheaderlen + iph->ihl*4);
iph->id = id;
iph->frag_off = htons(offset>>3);
iph->frag_off |= mf;
#ifdef CONFIG_IP_MULTICAST
if (MULTICAST(daddr))
iph->ttl = sk->ip_mc_ttl;
else
#endif
iph->ttl = sk->ip_ttl;
iph->protocol = type;
iph->check = 0;
iph->saddr = saddr;
iph->daddr = daddr;
iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
data += iph->ihl*4;

/*
* Any further fragments will have MF set.
*/

mf = htons(IP_MF);
}

/*
* User data callback
*/

getfrag(frag, saddr, data, offset, fraglen-fragheaderlen);

/*
* Account for the fragment.
*/

#ifdef CONFIG_FIREWALL
if(!offset && call_out_firewall(PF_INET, skb->dev, iph, NULL) < FW_ACCEPT)
{
kfree_skb(skb, FREE_WRITE);
dev_unlock_list();
return -EPERM;
}
#endif
#ifdef CONFIG_IP_ACCT
if(!offset)
ip_fw_chk(iph, dev, NULL, ip_acct_chain, 0, IP_FW_MODE_ACCT_OUT);
#endif
offset -= (maxfraglen-fragheaderlen);
fraglen = maxfraglen;

#ifdef CONFIG_IP_MULTICAST

/*
* Multicasts are looped back for other local users
*/

if (MULTICAST(daddr) && !(dev->flags&IFF_LOOPBACK))
{
/*
* Loop back any frames. The check for IGMP_ALL_HOSTS is because
* you are always magically a member of this group.
*
* Always loop back all host messages when running as a multicast router.
*/

if(sk==NULL || sk->ip_mc_loop)
{
if(skb->daddr==IGMP_ALL_HOSTS || (dev->flags&IFF_ALLMULTI))
ip_loopback(dev,skb);
else
{
struct ip_mc_list *imc=dev->ip_mc_list;
while(imc!=NULL)
{
if(imc->multiaddr==daddr)
{
ip_loopback(dev,skb);
break;
}
imc=imc->next;
}
}
}

/*
* Multicasts with ttl 0 must not go beyond the host. Fixme: avoid the
* extra clone.
*/

if(skb->ip_hdr->ttl==0)
kfree_skb(skb, FREE_READ);
}
#endif

nfrags++;

/*
* BSD loops broadcasts
*/

if((dev->flags&IFF_BROADCAST) && (daddr==0xFFFFFFFF || daddr==dev->pa_brdaddr) && !(dev->flags&IFF_LOOPBACK))
ip_loopback(dev,skb);

/*
* Now queue the bytes into the device.
*/

if (dev->flags & IFF_UP)
{
dev_queue_xmit(skb, dev, sk->priority);
}
else
{
/*
* Whoops...
*/

ip_statistics.IpOutDiscards++;
if(nfrags>1)
ip_statistics.IpFragCreates+=nfrags;
kfree_skb(skb, FREE_WRITE);
dev_unlock_list();
/*
* BSD behaviour.
*/
if(sk!=NULL)
sk->err=ENETDOWN;
return(0); /* lose rest of fragments */
}
}
while (offset >= 0);
if(nfrags>1)
ip_statistics.IpFragCreates+=nfrags;
dev_unlock_list();
return(0);
}


/*
* IP protocol layer initialiser
*/

static struct packet_type ip_packet_type =
{
0, /* MUTTER ntohs(ETH_P_IP),*/
NULL, /* All devices */
ip_rcv,
NULL,
NULL,
};

#ifdef CONFIG_RTNETLINK

/*
* Netlink hooks for IP
*/

void ip_netlink_msg(unsigned long msg, __u32 daddr, __u32 gw, __u32 mask, short flags, short metric, char *name)
{
struct sk_buff *skb=alloc_skb(sizeof(struct netlink_rtinfo), GFP_ATOMIC);
struct netlink_rtinfo *nrt;
struct sockaddr_in *s;
if(skb==NULL)
return;
skb->free=1;
nrt=(struct netlink_rtinfo *)skb_put(skb, sizeof(struct netlink_rtinfo));
nrt->rtmsg_type=msg;
s=(struct sockaddr_in *)&nrt->rtmsg_dst;
s->sin_family=AF_INET;
s->sin_addr.s_addr=daddr;
s=(struct sockaddr_in *)&nrt->rtmsg_gateway;
s->sin_family=AF_INET;
s->sin_addr.s_addr=gw;
s=(struct sockaddr_in *)&nrt->rtmsg_genmask;
s->sin_family=AF_INET;
s->sin_addr.s_addr=mask;
nrt->rtmsg_flags=flags;
nrt->rtmsg_metric=metric;
strcpy(nrt->rtmsg_device,name);
if (netlink_post(NETLINK_ROUTE, skb))
kfree_skb(skb, FREE_WRITE);
}

#endif

/*
* Device notifier
*/

static int ip_rt_event(struct notifier_block *this, unsigned long event, void *ptr)
{
struct device *dev=ptr;
if(event==NETDEV_DOWN)
{
ip_netlink_msg(RTMSG_DELDEVICE, 0,0,0,0,0,dev->name);
ip_rt_flush(dev);
}
/*
* Join the initial group if multicast.
*/
if(event==NETDEV_UP)
{
#ifdef CONFIG_IP_MULTICAST
ip_mc_allhost(dev);
#endif
ip_netlink_msg(RTMSG_NEWDEVICE, 0,0,0,0,0,dev->name);
ip_rt_update(NETDEV_UP, dev);
}
return NOTIFY_DONE;
}

struct notifier_block ip_rt_notifier={
ip_rt_event,
NULL,
0
};

/*
* IP registers the packet type and then calls the subprotocol initialisers
*/

void ip_init(void)
{
ip_packet_type.type=htons(ETH_P_IP);
dev_add_pack(&ip_packet_type);

/* So we flush routes when a device is downed */
register_netdevice_notifier(&ip_rt_notifier);

/* ip_raw_init();
ip_packet_init();
ip_tcp_init();
ip_udp_init();*/

#ifdef CONFIG_IP_MULTICAST
#ifdef CONFIG_PROC_FS
proc_net_register(&(struct proc_dir_entry) {
PROC_NET_IGMP, 4, "igmp",
S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_net_inode_operations,
ip_mc_procinfo
});
#endif
#endif
}