* JAR-related files that resemble Manifest files are Signature files
* (with an .SF extension) found in signed JARs.
*/
public abstract class JarUtils
{
// We used to log here, but this causes problems during bootstrap,
// and it didn't seem worthwhile to preserve this. Still, this
// might be useful for debugging.
// private static final Logger log = Logger.getLogger(JarUtils.class.getName());
public static final String META_INF = "META-INF/";
public static final String DSA_SUFFIX = ".DSA";
public static final String SF_SUFFIX = ".SF";
public static final String NAME = "Name";
/**
* The original string representation of the manifest version attribute name.
*/
public static final String MANIFEST_VERSION = "Manifest-Version";
/**
* The original string representation of the signature version attribute
* name.
*/
public static final String SIGNATURE_VERSION = "Signature-Version";
/** Platform-independent line-ending. */
public static final byte[] CRLF = new byte[] { 0x0D, 0x0A };
private static final String DEFAULT_MF_VERSION = "1.0";
private static final String DEFAULT_SF_VERSION = "1.0";
private static final Name CREATED_BY = new Name("Created-By");
private static final String CREATOR = SystemProperties.getProperty("java.version")
+ " ("
+ SystemProperties.getProperty("java.vendor")
+ ")";
// default 0-arguments constructor
// Methods for reading Manifest files from InputStream ----------------------
public static void
readMFManifest(Attributes attr, Map entries, InputStream in)
throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF-8"));
readMainSection(attr, br);
readIndividualSections(entries, br);
}
public static void
readSFManifest(Attributes attr, Map entries, InputStream in)
throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF-8"));
String version_header = Name.SIGNATURE_VERSION.toString();
try
{
String version = expectHeader(version_header, br);
attr.putValue(SIGNATURE_VERSION, version);
// This may cause problems during VM bootstrap.
// if (! DEFAULT_SF_VERSION.equals(version))
// log.warning("Unexpected version number: " + version
// + ". Continue (but may fail later)");
}
catch (IOException ioe)
{
throw new JarException("Signature file MUST start with a "
+ version_header + ": " + ioe.getMessage());
}
read_attributes(attr, br);
// read individual sections
String s = br.readLine();
while (s != null && s.length() > 0)
{
Attributes eAttr = readSectionName(s, br, entries);
read_attributes(eAttr, br);
s = br.readLine();
}
}
private static void readMainSection(Attributes attr, BufferedReader br)
throws IOException
{
// According to the spec we should actually call read_version_info() here.
read_attributes(attr, br);
// Explicitly set Manifest-Version attribute if not set in Main
// attributes of Manifest.
// XXX (rsn): why 0.0 and not 1.0?
if (attr.getValue(Name.MANIFEST_VERSION) == null)
attr.putValue(MANIFEST_VERSION, "0.0");
}
private static void readIndividualSections(Map entries, BufferedReader br)
throws IOException
{
String s = br.readLine();
while (s != null && (! s.equals("")))
{
Attributes attr = readSectionName(s, br, entries);
read_attributes(attr, br);
s = br.readLine();
}
}
/**
* Pedantic method that requires the next attribute in the Manifest to be the
* "Manifest-Version". This follows the Manifest spec closely but reject some
* jar Manifest files out in the wild.
*/
private static void readVersionInfo(Attributes attr, BufferedReader br)
throws IOException
{
String version_header = Name.MANIFEST_VERSION.toString();
try
{
String value = expectHeader(version_header, br);
attr.putValue(MANIFEST_VERSION, value);
}
catch (IOException ioe)
{
throw new JarException("Manifest should start with a " + version_header
+ ": " + ioe.getMessage());
}
}
private static String expectHeader(String header, BufferedReader br)
throws IOException
{
String s = br.readLine();
if (s == null)
throw new JarException("unexpected end of file");
return expectHeader(header, br, s);
}
private static void read_attributes(Attributes attr, BufferedReader br)
throws IOException
{
String s = br.readLine();
while (s != null && (! s.equals("")))
{
readAttribute(attr, s, br);
s = br.readLine();
}
}
private static void
readAttribute(Attributes attr, String s, BufferedReader br) throws IOException
{
try
{
int colon = s.indexOf(": ");
String name = s.substring(0, colon);
String value_start = s.substring(colon + 2);
String value = readHeaderValue(value_start, br);
attr.putValue(name, value);
}
catch (IndexOutOfBoundsException iobe)
{
throw new JarException("Manifest contains a bad header: " + s);
}
}
private static String readHeaderValue(String s, BufferedReader br)
throws IOException
{
boolean try_next = true;
while (try_next)
{
// Lets see if there is something on the next line
br.mark(1);
if (br.read() == ' ')
s += br.readLine();
else
{
br.reset();
try_next = false;
}
}
return s;
}
private static Attributes
readSectionName(String s, BufferedReader br, Map entries) throws JarException
{
try
{
String name = expectHeader(NAME, br, s);
Attributes attr = new Attributes();
entries.put(name, attr);
return attr;
}
catch (IOException ioe)
{
throw new JarException("Section should start with a Name header: "
+ ioe.getMessage());
}
}
private static String expectHeader(String header, BufferedReader br, String s)
throws IOException
{
try
{
String name = s.substring(0, header.length() + 1);
if (name.equalsIgnoreCase(header + ":"))
{
String value_start = s.substring(header.length() + 2);
return readHeaderValue(value_start, br);
}
}
catch (IndexOutOfBoundsException ignored)
{
}
// If we arrive here, something went wrong
throw new JarException("unexpected '" + s + "'");
}
// Methods for writing Manifest files to an OutputStream --------------------
public static void
writeMFManifest(Attributes attr, Map entries, OutputStream stream)
throws IOException
{
BufferedOutputStream out = stream instanceof BufferedOutputStream
? (BufferedOutputStream) stream
: new BufferedOutputStream(stream, 4096);
writeVersionInfo(attr, out);
Iterator i;
Map.Entry e;
for (i = attr.entrySet().iterator(); i.hasNext();)
{
e = (Map.Entry) i.next();
// Don't print the manifest version again
if (! Name.MANIFEST_VERSION.equals(e.getKey()))
writeAttributeEntry(e, out);
}
out.write(CRLF);
Iterator j;
for (i = entries.entrySet().iterator(); i.hasNext();)
{
e = (Map.Entry) i.next();
writeHeader(NAME, e.getKey().toString(), out);
Attributes eAttr = (Attributes) e.getValue();
for (j = eAttr.entrySet().iterator(); j.hasNext();)
{
Map.Entry e2 = (Map.Entry) j.next();
writeAttributeEntry(e2, out);
}
out.write(CRLF);
}
out.flush();
}
public static void
writeSFManifest(Attributes attr, Map entries, OutputStream stream)
throws IOException
{
BufferedOutputStream out = stream instanceof BufferedOutputStream
? (BufferedOutputStream) stream
: new BufferedOutputStream(stream, 4096);
writeHeader(Name.SIGNATURE_VERSION.toString(), DEFAULT_SF_VERSION, out);
writeHeader(CREATED_BY.toString(), CREATOR, out);
Iterator i;
Map.Entry e;
for (i = attr.entrySet().iterator(); i.hasNext();)
{
e = (Map.Entry) i.next();
Name name = (Name) e.getKey();
if (Name.SIGNATURE_VERSION.equals(name) || CREATED_BY.equals(name))
continue;
writeHeader(name.toString(), (String) e.getValue(), out);
}
out.write(CRLF);
Iterator j;
for (i = entries.entrySet().iterator(); i.hasNext();)
{
e = (Map.Entry) i.next();
writeHeader(NAME, e.getKey().toString(), out);
Attributes eAttr = (Attributes) e.getValue();
for (j = eAttr.entrySet().iterator(); j.hasNext();)
{
Map.Entry e2 = (Map.Entry) j.next();
writeHeader(e2.getKey().toString(), (String) e2.getValue(), out);
}
out.write(CRLF);
}
out.flush();
}
private static void writeVersionInfo(Attributes attr, OutputStream out)
throws IOException
{
// First check if there is already a version attribute set
String version = attr.getValue(Name.MANIFEST_VERSION);
if (version == null)
version = DEFAULT_MF_VERSION;
writeHeader(Name.MANIFEST_VERSION.toString(), version, out);
}
private static void writeAttributeEntry(Map.Entry entry, OutputStream out)
throws IOException
{
String name = entry.getKey().toString();
String value = entry.getValue().toString();
if (name.equalsIgnoreCase(NAME))
throw new JarException("Attributes cannot be called 'Name'");
if (name.startsWith("From"))
throw new JarException("Header cannot start with the four letters 'From'"
+ name);
writeHeader(name, value, out);
}
/**
* The basic method for writing Mainfest attributes. This
* implementation respects the rule stated in the Jar Specification concerning
* the maximum allowed line length; i.e.
*
*
* No line may be longer than 72 bytes (not characters), in its UTF8-encoded * form. If a value would make the initial line longer than this, it should * be continued on extra lines (each starting with a single SPACE). ** * and * *
* Because header names cannot be continued, the maximum length of a header * name is 70 bytes (there must be a colon and a SPACE after the name). ** * @param name the name of the attribute. * @param value the value of the attribute. * @param out the output stream to write the attribute's name/value pair to. * @throws IOException if an I/O related exception occurs during the process. */ private static void writeHeader(String name, String value, OutputStream out) throws IOException { String target = name + ": "; byte[] b = target.getBytes("UTF-8"); if (b.length > 72) throw new IOException("Attribute's name already longer than 70 bytes"); if (b.length == 72) { out.write(b); out.write(CRLF); target = " " + value; } else target = target + value; int n; while (true) { b = target.getBytes("UTF-8"); if (b.length < 73) { out.write(b); break; } // find an appropriate character position to break on n = 72; while (true) { b = target.substring(0, n).getBytes("UTF-8"); if (b.length < 73) break; n--; if (n < 1) throw new IOException("Header is unbreakable and longer than 72 bytes"); } out.write(b); out.write(CRLF); target = " " + target.substring(n); } out.write(CRLF); } }