home *** CD-ROM | disk | FTP | other *** search
/ GRIPS 2: Government Rast…rocessing Software & Data / GRIPS_2.cdr / dos / ncsa_tel / tel_2_2_ / source / ip.c < prev    next >
C/C++ Source or Header  |  1988-07-15  |  12KB  |  497 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. ****************************************************************************
  18. *  Revision history:
  19. *
  20. *  10/87  Initial source release, Tim Krauskopf
  21. *  2/88  typedefs of integer lengths, TK
  22. */
  23.  
  24. #include "stdio.h"
  25. #include "protocol.h"
  26. #include "data.h"
  27.  
  28. uint16 ipcheck(),tcpcheck();
  29.  
  30. /***************************************************************************/
  31. /*  ipinterpret
  32. *   Called by the reception routine with a new IP packet.  Check the checksum,
  33. *   addressing and protocol type and call appropriate routines.
  34. */
  35.  
  36. ipinterpret(p)
  37.     IPKT *p;
  38.     {
  39.     int hischeck,iplen,i;
  40.  
  41. /*
  42. *  We cannot handle fragmented IP packets yet, return an error
  43. */
  44.     if (p->i.frags & 0x20) {
  45.         netposterr(304);
  46.         return(1);
  47.     }
  48.  
  49. /*
  50. *  checksum verification of IP header
  51. */
  52.  
  53.     if (p->i.check) {             /* no IP checksumming if check=0 */
  54.         if (ipcheck(&p->i.versionandhdrlen,(p->i.versionandhdrlen & 0x0f) << 1))  {
  55.             netposterr(300);    /* bad IP checksum */
  56.             return(1);             /* drop packet */
  57.         }
  58.     }
  59.  
  60. /*
  61. *  check to make sure that the packet is for me.
  62. *  Throws out all packets which are not directed to my IP address.
  63. *
  64. *  This code is incomplete.  It does not pass broadcast IP addresses up
  65. *  to higher layers.  It used to report packets which were incorrectly
  66. *  addressed, but no longer does.  Needs proper check for broadcast 
  67. *  addresses.
  68. */
  69.     if (!comparen(nnipnum,p->i.ipdest,4)) {     /* potential non-match */
  70.         return(1);                /* drop packet */
  71.     }
  72.  
  73. /*
  74. *  Extract total length of packet
  75. */
  76.     iplen = intswap(p->i.tlen);
  77.  
  78. /*
  79. *  See if there are any IP options to be handled.
  80. *  We don't understand IP options, post a warning to the user and drop
  81. *  the packet.
  82. */
  83.     i = (p->i.versionandhdrlen & 0x0f)<<2;
  84.  
  85.     if (i > 20) {
  86.         netposterr(302);                /* packet with options */
  87.         return(1);
  88.     }
  89.  
  90.     switch (p->i.protocol) {        /* which protocol to handle this packet? */
  91.         case PROTUDP:
  92.             return(udpinterpret(p,iplen-i));
  93.             break;
  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.  
  205.     if (p->c.check) {            /* ignore if chksum = 0 */
  206.         if (ipcheck(&p->c,icmplen>>1)) {
  207.             netposterr(699);
  208.             return(-1);
  209.         }
  210.     }
  211.  
  212.     switch (i) {
  213.         case 8:                            /* ping request sent to me */
  214.             p->c.type = 0;                /* echo reply type */
  215.             neticmpturn(p,icmplen);        /* send back */
  216.             break;
  217.  
  218.         case 5:                            /* ICMP redirect */
  219.             iptr = (IPLAYER *)p->data;
  220.             netputuev(ICMPCLASS,IREDIR,0);        /* event to be picked up */
  221.  
  222.             movebytes(nnicmpsave,iptr->ipdest,4);        /* dest address */
  223.             movebytes(nnicmpnew,&p->c.part1,4);            /* new gateway */
  224.             break;
  225.  
  226.         default:
  227.             break;
  228.     }
  229.  
  230.     return(0);
  231. }
  232.  
  233. /****************************************************************************/
  234. /*  udpinterpret
  235. *   take incoming UDP packets and make them available to the user level
  236. *   routines.  Currently keeps the last packet coming in to a port.
  237. *
  238. *   Limitations:
  239. *   Can only listen to one UDP port at a time.  Only saves the last packet
  240. *   received on that port.
  241. *   Port numbers should be assigned like TCP ports are (future).
  242. */
  243. udpinterpret(p,ulen)
  244.     UDPKT *p;
  245.     int ulen;
  246.     {
  247.     uint hischeck,mycheck;
  248. /*
  249. *  did we want this data ?  If not, then let it go, no comment
  250. *  If we want it, copy the relevent information into our structure
  251. */
  252.     if (intswap(p->u.dest) != ulist.listen) 
  253.         return(1);
  254.  
  255. /*
  256. *  first compute the checksum to see if it is a valid packet
  257. */
  258.     hischeck = p->u.check;
  259.     p->u.check = 0;
  260.  
  261.     if (hischeck) {
  262.         movebytes(tcps.source,p->i.ipsource,8);
  263.         tcps.z = 0;
  264.         tcps.proto = p->i.protocol;
  265.  
  266.         tcps.tcplen = intswap(ulen);
  267.  
  268.  
  269.         mycheck = tcpcheck(&tcps,&p->u,ulen);
  270.  
  271.         if (hischeck != mycheck) {
  272.             netposterr(700);
  273.             return(2);
  274.         }
  275.  
  276.         p->u.check = hischeck;                    /* put it back */
  277.     }
  278.  
  279.     ulen -= 8;                        /* account for header */
  280.     if (ulen > UMAXLEN)                /* most data that we can accept */
  281.         ulen = UMAXLEN;
  282.  
  283.     movebytes(ulist.who,p->i.ipsource,4);
  284.     movebytes(ulist.data,p->data,ulen);
  285.     ulist.length = ulen;
  286.     ulist.stale = 0;
  287.     netputuev(USERCLASS,UDPDATA,ulist.listen);        /* post that it is here */
  288.  
  289.     return(0);
  290. }
  291.  
  292. /****************************************************************************/
  293. /*  neturead
  294. *   get the data from the UDP buffer
  295. *   Returns the number of bytes transferred into your buffer, -1 if none here
  296. *   This needs work.
  297. */
  298. neturead(buffer)
  299.     char *buffer;
  300.     {
  301.     if (ulist.stale)
  302.         return(-1);
  303.  
  304.     movebytes(buffer,ulist.data,ulist.length);
  305.     ulist.stale = 1;
  306.  
  307.     return(ulist.length);
  308. }
  309.  
  310. /***************************************************************************/
  311. /*  netulisten
  312. *   Specify which UDP port number to listen to.
  313. *   Can only listen to one at a time.
  314. */
  315. netulisten(port)
  316.     int port;
  317.     {
  318.     ulist.listen = port;
  319. }
  320.  
  321. /***************************************************************************/
  322. /*  netusend
  323. *   send some data out in a UDP packet
  324. *   uses the preinitialized data in the port packet ulist.udpout
  325. *   
  326. *   returns 0 on okay send, nonzero on error
  327. */
  328. netusend(machine,port,retport,buffer,n)
  329.     unsigned char *machine,*buffer;
  330.     unsigned int port,retport;
  331.     int n;
  332.     {
  333.     unsigned char *pc;
  334.  
  335.     if (n > UMAXLEN)
  336.         n = UMAXLEN;
  337. /*
  338. *  make sure that we have the right dlayer address
  339. */
  340.     if (!comparen(machine,ulist.udpout.i.ipdest,4)) {
  341.         pc = netdlayer(machine);
  342.         if (pc == NULL) 
  343.             return(-2);
  344.         movebytes(ulist.udpout.d.dest,pc,DADDLEN);
  345.         movebytes(ulist.udpout.i.ipdest,machine,4);
  346.         movebytes(ulist.tcps.dest,machine,4);
  347.     }
  348.  
  349.     ulist.udpout.u.dest = intswap(port);
  350.     ulist.udpout.u.source = intswap(retport);
  351.     ulist.tcps.tcplen = ulist.udpout.u.length = intswap(n+sizeof(UDPLAYER));
  352.     movenbytes(ulist.udpout.data,buffer,n);
  353.  
  354. /*
  355. *  put in checksum
  356. */
  357.     ulist.udpout.u.check = 0;
  358.     ulist.udpout.u.check = tcpcheck(&ulist.tcps,&ulist.udpout.u,n+sizeof(UDPLAYER));
  359.  
  360. /*
  361. *   iplayer for send
  362. */
  363.     ulist.udpout.i.tlen = intswap(n+sizeof(IPLAYER)+sizeof(UDPLAYER));
  364.     ulist.udpout.i.ident = intswap(nnipident++);
  365.     ulist.udpout.i.check = 0;
  366.     ulist.udpout.i.check = ipcheck(&ulist.udpout.i,10);
  367. /*
  368. *  send it
  369. */
  370.     return(dlayersend(&ulist.udpout,
  371.         sizeof(DLAYER)+sizeof(IPLAYER)+sizeof(UDPLAYER)+n));
  372.  
  373. }
  374.  
  375. #ifdef notneeded
  376. /***************************************************************************/
  377. /*  neticmpsend
  378. *   Not currently used.  Has not been tested since 9/87.
  379. *   Do not assume this works (TK)
  380. *
  381. *   send out an icmp packet, probably to do a ping operation
  382. *   
  383. *   returns 0 on okay send, nonzero on error
  384. */
  385. neticmpsend(machine,type,code,buffer,n)
  386.     unsigned char *machine,*buffer,type,code;
  387.     int n;
  388.     {
  389.     unsigned char *pc;
  390.  
  391.     if (n > ICMPMAX)
  392.         n = ICMPMAX;
  393. /*
  394. *  make sure that we have the right dlayer address
  395. *
  396. *  this may be re-entrant, needs checking.  Okay, as long as this compare
  397. *  is false when called from netsleep() routines!
  398. *  When called from user routines, we are okay.
  399. */
  400.     if (!comparen(machine,blankicmp.i.ipdest,4)) {
  401.         pc = netdlayer(machine);
  402.         if (pc == NULL) 
  403.             return(-2);
  404.         movebytes(blankicmp.d.dest,pc,DADDLEN);
  405.         movebytes(blankicmp.i.ipdest,machine,4);
  406. /*        movebytes(ulist.tcps.dest,machine,4); */
  407.     }
  408. /*
  409. *  prepare ICMP portion
  410. */
  411.     blankicmp.c.type = type;
  412.     blankicmp.c.code = code;
  413.     movenbytes(&blankicmp.data,buffer,n);
  414.  
  415.     blankicmp.c.check = 0;
  416.     blankicmp.c.check = ipcheck(&blankicmp.c,(sizeof(ICMPLAYER)+n)>>1);
  417.  
  418. /*
  419. *   iplayer for send
  420. */
  421.     blankicmp.i.tlen = intswap(n+sizeof(IPLAYER)+sizeof(ICMPLAYER));
  422.     blankicmp.i.ident = intswap(nnipident++);
  423.     blankicmp.i.check = 0;
  424.     blankicmp.i.check = ipcheck(&blankicmp.i,10);
  425. /*
  426. *  send it
  427. *
  428. *  debug this routine before using
  429. */
  430.     return(dlayersend(&blankicmp,
  431.         sizeof(DLAYER)+sizeof(IPLAYER)+sizeof(ICMPLAYER)+n));
  432.  
  433. }
  434. #endif
  435.  
  436. /***************************************************************************/
  437. /*  neticmpturn
  438. *
  439. *   send out an icmp packet, probably in response to a ping operation
  440. *   interchanges the source and destination addresses of the packet,
  441. *   puts in my addresses for the source and sends it
  442. *
  443. *   does not change any of the ICMP fields, just the IP and dlayers
  444. *   returns 0 on okay send, nonzero on error
  445. */
  446.  
  447. neticmpturn(p,ilen)
  448.     ICMPKT *p;
  449.     int ilen;
  450.     {
  451.     unsigned char *pc;
  452. /*
  453. *  reverse the addresses, dlayer and IP layer
  454. */
  455.     if (comparen(p->d.me,broadaddr,DADDLEN))
  456.         return(0);
  457.  
  458.     movebytes(p->d.dest,p->d.me,DADDLEN);
  459.  
  460. #ifdef MAC
  461. /*
  462. *   look up address in the arp cache if we are using AppleTalk
  463. *   encapsulation.
  464. */
  465.     if (!nnemac) {
  466.         pc = getdlayer(p->i.ipsource);
  467.         if (pc != NULL)
  468.             movebytes(p->d.dest,pc,DADDLEN);
  469.         else
  470.             return(0);        /* no hope this time */
  471.     }
  472. #endif
  473.  
  474.  
  475.     movebytes(p->i.ipdest,p->i.ipsource,4);
  476.     movebytes(p->d.me,nnmyaddr,DADDLEN);
  477.     movebytes(p->i.ipsource,nnipnum,4);
  478. /*
  479. *  prepare ICMP checksum
  480. */
  481.     p->c.check = 0;
  482.     p->c.check = ipcheck(&p->c,ilen>>1);
  483.  
  484. /*
  485. *   iplayer for send
  486. */
  487.     p->i.ident = intswap(nnipident++);
  488.     p->i.check = 0;
  489.     p->i.check = ipcheck(&p->i,10);
  490.  
  491. /*
  492. *  send it
  493. */
  494.     return(dlayersend(p,sizeof(DLAYER)+sizeof(IPLAYER)+ilen));
  495.  
  496. }
  497.