Changeset 18


Ignore:
Timestamp:
Aug 13, 2012 5:19:47 PM (5 years ago)
Author:
psaiteja
Message:

This is the code which properly displays poly.edu website. The error in processing correct url (when removing host details) has been validated and corrected. TODO: some lag still exists when using google.com and when browsing some forums - the socket is timing out before displaying the webpage.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • VSNPullServer/src/PullServer.java

    r14 r18  
    372372                        int hostPort = 80; 
    373373                        StringBuffer url = new StringBuffer(""); 
    374                         StringBuffer connectedorigin = new StringBuffer(""); 
     374                        StringBuffer contactedorigin = new StringBuffer(""); 
    375375                         
    376376                        // get the header info (the web browser won't disconnect after 
    377377                        // it's sent a request, so make sure the waitForDisconnect 
    378378                        // parameter is false) 
    379                         request = getHTTPData(clientIn, host, url, connectedorigin, false); 
     379                        request = getHTTPData(clientIn, host, url, contactedorigin, false); 
    380380                        requestLength = Array.getLength(request); 
    381381                         
     
    391391                                hostName = hostName.substring(0, pos); 
    392392                        } 
    393                         System.out.println("gotrequest url:"+url+"\nhost:"+hostName+"\nhostport:"+hostPort); 
     393                        System.out.println("gotrequest url:"+url+"\nhost:"+host+"\nhostport:"+hostPort); 
    394394                        // either forward this request to another proxy server or 
    395395                        // send it straight to the Host 
    396                          
    397                         if(connectedorigin.toString().equalsIgnoreCase("false")){ 
     396                        //System.out.println("contactedorigin:"+contactedorigin.toString()); 
     397                        if(contactedorigin.toString().equalsIgnoreCase("false")){ 
    398398                                MessageDigest sha1 = MessageDigest.getInstance("SHA-1"); 
    399399                                byte [] udigest = sha1.digest((host.toString()+url.toString()).getBytes()); 
     
    404404                        } 
    405405                         
     406                        //System.out.println("computed urlhash:"+urldigest.toString()); 
    406407                        try {            
    407408                                        Statement stmt2 = conn.createStatement(); 
     
    412413                                                                + " ObjectHash:" + rs.getString(2) + " Time:" 
    413414                                                                + rs.getString(3)+ " Count:"+rs.getInt(4)); 
     415                                                System.out.println("redirecting user to origin"); 
    414416                                                int occur = rs.getInt(4); 
    415417                                                Statement stmt3 = conn.createStatement(); 
     
    529531                StringBuffer host = new StringBuffer(""); 
    530532                StringBuffer url = new StringBuffer(""); 
    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) 
     533                StringBuffer contactedorigin = new StringBuffer(""); 
     534                return getHTTPData(in, host, url,contactedorigin, waitForDisconnect); 
     535        } 
     536         
     537         
     538        private byte[] getHTTPData (InputStream in, StringBuffer host, StringBuffer url, StringBuffer contactedorigin, boolean waitForDisconnect) 
    537539        { 
    538540                // get the HTTP data from an InputStream, and return it as 
     
    542544                // information when it's used as a parameter like that 
    543545                ByteArrayOutputStream bs = new ByteArrayOutputStream(); 
    544                 streamHTTPData(in, bs, host, url, connectedorigin, waitForDisconnect); 
     546                streamHTTPData(in, bs, host, url, contactedorigin, waitForDisconnect); 
    545547                return bs.toByteArray(); 
    546548        } 
     
    551553                StringBuffer host = new StringBuffer(""); 
    552554                StringBuffer url = new StringBuffer(""); 
    553                 StringBuffer connectedorigin = new StringBuffer(""); 
    554                 return streamHTTPData(in, out, host, url, connectedorigin, waitForDisconnect); 
     555                StringBuffer contactedorigin = new StringBuffer(""); 
     556                return streamHTTPData(in, out, host, url, contactedorigin, waitForDisconnect); 
    555557        } 
    556558         
    557559        private int streamHTTPData(InputStream in, OutputStream out, 
    558                         StringBuffer host, StringBuffer url, StringBuffer connectedorigin, boolean waitForDisconnect) { 
     560                        StringBuffer host, StringBuffer url, StringBuffer contactedorigin, boolean waitForDisconnect) { 
    559561                // get the HTTP data from an InputStream, and send it to 
    560562                // the designated OutputStream 
     
    590592                                                pre_url.setLength(0); 
    591593                                                pre_url.append(data.substring(0,pos)); 
    592                                                 String suffix = data.substring(pos + 1,data.indexOf(" ", pos + 1)); 
     594                                                //String suffix = data.substring(pos + 1,data.indexOf(" ", pos + 1)); 
     595                                                //url.setLength(0); 
     596                                                //url.append(suffix.trim()); 
    593597                                                url.setLength(0); 
    594                                                 url.append(suffix.trim()); 
     598                                                url.append(data.substring(pos + 1,data.indexOf(" ", pos + 1))); 
    595599                                                post_url.setLength(0); 
    596600                                                post_url.append(data.substring(data.indexOf(" ", pos + 1)+1)); 
     
    619623                                                        .trim()); 
    620624                                 
    621                                 if(data.indexOf("VSNConnectedOrigin:")>=0){ 
    622                                         connectedorigin.setLength(0); 
    623                                         connectedorigin.append(data.substring(data.indexOf("VSNConnectedOrigin:")+19).trim()); 
     625                                if(data.indexOf("VSNContactedOrigin:")>=0){ 
     626                                        contactedorigin.setLength(0); 
     627                                        contactedorigin.append(data.substring(data.indexOf("VSNContactedOrigin:")+19).trim()); 
    624628                                        continue; 
    625629                                } 
     
    627631                        } 
    628632                         
    629                         if(url.indexOf(host.toString())>=0){ 
    630                                 String newurl = url.substring(url.indexOf(host.toString())+host.length()); 
     633//                      if(url.indexOf(host.toString())>=0){ 
     634//                              String newurl = url.substring(url.indexOf(host.toString())+host.length()); 
     635//                              url.setLength(0); 
     636//                              url.append(newurl); 
     637//                      } 
     638                         
     639                        if(url.toString().startsWith(host.toString()) || url.toString().startsWith("http://"+host.toString())){ 
     640                                String newurl = url.substring(url.toString().indexOf(host.toString())+host.length()); 
    631641                                url.setLength(0); 
    632642                                url.append(newurl); 
    633643                        } 
     644                         
    634645                        // add a blank line to terminate the header info 
    635646                        header.append(pre_url+" "+url+" "+post_url+"\r\n"+temp_header+"\r\n"); 
     
    813824                                                                 
    814825                                                                //System.out.println(url.toString()); 
    815                                                                         //System.out.println("Digests: " + urldigest + " : " 
     826                                                                        //System.out.println("calculated digets before database insertion Digests (url:object): " + urldigest + " : " 
    816827                                                                        //              + objectdigest); 
    817828                                                                         
     
    875886                return bs.size(); 
    876887        } 
    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 //      } 
    1089          
    1090          
     888                 
    1091889        private String readLine (InputStream in) 
    1092890        { 
Note: See TracChangeset for help on using the changeset viewer.