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,
404 int len, int noblock, 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 __u32 sa;
545 if (addr_len < sizeof(*usin))
546 return(-EINVAL);
547
548 if (usin->sin_family && usin->sin_family != AF_INET)
549 return(-EAFNOSUPPORT);
550 if (usin->sin_addr.s_addr==INADDR_ANY)
551 usin->sin_addr.s_addr=ip_my_addr();
552
553 if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
554 return -EACCES;
555
556 rt=(sk->localroute?ip_rt_local:ip_rt_route)((__u32)usin->sin_addr.s_addr, NULL, &sa);
557 if(rt==NULL)
558 return -ENETUNREACH;
559 if(!sk->saddr)
560 sk->saddr = sa;
561 if(!sk->rcv_saddr)
562 sk->rcv_saddr = sa;
563 sk->daddr = usin->sin_addr.s_addr;
564 sk->dummy_th.dest = usin->sin_port;
565 sk->state = TCP_ESTABLISHED;
566 udp_cache_zap();
567 sk->ip_route_cache = rt;
568 sk->ip_route_stamp = rt_stamp;
569 return(0);
570 }
571
572
573 static void udp_close(struct sock *sk, int timeout)
574 {
575 sk->inuse = 1;
576 sk->state = TCP_CLOSE;
577 if(uh_cache_sk==sk)
578 udp_cache_zap();
579 if (sk->dead)
580 destroy_sock(sk);
581 else
582 release_sock(sk);
583 }
584
585
586
587
588
589
590 int udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
591 __u32 daddr, unsigned short len,
592 __u32 saddr, int redo, struct inet_protocol *protocol)
593 {
594 struct sock *sk;
595 struct udphdr *uh;
596 unsigned short ulen;
597 int addr_type = IS_MYADDR;
598
599 if(!dev || dev->pa_addr!=daddr)
600 addr_type=ip_chk_addr(daddr);
601
602
603
604
605
606 uh = (struct udphdr *) skb->h.uh;
607
608 ip_statistics.IpInDelivers++;
609
610
611
612
613
614 ulen = ntohs(uh->len);
615
616 if (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh))
617 {
618 NETDEBUG(printk("UDP: short packet: %d/%d\n", ulen, len));
619 udp_statistics.UdpInErrors++;
620 kfree_skb(skb, FREE_WRITE);
621 return(0);
622 }
623
624
625
626
627
628
629
630
631 if (uh->check && (
632 ( skb->ip_summed && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
633 ( !skb->ip_summed && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
634 )
635 )
636 {
637
638
639
640
641
642
643 NETDEBUG(printk("UDP: bad checksum. From %08lX:%d to %08lX:%d ulen %d\n",
644 ntohl(saddr),ntohs(uh->source),
645 ntohl(daddr),ntohs(uh->dest),
646 ulen));
647 udp_statistics.UdpInErrors++;
648 kfree_skb(skb, FREE_WRITE);
649 return(0);
650 }
651
652
653 len=ulen;
654
655 #ifdef CONFIG_IP_MULTICAST
656 if (addr_type!=IS_MYADDR)
657 {
658
659
660
661 struct sock *sknext=NULL;
662 sk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
663 saddr, uh->source, daddr);
664 if(sk)
665 {
666 do
667 {
668 struct sk_buff *skb1;
669
670 sknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
671 if(sknext)
672 skb1=skb_clone(skb,GFP_ATOMIC);
673 else
674 skb1=skb;
675 if(skb1)
676 udp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
677 sk=sknext;
678 }
679 while(sknext!=NULL);
680 }
681 else
682 kfree_skb(skb, FREE_READ);
683 return 0;
684 }
685 #endif
686 if(saddr==uh_cache_saddr && daddr==uh_cache_daddr && uh->dest==uh_cache_dport && uh->source==uh_cache_sport)
687 sk=(struct sock *)uh_cache_sk;
688 else
689 {
690 sk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
691 uh_cache_saddr=saddr;
692 uh_cache_daddr=daddr;
693 uh_cache_dport=uh->dest;
694 uh_cache_sport=uh->source;
695 uh_cache_sk=sk;
696 }
697
698 if (sk == NULL)
699 {
700 udp_statistics.UdpNoPorts++;
701 if (addr_type == IS_MYADDR)
702 {
703 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
704 }
705
706
707
708
709 skb->sk = NULL;
710 kfree_skb(skb, FREE_WRITE);
711 return(0);
712 }
713 return udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
714 }
715
716 static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
717 {
718 skb->sk = sk;
719 skb->dev = dev;
720 skb_trim(skb,len);
721
722
723
724
725
726 skb->daddr = saddr;
727 skb->saddr = daddr;
728
729
730
731
732
733
734
735
736
737 if (sock_queue_rcv_skb(sk,skb)<0)
738 {
739 udp_statistics.UdpInErrors++;
740 ip_statistics.IpInDiscards++;
741 ip_statistics.IpInDelivers--;
742 skb->sk = NULL;
743 kfree_skb(skb, FREE_WRITE);
744 release_sock(sk);
745 return(0);
746 }
747 udp_statistics.UdpInDatagrams++;
748 release_sock(sk);
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,
772 128,
773 0,
774 "UDP",
775 0, 0,
776 {NULL,}
777 };