Changeset 14


Ignore:
Timestamp:
Aug 9, 2012 8:31:18 PM (5 years ago)
Author:
psaiteja
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • VSNPullServer/src/PullServer.java

    r11 r14  
    372372                        int hostPort = 80; 
    373373                        StringBuffer url = new StringBuffer(""); 
     374                        StringBuffer connectedorigin = new StringBuffer(""); 
    374375                         
    375376                        // get the header info (the web browser won't disconnect after 
    376377                        // it's sent a request, so make sure the waitForDisconnect 
    377378                        // parameter is false) 
    378                         request = getHTTPData(clientIn, host, url, false); 
     379                        request = getHTTPData(clientIn, host, url, connectedorigin, false); 
    379380                        requestLength = Array.getLength(request); 
    380381                         
     
    390391                                hostName = hostName.substring(0, pos); 
    391392                        } 
    392                         System.out.println("url:"+url+"\nhost:"+hostName+"\nhostport:"+hostPort); 
     393                        System.out.println("gotrequest url:"+url+"\nhost:"+hostName+"\nhostport:"+hostPort); 
    393394                        // either forward this request to another proxy server or 
    394395                        // send it straight to the Host 
     396                         
     397                        if(connectedorigin.toString().equalsIgnoreCase("false")){ 
     398                                MessageDigest sha1 = MessageDigest.getInstance("SHA-1"); 
     399                                byte [] udigest = sha1.digest((host.toString()+url.toString()).getBytes()); 
     400                         
     401                        StringBuffer urldigest = new StringBuffer(); 
     402                        for (int i=0;i<udigest.length;i++) { 
     403                                urldigest.append(Integer.toHexString(0xFF & udigest[i])); 
     404                        } 
     405                         
     406                        try {            
     407                                        Statement stmt2 = conn.createStatement(); 
     408                                        ResultSet rs = stmt2.executeQuery("select * from ServerHashlist where UrlHash='"+urldigest+"'"); 
     409                                        int num = 0; 
     410                                        if (rs.next()) { 
     411                                                System.out.println("ENTRY EXISTS -  UrlHash: " + rs.getString(1) 
     412                                                                + " ObjectHash:" + rs.getString(2) + " Time:" 
     413                                                                + rs.getString(3)+ " Count:"+rs.getInt(4)); 
     414                                                int occur = rs.getInt(4); 
     415                                                Statement stmt3 = conn.createStatement(); 
     416                                                int updatecount = stmt3.executeUpdate("UPDATE ServerHashlist SET Occurrence="+(occur+1)+" WHERE UrlHash='"+urldigest+"'"); 
     417                                                 
     418                                                String redirectmsg ="VSNRedirect:true\r\nVSNurldigest:"+rs.getString(1)+"\r\nVSNobjectdigest:"+rs.getString(2)+"\r\ncontent-length:0\r\n\r\n"; 
     419                                                clientOut.write(redirectmsg.getBytes()); 
     420                                                clientOut.flush(); 
     421                                                 
     422                                                clientOut.close(); 
     423                                                clientIn.close(); 
     424                                                pSocket.close(); 
     425                                                return; 
     426                                        } 
     427                                        rs.close(); 
     428                                } catch (Exception e) { 
     429                                        e.printStackTrace(); 
     430                                } 
     431                        } 
     432                         
     433                 
    395434                        try 
    396435                        { 
    397  
    398436                                server = new Socket(hostName, hostPort); 
    399  
    400437                        }  catch (Exception e)  { 
    401438                                // tell the client there was an error 
     
    431468                                        //responseLength = Array.getLength(response); 
    432469                                //}  else  { 
    433                                         responseLength = streamHTTPData2(serverIn, clientOut,new StringBuffer(""),url, true); 
     470                                        responseLength = streamHTTPData2(serverIn, clientOut,host,url, true); 
    434471                                } 
    435472                                catch (SocketTimeoutException ste) 
     
    468505                                debugOut.flush(); 
    469506                        } 
    470 //                      if (debugLevel > 1) 
    471 //                      { 
    472 //                              debugOut.println("REQUEST:\n" + (new String(request))); 
    473 //                              debugOut.println("RESPONSE:\n" + (new String(response))); 
    474 //                              debugOut.flush(); 
    475 //                      } 
    476507                         
    477508                        // close all the client streams so we can listen again 
     
    498529                StringBuffer host = new StringBuffer(""); 
    499530                StringBuffer url = new StringBuffer(""); 
    500                 return getHTTPData(in, host, url, waitForDisconnect); 
    501         } 
    502          
    503          
    504         private byte[] getHTTPData (InputStream in, StringBuffer host, StringBuffer url, boolean waitForDisconnect) 
     531                StringBuffer connectedorigin = new StringBuffer(""); 
     532                return getHTTPData(in, host, url,connectedorigin, waitForDisconnect); 
     533        } 
     534         
     535         
     536        private byte[] getHTTPData (InputStream in, StringBuffer host, StringBuffer url, StringBuffer connectedorigin, boolean waitForDisconnect) 
    505537        { 
    506538                // get the HTTP data from an InputStream, and return it as 
     
    510542                // information when it's used as a parameter like that 
    511543                ByteArrayOutputStream bs = new ByteArrayOutputStream(); 
    512                 streamHTTPData(in, bs, host, url, waitForDisconnect); 
     544                streamHTTPData(in, bs, host, url, connectedorigin, waitForDisconnect); 
    513545                return bs.toByteArray(); 
    514546        } 
     
    519551                StringBuffer host = new StringBuffer(""); 
    520552                StringBuffer url = new StringBuffer(""); 
    521                 return streamHTTPData(in, out, host, url, waitForDisconnect); 
     553                StringBuffer connectedorigin = new StringBuffer(""); 
     554                return streamHTTPData(in, out, host, url, connectedorigin, waitForDisconnect); 
    522555        } 
    523556         
    524557        private int streamHTTPData(InputStream in, OutputStream out, 
    525                         StringBuffer host, StringBuffer url, boolean waitForDisconnect) { 
     558                        StringBuffer host, StringBuffer url, StringBuffer connectedorigin, boolean waitForDisconnect) { 
    526559                // get the HTTP data from an InputStream, and send it to 
    527560                // the designated OutputStream 
     
    571604                                if (data.length() == 0) 
    572605                                        break; 
    573                                 temp_header.append(data + "\r\n"); 
     606                                 
    574607 
    575608                                // check for the Host header 
     
    585618                                        contentLength = Integer.parseInt(data.substring(pos + 15) 
    586619                                                        .trim()); 
    587                         } 
    588  
    589                         String newurl = url.substring(url.indexOf(host.toString())+host.length()); 
    590                         url.setLength(0); 
    591                         url.append(newurl); 
     620                                 
     621                                if(data.indexOf("VSNConnectedOrigin:")>=0){ 
     622                                        connectedorigin.setLength(0); 
     623                                        connectedorigin.append(data.substring(data.indexOf("VSNConnectedOrigin:")+19).trim()); 
     624                                        continue; 
     625                                } 
     626                                temp_header.append(data + "\r\n"); 
     627                        } 
     628                         
     629                        if(url.indexOf(host.toString())>=0){ 
     630                                String newurl = url.substring(url.indexOf(host.toString())+host.length()); 
     631                                url.setLength(0); 
     632                                url.append(newurl); 
     633                        } 
    592634                        // add a blank line to terminate the header info 
    593635                        header.append(pre_url+" "+url+" "+post_url+"\r\n"+temp_header+"\r\n"); 
    594  
     636                         
    595637                        // convert the header to a byte array, and write it to our stream 
    596638                        out.write(header.toString().getBytes(), 0, header.length()); 
     
    621663                                        } 
    622664                                } catch (Exception e) { 
    623                                         String errMsg = "Error getting HTTP body: " + e; 
     665                                        String errMsg = "request Error getting HTTP body: " + e; 
     666                                        e.printStackTrace(); 
    624667                                        if (debugLevel > 0) 
    625668                                                debugOut.println(errMsg); 
     
    629672                } catch (Exception e) { 
    630673                        if (debugLevel > 0) 
    631                                 debugOut.println("Error getting HTTP data: " + e); 
     674                                debugOut.println("Streamhttp1 Error getting HTTP data: " + e); 
    632675                } 
    633676 
     
    674717                                        } 
    675718                                } 
    676 //                              else{ 
    677 //                                      if((pos >= 0) && (data.indexOf(" ", pos+1) >= 0)){ 
    678 //                                              String suffix = data.substring(pos+1, data.indexOf(" ", pos+1)); 
    679 //                                              url.setLength(0); 
    680 //                                              url.append(suffix.trim()); 
    681 //                                      } 
    682 //                              } 
    683719                        } 
    684720                         
     
    715751                        // convert the header to a byte array, and write it to our stream 
    716752                        out.write(header.toString().getBytes(), 0, header.length()); 
     753                        out.flush(); 
    717754                         
    718755                        // if the header indicated that this was not a 200 response, 
     
    725762                        } 
    726763             
    727                         if(url.toString().contains("youtube")) 
    728                                 System.out.println("YOUTUBE:"+contentType); 
    729764                        // get the body, if any; we try to use the Content-Length header to 
    730765                        // determine how much data we're supposed to be getting, because  
     
    736771                        if ((contentLength > 0) || (waitForDisconnect)) 
    737772                        { 
    738                                 System.out.println("Trying to get content body"); 
     773                                //System.out.println("Trying to get content body"); 
    739774                                try { 
    740775                                        byte[] buf = new byte[4096]; 
     
    751786                                                        else{ 
    752787                                                                bs.write(buf, 0, bytesIn); 
     788                                                                out.write(buf, 0, bytesIn); 
     789                                                                out.flush(); 
    753790                                                                 
    754791                                                                if(byteCount>=contentLength){ 
     
    759796                                                                        //sha1.update(response, 0, response.length); 
    760797                                                                        byte [] obdigest = sha1.digest(response); 
    761                                                                         System.out.println("digest size = "+sha1.getDigestLength()+" ondigest size = "+obdigest.length); 
    762798                                                                        sha1.reset(); 
    763799                                                                        //sha1.update(url_string.getBytes(), 0, 
     
    783819                                                                                Statement stmt2 = conn.createStatement(); 
    784820                                                                                ResultSet rs = stmt2.executeQuery("select * from ServerHashlist where UrlHash='"+urldigest+"'"); 
    785                                                                                 int num = 0; 
    786821                                                                                if (rs.next()) { 
    787                                                                                         System.out.println("ENTRY EXISTS -  UrlHash: " + rs.getString(1) 
    788                                                                                                         + " ObjectHash:" + rs.getString(2) + " Time:" 
    789                                                                                                         + rs.getString(3)+ " Count:"+rs.getInt(4)); 
     822                                                                                        //System.out.println("ENTRY EXISTS -  UrlHash: " + rs.getString(1) 
     823                                                                                        //              + " ObjectHash:" + rs.getString(2) + " Time:" 
     824                                                                                        //              + rs.getString(3)+ " Count:"+rs.getInt(4)); 
    790825                                                                                        int occur = rs.getInt(4); 
    791                                                                                         Statement stmt3 = conn.createStatement(); 
    792                                                                                         int updatecount = stmt3.executeUpdate("UPDATE ServerHashlist SET Occurrence="+(occur+1)+" WHERE UrlHash='"+urldigest+"'"); 
    793                                                                                         System.out.println("Updated "+updatecount+" records"); 
     826                                                                                                                                                                                 
     827                                                                                        PreparedStatement psUpdate = conn.prepareStatement("UPDATE ServerHashlist SET Occurrence=?, ObjectHash=?, hashTime=? WHERE UrlHash=?"); 
     828                                                                                        psUpdate.setInt(1, (occur+1)); 
     829                                                                                        psUpdate.setString(2, objectdigest.toString()); 
     830                                                                                        java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
     831                                                                                        psUpdate.setTimestamp(3, currentTimestamp); 
     832                                                                                        psUpdate.setString(4, urldigest.toString()); 
     833                                                                                        psUpdate.executeUpdate(); 
    794834                                                                                         
    795835                                                                                } else { 
     
    805845                                                                                } 
    806846                                                                                rs.close(); 
    807  
    808                                                                                 /*Statement stmt3 = conn.createStatement(); 
    809                                                                                 rs = stmt3.executeQuery("select * from ClientHashlist"); 
    810                                                                                 num = 0; 
    811                                                                                 while (rs.next()) { 
    812                                                                                         System.out.println(++num + ": UrlHash: " + rs.getString(1) 
    813                                                                                                         + " ObjectHash:" + rs.getString(2) + " Time:" 
    814                                                                                                         + rs.getString(3)); 
    815                                                                                 } 
    816                                                                                 rs.close();*/ 
    817847                                                                        } catch (Exception e) { 
    818848                                                                                e.printStackTrace(); 
    819                                                                         } 
    820  
    821                                                                  
    822                                                                 out.write(bs.toByteArray(), 0, bs.size()); 
    823                                                                         out.flush();                             
     849                                                                        }                        
    824850                                                                } 
    825851                                                        } 
     
    830856                                                        out.write(buf, 0, bytesIn); 
    831857                                                        out.flush(); 
    832                                                 } 
    833                                                  
    834                                                  
     858                                                }        
    835859                                        } 
    836860                                }  catch (Exception e)  { 
    837                                         String errMsg = "Error getting HTTP body: " + e; 
     861                                        String errMsg = "Streamhttp2 Error getting HTTP body: " + e; 
     862                                        e.printStackTrace(); 
    838863                                        if (debugLevel > 0) 
    839864                                                debugOut.println(errMsg); 
     
    850875                return bs.size(); 
    851876        } 
     877         
     878//      private int streamHTTPData3 (InputStream in, OutputStream out,  
     879//                      StringBuffer host, StringBuffer url, boolean waitForDisconnect) 
     880//      { 
     881//              // get the HTTP data from an InputStream, and send it to 
     882//              // the designated OutputStream 
     883//              StringBuffer header = new StringBuffer(""); 
     884//              String data = ""; 
     885//              int responseCode = 200; 
     886//              int contentLength = 0; 
     887//              String contentType = ""; 
     888//              int pos = -1; 
     889//              int byteCount = 0; 
     890//              ByteArrayOutputStream bs = new ByteArrayOutputStream(); 
     891// 
     892//              try 
     893//              { 
     894//                      // get the first line of the header, so we know the response code 
     895//                      data = readLine(in); 
     896//                      if (data != null) 
     897//                      { 
     898//                              header.append(data + "\r\n"); 
     899//                              pos = data.indexOf(" "); 
     900//                              if ((data.toLowerCase().startsWith("http")) && (pos >= 0) && (data.indexOf(" ", pos+1) >= 0)) 
     901//                              { 
     902//                                      String rcString = data.substring(pos+1, data.indexOf(" ", pos+1)); 
     903//                                      try 
     904//                                      { 
     905//                                              responseCode = Integer.parseInt(rcString); 
     906//                                      }  catch (Exception e)  { 
     907//                                              if (debugLevel > 0) 
     908//                                                      debugOut.println("Error parsing response code " + rcString); 
     909//                                      } 
     910//                              } 
     911//                      } 
     912// 
     913//                      // get the rest of the header info 
     914//                      while ((data = readLine(in)) != null) 
     915//                      { 
     916//                              // the header ends at the first blank line 
     917//                              if (data.length() == 0) 
     918//                                      break; 
     919//                              header.append(data + "\r\n"); 
     920// 
     921//                              // check for the Host header 
     922//                              pos = data.toLowerCase().indexOf("host:"); 
     923//                              if (pos >= 0) 
     924//                              { 
     925//                                      host.setLength(0); 
     926//                                      host.append(data.substring(pos + 5).trim()); 
     927//                              } 
     928// 
     929//                              // check for the Content-Length header 
     930//                              pos = data.toLowerCase().indexOf("content-length:"); 
     931//                              if (pos >= 0) 
     932//                                      contentLength = Integer.parseInt(data.substring(pos + 15).trim()); 
     933// 
     934//                              // check for the Content-Type header 
     935//                              pos = data.toLowerCase().indexOf("content-type:"); 
     936//                              if (pos >= 0) 
     937//                                      contentType = data.substring(pos + 13).trim(); 
     938// 
     939//                               
     940//                      } 
     941// 
     942//                      // add a blank line to terminate the header info 
     943//                      header.append("\r\n"); 
     944// 
     945//                      //// convert the header to a byte array, and write it to our stream 
     946//                      //out.write(header.toString().getBytes(), 0, header.length()); 
     947// 
     948//                      // if the header indicated that this was not a 200 response, 
     949//                      // just return what we've got if there is no Content-Length, 
     950//                      // because we may not be getting anything else 
     951//                      if ((responseCode != 200) && (contentLength == 0)) 
     952//                      { 
     953//                              // convert the header to a byte array, and write it to our stream 
     954//                              out.write(header.toString().getBytes(), 0, header.length()); 
     955//                              out.flush(); 
     956//                              return 0; 
     957//                      } 
     958// 
     959// 
     960//                      // get the body, if any; we try to use the Content-Length header to 
     961//                      // determine how much data we're supposed to be getting, because  
     962//                      // sometimes the client/server won't disconnect after sending us 
     963//                      // information... 
     964//                      if (contentLength > 0) 
     965//                              waitForDisconnect = false; 
     966// 
     967//                      boolean wroteheader = false; 
     968// 
     969//                      if ((contentLength > 0) || (waitForDisconnect)) 
     970//                      { 
     971//                              try { 
     972//                                      byte[] buf = new byte[4096]; 
     973//                                      int bytesIn = 0; 
     974//                                      while ( ((byteCount < contentLength) || (waitForDisconnect))  
     975//                                                      && ((bytesIn = in.read(buf)) >= 0) ) 
     976//                                      { 
     977//                                              byteCount += bytesIn; 
     978//                                              if(contentLength > 0){ 
     979//                                                      if(contentType.toLowerCase().contains("video")){ 
     980//                                                              if(!wroteheader){ 
     981//                                                                      // convert the header to a byte array, and write it to our stream 
     982//                                                                      out.write(header.toString().getBytes(), 0, header.length()); 
     983//                                                                      wroteheader = true; 
     984//                                                              } 
     985//                                                              out.write(buf, 0, bytesIn); 
     986//                                                              out.flush(); 
     987//                                                      } 
     988//                                                      else{ 
     989//                                                              bs.write(buf, 0, bytesIn); 
     990// 
     991//                                                              if(!wroteheader){ 
     992//                                                                      // convert the header to a byte array, and write it to our stream 
     993//                                                                      out.write(header.toString().getBytes(), 0, header.length()); 
     994//                                                                      wroteheader = true; 
     995//                                                              } 
     996//                                                              out.write(buf, 0, bytesIn); 
     997//                                                              out.flush(); 
     998//                                                               
     999// 
     1000//                                                              if(byteCount>=contentLength){ 
     1001//                                                                      byte [] response = bs.toByteArray(); 
     1002// 
     1003//                                                                      MessageDigest sha1 = MessageDigest.getInstance("SHA-1"); 
     1004// 
     1005//                                                                      //sha1.update(response, 0, response.length); 
     1006//                                                                      byte [] obdigest = sha1.digest(response); 
     1007//                                                                      System.out.println("digest size = "+sha1.getDigestLength()+" ondigest size = "+obdigest.length); 
     1008//                                                                      sha1.reset(); 
     1009//                                                                      //sha1.update(url_string.getBytes(), 0, 
     1010//                                                                      //              url_string.length()); 
     1011//                                                                      byte [] udigest = sha1.digest((host.toString()+url.toString()).getBytes()); 
     1012// 
     1013//                                                                      //convert the byte to hex format method 2 
     1014//                                                                      StringBuffer objectdigest = new StringBuffer(); 
     1015//                                                                      for (int i=0;i<obdigest.length;i++) { 
     1016//                                                                              objectdigest.append(Integer.toHexString(0xFF & obdigest[i])); 
     1017//                                                                      } 
     1018// 
     1019//                                                                      StringBuffer urldigest = new StringBuffer(); 
     1020//                                                                      for (int i=0;i<udigest.length;i++) { 
     1021//                                                                              urldigest.append(Integer.toHexString(0xFF & udigest[i])); 
     1022//                                                                      } 
     1023// 
     1024//                                                                      //System.out.println(url.toString()); 
     1025//                                                                      //System.out.println("Digests: " + urldigest + " : " 
     1026//                                                                      //              + objectdigest); 
     1027// 
     1028//                                                                      try {            
     1029//                                                                              Statement stmt2 = conn.createStatement();                                                                                
     1030//                                                                              ResultSet rs = stmt2.executeQuery("select * from ClientHashlist where UrlHash='"+urldigest+"'"); 
     1031//                                                                              if (rs.next()) { 
     1032//                                                                                      System.out.println("ENTRY EXISTS -  UrlHash: " + rs.getString(1) 
     1033//                                                                                                      + " ObjectHash:" + rs.getString(2) + " Time:" 
     1034//                                                                                                      + rs.getString(3)); 
     1035//                                                                                       
     1036//                                                                                      PreparedStatement psUpdate = conn.prepareStatement("UPDATE ClientHashlist SET ObjectHash=?, hashTime=? WHERE UrlHash=?"); 
     1037//                                                                                      psUpdate.setString(1, objectdigest.toString()); 
     1038//                                                                                      java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
     1039//                                                                                      psUpdate.setTimestamp(2, currentTimestamp); 
     1040//                                                                                      psUpdate.setString(3, urldigest.toString()); 
     1041//                                                                                      psUpdate.executeUpdate(); 
     1042//                                                                              } else { 
     1043//                                                                                      PreparedStatement psInsert = conn 
     1044//                                                                                                      .prepareStatement("insert into ClientHashlist values (?,?,?)"); 
     1045// 
     1046//                                                                                      psInsert.setString(1, urldigest.toString()); 
     1047//                                                                                      psInsert.setString(2, objectdigest.toString()); 
     1048//                                                                                      java.sql.Timestamp currentTimestamp = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); 
     1049//                                                                                      psInsert.setTimestamp(3, currentTimestamp); 
     1050//                                                                                      psInsert.executeUpdate();                
     1051//                                                                              } 
     1052//                                                                              rs.close(); 
     1053//                                                                      } catch (Exception e) { 
     1054//                                                                              e.printStackTrace(); 
     1055//                                                                      }                                
     1056//                                                              } 
     1057//                                                      } 
     1058// 
     1059//                                              } 
     1060//                                              else{ 
     1061//                                                      if(!wroteheader){ 
     1062//                                                              // convert the header to a byte array, and write it to our stream 
     1063//                                                              out.write(header.toString().getBytes(), 0, header.length()); 
     1064//                                                              wroteheader = true; 
     1065//                                                      } 
     1066//                                                      //bs.write(buf, 0, bytesIn); 
     1067//                                                      out.write(buf, 0, bytesIn); 
     1068//                                                      out.flush(); 
     1069//                                              } 
     1070// 
     1071// 
     1072//                                      } 
     1073//                              }  catch (Exception e)  { 
     1074//                                      String errMsg = "Error getting HTTP body: " + e; 
     1075//                                      if (debugLevel > 0) 
     1076//                                              debugOut.println(errMsg); 
     1077//                                      //bs.write(errMsg.getBytes(), 0, errMsg.length()); 
     1078//                              } 
     1079//                      } 
     1080//              }  catch (Exception e)  { 
     1081//                      if (debugLevel > 0) 
     1082//                              debugOut.println("Error getting HTTP data: " + e); 
     1083//              } 
     1084// 
     1085//              //flush the OutputStream and return 
     1086//              try  {  out.flush();  }  catch (Exception e)  {} 
     1087//              return bs.size(); 
     1088//      } 
    8521089         
    8531090         
Note: See TracChangeset for help on using the changeset viewer.