throughfirewall.java

实现Oracle客户端和Oracle服务器中间转发的Java源代码.*注:使Window下Oracle数据和侦听端口共享

package throughfirewall;

import java.util.Vector;
import java.io.*;
import java.net.*;

//@start java.exe -classpath .\jproxychain.jar l0056509104

class throughfirewall
{
   private static final   int MAX_CONNECTION=1000;
   private static boolean DEBUG_MODE = false;
   private static Vector  clients     = new Vector();  
   private static int     localPort   = 6000;
   private static int     remotePort  = 1521;
   private static String  remotetHost = "192.0.2.91";
   private static String  connectType = "WINDOW";
   
   public static void main(String[] args) throws IOException
   {
      int i;
      String[] szUsage={"使用说明: ",
                  "   OracleNet localPort remotePort remotetHost connectType debugMode",    
                  "   OracleNet localPort remotePort remotetHost connectType",    
                  "   OracleNet localPort remotePort remotetHost debugMode",    
                  "   OracleNet localPort remotePort remotetHost",    
                  "参数说明：",    
                  "   localPort  : 客户端tnsnames.ora配置的远程端口",    
                  "   remotePort : 服务器侦听端口",    
                  "   remotetHost: 服务器侦听地址",    
                  "   connectType: 服务器类型,其必须为UNIX或WINDOW，缺省为WINDOW",    
                  "   debugMode  : 调试模式，其值为DEBUG或NODEBUG，缺省为NODEBUG",    
                  "使用样例: ",    
                  "   OracleNet.exe 1234 1521 192.0.2.91 UNIX DEBUG",    
                  "   OracleNet.exe 1234 1521 192.0.2.91 WINDOW DEBUG",    
                  "   OracleNet.exe 1234 1521 192.0.2.91 UNIX",    
                  "   OracleNet.exe 1234 1521 192.0.2.91 WINDOW",    
                  "   OracleNet.exe 1234 1521 192.0.2.91 DEBUG",    
                  "   OracleNet.exe 1234 1521 192.0.2.91",    
                  "缺省命令行: "};
      About();
      if (args.length == 3)
      { 
         localPort   = Integer.parseInt(args[0]);
         remotePort  = Integer.parseInt(args[1]);
         remotetHost = args[2];
      }
      else if (args.length == 4)
      { 
         localPort   = Integer.parseInt(args[0]);
         remotePort  = Integer.parseInt(args[1]);
         remotetHost = args[2];
         if(args[3].equalsIgnoreCase("DEBUG"))
         {
            DEBUG_MODE = true;
         }
         else if(args[3].equalsIgnoreCase("NODEBUG"))
         {
            DEBUG_MODE = false;
         }
         else
         {
            connectType = args[3];
         }
      }
      else
      {
         for (i=0;i<szUsage.length;i++)
         {
            System.out.println(szUsage[i]);
         }
         System.out.println("   OracleNet.exe "+localPort+" "+remotePort+" "+remotetHost+" "+connectType+" NODEBUG");    
      }
      new throughfirewall(localPort,remotePort,remotetHost);
   }

   throughfirewall(int localPort,int remotePort,String remotetHost) throws IOException
   {
      ServerSocket server=new ServerSocket(localPort);
      System.out.println("服务已启动，等待客户端连接......");     
      System.out.println("本地服务端口:"+localPort);
      System.out.println("远程服务映射端口:"+remotePort);
      System.out.println("远程服务映射主机:"+remotetHost);
      try
      {
         while(true)
         {
            Socket incoming=server.accept();
            try
            {  
               System.out.println("客户端【"+incoming.getInetAddress().getHostName()+"/"+incoming.getPort()+"】请求连接");
               if(clients.size()>=MAX_CONNECTION)
               {
                  System.out.println("连接超过最大连接数，取消连接请求");     
                  incoming.close();
               }
               else
               {
                  System.out.println("正在连接重定向【"+remotetHost+"/"+ remotePort+"】");
                  Socket outputing=new Socket(remotetHost,remotePort);
                  
                  System.out.println("重定向成功,当前转发模式【"+connectType+"】");     
                  if(connectType.equalsIgnoreCase("UNIX"))
                  {
                     clients.addElement(new SocketMap(outputing,incoming,"SERVER"));
                     //clients.addElement(new SocketMap(incoming,outputing,"CLIENT"));
                     new SocketMap(incoming,outputing,"CLIENT");
                  }
                  else
                  {
                     clients.addElement(new OracleWinMap(incoming,outputing));
                  }
               }
            }
            catch(IOException e)
            {
               System.out.println("建立服务失败.");
               try
               {
                  incoming.close();
               }
               catch(IOException err)
               {
                  System.out.println("发生错误，关闭连接");
               }
            }
         }
      }
      finally
      {
         server.close();
      }
   }

   class OracleWinMap extends Thread
   {
      private Socket       socket,target;
      private byte[]       dataBuf = new byte[512];
      private int          dataLen;
      private InputStream  clsIn,dbIn;
      private OutputStream clsOut,dbOut;

      OracleWinMap(Socket source,Socket dest) throws IOException
      {
         socket         = source;
         target         = dest;
         clsIn          = socket.getInputStream();
         clsOut         = socket.getOutputStream();
         dbIn           = target.getInputStream();
         dbOut          = target.getOutputStream();

         start();
      }
      
      public void run()
      {
         int     dataPort=0;    
         
         try
         {
            dataLen = clsIn.read(dataBuf);
            if (dataLen>0)
            {
               dbOut.write(dataBuf,0,dataLen);
               dbOut.flush();                            
            }

            dataLen = dbIn.read(dataBuf);
            if (dataLen>0)
            {
               localPort  ++;
               dataPort   = setPackageHeader(socket.getLocalAddress().getHostAddress(),localPort);
               dataBuf[1] = (byte) dataLen;
               clsOut.write(dataBuf,0,dataLen);
               clsOut.flush();                                     
            }  
            try
            {
               if(DEBUG_MODE)
               {
                  System.out.println(localPort+"->"+dataPort);
               }
               DataConnect(localPort,dataPort);    
               localPort ++;
            }  
            catch (Exception e) 
            {
               System.out.println("处理连接数据库侦听异常：" + e);
            }
         }
         catch (Exception e) 
         {
         } 
         finally
         {
            try
            {              
               target.close();
               socket.close();
               clients.remove(this);
            }
            catch(IOException e)
            {
               System.out.println("调用DataConnect错误：" + e);
               System.out.println("发生错误，关闭连接");
            }
         }
      }

      public int setPackageHeader(String Host,int Port)
      {
         byte[]  list = new byte[512];
         int     dbPort,sPos,ePos,len,index;
         String  listStr = "",dbHost;     
         boolean isWindow=false;
   
         for (int i=0; i< 10; i++)
         {
            list [i] =dataBuf[i];
         }
         for (int i=10; i<dataLen; i++)
         { 
            listStr =listStr + (char) dataBuf[i];
         }
         
         if(DEBUG_MODE)
         {
            System.out.println("原数据通道"+listStr);
         }
         
         len     = listStr.length();
         
         sPos    = listStr.indexOf("HOST=");
         ePos    = listStr.indexOf(')',sPos); 
         dbHost  = listStr.substring(sPos+5,ePos);
         if(dbHost!=Host && sPos>0)
         {
            listStr = listStr.substring(0,sPos + 5)  + Host +  listStr.substring(ePos);
            isWindow = true;
         }

         sPos = listStr.indexOf("PORT=");       //查找数据端口
         ePos = listStr.indexOf(')',sPos);
         dbPort   = Integer.parseInt(listStr.substring(sPos+5,ePos));
         if(dbPort!=Port && sPos>0)
         {
            listStr  = listStr.substring(0,sPos + 5) + Port +  listStr.substring(ePos);
            isWindow = true;
         }
         
         if(DEBUG_MODE)
         {
            System.out.println("新数据通道"+listStr);
         }

         if(isWindow) //数据端口和侦听端口不一致
         {
            for (int i=0; i<listStr.length(); i++) //加上更新后的字符串
            { 
               list[10 + i] = (byte) listStr.charAt(i);
            }
            
            dataLen  = 10 + listStr.length();      //更新侦听信息
            for (int i=0; i< list.length; i++)
            {
              dataBuf[i] = list[i];
            } 
         }
         return dbPort;          
      }       

      void DataConnect(int clsPort,int dbPort)
      {
         ServerSocket server = null;         
         Socket   clsSocket,dbSocket;
         try
         {
            server    =new ServerSocket(clsPort);      
            dbSocket  =new Socket(remotetHost,dbPort);
            clsSocket =server.accept();
           
            if(DEBUG_MODE)
            {
               System.out.println("SocketMap("+clsSocket+","+dbSocket+",\"CLIENT\");");
               System.out.println("SocketMap("+dbSocket+","+clsSocket+",\"SERVER\");");
            }
            new SocketMap(dbSocket,clsSocket,"SERVER");
            new SocketMap(clsSocket,dbSocket,"CLIENT");
         } 
         catch (Exception e) 
         {
            System.out.println("建立连接错误："+e);
            try
            {
               server.close();
            } 
            catch(Exception f) 
            {
               e.printStackTrace();
            }
         }
      }

   }

   class SocketMap extends Thread
   {
      private byte[]       dataBuf = new byte[512];
      private int          dataLen;
      private Socket       socket,target;
      private InputStream  thisIn,targetIn;
      private OutputStream thisOut,targetOut;
      private String       serverSymbol,clientSymbol;
      
      SocketMap(Socket source,Socket dest,String symbol) throws IOException
      {
         serverSymbol = symbol;
         socket       = source;
         target       = dest;
         thisIn       = socket.getInputStream();
         thisOut      = socket.getOutputStream();
         targetIn     = target.getInputStream();
         targetOut    = target.getOutputStream();
         if(symbol.equalsIgnoreCase("SERVER"))
         {
            clientSymbol = socket.getLocalAddress().getHostName()+"/"+socket.getPort();
         }
         else
         {
            clientSymbol = socket.getInetAddress().getHostName()+"/"+socket.getPort();
         }
         
         start();
      }
      
      public void run()
      {
         int     dbdataPort=0;    
         
         System.out.println(serverSymbol+"->【"+clientSymbol+"】开始一个新的线程服务");
         try
         {
            while(true)
            {
               dataLen=thisIn.read(dataBuf);
               if (dataLen>0)
               {
                  if(DEBUG_MODE)
                  {
                     System.out.println(serverSymbol+"缓冲区长度:"+dataLen);
                     if(serverSymbol.equalsIgnoreCase("SERVER"))
                     {
                        SetErrLog("c:\\SocketSERVER.Log",dataBuf,dataLen);
                     }
                     else
                     {
                        SetErrLog("c:\\SocketCLIENT.Log",dataBuf,dataLen);
                     }
                  }
                  targetOut.write(dataBuf,0,dataLen);
                  targetOut.flush();
               }
               else
               {
                  break;
               }
               try
               {
                  this.sleep(10);
               }
               catch(InterruptedException e)
               {
                  e.printStackTrace();
               }
            }
            System.out.println(serverSymbol+"->【"+clientSymbol+"】关闭连接");
         }
         catch(IOException e)
         {
         }
         finally
         {
            try
            {              
               socket.close();    
               if(connectType.equalsIgnoreCase("UNIX") && serverSymbol.equalsIgnoreCase("SERVER"))
               {  
                  clients.remove(this);
               }
            }
            catch(IOException e)
            {
               System.out.println("发生错误，关闭连接");
            }
         }
      }
   
      public void SetErrLog(String filename,byte[] dataBuffer,int len) 
      {
         File file = new File(filename);
         FileOutputStream fos;
         
         try
         {
            if(!file.exists())
            {
               fos = new FileOutputStream(file);
            }
            else
            {
               fos = new FileOutputStream(file,true);
            }
            fos.write(dataBuffer,0,len);
            fos.close();
         }
         catch(FileNotFoundException e)
         {
            e.printStackTrace();
         }
         catch(Exception e)
         {
            e.printStackTrace();
         }
      }
   }

   //版本声明
   static void About()
   {
      int      i;
      String[] szAbout={"\n\n\n\t\t\t\t欢迎使用本系统\n\n",
                        "\t    本系统是一个网络Socket转发工具，用于远程Socket转发\n",
                        "\t及Oracle数据库的连接维护。本产品属于个人所有，未经许可，\n",
                        "\t不得随意传播！\n","\t    本产品如有异常请与作者联系！\n\n",
                        "\t\t\t\t联系人：钱海兵\n","\t\t\t\tE-Mail:[e-mail]\n"};
      
      for (i=0;i<szAbout.length;i++)
      {
         System.out.println(szAbout[i]);
      }
   }   
  
}