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