2017-01-06 10:29:48 +08:00
|
|
|
//===-- TarWriter.cpp - Tar archive file creator --------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// TarWriter class provides a feature to create a tar archive file.
|
|
|
|
//
|
2017-01-06 13:33:45 +08:00
|
|
|
// I put emphasis on simplicity over comprehensiveness when implementing this
|
|
|
|
// class because we don't need a full-fledged archive file generator in LLVM
|
|
|
|
// at the moment.
|
2017-01-06 10:29:48 +08:00
|
|
|
//
|
2017-01-06 13:33:45 +08:00
|
|
|
// The filename field in the Unix V7 tar header is 100 bytes. Longer filenames
|
|
|
|
// are stored using the PAX extension. The PAX header is standardized in
|
|
|
|
// POSIX.1-2001.
|
2017-01-06 10:29:48 +08:00
|
|
|
//
|
|
|
|
// The struct definition of UstarHeader is copied from
|
|
|
|
// https://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Support/TarWriter.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
#include "llvm/Support/FileSystem.h"
|
|
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
// Each file in an archive must be aligned to this block size.
|
|
|
|
static const int BlockSize = 512;
|
|
|
|
|
|
|
|
struct UstarHeader {
|
|
|
|
char Name[100];
|
|
|
|
char Mode[8];
|
|
|
|
char Uid[8];
|
|
|
|
char Gid[8];
|
|
|
|
char Size[12];
|
|
|
|
char Mtime[12];
|
|
|
|
char Checksum[8];
|
|
|
|
char TypeFlag;
|
|
|
|
char Linkname[100];
|
|
|
|
char Magic[6];
|
|
|
|
char Version[2];
|
|
|
|
char Uname[32];
|
|
|
|
char Gname[32];
|
|
|
|
char DevMajor[8];
|
|
|
|
char DevMinor[8];
|
|
|
|
char Prefix[155];
|
|
|
|
char Pad[12];
|
|
|
|
};
|
|
|
|
static_assert(sizeof(UstarHeader) == BlockSize, "invalid Ustar header");
|
|
|
|
|
|
|
|
// A PAX attribute is in the form of "<length> <key>=<value>\n"
|
|
|
|
// where <length> is the length of the entire string including
|
|
|
|
// the length field itself. An example string is this.
|
|
|
|
//
|
|
|
|
// 25 ctime=1084839148.1212\n
|
|
|
|
//
|
|
|
|
// This function create such string.
|
2017-01-06 13:33:45 +08:00
|
|
|
static std::string formatPax(StringRef Key, StringRef Val) {
|
|
|
|
int Len = Key.size() + Val.size() + 3; // +3 for " ", "=" and "\n"
|
2017-01-06 10:29:48 +08:00
|
|
|
|
|
|
|
// We need to compute total size twice because appending
|
|
|
|
// a length field could change total size by one.
|
|
|
|
int Total = Len + Twine(Len).str().size();
|
|
|
|
Total = Len + Twine(Total).str().size();
|
|
|
|
return (Twine(Total) + " " + Key + "=" + Val + "\n").str();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Headers in tar files must be aligned to 512 byte boundaries.
|
2017-01-06 13:33:45 +08:00
|
|
|
// This function forwards the current file position to the next boundary.
|
2017-01-06 10:29:48 +08:00
|
|
|
static void pad(raw_fd_ostream &OS) {
|
|
|
|
uint64_t Pos = OS.tell();
|
|
|
|
OS.seek(alignTo(Pos, BlockSize));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Computes a checksum for a tar header.
|
|
|
|
static void computeChecksum(UstarHeader &Hdr) {
|
|
|
|
// Before computing a checksum, checksum field must be
|
|
|
|
// filled with space characters.
|
|
|
|
memset(Hdr.Checksum, ' ', sizeof(Hdr.Checksum));
|
|
|
|
|
|
|
|
// Compute a checksum and set it to the checksum field.
|
|
|
|
unsigned Chksum = 0;
|
|
|
|
for (size_t I = 0; I < sizeof(Hdr); ++I)
|
|
|
|
Chksum += reinterpret_cast<uint8_t *>(&Hdr)[I];
|
|
|
|
sprintf(Hdr.Checksum, "%06o", Chksum);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a tar header and write it to a given output stream.
|
2017-01-06 13:33:45 +08:00
|
|
|
static void writePaxHeader(raw_fd_ostream &OS, StringRef Path) {
|
2017-01-06 10:29:48 +08:00
|
|
|
// A PAX header consists of a 512-byte header followed
|
|
|
|
// by key-value strings. First, create key-value strings.
|
|
|
|
std::string PaxAttr = formatPax("path", Path);
|
|
|
|
|
|
|
|
// Create a 512-byte header.
|
|
|
|
UstarHeader Hdr = {};
|
|
|
|
sprintf(Hdr.Size, "%011lo", PaxAttr.size());
|
|
|
|
Hdr.TypeFlag = 'x'; // PAX magic
|
|
|
|
memcpy(Hdr.Magic, "ustar", 6); // Ustar magic
|
|
|
|
computeChecksum(Hdr);
|
|
|
|
|
|
|
|
// Write them down.
|
|
|
|
OS << StringRef(reinterpret_cast<char *>(&Hdr), sizeof(Hdr));
|
|
|
|
OS << PaxAttr;
|
|
|
|
pad(OS);
|
|
|
|
}
|
|
|
|
|
|
|
|
// The PAX header is an extended format, so a PAX header needs
|
|
|
|
// to be followed by a "real" header.
|
2017-01-06 13:33:45 +08:00
|
|
|
static void writeUstarHeader(raw_fd_ostream &OS, StringRef Path, size_t Size) {
|
2017-01-06 10:29:48 +08:00
|
|
|
UstarHeader Hdr = {};
|
2017-01-06 13:33:45 +08:00
|
|
|
memcpy(Hdr.Name, Path.data(), Path.size());
|
2017-01-06 10:29:48 +08:00
|
|
|
strcpy(Hdr.Mode, "0000664");
|
|
|
|
sprintf(Hdr.Size, "%011lo", Size);
|
|
|
|
memcpy(Hdr.Magic, "ustar", 6);
|
|
|
|
computeChecksum(Hdr);
|
|
|
|
OS << StringRef(reinterpret_cast<char *>(&Hdr), sizeof(Hdr));
|
|
|
|
}
|
|
|
|
|
|
|
|
// We want to use '/' as a path separator even on Windows.
|
|
|
|
// This function canonicalizes a given path.
|
|
|
|
static std::string canonicalize(std::string S) {
|
|
|
|
#ifdef LLVM_ON_WIN32
|
|
|
|
std::replace(S.begin(), S.end(), '\\', '/');
|
|
|
|
#endif
|
|
|
|
return S;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates a TarWriter instance and returns it.
|
|
|
|
Expected<std::unique_ptr<TarWriter>> TarWriter::create(StringRef OutputPath,
|
|
|
|
StringRef BaseDir) {
|
|
|
|
int FD;
|
|
|
|
if (std::error_code EC = openFileForWrite(OutputPath, FD, sys::fs::F_None))
|
|
|
|
return make_error<StringError>("cannot open " + OutputPath, EC);
|
|
|
|
return std::unique_ptr<TarWriter>(new TarWriter(FD, BaseDir));
|
|
|
|
}
|
|
|
|
|
|
|
|
TarWriter::TarWriter(int FD, StringRef BaseDir)
|
|
|
|
: OS(FD, /*shouldClose=*/true, /*unbuffered=*/false), BaseDir(BaseDir) {}
|
|
|
|
|
|
|
|
// Append a given file to an archive.
|
|
|
|
void TarWriter::append(StringRef Path, StringRef Data) {
|
|
|
|
// Write Path and Data.
|
2017-01-06 13:33:45 +08:00
|
|
|
std::string S = BaseDir + "/" + canonicalize(Path) + "\0";
|
|
|
|
if (S.size() <= sizeof(UstarHeader::Name)) {
|
|
|
|
writeUstarHeader(OS, S, Data.size());
|
|
|
|
} else {
|
|
|
|
writePaxHeader(OS, S);
|
|
|
|
writeUstarHeader(OS, "", Data.size());
|
|
|
|
}
|
|
|
|
|
2017-01-06 10:29:48 +08:00
|
|
|
OS << Data;
|
|
|
|
pad(OS);
|
|
|
|
|
|
|
|
// POSIX requires tar archives end with two null blocks.
|
|
|
|
// Here, we write the terminator and then seek back, so that
|
|
|
|
// the file being output is terminated correctly at any moment.
|
|
|
|
uint64_t Pos = OS.tell();
|
|
|
|
OS << std::string(BlockSize * 2, '\0');
|
|
|
|
OS.seek(Pos);
|
|
|
|
OS.flush();
|
|
|
|
}
|