/**
* 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, closeArchiveEntry()
* <B>MUST</B> be called to ensure that all buffered data
* is completely written to the output stream.
*
* @param archiveEntry The TarEntry to be written to the archive.
* @throws IOException on error
* @throws ClassCastException if archiveEntry is not an instance of TarArchiveEntry
*/
public override void putArchiveEntry(ArchiveEntry archiveEntry) //throws IOException
{
if (finished)
{
throw new java.io.IOException("Stream has already been finished");
}
TarArchiveEntry entry = (TarArchiveEntry)archiveEntry;
if (entry.getName().length() >= TarConstants.NAMELEN)
{
if (longFileMode == LONGFILE_GNU)
{
// create a TarEntry for the LongLink, the contents
// of which are the entry's name
TarArchiveEntry longLinkEntry = new TarArchiveEntry(TarConstants.GNU_LONGLINK,
TarConstants.LF_GNUTYPE_LONGNAME);
byte[] nameBytes = ArchiveUtils.toAsciiBytes(entry.getName());
longLinkEntry.setSize(nameBytes.Length + 1); // +1 for NUL
putArchiveEntry(longLinkEntry);
write(nameBytes);
write(0); // NUL terminator
closeArchiveEntry();
}
else if (longFileMode != LONGFILE_TRUNCATE)
{
throw new java.lang.RuntimeException("file name '" + entry.getName()
+ "' is too long ( > "
+ TarConstants.NAMELEN + " bytes)");
}
}
entry.writeEntryHeader(recordBuf);
buffer.writeRecord(recordBuf);
currBytes = 0;
if (entry.isDirectory())
{
currSize = 0;
}
else
{
currSize = entry.getSize();
}
currName = entry.getName();
haveUnclosedEntry = true;
}
/**
* 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 TarArchiveEntry[] getDirectoryEntries()
{
if (file == null || !file.isDirectory())
{
return(new TarArchiveEntry[0]);
}
String[] list = file.list();
TarArchiveEntry[] result = new TarArchiveEntry[list.Length];
for (int i = 0; i < list.Length; ++i)
{
result[i] = new TarArchiveEntry(new java.io.File(file, list[i]));
}
return(result);
}
protected void setCurrentEntry(TarArchiveEntry e)
{
currEntry = e;
}
/**
* 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.
* @throws IOException on error
*/
public TarArchiveEntry getNextTarEntry() //throws IOException
{
if (hasHitEOF)
{
return(null);
}
if (currEntry != null)
{
long numToSkip = entrySize - entryOffset;
while (numToSkip > 0)
{
long skipped = skip(numToSkip);
if (skipped <= 0)
{
throw new java.lang.RuntimeException("failed to skip current tar entry");
}
numToSkip -= skipped;
}
readBuf = null;
}
byte[] headerBuf = buffer.readRecord();
if (headerBuf == null)
{
hasHitEOF = true;
}
else if (buffer.isEOFRecord(headerBuf))
{
hasHitEOF = true;
}
if (hasHitEOF)
{
currEntry = null;
}
else
{
currEntry = new TarArchiveEntry(headerBuf);
entryOffset = 0;
entrySize = currEntry.getSize();
}
if (currEntry != null && currEntry.isGNULongNameEntry())
{
// read in the name
StringBuilder longName = new StringBuilder();
byte[] buf = new byte[SMALL_BUFFER_SIZE];
int length = 0;
while ((length = read(buf)) >= 0)
{
longName.Append(System.Text.ASCIIEncoding.ASCII.GetString(buf, 0, length));
}
getNextEntry();
if (currEntry == null)
{
// Bugzilla: 40334
// Malformed tar file - long entry name not followed by entry
return(null);
}
// remove trailing null terminator
if (longName.Length > 0 &&
longName[longName.Length - 1] == 0)
{
longName.deleteCharAt(longName.Length - 1);
}
currEntry.setName(longName.toString());
}
if (currEntry != null && currEntry.isPaxHeader()) // Process Pax headers
{
paxHeaders();
}
return(currEntry);
}
/**
* Determine if the given entry is a descendant of this entry.
* Descendancy is determined by the name of the descendant
* starting with this entry's name.
*
* @param desc Entry to be checked as a descendent of this.
* @return True if entry is a descendant of this.
*/
public bool isDescendent(TarArchiveEntry desc)
{
return(desc.getName().StartsWith(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 bool equals(TarArchiveEntry it)
{
return(getName().equals(it.getName()));
}
