swift-stdlib-tool.cpp

//===----------------------------------------------------------------------===//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

const char *usage = 
    "  swift-stdlib-tool --print [options...]\n"
    "    Find and print the Swift libraries required by an app.\n"
    "\n"
    "  swift-stdlib-tool --copy [options...]\n"
    "    Copy the Swift libraries into an app bundle, and optionally sign them.\n"
    "\n"
    "  --verbose\n"
    "      Print progress.\n"
    "  --verbose --verbose\n"
    "      Print debugging details.\n"
    "  --help\n"
    "      Print usage.\n"
    "\n"
    "  Options for lookup:\n"
    "  --scan-executable <path>\n"
    "      Scan the executable at <path> for references to Swift libraries.\n"
    "      This option may be set multiple times.\n"
    "  --scan-folder <path>\n"
    "      Scan any executables inside <path> for references to Swift libraries.\n"
    "      This option may be set multiple times.\n"
    "  --platform <macosx|iphoneos|iphonesimulator>\n"
    "      Use the Swift libraries for <platform>.\n"
    "  --source-libraries <path>\n"
    "      Search <path> for Swift libraries.\n"
    "      The default is /path/to/swift-stdlib-tool/../../lib/swift/<platform>/\n"
    "\n"
    "  Options for copying and signing:\n"
    "  --destination <path>\n"
    "      Copy Swift libraries into <path>.\n"
    "  --unsigned-destination <path>\n"
    "      Copy Swift libraries into <path> without signing them.\n"
    "  --sign <identity>\n"
    "      Sign copied Swift libraries using <identity>.\n"
    "  --keychain <keychain>\n"
    "      Search <keychain> for the code signing identity.\n"
    "  --Xcodesign <option>\n"
    "      Pass <option> to the codesign tool.\n"
    "  --strip-bitcode\n"
    "      Remove embedded bitcode from libraries copied to --destination.\n"
    "      Libraries copied to --unsigned-destination are unmodified.\n"
    "\n"
    "  Options for libraries copied as resources\n"
    "  --resource-library <library>\n"
    "      Copy <library> and its dependencies as resources without signing\n"
    "      them. These copies are in addition to any libraries copied as a result\n"
    "      of the --scan-executable option.\n"
    "      Any library in the Swift library search path can be specified for\n"
    "      <library>.\n"
    "      This option may be set multiple times.\n"
    "  --resource-destination <path>\n"
    "      The <path> to copy Swift resource libraries to.\n"
    "\n"
    ;

#include <sys/types.h>
#include <sys/param.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <os/overflow.h>
#include <mach-o/fat.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <libkern/OSByteOrder.h>
#include <uuid/uuid.h>
#include <dispatch/dispatch.h>
#include <copyfile.h>
#include <dirent.h>
#include <libgen.h>

#include <algorithm>
#include <vector>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <mutex>


#pragma clang diagnostic ignored "-Wgcc-compat"

#ifndef CPU_TYPE_ARM64
#   define CPU_TYPE_ARM64  ((cpu_type_t) (CPU_TYPE_ARM | CPU_ARCH_ABI64))
#endif

static int Verbose = 0;

#ifdef __OPTIMIZE__
#define INLINE	__attribute__((always_inline))
#else
#define INLINE
#endif

//
// This abstraction layer is for use with file formats that have 64-bit/32-bit and Big-Endian/Little-Endian variants
//
// For example: to make a utility that handles 32-bit little enidan files use:  Pointer32<LittleEndian>
//
//
//		get16()			read a 16-bit number from an E endian struct
//		set16()			write a 16-bit number to an E endian struct
//		get32()			read a 32-bit number from an E endian struct
//		set32()			write a 32-bit number to an E endian struct
//		get64()			read a 64-bit number from an E endian struct
//		set64()			write a 64-bit number to an E endian struct
//
//		getBits()		read a bit field from an E endian struct (bitCount=number of bits in field, firstBit=bit index of field)
//		setBits()		write a bit field to an E endian struct (bitCount=number of bits in field, firstBit=bit index of field)
//
//		getBitsRaw()	read a bit field from a struct with native endianness
//		setBitsRaw()	write a bit field from a struct with native endianness
//

class BigEndian
{
public:
	static uint16_t	get16(const uint16_t& from)				INLINE { return OSReadBigInt16(&from, 0); }
	static void		set16(uint16_t& into, uint16_t value)	INLINE { OSWriteBigInt16(&into, 0, value); }
	
	static uint32_t	get32(const uint32_t& from)				INLINE { return OSReadBigInt32(&from, 0); }
	static void		set32(uint32_t& into, uint32_t value)	INLINE { OSWriteBigInt32(&into, 0, value); }
	
	static uint64_t get64(const uint64_t& from)				INLINE { return OSReadBigInt64(&from, 0); }
	static void		set64(uint64_t& into, uint64_t value)	INLINE { OSWriteBigInt64(&into, 0, value); }
	
	static uint32_t	getBits(const uint32_t& from, 
						uint8_t firstBit, uint8_t bitCount)	INLINE { return getBitsRaw(get32(from), firstBit, bitCount); }
	static void		setBits(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE { uint32_t temp = get32(into); setBitsRaw(temp, value, firstBit, bitCount); set32(into, temp); }

	static uint32_t	getBitsRaw(const uint32_t& from, 
						uint8_t firstBit, uint8_t bitCount)	INLINE { return ((from >> (32-firstBit-bitCount)) & ((1<<bitCount)-1)); }
	static void		setBitsRaw(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE { uint32_t temp = into; 
																							const uint32_t mask = ((1<<bitCount)-1); 
																							temp &= ~(mask << (32-firstBit-bitCount)); 
																							temp |= ((value & mask) << (32-firstBit-bitCount)); 
																							into = temp; }
	enum { little_endian = 0 };
};


class LittleEndian
{
public:
	static uint16_t	get16(const uint16_t& from)				INLINE { return OSReadLittleInt16(&from, 0); }
	static void		set16(uint16_t& into, uint16_t value)	INLINE { OSWriteLittleInt16(&into, 0, value); }
	
	static uint32_t	get32(const uint32_t& from)				INLINE { return OSReadLittleInt32(&from, 0); }
	static void		set32(uint32_t& into, uint32_t value)	INLINE { OSWriteLittleInt32(&into, 0, value); }
	
	static uint64_t get64(const uint64_t& from)				INLINE { return OSReadLittleInt64(&from, 0); }
	static void		set64(uint64_t& into, uint64_t value)	INLINE { OSWriteLittleInt64(&into, 0, value); }

	static uint32_t	getBits(const uint32_t& from,
						uint8_t firstBit, uint8_t bitCount)	INLINE { return getBitsRaw(get32(from), firstBit, bitCount); }
	static void		setBits(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE { uint32_t temp = get32(into); setBitsRaw(temp, value, firstBit, bitCount); set32(into, temp); }

	static uint32_t	getBitsRaw(const uint32_t& from,
						uint8_t firstBit, uint8_t bitCount)	INLINE { return ((from >> firstBit) & ((1<<bitCount)-1)); }
	static void		setBitsRaw(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE {  uint32_t temp = into; 
																							const uint32_t mask = ((1<<bitCount)-1); 
																							temp &= ~(mask << firstBit); 
																							temp |= ((value & mask) << firstBit); 
																							into = temp; }
	enum { little_endian = 1 };
};

#if __BIG_ENDIAN__
typedef BigEndian CurrentEndian;
typedef LittleEndian OtherEndian;
#elif __LITTLE_ENDIAN__
typedef LittleEndian CurrentEndian;
typedef BigEndian OtherEndian;
#else
#error unknown endianness
#endif


template <typename _E>
class Pointer32
{
public:
	typedef uint32_t	uint_t;
	typedef int32_t		sint_t;
	typedef _E			E;
	
	static uint64_t	getP(const uint_t& from)				INLINE { return _E::get32(from); }
	static void		setP(uint_t& into, uint64_t value)		INLINE { _E::set32(into, value); }
};


template <typename _E>
class Pointer64
{
public:
	typedef uint64_t	uint_t;
	typedef int64_t		sint_t;
	typedef _E			E;
	
	static uint64_t	getP(const uint_t& from)				INLINE { return _E::get64(from); }
	static void		setP(uint_t& into, uint64_t value)		INLINE { _E::set64(into, value); }
};


//
// mach-o file header
//
template <typename P> struct macho_header_content {};
template <> struct macho_header_content<Pointer32<BigEndian> >    { mach_header		fields; };
template <> struct macho_header_content<Pointer64<BigEndian> >	  { mach_header_64	fields; };
template <> struct macho_header_content<Pointer32<LittleEndian> > { mach_header		fields; };
template <> struct macho_header_content<Pointer64<LittleEndian> > { mach_header_64	fields; };

template <typename P>
class macho_header {
public:
	uint32_t		magic() const					INLINE { return E::get32(header.fields.magic); }
	void			set_magic(uint32_t value)		INLINE { E::set32(header.fields.magic, value); }

	uint32_t		cputype() const					INLINE { return E::get32(header.fields.cputype); }
	void			set_cputype(uint32_t value)		INLINE { E::set32((uint32_t&)header.fields.cputype, value); }

	uint32_t		cpusubtype() const				INLINE { return E::get32(header.fields.cpusubtype); }
	void			set_cpusubtype(uint32_t value)	INLINE { E::set32((uint32_t&)header.fields.cpusubtype, value); }

	uint32_t		filetype() const				INLINE { return E::get32(header.fields.filetype); }
	void			set_filetype(uint32_t value)	INLINE { E::set32(header.fields.filetype, value); }

	uint32_t		ncmds() const					INLINE { return E::get32(header.fields.ncmds); }
	void			set_ncmds(uint32_t value)		INLINE { E::set32(header.fields.ncmds, value); }

	uint32_t		sizeofcmds() const				INLINE { return E::get32(header.fields.sizeofcmds); }
	void			set_sizeofcmds(uint32_t value)	INLINE { E::set32(header.fields.sizeofcmds, value); }

	uint32_t		flags() const					INLINE { return E::get32(header.fields.flags); }
	void			set_flags(uint32_t value)		INLINE { E::set32(header.fields.flags, value); }

	uint32_t		reserved() const				INLINE { return E::get32(header.fields.reserved); }
	void			set_reserved(uint32_t value)	INLINE { E::set32(header.fields.reserved, value); }

	typedef typename P::E		E;
private:
	macho_header_content<P>	header;
};


//
// mach-o load command
//
template <typename P>
class macho_load_command {
public:
	uint32_t		cmd() const						INLINE { return E::get32(command.cmd); }
	void			set_cmd(uint32_t value)			INLINE { E::set32(command.cmd, value); }

	uint32_t		cmdsize() const					INLINE { return E::get32(command.cmdsize); }
	void			set_cmdsize(uint32_t value)		INLINE { E::set32(command.cmdsize, value); }

	typedef typename P::E		E;
private:
	load_command	command;
};


//
// mach-o uuid load command
//
template <typename P>
class macho_uuid_command {
public:
	uint32_t		cmd() const								INLINE { return E::get32(fields.cmd); }
	void			set_cmd(uint32_t value)					INLINE { E::set32(fields.cmd, value); }

	uint32_t		cmdsize() const							INLINE { return E::get32(fields.cmdsize); }
	void			set_cmdsize(uint32_t value)				INLINE { E::set32(fields.cmdsize, value); }

	const uint8_t*	uuid() const							INLINE { return fields.uuid; }
	void			set_uuid(uint8_t value[16])				INLINE { memcpy(&fields.uuid, value, 16); }
			
	typedef typename P::E		E;
private:
	uuid_command	fields;
};


//
// mach-o dylib load command
//
template <typename P>
class macho_dylib_command {
public:
	uint32_t		cmd() const									INLINE { return E::get32(fields.cmd); }
	void			set_cmd(uint32_t value)						INLINE { E::set32(fields.cmd, value); }

	uint32_t		cmdsize() const								INLINE { return E::get32(fields.cmdsize); }
	void			set_cmdsize(uint32_t value)					INLINE { E::set32(fields.cmdsize, value); }

	uint32_t		name_offset() const							INLINE { return E::get32(fields.dylib.name.offset); }
	void			set_name_offset(uint32_t value)				INLINE { E::set32(fields.dylib.name.offset, value);  }
	
	uint32_t		timestamp() const							INLINE { return E::get32(fields.dylib.timestamp); }
	void			set_timestamp(uint32_t value)				INLINE { E::set32(fields.dylib.timestamp, value); }

	uint32_t		current_version() const						INLINE { return E::get32(fields.dylib.current_version); }
	void			set_current_version(uint32_t value)			INLINE { E::set32(fields.dylib.current_version, value); }

	uint32_t		compatibility_version() const				INLINE { return E::get32(fields.dylib.compatibility_version); }
	void			set_compatibility_version(uint32_t value)	INLINE { E::set32(fields.dylib.compatibility_version, value); }

	const char*		name() const								INLINE { return (const char*)&fields + name_offset(); }
	void			set_name_offset()							INLINE { set_name_offset(sizeof(fields)); }
	
	typedef typename P::E		E;
private:
	dylib_command	fields;
};


// Print everything to standard output.
// Mixing stdout and stderr looks bad when the output is reprinted by Xcode.

void printUsage() 
{
    fprintf(stdout, "%s", usage);
}

void fail(const char *msg, ...) 
    __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
{
    va_list args;
    va_start(args, msg);
    char *msg2;
    asprintf(&msg2, "*** error: %s\n", msg);
    vfprintf(stdout, msg2, args);
    exit(1);
}

void fail_errno(const char *msg, ...) 
    __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
{
    va_list args;
    va_start(args, msg);
    char *msg2;
    asprintf(&msg2, "*** error: %s: %s\n", msg, strerror(errno));
    vfprintf(stdout, msg2, args);
    exit(1);
}

void fail_usage(const char *msg, ...) 
    __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
{
    va_list args;
    va_start(args, msg);
    char *msg2;
    asprintf(&msg2, "*** error: %s\n\n", msg);
    vfprintf(stdout, msg2, args);
    printUsage();
    exit(1);
}


void log_vn(int verbosity, const char *msg, va_list args)
    __attribute__((format(printf, 2, 0)))
{
    if (verbosity <= Verbose) {
        char *msg2;
        asprintf(&msg2, "%s\n", msg);
        vfprintf(stdout, msg2, args);
        free(msg2);
    }
}

int log_v(const char *msg, ...) 
    __attribute__((format(printf, 1, 2)))
{
    va_list args;
    va_start(args, msg);
    log_vn(1, msg, args);
    return -1;
}

int log_vv(const char *msg, ...) 
    __attribute__((format(printf, 1, 2)))
{
    va_list args;
    va_start(args, msg);
    log_vn(2, msg, args);
    return -1;
}


ssize_t pread_all(int fd, void *buf, size_t count, off_t offset)
{
    size_t total = 0;
    while (total < count) {
        ssize_t readed = pread(fd, (void *)((char *)buf+total), 
                               count-total, offset+total);
        if (readed > 0) total += readed;     // got data
        else if (readed == 0) return total;  // EOF: done
        else if (readed == -1  &&  errno != EINTR) return -1;  
                                                   // error but not EINTR: fail
    }

    return total;
}


template <typename T> 
int parse_macho(int fd, uint32_t offset, uint32_t size, 
                void (^dylibVisitor)(std::string const &path),
                void (^uuidVisitor)(uuid_t const uuid))
{
    ssize_t readed;

    macho_header<T> mh;
    if (size < sizeof(mh)) return log_vv("file is too small");
    readed = pread_all(fd, &mh, sizeof(mh), offset);
    if (readed != sizeof(mh)) return log_vv("pread failed");

    uint32_t sizeofcmds = mh.sizeofcmds();
    size -= sizeof(mh);
    offset += sizeof(mh);
    if (size < sizeofcmds) return log_vv("file is badly formed");

    uint8_t *cmdp = (uint8_t *)malloc(sizeofcmds);
    if (!cmdp) return log_vv("malloc(sizeofcmds) failed");

    readed = pread_all(fd, cmdp, sizeofcmds, offset);
    if (readed == sizeofcmds) {
        uint8_t *cmds = cmdp;
        for (uint32_t c = 0; c < mh.ncmds(); c++) {
            macho_load_command<T> *cmd;
            if (size < sizeof(*cmd)) return log_vv("file is badly formed");
            cmd = (macho_load_command<T>*) cmds;
            if (size < cmd->cmdsize()) return log_vv("file is badly formed");
            cmds += cmd->cmdsize();
            size -= cmd->cmdsize();

            if (dylibVisitor  &&  
                (cmd->cmd() == LC_LOAD_DYLIB  ||  
                 cmd->cmd() == LC_LOAD_WEAK_DYLIB  ||  
                 cmd->cmd() == LC_LAZY_LOAD_DYLIB))
            {
                macho_dylib_command<T>* dylib = (macho_dylib_command<T>*)cmd;
                if (dylib->cmdsize() < dylib->name_offset()) continue;
                char *name = (char *)dylib + dylib->name_offset();
                size_t name_len =
                    strnlen(name, dylib->cmdsize() - dylib->name_offset());
                log_vv("  loads %.*s", (int)name_len, name);

                #define PREPREFIX "@rpath/"
                #define PREFIX    PREPREFIX "libswift"
                if (0 == strncmp(name, PREFIX, strlen(PREFIX))) {
                    dylibVisitor(name + strlen(PREPREFIX));
                }
            }
            else if (uuidVisitor  &&  cmd->cmd() == LC_UUID) {
                macho_uuid_command<T>* uuid_cmd = (macho_uuid_command<T>*)cmd;
                if (uuid_cmd->cmdsize() < sizeof(uuid_command)) continue;
                uuidVisitor(uuid_cmd->uuid());
            }
        }
    }
    free(cmdp);

    return 0;
}


int parse_macho(int fd, uint32_t offset, uint32_t size, 
              void (^dylibVisitor)(std::string const &path),
              void (^uuidVisitor)(uuid_t const uuid))
{
    uint32_t magic;
    if (size < sizeof(magic)) return log_vv("file is too small");
    ssize_t readed = pread_all(fd, &magic, sizeof(magic), offset);
    if (readed != sizeof(magic)) return log_vv("pread failed");
    
    switch (magic) {
    case MH_MAGIC_64:
        return parse_macho<Pointer64<CurrentEndian>>(fd, offset, size, 
                                                     dylibVisitor, uuidVisitor);
    case MH_MAGIC:
        return parse_macho<Pointer32<CurrentEndian>>(fd, offset, size, 
                                                     dylibVisitor, uuidVisitor);
    case MH_CIGAM_64:
        return parse_macho<Pointer64<OtherEndian>>(fd, offset, size, 
                                                   dylibVisitor, uuidVisitor);
    case MH_CIGAM:
        return parse_macho<Pointer32<OtherEndian>>(fd, offset, size, 
                                                   dylibVisitor, uuidVisitor);
    default:
        return log_vv("file is not mach-o");
    }
}


int parse_fat(int fd, off_t fsize, char *buffer, size_t size, 
              void (^dylibVisitor)(std::string const &path),
              void (^uuidVisitor)(uuid_t const uuid))
{
    uint32_t magic;

    if (size < sizeof(magic)) {
        return log_vv("file is too small");
    }

    magic = *(uint32_t *)buffer;
    if (magic == FAT_MAGIC || magic == FAT_CIGAM) {
        struct fat_header *fh;
        uint32_t fat_magic, fat_nfat_arch;
        struct fat_arch *archs;
        uint32_t i;
        
        if (size < sizeof(struct fat_header)) {
            return log_vv("file is too small");
        }

        fh = (struct fat_header *)buffer;
        fat_magic = OSSwapBigToHostInt32(fh->magic);
        fat_nfat_arch = OSSwapBigToHostInt32(fh->nfat_arch);

        size_t fat_arch_size;
        // fat_nfat_arch * sizeof(struct fat_arch) + sizeof(struct fat_header)
        if (os_mul_and_add_overflow(fat_nfat_arch, sizeof(struct fat_arch),
                                    sizeof(struct fat_header), &fat_arch_size))
        {
            return log_vv("too many fat archs\n");
        }
        if (size < fat_arch_size) {
            return log_vv("file is too small");
        }

        archs = (struct fat_arch *)(buffer + sizeof(struct fat_header));

        /* Special case hidden CPU_TYPE_ARM64 */
        size_t fat_arch_plus_one_size;
        if (os_add_overflow(fat_arch_size, sizeof(struct fat_arch),
                            &fat_arch_plus_one_size))
        {
            return log_vv("too many fat archs\n");
        }
        if (size >= fat_arch_plus_one_size) {
            if (fat_nfat_arch > 0
                && OSSwapBigToHostInt32(archs[fat_nfat_arch].cputype) == CPU_TYPE_ARM64) {
                fat_nfat_arch++;
            }
        }
        /* End special case hidden CPU_TYPE_ARM64 */

        for (i=0; i < fat_nfat_arch; i++) {
            int ret;
            uint32_t arch_cputype, arch_cpusubtype, arch_offset, arch_size, arch_align;

            arch_cputype = OSSwapBigToHostInt32(archs[i].cputype);
            arch_cpusubtype = OSSwapBigToHostInt32(archs[i].cpusubtype);
            arch_offset = OSSwapBigToHostInt32(archs[i].offset);
            arch_size = OSSwapBigToHostInt32(archs[i].size);
            arch_align = OSSwapBigToHostInt32(archs[i].align);

            /* Check that slice data is after all fat headers and archs */
            if (arch_offset < fat_arch_size) {
                return log_vv("file is badly formed");
            }

            /* Check that the slice ends before the file does */
            if (arch_offset > fsize) {
                return log_vv("file is badly formed");
            }

            if (arch_size > fsize) {
                return log_vv("file is badly formed");
            }

            if (arch_offset > (fsize - arch_size)) {
                return log_vv("file is badly formed");
            }

            ret = parse_macho(fd, arch_offset, arch_size,
                              dylibVisitor, uuidVisitor);
            if (ret != 0) {
                return ret;
            }
        }
        return 0;
    } else {
        /* Not a fat file */
        return parse_macho(fd, 0, fsize, dylibVisitor, uuidVisitor);
    }
}


void process(std::string const& path, void(^dylibVisitor)(std::string const&),
             void (^uuidVisitor)(uuid_t const))
{
    log_vv("Scanning %s...", path.c_str());

    int fd = open(path.c_str(), O_RDONLY);
    if (fd < 0) log_vv("%s: open failed: %s", 
                       path.c_str(), strerror(errno));

    struct stat st;
    if (fstat(fd, &st) < 0) {
        log_vv("%s: stat failed: %s", 
               path.c_str(), strerror(errno));
    } else {
        const int len = 4096;
        char buf[len];
        ssize_t readed = pread_all(fd, buf, len, 0);
        if (readed != len) {
            log_vv("%s: pread failed: %s", 
                   path.c_str(), strerror(errno));
        } else {
            parse_fat(fd, st.st_size, buf, len, dylibVisitor, uuidVisitor);
        }
    }
    close(fd);
}

bool operator <= (const struct timespec &lhs, const struct timespec &rhs) 
{
    if (lhs.tv_sec == rhs.tv_sec) return lhs.tv_nsec <= rhs.tv_nsec;
    return lhs.tv_sec <= rhs.tv_sec;
}

std::string parentPath(std::string path) {
    const char *pathCstr = path.c_str();
    char parent[MAXPATHLEN];

    return dirname_r(pathCstr, parent) ? parent : pathCstr;
}

std::string filename(std::string path) {
    const char *pathCstr = path.c_str();
    char filename[MAXPATHLEN];

    return basename_r(pathCstr, filename) ? filename : pathCstr;
}

// This executable's own path.
std::string self_executable = []() -> std::string {
    char path[MAXPATHLEN] = {0};
    uint32_t len = sizeof(path);
    _NSGetExecutablePath(path, &len);
    return std::string(path);
}();


// This executable's own xctoolchain path.
std::string self_toolchain = []() -> std::string  {
    auto result = self_executable;
    
    // Remove the executable name.
    result = parentPath(result);
    
    // Remove trailing /usr/bin, if any
    if (filename(result) == "bin") {
        result = parentPath(result);
    }
    if (filename(result) == "usr") {
        result = parentPath(result);
    }
    return result;
}();

std::vector<uint8_t> readToEOF(int fd) {
    std::vector<uint8_t> retData;
    #define BUFFER_SIZE 1024
    uint8_t readBuffer[BUFFER_SIZE];
    ssize_t readSize = 0;
    while ((readSize = read(fd, readBuffer, BUFFER_SIZE)) > 0) {
        retData.reserve(retData.size() + readSize);
        std::copy(readBuffer, readBuffer + readSize,
                  std::back_inserter(retData));
    }
    return retData;
}

// Runs a tool with `xcrun`. 
// Returns the tool's termination status.
// Prints the tool's command line if we are verbose.
// Prints the tool's stdout and stderr if terminationStatus is non-zero
//   or if we are very verbose.
typedef void (^XcrunToolBlock)(std::vector<uint8_t> stdOutData, std::vector<uint8_t> stdErrorData, int err);

int xcrunToolCommand(std::vector<std::string> commandAndArguments, XcrunToolBlock block = 0)
{
    const char *launchPath = "/usr/bin/xcrun";

    // Tell xcrun to search our toolchain first.
    std::vector<const char *> arguments;
    arguments.push_back(launchPath);
    arguments.push_back("--toolchain");
    arguments.push_back(self_toolchain.c_str());

    // Tell xcrun to print its command if we are very verbose.
    if (Verbose > 1) {
        arguments.push_back("--log");
    }

    for (auto const &string : commandAndArguments) {
        arguments.push_back(string.c_str());
    }
    arguments.push_back(NULL);

    int outPipe[2];
    int errPipe[2];

    pipe(outPipe);
    pipe(errPipe);
    
    log_v("  %s", launchPath);

    int childPid = fork();

    if (childPid == 0) {
        dup2(outPipe[1], STDOUT_FILENO);
        dup2(errPipe[1], STDERR_FILENO);

        close(outPipe[0]);
        close(errPipe[0]);

        execv(launchPath, (char *const *)arguments.data());
    }
    close(outPipe[1]);
    close(errPipe[1]);
    
    // Read stdout and stderr in parallel, then wait for the task 
    // to exit. Anything else risks deadlock if the task fills 
    // one of the output buffers.

    int errPipeReadFd = errPipe[1];
    __block std::vector<uint8_t> stdErrData;
    dispatch_semaphore_t gotStdErr = dispatch_semaphore_create(0);
    dispatch_queue_t concurrentQueue = 
        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(concurrentQueue, ^{
        stdErrData = readToEOF(errPipeReadFd);
        dispatch_semaphore_signal(gotStdErr);
    });

    auto const stdOutData = readToEOF(outPipe[0]);
    close(outPipe[0]);

    dispatch_semaphore_wait(gotStdErr, DISPATCH_TIME_FOREVER);
    dispatch_release(gotStdErr);
    close(errPipe[0]);

    int status = 0;
    waitpid(childPid, &status, 0);
    status = WIFSIGNALED(status) ? WTERMSIG(status) : (WIFEXITED(status) ? WEXITSTATUS(status) : 0);
    
    // Task is finished and we have its stdout and stderr output.

    // Print its stdout and stderr if it failed or we are verbose.
    // (Print nothing by default because codesign is noisy.)

    if (status  ||  Verbose > 1) {
        fwrite(stdErrData.data(), stdErrData.size(), 1, stdout);
        fwrite(stdOutData.data(), stdOutData.size(), 1, stdout);
    }
    if (block) { block(stdOutData, stdErrData, status); }
    return status;
}


void copyAndStripBitcode(std::string src, std::string dst)
{
    // -r removes bitcode
    std::vector<std::string> commandAndArgs = {"bitcode_strip", src, "-r", "-o", dst};
    int err = xcrunToolCommand(commandAndArgs);

    // Fail if bitcode_strip failed.
    if (err) {
        fail("Couldn't copy and strip bitcode %s to %s: bitcode_strip failed "
             "with exit code %d", src.c_str(), dst.c_str(), err);
    }
}

void copyFile(std::string src, std::string dst, bool stripBitcode)
{
    if (stripBitcode) {
        copyAndStripBitcode(src, dst);
    } else {
        if (copyfile(src.c_str(), dst.c_str(), NULL, COPYFILE_ALL) != 0) {
            fail("Couldn't copy %s to %s: %s", src.c_str(), dst.c_str(), strerror(errno));
        }
   }
}

std::string uuidString(uuid_t const uuid) {
    char buffer[37];
    uuid_unparse(uuid, buffer);
    return buffer;
}

void copyLibraries(std::string src_dir, std::string dst_dir,
                   std::unordered_map<std::string,
                   std::unordered_set<std::string>> const &libs,
                   bool stripBitcode)
{
    mkpath_np(dst_dir.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
    
    for (auto const &pair : libs) {
        auto const &lib = pair.first;
        auto const &srcUUIDs = pair.second;

        std::string src = src_dir + "/" + lib;
        std::string dst = dst_dir + "/" + lib;
        
        // Compare UUIDs of src and dst and don't copy if they're the same.
        // Do not use mod times for this task: the dst copy gets code-signed 
        // and bitcode-stripped so it can look newer than it really is.
        __block std::unordered_set<std::string> dstUUIDs;
        process(dst, NULL, ^(uuid_t const uuid) {
            dstUUIDs.insert(uuidString(uuid));
        });

        std::string srcUUIDsString;
        srcUUIDsString.reserve(37 * srcUUIDs.size());

        for (auto const &uuidString : srcUUIDs) {
            srcUUIDsString.append(uuidString + std::string(" "));
        }

        std::string dstUUIDsString;
        dstUUIDsString.reserve(37 * dstUUIDs.size());

        for (auto const &uuidString : dstUUIDs) {
            dstUUIDsString.append(uuidString + " ");
        }

        log_vv("Source UUIDs %s: %s", src.c_str(), srcUUIDsString.c_str());
        log_vv("Destination UUIDs %s: %s", dst.c_str(), dstUUIDsString.c_str());

        if (srcUUIDs == dstUUIDs) {
            log_v("%s is up to date at %s", 
                  lib.c_str(), dst.c_str());
            continue;
        }
        
        // Perform the copy.
        
        log_v("Copying %s from %s to %s", 
              lib.c_str(),
              src_dir.c_str(), 
              dst_dir.c_str());
        
        unlink(dst.c_str());
        copyFile(src, dst, stripBitcode);
    }
}

std::vector<uint8_t> query_code_signature(std::string file) {
    __block std::vector<uint8_t> d;
    std::vector<std::string> command = {"codesign", "-r-", "--display", file};
    log_v("Probing signature of %s", file.c_str());
    xcrunToolCommand(command,
     ^(std::vector<uint8_t> stdOutData, std::vector<uint8_t> stdErrData, int err) {
        if (!err) { d = stdOutData; }
    });
    return d;
}

template <typename F>
void enumerateDirectory(std::string directory, F&& func) {
    DIR *dir = opendir(directory.c_str());
    if (dir == NULL) {
        return;
    }

    std::vector<std::string> subpaths;
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        std::string path = directory + "/" + entry->d_name;
        if (entry->d_type == DT_REG) {
            func(path);
        } else if (entry->d_type == DT_DIR) {
            // check if . or ..
            if (strncmp(entry->d_name, "..", entry->d_namlen) == 0) {
                continue;
            }
            subpaths.push_back(path);
        }
    }
    closedir(dir);
    for (auto const &path : subpaths) {
        enumerateDirectory(path, func);
    }
}



int main(int argc, const char *argv[])
{
    // Executables to scan for Swift references.
    // --scan-executable
    std::vector<std::string> executables;

    // Directories to scan for more executables.
    // --scan-folder
    std::vector<std::string> embedDirs;

    // Platform name.
    // --platform
    // or the last path component of --source-libraries
    std::string platform;

    // Copy source.
    // --source-libraries
    // or /path/to/swift-stdlib-tool/../../lib/swift/<--platform>
    std::string src_dir;

    // Copy destinations, signed and unsigned.
    // --destination and --unsigned-destination
    std::string dst_dir;
    std::string unsigned_dst_dir;

    // Resource copy destination.
    // --resource-destination
    std::string resource_dst_dir;

    // Resource libraries.
    // --resource-library
    std::vector<std::string> resourceLibraries;

    // Code signing options.
    std::string ident;
    std::string keychain;
    std::vector<std::string> otherCodesignFlags;

    // Read arguments
    bool print = false;
    bool copy = false;
    bool stripBitcode = false;
    for (int i = 1; i < argc; i++) {
        if (0 == strcmp(argv[i], "--print")) print = true;
        if (0 == strcmp(argv[i], "--copy")) copy = true;
        if (0 == strcmp(argv[i], "--verbose")) Verbose++;
        if (0 == strcmp(argv[i], "--help")) {
            printUsage();
            exit(0);
        }

        if (0 == strcmp(argv[i], "--scan-executable")) {
            executables.emplace_back(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--scan-folder")) {
            embedDirs.emplace_back(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--source-libraries")) {
            src_dir = std::string(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--platform")) {
            platform = std::string(argv[++i]);
        }

        if (0 == strcmp(argv[i], "--destination")) {
            dst_dir = std::string(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--unsigned-destination")) {
            unsigned_dst_dir = std::string(argv[++i]);
        }

        if (0 == strcmp(argv[i], "--sign")) {
            ident = std::string(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--keychain")) {
            keychain = std::string(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--Xcodesign")) {
            otherCodesignFlags.push_back(std::string(argv[++i]));
        }

        if (0 == strcmp(argv[i], "--strip-bitcode")) {
            stripBitcode = true;
        }

        if (0 == strcmp(argv[i], "--resource-destination")) {
            resource_dst_dir = std::string(argv[++i]);
        }
        if (0 == strcmp(argv[i], "--resource-library")) {
            resourceLibraries.push_back(std::string(argv[++i]));
        }
    }

    // Fix up src_dir and platform values.
    if (src_dir.empty() && platform.empty()) {
        // Neither src_dir nor platform is set. Die.
        fail_usage("At least one of --source-libraries and --platform "
                   "must be set.");
    } else if (src_dir.empty()) {
        // platform is set but src_dir is not. 
        // Use platform to set src_dir relative to us.
        src_dir = parentPath(parentPath(self_executable)) + "/" + "lib" +
                  "swift-5.0" + "/" + platform;
    } else if (platform.empty()) {
        // src_dir is set but platform is not.
        // Pick platform from src_dir's name.
        platform = src_dir;
    }

    // Add the platform to unsigned_dst_dir if it is not already present.
    if (!unsigned_dst_dir.empty()) {
        auto const unsigned_platform = unsigned_dst_dir;
        if (platform != unsigned_platform) {
            unsigned_dst_dir = unsigned_dst_dir + "/" + platform;
        }
    }
    
    // If the user specifies --strip-bitcode but not --sign, this
    // will cause the dylibs to get copied, stripped, but not resigned.
    // This will cause apps to fail to launch because the code signature
    // is invalid.  In this case, ignore --strip-bitcode.
    if (stripBitcode && ident.empty()) {
        stripBitcode = false;
    }

    // Collect executables from the --scan-folder locations.
    for (auto const &embedDir : embedDirs) {
        enumerateDirectory(embedDir, [&](std::string entry) {
            if (0 == access(entry.c_str(), X_OK)) {
                executables.push_back(entry);
            } else {
                log_vv("%s is not an executable file", entry.c_str());
            }
        });
    }
         
    // Collect Swift library names from the input files.
    // If the library does not exist in src_dir then assume the user wrote 
    // their own library named libswift* and is handling it elsewhere.
    __block std::unordered_map<std::string,
                    std::unordered_set<std::string>> swiftLibs;
    for (auto const &path : executables) {
        process(path,
           ^(std::string const &linkedLib) {
                auto const linkedSrc = src_dir + "/" + linkedLib;
                if (access(linkedSrc.c_str(), F_OK) == 0) {
                    swiftLibs[linkedLib] = std::unordered_set<std::string>();
                }
            }, 
            NULL);
    }

    // Collect more Swift library names from the Swift libraries themselves.
    // Also collect the Swift libraries' UUIDs.
    __block std::vector<std::string> worklist;
    worklist.reserve(swiftLibs.size());
    for (auto const &pair : swiftLibs) {
        worklist.push_back(pair.first);
    }
    while (worklist.size()) {
        auto const lib = worklist.back();
        worklist.pop_back();
        auto const path = src_dir + "/" + lib;
        process(path,
            ^(std::string const &linkedLib) {
                auto const linkedSrc = src_dir + "/" + linkedLib;
                if (swiftLibs.count(linkedLib) == 0 &&
                    access(linkedSrc.c_str(), F_OK) == 0)
                {
                    swiftLibs[linkedLib] = std::unordered_set<std::string>();
                    worklist.push_back(linkedLib);
                }
            }, 
            ^(uuid_t const uuid) {
                swiftLibs[lib].insert(uuidString(uuid));
            });
    }

    // Collect all the Swift libraries that the user requested
    // with --resource-library.
    __block std::unordered_map<std::string,
        std::unordered_set<std::string>> swiftLibsForResources;
    for (auto const &lib : resourceLibraries) {
        auto const libSrc = src_dir + "/" + lib;
        if (access(libSrc.c_str(), F_OK) == 0) {
            swiftLibsForResources[lib] = std::unordered_set<std::string>();
        }
    }

    // Collect dependencies of --resource-library libs.
    worklist.clear();
    for (auto const &pair : swiftLibsForResources) {
        worklist.push_back(pair.first);
    }
    while (worklist.size()) {
        auto const lib = worklist.back();
        worklist.pop_back();
        auto const path = src_dir + "/" + lib;
        process(path,
            ^(std::string const &linkedLib) {
                auto const linkedSrc = src_dir + "/" + linkedLib;
                if (swiftLibsForResources.count(linkedLib) == 0 &&
                    access(linkedSrc.c_str(), F_OK) == 0)
                {
                    swiftLibsForResources[linkedLib] = std::unordered_set<std::string>();
                    worklist.push_back(linkedLib);
                }
            },
            ^(uuid_t const uuid) {
                swiftLibsForResources[lib].insert(uuidString(uuid));
            });
    }

    // Print the Swift libraries (full path to toolchain's copy)
    if (print) {
        for (auto const &lib : swiftLibs) {
            printf("%s\n", (src_dir + "/" + lib.first).c_str());
        }
    }

    // Copy the Swift libraries to $build_dir/$frameworks
    // and $build_dir/$unsigned_frameworks
    if (copy) {
        copyLibraries(src_dir, dst_dir, swiftLibs, stripBitcode);
        if (unsigned_dst_dir.empty()) {
            // Never strip bitcode from the unsigned libraries. 
            // Their existing signatures must be preserved.
            copyLibraries(src_dir, unsigned_dst_dir, swiftLibs, false);
        }

        if (resource_dst_dir.empty()) {
            // Never strip bitcode from resources libraries, for
            // the same reason as the libraries copied to
            // unsigned_dst_dir.
            copyLibraries(src_dir, resource_dst_dir, swiftLibsForResources, false);
        }
    }

    // Codesign the Swift libraries in $build_dir/$frameworks
    // but not the libraries in $build_dir/$unsigned_frameworks.
    if (ident.empty()) {
        // Swift libraries that are up-to-date get codesigned anyway
        // (in case options changed or a previous build was incomplete).
        // We do employ an optimization, however, if resigning the dylib
        // results in getting the same signing identity and credentials
        // then we keep the original file to optimize for delta updates
        // to the device.

        __block bool signedOne = false;
        std::mutex signingLock;

        for (auto const &pair : swiftLibs) {
            auto const &lib = pair.first;
            // Work around authentication UI problems
            // by signing one synchronously and then signing the rest.
            signingLock.lock();
            if (signedOne) {
                // First signer is complete. Proceed concurrently.
                signingLock.unlock();
            } else {
                // We are the first signer. Hold the lock until we finish.
            }

            // Get the code signature, and copy the dylib to the side
            // to preserve it in case it does not change.  We can use
            // this to avoid unnecessary copies during delta installs
            // to devices.
            auto const dst = dst_dir + "/" + lib;
            auto const oldSignatureData = query_code_signature(dst);
            const char *tmpFilePath = 0;
            if (!oldSignatureData.empty()) {
                // Make a copy of the existing file, with permissions and
                // mtime preserved.
                auto tmpFile = dst + ".original";
                tmpFilePath = tmpFile.c_str();
                xcrunToolCommand({"cp", "-p", dst, tmpFile});
            }

            // Proceed with (re-)codesigning.
            log_v("Codesigning %s at %s", lib.c_str(), dst_dir.c_str());

            // Build the codesign invocation.
            std::vector<std::string> commandAndArguments {
                 "codesign", "--force", "--sign", ident, "--verbose"};

            if (!keychain.empty()) {
                commandAndArguments.push_back("--keychain");
                commandAndArguments.push_back(keychain);
            }

            // Other codesign flags come later
            // so they can override the default flags.
            std::copy(otherCodesignFlags.begin(), otherCodesignFlags.end(),
                      std::back_inserter(commandAndArguments));

            commandAndArguments.push_back(dst);

            int err = xcrunToolCommand(commandAndArguments);

            // Fail if codesign failed.
            if (err) {
                // Clean up any temporary files.
                if (tmpFilePath)
                    unlink(tmpFilePath);
                fail("Couldn't codesign %s: codesign failed with "
                     "exit code %d", dst.c_str(), err);
            }

            // If we have an existing code signature data, query the new one and compare
            // it with the code signature of the file before we re-signed it.
            // If they are the same, use the original file instead.  This preserves
            // the contents of the file and mtime for use with delta installs.
            if (!oldSignatureData.empty()) {
                auto const newSignatureData = query_code_signature(dst);

#if 0
                // For Debugging.
                fprintf(stdout, "oldSignature (%lu bytes)\n", (unsigned long)oldSignatureData.size());
                fwrite(oldSignatureData.data(), oldSignatureData.size(), 1, stdout);
                fprintf(stdout, "\nnewSignature (%lu bytes)\n", (unsigned long)newSignatureData.size());
                fwrite(newSignatureData.data(), newSignatureData.size(), 1, stdout);
                fprintf(stdout, "\n");
                fflush(stdout);
#endif

                auto const newLength = newSignatureData.size();
                if (newLength == oldSignatureData.size() && 
                    memcmp(newSignatureData.data(), oldSignatureData.data(), newLength) == 0) {
                    log_v("Code signature of %s is unchanged; keeping original", lib.c_str());
                    // The two signatures match.  Unlink the new file, and re-link the old file.
                    const char *filePath = dst.c_str();
                    unlink(filePath);
                    link(tmpFilePath, filePath);
                }
            }
            // Clean up any temporary files.
            if (tmpFilePath) {
                unlink(tmpFilePath);
            }

            if (!signedOne) {
                // We are the first signer. Allow the others to proceed now.
                signedOne = true;
                signingLock.unlock();
            }
        };
    }
    exit(0);
}