This source file includes following definitions.
- udp_cache_zap
- udp_err
- udp_check
- udp_getfrag
- udp_getfrag_nosum
- udp_send
- udp_sendto
- udp_write
- udp_ioctl
- udp_recvfrom
- udp_read
- 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 #include <asm/system.h>
85 #include <asm/segment.h>
86 #include <linux/types.h>
87 #include <linux/sched.h>
88 #include <linux/fcntl.h>
89 #include <linux/socket.h>
90 #include <linux/sockios.h>
91 #include <linux/in.h>
92 #include <linux/errno.h>
93 #include <linux/timer.h>
94 #include <linux/termios.h>
95 #include <linux/mm.h>
96 #include <linux/config.h>
97 #include <linux/inet.h>
98 #include <linux/netdevice.h>
99 #include <net/snmp.h>
100 #include <net/ip.h>
101 #include <net/protocol.h>
102 #include <net/tcp.h>
103 #include <linux/skbuff.h>
104 #include <net/sock.h>
105 #include <net/udp.h>
106 #include <net/icmp.h>
107 #include <net/route.h>
108 #include <net/checksum.h>
109
110
111
112
113
114 struct udp_mib udp_statistics;
115
116
117
118
119
120 volatile unsigned long uh_cache_saddr,uh_cache_daddr;
121 volatile unsigned short uh_cache_dport, uh_cache_sport;
122 volatile struct sock *uh_cache_sk;
123
124 void udp_cache_zap(void)
125 {
126 unsigned long flags;
127 save_flags(flags);
128 cli();
129 uh_cache_saddr=0;
130 uh_cache_daddr=0;
131 uh_cache_dport=0;
132 uh_cache_sport=0;
133 uh_cache_sk=NULL;
134 restore_flags(flags);
135 }
136
137 static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
138
139 #define min(a,b) ((a)<(b)?(a):(b))
140
141
142
143
144
145
146
147
148
149
150
151
152
153 void udp_err(int err, unsigned char *header, unsigned long daddr,
154 unsigned long saddr, struct inet_protocol *protocol)
155 {
156 struct udphdr *th;
157 struct sock *sk;
158 struct iphdr *ip=(struct iphdr *)header;
159
160 header += 4*ip->ihl;
161
162
163
164
165
166 th = (struct udphdr *)header;
167
168 sk = get_sock(&udp_prot, th->source, daddr, th->dest, saddr);
169
170 if (sk == NULL)
171 return;
172
173 if ((err & 0xff00) == (ICMP_SOURCE_QUENCH << 8))
174 {
175 if (sk->cong_window > 1)
176 sk->cong_window = sk->cong_window/2;
177 return;
178 }
179
180
181
182
183
184
185
186
187
188
189
190
191
192 if (icmp_err_convert[err & 0xff].fatal)
193 {
194 sk->err = icmp_err_convert[err & 0xff].errno;
195 sk->error_report(sk);
196 }
197 }
198
199
200 static unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
201 {
202 return(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));
203 }
204
205 struct udpfakehdr
206 {
207 struct udphdr uh;
208 int daddr;
209 int other;
210 const char *from;
211 int wcheck;
212 };
213
214
215
216
217
218
219
220 static void udp_getfrag(const void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen)
221 {
222 struct udpfakehdr *ufh = (struct udpfakehdr *)p;
223 const char *src;
224 char *dst;
225 unsigned int len;
226
227 if (offset)
228 {
229 len = fraglen;
230 src = ufh->from+(offset-sizeof(struct udphdr));
231 dst = to;
232 }
233 else
234 {
235 len = fraglen-sizeof(struct udphdr);
236 src = ufh->from;
237 dst = to+sizeof(struct udphdr);
238 }
239 ufh->wcheck = csum_partial_copy_fromuser(src, dst, len, ufh->wcheck);
240 if (offset == 0)
241 {
242 ufh->wcheck = csum_partial((char *)ufh, sizeof(struct udphdr),
243 ufh->wcheck);
244 ufh->uh.check = csum_tcpudp_magic(saddr, ufh->daddr,
245 ntohs(ufh->uh.len),
246 IPPROTO_UDP, ufh->wcheck);
247 if (ufh->uh.check == 0)
248 ufh->uh.check = -1;
249 memcpy(to, ufh, sizeof(struct udphdr));
250 }
251 }
252
253
254
255
256
257
258
259
260 static void udp_getfrag_nosum(const void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen)
261 {
262 struct udpfakehdr *ufh = (struct udpfakehdr *)p;
263 const char *src;
264 char *dst;
265 unsigned int len;
266
267 if (offset)
268 {
269 len = fraglen;
270 src = ufh->from+(offset-sizeof(struct udphdr));
271 dst = to;
272 }
273 else
274 {
275 len = fraglen-sizeof(struct udphdr);
276 src = ufh->from;
277 dst = to+sizeof(struct udphdr);
278 }
279 memcpy_fromfs(dst,src,len);
280 if (offset == 0)
281 memcpy(to, ufh, sizeof(struct udphdr));
282 }
283
284
285
286
287
288
289 static int udp_send(struct sock *sk, struct sockaddr_in *sin,
290 const unsigned char *from, int len, int rt)
291 {
292 int ulen = len + sizeof(struct udphdr);
293 int a;
294 struct udpfakehdr ufh;
295
296 ufh.uh.source = sk->dummy_th.source;
297 ufh.uh.dest = sin->sin_port;
298 ufh.uh.len = htons(ulen);
299 ufh.uh.check = 0;
300 ufh.daddr = sin->sin_addr.s_addr;
301 ufh.other = (htons(ulen) << 16) + IPPROTO_UDP*256;
302 ufh.from = from;
303 ufh.wcheck = 0;
304
305
306
307
308
309
310
311
312
313
314
315 if(sk->no_check)
316 a = ip_build_xmit(sk, udp_getfrag_nosum, &ufh, ulen,
317 sin->sin_addr.s_addr, rt, IPPROTO_UDP);
318 else
319 a = ip_build_xmit(sk, udp_getfrag, &ufh, ulen,
320 sin->sin_addr.s_addr, rt, IPPROTO_UDP);
321 if(a<0)
322 return a;
323 udp_statistics.UdpOutDatagrams++;
324 return len;
325 }
326
327
328 static int udp_sendto(struct sock *sk, const unsigned char *from, int len, int noblock,
329 unsigned flags, struct sockaddr_in *usin, int addr_len)
330 {
331 struct sockaddr_in sin;
332 int tmp;
333
334
335
336
337 if (flags&~MSG_DONTROUTE)
338 return(-EINVAL);
339
340
341
342
343 if (usin)
344 {
345 if (addr_len < sizeof(sin))
346 return(-EINVAL);
347 if (usin->sin_family && usin->sin_family != AF_INET)
348 return(-EINVAL);
349 if (usin->sin_port == 0)
350 return(-EINVAL);
351 }
352 else
353 {
354 if (sk->state != TCP_ESTABLISHED)
355 return(-EINVAL);
356 sin.sin_family = AF_INET;
357 sin.sin_port = sk->dummy_th.dest;
358 sin.sin_addr.s_addr = sk->daddr;
359 usin = &sin;
360 }
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377 if(usin->sin_addr.s_addr==INADDR_ANY)
378 usin->sin_addr.s_addr=ip_my_addr();
379
380 if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
381 return -EACCES;
382
383 sk->inuse = 1;
384
385
386 tmp = udp_send(sk, usin, from, len, flags);
387
388
389 release_sock(sk);
390 return(tmp);
391 }
392
393
394
395
396
397 static int udp_write(struct sock *sk, const unsigned char *buff, int len, int noblock,
398 unsigned flags)
399 {
400 return(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
401 }
402
403
404
405
406
407
408 int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
409 {
410 int err;
411 switch(cmd)
412 {
413 case TIOCOUTQ:
414 {
415 unsigned long amount;
416
417 if (sk->state == TCP_LISTEN) return(-EINVAL);
418 amount = sk->prot->wspace(sk);
419 err=verify_area(VERIFY_WRITE,(void *)arg,
420 sizeof(unsigned long));
421 if(err)
422 return(err);
423 put_fs_long(amount,(unsigned long *)arg);
424 return(0);
425 }
426
427 case TIOCINQ:
428 {
429 struct sk_buff *skb;
430 unsigned long amount;
431
432 if (sk->state == TCP_LISTEN) return(-EINVAL);
433 amount = 0;
434 skb = skb_peek(&sk->receive_queue);
435 if (skb != NULL) {
436
437
438
439
440
441 amount = skb->len;
442 }
443 err=verify_area(VERIFY_WRITE,(void *)arg,
444 sizeof(unsigned long));
445 if(err)
446 return(err);
447 put_fs_long(amount,(unsigned long *)arg);
448 return(0);
449 }
450
451 default:
452 return(-EINVAL);
453 }
454 return(0);
455 }
456
457
458
459
460
461
462
463 int udp_recvfrom(struct sock *sk, unsigned char *to, int len,
464 int noblock, unsigned flags, struct sockaddr_in *sin,
465 int *addr_len)
466 {
467 int copied = 0;
468 int truesize;
469 struct sk_buff *skb;
470 int er;
471
472
473
474
475
476 if (addr_len)
477 *addr_len=sizeof(*sin);
478
479
480
481
482
483
484 skb=skb_recv_datagram(sk,flags,noblock,&er);
485 if(skb==NULL)
486 return er;
487
488 truesize = skb->len - sizeof(struct udphdr);
489 copied = min(len, truesize);
490
491
492
493
494
495 skb_copy_datagram(skb,sizeof(struct udphdr),to,copied);
496 sk->stamp=skb->stamp;
497
498
499 if (sin)
500 {
501 sin->sin_family = AF_INET;
502 sin->sin_port = skb->h.uh->source;
503 sin->sin_addr.s_addr = skb->daddr;
504 }
505
506 skb_free_datagram(skb);
507 release_sock(sk);
508 return(copied);
509 }
510
511
512
513
514
515 int udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
516 unsigned flags)
517 {
518 return(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
519 }
520
521
522 int udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
523 {
524 struct rtable *rt;
525 unsigned long sa;
526 if (addr_len < sizeof(*usin))
527 return(-EINVAL);
528
529 if (usin->sin_family && usin->sin_family != AF_INET)
530 return(-EAFNOSUPPORT);
531 if (usin->sin_addr.s_addr==INADDR_ANY)
532 usin->sin_addr.s_addr=ip_my_addr();
533
534 if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
535 return -EACCES;
536
537 rt=(sk->localroute?ip_rt_local:ip_rt_route)(usin->sin_addr.s_addr, NULL, &sa);
538 if(rt==NULL)
539 return -ENETUNREACH;
540 sk->saddr = sa;
541 sk->daddr = usin->sin_addr.s_addr;
542 sk->dummy_th.dest = usin->sin_port;
543 sk->state = TCP_ESTABLISHED;
544 udp_cache_zap();
545 sk->ip_route_cache = rt;
546 sk->ip_route_stamp = rt_stamp;
547 return(0);
548 }
549
550
551 static void udp_close(struct sock *sk, int timeout)
552 {
553 sk->inuse = 1;
554 sk->state = TCP_CLOSE;
555 if(uh_cache_sk==sk)
556 udp_cache_zap();
557 if (sk->dead)
558 destroy_sock(sk);
559 else
560 release_sock(sk);
561 }
562
563
564
565
566
567
568 int udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
569 unsigned long daddr, unsigned short len,
570 unsigned long saddr, int redo, struct inet_protocol *protocol)
571 {
572 struct sock *sk;
573 struct udphdr *uh;
574 unsigned short ulen;
575 int addr_type = IS_MYADDR;
576
577 if(!dev || dev->pa_addr!=daddr)
578 addr_type=ip_chk_addr(daddr);
579
580
581
582
583
584 uh = (struct udphdr *) skb->h.uh;
585
586 ip_statistics.IpInDelivers++;
587
588
589
590
591
592 ulen = ntohs(uh->len);
593
594 if (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh))
595 {
596 NETDEBUG(printk("UDP: short packet: %d/%d\n", ulen, len));
597 udp_statistics.UdpInErrors++;
598 kfree_skb(skb, FREE_WRITE);
599 return(0);
600 }
601
602
603
604
605
606
607
608
609 if (uh->check && (
610 ( skb->ip_summed && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
611 ( !skb->ip_summed && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
612 )
613 )
614 {
615
616
617
618
619
620
621 NETDEBUG(printk("UDP: bad checksum. From %08lX:%d to %08lX:%d ulen %d\n",
622 ntohl(saddr),ntohs(uh->source),
623 ntohl(daddr),ntohs(uh->dest),
624 ulen));
625 udp_statistics.UdpInErrors++;
626 kfree_skb(skb, FREE_WRITE);
627 return(0);
628 }
629
630
631 len=ulen;
632
633 #ifdef CONFIG_IP_MULTICAST
634 if (addr_type!=IS_MYADDR)
635 {
636
637
638
639 struct sock *sknext=NULL;
640 sk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
641 saddr, uh->source, daddr);
642 if(sk)
643 {
644 do
645 {
646 struct sk_buff *skb1;
647
648 sknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
649 if(sknext)
650 skb1=skb_clone(skb,GFP_ATOMIC);
651 else
652 skb1=skb;
653 if(skb1)
654 udp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
655 sk=sknext;
656 }
657 while(sknext!=NULL);
658 }
659 else
660 kfree_skb(skb, FREE_READ);
661 return 0;
662 }
663 #endif
664 if(saddr==uh_cache_saddr && daddr==uh_cache_daddr && uh->dest==uh_cache_dport && uh->source==uh_cache_sport)
665 sk=(struct sock *)uh_cache_sk;
666 else
667 {
668 sk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
669 uh_cache_saddr=saddr;
670 uh_cache_daddr=daddr;
671 uh_cache_dport=uh->dest;
672 uh_cache_sport=uh->source;
673 uh_cache_sk=sk;
674 }
675
676 if (sk == NULL)
677 {
678 udp_statistics.UdpNoPorts++;
679 if (addr_type == IS_MYADDR)
680 {
681 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
682 }
683
684
685
686
687 skb->sk = NULL;
688 kfree_skb(skb, FREE_WRITE);
689 return(0);
690 }
691 return udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
692 }
693
694 static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
695 {
696 skb->sk = sk;
697 skb->dev = dev;
698 skb_trim(skb,len);
699
700
701
702
703
704 skb->daddr = saddr;
705 skb->saddr = daddr;
706
707
708
709
710
711
712
713
714
715 if (sock_queue_rcv_skb(sk,skb)<0)
716 {
717 udp_statistics.UdpInErrors++;
718 ip_statistics.IpInDiscards++;
719 ip_statistics.IpInDelivers--;
720 skb->sk = NULL;
721 kfree_skb(skb, FREE_WRITE);
722 release_sock(sk);
723 return(0);
724 }
725 udp_statistics.UdpInDatagrams++;
726 release_sock(sk);
727 return(0);
728 }
729
730
731 struct proto udp_prot = {
732 sock_wmalloc,
733 sock_rmalloc,
734 sock_wfree,
735 sock_rfree,
736 sock_rspace,
737 sock_wspace,
738 udp_close,
739 udp_read,
740 udp_write,
741 udp_sendto,
742 udp_recvfrom,
743 ip_build_header,
744 udp_connect,
745 NULL,
746 ip_queue_xmit,
747 NULL,
748 NULL,
749 NULL,
750 udp_rcv,
751 datagram_select,
752 udp_ioctl,
753 NULL,
754 NULL,
755 ip_setsockopt,
756 ip_getsockopt,
757 128,
758 0,
759 "UDP",
760 0, 0,
761 {NULL,}
762 };