![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to udp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / net / tcp|
Return to udp.c CVS log | Up to [Early Linux] / linux / net / tcp |
1.1 root 1: /* udp.c */
2: /*
3: Copyright (C) 1992 Ross Biro
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License as published by
7: the Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This program is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; if not, write to the Free Software
17: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: The Author may be reached as [email protected] or
20: C/O Department of Mathematics; Stanford University; Stanford, CA 94305
21: */
22:
23: #include <linux/types.h>
24: #include <linux/sched.h>
25: #include <linux/fcntl.h>
26: #include <linux/socket.h>
27: #include <netinet/in.h>
28: #include "timer.h"
29: #include "ip.h"
30: #include "tcp.h"
31: #include "sock.h"
32: #include <linux/errno.h>
33: #include <linux/timer.h>
34: #include <asm/system.h>
35: #include <asm/segment.h>
36: #include "../kern_sock.h" /* for PRINTK */
37: #include "udp.h"
38: #include "icmp.h"
39:
40: #define min(a,b) ((a)<(b)?(a):(b))
41:
42: static void
43: print_uh(struct udp_header *uh)
44: {
45: PRINTK("source = %d, dest = %d\n", net16(uh->source), net16(uh->dest));
46: PRINTK("len = %d, check = %d\n", net16(uh->len), net16(uh->check));
47: }
48:
49:
50: int
51: udp_select (volatile struct sock *sk, int sel_type, select_table *wait)
52: {
53: select_wait(sk->sleep, wait);
54: switch (sel_type)
55: {
56: case SEL_IN:
57: if (sk->rqueue != NULL)
58: {
59: return (1);
60: }
61: return (0);
62:
63: case SEL_OUT:
64: if (sk->prot->wspace(sk) >= MIN_WRITE_SPACE)
65: {
66: return (1);
67: }
68: return (0);
69:
70: case SEL_EX:
71: if (sk->err) return (1); /* can this ever happen? */
72: return (0);
73: }
74: return (0);
75: }
76:
77: /* this routine is called by the icmp module when it gets some
78: sort of error condition. If err < 0 then the socket should
79: be closed and the error returned to the user. If err > 0
80: it's just the icmp type << 8 | icmp code.
81: header points to the first 8 bytes of the tcp header. We need
82: to find the appropriate port. */
83:
84: void
85: udp_err (int err, unsigned char *header, unsigned long daddr,
86: unsigned long saddr, struct ip_protocol *protocol)
87: {
88: struct tcp_header *th;
89: volatile struct sock *sk;
90:
91: th = (struct tcp_header *)header;
92: sk = get_sock (&udp_prot, net16(th->dest), saddr, th->source, daddr);
93:
94: if (sk == NULL) return;
95: if (err & 0xff00 == (ICMP_SOURCE_QUENCH << 8))
96: {
97: if (sk->cong_window > 1)
98: sk->cong_window = sk->cong_window/2;
99: return;
100: }
101:
102: sk->err = icmp_err_convert[err & 0xff].errno;
103: if (icmp_err_convert[err & 0xff].fatal)
104: {
105: sk->prot->close(sk, 0);
106: }
107:
108: return;
109:
110: }
111:
112: static unsigned short
113: udp_check (struct udp_header *uh, int len,
114: unsigned long saddr, unsigned long daddr)
115: {
116: unsigned long sum;
117: PRINTK ("udp_check (uh=%X, len = %d, saddr = %X, daddr = %X)\n",
118: uh, len, saddr, daddr);
119:
120: print_uh (uh);
121:
122: __asm__("\t addl %%ecx,%%ebx\n"
123: "\t adcl %%edx,%%ebx\n"
124: "\t adcl $0, %%ebx\n"
125: : "=b" (sum)
126: : "0" (daddr), "c" (saddr), "d" ((net16(len) << 16) + IP_UDP*256)
127: : "cx","bx","dx" );
128:
129: if (len > 3)
130: {
131: __asm__(
132: "\tclc\n"
133: "1:\n"
134: "\t lodsl\n"
135: "\t adcl %%eax, %%ebx\n"
136: "\t loop 1b\n"
137: "\t adcl $0, %%ebx\n"
138: : "=b" (sum) , "=S" (uh)
139: : "0" (sum), "c" (len/4) ,"1" (uh)
140: : "ax", "cx", "bx", "si" );
141: }
142:
143: /* convert from 32 bits to 16 bits. */
144: __asm__(
145: "\t movl %%ebx, %%ecx\n"
146: "\t shrl $16,%%ecx\n"
147: "\t addw %%cx, %%bx\n"
148: "\t adcw $0, %%bx\n"
149: : "=b" (sum)
150: : "0" (sum)
151: : "bx", "cx");
152:
153:
154: /* check for an extra word. */
155: if ((len & 2) != 0)
156: {
157: __asm__("\t lodsw\n"
158: "\t addw %%ax,%%bx\n"
159: "\t adcw $0, %%bx\n"
160: : "=b" (sum), "=S" (uh)
161: : "0" (sum) ,"1" (uh)
162: : "si", "ax", "bx");
163: }
164:
165: /* now check for the extra byte. */
166: if ((len & 1) != 0)
167: {
168: __asm__("\t lodsb\n"
169: "\t movb $0,%%ah\n"
170: "\t addw %%ax,%%bx\n"
171: "\t adcw $0, %%bx\n"
172: : "=b" (sum)
173: : "0" (sum) ,"S" (uh)
174: : "si", "ax", "bx");
175: }
176: /* we only want the bottom 16 bits, but we never cleared
177: the top 16. */
178: return ((~sum) & 0xffff);
179: }
180:
181: static void
182: udp_send_check (struct udp_header *uh, unsigned long saddr,
183: unsigned long daddr, int len, volatile struct sock *sk)
184: {
185: uh->check = 0;
186: if (sk && sk->no_check) return;
187: uh->check = udp_check (uh, len, saddr, daddr);
188: }
189:
190: static int
191: udp_loopback (volatile struct sock *sk, unsigned short port,
192: unsigned char *from,
193: int len, unsigned long daddr, unsigned long saddr)
194: {
195: struct udp_header *uh;
196: struct sk_buff *skb;
197: volatile struct sock *pair;
198: sk->inuse = 1;
199:
200: PRINTK ("udp_loopback \n");
201:
202: pair = get_sock (sk->prot, net16(port), saddr,
203: sk->dummy_th.source, daddr);
204:
205: if (pair == NULL) return (0);
206:
207: skb = pair->prot->rmalloc (pair,
208: sizeof (*skb) + sizeof (*uh) + len + 4,
209: 0);
210:
211: /* if we didn't get the memory, just drop the packet. */
212: if (skb == NULL) return (len);
213:
214: skb->mem_addr = skb;
215: skb->mem_len = sizeof (*skb) + len + sizeof (*uh) + 4;
216:
217: skb->daddr = saddr;
218: skb->saddr = daddr;
219:
220: skb->len = len;
221: skb->h.raw = (unsigned char *)(skb+1);
222:
223: uh = skb->h.uh;
224: uh -> source = sk->dummy_th.source;
225: uh -> dest = port;
226: uh -> len = len + sizeof (*uh);
227: verify_area (from , len);
228: memcpy_fromfs(uh+1, from, len);
229: pair->inuse = 1;
230: if (pair->rqueue == NULL)
231: {
232: pair->rqueue = skb;
233: skb->next = skb;
234: skb->prev = skb;
235: }
236: else
237: {
238: skb->next = pair->rqueue;
239: skb->prev = pair->rqueue->prev;
240: skb->prev->next = skb;
241: skb->next->prev = skb;
242: }
243: wake_up (pair->sleep);
244: release_sock (pair);
245: release_sock (sk);
246: return (len);
247:
248: }
249:
250: static int
251: udp_sendto (volatile struct sock *sk, unsigned char *from, int len,
252: int noblock,
253: unsigned flags, struct sockaddr_in *usin, int addr_len)
254: {
255: /* this should be easy, we just send the packet. */
256: struct sk_buff *skb;
257: struct udp_header *uh;
258: unsigned char *buff;
259: unsigned long saddr;
260: int copied=0;
261: int amt;
262: struct device *dev=NULL;
263: struct sockaddr_in sin;
264:
265: /* check the flags. */
266: if (flags) return (-EINVAL);
267: if (len < 0) return (-EINVAL);
268: if (len == 0) return (0);
269:
270: PRINTK ("sendto len = %d\n", len);
271:
272: /* get and verify the address. */
273: if (usin)
274: {
275: if (addr_len < sizeof (sin))
276: return (-EINVAL);
277: verify_area (usin, sizeof (sin));
278: memcpy_fromfs (&sin, usin, sizeof(sin));
279: if (sin.sin_family &&
280: sin.sin_family != AF_INET)
281: return (-EINVAL);
282: if (sin.sin_port == 0)
283: return (-EINVAL);
284: }
285: else
286: {
287: if (sk->state != TCP_ESTABLISHED)
288: return (-EINVAL);
289: sin.sin_family = AF_INET;
290: sin.sin_port = sk->dummy_th.dest;
291: sin.sin_addr.s_addr = sk->daddr;
292: }
293:
294: /* check for a valid saddr. */
295: saddr = sk->saddr;
296: if ((saddr & 0xff000000) == 0)
297: {
298: saddr = MY_IP_ADDR;
299: }
300:
301: /* if it's a broadcast, make sure we get it. */
302: if ((sin.sin_addr.s_addr & 0xff000000) == 0)
303: {
304: int err;
305: err = udp_loopback (sk, sin.sin_port, from, len,
306: sin.sin_addr.s_addr, saddr);
307: if (err < 0)
308: return (err);
309: }
310:
311: sk->inuse = 1;
312:
313: while (len > 0)
314: {
315: int tmp;
316: skb = sk->prot->wmalloc (sk, len + sizeof (*skb)
317: + sk->prot->max_header, 0);
318: /* this should never happen, but it is possible. */
319:
320: if (skb == NULL)
321: {
322: printk ("udp_sendto: write buffer full?\n");
323: print_sk(sk);
324: release_sock (sk);
325: if (copied || !noblock)
326: return (copied);
327: return (-EAGAIN);
328: }
329:
330: skb->mem_addr = skb;
331: skb->mem_len = len + sizeof (*skb) + sk->prot->max_header;
332: skb->sk = sk;
333: skb->free = 1;
334: skb->arp = 0;
335:
336: /* now build the ip and dev header. */
337: buff = (unsigned char *)(skb+1);
338: tmp = sk->prot->build_header (skb, saddr,
339: sin.sin_addr.s_addr, &dev,
340: IP_UDP, sk->opt, skb->mem_len);
341: if (tmp < 0 )
342: {
343: sk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
344: release_sock (sk);
345: return (tmp);
346: }
347: buff += tmp;
348:
349: /* we shouldn't do this, instead we should just
350: let the ip protocol fragment the packet. */
351: amt = min (len + tmp + sizeof (*uh), dev->mtu);
352:
353: PRINTK ("amt = %d, dev = %X, dev->mtu = %d\n",
354: amt, dev, dev->mtu);
355:
356: skb->len = amt;
357: amt -= tmp;
358:
359: uh = (struct udp_header *)buff;
360: uh->len = net16(amt);
361: uh->source = sk->dummy_th.source;
362: uh->dest = sin.sin_port;
363:
364: amt -= sizeof (*uh);
365: buff += sizeof (*uh);
366:
367: verify_area (from, amt);
368: memcpy_fromfs( buff, from, amt);
369:
370: len -= amt;
371: copied += amt;
372: from += amt;
373: udp_send_check (uh, saddr, sin.sin_addr.s_addr,
374: amt+sizeof (*uh), sk);
375:
376: sk->prot->queue_xmit (sk, dev, skb, 1);
377: }
378: release_sock (sk);
379: return (copied);
380: }
381:
382: static int
383: udp_write (volatile struct sock *sk, unsigned char *buff, int len, int noblock,
384: unsigned flags)
385: {
386: return (udp_sendto (sk, buff, len, noblock, flags, NULL, 0));
387: }
388:
389: int
390: udp_recvfrom (volatile struct sock *sk, unsigned char *to, int len,
391: int noblock,
392: unsigned flags, struct sockaddr_in *sin, int *addr_len)
393: {
394: /* this should be easy, if there is something there we
395: return it, otherwise we block. */
396: int copied=0;
397: struct sk_buff *skb;
398: if (len == 0) return (0);
399: if (len < 0) return (-EINVAL);
400: if (addr_len)
401: {
402: verify_area (addr_len, sizeof(*addr_len));
403: put_fs_long (sizeof (*sin), addr_len);
404: }
405: sk->inuse = 1;
406: while (sk->rqueue == NULL)
407: {
408: if (noblock)
409: {
410: release_sock (sk);
411: return (-EAGAIN);
412: }
413: release_sock (sk);
414: cli();
415: if (sk->rqueue == NULL)
416: {
417: interruptible_sleep_on (sk->sleep);
418: if (current->signal & ~current->blocked)
419: {
420: return (-ERESTARTSYS);
421: }
422: }
423: sti();
424: }
425: skb = sk->rqueue;
426:
427: if (!(flags & MSG_PEEK))
428: {
429: if (skb->next == skb )
430: {
431: sk->rqueue = NULL;
432: }
433: else
434: {
435: sk->rqueue = sk->rqueue ->next;
436: skb->prev->next = skb->next;
437: skb->next->prev = skb->prev;
438: }
439: }
440: copied = min (len, skb->len);
441: verify_area (to, copied);
442: memcpy_tofs (to, skb->h.raw + sizeof (struct udp_header), copied);
443: /* copy the address. */
444: if (sin)
445: {
446: struct sockaddr_in addr;
447: addr.sin_family = AF_INET;
448: addr.sin_port = skb->h.uh->source;
449: addr.sin_addr.s_addr = skb->daddr;
450: verify_area (sin, sizeof (*sin));
451: memcpy_tofs(sin, &addr, sizeof (*sin));
452: }
453:
454: if (!(flags & MSG_PEEK))
455: {
456: free_skb (skb, FREE_READ);
457: }
458: release_sock (sk);
459: return (copied);
460:
461: }
462:
463:
464: int
465: udp_read (volatile struct sock *sk, unsigned char *buff, int len, int noblock,
466: unsigned flags)
467: {
468: return (udp_recvfrom (sk, buff, len, noblock, flags, NULL, NULL));
469: }
470:
471: int
472: udp_connect (volatile struct sock *sk, struct sockaddr_in *usin, int addr_len)
473: {
474: struct sockaddr_in sin;
475: if (addr_len < sizeof (sin)) return (-EINVAL);
476: verify_area (usin, sizeof (sin));
477: memcpy_fromfs (&sin, usin, sizeof (sin));
478: if (sin.sin_family && sin.sin_family != AF_INET)
479: return (-EAFNOSUPPORT);
480: sk->daddr = sin.sin_addr.s_addr;
481: sk->dummy_th.dest = sin.sin_port;
482: sk->state = TCP_ESTABLISHED;
483: return(0);
484: }
485:
486: static void
487: udp_close(volatile struct sock *sk, int timeout)
488: {
489: sk->inuse = 1;
490: sk->state = TCP_CLOSE;
491: if (sk->dead)
492: destroy_sock (sk);
493: else
494: release_sock (sk);
495: }
496:
497: int
498: udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
499: unsigned long daddr, unsigned short len,
500: unsigned long saddr, int redo, struct ip_protocol *protocol)
501: {
502: /* all we need to do is get the socket, and then do a checksum. */
503: struct proto *prot=&udp_prot;
504: volatile struct sock *sk;
505: struct udp_header *uh;
506:
507: uh = (struct udp_header *) skb->h.uh;
508:
509: if (dev->add_arp) dev->add_arp (saddr, skb, dev);
510:
511: sk = get_sock (prot, net16(uh->dest), saddr, uh->source, daddr);
512:
513: /* if we don't know about the socket, forget about it. */
514: if (sk == NULL &&
515: (daddr & 0xff000000 != 0) && (daddr & 0xff000000 != 0xff000000))
516: {
517: icmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
518: skb->sk = NULL;
519: free_skb (skb, 0);
520: return (0);
521: }
522:
523:
524: if (!redo)
525: {
526: if (uh->check && udp_check (uh, len, saddr, daddr))
527: {
528: PRINTK ("bad udp checksum\n");
529: skb->sk = NULL;
530: free_skb (skb, 0);
531: return (0);
532: }
533:
534: skb->sk = sk;
535: skb->dev = dev;
536: skb->len = len;
537:
538: /* these are supposed to be switched. */
539: skb->daddr = saddr;
540: skb->saddr = daddr;
541:
542: /* Now deal with the in use. */
543: cli();
544: if (sk->inuse)
545: {
546: if (sk->back_log == NULL)
547: {
548: sk->back_log = skb;
549: skb->next = skb;
550: skb->prev = skb;
551: }
552: else
553: {
554: skb->next = sk->back_log;
555: skb->prev = sk->back_log->prev;
556: skb->prev->next = skb;
557: skb->next->prev = skb;
558: }
559: sti();
560: return (0);
561: }
562: sk->inuse = 1;
563: sti();
564: }
565:
566: /* charge it too the socket. */
567: if (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
568: {
569: skb->sk = NULL;
570: free_skb (skb, 0);
571: release_sock (sk);
572: return (0);
573: }
574:
575: sk->rmem_alloc += skb->mem_len;
576:
577: /* At this point we should print the thing out. */
578: PRINTK ("<< \n");
579: print_sk (sk);
580:
581: /* now add it to the data chain and wake things up. */
582: if (sk->rqueue == NULL)
583: {
584: sk->rqueue = skb;
585: skb->next = skb;
586: skb->prev = skb;
587: }
588: else
589: {
590: skb->next = sk->rqueue;
591: skb->prev = sk->rqueue->prev;
592: skb->prev->next = skb;
593: skb->next->prev = skb;
594: }
595:
596: skb->len = len - sizeof (*uh);
597:
598: if (!sk->dead)
599: wake_up (sk->sleep);
600:
601: release_sock (sk);
602: return (0);
603: }
604:
605:
606:
607: struct proto udp_prot =
608: {
609: sock_wmalloc,
610: sock_rmalloc,
611: sock_wfree,
612: sock_rfree,
613: sock_rspace,
614: sock_wspace,
615: udp_close,
616: udp_read,
617: udp_write,
618: udp_sendto,
619: udp_recvfrom,
620: ip_build_header,
621: udp_connect,
622: NULL,
623: ip_queue_xmit,
624: ip_retransmit,
625: NULL,
626: NULL,
627: udp_rcv,
628: udp_select,
629: NULL,
630: NULL,
631: 128,
632: 0,
633: {NULL,}
634: };
635:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.