    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 java.io.File;
    022import java.io.IOException;
    023import java.io.UncheckedIOException;
    024import java.math.BigDecimal;
    025import java.nio.file.DirectoryStream;
    026import java.nio.file.Files;
    027import java.nio.file.LinkOption;
    028import java.nio.file.Path;
    029import java.nio.file.attribute.BasicFileAttributes;
    030import java.nio.file.attribute.DosFileAttributes;
    031import java.nio.file.attribute.FileTime;
    032import java.nio.file.attribute.PosixFileAttributes;
    033import java.time.Instant;
    034import java.util.ArrayList;
    035import java.util.Collections;
    036import java.util.Comparator;
    037import java.util.Date;
    038import java.util.HashMap;
    039import java.util.List;
    040import java.util.Locale;
    041import java.util.Map;
    042import java.util.Objects;
    043import java.util.Set;
    044import java.util.stream.Collectors;
    045
    046import org.apache.commons.compress.archivers.ArchiveEntry;
    047import org.apache.commons.compress.archivers.EntryStreamOffsets;
    048import org.apache.commons.compress.archivers.zip.ZipEncoding;
    049import org.apache.commons.compress.utils.ArchiveUtils;
    050import org.apache.commons.compress.utils.IOUtils;
    051import org.apache.commons.compress.utils.TimeUtils;
    052
    053/**
    054 * This class represents an entry in a Tar archive. It consists
    055 * of the entry's header, as well as the entry's File. Entries
    056 * can be instantiated in one of three ways, depending on how
    057 * they are to be used.
    058 * <p>
    059 * TarEntries that are created from the header bytes read from
    060 * an archive are instantiated with the {@link TarArchiveEntry#TarArchiveEntry(byte[])}
    061 * constructor. These entries will be used when extracting from
    062 * or listing the contents of an archive. These entries have their
    063 * header filled in using the header bytes. They also set the File
    064 * to null, since they reference an archive entry not a file.
    065 * </p>
    066 * <p>
    067 * TarEntries that are created from Files that are to be written
    068 * into an archive are instantiated with the {@link TarArchiveEntry#TarArchiveEntry(File)}
    069 * or {@link TarArchiveEntry#TarArchiveEntry(Path)} constructor.
    070 * These entries have their header filled in using the File's information.
    071 * They also keep a reference to the File for convenience when writing entries.
    072 * </p>
    073 * <p>
    074 * Finally, TarEntries can be constructed from nothing but a name.
    075 * This allows the programmer to construct the entry by hand, for
    076 * instance when only an InputStream is available for writing to
    077 * the archive, and the header information is constructed from
    078 * other information. In this case the header fields are set to
    079 * defaults and the File is set to null.
    080 * </p>
    081 * <p>
    082 * The C structure for a Tar Entry's header is:
    083 * </p>
    084 * <pre>
    085 * struct header {
    086 *   char name[100];     // TarConstants.NAMELEN    - offset   0
    087 *   char mode[8];       // TarConstants.MODELEN    - offset 100
    088 *   char uid[8];        // TarConstants.UIDLEN     - offset 108
    089 *   char gid[8];        // TarConstants.GIDLEN     - offset 116
    090 *   char size[12];      // TarConstants.SIZELEN    - offset 124
    091 *   char mtime[12];     // TarConstants.MODTIMELEN - offset 136
    092 *   char chksum[8];     // TarConstants.CHKSUMLEN  - offset 148
    093 *   char linkflag[1];   //                         - offset 156
    094 *   char linkname[100]; // TarConstants.NAMELEN    - offset 157
    095 *   // The following fields are only present in new-style POSIX tar archives:
    096 *   char magic[6];      // TarConstants.MAGICLEN   - offset 257
    097 *   char version[2];    // TarConstants.VERSIONLEN - offset 263
    098 *   char uname[32];     // TarConstants.UNAMELEN   - offset 265
    099 *   char gname[32];     // TarConstants.GNAMELEN   - offset 297
    100 *   char devmajor[8];   // TarConstants.DEVLEN     - offset 329
    101 *   char devminor[8];   // TarConstants.DEVLEN     - offset 337
    102 *   char prefix[155];   // TarConstants.PREFIXLEN  - offset 345
    103 *   // Used if "name" field is not long enough to hold the path
    104 *   char pad[12];       // NULs                    - offset 500
    105 * } header;
    106 * </pre>
    107 * <p>
    108 * All unused bytes are set to null.
    109 * New-style GNU tar files are slightly different from the above.
    110 * For values of size larger than 077777777777L (11 7s)
    111 * or uid and gid larger than 07777777L (7 7s)
    112 * the sign bit of the first byte is set, and the rest of the
    113 * field is the binary representation of the number.
    114 * See {@link TarUtils#parseOctalOrBinary(byte[], int, int)}.
    115 * <p>
    116 * The C structure for a old GNU Tar Entry's header is:
    117 * </p>
    118 * <pre>
    119 * struct oldgnu_header {
    120 *   char unused_pad1[345]; // TarConstants.PAD1LEN_GNU       - offset 0
    121 *   char atime[12];        // TarConstants.ATIMELEN_GNU      - offset 345
    122 *   char ctime[12];        // TarConstants.CTIMELEN_GNU      - offset 357
    123 *   char offset[12];       // TarConstants.OFFSETLEN_GNU     - offset 369
    124 *   char longnames[4];     // TarConstants.LONGNAMESLEN_GNU  - offset 381
    125 *   char unused_pad2;      // TarConstants.PAD2LEN_GNU       - offset 385
    126 *   struct sparse sp[4];   // TarConstants.SPARSELEN_GNU     - offset 386
    127 *   char isextended;       // TarConstants.ISEXTENDEDLEN_GNU - offset 482
    128 *   char realsize[12];     // TarConstants.REALSIZELEN_GNU   - offset 483
    129 *   char unused_pad[17];   // TarConstants.PAD3LEN_GNU       - offset 495
    130 * };
    131 * </pre>
    132 * <p>
    133 * Whereas, "struct sparse" is:
    134 * </p>
    135 * <pre>
    136 * struct sparse {
    137 *   char offset[12];   // offset 0
    138 *   char numbytes[12]; // offset 12
    139 * };
    140 * </pre>
    141 * <p>
    142 * The C structure for a xstar (Jörg Schilling star) Tar Entry's header is:
    143 * </p>
    144 * <pre>
    145 * struct star_header {
    146 *   char name[100];     // offset   0
    147 *   char mode[8];       // offset 100
    148 *   char uid[8];        // offset 108
    149 *   char gid[8];        // offset 116
    150 *   char size[12];      // offset 124
    151 *   char mtime[12];     // offset 136
    152 *   char chksum[8];     // offset 148
    153 *   char typeflag;      // offset 156
    154 *   char linkname[100]; // offset 157
    155 *   char magic[6];      // offset 257
    156 *   char version[2];    // offset 263
    157 *   char uname[32];     // offset 265
    158 *   char gname[32];     // offset 297
    159 *   char devmajor[8];   // offset 329
    160 *   char devminor[8];   // offset 337
    161 *   char prefix[131];   // offset 345
    162 *   char atime[12];     // offset 476
    163 *   char ctime[12];     // offset 488
    164 *   char mfill[8];      // offset 500
    165 *   char xmagic[4];     // offset 508  "tar\0"
    166 * };
    167 * </pre>
    168 * <p>
    169 * which is identical to new-style POSIX up to the first 130 bytes of the prefix.
    170 * </p>
    171 * <p>
    172 * The C structure for the xstar-specific parts of a xstar Tar Entry's header is:
    173 * </p>
    174 * <pre>
    175 * struct xstar_in_header {
    176 *   char fill[345];         // offset 0     Everything before t_prefix
    177 *   char prefix[1];         // offset 345   Prefix for t_name
    178 *   char fill2;             // offset 346
    179 *   char fill3[8];          // offset 347
    180 *   char isextended;        // offset 355
    181 *   struct sparse sp[SIH];  // offset 356   8 x 12
    182 *   char realsize[12];      // offset 452   Real size for sparse data
    183 *   char offset[12];        // offset 464   Offset for multivolume data
    184 *   char atime[12];         // offset 476
    185 *   char ctime[12];         // offset 488
    186 *   char mfill[8];          // offset 500
    187 *   char xmagic[4];         // offset 508   "tar\0"
    188 * };
    189 * </pre>
    190 *
    191 * @NotThreadSafe
    192 */
    193public class TarArchiveEntry implements ArchiveEntry, TarConstants, EntryStreamOffsets {
    194
    195    private static final TarArchiveEntry[] EMPTY_TAR_ARCHIVE_ENTRY_ARRAY = {};
    196
    197    /**
    198     * Value used to indicate unknown mode, user/groupids, device numbers and modTime when parsing a file in lenient
    199     * mode and the archive contains illegal fields.
    200     * @since 1.19
    201     */
    202    public static final long UNKNOWN = -1L;
    203
    204    /** Maximum length of a user's name in the tar file */
    205    public static final int MAX_NAMELEN = 31;
    206
    207    /** Default permissions bits for directories */
    208    public static final int DEFAULT_DIR_MODE = 040755;
    209
    210    /** Default permissions bits for files */
    211    public static final int DEFAULT_FILE_MODE = 0100644;
    212
    213    /**
    214     * Convert millis to seconds
    215     * @deprecated Unused.
    216     */
    217    @Deprecated
    218    public static final int MILLIS_PER_SECOND = 1000;
    219
    220    /**
    221     * Regular expression pattern for validating values in pax extended header file time fields.
    222     * These fields contain two numeric values (seconds and sub-second values) as per this definition:
    223     * https://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_05
    224     * <p>
    225     * Since they are parsed into long values, maximum length of each is the same as Long.MAX_VALUE
    226     * which is 19 digits.
    227     * </p>
    228     */
    229    private static final String PAX_EXTENDED_HEADER_FILE_TIMES_PATTERN = "-?\\d{1,19}(?:\\.\\d{1,19})?";
    230
    231    private static FileTime fileTimeFromOptionalSeconds(final long seconds) {
    232        if (seconds <= 0) {
    233            return null;
    234        }
    235        return TimeUtils.unixTimeToFileTime(seconds);
    236    }
    237
    238    /**
    239     * Strips Windows' drive letter as well as any leading slashes, turns path separators into forward slashes.
    240     */
    241    private static String normalizeFileName(String fileName, final boolean preserveAbsolutePath) {
    242        if (!preserveAbsolutePath) {
    243            final String property = System.getProperty("os.name");
    244            if (property != null) {
    245                final String osName = property.toLowerCase(Locale.ROOT);
    246
    247                // Strip off drive letters!
    248                // REVIEW Would a better check be "(File.separator == '\')"?
    249
    250                if (osName.startsWith("windows")) {
    251                    if (fileName.length() > 2) {
    252                        final char ch1 = fileName.charAt(0);
    253                        final char ch2 = fileName.charAt(1);
    254
    255                        if (ch2 == ':' && (ch1 >= 'a' && ch1 <= 'z' || ch1 >= 'A' && ch1 <= 'Z')) {
    256                            fileName = fileName.substring(2);
    257                        }
    258                    }
    259                } else if (osName.contains("netware")) {
    260                    final int colon = fileName.indexOf(':');
    261                    if (colon != -1) {
    262                        fileName = fileName.substring(colon + 1);
    263                    }
    264                }
    265            }
    266        }
    267
    268        fileName = fileName.replace(File.separatorChar, '/');
    269
    270        // No absolute pathnames
    271        // Windows (and Posix?) paths can start with "\\NetworkDrive\",
    272        // so we loop on starting /'s.
    273        while (!preserveAbsolutePath && fileName.startsWith("/")) {
    274            fileName = fileName.substring(1);
    275        }
    276        return fileName;
    277    }
    278
    279    private static Instant parseInstantFromDecimalSeconds(final String value) throws IOException {
    280        // Validate field values to prevent denial of service attacks with BigDecimal values (see JDK-6560193)
    281        if (!value.matches(TarArchiveEntry.PAX_EXTENDED_HEADER_FILE_TIMES_PATTERN)) {
    282            throw new IOException("Corrupted PAX header. Time field value is invalid '" + value + "'");
    283        }
    284
    285        final BigDecimal epochSeconds = new BigDecimal(value);
    286        final long seconds = epochSeconds.longValue();
    287        final long nanos = epochSeconds.remainder(BigDecimal.ONE).movePointRight(9).longValue();
    288        return Instant.ofEpochSecond(seconds, nanos);
    289    }
    290
    291    /** The entry's name. */
    292    private String name = "";
    293
    294    /** Whether to allow leading slashes or drive names inside the name */
    295    private final boolean preserveAbsolutePath;
    296
    297    /** The entry's permission mode. */
    298    private int mode;
    299
    300    /** The entry's user id. */
    301    private long userId;
    302
    303    /** The entry's group id. */
    304    private long groupId;
    305
    306    /** The entry's size. */
    307    private long size;
    308    /**
    309     * The entry's modification time.
    310     * Corresponds to the POSIX {@code mtime} attribute.
    311     */
    312    private FileTime mTime;
    313
    314    /**
    315     * The entry's status change time.
    316     * Corresponds to the POSIX {@code ctime} attribute.
    317     *
    318     * @since 1.22
    319     */
    320    private FileTime cTime;
    321
    322    /**
    323     * The entry's last access time.
    324     * Corresponds to the POSIX {@code atime} attribute.
    325     *
    326     * @since 1.22
    327     */
    328    private FileTime aTime;
    329
    330    /**
    331     * The entry's creation time.
    332     * Corresponds to the POSIX {@code birthtime} attribute.
    333     *
    334     * @since 1.22
    335     */
    336    private FileTime birthTime;
    337
    338    /** If the header checksum is reasonably correct. */
    339    private boolean checkSumOK;
    340
    341    /** The entry's link flag. */
    342    private byte linkFlag;
    343
    344    /** The entry's link name. */
    345    private String linkName = "";
    346
    347    /** The entry's magic tag. */
    348    private String magic = MAGIC_POSIX;
    349
    350    /** The version of the format */
    351    private String version = VERSION_POSIX;
    352
    353    /** The entry's user name. */
    354    private String userName;
    355
    356    /** The entry's group name. */
    357    private String groupName = "";
    358
    359    /** The entry's major device number. */
    360    private int devMajor;
    361
    362    /** The entry's minor device number. */
    363    private int devMinor;
    364
    365    /** The sparse headers in tar */
    366    private List<TarArchiveStructSparse> sparseHeaders;
    367
    368    /** If an extension sparse header follows. */
    369    private boolean isExtended;
    370
    371    /** The entry's real size in case of a sparse file. */
    372    private long realSize;
    373
    374    /** is this entry a GNU sparse entry using one of the PAX formats? */
    375    private boolean paxGNUSparse;
    376
    377    /** is this entry a GNU sparse entry using 1.X PAX formats?
    378     *  the sparse headers of 1.x PAX Format is stored in file data block */
    379    private boolean paxGNU1XSparse;
    380
    381    /** is this entry a star sparse entry using the PAX header? */
    382    private boolean starSparse;
    383
    384    /** The entry's file reference */
    385    private final Path file;
    386
    387    /** The entry's file linkOptions*/
    388    private final LinkOption[] linkOptions;
    389
    390    /** Extra, user supplied pax headers     */
    391    private final Map<String,String> extraPaxHeaders = new HashMap<>();
    392
    393    private long dataOffset = EntryStreamOffsets.OFFSET_UNKNOWN;
    394
    395    /**
    396     * Construct an empty entry and prepares the header values.
    397     */
    398    private TarArchiveEntry(final boolean preserveAbsolutePath) {
    399        String user = System.getProperty("user.name", "");
    400
    401        if (user.length() > MAX_NAMELEN) {
    402            user = user.substring(0, MAX_NAMELEN);
    403        }
    404
    405        this.userName = user;
    406        this.file = null;
    407        this.linkOptions = IOUtils.EMPTY_LINK_OPTIONS;
    408        this.preserveAbsolutePath = preserveAbsolutePath;
    409    }
    410
    411    /**
    412     * Construct an entry from an archive's header bytes. File is set
    413     * to null.
    414     *
    415     * @param headerBuf The header bytes from a tar archive entry.
    416     * @throws IllegalArgumentException if any of the numeric fields have an invalid format
    417     */
    418    public TarArchiveEntry(final byte[] headerBuf) {
    419        this(false);
    420        parseTarHeader(headerBuf);
    421    }
    422
    423    /**
    424     * Construct an entry from an archive's header bytes. File is set
    425     * to null.
    426     *
    427     * @param headerBuf The header bytes from a tar archive entry.
    428     * @param encoding encoding to use for file names
    429     * @since 1.4
    430     * @throws IllegalArgumentException if any of the numeric fields have an invalid format
    431     * @throws IOException on error
    432     */
    433    public TarArchiveEntry(final byte[] headerBuf, final ZipEncoding encoding)
    434        throws IOException {
    435        this(headerBuf, encoding, false);
    436    }
    437
    438    /**
    439     * Construct an entry from an archive's header bytes. File is set
    440     * to null.
    441     *
    442     * @param headerBuf The header bytes from a tar archive entry.
    443     * @param encoding encoding to use for file names
    444     * @param lenient when set to true illegal values for group/userid, mode, device numbers and timestamp will be
    445     * ignored and the fields set to {@link #UNKNOWN}. When set to false such illegal fields cause an exception instead.
    446     * @since 1.19
    447     * @throws IllegalArgumentException if any of the numeric fields have an invalid format
    448     * @throws IOException on error
    449     */
    450    public TarArchiveEntry(final byte[] headerBuf, final ZipEncoding encoding, final boolean lenient)
    451        throws IOException {
    452        this(Collections.emptyMap(), headerBuf, encoding, lenient);
    453    }
    454
    455    /**
    456     * Construct an entry from an archive's header bytes for random access tar. File is set to null.
    457     * @param headerBuf the header bytes from a tar archive entry.
    458     * @param encoding encoding to use for file names.
    459     * @param lenient when set to true illegal values for group/userid, mode, device numbers and timestamp will be
    460     * ignored and the fields set to {@link #UNKNOWN}. When set to false such illegal fields cause an exception instead.
    461     * @param dataOffset position of the entry data in the random access file.
    462     * @since 1.21
    463     * @throws IllegalArgumentException if any of the numeric fields have an invalid format.
    464     * @throws IOException on error.
    465     */
    466    public TarArchiveEntry(final byte[] headerBuf, final ZipEncoding encoding, final boolean lenient,
    467            final long dataOffset) throws IOException {
    468        this(headerBuf, encoding, lenient);
    469        setDataOffset(dataOffset);
    470    }
    471
    472    /**
    473     * Construct an entry for a file. File is set to file, and the
    474     * header is constructed from information from the file.
    475     * The name is set from the normalized file path.
    476     *
    477     * <p>The entry's name will be the value of the {@code file}'s
    478     * path with all file separators replaced by forward slashes and
    479     * leading slashes as well as Windows drive letters stripped. The
    480     * name will end in a slash if the {@code file} represents a
    481     * directory.</p>
    482     *
    483     * <p>Note: Since 1.21 this internally uses the same code as the
    484     * TarArchiveEntry constructors with a {@link Path} as parameter.
    485     * But all thrown exceptions are ignored. If handling those
    486     * exceptions is needed consider switching to the path constructors.</p>
    487     *
    488     * @param file The file that the entry represents.
    489     */
    490    public TarArchiveEntry(final File file) {
    491        this(file, file.getPath());
    492    }
    493
    494    /**
    495     * Construct an entry for a file. File is set to file, and the
    496     * header is constructed from information from the file.
    497     *
    498     * <p>The entry's name will be the value of the {@code fileName}
    499     * argument with all file separators replaced by forward slashes
    500     * and leading slashes as well as Windows drive letters stripped.
    501     * The name will end in a slash if the {@code file} represents a
    502     * directory.</p>
    503     *
    504     * <p>Note: Since 1.21 this internally uses the same code as the
    505     * TarArchiveEntry constructors with a {@link Path} as parameter.
    506     * But all thrown exceptions are ignored. If handling those
    507     * exceptions is needed consider switching to the path constructors.</p>
    508     *
    509     * @param file The file that the entry represents.
    510     * @param fileName the name to be used for the entry.
    511     */
    512    public TarArchiveEntry(final File file, final String fileName) {
    513        final String normalizedName = normalizeFileName(fileName, false);
    514        this.file = file.toPath();
    515        this.linkOptions = IOUtils.EMPTY_LINK_OPTIONS;
    516
    517        try {
    518            readFileMode(this.file, normalizedName);
    519        } catch (final IOException e) {
    520            // Ignore exceptions from NIO for backwards compatibility
    521            // Fallback to get size of file if it's no directory to the old file api
    522            if (!file.isDirectory()) {
    523                this.size = file.length();
    524            }
    525        }
    526
    527        this.userName = "";
    528        try {
    529            readOsSpecificProperties(this.file);
    530        } catch (final IOException e) {
    531            // Ignore exceptions from NIO for backwards compatibility
    532            // Fallback to get the last modified date of the file from the old file api
    533            this.mTime = FileTime.fromMillis(file.lastModified());
    534        }
    535        preserveAbsolutePath = false;
    536    }
    537
    538    /**
    539     * Construct an entry from an archive's header bytes. File is set to null.
    540     *
    541     * @param globalPaxHeaders the parsed global PAX headers, or null if this is the first one.
    542     * @param headerBuf The header bytes from a tar archive entry.
    543     * @param encoding encoding to use for file names
    544     * @param lenient when set to true illegal values for group/userid, mode, device numbers and timestamp will be
    545     * ignored and the fields set to {@link #UNKNOWN}. When set to false such illegal fields cause an exception instead.
    546     * @since 1.22
    547     * @throws IllegalArgumentException if any of the numeric fields have an invalid format
    548     * @throws IOException on error
    549     */
    550    public TarArchiveEntry(final Map<String, String> globalPaxHeaders, final byte[] headerBuf,
    551            final ZipEncoding encoding, final boolean lenient) throws IOException {
    552        this(false);
    553        parseTarHeader(globalPaxHeaders, headerBuf, encoding, false, lenient);
    554    }
    555
    556    /**
    557     * Construct an entry from an archive's header bytes for random access tar. File is set to null.
    558     * @param globalPaxHeaders the parsed global PAX headers, or null if this is the first one.
    559     * @param headerBuf the header bytes from a tar archive entry.
    560     * @param encoding encoding to use for file names.
    561     * @param lenient when set to true illegal values for group/userid, mode, device numbers and timestamp will be
    562     * ignored and the fields set to {@link #UNKNOWN}. When set to false such illegal fields cause an exception instead.
    563     * @param dataOffset position of the entry data in the random access file.
    564     * @since 1.22
    565     * @throws IllegalArgumentException if any of the numeric fields have an invalid format.
    566     * @throws IOException on error.
    567     */
    568    public TarArchiveEntry(final Map<String, String> globalPaxHeaders, final byte[] headerBuf,
    569            final ZipEncoding encoding, final boolean lenient, final long dataOffset) throws IOException {
    570        this(globalPaxHeaders, headerBuf, encoding, lenient);
    571        setDataOffset(dataOffset);
    572    }
    573
    574    /**
    575     * Construct an entry for a file. File is set to file, and the
    576     * header is constructed from information from the file.
    577     * The name is set from the normalized file path.
    578     *
    579     * <p>The entry's name will be the value of the {@code file}'s
    580     * path with all file separators replaced by forward slashes and
    581     * leading slashes as well as Windows drive letters stripped. The
    582     * name will end in a slash if the {@code file} represents a
    583     * directory.</p>
    584     *
    585     * @param file The file that the entry represents.
    586     * @throws IOException if an I/O error occurs
    587     * @since 1.21
    588     */
    589    public TarArchiveEntry(final Path file) throws IOException {
    590        this(file, file.toString());
    591    }
    592
    593    /**
    594     * Construct an entry for a file. File is set to file, and the
    595     * header is constructed from information from the file.
    596     *
    597     * <p>The entry's name will be the value of the {@code fileName}
    598     * argument with all file separators replaced by forward slashes
    599     * and leading slashes as well as Windows drive letters stripped.
    600     * The name will end in a slash if the {@code file} represents a
    601     * directory.</p>
    602     *
    603     * @param file     The file that the entry represents.
    604     * @param fileName the name to be used for the entry.
    605     * @param linkOptions options indicating how symbolic links are handled.
    606     * @throws IOException if an I/O error occurs
    607     * @since 1.21
    608     */
    609    public TarArchiveEntry(final Path file, final String fileName, final LinkOption... linkOptions) throws IOException {
    610        final String normalizedName = normalizeFileName(fileName, false);
    611        this.file = file;
    612        this.linkOptions = linkOptions == null ? IOUtils.EMPTY_LINK_OPTIONS : linkOptions;
    613
    614        readFileMode(file, normalizedName, linkOptions);
    615
    616        this.userName = "";
    617        readOsSpecificProperties(file);
    618        preserveAbsolutePath = false;
    619    }
    620
    621    /**
    622     * Construct an entry with only a name. This allows the programmer
    623     * to construct the entry's header "by hand". File is set to null.
    624     *
    625     * <p>The entry's name will be the value of the {@code name}
    626     * argument with all file separators replaced by forward slashes
    627     * and leading slashes as well as Windows drive letters stripped.</p>
    628     *
    629     * @param name the entry name
    630     */
    631    public TarArchiveEntry(final String name) {
    632        this(name, false);
    633    }
    634
    635    /**
    636     * Construct an entry with only a name. This allows the programmer
    637     * to construct the entry's header "by hand". File is set to null.
    638     *
    639     * <p>The entry's name will be the value of the {@code name}
    640     * argument with all file separators replaced by forward slashes.
    641     * Leading slashes and Windows drive letters are stripped if
    642     * {@code preserveAbsolutePath} is {@code false}.</p>
    643     *
    644     * @param name the entry name
    645     * @param preserveAbsolutePath whether to allow leading slashes
    646     * or drive letters in the name.
    647     *
    648     * @since 1.1
    649     */
    650    public TarArchiveEntry(String name, final boolean preserveAbsolutePath) {
    651        this(preserveAbsolutePath);
    652
    653        name = normalizeFileName(name, preserveAbsolutePath);
    654        final boolean isDir = name.endsWith("/");
    655
    656        this.name = name;
    657        this.mode = isDir ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE;
    658        this.linkFlag = isDir ? LF_DIR : LF_NORMAL;
    659        this.mTime = FileTime.from(Instant.now());
    660        this.userName = "";
    661    }
    662
    663    /**
    664     * Construct an entry with a name and a link flag.
    665     *
    666     * <p>The entry's name will be the value of the {@code name}
    667     * argument with all file separators replaced by forward slashes
    668     * and leading slashes as well as Windows drive letters
    669     * stripped.</p>
    670     *
    671     * @param name the entry name
    672     * @param linkFlag the entry link flag.
    673     */
    674    public TarArchiveEntry(final String name, final byte linkFlag) {
    675        this(name, linkFlag, false);
    676    }
    677
    678    /**
    679     * Construct an entry with a name and a link flag.
    680     *
    681     * <p>The entry's name will be the value of the {@code name}
    682     * argument with all file separators replaced by forward slashes.
    683     * Leading slashes and Windows drive letters are stripped if
    684     * {@code preserveAbsolutePath} is {@code false}.</p>
    685     *
    686     * @param name the entry name
    687     * @param linkFlag the entry link flag.
    688     * @param preserveAbsolutePath whether to allow leading slashes
    689     * or drive letters in the name.
    690     *
    691     * @since 1.5
    692     */
    693    public TarArchiveEntry(final String name, final byte linkFlag, final boolean preserveAbsolutePath) {
    694        this(name, preserveAbsolutePath);
    695        this.linkFlag = linkFlag;
    696        if (linkFlag == LF_GNUTYPE_LONGNAME) {
    697            magic = MAGIC_GNU;
    698            version = VERSION_GNU_SPACE;
    699        }
    700    }
    701
    702    /**
    703     * add a PAX header to this entry. If the header corresponds to an existing field in the entry,
    704     * that field will be set; otherwise the header will be added to the extraPaxHeaders Map
    705     * @param name  The full name of the header to set.
    706     * @param value value of header.
    707     * @since 1.15
    708     */
    709    public void addPaxHeader(final String name, final String value) {
    710        try {
    711            processPaxHeader(name, value);
    712        } catch (final IOException ex) {
    713            throw new IllegalArgumentException("Invalid input", ex);
    714        }
    715    }
    716
    717    /**
    718     * clear all extra PAX headers.
    719     * @since 1.15
    720     */
    721    public void clearExtraPaxHeaders() {
    722        extraPaxHeaders.clear();
    723    }
    724
    725    /**
    726     * Determine if the two entries are equal. Equality is determined
    727     * by the header names being equal.
    728     *
    729     * @param it Entry to be checked for equality.
    730     * @return True if the entries are equal.
    731     */
    732    @Override
    733    public boolean equals(final Object it) {
    734        if (it == null || getClass() != it.getClass()) {
    735            return false;
    736        }
    737        return equals((TarArchiveEntry) it);
    738    }
    739
    740    /**
    741     * Determine if the two entries are equal. Equality is determined
    742     * by the header names being equal.
    743     *
    744     * @param it Entry to be checked for equality.
    745     * @return True if the entries are equal.
    746     */
    747    public boolean equals(final TarArchiveEntry it) {
    748        return it != null && getName().equals(it.getName());
    749    }
    750
    751    /**
    752     * Evaluate an entry's header format from a header buffer.
    753     *
    754     * @param header The tar entry header buffer to evaluate the format for.
    755     * @return format type
    756     */
    757    private int evaluateType(final Map<String, String> globalPaxHeaders, final byte[] header) {
    758        if (ArchiveUtils.matchAsciiBuffer(MAGIC_GNU, header, MAGIC_OFFSET, MAGICLEN)) {
    759            return FORMAT_OLDGNU;
    760        }
    761        if (ArchiveUtils.matchAsciiBuffer(MAGIC_POSIX, header, MAGIC_OFFSET, MAGICLEN)) {
    762            if (isXstar(globalPaxHeaders, header)) {
    763                return FORMAT_XSTAR;
    764            }
    765            return FORMAT_POSIX;
    766        }
    767        return 0;
    768    }
    769
    770    private int fill(final byte value, final int offset, final byte[] outbuf, final int length) {
    771        for (int i = 0; i < length; i++) {
    772            outbuf[offset + i] = value;
    773        }
    774        return offset + length;
    775    }
    776
    777    private int fill(final int value, final int offset, final byte[] outbuf, final int length) {
    778        return fill((byte) value, offset, outbuf, length);
    779    }
    780
    781    void fillGNUSparse0xData(final Map<String, String> headers) {
    782        paxGNUSparse = true;
    783        realSize = Integer.parseInt(headers.get(TarGnuSparseKeys.SIZE));
    784        if (headers.containsKey(TarGnuSparseKeys.NAME)) {
    785            // version 0.1
    786            name = headers.get(TarGnuSparseKeys.NAME);
    787        }
    788    }
    789
    790    void fillGNUSparse1xData(final Map<String, String> headers) throws IOException {
    791        paxGNUSparse = true;
    792        paxGNU1XSparse = true;
    793        if (headers.containsKey(TarGnuSparseKeys.NAME)) {
    794            name = headers.get(TarGnuSparseKeys.NAME);
    795        }
    796        if (headers.containsKey(TarGnuSparseKeys.REALSIZE)) {
    797            try {
    798                realSize = Integer.parseInt(headers.get(TarGnuSparseKeys.REALSIZE));
    799            } catch (final NumberFormatException ex) {
    800                throw new IOException("Corrupted TAR archive. GNU.sparse.realsize header for "
    801                    + name + " contains non-numeric value");
    802            }
    803        }
    804    }
    805
    806    void fillStarSparseData(final Map<String, String> headers) throws IOException {
    807        starSparse = true;
    808        if (headers.containsKey("SCHILY.realsize")) {
    809            try {
    810                realSize = Long.parseLong(headers.get("SCHILY.realsize"));
    811            } catch (final NumberFormatException ex) {
    812                throw new IOException("Corrupted TAR archive. SCHILY.realsize header for "
    813                    + name + " contains non-numeric value");
    814            }
    815        }
    816    }
    817
    818    /**
    819     * Get this entry's creation time.
    820     *
    821     * @since 1.22
    822     * @return This entry's computed creation time.
    823     */
    824    public FileTime getCreationTime() {
    825        return birthTime;
    826    }
    827
    828    /**
    829     * {@inheritDoc}
    830     * @since 1.21
    831     */
    832    @Override
    833    public long getDataOffset() {
    834        return dataOffset;
    835    }
    836
    837    /**
    838     * Get this entry's major device number.
    839     *
    840     * @return This entry's major device number.
    841     * @since 1.4
    842     */
    843    public int getDevMajor() {
    844        return devMajor;
    845    }
    846
    847    /**
    848     * Get this entry's minor device number.
    849     *
    850     * @return This entry's minor device number.
    851     * @since 1.4
    852     */
    853    public int getDevMinor() {
    854        return devMinor;
    855    }
    856
    857    /**
    858     * If this entry represents a file, and the file is a directory, return
    859     * an array of TarEntries for this entry's children.
    860     *
    861     * <p>This method is only useful for entries created from a {@code
    862     * File} or {@code Path} but not for entries read from an archive.</p>
    863     *
    864     * @return An array of TarEntry's for this entry's children.
    865     */
    866    public TarArchiveEntry[] getDirectoryEntries() {
    867        if (file == null || !isDirectory()) {
    868            return EMPTY_TAR_ARCHIVE_ENTRY_ARRAY;
    869        }
    870
    871        final List<TarArchiveEntry> entries = new ArrayList<>();
    872        try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(file)) {
    873            for (final Path p : dirStream) {
    874                entries.add(new TarArchiveEntry(p));
    875            }
    876        } catch (final IOException e) {
    877            return EMPTY_TAR_ARCHIVE_ENTRY_ARRAY;
    878        }
    879        return entries.toArray(EMPTY_TAR_ARCHIVE_ENTRY_ARRAY);
    880    }
    881
    882    /**
    883     * get named extra PAX header
    884     * @param name The full name of an extended PAX header to retrieve
    885     * @return The value of the header, if any.
    886     * @since 1.15
    887     */
    888    public String getExtraPaxHeader(final String name) {
    889        return extraPaxHeaders.get(name);
    890    }
    891
    892    /**
    893     * get extra PAX Headers
    894     * @return read-only map containing any extra PAX Headers
    895     * @since 1.15
    896     */
    897    public Map<String, String> getExtraPaxHeaders() {
    898        return Collections.unmodifiableMap(extraPaxHeaders);
    899    }
    900
    901    /**
    902     * Get this entry's file.
    903     *
    904     * <p>This method is only useful for entries created from a {@code
    905     * File} or {@code Path} but not for entries read from an archive.</p>
    906     *
    907     * @return this entry's file or null if the entry was not created from a file.
    908     */
    909    public File getFile() {
    910        if (file == null) {
    911            return null;
    912        }
    913        return file.toFile();
    914    }
    915
    916    /**
    917     * Get this entry's group id.
    918     *
    919     * @return This entry's group id.
    920     * @deprecated use #getLongGroupId instead as group ids can be
    921     * bigger than {@link Integer#MAX_VALUE}
    922     */
    923    @Deprecated
    924    public int getGroupId() {
    925        return (int) (groupId & 0xffffffff);
    926    }
    927
    928    /**
    929     * Get this entry's group name.
    930     *
    931     * @return This entry's group name.
    932     */
    933    public String getGroupName() {
    934        return groupName;
    935    }
    936
    937    /**
    938     * Get this entry's last access time.
    939     *
    940     * @since 1.22
    941     * @return This entry's last access time.
    942     */
    943    public FileTime getLastAccessTime() {
    944        return aTime;
    945    }
    946
    947    /**
    948     * Get this entry's modification time.
    949     * This is equivalent to {@link TarArchiveEntry#getLastModifiedTime()}, but precision is truncated to milliseconds.
    950     *
    951     * @return This entry's modification time.
    952     * @see TarArchiveEntry#getLastModifiedTime()
    953     */
    954    @Override
    955    public Date getLastModifiedDate() {
    956        return getModTime();
    957    }
    958
    959    /**
    960     * Get this entry's modification time.
    961     *
    962     * @since 1.22
    963     * @return This entry's modification time.
    964     */
    965    public FileTime getLastModifiedTime() {
    966        return mTime;
    967    }
    968
    969    /**
    970     * Get this entry's link flag.
    971     *
    972     * @return this entry's link flag.
    973     * @since 1.23
    974     */
    975    public byte getLinkFlag() {
    976        return this.linkFlag;
    977    }
    978
    979    /**
    980     * Get this entry's link name.
    981     *
    982     * @return This entry's link name.
    983     */
    984    public String getLinkName() {
    985        return linkName;
    986    }
    987
    988    /**
    989     * Get this entry's group id.
    990     *
    991     * @since 1.10
    992     * @return This entry's group id.
    993     */
    994    public long getLongGroupId() {
    995        return groupId;
    996    }
    997
    998    /**
    999     * Get this entry's user id.
    1000     *
    1001     * @return This entry's user id.
    1002     * @since 1.10
    1003     */
    1004    public long getLongUserId() {
    1005        return userId;
    1006    }
    1007
    1008    /**
    1009     * Get this entry's mode.
    1010     *
    1011     * @return This entry's mode.
    1012     */
    1013    public int getMode() {
    1014        return mode;
    1015    }
    1016
    1017    /**
    1018     * Get this entry's modification time.
    1019     * This is equivalent to {@link TarArchiveEntry#getLastModifiedTime()}, but precision is truncated to milliseconds.
    1020     *
    1021     * @return This entry's modification time.
    1022     * @see TarArchiveEntry#getLastModifiedTime()
    1023     */
    1024    public Date getModTime() {
    1025        return TimeUtils.toDate(mTime);
    1026    }
    1027
    1028    /**
    1029     * Get this entry's name.
    1030     *
    1031     * <p>This method returns the raw name as it is stored inside of the archive.</p>
    1032     *
    1033     * @return This entry's name.
    1034     */
    1035    @Override
    1036    public String getName() {
    1037        return name;
    1038    }
    1039
    1040    /**
    1041     * Get this entry's sparse headers ordered by offset with all empty sparse sections at the start filtered out.
    1042     *
    1043     * @return immutable list of this entry's sparse headers, never null
    1044     * @since 1.21
    1045     * @throws IOException if the list of sparse headers contains blocks that overlap
    1046     */
    1047    public List<TarArchiveStructSparse> getOrderedSparseHeaders() throws IOException {
    1048        if (sparseHeaders == null || sparseHeaders.isEmpty()) {
    1049            return Collections.emptyList();
    1050        }
    1051        final List<TarArchiveStructSparse> orderedAndFiltered = sparseHeaders.stream()
    1052            .filter(s -> s.getOffset() > 0 || s.getNumbytes() > 0)
    1053            .sorted(Comparator.comparingLong(TarArchiveStructSparse::getOffset))
    1054            .collect(Collectors.toList());
    1055
    1056        final int numberOfHeaders = orderedAndFiltered.size();
    1057        for (int i = 0; i < numberOfHeaders; i++) {
    1058            final TarArchiveStructSparse str = orderedAndFiltered.get(i);
    1059            if (i + 1 < numberOfHeaders
    1060                && str.getOffset() + str.getNumbytes() > orderedAndFiltered.get(i + 1).getOffset()) {
    1061                throw new IOException("Corrupted TAR archive. Sparse blocks for "
    1062                    + getName() + " overlap each other.");
    1063            }
    1064            if (str.getOffset() + str.getNumbytes() < 0) {
    1065                // integer overflow?
    1066                throw new IOException("Unreadable TAR archive. Offset and numbytes for sparse block in "
    1067                    + getName() + " too large.");
    1068            }
    1069        }
    1070        if (!orderedAndFiltered.isEmpty()) {
    1071            final TarArchiveStructSparse last = orderedAndFiltered.get(numberOfHeaders - 1);
    1072            if (last.getOffset() + last.getNumbytes() > getRealSize()) {
    1073                throw new IOException("Corrupted TAR archive. Sparse block extends beyond real size of the entry");
    1074            }
    1075        }
    1076
    1077        return orderedAndFiltered;
    1078    }
    1079
    1080    /**
    1081     * Get this entry's file.
    1082     *
    1083     * <p>This method is only useful for entries created from a {@code
    1084     * File} or {@code Path} but not for entries read from an archive.</p>
    1085     *
    1086     * @return this entry's file or null if the entry was not created from a file.
    1087     * @since 1.21
    1088     */
    1089    public Path getPath() {
    1090        return file;
    1091    }
    1092
    1093    /**
    1094     * Get this entry's real file size in case of a sparse file.
    1095     *
    1096     * <p>This is the size a file would take on disk if the entry was expanded.</p>
    1097     *
    1098     * <p>If the file is not a sparse file, return size instead of realSize.</p>
    1099     *
    1100     * @return This entry's real file size, if the file is not a sparse file, return size instead of realSize.
    1101     */
    1102    public long getRealSize() {
    1103        if (!isSparse()) {
    1104            return getSize();
    1105        }
    1106        return realSize;
    1107    }
    1108
    1109    /**
    1110     * Get this entry's file size.
    1111     *
    1112     * <p>This is the size the entry's data uses inside the archive. Usually this is the same as {@link
    1113     * #getRealSize}, but it doesn't take the "holes" into account when the entry represents a sparse file.
    1114     *
    1115     * @return This entry's file size.
    1116     */
    1117    @Override
    1118    public long getSize() {
    1119        return size;
    1120    }
    1121
    1122    /**
    1123     * Get this entry's sparse headers
    1124     *
    1125     * @return This entry's sparse headers
    1126     * @since 1.20
    1127     */
    1128    public List<TarArchiveStructSparse> getSparseHeaders() {
    1129        return sparseHeaders;
    1130    }
    1131
    1132    /**
    1133     * Get this entry's status change time.
    1134     *
    1135     * @since 1.22
    1136     * @return This entry's status change time.
    1137     */
    1138    public FileTime getStatusChangeTime() {
    1139        return cTime;
    1140    }
    1141
    1142    /**
    1143     * Get this entry's user id.
    1144     *
    1145     * @return This entry's user id.
    1146     * @deprecated use #getLongUserId instead as user ids can be
    1147     * bigger than {@link Integer#MAX_VALUE}
    1148     */
    1149    @Deprecated
    1150    public int getUserId() {
    1151        return (int) (userId & 0xffffffff);
    1152    }
    1153
    1154    /**
    1155     * Get this entry's user name.
    1156     *
    1157     * @return This entry's user name.
    1158     */
    1159    public String getUserName() {
    1160        return userName;
    1161    }
    1162
    1163    /**
    1164     * Hashcodes are based on entry names.
    1165     *
    1166     * @return the entry hash code
    1167     */
    1168    @Override
    1169    public int hashCode() {
    1170        return getName().hashCode();
    1171    }
    1172
    1173    /**
    1174     * Check if this is a block device entry.
    1175     *
    1176     * @since 1.2
    1177     * @return whether this is a block device
    1178     */
    1179    public boolean isBlockDevice() {
    1180        return linkFlag == LF_BLK;
    1181    }
    1182
    1183    /**
    1184     * Check if this is a character device entry.
    1185     *
    1186     * @since 1.2
    1187     * @return whether this is a character device
    1188     */
    1189    public boolean isCharacterDevice() {
    1190        return linkFlag == LF_CHR;
    1191    }
    1192
    1193    /**
    1194     * Get this entry's checksum status.
    1195     *
    1196     * @return if the header checksum is reasonably correct
    1197     * @see TarUtils#verifyCheckSum(byte[])
    1198     * @since 1.5
    1199     */
    1200    public boolean isCheckSumOK() {
    1201        return checkSumOK;
    1202    }
    1203
    1204    /**
    1205     * Determine if the given entry is a descendant of this entry.
    1206     * Descendancy is determined by the name of the descendant
    1207     * starting with this entry's name.
    1208     *
    1209     * @param desc Entry to be checked as a descendent of this.
    1210     * @return True if entry is a descendant of this.
    1211     */
    1212    public boolean isDescendent(final TarArchiveEntry desc) {
    1213        return desc.getName().startsWith(getName());
    1214    }
    1215
    1216    /**
    1217     * Return whether or not this entry represents a directory.
    1218     *
    1219     * @return True if this entry is a directory.
    1220     */
    1221    @Override
    1222    public boolean isDirectory() {
    1223        if (file != null) {
    1224            return Files.isDirectory(file, linkOptions);
    1225        }
    1226
    1227        if (linkFlag == LF_DIR) {
    1228            return true;
    1229        }
    1230
    1231        return !isPaxHeader() && !isGlobalPaxHeader() && getName().endsWith("/");
    1232    }
    1233
    1234    /**
    1235     * Indicates in case of an oldgnu sparse file if an extension
    1236     * sparse header follows.
    1237     *
    1238     * @return true if an extension oldgnu sparse header follows.
    1239     */
    1240    public boolean isExtended() {
    1241        return isExtended;
    1242    }
    1243
    1244    /**
    1245     * Check if this is a FIFO (pipe) entry.
    1246     *
    1247     * @since 1.2
    1248     * @return whether this is a FIFO entry
    1249     */
    1250    public boolean isFIFO() {
    1251        return linkFlag == LF_FIFO;
    1252    }
    1253
    1254    /**
    1255     * Check if this is a "normal file"
    1256     *
    1257     * @since 1.2
    1258     * @return whether this is a "normal file"
    1259     */
    1260    public boolean isFile() {
    1261        if (file != null) {
    1262            return Files.isRegularFile(file, linkOptions);
    1263        }
    1264        if (linkFlag == LF_OLDNORM || linkFlag == LF_NORMAL) {
    1265            return true;
    1266        }
    1267        return !getName().endsWith("/");
    1268    }
    1269
    1270    /**
    1271     * Check if this is a Pax header.
    1272     *
    1273     * @return {@code true} if this is a Pax header.
    1274     *
    1275     * @since 1.1
    1276     */
    1277    public boolean isGlobalPaxHeader() {
    1278        return linkFlag == LF_PAX_GLOBAL_EXTENDED_HEADER;
    1279    }
    1280
    1281    /**
    1282     * Indicate if this entry is a GNU long linkname block
    1283     *
    1284     * @return true if this is a long name extension provided by GNU tar
    1285     */
    1286    public boolean isGNULongLinkEntry() {
    1287        return linkFlag == LF_GNUTYPE_LONGLINK;
    1288    }
    1289
    1290    /**
    1291     * Indicate if this entry is a GNU long name block
    1292     *
    1293     * @return true if this is a long name extension provided by GNU tar
    1294     */
    1295    public boolean isGNULongNameEntry() {
    1296        return linkFlag == LF_GNUTYPE_LONGNAME;
    1297    }
    1298
    1299    /**
    1300     * Indicate if this entry is a GNU sparse block.
    1301     *
    1302     * @return true if this is a sparse extension provided by GNU tar
    1303     */
    1304    public boolean isGNUSparse() {
    1305        return isOldGNUSparse() || isPaxGNUSparse();
    1306    }
    1307
    1308    private boolean isInvalidPrefix(final byte[] header) {
    1309        // prefix[130] is guaranteed to be '\0' with XSTAR/XUSTAR
    1310        if (header[XSTAR_PREFIX_OFFSET + 130] != 0) {
    1311            // except when typeflag is 'M'
    1312            if (header[LF_OFFSET] != LF_MULTIVOLUME) {
    1313                return true;
    1314            }
    1315            // We come only here if we try to read in a GNU/xstar/xustar multivolume archive starting past volume #0
    1316            // As of 1.22, commons-compress does not support multivolume tar archives.
    1317            // If/when it does, this should work as intended.
    1318            if ((header[XSTAR_MULTIVOLUME_OFFSET] & 0x80) == 0
    1319                    && header[XSTAR_MULTIVOLUME_OFFSET + 11] != ' ') {
    1320                return true;
    1321            }
    1322        }
    1323        return false;
    1324    }
    1325
    1326    private boolean isInvalidXtarTime(final byte[] buffer, final int offset, final int length) {
    1327        // If atime[0]...atime[10] or ctime[0]...ctime[10] is not a POSIX octal number it cannot be 'xstar'.
    1328        if ((buffer[offset] & 0x80) == 0) {
    1329            final int lastIndex = length - 1;
    1330            for (int i = 0; i < lastIndex; i++) {
    1331                final byte b = buffer[offset + i];
    1332                if (b < '0' || b > '7') {
    1333                    return true;
    1334                }
    1335            }
    1336            // Check for both POSIX compliant end of number characters if not using base 256
    1337            final byte b = buffer[offset + lastIndex];
    1338            if (b != ' ' && b != 0) {
    1339                return true;
    1340            }
    1341        }
    1342        return false;
    1343    }
    1344
    1345    /**
    1346     * Check if this is a link entry.
    1347     *
    1348     * @since 1.2
    1349     * @return whether this is a link entry
    1350     */
    1351    public boolean isLink() {
    1352        return linkFlag == LF_LINK;
    1353    }
    1354
    1355    /**
    1356     * Indicate if this entry is a GNU or star sparse block using the
    1357     * oldgnu format.
    1358     *
    1359     * @return true if this is a sparse extension provided by GNU tar or star
    1360     * @since 1.11
    1361     */
    1362    public boolean isOldGNUSparse() {
    1363        return linkFlag == LF_GNUTYPE_SPARSE;
    1364    }
    1365
    1366    /**
    1367     * Get if this entry is a sparse file with 1.X PAX Format or not
    1368     *
    1369     * @return True if this entry is a sparse file with 1.X PAX Format
    1370     * @since 1.20
    1371     */
    1372    public boolean isPaxGNU1XSparse() {
    1373        return paxGNU1XSparse;
    1374    }
    1375
    1376    /**
    1377     * Indicate if this entry is a GNU sparse block using one of the
    1378     * PAX formats.
    1379     *
    1380     * @return true if this is a sparse extension provided by GNU tar
    1381     * @since 1.11
    1382     */
    1383    public boolean isPaxGNUSparse() {
    1384        return paxGNUSparse;
    1385    }
    1386
    1387    /**
    1388     * Check if this is a Pax header.
    1389     *
    1390     * @return {@code true} if this is a Pax header.
    1391     *
    1392     * @since 1.1
    1393     *
    1394     */
    1395    public boolean isPaxHeader() {
    1396        return linkFlag == LF_PAX_EXTENDED_HEADER_LC
    1397            || linkFlag == LF_PAX_EXTENDED_HEADER_UC;
    1398    }
    1399
    1400    /**
    1401     * Check whether this is a sparse entry.
    1402     *
    1403     * @return whether this is a sparse entry
    1404     * @since 1.11
    1405     */
    1406    public boolean isSparse() {
    1407        return isGNUSparse() || isStarSparse();
    1408    }
    1409
    1410    /**
    1411     * Indicate if this entry is a star sparse block using PAX headers.
    1412     *
    1413     * @return true if this is a sparse extension provided by star
    1414     * @since 1.11
    1415     */
    1416    public boolean isStarSparse() {
    1417        return starSparse;
    1418    }
    1419
    1420    /**
    1421     * {@inheritDoc}
    1422     * @since 1.21
    1423     */
    1424    @Override
    1425    public boolean isStreamContiguous() {
    1426        return true;
    1427    }
    1428
    1429    /**
    1430     * Check if this is a symbolic link entry.
    1431     *
    1432     * @since 1.2
    1433     * @return whether this is a symbolic link
    1434     */
    1435    public boolean isSymbolicLink() {
    1436        return linkFlag == LF_SYMLINK;
    1437    }
    1438
    1439    /**
    1440     * Check for XSTAR / XUSTAR format.
    1441     *
    1442     * Use the same logic found in star version 1.6 in {@code header.c}, function {@code isxmagic(TCB *ptb)}.
    1443     */
    1444    private boolean isXstar(final Map<String, String> globalPaxHeaders, final byte[] header) {
    1445        // Check if this is XSTAR
    1446        if (ArchiveUtils.matchAsciiBuffer(MAGIC_XSTAR, header, XSTAR_MAGIC_OFFSET, XSTAR_MAGIC_LEN)) {
    1447            return true;
    1448        }
    1449
    1450        /*
    1451        If SCHILY.archtype is present in the global PAX header, we can use it to identify the type of archive.
    1452
    1453        Possible values for XSTAR:
    1454        - xustar: 'xstar' format without "tar" signature at header offset 508.
    1455        - exustar: 'xustar' format variant that always includes x-headers and g-headers.
    1456         */
    1457        final String archType = globalPaxHeaders.get("SCHILY.archtype");
    1458        if (archType != null) {
    1459            return "xustar".equals(archType) || "exustar".equals(archType);
    1460        }
    1461
    1462        // Check if this is XUSTAR
    1463        if (isInvalidPrefix(header)) {
    1464            return false;
    1465        }
    1466        if (isInvalidXtarTime(header, XSTAR_ATIME_OFFSET, ATIMELEN_XSTAR)) {
    1467            return false;
    1468        }
    1469        if (isInvalidXtarTime(header, XSTAR_CTIME_OFFSET, CTIMELEN_XSTAR)) {
    1470            return false;
    1471        }
    1472
    1473        return true;
    1474    }
    1475
    1476    private long parseOctalOrBinary(final byte[] header, final int offset, final int length, final boolean lenient) {
    1477        if (lenient) {
    1478            try {
    1479                return TarUtils.parseOctalOrBinary(header, offset, length);
    1480            } catch (final IllegalArgumentException ex) { //NOSONAR
    1481                return UNKNOWN;
    1482            }
    1483        }
    1484        return TarUtils.parseOctalOrBinary(header, offset, length);
    1485    }
    1486
    1487    /**
    1488     * Parse an entry's header information from a header buffer.
    1489     *
    1490     * @param header The tar entry header buffer to get information from.
    1491     * @throws IllegalArgumentException if any of the numeric fields have an invalid format
    1492     */
    1493    public void parseTarHeader(final byte[] header) {
    1494        try {
    1495            parseTarHeader(header, TarUtils.DEFAULT_ENCODING);
    1496        } catch (final IOException ex) { // NOSONAR
    1497            try {
    1498                parseTarHeader(header, TarUtils.DEFAULT_ENCODING, true, false);
    1499            } catch (final IOException ex2) {
    1500                // not really possible
    1501                throw new UncheckedIOException(ex2); //NOSONAR
    1502            }
    1503        }
    1504    }
    1505
    1506    /**
    1507     * Parse an entry's header information from a header buffer.
    1508     *
    1509     * @param header The tar entry header buffer to get information from.
    1510     * @param encoding encoding to use for file names
    1511     * @since 1.4
    1512     * @throws IllegalArgumentException if any of the numeric fields
    1513     * have an invalid format
    1514     * @throws IOException on error
    1515     */
    1516    public void parseTarHeader(final byte[] header, final ZipEncoding encoding)
    1517        throws IOException {
    1518        parseTarHeader(header, encoding, false, false);
    1519    }
    1520
    1521    private void parseTarHeader(final byte[] header, final ZipEncoding encoding,
    1522                                final boolean oldStyle, final boolean lenient)
    1523        throws IOException {
    1524        parseTarHeader(Collections.emptyMap(), header, encoding, oldStyle, lenient);
    1525    }
    1526
    1527    private void parseTarHeader(final Map<String, String> globalPaxHeaders, final byte[] header,
    1528                                final ZipEncoding encoding, final boolean oldStyle, final boolean lenient)
    1529        throws IOException {
    1530        try {
    1531            parseTarHeaderUnwrapped(globalPaxHeaders, header, encoding, oldStyle, lenient);
    1532        } catch (final IllegalArgumentException ex) {
    1533            throw new IOException("Corrupted TAR archive.", ex);
    1534        }
    1535    }
    1536
    1537    private void parseTarHeaderUnwrapped(final Map<String, String> globalPaxHeaders, final byte[] header,
    1538                                         final ZipEncoding encoding, final boolean oldStyle, final boolean lenient)
    1539        throws IOException {
    1540        int offset = 0;
    1541
    1542        name = oldStyle ? TarUtils.parseName(header, offset, NAMELEN)
    1543            : TarUtils.parseName(header, offset, NAMELEN, encoding);
    1544        offset += NAMELEN;
    1545        mode = (int) parseOctalOrBinary(header, offset, MODELEN, lenient);
    1546        offset += MODELEN;
    1547        userId = (int) parseOctalOrBinary(header, offset, UIDLEN, lenient);
    1548        offset += UIDLEN;
    1549        groupId = (int) parseOctalOrBinary(header, offset, GIDLEN, lenient);
    1550        offset += GIDLEN;
    1551        size = TarUtils.parseOctalOrBinary(header, offset, SIZELEN);
    1552        if (size < 0) {
    1553            throw new IOException("broken archive, entry with negative size");
    1554        }
    1555        offset += SIZELEN;
    1556        mTime = TimeUtils.unixTimeToFileTime(parseOctalOrBinary(header, offset, MODTIMELEN, lenient));
    1557        offset += MODTIMELEN;
    1558        checkSumOK = TarUtils.verifyCheckSum(header);
    1559        offset += CHKSUMLEN;
    1560        linkFlag = header[offset++];
    1561        linkName = oldStyle ? TarUtils.parseName(header, offset, NAMELEN)
    1562            : TarUtils.parseName(header, offset, NAMELEN, encoding);
    1563        offset += NAMELEN;
    1564        magic = TarUtils.parseName(header, offset, MAGICLEN);
    1565        offset += MAGICLEN;
    1566        version = TarUtils.parseName(header, offset, VERSIONLEN);
    1567        offset += VERSIONLEN;
    1568        userName = oldStyle ? TarUtils.parseName(header, offset, UNAMELEN)
    1569            : TarUtils.parseName(header, offset, UNAMELEN, encoding);
    1570        offset += UNAMELEN;
    1571        groupName = oldStyle ? TarUtils.parseName(header, offset, GNAMELEN)
    1572            : TarUtils.parseName(header, offset, GNAMELEN, encoding);
    1573        offset += GNAMELEN;
    1574        if (linkFlag == LF_CHR || linkFlag == LF_BLK) {
    1575            devMajor = (int) parseOctalOrBinary(header, offset, DEVLEN, lenient);
    1576            offset += DEVLEN;
    1577            devMinor = (int) parseOctalOrBinary(header, offset, DEVLEN, lenient);
    1578            offset += DEVLEN;
    1579        } else {
    1580            offset += 2 * DEVLEN;
    1581        }
    1582
    1583        final int type = evaluateType(globalPaxHeaders, header);
    1584        switch (type) {
    1585        case FORMAT_OLDGNU: {
    1586            aTime = fileTimeFromOptionalSeconds(parseOctalOrBinary(header, offset, ATIMELEN_GNU, lenient));
    1587            offset += ATIMELEN_GNU;
    1588            cTime = fileTimeFromOptionalSeconds(parseOctalOrBinary(header, offset, CTIMELEN_GNU, lenient));
    1589            offset += CTIMELEN_GNU;
    1590            offset += OFFSETLEN_GNU;
    1591            offset += LONGNAMESLEN_GNU;
    1592            offset += PAD2LEN_GNU;
    1593            sparseHeaders =
    1594                new ArrayList<>(TarUtils.readSparseStructs(header, offset, SPARSE_HEADERS_IN_OLDGNU_HEADER));
    1595            offset += SPARSELEN_GNU;
    1596            isExtended = TarUtils.parseBoolean(header, offset);
    1597            offset += ISEXTENDEDLEN_GNU;
    1598            realSize = TarUtils.parseOctal(header, offset, REALSIZELEN_GNU);
    1599            offset += REALSIZELEN_GNU; // NOSONAR - assignment as documentation
    1600            break;
    1601        }
    1602        case FORMAT_XSTAR: {
    1603            final String xstarPrefix = oldStyle
    1604                ? TarUtils.parseName(header, offset, PREFIXLEN_XSTAR)
    1605                : TarUtils.parseName(header, offset, PREFIXLEN_XSTAR, encoding);
    1606            offset += PREFIXLEN_XSTAR;
    1607            if (!xstarPrefix.isEmpty()) {
    1608                name = xstarPrefix + "/" + name;
    1609            }
    1610            aTime = fileTimeFromOptionalSeconds(parseOctalOrBinary(header, offset, ATIMELEN_XSTAR, lenient));
    1611            offset += ATIMELEN_XSTAR;
    1612            cTime = fileTimeFromOptionalSeconds(parseOctalOrBinary(header, offset, CTIMELEN_XSTAR, lenient));
    1613            offset += CTIMELEN_XSTAR; // NOSONAR - assignment as documentation
    1614            break;
    1615        }
    1616        case FORMAT_POSIX:
    1617        default: {
    1618            final String prefix = oldStyle
    1619                ? TarUtils.parseName(header, offset, PREFIXLEN)
    1620                : TarUtils.parseName(header, offset, PREFIXLEN, encoding);
    1621            offset += PREFIXLEN; // NOSONAR - assignment as documentation
    1622            // SunOS tar -E does not add / to directory names, so fix
    1623            // up to be consistent
    1624            if (isDirectory() && !name.endsWith("/")){
    1625                name = name + "/";
    1626            }
    1627            if (!prefix.isEmpty()){
    1628                name = prefix + "/" + name;
    1629            }
    1630        }
    1631        }
    1632    }
    1633
    1634    /**
    1635     * process one pax header, using the entries extraPaxHeaders map as source for extra headers
    1636     * used when handling entries for sparse files.
    1637     * @param key
    1638     * @param val
    1639     * @since 1.15
    1640     */
    1641    private void processPaxHeader(final String key, final String val) throws IOException {
    1642        processPaxHeader(key, val, extraPaxHeaders);
    1643    }
    1644
    1645    /**
    1646     * Process one pax header, using the supplied map as source for extra headers to be used when handling
    1647     * entries for sparse files
    1648     *
    1649     * @param key  the header name.
    1650     * @param val  the header value.
    1651     * @param headers  map of headers used for dealing with sparse file.
    1652     * @throws NumberFormatException  if encountered errors when parsing the numbers
    1653     * @since 1.15
    1654     */
    1655    private void processPaxHeader(final String key, final String val, final Map<String, String> headers)
    1656        throws IOException {
    1657    /*
    1658     * The following headers are defined for Pax.
    1659     * charset: cannot use these without changing TarArchiveEntry fields
    1660     * mtime
    1661     * atime
    1662     * ctime
    1663     * LIBARCHIVE.creationtime
    1664     * comment
    1665     * gid, gname
    1666     * linkpath
    1667     * size
    1668     * uid,uname
    1669     * SCHILY.devminor, SCHILY.devmajor: don't have setters/getters for those
    1670     *
    1671     * GNU sparse files use additional members, we use
    1672     * GNU.sparse.size to detect the 0.0 and 0.1 versions and
    1673     * GNU.sparse.realsize for 1.0.
    1674     *
    1675     * star files use additional members of which we use
    1676     * SCHILY.filetype in order to detect star sparse files.
    1677     *
    1678     * If called from addExtraPaxHeader, these additional headers must be already present .
    1679     */
    1680        switch (key) {
    1681            case "path":
    1682                setName(val);
    1683                break;
    1684            case "linkpath":
    1685                setLinkName(val);
    1686                break;
    1687            case "gid":
    1688                setGroupId(Long.parseLong(val));
    1689                break;
    1690            case "gname":
    1691                setGroupName(val);
    1692                break;
    1693            case "uid":
    1694                setUserId(Long.parseLong(val));
    1695                break;
    1696            case "uname":
    1697                setUserName(val);
    1698                break;
    1699            case "size":
    1700                final long size = Long.parseLong(val);
    1701                if (size < 0) {
    1702                    throw new IOException("Corrupted TAR archive. Entry size is negative");
    1703                }
    1704                setSize(size);
    1705                break;
    1706            case "mtime":
    1707                setLastModifiedTime(FileTime.from(parseInstantFromDecimalSeconds(val)));
    1708                break;
    1709            case "atime":
    1710                setLastAccessTime(FileTime.from(parseInstantFromDecimalSeconds(val)));
    1711                break;
    1712            case "ctime":
    1713                setStatusChangeTime(FileTime.from(parseInstantFromDecimalSeconds(val)));
    1714                break;
    1715            case "LIBARCHIVE.creationtime":
    1716                setCreationTime(FileTime.from(parseInstantFromDecimalSeconds(val)));
    1717                break;
    1718            case "SCHILY.devminor":
    1719                final int devMinor = Integer.parseInt(val);
    1720                if (devMinor < 0) {
    1721                    throw new IOException("Corrupted TAR archive. Dev-Minor is negative");
    1722                }
    1723                setDevMinor(devMinor);
    1724                break;
    1725            case "SCHILY.devmajor":
    1726                final int devMajor = Integer.parseInt(val);
    1727                if (devMajor < 0) {
    1728                    throw new IOException("Corrupted TAR archive. Dev-Major is negative");
    1729                }
    1730                setDevMajor(devMajor);
    1731                break;
    1732            case TarGnuSparseKeys.SIZE:
    1733                fillGNUSparse0xData(headers);
    1734                break;
    1735            case TarGnuSparseKeys.REALSIZE:
    1736                fillGNUSparse1xData(headers);
    1737                break;
    1738            case "SCHILY.filetype":
    1739                if ("sparse".equals(val)) {
    1740                    fillStarSparseData(headers);
    1741                }
    1742                break;
    1743            default:
    1744                extraPaxHeaders.put(key, val);
    1745        }
    1746    }
    1747
    1748    private void readFileMode(final Path file, final String normalizedName, final LinkOption... options) throws IOException {
    1749        if (Files.isDirectory(file, options)) {
    1750            this.mode = DEFAULT_DIR_MODE;
    1751            this.linkFlag = LF_DIR;
    1752
    1753            final int nameLength = normalizedName.length();
    1754            if (nameLength == 0 || normalizedName.charAt(nameLength - 1) != '/') {
    1755                this.name = normalizedName + "/";
    1756            } else {
    1757                this.name = normalizedName;
    1758            }
    1759        } else {
    1760            this.mode = DEFAULT_FILE_MODE;
    1761            this.linkFlag = LF_NORMAL;
    1762            this.name = normalizedName;
    1763            this.size = Files.size(file);
    1764        }
    1765    }
    1766
    1767    private void readOsSpecificProperties(final Path file, final LinkOption... options) throws IOException {
    1768        final Set<String> availableAttributeViews = file.getFileSystem().supportedFileAttributeViews();
    1769        if (availableAttributeViews.contains("posix")) {
    1770            final PosixFileAttributes posixFileAttributes = Files.readAttributes(file, PosixFileAttributes.class, options);
    1771            setLastModifiedTime(posixFileAttributes.lastModifiedTime());
    1772            setCreationTime(posixFileAttributes.creationTime());
    1773            setLastAccessTime(posixFileAttributes.lastAccessTime());
    1774            this.userName = posixFileAttributes.owner().getName();
    1775            this.groupName = posixFileAttributes.group().getName();
    1776            if (availableAttributeViews.contains("unix")) {
    1777                this.userId = ((Number) Files.getAttribute(file, "unix:uid", options)).longValue();
    1778                this.groupId = ((Number) Files.getAttribute(file, "unix:gid", options)).longValue();
    1779                try {
    1780                    setStatusChangeTime((FileTime) Files.getAttribute(file, "unix:ctime", options));
    1781                } catch (final IllegalArgumentException ex) { // NOSONAR
    1782                    // ctime is not supported
    1783                }
    1784            }
    1785        } else if (availableAttributeViews.contains("dos")) {
    1786            final DosFileAttributes dosFileAttributes = Files.readAttributes(file, DosFileAttributes.class, options);
    1787            setLastModifiedTime(dosFileAttributes.lastModifiedTime());
    1788            setCreationTime(dosFileAttributes.creationTime());
    1789            setLastAccessTime(dosFileAttributes.lastAccessTime());
    1790            this.userName = Files.getOwner(file, options).getName();
    1791        } else {
    1792            final BasicFileAttributes basicFileAttributes = Files.readAttributes(file, BasicFileAttributes.class, options);
    1793            setLastModifiedTime(basicFileAttributes.lastModifiedTime());
    1794            setCreationTime(basicFileAttributes.creationTime());
    1795            setLastAccessTime(basicFileAttributes.lastAccessTime());
    1796            this.userName = Files.getOwner(file, options).getName();
    1797        }
    1798    }
    1799
    1800    /**
    1801     * Set this entry's creation time.
    1802     *
    1803     * @param time This entry's new creation time.
    1804     * @since 1.22
    1805     */
    1806    public void setCreationTime(final FileTime time) {
    1807        birthTime = time;
    1808    }
    1809
    1810    /**
    1811     * Set the offset of the data for the tar entry.
    1812     * @param dataOffset the position of the data in the tar.
    1813     * @since 1.21
    1814     */
    1815    public void setDataOffset(final long dataOffset) {
    1816        if (dataOffset < 0) {
    1817            throw new IllegalArgumentException("The offset can not be smaller than 0");
    1818        }
    1819        this.dataOffset = dataOffset;
    1820    }
    1821
    1822    /**
    1823     * Set this entry's major device number.
    1824     *
    1825     * @param devNo This entry's major device number.
    1826     * @throws IllegalArgumentException if the devNo is &lt; 0.
    1827     * @since 1.4
    1828     */
    1829    public void setDevMajor(final int devNo) {
    1830        if (devNo < 0){
    1831            throw new IllegalArgumentException("Major device number is out of "
    1832                                               + "range: " + devNo);
    1833        }
    1834        this.devMajor = devNo;
    1835    }
    1836
    1837    /**
    1838     * Set this entry's minor device number.
    1839     *
    1840     * @param devNo This entry's minor device number.
    1841     * @throws IllegalArgumentException if the devNo is &lt; 0.
    1842     * @since 1.4
    1843     */
    1844    public void setDevMinor(final int devNo) {
    1845        if (devNo < 0){
    1846            throw new IllegalArgumentException("Minor device number is out of "
    1847                                               + "range: " + devNo);
    1848        }
    1849        this.devMinor = devNo;
    1850    }
    1851
    1852    /**
    1853     * Set this entry's group id.
    1854     *
    1855     * @param groupId This entry's new group id.
    1856     */
    1857    public void setGroupId(final int groupId) {
    1858        setGroupId((long) groupId);
    1859    }
    1860
    1861    /**
    1862     * Set this entry's group id.
    1863     *
    1864     * @since 1.10
    1865     * @param groupId This entry's new group id.
    1866     */
    1867    public void setGroupId(final long groupId) {
    1868        this.groupId = groupId;
    1869    }
    1870
    1871    /**
    1872     * Set this entry's group name.
    1873     *
    1874     * @param groupName This entry's new group name.
    1875     */
    1876    public void setGroupName(final String groupName) {
    1877        this.groupName = groupName;
    1878    }
    1879
    1880    /**
    1881     * Convenience method to set this entry's group and user ids.
    1882     *
    1883     * @param userId This entry's new user id.
    1884     * @param groupId This entry's new group id.
    1885     */
    1886    public void setIds(final int userId, final int groupId) {
    1887        setUserId(userId);
    1888        setGroupId(groupId);
    1889    }
    1890
    1891    /**
    1892     * Set this entry's last access time.
    1893     *
    1894     * @param time This entry's new last access time.
    1895     * @since 1.22
    1896     */
    1897    public void setLastAccessTime(final FileTime time) {
    1898        aTime = time;
    1899    }
    1900
    1901    /**
    1902     * Set this entry's modification time.
    1903     *
    1904     * @param time This entry's new modification time.
    1905     * @since 1.22
    1906     */
    1907    public void setLastModifiedTime(final FileTime time) {
    1908        mTime = Objects.requireNonNull(time, "Time must not be null");
    1909    }
    1910
    1911    /**
    1912     * Set this entry's link name.
    1913     *
    1914     * @param link the link name to use.
    1915     *
    1916     * @since 1.1
    1917     */
    1918    public void setLinkName(final String link) {
    1919        this.linkName = link;
    1920    }
    1921
    1922    /**
    1923     * Set the mode for this entry
    1924     *
    1925     * @param mode the mode for this entry
    1926     */
    1927    public void setMode(final int mode) {
    1928        this.mode = mode;
    1929    }
    1930
    1931    /**
    1932     * Set this entry's modification time.
    1933     *
    1934     * @param time This entry's new modification time.
    1935     * @see TarArchiveEntry#setLastModifiedTime(FileTime)
    1936     */
    1937    public void setModTime(final Date time) {
    1938        setLastModifiedTime(TimeUtils.toFileTime(time));
    1939    }
    1940
    1941    /**
    1942     * Set this entry's modification time.
    1943     *
    1944     * @param time This entry's new modification time.
    1945     * @since 1.21
    1946     * @see TarArchiveEntry#setLastModifiedTime(FileTime)
    1947     */
    1948    public void setModTime(final FileTime time) {
    1949        setLastModifiedTime(time);
    1950    }
    1951
    1952    /**
    1953     * Set this entry's modification time. The parameter passed
    1954     * to this method is in "Java time".
    1955     *
    1956     * @param time This entry's new modification time.
    1957     * @see TarArchiveEntry#setLastModifiedTime(FileTime)
    1958     */
    1959    public void setModTime(final long time) {
    1960        setLastModifiedTime(FileTime.fromMillis(time));
    1961    }
    1962
    1963    /**
    1964     * Set this entry's name.
    1965     *
    1966     * @param name This entry's new name.
    1967     */
    1968    public void setName(final String name) {
    1969        this.name = normalizeFileName(name, this.preserveAbsolutePath);
    1970    }
    1971
    1972    /**
    1973     * Convenience method to set this entry's group and user names.
    1974     *
    1975     * @param userName This entry's new user name.
    1976     * @param groupName This entry's new group name.
    1977     */
    1978    public void setNames(final String userName, final String groupName) {
    1979        setUserName(userName);
    1980        setGroupName(groupName);
    1981    }
    1982
    1983    /**
    1984     * Set this entry's file size.
    1985     *
    1986     * @param size This entry's new file size.
    1987     * @throws IllegalArgumentException if the size is &lt; 0.
    1988     */
    1989    public void setSize(final long size) {
    1990        if (size < 0){
    1991            throw new IllegalArgumentException("Size is out of range: " + size);
    1992        }
    1993        this.size = size;
    1994    }
    1995
    1996    /**
    1997     * Set this entry's sparse headers
    1998     * @param sparseHeaders The new sparse headers
    1999     * @since 1.20
    2000     */
    2001    public void setSparseHeaders(final List<TarArchiveStructSparse> sparseHeaders) {
    2002        this.sparseHeaders = sparseHeaders;
    2003    }
    2004
    2005    /**
    2006     * Set this entry's status change time.
    2007     *
    2008     * @param time This entry's new status change time.
    2009     * @since 1.22
    2010     */
    2011    public void setStatusChangeTime(final FileTime time) {
    2012        cTime = time;
    2013    }
    2014
    2015    /**
    2016     * Set this entry's user id.
    2017     *
    2018     * @param userId This entry's new user id.
    2019     */
    2020    public void setUserId(final int userId) {
    2021        setUserId((long) userId);
    2022    }
    2023
    2024    /**
    2025     * Set this entry's user id.
    2026     *
    2027     * @param userId This entry's new user id.
    2028     * @since 1.10
    2029     */
    2030    public void setUserId(final long userId) {
    2031        this.userId = userId;
    2032    }
    2033
    2034    /**
    2035     * Set this entry's user name.
    2036     *
    2037     * @param userName This entry's new user name.
    2038     */
    2039    public void setUserName(final String userName) {
    2040        this.userName = userName;
    2041    }
    2042
    2043    /**
    2044     * Update the entry using a map of pax headers.
    2045     * @param headers
    2046     * @since 1.15
    2047     */
    2048    void updateEntryFromPaxHeaders(final Map<String, String> headers) throws IOException {
    2049        for (final Map.Entry<String, String> ent : headers.entrySet()) {
    2050            processPaxHeader(ent.getKey(), ent.getValue(), headers);
    2051        }
    2052    }
    2053
    2054    /**
    2055     * Write an entry's header information to a header buffer.
    2056     *
    2057     * <p>This method does not use the star/GNU tar/BSD tar extensions.</p>
    2058     *
    2059     * @param outbuf The tar entry header buffer to fill in.
    2060     */
    2061    public void writeEntryHeader(final byte[] outbuf) {
    2062        try {
    2063            writeEntryHeader(outbuf, TarUtils.DEFAULT_ENCODING, false);
    2064        } catch (final IOException ex) { // NOSONAR
    2065            try {
    2066                writeEntryHeader(outbuf, TarUtils.FALLBACK_ENCODING, false);
    2067            } catch (final IOException ex2) {
    2068                // impossible
    2069                throw new UncheckedIOException(ex2); //NOSONAR
    2070            }
    2071        }
    2072    }
    2073
    2074    /**
    2075     * Write an entry's header information to a header buffer.
    2076     *
    2077     * @param outbuf The tar entry header buffer to fill in.
    2078     * @param encoding encoding to use when writing the file name.
    2079     * @param starMode whether to use the star/GNU tar/BSD tar
    2080     * extension for numeric fields if their value doesn't fit in the
    2081     * maximum size of standard tar archives
    2082     * @since 1.4
    2083     * @throws IOException on error
    2084     */
    2085    public void writeEntryHeader(final byte[] outbuf, final ZipEncoding encoding,
    2086                                 final boolean starMode) throws IOException {
    2087        int offset = 0;
    2088
    2089        offset = TarUtils.formatNameBytes(name, outbuf, offset, NAMELEN,
    2090                                          encoding);
    2091        offset = writeEntryHeaderField(mode, outbuf, offset, MODELEN, starMode);
    2092        offset = writeEntryHeaderField(userId, outbuf, offset, UIDLEN,
    2093                                       starMode);
    2094        offset = writeEntryHeaderField(groupId, outbuf, offset, GIDLEN,
    2095                                       starMode);
    2096        offset = writeEntryHeaderField(size, outbuf, offset, SIZELEN, starMode);
    2097        offset = writeEntryHeaderField(TimeUtils.toUnixTime(mTime), outbuf, offset,
    2098                                       MODTIMELEN, starMode);
    2099
    2100        final int csOffset = offset;
    2101
    2102        offset = fill((byte) ' ', offset, outbuf, CHKSUMLEN);
    2103
    2104        outbuf[offset++] = linkFlag;
    2105        offset = TarUtils.formatNameBytes(linkName, outbuf, offset, NAMELEN,
    2106                                          encoding);
    2107        offset = TarUtils.formatNameBytes(magic, outbuf, offset, MAGICLEN);
    2108        offset = TarUtils.formatNameBytes(version, outbuf, offset, VERSIONLEN);
    2109        offset = TarUtils.formatNameBytes(userName, outbuf, offset, UNAMELEN,
    2110                                          encoding);
    2111        offset = TarUtils.formatNameBytes(groupName, outbuf, offset, GNAMELEN,
    2112                                          encoding);
    2113        offset = writeEntryHeaderField(devMajor, outbuf, offset, DEVLEN,
    2114                                       starMode);
    2115        offset = writeEntryHeaderField(devMinor, outbuf, offset, DEVLEN,
    2116                                       starMode);
    2117
    2118        if (starMode) {
    2119            // skip prefix
    2120            offset = fill(0, offset, outbuf, PREFIXLEN_XSTAR);
    2121            offset = writeEntryHeaderOptionalTimeField(aTime, offset, outbuf, ATIMELEN_XSTAR);
    2122            offset = writeEntryHeaderOptionalTimeField(cTime, offset, outbuf, CTIMELEN_XSTAR);
    2123            // 8-byte fill
    2124            offset = fill(0, offset, outbuf, 8);
    2125            // Do not write MAGIC_XSTAR because it causes issues with some TAR tools
    2126            // This makes it effectively XUSTAR, which guarantees compatibility with USTAR
    2127            offset = fill(0, offset, outbuf, XSTAR_MAGIC_LEN);
    2128        }
    2129
    2130        offset = fill(0, offset, outbuf, outbuf.length - offset); // NOSONAR - assignment as documentation
    2131
    2132        final long chk = TarUtils.computeCheckSum(outbuf);
    2133
    2134        TarUtils.formatCheckSumOctalBytes(chk, outbuf, csOffset, CHKSUMLEN);
    2135    }
    2136
    2137    private int writeEntryHeaderField(final long value, final byte[] outbuf, final int offset,
    2138                                      final int length, final boolean starMode) {
    2139        if (!starMode && (value < 0
    2140                          || value >= 1L << 3 * (length - 1))) {
    2141            // value doesn't fit into field when written as octal
    2142            // number, will be written to PAX header or causes an
    2143            // error
    2144            return TarUtils.formatLongOctalBytes(0, outbuf, offset, length);
    2145        }
    2146        return TarUtils.formatLongOctalOrBinaryBytes(value, outbuf, offset,
    2147                                                     length);
    2148    }
    2149
    2150    private int writeEntryHeaderOptionalTimeField(final FileTime time, int offset, final byte[] outbuf, final int fieldLength) {
    2151        if (time != null) {
    2152            offset = writeEntryHeaderField(TimeUtils.toUnixTime(time), outbuf, offset, fieldLength, true);
    2153        } else {
    2154            offset = fill(0, offset, outbuf, fieldLength);
    2155        }
    2156        return offset;
    2157    }
    2158
    2159}
    2160