root/net/ipv4/udp.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. udp_cache_zap
  2. udp_err
  3. udp_check
  4. udp_getfrag
  5. udp_getfrag_nosum
  6. udp_send
  7. udp_sendto
  8. udp_sendmsg
  9. udp_ioctl
  10. udp_recvmsg
  11. udp_connect
  12. udp_close
  13. udp_rcv
  14. udp_deliver

   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  *              The User Datagram Protocol (UDP).
   7  *
   8  * Version:     @(#)udp.c       1.0.13  06/02/93
   9  *
  10  * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
  13  *              Alan Cox, <Alan.Cox@linux.org>
  14  *
  15  * Fixes:
  16  *              Alan Cox        :       verify_area() calls
  17  *              Alan Cox        :       stopped close while in use off icmp
  18  *                                      messages. Not a fix but a botch that
  19  *                                      for udp at least is 'valid'.
  20  *              Alan Cox        :       Fixed icmp handling properly
  21  *              Alan Cox        :       Correct error for oversized datagrams
  22  *              Alan Cox        :       Tidied select() semantics. 
  23  *              Alan Cox        :       udp_err() fixed properly, also now 
  24  *                                      select and read wake correctly on errors
  25  *              Alan Cox        :       udp_send verify_area moved to avoid mem leak
  26  *              Alan Cox        :       UDP can count its memory
  27  *              Alan Cox        :       send to an unknown connection causes
  28  *                                      an ECONNREFUSED off the icmp, but
  29  *                                      does NOT close.
  30  *              Alan Cox        :       Switched to new sk_buff handlers. No more backlog!
  31  *              Alan Cox        :       Using generic datagram code. Even smaller and the PEEK
  32  *                                      bug no longer crashes it.
  33  *              Fred Van Kempen :       Net2e support for sk->broadcast.
  34  *              Alan Cox        :       Uses skb_free_datagram
  35  *              Alan Cox        :       Added get/set sockopt support.
  36  *              Alan Cox        :       Broadcasting without option set returns EACCES.
  37  *              Alan Cox        :       No wakeup calls. Instead we now use the callbacks.
  38  *              Alan Cox        :       Use ip_tos and ip_ttl
  39  *              Alan Cox        :       SNMP Mibs
  40  *              Alan Cox        :       MSG_DONTROUTE, and 0.0.0.0 support.
  41  *              Matt Dillon     :       UDP length checks.
  42  *              Alan Cox        :       Smarter af_inet used properly.
  43  *              Alan Cox        :       Use new kernel side addressing.
  44  *              Alan Cox        :       Incorrect return on truncated datagram receive.
  45  *      Arnt Gulbrandsen        :       New udp_send and stuff
  46  *              Alan Cox        :       Cache last socket
  47  *              Alan Cox        :       Route cache
  48  *              Jon Peatfield   :       Minor efficientcy fix to sendto().
  49  *              Mike Shaver     :       RFC1122 checks.
  50  *              Alan Cox        :       Nonblocking error fix.
  51  *
  52  *
  53  *              This program is free software; you can redistribute it and/or
  54  *              modify it under the terms of the GNU General Public License
  55  *              as published by the Free Software Foundation; either version
  56  *              2 of the License, or (at your option) any later version.
  57  */
  58  
  59 /* RFC1122 Status:
  60    4.1.3.1 (Ports):
  61      SHOULD send ICMP_PORT_UNREACHABLE in reponse to datagrams to 
  62        an un-listened port. (OK)
  63    4.1.3.2 (IP Options)
  64      MUST pass IP options from IP -> application (OK)
  65      MUST allow application to specify IP options (OK)
  66    4.1.3.3 (ICMP Messages)
  67      MUST pass ICMP error messages to application (OK)
  68    4.1.3.4 (UDP Checksums)
  69      MUST provide facility for checksumming (OK)
  70      MAY allow application to control checksumming (OK)
  71      MUST default to checksumming on (OK)
  72      MUST discard silently datagrams with bad csums (OK)
  73    4.1.3.5 (UDP Multihoming)
  74      MUST allow application to specify source address (OK)
  75      SHOULD be able to communicate the chosen src addr up to application
  76        when application doesn't choose (NOT YET - doesnt seem to be in the BSD API)
  77        [Does opening a SOCK_PACKET and snooping your output count 8)]
  78    4.1.3.6 (Invalid Addresses)
  79      MUST discard invalid source addresses (NOT YET -- will be implemented
  80        in IP, so UDP will eventually be OK.  Right now it's a violation.)
  81      MUST only send datagrams with one of our addresses (NOT YET - ought to be OK )
  82    950728 -- MS
  83 */
  84 
  85 #include <asm/system.h>
  86 #include <asm/segment.h>
  87 #include <linux/types.h>
  88 #include <linux/sched.h>
  89 #include <linux/fcntl.h>
  90 #include <linux/socket.h>
  91 #include <linux/sockios.h>
  92 #include <linux/in.h>
  93 #include <linux/errno.h>
  94 #include <linux/timer.h>
  95 #include <linux/termios.h>
  96 #include <linux/mm.h>
  97 #include <linux/config.h>
  98 #include <linux/inet.h>
  99 #include <linux/netdevice.h>
 100 #include <net/snmp.h>
 101 #include <net/ip.h>
 102 #include <net/protocol.h>
 103 #include <net/tcp.h>
 104 #include <linux/skbuff.h>
 105 #include <net/sock.h>
 106 #include <net/udp.h>
 107 #include <net/icmp.h>
 108 #include <net/route.h>
 109 #include <net/checksum.h>
 110 
 111 /*
 112  *      Snmp MIB for the UDP layer
 113  */
 114 
 115 struct udp_mib          udp_statistics;
 116 
 117 /*
 118  *      Cached last hit socket
 119  */
 120  
 121 volatile unsigned long  uh_cache_saddr,uh_cache_daddr;
 122 volatile unsigned short  uh_cache_dport, uh_cache_sport;
 123 volatile struct sock *uh_cache_sk;
 124 
 125 void udp_cache_zap(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 126 {
 127         unsigned long flags;
 128         save_flags(flags);
 129         cli();
 130         uh_cache_saddr=0;
 131         uh_cache_daddr=0;
 132         uh_cache_dport=0;
 133         uh_cache_sport=0;
 134         uh_cache_sk=NULL;
 135         restore_flags(flags);
 136 }
 137 
 138 static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
 139 
 140 #define min(a,b)        ((a)<(b)?(a):(b))
 141 
 142 
 143 /*
 144  * This routine is called by the ICMP module when it gets some
 145  * sort of error condition.  If err < 0 then the socket should
 146  * be closed and the error returned to the user.  If err > 0
 147  * it's just the icmp type << 8 | icmp code.  
 148  * Header points to the ip header of the error packet. We move
 149  * on past this. Then (as it used to claim before adjustment)
 150  * header points to the first 8 bytes of the udp header.  We need
 151  * to find the appropriate port.
 152  */
 153 
 154 void udp_err(int type, int code, unsigned char *header, __u32 daddr,
     /* [previous][next][first][last][top][bottom][index][help] */
 155         __u32 saddr, struct inet_protocol *protocol)
 156 {
 157         struct udphdr *uh;
 158         struct sock *sk;
 159 
 160         /*
 161          *      Find the 8 bytes of post IP header ICMP included for us
 162          */  
 163         
 164         uh = (struct udphdr *)header;  
 165    
 166         sk = get_sock(&udp_prot, uh->source, daddr, uh->dest, saddr);
 167 
 168         if (sk == NULL) 
 169                 return; /* No socket for error */
 170         
 171         if (type == ICMP_SOURCE_QUENCH) 
 172         {       /* Slow down! */
 173                 if (sk->cong_window > 1) 
 174                         sk->cong_window = sk->cong_window/2;
 175                 return;
 176         }
 177 
 178         if (type == ICMP_PARAMETERPROB)
 179         {
 180                 sk->err = EPROTO;
 181                 sk->error_report(sk);
 182                 return;
 183         }
 184                         
 185         /*
 186          *      Various people wanted BSD UDP semantics. Well they've come 
 187          *      back out because they slow down response to stuff like dead
 188          *      or unreachable name servers and they screw term users something
 189          *      chronic. Oh and it violates RFC1122. So basically fix your 
 190          *      client code people.
 191          */
 192          
 193         /* RFC1122: OK.  Passes ICMP errors back to application, as per */
 194         /* 4.1.3.3. */
 195         /* After the comment above, that should be no surprise. */
 196 
 197         if (code < 13 && icmp_err_convert[code].fatal)
 198         {
 199                 /*
 200                  *      4.x BSD compatibility item. Break RFC1122 to
 201                  *      get BSD socket semantics.
 202                  */
 203                 if(sk->bsdism && sk->state!=TCP_ESTABLISHED)
 204                         return;
 205                 sk->err = icmp_err_convert[code].errno;
 206                 sk->error_report(sk);
 207         }
 208 }
 209 
 210 
 211 static unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
     /* [previous][next][first][last][top][bottom][index][help] */
 212 {
 213         return(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));
 214 }
 215 
 216 struct udpfakehdr 
 217 {
 218         struct udphdr uh;
 219         __u32 daddr;
 220         __u32 other;
 221         const char *from;
 222         __u32 wcheck;
 223 };
 224 
 225 /*
 226  *      Copy and checksum a UDP packet from user space into a buffer. We still have to do the planning to
 227  *      get ip_build_xmit to spot direct transfer to network card and provide an additional callback mode
 228  *      for direct user->board I/O transfers. That one will be fun.
 229  */
 230  
 231 static void udp_getfrag(const void *p, __u32 saddr, char * to, unsigned int offset, unsigned int fraglen) 
     /* [previous][next][first][last][top][bottom][index][help] */
 232 {
 233         struct udpfakehdr *ufh = (struct udpfakehdr *)p;
 234         const char *src;
 235         char *dst;
 236         unsigned int len;
 237 
 238         if (offset) 
 239         {
 240                 len = fraglen;
 241                 src = ufh->from+(offset-sizeof(struct udphdr));
 242                 dst = to;
 243         }
 244         else 
 245         {
 246                 len = fraglen-sizeof(struct udphdr);
 247                 src = ufh->from;
 248                 dst = to+sizeof(struct udphdr);
 249         }
 250         ufh->wcheck = csum_partial_copy_fromuser(src, dst, len, ufh->wcheck);
 251         if (offset == 0) 
 252         {
 253                 ufh->wcheck = csum_partial((char *)ufh, sizeof(struct udphdr),
 254                                    ufh->wcheck);
 255                 ufh->uh.check = csum_tcpudp_magic(saddr, ufh->daddr, 
 256                                           ntohs(ufh->uh.len),
 257                                           IPPROTO_UDP, ufh->wcheck);
 258                 if (ufh->uh.check == 0)
 259                         ufh->uh.check = -1;
 260                 memcpy(to, ufh, sizeof(struct udphdr));
 261         }
 262 }
 263 
 264 /*
 265  *      Uncheckummed UDP is sufficiently criticial to stuff like ATM video conferencing
 266  *      that we use two routines for this for speed. Probably we ought to have a CONFIG_FAST_NET
 267  *      set for >10Mb/second boards to activate this sort of coding. Timing needed to verify if
 268  *      this is a valid decision.
 269  */
 270  
 271 static void udp_getfrag_nosum(const void *p, __u32 saddr, char * to, unsigned int offset, unsigned int fraglen) 
     /* [previous][next][first][last][top][bottom][index][help] */
 272 {
 273         struct udpfakehdr *ufh = (struct udpfakehdr *)p;
 274         const char *src;
 275         char *dst;
 276         unsigned int len;
 277 
 278         if (offset) 
 279         {
 280                 len = fraglen;
 281                 src = ufh->from+(offset-sizeof(struct udphdr));
 282                 dst = to;
 283         }
 284         else 
 285         {
 286                 len = fraglen-sizeof(struct udphdr);
 287                 src = ufh->from;
 288                 dst = to+sizeof(struct udphdr);
 289         }
 290         memcpy_fromfs(dst,src,len);
 291         if (offset == 0) 
 292                 memcpy(to, ufh, sizeof(struct udphdr));
 293 }
 294 
 295 
 296 /*
 297  *      Send UDP frames.
 298  */
 299 
 300 static int udp_send(struct sock *sk, struct sockaddr_in *sin,
     /* [previous][next][first][last][top][bottom][index][help] */
 301                       const unsigned char *from, int len, int rt,
 302                     __u32 saddr, int noblock) 
 303 {
 304         int ulen = len + sizeof(struct udphdr);
 305         int a;
 306         struct udpfakehdr ufh;
 307         
 308         if(ulen>65535-sizeof(struct iphdr))
 309                 return -EMSGSIZE;
 310 
 311         ufh.uh.source = sk->dummy_th.source;
 312         ufh.uh.dest = sin->sin_port;
 313         ufh.uh.len = htons(ulen);
 314         ufh.uh.check = 0;
 315         ufh.daddr = sin->sin_addr.s_addr;
 316         ufh.other = (htons(ulen) << 16) + IPPROTO_UDP*256;
 317         ufh.from = from;
 318         ufh.wcheck = 0;
 319 
 320         /* RFC1122: OK.  Provides the checksumming facility (MUST) as per */
 321         /* 4.1.3.4. It's configurable by the application via setsockopt() */
 322         /* (MAY) and it defaults to on (MUST).  Almost makes up for the */
 323         /* violation above. -- MS */
 324 
 325         if(sk->no_check)
 326                 a = ip_build_xmit(sk, udp_getfrag_nosum, &ufh, ulen, 
 327                         sin->sin_addr.s_addr, saddr, sk->opt, rt, IPPROTO_UDP, noblock);
 328         else
 329                 a = ip_build_xmit(sk, udp_getfrag, &ufh, ulen, 
 330                         sin->sin_addr.s_addr, saddr, sk->opt, rt, IPPROTO_UDP, noblock);
 331         if(a<0)
 332                 return a;
 333         udp_statistics.UdpOutDatagrams++;
 334         return len;
 335 }
 336 
 337 
 338 static int udp_sendto(struct sock *sk, const unsigned char *from, int len, int noblock,
     /* [previous][next][first][last][top][bottom][index][help] */
 339            unsigned flags, struct sockaddr_in *usin, int addr_len)
 340 {
 341         struct sockaddr_in sin;
 342         int tmp;
 343         __u32 saddr=0;
 344 
 345         /* 
 346          *      Check the flags. We support no flags for UDP sending
 347          */
 348 
 349         if (flags&~MSG_DONTROUTE) 
 350                 return(-EINVAL);
 351         /*
 352          *      Get and verify the address. 
 353          */
 354          
 355         if (usin) 
 356         {
 357                 if (addr_len < sizeof(sin)) 
 358                         return(-EINVAL);
 359                 if (usin->sin_family && usin->sin_family != AF_INET) 
 360                         return(-EINVAL);
 361                 if (usin->sin_port == 0) 
 362                         return(-EINVAL);
 363         } 
 364         else 
 365         {
 366                 if (sk->state != TCP_ESTABLISHED) 
 367                         return(-EINVAL);
 368                 sin.sin_family = AF_INET;
 369                 sin.sin_port = sk->dummy_th.dest;
 370                 sin.sin_addr.s_addr = sk->daddr;
 371                 usin = &sin;
 372         }
 373   
 374         /*
 375          *      BSD socket semantics. You must set SO_BROADCAST to permit
 376          *      broadcasting of data.
 377          */
 378          
 379         /* RFC1122: OK.  Allows the application to select the specific */
 380         /* source address for an outgoing packet (MUST) as per 4.1.3.5. */
 381         /* Optional addition: a mechanism for telling the application what */
 382         /* address was used. (4.1.3.5, MAY) -- MS */
 383 
 384         /* RFC1122: MUST ensure that all outgoing packets have one */
 385         /* of this host's addresses as a source addr.(4.1.3.6) - bind in  */
 386         /* af_inet.c checks these. It does need work to allow BSD style */
 387         /* bind to multicast as is done by xntpd                */
 388 
 389         if(usin->sin_addr.s_addr==INADDR_ANY)
 390                 usin->sin_addr.s_addr=ip_my_addr();
 391                 
 392         if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
 393                 return -EACCES;                 /* Must turn broadcast on first */
 394 
 395         lock_sock(sk);
 396 
 397         /* Send the packet. */
 398         tmp = udp_send(sk, usin, from, len, flags, saddr, noblock);
 399 
 400         /* The datagram has been sent off.  Release the socket. */
 401         release_sock(sk);
 402         return(tmp);
 403 }
 404 
 405 /*
 406  *      Temporary
 407  */
 408  
 409 static int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock, 
     /* [previous][next][first][last][top][bottom][index][help] */
 410         int flags)
 411 {
 412         if(msg->msg_iovlen==1)
 413                 return udp_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);
 414         else
 415         {
 416                 /*
 417                  *      For awkward cases we linearise the buffer first. In theory this is only frames
 418                  *      whose iovec's don't split on 4 byte boundaries, and soon encrypted stuff (to keep
 419                  *      skip happy). We are a bit more general about it.
 420                  */
 421                  
 422                 unsigned char *buf;
 423                 int fs;
 424                 int err;
 425                 if(len>65515)
 426                         return -EMSGSIZE;
 427                 buf=kmalloc(len, GFP_KERNEL);
 428                 if(buf==NULL)
 429                         return -ENOBUFS;
 430                 memcpy_fromiovec(buf, msg->msg_iov, len);
 431                 fs=get_fs();
 432                 set_fs(get_ds());
 433                 err=udp_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);
 434                 set_fs(fs);
 435                 kfree_s(buf,len);
 436                 return err;
 437         }
 438 }
 439 
 440 /*
 441  *      IOCTL requests applicable to the UDP protocol
 442  */
 443  
 444 int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 445 {
 446         int err;
 447         switch(cmd) 
 448         {
 449                 case TIOCOUTQ:
 450                 {
 451                         unsigned long amount;
 452 
 453                         if (sk->state == TCP_LISTEN) return(-EINVAL);
 454                         amount = sock_wspace(sk);
 455                         err=verify_area(VERIFY_WRITE,(void *)arg,
 456                                         sizeof(unsigned long));
 457                         if(err)
 458                                 return(err);
 459                         put_fs_long(amount,(unsigned long *)arg);
 460                         return(0);
 461                 }
 462 
 463                 case TIOCINQ:
 464                 {
 465                         struct sk_buff *skb;
 466                         unsigned long amount;
 467 
 468                         if (sk->state == TCP_LISTEN) return(-EINVAL);
 469                         amount = 0;
 470                         skb = skb_peek(&sk->receive_queue);
 471                         if (skb != NULL) {
 472                                 /*
 473                                  * We will only return the amount
 474                                  * of this packet since that is all
 475                                  * that will be read.
 476                                  */
 477                                 amount = skb->len-sizeof(struct udphdr);
 478                         }
 479                         err=verify_area(VERIFY_WRITE,(void *)arg,
 480                                                 sizeof(unsigned long));
 481                         if(err)
 482                                 return(err);
 483                         put_fs_long(amount,(unsigned long *)arg);
 484                         return(0);
 485                 }
 486 
 487                 default:
 488                         return(-EINVAL);
 489         }
 490         return(0);
 491 }
 492 
 493 
 494 /*
 495  *      This should be easy, if there is something there we\
 496  *      return it, otherwise we block.
 497  */
 498 
 499 int udp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
     /* [previous][next][first][last][top][bottom][index][help] */
 500              int noblock, int flags,int *addr_len)
 501 {
 502         int copied = 0;
 503         int truesize;
 504         struct sk_buff *skb;
 505         int er;
 506         struct sockaddr_in *sin=(struct sockaddr_in *)msg->msg_name;
 507 
 508         /*
 509          *      Check any passed addresses
 510          */
 511          
 512         if (addr_len) 
 513                 *addr_len=sizeof(*sin);
 514   
 515         /*
 516          *      From here the generic datagram does a lot of the work. Come
 517          *      the finished NET3, it will do _ALL_ the work!
 518          */
 519                 
 520         skb=skb_recv_datagram(sk,flags,noblock,&er);
 521         if(skb==NULL)
 522                 return er;
 523   
 524         truesize = skb->len - sizeof(struct udphdr);
 525         copied = min(len, truesize);
 526 
 527         /*
 528          *      FIXME : should use udp header size info value 
 529          */
 530          
 531         skb_copy_datagram_iovec(skb,sizeof(struct udphdr),msg->msg_iov,copied);
 532         sk->stamp=skb->stamp;
 533 
 534         /* Copy the address. */
 535         if (sin) 
 536         {
 537                 sin->sin_family = AF_INET;
 538                 sin->sin_port = skb->h.uh->source;
 539                 sin->sin_addr.s_addr = skb->daddr;
 540         }
 541   
 542         skb_free_datagram(sk, skb);
 543         return(copied);
 544 }
 545 
 546 int udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
     /* [previous][next][first][last][top][bottom][index][help] */
 547 {
 548         struct rtable *rt;
 549         if (addr_len < sizeof(*usin)) 
 550                 return(-EINVAL);
 551 
 552         if (usin->sin_family && usin->sin_family != AF_INET) 
 553                 return(-EAFNOSUPPORT);
 554         if (usin->sin_addr.s_addr==INADDR_ANY)
 555                 usin->sin_addr.s_addr=ip_my_addr();
 556 
 557         if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
 558                 return -EACCES;                 /* Must turn broadcast on first */
 559         
 560         rt=ip_rt_route((__u32)usin->sin_addr.s_addr, sk->localroute);
 561         if (rt==NULL)
 562                 return -ENETUNREACH;
 563         if(!sk->saddr)
 564                 sk->saddr = rt->rt_src;         /* Update source address */
 565         if(!sk->rcv_saddr)
 566                 sk->rcv_saddr = rt->rt_src;
 567         sk->daddr = usin->sin_addr.s_addr;
 568         sk->dummy_th.dest = usin->sin_port;
 569         sk->state = TCP_ESTABLISHED;
 570         udp_cache_zap();
 571         sk->ip_route_cache = rt;
 572         return(0);
 573 }
 574 
 575 
 576 static void udp_close(struct sock *sk, unsigned long timeout)
     /* [previous][next][first][last][top][bottom][index][help] */
 577 {
 578         lock_sock(sk);
 579         sk->state = TCP_CLOSE;
 580         if(uh_cache_sk==sk)
 581                 udp_cache_zap();
 582         release_sock(sk);
 583         destroy_sock(sk);
 584 }
 585 
 586 
 587 /*
 588  *      All we need to do is get the socket, and then do a checksum. 
 589  */
 590  
 591 int udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
     /* [previous][next][first][last][top][bottom][index][help] */
 592         __u32 daddr, unsigned short len,
 593         __u32 saddr, int redo, struct inet_protocol *protocol)
 594 {
 595         struct sock *sk;
 596         struct udphdr *uh;
 597         unsigned short ulen;
 598         int addr_type = IS_MYADDR;
 599         
 600         if(!dev || dev->pa_addr!=daddr)
 601                 addr_type=ip_chk_addr(daddr);
 602                 
 603         /*
 604          *      Get the header.
 605          */
 606          
 607         uh = (struct udphdr *) skb->h.uh;
 608         
 609         ip_statistics.IpInDelivers++;
 610 
 611         /*
 612          *      Validate the packet and the UDP length.
 613          */
 614          
 615         ulen = ntohs(uh->len);
 616         
 617         if (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh)) 
 618         {
 619                 NETDEBUG(printk("UDP: short packet: %d/%d\n", ulen, len));
 620                 udp_statistics.UdpInErrors++;
 621                 kfree_skb(skb, FREE_WRITE);
 622                 return(0);
 623         }
 624 
 625         /* RFC1122 warning: According to 4.1.3.6, we MUST discard any */
 626         /* datagram which has an invalid source address, either here or */
 627         /* in IP. */
 628         /* Right now, IP isn't doing it, and neither is UDP. It's on the */
 629         /* FIXME list for IP, though, so I wouldn't worry about it. */
 630         /* (That's the Right Place to do it, IMHO.) -- MS */
 631 
 632         if (uh->check && (
 633                 ( (skb->ip_summed == CHECKSUM_HW) && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
 634                 ( (skb->ip_summed == CHECKSUM_NONE) && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
 635                           /* skip if CHECKSUM_UNNECESSARY */
 636                          )
 637            )
 638         {
 639                 /* <mea@utu.fi> wants to know, who sent it, to
 640                    go and stomp on the garbage sender... */
 641 
 642           /* RFC1122: OK.  Discards the bad packet silently (as far as */
 643           /* the network is concered, anyway) as per 4.1.3.4 (MUST). */
 644 
 645                 NETDEBUG(printk("UDP: bad checksum. From %08lX:%d to %08lX:%d ulen %d\n",
 646                        ntohl(saddr),ntohs(uh->source),
 647                        ntohl(daddr),ntohs(uh->dest),
 648                        ulen));
 649                 udp_statistics.UdpInErrors++;
 650                 kfree_skb(skb, FREE_WRITE);
 651                 return(0);
 652         }
 653 
 654 
 655         len=ulen;
 656 
 657 #ifdef CONFIG_IP_MULTICAST
 658         if (addr_type!=IS_MYADDR)
 659         {
 660                 /*
 661                  *      Multicasts and broadcasts go to each listener.
 662                  */
 663                 struct sock *sknext=NULL;
 664                 sk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
 665                                 saddr, uh->source, daddr);
 666                 if(sk)
 667                 {               
 668                         do
 669                         {
 670                                 struct sk_buff *skb1;
 671 
 672                                 sknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
 673                                 if(sknext)
 674                                         skb1=skb_clone(skb,GFP_ATOMIC);
 675                                 else
 676                                         skb1=skb;
 677                                 if(skb1)
 678                                         udp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
 679                                 sk=sknext;
 680                         }
 681                         while(sknext!=NULL);
 682                 }
 683                 else
 684                         kfree_skb(skb, FREE_READ);
 685                 return 0;
 686         }       
 687 #endif
 688         if(saddr==uh_cache_saddr && daddr==uh_cache_daddr && uh->dest==uh_cache_dport && uh->source==uh_cache_sport)
 689                 sk=(struct sock *)uh_cache_sk;
 690         else
 691         {
 692                 sk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
 693                 uh_cache_saddr=saddr;
 694                 uh_cache_daddr=daddr;
 695                 uh_cache_dport=uh->dest;
 696                 uh_cache_sport=uh->source;
 697                 uh_cache_sk=sk;
 698         }
 699         
 700         if (sk == NULL) 
 701         {
 702                 udp_statistics.UdpNoPorts++;
 703                 if (addr_type == IS_MYADDR) 
 704                 {
 705                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
 706                 }
 707                 /*
 708                  * Hmm.  We got an UDP broadcast to a port to which we
 709                  * don't wanna listen.  Ignore it.
 710                  */
 711                 skb->sk = NULL;
 712                 kfree_skb(skb, FREE_WRITE);
 713                 return(0);
 714         }
 715         return udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
 716 }
 717 
 718 static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
     /* [previous][next][first][last][top][bottom][index][help] */
 719 {
 720         skb->sk = sk;
 721         skb->dev = dev;
 722         skb_trim(skb,len);
 723 
 724         /*
 725          *      These are supposed to be switched. 
 726          */
 727          
 728         skb->daddr = saddr;
 729         skb->saddr = daddr;
 730 
 731 
 732         /*
 733          *      Charge it to the socket, dropping if the queue is full.
 734          */
 735 
 736         /* I assume this includes the IP options, as per RFC1122 (4.1.3.2). */
 737         /* If not, please let me know. -- MS */
 738 
 739         if (sock_queue_rcv_skb(sk,skb)<0) 
 740         {
 741                 udp_statistics.UdpInErrors++;
 742                 ip_statistics.IpInDiscards++;
 743                 ip_statistics.IpInDelivers--;
 744                 skb->sk = NULL;
 745                 kfree_skb(skb, FREE_WRITE);
 746                 return(0);
 747         }
 748         udp_statistics.UdpInDatagrams++;
 749         return(0);
 750 }
 751 
 752 
 753 struct proto udp_prot = {
 754         udp_close,
 755         ip_build_header,
 756         udp_connect,
 757         NULL,
 758         ip_queue_xmit,
 759         NULL,
 760         NULL,
 761         NULL,
 762         udp_rcv,
 763         datagram_select,
 764         udp_ioctl,
 765         NULL,
 766         NULL,
 767         ip_setsockopt,
 768         ip_getsockopt,
 769         udp_sendmsg,
 770         udp_recvmsg,
 771         NULL,           /* No special bind function */
 772         128,
 773         0,
 774         "UDP",
 775         0, 0,
 776         {NULL,}
 777 };

/* [previous][next][first][last][top][bottom][index][help] */