?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
setupapi: Fix buffer overflow in SetupGetFileCompressionInfoW.
[wine.git] / dlls / ntdll / directory.c
blob78b3ea7c35c1073d354241f5ddfbae242c8f0cd9
1 /*
2 * NTDLL directory functions
3 *
4 * Copyright 1993 Erik Bos
5 * Copyright 2003 Eric Pouech
6 * Copyright 1996, 2004 Alexandre Julliard
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <sys/types.h>
28 #ifdef HAVE_DIRENT_H
29 # include <dirent.h>
30 #endif
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdarg.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include <stdio.h>
37 #include <limits.h>
38 #ifdef HAVE_MNTENT_H
39 #include <mntent.h>
40 #endif
41 #ifdef HAVE_SYS_STAT_H
42 # include <sys/stat.h>
43 #endif
44 #ifdef HAVE_SYS_SYSCALL_H
45 # include <sys/syscall.h>
46 #endif
47 #ifdef HAVE_SYS_ATTR_H
48 #include <sys/attr.h>
49 #endif
50 #ifdef HAVE_SYS_IOCTL_H
51 #include <sys/ioctl.h>
52 #endif
53 #ifdef HAVE_LINUX_IOCTL_H
54 #include <linux/ioctl.h>
55 #endif
56 #ifdef HAVE_LINUX_MAJOR_H
57 # include <linux/major.h>
58 #endif
59 #ifdef HAVE_SYS_PARAM_H
60 #include <sys/param.h>
61 #endif
62 #ifdef HAVE_SYS_MOUNT_H
63 #include <sys/mount.h>
64 #endif
65 #ifdef HAVE_SYS_STATFS_H
66 #include <sys/statfs.h>
67 #endif
68 #include <time.h>
69 #ifdef HAVE_UNISTD_H
70 # include <unistd.h>
71 #endif
72
73 #define NONAMELESSUNION
74 #define NONAMELESSSTRUCT
75 #include "ntstatus.h"
76 #define WIN32_NO_STATUS
77 #include "windef.h"
78 #include "winnt.h"
79 #include "winternl.h"
80 #include "ddk/wdm.h"
81 #include "ntdll_misc.h"
82 #include "wine/unicode.h"
83 #include "wine/server.h"
84 #include "wine/list.h"
85 #include "wine/library.h"
86 #include "wine/debug.h"
87
88 WINE_DEFAULT_DEBUG_CHANNEL(file);
89
90 /* just in case... */
91 #undef VFAT_IOCTL_READDIR_BOTH
92 #undef USE_GETDENTS
93
94 #ifdef linux
95
96 /* We want the real kernel dirent structure, not the libc one */
97 typedef struct
98 {
99 long d_ino;
100 long d_off;
101 unsigned short d_reclen;
102 char d_name[256];
103 } KERNEL_DIRENT;
104
105 /* Define the VFAT ioctl to get both short and long file names */
106 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, KERNEL_DIRENT [2] )
107
108 #ifndef O_DIRECTORY
109 # define O_DIRECTORY 0200000 /* must be directory */
110 #endif
111
112 #ifdef __NR_getdents64
113 typedef struct
114 {
115 ULONG64 d_ino;
116 LONG64 d_off;
117 unsigned short d_reclen;
118 unsigned char d_type;
119 char d_name[256];
120 } KERNEL_DIRENT64;
121
122 static inline int getdents64( int fd, char *de, unsigned int size )
123 {
124 return syscall( __NR_getdents64, fd, de, size );
125 }
126 #define USE_GETDENTS
127 #endif
128
129 #endif /* linux */
130
131 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
132 #define IS_SEPARATOR(ch) ((ch) == '\\' || (ch) == '/')
133
134 #define INVALID_NT_CHARS '*','?','<','>','|','"'
135 #define INVALID_DOS_CHARS INVALID_NT_CHARS,'+','=',',',';','[',']',' ','\345'
136
137 #define MAX_DIR_ENTRY_LEN 255 /* max length of a directory entry in chars */
138
139 #define MAX_IGNORED_FILES 4
140
141 struct file_identity
142 {
143 dev_t dev;
144 ino_t ino;
145 };
146
147 static struct file_identity ignored_files[MAX_IGNORED_FILES];
148 static unsigned int ignored_files_count;
149
150 union file_directory_info
151 {
152 ULONG next;
153 FILE_DIRECTORY_INFORMATION dir;
154 FILE_BOTH_DIRECTORY_INFORMATION both;
155 FILE_FULL_DIRECTORY_INFORMATION full;
156 FILE_ID_BOTH_DIRECTORY_INFORMATION id_both;
157 FILE_ID_FULL_DIRECTORY_INFORMATION id_full;
158 };
159
160 static BOOL show_dot_files;
161 static RTL_RUN_ONCE init_once = RTL_RUN_ONCE_INIT;
162
163 /* at some point we may want to allow Winelib apps to set this */
164 static const BOOL is_case_sensitive = FALSE;
165
166 UNICODE_STRING system_dir = { 0, 0, NULL }; /* system directory */
167
168 static struct file_identity curdir;
169 static struct file_identity windir;
170
171 static RTL_CRITICAL_SECTION dir_section;
172 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
173 {
174 0, 0, &dir_section,
175 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
176 0, 0, { (DWORD_PTR)(__FILE__ ": dir_section") }
177 };
178 static RTL_CRITICAL_SECTION dir_section = { &critsect_debug, -1, 0, 0, 0, 0 };
179
180
181 /* check if a given Unicode char is OK in a DOS short name */
182 static inline BOOL is_invalid_dos_char( WCHAR ch )
183 {
184 static const WCHAR invalid_chars[] = { INVALID_DOS_CHARS,'~','.',0 };
185 if (ch > 0x7f) return TRUE;
186 return strchrW( invalid_chars, ch ) != NULL;
187 }
188
189 /* check if the device can be a mounted volume */
190 static inline BOOL is_valid_mounted_device( const struct stat *st )
191 {
192 #if defined(linux) || defined(__sun__)
193 return S_ISBLK( st->st_mode );
194 #else
195 /* disks are char devices on *BSD */
196 return S_ISCHR( st->st_mode );
197 #endif
198 }
199
200 static inline void ignore_file( const char *name )
201 {
202 struct stat st;
203 assert( ignored_files_count < MAX_IGNORED_FILES );
204 if (!stat( name, &st ))
205 {
206 ignored_files[ignored_files_count].dev = st.st_dev;
207 ignored_files[ignored_files_count].ino = st.st_ino;
208 ignored_files_count++;
209 }
210 }
211
212 static inline BOOL is_same_file( const struct file_identity *file, const struct stat *st )
213 {
214 return st->st_dev == file->dev && st->st_ino == file->ino;
215 }
216
217 static inline BOOL is_ignored_file( const struct stat *st )
218 {
219 unsigned int i;
220
221 for (i = 0; i < ignored_files_count; i++)
222 if (is_same_file( &ignored_files[i], st )) return TRUE;
223 return FALSE;
224 }
225
226 static inline unsigned int dir_info_size( FILE_INFORMATION_CLASS class, unsigned int len )
227 {
228 switch (class)
229 {
230 case FileDirectoryInformation:
231 return (FIELD_OFFSET( FILE_DIRECTORY_INFORMATION, FileName[len] ) + 3) & ~3;
232 case FileBothDirectoryInformation:
233 return (FIELD_OFFSET( FILE_BOTH_DIRECTORY_INFORMATION, FileName[len] ) + 3) & ~3;
234 case FileFullDirectoryInformation:
235 return (FIELD_OFFSET( FILE_FULL_DIRECTORY_INFORMATION, FileName[len] ) + 3) & ~3;
236 case FileIdBothDirectoryInformation:
237 return (FIELD_OFFSET( FILE_ID_BOTH_DIRECTORY_INFORMATION, FileName[len] ) + 3) & ~3;
238 case FileIdFullDirectoryInformation:
239 return (FIELD_OFFSET( FILE_ID_FULL_DIRECTORY_INFORMATION, FileName[len] ) + 3) & ~3;
240 default:
241 assert(0);
242 return 0;
243 }
244 }
245
246 static inline unsigned int max_dir_info_size( FILE_INFORMATION_CLASS class )
247 {
248 return dir_info_size( class, MAX_DIR_ENTRY_LEN );
249 }
250
251 static inline BOOL has_wildcard( const UNICODE_STRING *mask )
252 {
253 return (!mask ||
254 memchrW( mask->Buffer, '*', mask->Length / sizeof(WCHAR) ) ||
255 memchrW( mask->Buffer, '?', mask->Length / sizeof(WCHAR) ));
256 }
257
258
259 /* support for a directory queue for filesystem searches */
260
261 struct dir_name
262 {
263 struct list entry;
264 char name[1];
265 };
266
267 static struct list dir_queue = LIST_INIT( dir_queue );
268
269 static NTSTATUS add_dir_to_queue( const char *name )
270 {
271 int len = strlen( name ) + 1;
272 struct dir_name *dir = RtlAllocateHeap( GetProcessHeap(), 0,
273 FIELD_OFFSET( struct dir_name, name[len] ));
274 if (!dir) return STATUS_NO_MEMORY;
275 strcpy( dir->name, name );
276 list_add_tail( &dir_queue, &dir->entry );
277 return STATUS_SUCCESS;
278 }
279
280 static NTSTATUS next_dir_in_queue( char *name )
281 {
282 struct list *head = list_head( &dir_queue );
283 if (head)
284 {
285 struct dir_name *dir = LIST_ENTRY( head, struct dir_name, entry );
286 strcpy( name, dir->name );
287 list_remove( &dir->entry );
288 RtlFreeHeap( GetProcessHeap(), 0, dir );
289 return STATUS_SUCCESS;
290 }
291 return STATUS_OBJECT_NAME_NOT_FOUND;
292 }
293
294 static void flush_dir_queue(void)
295 {
296 struct list *head;
297
298 while ((head = list_head( &dir_queue )))
299 {
300 struct dir_name *dir = LIST_ENTRY( head, struct dir_name, entry );
301 list_remove( &dir->entry );
302 RtlFreeHeap( GetProcessHeap(), 0, dir );
303 }
304 }
305
306
307 /***********************************************************************
308 * get_default_com_device
309 *
310 * Return the default device to use for serial ports.
311 */
312 static char *get_default_com_device( int num )
313 {
314 char *ret = NULL;
315
316 if (!num || num > 9) return ret;
317 #ifdef linux
318 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/ttyS0") );
319 if (ret)
320 {
321 strcpy( ret, "/dev/ttyS0" );
322 ret[strlen(ret) - 1] = '0' + num - 1;
323 }
324 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
325 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/cuau0") );
326 if (ret)
327 {
328 strcpy( ret, "/dev/cuau0" );
329 ret[strlen(ret) - 1] = '0' + num - 1;
330 }
331 #elif defined(__DragonFly__)
332 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/cuaa0") );
333 if (ret)
334 {
335 strcpy( ret, "/dev/cuaa0" );
336 ret[strlen(ret) - 1] = '0' + num - 1;
337 }
338 #else
339 FIXME( "no known default for device com%d\n", num );
340 #endif
341 return ret;
342 }
343
344
345 /***********************************************************************
346 * get_default_lpt_device
347 *
348 * Return the default device to use for parallel ports.
349 */
350 static char *get_default_lpt_device( int num )
351 {
352 char *ret = NULL;
353
354 if (!num || num > 9) return ret;
355 #ifdef linux
356 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/lp0") );
357 if (ret)
358 {
359 strcpy( ret, "/dev/lp0" );
360 ret[strlen(ret) - 1] = '0' + num - 1;
361 }
362 #else
363 FIXME( "no known default for device lpt%d\n", num );
364 #endif
365 return ret;
366 }
367
368
369 /***********************************************************************
370 * DIR_get_drives_info
371 *
372 * Retrieve device/inode number for all the drives. Helper for find_drive_root.
373 */
374 unsigned int DIR_get_drives_info( struct drive_info info[MAX_DOS_DRIVES] )
375 {
376 static struct drive_info cache[MAX_DOS_DRIVES];
377 static time_t last_update;
378 static unsigned int nb_drives;
379 unsigned int ret;
380 time_t now = time(NULL);
381
382 RtlEnterCriticalSection( &dir_section );
383 if (now != last_update)
384 {
385 const char *config_dir = wine_get_config_dir();
386 char *buffer, *p;
387 struct stat st;
388 unsigned int i;
389
390 if ((buffer = RtlAllocateHeap( GetProcessHeap(), 0,
391 strlen(config_dir) + sizeof("/dosdevices/a:") )))
392 {
393 strcpy( buffer, config_dir );
394 strcat( buffer, "/dosdevices/a:" );
395 p = buffer + strlen(buffer) - 2;
396
397 for (i = nb_drives = 0; i < MAX_DOS_DRIVES; i++)
398 {
399 *p = 'a' + i;
400 if (!stat( buffer, &st ))
401 {
402 cache[i].dev = st.st_dev;
403 cache[i].ino = st.st_ino;
404 nb_drives++;
405 }
406 else
407 {
408 cache[i].dev = 0;
409 cache[i].ino = 0;
410 }
411 }
412 RtlFreeHeap( GetProcessHeap(), 0, buffer );
413 }
414 last_update = now;
415 }
416 memcpy( info, cache, sizeof(cache) );
417 ret = nb_drives;
418 RtlLeaveCriticalSection( &dir_section );
419 return ret;
420 }
421
422
423 /***********************************************************************
424 * parse_mount_entries
425 *
426 * Parse mount entries looking for a given device. Helper for get_default_drive_device.
427 */
428
429 #ifdef sun
430 #include <sys/vfstab.h>
431 static char *parse_vfstab_entries( FILE *f, dev_t dev, ino_t ino)
432 {
433 struct vfstab entry;
434 struct stat st;
435 char *device;
436
437 while (! getvfsent( f, &entry ))
438 {
439 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
440 if (!strcmp( entry.vfs_fstype, "nfs" ) ||
441 !strcmp( entry.vfs_fstype, "smbfs" ) ||
442 !strcmp( entry.vfs_fstype, "ncpfs" )) continue;
443
444 if (stat( entry.vfs_mountp, &st ) == -1) continue;
445 if (st.st_dev != dev || st.st_ino != ino) continue;
446 if (!strcmp( entry.vfs_fstype, "fd" ))
447 {
448 if ((device = strstr( entry.vfs_mntopts, "dev=" )))
449 {
450 char *p = strchr( device + 4, ',' );
451 if (p) *p = 0;
452 return device + 4;
453 }
454 }
455 else
456 return entry.vfs_special;
457 }
458 return NULL;
459 }
460 #endif
461
462 #ifdef linux
463 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
464 {
465 struct mntent *entry;
466 struct stat st;
467 char *device;
468
469 while ((entry = getmntent( f )))
470 {
471 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
472 if (!strcmp( entry->mnt_type, "nfs" ) ||
473 !strcmp( entry->mnt_type, "smbfs" ) ||
474 !strcmp( entry->mnt_type, "ncpfs" )) continue;
475
476 if (stat( entry->mnt_dir, &st ) == -1) continue;
477 if (st.st_dev != dev || st.st_ino != ino) continue;
478 if (!strcmp( entry->mnt_type, "supermount" ))
479 {
480 if ((device = strstr( entry->mnt_opts, "dev=" )))
481 {
482 char *p = strchr( device + 4, ',' );
483 if (p) *p = 0;
484 return device + 4;
485 }
486 }
487 else if (!stat( entry->mnt_fsname, &st ) && S_ISREG(st.st_mode))
488 {
489 /* if device is a regular file check for a loop mount */
490 if ((device = strstr( entry->mnt_opts, "loop=" )))
491 {
492 char *p = strchr( device + 5, ',' );
493 if (p) *p = 0;
494 return device + 5;
495 }
496 }
497 else
498 return entry->mnt_fsname;
499 }
500 return NULL;
501 }
502 #endif
503
504 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
505 #include <fstab.h>
506 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
507 {
508 struct fstab *entry;
509 struct stat st;
510
511 while ((entry = getfsent()))
512 {
513 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
514 if (!strcmp( entry->fs_vfstype, "nfs" ) ||
515 !strcmp( entry->fs_vfstype, "smbfs" ) ||
516 !strcmp( entry->fs_vfstype, "ncpfs" )) continue;
517
518 if (stat( entry->fs_file, &st ) == -1) continue;
519 if (st.st_dev != dev || st.st_ino != ino) continue;
520 return entry->fs_spec;
521 }
522 return NULL;
523 }
524 #endif
525
526 #ifdef sun
527 #include <sys/mnttab.h>
528 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
529 {
530 struct mnttab entry;
531 struct stat st;
532 char *device;
533
534
535 while (( ! getmntent( f, &entry) ))
536 {
537 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
538 if (!strcmp( entry.mnt_fstype, "nfs" ) ||
539 !strcmp( entry.mnt_fstype, "smbfs" ) ||
540 !strcmp( entry.mnt_fstype, "ncpfs" )) continue;
541
542 if (stat( entry.mnt_mountp, &st ) == -1) continue;
543 if (st.st_dev != dev || st.st_ino != ino) continue;
544 if (!strcmp( entry.mnt_fstype, "fd" ))
545 {
546 if ((device = strstr( entry.mnt_mntopts, "dev=" )))
547 {
548 char *p = strchr( device + 4, ',' );
549 if (p) *p = 0;
550 return device + 4;
551 }
552 }
553 else
554 return entry.mnt_special;
555 }
556 return NULL;
557 }
558 #endif
559
560 /***********************************************************************
561 * get_default_drive_device
562 *
563 * Return the default device to use for a given drive mount point.
564 */
565 static char *get_default_drive_device( const char *root )
566 {
567 char *ret = NULL;
568
569 #ifdef linux
570 FILE *f;
571 char *device = NULL;
572 int fd, res = -1;
573 struct stat st;
574
575 /* try to open it first to force it to get mounted */
576 if ((fd = open( root, O_RDONLY | O_DIRECTORY )) != -1)
577 {
578 res = fstat( fd, &st );
579 close( fd );
580 }
581 /* now try normal stat just in case */
582 if (res == -1) res = stat( root, &st );
583 if (res == -1) return NULL;
584
585 RtlEnterCriticalSection( &dir_section );
586
587 if ((f = fopen( "/etc/mtab", "r" )))
588 {
589 device = parse_mount_entries( f, st.st_dev, st.st_ino );
590 fclose( f );
591 }
592 /* look through fstab too in case it's not mounted (for instance if it's an audio CD) */
593 if (!device && (f = fopen( "/etc/fstab", "r" )))
594 {
595 device = parse_mount_entries( f, st.st_dev, st.st_ino );
596 fclose( f );
597 }
598 if (device)
599 {
600 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(device) + 1 );
601 if (ret) strcpy( ret, device );
602 }
603 RtlLeaveCriticalSection( &dir_section );
604
605 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__ ) || defined(__DragonFly__)
606 char *device = NULL;
607 int fd, res = -1;
608 struct stat st;
609
610 /* try to open it first to force it to get mounted */
611 if ((fd = open( root, O_RDONLY )) != -1)
612 {
613 res = fstat( fd, &st );
614 close( fd );
615 }
616 /* now try normal stat just in case */
617 if (res == -1) res = stat( root, &st );
618 if (res == -1) return NULL;
619
620 RtlEnterCriticalSection( &dir_section );
621
622 /* The FreeBSD parse_mount_entries doesn't require a file argument, so just
623 * pass NULL. Leave the argument in for symmetry.
624 */
625 device = parse_mount_entries( NULL, st.st_dev, st.st_ino );
626 if (device)
627 {
628 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(device) + 1 );
629 if (ret) strcpy( ret, device );
630 }
631 RtlLeaveCriticalSection( &dir_section );
632
633 #elif defined( sun )
634 FILE *f;
635 char *device = NULL;
636 int fd, res = -1;
637 struct stat st;
638
639 /* try to open it first to force it to get mounted */
640 if ((fd = open( root, O_RDONLY )) != -1)
641 {
642 res = fstat( fd, &st );
643 close( fd );
644 }
645 /* now try normal stat just in case */
646 if (res == -1) res = stat( root, &st );
647 if (res == -1) return NULL;
648
649 RtlEnterCriticalSection( &dir_section );
650
651 if ((f = fopen( "/etc/mnttab", "r" )))
652 {
653 device = parse_mount_entries( f, st.st_dev, st.st_ino);
654 fclose( f );
655 }
656 /* look through fstab too in case it's not mounted (for instance if it's an audio CD) */
657 if (!device && (f = fopen( "/etc/vfstab", "r" )))
658 {
659 device = parse_vfstab_entries( f, st.st_dev, st.st_ino );
660 fclose( f );
661 }
662 if (device)
663 {
664 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(device) + 1 );
665 if (ret) strcpy( ret, device );
666 }
667 RtlLeaveCriticalSection( &dir_section );
668
669 #elif defined(__APPLE__)
670 struct statfs *mntStat;
671 struct stat st;
672 int i;
673 int mntSize;
674 dev_t dev;
675 ino_t ino;
676 static const char path_bsd_device[] = "/dev/disk";
677 int res;
678
679 res = stat( root, &st );
680 if (res == -1) return NULL;
681
682 dev = st.st_dev;
683 ino = st.st_ino;
684
685 RtlEnterCriticalSection( &dir_section );
686
687 mntSize = getmntinfo(&mntStat, MNT_NOWAIT);
688
689 for (i = 0; i < mntSize && !ret; i++)
690 {
691 if (stat(mntStat[i].f_mntonname, &st ) == -1) continue;
692 if (st.st_dev != dev || st.st_ino != ino) continue;
693
694 /* FIXME add support for mounted network drive */
695 if ( strncmp(mntStat[i].f_mntfromname, path_bsd_device, strlen(path_bsd_device)) == 0)
696 {
697 /* set return value to the corresponding raw BSD node */
698 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(mntStat[i].f_mntfromname) + 2 /* 2 : r and \0 */ );
699 if (ret)
700 {
701 strcpy(ret, "/dev/r");
702 strcat(ret, mntStat[i].f_mntfromname+sizeof("/dev/")-1);
703 }
704 }
705 }
706 RtlLeaveCriticalSection( &dir_section );
707 #else
708 static int warned;
709 if (!warned++) FIXME( "auto detection of DOS devices not supported on this platform\n" );
710 #endif
711 return ret;
712 }
713
714
715 /***********************************************************************
716 * get_device_mount_point
717 *
718 * Return the current mount point for a device.
719 */
720 static char *get_device_mount_point( dev_t dev )
721 {
722 char *ret = NULL;
723
724 #ifdef linux
725 FILE *f;
726
727 RtlEnterCriticalSection( &dir_section );
728
729 if ((f = fopen( "/etc/mtab", "r" )))
730 {
731 struct mntent *entry;
732 struct stat st;
733 char *p, *device;
734
735 while ((entry = getmntent( f )))
736 {
737 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
738 if (!strcmp( entry->mnt_type, "nfs" ) ||
739 !strcmp( entry->mnt_type, "smbfs" ) ||
740 !strcmp( entry->mnt_type, "ncpfs" )) continue;
741
742 if (!strcmp( entry->mnt_type, "supermount" ))
743 {
744 if ((device = strstr( entry->mnt_opts, "dev=" )))
745 {
746 device += 4;
747 if ((p = strchr( device, ',' ))) *p = 0;
748 }
749 }
750 else if (!stat( entry->mnt_fsname, &st ) && S_ISREG(st.st_mode))
751 {
752 /* if device is a regular file check for a loop mount */
753 if ((device = strstr( entry->mnt_opts, "loop=" )))
754 {
755 device += 5;
756 if ((p = strchr( device, ',' ))) *p = 0;
757 }
758 }
759 else device = entry->mnt_fsname;
760
761 if (device && !stat( device, &st ) && S_ISBLK(st.st_mode) && st.st_rdev == dev)
762 {
763 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(entry->mnt_dir) + 1 );
764 if (ret) strcpy( ret, entry->mnt_dir );
765 break;
766 }
767 }
768 fclose( f );
769 }
770 RtlLeaveCriticalSection( &dir_section );
771 #elif defined(__APPLE__)
772 struct statfs *entry;
773 struct stat st;
774 int i, size;
775
776 RtlEnterCriticalSection( &dir_section );
777
778 size = getmntinfo( &entry, MNT_NOWAIT );
779 for (i = 0; i < size; i++)
780 {
781 if (stat( entry[i].f_mntfromname, &st ) == -1) continue;
782 if (S_ISBLK(st.st_mode) && st.st_rdev == dev)
783 {
784 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(entry[i].f_mntonname) + 1 );
785 if (ret) strcpy( ret, entry[i].f_mntonname );
786 break;
787 }
788 }
789 RtlLeaveCriticalSection( &dir_section );
790 #else
791 static int warned;
792 if (!warned++) FIXME( "unmounting devices not supported on this platform\n" );
793 #endif
794 return ret;
795 }
796
797
798 #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \
799 defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE)
800
801 struct get_fsid
802 {
803 ULONG size;
804 dev_t dev;
805 fsid_t fsid;
806 };
807
808 struct fs_cache
809 {
810 dev_t dev;
811 fsid_t fsid;
812 BOOLEAN case_sensitive;
813 } fs_cache[64];
814
815 struct vol_caps
816 {
817 ULONG size;
818 vol_capabilities_attr_t caps;
819 };
820
821 /***********************************************************************
822 * look_up_fs_cache
823 *
824 * Checks if the specified file system is in the cache.
825 */
826 static struct fs_cache *look_up_fs_cache( dev_t dev )
827 {
828 int i;
829 for (i = 0; i < sizeof(fs_cache)/sizeof(fs_cache[0]); i++)
830 if (fs_cache[i].dev == dev)
831 return fs_cache+i;
832 return NULL;
833 }
834
835 /***********************************************************************
836 * add_fs_cache
837 *
838 * Adds the specified file system to the cache.
839 */
840 static void add_fs_cache( dev_t dev, fsid_t fsid, BOOLEAN case_sensitive )
841 {
842 int i;
843 struct fs_cache *entry = look_up_fs_cache( dev );
844 static int once = 0;
845 if (entry)
846 {
847 /* Update the cache */
848 entry->fsid = fsid;
849 entry->case_sensitive = case_sensitive;
850 return;
851 }
852
853 /* Add a new entry */
854 for (i = 0; i < sizeof(fs_cache)/sizeof(fs_cache[0]); i++)
855 if (fs_cache[i].dev == 0)
856 {
857 /* This entry is empty, use it */
858 fs_cache[i].dev = dev;
859 fs_cache[i].fsid = fsid;
860 fs_cache[i].case_sensitive = case_sensitive;
861 return;
862 }
863
864 /* Cache is out of space, warn */
865 if (!once++)
866 WARN( "FS cache is out of space, expect performance problems\n" );
867 }
868
869 /***********************************************************************
870 * get_dir_case_sensitivity_attr
871 *
872 * Checks if the volume containing the specified directory is case
873 * sensitive or not. Uses getattrlist(2).
874 */
875 static int get_dir_case_sensitivity_attr( const char *dir )
876 {
877 char *mntpoint = NULL;
878 struct attrlist attr;
879 struct vol_caps caps;
880 struct get_fsid get_fsid;
881 struct fs_cache *entry;
882
883 /* First get the FS ID of the volume */
884 attr.bitmapcount = ATTR_BIT_MAP_COUNT;
885 attr.reserved = 0;
886 attr.commonattr = ATTR_CMN_DEVID|ATTR_CMN_FSID;
887 attr.volattr = attr.dirattr = attr.fileattr = attr.forkattr = 0;
888 get_fsid.size = 0;
889 if (getattrlist( dir, &attr, &get_fsid, sizeof(get_fsid), 0 ) != 0 ||
890 get_fsid.size != sizeof(get_fsid))
891 return -1;
892 /* Try to look it up in the cache */
893 entry = look_up_fs_cache( get_fsid.dev );
894 if (entry && !memcmp( &entry->fsid, &get_fsid.fsid, sizeof(fsid_t) ))
895 /* Cache lookup succeeded */
896 return entry->case_sensitive;
897 /* Cache is stale at this point, we have to update it */
898
899 mntpoint = get_device_mount_point( get_fsid.dev );
900 /* Now look up the case-sensitivity */
901 attr.commonattr = 0;
902 attr.volattr = ATTR_VOL_INFO|ATTR_VOL_CAPABILITIES;
903 if (getattrlist( mntpoint, &attr, &caps, sizeof(caps), 0 ) < 0)
904 {
905 RtlFreeHeap( GetProcessHeap(), 0, mntpoint );
906 add_fs_cache( get_fsid.dev, get_fsid.fsid, TRUE );
907 return TRUE;
908 }
909 RtlFreeHeap( GetProcessHeap(), 0, mntpoint );
910 if (caps.size == sizeof(caps) &&
911 (caps.caps.valid[VOL_CAPABILITIES_FORMAT] &
912 (VOL_CAP_FMT_CASE_SENSITIVE | VOL_CAP_FMT_CASE_PRESERVING)) ==
913 (VOL_CAP_FMT_CASE_SENSITIVE | VOL_CAP_FMT_CASE_PRESERVING))
914 {
915 BOOLEAN ret;
916
917 if ((caps.caps.capabilities[VOL_CAPABILITIES_FORMAT] &
918 VOL_CAP_FMT_CASE_SENSITIVE) != VOL_CAP_FMT_CASE_SENSITIVE)
919 ret = FALSE;
920 else
921 ret = TRUE;
922 /* Update the cache */
923 add_fs_cache( get_fsid.dev, get_fsid.fsid, ret );
924 return ret;
925 }
926 return FALSE;
927 }
928 #endif
929
930 /***********************************************************************
931 * get_dir_case_sensitivity_stat
932 *
933 * Checks if the volume containing the specified directory is case
934 * sensitive or not. Uses statfs(2) or statvfs(2).
935 */
936 static BOOLEAN get_dir_case_sensitivity_stat( const char *dir )
937 {
938 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
939 struct statfs stfs;
940
941 if (statfs( dir, &stfs ) == -1) return FALSE;
942 /* Assume these file systems are always case insensitive on Mac OS.
943 * For FreeBSD, only assume CIOPFS is case insensitive (AFAIK, Mac OS
944 * is the only UNIX that supports case-insensitive lookup).
945 */
946 if (!strcmp( stfs.f_fstypename, "fusefs" ) &&
947 !strncmp( stfs.f_mntfromname, "ciopfs", 5 ))
948 return FALSE;
949 #ifdef __APPLE__
950 if (!strcmp( stfs.f_fstypename, "msdos" ) ||
951 !strcmp( stfs.f_fstypename, "cd9660" ) ||
952 !strcmp( stfs.f_fstypename, "udf" ) ||
953 !strcmp( stfs.f_fstypename, "ntfs" ) ||
954 !strcmp( stfs.f_fstypename, "smbfs" ))
955 return FALSE;
956 #ifdef _DARWIN_FEATURE_64_BIT_INODE
957 if (!strcmp( stfs.f_fstypename, "hfs" ) && (stfs.f_fssubtype == 0 ||
958 stfs.f_fssubtype == 1 ||
959 stfs.f_fssubtype == 128))
960 return FALSE;
961 #else
962 /* The field says "reserved", but a quick look at the kernel source
963 * tells us that this "reserved" field is really the same as the
964 * "fssubtype" field from the inode64 structure (see munge_statfs()
965 * in <xnu-source>/bsd/vfs/vfs_syscalls.c).
966 */
967 if (!strcmp( stfs.f_fstypename, "hfs" ) && (stfs.f_reserved1 == 0 ||
968 stfs.f_reserved1 == 1 ||
969 stfs.f_reserved1 == 128))
970 return FALSE;
971 #endif
972 #endif
973 return TRUE;
974
975 #elif defined(__NetBSD__)
976 struct statvfs stfs;
977
978 if (statvfs( dir, &stfs ) == -1) return FALSE;
979 /* Only assume CIOPFS is case insensitive. */
980 if (strcmp( stfs.f_fstypename, "fusefs" ) ||
981 strncmp( stfs.f_mntfromname, "ciopfs", 5 ))
982 return TRUE;
983 return FALSE;
984
985 #elif defined(__linux__)
986 struct statfs stfs;
987 struct stat st;
988 char *cifile;
989
990 /* Only assume CIOPFS is case insensitive. */
991 if (statfs( dir, &stfs ) == -1) return FALSE;
992 if (stfs.f_type != 0x65735546 /* FUSE_SUPER_MAGIC */)
993 return TRUE;
994 /* Normally, we'd have to parse the mtab to find out exactly what
995 * kind of FUSE FS this is. But, someone on wine-devel suggested
996 * a shortcut. We'll stat a special file in the directory. If it's
997 * there, we'll assume it's a CIOPFS, else not.
998 * This will break if somebody puts a file named ".ciopfs" in a non-
999 * CIOPFS directory.
1000 */
1001 cifile = RtlAllocateHeap( GetProcessHeap(), 0, strlen( dir )+sizeof("/.ciopfs") );
1002 if (!cifile) return TRUE;
1003 strcpy( cifile, dir );
1004 strcat( cifile, "/.ciopfs" );
1005 if (stat( cifile, &st ) == 0)
1006 {
1007 RtlFreeHeap( GetProcessHeap(), 0, cifile );
1008 return FALSE;
1009 }
1010 RtlFreeHeap( GetProcessHeap(), 0, cifile );
1011 return TRUE;
1012 #else
1013 return TRUE;
1014 #endif
1015 }
1016
1017
1018 /***********************************************************************
1019 * get_dir_case_sensitivity
1020 *
1021 * Checks if the volume containing the specified directory is case
1022 * sensitive or not. Uses statfs(2) or statvfs(2).
1023 */
1024 static BOOLEAN get_dir_case_sensitivity( const char *dir )
1025 {
1026 #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \
1027 defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE)
1028 int case_sensitive = get_dir_case_sensitivity_attr( dir );
1029 if (case_sensitive != -1) return case_sensitive;
1030 #endif
1031 return get_dir_case_sensitivity_stat( dir );
1032 }
1033
1034
1035 /***********************************************************************
1036 * init_options
1037 *
1038 * Initialize the show_dot_files options.
1039 */
1040 static DWORD WINAPI init_options( RTL_RUN_ONCE *once, void *param, void **context )
1041 {
1042 static const WCHAR WineW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e',0};
1043 static const WCHAR ShowDotFilesW[] = {'S','h','o','w','D','o','t','F','i','l','e','s',0};
1044 char tmp[80];
1045 HANDLE root, hkey;
1046 DWORD dummy;
1047 OBJECT_ATTRIBUTES attr;
1048 UNICODE_STRING nameW;
1049
1050 RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
1051 attr.Length = sizeof(attr);
1052 attr.RootDirectory = root;
1053 attr.ObjectName = &nameW;
1054 attr.Attributes = 0;
1055 attr.SecurityDescriptor = NULL;
1056 attr.SecurityQualityOfService = NULL;
1057 RtlInitUnicodeString( &nameW, WineW );
1058
1059 /* @@ Wine registry key: HKCU\Software\Wine */
1060 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
1061 {
1062 RtlInitUnicodeString( &nameW, ShowDotFilesW );
1063 if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
1064 {
1065 WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
1066 show_dot_files = IS_OPTION_TRUE( str[0] );
1067 }
1068 NtClose( hkey );
1069 }
1070 NtClose( root );
1071
1072 /* a couple of directories that we don't want to return in directory searches */
1073 ignore_file( wine_get_config_dir() );
1074 ignore_file( "/dev" );
1075 ignore_file( "/proc" );
1076 #ifdef linux
1077 ignore_file( "/sys" );
1078 #endif
1079 return TRUE;
1080 }
1081
1082
1083 /***********************************************************************
1084 * DIR_is_hidden_file
1085 *
1086 * Check if the specified file should be hidden based on its name and the show dot files option.
1087 */
1088 BOOL DIR_is_hidden_file( const UNICODE_STRING *name )
1089 {
1090 WCHAR *p, *end;
1091
1092 RtlRunOnceExecuteOnce( &init_once, init_options, NULL, NULL );
1093
1094 if (show_dot_files) return FALSE;
1095
1096 end = p = name->Buffer + name->Length/sizeof(WCHAR);
1097 while (p > name->Buffer && IS_SEPARATOR(p[-1])) p--;
1098 while (p > name->Buffer && !IS_SEPARATOR(p[-1])) p--;
1099 if (p == end || *p != '.') return FALSE;
1100 /* make sure it isn't '.' or '..' */
1101 if (p + 1 == end) return FALSE;
1102 if (p[1] == '.' && p + 2 == end) return FALSE;
1103 return TRUE;
1104 }
1105
1106
1107 /***********************************************************************
1108 * hash_short_file_name
1109 *
1110 * Transform a Unix file name into a hashed DOS name. If the name is a valid
1111 * DOS name, it is converted to upper-case; otherwise it is replaced by a
1112 * hashed version that fits in 8.3 format.
1113 * 'buffer' must be at least 12 characters long.
1114 * Returns length of short name in bytes; short name is NOT null-terminated.
1115 */
1116 static ULONG hash_short_file_name( const UNICODE_STRING *name, LPWSTR buffer )
1117 {
1118 static const char hash_chars[32] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
1119
1120 LPCWSTR p, ext, end = name->Buffer + name->Length / sizeof(WCHAR);
1121 LPWSTR dst;
1122 unsigned short hash;
1123 int i;
1124
1125 /* Compute the hash code of the file name */
1126 /* If you know something about hash functions, feel free to */
1127 /* insert a better algorithm here... */
1128 if (!is_case_sensitive)
1129 {
1130 for (p = name->Buffer, hash = 0xbeef; p < end - 1; p++)
1131 hash = (hash<<3) ^ (hash>>5) ^ tolowerW(*p) ^ (tolowerW(p[1]) << 8);
1132 hash = (hash<<3) ^ (hash>>5) ^ tolowerW(*p); /* Last character */
1133 }
1134 else
1135 {
1136 for (p = name->Buffer, hash = 0xbeef; p < end - 1; p++)
1137 hash = (hash << 3) ^ (hash >> 5) ^ *p ^ (p[1] << 8);
1138 hash = (hash << 3) ^ (hash >> 5) ^ *p; /* Last character */
1139 }
1140
1141 /* Find last dot for start of the extension */
1142 for (p = name->Buffer + 1, ext = NULL; p < end - 1; p++) if (*p == '.') ext = p;
1143
1144 /* Copy first 4 chars, replacing invalid chars with '_' */
1145 for (i = 4, p = name->Buffer, dst = buffer; i > 0; i--, p++)
1146 {
1147 if (p == end || p == ext) break;
1148 *dst++ = is_invalid_dos_char(*p) ? '_' : toupperW(*p);
1149 }
1150 /* Pad to 5 chars with '~' */
1151 while (i-- >= 0) *dst++ = '~';
1152
1153 /* Insert hash code converted to 3 ASCII chars */
1154 *dst++ = hash_chars[(hash >> 10) & 0x1f];
1155 *dst++ = hash_chars[(hash >> 5) & 0x1f];
1156 *dst++ = hash_chars[hash & 0x1f];
1157
1158 /* Copy the first 3 chars of the extension (if any) */
1159 if (ext)
1160 {
1161 *dst++ = '.';
1162 for (i = 3, ext++; (i > 0) && ext < end; i--, ext++)
1163 *dst++ = is_invalid_dos_char(*ext) ? '_' : toupperW(*ext);
1164 }
1165 return dst - buffer;
1166 }
1167
1168
1169 /***********************************************************************
1170 * match_filename
1171 *
1172 * Check a long file name against a mask.
1173 *
1174 * Tests (done in W95 DOS shell - case insensitive):
1175 * *.txt test1.test.txt *
1176 * *st1* test1.txt *
1177 * *.t??????.t* test1.ta.tornado.txt *
1178 * *tornado* test1.ta.tornado.txt *
1179 * t*t test1.ta.tornado.txt *
1180 * ?est* test1.txt *
1181 * ?est??? test1.txt -
1182 * *test1.txt* test1.txt *
1183 * h?l?o*t.dat hellothisisatest.dat *
1184 */
1185 static BOOLEAN match_filename( const UNICODE_STRING *name_str, const UNICODE_STRING *mask_str )
1186 {
1187 BOOL mismatch;
1188 const WCHAR *name = name_str->Buffer;
1189 const WCHAR *mask = mask_str->Buffer;
1190 const WCHAR *name_end = name + name_str->Length / sizeof(WCHAR);
1191 const WCHAR *mask_end = mask + mask_str->Length / sizeof(WCHAR);
1192 const WCHAR *lastjoker = NULL;
1193 const WCHAR *next_to_retry = NULL;
1194
1195 TRACE("(%s, %s)\n", debugstr_us(name_str), debugstr_us(mask_str));
1196
1197 while (name < name_end && mask < mask_end)
1198 {
1199 switch(*mask)
1200 {
1201 case '*':
1202 mask++;
1203 while (mask < mask_end && *mask == '*') mask++; /* Skip consecutive '*' */
1204 if (mask == mask_end) return TRUE; /* end of mask is all '*', so match */
1205 lastjoker = mask;
1206
1207 /* skip to the next match after the joker(s) */
1208 if (is_case_sensitive)
1209 while (name < name_end && (*name != *mask)) name++;
1210 else
1211 while (name < name_end && (toupperW(*name) != toupperW(*mask))) name++;
1212 next_to_retry = name;
1213 break;
1214 case '?':
1215 mask++;
1216 name++;
1217 break;
1218 default:
1219 if (is_case_sensitive) mismatch = (*mask != *name);
1220 else mismatch = (toupperW(*mask) != toupperW(*name));
1221
1222 if (!mismatch)
1223 {
1224 mask++;
1225 name++;
1226 if (mask == mask_end)
1227 {
1228 if (name == name_end) return TRUE;
1229 if (lastjoker) mask = lastjoker;
1230 }
1231 }
1232 else /* mismatch ! */
1233 {
1234 if (lastjoker) /* we had an '*', so we can try unlimitedly */
1235 {
1236 mask = lastjoker;
1237
1238 /* this scan sequence was a mismatch, so restart
1239 * 1 char after the first char we checked last time */
1240 next_to_retry++;
1241 name = next_to_retry;
1242 }
1243 else return FALSE; /* bad luck */
1244 }
1245 break;
1246 }
1247 }
1248 while (mask < mask_end && ((*mask == '.') || (*mask == '*')))
1249 mask++; /* Ignore trailing '.' or '*' in mask */
1250 return (name == name_end && mask == mask_end);
1251 }
1252
1253
1254 /***********************************************************************
1255 * append_entry
1256 *
1257 * helper for NtQueryDirectoryFile
1258 */
1259 static union file_directory_info *append_entry( void *info_ptr, IO_STATUS_BLOCK *io, ULONG max_length,
1260 const char *long_name, const char *short_name,
1261 const UNICODE_STRING *mask, FILE_INFORMATION_CLASS class )
1262 {
1263 union file_directory_info *info;
1264 int i, long_len, short_len, total_len;
1265 struct stat st;
1266 WCHAR long_nameW[MAX_DIR_ENTRY_LEN];
1267 WCHAR short_nameW[12];
1268 WCHAR *filename;
1269 UNICODE_STRING str;
1270 ULONG attributes = 0;
1271
1272 io->u.Status = STATUS_SUCCESS;
1273 long_len = ntdll_umbstowcs( 0, long_name, strlen(long_name), long_nameW, MAX_DIR_ENTRY_LEN );
1274 if (long_len == -1) return NULL;
1275
1276 str.Buffer = long_nameW;
1277 str.Length = long_len * sizeof(WCHAR);
1278 str.MaximumLength = sizeof(long_nameW);
1279
1280 if (short_name)
1281 {
1282 short_len = ntdll_umbstowcs( 0, short_name, strlen(short_name),
1283 short_nameW, sizeof(short_nameW) / sizeof(WCHAR) );
1284 if (short_len == -1) short_len = sizeof(short_nameW) / sizeof(WCHAR);
1285 }
1286 else /* generate a short name if necessary */
1287 {
1288 BOOLEAN spaces;
1289
1290 short_len = 0;
1291 if (!RtlIsNameLegalDOS8Dot3( &str, NULL, &spaces ) || spaces)
1292 short_len = hash_short_file_name( &str, short_nameW );
1293 }
1294
1295 TRACE( "long %s short %s mask %s\n",
1296 debugstr_us(&str), debugstr_wn(short_nameW, short_len), debugstr_us(mask) );
1297
1298 if (mask && !match_filename( &str, mask ))
1299 {
1300 if (!short_len) return NULL; /* no short name to match */
1301 str.Buffer = short_nameW;
1302 str.Length = short_len * sizeof(WCHAR);
1303 str.MaximumLength = sizeof(short_nameW);
1304 if (!match_filename( &str, mask )) return NULL;
1305 }
1306
1307 if (lstat( long_name, &st ) == -1) return NULL;
1308 if (S_ISLNK( st.st_mode ))
1309 {
1310 if (stat( long_name, &st ) == -1) return NULL;
1311 if (S_ISDIR( st.st_mode )) attributes |= FILE_ATTRIBUTE_REPARSE_POINT;
1312 }
1313 if (is_ignored_file( &st ))
1314 {
1315 TRACE( "ignoring file %s\n", long_name );
1316 return NULL;
1317 }
1318 if (!show_dot_files && long_name[0] == '.' && long_name[1] && (long_name[1] != '.' || long_name[2]))
1319 attributes |= FILE_ATTRIBUTE_HIDDEN;
1320
1321 total_len = dir_info_size( class, long_len );
1322 if (io->Information + total_len > max_length)
1323 {
1324 total_len = max_length - io->Information;
1325 io->u.Status = STATUS_BUFFER_OVERFLOW;
1326 }
1327 info = (union file_directory_info *)((char *)info_ptr + io->Information);
1328 if (st.st_dev != curdir.dev) st.st_ino = 0; /* ignore inode if on a different device */
1329 /* all the structures start with a FileDirectoryInformation layout */
1330 fill_stat_info( &st, info, class );
1331 info->dir.NextEntryOffset = total_len;
1332 info->dir.FileIndex = 0; /* NTFS always has 0 here, so let's not bother with it */
1333 info->dir.FileAttributes |= attributes;
1334
1335 switch (class)
1336 {
1337 case FileDirectoryInformation:
1338 info->dir.FileNameLength = long_len * sizeof(WCHAR);
1339 filename = info->dir.FileName;
1340 break;
1341
1342 case FileFullDirectoryInformation:
1343 info->full.EaSize = 0; /* FIXME */
1344 info->full.FileNameLength = long_len * sizeof(WCHAR);
1345 filename = info->full.FileName;
1346 break;
1347
1348 case FileIdFullDirectoryInformation:
1349 info->id_full.EaSize = 0; /* FIXME */
1350 info->id_full.FileNameLength = long_len * sizeof(WCHAR);
1351 filename = info->id_full.FileName;
1352 break;
1353
1354 case FileBothDirectoryInformation:
1355 info->both.EaSize = 0; /* FIXME */
1356 info->both.ShortNameLength = short_len * sizeof(WCHAR);
1357 for (i = 0; i < short_len; i++) info->both.ShortName[i] = toupperW(short_nameW[i]);
1358 info->both.FileNameLength = long_len * sizeof(WCHAR);
1359 filename = info->both.FileName;
1360 break;
1361
1362 case FileIdBothDirectoryInformation:
1363 info->id_both.EaSize = 0; /* FIXME */
1364 info->id_both.ShortNameLength = short_len * sizeof(WCHAR);
1365 for (i = 0; i < short_len; i++) info->id_both.ShortName[i] = toupperW(short_nameW[i]);
1366 info->id_both.FileNameLength = long_len * sizeof(WCHAR);
1367 filename = info->id_both.FileName;
1368 break;
1369
1370 default:
1371 assert(0);
1372 return NULL;
1373 }
1374 memcpy( filename, long_nameW, total_len - ((char *)filename - (char *)info) );
1375 io->Information += total_len;
1376 return info;
1377 }
1378
1379
1380 #ifdef VFAT_IOCTL_READDIR_BOTH
1381
1382 /***********************************************************************
1383 * start_vfat_ioctl
1384 *
1385 * Wrapper for the VFAT ioctl to work around various kernel bugs.
1386 * dir_section must be held by caller.
1387 */
1388 static KERNEL_DIRENT *start_vfat_ioctl( int fd )
1389 {
1390 static KERNEL_DIRENT *de;
1391 int res;
1392
1393 if (!de)
1394 {
1395 SIZE_T size = 2 * sizeof(*de) + page_size;
1396 void *addr = NULL;
1397
1398 if (NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 1, &size, MEM_RESERVE, PAGE_READWRITE ))
1399 return NULL;
1400 /* commit only the size needed for the dir entries */
1401 /* this leaves an extra unaccessible page, which should make the kernel */
1402 /* fail with -EFAULT before it stomps all over our memory */
1403 de = addr;
1404 size = 2 * sizeof(*de);
1405 NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 1, &size, MEM_COMMIT, PAGE_READWRITE );
1406 }
1407
1408 /* set d_reclen to 65535 to work around an AFS kernel bug */
1409 de[0].d_reclen = 65535;
1410 res = ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de );
1411 if (res == -1)
1412 {
1413 if (errno != ENOENT) return NULL; /* VFAT ioctl probably not supported */
1414 de[0].d_reclen = 0; /* eof */
1415 }
1416 else if (!res && de[0].d_reclen == 65535) return NULL; /* AFS bug */
1417
1418 return de;
1419 }
1420
1421
1422 /***********************************************************************
1423 * read_directory_vfat
1424 *
1425 * Read a directory using the VFAT ioctl; helper for NtQueryDirectoryFile.
1426 */
1427 static int read_directory_vfat( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1428 BOOLEAN single_entry, const UNICODE_STRING *mask,
1429 BOOLEAN restart_scan, FILE_INFORMATION_CLASS class )
1430
1431 {
1432 size_t len;
1433 KERNEL_DIRENT *de;
1434 union file_directory_info *info, *last_info = NULL;
1435
1436 io->u.Status = STATUS_SUCCESS;
1437
1438 if (restart_scan) lseek( fd, 0, SEEK_SET );
1439
1440 if (length < max_dir_info_size(class)) /* we may have to return a partial entry here */
1441 {
1442 off_t old_pos = lseek( fd, 0, SEEK_CUR );
1443
1444 if (!(de = start_vfat_ioctl( fd ))) return -1; /* not supported */
1445
1446 while (de[0].d_reclen)
1447 {
1448 /* make sure names are null-terminated to work around an x86-64 kernel bug */
1449 len = min(de[0].d_reclen, sizeof(de[0].d_name) - 1 );
1450 de[0].d_name[len] = 0;
1451 len = min(de[1].d_reclen, sizeof(de[1].d_name) - 1 );
1452 de[1].d_name[len] = 0;
1453
1454 if (de[1].d_name[0])
1455 info = append_entry( buffer, io, length, de[1].d_name, de[0].d_name, mask, class );
1456 else
1457 info = append_entry( buffer, io, length, de[0].d_name, NULL, mask, class );
1458 if (info)
1459 {
1460 last_info = info;
1461 if (io->u.Status == STATUS_BUFFER_OVERFLOW)
1462 lseek( fd, old_pos, SEEK_SET ); /* restore pos to previous entry */
1463 break;
1464 }
1465 old_pos = lseek( fd, 0, SEEK_CUR );
1466 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1) break;
1467 }
1468 }
1469 else /* we'll only return full entries, no need to worry about overflow */
1470 {
1471 if (!(de = start_vfat_ioctl( fd ))) return -1; /* not supported */
1472
1473 while (de[0].d_reclen)
1474 {
1475 /* make sure names are null-terminated to work around an x86-64 kernel bug */
1476 len = min(de[0].d_reclen, sizeof(de[0].d_name) - 1 );
1477 de[0].d_name[len] = 0;
1478 len = min(de[1].d_reclen, sizeof(de[1].d_name) - 1 );
1479 de[1].d_name[len] = 0;
1480
1481 if (de[1].d_name[0])
1482 info = append_entry( buffer, io, length, de[1].d_name, de[0].d_name, mask, class );
1483 else
1484 info = append_entry( buffer, io, length, de[0].d_name, NULL, mask, class );
1485 if (info)
1486 {
1487 last_info = info;
1488 if (single_entry) break;
1489 /* check if we still have enough space for the largest possible entry */
1490 if (io->Information + max_dir_info_size(class) > length) break;
1491 }
1492 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1) break;
1493 }
1494 }
1495
1496 if (last_info) last_info->next = 0;
1497 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1498 return 0;
1499 }
1500 #endif /* VFAT_IOCTL_READDIR_BOTH */
1501
1502
1503 #ifdef USE_GETDENTS
1504 /***********************************************************************
1505 * read_first_dent_name
1506 *
1507 * reads name of first or second dentry (if they have inodes).
1508 */
1509 static char *read_first_dent_name( int which, int fd, off_t second_offs, KERNEL_DIRENT64 *de_first_two,
1510 char *buffer, size_t size, BOOL *buffer_changed )
1511 {
1512 KERNEL_DIRENT64 *de;
1513 int res;
1514
1515 de = de_first_two;
1516 if (de != NULL)
1517 {
1518 if (which == 1)
1519 de = (KERNEL_DIRENT64 *)((char *)de + de->d_reclen);
1520
1521 return de->d_ino ? de->d_name : NULL;
1522 }
1523
1524 *buffer_changed = TRUE;
1525 lseek( fd, which == 1 ? second_offs : 0, SEEK_SET );
1526 res = getdents64( fd, buffer, size );
1527 if (res <= 0)
1528 return NULL;
1529
1530 de = (KERNEL_DIRENT64 *)buffer;
1531 return de->d_ino ? de->d_name : NULL;
1532 }
1533
1534 /***********************************************************************
1535 * read_directory_getdents
1536 *
1537 * Read a directory using the Linux getdents64 system call; helper for NtQueryDirectoryFile.
1538 */
1539 static int read_directory_getdents( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1540 BOOLEAN single_entry, const UNICODE_STRING *mask,
1541 BOOLEAN restart_scan, FILE_INFORMATION_CLASS class )
1542 {
1543 static off_t second_entry_pos;
1544 static struct file_identity last_dir_id;
1545 off_t old_pos = 0, next_pos;
1546 size_t size = length;
1547 char *data, local_buffer[8192];
1548 KERNEL_DIRENT64 *de, *de_first_two = NULL;
1549 union file_directory_info *info, *last_info = NULL;
1550 const char *filename;
1551 BOOL data_buffer_changed;
1552 int res, swap_to;
1553
1554 if (size <= sizeof(local_buffer) || !(data = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1555 {
1556 size = sizeof(local_buffer);
1557 data = local_buffer;
1558 }
1559
1560 if (restart_scan) lseek( fd, 0, SEEK_SET );
1561 else
1562 {
1563 old_pos = lseek( fd, 0, SEEK_CUR );
1564 if (old_pos == -1)
1565 {
1566 io->u.Status = (errno == ENOENT) ? STATUS_NO_MORE_FILES : FILE_GetNtStatus();
1567 res = 0;
1568 goto done;
1569 }
1570 }
1571
1572 io->u.Status = STATUS_SUCCESS;
1573 de = (KERNEL_DIRENT64 *)data;
1574
1575 /* if old_pos is not 0 we don't know how many entries have been returned already,
1576 * so maintain second_entry_pos to know when to return '..' */
1577 if (old_pos != 0 && (last_dir_id.dev != curdir.dev || last_dir_id.ino != curdir.ino))
1578 {
1579 lseek( fd, 0, SEEK_SET );
1580 res = getdents64( fd, data, size );
1581 if (res > 0)
1582 {
1583 second_entry_pos = de->d_off;
1584 last_dir_id = curdir;
1585 }
1586 lseek( fd, old_pos, SEEK_SET );
1587 }
1588
1589 res = getdents64( fd, data, size );
1590 if (res == -1)
1591 {
1592 if (errno != ENOSYS)
1593 {
1594 io->u.Status = FILE_GetNtStatus();
1595 res = 0;
1596 }
1597 goto done;
1598 }
1599
1600 if (old_pos == 0 && res > 0)
1601 {
1602 second_entry_pos = de->d_off;
1603 last_dir_id = curdir;
1604 if (res > de->d_reclen)
1605 de_first_two = de;
1606 }
1607
1608 while (res > 0)
1609 {
1610 res -= de->d_reclen;
1611 next_pos = de->d_off;
1612 filename = NULL;
1613
1614 /* we must return first 2 entries as "." and "..", but getdents64()
1615 * can return them anywhere, so swap first entries with "." and ".." */
1616 if (old_pos == 0)
1617 filename = ".";
1618 else if (old_pos == second_entry_pos)
1619 filename = "..";
1620 else if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." ))
1621 {
1622 swap_to = !strcmp( de->d_name, "." ) ? 0 : 1;
1623 data_buffer_changed = FALSE;
1624
1625 filename = read_first_dent_name( swap_to, fd, second_entry_pos, de_first_two,
1626 data, size, &data_buffer_changed );
1627 if (filename != NULL && (!strcmp( filename, "." ) || !strcmp( filename, ".." )))
1628 filename = read_first_dent_name( swap_to ^ 1, fd, second_entry_pos, NULL,
1629 data, size, &data_buffer_changed );
1630 if (data_buffer_changed)
1631 {
1632 lseek( fd, next_pos, SEEK_SET );
1633 res = 0;
1634 }
1635 }
1636 else if (de->d_ino)
1637 filename = de->d_name;
1638
1639 if (filename && (info = append_entry( buffer, io, length, filename, NULL, mask, class )))
1640 {
1641 last_info = info;
1642 if (io->u.Status == STATUS_BUFFER_OVERFLOW)
1643 {
1644 lseek( fd, old_pos, SEEK_SET ); /* restore pos to previous entry */
1645 break;
1646 }
1647 /* check if we still have enough space for the largest possible entry */
1648 if (single_entry || io->Information + max_dir_info_size(class) > length)
1649 {
1650 if (res > 0) lseek( fd, next_pos, SEEK_SET ); /* set pos to next entry */
1651 break;
1652 }
1653 }
1654 old_pos = next_pos;
1655 /* move on to the next entry */
1656 if (res > 0) de = (KERNEL_DIRENT64 *)((char *)de + de->d_reclen);
1657 else
1658 {
1659 res = getdents64( fd, data, size );
1660 de = (KERNEL_DIRENT64 *)data;
1661 de_first_two = NULL;
1662 }
1663 }
1664
1665 if (last_info) last_info->next = 0;
1666 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1667 res = 0;
1668 done:
1669 if (data != local_buffer) RtlFreeHeap( GetProcessHeap(), 0, data );
1670 return res;
1671 }
1672
1673 #elif defined HAVE_GETDIRENTRIES
1674
1675 #ifdef _DARWIN_FEATURE_64_BIT_INODE
1676
1677 /* Darwin doesn't provide a version of getdirentries with support for 64-bit
1678 * inodes. When 64-bit inodes are enabled, the getdirentries symbol is mapped
1679 * to _getdirentries_is_not_available_when_64_bit_inodes_are_in_effect so that
1680 * we get link errors if we try to use it. We still need getdirentries, but we
1681 * don't need it to support 64-bit inodes. So, we use the legacy getdirentries
1682 * with 32-bit inodes. We have to be careful to use a corresponding dirent
1683 * structure, too.
1684 */
1685 int darwin_legacy_getdirentries(int, char *, int, long *) __asm("_getdirentries");
1686 #define getdirentries darwin_legacy_getdirentries
1687
1688 struct darwin_legacy_dirent {
1689 __uint32_t d_ino;
1690 __uint16_t d_reclen;
1691 __uint8_t d_type;
1692 __uint8_t d_namlen;
1693 char d_name[__DARWIN_MAXNAMLEN + 1];
1694 };
1695 #define dirent darwin_legacy_dirent
1696
1697 #endif
1698
1699 /***********************************************************************
1700 * wine_getdirentries
1701 *
1702 * Wrapper for the BSD getdirentries system call to fix a bug in the
1703 * Mac OS X version. For some file systems (at least Apple Filing
1704 * Protocol a.k.a. AFP), getdirentries resets the file position to 0
1705 * when it's about to return 0 (no more entries). So, a subsequent
1706 * getdirentries call starts over at the beginning again, causing an
1707 * infinite loop.
1708 */
1709 static inline int wine_getdirentries(int fd, char *buf, int nbytes, long *basep)
1710 {
1711 int res = getdirentries(fd, buf, nbytes, basep);
1712 #ifdef __APPLE__
1713 if (res == 0)
1714 lseek(fd, *basep, SEEK_SET);
1715 #endif
1716 return res;
1717 }
1718
1719 static inline int dir_reclen(struct dirent *de)
1720 {
1721 #ifdef HAVE_STRUCT_DIRENT_D_RECLEN
1722 return de->d_reclen;
1723 #else
1724 return _DIRENT_RECLEN(de->d_namlen);
1725 #endif
1726 }
1727
1728 /***********************************************************************
1729 * read_directory_getdirentries
1730 *
1731 * Read a directory using the BSD getdirentries system call; helper for NtQueryDirectoryFile.
1732 */
1733 static int read_directory_getdirentries( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1734 BOOLEAN single_entry, const UNICODE_STRING *mask,
1735 BOOLEAN restart_scan, FILE_INFORMATION_CLASS class )
1736 {
1737 long restart_pos;
1738 ULONG_PTR restart_info_pos = 0;
1739 size_t size, initial_size = length;
1740 int res, fake_dot_dot = 1;
1741 char *data, local_buffer[8192];
1742 struct dirent *de;
1743 union file_directory_info *info, *last_info = NULL, *restart_last_info = NULL;
1744
1745 size = initial_size;
1746 data = local_buffer;
1747 if (size > sizeof(local_buffer) && !(data = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1748 {
1749 io->u.Status = STATUS_NO_MEMORY;
1750 return io->u.Status;
1751 }
1752
1753 if (restart_scan) lseek( fd, 0, SEEK_SET );
1754
1755 io->u.Status = STATUS_SUCCESS;
1756
1757 /* FIXME: should make sure size is larger than filesystem block size */
1758 res = wine_getdirentries( fd, data, size, &restart_pos );
1759 if (res == -1)
1760 {
1761 io->u.Status = FILE_GetNtStatus();
1762 res = 0;
1763 goto done;
1764 }
1765
1766 de = (struct dirent *)data;
1767
1768 if (restart_scan)
1769 {
1770 /* check if we got . and .. from getdirentries */
1771 if (res > 0)
1772 {
1773 if (!strcmp( de->d_name, "." ) && res > dir_reclen(de))
1774 {
1775 struct dirent *next_de = (struct dirent *)(data + dir_reclen(de));
1776 if (!strcmp( next_de->d_name, ".." )) fake_dot_dot = 0;
1777 }
1778 }
1779 /* make sure we have enough room for both entries */
1780 if (fake_dot_dot)
1781 {
1782 const ULONG min_info_size = dir_info_size( class, 1 ) + dir_info_size( class, 2 );
1783 if (length < min_info_size || single_entry)
1784 {
1785 FIXME( "not enough room %u/%u for fake . and .. entries\n", length, single_entry );
1786 fake_dot_dot = 0;
1787 }
1788 }
1789
1790 if (fake_dot_dot)
1791 {
1792 if ((info = append_entry( buffer, io, length, ".", NULL, mask, class )))
1793 last_info = info;
1794 if ((info = append_entry( buffer, io, length, "..", NULL, mask, class )))
1795 last_info = info;
1796
1797 restart_last_info = last_info;
1798 restart_info_pos = io->Information;
1799
1800 /* check if we still have enough space for the largest possible entry */
1801 if (last_info && io->Information + max_dir_info_size(class) > length)
1802 {
1803 lseek( fd, 0, SEEK_SET ); /* reset pos to first entry */
1804 res = 0;
1805 }
1806 }
1807 }
1808
1809 while (res > 0)
1810 {
1811 res -= dir_reclen(de);
1812 if (de->d_fileno &&
1813 !(fake_dot_dot && (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." ))) &&
1814 ((info = append_entry( buffer, io, length, de->d_name, NULL, mask, class ))))
1815 {
1816 last_info = info;
1817 if (io->u.Status == STATUS_BUFFER_OVERFLOW)
1818 {
1819 lseek( fd, (unsigned long)restart_pos, SEEK_SET );
1820 if (restart_info_pos) /* if we have a complete read already, return it */
1821 {
1822 io->u.Status = STATUS_SUCCESS;
1823 io->Information = restart_info_pos;
1824 last_info = restart_last_info;
1825 break;
1826 }
1827 /* otherwise restart from the start with a smaller size */
1828 size = (char *)de - data;
1829 if (!size) break;
1830 io->Information = 0;
1831 last_info = NULL;
1832 goto restart;
1833 }
1834 if (!has_wildcard( mask )) break;
1835 /* if we have to return but the buffer contains more data, restart with a smaller size */
1836 if (res > 0 && (single_entry || io->Information + max_dir_info_size(class) > length))
1837 {
1838 lseek( fd, (unsigned long)restart_pos, SEEK_SET );
1839 size = (char *)de + dir_reclen(de) - data;
1840 io->Information = restart_info_pos;
1841 last_info = restart_last_info;
1842 goto restart;
1843 }
1844 }
1845 /* move on to the next entry */
1846 if (res > 0)
1847 {
1848 de = (struct dirent *)((char *)de + dir_reclen(de));
1849 continue;
1850 }
1851 if (size < initial_size) break; /* already restarted once, give up now */
1852 restart_last_info = last_info;
1853 restart_info_pos = io->Information;
1854 restart:
1855 res = wine_getdirentries( fd, data, size, &restart_pos );
1856 de = (struct dirent *)data;
1857 }
1858
1859 if (last_info) last_info->next = 0;
1860 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1861 res = 0;
1862 done:
1863 if (data != local_buffer) RtlFreeHeap( GetProcessHeap(), 0, data );
1864 return res;
1865 }
1866
1867 #ifdef _DARWIN_FEATURE_64_BIT_INODE
1868 #undef getdirentries
1869 #undef dirent
1870 #endif
1871
1872 #endif /* HAVE_GETDIRENTRIES */
1873
1874
1875 /***********************************************************************
1876 * read_directory_readdir
1877 *
1878 * Read a directory using the POSIX readdir interface; helper for NtQueryDirectoryFile.
1879 */
1880 static void read_directory_readdir( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1881 BOOLEAN single_entry, const UNICODE_STRING *mask,
1882 BOOLEAN restart_scan, FILE_INFORMATION_CLASS class )
1883 {
1884 DIR *dir;
1885 off_t i, old_pos = 0;
1886 struct dirent *de;
1887 union file_directory_info *info, *last_info = NULL;
1888
1889 if (!(dir = opendir( "." )))
1890 {
1891 io->u.Status = FILE_GetNtStatus();
1892 return;
1893 }
1894
1895 if (!restart_scan)
1896 {
1897 old_pos = lseek( fd, 0, SEEK_CUR );
1898 /* skip the right number of entries */
1899 for (i = 0; i < old_pos - 2; i++)
1900 {
1901 if (!readdir( dir ))
1902 {
1903 closedir( dir );
1904 io->u.Status = STATUS_NO_MORE_FILES;
1905 return;
1906 }
1907 }
1908 }
1909 io->u.Status = STATUS_SUCCESS;
1910
1911 for (;;)
1912 {
1913 if (old_pos == 0)
1914 info = append_entry( buffer, io, length, ".", NULL, mask, class );
1915 else if (old_pos == 1)
1916 info = append_entry( buffer, io, length, "..", NULL, mask, class );
1917 else if ((de = readdir( dir )))
1918 {
1919 if (strcmp( de->d_name, "." ) && strcmp( de->d_name, ".." ))
1920 info = append_entry( buffer, io, length, de->d_name, NULL, mask, class );
1921 else
1922 info = NULL;
1923 }
1924 else
1925 break;
1926 old_pos++;
1927 if (info)
1928 {
1929 last_info = info;
1930 if (io->u.Status == STATUS_BUFFER_OVERFLOW)
1931 {
1932 old_pos--; /* restore pos to previous entry */
1933 break;
1934 }
1935 if (single_entry) break;
1936 /* check if we still have enough space for the largest possible entry */
1937 if (io->Information + max_dir_info_size(class) > length) break;
1938 }
1939 }
1940
1941 lseek( fd, old_pos, SEEK_SET ); /* store dir offset as filepos for fd */
1942 closedir( dir );
1943
1944 if (last_info) last_info->next = 0;
1945 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1946 }
1947
1948 /***********************************************************************
1949 * read_directory_stat
1950 *
1951 * Read a single file from a directory by determining whether the file
1952 * identified by mask exists using stat.
1953 */
1954 static int read_directory_stat( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1955 BOOLEAN single_entry, const UNICODE_STRING *mask,
1956 BOOLEAN restart_scan, FILE_INFORMATION_CLASS class )
1957 {
1958 int unix_len, ret, used_default;
1959 char *unix_name;
1960 struct stat st;
1961
1962 TRACE("trying optimisation for file %s\n", debugstr_us( mask ));
1963
1964 unix_len = ntdll_wcstoumbs( 0, mask->Buffer, mask->Length / sizeof(WCHAR), NULL, 0, NULL, NULL );
1965 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len + 1)))
1966 {
1967 io->u.Status = STATUS_NO_MEMORY;
1968 return 0;
1969 }
1970 ret = ntdll_wcstoumbs( 0, mask->Buffer, mask->Length / sizeof(WCHAR), unix_name, unix_len,
1971 NULL, &used_default );
1972 if (ret > 0 && !used_default)
1973 {
1974 unix_name[ret] = 0;
1975 if (restart_scan)
1976 {
1977 lseek( fd, 0, SEEK_SET );
1978 }
1979 else if (lseek( fd, 0, SEEK_CUR ) != 0)
1980 {
1981 io->u.Status = STATUS_NO_MORE_FILES;
1982 ret = 0;
1983 goto done;
1984 }
1985
1986 ret = stat( unix_name, &st );
1987 if (!ret)
1988 {
1989 union file_directory_info *info = append_entry( buffer, io, length, unix_name, NULL, NULL, class );
1990 if (info)
1991 {
1992 info->next = 0;
1993 if (io->u.Status != STATUS_BUFFER_OVERFLOW) lseek( fd, 1, SEEK_CUR );
1994 }
1995 else io->u.Status = STATUS_NO_MORE_FILES;
1996 }
1997 }
1998 else ret = -1;
1999
2000 done:
2001 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2002
2003 TRACE("returning %d\n", ret);
2004
2005 return ret;
2006 }
2007
2008
2009 /******************************************************************************
2010 * NtQueryDirectoryFile [NTDLL.@]
2011 * ZwQueryDirectoryFile [NTDLL.@]
2012 */
2013 NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event,
2014 PIO_APC_ROUTINE apc_routine, PVOID apc_context,
2015 PIO_STATUS_BLOCK io,
2016 PVOID buffer, ULONG length,
2017 FILE_INFORMATION_CLASS info_class,
2018 BOOLEAN single_entry,
2019 PUNICODE_STRING mask,
2020 BOOLEAN restart_scan )
2021 {
2022 int cwd, fd, needs_close;
2023
2024 TRACE("(%p %p %p %p %p %p 0x%08x 0x%08x 0x%08x %s 0x%08x\n",
2025 handle, event, apc_routine, apc_context, io, buffer,
2026 length, info_class, single_entry, debugstr_us(mask),
2027 restart_scan);
2028
2029 if (event || apc_routine)
2030 {
2031 FIXME( "Unsupported yet option\n" );
2032 return io->u.Status = STATUS_NOT_IMPLEMENTED;
2033 }
2034 switch (info_class)
2035 {
2036 case FileDirectoryInformation:
2037 case FileBothDirectoryInformation:
2038 case FileFullDirectoryInformation:
2039 case FileIdBothDirectoryInformation:
2040 case FileIdFullDirectoryInformation:
2041 if (length < dir_info_size( info_class, 1 )) return io->u.Status = STATUS_INFO_LENGTH_MISMATCH;
2042 if (!buffer) return io->u.Status = STATUS_ACCESS_VIOLATION;
2043 break;
2044 default:
2045 FIXME( "Unsupported file info class %d\n", info_class );
2046 return io->u.Status = STATUS_NOT_IMPLEMENTED;
2047 }
2048
2049 if ((io->u.Status = server_get_unix_fd( handle, FILE_LIST_DIRECTORY, &fd, &needs_close, NULL, NULL )) != STATUS_SUCCESS)
2050 return io->u.Status;
2051
2052 io->Information = 0;
2053
2054 RtlRunOnceExecuteOnce( &init_once, init_options, NULL, NULL );
2055
2056 RtlEnterCriticalSection( &dir_section );
2057
2058 cwd = open( ".", O_RDONLY );
2059 if (fchdir( fd ) != -1)
2060 {
2061 struct stat st;
2062 fstat( fd, &st );
2063 curdir.dev = st.st_dev;
2064 curdir.ino = st.st_ino;
2065 #ifdef VFAT_IOCTL_READDIR_BOTH
2066 if ((read_directory_vfat( fd, io, buffer, length, single_entry,
2067 mask, restart_scan, info_class )) != -1) goto done;
2068 #endif
2069 if (!has_wildcard( mask ) &&
2070 read_directory_stat( fd, io, buffer, length, single_entry,
2071 mask, restart_scan, info_class ) != -1) goto done;
2072 #ifdef USE_GETDENTS
2073 if ((read_directory_getdents( fd, io, buffer, length, single_entry,
2074 mask, restart_scan, info_class )) != -1) goto done;
2075 #elif defined HAVE_GETDIRENTRIES
2076 if ((read_directory_getdirentries( fd, io, buffer, length, single_entry,
2077 mask, restart_scan, info_class )) != -1) goto done;
2078 #endif
2079 read_directory_readdir( fd, io, buffer, length, single_entry, mask, restart_scan, info_class );
2080
2081 done:
2082 if (cwd == -1 || fchdir( cwd ) == -1) chdir( "/" );
2083 }
2084 else io->u.Status = FILE_GetNtStatus();
2085
2086 RtlLeaveCriticalSection( &dir_section );
2087
2088 if (needs_close) close( fd );
2089 if (cwd != -1) close( cwd );
2090 TRACE( "=> %x (%ld)\n", io->u.Status, io->Information );
2091 return io->u.Status;
2092 }
2093
2094
2095 /***********************************************************************
2096 * find_file_in_dir
2097 *
2098 * Find a file in a directory the hard way, by doing a case-insensitive search.
2099 * The file found is appended to unix_name at pos.
2100 * There must be at least MAX_DIR_ENTRY_LEN+2 chars available at pos.
2101 */
2102 static NTSTATUS find_file_in_dir( char *unix_name, int pos, const WCHAR *name, int length,
2103 BOOLEAN check_case, BOOLEAN *is_win_dir )
2104 {
2105 WCHAR buffer[MAX_DIR_ENTRY_LEN];
2106 UNICODE_STRING str;
2107 BOOLEAN spaces, is_name_8_dot_3;
2108 DIR *dir;
2109 struct dirent *de;
2110 struct stat st;
2111 int ret, used_default;
2112
2113 /* try a shortcut for this directory */
2114
2115 unix_name[pos++] = '/';
2116 ret = ntdll_wcstoumbs( 0, name, length, unix_name + pos, MAX_DIR_ENTRY_LEN,
2117 NULL, &used_default );
2118 /* if we used the default char, the Unix name won't round trip properly back to Unicode */
2119 /* so it cannot match the file we are looking for */
2120 if (ret >= 0 && !used_default)
2121 {
2122 unix_name[pos + ret] = 0;
2123 if (!stat( unix_name, &st ))
2124 {
2125 if (is_win_dir) *is_win_dir = is_same_file( &windir, &st );
2126 return STATUS_SUCCESS;
2127 }
2128 }
2129 if (check_case) goto not_found; /* we want an exact match */
2130
2131 if (pos > 1) unix_name[pos - 1] = 0;
2132 else unix_name[1] = 0; /* keep the initial slash */
2133
2134 /* check if it fits in 8.3 so that we don't look for short names if we won't need them */
2135
2136 str.Buffer = (WCHAR *)name;
2137 str.Length = length * sizeof(WCHAR);
2138 str.MaximumLength = str.Length;
2139 is_name_8_dot_3 = RtlIsNameLegalDOS8Dot3( &str, NULL, &spaces ) && !spaces;
2140
2141 if (!is_name_8_dot_3 && !get_dir_case_sensitivity( unix_name )) goto not_found;
2142
2143 /* now look for it through the directory */
2144
2145 #ifdef VFAT_IOCTL_READDIR_BOTH
2146 if (is_name_8_dot_3)
2147 {
2148 int fd = open( unix_name, O_RDONLY | O_DIRECTORY );
2149 if (fd != -1)
2150 {
2151 KERNEL_DIRENT *kde;
2152
2153 RtlEnterCriticalSection( &dir_section );
2154 if ((kde = start_vfat_ioctl( fd )))
2155 {
2156 unix_name[pos - 1] = '/';
2157 while (kde[0].d_reclen)
2158 {
2159 /* make sure names are null-terminated to work around an x86-64 kernel bug */
2160 size_t len = min(kde[0].d_reclen, sizeof(kde[0].d_name) - 1 );
2161 kde[0].d_name[len] = 0;
2162 len = min(kde[1].d_reclen, sizeof(kde[1].d_name) - 1 );
2163 kde[1].d_name[len] = 0;
2164
2165 if (kde[1].d_name[0])
2166 {
2167 ret = ntdll_umbstowcs( 0, kde[1].d_name, strlen(kde[1].d_name),
2168 buffer, MAX_DIR_ENTRY_LEN );
2169 if (ret == length && !memicmpW( buffer, name, length))
2170 {
2171 strcpy( unix_name + pos, kde[1].d_name );
2172 RtlLeaveCriticalSection( &dir_section );
2173 close( fd );
2174 goto success;
2175 }
2176 }
2177 ret = ntdll_umbstowcs( 0, kde[0].d_name, strlen(kde[0].d_name),
2178 buffer, MAX_DIR_ENTRY_LEN );
2179 if (ret == length && !memicmpW( buffer, name, length))
2180 {
2181 strcpy( unix_name + pos,
2182 kde[1].d_name[0] ? kde[1].d_name : kde[0].d_name );
2183 RtlLeaveCriticalSection( &dir_section );
2184 close( fd );
2185 goto success;
2186 }
2187 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)kde ) == -1)
2188 {
2189 RtlLeaveCriticalSection( &dir_section );
2190 close( fd );
2191 goto not_found;
2192 }
2193 }
2194 }
2195 RtlLeaveCriticalSection( &dir_section );
2196 close( fd );
2197 }
2198 /* fall through to normal handling */
2199 }
2200 #endif /* VFAT_IOCTL_READDIR_BOTH */
2201
2202 if (!(dir = opendir( unix_name )))
2203 {
2204 if (errno == ENOENT) return STATUS_OBJECT_PATH_NOT_FOUND;
2205 else return FILE_GetNtStatus();
2206 }
2207 unix_name[pos - 1] = '/';
2208 str.Buffer = buffer;
2209 str.MaximumLength = sizeof(buffer);
2210 while ((de = readdir( dir )))
2211 {
2212 ret = ntdll_umbstowcs( 0, de->d_name, strlen(de->d_name), buffer, MAX_DIR_ENTRY_LEN );
2213 if (ret == length && !memicmpW( buffer, name, length ))
2214 {
2215 strcpy( unix_name + pos, de->d_name );
2216 closedir( dir );
2217 goto success;
2218 }
2219
2220 if (!is_name_8_dot_3) continue;
2221
2222 str.Length = ret * sizeof(WCHAR);
2223 if (!RtlIsNameLegalDOS8Dot3( &str, NULL, &spaces ) || spaces)
2224 {
2225 WCHAR short_nameW[12];
2226 ret = hash_short_file_name( &str, short_nameW );
2227 if (ret == length && !memicmpW( short_nameW, name, length ))
2228 {
2229 strcpy( unix_name + pos, de->d_name );
2230 closedir( dir );
2231 goto success;
2232 }
2233 }
2234 }
2235 closedir( dir );
2236
2237 not_found:
2238 unix_name[pos - 1] = 0;
2239 return STATUS_OBJECT_PATH_NOT_FOUND;
2240
2241 success:
2242 if (is_win_dir && !stat( unix_name, &st )) *is_win_dir = is_same_file( &windir, &st );
2243 return STATUS_SUCCESS;
2244 }
2245
2246
2247 #ifndef _WIN64
2248
2249 static const WCHAR catrootW[] = {'s','y','s','t','e','m','3','2','\\','c','a','t','r','o','o','t',0};
2250 static const WCHAR catroot2W[] = {'s','y','s','t','e','m','3','2','\\','c','a','t','r','o','o','t','2',0};
2251 static const WCHAR driversstoreW[] = {'s','y','s','t','e','m','3','2','\\','d','r','i','v','e','r','s','s','t','o','r','e',0};
2252 static const WCHAR driversetcW[] = {'s','y','s','t','e','m','3','2','\\','d','r','i','v','e','r','s','\\','e','t','c',0};
2253 static const WCHAR logfilesW[] = {'s','y','s','t','e','m','3','2','\\','l','o','g','f','i','l','e','s',0};
2254 static const WCHAR spoolW[] = {'s','y','s','t','e','m','3','2','\\','s','p','o','o','l',0};
2255 static const WCHAR system32W[] = {'s','y','s','t','e','m','3','2',0};
2256 static const WCHAR syswow64W[] = {'s','y','s','w','o','w','6','4',0};
2257 static const WCHAR sysnativeW[] = {'s','y','s','n','a','t','i','v','e',0};
2258 static const WCHAR regeditW[] = {'r','e','g','e','d','i','t','.','e','x','e',0};
2259 static const WCHAR wow_regeditW[] = {'s','y','s','w','o','w','6','4','\\','r','e','g','e','d','i','t','.','e','x','e',0};
2260
2261 static struct
2262 {
2263 const WCHAR *source;
2264 const WCHAR *dos_target;
2265 const char *unix_target;
2266 } redirects[] =
2267 {
2268 { catrootW, NULL, NULL },
2269 { catroot2W, NULL, NULL },
2270 { driversstoreW, NULL, NULL },
2271 { driversetcW, NULL, NULL },
2272 { logfilesW, NULL, NULL },
2273 { spoolW, NULL, NULL },
2274 { system32W, syswow64W, NULL },
2275 { sysnativeW, system32W, NULL },
2276 { regeditW, wow_regeditW, NULL }
2277 };
2278
2279 static unsigned int nb_redirects;
2280
2281
2282 /***********************************************************************
2283 * get_redirect_target
2284 *
2285 * Find the target unix name for a redirected dir.
2286 */
2287 static const char *get_redirect_target( const char *windows_dir, const WCHAR *name )
2288 {
2289 int used_default, len, pos, win_len = strlen( windows_dir );
2290 char *unix_name, *unix_target = NULL;
2291 NTSTATUS status;
2292
2293 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, win_len + MAX_DIR_ENTRY_LEN + 2 )))
2294 return NULL;
2295 memcpy( unix_name, windows_dir, win_len );
2296 pos = win_len;
2297
2298 while (*name)
2299 {
2300 const WCHAR *end, *next;
2301
2302 for (end = name; *end; end++) if (IS_SEPARATOR(*end)) break;
2303 for (next = end; *next; next++) if (!IS_SEPARATOR(*next)) break;
2304
2305 status = find_file_in_dir( unix_name, pos, name, end - name, FALSE, NULL );
2306 if (status == STATUS_OBJECT_PATH_NOT_FOUND && !*next) /* not finding last element is ok */
2307 {
2308 len = ntdll_wcstoumbs( 0, name, end - name, unix_name + pos + 1,
2309 MAX_DIR_ENTRY_LEN - (pos - win_len), NULL, &used_default );
2310 if (len > 0 && !used_default)
2311 {
2312 unix_name[pos] = '/';
2313 pos += len + 1;
2314 unix_name[pos] = 0;
2315 break;
2316 }
2317 }
2318 if (status) goto done;
2319 pos += strlen( unix_name + pos );
2320 name = next;
2321 }
2322
2323 if ((unix_target = RtlAllocateHeap( GetProcessHeap(), 0, pos - win_len )))
2324 memcpy( unix_target, unix_name + win_len + 1, pos - win_len );
2325
2326 done:
2327 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2328 return unix_target;
2329 }
2330
2331
2332 /***********************************************************************
2333 * init_redirects
2334 */
2335 static void init_redirects(void)
2336 {
2337 UNICODE_STRING nt_name;
2338 ANSI_STRING unix_name;
2339 NTSTATUS status;
2340 struct stat st;
2341 unsigned int i;
2342
2343 if (!RtlDosPathNameToNtPathName_U( user_shared_data->NtSystemRoot, &nt_name, NULL, NULL ))
2344 {
2345 ERR( "can't convert %s\n", debugstr_w(user_shared_data->NtSystemRoot) );
2346 return;
2347 }
2348 status = wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN_IF, FALSE );
2349 RtlFreeUnicodeString( &nt_name );
2350 if (status)
2351 {
2352 ERR( "cannot open %s (%x)\n", debugstr_w(user_shared_data->NtSystemRoot), status );
2353 return;
2354 }
2355 if (!stat( unix_name.Buffer, &st ))
2356 {
2357 windir.dev = st.st_dev;
2358 windir.ino = st.st_ino;
2359 nb_redirects = sizeof(redirects) / sizeof(redirects[0]);
2360 for (i = 0; i < nb_redirects; i++)
2361 {
2362 if (!redirects[i].dos_target) continue;
2363 redirects[i].unix_target = get_redirect_target( unix_name.Buffer, redirects[i].dos_target );
2364 TRACE( "%s -> %s\n", debugstr_w(redirects[i].source), redirects[i].unix_target );
2365 }
2366 }
2367 RtlFreeAnsiString( &unix_name );
2368
2369 }
2370
2371
2372 /***********************************************************************
2373 * match_redirect
2374 *
2375 * Check if path matches a redirect name. If yes, return matched length.
2376 */
2377 static int match_redirect( const WCHAR *path, int len, const WCHAR *redir, BOOLEAN check_case )
2378 {
2379 int i = 0;
2380
2381 while (i < len && *redir)
2382 {
2383 if (IS_SEPARATOR(path[i]))
2384 {
2385 if (*redir++ != '\\') return 0;
2386 while (i < len && IS_SEPARATOR(path[i])) i++;
2387 continue; /* move on to next path component */
2388 }
2389 else if (check_case)
2390 {
2391 if (path[i] != *redir) return 0;
2392 }
2393 else
2394 {
2395 if (tolowerW(path[i]) != tolowerW(*redir)) return 0;
2396 }
2397 i++;
2398 redir++;
2399 }
2400 if (*redir) return 0;
2401 if (i < len && !IS_SEPARATOR(path[i])) return 0;
2402 while (i < len && IS_SEPARATOR(path[i])) i++;
2403 return i;
2404 }
2405
2406
2407 /***********************************************************************
2408 * get_redirect_path
2409 *
2410 * Retrieve the Unix path corresponding to a redirected path if any.
2411 */
2412 static int get_redirect_path( char *unix_name, int pos, const WCHAR *name, int length, BOOLEAN check_case )
2413 {
2414 unsigned int i;
2415 int len;
2416
2417 for (i = 0; i < nb_redirects; i++)
2418 {
2419 if ((len = match_redirect( name, length, redirects[i].source, check_case )))
2420 {
2421 if (!redirects[i].unix_target) break;
2422 unix_name[pos++] = '/';
2423 strcpy( unix_name + pos, redirects[i].unix_target );
2424 return len;
2425 }
2426 }
2427 return 0;
2428 }
2429
2430 #else /* _WIN64 */
2431
2432 /* there are no redirects on 64-bit */
2433
2434 static const unsigned int nb_redirects = 0;
2435
2436 static int get_redirect_path( char *unix_name, int pos, const WCHAR *name, int length, BOOLEAN check_case )
2437 {
2438 return 0;
2439 }
2440
2441 #endif
2442
2443 /***********************************************************************
2444 * DIR_init_windows_dir
2445 */
2446 void DIR_init_windows_dir( const WCHAR *win, const WCHAR *sys )
2447 {
2448 /* FIXME: should probably store paths as NT file names */
2449
2450 RtlCreateUnicodeString( &system_dir, sys );
2451
2452 #ifndef _WIN64
2453 if (is_wow64) init_redirects();
2454 #endif
2455 }
2456
2457
2458 /******************************************************************************
2459 * get_dos_device
2460 *
2461 * Get the Unix path of a DOS device.
2462 */
2463 static NTSTATUS get_dos_device( const WCHAR *name, UINT name_len, ANSI_STRING *unix_name_ret )
2464 {
2465 const char *config_dir = wine_get_config_dir();
2466 struct stat st;
2467 char *unix_name, *new_name, *dev;
2468 unsigned int i;
2469 int unix_len;
2470
2471 /* make sure the device name is ASCII */
2472 for (i = 0; i < name_len; i++)
2473 if (name[i] <= 32 || name[i] >= 127) return STATUS_BAD_DEVICE_TYPE;
2474
2475 unix_len = strlen(config_dir) + sizeof("/dosdevices/") + name_len + 1;
2476
2477 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len )))
2478 return STATUS_NO_MEMORY;
2479
2480 strcpy( unix_name, config_dir );
2481 strcat( unix_name, "/dosdevices/" );
2482 dev = unix_name + strlen(unix_name);
2483
2484 for (i = 0; i < name_len; i++) dev[i] = (char)tolowerW(name[i]);
2485 dev[i] = 0;
2486
2487 /* special case for drive devices */
2488 if (name_len == 2 && dev[1] == ':')
2489 {
2490 dev[i++] = ':';
2491 dev[i] = 0;
2492 }
2493
2494 for (;;)
2495 {
2496 if (!stat( unix_name, &st ))
2497 {
2498 TRACE( "%s -> %s\n", debugstr_wn(name,name_len), debugstr_a(unix_name) );
2499 unix_name_ret->Buffer = unix_name;
2500 unix_name_ret->Length = strlen(unix_name);
2501 unix_name_ret->MaximumLength = unix_len;
2502 return STATUS_SUCCESS;
2503 }
2504 if (!dev) break;
2505
2506 /* now try some defaults for it */
2507 if (!strcmp( dev, "aux" ))
2508 {
2509 strcpy( dev, "com1" );
2510 continue;
2511 }
2512 if (!strcmp( dev, "prn" ))
2513 {
2514 strcpy( dev, "lpt1" );
2515 continue;
2516 }
2517 if (!strcmp( dev, "nul" ))
2518 {
2519 strcpy( unix_name, "/dev/null" );
2520 dev = NULL; /* last try */
2521 continue;
2522 }
2523
2524 new_name = NULL;
2525 if (dev[1] == ':' && dev[2] == ':') /* drive device */
2526 {
2527 dev[2] = 0; /* remove last ':' to get the drive mount point symlink */
2528 new_name = get_default_drive_device( unix_name );
2529 }
2530 else if (!strncmp( dev, "com", 3 )) new_name = get_default_com_device( atoi(dev + 3 ));
2531 else if (!strncmp( dev, "lpt", 3 )) new_name = get_default_lpt_device( atoi(dev + 3 ));
2532
2533 if (!new_name) break;
2534
2535 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2536 unix_name = new_name;
2537 unix_len = strlen(unix_name) + 1;
2538 dev = NULL; /* last try */
2539 }
2540 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2541 return STATUS_BAD_DEVICE_TYPE;
2542 }
2543
2544
2545 /* return the length of the DOS namespace prefix if any */
2546 static inline int get_dos_prefix_len( const UNICODE_STRING *name )
2547 {
2548 static const WCHAR nt_prefixW[] = {'\\','?','?','\\'};
2549 static const WCHAR dosdev_prefixW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\'};
2550
2551 if (name->Length > sizeof(nt_prefixW) &&
2552 !memcmp( name->Buffer, nt_prefixW, sizeof(nt_prefixW) ))
2553 return sizeof(nt_prefixW) / sizeof(WCHAR);
2554
2555 if (name->Length > sizeof(dosdev_prefixW) &&
2556 !memicmpW( name->Buffer, dosdev_prefixW, sizeof(dosdev_prefixW)/sizeof(WCHAR) ))
2557 return sizeof(dosdev_prefixW) / sizeof(WCHAR);
2558
2559 return 0;
2560 }
2561
2562
2563 /******************************************************************************
2564 * find_file_id
2565 *
2566 * Recursively search directories from the dir queue for a given inode.
2567 */
2568 static NTSTATUS find_file_id( ANSI_STRING *unix_name, ULONGLONG file_id, dev_t dev )
2569 {
2570 unsigned int pos;
2571 DIR *dir;
2572 struct dirent *de;
2573 NTSTATUS status;
2574 struct stat st;
2575
2576 while (!(status = next_dir_in_queue( unix_name->Buffer )))
2577 {
2578 if (!(dir = opendir( unix_name->Buffer ))) continue;
2579 TRACE( "searching %s for %s\n", unix_name->Buffer, wine_dbgstr_longlong(file_id) );
2580 pos = strlen( unix_name->Buffer );
2581 if (pos + MAX_DIR_ENTRY_LEN >= unix_name->MaximumLength/sizeof(WCHAR))
2582 {
2583 char *new = RtlReAllocateHeap( GetProcessHeap(), 0, unix_name->Buffer,
2584 unix_name->MaximumLength * 2 );
2585 if (!new)
2586 {
2587 closedir( dir );
2588 return STATUS_NO_MEMORY;
2589 }
2590 unix_name->MaximumLength *= 2;
2591 unix_name->Buffer = new;
2592 }
2593 unix_name->Buffer[pos++] = '/';
2594 while ((de = readdir( dir )))
2595 {
2596 if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
2597 strcpy( unix_name->Buffer + pos, de->d_name );
2598 if (lstat( unix_name->Buffer, &st ) == -1) continue;
2599 if (st.st_dev != dev) continue;
2600 if (st.st_ino == file_id)
2601 {
2602 closedir( dir );
2603 return STATUS_SUCCESS;
2604 }
2605 if (!S_ISDIR( st.st_mode )) continue;
2606 if ((status = add_dir_to_queue( unix_name->Buffer )) != STATUS_SUCCESS)
2607 {
2608 closedir( dir );
2609 return status;
2610 }
2611 }
2612 closedir( dir );
2613 }
2614 return status;
2615 }
2616
2617
2618 /******************************************************************************
2619 * file_id_to_unix_file_name
2620 *
2621 * Lookup a file from its file id instead of its name.
2622 */
2623 NTSTATUS file_id_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, ANSI_STRING *unix_name )
2624 {
2625 enum server_fd_type type;
2626 int old_cwd, root_fd, needs_close;
2627 NTSTATUS status;
2628 ULONGLONG file_id;
2629 struct stat st, root_st;
2630
2631 if (attr->ObjectName->Length != sizeof(ULONGLONG)) return STATUS_OBJECT_PATH_SYNTAX_BAD;
2632 if (!attr->RootDirectory) return STATUS_INVALID_PARAMETER;
2633 memcpy( &file_id, attr->ObjectName->Buffer, sizeof(file_id) );
2634
2635 unix_name->MaximumLength = 2 * MAX_DIR_ENTRY_LEN + 4;
2636 if (!(unix_name->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, unix_name->MaximumLength )))
2637 return STATUS_NO_MEMORY;
2638 strcpy( unix_name->Buffer, "." );
2639
2640 if ((status = server_get_unix_fd( attr->RootDirectory, 0, &root_fd, &needs_close, &type, NULL )))
2641 goto done;
2642
2643 if (type != FD_TYPE_DIR)
2644 {
2645 status = STATUS_OBJECT_TYPE_MISMATCH;
2646 goto done;
2647 }
2648
2649 fstat( root_fd, &root_st );
2650 if (root_st.st_ino == file_id) /* shortcut for "." */
2651 {
2652 status = STATUS_SUCCESS;
2653 goto done;
2654 }
2655
2656 RtlEnterCriticalSection( &dir_section );
2657 if ((old_cwd = open( ".", O_RDONLY )) != -1 && fchdir( root_fd ) != -1)
2658 {
2659 /* shortcut for ".." */
2660 if (!stat( "..", &st ) && st.st_dev == root_st.st_dev && st.st_ino == file_id)
2661 {
2662 strcpy( unix_name->Buffer, ".." );
2663 status = STATUS_SUCCESS;
2664 }
2665 else
2666 {
2667 status = add_dir_to_queue( "." );
2668 if (!status)
2669 status = find_file_id( unix_name, file_id, root_st.st_dev );
2670 if (!status) /* get rid of "./" prefix */
2671 memmove( unix_name->Buffer, unix_name->Buffer + 2, strlen(unix_name->Buffer) - 1 );
2672 flush_dir_queue();
2673 }
2674 if (fchdir( old_cwd ) == -1) chdir( "/" );
2675 }
2676 else status = FILE_GetNtStatus();
2677 RtlLeaveCriticalSection( &dir_section );
2678 if (old_cwd != -1) close( old_cwd );
2679
2680 done:
2681 if (status == STATUS_SUCCESS)
2682 {
2683 TRACE( "%s -> %s\n", wine_dbgstr_longlong(file_id), debugstr_a(unix_name->Buffer) );
2684 unix_name->Length = strlen( unix_name->Buffer );
2685 }
2686 else
2687 {
2688 TRACE( "%s not found in dir %p\n", wine_dbgstr_longlong(file_id), attr->RootDirectory );
2689 RtlFreeHeap( GetProcessHeap(), 0, unix_name->Buffer );
2690 }
2691 if (needs_close) close( root_fd );
2692 return status;
2693 }
2694
2695
2696 /******************************************************************************
2697 * lookup_unix_name
2698 *
2699 * Helper for nt_to_unix_file_name
2700 */
2701 static NTSTATUS lookup_unix_name( const WCHAR *name, int name_len, char **buffer, int unix_len, int pos,
2702 UINT disposition, BOOLEAN check_case )
2703 {
2704 NTSTATUS status;
2705 int ret, used_default, len;
2706 struct stat st;
2707 char *unix_name = *buffer;
2708 const BOOL redirect = nb_redirects && ntdll_get_thread_data()->wow64_redir;
2709
2710 /* try a shortcut first */
2711
2712 ret = ntdll_wcstoumbs( 0, name, name_len, unix_name + pos, unix_len - pos - 1,
2713 NULL, &used_default );
2714
2715 while (name_len && IS_SEPARATOR(*name))
2716 {
2717 name++;
2718 name_len--;
2719 }
2720
2721 if (ret >= 0 && !used_default) /* if we used the default char the name didn't convert properly */
2722 {
2723 char *p;
2724 unix_name[pos + ret] = 0;
2725 for (p = unix_name + pos ; *p; p++) if (*p == '\\') *p = '/';
2726 if (!redirect || (!strstr( unix_name, "/windows/") && strncmp( unix_name, "windows/", 8 )))
2727 {
2728 if (!stat( unix_name, &st ))
2729 {
2730 /* creation fails with STATUS_ACCESS_DENIED for the root of the drive */
2731 if (disposition == FILE_CREATE)
2732 return name_len ? STATUS_OBJECT_NAME_COLLISION : STATUS_ACCESS_DENIED;
2733 return STATUS_SUCCESS;
2734 }
2735 }
2736 }
2737
2738 if (!name_len) /* empty name -> drive root doesn't exist */
2739 return STATUS_OBJECT_PATH_NOT_FOUND;
2740 if (check_case && !redirect && (disposition == FILE_OPEN || disposition == FILE_OVERWRITE))
2741 return STATUS_OBJECT_NAME_NOT_FOUND;
2742
2743 /* now do it component by component */
2744
2745 while (name_len)
2746 {
2747 const WCHAR *end, *next;
2748 BOOLEAN is_win_dir = FALSE;
2749
2750 end = name;
2751 while (end < name + name_len && !IS_SEPARATOR(*end)) end++;
2752 next = end;
2753 while (next < name + name_len && IS_SEPARATOR(*next)) next++;
2754 name_len -= next - name;
2755
2756 /* grow the buffer if needed */
2757
2758 if (unix_len - pos < MAX_DIR_ENTRY_LEN + 2)
2759 {
2760 char *new_name;
2761 unix_len += 2 * MAX_DIR_ENTRY_LEN;
2762 if (!(new_name = RtlReAllocateHeap( GetProcessHeap(), 0, unix_name, unix_len )))
2763 return STATUS_NO_MEMORY;
2764 unix_name = *buffer = new_name;
2765 }
2766
2767 status = find_file_in_dir( unix_name, pos, name, end - name,
2768 check_case, redirect ? &is_win_dir : NULL );
2769
2770 /* if this is the last element, not finding it is not necessarily fatal */
2771 if (!name_len)
2772 {
2773 if (status == STATUS_OBJECT_PATH_NOT_FOUND)
2774 {
2775 status = STATUS_OBJECT_NAME_NOT_FOUND;
2776 if (disposition != FILE_OPEN && disposition != FILE_OVERWRITE)
2777 {
2778 ret = ntdll_wcstoumbs( 0, name, end - name, unix_name + pos + 1,
2779 MAX_DIR_ENTRY_LEN, NULL, &used_default );
2780 if (ret > 0 && !used_default)
2781 {
2782 unix_name[pos] = '/';
2783 unix_name[pos + 1 + ret] = 0;
2784 status = STATUS_NO_SUCH_FILE;
2785 break;
2786 }
2787 }
2788 }
2789 else if (status == STATUS_SUCCESS && disposition == FILE_CREATE)
2790 {
2791 status = STATUS_OBJECT_NAME_COLLISION;
2792 }
2793 }
2794
2795 if (status != STATUS_SUCCESS) break;
2796
2797 pos += strlen( unix_name + pos );
2798 name = next;
2799
2800 if (is_win_dir && (len = get_redirect_path( unix_name, pos, name, name_len, check_case )))
2801 {
2802 name += len;
2803 name_len -= len;
2804 pos += strlen( unix_name + pos );
2805 TRACE( "redirecting -> %s + %s\n", debugstr_a(unix_name), debugstr_w(name) );
2806 }
2807 }
2808
2809 return status;
2810 }
2811
2812
2813 /******************************************************************************
2814 * nt_to_unix_file_name_attr
2815 */
2816 NTSTATUS nt_to_unix_file_name_attr( const OBJECT_ATTRIBUTES *attr, ANSI_STRING *unix_name_ret,
2817 UINT disposition )
2818 {
2819 static const WCHAR invalid_charsW[] = { INVALID_NT_CHARS, 0 };
2820 enum server_fd_type type;
2821 int old_cwd, root_fd, needs_close;
2822 const WCHAR *name, *p;
2823 char *unix_name;
2824 int name_len, unix_len;
2825 NTSTATUS status;
2826 BOOLEAN check_case = !(attr->Attributes & OBJ_CASE_INSENSITIVE);
2827
2828 if (!attr->RootDirectory) /* without root dir fall back to normal lookup */
2829 return wine_nt_to_unix_file_name( attr->ObjectName, unix_name_ret, disposition, check_case );
2830
2831 name = attr->ObjectName->Buffer;
2832 name_len = attr->ObjectName->Length / sizeof(WCHAR);
2833
2834 if (name_len && IS_SEPARATOR(name[0])) return STATUS_INVALID_PARAMETER;
2835
2836 /* check for invalid characters */
2837 for (p = name; p < name + name_len; p++)
2838 if (*p < 32 || strchrW( invalid_charsW, *p )) return STATUS_OBJECT_NAME_INVALID;
2839
2840 unix_len = ntdll_wcstoumbs( 0, name, name_len, NULL, 0, NULL, NULL );
2841 unix_len += MAX_DIR_ENTRY_LEN + 3;
2842 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len )))
2843 return STATUS_NO_MEMORY;
2844 unix_name[0] = '.';
2845
2846 if (!(status = server_get_unix_fd( attr->RootDirectory, 0, &root_fd, &needs_close, &type, NULL )))
2847 {
2848 if (type != FD_TYPE_DIR)
2849 {
2850 if (needs_close) close( root_fd );
2851 status = STATUS_BAD_DEVICE_TYPE;
2852 }
2853 else
2854 {
2855 RtlEnterCriticalSection( &dir_section );
2856 if ((old_cwd = open( ".", O_RDONLY )) != -1 && fchdir( root_fd ) != -1)
2857 {
2858 status = lookup_unix_name( name, name_len, &unix_name, unix_len, 1,
2859 disposition, check_case );
2860 if (fchdir( old_cwd ) == -1) chdir( "/" );
2861 }
2862 else status = FILE_GetNtStatus();
2863 RtlLeaveCriticalSection( &dir_section );
2864 if (old_cwd != -1) close( old_cwd );
2865 if (needs_close) close( root_fd );
2866 }
2867 }
2868 else if (status == STATUS_OBJECT_TYPE_MISMATCH) status = STATUS_BAD_DEVICE_TYPE;
2869
2870 if (status == STATUS_SUCCESS || status == STATUS_NO_SUCH_FILE)
2871 {
2872 TRACE( "%s -> %s\n", debugstr_us(attr->ObjectName), debugstr_a(unix_name) );
2873 unix_name_ret->Buffer = unix_name;
2874 unix_name_ret->Length = strlen(unix_name);
2875 unix_name_ret->MaximumLength = unix_len;
2876 }
2877 else
2878 {
2879 TRACE( "%s not found in %s\n", debugstr_w(name), unix_name );
2880 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2881 }
2882 return status;
2883 }
2884
2885
2886 /******************************************************************************
2887 * wine_nt_to_unix_file_name (NTDLL.@) Not a Windows API
2888 *
2889 * Convert a file name from NT namespace to Unix namespace.
2890 *
2891 * If disposition is not FILE_OPEN or FILE_OVERWRITE, the last path
2892 * element doesn't have to exist; in that case STATUS_NO_SUCH_FILE is
2893 * returned, but the unix name is still filled in properly.
2894 */
2895 NTSTATUS CDECL wine_nt_to_unix_file_name( const UNICODE_STRING *nameW, ANSI_STRING *unix_name_ret,
2896 UINT disposition, BOOLEAN check_case )
2897 {
2898 static const WCHAR unixW[] = {'u','n','i','x'};
2899 static const WCHAR invalid_charsW[] = { INVALID_NT_CHARS, 0 };
2900
2901 NTSTATUS status = STATUS_SUCCESS;
2902 const char *config_dir = wine_get_config_dir();
2903 const WCHAR *name, *p;
2904 struct stat st;
2905 char *unix_name;
2906 int pos, ret, name_len, unix_len, prefix_len, used_default;
2907 WCHAR prefix[MAX_DIR_ENTRY_LEN];
2908 BOOLEAN is_unix = FALSE;
2909
2910 name = nameW->Buffer;
2911 name_len = nameW->Length / sizeof(WCHAR);
2912
2913 if (!name_len || !IS_SEPARATOR(name[0])) return STATUS_OBJECT_PATH_SYNTAX_BAD;
2914
2915 if (!(pos = get_dos_prefix_len( nameW )))
2916 return STATUS_BAD_DEVICE_TYPE; /* no DOS prefix, assume NT native name */
2917
2918 name += pos;
2919 name_len -= pos;
2920
2921 /* check for sub-directory */
2922 for (pos = 0; pos < name_len; pos++)
2923 {
2924 if (IS_SEPARATOR(name[pos])) break;
2925 if (name[pos] < 32 || strchrW( invalid_charsW, name[pos] ))
2926 return STATUS_OBJECT_NAME_INVALID;
2927 }
2928 if (pos > MAX_DIR_ENTRY_LEN)
2929 return STATUS_OBJECT_NAME_INVALID;
2930
2931 if (pos == name_len) /* no subdir, plain DOS device */
2932 return get_dos_device( name, name_len, unix_name_ret );
2933
2934 for (prefix_len = 0; prefix_len < pos; prefix_len++)
2935 prefix[prefix_len] = tolowerW(name[prefix_len]);
2936
2937 name += prefix_len;
2938 name_len -= prefix_len;
2939
2940 /* check for invalid characters (all chars except 0 are valid for unix) */
2941 is_unix = (prefix_len == 4 && !memcmp( prefix, unixW, sizeof(unixW) ));
2942 if (is_unix)
2943 {
2944 for (p = name; p < name + name_len; p++)
2945 if (!*p) return STATUS_OBJECT_NAME_INVALID;
2946 check_case = TRUE;
2947 }
2948 else
2949 {
2950 for (p = name; p < name + name_len; p++)
2951 if (*p < 32 || strchrW( invalid_charsW, *p )) return STATUS_OBJECT_NAME_INVALID;
2952 }
2953
2954 unix_len = ntdll_wcstoumbs( 0, prefix, prefix_len, NULL, 0, NULL, NULL );
2955 unix_len += ntdll_wcstoumbs( 0, name, name_len, NULL, 0, NULL, NULL );
2956 unix_len += MAX_DIR_ENTRY_LEN + 3;
2957 unix_len += strlen(config_dir) + sizeof("/dosdevices/");
2958 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len )))
2959 return STATUS_NO_MEMORY;
2960 strcpy( unix_name, config_dir );
2961 strcat( unix_name, "/dosdevices/" );
2962 pos = strlen(unix_name);
2963
2964 ret = ntdll_wcstoumbs( 0, prefix, prefix_len, unix_name + pos, unix_len - pos - 1,
2965 NULL, &used_default );
2966 if (!ret || used_default)
2967 {
2968 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2969 return STATUS_OBJECT_NAME_INVALID;
2970 }
2971 pos += ret;
2972
2973 /* check if prefix exists (except for DOS drives to avoid extra stat calls) */
2974
2975 if (prefix_len != 2 || prefix[1] != ':')
2976 {
2977 unix_name[pos] = 0;
2978 if (lstat( unix_name, &st ) == -1 && errno == ENOENT)
2979 {
2980 if (!is_unix)
2981 {
2982 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2983 return STATUS_BAD_DEVICE_TYPE;
2984 }
2985 pos = 0; /* fall back to unix root */
2986 }
2987 }
2988
2989 status = lookup_unix_name( name, name_len, &unix_name, unix_len, pos, disposition, check_case );
2990 if (status == STATUS_SUCCESS || status == STATUS_NO_SUCH_FILE)
2991 {
2992 TRACE( "%s -> %s\n", debugstr_us(nameW), debugstr_a(unix_name) );
2993 unix_name_ret->Buffer = unix_name;
2994 unix_name_ret->Length = strlen(unix_name);
2995 unix_name_ret->MaximumLength = unix_len;
2996 }
2997 else
2998 {
2999 TRACE( "%s not found in %s\n", debugstr_w(name), unix_name );
3000 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
3001 }
3002 return status;
3003 }
3004
3005
3006 /******************************************************************
3007 * RtlWow64EnableFsRedirection (NTDLL.@)
3008 */
3009 NTSTATUS WINAPI RtlWow64EnableFsRedirection( BOOLEAN enable )
3010 {
3011 if (!is_wow64) return STATUS_NOT_IMPLEMENTED;
3012 ntdll_get_thread_data()->wow64_redir = enable;
3013 return STATUS_SUCCESS;
3014 }
3015
3016
3017 /******************************************************************
3018 * RtlWow64EnableFsRedirectionEx (NTDLL.@)
3019 */
3020 NTSTATUS WINAPI RtlWow64EnableFsRedirectionEx( ULONG disable, ULONG *old_value )
3021 {
3022 if (!is_wow64) return STATUS_NOT_IMPLEMENTED;
3023 if (((ULONG_PTR)old_value >> 16) == 0) return STATUS_ACCESS_VIOLATION;
3024
3025 *old_value = !ntdll_get_thread_data()->wow64_redir;
3026 ntdll_get_thread_data()->wow64_redir = !disable;
3027 return STATUS_SUCCESS;
3028 }
3029
3030
3031 /******************************************************************
3032 * RtlDoesFileExists_U (NTDLL.@)
3033 */
3034 BOOLEAN WINAPI RtlDoesFileExists_U(LPCWSTR file_name)
3035 {
3036 UNICODE_STRING nt_name;
3037 FILE_BASIC_INFORMATION basic_info;
3038 OBJECT_ATTRIBUTES attr;
3039 BOOLEAN ret;
3040
3041 if (!RtlDosPathNameToNtPathName_U( file_name, &nt_name, NULL, NULL )) return FALSE;
3042
3043 attr.Length = sizeof(attr);
3044 attr.RootDirectory = 0;
3045 attr.ObjectName = &nt_name;
3046 attr.Attributes = OBJ_CASE_INSENSITIVE;
3047 attr.SecurityDescriptor = NULL;
3048 attr.SecurityQualityOfService = NULL;
3049
3050 ret = NtQueryAttributesFile(&attr, &basic_info) == STATUS_SUCCESS;
3051
3052 RtlFreeUnicodeString( &nt_name );
3053 return ret;
3054 }
3055
3056
3057 /***********************************************************************
3058 * DIR_unmount_device
3059 *
3060 * Unmount the specified device.
3061 */
3062 NTSTATUS DIR_unmount_device( HANDLE handle )
3063 {
3064 NTSTATUS status;
3065 int unix_fd, needs_close;
3066
3067 if (!(status = server_get_unix_fd( handle, 0, &unix_fd, &needs_close, NULL, NULL )))
3068 {
3069 struct stat st;
3070 char *mount_point = NULL;
3071
3072 if (fstat( unix_fd, &st ) == -1 || !is_valid_mounted_device( &st ))
3073 status = STATUS_INVALID_PARAMETER;
3074 else
3075 {
3076 if ((mount_point = get_device_mount_point( st.st_rdev )))
3077 {
3078 #ifdef __APPLE__
3079 static const char umount[] = "diskutil unmount >/dev/null 2>&1 ";
3080 #else
3081 static const char umount[] = "umount >/dev/null 2>&1 ";
3082 #endif
3083 char *cmd = RtlAllocateHeap( GetProcessHeap(), 0, strlen(mount_point)+sizeof(umount));
3084 if (cmd)
3085 {
3086 strcpy( cmd, umount );
3087 strcat( cmd, mount_point );
3088 system( cmd );
3089 RtlFreeHeap( GetProcessHeap(), 0, cmd );
3090 #ifdef linux
3091 /* umount will fail to release the loop device since we still have
3092 a handle to it, so we release it here */
3093 if (major(st.st_rdev) == LOOP_MAJOR) ioctl( unix_fd, 0x4c01 /*LOOP_CLR_FD*/, 0 );
3094 #endif
3095 }
3096 RtlFreeHeap( GetProcessHeap(), 0, mount_point );
3097 }
3098 }
3099 if (needs_close) close( unix_fd );
3100 }
3101 return status;
3102 }
3103
3104
3105 /******************************************************************************
3106 * DIR_get_unix_cwd
3107 *
3108 * Retrieve the Unix name of the current directory; helper for wine_unix_to_nt_file_name.
3109 * Returned value must be freed by caller.
3110 */
3111 NTSTATUS DIR_get_unix_cwd( char **cwd )
3112 {
3113 int old_cwd, unix_fd, needs_close;
3114 CURDIR *curdir;
3115 HANDLE handle;
3116 NTSTATUS status;
3117
3118 RtlAcquirePebLock();
3119
3120 if (NtCurrentTeb()->Tib.SubSystemTib) /* FIXME: hack */
3121 curdir = &((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir;
3122 else
3123 curdir = &NtCurrentTeb()->Peb->ProcessParameters->CurrentDirectory;
3124
3125 if (!(handle = curdir->Handle))
3126 {
3127 UNICODE_STRING dirW;
3128 OBJECT_ATTRIBUTES attr;
3129 IO_STATUS_BLOCK io;
3130
3131 if (!RtlDosPathNameToNtPathName_U( curdir->DosPath.Buffer, &dirW, NULL, NULL ))
3132 {
3133 status = STATUS_OBJECT_NAME_INVALID;
3134 goto done;
3135 }
3136 attr.Length = sizeof(attr);
3137 attr.RootDirectory = 0;
3138 attr.Attributes = OBJ_CASE_INSENSITIVE;
3139 attr.ObjectName = &dirW;
3140 attr.SecurityDescriptor = NULL;
3141 attr.SecurityQualityOfService = NULL;
3142
3143 status = NtOpenFile( &handle, 0, &attr, &io, 0,
3144 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
3145 RtlFreeUnicodeString( &dirW );
3146 if (status != STATUS_SUCCESS) goto done;
3147 }
3148
3149 if ((status = server_get_unix_fd( handle, 0, &unix_fd, &needs_close, NULL, NULL )) == STATUS_SUCCESS)
3150 {
3151 RtlEnterCriticalSection( &dir_section );
3152
3153 if ((old_cwd = open(".", O_RDONLY)) != -1 && fchdir( unix_fd ) != -1)
3154 {
3155 unsigned int size = 512;
3156
3157 for (;;)
3158 {
3159 if (!(*cwd = RtlAllocateHeap( GetProcessHeap(), 0, size )))
3160 {
3161 status = STATUS_NO_MEMORY;
3162 break;
3163 }
3164 if (getcwd( *cwd, size )) break;
3165 RtlFreeHeap( GetProcessHeap(), 0, *cwd );
3166 if (errno != ERANGE)
3167 {
3168 status = STATUS_OBJECT_PATH_INVALID;
3169 break;
3170 }
3171 size *= 2;
3172 }
3173 if (fchdir( old_cwd ) == -1) chdir( "/" );
3174 }
3175 else status = FILE_GetNtStatus();
3176
3177 RtlLeaveCriticalSection( &dir_section );
3178 if (old_cwd != -1) close( old_cwd );
3179 if (needs_close) close( unix_fd );
3180 }
3181 if (!curdir->Handle) NtClose( handle );
3182
3183 done:
3184 RtlReleasePebLock();
3185 return status;
3186 }
3187
3188 struct read_changes_info
3189 {
3190 HANDLE FileHandle;
3191 PVOID Buffer;
3192 ULONG BufferSize;
3193 PIO_APC_ROUTINE apc;
3194 void *apc_arg;
3195 };
3196
3197 /* callback for ioctl user APC */
3198 static void WINAPI read_changes_user_apc( void *arg, IO_STATUS_BLOCK *io, ULONG reserved )
3199 {
3200 struct read_changes_info *info = arg;
3201 if (info->apc) info->apc( info->apc_arg, io, reserved );
3202 RtlFreeHeap( GetProcessHeap(), 0, info );
3203 }
3204
3205 static NTSTATUS read_changes_apc( void *user, PIO_STATUS_BLOCK iosb, NTSTATUS status, void **apc )
3206 {
3207 struct read_changes_info *info = user;
3208 char data[PATH_MAX];
3209 NTSTATUS ret;
3210 int size;
3211
3212 SERVER_START_REQ( read_change )
3213 {
3214 req->handle = wine_server_obj_handle( info->FileHandle );
3215 wine_server_set_reply( req, data, PATH_MAX );
3216 ret = wine_server_call( req );
3217 size = wine_server_reply_size( reply );
3218 }
3219 SERVER_END_REQ;
3220
3221 if (ret == STATUS_SUCCESS && info->Buffer)
3222 {
3223 PFILE_NOTIFY_INFORMATION pfni = info->Buffer;
3224 int i, left = info->BufferSize;
3225 DWORD *last_entry_offset = NULL;
3226 struct filesystem_event *event = (struct filesystem_event*)data;
3227
3228 while (size && left >= sizeof(*pfni))
3229 {
3230 /* convert to an NT style path */
3231 for (i=0; i<event->len; i++)
3232 if (event->name[i] == '/')
3233 event->name[i] = '\\';
3234
3235 pfni->Action = event->action;
3236 pfni->FileNameLength = ntdll_umbstowcs( 0, event->name, event->len, pfni->FileName,
3237 (left - offsetof(FILE_NOTIFY_INFORMATION, FileName)) / sizeof(WCHAR));
3238 last_entry_offset = &pfni->NextEntryOffset;
3239
3240 if(pfni->FileNameLength == -1 || pfni->FileNameLength == -2)
3241 break;
3242
3243 i = offsetof(FILE_NOTIFY_INFORMATION, FileName[pfni->FileNameLength]);
3244 pfni->FileNameLength *= sizeof(WCHAR);
3245 pfni->NextEntryOffset = i;
3246 pfni = (FILE_NOTIFY_INFORMATION*)((char*)pfni + i);
3247 left -= i;
3248
3249 i = (offsetof(struct filesystem_event, name[event->len])
3250 + sizeof(int)-1) / sizeof(int) * sizeof(int);
3251 event = (struct filesystem_event*)((char*)event + i);
3252 size -= i;
3253 }
3254
3255 if (size)
3256 {
3257 ret = STATUS_NOTIFY_ENUM_DIR;
3258 size = 0;
3259 }
3260 else
3261 {
3262 *last_entry_offset = 0;
3263 size = info->BufferSize - left;
3264 }
3265 }
3266 else
3267 {
3268 ret = STATUS_NOTIFY_ENUM_DIR;
3269 size = 0;
3270 }
3271
3272 iosb->u.Status = ret;
3273 iosb->Information = size;
3274 *apc = read_changes_user_apc;
3275 return ret;
3276 }
3277
3278 #define FILE_NOTIFY_ALL ( \
3279 FILE_NOTIFY_CHANGE_FILE_NAME | \
3280 FILE_NOTIFY_CHANGE_DIR_NAME | \
3281 FILE_NOTIFY_CHANGE_ATTRIBUTES | \
3282 FILE_NOTIFY_CHANGE_SIZE | \
3283 FILE_NOTIFY_CHANGE_LAST_WRITE | \
3284 FILE_NOTIFY_CHANGE_LAST_ACCESS | \
3285 FILE_NOTIFY_CHANGE_CREATION | \
3286 FILE_NOTIFY_CHANGE_SECURITY )
3287
3288 /******************************************************************************
3289 * NtNotifyChangeDirectoryFile [NTDLL.@]
3290 */
3291 NTSTATUS WINAPI
3292 NtNotifyChangeDirectoryFile( HANDLE FileHandle, HANDLE Event,
3293 PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,
3294 PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer,
3295 ULONG BufferSize, ULONG CompletionFilter, BOOLEAN WatchTree )
3296 {
3297 struct read_changes_info *info;
3298 NTSTATUS status;
3299 ULONG_PTR cvalue = ApcRoutine ? 0 : (ULONG_PTR)ApcContext;
3300
3301 TRACE("%p %p %p %p %p %p %u %u %d\n",
3302 FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock,
3303 Buffer, BufferSize, CompletionFilter, WatchTree );
3304
3305 if (!IoStatusBlock)
3306 return STATUS_ACCESS_VIOLATION;
3307
3308 if (CompletionFilter == 0 || (CompletionFilter & ~FILE_NOTIFY_ALL))
3309 return STATUS_INVALID_PARAMETER;
3310
3311 info = RtlAllocateHeap( GetProcessHeap(), 0, sizeof *info );
3312 if (!info)
3313 return STATUS_NO_MEMORY;
3314
3315 info->FileHandle = FileHandle;
3316 info->Buffer = Buffer;
3317 info->BufferSize = BufferSize;
3318 info->apc = ApcRoutine;
3319 info->apc_arg = ApcContext;
3320
3321 SERVER_START_REQ( read_directory_changes )
3322 {
3323 req->filter = CompletionFilter;
3324 req->want_data = (Buffer != NULL);
3325 req->subtree = WatchTree;
3326 req->async.handle = wine_server_obj_handle( FileHandle );
3327 req->async.callback = wine_server_client_ptr( read_changes_apc );
3328 req->async.iosb = wine_server_client_ptr( IoStatusBlock );
3329 req->async.arg = wine_server_client_ptr( info );
3330 req->async.event = wine_server_obj_handle( Event );
3331 req->async.cvalue = cvalue;
3332 status = wine_server_call( req );
3333 }
3334 SERVER_END_REQ;
3335
3336 if (status != STATUS_PENDING)
3337 RtlFreeHeap( GetProcessHeap(), 0, info );
3338
3339 return status;
3340 }
Windows API implementation