()
{
public boolean hasNext()
{
return en.hasMoreElements();
}
public PlexusIoResource next()
{
final TarEntry entry = (TarEntry) en.nextElement();
return new TarResource( tarFile, entry );
}
public void remove()
{
throw new UnsupportedOperationException( "Removing isn't implemented." );
}
};
}
}
PlexusIoTarGZipFileResourceCollection.java 0000664 0000000 0000000 00000000410 12026402656 0040663 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
import java.io.File;
public class PlexusIoTarGZipFileResourceCollection
extends PlexusIoTarFileResourceCollection
{
protected TarFile newTarFile( File file )
{
return new GZipTarFile( file );
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarArchiver.java 0000664 0000000 0000000 00000042052 12026402656 0033627 0 ustar 00root root 0000000 0000000 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.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.GZIPOutputStream;
import org.codehaus.plexus.archiver.AbstractArchiver;
import org.codehaus.plexus.archiver.ArchiveEntry;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.ResourceIterator;
import org.codehaus.plexus.archiver.UnixStat;
import org.codehaus.plexus.archiver.bzip2.CBZip2OutputStream;
import org.codehaus.plexus.archiver.util.EnumeratedAttribute;
import org.codehaus.plexus.archiver.util.ResourceUtils;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes;
import org.codehaus.plexus.components.io.resources.PlexusIoResource;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.StringUtils;
/**
* @author Emmanuel Venisse
* @version $Revision$ $Date$
*/
public class TarArchiver
extends AbstractArchiver
{
/**
* Indicates whether the user has been warned about long files already.
*/
private boolean longWarningGiven = false;
private TarLongFileMode longFileMode = new TarLongFileMode();
private TarCompressionMethod compression = new TarCompressionMethod();
private TarOptions options = new TarOptions();
private TarOutputStream tOut;
/**
*
*/
public TarOptions getOptions()
{
return options;
}
/**
* Set all tar options
*
* @param options options
*/
public void setOptions( TarOptions options )
{
this.options = options;
// FIXME: do these options have precedence over
// setDefaultFileMode / setDefaultDirMode
// or the other way around? Assuming these
// take precedende since they're more specific.
// Better refactor this when usage is known.
setDefaultFileMode( options.getMode() );
setDefaultDirectoryMode( options.getMode() );
}
// /**
// * Override AbstractArchiver.setDefaultFileMode to
// * update TarOptions.
// */
// public void setDefaultFileMode( int mode )
// {
// super.setDefaultFileMode( mode );
//
// options.setMode( mode );
// }
//
// /**
// * Override AbstractArchiver.setDefaultDirectoryMode to
// * update TarOptions.
// */
// public void setDefaultDirectoryMode( int mode )
// {
// super.setDefaultDirectoryMode( mode );
//
// options.setDirMode( mode );
// }
//
//
/**
* Set how to handle long files, those with a path>100 chars.
* Optional, default=warn.
*
* Allowable values are
*
* - truncate - paths are truncated to the maximum length
*
- fail - paths greater than the maximum cause a build exception
*
- warn - paths greater than the maximum cause a warning and GNU is used
*
- gnu - GNU extensions are used for any paths greater than the maximum.
*
- omit - paths greater than the maximum are omitted from the archive
*
*
* @param mode the mode to handle long file names.
*/
public void setLongfile( TarLongFileMode mode )
{
this.longFileMode = mode;
}
/**
* Set compression method.
* Allowable values are
*
* - none - no compression
*
- gzip - Gzip compression
*
- bzip2 - Bzip2 compression
*
*
* @param mode the compression method.
*/
public void setCompression( TarCompressionMethod mode )
{
this.compression = mode;
}
protected void execute()
throws ArchiverException, IOException
{
if ( !checkForced() )
{
return;
}
ResourceIterator iter = getResources();
if ( !iter.hasNext() )
{
throw new ArchiverException( "You must set at least one file." );
}
File tarFile = getDestFile();
if ( tarFile == null )
{
throw new ArchiverException( "You must set the destination tar file." );
}
if ( tarFile.exists() && !tarFile.isFile() )
{
throw new ArchiverException( tarFile + " isn't a file." );
}
if ( tarFile.exists() && !tarFile.canWrite() )
{
throw new ArchiverException( tarFile + " is read-only." );
}
getLogger().info( "Building tar: " + tarFile.getAbsolutePath() );
tOut = new TarOutputStream(
compression.compress( new BufferedOutputStream( new FileOutputStream( tarFile ) ) ) );
tOut.setDebug( true );
if ( longFileMode.isTruncateMode() )
{
tOut.setLongFileMode( TarOutputStream.LONGFILE_TRUNCATE );
}
else if ( longFileMode.isFailMode() || longFileMode.isOmitMode() )
{
tOut.setLongFileMode( TarOutputStream.LONGFILE_ERROR );
}
else
{
// warn or GNU
tOut.setLongFileMode( TarOutputStream.LONGFILE_GNU );
}
longWarningGiven = false;
while ( iter.hasNext() )
{
ArchiveEntry entry = iter.next();
// Check if we don't add tar file in inself
if ( ResourceUtils.isSame( entry.getResource(), tarFile ) )
{
throw new ArchiverException( "A tar file cannot include itself." );
}
String fileName = entry.getName();
String name = StringUtils.replace( fileName, File.separatorChar, '/' );
tarFile( entry, tOut, name );
}
}
/**
* tar a file
*
* @param entry the file to tar
* @param tOut the output stream
* @param vPath the path name of the file to tar
* @throws IOException on error
*/
protected void tarFile( ArchiveEntry entry, TarOutputStream tOut, String vPath )
throws ArchiverException, IOException
{
InputStream fIn = null;
// don't add "" to the archive
if ( vPath.length() <= 0 )
{
return;
}
if ( entry.getResource().isDirectory() && !vPath.endsWith( "/" ) )
{
vPath += "/";
}
if ( vPath.startsWith( "/" ) && !options.getPreserveLeadingSlashes() )
{
int l = vPath.length();
if ( l <= 1 )
{
// we would end up adding "" to the archive
return;
}
vPath = vPath.substring( 1, l );
}
try
{
if ( vPath.length() >= TarConstants.NAMELEN )
{
if ( longFileMode.isOmitMode() )
{
getLogger().info( "Omitting: " + vPath );
return;
}
else if ( longFileMode.isWarnMode() )
{
getLogger().warn( "Entry: " + vPath + " longer than " + TarConstants.NAMELEN + " characters." );
if ( !longWarningGiven )
{
getLogger().warn( "Resulting tar file can only be processed "
+ "successfully by GNU compatible tar commands" );
longWarningGiven = true;
}
}
else if ( longFileMode.isFailMode() )
{
throw new ArchiverException( "Entry: " + vPath + " longer than " + TarConstants.NAMELEN
+ "characters." );
}
}
TarEntry te = new TarEntry( vPath );
long teLastModified = entry.getResource().getLastModified();
te.setModTime( teLastModified == PlexusIoResource.UNKNOWN_MODIFICATION_DATE ? System.currentTimeMillis()
: teLastModified );
if ( !entry.getResource().isDirectory() )
{
final long size = entry.getResource().getSize();
te.setSize( size == PlexusIoResource.UNKNOWN_RESOURCE_SIZE ? 0 : size );
te.setMode( entry.getMode() );
}
else
{
te.setMode( entry.getMode() );
}
PlexusIoResourceAttributes attributes = entry.getResourceAttributes();
te.setUserName( ( attributes != null && attributes.getUserName() != null ) ? attributes.getUserName()
: options.getUserName() );
te.setGroupName( ( attributes != null && attributes.getGroupName() != null ) ? attributes.getGroupName()
: options.getGroup() );
te.setUserId( ( attributes != null && attributes.getUserId() != null) ? attributes.getUserId()
: options.getUid() );
te.setGroupId( ( attributes != null && attributes.getGroupId() != null) ? attributes.getGroupId()
: options.getGid() );
tOut.putNextEntry( te );
if ( !entry.getResource().isDirectory() )
{
fIn = entry.getInputStream();
byte[] buffer = new byte[8 * 1024];
int count = 0;
do
{
tOut.write( buffer, 0, count );
count = fIn.read( buffer, 0, buffer.length );
}
while ( count != -1 );
}
tOut.closeEntry();
}
finally
{
IOUtil.close( fIn );
}
}
/**
* Valid Modes for Compression attribute to Tar Task
*/
public class TarOptions
{
/**
* @deprecated
*/
private int fileMode = UnixStat.FILE_FLAG | UnixStat.DEFAULT_FILE_PERM;
/**
* @deprecated
*/
private int dirMode = UnixStat.DIR_FLAG | UnixStat.DEFAULT_DIR_PERM;
private String userName = "";
private String groupName = "";
private int uid;
private int gid;
private boolean preserveLeadingSlashes = false;
/**
* A 3 digit octal string, specify the user, group and
* other modes in the standard Unix fashion;
* optional, default=0644
*
* @param octalString a 3 digit octal string.
* @deprecated use AbstractArchiver.setDefaultFileMode(int)
*/
public void setMode( String octalString )
{
setMode( Integer.parseInt( octalString, 8 ) );
}
/**
* @param mode unix file mode
* @deprecated use AbstractArchiver.setDefaultFileMode(int)
*/
public void setMode( int mode )
{
this.fileMode = UnixStat.FILE_FLAG | ( mode & UnixStat.PERM_MASK );
}
/**
* @return the current mode.
* @deprecated use AbstractArchiver.getDefaultFileMode()
*/
public int getMode()
{
return fileMode;
}
/**
* A 3 digit octal string, specify the user, group and
* other modes in the standard Unix fashion;
* optional, default=0755
*
* @param octalString a 3 digit octal string.
* @since Ant 1.6
* @deprecated use AbstractArchiver.setDefaultDirectoryMode(int)
*/
public void setDirMode( String octalString )
{
setDirMode( Integer.parseInt( octalString, 8 ) );
}
/**
* @param mode unix directory mode
* @deprecated use AbstractArchiver.setDefaultDirectoryMode(int)
*/
public void setDirMode( int mode )
{
this.dirMode = UnixStat.DIR_FLAG | ( mode & UnixStat.PERM_MASK );
}
/**
* @return the current directory mode
* @since Ant 1.6
* @deprecated use AbstractArchiver.getDefaultDirectoryMode()
*/
public int getDirMode()
{
return dirMode;
}
/**
* The username for the tar entry
* This is not the same as the UID.
*
* @param userName the user name for the tar entry.
*/
public void setUserName( String userName )
{
this.userName = userName;
}
/**
* @return the user name for the tar entry
*/
public String getUserName()
{
return userName;
}
/**
* The uid for the tar entry
* This is not the same as the User name.
*
* @param uid the id of the user for the tar entry.
*/
public void setUid( int uid )
{
this.uid = uid;
}
/**
* @return the uid for the tar entry
*/
public int getUid()
{
return uid;
}
/**
* The groupname for the tar entry; optional, default=""
* This is not the same as the GID.
*
* @param groupName the group name string.
*/
public void setGroup( String groupName )
{
this.groupName = groupName;
}
/**
* @return the group name string.
*/
public String getGroup()
{
return groupName;
}
/**
* The GID for the tar entry; optional, default="0"
* This is not the same as the group name.
*
* @param gid the group id.
*/
public void setGid( int gid )
{
this.gid = gid;
}
/**
* @return the group identifier.
*/
public int getGid()
{
return gid;
}
/**
* @return the leading slashes flag.
*/
public boolean getPreserveLeadingSlashes()
{
return preserveLeadingSlashes;
}
/**
* Flag to indicates whether leading `/'s should
* be preserved in the file names.
* Optional, default is false.
*
* @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
{
IOUtil.close( tOut );
}
protected String getArchiveType()
{
return "TAR";
}
}
TarBZip2UnArchiver.java 0000664 0000000 0000000 00000002471 12026402656 0034723 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 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-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarBuffer.java 0000664 0000000 0000000 00000031252 12026402656 0033275 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;
import java.util.Arrays;
/**
* 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 )
{
if (offset == 0) {
// Ensure that we do not read gigabytes of zeros
// for a corrupt tar file.
// See http://issues.apache.org/bugzilla/show_bug.cgi?id=39924
return false;
}
// However, just leaving the unread portion of the buffer dirty does
// cause problems in some cases. This problem is described in
// http://issues.apache.org/bugzilla/show_bug.cgi?id=29877
//
// The solution is to fill the unused portion of the buffer with zeros.
Arrays.fill(blockBuffer, offset, offset + bytesNeeded, (byte) 0);
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++;
Arrays.fill(blockBuffer, (byte) 0);
}
/**
* 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 12026402656 0035437 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarConstants.java0000664 0000000 0000000 00000006511 12026402656 0034040 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-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarEntry.java 0000664 0000000 0000000 00000045471 12026402656 0033175 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 descendant 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();
}
return ( this.linkFlag == LF_DIR ) || this.getName().endsWith( "/" );
}
/**
* 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-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarFile.java 0000664 0000000 0000000 00000013420 12026402656 0032740 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 00000002464 12026402656 0034650 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000026526 12026402656 0034270 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000004536 12026402656 0034316 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000025051 12026402656 0034461 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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
{
byte[] entryName = entry.getName().getBytes();
if ( entryName.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( entryName.length + 1 );
putNextEntry( longLinkEntry );
write( entryName);
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-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarResource.java 0000664 0000000 0000000 00000004101 12026402656 0033644 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 00000013352 12026402656 0034054 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 org.codehaus.plexus.util.IOUtil;
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
*
* - none - no compression
*
- gzip - Gzip compression
*
- bzip2 - Bzip2 compression
*
*
* @param method compression method
*/
public void setCompression( UntarCompressionMethod method )
{
compression = method;
}
/**
* No encoding support in Untar.
*/
public void setEncoding( String encoding )
{
getLogger().warn( "The TarUnArchiver doesn't support the encoding attribute" );
}
protected void execute()
throws ArchiverException
{
TarInputStream tis = null;
try
{
getLogger().info( "Expanding: " + getSourceFile() + " into " + getDestDirectory() );
tis = new TarInputStream( compression.decompress( getSourceFile(),
new BufferedInputStream(
new FileInputStream( getSourceFile() ) ) ) );
TarEntry te;
while ( ( te = tis.getNextEntry() ) != null )
{
extractFile( getSourceFile(), getDestDirectory(), tis, te.getName(), te.getModTime(),
te.isDirectory(), te.getMode() != 0 ? te.getMode() : null);
}
getLogger().debug( "expand complete" );
}
catch ( IOException ioe )
{
throw new ArchiverException( "Error while expanding " + getSourceFile().getAbsolutePath(), ioe );
}
finally
{
IOUtil.close( tis );
}
}
/**
* Valid Modes for Compression attribute to Untar Task
*/
public static final class UntarCompressionMethod
extends EnumeratedAttribute
{
// permissible values for compression attribute
/**
* No compression
*/
public static final String NONE = "none";
/**
* GZIP compression
*/
public static final String GZIP = "gzip";
/**
* BZIP2 compression
*/
public static final String BZIP2 = "bzip2";
/**
* Constructor
*/
public UntarCompressionMethod()
{
super();
try
{
setValue( NONE );
}
catch ( ArchiverException ae )
{
//Do nothing
}
}
/**
* Constructor
*/
public UntarCompressionMethod( String method )
{
super();
try
{
setValue( method );
}
catch ( ArchiverException ae )
{
//Do nothing
}
}
/**
* Get valid enumeration values
*
* @return valid values
*/
public String[] getValues()
{
return new String[]{NONE, GZIP, BZIP2};
}
/**
* This method wraps the input stream with the
* corresponding decompression method
*
* @param file provides location information for BuildException
* @param istream input stream
* @return input stream with on-the-fly decompression
* @throws IOException thrown by GZIPInputStream constructor
*/
private InputStream decompress( final File file, final InputStream istream )
throws IOException, ArchiverException
{
final String value = getValue();
if ( GZIP.equals( value ) )
{
return new GZIPInputStream( istream );
}
else if ( BZIP2.equals( value ) )
{
final char[] magic = new char[]{'B', 'Z'};
for ( int i = 0; i < magic.length; i++ )
{
if ( istream.read() != magic[ i ] )
{
throw new ArchiverException( "Invalid bz2 file." + file.toString() );
}
}
return new CBZip2InputStream( istream );
}
return istream;
}
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/tar/TarUtils.java 0000664 0000000 0000000 00000014012 12026402656 0033157 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 class provides static utility methods to work with byte streams.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.tar.TarUtils v1.11
*/
public class TarUtils
{
/**
* Parse an octal string from a header buffer. This is used for the
* file permission mode value.
*
* @param header The header buffer from which to parse.
* @param offset The offset into the buffer from which to parse.
* @param length The number of header bytes to parse.
* @return The long value of the octal string.
*/
public static long parseOctal( byte[] header, int offset, int length )
{
long result = 0;
boolean stillPadding = true;
int end = offset + length;
for ( int i = offset; i < end; ++i )
{
if ( header[ i ] == 0 )
{
break;
}
if ( header[ i ] == (byte) ' ' || header[ i ] == '0' )
{
if ( stillPadding )
{
continue;
}
if ( header[ i ] == (byte) ' ' )
{
break;
}
}
stillPadding = false;
result = ( result << 3 ) + ( header[ i ] - '0' );
}
return result;
}
/**
* Parse an entry name from a header buffer.
*
* @param header The header buffer from which to parse.
* @param offset The offset into the buffer from which to parse.
* @param length The number of header bytes to parse.
* @return The header's entry name.
*/
public static StringBuffer parseName( byte[] header, int offset, int length )
{
StringBuffer result = new StringBuffer( length );
int end = offset + length;
for ( int i = offset; i < end; ++i )
{
if ( header[ i ] == 0 )
{
break;
}
result.append( (char) header[ i ] );
}
return result;
}
/**
* Determine the number of bytes in an entry name.
*
* @param name The header name from which to parse.
* @param offset The offset into the buffer from which to parse.
* @param length The number of header bytes to parse.
* @return The number of bytes in a header's entry name.
*/
public static int getNameBytes( StringBuffer name, byte[] buf, int offset, int length )
{
int i;
for ( i = 0; i < length && i < name.length(); ++i )
{
buf[ offset + i ] = (byte) name.charAt( i );
}
for ( ; i < length; ++i )
{
buf[ offset + i ] = 0;
}
return offset + length;
}
/**
* Parse an octal integer from a header buffer.
*
* @param value The header value
* @param offset The offset into the buffer from which to parse.
* @param length The number of header bytes to parse.
* @return The integer value of the octal bytes.
*/
public static int getOctalBytes( long value, byte[] buf, int offset, int length )
{
int idx = length - 1;
buf[ offset + idx ] = 0;
--idx;
buf[ offset + idx ] = (byte) ' ';
--idx;
if ( value == 0 )
{
buf[ offset + idx ] = (byte) '0';
--idx;
}
else
{
for ( long val = value; idx >= 0 && val > 0; --idx )
{
buf[ offset + idx ] = (byte) ( (byte) '0' + (byte) ( val & 7 ) );
val = val >> 3;
}
}
for ( ; idx >= 0; --idx )
{
buf[ offset + idx ] = (byte) ' ';
}
return offset + length;
}
/**
* Parse an octal long integer from a header buffer.
*
* @param value The header value
* @param offset The offset into the buffer from which to parse.
* @param length The number of header bytes to parse.
* @return The long value of the octal bytes.
*/
public static int getLongOctalBytes( long value, byte[] buf, int offset, int length )
{
byte[] temp = new byte[length + 1];
getOctalBytes( value, temp, 0, length + 1 );
System.arraycopy( temp, 0, buf, offset, length );
return offset + length;
}
/**
* Parse the checksum octal integer from a header buffer.
*
* @param value The header value
* @param offset The offset into the buffer from which to parse.
* @param length The number of header bytes to parse.
* @return The integer value of the entry's checksum.
*/
public static int getCheckSumOctalBytes( long value, byte[] buf, int offset, int length )
{
getOctalBytes( value, buf, offset, length );
buf[ offset + length - 1 ] = (byte) ' ';
buf[ offset + length - 2 ] = 0;
return offset + length;
}
/**
* Compute the checksum of a tar entry header.
*
* @param buf The tar entry's header buffer.
* @return The computed checksum.
*/
public static long computeCheckSum( byte[] buf )
{
long sum = 0;
for ( int i = 0; i < buf.length; ++i )
{
sum += 255 & buf[ i ];
}
return sum;
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/util/ 0000775 0000000 0000000 00000000000 12026402656 0030736 5 ustar 00root root 0000000 0000000 AbstractFileSet.java 0000664 0000000 0000000 00000005200 12026402656 0034536 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
import org.codehaus.plexus.archiver.BaseFileSet;
import org.codehaus.plexus.components.io.fileselectors.FileSelector;
/**
* Default implementation of {@link BaseFileSet}.
* @since 1.0-alpha-9
*/
public abstract class AbstractFileSet
implements BaseFileSet
{
private String prefix;
private String[] includes;
private String[] excludes;
private FileSelector[] fileSelectors;
private boolean caseSensitive = true;
private boolean usingDefaultExcludes = true;
private boolean includingEmptyDirectories = true;
/**
* Sets a string of patterns, which excluded files
* should match.
*/
public void setExcludes( String[] excludes )
{
this.excludes = excludes;
}
public String[] getExcludes()
{
return excludes;
}
/**
* Sets a set of file selectors, which should be used
* to select the included files.
*/
public void setFileSelectors( FileSelector[] fileSelectors )
{
this.fileSelectors = fileSelectors;
}
public FileSelector[] getFileSelectors()
{
return fileSelectors;
}
/**
* Sets a string of patterns, which included files
* should match.
*/
public void setIncludes( String[] includes )
{
this.includes = includes;
}
public String[] getIncludes()
{
return includes;
}
/**
* Sets the prefix, which the file sets contents shall
* have.
*/
public void setPrefix( String prefix )
{
this.prefix = prefix;
}
public String getPrefix()
{
return prefix;
}
/**
* Sets, whether the include/exclude patterns are
* case sensitive. Defaults to true.
*/
public void setCaseSensitive( boolean caseSensitive )
{
this.caseSensitive = caseSensitive;
}
public boolean isCaseSensitive()
{
return caseSensitive;
}
/**
* Sets, whether the default excludes are being
* applied. Defaults to true.
*/
public void setUsingDefaultExcludes( boolean usingDefaultExcludes )
{
this.usingDefaultExcludes = usingDefaultExcludes;
}
public boolean isUsingDefaultExcludes()
{
return usingDefaultExcludes;
}
/**
* Sets, whether empty directories are being included. Defaults
* to true.
*/
public void setIncludingEmptyDirectories( boolean includingEmptyDirectories )
{
this.includingEmptyDirectories = includingEmptyDirectories;
}
public boolean isIncludingEmptyDirectories()
{
return includingEmptyDirectories;
}
}
ArchiveEntryUtils.java 0000664 0000000 0000000 00000012720 12026402656 0035150 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
import java.io.File;
import java.lang.reflect.Method;
public final class ArchiveEntryUtils
{
public static boolean jvmFilePermAvailable = false;
static
{
try
{
jvmFilePermAvailable = File.class.getMethod( "setReadable", new Class[] { Boolean.TYPE } ) != null;
}
catch ( final Exception e )
{
// ignore exception log this ?
}
}
private ArchiveEntryUtils()
{
// no op
}
/**
* @since 1.1
* @param file
* @param mode
* @param logger
* @param useJvmChmod
* will use jvm file permissions not available for group level
* @throws ArchiverException
*/
public static void chmod( final File file, final int mode, final Logger logger, boolean useJvmChmod )
throws ArchiverException
{
if ( !Os.isFamily( Os.FAMILY_UNIX ) )
{
return;
}
final String m = Integer.toOctalString( mode & 0xfff );
if ( useJvmChmod && !jvmFilePermAvailable )
{
useJvmChmod = false;
}
if ( useJvmChmod && jvmFilePermAvailable )
{
applyPermissionsWithJvm( file, m, logger );
return;
}
try
{
final Commandline commandline = new Commandline();
commandline.setWorkingDirectory( file.getParentFile().getAbsolutePath() );
if ( logger.isDebugEnabled() )
{
logger.debug( file + ": mode " + Integer.toOctalString( mode ) + ", chmod " + m );
}
commandline.setExecutable( "chmod" );
commandline.createArg().setValue( m );
final String path = file.getAbsolutePath();
commandline.createArg().setValue( path );
// commenting this debug statement, since it can produce VERY verbose output...
// this method is called often during archive creation.
// logger.debug( "Executing:\n\n" + commandline.toString() + "\n\n" );
final CommandLineUtils.StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();
final CommandLineUtils.StringStreamConsumer stdout = new CommandLineUtils.StringStreamConsumer();
final int exitCode = CommandLineUtils.executeCommandLine( commandline, stderr, stdout );
if ( exitCode != 0 )
{
logger.warn( "-------------------------------" );
logger.warn( "Standard error:" );
logger.warn( "-------------------------------" );
logger.warn( stderr.getOutput() );
logger.warn( "-------------------------------" );
logger.warn( "Standard output:" );
logger.warn( "-------------------------------" );
logger.warn( stdout.getOutput() );
logger.warn( "-------------------------------" );
throw new ArchiverException( "chmod exit code was: " + exitCode );
}
}
catch ( final CommandLineException e )
{
throw new ArchiverException( "Error while executing chmod.", e );
}
}
/**
* jvm chmod will be used only if System property 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 )
throws ArchiverException
{
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 ArchiverException( "error calling dynamically file permissons with jvm " + e.getMessage(), e );
}
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/util/Compressor.java 0000664 0000000 0000000 00000013431 12026402656 0033737 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;
import org.codehaus.plexus.util.IOUtil;
/**
* @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
{
InputStream in = new FileInputStream( file );
try
{
compressFile( in, zOut );
}
finally
{
IOUtil.close( in );
}
}
/**
* compress a resource to an output stream
*/
protected void compress( PlexusIoResource resource, OutputStream zOut )
throws IOException
{
InputStream in = resource.getContents();
try
{
compressFile( in, zOut );
}
finally
{
IOUtil.close( in );
}
}
/**
* 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 00000001027 12026402656 0036030 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000001014 12026402656 0034356 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000006367 12026402656 0035513 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 12026402656 0034452 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000013150 12026402656 0035473 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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();i s;
}
/**
* Queries, whether the given source is up-to-date relative to
* the given modification date.
*/
public static boolean isUptodate( long sourceDate, long destinationDate )
{
if ( sourceDate == PlexusIoResource.UNKNOWN_MODIFICATION_DATE )
{
return false;
}
if ( destinationDate == 0 )
{
return false;
}
return destinationDate > sourceDate;
}
/**
* Copies the sources contents to the given destination file.
*/
public static void copyFile( PlexusIoResource in, File outFile )
throws IOException
{
InputStream input = null;
OutputStream output = null;
try
{
input = in.getContents();
output = new FileOutputStream( outFile );
IOUtil.copy( input, output );
}
finally
{
IOUtil.close( input );
IOUtil.close( output );
}
}
/**
* Checks, whether the resource and the file are identical.
*/
public static boolean isSame( PlexusIoResource resource, File file )
{
if ( resource instanceof PlexusIoFileResource )
{
File resourceFile = ((PlexusIoFileResource) resource).getFile();
return file.equals( resourceFile );
}
return false;
}
/**
* Checks, whether the resource and the file are identical.
* Uses {@link File#getCanonicalFile()} for comparison, which is much
* slower than comparing the files.
*/
public static boolean isCanonicalizedSame( PlexusIoResource resource, File file )
throws IOException
{
if ( resource instanceof PlexusIoFileResource )
{
File resourceFile = ((PlexusIoFileResource) resource).getFile();
return file.getCanonicalFile().equals( resourceFile.getCanonicalFile() );
}
return false;
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/war/ 0000775 0000000 0000000 00000000000 12026402656 0030552 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/war/WarArchiver.java 0000664 0000000 0000000 00000014060 12026402656 0033633 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.war;
/*
* 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.ArchiveEntry;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import org.codehaus.plexus.archiver.util.ResourceUtils;
import org.codehaus.plexus.archiver.zip.ZipOutputStream;
import java.io.File;
import java.io.IOException;
/**
* An extension of <jar> to create a WAR archive.
* Contains special treatment for files that should end up in the
* WEB-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" + File.separatorChar + "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 a element.
if ( vPath.equalsIgnoreCase( "WEB-INF/web.xml" ) )
{
if ( descriptorAdded || ( ignoreWebxml
&& ( deploymentDescriptor == null
|| !ResourceUtils.isCanonicalizedSame( entry.getResource(), deploymentDescriptor ) ) ) )
{
getLogger().warn( "Warning: selected " + archiveType
+ " files include a WEB-INF/web.xml which will be ignored "
+ "\n(webxml attribute is missing from "
+ archiveType + " task, or ignoreWebxml attribute is specified as 'true')" );
}
else
{
super.zipFile( entry, zOut, vPath );
descriptorAdded = true;
}
}
else
{
super.zipFile( entry, zOut, vPath );
}
}
/**
* Make sure we don't think we already have a web.xml next time this task
* gets executed.
*/
protected void cleanUp()
{
descriptorAdded = false;
ignoreWebxml = true;
super.cleanUp();
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ 0000775 0000000 0000000 00000000000 12026402656 0030563 5 ustar 00root root 0000000 0000000 AbstractZipArchiver.java 0000775 0000000 0000000 00000056663 12026402656 0035304 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Stack;
import java.util.zip.CRC32;
import org.codehaus.plexus.archiver.AbstractArchiver;
import org.codehaus.plexus.archiver.ArchiveEntry;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.ResourceIterator;
import org.codehaus.plexus.archiver.UnixStat;
import org.codehaus.plexus.archiver.util.ResourceUtils;
import org.codehaus.plexus.components.io.resources.PlexusIoFileResource;
import org.codehaus.plexus.components.io.resources.PlexusIoResource;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
/**
* @version $Revision$ $Date$
*/
@SuppressWarnings({"NullableProblems", "UnusedDeclaration"})
public abstract class AbstractZipArchiver
extends AbstractArchiver
{
private String comment;
/**
* Encoding to use for filenames, defaults to the platform's
* default encoding.
*/
private String encoding;
private boolean doCompress = true;
private boolean recompressAddedZips = true;
private boolean doUpdate = false;
// shadow of the above if the value is altered in execute
private boolean savedDoUpdate = false;
protected String archiveType = "zip";
/*
* Whether the original compression of entries coming from a ZIP
* archive should be kept (for example when updating an archive).
*/
//not used: private boolean keepCompression = false;
private boolean doFilesonly = false;
protected Hashtable entries = new Hashtable();
protected Hashtable addedDirs = new Hashtable();
private static final long EMPTY_CRC = new CRC32().getValue();
protected boolean doubleFilePass = false;
protected boolean skipWriting = false;
/**
* @deprecated Use {@link Archiver#setDuplicateBehavior(String)} instead.
*/
protected String duplicate = Archiver.DUPLICATES_SKIP;
/**
* true when we are adding new files into the Zip file, as opposed
* to adding back the unchanged files
*/
protected boolean addingNewFiles = false;
/**
* Whether the file modification times will be rounded up to the
* next even number of seconds.
*/
private boolean roundUp = true;
// Renamed version of original file, if it exists
private File renamedFile = null;
private File zipFile;
private boolean success;
private ZipOutputStream zOut;
public String getComment()
{
return comment;
}
public void setComment( String comment )
{
this.comment = comment;
}
public String getEncoding()
{
return encoding;
}
public void setEncoding( String encoding )
{
this.encoding = encoding;
}
public void setCompress( boolean compress )
{
this.doCompress = compress;
}
public boolean isCompress()
{
return doCompress;
}
public boolean isRecompressAddedZips()
{
return recompressAddedZips;
}
public void setRecompressAddedZips( boolean recompressAddedZips )
{
this.recompressAddedZips = recompressAddedZips;
}
public void setUpdateMode( boolean update )
{
this.doUpdate = update;
savedDoUpdate = doUpdate;
}
public boolean isInUpdateMode()
{
return doUpdate;
}
/**
* If true, emulate Sun's jar utility by not adding parent directories;
* optional, defaults to false.
* @param f true to emilate sun jar utility
*/
public void setFilesonly( boolean f )
{
doFilesonly = f;
}
public boolean isFilesonly()
{
return doFilesonly;
}
/**
* Whether the file modification times will be rounded up to the
* next even number of seconds.
*
* Zip 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.
* @param r true to round
*/
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
{
//noinspection deprecation
if ( !Archiver.DUPLICATES_SKIP.equals( duplicate ) )
{
//noinspection deprecation
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 )
{
//noinspection unchecked
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(), 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() );
return l != null && (l == -1 || !ResourceUtils.isUptodate(entry.getResource(), l));
}
/**
* Add the given resources.
*
* @param resources the resources to add
* @param zOut the stream to write to
*/
@SuppressWarnings({"JavaDoc"})
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.
*/
@SuppressWarnings({"JavaDoc"})
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 = 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() );
}
}
}
private void readWithZipStats(InputStream in, byte[] header, ZipEntry ze, ByteArrayOutputStream bos) throws IOException {
byte[] buffer = new byte[8 * 1024];
CRC32 cal2 = new CRC32();
long size = 0;
for (byte aHeader : header) {
cal2.update(aHeader);
size++;
}
int count = 0;
do
{
size += count;
cal2.update( buffer, 0, count );
if (bos != null)
{
bos.write( buffer, 0, count );
}
count = in.read( buffer, 0, buffer.length );
}
while ( count != -1 );
ze.setSize(size);
ze.setCrc(cal2.getValue());
}
public static long copy( final InputStream input,
final OutputStream output,
final int bufferSize )
throws IOException
{
final byte[] buffer = new byte[bufferSize];
long size = 0;
int n;
while ( -1 != ( n = input.read( buffer ) ) )
{
size += n;
output.write( buffer, 0, n );
}
return size;
}
/**
* 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.
*/
@SuppressWarnings({"JavaDoc"})
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 );
byte[] header = new byte[4];
int read = in.read(header);
boolean compressThis = doCompress;
if (!recompressAddedZips && isZipHeader(header)){
compressThis = false;
}
ze.setMethod( compressThis ? ZipEntry.DEFLATED : ZipEntry.STORED );
ze.setUnixMode( UnixStat.FILE_FLAG | mode );
/*
* 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() || compressThis) {
zOut.putNextEntry( ze );
if (read > 0) zOut.write(header, 0, read);
IOUtil.copy( in, zOut, 8 * 1024);
} else {
if (in.markSupported())
{
in.mark( Integer.MAX_VALUE );
readWithZipStats(in, header, ze, null);
in.reset();
zOut.putNextEntry(ze);
if (read > 0) zOut.write(header, 0, read);
IOUtil.copy(in, zOut, 8 * 1024);
}
else
{
// Store data into a byte[]
ByteArrayOutputStream bos = new ByteArrayOutputStream(128 * 1024);
readWithZipStats(in, header, ze, bos);
zOut.putNextEntry(ze);
if (read > 0) zOut.write(header, 0, read);
bos.writeTo( zOut);
}
}
}
}
private boolean isZipHeader(byte[] header) {
return header[0] == 0x50 && header[1] == 0x4b && header[2] == 03 && header[3] == 04;
}
/**
* 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
*/
@SuppressWarnings({"JavaDoc"})
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 in = entry.getInputStream();
try
{
// ZIPs store time with a granularity of 2 seconds, round up
final long lastModified = entry.getResource().getLastModified() + ( roundUp ? 1999 : 0 );
zipFile( in, zOut, vPath, lastModified, null, entry.getMode() );
}
catch ( IOException e )
{
throw new ArchiverException( "IOException when zipping " + entry.getName() + ": " + e.getMessage(), e );
}
finally
{
IOUtil.close( in );
}
}
/**
*
*/
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
*
* @param zipFile The file
* @return true for historic reasons
*/
@SuppressWarnings({"JavaDoc"})
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
{
IOUtil.close( os );
}
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();
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 00000021406 12026402656 0035567 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.Date;
import java.util.Enumeration;
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 org.codehaus.plexus.util.IOUtil;
/**
* @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.
*
*/
public void setEncoding( String encoding )
{
if ( NATIVE_ENCODING.equals( encoding ) )
{
encoding = null;
}
this.encoding = encoding;
}
private static class ZipEntryFileInfo
implements PlexusIoResource
{
private final ZipFile zipFile;
private final ZipEntry zipEntry;
ZipEntryFileInfo( final ZipFile zipFile, final ZipEntry zipEntry )
{
this.zipFile = zipFile;
this.zipEntry = zipEntry;
}
public String getName()
{
return zipEntry.getName();
}
public boolean isDirectory()
{
return zipEntry.isDirectory();
}
public boolean isFile()
{
return !zipEntry.isDirectory();
}
public InputStream getContents()
throws IOException
{
return zipFile.getInputStream( zipEntry );
}
public long getLastModified()
{
final long l = zipEntry.getTime();
return l == 0 ? PlexusIoResource.UNKNOWN_MODIFICATION_DATE : l;
}
public long getSize()
{
final long l = zipEntry.getSize();
return l == -1 ? PlexusIoResource.UNKNOWN_RESOURCE_SIZE : l;
}
public URL getURL()
throws IOException
{
return null;
}
public boolean isExisting()
{
return true;
}
}
protected void execute()
throws ArchiverException
{
getLogger().debug( "Expanding: " + getSourceFile() + " into " + getDestDirectory() );
ZipFile zf = null;
try
{
zf = new ZipFile( getSourceFile(), encoding );
final Enumeration e = zf.getEntries();
while ( e.hasMoreElements() )
{
final ZipEntry ze = (ZipEntry) e.nextElement();
final ZipEntryFileInfo fileInfo = new ZipEntryFileInfo( zf, ze );
if ( !isSelected( ze.getName(), fileInfo ) )
{
continue;
}
InputStream in = zf.getInputStream( ze );
extractFileIfIncluded( getSourceFile(), getDestDirectory(), in, ze.getName(),
new Date( ze.getTime() ), ze.isDirectory(), ze.getUnixMode()!= 0 ? ze.getUnixMode() : null );
in.close();
}
getLogger().debug( "expand complete" );
}
catch ( final IOException ioe )
{
throw new ArchiverException( "Error while expanding " + getSourceFile().getAbsolutePath(), ioe );
}
finally
{
if ( zf != null )
{
try
{
zf.close();
}
catch ( final IOException e )
{
// ignore
}
}
}
}
private void extractFileIfIncluded( final File sourceFile, final File destDirectory, final InputStream inputStream,
final String name, final Date time, final boolean isDirectory,
final Integer mode )
throws IOException, ArchiverException
{
try
{
if ( include( inputStream, name ) )
{
extractFile( sourceFile, destDirectory, inputStream, name, time, isDirectory, mode );
}
}
catch ( final ArchiveFilterException e )
{
throw new ArchiverException( "Error verifying \'" + name + "\' for inclusion: " + e.getMessage(), e );
}
}
protected void extractFile( final File srcF, final File dir, final InputStream compressedInputStream,
final String entryName, final Date entryDate, final boolean isDirectory,
final Integer mode )
throws IOException, ArchiverException
{
final File f = FileUtils.resolveFile( dir, entryName );
try
{
if ( !isOverwrite() && f.exists() && ( f.lastModified() >= entryDate.getTime() ) )
{
return;
}
// create intermediary directories - sometimes zip don't add them
final File dirF = f.getParentFile();
if ( dirF != null )
{
dirF.mkdirs();
}
if ( isDirectory )
{
f.mkdirs();
}
else
{
OutputStream out = null;
try
{
out = new FileOutputStream( f );
IOUtil.copy( compressedInputStream, out );
}
finally
{
IOUtil.close( out );
}
}
f.setLastModified( entryDate.getTime() );
if ( !isIgnorePermissions() && mode != null && !isDirectory)
{
ArchiveEntryUtils.chmod( f, mode, getLogger(), isUseJvmChmod() );
}
}
catch ( final FileNotFoundException ex )
{
getLogger().warn( "Unable to expand to file " + f.getPath() );
}
}
protected void execute( final String path, final File outputDirectory )
throws ArchiverException
{
ZipFile zipFile = null;
try
{
zipFile = new ZipFile( getSourceFile(), encoding );
final Enumeration e = zipFile.getEntries();
while ( e.hasMoreElements() )
{
final ZipEntry ze = (ZipEntry) e.nextElement();
final ZipEntryFileInfo fileInfo = new ZipEntryFileInfo( zipFile, ze );
if ( !isSelected( ze.getName(), fileInfo ) )
{
continue;
}
if ( ze.getName().startsWith( path ) )
{
final InputStream inputStream = zipFile.getInputStream( ze );
extractFileIfIncluded( getSourceFile(), outputDirectory, inputStream,
ze.getName(), new Date( ze.getTime() ), ze.isDirectory(),
ze.getUnixMode() != 0 ? ze.getUnixMode() : null );
inputStream.close();
}
}
}
catch ( final IOException ioe )
{
throw new ArchiverException( "Error while expanding " + getSourceFile().getAbsolutePath(), ioe );
}
finally
{
if ( zipFile != null )
{
try
{
zipFile.close();
}
catch ( final IOException e )
{
// ignore
}
}
}
}
}
AsiExtraField.java 0000664 0000000 0000000 00000020724 12026402656 0034040 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 org.codehaus.plexus.archiver.UnixStat;
import java.util.zip.CRC32;
import java.util.zip.ZipException;
/**
* Adds Unix file permission and UID/GID fields as well as symbolic
* link handling.
*
* 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 00000013411 12026402656 0034417 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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 00000002616 12026402656 0040133 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip;
import java.io.File;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Iterator;
import org.codehaus.plexus.components.io.resources.AbstractPlexusIoArchiveResourceCollection;
import org.codehaus.plexus.components.io.resources.PlexusIoResource;
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 PlexusIoResource next()
{
final ZipEntry entry = (ZipEntry) en.nextElement();
return new ZipResource( zipFile, entry );
}
public void remove()
{
throw new UnsupportedOperationException( "Removing isn't implemented." );
}
};
}
}
UnrecognizedExtraField.java 0000664 0000000 0000000 00000005125 12026402656 0035756 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipArchiver.java 0000664 0000000 0000000 00000001364 12026402656 0033660 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-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipEntry.java 0000664 0000000 0000000 00000031320 12026402656 0033211 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 12026402656 0034071 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipFile.java 0000664 0000000 0000000 00000047143 12026402656 0033001 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 for java.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:
*
*
* - There is no getName method.
* - entries has been renamed to getEntries.
* - getEntries and getEntry return
*
org.apache.tools.zip.ZipEntry instances.
* - close is allowed to throw IOException.
*
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.ZipFile v1.13
*/
@SuppressWarnings("JavaDoc")
public class ZipFile
implements ArchiveFile
{
/**
* Maps ZipEntrys to Longs, recording the offsets of the local
* file headers.
*/
private final Hashtable entries = new Hashtable();
/**
* Maps String to ZipEntrys, name -> actual entry.
*/
private final Hashtable nameMap = new Hashtable();
/**
* Maps ZipEntrys to Longs, recording the offsets of the actual file data.
*/
private final Hashtable dataOffsets = 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.
*/
private String encoding = null;
/**
* The actual data source.
*/
private final 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 - or null 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 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 {
Long start = dataOffsets.get( ze );
if ( start == null )
{
return null;
}
BoundedInputStream bis = new BoundedInputStream(start, ze.getCompressedSize() );
switch ( ze.getMethod() )
{
case ZipEntry.STORED:
return bis;
case ZipEntry.DEFLATED:
bis.addDummy();
return new InflaterInputStream( bis, new Inflater( true ) )
{
public void close()
throws IOException
{
super.close();
inf.end();
}
};
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 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 = entries.get(ze);
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,
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-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipLong.java 0000664 0000000 0000000 00000005225 12026402656 0033014 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 00000056453 12026402656 0034523 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.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
*
* @since 1.1
*/
protected static ZipLong toDosTime( Date time )
{
int year = time.getYear() + 1900;
int month = time.getMonth() + 1;
if ( year < 1980 )
{
return DOS_TIME_MIN;
}
long value = ( ( year - 1980 ) << 25 )
| ( month << 21 )
| ( time.getDate() << 16 )
| ( time.getHours() << 11 )
| ( time.getMinutes() << 5 )
| ( time.getSeconds() >> 1 );
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 new ZipLong( result );
}
/**
* Retrieve the bytes for the given String in the encoding set for
* this Stream.
*
* @since 1.3
*/
protected byte[] getBytes( String name )
throws ZipException
{
if ( encoding == null )
{
return name.getBytes();
}
else
{
try
{
return name.getBytes( encoding );
}
catch ( UnsupportedEncodingException uee )
{
throw new ZipException( uee.getMessage() );
}
}
}
/**
* Write bytes to output or random access file
*
* @since 1.14
*/
protected final void writeOut( byte [] data )
throws IOException
{
writeOut( data, 0, data.length );
}
/**
* Write bytes to output or random access file
*
* @since 1.14
*/
protected final void writeOut( byte [] data, int offset, int length )
throws IOException
{
if ( raf != null )
{
raf.write( data, offset, length );
}
else
{
out.write( data, offset, length );
}
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipResource.java 0000664 0000000 0000000 00000004141 12026402656 0033700 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.zip;
import org.codehaus.plexus.archiver.UnixStat;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes;
import org.codehaus.plexus.components.io.attributes.SimpleResourceAttributes;
import org.codehaus.plexus.components.io.resources.AbstractPlexusIoResourceWithAttributes;
import org.codehaus.plexus.components.io.resources.PlexusIoResource;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
public class ZipResource
extends AbstractPlexusIoResourceWithAttributes
{
private final ZipFile zipFile;
private final ZipEntry entry;
private PlexusIoResourceAttributes attributes;
public ZipResource( ZipFile zipFile, ZipEntry entry )
{
this.zipFile = zipFile;
this.entry = entry;
final boolean dir = entry.isDirectory();
setName( entry.getName() );
setFile( !dir );
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()
{
int mode = entry.getUnixMode();
if ( ( mode & UnixStat.FILE_FLAG ) == UnixStat.FILE_FLAG )
{
mode = mode & ~UnixStat.FILE_FLAG;
}
else
{
mode = mode & ~UnixStat.DIR_FLAG;
}
if ( attributes == null )
{
attributes = new SimpleResourceAttributes();
attributes.setOctalMode( mode );
}
return attributes;
}
public synchronized void setAttributes( PlexusIoResourceAttributes attributes )
{
this.attributes = attributes;
}
public URL getURL()
throws IOException
{
return null;
}
public InputStream getContents()
throws IOException
{
return zipFile.getInputStream( entry );
}
}
plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/zip/ZipShort.java 0000664 0000000 0000000 00000004627 12026402656 0033221 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 two byte integer with conversion
* rules for the big endian byte order of ZIP files.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.ZipShort v1.10
*/
public final class ZipShort
implements Cloneable
{
private int value;
/**
* Create instance from a number.
*
* @since 1.1
*/
public ZipShort( int value )
{
this.value = value;
}
/**
* Create instance from bytes.
*
* @since 1.1
*/
public ZipShort( byte[] bytes )
{
this( bytes, 0 );
}
/**
* Create instance from the two bytes starting at offset.
*
* @since 1.1
*/
public ZipShort( byte[] bytes, int offset )
{
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[2];
result[ 0 ] = (byte) ( value & 0xFF );
result[ 1 ] = (byte) ( ( value & 0xFF00 ) >> 8 );
return result;
}
/**
* Get value as Java int.
*
* @since 1.1
*/
public int 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 ZipShort ) )
{
return false;
}
return value == ( (ZipShort) o ).getValue();
}
/**
* Override to make two instances with same value equal.
*
* @since 1.1
*/
public int hashCode()
{
return value;
}
}
ZipUnArchiver.java 0000664 0000000 0000000 00000001737 12026402656 0034110 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip;
import java.io.File;
/**
*
* 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.
*/
/**
* @author Emmanuel Venisse
* @version $Revision$ $Date$
*/
public class ZipUnArchiver
extends AbstractZipUnArchiver
{
public ZipUnArchiver()
{
}
public ZipUnArchiver( File sourceFile )
{
super( sourceFile );
}
}
plexus-archiver-plexus-archiver-2.2/src/main/resources/ 0000775 0000000 0000000 00000000000 12026402656 0023345 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/META-INF/ 0000775 0000000 0000000 00000000000 12026402656 0024505 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/META-INF/plexus/ 0000775 0000000 0000000 00000000000 12026402656 0026025 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/META-INF/plexus/components.xml 0000664 0000000 0000000 00000042600 12026402656 0030736 0 ustar 00root root 0000000 0000000
org.codehaus.plexus.archiver.Archiver
bzip2
org.codehaus.plexus.archiver.bzip2.BZip2Archiver
per-lookup
org.codehaus.plexus.archiver.Archiver
dir
org.codehaus.plexus.archiver.dir.DirectoryArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
ear
org.codehaus.plexus.archiver.ear.EarArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
gzip
org.codehaus.plexus.archiver.gzip.GZipArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
jar
org.codehaus.plexus.archiver.jar.JarArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
tar
org.codehaus.plexus.archiver.tar.TarArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
war
org.codehaus.plexus.archiver.war.WarArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
zip
org.codehaus.plexus.archiver.zip.ZipArchiver
per-lookup
org.codehaus.plexus.archiver.Archiver
rar
org.codehaus.plexus.archiver.jar.JarArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
bzip2
org.codehaus.plexus.archiver.bzip2.BZip2UnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
gzip
org.codehaus.plexus.archiver.gzip.GZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
tar
org.codehaus.plexus.archiver.tar.TarUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
zip
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
jar
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
war
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
ear
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
swc
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
nar
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
esb
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
sar
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
car
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
par
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
rar
org.codehaus.plexus.archiver.zip.ZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
tgz
org.codehaus.plexus.archiver.tar.TarGZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
tar.gz
org.codehaus.plexus.archiver.tar.TarGZipUnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
tbz2
org.codehaus.plexus.archiver.tar.TarBZip2UnArchiver
per-lookup
org.codehaus.plexus.archiver.UnArchiver
tar.bz2
org.codehaus.plexus.archiver.tar.TarBZip2UnArchiver
per-lookup
org.codehaus.plexus.archiver.manager.ArchiverManager
org.codehaus.plexus.archiver.manager.DefaultArchiverManager
default
org.codehaus.plexus.components.io.fileselectors.FileSelector
jar-security
org.codehaus.plexus.archiver.filters.JarSecurityFileSelector
singleton
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
bzip2
org.codehaus.plexus.archiver.bzip2.PlexusIoBzip2ResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
bz2
org.codehaus.plexus.archiver.bzip2.PlexusIoBzip2ResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
gzip
org.codehaus.plexus.archiver.gzip.PlexusIoGzipResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
gz
org.codehaus.plexus.archiver.gzip.PlexusIoGzipResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
tar
org.codehaus.plexus.archiver.tar.PlexusIoTarFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
jar
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
war
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
ear
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
swc
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
nar
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
esb
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
sar
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
car
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
Par
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
rar
org.codehaus.plexus.components.io.resources.PlexusIoZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
tgz
org.codehaus.plexus.archiver.tar.PlexusIoTarGZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
tar.gz
org.codehaus.plexus.archiver.tar.PlexusIoTarGZipFileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
tbz2
org.codehaus.plexus.archiver.tar.PlexusIoTarBZip2FileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
tar.bz2
org.codehaus.plexus.archiver.tar.PlexusIoTarBZip2FileResourceCollection
per-lookup
org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection
zip
org.codehaus.plexus.archiver.zip.PlexusIoZipFileResourceCollection
per-lookup
plexus-archiver-plexus-archiver-2.2/src/main/resources/org/ 0000775 0000000 0000000 00000000000 12026402656 0024134 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/org/codehaus/ 0000775 0000000 0000000 00000000000 12026402656 0025727 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12026402656 0027247 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/org/codehaus/plexus/archiver/ 0000775 0000000 0000000 00000000000 12026402656 0031052 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/org/codehaus/plexus/archiver/jar/ 0000775 0000000 0000000 00000000000 12026402656 0031626 5 ustar 00root root 0000000 0000000 defaultManifest.mf 0000664 0000000 0000000 00000000071 12026402656 0035204 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/main/resources/org/codehaus/plexus/archiver/jar Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
plexus-archiver-plexus-archiver-2.2/src/site/ 0000775 0000000 0000000 00000000000 12026402656 0021353 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/site/site.xml 0000664 0000000 0000000 00000000417 12026402656 0023043 0 ustar 00root root 0000000 0000000
plexus-archiver-plexus-archiver-2.2/src/test/ 0000775 0000000 0000000 00000000000 12026402656 0021366 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/dotfiles/ 0000775 0000000 0000000 00000000000 12026402656 0023177 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/dotfiles/.plxarc 0000664 0000000 0000000 00000000041 12026402656 0024464 0 ustar 00root root 0000000 0000000 licenses
licenses:META-INF/maven
plexus-archiver-plexus-archiver-2.2/src/test/dotfiles/licenses/ 0000775 0000000 0000000 00000000000 12026402656 0025004 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/dotfiles/licenses/LICENSE.txt 0000664 0000000 0000000 00000026136 12026402656 0026637 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.
plexus-archiver-plexus-archiver-2.2/src/test/dotfiles/licenses/NOTICE.txt 0000664 0000000 0000000 00000000145 12026402656 0026526 0 ustar 00root root 0000000 0000000 This product includes software developed by
The Apache Software Foundation (http://www.apache.org/).
plexus-archiver-plexus-archiver-2.2/src/test/jars/ 0000775 0000000 0000000 00000000000 12026402656 0022325 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/jars/test.jar 0000664 0000000 0000000 00000002056 12026402656 0024005 0 ustar 00root root 0000000 0000000 PK BVG5 META-INF/ PK PK BVG5 META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu X*h8*8(x%irr PKRWF F PK
UG5
resources/PK
VG5 resources/artifactId/PK
VG5 resources/artifactId/directory/PK VG5 . resources/artifactId/directory/test.propertiesKMM(, PKuF
PK VG5 $ resources/artifactId/test.propertiesKMJ, PK1
PK BVG5 META-INF/ PK BVG5RWF F = META-INF/MANIFEST.MFPK
UG5
resources/PK
VG5 resources/artifactId/PK
VG5 resources/artifactId/directory/PK VG5uF
. ] resources/artifactId/directory/test.propertiesPK VG51
$ resources/artifactId/test.propertiesPK % plexus-archiver-plexus-archiver-2.2/src/test/jars/test.rar 0000775 0000000 0000000 00000002056 12026402656 0024020 0 ustar 00root root 0000000 0000000 PK BVG5 META-INF/ PK PK BVG5 META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu X*h8*8(x%irr PKRWF F PK
UG5
resources/PK
VG5 resources/artifactId/PK
VG5 resources/artifactId/directory/PK VG5 . resources/artifactId/directory/test.propertiesKMM(, PKuF
PK VG5 $ resources/artifactId/test.propertiesKMJ, PK1
PK BVG5 META-INF/ PK BVG5RWF F = META-INF/MANIFEST.MFPK
UG5
resources/PK
VG5 resources/artifactId/PK
VG5 resources/artifactId/directory/PK VG5uF
. ] resources/artifactId/directory/test.propertiesPK VG51
$ resources/artifactId/test.propertiesPK % plexus-archiver-plexus-archiver-2.2/src/test/jars/test.zip 0000664 0000000 0000000 00000000235 12026402656 0024030 0 ustar 00root root 0000000 0000000 PK
:k;בQ test.shUT PSJPSJUx #!/bin/sh
PK
:k;בQ
test.shUT PSJUx PK B E plexus-archiver-plexus-archiver-2.2/src/test/java/ 0000775 0000000 0000000 00000000000 12026402656 0022307 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/ 0000775 0000000 0000000 00000000000 12026402656 0023076 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12026402656 0024671 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12026402656 0026211 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/ 0000775 0000000 0000000 00000000000 12026402656 0030014 5 ustar 00root root 0000000 0000000 AbstractArchiverTest.java 0000664 0000000 0000000 00000004644 12026402656 0034677 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver package org.codehaus.plexus.archiver;
import java.io.IOException;
import junit.framework.TestCase;
public class AbstractArchiverTest extends TestCase
{
private AbstractArchiver archiver;
protected void setUp() throws Exception
{
super.setUp();
this.archiver = new AbstractArchiver()
{
protected String getArchiveType()
{
throw new UnsupportedOperationException();
}
protected void execute() throws ArchiverException, IOException
{
throw new UnsupportedOperationException();
}
protected void close() throws IOException
{
throw new UnsupportedOperationException();
}
};
}
public void testModesAndOverridesAreUnsetByDefault()
{
assertEquals(-1, archiver.getDefaultFileMode());
assertEquals(-1, archiver.getOverrideFileMode());
assertEquals(Archiver.DEFAULT_DIR_MODE, archiver.getDefaultDirectoryMode());
assertEquals(-1, archiver.getOverrideDirectoryMode());
}
public void testWhenUnsetModeUsesDefault()
{
assertEquals(Archiver.DEFAULT_FILE_MODE, archiver.getFileMode());
assertEquals(Archiver.DEFAULT_DIR_MODE, archiver.getDirectoryMode());
}
public void testSetModeIsUsedWithFlagsForType()
{
archiver.setFileMode(0400);
assertEquals(0100400, archiver.getFileMode());
archiver.setDirectoryMode(0600);
assertEquals(040600, archiver.getDirectoryMode());
}
public void testSetDefaultIncludesFlagsForType()
{
archiver.setDefaultFileMode(0400);
assertEquals(0100400, archiver.getDefaultFileMode());
archiver.setDefaultDirectoryMode(0600);
assertEquals(040600, archiver.getDefaultDirectoryMode());
}
public void testDefaultIsUsedWhenModeIsUnset()
{
archiver.setDefaultFileMode(0400);
assertEquals(0100400, archiver.getFileMode());
archiver.setDefaultDirectoryMode(0600);
assertEquals(040600, archiver.getDirectoryMode());
}
public void testOverridesCanBeReset()
{
archiver.setFileMode(0400);
archiver.setFileMode(-1);
assertEquals(-1, archiver.getOverrideFileMode());
archiver.setDirectoryMode(0600);
archiver.setDirectoryMode(-1);
assertEquals(-1, archiver.getOverrideDirectoryMode());
}
}
BasePlexusArchiverTest.java 0000664 0000000 0000000 00000006330 12026402656 0035201 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver package org.codehaus.plexus.archiver;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.util.FileUtils;
/**
* Base abstract class that all the test-cases for different archivers
* extend so that they can use its helpful methids.
*
* @version $Id$
*/
public abstract class BasePlexusArchiverTest extends PlexusTestCase
{
/**
* Ensure that when a new file is created at the specified location that the timestamp of
* that file will be greater than the one specified as a reference.
*
* Warning: Runs in a busy loop creating a file until the output file is newer than the reference timestamp.
* This should be better than sleeping for a race condition time out value.
*
* @param outputFile the file to be created
* @param timestampReference the created file will have a newer timestamp than this reference timestamp.
* @throws Exception failures
*/
protected void waitUntilNewTimestamp( File outputFile, long timestampReference ) throws Exception
{
File tmpFile = File.createTempFile( "ZipArchiverTest.waitUntilNewTimestamp", null );
// slurp the file into a temp file and then copy the temp back over the top until it is newer.
FileUtils.copyFile( outputFile, tmpFile );
FileUtils.copyFile( tmpFile, outputFile );
while ( timestampReference >= outputFile.lastModified() )
{
FileUtils.copyFile( tmpFile, outputFile );
Thread.yield();
}
tmpFile.delete();
}
/**
* Base method for all the Archivers to create an archiver.
*
* @param format
* @return
* @throws Exception
*/
protected Archiver createArchiver(String format) throws Exception {
final File pomFile = new File("pom.xml");
final File rarFile = new File( "target/output/pom.xml."+format );
Archiver archiver = (Archiver) lookup( Archiver.ROLE, format );
archiver.setDestFile( rarFile );
archiver.addFile( pomFile, "pom.xml" );
return archiver;
}
}
DotDirectiveArchiveFinalizerTest.java 0000664 0000000 0000000 00000003424 12026402656 0037176 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver package org.codehaus.plexus.archiver;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import java.io.File;
import java.util.jar.JarFile;
/** @author Jason van Zyl */
public class DotDirectiveArchiveFinalizerTest
extends PlexusTestCase
{
public void testDotDirectiveArchiveFinalizer()
throws Exception
{
DotDirectiveArchiveFinalizer ddaf =
new DotDirectiveArchiveFinalizer( new File( getBasedir(), "src/test/dotfiles" ) );
JarArchiver archiver = new JarArchiver();
File jarFile = new File( getBasedir(), "target/dotfiles.jar" );
archiver.setDestFile( jarFile );
archiver.addArchiveFinalizer( ddaf );
archiver.createArchive();
JarFile jar = new JarFile( jarFile );
assertNotNull( jar.getEntry( "LICENSE.txt" ) );
assertNotNull( jar.getEntry( "NOTICE.txt" ) );
assertNotNull( jar.getEntry( "META-INF/maven/LICENSE.txt" ) );
assertNotNull( jar.getEntry( "META-INF/maven/NOTICE.txt" ) );
}
public void testDefaultDotDirectiveBehaviour()
throws Exception
{
File dotFileDirectory = new File( getBasedir(), "src/test/dotfiles" );
JarArchiver archiver = new JarArchiver();
archiver.setDotFileDirectory( dotFileDirectory );
File jarFile = new File( getBasedir(), "target/default-dotfiles.jar" );
archiver.setDestFile( jarFile );
archiver.createArchive();
JarFile jar = new JarFile( jarFile );
assertNotNull( jar.getEntry( "LICENSE.txt" ) );
assertNotNull( jar.getEntry( "NOTICE.txt" ) );
assertNotNull( jar.getEntry( "META-INF/maven/LICENSE.txt" ) );
assertNotNull( jar.getEntry( "META-INF/maven/NOTICE.txt" ) );
}
}
DuplicateFilesTest.java 0000664 0000000 0000000 00000011010 12026402656 0034326 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver package org.codehaus.plexus.archiver;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.zip.AbstractZipArchiver;
import org.codehaus.plexus.archiver.zip.ZipFile;
import org.codehaus.plexus.archiver.zip.ZipEntry;
import org.codehaus.plexus.archiver.tar.TarInputStream;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.util.FileUtils;
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.util.Enumeration;
/**
* @author Erik Engstrom
*/
public class DuplicateFilesTest
extends PlexusTestCase
{
private static final File file1 = getTestFile( "src/test/resources/group-writable/foo.txt" );
private static final File file2 = getTestFile( "src/test/resources/world-writable/foo.txt" );
private static final File destination = getTestFile( "target/output/duplicateFiles" );
public void setUp()
throws Exception
{
super.setUp();
getContainer().getLoggerManager().setThreshold( Logger.LEVEL_DEBUG );
}
public void testZipArchiver()
throws Exception
{
Archiver archiver = (Archiver) lookup( Archiver.ROLE, "zip" );
archiver.setDuplicateBehavior( Archiver.DUPLICATES_SKIP );
File archive = createArchive( archiver, "zip" );
ZipFile zf = new ZipFile( archive );
Enumeration e = zf.getEntries();
int entryCount = 0;
while ( e.hasMoreElements() )
{
ZipEntry entry = (ZipEntry) e.nextElement();
System.out.println( entry.getName() );
entryCount++;
}
// Zip file should have 2 entries, 1 for the directory and one for foo.txt
assertEquals( 2, entryCount );
testArchive( archive, "zip" );
}
public void testDirArchiver()
throws Exception
{
Archiver archiver = (Archiver) lookup( Archiver.ROLE, "dir" );
createArchive( archiver, "dir" );
testFinalFile( "target/output/duplicateFiles.dir/duplicateFiles/foo.txt" );
}
public void testTarArchiver()
throws Exception
{
Archiver archiver = (Archiver) lookup( Archiver.ROLE, "tar" );
archiver.setDuplicateBehavior( Archiver.DUPLICATES_SKIP );
File archive = createArchive( archiver, "tar" );
TarInputStream tis;
tis = new TarInputStream( new BufferedInputStream( new FileInputStream( archive ) ) );
int entryCount = 0;
while ( ( tis.getNextEntry() ) != null )
{
entryCount++;
}
assertEquals( 1, entryCount );
testArchive( archive, "tar" );
}
private File createArchive( Archiver archiver, String outputFileExt )
throws Exception
{
archiver.addFile( file1, "duplicateFiles/foo.txt" );
archiver.addFile( file2, "duplicateFiles/foo.txt" );
// delete it if it exists to ensure it is actually empty
if ( destination.exists() )
{
destination.delete();
}
File archive = getTestFile( "target/output/duplicateFiles." + outputFileExt );
if ( archive.exists() )
{
if ( archive.isDirectory() )
{
FileUtils.deleteDirectory( archive );
}
else
{
archive.delete();
}
}
archiver.setDestFile( archive );
archiver.createArchive();
return archive;
}
private void testArchive( File archive, String role )
throws Exception
{
// Check the content of the archive by extracting it
UnArchiver unArchiver = (UnArchiver) lookup( UnArchiver.ROLE, role );
unArchiver.setSourceFile( archive );
unArchiver.setDestDirectory( getTestFile( "target/output/" ) );
unArchiver.extract();
assertTrue( destination.exists() );
assertTrue( destination.isDirectory() );
testFinalFile( "target/output/duplicateFiles/foo.txt" );
}
private void testFinalFile( String path )
throws Exception
{
File outputFile = getTestFile( path );
assertTrue( outputFile.exists() );
BufferedReader reader = new BufferedReader( new FileReader( outputFile ) );
String firstLine = reader.readLine();
reader.close();
reader = new BufferedReader( new FileReader( file2 ) );
String expectedFirstLine = reader.readLine();
reader.close();
assertEquals( expectedFirstLine, firstLine );
}
}
EmptyDirectoryTest.java 0000664 0000000 0000000 00000006257 12026402656 0034435 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver package org.codehaus.plexus.archiver;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.PlexusTestCase;
import java.io.File;
/**
* @author Daniel Krisher
* @version $Id$
*/
public class EmptyDirectoryTest
extends PlexusTestCase
{
public void testZipArchiver()
throws Exception
{
testEmptyDirectory( "zip" );
}
public void testJarArchiver()
throws Exception
{
// No JAR UnArchiver implementation :(
// testEmptyDirectory( "jar" );
}
public void testTarArchiver()
throws Exception
{
testEmptyDirectory( "tar" );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
private void testEmptyDirectory( String role )
throws Exception
{
Archiver archiver = (Archiver) lookup( Archiver.ROLE, role );
// Should default to true...
assertTrue( archiver.getIncludeEmptyDirs() );
// create an empty directory to store in the zip archive
File emptyDir = getTestFile( "target/output/emptyTest/TmpEmptyDir" );
// delete it if it exists to ensure it is actually empty
if ( emptyDir.exists() )
{
emptyDir.delete();
}
emptyDir.mkdirs();
archiver.addDirectory( emptyDir.getParentFile() );
File archive = getTestFile( "target/output/emptyDirArchive.zip" );
if ( archive.exists() )
{
archive.delete();
}
archiver.setDestFile( archive );
archiver.createArchive();
// delete the empty dir, we will extract it from the archive
emptyDir.delete();
// Check the content of the archive by extracting it
UnArchiver unArchiver = (UnArchiver) lookup( UnArchiver.ROLE, role );
unArchiver.setSourceFile( archive );
unArchiver.setDestDirectory( getTestFile( "target/output/emptyTest" ) );
unArchiver.extract();
assertTrue( emptyDir.exists() );
assertTrue( emptyDir.isDirectory() );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/bzip2/ 0000775 0000000 0000000 00000000000 12026402656 0031042 5 ustar 00root root 0000000 0000000 BZip2ArchiverTest.java 0000664 0000000 0000000 00000011625 12026402656 0035105 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/bzip2 package org.codehaus.plexus.archiver.bzip2;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Arrays;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.BasePlexusArchiverTest;
import org.codehaus.plexus.archiver.zip.ZipArchiver;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
/**
* @author Emmanuel Venisse
* @version $Id$
*/
public class BZip2ArchiverTest
extends BasePlexusArchiverTest
{
public void testCreateArchive()
throws Exception
{
ZipArchiver zipArchiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
zipArchiver.addDirectory( getTestFile( "src" ) );
zipArchiver.setDestFile( getTestFile( "target/output/archiveForbz2.zip" ) );
zipArchiver.createArchive();
BZip2Archiver archiver = (BZip2Archiver) lookup( Archiver.ROLE, "bzip2" );
String[] inputFiles = new String[ 1 ];
inputFiles[ 0 ] = "archiveForbz2.zip";
archiver.addDirectory( getTestFile( "target/output" ), inputFiles, null );
archiver.setDestFile( getTestFile( "target/output/archive.bz2" ) );
archiver.createArchive();
}
public void testCreateResourceCollection()
throws Exception
{
final File pomFile = new File("pom.xml");
final File bz2File = new File( "target/output/pom.xml.bz2" );
BZip2Archiver bzip2Archiver = (BZip2Archiver) lookup( Archiver.ROLE, "bzip2" );
bzip2Archiver.setDestFile( bz2File );
bzip2Archiver.addFile( pomFile, "pom.xml" );
FileUtils.removePath( bz2File.getPath() );
bzip2Archiver.createArchive();
System.out.println( "Created: " + bz2File.getAbsolutePath() );
final File zipFile = new File( "target/output/pom.zip" );
ZipArchiver zipArchiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
zipArchiver.setDestFile( zipFile );
zipArchiver.addArchivedFileSet( bz2File, "prfx/" );
FileUtils.removePath( zipFile.getPath() );
zipArchiver.createArchive();
final ZipFile juZipFile = new ZipFile( zipFile );
final ZipEntry zipEntry = juZipFile.getEntry( "prfx/target/output/pom.xml" );
final InputStream archivePom = juZipFile.getInputStream( zipEntry );
final InputStream pom = new FileInputStream( pomFile );
assertTrue( Arrays.equals( IOUtil.toByteArray( pom ), IOUtil.toByteArray( archivePom ) ) );
archivePom.close();
pom.close();
juZipFile.close();
}
/**
* Tests the .bzip2 archiver is forced set to true, and after that
* tests the behavior when the forced is set to false.
*
* @throws Exception
*/
public void testBz2IsForcedBehaviour() throws Exception
{
BZip2Archiver bZip2Archiver = (BZip2Archiver) createArchiver( "bzip2" );
assertTrue( bZip2Archiver.isSupportingForced() );
bZip2Archiver.createArchive();
final long creationTime = bZip2Archiver.getDestFile().lastModified();
waitUntilNewTimestamp( bZip2Archiver.getDestFile(), creationTime );
bZip2Archiver = (BZip2Archiver) createArchiver( "bzip2" );
bZip2Archiver.setForced( true );
bZip2Archiver.createArchive();
final long firstRunTime = bZip2Archiver.getDestFile().lastModified();
assertFalse( creationTime==firstRunTime );
bZip2Archiver = (BZip2Archiver) createArchiver( "bzip2" );
bZip2Archiver.setForced( false );
bZip2Archiver.createArchive();
final long secondRunTime = bZip2Archiver.getDestFile().lastModified();
assertEquals( firstRunTime,secondRunTime );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/gzip/ 0000775 0000000 0000000 00000000000 12026402656 0030765 5 ustar 00root root 0000000 0000000 GZipArchiverTest.java 0000664 0000000 0000000 00000011433 12026402656 0034750 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/gzip package org.codehaus.plexus.archiver.gzip;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Arrays;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.BasePlexusArchiverTest;
import org.codehaus.plexus.archiver.zip.ZipArchiver;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
/**
* @author Emmanuel Venisse
* @version $Id$
*/
public class GZipArchiverTest
extends BasePlexusArchiverTest
{
public void testCreateArchive()
throws Exception
{
ZipArchiver zipArchiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
zipArchiver.addDirectory( getTestFile( "src" ) );
zipArchiver.setDestFile( getTestFile( "target/output/archiveForGzip.zip" ) );
zipArchiver.createArchive();
GZipArchiver archiver = (GZipArchiver) lookup( Archiver.ROLE, "gzip" );
String[] inputFiles = new String[ 1 ];
inputFiles[ 0 ] = "archiveForGzip.zip";
archiver.addDirectory( getTestFile( "target/output" ), inputFiles, null );
archiver.setDestFile( getTestFile( "target/output/archive.gzip" ) );
archiver.createArchive();
}
public void testCreateResourceCollection()
throws Exception
{
final File pomFile = new File("pom.xml");
final File gzFile = new File( "target/output/pom.xml.gz" );
GZipArchiver gzipArchiver = (GZipArchiver) lookup( Archiver.ROLE, "gzip" );
gzipArchiver.setDestFile( gzFile );
gzipArchiver.addFile( pomFile, "pom.xml" );
FileUtils.removePath( gzFile.getPath() );
gzipArchiver.createArchive();
final File zipFile = new File( "target/output/pom.zip" );
ZipArchiver zipArchiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
zipArchiver.setDestFile( zipFile );
zipArchiver.addArchivedFileSet( gzFile, "prfx/" );
FileUtils.removePath( zipFile.getPath() );
zipArchiver.createArchive();
final ZipFile juZipFile = new ZipFile( zipFile );
final ZipEntry zipEntry = juZipFile.getEntry( "prfx/target/output/pom.xml" );
final InputStream archivePom = juZipFile.getInputStream( zipEntry );
final InputStream pom = new FileInputStream( pomFile );
assertTrue( Arrays.equals( IOUtil.toByteArray( pom ), IOUtil.toByteArray( archivePom ) ) );
archivePom.close();
pom.close();
juZipFile.close();
}
/**
* Tests the .gzip archiver is forced set to true, and after that
* tests the behavior when the forced is set to false.
*
* @throws Exception
*/
public void testTarGzIsForcedBehaviour() throws Exception
{
GZipArchiver gZipArchiver = (GZipArchiver) createArchiver( "gzip" );
assertTrue( gZipArchiver.isSupportingForced() );
gZipArchiver.createArchive();
final long creationTime = gZipArchiver.getDestFile().lastModified();
waitUntilNewTimestamp( gZipArchiver.getDestFile(), creationTime );
gZipArchiver = (GZipArchiver) createArchiver( "gzip" );
gZipArchiver.setForced( true );
gZipArchiver.createArchive();
final long firstRunTime = gZipArchiver.getDestFile().lastModified();
assertFalse( creationTime==firstRunTime );
gZipArchiver = (GZipArchiver) createArchiver( "gzip" );
gZipArchiver.setForced( false );
gZipArchiver.createArchive();
final long secondRunTime = gZipArchiver.getDestFile().lastModified();
assertEquals( firstRunTime,secondRunTime );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar/ 0000775 0000000 0000000 00000000000 12026402656 0030570 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar/IndexTest.java 0000664 0000000 0000000 00000013206 12026402656 0033344 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.jar;
/*
* Copyright 2006 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.BufferedInputStream;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.zip.ZipEntry;
import org.codehaus.plexus.archiver.zip.ZipFile;
/**
* @author Richard van der Hoff
* @version $Id$
*/
public class IndexTest extends PlexusTestCase {
public void testCreateArchiveWithIndexedJars()
throws Exception
{
/* create a dummy jar */
JarArchiver archiver1 = (JarArchiver) lookup( Archiver.ROLE, "jar" );
archiver1.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), "one.txt" );
archiver1.setDestFile( getTestFile( "target/output/archive1.jar" ) );
archiver1.createArchive();
/* now create another jar, with an index, and whose manifest includes a Class-Path entry for the first jar.
*/
Manifest m = new Manifest();
Manifest.Attribute classpathAttr = new Manifest.Attribute( "Class-Path", "archive1.jar" );
m.addConfiguredAttribute( classpathAttr );
JarArchiver archiver2 = (JarArchiver) lookup( Archiver.ROLE, "jar" );
archiver2.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), "two.txt" );
archiver2.setIndex(true);
archiver2.addConfiguredIndexJars(archiver1.getDestFile());
archiver2.setDestFile( getTestFile( "target/output/archive2.jar" ) );
archiver2.addConfiguredManifest(m);
archiver2.createArchive();
// read the index file back and check it looks like it ought to
ZipFile zf = new ZipFile( archiver2.getDestFile() );
ZipEntry indexEntry = zf.getEntry("META-INF/INDEX.LIST");
assertNotNull(indexEntry);
BufferedInputStream bis = new BufferedInputStream(zf.getInputStream(indexEntry));
byte buf[] = new byte[1024];
int i = bis.read(buf);
String res = new String(buf,0,i);
assertEquals("JarIndex-Version: 1.0\n\narchive2.jar\ntwo.txt\n\narchive1.jar\none.txt\n\n", res.replaceAll("\r\n", "\n"));
}
/**
* this is pretty much a duplicate of testCreateArchiveWithIndexedJars(), but adds some extra
* tests for files in META-INF
*/
public void testCreateArchiveWithIndexedJarsAndMetaInf()
throws Exception
{
/* create a dummy jar */
JarArchiver archiver1 = (JarArchiver) lookup( Archiver.ROLE, "jar" );
archiver1.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), "one.txt" );
// add a file in the META-INF directory, as this previously didn't make it into the index
archiver1.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), "META-INF/foo" );
archiver1.setDestFile( getTestFile( "target/output/archive1.jar" ) );
archiver1.createArchive();
/* create another dummy jar, with an index but nothing else in META-INF. Also checks non-leaf files. */
JarArchiver archiver3 = (JarArchiver) lookup( Archiver.ROLE, "jar" );
archiver3.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), "org/apache/maven/one.txt" );
archiver3.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), "META-INF/INDEX.LIST" );
archiver3.setDestFile( getTestFile( "target/output/archive3.jar" ) );
archiver3.createArchive();
/* now create another jar, with an index, and whose manifest includes a Class-Path entry for the first two jars.
*/
Manifest m = new Manifest();
Manifest.Attribute classpathAttr = new Manifest.Attribute( "Class-Path", "archive1.jar archive3.jar" );
m.addConfiguredAttribute( classpathAttr );
JarArchiver archiver2 = (JarArchiver) lookup( Archiver.ROLE, "jar" );
archiver2.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), "two.txt" );
archiver2.setIndex(true);
archiver2.addConfiguredIndexJars(archiver1.getDestFile());
archiver2.addConfiguredIndexJars(archiver3.getDestFile());
archiver2.setDestFile( getTestFile( "target/output/archive2.jar" ) );
archiver2.addConfiguredManifest(m);
archiver2.createArchive();
// read the index file back and check it looks like it ought to
ZipFile zf = new ZipFile( archiver2.getDestFile() );
ZipEntry indexEntry = zf.getEntry("META-INF/INDEX.LIST");
assertNotNull(indexEntry);
BufferedInputStream bis = new BufferedInputStream(zf.getInputStream(indexEntry));
byte buf[] = new byte[1024];
int i = bis.read(buf);
String res = new String(buf,0,i);
//System.out.println(res);
StringBuffer expected = new StringBuffer();
expected.append("JarIndex-Version: 1.0\n\n");
expected.append("archive2.jar\ntwo.txt\n\n");
expected.append("archive1.jar\nMETA-INF\none.txt\n\n");
expected.append("archive3.jar\norg\norg/apache\norg/apache/maven\n\n");
assertEquals(expected.toString(), res.replaceAll("\r\n", "\n"));
}
}
JarArchiverTest.java 0000664 0000000 0000000 00000001517 12026402656 0034420 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar package org.codehaus.plexus.archiver.jar;
import org.codehaus.plexus.archiver.ArchiverException;
import java.io.File;
import java.io.IOException;
import junit.framework.TestCase;
public class JarArchiverTest
extends TestCase
{
public void testCreateManifestOnlyJar()
throws IOException, ManifestException, ArchiverException
{
File jarFile = File.createTempFile( "JarArchiverTest.", ".jar" );
jarFile.deleteOnExit();
JarArchiver archiver = new JarArchiver();
archiver.setDestFile( jarFile );
Manifest manifest = new Manifest();
Manifest.Attribute attribute = new Manifest.Attribute( "Main-Class", getClass().getName() );
manifest.addConfiguredAttribute( attribute );
archiver.addConfiguredManifest( manifest );
archiver.createArchive();
}
}
JdkManifestFactoryTest.java 0000664 0000000 0000000 00000007265 12026402656 0035755 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar package org.codehaus.plexus.archiver.jar;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import org.codehaus.plexus.PlexusTestCase;
/**
* @author Kristian Rosenvold
*/
public class JdkManifestFactoryTest
extends PlexusTestCase
{
public void testGetDefaultManifest()
throws Exception
{
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Manifest manifest = JdkManifestFactory.getDefaultManifest();
manifest.write( byteArrayOutputStream );
System.out.println( new String( byteArrayOutputStream.toByteArray() ) );
}
public void testGetDefaultManifestString()
throws Exception
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifestWithClassPath.mf" );
Manifest manifestWithout = getManifest( "src/test/resources/manifests/manifest1.mf" );
String value = manifest.getMainAttributes().getValue( ManifestConstants.ATTRIBUTE_CLASSPATH );
System.out.println( "value = " + value );
manifestWithout.getMainAttributes().putValue( ManifestConstants.ATTRIBUTE_CLASSPATH, value );
String value2 = manifestWithout.getMainAttributes().getValue( ManifestConstants.ATTRIBUTE_CLASSPATH );
assertEquals( value, value2 );
}
public void testIllegals()
throws ManifestException, IOException
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifest6.mf" );
assertNotNull( manifest );
try
{
getManifest( "src/test/resources/manifests/manifest5.mf" );
fail( "We expect to fail" );
}
catch ( IOException ignore )
{
}
}
public void testMerge()
throws ManifestException, IOException
{
Manifest manifest1 = getManifest( "src/test/resources/manifests/manifestMerge1.mf" );
Manifest manifest2 = getManifest( "src/test/resources/manifests/manifestMerge2.mf" );
Manifest target = new Manifest();
JdkManifestFactory.merge( target, manifest1, false );
assertEquals( "001", target.getMainAttributes().getValue( "Bar" ) );
Attributes fudz = target.getAttributes( "Fudz" );
assertNotNull( fudz );
assertEquals( "002", fudz.getValue( "Bar" ) );
Attributes redz = target.getAttributes( "Redz" );
assertNotNull( redz );
assertEquals( "002", redz.getValue( "Baz" ) );
JdkManifestFactory.merge( target, manifest2, false );
assertEquals( "001", target.getMainAttributes().getValue( "Bar" ) );
fudz = target.getAttributes( "Fudz" );
assertNotNull( fudz );
assertEquals( "003", fudz.getValue( "Bar" ) );
redz = target.getAttributes( "Redz" );
assertNotNull( redz );
assertEquals( "002", redz.getValue( "Baz" ) );
}
public void testDualClassPath()
throws ManifestException, IOException
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifestWithDualClassPath.mf" );
final Attributes mainAttributes = manifest.getMainAttributes();
final String attribute = mainAttributes.getValue( "Class-Path" );
// assertEquals( "../config/ classes12.jar baz", attribute );
}
/**
* Reads a Manifest file.
*/
private java.util.jar.Manifest getManifest( String filename )
throws IOException, ManifestException
{
FileInputStream r = new FileInputStream( getTestFile( filename ) );
try
{
return new Manifest( r );
}
finally
{
r.close();
}
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar/ManifestTest.java0000664 0000000 0000000 00000031363 12026402656 0034047 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.jar;
/*
* 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.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Enumeration;
import java.util.jar.Attributes;
import org.codehaus.plexus.PlexusTestCase;
/**
* @author Emmanuel Venisse
* @version $Id$
*/
public class ManifestTest
extends PlexusTestCase
{
public void testManifestReader1()
throws Exception
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifest1.mf" );
String version = manifest.getManifestVersion();
assertEquals( "Manifest was not created with correct version - ", "1.0", version );
}
public void testManifestReader2()
throws Exception
{
try
{
getManifest( "src/test/resources/manifests/manifest2.mf" );
fail( "Manifest isn't well formed. It must be generate an exception." );
}
catch ( IOException ignore )
{
}
}
public void testManifestReader3()
throws Exception
{
try
{
getManifest( "src/test/resources/manifests/manifest3.mf" );
fail( "Manifest isn't well formed. It must be generate an exception." );
}
catch ( IOException ignore )
{
}
}
public void testManifestReader5()
throws Exception
{
try
{
getManifest( "src/test/resources/manifests/manifest5.mf" );
fail();
}
catch ( IOException ignore )
{
}
}
public void testAddConfiguredSection()
throws ManifestException
{
Manifest manifest = new Manifest();
Manifest.Section section = new Manifest.Section();
section.setName( "fud" );
section.addConfiguredAttribute( new Manifest.Attribute( "bar", "baz" ) );
manifest.addConfiguredSection( section );
assertEquals( "baz", manifest.getAttributes( "fud" ).getValue( "bar" ) );
}
public void testAttributeLongLineWrite()
throws Exception
{
StringWriter writer = new StringWriter();
Manifest.Attribute attr = new Manifest.Attribute();
String longLineOfChars =
"123456789 123456789 123456789 123456789 123456789 123456789 123456789 "
+ "123456789 123456789 123456789 ";
attr.setName( "test" );
attr.setValue( longLineOfChars );
attr.write( new PrintWriter( writer ) );
writer.flush();
assertEquals( "should be multiline",
"test: 123456789 123456789 123456789 123456789 123456789 123456789 1234"
+ Manifest.EOL +
" 56789 123456789 123456789 123456789 " + Manifest.EOL,
writer.toString() );
}
public void testDualClassPath()
throws ManifestException, IOException
{
Manifest manifest =
getManifest( "src/test/resources/manifests/manifestWithDualClassPath.mf" );
final String attribute = manifest.getMainSection().getAttributeValue( "Class-Path" );
// According to discussions, we drop support for duplicate class-path attribute
assertEquals( "baz", attribute );
}
public void testAttributeMultiLineValue()
throws Exception
{
checkMultiLineAttribute( "123456789" + Manifest.EOL + "123456789",
"123456789" + Manifest.EOL + " 123456789" + Manifest.EOL );
}
public void testAttributeDifferentLineEndings()
throws Exception
{
checkMultiLineAttribute( "\tA\rB\n\t C\r\n \tD\n\r", "\tA" + Manifest.EOL +
" B" + Manifest.EOL +
" \t C" + Manifest.EOL +
" \tD" + Manifest.EOL );
}
public void testIterators()
throws ManifestException, IOException
{
PlexusManifest plexusManifest =
getPlexusManifest( "src/test/resources/manifests/manifestMerge1.mf" );
Enumeration attributeKeys = plexusManifest.getMainSection().getAttributeKeys();
assertNotNull( attributeKeys.nextElement() );
Manifest manifest = getManifest( "src/test/resources/manifests/manifestMerge1.mf" );
String key = manifest.getMainSection().iterator().next();
assertNotNull( key );
}
public void testAddAttributes()
throws ManifestException, IOException
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifestMerge1.mf" );
Manifest.ExistingSection fudz = manifest.getSection( "Fudz" );
fudz.addConfiguredAttribute( new Manifest.Attribute( "boz", "bzz" ) );
assertEquals( "bzz", fudz.getAttribute( "boz" ).getValue());
assertEquals( "bzz", manifest.getSection( "Fudz" ).getAttributeValue( "boz" ) );
}
public void testRemoveAttributes()
throws ManifestException, IOException
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifestMerge1.mf" );
Manifest.ExistingSection fudz = manifest.getSection( "Fudz" );
fudz.addConfiguredAttribute( new Manifest.Attribute( "boz", "bzz" ) );
assertEquals( "bzz", fudz.getAttributeValue( "boz" ) );
fudz.removeAttribute( "boz" );
assertNull( fudz.getAttributeValue( "boz" ) );
}
public void testAttributeSerialization()
throws IOException, ManifestException
{
Manifest manifest = new Manifest( );
manifest.getMainAttributes().putValue( "mfa1", "fud1" );
manifest.getMainSection().addAttributeAndCheck( new Manifest.Attribute( "mfa2", "fud2" ) );
Attributes attributes = new Attributes( );
attributes.putValue( "attA", "baz" );
manifest.getEntries().put( "sub", attributes );
manifest.getSection( "sub" ).addAttributeAndCheck( new Manifest.Attribute( "attB", "caB" ) );
StringWriter writer = new StringWriter();
manifest.write( new PrintWriter( writer ) );
String s = writer.toString();
assertTrue( s.contains( "mfa1: fud1" ) );
assertTrue( s.contains( "mfa2: fud2" ) );
assertTrue( s.contains( "attA: baz" ) );
assertTrue( s.contains( "attB: caB" ) );
}
public void testDefaultBehaviour()
{
Manifest manifest = new Manifest();
Manifest.ExistingSection mainSection = manifest.getMainSection();
assertNotNull( mainSection );
String bar = mainSection.getAttributeValue( "Bar" );
assertNull( bar );
assertNull( manifest.getSection( "Fud" ) );
}
public void testGetDefaultManifest()
throws Exception
{
java.util.jar.Manifest mf = Manifest.getDefaultManifest();
java.util.jar.Attributes mainAttributes = mf.getMainAttributes();
assertEquals( 3, mainAttributes.size() );
assertTrue(
mainAttributes.containsKey( new java.util.jar.Attributes.Name( "Manifest-Version" ) ) );
assertTrue(
mainAttributes.containsKey( new java.util.jar.Attributes.Name( "Created-By" ) ) );
assertTrue(
mainAttributes.containsKey( new java.util.jar.Attributes.Name( "Archiver-Version" ) ) );
}
public void checkMultiLineAttribute( String in, String expected )
throws Exception
{
StringWriter writer = new StringWriter();
Manifest.Attribute attr = new Manifest.Attribute();
attr.setName( "test" );
attr.setValue( in );
attr.write( new PrintWriter( writer ) );
writer.flush();
// Print the string with whitespace replaced with special codes
// so in case of failure you can see what went wrong.
System.err.println( "String: " + dumpString( writer.toString() ) );
assertEquals( "should be indented multiline", "test: " + expected, writer.toString() );
}
private static String dumpString( String in )
{
String out = "";
char[] chars = in.toCharArray();
for ( char aChar : chars )
{
switch ( aChar )
{
case '\t':
out += "\\t";
break;
case '\r':
out += "\\r";
break;
case '\n':
out += "\\n";
break;
case ' ':
out += "\\s";
break;
default:
out += aChar;
break;
}
}
return out;
}
public void testAddAttributesPlexusManifest()
throws ManifestException, IOException
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifestMerge1.mf" );
Manifest.ExistingSection fudz = manifest.getSection( "Fudz" );
fudz.addConfiguredAttribute( new Manifest.Attribute( "boz", "bzz" ) );
assertEquals( "bzz", manifest.getSection( "Fudz" ).getAttributeValue( "boz" ) );
}
public void testRemoveAttributesPlexusManifest()
throws ManifestException, IOException
{
Manifest manifest = getManifest( "src/test/resources/manifests/manifestMerge1.mf" );
Manifest.ExistingSection fudz = manifest.getSection( "Fudz" );
fudz.addConfiguredAttribute( new Manifest.Attribute( "boz", "bzz" ) );
assertEquals( "bzz", fudz.getAttributeValue( "boz" ) );
fudz.removeAttribute( "boz" );
assertNull( fudz.getAttributeValue( "boz" ) );
}
public void testAttributeSerializationPlexusManifest()
throws IOException, ManifestException
{
Manifest manifest = new Manifest( );
manifest.getMainSection().addConfiguredAttribute( new Manifest.Attribute( "mfa1", "fud1" ) );
manifest.getMainSection().addConfiguredAttribute( new Manifest.Attribute( "mfa2", "fud2" ) );
Manifest.Section attributes = new Manifest.Section( );
attributes.setName( "TestSection" );
attributes.addConfiguredAttribute( new Manifest.Attribute( "attA", "baz" ) );
attributes.addConfiguredAttribute( new Manifest.Attribute( "attB", "caB" ) );
manifest.addConfiguredSection( attributes );
StringWriter writer = new StringWriter();
manifest.write( new PrintWriter( writer ) );
String s = writer.toString();
assertTrue( s.contains( "mfa1: fud1" ) );
assertTrue( s.contains( "mfa2: fud2" ) );
assertTrue( s.contains( "attA: baz" ) );
assertTrue( s.contains( "attB: caB" ) );
}
public void testClassPathPlexusManifest()
throws ManifestException
{
Manifest manifest = new Manifest();
manifest.addConfiguredAttribute(
new Manifest.Attribute( ManifestConstants.ATTRIBUTE_CLASSPATH, "fud" ) );
manifest.addConfiguredAttribute(
new Manifest.Attribute( ManifestConstants.ATTRIBUTE_CLASSPATH, "duf" ) );
assertEquals( "fud duf", manifest.getMainSection().getAttributeValue(
ManifestConstants.ATTRIBUTE_CLASSPATH ) );
}
public void testAddConfiguredSectionPlexusManifest()
throws ManifestException
{
Manifest manifest = new Manifest();
Manifest.Section section = new Manifest.Section();
section.setName( "fud" );
section.addConfiguredAttribute( new Manifest.Attribute( "bar", "baz" ) );
manifest.addConfiguredSection( section );
assertEquals( "baz", manifest.getSection( "fud" ).getAttributeValue( "bar" ));
}
/**
* Reads a Manifest file.
*
* @param filename the file
* @return a manifest
* @throws java.io.IOException .
* @throws ManifestException .
*/
private Manifest getManifest( String filename )
throws IOException, ManifestException
{
FileReader r = new FileReader( getTestFile( filename ) );
try
{
return new Manifest( r );
}
finally
{
r.close();
}
}
private PlexusManifest getPlexusManifest( String filename )
throws IOException, ManifestException
{
FileReader r = new FileReader( getTestFile( filename ) );
try
{
return new PlexusManifest( r );
}
finally
{
r.close();
}
}
}
PlexusManifest.java 0000664 0000000 0000000 00000113570 12026402656 0034332 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar 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 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;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.util.IOUtil;
/**
* THE ORIGINAL manifest implementation from plexus 2.0.2
*/
public class PlexusManifest
{
/**
* The standard manifest version header
*/
public static final String ATTRIBUTE_MANIFEST_VERSION = ManifestConstants.ATTRIBUTE_MANIFEST_VERSION;
/**
* The standard Signature Version header
*/
public static final String ATTRIBUTE_SIGNATURE_VERSION = ManifestConstants.ATTRIBUTE_SIGNATURE_VERSION;
/**
* The Name Attribute is the first in a named section
*/
public static final String ATTRIBUTE_NAME = ManifestConstants.ATTRIBUTE_NAME;
/**
* The From Header is disallowed in a PlexusManifest
*/
public static final String ATTRIBUTE_FROM = ManifestConstants.ATTRIBUTE_FROM;
/**
* The Class-Path Header is special - it can be duplicated
*/
public static final String ATTRIBUTE_CLASSPATH = ManifestConstants.ATTRIBUTE_CLASSPATH;
/**
* Default PlexusManifest version if one is not specified
*/
public static final String DEFAULT_MANIFEST_VERSION = ManifestConstants.DEFAULT_MANIFEST_VERSION;
/**
* The max length of a line in a PlexusManifest
*/
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 PlexusManifest
*
* @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;
}
return rhsAttribute.values != null && 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( "PlexusManifest 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 PlexusManifest 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 = 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 PlexusManifest 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
* @throws java.io.IOException when Io excepts
*/
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
* PlexusManifest 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( ManifestConstants.ATTRIBUTE_CLASSPATH ) )
{
if ( classpathAttribute == null )
{
classpathAttribute = new Attribute();
classpathAttribute.setName( ManifestConstants.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 PlexusManifest.Attribute instance if the attribute is
* single-valued, otherwise a Vector of PlexusManifest.Attribute
* instances.
*/
public Attribute getAttribute( String attributeName )
{
return 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 the element rather "
+ "than using a \"Name\" manifest attribute" );
}
}
/**
* Add an attribute to the section
*
* @param attribute the attribute to be added.
* @return the value of the attribute if it is a name
* attribute - null other wise
* @throws ManifestException if the attribute already
* exists in this section.
*/
public String addAttributeAndCheck( Attribute attribute )
throws ManifestException
{
if ( attribute.getName() == null || attribute.getValue() == null )
{
throw new ManifestException( "Attributes must have name and value" );
}
if ( attribute.getKey().equalsIgnoreCase( ATTRIBUTE_NAME ) )
{
warnings.addElement(
"\"" + ATTRIBUTE_NAME + "\" attributes " + "should not occur in the main section and must be the "
+ "first element in all other sections: \"" + attribute.getName() + ": " + attribute.getValue()
+ "\"" );
return attribute.getValue();
}
if ( attribute.getKey().startsWith( ATTRIBUTE_FROM.toLowerCase() ) )
{
warnings.addElement( "PlexusManifest attributes should not start " + "with \"" + ATTRIBUTE_FROM + "\" in \""
+ attribute.getName() + ": " + attribute.getValue() + "\"" );
}
else
{
// classpath attributes go into a vector
String attributeKey = attribute.getKey();
if ( attributeKey.equalsIgnoreCase( ManifestConstants.ATTRIBUTE_CLASSPATH ) )
{
Attribute classpathAttribute = attributes.get( attributeKey );
if ( classpathAttribute == null )
{
storeAttribute( attribute );
}
else
{
warnings.addElement( "Multiple Class-Path attributes " + "are supported but violate the Jar "
+ "specification and may not be correctly "
+ "processed in all environments" );
Enumeration e = attribute.getValues();
while ( e.hasMoreElements() )
{
String value = (String) e.nextElement();
classpathAttribute.addValue( value );
}
}
}
else if ( attributes.containsKey( attributeKey ) )
{
throw new ManifestException( "The attribute \"" + attribute.getName() + "\" may not occur more "
+ "than once in the same section" );
}
else
{
storeAttribute( attribute );
}
}
return null;
}
/**
* Clone this section
*
* @return the cloned Section
* @since Ant 1.5.2
*/
public Object clone()
{
Section cloned = new Section();
cloned.setName( name );
Enumeration e = getAttributeKeys();
while ( e.hasMoreElements() )
{
String key = (String) e.nextElement();
Attribute attribute = getAttribute( key );
cloned.storeAttribute( new Attribute( attribute.getName(), attribute.getValue() ) );
}
return cloned;
}
/**
* Store an attribute and update the index.
*
* @param attribute the attribute to be stored
*/
private void storeAttribute( Attribute attribute )
{
if ( attribute == null )
{
return;
}
String attributeKey = attribute.getKey();
attributes.put( attributeKey, attribute );
if ( !attributeIndex.contains( attributeKey ) )
{
attributeIndex.addElement( attributeKey );
}
}
/**
* Get the warnings for this section.
*
* @return an Enumeration of warning strings.
*/
public Enumeration getWarnings()
{
return warnings.elements();
}
/**
* @see java.lang.Object#hashCode
*/
public int hashCode()
{
int hashCode = 0;
if ( name != null )
{
hashCode += name.hashCode();
}
hashCode += attributes.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;
}
Section rhsSection = (Section) rhs;
if ( rhsSection.attributes == null )
{
return false;
}
return attributes.equals( rhsSection.attributes );
}
}
/**
* The version of this manifest
*/
private String manifestVersion = DEFAULT_MANIFEST_VERSION;
/**
* The main section of this manifest
*/
private Section mainSection = new Section();
/**
* The named sections of this manifest
*/
private Hashtable sections = new Hashtable();
/**
* Index of sections - used to retain order of sections in manifest
*/
private Vector sectionIndex = new Vector();
/**
* Construct a manifest from Ant's default manifest file.
*
* @return the default manifest.
* @throws ArchiverException if there is a problem loading the
* default manifest
*/
public static PlexusManifest getDefaultManifest()
throws ArchiverException
{
try
{
String defManifest = "/org/codehaus/plexus/archiver/jar/defaultManifest.mf";
InputStream in = PlexusManifest.class.getResourceAsStream( defManifest );
if ( in == null )
{
throw new ArchiverException( "Could not find default manifest: " + defManifest );
}
try
{
PlexusManifest defaultManifest = new PlexusManifest( new InputStreamReader( in, "UTF-8" ) );
Attribute createdBy = new Attribute( "Created-By", System.getProperty( "java.vm.version" ) + " ("
+ System.getProperty( "java.vm.vendor" ) + ")" );
defaultManifest.getMainSection().storeAttribute( createdBy );
return defaultManifest;
}
catch ( UnsupportedEncodingException e )
{
return new PlexusManifest( new InputStreamReader( in ) );
}
finally
{
IOUtil.close( in );
}
}
catch ( ManifestException e )
{
throw new ArchiverException( "Default manifest is invalid !!", e );
}
catch ( IOException e )
{
throw new ArchiverException( "Unable to read default manifest", e );
}
}
/**
* Construct an empty manifest
*/
public PlexusManifest()
{
}
/**
* Read a manifest file from the given reader
*
* @param r is the reader from which the PlexusManifest is read
* @throws ManifestException if the manifest is not valid according
* to the JAR spec
* @throws IOException if the manifest cannot be read from the reader.
*/
public PlexusManifest( Reader r )
throws ManifestException, IOException
{
BufferedReader reader = new BufferedReader( r );
// This should be the manifest version
String nextSectionName = mainSection.read( reader );
String readManifestVersion = mainSection.getAttributeValue( ATTRIBUTE_MANIFEST_VERSION );
if ( readManifestVersion != null )
{
manifestVersion = readManifestVersion;
mainSection.removeAttribute( ATTRIBUTE_MANIFEST_VERSION );
}
String line;
while ( ( line = reader.readLine() ) != null )
{
if ( line.length() == 0 )
{
continue;
}
Section section = new Section();
if ( nextSectionName == null )
{
Attribute sectionName = new Attribute( line );
if ( !sectionName.getName().equalsIgnoreCase( ATTRIBUTE_NAME ) )
{
throw new ManifestException(
"PlexusManifest sections should start with a \"" + ATTRIBUTE_NAME + "\" attribute and not \""
+ sectionName.getName() + "\"" );
}
nextSectionName = sectionName.getValue();
}
else
{
// we have already started reading this section
// this line is the first attribute. set it and then
// let the normal read handle the rest
Attribute firstAttribute = new Attribute( line );
section.addAttributeAndCheck( firstAttribute );
}
section.setName( nextSectionName );
nextSectionName = section.read( reader );
addConfiguredSection( section );
}
}
/**
* Add a section to the manifest
*
* @param section the manifest section to be added
* @throws ManifestException if the secti0on is not valid.
*/
public void addConfiguredSection( Section section )
throws ManifestException
{
String sectionName = section.getName();
if ( sectionName == null )
{
throw new ManifestException( "Sections must have a name" );
}
sections.put( sectionName, section );
if ( !sectionIndex.contains( sectionName ) )
{
sectionIndex.addElement( sectionName );
}
}
/**
* Add an attribute to the manifest - it is added to the main section.
*
* @param attribute the attribute to be added.
* @throws ManifestException if the attribute is not valid.
*/
public void addConfiguredAttribute( Attribute attribute )
throws ManifestException
{
if ( attribute.getKey() == null || attribute.getValue() == null )
{
throw new ManifestException( "Attributes must have name and value" );
}
if ( attribute.getKey().equalsIgnoreCase( ATTRIBUTE_MANIFEST_VERSION ) )
{
manifestVersion = attribute.getValue();
}
else
{
mainSection.addConfiguredAttribute( attribute );
}
}
/**
* Merge the contents of the given manifest into this manifest
*
* @param other the PlexusManifest to be merged with this one.
* @throws ManifestException if there is a problem merging the
* manifest according to the PlexusManifest spec.
*/
public void merge( PlexusManifest other )
throws ManifestException
{
merge( other, false );
}
/**
* Merge the contents of the given manifest into this manifest
*
* @param other the PlexusManifest to be merged with this one.
* @param overwriteMain whether to overwrite the main section
* of the current manifest
* @throws ManifestException if there is a problem merging the
* manifest according to the PlexusManifest spec.
*/
public void merge( PlexusManifest other, boolean overwriteMain )
throws ManifestException
{
if ( other != null )
{
if ( overwriteMain )
{
mainSection = (Section) other.mainSection.clone();
}
else
{
mainSection.merge( other.mainSection );
}
if ( other.manifestVersion != null )
{
manifestVersion = other.manifestVersion;
}
Enumeration e = other.getSectionNames();
while ( e.hasMoreElements() )
{
String sectionName = (String) e.nextElement();
Section ourSection = sections.get( sectionName );
Section otherSection = other.sections.get( sectionName );
if ( ourSection == null )
{
if ( otherSection != null )
{
addConfiguredSection( (Section) otherSection.clone() );
}
}
else
{
ourSection.merge( otherSection );
}
}
}
}
/**
* Write the manifest out to a print writer.
*
* @param writer the Writer to which the manifest is written
* @throws IOException if the manifest cannot be written
*/
public void write( PrintWriter writer )
throws IOException
{
writer.print( ATTRIBUTE_MANIFEST_VERSION + ": " + manifestVersion + EOL );
String signatureVersion = mainSection.getAttributeValue( ATTRIBUTE_SIGNATURE_VERSION );
if ( signatureVersion != null )
{
writer.print( ATTRIBUTE_SIGNATURE_VERSION + ": " + signatureVersion + EOL );
mainSection.removeAttribute( ATTRIBUTE_SIGNATURE_VERSION );
}
mainSection.write( writer );
// add it back
if ( signatureVersion != null )
{
try
{
Attribute svAttr = new Attribute( ATTRIBUTE_SIGNATURE_VERSION, signatureVersion );
mainSection.addConfiguredAttribute( svAttr );
}
catch ( ManifestException e )
{
// shouldn't happen - ignore
}
}
Enumeration e = sectionIndex.elements();
while ( e.hasMoreElements() )
{
String sectionName = (String) e.nextElement();
Section section = getSection( sectionName );
section.write( writer );
}
}
/**
* Convert the manifest to its string representation
*
* @return a multiline string with the PlexusManifest as it
* appears in a PlexusManifest file.
*/
public String toString()
{
StringWriter sw = new StringWriter();
try
{
write( new PrintWriter( sw ) );
}
catch ( IOException e )
{
return null;
}
return sw.toString();
}
/**
* Get the warnings for this manifest.
*
* @return an enumeration of warning strings
*/
public Enumeration getWarnings()
{
Vector warnings = new Vector();
Enumeration warnEnum = mainSection.getWarnings();
while ( warnEnum.hasMoreElements() )
{
warnings.addElement( warnEnum.nextElement() );
}
// create a vector and add in the warnings for all the sections
Enumeration e = sections.elements();
while ( e.hasMoreElements() )
{
Section section = e.nextElement();
Enumeration e2 = section.getWarnings();
while ( e2.hasMoreElements() )
{
warnings.addElement( e2.nextElement() );
}
}
return warnings.elements();
}
/**
* @see java.lang.Object#hashCode
*/
public int hashCode()
{
int hashCode = 0;
if ( manifestVersion != null )
{
hashCode += manifestVersion.hashCode();
}
hashCode += mainSection.hashCode();
hashCode += sections.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;
}
PlexusManifest rhsManifest = (PlexusManifest) rhs;
if ( manifestVersion == null )
{
if ( rhsManifest.manifestVersion != null )
{
return false;
}
}
else if ( !manifestVersion.equals( rhsManifest.manifestVersion ) )
{
return false;
}
if ( !mainSection.equals( rhsManifest.mainSection ) )
{
return false;
}
if ( rhsManifest.sections == null )
{
return false;
}
return sections.equals( rhsManifest.sections );
}
/**
* Get the version of the manifest
*
* @return the manifest's version string
*/
public String getManifestVersion()
{
return manifestVersion;
}
/**
* Get the main section of the manifest
*
* @return the main section of the manifest
*/
public Section getMainSection()
{
return mainSection;
}
/**
* Get a particular section from the manifest
*
* @param name the name of the section desired.
* @return the specified section or null if that section
* does not exist in the manifest
*/
public Section getSection( String name )
{
return sections.get( name );
}
/**
* Get the section names in this manifest.
*
* @return an Enumeration of section names
*/
public Enumeration getSectionNames()
{
return sectionIndex.elements();
}
}
SecurityFilterTest.java 0000664 0000000 0000000 00000005710 12026402656 0035174 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/jar package org.codehaus.plexus.archiver.jar;
/*
* Copyright 2007 The Codehaus 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.util.ArrayList;
import java.util.List;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.filters.JarSecurityFileFilter;
import org.codehaus.plexus.archiver.zip.ZipEntry;
import org.codehaus.plexus.archiver.zip.ZipFile;
/**
* @author Mike Cumings
* @version $Id$
* @since 14 Jun 07
*/
public class SecurityFilterTest
extends PlexusTestCase
{
public void testSecurityFilters()
throws Exception
{
File dummyContent = getTestFile( "src/test/resources/jar-security/dummy.txt" );
String[] unFilteredFiles = new String[] { "META-INF/BOB.txt", "META-INF/harry.xml", };
String[] filteredFiles = new String[] {
"META-INF/FOO.DSA",
"META-INF/BAR.dsa",
"META-INF/BAZ.RSA",
"META-INF/BOO.rsa",
"META-INF/SIG.SF",
"META-INF/FILE.sf" };
// Load up our filter ist
List filters = new ArrayList();
filters.add( new JarSecurityFileFilter() );
//filters.add( new JarSecurityFileSelector() );
// Create our test jar with fake security files
JarArchiver archiver = (JarArchiver) lookup( Archiver.ROLE, "jar" );
archiver.setArchiveFilters( filters );
for ( int i = 0; i < filteredFiles.length; i++ )
{
archiver.addFile( dummyContent, filteredFiles[i] );
}
for ( int i = 0; i < unFilteredFiles.length; i++ )
{
archiver.addFile( dummyContent, unFilteredFiles[i] );
}
archiver.setDestFile( getTestFile( "target/jar-security/test-archive.jar" ) );
archiver.createArchive();
// Verify that the fake files were filtered out of the created jar and that
// the legitimate files were not
ZipFile zf = new ZipFile( archiver.getDestFile() );
for ( int i = 0; i < filteredFiles.length; i++ )
{
ZipEntry entry = zf.getEntry( filteredFiles[i] );
assertNull( "Entry was not filtered out: " + filteredFiles[i], entry );
}
for ( int i = 0; i < unFilteredFiles.length; i++ )
{
ZipEntry entry = zf.getEntry( unFilteredFiles[i] );
assertNotNull( "Entry was filtered out: " + unFilteredFiles[i], entry );
}
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/manager/ 0000775 0000000 0000000 00000000000 12026402656 0031426 5 ustar 00root root 0000000 0000000 ArchiverManagerTest.java 0000664 0000000 0000000 00000013403 12026402656 0036111 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/manager package org.codehaus.plexus.archiver.manager;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.UnArchiver;
import java.io.File;
/**
* @author Dan T. Tran
* @version $Id: ArchiverManagerTest.java$
*/
public class ArchiverManagerTest
extends PlexusTestCase
{
public void testLookupArchiver()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
Archiver archiver = manager.getArchiver( "jar" );
assertNotNull( archiver );
}
public void testReuseArchiver()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
Archiver archiver = manager.getArchiver( "jar" );
assertNotNull( archiver );
archiver.addDirectory( new File( getBasedir() ) );
Archiver newArchiver = manager.getArchiver( "jar" );
assertNotNull( newArchiver );
assertFalse( newArchiver.equals( archiver ) );
assertTrue( !newArchiver.getResources().hasNext() );
}
public void testLookupUnArchiver()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
UnArchiver unarchiver = manager.getUnArchiver( "zip" );
assertNotNull( unarchiver );
}
public void testLookupUnknownArchiver()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
try
{
manager.getArchiver( "Unknown" );
fail();
}
catch ( NoSuchArchiverException e )
{
}
}
public void testLookupUnknownUnArchiver()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
try
{
manager.getUnArchiver( "Unknown" );
fail();
}
catch ( NoSuchArchiverException e )
{
}
}
public void testLookupUnArchiverUsingFile()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
UnArchiver unarchiver = manager.getUnArchiver( new File( "test.tar.gz" ) );
assertNotNull( unarchiver );
unarchiver = manager.getUnArchiver( new File( "test.tar.bz2" ) );
assertNotNull( unarchiver );
unarchiver = manager.getUnArchiver( new File( "test.tgz" ) );
assertNotNull( unarchiver );
unarchiver = manager.getUnArchiver( new File( "test.tbz2" ) );
assertNotNull( unarchiver );
unarchiver = manager.getUnArchiver( new File( "test.bzip2" ) );
assertNotNull( unarchiver );
unarchiver = manager.getUnArchiver( new File( "test.tar" ) );
assertNotNull( unarchiver );
}
public void testLookupArchiverUsingFile()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
Archiver archiver = manager.getArchiver( new File( "test.gzip" ) );
assertNotNull( archiver );
archiver = manager.getArchiver( new File( "test.bzip2" ) );
assertNotNull( archiver );
archiver = manager.getArchiver( new File( "test.tar" ) );
assertNotNull( archiver );
}
public void testUnspportedLookupArchiverUsingFile()
throws Exception
{
ArchiverManager manager = (ArchiverManager) lookup( ArchiverManager.ROLE );
try
{
manager.getArchiver( new File( "test.tbz2" ) );
//until we support this type, this must fail
fail ( "Please remove this test." );
}
catch ( NoSuchArchiverException e )
{
}
try
{
manager.getArchiver( new File( "test.tgz" ) );
//until we support this type, this must fail
fail ( "Please remove this test." );
}
catch ( NoSuchArchiverException e )
{
}
try
{
manager.getArchiver( new File( "test.tar.gz" ) );
//until we support this type, this must fail
fail ( "Please remove this test." );
}
catch ( NoSuchArchiverException e )
{
}
try
{
manager.getArchiver( new File( "test.tar.bz2" ) );
//until we support this type, this must fail
fail ( "Please remove this test." );
}
catch ( NoSuchArchiverException e )
{
}
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/rar/ 0000775 0000000 0000000 00000000000 12026402656 0030600 5 ustar 00root root 0000000 0000000 RarArchiverTest.java 0000664 0000000 0000000 00000010351 12026402656 0034434 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/rar package org.codehaus.plexus.archiver.rar;
import java.io.File;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.BasePlexusArchiverTest;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.util.FileUtils;
/*
* Copyright 2007 The Codehaus 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.
*/
/**
* @author olamy
* @since 13 mars 07
* @version $Id$
*/
public class RarArchiverTest
extends BasePlexusArchiverTest
{
public File getTargetRarFolder()
{
return new File( getBasedir(), "/target/rartest/" );
}
protected void setUp()
throws Exception
{
super.setUp();
// clean output directory and re create it
if ( getTargetRarFolder().exists() )
{
FileUtils.deleteDirectory( getTargetRarFolder() );
}
}
public void testArchive()
throws Exception
{
Archiver archiver = (Archiver) lookup( Archiver.ROLE, "rar" );
archiver.setDestFile( new File( getTargetRarFolder(), "test.rar" ) );
//archiver.addDirectory( , "manifests" );
archiver.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), "manifests/manifest1.mf" );
archiver.createArchive();
assertTrue( new File( getTargetRarFolder(), "test.rar" ).exists() );
UnArchiver unArchiver = (UnArchiver) lookup( UnArchiver.ROLE, "rar" );
unArchiver.setSourceFile( new File( getTargetRarFolder(), "test.rar" ) );
unArchiver.setDestDirectory( getTargetRarFolder() );
unArchiver.extract();
File manifestsDir = new File( getTargetRarFolder(), "/manifests" );
assertTrue( manifestsDir.exists() );
File manifestsFile = new File( getTargetRarFolder(), "/manifests/manifest1.mf" );
assertTrue( manifestsFile.exists() );
}
public void atestUnarchive()
throws Exception
{
UnArchiver unArchiver = (UnArchiver) lookup( UnArchiver.ROLE, "rar" );
File rarFile = new File( getBasedir() + "/src/test/jars/test.rar" );
assertTrue( rarFile.exists() );
unArchiver.setSourceFile( rarFile );
unArchiver.setDestDirectory( getTargetRarFolder() );
getTargetRarFolder().mkdir();
unArchiver.extract();
File dirExtract = new File( getTargetRarFolder(), "META-INF" );
assertTrue( dirExtract.exists() );
assertTrue( dirExtract.isDirectory() );
}
/**
* Tests the .rar archiver is forced set to true, and after that
* tests the behavior when the forced is set to false.
*
* @throws Exception
*/
public void testRarIsForcedBehaviour() throws Exception
{
Archiver rarArvhiver = createArchiver( "rar" );
assertTrue( rarArvhiver.isSupportingForced() );
rarArvhiver.createArchive();
final long creationTime = rarArvhiver.getDestFile().lastModified();
rarArvhiver = createArchiver( "rar" );
assertTrue( rarArvhiver.isSupportingForced() );
//Default should be true
rarArvhiver.setForced( true );
waitUntilNewTimestamp( rarArvhiver.getDestFile(), creationTime );
rarArvhiver.createArchive();
final long firstRunTime = rarArvhiver.getDestFile().lastModified();
assertFalse( creationTime==firstRunTime );
//waitUntilNewTimestamp( rarArvhiver.getDestFile(), firstRunTime );
rarArvhiver = createArchiver( "rar" );
rarArvhiver.setForced( false );
rarArvhiver.createArchive();
final long secondRunTime = rarArvhiver.getDestFile().lastModified();
assertEquals( secondRunTime,firstRunTime );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar/ 0000775 0000000 0000000 00000000000 12026402656 0030602 5 ustar 00root root 0000000 0000000 TarArchiverTest.java 0000664 0000000 0000000 00000034713 12026402656 0034450 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.UnixStat;
import org.codehaus.plexus.archiver.bzip2.BZip2Compressor;
import org.codehaus.plexus.archiver.gzip.GZipCompressor;
import org.codehaus.plexus.archiver.util.ArchiveEntryUtils;
import org.codehaus.plexus.archiver.util.Compressor;
import org.codehaus.plexus.archiver.zip.ArchiveFileComparator;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributeUtils;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes;
import org.codehaus.plexus.components.io.resources.PlexusIoFileResource;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.logging.console.ConsoleLogger;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.Os;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author Emmanuel Venisse
* @version $Id$
*/
public class TarArchiverTest
extends PlexusTestCase
{
private Logger logger;
public void setUp()
throws Exception
{
super.setUp();
logger = new ConsoleLogger( Logger.LEVEL_DEBUG, "test" );
}
public void testCreateArchiveWithDetectedModes()
throws Exception
{
String[] executablePaths = { "path/to/executable", "path/to/executable.bat" };
String[] confPaths = { "path/to/etc/file", "path/to/etc/file2" };
String[] logPaths = { "path/to/logs/log.txt" };
int exeMode = 0777;
int confMode = 0600;
int logMode = 0640;
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
StackTraceElement e = new Throwable().getStackTrace()[0];
System.out.println( "Cannot execute test: " + e.getMethodName() + " on " + System.getProperty( "os.name" ) );
return;
}
File tmpDir = null;
try
{
tmpDir = File.createTempFile( "tbz2-with-chmod.", ".dir" );
tmpDir.delete();
tmpDir.mkdirs();
for ( int i = 0; i < executablePaths.length; i++ )
{
writeFile( tmpDir, executablePaths[i], exeMode );
}
for ( int i = 0; i < confPaths.length; i++ )
{
writeFile( tmpDir, confPaths[i], confMode );
}
for ( int i = 0; i < logPaths.length; i++ )
{
writeFile( tmpDir, logPaths[i], logMode );
}
{
Map attributesByPath = PlexusIoResourceAttributeUtils.getFileAttributesByPath( tmpDir );
for ( int i = 0; i < executablePaths.length; i++ )
{
String path = executablePaths[i];
PlexusIoResourceAttributes attrs = (PlexusIoResourceAttributes) attributesByPath.get( path );
if ( attrs == null )
{
attrs =
(PlexusIoResourceAttributes) attributesByPath.get( new File( tmpDir, path ).getAbsolutePath() );
}
assertNotNull( attrs );
assertEquals( "Wrong mode for: " + path + "; expected: " + exeMode, exeMode, attrs.getOctalMode() );
}
for ( int i = 0; i < confPaths.length; i++ )
{
String path = confPaths[i];
PlexusIoResourceAttributes attrs = (PlexusIoResourceAttributes) attributesByPath.get( path );
if ( attrs == null )
{
attrs =
(PlexusIoResourceAttributes) attributesByPath.get( new File( tmpDir, path ).getAbsolutePath() );
}
assertNotNull( attrs );
assertEquals( "Wrong mode for: " + path + "; expected: " + confMode, confMode, attrs.getOctalMode() );
}
for ( int i = 0; i < logPaths.length; i++ )
{
String path = logPaths[i];
PlexusIoResourceAttributes attrs = (PlexusIoResourceAttributes) attributesByPath.get( path );
if ( attrs == null )
{
attrs =
(PlexusIoResourceAttributes) attributesByPath.get( new File( tmpDir, path ).getAbsolutePath() );
}
assertNotNull( attrs );
assertEquals( "Wrong mode for: " + path + "; expected: " + logMode, logMode, attrs.getOctalMode() );
}
}
File tarFile = getTestFile( "target/output/tar-with-modes.tar" );
TarArchiver archiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
archiver.setDestFile( tarFile );
archiver.addDirectory( tmpDir );
archiver.createArchive();
assertTrue( tarFile.exists() );
File tarFile2 = getTestFile( "target/output/tar-with-modes-L2.tar" );
archiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
archiver.setDestFile( tarFile2 );
archiver.addArchivedFileSet( tarFile );
archiver.createArchive();
TarFile tf = new TarFile( tarFile2 );
Map entriesByPath = new LinkedHashMap();
for( Enumeration e = tf.getEntries(); e.hasMoreElements(); )
{
TarEntry te = (TarEntry) e.nextElement();
entriesByPath.put( te.getName(), te );
}
for ( int i = 0; i < executablePaths.length; i++ )
{
String path = executablePaths[i];
TarEntry te = (TarEntry) entriesByPath.get( path );
int mode = te.getMode() & UnixStat.PERM_MASK;
assertEquals( "Wrong mode for: " + path + "; expected: " + exeMode, exeMode, mode );
}
for ( int i = 0; i < confPaths.length; i++ )
{
String path = confPaths[i];
TarEntry te = (TarEntry) entriesByPath.get( path );
int mode = te.getMode() & UnixStat.PERM_MASK;
assertEquals( "Wrong mode for: " + path + "; expected: " + confMode, confMode, mode );
}
for ( int i = 0; i < logPaths.length; i++ )
{
String path = logPaths[i];
TarEntry te = (TarEntry) entriesByPath.get( path );
int mode = te.getMode() & UnixStat.PERM_MASK;
assertEquals( "Wrong mode for: " + path + "; expected: " + logMode, logMode, mode );
}
}
finally
{
if ( tmpDir != null && tmpDir.exists() )
{
try
{
FileUtils.forceDelete( tmpDir );
}
catch ( IOException e )
{
e.printStackTrace();
}
}
}
}
public void testUnicode() throws Exception {
File tmpDir = getTestFile( "src/test/resources/utf8" );
TarArchiver archiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
File tarFile = getTestFile( "target/output/tar-with-longFileName.tar" );
archiver.setDestFile(tarFile);
TarLongFileMode mode = new TarLongFileMode();
mode.setValue( TarLongFileMode.GNU);
archiver.setLongfile(mode);
archiver.addDirectory( tmpDir );
archiver.createArchive();
assertTrue( tarFile.exists() );
}
private void writeFile( File dir, String fname, int mode )
throws IOException, ArchiverException
{
File file = new File( dir, fname );
FileWriter writer = null;
try
{
if ( file.getParentFile() != null )
{
file.getParentFile().mkdirs();
}
writer = new FileWriter( file );
writer.write( "This is a test file." );
}
finally
{
IOUtil.close( writer );
}
ArchiveEntryUtils.chmod( file, mode, logger, false );
}
public void testCreateArchive()
throws Exception
{
TarArchiver archiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
archiver.setDirectoryMode( 0500 );
archiver.getOptions().setDirMode( 0500 );
archiver.setFileMode( 0400 );
archiver.getOptions().setMode( 0400 );
archiver.addDirectory( getTestFile( "src" ) );
archiver.setFileMode( 0640 );
archiver.getOptions().setMode( 0640 );
archiver.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), "one.txt" );
archiver.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), "two.txt", 0664 );
archiver.setDestFile( getTestFile( "target/output/archive.tar" ) );
archiver.createArchive();
TarInputStream tis;
tis = new TarInputStream( new BufferedInputStream( new FileInputStream( archiver.getDestFile() ) ) );
TarEntry te;
while ( ( te = tis.getNextEntry() ) != null )
{
if ( te.isDirectory() )
{
assertEquals( 0500, te.getMode() & UnixStat.PERM_MASK );
}
else
{
if ( te.getName().equals( "one.txt" ) )
{
assertEquals( 0640, te.getMode() & UnixStat.PERM_MASK );
}
else if ( te.getName().equals( "two.txt" ) )
{
assertEquals( 0664, te.getMode() & UnixStat.PERM_MASK );
}
else
{
assertEquals( 0400, te.getMode() & UnixStat.PERM_MASK );
}
}
}
}
private class TarHandler
{
File createTarFile()
throws Exception
{
final File srcDir = new File("src");
final File tarFile = new File( "target/output/src.tar" );
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
tarArchiver.setDestFile( tarFile );
tarArchiver.addDirectory( srcDir, null, FileUtils.getDefaultExcludes() );
FileUtils.removePath( tarFile.getPath() );
tarArchiver.createArchive();
return tarFile;
}
File createTarfile2( File tarFile )
throws Exception
{
final File tarFile2 = new File( "target/output/src2.tar" );
TarArchiver tarArchiver2 = (TarArchiver) lookup( Archiver.ROLE, "tar" );
tarArchiver2.setDestFile( tarFile2 );
tarArchiver2.addArchivedFileSet( tarFile, "prfx/" );
FileUtils.removePath( tarFile2.getPath() );
tarArchiver2.createArchive();
return tarFile2;
}
TarFile newTarFile( File tarFile )
{
return new TarFile( tarFile );
}
}
private class GZipTarHandler extends TarHandler
{
File createTarFile()
throws Exception
{
File file = super.createTarFile();
File compressedFile = new File( file.getPath() + ".gz" );
Compressor compressor = new GZipCompressor();
compressor.setSource( new PlexusIoFileResource( file ) );
compressor.setDestFile( compressedFile );
compressor.compress();
compressor.close();
return compressedFile;
}
TarFile newTarFile( File tarFile )
{
return new GZipTarFile( tarFile );
}
}
private class BZip2TarHandler extends TarHandler
{
File createTarFile()
throws Exception
{
File file = super.createTarFile();
File compressedFile = new File( file.getPath() + ".bz2" );
Compressor compressor = new BZip2Compressor();
compressor.setSource( new PlexusIoFileResource( file ) );
compressor.setDestFile( compressedFile );
compressor.compress();
compressor.close();
return compressedFile;
}
TarFile newTarFile( File tarFile )
{
return new BZip2TarFile( tarFile );
}
}
public void testUncompressedResourceCollection()
throws Exception
{
testCreateResourceCollection( new TarHandler() );
}
public void testGzipCompressedResourceCollection()
throws Exception
{
testCreateResourceCollection( new GZipTarHandler() );
}
public void testBzip2CompressedResourceCollection()
throws Exception
{
testCreateResourceCollection( new BZip2TarHandler() );
}
private void testCreateResourceCollection( TarHandler tarHandler )
throws Exception
{
final File tarFile = tarHandler.createTarFile();
final File tarFile2 = tarHandler.createTarfile2( tarFile );
final TarFile cmp1 = tarHandler.newTarFile( tarFile );
final TarFile cmp2 = new TarFile( tarFile2 );
ArchiveFileComparator.assertEquals( cmp1, cmp2, "prfx/" );
cmp1.close();
cmp2.close();
}
}
TarBZip2UnArchiverTest.java 0000664 0000000 0000000 00000006271 12026402656 0035620 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.bzip2.BZip2Archiver;
/**
* @author Dan Tran
* @version $Id$
*/
public class TarBZip2UnArchiverTest
extends PlexusTestCase
{
public void testExtract()
throws Exception
{
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
String fileName1 = "TarBZip2UnArchiverTest1.txt";
String fileName2 = "TarBZip2UnArchiverTest2.txt";
File file1InTar = getTestFile( "target/output/" + fileName1 );
File file2InTar = getTestFile( "target/output/" + fileName2 );
file1InTar.delete();
file2InTar.delete();
File testBZip2File = getTestFile( "target/output/archive.tar.bz2" );
tarArchiver.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), fileName1 );
tarArchiver.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), fileName2, 0664 );
tarArchiver.setDestFile( getTestFile( "target/output/archive.tar" ) );
tarArchiver.createArchive();
BZip2Archiver gzipArchiver = (BZip2Archiver) lookup( Archiver.ROLE, "bzip2" );
gzipArchiver.setDestFile( testBZip2File );
gzipArchiver.addFile( getTestFile( "target/output/archive.tar" ), "dontcare" );
gzipArchiver.createArchive();
TarBZip2UnArchiver tarBZip2UnArchiver = (TarBZip2UnArchiver) lookup( UnArchiver.ROLE, "tbz2" );
tarBZip2UnArchiver.setDestDirectory( getTestFile( "target/output" ) );
tarBZip2UnArchiver.setSourceFile( testBZip2File );
tarBZip2UnArchiver.extract();
assertTrue( file1InTar.exists() );
assertTrue( file2InTar.exists() );
//makesure we place the source file back
assertEquals( testBZip2File, tarBZip2UnArchiver.getSourceFile() );
}
public void testLookup()
throws Exception
{
lookup( UnArchiver.ROLE, "tar.bz2" );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar/TarEntryTest.java0000664 0000000 0000000 00000002046 12026402656 0034057 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.archiver.tar;
/*
* 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 junit.framework.TestCase;
/**
* @version $Revision$ $Date$
* from org.apache.ant.tools.tar.TarEntryTest v1.4
* @since Ant 1.6
*/
public class TarEntryTest
extends TestCase
{
/**
* demonstrates bug 18105 on OSes with os.name shorter than 7.
*/
public void testFileConstructor()
{
new TarEntry( new java.io.File( "/foo" ) );
}
}
TarFileAttributesTest.java 0000664 0000000 0000000 00000023474 12026402656 0035635 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.util.DefaultArchivedFileSet;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributeUtils;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.Os;
public class TarFileAttributesTest
extends PlexusTestCase
{
private final List toDelete = new ArrayList();
public void setUp()
throws Exception
{
super.setUp();
System.out.println( "Octal 0660 is decimal " + 0660 );
System.out.println( "Octal 0644 is decimal " + 0644 );
System.out.println( "Octal 0440 is decimal " + 0440 );
}
public void tearDown()
throws Exception
{
super.tearDown();
if ( !toDelete.isEmpty() )
{
for ( Iterator it = toDelete.iterator(); it.hasNext(); )
{
File f = (File) it.next();
System.out.println( "Deleting: " + f );
if ( f.isDirectory() )
{
try
{
FileUtils.deleteDirectory( f );
}
catch ( IOException e )
{
System.out.println( "Error deleting test directory: " + f );
}
}
else
{
f.delete();
f.deleteOnExit();
}
}
}
}
private void printTestHeader()
{
StackTraceElement e = new Throwable().getStackTrace()[1];
System.out.println( "\n\nRunning: " + e.getMethodName() + "\n\n" );
}
public void testUseAttributesFromTarArchiveInputInTarArchiverOutput()
throws Exception
{
printTestHeader();
if ( checkForWindows() )
{
System.out.println( "This test cannot run on windows. Aborting." );
return;
}
File tempFile = File.createTempFile( "tar-file-attributes.", ".tmp" );
toDelete.add( tempFile );
FileWriter writer = null;
try
{
writer = new FileWriter( tempFile );
writer.write( "This is a test file." );
}
finally
{
IOUtil.close( writer );
}
int result = Runtime.getRuntime().exec( "chmod 440 " + tempFile.getAbsolutePath() ).waitFor();
assertEquals( 0, result );
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
File tempTarFile = File.createTempFile( "tar-file.", ".tar" );
toDelete.add( tempTarFile );
tarArchiver.setDestFile( tempTarFile );
tarArchiver.addFile( tempFile, tempFile.getName(), 0660 );
tarArchiver.createArchive();
tarArchiver = null;
TarArchiver tarArchiver2 = (TarArchiver) lookup( Archiver.ROLE, "tar" );
File tempTarFile2 = File.createTempFile( "tar-file.", ".tar" );
toDelete.add( tempTarFile2 );
tarArchiver2.setDestFile( tempTarFile2 );
DefaultArchivedFileSet afs = new DefaultArchivedFileSet();
afs.setArchive( tempTarFile );
System.out.println( "Adding tar archive to new archiver: " + tempTarFile );
tarArchiver2.addArchivedFileSet( afs );
tarArchiver2.createArchive();
// Cut from here, and feed it into a new tar archiver...then unarchive THAT.
TarUnArchiver tarUnArchiver = (TarUnArchiver) lookup( UnArchiver.ROLE, "tar" );
File tempTarDir = File.createTempFile( "tar-test.", ".dir" );
tempTarDir.delete();
tempTarDir.mkdirs();
toDelete.add( tempTarDir );
tarUnArchiver.setDestDirectory( tempTarDir );
tarUnArchiver.setSourceFile( tempTarFile2 );
tarUnArchiver.extract();
PlexusIoResourceAttributes fileAttributes =
PlexusIoResourceAttributeUtils.getFileAttributes( new File( tempTarDir, tempFile.getName() ) );
assertEquals( 0660, fileAttributes.getOctalMode() );
}
public void testUseDetectedFileAttributes()
throws Exception
{
printTestHeader();
if ( checkForWindows() )
{
System.out.println( "This test cannot run on windows. Aborting." );
return;
}
File tempFile = File.createTempFile( "tar-file-attributes.", ".tmp" );
toDelete.add( tempFile );
FileWriter writer = null;
try
{
writer = new FileWriter( tempFile );
writer.write( "This is a test file." );
}
finally
{
IOUtil.close( writer );
}
int result = Runtime.getRuntime().exec( "chmod 440 " + tempFile.getAbsolutePath() ).waitFor();
assertEquals( 0, result );
PlexusIoResourceAttributes fileAttributes = PlexusIoResourceAttributeUtils.getFileAttributes( tempFile );
assertEquals( 0440, fileAttributes.getOctalMode() );
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
File tempTarFile = File.createTempFile( "tar-file.", ".tar" );
toDelete.add( tempTarFile );
tarArchiver.setDestFile( tempTarFile );
tarArchiver.addFile( tempFile, tempFile.getName() );
tarArchiver.createArchive();
TarUnArchiver tarUnArchiver = (TarUnArchiver) lookup( UnArchiver.ROLE, "tar" );
File tempTarDir = File.createTempFile( "tar-test.", ".dir" );
tempTarDir.delete();
tempTarDir.mkdirs();
toDelete.add( tempTarDir );
tarUnArchiver.setDestDirectory( tempTarDir );
tarUnArchiver.setSourceFile( tempTarFile );
tarUnArchiver.extract();
fileAttributes = PlexusIoResourceAttributeUtils.getFileAttributes( new File( tempTarDir, tempFile.getName() ) );
assertEquals( 0440, fileAttributes.getOctalMode() );
}
private boolean checkForWindows()
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
return true;
}
return false;
}
public void testOverrideDetectedFileAttributes()
throws Exception
{
printTestHeader();
if ( checkForWindows() )
{
System.out.println( "This test cannot run on windows. Aborting." );
return;
}
File tempFile = File.createTempFile( "tar-file-attributes.", ".tmp" );
toDelete.add( tempFile );
FileWriter writer = null;
try
{
writer = new FileWriter( tempFile );
writer.write( "This is a test file." );
}
finally
{
IOUtil.close( writer );
}
int result = Runtime.getRuntime().exec( "chmod 440 " + tempFile.getAbsolutePath() ).waitFor();
assertEquals( 0, result );
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
File tempTarFile = File.createTempFile( "tar-file.", ".tar" );
toDelete.add( tempTarFile );
tarArchiver.setDestFile( tempTarFile );
tarArchiver.addFile( tempFile, tempFile.getName(), 0660 );
tarArchiver.createArchive();
TarUnArchiver tarUnArchiver = (TarUnArchiver) lookup( UnArchiver.ROLE, "tar" );
File tempTarDir = File.createTempFile( "tar-test.", ".dir" );
tempTarDir.delete();
tempTarDir.mkdirs();
toDelete.add( tempTarDir );
tarUnArchiver.setDestDirectory( tempTarDir );
tarUnArchiver.setSourceFile( tempTarFile );
tarUnArchiver.extract();
PlexusIoResourceAttributes fileAttributes =
PlexusIoResourceAttributeUtils.getFileAttributes( new File( tempTarDir, tempFile.getName() ) );
assertEquals( 0660, fileAttributes.getOctalMode() );
}
public void testOverrideDetectedFileAttributesUsingFileMode()
throws Exception
{
printTestHeader();
if ( checkForWindows() )
{
System.out.println( "This test cannot run on windows. Aborting." );
return;
}
File tempFile = File.createTempFile( "tar-file-attributes.", ".tmp" );
toDelete.add( tempFile );
FileWriter writer = null;
try
{
writer = new FileWriter( tempFile );
writer.write( "This is a test file." );
}
finally
{
IOUtil.close( writer );
}
int result = Runtime.getRuntime().exec( "chmod 440 " + tempFile.getAbsolutePath() ).waitFor();
assertEquals( 0, result );
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
File tempTarFile = File.createTempFile( "tar-file.", ".tar" );
toDelete.add( tempTarFile );
tarArchiver.setDestFile( tempTarFile );
tarArchiver.setFileMode( 0660 );
tarArchiver.addFile( tempFile, tempFile.getName() );
tarArchiver.createArchive();
TarUnArchiver tarUnArchiver = (TarUnArchiver) lookup( UnArchiver.ROLE, "tar" );
File tempTarDir = File.createTempFile( "tar-test.", ".dir" );
tempTarDir.delete();
tempTarDir.mkdirs();
toDelete.add( tempTarDir );
tarUnArchiver.setDestDirectory( tempTarDir );
tarUnArchiver.setSourceFile( tempTarFile );
tarUnArchiver.extract();
PlexusIoResourceAttributes fileAttributes =
PlexusIoResourceAttributeUtils.getFileAttributes( new File( tempTarDir, tempFile.getName() ) );
assertEquals( 0660, fileAttributes.getOctalMode() );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar/TarFileTest.java 0000664 0000000 0000000 00000007132 12026402656 0033636 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.util.Arrays;
import java.util.Enumeration;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.bzip2.BZip2Compressor;
import org.codehaus.plexus.archiver.gzip.GZipCompressor;
import org.codehaus.plexus.archiver.util.Compressor;
import org.codehaus.plexus.components.io.resources.PlexusIoFileResource;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
/**
* Test case for {@link TarFile}.
*/
public class TarFileTest
extends PlexusTestCase
{
private interface TarFileCreator
{
TarFile newTarFile( File file ) throws IOException;
}
/**
* Test for the uncompressed tar file, {@link TarFile}.
*/
public void testTarFile() throws Exception
{
testTarFile( null, null, new TarFileCreator(){
public TarFile newTarFile( File file )
throws IOException
{
return new TarFile( file );
}
} );
}
/**
* Test for the gzip compressed tar file, {@link GZipTarFile}.
*/
public void testGZipTarFile() throws Exception
{
final GZipCompressor compressor = new GZipCompressor();
testTarFile( compressor, ".gz", new TarFileCreator(){
public TarFile newTarFile( File file )
throws IOException
{
return new GZipTarFile( file );
}
} );
}
/**
* Test for the bzip2 compressed tar file, {@link BZip2TarFile}.
*/
public void testBZip2TarFile() throws Exception
{
final BZip2Compressor compressor = new BZip2Compressor();
testTarFile( compressor, ".bz2", new TarFileCreator(){
public TarFile newTarFile( File file )
throws IOException
{
return new BZip2TarFile( file );
}
} );
}
private void testTarFile( Compressor compressor, String extension,
TarFileCreator tarFileCreator )
throws Exception
{
File file = new File( "target/output/TarFileTest.tar" );
final Archiver archiver = (Archiver) lookup( Archiver.ROLE, "tar" );
archiver.setDestFile( file );
archiver.addDirectory( new File( "src" ) );
FileUtils.removePath( file.getPath() );
archiver.createArchive();
if ( compressor != null )
{
final File compressedFile = new File( file.getPath() + extension );
compressor.setSource( new PlexusIoFileResource( file ) );
compressor.setDestFile( compressedFile );
compressor.compress();
compressor.close();
file = compressedFile;
}
final TarFile tarFile = tarFileCreator.newTarFile( file );
for ( Enumeration en = tarFile.getEntries(); en.hasMoreElements(); )
{
final TarEntry te = (TarEntry) en.nextElement();
if ( te.isDirectory() )
{
continue;
}
final File teFile = new File( "src", te.getName() );
final InputStream teStream = tarFile.getInputStream( te );
final InputStream fileStream = new FileInputStream( teFile );
assertTrue( Arrays.equals( IOUtil.toByteArray( teStream ), IOUtil.toByteArray( fileStream ) ) );
teStream.close();
fileStream.close();
}
tarFile.close();
}
}
TarGZipUnArchiverTest.java 0000664 0000000 0000000 00000006242 12026402656 0035541 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.gzip.GZipArchiver;
/**
* @author Dan Tran
* @version $Id$
*/
public class TarGZipUnArchiverTest
extends PlexusTestCase
{
public void testExtract()
throws Exception
{
TarArchiver tarArchiver = (TarArchiver) lookup( Archiver.ROLE, "tar" );
String fileName1 = "TarGZipUnArchiverTest1.txt";
String fileName2 = "TarGZipUnArchiverTest2.txt";
File file1InTar = getTestFile( "target/output/" + fileName1 );
File file2InTar = getTestFile( "target/output/" + fileName2 );
file1InTar.delete();
file2InTar.delete();
tarArchiver.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), fileName1 );
tarArchiver.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), fileName2, 0664 );
tarArchiver.setDestFile( getTestFile( "target/output/archive.tar" ) );
tarArchiver.createArchive();
GZipArchiver gzipArchiver = (GZipArchiver) lookup( Archiver.ROLE, "gzip" );
File testGZipFile = getTestFile( "target/output/archive.tar.gz" );
gzipArchiver.setDestFile( testGZipFile );
gzipArchiver.addFile( getTestFile( "target/output/archive.tar" ), "dontcare" );
gzipArchiver.createArchive();
TarGZipUnArchiver tarGZipUnArchiver = (TarGZipUnArchiver) lookup( UnArchiver.ROLE, "tgz" );
tarGZipUnArchiver.setDestDirectory( getTestFile( "target/output" ) );
tarGZipUnArchiver.setSourceFile( testGZipFile );
tarGZipUnArchiver.extract();
assertTrue( file1InTar.exists() );
assertTrue( file2InTar.exists() );
//make sure we place the source file back
assertEquals( testGZipFile, tarGZipUnArchiver.getSourceFile() );
}
public void testLookup()
throws Exception
{
lookup( UnArchiver.ROLE, "tar.gz" );
}
}
TarRoundTripTest.java 0000664 0000000 0000000 00000004026 12026402656 0034625 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/tar package org.codehaus.plexus.archiver.tar;
/*
* 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 junit.framework.TestCase;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
* @version $Id$
* from org.apache.ant.tools.tar.TarRoundTripTest v1.6
*/
public class TarRoundTripTest
extends TestCase
{
private static final String LONG_NAME
= "this/path/name/contains/more/than/one/hundred/characters/in/order/"
+ "to/test/the/GNU/long/file/name/capability/round/tripped";
/**
* test round-tripping long (GNU) entries
*/
public void testLongRoundTripping()
throws IOException
{
TarEntry original = new TarEntry( LONG_NAME );
assertEquals( "over 100 chars", true, LONG_NAME.length() > 100 );
assertEquals( "original name", LONG_NAME, original.getName() );
ByteArrayOutputStream buff = new ByteArrayOutputStream();
TarOutputStream tos = new TarOutputStream( buff );
tos.setLongFileMode( TarOutputStream.LONGFILE_GNU );
tos.putNextEntry( original );
tos.closeEntry();
tos.close();
TarInputStream tis = new TarInputStream( new ByteArrayInputStream( buff.toByteArray() ) );
TarEntry tripped = tis.getNextEntry();
assertEquals( "round-tripped name", LONG_NAME, tripped.getName() );
assertNull( "no more entries", tis.getNextEntry() );
tis.close();
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/util/ 0000775 0000000 0000000 00000000000 12026402656 0030771 5 ustar 00root root 0000000 0000000 EnumeratedAttributeTest.java 0000664 0000000 0000000 00000005673 12026402656 0036405 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/util package org.codehaus.plexus.archiver.util;
/*
* Copyright 2000-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 junit.framework.TestCase;
import org.codehaus.plexus.archiver.ArchiverException;
/**
* JUnit 3 testcases for org.apache.tools.ant.EnumeratedAttribute.
*/
public class EnumeratedAttributeTest
extends TestCase
{
private static String[] expected = {"a", "b", "c"};
public EnumeratedAttributeTest( String name )
{
super( name );
}
public void testContains()
{
EnumeratedAttribute t1 = new TestNormal();
for ( int i = 0; i < expected.length; i++ )
{
assertTrue( expected[ i ] + " is in TestNormal",
t1.containsValue( expected[ i ] ) );
assertTrue( expected[ i ].toUpperCase() + " is in TestNormal",
!t1.containsValue( expected[ i ].toUpperCase() ) );
}
assertTrue( "TestNormal doesn\'t have \"d\" attribute",
!t1.containsValue( "d" ) );
assertTrue( "TestNull doesn\'t have \"d\" attribute and doesn\'t die",
!( new TestNull() ).containsValue( "d" ) );
}
public void testExceptions()
{
EnumeratedAttribute t1 = new TestNormal();
for ( int i = 0; i < expected.length; i++ )
{
try
{
t1.setValue( expected[ i ] );
}
catch ( ArchiverException ae )
{
fail( "unexpected exception for value " + expected[ i ] );
}
}
try
{
t1.setValue( "d" );
fail( "expected exception for value \"d\"" );
}
catch ( ArchiverException ae )
{
}
try
{
( new TestNull() ).setValue( "d" );
fail( "expected exception for value \"d\" in TestNull" );
}
catch ( ArchiverException ae )
{
}
catch ( Throwable other )
{
fail( "unexpected death of TestNull: " + other.getMessage() );
}
}
public static class TestNormal
extends EnumeratedAttribute
{
public String[] getValues()
{
return expected;
}
}
public static class TestNull
extends EnumeratedAttribute
{
public String[] getValues()
{
return null;
}
}
}
FilePermissionUtilsTest.java 0000664 0000000 0000000 00000005357 12026402656 0036400 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/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.io.File;
import java.lang.reflect.Method;
import junit.framework.TestCase;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.logging.console.ConsoleLogger;
/**
* @author Olivier Lamy
*
*/
public class FilePermissionUtilsTest
extends TestCase
{
Logger getLogger()
{
return new ConsoleLogger( Logger.LEVEL_DEBUG, "foo" );
}
public void testOnlyWritableOnlyUser() throws Exception
{
FilePermission fp = FilePermissionUtils.getFilePermissionFromMode( "200", getLogger() );
assertTrue( fp.isWritable() );
assertTrue( fp.isOwnerOnlyWritable() );
assertFalse( fp.isExecutable() );
assertTrue( fp.isOwnerOnlyExecutable() );
assertFalse( fp.isReadable() );
}
public void testExecAndRead()
{
FilePermission fp = FilePermissionUtils.getFilePermissionFromMode( "500", getLogger() );
assertFalse( fp.isWritable() );
assertTrue( fp.isOwnerOnlyWritable() );
assertTrue( fp.isExecutable() );
assertTrue( fp.isOwnerOnlyExecutable() );
assertTrue( fp.isReadable() );
}
public void testAllUser()
{
FilePermission fp = FilePermissionUtils.getFilePermissionFromMode( "700", getLogger() );
assertTrue( fp.isWritable() );
assertTrue( fp.isOwnerOnlyWritable() );
assertTrue( fp.isExecutable() );
assertTrue( fp.isOwnerOnlyExecutable() );
assertTrue( fp.isReadable() );
}
public void testAllAllUser()
{
FilePermission fp = FilePermissionUtils.getFilePermissionFromMode( "707", getLogger() );
assertTrue( fp.isWritable() );
assertFalse( fp.isOwnerOnlyWritable() );
assertTrue( fp.isExecutable() );
assertFalse( fp.isOwnerOnlyExecutable() );
assertTrue( fp.isReadable() );
assertFalse( fp.isOwnerOnlyReadable() );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/war/ 0000775 0000000 0000000 00000000000 12026402656 0030605 5 ustar 00root root 0000000 0000000 WarArchiverTest.java 0000664 0000000 0000000 00000005544 12026402656 0034456 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/war package org.codehaus.plexus.archiver.war;
import java.io.File;
import java.io.IOException;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.ArchiveEntry;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.BasePlexusArchiverTest;
import org.codehaus.plexus.archiver.ResourceIterator;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import org.codehaus.plexus.archiver.jar.Manifest;
import org.codehaus.plexus.archiver.jar.ManifestException;
import org.codehaus.plexus.util.FileUtils;
import junit.framework.TestCase;
/**
* @author Kristian Rosenvold
*/
public class WarArchiverTest
extends PlexusTestCase
{
private int expected = 8;
public void testReAddingPlatformSpecificEncoding()
throws Exception
{
WarArchiver archiver = (WarArchiver) lookup( Archiver.ROLE, "war" );
archiver.setDestFile( new File( getTargetRarFolder(), "test.war" ) );
File dummyContent = getTestFile( "src/test/resources/folders" );
archiver.addDirectory( dummyContent );
assertEquals( expected, count( archiver.getResources() ) ); // I wonder what the first entry is
File file = getTestFile( "src/test/resources/folders/WEB-INF/web.xml" );
archiver.setWebxml( file);
assertEquals( expected, count( archiver.getResources() ) ); // I wonder what the first entry is
archiver.createArchive();
assertTrue( new File( getTargetRarFolder(), "test.war" ).exists() );
}
public void testInfiniteRecursion()
throws Exception
{
WarArchiver archiver = (WarArchiver) lookup( Archiver.ROLE, "war" );
archiver.setDestFile( new File( getTargetRarFolder(), "test.war" ) );
// Easy to produce infinite recursion if you just add existing files again and again
File dummyContent = getTestFile( "src/test/resources/folders", "File.txt" );
for (int i = 0; i < 100000; i++){
archiver.addFile( dummyContent, "testZ" );
}
assertEquals( 1, count( archiver.getResources() ) ); // I wonder what the first entry is
}
public File getTargetRarFolder()
{
return new File( getBasedir(), "/target/wartest/" );
}
protected void setUp()
throws Exception
{
super.setUp();
// clean output directory and re create it
if ( getTargetRarFolder().exists() )
{
FileUtils.deleteDirectory( getTargetRarFolder() );
}
}
private int count(ResourceIterator resourceIterator){
int i = 0;
while (resourceIterator.hasNext()){
i++;
ArchiveEntry next = resourceIterator.next();
System.out.print( next.getMode() );
System.out.println( next.getName() );
}
return i;
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip/ 0000775 0000000 0000000 00000000000 12026402656 0030616 5 ustar 00root root 0000000 0000000 ArchiveFileComparator.java 0000664 0000000 0000000 00000005336 12026402656 0035622 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.codehaus.plexus.archiver.ArchiveFile;
import org.codehaus.plexus.archiver.ArchiveFile.Entry;
import org.codehaus.plexus.util.IOUtil;
import junit.framework.Assert;
/**
* A utility class, which allows to compare archive files.
*/
public class ArchiveFileComparator
{
/**
* Creates a map with the archive files contents. The map keys
* are the names of file entries in the archive file. The map
* values are the respective archive entries.
*/
private static Map getFileEntries( ArchiveFile file )
throws IOException
{
final Map map = new HashMap();
for ( java.util.Enumeration en = file.getEntries(); en.hasMoreElements(); )
{
Entry ze = (Entry) en.nextElement();
if ( ze.isDirectory() )
{
continue;
}
if ( map.put( ze.getName(), ze ) != null )
{
Assert.fail( "Multiple archive file entries named " + ze.getName() + " found." );
}
}
return map;
}
/**
* Called to compare the given archive entries.
*/
private static void assertEquals( ArchiveFile file1, Entry entry1,
ArchiveFile file2, Entry entry2 )
throws Exception
{
Assert.assertEquals( entry1.isDirectory(), entry2.isDirectory() );
Assert.assertEquals( entry1.getLastModificationTime(), entry2.getLastModificationTime() );
final InputStream is1 = file1.getInputStream( entry1 );
final InputStream is2 = file2.getInputStream( entry2 );
final byte[] bytes1 = IOUtil.toByteArray( is1 );
final byte[] bytes2 = IOUtil.toByteArray( is2 );
Assert.assertTrue( Arrays.equals( bytes1, bytes2 ) );
is1.close();
is2.close();
}
/**
* Called to compare the given archive files.
*/
public static void assertEquals( ArchiveFile file1, ArchiveFile file2, String prefix )
throws Exception
{
final Map map1 = getFileEntries( file1 );
final Map map2 = getFileEntries( file2 );
for ( java.util.Iterator iter = map1.keySet().iterator(); iter.hasNext(); )
{
final String name1 = (String) iter.next();
final String name2 = prefix == null ? name1 : (prefix + name1);
Entry ze1 = (Entry) map1.get( name1 );
Entry ze2 = (Entry) map2.remove( name2 );
Assert.assertNotNull( ze2 );
assertEquals( file1, ze1, file2, ze2 );
}
Assert.assertTrue( map2.isEmpty() );
}
}
AsiExtraFieldTest.java 0000664 0000000 0000000 00000013503 12026402656 0034730 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/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 junit.framework.TestCase;
import org.codehaus.plexus.archiver.UnixStat;
/**
* JUnit 3 testcases for org.apache.tools.zip.AsiExtraField.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.AsiExtraFieldTest v1.8
*/
public class AsiExtraFieldTest
extends TestCase
implements UnixStat
{
public AsiExtraFieldTest( String name )
{
super( name );
}
/**
* Test file mode magic.
*/
public void testModes()
{
AsiExtraField a = new AsiExtraField();
a.setMode( 0123 );
assertEquals( "plain file", 0100123, a.getMode() );
a.setDirectory( true );
assertEquals( "directory", 040123, a.getMode() );
a.setLinkedFile( "test" );
assertEquals( "symbolic link", 0120123, a.getMode() );
}
/**
* Test content.
*/
public void testContent()
{
AsiExtraField a = new AsiExtraField();
a.setMode( 0123 );
a.setUserId( 5 );
a.setGroupId( 6 );
byte[] b = a.getLocalFileDataData();
// CRC manually calculated, sorry
byte[] expect = {(byte) 0xC6, 0x02, 0x78, (byte) 0xB6, // CRC
0123, (byte) 0x80, // mode
0, 0, 0, 0, // link length
5, 0, 6, 0}; // uid, gid
assertEquals( "no link", expect.length, b.length );
for ( int i = 0; i < expect.length; i++ )
{
assertEquals( "no link, byte " + i, expect[ i ], b[ i ] );
}
a.setLinkedFile( "test" );
expect = new byte[]{0x75, (byte) 0x8E, 0x41, (byte) 0xFD, // CRC
0123, (byte) 0xA0, // mode
4, 0, 0, 0, // link length
5, 0, 6, 0, // uid, gid
(byte) 't', (byte) 'e', (byte) 's', (byte) 't'};
b = a.getLocalFileDataData();
assertEquals( "no link", expect.length, b.length );
for ( int i = 0; i < expect.length; i++ )
{
assertEquals( "no link, byte " + i, expect[ i ], b[ i ] );
}
}
/**
* Test reparse
*/
public void testReparse()
throws Exception
{
// CRC manually calculated, sorry
byte[] data = {(byte) 0xC6, 0x02, 0x78, (byte) 0xB6, // CRC
0123, (byte) 0x80, // mode
0, 0, 0, 0, // link length
5, 0, 6, 0}; // uid, gid
AsiExtraField a = new AsiExtraField();
a.parseFromLocalFileData( data, 0, data.length );
assertEquals( "length plain file", data.length,
a.getLocalFileDataLength().getValue() );
assertTrue( "plain file, no link", !a.isLink() );
assertTrue( "plain file, no dir", !a.isDirectory() );
assertEquals( "mode plain file", FILE_FLAG | 0123, a.getMode() );
assertEquals( "uid plain file", 5, a.getUserId() );
assertEquals( "gid plain file", 6, a.getGroupId() );
data = new byte[]{0x75, (byte) 0x8E, 0x41, (byte) 0xFD, // CRC
0123, (byte) 0xA0, // mode
4, 0, 0, 0, // link length
5, 0, 6, 0, // uid, gid
(byte) 't', (byte) 'e', (byte) 's', (byte) 't'};
a = new AsiExtraField();
a.parseFromLocalFileData( data, 0, data.length );
assertEquals( "length link", data.length,
a.getLocalFileDataLength().getValue() );
assertTrue( "link, is link", a.isLink() );
assertTrue( "link, no dir", !a.isDirectory() );
assertEquals( "mode link", LINK_FLAG | 0123, a.getMode() );
assertEquals( "uid link", 5, a.getUserId() );
assertEquals( "gid link", 6, a.getGroupId() );
assertEquals( "test", a.getLinkedFile() );
data = new byte[]{(byte) 0x8E, 0x01, (byte) 0xBF, (byte) 0x0E, // CRC
0123, (byte) 0x40, // mode
0, 0, 0, 0, // link
5, 0, 6, 0}; // uid, gid
a = new AsiExtraField();
a.parseFromLocalFileData( data, 0, data.length );
assertEquals( "length dir", data.length,
a.getLocalFileDataLength().getValue() );
assertTrue( "dir, no link", !a.isLink() );
assertTrue( "dir, is dir", a.isDirectory() );
assertEquals( "mode dir", DIR_FLAG | 0123, a.getMode() );
assertEquals( "uid dir", 5, a.getUserId() );
assertEquals( "gid dir", 6, a.getGroupId() );
data = new byte[]{0, 0, 0, 0, // bad CRC
0123, (byte) 0x40, // mode
0, 0, 0, 0, // link
5, 0, 6, 0}; // uid, gid
a = new AsiExtraField();
try
{
a.parseFromLocalFileData( data, 0, data.length );
fail( "should raise bad CRC exception" );
}
catch ( Exception e )
{
assertEquals( "bad CRC checksum 0 instead of ebf018e",
e.getMessage() );
}
}
}
ExtraFieldUtilsTest.java 0000664 0000000 0000000 00000010722 12026402656 0035314 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/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 junit.framework.TestCase;
import org.codehaus.plexus.archiver.UnixStat;
/**
* JUnit 3 testcases for org.apache.tools.zip.ExtraFieldUtils.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.ExtraFieldUtilsTest v1.8
*/
public class ExtraFieldUtilsTest
extends TestCase
implements UnixStat
{
public ExtraFieldUtilsTest( String name )
{
super( name );
}
private AsiExtraField a;
private UnrecognizedExtraField dummy;
private byte[] data;
private byte[] aLocal;
public void setUp()
{
a = new AsiExtraField();
a.setMode( 0755 );
a.setDirectory( true );
dummy = new UnrecognizedExtraField();
dummy.setHeaderId( new ZipShort( 1 ) );
dummy.setLocalFileDataData( new byte[0] );
dummy.setCentralDirectoryData( new byte[]{0} );
aLocal = a.getLocalFileDataData();
byte[] dummyLocal = dummy.getLocalFileDataData();
data = new byte[4 + aLocal.length + 4 + dummyLocal.length];
System.arraycopy( a.getHeaderId().getBytes(), 0, data, 0, 2 );
System.arraycopy( a.getLocalFileDataLength().getBytes(), 0, data, 2, 2 );
System.arraycopy( aLocal, 0, data, 4, aLocal.length );
System.arraycopy( dummy.getHeaderId().getBytes(), 0, data,
4 + aLocal.length, 2 );
System.arraycopy( dummy.getLocalFileDataLength().getBytes(), 0, data,
4 + aLocal.length + 2, 2 );
System.arraycopy( dummyLocal, 0, data,
4 + aLocal.length + 4, dummyLocal.length );
}
/**
* test parser.
*/
public void testParse()
throws Exception
{
ZipExtraField[] ze = ExtraFieldUtils.parse( data );
assertEquals( "number of fields", 2, ze.length );
assertTrue( "type field 1", ze[ 0 ] instanceof AsiExtraField );
assertEquals( "mode field 1", 040755,
( (AsiExtraField) ze[ 0 ] ).getMode() );
assertTrue( "type field 2", ze[ 1 ] instanceof UnrecognizedExtraField );
assertEquals( "data length field 2", 0,
ze[ 1 ].getLocalFileDataLength().getValue() );
byte[] data2 = new byte[data.length - 1];
System.arraycopy( data, 0, data2, 0, data2.length );
try
{
ExtraFieldUtils.parse( data2 );
fail( "data should be invalid" );
}
catch ( Exception e )
{
assertEquals( "message",
"data starting at " + ( 4 + aLocal.length ) + " is in unknown format",
e.getMessage() );
}
}
/**
* Test merge methods
*/
public void testMerge()
{
byte[] local =
ExtraFieldUtils.mergeLocalFileDataData( new ZipExtraField[]{a, dummy} );
assertEquals( "local length", data.length, local.length );
for ( int i = 0; i < local.length; i++ )
{
assertEquals( "local byte " + i, data[ i ], local[ i ] );
}
byte[] dummyCentral = dummy.getCentralDirectoryData();
byte[] data2 = new byte[4 + aLocal.length + 4 + dummyCentral.length];
System.arraycopy( data, 0, data2, 0, 4 + aLocal.length + 2 );
System.arraycopy( dummy.getCentralDirectoryLength().getBytes(), 0,
data2, 4 + aLocal.length + 2, 2 );
System.arraycopy( dummyCentral, 0, data2,
4 + aLocal.length + 4, dummyCentral.length );
byte[] central =
ExtraFieldUtils.mergeCentralDirectoryData( new ZipExtraField[]{a, dummy} );
assertEquals( "central length", data2.length, central.length );
for ( int i = 0; i < central.length; i++ )
{
assertEquals( "central byte " + i, data2[ i ], central[ i ] );
}
}
}
ZipArchiverTest.java 0000664 0000000 0000000 00000032446 12026402656 0034501 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip;
/*
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.BasePlexusArchiverTest;
import org.codehaus.plexus.archiver.UnixStat;
import org.codehaus.plexus.archiver.util.ArchiveEntryUtils;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributeUtils;
import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.logging.console.ConsoleLogger;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.Os;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;
/**
* @author Emmanuel Venisse
* @version $Id$
*/
public class ZipArchiverTest
extends BasePlexusArchiverTest
{
private Logger logger;
public void setUp()
throws Exception
{
super.setUp();
logger = new ConsoleLogger( Logger.LEVEL_DEBUG, "test" );
}
public void testCreateArchiveWithDetectedModes()
throws Exception
{
String[] executablePaths = {
"path/to/executable",
"path/to/executable.bat"
};
String[] confPaths = {
"path/to/etc/file",
"path/to/etc/file2"
};
String[] logPaths = {
"path/to/logs/log.txt"
};
int exeMode = 0777;
int confMode = 0600;
int logMode = 0640;
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
StackTraceElement e = new Throwable().getStackTrace()[0];
System.out.println( "Cannot execute test: " + e.getMethodName() + " on " + System.getProperty( "os.name" ) );
return;
}
File tmpDir = null;
try
{
tmpDir = File.createTempFile( "zip-with-chmod.", ".dir" );
tmpDir.delete();
tmpDir.mkdirs();
for ( int i = 0; i < executablePaths.length; i++ )
{
writeFile( tmpDir, executablePaths[i], exeMode );
}
for ( int i = 0; i < confPaths.length; i++ )
{
writeFile( tmpDir, confPaths[i], confMode );
}
for ( int i = 0; i < logPaths.length; i++ )
{
writeFile( tmpDir, logPaths[i], logMode );
}
{
Map attributesByPath = PlexusIoResourceAttributeUtils.getFileAttributesByPath( tmpDir );
for ( int i = 0; i < executablePaths.length; i++ )
{
String path = executablePaths[i];
PlexusIoResourceAttributes attrs = (PlexusIoResourceAttributes) attributesByPath.get( path );
if ( attrs == null )
{
attrs = (PlexusIoResourceAttributes) attributesByPath.get( new File( tmpDir, path ).getAbsolutePath() );
}
assertNotNull( attrs );
assertEquals( "Wrong mode for: " + path + "; expected: " + exeMode, exeMode, attrs.getOctalMode() );
}
for ( int i = 0; i < confPaths.length; i++ )
{
String path = confPaths[i];
PlexusIoResourceAttributes attrs = (PlexusIoResourceAttributes) attributesByPath.get( path );
if ( attrs == null )
{
attrs = (PlexusIoResourceAttributes) attributesByPath.get( new File( tmpDir, path ).getAbsolutePath() );
}
assertNotNull( attrs );
assertEquals( "Wrong mode for: " + path + "; expected: " + confMode, confMode, attrs.getOctalMode() );
}
for ( int i = 0; i < logPaths.length; i++ )
{
String path = logPaths[i];
PlexusIoResourceAttributes attrs = (PlexusIoResourceAttributes) attributesByPath.get( path );
if ( attrs == null )
{
attrs = (PlexusIoResourceAttributes) attributesByPath.get( new File( tmpDir, path ).getAbsolutePath() );
}
assertNotNull( attrs );
assertEquals( "Wrong mode for: " + path + "; expected: " + logMode, logMode, attrs.getOctalMode() );
}
}
File zipFile = getTestFile( "target/output/zip-with-modes.zip" );
ZipArchiver archiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
archiver.setDestFile( zipFile );
archiver.addDirectory( tmpDir );
archiver.createArchive();
assertTrue( zipFile.exists() );
File zipFile2 = getTestFile( "target/output/zip-with-modes-L2.zip" );
archiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
archiver.setDestFile( zipFile2 );
archiver.addArchivedFileSet( zipFile );
archiver.createArchive();
ZipFile zf = new ZipFile( zipFile2 );
for ( int i = 0; i < executablePaths.length; i++ )
{
String path = executablePaths[i];
ZipEntry ze = zf.getEntry( path );
int mode = ze.getUnixMode() & UnixStat.PERM_MASK;
assertEquals( "Wrong mode for: " + path + "; expected: " + exeMode, exeMode, mode );
}
for ( int i = 0; i < confPaths.length; i++ )
{
String path = confPaths[i];
ZipEntry ze = zf.getEntry( path );
int mode = ze.getUnixMode() & UnixStat.PERM_MASK;
assertEquals( "Wrong mode for: " + path + "; expected: " + confMode, confMode, mode );
}
for ( int i = 0; i < logPaths.length; i++ )
{
String path = logPaths[i];
ZipEntry ze = zf.getEntry( path );
int mode = ze.getUnixMode() & UnixStat.PERM_MASK;
assertEquals( "Wrong mode for: " + path + "; expected: " + logMode, logMode, mode );
}
}
finally
{
if ( tmpDir != null && tmpDir.exists() )
{
try
{
FileUtils.forceDelete( tmpDir );
}
catch ( IOException e )
{
e.printStackTrace();
}
}
}
}
private void writeFile( File dir, String fname, int mode )
throws IOException, ArchiverException
{
File file = new File( dir, fname );
FileWriter writer = null;
try
{
if ( file.getParentFile() != null )
{
file.getParentFile().mkdirs();
}
writer = new FileWriter( file );
writer.write( "This is a test file." );
}
finally
{
IOUtil.close( writer );
}
ArchiveEntryUtils.chmod( file, mode, logger, false );
}
public void testCreateArchive()
throws Exception
{
ZipArchiver archiver = newArchiver( "archive1.zip" );
createArchive(archiver);
}
private ZipArchiver newArchiver( String name ) throws Exception {
ZipArchiver archiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
archiver.setFileMode( 0640 );
archiver.addFile( getTestFile( "src/test/resources/manifests/manifest1.mf" ), "one.txt" );
archiver.addFile( getTestFile( "src/test/resources/manifests/manifest2.mf" ), "two.txt", 0664 );
// reset default file mode for files included from now on
archiver.setFileMode( 0400 );
archiver.setDirectoryMode( 0777 );
archiver.addDirectory( getTestFile( "src/test/resources/world-writable/" ), "worldwritable/" );
archiver.setDirectoryMode( 0070 );
archiver.addDirectory( getTestFile( "src/test/resources/group-writable/" ), "groupwritable/" );
archiver.setDirectoryMode( 0500 );
archiver.setFileMode( 0400 );
archiver.addDirectory( getTestFile( "src" ) );
archiver.setDestFile( getTestFile( "target/output/" + name ) );
return archiver;
}
private void createArchive( ZipArchiver archiver )
throws ArchiverException, IOException
{
archiver.createArchive();
ZipFile zf = new ZipFile( archiver.getDestFile() );
Enumeration e = zf.getEntries();
while ( e.hasMoreElements() )
{
ZipEntry ze = (ZipEntry) e.nextElement();
if ( ze.isDirectory() )
{
if ( ze.getName().startsWith( "worldwritable" ) )
{
assertEquals( 0777, UnixStat.PERM_MASK & ze.getUnixMode() );
}
else if ( ze.getName().startsWith( "groupwritable" ) )
{
assertEquals( 0070, UnixStat.PERM_MASK & ze.getUnixMode() );
}
else
{
assertEquals( 0500, UnixStat.PERM_MASK & ze.getUnixMode() );
}
}
else
{
if ( ze.getName().equals( "one.txt" ) )
{
assertEquals( 0640, UnixStat.PERM_MASK & ze.getUnixMode() );
}
else if ( ze.getName().equals( "two.txt" ) )
{
assertEquals( 0664, UnixStat.PERM_MASK & ze.getUnixMode() );
}
else
{
assertEquals( 0400, UnixStat.PERM_MASK & ze.getUnixMode() );
}
}
}
}
public void testForced()
throws Exception
{
ZipArchiver archiver = newArchiver( "archive2.zip" );
assertTrue( archiver.isForced() );
File f = archiver.getDestFile();
if ( f.exists() )
{
FileUtils.fileDelete( f.getPath() );
}
assertFalse( f.exists() );
createArchive( archiver );
long l1 = f.lastModified();
assertTrue( f.exists() );
archiver = newArchiver( "archive2.zip" );
waitUntilNewTimestamp( archiver.getDestFile(), l1 );
createArchive( archiver );
long l2 = f.lastModified();
assertTrue( f.exists() );
assertTrue( l2 > l1 );
archiver = newArchiver( "archive2.zip" );
assertTrue( archiver.isSupportingForced() );
archiver.setForced( false );
assertFalse( archiver.isForced() );
createArchive( archiver );
long l3 = f.lastModified();
assertTrue( f.exists() );
assertEquals(l2, l3);
}
public void testCreateResourceCollection()
throws Exception
{
final File srcDir = new File("src");
final File zipFile = new File( "target/output/src.zip" );
ZipArchiver zipArchiver = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
zipArchiver.setDestFile( zipFile );
zipArchiver.addDirectory( srcDir, null, FileUtils.getDefaultExcludes() );
FileUtils.removePath( zipFile.getPath() );
zipArchiver.createArchive();
final File zipFile2 = new File( "target/output/src2.zip" );
ZipArchiver zipArchiver2 = (ZipArchiver) lookup( Archiver.ROLE, "zip" );
zipArchiver2.setDestFile( zipFile2 );
zipArchiver2.addArchivedFileSet( zipFile, "prfx/" );
FileUtils.removePath( zipFile2.getPath() );
zipArchiver2.createArchive();
final ZipFile cmp1 = new ZipFile( zipFile );
final ZipFile cmp2 = new ZipFile( zipFile2 );
ArchiveFileComparator.assertEquals( cmp1, cmp2, "prfx/" );
cmp1.close();
cmp2.close();
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip/ZipEntryTest.java0000664 0000000 0000000 00000010170 12026402656 0034104 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.
*
*/
import junit.framework.TestCase;
/**
* JUnit 3 testcases for org.apache.tools.zip.ZipEntry.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.ZipEntryTest v1.9
*/
public class ZipEntryTest
extends TestCase
{
public ZipEntryTest( String name )
{
super( name );
}
/**
* test handling of extra fields
*
* @since 1.1
*/
public void testExtraFields()
{
AsiExtraField a = new AsiExtraField();
a.setDirectory( true );
a.setMode( 0755 );
UnrecognizedExtraField u = new UnrecognizedExtraField();
u.setHeaderId( new ZipShort( 1 ) );
u.setLocalFileDataData( new byte[0] );
ZipEntry ze = new ZipEntry( "test/" );
ze.setExtraFields( new ZipExtraField[]{a, u} );
byte[] data1 = ze.getExtra();
ZipExtraField[] result = ze.getExtraFields();
assertEquals( "first pass", 2, result.length );
assertSame( a, result[ 0 ] );
assertSame( u, result[ 1 ] );
UnrecognizedExtraField u2 = new UnrecognizedExtraField();
u2.setHeaderId( new ZipShort( 1 ) );
u2.setLocalFileDataData( new byte[]{1} );
ze.addExtraField( u2 );
byte[] data2 = ze.getExtra();
result = ze.getExtraFields();
assertEquals( "second pass", 2, result.length );
assertSame( a, result[ 0 ] );
assertSame( u2, result[ 1 ] );
assertEquals( "length second pass", data1.length + 1, data2.length );
UnrecognizedExtraField u3 = new UnrecognizedExtraField();
u3.setHeaderId( new ZipShort( 2 ) );
u3.setLocalFileDataData( new byte[]{1} );
ze.addExtraField( u3 );
result = ze.getExtraFields();
assertEquals( "third pass", 3, result.length );
ze.removeExtraField( new ZipShort( 1 ) );
byte[] data3 = ze.getExtra();
result = ze.getExtraFields();
assertEquals( "fourth pass", 2, result.length );
assertSame( a, result[ 0 ] );
assertSame( u3, result[ 1 ] );
assertEquals( "length fourth pass", data2.length, data3.length );
try
{
ze.removeExtraField( new ZipShort( 1 ) );
fail( "should be no such element" );
}
catch ( java.util.NoSuchElementException nse )
{
}
}
public void testUnixMode()
{
ZipEntry ze = new ZipEntry( "foo" );
assertEquals( 0, ze.getPlatform() );
ze.setUnixMode( 0755 );
assertEquals( 3, ze.getPlatform() );
assertEquals( 0755,
( ze.getExternalAttributes() >> 16 ) & 0xFFFF );
assertEquals( 0, ze.getExternalAttributes() & 0xFFFF );
ze.setUnixMode( 0444 );
assertEquals( 3, ze.getPlatform() );
assertEquals( 0444,
( ze.getExternalAttributes() >> 16 ) & 0xFFFF );
assertEquals( 1, ze.getExternalAttributes() & 0xFFFF );
ze = new ZipEntry( "foo/" );
assertEquals( 0, ze.getPlatform() );
ze.setUnixMode( 0777 );
assertEquals( 3, ze.getPlatform() );
assertEquals( 0777,
( ze.getExternalAttributes() >> 16 ) & 0xFFFF );
assertEquals( 0x10, ze.getExternalAttributes() & 0xFFFF );
ze.setUnixMode( 0577 );
assertEquals( 3, ze.getPlatform() );
assertEquals( 0577,
( ze.getExternalAttributes() >> 16 ) & 0xFFFF );
assertEquals( 0x11, ze.getExternalAttributes() & 0xFFFF );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip/ZipLongTest.java 0000664 0000000 0000000 00000005052 12026402656 0033705 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 junit.framework.TestCase;
/**
* JUnit 3 testcases for org.apache.tools.zip.ZipLong.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.ZipLongTest v1.8
*/
public class ZipLongTest
extends TestCase
{
public ZipLongTest( String name )
{
super( name );
}
/**
* Test conversion to bytes.
*/
public void testToBytes()
{
ZipLong zl = new ZipLong( 0x12345678 );
byte[] result = zl.getBytes();
assertEquals( "length getBytes", 4, result.length );
assertEquals( "first byte getBytes", 0x78, result[ 0 ] );
assertEquals( "second byte getBytes", 0x56, result[ 1 ] );
assertEquals( "third byte getBytes", 0x34, result[ 2 ] );
assertEquals( "fourth byte getBytes", 0x12, result[ 3 ] );
}
/**
* Test conversion from bytes.
*/
public void testFromBytes()
{
byte[] val = new byte[]{0x78, 0x56, 0x34, 0x12};
ZipLong zl = new ZipLong( val );
assertEquals( "value from bytes", 0x12345678, zl.getValue() );
}
/**
* Test the contract of the equals method.
*/
public void testEquals()
{
ZipLong zl = new ZipLong( 0x12345678 );
ZipLong zl2 = new ZipLong( 0x12345678 );
ZipLong zl3 = new ZipLong( 0x87654321 );
assertTrue( "reflexive", zl.equals( zl ) );
assertTrue( "works", zl.equals( zl2 ) );
assertTrue( "works, part two", !zl.equals( zl3 ) );
assertTrue( "symmetric", zl2.equals( zl ) );
assertNotNull( "null handling", zl );
assertTrue( "non ZipLong handling", !zl.equals( new Integer( 0x1234 ) ) );
}
/**
* Test sign handling.
*/
public void testSign()
{
ZipLong zl = new ZipLong( new byte[]{(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF} );
assertEquals( 0x00000000FFFFFFFFl, zl.getValue() );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip/ZipShortTest.java0000664 0000000 0000000 00000004563 12026402656 0034113 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 junit.framework.TestCase;
/**
* JUnit 3 testcases for org.apache.tools.zip.ZipShort.
*
* @version $Revision$ $Date$
* from org.apache.ant.tools.zip.ZipShortTest v1.8
*/
public class ZipShortTest
extends TestCase
{
public ZipShortTest( String name )
{
super( name );
}
/**
* Test conversion to bytes.
*/
public void testToBytes()
{
ZipShort zs = new ZipShort( 0x1234 );
byte[] result = zs.getBytes();
assertEquals( "length getBytes", 2, result.length );
assertEquals( "first byte getBytes", 0x34, result[ 0 ] );
assertEquals( "second byte getBytes", 0x12, result[ 1 ] );
}
/**
* Test conversion from bytes.
*/
public void testFromBytes()
{
byte[] val = new byte[]{0x34, 0x12};
ZipShort zs = new ZipShort( val );
assertEquals( "value from bytes", 0x1234, zs.getValue() );
}
/**
* Test the contract of the equals method.
*/
public void testEquals()
{
ZipShort zs = new ZipShort( 0x1234 );
ZipShort zs2 = new ZipShort( 0x1234 );
ZipShort zs3 = new ZipShort( 0x5678 );
assertTrue( "reflexive", zs.equals( zs ) );
assertTrue( "works", zs.equals( zs2 ) );
assertTrue( "works, part two", !zs.equals( zs3 ) );
assertTrue( "symmetric", zs2.equals( zs ) );
assertNotNull( "null handling", zs );
assertTrue( "non ZipShort handling", !zs.equals( new Integer( 0x1234 ) ) );
}
/**
* Test sign handling.
*/
public void testSign()
{
ZipShort zs = new ZipShort( new byte[]{(byte) 0xFF, (byte) 0xFF} );
assertEquals( 0x0000FFFF, zs.getValue() );
}
}
ZipUnArchiverTest.java 0000664 0000000 0000000 00000010402 12026402656 0034770 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/java/org/codehaus/plexus/archiver/zip package org.codehaus.plexus.archiver.zip;
import java.io.File;
import java.lang.reflect.Method;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.components.io.fileselectors.FileSelector;
import org.codehaus.plexus.components.io.fileselectors.IncludeExcludeFileSelector;
import org.codehaus.plexus.util.FileUtils;
/**
* @author Jason van Zyl
*/
public class ZipUnArchiverTest
extends PlexusTestCase
{
public void testExtractingZipPreservesExecutableFlag()
throws Exception
{
String s = "target/zip-unarchiver-tests";
File testZip = new File( getBasedir(), "src/test/jars/test.zip" );
File outputDirectory = new File( getBasedir(), s );
FileUtils.deleteDirectory( outputDirectory );
ZipUnArchiver zu = (ZipUnArchiver) lookup( UnArchiver.ROLE, "zip" );
zu.setSourceFile( testZip );
zu.extract( "", outputDirectory );
File testScript = new File( outputDirectory, "test.sh" );
final Method canExecute;
try
{
canExecute = File.class.getMethod( "canExecute" );
canExecute.invoke( testScript );
assertTrue( (Boolean) canExecute.invoke( testScript ) );
}
catch ( NoSuchMethodException ignore )
{
}
}
public void testZeroFileModeInZip()
throws Exception
{
String s = "target/zip-unarchiver-filemode-tests";
File testZip = new File( getBasedir(), "src/test/resources/zeroFileMode/foobar.zip" );
File outputDirectory = new File( getBasedir(), s );
FileUtils.deleteDirectory( outputDirectory );
ZipUnArchiver zu = (ZipUnArchiver) lookup( UnArchiver.ROLE, "zip" );
zu.setSourceFile( testZip );
zu.setIgnorePermissions( false );
zu.extract( "", outputDirectory );
File testScript = new File( outputDirectory, "foo.txt" );
final Method canRead;
try
{
canRead = File.class.getMethod( "canRead" );
canRead.invoke( testScript );
assertTrue( (Boolean) canRead.invoke( testScript ) );
}
catch ( NoSuchMethodException ignore )
{
}
}
private void runUnarchiver( String path, FileSelector[] selectors, boolean[] results )
throws Exception
{
String s = "target/zip-unarchiver-tests";
File testJar = new File( getBasedir(), "src/test/jars/test.jar" );
File outputDirectory = new File( getBasedir(), s );
ZipUnArchiver zu = (ZipUnArchiver) lookup( UnArchiver.ROLE, "zip" );
zu.setSourceFile( testJar );
zu.setFileSelectors( selectors );
FileUtils.deleteDirectory( outputDirectory );
zu.extract( path, outputDirectory );
File f0 = new File( getBasedir(), s + "/resources/artifactId/test.properties" );
assertEquals( results[0], f0.exists() );
File f1 = new File( getBasedir(), s + "/resources/artifactId/directory/test.properties" );
assertEquals( results[1], f1.exists() );
File f2 = new File( getBasedir(), s + "/META-INF/MANIFEST.MF" );
assertEquals( results[2], f2.exists() );
}
public void testExtractingADirectoryFromAJarFile()
throws Exception
{
runUnarchiver( "resources/artifactId", null, new boolean[]{ true, true, false } );
runUnarchiver( "", null, new boolean[]{ true, true, true } );
}
public void testSelectors()
throws Exception
{
IncludeExcludeFileSelector fileSelector = new IncludeExcludeFileSelector();
runUnarchiver( "", new FileSelector[]{ fileSelector }, new boolean[]{ true, true, true } );
fileSelector.setExcludes( new String[]{ "**/test.properties" } );
runUnarchiver( "", new FileSelector[]{ fileSelector }, new boolean[]{ false, false, true } );
fileSelector.setIncludes( new String[]{ "**/test.properties" } );
fileSelector.setExcludes( null );
runUnarchiver( "", new FileSelector[]{ fileSelector }, new boolean[]{ true, true, false } );
fileSelector.setExcludes( new String[]{ "resources/artifactId/directory/test.properties" } );
runUnarchiver( "", new FileSelector[]{ fileSelector }, new boolean[]{ true, false, false } );
}
}
plexus-archiver-plexus-archiver-2.2/src/test/resources/ 0000775 0000000 0000000 00000000000 12026402656 0023400 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/ 0000775 0000000 0000000 00000000000 12026402656 0025036 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/File.txt 0000664 0000000 0000000 00000000016 12026402656 0026453 0 ustar 00root root 0000000 0000000 A file in root plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/WEB-INF/ 0000775 0000000 0000000 00000000000 12026402656 0026065 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/WEB-INF/web.xml 0000664 0000000 0000000 00000000013 12026402656 0027356 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/a/ 0000775 0000000 0000000 00000000000 12026402656 0025256 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/a/FileInA.txt 0000664 0000000 0000000 00000000013 12026402656 0027260 0 ustar 00root root 0000000 0000000 A file in A plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/b/ 0000775 0000000 0000000 00000000000 12026402656 0025257 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/folders/b/FileInB.txt 0000664 0000000 0000000 00000000013 12026402656 0027262 0 ustar 00root root 0000000 0000000 A file in B plexus-archiver-plexus-archiver-2.2/src/test/resources/group-writable/ 0000775 0000000 0000000 00000000000 12026402656 0026343 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/group-writable/bar.txt 0000664 0000000 0000000 00000000000 12026402656 0027636 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/group-writable/foo.txt 0000664 0000000 0000000 00000000000 12026402656 0027655 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/jar-security/ 0000775 0000000 0000000 00000000000 12026402656 0026021 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/jar-security/dummy.txt 0000664 0000000 0000000 00000000111 12026402656 0027706 0 ustar 00root root 0000000 0000000 This file is used as fake content for the security file filtering tests.
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/ 0000775 0000000 0000000 00000000000 12026402656 0025371 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifest1.mf 0000664 0000000 0000000 00000000027 12026402656 0027603 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifest2.mf 0000664 0000000 0000000 00000000073 12026402656 0027605 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Header-without-colon maybe mistyped
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifest3.mf 0000664 0000000 0000000 00000000076 12026402656 0027611 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Can't start with a continuation line
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifest4.mf 0000664 0000000 0000000 00000000044 12026402656 0027605 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Name: test5
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifest5.mf 0000664 0000000 0000000 00000000067 12026402656 0027613 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Test: test6
Class-Path: fubar
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifest6.mf 0000664 0000000 0000000 00000000065 12026402656 0027612 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Class-Path: fubar
From: Jack
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifestMerge1.mf 0000664 0000000 0000000 00000000124 12026402656 0030561 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
From: Jack
Bar: 001
Name: Fudz
Bar: 002
Name: Redz
Baz: 002
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifestMerge2.mf 0000664 0000000 0000000 00000000077 12026402656 0030571 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
From: Jack
Bar: 001
Name: Fudz
Bar: 003
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifestWithClassPath.mf 0000664 0000000 0000000 00000000730 12026402656 0032162 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Class-Path: ../config/
classes12.jar
bc4jct.jar
bc4jdomorcl.jar
bc4jmt.jar
commons-beanutils-bean-collections.jar
commons-beanutils-core.jar
commons-beanutils.jar
commons-codec-1.3.jar
commons-collections-3.1.jar
commons-configuration-1.2.jar
commons-digester.jar
commons-lang-2.0.jar
commons-logging.jar
htbclnt.jar
areallylongjarfilethatisnotentirelyrealbutstillaverylongname.jar
j2ee/home/oc4jclient.jar
From: Jack
plexus-archiver-plexus-archiver-2.2/src/test/resources/manifests/manifestWithDualClassPath.mf 0000664 0000000 0000000 00000000141 12026402656 0032764 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Class-Path: ../config/
classes12.jar
From: Jack
Ape: Fud
Class-Path: baz
plexus-archiver-plexus-archiver-2.2/src/test/resources/utf8/ 0000775 0000000 0000000 00000000000 12026402656 0024266 5 ustar 00root root 0000000 0000000 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391.paxheader 0000666 0000000 0000000 00000000310 12026402656 0020607 x ustar 00root root 0000000 0000000 200 path=plexus-archiver-plexus-archiver-2.2/src/test/resources/utf8/D12345679012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890æøå.txt
e69de29bb2d1d6434b8b29ae775ad8c2e48c5391.data 0000664 0000000 0000000 00000000000 12026402656 0017441 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/world-writable/ 0000775 0000000 0000000 00000000000 12026402656 0026336 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/world-writable/foo.txt 0000664 0000000 0000000 00000000000 12026402656 0027650 0 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/zeroFileMode/ 0000775 0000000 0000000 00000000000 12026402656 0025764 5 ustar 00root root 0000000 0000000 plexus-archiver-plexus-archiver-2.2/src/test/resources/zeroFileMode/foobar.zip 0000775 0000000 0000000 00000000705 12026402656 0027765 0 ustar 00root root 0000000 0000000 PK
+6!es foo.txtfooPK
66 ( Documents and Settings/olamy/Bureau/bar/PK
46 bar/bar.txtPK
66 bar/PK
+6!es foo.txtPK
66 ( ( Documents and Settings/olamy/Bureau/bar/PK
46 n bar/bar.txtPK
66 bar/PK