VuoFileUtilities.cc

Go to the documentation of this file.

 
#include <CommonCrypto/CommonDigest.h>
#include <dirent.h>
#include <spawn.h>
#include <sstream>
#include <sys/mman.h>
#include <sys/stat.h>
#include <copyfile.h>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <mach-o/dyld.h>
#include <sys/time.h>
#include "VuoException.hh"
#include "VuoFileUtilities.hh"
#include "VuoFileUtilitiesCocoa.hh"
#include "VuoStringUtilities.hh"
 
bool VuoFileUtilities::dylibLoaderInitialMatchCompleted = false;
string VuoFileUtilities::vuoFrameworkPath;
string VuoFileUtilities::vuoRunnerFrameworkPath;
 
void VuoFileUtilities::splitPath(string path, string &dir, string &file, string &extension)
{
    dir = "";
    file = "";
    extension = "";
    const char FILE_SEPARATOR = '/';
 
    size_t separatorIndex = path.rfind(FILE_SEPARATOR);
    string fileAndExtension;
    if (separatorIndex != string::npos)
    {
        dir = path.substr(0, separatorIndex + 1);
        if (separatorIndex < path.length())
            fileAndExtension = path.substr(separatorIndex + 1, path.length());
    }
    else
    {
        fileAndExtension = path;
    }
 
    size_t dotIndex = fileAndExtension.rfind(".");
    if (dotIndex != string::npos)
    {
        file = fileAndExtension.substr(0, dotIndex);
        extension = fileAndExtension.substr(dotIndex + 1, fileAndExtension.length());
    }
    else
    {
        file = fileAndExtension;
    }
}
 
void VuoFileUtilities::canonicalizePath(string &path)
{
    // Remove repeated file separators.
    for (int i = 0; i < path.length(); ++i)
        if (path[i] == '/')
            while (i+1 < path.length() && path[i+1] == '/')
                path.erase(i+1, 1);
 
    // Remove trailing file separator.
    if (path.length() > 1 && VuoStringUtilities::endsWith(path, "/"))
        path.erase(path.length()-1);
}
 
bool VuoFileUtilities::arePathsEqual(string path1, string path2)
{
    canonicalizePath(path1);
    canonicalizePath(path2);
    return path1 == path2;
}
 
string VuoFileUtilities::getAbsolutePath(const string &path)
{
    if (VuoStringUtilities::beginsWith(path, "/"))
        return path;
 
    char *cwd = getcwd(NULL, 0);
    if (! cwd)
    {
        VUserLog("Couldn't get current working directory: %s", strerror(errno));
        return path;
    }
 
    string absolutePath = string(cwd) + "/" + path;
    free(cwd);
    return absolutePath;
}
 
string VuoFileUtilities::makeTmpFile(string file, string extension, string directory)
{
    if (directory.empty())
        directory = getTmpDir();
    if (directory.at(directory.length()-1) != '/')
        directory += "/";
    string suffix = (extension.empty() ? "" : ("." + extension));
    string pathTemplate = directory + file + "-XXXXXX" + suffix;
    char *path = (char *)calloc(pathTemplate.length() + 1, sizeof(char));
    strncpy(path, pathTemplate.c_str(), pathTemplate.length());
    int fd = mkstemps(path, suffix.length());
    close(fd);  
    string pathStr(path);
    free(path);
    return pathStr;
}
 
string VuoFileUtilities::makeTmpDir(string prefix)
{
    string pathTemplate = getTmpDir() + "/" + prefix + ".XXXXXX";
    char *path = (char *)calloc(pathTemplate.length() + 1, sizeof(char));
    strncpy(path, pathTemplate.c_str(), pathTemplate.length());
    mkdtemp(path);
    string pathStr(path);
    free(path);
    return pathStr;
}
 
string VuoFileUtilities::makeTmpDirOnSameVolumeAsPath(string path)
{
    return VuoFileUtilitiesCocoa_makeTmpDirOnSameVolumeAsPath(path);
}
 
string VuoFileUtilities::getTmpDir(void)
{
    char *cwd = getcwd(NULL, 0);
    if (!cwd)
        VUserLog("Error in getcwd(): %s", strerror(errno));
 
    if (cwd && strstr(cwd, "/Library/Containers/"))  // We're in a sandbox.
    {
        // https://b33p.net/kosada/node/16374
        // In the macOS 10.15 screen saver sandbox, at least,
        // we're not allowed to use the system or user temporary directories for socket-files,
        // but we are allowed to use the sandbox container directory.
        string cwdS(cwd);
        free(cwd);
        return VuoStringUtilities::endsWith(cwdS, "/") ? VuoStringUtilities::substrBefore(cwdS, "/") : cwdS;
    }
    free(cwd);
 
    char userTempDir[PATH_MAX];
    if (confstr(_CS_DARWIN_USER_TEMP_DIR, userTempDir, PATH_MAX) > 0)
    {
        string userTempDirS(userTempDir);
        return VuoStringUtilities::endsWith(userTempDirS, "/") ? VuoStringUtilities::substrBefore(userTempDirS, "/") : userTempDirS;
    }
 
    return "/tmp";
}
 
void VuoFileUtilities::makeDir(string path)
{
    if (path.empty())
        throw VuoException("Couldn't create directory with empty path");
 
    if (dirExists(path))
        return;
 
    const char FILE_SEPARATOR = '/';
    size_t lastNonSeparator = path.find_last_not_of(FILE_SEPARATOR);
    if (lastNonSeparator != string::npos)
        path.resize(lastNonSeparator + 1);
 
    string parentDir, file, ext;
    splitPath(path, parentDir, file, ext);
    makeDir(parentDir);
 
    // `mkdir` ANDs the mode with the process's umask,
    // so by default the created directory's mode will end up being 0755.
    int ret = mkdir(path.c_str(), 0777);
    int mkdirErrno = errno;
    if (ret != 0 && ! dirExists(path))
        throw VuoException((string("Couldn't create directory \"" + path + "\": ") + strerror(mkdirErrno)).c_str());
}
 
void VuoFileUtilities::dylibLoaded(const struct mach_header *mh32, intptr_t vmaddr_slide)
{
    if (dylibLoaderInitialMatchCompleted)
        return;
 
    const struct mach_header_64 *mh = reinterpret_cast<const mach_header_64 *>(mh32);
 
    // Ignore system libraries.
    if (mh->flags & MH_DYLIB_IN_CACHE)
        return;
 
    // Get the file path of the current dylib.
    Dl_info info{"", nullptr, "", nullptr};
    dladdr((void *)vmaddr_slide, &info);
 
    // Check whether it's one of the dylibs we're looking for.
 
    auto getMatchingPath = [info](string fragment) -> string {
        string qualifiedFragment = "/" + fragment + ".framework/Versions/";
        const char *found = strstr(info.dli_fname, qualifiedFragment.c_str());
        if (found)
        {
            char *pathC = strndup(info.dli_fname, found - info.dli_fname);
            string path = string(pathC) + "/" + fragment + ".framework";
            free(pathC);
            if (access(path.c_str(), 0) == 0)
                return path;
        }
        return string();
    };
 
    string possibleVuoFramework = getMatchingPath("Vuo");
    if (!possibleVuoFramework.empty())
        vuoFrameworkPath = possibleVuoFramework;
 
    string possibleVuoRunnerFramework = getMatchingPath("VuoRunner");
    if (!possibleVuoRunnerFramework.empty())
        vuoRunnerFrameworkPath = possibleVuoRunnerFramework;
}
 
void VuoFileUtilities::initializeVuoFrameworkPaths(void)
{
    static once_flag once;
    call_once(once, []() {
        // Check whether Vuo.framework is in the list of loaded dynamic libraries.
        _dyld_register_func_for_add_image(&dylibLoaded);
        dylibLoaderInitialMatchCompleted = true;
        // The above function invokes the callback for each already-loaded dylib, then returns.
 
        if (vuoRunnerFrameworkPath.empty() && !vuoFrameworkPath.empty())
        {
            // Check for VuoRunner.framework alongside Vuo.framework.
            string pathCandidate = vuoFrameworkPath + "/../VuoRunner.framework";
            if (dirExists(pathCandidate))
                vuoRunnerFrameworkPath = pathCandidate;
        }
    });
}
 
string VuoFileUtilities::getVuoFrameworkPath(void)
{
    initializeVuoFrameworkPaths();
    return vuoFrameworkPath;
}
 
string VuoFileUtilities::getVuoRunnerFrameworkPath(void)
{
    initializeVuoFrameworkPaths();
    return vuoRunnerFrameworkPath;
}
 
string VuoFileUtilities::getCompositionLocalModulesPath(const string &compositionPath)
{
    string compositionDir, compositionFile, ext;
    splitPath(getAbsolutePath(compositionPath), compositionDir, compositionFile, ext);
    canonicalizePath(compositionDir);
 
    string parentDir, compositionDirName;
    splitPath(compositionDir, parentDir, compositionDirName, ext);
    canonicalizePath(compositionDirName);
 
    string compositionBaseDir = (compositionDirName == "Modules" ? parentDir : compositionDir);
 
    string compositionModulesDir = compositionBaseDir + "/Modules";
    canonicalizePath(compositionModulesDir);
 
    return compositionModulesDir;
}
 
string VuoFileUtilities::getUserModulesPath()
{
    const char *home = getenv("HOME");
    if (!home)
        return string();
 
    return string(home) + "/Library/Application Support/Vuo/Modules";
}
 
string VuoFileUtilities::getSystemModulesPath()
{
    return "/Library/Application Support/Vuo/Modules";
}
 
string VuoFileUtilities::getCachePath(void)
{
    const char *home = getenv("HOME");
    if (!home)
        return string();
 
    return string(home) + "/Library/Caches/org.vuo/" + VUO_VERSION_AND_BUILD_STRING;
}
 
bool VuoFileUtilities::isInstalledAsModule(const string &path)
{
    if (path.empty())
        return false;
 
    string compositionLocalModulesPath = getCompositionLocalModulesPath(path);
 
    string dir, file, ext;
    VuoFileUtilities::splitPath(path, dir, file, ext);
 
    return VuoFileUtilities::arePathsEqual(compositionLocalModulesPath, dir);
}
 
void VuoFileUtilities::preserveOriginalFileName(string &fileContents, string originalFileName)
{
    fileContents.insert(getFirstInsertionIndex(fileContents), "#line 1 \"" + originalFileName + "\"\n");
}
 
size_t VuoFileUtilities::getFirstInsertionIndex(string s)
{
    string bomUtf8 = "\xEF\xBB\xBF";
    string bomUtf16Be = "\xFE\xFF";
    string bomUtf16Le = "\xFF\xFE";
    string boms[] = { bomUtf8, bomUtf16Be, bomUtf16Le };
    for (int i = 0; i < 3; ++i)
    {
        bool isMatch = true;
        for (int j = 0; j < boms[i].length(); ++j)
            if (boms[i][j] != s[j])
                isMatch = false;
 
        if (isMatch)
            return boms[i].length();
    }
    return 0;
}
 
string VuoFileUtilities::readStdinToString(void)
{
    // https://stackoverflow.com/questions/201992/how-to-read-until-eof-from-cin-in-c
 
    string contents;
    string line;
    while (getline(cin, line))
       contents += line;
 
    return contents;
}
 
string VuoFileUtilities::readFileToString(string path)
{
    // https://stackoverflow.com/questions/2602013/read-whole-ascii-file-into-c-stdstring
 
    ifstream in(path.c_str(), ios::in | ios::binary);
    if (! in)
        throw VuoException(string("Couldn't read file: ") + strerror(errno) + " — " + path);
 
    string contents;
    in.seekg(0, ios::end);
    contents.resize(in.tellg());
    in.seekg(0, ios::beg);
    in.read(&contents[0], contents.size());
    in.close();
    return contents;
}
 
void VuoFileUtilities::writeRawDataToFile(const char *data, size_t numBytes, string file)
{
    FILE *f = fopen(file.c_str(), "wb");
    if (! f)
        throw VuoException(string("Couldn't open file for writing: ") + strerror(errno) + " — " + file);
 
    size_t numBytesWritten = fwrite(data, sizeof(char), numBytes, f);
    if (numBytesWritten != numBytes)
    {
        fclose(f);
        throw VuoException(string("Couldn't write all data: ") + strerror(errno) + " — " + file);
    }
 
    fclose(f);
}
 
void VuoFileUtilities::writeStringToFile(string s, string file)
{
    writeRawDataToFile(s.data(), s.length(), file);
}
 
void VuoFileUtilities::writeStringToFileSafely(string s, string path)
{
    string dir, file, ext;
    splitPath(path, dir, file, ext);
    string tmpPath = makeTmpFile("." + file, ext, dir);
 
    writeStringToFile(s, tmpPath);
 
    moveFile(tmpPath, path);
}
 
bool VuoFileUtilities::fileExists(string path)
{
    if (VuoFileUtilitiesCocoa_isMacAlias(path))
        path = VuoFileUtilitiesCocoa_resolveMacAlias(path);
 
    // `access()` automatically dereferences symlinks.
    return access(path.c_str(), 0) == 0;
}
 
bool VuoFileUtilities::dirExists(string path)
{
    if (VuoFileUtilitiesCocoa_isMacAlias(path))
        path = VuoFileUtilitiesCocoa_resolveMacAlias(path);
 
    // `stat()` automatically dereferences symlinks.
    struct stat st_buf;
    int status = stat(path.c_str(), &st_buf);
    return (! status && S_ISDIR(st_buf.st_mode));
}
 
bool VuoFileUtilities::isSymlink(string path)
{
    struct stat st_buf;
    int status = lstat(path.c_str(), &st_buf);
    return (! status && S_ISLNK(st_buf.st_mode));
}
 
bool VuoFileUtilities::fileIsReadable(string path)
{
    if (VuoFileUtilitiesCocoa_isMacAlias(path))
        path = VuoFileUtilitiesCocoa_resolveMacAlias(path);
 
    // `access()` automatically dereferences symlinks.
    return access(path.c_str(), R_OK) == 0;
}
 
bool VuoFileUtilities::fileContainsReadableData(string path)
{
    if (VuoFileUtilitiesCocoa_isMacAlias(path))
        path = VuoFileUtilitiesCocoa_resolveMacAlias(path);
 
    // `fopen()` automatically dereferences symlinks.
    FILE *f = fopen(path.c_str(), "rb");
    if (!f)
        return false;
 
    fseek(f, 0, SEEK_END);
    long pos = ftell(f);
    if (pos <= 0)
    {
        fclose(f);
        return false;
    }
 
    // `fopen` and `fseek` both succeed on directories, so also attempt to actually read the data.
    fseek(f, 0, SEEK_SET);
    char z;
    size_t ret = fread(&z, 1, 1, f);
    fclose(f);
    return ret > 0;
}
 
void VuoFileUtilities::createFile(string path)
{
    FILE *f = fopen(path.c_str(), "a");
    fclose(f);
}
 
void VuoFileUtilities::deleteFile(string path)
{
    int ret = remove(path.c_str());
    if (ret != 0 && fileExists(path))
        VUserLog("Couldn't delete file: %s — %s", strerror(errno), path.c_str());
}
 
void VuoFileUtilities::deleteDir(string path)
{
    if (! dirExists(path))
        return;
 
    DIR *d = opendir(path.c_str());
    if (! d)
    {
        VUserLog("Couldn't read directory: %s — %s", strerror(errno), path.c_str());
        return;
    }
 
    struct dirent *de;
    while( (de=readdir(d)) )
    {
        string fileName = de->d_name;
        string filePath = path + "/" + fileName;
 
        if (fileName == "." || fileName == "..")
            continue;
 
        if (dirExists(filePath))
            deleteDir(filePath);
        else
            deleteFile(filePath);
    }
 
    closedir(d);
 
    deleteFile(path);
}
 
void VuoFileUtilities::moveFile(string fromPath, string toPath)
{
    int ret = rename(fromPath.c_str(), toPath.c_str());
    if (ret != 0)
        throw VuoException(string("Couldn't move file: ") + strerror(errno) + " — " + toPath);
}
 
void VuoFileUtilities::moveFileToTrash(string filePath)
{
    VuoFileUtilitiesCocoa_moveFileToTrash(filePath);
}
 
void VuoFileUtilities::copyFile(string fromPath, string toPath, bool preserveMetadata)
{
    int i = open(fromPath.c_str(), O_RDONLY);
    if (i == -1)
        throw VuoException(string("Couldn't open copy source: ") + strerror(errno) + " — " + fromPath);
 
    struct stat s;
    fstat(i, &s);
    int o = open(toPath.c_str(), O_WRONLY | O_CREAT, s.st_mode & 0777);
    if (o == -1)
    {
        close(i);
        throw VuoException(string("Couldn't open copy destination: ") + strerror(errno) + " — " + toPath);
    }
 
    int ret = fcopyfile(i, o, NULL, COPYFILE_DATA | (preserveMetadata ? COPYFILE_STAT : 0));
    char *e = strerror(errno);
    close(o);
    close(i);
 
    if (ret)
        throw VuoException(string("Couldn't copy ") + fromPath + " to " + toPath + ": " + e);
 
    VDebugLog("%s -> %s", fromPath.c_str(), toPath.c_str());
}
 
void VuoFileUtilities::copyDirectory(string fromPath, string toPath)
{
    if (isSymlink(fromPath))
    {
        // Preserve the relative symlinks found in framework bundles, instead of flattening them.
        char linkDestination[PATH_MAX + 1];
        ssize_t len = readlink(fromPath.c_str(), linkDestination, PATH_MAX);
        linkDestination[len] = 0;  // "readlink does not append a NUL character to buf."
        if (symlink(linkDestination, toPath.c_str()) == -1)
            throw VuoException(string("Couldn't copy symlink \"") + fromPath + "\" to \"" + toPath + "\": " + strerror(errno));
 
        VDebugLog("%s -> %s (symlink)", fromPath.c_str(), toPath.c_str());
    }
 
    else if (!dirExists(fromPath))
        copyFile(fromPath, toPath);
 
    else
    {
        VDebugLog("%s ::", fromPath.c_str());
        auto files = findAllFilesInDirectory(fromPath);
        makeDir(toPath);
        for (auto file : files)
        {
            string sourceFile = fromPath + "/" + file->getRelativePath();
            string targetFile = toPath + "/" + file->getRelativePath();
            copyDirectory(sourceFile, targetFile);
        }
    }
}
 
string VuoFileUtilities::calculateFileSHA256(const string &path)
{
    int fd = open(path.c_str(), O_RDONLY);
    if (fd < 0)
        throw VuoException("Error: Couldn't open \"" + path + "\": " + strerror(errno));
    VuoDefer(^{ close(fd); });
 
    struct stat stat;
    if (fstat(fd, &stat) != 0)
        throw VuoException("Error: Couldn't fstat \"" + path + "\": " + strerror(errno));
 
    // Instead of reading the file into a string and calling `VuoStringUtilities::calculateSHA256`,
    // use `mmap` so the OS can efficiently read parts of the file at a time (reducing memory required).
    void *data = mmap(nullptr, stat.st_size, PROT_READ, MAP_PRIVATE | MAP_NOCACHE, fd, 0);
    if (data == MAP_FAILED)
        throw VuoException("Error: Couldn't mmap \"" + path + "\": " + strerror(errno));
    VuoDefer(^{ munmap(data, stat.st_size); });
 
    unsigned char hash[CC_SHA256_DIGEST_LENGTH];
    if (!CC_SHA256(data, stat.st_size, hash))
        throw VuoException("Error: CC_SHA256 failed on file \"" + path + "\"");
 
    ostringstream oss;
    oss << setfill('0') << hex;
    for (int i = 0; i < CC_SHA256_DIGEST_LENGTH; ++i)
        oss << setw(2) << (int)hash[i];
    return oss.str();
}
 
unsigned long VuoFileUtilities::getFileLastModifiedInSeconds(string path)
{
    struct stat s;
    lstat(path.c_str(), &s);
    return s.st_mtimespec.tv_sec;  // s.st_mtimespec.tv_nsec is always 0 on some OSes, hence the resolution of 1 second
}
 
unsigned long VuoFileUtilities::getSecondsSinceFileLastAccessed(string path)
{
    struct stat s;
    lstat(path.c_str(), &s);
 
    struct timeval t;
    gettimeofday(&t, NULL);
 
    return t.tv_sec - s.st_atimespec.tv_sec;
}
 
set<VuoFileUtilities::File *> VuoFileUtilities::findAllFilesInDirectory(string dirPath, set<string> archiveExtensions,
                                                                        bool shouldSearchRecursively)
{
    set<File *> files;
 
    if (VuoFileUtilitiesCocoa_isMacAlias(dirPath))
        dirPath = VuoFileUtilitiesCocoa_resolveMacAlias(dirPath);
 
    // `opendir()` automatically dereferences symlinks.
    DIR *d = opendir(dirPath.c_str());
    if (! d)
    {
        if (access(dirPath.c_str(), F_OK) != -1)
            throw VuoException(string("Couldn't read directory: ") + strerror(errno) + " — " + dirPath);
        return files;
    }
 
    struct dirent *de;
    while( (de=readdir(d)) )
    {
        string fileName = de->d_name;
        string relativeFilePath = dirPath + "/" + fileName;
 
        if (fileName == "." || fileName == "..")
            continue;
 
        bool isArchive = false;
        for (set<string>::iterator archiveExtension = archiveExtensions.begin(); archiveExtension != archiveExtensions.end(); ++archiveExtension)
            if (VuoStringUtilities::endsWith(fileName, "." + *archiveExtension))
                isArchive = true;
 
        if (isArchive)
        {
            set<File *> fs = findAllFilesInArchive(relativeFilePath);
            if (fs.empty())
                isArchive = false;
            else
                files.insert(fs.begin(), fs.end());
        }
 
        if (! isArchive)
        {
            bool shouldSearchDir = shouldSearchRecursively
                                && dirExists(relativeFilePath)
                                && !isSymlink(relativeFilePath);
            if (shouldSearchDir)
            {
                set<File *> filesInDir = findAllFilesInDirectory(relativeFilePath, archiveExtensions, true);
                for (set<File *>::iterator i = filesInDir.begin(); i != filesInDir.end(); ++i)
                {
                    File *f = *i;
                    f->dirPath = dirPath;
                    f->filePath = fileName + "/" + f->filePath;
                }
                files.insert(filesInDir.begin(), filesInDir.end());
            }
            else
            {
                File *f = new File(dirPath, fileName);
                files.insert(f);
            }
        }
    }
 
    closedir(d);
 
    return files;
}
 
set<VuoFileUtilities::File *> VuoFileUtilities::findFilesInDirectory(string dirPath, set<string> extensions, set<string> archiveExtensions)
{
    set<File *> allFiles = findAllFilesInDirectory(dirPath, archiveExtensions);
    set<File *> matchingFiles;
 
    for (set<File *>::iterator i = allFiles.begin(); i != allFiles.end(); ++i)
    {
        bool endsWithExtension = false;
        for (set<string>::iterator extension = extensions.begin(); extension != extensions.end(); ++extension)
            if (VuoStringUtilities::endsWith((*i)->getRelativePath(), "." + *extension))
                endsWithExtension = true;
 
        if (endsWithExtension && ((*i)->isInArchive() || !VuoFileUtilities::dirExists((*i)->path())))
            matchingFiles.insert(*i);
        else
            delete *i;
    }
 
    return matchingFiles;
}
 
set<VuoFileUtilities::File *> VuoFileUtilities::findAllFilesInArchive(string archivePath)
{
    set<File *> files;
 
    Archive *archive = new Archive(archivePath);
    if (! archive->zipArchive)
    {
        delete archive;
        return files;
    }
 
    mz_uint numFiles = mz_zip_reader_get_num_files(archive->zipArchive);
    for (mz_uint i = 0; i < numFiles; ++i)
    {
        mz_zip_archive_file_stat file_stat;
        bool success = mz_zip_reader_file_stat(archive->zipArchive, i, &file_stat);
        if (! success)
        {
            VUserLog("Error: Couldn't read file '%u' in zip archive '%s'.", i, archive->path.c_str());
            break;
        }
 
        File *f = new File(archive, file_stat.m_filename);
        files.insert(f);
    }
 
    if (archive->referenceCount == 0)
        delete archive;
 
    return files;
}
 
set<VuoFileUtilities::File *> VuoFileUtilities::findFilesInArchive(string archivePath, string dirPath, set<string> extensions)
{
    set<File *> allFiles = findAllFilesInArchive(archivePath);
    set<File *> matchingFiles;
 
    for (set<File *>::iterator i = allFiles.begin(); i != allFiles.end(); ++i)
    {
        File *f = *i;
 
        string dir, file, ext;
        splitPath(f->getRelativePath(), dir, file, ext);
        bool beginsWithDir = VuoStringUtilities::beginsWith(dir, dirPath);
 
        bool endsWithExtension = false;
        for (set<string>::iterator extension = extensions.begin(); extension != extensions.end(); ++extension)
            if (VuoStringUtilities::endsWith(f->getRelativePath(), "." + *extension))
                endsWithExtension = true;
 
        if (beginsWithDir && endsWithExtension)
            matchingFiles.insert(f);
        else
            delete f;
    }
 
    return matchingFiles;
}
 
string VuoFileUtilities::getArchiveFileContentsAsString(string archivePath, string filePath)
{
    string contents;
    set<File *> archiveFiles = findAllFilesInArchive(archivePath);
    for (set<File *>::iterator i = archiveFiles.begin(); i != archiveFiles.end(); ++i)
    {
        File *file = *i;
        if (filePath == file->getRelativePath())
            contents = file->getContentsAsString();
        delete file;
    }
 
    return contents;
}
 
size_t VuoFileUtilities::getAvailableSpaceOnVolumeContainingPath(string path)
{
    return VuoFileUtilitiesCocoa_getAvailableSpaceOnVolumeContainingPath(path);
}
 
void VuoFileUtilities::adHocCodeSign(string path, vector<string> environment, string entitlementsPath)
{
    double t0 = VuoLogGetTime();
    vector<string> processAndArgs{
        getVuoFrameworkPath() + "/Helpers/codesignWrapper.sh",
        "--force",
        "--sign",
        "-",  // "-" = ad-hoc
        path,
    };
    if (!entitlementsPath.empty())
    {
        processAndArgs.push_back("--entitlements");
        processAndArgs.push_back(entitlementsPath);
    }
    executeProcess(processAndArgs, environment);
 
    VDebugLog("\tAd-hoc code-signing took %5.2fs", VuoLogGetTime() - t0);
}
 
VuoFileUtilities::Archive::Archive(string path) :
    path(path)
{
    this->referenceCount = 0;
 
    // mz_zip_reader_init_file sometimes ends up with a garbage function pointer if the mz_zip_archive isn't initialized to zeroes
    this->zipArchive = (mz_zip_archive *)calloc(1, sizeof(mz_zip_archive));
 
    bool success = mz_zip_reader_init_file(zipArchive, path.c_str(), 0);
    if (! success)
    {
        free(zipArchive);
        zipArchive = NULL;
    }
}
 
VuoFileUtilities::Archive::~Archive(void)
{
    if (zipArchive)
    {
        mz_zip_reader_end(zipArchive);
        free(zipArchive);
    }
}
 
VuoFileUtilities::File::File()
{
}
 
VuoFileUtilities::File::File(string dirPath, string filePath) :
    filePath(filePath),
    dirPath(dirPath)
{
    this->fileDescriptor = -1;
    this->archive = NULL;
}
 
VuoFileUtilities::File::File(Archive *archive, string filePath) :
    filePath(filePath)
{
    this->fileDescriptor = -1;
    this->archive = archive;
    ++archive->referenceCount;
}
 
VuoFileUtilities::File VuoFileUtilities::File::fileWithDifferentExtension(string extension)
{
    string newFilePath = basename() + "." + extension;
 
    if (archive)
        return File(archive, newFilePath);
    else
        return File(dirPath, newFilePath);
}
 
VuoFileUtilities::File::~File(void)
{
    if (archive && --archive->referenceCount == 0)
        delete archive;
}
 
bool VuoFileUtilities::File::isInArchive(void)
{
    return (archive != NULL);
}
 
string VuoFileUtilities::File::getArchivePath(void)
{
    return (archive ? archive->path : "");
}
 
string VuoFileUtilities::File::getRelativePath(void)
{
    return filePath;
}
 
string VuoFileUtilities::File::path()
{
    if (archive)
        throw VuoException("Can't return a simple absolute path for a file in an archive.");
 
    return dirPath + "/" + filePath;
}
 
string VuoFileUtilities::File::dir()
{
    if (archive)
        throw VuoException("Can't return a simple absolute path for a file in an archive.");
 
    return dirPath;
}
 
string VuoFileUtilities::File::basename()
{
    return filePath.substr(0, filePath.find_last_of('.'));
}
 
string VuoFileUtilities::File::extension()
{
    return filePath.substr(filePath.find_last_of('.') + 1);
}
 
bool VuoFileUtilities::File::exists()
{
    if (archive)
        return mz_zip_reader_locate_file(archive->zipArchive, filePath.c_str(), nullptr, MZ_ZIP_FLAG_CASE_SENSITIVE) != -1;
    else
        return VuoFileUtilities::fileExists((dirPath.empty() ? "" : (dirPath + "/")) + filePath);
}
 
char * VuoFileUtilities::File::getContentsAsRawData(size_t &numBytes)
{
    char * buffer;
    numBytes = 0;
 
    if (! archive)
    {
        // http://www.cplusplus.com/reference/cstdio/fread/
 
        string fullPath = (dirPath.empty() ? "" : (dirPath + "/")) + filePath;
 
        FILE *pFile = fopen ( fullPath.c_str() , "rb" );
        if (pFile==NULL)
            throw VuoException(string("Couldn't open file: ") + strerror(errno) + " — " + fullPath);
 
        // obtain file size:
        fseek (pFile , 0 , SEEK_END);
        size_t lSize = ftell (pFile);
        rewind (pFile);
 
        // allocate memory to contain the whole file:
        buffer = (char*) malloc (sizeof(char)*lSize);
 
        // copy the file into the buffer:
        numBytes = fread (buffer,1,lSize,pFile);
        fclose(pFile);
        if (numBytes != lSize)
        {
            free(buffer);
            throw VuoException(string("Couldn't read file: ") + strerror(errno) + " — " + fullPath);
        }
    }
    else
    {
        buffer = (char *)mz_zip_reader_extract_file_to_heap(archive->zipArchive, filePath.c_str(), &numBytes, 0);
    }
 
    return buffer;
}
 
string VuoFileUtilities::File::getContentsAsString(void)
{
    size_t numBytes;
    char *buffer = getContentsAsRawData(numBytes);
    string s(buffer, numBytes);
    free(buffer);
    return s;
}
 
bool VuoFileUtilities::File::lockForReading(bool nonBlocking)
{
    if (fileDescriptor < 0)
        fileDescriptor = open((dirPath + "/" + filePath).c_str(), O_RDONLY);
    int ret = flock(fileDescriptor, LOCK_SH | (nonBlocking ? LOCK_NB : 0));
    return ret == 0;
}
 
bool VuoFileUtilities::File::lockForWriting(bool nonBlocking)
{
    if (fileDescriptor < 0)
        fileDescriptor = open((dirPath + "/" + filePath).c_str(), O_RDONLY);
    int ret = flock(fileDescriptor, LOCK_EX | (nonBlocking ? LOCK_NB : 0));
    return ret == 0;
}
 
void VuoFileUtilities::File::unlock(void)
{
    flock(fileDescriptor, LOCK_UN);
    close(fileDescriptor);
    fileDescriptor = -1;
}
 
void VuoFileUtilities::focusProcess(pid_t pid, bool force)
{
    VuoFileUtilitiesCocoa_focusProcess(pid, force);
}
 
void VuoFileUtilities::executeProcess(vector<string> processAndArgs, vector<string> environment)
{
    string binaryDir, binaryFile, binaryExt;
    splitPath(processAndArgs[0], binaryDir, binaryFile, binaryExt);
 
    string errorPrefix = "Couldn't execute " + binaryFile + ": ";
 
    // Capture stdout and stderr.
    int outputPipe[2];
    int ret = pipe(outputPipe);
    if (ret)
        throw VuoException(errorPrefix + "couldn't open pipe: " + strerror(ret));
    int pipeRead  = outputPipe[0];
    int pipeWrite = outputPipe[1];
    VuoDefer(^{ close(pipeRead); });
    posix_spawn_file_actions_t fileActions;
    posix_spawn_file_actions_init(&fileActions);
    posix_spawn_file_actions_adddup2(&fileActions, pipeWrite, STDOUT_FILENO);
    posix_spawn_file_actions_adddup2(&fileActions, pipeWrite, STDERR_FILENO);
    posix_spawn_file_actions_addclose(&fileActions, pipeRead);
 
    // Convert args.
    // posix_spawn requires a null-terminated array, which `&processAndArgs[0]` doesn't guarantee.
    char **processAndArgsZ = (char **)malloc(sizeof(char *) * (processAndArgs.size() + 1));
    int argCount = 0;
    string commandLine;
    for (auto arg : processAndArgs)
    {
        processAndArgsZ[argCount++] = strdup(arg.c_str());
        if (argCount > 0)
            commandLine += ' ';
        commandLine += '"' + arg + '"';
    }
    processAndArgsZ[argCount] = nullptr;
 
 
    // Convert environment.
    // posix_spawn requires a null-terminated array, which `&processAndArgs[0]` doesn't guarantee.
    char **environmentZ = (char **)malloc(sizeof(char *) * (environment.size() + 1));
    int environmentVarCount = 0;
    for (auto environmentVar : environment)
    {
        environmentZ[environmentVarCount++] = strdup(environmentVar.c_str());
        commandLine = environmentVar + " " + commandLine;
    }
    environmentZ[environmentVarCount] = nullptr;
 
 
    // Execute.
    pid_t pid;
    VDebugLog("%s", commandLine.c_str());
    ret = posix_spawn(&pid, processAndArgs[0].c_str(), &fileActions, NULL, (char * const *)processAndArgsZ, (char * const *)environmentZ);
    close(pipeWrite);
    posix_spawn_file_actions_destroy(&fileActions);
    for (int i = 0; i < argCount; ++i)
        free(processAndArgsZ[i]);
 
    if (ret)
        throw VuoException(errorPrefix + strerror(ret));
    else
    {
        int ret;
        int status;
        while (true)
        {
            ret = waitpid(pid, &status, 0);
            if (ret == -1 && errno == EINTR)
                // This process received a signal while waiting for the other process
                // (seems to happen when running under lldb); try waiting again.
                continue;
            else if (ret == -1)
                throw VuoException(errorPrefix + "waitpid failed: " + strerror(errno));
            else if (status != 0)
            {
                string output;
                char buf[256];
                bzero(buf, 256);
                while (read(pipeRead, &buf, 255) > 0)
                {
                    output += buf;
                    bzero(buf, 256);
                }
 
                throw VuoException(binaryFile + " failed: " + output);
            }
            else
                // The other process completed without error.
                break;
        }
    }
}
 
bool VuoFileUtilities::isCompositionExtension(string extension)
{
    return extension == "vuo";
}
 
set<string> VuoFileUtilities::getCSourceExtensions()
{
    set<string> e;
    e.insert("c");
    e.insert("cc");
    e.insert("C");
    e.insert("cpp");
    e.insert("cxx");
    e.insert("c++");
    e.insert("m");
    e.insert("mm");
    return e;
}
 
bool VuoFileUtilities::isCSourceExtension(string extension)
{
    auto extensions = getCSourceExtensions();
    return extensions.find(extension) != extensions.end();
}
 
bool VuoFileUtilities::isIsfSourceExtension(string extension)
{
    set<string> e;
    e.insert("fs");
    e.insert("vs");
    e.insert("vuoshader");
    e.insert("vuoobjectfilter");
    return e.find(extension) != e.end();
}
 
string VuoFileUtilities::buildModuleCacheDescription(const string &moduleCachePath, bool generated)
{
    return string() + "the cache of " + (generated ? "generated" : "installed") + " modules at '" + moduleCachePath + "'";
}
 
string VuoFileUtilities::buildModuleCacheIndexPath(const string &moduleCachePath, bool builtIn, bool generated)
{
    string moduleCachePathCanonical = moduleCachePath;
    canonicalizePath(moduleCachePathCanonical);
 
    return moduleCachePathCanonical + "/libVuoModuleCache-" + (generated ? "generated" : "installed") + ".txt";
}
 
string VuoFileUtilities::buildModuleCacheDylibPath(const string &moduleCachePath, bool builtIn, bool generated)
{
    string moduleCachePathCanonical = moduleCachePath;
    canonicalizePath(moduleCachePathCanonical);
 
    string partialPath = moduleCachePathCanonical + "/libVuoModuleCache-" + (generated ? "generated" : "installed");
    if (builtIn)
        return partialPath + ".dylib";
 
    string uniquePath;
    do {
        uniquePath = partialPath + "-" + VuoStringUtilities::makeRandomHash(4) + ".dylib";
    } while (fileExists(uniquePath));
    return uniquePath;
}
 
string VuoFileUtilities::findLatestRevisionOfModuleCacheDylib(const string &moduleCachePath, bool builtIn, bool generated,
                                                              unsigned long &lastModified)
{
    string path = buildModuleCacheDylibPath(moduleCachePath, builtIn, generated);
 
    if (builtIn)
    {
        if (fileExists(path))
        {
            lastModified = getFileLastModifiedInSeconds(path);
            return path;
        }
        else
        {
            lastModified = 0;
            return "";
        }
    }
 
    string dir, file, ext;
    splitPath(path, dir, file, ext);
    string fileName = file + "." + ext;
 
    vector< pair<string, unsigned long> > existingRevisions;
    for (File *existingFile : findFilesInDirectory(moduleCachePath, {"dylib"}))
    {
        if (areDifferentRevisionsOfSameModuleCacheDylib(existingFile->getRelativePath(), fileName))
            existingRevisions.push_back({existingFile->path(), getFileLastModifiedInSeconds(existingFile->path())});
 
        delete existingFile;
    }
 
    if (existingRevisions.empty())
    {
        lastModified = 0;
        return "";
    }
 
    auto latest = std::max_element(existingRevisions.begin(), existingRevisions.end(),
                                   [](pair<string, unsigned long> p1, pair<string, unsigned long> p2) { return p1.second < p2.second; });
 
    lastModified = latest->second;
    return latest->first;
}
 
void VuoFileUtilities::deleteOtherRevisionsOfModuleCacheDylib(const string &dylibPath)
{
    string moduleCachePath, file, ext;
    splitPath(dylibPath, moduleCachePath, file, ext);
    string dylibFileName = file + "." + ext;
 
    for (File *otherFile : findFilesInDirectory(moduleCachePath, {"dylib"}))
    {
        if (areDifferentRevisionsOfSameModuleCacheDylib(otherFile->getRelativePath(), dylibFileName))
            deleteFile(otherFile->path());
 
        delete otherFile;
    }
}
 
bool VuoFileUtilities::areDifferentRevisionsOfSameModuleCacheDylib(const string &dylibPath1, const string &dylibPath2)
{
    string dir1, dir2, file1, file2, ext;
    splitPath(dylibPath1, dir1, file1, ext);
    splitPath(dylibPath2, dir2, file2, ext);
 
    if (arePathsEqual(dir1, dir2))
    {
        vector<string> parts1 = VuoStringUtilities::split(file1, '-');
        vector<string> parts2 = VuoStringUtilities::split(file2, '-');
 
        if (parts1.size() == 3 && parts2.size() == 3 && parts1.back() != parts2.back())
        {
            parts1.pop_back();
            parts2.pop_back();
            return parts1 == parts2;
        }
    }
 
    return false;
}