org.apache.tools.zip.ZipEntry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ant Show documentation
Show all versions of ant Show documentation
Repackaging of Ant as a module
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.tools.zip;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.zip.ZipException;
/**
* Extension that adds better handling of extra fields and provides
* access to the internal and external file attributes.
*
* The extra data is expected to follow the recommendation of
* {@link
* APPNOTE.txt}:
*
* - the extra byte array consists of a sequence of extra fields
* - each extra fields starts by a two byte header id followed by
* a two byte sequence holding the length of the remainder of
* data.
*
*
* Any extra data that cannot be parsed by the rules above will be
* consumed as "unparseable" extra data and treated differently by the
* methods of this class. Older versions would have thrown an
* exception if any attempt was made to read or write extra data not
* conforming to the recommendation.
*
*/
public class ZipEntry extends java.util.zip.ZipEntry implements Cloneable {
public static final int PLATFORM_UNIX = 3;
public static final int PLATFORM_FAT = 0;
public static final int CRC_UNKNOWN = -1;
private static final int SHORT_MASK = 0xFFFF;
private static final int SHORT_SHIFT = 16;
private static final byte[] EMPTY = new byte[0];
/**
* The {@link java.util.zip.ZipEntry} base class only supports
* the compression methods STORED and DEFLATED. We override the
* field so that any compression methods can be used.
*
* The default value -1 means that the method has not been specified.
*/
private int method = -1;
/**
* The {@link java.util.zip.ZipEntry#setSize} method in the base
* class throws an IllegalArgumentException if the size is bigger
* than 2GB for Java versions < 7. Need to keep our own size
* information for Zip64 support.
*/
private long size = -1;
private int internalAttributes = 0;
private int platform = PLATFORM_FAT;
private long externalAttributes = 0;
private ZipExtraField[] extraFields;
private UnparseableExtraFieldData unparseableExtra = null;
private String name = null;
private byte[] rawName = null;
private GeneralPurposeBit gpb = new GeneralPurposeBit();
private static final ZipExtraField[] noExtraFields = new ZipExtraField[0];
/**
* Creates a new zip entry with the specified name.
*
*
Assumes the entry represents a directory if and only if the
* name ends with a forward slash "/".
*
* @param name the name of the entry
* @since 1.1
*/
public ZipEntry(final String name) {
super(name);
setName(name);
}
/**
* Creates a new zip entry with fields taken from the specified zip entry.
*
* Assumes the entry represents a directory if and only if the
* name ends with a forward slash "/".
*
* @param entry the entry to get fields from
* @since 1.1
* @throws ZipException on error
*/
public ZipEntry(final java.util.zip.ZipEntry entry) throws ZipException {
super(entry);
setName(entry.getName());
final byte[] extra = entry.getExtra();
if (extra != null) {
setExtraFields(ExtraFieldUtils.parse(extra, true,
ExtraFieldUtils
.UnparseableExtraField.READ));
} else {
// initializes extra data to an empty byte array
setExtra();
}
setMethod(entry.getMethod());
this.size = entry.getSize();
}
/**
* Creates a new zip entry with fields taken from the specified zip entry.
*
* Assumes the entry represents a directory if and only if the
* name ends with a forward slash "/".
*
* @param entry the entry to get fields from
* @throws ZipException on error
* @since 1.1
*/
public ZipEntry(final ZipEntry entry) throws ZipException {
this((java.util.zip.ZipEntry) entry);
setInternalAttributes(entry.getInternalAttributes());
setExternalAttributes(entry.getExternalAttributes());
setExtraFields(getAllExtraFieldsNoCopy());
setPlatform(entry.getPlatform());
GeneralPurposeBit other = entry.getGeneralPurposeBit();
setGeneralPurposeBit(other == null ? null :
(GeneralPurposeBit) other.clone());
}
/**
* @since 1.9
*/
protected ZipEntry() {
this("");
}
/**
* Creates a new zip entry taking some information from the given
* file and using the provided name.
*
* The name will be adjusted to end with a forward slash "/" if
* the file is a directory. If the file is not a directory a
* potential trailing forward slash will be stripped from the
* entry name.
*/
public ZipEntry(final File inputFile, final String entryName) {
this(inputFile.isDirectory() && !entryName.endsWith("/") ?
entryName + "/" : entryName);
if (inputFile.isFile()){
setSize(inputFile.length());
}
setTime(inputFile.lastModified());
// TODO are there any other fields we can set here?
}
/**
* Overwrite clone.
* @return a cloned copy of this ZipEntry
* @since 1.1
*/
@Override
public Object clone() {
final ZipEntry e = (ZipEntry) super.clone();
e.setInternalAttributes(getInternalAttributes());
e.setExternalAttributes(getExternalAttributes());
e.setExtraFields(getAllExtraFieldsNoCopy());
return e;
}
/**
* Returns the compression method of this entry, or -1 if the
* compression method has not been specified.
*
* @return compression method
*/
@Override
public int getMethod() {
return method;
}
/**
* Sets the compression method of this entry.
*
* @param method compression method
*/
@Override
public void setMethod(final int method) {
if (method < 0) {
throw new IllegalArgumentException(
"ZIP compression method can not be negative: " + method);
}
this.method = method;
}
/**
* Retrieves the internal file attributes.
*
* @return the internal file attributes
* @since 1.1
*/
public int getInternalAttributes() {
return internalAttributes;
}
/**
* Sets the internal file attributes.
* @param value an int value
* @since 1.1
*/
public void setInternalAttributes(final int value) {
internalAttributes = value;
}
/**
* Retrieves the external file attributes.
* @return the external file attributes
* @since 1.1
*/
public long getExternalAttributes() {
return externalAttributes;
}
/**
* Sets the external file attributes.
* @param value an long value
* @since 1.1
*/
public void setExternalAttributes(final long value) {
externalAttributes = value;
}
/**
* Sets Unix permissions in a way that is understood by Info-Zip's
* unzip command.
* @param mode an int value
* @since Ant 1.5.2
*/
public void setUnixMode(final int mode) {
// CheckStyle:MagicNumberCheck OFF - no point
setExternalAttributes((mode << SHORT_SHIFT)
// MS-DOS read-only attribute
| ((mode & 0200) == 0 ? 1 : 0)
// MS-DOS directory flag
| (isDirectory() ? 0x10 : 0));
// CheckStyle:MagicNumberCheck ON
platform = PLATFORM_UNIX;
}
/**
* Unix permission.
* @return the unix permissions
* @since Ant 1.6
*/
public int getUnixMode() {
return platform != PLATFORM_UNIX ? 0 :
(int) ((getExternalAttributes() >> SHORT_SHIFT) & SHORT_MASK);
}
/**
* Platform specification to put into the "version made
* by" part of the central file header.
*
* @return PLATFORM_FAT unless {@link #setUnixMode setUnixMode}
* has been called, in which case PLATFORM_UNIX will be returned.
*
* @since Ant 1.5.2
*/
public int getPlatform() {
return platform;
}
/**
* Set the platform (UNIX or FAT).
* @param platform an int value - 0 is FAT, 3 is UNIX
* @since 1.9
*/
protected void setPlatform(final int platform) {
this.platform = platform;
}
/**
* Replaces all currently attached extra fields with the new array.
* @param fields an array of extra fields
* @since 1.1
*/
public void setExtraFields(final ZipExtraField[] fields) {
List newFields = new ArrayList();
for (ZipExtraField field : fields) {
if (field instanceof UnparseableExtraFieldData) {
unparseableExtra = (UnparseableExtraFieldData) field;
} else {
newFields.add( field);
}
}
extraFields = newFields.toArray(new ZipExtraField[newFields.size()]);
setExtra();
}
/**
* Retrieves all extra fields that have been parsed successfully.
* @return an array of the extra fields
*/
public ZipExtraField[] getExtraFields() {
return getParseableExtraFields();
}
/**
* Retrieves extra fields.
* @param includeUnparseable whether to also return unparseable
* extra fields as {@link UnparseableExtraFieldData} if such data
* exists.
* @return an array of the extra fields
* @since 1.1
*/
public ZipExtraField[] getExtraFields(final boolean includeUnparseable) {
return includeUnparseable ?
getAllExtraFields() :
getParseableExtraFields();
}
private ZipExtraField[] getParseableExtraFieldsNoCopy() {
if (extraFields == null) {
return noExtraFields;
}
return extraFields;
}
private ZipExtraField[] getParseableExtraFields() {
final ZipExtraField[] parseableExtraFields = getParseableExtraFieldsNoCopy();
return (parseableExtraFields == extraFields)
? copyOf(parseableExtraFields) : parseableExtraFields;
}
private ZipExtraField[] copyOf(ZipExtraField[] src){
return copyOf(src, src.length);
}
private ZipExtraField[] copyOf(ZipExtraField[] src, int length){
ZipExtraField[] cpy = new ZipExtraField[length];
System.arraycopy(src, 0, cpy, 0, Math.min(src.length, length));
return cpy;
}
private ZipExtraField[] getMergedFields() {
final ZipExtraField[] zipExtraFields =
copyOf(extraFields, extraFields.length + 1);
zipExtraFields[extraFields.length] = unparseableExtra;
return zipExtraFields;
}
private ZipExtraField[] getUnparseableOnly() {
return unparseableExtra == null
? noExtraFields : new ZipExtraField[] { unparseableExtra };
}
private ZipExtraField[] getAllExtraFields() {
final ZipExtraField[] allExtraFieldsNoCopy = getAllExtraFieldsNoCopy();
return (allExtraFieldsNoCopy == extraFields)
? copyOf(allExtraFieldsNoCopy) : allExtraFieldsNoCopy;
}
/**
* Get all extra fields, including unparseable ones.
* @return An array of all extra fields. Not necessarily a copy of internal data structures, hence private method
*/
private ZipExtraField[] getAllExtraFieldsNoCopy() {
if (extraFields == null) {
return getUnparseableOnly();
}
return unparseableExtra != null ? getMergedFields() : extraFields;
}
/**
* Adds an extra field - replacing an already present extra field
* of the same type.
*
* If no extra field of the same type exists, the field will be
* added as last field.
* @param ze an extra field
* @since 1.1
*/
public void addExtraField(final ZipExtraField ze) {
if (ze instanceof UnparseableExtraFieldData) {
unparseableExtra = (UnparseableExtraFieldData) ze;
} else {
if (extraFields == null) {
extraFields = new ZipExtraField[] {ze};
} else {
if (getExtraField(ze.getHeaderId()) != null){
removeExtraField(ze.getHeaderId());
}
final ZipExtraField[] zipExtraFields =
copyOf(extraFields, extraFields.length + 1);
zipExtraFields[extraFields.length] = ze;
extraFields = zipExtraFields;
}
}
setExtra();
}
/**
* Adds an extra field - replacing an already present extra field
* of the same type.
*
* The new extra field will be the first one.
* @param ze an extra field
* @since 1.1
*/
public void addAsFirstExtraField(final ZipExtraField ze) {
if (ze instanceof UnparseableExtraFieldData) {
unparseableExtra = (UnparseableExtraFieldData) ze;
} else {
if (getExtraField(ze.getHeaderId()) != null){
removeExtraField(ze.getHeaderId());
}
ZipExtraField[] copy = extraFields;
int newLen = extraFields != null ? extraFields.length + 1: 1;
extraFields = new ZipExtraField[newLen];
extraFields[0] = ze;
if (copy != null){
System.arraycopy(copy, 0, extraFields, 1, extraFields.length - 1);
}
}
setExtra();
}
/**
* Remove an extra field.
* @param type the type of extra field to remove
* @since 1.1
*/
public void removeExtraField(final ZipShort type) {
if (extraFields == null) {
throw new java.util.NoSuchElementException();
}
List newResult = new ArrayList();
for (ZipExtraField extraField : extraFields) {
if (!type.equals(extraField.getHeaderId())){
newResult.add(extraField);
}
}
if (extraFields.length == newResult.size()) {
throw new java.util.NoSuchElementException();
}
extraFields = newResult.toArray(new ZipExtraField[newResult.size()]);
setExtra();
}
/**
* Removes unparseable extra field data.
*/
public void removeUnparseableExtraFieldData() {
if (unparseableExtra == null) {
throw new java.util.NoSuchElementException();
}
unparseableExtra = null;
setExtra();
}
/**
* Looks up an extra field by its header id.
*
* @return null if no such field exists.
*/
public ZipExtraField getExtraField(final ZipShort type) {
if (extraFields != null) {
for (ZipExtraField extraField : extraFields) {
if (type.equals(extraField.getHeaderId())) {
return extraField;
}
}
}
return null;
}
/**
* Looks up extra field data that couldn't be parsed correctly.
*
* @return null if no such field exists.
*/
public UnparseableExtraFieldData getUnparseableExtraFieldData() {
return unparseableExtra;
}
/**
* Parses the given bytes as extra field data and consumes any
* unparseable data as an {@link UnparseableExtraFieldData}
* instance.
* @param extra an array of bytes to be parsed into extra fields
* @throws RuntimeException if the bytes cannot be parsed
* @since 1.1
* @throws RuntimeException on error
*/
@Override
public void setExtra(final byte[] extra) throws RuntimeException {
try {
final ZipExtraField[] local =
ExtraFieldUtils.parse(extra, true,
ExtraFieldUtils.UnparseableExtraField.READ);
mergeExtraFields(local, true);
} catch (final ZipException e) {
// actually this is not be possible as of Ant 1.8.1
throw new RuntimeException("Error parsing extra fields for entry: " //NOSONAR
+ getName() + " - " + e.getMessage(), e);
}
}
/**
* Unfortunately {@link java.util.zip.ZipOutputStream
* java.util.zip.ZipOutputStream} seems to access the extra data
* directly, so overriding getExtra doesn't help - we need to
* modify super's data directly.
*
* @since 1.1
*/
protected void setExtra() {
super.setExtra(ExtraFieldUtils.mergeLocalFileDataData(getExtraFields(true)));
}
/**
* Sets the central directory part of extra fields.
*/
public void setCentralDirectoryExtra(final byte[] b) {
try {
final ZipExtraField[] central =
ExtraFieldUtils.parse(b, false,
ExtraFieldUtils.UnparseableExtraField.READ);
mergeExtraFields(central, false);
} catch (final ZipException e) {
throw new RuntimeException(e.getMessage(), e); //NOSONAR
}
}
/**
* Retrieves the extra data for the local file data.
* @return the extra data for local file
* @since 1.1
*/
public byte[] getLocalFileDataExtra() {
final byte[] extra = getExtra();
return extra != null ? extra : EMPTY;
}
/**
* Retrieves the extra data for the central directory.
* @return the central directory extra data
* @since 1.1
*/
public byte[] getCentralDirectoryExtra() {
return ExtraFieldUtils.mergeCentralDirectoryData(getExtraFields(true));
}
/**
* Make this class work in JDK 1.1 like a 1.2 class.
*
* This either stores the size for later usage or invokes
* setCompressedSize via reflection.
* @param size the size to use
* @deprecated since 1.7.
* Use setCompressedSize directly.
* @since 1.2
*/
@Deprecated
public void setComprSize(final long size) {
setCompressedSize(size);
}
/**
* Get the name of the entry.
* @return the entry name
* @since 1.9
*/
@Override
public String getName() {
return name == null ? super.getName() : name;
}
/**
* Is this entry a directory?
* @return true if the entry is a directory
* @since 1.10
*/
@Override
public boolean isDirectory() {
return getName().endsWith("/");
}
/**
* Set the name of the entry.
* @param name the name to use
*/
protected void setName(String name) {
if (name != null && getPlatform() == PLATFORM_FAT
&& name.indexOf("/") == -1) {
name = name.replace('\\', '/');
}
this.name = name;
}
/**
* Gets the uncompressed size of the entry data.
* @return the entry size
*/
@Override
public long getSize() {
return size;
}
/**
* Sets the uncompressed size of the entry data.
* @param size the uncompressed size in bytes
* @exception IllegalArgumentException if the specified size is less
* than 0
*/
@Override
public void setSize(final long size) {
if (size < 0) {
throw new IllegalArgumentException("invalid entry size");
}
this.size = size;
}
/**
* Sets the name using the raw bytes and the string created from
* it by guessing or using the configured encoding.
* @param name the name to use created from the raw bytes using
* the guessed or configured encoding
* @param rawName the bytes originally read as name from the
* archive
*/
protected void setName(final String name, final byte[] rawName) {
setName(name);
this.rawName = rawName;
}
/**
* Returns the raw bytes that made up the name before it has been
* converted using the configured or guessed encoding.
*
* This method will return null if this instance has not been
* read from an archive.
*/
public byte[] getRawName() {
if (rawName != null) {
final byte[] b = new byte[rawName.length];
System.arraycopy(rawName, 0, b, 0, rawName.length);
return b;
}
return null;
}
/**
* Get the hashCode of the entry.
* This uses the name as the hashcode.
* @return a hashcode.
* @since Ant 1.7
*/
@Override
public int hashCode() {
// this method has severe consequences on performance. We cannot rely
// on the super.hashCode() method since super.getName() always return
// the empty string in the current implemention (there's no setter)
// so it is basically draining the performance of a hashmap lookup
return getName().hashCode();
}
/**
* The "general purpose bit" field.
*/
public GeneralPurposeBit getGeneralPurposeBit() {
return gpb;
}
/**
* The "general purpose bit" field.
*/
public void setGeneralPurposeBit(final GeneralPurposeBit b) {
gpb = b;
}
/**
* If there are no extra fields, use the given fields as new extra
* data - otherwise merge the fields assuming the existing fields
* and the new fields stem from different locations inside the
* archive.
* @param f the extra fields to merge
* @param local whether the new fields originate from local data
*/
private void mergeExtraFields(final ZipExtraField[] f, final boolean local)
throws ZipException {
if (extraFields == null) {
setExtraFields(f);
} else {
for (final ZipExtraField element : f) {
ZipExtraField existing;
if (element instanceof UnparseableExtraFieldData) {
existing = unparseableExtra;
} else {
existing = getExtraField(element.getHeaderId());
}
if (existing == null) {
addExtraField(element);
} else {
if (local
|| !(existing
instanceof CentralDirectoryParsingZipExtraField)) {
final byte[] b = element.getLocalFileDataData();
existing.parseFromLocalFileData(b, 0, b.length);
} else {
final byte[] b = element.getCentralDirectoryData();
((CentralDirectoryParsingZipExtraField) existing)
.parseFromCentralDirectoryData(b, 0, b.length);
}
}
}
setExtra();
}
}
/** {@inheritDoc} */
public Date getLastModifiedDate() {
return new Date(getTime());
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
final ZipEntry other = (ZipEntry) obj;
final String myName = getName();
final String otherName = other.getName();
if (myName == null) {
if (otherName != null) {
return false;
}
} else if (!myName.equals(otherName)) {
return false;
}
String myComment = getComment();
String otherComment = other.getComment();
if (myComment == null) {
myComment = "";
}
if (otherComment == null) {
otherComment = "";
}
return getTime() == other.getTime()
&& myComment.equals(otherComment)
&& getInternalAttributes() == other.getInternalAttributes()
&& getPlatform() == other.getPlatform()
&& getExternalAttributes() == other.getExternalAttributes()
&& getMethod() == other.getMethod()
&& getSize() == other.getSize()
&& getCrc() == other.getCrc()
&& getCompressedSize() == other.getCompressedSize()
&& Arrays.equals(getCentralDirectoryExtra(),
other.getCentralDirectoryExtra())
&& Arrays.equals(getLocalFileDataExtra(),
other.getLocalFileDataExtra())
&& gpb.equals(other.gpb);
}
}