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                 sk->err = icmp_err_convert[code].errno;
 200                 sk->error_report(sk);
 201         }
 202 }
 203 
 204 
 205 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] */
 206 {
 207         return(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));
 208 }
 209 
 210 struct udpfakehdr 
 211 {
 212         struct udphdr uh;
 213         int daddr;
 214         int other;
 215         const char *from;
 216         int wcheck;
 217 };
 218 
 219 /*
 220  *      Copy and checksum a UDP packet from user space into a buffer. We still have to do the planning to
 221  *      get ip_build_xmit to spot direct transfer to network card and provide an additional callback mode
 222  *      for direct user->board I/O transfers. That one will be fun.
 223  */
 224  
 225 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] */
 226 {
 227         struct udpfakehdr *ufh = (struct udpfakehdr *)p;
 228         const char *src;
 229         char *dst;
 230         unsigned int len;
 231 
 232         if (offset) 
 233         {
 234                 len = fraglen;
 235                 src = ufh->from+(offset-sizeof(struct udphdr));
 236                 dst = to;
 237         }
 238         else 
 239         {
 240                 len = fraglen-sizeof(struct udphdr);
 241                 src = ufh->from;
 242                 dst = to+sizeof(struct udphdr);
 243         }
 244         ufh->wcheck = csum_partial_copy_fromuser(src, dst, len, ufh->wcheck);
 245         if (offset == 0) 
 246         {
 247                 ufh->wcheck = csum_partial((char *)ufh, sizeof(struct udphdr),
 248                                    ufh->wcheck);
 249                 ufh->uh.check = csum_tcpudp_magic(saddr, ufh->daddr, 
 250                                           ntohs(ufh->uh.len),
 251                                           IPPROTO_UDP, ufh->wcheck);
 252                 if (ufh->uh.check == 0)
 253                         ufh->uh.check = -1;
 254                 memcpy(to, ufh, sizeof(struct udphdr));
 255         }
 256 }
 257 
 258 /*
 259  *      Uncheckummed UDP is sufficiently criticial to stuff like ATM video conferencing
 260  *      that we use two routines for this for speed. Probably we ought to have a CONFIG_FAST_NET
 261  *      set for >10Mb/second boards to activate this sort of coding. Timing needed to verify if
 262  *      this is a valid decision.
 263  */
 264  
 265 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] */
 266 {
 267         struct udpfakehdr *ufh = (struct udpfakehdr *)p;
 268         const char *src;
 269         char *dst;
 270         unsigned int len;
 271 
 272         if (offset) 
 273         {
 274                 len = fraglen;
 275                 src = ufh->from+(offset-sizeof(struct udphdr));
 276                 dst = to;
 277         }
 278         else 
 279         {
 280                 len = fraglen-sizeof(struct udphdr);
 281                 src = ufh->from;
 282                 dst = to+sizeof(struct udphdr);
 283         }
 284         memcpy_fromfs(dst,src,len);
 285         if (offset == 0) 
 286                 memcpy(to, ufh, sizeof(struct udphdr));
 287 }
 288 
 289 
 290 /*
 291  *      Send UDP frames.
 292  */
 293 
 294 static int udp_send(struct sock *sk, struct sockaddr_in *sin,
     /* [previous][next][first][last][top][bottom][index][help] */
 295                       const unsigned char *from, int len, int rt,
 296                     __u32 saddr, int noblock) 
 297 {
 298         int ulen = len + sizeof(struct udphdr);
 299         int a;
 300         struct udpfakehdr ufh;
 301         
 302         if(ulen>65535-sizeof(struct iphdr))
 303                 return -EMSGSIZE;
 304 
 305         ufh.uh.source = sk->dummy_th.source;
 306         ufh.uh.dest = sin->sin_port;
 307         ufh.uh.len = htons(ulen);
 308         ufh.uh.check = 0;
 309         ufh.daddr = sin->sin_addr.s_addr;
 310         ufh.other = (htons(ulen) << 16) + IPPROTO_UDP*256;
 311         ufh.from = from;
 312         ufh.wcheck = 0;
 313 
 314         /* RFC1122: OK.  Provides the checksumming facility (MUST) as per */
 315         /* 4.1.3.4. It's configurable by the application via setsockopt() */
 316         /* (MAY) and it defaults to on (MUST).  Almost makes up for the */
 317         /* violation above. -- MS */
 318 
 319         if(sk->no_check)
 320                 a = ip_build_xmit(sk, udp_getfrag_nosum, &ufh, ulen, 
 321                         sin->sin_addr.s_addr, saddr, sk->opt, rt, IPPROTO_UDP, noblock);
 322         else
 323                 a = ip_build_xmit(sk, udp_getfrag, &ufh, ulen, 
 324                         sin->sin_addr.s_addr, saddr, sk->opt, rt, IPPROTO_UDP, noblock);
 325         if(a<0)
 326                 return a;
 327         udp_statistics.UdpOutDatagrams++;
 328         return len;
 329 }
 330 
 331 
 332 static int udp_sendto(struct sock *sk, const unsigned char *from, int len, int noblock,
     /* [previous][next][first][last][top][bottom][index][help] */
 333            unsigned flags, struct sockaddr_in *usin, int addr_len)
 334 {
 335         struct sockaddr_in sin;
 336         int tmp;
 337         __u32 saddr=0;
 338 
 339         /* 
 340          *      Check the flags. We support no flags for UDP sending
 341          */
 342 
 343         if (flags&~MSG_DONTROUTE) 
 344                 return(-EINVAL);
 345         /*
 346          *      Get and verify the address. 
 347          */
 348          
 349         if (usin) 
 350         {
 351                 if (addr_len < sizeof(sin)) 
 352                         return(-EINVAL);
 353                 if (usin->sin_family && usin->sin_family != AF_INET) 
 354                         return(-EINVAL);
 355                 if (usin->sin_port == 0) 
 356                         return(-EINVAL);
 357         } 
 358         else 
 359         {
 360                 if (sk->state != TCP_ESTABLISHED) 
 361                         return(-EINVAL);
 362                 sin.sin_family = AF_INET;
 363                 sin.sin_port = sk->dummy_th.dest;
 364                 sin.sin_addr.s_addr = sk->daddr;
 365                 usin = &sin;
 366         }
 367   
 368         /*
 369          *      BSD socket semantics. You must set SO_BROADCAST to permit
 370          *      broadcasting of data.
 371          */
 372          
 373         /* RFC1122: OK.  Allows the application to select the specific */
 374         /* source address for an outgoing packet (MUST) as per 4.1.3.5. */
 375         /* Optional addition: a mechanism for telling the application what */
 376         /* address was used. (4.1.3.5, MAY) -- MS */
 377 
 378         /* RFC1122: MUST ensure that all outgoing packets have one */
 379         /* of this host's addresses as a source addr.(4.1.3.6) - bind in  */
 380         /* af_inet.c checks these. It does need work to allow BSD style */
 381         /* bind to multicast as is done by xntpd                */
 382 
 383         if(usin->sin_addr.s_addr==INADDR_ANY)
 384                 usin->sin_addr.s_addr=ip_my_addr();
 385                 
 386         if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
 387                 return -EACCES;                 /* Must turn broadcast on first */
 388 
 389         sk->inuse = 1;
 390 
 391         /* Send the packet. */
 392         tmp = udp_send(sk, usin, from, len, flags, saddr, noblock);
 393 
 394         /* The datagram has been sent off.  Release the socket. */
 395         release_sock(sk);
 396         return(tmp);
 397 }
 398 
 399 /*
 400  *      Temporary
 401  */
 402  
 403 static int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock, 
     /* [previous][next][first][last][top][bottom][index][help] */
 404         int flags)
 405 {
 406         if(msg->msg_iovlen==1)
 407                 return udp_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);
 408         else
 409         {
 410                 /*
 411                  *      For awkward cases we linearise the buffer first. In theory this is only frames
 412                  *      whose iovec's don't split on 4 byte boundaries, and soon encrypted stuff (to keep
 413                  *      skip happy). We are a bit more general about it.
 414                  */
 415                  
 416                 unsigned char *buf;
 417                 int fs;
 418                 int err;
 419                 if(len>65515)
 420                         return -EMSGSIZE;
 421                 buf=kmalloc(len, GFP_KERNEL);
 422                 if(buf==NULL)
 423                         return -ENOBUFS;
 424                 memcpy_fromiovec(buf, msg->msg_iov, len);
 425                 fs=get_fs();
 426                 set_fs(get_fs());
 427                 err=udp_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);
 428                 set_fs(fs);
 429                 kfree_s(buf,len);
 430                 return err;
 431         }
 432 }
 433 
 434 /*
 435  *      IOCTL requests applicable to the UDP protocol
 436  */
 437  
 438 int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 439 {
 440         int err;
 441         switch(cmd) 
 442         {
 443                 case TIOCOUTQ:
 444                 {
 445                         unsigned long amount;
 446 
 447                         if (sk->state == TCP_LISTEN) return(-EINVAL);
 448                         amount = sock_wspace(sk);
 449                         err=verify_area(VERIFY_WRITE,(void *)arg,
 450                                         sizeof(unsigned long));
 451                         if(err)
 452                                 return(err);
 453                         put_fs_long(amount,(unsigned long *)arg);
 454                         return(0);
 455                 }
 456 
 457                 case TIOCINQ:
 458                 {
 459                         struct sk_buff *skb;
 460                         unsigned long amount;
 461 
 462                         if (sk->state == TCP_LISTEN) return(-EINVAL);
 463                         amount = 0;
 464                         skb = skb_peek(&sk->receive_queue);
 465                         if (skb != NULL) {
 466                                 /*
 467                                  * We will only return the amount
 468                                  * of this packet since that is all
 469                                  * that will be read.
 470                                  */
 471                                 amount = skb->len;
 472                         }
 473                         err=verify_area(VERIFY_WRITE,(void *)arg,
 474                                                 sizeof(unsigned long));
 475                         if(err)
 476                                 return(err);
 477                         put_fs_long(amount,(unsigned long *)arg);
 478                         return(0);
 479                 }
 480 
 481                 default:
 482                         return(-EINVAL);
 483         }
 484         return(0);
 485 }
 486 
 487 
 488 /*
 489  *      This should be easy, if there is something there we\
 490  *      return it, otherwise we block.
 491  */
 492 
 493 int udp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
     /* [previous][next][first][last][top][bottom][index][help] */
 494              int noblock, int flags,int *addr_len)
 495 {
 496         int copied = 0;
 497         int truesize;
 498         struct sk_buff *skb;
 499         int er;
 500         struct sockaddr_in *sin=(struct sockaddr_in *)msg->msg_name;
 501 
 502         /*
 503          *      Check any passed addresses
 504          */
 505          
 506         if (addr_len) 
 507                 *addr_len=sizeof(*sin);
 508   
 509         /*
 510          *      From here the generic datagram does a lot of the work. Come
 511          *      the finished NET3, it will do _ALL_ the work!
 512          */
 513                 
 514         skb=skb_recv_datagram(sk,flags,noblock,&er);
 515         if(skb==NULL)
 516                 return er;
 517   
 518         truesize = skb->len - sizeof(struct udphdr);
 519         copied = min(len, truesize);
 520 
 521         /*
 522          *      FIXME : should use udp header size info value 
 523          */
 524          
 525         skb_copy_datagram_iovec(skb,sizeof(struct udphdr),msg->msg_iov,copied);
 526         sk->stamp=skb->stamp;
 527 
 528         /* Copy the address. */
 529         if (sin) 
 530         {
 531                 sin->sin_family = AF_INET;
 532                 sin->sin_port = skb->h.uh->source;
 533                 sin->sin_addr.s_addr = skb->daddr;
 534         }
 535   
 536         skb_free_datagram(skb);
 537         release_sock(sk);
 538         return(copied);
 539 }
 540 
 541 int udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
     /* [previous][next][first][last][top][bottom][index][help] */
 542 {
 543         struct rtable *rt;
 544         if (addr_len < sizeof(*usin)) 
 545                 return(-EINVAL);
 546 
 547         if (usin->sin_family && usin->sin_family != AF_INET) 
 548                 return(-EAFNOSUPPORT);
 549         if (usin->sin_addr.s_addr==INADDR_ANY)
 550                 usin->sin_addr.s_addr=ip_my_addr();
 551 
 552         if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
 553                 return -EACCES;                 /* Must turn broadcast on first */
 554         
 555         rt=ip_rt_route((__u32)usin->sin_addr.s_addr, sk->localroute);
 556         if (rt==NULL)
 557                 return -ENETUNREACH;
 558         if(!sk->saddr)
 559                 sk->saddr = rt->rt_src;         /* Update source address */
 560         if(!sk->rcv_saddr)
 561                 sk->rcv_saddr = rt->rt_src;
 562         sk->daddr = usin->sin_addr.s_addr;
 563         sk->dummy_th.dest = usin->sin_port;
 564         sk->state = TCP_ESTABLISHED;
 565         udp_cache_zap();
 566         sk->ip_route_cache = rt;
 567         return(0);
 568 }
 569 
 570 
 571 static void udp_close(struct sock *sk, int timeout)
     /* [previous][next][first][last][top][bottom][index][help] */
 572 {
 573         sk->inuse = 1;
 574         sk->state = TCP_CLOSE;
 575         if(uh_cache_sk==sk)
 576                 udp_cache_zap();
 577         if (sk->dead) 
 578                 destroy_sock(sk);
 579         else
 580                 release_sock(sk);
 581 }
 582 
 583 
 584 /*
 585  *      All we need to do is get the socket, and then do a checksum. 
 586  */
 587  
 588 int udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
     /* [previous][next][first][last][top][bottom][index][help] */
 589         __u32 daddr, unsigned short len,
 590         __u32 saddr, int redo, struct inet_protocol *protocol)
 591 {
 592         struct sock *sk;
 593         struct udphdr *uh;
 594         unsigned short ulen;
 595         int addr_type = IS_MYADDR;
 596         
 597         if(!dev || dev->pa_addr!=daddr)
 598                 addr_type=ip_chk_addr(daddr);
 599                 
 600         /*
 601          *      Get the header.
 602          */
 603          
 604         uh = (struct udphdr *) skb->h.uh;
 605         
 606         ip_statistics.IpInDelivers++;
 607 
 608         /*
 609          *      Validate the packet and the UDP length.
 610          */
 611          
 612         ulen = ntohs(uh->len);
 613         
 614         if (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh)) 
 615         {
 616                 NETDEBUG(printk("UDP: short packet: %d/%d\n", ulen, len));
 617                 udp_statistics.UdpInErrors++;
 618                 kfree_skb(skb, FREE_WRITE);
 619                 return(0);
 620         }
 621 
 622         /* RFC1122 warning: According to 4.1.3.6, we MUST discard any */
 623         /* datagram which has an invalid source address, either here or */
 624         /* in IP. */
 625         /* Right now, IP isn't doing it, and neither is UDP. It's on the */
 626         /* FIXME list for IP, though, so I wouldn't worry about it. */
 627         /* (That's the Right Place to do it, IMHO.) -- MS */
 628 
 629         if (uh->check && (
 630                 ( skb->ip_summed && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
 631                 ( !skb->ip_summed && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
 632                          )
 633            )
 634         {
 635                 /* <mea@utu.fi> wants to know, who sent it, to
 636                    go and stomp on the garbage sender... */
 637 
 638           /* RFC1122: OK.  Discards the bad packet silently (as far as */
 639           /* the network is concered, anyway) as per 4.1.3.4 (MUST). */
 640 
 641                 NETDEBUG(printk("UDP: bad checksum. From %08lX:%d to %08lX:%d ulen %d\n",
 642                        ntohl(saddr),ntohs(uh->source),
 643                        ntohl(daddr),ntohs(uh->dest),
 644                        ulen));
 645                 udp_statistics.UdpInErrors++;
 646                 kfree_skb(skb, FREE_WRITE);
 647                 return(0);
 648         }
 649 
 650 
 651         len=ulen;
 652 
 653 #ifdef CONFIG_IP_MULTICAST
 654         if (addr_type!=IS_MYADDR)
 655         {
 656                 /*
 657                  *      Multicasts and broadcasts go to each listener.
 658                  */
 659                 struct sock *sknext=NULL;
 660                 sk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
 661                                 saddr, uh->source, daddr);
 662                 if(sk)
 663                 {               
 664                         do
 665                         {
 666                                 struct sk_buff *skb1;
 667 
 668                                 sknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
 669                                 if(sknext)
 670                                         skb1=skb_clone(skb,GFP_ATOMIC);
 671                                 else
 672                                         skb1=skb;
 673                                 if(skb1)
 674                                         udp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
 675                                 sk=sknext;
 676                         }
 677                         while(sknext!=NULL);
 678                 }
 679                 else
 680                         kfree_skb(skb, FREE_READ);
 681                 return 0;
 682         }       
 683 #endif
 684         if(saddr==uh_cache_saddr && daddr==uh_cache_daddr && uh->dest==uh_cache_dport && uh->source==uh_cache_sport)
 685                 sk=(struct sock *)uh_cache_sk;
 686         else
 687         {
 688                 sk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
 689                 uh_cache_saddr=saddr;
 690                 uh_cache_daddr=daddr;
 691                 uh_cache_dport=uh->dest;
 692                 uh_cache_sport=uh->source;
 693                 uh_cache_sk=sk;
 694         }
 695         
 696         if (sk == NULL) 
 697         {
 698                 udp_statistics.UdpNoPorts++;
 699                 if (addr_type == IS_MYADDR) 
 700                 {
 701                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
 702                 }
 703                 /*
 704                  * Hmm.  We got an UDP broadcast to a port to which we
 705                  * don't wanna listen.  Ignore it.
 706                  */
 707                 skb->sk = NULL;
 708                 kfree_skb(skb, FREE_WRITE);
 709                 return(0);
 710         }
 711         return udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
 712 }
 713 
 714 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] */
 715 {
 716         skb->sk = sk;
 717         skb->dev = dev;
 718         skb_trim(skb,len);
 719 
 720         /*
 721          *      These are supposed to be switched. 
 722          */
 723          
 724         skb->daddr = saddr;
 725         skb->saddr = daddr;
 726 
 727 
 728         /*
 729          *      Charge it to the socket, dropping if the queue is full.
 730          */
 731 
 732         /* I assume this includes the IP options, as per RFC1122 (4.1.3.2). */
 733         /* If not, please let me know. -- MS */
 734 
 735         if (sock_queue_rcv_skb(sk,skb)<0) 
 736         {
 737                 udp_statistics.UdpInErrors++;
 738                 ip_statistics.IpInDiscards++;
 739                 ip_statistics.IpInDelivers--;
 740                 skb->sk = NULL;
 741                 kfree_skb(skb, FREE_WRITE);
 742                 release_sock(sk);
 743                 return(0);
 744         }
 745         udp_statistics.UdpInDatagrams++;
 746         release_sock(sk);
 747         return(0);
 748 }
 749 
 750 
 751 struct proto udp_prot = {
 752         udp_close,
 753         ip_build_header,
 754         udp_connect,
 755         NULL,
 756         ip_queue_xmit,
 757         NULL,
 758         NULL,
 759         NULL,
 760         udp_rcv,
 761         datagram_select,
 762         udp_ioctl,
 763         NULL,
 764         NULL,
 765         ip_setsockopt,
 766         ip_getsockopt,
 767         udp_sendmsg,
 768         udp_recvmsg,
 769         NULL,           /* No special bind function */
 770         128,
 771         0,
 772         "UDP",
 773         0, 0,
 774         {NULL,}
 775 };

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