VirtualBox

Changeset 98325 in vbox


Ignore:
Timestamp:
Jan 26, 2023 4:16:07 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
155544
Message:

Runtime,Main: Remove the now unused and deprecated RTTar* API in favor of the VFS implementation, move the header declaring the tar headers to iprt/formats so the appliance code can access some required defines [build fix, needed to split up the tar format header]

Location:
trunk
Files:
4 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/formats/tar.h

    r98322 r98325  
    3535 */
    3636
    37 #ifndef IPRT_INCLUDED_SRC_common_zip_tar_h
    38 #define IPRT_INCLUDED_SRC_common_zip_tar_h
     37#ifndef IPRT_INCLUDED_formats_tar_h
     38#define IPRT_INCLUDED_formats_tar_h
    3939#ifndef RT_WITHOUT_PRAGMA_ONCE
    4040# pragma once
    … …  
    295295AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, devminor,  RTZIPTARHDRGNU, devminor);
    296296
    297 
    298 
    299 /**
    300  * Tar header union.
    301  */
    302 typedef union RTZIPTARHDR
    303 {
    304     /** Byte view. */
    305     char                ab[512];
    306     /** The standard header. */
    307     RTZIPTARHDRANCIENT      Ancient;
    308     /** The standard header. */
    309     RTZIPTARHDRPOSIX        Posix;
    310     /** The GNU header. */
    311     RTZIPTARHDRGNU          Gnu;
    312     /** The bits common to both GNU and the standard header. */
    313     RTZIPTARHDRCOMMON       Common;
    314     /** GNU sparse header. */
    315     RTZIPTARHDRGNUSPARSE    GnuSparse;
    316 } RTZIPTARHDR;
    317 AssertCompileSize(RTZIPTARHDR, 512);
    318 /** Pointer to a tar file header. */
    319 typedef RTZIPTARHDR *PRTZIPTARHDR;
    320 /** Pointer to a const tar file header. */
    321 typedef RTZIPTARHDR const *PCRTZIPTARHDR;
    322 
    323 
    324 /**
    325  * Tar header type.
    326  */
    327 typedef enum RTZIPTARTYPE
    328 {
    329     /** Invalid type value. */
    330     RTZIPTARTYPE_INVALID = 0,
    331     /** Posix header.  */
    332     RTZIPTARTYPE_POSIX,
    333     /** The old GNU header, has layout conflicting with posix. */
    334     RTZIPTARTYPE_GNU,
    335     /** Ancient tar header which does not use anything beyond the magic. */
    336     RTZIPTARTYPE_ANCIENT,
    337     /** End of the valid type values (this is not valid).  */
    338     RTZIPTARTYPE_END,
    339     /** The usual type blow up.  */
    340     RTZIPTARTYPE_32BIT_HACK = 0x7fffffff
    341 } RTZIPTARTYPE;
    342 typedef RTZIPTARTYPE *PRTZIPTARTYPE;
    343 
    344 
    345 /**
    346  * Calculates the TAR header checksums and detects if it's all zeros.
    347  *
    348  * @returns true if all zeros, false if not.
    349  * @param   pHdr            The header to checksum.
    350  * @param   pi32Unsigned    Where to store the checksum calculated using
    351  *                          unsigned chars.   This is the one POSIX specifies.
    352  * @param   pi32Signed      Where to store the checksum calculated using
    353  *                          signed chars.
    354  *
    355  * @remarks The reason why we calculate the checksum as both signed and unsigned
    356  *          has to do with various the char C type being signed on some hosts
    357  *          and unsigned on others.
    358  */
    359 DECLINLINE(bool) rtZipTarCalcChkSum(PCRTZIPTARHDR pHdr, int32_t *pi32Unsigned, int32_t *pi32Signed)
    360 {
    361     int32_t i32Unsigned = 0;
    362     int32_t i32Signed   = 0;
    363 
    364     /*
    365      * Sum up the entire header.
    366      */
    367     const char *pch    = (const char *)pHdr;
    368     const char *pchEnd = pch + sizeof(*pHdr);
    369     do
    370     {
    371         i32Unsigned += *(unsigned char *)pch;
    372         i32Signed   += *(signed   char *)pch;
    373     } while (++pch != pchEnd);
    374 
    375     /*
    376      * Check if it's all zeros and replace the chksum field with spaces.
    377      */
    378     bool const fZeroHdr = i32Unsigned == 0;
    379 
    380     pch    = pHdr->Common.chksum;
    381     pchEnd = pch + sizeof(pHdr->Common.chksum);
    382     do
    383     {
    384         i32Unsigned -= *(unsigned char *)pch;
    385         i32Signed   -= *(signed   char *)pch;
    386     } while (++pch != pchEnd);
    387 
    388     i32Unsigned += (unsigned char)' ' * sizeof(pHdr->Common.chksum);
    389     i32Signed   += (signed   char)' ' * sizeof(pHdr->Common.chksum);
    390 
    391     *pi32Unsigned = i32Unsigned;
    392     if (pi32Signed)
    393         *pi32Signed = i32Signed;
    394     return fZeroHdr;
    395 }
    396 
    397 
    398 #endif /* !IPRT_INCLUDED_SRC_common_zip_tar_h */
    399 
     297#endif /* !IPRT_INCLUDED_formats_tar_h */
     298

  • trunk/src/VBox/Runtime/common/zip/tar.h

    r98322 r98325  
    4242
    4343#include <iprt/assert.h>
    44 
    45 /** @name RTZIPTARHDRPOSIX::typeflag
    46  * @{  */
    47 #define RTZIPTAR_TF_OLDNORMAL   '\0' /**< Normal disk file, Unix compatible */
    48 #define RTZIPTAR_TF_NORMAL      '0'  /**< Normal disk file */
    49 #define RTZIPTAR_TF_LINK        '1'  /**< Link to previously dumped file */
    50 #define RTZIPTAR_TF_SYMLINK     '2'  /**< Symbolic link */
    51 #define RTZIPTAR_TF_CHR         '3'  /**< Character special file */
    52 #define RTZIPTAR_TF_BLK         '4'  /**< Block special file */
    53 #define RTZIPTAR_TF_DIR         '5'  /**< Directory */
    54 #define RTZIPTAR_TF_FIFO        '6'  /**< FIFO special file */
    55 #define RTZIPTAR_TF_CONTIG      '7'  /**< Contiguous file */
    56 
    57 #define RTZIPTAR_TF_X_HDR       'x'  /**< Extended header. */
    58 #define RTZIPTAR_TF_X_GLOBAL    'g'  /**< Global extended header. */
    59 
    60 #define RTZIPTAR_TF_SOLARIS_XHDR    'X'
    61 
    62 #define RTZIPTAR_TF_GNU_DUMPDIR     'D'
    63 #define RTZIPTAR_TF_GNU_LONGLINK    'K' /**< GNU long link header. */
    64 #define RTZIPTAR_TF_GNU_LONGNAME    'L' /**< GNU long name header. */
    65 #define RTZIPTAR_TF_GNU_MULTIVOL    'M'
    66 #define RTZIPTAR_TF_GNU_SPARSE      'S'
    67 #define RTZIPTAR_TF_GNU_VOLDHR      'V'
    68 /** @} */
    69 
    70 /** Maximum length of a tar filename, excluding the terminating '\0'. More
    71  * does not fit into a tar record. */
    72 #define RTZIPTAR_NAME_MAX           99
    73 
    74 
    75 /**
    76  * The ancient tar header.
    77  *
    78  * The posix and gnu headers are compatible with the members up to and including
    79  * link name, from there on they differ.
    80  */
    81 typedef struct RTZIPTARHDRANCIENT
    82 {
    83     char    name[100];
    84     char    mode[8];
    85     char    uid[8];
    86     char    gid[8];
    87     char    size[12];
    88     char    mtime[12];
    89     char    chksum[8];
    90     char    typeflag;
    91     char    linkname[100];              /**< Was called linkflag. */
    92     char    unused[8+64+16+155+12];
    93 } RTZIPTARHDRANCIENT;
    94 AssertCompileSize(RTZIPTARHDRANCIENT, 512);
    95 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, name,        0);
    96 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, mode,      100);
    97 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, uid,       108);
    98 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, gid,       116);
    99 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, size,      124);
    100 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, mtime,     136);
    101 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, chksum,    148);
    102 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, typeflag,  156);
    103 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, linkname,  157);
    104 AssertCompileMemberOffset(RTZIPTARHDRANCIENT, unused,    257);
    105 
    106 
    107 /** The uniform standard tape archive format magic value. */
    108 #define RTZIPTAR_USTAR_MAGIC        "ustar"
    109 /** The ustar version string.
    110  * @remarks The terminator character is not part of the field.  */
    111 #define RTZIPTAR_USTAR_VERSION      "00"
    112 
    113 /** The GNU magic + version value. */
    114 #define RTZIPTAR_GNU_MAGIC          "ustar  "
    115 
    116 
    117 /**
    118  * The posix header (according to SuS).
    119  */
    120 typedef struct RTZIPTARHDRPOSIX
    121 {
    122     char    name[100];
    123     char    mode[8];
    124     char    uid[8];
    125     char    gid[8];
    126     char    size[12];
    127     char    mtime[12];
    128     char    chksum[8];
    129     char    typeflag;
    130     char    linkname[100];
    131     char    magic[6];
    132     char    version[2];
    133     char    uname[32];
    134     char    gname[32];
    135     char    devmajor[8];
    136     char    devminor[8];
    137     char    prefix[155];
    138     char    unused[12];
    139 } RTZIPTARHDRPOSIX;
    140 AssertCompileSize(RTZIPTARHDRPOSIX, 512);
    141 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, name,        0);
    142 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, mode,      100);
    143 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, uid,       108);
    144 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, gid,       116);
    145 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, size,      124);
    146 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, mtime,     136);
    147 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, chksum,    148);
    148 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, typeflag,  156);
    149 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, linkname,  157);
    150 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, magic,     257);
    151 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, version,   263);
    152 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, uname,     265);
    153 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, gname,     297);
    154 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, devmajor,  329);
    155 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, devminor,  337);
    156 AssertCompileMemberOffset(RTZIPTARHDRPOSIX, prefix,    345);
    157 
    158 /**
    159  * GNU sparse data segment descriptor.
    160  */
    161 typedef struct RTZIPTARGNUSPARSE
    162 {
    163     char    offset[12];     /**< Absolute offset relative to the start of the file. */
    164     char    numbytes[12];
    165 } RTZIPTARGNUSPARSE;
    166 AssertCompileSize(RTZIPTARGNUSPARSE, 24);
    167 AssertCompileMemberOffset(RTZIPTARGNUSPARSE, offset,    0);
    168 AssertCompileMemberOffset(RTZIPTARGNUSPARSE, numbytes,  12);
    169 /** Pointer to a GNU sparse data segment descriptor. */
    170 typedef RTZIPTARGNUSPARSE *PRTZIPTARGNUSPARSE;
    171 /** Pointer to a const GNU sparse data segment descriptor. */
    172 typedef RTZIPTARGNUSPARSE *PCRTZIPTARGNUSPARSE;
    173 
    174 /**
    175  * The GNU header.
    176  */
    177 typedef struct RTZIPTARHDRGNU
    178 {
    179     char    name[100];
    180     char    mode[8];
    181     char    uid[8];
    182     char    gid[8];
    183     char    size[12];
    184     char    mtime[12];
    185     char    chksum[8];
    186     char    typeflag;
    187     char    linkname[100];
    188     char    magic[8];
    189     char    uname[32];
    190     char    gname[32];
    191     char    devmajor[8];
    192     char    devminor[8];
    193     char    atime[12];
    194     char    ctime[12];
    195     char    offset[12];         /**< for multi-volume? */
    196     char    longnames[4];       /**< Seems to be unused. */
    197     char    unused[1];
    198     RTZIPTARGNUSPARSE sparse[4];
    199     char    isextended; /**< More headers about sparse stuff if binary value 1. */
    200     char    realsize[12];
    201     char    unused2[17];
    202 } RTZIPTARHDRGNU;
    203 AssertCompileSize(RTZIPTARHDRGNU, 512);
    204 AssertCompileMemberOffset(RTZIPTARHDRGNU, name,        0);
    205 AssertCompileMemberOffset(RTZIPTARHDRGNU, mode,      100);
    206 AssertCompileMemberOffset(RTZIPTARHDRGNU, uid,       108);
    207 AssertCompileMemberOffset(RTZIPTARHDRGNU, gid,       116);
    208 AssertCompileMemberOffset(RTZIPTARHDRGNU, size,      124);
    209 AssertCompileMemberOffset(RTZIPTARHDRGNU, mtime,     136);
    210 AssertCompileMemberOffset(RTZIPTARHDRGNU, chksum,    148);
    211 AssertCompileMemberOffset(RTZIPTARHDRGNU, typeflag,  156);
    212 AssertCompileMemberOffset(RTZIPTARHDRGNU, linkname,  157);
    213 AssertCompileMemberOffset(RTZIPTARHDRGNU, magic,     257);
    214 AssertCompileMemberOffset(RTZIPTARHDRGNU, uname,     265);
    215 AssertCompileMemberOffset(RTZIPTARHDRGNU, gname,     297);
    216 AssertCompileMemberOffset(RTZIPTARHDRGNU, devmajor,  329);
    217 AssertCompileMemberOffset(RTZIPTARHDRGNU, devminor,  337);
    218 AssertCompileMemberOffset(RTZIPTARHDRGNU, atime,     345);
    219 AssertCompileMemberOffset(RTZIPTARHDRGNU, ctime,     357);
    220 AssertCompileMemberOffset(RTZIPTARHDRGNU, offset,    369);
    221 AssertCompileMemberOffset(RTZIPTARHDRGNU, longnames, 381);
    222 AssertCompileMemberOffset(RTZIPTARHDRGNU, unused,    385);
    223 AssertCompileMemberOffset(RTZIPTARHDRGNU, sparse,    386);
    224 AssertCompileMemberOffset(RTZIPTARHDRGNU, isextended,482);
    225 AssertCompileMemberOffset(RTZIPTARHDRGNU, realsize,  483);
    226 AssertCompileMemberOffset(RTZIPTARHDRGNU, unused2,   495);
    227 
    228 
    229 /**
    230  * GNU sparse header.
    231  */
    232 typedef struct RTZIPTARHDRGNUSPARSE
    233 {
    234     RTZIPTARGNUSPARSE sp[21];
    235     char    isextended;
    236     char    unused[7];
    237 } RTZIPTARHDRGNUSPARSE;
    238 AssertCompileSize(RTZIPTARHDRGNUSPARSE, 512);
    239 AssertCompileMemberOffset(RTZIPTARHDRGNUSPARSE, sp,         0);
    240 AssertCompileMemberOffset(RTZIPTARHDRGNUSPARSE, isextended, 504);
    241 AssertCompileMemberOffset(RTZIPTARHDRGNUSPARSE, unused,     505);
    242 
    243 
    244 /**
    245  * The bits common to posix and GNU.
    246  */
    247 typedef struct RTZIPTARHDRCOMMON
    248 {
    249     char    name[100];
    250     char    mode[8];
    251     char    uid[8];
    252     char    gid[8];
    253     char    size[12];
    254     char    mtime[12];
    255     char    chksum[8];
    256     char    typeflag;
    257     char    linkname[100];
    258     char    magic[6];
    259     char    version[2];
    260     char    uname[32];
    261     char    gname[32];
    262     char    devmajor[8];
    263     char    devminor[8];
    264     char    not_common[155+12];
    265 } RTZIPTARHDRCOMMON;
    266 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, name,      RTZIPTARHDRPOSIX, name);
    267 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, mode,      RTZIPTARHDRPOSIX, mode);
    268 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, uid,       RTZIPTARHDRPOSIX, uid);
    269 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, gid,       RTZIPTARHDRPOSIX, gid);
    270 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, size,      RTZIPTARHDRPOSIX, size);
    271 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, mtime,     RTZIPTARHDRPOSIX, mtime);
    272 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, chksum,    RTZIPTARHDRPOSIX, chksum);
    273 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, typeflag,  RTZIPTARHDRPOSIX, typeflag);
    274 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, linkname,  RTZIPTARHDRPOSIX, linkname);
    275 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, magic,     RTZIPTARHDRPOSIX, magic);
    276 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, version,   RTZIPTARHDRPOSIX, version);
    277 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, uname,     RTZIPTARHDRPOSIX, uname);
    278 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, gname,     RTZIPTARHDRPOSIX, gname);
    279 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, devmajor,  RTZIPTARHDRPOSIX, devmajor);
    280 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, devminor,  RTZIPTARHDRPOSIX, devminor);
    281 
    282 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, name,      RTZIPTARHDRGNU, name);
    283 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, mode,      RTZIPTARHDRGNU, mode);
    284 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, uid,       RTZIPTARHDRGNU, uid);
    285 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, gid,       RTZIPTARHDRGNU, gid);
    286 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, size,      RTZIPTARHDRGNU, size);
    287 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, mtime,     RTZIPTARHDRGNU, mtime);
    288 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, chksum,    RTZIPTARHDRGNU, chksum);
    289 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, typeflag,  RTZIPTARHDRGNU, typeflag);
    290 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, linkname,  RTZIPTARHDRGNU, linkname);
    291 AssertCompileMembersAtSameOffset(     RTZIPTARHDRCOMMON, magic,     RTZIPTARHDRGNU, magic);
    292 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, uname,     RTZIPTARHDRGNU, uname);
    293 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, gname,     RTZIPTARHDRGNU, gname);
    294 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, devmajor,  RTZIPTARHDRGNU, devmajor);
    295 AssertCompileMembersSameSizeAndOffset(RTZIPTARHDRCOMMON, devminor,  RTZIPTARHDRGNU, devminor);
    296 
    297 
     44#include <iprt/formats/tar.h>
    29845
    29946/**

  • trunk/src/VBox/Runtime/common/zip/tarvfs.cpp

    r98322 r98325  
    5252#include <iprt/vfslowlevel.h>
    5353
    54 #include <iprt/formats/tar.h>
    5554#include "tarvfsreader.h"
    5655

  • trunk/src/VBox/Runtime/common/zip/tarvfsreader.h

    r98322 r98325  
    4141#endif
    4242
    43 #include <iprt/formats/tar.h>
     43#include "tar.h"
    4444
    4545

  • trunk/src/VBox/Runtime/common/zip/tarvfswriter.cpp

    r98322 r98325  
    5252#include <iprt/vfslowlevel.h>
    5353#include <iprt/zero.h>
    54 
    55 #include <iprt/formats/tar.h>
    5654
    5755#include "tarvfsreader.h"
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette