contrib/llvm/lib/Support/TarWriter.cpp

   1 //===-- TarWriter.cpp - Tar archive file creator --------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // TarWriter class provides a feature to create a tar archive file.
  10 //
  11 // I put emphasis on simplicity over comprehensiveness when implementing this
  12 // class because we don't need a full-fledged archive file generator in LLVM
  13 // at the moment.
  14 //
  15 // The filename field in the Unix V7 tar header is 100 bytes. Longer filenames
  16 // are stored using the PAX extension. The PAX header is standardized in
  17 // POSIX.1-2001.
  18 //
  19 // The struct definition of UstarHeader is copied from
  20 // https://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5
  21 //
  22 //===----------------------------------------------------------------------===//
  23
  24 #include "llvm/Support/TarWriter.h"
  25 #include "llvm/ADT/StringRef.h"
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/MathExtras.h"
  28 #include "llvm/Support/Path.h"
  29
  30 using namespace llvm;
  31
  32 // Each file in an archive must be aligned to this block size.
  33 static const int BlockSize = 512;
  34
  35 struct UstarHeader {
  36   char Name[100];
  37   char Mode[8];
  38   char Uid[8];
  39   char Gid[8];
  40   char Size[12];
  41   char Mtime[12];
  42   char Checksum[8];
  43   char TypeFlag;
  44   char Linkname[100];
  45   char Magic[6];
  46   char Version[2];
  47   char Uname[32];
  48   char Gname[32];
  49   char DevMajor[8];
  50   char DevMinor[8];
  51   char Prefix[155];
  52   char Pad[12];
  53 };
  54 static_assert(sizeof(UstarHeader) == BlockSize, "invalid Ustar header");
  55
  56 static UstarHeader makeUstarHeader() {
  57   UstarHeader Hdr = {};
  58   memcpy(Hdr.Magic, "ustar", 5); // Ustar magic
  59   memcpy(Hdr.Version, "00", 2);  // Ustar version
  60   return Hdr;
  61 }
  62
  63 // A PAX attribute is in the form of "<length> <key>=<value>\n"
  64 // where <length> is the length of the entire string including
  65 // the length field itself. An example string is this.
  66 //
  67 //   25 ctime=1084839148.1212\n
  68 //
  69 // This function create such string.
  70 static std::string formatPax(StringRef Key, StringRef Val) {
  71   int Len = Key.size() + Val.size() + 3; // +3 for " ", "=" and "\n"
  72
  73   // We need to compute total size twice because appending
  74   // a length field could change total size by one.
  75   int Total = Len + Twine(Len).str().size();
  76   Total = Len + Twine(Total).str().size();
  77   return (Twine(Total) + " " + Key + "=" + Val + "\n").str();
  78 }
  79
  80 // Headers in tar files must be aligned to 512 byte boundaries.
  81 // This function forwards the current file position to the next boundary.
  82 static void pad(raw_fd_ostream &OS) {
  83   uint64_t Pos = OS.tell();
  84   OS.seek(alignTo(Pos, BlockSize));
  85 }
  86
  87 // Computes a checksum for a tar header.
  88 static void computeChecksum(UstarHeader &Hdr) {
  89   // Before computing a checksum, checksum field must be
  90   // filled with space characters.
  91   memset(Hdr.Checksum, ' ', sizeof(Hdr.Checksum));
  92
  93   // Compute a checksum and set it to the checksum field.
  94   unsigned Chksum = 0;
  95   for (size_t I = 0; I < sizeof(Hdr); ++I)
  96     Chksum += reinterpret_cast<uint8_t *>(&Hdr)[I];
  97   snprintf(Hdr.Checksum, sizeof(Hdr.Checksum), "%06o", Chksum);
  98 }
  99
 100 // Create a tar header and write it to a given output stream.
 101 static void writePaxHeader(raw_fd_ostream &OS, StringRef Path) {
 102   // A PAX header consists of a 512-byte header followed
 103   // by key-value strings. First, create key-value strings.
 104   std::string PaxAttr = formatPax("path", Path);
 105
 106   // Create a 512-byte header.
 107   UstarHeader Hdr = makeUstarHeader();
 108   snprintf(Hdr.Size, sizeof(Hdr.Size), "%011zo", PaxAttr.size());
 109   Hdr.TypeFlag = 'x'; // PAX magic
 110   computeChecksum(Hdr);
 111
 112   // Write them down.
 113   OS << StringRef(reinterpret_cast<char *>(&Hdr), sizeof(Hdr));
 114   OS << PaxAttr;
 115   pad(OS);
 116 }
 117
 118 // Path fits in a Ustar header if
 119 //
 120 // - Path is less than 100 characters long, or
 121 // - Path is in the form of "<prefix>/<name>" where <prefix> is less
 122 //   than or equal to 155 characters long and <name> is less than 100
 123 //   characters long. Both <prefix> and <name> can contain extra '/'.
 124 //
 125 // If Path fits in a Ustar header, updates Prefix and Name and returns true.
 126 // Otherwise, returns false.
 127 static bool splitUstar(StringRef Path, StringRef &Prefix, StringRef &Name) {
 128   if (Path.size() < sizeof(UstarHeader::Name)) {
 129     Prefix = "";
 130     Name = Path;
 131     return true;
 132   }
 133
 134   size_t Sep = Path.rfind('/', sizeof(UstarHeader::Prefix) + 1);
 135   if (Sep == StringRef::npos)
 136     return false;
 137   if (Path.size() - Sep - 1 >= sizeof(UstarHeader::Name))
 138     return false;
 139
 140   Prefix = Path.substr(0, Sep);
 141   Name = Path.substr(Sep + 1);
 142   return true;
 143 }
 144
 145 // The PAX header is an extended format, so a PAX header needs
 146 // to be followed by a "real" header.
 147 static void writeUstarHeader(raw_fd_ostream &OS, StringRef Prefix,
 148                              StringRef Name, size_t Size) {
 149   UstarHeader Hdr = makeUstarHeader();
 150   memcpy(Hdr.Name, Name.data(), Name.size());
 151   memcpy(Hdr.Mode, "0000664", 8);
 152   snprintf(Hdr.Size, sizeof(Hdr.Size), "%011zo", Size);
 153   memcpy(Hdr.Prefix, Prefix.data(), Prefix.size());
 154   computeChecksum(Hdr);
 155   OS << StringRef(reinterpret_cast<char *>(&Hdr), sizeof(Hdr));
 156 }
 157
 158 // Creates a TarWriter instance and returns it.
 159 Expected<std::unique_ptr<TarWriter>> TarWriter::create(StringRef OutputPath,
 160                                                        StringRef BaseDir) {
 161   using namespace sys::fs;
 162   int FD;
 163   if (std::error_code EC =
 164           openFileForWrite(OutputPath, FD, CD_CreateAlways, OF_None))
 165     return make_error<StringError>("cannot open " + OutputPath, EC);
 166   return std::unique_ptr<TarWriter>(new TarWriter(FD, BaseDir));
 167 }
 168
 169 TarWriter::TarWriter(int FD, StringRef BaseDir)
 170     : OS(FD, /*shouldClose=*/true, /*unbuffered=*/false), BaseDir(BaseDir) {}
 171
 172 // Append a given file to an archive.
 173 void TarWriter::append(StringRef Path, StringRef Data) {
 174   // Write Path and Data.
 175   std::string Fullpath = BaseDir + "/" + sys::path::convert_to_slash(Path);
 176
 177   // We do not want to include the same file more than once.
 178   if (!Files.insert(Fullpath).second)
 179     return;
 180
 181   StringRef Prefix;
 182   StringRef Name;
 183   if (splitUstar(Fullpath, Prefix, Name)) {
 184     writeUstarHeader(OS, Prefix, Name, Data.size());
 185   } else {
 186     writePaxHeader(OS, Fullpath);
 187     writeUstarHeader(OS, "", "", Data.size());
 188   }
 189
 190   OS << Data;
 191   pad(OS);
 192
 193   // POSIX requires tar archives end with two null blocks.
 194   // Here, we write the terminator and then seek back, so that
 195   // the file being output is terminated correctly at any moment.
 196   uint64_t Pos = OS.tell();
 197   OS << std::string(BlockSize * 2, '\0');
 198   OS.seek(Pos);
 199   OS.flush();
 200 }