rf-web/vendor/bundle/gems/rb-fsevent-0.10.3/ext/fsevent_watch/FSEventsFix.c

/*
 * FSEventsFix
 *
 * Resolves a long-standing bug in realpath() that prevents FSEvents API from
 * monitoring certain folders on a wide range of OS X released (10.6-10.10 at least).
 *
 * The underlying issue is that for some folders, realpath() call starts returning
 * a path with incorrect casing (e.g. "/users/smt" instead of "/Users/smt").
 * FSEvents is case-sensitive and calls realpath() on the paths you pass in, so
 * an incorrect value returned by realpath() prevents FSEvents from seeing any
 * change events.
 *
 * See the discussion at https://github.com/thibaudgg/rb-fsevent/issues/10 about
 * the history of this bug and how this library came to exist.
 *
 * This library uses Facebook's fishhook to replace a custom implementation of
 * realpath in place of the system realpath; FSEvents will then invoke our custom
 * implementation (which does not screw up the names) and will thus work correctly.
 *
 * Our implementation of realpath is based on the open-source implementation from
 * OS X 10.10, with a single change applied (enclosed in "BEGIN WORKAROUND FOR
 * OS X BUG" ... "END WORKAROUND FOR OS X BUG").
 *
 * Include FSEventsFix.{h,c} into your project and call FSEventsFixInstall().
 *
 * It is recommended that you install FSEventsFix on demand, using FSEventsFixIsBroken
 * to check if the folder you're about to pass to FSEventStreamCreate needs the fix.
 * Note that the fix must be applied before calling FSEventStreamCreate.
 *
 * FSEventsFixIsBroken requires a path that uses the correct case for all folder names,
 * i.e. a path provided by the system APIs or constructed from folder names provided
 * by the directory enumeration APIs.
 *
 * Copyright (c) 2015 Andrey Tarantsov <andrey@tarantsov.com>
 * Copyright (c) 2003 Constantin S. Svintsoff <kostik@iclub.nsu.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * Based on a realpath implementation from Apple libc 498.1.7, taken from
 * http://www.opensource.apple.com/source/Libc/Libc-498.1.7/stdlib/FreeBSD/realpath.c
 * and provided under the following license:
 *
 * Copyright (c) 2003 Constantin S. Svintsoff <kostik@iclub.nsu.ru>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The names of the authors may not be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */


#include "FSEventsFix.h"

#include <dispatch/dispatch.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <dlfcn.h>


const char *const FSEventsFixVersionString = "0.11.0";


#pragma mark - Forward declarations

static char *(*orig_realpath)(const char *restrict file_name, char resolved_name[PATH_MAX]);
static char *CFURL_realpath(const char *restrict file_name, char resolved_name[PATH_MAX]);
static char *FSEventsFix_realpath_wrapper(const char *restrict src, char *restrict dst);

static void _FSEventsFixHookInstall();
static void _FSEventsFixHookUninstall();


#pragma mark - Internal state

static dispatch_queue_t g_queue = NULL;

static int64_t g_enable_refcount = 0;

static bool g_in_self_test = false;
static bool g_hook_operational = false;

static void(^g_logging_block)(FSEventsFixMessageType type, const char *message);
static FSEventsFixDebugOptions g_debug_opt = 0;

typedef struct {
    char *name;
    void *replacement;
    void *original;
    uint hooked_symbols;
} rebinding_t;

static rebinding_t g_rebindings[] = {
    { "_realpath$DARWIN_EXTSN", (void *) &FSEventsFix_realpath_wrapper, (void *) &realpath, 0 }
};
static const uint g_rebindings_nel = sizeof(g_rebindings) / sizeof(g_rebindings[0]);


#pragma mark - Logging

static void _FSEventsFixLog(FSEventsFixMessageType type, const char *__restrict fmt, ...) __attribute__((__format__ (__printf__, 2, 3)));

static void _FSEventsFixLog(FSEventsFixMessageType type, const char *__restrict fmt, ...) {
    if (g_logging_block) {
        char *message = NULL;
        va_list va;
        va_start(va, fmt);
        vasprintf(&message, fmt, va);
        va_end(va);

        if (message) {
            if (!!(g_debug_opt & FSEventsFixDebugOptionLogToStderr)) {
                fprintf(stderr, "FSEventsFix: %s\n", message);
            }
            if (g_logging_block) {
                g_logging_block(type, message);
            }
            free(message);
        }
    }
}


#pragma mark - API

void _FSEventsFixInitialize() {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        g_queue = dispatch_queue_create("FSEventsFix", DISPATCH_QUEUE_SERIAL);
    });
}

void FSEventsFixConfigure(FSEventsFixDebugOptions debugOptions, void(^loggingBlock)(FSEventsFixMessageType severity, const char *message)) {
    _FSEventsFixInitialize();
    loggingBlock = Block_copy(loggingBlock);
    dispatch_sync(g_queue, ^{
        g_debug_opt = debugOptions;
        g_logging_block = loggingBlock;
    });
}

// Must be called from the private serial queue.
void _FSEventsFixSelfTest() {
    g_in_self_test = true;
    g_hook_operational = false;
    static char result[1024];
    realpath("/Etc/__!FSEventsFixSelfTest!__", result);
    g_in_self_test = false;
}

void FSEventsFixEnable() {
    _FSEventsFixInitialize();
    dispatch_sync(g_queue, ^{
        if (++g_enable_refcount == 1) {
            orig_realpath = dlsym(RTLD_DEFAULT, "realpath");
            _FSEventsFixHookInstall();
            _FSEventsFixSelfTest();
            if (g_hook_operational) {
                _FSEventsFixLog(FSEventsFixMessageTypeStatusChange, "Enabled");
            } else {
                _FSEventsFixLog(FSEventsFixMessageTypeFatalError, "Failed to enable (hook not called)");
            }
        }
    });
}

void FSEventsFixDisable() {
    _FSEventsFixInitialize();
    dispatch_sync(g_queue, ^{
        if (g_enable_refcount == 0) {
            abort();
        }
        if (--g_enable_refcount == 0) {
            _FSEventsFixHookUninstall();
            _FSEventsFixSelfTest();
            if (!g_hook_operational) {
                _FSEventsFixLog(FSEventsFixMessageTypeStatusChange, "Disabled");
            } else {
                _FSEventsFixLog(FSEventsFixMessageTypeFatalError, "Failed to disable (hook still called)");
            }
        }
    });
}

bool FSEventsFixIsOperational() {
    _FSEventsFixInitialize();
    __block bool result = false;
    dispatch_sync(g_queue, ^{
        result = g_hook_operational;
    });
    return result;
}

bool _FSEventsFixIsBroken_noresolve(const char *resolved) {
    if (!!(g_debug_opt & FSEventsFixDebugOptionSimulateBroken)) {
        if (strstr(resolved, FSEventsFixSimulatedBrokenFolderMarker)) {
            return true;
        }
    }

    char *reresolved = realpath(resolved, NULL);
    if (reresolved) {
        bool broken = (0 != strcmp(resolved, reresolved));
        free(reresolved);
        return broken;
    } else {
        return true;
    }
}

bool FSEventsFixIsBroken(const char *path) {
    char *resolved = CFURL_realpath(path, NULL);
    if (!resolved) {
        return true;
    }
    bool broken = _FSEventsFixIsBroken_noresolve(resolved);
    free(resolved);
    return broken;
}

char *FSEventsFixCopyRootBrokenFolderPath(const char *inpath) {
    if (!FSEventsFixIsBroken(inpath)) {
        return NULL;
    }

    // get a mutable copy of an absolute path
    char *path = CFURL_realpath(inpath, NULL);
    if (!path) {
        return NULL;
    }

    for (;;) {
        char *sep = strrchr(path, '/');
        if ((sep == NULL) || (sep == path)) {
            break;
        }
        *sep = 0;
        if (!_FSEventsFixIsBroken_noresolve(path)) {
            *sep = '/';
            break;
        }
    }

    return path;
}

static void _FSEventsFixAttemptRepair(const char *folder) {
    int rv = rename(folder, folder);

    if (!!(g_debug_opt & FSEventsFixDebugOptionSimulateRepair)) {
        const char *pos = strstr(folder, FSEventsFixSimulatedBrokenFolderMarker);
        if (pos) {
            char *fixed = strdup(folder);
            fixed[pos - folder] = 0;
            strcat(fixed, pos + strlen(FSEventsFixSimulatedBrokenFolderMarker));

            rv = rename(folder, fixed);
            free(fixed);
        }
    }

    if (rv != 0) {
        if (errno == EPERM) {
            _FSEventsFixLog(FSEventsFixMessageTypeResult, "Permission error when trying to repair '%s'", folder);
        } else {
            _FSEventsFixLog(FSEventsFixMessageTypeExpectedFailure, "Unknown error when trying to repair '%s': errno = %d", folder, errno);
        }
    }
}

FSEventsFixRepairStatus FSEventsFixRepairIfNeeded(const char *inpath) {
    char *root = FSEventsFixCopyRootBrokenFolderPath(inpath);
    if (root == NULL) {
        return FSEventsFixRepairStatusNotBroken;
    }

    for (;;) {
        _FSEventsFixAttemptRepair(root);
        char *newRoot = FSEventsFixCopyRootBrokenFolderPath(inpath);
        if (newRoot == NULL) {
            _FSEventsFixLog(FSEventsFixMessageTypeResult, "Repaired '%s' in '%s'", root, inpath);
            free(root);
            return FSEventsFixRepairStatusRepaired;
        }
        if (0 == strcmp(root, newRoot)) {
            _FSEventsFixLog(FSEventsFixMessageTypeResult, "Failed to repair '%s' in '%s'", root, inpath);
            free(root);
            free(newRoot);
            return FSEventsFixRepairStatusFailed;
        }
        _FSEventsFixLog(FSEventsFixMessageTypeResult, "Partial success, repaired '%s' in '%s'", root, inpath);
        free(root);
        root = newRoot;
    }
}


#pragma mark - FSEventsFix realpath wrapper

static char *FSEventsFix_realpath_wrapper(const char * __restrict src, char * __restrict dst) {
    if (g_in_self_test) {
        if (strstr(src, "__!FSEventsFixSelfTest!__")) {
            g_hook_operational = true;
        }
    }

    // CFURL_realpath doesn't support putting where resolution failed into the
    // dst buffer, so we call the original realpath here first and if it gets a
    // result, replace that with the output of CFURL_realpath. that way all the
    // features of the original realpath are available.
    char *rv = NULL;
    char *orv = orig_realpath(src, dst);
    if (orv != NULL) { rv = CFURL_realpath(src, dst); }

    if (!!(g_debug_opt & FSEventsFixDebugOptionLogCalls)) {
        char *result = rv ?: dst;
        _FSEventsFixLog(FSEventsFixMessageTypeCall, "realpath(%s) => %s\n", src, result);
    }

    if (!!(g_debug_opt & FSEventsFixDebugOptionUppercaseReturn)) {
        char *result = rv ?: dst;
        if (result) {
            for (char *pch = result; *pch; ++pch) {
                *pch = (char)toupper(*pch);
            }
        }
    }

    return rv;
}


#pragma mark - realpath

// naive implementation of realpath on top of CFURL
// NOTE: doesn't quite support the full range of errno results one would
// expect here, in part because some of these functions just return a boolean,
// and in part because i'm not dealing with messy CFErrorRef objects and
// attempting to translate those to sane errno values.
// NOTE: the OSX realpath will return _where_ resolution failed in resolved_name
// if passed in and return NULL. we can't properly support that extension here
// since the resolution happens entirely behind the scenes to us in CFURL.
static char* CFURL_realpath(const char *file_name, char resolved_name[PATH_MAX])
{
    char* resolved;
    CFURLRef url1;
    CFURLRef url2;
    CFStringRef path;

    if (file_name == NULL) {
        errno = EINVAL;
        return (NULL);
    }

#if __DARWIN_UNIX03
    if (*file_name == 0) {
        errno = ENOENT;
        return (NULL);
    }
#endif

    // create a buffer to store our result if we weren't passed one
    if (!resolved_name) {
        if ((resolved = malloc(PATH_MAX)) == NULL) return (NULL);
    } else {
        resolved = resolved_name;
    }

    url1 = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8*)file_name, (CFIndex)strlen(file_name), false);
    if (url1 == NULL) { goto error_return; }

    url2 = CFURLCopyAbsoluteURL(url1);
    CFRelease(url1);
    if (url2 == NULL) { goto error_return; }

    url1 = CFURLCreateFileReferenceURL(NULL, url2, NULL);
    CFRelease(url2);
    if (url1 == NULL) { goto error_return; }

    // if there are multiple hard links to the original path, this may end up
    // being _completely_ different from what was intended
    url2 = CFURLCreateFilePathURL(NULL, url1, NULL);
    CFRelease(url1);
    if (url2 == NULL) { goto error_return; }

    path = CFURLCopyFileSystemPath(url2, kCFURLPOSIXPathStyle);
    CFRelease(url2);
    if (path == NULL) { goto error_return; }

    bool success = CFStringGetCString(path, resolved, PATH_MAX, kCFStringEncodingUTF8);
    CFRelease(path);
    if (!success) { goto error_return; }

    return resolved;

error_return:
    if (!resolved_name) {
        // we weren't passed in an output buffer and created our own. free it
        int e = errno;
        free(resolved);
        errno = e;
    }
    return (NULL);
}


#pragma mark - fishhook

// Copyright (c) 2013, Facebook, Inc.
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name Facebook nor the names of its contributors may be used to
//     endorse or promote products derived from this software without specific
//     prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#import <stdlib.h>
#import <string.h>
#import <sys/types.h>
#import <mach-o/dyld.h>
#import <mach-o/loader.h>
#import <mach-o/nlist.h>

#ifdef __LP64__
typedef struct mach_header_64 mach_header_t;
typedef struct segment_command_64 segment_command_t;
typedef struct section_64 section_t;
typedef struct nlist_64 nlist_t;
#define LC_SEGMENT_ARCH_DEPENDENT LC_SEGMENT_64
#else
typedef struct mach_header mach_header_t;
typedef struct segment_command segment_command_t;
typedef struct section section_t;
typedef struct nlist nlist_t;
#define LC_SEGMENT_ARCH_DEPENDENT LC_SEGMENT
#endif

static volatile bool g_hook_installed = false;

static void _FSEventsFixHookUpdateSection(section_t *section, intptr_t slide, nlist_t *symtab, char *strtab, uint32_t *indirect_symtab)
{
    uint32_t *indirect_symbol_indices = indirect_symtab + section->reserved1;
    void **indirect_symbol_bindings = (void **)((uintptr_t)slide + section->addr);
    for (uint i = 0; i < section->size / sizeof(void *); i++) {
        uint32_t symtab_index = indirect_symbol_indices[i];
        if (symtab_index == INDIRECT_SYMBOL_ABS || symtab_index == INDIRECT_SYMBOL_LOCAL ||
            symtab_index == (INDIRECT_SYMBOL_LOCAL   | INDIRECT_SYMBOL_ABS)) {
            continue;
        }
        uint32_t strtab_offset = symtab[symtab_index].n_un.n_strx;
        char *symbol_name = strtab + strtab_offset;
        for (rebinding_t *cur = g_rebindings, *end = g_rebindings + g_rebindings_nel; cur < end; ++cur)  {
            if (strcmp(symbol_name, cur->name) == 0) {
                if (g_hook_installed) {
                    if (indirect_symbol_bindings[i] != cur->replacement) {
                        indirect_symbol_bindings[i] = cur->replacement;
                        ++cur->hooked_symbols;
                    }
                } else if (cur->original != NULL) {
                    if (indirect_symbol_bindings[i] == cur->replacement) {
                        indirect_symbol_bindings[i] = cur->original;
                        if (cur->hooked_symbols > 0) {
                            --cur->hooked_symbols;
                        }
                    }
                }
                goto symbol_loop;
            }
        }
    symbol_loop:;
    }
}

static void _FSEventsFixHookUpdateImage(const struct mach_header *header, intptr_t slide) {
    Dl_info info;
    if (dladdr(header, &info) == 0) {
        return;
    }

    segment_command_t *cur_seg_cmd;
    segment_command_t *linkedit_segment = NULL;
    struct symtab_command* symtab_cmd = NULL;
    struct dysymtab_command* dysymtab_cmd = NULL;

    uintptr_t cur = (uintptr_t)header + sizeof(mach_header_t);
    for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) {
        cur_seg_cmd = (segment_command_t *)cur;
        if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) {
            if (strcmp(cur_seg_cmd->segname, SEG_LINKEDIT) == 0) {
                linkedit_segment = cur_seg_cmd;
            }
        } else if (cur_seg_cmd->cmd == LC_SYMTAB) {
            symtab_cmd = (struct symtab_command*)cur_seg_cmd;
        } else if (cur_seg_cmd->cmd == LC_DYSYMTAB) {
            dysymtab_cmd = (struct dysymtab_command*)cur_seg_cmd;
        }
    }

    if (!symtab_cmd || !dysymtab_cmd || !linkedit_segment ||
        !dysymtab_cmd->nindirectsyms) {
        return;
    }

    // Find base symbol/string table addresses
    uintptr_t linkedit_base = (uintptr_t)slide + linkedit_segment->vmaddr - linkedit_segment->fileoff;
    nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff);
    char *strtab = (char *)(linkedit_base + symtab_cmd->stroff);

    // Get indirect symbol table (array of uint32_t indices into symbol table)
    uint32_t *indirect_symtab = (uint32_t *)(linkedit_base + dysymtab_cmd->indirectsymoff);

    cur = (uintptr_t)header + sizeof(mach_header_t);
    for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) {
        cur_seg_cmd = (segment_command_t *)cur;
        if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) {
            if (strcmp(cur_seg_cmd->segname, SEG_DATA) != 0) {
                continue;
            }
            for (uint j = 0; j < cur_seg_cmd->nsects; j++) {
                section_t *sect =
                (section_t *)(cur + sizeof(segment_command_t)) + j;
                if ((sect->flags & SECTION_TYPE) == S_LAZY_SYMBOL_POINTERS) {
                    _FSEventsFixHookUpdateSection(sect, slide, symtab, strtab, indirect_symtab);
                }
                if ((sect->flags & SECTION_TYPE) == S_NON_LAZY_SYMBOL_POINTERS) {
                    _FSEventsFixHookUpdateSection(sect, slide, symtab, strtab, indirect_symtab);
                }
            }
        }
    }
}

static void _FSEventsFixHookSaveOriginals() {
    for (rebinding_t *cur = g_rebindings, *end = g_rebindings + g_rebindings_nel; cur < end; ++cur)  {
        void *original = cur->original = dlsym(RTLD_DEFAULT, cur->name+1);
        if (!original) {
            const char *error = dlerror();
            _FSEventsFixLog(FSEventsFixMessageTypeFatalError, "Cannot find symbol %s, dlsym says: %s\n", cur->name, error);
        }
    }
}

static void _FSEventsFixHookUpdate() {
    uint32_t c = _dyld_image_count();
    for (uint32_t i = 0; i < c; i++) {
        _FSEventsFixHookUpdateImage(_dyld_get_image_header(i), _dyld_get_image_vmaddr_slide(i));
    }
}

static void _FSEventsFixHookInstall() {
    static bool first_rebinding_done = false;

    if (!g_hook_installed) {
        g_hook_installed = true;

        if (!first_rebinding_done) {
            first_rebinding_done = true;
            _FSEventsFixHookSaveOriginals();
            _dyld_register_func_for_add_image(_FSEventsFixHookUpdateImage);
        } else {
            _FSEventsFixHookUpdate();
        }
    }
}

static void _FSEventsFixHookUninstall() {
    if (g_hook_installed) {
        g_hook_installed = false;
        _FSEventsFixHookUpdate();
    }
}