| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2006-2007 Red Hat, Inc. |
| * Copyright (C) 2015 Chun-wei Fan |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| * |
| * Author: Vlad Grecescu <b100dian@gmail.com> |
| * Author: Chun-wei Fan <fanc999@yahoo.com.tw> |
| * |
| */ |
| |
| #include "config.h" |
| |
| #include "gwin32fsmonitorutils.h" |
| #include "gio/gfile.h" |
| |
| #include <windows.h> |
| |
| #define MAX_PATH_LONG 32767 /* Support Paths longer than MAX_PATH (260) characters */ |
| |
| static gboolean |
| g_win32_fs_monitor_handle_event (GWin32FSMonitorPrivate *monitor, |
| const gchar *filename, |
| PFILE_NOTIFY_INFORMATION pfni) |
| { |
| GFileMonitorEvent fme; |
| PFILE_NOTIFY_INFORMATION pfni_next; |
| WIN32_FILE_ATTRIBUTE_DATA attrib_data = {0, }; |
| gchar *renamed_file = NULL; |
| |
| switch (pfni->Action) |
| { |
| case FILE_ACTION_ADDED: |
| fme = G_FILE_MONITOR_EVENT_CREATED; |
| break; |
| |
| case FILE_ACTION_REMOVED: |
| fme = G_FILE_MONITOR_EVENT_DELETED; |
| break; |
| |
| case FILE_ACTION_MODIFIED: |
| { |
| gboolean success_attribs = GetFileAttributesExW (monitor->wfullpath_with_long_prefix, |
| GetFileExInfoStandard, |
| &attrib_data); |
| |
| if (monitor->file_attribs != INVALID_FILE_ATTRIBUTES && |
| success_attribs && |
| attrib_data.dwFileAttributes != monitor->file_attribs) |
| fme = G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED; |
| else |
| fme = G_FILE_MONITOR_EVENT_CHANGED; |
| |
| monitor->file_attribs = attrib_data.dwFileAttributes; |
| } |
| break; |
| |
| case FILE_ACTION_RENAMED_OLD_NAME: |
| if (pfni->NextEntryOffset != 0) |
| { |
| /* If the file was renamed in the same directory, we would get a |
| * FILE_ACTION_RENAMED_NEW_NAME action in the next FILE_NOTIFY_INFORMATION |
| * structure. |
| */ |
| glong file_name_len = 0; |
| |
| pfni_next = (PFILE_NOTIFY_INFORMATION) ((BYTE*)pfni + pfni->NextEntryOffset); |
| renamed_file = g_utf16_to_utf8 (pfni_next->FileName, pfni_next->FileNameLength / sizeof(WCHAR), NULL, &file_name_len, NULL); |
| if (pfni_next->Action == FILE_ACTION_RENAMED_NEW_NAME) |
| fme = G_FILE_MONITOR_EVENT_RENAMED; |
| else |
| fme = G_FILE_MONITOR_EVENT_MOVED_OUT; |
| } |
| else |
| fme = G_FILE_MONITOR_EVENT_MOVED_OUT; |
| break; |
| |
| case FILE_ACTION_RENAMED_NEW_NAME: |
| if (monitor->pfni_prev != NULL && |
| monitor->pfni_prev->Action == FILE_ACTION_RENAMED_OLD_NAME) |
| { |
| /* don't bother sending events, was already sent (rename) */ |
| fme = -1; |
| } |
| else |
| fme = G_FILE_MONITOR_EVENT_MOVED_IN; |
| break; |
| |
| default: |
| /* The possible Windows actions are all above, so shouldn't get here */ |
| g_assert_not_reached (); |
| break; |
| } |
| |
| if (fme != -1) |
| return g_file_monitor_source_handle_event (monitor->fms, |
| fme, |
| filename, |
| renamed_file, |
| NULL, |
| g_get_monotonic_time ()); |
| else |
| return FALSE; |
| } |
| |
| |
| static void CALLBACK |
| g_win32_fs_monitor_callback (DWORD error, |
| DWORD nBytes, |
| LPOVERLAPPED lpOverlapped) |
| { |
| gulong offset; |
| PFILE_NOTIFY_INFORMATION pfile_notify_walker; |
| GWin32FSMonitorPrivate *monitor = (GWin32FSMonitorPrivate *) lpOverlapped; |
| |
| DWORD notify_filter = monitor->isfile ? |
| (FILE_NOTIFY_CHANGE_FILE_NAME | |
| FILE_NOTIFY_CHANGE_ATTRIBUTES | |
| FILE_NOTIFY_CHANGE_SIZE) : |
| (FILE_NOTIFY_CHANGE_FILE_NAME | |
| FILE_NOTIFY_CHANGE_DIR_NAME | |
| FILE_NOTIFY_CHANGE_ATTRIBUTES | |
| FILE_NOTIFY_CHANGE_SIZE); |
| |
| /* If monitor->self is NULL the GWin32FileMonitor object has been destroyed. */ |
| if (monitor->self == NULL || |
| g_file_monitor_is_cancelled (monitor->self) || |
| monitor->file_notify_buffer == NULL) |
| { |
| g_free (monitor->file_notify_buffer); |
| g_free (monitor); |
| return; |
| } |
| |
| offset = 0; |
| |
| do |
| { |
| pfile_notify_walker = (PFILE_NOTIFY_INFORMATION)((BYTE *)monitor->file_notify_buffer + offset); |
| if (pfile_notify_walker->Action > 0) |
| { |
| glong file_name_len; |
| gchar *changed_file; |
| |
| changed_file = g_utf16_to_utf8 (pfile_notify_walker->FileName, |
| pfile_notify_walker->FileNameLength / sizeof(WCHAR), |
| NULL, &file_name_len, NULL); |
| |
| if (monitor->isfile) |
| { |
| gint long_filename_length = wcslen (monitor->wfilename_long); |
| gint short_filename_length = wcslen (monitor->wfilename_short); |
| enum GWin32FileMonitorFileAlias alias_state; |
| |
| /* If monitoring a file, check that the changed file |
| * in the directory matches the file that is to be monitored |
| * We need to check both the long and short file names for the same file. |
| * |
| * We need to send in the name of the monitored file, not its long (or short) variant, |
| * if they exist. |
| */ |
| |
| if (_wcsnicmp (pfile_notify_walker->FileName, |
| monitor->wfilename_long, |
| long_filename_length) == 0) |
| { |
| if (_wcsnicmp (pfile_notify_walker->FileName, |
| monitor->wfilename_short, |
| short_filename_length) == 0) |
| { |
| alias_state = G_WIN32_FILE_MONITOR_NO_ALIAS; |
| } |
| else |
| alias_state = G_WIN32_FILE_MONITOR_LONG_FILENAME; |
| } |
| else if (_wcsnicmp (pfile_notify_walker->FileName, |
| monitor->wfilename_short, |
| short_filename_length) == 0) |
| { |
| alias_state = G_WIN32_FILE_MONITOR_SHORT_FILENAME; |
| } |
| else |
| alias_state = G_WIN32_FILE_MONITOR_NO_MATCH_FOUND; |
| |
| if (alias_state != G_WIN32_FILE_MONITOR_NO_MATCH_FOUND) |
| { |
| wchar_t *monitored_file_w; |
| gchar *monitored_file; |
| |
| switch (alias_state) |
| { |
| case G_WIN32_FILE_MONITOR_NO_ALIAS: |
| monitored_file = g_strdup (changed_file); |
| break; |
| case G_WIN32_FILE_MONITOR_LONG_FILENAME: |
| case G_WIN32_FILE_MONITOR_SHORT_FILENAME: |
| monitored_file_w = wcsrchr (monitor->wfullpath_with_long_prefix, L'\\'); |
| monitored_file = g_utf16_to_utf8 (monitored_file_w + 1, -1, NULL, NULL, NULL); |
| break; |
| default: |
| g_assert_not_reached (); |
| break; |
| } |
| |
| g_win32_fs_monitor_handle_event (monitor, monitored_file, pfile_notify_walker); |
| g_free (monitored_file); |
| } |
| } |
| else |
| g_win32_fs_monitor_handle_event (monitor, changed_file, pfile_notify_walker); |
| |
| g_free (changed_file); |
| } |
| |
| monitor->pfni_prev = pfile_notify_walker; |
| offset += pfile_notify_walker->NextEntryOffset; |
| } |
| while (pfile_notify_walker->NextEntryOffset); |
| |
| ReadDirectoryChangesW (monitor->hDirectory, |
| monitor->file_notify_buffer, |
| monitor->buffer_allocated_bytes, |
| FALSE, |
| notify_filter, |
| &monitor->buffer_filled_bytes, |
| &monitor->overlapped, |
| g_win32_fs_monitor_callback); |
| } |
| |
| void |
| g_win32_fs_monitor_init (GWin32FSMonitorPrivate *monitor, |
| const gchar *dirname, |
| const gchar *filename, |
| gboolean isfile) |
| { |
| wchar_t *wdirname_with_long_prefix = NULL; |
| const gchar LONGPFX[] = "\\\\?\\"; |
| gchar *fullpath_with_long_prefix, *dirname_with_long_prefix; |
| DWORD notify_filter = isfile ? |
| (FILE_NOTIFY_CHANGE_FILE_NAME | |
| FILE_NOTIFY_CHANGE_ATTRIBUTES | |
| FILE_NOTIFY_CHANGE_SIZE) : |
| (FILE_NOTIFY_CHANGE_FILE_NAME | |
| FILE_NOTIFY_CHANGE_DIR_NAME | |
| FILE_NOTIFY_CHANGE_ATTRIBUTES | |
| FILE_NOTIFY_CHANGE_SIZE); |
| |
| gboolean success_attribs; |
| WIN32_FILE_ATTRIBUTE_DATA attrib_data = {0, }; |
| |
| |
| if (dirname != NULL) |
| { |
| dirname_with_long_prefix = g_strconcat (LONGPFX, dirname, NULL); |
| wdirname_with_long_prefix = g_utf8_to_utf16 (dirname_with_long_prefix, -1, NULL, NULL, NULL); |
| |
| if (isfile) |
| { |
| gchar *fullpath; |
| wchar_t wlongname[MAX_PATH_LONG]; |
| wchar_t wshortname[MAX_PATH_LONG]; |
| wchar_t *wfullpath, *wbasename_long, *wbasename_short; |
| |
| fullpath = g_build_filename (dirname, filename, NULL); |
| fullpath_with_long_prefix = g_strconcat (LONGPFX, fullpath, NULL); |
| |
| wfullpath = g_utf8_to_utf16 (fullpath, -1, NULL, NULL, NULL); |
| |
| monitor->wfullpath_with_long_prefix = |
| g_utf8_to_utf16 (fullpath_with_long_prefix, -1, NULL, NULL, NULL); |
| |
| /* ReadDirectoryChangesW() can return the normal filename or the |
| * "8.3" format filename, so we need to keep track of both these names |
| * so that we can check against them later when it returns |
| */ |
| if (GetLongPathNameW (monitor->wfullpath_with_long_prefix, wlongname, MAX_PATH_LONG) == 0) |
| { |
| wbasename_long = wcsrchr (monitor->wfullpath_with_long_prefix, L'\\'); |
| monitor->wfilename_long = wbasename_long != NULL ? |
| wcsdup (wbasename_long + 1) : |
| wcsdup (wfullpath); |
| } |
| else |
| { |
| wbasename_long = wcsrchr (wlongname, L'\\'); |
| monitor->wfilename_long = wbasename_long != NULL ? |
| wcsdup (wbasename_long + 1) : |
| wcsdup (wlongname); |
| |
| } |
| |
| if (GetShortPathNameW (monitor->wfullpath_with_long_prefix, wshortname, MAX_PATH_LONG) == 0) |
| { |
| wbasename_short = wcsrchr (monitor->wfullpath_with_long_prefix, L'\\'); |
| monitor->wfilename_short = wbasename_short != NULL ? |
| wcsdup (wbasename_short + 1) : |
| wcsdup (wfullpath); |
| } |
| else |
| { |
| wbasename_short = wcsrchr (wshortname, L'\\'); |
| monitor->wfilename_short = wbasename_short != NULL ? |
| wcsdup (wbasename_short + 1) : |
| wcsdup (wshortname); |
| } |
| |
| g_free (fullpath); |
| } |
| else |
| { |
| monitor->wfilename_short = NULL; |
| monitor->wfilename_long = NULL; |
| monitor->wfullpath_with_long_prefix = g_utf8_to_utf16 (dirname_with_long_prefix, -1, NULL, NULL, NULL); |
| } |
| |
| monitor->isfile = isfile; |
| } |
| else |
| { |
| dirname_with_long_prefix = g_strconcat (LONGPFX, filename, NULL); |
| monitor->wfullpath_with_long_prefix = g_utf8_to_utf16 (dirname_with_long_prefix, -1, NULL, NULL, NULL); |
| monitor->wfilename_long = NULL; |
| monitor->wfilename_short = NULL; |
| monitor->isfile = FALSE; |
| } |
| |
| success_attribs = GetFileAttributesExW (monitor->wfullpath_with_long_prefix, |
| GetFileExInfoStandard, |
| &attrib_data); |
| if (success_attribs) |
| monitor->file_attribs = attrib_data.dwFileAttributes; /* Store up original attributes */ |
| else |
| monitor->file_attribs = INVALID_FILE_ATTRIBUTES; |
| monitor->pfni_prev = NULL; |
| monitor->hDirectory = CreateFileW (wdirname_with_long_prefix != NULL ? wdirname_with_long_prefix : monitor->wfullpath_with_long_prefix, |
| FILE_GENERIC_READ | FILE_GENERIC_WRITE, |
| FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, |
| NULL, |
| OPEN_EXISTING, |
| FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, |
| NULL); |
| |
| g_free (wdirname_with_long_prefix); |
| g_free (dirname_with_long_prefix); |
| |
| if (monitor->hDirectory != INVALID_HANDLE_VALUE) |
| { |
| ReadDirectoryChangesW (monitor->hDirectory, |
| monitor->file_notify_buffer, |
| monitor->buffer_allocated_bytes, |
| FALSE, |
| notify_filter, |
| &monitor->buffer_filled_bytes, |
| &monitor->overlapped, |
| g_win32_fs_monitor_callback); |
| } |
| } |
| |
| GWin32FSMonitorPrivate * |
| g_win32_fs_monitor_create (gboolean isfile) |
| { |
| GWin32FSMonitorPrivate *monitor = g_new0 (GWin32FSMonitorPrivate, 1); |
| |
| monitor->buffer_allocated_bytes = 32784; |
| monitor->file_notify_buffer = g_new0 (FILE_NOTIFY_INFORMATION, monitor->buffer_allocated_bytes); |
| |
| return monitor; |
| } |
| |
| void |
| g_win32_fs_monitor_finalize (GWin32FSMonitorPrivate *monitor) |
| { |
| g_free (monitor->wfullpath_with_long_prefix); |
| g_free (monitor->wfilename_long); |
| g_free (monitor->wfilename_short); |
| |
| if (monitor->hDirectory == INVALID_HANDLE_VALUE) |
| { |
| /* If we don't have a directory handle we can free |
| * monitor->file_notify_buffer and monitor here. The |
| * callback won't be called obviously any more (and presumably |
| * never has been called). |
| */ |
| g_free (monitor->file_notify_buffer); |
| monitor->file_notify_buffer = NULL; |
| g_free (monitor); |
| } |
| else |
| { |
| /* If we have a directory handle, the OVERLAPPED struct is |
| * passed once more to the callback as a result of the |
| * CloseHandle() done in the cancel method, so monitor has to |
| * be kept around. The GWin32DirectoryMonitor object is |
| * disappearing, so can't leave a pointer to it in |
| * monitor->self. |
| */ |
| monitor->self = NULL; |
| } |
| } |
| |
| void |
| g_win32_fs_monitor_close_handle (GWin32FSMonitorPrivate *monitor) |
| { |
| /* This triggers a last callback() with nBytes==0. */ |
| |
| /* Actually I am not so sure about that, it seems to trigger a last |
| * callback allright, but the way to recognize that it is the final |
| * one is not to check for nBytes==0, I think that was a |
| * misunderstanding. |
| */ |
| if (monitor->hDirectory != INVALID_HANDLE_VALUE) |
| CloseHandle (monitor->hDirectory); |
| } |
