home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 June / CHIPHEFT062001.ISO / browser / nc32lyc / comm.z / java40.jar / netscape / net / URLConnection.class (.txt) < prev    next >
Encoding:
Java Class File  |  2000-08-15  |  9.4 KB  |  509 lines
  1. package netscape.net;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.net.InetAddress;
  7. import java.net.MalformedURLException;
  8. import java.net.URL;
  9. import java.net.UnknownHostException;
  10. import java.net.UnknownServiceException;
  11. import java.util.Enumeration;
  12. import java.util.Hashtable;
  13. import netscape.security.AppletSecurity;
  14. import netscape.security.PrivilegeManager;
  15. import netscape.security.Target;
  16. import netscape.security.UserTarget;
  17.  
  18. final class URLConnection extends java.net.URLConnection {
  19.    static final String EOL = "\r\n";
  20.    int pStreamData;
  21.    URLInputStream currentInputStream;
  22.    URLOutputStream currentOutputStream;
  23.    String postHeaders;
  24.    boolean useSARCache = false;
  25.    Hashtable properties;
  26.    static Hashtable defaultProperties;
  27.    private String filename;
  28.    private String path;
  29.    private String name;
  30.    private String mimeTypeHint;
  31.    private int type;
  32.    private int maxSize;
  33.    private boolean isOpen = false;
  34.    private Cache cache;
  35.    private final int GET_FIRST = 1;
  36.    private final int GET_NEXT = 2;
  37.    private final int GET_LAST = 3;
  38.    private boolean enabled = true;
  39.    static final int BUF_SIZE = 1024;
  40.    static byte[] junk = new byte[1024];
  41.    String rangeHeader;
  42.  
  43.    protected URLConnection(URL var1) {
  44.       super(var1);
  45.       String var2 = null;
  46.  
  47.       try {
  48.          var2 = InetAddress.getByName(var1.getHost()).getHostAddress();
  49.       } catch (UnknownHostException var4) {
  50.       } catch (SecurityException var5) {
  51.       }
  52.  
  53.       boolean var3 = !SecurityManager.isPrivilegeEnabled("UniversalRedirect");
  54.       this.pCreate(var1.toExternalForm(), var2, var3);
  55.    }
  56.  
  57.    private native void pCreate(String var1, String var2, boolean var3);
  58.  
  59.    protected native void finalize();
  60.  
  61.    public void connect() throws IOException {
  62.       if (!super.connected) {
  63.          System.getSecurityManager().checkURLConnect(super.url);
  64.          super.connected = true;
  65.          StringBuffer var1 = new StringBuffer();
  66.          if (this.postHeaders != null) {
  67.             var1.append(this.postHeaders);
  68.          }
  69.  
  70.          boolean var2 = false;
  71.          Hashtable var3 = this.properties;
  72.          if (var3 == null) {
  73.             var3 = defaultProperties;
  74.          }
  75.  
  76.          if (var3 != null) {
  77.             Enumeration var4 = var3.keys();
  78.  
  79.             while(var4.hasMoreElements()) {
  80.                String var5 = (String)var4.nextElement();
  81.                if (!var5.equalsIgnoreCase("Content-length")) {
  82.                   if (var5.equalsIgnoreCase("Content-type")) {
  83.                      var2 = true;
  84.                   }
  85.  
  86.                   String var6 = (String)var3.get(var5);
  87.                   var1.append(var5);
  88.                   var1.append(":");
  89.                   var1.append(var6);
  90.                   var1.append("\r\n");
  91.                }
  92.             }
  93.          }
  94.  
  95.          if (!var2) {
  96.             var1.append("Content-type: multipart/form-data");
  97.             var1.append("\r\n");
  98.          }
  99.  
  100.          this.postHeaders = var1.toString();
  101.          this.properties = null;
  102.          if (this.currentOutputStream != null) {
  103.             this.currentOutputStream.close();
  104.          }
  105.  
  106.          URLInputStream var7 = (URLInputStream)this.getInputStream();
  107.          var7.open();
  108.          this.rangeHeader = null;
  109.       }
  110.    }
  111.  
  112.    public int getContentLength() {
  113.       try {
  114.          this.getInputStream();
  115.       } catch (Exception var1) {
  116.          return -1;
  117.       }
  118.  
  119.       return this.getContentLength0();
  120.    }
  121.  
  122.    public native int getContentLength0();
  123.  
  124.    public String getContentType() {
  125.       try {
  126.          this.getInputStream();
  127.       } catch (Exception var1) {
  128.          return null;
  129.       }
  130.  
  131.       return this.getContentType0();
  132.    }
  133.  
  134.    public native String getContentType0();
  135.  
  136.    public String getHeaderField(String var1) {
  137.       try {
  138.          this.getInputStream();
  139.       } catch (Exception var2) {
  140.          return null;
  141.       }
  142.  
  143.       return this.getHeaderField0(var1);
  144.    }
  145.  
  146.    public native String getHeaderField0(String var1);
  147.  
  148.    public String getHeaderFieldKey(int var1) {
  149.       try {
  150.          this.getInputStream();
  151.       } catch (Exception var2) {
  152.          return null;
  153.       }
  154.  
  155.       return this.getHeaderFieldKey0(var1);
  156.    }
  157.  
  158.    public native String getHeaderFieldKey0(int var1);
  159.  
  160.    public InputStream getInputStream() throws IOException {
  161.       if (!super.connected) {
  162.          this.connect();
  163.       }
  164.  
  165.       if (!super.doInput) {
  166.          throw new UnknownServiceException("protocol doesn't support input");
  167.       } else {
  168.          if (this.currentInputStream == null) {
  169.             this.currentInputStream = new URLInputStream(this);
  170.          }
  171.  
  172.          return this.currentInputStream;
  173.       }
  174.    }
  175.  
  176.    public OutputStream getOutputStream() throws IOException {
  177.       if (super.connected) {
  178.          throw new IllegalAccessError("Already connected");
  179.       } else if (!super.doOutput) {
  180.          throw new UnknownServiceException("protocol doesn't support output");
  181.       } else {
  182.          if (this.currentOutputStream == null) {
  183.             this.currentOutputStream = new URLOutputStream(this);
  184.             this.currentOutputStream.open();
  185.          }
  186.  
  187.          return this.currentOutputStream;
  188.       }
  189.    }
  190.  
  191.    public void setRequestProperty(String var1, String var2) {
  192.       if (super.connected) {
  193.          throw new IllegalAccessError("Already connected");
  194.       } else if (var1.equalsIgnoreCase("Range")) {
  195.          this.rangeHeader = var2;
  196.       } else {
  197.          if (this.properties == null) {
  198.             this.properties = new Hashtable();
  199.          }
  200.  
  201.          if (var2 != null) {
  202.             this.properties.put(var1, var2);
  203.          } else {
  204.             this.properties.remove(var1);
  205.          }
  206.       }
  207.    }
  208.  
  209.    public String getRequestProperty(String var1) {
  210.       if (super.connected) {
  211.          throw new IllegalAccessError("Already connected");
  212.       } else {
  213.          return this.properties == null ? null : (String)this.properties.get(var1);
  214.       }
  215.    }
  216.  
  217.    public static void setDefaultRequestProperty(String var0, String var1) {
  218.       if (defaultProperties == null) {
  219.          defaultProperties = new Hashtable();
  220.       }
  221.  
  222.       if (var1 != null) {
  223.          defaultProperties.put(var0, var1);
  224.       } else {
  225.          defaultProperties.remove(var0);
  226.       }
  227.    }
  228.  
  229.    public static String getDefaultRequestProperty(String var0) {
  230.       return defaultProperties == null ? null : (String)defaultProperties.get(var0);
  231.    }
  232.  
  233.    native void close() throws IOException;
  234.  
  235.    void setUseSARCache(boolean var1) {
  236.       this.useSARCache = var1;
  237.    }
  238.  
  239.    void setName(String var1) {
  240.       this.name = var1;
  241.    }
  242.  
  243.    void setFilename(String var1) {
  244.       this.filename = var1;
  245.    }
  246.  
  247.    void setPath(String var1) {
  248.       this.path = var1;
  249.    }
  250.  
  251.    void setMimeTypeHint(String var1) {
  252.       this.mimeTypeHint = var1;
  253.    }
  254.  
  255.    boolean getUseSARCache() {
  256.       return this.useSARCache;
  257.    }
  258.  
  259.    void openCache(String var1, String var2, String var3, Cache var4) {
  260.       if (this.enabled) {
  261.          this.path = var1;
  262.          this.filename = var2;
  263.          this.name = var3;
  264.          this.maxSize = 0;
  265.          this.cache = var4;
  266.          this.isOpen = this.nOpenCache();
  267.       }
  268.    }
  269.  
  270.    void openCache(String var1, String var2, String var3, Cache var4, int var5) {
  271.       if (this.enabled) {
  272.          this.path = var1;
  273.          this.filename = var2;
  274.          this.name = var3;
  275.          this.maxSize = var5;
  276.          this.cache = var4;
  277.          this.isOpen = this.nOpenCache();
  278.       }
  279.    }
  280.  
  281.    private native boolean nOpenCache();
  282.  
  283.    void setMaxSize(int var1) {
  284.       this.maxSize = var1;
  285.       this.nUpdateCache();
  286.    }
  287.  
  288.    private native void nUpdateCache();
  289.  
  290.    String isURLInCache(String var1) {
  291.       return !this.enabled ? null : this.nIsURLInCache(var1);
  292.    }
  293.  
  294.    private native String nIsURLInCache(String var1);
  295.  
  296.    void getURL(URL var1) {
  297.       if (this.enabled) {
  298.          if (!this.isOpen) {
  299.             this.nOpenCache();
  300.             this.isOpen = true;
  301.          }
  302.  
  303.          PrivilegeManager var3 = AppletSecurity.getPrivilegeManager();
  304.          UserTarget var4 = (UserTarget)Target.findTarget("UniversalConnect");
  305.          var3.enablePrivilege(var4);
  306.  
  307.          try {
  308.             URLConnection var2 = (URLConnection)var1.openConnection();
  309.             var2.setUseSARCache(true);
  310.             var2.setName(this.name);
  311.             var2.setFilename(this.filename);
  312.             var2.setPath(this.path);
  313.             InputStream var5 = var2.getInputStream();
  314.  
  315.             try {
  316.                while(var5.read(junk) >= 0) {
  317.                }
  318.             } catch (IOException var6) {
  319.             }
  320.  
  321.             var5.close();
  322.          } catch (IOException var7) {
  323.          }
  324.  
  325.          var3.revertPrivilege(var4);
  326.       }
  327.    }
  328.  
  329.    void getURL(CacheRequest var1) throws MalformedURLException {
  330.       if (this.enabled) {
  331.          URL var2 = var1.getURL();
  332.          if (!this.isOpen) {
  333.             this.nOpenCache();
  334.             this.isOpen = true;
  335.          }
  336.  
  337.          PrivilegeManager var4 = AppletSecurity.getPrivilegeManager();
  338.          UserTarget var5 = (UserTarget)Target.findTarget("UniversalConnect");
  339.          var4.enablePrivilege(var5);
  340.  
  341.          try {
  342.             URLConnection var3 = (URLConnection)var2.openConnection();
  343.             var3.setUseSARCache(true);
  344.             var3.setName(this.name);
  345.             var3.setFilename(this.filename);
  346.             var3.setPath(this.path);
  347.             var3.setMimeTypeHint(var1.getMimeTypeHint());
  348.             InputStream var6 = var3.getInputStream();
  349.  
  350.             try {
  351.                while(var6.read(junk) >= 0) {
  352.                }
  353.             } catch (IOException var7) {
  354.             }
  355.  
  356.             var1.setLocation(var3.getHeaderField("Location"));
  357.             var1.setContentType(var3.getHeaderField("Content-type"));
  358.             var1.setContentLength(var3.getHeaderField("Content-length"));
  359.             var1.setLastModified(var3.getHeaderField("Last-modified"));
  360.             var1.setExpires(var3.getHeaderField("Expires"));
  361.             var6.close();
  362.          } catch (IOException var8) {
  363.          }
  364.  
  365.          var4.revertPrivilege(var5);
  366.       }
  367.    }
  368.  
  369.    InputStream getInputStream(CacheRequest var1) throws IOException {
  370.       if (!this.enabled) {
  371.          return null;
  372.       } else {
  373.          URL var3 = var1.getURL();
  374.          Object var4 = null;
  375.          if (!this.isOpen) {
  376.             this.nOpenCache();
  377.             this.isOpen = true;
  378.          }
  379.  
  380.          PrivilegeManager var5 = AppletSecurity.getPrivilegeManager();
  381.          UserTarget var6 = (UserTarget)Target.findTarget("UniversalConnect");
  382.          var5.enablePrivilege(var6);
  383.          URLConnection var2 = (URLConnection)var3.openConnection();
  384.          var2.setUseSARCache(true);
  385.          var2.setName(this.name);
  386.          var2.setFilename(this.filename);
  387.          var2.setPath(this.path);
  388.          var2.setMimeTypeHint(var1.getMimeTypeHint());
  389.          InputStream var7 = var2.getInputStream();
  390.          var1.setLocation(var2.getHeaderField("Location"));
  391.          var1.setContentType(var2.getHeaderField("Content-type"));
  392.          var1.setContentLength(var2.getHeaderField("Content-length"));
  393.          var1.setLastModified(var2.getHeaderField("Last-modified"));
  394.          var1.setExpires(var2.getHeaderField("Expires"));
  395.          var5.revertPrivilege(var6);
  396.          return var7;
  397.       }
  398.    }
  399.  
  400.    InputStream getInputStream(URL var1) throws IOException {
  401.       if (!this.enabled) {
  402.          return null;
  403.       } else {
  404.          Object var3 = null;
  405.          if (!this.isOpen) {
  406.             this.nOpenCache();
  407.             this.isOpen = true;
  408.          }
  409.  
  410.          PrivilegeManager var4 = AppletSecurity.getPrivilegeManager();
  411.          UserTarget var5 = (UserTarget)Target.findTarget("UniversalConnect");
  412.          var4.enablePrivilege(var5);
  413.          URLConnection var2 = (URLConnection)var1.openConnection();
  414.          var2.setUseSARCache(true);
  415.          var2.setName(this.name);
  416.          var2.setFilename(this.filename);
  417.          var2.setPath(this.path);
  418.          InputStream var6 = var2.getInputStream();
  419.          var4.revertPrivilege(var5);
  420.          return var6;
  421.       }
  422.    }
  423.  
  424.    boolean put(String var1, String var2, Hashtable var3) {
  425.       if (!this.enabled) {
  426.          return false;
  427.       } else {
  428.          String var4 = (String)var3.get("Content-type");
  429.          String var5 = (String)var3.get("Content-length");
  430.          String var6 = (String)var3.get("Last-modified");
  431.          String var7 = (String)var3.get("Date");
  432.          return this.nPut(var1, var2, var4, var6 != null ? Long.parseLong(var6) : 0L, var5 != null ? Integer.parseInt(var5) : 0, var7 != null ? Long.parseLong(var7) : 0L);
  433.       }
  434.    }
  435.  
  436.    private native boolean nPut(String var1, String var2, String var3, long var4, int var6, long var7);
  437.  
  438.    void remove(String var1) {
  439.       if (this.enabled) {
  440.          if (this.isOpen) {
  441.             this.nRemove(var1);
  442.          }
  443.       }
  444.    }
  445.  
  446.    void remove(URL var1) {
  447.       if (this.enabled) {
  448.          this.remove(var1.toString());
  449.       }
  450.    }
  451.  
  452.    private native void nRemove(String var1);
  453.  
  454.    void clear() {
  455.       if (this.enabled) {
  456.          if (this.isOpen) {
  457.             this.nClear();
  458.          }
  459.       }
  460.    }
  461.  
  462.    private native void nClear();
  463.  
  464.    void delete() {
  465.       if (this.enabled) {
  466.          if (this.isOpen) {
  467.             this.nDelete();
  468.          }
  469.       }
  470.    }
  471.  
  472.    private native void nDelete();
  473.  
  474.    void closeCache() {
  475.       if (this.enabled) {
  476.          if (this.isOpen) {
  477.             this.nCloseCache();
  478.             this.isOpen = false;
  479.          }
  480.       }
  481.    }
  482.  
  483.    private native void nCloseCache();
  484.  
  485.    void getFirstManagedCache(CacheObject var1) {
  486.       if (this.enabled) {
  487.          this.nEnumManagedCaches(var1, 1);
  488.       }
  489.    }
  490.  
  491.    void getLastManagedCache(CacheObject var1) {
  492.       if (this.enabled) {
  493.          this.nEnumManagedCaches(var1, 3);
  494.       }
  495.    }
  496.  
  497.    void getNextManagedCache(CacheObject var1) {
  498.       if (this.enabled) {
  499.          this.nEnumManagedCaches(var1, 2);
  500.       }
  501.    }
  502.  
  503.    private native void nEnumManagedCaches(CacheObject var1, int var2);
  504.  
  505.    public static String guessContentTypeFromName(String var0) {
  506.       return java.net.URLConnection.guessContentTypeFromName(var0);
  507.    }
  508. }
  509.