X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2FHTTP.java;h=fed6e6e852931746412e214e66e1719884663d6c;hb=6b010667b40641fdb82925e56466f847f721ef1f;hp=a257878cf0855da4b8c89635e340a42c8d958243;hpb=b32cea3f3e272ab00899d134d75a8bd7bcf6c8c0;p=org.ibex.core.git

diff --git a/src/org/xwt/HTTP.java b/src/org/xwt/HTTP.java
index a257878..fed6e6e 100644
--- a/src/org/xwt/HTTP.java
+++ b/src/org/xwt/HTTP.java
@@ -1,4 +1,4 @@
-// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
+// Copyright 2003 Adam Megacz, see the COPYING file for licensing [GPL]
 package org.xwt;
 
 import java.net.*;
@@ -60,6 +60,9 @@ public class HTTP {
     /** true iff we are allowed to skip the resolve check (only allowed when we're downloading the PAC script) */
     boolean skipResolveCheck = false;
 
+    /** true iff we're using a proxy */
+    boolean proxied = false;
+
 
     // Public Methods ////////////////////////////////////////////////////////////////////////////////////////
 
@@ -70,16 +73,16 @@ public class HTTP {
     }
 
     /** Performs an HTTP GET request */
-    public HTTPInputStream GET() throws IOException { return makeRequest(null, null); }
+    public InputStream GET() throws IOException { return makeRequest(null, null); }
 
     /** Performs an HTTP POST request; content is appended to the headers (so it should include a blank line to delimit the beginning of the body) */
-    public HTTPInputStream POST(String contentType, String content) throws IOException { return makeRequest(contentType, content); }
+    public InputStream POST(String contentType, String content) throws IOException { return makeRequest(contentType, content); }
 
     /**
      *  This method isn't synchronized; however, only one thread can be in the inner synchronized block at a time, and the rest of
      *  the method is protected by in-order one-at-a-time semaphore lock-steps
      */
-    private HTTPInputStream makeRequest(String contentType, String content) throws IOException {
+    private InputStream makeRequest(String contentType, String content) throws IOException {
 
         // Step 1: send the request and establish a semaphore to stop any requests that pipeline after us
         Semaphore blockOn = null;
@@ -132,7 +135,8 @@ public class HTTP {
                 if (h.get("HTTP").equals("1.0") && h.get("content-length") == null)
                     throw new HTTPException("XWT does not support HTTP/1.0 servers which fail to return the Content-Length header");
                 int cl = h.get("content-length") == null ? -1 : Integer.parseInt(h.get("content-length").toString());
-                HTTPInputStream ret = new HTTPInputStream(in, cl, releaseMe);
+                InputStream ret = new HTTPInputStream(in, cl, releaseMe);
+                if ("gzip".equals(h.get("content-encoding"))) ret = new java.util.zip.GZIPInputStream(ret);
                 doRelease = false;
                 return ret;
                 
@@ -150,14 +154,11 @@ public class HTTP {
     // Safeguarded DNS Resolver ///////////////////////////////////////////////////////////////////////////
 
     /**
-     *  resolves the hostname and returns it as a string in the form "x.y.z.w", except for the special case "xmlrpc.xwt.org".
+     *  resolves the hostname and returns it as a string in the form "x.y.z.w"
      *  @throws HTTPException if the host falls within a firewalled netblock
      */
     private void resolveAndCheckIfFirewalled(String host) throws HTTPException {
 
-        // special case
-        if (host.equals("xmlrpc.xwt.org")) return;
-
         // cached
         if (resolvedHosts.get(host) != null) return;
 
@@ -175,7 +176,6 @@ public class HTTP {
             return;
         } catch (UnknownHostException uhe) { }
 
-        // resolve using xmlrpc.xwt.org
         if (Platform.detectProxy() == null) throw new HTTPException("could not resolve hostname \"" + host + "\" and no proxy configured");
         if (Log.on) Log.log(this, "  could not resolve host " + host + "; using xmlrpc.xwt.org to ensure security");
         try {
@@ -358,6 +358,7 @@ public class HTTP {
         if (sock == null && pi != null && ssl && pi.httpsProxyHost != null) sock = attemptHttpProxy(pi.httpsProxyHost, pi.httpsProxyPort);
         if (sock == null && pi != null && pi.httpProxyHost != null) sock = attemptHttpProxy(pi.httpProxyHost, pi.httpProxyPort);
         if (sock == null && pi != null && pi.socksProxyHost != null) sock = attemptSocksProxy(pi.socksProxyHost, pi.socksProxyPort);
+        proxied = sock != null;
         if (sock == null) sock = attemptDirect();
         if (sock == null) throw new HTTPException("unable to contact host " + host);
         if (in == null) in = new BufferedInputStream(sock.getInputStream());
@@ -368,9 +369,9 @@ public class HTTP {
         PrintWriter pw = new PrintWriter(new OutputStreamWriter(sock.getOutputStream()));
         if (content != null) {
             pw.print("POST " + path + " HTTP/1.1\r\n");
-        int contentLength = content.substring(0, 2).equals("\r\n") ?
-        content.length() - 2 :
-        (content.length() - content.indexOf("\r\n\r\n") - 4);
+            int contentLength = content.substring(0, 2).equals("\r\n") ?
+                content.length() - 2 :
+                (content.length() - content.indexOf("\r\n\r\n") - 4);
             pw.print("Content-Length: " + contentLength + "\r\n");
             if (contentType != null) pw.print("Content-Type: " + contentType + "\r\n");
         } else {
@@ -378,7 +379,9 @@ public class HTTP {
         }
         
         pw.print("User-Agent: XWT\r\n");
+        pw.print("Accept-encoding: gzip\r\n");
         pw.print("Host: " + (host + (port == 80 ? "" : (":" + port))) + "\r\n");
+        if (proxied) pw.print("X-RequestOrigin: " + Main.originHost + "\r\n");
 
         if (Proxy.Authorization.authorization != null) pw.print("Proxy-Authorization: " + Proxy.Authorization.authorization2 + "\r\n");
         if (authCache.get(originalUrl) != null) pw.print("Authorization: " + authCache.get(originalUrl) + "\r\n");
@@ -477,7 +480,7 @@ public class HTTP {
         private int contentLength = 0;
         public int getContentLength() { return contentLength; }
 
-        HTTPInputStream(InputStream in, int length, Semaphore releaseMe) {
+        HTTPInputStream(InputStream in, int length, Semaphore releaseMe) throws IOException {
             super(in);
             this.releaseMe = releaseMe;
             this.contentLength = length;
@@ -507,7 +510,7 @@ public class HTTP {
                 int i = super.read();
                 if (i == -1) throw new HTTPException("encountered end of stream while reading chunk length");
 
-                // FIXME: handle chunking extensions
+                // FEATURE: handle chunking extensions
                 if (i == '\r') {
                     super.read();    // LF
                     break;
@@ -515,7 +518,7 @@ public class HTTP {
                     chunkLen += (char)i;
                 }
             }
-            length = Integer.parseInt(chunkLen, 16);
+            length = Integer.parseInt(chunkLen.trim(), 16);
             if (length == 0) chunkedDone = true;
         }
 
@@ -633,4 +636,339 @@ public class HTTP {
         return ret;
     }
 
+
+    // Proxy ///////////////////////////////////////////////////////////
+
+    /** encapsulates most of the proxy logic; some is shared in HTTP.java */
+    public static class Proxy {
+        
+        public Proxy() { }
+        
+        /** the HTTP Proxy host to use */
+        public String httpProxyHost = null;
+        
+        /** the HTTP Proxy port to use */
+        public int httpProxyPort = -1;
+        
+        /** if a seperate proxy should be used for HTTPS, this is the hostname; otherwise, httpProxyHost is used */
+        public String httpsProxyHost = null;
+    
+        /** if a seperate proxy should be used for HTTPS, this is the port */
+        public int httpsProxyPort = -1;
+    
+        /** the SOCKS Proxy Host to use */
+        public String socksProxyHost = null;
+    
+        /** the SOCKS Proxy Port to use */
+        public int socksProxyPort = -1;
+    
+        /** hosts to be excluded from proxy use; wildcards permitted */
+        public String[] excluded = null;
+    
+        /** the PAC script */
+        public JS.Callable proxyAutoConfigFunction = null;
+    
+        public static Proxy detectProxyViaManual() {
+            Proxy ret = new Proxy();
+        
+            ret.httpProxyHost = Platform.getEnv("http_proxy");
+            if (ret.httpProxyHost != null) {
+                if (ret.httpProxyHost.startsWith("http://")) ret.httpProxyHost = ret.httpProxyHost.substring(7);
+                if (ret.httpProxyHost.endsWith("/")) ret.httpProxyHost = ret.httpProxyHost.substring(0, ret.httpProxyHost.length() - 1);
+                if (ret.httpProxyHost.indexOf(':') != -1) {
+                    ret.httpProxyPort = Integer.parseInt(ret.httpProxyHost.substring(ret.httpProxyHost.indexOf(':') + 1));
+                    ret.httpProxyHost = ret.httpProxyHost.substring(0, ret.httpProxyHost.indexOf(':'));
+                } else {
+                    ret.httpProxyPort = 80;
+                }
+            }
+        
+            ret.httpsProxyHost = Platform.getEnv("https_proxy");
+            if (ret.httpsProxyHost != null) {
+                if (ret.httpsProxyHost.startsWith("https://")) ret.httpsProxyHost = ret.httpsProxyHost.substring(7);
+                if (ret.httpsProxyHost.endsWith("/")) ret.httpsProxyHost = ret.httpsProxyHost.substring(0, ret.httpsProxyHost.length() - 1);
+                if (ret.httpsProxyHost.indexOf(':') != -1) {
+                    ret.httpsProxyPort = Integer.parseInt(ret.httpsProxyHost.substring(ret.httpsProxyHost.indexOf(':') + 1));
+                    ret.httpsProxyHost = ret.httpsProxyHost.substring(0, ret.httpsProxyHost.indexOf(':'));
+                } else {
+                    ret.httpsProxyPort = 80;
+                }
+            }
+        
+            ret.socksProxyHost = Platform.getEnv("socks_proxy");
+            if (ret.socksProxyHost != null) {
+                if (ret.socksProxyHost.startsWith("socks://")) ret.socksProxyHost = ret.socksProxyHost.substring(7);
+                if (ret.socksProxyHost.endsWith("/")) ret.socksProxyHost = ret.socksProxyHost.substring(0, ret.socksProxyHost.length() - 1);
+                if (ret.socksProxyHost.indexOf(':') != -1) {
+                    ret.socksProxyPort = Integer.parseInt(ret.socksProxyHost.substring(ret.socksProxyHost.indexOf(':') + 1));
+                    ret.socksProxyHost = ret.socksProxyHost.substring(0, ret.socksProxyHost.indexOf(':'));
+                } else {
+                    ret.socksProxyPort = 80;
+                }
+            }
+        
+            String noproxy = Platform.getEnv("no_proxy");
+            if (noproxy != null) {
+                StringTokenizer st = new StringTokenizer(noproxy, ",");
+                ret.excluded = new String[st.countTokens()];
+                for(int i=0; st.hasMoreTokens(); i++) ret.excluded[i] = st.nextToken();
+            }
+        
+            if (ret.httpProxyHost == null && ret.socksProxyHost == null) return null;
+            return ret;
+        }
+    
+        public static JS.Scope proxyAutoConfigRootScope = new ProxyAutoConfigRootScope();
+        public static JS.Callable getProxyAutoConfigFunction(String url) {
+            try { 
+                BufferedReader br = new BufferedReader(new InputStreamReader(new HTTP(url, true).GET()));
+                String s = null;
+                String script = "";
+                while((s = br.readLine()) != null) script += s + "\n";
+                if (Log.on) Log.log(Proxy.class, "successfully retrieved WPAD PAC:");
+                if (Log.on) Log.log(Proxy.class, script);
+            
+                // MS CARP hack
+                Vector carpHosts = new Vector();
+                for(int i=0; i<script.length(); i++)
+                    if (script.regionMatches(i, "new Node(", 0, 9)) {
+                        String host = script.substring(i + 10, script.indexOf('\"', i + 11));
+                        if (Log.on) Log.log(Proxy.class, "Detected MS Proxy Server CARP Script, Host=" + host);
+                        carpHosts.addElement(host);
+                    }
+                if (carpHosts.size() > 0) {
+                    script = "function FindProxyForURL(url, host) {\nreturn \"";
+                    for(int i=0; i<carpHosts.size(); i++)
+                        script += "PROXY " + carpHosts.elementAt(i) + "; ";
+                    script += "\";\n}";
+                    if (Log.on) Log.log(Proxy.class, "DeCARPed PAC script:");
+                    if (Log.on) Log.log(Proxy.class, script);
+                }
+
+                JS.CompiledFunction scr = JS.parse("PAC script at " + url, 0, new StringReader(script));
+                scr.call(new JS.Array(), proxyAutoConfigRootScope);
+                return (JS.Callable)proxyAutoConfigRootScope.get("FindProxyForURL");
+            } catch (Exception e) {
+                if (Log.on) {
+                    Log.log(Platform.class, "WPAD detection failed due to:");
+                    if (e instanceof JS.Exn) {
+                        try {
+                            org.xwt.js.JS.Array arr = new org.xwt.js.JS.Array();
+                            arr.addElement(((JS.Exn)e).getObject());
+                        } catch (Exception e2) {
+                            Log.log(Platform.class, e);
+                        }
+                    }
+                    else Log.log(Platform.class, e);
+                }
+                return null;
+            }
+        }
+
+
+        // Authorization ///////////////////////////////////////////////////////////////////////////////////
+
+        public static class Authorization {
+
+            static public String authorization = null;
+            static public String authorization2 = null;
+            static public Semaphore waitingForUser = new Semaphore();
+
+            public static synchronized void getPassword(final String realm, final String style, final String proxyIP, String oldAuth) {
+
+                // this handles cases where multiple threads hit the proxy auth at the same time -- all but one will block on the
+                // synchronized keyword. If 'authorization' changed while the thread was blocked, it means that the user entered
+                // a password, so we should reattempt authorization.
+
+                if (authorization != oldAuth) return;
+                if (Log.on) Log.log(Authorization.class, "displaying proxy authorization dialog");
+                Message.Q.add(new Message() {
+                        public void perform() {
+                            Box b = new Box();
+                            Template t = Template.getTemplate((Res)Main.builtin.get("org/xwt/builtin/proxy_authorization.xwt"));
+                            t.apply(b, null, null);
+                            b.put("realm", realm);
+                            b.put("proxyIP", proxyIP);
+                        }
+                    });
+
+                waitingForUser.block();
+                if (Log.on) Log.log(Authorization.class, "got proxy authorization info; re-attempting connection");
+            
+            }
+        }
+
+
+        // ProxyAutoConfigRootScope ////////////////////////////////////////////////////////////////////
+
+        public static class ProxyAutoConfigRootScope extends JS.GlobalScope {
+
+            public ProxyAutoConfigRootScope() { super(null); }
+        
+            public Object get(Object name) {
+                if (name.equals("isPlainHostName")) return isPlainHostName;
+                else if (name.equals("dnsDomainIs")) return dnsDomainIs;
+                else if (name.equals("localHostOrDomainIs")) return localHostOrDomainIs;
+                else if (name.equals("isResolvable")) return isResolvable;
+                else if (name.equals("isInNet")) return isInNet;
+                else if (name.equals("dnsResolve")) return dnsResolve;
+                else if (name.equals("myIpAddress")) return myIpAddress;
+                else if (name.equals("dnsDomainLevels")) return dnsDomainLevels;
+                else if (name.equals("shExpMatch")) return shExpMatch;
+                else if (name.equals("weekdayRange")) return weekdayRange;
+                else if (name.equals("dateRange")) return dateRange;
+                else if (name.equals("timeRange")) return timeRange;
+                else if (name.equals("ProxyConfig")) return ProxyConfig;
+                else return super.get(name);
+            }
+        
+            private static final JS.Obj proxyConfigBindings = new JS.Obj();
+            private static final JS.Obj ProxyConfig = new JS.Obj() {
+                    public Object get(Object name) {
+                        if (name.equals("bindings")) return proxyConfigBindings;
+                        return null;
+                    }
+                };
+        
+            private static final JS.Callable isPlainHostName = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        return (args.elementAt(0).toString().indexOf('.') == -1) ? Boolean.TRUE : Boolean.FALSE;
+                    }
+                };
+        
+            private static final JS.Callable dnsDomainIs = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        return (args.elementAt(0).toString().endsWith(args.elementAt(1).toString())) ? Boolean.TRUE : Boolean.FALSE;
+                    }
+                };
+        
+            private static final JS.Callable localHostOrDomainIs = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        return (args.elementAt(0).toString().equals(args.elementAt(1).toString()) || 
+                                (args.elementAt(0).toString().indexOf('.') == -1 && args.elementAt(1).toString().startsWith(args.elementAt(0).toString()))) ?
+                            Boolean.TRUE : Boolean.FALSE;
+                    }
+                };
+        
+            private static final JS.Callable isResolvable = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        try {
+                            return (InetAddress.getByName(args.elementAt(0).toString()) != null) ? Boolean.TRUE : Boolean.FALSE;
+                        } catch (UnknownHostException e) {
+                            return Boolean.FALSE;
+                        }
+                    }
+                };
+        
+            private static final JS.Callable isInNet = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        if (args.length() != 3) return Boolean.FALSE;
+                        try {
+                            byte[] host = InetAddress.getByName(args.elementAt(0).toString()).getAddress();
+                            byte[] net = InetAddress.getByName(args.elementAt(1).toString()).getAddress();
+                            byte[] mask = InetAddress.getByName(args.elementAt(2).toString()).getAddress();
+                            return ((host[0] & mask[0]) == net[0] &&
+                                    (host[1] & mask[1]) == net[1] &&
+                                    (host[2] & mask[2]) == net[2] &&
+                                    (host[3] & mask[3]) == net[3]) ?
+                                Boolean.TRUE : Boolean.FALSE;
+                        } catch (Exception e) {
+                            throw new JS.Exn("exception in isInNet(): " + e);
+                        }
+                    }
+                };
+        
+            private static final JS.Callable dnsResolve = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        try {
+                            return InetAddress.getByName(args.elementAt(0).toString()).getHostAddress();
+                        } catch (UnknownHostException e) {
+                            return null;
+                        }
+                    }
+                };
+        
+            private static final JS.Callable myIpAddress = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        try {
+                            return InetAddress.getLocalHost().getHostAddress();
+                        } catch (UnknownHostException e) {
+                            if (Log.on) Log.log(this, "strange... host does not know its own address");
+                            return null;
+                        }
+                    }
+                };
+        
+            private static final JS.Callable dnsDomainLevels = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        String s = args.elementAt(0).toString();
+                        int i = 0;
+                        while((i = s.indexOf('.', i)) != -1) i++;
+                        return new Integer(i);
+                    }
+                };
+        
+            private static boolean match(String[] arr, String s, int index) {
+                if (index >= arr.length) return true;
+                for(int i=0; i<s.length(); i++) {
+                    String s2 = s.substring(i);
+                    if (s2.startsWith(arr[index]) && match(arr, s2.substring(arr[index].length()), index + 1)) return true;
+                }
+                return false;
+            }
+        
+            private static final JS.Callable shExpMatch = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        StringTokenizer st = new StringTokenizer(args.elementAt(1).toString(), "*", false);
+                        String[] arr = new String[st.countTokens()];
+                        String s = args.elementAt(0).toString();
+                        for (int i=0; st.hasMoreTokens(); i++) arr[i] = st.nextToken();
+                        return match(arr, s, 0) ? Boolean.TRUE : Boolean.FALSE;
+                    }
+                };
+        
+            public static String[] days = { "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };
+        
+            private static final JS.Callable weekdayRange = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        TimeZone tz = (args.length() < 3 || args.elementAt(2) == null || !args.elementAt(2).equals("GMT")) ? TimeZone.getTimeZone("UTC") : TimeZone.getDefault();
+                        Calendar c = new GregorianCalendar();
+                        c.setTimeZone(tz);
+                        c.setTime(new java.util.Date());
+                        java.util.Date d = c.getTime();
+                        int day = d.getDay();
+                    
+                        String d1s = args.elementAt(0).toString().toUpperCase();
+                        int d1 = 0, d2 = 0;
+                        for(int i=0; i<days.length; i++) if (days[i].equals(d1s)) d1 = i;
+                    
+                        if (args.length() == 1)
+                            return d1 == day ? Boolean.TRUE : Boolean.FALSE;
+                    
+                        String d2s = args.elementAt(1).toString().toUpperCase();
+                        for(int i=0; i<days.length; i++) if (days[i].equals(d2s)) d2 = i;
+                    
+                        return
+                            ((d1 <= d2 && day >= d1 && day <= d2) ||
+                             (d1 > d2 && (day >= d1 || day <= d2))) ?
+                            Boolean.TRUE : Boolean.FALSE;
+                    }
+                };
+        
+            private static final JS.Callable dateRange = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        throw new JS.Exn("XWT does not support dateRange() in PAC scripts");
+                    }
+                };
+        
+            private static final JS.Callable timeRange = new JS.Callable() {
+                    public Object call(org.xwt.js.JS.Array args) throws JS.Exn {
+                        throw new JS.Exn("XWT does not support timeRange() in PAC scripts");
+                    }
+                };
+        
+        }
+
+    }
+
 }