root/net/inet/raw.c

/* */

DEFINITIONS

1. min
2. raw_err
3. raw_rcv
4. raw_sendto
5. raw_write
6. raw_close
7. raw_init
8. raw_recvfrom
9. raw_read

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              RAW - implementation of IP "raw" sockets.
   7  *
   8  * Version:     @(#)raw.c       1.0.4   05/25/93
   9  *
  10  * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *
  13  * Fixes:
  14  *              Alan Cox        :       verify_area() fixed up
  15  *              Alan Cox        :       ICMP error handling
  16  *              Alan Cox        :       EMSGSIZE if you send too big a packet
  17  *              Alan Cox        :       Now uses generic datagrams and shared skbuff
  18  *                                      library. No more peek crashes, no more backlogs
  19  *              Alan Cox        :       Checks sk->broadcast.
  20  *              Alan Cox        :       Uses skb_free_datagram/skb_copy_datagram
  21  *              Alan Cox        :       Raw passes ip options too
  22  *              Alan Cox        :       Setsocketopt added
  23  *              Alan Cox        :       Fixed error return for broadcasts
  24  *              Alan Cox        :       Removed wake_up calls
  25  *              Alan Cox        :       Use ttl/tos
  26  *
  27  *              This program is free software; you can redistribute it and/or
  28  *              modify it under the terms of the GNU General Public License
  29  *              as published by the Free Software Foundation; either version
  30  *              2 of the License, or (at your option) any later version.
  31  */
  32 #include <asm/system.h>
  33 #include <asm/segment.h>
  34 #include <linux/types.h>
  35 #include <linux/sched.h>
  36 #include <linux/errno.h>
  37 #include <linux/timer.h>
  38 #include <linux/mm.h>
  39 #include <linux/kernel.h>
  40 #include <linux/fcntl.h>
  41 #include <linux/socket.h>
  42 #include <linux/in.h>
  43 #include "inet.h"
  44 #include "dev.h"
  45 #include "ip.h"
  46 #include "protocol.h"
  47 #include "tcp.h"
  48 #include "skbuff.h"
  49 #include "sock.h"
  50 #include "icmp.h"
  51 #include "udp.h"
  52 
  53 
  54 static unsigned long
  55 min(unsigned long a, unsigned long b)
     /*  */
  56 {
  57   if (a < b) return(a);
  58   return(b);
  59 }
  60 
  61 
  62 /* raw_err gets called by the icmp module. */
  63 void
  64 raw_err (int err, unsigned char *header, unsigned long daddr,
     /*  */
  65          unsigned long saddr, struct inet_protocol *protocol)
  66 {
  67   struct sock *sk;
  68    
  69   DPRINTF((DBG_RAW, "raw_err(err=%d, hdr=%X, daddr=%X, saddr=%X, protocl=%X)\n",
  70                 err, header, daddr, saddr, protocol));
  71 
  72   if (protocol == NULL) return;
  73   sk = (struct sock *) protocol->data;
  74   if (sk == NULL) return;
  75 
  76   /* This is meaningless in raw sockets. */
  77   if (err & 0xff00 == (ICMP_SOURCE_QUENCH << 8)) {
  78         if (sk->cong_window > 1) sk->cong_window = sk->cong_window/2;
  79         return;
  80   }
  81 
  82   sk->err = icmp_err_convert[err & 0xff].errno;
  83   sk->error_report(sk);
  84   
  85   return;
  86 }
  87 
  88 
  89 /*
  90  * This should be the easiest of all, all we do is\
  91  * copy it into a buffer.
  92  */
  93 int
  94 raw_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
     /*  */
  95         unsigned long daddr, unsigned short len, unsigned long saddr,
  96         int redo, struct inet_protocol *protocol)
  97 {
  98   struct sock *sk;
  99 
 100   DPRINTF((DBG_RAW, "raw_rcv(skb=%X, dev=%X, opt=%X, daddr=%X,\n"
 101            "         len=%d, saddr=%X, redo=%d, protocol=%X)\n",
 102            skb, dev, opt, daddr, len, saddr, redo, protocol));
 103 
 104   if (skb == NULL) return(0);
 105   if (protocol == NULL) {
 106         kfree_skb(skb, FREE_READ);
 107         return(0);
 108   }
 109   sk = (struct sock *) protocol->data;
 110   if (sk == NULL) {
 111         kfree_skb(skb, FREE_READ);
 112         return(0);
 113   }
 114 
 115   /* Now we need to copy this into memory. */
 116   skb->sk = sk;
 117   skb->len = len + skb->ip_hdr->ihl*sizeof(long);
 118   skb->h.raw = (unsigned char *) skb->ip_hdr;
 119   skb->dev = dev;
 120   skb->saddr = daddr;
 121   skb->daddr = saddr;
 122 
 123   /* Charge it too the socket. */
 124   if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) {
 125         skb->sk = NULL;
 126         kfree_skb(skb, FREE_READ);
 127         return(0);
 128   }
 129   sk->rmem_alloc += skb->mem_len;
 130   skb_queue_tail(&sk->rqueue,skb);
 131   sk->data_ready(sk,skb->len);
 132   release_sock(sk);
 133   return(0);
 134 }
 135 
 136 
 137 /* This will do terrible things if len + ipheader + devheader > dev->mtu */
 138 static int
 139 raw_sendto(struct sock *sk, unsigned char *from, int len,
     /*  */
 140            int noblock,
 141            unsigned flags, struct sockaddr_in *usin, int addr_len)
 142 {
 143   struct sk_buff *skb;
 144   struct device *dev=NULL;
 145   struct sockaddr_in sin;
 146   int tmp;
 147   int err;
 148 
 149   DPRINTF((DBG_RAW, "raw_sendto(sk=%X, from=%X, len=%d, noblock=%d, flags=%X,\n"
 150            "            usin=%X, addr_len = %d)\n", sk, from, len, noblock,
 151            flags, usin, addr_len));
 152 
 153   /* Check the flags. */
 154   if (flags) return(-EINVAL);
 155   if (len < 0) return(-EINVAL);
 156 
 157   err=verify_area(VERIFY_READ,from,len);
 158   if(err)
 159         return err;
 160   /* Get and verify the address. */
 161   if (usin) {
 162         if (addr_len < sizeof(sin)) return(-EINVAL);
 163         err=verify_area (VERIFY_READ, usin, sizeof (sin));
 164         if(err)
 165                 return err;
 166         memcpy_fromfs(&sin, usin, sizeof(sin));
 167         if (sin.sin_family && sin.sin_family != AF_INET) return(-EINVAL);
 168   } else {
 169         if (sk->state != TCP_ESTABLISHED) return(-EINVAL);
 170         sin.sin_family = AF_INET;
 171         sin.sin_port = sk->protocol;
 172         sin.sin_addr.s_addr = sk->daddr;
 173   }
 174   if (sin.sin_port == 0) sin.sin_port = sk->protocol;
 175   
 176   if (sk->broadcast == 0 && chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
 177         return -EACCES;
 178 
 179   sk->inuse = 1;
 180   skb = NULL;
 181   while (skb == NULL) {
 182         if(sk->err!=0)
 183         {
 184                 err= -sk->err;
 185                 sk->err=0;
 186                 release_sock(sk);
 187                 return(err);
 188         }
 189         
 190         skb = sk->prot->wmalloc(sk,
 191                         len+sizeof(*skb) + sk->prot->max_header,
 192                         0, GFP_KERNEL);
 193         if (skb == NULL) {
 194                 int tmp;
 195 
 196                 DPRINTF((DBG_RAW, "raw_sendto: write buffer full?\n"));
 197                 if (noblock) 
 198                         return(-EAGAIN);
 199                 tmp = sk->wmem_alloc;
 200                 release_sock(sk);
 201                 cli();
 202                 if (tmp <= sk->wmem_alloc) {
 203                         interruptible_sleep_on(sk->sleep);
 204                         if (current->signal & ~current->blocked) {
 205                                 sti();
 206                                 return(-ERESTARTSYS);
 207                         }
 208                 }
 209                 sk->inuse = 1;
 210                 sti();
 211         }
 212   }
 213   skb->mem_addr = skb;
 214   skb->mem_len = len + sizeof(*skb) +sk->prot->max_header;
 215   skb->sk = sk;
 216 
 217   skb->free = 1; /* these two should be unecessary. */
 218   skb->arp = 0;
 219 
 220   tmp = sk->prot->build_header(skb, sk->saddr, 
 221                                sin.sin_addr.s_addr, &dev,
 222                                sk->protocol, sk->opt, skb->mem_len, sk->ip_tos,sk->ip_ttl);
 223   if (tmp < 0) {
 224         DPRINTF((DBG_RAW, "raw_sendto: error building ip header.\n"));
 225         kfree_skb(skb,FREE_WRITE);
 226         release_sock(sk);
 227         return(tmp);
 228   }
 229 
 230   /* verify_area(VERIFY_WRITE, from, len);*/
 231   memcpy_fromfs(skb->data + tmp, from, len);
 232 
 233   /* If we are using IPPROTO_RAW, we need to fill in the source address in
 234      the IP header */
 235 
 236   if(sk->protocol==IPPROTO_RAW) {
 237     unsigned char *buff;
 238     struct iphdr *iph;
 239 
 240     buff = skb->data;
 241     buff += tmp;
 242     iph = (struct iphdr *)buff;
 243     iph->saddr = sk->saddr;
 244   }
 245 
 246   skb->len = tmp + len;
 247   sk->prot->queue_xmit(sk, dev, skb, 1);
 248   release_sock(sk);
 249   return(len);
 250 }
 251 
 252 
 253 static int
 254 raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
     /*  */
 255            unsigned flags)
 256 {
 257   return(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
 258 }
 259 
 260 
 261 static void
 262 raw_close(struct sock *sk, int timeout)
     /*  */
 263 {
 264   sk->inuse = 1;
 265   sk->state = TCP_CLOSE;
 266 
 267   DPRINTF((DBG_RAW, "raw_close: deleting protocol %d\n",
 268            ((struct inet_protocol *)sk->pair)->protocol));
 269 
 270   if (inet_del_protocol((struct inet_protocol *)sk->pair) < 0)
 271                 DPRINTF((DBG_RAW, "raw_close: del_protocol failed.\n"));
 272   kfree_s((void *)sk->pair, sizeof (struct inet_protocol));
 273   sk->pair = NULL;
 274   release_sock(sk);
 275 }
 276 
 277 
 278 static int
 279 raw_init(struct sock *sk)
     /*  */
 280 {
 281   struct inet_protocol *p;
 282 
 283   p = (struct inet_protocol *) kmalloc(sizeof (*p), GFP_KERNEL);
 284   if (p == NULL) return(-ENOMEM);
 285 
 286   p->handler = raw_rcv;
 287   p->protocol = sk->protocol;
 288   p->data = (void *)sk;
 289   p->err_handler = raw_err;
 290   p->name="USER";
 291   p->frag_handler = NULL;       /* For now */
 292   inet_add_protocol(p);
 293    
 294   /* We need to remember this somewhere. */
 295   sk->pair = (struct sock *)p;
 296 
 297   DPRINTF((DBG_RAW, "raw init added protocol %d\n", sk->protocol));
 298 
 299   return(0);
 300 }
 301 
 302 
 303 /*
 304  * This should be easy, if there is something there
 305  * we return it, otherwise we block.
 306  */
 307 int
 308 raw_recvfrom(struct sock *sk, unsigned char *to, int len,
     /*  */
 309              int noblock, unsigned flags, struct sockaddr_in *sin,
 310              int *addr_len)
 311 {
 312   int copied=0;
 313   struct sk_buff *skb;
 314   int err;
 315 
 316   DPRINTF((DBG_RAW, "raw_recvfrom (sk=%X, to=%X, len=%d, noblock=%d, flags=%X,\n"
 317            "              sin=%X, addr_len=%X)\n",
 318                 sk, to, len, noblock, flags, sin, addr_len));
 319 
 320   if (len == 0) return(0);
 321   if (len < 0) return(-EINVAL);
 322 
 323   if (sk->shutdown & RCV_SHUTDOWN) return(0);
 324   if (addr_len) {
 325         err=verify_area(VERIFY_WRITE, addr_len, sizeof(*addr_len));
 326         if(err)
 327                 return err;
 328         put_fs_long(sizeof(*sin), addr_len);
 329   }
 330   if(sin)
 331   {
 332         err=verify_area(VERIFY_WRITE, sin, sizeof(*sin));
 333         if(err)
 334                 return err;
 335   }
 336   
 337   err=verify_area(VERIFY_WRITE,to,len);
 338   if(err)
 339         return err;
 340 
 341   skb=skb_recv_datagram(sk,flags,noblock,&err);
 342   if(skb==NULL)
 343         return err;
 344 
 345   copied = min(len, skb->len);
 346   
 347   skb_copy_datagram(skb, 0, to, copied);
 348 
 349   /* Copy the address. */
 350   if (sin) {
 351         struct sockaddr_in addr;
 352 
 353         addr.sin_family = AF_INET;
 354         addr.sin_addr.s_addr = skb->daddr;
 355         memcpy_tofs(sin, &addr, sizeof(*sin));
 356   }
 357 
 358   skb_free_datagram(skb);
 359   release_sock(sk);
 360   return (copied);
 361 }
 362 
 363 
 364 int
 365 raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,
     /*  */
 366           unsigned flags)
 367 {
 368   return(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
 369 }
 370 
 371 
 372 struct proto raw_prot = {
 373   sock_wmalloc,
 374   sock_rmalloc,
 375   sock_wfree,
 376   sock_rfree,
 377   sock_rspace,
 378   sock_wspace,
 379   raw_close,
 380   raw_read,
 381   raw_write,
 382   raw_sendto,
 383   raw_recvfrom,
 384   ip_build_header,
 385   udp_connect,
 386   NULL,
 387   ip_queue_xmit,
 388   ip_retransmit,
 389   NULL,
 390   NULL,
 391   raw_rcv,
 392   datagram_select,
 393   NULL,
 394   raw_init,
 395   NULL,
 396   ip_setsockopt,
 397   ip_getsockopt,
 398   128,
 399   0,
 400   {NULL,},
 401   "RAW"
 402 };

/* */