xref: /libuv/src/win/fs-event.c (revision badecdca)
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2  *
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to
5  * deal in the Software without restriction, including without limitation the
6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7  * sell copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  *
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19  * IN THE SOFTWARE.
20  */
21 
22 #include <assert.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <string.h>
26 
27 #include "uv.h"
28 #include "internal.h"
29 #include "handle-inl.h"
30 #include "req-inl.h"
31 
32 
33 const unsigned int uv_directory_watcher_buffer_size = 4096;
34 
35 
uv__fs_event_queue_readdirchanges(uv_loop_t * loop,uv_fs_event_t * handle)36 static void uv__fs_event_queue_readdirchanges(uv_loop_t* loop,
37     uv_fs_event_t* handle) {
38   assert(handle->dir_handle != INVALID_HANDLE_VALUE);
39   assert(!handle->req_pending);
40 
41   memset(&(handle->req.u.io.overlapped), 0,
42          sizeof(handle->req.u.io.overlapped));
43   if (!ReadDirectoryChangesW(handle->dir_handle,
44                              handle->buffer,
45                              uv_directory_watcher_buffer_size,
46                              (handle->flags & UV_FS_EVENT_RECURSIVE) ? TRUE : FALSE,
47                              FILE_NOTIFY_CHANGE_FILE_NAME      |
48                                FILE_NOTIFY_CHANGE_DIR_NAME     |
49                                FILE_NOTIFY_CHANGE_ATTRIBUTES   |
50                                FILE_NOTIFY_CHANGE_SIZE         |
51                                FILE_NOTIFY_CHANGE_LAST_WRITE   |
52                                FILE_NOTIFY_CHANGE_LAST_ACCESS  |
53                                FILE_NOTIFY_CHANGE_CREATION     |
54                                FILE_NOTIFY_CHANGE_SECURITY,
55                              NULL,
56                              &handle->req.u.io.overlapped,
57                              NULL)) {
58     /* Make this req pending reporting an error. */
59     SET_REQ_ERROR(&handle->req, GetLastError());
60     uv__insert_pending_req(loop, (uv_req_t*)&handle->req);
61   }
62 
63   handle->req_pending = 1;
64 }
65 
uv__relative_path(const WCHAR * filename,const WCHAR * dir,WCHAR ** relpath)66 static void uv__relative_path(const WCHAR* filename,
67                               const WCHAR* dir,
68                               WCHAR** relpath) {
69   size_t relpathlen;
70   size_t filenamelen = wcslen(filename);
71   size_t dirlen = wcslen(dir);
72   assert(!_wcsnicmp(filename, dir, dirlen));
73   if (dirlen > 0 && dir[dirlen - 1] == '\\')
74     dirlen--;
75   relpathlen = filenamelen - dirlen - 1;
76   *relpath = uv__malloc((relpathlen + 1) * sizeof(WCHAR));
77   if (!*relpath)
78     uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
79   wcsncpy(*relpath, filename + dirlen + 1, relpathlen);
80   (*relpath)[relpathlen] = L'\0';
81 }
82 
uv__split_path(const WCHAR * filename,WCHAR ** dir,WCHAR ** file)83 static int uv__split_path(const WCHAR* filename, WCHAR** dir,
84     WCHAR** file) {
85   size_t len, i;
86   DWORD dir_len;
87 
88   if (filename == NULL) {
89     if (dir != NULL)
90       *dir = NULL;
91     *file = NULL;
92     return 0;
93   }
94 
95   len = wcslen(filename);
96   i = len;
97   while (i > 0 && filename[--i] != '\\' && filename[i] != '/');
98 
99   if (i == 0) {
100     if (dir) {
101       dir_len = GetCurrentDirectoryW(0, NULL);
102       if (dir_len == 0) {
103         return -1;
104       }
105       *dir = (WCHAR*)uv__malloc(dir_len * sizeof(WCHAR));
106       if (!*dir) {
107         uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
108       }
109 
110       if (!GetCurrentDirectoryW(dir_len, *dir)) {
111         uv__free(*dir);
112         *dir = NULL;
113         return -1;
114       }
115     }
116 
117     *file = _wcsdup(filename);
118   } else {
119     if (dir) {
120       *dir = (WCHAR*)uv__malloc((i + 2) * sizeof(WCHAR));
121       if (!*dir) {
122         uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
123       }
124       wcsncpy(*dir, filename, i + 1);
125       (*dir)[i + 1] = L'\0';
126     }
127 
128     *file = (WCHAR*)uv__malloc((len - i) * sizeof(WCHAR));
129     if (!*file) {
130       uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
131     }
132     wcsncpy(*file, filename + i + 1, len - i - 1);
133     (*file)[len - i - 1] = L'\0';
134   }
135 
136   return 0;
137 }
138 
139 
uv_fs_event_init(uv_loop_t * loop,uv_fs_event_t * handle)140 int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
141   uv__handle_init(loop, (uv_handle_t*) handle, UV_FS_EVENT);
142   handle->dir_handle = INVALID_HANDLE_VALUE;
143   handle->buffer = NULL;
144   handle->req_pending = 0;
145   handle->filew = NULL;
146   handle->short_filew = NULL;
147   handle->dirw = NULL;
148 
149   UV_REQ_INIT(&handle->req, UV_FS_EVENT_REQ);
150   handle->req.data = handle;
151 
152   return 0;
153 }
154 
155 
uv_fs_event_start(uv_fs_event_t * handle,uv_fs_event_cb cb,const char * path,unsigned int flags)156 int uv_fs_event_start(uv_fs_event_t* handle,
157                       uv_fs_event_cb cb,
158                       const char* path,
159                       unsigned int flags) {
160   int is_path_dir;
161   size_t size;
162   DWORD attr, last_error;
163   WCHAR* dir = NULL, *dir_to_watch, *pathw = NULL;
164   DWORD short_path_buffer_len;
165   WCHAR *short_path_buffer;
166   WCHAR* short_path, *long_path;
167 
168   short_path = NULL;
169   if (uv__is_active(handle))
170     return UV_EINVAL;
171 
172   handle->cb = cb;
173   handle->path = uv__strdup(path);
174   if (!handle->path) {
175     uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
176   }
177 
178   uv__handle_start(handle);
179 
180   last_error = uv__convert_utf8_to_utf16(path, &pathw);
181   if (last_error)
182     goto error_uv;
183 
184   /* Determine whether path is a file or a directory. */
185   attr = GetFileAttributesW(pathw);
186   if (attr == INVALID_FILE_ATTRIBUTES) {
187     last_error = GetLastError();
188     goto error;
189   }
190 
191   is_path_dir = (attr & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
192 
193   if (is_path_dir) {
194      /* path is a directory, so that's the directory that we will watch. */
195 
196     /* Convert to long path. */
197     size = GetLongPathNameW(pathw, NULL, 0);
198 
199     if (size) {
200       long_path = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
201       if (!long_path) {
202         uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
203       }
204 
205       size = GetLongPathNameW(pathw, long_path, size);
206       if (size) {
207         long_path[size] = '\0';
208       } else {
209         uv__free(long_path);
210         long_path = NULL;
211       }
212 
213       if (long_path) {
214         uv__free(pathw);
215         pathw = long_path;
216       }
217     }
218 
219     dir_to_watch = pathw;
220   } else {
221     /*
222      * path is a file.  So we split path into dir & file parts, and
223      * watch the dir directory.
224      */
225 
226     /* Convert to short path. */
227     short_path_buffer = NULL;
228     short_path_buffer_len = GetShortPathNameW(pathw, NULL, 0);
229     if (short_path_buffer_len == 0) {
230       goto short_path_done;
231     }
232     short_path_buffer = uv__malloc(short_path_buffer_len * sizeof(WCHAR));
233     if (short_path_buffer == NULL) {
234       goto short_path_done;
235     }
236     if (GetShortPathNameW(pathw,
237                           short_path_buffer,
238                           short_path_buffer_len) == 0) {
239       uv__free(short_path_buffer);
240       short_path_buffer = NULL;
241     }
242 short_path_done:
243     short_path = short_path_buffer;
244 
245     if (uv__split_path(pathw, &dir, &handle->filew) != 0) {
246       last_error = GetLastError();
247       goto error;
248     }
249 
250     if (uv__split_path(short_path, NULL, &handle->short_filew) != 0) {
251       last_error = GetLastError();
252       goto error;
253     }
254 
255     dir_to_watch = dir;
256     uv__free(pathw);
257     pathw = NULL;
258   }
259 
260   handle->dir_handle = CreateFileW(dir_to_watch,
261                                    FILE_LIST_DIRECTORY,
262                                    FILE_SHARE_READ | FILE_SHARE_DELETE |
263                                      FILE_SHARE_WRITE,
264                                    NULL,
265                                    OPEN_EXISTING,
266                                    FILE_FLAG_BACKUP_SEMANTICS |
267                                      FILE_FLAG_OVERLAPPED,
268                                    NULL);
269 
270   if (dir) {
271     uv__free(dir);
272     dir = NULL;
273   }
274 
275   if (handle->dir_handle == INVALID_HANDLE_VALUE) {
276     last_error = GetLastError();
277     goto error;
278   }
279 
280   if (CreateIoCompletionPort(handle->dir_handle,
281                              handle->loop->iocp,
282                              (ULONG_PTR)handle,
283                              0) == NULL) {
284     last_error = GetLastError();
285     goto error;
286   }
287 
288   if (!handle->buffer) {
289     handle->buffer = (char*)uv__malloc(uv_directory_watcher_buffer_size);
290   }
291   if (!handle->buffer) {
292     uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
293   }
294 
295   memset(&(handle->req.u.io.overlapped), 0,
296          sizeof(handle->req.u.io.overlapped));
297 
298   if (!ReadDirectoryChangesW(handle->dir_handle,
299                              handle->buffer,
300                              uv_directory_watcher_buffer_size,
301                              (flags & UV_FS_EVENT_RECURSIVE) ? TRUE : FALSE,
302                              FILE_NOTIFY_CHANGE_FILE_NAME      |
303                                FILE_NOTIFY_CHANGE_DIR_NAME     |
304                                FILE_NOTIFY_CHANGE_ATTRIBUTES   |
305                                FILE_NOTIFY_CHANGE_SIZE         |
306                                FILE_NOTIFY_CHANGE_LAST_WRITE   |
307                                FILE_NOTIFY_CHANGE_LAST_ACCESS  |
308                                FILE_NOTIFY_CHANGE_CREATION     |
309                                FILE_NOTIFY_CHANGE_SECURITY,
310                              NULL,
311                              &handle->req.u.io.overlapped,
312                              NULL)) {
313     last_error = GetLastError();
314     goto error;
315   }
316 
317   assert(is_path_dir ? pathw != NULL : pathw == NULL);
318   handle->dirw = pathw;
319   handle->req_pending = 1;
320   return 0;
321 
322 error:
323   last_error = uv_translate_sys_error(last_error);
324 
325 error_uv:
326   if (handle->path) {
327     uv__free(handle->path);
328     handle->path = NULL;
329   }
330 
331   if (handle->filew) {
332     uv__free(handle->filew);
333     handle->filew = NULL;
334   }
335 
336   if (handle->short_filew) {
337     uv__free(handle->short_filew);
338     handle->short_filew = NULL;
339   }
340 
341   uv__free(pathw);
342 
343   if (handle->dir_handle != INVALID_HANDLE_VALUE) {
344     CloseHandle(handle->dir_handle);
345     handle->dir_handle = INVALID_HANDLE_VALUE;
346   }
347 
348   if (handle->buffer) {
349     uv__free(handle->buffer);
350     handle->buffer = NULL;
351   }
352 
353   if (uv__is_active(handle))
354     uv__handle_stop(handle);
355 
356   uv__free(short_path);
357 
358   return last_error;
359 }
360 
361 
uv_fs_event_stop(uv_fs_event_t * handle)362 int uv_fs_event_stop(uv_fs_event_t* handle) {
363   if (!uv__is_active(handle))
364     return 0;
365 
366   if (handle->dir_handle != INVALID_HANDLE_VALUE) {
367     CloseHandle(handle->dir_handle);
368     handle->dir_handle = INVALID_HANDLE_VALUE;
369   }
370 
371   uv__handle_stop(handle);
372 
373   if (handle->filew) {
374     uv__free(handle->filew);
375     handle->filew = NULL;
376   }
377 
378   if (handle->short_filew) {
379     uv__free(handle->short_filew);
380     handle->short_filew = NULL;
381   }
382 
383   if (handle->path) {
384     uv__free(handle->path);
385     handle->path = NULL;
386   }
387 
388   if (handle->dirw) {
389     uv__free(handle->dirw);
390     handle->dirw = NULL;
391   }
392 
393   return 0;
394 }
395 
396 
file_info_cmp(WCHAR * str,WCHAR * file_name,size_t file_name_len)397 static int file_info_cmp(WCHAR* str, WCHAR* file_name, size_t file_name_len) {
398   size_t str_len;
399 
400   if (str == NULL)
401     return -1;
402 
403   str_len = wcslen(str);
404 
405   /*
406     Since we only care about equality, return early if the strings
407     aren't the same length
408   */
409   if (str_len != (file_name_len / sizeof(WCHAR)))
410     return -1;
411 
412   return _wcsnicmp(str, file_name, str_len);
413 }
414 
415 
uv__process_fs_event_req(uv_loop_t * loop,uv_req_t * req,uv_fs_event_t * handle)416 void uv__process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
417     uv_fs_event_t* handle) {
418   FILE_NOTIFY_INFORMATION* file_info;
419   int err, sizew, size;
420   char* filename = NULL;
421   WCHAR* filenamew = NULL;
422   WCHAR* long_filenamew = NULL;
423   DWORD offset = 0;
424 
425   assert(req->type == UV_FS_EVENT_REQ);
426   assert(handle->req_pending);
427   handle->req_pending = 0;
428 
429   /* Don't report any callbacks if:
430    * - We're closing, just push the handle onto the endgame queue
431    * - We are not active, just ignore the callback
432    */
433   if (!uv__is_active(handle)) {
434     if (handle->flags & UV_HANDLE_CLOSING) {
435       uv__want_endgame(loop, (uv_handle_t*) handle);
436     }
437     return;
438   }
439 
440   file_info = (FILE_NOTIFY_INFORMATION*)(handle->buffer + offset);
441 
442   if (REQ_SUCCESS(req)) {
443     if (req->u.io.overlapped.InternalHigh > 0) {
444       do {
445         file_info = (FILE_NOTIFY_INFORMATION*)((char*)file_info + offset);
446         assert(!filename);
447         assert(!filenamew);
448         assert(!long_filenamew);
449 
450         /*
451          * Fire the event only if we were asked to watch a directory,
452          * or if the filename filter matches.
453          */
454         if (handle->dirw ||
455             file_info_cmp(handle->filew,
456                           file_info->FileName,
457                           file_info->FileNameLength) == 0 ||
458             file_info_cmp(handle->short_filew,
459                           file_info->FileName,
460                           file_info->FileNameLength) == 0) {
461 
462           if (handle->dirw) {
463             /*
464              * We attempt to resolve the long form of the file name explicitly.
465              * We only do this for file names that might still exist on disk.
466              * If this fails, we use the name given by ReadDirectoryChangesW.
467              * This may be the long form or the 8.3 short name in some cases.
468              */
469             if (file_info->Action != FILE_ACTION_REMOVED &&
470               file_info->Action != FILE_ACTION_RENAMED_OLD_NAME) {
471               /* Construct a full path to the file. */
472               size = wcslen(handle->dirw) +
473                 file_info->FileNameLength / sizeof(WCHAR) + 2;
474 
475               filenamew = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
476               if (!filenamew) {
477                 uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
478               }
479 
480               _snwprintf(filenamew, size, L"%s\\%.*s", handle->dirw,
481                 file_info->FileNameLength / (DWORD)sizeof(WCHAR),
482                 file_info->FileName);
483 
484               filenamew[size - 1] = L'\0';
485 
486               /* Convert to long name. */
487               size = GetLongPathNameW(filenamew, NULL, 0);
488 
489               if (size) {
490                 long_filenamew = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
491                 if (!long_filenamew) {
492                   uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
493                 }
494 
495                 size = GetLongPathNameW(filenamew, long_filenamew, size);
496                 if (size) {
497                   long_filenamew[size] = '\0';
498                 } else {
499                   uv__free(long_filenamew);
500                   long_filenamew = NULL;
501                 }
502               }
503 
504               uv__free(filenamew);
505 
506               if (long_filenamew) {
507                 /* Get the file name out of the long path. */
508                 uv__relative_path(long_filenamew,
509                                   handle->dirw,
510                                   &filenamew);
511                 uv__free(long_filenamew);
512                 long_filenamew = filenamew;
513                 sizew = -1;
514               } else {
515                 /* We couldn't get the long filename, use the one reported. */
516                 filenamew = file_info->FileName;
517                 sizew = file_info->FileNameLength / sizeof(WCHAR);
518               }
519             } else {
520               /*
521                * Removed or renamed events cannot be resolved to the long form.
522                * We therefore use the name given by ReadDirectoryChangesW.
523                * This may be the long form or the 8.3 short name in some cases.
524                */
525               filenamew = file_info->FileName;
526               sizew = file_info->FileNameLength / sizeof(WCHAR);
527             }
528           } else {
529             /* We already have the long name of the file, so just use it. */
530             filenamew = handle->filew;
531             sizew = -1;
532           }
533 
534           /* Convert the filename to utf8. */
535           uv__convert_utf16_to_utf8(filenamew, sizew, &filename);
536 
537           switch (file_info->Action) {
538             case FILE_ACTION_ADDED:
539             case FILE_ACTION_REMOVED:
540             case FILE_ACTION_RENAMED_OLD_NAME:
541             case FILE_ACTION_RENAMED_NEW_NAME:
542               handle->cb(handle, filename, UV_RENAME, 0);
543               break;
544 
545             case FILE_ACTION_MODIFIED:
546               handle->cb(handle, filename, UV_CHANGE, 0);
547               break;
548           }
549 
550           uv__free(filename);
551           filename = NULL;
552           uv__free(long_filenamew);
553           long_filenamew = NULL;
554           filenamew = NULL;
555         }
556 
557         offset = file_info->NextEntryOffset;
558       } while (offset && !(handle->flags & UV_HANDLE_CLOSING));
559     } else {
560       handle->cb(handle, NULL, UV_CHANGE, 0);
561     }
562   } else {
563     err = GET_REQ_ERROR(req);
564     /*
565      * Check whether the ERROR_ACCESS_DENIED is caused by the watched directory
566      * being actually deleted (not an actual error) or a legit error. Retrieve
567      * FileStandardInfo to check whether the directory is pending deletion.
568      */
569     FILE_STANDARD_INFO info;
570     if (err == ERROR_ACCESS_DENIED &&
571         handle->dirw != NULL &&
572         GetFileInformationByHandleEx(handle->dir_handle,
573                                      FileStandardInfo,
574                                      &info,
575                                      sizeof(info)) &&
576         info.Directory &&
577         info.DeletePending) {
578       uv__convert_utf16_to_utf8(handle->dirw, -1, &filename);
579       handle->cb(handle, filename, UV_RENAME, 0);
580     } else {
581       handle->cb(handle, NULL, 0, uv_translate_sys_error(err));
582     }
583   }
584 
585   if (handle->flags & UV_HANDLE_CLOSING) {
586     uv__want_endgame(loop, (uv_handle_t*)handle);
587   } else if (uv__is_active(handle)) {
588     uv__fs_event_queue_readdirchanges(loop, handle);
589   }
590 }
591 
592 
uv__fs_event_close(uv_loop_t * loop,uv_fs_event_t * handle)593 void uv__fs_event_close(uv_loop_t* loop, uv_fs_event_t* handle) {
594   uv_fs_event_stop(handle);
595 
596   uv__handle_closing(handle);
597 
598   if (!handle->req_pending) {
599     uv__want_endgame(loop, (uv_handle_t*)handle);
600   }
601 
602 }
603 
604 
uv__fs_event_endgame(uv_loop_t * loop,uv_fs_event_t * handle)605 void uv__fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) {
606   if ((handle->flags & UV_HANDLE_CLOSING) && !handle->req_pending) {
607     assert(!(handle->flags & UV_HANDLE_CLOSED));
608 
609     if (handle->buffer) {
610       uv__free(handle->buffer);
611       handle->buffer = NULL;
612     }
613 
614     uv__handle_close(handle);
615   }
616 }
617