[86035] | 1 | /* $Id: cpiovfs.cpp 100908 2023-08-19 02:57:05Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * IPRT - CPIO Virtual Filesystem, Reader.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2020-2023 Oracle and/or its affiliates.
|
---|
[86035] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
[86035] | 11 | *
|
---|
[96407] | 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
[86035] | 25 | * The contents of this file may alternatively be used under the terms
|
---|
| 26 | * of the Common Development and Distribution License Version 1.0
|
---|
[96407] | 27 | * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
|
---|
| 28 | * in the VirtualBox distribution, in which case the provisions of the
|
---|
[86035] | 29 | * CDDL are applicable instead of those of the GPL.
|
---|
| 30 | *
|
---|
| 31 | * You may elect to license modified versions of this file under the
|
---|
| 32 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
[96407] | 33 | *
|
---|
| 34 | * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
|
---|
[86035] | 35 | */
|
---|
| 36 |
|
---|
| 37 |
|
---|
| 38 | /*********************************************************************************************************************************
|
---|
| 39 | * Header Files *
|
---|
| 40 | *********************************************************************************************************************************/
|
---|
| 41 | #include "internal/iprt.h"
|
---|
| 42 | #include <iprt/zip.h>
|
---|
| 43 |
|
---|
| 44 | #include <iprt/asm.h>
|
---|
| 45 | #include <iprt/assert.h>
|
---|
| 46 | #include <iprt/ctype.h>
|
---|
| 47 | #include <iprt/err.h>
|
---|
| 48 | #include <iprt/poll.h>
|
---|
| 49 | #include <iprt/file.h>
|
---|
| 50 | #include <iprt/string.h>
|
---|
| 51 | #include <iprt/vfs.h>
|
---|
| 52 | #include <iprt/vfslowlevel.h>
|
---|
| 53 |
|
---|
| 54 | #include "cpiovfsreader.h"
|
---|
| 55 |
|
---|
| 56 |
|
---|
| 57 | /**
|
---|
| 58 | * Converts a octal numeric header field to the C native type.
|
---|
| 59 | *
|
---|
| 60 | * @returns IPRT status code.
|
---|
| 61 | * @param pachField The CPIO header field.
|
---|
| 62 | * @param cchField The length of the field.
|
---|
| 63 | * @param pi64 Where to store the value.
|
---|
| 64 | */
|
---|
| 65 | static int rtZipCpioHdrOctalFieldToNum(const char *pachField, size_t cchField, int64_t *pi64)
|
---|
| 66 | {
|
---|
| 67 | /*
|
---|
| 68 | * Skip leading zeros to save a few slower loops below.
|
---|
| 69 | */
|
---|
| 70 | while (cchField > 0 && *pachField == '0')
|
---|
| 71 | cchField--, pachField++;
|
---|
| 72 |
|
---|
| 73 | /*
|
---|
| 74 | * Convert octal digits.
|
---|
| 75 | */
|
---|
| 76 | int64_t i64 = 0;
|
---|
| 77 | while (cchField > 0)
|
---|
| 78 | {
|
---|
| 79 | unsigned char uDigit = *pachField - '0';
|
---|
| 80 | if (uDigit >= 8)
|
---|
| 81 | return VERR_TAR_BAD_NUM_FIELD;
|
---|
| 82 | i64 <<= 3;
|
---|
| 83 | i64 |= uDigit;
|
---|
| 84 |
|
---|
| 85 | pachField++;
|
---|
| 86 | cchField--;
|
---|
| 87 | }
|
---|
| 88 | *pi64 = i64;
|
---|
| 89 |
|
---|
| 90 | return VINF_SUCCESS;
|
---|
| 91 | }
|
---|
| 92 |
|
---|
| 93 |
|
---|
| 94 | /**
|
---|
| 95 | * Converts a hex character to the appropriate nibble.
|
---|
| 96 | *
|
---|
| 97 | * @returns Nibble of the character.
|
---|
| 98 | * @param chVal The value to convert.
|
---|
| 99 | */
|
---|
| 100 | static inline uint8_t rtZipCpioHexToNibble(char chVal)
|
---|
| 101 | {
|
---|
| 102 | if (chVal >= '0' && chVal <= '9')
|
---|
| 103 | return chVal - '0';
|
---|
| 104 | else if (chVal >= 'a' && chVal <= 'f')
|
---|
| 105 | return chVal - 'a' + 10;
|
---|
| 106 | else if (chVal >= 'A' && chVal <= 'F')
|
---|
| 107 | return chVal - 'A' + 10;
|
---|
| 108 |
|
---|
| 109 | return 0xff;
|
---|
| 110 | }
|
---|
| 111 |
|
---|
| 112 |
|
---|
| 113 | /**
|
---|
| 114 | * Converts a hexadecimal numeric header field to the C native type.
|
---|
| 115 | *
|
---|
| 116 | * @returns IPRT status code.
|
---|
| 117 | * @param pachField The CPIO header field.
|
---|
| 118 | * @param cchField The length of the field.
|
---|
| 119 | * @param pi64 Where to store the value.
|
---|
| 120 | */
|
---|
| 121 | static int rtZipCpioHdrHexFieldToNum(const char *pachField, size_t cchField, int64_t *pi64)
|
---|
| 122 | {
|
---|
| 123 | uint64_t u64 = 0;
|
---|
| 124 |
|
---|
| 125 | while (cchField-- > 0)
|
---|
| 126 | {
|
---|
| 127 | uint8_t bNb = rtZipCpioHexToNibble(*pachField++);
|
---|
| 128 |
|
---|
| 129 | if (RT_LIKELY(bNb != 0xff))
|
---|
| 130 | u64 = (u64 << 4) | bNb;
|
---|
| 131 | else
|
---|
| 132 | return VERR_TAR_BAD_NUM_FIELD;
|
---|
| 133 | }
|
---|
| 134 |
|
---|
| 135 | *pi64 = (int64_t)u64;
|
---|
| 136 | return VINF_SUCCESS;
|
---|
| 137 | }
|
---|
| 138 |
|
---|
| 139 |
|
---|
| 140 | /**
|
---|
| 141 | * Parses the given ancient binary header and converts it to an FS object info structure.
|
---|
| 142 | *
|
---|
| 143 | * @returns IPRT status code.
|
---|
| 144 | * @param pThis The CPIO reader state.
|
---|
| 145 | * @param pHdr The header to convert.
|
---|
| 146 | * @param pcbFilePath Where to store the file path size on success.
|
---|
| 147 | * @param pcbPad Where to store the number of bytes padded after the header and file path
|
---|
| 148 | * before the content begins.
|
---|
| 149 | */
|
---|
| 150 | static int rtZipCpioReaderParseHeaderAncientBin(PRTZIPCPIOREADER pThis, PCCPIOHDRBIN pHdr,
|
---|
| 151 | uint32_t *pcbFilePath, uint32_t *pcbPad)
|
---|
| 152 | {
|
---|
| 153 | RT_NOREF(pThis, pHdr, pcbFilePath, pcbPad);
|
---|
| 154 | return VERR_NOT_SUPPORTED;
|
---|
| 155 | }
|
---|
| 156 |
|
---|
| 157 |
|
---|
| 158 | /**
|
---|
| 159 | * Parses the given SuSv2 ASCII header and converts it to an FS object info structure.
|
---|
| 160 | *
|
---|
| 161 | * @returns IPRT status code.
|
---|
| 162 | * @param pThis The CPIO reader state.
|
---|
| 163 | * @param pHdr The header to convert.
|
---|
| 164 | * @param pcbFilePath Where to store the file path size on success.
|
---|
| 165 | * @param pcbPad Where to store the number of bytes padded after the header and file path
|
---|
| 166 | * before the content begins.
|
---|
| 167 | */
|
---|
| 168 | static int rtZipCpioReaderParseHeaderAsciiSusV2(PRTZIPCPIOREADER pThis, PCCPIOHDRSUSV2 pHdr,
|
---|
| 169 | uint32_t *pcbFilePath, uint32_t *pcbPad)
|
---|
| 170 | {
|
---|
| 171 | PRTFSOBJINFO pObjInfo = &pThis->ObjInfo;
|
---|
| 172 | int rc;
|
---|
| 173 | int64_t i64Tmp;
|
---|
| 174 | int64_t c64SecModTime;
|
---|
| 175 |
|
---|
| 176 | pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
|
---|
| 177 | pObjInfo->Attr.u.Unix.Device = 0;
|
---|
| 178 | pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
|
---|
| 179 |
|
---|
| 180 | #define GET_CPIO_NUMERIC_FIELD_RET(a_Var, a_Field) \
|
---|
| 181 | do { \
|
---|
| 182 | rc = rtZipCpioHdrOctalFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
|
---|
| 183 | if (RT_FAILURE(rc)) \
|
---|
| 184 | return rc; \
|
---|
| 185 | (a_Var) = i64Tmp; \
|
---|
| 186 | if ((a_Var) != i64Tmp) \
|
---|
| 187 | return VERR_TAR_NUM_VALUE_TOO_LARGE; \
|
---|
| 188 | } while (0)
|
---|
| 189 |
|
---|
| 190 | #define GET_CPIO_NUMERIC_FIELD_RET_U64(a_Var, a_Field) \
|
---|
| 191 | do { \
|
---|
| 192 | rc = rtZipCpioHdrOctalFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
|
---|
| 193 | if (RT_FAILURE(rc)) \
|
---|
| 194 | return rc; \
|
---|
| 195 | (a_Var) = (uint64_t)i64Tmp; \
|
---|
| 196 | if ((a_Var) != (uint64_t)i64Tmp) \
|
---|
| 197 | return VERR_TAR_NUM_VALUE_TOO_LARGE; \
|
---|
| 198 | } while (0)
|
---|
| 199 |
|
---|
| 200 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.fMode, pHdr->achMode);
|
---|
| 201 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.uid, pHdr->achUid);
|
---|
| 202 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.gid, pHdr->achGid);
|
---|
| 203 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.cHardlinks, pHdr->achNLinks);
|
---|
| 204 | GET_CPIO_NUMERIC_FIELD_RET_U64(pObjInfo->Attr.u.Unix.INodeId, pHdr->achInode);
|
---|
| 205 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.Device, pHdr->achDev);
|
---|
| 206 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->cbObject, pHdr->achFileSize);
|
---|
| 207 | pObjInfo->cbAllocated = pObjInfo->cbObject;
|
---|
| 208 | GET_CPIO_NUMERIC_FIELD_RET( c64SecModTime, pHdr->achMTime);
|
---|
| 209 | RTTimeSpecSetSeconds(&pObjInfo->ChangeTime, c64SecModTime);
|
---|
| 210 | RTTimeSpecSetSeconds(&pObjInfo->ModificationTime, c64SecModTime);
|
---|
| 211 | RTTimeSpecSetSeconds(&pObjInfo->AccessTime, c64SecModTime);
|
---|
| 212 | RTTimeSpecSetSeconds(&pObjInfo->BirthTime, c64SecModTime);
|
---|
| 213 | if (c64SecModTime != RTTimeSpecGetSeconds(&pObjInfo->ModificationTime))
|
---|
| 214 | return VERR_TAR_NUM_VALUE_TOO_LARGE;
|
---|
| 215 |
|
---|
| 216 | GET_CPIO_NUMERIC_FIELD_RET(*pcbFilePath, pHdr->achNameSize);
|
---|
| 217 |
|
---|
| 218 | /* There is never any padding. */
|
---|
| 219 | *pcbPad = 0;
|
---|
| 220 |
|
---|
| 221 | #undef GET_CPIO_NUMERIC_FIELD_RET
|
---|
| 222 | #undef GET_CPIO_NUMERIC_FIELD_RET_U64
|
---|
| 223 |
|
---|
| 224 | return rc;
|
---|
| 225 | }
|
---|
| 226 |
|
---|
| 227 |
|
---|
| 228 | /**
|
---|
| 229 | * Parses the given "new" ASCII header and converts it to an FS object info structure.
|
---|
| 230 | *
|
---|
| 231 | * @returns IPRT status code.
|
---|
| 232 | * @param pThis The CPIO reader state.
|
---|
| 233 | * @param pHdr The header to convert.
|
---|
| 234 | * @param fWithChksum Flag whether the header uses the checksum field.
|
---|
| 235 | * @param pcbFilePath Where to store the file path size on success.
|
---|
| 236 | * @param pcbPad Where to store the number of bytes padded after the header and file path
|
---|
| 237 | * before the content begins.
|
---|
| 238 | */
|
---|
| 239 | static int rtZipCpioReaderParseHeaderAsciiNew(PRTZIPCPIOREADER pThis, PCCPIOHDRNEW pHdr, bool fWithChksum,
|
---|
| 240 | uint32_t *pcbFilePath, uint32_t *pcbPad)
|
---|
| 241 | {
|
---|
| 242 | RT_NOREF(fWithChksum); /** @todo */
|
---|
| 243 | PRTFSOBJINFO pObjInfo = &pThis->ObjInfo;
|
---|
| 244 | int rc;
|
---|
| 245 | int64_t i64Tmp;
|
---|
| 246 | int64_t c64SecModTime;
|
---|
| 247 | uint32_t uMajor, uMinor;
|
---|
| 248 |
|
---|
| 249 | pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
|
---|
| 250 | pObjInfo->Attr.u.Unix.Device = 0;
|
---|
| 251 | pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
|
---|
| 252 |
|
---|
| 253 | #define GET_CPIO_NUMERIC_FIELD_RET(a_Var, a_Field) \
|
---|
| 254 | do { \
|
---|
| 255 | rc = rtZipCpioHdrHexFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
|
---|
| 256 | if (RT_FAILURE(rc)) \
|
---|
| 257 | return rc; \
|
---|
| 258 | (a_Var) = i64Tmp; \
|
---|
| 259 | if ((a_Var) != i64Tmp) \
|
---|
| 260 | return VERR_TAR_NUM_VALUE_TOO_LARGE; \
|
---|
| 261 | } while (0)
|
---|
| 262 |
|
---|
| 263 | #define GET_CPIO_NUMERIC_FIELD_RET_U64(a_Var, a_Field) \
|
---|
| 264 | do { \
|
---|
| 265 | rc = rtZipCpioHdrHexFieldToNum(a_Field, sizeof(a_Field), &i64Tmp); \
|
---|
| 266 | if (RT_FAILURE(rc)) \
|
---|
| 267 | return rc; \
|
---|
| 268 | (a_Var) = (uint64_t)i64Tmp; \
|
---|
| 269 | if ((a_Var) != (uint64_t)i64Tmp) \
|
---|
| 270 | return VERR_TAR_NUM_VALUE_TOO_LARGE; \
|
---|
| 271 | } while (0)
|
---|
| 272 |
|
---|
| 273 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.fMode, pHdr->achMode);
|
---|
| 274 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.uid, pHdr->achUid);
|
---|
| 275 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.gid, pHdr->achGid);
|
---|
| 276 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->Attr.u.Unix.cHardlinks, pHdr->achNLinks);
|
---|
| 277 | GET_CPIO_NUMERIC_FIELD_RET_U64(pObjInfo->Attr.u.Unix.INodeId, pHdr->achInode);
|
---|
| 278 | GET_CPIO_NUMERIC_FIELD_RET( uMajor, pHdr->achDevMajor);
|
---|
| 279 | GET_CPIO_NUMERIC_FIELD_RET( uMinor, pHdr->achDevMinor);
|
---|
| 280 | GET_CPIO_NUMERIC_FIELD_RET( pObjInfo->cbObject, pHdr->achFileSize);
|
---|
| 281 | pObjInfo->cbAllocated = RT_ALIGN_64(pObjInfo->cbObject, 4);
|
---|
| 282 | GET_CPIO_NUMERIC_FIELD_RET( c64SecModTime, pHdr->achMTime);
|
---|
| 283 | RTTimeSpecSetSeconds(&pObjInfo->ChangeTime, c64SecModTime);
|
---|
| 284 | RTTimeSpecSetSeconds(&pObjInfo->ModificationTime, c64SecModTime);
|
---|
| 285 | RTTimeSpecSetSeconds(&pObjInfo->AccessTime, c64SecModTime);
|
---|
| 286 | RTTimeSpecSetSeconds(&pObjInfo->BirthTime, c64SecModTime);
|
---|
| 287 | if (c64SecModTime != RTTimeSpecGetSeconds(&pObjInfo->ModificationTime))
|
---|
| 288 | return VERR_TAR_NUM_VALUE_TOO_LARGE;
|
---|
| 289 | pObjInfo->Attr.u.Unix.Device = RTDEV_MAKE(uMajor, uMinor);
|
---|
| 290 | if ( uMajor != RTDEV_MAJOR(pObjInfo->Attr.u.Unix.Device)
|
---|
| 291 | || uMinor != RTDEV_MINOR(pObjInfo->Attr.u.Unix.Device))
|
---|
| 292 | return VERR_TAR_DEV_VALUE_TOO_LARGE;
|
---|
| 293 |
|
---|
| 294 | GET_CPIO_NUMERIC_FIELD_RET(*pcbFilePath, pHdr->achNameSize);
|
---|
| 295 |
|
---|
| 296 | /* Header and file path are padded with 0 bytes to a 4 byte boundary. */
|
---|
| 297 | uint32_t cbComp = *pcbFilePath + sizeof(*pHdr);
|
---|
| 298 | *pcbPad = RT_ALIGN_32(cbComp, 4) - cbComp;
|
---|
| 299 |
|
---|
| 300 | #undef GET_CPIO_NUMERIC_FIELD_RET
|
---|
| 301 | #undef GET_CPIO_NUMERIC_FIELD_RET_U64
|
---|
| 302 |
|
---|
| 303 | return rc;
|
---|
| 304 | }
|
---|
| 305 |
|
---|
| 306 |
|
---|
| 307 | /**
|
---|
| 308 | * Parses and validates a CPIO header.
|
---|
| 309 | *
|
---|
| 310 | * @returns IPRT status code.
|
---|
| 311 | * @param pThis The CPIO reader state.
|
---|
| 312 | * @param enmType The CPIO header type.
|
---|
| 313 | * @param pHdr The CPIO header that has been read.
|
---|
| 314 | * @param pcbFilePath Where to store the size of the file path on success.
|
---|
| 315 | * @param pcbPad Where to store the number of bytes padded after the header and file path
|
---|
| 316 | * before the content begins.
|
---|
| 317 | */
|
---|
| 318 | static int rtZipCpioReaderParseHeader(PRTZIPCPIOREADER pThis, RTZIPCPIOTYPE enmType, PCCPIOHDR pHdr,
|
---|
| 319 | uint32_t *pcbFilePath, uint32_t *pcbPad)
|
---|
| 320 | {
|
---|
| 321 | int rc;
|
---|
| 322 |
|
---|
| 323 | switch (enmType)
|
---|
| 324 | {
|
---|
| 325 | case RTZIPCPIOTYPE_ANCIENT_BIN:
|
---|
| 326 | rc = rtZipCpioReaderParseHeaderAncientBin(pThis, &pHdr->AncientBin,
|
---|
| 327 | pcbFilePath, pcbPad);
|
---|
| 328 | break;
|
---|
| 329 | case RTZIPCPIOTYPE_ASCII_SUSV2:
|
---|
| 330 | rc = rtZipCpioReaderParseHeaderAsciiSusV2(pThis, &pHdr->AsciiSuSv2,
|
---|
| 331 | pcbFilePath, pcbPad);
|
---|
| 332 | break;
|
---|
| 333 | case RTZIPCPIOTYPE_ASCII_NEW:
|
---|
| 334 | rc = rtZipCpioReaderParseHeaderAsciiNew(pThis, &pHdr->AsciiNew, false /*fWithChksum*/,
|
---|
| 335 | pcbFilePath, pcbPad);
|
---|
| 336 | break;
|
---|
| 337 | case RTZIPCPIOTYPE_ASCII_NEW_CHKSUM:
|
---|
| 338 | rc = rtZipCpioReaderParseHeaderAsciiNew(pThis, &pHdr->AsciiNew, true /*fWithChksum*/,
|
---|
| 339 | pcbFilePath, pcbPad);
|
---|
| 340 | break;
|
---|
| 341 | default:
|
---|
| 342 | AssertMsgFailedBreakStmt(("Invalid CPIO type %d\n", enmType), rc = VERR_INTERNAL_ERROR);
|
---|
| 343 | }
|
---|
| 344 |
|
---|
| 345 | return rc;
|
---|
| 346 | }
|
---|
| 347 |
|
---|
| 348 |
|
---|
| 349 | /**
|
---|
| 350 | * Reads the file path from the CPIO archive stream.
|
---|
| 351 | *
|
---|
| 352 | * @returns IPRT status code.
|
---|
| 353 | * @param hVfsIos The I/O stream to read from.
|
---|
| 354 | * @param pThis The CPIO reader state.
|
---|
| 355 | * @param cbFilePath Size of the file path in bytes.
|
---|
| 356 | */
|
---|
| 357 | static int rtZipCpioReaderReadPath(RTVFSIOSTREAM hVfsIos, PRTZIPCPIOREADER pThis, size_t cbFilePath)
|
---|
| 358 | {
|
---|
| 359 | if (cbFilePath >= sizeof(pThis->szName))
|
---|
| 360 | return VERR_TAR_NAME_TOO_LONG;
|
---|
| 361 |
|
---|
| 362 | size_t cbRead;
|
---|
| 363 | int rc = RTVfsIoStrmRead(hVfsIos, &pThis->szName[0], cbFilePath, true /*fBlocking*/, &cbRead);
|
---|
| 364 | if (RT_FAILURE(rc))
|
---|
| 365 | return rc;
|
---|
| 366 | if (cbRead != cbFilePath)
|
---|
| 367 | return VERR_TAR_UNEXPECTED_EOS;
|
---|
| 368 |
|
---|
| 369 | /* The read file name should be zero terminated at the end. */
|
---|
| 370 | if (pThis->szName[cbFilePath - 1] != '\0')
|
---|
| 371 | return VERR_TAR_MALFORMED_GNU_LONGXXXX;
|
---|
| 372 |
|
---|
| 373 | return VINF_SUCCESS;
|
---|
| 374 | }
|
---|
| 375 |
|
---|
| 376 |
|
---|
| 377 | /*
|
---|
| 378 | *
|
---|
| 379 | * T h e V F S F i l e s y s t e m S t r e a m B i t s.
|
---|
| 380 | * T h e V F S F i l e s y s t e m S t r e a m B i t s.
|
---|
| 381 | * T h e V F S F i l e s y s t e m S t r e a m B i t s.
|
---|
| 382 | *
|
---|
| 383 | */
|
---|
| 384 |
|
---|
| 385 | /**
|
---|
| 386 | * @interface_method_impl{RTVFSOBJOPS,pfnClose}
|
---|
| 387 | */
|
---|
| 388 | static DECLCALLBACK(int) rtZipCpioFssBaseObj_Close(void *pvThis)
|
---|
| 389 | {
|
---|
| 390 | PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
|
---|
| 391 |
|
---|
| 392 | /* Currently there is nothing we really have to do here. */
|
---|
| 393 | pThis->offHdr = -1;
|
---|
| 394 |
|
---|
| 395 | return VINF_SUCCESS;
|
---|
| 396 | }
|
---|
| 397 |
|
---|
| 398 |
|
---|
| 399 | /**
|
---|
| 400 | * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
|
---|
| 401 | */
|
---|
| 402 | static DECLCALLBACK(int) rtZipCpioFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 403 | {
|
---|
| 404 | PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
|
---|
| 405 |
|
---|
| 406 | /*
|
---|
| 407 | * Copy the desired data.
|
---|
| 408 | */
|
---|
| 409 | switch (enmAddAttr)
|
---|
| 410 | {
|
---|
| 411 | case RTFSOBJATTRADD_NOTHING:
|
---|
| 412 | case RTFSOBJATTRADD_UNIX:
|
---|
| 413 | *pObjInfo = pThis->ObjInfo;
|
---|
| 414 | break;
|
---|
| 415 |
|
---|
| 416 | case RTFSOBJATTRADD_UNIX_OWNER:
|
---|
| 417 | *pObjInfo = pThis->ObjInfo;
|
---|
| 418 | pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER;
|
---|
| 419 | pObjInfo->Attr.u.UnixOwner.uid = pThis->ObjInfo.Attr.u.Unix.uid;
|
---|
| 420 | pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
|
---|
| 421 | break;
|
---|
| 422 |
|
---|
| 423 | case RTFSOBJATTRADD_UNIX_GROUP:
|
---|
| 424 | *pObjInfo = pThis->ObjInfo;
|
---|
| 425 | pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP;
|
---|
| 426 | pObjInfo->Attr.u.UnixGroup.gid = pThis->ObjInfo.Attr.u.Unix.gid;
|
---|
| 427 | pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
|
---|
| 428 | break;
|
---|
| 429 |
|
---|
| 430 | case RTFSOBJATTRADD_EASIZE:
|
---|
| 431 | *pObjInfo = pThis->ObjInfo;
|
---|
| 432 | pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
|
---|
| 433 | RT_ZERO(pObjInfo->Attr.u);
|
---|
| 434 | break;
|
---|
| 435 |
|
---|
| 436 | default:
|
---|
| 437 | return VERR_NOT_SUPPORTED;
|
---|
| 438 | }
|
---|
| 439 |
|
---|
| 440 | return VINF_SUCCESS;
|
---|
| 441 | }
|
---|
| 442 |
|
---|
| 443 |
|
---|
| 444 | /**
|
---|
| 445 | * Tar filesystem base object operations.
|
---|
| 446 | */
|
---|
| 447 | static const RTVFSOBJOPS g_rtZipCpioFssBaseObjOps =
|
---|
| 448 | {
|
---|
| 449 | RTVFSOBJOPS_VERSION,
|
---|
| 450 | RTVFSOBJTYPE_BASE,
|
---|
| 451 | "CpioFsStream::Obj",
|
---|
| 452 | rtZipCpioFssBaseObj_Close,
|
---|
| 453 | rtZipCpioFssBaseObj_QueryInfo,
|
---|
[94291] | 454 | NULL,
|
---|
[86035] | 455 | RTVFSOBJOPS_VERSION
|
---|
| 456 | };
|
---|
| 457 |
|
---|
| 458 |
|
---|
| 459 | /**
|
---|
| 460 | * @interface_method_impl{RTVFSOBJOPS,pfnClose}
|
---|
| 461 | */
|
---|
| 462 | static DECLCALLBACK(int) rtZipCpioFssIos_Close(void *pvThis)
|
---|
| 463 | {
|
---|
| 464 | PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
|
---|
| 465 |
|
---|
| 466 | RTVfsIoStrmRelease(pThis->hVfsIos);
|
---|
| 467 | pThis->hVfsIos = NIL_RTVFSIOSTREAM;
|
---|
| 468 |
|
---|
| 469 | return rtZipCpioFssBaseObj_Close(&pThis->BaseObj);
|
---|
| 470 | }
|
---|
| 471 |
|
---|
| 472 |
|
---|
| 473 | /**
|
---|
| 474 | * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
|
---|
| 475 | */
|
---|
| 476 | static DECLCALLBACK(int) rtZipCpioFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 477 | {
|
---|
| 478 | PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
|
---|
| 479 | return rtZipCpioFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
|
---|
| 480 | }
|
---|
| 481 |
|
---|
| 482 |
|
---|
| 483 | /**
|
---|
| 484 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
|
---|
| 485 | */
|
---|
[100908] | 486 | static DECLCALLBACK(int) rtZipCpioFssIos_Read(void *pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
|
---|
[86035] | 487 | {
|
---|
| 488 | PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
|
---|
| 489 | Assert(pSgBuf->cSegs == 1);
|
---|
| 490 |
|
---|
| 491 | /*
|
---|
| 492 | * Make offset into a real offset so it's possible to do random access
|
---|
| 493 | * on CPIO files that are seekable. Fend of reads beyond the end of the
|
---|
| 494 | * stream.
|
---|
| 495 | */
|
---|
| 496 | if (off < 0)
|
---|
| 497 | off = pThis->offFile;
|
---|
| 498 | if (off >= pThis->cbFile)
|
---|
| 499 | return pcbRead ? VINF_EOF : VERR_EOF;
|
---|
| 500 |
|
---|
| 501 |
|
---|
| 502 | Assert(pThis->cbFile >= pThis->offFile);
|
---|
| 503 | uint64_t cbLeft = (uint64_t)(pThis->cbFile - off);
|
---|
| 504 | size_t cbToRead = pSgBuf->paSegs[0].cbSeg;
|
---|
| 505 | if (cbToRead > cbLeft)
|
---|
| 506 | {
|
---|
| 507 | if (!pcbRead)
|
---|
| 508 | return VERR_EOF;
|
---|
| 509 | cbToRead = (size_t)cbLeft;
|
---|
| 510 | }
|
---|
| 511 |
|
---|
| 512 | /*
|
---|
| 513 | * Do the reading.
|
---|
| 514 | */
|
---|
| 515 | size_t cbReadStack = 0;
|
---|
| 516 | if (!pcbRead)
|
---|
| 517 | pcbRead = &cbReadStack;
|
---|
| 518 | int rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offStart + off, pSgBuf->paSegs[0].pvSeg, cbToRead, fBlocking, pcbRead);
|
---|
| 519 | pThis->offFile = off + *pcbRead;
|
---|
[100908] | 520 | RTSgBufAdvance(pSgBuf, *pcbRead);
|
---|
| 521 |
|
---|
[86035] | 522 | if (pThis->offFile >= pThis->cbFile)
|
---|
| 523 | {
|
---|
| 524 | Assert(pThis->offFile == pThis->cbFile);
|
---|
| 525 | pThis->fEndOfStream = true;
|
---|
| 526 | RTVfsIoStrmSkip(pThis->hVfsIos, pThis->cbPadding);
|
---|
| 527 | }
|
---|
| 528 |
|
---|
| 529 | return rc;
|
---|
| 530 | }
|
---|
| 531 |
|
---|
| 532 |
|
---|
| 533 | /**
|
---|
| 534 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
|
---|
| 535 | */
|
---|
[100908] | 536 | static DECLCALLBACK(int) rtZipCpioFssIos_Write(void *pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
|
---|
[86035] | 537 | {
|
---|
| 538 | /* Cannot write to a read-only I/O stream. */
|
---|
| 539 | NOREF(pvThis); NOREF(off); NOREF(pSgBuf); NOREF(fBlocking); NOREF(pcbWritten);
|
---|
| 540 | return VERR_ACCESS_DENIED;
|
---|
| 541 | }
|
---|
| 542 |
|
---|
| 543 |
|
---|
| 544 | /**
|
---|
| 545 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
|
---|
| 546 | */
|
---|
| 547 | static DECLCALLBACK(int) rtZipCpioFssIos_Flush(void *pvThis)
|
---|
| 548 | {
|
---|
| 549 | /* It's a read only stream, nothing dirty to flush. */
|
---|
| 550 | NOREF(pvThis);
|
---|
| 551 | return VINF_SUCCESS;
|
---|
| 552 | }
|
---|
| 553 |
|
---|
| 554 |
|
---|
| 555 | /**
|
---|
| 556 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
|
---|
| 557 | */
|
---|
| 558 | static DECLCALLBACK(int) rtZipCpioFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
|
---|
| 559 | uint32_t *pfRetEvents)
|
---|
| 560 | {
|
---|
| 561 | PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
|
---|
| 562 |
|
---|
| 563 | /* When we've reached the end, read will be set to indicate it. */
|
---|
| 564 | if ( (fEvents & RTPOLL_EVT_READ)
|
---|
| 565 | && pThis->fEndOfStream)
|
---|
| 566 | {
|
---|
| 567 | int rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, 0, fIntr, pfRetEvents);
|
---|
| 568 | if (RT_SUCCESS(rc))
|
---|
| 569 | *pfRetEvents |= RTPOLL_EVT_READ;
|
---|
| 570 | else
|
---|
| 571 | *pfRetEvents = RTPOLL_EVT_READ;
|
---|
| 572 | return VINF_SUCCESS;
|
---|
| 573 | }
|
---|
| 574 |
|
---|
| 575 | return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
|
---|
| 576 | }
|
---|
| 577 |
|
---|
| 578 |
|
---|
| 579 | /**
|
---|
| 580 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
|
---|
| 581 | */
|
---|
| 582 | static DECLCALLBACK(int) rtZipCpioFssIos_Tell(void *pvThis, PRTFOFF poffActual)
|
---|
| 583 | {
|
---|
| 584 | PRTZIPCPIOIOSTREAM pThis = (PRTZIPCPIOIOSTREAM)pvThis;
|
---|
| 585 | *poffActual = pThis->offFile;
|
---|
| 586 | return VINF_SUCCESS;
|
---|
| 587 | }
|
---|
| 588 |
|
---|
| 589 |
|
---|
| 590 | /**
|
---|
| 591 | * Tar I/O stream operations.
|
---|
| 592 | */
|
---|
| 593 | static const RTVFSIOSTREAMOPS g_rtZipCpioFssIosOps =
|
---|
| 594 | {
|
---|
| 595 | { /* Obj */
|
---|
| 596 | RTVFSOBJOPS_VERSION,
|
---|
| 597 | RTVFSOBJTYPE_IO_STREAM,
|
---|
| 598 | "CpioFsStream::IoStream",
|
---|
| 599 | rtZipCpioFssIos_Close,
|
---|
| 600 | rtZipCpioFssIos_QueryInfo,
|
---|
[94291] | 601 | NULL,
|
---|
[86035] | 602 | RTVFSOBJOPS_VERSION
|
---|
| 603 | },
|
---|
| 604 | RTVFSIOSTREAMOPS_VERSION,
|
---|
| 605 | RTVFSIOSTREAMOPS_FEAT_NO_SG,
|
---|
| 606 | rtZipCpioFssIos_Read,
|
---|
| 607 | rtZipCpioFssIos_Write,
|
---|
| 608 | rtZipCpioFssIos_Flush,
|
---|
| 609 | rtZipCpioFssIos_PollOne,
|
---|
| 610 | rtZipCpioFssIos_Tell,
|
---|
| 611 | NULL /*Skip*/,
|
---|
| 612 | NULL /*ZeroFill*/,
|
---|
| 613 | RTVFSIOSTREAMOPS_VERSION
|
---|
| 614 | };
|
---|
| 615 |
|
---|
| 616 |
|
---|
| 617 | /**
|
---|
| 618 | * @interface_method_impl{RTVFSOBJOPS,pfnClose}
|
---|
| 619 | */
|
---|
| 620 | static DECLCALLBACK(int) rtZipCpioFssSym_Close(void *pvThis)
|
---|
| 621 | {
|
---|
| 622 | PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
|
---|
| 623 | return rtZipCpioFssBaseObj_Close(pThis);
|
---|
| 624 | }
|
---|
| 625 |
|
---|
| 626 |
|
---|
| 627 | /**
|
---|
| 628 | * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
|
---|
| 629 | */
|
---|
| 630 | static DECLCALLBACK(int) rtZipCpioFssSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 631 | {
|
---|
| 632 | PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
|
---|
| 633 | return rtZipCpioFssBaseObj_QueryInfo(pThis, pObjInfo, enmAddAttr);
|
---|
| 634 | }
|
---|
| 635 |
|
---|
| 636 | /**
|
---|
| 637 | * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
|
---|
| 638 | */
|
---|
| 639 | static DECLCALLBACK(int) rtZipCpioFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
|
---|
| 640 | {
|
---|
| 641 | NOREF(pvThis); NOREF(fMode); NOREF(fMask);
|
---|
| 642 | return VERR_ACCESS_DENIED;
|
---|
| 643 | }
|
---|
| 644 |
|
---|
| 645 |
|
---|
| 646 | /**
|
---|
| 647 | * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
|
---|
| 648 | */
|
---|
| 649 | static DECLCALLBACK(int) rtZipCpioFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
|
---|
| 650 | PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
|
---|
| 651 | {
|
---|
| 652 | NOREF(pvThis); NOREF(pAccessTime); NOREF(pModificationTime); NOREF(pChangeTime); NOREF(pBirthTime);
|
---|
| 653 | return VERR_ACCESS_DENIED;
|
---|
| 654 | }
|
---|
| 655 |
|
---|
| 656 |
|
---|
| 657 | /**
|
---|
| 658 | * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
|
---|
| 659 | */
|
---|
| 660 | static DECLCALLBACK(int) rtZipCpioFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
|
---|
| 661 | {
|
---|
| 662 | NOREF(pvThis); NOREF(uid); NOREF(gid);
|
---|
| 663 | return VERR_ACCESS_DENIED;
|
---|
| 664 | }
|
---|
| 665 |
|
---|
| 666 |
|
---|
| 667 | /**
|
---|
| 668 | * @interface_method_impl{RTVFSSYMLINKOPS,pfnRead}
|
---|
| 669 | */
|
---|
| 670 | static DECLCALLBACK(int) rtZipCpioFssSym_Read(void *pvThis, char *pszTarget, size_t cbTarget)
|
---|
| 671 | {
|
---|
| 672 | PRTZIPCPIOBASEOBJ pThis = (PRTZIPCPIOBASEOBJ)pvThis;
|
---|
| 673 | return RTStrCopy(pszTarget, cbTarget, pThis->pCpioReader->szTarget);
|
---|
| 674 | }
|
---|
| 675 |
|
---|
| 676 |
|
---|
| 677 | /**
|
---|
| 678 | * CPIO symbolic (and hardlink) operations.
|
---|
| 679 | */
|
---|
| 680 | static const RTVFSSYMLINKOPS g_rtZipCpioFssSymOps =
|
---|
| 681 | {
|
---|
| 682 | { /* Obj */
|
---|
| 683 | RTVFSOBJOPS_VERSION,
|
---|
| 684 | RTVFSOBJTYPE_SYMLINK,
|
---|
| 685 | "CpioFsStream::Symlink",
|
---|
| 686 | rtZipCpioFssSym_Close,
|
---|
| 687 | rtZipCpioFssSym_QueryInfo,
|
---|
[94291] | 688 | NULL,
|
---|
[86035] | 689 | RTVFSOBJOPS_VERSION
|
---|
| 690 | },
|
---|
| 691 | RTVFSSYMLINKOPS_VERSION,
|
---|
| 692 | 0,
|
---|
| 693 | { /* ObjSet */
|
---|
| 694 | RTVFSOBJSETOPS_VERSION,
|
---|
| 695 | RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
|
---|
| 696 | rtZipCpioFssSym_SetMode,
|
---|
| 697 | rtZipCpioFssSym_SetTimes,
|
---|
| 698 | rtZipCpioFssSym_SetOwner,
|
---|
| 699 | RTVFSOBJSETOPS_VERSION
|
---|
| 700 | },
|
---|
| 701 | rtZipCpioFssSym_Read,
|
---|
| 702 | RTVFSSYMLINKOPS_VERSION
|
---|
| 703 | };
|
---|
| 704 |
|
---|
| 705 |
|
---|
| 706 | /**
|
---|
| 707 | * @interface_method_impl{RTVFSOBJOPS,pfnClose}
|
---|
| 708 | */
|
---|
| 709 | static DECLCALLBACK(int) rtZipCpioFss_Close(void *pvThis)
|
---|
| 710 | {
|
---|
| 711 | PRTZIPCPIOFSSTREAM pThis = (PRTZIPCPIOFSSTREAM)pvThis;
|
---|
| 712 |
|
---|
| 713 | RTVfsObjRelease(pThis->hVfsCurObj);
|
---|
| 714 | pThis->hVfsCurObj = NIL_RTVFSOBJ;
|
---|
| 715 | pThis->pCurIosData = NULL;
|
---|
| 716 |
|
---|
| 717 | RTVfsIoStrmRelease(pThis->hVfsIos);
|
---|
| 718 | pThis->hVfsIos = NIL_RTVFSIOSTREAM;
|
---|
| 719 |
|
---|
| 720 | return VINF_SUCCESS;
|
---|
| 721 | }
|
---|
| 722 |
|
---|
| 723 |
|
---|
| 724 | /**
|
---|
| 725 | * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
|
---|
| 726 | */
|
---|
| 727 | static DECLCALLBACK(int) rtZipCpioFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 728 | {
|
---|
| 729 | PRTZIPCPIOFSSTREAM pThis = (PRTZIPCPIOFSSTREAM)pvThis;
|
---|
| 730 | /* Take the lazy approach here, with the sideffect of providing some info
|
---|
| 731 | that is actually kind of useful. */
|
---|
| 732 | return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
|
---|
| 733 | }
|
---|
| 734 |
|
---|
| 735 |
|
---|
| 736 | /**
|
---|
| 737 | * @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
|
---|
| 738 | */
|
---|
| 739 | DECL_HIDDEN_CALLBACK(int) rtZipCpioFss_Next(void *pvThis, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj)
|
---|
| 740 | {
|
---|
| 741 | PRTZIPCPIOFSSTREAM pThis = (PRTZIPCPIOFSSTREAM)pvThis;
|
---|
| 742 |
|
---|
| 743 | /*
|
---|
| 744 | * Dispense with the current object.
|
---|
| 745 | */
|
---|
| 746 | if (pThis->hVfsCurObj != NIL_RTVFSOBJ)
|
---|
| 747 | {
|
---|
| 748 | if (pThis->pCurIosData)
|
---|
| 749 | {
|
---|
| 750 | pThis->pCurIosData->fEndOfStream = true;
|
---|
| 751 | pThis->pCurIosData->offFile = pThis->pCurIosData->cbFile;
|
---|
| 752 | pThis->pCurIosData = NULL;
|
---|
| 753 | }
|
---|
| 754 |
|
---|
| 755 | RTVfsObjRelease(pThis->hVfsCurObj);
|
---|
| 756 | pThis->hVfsCurObj = NIL_RTVFSOBJ;
|
---|
| 757 | }
|
---|
| 758 |
|
---|
| 759 | /*
|
---|
| 760 | * Check if we've already reached the end in some way.
|
---|
| 761 | */
|
---|
| 762 | if (pThis->fEndOfStream)
|
---|
| 763 | return VERR_EOF;
|
---|
| 764 | if (pThis->rcFatal != VINF_SUCCESS)
|
---|
| 765 | return pThis->rcFatal;
|
---|
| 766 |
|
---|
| 767 | /*
|
---|
| 768 | * Make sure the input stream is in the right place.
|
---|
| 769 | */
|
---|
| 770 | RTFOFF offHdr = RTVfsIoStrmTell(pThis->hVfsIos);
|
---|
| 771 | while ( offHdr >= 0
|
---|
| 772 | && offHdr < pThis->offNextHdr)
|
---|
| 773 | {
|
---|
| 774 | int rc = RTVfsIoStrmSkip(pThis->hVfsIos, pThis->offNextHdr - offHdr);
|
---|
| 775 | if (RT_FAILURE(rc))
|
---|
| 776 | {
|
---|
| 777 | /** @todo Ignore if we're at the end of the stream? */
|
---|
| 778 | return pThis->rcFatal = rc;
|
---|
| 779 | }
|
---|
| 780 |
|
---|
| 781 | offHdr = RTVfsIoStrmTell(pThis->hVfsIos);
|
---|
| 782 | }
|
---|
| 783 |
|
---|
| 784 | if (offHdr < 0)
|
---|
| 785 | return pThis->rcFatal = (int)offHdr;
|
---|
| 786 | if (offHdr > pThis->offNextHdr)
|
---|
| 787 | return pThis->rcFatal = VERR_INTERNAL_ERROR_3;
|
---|
| 788 | Assert(pThis->offNextHdr == offHdr);
|
---|
| 789 | pThis->offCurHdr = offHdr;
|
---|
| 790 |
|
---|
| 791 | /*
|
---|
| 792 | * Consume CPIO headers.
|
---|
| 793 | */
|
---|
| 794 | size_t cbHdr = 0;
|
---|
| 795 | /*
|
---|
| 796 | * Read the next header.
|
---|
| 797 | *
|
---|
| 798 | * Read the first 6 bytes to determine the header type and continue reading the
|
---|
| 799 | * rest of the header.
|
---|
| 800 | */
|
---|
| 801 | CPIOHDR Hdr;
|
---|
| 802 | RTZIPCPIOTYPE enmHdrType = RTZIPCPIOTYPE_INVALID;
|
---|
| 803 | size_t cbRead;
|
---|
| 804 | int rc = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr.ab[0], sizeof(Hdr.AsciiNew.achMagic), true /*fBlocking*/, &cbRead);
|
---|
| 805 | if (RT_FAILURE(rc))
|
---|
| 806 | return pThis->rcFatal = rc;
|
---|
| 807 | if (rc == VINF_EOF && cbRead == 0)
|
---|
| 808 | {
|
---|
| 809 | pThis->fEndOfStream = true;
|
---|
| 810 | return VERR_EOF;
|
---|
| 811 | }
|
---|
| 812 | if (cbRead != sizeof(Hdr.AsciiNew.achMagic))
|
---|
| 813 | return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
|
---|
| 814 |
|
---|
| 815 | if (Hdr.AncientBin.u16Magic == CPIO_HDR_BIN_MAGIC)
|
---|
| 816 | {
|
---|
| 817 | cbHdr = sizeof(Hdr.AncientBin);
|
---|
| 818 | enmHdrType = RTZIPCPIOTYPE_ANCIENT_BIN;
|
---|
| 819 | }
|
---|
| 820 | else if (!strncmp(&Hdr.AsciiSuSv2.achMagic[0], CPIO_HDR_SUSV2_MAGIC, sizeof(Hdr.AsciiSuSv2.achMagic)))
|
---|
| 821 | {
|
---|
| 822 | cbHdr = sizeof(Hdr.AsciiSuSv2);
|
---|
| 823 | enmHdrType = RTZIPCPIOTYPE_ASCII_SUSV2;
|
---|
| 824 | }
|
---|
| 825 | else if (!strncmp(&Hdr.AsciiNew.achMagic[0], CPIO_HDR_NEW_MAGIC, sizeof(Hdr.AsciiNew.achMagic)))
|
---|
| 826 | {
|
---|
| 827 | cbHdr = sizeof(Hdr.AsciiNew);
|
---|
| 828 | enmHdrType = RTZIPCPIOTYPE_ASCII_NEW;
|
---|
| 829 | }
|
---|
| 830 | else if (!strncmp(&Hdr.AsciiNew.achMagic[0], CPIO_HDR_NEW_CHKSUM_MAGIC, sizeof(Hdr.AsciiNew.achMagic)))
|
---|
| 831 | {
|
---|
| 832 | cbHdr = sizeof(Hdr.AsciiNew);
|
---|
| 833 | enmHdrType = RTZIPCPIOTYPE_ASCII_NEW_CHKSUM;
|
---|
| 834 | }
|
---|
| 835 | else
|
---|
| 836 | return pThis->rcFatal = VERR_TAR_UNKNOWN_TYPE_FLAG; /** @todo Dedicated status code. */
|
---|
| 837 |
|
---|
| 838 | /* Read the rest of the header. */
|
---|
| 839 | size_t cbHdrLeft = cbHdr - sizeof(Hdr.AsciiNew.achMagic);
|
---|
| 840 | rc = RTVfsIoStrmRead(pThis->hVfsIos, &Hdr.ab[sizeof(Hdr.AsciiNew.achMagic)], cbHdr - sizeof(Hdr.AsciiNew.achMagic), true /*fBlocking*/, &cbRead);
|
---|
| 841 | if (RT_FAILURE(rc))
|
---|
| 842 | return pThis->rcFatal = rc;
|
---|
| 843 | if (cbRead != cbHdrLeft)
|
---|
| 844 | return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
|
---|
| 845 |
|
---|
| 846 | /*
|
---|
| 847 | * Parse it.
|
---|
| 848 | */
|
---|
| 849 | uint32_t cbFilePath = 0;
|
---|
| 850 | uint32_t cbPad = 0;
|
---|
| 851 | rc = rtZipCpioReaderParseHeader(&pThis->CpioReader, enmHdrType, &Hdr, &cbFilePath, &cbPad);
|
---|
| 852 | if (RT_FAILURE(rc))
|
---|
| 853 | return pThis->rcFatal = rc;
|
---|
| 854 |
|
---|
| 855 | /* Read the file path following the header. */
|
---|
| 856 | rc = rtZipCpioReaderReadPath(pThis->hVfsIos, &pThis->CpioReader, cbFilePath);
|
---|
| 857 | if (RT_FAILURE(rc))
|
---|
| 858 | return pThis->rcFatal = rc;
|
---|
| 859 |
|
---|
| 860 | if (cbPad)
|
---|
| 861 | RTVfsIoStrmSkip(pThis->hVfsIos, cbPad);
|
---|
| 862 | pThis->offNextHdr = offHdr + cbHdr + cbFilePath + cbPad;
|
---|
| 863 |
|
---|
| 864 | /*
|
---|
| 865 | * CPIO uses a special trailer file record with a 0 mode and size and using a special
|
---|
| 866 | * marker filename. The filesystem stream is marked EOS When such a record is encountered
|
---|
| 867 | * to not try to read anything which might come behind it, imagine an initramfs image consisting
|
---|
| 868 | * of multiple archives which don't need to be necessarily be all of the CPIO kind (yes, this is
|
---|
| 869 | * a reality with ubuntu for example containing microcode updates as seperate CPIO archives
|
---|
| 870 | * coming before the main LZ4 compressed CPIO archive...).
|
---|
| 871 | */
|
---|
| 872 | PCRTFSOBJINFO pInfo = &pThis->CpioReader.ObjInfo;
|
---|
| 873 | if (RT_UNLIKELY( !pInfo->Attr.fMode
|
---|
| 874 | && !pInfo->cbAllocated
|
---|
| 875 | && !strcmp(&pThis->CpioReader.szName[0], CPIO_EOS_FILE_NAME)))
|
---|
| 876 | {
|
---|
| 877 | pThis->fEndOfStream = true;
|
---|
| 878 | return VERR_EOF;
|
---|
| 879 | }
|
---|
| 880 |
|
---|
| 881 | /*
|
---|
| 882 | * Create an object of the appropriate type.
|
---|
| 883 | */
|
---|
| 884 | RTVFSOBJTYPE enmType;
|
---|
| 885 | RTVFSOBJ hVfsObj;
|
---|
| 886 | RTFMODE fType = pInfo->Attr.fMode & RTFS_TYPE_MASK;
|
---|
| 887 | switch (fType)
|
---|
| 888 | {
|
---|
| 889 | /*
|
---|
| 890 | * Files are represented by a VFS I/O stream, hardlinks have their content
|
---|
| 891 | * embedded as it is another file.
|
---|
| 892 | */
|
---|
| 893 | case RTFS_TYPE_FILE:
|
---|
| 894 | {
|
---|
| 895 | RTVFSIOSTREAM hVfsIos;
|
---|
| 896 | PRTZIPCPIOIOSTREAM pIosData;
|
---|
| 897 | rc = RTVfsNewIoStream(&g_rtZipCpioFssIosOps,
|
---|
| 898 | sizeof(*pIosData),
|
---|
| 899 | RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
|
---|
| 900 | NIL_RTVFS,
|
---|
| 901 | NIL_RTVFSLOCK,
|
---|
| 902 | &hVfsIos,
|
---|
| 903 | (void **)&pIosData);
|
---|
| 904 | if (RT_FAILURE(rc))
|
---|
| 905 | return pThis->rcFatal = rc;
|
---|
| 906 |
|
---|
| 907 | pIosData->BaseObj.offHdr = offHdr;
|
---|
| 908 | pIosData->BaseObj.offNextHdr = pThis->offNextHdr;
|
---|
| 909 | pIosData->BaseObj.pCpioReader = &pThis->CpioReader;
|
---|
| 910 | pIosData->BaseObj.ObjInfo = *pInfo;
|
---|
| 911 | pIosData->cbFile = pInfo->cbObject;
|
---|
| 912 | pIosData->offFile = 0;
|
---|
| 913 | pIosData->offStart = RTVfsIoStrmTell(pThis->hVfsIos);
|
---|
| 914 | pIosData->cbPadding = (uint32_t)(pInfo->cbAllocated - pInfo->cbObject);
|
---|
| 915 | pIosData->fEndOfStream = false;
|
---|
| 916 | pIosData->hVfsIos = pThis->hVfsIos;
|
---|
| 917 | RTVfsIoStrmRetain(pThis->hVfsIos);
|
---|
| 918 |
|
---|
| 919 | pThis->pCurIosData = pIosData;
|
---|
| 920 | pThis->offNextHdr += pIosData->cbFile + pIosData->cbPadding;
|
---|
| 921 |
|
---|
| 922 | enmType = RTVFSOBJTYPE_IO_STREAM;
|
---|
| 923 | hVfsObj = RTVfsObjFromIoStream(hVfsIos);
|
---|
| 924 | RTVfsIoStrmRelease(hVfsIos);
|
---|
| 925 | break;
|
---|
| 926 | }
|
---|
| 927 |
|
---|
| 928 | case RTFS_TYPE_SYMLINK:
|
---|
| 929 | {
|
---|
| 930 | RTVFSSYMLINK hVfsSym;
|
---|
| 931 | PRTZIPCPIOBASEOBJ pBaseObjData;
|
---|
| 932 | rc = RTVfsNewSymlink(&g_rtZipCpioFssSymOps,
|
---|
| 933 | sizeof(*pBaseObjData),
|
---|
| 934 | NIL_RTVFS,
|
---|
| 935 | NIL_RTVFSLOCK,
|
---|
| 936 | &hVfsSym,
|
---|
| 937 | (void **)&pBaseObjData);
|
---|
| 938 | if (RT_FAILURE(rc))
|
---|
| 939 | return pThis->rcFatal = rc;
|
---|
| 940 |
|
---|
| 941 | pBaseObjData->offHdr = offHdr;
|
---|
| 942 | pBaseObjData->offNextHdr = pThis->offNextHdr;
|
---|
| 943 | pBaseObjData->pCpioReader = &pThis->CpioReader;
|
---|
| 944 | pBaseObjData->ObjInfo = *pInfo;
|
---|
| 945 |
|
---|
| 946 | /* Read the body of the symlink (as normal file data). */
|
---|
| 947 | if (pInfo->cbObject + 1 > (RTFOFF)sizeof(pThis->CpioReader.szTarget))
|
---|
| 948 | return VERR_TAR_NAME_TOO_LONG;
|
---|
| 949 |
|
---|
| 950 | cbPad = (uint32_t)(pInfo->cbAllocated - pInfo->cbObject);
|
---|
| 951 | rc = RTVfsIoStrmRead(pThis->hVfsIos, &pThis->CpioReader.szTarget[0], pInfo->cbObject, true /*fBlocking*/, &cbRead);
|
---|
| 952 | if (RT_FAILURE(rc))
|
---|
| 953 | return pThis->rcFatal = rc;
|
---|
| 954 | if (cbRead != (uint32_t)pInfo->cbObject)
|
---|
| 955 | return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
|
---|
| 956 |
|
---|
| 957 | pThis->CpioReader.szTarget[pInfo->cbObject] = '\0';
|
---|
| 958 |
|
---|
| 959 | if (cbPad)
|
---|
| 960 | rc = RTVfsIoStrmSkip(pThis->hVfsIos, cbPad);
|
---|
| 961 | if (RT_FAILURE(rc))
|
---|
| 962 | return pThis->rcFatal = rc;
|
---|
| 963 |
|
---|
| 964 | pThis->offNextHdr += pInfo->cbAllocated;
|
---|
| 965 |
|
---|
| 966 | enmType = RTVFSOBJTYPE_SYMLINK;
|
---|
| 967 | hVfsObj = RTVfsObjFromSymlink(hVfsSym);
|
---|
| 968 | RTVfsSymlinkRelease(hVfsSym);
|
---|
| 969 | break;
|
---|
| 970 | }
|
---|
| 971 |
|
---|
| 972 | /*
|
---|
| 973 | * All other objects are repesented using a VFS base object since they
|
---|
| 974 | * carry no data streams.
|
---|
| 975 | */
|
---|
| 976 | case RTFS_TYPE_DEV_BLOCK:
|
---|
| 977 | case RTFS_TYPE_DEV_CHAR:
|
---|
| 978 | case RTFS_TYPE_DIRECTORY:
|
---|
| 979 | case RTFS_TYPE_FIFO:
|
---|
| 980 | {
|
---|
| 981 | PRTZIPCPIOBASEOBJ pBaseObjData;
|
---|
| 982 | rc = RTVfsNewBaseObj(&g_rtZipCpioFssBaseObjOps,
|
---|
| 983 | sizeof(*pBaseObjData),
|
---|
| 984 | NIL_RTVFS,
|
---|
| 985 | NIL_RTVFSLOCK,
|
---|
| 986 | &hVfsObj,
|
---|
| 987 | (void **)&pBaseObjData);
|
---|
| 988 | if (RT_FAILURE(rc))
|
---|
| 989 | return pThis->rcFatal = rc;
|
---|
| 990 |
|
---|
| 991 | pBaseObjData->offHdr = offHdr;
|
---|
| 992 | pBaseObjData->offNextHdr = pThis->offNextHdr;
|
---|
| 993 | pBaseObjData->pCpioReader = &pThis->CpioReader;
|
---|
| 994 | pBaseObjData->ObjInfo = *pInfo;
|
---|
| 995 |
|
---|
| 996 | enmType = RTVFSOBJTYPE_BASE;
|
---|
| 997 | break;
|
---|
| 998 | }
|
---|
| 999 |
|
---|
| 1000 | default:
|
---|
| 1001 | AssertFailed();
|
---|
| 1002 | return pThis->rcFatal = VERR_INTERNAL_ERROR_5;
|
---|
| 1003 | }
|
---|
| 1004 | pThis->hVfsCurObj = hVfsObj;
|
---|
| 1005 |
|
---|
| 1006 | /*
|
---|
| 1007 | * Set the return data and we're done.
|
---|
| 1008 | */
|
---|
| 1009 | if (ppszName)
|
---|
| 1010 | {
|
---|
| 1011 | rc = RTStrDupEx(ppszName, pThis->CpioReader.szName);
|
---|
| 1012 | if (RT_FAILURE(rc))
|
---|
| 1013 | return rc;
|
---|
| 1014 | }
|
---|
| 1015 |
|
---|
| 1016 | if (phVfsObj)
|
---|
| 1017 | {
|
---|
| 1018 | RTVfsObjRetain(hVfsObj);
|
---|
| 1019 | *phVfsObj = hVfsObj;
|
---|
| 1020 | }
|
---|
| 1021 |
|
---|
| 1022 | if (penmType)
|
---|
| 1023 | *penmType = enmType;
|
---|
| 1024 |
|
---|
| 1025 | return VINF_SUCCESS;
|
---|
| 1026 | }
|
---|
| 1027 |
|
---|
| 1028 |
|
---|
| 1029 |
|
---|
| 1030 | /**
|
---|
| 1031 | * CPIO filesystem stream operations.
|
---|
| 1032 | */
|
---|
| 1033 | static const RTVFSFSSTREAMOPS rtZipCpioFssOps =
|
---|
| 1034 | {
|
---|
| 1035 | { /* Obj */
|
---|
| 1036 | RTVFSOBJOPS_VERSION,
|
---|
| 1037 | RTVFSOBJTYPE_FS_STREAM,
|
---|
| 1038 | "CpioFsStream",
|
---|
| 1039 | rtZipCpioFss_Close,
|
---|
| 1040 | rtZipCpioFss_QueryInfo,
|
---|
[94291] | 1041 | NULL,
|
---|
[86035] | 1042 | RTVFSOBJOPS_VERSION
|
---|
| 1043 | },
|
---|
| 1044 | RTVFSFSSTREAMOPS_VERSION,
|
---|
| 1045 | 0,
|
---|
| 1046 | rtZipCpioFss_Next,
|
---|
| 1047 | NULL,
|
---|
| 1048 | NULL,
|
---|
| 1049 | NULL,
|
---|
| 1050 | RTVFSFSSTREAMOPS_VERSION
|
---|
| 1051 | };
|
---|
| 1052 |
|
---|
| 1053 |
|
---|
| 1054 | /**
|
---|
| 1055 | * Internal function use both by RTZipCpioFsStreamFromIoStream() and by
|
---|
| 1056 | * RTZipCpioFsStreamForFile() in updating mode.
|
---|
| 1057 | */
|
---|
| 1058 | DECLHIDDEN(void) rtZipCpioReaderInit(PRTZIPCPIOFSSTREAM pThis, RTVFSIOSTREAM hVfsIos, uint64_t offStart)
|
---|
| 1059 | {
|
---|
| 1060 | pThis->hVfsIos = hVfsIos;
|
---|
| 1061 | pThis->hVfsCurObj = NIL_RTVFSOBJ;
|
---|
| 1062 | pThis->pCurIosData = NULL;
|
---|
| 1063 | pThis->offStart = offStart;
|
---|
| 1064 | pThis->offNextHdr = offStart;
|
---|
| 1065 | pThis->fEndOfStream = false;
|
---|
| 1066 | pThis->rcFatal = VINF_SUCCESS;
|
---|
| 1067 |
|
---|
| 1068 | /* Don't check if it's a CPIO stream here, do that in the
|
---|
| 1069 | rtZipCpioFss_Next. */
|
---|
| 1070 | }
|
---|
| 1071 |
|
---|
| 1072 |
|
---|
| 1073 | RTDECL(int) RTZipCpioFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
|
---|
| 1074 | {
|
---|
| 1075 | /*
|
---|
| 1076 | * Input validation.
|
---|
| 1077 | */
|
---|
| 1078 | AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
|
---|
| 1079 | *phVfsFss = NIL_RTVFSFSSTREAM;
|
---|
| 1080 | AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
|
---|
| 1081 | AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
|
---|
| 1082 |
|
---|
| 1083 | RTFOFF const offStart = RTVfsIoStrmTell(hVfsIosIn);
|
---|
| 1084 | AssertReturn(offStart >= 0, (int)offStart);
|
---|
| 1085 |
|
---|
| 1086 | uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
|
---|
| 1087 | AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
|
---|
| 1088 |
|
---|
| 1089 | /*
|
---|
| 1090 | * Retain the input stream and create a new filesystem stream handle.
|
---|
| 1091 | */
|
---|
| 1092 | PRTZIPCPIOFSSTREAM pThis;
|
---|
| 1093 | RTVFSFSSTREAM hVfsFss;
|
---|
| 1094 | int rc = RTVfsNewFsStream(&rtZipCpioFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, RTFILE_O_READ,
|
---|
| 1095 | &hVfsFss, (void **)&pThis);
|
---|
| 1096 | if (RT_SUCCESS(rc))
|
---|
| 1097 | {
|
---|
| 1098 | rtZipCpioReaderInit(pThis, hVfsIosIn, fFlags);
|
---|
| 1099 | *phVfsFss = hVfsFss;
|
---|
| 1100 | return VINF_SUCCESS;
|
---|
| 1101 | }
|
---|
| 1102 |
|
---|
| 1103 | RTVfsIoStrmRelease(hVfsIosIn);
|
---|
| 1104 | return rc;
|
---|
| 1105 | }
|
---|
| 1106 |
|
---|
| 1107 |
|
---|
| 1108 | /**
|
---|
| 1109 | * Used by RTZipCpioFsStreamTruncate to resolve @a hVfsObj.
|
---|
| 1110 | */
|
---|
| 1111 | DECLHIDDEN(PRTZIPCPIOBASEOBJ) rtZipCpioFsStreamBaseObjToPrivate(PRTZIPCPIOFSSTREAM pThis, RTVFSOBJ hVfsObj)
|
---|
| 1112 | {
|
---|
| 1113 | PRTZIPCPIOBASEOBJ pThisObj;
|
---|
| 1114 | RTVFSOBJTYPE enmType = RTVfsObjGetType(hVfsObj);
|
---|
| 1115 | switch (enmType)
|
---|
| 1116 | {
|
---|
| 1117 | case RTVFSOBJTYPE_IO_STREAM:
|
---|
| 1118 | {
|
---|
| 1119 | RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
|
---|
| 1120 | AssertReturn(hVfsIos != NIL_RTVFSIOSTREAM, NULL);
|
---|
| 1121 | PRTZIPCPIOIOSTREAM pThisStrm = (PRTZIPCPIOIOSTREAM)RTVfsIoStreamToPrivate(hVfsIos, &g_rtZipCpioFssIosOps);
|
---|
| 1122 | RTVfsIoStrmRelease(hVfsIos);
|
---|
| 1123 | pThisObj = &pThisStrm->BaseObj;
|
---|
| 1124 | break;
|
---|
| 1125 | }
|
---|
| 1126 |
|
---|
| 1127 | case RTVFSOBJTYPE_SYMLINK:
|
---|
| 1128 | {
|
---|
| 1129 | RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
|
---|
| 1130 | AssertReturn(hVfsSymlink != NIL_RTVFSSYMLINK, NULL);
|
---|
| 1131 | pThisObj = (PRTZIPCPIOBASEOBJ)RTVfsSymlinkToPrivate(hVfsSymlink, &g_rtZipCpioFssSymOps);
|
---|
| 1132 | RTVfsSymlinkRelease(hVfsSymlink);
|
---|
| 1133 | break;
|
---|
| 1134 | }
|
---|
| 1135 |
|
---|
| 1136 | case RTVFSOBJTYPE_BASE:
|
---|
| 1137 | pThisObj = (PRTZIPCPIOBASEOBJ)RTVfsObjToPrivate(hVfsObj, &g_rtZipCpioFssBaseObjOps);
|
---|
| 1138 | break;
|
---|
| 1139 |
|
---|
| 1140 | default:
|
---|
| 1141 | /** @todo implement. */
|
---|
| 1142 | AssertFailedReturn(NULL);
|
---|
| 1143 | }
|
---|
| 1144 |
|
---|
| 1145 | AssertReturn(pThisObj->pCpioReader == &pThis->CpioReader, NULL);
|
---|
| 1146 | return pThisObj;
|
---|
| 1147 | }
|
---|
| 1148 |
|
---|