LCOV - code coverage report
Current view: top level - lib/Support - TarWriter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 64 65 98.5 %
Date: 2018-09-23 13:06:45 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13