src/main/java/org/apache/commons/compress/archivers/zip/ZipArchiveEntry.java - platform/external/apache-commons-compress - Gitiles

 /*
  *  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.commons.compress.archivers.zip;

 import java.io.File;
 import java.util.Date;
 import java.util.LinkedHashMap;
 import java.util.zip.ZipException;
 import org.apache.commons.compress.archivers.ArchiveEntry;

 /**
  * Extension that adds better handling of extra fields and provides
  * access to the internal and external file attributes.
  *
  * @NotThreadSafe
  */
 public class ZipArchiveEntry extends java.util.zip.ZipEntry
     implements ArchiveEntry, Cloneable {

     public static final int PLATFORM_UNIX = 3;
     public static final int PLATFORM_FAT  = 0;
     private static final int SHORT_MASK = 0xFFFF;
     private static final int SHORT_SHIFT = 16;

     private int internalAttributes = 0;
     private int platform = PLATFORM_FAT;
     private long externalAttributes = 0;
     private LinkedHashMap/*<ZipShort, ZipExtraField>*/ extraFields = null;
     private String name = null;

     /**
      * Creates a new zip entry with the specified name.
      * @param name the name of the entry
      */
     public ZipArchiveEntry(String name) {
         super(name);
     }

     /**
      * Creates a new zip entry with fields taken from the specified zip entry.
      * @param entry the entry to get fields from
      * @throws ZipException on error
      */
     public ZipArchiveEntry(java.util.zip.ZipEntry entry) throws ZipException {
         super(entry);
         setName(entry.getName());
         byte[] extra = entry.getExtra();
         if (extra != null) {
             setExtraFields(ExtraFieldUtils.parse(extra));
         } else {
             // initializes extra data to an empty byte array
             setExtra();
         }
     }

     /**
      * Creates a new zip entry with fields taken from the specified zip entry.
      * @param entry the entry to get fields from
      * @throws ZipException on error
      */
     public ZipArchiveEntry(ZipArchiveEntry entry) throws ZipException {
         this((java.util.zip.ZipEntry) entry);
         setInternalAttributes(entry.getInternalAttributes());
         setExternalAttributes(entry.getExternalAttributes());
         setExtraFields(entry.getExtraFields());
     }

     /**
      */
     protected ZipArchiveEntry() {
         super("");
     }

     public ZipArchiveEntry(File inputFile, String entryName) {
         this(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 ZipArchiveEntry
      */
     public Object clone() {
         ZipArchiveEntry e = (ZipArchiveEntry) super.clone();

         e.extraFields = extraFields != null ? (LinkedHashMap) extraFields.clone() : null;
         e.setInternalAttributes(getInternalAttributes());
         e.setExternalAttributes(getExternalAttributes());
         e.setExtraFields(getExtraFields());
         return e;
     }

     /**
      * Retrieves the internal file attributes.
      *
      * @return the internal file attributes
      */
     public int getInternalAttributes() {
         return internalAttributes;
     }

     /**
      * Sets the internal file attributes.
      * @param value an <code>int</code> value
      */
     public void setInternalAttributes(int value) {
         internalAttributes = value;
     }

     /**
      * Retrieves the external file attributes.
      * @return the external file attributes
      */
     public long getExternalAttributes() {
         return externalAttributes;
     }

     /**
      * Sets the external file attributes.
      * @param value an <code>long</code> value
      */
     public void setExternalAttributes(long value) {
         externalAttributes = value;
     }

     /**
      * Sets Unix permissions in a way that is understood by Info-Zip's
      * unzip command.
      * @param mode an <code>int</code> value
      */
     public void setUnixMode(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
      */
     public int getUnixMode() {
         return platform != PLATFORM_UNIX ? 0 :
             (int) ((getExternalAttributes() >> SHORT_SHIFT) & SHORT_MASK);
     }

     /**
      * Platform specification to put into the &quot;version made
      * by&quot; part of the central file header.
      *
      * @return PLATFORM_FAT unless {@link #setUnixMode setUnixMode}
      * has been called, in which case PLATORM_UNIX will be returned.
      */
     public int getPlatform() {
         return platform;
     }

     /**
      * Set the platform (UNIX or FAT).
      * @param platform an <code>int</code> value - 0 is FAT, 3 is UNIX
      */
     protected void setPlatform(int platform) {
         this.platform = platform;
     }

     /**
      * Replaces all currently attached extra fields with the new array.
      * @param fields an array of extra fields
      */
     public void setExtraFields(ZipExtraField[] fields) {
         extraFields = new LinkedHashMap();
         for (int i = 0; i < fields.length; i++) {
             extraFields.put(fields[i].getHeaderId(), fields[i]);
         }
         setExtra();
     }

     /**
      * Retrieves extra fields.
      * @return an array of the extra fields
      */
     public ZipExtraField[] getExtraFields() {
         if (extraFields == null) {
             return new ZipExtraField[0];
         }
         ZipExtraField[] result = new ZipExtraField[extraFields.size()];
         return (ZipExtraField[]) extraFields.values().toArray(result);
     }

     /**
      * Adds an extra fields - replacing an already present extra field
      * of the same type.
      *
      * <p>If no extra field of the same type exists, the field will be
      * added as last field.</p>
      * @param ze an extra field
      */
     public void addExtraField(ZipExtraField ze) {
         if (extraFields == null) {
             extraFields = new LinkedHashMap();
         }
         extraFields.put(ze.getHeaderId(), ze);
         setExtra();
     }

     /**
      * Adds an extra fields - replacing an already present extra field
      * of the same type.
      *
      * <p>The new extra field will be the first one.</p>
      * @param ze an extra field
      */
     public void addAsFirstExtraField(ZipExtraField ze) {
         LinkedHashMap copy = extraFields;
         extraFields = new LinkedHashMap();
         extraFields.put(ze.getHeaderId(), ze);
         if (copy != null) {
             copy.remove(ze.getHeaderId());
             extraFields.putAll(copy);
         }
         setExtra();
     }

     /**
      * Remove an extra fields.
      * @param type the type of extra field to remove
      */
     public void removeExtraField(ZipShort type) {
         if (extraFields == null) {
             throw new java.util.NoSuchElementException();
         }
         if (extraFields.remove(type) == null) {
             throw new java.util.NoSuchElementException();
         }
         setExtra();
     }

     /**
      * Looks up an extra field by its header id.
      *
      * @return null if no such field exists.
      */
     public ZipExtraField getExtraField(ZipShort type) {
         if (extraFields != null) {
             return (ZipExtraField) extraFields.get(type);
         }
         return null;
     }

     /**
      * Throws an Exception if extra data cannot be parsed into extra fields.
      * @param extra an array of bytes to be parsed into extra fields
      * @throws RuntimeException if the bytes cannot be parsed
      * @throws RuntimeException on error
      */
     public void setExtra(byte[] extra) throws RuntimeException {
         try {
             ZipExtraField[] local = ExtraFieldUtils.parse(extra, true);
             mergeExtraFields(local, true);
         } catch (ZipException e) {
             throw new RuntimeException(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.
      */
     protected void setExtra() {
         super.setExtra(ExtraFieldUtils.mergeLocalFileDataData(getExtraFields()));
     }

     /**
      * Sets the central directory part of extra fields.
      */
     public void setCentralDirectoryExtra(byte[] b) {
         try {
             ZipExtraField[] central = ExtraFieldUtils.parse(b, false);
             mergeExtraFields(central, false);
         } catch (ZipException e) {
             throw new RuntimeException(e.getMessage(), e);
         }
     }

     /**
      * Retrieves the extra data for the local file data.
      * @return the extra data for local file
      */
     public byte[] getLocalFileDataExtra() {
         byte[] extra = getExtra();
         return extra != null ? extra : new byte[0];
     }

     /**
      * Retrieves the extra data for the central directory.
      * @return the central directory extra data
      */
     public byte[] getCentralDirectoryExtra() {
         return ExtraFieldUtils.mergeCentralDirectoryData(getExtraFields());
     }

     /**
      * Get the name of the entry.
      * @return the entry name
      */
     public String getName() {
         return name == null ? super.getName() : name;
     }

     /**
      * Is this entry a directory?
      * @return true if the entry is a directory
      */
     public boolean isDirectory() {
         return getName().endsWith("/");
     }

     /**
      * Set the name of the entry.
      * @param name the name to use
      */
     protected void setName(String name) {
         this.name = name;
     }

     /**
      * Get the hashCode of the entry.
      * This uses the name as the hashcode.
      * @return a hashcode.
      */
     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();
     }

     /**
      * 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(ZipExtraField[] f, boolean local)
         throws ZipException {
         if (extraFields == null) {
             setExtraFields(f);
         } else {
             for (int i = 0; i < f.length; i++) {
                 ZipExtraField existing = getExtraField(f[i].getHeaderId());
                 if (existing == null) {
                     addExtraField(f[i]);
                 } else {
                     if (local) {
                         byte[] b = f[i].getLocalFileDataData();
                         existing.parseFromLocalFileData(b, 0, b.length);
                     } else {
                         byte[] b = f[i].getCentralDirectoryData();
                         existing.parseFromCentralDirectoryData(b, 0, b.length);
                     }
                 }
             }
             setExtra();
         }
     }

     /** {@inheritDocs} */
     public Date getLastModifiedDate() {
         return new Date(getTime());
     }

     /* (non-Javadoc)
      * @see java.lang.Object#equals(java.lang.Object)
      */
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }
         ZipArchiveEntry other = (ZipArchiveEntry) obj;
         if (name == null) {
             if (other.name != null) {
                 return false;
             }
         } else if (!name.equals(other.name)) {
             return false;
         }
         return true;
     }
 }
	/*
	* 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.commons.compress.archivers.zip;

	import java.io.File;
	import java.util.Date;
	import java.util.LinkedHashMap;
	import java.util.zip.ZipException;
	import org.apache.commons.compress.archivers.ArchiveEntry;

	/**
	* Extension that adds better handling of extra fields and provides
	* access to the internal and external file attributes.
	*
	* @NotThreadSafe
	*/
	public class ZipArchiveEntry extends java.util.zip.ZipEntry
	implements ArchiveEntry, Cloneable {

	public static final int PLATFORM_UNIX = 3;
	public static final int PLATFORM_FAT = 0;
	private static final int SHORT_MASK = 0xFFFF;
	private static final int SHORT_SHIFT = 16;

	private int internalAttributes = 0;
	private int platform = PLATFORM_FAT;
	private long externalAttributes = 0;
	private LinkedHashMap/<ZipShort, ZipExtraField>/ extraFields = null;
	private String name = null;

	/**
	* Creates a new zip entry with the specified name.
	* @param name the name of the entry
	*/
	public ZipArchiveEntry(String name) {
	super(name);
	}

	/**
	* Creates a new zip entry with fields taken from the specified zip entry.
	* @param entry the entry to get fields from
	* @throws ZipException on error
	*/
	public ZipArchiveEntry(java.util.zip.ZipEntry entry) throws ZipException {
	super(entry);
	setName(entry.getName());
	byte[] extra = entry.getExtra();
	if (extra != null) {
	setExtraFields(ExtraFieldUtils.parse(extra));
	} else {
	// initializes extra data to an empty byte array
	setExtra();
	}
	}

	/**
	* Creates a new zip entry with fields taken from the specified zip entry.
	* @param entry the entry to get fields from
	* @throws ZipException on error
	*/
	public ZipArchiveEntry(ZipArchiveEntry entry) throws ZipException {
	this((java.util.zip.ZipEntry) entry);
	setInternalAttributes(entry.getInternalAttributes());
	setExternalAttributes(entry.getExternalAttributes());
	setExtraFields(entry.getExtraFields());
	}

	/**
	*/
	protected ZipArchiveEntry() {
	super("");
	}

	public ZipArchiveEntry(File inputFile, String entryName) {
	this(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 ZipArchiveEntry
	*/
	public Object clone() {
	ZipArchiveEntry e = (ZipArchiveEntry) super.clone();

	e.extraFields = extraFields != null ? (LinkedHashMap) extraFields.clone() : null;
	e.setInternalAttributes(getInternalAttributes());
	e.setExternalAttributes(getExternalAttributes());
	e.setExtraFields(getExtraFields());
	return e;
	}

	/**
	* Retrieves the internal file attributes.
	*
	* @return the internal file attributes
	*/
	public int getInternalAttributes() {
	return internalAttributes;
	}

	/**
	* Sets the internal file attributes.
	* @param value an <code>int</code> value
	*/
	public void setInternalAttributes(int value) {
	internalAttributes = value;
	}

	/**
	* Retrieves the external file attributes.
	* @return the external file attributes
	*/
	public long getExternalAttributes() {
	return externalAttributes;
	}

	/**
	* Sets the external file attributes.
	* @param value an <code>long</code> value
	*/
	public void setExternalAttributes(long value) {
	externalAttributes = value;
	}

	/**
	* Sets Unix permissions in a way that is understood by Info-Zip's
	* unzip command.
	* @param mode an <code>int</code> value
	*/
	public void setUnixMode(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
	*/
	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 PLATORM_UNIX will be returned.
	*/
	public int getPlatform() {
	return platform;
	}

	/**
	* Set the platform (UNIX or FAT).
	* @param platform an <code>int</code> value - 0 is FAT, 3 is UNIX
	*/
	protected void setPlatform(int platform) {
	this.platform = platform;
	}

	/**
	* Replaces all currently attached extra fields with the new array.
	* @param fields an array of extra fields
	*/
	public void setExtraFields(ZipExtraField[] fields) {
	extraFields = new LinkedHashMap();
	for (int i = 0; i < fields.length; i++) {
	extraFields.put(fields[i].getHeaderId(), fields[i]);
	}
	setExtra();
	}

	/**
	* Retrieves extra fields.
	* @return an array of the extra fields
	*/
	public ZipExtraField[] getExtraFields() {
	if (extraFields == null) {
	return new ZipExtraField[0];
	}
	ZipExtraField[] result = new ZipExtraField[extraFields.size()];
	return (ZipExtraField[]) extraFields.values().toArray(result);
	}

	/**
	* Adds an extra fields - replacing an already present extra field
	* of the same type.
	*
	* <p>If no extra field of the same type exists, the field will be
	* added as last field.</p>
	* @param ze an extra field
	*/
	public void addExtraField(ZipExtraField ze) {
	if (extraFields == null) {
	extraFields = new LinkedHashMap();
	}
	extraFields.put(ze.getHeaderId(), ze);
	setExtra();
	}

	/**
	* Adds an extra fields - replacing an already present extra field
	* of the same type.
	*
	* <p>The new extra field will be the first one.</p>
	* @param ze an extra field
	*/
	public void addAsFirstExtraField(ZipExtraField ze) {
	LinkedHashMap copy = extraFields;
	extraFields = new LinkedHashMap();
	extraFields.put(ze.getHeaderId(), ze);
	if (copy != null) {
	copy.remove(ze.getHeaderId());
	extraFields.putAll(copy);
	}
	setExtra();
	}

	/**
	* Remove an extra fields.
	* @param type the type of extra field to remove
	*/
	public void removeExtraField(ZipShort type) {
	if (extraFields == null) {
	throw new java.util.NoSuchElementException();
	}
	if (extraFields.remove(type) == null) {
	throw new java.util.NoSuchElementException();
	}
	setExtra();
	}

	/**
	* Looks up an extra field by its header id.
	*
	* @return null if no such field exists.
	*/
	public ZipExtraField getExtraField(ZipShort type) {
	if (extraFields != null) {
	return (ZipExtraField) extraFields.get(type);
	}
	return null;
	}

	/**
	* Throws an Exception if extra data cannot be parsed into extra fields.
	* @param extra an array of bytes to be parsed into extra fields
	* @throws RuntimeException if the bytes cannot be parsed
	* @throws RuntimeException on error
	*/
	public void setExtra(byte[] extra) throws RuntimeException {
	try {
	ZipExtraField[] local = ExtraFieldUtils.parse(extra, true);
	mergeExtraFields(local, true);
	} catch (ZipException e) {
	throw new RuntimeException(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.
	*/
	protected void setExtra() {
	super.setExtra(ExtraFieldUtils.mergeLocalFileDataData(getExtraFields()));
	}

	/**
	* Sets the central directory part of extra fields.
	*/
	public void setCentralDirectoryExtra(byte[] b) {
	try {
	ZipExtraField[] central = ExtraFieldUtils.parse(b, false);
	mergeExtraFields(central, false);
	} catch (ZipException e) {
	throw new RuntimeException(e.getMessage(), e);
	}
	}

	/**
	* Retrieves the extra data for the local file data.
	* @return the extra data for local file
	*/
	public byte[] getLocalFileDataExtra() {
	byte[] extra = getExtra();
	return extra != null ? extra : new byte[0];
	}

	/**
	* Retrieves the extra data for the central directory.
	* @return the central directory extra data
	*/
	public byte[] getCentralDirectoryExtra() {
	return ExtraFieldUtils.mergeCentralDirectoryData(getExtraFields());
	}

	/**
	* Get the name of the entry.
	* @return the entry name
	*/
	public String getName() {
	return name == null ? super.getName() : name;
	}

	/**
	* Is this entry a directory?
	* @return true if the entry is a directory
	*/
	public boolean isDirectory() {
	return getName().endsWith("/");
	}

	/**
	* Set the name of the entry.
	* @param name the name to use
	*/
	protected void setName(String name) {
	this.name = name;
	}

	/**
	* Get the hashCode of the entry.
	* This uses the name as the hashcode.
	* @return a hashcode.
	*/
	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();
	}

	/**
	* 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(ZipExtraField[] f, boolean local)
	throws ZipException {
	if (extraFields == null) {
	setExtraFields(f);
	} else {
	for (int i = 0; i < f.length; i++) {
	ZipExtraField existing = getExtraField(f[i].getHeaderId());
	if (existing == null) {
	addExtraField(f[i]);
	} else {
	if (local) {
	byte[] b = f[i].getLocalFileDataData();
	existing.parseFromLocalFileData(b, 0, b.length);
	} else {
	byte[] b = f[i].getCentralDirectoryData();
	existing.parseFromCentralDirectoryData(b, 0, b.length);
	}
	}
	}
	setExtra();
	}
	}

	/** {@inheritDocs} */
	public Date getLastModifiedDate() {
	return new Date(getTime());
	}

	/* (non-Javadoc)
	* @see java.lang.Object#equals(java.lang.Object)
	*/
	public boolean equals(Object obj) {
	if (this == obj) {
	return true;
	}
	if (obj == null \|\| getClass() != obj.getClass()) {
	return false;
	}
	ZipArchiveEntry other = (ZipArchiveEntry) obj;
	if (name == null) {
	if (other.name != null) {
	return false;
	}
	} else if (!name.equals(other.name)) {
	return false;
	}
	return true;
	}
	}