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