| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.commons.compress.archivers.tar; |
| |
| import java.io.FilterOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| 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(). |
| * |
| */ |
| 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; |
| |
| // CheckStyle:VisibilityModifier OFF - bc |
| protected boolean debug; |
| protected long currSize; |
| protected String currName; |
| protected long currBytes; |
| protected byte[] oneBuf; |
| protected byte[] recordBuf; |
| protected int assemLen; |
| protected byte[] assemBuf; |
| protected TarBuffer buffer; |
| protected int longFileMode = LONGFILE_ERROR; |
| // CheckStyle:VisibilityModifier ON |
| |
| private boolean closed = false; |
| |
| /** |
| * Constructor for TarInputStream. |
| * @param os the output stream to use |
| */ |
| public TarOutputStream(OutputStream os) { |
| this(os, TarBuffer.DEFAULT_BLKSIZE, TarBuffer.DEFAULT_RCDSIZE); |
| } |
| |
| /** |
| * Constructor for TarInputStream. |
| * @param os the output stream to use |
| * @param blockSize the block size to use |
| */ |
| public TarOutputStream(OutputStream os, int blockSize) { |
| this(os, blockSize, TarBuffer.DEFAULT_RCDSIZE); |
| } |
| |
| /** |
| * Constructor for TarInputStream. |
| * @param os the output stream to use |
| * @param blockSize the block size to use |
| * @param recordSize the record size to use |
| */ |
| 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]; |
| } |
| |
| /** |
| * Set the long file mode. |
| * This can be LONGFILE_ERROR(0), LONGFILE_TRUNCATE(1) or LONGFILE_GNU(2). |
| * This specifies the treatment of long file names (names >= TarConstants.NAMELEN). |
| * Default is LONGFILE_ERROR. |
| * @param longFileMode the mode to use |
| */ |
| 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) { |
| buffer.setDebug(debug); |
| } |
| |
| /** |
| * Ends the TAR archive without closing the underlying OutputStream. |
| * The result is that the two EOF records of nulls are written. |
| * @throws IOException on error |
| */ |
| public void finish() throws IOException { |
| // See Bugzilla 28776 for a discussion on this |
| // http://issues.apache.org/bugzilla/show_bug.cgi?id=28776 |
| writeEOFRecord(); |
| writeEOFRecord(); |
| } |
| |
| /** |
| * Ends the TAR archive and closes the underlying OutputStream. |
| * This means that finish() is called followed by calling the |
| * TarBuffer's close(). |
| * @throws IOException on error |
| */ |
| public void close() throws IOException { |
| if (!closed) { |
| finish(); |
| buffer.close(); |
| out.close(); |
| closed = true; |
| } |
| } |
| |
| /** |
| * Get the record size being used by this stream's TarBuffer. |
| * |
| * @return The TarBuffer record size. |
| */ |
| public int getRecordSize() { |
| return 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() |
| * <B>MUST</B> 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. |
| * @throws IOException on error |
| */ |
| public void putNextEntry(TarArchiveEntry entry) throws IOException { |
| if (entry.getName().length() >= TarConstants.NAMELEN) { |
| |
| if (longFileMode == LONGFILE_GNU) { |
| // create a TarEntry for the LongLink, the contents |
| // of which are the entry's name |
| TarArchiveEntry longLinkEntry = new TarArchiveEntry(TarConstants.GNU_LONGLINK, |
| TarConstants.LF_GNUTYPE_LONGNAME); |
| |
| longLinkEntry.setSize(entry.getName().length() + 1); |
| putNextEntry(longLinkEntry); |
| write(entry.getName().getBytes()); |
| write(0); |
| closeEntry(); |
| } else if (longFileMode != LONGFILE_TRUNCATE) { |
| throw new RuntimeException("file name '" + entry.getName() |
| + "' is too long ( > " |
| + TarConstants.NAMELEN + " bytes)"); |
| } |
| } |
| |
| entry.writeEntryHeader(recordBuf); |
| buffer.writeRecord(recordBuf); |
| |
| currBytes = 0; |
| |
| if (entry.isDirectory()) { |
| currSize = 0; |
| } else { |
| currSize = entry.getSize(); |
| } |
| currName = entry.getName(); |
| } |
| |
| /** |
| * 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. |
| * @throws IOException on error |
| */ |
| public void closeEntry() throws IOException { |
| if (assemLen > 0) { |
| for (int i = assemLen; i < assemBuf.length; ++i) { |
| assemBuf[i] = 0; |
| } |
| |
| buffer.writeRecord(assemBuf); |
| |
| currBytes += assemLen; |
| assemLen = 0; |
| } |
| |
| if (currBytes < currSize) { |
| throw new IOException("entry '" + currName + "' closed at '" |
| + currBytes |
| + "' before the '" + 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. |
| * @throws IOException on error |
| */ |
| public void write(int b) throws IOException { |
| oneBuf[0] = (byte) b; |
| |
| write(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. |
| * @throws IOException on error |
| */ |
| public void write(byte[] wBuf) throws IOException { |
| 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. |
| * @throws IOException on error |
| */ |
| public void write(byte[] wBuf, int wOffset, int numToWrite) throws IOException { |
| if ((currBytes + numToWrite) > currSize) { |
| throw new IOException("request to write '" + numToWrite |
| + "' bytes exceeds size in header of '" |
| + currSize + "' bytes for entry '" |
| + currName + "'"); |
| |
| // |
| // 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 (assemLen > 0) { |
| if ((assemLen + numToWrite) >= recordBuf.length) { |
| int aLen = recordBuf.length - assemLen; |
| |
| System.arraycopy(assemBuf, 0, recordBuf, 0, |
| assemLen); |
| System.arraycopy(wBuf, wOffset, recordBuf, |
| assemLen, aLen); |
| buffer.writeRecord(recordBuf); |
| |
| currBytes += recordBuf.length; |
| wOffset += aLen; |
| numToWrite -= aLen; |
| assemLen = 0; |
| } else { |
| System.arraycopy(wBuf, wOffset, assemBuf, assemLen, |
| numToWrite); |
| |
| wOffset += numToWrite; |
| 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 < recordBuf.length) { |
| System.arraycopy(wBuf, wOffset, assemBuf, assemLen, |
| numToWrite); |
| |
| assemLen += numToWrite; |
| |
| break; |
| } |
| |
| buffer.writeRecord(wBuf, wOffset); |
| |
| int num = recordBuf.length; |
| |
| 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 < recordBuf.length; ++i) { |
| recordBuf[i] = 0; |
| } |
| |
| buffer.writeRecord(recordBuf); |
| } |
| } |