net/tcp/raw.c

/* */
This source file includes following definitions.
min
raw_err
raw_rcv
raw_sendto
raw_write
raw_close
raw_init
raw_recvfrom
raw_read
   1 /* raw.c - implements raw ip sockets. */
   2 /*
   3     Copyright (C) 1992  Ross Biro
   4 
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2, or (at your option)
   8     any later version.
   9 
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14 
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
  18 
  19     The Author may be reached as bir7@leland.stanford.edu or
  20     C/O Department of Mathematics; Stanford University; Stanford, CA 94305
  21 */
  22 /* $Id: raw.c,v 0.8.4.12 1993/01/26 22:04:00 bir7 Exp $ */
  23 /* $Log: raw.c,v $
  24  * Revision 0.8.4.12  1993/01/26  22:04:00  bir7
  25  * Added support for proc fs.
  26  *
  27  * Revision 0.8.4.11  1993/01/23  18:00:11  bir7
  28  * Added volatile keyword
  29  *
  30  * Revision 0.8.4.10  1993/01/22  23:21:38  bir7
  31  * Merged with 99 pl4
  32  *
  33  * Revision 0.8.4.9  1992/12/12  19:25:04  bir7
  34  * Cleaned up Log messages.
  35  *
  36  * Revision 0.8.4.8  1992/12/12  01:50:49  bir7
  37  * Fixed bug in call to err routine.
  38  *
  39  * Revision 0.8.4.7  1992/12/06  11:31:47  bir7
  40  * added raw_err.
  41  *
  42  * Revision 0.8.4.6  1992/11/18  15:38:03  bir7
  43  * Works now.
  44  *
  45  *
  46  * Revision 0.8.4.4  1992/11/17  09:27:07  bir7
  47  * Fixed error in header building.
  48  *
  49  * Revision 0.8.4.3  1992/11/16  16:13:40  bir7
  50  * Added debuggin information.
  51  *
  52  * Revision 0.8.4.2  1992/11/10  10:38:48  bir7
  53  * Change free_s to kfree_s and accidently changed free_skb to kfree_skb.
  54  *
  55  * Revision 0.8.4.1  1992/11/10  00:17:18  bir7
  56  * version change only.
  57  *
  58  * Revision 0.8.3.3  1992/11/10  00:14:47  bir7
  59  * Changed malloc to kmalloc and added Id and Log
  60  * */
  61 
  62 #include <linux/types.h>
  63 #include <linux/sched.h>
  64 #include <linux/fcntl.h>
  65 #include <linux/socket.h>
  66 #include <netinet/in.h>
  67 #include "timer.h"
  68 #include "ip.h"
  69 #include "tcp.h"
  70 #include "sock.h"
  71 #include <linux/errno.h>
  72 #include <linux/timer.h>
  73 #include <asm/system.h>
  74 #include <asm/segment.h>
  75 #include <linux/mm.h>
  76 #include <linux/kernel.h>
  77 #include "icmp.h"
  78 
  79 
  80 #ifdef PRINTK
  81 #undef PRINTK
  82 #endif
  83 
  84 #undef RAW_DEBUG
  85 #ifdef RAW_DEBUG
  86 #define PRINTK(x) printk x
  87 #else
  88 #define PRINTK(x) /**/
  89 #endif
  90 
  91 extern struct proto raw_prot;
  92 
  93 static  unsigned long
  94 min(unsigned long a, unsigned long b)
     /*  */
  95 {
  96    if (a < b) return (a);
  97    return (b);
  98 }
  99 
 100 /* raw_err gets called by the icmp module. */
 101 void
 102 raw_err (int err, unsigned char *header, unsigned long daddr,
     /*  */
 103          unsigned long saddr, struct ip_protocol *protocol)
 104 {
 105    volatile struct sock *sk;
 106    
 107    PRINTK (("raw_err (err=%d, header=%X, daddr=%X, saddr=%X, ip_protocl=%X)\n"));
 108 
 109    if (protocol == NULL) return;
 110 
 111    sk = protocol->data;
 112 
 113    if (sk == NULL) return;
 114 
 115    /* This is meaningless in raw sockets. */
 116    if (err & 0xff00 == (ICMP_SOURCE_QUENCH << 8))
 117      {
 118         if (sk->cong_window > 1)
 119           sk->cong_window = sk->cong_window/2;
 120         return;
 121      }
 122 
 123    sk->err = icmp_err_convert[err & 0xff].errno;
 124    /* none of them are fatal for raw sockets. */
 125 /*   if (icmp_err_convert[err & 0xff].fatal)
 126      {
 127         sk->prot->close(sk, 0);
 128      } */
 129 
 130    return;
 131 
 132 }
 133 
 134 /* this should be the easiest of all, all we do is copy it into
 135    a buffer. */
 136 int
 137 raw_rcv (struct sk_buff *skb, struct device *dev, struct options *opt,
     /*  */
 138          unsigned long daddr, unsigned short len, unsigned long saddr,
 139          int redo, struct ip_protocol *protocol)
 140 {
 141 
 142   volatile struct sock *sk;
 143 
 144    PRINTK (("raw_rcv (skb=%X, dev=%X, opt=%X, daddr=%X,\n"
 145            "         len=%d, saddr=%X, redo=%d, protocol=%X)\n",
 146            skb, dev, opt, daddr, len, saddr, redo, protocol));
 147 
 148    if (skb == NULL) return (0);
 149    if (protocol == NULL)
 150      {
 151        kfree_skb (skb, FREE_READ);
 152        return (0);
 153      }
 154    sk = protocol->data;
 155    if (sk == NULL)
 156      {
 157        kfree_skb (skb, FREE_READ);
 158        return (0);
 159      }
 160 
 161    /* now we need to copy this into memory. */
 162    skb->sk = sk;
 163    skb->len = len;
 164    skb->dev = dev;
 165    skb->saddr = daddr;
 166    skb->daddr = saddr;
 167 
 168    if (!redo )
 169      {
 170         /* now see if we are in use. */
 171         cli();
 172         if (sk->inuse)
 173           {
 174              PRINTK (("raw_rcv adding to backlog. \n"));
 175              if (sk->back_log == NULL)
 176                {
 177                   sk->back_log = skb;
 178                   skb->next = skb;
 179                   skb->prev = skb;
 180                }
 181              else
 182                {
 183                   skb->next = sk->back_log;
 184                   skb->prev = sk->back_log->prev;
 185                   skb->prev->next = skb;
 186                   skb->next->prev = skb;
 187                }
 188              sti();
 189              return (0);
 190           }
 191         sk->inuse = 1;
 192         sti();
 193      }
 194 
 195    /* charge it too the socket. */
 196    if (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
 197      {
 198         skb->sk = NULL;
 199         kfree_skb (skb, FREE_READ);
 200         return (0);
 201      }
 202              
 203    sk->rmem_alloc += skb->mem_len;
 204 
 205    /* now just put it onto the queue. */
 206    if (sk->rqueue == NULL)
 207      {
 208         sk->rqueue = skb;
 209         skb->next = skb;
 210         skb->prev = skb;
 211      }
 212    else
 213      {
 214         skb->next = sk->rqueue;
 215         skb->prev = sk->rqueue->prev;
 216         skb->prev->next = skb;
 217         skb->next->prev = skb;
 218      }
 219    wake_up (sk->sleep);
 220    release_sock (sk);
 221    return (0);
 222 }
 223 
 224 /* this will do terrible things if len + ipheader + devheader > dev->mtu */
 225 static int
 226 raw_sendto (volatile struct sock *sk, unsigned char *from, int len,
     /*  */
 227             int noblock,
 228             unsigned flags, struct sockaddr_in *usin, int addr_len)
 229 {
 230    struct sk_buff *skb;
 231    struct device *dev=NULL;
 232    struct sockaddr_in sin;
 233    int tmp;
 234 
 235    PRINTK (("raw_sendto (sk=%X, from=%X, len=%d, noblock=%d, flags=%X,\n"
 236            "            usin=%X, addr_len = %d)\n", sk, from, len, noblock,
 237            flags, usin, addr_len));
 238 
 239    /* check the flags. */
 240    if (flags) return (-EINVAL);
 241    if (len < 0) return (-EINVAL);
 242 
 243    /* get and verify the address. */
 244    if (usin)
 245      {
 246         if (addr_len < sizeof (sin))
 247           return (-EINVAL);
 248 /*      verify_area (VERIFY_WRITE, usin, sizeof (sin));*/
 249         memcpy_fromfs (&sin, usin, sizeof(sin));
 250         if (sin.sin_family &&
 251             sin.sin_family != AF_INET)
 252           return (-EINVAL);
 253      }
 254    else
 255      {
 256         if (sk->state != TCP_ESTABLISHED)
 257           return (-EINVAL);
 258         sin.sin_family = AF_INET;
 259         sin.sin_port = sk->protocol;
 260         sin.sin_addr.s_addr = sk->daddr;
 261      }
 262    if (sin.sin_port == 0) sin.sin_port = sk->protocol;
 263 
 264    sk->inuse = 1;
 265    skb = NULL;
 266    while (skb == NULL)
 267      {
 268        skb = sk->prot->wmalloc (sk, len+sizeof (*skb) + sk->prot->max_header,
 269                                 0, GFP_KERNEL);
 270        /* this shouldn't happen, but it could. */
 271        /* need to change this to sleep. */
 272        if (skb == NULL)
 273          {
 274            int tmp;
 275            PRINTK (("raw_sendto: write buffer full?\n"));
 276            if (noblock) return (-EAGAIN);
 277            tmp = sk->wmem_alloc;
 278            release_sock (sk);
 279            cli();
 280            if (tmp <= sk->wmem_alloc)
 281              {
 282                interruptible_sleep_on (sk->sleep);
 283                if (current->signal & ~current->blocked)
 284                  {
 285                    sti();
 286                    return (-ERESTARTSYS);
 287                  }
 288              }
 289            sk->inuse = 1;
 290            sti();
 291          }
 292      }
 293    skb->lock = 0;
 294    skb->mem_addr = skb;
 295    skb->mem_len = len + sizeof (*skb) +sk->prot->max_header;
 296    skb->sk = sk;
 297 
 298    skb->free = 1; /* these two should be unecessary. */
 299    skb->arp = 0;
 300 
 301    tmp = sk->prot->build_header (skb, sk->saddr, 
 302                                  sin.sin_addr.s_addr, &dev,
 303                                  sk->protocol, sk->opt, skb->mem_len);
 304    if (tmp < 0)
 305      {
 306        PRINTK (("raw_sendto: error building ip header.\n"));
 307         sk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
 308         release_sock (sk);
 309         return (tmp);
 310      }
 311 
 312 /*   verify_area (VERIFY_WRITE, from, len);*/
 313    memcpy_fromfs ((unsigned char *)(skb+1)+tmp, from, len);
 314    skb->len = tmp + len;
 315    sk->prot->queue_xmit (sk, dev, skb, 1);
 316    release_sock (sk);
 317    return (len);
 318 }
 319 
 320 static int
 321 raw_write (volatile struct sock *sk, unsigned char *buff, int len, int noblock,
     /*  */
 322            unsigned flags)
 323 {
 324    return (raw_sendto (sk, buff, len, noblock, flags, NULL, 0));
 325 }
 326 
 327 static void
 328 raw_close (volatile struct sock *sk, int timeout)
     /*  */
 329 {
 330    sk->inuse = 1;
 331    sk->state = TCP_CLOSE;
 332    PRINTK (("raw_close: deleting ip_protocol %d\n",
 333            ((struct ip_protocol *)sk->pair)->protocol));
 334    if (delete_ip_protocol ((struct ip_protocol *)sk->pair) < 0)
 335      PRINTK (("raw_close: delete_ip_protocol failed. \n"));
 336    kfree_s ((void *)sk->pair, sizeof (struct ip_protocol));
 337    sk->pair = NULL;
 338    release_sock (sk);
 339 }
 340 
 341 static int
 342 raw_init (volatile struct sock *sk)
     /*  */
 343 {
 344    struct ip_protocol *p;
 345    p = kmalloc (sizeof (*p), GFP_KERNEL);
 346    if (p == NULL) return (-ENOMEM);
 347 
 348    p->handler = raw_rcv;
 349    p->protocol = sk->protocol;
 350    p->data = (void *)sk;
 351    p->err_handler = raw_err;
 352    add_ip_protocol (p);
 353    
 354    /* we need to remember this somewhere. */
 355    sk->pair = (volatile struct sock *)p;
 356 
 357    PRINTK (("raw init added protocol %d\n", sk->protocol));
 358 
 359    return (0);
 360 }
 361 
 362 
 363 int
 364 raw_recvfrom (volatile struct sock *sk, unsigned char *to, int len,
     /*  */
 365               int noblock,
 366               unsigned flags, struct sockaddr_in *sin, int *addr_len)
 367 {
 368         /* this should be easy, if there is something there we
 369            return it, otherwise we block. */
 370         int copied=0;
 371         struct sk_buff *skb;
 372 
 373         PRINTK (("raw_recvfrom (sk=%X, to=%X, len=%d, noblock=%d, flags=%X,\n"
 374                 "              sin=%X, addr_len=%X)\n", sk, to, len, noblock,
 375                 flags, sin, addr_len));
 376 
 377         if (len == 0) return (0);
 378         if (len < 0) return (-EINVAL);
 379 
 380         if (sk->shutdown & RCV_SHUTDOWN) return (0);
 381         if (addr_len)
 382           {
 383                   verify_area (VERIFY_WRITE, addr_len, sizeof(*addr_len));
 384                   put_fs_long (sizeof (*sin), addr_len);
 385           }
 386         sk->inuse = 1;
 387         while (sk->rqueue == NULL)
 388           {
 389              if (noblock)
 390                {
 391                   release_sock (sk);
 392                   if (copied) return (copied);
 393                   return (-EAGAIN);
 394                }
 395              release_sock (sk);
 396              cli();
 397              if (sk->rqueue == NULL)
 398                {
 399                   interruptible_sleep_on (sk->sleep);
 400                   if (current->signal & ~current->blocked)
 401                     {
 402                       sti();
 403                       return (-ERESTARTSYS);
 404                     }
 405                }
 406              sk->inuse = 1;
 407              sti();
 408           }
 409         skb = sk->rqueue;
 410 
 411         if (!(flags & MSG_PEEK))
 412           {
 413                   if (skb->next == skb )
 414                     {
 415                             sk->rqueue = NULL;
 416                     }
 417                   else
 418                     {
 419                             sk->rqueue = (struct sk_buff *)sk->rqueue ->next;
 420                             skb->prev->next = skb->next;
 421                             skb->next->prev = skb->prev;
 422                     }
 423           }
 424         copied = min (len, skb->len);
 425         verify_area (VERIFY_WRITE, to, copied);
 426         memcpy_tofs (to, skb->h.raw,  copied);
 427         /* copy the address. */
 428         if (sin)
 429           {
 430                   struct sockaddr_in addr;
 431                   addr.sin_family = AF_INET;
 432                   addr.sin_addr.s_addr = skb->daddr;
 433                   verify_area (VERIFY_WRITE, sin, sizeof (*sin));
 434                   memcpy_tofs(sin, &addr, sizeof (*sin));
 435           }
 436 
 437         if (!(flags & MSG_PEEK))
 438           {
 439              kfree_skb (skb, FREE_READ);
 440           }
 441         release_sock (sk);
 442         return (copied);
 443 
 444 }
 445 
 446 int
 447 raw_read (volatile struct sock *sk, unsigned char *buff, int len, int noblock,
     /*  */
 448           unsigned flags)
 449 {
 450         return (raw_recvfrom (sk, buff, len, noblock, flags, NULL, NULL));
 451 }
 452 
 453 
 454 int udp_connect (volatile struct sock *sk, struct sockaddr_in *usin,
 455                  int addr_len);
 456 
 457 int udp_select (volatile struct sock *sk, int sel_type, select_table *wait);
 458 
 459 
 460 struct proto raw_prot =
 461 {
 462   sock_wmalloc,
 463   sock_rmalloc,
 464   sock_wfree,
 465   sock_rfree,
 466   sock_rspace,
 467   sock_wspace,
 468   raw_close,
 469   raw_read,
 470   raw_write,
 471   raw_sendto,
 472   raw_recvfrom,
 473   ip_build_header,
 474   udp_connect,
 475   NULL,
 476   ip_queue_xmit,
 477   ip_retransmit,
 478   NULL,
 479   NULL,
 480   raw_rcv,
 481   udp_select,
 482   NULL,
 483   raw_init,
 484   NULL,
 485   128,
 486   0,
 487   {NULL,},
 488   "RAW"
 489 };
/* */
root/net/tcp/raw.c

DEFINITIONS
