9d2a2ef983a3cd251dc5963650885f6e2a52a33f
[reactos.git] / reactos / dll / win32 / shell32 / wine / changenotify.c
1 /*
2 * shell change notification
3 *
4 * Copyright 2000 Juergen Schmied
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define WIN32_NO_STATUS
22 #define _INC_WINDOWS
23 #define COBJMACROS
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
26 #define BUFFER_SIZE 1024
27
28 #include <windef.h>
29 #include <winbase.h>
30 #include <shlobj.h>
31 #include <strsafe.h>
32 #include <undocshell.h>
33 #include <shlwapi.h>
34 #include <wine/debug.h>
35 #include <wine/list.h>
36 #include <process.h>
37
38 #include "pidl.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(shell);
41
42 static CRITICAL_SECTION SHELL32_ChangenotifyCS;
43 static CRITICAL_SECTION_DEBUG critsect_debug =
44 {
45 0, 0, &SHELL32_ChangenotifyCS,
46 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
47 0, 0, { (DWORD_PTR)(__FILE__ ": SHELL32_ChangenotifyCS") }
48 };
49 static CRITICAL_SECTION SHELL32_ChangenotifyCS = { &critsect_debug, -1, 0, 0, 0, 0 };
50
51 #ifdef __REACTOS__
52 typedef struct {
53 PCIDLIST_ABSOLUTE pidl;
54 BOOL fRecursive;
55 /* File system notification items */
56 HANDLE hDirectory; /* Directory handle */
57 WCHAR wstrDirectory[MAX_PATH]; /* Directory name */
58 OVERLAPPED overlapped; /* Overlapped structure */
59 BYTE *buffer; /* Async buffer to fill */
60 BYTE *backBuffer; /* Back buffer to swap buffer into */
61 } SHChangeNotifyEntryInternal, *LPNOTIFYREGISTER;
62 #else
63 typedef SHChangeNotifyEntry *LPNOTIFYREGISTER;
64 #endif
65
66 /* internal list of notification clients (internal) */
67 typedef struct _NOTIFICATIONLIST
68 {
69 struct list entry;
70 HWND hwnd; /* window to notify */
71 DWORD uMsg; /* message to send */
72 LPNOTIFYREGISTER apidl; /* array of entries to watch*/
73 UINT cidl; /* number of pidls in array */
74 LONG wEventMask; /* subscribed events */
75 DWORD dwFlags; /* client flags */
76 ULONG id;
77 } NOTIFICATIONLIST, *LPNOTIFICATIONLIST;
78
79 #ifdef __REACTOS__
80 VOID _ProcessNotification(LPNOTIFYREGISTER item);
81 BOOL _OpenDirectory(LPNOTIFYREGISTER item);
82 static void CALLBACK _RequestTermination(ULONG_PTR arg);
83 static void CALLBACK _RequestAllTermination(ULONG_PTR arg);
84 static void CALLBACK _AddDirectoryProc(ULONG_PTR arg);
85 static VOID _BeginRead(LPNOTIFYREGISTER item);
86 static unsigned int WINAPI _RunAsyncThreadProc(LPVOID arg);
87 #endif
88
89 static struct list notifications = LIST_INIT( notifications );
90 static LONG next_id;
91
92 #ifdef __REACTOS__
93 HANDLE m_hThread;
94 UINT m_dwThreadId;
95 BOOL m_bTerminate;
96 #endif
97
98 #define SHCNE_NOITEMEVENTS ( \
99 SHCNE_ASSOCCHANGED )
100
101 #define SHCNE_ONEITEMEVENTS ( \
102 SHCNE_ATTRIBUTES | SHCNE_CREATE | SHCNE_DELETE | SHCNE_DRIVEADD | \
103 SHCNE_DRIVEADDGUI | SHCNE_DRIVEREMOVED | SHCNE_FREESPACE | \
104 SHCNE_MEDIAINSERTED | SHCNE_MEDIAREMOVED | SHCNE_MKDIR | \
105 SHCNE_NETSHARE | SHCNE_NETUNSHARE | SHCNE_RMDIR | \
106 SHCNE_SERVERDISCONNECT | SHCNE_UPDATEDIR | SHCNE_UPDATEIMAGE )
107
108 #define SHCNE_TWOITEMEVENTS ( \
109 SHCNE_RENAMEFOLDER | SHCNE_RENAMEITEM | SHCNE_UPDATEITEM )
110
111 /* for dumping events */
112 static const char * DumpEvent( LONG event )
113 {
114 if( event == SHCNE_ALLEVENTS )
115 return "SHCNE_ALLEVENTS";
116 #define DUMPEV(x) ,( event & SHCNE_##x )? #x " " : ""
117 return wine_dbg_sprintf( "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
118 DUMPEV(RENAMEITEM)
119 DUMPEV(CREATE)
120 DUMPEV(DELETE)
121 DUMPEV(MKDIR)
122 DUMPEV(RMDIR)
123 DUMPEV(MEDIAINSERTED)
124 DUMPEV(MEDIAREMOVED)
125 DUMPEV(DRIVEREMOVED)
126 DUMPEV(DRIVEADD)
127 DUMPEV(NETSHARE)
128 DUMPEV(NETUNSHARE)
129 DUMPEV(ATTRIBUTES)
130 DUMPEV(UPDATEDIR)
131 DUMPEV(UPDATEITEM)
132 DUMPEV(SERVERDISCONNECT)
133 DUMPEV(UPDATEIMAGE)
134 DUMPEV(DRIVEADDGUI)
135 DUMPEV(RENAMEFOLDER)
136 DUMPEV(FREESPACE)
137 DUMPEV(EXTENDED_EVENT)
138 DUMPEV(ASSOCCHANGED)
139 DUMPEV(INTERRUPT)
140 );
141 #undef DUMPEV
142 }
143
144 static const char * NodeName(const NOTIFICATIONLIST *item)
145 {
146 const char *str;
147 WCHAR path[MAX_PATH];
148
149 if(SHGetPathFromIDListW(item->apidl[0].pidl, path ))
150 str = wine_dbg_sprintf("%s", debugstr_w(path));
151 else
152 str = wine_dbg_sprintf("<not a disk file>" );
153 return str;
154 }
155
156 static void DeleteNode(LPNOTIFICATIONLIST item)
157 {
158 UINT i;
159
160 TRACE("item=%p\n", item);
161
162 /* remove item from list */
163 list_remove( &item->entry );
164
165 /* free the item */
166 for (i=0; i<item->cidl; i++)
167 #ifdef __REACTOS__
168 {
169 QueueUserAPC(_RequestTermination, m_hThread, (ULONG_PTR) &item->apidl[i] );
170 WaitForSingleObjectEx(m_hThread, 100, FALSE);
171 #endif
172 SHFree((LPITEMIDLIST)item->apidl[i].pidl);
173 #ifdef __REACTOS__
174 SHFree(item->apidl[i].buffer);
175 SHFree(item->apidl[i].backBuffer);
176 }
177 #endif
178 SHFree(item->apidl);
179 SHFree(item);
180 }
181
182 void InitChangeNotifications(void)
183 {
184 #ifdef __REACTOS__
185 m_hThread = NULL;
186 #endif
187 }
188
189 void FreeChangeNotifications(void)
190 {
191 LPNOTIFICATIONLIST ptr, next;
192
193 TRACE("\n");
194
195 EnterCriticalSection(&SHELL32_ChangenotifyCS);
196
197 LIST_FOR_EACH_ENTRY_SAFE( ptr, next, &notifications, NOTIFICATIONLIST, entry )
198 DeleteNode( ptr );
199
200 LeaveCriticalSection(&SHELL32_ChangenotifyCS);
201
202 #ifdef __REACTOS__
203 QueueUserAPC(_RequestAllTermination, m_hThread, (ULONG_PTR) NULL );
204 #endif
205
206 DeleteCriticalSection(&SHELL32_ChangenotifyCS);
207 }
208
209 /*************************************************************************
210 * SHChangeNotifyRegister [SHELL32.2]
211 *
212 */
213 ULONG WINAPI
214 SHChangeNotifyRegister(
215 HWND hwnd,
216 int fSources,
217 LONG wEventMask,
218 UINT uMsg,
219 int cItems,
220 SHChangeNotifyEntry *lpItems)
221 {
222 LPNOTIFICATIONLIST item;
223 int i;
224
225 item = SHAlloc(sizeof(NOTIFICATIONLIST));
226
227 TRACE("(%p,0x%08x,0x%08x,0x%08x,%d,%p) item=%p\n",
228 hwnd, fSources, wEventMask, uMsg, cItems, lpItems, item);
229
230 #ifdef __REACTOS__
231 if (!m_hThread)
232 m_hThread = (HANDLE) _beginthreadex(NULL, 0, _RunAsyncThreadProc, NULL, 0, &m_dwThreadId);
233 #endif
234
235 item->cidl = cItems;
236 #ifdef __REACTOS__
237 item->apidl = SHAlloc(sizeof(SHChangeNotifyEntryInternal) * cItems);
238 #else
239 item->apidl = SHAlloc(sizeof(SHChangeNotifyEntry) * cItems);
240 #endif
241 for(i=0;i<cItems;i++)
242 {
243 #ifdef __REACTOS__
244 ZeroMemory(&item->apidl[i], sizeof(SHChangeNotifyEntryInternal));
245 #endif
246 item->apidl[i].pidl = ILClone(lpItems[i].pidl);
247 item->apidl[i].fRecursive = lpItems[i].fRecursive;
248 #ifdef __REACTOS__
249 item->apidl[i].buffer = SHAlloc(BUFFER_SIZE);
250 item->apidl[i].backBuffer = SHAlloc(BUFFER_SIZE);
251 item->apidl[i].overlapped.hEvent = &item->apidl[i];
252
253 if (fSources & SHCNRF_InterruptLevel && _OpenDirectory( &item->apidl[i] ))
254 QueueUserAPC(_AddDirectoryProc, m_hThread, (ULONG_PTR) &item->apidl[i] );
255 else ERR("_OpenDirectory Failed\n");
256 #endif
257 }
258 item->hwnd = hwnd;
259 item->uMsg = uMsg;
260 item->wEventMask = wEventMask;
261 item->dwFlags = fSources;
262 item->id = InterlockedIncrement( &next_id );
263
264 TRACE("new node: %s\n", NodeName( item ));
265
266 EnterCriticalSection(&SHELL32_ChangenotifyCS);
267
268 list_add_tail( &notifications, &item->entry );
269
270 LeaveCriticalSection(&SHELL32_ChangenotifyCS);
271
272 return item->id;
273 }
274
275 /*************************************************************************
276 * SHChangeNotifyDeregister [SHELL32.4]
277 */
278 BOOL WINAPI SHChangeNotifyDeregister(ULONG hNotify)
279 {
280 LPNOTIFICATIONLIST node;
281
282 TRACE("(0x%08x)\n", hNotify);
283
284 EnterCriticalSection(&SHELL32_ChangenotifyCS);
285
286 LIST_FOR_EACH_ENTRY( node, &notifications, NOTIFICATIONLIST, entry )
287 {
288 if (node->id == hNotify)
289 {
290 DeleteNode( node );
291 LeaveCriticalSection(&SHELL32_ChangenotifyCS);
292 return TRUE;
293 }
294 }
295 LeaveCriticalSection(&SHELL32_ChangenotifyCS);
296 return FALSE;
297 }
298
299 /*************************************************************************
300 * SHChangeNotifyUpdateEntryList [SHELL32.5]
301 */
302 BOOL WINAPI SHChangeNotifyUpdateEntryList(DWORD unknown1, DWORD unknown2,
303 DWORD unknown3, DWORD unknown4)
304 {
305 FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x)\n",
306 unknown1, unknown2, unknown3, unknown4);
307
308 return TRUE;
309 }
310
311 struct new_delivery_notification
312 {
313 LONG event;
314 DWORD pidl1_size;
315 DWORD pidl2_size;
316 LPITEMIDLIST pidls[2];
317 BYTE data[1];
318 };
319
320 static BOOL should_notify( LPCITEMIDLIST changed, LPCITEMIDLIST watched, BOOL sub )
321 {
322 TRACE("%p %p %d\n", changed, watched, sub );
323 if ( !watched )
324 return FALSE;
325 if (ILIsEqual( watched, changed ) )
326 return TRUE;
327 if( sub && ILIsParent( watched, changed, FALSE ) )
328 return TRUE;
329 return FALSE;
330 }
331
332 /*************************************************************************
333 * SHChangeNotify [SHELL32.@]
334 */
335 void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
336 {
337 struct notification_recipients {
338 struct list entry;
339 HWND hwnd;
340 DWORD msg;
341 DWORD flags;
342 } *cur, *next;
343
344 HANDLE shared_data = NULL;
345 LPITEMIDLIST Pidls[2];
346 LPNOTIFICATIONLIST ptr;
347 struct list recipients;
348
349 Pidls[0] = NULL;
350 Pidls[1] = NULL;
351
352 TRACE("(0x%08x,0x%08x,%p,%p)\n", wEventId, uFlags, dwItem1, dwItem2);
353
354 if(uFlags & ~(SHCNF_TYPE|SHCNF_FLUSH))
355 FIXME("ignoring unsupported flags: %x\n", uFlags);
356
357 if( ( wEventId & SHCNE_NOITEMEVENTS ) && ( dwItem1 || dwItem2 ) )
358 {
359 TRACE("dwItem1 and dwItem2 are not zero, but should be\n");
360 dwItem1 = 0;
361 dwItem2 = 0;
362 return;
363 }
364 else if( ( wEventId & SHCNE_ONEITEMEVENTS ) && dwItem2 )
365 {
366 TRACE("dwItem2 is not zero, but should be\n");
367 dwItem2 = 0;
368 return;
369 }
370
371 if( ( ( wEventId & SHCNE_NOITEMEVENTS ) &&
372 ( wEventId & ~SHCNE_NOITEMEVENTS ) ) ||
373 ( ( wEventId & SHCNE_ONEITEMEVENTS ) &&
374 ( wEventId & ~SHCNE_ONEITEMEVENTS ) ) ||
375 ( ( wEventId & SHCNE_TWOITEMEVENTS ) &&
376 ( wEventId & ~SHCNE_TWOITEMEVENTS ) ) )
377 {
378 WARN("mutually incompatible events listed\n");
379 return;
380 }
381
382 /* convert paths in IDLists*/
383 switch (uFlags & SHCNF_TYPE)
384 {
385 case SHCNF_PATHA:
386 if (dwItem1) Pidls[0] = SHSimpleIDListFromPathA(dwItem1); //FIXME
387 if (dwItem2) Pidls[1] = SHSimpleIDListFromPathA(dwItem2); //FIXME
388 break;
389 case SHCNF_PATHW:
390 if (dwItem1) Pidls[0] = SHSimpleIDListFromPathW(dwItem1);
391 if (dwItem2) Pidls[1] = SHSimpleIDListFromPathW(dwItem2);
392 #ifdef __REACTOS__
393 if (wEventId & (SHCNE_MKDIR | SHCNE_RMDIR | SHCNE_UPDATEDIR | SHCNE_RENAMEFOLDER))
394 {
395 /*
396 * The last items in the ID are currently files. So we chop off the last
397 * entry, and create a new one using a find data struct.
398 */
399 if (dwItem1 && Pidls[0]){
400 WIN32_FIND_DATAW wfd;
401 LPITEMIDLIST oldpidl, newpidl;
402 LPWSTR p = PathFindFileNameW((LPCWSTR)dwItem1);
403 ILRemoveLastID(Pidls[0]);
404 lstrcpynW(&wfd.cFileName[0], p, MAX_PATH);
405 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
406 newpidl = _ILCreateFromFindDataW(&wfd);
407 oldpidl = ILClone(Pidls[0]);
408 ILFree(Pidls[0]);
409 Pidls[0] = ILCombine(oldpidl, newpidl);
410 ILFree(newpidl);
411 ILFree(oldpidl);
412 }
413 if (dwItem2 && Pidls[1]){
414 WIN32_FIND_DATAW wfd;
415 LPITEMIDLIST oldpidl, newpidl;
416 LPWSTR p = PathFindFileNameW((LPCWSTR)dwItem2);
417 ILRemoveLastID(Pidls[1]);
418 lstrcpynW(&wfd.cFileName[0], p, MAX_PATH);
419 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
420 newpidl = _ILCreateFromFindDataW(&wfd);
421 oldpidl = ILClone(Pidls[0]);
422 ILFree(Pidls[1]);
423 Pidls[1] = ILCombine(oldpidl, newpidl);
424 ILFree(newpidl);
425 ILFree(oldpidl);
426 }
427 }
428 #endif
429 break;
430 case SHCNF_IDLIST:
431 Pidls[0] = ILClone(dwItem1);
432 Pidls[1] = ILClone(dwItem2);
433 break;
434 case SHCNF_PRINTERA:
435 case SHCNF_PRINTERW:
436 FIXME("SHChangeNotify with (uFlags & SHCNF_PRINTER)\n");
437 return;
438 case SHCNF_DWORD:
439 default:
440 FIXME("unknown type %08x\n", uFlags & SHCNF_TYPE);
441 return;
442 }
443
444 list_init(&recipients);
445 EnterCriticalSection(&SHELL32_ChangenotifyCS);
446 LIST_FOR_EACH_ENTRY( ptr, &notifications, NOTIFICATIONLIST, entry )
447 {
448 struct notification_recipients *item;
449 BOOL notify = FALSE;
450 DWORD i;
451
452 for( i=0; (i<ptr->cidl) && !notify ; i++ )
453 {
454 LPCITEMIDLIST pidl = ptr->apidl[i].pidl;
455 BOOL subtree = ptr->apidl[i].fRecursive;
456
457 if (wEventId & ptr->wEventMask)
458 {
459 if( !pidl ) /* all ? */
460 notify = TRUE;
461 else if( wEventId & SHCNE_NOITEMEVENTS )
462 notify = TRUE;
463 else if( wEventId & ( SHCNE_ONEITEMEVENTS | SHCNE_TWOITEMEVENTS ) )
464 notify = should_notify( Pidls[0], pidl, subtree );
465 else if( wEventId & SHCNE_TWOITEMEVENTS )
466 notify = should_notify( Pidls[1], pidl, subtree );
467 }
468 }
469
470 if( !notify )
471 continue;
472
473 item = SHAlloc(sizeof(struct notification_recipients));
474 if(!item) {
475 ERR("out of memory\n");
476 continue;
477 }
478
479 item->hwnd = ptr->hwnd;
480 item->msg = ptr->uMsg;
481 item->flags = ptr->dwFlags;
482 list_add_tail(&recipients, &item->entry);
483 }
484 LeaveCriticalSection(&SHELL32_ChangenotifyCS);
485
486 LIST_FOR_EACH_ENTRY_SAFE(cur, next, &recipients, struct notification_recipients, entry)
487 {
488 TRACE("notifying %p, event %s(%x)\n", cur->hwnd, DumpEvent(wEventId), wEventId);
489
490 if (cur->flags & SHCNRF_NewDelivery) {
491 if(!shared_data) {
492 struct new_delivery_notification *notification;
493 UINT size1 = ILGetSize(Pidls[0]), size2 = ILGetSize(Pidls[1]);
494 UINT offset = (size1+sizeof(int)-1)/sizeof(int)*sizeof(int);
495
496 notification = SHAlloc(sizeof(struct new_delivery_notification)+offset+size2);
497 if(!notification) {
498 ERR("out of memory\n");
499 } else {
500 notification->event = wEventId;
501 notification->pidl1_size = size1;
502 notification->pidl2_size = size2;
503 if(size1)
504 memcpy(notification->data, Pidls[0], size1);
505 if(size2)
506 memcpy(notification->data+offset, Pidls[1], size2);
507
508 shared_data = SHAllocShared(notification,
509 sizeof(struct new_delivery_notification)+size1+size2,
510 GetCurrentProcessId());
511 SHFree(notification);
512 }
513 }
514
515 if(shared_data)
516 SendMessageA(cur->hwnd, cur->msg, (WPARAM)shared_data, GetCurrentProcessId());
517 else
518 ERR("out of memory\n");
519 } else {
520 SendMessageA(cur->hwnd, cur->msg, (WPARAM)Pidls, wEventId);
521 }
522
523 list_remove(&cur->entry);
524 SHFree(cur);
525 }
526 SHFreeShared(shared_data, GetCurrentProcessId());
527 SHFree(Pidls[0]);
528 SHFree(Pidls[1]);
529
530 #ifndef __REACTOS__
531 if (wEventId & SHCNE_ASSOCCHANGED)
532 {
533 static const WCHAR args[] = {' ','-','a',0 };
534 TRACE("refreshing file type associations\n");
535 run_winemenubuilder( args );
536 }
537 #endif
538 }
539
540 /*************************************************************************
541 * NTSHChangeNotifyRegister [SHELL32.640]
542 * NOTES
543 * Idlist is an array of structures and Count specifies how many items in the array.
544 * count should always be one when calling SHChangeNotifyRegister, or
545 * SHChangeNotifyDeregister will not work properly.
546 */
547 EXTERN_C ULONG WINAPI NTSHChangeNotifyRegister(
548 HWND hwnd,
549 int fSources,
550 LONG fEvents,
551 UINT msg,
552 int count,
553 SHChangeNotifyEntry *idlist)
554 {
555 return SHChangeNotifyRegister(hwnd, fSources | SHCNRF_NewDelivery,
556 fEvents, msg, count, idlist);
557 }
558
559 /*************************************************************************
560 * SHChangeNotification_Lock [SHELL32.644]
561 */
562 HANDLE WINAPI SHChangeNotification_Lock(
563 HANDLE hChange,
564 DWORD dwProcessId,
565 LPITEMIDLIST **lppidls,
566 LPLONG lpwEventId)
567 {
568 struct new_delivery_notification *ndn;
569 UINT offset;
570
571 TRACE("%p %08x %p %p\n", hChange, dwProcessId, lppidls, lpwEventId);
572
573 ndn = SHLockShared(hChange, dwProcessId);
574 if(!ndn) {
575 WARN("SHLockShared failed\n");
576 return NULL;
577 }
578
579 if(lppidls) {
580 offset = (ndn->pidl1_size+sizeof(int)-1)/sizeof(int)*sizeof(int);
581 ndn->pidls[0] = ndn->pidl1_size ? (LPITEMIDLIST)ndn->data : NULL;
582 ndn->pidls[1] = ndn->pidl2_size ? (LPITEMIDLIST)(ndn->data+offset) : NULL;
583 *lppidls = ndn->pidls;
584 }
585
586 if(lpwEventId)
587 *lpwEventId = ndn->event;
588
589 return ndn;
590 }
591
592 /*************************************************************************
593 * SHChangeNotification_Unlock [SHELL32.645]
594 */
595 BOOL WINAPI SHChangeNotification_Unlock ( HANDLE hLock)
596 {
597 TRACE("%p\n", hLock);
598 return SHUnlockShared(hLock);
599 }
600
601 /*************************************************************************
602 * NTSHChangeNotifyDeregister [SHELL32.641]
603 */
604 DWORD WINAPI NTSHChangeNotifyDeregister(ULONG x1)
605 {
606 FIXME("(0x%08x):semi stub.\n",x1);
607
608 return SHChangeNotifyDeregister( x1 );
609 }
610
611 #ifdef __REACTOS__
612
613 static
614 void
615 CALLBACK
616 _AddDirectoryProc(ULONG_PTR arg)
617 {
618 LPNOTIFYREGISTER item = (LPNOTIFYREGISTER)arg;
619 _BeginRead(item);
620 }
621
622 BOOL _OpenDirectory(LPNOTIFYREGISTER item)
623 {
624 STRRET strFile;
625 IShellFolder *psfDesktop;
626 HRESULT hr;
627
628 // Makes function idempotent
629 if (item->hDirectory && !(item->hDirectory == INVALID_HANDLE_VALUE))
630 return TRUE;
631
632 hr = SHGetDesktopFolder(&psfDesktop);
633 if (!SUCCEEDED(hr))
634 return FALSE;
635
636 hr = IShellFolder_GetDisplayNameOf(psfDesktop, item->pidl, SHGDN_FORPARSING, &strFile);
637 IShellFolder_Release(psfDesktop);
638 if (!SUCCEEDED(hr))
639 return FALSE;
640
641 hr = StrRetToBufW(&strFile, NULL, item->wstrDirectory, _countof(item->wstrDirectory));
642 if (!SUCCEEDED(hr))
643 return FALSE;
644
645 TRACE("_OpenDirectory %s\n", debugstr_w(item->wstrDirectory));
646
647 item->hDirectory = CreateFileW(item->wstrDirectory, // pointer to the file name
648 GENERIC_READ | FILE_LIST_DIRECTORY, // access (read/write) mode
649 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, // share mode
650 NULL, // security descriptor
651 OPEN_EXISTING, // how to create
652 FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, // file attributes
653 NULL); // file with attributes to copy
654
655 if (item->hDirectory == INVALID_HANDLE_VALUE)
656 {
657 return FALSE;
658 }
659 return TRUE;
660 }
661
662 static void CALLBACK _RequestTermination(ULONG_PTR arg)
663 {
664 LPNOTIFYREGISTER item = (LPNOTIFYREGISTER) arg;
665 TRACE("_RequestTermination %p \n", item->hDirectory);
666 if (!item->hDirectory || item->hDirectory == INVALID_HANDLE_VALUE) return;
667
668 CancelIo(item->hDirectory);
669 CloseHandle(item->hDirectory);
670 item->hDirectory = NULL;
671 }
672
673 static
674 void
675 CALLBACK
676 _NotificationCompletion(DWORD dwErrorCode, // completion code
677 DWORD dwNumberOfBytesTransfered, // number of bytes transferred
678 LPOVERLAPPED lpOverlapped) // I/O information buffer
679 {
680 /* MSDN: The hEvent member of the OVERLAPPED structure is not used by the
681 system, so you can use it yourself. We do just this, storing a pointer
682 to the working struct in the overlapped structure. */
683 LPNOTIFYREGISTER item = (LPNOTIFYREGISTER) lpOverlapped->hEvent;
684 TRACE("_NotificationCompletion\n");
685
686 if (dwErrorCode == ERROR_OPERATION_ABORTED)
687 {
688 /* Command was induced by CancelIo in the shutdown procedure. */
689 TRACE("_NotificationCompletion ended.\n");
690 return;
691 }
692
693 /* This likely means overflow, so force whole directory refresh. */
694 if (!dwNumberOfBytesTransfered)
695 {
696 ERR("_NotificationCompletion overflow\n");
697
698 ZeroMemory(item->buffer, BUFFER_SIZE);
699 _BeginRead(item);
700
701 SHChangeNotify(SHCNE_UPDATEITEM | SHCNE_INTERRUPT,
702 SHCNF_IDLIST,
703 item->pidl,
704 NULL);
705
706 return;
707 }
708
709 /*
710 * Get the new read issued as fast as possible (before we do the
711 * processing and message posting). All of the file notification
712 * occur on one thread so the buffers should not collide with one another.
713 * The extra zero mems are because the FNI size isn't written correctly.
714 */
715
716 ZeroMemory(item->backBuffer, BUFFER_SIZE);
717 memcpy(item->backBuffer, item->buffer, dwNumberOfBytesTransfered);
718 ZeroMemory(item->buffer, BUFFER_SIZE);
719
720 _BeginRead(item);
721
722 _ProcessNotification(item);
723 }
724
725 static VOID _BeginRead(LPNOTIFYREGISTER item )
726 {
727 TRACE("_BeginRead %p \n", item->hDirectory);
728
729 /* This call needs to be reissued after every APC. */
730 if (!ReadDirectoryChangesW(item->hDirectory, // handle to directory
731 item->buffer, // read results buffer
732 BUFFER_SIZE, // length of buffer
733 FALSE, // monitoring option (recursion)
734 FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_FILE_NAME, // filter conditions
735 NULL, // bytes returned
736 &item->overlapped, // overlapped buffer
737 _NotificationCompletion)) // completion routine
738 ERR("ReadDirectoryChangesW failed. (%p, %p, %p, %p) Code: %u \n",
739 item->hDirectory,
740 item->buffer,
741 &item->overlapped,
742 _NotificationCompletion,
743 GetLastError());
744 }
745
746 DWORD _MapAction(DWORD dwAction, BOOL isDir)
747 {
748 switch (dwAction)
749 {
750 case FILE_ACTION_ADDED : return isDir ? SHCNE_MKDIR : SHCNE_CREATE;
751 case FILE_ACTION_REMOVED : return isDir ? SHCNE_RMDIR : SHCNE_DELETE;
752 case FILE_ACTION_MODIFIED : return isDir ? SHCNE_UPDATEDIR : SHCNE_UPDATEITEM;
753 case FILE_ACTION_RENAMED_OLD_NAME : return isDir ? SHCNE_UPDATEDIR : SHCNE_UPDATEITEM;
754 case FILE_ACTION_RENAMED_NEW_NAME : return isDir ? SHCNE_UPDATEDIR : SHCNE_UPDATEITEM;
755 default: return SHCNE_UPDATEITEM;
756 }
757 }
758
759 VOID _ProcessNotification(LPNOTIFYREGISTER item)
760 {
761 BYTE* pBase = item->backBuffer;
762 TRACE("_ProcessNotification\n");
763
764 for (;;)
765 {
766 FILE_NOTIFY_INFORMATION* fni = (FILE_NOTIFY_INFORMATION*)pBase;
767 LPWSTR wszFilename;
768 INT len = 0;
769 WCHAR wstrFilename[MAX_PATH];
770 WCHAR tmp[MAX_PATH];
771 StringCchCopy(tmp, fni->FileNameLength, fni->FileName);
772
773 PathCombine(wstrFilename, item->wstrDirectory, tmp);
774
775 /* If it could be a short filename, expand it. */
776 wszFilename = PathFindFileNameW(wstrFilename);
777
778 len = lstrlenW(wszFilename);
779 /* The maximum length of an 8.3 filename is twelve, including the dot. */
780 if (len <= 12 && wcschr(wszFilename, L'~'))
781 {
782 /* Convert to the long filename form. Unfortunately, this
783 does not work for deletions, so it's an imperfect fix. */
784 wchar_t wbuf[MAX_PATH];
785 if (GetLongPathName(wstrFilename, wbuf, _countof (wbuf)) > 0)
786 StringCchCopyW(wstrFilename, MAX_PATH, wbuf);
787 }
788
789 /* On deletion of a folder PathIsDirectory will return false even if
790 it *was* a directory, so, again, imperfect. */
791 SHChangeNotify(_MapAction(fni->Action, PathIsDirectory(wstrFilename)) | SHCNE_INTERRUPT,
792 SHCNF_PATHW,
793 wstrFilename,
794 NULL);
795
796 if (!fni->NextEntryOffset)
797 break;
798 pBase += fni->NextEntryOffset;
799 }
800 }
801
802 static void CALLBACK _RequestAllTermination(ULONG_PTR arg)
803 {
804 m_bTerminate = TRUE;
805 }
806
807 static unsigned int WINAPI _RunAsyncThreadProc(LPVOID arg)
808 {
809 m_bTerminate = FALSE;
810 while (!m_bTerminate)
811 {
812 SleepEx(INFINITE, TRUE);
813 }
814 return 0;
815 }
816
817 #endif /* __REACTOS__ */