This source file includes following definitions.
- udp_cache_zap
- udp_err
- udp_check
- udp_getfrag
- udp_getfrag_nosum
- udp_send
- udp_sendto
- udp_sendmsg
- udp_ioctl
- udp_recvmsg
- udp_connect
- udp_close
- udp_rcv
- udp_deliver
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
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
113
114
115 struct udp_mib udp_statistics;
116
117
118
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)
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
145
146
147
148
149
150
151
152
153
154 void udp_err(int type, int code, unsigned char *header, __u32 daddr,
155 __u32 saddr, struct inet_protocol *protocol)
156 {
157 struct udphdr *uh;
158 struct sock *sk;
159
160
161
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;
170
171 if (type == ICMP_SOURCE_QUENCH)
172 {
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
187
188
189
190
191
192
193
194
195
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)
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
221
222
223
224
225 static void udp_getfrag(const void *p, __u32 saddr, char * to, unsigned int offset, unsigned int fraglen)
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
260
261
262
263
264
265 static void udp_getfrag_nosum(const void *p, __u32 saddr, char * to, unsigned int offset, unsigned int fraglen)
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
292
293
294 static int udp_send(struct sock *sk, struct sockaddr_in *sin,
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
315
316
317
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,
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
341
342
343 if (flags&~MSG_DONTROUTE)
344 return(-EINVAL);
345
346
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
370
371
372
373
374
375
376
377
378
379
380
381
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;
388
389 sk->inuse = 1;
390
391
392 tmp = udp_send(sk, usin, from, len, flags, saddr, noblock);
393
394
395 release_sock(sk);
396 return(tmp);
397 }
398
399
400
401
402
403 static int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock,
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
412
413
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
436
437
438 int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
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
468
469
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
490
491
492
493 int udp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
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
504
505
506 if (addr_len)
507 *addr_len=sizeof(*sin);
508
509
510
511
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
523
524
525 skb_copy_datagram_iovec(skb,sizeof(struct udphdr),msg->msg_iov,copied);
526 sk->stamp=skb->stamp;
527
528
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)
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;
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;
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)
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
586
587
588 int udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
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
602
603
604 uh = (struct udphdr *) skb->h.uh;
605
606 ip_statistics.IpInDelivers++;
607
608
609
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
623
624
625
626
627
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
636
637
638
639
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
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
705
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)
715 {
716 skb->sk = sk;
717 skb->dev = dev;
718 skb_trim(skb,len);
719
720
721
722
723
724 skb->daddr = saddr;
725 skb->saddr = daddr;
726
727
728
729
730
731
732
733
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,
770 128,
771 0,
772 "UDP",
773 0, 0,
774 {NULL,}
775 };