mocha: show actual file in Diff dialog (WEB-15907)
[idea/community.git] / native / fsNotifier / mac / fsnotifier.c
1 /*
2  * Copyright 2000-2014 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <CoreServices/CoreServices.h>
18 #include <pthread.h>
19 #include <stdio.h>
20 #include <strings.h>
21 #include <sys/mount.h>
22
23 #define PRIVATE_DIR "/private/"
24 #define PRIVATE_LEN 9
25
26 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
27 static bool report_private = true;
28
29 static void reportEvent(char *event, char *path) {
30     size_t len = 0;
31     if (path != NULL) {
32         len = strlen(path);
33         for (char* p = path; *p != '\0'; p++) {
34             if (*p == '\n') {
35                 *p = '\0';
36             }
37         }
38     }
39
40     pthread_mutex_lock(&lock);
41     if (path == NULL || report_private || strncasecmp(path, PRIVATE_DIR, PRIVATE_LEN) != 0) {
42         fputs(event, stdout);
43         fputc('\n', stdout);
44         if (path != NULL) {
45             fwrite(path, len, 1, stdout);
46             fputc('\n', stdout);
47         }
48         fflush(stdout);
49     }
50     pthread_mutex_unlock(&lock);
51 }
52
53 static void callback(ConstFSEventStreamRef streamRef,
54                      void *clientCallBackInfo,
55                      size_t numEvents,
56                      void *eventPaths,
57                      const FSEventStreamEventFlags eventFlags[],
58                      const FSEventStreamEventId eventIds[]) {
59     char **paths = eventPaths;
60
61     for (int i = 0; i < numEvents; i++) {
62         // TODO[max] Lion has much more detailed flags we need accurately process. For now just reduce to SL events range.
63         FSEventStreamEventFlags flags = eventFlags[i] & 0xFF;
64         if ((flags & kFSEventStreamEventFlagMustScanSubDirs) != 0) {
65             reportEvent("RECDIRTY", paths[i]);
66         }
67         else if (flags != kFSEventStreamEventFlagNone) {
68             reportEvent("RESET", NULL);
69         }
70         else {
71             reportEvent("DIRTY", paths[i]);
72         }
73     }
74 }
75
76 static void * EventProcessingThread(void *data) {
77     FSEventStreamRef stream = (FSEventStreamRef) data;
78     FSEventStreamScheduleWithRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
79     FSEventStreamStart(stream);
80     CFRunLoopRun();
81     return NULL;
82 }
83
84 static void PrintMountedFileSystems(CFArrayRef roots) {
85     int fsCount = getfsstat(NULL, 0, MNT_WAIT);
86     if (fsCount == -1) return;
87
88     struct statfs fs[fsCount];
89     fsCount = getfsstat(fs, (int)(sizeof(struct statfs) * fsCount), MNT_NOWAIT);
90     if (fsCount == -1) return;
91
92     CFMutableArrayRef mounts = CFArrayCreateMutable(NULL, 0, NULL);
93
94     for (int i = 0; i < fsCount; i++) {
95         if ((fs[i].f_flags & MNT_LOCAL) != MNT_LOCAL) {
96             char *mount = fs[i].f_mntonname;
97             size_t mountLen = strlen(mount);
98
99             for (int j = 0; j < CFArrayGetCount(roots); j++) {
100                 char *root = (char *)CFArrayGetValueAtIndex(roots, j);
101                 size_t rootLen = strlen(root);
102
103                 if (rootLen >= mountLen && strncmp(root, mount, mountLen) == 0) {
104                     // root under mount point
105                     if (rootLen == mountLen || root[mountLen] == '/' || strcmp(mount, "/") == 0) {
106                         CFArrayAppendValue(mounts, root);
107                     }
108                 }
109                 else if (strncmp(root, mount, rootLen) == 0) {
110                     // root over mount point
111                     if (strcmp(root, "/") == 0 || mount[rootLen] == '/') {
112                         CFArrayAppendValue(mounts, mount);
113                     }
114                 }
115             }
116         }
117     }
118
119     pthread_mutex_lock(&lock);
120     printf("UNWATCHEABLE\n");
121     for (int i = 0; i < CFArrayGetCount(mounts); i++) {
122         char *mount = (char *)CFArrayGetValueAtIndex(mounts, i);
123         printf("%s\n", mount);
124     }
125     printf("#\n");
126     fflush(stdout);
127     pthread_mutex_unlock(&lock);
128
129     CFRelease(mounts);
130 }
131
132 // Static buffer for fscanf. All of the are being performed from a single thread, so it's thread safe.
133 static char command[2048];
134
135 static void ParseRoots() {
136     CFMutableArrayRef roots = CFArrayCreateMutable(NULL, 0, NULL);
137     bool has_private_root = false;
138
139     while (TRUE) {
140         fscanf(stdin, "%s", command);
141         if (strcmp(command, "#") == 0 || feof(stdin)) break;
142         char* path = command[0] == '|' ? command + 1 : command;
143         CFArrayAppendValue(roots, strdup(path));
144         if (strcmp(path, "/") == 0 || strncasecmp(path, PRIVATE_DIR, PRIVATE_LEN) == 0) {
145             has_private_root = true;
146         }
147     }
148
149     pthread_mutex_lock(&lock);
150     report_private = has_private_root;
151     pthread_mutex_unlock(&lock);
152
153     PrintMountedFileSystems(roots);
154
155     for (int i = 0; i < CFArrayGetCount(roots); i++) {
156         void *value = (char *)CFArrayGetValueAtIndex(roots, i);
157         free(value);
158     }
159     CFRelease(roots);
160 }
161
162 int main(const int argc, const char* argv[]) {
163     // Checking if necessary API is available (need MacOS X 10.5 or later).
164     if (FSEventStreamCreate == NULL) {
165         printf("GIVEUP\n");
166         return 1;
167     }
168
169     CFStringRef path = CFSTR("/");
170     CFArrayRef pathsToWatch = CFArrayCreate(NULL, (const void **)&path, 1, NULL);
171     CFAbsoluteTime latency = 0.3;  // Latency in seconds
172     FSEventStreamRef stream = FSEventStreamCreate(
173         NULL,
174         &callback,
175         NULL,
176         pathsToWatch,
177         kFSEventStreamEventIdSinceNow,
178         latency,
179         kFSEventStreamCreateFlagNoDefer
180     );
181     if (stream == NULL) {
182         printf("GIVEUP\n");
183         return 2;
184     }
185
186     pthread_t threadId;
187     if (pthread_create(&threadId, NULL, EventProcessingThread, stream) != 0) {
188         printf("GIVEUP\n");
189         return 3;
190     }
191
192     while (TRUE) {
193         fscanf(stdin, "%s", command);
194         if (strcmp(command, "EXIT") == 0 || feof(stdin)) break;
195         if (strcmp(command, "ROOTS") == 0) ParseRoots();
196     }
197
198     return 0;
199 }