Add CpioReader for reading CPIO archives

Databean · Databean · commit c12f426dd1dc · 2026-04-18T01:42:56.000Z
Bug: b/503906646
diff --git a/base/cvd/cuttlefish/io/BUILD.bazel b/base/cvd/cuttlefish/io/BUILD.bazel
@@ -81,6 +81,33 @@ cf_cc_test(
     ],
 )
 
+cf_cc_library(
+    name = "cpio",
+    srcs = ["cpio.cc"],
+    hdrs = ["cpio.h"],
+    deps = [
+        "//cuttlefish/common/libs/utils:size_utils",
+        "//cuttlefish/io",
+        "//cuttlefish/io:filesystem",
+        "//cuttlefish/io:read_exact",
+        "//cuttlefish/io:read_window_view",
+        "//cuttlefish/result:expect",
+        "//cuttlefish/result:result_type",
+    ],
+)
+
+cf_cc_test(
+    name = "cpio_test",
+    srcs = ["cpio_test.cc"],
+    deps = [
+        "//cuttlefish/io:cpio",
+        "//cuttlefish/io:in_memory",
+        "//cuttlefish/io:read_exact",
+        "//cuttlefish/io:string",
+        "//cuttlefish/result:result_matchers",
+    ],
+)
+
 cf_cc_library(
     name = "default_visitor",
     srcs = ["default_visitor.cc"],
diff --git a/base/cvd/cuttlefish/io/cpio.cc b/base/cvd/cuttlefish/io/cpio.cc
@@ -0,0 +1,236 @@
+//
+// Copyright (C) 2026 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cuttlefish/io/cpio.h"
+
+#include <endian.h>
+#include <string.h>
+
+#include <charconv>
+#include <string_view>
+
+#include "cuttlefish/common/libs/utils/size_utils.h"
+#include "cuttlefish/io/read_exact.h"
+#include "cuttlefish/io/read_window_view.h"
+#include "cuttlefish/result/expect.h"
+
+namespace cuttlefish {
+
+// For the CPIO file format specification, see:
+// https://github.com/libyal/dtformats/blob/c55446a4369149bb109bf783f29a2838c7328718/documentation/Copy%20in%20and%20out%20(CPIO)%20archive%20format.asciidoc
+namespace {
+
+constexpr std::string_view kMagicNewc1 = "070701";
+constexpr std::string_view kMagicNewc2 = "070702";
+constexpr std::string_view kMagicOdc = "070707";
+constexpr std::string_view kTrailerName = "TRAILER!!!";
+
+Result<uint32_t> ParseHex(const char* buf, size_t size) {
+  uint32_t val = 0;
+  std::from_chars_result result = std::from_chars(buf, buf + size, val, 16);
+  CF_EXPECT(result.ec == std::errc(), "Failed to parse hex value");
+  return val;
+}
+
+Result<uint32_t> ParseOctal(const char* buf, size_t size) {
+  uint32_t val = 0;
+  std::from_chars_result result = std::from_chars(buf, buf + size, val, 8);
+  CF_EXPECT(result.ec == std::errc(), "Failed to parse octal value");
+  return val;
+}
+
+uint16_t Read16(const char* ptr, bool file_is_big_endian) {
+  uint16_t val;
+  memcpy(&val, ptr, sizeof(val));  // Guarantees alignment of `val`
+  return file_is_big_endian ? be16toh(val) : le16toh(val);
+}
+
+uint32_t Read32(const char* ptr, bool file_is_big_endian) {
+  uint32_t val;
+  memcpy(&val, ptr, sizeof(val));  // Guarantees alignment of `val`
+  return file_is_big_endian ? be32toh(val) : le32toh(val);
+}
+
+}  // namespace
+
+Result<std::unique_ptr<CpioReader>> CpioReader::Open(
+    std::unique_ptr<ReaderSeeker> reader) {
+  CF_EXPECT(reader != nullptr, "Reader is null");
+  std::map<std::string, FileEntry, std::less<>> entries =
+      CF_EXPECT(Parse(*reader));
+  return std::unique_ptr<CpioReader>(
+      new CpioReader(std::move(reader), std::move(entries)));
+}
+
+CpioReader::CpioReader(std::unique_ptr<ReaderSeeker> reader,
+                       std::map<std::string, FileEntry, std::less<>> entries)
+    : reader_(std::move(reader)), entries_(std::move(entries)) {}
+
+Result<std::map<std::string, CpioReader::FileEntry, std::less<>>>
+CpioReader::Parse(ReaderSeeker& reader) {
+  char magic[6];
+  CF_EXPECT(PReadExact(reader, magic, 6, 0));
+
+  // Check for binary magic (2 bytes)
+  uint8_t m0 = static_cast<uint8_t>(magic[0]);
+  uint8_t m1 = static_cast<uint8_t>(magic[1]);
+  if (m0 == 0xC7 && m1 == 0x71) {
+    return ParseBin(reader, false);
+  } else if (m0 == 0x71 && m1 == 0xC7) {
+    return ParseBin(reader, true);
+  }
+
+  std::string_view magic_view(magic, 6);
+  if (magic_view == kMagicNewc1 || magic_view == kMagicNewc2) {
+    return ParseNewc(reader);
+  } else if (magic_view == kMagicOdc) {
+    return ParseOdc(reader);
+  } else {
+    return CF_ERRF("Unknown cpio magic: {}", magic_view);
+  }
+}
+
+Result<std::map<std::string, CpioReader::FileEntry, std::less<>>>
+CpioReader::ParseNewc(ReaderSeeker& reader) {
+  std::map<std::string, FileEntry, std::less<>> entries;
+  uint64_t offset = 0;
+  while (true) {
+    // Align to 4 bytes before reading header
+    offset = AlignToPowerOf2(offset, 2);
+
+    char header[110];
+    CF_EXPECT(PReadExact(reader, header, 110, offset));
+
+    std::string_view magic(header, 6);
+    CF_EXPECT(magic == kMagicNewc1 || magic == kMagicNewc2,
+              "Invalid magic in header");
+
+    uint32_t filesize = CF_EXPECT(ParseHex(header + 54, 8));
+    uint32_t namesize = CF_EXPECT(ParseHex(header + 94, 8));
+    uint32_t mode = CF_EXPECT(ParseHex(header + 14, 8));
+
+    std::string name(namesize - 1, '\0');
+    CF_EXPECT(PReadExact(reader, name.data(), namesize - 1, offset + 110));
+
+    if (name == kTrailerName) {
+      break;
+    }
+
+    uint64_t data_offset = AlignToPowerOf2(offset + 110 + namesize, 2);
+
+    entries.emplace(std::move(name), FileEntry{
+                                         .offset = data_offset,
+                                         .size = filesize,
+                                         .mode = mode,
+                                     });
+
+    offset = data_offset + filesize;
+  }
+  return entries;
+}
+
+Result<std::map<std::string, CpioReader::FileEntry, std::less<>>>
+CpioReader::ParseOdc(ReaderSeeker& reader) {
+  std::map<std::string, FileEntry, std::less<>> entries;
+  uint64_t offset = 0;
+  while (true) {
+    char header[76];
+    CF_EXPECT(PReadExact(reader, header, 76, offset));
+
+    std::string_view magic(header, 6);
+    CF_EXPECT_EQ(magic, kMagicOdc, "Invalid magic in header");
+
+    uint32_t mode = CF_EXPECT(ParseOctal(header + 18, 6));
+    uint32_t namesize = CF_EXPECT(ParseOctal(header + 59, 6));
+    uint32_t filesize = CF_EXPECT(ParseOctal(header + 65, 11));
+
+    std::string name(namesize - 1, '\0');
+    CF_EXPECT(PReadExact(reader, name.data(), namesize - 1, offset + 76));
+
+    if (name == kTrailerName) {
+      break;
+    }
+
+    uint64_t data_offset = offset + 76 + namesize;
+
+    entries.emplace(std::move(name), FileEntry{
+                                         .offset = data_offset,
+                                         .size = filesize,
+                                         .mode = mode,
+                                     });
+
+    offset = data_offset + filesize;
+  }
+  return entries;
+}
+
+Result<std::map<std::string, CpioReader::FileEntry, std::less<>>>
+CpioReader::ParseBin(ReaderSeeker& reader, bool file_is_big_endian) {
+  std::map<std::string, FileEntry, std::less<>> entries;
+  uint64_t offset = 0;
+  while (true) {
+    char header[26];
+    CF_EXPECT(PReadExact(reader, header, 26, offset));
+
+    uint8_t m0 = static_cast<uint8_t>(header[0]);
+    uint8_t m1 = static_cast<uint8_t>(header[1]);
+    if (file_is_big_endian) {
+      CF_EXPECT(m0 == 0x71 && m1 == 0xC7, "Invalid magic in binary header");
+    } else {
+      CF_EXPECT(m0 == 0xC7 && m1 == 0x71, "Invalid magic in binary header");
+    }
+
+    // It is possible to define a packed struct for this type, but the
+    // `filesize` member is not aligned and would not be safe to read directly
+    // from the struct.
+    uint16_t mode = Read16(header + 6, file_is_big_endian);
+    uint16_t namesize = Read16(header + 20, file_is_big_endian);
+    uint32_t filesize = Read32(header + 22, file_is_big_endian);
+
+    std::string name(namesize - 1, '\0');
+    CF_EXPECT(PReadExact(reader, name.data(), namesize - 1, offset + 26));
+
+    if (name == kTrailerName) {
+      break;
+    }
+
+    uint64_t data_offset = AlignToPowerOf2(offset + 26 + namesize, 1);
+
+    entries.emplace(std::move(name), FileEntry{
+                                         .offset = data_offset,
+                                         .size = filesize,
+                                         .mode = mode,
+                                     });
+
+    offset = AlignToPowerOf2(data_offset + filesize, 1);
+  }
+  return entries;
+}
+
+Result<std::unique_ptr<ReaderSeeker>> CpioReader::OpenReadOnly(
+    std::string_view path) {
+  auto it = entries_.find(path);
+  CF_EXPECTF(it != entries_.end(), "File not found in cpio: '{}'", path);
+  return std::make_unique<ReadWindowView>(*reader_, it->second.offset,
+                                          it->second.size);
+}
+
+Result<uint32_t> CpioReader::FileAttributes(std::string_view path) const {
+  auto it = entries_.find(path);
+  CF_EXPECTF(it != entries_.end(), "File not found in cpio: '{}'", path);
+  return it->second.mode;
+}
+
+}  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/io/cpio.h b/base/cvd/cuttlefish/io/cpio.h
@@ -0,0 +1,64 @@
+//
+// Copyright (C) 2026 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <string_view>
+
+#include "cuttlefish/io/filesystem.h"
+#include "cuttlefish/io/io.h"
+#include "cuttlefish/result/result_type.h"
+
+namespace cuttlefish {
+
+class CpioReader : public ReadFilesystem {
+ public:
+  static Result<std::unique_ptr<CpioReader>> Open(
+      std::unique_ptr<ReaderSeeker> reader);
+
+  Result<std::unique_ptr<ReaderSeeker>> OpenReadOnly(
+      std::string_view path) override;
+
+  Result<uint32_t> FileAttributes(std::string_view path) const override;
+
+ private:
+  struct FileEntry {
+    uint64_t offset;
+    uint64_t size;
+    uint32_t mode;
+  };
+
+  CpioReader(std::unique_ptr<ReaderSeeker> reader,
+             std::map<std::string, FileEntry, std::less<>> entries);
+
+  static Result<std::map<std::string, FileEntry, std::less<>>> Parse(
+      ReaderSeeker& reader);
+  static Result<std::map<std::string, FileEntry, std::less<>>> ParseOdc(
+      ReaderSeeker& reader);
+  static Result<std::map<std::string, FileEntry, std::less<>>> ParseNewc(
+      ReaderSeeker& reader);
+  static Result<std::map<std::string, FileEntry, std::less<>>> ParseBin(
+      ReaderSeeker& reader, bool file_is_big_endian);
+
+  std::unique_ptr<ReaderSeeker> reader_;
+  std::map<std::string, FileEntry, std::less<>> entries_;
+};
+
+}  // namespace cuttlefish
diff --git a/base/cvd/cuttlefish/io/cpio_test.cc b/base/cvd/cuttlefish/io/cpio_test.cc
