qiita_org 0.1.20 → 0.1.25

data/gems/ruby/2.7.0/gems/rb-fsevent-0.10.4/Rakefile

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace(:spec) do
+  desc "Run all specs on multiple ruby versions"
+  task(:portability) do
+    versions = %w[2.4.1 rbx-3.72 jruby-1.7.26 jruby-9.1.8.0]
+    versions.each do |version|
+      # system <<-BASH
+      #   bash -c 'source ~/.rvm/scripts/rvm;
+      #            rvm #{version};
+      #            echo "--------- version #{version} ----------\n";
+      #            bundle install;
+      #            rake spec'
+      # BASH
+      system <<-BASH
+        bash -c 'export PATH="$HOME/.rbenv/bin:$PATH";
+                 [[ `which rbenv` ]] && eval "$(rbenv init -)";
+                 [[ ! -a $HOME/.rbenv/versions/#{version} ]] && rbenv install #{version};
+                 rbenv shell #{version};
+                 rbenv which bundle 2> /dev/null || gem install bundler;
+                 rm Gemfile.lock;
+                 bundle install;
+                 rake spec;'
+      BASH
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/rb-fsevent-0.10.4/ext/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011-2013 Travis Tilley
+
+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.
+

data/gems/ruby/2.7.0/gems/rb-fsevent-0.10.4/ext/fsevent_watch/FSEventsFix.c

@@ -0,0 +1,626 @@
+/*
+ * 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();
+    }
+}