Changeset 26


Ignore:
Timestamp:
Aug 21, 2012 11:00:53 AM (5 years ago)
Author:
psaiteja
Message:

Not working code, but contains all the needed code blocks.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • VSNServer/src/ServerProxy.java

    r25 r26  
    156156                                        System.out.println("Table does not exist"); 
    157157                                        Statement stmt = conn.createStatement(); 
    158                                         String createtable = "CREATE TABLE ServerHashlist (UrlHash VARCHAR(36) NOT NULL PRIMARY KEY, ObjectHash VARCHAR(36) NOT NULL, HashTime TIMESTAMP NOT NULL, Occurrence INT DEFAULT 0"; 
     158                                        String createtable = "CREATE TABLE ServerHashlist (UrlHash VARCHAR(40) NOT NULL PRIMARY KEY, ObjectHash VARCHAR(40) NOT NULL, HashTime TIMESTAMP NOT NULL, Occurrence INT DEFAULT 0"; 
    159159                                        for(int ct=0;ct<m_threshold;ct++){ 
    160160                                                createtable += ", IP"+(ct+1)+" VARCHAR(15)"; 
     
    173173                                        conn = DriverManager.getConnection("jdbc:derby:serverdatabase;create=true"); 
    174174                                        Statement stmt = conn.createStatement(); 
    175                                         String createtable = "CREATE TABLE ServerHashlist (UrlHash VARCHAR(36) NOT NULL PRIMARY KEY, ObjectHash VARCHAR(36) NOT NULL, HashTime TIMESTAMP NOT NULL, Occurrence INT DEFAULT 0"; 
     175                                        String createtable = "CREATE TABLE ServerHashlist (UrlHash VARCHAR(40) NOT NULL PRIMARY KEY, ObjectHash VARCHAR(40) NOT NULL, HashTime TIMESTAMP NOT NULL, Occurrence INT DEFAULT 0"; 
    176176                                        for(int ct=0;ct<m_threshold;ct++){ 
    177177                                                createtable += ", IP"+(ct+1)+" VARCHAR(15)"; 
     
    202202                                        System.out.println("Client database Table does not exist"); 
    203203                                        Statement stmt = conn.createStatement(); 
    204                                         stmt.executeUpdate("CREATE TABLE ClientDatabase (IP VARCHAR(16) NOT NULL PRIMARY KEY, Port INT DEFAULT 9000, Added TIMESTAMP NOT NULL)"); 
     204                                        stmt.executeUpdate("CREATE TABLE ClientDatabase (IP VARCHAR(15) NOT NULL PRIMARY KEY, Port INT DEFAULT "+(DEFAULT_UDP_PORT-1)+", Added TIMESTAMP NOT NULL)"); 
    205205                                        Statement stmt2 = conn.createStatement(); 
    206206                                        stmt2.executeUpdate("CREATE INDEX IPIndex on ClientDatabase(IP ASC)"); 
     
    211211                                        conn = DriverManager.getConnection("jdbc:derby:serverdatabase;create=true"); 
    212212                                        Statement stmt = conn.createStatement(); 
    213                                         stmt.executeUpdate("CREATE TABLE ClientDatabase (IP VARCHAR(16) NOT NULL PRIMARY KEY, Port INT DEFAULT 9000, Added TIMESTAMP NOT NULL)"); 
     213                                        stmt.executeUpdate("CREATE TABLE ClientDatabase (IP VARCHAR(15) NOT NULL PRIMARY KEY, Port INT DEFAULT "+(DEFAULT_UDP_PORT-1)+", Added TIMESTAMP NOT NULL)"); 
    214214                                        Statement stmt2 = conn.createStatement(); 
    215215                                        stmt2.executeUpdate("CREATE INDEX IPIndex on ClientDatabase(IP ASC)"); 
     
    225225                        try{ 
    226226                                System.out.println("Starting UDP server"); 
    227                                 udpthread = new UDPServerThread(UDPport,conn); 
     227                                udpthread = new UDPServerThread(UDPport,conn,m_threshold); 
    228228                                udpthread.start(); 
    229229                        } 
     
    261261                                        e.printStackTrace(); 
    262262                                } 
    263                                 ServerProxyThread t = new ServerProxyThread(client, conn, udpthread); 
     263                                ServerProxyThread t = new ServerProxyThread(client, conn, udpthread, m_threshold); 
    264264                                t.setDebug(debugLevel, debugOut); 
    265265                                t.setTimeout(ptTimeout); 
     
    281281        private int UDPport = DEFAULT_UDP_PORT; 
    282282        private DatagramSocket UDPserver = null; 
     283        private int m_threshold = 0; 
    283284         
    284285        private Connection database_conn; 
    285286         
    286         public UDPServerThread(int port, Connection conn) throws SocketException{ 
     287        public UDPServerThread(int port, Connection conn, int m) throws SocketException{ 
    287288                UDPport = port; 
    288289                database_conn = conn; 
     290                m_threshold = m; 
    289291                 
    290292                UDPserver = new DatagramSocket(UDPport); 
     
    314316                        try{ 
    315317                                UDPserver.receive(receivePacket); 
    316                                 String IPAddress = new String(receivePacket.getAddress().getAddress());  
     318                                String IPAddress = receivePacket.getAddress().getHostAddress();  
    317319                                int port = receivePacket.getPort();  
    318320                                 
    319321                                try {            
    320                                         Statement stmt2 = database_conn.createStatement(); 
    321                                         ResultSet rs = stmt2.executeQuery("select * from ClientDatabase where IP='"+IPAddress+"'"); 
     322                                        Statement stmt = database_conn.createStatement(); 
     323                                        ResultSet rs = stmt.executeQuery("select * from ClientDatabase where IP='"+IPAddress+"'"); 
    322324                                        if (! rs.next()) { 
    323325                                                PreparedStatement psInsert = database_conn.prepareStatement("insert into ClientDatabase values (?,?,?)"); 
     
    347349        public void sendoldhashes(String ip, int port){ 
    348350                try {            
    349                         Statement stmt2 = database_conn.createStatement(); 
    350                         ResultSet rs = stmt2.executeQuery("select * from ServerHashlist"); 
     351                        Statement stmt = database_conn.createStatement(); 
     352                        ResultSet rs = stmt.executeQuery("select * from ServerHashlist where Occurrence>="+m_threshold); 
    351353                        int num = 0; 
    352                         int MAX_per_packet = 30; //considering 42 bytes (2 sha1 digests+tab+newline) per hash entry, and max 1400 MTU for the UDP packet 
     354                        //java sql timestamp of the format: yyyy-mm-dd hh:mm:ss.fffffffff 
     355                        //considering 75 bytes (2 sha1 digests (40 bytes) + timestamp (30 bytes) +3 tabs (3 bytes)+ 1 newline (1 byte) ) per hash entry, and max 1400 MTU for the UDP packet 
     356                        int MAX_per_packet = 18;  
    353357                        String sendhashdata = ""; 
    354358                        while (rs.next()) { 
    355                                 System.out.println("ENTRY EXISTS -  UrlHash: " + rs.getString(1) 
    356                                                 + " ObjectHash:" + rs.getString(2) ); 
    357                                 sendhashdata += rs.getString(1)+"\t"+rs.getString(2)+"\n"; 
     359                                sendhashdata += rs.getString(1)+"\t"+rs.getString(2)+"\t"+rs.getTimestamp(3)+"\n"; 
    358360                                num++; 
    359361                                if(num==MAX_per_packet){ 
    360362                                        byte [] sendData = sendhashdata.getBytes(); 
    361                                         DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,InetAddress.getByAddress(ip.getBytes()),port); 
     363                                        DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,InetAddress.getByName(ip),port); 
    362364                                        UDPserver.send(sendPacket); 
    363365                                        sendhashdata = ""; 
     
    367369                        if(num>0){ 
    368370                                byte [] sendData = sendhashdata.getBytes(); 
    369                                 DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,InetAddress.getByAddress(ip.getBytes()),port); 
     371                                DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,InetAddress.getByName(ip),port); 
    370372                                UDPserver.send(sendPacket); 
    371373                                sendhashdata = ""; 
     
    380382        } 
    381383         
    382         public void sendhashtoall(String newhash){ 
     384        public void sendhashtoall(String newhash, boolean exclude){ 
    383385                String clientip; 
    384386                int port; 
    385                  
    386                 try {            
    387                         Statement stmt = database_conn.createStatement(); 
    388                         ResultSet rs = stmt.executeQuery("select * from ClientDatabase"); 
     387                String urlhash = newhash.substring(0,newhash.indexOf("\t")); 
     388                String [] ip = new String [m_threshold]; 
     389                try { 
     390                        if(!exclude){ 
     391                                Statement stmt1 = database_conn.createStatement(); 
     392                                ResultSet rs1 = stmt1.executeQuery("select * from ServerHashlist where UrlHash='"+urlhash+"'"); 
     393                                if(rs1.next()){ 
     394                                        for(int i=0;i<m_threshold;i++){ 
     395                                                ip[i] = rs1.getString(5+i); 
     396                                        } 
     397                                } 
     398                        } 
     399                         
     400                        Statement stmt2 = database_conn.createStatement(); 
     401                        ResultSet rs = stmt2.executeQuery("select * from ClientDatabase"); 
    389402                        while(rs.next()) { 
    390403                                clientip = rs.getString(1); 
    391404                                port = rs.getInt(2); 
    392                                 byte [] sendData = newhash.getBytes(); 
    393                                 try{ 
    394                                         DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,InetAddress.getByAddress(clientip.getBytes()),port); 
    395                                         UDPserver.send(sendPacket); 
    396                                 } 
    397                                 catch(Exception e){ 
    398                                         System.out.println("Something wrong in pushing new hash entry to a user"); 
    399                                         e.printStackTrace(); 
     405                                 
     406                                if(!Arrays.asList(ip).contains(clientip)){ 
     407                                        byte [] sendData = newhash.getBytes(); 
     408                                        try{ 
     409                                                DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,InetAddress.getByName(clientip),port); 
     410                                                UDPserver.send(sendPacket); 
     411                                        } 
     412                                        catch(Exception e){ 
     413                                                System.out.println("Something wrong in pushing new hash entry to a user"); 
     414                                                e.printStackTrace(); 
     415                                        } 
    400416                                } 
    401417                        } 
     
    407423        } 
    408424} 
    409 /*  
    410  * The ProxyThread will take an HTTP request from the client 
    411  * socket and send it to either the server that the client is 
    412  * trying to contact, or another proxy server 
    413  */ 
     425 
    414426class ServerProxyThread extends Thread 
    415427{ 
     
    419431        private Connection conn; 
    420432        private UDPServerThread udpthread; 
     433        private int m_threshold = 0; 
    421434         
    422435        // the socketTimeout is used to time out the connection to 
     
    426439        public static final int DEFAULT_TIMEOUT = 5 * 1000; 
    427440        private int socketTimeout = DEFAULT_TIMEOUT; 
    428          
    429          
    430 //      public PullServerProxyThread(Socket s) 
    431 //      { 
    432 //              clientSocket = s; 
    433 //      } 
    434  
    435         public ServerProxyThread(Socket s, Connection con2, UDPServerThread udp) 
     441 
     442        public ServerProxyThread(Socket s, Connection con2, UDPServerThread udp, int m) 
    436443        { 
    437444                clientSocket = s; 
    438445                conn = con2; 
    439446                udpthread = udp; 
     447                m_threshold = m; 
    440448        } 
    441449         
     
    473481                        // other variables 
    474482                        byte[] request = null; 
    475                         byte[] response = null; 
    476483                        int requestLength = 0; 
    477484                        int responseLength = 0; 
     
    524531                                                                + " ObjectHash:" + rs.getString(2) + " Time:" 
    525532                                                                + rs.getString(3)+ " Count:"+rs.getInt(4)); 
     533                                                int m = rs.getInt(4); 
     534                                                if(m<m_threshold){                                                       
     535                                                        String [] ip = new String[m_threshold]; 
     536                                                        for(int ip_c = 0;ip_c<m_threshold;ip_c++){ 
     537                                                                ip[ip_c] = rs.getString(5+ip_c); 
     538                                                        } 
     539                                                         
     540                                                        String clientip = clientSocket.getInetAddress().getHostAddress(); 
     541                                                        if(!Arrays.asList(ip).contains(clientip)){ 
     542                                                                Statement stmt3 = conn.createStatement(); 
     543                                                                int updatecount = stmt3.executeUpdate("UPDATE ServerHashlist SET Occurrence="+(m+1)+", IP"+(4+m+1)+"='"+clientip+"' WHERE UrlHash='"+urldigest+"'"); 
     544                                                                if(m+1==m_threshold){ 
     545                                                                        String objectdigest = rs.getString(2); 
     546                                                                        String timestamp = rs.getTimestamp(3).toString(); 
     547                                                                        udpthread.sendhashtoall(urldigest+"\t"+objectdigest+"\t"+timestamp, false); 
     548                                                                } 
     549                                                        } 
     550                                                } 
    526551                                                System.out.println("redirecting user to origin"); 
    527                                                 int occur = rs.getInt(4); 
    528                                                 Statement stmt3 = conn.createStatement(); 
    529                                                 int updatecount = stmt3.executeUpdate("UPDATE ServerHashlist SET Occurrence="+(occur+1)+" WHERE UrlHash='"+urldigest+"'"); 
    530  
    531552                                                String redirectmsg ="VSNRedirect:true\r\nVSNurldigest:"+rs.getString(1)+"\r\nVSNobjectdigest:"+rs.getString(2)+"\r\ncontent-length:0\r\n\r\n"; 
    532553                                                clientOut.write(redirectmsg.getBytes()); 
     
    574595                                        serverOut.write(request, 0, requestLength); 
    575596                                        serverOut.flush(); 
    576                                  
    577                                         responseLength = streamHTTPData2(serverIn, clientOut,host,url, true); 
     597                                        String clientip = clientSocket.getInetAddress().getHostAddress(); 
     598                                        responseLength = streamHTTPData2(serverIn, clientOut,host,url, true,clientip); 
    578599                                } 
    579600                                catch (SocketTimeoutException ste) 
     
    589610                                                "Connection: close\r\n\r\n"; 
    590611                                        String errMsg = errMsg_header+errMsg_body; 
    591 //                                      String errMsg = "HTTP/1.0 504 Gateway Time-out\r\nContent-Type: text/html\r\n\r\n" +  
    592 //                                                      "<html><body>Error connecting to the server:\n" + ste + "\n</body></html>\r\n"; 
    593612                                        clientOut.write(errMsg.getBytes(), 0, errMsg.length()); 
    594613                                } 
     
    660679                                //temp_header.append(data + "\r\n"); 
    661680                                pos = data.indexOf(" "); 
    662 //                              if ((data.toLowerCase().startsWith("http")) && (pos >= 0) 
    663 //                                              && (data.indexOf(" ", pos + 1) >= 0)) { 
    664 //                                      String rcString = data.substring(pos + 1, 
    665 //                                                      data.indexOf(" ", pos + 1)); 
    666 //                                      try { 
    667 //                                              responseCode = Integer.parseInt(rcString); 
    668 //                                      } catch (Exception e) { 
    669 //                                              if (debugLevel > 0) 
    670 //                                                      debugOut.println("Error parsing response code " 
    671 //                                                                      + rcString); 
    672 //                                      } 
    673 //                              } else { 
    674                                         if ((pos >= 0) && (data.indexOf(" ", pos + 1) >= 0)) { 
    675                                                 pre_url.setLength(0); 
    676                                                 pre_url.append(data.substring(0,pos)); 
    677                                                 url.setLength(0); 
    678                                                 url.append(data.substring(pos + 1,data.indexOf(" ", pos + 1))); 
    679                                                 post_url.setLength(0); 
    680                                                 post_url.append(data.substring(data.indexOf(" ", pos + 1)+1)); 
    681                                         } 
    682                                 //} 
     681                                if ((pos >= 0) && (data.indexOf(" ", pos + 1) >= 0)) { 
     682                                        pre_url.setLength(0); 
     683                                        pre_url.append(data.substring(0,pos)); 
     684                                        url.setLength(0); 
     685                                        url.append(data.substring(pos + 1,data.indexOf(" ", pos + 1))); 
     686                                        post_url.setLength(0); 
     687                                        post_url.append(data.substring(data.indexOf(" ", pos + 1)+1)); 
     688                                } 
    683689                        } 
    684690 
     
    769775         
    770776        private int streamHTTPData2 (InputStream in, OutputStream out,  
    771                                                                         StringBuffer host, StringBuffer url, boolean waitForDisconnect) 
     777                                                                        StringBuffer host, StringBuffer url, boolean waitForDisconnect,String clientip) 
    772778        { 
    773779                // get the HTTP data from an InputStream, and send it to 
     
    811817                                        break; 
    812818                                header.append(data + "\r\n"); 
    813                                  
    814                                 // check for the Host header 
    815                                 pos = data.toLowerCase().indexOf("host:"); 
    816                                 if (pos >= 0) 
    817                                 { 
    818                                         host.setLength(0); 
    819                                         host.append(data.substring(pos + 5).trim()); 
    820                                 } 
    821819                                 
    822820                                // check for the Content-Length header 
     
    896894                                                                        urldigest.append(Integer.toHexString(0xFF & udigest[i])); 
    897895                                                                } 
    898                                                                  
    899                                                                 //System.out.println(url.toString()); 
    900                                                                         //System.out.println("calculated digets before database insertion Digests (url:object): " + urldigest + " : " 
    901                                                                         //              + objectdigest); 
    902896                                                                         
    903897                                                                        try {            
     
    909903                                                                                        //              + rs.getString(3)+ " Count:"+rs.getInt(4)); 
    910904                                                                                        String old_objecthash = rs.getString(2); 
    911                                                                                         int occur = rs.getInt(4); 
    912                                                                                                                                                                                  
    913                                                                                         PreparedStatement psUpdate = conn.prepareStatement("UPDATE ServerHashlist SET Occurrence=?, ObjectHash=?, hashTime=? WHERE UrlHash=?"); 
    914                                                                                         psUpdate.setInt(1, (occur+1)); 
    915                                                                                         psUpdate.setString(2, objectdigest.toString()); 
    916                                                                                         java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
    917                                                                                         psUpdate.setTimestamp(3, currentTimestamp); 
    918                                                                                         psUpdate.setString(4, urldigest.toString()); 
    919                                                                                         psUpdate.executeUpdate(); 
    920                                                                                          
    921                                                                                         if(!old_objecthash.equalsIgnoreCase(objectdigest.toString())){ 
    922                                                                                                 udpthread.sendhashtoall(urldigest.toString()+"\t"+objectdigest.toString()); 
     905                                                                                        int m = rs.getInt(4); 
     906                                                                                        if(m<m_threshold){                                                                                               
     907                                                                                                String [] ip = new String[m_threshold]; 
     908                                                                                                for(int ip_c = 0;ip_c<m_threshold;ip_c++){ 
     909                                                                                                        ip[ip_c] = rs.getString(5+ip_c); 
     910                                                                                                } 
     911                                                                                                 
     912                                                                                                if(!Arrays.asList(ip).contains(clientip)){ 
     913                                                                                                        PreparedStatement psUpdate = conn.prepareStatement("UPDATE ServerHashlist SET ObjectHash=?,hashTime=?, Occurrence=?, IP"+(4+m+1)+"=? WHERE UrlHash=?"); 
     914                                                                                                        psUpdate.setString(1, objectdigest.toString()); 
     915                                                                                                        java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
     916                                                                                                        psUpdate.setTimestamp(2, currentTimestamp); 
     917                                                                                                        psUpdate.setInt(3, m+1); 
     918                                                                                                        psUpdate.setString(4, clientip); 
     919                                                                                                        psUpdate.setString(5, urldigest.toString()); 
     920                                                                                                        psUpdate.executeUpdate(); 
     921                                                                                                         
     922                                                                                                        if(m+1==m_threshold){ 
     923                                                                                                                if(!old_objecthash.equalsIgnoreCase(objectdigest.toString())){ 
     924                                                                                                                        udpthread.sendhashtoall(urldigest.toString()+"\t"+objectdigest.toString()+"\t"+currentTimestamp.toString(), true); 
     925                                                                                                                } 
     926                                                                                                                else{ 
     927                                                                                                                        udpthread.sendhashtoall(urldigest.toString()+"\t"+objectdigest.toString()+"\t"+currentTimestamp.toString(), false); 
     928                                                                                                                } 
     929                                                                                                        } 
     930                                                                                                } 
     931                                                                                        } 
     932                                                                                        else{ 
     933                                                                                                PreparedStatement psUpdate = conn.prepareStatement("UPDATE ServerHashlist SET ObjectHash=?, hashTime=? WHERE UrlHash=?"); 
     934                                                                                                psUpdate.setString(1, objectdigest.toString()); 
     935                                                                                                java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
     936                                                                                                psUpdate.setTimestamp(2, currentTimestamp); 
     937                                                                                                psUpdate.setString(3, urldigest.toString()); 
     938                                                                                                psUpdate.executeUpdate(); 
     939                                                                                                 
     940                                                                                                if(!old_objecthash.equalsIgnoreCase(objectdigest.toString())){ 
     941                                                                                                        udpthread.sendhashtoall(urldigest.toString()+"\t"+objectdigest.toString()+"\t"+currentTimestamp.toString(), true); 
     942                                                                                                } 
    923943                                                                                        } 
    924944                                                                                } else { 
    925                                                                                         PreparedStatement psInsert = conn 
    926                                                                                                         .prepareStatement("insert into ServerHashlist values (?,?,?,?)"); 
    927  
     945                                                                                        String insertstatement = "insert into ServerHashlist values (?,?,?,?"; 
     946                                                                                        for(int psi=0;psi<m_threshold;psi++){ 
     947                                                insertstatement +=",?"; 
     948                                            } 
     949                                                                                        insertstatement +=")"; 
     950                                                                                        PreparedStatement psInsert = conn.prepareStatement(insertstatement); 
     951                                                                                         
    928952                                                                                        psInsert.setString(1, urldigest.toString()); 
    929953                                                                                        psInsert.setString(2, objectdigest.toString()); 
    930954                                                                                        java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
    931955                                                                                        psInsert.setTimestamp(3, currentTimestamp); 
    932                                             psInsert.setInt(4, 0); 
     956                                            psInsert.setInt(4, 1); 
     957                                            psInsert.setString(5, clientip); 
     958                                            for(int psi=1;psi<m_threshold;psi++){ 
     959                                                psInsert.setString(5+psi, ""); 
     960                                            } 
    933961                                                                                        psInsert.executeUpdate(); 
    934                                                                                          
    935                                                                                         udpthread.sendhashtoall(urldigest.toString()+"\t"+objectdigest.toString()); 
     962                                                                                        if(m_threshold==1) 
     963                                                                                                udpthread.sendhashtoall(urldigest.toString()+"\t"+objectdigest.toString()+"\t"+currentTimestamp.toString(), false); 
    936964                                                                                } 
    937965                                                                                rs.close(); 
     
    960988                }  catch (Exception e)  { 
    961989                        if (debugLevel > 0) 
    962                                 debugOut.println("Error getting HTTP data: " + e); 
     990                                debugOut.println("Streamhttp2(b) Error getting HTTP data: " + e); 
    963991                } 
    964992                 
Note: See TracChangeset for help on using the changeset viewer.