* Returns, whether recreating the archive is forced (default). Setting this option to false means, that the * archiver should compare the timestamps of included files with the timestamp of the target archive and rebuild the * archive only, if the latter timestamp precedes the former timestamps. Checking for timestamps will typically * offer a performance gain (in particular, if the following steps in a build can be suppressed, if an archive isn't * recrated) on the cost that you get inaccurate results from time to time. In particular, removal of source files * won't be detected. *
** An archiver doesn't necessarily support checks for uptodate. If so, setting this option to true will simply be * ignored. The method {@link #isSupportingForced()} may be called to check whether an archiver does support * uptodate checks. *
* * @return True, if the target archive should always be created; false otherwise * @see #setForced(boolean) * @see #isSupportingForced() */ boolean isForced(); /** ** Sets, whether recreating the archive is forced (default). Setting this option to false means, that the archiver * should compare the timestamps of included files with the timestamp of the target archive and rebuild the archive * only, if the latter timestamp precedes the former timestamps. Checking for timestamps will typically offer a * performance gain (in particular, if the following steps in a build can be suppressed, if an archive isn't * recrated) on the cost that you get inaccurate results from time to time. In particular, removal of source files * won't be detected. *
** An archiver doesn't necessarily support checks for uptodate. If so, setting this option to true will simply be * ignored. The method {@link #isSupportingForced()} may be called to check whether an archiver does support * uptodate checks. *
* * @param forced * True, if the target archive should always be created; false otherwise * @see #isForced() * @see #isSupportingForced() */ void setForced( boolean forced ); /** * Returns, whether the archive supports uptodate checks. If so, you may set {@link #setForced(boolean)} to true. * * @return True, if the archiver does support uptodate checks, false otherwise * @see #setForced(boolean) * @see #isForced() */ boolean isSupportingForced(); /** * Returns the behavior of this archiver when duplicate files are detected. */ String getDuplicateBehavior(); /** * Set the behavior of this archiver when duplicate files are detected. One of:If we are going to recreate the archive instead of updating
* it, all resources should be considered as new, if a single one
* is. Because of this, subclasses overriding this method must
* call super.getResourcesToAdd and indicate with the
* third arg if they already know that the archive is
* out-of-date.
If this jar has a classpath attribute in its manifest, we * can assume that it will only require an index of jars listed * there. try to find which classpath entry is most likely the * one the given file name points to.
* *In the absence of a classpath attribute, assume the other * files will be placed inside the same directory as this jar and * use their basename.
* *if there is a classpath and the given file doesn't match any * of its entries, return null.
*/ protected static final String findJarName( String fileName, String[] classpath ) { if ( classpath == null ) { return ( new File( fileName ) ).getName(); } fileName = fileName.replace( File.separatorChar, '/' ); TreeMap matches = new TreeMap( new Comparator() { // longest match comes first public int compare( Object o1, Object o2 ) { if ( ( o1 instanceof String ) && ( o2 instanceof String ) ) { return ( (String) o2 ).length() - ( (String) o1 ).length(); } return 0; } } ); for ( int i = 0; i < classpath.length; i++ ) { if ( fileName.endsWith( classpath[ i ] ) ) { matches.put( classpath[ i ], classpath[ i ] ); } else { int slash = classpath[ i ].indexOf( "/" ); String candidate = classpath[ i ]; while ( slash > -1 ) { candidate = candidate.substring( slash + 1 ); if ( fileName.endsWith( candidate ) ) { matches.put( candidate, classpath[ i ] ); break; } slash = candidate.indexOf( "/" ); } } } return matches.size() == 0 ? null : (String) matches.get( matches.firstKey() ); } /** * Grab lists of all root-level files and all directories * contained in the given archive. */ protected static final void grabFilesAndDirs( String file, List dirs, List files ) throws IOException { ZipFile zf = null; try { zf = new ZipFile( file, "utf-8" ); Enumeration entries = zf.getEntries(); HashSet dirSet = new HashSet(); while ( entries.hasMoreElements() ) { ZipEntry ze = (ZipEntry) entries.nextElement(); String name = ze.getName(); // avoid index for manifest-only jars. if (!name.equals(META_INF_NAME) && !name.equals(META_INF_NAME+"/") && !name.equals(INDEX_NAME) && !name.equals(MANIFEST_NAME)) { if ( ze.isDirectory() ) { dirSet.add( name ); } else if ( name.indexOf( "/" ) == -1 ) { files.add( name ); } else { // a file, not in the root // since the jar may be one without directory // entries, add the parent dir of this file as // well. dirSet.add( name.substring( 0, name.lastIndexOf( "/" ) + 1 ) ); } } } dirs.addAll( dirSet ); } finally { if ( zf != null ) { zf.close(); } } } } plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/jar/Manifest.java 0000664 0000000 0000000 00000115201 11454043605 0033144 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.jar; /** * * Copyright 2004 The Apache Software Foundation * * Licensed 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. */ import org.codehaus.plexus.archiver.ArchiverException; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.Reader; import java.io.StringWriter; import java.io.UnsupportedEncodingException; import java.util.Enumeration; import java.util.Hashtable; import java.util.StringTokenizer; import java.util.Vector; /** * Holds the data of a jar manifest. * * Manifests are processed according to the * {@link Jar * file specification.}. * Specifically, a manifest element consists of * a set of attributes and sections. These sections in turn may contain * attributes. Note in particular that this may result in manifest lines * greater than 72 bytes being wrapped and continued on the next * line. If an application can not handle the continuation mechanism, it * is a defect in the application, not this task. * * @since Ant 1.4 */ public class Manifest { /** * The standard manifest version header */ public static final String ATTRIBUTE_MANIFEST_VERSION = "Manifest-Version"; /** * The standard Signature Version header */ public static final String ATTRIBUTE_SIGNATURE_VERSION = "Signature-Version"; /** * The Name Attribute is the first in a named section */ public static final String ATTRIBUTE_NAME = "Name"; /** * The From Header is disallowed in a Manifest */ public static final String ATTRIBUTE_FROM = "From"; /** * The Class-Path Header is special - it can be duplicated */ public static final String ATTRIBUTE_CLASSPATH = "Class-Path"; /** * Default Manifest version if one is not specified */ public static final String DEFAULT_MANIFEST_VERSION = "1.0"; /** * The max length of a line in a Manifest */ public static final int MAX_LINE_LENGTH = 72; /** * Max length of a line section which is continued. Need to allow * for the CRLF. */ public static final int MAX_SECTION_LENGTH = MAX_LINE_LENGTH - 2; /** * The End-Of-Line marker in manifests */ public static final String EOL = "\r\n"; /** * An attribute for the manifest. * Those attributes that are not nested into a section will be added to the "Main" section. */ public static class Attribute { /** * The attribute's name */ private String name = null; /** * The attribute's value */ private Vector values = new Vector(); /** * For multivalued attributes, this is the index of the attribute * currently being defined. */ private int currentIndex = 0; /** * Construct an empty attribute */ public Attribute() { } /** * Construct an attribute by parsing a line from the Manifest * * @param line the line containing the attribute name and value * @throws ManifestException if the line is not valid */ public Attribute( String line ) throws ManifestException { parse( line ); } /** * Construct a manifest by specifying its name and value * * @param name the attribute's name * @param value the Attribute's value */ public Attribute( String name, String value ) { this.name = name; setValue( value ); } /** * @see java.lang.Object#hashCode */ public int hashCode() { int hashCode = 0; if ( name != null ) { hashCode += name.hashCode(); } hashCode += values.hashCode(); return hashCode; } /** * @see java.lang.Object#equals */ public boolean equals( Object rhs ) { if ( rhs == null || rhs.getClass() != getClass() ) { return false; } if ( rhs == this ) { return true; } Attribute rhsAttribute = (Attribute) rhs; String lhsKey = getKey(); String rhsKey = rhsAttribute.getKey(); if ( ( lhsKey == null && rhsKey != null ) || ( lhsKey != null && rhsKey == null ) || !lhsKey.equals( rhsKey ) ) { return false; } if ( rhsAttribute.values == null ) { return false; } return values.equals( rhsAttribute.values ); } /** * Parse a line into name and value pairs * * @param line the line to be parsed * @throws ManifestException if the line does not contain a colon * separating the name and value */ public void parse( String line ) throws ManifestException { int index = line.indexOf( ": " ); if ( index == -1 ) { throw new ManifestException( "Manifest line \"" + line + "\" is not valid as it does not " + "contain a name and a value separated by ': ' " ); } name = line.substring( 0, index ); setValue( line.substring( index + 2 ) ); } /** * Set the Attribute's name; required * * @param name the attribute's name */ public void setName( String name ) { this.name = name; } /** * Get the Attribute's name * * @return the attribute's name. */ public String getName() { return name; } /** * Get the attribute's Key - its name in lower case. * * @return the attribute's key. */ public String getKey() { if ( name == null ) { return null; } return name.toLowerCase(); } /** * Set the Attribute's value; required * * @param value the attribute's value */ public void setValue( String value ) { if ( currentIndex >= values.size() ) { values.addElement( value ); currentIndex = values.size() - 1; } else { values.setElementAt( value, currentIndex ); } } /** * Get the Attribute's value. * * @return the attribute's value. */ public String getValue() { if ( values.size() == 0 ) { return null; } String fullValue = ""; for ( Enumeration e = getValues(); e.hasMoreElements(); ) { String value = (String) e.nextElement(); fullValue += value + " "; } return fullValue.trim(); } /** * Add a new value to this attribute - making it multivalued. * * @param value the attribute's additional value */ public void addValue( String value ) { currentIndex++; setValue( value ); } /** * Get all the attribute's values. * * @return an enumeration of the attributes values */ public Enumeration getValues() { return values.elements(); } /** * Add a continuation line from the Manifest file. * * When lines are too long in a manifest, they are continued on the * next line by starting with a space. This method adds the continuation * data to the attribute value by skipping the first character. * * @param line the continuation line. */ public void addContinuation( String line ) { String currentValue = (String) values.elementAt( currentIndex ); setValue( currentValue + line.substring( 1 ) ); } /** * Write the attribute out to a print writer. * * @param writer the Writer to which the attribute is written * @throws IOException if the attribute value cannot be written */ public void write( PrintWriter writer ) throws IOException { StringWriter sWriter = new StringWriter(); PrintWriter bufferWriter = new PrintWriter( sWriter ); for ( Enumeration e = getValues(); e.hasMoreElements(); ) { writeValue( bufferWriter, (String) e.nextElement() ); } byte[] convertedToUtf8 = sWriter.toString().getBytes( "UTF-8" ); writer.print( new String( convertedToUtf8, "UTF-8" ) ); } /** * Write a single attribute value out. Should handle multiple lines of attribute value. * * @param writer the Writer to which the attribute is written * @param value the attribute value * @throws IOException if the attribute value cannot be written */ private void writeValue( PrintWriter writer, String value ) throws IOException { String nameValue = name + ": " + value; StringTokenizer tokenizer = new StringTokenizer( nameValue, "\n\r" ); String prefix = ""; while ( tokenizer.hasMoreTokens() ) { writeLine( writer, prefix + tokenizer.nextToken() ); prefix = " "; } } /** * Write a single Manifest line. Should handle more than 72 characters of line * * @param writer the Writer to which the attribute is written * @param line the manifest line to be written */ private void writeLine( PrintWriter writer, String line ) throws IOException { while ( line.getBytes().length > MAX_LINE_LENGTH ) { // try to find a MAX_LINE_LENGTH byte section int breakIndex = MAX_SECTION_LENGTH; String section = line.substring( 0, breakIndex ); while ( section.getBytes().length > MAX_SECTION_LENGTH && breakIndex > 0 ) { breakIndex--; section = line.substring( 0, breakIndex ); } if ( breakIndex == 0 ) { throw new IOException( "Unable to write manifest line " + line ); } writer.print( section + EOL ); line = " " + line.substring( breakIndex ); } writer.print( line + EOL ); } } /** * A manifest section - you can nest attribute elements into sections. * A section consists of a set of attribute values, * separated from other sections by a blank line. */ public static class Section { /** * Warnings for this section */ private Vector warnings = new Vector(); /** * The section's name if any. The main section in a * manifest is unnamed. */ private String name = null; /** * The section's attributes. */ private Hashtable attributes = new Hashtable(); /** * Index used to retain the attribute ordering */ private Vector attributeIndex = new Vector(); /** * The name of the section; optional -default is the main section. * * @param name the section's name */ public void setName( String name ) { this.name = name; } /** * Get the Section's name. * * @return the section's name. */ public String getName() { return name; } /** * Read a section through a reader. * * @param reader the reader from which the section is read * @return the name of the next section if it has been read as * part of this section - This only happens if the * Manifest is malformed. * @throws ManifestException if the section is not valid according * to the JAR spec * @throws IOException if the section cannot be read from the reader. */ public String read( BufferedReader reader ) throws ManifestException, IOException { Attribute attribute = null; while ( true ) { String line = reader.readLine(); if ( line == null || line.length() == 0 ) { return null; } if ( line.charAt( 0 ) == ' ' ) { // continuation line if ( attribute == null ) { if ( name != null ) { // a continuation on the first line is a // continuation of the name - concatenate this // line and the name name += line.substring( 1 ); } else { throw new ManifestException( "Can't start an " + "attribute with a continuation line " + line ); } } else { attribute.addContinuation( line ); } } else { attribute = new Attribute( line ); String nameReadAhead = addAttributeAndCheck( attribute ); // refresh attribute in case of multivalued attributes. attribute = getAttribute( attribute.getKey() ); if ( nameReadAhead != null ) { return nameReadAhead; } } } } /** * Merge in another section * * @param section the section to be merged with this one. * @throws ManifestException if the sections cannot be merged. */ public void merge( Section section ) throws ManifestException { if ( name == null && section.getName() != null || name != null && !( name.equalsIgnoreCase( section.getName() ) ) ) { throw new ManifestException( "Unable to merge sections " + "with different names" ); } Enumeration e = section.getAttributeKeys(); Attribute classpathAttribute = null; while ( e.hasMoreElements() ) { String attributeName = (String) e.nextElement(); Attribute attribute = section.getAttribute( attributeName ); if ( attributeName.equalsIgnoreCase( ATTRIBUTE_CLASSPATH ) ) { if ( classpathAttribute == null ) { classpathAttribute = new Attribute(); classpathAttribute.setName( ATTRIBUTE_CLASSPATH ); } Enumeration cpe = attribute.getValues(); while ( cpe.hasMoreElements() ) { String value = (String) cpe.nextElement(); classpathAttribute.addValue( value ); } } else { // the merge file always wins storeAttribute( attribute ); } } if ( classpathAttribute != null ) { // the merge file *always* wins, even for Class-Path storeAttribute( classpathAttribute ); } // add in the warnings Enumeration warnEnum = section.warnings.elements(); while ( warnEnum.hasMoreElements() ) { warnings.addElement( warnEnum.nextElement() ); } } /** * Write the section out to a print writer. * * @param writer the Writer to which the section is written * @throws IOException if the section cannot be written */ public void write( PrintWriter writer ) throws IOException { if ( name != null ) { Attribute nameAttr = new Attribute( ATTRIBUTE_NAME, name ); nameAttr.write( writer ); } Enumeration e = getAttributeKeys(); while ( e.hasMoreElements() ) { String key = (String) e.nextElement(); Attribute attribute = getAttribute( key ); attribute.write( writer ); } writer.print( EOL ); } /** * Get a attribute of the section * * @param attributeName the name of the attribute * @return a Manifest.Attribute instance if the attribute is * single-valued, otherwise a Vector of Manifest.Attribute * instances. */ public Attribute getAttribute( String attributeName ) { return (Attribute) attributes.get( attributeName.toLowerCase() ); } /** * Get the attribute keys. * * @return an Enumeration of Strings, each string being the lower case * key of an attribute of the section. */ public Enumeration getAttributeKeys() { return attributeIndex.elements(); } /** * Get the value of the attribute with the name given. * * @param attributeName the name of the attribute to be returned. * @return the attribute's value or null if the attribute does not exist * in the section */ public String getAttributeValue( String attributeName ) { Attribute attribute = getAttribute( attributeName.toLowerCase() ); if ( attribute == null ) { return null; } return attribute.getValue(); } /** * Remove tge given attribute from the section * * @param attributeName the name of the attribute to be removed. */ public void removeAttribute( String attributeName ) { String key = attributeName.toLowerCase(); attributes.remove( key ); attributeIndex.removeElement( key ); } /** * Add an attribute to the section. * * @param attribute the attribute to be added to the section * @throws ManifestException if the attribute is not valid. */ public void addConfiguredAttribute( Attribute attribute ) throws ManifestException { String check = addAttributeAndCheck( attribute ); if ( check != null ) { throw new ManifestException( "Specify the section name using " + "the \"name\" attribute of thefalse.
*
* @param preserveLeadingSlashes the leading slashes flag.
*/
public void setPreserveLeadingSlashes( boolean preserveLeadingSlashes )
{
this.preserveLeadingSlashes = preserveLeadingSlashes;
}
}
/**
* Valid Modes for Compression attribute to Tar Task
*/
public static final class TarCompressionMethod
extends EnumeratedAttribute
{
// permissible values for compression attribute
/**
* No compression
*/
private static final String NONE = "none";
/**
* GZIP compression
*/
private static final String GZIP = "gzip";
/**
* BZIP2 compression
*/
private static final String BZIP2 = "bzip2";
/**
* Default constructor
*/
public TarCompressionMethod()
{
super();
try
{
setValue( NONE );
}
catch ( ArchiverException ae )
{
//Do nothing
}
}
/**
* Get valid enumeration values.
*
* @return valid enumeration values
*/
public String[] getValues()
{
return new String[]{NONE, GZIP, BZIP2};
}
/**
* This method wraps the output stream with the
* corresponding compression method
*
* @param ostream output stream
* @return output stream with on-the-fly compression
* @throws IOException thrown if file is not writable
*/
private OutputStream compress( final OutputStream ostream )
throws IOException
{
final String value = getValue();
if ( GZIP.equals( value ) )
{
return new GZIPOutputStream( ostream );
}
else
{
if ( BZIP2.equals( value ) )
{
ostream.write( 'B' );
ostream.write( 'Z' );
return new CBZip2OutputStream( ostream );
}
}
return ostream;
}
}
public boolean isSupportingForced() {
return true;
}
protected void cleanUp()
{
super.cleanUp();
tOut = null;
}
protected void close()
throws IOException
{
if ( tOut != null )
{
try
{
// close up
tOut.close();
}
catch ( IOException e )
{
// ignore
}
}
}
protected String getArchiveType()
{
return "TAR";
}
}
TarBZip2UnArchiver.java 0000664 0000000 0000000 00000003015 11454043605 0034714 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
/**
*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.bzip2.BZip2UnArchiver;
import org.codehaus.plexus.archiver.tar.TarUnArchiver.UntarCompressionMethod;
import java.io.File;
import java.io.IOException;
/**
* Extract files in tar with bzip2 compression
* @author Dan Tran
* @version $Revision: $
*/
public class TarBZip2UnArchiver
extends TarUnArchiver
{
public TarBZip2UnArchiver()
{
this.setupCompressionMethod();
}
public TarBZip2UnArchiver( File sourceFile )
{
super( sourceFile );
this.setupCompressionMethod();
}
private void setupCompressionMethod()
{
UntarCompressionMethod untarCompressionMethod = new UntarCompressionMethod( UntarCompressionMethod.BZIP2 );
this.setCompression( untarCompressionMethod );
}
}
plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar/TarBuffer.java 0000664 0000000 0000000 00000030701 11454043605 0033271 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.tar;
/*
* Copyright 2000,2002,2004 The Apache Software Foundation
*
* Licensed 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.
*
*/
/*
* This package is based on the work done by Timothy Gerard Endres
* (time@ice.com) to whom the Ant project is very grateful for his great code.
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* The TarBuffer class implements the tar archive concept
* of a buffered input stream. This concept goes back to the
* days of blocked tape drives and special io devices. In the
* Java universe, the only real function that this class
* performs is to ensure that files have the correct "block"
* size, or other tars will complain.
*
* You should never have a need to access this class directly.
* TarBuffers are created by Tar IO Streams.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.tar.TarBuffer v1.12
*/
public class TarBuffer
{
public static final int DEFAULT_RCDSIZE = ( 512 );
public static final int DEFAULT_BLKSIZE = ( DEFAULT_RCDSIZE * 20 );
private InputStream inStream;
private OutputStream outStream;
private byte[] blockBuffer;
private int currBlkIdx;
private int currRecIdx;
private int blockSize;
private int recordSize;
private int recsPerBlock;
private boolean debug;
public TarBuffer( InputStream inStream )
{
this( inStream, TarBuffer.DEFAULT_BLKSIZE );
}
public TarBuffer( InputStream inStream, int blockSize )
{
this( inStream, blockSize, TarBuffer.DEFAULT_RCDSIZE );
}
public TarBuffer( InputStream inStream, int blockSize, int recordSize )
{
this.inStream = inStream;
this.outStream = null;
this.initialize( blockSize, recordSize );
}
public TarBuffer( OutputStream outStream )
{
this( outStream, TarBuffer.DEFAULT_BLKSIZE );
}
public TarBuffer( OutputStream outStream, int blockSize )
{
this( outStream, blockSize, TarBuffer.DEFAULT_RCDSIZE );
}
public TarBuffer( OutputStream outStream, int blockSize, int recordSize )
{
this.inStream = null;
this.outStream = outStream;
this.initialize( blockSize, recordSize );
}
/**
* Initialization common to all constructors.
*/
private void initialize( int blockSize, int recordSize )
{
this.debug = false;
this.blockSize = blockSize;
this.recordSize = recordSize;
this.recsPerBlock = ( this.blockSize / this.recordSize );
this.blockBuffer = new byte[this.blockSize];
if ( this.inStream != null )
{
this.currBlkIdx = -1;
this.currRecIdx = this.recsPerBlock;
}
else
{
this.currBlkIdx = 0;
this.currRecIdx = 0;
}
}
/**
* Get the TAR Buffer's block size. Blocks consist of multiple records.
*/
public int getBlockSize()
{
return this.blockSize;
}
/**
* Get the TAR Buffer's record size.
*/
public int getRecordSize()
{
return this.recordSize;
}
/**
* Set the debugging flag for the buffer.
*
* @param debug If true, print debugging output.
*/
public void setDebug( boolean debug )
{
this.debug = debug;
}
/**
* Determine if an archive record indicate End of Archive. End of
* archive is indicated by a record that consists entirely of null bytes.
*
* @param record The record data to check.
*/
public boolean isEOFRecord( byte[] record )
{
for ( int i = 0, sz = this.getRecordSize(); i < sz; ++i )
{
if ( record[ i ] != 0 )
{
return false;
}
}
return true;
}
/**
* Skip over a record on the input stream.
*/
public void skipRecord()
throws IOException
{
if ( this.debug )
{
System.err.println( "SkipRecord: recIdx = " + this.currRecIdx
+ " blkIdx = " + this.currBlkIdx );
}
if ( this.inStream == null )
{
throw new IOException( "reading (via skip) from an output buffer" );
}
if ( this.currRecIdx >= this.recsPerBlock )
{
if ( !this.readBlock() )
{
return; // UNDONE
}
}
this.currRecIdx++;
}
/**
* Read a record from the input stream and return the data.
*
* @return The record data.
*/
public byte[] readRecord()
throws IOException
{
if ( this.debug )
{
System.err.println( "ReadRecord: recIdx = " + this.currRecIdx
+ " blkIdx = " + this.currBlkIdx );
}
if ( this.inStream == null )
{
throw new IOException( "reading from an output buffer" );
}
if ( this.currRecIdx >= this.recsPerBlock )
{
if ( !this.readBlock() )
{
return null;
}
}
byte[] result = new byte[this.recordSize];
System.arraycopy( this.blockBuffer,
( this.currRecIdx * this.recordSize ), result, 0,
this.recordSize );
this.currRecIdx++;
return result;
}
/**
* @return false if End-Of-File, else true
*/
private boolean readBlock()
throws IOException
{
if ( this.debug )
{
System.err.println( "ReadBlock: blkIdx = " + this.currBlkIdx );
}
if ( this.inStream == null )
{
throw new IOException( "reading from an output buffer" );
}
this.currRecIdx = 0;
int offset = 0;
int bytesNeeded = this.blockSize;
while ( bytesNeeded > 0 )
{
long numBytes = this.inStream.read( this.blockBuffer, offset,
bytesNeeded );
//
// NOTE
// We have fit EOF, and the block is not full!
//
// This is a broken archive. It does not follow the standard
// blocking algorithm. However, because we are generous, and
// it requires little effort, we will simply ignore the error
// and continue as if the entire block were read. This does
// not appear to break anything upstream. We used to return
// false in this case.
//
// Thanks to 'Yohann.Roussel@alcatel.fr' for this fix.
//
if ( numBytes == -1 )
{
break;
}
offset += numBytes;
bytesNeeded -= numBytes;
if ( numBytes != this.blockSize )
{
if ( this.debug )
{
System.err.println( "ReadBlock: INCOMPLETE READ "
+ numBytes + " of " + this.blockSize
+ " bytes read." );
}
}
}
this.currBlkIdx++;
return true;
}
/**
* Get the current block number, zero based.
*
* @return The current zero based block number.
*/
public int getCurrentBlockNum()
{
return this.currBlkIdx;
}
/**
* Get the current record number, within the current block, zero based.
* Thus, current offset = (currentBlockNum * recsPerBlk) + currentRecNum.
*
* @return The current zero based record number.
*/
public int getCurrentRecordNum()
{
return this.currRecIdx - 1;
}
/**
* Write an archive record to the archive.
*
* @param record The record data to write to the archive.
*/
public void writeRecord( byte[] record )
throws IOException
{
if ( this.debug )
{
System.err.println( "WriteRecord: recIdx = " + this.currRecIdx
+ " blkIdx = " + this.currBlkIdx );
}
if ( this.outStream == null )
{
throw new IOException( "writing to an input buffer" );
}
if ( record.length != this.recordSize )
{
throw new IOException( "record to write has length '"
+ record.length
+ "' which is not the record size of '"
+ this.recordSize + "'" );
}
if ( this.currRecIdx >= this.recsPerBlock )
{
this.writeBlock();
}
System.arraycopy( record, 0, this.blockBuffer,
( this.currRecIdx * this.recordSize ),
this.recordSize );
this.currRecIdx++;
}
/**
* Write an archive record to the archive, where the record may be
* inside of a larger array buffer. The buffer must be "offset plus
* record size" long.
*
* @param buf The buffer containing the record data to write.
* @param offset The offset of the record data within buf.
*/
public void writeRecord( byte[] buf, int offset )
throws IOException
{
if ( this.debug )
{
System.err.println( "WriteRecord: recIdx = " + this.currRecIdx
+ " blkIdx = " + this.currBlkIdx );
}
if ( this.outStream == null )
{
throw new IOException( "writing to an input buffer" );
}
if ( ( offset + this.recordSize ) > buf.length )
{
throw new IOException( "record has length '" + buf.length
+ "' with offset '" + offset
+ "' which is less than the record size of '"
+ this.recordSize + "'" );
}
if ( this.currRecIdx >= this.recsPerBlock )
{
this.writeBlock();
}
System.arraycopy( buf, offset, this.blockBuffer,
( this.currRecIdx * this.recordSize ),
this.recordSize );
this.currRecIdx++;
}
/**
* Write a TarBuffer block to the archive.
*/
private void writeBlock()
throws IOException
{
if ( this.debug )
{
System.err.println( "WriteBlock: blkIdx = " + this.currBlkIdx );
}
if ( this.outStream == null )
{
throw new IOException( "writing to an input buffer" );
}
this.outStream.write( this.blockBuffer, 0, this.blockSize );
this.outStream.flush();
this.currRecIdx = 0;
this.currBlkIdx++;
}
/**
* Flush the current data block if it has any data in it.
*/
private void flushBlock()
throws IOException
{
if ( this.debug )
{
System.err.println( "TarBuffer.flushBlock() called." );
}
if ( this.outStream == null )
{
throw new IOException( "writing to an input buffer" );
}
if ( this.currRecIdx > 0 )
{
this.writeBlock();
}
}
/**
* Close the TarBuffer. If this is an output buffer, also flush the
* current block before closing.
*/
public void close()
throws IOException
{
if ( this.debug )
{
System.err.println( "TarBuffer.closeBuffer()." );
}
if ( this.outStream != null )
{
this.flushBlock();
if ( this.outStream != System.out
&& this.outStream != System.err )
{
this.outStream.close();
this.outStream = null;
}
}
else if ( this.inStream != null )
{
if ( this.inStream != System.in )
{
this.inStream.close();
this.inStream = null;
}
}
}
}
TarCompressionMethod.java 0000664 0000000 0000000 00000003110 11454043605 0035435 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
/*
* Copyright 2000-2004 The Apache Software Foundation
*
* Licensed 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.
*
*/
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.util.EnumeratedAttribute;
/**
* Valid Modes for Compression attribute to Tar Task
*/
public final class TarCompressionMethod
extends EnumeratedAttribute
{
// permissible values for compression attribute
/**
* No compression
*/
private static final String NONE = "none";
/**
* GZIP compression
*/
private static final String GZIP = "gzip";
/**
* BZIP2 compression
*/
private static final String BZIP2 = "bzip2";
/**
* Default constructor
*/
public TarCompressionMethod()
throws ArchiverException
{
super();
setValue( NONE );
}
/**
* Get valid enumeration values.
*
* @return valid enumeration values
*/
public String[] getValues()
{
return new String[]{NONE, GZIP, BZIP2};
}
}
plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar/TarConstants.java0000664 0000000 0000000 00000006511 11454043605 0034036 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.tar;
/*
* Copyright 2000-2002,2004 The Apache Software Foundation
*
* Licensed 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.
*
*/
/*
* This package is based on the work done by Timothy Gerard Endres
* (time@ice.com) to whom the Ant project is very grateful for his great code.
*/
/**
* This interface contains all the definitions used in the package.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.tar.TarConstants v1.13
*/
public interface TarConstants
{
/**
* The length of the name field in a header buffer.
*/
int NAMELEN = 100;
/**
* The length of the mode field in a header buffer.
*/
int MODELEN = 8;
/**
* The length of the user id field in a header buffer.
*/
int UIDLEN = 8;
/**
* The length of the group id field in a header buffer.
*/
int GIDLEN = 8;
/**
* The length of the checksum field in a header buffer.
*/
int CHKSUMLEN = 8;
/**
* The length of the size field in a header buffer.
*/
int SIZELEN = 12;
/**
* The length of the magic field in a header buffer.
*/
int MAGICLEN = 8;
/**
* The length of the modification time field in a header buffer.
*/
int MODTIMELEN = 12;
/**
* The length of the user name field in a header buffer.
*/
int UNAMELEN = 32;
/**
* The length of the group name field in a header buffer.
*/
int GNAMELEN = 32;
/**
* The length of the devices field in a header buffer.
*/
int DEVLEN = 8;
/**
* LF_ constants represent the "link flag" of an entry, or more commonly,
* the "entry type". This is the "old way" of indicating a normal file.
*/
byte LF_OLDNORM = 0;
/**
* Normal file type.
*/
byte LF_NORMAL = (byte) '0';
/**
* Link file type.
*/
byte LF_LINK = (byte) '1';
/**
* Symbolic link file type.
*/
byte LF_SYMLINK = (byte) '2';
/**
* Character device file type.
*/
byte LF_CHR = (byte) '3';
/**
* Block device file type.
*/
byte LF_BLK = (byte) '4';
/**
* Directory file type.
*/
byte LF_DIR = (byte) '5';
/**
* FIFO (pipe) file type.
*/
byte LF_FIFO = (byte) '6';
/**
* Contiguous file type.
*/
byte LF_CONTIG = (byte) '7';
/**
* The magic tag representing a POSIX tar archive.
*/
String TMAGIC = "ustar";
/**
* The magic tag representing a GNU tar archive.
*/
String GNU_TMAGIC = "ustar ";
/**
* The namr of the GNU tar entry which contains a long name.
*/
String GNU_LONGLINK = "././@LongLink";
/**
* Identifies the *next* file on the tape as having a long name.
*/
byte LF_GNUTYPE_LONGNAME = (byte) 'L';
}
plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar/TarEntry.java 0000664 0000000 0000000 00000045701 11454043605 0033167 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.tar;
/*
* Copyright 2000-2004 The Apache Software Foundation
*
* Licensed 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.
*
*/
/*
* This package is based on the work done by Timothy Gerard Endres
* (time@ice.com) to whom the Ant project is very grateful for his great code.
*/
import java.io.File;
import java.util.Date;
import java.util.Locale;
import org.codehaus.plexus.archiver.ArchiveFile;
/**
* This class represents an entry in a Tar archive. It consists
* of the entry's header, as well as the entry's File. Entries
* can be instantiated in one of three ways, depending on how
* they are to be used.
*
* TarEntries that are created from the header bytes read from
* an archive are instantiated with the TarEntry( byte[] )
* constructor. These entries will be used when extracting from
* or listing the contents of an archive. These entries have their
* header filled in using the header bytes. They also set the File
* to null, since they reference an archive entry not a file.
*
* TarEntries that are created from Files that are to be written
* into an archive are instantiated with the TarEntry( File )
* constructor. These entries have their header filled in using
* the File's information. They also keep a reference to the File
* for convenience when writing entries.
*
* Finally, TarEntries can be constructed from nothing but a name.
* This allows the programmer to construct the entry by hand, for
* instance when only an InputStream is available for writing to
* the archive, and the header information is constructed from
* other information. In this case the header fields are set to
* defaults and the File is set to null.
*
*
* The C structure for a Tar Entry's header is:
*
* struct header {
* char name[NAMSIZ];
* char mode[8];
* char uid[8];
* char gid[8];
* char size[12];
* char mtime[12];
* char chksum[8];
* char linkflag;
* char linkname[NAMSIZ];
* char magic[8];
* char uname[TUNMLEN];
* char gname[TGNMLEN];
* char devmajor[8];
* char devminor[8];
* } header;
*
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.tar.TarEntry v1.22
*/
public class TarEntry
implements TarConstants, ArchiveFile.Entry
{
/**
* The entry's name.
*/
private StringBuffer name;
/**
* The entry's permission mode.
*/
private int mode;
/**
* The entry's user id.
*/
private int userId;
/**
* The entry's group id.
*/
private int groupId;
/**
* The entry's size.
*/
private long size;
/**
* The entry's modification time.
*/
private long modTime;
/**
* The entry's checksum.
*/
private int checkSum;
/**
* The entry's link flag.
*/
private byte linkFlag;
/**
* The entry's link name.
*/
private StringBuffer linkName;
/**
* The entry's magic tag.
*/
private StringBuffer magic;
/**
* The entry's user name.
*/
private StringBuffer userName;
/**
* The entry's group name.
*/
private StringBuffer groupName;
/**
* The entry's major device number.
*/
private int devMajor;
/**
* The entry's minor device number.
*/
private int devMinor;
/**
* The entry's file reference
*/
private File file;
/**
* Maximum length of a user's name in the tar file
*/
public static final int MAX_NAMELEN = 31;
/**
* Default permissions bits for directories
*/
public static final int DEFAULT_DIR_MODE = 040755;
/**
* Default permissions bits for files
*/
public static final int DEFAULT_FILE_MODE = 0100644;
/**
* Convert millis to seconds
*/
public static final int MILLIS_PER_SECOND = 1000;
/**
* Construct an empty entry and prepares the header values.
*/
private TarEntry()
{
this.magic = new StringBuffer( TMAGIC );
this.name = new StringBuffer();
this.linkName = new StringBuffer();
String user = System.getProperty( "user.name", "" );
if ( user.length() > MAX_NAMELEN )
{
user = user.substring( 0, MAX_NAMELEN );
}
this.userId = 0;
this.groupId = 0;
this.userName = new StringBuffer( user );
this.groupName = new StringBuffer( "" );
this.file = null;
}
/**
* Construct an entry with only a name. This allows the programmer
* to construct the entry's header "by hand". File is set to null.
*
* @param name the entry name
*/
public TarEntry( String name )
{
this();
boolean isDir = name.endsWith( "/" );
this.devMajor = 0;
this.devMinor = 0;
this.name = new StringBuffer( name );
this.mode = isDir ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE;
this.linkFlag = isDir ? LF_DIR : LF_NORMAL;
this.userId = 0;
this.groupId = 0;
this.size = 0;
this.modTime = ( new Date() ).getTime() / MILLIS_PER_SECOND;
this.linkName = new StringBuffer( "" );
this.userName = new StringBuffer( "" );
this.groupName = new StringBuffer( "" );
this.devMajor = 0;
this.devMinor = 0;
}
/**
* Construct an entry with a name an a link flag.
*
* @param name the entry name
* @param linkFlag the entry link flag.
*/
public TarEntry( String name, byte linkFlag )
{
this( name );
this.linkFlag = linkFlag;
}
/**
* Construct an entry for a file. File is set to file, and the
* header is constructed from information from the file.
*
* @param file The file that the entry represents.
*/
public TarEntry( File file )
{
this();
this.file = file;
String name = file.getPath();
String osname = System.getProperty( "os.name" ).toLowerCase( Locale.US );
if ( osname != null )
{
// Strip off drive letters!
// REVIEW Would a better check be "(File.separator == '\')"?
if ( osname.startsWith( "windows" ) )
{
if ( name.length() > 2 )
{
char ch1 = name.charAt( 0 );
char ch2 = name.charAt( 1 );
if ( ch2 == ':'
&& ( ( ch1 >= 'a' && ch1 <= 'z' )
|| ( ch1 >= 'A' && ch1 <= 'Z' ) ) )
{
name = name.substring( 2 );
}
}
}
else if ( osname.indexOf( "netware" ) > -1 )
{
int colon = name.indexOf( ':' );
if ( colon != -1 )
{
name = name.substring( colon + 1 );
}
}
}
name = name.replace( File.separatorChar, '/' );
// No absolute pathnames
// Windows (and Posix?) paths can start with "\\NetworkDrive\",
// so we loop on starting /'s.
while ( name.startsWith( "/" ) )
{
name = name.substring( 1 );
}
this.linkName = new StringBuffer( "" );
this.name = new StringBuffer( name );
if ( file.isDirectory() )
{
this.mode = DEFAULT_DIR_MODE;
this.linkFlag = LF_DIR;
if ( this.name.charAt( this.name.length() - 1 ) != '/' )
{
this.name.append( "/" );
}
}
else
{
this.mode = DEFAULT_FILE_MODE;
this.linkFlag = LF_NORMAL;
}
this.size = file.length();
this.modTime = file.lastModified() / MILLIS_PER_SECOND;
this.devMajor = 0;
this.devMinor = 0;
}
/**
* Construct an entry from an archive's header bytes. File is set
* to null.
*
* @param headerBuf The header bytes from a tar archive entry.
*/
public TarEntry( byte[] headerBuf )
{
this();
this.parseTarHeader( headerBuf );
}
/**
* Determine if the two entries are equal. Equality is determined
* by the header names being equal.
*
* @param it Entry to be checked for equality.
* @return True if the entries are equal.
*/
public boolean equals( TarEntry it )
{
return this.getName().equals( it.getName() );
}
/**
* Determine if the two entries are equal. Equality is determined
* by the header names being equal.
*
* @param it Entry to be checked for equality.
* @return True if the entries are equal.
*/
public boolean equals( Object it )
{
if ( it == null || getClass() != it.getClass() )
{
return false;
}
return equals( (TarEntry) it );
}
/**
* Hashcodes are based on entry names.
*
* @return the entry hashcode
*/
public int hashCode()
{
return getName().hashCode();
}
/**
* Determine if the given entry is a descendant of this entry.
* Descendancy is determined by the name of the descendant
* starting with this entry's name.
*
* @param desc Entry to be checked as a descendent of this.
* @return True if entry is a descendant of this.
*/
public boolean isDescendent( TarEntry desc )
{
return desc.getName().startsWith( this.getName() );
}
/**
* Get this entry's name.
*
* @return This entry's name.
*/
public String getName()
{
return this.name.toString();
}
/**
* Set this entry's name.
*
* @param name This entry's new name.
*/
public void setName( String name )
{
this.name = new StringBuffer( name );
}
/**
* Set the mode for this entry
*
* @param mode the mode for this entry
*/
public void setMode( int mode )
{
this.mode = mode;
}
/**
* Get this entry's link name.
*
* @return This entry's link name.
*/
public String getLinkName()
{
return this.linkName.toString();
}
/**
* Get this entry's user id.
*
* @return This entry's user id.
*/
public int getUserId()
{
return this.userId;
}
/**
* Set this entry's user id.
*
* @param userId This entry's new user id.
*/
public void setUserId( int userId )
{
this.userId = userId;
}
/**
* Get this entry's group id.
*
* @return This entry's group id.
*/
public int getGroupId()
{
return this.groupId;
}
/**
* Set this entry's group id.
*
* @param groupId This entry's new group id.
*/
public void setGroupId( int groupId )
{
this.groupId = groupId;
}
/**
* Get this entry's user name.
*
* @return This entry's user name.
*/
public String getUserName()
{
return this.userName.toString();
}
/**
* Set this entry's user name.
*
* @param userName This entry's new user name.
*/
public void setUserName( String userName )
{
this.userName = new StringBuffer( userName );
}
/**
* Get this entry's group name.
*
* @return This entry's group name.
*/
public String getGroupName()
{
return this.groupName.toString();
}
/**
* Set this entry's group name.
*
* @param groupName This entry's new group name.
*/
public void setGroupName( String groupName )
{
this.groupName = new StringBuffer( groupName );
}
/**
* Convenience method to set this entry's group and user ids.
*
* @param userId This entry's new user id.
* @param groupId This entry's new group id.
*/
public void setIds( int userId, int groupId )
{
this.setUserId( userId );
this.setGroupId( groupId );
}
/**
* Convenience method to set this entry's group and user names.
*
* @param userName This entry's new user name.
* @param groupName This entry's new group name.
*/
public void setNames( String userName, String groupName )
{
this.setUserName( userName );
this.setGroupName( groupName );
}
/**
* Set this entry's modification time. The parameter passed
* to this method is in "Java time".
*
* @param time This entry's new modification time.
*/
public void setModTime( long time )
{
this.modTime = time / MILLIS_PER_SECOND;
}
/**
* Set this entry's modification time.
*
* @param time This entry's new modification time.
*/
public void setModTime( Date time )
{
this.modTime = time.getTime() / MILLIS_PER_SECOND;
}
/**
* Get this entry's modification time.
*
* @return time This entry's new modification time.
*/
public Date getModTime()
{
return new Date( this.modTime * MILLIS_PER_SECOND );
}
/**
* Get this entry's checksum time.
*
* @return time This entry's new modification time.
*/
public int getChecksum()
{
return checkSum;
}
/**
* Get this entry's file.
*
* @return This entry's file.
*/
public File getFile()
{
return this.file;
}
/**
* Get this entry's mode.
*
* @return This entry's mode.
*/
public int getMode()
{
return this.mode;
}
/**
* Get this entry's file size.
*
* @return This entry's file size.
*/
public long getSize()
{
return this.size;
}
/**
* Set this entry's file size.
*
* @param size This entry's new file size.
*/
public void setSize( long size )
{
this.size = size;
}
/**
* Indicate if this entry is a GNU long name block
*
* @return true if this is a long name extension provided by GNU tar
*/
public boolean isGNULongNameEntry()
{
return linkFlag == LF_GNUTYPE_LONGNAME
&& name.toString().equals( GNU_LONGLINK );
}
/**
* Return whether or not this entry represents a directory.
*
* @return True if this entry is a directory.
*/
public boolean isDirectory()
{
if ( this.file != null )
{
return this.file.isDirectory();
}
if ( this.linkFlag == LF_DIR )
{
return true;
}
if ( this.getName().endsWith( "/" ) )
{
return true;
}
return false;
}
/**
* If this entry represents a file, and the file is a directory, return
* an array of TarEntries for this entry's children.
*
* @return An array of TarEntry's for this entry's children.
*/
public TarEntry[] getDirectoryEntries()
{
if ( this.file == null || !this.file.isDirectory() )
{
return new TarEntry[0];
}
String[] list = this.file.list();
TarEntry[] result = new TarEntry[list.length];
for ( int i = 0; i < list.length; ++i )
{
result[ i ] = new TarEntry( new File( this.file, list[ i ] ) );
}
return result;
}
/**
* Write an entry's header information to a header buffer.
*
* @param outbuf The tar entry header buffer to fill in.
*/
public void writeEntryHeader( byte[] outbuf )
{
int offset = 0;
offset = TarUtils.getNameBytes( this.name, outbuf, offset, NAMELEN );
offset = TarUtils.getOctalBytes( this.mode, outbuf, offset, MODELEN );
offset = TarUtils.getOctalBytes( this.userId, outbuf, offset, UIDLEN );
offset = TarUtils.getOctalBytes( this.groupId, outbuf, offset, GIDLEN );
offset = TarUtils.getLongOctalBytes( this.size, outbuf, offset, SIZELEN );
offset = TarUtils.getLongOctalBytes( this.modTime, outbuf, offset, MODTIMELEN );
int csOffset = offset;
for ( int c = 0; c < CHKSUMLEN; ++c )
{
outbuf[ offset++ ] = (byte) ' ';
}
outbuf[ offset++ ] = this.linkFlag;
offset = TarUtils.getNameBytes( this.linkName, outbuf, offset, NAMELEN );
offset = TarUtils.getNameBytes( this.magic, outbuf, offset, MAGICLEN );
offset = TarUtils.getNameBytes( this.userName, outbuf, offset, UNAMELEN );
offset = TarUtils.getNameBytes( this.groupName, outbuf, offset, GNAMELEN );
offset = TarUtils.getOctalBytes( this.devMajor, outbuf, offset, DEVLEN );
offset = TarUtils.getOctalBytes( this.devMinor, outbuf, offset, DEVLEN );
while ( offset < outbuf.length )
{
outbuf[ offset++ ] = 0;
}
long checkSum = TarUtils.computeCheckSum( outbuf );
TarUtils.getCheckSumOctalBytes( checkSum, outbuf, csOffset, CHKSUMLEN );
}
/**
* Parse an entry's header information from a header buffer.
*
* @param header The tar entry header buffer to get information from.
*/
public void parseTarHeader( byte[] header )
{
int offset = 0;
this.name = TarUtils.parseName( header, offset, NAMELEN );
offset += NAMELEN;
this.mode = (int) TarUtils.parseOctal( header, offset, MODELEN );
offset += MODELEN;
this.userId = (int) TarUtils.parseOctal( header, offset, UIDLEN );
offset += UIDLEN;
this.groupId = (int) TarUtils.parseOctal( header, offset, GIDLEN );
offset += GIDLEN;
this.size = TarUtils.parseOctal( header, offset, SIZELEN );
offset += SIZELEN;
this.modTime = TarUtils.parseOctal( header, offset, MODTIMELEN );
offset += MODTIMELEN;
this.checkSum = (int) TarUtils.parseOctal( header, offset, CHKSUMLEN );
offset += CHKSUMLEN;
this.linkFlag = header[ offset++ ];
this.linkName = TarUtils.parseName( header, offset, NAMELEN );
offset += NAMELEN;
this.magic = TarUtils.parseName( header, offset, MAGICLEN );
offset += MAGICLEN;
this.userName = TarUtils.parseName( header, offset, UNAMELEN );
offset += UNAMELEN;
this.groupName = TarUtils.parseName( header, offset, GNAMELEN );
offset += GNAMELEN;
this.devMajor = (int) TarUtils.parseOctal( header, offset, DEVLEN );
offset += DEVLEN;
this.devMinor = (int) TarUtils.parseOctal( header, offset, DEVLEN );
}
public long getLastModificationTime()
{
return modTime == 0 ? -1 : (modTime * MILLIS_PER_SECOND);
}
}
plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar/TarFile.java 0000664 0000000 0000000 00000013364 11454043605 0032745 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.tar;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.FilterInputStream;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import org.codehaus.plexus.archiver.ArchiveFile;
/**
* Implementation of {@link ArchiveFile} for tar files.
*Compared to * {@link ZipFile}, this one should be used with some care, due to the * nature of a tar file: While a zip file contains a catalog, a tar * file does not. In other words, the only way to read a tar file in * a performant manner is by iterating over it from the beginning to * the end. If you try to open another entry than the "next" entry, * then you force to skip entries, until the requested entry is found. * This may require to reread the entire file!
*In other words, the recommended use of this class is to use * {@link #getEntries()} and invoke {@link #getInputStream(TarEntry)} * only for the current entry. Basically, this is to handle it like * {@link TarInputStream}.
*The advantage of this class is that you may write code for the * {@link ArchiveFile}, which is valid for both tar files and zip files.
*/ public class TarFile implements ArchiveFile { private final java.io.File file; private TarInputStream inputStream; private TarEntry currentEntry; /** * Creates a new instance with the given file. */ public TarFile( File file ) { this.file = file; } /** * Implementation of {@link ArchiveFile#getEntries()}. Note, that there is * an interaction between this method and {@link #getInputStream(TarEntry)}, * or {@link #getInputStream(org.codehaus.plexus.archiver.ArchiveFile.Entry)}: * If an input stream is opened for any other entry than the enumerations * current entry, then entries may be skipped. */ public Enumeration getEntries() throws IOException { if ( inputStream != null ) { close(); } open(); return new Enumeration() { boolean currentEntryValid; public boolean hasMoreElements() { if ( !currentEntryValid ) { try { currentEntry = inputStream.getNextEntry(); } catch ( IOException e ) { throw new UndeclaredThrowableException( e ); } } return currentEntry != null; } public Object nextElement() { if ( currentEntry == null ) { throw new NoSuchElementException(); } currentEntryValid = false; return currentEntry; } }; } public void close() throws IOException { if ( inputStream != null ) { inputStream.close(); inputStream = null; } } public InputStream getInputStream( Entry entry ) throws IOException { return getInputStream( (TarEntry) entry ); } /** * Returns an {@link InputStream} with the given entries * contents. This {@link InputStream} may be closed: Nothing * happens in that case, because an actual close would invalidate * the underlying {@link TarInputStream}. */ public InputStream getInputStream( TarEntry entry ) throws IOException { if ( entry.equals( (Object) currentEntry ) && inputStream != null ) { return new FilterInputStream( inputStream ) { public void close() throws IOException { // Does nothing. } }; } return getInputStream( entry, currentEntry ); } protected InputStream getInputStream( File file ) throws IOException { return new FileInputStream( file ); } private InputStream getInputStream( TarEntry entry, TarEntry currentEntry ) throws IOException { if ( currentEntry == null || inputStream == null ) { // Search for the entry from the beginning of the file to the end. if ( inputStream != null ) { close(); } open(); if ( !findEntry( entry, null ) ) { throw new IOException( "Unknown entry: " + entry.getName() ); } } else { // Search for the entry from the current position to the end of the file. if ( findEntry( entry, null ) ) { return getInputStream( entry ); } close(); open(); if ( !findEntry( entry, currentEntry ) ) { throw new IOException( "No such entry: " + entry.getName() ); } } return getInputStream( entry ); } private void open() throws IOException { inputStream = new TarInputStream( getInputStream( file ) ); } private boolean findEntry( TarEntry entry, TarEntry currentEntry) throws IOException { for (;;) { this.currentEntry = inputStream.getNextEntry(); if ( this.currentEntry == null || (currentEntry != null && this.currentEntry.equals( currentEntry ) ) ) { return false; } if ( this.currentEntry.equals( entry ) ) { return true; } } } } TarGZipUnArchiver.java 0000664 0000000 0000000 00000002453 11454043605 0034644 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar; /** * * Copyright 2004 The Apache Software Foundation * * Licensed 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. */ import java.io.File; /** * Extract files in tar with gzip compression * @author Dan Tran * @version $Revision: $ */ public class TarGZipUnArchiver extends TarUnArchiver { public TarGZipUnArchiver() { this.setupCompressionMethod(); } public TarGZipUnArchiver( File sourceFile ) { super( sourceFile ); this.setupCompressionMethod(); } private void setupCompressionMethod() { UntarCompressionMethod untarCompressionMethod = new UntarCompressionMethod( UntarCompressionMethod.GZIP ); this.setCompression( untarCompressionMethod ); } } TarInputStream.java 0000664 0000000 0000000 00000027146 11454043605 0034265 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar; /* * Copyright 2000-2004 The Apache Software Foundation * * Licensed 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. * */ /* * This package is based on the work done by Timothy Gerard Endres * (time@ice.com) to whom the Ant project is very grateful for his great code. */ import java.io.FilterInputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; /** * The TarInputStream reads a UNIX tar archive as an InputStream. * methods are provided to position at each successive entry in * the archive, and the read each entry as a normal input stream * using read(). * * @version $Revision$ $Date$ * from org.apache.ant.tools.tar.TarInputStream v1.16 */ public class TarInputStream extends FilterInputStream { protected boolean debug; protected boolean hasHitEOF; protected int entrySize; protected int entryOffset; protected byte[] oneBuf; protected byte[] readBuf; protected TarBuffer buffer; protected TarEntry currEntry; public TarInputStream( InputStream is ) { this( is, TarBuffer.DEFAULT_BLKSIZE, TarBuffer.DEFAULT_RCDSIZE ); } public TarInputStream( InputStream is, int blockSize ) { this( is, blockSize, TarBuffer.DEFAULT_RCDSIZE ); } public TarInputStream( InputStream is, int blockSize, int recordSize ) { super( is ); this.buffer = new TarBuffer( is, blockSize, recordSize ); this.readBuf = null; this.oneBuf = new byte[1]; this.debug = false; this.hasHitEOF = false; } /** * Sets the debugging flag. * * @param debug True to turn on debugging. */ public void setDebug( boolean debug ) { this.debug = debug; this.buffer.setDebug( debug ); } /** * Closes this stream. Calls the TarBuffer's close() method. */ public void close() throws IOException { this.buffer.close(); } /** * Get the record size being used by this stream's TarBuffer. * * @return The TarBuffer record size. */ public int getRecordSize() { return this.buffer.getRecordSize(); } /** * Get the available data that can be read from the current * entry in the archive. This does not indicate how much data * is left in the entire archive, only in the current entry. * This value is determined from the entry's size header field * and the amount of data already read from the current entry. * * @return The number of available bytes for the current entry. */ public int available() throws IOException { return this.entrySize - this.entryOffset; } /** * Skip bytes in the input buffer. This skips bytes in the * current entry's data, not the entire archive, and will * stop at the end of the current entry's data if the number * to skip extends beyond that point. * * @param numToSkip The number of bytes to skip. */ public long skip( long numToSkip ) throws IOException { // REVIEW // This is horribly inefficient, but it ensures that we // properly skip over bytes via the TarBuffer... // byte[] skipBuf = new byte[8 * 1024]; long skip = numToSkip; while ( skip > 0 ) { int realSkip = (int) ( skip > skipBuf.length ? skipBuf.length : skip ); int numRead = this.read( skipBuf, 0, realSkip ); if ( numRead == -1 ) { break; } skip -= numRead; } return ( numToSkip - skip ); } /** * Since we do not support marking just yet, we return false. * * @return False. */ public boolean markSupported() { return false; } /** * Since we do not support marking just yet, we do nothing. * * @param markLimit The limit to mark. */ public void mark( int markLimit ) { } /** * Since we do not support marking just yet, we do nothing. */ public void reset() { } /** * Get the next entry in this tar archive. This will skip * over any remaining data in the current entry, if there * is one, and place the input stream at the header of the * next entry, and read the header and instantiate a new * TarEntry from the header bytes and return that entry. * If there are no more entries in the archive, null will * be returned to indicate that the end of the archive has * been reached. * * @return The next TarEntry in the archive, or null. */ public TarEntry getNextEntry() throws IOException { if ( this.hasHitEOF ) { return null; } if ( this.currEntry != null ) { int numToSkip = this.entrySize - this.entryOffset; if ( this.debug ) { System.err.println( "TarInputStream: SKIP currENTRY '" + this.currEntry.getName() + "' SZ " + this.entrySize + " OFF " + this.entryOffset + " skipping " + numToSkip + " bytes" ); } if ( numToSkip > 0 ) { this.skip( numToSkip ); } this.readBuf = null; } byte[] headerBuf = this.buffer.readRecord(); if ( headerBuf == null ) { if ( this.debug ) { System.err.println( "READ NULL RECORD" ); } this.hasHitEOF = true; } else if ( this.buffer.isEOFRecord( headerBuf ) ) { if ( this.debug ) { System.err.println( "READ EOF RECORD" ); } this.hasHitEOF = true; } if ( this.hasHitEOF ) { this.currEntry = null; } else { this.currEntry = new TarEntry( headerBuf ); if ( this.debug ) { System.err.println( "TarInputStream: SET CURRENTRY '" + this.currEntry.getName() + "' size = " + this.currEntry.getSize() ); } this.entryOffset = 0; // REVIEW How do we resolve this discrepancy?! this.entrySize = (int) this.currEntry.getSize(); } if ( this.currEntry != null && this.currEntry.isGNULongNameEntry() ) { // read in the name StringBuffer longName = new StringBuffer(); byte[] buffer = new byte[256]; int length; while ( ( length = read( buffer ) ) >= 0 ) { longName.append( new String( buffer, 0, length ) ); } getNextEntry(); // remove trailing null terminator if ( longName.length() > 0 && longName.charAt( longName.length() - 1 ) == 0 ) { longName.deleteCharAt( longName.length() - 1 ); } this.currEntry.setName( longName.toString() ); } return this.currEntry; } /** * Reads a byte from the current tar archive entry. * * This method simply calls read( byte[], int, int ). * * @return The byte read, or -1 at EOF. */ public int read() throws IOException { int num = this.read( this.oneBuf, 0, 1 ); if ( num == -1 ) { return num; } else { return (int) this.oneBuf[ 0 ]; } } /** * Reads bytes from the current tar archive entry. * * This method simply calls read( byte[], int, int ). * * @param buf The buffer into which to place bytes read. * @return The number of bytes read, or -1 at EOF. */ public int read( byte[] buf ) throws IOException { return this.read( buf, 0, buf.length ); } /** * Reads bytes from the current tar archive entry. * * This method is aware of the boundaries of the current * entry in the archive and will deal with them as if they * were this stream's start and EOF. * * @param buf The buffer into which to place bytes read. * @param offset The offset at which to place bytes read. * @param numToRead The number of bytes to read. * @return The number of bytes read, or -1 at EOF. */ public int read( byte[] buf, int offset, int numToRead ) throws IOException { int totalRead = 0; if ( this.entryOffset >= this.entrySize ) { return -1; } if ( ( numToRead + this.entryOffset ) > this.entrySize ) { numToRead = ( this.entrySize - this.entryOffset ); } if ( this.readBuf != null ) { int sz = ( numToRead > this.readBuf.length ) ? this.readBuf.length : numToRead; System.arraycopy( this.readBuf, 0, buf, offset, sz ); if ( sz >= this.readBuf.length ) { this.readBuf = null; } else { int newLen = this.readBuf.length - sz; byte[] newBuf = new byte[newLen]; System.arraycopy( this.readBuf, sz, newBuf, 0, newLen ); this.readBuf = newBuf; } totalRead += sz; numToRead -= sz; offset += sz; } while ( numToRead > 0 ) { byte[] rec = this.buffer.readRecord(); if ( rec == null ) { // Unexpected EOF! throw new IOException( "unexpected EOF with " + numToRead + " bytes unread" ); } int sz = numToRead; int recLen = rec.length; if ( recLen > sz ) { System.arraycopy( rec, 0, buf, offset, sz ); this.readBuf = new byte[recLen - sz]; System.arraycopy( rec, sz, this.readBuf, 0, recLen - sz ); } else { sz = recLen; System.arraycopy( rec, 0, buf, offset, recLen ); } totalRead += sz; numToRead -= sz; offset += sz; } this.entryOffset += totalRead; return totalRead; } /** * Copies the contents of the current tar archive entry directly into * an output stream. * * @param out The OutputStream into which to write the entry's data. */ public void copyEntryContents( OutputStream out ) throws IOException { byte[] buf = new byte[32 * 1024]; while ( true ) { int numRead = this.read( buf, 0, buf.length ); if ( numRead == -1 ) { break; } out.write( buf, 0, numRead ); } } } TarLongFileMode.java 0000664 0000000 0000000 00000004552 11454043605 0034312 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar; /* * Copyright 2000-2004 The Apache Software Foundation * * Licensed 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. * */ import org.codehaus.plexus.archiver.ArchiverException; import org.codehaus.plexus.archiver.util.EnumeratedAttribute; /** * Set of options for long file handling in the task. */ public class TarLongFileMode extends EnumeratedAttribute { /** * permissible values for longfile attribute */ public static final String WARN = "warn" , FAIL = "fail" , TRUNCATE = "truncate" , GNU = "gnu" , OMIT = "omit"; private final String[] validModes = {WARN, FAIL, TRUNCATE, GNU, OMIT}; /** * Constructor, defaults to "warn" */ public TarLongFileMode() { super(); try { setValue( WARN ); } catch ( ArchiverException ae ) { //Do nothing } } /** * @return the possible values for this enumerated type. */ public String[] getValues() { return validModes; } /** * @return true if value is "truncate". */ public boolean isTruncateMode() { return TRUNCATE.equalsIgnoreCase( getValue() ); } /** * @return true if value is "warn". */ public boolean isWarnMode() { return WARN.equalsIgnoreCase( getValue() ); } /** * @return true if value is "gnu". */ public boolean isGnuMode() { return GNU.equalsIgnoreCase( getValue() ); } /** * @return true if value is "fail". */ public boolean isFailMode() { return FAIL.equalsIgnoreCase( getValue() ); } /** * @return true if value is "omit". */ public boolean isOmitMode() { return OMIT.equalsIgnoreCase( getValue() ); } } TarOutputStream.java 0000664 0000000 0000000 00000025437 11454043605 0034467 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar; /* * Copyright 2000-2002,2004 The Apache Software Foundation * * Licensed 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. * */ /* * This package is based on the work done by Timothy Gerard Endres * (time@ice.com) to whom the Ant project is very grateful for his great code. */ import java.io.FilterOutputStream; import java.io.IOException; import java.io.OutputStream; /** * The TarOutputStream writes a UNIX tar archive as an OutputStream. * Methods are provided to put entries, and then write their contents * by writing to this stream using write(). * * @version $Revision$ $Date$ * from org.apache.ant.tools.tar.TarOutputStream v1.16 */ public class TarOutputStream extends FilterOutputStream { /** * Fail if a long file name is required in the archive. */ public static final int LONGFILE_ERROR = 0; /** * Long paths will be truncated in the archive. */ public static final int LONGFILE_TRUNCATE = 1; /** * GNU tar extensions are used to store long file names in the archive. */ public static final int LONGFILE_GNU = 2; protected boolean debug; protected int currSize; protected int currBytes; protected byte[] oneBuf; protected byte[] recordBuf; protected int assemLen; protected byte[] assemBuf; protected TarBuffer buffer; protected int longFileMode = LONGFILE_ERROR; public TarOutputStream( OutputStream os ) { this( os, TarBuffer.DEFAULT_BLKSIZE, TarBuffer.DEFAULT_RCDSIZE ); } public TarOutputStream( OutputStream os, int blockSize ) { this( os, blockSize, TarBuffer.DEFAULT_RCDSIZE ); } public TarOutputStream( OutputStream os, int blockSize, int recordSize ) { super( os ); this.buffer = new TarBuffer( os, blockSize, recordSize ); this.debug = false; this.assemLen = 0; this.assemBuf = new byte[recordSize]; this.recordBuf = new byte[recordSize]; this.oneBuf = new byte[1]; } public void setLongFileMode( int longFileMode ) { this.longFileMode = longFileMode; } /** * Sets the debugging flag. * * @param debugF True to turn on debugging. */ public void setDebug( boolean debugF ) { this.debug = debugF; } /** * Sets the debugging flag in this stream's TarBuffer. * * @param debug True to turn on debugging. */ public void setBufferDebug( boolean debug ) { this.buffer.setDebug( debug ); } /** * Ends the TAR archive without closing the underlying OutputStream. * The result is that two EOF record of nulls are written. */ public void finish() throws IOException { this.writeEOFRecord(); this.writeEOFRecord(); } /** * Ends the TAR archive and closes the underlying OutputStream. * This means that finish() is called followed by calling the * TarBuffer's close(). */ public void close() throws IOException { this.finish(); this.buffer.close(); } /** * Get the record size being used by this stream's TarBuffer. * * @return The TarBuffer record size. */ public int getRecordSize() { return this.buffer.getRecordSize(); } /** * Put an entry on the output stream. This writes the entry's * header record and positions the output stream for writing * the contents of the entry. Once this method is called, the * stream is ready for calls to write() to write the entry's * contents. Once the contents are written, closeEntry() * MUST be called to ensure that all buffered data * is completely written to the output stream. * * @param entry The TarEntry to be written to the archive. */ public void putNextEntry( TarEntry entry ) throws IOException { if ( entry.getName().length() >= TarConstants.NAMELEN ) { if ( longFileMode == LONGFILE_GNU ) { // create a TarEntry for the LongLink, the contents // of which are the entry's name TarEntry longLinkEntry = new TarEntry( TarConstants.GNU_LONGLINK, TarConstants.LF_GNUTYPE_LONGNAME ); longLinkEntry.setSize( entry.getName().length() + 1 ); putNextEntry( longLinkEntry ); write( entry.getName().getBytes() ); write( 0 ); closeEntry(); } else if ( longFileMode != LONGFILE_TRUNCATE ) { throw new RuntimeException( "file name '" + entry.getName() + "' is too long ( > " + TarConstants.NAMELEN + " bytes)" ); } } entry.writeEntryHeader( this.recordBuf ); this.buffer.writeRecord( this.recordBuf ); this.currBytes = 0; if ( entry.isDirectory() ) { this.currSize = 0; } else { this.currSize = (int) entry.getSize(); } } /** * Close an entry. This method MUST be called for all file * entries that contain data. The reason is that we must * buffer data written to the stream in order to satisfy * the buffer's record based writes. Thus, there may be * data fragments still being assembled that must be written * to the output stream before this entry is closed and the * next entry written. */ public void closeEntry() throws IOException { if ( this.assemLen > 0 ) { for ( int i = this.assemLen; i < this.assemBuf.length; ++i ) { this.assemBuf[ i ] = 0; } this.buffer.writeRecord( this.assemBuf ); this.currBytes += this.assemLen; this.assemLen = 0; } if ( this.currBytes < this.currSize ) { throw new IOException( "entry closed at '" + this.currBytes + "' before the '" + this.currSize + "' bytes specified in the header were written" ); } } /** * Writes a byte to the current tar archive entry. * * This method simply calls read( byte[], int, int ). * * @param b The byte written. */ public void write( int b ) throws IOException { this.oneBuf[ 0 ] = (byte) b; this.write( this.oneBuf, 0, 1 ); } /** * Writes bytes to the current tar archive entry. * * This method simply calls write( byte[], int, int ). * * @param wBuf The buffer to write to the archive. */ public void write( byte[] wBuf ) throws IOException { this.write( wBuf, 0, wBuf.length ); } /** * Writes bytes to the current tar archive entry. This method * is aware of the current entry and will throw an exception if * you attempt to write bytes past the length specified for the * current entry. The method is also (painfully) aware of the * record buffering required by TarBuffer, and manages buffers * that are not a multiple of recordsize in length, including * assembling records from small buffers. * * @param wBuf The buffer to write to the archive. * @param wOffset The offset in the buffer from which to get bytes. * @param numToWrite The number of bytes to write. */ public void write( byte[] wBuf, int wOffset, int numToWrite ) throws IOException { if ( ( this.currBytes + numToWrite ) > this.currSize ) { throw new IOException( "request to write '" + numToWrite + "' bytes exceeds size in header of '" + this.currSize + "' bytes" ); // // We have to deal with assembly!!! // The programmer can be writing little 32 byte chunks for all // we know, and we must assemble complete records for writing. // REVIEW Maybe this should be in TarBuffer? Could that help to // eliminate some of the buffer copying. // } if ( this.assemLen > 0 ) { if ( ( this.assemLen + numToWrite ) >= this.recordBuf.length ) { int aLen = this.recordBuf.length - this.assemLen; System.arraycopy( this.assemBuf, 0, this.recordBuf, 0, this.assemLen ); System.arraycopy( wBuf, wOffset, this.recordBuf, this.assemLen, aLen ); this.buffer.writeRecord( this.recordBuf ); this.currBytes += this.recordBuf.length; wOffset += aLen; numToWrite -= aLen; this.assemLen = 0; } else { System.arraycopy( wBuf, wOffset, this.assemBuf, this.assemLen, numToWrite ); wOffset += numToWrite; this.assemLen += numToWrite; numToWrite -= numToWrite; } } // // When we get here we have EITHER: // o An empty "assemble" buffer. // o No bytes to write (numToWrite == 0) // while ( numToWrite > 0 ) { if ( numToWrite < this.recordBuf.length ) { System.arraycopy( wBuf, wOffset, this.assemBuf, this.assemLen, numToWrite ); this.assemLen += numToWrite; break; } this.buffer.writeRecord( wBuf, wOffset ); int num = this.recordBuf.length; this.currBytes += num; numToWrite -= num; wOffset += num; } } /** * Write an EOF (end of archive) record to the tar archive. * An EOF record consists of a record of all zeros. */ private void writeEOFRecord() throws IOException { for ( int i = 0; i < this.recordBuf.length; ++i ) { this.recordBuf[ i ] = 0; } this.buffer.writeRecord( this.recordBuf ); } } plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar/TarResource.java 0000664 0000000 0000000 00000004132 11454043605 0033646 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.tar; import java.io.IOException; import java.io.InputStream; import java.net.URL; import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes; import org.codehaus.plexus.components.io.attributes.SimpleResourceAttributes; import org.codehaus.plexus.components.io.resources.AbstractPlexusIoResource; import org.codehaus.plexus.components.io.resources.PlexusIoResource; import org.codehaus.plexus.components.io.resources.PlexusIoResourceWithAttributes; public class TarResource extends AbstractPlexusIoResource implements PlexusIoResourceWithAttributes { private final TarFile tarFile; private final TarEntry entry; private PlexusIoResourceAttributes attributes; public TarResource( TarFile tarFile, TarEntry entry ) { this.tarFile = tarFile; this.entry = entry; final boolean dir = entry.isDirectory(); setName( entry.getName() ); setDirectory( dir ); setExisting( true ); setFile( !dir ); long l = entry.getLastModificationTime(); setLastModified( l == -1 ? PlexusIoResource.UNKNOWN_MODIFICATION_DATE : l ); setSize( dir ? PlexusIoResource.UNKNOWN_RESOURCE_SIZE : entry.getSize() ); } public synchronized PlexusIoResourceAttributes getAttributes() { if ( attributes == null ) { attributes = new SimpleResourceAttributes(); attributes.setUserId( entry.getUserId() ); attributes.setUserName( entry.getUserName() ); attributes.setGroupId( entry.getGroupId() ); attributes.setGroupName( entry.getGroupName() ); attributes.setOctalMode( entry.getMode() ); } return attributes; } public synchronized void setAttributes( PlexusIoResourceAttributes attributes ) { this.attributes = attributes; } public URL getURL() throws IOException { return null; } public InputStream getContents() throws IOException { return tarFile.getInputStream( entry ); } } TarUnArchiver.java 0000664 0000000 0000000 00000013754 11454043605 0034060 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar; /** * * Copyright 2004 The Apache Software Foundation * * Licensed 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. */ import org.codehaus.plexus.archiver.ArchiverException; import org.codehaus.plexus.archiver.bzip2.CBZip2InputStream; import org.codehaus.plexus.archiver.util.EnumeratedAttribute; import org.codehaus.plexus.archiver.zip.AbstractZipUnArchiver; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.zip.GZIPInputStream; /** * @author Emmanuel Venisse * @version $Revision$ $Date$ */ public class TarUnArchiver extends AbstractZipUnArchiver { public TarUnArchiver() { } public TarUnArchiver( File sourceFile ) { super( sourceFile ); } /** * compression method */ private UntarCompressionMethod compression = new UntarCompressionMethod(); /** * Set decompression algorithm to use; default=none. * * Allowable values are *useJvmChmod set to true
*
* @param file
* @param mode
* @param logger
* @throws ArchiverException
*/
public static void chmod( final File file, final int mode, final Logger logger )
throws ArchiverException
{
chmod( file, mode, logger, Boolean.getBoolean( "useJvmChmod" ) && jvmFilePermAvailable );
}
private static void applyPermissionsWithJvm( final File file, final String mode, final Logger logger )
{
final FilePermission filePermission = FilePermissionUtils.getFilePermissionFromMode( mode, logger );
Method method;
try
{
method = File.class.getMethod( "setReadable", new Class[] { Boolean.TYPE, Boolean.TYPE } );
method.invoke( file,
new Object[] { Boolean.valueOf( filePermission.isReadable() ),
Boolean.valueOf( filePermission.isOwnerOnlyReadable() ) } );
method = File.class.getMethod( "setExecutable", new Class[] { Boolean.TYPE, Boolean.TYPE } );
method.invoke( file,
new Object[] { Boolean.valueOf( filePermission.isExecutable() ),
Boolean.valueOf( filePermission.isOwnerOnlyExecutable() ) } );
method = File.class.getMethod( "setWritable", new Class[] { Boolean.TYPE, Boolean.TYPE } );
method.invoke( file,
new Object[] { Boolean.valueOf( filePermission.isWritable() ),
Boolean.valueOf( filePermission.isOwnerOnlyWritable() ) } );
}
catch ( final Exception e )
{
logger.error( "error calling dynamically file permissons with jvm " + e.getMessage(), e );
throw new RuntimeException( "error calling dynamically file permissons with jvm " + e.getMessage(), e );
}
}
}
plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/util/Compressor.java 0000664 0000000 0000000 00000013563 11454043605 0033743 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.util;
/**
*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.components.io.resources.PlexusIoFileResource;
import org.codehaus.plexus.components.io.resources.PlexusIoResource;
import org.codehaus.plexus.logging.AbstractLogEnabled;
/**
* @version $Revision$ $Date$
*/
public abstract class Compressor
extends AbstractLogEnabled
{
private File destFile;
private PlexusIoResource source;
/**
* the required destination file.
*
* @param compressFile
*/
public void setDestFile( File compressFile )
{
this.destFile = compressFile;
}
public File getDestFile()
{
return destFile;
}
/**
* The resource to compress; required.
*/
public void setSource( PlexusIoResource source )
{
this.source = source;
}
/**
* The resource to compress; required.
*/
public PlexusIoResource getSource()
{
return source;
}
/**
* the file to compress; required.
* @deprecated Use {@link #getSource()}.
*/
public void setSourceFile( File srcFile )
{
final PlexusIoFileResource res = new PlexusIoFileResource( srcFile );
setSource( res );
}
/**
* @deprecated Use {@link #getSource()}.
*/
public File getSourceFile()
{
final PlexusIoResource res = getSource();
if ( res instanceof PlexusIoFileResource )
{
return ((PlexusIoFileResource) res).getFile();
}
return null;
}
/**
* validation routine
*
* @throws ArchiverException if anything is invalid
*/
private void validate()
throws ArchiverException
{
if ( destFile == null )
{
throw new ArchiverException( "Destination file attribute is required" );
}
if ( destFile.isDirectory() )
{
throw new ArchiverException( "Destination file attribute must not "
+ "represent a directory!" );
}
if ( source == null )
{
throw new ArchiverException( "Source file attribute is required" );
}
if ( source.isDirectory() )
{
throw new ArchiverException( "Source file attribute must not "
+ "represent a directory!" );
}
}
/**
* validate, then hand off to the subclass
*
* @throws BuildException
*/
public void execute()
throws ArchiverException
{
validate();
try
{
if ( !source.isExisting() )
{
// getLogger().info( "Nothing to do: " + sourceFile.getAbsolutePath()
// + " doesn't exist." );
}
else
{
final long l = source.getLastModified();
if ( l == PlexusIoResource.UNKNOWN_MODIFICATION_DATE
|| destFile.lastModified() == 0
|| destFile.lastModified() < l )
{
compress();
}
else
{
// getLogger().info( "Nothing to do: " + destFile.getAbsolutePath()
// + " is up to date." );
}
}
}
finally
{
close();
}
}
/**
* compress a stream to an output stream
*
* @param in
* @param zOut
* @throws IOException
*/
private void compressFile( InputStream in, OutputStream zOut )
throws IOException
{
byte[] buffer = new byte[8 * 1024];
int count = 0;
do
{
zOut.write( buffer, 0, count );
count = in.read( buffer, 0, buffer.length );
}
while ( count != -1 );
}
/**
* compress a file to an output stream
* @deprecated Use {@link #compress(PlexusIoResource, OutputStream)}.
*/
protected void compressFile( File file, OutputStream zOut )
throws IOException
{
FileInputStream fIn = new FileInputStream( file );
try
{
compressFile( fIn, zOut );
}
finally
{
fIn.close();
}
}
/**
* compress a resource to an output stream
*/
protected void compress( PlexusIoResource resource, OutputStream zOut )
throws IOException
{
InputStream fIn = resource.getContents();
try
{
compressFile( fIn, zOut );
}
finally
{
fIn.close();
}
}
/**
* subclasses must implement this method to do their compression
*
* this is public so the process of compression and closing can be dealt with separately.
*/
public abstract void compress()
throws ArchiverException;
/**
* subclasses must implement this method to cleanup after compression
*
* this is public so the process of compression and closing can be dealt with separately.
*/
public abstract void close();
}
DefaultArchivedFileSet.java 0000664 0000000 0000000 00000001017 11454043605 0036025 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
import java.io.File;
import org.codehaus.plexus.archiver.ArchivedFileSet;
/**
* Default implementation of {@link ArchivedFileSet}.
* @since 1.0-alpha-9
*/
public class DefaultArchivedFileSet extends AbstractFileSet implements ArchivedFileSet
{
private File archive;
/**
* Sets the file sets archive.
*/
public void setArchive( File archive )
{
this.archive = archive;
}
public File getArchive()
{
return archive;
}
}
DefaultFileSet.java 0000664 0000000 0000000 00000001004 11454043605 0034353 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
import java.io.File;
import org.codehaus.plexus.archiver.FileSet;
/**
* Default implementation of {@link FileSet}.
* @since 1.0-alpha-9
*/
public class DefaultFileSet extends AbstractFileSet implements FileSet
{
private File directory;
/**
* Sets the file sets base directory.
*/
public void setDirectory( File directory )
{
this.directory = directory;
}
public File getDirectory()
{
return directory;
}
}
EnumeratedAttribute.java 0000664 0000000 0000000 00000006370 11454043605 0035503 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
/**
*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
import org.codehaus.plexus.archiver.ArchiverException;
/**
* Helper class for attributes that can only take one of a fixed list
* of values.
*
* See {@link org.apache.tools.ant.taskdefs.FixCRLF FixCRLF} for an
* example.
*/
public abstract class EnumeratedAttribute
{
/**
* The selected value in this enumeration.
*/
protected String value;
/**
* the index of the selected value in the array.
*/
private int index = -1;
/**
* This is the only method a subclass needs to implement.
*
* @return an array holding all possible values of the enumeration.
* The order of elements must be fixed so that indexOfValue(String)
* always return the same index for the same value.
*/
public abstract String[] getValues();
/**
* bean constructor
*/
protected EnumeratedAttribute()
{
}
/**
* Invoked by {@link org.apache.tools.ant.IntrospectionHelper IntrospectionHelper}.
*/
public final void setValue( String value )
throws ArchiverException
{
int index = indexOfValue( value );
if ( index == -1 )
{
throw new ArchiverException( value + " is not a legal value for this attribute" );
}
this.index = index;
this.value = value;
}
/**
* Is this value included in the enumeration?
*/
public final boolean containsValue( String value )
{
return ( indexOfValue( value ) != -1 );
}
/**
* get the index of a value in this enumeration.
*
* @param value the string value to look for.
* @return the index of the value in the array of strings
* or -1 if it cannot be found.
* @see #getValues()
*/
public final int indexOfValue( String value )
{
String[] values = getValues();
if ( values == null || value == null )
{
return -1;
}
for ( int i = 0; i < values.length; i++ )
{
if ( value.equals( values[ i ] ) )
{
return i;
}
}
return -1;
}
/**
* @return the selected value.
*/
public final String getValue()
{
return value;
}
/**
* @return the index of the selected value in the array.
* @see #getValues()
*/
public final int getIndex()
{
return index;
}
/**
* Convert the value to its string form.
*
* @return the string form of the value.
*/
public String toString()
{
return getValue();
}
}
FilePermission.java 0000664 0000000 0000000 00000006121 11454043605 0034450 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
/*
* 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.
*/
/**
* @author Olivier Lamy
* @since 1.1
*
*/
public class FilePermission
{
private boolean executable;
private boolean ownerOnlyExecutable;
private boolean ownerOnlyReadable;
private boolean readable;
private boolean ownerOnlyWritable;
private boolean writable;
public FilePermission( boolean executable, boolean ownerOnlyExecutable, boolean ownerOnlyReadable,
boolean readable, boolean ownerOnlyWritable, boolean writable )
{
this.executable = executable;
this.ownerOnlyExecutable = ownerOnlyExecutable;
this.ownerOnlyReadable = ownerOnlyReadable;
this.readable = readable;
this.ownerOnlyWritable = ownerOnlyWritable;
this.writable = writable;
}
public boolean isExecutable()
{
return executable;
}
public void setExecutable( boolean executable )
{
this.executable = executable;
}
public boolean isOwnerOnlyExecutable()
{
return ownerOnlyExecutable;
}
public void setOwnerOnlyExecutable( boolean ownerOnlyExecutable )
{
this.ownerOnlyExecutable = ownerOnlyExecutable;
}
public boolean isOwnerOnlyReadable()
{
return ownerOnlyReadable;
}
public void setOwnerOnlyReadable( boolean ownerOnlyReadable )
{
this.ownerOnlyReadable = ownerOnlyReadable;
}
public boolean isReadable()
{
return readable;
}
public void setReadable( boolean readable )
{
this.readable = readable;
}
public boolean isOwnerOnlyWritable()
{
return ownerOnlyWritable;
}
public void setOwnerOnlyWritable( boolean ownerOnlyWritable )
{
this.ownerOnlyWritable = ownerOnlyWritable;
}
public boolean isWritable()
{
return writable;
}
public void setWritable( boolean writable )
{
this.writable = writable;
}
public String toString()
{
return "FilePermission [executable=" + executable + ", ownerOnlyExecutable=" + ownerOnlyExecutable
+ ", ownerOnlyReadable=" + ownerOnlyReadable + ", readable=" + readable + ", ownerOnlyWritable="
+ ownerOnlyWritable + ", writable=" + writable + "]";
}
}
FilePermissionUtils.java 0000664 0000000 0000000 00000013134 11454043605 0035473 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
/*
* 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.
*/
import java.util.ArrayList;
import java.util.List;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.util.StringUtils;
/**
* @author Olivier Lamy
* @since 1.0.1
*
*/
public class FilePermissionUtils
{
private FilePermissionUtils()
{
// no op
}
/**
* @param mode file mode "a la" unix ie 664, 440, etc
* @return FilePermission associated to the mode (group permission are ignored here)
*/
public static FilePermission getFilePermissionFromMode( String mode, Logger logger )
{
if ( StringUtils.isBlank( mode ) )
{
throw new IllegalArgumentException( " file mode cannot be empty" );
}
// 4 characters works on some unix (ie solaris)
if ( mode.length() != 3 && mode.length() != 4 )
{
throw new IllegalArgumentException( " file mode must be 3 or 4 characters" );
}
List modes = new ArrayList(mode.length());
for (int i = 0,size = mode.length();iWEB-INF/lib, WEB-INF/classes or
* WEB-INF directories of the Web Application Archive.
(The War task is a shortcut for specifying the particular layout of a WAR file. * The same thing can be accomplished by using the prefix and fullpath * attributes of zipfilesets in a Zip or Jar task.)
*The extended zipfileset element from the zip task * (with attributes prefix, fullpath, and src) * is available in the War task.
* * @see JarArchiver */ public class WarArchiver extends JarArchiver { /** * our web.xml deployment descriptor */ private File deploymentDescriptor; /** * flag set if finding the webxml is to be expected. */ private boolean ignoreWebxml = true; /** * flag set if the descriptor is added */ private boolean descriptorAdded; public void setIgnoreWebxml( boolean ignore ) { ignoreWebxml = ignore; } public WarArchiver() { super(); archiveType = "war"; } /** * set the deployment descriptor to use (WEB-INF/web.xml); * required unless update=true */ public void setWebxml( File descr ) throws ArchiverException { deploymentDescriptor = descr; if ( !deploymentDescriptor.exists() ) { throw new ArchiverException( "Deployment descriptor: " + deploymentDescriptor + " does not exist." ); } addFile( descr, "WEB-INF/web.xml" ); } /** * add a file under WEB-INF/lib/ */ public void addLib( File fileName ) throws ArchiverException { addDirectory( fileName.getParentFile(), "WEB-INF/lib/", new String[]{fileName.getName()}, null ); } /** * add files under WEB-INF/lib/ */ public void addLibs( File directoryName, String[] includes, String[] excludes ) throws ArchiverException { addDirectory( directoryName, "WEB-INF/lib/", includes, excludes ); } /** * add a file under WEB-INF/lib/ */ public void addClass( File fileName ) throws ArchiverException { addDirectory( fileName.getParentFile(), "WEB-INF/classes/", new String[]{fileName.getName()}, null ); } /** * add files under WEB-INF/classes */ public void addClasses( File directoryName, String[] includes, String[] excludes ) throws ArchiverException { addDirectory( directoryName, "WEB-INF/classes/", includes, excludes ); } /** * files to add under WEB-INF; */ public void addWebinf( File directoryName, String[] includes, String[] excludes ) throws ArchiverException { addDirectory( directoryName, "WEB-INF/", includes, excludes ); } /** * override of parent; validates configuration * before initializing the output stream. */ protected void initZipOutputStream( ZipOutputStream zOut ) throws IOException, ArchiverException { // If no webxml file is specified, it's an error. if ( ignoreWebxml && deploymentDescriptor == null && !isInUpdateMode() ) { throw new ArchiverException( "webxml attribute is required (or pre-existing WEB-INF/web.xml if executing in update mode)" ); } super.initZipOutputStream( zOut ); } /** * Overridden from ZipArchiver class to deal with web.xml */ protected void zipFile( ArchiveEntry entry, ZipOutputStream zOut, String vPath ) throws IOException, ArchiverException { // If the file being added is WEB-INF/web.xml, we warn if it's // not the one specified in the "webxml" attribute - or if // it's being added twice, meaning the same file is specified // by the "webxml" attribute and in aZip archives store file modification times with a * granularity of two seconds, so the times will either be rounded * up or down. If you round down, the archive will always seem * out-of-date when you rerun the task, so the default is to round * up. Rounding up may lead to a different type of problems like * JSPs inside a web archive that seem to be slightly more recent * than precompiled pages, rendering precompilation useless.
*/ public void setRoundUp( boolean r ) { roundUp = r; } public boolean isRoundUp() { return roundUp; } protected void execute() throws ArchiverException, IOException { if ( ! checkForced() ) { return; } if ( doubleFilePass ) { skipWriting = true; createArchiveMain(); skipWriting = false; createArchiveMain(); } else { createArchiveMain(); } finalizeZipOutputStream( zOut ); } protected void finalizeZipOutputStream( ZipOutputStream zOut ) throws IOException, ArchiverException { } private void createArchiveMain() throws ArchiverException, IOException { if ( !Archiver.DUPLICATES_SKIP.equals( duplicate ) ) { setDuplicateBehavior( duplicate ); } ResourceIterator iter = getResources(); if ( !iter.hasNext() && !hasVirtualFiles() ) { throw new ArchiverException( "You must set at least one file." ); } zipFile = getDestFile(); if ( zipFile == null ) { throw new ArchiverException( "You must set the destination " + archiveType + "file." ); } if ( zipFile.exists() && !zipFile.isFile() ) { throw new ArchiverException( zipFile + " isn't a file." ); } if ( zipFile.exists() && !zipFile.canWrite() ) { throw new ArchiverException( zipFile + " is read-only." ); } // Whether or not an actual update is required - // we don't need to update if the original file doesn't exist addingNewFiles = true; if ( doUpdate && !zipFile.exists() ) { doUpdate = false; getLogger().debug( "ignoring update attribute as " + archiveType + " doesn't exist." ); } success = false; if ( doUpdate ) { renamedFile = FileUtils.createTempFile( "zip", ".tmp", zipFile.getParentFile() ); renamedFile.deleteOnExit(); try { FileUtils.rename( zipFile, renamedFile ); } catch ( SecurityException e ) { getLogger().debug( e.toString() ); throw new ArchiverException( "Not allowed to rename old file (" + zipFile.getAbsolutePath() + ") to temporary file", e ); } catch ( IOException e ) { getLogger().debug( e.toString() ); throw new ArchiverException( "Unable to rename old file (" + zipFile.getAbsolutePath() + ") to temporary file", e ); } } String action = doUpdate ? "Updating " : "Building "; getLogger().info( action + archiveType + ": " + zipFile.getAbsolutePath() ); if ( !skipWriting ) { zOut = new ZipOutputStream( zipFile ); zOut.setEncoding( encoding ); if ( doCompress ) { zOut.setMethod( ZipOutputStream.DEFLATED ); } else { zOut.setMethod( ZipOutputStream.STORED ); } } initZipOutputStream( zOut ); // Add the new files to the archive. addResources( iter, zOut ); // If we've been successful on an update, delete the // temporary file if ( doUpdate ) { if ( !renamedFile.delete() ) { getLogger().warn( "Warning: unable to delete temporary file " + renamedFile.getName() ); } } success = true; } protected Map getZipEntryNames( File file ) throws IOException { if ( !file.exists() || !doUpdate ) { return Collections.EMPTY_MAP; } final Map entries = new HashMap(); final ZipFile zipFile = new ZipFile( file ); for ( Enumeration en = zipFile.getEntries(); en.hasMoreElements(); ) { ZipEntry ze = (ZipEntry) en.nextElement(); entries.put( ze.getName(), new Long( ze.getLastModificationTime() ) ); } return entries; } protected boolean isFileAdded( ArchiveEntry entry, Map entries ) { return !entries.containsKey( entry.getName() ); } protected boolean isFileUpdated( ArchiveEntry entry, Map entries ) { Long l = (Long) entries.get( entry.getName() ); if ( l == null ) { return false; } return l.longValue() == -1 || !ResourceUtils.isUptodate( entry.getResource(), l.longValue() ); } /** * Add the given resources. * * @param resources the resources to add * @param zOut the stream to write to */ protected final void addResources( ResourceIterator resources, ZipOutputStream zOut ) throws IOException, ArchiverException { File base = null; while ( resources.hasNext() ) { ArchiveEntry entry = resources.next(); String name = entry.getName(); name = name.replace( File.separatorChar, '/' ); if ( "".equals( name ) ) { continue; } if ( entry.getResource().isDirectory() && !name.endsWith( "/" ) ) { name = name + "/"; } addParentDirs( base, name, zOut, "" ); if ( entry.getResource().isFile() ) { zipFile( entry, zOut, name ); } else { zipDir( entry.getResource(), zOut, name, entry.getMode() ); } } } /** * Ensure all parent dirs of a given entry have been added. */ protected final void addParentDirs( File baseDir, String entry, ZipOutputStream zOut, String prefix ) throws IOException { if ( !doFilesonly && getIncludeEmptyDirs() ) { Stack directories = new Stack(); // Don't include the last entry itself if it's // a dir; it will be added on its own. int slashPos = entry.length() - ( entry.endsWith( "/" ) ? 1 : 0 ); while ( ( slashPos = entry.lastIndexOf( '/', slashPos - 1 ) ) != -1 ) { String dir = entry.substring( 0, slashPos + 1 ); if ( addedDirs.contains( prefix + dir ) ) { break; } directories.push( dir ); } while ( !directories.isEmpty() ) { String dir = (String) directories.pop(); File f; if ( baseDir != null ) { f = new File( baseDir, dir ); } else { f = new File( dir ); } final PlexusIoFileResource res = new PlexusIoFileResource( f ); zipDir( res, zOut, prefix + dir, getRawDefaultDirectoryMode() ); } } } /** * Adds a new entry to the archive, takes care of duplicates as well. * * @param in the stream to read data for the entry from. * @param zOut the stream to write to. * @param vPath the name this entry shall have in the archive. * @param lastModified last modification time for the entry. * @param fromArchive the original archive we are copying this * entry from, will be null if we are not copying from an archive. * @param mode the Unix permissions to set. */ protected void zipFile( InputStream in, ZipOutputStream zOut, String vPath, long lastModified, File fromArchive, int mode ) throws IOException, ArchiverException { getLogger().debug( "adding entry " + vPath ); entries.put( vPath, vPath ); if ( !skipWriting ) { ZipEntry ze = new ZipEntry( vPath ); ze.setTime( lastModified ); ze.setMethod( doCompress ? ZipEntry.DEFLATED : ZipEntry.STORED ); /* * ZipOutputStream.putNextEntry expects the ZipEntry to * know its size and the CRC sum before you start writing * the data when using STORED mode - unless it is seekable. * * This forces us to process the data twice. */ if ( !zOut.isSeekable() && !doCompress ) { long size = 0; CRC32 cal = new CRC32(); if ( !in.markSupported() ) { // Store data into a byte[] ByteArrayOutputStream bos = new ByteArrayOutputStream(); byte[] buffer = new byte[8 * 1024]; int count = 0; do { size += count; cal.update( buffer, 0, count ); bos.write( buffer, 0, count ); count = in.read( buffer, 0, buffer.length ); } while ( count != -1 ); in = new ByteArrayInputStream( bos.toByteArray() ); } else { in.mark( Integer.MAX_VALUE ); byte[] buffer = new byte[8 * 1024]; int count = 0; do { size += count; cal.update( buffer, 0, count ); count = in.read( buffer, 0, buffer.length ); } while ( count != -1 ); in.reset(); } ze.setSize( size ); ze.setCrc( cal.getValue() ); } ze.setUnixMode( UnixStat.FILE_FLAG | mode ); zOut.putNextEntry( ze ); byte[] buffer = new byte[8 * 1024]; int count = 0; do { if ( count != 0 ) { zOut.write( buffer, 0, count ); } count = in.read( buffer, 0, buffer.length ); } while ( count != -1 ); } addedFiles.addElement( vPath ); } /** * Method that gets called when adding from java.io.File instances. * *This implementation delegates to the six-arg version.
* * @param entry the file to add to the archive * @param zOut the stream to write to * @param vPath the name this entry shall have in the archive */ protected void zipFile( ArchiveEntry entry, ZipOutputStream zOut, String vPath ) throws IOException, ArchiverException { if ( ResourceUtils.isSame( entry.getResource(), getDestFile() ) ) { throw new ArchiverException( "A zip file cannot include itself" ); } InputStream fIn = entry.getInputStream(); try { // ZIPs store time with a granularity of 2 seconds, round up final long lastModified = entry.getResource().getLastModified() + ( roundUp ? 1999 : 0 ); zipFile( fIn, zOut, vPath, lastModified, null, entry.getMode() ); } finally { fIn.close(); } } /** * */ protected void zipDir( PlexusIoResource dir, ZipOutputStream zOut, String vPath, int mode ) throws IOException { if ( addedDirs.get( vPath ) != null ) { // don't add directories we've already added. // no warning if we try, it is harmless in and of itself return; } getLogger().debug( "adding directory " + vPath ); addedDirs.put( vPath, vPath ); if ( !skipWriting ) { ZipEntry ze = new ZipEntry( vPath ); if ( dir != null && dir.isExisting() ) { // ZIPs store time with a granularity of 2 seconds, round up final long lastModified = dir.getLastModified() + ( roundUp ? 1999 : 0 ); ze.setTime( lastModified ); } else { // ZIPs store time with a granularity of 2 seconds, round up ze.setTime( System.currentTimeMillis() + ( roundUp ? 1999 : 0 ) ); } ze.setSize( 0 ); ze.setMethod( ZipEntry.STORED ); // This is faintly ridiculous: ze.setCrc( EMPTY_CRC ); ze.setUnixMode( mode ); zOut.putNextEntry( ze ); } } /** * Create an empty zip file * * @return true for historic reasons */ protected boolean createEmptyZip( File zipFile ) throws ArchiverException { // In this case using java.util.zip will not work // because it does not permit a zero-entry archive. // Must create it manually. getLogger().info( "Note: creating empty " + archiveType + " archive " + zipFile ); OutputStream os = null; try { os = new FileOutputStream( zipFile ); // Cf. PKZIP specification. byte[] empty = new byte[22]; empty[0] = 80; // P empty[1] = 75; // K empty[2] = 5; empty[3] = 6; // remainder zeros os.write( empty ); } catch ( IOException ioe ) { throw new ArchiverException( "Could not create empty ZIP archive " + "(" + ioe.getMessage() + ")", ioe ); } finally { if ( os != null ) { try { os.close(); } catch ( IOException e ) { //ignore } } } return true; } /** * Do any clean up necessary to allow this instance to be used again. * *When we get here, the Zip file has been closed and all we * need to do is to reset some globals.
* *This method will only reset globals that have been changed * during execute(), it will not alter the attributes or nested * child elements. If you want to reset the instance so that you * can later zip a completely different set of files, you must use * the reset method.
* * @see #reset */ protected void cleanUp() { super.cleanUp(); addedDirs.clear(); addedFiles.removeAllElements(); entries.clear(); addingNewFiles = false; doUpdate = savedDoUpdate; success = false; zOut = null; renamedFile = null; zipFile = null; } /** * Makes this instance reset all attributes to their default * values and forget all children. * * @see #cleanUp */ public void reset() { setDestFile( null ); // duplicate = "add"; archiveType = "zip"; doCompress = true; doUpdate = false; doFilesonly = false; encoding = null; } /** * method for subclasses to override */ protected void initZipOutputStream( ZipOutputStream zOut ) throws IOException, ArchiverException { } /** * method for subclasses to override */ public boolean isSupportingForced() { return true; } protected boolean revert( StringBuffer messageBuffer ) { int initLength = messageBuffer.length(); // delete a bogus ZIP file (but only if it's not the original one) if ( ( !doUpdate || renamedFile != null ) && !zipFile.delete() ) { messageBuffer.append( " (and the archive is probably corrupt but I could not delete it)" ); } if ( doUpdate && renamedFile != null ) { try { FileUtils.rename( renamedFile, zipFile ); } catch ( IOException e ) { messageBuffer.append( " (and I couldn't rename the temporary file " ); messageBuffer.append( renamedFile.getName() ); messageBuffer.append( " back)" ); } } return messageBuffer.length() == initLength; } protected void close() throws IOException { // Close the output stream. try { if ( zOut != null ) { zOut.close(); } } catch ( IOException ex ) { // If we're in this finally clause because of an // exception, we don't really care if there's an // exception when closing the stream. E.g. if it // throws "ZIP file must have at least one entry", // because an exception happened before we added // any files, then we must swallow this // exception. Otherwise, the error that's reported // will be the close() error, which is not the // real cause of the problem. if ( success ) { throw ex; } } } protected String getArchiveType() { return archiveType; } } AbstractZipUnArchiver.java 0000664 0000000 0000000 00000021760 11454043605 0035570 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip; /** * * Copyright 2004 The Apache Software Foundation * * Licensed 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. */ import org.codehaus.plexus.archiver.AbstractUnArchiver; import org.codehaus.plexus.archiver.ArchiveFilterException; import org.codehaus.plexus.archiver.ArchiverException; import org.codehaus.plexus.archiver.util.ArchiveEntryUtils; import org.codehaus.plexus.components.io.resources.PlexusIoResource; import org.codehaus.plexus.util.FileUtils; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.Date; import java.util.Enumeration; /** * @author Emmanuel Venisse * @version $Id$ */ public abstract class AbstractZipUnArchiver extends AbstractUnArchiver { private static final String NATIVE_ENCODING = "native-encoding"; private String encoding = "UTF8"; public AbstractZipUnArchiver() { } public AbstractZipUnArchiver( final File sourceFile ) { super( sourceFile ); } /** * Sets the encoding to assume for file names and comments. * *
* Set to native-encoding if you want your platform's native encoding, defaults to UTF8.
*
This class uses the ASi extra field in the format: *
* Value Size Description * ----- ---- ----------- * (Unix3) 0x756e Short tag for this extra block type * TSize Short total data size for this block * CRC Long CRC-32 of the remaining data * Mode Short file permissions * SizDev Long symlink'd size OR major/minor dev num * UID Short user ID * GID Short group ID * (var.) variable symbolic link filename ** taken from appnote.iz (Info-ZIP note, 981119) found at ftp://ftp.uu.net/pub/archiving/zip/doc/ * * *
Short is two bytes and Long is four bytes in big endian byte and * word order, device numbers are currently not supported.
* * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.AsiExtraField v1.10 */ public class AsiExtraField implements ZipExtraField, UnixStat, Cloneable { private static final ZipShort HEADER_ID = new ZipShort( 0x756E ); /** * Standard Unix stat(2) file mode. * * @since 1.1 */ private int mode = 0; /** * User ID. * * @since 1.1 */ private int uid = 0; /** * Group ID. * * @since 1.1 */ private int gid = 0; /** * File this entry points to, if it is a symbolic link. * *empty string - if entry is not a symbolic link.
* * @since 1.1 */ private String link = ""; /** * Is this an entry for a directory? * * @since 1.1 */ private boolean dirFlag = false; /** * Instance used to calculate checksums. * * @since 1.1 */ private CRC32 crc = new CRC32(); public AsiExtraField() { } /** * The Header-ID. * * @since 1.1 */ public ZipShort getHeaderId() { return HEADER_ID; } /** * Length of the extra field in the local file data - without * Header-ID or length specifier. * * @since 1.1 */ public ZipShort getLocalFileDataLength() { return new ZipShort( 4 // CRC + 2 // Mode + 4 // SizDev + 2 // UID + 2 // GID + getLinkedFile().getBytes().length ); } /** * Delegate to local file data. * * @since 1.1 */ public ZipShort getCentralDirectoryLength() { return getLocalFileDataLength(); } /** * The actual data to put into local file data - without Header-ID * or length specifier. * * @since 1.1 */ public byte[] getLocalFileDataData() { // CRC will be added later byte[] data = new byte[getLocalFileDataLength().getValue() - 4]; System.arraycopy( ( new ZipShort( getMode() ) ).getBytes(), 0, data, 0, 2 ); byte[] linkArray = getLinkedFile().getBytes(); System.arraycopy( ( new ZipLong( linkArray.length ) ).getBytes(), 0, data, 2, 4 ); System.arraycopy( ( new ZipShort( getUserId() ) ).getBytes(), 0, data, 6, 2 ); System.arraycopy( ( new ZipShort( getGroupId() ) ).getBytes(), 0, data, 8, 2 ); System.arraycopy( linkArray, 0, data, 10, linkArray.length ); crc.reset(); crc.update( data ); long checksum = crc.getValue(); byte[] result = new byte[data.length + 4]; System.arraycopy( ( new ZipLong( checksum ) ).getBytes(), 0, result, 0, 4 ); System.arraycopy( data, 0, result, 4, data.length ); return result; } /** * Delegate to local file data. * * @since 1.1 */ public byte[] getCentralDirectoryData() { return getLocalFileDataData(); } /** * Set the user id. * * @since 1.1 */ public void setUserId( int uid ) { this.uid = uid; } /** * Get the user id. * * @since 1.1 */ public int getUserId() { return uid; } /** * Set the group id. * * @since 1.1 */ public void setGroupId( int gid ) { this.gid = gid; } /** * Get the group id. * * @since 1.1 */ public int getGroupId() { return gid; } /** * Indicate that this entry is a symbolic link to the given filename. * * @param name Name of the file this entry links to, empty String * if it is not a symbolic link. * @since 1.1 */ public void setLinkedFile( String name ) { link = name; mode = getMode( mode ); } /** * Name of linked file * * @return name of the file this entry links to if it is a * symbolic link, the empty string otherwise. * @since 1.1 */ public String getLinkedFile() { return link; } /** * Is this entry a symbolic link? * * @since 1.1 */ public boolean isLink() { return getLinkedFile().length() != 0; } /** * File mode of this file. * * @since 1.1 */ public void setMode( int mode ) { this.mode = getMode( mode ); } /** * File mode of this file. * * @since 1.1 */ public int getMode() { return mode; } /** * Indicate whether this entry is a directory. * * @since 1.1 */ public void setDirectory( boolean dirFlag ) { this.dirFlag = dirFlag; mode = getMode( mode ); } /** * Is this entry a directory? * * @since 1.1 */ public boolean isDirectory() { return dirFlag && !isLink(); } /** * Populate data from this array as if it was in local file data. * * @since 1.1 */ public void parseFromLocalFileData( byte[] data, int offset, int length ) throws ZipException { long givenChecksum = ( new ZipLong( data, offset ) ).getValue(); byte[] tmp = new byte[length - 4]; System.arraycopy( data, offset + 4, tmp, 0, length - 4 ); crc.reset(); crc.update( tmp ); long realChecksum = crc.getValue(); if ( givenChecksum != realChecksum ) { throw new ZipException( "bad CRC checksum " + Long.toHexString( givenChecksum ) + " instead of " + Long.toHexString( realChecksum ) ); } int newMode = ( new ZipShort( tmp, 0 ) ).getValue(); byte[] linkArray = new byte[(int) ( new ZipLong( tmp, 2 ) ).getValue()]; uid = ( new ZipShort( tmp, 6 ) ).getValue(); gid = ( new ZipShort( tmp, 8 ) ).getValue(); if ( linkArray.length == 0 ) { link = ""; } else { System.arraycopy( tmp, 10, linkArray, 0, linkArray.length ); link = new String( linkArray ); } setDirectory( ( newMode & DIR_FLAG ) != 0 ); setMode( newMode ); } /** * Get the file mode for given permissions with the correct file type. * * @since 1.1 */ protected int getMode( int mode ) { int type = FILE_FLAG; if ( isLink() ) { type = LINK_FLAG; } else if ( isDirectory() ) { type = DIR_FLAG; } return type | ( mode & PERM_MASK ); } } ExtraFieldUtils.java 0000664 0000000 0000000 00000013725 11454043605 0034425 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip; /* * Copyright 2001-2002,2004 The Apache Software Foundation * * Licensed 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. * */ import java.util.Hashtable; import java.util.Vector; import java.util.zip.ZipException; /** * ZipExtraField related methods * * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.ExtraFieldUtils v1.9 */ public class ExtraFieldUtils { /** * Static registry of known extra fields. * * @since 1.1 */ private static Hashtable implementations; static { implementations = new Hashtable(); register( AsiExtraField.class ); } /** * Register a ZipExtraField implementation. * *The given class must have a no-arg constructor and implement * the {@link ZipExtraField ZipExtraField interface}.
* * @since 1.1 */ public static void register( Class c ) { try { ZipExtraField ze = (ZipExtraField) c.newInstance(); implementations.put( ze.getHeaderId(), c ); } catch ( ClassCastException cc ) { throw new RuntimeException( c + " doesn\'t implement ZipExtraField" ); } catch ( InstantiationException ie ) { throw new RuntimeException( c + " is not a concrete class" ); } catch ( IllegalAccessException ie ) { throw new RuntimeException( c + "\'s no-arg constructor is not public" ); } } /** * Create an instance of the approriate ExtraField, falls back to * {@link UnrecognizedExtraField UnrecognizedExtraField}. * * @since 1.1 */ public static ZipExtraField createExtraField( ZipShort headerId ) throws InstantiationException, IllegalAccessException { Class c = (Class) implementations.get( headerId ); if ( c != null ) { return (ZipExtraField) c.newInstance(); } UnrecognizedExtraField u = new UnrecognizedExtraField(); u.setHeaderId( headerId ); return u; } /** * Split the array into ExtraFields and populate them with the * give data. * * @since 1.1 */ public static ZipExtraField[] parse( byte[] data ) throws ZipException { Vector v = new Vector(); int start = 0; while ( start <= data.length - 4 ) { ZipShort headerId = new ZipShort( data, start ); int length = ( new ZipShort( data, start + 2 ) ).getValue(); if ( start + 4 + length > data.length ) { throw new ZipException( "data starting at " + start + " is in unknown format" ); } try { ZipExtraField ze = createExtraField( headerId ); ze.parseFromLocalFileData( data, start + 4, length ); v.addElement( ze ); } catch ( InstantiationException ie ) { throw new ZipException( ie.getMessage() ); } catch ( IllegalAccessException iae ) { throw new ZipException( iae.getMessage() ); } start += ( length + 4 ); } if ( start != data.length ) { // array not exhausted throw new ZipException( "data starting at " + start + " is in unknown format" ); } ZipExtraField[] result = new ZipExtraField[v.size()]; v.copyInto( result ); return result; } /** * Merges the local file data fields of the given ZipExtraFields. * * @since 1.1 */ public static byte[] mergeLocalFileDataData( ZipExtraField[] data ) { int sum = 4 * data.length; for ( int i = 0; i < data.length; i++ ) { sum += data[ i ].getLocalFileDataLength().getValue(); } byte[] result = new byte[sum]; int start = 0; for ( int i = 0; i < data.length; i++ ) { System.arraycopy( data[ i ].getHeaderId().getBytes(), 0, result, start, 2 ); System.arraycopy( data[ i ].getLocalFileDataLength().getBytes(), 0, result, start + 2, 2 ); byte[] local = data[ i ].getLocalFileDataData(); System.arraycopy( local, 0, result, start + 4, local.length ); start += ( local.length + 4 ); } return result; } /** * Merges the central directory fields of the given ZipExtraFields. * * @since 1.1 */ public static byte[] mergeCentralDirectoryData( ZipExtraField[] data ) { int sum = 4 * data.length; for ( int i = 0; i < data.length; i++ ) { sum += data[ i ].getCentralDirectoryLength().getValue(); } byte[] result = new byte[sum]; int start = 0; for ( int i = 0; i < data.length; i++ ) { System.arraycopy( data[ i ].getHeaderId().getBytes(), 0, result, start, 2 ); System.arraycopy( data[ i ].getCentralDirectoryLength().getBytes(), 0, result, start + 2, 2 ); byte[] local = data[ i ].getCentralDirectoryData(); System.arraycopy( local, 0, result, start + 4, local.length ); start += ( local.length + 4 ); } return result; } } PlexusIoZipFileResourceCollection.java 0000664 0000000 0000000 00000002507 11454043605 0040130 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip; import org.codehaus.plexus.components.io.resources.AbstractPlexusIoArchiveResourceCollection; import java.io.File; import java.io.IOException; import java.util.Enumeration; import java.util.Iterator; public class PlexusIoZipFileResourceCollection extends AbstractPlexusIoArchiveResourceCollection { /** * The zip file resource collections role hint. */ public static final String ROLE_HINT = "zip"; protected Iterator getEntries() throws IOException { final File f = getFile(); if ( f == null ) { throw new IOException( "The tar archive file has not been set." ); } final ZipFile zipFile = new ZipFile( f ); final Enumeration en = zipFile.getEntries(); return new Iterator(){ public boolean hasNext() { return en.hasMoreElements(); } public Object next() { final ZipEntry entry = (ZipEntry) en.nextElement(); final ZipResource res = new ZipResource( zipFile, entry ); return res; } public void remove() { throw new UnsupportedOperationException( "Removing isn't implemented." ); } }; } } UnrecognizedExtraField.java 0000664 0000000 0000000 00000005125 11454043605 0035754 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip; /* * Copyright 2001-2002,2004 The Apache Software Foundation * * Licensed 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. * */ /** * Simple placeholder for all those extra fields we don't want to deal * with. * *Assumes local file data and central directory entries are * identical - unless told the opposite.
* * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.UnrecognizedExtraField v1.8 */ public class UnrecognizedExtraField implements ZipExtraField { /** * The Header-ID. * * @since 1.1 */ private ZipShort headerId; public void setHeaderId( ZipShort headerId ) { this.headerId = headerId; } public ZipShort getHeaderId() { return headerId; } /** * Extra field data in local file data - without * Header-ID or length specifier. * * @since 1.1 */ private byte[] localData; public void setLocalFileDataData( byte[] data ) { localData = data; } public ZipShort getLocalFileDataLength() { return new ZipShort( localData.length ); } public byte[] getLocalFileDataData() { return localData; } /** * Extra field data in central directory - without * Header-ID or length specifier. * * @since 1.1 */ private byte[] centralData; public void setCentralDirectoryData( byte[] data ) { centralData = data; } public ZipShort getCentralDirectoryLength() { if ( centralData != null ) { return new ZipShort( centralData.length ); } return getLocalFileDataLength(); } public byte[] getCentralDirectoryData() { if ( centralData != null ) { return centralData; } return getLocalFileDataData(); } public void parseFromLocalFileData( byte[] data, int offset, int length ) { byte[] tmp = new byte[length]; System.arraycopy( data, offset, tmp, 0, length ); setLocalFileDataData( tmp ); } } plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipArchiver.java 0000664 0000000 0000000 00000001364 11454043605 0033656 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.zip; /** * * Copyright 2004 The Apache Software Foundation * * Licensed 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. */ /** * @version $Id$ */ public class ZipArchiver extends AbstractZipArchiver { } plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipEntry.java 0000664 0000000 0000000 00000031667 11454043605 0033225 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.zip; /* * Copyright 2001-2004 The Apache Software Foundation * * Licensed 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. * */ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Vector; import java.util.zip.ZipException; import org.codehaus.plexus.archiver.ArchiveFile; /** * Extension that adds better handling of extra fields and provides * access to the internal and external file attributes. * * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.ZipEntry v1.16 */ public class ZipEntry extends java.util.zip.ZipEntry implements Cloneable, ArchiveFile.Entry { private static final int PLATFORM_UNIX = 3; private static final int PLATFORM_FAT = 0; private int internalAttributes = 0; private int platform = PLATFORM_FAT; private long externalAttributes = 0; private Vector extraFields = new Vector(); private String name = null; /** * Creates a new zip entry with the specified name. * * @since 1.1 */ public ZipEntry( String name ) { super( name ); } /** * Creates a new zip entry with fields taken from the specified zip entry. * * @since 1.1 */ public ZipEntry( java.util.zip.ZipEntry entry ) throws ZipException { /* * REVISIT: call super(entry) instead of this stuff in Ant2, * "copy constructor" has not been available in JDK 1.1 */ super( entry.getName() ); setComment( entry.getComment() ); setMethod( entry.getMethod() ); setTime( entry.getTime() ); long size = entry.getSize(); if ( size > 0 ) { setSize( size ); } long cSize = entry.getCompressedSize(); if ( cSize > 0 ) { setComprSize( cSize ); } long crc = entry.getCrc(); if ( crc > 0 ) { setCrc( crc ); } 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. * * @since 1.1 */ public ZipEntry( ZipEntry entry ) throws ZipException { this( (java.util.zip.ZipEntry) entry ); setInternalAttributes( entry.getInternalAttributes() ); setExternalAttributes( entry.getExternalAttributes() ); setExtraFields( entry.getExtraFields() ); } /** * @since 1.9 */ protected ZipEntry() { super( "" ); } /** * Overwrite clone * * @since 1.1 */ public Object clone() { try { ZipEntry e = (ZipEntry) super.clone(); e.setName( getName() ); e.setComment( getComment() ); e.setMethod( getMethod() ); e.setTime( getTime() ); long size = getSize(); if ( size > 0 ) { e.setSize( size ); } long cSize = getCompressedSize(); if ( cSize > 0 ) { e.setComprSize( cSize ); } long crc = getCrc(); if ( crc > 0 ) { e.setCrc( crc ); } e.extraFields = (Vector) extraFields.clone(); e.setInternalAttributes( getInternalAttributes() ); e.setExternalAttributes( getExternalAttributes() ); e.setExtraFields( getExtraFields() ); return e; } catch ( Throwable t ) { // in JDK 1.1 ZipEntry is not Cloneable, so super.clone declares // to throw CloneNotSupported - since JDK 1.2 it is overridden to // not throw that exception return null; } } /** * Retrieves the internal file attributes. * * @since 1.1 */ public int getInternalAttributes() { return internalAttributes; } /** * Sets the internal file attributes. * * @since 1.1 */ public void setInternalAttributes( int value ) { internalAttributes = value; } /** * Retrieves the external file attributes. * * @since 1.1 */ public long getExternalAttributes() { return externalAttributes; } /** * Sets the external file attributes. * * @since 1.1 */ public void setExternalAttributes( long value ) { externalAttributes = value; } /** * Sets Unix permissions in a way that is understood by Info-Zip's * unzip command. * * @since Ant 1.5.2 */ public void setUnixMode( int mode ) { setExternalAttributes( ( mode << 16 ) // MS-DOS read-only attribute | ( ( mode & 0200 ) == 0 ? 1 : 0 ) // MS-DOS directory flag | ( isDirectory() ? 0x10 : 0 ) ); platform = PLATFORM_UNIX; } /** * Unix permission. * * @since Ant 1.6 */ public int getUnixMode() { return (int) ( ( getExternalAttributes() >> 16 ) & 0xFFFF ); } /** * Platform specification to put into the "version made * by" part of the central file header. * * @return 0 (MS-DOS FAT) unless {@link #setUnixMode setUnixMode} * has been called, in which case 3 (Unix) will be returned. * @since Ant 1.5.2 */ public int getPlatform() { return platform; } /** * @since 1.9 */ protected void setPlatform( int platform ) { this.platform = platform; } /** * Replaces all currently attached extra fields with the new array. * * @since 1.1 */ public void setExtraFields( ZipExtraField[] fields ) { extraFields.removeAllElements(); for ( int i = 0; i < fields.length; i++ ) { extraFields.addElement( fields[ i ] ); } setExtra(); } /** * Retrieves extra fields. * * @since 1.1 */ public ZipExtraField[] getExtraFields() { ZipExtraField[] result = new ZipExtraField[extraFields.size()]; extraFields.copyInto( result ); return result; } /** * Adds an extra fields - replacing an already present extra field * of the same type. * * @since 1.1 */ public void addExtraField( ZipExtraField ze ) { ZipShort type = ze.getHeaderId(); boolean done = false; for ( int i = 0; !done && i < extraFields.size(); i++ ) { if ( ( (ZipExtraField) extraFields.elementAt( i ) ).getHeaderId().equals( type ) ) { extraFields.setElementAt( ze, i ); done = true; } } if ( !done ) { extraFields.addElement( ze ); } setExtra(); } /** * Remove an extra fields. * * @since 1.1 */ public void removeExtraField( ZipShort type ) { boolean done = false; for ( int i = 0; !done && i < extraFields.size(); i++ ) { if ( ( (ZipExtraField) extraFields.elementAt( i ) ).getHeaderId().equals( type ) ) { extraFields.removeElementAt( i ); done = true; } } if ( !done ) { throw new java.util.NoSuchElementException(); } setExtra(); } /** * Throws an Exception if extra data cannot be parsed into extra fields. * * @since 1.1 */ public void setExtra( byte[] extra ) throws RuntimeException { try { setExtraFields( ExtraFieldUtils.parse( extra ) ); } catch ( Exception e ) { throw new RuntimeException( e.getMessage() ); } } /** * 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() ) ); } /** * Retrieves the extra data for the local file data. * * @since 1.1 */ public byte[] getLocalFileDataExtra() { byte[] extra = getExtra(); return extra != null ? extra : new byte[0]; } /** * Retrieves the extra data for the central directory. * * @since 1.1 */ public byte[] getCentralDirectoryExtra() { return ExtraFieldUtils.mergeCentralDirectoryData( getExtraFields() ); } /** * Helper for JDK 1.1 <-> 1.2 incompatibility. * * @since 1.2 */ private Long compressedSize = null; /** * 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.
* * @since 1.2 */ public void setComprSize( long size ) { if ( haveSetCompressedSize() ) { performSetCompressedSize( this, size ); } else { compressedSize = new Long( size ); } } /** * Override to make this class work in JDK 1.1 like a 1.2 class. * * @since 1.2 */ public long getCompressedSize() { if ( compressedSize != null ) { // has been set explicitly and we are running in a 1.1 VM return compressedSize.longValue(); } return super.getCompressedSize(); } /** * @since 1.9 */ public String getName() { return name == null ? super.getName() : name; } /** * @since 1.10 */ public boolean isDirectory() { return getName().endsWith( "/" ); } protected void setName( String name ) { this.name = name; } /** * Helper for JDK 1.1 * * @since 1.2 */ private static Method setCompressedSizeMethod = null; /** * Helper for JDK 1.1 * * @since 1.2 */ private final static Object lockReflection = new Object(); /** * Helper for JDK 1.1 * * @since 1.2 */ private static boolean triedToGetMethod = false; /** * Are we running JDK 1.2 or higher? * * @since 1.2 */ private static boolean haveSetCompressedSize() { checkSCS(); return setCompressedSizeMethod != null; } /** * Invoke setCompressedSize via reflection. * * @since 1.2 */ private static void performSetCompressedSize( ZipEntry ze, long size ) { Long[] s = {new Long( size )}; try { setCompressedSizeMethod.invoke( ze, s ); } catch ( InvocationTargetException ite ) { Throwable nested = ite.getTargetException(); throw new RuntimeException( "Exception setting the compressed size " + "of " + ze + ": " + nested.getMessage() ); } catch ( Throwable other ) { throw new RuntimeException( "Exception setting the compressed size " + "of " + ze + ": " + other.getMessage() ); } } /** * Try to get a handle to the setCompressedSize method. * * @since 1.2 */ private static void checkSCS() { if ( !triedToGetMethod ) { synchronized ( lockReflection ) { triedToGetMethod = true; try { setCompressedSizeMethod = java.util.zip.ZipEntry.class.getMethod( "setCompressedSize", new Class[]{Long.TYPE} ); } catch ( NoSuchMethodException nse ) { // ignored } } } } public long getLastModificationTime() { return getTime(); } } ZipExtraField.java 0000664 0000000 0000000 00000004266 11454043605 0034067 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip; /* * Copyright 2001,2004 The Apache Software Foundation * * Licensed 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. * */ import java.util.zip.ZipException; /** * General format of extra field data. * *Extra fields usually appear twice per file, once in the local * file data and once in the central directory. Usually they are the * same, but they don't have to be. {@link * java.util.zip.ZipOutputStream java.util.zip.ZipOutputStream} will * only use the local file data in both places.
* * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.ZipExtraField v1.9 */ public interface ZipExtraField { /** * The Header-ID. * * @since 1.1 */ ZipShort getHeaderId(); /** * Length of the extra field in the local file data - without * Header-ID or length specifier. * * @since 1.1 */ ZipShort getLocalFileDataLength(); /** * Length of the extra field in the central directory - without * Header-ID or length specifier. * * @since 1.1 */ ZipShort getCentralDirectoryLength(); /** * The actual data to put into local file data - without Header-ID * or length specifier. * * @since 1.1 */ byte[] getLocalFileDataData(); /** * The actual data to put central directory - without Header-ID or * length specifier. * * @since 1.1 */ byte[] getCentralDirectoryData(); /** * Populate data from this array as if it was in local file data. * * @since 1.1 */ void parseFromLocalFileData( byte[] data, int offset, int length ) throws ZipException; } plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipFile.java 0000664 0000000 0000000 00000046577 11454043605 0033011 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.zip; /* * Copyright 2003-2004 The Apache Software Foundation * * Licensed 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. * */ import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.RandomAccessFile; import java.io.UnsupportedEncodingException; import java.util.Calendar; import java.util.Date; import java.util.Enumeration; import java.util.Hashtable; import java.util.zip.Inflater; import java.util.zip.InflaterInputStream; import java.util.zip.ZipException; import org.codehaus.plexus.archiver.ArchiveFile; /** * Replacement forjava.util.ZipFile.
*
* This class adds support for file name encodings other than UTF-8
* (which is required to work on ZIP files created by native zip tools
* and is able to skip a preamble like the one found in self
* extracting archives. Furthermore it returns instances of
* org.apache.tools.zip.ZipEntry instead of
* java.util.zip.ZipEntry.
It doesn't extend java.util.zip.ZipFile as it would
* have to reimplement all methods anyway. Like
* java.util.ZipFile, it uses RandomAccessFile under the
* covers and supports compressed and uncompressed entries.
The method signatures mimic the ones of
* java.util.zip.ZipFile, with a couple of exceptions:
*
org.apache.tools.zip.ZipEntry instances.For a list of possible values see http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html. * Defaults to the platform's default character encoding.
*/ private String encoding = null; /** * The actual data source. */ private RandomAccessFile archive; /** * Opens the given file for reading, assuming the platform's * native encoding for file names. * * @param f the archive. * @throws IOException if an error occurs while reading the file. */ public ZipFile( File f ) throws IOException { this( f, null ); } /** * Opens the given file for reading, assuming the platform's * native encoding for file names. * * @param name name of the archive. * @throws IOException if an error occurs while reading the file. */ public ZipFile( String name ) throws IOException { this( new File( name ), null ); } /** * Opens the given file for reading, assuming the specified * encoding for file names. * * @param name name of the archive. * @param encoding the encoding to use for file names * @throws IOException if an error occurs while reading the file. */ public ZipFile( String name, String encoding ) throws IOException { this( new File( name ), encoding ); } /** * Opens the given file for reading, assuming the specified * encoding for file names. * * @param f the archive. * @param encoding the encoding to use for file names * @throws IOException if an error occurs while reading the file. */ public ZipFile( File f, String encoding ) throws IOException { this.encoding = encoding; archive = new RandomAccessFile( f, "r" ); populateFromCentralDirectory(); resolveLocalFileHeaderData(); } /** * The encoding to use for filenames and the file comment. * * @return null if using the platform's default character encoding. */ public String getEncoding() { return encoding; } /** * Closes the archive. * * @throws IOException if an error occurs closing the archive. */ public void close() throws IOException { archive.close(); } /** * Returns all entries. * * @return all entries as {@link ZipEntry} instances */ public Enumeration getEntries() { return entries.keys(); } /** * Returns a named entry - ornull if no entry by
* that name exists.
*
* @param name name of the entry.
* @return the ZipEntry corresponding to the given name - or
* null if not present.
*/
public ZipEntry getEntry( String name )
{
return (ZipEntry) nameMap.get( name );
}
public InputStream getInputStream( ArchiveFile.Entry entry )
throws IOException
{
return getInputStream( (ZipEntry) entry );
}
/**
* Returns an InputStream for reading the contents of the given entry.
*
* @param ze the entry to get the stream for.
* @return a stream to read the entry from.
*/
public InputStream getInputStream( ZipEntry ze )
throws IOException, ZipException
{
Long start = (Long) dataOffsets.get( ze );
if ( start == null )
{
return null;
}
BoundedInputStream bis =
new BoundedInputStream( start.longValue(), ze.getCompressedSize() );
switch ( ze.getMethod() )
{
case ZipEntry.STORED:
return bis;
case ZipEntry.DEFLATED:
bis.addDummy();
return new InflaterInputStream( bis, new Inflater( true ) );
default:
throw new ZipException( "Found unsupported compression method "
+ ze.getMethod() );
}
}
private static final int CFH_LEN =
/* version made by */ 2 +
/* version needed to extract */ 2 +
/* general purpose bit flag */ 2 +
/* compression method */ 2 +
/* last mod file time */ 2 +
/* last mod file date */ 2 +
/* crc-32 */ 4 +
/* compressed size */ 4 +
/* uncompressed size */ 4 +
/* filename length */ 2 +
/* extra field length */ 2 +
/* file comment length */ 2 +
/* disk number start */ 2 +
/* internal file attributes */ 2 +
/* external file attributes */ 4 +
/* relative offset of local header */ 4;
/**
* Reads the central directory of the given archive and populates
* the internal tables with ZipEntry instances.
*
* The ZipEntrys will know all data that can be obtained from * the central directory alone, but not the data that requires the * local file header or additional data to be read.
*/ private void populateFromCentralDirectory() throws IOException { positionAtCentralDirectory(); byte[] cfh = new byte[CFH_LEN]; byte[] signatureBytes = new byte[4]; archive.readFully( signatureBytes ); ZipLong sig = new ZipLong( signatureBytes ); while ( sig.equals( ZipOutputStream.CFH_SIG ) ) { archive.readFully( cfh ); int off = 0; ZipEntry ze = new ZipEntry(); ZipShort versionMadeBy = new ZipShort( cfh, off ); off += 2; ze.setPlatform( ( versionMadeBy.getValue() >> 8 ) & 0x0F ); off += 4; // skip version info and general purpose byte ze.setMethod( ( new ZipShort( cfh, off ) ).getValue() ); off += 2; ze.setTime( fromDosTime( new ZipLong( cfh, off ) ).getTime() ); off += 4; ze.setCrc( ( new ZipLong( cfh, off ) ).getValue() ); off += 4; ze.setCompressedSize( ( new ZipLong( cfh, off ) ).getValue() ); off += 4; ze.setSize( ( new ZipLong( cfh, off ) ).getValue() ); off += 4; int fileNameLen = ( new ZipShort( cfh, off ) ).getValue(); off += 2; int extraLen = ( new ZipShort( cfh, off ) ).getValue(); off += 2; int commentLen = ( new ZipShort( cfh, off ) ).getValue(); off += 2; off += 2; // disk number ze.setInternalAttributes( ( new ZipShort( cfh, off ) ).getValue() ); off += 2; ze.setExternalAttributes( ( new ZipLong( cfh, off ) ).getValue() ); off += 4; // LFH offset entries.put( ze, new Long( ( new ZipLong( cfh, off ) ).getValue() ) ); byte[] fileName = new byte[fileNameLen]; archive.readFully( fileName ); ze.setName( getString( fileName ) ); nameMap.put( ze.getName(), ze ); archive.skipBytes( extraLen ); byte[] comment = new byte[commentLen]; archive.readFully( comment ); ze.setComment( getString( comment ) ); archive.readFully( signatureBytes ); sig = new ZipLong( signatureBytes ); } } private static final int MIN_EOCD_SIZE = /* end of central dir signature */ 4 + /* number of this disk */ 2 + /* number of the disk with the */ + /* start of the central directory */ 2 + /* total number of entries in */ + /* the central dir on this disk */ 2 + /* total number of entries in */ + /* the central dir */ 2 + /* size of the central directory */ 4 + /* offset of start of central */ + /* directory with respect to */ + /* the starting disk number */ 4 + /* zipfile comment length */ 2; private static final int CFD_LOCATOR_OFFSET = /* end of central dir signature */ 4 + /* number of this disk */ 2 + /* number of the disk with the */ + /* start of the central directory */ 2 + /* total number of entries in */ + /* the central dir on this disk */ 2 + /* total number of entries in */ + /* the central dir */ 2 + /* size of the central directory */ 4; /** * Searches for the "End of central dir record", parses * it and positions the stream at the first central directory * record. */ private void positionAtCentralDirectory() throws IOException { long off = archive.length() - MIN_EOCD_SIZE; archive.seek( off ); byte[] sig = ZipOutputStream.EOCD_SIG.getBytes(); int curr = archive.read(); boolean found = false; while ( curr != -1 ) { if ( curr == sig[ 0 ] ) { curr = archive.read(); if ( curr == sig[ 1 ] ) { curr = archive.read(); if ( curr == sig[ 2 ] ) { curr = archive.read(); if ( curr == sig[ 3 ] ) { found = true; break; } } } } archive.seek( --off ); curr = archive.read(); } if ( !found ) { throw new ZipException( "archive is not a ZIP archive" ); } archive.seek( off + CFD_LOCATOR_OFFSET ); byte[] cfdOffset = new byte[4]; archive.readFully( cfdOffset ); archive.seek( ( new ZipLong( cfdOffset ) ).getValue() ); } /** * Number of bytes in local file header up to the "length of * filename" entry. */ private static final long LFH_OFFSET_FOR_FILENAME_LENGTH = /* local file header signature */ 4 + /* version needed to extract */ 2 + /* general purpose bit flag */ 2 + /* compression method */ 2 + /* last mod file time */ 2 + /* last mod file date */ 2 + /* crc-32 */ 4 + /* compressed size */ 4 + /* uncompressed size */ 4; /** * Walks through all recorded entries and adds the data available * from the local file header. * *Also records the offsets for the data to read from the * entries.
*/ private void resolveLocalFileHeaderData() throws IOException { Enumeration e = getEntries(); while ( e.hasMoreElements() ) { ZipEntry ze = (ZipEntry) e.nextElement(); long offset = ( (Long) entries.get( ze ) ).longValue(); archive.seek( offset + LFH_OFFSET_FOR_FILENAME_LENGTH ); byte[] b = new byte[2]; archive.readFully( b ); int fileNameLen = ( new ZipShort( b ) ).getValue(); archive.readFully( b ); int extraFieldLen = ( new ZipShort( b ) ).getValue(); archive.skipBytes( fileNameLen ); byte[] localExtraData = new byte[extraFieldLen]; archive.readFully( localExtraData ); ze.setExtra( localExtraData ); dataOffsets.put( ze, new Long( offset + LFH_OFFSET_FOR_FILENAME_LENGTH + 2 + 2 + fileNameLen + extraFieldLen ) ); } } /** * Convert a DOS date/time field to a Date object. * * @param l contains the stored DOS time. * @return a Date instance corresponding to the given time. */ protected static Date fromDosTime( ZipLong l ) { long dosTime = l.getValue(); Calendar cal = Calendar.getInstance(); cal.set( Calendar.YEAR, (int) ( ( dosTime >> 25 ) & 0x7f ) + 1980 ); cal.set( Calendar.MONTH, (int) ( ( dosTime >> 21 ) & 0x0f ) - 1 ); cal.set( Calendar.DATE, (int) ( dosTime >> 16 ) & 0x1f ); cal.set( Calendar.HOUR_OF_DAY, (int) ( dosTime >> 11 ) & 0x1f ); cal.set( Calendar.MINUTE, (int) ( dosTime >> 5 ) & 0x3f ); cal.set( Calendar.SECOND, (int) ( dosTime << 1 ) & 0x3e ); return cal.getTime(); } /** * Retrieve a String from the given bytes using the encoding set * for this ZipFile. * * @param bytes the byte array to transform * @return String obtained by using the given encoding * @throws ZipException if the encoding cannot be recognized. */ protected String getString( byte[] bytes ) throws ZipException { if ( encoding == null ) { return new String( bytes ); } else { try { return new String( bytes, encoding ); } catch ( UnsupportedEncodingException uee ) { throw new ZipException( uee.getMessage() ); } } } /** * InputStream that delegates requests to the underlying * RandomAccessFile, making sure that only bytes from a certain * range can be read. */ private class BoundedInputStream extends InputStream { private long remaining; private long loc; private boolean addDummyByte = false; BoundedInputStream( long start, long remaining ) { this.remaining = remaining; loc = start; } public int read() throws IOException { if ( remaining-- <= 0 ) { if ( addDummyByte ) { addDummyByte = false; return 0; } return -1; } synchronized ( archive ) { archive.seek( loc++ ); return archive.read(); } } public int read( byte[] b, int off, int len ) throws IOException { if ( remaining <= 0 ) { if ( addDummyByte ) { addDummyByte = false; b[ off ] = 0; return 1; } return -1; } if ( len <= 0 ) { return 0; } if ( len > remaining ) { len = (int) remaining; } int ret; synchronized ( archive ) { archive.seek( loc ); ret = archive.read( b, off, len ); } if ( ret > 0 ) { loc += ret; remaining -= ret; } return ret; } /** * Inflater needs an extra dummy byte for nowrap - see * Inflater's javadocs. */ void addDummy() { addDummyByte = true; } } } plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipLong.java 0000664 0000000 0000000 00000005225 11454043605 0033012 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.zip; /* * Copyright 2001-2002,2004 The Apache Software Foundation * * Licensed 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. * */ /** * Utility class that represents a four byte integer with conversion * rules for the big endian byte order of ZIP files. * * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.ZipLong v1.10 */ public final class ZipLong implements Cloneable { private long value; /** * Create instance from a number. * * @since 1.1 */ public ZipLong( long value ) { this.value = value; } /** * Create instance from bytes. * * @since 1.1 */ public ZipLong( byte[] bytes ) { this( bytes, 0 ); } /** * Create instance from the four bytes starting at offset. * * @since 1.1 */ public ZipLong( byte[] bytes, int offset ) { value = ( bytes[ offset + 3 ] << 24 ) & 0xFF000000L; value += ( bytes[ offset + 2 ] << 16 ) & 0xFF0000; value += ( bytes[ offset + 1 ] << 8 ) & 0xFF00; value += ( bytes[ offset ] & 0xFF ); } /** * Get value as two bytes in big endian byte order. * * @since 1.1 */ public byte[] getBytes() { byte[] result = new byte[4]; result[ 0 ] = (byte) ( ( value & 0xFF ) ); result[ 1 ] = (byte) ( ( value & 0xFF00 ) >> 8 ); result[ 2 ] = (byte) ( ( value & 0xFF0000 ) >> 16 ); result[ 3 ] = (byte) ( ( value & 0xFF000000l ) >> 24 ); return result; } /** * Get value as Java int. * * @since 1.1 */ public long getValue() { return value; } /** * Override to make two instances with same value equal. * * @since 1.1 */ public boolean equals( Object o ) { if ( o == null || !( o instanceof ZipLong ) ) { return false; } return value == ( (ZipLong) o ).getValue(); } /** * Override to make two instances with same value equal. * * @since 1.1 */ public int hashCode() { return (int) value; } } ZipOutputStream.java 0000664 0000000 0000000 00000057261 11454043605 0034517 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-1.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip; /* * Copyright 2001-2004 The Apache Software Foundation * * Licensed 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. * */ import java.io.File; import java.io.FileOutputStream; import java.io.FilterOutputStream; import java.io.IOException; import java.io.OutputStream; import java.io.RandomAccessFile; import java.io.UnsupportedEncodingException; import java.util.Date; import java.util.Hashtable; import java.util.Vector; import java.util.zip.CRC32; import java.util.zip.Deflater; import java.util.zip.ZipException; /** * Reimplementation of {@link java.util.zip.ZipOutputStream * java.util.zip.ZipOutputStream} that does handle the extended * functionality of this package, especially internal/external file * attributes and extra fields with different layouts for local file * data and central directory entries. * *This class will try to use {@link java.io.RandomAccessFile * RandomAccessFile} when you know that the output is going to go to a * file.
* *If RandomAccessFile cannot be used, this implementation will use * a Data Descriptor to store size and CRC information for {@link * #DEFLATED DEFLATED} entries, this means, you don't need to * calculate them yourself. Unfortunately this is not possible for * the {@link #STORED STORED} method, here setting the CRC and * uncompressed size information is required before {@link * #putNextEntry putNextEntry} can be called.
* * @version $Revision$ $Date$ * from org.apache.ant.tools.zip.ZipOutputStream v1.24 */ public class ZipOutputStream extends FilterOutputStream { /** * Current entry. * * @since 1.1 */ private ZipEntry entry; /** * The file comment. * * @since 1.1 */ private String comment = ""; /** * Compression level for next entry. * * @since 1.1 */ private int level = Deflater.DEFAULT_COMPRESSION; /** * Has the compression level changed when compared to the last * entry? * * @since 1.5 */ private boolean hasCompressionLevelChanged = false; /** * Default compression method for next entry. * * @since 1.1 */ private int method = DEFLATED; /** * List of ZipEntries written so far. * * @since 1.1 */ private Vector entries = new Vector(); /** * CRC instance to avoid parsing DEFLATED data twice. * * @since 1.1 */ private CRC32 crc = new CRC32(); /** * Count the bytes written to out. * * @since 1.1 */ private long written = 0; /** * Data for local header data * * @since 1.1 */ private long dataStart = 0; /** * Offset for CRC entry in the local file header data for the * current entry starts here. * * @since 1.15 */ private long localDataStart = 0; /** * Start of central directory. * * @since 1.1 */ private ZipLong cdOffset = new ZipLong( 0 ); /** * Length of central directory. * * @since 1.1 */ private ZipLong cdLength = new ZipLong( 0 ); /** * Helper, a 0 as ZipShort. * * @since 1.1 */ private static final byte[] ZERO = {0, 0}; /** * Helper, a 0 as ZipLong. * * @since 1.1 */ private static final byte[] LZERO = {0, 0, 0, 0}; /** * Holds the offsets of the LFH starts for each entry. * * @since 1.1 */ private Hashtable offsets = new Hashtable(); /** * The encoding to use for filenames and the file comment. * *For a list of possible values see http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html. * Defaults to the platform's default character encoding.
* * @since 1.3 */ private String encoding = null; /** * This Deflater object is used for output. * *This attribute is only protected to provide a level of API * backwards compatibility. This class used to extend {@link * java.util.zip.DeflaterOutputStream DeflaterOutputStream} up to * Revision 1.13.
* * @since 1.14 */ protected Deflater def = new Deflater( Deflater.DEFAULT_COMPRESSION, true ); /** * This buffer servers as a Deflater. * *This attribute is only protected to provide a level of API * backwards compatibility. This class used to extend {@link * java.util.zip.DeflaterOutputStream DeflaterOutputStream} up to * Revision 1.13.
* * @since 1.14 */ protected byte[] buf = new byte[512]; /** * Optional random access output. * * @since 1.14 */ private RandomAccessFile raf = null; /** * Compression method for deflated entries. * * @since 1.1 */ public static final int DEFLATED = ZipEntry.DEFLATED; /** * Compression method for deflated entries. * * @since 1.1 */ public static final int STORED = ZipEntry.STORED; /** * Creates a new ZIP OutputStream filtering the underlying stream. * * @since 1.1 */ public ZipOutputStream( OutputStream out ) { super( out ); } /** * Creates a new ZIP OutputStream writing to a File. Will use * random access if possible. * * @since 1.14 */ public ZipOutputStream( File file ) throws IOException { super( null ); try { raf = new RandomAccessFile( file, "rw" ); raf.setLength( 0 ); } catch ( IOException e ) { if ( raf != null ) { try { raf.close(); } catch ( IOException inner ) { // ignore } raf = null; } out = new FileOutputStream( file ); } } /** * This method indicates whether this archive is writing to a seekable stream (i.e., to a random * access file). * *For seekable streams, you don't need to calculate the CRC or * uncompressed size for {@link #STORED} entries before * invoking {@link #putNextEntry}. * * @since 1.17 */ public boolean isSeekable() { return raf != null; } /** * The encoding to use for filenames and the file comment. *
*For a list of possible values see http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html. * Defaults to the platform's default character encoding.
* * @since 1.3 */ public void setEncoding( String encoding ) { this.encoding = encoding; } /** * The encoding to use for filenames and the file comment. * * @return null if using the platform's default character encoding. * @since 1.3 */ public String getEncoding() { return encoding; } /** * Finishs writing the contents and closes this as well as the * underlying stream. * * @since 1.1 */ public void finish() throws IOException { closeEntry(); cdOffset = new ZipLong( written ); for ( int i = 0; i < entries.size(); i++ ) { writeCentralFileHeader( (ZipEntry) entries.elementAt( i ) ); } cdLength = new ZipLong( written - cdOffset.getValue() ); writeCentralDirectoryEnd(); offsets.clear(); entries.removeAllElements(); } /** * Writes all necessary data for this entry. * * @since 1.1 */ public void closeEntry() throws IOException { if ( entry == null ) { return; } long realCrc = crc.getValue(); crc.reset(); if ( entry.getMethod() == DEFLATED ) { def.finish(); while ( !def.finished() ) { deflate(); } entry.setSize( def.getTotalIn() ); entry.setComprSize( def.getTotalOut() ); entry.setCrc( realCrc ); def.reset(); written += entry.getCompressedSize(); } else if ( raf == null ) { if ( entry.getCrc() != realCrc ) { throw new ZipException( "bad CRC checksum for entry " + entry.getName() + ": " + Long.toHexString( entry.getCrc() ) + " instead of " + Long.toHexString( realCrc ) ); } if ( entry.getSize() != written - dataStart ) { throw new ZipException( "bad size for entry " + entry.getName() + ": " + entry.getSize() + " instead of " + ( written - dataStart ) ); } } else { /* method is STORED and we used RandomAccessFile */ long size = written - dataStart; entry.setSize( size ); entry.setComprSize( size ); entry.setCrc( realCrc ); } // If random access output, write the local file header containing // the correct CRC and compressed/uncompressed sizes if ( raf != null ) { long save = raf.getFilePointer(); raf.seek( localDataStart ); writeOut( ( new ZipLong( entry.getCrc() ) ).getBytes() ); writeOut( ( new ZipLong( entry.getCompressedSize() ) ).getBytes() ); writeOut( ( new ZipLong( entry.getSize() ) ).getBytes() ); raf.seek( save ); } writeDataDescriptor( entry ); entry = null; } /** * Begin writing next entry. * * @since 1.1 */ public void putNextEntry( ZipEntry ze ) throws IOException { closeEntry(); entry = ze; entries.addElement( entry ); if ( entry.getMethod() == -1 ) { // not specified entry.setMethod( method ); } if ( entry.getTime() == -1 ) { // not specified entry.setTime( System.currentTimeMillis() ); } // Size/CRC not required if RandomAccessFile is used if ( entry.getMethod() == STORED && raf == null ) { if ( entry.getSize() == -1 ) { throw new ZipException( "uncompressed size is required for" + " STORED method when not writing to a" + " file" ); } if ( entry.getCrc() == -1 ) { throw new ZipException( "crc checksum is required for STORED" + " method when not writing to a file" ); } entry.setComprSize( entry.getSize() ); } if ( entry.getMethod() == DEFLATED && hasCompressionLevelChanged ) { def.setLevel( level ); hasCompressionLevelChanged = false; } writeLocalFileHeader( entry ); } /** * Set the file comment. * * @since 1.1 */ public void setComment( String comment ) { this.comment = comment; } /** * Sets the compression level for subsequent entries. * *Default is Deflater.DEFAULT_COMPRESSION.
* * @since 1.1 */ public void setLevel( int level ) { hasCompressionLevelChanged = ( this.level != level ); this.level = level; } /** * Sets the default compression method for subsequent entries. * *Default is DEFLATED.
* * @since 1.1 */ public void setMethod( int method ) { this.method = method; } /** * Writes bytes to ZIP entry. */ public void write( byte[] b, int offset, int length ) throws IOException { if ( entry.getMethod() == DEFLATED ) { if ( length > 0 ) { if ( !def.finished() ) { def.setInput( b, offset, length ); while ( !def.needsInput() ) { deflate(); } } } } else { writeOut( b, offset, length ); written += length; } crc.update( b, offset, length ); } /** * Writes a single byte to ZIP entry. * *Delegates to the three arg method.
* * @since 1.14 */ public void write( int b ) throws IOException { byte[] buf = new byte[1]; buf[ 0 ] = (byte) ( b & 0xff ); write( buf, 0, 1 ); } /** * Closes this output stream and releases any system resources * associated with the stream. * * @throws IOException if an I/O error occurs. * @since 1.14 */ public void close() throws IOException { finish(); if ( raf != null ) { raf.close(); } if ( out != null ) { out.close(); } } /** * Flushes this output stream and forces any buffered output bytes * to be written out to the stream. * * @throws IOException if an I/O error occurs. * @since 1.14 */ public void flush() throws IOException { if ( out != null ) { out.flush(); } } /* * Various ZIP constants */ /** * local file header signature * * @since 1.1 */ protected static final ZipLong LFH_SIG = new ZipLong( 0X04034B50L ); /** * data descriptor signature * * @since 1.1 */ protected static final ZipLong DD_SIG = new ZipLong( 0X08074B50L ); /** * central file header signature * * @since 1.1 */ protected static final ZipLong CFH_SIG = new ZipLong( 0X02014B50L ); /** * end of central dir signature * * @since 1.1 */ protected static final ZipLong EOCD_SIG = new ZipLong( 0X06054B50L ); /** * Writes next block of compressed data to the output stream. * * @since 1.14 */ protected final void deflate() throws IOException { int len = def.deflate( buf, 0, buf.length ); if ( len > 0 ) { writeOut( buf, 0, len ); } } /** * Writes the local file header entry * * @since 1.1 */ protected void writeLocalFileHeader( ZipEntry ze ) throws IOException { offsets.put( ze, new ZipLong( written ) ); writeOut( LFH_SIG.getBytes() ); written += 4; // version needed to extract // general purpose bit flag if ( ze.getMethod() == DEFLATED && raf == null ) { // requires version 2 as we are going to store length info // in the data descriptor writeOut( ( new ZipShort( 20 ) ).getBytes() ); // bit3 set to signal, we use a data descriptor writeOut( ( new ZipShort( 8 ) ).getBytes() ); } else { writeOut( ( new ZipShort( 10 ) ).getBytes() ); writeOut( ZERO ); } written += 4; // compression method writeOut( ( new ZipShort( ze.getMethod() ) ).getBytes() ); written += 2; // last mod. time and date writeOut( toDosTime( new Date( ze.getTime() ) ).getBytes() ); written += 4; // CRC // compressed length // uncompressed length localDataStart = written; if ( ze.getMethod() == DEFLATED || raf != null ) { writeOut( LZERO ); writeOut( LZERO ); writeOut( LZERO ); } else { writeOut( ( new ZipLong( ze.getCrc() ) ).getBytes() ); writeOut( ( new ZipLong( ze.getSize() ) ).getBytes() ); writeOut( ( new ZipLong( ze.getSize() ) ).getBytes() ); } written += 12; // file name length byte[] name = getBytes( ze.getName() ); writeOut( ( new ZipShort( name.length ) ).getBytes() ); written += 2; // extra field length byte[] extra = ze.getLocalFileDataExtra(); writeOut( ( new ZipShort( extra.length ) ).getBytes() ); written += 2; // file name writeOut( name ); written += name.length; // extra field writeOut( extra ); written += extra.length; dataStart = written; } /** * Writes the data descriptor entry * * @since 1.1 */ protected void writeDataDescriptor( ZipEntry ze ) throws IOException { if ( ze.getMethod() != DEFLATED || raf != null ) { return; } writeOut( DD_SIG.getBytes() ); writeOut( ( new ZipLong( entry.getCrc() ) ).getBytes() ); writeOut( ( new ZipLong( entry.getCompressedSize() ) ).getBytes() ); writeOut( ( new ZipLong( entry.getSize() ) ).getBytes() ); written += 16; } /** * Writes the central file header entry * * @since 1.1 */ protected void writeCentralFileHeader( ZipEntry ze ) throws IOException { writeOut( CFH_SIG.getBytes() ); written += 4; // version made by writeOut( ( new ZipShort( ( ze.getPlatform() << 8 ) | 20 ) ).getBytes() ); written += 2; // version needed to extract // general purpose bit flag if ( ze.getMethod() == DEFLATED && raf == null ) { // requires version 2 as we are going to store length info // in the data descriptor writeOut( ( new ZipShort( 20 ) ).getBytes() ); // bit3 set to signal, we use a data descriptor writeOut( ( new ZipShort( 8 ) ).getBytes() ); } else { writeOut( ( new ZipShort( 10 ) ).getBytes() ); writeOut( ZERO ); } written += 4; // compression method writeOut( ( new ZipShort( ze.getMethod() ) ).getBytes() ); written += 2; // last mod. time and date writeOut( toDosTime( new Date( ze.getTime() ) ).getBytes() ); written += 4; // CRC // compressed length // uncompressed length writeOut( ( new ZipLong( ze.getCrc() ) ).getBytes() ); writeOut( ( new ZipLong( ze.getCompressedSize() ) ).getBytes() ); writeOut( ( new ZipLong( ze.getSize() ) ).getBytes() ); written += 12; // file name length byte[] name = getBytes( ze.getName() ); writeOut( ( new ZipShort( name.length ) ).getBytes() ); written += 2; // extra field length byte[] extra = ze.getCentralDirectoryExtra(); writeOut( ( new ZipShort( extra.length ) ).getBytes() ); written += 2; // file comment length String comm = ze.getComment(); if ( comm == null ) { comm = ""; } byte[] comment = getBytes( comm ); writeOut( ( new ZipShort( comment.length ) ).getBytes() ); written += 2; // disk number start writeOut( ZERO ); written += 2; // internal file attributes writeOut( ( new ZipShort( ze.getInternalAttributes() ) ).getBytes() ); written += 2; // external file attributes writeOut( ( new ZipLong( ze.getExternalAttributes() ) ).getBytes() ); written += 4; // relative offset of LFH writeOut( ( (ZipLong) offsets.get( ze ) ).getBytes() ); written += 4; // file name writeOut( name ); written += name.length; // extra field writeOut( extra ); written += extra.length; // file comment writeOut( comment ); written += comment.length; } /** * Writes the "End of central dir record" * * @since 1.1 */ protected void writeCentralDirectoryEnd() throws IOException { writeOut( EOCD_SIG.getBytes() ); // disk numbers writeOut( ZERO ); writeOut( ZERO ); // number of entries byte[] num = ( new ZipShort( entries.size() ) ).getBytes(); writeOut( num ); writeOut( num ); // length and location of CD writeOut( cdLength.getBytes() ); writeOut( cdOffset.getBytes() ); // ZIP file comment byte[] data = getBytes( comment ); writeOut( ( new ZipShort( data.length ) ).getBytes() ); writeOut( data ); } /** * Smallest date/time ZIP can handle. * * @since 1.1 */ private static final ZipLong DOS_TIME_MIN = new ZipLong( 0x00002100L ); /** * Convert a Date object to a DOS date/time field. * *Stolen from InfoZip's fileio.c