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