![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip.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 ip.c CVS log | Up to [Early Linux] / linux / net / tcp |
1.1 ! root 1: /* ip.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 <asm/segment.h> ! 24: #include <asm/system.h> ! 25: #include <linux/types.h> ! 26: #include <linux/kernel.h> ! 27: #include <linux/sched.h> ! 28: #include <linux/string.h> ! 29: #include <linux/socket.h> ! 30: #include <netinet/in.h> ! 31: #include "timer.h" ! 32: #include "ip.h" ! 33: #include "tcp.h" ! 34: #include "sock.h" ! 35: #include <linux/errno.h> ! 36: #include "arp.h" ! 37: #include "icmp.h" ! 38: ! 39: unsigned long ip_addr[MAX_IP_ADDRES]={0,0,0}; ! 40: ! 41: #undef IP_DEBUG ! 42: #ifdef IP_DEBUG ! 43: #define PRINTK printk ! 44: #else ! 45: #define PRINTK dummy_routine ! 46: #endif ! 47: ! 48: static struct rtable *rt_base=NULL; /* used to base all the routing data. */ ! 49: ! 50: struct ip_protocol *ip_protos[MAX_IP_PROTOS] = { NULL, }; ! 51: ! 52: #if 0 ! 53: static struct ip_protocol * ! 54: get_protocol(unsigned char prot) ! 55: { ! 56: unsigned char hash; ! 57: struct ip_protocol *p; ! 58: PRINTK ("get_protocol (%d)\n ", prot); ! 59: hash = prot & (MAX_IP_PROTOS -1); ! 60: for (p = ip_protos[hash] ; p != NULL; p=p->next) ! 61: { ! 62: PRINTK ("trying protocol %d\n", p->protocol); ! 63: if (p->protocol == prot) ! 64: return (p); ! 65: } ! 66: return (NULL); ! 67: ! 68: } ! 69: #endif ! 70: ! 71: void ! 72: add_ip_protocol (struct ip_protocol *prot) ! 73: { ! 74: unsigned char hash; ! 75: struct ip_protocol *p2; ! 76: hash = prot->protocol & (MAX_IP_PROTOS-1); ! 77: prot ->next = ip_protos[hash]; ! 78: ip_protos[hash] = prot; ! 79: prot->copy = 0; ! 80: /* set the copy bit if we need to. */ ! 81: for (p2 = prot->next; p2 != NULL; p2=p2->next) ! 82: { ! 83: if (p2->protocol == prot->protocol) ! 84: { ! 85: prot->copy = 1; ! 86: break; ! 87: } ! 88: } ! 89: ! 90: } ! 91: ! 92: int ! 93: delete_ip_protocol (struct ip_protocol *prot) ! 94: { ! 95: struct ip_protocol *p; ! 96: struct ip_protocol *lp=NULL; ! 97: unsigned char hash; ! 98: ! 99: ! 100: hash = prot->protocol & (MAX_IP_PROTOS -1); ! 101: if (prot == ip_protos[hash]) ! 102: { ! 103: ip_protos[hash]=ip_protos[hash]->next; ! 104: return (0); ! 105: } ! 106: ! 107: for (p = ip_protos[hash]; p != NULL; p = p->next) ! 108: { ! 109: /* we have to worry if the protocol being deleted is the ! 110: last one on the list, then we may need to reset someones ! 111: copied bit. */ ! 112: if (p->next != NULL && p->next == prot) ! 113: { ! 114: /* if we are the last one with this protocol and ! 115: there is a previous one, reset its copy bit. */ ! 116: ! 117: if (p->copy == 0 && lp != NULL) ! 118: lp->copy = 0; ! 119: p->next = prot->next; ! 120: return (0); ! 121: } ! 122: ! 123: if (p->next != NULL && p->next->protocol == prot->protocol) ! 124: { ! 125: lp = p; ! 126: } ! 127: } ! 128: return (-1); ! 129: } ! 130: ! 131: /* addr1 is the address which may or may not be broadcast etc. ! 132: addr2 is the "real addr." */ ! 133: ! 134: int ! 135: ip_addr_match (unsigned long addr1, unsigned long addr2) ! 136: { ! 137: int i; ! 138: if (addr1 == addr2) return (1); ! 139: for (i = 0; i < 4; i++, addr1 >>= 8, addr2 >>= 8) ! 140: { ! 141: if ((addr1 & 0xff) != (addr2 & 0xff)) ! 142: { ! 143: /* the only way this could be a match is for the rest of ! 144: addr1 to be 0. */ ! 145: if (addr1 != 0) ! 146: { ! 147: return (0); ! 148: } ! 149: return (1); ! 150: } ! 151: } ! 152: return (1); ! 153: } ! 154: ! 155: int ! 156: my_ip_addr(unsigned long addr) ! 157: { ! 158: int i; ! 159: for (i = 0; i < MAX_IP_ADDRES; i++) ! 160: { ! 161: if (ip_addr[i] == 0) return (0); ! 162: if (ip_addr_match (addr, ip_addr[i])) return (1); ! 163: } ! 164: return (0); ! 165: } ! 166: ! 167: /* these two routines will do routining. */ ! 168: static void ! 169: strict_route(struct ip_header *iph, struct options *opt) ! 170: { ! 171: } ! 172: ! 173: static void ! 174: loose_route(struct ip_header *iph, struct options *opt) ! 175: { ! 176: } ! 177: ! 178: void ! 179: print_rt(struct rtable *rt) ! 180: { ! 181: PRINTK ("net = %08X router = %08X\n",rt->net, rt->router); ! 182: PRINTK ("dev = %X, next = %X\n",rt->dev, rt->next); ! 183: } ! 184: ! 185: void ! 186: print_ipprot (struct ip_protocol *ipprot) ! 187: { ! 188: PRINTK ("handler = %X, protocol = %d\n", ! 189: ipprot->handler, ipprot->protocol); ! 190: } ! 191: ! 192: /* This assumes that address are all in net order. */ ! 193: static struct device * ! 194: ip_route(struct options *opt, unsigned long daddr , unsigned long *raddr) ! 195: { ! 196: struct rtable *rt; ! 197: /* look through the routing table for some ! 198: kind of match. */ ! 199: for (rt=rt_base; rt != NULL; rt=rt->next) ! 200: { ! 201: /* see if we found one. */ ! 202: if (ip_addr_match (rt->net, daddr)) ! 203: { ! 204: *raddr = rt->router; ! 205: return (rt->dev); ! 206: } ! 207: } ! 208: return (NULL); ! 209: }; ! 210: ! 211: void ! 212: add_route (struct rtable *rt) ! 213: { ! 214: int mask; ! 215: struct rtable *r; ! 216: struct rtable *r1; ! 217: PRINTK ("add_route (rt=%X):\n",rt); ! 218: print_rt(rt); ! 219: ! 220: if (rt_base == NULL) ! 221: { ! 222: rt->next = NULL; ! 223: rt_base = rt; ! 224: return; ! 225: } ! 226: ! 227: /* what we have to do is loop though this until we have found the ! 228: first address which has the same generality as the one in rt. Then ! 229: we can put rt in after it. */ ! 230: for (mask = 0xff000000; mask != 0xffffffff; mask = (mask >> 8) | mask) ! 231: { ! 232: if (mask & rt->net) ! 233: { ! 234: mask = mask << 8; ! 235: break; ! 236: } ! 237: } ! 238: PRINTK ("mask = %X\n",mask); ! 239: r1=rt_base; ! 240: for (r=rt_base; r != NULL; r=r->next) ! 241: { ! 242: /* see if we are getting a duplicate. */ ! 243: if (r->net == rt->net) ! 244: { ! 245: if (r == rt_base) ! 246: { ! 247: rt->next = r->next; ! 248: rt_base = rt; ! 249: } ! 250: else ! 251: { ! 252: rt->next = r->next; ! 253: r1->next = rt; ! 254: } ! 255: free_s (r, sizeof (*r)); ! 256: return; ! 257: } ! 258: ! 259: if (!(r->net & mask)) ! 260: { ! 261: PRINTK("adding before r=%X\n",r); ! 262: print_rt(r); ! 263: if (r == rt_base) ! 264: { ! 265: rt->next = rt_base; ! 266: rt_base = rt; ! 267: return; ! 268: } ! 269: rt->next = r; ! 270: r1->next = rt; ! 271: return; ! 272: } ! 273: r1 = r; ! 274: } ! 275: PRINTK ("adding after r1=%X\n",r1); ! 276: print_rt(r1); ! 277: /* goes at the end. */ ! 278: rt->next = NULL; ! 279: r1->next = rt; ! 280: } ! 281: ! 282: int ! 283: ip_set_dev (struct ip_config *u_ipc) ! 284: { ! 285: struct rtable *rt; ! 286: struct device *dev; ! 287: struct ip_config ipc; ! 288: static int ip_ads = 0; ! 289: ! 290: if (ip_ads >= MAX_IP_ADDRES) return (-EINVAL); ! 291: ! 292: verify_area (u_ipc, sizeof (ipc)); ! 293: memcpy_fromfs(&ipc, u_ipc, sizeof (ipc)); ! 294: ipc.name[MAX_IP_NAME-1] = 0; ! 295: dev = get_dev (ipc.name); ! 296: ! 297: if (dev == NULL) return (-EINVAL); ! 298: ! 299: /* see if we need to add a broadcast address. */ ! 300: if (ipc.net != -1) ! 301: { ! 302: arp_add_broad (ipc.net, dev); ! 303: rt = malloc (sizeof (*rt)); ! 304: if (rt == NULL) return (-ENOMEM); ! 305: ! 306: rt->net = ipc.net; ! 307: rt->dev = dev; ! 308: rt->router = 0; ! 309: add_route (rt); ! 310: /* dev->net = ipc.net;*/ ! 311: } ! 312: ! 313: if (ipc.router != -1) ! 314: { ! 315: rt = malloc (sizeof (*rt)); ! 316: if (rt == NULL) return (-ENOMEM); ! 317: rt->net = 0; ! 318: rt->dev = dev; ! 319: rt->router = ipc.router; ! 320: add_route (rt); ! 321: } ! 322: ! 323: if (dev->loopback) ! 324: { ! 325: rt = malloc (sizeof (*rt)); ! 326: if (rt == NULL) return (-ENOMEM); ! 327: rt->net = ipc.paddr; ! 328: rt->dev = dev; ! 329: rt->router = 0; ! 330: add_route (rt); ! 331: ! 332: } ! 333: ! 334: ! 335: if (!my_ip_addr (ipc.paddr)) ! 336: ip_addr[ip_ads++] = ipc.paddr; ! 337: ! 338: dev->up = ipc.up; ! 339: if (dev->up) ! 340: { ! 341: if (dev->open) ! 342: dev->open(dev); ! 343: } ! 344: else ! 345: { ! 346: if (dev->stop) ! 347: dev->stop(dev); ! 348: } ! 349: return (0); ! 350: ! 351: } ! 352: ! 353: /* this routine will check to see if we have lost a gateway. */ ! 354: void ! 355: ip_route_check (unsigned long daddr) ! 356: { ! 357: } ! 358: ! 359: /* this routine puts the options at the end of an ip header. */ ! 360: static int ! 361: build_options (struct ip_header *iph, struct options *opt) ! 362: { ! 363: unsigned char *ptr; ! 364: /* currently we don't support any options. */ ! 365: ptr = (unsigned char *)(iph+1); ! 366: *ptr = 0; ! 367: return (4); ! 368: } ! 369: ! 370: /* This routine builds the appropriate hardware/ip headers for ! 371: the routine. It assumes that if *prot != NULL then the ! 372: protocol knows what it's doing, otherwise it uses the ! 373: routing/arp tables to select a protocol struct. */ ! 374: ! 375: int ! 376: ip_build_header (struct sk_buff *skb, unsigned long saddr, ! 377: unsigned long daddr, struct device **dev, int type, ! 378: struct options *opt, int len) ! 379: { ! 380: static struct options optmem; ! 381: struct ip_header *iph; ! 382: unsigned char *buff; ! 383: static int count = 0; ! 384: unsigned long raddr; /* for the router. */ ! 385: int tmp; ! 386: if (saddr == 0) saddr = MY_IP_ADDR; ! 387: PRINTK ("ip_build_header (skb=%X, saddr=%X, daddr=%X, *dev=%X,\n" ! 388: " type=%d, opt=%X, len = %d)\n", ! 389: skb, saddr, daddr, *dev, type, opt, len); ! 390: buff = (unsigned char *)(skb + 1); ! 391: /* see if we need to look up the device. */ ! 392: if (*dev == NULL) ! 393: { ! 394: *dev = ip_route(&optmem,daddr, &raddr); ! 395: if (*dev == NULL) ! 396: { ! 397: return (-ENETUNREACH); ! 398: } ! 399: opt = &optmem; ! 400: } ! 401: else ! 402: { ! 403: /* we still need the address of the first hop. */ ! 404: ip_route (&optmem, daddr, &raddr); ! 405: } ! 406: if (raddr == 0) raddr = daddr; ! 407: /* now build the header. */ ! 408: /* we need to worry about routing in here. daddr should ! 409: really be the address of the next hop. */ ! 410: /* but raddr is . */ ! 411: if ((*dev)->hard_header) ! 412: { ! 413: tmp = (*dev)->hard_header(buff, *dev, ETHERTYPE_IP, raddr, saddr, len); ! 414: } ! 415: else ! 416: { ! 417: tmp = 0; ! 418: } ! 419: if (tmp < 0) ! 420: { ! 421: tmp = -tmp; ! 422: skb->arp = 0; ! 423: } ! 424: else ! 425: { ! 426: skb->arp = 1; ! 427: } ! 428: buff += tmp; ! 429: len -= tmp; ! 430: skb->dev = *dev; ! 431: /* now build the ip header. */ ! 432: iph = (struct ip_header *)buff; ! 433: iph->version = 4; ! 434: iph->tos = 0; ! 435: iph->frag_off = 0; ! 436: iph->ttl = 32; ! 437: iph->daddr = daddr; ! 438: iph->saddr = saddr; ! 439: iph->protocol=type; ! 440: iph->ihl = 5; ! 441: iph->id = net16(count++); ! 442: /* build_options (iph, opt);*/ ! 443: return (20+tmp); ! 444: } ! 445: ! 446: static int ! 447: do_options(struct ip_header *iph, struct options *opt) ! 448: { ! 449: unsigned char *buff; ! 450: int done = 0; ! 451: int len=sizeof (*iph); ! 452: int i; ! 453: /* zero out the options. */ ! 454: opt->record_route.route_size = 0; ! 455: opt->loose_route.route_size = 0; ! 456: opt->strict_route.route_size = 0; ! 457: opt->tstamp.ptr = 0; ! 458: opt->security = 0; ! 459: opt->compartment = 0; ! 460: opt->handling = 0; ! 461: opt->stream = 0; ! 462: opt->tcc = 0; ! 463: return (0); ! 464: /* advance the pointer to start at the options. */ ! 465: buff = (unsigned char *)(iph + 1); ! 466: ! 467: /*now start the processing. */ ! 468: while (!done && len < iph->ihl*4) ! 469: { ! 470: switch (*buff) ! 471: { ! 472: case IPOPT_END: ! 473: done=1; ! 474: break; ! 475: ! 476: case IPOPT_NOOP: ! 477: buff++; ! 478: len ++; ! 479: break; ! 480: ! 481: case IPOPT_SEC: ! 482: buff++; ! 483: if (*buff != 11) ! 484: return (1); ! 485: buff++; ! 486: opt->security = net16(*(unsigned short *)buff); ! 487: buff += 2; ! 488: opt->compartment = net16(*(unsigned short *)buff); ! 489: buff += 2; ! 490: opt-> handling = net16(*(unsigned short *)buff); ! 491: buff += 2; ! 492: opt->tcc = ((*buff) << 16) + net16(*(unsigned short *)(buff+1)); ! 493: buff += 3; ! 494: len += 11; ! 495: break; ! 496: ! 497: case IPOPT_LSRR: ! 498: buff ++; ! 499: if ((*buff - 3)% 4 != 0) return (1); ! 500: len += *buff; ! 501: opt->loose_route.route_size = (*buff -3)/4; ! 502: buff ++; ! 503: if (*buff % 4 != 0) return (1); ! 504: opt->loose_route.pointer = *buff/4 - 1; ! 505: buff ++; ! 506: buff ++; ! 507: for (i = 0; i < opt->loose_route.route_size; i++) ! 508: { ! 509: opt->loose_route.route[i]=*(unsigned long *)buff; ! 510: buff += 4; ! 511: } ! 512: break; ! 513: ! 514: ! 515: case IPOPT_SSRR: ! 516: buff ++; ! 517: if ((*buff - 3)% 4 != 0) return (1); ! 518: len += *buff; ! 519: opt->strict_route.route_size = (*buff -3)/4; ! 520: buff ++; ! 521: if (*buff % 4 != 0) return (1); ! 522: opt->strict_route.pointer = *buff/4 - 1; ! 523: buff ++; ! 524: buff ++; ! 525: for (i = 0; i < opt->strict_route.route_size; i++) ! 526: { ! 527: opt->strict_route.route[i]=*(unsigned long *)buff; ! 528: buff += 4; ! 529: } ! 530: break; ! 531: ! 532: case IPOPT_RR: ! 533: buff ++; ! 534: if ((*buff - 3)% 4 != 0) return (1); ! 535: len += *buff; ! 536: opt->record_route.route_size = (*buff -3)/4; ! 537: buff ++; ! 538: if (*buff % 4 != 0) return (1); ! 539: opt->record_route.pointer = *buff/4 - 1; ! 540: buff ++; ! 541: buff ++; ! 542: for (i = 0; i < opt->record_route.route_size; i++) ! 543: { ! 544: opt->record_route.route[i]=*(unsigned long *)buff; ! 545: buff += 4; ! 546: } ! 547: break; ! 548: ! 549: case IPOPT_SID: ! 550: len += 4; ! 551: buff +=2; ! 552: opt->stream = *(unsigned short *)buff; ! 553: buff += 2; ! 554: break; ! 555: ! 556: case IPOPT_TIMESTAMP: ! 557: buff ++; ! 558: len += *buff; ! 559: if (*buff % 4 != 0) return (1); ! 560: opt->tstamp.len = *buff / 4 - 1; ! 561: buff ++; ! 562: if ((*buff - 1) % 4 != 0) return (1); ! 563: opt->tstamp.ptr = (*buff-1)/4; ! 564: buff ++; ! 565: opt->tstamp.x.full_char = *buff; ! 566: buff ++; ! 567: for (i = 0; i < opt->tstamp.len; i++) ! 568: { ! 569: opt->tstamp.data[i] = *(unsigned long *)buff; ! 570: buff += 4; ! 571: } ! 572: break; ! 573: ! 574: default: ! 575: return (1); ! 576: } ! 577: } ! 578: if (opt->record_route.route_size == 0) ! 579: { ! 580: if (opt->strict_route.route_size != 0) ! 581: { ! 582: memcpy (&(opt->record_route), &(opt->strict_route), ! 583: sizeof (opt->record_route)); ! 584: } ! 585: else if (opt->loose_route.route_size != 0) ! 586: { ! 587: memcpy (&(opt->record_route), &(opt->loose_route), ! 588: sizeof (opt->record_route)); ! 589: } ! 590: } ! 591: ! 592: if (opt->strict_route.route_size != 0 && ! 593: opt->strict_route.route_size != opt->strict_route.pointer) ! 594: { ! 595: strict_route (iph, opt); ! 596: return (0); ! 597: } ! 598: ! 599: if (opt->loose_route.route_size != 0 && ! 600: opt->loose_route.route_size != opt->loose_route.pointer) ! 601: { ! 602: loose_route (iph, opt); ! 603: return (0); ! 604: } ! 605: ! 606: return (0); ! 607: } ! 608: ! 609: ! 610: /* This routine does all the checksum computations that don't require ! 611: anything special (like copying or special headers.) */ ! 612: ! 613: unsigned short ! 614: ip_compute_csum(unsigned char * buff, int len) ! 615: { ! 616: unsigned long sum = 0; ! 617: if (len > 3) ! 618: { ! 619: /* do the first multiple of 4 bytes and convert to 16 bits. */ ! 620: __asm__("\t clc\n" ! 621: "1:\n" ! 622: "\t lodsl\n" ! 623: "\t adcl %%eax, %%ebx\n" ! 624: "\t loop 1b\n" ! 625: "\t adcl $0, %%ebx\n" ! 626: "\t movl %%ebx, %%eax\n" ! 627: "\t shrl $16, %%eax\n" ! 628: "\t addw %%ax, %%bx\n" ! 629: "\t adcw $0, %%bx\n" ! 630: : "=b" (sum) , "=S" (buff) ! 631: : "0" (sum), "c" (len >> 2) ,"1" (buff) ! 632: : "ax", "cx", "si", "bx" ); ! 633: } ! 634: if (len & 2) ! 635: { ! 636: __asm__("\t lodsw\n" ! 637: "\t addw %%ax, %%bx\n" ! 638: "\t adcw $0, %%bx\n" ! 639: : "=b" (sum), "=S" (buff) ! 640: : "0" (sum), "1" (buff) ! 641: : "bx", "ax", "si"); ! 642: } ! 643: if (len & 1) ! 644: { ! 645: __asm__("\t lodsb\n" ! 646: "\t movb $0, %%ah\n" ! 647: "\t addw %%ax, %%bx\n" ! 648: "\t adcw $0, %%bx\n" ! 649: : "=b" (sum), "=S" (buff) ! 650: : "0" (sum), "1" (buff) ! 651: : "bx", "ax", "si"); ! 652: } ! 653: sum =~sum; ! 654: return (sum&0xffff); ! 655: } ! 656: ! 657: static int ! 658: ip_csum(struct ip_header *iph) ! 659: { ! 660: if (iph->check == 0) return (0); ! 661: if (ip_compute_csum((unsigned char *)iph, iph->ihl*4) == 0) return (0); ! 662: return (1); ! 663: } ! 664: ! 665: static void ! 666: ip_send_check(struct ip_header *iph) ! 667: { ! 668: iph->check = 0; ! 669: iph->check = ip_compute_csum((unsigned char *)iph, iph->ihl*4); ! 670: } ! 671: ! 672: int ! 673: ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt) ! 674: { ! 675: struct ip_header *iph; ! 676: unsigned char hash; ! 677: unsigned char flag=0; ! 678: static struct options opt; /* since we don't use these yet, and they ! 679: take up stack space. */ ! 680: struct ip_protocol *ipprot; ! 681: ! 682: iph=skb->h.iph; ! 683: ! 684: PRINTK("<<\n"); ! 685: print_iph(iph); ! 686: ! 687: if (ip_csum (iph) || do_options (iph,&opt) || iph->version != 4) ! 688: { ! 689: PRINTK ("ip packet thrown out. \n"); ! 690: skb->sk = NULL; ! 691: free_skb(skb, 0); ! 692: return (0); ! 693: } ! 694: ! 695: /* for now we will only deal with packets meant for us. */ ! 696: if (!my_ip_addr(iph->daddr)) ! 697: { ! 698: PRINTK ("packet meant for someone else.\n"); ! 699: skb->sk = NULL; ! 700: free_skb(skb, 0); ! 701: return (0); ! 702: } ! 703: ! 704: /* deal with fragments. or don't for now.*/ ! 705: if ((iph->frag_off & 64) || (net16(iph->frag_off)&0x1fff)) ! 706: { ! 707: printk ("packet fragmented. \n"); ! 708: skb->sk = NULL; ! 709: free_skb(skb, 0); ! 710: return(0); ! 711: } ! 712: ! 713: skb->h.raw += iph->ihl*4; ! 714: ! 715: /* add it to the arp table if it's talking to us. That way we ! 716: will be able to talk to them also. */ ! 717: ! 718: hash = iph->protocol & (MAX_IP_PROTOS -1); ! 719: for (ipprot = ip_protos[hash]; ipprot != NULL; ipprot=ipprot->next) ! 720: { ! 721: struct sk_buff *skb2; ! 722: PRINTK ("Using protocol = %X:\n", ipprot); ! 723: print_ipprot (ipprot); ! 724: /* pass it off to everyone who wants it. */ ! 725: /* we should check the return values here. */ ! 726: /* see if we need to make a copy of it. This will ! 727: only be set if more than one protpocol wants it. ! 728: and then not for the last one. */ ! 729: ! 730: if (ipprot->copy) ! 731: { ! 732: skb2 = malloc (skb->mem_len); ! 733: if (skb2 == NULL) continue; ! 734: memcpy (skb2, skb, skb->mem_len); ! 735: skb2->mem_addr = skb2; ! 736: } ! 737: else ! 738: { ! 739: skb2 = skb; ! 740: } ! 741: flag = 1; ! 742: ipprot->handler (skb2, dev, &opt, iph->daddr, ! 743: net16(iph->tot_len) - iph->ihl*4, ! 744: iph->saddr, 0, ipprot); ! 745: ! 746: } ! 747: if (!flag) ! 748: { ! 749: icmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev); ! 750: skb->sk = NULL; ! 751: free_skb (skb, 0); ! 752: } ! 753: ! 754: ! 755: return (0); ! 756: } ! 757: ! 758: ! 759: /* queues a packet to be sent, and starts the transmitter if ! 760: necessary. if free = 1 then we free the block after transmit, ! 761: otherwise we don't. */ ! 762: /* This routine also needs to put in the total length, and compute ! 763: the checksum. */ ! 764: void ! 765: ip_queue_xmit (volatile struct sock *sk, struct device *dev, ! 766: struct sk_buff *skb, int free) ! 767: { ! 768: struct ip_header *iph; ! 769: unsigned char *ptr; ! 770: if (sk == NULL) free = 1; ! 771: skb->free = free; ! 772: skb->dev = dev; ! 773: skb->when = jiffies; ! 774: PRINTK(">>\n"); ! 775: ptr = (unsigned char *)(skb + 1); ! 776: ptr += dev->hard_header_len; ! 777: iph = (struct ip_header *)ptr; ! 778: iph->tot_len = net16(skb->len-dev->hard_header_len); ! 779: ip_send_check (iph); ! 780: print_iph(iph); ! 781: skb->next = NULL; ! 782: if (!free) ! 783: { ! 784: skb->link3 = NULL; ! 785: sk->packets_out++; ! 786: cli(); ! 787: if (sk->send_tail == NULL) ! 788: { ! 789: sk->send_tail = skb; ! 790: sk->send_head = skb; ! 791: } ! 792: else ! 793: { ! 794: sk->send_tail->link3 = skb; ! 795: sk->send_tail = skb; ! 796: } ! 797: sti(); ! 798: sk->time_wait.len = sk->rtt*2; ! 799: sk->timeout=TIME_WRITE; ! 800: reset_timer ((struct timer *)&sk->time_wait); ! 801: } ! 802: else ! 803: { ! 804: skb->sk = sk; ! 805: } ! 806: if (dev->up) ! 807: { ! 808: if (sk) ! 809: dev->queue_xmit(skb, dev, sk->priority); ! 810: else ! 811: dev->queue_xmit (skb, dev, SOPRI_NORMAL); ! 812: } ! 813: else ! 814: { ! 815: if (free) ! 816: free_skb (skb, FREE_WRITE); ! 817: } ! 818: } ! 819: ! 820: void ! 821: ip_retransmit (volatile struct sock *sk, int all) ! 822: { ! 823: struct sk_buff * skb; ! 824: struct proto *prot; ! 825: struct device *dev; ! 826: ! 827: prot = sk->prot; ! 828: skb = sk->send_head; ! 829: while (skb != NULL) ! 830: { ! 831: dev = skb->dev; ! 832: /* rebuild_header sees if the arp is done. If not it sends a new ! 833: arp, and if so it builds the header. */ ! 834: if (!skb->arp) ! 835: { ! 836: if (dev->rebuild_header ((struct enet_header *)(skb+1),dev)) ! 837: { ! 838: if (!all) break; ! 839: skb=skb->link3; ! 840: continue; ! 841: } ! 842: } ! 843: skb->arp = 1; ! 844: skb->when = jiffies; ! 845: ! 846: if (dev->up) ! 847: if (sk) ! 848: dev->queue_xmit(skb, dev, sk->priority); ! 849: else ! 850: dev->queue_xmit(skb, dev, SOPRI_NORMAL ); ! 851: ! 852: sk->retransmits++; ! 853: sk->prot->retransmits ++; ! 854: if (!all) break; ! 855: /* this should cut it off before we send too ! 856: many packets. */ ! 857: if (sk->retransmits > sk->cong_window) break; ! 858: skb=skb->link3; ! 859: } ! 860: sk->time_wait.len = sk->rtt*2; ! 861: sk->timeout = TIME_WRITE; ! 862: reset_timer ((struct timer *)&sk->time_wait); ! 863: } ! 864: ! 865: void ! 866: print_iph (struct ip_header *ip) ! 867: { ! 868: PRINTK ("ip header:\n"); ! 869: PRINTK (" ihl = %d, version = %d, tos = %d, tot_len = %d\n", ! 870: ip->ihl, ip->version, ip->tos, net16(ip->tot_len)); ! 871: PRINTK (" id = %x, ttl = %d, prot = %d, check=%x\n", ! 872: ip->id, ip->ttl, ip->protocol, ip->check); ! 873: PRINTK (" frag_off=%d\n", ip->frag_off); ! 874: PRINTK (" saddr = %X, daddr = %X\n",ip->saddr, ip->daddr); ! 875: } ! 876: ! 877: #if 0 ! 878: int ! 879: ip_handoff (volatile struct sock *sk) ! 880: { ! 881: struct ip_protocol *p; ! 882: struct sk_buff *skb; ! 883: p = get_protocol (sk->protocol); ! 884: ! 885: if (p == NULL) ! 886: { ! 887: /* this can never happen. */ ! 888: printk ("sock_ioctl: protocol not found. \n"); ! 889: /* what else can I do, I suppose I could send a sigkill. */ ! 890: return (-EIO); ! 891: } ! 892: ! 893: while (p->handler != sk->prot->rcv) ! 894: { ! 895: p=p->next; ! 896: if (p == NULL) ! 897: { ! 898: /* this can never happen. */ ! 899: printk ("sock_ioctl: protocol not found. \n"); ! 900: /* what else can I do, I suppose I could send a sigkill. */ ! 901: return (-EIO); ! 902: } ! 903: } ! 904: p = p-> next; ! 905: sk->inuse = 1; ! 906: ! 907: /* now we have to remove the top sock buff. If there are none, then ! 908: we return. */ ! 909: if (sk->rqueue == NULL) return (0); ! 910: skb = sk->rqueue; ! 911: if (skb->next == skb) ! 912: { ! 913: sk->rqueue = NULL; ! 914: } ! 915: else ! 916: { ! 917: sk->rqueue = skb->next; ! 918: skb->next->prev = skb->prev; ! 919: skb->prev->next = skb->next; ! 920: } ! 921: if (p != NULL) ! 922: { ! 923: p->handler ((unsigned char *)(skb+1), skb->dev, NULL, skb->saddr, ! 924: skb->len, skb->daddr, p->protocol, 0); ! 925: } ! 926: free_skb (skb, FREE_READ); ! 927: release_sock (sk); ! 928: return (0); ! 929: } ! 930: ! 931: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.