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