开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 防火墙与安全工具 > 查看源码
Outnat.cpp
资源名称：Firewall防火墙.rar　[点击查看]
上传用户：heseme
上传日期：2009-12-23
资源大小：228k
文件大小：24k
源码类别：

防火墙与安全工具

开发平台：

Visual C++

Outnat.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "outnat.h"
  3. #include "Struct.h"
  4. extern struct  NAT_Cfg pnatcfg;
  5. extern in_addr_t OutGlobalAddr;
  7. extern  BYTE INNO;
  8. extern  BYTE OUTNO;
  9. extern  BYTE DMNO;
  11. #define   ETH_HEAD    14  //以太帧头大小
  12. #define   IP_HEAD     20  //
  13. //#define   DYN_LOW_PORT    5000    //用于转换的最低端口
  14. unsigned short   DYN_LOW_PORT ;  //用于转换的最低端口
  16. //#define   DYN_HIGH_PORT    10000  //用于转换的最高端口
  17. unsigned short   DYN_HIGH_PORT;     //用于转换的最高端口
  19. //#define   MAX_NAT_CONNECT  500    //可支持的最大TCP连接数
  20. unsigned short   MAX_NAT_CONNECT;  //可支持的最大TCP连接数
  21. //#define   MAX_NAT_CONNECTUDP  100 //可支持的最大UDP连接数
  22. //#define   ITEM_LENG        25     
  23. //#define   OTHERITEM_LENG   25
  24. //#define   TCPTIMEOUT       5       //每个TCP转换表项的超时值
  25. unsigned short   TCPTIMEOUT;       //每个TCP转换表项的超时值
  27. //#define   UDPTIMEOUT       5       //每个UDP转换表项的超时值
  28. //#define   MAX_STATICITEM   6
  30. NATTABLE_ITEM*     nattable;          //转换表  
  31. HANDLE             access_event;      //访问控制
  32. BYTE               StaticTCPcount;    //设置的TCP静态转换个数
  33. BYTE               StaticUDPcount;     //设置的UDP静态转换个数
  34. STATICTCPTABLE     StaticTCPtable[100] ;  //静态转换表
  35. STATICUDPTABLE     StaticUDPtable[100] ;  //静态转换表
  37. ULONG        uc_GlobalIPAddress;       //对外的全局地址
  38. //ULONG        ul_InterIPAddress;
  40. NATTABLE_ITEM*   otheritem;           //转换表项
  41. USHORT*  pChooseportBufferheader;     //可选择端口栈的头指针
  42. USHORT*  pChooseportBufferbottom;     //可选择端口栈的尾指针
  43. USHORT         InHashIDTable[1000];   //转换表的入站索引
  44. USHORT         OutHashIDTable[1000];  //转换表的出站索引
  46. //input eth and calculate checksum
  47. BOOL GetTCPCksum(BYTE* buffer,int leng)
  48. {
  49.     //BYTE* tempbuffer;
  50. USHORT  tcpleng;
  51. USHORT  tcpchecksum;
  52. USHORT*  tempushort;
  54. USHORT  IPleng;
  55. BYTE*   tempbuffer;
  57. buffer[34+16] = 0;
  58. buffer[34+17] = 0;
  60.     //getIPleng(total)
  61.     ((BYTE*)(&IPleng))[0] = buffer[17];
  62.     ((BYTE*)(&IPleng))[1] = buffer[16];
  63. //get tcpleng(total)
  64. tcpleng = IPleng - 20;
  65.     
  66. //get pseudo head
  67. tempbuffer = new BYTE[tcpleng+12];
  68. memcpy(tempbuffer+12,buffer+34,tcpleng);
  69. tempbuffer[0] = buffer[26];
  70. tempbuffer[1] = buffer[27];
  71. tempbuffer[2] = buffer[28];
  72. tempbuffer[3] = buffer[29];
  73. tempbuffer[4] = buffer[30];
  74. tempbuffer[5] = buffer[31];
  75. tempbuffer[6] = buffer[32];
  76. tempbuffer[7] = buffer[33];
  77.         tempbuffer[8] = 0;
  78. tempbuffer[9] = 6;
  79. tempbuffer[10] = ((BYTE*)(&tcpleng))[1];
  80. tempbuffer[11] = ((BYTE*)(&tcpleng))[0];
  81.         
  82. tempushort = (USHORT*) tempbuffer;
  83. tcpchecksum = GetCksum(tempushort, tcpleng+12);
  84. buffer[34+16] = ((BYTE*)(&tcpchecksum))[0];
  85. buffer[34+17] = ((BYTE*)(&tcpchecksum))[1];
  86. delete [] tempbuffer;
  87. return TRUE;
  88. }
  90. //input eth and calculate checksum
  91. BOOL GetUDPCksum(BYTE* buffer,int leng)
  92. {
  93. USHORT  udpleng;
  94. USHORT  udpchecksum;
  95. USHORT*  tempushort;
  97. BYTE*   tempbuffer;
  98. //set checksum=0;
  99. buffer[34+6] = 0;
  100. buffer[34+7] = 0;
  101.     //getudpleng(total)
  102.     ((BYTE*)(&udpleng))[0] = buffer[34+5];
  103.     ((BYTE*)(&udpleng))[1] = buffer[34+4];
  104.     //get pseudo head
  105. tempbuffer = new BYTE[udpleng+12];
  106. memcpy(tempbuffer+12,buffer+34,udpleng);
  107. tempbuffer[0] = buffer[26];
  108. tempbuffer[1] = buffer[27];
  109. tempbuffer[2] = buffer[28];
  110. tempbuffer[3] = buffer[29];
  111. tempbuffer[4] = buffer[30];
  112. tempbuffer[5] = buffer[31];
  113. tempbuffer[6] = buffer[32];
  114. tempbuffer[7] = buffer[33];
  115.         tempbuffer[8] = 0;
  116. tempbuffer[9] = 17;
  117. tempbuffer[10] = buffer[34+4];
  118. tempbuffer[11] = buffer[34+5];
  119.         
  120. tempushort = (USHORT*) tempbuffer;
  121. udpchecksum = GetCksum(tempushort, udpleng+12);
  122. buffer[34+6] = ((BYTE*)(&udpchecksum))[0];
  123. buffer[34+7] = ((BYTE*)(&udpchecksum))[1];
  124. delete [] tempbuffer;
  125. return TRUE;
  126. }
  128. //input eth and calculate checksum
  129. BOOL GetIPCksum(BYTE* buffer,int leng)
  130. {
  131. BYTE* tempbufferttt;
  132. USHORT* tempushortbuffer;
  133. USHORT  checksum;
  135. tempbufferttt = &buffer[14];
  136. tempushortbuffer = (USHORT* )tempbufferttt;
  137. tempushortbuffer[5] = 0;
  138.     checksum = GetCksum(tempushortbuffer,20);
  139. tempushortbuffer[5] = checksum;
  141.     return TRUE;
  142. }
  144. //input buffer  and calculate checksum
  145. USHORT  GetCksum(USHORT* buffer,int size)
  146. {
  147. DWORD cksum;
  148. USHORT OddByte;
  150. cksum=0;
  151. while(size>1)
  152. {
  153. cksum+=*buffer++;
  154. size-=2;
  155. }
  156. if(size==1)
  157. {
  158.         OddByte = 0;
  159. *((unsigned char*)&OddByte)= *(unsigned char*)buffer;
  160. cksum+=OddByte;
  161. }
  162. cksum=(cksum>>16)+(cksum&0xffff);
  163. cksum+=(cksum>>16);
  164. cksum=~cksum;
  166.     return (unsigned short)cksum;
  167. }
  170. /*for test*/
  171. BOOL NatForOutIcmpPacket(BYTE* EthBuffer,ULONG packetlength,USHORT Adapternumber)
  172. {
  173.     BYTE* tempbuffer;
  174. BYTE* tempbufferttt;
  175. USHORT*  tempushortbuffer;
  176. USHORT   checksum;
  177.     int   EheadLength;
  179. EheadLength=14;
  180.     tempbuffer=EthBuffer;
  181. if(tempbuffer[12]==0x08&&tempbuffer[13]==0x00)
  182. {
  183. if(tempbuffer[23]!=0x01)
  184. {
  185. return FALSE;
  186. }
  187. //begin modify
  188. tempbuffer[26] = 0xc0;
  189.         tempbuffer[27] = 0xa8;
  190. tempbuffer[28] = 0x81;
  191. tempbuffer[29] = 0xc1;
  192. //modify ip checksum
  193.         tempbufferttt = &tempbuffer[14];
  194. tempushortbuffer = (USHORT* )tempbufferttt;
  195. tempushortbuffer[5] = 0;
  196.         checksum = GetCksum(tempushortbuffer,20);
  197. tempushortbuffer[5] = checksum;
  198. }
  199. else
  200. {
  201. TRACE(_T("Found a not IP packetn"));
  202. }
  203. return TRUE;
  204. }
  206. /*for test*/
  207. BOOL NatForInIcmpPacket(BYTE* EthBuffer,ULONG packetlength,USHORT Adapternumber)
  208. {
  210.     BYTE* tempbuffer;
  211. USHORT*  tempushortbuffer;
  212. USHORT   checksum;
  213.     int   EheadLength;
  215. EheadLength=14;
  216.     tempbuffer=EthBuffer;
  217. if(tempbuffer[12]==0x08&&tempbuffer[13]==0x00)
  218. {
  219. if(tempbuffer[23]!=0x01)
  220. {
  221. TRACE(_T("It's  not a IPandICMP packetn"));
  222. return FALSE;
  223. }
  224. tempbuffer[30] = 0xc0;
  225.         tempbuffer[31] = 0xa8;
  226. tempbuffer[32] = 0x0;
  227. tempbuffer[33] = 0x0b;
  228. //modify ip checksum
  229.         tempbuffer = &tempbuffer[14];
  230. tempushortbuffer = (USHORT* )tempbuffer;
  231. tempushortbuffer[5] = 0;
  232.         checksum  = GetCksum(tempushortbuffer,20);
  233. tempushortbuffer[5] = checksum;
  234. }
  235. else
  236. {
  237. TRACE(_T("Found a not IP packetn"));
  238. }
  239. return TRUE;
  240. }
  242. //add item to nattable
  243. NATTABLE_ITEM*  NatTableAddItem(BYTE* EthBuffer,BOOL bDirection, USHORT type)
  244. {
  246.    _ETHER_PACKET*   pEtherPacket;
  247.    _IP_HEADER*      pIPheader;
  248.    _TCP_HEADER*     pTCPheader;
  249.    _UDP_HEADER*     pUDPheader;
  250.        NATTABLE_ITEM*   pResult;
  251.    NATTABLE_ITEM*   ptempResult;  
  252.    USHORT           uSearchInterPort;
  253.    USHORT           uSearchOutPort;
  254.    USHORT             pos;
  255.    USHORT             index;
  256.    USHORT           tempSuffix;
  258.        pEtherPacket = (_ETHER_PACKET*)EthBuffer;
  259.    pIPheader    = (_IP_HEADER*)(EthBuffer+14);
  260.    //pTCPheader   = (_TCP_HEADER*)(EthBuffer+34);      
  261.        
  262.    switch (type) {
  263.    case 1: //it a tcp
  264.        TRACE(_T("ADD TCP ITEMn"));
  265.        pTCPheader   = (_TCP_HEADER*)(EthBuffer+34);
  266.                uSearchInterPort = pTCPheader->source;    
  267.    //modify InHashIDTable;
  268.    //modify OutHashIDTable;
  269.    //modify nattable
  270.        //get out port    
  271.    if(pChooseportBufferheader == pChooseportBufferbottom)
  272.    return 0;     
  273.        
  274.    
  275.    uSearchOutPort = *pChooseportBufferheader;    
  276.    pChooseportBufferheader--;
  277.    
  279.        //modify nattable
  280.    //USHORT  iii = uSearchOutPort - DYN_LOW_PORT;
  281.    
  282.    pResult= &nattable[swaps(uSearchOutPort) - DYN_LOW_PORT];
  283.        memset(pResult,0,sizeof(NATTABLE_ITEM));
  284.    pResult->ul_GlobalIPAddress = uc_GlobalIPAddress;
  285.    pResult ->ul_InterIPAddress = pIPheader->saddr;
  286.    pResult ->ul_OutIPAddress   = pIPheader ->daddr;
  287.    pResult ->us_InterPort      = uSearchInterPort;
  288.    pResult ->us_OutPort        = uSearchOutPort;
  289.    pResult ->us_TimeOut        = TCPTIMEOUT;   
  290.        pResult-> bUse              = 1;
  292.        //get for InhashIDTable
  293.    pos = uSearchOutPort% 997 +1;
  294.    tempSuffix = InHashIDTable[pos];
  296.    // modify InHashIDTable
  297.     if(InHashIDTable[pos] == 0)
  298.     InHashIDTable[pos] = swaps(uSearchOutPort) - DYN_LOW_PORT;
  299. else
  300.  {
  301. ptempResult = &nattable[(InHashIDTable[pos])];
  302. tempSuffix = InHashIDTable[pos];
  303. while(1) 
  304. {
  305.              if(ptempResult->uInSuffixNext !=0)
  306.  {
  307.  tempSuffix  = ptempResult->uInSuffixNext;
  308.  ptempResult = &nattable[ptempResult->uInSuffixNext];            
  309.  continue;
  310.  }
  311.  else
  312.  {
  313.  ptempResult->uInSuffixNext = swaps(uSearchOutPort) - DYN_LOW_PORT;
  314.                  pResult->uInSuffixParent   = tempSuffix;
  315.  break;
  316.  }
  317. }
  318.  }
  319.    
  320.    //modify uOutHashIDTable
  321.    //get outHashID
  322.        index = NATGetIndexOther(pIPheader->saddr,pIPheader->daddr,pTCPheader->source);
  323.       
  324.    if(OutHashIDTable[index] == 0)
  325.     OutHashIDTable[index] = swaps(uSearchOutPort) - DYN_LOW_PORT;
  326. else
  327.  {
  328. ptempResult = &nattable[(OutHashIDTable[index])];
  329. tempSuffix = OutHashIDTable[index];
  330. while(1) 
  331. {
  332.              if(ptempResult->uOutSuffixNext !=0)
  333.  {
  334.  tempSuffix  = ptempResult->uOutSuffixNext;
  335.  ptempResult = &nattable[ptempResult->uOutSuffixNext];            
  336.  continue;
  337.  }
  338.  else
  339.  {
  340.                  ptempResult->uOutSuffixNext = swaps(uSearchOutPort) - DYN_LOW_PORT;
  341.                  pResult->uOutSuffixParent = tempSuffix;
  342.  break;
  343.  }
  344. }
  345.  }
  346.           
  347.         break;
  348.    case 2: //it a udp
  349.    break;
  350.    default:
  351.    return 0;
  352.    }
  353.    
  354.    return pResult;           
  355. }
  357. NATTABLE_ITEM* NatSearch(BYTE* EthBuffer,BOOL bDirection, USHORT type)
  358. {
  359.    _ETHER_PACKET*   pEtherPacket;
  360.    _IP_HEADER*      pIPheader;
  361.    _TCP_HEADER*     pTCPheader;
  362.    _UDP_HEADER*     pUDPheader;
  363.        NATTABLE_ITEM*   pResult;
  364.    USHORT           pos;
  365.        USHORT           otherindex;
  366.        NATTABLE_ITEM*  pOtherResult;
  368.        pEtherPacket = (_ETHER_PACKET*)EthBuffer;
  369.    pIPheader    = (_IP_HEADER*)(EthBuffer+14);
  370.    
  371.    switch (type) {
  372.    case 1: //it is a tcp
  373.        WaitForSingleObject(access_event,INFINITE);
  374.            //ResetEvent(access_event);
  375. //    TRACE(_T("begin search item n"));
  376.        pTCPheader   = (_TCP_HEADER*)(EthBuffer+34);
  377.                if(bDirection) //out is true, in is false
  378.    {
  379.    //search for out packet
  380.    //get index in othertable
  381. //    TRACE(_T("OUT SEARCH n"));
  383.    otherindex = NATGetIndexOther(pIPheader->saddr,pIPheader->daddr,pTCPheader->source);
  385.    if(OutHashIDTable[otherindex]<1)
  386.            return 0;
  387.                     pOtherResult = &nattable[OutHashIDTable[otherindex]];
  388.                    while(1)
  389.    {
  390.   
  391.               if(pOtherResult->us_TimeOut != 0 && pOtherResult->ul_InterIPAddress == pIPheader->saddr&&
  392.  pTCPheader->source == pOtherResult->us_InterPort)
  393.   {
  394.    pOtherResult->us_TimeOut = TCPTIMEOUT;
  395.    //SetEvent(access_event);
  396.                return pOtherResult;
  397.   }
  399.               if(pOtherResult->uOutSuffixNext != 0 )
  400.   {
  401.                    pOtherResult = &nattable[pOtherResult->uOutSuffixNext];
  402.    TRACE(_T("found  next for out packetn")); 
  403.                     continue;
  404.   }
  405.               else
  406.   {
  407.                pOtherResult = 0;
  408.                     break;
  409.   }
  410.   
  411.    }
  412.        //SetEvent(access_event);
  413.                    return  pOtherResult;
  414.    }
  415.    else
  416.    {
  417.    //search for in packet
  418. //    TRACE(_T("IN SEARCH n"));
  419.    pos = pTCPheader->dest % 997+1;
  420.    if(InHashIDTable[pos]>0)
  421.       pResult = &nattable[(InHashIDTable[pos])] ;  
  422.                    else
  423.    return 0;
  425.                    while(1)
  426.    {
  427.   
  428.               if(pResult->us_TimeOut != 0 && pResult->us_OutPort == pTCPheader->dest )
  429.   {
  430.   pResult->us_TimeOut = TCPTIMEOUT;
  431.   //SetEvent(access_event);
  432.                    return pResult;
  433.   }
  435.               if(pResult->uInSuffixNext != 0)
  436.   {
  437.                    pResult = &nattable[pResult->uInSuffixNext];
  438.    TRACE(_T("found  next for in packetn")); 
  439.                     continue;
  440.   }
  441.               else
  442.   {
  443.                pResult = 0;
  444.    //TRACE(_T(""));
  445.                    break;
  446.   }
  447.   
  448.    }
  449.    //SetEvent(access_event);
  450.                    return  pResult;
  451.    }
  452.    break;
  453.    case 2: //it a udp
  454.        break;
  455.    default:
  456.    return 0;
  457.    }    
  458.    return 0;
  459. }
  461. //nat packet include in and out
  462. BOOL NatPacket(BYTE* total_EthBuffer)
  463. {
  464. _ETHER_PACKET*   pEtherPacket;
  465. _IP_HEADER*      pIPheader;
  466. _TCP_HEADER*     pTCPheader;
  467. _UDP_HEADER*     pUDPheader;
  468.     NATTABLE_ITEM*   pResult;
  469.     BYTE*  EthBuffer;
  470.     int Direction;
  471.     EthBuffer = total_EthBuffer+2;
  472. pResult = 0;
  473.     pEtherPacket = (_ETHER_PACKET*)EthBuffer;
  474. pIPheader    = (_IP_HEADER*)(EthBuffer+14);
  475. pTCPheader   = (_TCP_HEADER*)(EthBuffer+34);
  476. pUDPheader   = (_UDP_HEADER*)(EthBuffer+34);
  478.     //if the packet is not a ip
  479. if(pEtherPacket->ETH.h_proto != 0x0008)
  480. {
  481. return FALSE;
  482. }
  483.    
  484. //the packet is from devinstance = 3 ?
  485. //need modify
  486.   if(total_EthBuffer[1]!=(OUTNO-0x30))
  487. return FALSE;
  489.     //set direction by out or in
  490. if(total_EthBuffer[0] == 1)
  491.         Direction = 1;
  492. else
  493. Direction = 0;
  495. if(Direction)//out is true, in is false
  496. {
  497. switch  (pIPheader->protocol) {
  498. case 6:
  499. //out
  500. //the packet by this computer not nat
  501. if(pIPheader ->saddr == uc_GlobalIPAddress)
  502.     return TRUE;
  503.         
  504. //first find in statictable
  505.         if(!NATSearchStatic(EthBuffer,1,1))
  506. {
  507. pResult = NatSearch(EthBuffer,1,1);
  508. // TRACE(_T("search endn"));
  509. //Note: no judge the result of additem
  510. if(!pResult)
  511. {
  512. WaitForSingleObject(access_event,INFINITE);
  513.         ResetEvent(access_event);
  514. pResult = NatTableAddItem(EthBuffer,1,1);
  515. SetEvent(access_event);
  516. }
  517.         if(!pResult)
  518. {
  519. //if go to here ,something is wrong
  520. TRACE(_T("addite erron"));
  521. return FALSE;
  522. }
  523. //modify src port
  524. pTCPheader ->source = pResult->us_OutPort;
  525. }
  526.         //modify ipaddress
  527. pIPheader->saddr = uc_GlobalIPAddress;
  528. //TRACE(_T("sport =%x", pTCPheader ->source));
  529. //modify ip checksum
  530. GetIPCksum(EthBuffer,1000); 
  531. //modify tcp checksum
  532.     GetTCPCksum(EthBuffer,1000);                                                                                                                                                                                                                                                                                                                                                                                    GetTCPCksum(EthBuffer,1000);
  533. break;
  534. case 17:
  535. //Note: no add for udp packet
  536. //the packet by this computer not nat
  537. if(pIPheader ->saddr == uc_GlobalIPAddress)
  538.     return TRUE;
  540. pIPheader->saddr = uc_GlobalIPAddress;
  541. //TRACE(_T("sport =%x", pTCPheader ->source));
  542. //modify ip checksum
  543. GetIPCksum(EthBuffer,1000);
  544.         //modify tcp checksum
  545.     GetUDPCksum(EthBuffer,1000);
  546. break;
  547. default:
  548. return FALSE;
  549. }
  550. }
  551. else
  552. {
  553. switch (pIPheader->protocol){
  554. case 6:
  555. //in
  556. //TRACE(_T("source port = %d n"),swaps(pTCPheader->source));
  557. //first find in statictable
  558. if(!NATSearchStatic(EthBuffer,0,1))
  559. {
  560. pResult = NatSearch(EthBuffer,0,1);
  561.         if(pResult == 0)
  562. {
  563. TRACE(_T("IN PACKET NOT FOUND ITEM n"));
  564. return FALSE;
  565. }
  566. //modify dst ipaddress "192.168.0.11"
  567. //modify dst port
  568. pIPheader->daddr = pResult->ul_InterIPAddress;
  569. pTCPheader ->dest = pResult->us_InterPort;
  570. }
  571. //modify ip checksum
  572. // TRACE(_T("IN PACKET begin nat n"));
  573. GetIPCksum(EthBuffer,1000);
  574.         //modify tcp checksum
  575. GetTCPCksum(EthBuffer,1000);
  576. break;
  577.  case 17:
  579.         //if in staticudptable, modify dst ipaddress
  580.  //first find in statictable
  581. if(NATSearchStatic(EthBuffer,0,2))
  582. {
  583.     GetIPCksum(EthBuffer,1000);
  584.             GetUDPCksum(EthBuffer,1000);
  585. }
  586. break;
  587. default:
  588. return FALSE;
  589. }
  590. }
  591. return TRUE;
  592. }
  594. void NatCfg()
  595. {
  596.    DYN_LOW_PORT=pnatcfg.us_LowPort;  
  598.    DYN_HIGH_PORT=pnatcfg.us_HighPort;
  600.    MAX_NAT_CONNECT=pnatcfg.us_MaxNatNumber;
  601.    TCPTIMEOUT=pnatcfg.nTimeOut_TCP; 
  602.  //Set up nattable and inhashIDtable,outhashIDtable ,three table
  603.  //BYTE* temp = new BYTE[1024*ITEM_LENG];
  604.  //memset(temp,0,1024*ITEM_LENG);
  606.  //tempaddd for test
  607. //need modify
  608.  STATICTABLE      statictable;
  609. //  statictable.count = 3;
  610.      statictable.count = pnatcfg.StaticTable.count;
  611. //  STATICTABLEITEM*  statictableitem = new STATICTABLEITEM[pnatcfg->StaticTable.count];
  612.      
  613. //     statictable.item = statictableitem;
  614.  statictable.item=pnatcfg.StaticTable.item;
  615. /*
  616.  statictableitem[0].type = 1;
  617.  statictableitem[0].ulIpadress = 0x0b00a8c0;
  618.  statictableitem[0].usPort =  swaps(20);//16415;
  619.  statictableitem[1].type = 2;
  620.  statictableitem[1].ulIpadress = 0x0b00a8c0;
  621.  statictableitem[1].usPort =  0xba08;
  622.  statictableitem[2].type = 1;
  623.  statictableitem[2].ulIpadress = 0x0b00a8c0;
  624.  statictableitem[2].usPort =  300;
  625. */
  626.  //for test end
  628.    StaticTCPcount = 0;
  629.  StaticUDPcount = 0;
  631.  STATICTABLEITEM*  temp;
  632.  temp = statictable.item;
  633.      
  634.  //set static data from statictable
  635.  for(int j=0;j<statictable.count;j++) 
  636.  {
  637.  switch  (temp->type){
  638.  case 1:
  639.  //tcp
  640.  StaticTCPtable[StaticTCPcount].ulIpadress = temp->ulIpadress;
  641.  StaticTCPtable[StaticTCPcount].usPort     = temp->usPort;
  642.  StaticTCPcount++;
  643.  break;
  644.  case 2:
  645.  //udp
  646.  StaticUDPtable[StaticUDPcount].ulIpadress = temp->ulIpadress;
  647.  StaticUDPtable[StaticUDPcount].usPort     = temp->usPort;
  648.  StaticUDPcount++;
  649.  break;
  650.  default:
  651.  break;
  652.  }
  653.  temp++;
  654.  }
  656. //     delete[] statictableitem;
  657.  nattable = new NATTABLE_ITEM[MAX_NAT_CONNECT];
  658.  memset(nattable,0,sizeof(NATTABLE_ITEM)*MAX_NAT_CONNECT);
  659.      
  660.  memset(InHashIDTable,0,1000);
  661.  memset(OutHashIDTable,0,1000);
  663.      USHORT    lowport;
  664.  lowport = DYN_LOW_PORT;
  665.  //set GlobalIPAddress
  666.  //need modifyOutGlobalAddr
  667.  ((BYTE*)(&uc_GlobalIPAddress))[0] = OutGlobalAddr.s_b[0];
  668.  ((BYTE*)(&uc_GlobalIPAddress))[1] = OutGlobalAddr.s_b[1];
  669.  ((BYTE*)(&uc_GlobalIPAddress))[2] = OutGlobalAddr.s_b[2];
  670.  ((BYTE*)(&uc_GlobalIPAddress))[3] = OutGlobalAddr.s_b[3];   
  671.  
  672.    
  673.  //set up a buffer for choose outport;
  674.  pChooseportBufferbottom = new USHORT[MAX_NAT_CONNECT];
  675.  pChooseportBufferheader = pChooseportBufferbottom;
  676.      for(USHORT i=0;i<MAX_NAT_CONNECT;i++)
  677.  {
  678.  //Note: not add different port use for other side
  679.  pChooseportBufferbottom[i] = swaps(lowport +i);
  680.  pChooseportBufferheader   =  &pChooseportBufferbottom[i];
  681.  }
  682.  
  683.      
  684.  access_event = CreateEvent(0,1,1,0);
  685.  DWORD     dwThreadId;
  686.  //for timeout inspec
  687.  ::CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)NatBeginThread,NULL,0,&dwThreadId);
  688.  
  689.      return ;
  690. }
  692. BOOL  NATableTimeInspec()
  693. {
  694. //modify TimeOut
  695. //NATTABLE_ITEM* pTempItem     = 0;
  696. //NATTABLE_ITEM* pTempItemlast ;
  697. USHORT    temp;
  698.     
  699. for(int i=1;i<MAX_NAT_CONNECT;i++)
  700. {
  701.        
  702.  if(nattable[i].bUse == 0)
  703.  continue;
  704.  if(nattable[i].us_TimeOut == 0)
  705.  {
  706.  //modif nattable item and inhashidtable and outhashidtable
  707.  if(nattable[i].uInSuffixParent >0 )
  708.    nattable[nattable[i].uInSuffixParent].uInSuffixNext = nattable[i].uInSuffixNext;
  709.  else
  710.  {
  711.  temp = nattable[i].us_OutPort % 997 +1;
  712.  if(nattable[i].uInSuffixNext == 0)
  713.  InHashIDTable[temp] = 0;
  714.  else
  715.  {
  716.  InHashIDTable[temp] = nattable[i].uInSuffixNext;
  717.  //nattable[nattable[i].uInSuffixNext].uInSuffixParent = 0;
  718.  }
  719.  }
  721.  if(nattable[i].uInSuffixNext >0)
  722.  nattable[nattable[i].uInSuffixNext].uInSuffixParent = nattable[i].uInSuffixParent;  
  724.  if(nattable[i].uOutSuffixParent >0 )
  725.    nattable[nattable[i].uOutSuffixParent].uOutSuffixNext = nattable[i].uOutSuffixNext;
  726.  else
  727.  {
  728.  temp = NATGetIndexOther(nattable[i].ul_InterIPAddress,
  729.     nattable[i].ul_OutIPAddress,nattable[i].us_InterPort);
  731.  if(nattable[i].uOutSuffixNext == 0)
  732.  OutHashIDTable[temp] = 0;
  733.  else
  734.  {
  735.  OutHashIDTable[temp] = nattable[i].uOutSuffixNext;
  736.  //nattable[nattable[i].uOutSuffixNext].uOutSuffixParent = 0;
  737.  }
  738.  }
  740.  if(nattable[i].uOutSuffixNext >0)
  741.  nattable[nattable[i].uOutSuffixNext].uOutSuffixParent = nattable[i].uOutSuffixParent;  
  742.  //
  743.  pChooseportBufferheader++;
  744.  *pChooseportBufferheader = nattable[i].us_OutPort;
  745.  if(nattable[i].us_OutPort >2100)
  746.                       TRACE(_T("port ERRn"));
  748.              memset(&nattable[i],0,sizeof(NATTABLE_ITEM));  
  749.  TRACE(_T("del a item :%dn"), i);
  750.  }
  751.  else
  752.              nattable[i].us_TimeOut--;
  753. }
  754.     
  755. return TRUE;
  756. }
  758. void ClearNatUseResoure()
  759. {
  760. delete[]  nattable;
  761. //delete[]  nattableUDP;
  762. delete[]  pChooseportBufferbottom;
  763. // delete[]  statictableitem;
  764. //delete[]  pChooseportBufferbottomUDP;
  765. CloseHandle(access_event);
  766. //CloseHandle(access_event2);
  767. return;
  768. }
  770. void NatBeginThread(PVOID temp)
  771. {
  772.      while(1)
  773.  {
  774.  Sleep(60000);
  775.  WaitForSingleObject(access_event,INFINITE);
  776.      ResetEvent(access_event);  
  777.  NATableTimeInspec();
  778.          SetEvent(access_event);
  779.  //TRACE(_T("over timeinspec n"));
  780. // WaitForSingleObject(access_event2,INFINITE);
  781.     // ResetEvent(access_event2);  
  782. // NATableTimeInspecUDP();
  783.         // SetEvent(access_event2);
  784.  }
  785. }
  789. USHORT  NATGetIndexOther(ULONG ipaddress1,ULONG ipaddress2,USHORT sport)
  790. {
  791.       USHORT  tempindex;
  792.   tempindex = 0;
  793.      
  794.   tempindex = ((USHORT* )&ipaddress1)[0]+((USHORT* )&ipaddress1)[1]
  795.   +((USHORT* )&ipaddress2)[0]+((USHORT* )&ipaddress2)[1]
  796.   +sport;
  797. //  TRACE(_T("1:  %d n"),((USHORT* )&ipaddress1)[0]);
  798. //  TRACE(_T("2:  %d n"),((USHORT* )&ipaddress1)[1]);
  799. //  TRACE(_T("3:  %d n"),((USHORT* )&ipaddress2)[0]);
  800. //  TRACE(_T("4:  %d n"),((USHORT* )&ipaddress2)[1]);
  801. //   TRACE(_T("PROT:  %d n"),sport);
  802. //      TRACE(_T("INDEX:  %d n"),tempindex);
  803.   return tempindex % 997;   
  804. }
  807. USHORT swaps(USHORT port)
  808. {
  809. USHORT lo,hi;
  810. USHORT host;
  812. lo=port&0xff;
  813. hi=port&0xff00;
  814. lo=lo<<8;
  815. hi=hi>>8;
  816. host=hi|lo;
  818. return host;
  819. }
  821. BOOL NATSearchStatic(BYTE* EthBuffer,BOOL Direction,USHORT type)
  822. {
  823. _IP_HEADER*      pIPheader;
  824. _TCP_HEADER*     pTCPheader;
  825. _UDP_HEADER*     pUDPheader;
  826.     
  827. pIPheader    = (_IP_HEADER*)(EthBuffer+14);
  828. pTCPheader   = (_TCP_HEADER*)(EthBuffer+34);
  829. pUDPheader   = (_UDP_HEADER*)(EthBuffer+34);
  830.     
  831. switch (type) {
  832. /*
  833. =1:  TCP;
  834. =2:  UDP;
  835. */
  836. case 1:
  837. if(Direction)
  838. /*
  839. Direction =TRUE;OUT
  840. Direction =FALSE;IN
  841. */
  842. {
  843. for(int i=0;i<StaticTCPcount;i++)
  844. {
  845. if(StaticTCPtable[i].usPort == pTCPheader->source)
  846. {
  847.                // pIPheader->saddr = uc_GlobalIPAddress;
  848. TRACE(_T("STATIC NAT OUT TCPn"));
  849. return TRUE;
  850. }
  851. }
  852. return FALSE;
  853. }
  854. else
  855. {
  856. if(pTCPheader->dest>DYN_LOW_PORT&&pTCPheader->dest<DYN_HIGH_PORT)
  857.           return FALSE;
  858. for(int j=0;j<StaticTCPcount;j++)
  859. {
  860. if(StaticTCPtable[j].usPort == pTCPheader->dest)
  861. {
  862.                 pIPheader->daddr = StaticTCPtable[j].ulIpadress;
  863. TRACE(_T("STATIC NAT IN TCPn"));
  864. return TRUE;
  865. }
  866. }
  867. return FALSE;
  868. }
  869. break;
  870. case 2:
  871. if(!Direction)
  872. /*
  873. Direction =TRUE;OUT
  874. Direction =FALSE;IN
  875. */
  876. {
  877.    for(int f=0;f<StaticUDPcount;f++)
  878. {
  879. if(StaticUDPtable[f].usPort == pUDPheader->dest)
  880. {
  881.                 pIPheader->daddr = StaticUDPtable[f].ulIpadress;
  882. TRACE(_T("STATIC NAT IN UDPn"));
  883. return TRUE;
  884. }
  885. }
  886. return FALSE;
  887. }
  888. break;
  889. default:
  890. return FALSE;
  891. }
  892. return FALSE;
  893. }