?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Allow async i/o operations to send completion messages.
[wine/wine64.git] / dlls / ntdll / directory.c
blob689194900977b231682ae387d7e01a0af9d32524
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 <sys/types.h>
27 #include <dirent.h>
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <stdarg.h>
31 #include <string.h>
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <limits.h>
35 #ifdef HAVE_MNTENT_H
36 #include <mntent.h>
37 #endif
38 #ifdef HAVE_SYS_STAT_H
39 # include <sys/stat.h>
40 #endif
41 #ifdef HAVE_SYS_IOCTL_H
42 #include <sys/ioctl.h>
43 #endif
44 #ifdef HAVE_LINUX_IOCTL_H
45 #include <linux/ioctl.h>
46 #endif
47 #ifdef HAVE_LINUX_MAJOR_H
48 # include <linux/major.h>
49 #endif
50 #ifdef HAVE_SYS_PARAM_H
51 #include <sys/param.h>
52 #endif
53 #ifdef HAVE_SYS_MOUNT_H
54 #include <sys/mount.h>
55 #endif
56 #include <time.h>
57 #ifdef HAVE_UNISTD_H
58 # include <unistd.h>
59 #endif
60
61 #define NONAMELESSUNION
62 #define NONAMELESSSTRUCT
63 #include "ntstatus.h"
64 #define WIN32_NO_STATUS
65 #include "windef.h"
66 #include "winnt.h"
67 #include "thread.h"
68 #include "winternl.h"
69 #include "ntdll_misc.h"
70 #include "wine/unicode.h"
71 #include "wine/server.h"
72 #include "wine/library.h"
73 #include "wine/debug.h"
74
75 WINE_DEFAULT_DEBUG_CHANNEL(file);
76
77 /* just in case... */
78 #undef VFAT_IOCTL_READDIR_BOTH
79 #undef USE_GETDENTS
80
81 #ifdef linux
82
83 /* We want the real kernel dirent structure, not the libc one */
84 typedef struct
85 {
86 long d_ino;
87 long d_off;
88 unsigned short d_reclen;
89 char d_name[256];
90 } KERNEL_DIRENT;
91
92 /* Define the VFAT ioctl to get both short and long file names */
93 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, KERNEL_DIRENT [2] )
94
95 #ifndef O_DIRECTORY
96 # define O_DIRECTORY 0200000 /* must be directory */
97 #endif
98
99 #ifdef __i386__
100
101 typedef struct
102 {
103 ULONG64 d_ino;
104 LONG64 d_off;
105 unsigned short d_reclen;
106 unsigned char d_type;
107 char d_name[256];
108 } KERNEL_DIRENT64;
109
110 static inline int getdents64( int fd, char *de, unsigned int size )
111 {
112 int ret;
113 __asm__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
114 : "=a" (ret)
115 : "0" (220 /*NR_getdents64*/), "r" (fd), "c" (de), "d" (size)
116 : "memory" );
117 if (ret < 0)
118 {
119 errno = -ret;
120 ret = -1;
121 }
122 return ret;
123 }
124 #define USE_GETDENTS
125
126 #endif /* i386 */
127
128 #endif /* linux */
129
130 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
131 #define IS_SEPARATOR(ch) ((ch) == '\\' || (ch) == '/')
132
133 #define INVALID_NT_CHARS '*','?','<','>','|','"'
134 #define INVALID_DOS_CHARS INVALID_NT_CHARS,'+','=',',',';','[',']',' ','\345'
135
136 #define MAX_DIR_ENTRY_LEN 255 /* max length of a directory entry in chars */
137
138 static const unsigned int max_dir_info_size = FIELD_OFFSET( FILE_BOTH_DIR_INFORMATION, FileName[MAX_DIR_ENTRY_LEN] );
139
140 static int show_dot_files = -1;
141
142 /* at some point we may want to allow Winelib apps to set this */
143 static const int is_case_sensitive = FALSE;
144
145 static RTL_CRITICAL_SECTION dir_section;
146 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
147 {
148 0, 0, &dir_section,
149 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
150 0, 0, { (DWORD_PTR)(__FILE__ ": dir_section") }
151 };
152 static RTL_CRITICAL_SECTION dir_section = { &critsect_debug, -1, 0, 0, 0, 0 };
153
154
155 /* check if a given Unicode char is OK in a DOS short name */
156 static inline BOOL is_invalid_dos_char( WCHAR ch )
157 {
158 static const WCHAR invalid_chars[] = { INVALID_DOS_CHARS,'~','.',0 };
159 if (ch > 0x7f) return TRUE;
160 return strchrW( invalid_chars, ch ) != NULL;
161 }
162
163 /* check if the device can be a mounted volume */
164 static inline int is_valid_mounted_device( const struct stat *st )
165 {
166 #if defined(linux) || defined(__sun__)
167 return S_ISBLK( st->st_mode );
168 #else
169 /* disks are char devices on *BSD */
170 return S_ISCHR( st->st_mode );
171 #endif
172 }
173
174 /***********************************************************************
175 * get_default_com_device
176 *
177 * Return the default device to use for serial ports.
178 */
179 static char *get_default_com_device( int num )
180 {
181 char *ret = NULL;
182
183 if (!num || num > 9) return ret;
184 #ifdef linux
185 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/ttyS0") );
186 if (ret)
187 {
188 strcpy( ret, "/dev/ttyS0" );
189 ret[strlen(ret) - 1] = '0' + num - 1;
190 }
191 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
192 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/cuad0") );
193 if (ret)
194 {
195 strcpy( ret, "/dev/cuad0" );
196 ret[strlen(ret) - 1] = '0' + num - 1;
197 }
198 #else
199 FIXME( "no known default for device com%d\n", num );
200 #endif
201 return ret;
202 }
203
204
205 /***********************************************************************
206 * get_default_lpt_device
207 *
208 * Return the default device to use for parallel ports.
209 */
210 static char *get_default_lpt_device( int num )
211 {
212 char *ret = NULL;
213
214 if (!num || num > 9) return ret;
215 #ifdef linux
216 ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof("/dev/lp0") );
217 if (ret)
218 {
219 strcpy( ret, "/dev/lp0" );
220 ret[strlen(ret) - 1] = '0' + num - 1;
221 }
222 #else
223 FIXME( "no known default for device lpt%d\n", num );
224 #endif
225 return ret;
226 }
227
228
229 /***********************************************************************
230 * DIR_get_drives_info
231 *
232 * Retrieve device/inode number for all the drives. Helper for find_drive_root.
233 */
234 unsigned int DIR_get_drives_info( struct drive_info info[MAX_DOS_DRIVES] )
235 {
236 static struct drive_info cache[MAX_DOS_DRIVES];
237 static time_t last_update;
238 static unsigned int nb_drives;
239 unsigned int ret;
240 time_t now = time(NULL);
241
242 RtlEnterCriticalSection( &dir_section );
243 if (now != last_update)
244 {
245 const char *config_dir = wine_get_config_dir();
246 char *buffer, *p;
247 struct stat st;
248 unsigned int i;
249
250 if ((buffer = RtlAllocateHeap( GetProcessHeap(), 0,
251 strlen(config_dir) + sizeof("/dosdevices/a:") )))
252 {
253 strcpy( buffer, config_dir );
254 strcat( buffer, "/dosdevices/a:" );
255 p = buffer + strlen(buffer) - 2;
256
257 for (i = nb_drives = 0; i < MAX_DOS_DRIVES; i++)
258 {
259 *p = 'a' + i;
260 if (!stat( buffer, &st ))
261 {
262 cache[i].dev = st.st_dev;
263 cache[i].ino = st.st_ino;
264 nb_drives++;
265 }
266 else
267 {
268 cache[i].dev = 0;
269 cache[i].ino = 0;
270 }
271 }
272 RtlFreeHeap( GetProcessHeap(), 0, buffer );
273 }
274 last_update = now;
275 }
276 memcpy( info, cache, sizeof(cache) );
277 ret = nb_drives;
278 RtlLeaveCriticalSection( &dir_section );
279 return ret;
280 }
281
282
283 /***********************************************************************
284 * parse_mount_entries
285 *
286 * Parse mount entries looking for a given device. Helper for get_default_drive_device.
287 */
288
289 #ifdef sun
290 #include <sys/vfstab.h>
291 static char *parse_vfstab_entries( FILE *f, dev_t dev, ino_t ino)
292 {
293 struct vfstab entry;
294 struct stat st;
295 char *device;
296
297 while (! getvfsent( f, &entry ))
298 {
299 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
300 if (!strcmp( entry.vfs_fstype, "nfs" ) ||
301 !strcmp( entry.vfs_fstype, "smbfs" ) ||
302 !strcmp( entry.vfs_fstype, "ncpfs" )) continue;
303
304 if (stat( entry.vfs_mountp, &st ) == -1) continue;
305 if (st.st_dev != dev || st.st_ino != ino) continue;
306 if (!strcmp( entry.vfs_fstype, "fd" ))
307 {
308 if ((device = strstr( entry.vfs_mntopts, "dev=" )))
309 {
310 char *p = strchr( device + 4, ',' );
311 if (p) *p = 0;
312 return device + 4;
313 }
314 }
315 else
316 return entry.vfs_special;
317 }
318 return NULL;
319 }
320 #endif
321
322 #ifdef linux
323 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
324 {
325 struct mntent *entry;
326 struct stat st;
327 char *device;
328
329 while ((entry = getmntent( f )))
330 {
331 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
332 if (!strcmp( entry->mnt_type, "nfs" ) ||
333 !strcmp( entry->mnt_type, "smbfs" ) ||
334 !strcmp( entry->mnt_type, "ncpfs" )) continue;
335
336 if (stat( entry->mnt_dir, &st ) == -1) continue;
337 if (st.st_dev != dev || st.st_ino != ino) continue;
338 if (!strcmp( entry->mnt_type, "supermount" ))
339 {
340 if ((device = strstr( entry->mnt_opts, "dev=" )))
341 {
342 char *p = strchr( device + 4, ',' );
343 if (p) *p = 0;
344 return device + 4;
345 }
346 }
347 else if (!stat( entry->mnt_fsname, &st ) && S_ISREG(st.st_mode))
348 {
349 /* if device is a regular file check for a loop mount */
350 if ((device = strstr( entry->mnt_opts, "loop=" )))
351 {
352 char *p = strchr( device + 5, ',' );
353 if (p) *p = 0;
354 return device + 5;
355 }
356 }
357 else
358 return entry->mnt_fsname;
359 }
360 return NULL;
361 }
362 #endif
363
364 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
365 #include <fstab.h>
366 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
367 {
368 struct fstab *entry;
369 struct stat st;
370
371 while ((entry = getfsent()))
372 {
373 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
374 if (!strcmp( entry->fs_vfstype, "nfs" ) ||
375 !strcmp( entry->fs_vfstype, "smbfs" ) ||
376 !strcmp( entry->fs_vfstype, "ncpfs" )) continue;
377
378 if (stat( entry->fs_file, &st ) == -1) continue;
379 if (st.st_dev != dev || st.st_ino != ino) continue;
380 return entry->fs_spec;
381 }
382 return NULL;
383 }
384 #endif
385
386 #ifdef sun
387 #include <sys/mnttab.h>
388 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
389 {
390 struct mnttab entry;
391 struct stat st;
392 char *device;
393
394
395 while (( ! getmntent( f, &entry) ))
396 {
397 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
398 if (!strcmp( entry.mnt_fstype, "nfs" ) ||
399 !strcmp( entry.mnt_fstype, "smbfs" ) ||
400 !strcmp( entry.mnt_fstype, "ncpfs" )) continue;
401
402 if (stat( entry.mnt_mountp, &st ) == -1) continue;
403 if (st.st_dev != dev || st.st_ino != ino) continue;
404 if (!strcmp( entry.mnt_fstype, "fd" ))
405 {
406 if ((device = strstr( entry.mnt_mntopts, "dev=" )))
407 {
408 char *p = strchr( device + 4, ',' );
409 if (p) *p = 0;
410 return device + 4;
411 }
412 }
413 else
414 return entry.mnt_special;
415 }
416 return NULL;
417 }
418 #endif
419
420 /***********************************************************************
421 * get_default_drive_device
422 *
423 * Return the default device to use for a given drive mount point.
424 */
425 static char *get_default_drive_device( const char *root )
426 {
427 char *ret = NULL;
428
429 #ifdef linux
430 FILE *f;
431 char *device = NULL;
432 int fd, res = -1;
433 struct stat st;
434
435 /* try to open it first to force it to get mounted */
436 if ((fd = open( root, O_RDONLY | O_DIRECTORY )) != -1)
437 {
438 res = fstat( fd, &st );
439 close( fd );
440 }
441 /* now try normal stat just in case */
442 if (res == -1) res = stat( root, &st );
443 if (res == -1) return NULL;
444
445 RtlEnterCriticalSection( &dir_section );
446
447 if ((f = fopen( "/etc/mtab", "r" )))
448 {
449 device = parse_mount_entries( f, st.st_dev, st.st_ino );
450 endmntent( f );
451 }
452 /* look through fstab too in case it's not mounted (for instance if it's an audio CD) */
453 if (!device && (f = fopen( "/etc/fstab", "r" )))
454 {
455 device = parse_mount_entries( f, st.st_dev, st.st_ino );
456 endmntent( f );
457 }
458 if (device)
459 {
460 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(device) + 1 );
461 if (ret) strcpy( ret, device );
462 }
463 RtlLeaveCriticalSection( &dir_section );
464
465 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__ )
466 char *device = NULL;
467 int fd, res = -1;
468 struct stat st;
469
470 /* try to open it first to force it to get mounted */
471 if ((fd = open( root, O_RDONLY )) != -1)
472 {
473 res = fstat( fd, &st );
474 close( fd );
475 }
476 /* now try normal stat just in case */
477 if (res == -1) res = stat( root, &st );
478 if (res == -1) return NULL;
479
480 RtlEnterCriticalSection( &dir_section );
481
482 /* The FreeBSD parse_mount_entries doesn't require a file argument, so just
483 * pass NULL. Leave the argument in for symmetry.
484 */
485 device = parse_mount_entries( NULL, st.st_dev, st.st_ino );
486 if (device)
487 {
488 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(device) + 1 );
489 if (ret) strcpy( ret, device );
490 }
491 RtlLeaveCriticalSection( &dir_section );
492
493 #elif defined( sun )
494 FILE *f;
495 char *device = NULL;
496 int fd, res = -1;
497 struct stat st;
498
499 /* try to open it first to force it to get mounted */
500 if ((fd = open( root, O_RDONLY )) != -1)
501 {
502 res = fstat( fd, &st );
503 close( fd );
504 }
505 /* now try normal stat just in case */
506 if (res == -1) res = stat( root, &st );
507 if (res == -1) return NULL;
508
509 RtlEnterCriticalSection( &dir_section );
510
511 if ((f = fopen( "/etc/mnttab", "r" )))
512 {
513 device = parse_mount_entries( f, st.st_dev, st.st_ino);
514 fclose( f );
515 }
516 /* look through fstab too in case it's not mounted (for instance if it's an audio CD) */
517 if (!device && (f = fopen( "/etc/vfstab", "r" )))
518 {
519 device = parse_vfstab_entries( f, st.st_dev, st.st_ino );
520 fclose( f );
521 }
522 if (device)
523 {
524 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(device) + 1 );
525 if (ret) strcpy( ret, device );
526 }
527 RtlLeaveCriticalSection( &dir_section );
528
529 #elif defined(__APPLE__)
530 struct statfs *mntStat;
531 struct stat st;
532 int i;
533 int mntSize;
534 dev_t dev;
535 ino_t ino;
536 static const char path_bsd_device[] = "/dev/disk";
537 int res;
538
539 res = stat( root, &st );
540 if (res == -1) return NULL;
541
542 dev = st.st_dev;
543 ino = st.st_ino;
544
545 RtlEnterCriticalSection( &dir_section );
546
547 mntSize = getmntinfo(&mntStat, MNT_NOWAIT);
548
549 for (i = 0; i < mntSize && !ret; i++)
550 {
551 if (stat(mntStat[i].f_mntonname, &st ) == -1) continue;
552 if (st.st_dev != dev || st.st_ino != ino) continue;
553
554 /* FIXME add support for mounted network drive */
555 if ( strncmp(mntStat[i].f_mntfromname, path_bsd_device, strlen(path_bsd_device)) == 0)
556 {
557 /* set return value to the corresponding raw BSD node */
558 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(mntStat[i].f_mntfromname) + 2 /* 2 : r and \0 */ );
559 if (ret)
560 {
561 strcpy(ret, "/dev/r");
562 strcat(ret, mntStat[i].f_mntfromname+sizeof("/dev/")-1);
563 }
564 }
565 }
566 RtlLeaveCriticalSection( &dir_section );
567 #else
568 static int warned;
569 if (!warned++) FIXME( "auto detection of DOS devices not supported on this platform\n" );
570 #endif
571 return ret;
572 }
573
574
575 /***********************************************************************
576 * get_device_mount_point
577 *
578 * Return the current mount point for a device.
579 */
580 static char *get_device_mount_point( dev_t dev )
581 {
582 char *ret = NULL;
583
584 #ifdef linux
585 FILE *f;
586
587 RtlEnterCriticalSection( &dir_section );
588
589 if ((f = fopen( "/etc/mtab", "r" )))
590 {
591 struct mntent *entry;
592 struct stat st;
593 char *p, *device;
594
595 while ((entry = getmntent( f )))
596 {
597 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
598 if (!strcmp( entry->mnt_type, "nfs" ) ||
599 !strcmp( entry->mnt_type, "smbfs" ) ||
600 !strcmp( entry->mnt_type, "ncpfs" )) continue;
601
602 if (!strcmp( entry->mnt_type, "supermount" ))
603 {
604 if ((device = strstr( entry->mnt_opts, "dev=" )))
605 {
606 device += 4;
607 if ((p = strchr( device, ',' ))) *p = 0;
608 }
609 }
610 else if (!stat( entry->mnt_fsname, &st ) && S_ISREG(st.st_mode))
611 {
612 /* if device is a regular file check for a loop mount */
613 if ((device = strstr( entry->mnt_opts, "loop=" )))
614 {
615 device += 5;
616 if ((p = strchr( device, ',' ))) *p = 0;
617 }
618 }
619 else device = entry->mnt_fsname;
620
621 if (device && !stat( device, &st ) && S_ISBLK(st.st_mode) && st.st_rdev == dev)
622 {
623 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(entry->mnt_dir) + 1 );
624 if (ret) strcpy( ret, entry->mnt_dir );
625 break;
626 }
627 }
628 endmntent( f );
629 }
630 RtlLeaveCriticalSection( &dir_section );
631 #elif defined(__APPLE__)
632 struct statfs *entry;
633 struct stat st;
634 int i, size;
635
636 RtlEnterCriticalSection( &dir_section );
637
638 size = getmntinfo( &entry, MNT_NOWAIT );
639 for (i = 0; i < size; i++)
640 {
641 if (stat( entry[i].f_mntfromname, &st ) == -1) continue;
642 if (S_ISBLK(st.st_mode) && st.st_rdev == dev)
643 {
644 ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(entry[i].f_mntfromname) + 1 );
645 if (ret) strcpy( ret, entry[i].f_mntfromname );
646 break;
647 }
648 }
649 RtlLeaveCriticalSection( &dir_section );
650 #else
651 static int warned;
652 if (!warned++) FIXME( "unmounting devices not supported on this platform\n" );
653 #endif
654 return ret;
655 }
656
657
658 /***********************************************************************
659 * init_options
660 *
661 * Initialize the show_dot_files options.
662 */
663 static void init_options(void)
664 {
665 static const WCHAR WineW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e',0};
666 static const WCHAR ShowDotFilesW[] = {'S','h','o','w','D','o','t','F','i','l','e','s',0};
667 char tmp[80];
668 HANDLE root, hkey;
669 DWORD dummy;
670 OBJECT_ATTRIBUTES attr;
671 UNICODE_STRING nameW;
672
673 show_dot_files = 0;
674
675 RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
676 attr.Length = sizeof(attr);
677 attr.RootDirectory = root;
678 attr.ObjectName = &nameW;
679 attr.Attributes = 0;
680 attr.SecurityDescriptor = NULL;
681 attr.SecurityQualityOfService = NULL;
682 RtlInitUnicodeString( &nameW, WineW );
683
684 /* @@ Wine registry key: HKCU\Software\Wine */
685 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
686 {
687 RtlInitUnicodeString( &nameW, ShowDotFilesW );
688 if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
689 {
690 WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
691 show_dot_files = IS_OPTION_TRUE( str[0] );
692 }
693 NtClose( hkey );
694 }
695 NtClose( root );
696 }
697
698
699 /***********************************************************************
700 * DIR_is_hidden_file
701 *
702 * Check if the specified file should be hidden based on its name and the show dot files option.
703 */
704 BOOL DIR_is_hidden_file( const UNICODE_STRING *name )
705 {
706 WCHAR *p, *end;
707
708 if (show_dot_files == -1) init_options();
709 if (show_dot_files) return FALSE;
710
711 end = p = name->Buffer + name->Length/sizeof(WCHAR);
712 while (p > name->Buffer && IS_SEPARATOR(p[-1])) p--;
713 while (p > name->Buffer && !IS_SEPARATOR(p[-1])) p--;
714 if (p == end || *p != '.') return FALSE;
715 /* make sure it isn't '.' or '..' */
716 if (p + 1 == end) return FALSE;
717 if (p[1] == '.' && p + 2 == end) return FALSE;
718 return TRUE;
719 }
720
721
722 /***********************************************************************
723 * hash_short_file_name
724 *
725 * Transform a Unix file name into a hashed DOS name. If the name is a valid
726 * DOS name, it is converted to upper-case; otherwise it is replaced by a
727 * hashed version that fits in 8.3 format.
728 * 'buffer' must be at least 12 characters long.
729 * Returns length of short name in bytes; short name is NOT null-terminated.
730 */
731 static ULONG hash_short_file_name( const UNICODE_STRING *name, LPWSTR buffer )
732 {
733 static const char hash_chars[32] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
734
735 LPCWSTR p, ext, end = name->Buffer + name->Length / sizeof(WCHAR);
736 LPWSTR dst;
737 unsigned short hash;
738 int i;
739
740 /* Compute the hash code of the file name */
741 /* If you know something about hash functions, feel free to */
742 /* insert a better algorithm here... */
743 if (!is_case_sensitive)
744 {
745 for (p = name->Buffer, hash = 0xbeef; p < end - 1; p++)
746 hash = (hash<<3) ^ (hash>>5) ^ tolowerW(*p) ^ (tolowerW(p[1]) << 8);
747 hash = (hash<<3) ^ (hash>>5) ^ tolowerW(*p); /* Last character */
748 }
749 else
750 {
751 for (p = name->Buffer, hash = 0xbeef; p < end - 1; p++)
752 hash = (hash << 3) ^ (hash >> 5) ^ *p ^ (p[1] << 8);
753 hash = (hash << 3) ^ (hash >> 5) ^ *p; /* Last character */
754 }
755
756 /* Find last dot for start of the extension */
757 for (p = name->Buffer + 1, ext = NULL; p < end - 1; p++) if (*p == '.') ext = p;
758
759 /* Copy first 4 chars, replacing invalid chars with '_' */
760 for (i = 4, p = name->Buffer, dst = buffer; i > 0; i--, p++)
761 {
762 if (p == end || p == ext) break;
763 *dst++ = is_invalid_dos_char(*p) ? '_' : toupperW(*p);
764 }
765 /* Pad to 5 chars with '~' */
766 while (i-- >= 0) *dst++ = '~';
767
768 /* Insert hash code converted to 3 ASCII chars */
769 *dst++ = hash_chars[(hash >> 10) & 0x1f];
770 *dst++ = hash_chars[(hash >> 5) & 0x1f];
771 *dst++ = hash_chars[hash & 0x1f];
772
773 /* Copy the first 3 chars of the extension (if any) */
774 if (ext)
775 {
776 *dst++ = '.';
777 for (i = 3, ext++; (i > 0) && ext < end; i--, ext++)
778 *dst++ = is_invalid_dos_char(*ext) ? '_' : toupperW(*ext);
779 }
780 return dst - buffer;
781 }
782
783
784 /***********************************************************************
785 * match_filename
786 *
787 * Check a long file name against a mask.
788 *
789 * Tests (done in W95 DOS shell - case insensitive):
790 * *.txt test1.test.txt *
791 * *st1* test1.txt *
792 * *.t??????.t* test1.ta.tornado.txt *
793 * *tornado* test1.ta.tornado.txt *
794 * t*t test1.ta.tornado.txt *
795 * ?est* test1.txt *
796 * ?est??? test1.txt -
797 * *test1.txt* test1.txt *
798 * h?l?o*t.dat hellothisisatest.dat *
799 */
800 static BOOLEAN match_filename( const UNICODE_STRING *name_str, const UNICODE_STRING *mask_str )
801 {
802 int mismatch;
803 const WCHAR *name = name_str->Buffer;
804 const WCHAR *mask = mask_str->Buffer;
805 const WCHAR *name_end = name + name_str->Length / sizeof(WCHAR);
806 const WCHAR *mask_end = mask + mask_str->Length / sizeof(WCHAR);
807 const WCHAR *lastjoker = NULL;
808 const WCHAR *next_to_retry = NULL;
809
810 TRACE("(%s, %s)\n", debugstr_us(name_str), debugstr_us(mask_str));
811
812 while (name < name_end && mask < mask_end)
813 {
814 switch(*mask)
815 {
816 case '*':
817 mask++;
818 while (mask < mask_end && *mask == '*') mask++; /* Skip consecutive '*' */
819 if (mask == mask_end) return TRUE; /* end of mask is all '*', so match */
820 lastjoker = mask;
821
822 /* skip to the next match after the joker(s) */
823 if (is_case_sensitive)
824 while (name < name_end && (*name != *mask)) name++;
825 else
826 while (name < name_end && (toupperW(*name) != toupperW(*mask))) name++;
827 next_to_retry = name;
828 break;
829 case '?':
830 mask++;
831 name++;
832 break;
833 default:
834 if (is_case_sensitive) mismatch = (*mask != *name);
835 else mismatch = (toupperW(*mask) != toupperW(*name));
836
837 if (!mismatch)
838 {
839 mask++;
840 name++;
841 if (mask == mask_end)
842 {
843 if (name == name_end) return TRUE;
844 if (lastjoker) mask = lastjoker;
845 }
846 }
847 else /* mismatch ! */
848 {
849 if (lastjoker) /* we had an '*', so we can try unlimitedly */
850 {
851 mask = lastjoker;
852
853 /* this scan sequence was a mismatch, so restart
854 * 1 char after the first char we checked last time */
855 next_to_retry++;
856 name = next_to_retry;
857 }
858 else return FALSE; /* bad luck */
859 }
860 break;
861 }
862 }
863 while (mask < mask_end && ((*mask == '.') || (*mask == '*')))
864 mask++; /* Ignore trailing '.' or '*' in mask */
865 return (name == name_end && mask == mask_end);
866 }
867
868
869 /***********************************************************************
870 * append_entry
871 *
872 * helper for NtQueryDirectoryFile
873 */
874 static FILE_BOTH_DIR_INFORMATION *append_entry( void *info_ptr, ULONG_PTR *pos, ULONG max_length,
875 const char *long_name, const char *short_name,
876 const UNICODE_STRING *mask )
877 {
878 FILE_BOTH_DIR_INFORMATION *info;
879 int i, long_len, short_len, total_len;
880 struct stat st;
881 WCHAR long_nameW[MAX_DIR_ENTRY_LEN];
882 WCHAR short_nameW[12];
883 UNICODE_STRING str;
884
885 long_len = ntdll_umbstowcs( 0, long_name, strlen(long_name), long_nameW, MAX_DIR_ENTRY_LEN );
886 if (long_len == -1) return NULL;
887
888 str.Buffer = long_nameW;
889 str.Length = long_len * sizeof(WCHAR);
890 str.MaximumLength = sizeof(long_nameW);
891
892 if (short_name)
893 {
894 short_len = ntdll_umbstowcs( 0, short_name, strlen(short_name),
895 short_nameW, sizeof(short_nameW) / sizeof(WCHAR) );
896 if (short_len == -1) short_len = sizeof(short_nameW) / sizeof(WCHAR);
897 }
898 else /* generate a short name if necessary */
899 {
900 BOOLEAN spaces;
901
902 short_len = 0;
903 if (!RtlIsNameLegalDOS8Dot3( &str, NULL, &spaces ) || spaces)
904 short_len = hash_short_file_name( &str, short_nameW );
905 }
906
907 TRACE( "long %s short %s mask %s\n",
908 debugstr_us(&str), debugstr_wn(short_nameW, short_len), debugstr_us(mask) );
909
910 if (mask && !match_filename( &str, mask ))
911 {
912 if (!short_len) return NULL; /* no short name to match */
913 str.Buffer = short_nameW;
914 str.Length = short_len * sizeof(WCHAR);
915 str.MaximumLength = sizeof(short_nameW);
916 if (!match_filename( &str, mask )) return NULL;
917 }
918
919 total_len = (sizeof(*info) - sizeof(info->FileName) + long_len*sizeof(WCHAR) + 3) & ~3;
920 info = (FILE_BOTH_DIR_INFORMATION *)((char *)info_ptr + *pos);
921
922 if (*pos + total_len > max_length) total_len = max_length - *pos;
923
924 info->FileAttributes = 0;
925 if (lstat( long_name, &st ) == -1) return NULL;
926 if (S_ISLNK( st.st_mode ))
927 {
928 if (stat( long_name, &st ) == -1) return NULL;
929 if (S_ISDIR( st.st_mode )) info->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
930 }
931
932 info->NextEntryOffset = total_len;
933 info->FileIndex = 0; /* NTFS always has 0 here, so let's not bother with it */
934
935 RtlSecondsSince1970ToTime( st.st_mtime, &info->CreationTime );
936 RtlSecondsSince1970ToTime( st.st_mtime, &info->LastWriteTime );
937 RtlSecondsSince1970ToTime( st.st_atime, &info->LastAccessTime );
938 RtlSecondsSince1970ToTime( st.st_ctime, &info->ChangeTime );
939
940 if (S_ISDIR(st.st_mode))
941 {
942 info->EndOfFile.QuadPart = info->AllocationSize.QuadPart = 0;
943 info->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
944 }
945 else
946 {
947 info->EndOfFile.QuadPart = st.st_size;
948 info->AllocationSize.QuadPart = (ULONGLONG)st.st_blocks * 512;
949 info->FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
950 }
951
952 if (!(st.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)))
953 info->FileAttributes |= FILE_ATTRIBUTE_READONLY;
954
955 if (!show_dot_files && long_name[0] == '.' && long_name[1] && (long_name[1] != '.' || long_name[2]))
956 info->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
957
958 info->EaSize = 0; /* FIXME */
959 info->ShortNameLength = short_len * sizeof(WCHAR);
960 for (i = 0; i < short_len; i++) info->ShortName[i] = toupperW(short_nameW[i]);
961 info->FileNameLength = long_len * sizeof(WCHAR);
962 memcpy( info->FileName, long_nameW,
963 min( info->FileNameLength, total_len-sizeof(*info)+sizeof(info->FileName) ));
964
965 *pos += total_len;
966 return info;
967 }
968
969
970 #ifdef VFAT_IOCTL_READDIR_BOTH
971
972 /***********************************************************************
973 * start_vfat_ioctl
974 *
975 * Wrapper for the VFAT ioctl to work around various kernel bugs.
976 * dir_section must be held by caller.
977 */
978 static KERNEL_DIRENT *start_vfat_ioctl( int fd )
979 {
980 static KERNEL_DIRENT *de;
981 int res;
982
983 if (!de)
984 {
985 const size_t page_size = getpagesize();
986 SIZE_T size = 2 * sizeof(*de) + page_size;
987 void *addr = NULL;
988
989 if (NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 1, &size, MEM_RESERVE, PAGE_READWRITE ))
990 return NULL;
991 /* commit only the size needed for the dir entries */
992 /* this leaves an extra unaccessible page, which should make the kernel */
993 /* fail with -EFAULT before it stomps all over our memory */
994 de = addr;
995 size = 2 * sizeof(*de);
996 NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 1, &size, MEM_COMMIT, PAGE_READWRITE );
997 }
998
999 /* set d_reclen to 65535 to work around an AFS kernel bug */
1000 de[0].d_reclen = 65535;
1001 res = ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de );
1002 if (res == -1)
1003 {
1004 if (errno != ENOENT) return NULL; /* VFAT ioctl probably not supported */
1005 de[0].d_reclen = 0; /* eof */
1006 }
1007 else if (!res && de[0].d_reclen == 65535) return NULL; /* AFS bug */
1008
1009 return de;
1010 }
1011
1012
1013 /***********************************************************************
1014 * read_directory_vfat
1015 *
1016 * Read a directory using the VFAT ioctl; helper for NtQueryDirectoryFile.
1017 */
1018 static int read_directory_vfat( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1019 BOOLEAN single_entry, const UNICODE_STRING *mask,
1020 BOOLEAN restart_scan )
1021
1022 {
1023 size_t len;
1024 KERNEL_DIRENT *de;
1025 FILE_BOTH_DIR_INFORMATION *info, *last_info = NULL;
1026
1027 io->u.Status = STATUS_SUCCESS;
1028
1029 if (restart_scan) lseek( fd, 0, SEEK_SET );
1030
1031 if (length < max_dir_info_size) /* we may have to return a partial entry here */
1032 {
1033 off_t old_pos = lseek( fd, 0, SEEK_CUR );
1034
1035 if (!(de = start_vfat_ioctl( fd ))) return -1; /* not supported */
1036
1037 while (de[0].d_reclen)
1038 {
1039 /* make sure names are null-terminated to work around an x86-64 kernel bug */
1040 len = min(de[0].d_reclen, sizeof(de[0].d_name) - 1 );
1041 de[0].d_name[len] = 0;
1042 len = min(de[1].d_reclen, sizeof(de[1].d_name) - 1 );
1043 de[1].d_name[len] = 0;
1044
1045 if (de[1].d_name[0])
1046 info = append_entry( buffer, &io->Information, length,
1047 de[1].d_name, de[0].d_name, mask );
1048 else
1049 info = append_entry( buffer, &io->Information, length,
1050 de[0].d_name, NULL, mask );
1051 if (info)
1052 {
1053 last_info = info;
1054 if ((char *)info->FileName + info->FileNameLength > (char *)buffer + length)
1055 {
1056 io->u.Status = STATUS_BUFFER_OVERFLOW;
1057 lseek( fd, old_pos, SEEK_SET ); /* restore pos to previous entry */
1058 }
1059 break;
1060 }
1061 old_pos = lseek( fd, 0, SEEK_CUR );
1062 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1) break;
1063 }
1064 }
1065 else /* we'll only return full entries, no need to worry about overflow */
1066 {
1067 if (!(de = start_vfat_ioctl( fd ))) return -1; /* not supported */
1068
1069 while (de[0].d_reclen)
1070 {
1071 /* make sure names are null-terminated to work around an x86-64 kernel bug */
1072 len = min(de[0].d_reclen, sizeof(de[0].d_name) - 1 );
1073 de[0].d_name[len] = 0;
1074 len = min(de[1].d_reclen, sizeof(de[1].d_name) - 1 );
1075 de[1].d_name[len] = 0;
1076
1077 if (de[1].d_name[0])
1078 info = append_entry( buffer, &io->Information, length,
1079 de[1].d_name, de[0].d_name, mask );
1080 else
1081 info = append_entry( buffer, &io->Information, length,
1082 de[0].d_name, NULL, mask );
1083 if (info)
1084 {
1085 last_info = info;
1086 if (single_entry) break;
1087 /* check if we still have enough space for the largest possible entry */
1088 if (io->Information + max_dir_info_size > length) break;
1089 }
1090 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1) break;
1091 }
1092 }
1093
1094 if (last_info) last_info->NextEntryOffset = 0;
1095 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1096 return 0;
1097 }
1098 #endif /* VFAT_IOCTL_READDIR_BOTH */
1099
1100
1101 /***********************************************************************
1102 * read_directory_getdents
1103 *
1104 * Read a directory using the Linux getdents64 system call; helper for NtQueryDirectoryFile.
1105 */
1106 #ifdef USE_GETDENTS
1107 static int read_directory_getdents( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1108 BOOLEAN single_entry, const UNICODE_STRING *mask,
1109 BOOLEAN restart_scan )
1110 {
1111 off_t old_pos = 0;
1112 size_t size = length;
1113 int res, fake_dot_dot = 1;
1114 char *data, local_buffer[8192];
1115 KERNEL_DIRENT64 *de;
1116 FILE_BOTH_DIR_INFORMATION *info, *last_info = NULL;
1117
1118 if (size <= sizeof(local_buffer) || !(data = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1119 {
1120 size = sizeof(local_buffer);
1121 data = local_buffer;
1122 }
1123
1124 if (restart_scan) lseek( fd, 0, SEEK_SET );
1125 else if (length < max_dir_info_size) /* we may have to return a partial entry here */
1126 {
1127 old_pos = lseek( fd, 0, SEEK_CUR );
1128 if (old_pos == -1 && errno == ENOENT)
1129 {
1130 io->u.Status = STATUS_NO_MORE_FILES;
1131 res = 0;
1132 goto done;
1133 }
1134 }
1135
1136 io->u.Status = STATUS_SUCCESS;
1137
1138 res = getdents64( fd, data, size );
1139 if (res == -1)
1140 {
1141 if (errno != ENOSYS)
1142 {
1143 io->u.Status = FILE_GetNtStatus();
1144 res = 0;
1145 }
1146 goto done;
1147 }
1148
1149 de = (KERNEL_DIRENT64 *)data;
1150
1151 if (restart_scan)
1152 {
1153 /* check if we got . and .. from getdents */
1154 if (res > 0)
1155 {
1156 if (!strcmp( de->d_name, "." ) && res > de->d_reclen)
1157 {
1158 KERNEL_DIRENT64 *next_de = (KERNEL_DIRENT64 *)(data + de->d_reclen);
1159 if (!strcmp( next_de->d_name, ".." )) fake_dot_dot = 0;
1160 }
1161 }
1162 /* make sure we have enough room for both entries */
1163 if (fake_dot_dot)
1164 {
1165 static const ULONG min_info_size = (FIELD_OFFSET(FILE_BOTH_DIR_INFORMATION, FileName[1]) +
1166 FIELD_OFFSET(FILE_BOTH_DIR_INFORMATION, FileName[2]) + 3) & ~3;
1167 if (length < min_info_size || single_entry)
1168 {
1169 FIXME( "not enough room %u/%u for fake . and .. entries\n", length, single_entry );
1170 fake_dot_dot = 0;
1171 }
1172 }
1173
1174 if (fake_dot_dot)
1175 {
1176 if ((info = append_entry( buffer, &io->Information, length, ".", NULL, mask )))
1177 last_info = info;
1178 if ((info = append_entry( buffer, &io->Information, length, "..", NULL, mask )))
1179 last_info = info;
1180
1181 /* check if we still have enough space for the largest possible entry */
1182 if (last_info && io->Information + max_dir_info_size > length)
1183 {
1184 lseek( fd, 0, SEEK_SET ); /* reset pos to first entry */
1185 res = 0;
1186 }
1187 }
1188 }
1189
1190 while (res > 0)
1191 {
1192 res -= de->d_reclen;
1193 if (!(fake_dot_dot && (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." ))) &&
1194 (info = append_entry( buffer, &io->Information, length, de->d_name, NULL, mask )))
1195 {
1196 last_info = info;
1197 if ((char *)info->FileName + info->FileNameLength > (char *)buffer + length)
1198 {
1199 io->u.Status = STATUS_BUFFER_OVERFLOW;
1200 lseek( fd, old_pos, SEEK_SET ); /* restore pos to previous entry */
1201 break;
1202 }
1203 /* check if we still have enough space for the largest possible entry */
1204 if (single_entry || io->Information + max_dir_info_size > length)
1205 {
1206 if (res > 0) lseek( fd, de->d_off, SEEK_SET ); /* set pos to next entry */
1207 break;
1208 }
1209 }
1210 old_pos = de->d_off;
1211 /* move on to the next entry */
1212 if (res > 0) de = (KERNEL_DIRENT64 *)((char *)de + de->d_reclen);
1213 else
1214 {
1215 res = getdents64( fd, data, size );
1216 de = (KERNEL_DIRENT64 *)data;
1217 }
1218 }
1219
1220 if (last_info) last_info->NextEntryOffset = 0;
1221 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1222 res = 0;
1223 done:
1224 if (data != local_buffer) RtlFreeHeap( GetProcessHeap(), 0, data );
1225 return res;
1226 }
1227
1228 #elif defined HAVE_GETDIRENTRIES
1229
1230 /***********************************************************************
1231 * wine_getdirentries
1232 *
1233 * Wrapper for the BSD getdirentries system call to fix a bug in the
1234 * Mac OS X version. For some file systems (at least Apple Filing
1235 * Protocol a.k.a. AFP), getdirentries resets the file position to 0
1236 * when it's about to return 0 (no more entries). So, a subsequent
1237 * getdirentries call starts over at the beginning again, causing an
1238 * infinite loop.
1239 */
1240 static inline int wine_getdirentries(int fd, char *buf, int nbytes, long *basep)
1241 {
1242 int res = getdirentries(fd, buf, nbytes, basep);
1243 #ifdef __APPLE__
1244 if (res == 0)
1245 lseek(fd, *basep, SEEK_SET);
1246 #endif
1247 return res;
1248 }
1249
1250 /***********************************************************************
1251 * read_directory_getdirentries
1252 *
1253 * Read a directory using the BSD getdirentries system call; helper for NtQueryDirectoryFile.
1254 */
1255 static int read_directory_getdirentries( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1256 BOOLEAN single_entry, const UNICODE_STRING *mask,
1257 BOOLEAN restart_scan )
1258 {
1259 long restart_pos;
1260 ULONG_PTR restart_info_pos = 0;
1261 size_t size, initial_size = length;
1262 int res, fake_dot_dot = 1;
1263 char *data, local_buffer[8192];
1264 struct dirent *de;
1265 FILE_BOTH_DIR_INFORMATION *info, *last_info = NULL, *restart_last_info = NULL;
1266
1267 size = initial_size;
1268 data = local_buffer;
1269 if (size > sizeof(local_buffer) && !(data = RtlAllocateHeap( GetProcessHeap(), 0, size )))
1270 {
1271 io->u.Status = STATUS_NO_MEMORY;
1272 return io->u.Status;
1273 }
1274
1275 if (restart_scan) lseek( fd, 0, SEEK_SET );
1276
1277 io->u.Status = STATUS_SUCCESS;
1278
1279 /* FIXME: should make sure size is larger than filesystem block size */
1280 res = wine_getdirentries( fd, data, size, &restart_pos );
1281 if (res == -1)
1282 {
1283 io->u.Status = FILE_GetNtStatus();
1284 res = 0;
1285 goto done;
1286 }
1287
1288 de = (struct dirent *)data;
1289
1290 if (restart_scan)
1291 {
1292 /* check if we got . and .. from getdirentries */
1293 if (res > 0)
1294 {
1295 if (!strcmp( de->d_name, "." ) && res > de->d_reclen)
1296 {
1297 struct dirent *next_de = (struct dirent *)(data + de->d_reclen);
1298 if (!strcmp( next_de->d_name, ".." )) fake_dot_dot = 0;
1299 }
1300 }
1301 /* make sure we have enough room for both entries */
1302 if (fake_dot_dot)
1303 {
1304 static const ULONG min_info_size = (FIELD_OFFSET(FILE_BOTH_DIR_INFORMATION, FileName[1]) +
1305 FIELD_OFFSET(FILE_BOTH_DIR_INFORMATION, FileName[2]) + 3) & ~3;
1306 if (length < min_info_size || single_entry)
1307 {
1308 FIXME( "not enough room %u/%u for fake . and .. entries\n", length, single_entry );
1309 fake_dot_dot = 0;
1310 }
1311 }
1312
1313 if (fake_dot_dot)
1314 {
1315 if ((info = append_entry( buffer, &io->Information, length, ".", NULL, mask )))
1316 last_info = info;
1317 if ((info = append_entry( buffer, &io->Information, length, "..", NULL, mask )))
1318 last_info = info;
1319
1320 restart_last_info = last_info;
1321 restart_info_pos = io->Information;
1322
1323 /* check if we still have enough space for the largest possible entry */
1324 if (last_info && io->Information + max_dir_info_size > length)
1325 {
1326 lseek( fd, 0, SEEK_SET ); /* reset pos to first entry */
1327 res = 0;
1328 }
1329 }
1330 }
1331
1332 while (res > 0)
1333 {
1334 res -= de->d_reclen;
1335 if (de->d_fileno &&
1336 !(fake_dot_dot && (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." ))) &&
1337 ((info = append_entry( buffer, &io->Information, length, de->d_name, NULL, mask ))))
1338 {
1339 last_info = info;
1340 if ((char *)info->FileName + info->FileNameLength > (char *)buffer + length)
1341 {
1342 lseek( fd, (unsigned long)restart_pos, SEEK_SET );
1343 if (restart_info_pos) /* if we have a complete read already, return it */
1344 {
1345 io->Information = restart_info_pos;
1346 last_info = restart_last_info;
1347 break;
1348 }
1349 /* otherwise restart from the start with a smaller size */
1350 size = (char *)de - data;
1351 if (!size)
1352 {
1353 io->u.Status = STATUS_BUFFER_OVERFLOW;
1354 break;
1355 }
1356 io->Information = 0;
1357 last_info = NULL;
1358 goto restart;
1359 }
1360 /* if we have to return but the buffer contains more data, restart with a smaller size */
1361 if (res > 0 && (single_entry || io->Information + max_dir_info_size > length))
1362 {
1363 lseek( fd, (unsigned long)restart_pos, SEEK_SET );
1364 size = (char *)de - data;
1365 io->Information = restart_info_pos;
1366 last_info = restart_last_info;
1367 goto restart;
1368 }
1369 }
1370 /* move on to the next entry */
1371 if (res > 0)
1372 {
1373 de = (struct dirent *)((char *)de + de->d_reclen);
1374 continue;
1375 }
1376 if (size < initial_size) break; /* already restarted once, give up now */
1377 size = min( size, length - io->Information );
1378 /* if size is too small don't bother to continue */
1379 if (size < max_dir_info_size && last_info) break;
1380 restart_last_info = last_info;
1381 restart_info_pos = io->Information;
1382 restart:
1383 res = wine_getdirentries( fd, data, size, &restart_pos );
1384 de = (struct dirent *)data;
1385 }
1386
1387 if (last_info) last_info->NextEntryOffset = 0;
1388 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1389 res = 0;
1390 done:
1391 if (data != local_buffer) RtlFreeHeap( GetProcessHeap(), 0, data );
1392 return res;
1393 }
1394 #endif /* HAVE_GETDIRENTRIES */
1395
1396
1397 /***********************************************************************
1398 * read_directory_readdir
1399 *
1400 * Read a directory using the POSIX readdir interface; helper for NtQueryDirectoryFile.
1401 */
1402 static void read_directory_readdir( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1403 BOOLEAN single_entry, const UNICODE_STRING *mask,
1404 BOOLEAN restart_scan )
1405 {
1406 DIR *dir;
1407 off_t i, old_pos = 0;
1408 struct dirent *de;
1409 FILE_BOTH_DIR_INFORMATION *info, *last_info = NULL;
1410
1411 if (!(dir = opendir( "." )))
1412 {
1413 io->u.Status = FILE_GetNtStatus();
1414 return;
1415 }
1416
1417 if (!restart_scan)
1418 {
1419 old_pos = lseek( fd, 0, SEEK_CUR );
1420 /* skip the right number of entries */
1421 for (i = 0; i < old_pos - 2; i++)
1422 {
1423 if (!readdir( dir ))
1424 {
1425 closedir( dir );
1426 io->u.Status = STATUS_NO_MORE_FILES;
1427 return;
1428 }
1429 }
1430 }
1431 io->u.Status = STATUS_SUCCESS;
1432
1433 for (;;)
1434 {
1435 if (old_pos == 0)
1436 info = append_entry( buffer, &io->Information, length, ".", NULL, mask );
1437 else if (old_pos == 1)
1438 info = append_entry( buffer, &io->Information, length, "..", NULL, mask );
1439 else if ((de = readdir( dir )))
1440 {
1441 if (strcmp( de->d_name, "." ) && strcmp( de->d_name, ".." ))
1442 info = append_entry( buffer, &io->Information, length, de->d_name, NULL, mask );
1443 else
1444 info = NULL;
1445 }
1446 else
1447 break;
1448 old_pos++;
1449 if (info)
1450 {
1451 last_info = info;
1452 if ((char *)info->FileName + info->FileNameLength > (char *)buffer + length)
1453 {
1454 io->u.Status = STATUS_BUFFER_OVERFLOW;
1455 old_pos--; /* restore pos to previous entry */
1456 break;
1457 }
1458 if (single_entry) break;
1459 /* check if we still have enough space for the largest possible entry */
1460 if (io->Information + max_dir_info_size > length) break;
1461 }
1462 }
1463
1464 lseek( fd, old_pos, SEEK_SET ); /* store dir offset as filepos for fd */
1465 closedir( dir );
1466
1467 if (last_info) last_info->NextEntryOffset = 0;
1468 else io->u.Status = restart_scan ? STATUS_NO_SUCH_FILE : STATUS_NO_MORE_FILES;
1469 }
1470
1471 /***********************************************************************
1472 * read_directory_stat
1473 *
1474 * Read a single file from a directory by determining whether the file
1475 * identified by mask exists using stat.
1476 */
1477 static int read_directory_stat( int fd, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1478 BOOLEAN single_entry, const UNICODE_STRING *mask,
1479 BOOLEAN restart_scan )
1480 {
1481 int unix_len, ret, used_default;
1482 char *unix_name;
1483 struct stat st;
1484
1485 TRACE("trying optimisation for file %s\n", debugstr_us( mask ));
1486
1487 unix_len = ntdll_wcstoumbs( 0, mask->Buffer, mask->Length / sizeof(WCHAR), NULL, 0, NULL, NULL );
1488 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len + 1)))
1489 {
1490 io->u.Status = STATUS_NO_MEMORY;
1491 return 0;
1492 }
1493 ret = ntdll_wcstoumbs( 0, mask->Buffer, mask->Length / sizeof(WCHAR), unix_name, unix_len,
1494 NULL, &used_default );
1495 if (ret > 0 && !used_default)
1496 {
1497 unix_name[ret] = 0;
1498 if (restart_scan)
1499 {
1500 lseek( fd, 0, SEEK_SET );
1501 }
1502 else if (lseek( fd, 0, SEEK_CUR ) != 0)
1503 {
1504 io->u.Status = STATUS_NO_MORE_FILES;
1505 ret = 0;
1506 goto done;
1507 }
1508
1509 ret = stat( unix_name, &st );
1510 if (!ret)
1511 {
1512 FILE_BOTH_DIR_INFORMATION *info = append_entry( buffer, &io->Information, length, unix_name, NULL, mask );
1513 if (info)
1514 {
1515 info->NextEntryOffset = 0;
1516 if ((char *)info->FileName + info->FileNameLength > (char *)buffer + length)
1517 io->u.Status = STATUS_BUFFER_OVERFLOW;
1518 else
1519 lseek( fd, 1, SEEK_CUR );
1520 }
1521 }
1522 }
1523 else ret = -1;
1524
1525 done:
1526 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1527
1528 TRACE("returning %d\n", ret);
1529
1530 return ret;
1531 }
1532
1533
1534 static inline WCHAR *mempbrkW( const WCHAR *ptr, const WCHAR *accept, size_t n )
1535 {
1536 const WCHAR *end;
1537 for (end = ptr + n; ptr < end; ptr++) if (strchrW( accept, *ptr )) return (WCHAR *)ptr;
1538 return NULL;
1539 }
1540
1541 /******************************************************************************
1542 * NtQueryDirectoryFile [NTDLL.@]
1543 * ZwQueryDirectoryFile [NTDLL.@]
1544 */
1545 NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event,
1546 PIO_APC_ROUTINE apc_routine, PVOID apc_context,
1547 PIO_STATUS_BLOCK io,
1548 PVOID buffer, ULONG length,
1549 FILE_INFORMATION_CLASS info_class,
1550 BOOLEAN single_entry,
1551 PUNICODE_STRING mask,
1552 BOOLEAN restart_scan )
1553 {
1554 int cwd, fd, needs_close;
1555 static const WCHAR wszWildcards[] = { '*','?',0 };
1556
1557 TRACE("(%p %p %p %p %p %p 0x%08x 0x%08x 0x%08x %s 0x%08x\n",
1558 handle, event, apc_routine, apc_context, io, buffer,
1559 length, info_class, single_entry, debugstr_us(mask),
1560 restart_scan);
1561
1562 if (length < sizeof(FILE_BOTH_DIR_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
1563
1564 if (event || apc_routine)
1565 {
1566 FIXME( "Unsupported yet option\n" );
1567 return io->u.Status = STATUS_NOT_IMPLEMENTED;
1568 }
1569 if (info_class != FileBothDirectoryInformation)
1570 {
1571 FIXME( "Unsupported file info class %d\n", info_class );
1572 return io->u.Status = STATUS_NOT_IMPLEMENTED;
1573 }
1574
1575 if ((io->u.Status = server_get_unix_fd( handle, FILE_LIST_DIRECTORY, &fd, &needs_close, NULL, NULL )) != STATUS_SUCCESS)
1576 return io->u.Status;
1577
1578 io->Information = 0;
1579
1580 RtlEnterCriticalSection( &dir_section );
1581
1582 if (show_dot_files == -1) init_options();
1583
1584 cwd = open( ".", O_RDONLY );
1585 if (fchdir( fd ) != -1)
1586 {
1587 #ifdef VFAT_IOCTL_READDIR_BOTH
1588 if ((read_directory_vfat( fd, io, buffer, length, single_entry, mask, restart_scan )) != -1)
1589 goto done;
1590 #endif
1591 if (mask && !mempbrkW( mask->Buffer, wszWildcards, mask->Length / sizeof(WCHAR) ) &&
1592 read_directory_stat( fd, io, buffer, length, single_entry, mask, restart_scan ) != -1)
1593 goto done;
1594 #ifdef USE_GETDENTS
1595 if ((read_directory_getdents( fd, io, buffer, length, single_entry, mask, restart_scan )) != -1)
1596 goto done;
1597 #elif defined HAVE_GETDIRENTRIES
1598 if ((read_directory_getdirentries( fd, io, buffer, length, single_entry, mask, restart_scan )) != -1)
1599 goto done;
1600 #endif
1601 read_directory_readdir( fd, io, buffer, length, single_entry, mask, restart_scan );
1602
1603 done:
1604 if (cwd == -1 || fchdir( cwd ) == -1) chdir( "/" );
1605 }
1606 else io->u.Status = FILE_GetNtStatus();
1607
1608 RtlLeaveCriticalSection( &dir_section );
1609
1610 if (needs_close) close( fd );
1611 if (cwd != -1) close( cwd );
1612 TRACE( "=> %x (%ld)\n", io->u.Status, io->Information );
1613 return io->u.Status;
1614 }
1615
1616
1617 /***********************************************************************
1618 * find_file_in_dir
1619 *
1620 * Find a file in a directory the hard way, by doing a case-insensitive search.
1621 * The file found is appended to unix_name at pos.
1622 * There must be at least MAX_DIR_ENTRY_LEN+2 chars available at pos.
1623 */
1624 static NTSTATUS find_file_in_dir( char *unix_name, int pos, const WCHAR *name, int length,
1625 int check_case )
1626 {
1627 WCHAR buffer[MAX_DIR_ENTRY_LEN];
1628 UNICODE_STRING str;
1629 BOOLEAN spaces;
1630 DIR *dir;
1631 struct dirent *de;
1632 struct stat st;
1633 int ret, used_default, is_name_8_dot_3;
1634
1635 /* try a shortcut for this directory */
1636
1637 unix_name[pos++] = '/';
1638 ret = ntdll_wcstoumbs( 0, name, length, unix_name + pos, MAX_DIR_ENTRY_LEN,
1639 NULL, &used_default );
1640 /* if we used the default char, the Unix name won't round trip properly back to Unicode */
1641 /* so it cannot match the file we are looking for */
1642 if (ret >= 0 && !used_default)
1643 {
1644 unix_name[pos + ret] = 0;
1645 if (!stat( unix_name, &st )) return STATUS_SUCCESS;
1646 }
1647 if (check_case) goto not_found; /* we want an exact match */
1648
1649 if (pos > 1) unix_name[pos - 1] = 0;
1650 else unix_name[1] = 0; /* keep the initial slash */
1651
1652 /* check if it fits in 8.3 so that we don't look for short names if we won't need them */
1653
1654 str.Buffer = (WCHAR *)name;
1655 str.Length = length * sizeof(WCHAR);
1656 str.MaximumLength = str.Length;
1657 is_name_8_dot_3 = RtlIsNameLegalDOS8Dot3( &str, NULL, &spaces ) && !spaces;
1658
1659 /* now look for it through the directory */
1660
1661 #ifdef VFAT_IOCTL_READDIR_BOTH
1662 if (is_name_8_dot_3)
1663 {
1664 int fd = open( unix_name, O_RDONLY | O_DIRECTORY );
1665 if (fd != -1)
1666 {
1667 KERNEL_DIRENT *de;
1668
1669 RtlEnterCriticalSection( &dir_section );
1670 if ((de = start_vfat_ioctl( fd )))
1671 {
1672 unix_name[pos - 1] = '/';
1673 while (de[0].d_reclen)
1674 {
1675 /* make sure names are null-terminated to work around an x86-64 kernel bug */
1676 size_t len = min(de[0].d_reclen, sizeof(de[0].d_name) - 1 );
1677 de[0].d_name[len] = 0;
1678 len = min(de[1].d_reclen, sizeof(de[1].d_name) - 1 );
1679 de[1].d_name[len] = 0;
1680
1681 if (de[1].d_name[0])
1682 {
1683 ret = ntdll_umbstowcs( 0, de[1].d_name, strlen(de[1].d_name),
1684 buffer, MAX_DIR_ENTRY_LEN );
1685 if (ret == length && !memicmpW( buffer, name, length))
1686 {
1687 strcpy( unix_name + pos, de[1].d_name );
1688 RtlLeaveCriticalSection( &dir_section );
1689 close( fd );
1690 return STATUS_SUCCESS;
1691 }
1692 }
1693 ret = ntdll_umbstowcs( 0, de[0].d_name, strlen(de[0].d_name),
1694 buffer, MAX_DIR_ENTRY_LEN );
1695 if (ret == length && !memicmpW( buffer, name, length))
1696 {
1697 strcpy( unix_name + pos,
1698 de[1].d_name[0] ? de[1].d_name : de[0].d_name );
1699 RtlLeaveCriticalSection( &dir_section );
1700 close( fd );
1701 return STATUS_SUCCESS;
1702 }
1703 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1)
1704 {
1705 RtlLeaveCriticalSection( &dir_section );
1706 close( fd );
1707 goto not_found;
1708 }
1709 }
1710 }
1711 RtlLeaveCriticalSection( &dir_section );
1712 close( fd );
1713 }
1714 /* fall through to normal handling */
1715 }
1716 #endif /* VFAT_IOCTL_READDIR_BOTH */
1717
1718 if (!(dir = opendir( unix_name )))
1719 {
1720 if (errno == ENOENT) return STATUS_OBJECT_PATH_NOT_FOUND;
1721 else return FILE_GetNtStatus();
1722 }
1723 unix_name[pos - 1] = '/';
1724 str.Buffer = buffer;
1725 str.MaximumLength = sizeof(buffer);
1726 while ((de = readdir( dir )))
1727 {
1728 ret = ntdll_umbstowcs( 0, de->d_name, strlen(de->d_name), buffer, MAX_DIR_ENTRY_LEN );
1729 if (ret == length && !memicmpW( buffer, name, length ))
1730 {
1731 strcpy( unix_name + pos, de->d_name );
1732 closedir( dir );
1733 return STATUS_SUCCESS;
1734 }
1735
1736 if (!is_name_8_dot_3) continue;
1737
1738 str.Length = ret * sizeof(WCHAR);
1739 if (!RtlIsNameLegalDOS8Dot3( &str, NULL, &spaces ) || spaces)
1740 {
1741 WCHAR short_nameW[12];
1742 ret = hash_short_file_name( &str, short_nameW );
1743 if (ret == length && !memicmpW( short_nameW, name, length ))
1744 {
1745 strcpy( unix_name + pos, de->d_name );
1746 closedir( dir );
1747 return STATUS_SUCCESS;
1748 }
1749 }
1750 }
1751 closedir( dir );
1752 goto not_found; /* avoid warning */
1753
1754 not_found:
1755 unix_name[pos - 1] = 0;
1756 return STATUS_OBJECT_PATH_NOT_FOUND;
1757 }
1758
1759
1760 /******************************************************************************
1761 * get_dos_device
1762 *
1763 * Get the Unix path of a DOS device.
1764 */
1765 static NTSTATUS get_dos_device( const WCHAR *name, UINT name_len, ANSI_STRING *unix_name_ret )
1766 {
1767 const char *config_dir = wine_get_config_dir();
1768 struct stat st;
1769 char *unix_name, *new_name, *dev;
1770 unsigned int i;
1771 int unix_len;
1772
1773 /* make sure the device name is ASCII */
1774 for (i = 0; i < name_len; i++)
1775 if (name[i] <= 32 || name[i] >= 127) return STATUS_BAD_DEVICE_TYPE;
1776
1777 unix_len = strlen(config_dir) + sizeof("/dosdevices/") + name_len + 1;
1778
1779 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len )))
1780 return STATUS_NO_MEMORY;
1781
1782 strcpy( unix_name, config_dir );
1783 strcat( unix_name, "/dosdevices/" );
1784 dev = unix_name + strlen(unix_name);
1785
1786 for (i = 0; i < name_len; i++) dev[i] = (char)tolowerW(name[i]);
1787 dev[i] = 0;
1788
1789 /* special case for drive devices */
1790 if (name_len == 2 && dev[1] == ':')
1791 {
1792 dev[i++] = ':';
1793 dev[i] = 0;
1794 }
1795
1796 for (;;)
1797 {
1798 if (!stat( unix_name, &st ))
1799 {
1800 TRACE( "%s -> %s\n", debugstr_wn(name,name_len), debugstr_a(unix_name) );
1801 unix_name_ret->Buffer = unix_name;
1802 unix_name_ret->Length = strlen(unix_name);
1803 unix_name_ret->MaximumLength = unix_len;
1804 return STATUS_SUCCESS;
1805 }
1806 if (!dev) break;
1807
1808 /* now try some defaults for it */
1809 if (!strcmp( dev, "aux" ))
1810 {
1811 strcpy( dev, "com1" );
1812 continue;
1813 }
1814 if (!strcmp( dev, "prn" ))
1815 {
1816 strcpy( dev, "lpt1" );
1817 continue;
1818 }
1819 if (!strcmp( dev, "nul" ))
1820 {
1821 strcpy( unix_name, "/dev/null" );
1822 dev = NULL; /* last try */
1823 continue;
1824 }
1825
1826 new_name = NULL;
1827 if (dev[1] == ':' && dev[2] == ':') /* drive device */
1828 {
1829 dev[2] = 0; /* remove last ':' to get the drive mount point symlink */
1830 new_name = get_default_drive_device( unix_name );
1831 }
1832 else if (!strncmp( dev, "com", 3 )) new_name = get_default_com_device( dev[3] - '0' );
1833 else if (!strncmp( dev, "lpt", 3 )) new_name = get_default_lpt_device( dev[3] - '0' );
1834
1835 if (!new_name) break;
1836
1837 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1838 unix_name = new_name;
1839 unix_len = strlen(unix_name) + 1;
1840 dev = NULL; /* last try */
1841 }
1842 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1843 return STATUS_BAD_DEVICE_TYPE;
1844 }
1845
1846
1847 /* return the length of the DOS namespace prefix if any */
1848 static inline int get_dos_prefix_len( const UNICODE_STRING *name )
1849 {
1850 static const WCHAR nt_prefixW[] = {'\\','?','?','\\'};
1851 static const WCHAR dosdev_prefixW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\'};
1852
1853 if (name->Length > sizeof(nt_prefixW) &&
1854 !memcmp( name->Buffer, nt_prefixW, sizeof(nt_prefixW) ))
1855 return sizeof(nt_prefixW) / sizeof(WCHAR);
1856
1857 if (name->Length > sizeof(dosdev_prefixW) &&
1858 !memicmpW( name->Buffer, dosdev_prefixW, sizeof(dosdev_prefixW)/sizeof(WCHAR) ))
1859 return sizeof(dosdev_prefixW) / sizeof(WCHAR);
1860
1861 return 0;
1862 }
1863
1864
1865 /******************************************************************************
1866 * wine_nt_to_unix_file_name (NTDLL.@) Not a Windows API
1867 *
1868 * Convert a file name from NT namespace to Unix namespace.
1869 *
1870 * If disposition is not FILE_OPEN or FILE_OVERWRITTE, the last path
1871 * element doesn't have to exist; in that case STATUS_NO_SUCH_FILE is
1872 * returned, but the unix name is still filled in properly.
1873 */
1874 NTSTATUS wine_nt_to_unix_file_name( const UNICODE_STRING *nameW, ANSI_STRING *unix_name_ret,
1875 UINT disposition, BOOLEAN check_case )
1876 {
1877 static const WCHAR unixW[] = {'u','n','i','x'};
1878 static const WCHAR invalid_charsW[] = { INVALID_NT_CHARS, 0 };
1879
1880 NTSTATUS status = STATUS_SUCCESS;
1881 const char *config_dir = wine_get_config_dir();
1882 const WCHAR *name, *p;
1883 struct stat st;
1884 char *unix_name;
1885 int pos, ret, name_len, unix_len, prefix_len, used_default;
1886 WCHAR prefix[MAX_DIR_ENTRY_LEN];
1887 BOOLEAN is_unix = FALSE;
1888
1889 name = nameW->Buffer;
1890 name_len = nameW->Length / sizeof(WCHAR);
1891
1892 if (!name_len || !IS_SEPARATOR(name[0])) return STATUS_OBJECT_PATH_SYNTAX_BAD;
1893
1894 if (!(pos = get_dos_prefix_len( nameW )))
1895 return STATUS_BAD_DEVICE_TYPE; /* no DOS prefix, assume NT native name */
1896
1897 name += pos;
1898 name_len -= pos;
1899
1900 /* check for sub-directory */
1901 for (pos = 0; pos < name_len; pos++)
1902 {
1903 if (IS_SEPARATOR(name[pos])) break;
1904 if (name[pos] < 32 || strchrW( invalid_charsW, name[pos] ))
1905 return STATUS_OBJECT_NAME_INVALID;
1906 }
1907 if (pos > MAX_DIR_ENTRY_LEN)
1908 return STATUS_OBJECT_NAME_INVALID;
1909
1910 if (pos == name_len) /* no subdir, plain DOS device */
1911 return get_dos_device( name, name_len, unix_name_ret );
1912
1913 for (prefix_len = 0; prefix_len < pos; prefix_len++)
1914 prefix[prefix_len] = tolowerW(name[prefix_len]);
1915
1916 name += prefix_len;
1917 name_len -= prefix_len;
1918
1919 /* check for invalid characters (all chars except 0 are valid for unix) */
1920 is_unix = (prefix_len == 4 && !memcmp( prefix, unixW, sizeof(unixW) ));
1921 if (is_unix)
1922 {
1923 for (p = name; p < name + name_len; p++)
1924 if (!*p) return STATUS_OBJECT_NAME_INVALID;
1925 check_case = TRUE;
1926 }
1927 else
1928 {
1929 for (p = name; p < name + name_len; p++)
1930 if (*p < 32 || strchrW( invalid_charsW, *p )) return STATUS_OBJECT_NAME_INVALID;
1931 }
1932
1933 unix_len = ntdll_wcstoumbs( 0, prefix, prefix_len, NULL, 0, NULL, NULL );
1934 unix_len += ntdll_wcstoumbs( 0, name, name_len, NULL, 0, NULL, NULL );
1935 unix_len += MAX_DIR_ENTRY_LEN + 3;
1936 unix_len += strlen(config_dir) + sizeof("/dosdevices/");
1937 if (!(unix_name = RtlAllocateHeap( GetProcessHeap(), 0, unix_len )))
1938 return STATUS_NO_MEMORY;
1939 strcpy( unix_name, config_dir );
1940 strcat( unix_name, "/dosdevices/" );
1941 pos = strlen(unix_name);
1942
1943 ret = ntdll_wcstoumbs( 0, prefix, prefix_len, unix_name + pos, unix_len - pos - 1,
1944 NULL, &used_default );
1945 if (!ret || used_default)
1946 {
1947 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1948 return STATUS_OBJECT_NAME_INVALID;
1949 }
1950 pos += ret;
1951
1952 /* check if prefix exists (except for DOS drives to avoid extra stat calls) */
1953
1954 if (prefix_len != 2 || prefix[1] != ':')
1955 {
1956 unix_name[pos] = 0;
1957 if (lstat( unix_name, &st ) == -1 && errno == ENOENT)
1958 {
1959 if (!is_unix)
1960 {
1961 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1962 return STATUS_BAD_DEVICE_TYPE;
1963 }
1964 pos = 0; /* fall back to unix root */
1965 }
1966 }
1967
1968 /* try a shortcut first */
1969
1970 ret = ntdll_wcstoumbs( 0, name, name_len, unix_name + pos, unix_len - pos - 1,
1971 NULL, &used_default );
1972
1973 while (name_len && IS_SEPARATOR(*name))
1974 {
1975 name++;
1976 name_len--;
1977 }
1978
1979 if (ret > 0 && !used_default) /* if we used the default char the name didn't convert properly */
1980 {
1981 char *p;
1982 unix_name[pos + ret] = 0;
1983 for (p = unix_name + pos ; *p; p++) if (*p == '\\') *p = '/';
1984 if (!stat( unix_name, &st ))
1985 {
1986 /* creation fails with STATUS_ACCESS_DENIED for the root of the drive */
1987 if (disposition == FILE_CREATE)
1988 {
1989 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1990 return name_len ? STATUS_OBJECT_NAME_COLLISION : STATUS_ACCESS_DENIED;
1991 }
1992 goto done;
1993 }
1994 }
1995
1996 if (!name_len) /* empty name -> drive root doesn't exist */
1997 {
1998 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
1999 return STATUS_OBJECT_PATH_NOT_FOUND;
2000 }
2001 if (check_case && (disposition == FILE_OPEN || disposition == FILE_OVERWRITE))
2002 {
2003 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2004 return STATUS_OBJECT_NAME_NOT_FOUND;
2005 }
2006
2007 /* now do it component by component */
2008
2009 while (name_len)
2010 {
2011 const WCHAR *end, *next;
2012
2013 end = name;
2014 while (end < name + name_len && !IS_SEPARATOR(*end)) end++;
2015 next = end;
2016 while (next < name + name_len && IS_SEPARATOR(*next)) next++;
2017 name_len -= next - name;
2018
2019 /* grow the buffer if needed */
2020
2021 if (unix_len - pos < MAX_DIR_ENTRY_LEN + 2)
2022 {
2023 char *new_name;
2024 unix_len += 2 * MAX_DIR_ENTRY_LEN;
2025 if (!(new_name = RtlReAllocateHeap( GetProcessHeap(), 0, unix_name, unix_len )))
2026 {
2027 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2028 return STATUS_NO_MEMORY;
2029 }
2030 unix_name = new_name;
2031 }
2032
2033 status = find_file_in_dir( unix_name, pos, name, end - name, check_case );
2034
2035 /* if this is the last element, not finding it is not necessarily fatal */
2036 if (!name_len)
2037 {
2038 if (status == STATUS_OBJECT_PATH_NOT_FOUND)
2039 {
2040 status = STATUS_OBJECT_NAME_NOT_FOUND;
2041 if (disposition != FILE_OPEN && disposition != FILE_OVERWRITE)
2042 {
2043 ret = ntdll_wcstoumbs( 0, name, end - name, unix_name + pos + 1,
2044 MAX_DIR_ENTRY_LEN, NULL, &used_default );
2045 if (ret > 0 && !used_default)
2046 {
2047 unix_name[pos] = '/';
2048 unix_name[pos + 1 + ret] = 0;
2049 status = STATUS_NO_SUCH_FILE;
2050 break;
2051 }
2052 }
2053 }
2054 else if (status == STATUS_SUCCESS && disposition == FILE_CREATE)
2055 {
2056 status = STATUS_OBJECT_NAME_COLLISION;
2057 }
2058 }
2059
2060 if (status != STATUS_SUCCESS)
2061 {
2062 /* couldn't find it at all, fail */
2063 WARN( "%s not found in %s\n", debugstr_w(name), unix_name );
2064 RtlFreeHeap( GetProcessHeap(), 0, unix_name );
2065 return status;
2066 }
2067
2068 pos += strlen( unix_name + pos );
2069 name = next;
2070 }
2071
2072 WARN( "%s -> %s required a case-insensitive search\n",
2073 debugstr_us(nameW), debugstr_a(unix_name) );
2074
2075 done:
2076 TRACE( "%s -> %s\n", debugstr_us(nameW), debugstr_a(unix_name) );
2077 unix_name_ret->Buffer = unix_name;
2078 unix_name_ret->Length = strlen(unix_name);
2079 unix_name_ret->MaximumLength = unix_len;
2080 return status;
2081 }
2082
2083
2084 /******************************************************************
2085 * RtlDoesFileExists_U (NTDLL.@)
2086 */
2087 BOOLEAN WINAPI RtlDoesFileExists_U(LPCWSTR file_name)
2088 {
2089 UNICODE_STRING nt_name;
2090 FILE_BASIC_INFORMATION basic_info;
2091 OBJECT_ATTRIBUTES attr;
2092 BOOLEAN ret;
2093
2094 if (!RtlDosPathNameToNtPathName_U( file_name, &nt_name, NULL, NULL )) return FALSE;
2095
2096 attr.Length = sizeof(attr);
2097 attr.RootDirectory = 0;
2098 attr.ObjectName = &nt_name;
2099 attr.Attributes = OBJ_CASE_INSENSITIVE;
2100 attr.SecurityDescriptor = NULL;
2101 attr.SecurityQualityOfService = NULL;
2102
2103 ret = NtQueryAttributesFile(&attr, &basic_info) == STATUS_SUCCESS;
2104
2105 RtlFreeUnicodeString( &nt_name );
2106 return ret;
2107 }
2108
2109
2110 /***********************************************************************
2111 * DIR_unmount_device
2112 *
2113 * Unmount the specified device.
2114 */
2115 NTSTATUS DIR_unmount_device( HANDLE handle )
2116 {
2117 NTSTATUS status;
2118 int unix_fd, needs_close;
2119
2120 if (!(status = server_get_unix_fd( handle, 0, &unix_fd, &needs_close, NULL, NULL )))
2121 {
2122 struct stat st;
2123 char *mount_point = NULL;
2124
2125 if (fstat( unix_fd, &st ) == -1 || !is_valid_mounted_device( &st ))
2126 status = STATUS_INVALID_PARAMETER;
2127 else
2128 {
2129 if ((mount_point = get_device_mount_point( st.st_rdev )))
2130 {
2131 #ifdef __APPLE__
2132 static const char umount[] = "diskutil unmount >/dev/null 2>&1 ";
2133 #else
2134 static const char umount[] = "umount >/dev/null 2>&1 ";
2135 #endif
2136 char *cmd = RtlAllocateHeap( GetProcessHeap(), 0, strlen(mount_point)+sizeof(umount));
2137 if (cmd)
2138 {
2139 strcpy( cmd, umount );
2140 strcat( cmd, mount_point );
2141 system( cmd );
2142 RtlFreeHeap( GetProcessHeap(), 0, cmd );
2143 #ifdef linux
2144 /* umount will fail to release the loop device since we still have
2145 a handle to it, so we release it here */
2146 if (major(st.st_rdev) == LOOP_MAJOR) ioctl( unix_fd, 0x4c01 /*LOOP_CLR_FD*/, 0 );
2147 #endif
2148 }
2149 RtlFreeHeap( GetProcessHeap(), 0, mount_point );
2150 }
2151 }
2152 if (needs_close) close( unix_fd );
2153 }
2154 return status;
2155 }
2156
2157
2158 /******************************************************************************
2159 * DIR_get_unix_cwd
2160 *
2161 * Retrieve the Unix name of the current directory; helper for wine_unix_to_nt_file_name.
2162 * Returned value must be freed by caller.
2163 */
2164 NTSTATUS DIR_get_unix_cwd( char **cwd )
2165 {
2166 int old_cwd, unix_fd, needs_close;
2167 CURDIR *curdir;
2168 HANDLE handle;
2169 NTSTATUS status;
2170
2171 RtlAcquirePebLock();
2172
2173 if (NtCurrentTeb()->Tib.SubSystemTib) /* FIXME: hack */
2174 curdir = &((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir;
2175 else
2176 curdir = &NtCurrentTeb()->Peb->ProcessParameters->CurrentDirectory;
2177
2178 if (!(handle = curdir->Handle))
2179 {
2180 UNICODE_STRING dirW;
2181 OBJECT_ATTRIBUTES attr;
2182 IO_STATUS_BLOCK io;
2183
2184 if (!RtlDosPathNameToNtPathName_U( curdir->DosPath.Buffer, &dirW, NULL, NULL ))
2185 {
2186 status = STATUS_OBJECT_NAME_INVALID;
2187 goto done;
2188 }
2189 attr.Length = sizeof(attr);
2190 attr.RootDirectory = 0;
2191 attr.Attributes = OBJ_CASE_INSENSITIVE;
2192 attr.ObjectName = &dirW;
2193 attr.SecurityDescriptor = NULL;
2194 attr.SecurityQualityOfService = NULL;
2195
2196 status = NtOpenFile( &handle, 0, &attr, &io, 0,
2197 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
2198 RtlFreeUnicodeString( &dirW );
2199 if (status != STATUS_SUCCESS) goto done;
2200 }
2201
2202 if ((status = server_get_unix_fd( handle, 0, &unix_fd, &needs_close, NULL, NULL )) == STATUS_SUCCESS)
2203 {
2204 RtlEnterCriticalSection( &dir_section );
2205
2206 if ((old_cwd = open(".", O_RDONLY)) != -1 && fchdir( unix_fd ) != -1)
2207 {
2208 unsigned int size = 512;
2209
2210 for (;;)
2211 {
2212 if (!(*cwd = RtlAllocateHeap( GetProcessHeap(), 0, size )))
2213 {
2214 status = STATUS_NO_MEMORY;
2215 break;
2216 }
2217 if (getcwd( *cwd, size )) break;
2218 RtlFreeHeap( GetProcessHeap(), 0, *cwd );
2219 if (errno != ERANGE)
2220 {
2221 status = STATUS_OBJECT_PATH_INVALID;
2222 break;
2223 }
2224 size *= 2;
2225 }
2226 if (fchdir( old_cwd ) == -1) chdir( "/" );
2227 }
2228 else status = FILE_GetNtStatus();
2229
2230 RtlLeaveCriticalSection( &dir_section );
2231 if (needs_close) close( unix_fd );
2232 }
2233 if (!curdir->Handle) NtClose( handle );
2234
2235 done:
2236 RtlReleasePebLock();
2237 return status;
2238 }
2239
2240 struct read_changes_info
2241 {
2242 HANDLE FileHandle;
2243 PVOID Buffer;
2244 ULONG BufferSize;
2245 PIO_APC_ROUTINE apc;
2246 void *apc_arg;
2247 };
2248
2249 /* callback for ioctl user APC */
2250 static void WINAPI read_changes_user_apc( void *arg, IO_STATUS_BLOCK *io, ULONG reserved )
2251 {
2252 struct read_changes_info *info = arg;
2253 if (info->apc) info->apc( info->apc_arg, io, reserved );
2254 RtlFreeHeap( GetProcessHeap(), 0, info );
2255 }
2256
2257 static NTSTATUS read_changes_apc( void *user, PIO_STATUS_BLOCK iosb, NTSTATUS status )
2258 {
2259 struct read_changes_info *info = user;
2260 char path[PATH_MAX];
2261 NTSTATUS ret = STATUS_SUCCESS;
2262 int len, action, i;
2263
2264 SERVER_START_REQ( read_change )
2265 {
2266 req->handle = info->FileHandle;
2267 wine_server_set_reply( req, path, PATH_MAX );
2268 ret = wine_server_call( req );
2269 action = reply->action;
2270 len = wine_server_reply_size( reply );
2271 }
2272 SERVER_END_REQ;
2273
2274 if (ret == STATUS_SUCCESS && info->Buffer &&
2275 (info->BufferSize > (sizeof (FILE_NOTIFY_INFORMATION) + len*sizeof(WCHAR))))
2276 {
2277 PFILE_NOTIFY_INFORMATION pfni;
2278
2279 pfni = (PFILE_NOTIFY_INFORMATION) info->Buffer;
2280
2281 /* convert to an NT style path */
2282 for (i=0; i<len; i++)
2283 if (path[i] == '/')
2284 path[i] = '\\';
2285
2286 len = ntdll_umbstowcs( 0, path, len, pfni->FileName,
2287 info->BufferSize - sizeof (*pfni) );
2288
2289 pfni->NextEntryOffset = 0;
2290 pfni->Action = action;
2291 pfni->FileNameLength = len * sizeof (WCHAR);
2292 pfni->FileName[len] = 0;
2293 len = sizeof (*pfni) - sizeof (DWORD) + pfni->FileNameLength;
2294 }
2295 else
2296 {
2297 ret = STATUS_NOTIFY_ENUM_DIR;
2298 len = 0;
2299 }
2300
2301 iosb->u.Status = ret;
2302 iosb->Information = len;
2303 return ret;
2304 }
2305
2306 #define FILE_NOTIFY_ALL ( \
2307 FILE_NOTIFY_CHANGE_FILE_NAME | \
2308 FILE_NOTIFY_CHANGE_DIR_NAME | \
2309 FILE_NOTIFY_CHANGE_ATTRIBUTES | \
2310 FILE_NOTIFY_CHANGE_SIZE | \
2311 FILE_NOTIFY_CHANGE_LAST_WRITE | \
2312 FILE_NOTIFY_CHANGE_LAST_ACCESS | \
2313 FILE_NOTIFY_CHANGE_CREATION | \
2314 FILE_NOTIFY_CHANGE_SECURITY )
2315
2316 /******************************************************************************
2317 * NtNotifyChangeDirectoryFile [NTDLL.@]
2318 */
2319 NTSTATUS WINAPI
2320 NtNotifyChangeDirectoryFile( HANDLE FileHandle, HANDLE Event,
2321 PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,
2322 PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer,
2323 ULONG BufferSize, ULONG CompletionFilter, BOOLEAN WatchTree )
2324 {
2325 struct read_changes_info *info;
2326 NTSTATUS status;
2327
2328 TRACE("%p %p %p %p %p %p %u %u %d\n",
2329 FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock,
2330 Buffer, BufferSize, CompletionFilter, WatchTree );
2331
2332 if (!IoStatusBlock)
2333 return STATUS_ACCESS_VIOLATION;
2334
2335 if (CompletionFilter == 0 || (CompletionFilter & ~FILE_NOTIFY_ALL))
2336 return STATUS_INVALID_PARAMETER;
2337
2338 info = RtlAllocateHeap( GetProcessHeap(), 0, sizeof *info );
2339 if (!info)
2340 return STATUS_NO_MEMORY;
2341
2342 info->FileHandle = FileHandle;
2343 info->Buffer = Buffer;
2344 info->BufferSize = BufferSize;
2345 info->apc = ApcRoutine;
2346 info->apc_arg = ApcContext;
2347
2348 SERVER_START_REQ( read_directory_changes )
2349 {
2350 req->handle = FileHandle;
2351 req->filter = CompletionFilter;
2352 req->want_data = (Buffer != NULL);
2353 req->subtree = WatchTree;
2354 req->async.callback = read_changes_apc;
2355 req->async.iosb = IoStatusBlock;
2356 req->async.arg = info;
2357 req->async.apc = read_changes_user_apc;
2358 req->async.event = Event;
2359 req->async.cvalue = 0;
2360 status = wine_server_call( req );
2361 }
2362 SERVER_END_REQ;
2363
2364 if (status != STATUS_PENDING)
2365 RtlFreeHeap( GetProcessHeap(), 0, info );
2366
2367 return status;
2368 }