home *** CD-ROM | disk | FTP | other *** search
/ GRIPS 2: Government Rast…rocessing Software & Data / GRIPS_2.cdr / dos / ncsa_tel / contribu / byu_tel2.hqx / tcpip / ip.c < prev    next >
Text File  |  1989-06-22  |  13KB  |  500 lines
  1. /*
  2. *   IP.C
  3. *   IP level routines, including ICMP
  4. *   also includes a basic version of UDP, not generalized yet
  5. *
  6. ****************************************************************************
  7. *                                                                          *
  8. *      part of:                                                            *
  9. *      TCP/IP kernel for NCSA Telnet                                       *
  10. *      by Tim Krauskopf                                                    *
  11. *                                                                          *
  12. *      National Center for Supercomputing Applications                     *
  13. *      152 Computing Applications Building                                 *
  14. *      605 E. Springfield Ave.                                             *
  15. *      Champaign, IL  61820                                                *
  16. *                                                                          *
  17. *    Copyright (c) 1987, Board of Trustees of the University of Illinois   *
  18. *                                                                          *
  19. ****************************************************************************
  20. *  Revision history:
  21. *
  22. *  10/87  Initial source release, Tim Krauskopf
  23. *  2/88  typedefs of integer lengths, TK
  24. */
  25.  
  26. #include "stdio.h"
  27. #include "protocol.h"
  28. #include "data.h"
  29.  
  30. uint16 ipcheck(),tcpcheck();
  31.  
  32. /***************************************************************************/
  33. /*  ipinterpret
  34. *   Called by the reception routine with a new IP packet.  Check the checksum,
  35. *   addressing and protocol type and call appropriate routines.
  36. */
  37.  
  38. ipinterpret(p)
  39.     IPKT *p;
  40.     {
  41.     int hischeck,iplen,i;
  42.  
  43. /*
  44. *  We cannot handle fragmented IP packets yet, return an error
  45. */
  46.     if (p->i.frags & 0x20) {
  47.         netposterr(304);
  48.         return(1);
  49.     }
  50.  
  51. /*
  52. *  checksum verification of IP header
  53. */
  54.  
  55.     if (p->i.check) {             /* no IP checksumming if check=0 */
  56.         if (ipcheck(&p->i.versionandhdrlen,(p->i.versionandhdrlen & 0x0f) << 1))  {
  57.             netposterr(300);    /* bad IP checksum */
  58.             return(1);             /* drop packet */
  59.         }
  60.     }
  61.  
  62. /*
  63. *  check to make sure that the packet is for me.
  64. *  Throws out all packets which are not directed to my IP address.
  65. *
  66. *  This code is incomplete.  It does not pass broadcast IP addresses up
  67. *  to higher layers.  It used to report packets which were incorrectly
  68. *  addressed, but no longer does.  Needs proper check for broadcast 
  69. *  addresses.
  70. */
  71.     if (!comparen(nnipnum,p->i.ipdest,4)) {     /* potential non-match */
  72.         return(1);                /* drop packet */
  73.     }
  74. /*
  75. *  Extract total length of packet
  76. */
  77.     iplen = intswap(p->i.tlen);
  78.  
  79. /*
  80. *  See if there are any IP options to be handled.
  81. *  We don't understand IP options, post a warning to the user and drop
  82. *  the packet.
  83. */
  84.     i = (p->i.versionandhdrlen & 0x0f)<<2;
  85.  
  86.     if (i > 20) {
  87.         netposterr(302);                /* packet with options */
  88.         return(1);
  89.     }
  90.  
  91.     switch (p->i.protocol) {        /* which protocol to handle this packet? */
  92.         case PROTUDP:
  93.             return(udpinterpret(p,iplen-i));
  94.         case PROTTCP:
  95.             return(tcpinterpret(p,iplen-i));    /* pass tcplen on to TCP */
  96.         case PROTICMP:
  97.             return(icmpinterpret(p,iplen-i));
  98.         default:
  99.             netposterr(303);
  100.             return(1);
  101.     }
  102.  
  103.     return(0);
  104. }    
  105.  
  106. #ifdef NNDEBUG
  107. ipdump(p)
  108.     IPKT *p;
  109.     {
  110.     uint16 iplen,iid;
  111.  
  112.     iid = intswap(p->i.ident);
  113.  
  114.     iplen = intswap(p->i.tlen);
  115.  
  116.     puts("found IP packet:");
  117.  
  118.     printf("Version+hdr: %x     service %d      tlen %u   \n",
  119.             p->i.versionandhdrlen,p->i.service,iplen);
  120.     printf("Ident: %u    frags: %4x    ttl: %d    prot: %d  \n",
  121.             iid,p->i.frags,p->i.ttl,p->i.protocol);
  122.     printf("addresses: s: %d.%d.%d.%d    t: %d.%d.%d.%d \n",
  123.         p->i.ipsource[0],p->i.ipsource[1],p->i.ipsource[2],p->i.ipsource[3],
  124.         p->i.ipdest[0],p->i.ipdest[1],p->i.ipdest[2],p->i.ipdest[3]);
  125.  
  126.  
  127.     puts("\n");
  128.     
  129. }
  130.  
  131. /***************************************************************************/
  132. /*  ipsend   THIS ROUTINE HAS NOT BEEN TESTED, NEVER USED!
  133. * 
  134. *   generic send of an IP packet according to parameters.  Use of this
  135. *   procedure is discouraged.  Terribly inefficient, but may be useful for
  136. *   tricky or diagnostic situations.  Unused for TCP.
  137. *
  138. *   usage:  ipsend(data,ident,prot,options,hdrlen)
  139. *        data is a pointer to the data to be sent
  140. *       ident is the 16 bit identifier
  141. *       prot is the protocol type, PROTUDP or PROTTCP or other
  142. *       hlen is in bytes, total header length, 20 is minimum
  143. *       dlen is the length of the data field, in bytes
  144. *        who is ip address of recipient
  145. *       options must be included in hlen and hidden in the data stream
  146. */
  147. ipsend(data,dlen,iid,iprot,who,hlen)
  148.     unsigned char *data,iprot,*who;
  149.     int iid,dlen,hlen;
  150.     {
  151.     int iplen;
  152.  
  153.     if (dlen > 512)
  154.         dlen = 512;
  155.  
  156.     iplen = hlen+dlen;                         /* total length of packet */
  157.     blankip.i.tlen = intswap(iplen);            /* byte swap */
  158.  
  159.     blankip.i.versionandhdrlen = 0x40 | (hlen>>2);
  160.  
  161.     blankip.i.ident = intswap(iid);           /* byte swap */
  162.  
  163.     blankip.i.protocol = iprot;
  164.  
  165.     blankip.i.check = 0;                    /* set to 0 before calculating */
  166.  
  167.     movebytes(blankip.i.ipdest,who,4);
  168.     movebytes(blankip.d.me,myaddr,DADDLEN);
  169.  
  170.     movenbytes(blankip.x.data,data,dlen);  /* might be header options data */
  171.  
  172.     blankip.i.check = ipcheck(&blankip.i.versionandhdrlen,hlen>>1);
  173.                                         /* checks based on words */
  174.  
  175.  
  176. /* resolve knowledge of Ethernet hardware addresses */
  177.  
  178. /*
  179. *  This is commented out because I know that this procedure is broken!
  180. *  If you use it, debug it first.
  181.  
  182.     dlayersend(&blankip,iplen+14);
  183. */
  184.  
  185.     return(0);
  186. }
  187.  
  188. #endif
  189.  
  190. /****************************************************************************/
  191. /*  icmpinterpret
  192. *   interpret the icmp message that just came in
  193. */
  194. icmpinterpret(p,icmplen)
  195.     ICMPKT *p;
  196.     int icmplen;
  197.     {
  198.     uint i,cksum,hisck;
  199.     IPLAYER *iptr;
  200.  
  201.     i = p->c.type;
  202.     netposterr(600 + i);        /* provide info for higher layer user */
  203.  
  204. #ifdef oldway
  205.     hisck = p->c.check;
  206.     p->c.check = 0;
  207. #endif
  208.  
  209.     if (p->c.check) {            /* ignore if chksum = 0 */
  210.         if (ipcheck(&p->c,icmplen>>1)) {
  211.             netposterr(699);
  212.             return(-1);
  213.         }
  214.     }
  215.  
  216.     switch (i) {
  217.         case 8:                            /* ping request sent to me */
  218.             p->c.type = 0;                /* echo reply type */
  219.             neticmpturn(p,icmplen);        /* send back */
  220.             break;
  221.  
  222.         case 5:                            /* ICMP redirect */
  223.             iptr = (IPLAYER *)p->data;
  224.             netputuev(ICMPCLASS,IREDIR,0);        /* event to be picked up */
  225.  
  226.             movebytes(nnicmpsave,iptr->ipdest,4);        /* dest address */
  227.             movebytes(nnicmpnew,&p->c.part1,4);            /* new gateway */
  228.             break;
  229.  
  230.         default:
  231.             break;
  232.     }
  233.  
  234.     return(0);
  235. }
  236.  
  237. /****************************************************************************/
  238. /*  udpinterpret
  239. *   take incoming UDP packets and make them available to the user level
  240. *   routines.  Currently keeps the last packet coming in to a port.
  241. *
  242. *   Limitations:
  243. *   Can only listen to one UDP port at a time.  Only saves the last packet
  244. *   received on that port.
  245. *   Port numbers should be assigned like TCP ports are (future).
  246. */
  247. udpinterpret(p,ulen)
  248.     UDPKT *p;
  249.     int ulen;
  250.     {
  251.     uint hischeck,mycheck;
  252. /*
  253. *  did we want this data ?  If not, then let it go, no comment
  254. *  If we want it, copy the relevent information into our structure
  255. */
  256.     if (intswap(p->u.dest) != ulist.listen) 
  257.         return(1);
  258.  
  259. /*
  260. *  first compute the checksum to see if it is a valid packet
  261. */
  262.     hischeck = p->u.check;
  263.     p->u.check = 0;
  264.  
  265.     if (hischeck) {
  266.         movebytes(tcps.source,p->i.ipsource,8);
  267.         tcps.z = 0;
  268.         tcps.proto = p->i.protocol;
  269.  
  270.         tcps.tcplen = intswap(ulen);
  271.  
  272.  
  273.         mycheck = tcpcheck(&tcps,&p->u,ulen);
  274.  
  275.         if (hischeck != mycheck) {
  276.             netposterr(700);
  277.             return(2);
  278.         }
  279.  
  280.         p->u.check = hischeck;                    /* put it back */
  281.     }
  282.  
  283.     ulen -= 8;                        /* account for header */
  284.     if (ulen > UMAXLEN)                /* most data that we can accept */
  285.         ulen = UMAXLEN;
  286.  
  287.     movebytes(ulist.who,p->i.ipsource,4);
  288.     movebytes(ulist.data,p->data,ulen);
  289.     ulist.length = ulen;
  290.     ulist.stale = 0;
  291.     netputuev(USERCLASS,UDPDATA,ulist.listen);        /* post that it is here */
  292.  
  293.     return(0);
  294. }
  295.  
  296.  
  297. /****************************************************************************/
  298. /*  neturead
  299. *   get the data from the UDP buffer
  300. *   Returns the number of bytes transferred into your buffer, -1 if none here
  301. *   This needs work.
  302. */
  303. neturead(buffer)
  304.     char *buffer;
  305.     {
  306.     if (ulist.stale)
  307.         return(-1);
  308.  
  309.     movebytes(buffer,ulist.data,ulist.length);
  310.     ulist.stale = 1;
  311.  
  312.     return(ulist.length);
  313. }
  314.  
  315. /***************************************************************************/
  316. /*  netulisten
  317. *   Specify which UDP port number to listen to.
  318. *   Can only listen to one at a time.
  319. */
  320. netulisten(port)
  321.     int port;
  322.     {
  323.     ulist.listen = port;
  324. }
  325.  
  326. /***************************************************************************/
  327. /*  netusend
  328. *   send some data out in a UDP packet
  329. *   uses the preinitialized data in the port packet ulist.udpout
  330. *   
  331. *   returns 0 on okay send, nonzero on error
  332. */
  333. netusend(machine,port,retport,buffer,n)
  334.     unsigned char *machine,*buffer;
  335.     unsigned int port,retport;
  336.     int n;
  337.     {
  338.     unsigned char *pc;
  339.  
  340.     if (n > UMAXLEN)
  341.         n = UMAXLEN;
  342. /*
  343. *  make sure that we have the right dlayer address
  344. */
  345.     if (!comparen(machine,ulist.udpout.i.ipdest,4)) {
  346.         pc = netdlayer(machine);
  347.         if (pc == NULL) 
  348.             return(-2);
  349.         movebytes(ulist.udpout.d.dest,pc,DADDLEN);
  350.         movebytes(ulist.udpout.i.ipdest,machine,4);
  351.         movebytes(ulist.tcps.dest,machine,4);
  352.     }
  353.  
  354.     ulist.udpout.u.dest = intswap(port);
  355.     ulist.udpout.u.source = intswap(retport);
  356.     ulist.tcps.tcplen = ulist.udpout.u.length = intswap(n+sizeof(UDPLAYER));
  357.     movenbytes(ulist.udpout.data,buffer,n);
  358.  
  359. /*
  360. *  put in checksum
  361. */
  362.     ulist.udpout.u.check = 0;
  363.     ulist.udpout.u.check = tcpcheck(&ulist.tcps,&ulist.udpout.u,n+sizeof(UDPLAYER));
  364.  
  365. /*
  366. *   iplayer for send
  367. */
  368.     ulist.udpout.i.tlen = intswap(n+sizeof(IPLAYER)+sizeof(UDPLAYER));
  369.     ulist.udpout.i.ident = intswap(nnipident++);
  370.     ulist.udpout.i.check = 0;
  371.     ulist.udpout.i.check = ipcheck(&ulist.udpout.i,10);
  372. /*
  373. *  send it
  374. */
  375.     return(dlayersend(&ulist.udpout,
  376.         sizeof(DLAYER)+sizeof(IPLAYER)+sizeof(UDPLAYER)+n));
  377.  
  378. }
  379.  
  380. #ifdef notneeded
  381. /***************************************************************************/
  382. /*  neticmpsend
  383. *   Not currently used.  Has not been tested since 9/87.
  384. *   Do not assume this works (TK)
  385. *
  386. *   send out an icmp packet, probably to do a ping operation
  387. *   
  388. *   returns 0 on okay send, nonzero on error
  389. */
  390. neticmpsend(machine,type,code,buffer,n)
  391.     unsigned char *machine,*buffer,type,code;
  392.     int n;
  393.     {
  394.     unsigned char *pc;
  395.  
  396.     if (n > ICMPMAX)
  397.         n = ICMPMAX;
  398. /*
  399. *  make sure that we have the right dlayer address
  400. *
  401. *  this may be re-entrant, needs checking.  Okay, as long as this compare
  402. *  is false when called from netsleep() routines!
  403. *  When called from user routines, we are okay.
  404. */
  405.     if (!comparen(machine,blankicmp.i.ipdest,4)) {
  406.         pc = netdlayer(machine);
  407.         if (pc == NULL) 
  408.             return(-2);
  409.         movebytes(blankicmp.d.dest,pc,DADDLEN);
  410.         movebytes(blankicmp.i.ipdest,machine,4);
  411. /*        movebytes(ulist.tcps.dest,machine,4); */
  412.     }
  413. /*
  414. *  prepare ICMP portion
  415. */
  416.     blankicmp.c.type = type;
  417.     blankicmp.c.code = code;
  418.     movenbytes(&blankicmp.data,buffer,n);
  419.  
  420.     blankicmp.c.check = 0;
  421.     blankicmp.c.check = ipcheck(&blankicmp.c,(sizeof(ICMPLAYER)+n)>>1);
  422.  
  423. /*
  424. *   iplayer for send
  425. */
  426.     blankicmp.i.tlen = intswap(n+sizeof(IPLAYER)+sizeof(ICMPLAYER));
  427.     blankicmp.i.ident = intswap(nnipident++);
  428.     blankicmp.i.check = 0;
  429.     blankicmp.i.check = ipcheck(&blankicmp.i,10);
  430. /*
  431. *  send it
  432. */
  433.     return(dlayersend(&blankicmp,
  434.         sizeof(DLAYER)+sizeof(IPLAYER)+sizeof(ICMPLAYER)+n));
  435.  
  436. }
  437. #endif
  438.  
  439. /***************************************************************************/
  440. /*  neticmpturn
  441. *
  442. *   send out an icmp packet, probably in response to a ping operation
  443. *   interchanges the source and destination addresses of the packet,
  444. *   puts in my addresses for the source and sends it
  445. *
  446. *   does not change any of the ICMP fields, just the IP and dlayers
  447. *   returns 0 on okay send, nonzero on error
  448. */
  449.  
  450. neticmpturn(p,ilen)
  451.     ICMPKT *p;
  452.     int ilen;
  453.     {
  454.     unsigned char *pc;
  455. /*
  456. *  reverse the addresses, dlayer and IP layer
  457. */
  458.     if (comparen(p->d.me,broadaddr,DADDLEN))
  459.         return(0);
  460.  
  461.     movebytes(p->d.dest,p->d.me,DADDLEN);
  462.  
  463. #ifdef MAC
  464. /*
  465. *   look up address in the arp cache if we are using AppleTalk
  466. *   encapsulation.
  467. */
  468.     if (!nnemac) {
  469.         pc = getdlayer(p->i.ipsource);
  470.         if (pc != NULL)
  471.             movebytes(p->d.dest,pc,DADDLEN);
  472.         else
  473.             return(0);        /* no hope this time */
  474.     }
  475. #endif
  476.  
  477.  
  478.     movebytes(p->i.ipdest,p->i.ipsource,4);
  479.     movebytes(p->d.me,nnmyaddr,DADDLEN);
  480.     movebytes(p->i.ipsource,nnipnum,4);
  481. /*
  482. *  prepare ICMP checksum
  483. */
  484.     p->c.check = 0;
  485.     p->c.check = ipcheck(&p->c,ilen>>1);
  486.  
  487. /*
  488. *   iplayer for send
  489. */
  490.     p->i.ident = intswap(nnipident++);
  491.     p->i.check = 0;
  492.     p->i.check = ipcheck(&p->i,10);
  493.  
  494. /*
  495. *  send it
  496. */
  497.     return(dlayersend(p,sizeof(DLAYER)+sizeof(IPLAYER)+ilen));
  498.  
  499. }
  500.