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