001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.apache.commons.compress.archivers.tar; 020 021import static java.nio.charset.StandardCharsets.UTF_8; 022 023import java.io.File; 024import java.io.IOException; 025import java.io.OutputStream; 026import java.io.StringWriter; 027import java.math.BigDecimal; 028import java.math.RoundingMode; 029import java.nio.ByteBuffer; 030import java.nio.file.LinkOption; 031import java.nio.file.Path; 032import java.nio.file.attribute.FileTime; 033import java.time.Instant; 034import java.util.Arrays; 035import java.util.HashMap; 036import java.util.Map; 037 038import org.apache.commons.compress.archivers.ArchiveEntry; 039import org.apache.commons.compress.archivers.ArchiveOutputStream; 040import org.apache.commons.compress.archivers.zip.ZipEncoding; 041import org.apache.commons.compress.archivers.zip.ZipEncodingHelper; 042import org.apache.commons.compress.utils.CountingOutputStream; 043import org.apache.commons.compress.utils.ExactMath; 044import org.apache.commons.compress.utils.FixedLengthBlockOutputStream; 045import org.apache.commons.compress.utils.TimeUtils; 046 047/** 048 * The TarOutputStream writes a UNIX tar archive as an OutputStream. Methods are provided to put 049 * entries, and then write their contents by writing to this stream using write(). 050 * 051 * <p>tar archives consist of a sequence of records of 512 bytes each 052 * that are grouped into blocks. Prior to Apache Commons Compress 1.14 053 * it has been possible to configure a record size different from 512 054 * bytes and arbitrary block sizes. Starting with Compress 1.15 512 is 055 * the only valid option for the record size and the block size must 056 * be a multiple of 512. Also the default block size changed from 057 * 10240 bytes prior to Compress 1.15 to 512 bytes with Compress 058 * 1.15.</p> 059 * 060 * @NotThreadSafe 061 */ 062public class TarArchiveOutputStream extends ArchiveOutputStream { 063 064 /** 065 * Fail if a long file name is required in the archive. 066 */ 067 public static final int LONGFILE_ERROR = 0; 068 069 /** 070 * Long paths will be truncated in the archive. 071 */ 072 public static final int LONGFILE_TRUNCATE = 1; 073 074 /** 075 * GNU tar extensions are used to store long file names in the archive. 076 */ 077 public static final int LONGFILE_GNU = 2; 078 079 /** 080 * POSIX/PAX extensions are used to store long file names in the archive. 081 */ 082 public static final int LONGFILE_POSIX = 3; 083 084 /** 085 * Fail if a big number (e.g. size > 8GiB) is required in the archive. 086 */ 087 public static final int BIGNUMBER_ERROR = 0; 088 089 /** 090 * star/GNU tar/BSD tar extensions are used to store big number in the archive. 091 */ 092 public static final int BIGNUMBER_STAR = 1; 093 094 /** 095 * POSIX/PAX extensions are used to store big numbers in the archive. 096 */ 097 public static final int BIGNUMBER_POSIX = 2; 098 private static final int RECORD_SIZE = 512; 099 100 private static final ZipEncoding ASCII = 101 ZipEncodingHelper.getZipEncoding("ASCII"); 102 private static final int BLOCK_SIZE_UNSPECIFIED = -511; 103 private long currSize; 104 private String currName; 105 private long currBytes; 106 private final byte[] recordBuf; 107 private int longFileMode = LONGFILE_ERROR; 108 private int bigNumberMode = BIGNUMBER_ERROR; 109 110 private long recordsWritten; 111 112 private final int recordsPerBlock; 113 114 private boolean closed; 115 116 /** 117 * Indicates if putArchiveEntry has been called without closeArchiveEntry 118 */ 119 private boolean haveUnclosedEntry; 120 /** 121 * indicates if this archive is finished 122 */ 123 private boolean finished; 124 125 private final FixedLengthBlockOutputStream out; 126 127 private final CountingOutputStream countingOut; 128 129 private final ZipEncoding zipEncoding; 130 // the provided encoding (for unit tests) 131 final String encoding; 132 133 private boolean addPaxHeadersForNonAsciiNames; 134 135 /** 136 * Constructor for TarArchiveOutputStream. 137 * 138 * <p>Uses a block size of 512 bytes.</p> 139 * 140 * @param os the output stream to use 141 */ 142 public TarArchiveOutputStream(final OutputStream os) { 143 this(os, BLOCK_SIZE_UNSPECIFIED); 144 } 145 146 /** 147 * Constructor for TarArchiveOutputStream. 148 * 149 * @param os the output stream to use 150 * @param blockSize the block size to use. Must be a multiple of 512 bytes. 151 */ 152 public TarArchiveOutputStream(final OutputStream os, final int blockSize) { 153 this(os, blockSize, null); 154 } 155 156 /** 157 * Constructor for TarArchiveOutputStream. 158 * 159 * @param os the output stream to use 160 * @param blockSize the block size to use 161 * @param recordSize the record size to use. Must be 512 bytes. 162 * @deprecated recordSize must always be 512 bytes. An IllegalArgumentException will be thrown 163 * if any other value is used 164 */ 165 @Deprecated 166 public TarArchiveOutputStream(final OutputStream os, final int blockSize, 167 final int recordSize) { 168 this(os, blockSize, recordSize, null); 169 } 170 171 172 /** 173 * Constructor for TarArchiveOutputStream. 174 * 175 * @param os the output stream to use 176 * @param blockSize the block size to use . Must be a multiple of 512 bytes. 177 * @param recordSize the record size to use. Must be 512 bytes. 178 * @param encoding name of the encoding to use for file names 179 * @since 1.4 180 * @deprecated recordSize must always be 512 bytes. An IllegalArgumentException will be thrown 181 * if any other value is used. 182 */ 183 @Deprecated 184 public TarArchiveOutputStream(final OutputStream os, final int blockSize, 185 final int recordSize, final String encoding) { 186 this(os, blockSize, encoding); 187 if (recordSize != RECORD_SIZE) { 188 throw new IllegalArgumentException( 189 "Tar record size must always be 512 bytes. Attempt to set size of " + recordSize); 190 } 191 192 } 193 194 /** 195 * Constructor for TarArchiveOutputStream. 196 * 197 * @param os the output stream to use 198 * @param blockSize the block size to use. Must be a multiple of 512 bytes. 199 * @param encoding name of the encoding to use for file names 200 * @since 1.4 201 */ 202 public TarArchiveOutputStream(final OutputStream os, final int blockSize, 203 final String encoding) { 204 final int realBlockSize; 205 if (BLOCK_SIZE_UNSPECIFIED == blockSize) { 206 realBlockSize = RECORD_SIZE; 207 } else { 208 realBlockSize = blockSize; 209 } 210 211 if (realBlockSize <= 0 || realBlockSize % RECORD_SIZE != 0) { 212 throw new IllegalArgumentException("Block size must be a multiple of 512 bytes. Attempt to use set size of " + blockSize); 213 } 214 out = new FixedLengthBlockOutputStream(countingOut = new CountingOutputStream(os), 215 RECORD_SIZE); 216 this.encoding = encoding; 217 this.zipEncoding = ZipEncodingHelper.getZipEncoding(encoding); 218 219 this.recordBuf = new byte[RECORD_SIZE]; 220 this.recordsPerBlock = realBlockSize / RECORD_SIZE; 221 } 222 223 /** 224 * Constructor for TarArchiveOutputStream. 225 * 226 * <p>Uses a block size of 512 bytes.</p> 227 * 228 * @param os the output stream to use 229 * @param encoding name of the encoding to use for file names 230 * @since 1.4 231 */ 232 public TarArchiveOutputStream(final OutputStream os, final String encoding) { 233 this(os, BLOCK_SIZE_UNSPECIFIED, encoding); 234 } 235 236 private void addFileTimePaxHeader(final Map<String, String> paxHeaders, 237 final String header, final FileTime value) { 238 if (value != null) { 239 final Instant instant = value.toInstant(); 240 final long seconds = instant.getEpochSecond(); 241 final int nanos = instant.getNano(); 242 if (nanos == 0) { 243 paxHeaders.put(header, String.valueOf(seconds)); 244 } else { 245 addInstantPaxHeader(paxHeaders, header, seconds, nanos); 246 } 247 } 248 } 249 250 private void addFileTimePaxHeaderForBigNumber(final Map<String, String> paxHeaders, 251 final String header, final FileTime value, 252 final long maxValue) { 253 if (value != null) { 254 final Instant instant = value.toInstant(); 255 final long seconds = instant.getEpochSecond(); 256 final int nanos = instant.getNano(); 257 if (nanos == 0) { 258 addPaxHeaderForBigNumber(paxHeaders, header, seconds, maxValue); 259 } else { 260 addInstantPaxHeader(paxHeaders, header, seconds, nanos); 261 } 262 } 263 } 264 265 private void addInstantPaxHeader(final Map<String, String> paxHeaders, 266 final String header, final long seconds, final int nanos) { 267 final BigDecimal bdSeconds = BigDecimal.valueOf(seconds); 268 final BigDecimal bdNanos = BigDecimal.valueOf(nanos).movePointLeft(9).setScale(7, RoundingMode.DOWN); 269 final BigDecimal timestamp = bdSeconds.add(bdNanos); 270 paxHeaders.put(header, timestamp.toPlainString()); 271 } 272 273 private void addPaxHeaderForBigNumber(final Map<String, String> paxHeaders, 274 final String header, final long value, 275 final long maxValue) { 276 if (value < 0 || value > maxValue) { 277 paxHeaders.put(header, String.valueOf(value)); 278 } 279 } 280 281 private void addPaxHeadersForBigNumbers(final Map<String, String> paxHeaders, 282 final TarArchiveEntry entry) { 283 addPaxHeaderForBigNumber(paxHeaders, "size", entry.getSize(), 284 TarConstants.MAXSIZE); 285 addPaxHeaderForBigNumber(paxHeaders, "gid", entry.getLongGroupId(), 286 TarConstants.MAXID); 287 addFileTimePaxHeaderForBigNumber(paxHeaders, "mtime", 288 entry.getLastModifiedTime(), TarConstants.MAXSIZE); 289 addFileTimePaxHeader(paxHeaders, "atime", entry.getLastAccessTime()); 290 if (entry.getStatusChangeTime() != null) { 291 addFileTimePaxHeader(paxHeaders, "ctime", entry.getStatusChangeTime()); 292 } else { 293 // ctime is usually set from creation time on platforms where the real ctime is not available 294 addFileTimePaxHeader(paxHeaders, "ctime", entry.getCreationTime()); 295 } 296 addPaxHeaderForBigNumber(paxHeaders, "uid", entry.getLongUserId(), 297 TarConstants.MAXID); 298 // libarchive extensions 299 addFileTimePaxHeader(paxHeaders, "LIBARCHIVE.creationtime", entry.getCreationTime()); 300 // star extensions by Jörg Schilling 301 addPaxHeaderForBigNumber(paxHeaders, "SCHILY.devmajor", 302 entry.getDevMajor(), TarConstants.MAXID); 303 addPaxHeaderForBigNumber(paxHeaders, "SCHILY.devminor", 304 entry.getDevMinor(), TarConstants.MAXID); 305 // there is no PAX header for file mode 306 failForBigNumber("mode", entry.getMode(), TarConstants.MAXID); 307 } 308 309 /** 310 * Closes the underlying OutputStream. 311 * 312 * @throws IOException on error 313 */ 314 @Override 315 public void close() throws IOException { 316 try { 317 if (!finished) { 318 finish(); 319 } 320 } finally { 321 if (!closed) { 322 out.close(); 323 closed = true; 324 } 325 } 326 } 327 328 /** 329 * Close an entry. This method MUST be called for all file entries that contain data. The reason 330 * is that we must buffer data written to the stream in order to satisfy the buffer's record 331 * based writes. Thus, there may be data fragments still being assembled that must be written to 332 * the output stream before this entry is closed and the next entry written. 333 * 334 * @throws IOException on error 335 */ 336 @Override 337 public void closeArchiveEntry() throws IOException { 338 if (finished) { 339 throw new IOException("Stream has already been finished"); 340 } 341 if (!haveUnclosedEntry) { 342 throw new IOException("No current entry to close"); 343 } 344 out.flushBlock(); 345 if (currBytes < currSize) { 346 throw new IOException("Entry '" + currName + "' closed at '" 347 + currBytes 348 + "' before the '" + currSize 349 + "' bytes specified in the header were written"); 350 } 351 recordsWritten += currSize / RECORD_SIZE; 352 353 if (0 != currSize % RECORD_SIZE) { 354 recordsWritten++; 355 } 356 haveUnclosedEntry = false; 357 } 358 359 @Override 360 public ArchiveEntry createArchiveEntry(final File inputFile, final String entryName) 361 throws IOException { 362 if (finished) { 363 throw new IOException("Stream has already been finished"); 364 } 365 return new TarArchiveEntry(inputFile, entryName); 366 } 367 368 @Override 369 public ArchiveEntry createArchiveEntry(final Path inputPath, final String entryName, final LinkOption... options) throws IOException { 370 if (finished) { 371 throw new IOException("Stream has already been finished"); 372 } 373 return new TarArchiveEntry(inputPath, entryName, options); 374 } 375 376 private byte[] encodeExtendedPaxHeadersContents(final Map<String, String> headers) { 377 final StringWriter w = new StringWriter(); 378 headers.forEach((k, v) -> { 379 int len = k.length() + v.length() 380 + 3 /* blank, equals and newline */ 381 + 2 /* guess 9 < actual length < 100 */; 382 String line = len + " " + k + "=" + v + "\n"; 383 int actualLength = line.getBytes(UTF_8).length; 384 while (len != actualLength) { 385 // Adjust for cases where length < 10 or > 100 386 // or where UTF-8 encoding isn't a single octet 387 // per character. 388 // Must be in loop as size may go from 99 to 100 in 389 // first pass so we'd need a second. 390 len = actualLength; 391 line = len + " " + k + "=" + v + "\n"; 392 actualLength = line.getBytes(UTF_8).length; 393 } 394 w.write(line); 395 }); 396 return w.toString().getBytes(UTF_8); 397 } 398 399 private void failForBigNumber(final String field, final long value, final long maxValue) { 400 failForBigNumber(field, value, maxValue, ""); 401 } 402 403 private void failForBigNumber(final String field, final long value, final long maxValue, 404 final String additionalMsg) { 405 if (value < 0 || value > maxValue) { 406 throw new IllegalArgumentException(field + " '" + value //NOSONAR 407 + "' is too big ( > " 408 + maxValue + " )." + additionalMsg); 409 } 410 } 411 412 private void failForBigNumbers(final TarArchiveEntry entry) { 413 failForBigNumber("entry size", entry.getSize(), TarConstants.MAXSIZE); 414 failForBigNumberWithPosixMessage("group id", entry.getLongGroupId(), TarConstants.MAXID); 415 failForBigNumber("last modification time", 416 TimeUtils.toUnixTime(entry.getLastModifiedTime()), 417 TarConstants.MAXSIZE); 418 failForBigNumber("user id", entry.getLongUserId(), TarConstants.MAXID); 419 failForBigNumber("mode", entry.getMode(), TarConstants.MAXID); 420 failForBigNumber("major device number", entry.getDevMajor(), 421 TarConstants.MAXID); 422 failForBigNumber("minor device number", entry.getDevMinor(), 423 TarConstants.MAXID); 424 } 425 426 private void failForBigNumberWithPosixMessage(final String field, final long value, 427 final long maxValue) { 428 failForBigNumber(field, value, maxValue, 429 " Use STAR or POSIX extensions to overcome this limit"); 430 } 431 432 /** 433 * Ends the TAR archive without closing the underlying OutputStream. 434 * 435 * An archive consists of a series of file entries terminated by an 436 * end-of-archive entry, which consists of two 512 blocks of zero bytes. 437 * POSIX.1 requires two EOF records, like some other implementations. 438 * 439 * @throws IOException on error 440 */ 441 @Override 442 public void finish() throws IOException { 443 if (finished) { 444 throw new IOException("This archive has already been finished"); 445 } 446 447 if (haveUnclosedEntry) { 448 throw new IOException("This archive contains unclosed entries."); 449 } 450 writeEOFRecord(); 451 writeEOFRecord(); 452 padAsNeeded(); 453 out.flush(); 454 finished = true; 455 } 456 457 @Override 458 public void flush() throws IOException { 459 out.flush(); 460 } 461 462 @Override 463 public long getBytesWritten() { 464 return countingOut.getBytesWritten(); 465 } 466 467 @Deprecated 468 @Override 469 public int getCount() { 470 return (int) getBytesWritten(); 471 } 472 473 /** 474 * Get the record size being used by this stream's TarBuffer. 475 * 476 * @return The TarBuffer record size. 477 * @deprecated 478 */ 479 @Deprecated 480 public int getRecordSize() { 481 return RECORD_SIZE; 482 } 483 484 /** 485 * Handles long file or link names according to the longFileMode setting. 486 * 487 * <p>I.e. if the given name is too long to be written to a plain tar header then <ul> <li>it 488 * creates a pax header who's name is given by the paxHeaderName parameter if longFileMode is 489 * POSIX</li> <li>it creates a GNU longlink entry who's type is given by the linkType parameter 490 * if longFileMode is GNU</li> <li>it throws an exception if longFileMode is ERROR</li> <li>it 491 * truncates the name if longFileMode is TRUNCATE</li> </ul></p> 492 * 493 * @param entry entry the name belongs to 494 * @param name the name to write 495 * @param paxHeaders current map of pax headers 496 * @param paxHeaderName name of the pax header to write 497 * @param linkType type of the GNU entry to write 498 * @param fieldName the name of the field 499 * @throws IllegalArgumentException if the {@link TarArchiveOutputStream#longFileMode} equals 500 * {@link TarArchiveOutputStream#LONGFILE_ERROR} and the file 501 * name is too long 502 * @return whether a pax header has been written. 503 */ 504 private boolean handleLongName(final TarArchiveEntry entry, final String name, 505 final Map<String, String> paxHeaders, 506 final String paxHeaderName, final byte linkType, final String fieldName) 507 throws IOException { 508 final ByteBuffer encodedName = zipEncoding.encode(name); 509 final int len = encodedName.limit() - encodedName.position(); 510 if (len >= TarConstants.NAMELEN) { 511 512 if (longFileMode == LONGFILE_POSIX) { 513 paxHeaders.put(paxHeaderName, name); 514 return true; 515 } 516 if (longFileMode == LONGFILE_GNU) { 517 // create a TarEntry for the LongLink, the contents 518 // of which are the link's name 519 final TarArchiveEntry longLinkEntry = new TarArchiveEntry(TarConstants.GNU_LONGLINK, 520 linkType); 521 522 longLinkEntry.setSize(len + 1L); // +1 for NUL 523 transferModTime(entry, longLinkEntry); 524 putArchiveEntry(longLinkEntry); 525 write(encodedName.array(), encodedName.arrayOffset(), len); 526 write(0); // NUL terminator 527 closeArchiveEntry(); 528 } else if (longFileMode != LONGFILE_TRUNCATE) { 529 throw new IllegalArgumentException(fieldName + " '" + name //NOSONAR 530 + "' is too long ( > " 531 + TarConstants.NAMELEN + " bytes)"); 532 } 533 } 534 return false; 535 } 536 537 private void padAsNeeded() throws IOException { 538 final int start = Math.toIntExact(recordsWritten % recordsPerBlock); 539 if (start != 0) { 540 for (int i = start; i < recordsPerBlock; i++) { 541 writeEOFRecord(); 542 } 543 } 544 } 545 546 /** 547 * Put an entry on the output stream. This writes the entry's header record and positions the 548 * output stream for writing the contents of the entry. Once this method is called, the stream 549 * is ready for calls to write() to write the entry's contents. Once the contents are written, 550 * closeArchiveEntry() <B>MUST</B> be called to ensure that all buffered data is completely 551 * written to the output stream. 552 * 553 * @param archiveEntry The TarEntry to be written to the archive. 554 * @throws IOException on error 555 * @throws ClassCastException if archiveEntry is not an instance of TarArchiveEntry 556 * @throws IllegalArgumentException if the {@link TarArchiveOutputStream#longFileMode} equals 557 * {@link TarArchiveOutputStream#LONGFILE_ERROR} and the file 558 * name is too long 559 * @throws IllegalArgumentException if the {@link TarArchiveOutputStream#bigNumberMode} equals 560 * {@link TarArchiveOutputStream#BIGNUMBER_ERROR} and one of the numeric values 561 * exceeds the limits of a traditional tar header. 562 */ 563 @Override 564 public void putArchiveEntry(final ArchiveEntry archiveEntry) throws IOException { 565 if (finished) { 566 throw new IOException("Stream has already been finished"); 567 } 568 final TarArchiveEntry entry = (TarArchiveEntry) archiveEntry; 569 if (entry.isGlobalPaxHeader()) { 570 final byte[] data = encodeExtendedPaxHeadersContents(entry.getExtraPaxHeaders()); 571 entry.setSize(data.length); 572 entry.writeEntryHeader(recordBuf, zipEncoding, bigNumberMode == BIGNUMBER_STAR); 573 writeRecord(recordBuf); 574 currSize= entry.getSize(); 575 currBytes = 0; 576 this.haveUnclosedEntry = true; 577 write(data); 578 closeArchiveEntry(); 579 } else { 580 final Map<String, String> paxHeaders = new HashMap<>(); 581 final String entryName = entry.getName(); 582 final boolean paxHeaderContainsPath = handleLongName(entry, entryName, paxHeaders, "path", 583 TarConstants.LF_GNUTYPE_LONGNAME, "file name"); 584 final String linkName = entry.getLinkName(); 585 final boolean paxHeaderContainsLinkPath = linkName != null && !linkName.isEmpty() 586 && handleLongName(entry, linkName, paxHeaders, "linkpath", 587 TarConstants.LF_GNUTYPE_LONGLINK, "link name"); 588 589 if (bigNumberMode == BIGNUMBER_POSIX) { 590 addPaxHeadersForBigNumbers(paxHeaders, entry); 591 } else if (bigNumberMode != BIGNUMBER_STAR) { 592 failForBigNumbers(entry); 593 } 594 595 if (addPaxHeadersForNonAsciiNames && !paxHeaderContainsPath 596 && !ASCII.canEncode(entryName)) { 597 paxHeaders.put("path", entryName); 598 } 599 600 if (addPaxHeadersForNonAsciiNames && !paxHeaderContainsLinkPath 601 && (entry.isLink() || entry.isSymbolicLink()) 602 && !ASCII.canEncode(linkName)) { 603 paxHeaders.put("linkpath", linkName); 604 } 605 paxHeaders.putAll(entry.getExtraPaxHeaders()); 606 607 if (!paxHeaders.isEmpty()) { 608 writePaxHeaders(entry, entryName, paxHeaders); 609 } 610 611 entry.writeEntryHeader(recordBuf, zipEncoding, bigNumberMode == BIGNUMBER_STAR); 612 writeRecord(recordBuf); 613 614 currBytes = 0; 615 616 if (entry.isDirectory()) { 617 currSize = 0; 618 } else { 619 currSize = entry.getSize(); 620 } 621 currName = entryName; 622 haveUnclosedEntry = true; 623 } 624 } 625 626 /** 627 * Whether to add a PAX extension header for non-ASCII file names. 628 * 629 * @param b whether to add a PAX extension header for non-ASCII file names. 630 * @since 1.4 631 */ 632 public void setAddPaxHeadersForNonAsciiNames(final boolean b) { 633 addPaxHeadersForNonAsciiNames = b; 634 } 635 636 /** 637 * Set the big number mode. This can be BIGNUMBER_ERROR(0), BIGNUMBER_STAR(1) or 638 * BIGNUMBER_POSIX(2). This specifies the treatment of big files (sizes > 639 * TarConstants.MAXSIZE) and other numeric values too big to fit into a traditional tar header. 640 * Default is BIGNUMBER_ERROR. 641 * 642 * @param bigNumberMode the mode to use 643 * @since 1.4 644 */ 645 public void setBigNumberMode(final int bigNumberMode) { 646 this.bigNumberMode = bigNumberMode; 647 } 648 649 /** 650 * Set the long file mode. This can be LONGFILE_ERROR(0), LONGFILE_TRUNCATE(1), LONGFILE_GNU(2) or 651 * LONGFILE_POSIX(3). This specifies the treatment of long file names (names >= 652 * TarConstants.NAMELEN). Default is LONGFILE_ERROR. 653 * 654 * @param longFileMode the mode to use 655 */ 656 public void setLongFileMode(final int longFileMode) { 657 this.longFileMode = longFileMode; 658 } 659 660 /** 661 * @return true if the character could lead to problems when used inside a TarArchiveEntry name 662 * for a PAX header. 663 */ 664 private boolean shouldBeReplaced(final char c) { 665 return c == 0 // would be read as Trailing null 666 || c == '/' // when used as last character TAE will consider the PAX header a directory 667 || c == '\\'; // same as '/' as slashes get "normalized" on Windows 668 } 669 670 private String stripTo7Bits(final String name) { 671 final int length = name.length(); 672 final StringBuilder result = new StringBuilder(length); 673 for (int i = 0; i < length; i++) { 674 final char stripped = (char) (name.charAt(i) & 0x7F); 675 if (shouldBeReplaced(stripped)) { 676 result.append("_"); 677 } else { 678 result.append(stripped); 679 } 680 } 681 return result.toString(); 682 } 683 684 private void transferModTime(final TarArchiveEntry from, final TarArchiveEntry to) { 685 long fromModTimeSeconds = TimeUtils.toUnixTime(from.getLastModifiedTime()); 686 if (fromModTimeSeconds < 0 || fromModTimeSeconds > TarConstants.MAXSIZE) { 687 fromModTimeSeconds = 0; 688 } 689 to.setLastModifiedTime(TimeUtils.unixTimeToFileTime(fromModTimeSeconds)); 690 } 691 692 /** 693 * Writes bytes to the current tar archive entry. This method is aware of the current entry and 694 * will throw an exception if you attempt to write bytes past the length specified for the 695 * current entry. 696 * 697 * @param wBuf The buffer to write to the archive. 698 * @param wOffset The offset in the buffer from which to get bytes. 699 * @param numToWrite The number of bytes to write. 700 * @throws IOException on error 701 */ 702 @Override 703 public void write(final byte[] wBuf, final int wOffset, final int numToWrite) throws IOException { 704 if (!haveUnclosedEntry) { 705 throw new IllegalStateException("No current tar entry"); 706 } 707 if (currBytes + numToWrite > currSize) { 708 throw new IOException("Request to write '" + numToWrite 709 + "' bytes exceeds size in header of '" 710 + currSize + "' bytes for entry '" 711 + currName + "'"); 712 } 713 out.write(wBuf, wOffset, numToWrite); 714 currBytes += numToWrite; 715 } 716 717 /** 718 * Write an EOF (end of archive) record to the tar archive. An EOF record consists of a record 719 * of all zeros. 720 */ 721 private void writeEOFRecord() throws IOException { 722 Arrays.fill(recordBuf, (byte) 0); 723 writeRecord(recordBuf); 724 } 725 726 /** 727 * Writes a PAX extended header with the given map as contents. 728 * 729 * @since 1.4 730 */ 731 void writePaxHeaders(final TarArchiveEntry entry, 732 final String entryName, 733 final Map<String, String> headers) throws IOException { 734 String name = "./PaxHeaders.X/" + stripTo7Bits(entryName); 735 if (name.length() >= TarConstants.NAMELEN) { 736 name = name.substring(0, TarConstants.NAMELEN - 1); 737 } 738 final TarArchiveEntry pex = new TarArchiveEntry(name, 739 TarConstants.LF_PAX_EXTENDED_HEADER_LC); 740 transferModTime(entry, pex); 741 742 final byte[] data = encodeExtendedPaxHeadersContents(headers); 743 pex.setSize(data.length); 744 putArchiveEntry(pex); 745 write(data); 746 closeArchiveEntry(); 747 } 748 749 /** 750 * Write an archive record to the archive. 751 * 752 * @param record The record data to write to the archive. 753 * @throws IOException on error 754 */ 755 private void writeRecord(final byte[] record) throws IOException { 756 if (record.length != RECORD_SIZE) { 757 throw new IOException("Record to write has length '" 758 + record.length 759 + "' which is not the record size of '" 760 + RECORD_SIZE + "'"); 761 } 762 763 out.write(record); 764 recordsWritten++; 765 } 766}