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

DEFINITIONS
