![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
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)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
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]](../icons/left.png)
*/
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)
/* */
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)
/* */
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)
/* */
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,
/* */
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,
/* */
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,
/* */
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)
/* */
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,
/* */
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)
/* */
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)
/* */
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,
/* */
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)
/* ![[last]](../icons/n_last.png)
*/
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 };
![[bottom]](../icons/n_bottom.png){kind=icon}
*/