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