Subversion Repositories or1k

/*

 * 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.

 *

 *              RAW - implementation of IP "raw" sockets.

 *

 * Version:     @(#)raw.c       1.0.4   05/25/93

 *

 * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>

 *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>

 *

 * Fixes:

 *              Alan Cox        :       verify_area() fixed up

 *              Alan Cox        :       ICMP error handling

 *              Alan Cox        :       EMSGSIZE if you send too big a packet

 *              Alan Cox        :       Now uses generic datagrams and shared skbuff

 *                                      library. No more peek crashes, no more backlogs

 *              Alan Cox        :       Checks sk->broadcast.

 *              Alan Cox        :       Uses skb_free_datagram/skb_copy_datagram

 *              Alan Cox        :       Raw passes ip options too

 *              Alan Cox        :       Setsocketopt added

 *              Alan Cox        :       Fixed error return for broadcasts

 *              Alan Cox        :       Removed wake_up calls

 *              Alan Cox        :       Use ttl/tos

 *              Alan Cox        :       Cleaned up old debugging

 *              Alan Cox        :       Use new kernel side addresses

 *      Arnt Gulbrandsen        :       Fixed MSG_DONTROUTE in raw sockets.

 *              Alan Cox        :       BSD style RAW socket demultiplexing.

 *              Alan Cox        :       Beginnings of mrouted support.

 *              Alan Cox        :       Added IP_HDRINCL option.

 *              Alan Cox        :       Skip broadcast check if BSDism set.

 *              David S. Miller :       New socket lookup architecture for ISS.

 *

 *              This program is free software; you can redistribute it and/or

 *              modify it under the terms of the GNU General Public License

 *              as published by the Free Software Foundation; either version

 *              2 of the License, or (at your option) any later version.

 */

#include <linux/config.h> 

#include <asm/system.h>

#include <asm/segment.h>

#include <linux/types.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/timer.h>

#include <linux/mm.h>

#include <linux/kernel.h>

#include <linux/fcntl.h>

#include <linux/socket.h>

#include <linux/in.h>

#include <linux/inet.h>

#include <linux/netdevice.h>

#include <linux/mroute.h>

#include <net/ip.h>

#include <net/protocol.h>

#include <linux/skbuff.h>

#include <net/sock.h>

#include <net/icmp.h>

#include <net/udp.h>

#include <net/raw.h>

#include <net/checksum.h>

#ifdef CONFIG_IP_MROUTE

struct sock *mroute_socket=NULL;

#endif

struct sock *raw_v4_htable[RAWV4_HTABLE_SIZE];

static void raw_v4_hash(struct sock *sk)

{

        struct sock **skp;

        int num = sk->num;

        num &= (RAWV4_HTABLE_SIZE - 1);

        skp = &raw_v4_htable[num];

        SOCKHASH_LOCK();

        sk->next = *skp;

        *skp = sk;

        sk->hashent = num;

        SOCKHASH_UNLOCK();

}

static void raw_v4_unhash(struct sock *sk)

{

        struct sock **skp;

        int num = sk->num;

        num &= (RAWV4_HTABLE_SIZE - 1);

        skp = &raw_v4_htable[num];

        SOCKHASH_LOCK();

        while(*skp != NULL) {

                if(*skp == sk) {

                        *skp = sk->next;

                        break;

                }

                skp = &((*skp)->next);

        }

        SOCKHASH_UNLOCK();

}

static void raw_v4_rehash(struct sock *sk)

{

        struct sock **skp;

        int num = sk->num;

        int oldnum = sk->hashent;

        num &= (RAWV4_HTABLE_SIZE - 1);

        skp = &raw_v4_htable[oldnum];

        SOCKHASH_LOCK();

        while(*skp != NULL) {

                if(*skp == sk) {

                        *skp = sk->next;

                        break;

                }

                skp = &((*skp)->next);

        }

        sk->next = raw_v4_htable[num];

        raw_v4_htable[num] = sk;

        sk->hashent = num;

        SOCKHASH_UNLOCK();

}

/* Grumble... icmp and ip_input want to get at this... */

struct sock *raw_v4_lookup(struct sock *sk, unsigned short num,

                           unsigned long raddr, unsigned long laddr)

{

        struct sock *s = sk;

        SOCKHASH_LOCK();

        for(s = sk; s; s = s->next) {

                if((s->num == num)                              &&

                   !(s->dead && (s->state == TCP_CLOSE))        &&

                   !(s->daddr && s->daddr != raddr)             &&

                   !(s->rcv_saddr && s->rcv_saddr != laddr))

                        break; /* gotcha */

        }

        SOCKHASH_UNLOCK();

        return s;

}

static inline unsigned long min(unsigned long a, unsigned long b)

{

        if (a < b)

                return(a);

        return(b);

}

/*

 *      Raw_err does not currently get called by the icmp module - FIXME:

 */

void raw_err (int type, int code, unsigned char *header, __u32 daddr,

         __u32 saddr, struct inet_protocol *protocol)

{

        struct sock *sk;

        if (protocol == NULL)

                return;

        sk = (struct sock *) protocol->data;

        if (sk == NULL)

                return;

        /* This is meaningless in raw sockets. */

        if (type == ICMP_SOURCE_QUENCH)

        {

                if (sk->cong_window > 1) sk->cong_window = sk->cong_window/2;

                return;

        }

        if(type == ICMP_PARAMETERPROB)

        {

                sk->err = EPROTO;

                sk->error_report(sk);

        }

        if(code<=NR_ICMP_UNREACH)

        {

                sk->err = icmp_err_convert[code & 0xff].errno;

                sk->error_report(sk);

        }

        return;

}

static inline void raw_rcv_skb(struct sock * sk, struct sk_buff * skb)

{

        /* Charge it to the socket. */

        if (__sock_queue_rcv_skb(sk,skb)<0)

        {

                ip_statistics.IpInDiscards++;

                skb->sk=NULL;

                kfree_skb(skb, FREE_READ);

                return;

        }

        ip_statistics.IpInDelivers++;

}

/*

 * This is the prot->rcv() function. It's called when we have

 * backlogged packets from core/sock.c if we couldn't receive it

 * when the packet arrived.

 */

static int raw_rcv_redo(struct sk_buff *skb, struct device *dev, struct options *opt,

        __u32 daddr, unsigned short len,

        __u32 saddr, int redo, struct inet_protocol * protocol)

{

        raw_rcv_skb(skb->sk, skb);

        return 0;

}

/* This gets rid of all the nasties in af_inet. -DaveM */

static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)

{

        struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;

        int chk_addr_ret;

        if((sk->state != TCP_CLOSE) || (addr_len < sizeof(struct sockaddr_in)))

                return -EINVAL;

        chk_addr_ret = ip_chk_addr(addr->sin_addr.s_addr);

        if(addr->sin_addr.s_addr != 0 && chk_addr_ret != IS_MYADDR &&

           chk_addr_ret != IS_MULTICAST && chk_addr_ret != IS_BROADCAST) {

#ifdef CONFIG_IP_TRANSPARENT_PROXY

                /* Superuser may bind to any address to allow transparent proxying. */

                if(!suser())

#endif

                        return -EADDRNOTAVAIL;

        }

        sk->rcv_saddr = sk->saddr = addr->sin_addr.s_addr;

        if(chk_addr_ret == IS_MULTICAST || chk_addr_ret == IS_BROADCAST)

                sk->saddr = 0;  /* Use device */

        ip_rt_put(sk->ip_route_cache);

        sk->ip_route_cache = NULL;

        return 0;

}

/*

 *      This should be the easiest of all, all we do is

 *      copy it into a buffer. All demultiplexing is done

 *      in ip.c

 */

int raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr)

{

        /* Now we need to copy this into memory. */

        skb->sk = sk;

        skb_trim(skb,ntohs(skb->ip_hdr->tot_len));

        skb->h.raw = (unsigned char *) skb->ip_hdr;

        skb->dev = dev;

        skb->saddr = daddr;

        skb->daddr = saddr;

#if 0   

        /*

         *      For no adequately explained reasons BSD likes to mess up the header of

         *      the received frame.

         */

        if(sk->bsdism)

                skb->ip_hdr->tot_len=ntohs(skb->ip_hdr->tot_len-4*skb->ip_hdr->ihl);

#endif

        if (sk->users) {

                __skb_queue_tail(&sk->back_log, skb);

                return 0;

        }

        raw_rcv_skb(sk, skb);

        return 0;

}

/*

 *      Send a RAW IP packet.

 */

/*

 *      Callback support is trivial for SOCK_RAW

 */

static void raw_getfrag(const void *p, __u32 saddr, char *to, unsigned int offset, unsigned int fraglen)

{

        memcpy_fromfs(to, (const unsigned char *)p+offset, fraglen);

}

/*

 *      IPPROTO_RAW needs extra work.

 */

static void raw_getrawfrag(const void *p, __u32 saddr, char *to, unsigned int offset, unsigned int fraglen)

{

        memcpy_fromfs(to, (const unsigned char *)p+offset, fraglen);

        if(offset==0)

        {

                struct iphdr *iph=(struct iphdr *)to;

                if(!iph->saddr)

                        iph->saddr=saddr;

                iph->check=0;

                iph->tot_len=htons(fraglen);    /* This is right as you can't frag

                                           RAW packets */

                /*

                 *      Deliberate breach of modularity to keep

                 *      ip_build_xmit clean (well less messy).

                 */

                if (!iph->id)

                        iph->id = htons(ip_id_count++);

                iph->check=ip_fast_csum((unsigned char *)iph, iph->ihl);

        }

}

static int raw_sendto(struct sock *sk, const unsigned char *from,

        int len, int noblock, unsigned flags, struct sockaddr_in *usin, int addr_len)

{

        int err;

        struct sockaddr_in sin;

        /*

         *      Check the flags. Only MSG_DONTROUTE is permitted.

         */

        if (flags & MSG_OOB)            /* Mirror BSD error message compatibility */

                return -EOPNOTSUPP;

        if (flags & ~MSG_DONTROUTE)

                return(-EINVAL);

        /*

         *      Get and verify the address.

         */

        if (usin)

        {

                if (addr_len < sizeof(sin))

                        return(-EINVAL);

                memcpy(&sin, usin, sizeof(sin));

                if (sin.sin_family && sin.sin_family != AF_INET)

                        return(-EINVAL);

                /*

                 *      Protocol type is host ordered byte.

                 */

                sin.sin_port=ntohs(sin.sin_port);

        }

        else

        {

                if (sk->state != TCP_ESTABLISHED)

                        return(-EINVAL);

                sin.sin_family = AF_INET;

                sin.sin_port = sk->num;

                sin.sin_addr.s_addr = sk->daddr;

        }

        if (sin.sin_port == 0)

                sin.sin_port = sk->num;

        if (sin.sin_addr.s_addr == INADDR_ANY)

                sin.sin_addr.s_addr = ip_my_addr();

        /*

         *      BSD raw sockets forget to check SO_BROADCAST ....

         */

        if (!sk->bsdism && sk->broadcast == 0 && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)

                return -EACCES;

        if(sk->ip_hdrincl)

        {

                if(len>65535)

                        return -EMSGSIZE;

                err=ip_build_xmit(sk, raw_getrawfrag, from, len, sin.sin_addr.s_addr, 0, sk->opt, flags, sin.sin_port, noblock);

        }

        else

        {

                if(len>65535-sizeof(struct iphdr))

                        return -EMSGSIZE;

                err=ip_build_xmit(sk, raw_getfrag, from, len, sin.sin_addr.s_addr, 0, sk->opt, flags, sin.sin_port, noblock);

        }

        return err<0?err:len;

}

/*

 *      Temporary

 */

static int raw_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock,

        int flags)

{

        if(msg->msg_iovlen==1)

                return raw_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);

        else

        {

                /*

                 *      For awkward cases we linearise the buffer first. In theory this is only frames

                 *      whose iovec's don't split on 4 byte boundaries, and soon encrypted stuff (to keep

                 *      skip happy). We are a bit more general about it.

                 */

                unsigned char *buf;

                int fs;

                int err;

                if(len>65515)

                        return -EMSGSIZE;

                buf=kmalloc(len, GFP_KERNEL);

                if(buf==NULL)

                        return -ENOBUFS;

                memcpy_fromiovec(buf, msg->msg_iov, len);

                fs=get_fs();

                set_fs(get_ds());

                err=raw_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);

                set_fs(fs);

                kfree_s(buf,len);

                return err;

        }

}

static void raw_close(struct sock *sk, unsigned long timeout)

{

        sk->state = TCP_CLOSE;

#ifdef CONFIG_IP_MROUTE 

        if(sk==mroute_socket)

        {

                mroute_close(sk);

                mroute_socket=NULL;

        }

#endif  

        sk->dead=1;

        destroy_sock(sk);

}

static int raw_init(struct sock *sk)

{

        return(0);

}

/*

 *      This should be easy, if there is something there

 *      we return it, otherwise we block.

 */

int raw_recvmsg(struct sock *sk, struct msghdr *msg, int len,

     int noblock, int flags,int *addr_len)

{

        int copied=0;

        struct sk_buff *skb;

        int err;

        struct sockaddr_in *sin=(struct sockaddr_in *)msg->msg_name;

        if (flags & MSG_OOB)

                return -EOPNOTSUPP;

        if (sk->shutdown & RCV_SHUTDOWN)

                return(0);

        if (addr_len)

                *addr_len=sizeof(*sin);

        skb=skb_recv_datagram(sk,flags,noblock,&err);

        if(skb==NULL)

                return err;

        copied = min(len, skb->len);

        skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);

        sk->stamp=skb->stamp;

        /* Copy the address. */

        if (sin)

        {

                sin->sin_family = AF_INET;

                sin->sin_addr.s_addr = skb->daddr;

        }

        skb_free_datagram(sk, skb);

        return (copied);

}

struct proto raw_prot = {

        (struct sock *)&raw_prot,       /* sklist_next */

        (struct sock *)&raw_prot,       /* sklist_prev */

        raw_close,                      /* close */

        ip_build_header,                /* build_header */

        udp_connect,                    /* connect */

        NULL,                           /* accept */

        ip_queue_xmit,                  /* queue_xmit */

        NULL,                           /* retransmit */

        NULL,                           /* write_wakeup */

        NULL,                           /* read_wakeup */

        raw_rcv_redo,                   /* rcv */

        datagram_select,                /* select */

#ifdef CONFIG_IP_MROUTE 

        ipmr_ioctl,                     /* ioctl */

#else

        NULL,                           /* ioctl */

#endif          

        raw_init,                       /* init */

        NULL,                           /* shutdown */

        ip_setsockopt,                  /* setsockopt */

        ip_getsockopt,                  /* getsockopt */

        raw_sendmsg,                    /* sendmsg */

        raw_recvmsg,                    /* recvmsg */

        raw_bind,                       /* bind */

        raw_v4_hash,                    /* hash */

        raw_v4_unhash,                  /* unhash */

        raw_v4_rehash,                  /* rehash */

        NULL,                           /* good_socknum */

        NULL,                           /* verify_bind */

        128,                            /* max_header */

        0,                               /* retransmits */

        "RAW",                          /* name */

        0,                               /* inuse */

};