d3dx9_36/tests: Add a trailing '\n' to an ok() call.
[wine] / server / change.c
1 /*
2  * Server-side change notification management
3  *
4  * Copyright (C) 1998 Alexandre Julliard
5  * Copyright (C) 2006 Mike McCormack
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <fcntl.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <signal.h>
30 #include <sys/stat.h>
31 #include <sys/types.h>
32 #include <limits.h>
33 #include <dirent.h>
34 #include <errno.h>
35
36 #include "ntstatus.h"
37 #define WIN32_NO_STATUS
38 #include "windef.h"
39
40 #include "file.h"
41 #include "handle.h"
42 #include "thread.h"
43 #include "request.h"
44 #include "process.h"
45 #include "security.h"
46 #include "winternl.h"
47
48 /* dnotify support */
49
50 #ifdef linux
51 #ifndef F_NOTIFY
52 #define F_NOTIFY 1026
53 #define DN_ACCESS       0x00000001      /* File accessed */
54 #define DN_MODIFY       0x00000002      /* File modified */
55 #define DN_CREATE       0x00000004      /* File created */
56 #define DN_DELETE       0x00000008      /* File removed */
57 #define DN_RENAME       0x00000010      /* File renamed */
58 #define DN_ATTRIB       0x00000020      /* File changed attributes */
59 #define DN_MULTISHOT    0x80000000      /* Don't remove notifier */
60 #endif
61 #endif
62
63 /* inotify support */
64
65 #ifdef HAVE_SYS_INOTIFY_H
66 #include <sys/inotify.h>
67 #define USE_INOTIFY
68 #elif defined(__linux__) && defined(__i386__)
69
70 #define SYS_inotify_init        291
71 #define SYS_inotify_add_watch   292
72 #define SYS_inotify_rm_watch    293
73
74 struct inotify_event {
75     int           wd;
76     unsigned int  mask;
77     unsigned int  cookie;
78     unsigned int  len;
79     char          name[1];
80 };
81
82 #define IN_ACCESS        0x00000001
83 #define IN_MODIFY        0x00000002
84 #define IN_ATTRIB        0x00000004
85 #define IN_CLOSE_WRITE   0x00000008
86 #define IN_CLOSE_NOWRITE 0x00000010
87 #define IN_OPEN          0x00000020
88 #define IN_MOVED_FROM    0x00000040
89 #define IN_MOVED_TO      0x00000080
90 #define IN_CREATE        0x00000100
91 #define IN_DELETE        0x00000200
92 #define IN_DELETE_SELF   0x00000400
93
94 #define IN_ISDIR         0x40000000
95
96 static inline int inotify_init( void )
97 {
98     return syscall( SYS_inotify_init );
99 }
100
101 static inline int inotify_add_watch( int fd, const char *name, unsigned int mask )
102 {
103     return syscall( SYS_inotify_add_watch, fd, name, mask );
104 }
105
106 static inline int inotify_rm_watch( int fd, int wd )
107 {
108     return syscall( SYS_inotify_rm_watch, fd, wd );
109 }
110
111 #define USE_INOTIFY
112
113 #endif
114
115 struct inode;
116
117 static void free_inode( struct inode *inode );
118
119 static struct fd *inotify_fd;
120
121 struct change_record {
122     struct list entry;
123     unsigned int cookie;
124     struct filesystem_event event;
125 };
126
127 struct dir
128 {
129     struct object  obj;      /* object header */
130     struct fd     *fd;       /* file descriptor to the directory */
131     mode_t         mode;     /* file stat.st_mode */
132     uid_t          uid;      /* file stat.st_uid */
133     struct list    entry;    /* entry in global change notifications list */
134     unsigned int   filter;   /* notification filter */
135     int            notified; /* SIGIO counter */
136     int            want_data; /* return change data */
137     int            subtree;  /* do we want to watch subdirectories? */
138     struct list    change_records;   /* data for the change */
139     struct list    in_entry; /* entry in the inode dirs list */
140     struct inode  *inode;    /* inode of the associated directory */
141 };
142
143 static struct fd *dir_get_fd( struct object *obj );
144 static struct security_descriptor *dir_get_sd( struct object *obj );
145 static int dir_set_sd( struct object *obj, const struct security_descriptor *sd,
146                        unsigned int set_info );
147 static void dir_dump( struct object *obj, int verbose );
148 static void dir_destroy( struct object *obj );
149
150 static const struct object_ops dir_ops =
151 {
152     sizeof(struct dir),       /* size */
153     dir_dump,                 /* dump */
154     no_get_type,              /* get_type */
155     add_queue,                /* add_queue */
156     remove_queue,             /* remove_queue */
157     default_fd_signaled,      /* signaled */
158     no_satisfied,             /* satisfied */
159     no_signal,                /* signal */
160     dir_get_fd,               /* get_fd */
161     default_fd_map_access,    /* map_access */
162     dir_get_sd,               /* get_sd */
163     dir_set_sd,               /* set_sd */
164     no_lookup_name,           /* lookup_name */
165     no_open_file,             /* open_file */
166     fd_close_handle,          /* close_handle */
167     dir_destroy               /* destroy */
168 };
169
170 static int dir_get_poll_events( struct fd *fd );
171 static enum server_fd_type dir_get_fd_type( struct fd *fd );
172
173 static const struct fd_ops dir_fd_ops =
174 {
175     dir_get_poll_events,         /* get_poll_events */
176     default_poll_event,          /* poll_event */
177     no_flush,                    /* flush */
178     dir_get_fd_type,             /* get_fd_type */
179     default_fd_ioctl,            /* ioctl */
180     default_fd_queue_async,      /* queue_async */
181     default_fd_reselect_async,   /* reselect_async */
182     default_fd_cancel_async      /* cancel_async */
183 };
184
185 static struct list change_list = LIST_INIT(change_list);
186
187 static void dnotify_adjust_changes( struct dir *dir )
188 {
189 #if defined(F_SETSIG) && defined(F_NOTIFY)
190     int fd = get_unix_fd( dir->fd );
191     unsigned int filter = dir->filter;
192     unsigned int val;
193     if ( 0 > fcntl( fd, F_SETSIG, SIGIO) )
194         return;
195
196     val = DN_MULTISHOT;
197     if (filter & FILE_NOTIFY_CHANGE_FILE_NAME)
198         val |= DN_RENAME | DN_DELETE | DN_CREATE;
199     if (filter & FILE_NOTIFY_CHANGE_DIR_NAME)
200         val |= DN_RENAME | DN_DELETE | DN_CREATE;
201     if (filter & FILE_NOTIFY_CHANGE_ATTRIBUTES)
202         val |= DN_ATTRIB;
203     if (filter & FILE_NOTIFY_CHANGE_SIZE)
204         val |= DN_MODIFY;
205     if (filter & FILE_NOTIFY_CHANGE_LAST_WRITE)
206         val |= DN_MODIFY;
207     if (filter & FILE_NOTIFY_CHANGE_LAST_ACCESS)
208         val |= DN_ACCESS;
209     if (filter & FILE_NOTIFY_CHANGE_CREATION)
210         val |= DN_CREATE;
211     if (filter & FILE_NOTIFY_CHANGE_SECURITY)
212         val |= DN_ATTRIB;
213     fcntl( fd, F_NOTIFY, val );
214 #endif
215 }
216
217 /* insert change in the global list */
218 static inline void insert_change( struct dir *dir )
219 {
220     sigset_t sigset;
221
222     sigemptyset( &sigset );
223     sigaddset( &sigset, SIGIO );
224     sigprocmask( SIG_BLOCK, &sigset, NULL );
225     list_add_head( &change_list, &dir->entry );
226     sigprocmask( SIG_UNBLOCK, &sigset, NULL );
227 }
228
229 /* remove change from the global list */
230 static inline void remove_change( struct dir *dir )
231 {
232     sigset_t sigset;
233
234     sigemptyset( &sigset );
235     sigaddset( &sigset, SIGIO );
236     sigprocmask( SIG_BLOCK, &sigset, NULL );
237     list_remove( &dir->entry );
238     sigprocmask( SIG_UNBLOCK, &sigset, NULL );
239 }
240
241 static void dir_dump( struct object *obj, int verbose )
242 {
243     struct dir *dir = (struct dir *)obj;
244     assert( obj->ops == &dir_ops );
245     fprintf( stderr, "Dirfile fd=%p filter=%08x\n", dir->fd, dir->filter );
246 }
247
248 /* enter here directly from SIGIO signal handler */
249 void do_change_notify( int unix_fd )
250 {
251     struct dir *dir;
252
253     /* FIXME: this is O(n) ... probably can be improved */
254     LIST_FOR_EACH_ENTRY( dir, &change_list, struct dir, entry )
255     {
256         if (get_unix_fd( dir->fd ) != unix_fd) continue;
257         interlocked_xchg_add( &dir->notified, 1 );
258         break;
259     }
260 }
261
262 /* SIGIO callback, called synchronously with the poll loop */
263 void sigio_callback(void)
264 {
265     struct dir *dir;
266
267     LIST_FOR_EACH_ENTRY( dir, &change_list, struct dir, entry )
268     {
269         if (interlocked_xchg( &dir->notified, 0 ))
270             fd_async_wake_up( dir->fd, ASYNC_TYPE_WAIT, STATUS_NOTIFY_ENUM_DIR );
271     }
272 }
273
274 static struct fd *dir_get_fd( struct object *obj )
275 {
276     struct dir *dir = (struct dir *)obj;
277     assert( obj->ops == &dir_ops );
278     return (struct fd *)grab_object( dir->fd );
279 }
280
281 static int get_dir_unix_fd( struct dir *dir )
282 {
283     return get_unix_fd( dir->fd );
284 }
285
286 static struct security_descriptor *dir_get_sd( struct object *obj )
287 {
288     struct dir *dir = (struct dir *)obj;
289     int unix_fd;
290     struct stat st;
291     struct security_descriptor *sd;
292     assert( obj->ops == &dir_ops );
293
294     unix_fd = get_dir_unix_fd( dir );
295
296     if (unix_fd == -1 || fstat( unix_fd, &st ) == -1)
297         return obj->sd;
298
299     /* mode and uid the same? if so, no need to re-generate security descriptor */
300     if (obj->sd &&
301         (st.st_mode & (S_IRWXU|S_IRWXO)) == (dir->mode & (S_IRWXU|S_IRWXO)) &&
302         (st.st_uid == dir->uid))
303         return obj->sd;
304
305     sd = mode_to_sd( st.st_mode,
306                      security_unix_uid_to_sid( st.st_uid ),
307                      token_get_primary_group( current->process->token ));
308     if (!sd) return obj->sd;
309
310     dir->mode = st.st_mode;
311     dir->uid = st.st_uid;
312     free( obj->sd );
313     obj->sd = sd;
314     return sd;
315 }
316
317 static int dir_set_sd( struct object *obj, const struct security_descriptor *sd,
318                        unsigned int set_info )
319 {
320     struct dir *dir = (struct dir *)obj;
321     const SID *owner;
322     struct stat st;
323     mode_t mode;
324     int unix_fd;
325
326     assert( obj->ops == &dir_ops );
327
328     unix_fd = get_dir_unix_fd( dir );
329
330     if (unix_fd == -1 || fstat( unix_fd, &st ) == -1) return 1;
331
332     if (set_info & OWNER_SECURITY_INFORMATION)
333     {
334         owner = sd_get_owner( sd );
335         if (!owner)
336         {
337             set_error( STATUS_INVALID_SECURITY_DESCR );
338             return 0;
339         }
340         if (!obj->sd || !security_equal_sid( owner, sd_get_owner( obj->sd ) ))
341         {
342             /* FIXME: get Unix uid and call fchown */
343         }
344     }
345     else if (obj->sd)
346         owner = sd_get_owner( obj->sd );
347     else
348         owner = token_get_user( current->process->token );
349
350     if (set_info & DACL_SECURITY_INFORMATION)
351     {
352         /* keep the bits that we don't map to access rights in the ACL */
353         mode = st.st_mode & (S_ISUID|S_ISGID|S_ISVTX);
354         mode |= sd_to_mode( sd, owner );
355
356         if (((st.st_mode ^ mode) & (S_IRWXU|S_IRWXG|S_IRWXO)) && fchmod( unix_fd, mode ) == -1)
357         {
358             file_set_error();
359             return 0;
360         }
361     }
362     return 1;
363 }
364
365 static struct change_record *get_first_change_record( struct dir *dir )
366 {
367     struct list *ptr = list_head( &dir->change_records );
368     if (!ptr) return NULL;
369     list_remove( ptr );
370     return LIST_ENTRY( ptr, struct change_record, entry );
371 }
372
373 static void dir_destroy( struct object *obj )
374 {
375     struct change_record *record;
376     struct dir *dir = (struct dir *)obj;
377     assert (obj->ops == &dir_ops);
378
379     if (dir->filter)
380         remove_change( dir );
381
382     if (dir->inode)
383     {
384         list_remove( &dir->in_entry );
385         free_inode( dir->inode );
386     }
387
388     while ((record = get_first_change_record( dir ))) free( record );
389
390     release_object( dir->fd );
391
392     if (inotify_fd && list_empty( &change_list ))
393     {
394         release_object( inotify_fd );
395         inotify_fd = NULL;
396     }
397 }
398
399 struct dir *get_dir_obj( struct process *process, obj_handle_t handle, unsigned int access )
400 {
401     return (struct dir *)get_handle_obj( process, handle, access, &dir_ops );
402 }
403
404 static int dir_get_poll_events( struct fd *fd )
405 {
406     return 0;
407 }
408
409 static enum server_fd_type dir_get_fd_type( struct fd *fd )
410 {
411     return FD_TYPE_DIR;
412 }
413
414 #ifdef USE_INOTIFY
415
416 #define HASH_SIZE 31
417
418 struct inode {
419     struct list ch_entry;    /* entry in the children list */
420     struct list children;    /* children of this inode */
421     struct inode *parent;    /* parent of this inode */
422     struct list dirs;        /* directory handles watching this inode */
423     struct list ino_entry;   /* entry in the inode hash */
424     struct list wd_entry;    /* entry in the watch descriptor hash */
425     dev_t dev;               /* device number */
426     ino_t ino;               /* device's inode number */
427     int wd;                  /* inotify's watch descriptor */
428     char *name;              /* basename name of the inode */
429 };
430
431 static struct list inode_hash[ HASH_SIZE ];
432 static struct list wd_hash[ HASH_SIZE ];
433
434 static int inotify_add_dir( char *path, unsigned int filter );
435
436 static struct inode *inode_from_wd( int wd )
437 {
438     struct list *bucket = &wd_hash[ wd % HASH_SIZE ];
439     struct inode *inode;
440
441     LIST_FOR_EACH_ENTRY( inode, bucket, struct inode, wd_entry )
442         if (inode->wd == wd)
443             return inode;
444
445     return NULL;
446 }
447
448 static inline struct list *get_hash_list( dev_t dev, ino_t ino )
449 {
450     return &inode_hash[ (ino ^ dev) % HASH_SIZE ];
451 }
452
453 static struct inode *find_inode( dev_t dev, ino_t ino )
454 {
455     struct list *bucket = get_hash_list( dev, ino );
456     struct inode *inode;
457
458     LIST_FOR_EACH_ENTRY( inode, bucket, struct inode, ino_entry )
459         if (inode->ino == ino && inode->dev == dev)
460              return inode;
461
462     return NULL;
463 }
464
465 static struct inode *create_inode( dev_t dev, ino_t ino )
466 {
467     struct inode *inode;
468
469     inode = malloc( sizeof *inode );
470     if (inode)
471     {
472         list_init( &inode->children );
473         list_init( &inode->dirs );
474         inode->ino = ino;
475         inode->dev = dev;
476         inode->wd = -1;
477         inode->parent = NULL;
478         inode->name = NULL;
479         list_add_tail( get_hash_list( dev, ino ), &inode->ino_entry );
480     }
481     return inode;
482 }
483
484 static struct inode *get_inode( dev_t dev, ino_t ino )
485 {
486     struct inode *inode;
487
488     inode = find_inode( dev, ino );
489     if (inode)
490         return inode;
491     return create_inode( dev, ino );
492 }
493
494 static void inode_set_wd( struct inode *inode, int wd )
495 {
496     if (inode->wd != -1)
497         list_remove( &inode->wd_entry );
498     inode->wd = wd;
499     list_add_tail( &wd_hash[ wd % HASH_SIZE ], &inode->wd_entry );
500 }
501
502 static void inode_set_name( struct inode *inode, const char *name )
503 {
504     free (inode->name);
505     inode->name = name ? strdup( name ) : NULL;
506 }
507
508 static void free_inode( struct inode *inode )
509 {
510     int subtree = 0, watches = 0;
511     struct inode *tmp, *next;
512     struct dir *dir;
513
514     LIST_FOR_EACH_ENTRY( dir, &inode->dirs, struct dir, in_entry )
515     {
516         subtree |= dir->subtree;
517         watches++;
518     }
519
520     if (!subtree && !inode->parent)
521     {
522         LIST_FOR_EACH_ENTRY_SAFE( tmp, next, &inode->children,
523                                   struct inode, ch_entry )
524         {
525             assert( tmp != inode );
526             assert( tmp->parent == inode );
527             free_inode( tmp );
528         }
529     }
530
531     if (watches)
532         return;
533
534     if (inode->parent)
535         list_remove( &inode->ch_entry );
536
537     /* disconnect remaining children from the parent */
538     LIST_FOR_EACH_ENTRY_SAFE( tmp, next, &inode->children, struct inode, ch_entry )
539     {
540         list_remove( &tmp->ch_entry );
541         tmp->parent = NULL;
542     }
543
544     if (inode->wd != -1)
545     {
546         inotify_rm_watch( get_unix_fd( inotify_fd ), inode->wd );
547         list_remove( &inode->wd_entry );
548     }
549     list_remove( &inode->ino_entry );
550
551     free( inode->name );
552     free( inode );
553 }
554
555 static struct inode *inode_add( struct inode *parent,
556                                 dev_t dev, ino_t ino, const char *name )
557 {
558     struct inode *inode;
559  
560     inode = get_inode( dev, ino );
561     if (!inode)
562         return NULL;
563  
564     if (!inode->parent)
565     {
566         list_add_tail( &parent->children, &inode->ch_entry );
567         inode->parent = parent;
568         assert( inode != parent );
569     }
570     inode_set_name( inode, name );
571
572     return inode;
573 }
574
575 static struct inode *inode_from_name( struct inode *inode, const char *name )
576 {
577     struct inode *i;
578
579     LIST_FOR_EACH_ENTRY( i, &inode->children, struct inode, ch_entry )
580         if (i->name && !strcmp( i->name, name ))
581             return i;
582     return NULL;
583 }
584
585 static int inotify_get_poll_events( struct fd *fd );
586 static void inotify_poll_event( struct fd *fd, int event );
587
588 static const struct fd_ops inotify_fd_ops =
589 {
590     inotify_get_poll_events,     /* get_poll_events */
591     inotify_poll_event,          /* poll_event */
592     NULL,                        /* flush */
593     NULL,                        /* get_fd_type */
594     NULL,                        /* ioctl */
595     NULL,                        /* queue_async */
596     NULL,                        /* reselect_async */
597     NULL,                        /* cancel_async */
598 };
599
600 static int inotify_get_poll_events( struct fd *fd )
601 {
602     return POLLIN;
603 }
604
605 static void inotify_do_change_notify( struct dir *dir, unsigned int action,
606                                       unsigned int cookie, const char *relpath )
607 {
608     struct change_record *record;
609
610     assert( dir->obj.ops == &dir_ops );
611
612     if (dir->want_data)
613     {
614         size_t len = strlen(relpath);
615         record = malloc( offsetof(struct change_record, event.name[len]) );
616         if (!record)
617             return;
618
619         record->cookie = cookie;
620         record->event.action = action;
621         memcpy( record->event.name, relpath, len );
622         record->event.len = len;
623
624         list_add_tail( &dir->change_records, &record->entry );
625     }
626
627     fd_async_wake_up( dir->fd, ASYNC_TYPE_WAIT, STATUS_ALERTED );
628 }
629
630 static unsigned int filter_from_event( struct inotify_event *ie )
631 {
632     unsigned int filter = 0;
633
634     if (ie->mask & (IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE | IN_CREATE))
635         filter |= FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME;
636     if (ie->mask & IN_MODIFY)
637         filter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
638     if (ie->mask & IN_ATTRIB)
639         filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SECURITY;
640     if (ie->mask & IN_ACCESS)
641         filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
642     if (ie->mask & IN_CREATE)
643         filter |= FILE_NOTIFY_CHANGE_CREATION;
644
645     if (ie->mask & IN_ISDIR)
646         filter &= ~FILE_NOTIFY_CHANGE_FILE_NAME;
647     else
648         filter &= ~FILE_NOTIFY_CHANGE_DIR_NAME;
649
650     return filter;
651 }
652
653 /* scan up the parent directories for watches */
654 static unsigned int filter_from_inode( struct inode *inode, int is_parent )
655 {
656     unsigned int filter = 0;
657     struct dir *dir;
658
659     /* combine filters from parents watching subtrees */
660     while (inode)
661     {
662         LIST_FOR_EACH_ENTRY( dir, &inode->dirs, struct dir, in_entry )
663             if (dir->subtree || !is_parent)
664                 filter |= dir->filter;
665         is_parent = 1;
666         inode = inode->parent;
667     }
668
669     return filter;
670 }
671
672 static char *inode_get_path( struct inode *inode, int sz )
673 {
674     struct list *head;
675     char *path;
676     int len;
677
678     if (!inode)
679         return NULL;
680
681     head = list_head( &inode->dirs );
682     if (head)
683     {
684         int unix_fd = get_unix_fd( LIST_ENTRY( head, struct dir, in_entry )->fd );
685         path = malloc ( 32 + sz );
686         if (path)
687             sprintf( path, "/proc/self/fd/%u/", unix_fd );
688         return path;
689     }
690
691     if (!inode->name)
692         return NULL;
693
694     len = strlen( inode->name );
695     path = inode_get_path( inode->parent, sz + len + 1 );
696     if (!path)
697         return NULL;
698     
699     strcat( path, inode->name );
700     strcat( path, "/" );
701
702     return path;
703 }
704
705 static void inode_check_dir( struct inode *parent, const char *name )
706 {
707     char *path;
708     unsigned int filter;
709     struct inode *inode;
710     struct stat st;
711     int wd = -1;
712
713     path = inode_get_path( parent, strlen(name) );
714     if (!path)
715         return;
716
717     strcat( path, name );
718
719     if (stat( path, &st ) < 0)
720         goto end;
721
722     filter = filter_from_inode( parent, 1 );
723     if (!filter)
724         goto end;
725
726     inode = inode_add( parent, st.st_dev, st.st_ino, name );
727     if (!inode || inode->wd != -1)
728         goto end;
729
730     wd = inotify_add_dir( path, filter );
731     if (wd != -1)
732         inode_set_wd( inode, wd );
733     else
734         free_inode( inode );
735
736 end:
737     free( path );
738 }
739
740 static int prepend( char **path, const char *segment )
741 {
742     int extra;
743     char *p;
744
745     extra = strlen( segment ) + 1;
746     if (*path)
747     {
748         int len = strlen( *path ) + 1;
749         p = realloc( *path, len + extra );
750         if (!p) return 0;
751         memmove( &p[ extra ], p, len );
752         p[ extra - 1 ] = '/';
753         memcpy( p, segment, extra - 1 );
754     }
755     else
756     {
757         p = malloc( extra );
758         if (!p) return 0;
759         memcpy( p, segment, extra );
760     }
761
762     *path = p;
763
764     return 1;
765 }
766
767 static void inotify_notify_all( struct inotify_event *ie )
768 {
769     unsigned int filter, action;
770     struct inode *inode, *i;
771     char *path = NULL;
772     struct dir *dir;
773
774     inode = inode_from_wd( ie->wd );
775     if (!inode)
776     {
777         fprintf( stderr, "no inode matches %d\n", ie->wd);
778         return;
779     }
780
781     filter = filter_from_event( ie );
782     
783     if (ie->mask & IN_CREATE)
784     {
785         if (ie->mask & IN_ISDIR)
786             inode_check_dir( inode, ie->name );
787
788         action = FILE_ACTION_ADDED;
789     }
790     else if (ie->mask & IN_DELETE)
791         action = FILE_ACTION_REMOVED;
792     else if (ie->mask & IN_MOVED_FROM)
793         action = FILE_ACTION_RENAMED_OLD_NAME;
794     else if (ie->mask & IN_MOVED_TO)
795         action = FILE_ACTION_RENAMED_NEW_NAME;
796     else
797         action = FILE_ACTION_MODIFIED;
798
799     /*
800      * Work our way up the inode hierarchy
801      *  extending the relative path as we go
802      *  and notifying all recursive watches.
803      */
804     if (!prepend( &path, ie->name ))
805         return;
806
807     for (i = inode; i; i = i->parent)
808     {
809         LIST_FOR_EACH_ENTRY( dir, &i->dirs, struct dir, in_entry )
810             if ((filter & dir->filter) && (i==inode || dir->subtree))
811                 inotify_do_change_notify( dir, action, ie->cookie, path );
812
813         if (!i->name || !prepend( &path, i->name ))
814             break;
815     }
816
817     free( path );
818
819     if (ie->mask & IN_DELETE)
820     {
821         i = inode_from_name( inode, ie->name );
822         if (i)
823             free_inode( i );
824     }
825 }
826
827 static void inotify_poll_event( struct fd *fd, int event )
828 {
829     int r, ofs, unix_fd;
830     char buffer[0x1000];
831     struct inotify_event *ie;
832
833     unix_fd = get_unix_fd( fd );
834     r = read( unix_fd, buffer, sizeof buffer );
835     if (r < 0)
836     {
837         fprintf(stderr,"inotify_poll_event(): inotify read failed!\n");
838         return;
839     }
840
841     for( ofs = 0; ofs < r - offsetof(struct inotify_event, name); )
842     {
843         ie = (struct inotify_event*) &buffer[ofs];
844         if (!ie->len)
845             break;
846         ofs += offsetof( struct inotify_event, name[ie->len] );
847         if (ofs > r) break;
848         inotify_notify_all( ie );
849     }
850 }
851
852 static inline struct fd *create_inotify_fd( void )
853 {
854     int unix_fd;
855
856     unix_fd = inotify_init();
857     if (unix_fd<0)
858         return NULL;
859     return create_anonymous_fd( &inotify_fd_ops, unix_fd, NULL, 0 );
860 }
861
862 static int map_flags( unsigned int filter )
863 {
864     unsigned int mask;
865
866     /* always watch these so we can track subdirectories in recursive watches */
867     mask = (IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE | IN_CREATE | IN_DELETE_SELF);
868
869     if (filter & FILE_NOTIFY_CHANGE_ATTRIBUTES)
870         mask |= IN_ATTRIB;
871     if (filter & FILE_NOTIFY_CHANGE_SIZE)
872         mask |= IN_MODIFY;
873     if (filter & FILE_NOTIFY_CHANGE_LAST_WRITE)
874         mask |= IN_MODIFY;
875     if (filter & FILE_NOTIFY_CHANGE_LAST_ACCESS)
876         mask |= IN_ACCESS;
877     if (filter & FILE_NOTIFY_CHANGE_SECURITY)
878         mask |= IN_ATTRIB;
879
880     return mask;
881 }
882
883 static int inotify_add_dir( char *path, unsigned int filter )
884 {
885     int wd = inotify_add_watch( get_unix_fd( inotify_fd ),
886                                 path, map_flags( filter ) );
887     if (wd != -1)
888         set_fd_events( inotify_fd, POLLIN );
889     return wd;
890 }
891
892 static int init_inotify( void )
893 {
894     int i;
895
896     if (inotify_fd)
897         return 1;
898
899     inotify_fd = create_inotify_fd();
900     if (!inotify_fd)
901         return 0;
902
903     for (i=0; i<HASH_SIZE; i++)
904     {
905         list_init( &inode_hash[i] );
906         list_init( &wd_hash[i] );
907     }
908
909     return 1;
910 }
911
912 static int inotify_adjust_changes( struct dir *dir )
913 {
914     unsigned int filter;
915     struct inode *inode;
916     struct stat st;
917     char path[32];
918     int wd, unix_fd;
919
920     if (!inotify_fd)
921         return 0;
922
923     unix_fd = get_unix_fd( dir->fd );
924
925     inode = dir->inode;
926     if (!inode)
927     {
928         /* check if this fd is already being watched */
929         if (-1 == fstat( unix_fd, &st ))
930             return 0;
931
932         inode = get_inode( st.st_dev, st.st_ino );
933         if (!inode)
934             inode = create_inode( st.st_dev, st.st_ino );
935         if (!inode)
936             return 0;
937         list_add_tail( &inode->dirs, &dir->in_entry );
938         dir->inode = inode;
939     }
940
941     filter = filter_from_inode( inode, 0 );
942
943     sprintf( path, "/proc/self/fd/%u", unix_fd );
944     wd = inotify_add_dir( path, filter );
945     if (wd == -1) return 0;
946
947     inode_set_wd( inode, wd );
948
949     return 1;
950 }
951
952 static char *get_basename( const char *link )
953 {
954     char *buffer, *name = NULL;
955     int r, n = 0x100;
956
957     while (1)
958     {
959         buffer = malloc( n );
960         if (!buffer) return NULL;
961
962         r = readlink( link, buffer, n );
963         if (r < 0)
964             break;
965
966         if (r < n)
967         {
968             name = buffer;
969             break;
970         }
971         free( buffer );
972         n *= 2;
973     }
974
975     if (name)
976     {
977         while (r > 0 && name[ r - 1 ] == '/' )
978             r--;
979         name[ r ] = 0;
980
981         name = strrchr( name, '/' );
982         if (name)
983             name = strdup( &name[1] );
984     }
985
986     free( buffer );
987     return name;
988 }
989
990 static int dir_add_to_existing_notify( struct dir *dir )
991 {
992     struct inode *inode, *parent;
993     unsigned int filter = 0;
994     struct stat st, st_new;
995     char link[35], *name;
996     int wd, unix_fd;
997
998     if (!inotify_fd)
999         return 0;
1000
1001     unix_fd = get_unix_fd( dir->fd );
1002
1003     /* check if it's in the list of inodes we want to watch */
1004     if (-1 == fstat( unix_fd, &st_new ))
1005         return 0;
1006     inode = find_inode( st_new.st_dev, st_new.st_ino );
1007     if (inode)
1008         return 0;
1009
1010     /* lookup the parent */
1011     sprintf( link, "/proc/self/fd/%u/..", unix_fd );
1012     if (-1 == stat( link, &st ))
1013         return 0;
1014
1015     /*
1016      * If there's no parent, stop.  We could keep going adding
1017      *  ../ to the path until we hit the root of the tree or
1018      *  find a recursively watched ancestor.
1019      * Assume it's too expensive to search up the tree for now.
1020      */
1021     parent = find_inode( st.st_dev, st.st_ino );
1022     if (!parent)
1023         return 0;
1024
1025     if (parent->wd == -1)
1026         return 0;
1027
1028     filter = filter_from_inode( parent, 1 );
1029     if (!filter)
1030         return 0;
1031
1032     sprintf( link, "/proc/self/fd/%u", unix_fd );
1033     name = get_basename( link );
1034     if (!name)
1035         return 0;
1036     inode = inode_add( parent, st_new.st_dev, st_new.st_ino, name );
1037     free( name );
1038     if (!inode)
1039         return 0;
1040
1041     /* Couldn't find this inode at the start of the function, must be new */
1042     assert( inode->wd == -1 );
1043
1044     wd = inotify_add_dir( link, filter );
1045     if (wd != -1)
1046         inode_set_wd( inode, wd );
1047
1048     return 1;
1049 }
1050
1051 #else
1052
1053 static int init_inotify( void )
1054 {
1055     return 0;
1056 }
1057
1058 static int inotify_adjust_changes( struct dir *dir )
1059 {
1060     return 0;
1061 }
1062
1063 static void free_inode( struct inode *inode )
1064 {
1065     assert( 0 );
1066 }
1067
1068 static int dir_add_to_existing_notify( struct dir *dir )
1069 {
1070     return 0;
1071 }
1072
1073 #endif  /* USE_INOTIFY */
1074
1075 struct object *create_dir_obj( struct fd *fd, unsigned int access, mode_t mode )
1076 {
1077     struct dir *dir;
1078
1079     dir = alloc_object( &dir_ops );
1080     if (!dir)
1081         return NULL;
1082
1083     list_init( &dir->change_records );
1084     dir->filter = 0;
1085     dir->notified = 0;
1086     dir->want_data = 0;
1087     dir->inode = NULL;
1088     grab_object( fd );
1089     dir->fd = fd;
1090     dir->mode = mode;
1091     dir->uid  = ~(uid_t)0;
1092     set_fd_user( fd, &dir_fd_ops, &dir->obj );
1093
1094     dir_add_to_existing_notify( dir );
1095
1096     return &dir->obj;
1097 }
1098
1099 /* enable change notifications for a directory */
1100 DECL_HANDLER(read_directory_changes)
1101 {
1102     struct dir *dir;
1103     struct async *async;
1104
1105     if (!req->filter)
1106     {
1107         set_error(STATUS_INVALID_PARAMETER);
1108         return;
1109     }
1110
1111     dir = get_dir_obj( current->process, req->async.handle, 0 );
1112     if (!dir)
1113         return;
1114
1115     /* requests don't timeout */
1116     if (!(async = fd_queue_async( dir->fd, &req->async, ASYNC_TYPE_WAIT ))) goto end;
1117
1118     /* assign it once */
1119     if (!dir->filter)
1120     {
1121         init_inotify();
1122         insert_change( dir );
1123         dir->filter = req->filter;
1124         dir->subtree = req->subtree;
1125         dir->want_data = req->want_data;
1126     }
1127
1128     /* if there's already a change in the queue, send it */
1129     if (!list_empty( &dir->change_records ))
1130         fd_async_wake_up( dir->fd, ASYNC_TYPE_WAIT, STATUS_ALERTED );
1131
1132     /* setup the real notification */
1133     if (!inotify_adjust_changes( dir ))
1134         dnotify_adjust_changes( dir );
1135
1136     release_object( async );
1137     set_error(STATUS_PENDING);
1138
1139 end:
1140     release_object( dir );
1141 }
1142
1143 DECL_HANDLER(read_change)
1144 {
1145     struct change_record *record, *next;
1146     struct dir *dir;
1147     struct list events;
1148     char *data, *event;
1149     int size = 0;
1150
1151     dir = get_dir_obj( current->process, req->handle, 0 );
1152     if (!dir)
1153         return;
1154
1155     list_init( &events );
1156     list_move_tail( &events, &dir->change_records );
1157     release_object( dir );
1158
1159     if (list_empty( &events ))
1160     {
1161         set_error( STATUS_NO_DATA_DETECTED );
1162         return;
1163     }
1164
1165     LIST_FOR_EACH_ENTRY( record, &events, struct change_record, entry )
1166     {
1167         size += (offsetof(struct filesystem_event, name[record->event.len])
1168                 + sizeof(int)-1) / sizeof(int) * sizeof(int);
1169     }
1170
1171     if (size > get_reply_max_size())
1172         set_error( STATUS_BUFFER_TOO_SMALL );
1173     else if ((data = mem_alloc( size )) != NULL)
1174     {
1175         event = data;
1176         LIST_FOR_EACH_ENTRY( record, &events, struct change_record, entry )
1177         {
1178             data_size_t len = offsetof( struct filesystem_event, name[record->event.len] );
1179
1180             /* FIXME: rename events are sometimes reported as delete/create */
1181             if (record->event.action == FILE_ACTION_RENAMED_OLD_NAME)
1182             {
1183                 struct list *elem = list_next( &events, &record->entry );
1184                 if (elem)
1185                     next = LIST_ENTRY(elem, struct change_record, entry);
1186
1187                 if (elem && next->cookie == record->cookie)
1188                     next->cookie = 0;
1189                 else
1190                     record->event.action = FILE_ACTION_REMOVED;
1191             }
1192             else if (record->event.action == FILE_ACTION_RENAMED_NEW_NAME && record->cookie)
1193                 record->event.action = FILE_ACTION_ADDED;
1194
1195             memcpy( event, &record->event, len );
1196             event += len;
1197             if (len % sizeof(int))
1198             {
1199                 memset( event, 0, sizeof(int) - len % sizeof(int) );
1200                 event += sizeof(int) - len % sizeof(int);
1201             }
1202         }
1203         set_reply_data_ptr( data, size );
1204     }
1205
1206     LIST_FOR_EACH_ENTRY_SAFE( record, next, &events, struct change_record, entry )
1207     {
1208         list_remove( &record->entry );
1209         free( record );
1210     }
1211 }