libjava/java/net/JarURLConnection.java

   1 /* JarURLConnection.java -- Class for manipulating remote jar files
   2    Copyright (C) 1998, 2002, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.net;
  40
  41 import java.io.IOException;
  42 import java.util.jar.Attributes;
  43 import java.util.jar.JarEntry;
  44 import java.util.jar.JarFile;
  45 import java.util.jar.JarInputStream;
  46 import java.util.jar.Manifest;
  47 import java.util.zip.ZipEntry;
  48 import java.security.cert.Certificate;
  49
  50 /**
  51  * This abstract class represents a common superclass for implementations
  52  * of jar URL's.  A jar URL is a special type of URL that allows JAR
  53  * files on remote systems to be accessed.  It has the form:
  54  * <p>
  55  * jar:<standard URL pointing to jar file>!/file/within/jarfile
  56  * <p> for example:
  57  * <p>
  58  * jar:http://www.urbanophile.com/java/foo.jar!/com/urbanophile/bar.class
  59  * <p>
  60  * That example URL points to the file /com/urbanophile/bar.class in the
  61  * remote JAR file http://www.urbanophile.com/java/foo.jar.  The HTTP
  62  * protocol is used only as an example.  Any supported remote protocol
  63  * can be used.
  64  * <p>
  65  * This class currently works by retrieving the entire jar file into a
  66  * local cache file, then performing standard jar operations on it.
  67  * (At least this is true for the default protocol implementation).
  68  *
  69  * @author Aaron M. Renn <arenn@urbanophile.com>
  70  * @author Kresten Krab Thorup <krab@gnu.org>
  71  * @date Aug 10, 1999.
  72  *
  73  * @since 1.2
  74  */
  75 public abstract class JarURLConnection extends URLConnection
  76 {
  77   /**
  78    * This is the actual URL that points the remote jar file.  This is parsed
  79    * out of the jar URL by the constructor.
  80    */
  81   private final URL jarFileURL;
  82
  83   /**
  84    * The connection to the jar file itself. A JarURLConnection
  85    * can represent an entry in a jar file or an entire jar file.  In
  86    * either case this describes just the jar file itself.
  87    */
  88   protected URLConnection jarFileURLConnection;
  89
  90   /**
  91    * This is the jar file "entry name" or portion after the "!/" in the
  92    * URL which represents the pathname inside the actual jar file.
  93    */
  94   private final String entryName;
  95
  96   /**
  97    * Creates a JarURLConnection from an URL object
  98    *
  99    * @param URL url The URL object for this connection.
 100    *
 101    * @exception MalformedURLException If url is invalid
 102    *
 103    * @specnote This constructor is protected since JDK 1.4
 104    */
 105   protected JarURLConnection (URL url)
 106     throws MalformedURLException
 107   {
 108     super (url);
 109
 110     if (!url.getProtocol().equals ("jar"))
 111       throw new MalformedURLException (url + ": Not jar protocol.");
 112
 113     String spec = url.getFile();
 114     int bang = spec.indexOf ("!/");
 115     if (bang == -1)
 116       throw new MalformedURLException (url + ": No `!/' in spec.");
 117
 118     // Extract the url for the jar itself.
 119     jarFileURL = new URL (spec.substring (0, bang));
 120
 121     // Get the name of the entry, if any.
 122     entryName = spec.length() == (bang + 2) ? null : spec.substring (bang + 2);
 123   }
 124
 125   /**
 126    * This method returns the "real" URL where the JarFile is located.
 127    * //****Is this right?*****
 128    *
 129    * @return The remote URL
 130    */
 131   public URL getJarFileURL ()
 132   {
 133     return jarFileURL;
 134   }
 135
 136   /**
 137    * Returns the "entry name" portion of the jar URL.  This is the portion
 138    * after the "!/" in the jar URL that represents the pathname inside the
 139    * actual jar file.
 140    *
 141    * @return The entry name.
 142    */
 143   public String getEntryName ()
 144   {
 145     return entryName;
 146   }
 147
 148   /**
 149    * Returns the entry in this jar file specified by the URL.
 150    *
 151    * @return The jar entry
 152    *
 153    * @exception IOException If an error occurs
 154    */
 155   public JarEntry getJarEntry () throws IOException
 156   {
 157     JarFile jarfile = null;
 158
 159     if (entryName == null)
 160       return null;
 161
 162     if (! doInput)
 163       throw new ProtocolException("Can't open JarEntry if doInput is false");
 164
 165     try
 166       {
 167         jarfile = getJarFile ();
 168       }
 169     catch (IOException x)
 170       {
 171         /* ignore */
 172       }
 173
 174     if (jarfile == null)
 175       {
 176         JarInputStream zis = new JarInputStream(
 177                         jarFileURLConnection.getInputStream ());
 178
 179         // This is hideous, we're doing a linear search for the thing...
 180         for (ZipEntry ent = zis.getNextEntry ();
 181              ent != null;
 182              ent = zis.getNextEntry ())
 183           {
 184             if (entryName.equals (ent.getName()))
 185               {
 186                 return new JarEntry (ent);
 187               }
 188           }
 189       }
 190
 191     else
 192       {
 193         return jarfile.getJarEntry (entryName);
 194       }
 195
 196     return null;
 197   }
 198
 199   /**
 200    * Returns a read-only JarFile object for the remote jar file
 201    *
 202    * @return The JarFile object
 203    *
 204    * @exception IOException If an error occurs
 205    */
 206   public abstract JarFile getJarFile () throws IOException;
 207
 208   /**
 209    * Returns an array of Certificate objects for the jar file entry specified
 210    * by this URL or null if there are none
 211    *
 212    * @return A Certificate array
 213    *
 214    * @exception IOException If an error occurs
 215    */
 216   public Certificate[] getCertificates () throws IOException
 217   {
 218     JarEntry entry = getJarEntry();
 219
 220     return entry != null ? entry.getCertificates() : null;
 221   }
 222
 223   /**
 224    * Returns the main Attributes for the jar file specified in the URL or
 225    * null if there are none
 226    *
 227    * @return The main Attributes for the JAR file for this connection
 228    *
 229    * @exception IOException If an error occurs
 230    */
 231   public Attributes getMainAttributes () throws IOException
 232   {
 233     Manifest manifest = getManifest();
 234
 235     return manifest != null ? manifest.getMainAttributes() : null;
 236   }
 237
 238   /**
 239    * Returns the Attributes for the Jar entry specified by the URL or null
 240    * if none
 241    *
 242    * @return The Attributes object for this connection if the URL for it points
 243    * to a JAR file entry, null otherwise
 244    *
 245    * @exception IOException If an error occurs
 246    */
 247   public Attributes getAttributes () throws IOException
 248   {
 249     JarEntry entry = getJarEntry();
 250
 251     return entry != null ? entry.getAttributes() : null;
 252   }
 253
 254   /**
 255    * Returns a Manifest object for this jar file, or null if there is no
 256    * manifest.
 257    *
 258    * @return The Manifest for this connection, or null if none
 259    *
 260    * @exception IOException If an error occurs
 261    */
 262   public Manifest getManifest () throws IOException
 263   {
 264     JarFile file = getJarFile();
 265
 266     return file != null ? file.getManifest() : null;
 267   }
 268 }