?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Allow NtQueryVolumeInformationFile to make async volume information queries.
[wine/zf.git] / dlls / ntdll / unix / file.c
blob00ca2005f92b3273942daa77cdf6de07bc038b9c
1 /*
2 * NTDLL directory and file 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 #if 0
24 #pragma makedep unix
25 #endif
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <assert.h>
31 #include <sys/types.h>
32 #include <dirent.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <stdarg.h>
36 #include <string.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <limits.h>
40 #ifdef HAVE_MNTENT_H
41 #include <mntent.h>
42 #endif
43 #ifdef HAVE_POLL_H
44 #include <poll.h>
45 #endif
46 #ifdef HAVE_SYS_STAT_H
47 # include <sys/stat.h>
48 #endif
49 #ifdef HAVE_SYS_STATVFS_H
50 # include <sys/statvfs.h>
51 #endif
52 #ifdef HAVE_SYS_SYSCALL_H
53 # include <sys/syscall.h>
54 #endif
55 #ifdef HAVE_SYS_SOCKET_H
56 #include <sys/socket.h>
57 #endif
58 #ifdef HAVE_SYS_TIME_H
59 # include <sys/time.h>
60 #endif
61 #ifdef HAVE_SYS_ATTR_H
62 #include <sys/attr.h>
63 #endif
64 #ifdef MAJOR_IN_MKDEV
65 # include <sys/mkdev.h>
66 #elif defined(MAJOR_IN_SYSMACROS)
67 # include <sys/sysmacros.h>
68 #endif
69 #ifdef HAVE_SYS_VNODE_H
70 # ifdef HAVE_STDINT_H
71 # include <stdint.h> /* needed for kfreebsd */
72 # endif
73 /* Work around a conflict with Solaris' system list defined in sys/list.h. */
74 #define list SYSLIST
75 #define list_next SYSLIST_NEXT
76 #define list_prev SYSLIST_PREV
77 #define list_head SYSLIST_HEAD
78 #define list_tail SYSLIST_TAIL
79 #define list_move_tail SYSLIST_MOVE_TAIL
80 #define list_remove SYSLIST_REMOVE
81 #include <sys/vnode.h>
82 #undef list
83 #undef list_next
84 #undef list_prev
85 #undef list_head
86 #undef list_tail
87 #undef list_move_tail
88 #undef list_remove
89 #endif
90 #ifdef HAVE_SYS_IOCTL_H
91 #include <sys/ioctl.h>
92 #endif
93 #ifdef HAVE_LINUX_IOCTL_H
94 #include <linux/ioctl.h>
95 #endif
96 #ifdef HAVE_LINUX_MAJOR_H
97 # include <linux/major.h>
98 #endif
99 #ifdef HAVE_SYS_PARAM_H
100 #include <sys/param.h>
101 #endif
102 #ifdef HAVE_SYS_CONF_H
103 #include <sys/conf.h>
104 #endif
105 #ifdef HAVE_SYS_MOUNT_H
106 #include <sys/mount.h>
107 #endif
108 #ifdef HAVE_SYS_STATFS_H
109 #include <sys/statfs.h>
110 #endif
111 #include <time.h>
112 #ifdef HAVE_UNISTD_H
113 # include <unistd.h>
114 #endif
115
116 #include "ntstatus.h"
117 #define WIN32_NO_STATUS
118 #define NONAMELESSUNION
119 #include "windef.h"
120 #include "winnt.h"
121 #include "winioctl.h"
122 #include "winternl.h"
123 #include "ddk/ntddk.h"
124 #include "ddk/ntddser.h"
125 #include "ddk/wdm.h"
126 #define WINE_MOUNTMGR_EXTENSIONS
127 #include "ddk/mountmgr.h"
128 #include "wine/server.h"
129 #include "wine/list.h"
130 #include "wine/debug.h"
131 #include "unix_private.h"
132
133 WINE_DEFAULT_DEBUG_CHANNEL(file);
134 WINE_DECLARE_DEBUG_CHANNEL(winediag);
135
136 #define MAX_DOS_DRIVES 26
137
138 #define FILE_WRITE_TO_END_OF_FILE ((LONGLONG)-1)
139 #define FILE_USE_FILE_POINTER_POSITION ((LONGLONG)-2)
140
141 /* just in case... */
142 #undef VFAT_IOCTL_READDIR_BOTH
143 #undef EXT2_IOC_GETFLAGS
144 #undef EXT4_CASEFOLD_FL
145
146 #ifdef linux
147
148 /* We want the real kernel dirent structure, not the libc one */
149 typedef struct
150 {
151 long d_ino;
152 long d_off;
153 unsigned short d_reclen;
154 char d_name[256];
155 } KERNEL_DIRENT;
156
157 /* Define the VFAT ioctl to get both short and long file names */
158 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, KERNEL_DIRENT [2] )
159
160 /* Define the ext2 ioctl for handling extra attributes */
161 #define EXT2_IOC_GETFLAGS _IOR('f', 1, long)
162
163 /* Case-insensitivity attribute */
164 #define EXT4_CASEFOLD_FL 0x40000000
165
166 #ifndef O_DIRECTORY
167 # define O_DIRECTORY 0200000 /* must be directory */
168 #endif
169
170 #ifndef AT_NO_AUTOMOUNT
171 #define AT_NO_AUTOMOUNT 0x800
172 #endif
173
174 #endif /* linux */
175
176 #define IS_SEPARATOR(ch) ((ch) == '\\' || (ch) == '/')
177
178 #define INVALID_NT_CHARS '*','?','<','>','|','"'
179 #define INVALID_DOS_CHARS INVALID_NT_CHARS,'+','=',',',';','[',']',' ','\345'
180
181 #define MAX_DIR_ENTRY_LEN 255 /* max length of a directory entry in chars */
182
183 #define MAX_IGNORED_FILES 4
184
185 struct file_identity
186 {
187 dev_t dev;
188 ino_t ino;
189 };
190
191 static struct file_identity ignored_files[MAX_IGNORED_FILES];
192 static unsigned int ignored_files_count;
193
194 union file_directory_info
195 {
196 ULONG next;
197 FILE_DIRECTORY_INFORMATION dir;
198 FILE_BOTH_DIRECTORY_INFORMATION both;
199 FILE_FULL_DIRECTORY_INFORMATION full;
200 FILE_ID_BOTH_DIRECTORY_INFORMATION id_both;
201 FILE_ID_FULL_DIRECTORY_INFORMATION id_full;
202 FILE_ID_GLOBAL_TX_DIR_INFORMATION id_tx;
203 FILE_NAMES_INFORMATION names;
204 };
205
206 struct dir_data_buffer
207 {
208 struct dir_data_buffer *next; /* next buffer in the list */
209 unsigned int size; /* total size of the buffer */
210 unsigned int pos; /* current position in the buffer */
211 char data[1];
212 };
213
214 struct dir_data_names
215 {
216 const WCHAR *long_name; /* long file name in Unicode */
217 const WCHAR *short_name; /* short file name in Unicode */
218 const char *unix_name; /* Unix file name in host encoding */
219 };
220
221 struct dir_data
222 {
223 unsigned int size; /* size of the names array */
224 unsigned int count; /* count of used entries in the names array */
225 unsigned int pos; /* current reading position in the names array */
226 struct file_identity id; /* directory file identity */
227 struct dir_data_names *names; /* directory file names */
228 struct dir_data_buffer *buffer; /* head of data buffers list */
229 };
230
231 static const unsigned int dir_data_buffer_initial_size = 4096;
232 static const unsigned int dir_data_cache_initial_size = 256;
233 static const unsigned int dir_data_names_initial_size = 64;
234
235 static struct dir_data **dir_data_cache;
236 static unsigned int dir_data_cache_size;
237
238 static BOOL show_dot_files;
239 static mode_t start_umask;
240
241 /* at some point we may want to allow Winelib apps to set this */
242 static const BOOL is_case_sensitive = FALSE;
243
244 static struct file_identity windir;
245
246 static pthread_mutex_t dir_mutex = PTHREAD_MUTEX_INITIALIZER;
247 static pthread_mutex_t mnt_mutex = PTHREAD_MUTEX_INITIALIZER;
248
249 /* check if a given Unicode char is OK in a DOS short name */
250 static inline BOOL is_invalid_dos_char( WCHAR ch )
251 {
252 static const WCHAR invalid_chars[] = { INVALID_DOS_CHARS,'~','.',0 };
253 if (ch > 0x7f) return TRUE;
254 return wcschr( invalid_chars, ch ) != NULL;
255 }
256
257 /* check if the device can be a mounted volume */
258 static inline BOOL is_valid_mounted_device( const struct stat *st )
259 {
260 #if defined(linux) || defined(__sun__)
261 return S_ISBLK( st->st_mode );
262 #else
263 /* disks are char devices on *BSD */
264 return S_ISCHR( st->st_mode );
265 #endif
266 }
267
268 static inline void ignore_file( const char *name )
269 {
270 struct stat st;
271 assert( ignored_files_count < MAX_IGNORED_FILES );
272 if (!stat( name, &st ))
273 {
274 ignored_files[ignored_files_count].dev = st.st_dev;
275 ignored_files[ignored_files_count].ino = st.st_ino;
276 ignored_files_count++;
277 }
278 }
279
280 static inline BOOL is_same_file( const struct file_identity *file, const struct stat *st )
281 {
282 return st->st_dev == file->dev && st->st_ino == file->ino;
283 }
284
285 static inline BOOL is_ignored_file( const struct stat *st )
286 {
287 unsigned int i;
288
289 for (i = 0; i < ignored_files_count; i++)
290 if (is_same_file( &ignored_files[i], st )) return TRUE;
291 return FALSE;
292 }
293
294 static inline unsigned int dir_info_align( unsigned int len )
295 {
296 return (len + 7) & ~7;
297 }
298
299 static inline unsigned int dir_info_size( FILE_INFORMATION_CLASS class, unsigned int len )
300 {
301 switch (class)
302 {
303 case FileDirectoryInformation:
304 return offsetof( FILE_DIRECTORY_INFORMATION, FileName[len] );
305 case FileBothDirectoryInformation:
306 return offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[len] );
307 case FileFullDirectoryInformation:
308 return offsetof( FILE_FULL_DIRECTORY_INFORMATION, FileName[len] );
309 case FileIdBothDirectoryInformation:
310 return offsetof( FILE_ID_BOTH_DIRECTORY_INFORMATION, FileName[len] );
311 case FileIdFullDirectoryInformation:
312 return offsetof( FILE_ID_FULL_DIRECTORY_INFORMATION, FileName[len] );
313 case FileIdGlobalTxDirectoryInformation:
314 return offsetof( FILE_ID_GLOBAL_TX_DIR_INFORMATION, FileName[len] );
315 case FileNamesInformation:
316 return offsetof( FILE_NAMES_INFORMATION, FileName[len] );
317 default:
318 assert(0);
319 return 0;
320 }
321 }
322
323 static inline BOOL has_wildcard( const UNICODE_STRING *mask )
324 {
325 int i;
326
327 if (!mask) return TRUE;
328 for (i = 0; i < mask->Length / sizeof(WCHAR); i++)
329 if (mask->Buffer[i] == '*' || mask->Buffer[i] == '?') return TRUE;
330 return FALSE;
331 }
332
333 NTSTATUS errno_to_status( int err )
334 {
335 TRACE( "errno = %d\n", err );
336 switch (err)
337 {
338 case EAGAIN: return STATUS_SHARING_VIOLATION;
339 case EBADF: return STATUS_INVALID_HANDLE;
340 case EBUSY: return STATUS_DEVICE_BUSY;
341 case ENOSPC: return STATUS_DISK_FULL;
342 case EPERM:
343 case EROFS:
344 case EACCES: return STATUS_ACCESS_DENIED;
345 case ENOTDIR: return STATUS_OBJECT_PATH_NOT_FOUND;
346 case ENOENT: return STATUS_OBJECT_NAME_NOT_FOUND;
347 case EISDIR: return STATUS_INVALID_DEVICE_REQUEST;
348 case EMFILE:
349 case ENFILE: return STATUS_TOO_MANY_OPENED_FILES;
350 case EINVAL: return STATUS_INVALID_PARAMETER;
351 case ENOTEMPTY: return STATUS_DIRECTORY_NOT_EMPTY;
352 case EPIPE: return STATUS_PIPE_DISCONNECTED;
353 case EIO: return STATUS_DEVICE_NOT_READY;
354 #ifdef ENOMEDIUM
355 case ENOMEDIUM: return STATUS_NO_MEDIA_IN_DEVICE;
356 #endif
357 case ENXIO: return STATUS_NO_SUCH_DEVICE;
358 case ENOTTY:
359 case EOPNOTSUPP:return STATUS_NOT_SUPPORTED;
360 case ECONNRESET:return STATUS_PIPE_DISCONNECTED;
361 case EFAULT: return STATUS_ACCESS_VIOLATION;
362 case ESPIPE: return STATUS_ILLEGAL_FUNCTION;
363 case ELOOP: return STATUS_REPARSE_POINT_NOT_RESOLVED;
364 #ifdef ETIME /* Missing on FreeBSD */
365 case ETIME: return STATUS_IO_TIMEOUT;
366 #endif
367 case ENOEXEC: /* ?? */
368 case EEXIST: /* ?? */
369 default:
370 FIXME( "Converting errno %d to STATUS_UNSUCCESSFUL\n", err );
371 return STATUS_UNSUCCESSFUL;
372 }
373 }
374
375 /* get space from the current directory data buffer, allocating a new one if necessary */
376 static void *get_dir_data_space( struct dir_data *data, unsigned int size )
377 {
378 struct dir_data_buffer *buffer = data->buffer;
379 void *ret;
380
381 if (!buffer || size > buffer->size - buffer->pos)
382 {
383 unsigned int new_size = buffer ? buffer->size * 2 : dir_data_buffer_initial_size;
384 if (new_size < size) new_size = size;
385 if (!(buffer = malloc( offsetof( struct dir_data_buffer, data[new_size] ) ))) return NULL;
386 buffer->pos = 0;
387 buffer->size = new_size;
388 buffer->next = data->buffer;
389 data->buffer = buffer;
390 }
391 ret = buffer->data + buffer->pos;
392 buffer->pos += size;
393 return ret;
394 }
395
396 /* add a string to the directory data buffer */
397 static const char *add_dir_data_nameA( struct dir_data *data, const char *name )
398 {
399 /* keep buffer data WCHAR-aligned */
400 char *ptr = get_dir_data_space( data, (strlen( name ) + sizeof(WCHAR)) & ~(sizeof(WCHAR) - 1) );
401 if (ptr) strcpy( ptr, name );
402 return ptr;
403 }
404
405 /* add a Unicode string to the directory data buffer */
406 static const WCHAR *add_dir_data_nameW( struct dir_data *data, const WCHAR *name )
407 {
408 WCHAR *ptr = get_dir_data_space( data, (wcslen( name ) + 1) * sizeof(WCHAR) );
409 if (ptr) wcscpy( ptr, name );
410 return ptr;
411 }
412
413 /* add an entry to the directory names array */
414 static BOOL add_dir_data_names( struct dir_data *data, const WCHAR *long_name,
415 const WCHAR *short_name, const char *unix_name )
416 {
417 static const WCHAR empty[1];
418 struct dir_data_names *names = data->names;
419
420 if (data->count >= data->size)
421 {
422 unsigned int new_size = max( data->size * 2, dir_data_names_initial_size );
423
424 if (!(names = realloc( names, new_size * sizeof(*names) ))) return FALSE;
425 data->size = new_size;
426 data->names = names;
427 }
428
429 if (short_name[0])
430 {
431 if (!(names[data->count].short_name = add_dir_data_nameW( data, short_name ))) return FALSE;
432 }
433 else names[data->count].short_name = empty;
434
435 if (!(names[data->count].long_name = add_dir_data_nameW( data, long_name ))) return FALSE;
436 if (!(names[data->count].unix_name = add_dir_data_nameA( data, unix_name ))) return FALSE;
437 data->count++;
438 return TRUE;
439 }
440
441 /* free the complete directory data structure */
442 static void free_dir_data( struct dir_data *data )
443 {
444 struct dir_data_buffer *buffer, *next;
445
446 if (!data) return;
447
448 for (buffer = data->buffer; buffer; buffer = next)
449 {
450 next = buffer->next;
451 free( buffer );
452 }
453 free( data->names );
454 free( data );
455 }
456
457
458 /* support for a directory queue for filesystem searches */
459
460 struct dir_name
461 {
462 struct list entry;
463 char name[1];
464 };
465
466 static struct list dir_queue = LIST_INIT( dir_queue );
467
468 static NTSTATUS add_dir_to_queue( const char *name )
469 {
470 int len = strlen( name ) + 1;
471 struct dir_name *dir = malloc( offsetof( struct dir_name, name[len] ));
472 if (!dir) return STATUS_NO_MEMORY;
473 strcpy( dir->name, name );
474 list_add_tail( &dir_queue, &dir->entry );
475 return STATUS_SUCCESS;
476 }
477
478 static NTSTATUS next_dir_in_queue( char *name )
479 {
480 struct list *head = list_head( &dir_queue );
481 if (head)
482 {
483 struct dir_name *dir = LIST_ENTRY( head, struct dir_name, entry );
484 strcpy( name, dir->name );
485 list_remove( &dir->entry );
486 free( dir );
487 return STATUS_SUCCESS;
488 }
489 return STATUS_OBJECT_NAME_NOT_FOUND;
490 }
491
492 static void flush_dir_queue(void)
493 {
494 struct list *head;
495
496 while ((head = list_head( &dir_queue )))
497 {
498 struct dir_name *dir = LIST_ENTRY( head, struct dir_name, entry );
499 list_remove( &dir->entry );
500 free( dir );
501 }
502 }
503
504
505 #ifdef __ANDROID__
506
507 static char *unescape_field( char *str )
508 {
509 char *in, *out;
510
511 for (in = out = str; *in; in++, out++)
512 {
513 *out = *in;
514 if (in[0] == '\\')
515 {
516 if (in[1] == '\\')
517 {
518 out[0] = '\\';
519 in++;
520 }
521 else if (in[1] == '0' && in[2] == '4' && in[3] == '0')
522 {
523 out[0] = ' ';
524 in += 3;
525 }
526 else if (in[1] == '0' && in[2] == '1' && in[3] == '1')
527 {
528 out[0] = '\t';
529 in += 3;
530 }
531 else if (in[1] == '0' && in[2] == '1' && in[3] == '2')
532 {
533 out[0] = '\n';
534 in += 3;
535 }
536 else if (in[1] == '1' && in[2] == '3' && in[3] == '4')
537 {
538 out[0] = '\\';
539 in += 3;
540 }
541 }
542 }
543 *out = '\0';
544
545 return str;
546 }
547
548 static inline char *get_field( char **str )
549 {
550 char *ret;
551
552 ret = strsep( str, " \t" );
553 if (*str) *str += strspn( *str, " \t" );
554
555 return ret;
556 }
557 /************************************************************************
558 * getmntent_replacement
559 *
560 * getmntent replacement for Android.
561 *
562 * NB returned static buffer is not thread safe; protect with mnt_mutex.
563 */
564 static struct mntent *getmntent_replacement( FILE *f )
565 {
566 static struct mntent entry;
567 static char buf[4096];
568 char *p, *start;
569
570 do
571 {
572 if (!fgets( buf, sizeof(buf), f )) return NULL;
573 p = strchr( buf, '\n' );
574 if (p) *p = '\0';
575 else /* Partially unread line, move file ptr to end */
576 {
577 char tmp[1024];
578 while (fgets( tmp, sizeof(tmp), f ))
579 if (strchr( tmp, '\n' )) break;
580 }
581 start = buf + strspn( buf, " \t" );
582 } while (start[0] == '\0' || start[0] == '#');
583
584 p = get_field( &start );
585 entry.mnt_fsname = p ? unescape_field( p ) : (char *)"";
586
587 p = get_field( &start );
588 entry.mnt_dir = p ? unescape_field( p ) : (char *)"";
589
590 p = get_field( &start );
591 entry.mnt_type = p ? unescape_field( p ) : (char *)"";
592
593 p = get_field( &start );
594 entry.mnt_opts = p ? unescape_field( p ) : (char *)"";
595
596 p = get_field( &start );
597 entry.mnt_freq = p ? atoi(p) : 0;
598
599 p = get_field( &start );
600 entry.mnt_passno = p ? atoi(p) : 0;
601
602 return &entry;
603 }
604 #define getmntent getmntent_replacement
605 #endif
606
607 /***********************************************************************
608 * parse_mount_entries
609 *
610 * Parse mount entries looking for a given device. Helper for get_default_drive_device.
611 */
612
613 #ifdef sun
614 #include <sys/vfstab.h>
615 static char *parse_vfstab_entries( FILE *f, dev_t dev, ino_t ino)
616 {
617 struct vfstab entry;
618 struct stat st;
619 char *device;
620
621 while (! getvfsent( f, &entry ))
622 {
623 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
624 if (!strcmp( entry.vfs_fstype, "nfs" ) ||
625 !strcmp( entry.vfs_fstype, "smbfs" ) ||
626 !strcmp( entry.vfs_fstype, "ncpfs" )) continue;
627
628 if (stat( entry.vfs_mountp, &st ) == -1) continue;
629 if (st.st_dev != dev || st.st_ino != ino) continue;
630 if (!strcmp( entry.vfs_fstype, "fd" ))
631 {
632 if ((device = strstr( entry.vfs_mntopts, "dev=" )))
633 {
634 char *p = strchr( device + 4, ',' );
635 if (p) *p = 0;
636 return device + 4;
637 }
638 }
639 else
640 return entry.vfs_special;
641 }
642 return NULL;
643 }
644 #endif
645
646 #ifdef linux
647 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
648 {
649 struct mntent *entry;
650 struct stat st;
651 char *device;
652
653 while ((entry = getmntent( f )))
654 {
655 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
656 if (!strcmp( entry->mnt_type, "nfs" ) ||
657 !strcmp( entry->mnt_type, "cifs" ) ||
658 !strcmp( entry->mnt_type, "smbfs" ) ||
659 !strcmp( entry->mnt_type, "ncpfs" )) continue;
660
661 if (stat( entry->mnt_dir, &st ) == -1) continue;
662 if (st.st_dev != dev || st.st_ino != ino) continue;
663 if (!strcmp( entry->mnt_type, "supermount" ))
664 {
665 if ((device = strstr( entry->mnt_opts, "dev=" )))
666 {
667 char *p = strchr( device + 4, ',' );
668 if (p) *p = 0;
669 return device + 4;
670 }
671 }
672 else if (!stat( entry->mnt_fsname, &st ) && S_ISREG(st.st_mode))
673 {
674 /* if device is a regular file check for a loop mount */
675 if ((device = strstr( entry->mnt_opts, "loop=" )))
676 {
677 char *p = strchr( device + 5, ',' );
678 if (p) *p = 0;
679 return device + 5;
680 }
681 }
682 else
683 return entry->mnt_fsname;
684 }
685 return NULL;
686 }
687 #endif
688
689 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
690 #include <fstab.h>
691 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
692 {
693 struct fstab *entry;
694 struct stat st;
695
696 while ((entry = getfsent()))
697 {
698 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
699 if (!strcmp( entry->fs_vfstype, "nfs" ) ||
700 !strcmp( entry->fs_vfstype, "smbfs" ) ||
701 !strcmp( entry->fs_vfstype, "ncpfs" )) continue;
702
703 if (stat( entry->fs_file, &st ) == -1) continue;
704 if (st.st_dev != dev || st.st_ino != ino) continue;
705 return entry->fs_spec;
706 }
707 return NULL;
708 }
709 #endif
710
711 #ifdef sun
712 #include <sys/mnttab.h>
713 static char *parse_mount_entries( FILE *f, dev_t dev, ino_t ino )
714 {
715 struct mnttab entry;
716 struct stat st;
717 char *device;
718
719
720 while (( ! getmntent( f, &entry) ))
721 {
722 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
723 if (!strcmp( entry.mnt_fstype, "nfs" ) ||
724 !strcmp( entry.mnt_fstype, "smbfs" ) ||
725 !strcmp( entry.mnt_fstype, "ncpfs" )) continue;
726
727 if (stat( entry.mnt_mountp, &st ) == -1) continue;
728 if (st.st_dev != dev || st.st_ino != ino) continue;
729 if (!strcmp( entry.mnt_fstype, "fd" ))
730 {
731 if ((device = strstr( entry.mnt_mntopts, "dev=" )))
732 {
733 char *p = strchr( device + 4, ',' );
734 if (p) *p = 0;
735 return device + 4;
736 }
737 }
738 else
739 return entry.mnt_special;
740 }
741 return NULL;
742 }
743 #endif
744
745 /***********************************************************************
746 * get_default_drive_device
747 *
748 * Return the default device to use for a given drive mount point.
749 */
750 static char *get_default_drive_device( const char *root )
751 {
752 char *ret = NULL;
753
754 #ifdef linux
755 FILE *f;
756 char *device = NULL;
757 int fd, res = -1;
758 struct stat st;
759
760 /* try to open it first to force it to get mounted */
761 if ((fd = open( root, O_RDONLY | O_DIRECTORY )) != -1)
762 {
763 res = fstat( fd, &st );
764 close( fd );
765 }
766 /* now try normal stat just in case */
767 if (res == -1) res = stat( root, &st );
768 if (res == -1) return NULL;
769
770 mutex_lock( &mnt_mutex );
771
772 #ifdef __ANDROID__
773 if ((f = fopen( "/proc/mounts", "r" )))
774 {
775 device = parse_mount_entries( f, st.st_dev, st.st_ino );
776 fclose( f );
777 }
778 #else
779 if ((f = fopen( "/etc/mtab", "r" )))
780 {
781 device = parse_mount_entries( f, st.st_dev, st.st_ino );
782 fclose( f );
783 }
784 /* look through fstab too in case it's not mounted (for instance if it's an audio CD) */
785 if (!device && (f = fopen( "/etc/fstab", "r" )))
786 {
787 device = parse_mount_entries( f, st.st_dev, st.st_ino );
788 fclose( f );
789 }
790 #endif
791 if (device) ret = strdup( device );
792 mutex_unlock( &mnt_mutex );
793
794 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__ ) || defined(__DragonFly__)
795 char *device = NULL;
796 int fd, res = -1;
797 struct stat st;
798
799 /* try to open it first to force it to get mounted */
800 if ((fd = open( root, O_RDONLY )) != -1)
801 {
802 res = fstat( fd, &st );
803 close( fd );
804 }
805 /* now try normal stat just in case */
806 if (res == -1) res = stat( root, &st );
807 if (res == -1) return NULL;
808
809 mutex_lock( &mnt_mutex );
810
811 /* The FreeBSD parse_mount_entries doesn't require a file argument, so just
812 * pass NULL. Leave the argument in for symmetry.
813 */
814 device = parse_mount_entries( NULL, st.st_dev, st.st_ino );
815 if (device) ret = strdup( device );
816 mutex_unlock( &mnt_mutex );
817
818 #elif defined( sun )
819 FILE *f;
820 char *device = NULL;
821 int fd, res = -1;
822 struct stat st;
823
824 /* try to open it first to force it to get mounted */
825 if ((fd = open( root, O_RDONLY )) != -1)
826 {
827 res = fstat( fd, &st );
828 close( fd );
829 }
830 /* now try normal stat just in case */
831 if (res == -1) res = stat( root, &st );
832 if (res == -1) return NULL;
833
834 mutex_lock( &mnt_mutex );
835
836 if ((f = fopen( "/etc/mnttab", "r" )))
837 {
838 device = parse_mount_entries( f, st.st_dev, st.st_ino);
839 fclose( f );
840 }
841 /* look through fstab too in case it's not mounted (for instance if it's an audio CD) */
842 if (!device && (f = fopen( "/etc/vfstab", "r" )))
843 {
844 device = parse_vfstab_entries( f, st.st_dev, st.st_ino );
845 fclose( f );
846 }
847 if (device) ret = strdup( device );
848 mutex_unlock( &mnt_mutex );
849
850 #elif defined(__APPLE__)
851 struct statfs *mntStat;
852 struct stat st;
853 int i;
854 int mntSize;
855 dev_t dev;
856 ino_t ino;
857 static const char path_bsd_device[] = "/dev/disk";
858 int res;
859
860 res = stat( root, &st );
861 if (res == -1) return NULL;
862
863 dev = st.st_dev;
864 ino = st.st_ino;
865
866 mutex_lock( &mnt_mutex );
867
868 mntSize = getmntinfo(&mntStat, MNT_NOWAIT);
869
870 for (i = 0; i < mntSize && !ret; i++)
871 {
872 if (stat(mntStat[i].f_mntonname, &st ) == -1) continue;
873 if (st.st_dev != dev || st.st_ino != ino) continue;
874
875 /* FIXME add support for mounted network drive */
876 if ( strncmp(mntStat[i].f_mntfromname, path_bsd_device, strlen(path_bsd_device)) == 0)
877 {
878 /* set return value to the corresponding raw BSD node */
879 ret = malloc( strlen(mntStat[i].f_mntfromname) + 2 /* 2 : r and \0 */ );
880 if (ret)
881 {
882 strcpy(ret, "/dev/r");
883 strcat(ret, mntStat[i].f_mntfromname+sizeof("/dev/")-1);
884 }
885 }
886 }
887 mutex_unlock( &mnt_mutex );
888 #else
889 static int warned;
890 if (!warned++) FIXME( "auto detection of DOS devices not supported on this platform\n" );
891 #endif
892 return ret;
893 }
894
895
896 /***********************************************************************
897 * get_device_mount_point
898 *
899 * Return the current mount point for a device.
900 */
901 static char *get_device_mount_point( dev_t dev )
902 {
903 char *ret = NULL;
904
905 #ifdef linux
906 FILE *f;
907
908 mutex_lock( &mnt_mutex );
909
910 #ifdef __ANDROID__
911 if ((f = fopen( "/proc/mounts", "r" )))
912 #else
913 if ((f = fopen( "/etc/mtab", "r" )))
914 #endif
915 {
916 struct mntent *entry;
917 struct stat st;
918 char *p, *device;
919
920 while ((entry = getmntent( f )))
921 {
922 /* don't even bother stat'ing network mounts, there's no meaningful device anyway */
923 if (!strcmp( entry->mnt_type, "nfs" ) ||
924 !strcmp( entry->mnt_type, "cifs" ) ||
925 !strcmp( entry->mnt_type, "smbfs" ) ||
926 !strcmp( entry->mnt_type, "ncpfs" )) continue;
927
928 if (!strcmp( entry->mnt_type, "supermount" ))
929 {
930 if ((device = strstr( entry->mnt_opts, "dev=" )))
931 {
932 device += 4;
933 if ((p = strchr( device, ',' ))) *p = 0;
934 }
935 }
936 else if (!stat( entry->mnt_fsname, &st ) && S_ISREG(st.st_mode))
937 {
938 /* if device is a regular file check for a loop mount */
939 if ((device = strstr( entry->mnt_opts, "loop=" )))
940 {
941 device += 5;
942 if ((p = strchr( device, ',' ))) *p = 0;
943 }
944 }
945 else device = entry->mnt_fsname;
946
947 if (device && !stat( device, &st ) && S_ISBLK(st.st_mode) && st.st_rdev == dev)
948 {
949 ret = strdup( entry->mnt_dir );
950 break;
951 }
952 }
953 fclose( f );
954 }
955 mutex_unlock( &mnt_mutex );
956 #elif defined(__APPLE__)
957 struct statfs *entry;
958 struct stat st;
959 int i, size;
960
961 mutex_lock( &mnt_mutex );
962
963 size = getmntinfo( &entry, MNT_NOWAIT );
964 for (i = 0; i < size; i++)
965 {
966 if (stat( entry[i].f_mntfromname, &st ) == -1) continue;
967 if (S_ISBLK(st.st_mode) && st.st_rdev == dev)
968 {
969 ret = strdup( entry[i].f_mntonname );
970 break;
971 }
972 }
973 mutex_unlock( &mnt_mutex );
974 #else
975 static int warned;
976 if (!warned++) FIXME( "unmounting devices not supported on this platform\n" );
977 #endif
978 return ret;
979 }
980
981
982 #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \
983 defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE)
984
985 struct get_fsid
986 {
987 ULONG size;
988 dev_t dev;
989 fsid_t fsid;
990 };
991
992 struct fs_cache
993 {
994 dev_t dev;
995 fsid_t fsid;
996 BOOLEAN case_sensitive;
997 } fs_cache[64];
998
999 struct vol_caps
1000 {
1001 ULONG size;
1002 vol_capabilities_attr_t caps;
1003 };
1004
1005 /***********************************************************************
1006 * look_up_fs_cache
1007 *
1008 * Checks if the specified file system is in the cache.
1009 */
1010 static struct fs_cache *look_up_fs_cache( dev_t dev )
1011 {
1012 int i;
1013 for (i = 0; i < ARRAY_SIZE( fs_cache ); i++)
1014 if (fs_cache[i].dev == dev)
1015 return fs_cache+i;
1016 return NULL;
1017 }
1018
1019 /***********************************************************************
1020 * add_fs_cache
1021 *
1022 * Adds the specified file system to the cache.
1023 */
1024 static void add_fs_cache( dev_t dev, fsid_t fsid, BOOLEAN case_sensitive )
1025 {
1026 int i;
1027 struct fs_cache *entry = look_up_fs_cache( dev );
1028 static int once = 0;
1029 if (entry)
1030 {
1031 /* Update the cache */
1032 entry->fsid = fsid;
1033 entry->case_sensitive = case_sensitive;
1034 return;
1035 }
1036
1037 /* Add a new entry */
1038 for (i = 0; i < ARRAY_SIZE( fs_cache ); i++)
1039 if (fs_cache[i].dev == 0)
1040 {
1041 /* This entry is empty, use it */
1042 fs_cache[i].dev = dev;
1043 fs_cache[i].fsid = fsid;
1044 fs_cache[i].case_sensitive = case_sensitive;
1045 return;
1046 }
1047
1048 /* Cache is out of space, warn */
1049 if (!once++)
1050 WARN( "FS cache is out of space, expect performance problems\n" );
1051 }
1052
1053 /***********************************************************************
1054 * get_dir_case_sensitivity_attr
1055 *
1056 * Checks if the volume containing the specified directory is case
1057 * sensitive or not. Uses getattrlist(2).
1058 */
1059 static int get_dir_case_sensitivity_attr( const char *dir )
1060 {
1061 char *mntpoint;
1062 struct attrlist attr;
1063 struct vol_caps caps;
1064 struct get_fsid get_fsid;
1065 struct fs_cache *entry;
1066
1067 /* First get the FS ID of the volume */
1068 attr.bitmapcount = ATTR_BIT_MAP_COUNT;
1069 attr.reserved = 0;
1070 attr.commonattr = ATTR_CMN_DEVID|ATTR_CMN_FSID;
1071 attr.volattr = attr.dirattr = attr.fileattr = attr.forkattr = 0;
1072 get_fsid.size = 0;
1073 if (getattrlist( dir, &attr, &get_fsid, sizeof(get_fsid), 0 ) != 0 ||
1074 get_fsid.size != sizeof(get_fsid))
1075 return -1;
1076 /* Try to look it up in the cache */
1077 entry = look_up_fs_cache( get_fsid.dev );
1078 if (entry && !memcmp( &entry->fsid, &get_fsid.fsid, sizeof(fsid_t) ))
1079 /* Cache lookup succeeded */
1080 return entry->case_sensitive;
1081 /* Cache is stale at this point, we have to update it */
1082
1083 mntpoint = get_device_mount_point( get_fsid.dev );
1084 /* Now look up the case-sensitivity */
1085 attr.commonattr = 0;
1086 attr.volattr = ATTR_VOL_INFO|ATTR_VOL_CAPABILITIES;
1087 if (getattrlist( mntpoint, &attr, &caps, sizeof(caps), 0 ) < 0)
1088 {
1089 free( mntpoint );
1090 add_fs_cache( get_fsid.dev, get_fsid.fsid, TRUE );
1091 return TRUE;
1092 }
1093 free( mntpoint );
1094 if (caps.size == sizeof(caps) &&
1095 (caps.caps.valid[VOL_CAPABILITIES_FORMAT] &
1096 (VOL_CAP_FMT_CASE_SENSITIVE | VOL_CAP_FMT_CASE_PRESERVING)) ==
1097 (VOL_CAP_FMT_CASE_SENSITIVE | VOL_CAP_FMT_CASE_PRESERVING))
1098 {
1099 BOOLEAN ret;
1100
1101 if ((caps.caps.capabilities[VOL_CAPABILITIES_FORMAT] &
1102 VOL_CAP_FMT_CASE_SENSITIVE) != VOL_CAP_FMT_CASE_SENSITIVE)
1103 ret = FALSE;
1104 else
1105 ret = TRUE;
1106 /* Update the cache */
1107 add_fs_cache( get_fsid.dev, get_fsid.fsid, ret );
1108 return ret;
1109 }
1110 return FALSE;
1111 }
1112 #endif
1113
1114 /***********************************************************************
1115 * get_dir_case_sensitivity_stat
1116 *
1117 * Checks if the volume containing the specified directory is case
1118 * sensitive or not. Uses (f)statfs(2), statvfs(2), fstatat(2), or ioctl(2).
1119 */
1120 static BOOLEAN get_dir_case_sensitivity_stat( const char *dir )
1121 {
1122 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1123 struct statfs stfs;
1124
1125 if (statfs( dir, &stfs ) == -1) return TRUE;
1126 /* Assume these file systems are always case insensitive.*/
1127 if (!strcmp( stfs.f_fstypename, "fusefs" ) &&
1128 !strncmp( stfs.f_mntfromname, "ciopfs", 5 ))
1129 return FALSE;
1130 /* msdosfs was case-insensitive since FreeBSD 8, if not earlier */
1131 if (!strcmp( stfs.f_fstypename, "msdosfs" ) ||
1132 /* older CIFS protocol versions uppercase filename on the client,
1133 * newer versions should be case-insensitive on the server anyway */
1134 !strcmp( stfs.f_fstypename, "smbfs" ))
1135 return FALSE;
1136 /* no ntfs-3g: modern fusefs has no way to report the filesystem on FreeBSD
1137 * no cd9660 or udf, they're case-sensitive on FreeBSD
1138 */
1139 #ifdef __APPLE__
1140 if (!strcmp( stfs.f_fstypename, "msdos" ) ||
1141 !strcmp( stfs.f_fstypename, "cd9660" ) ||
1142 !strcmp( stfs.f_fstypename, "udf" ) ||
1143 !strcmp( stfs.f_fstypename, "ntfs" ))
1144 return FALSE;
1145 #ifdef _DARWIN_FEATURE_64_BIT_INODE
1146 if (!strcmp( stfs.f_fstypename, "hfs" ) && (stfs.f_fssubtype == 0 ||
1147 stfs.f_fssubtype == 1 ||
1148 stfs.f_fssubtype == 128))
1149 return FALSE;
1150 #else
1151 /* The field says "reserved", but a quick look at the kernel source
1152 * tells us that this "reserved" field is really the same as the
1153 * "fssubtype" field from the inode64 structure (see munge_statfs()
1154 * in <xnu-source>/bsd/vfs/vfs_syscalls.c).
1155 */
1156 if (!strcmp( stfs.f_fstypename, "hfs" ) && (stfs.f_reserved1 == 0 ||
1157 stfs.f_reserved1 == 1 ||
1158 stfs.f_reserved1 == 128))
1159 return FALSE;
1160 #endif
1161 #endif
1162 return TRUE;
1163
1164 #elif defined(__NetBSD__)
1165 struct statvfs stfs;
1166
1167 if (statvfs( dir, &stfs ) == -1) return TRUE;
1168 /* Only assume CIOPFS is case insensitive. */
1169 if (strcmp( stfs.f_fstypename, "fusefs" ) ||
1170 strncmp( stfs.f_mntfromname, "ciopfs", 5 ))
1171 return FALSE;
1172 return TRUE;
1173
1174 #elif defined(__linux__)
1175 BOOLEAN sens = TRUE;
1176 struct statfs stfs;
1177 struct stat st;
1178 int fd, flags;
1179
1180 if ((fd = open( dir, O_RDONLY | O_NONBLOCK | O_LARGEFILE )) == -1)
1181 return TRUE;
1182
1183 if (ioctl( fd, EXT2_IOC_GETFLAGS, &flags ) != -1 && (flags & EXT4_CASEFOLD_FL))
1184 {
1185 sens = FALSE;
1186 }
1187 else if (fstatfs( fd, &stfs ) == 0 && /* CIOPFS is case insensitive. Instead of */
1188 stfs.f_type == 0x65735546 /* FUSE_SUPER_MAGIC */ && /* parsing mtab to discover if the FUSE FS */
1189 fstatat( fd, ".ciopfs", &st, AT_NO_AUTOMOUNT ) == 0) /* is CIOPFS, look for .ciopfs in the dir. */
1190 {
1191 sens = FALSE;
1192 }
1193
1194 close( fd );
1195 return sens;
1196 #else
1197 return TRUE;
1198 #endif
1199 }
1200
1201
1202 /***********************************************************************
1203 * get_dir_case_sensitivity
1204 *
1205 * Checks if the volume containing the specified directory is case
1206 * sensitive or not. Uses multiple methods, depending on platform.
1207 */
1208 static BOOLEAN get_dir_case_sensitivity( const char *dir )
1209 {
1210 #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \
1211 defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE)
1212 int case_sensitive = get_dir_case_sensitivity_attr( dir );
1213 if (case_sensitive != -1) return case_sensitive;
1214 #endif
1215 return get_dir_case_sensitivity_stat( dir );
1216 }
1217
1218
1219 /***********************************************************************
1220 * is_hidden_file
1221 *
1222 * Check if the specified file should be hidden based on its name and the show dot files option.
1223 */
1224 static BOOL is_hidden_file( const UNICODE_STRING *name )
1225 {
1226 WCHAR *p, *end;
1227
1228 if (show_dot_files) return FALSE;
1229
1230 end = p = name->Buffer + name->Length/sizeof(WCHAR);
1231 while (p > name->Buffer && IS_SEPARATOR(p[-1])) p--;
1232 while (p > name->Buffer && !IS_SEPARATOR(p[-1])) p--;
1233 if (p == end || *p != '.') return FALSE;
1234 /* make sure it isn't '.' or '..' */
1235 if (p + 1 == end) return FALSE;
1236 if (p[1] == '.' && p + 2 == end) return FALSE;
1237 return TRUE;
1238 }
1239
1240
1241 /***********************************************************************
1242 * hash_short_file_name
1243 *
1244 * Transform a Unix file name into a hashed DOS name. If the name is not a valid
1245 * DOS name, it is replaced by a hashed version that fits in 8.3 format.
1246 * 'buffer' must be at least 12 characters long.
1247 * Returns length of short name in bytes; short name is NOT null-terminated.
1248 */
1249 static ULONG hash_short_file_name( const WCHAR *name, int length, LPWSTR buffer )
1250 {
1251 static const char hash_chars[32] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
1252
1253 LPCWSTR p, ext, end = name + length;
1254 LPWSTR dst;
1255 unsigned short hash;
1256 int i;
1257
1258 /* Compute the hash code of the file name */
1259 /* If you know something about hash functions, feel free to */
1260 /* insert a better algorithm here... */
1261 if (!is_case_sensitive)
1262 {
1263 for (p = name, hash = 0xbeef; p < end - 1; p++)
1264 hash = (hash<<3) ^ (hash>>5) ^ towlower(*p) ^ (towlower(p[1]) << 8);
1265 hash = (hash<<3) ^ (hash>>5) ^ towlower(*p); /* Last character */
1266 }
1267 else
1268 {
1269 for (p = name, hash = 0xbeef; p < end - 1; p++)
1270 hash = (hash << 3) ^ (hash >> 5) ^ *p ^ (p[1] << 8);
1271 hash = (hash << 3) ^ (hash >> 5) ^ *p; /* Last character */
1272 }
1273
1274 /* Find last dot for start of the extension */
1275 for (p = name + 1, ext = NULL; p < end - 1; p++) if (*p == '.') ext = p;
1276
1277 /* Copy first 4 chars, replacing invalid chars with '_' */
1278 for (i = 4, p = name, dst = buffer; i > 0; i--, p++)
1279 {
1280 if (p == end || p == ext) break;
1281 *dst++ = is_invalid_dos_char(*p) ? '_' : *p;
1282 }
1283 /* Pad to 5 chars with '~' */
1284 while (i-- >= 0) *dst++ = '~';
1285
1286 /* Insert hash code converted to 3 ASCII chars */
1287 *dst++ = hash_chars[(hash >> 10) & 0x1f];
1288 *dst++ = hash_chars[(hash >> 5) & 0x1f];
1289 *dst++ = hash_chars[hash & 0x1f];
1290
1291 /* Copy the first 3 chars of the extension (if any) */
1292 if (ext)
1293 {
1294 *dst++ = '.';
1295 for (i = 3, ext++; (i > 0) && ext < end; i--, ext++)
1296 *dst++ = is_invalid_dos_char(*ext) ? '_' : *ext;
1297 }
1298 return dst - buffer;
1299 }
1300
1301
1302 /***********************************************************************
1303 * match_filename
1304 *
1305 * Check a long file name against a mask.
1306 *
1307 * Tests (done in W95 DOS shell - case insensitive):
1308 * *.txt test1.test.txt *
1309 * *st1* test1.txt *
1310 * *.t??????.t* test1.ta.tornado.txt *
1311 * *tornado* test1.ta.tornado.txt *
1312 * t*t test1.ta.tornado.txt *
1313 * ?est* test1.txt *
1314 * ?est??? test1.txt -
1315 * *test1.txt* test1.txt *
1316 * h?l?o*t.dat hellothisisatest.dat *
1317 */
1318 static BOOLEAN match_filename( const WCHAR *name, int length, const UNICODE_STRING *mask_str )
1319 {
1320 BOOL mismatch;
1321 const WCHAR *mask = mask_str->Buffer;
1322 const WCHAR *name_end = name + length;
1323 const WCHAR *mask_end = mask + mask_str->Length / sizeof(WCHAR);
1324 const WCHAR *lastjoker = NULL;
1325 const WCHAR *next_to_retry = NULL;
1326
1327 while (name < name_end && mask < mask_end)
1328 {
1329 switch(*mask)
1330 {
1331 case '*':
1332 mask++;
1333 while (mask < mask_end && *mask == '*') mask++; /* Skip consecutive '*' */
1334 if (mask == mask_end) return TRUE; /* end of mask is all '*', so match */
1335 lastjoker = mask;
1336
1337 /* skip to the next match after the joker(s) */
1338 if (is_case_sensitive)
1339 while (name < name_end && (*name != *mask)) name++;
1340 else
1341 while (name < name_end && (towupper(*name) != towupper(*mask))) name++;
1342 next_to_retry = name;
1343 break;
1344 case '?':
1345 case '>':
1346 mask++;
1347 name++;
1348 break;
1349 default:
1350 if (is_case_sensitive) mismatch = (*mask != *name);
1351 else mismatch = (towupper(*mask) != towupper(*name));
1352
1353 if (!mismatch)
1354 {
1355 mask++;
1356 name++;
1357 if (mask == mask_end)
1358 {
1359 if (name == name_end) return TRUE;
1360 if (lastjoker) mask = lastjoker;
1361 }
1362 }
1363 else /* mismatch ! */
1364 {
1365 if (lastjoker) /* we had an '*', so we can try unlimitedly */
1366 {
1367 mask = lastjoker;
1368
1369 /* this scan sequence was a mismatch, so restart
1370 * 1 char after the first char we checked last time */
1371 next_to_retry++;
1372 name = next_to_retry;
1373 }
1374 else return FALSE; /* bad luck */
1375 }
1376 break;
1377 }
1378 }
1379 while (mask < mask_end && ((*mask == '.') || (*mask == '*')))
1380 mask++; /* Ignore trailing '.' or '*' in mask */
1381 return (name == name_end && mask == mask_end);
1382 }
1383
1384
1385 /***********************************************************************
1386 * is_legal_8dot3_name
1387 *
1388 * Simplified version of RtlIsNameLegalDOS8Dot3.
1389 */
1390 static BOOLEAN is_legal_8dot3_name( const WCHAR *name, int len )
1391 {
1392 static const WCHAR invalid_chars[] = { INVALID_DOS_CHARS,':','/','\\',0 };
1393 int i, dot = -1;
1394
1395 if (len > 12) return FALSE;
1396
1397 /* a starting . is invalid, except for . and .. */
1398 if (len > 0 && name[0] == '.') return (len == 1 || (len == 2 && name[1] == '.'));
1399
1400 for (i = 0; i < len; i++)
1401 {
1402 if (name[i] > 0x7f) return FALSE;
1403 if (wcschr( invalid_chars, name[i] )) return FALSE;
1404 if (name[i] == '.')
1405 {
1406 if (dot != -1) return FALSE;
1407 dot = i;
1408 }
1409 }
1410
1411 if (dot == -1) return (len <= 8);
1412 if (dot > 8) return FALSE;
1413 return (len - dot > 1 && len - dot < 5);
1414 }
1415
1416
1417 /***********************************************************************
1418 * append_entry
1419 *
1420 * Add a file to the directory data if it matches the mask.
1421 */
1422 static BOOL append_entry( struct dir_data *data, const char *long_name,
1423 const char *short_name, const UNICODE_STRING *mask )
1424 {
1425 int long_len, short_len;
1426 WCHAR long_nameW[MAX_DIR_ENTRY_LEN + 1];
1427 WCHAR short_nameW[13];
1428
1429 long_len = ntdll_umbstowcs( long_name, strlen(long_name), long_nameW, ARRAY_SIZE(long_nameW) );
1430 if (long_len == ARRAY_SIZE(long_nameW)) return TRUE;
1431 long_nameW[long_len] = 0;
1432
1433 if (short_name)
1434 {
1435 short_len = ntdll_umbstowcs( short_name, strlen(short_name),
1436 short_nameW, ARRAY_SIZE( short_nameW ) - 1 );
1437 }
1438 else /* generate a short name if necessary */
1439 {
1440 short_len = 0;
1441 if (!is_legal_8dot3_name( long_nameW, long_len ))
1442 short_len = hash_short_file_name( long_nameW, long_len, short_nameW );
1443 }
1444 short_nameW[short_len] = 0;
1445 wcsupr( short_nameW );
1446
1447 TRACE( "long %s short %s mask %s\n",
1448 debugstr_w( long_nameW ), debugstr_w( short_nameW ), debugstr_us( mask ));
1449
1450 if (mask && !match_filename( long_nameW, long_len, mask ))
1451 {
1452 if (!short_len) return TRUE; /* no short name to match */
1453 if (!match_filename( short_nameW, short_len, mask )) return TRUE;
1454 }
1455
1456 return add_dir_data_names( data, long_nameW, short_nameW, long_name );
1457 }
1458
1459
1460 /* fetch the attributes of a file */
1461 static inline ULONG get_file_attributes( const struct stat *st )
1462 {
1463 ULONG attr;
1464
1465 if (S_ISDIR(st->st_mode))
1466 attr = FILE_ATTRIBUTE_DIRECTORY;
1467 else
1468 attr = FILE_ATTRIBUTE_ARCHIVE;
1469 if (!(st->st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)))
1470 attr |= FILE_ATTRIBUTE_READONLY;
1471 return attr;
1472 }
1473
1474
1475 static BOOL fd_is_mount_point( int fd, const struct stat *st )
1476 {
1477 struct stat parent;
1478 return S_ISDIR( st->st_mode ) && !fstatat( fd, "..", &parent, 0 )
1479 && (parent.st_dev != st->st_dev || parent.st_ino == st->st_ino);
1480 }
1481
1482
1483 /* get the stat info and file attributes for a file (by file descriptor) */
1484 static int fd_get_file_info( int fd, unsigned int options, struct stat *st, ULONG *attr )
1485 {
1486 int ret;
1487
1488 *attr = 0;
1489 ret = fstat( fd, st );
1490 if (ret == -1) return ret;
1491 *attr |= get_file_attributes( st );
1492 /* consider mount points to be reparse points (IO_REPARSE_TAG_MOUNT_POINT) */
1493 if ((options & FILE_OPEN_REPARSE_POINT) && fd_is_mount_point( fd, st ))
1494 *attr |= FILE_ATTRIBUTE_REPARSE_POINT;
1495 return ret;
1496 }
1497
1498
1499 /* get the stat info and file attributes for a file (by name) */
1500 static int get_file_info( const char *path, struct stat *st, ULONG *attr )
1501 {
1502 char *parent_path;
1503 int ret;
1504
1505 *attr = 0;
1506 ret = lstat( path, st );
1507 if (ret == -1) return ret;
1508 if (S_ISLNK( st->st_mode ))
1509 {
1510 ret = stat( path, st );
1511 if (ret == -1) return ret;
1512 /* is a symbolic link and a directory, consider these "reparse points" */
1513 if (S_ISDIR( st->st_mode )) *attr |= FILE_ATTRIBUTE_REPARSE_POINT;
1514 }
1515 else if (S_ISDIR( st->st_mode ) && (parent_path = malloc( strlen(path) + 4 )))
1516 {
1517 struct stat parent_st;
1518
1519 /* consider mount points to be reparse points (IO_REPARSE_TAG_MOUNT_POINT) */
1520 strcpy( parent_path, path );
1521 strcat( parent_path, "/.." );
1522 if (!stat( parent_path, &parent_st )
1523 && (st->st_dev != parent_st.st_dev || st->st_ino == parent_st.st_ino))
1524 *attr |= FILE_ATTRIBUTE_REPARSE_POINT;
1525
1526 free( parent_path );
1527 }
1528 *attr |= get_file_attributes( st );
1529 return ret;
1530 }
1531
1532
1533 #if defined(__ANDROID__) && !defined(HAVE_FUTIMENS)
1534 static int futimens( int fd, const struct timespec spec[2] )
1535 {
1536 return syscall( __NR_utimensat, fd, NULL, spec, 0 );
1537 }
1538 #define HAVE_FUTIMENS
1539 #endif /* __ANDROID__ */
1540
1541 #ifndef UTIME_OMIT
1542 #define UTIME_OMIT ((1 << 30) - 2)
1543 #endif
1544
1545 static BOOL set_file_times_precise( int fd, const LARGE_INTEGER *mtime,
1546 const LARGE_INTEGER *atime, NTSTATUS *status )
1547 {
1548 #ifdef HAVE_FUTIMENS
1549 struct timespec tv[2];
1550
1551 tv[0].tv_sec = tv[1].tv_sec = 0;
1552 tv[0].tv_nsec = tv[1].tv_nsec = UTIME_OMIT;
1553 if (atime->QuadPart)
1554 {
1555 tv[0].tv_sec = atime->QuadPart / 10000000 - SECS_1601_TO_1970;
1556 tv[0].tv_nsec = (atime->QuadPart % 10000000) * 100;
1557 }
1558 if (mtime->QuadPart)
1559 {
1560 tv[1].tv_sec = mtime->QuadPart / 10000000 - SECS_1601_TO_1970;
1561 tv[1].tv_nsec = (mtime->QuadPart % 10000000) * 100;
1562 }
1563 #ifdef __APPLE__
1564 if (!&futimens) return FALSE;
1565 #endif
1566 if (futimens( fd, tv ) == -1) *status = errno_to_status( errno );
1567 else *status = STATUS_SUCCESS;
1568 return TRUE;
1569 #else
1570 return FALSE;
1571 #endif
1572 }
1573
1574
1575 static NTSTATUS set_file_times( int fd, const LARGE_INTEGER *mtime, const LARGE_INTEGER *atime )
1576 {
1577 NTSTATUS status = STATUS_SUCCESS;
1578 #if defined(HAVE_FUTIMES) || defined(HAVE_FUTIMESAT)
1579 struct timeval tv[2];
1580 struct stat st;
1581 #endif
1582
1583 if (set_file_times_precise( fd, mtime, atime, &status ))
1584 return status;
1585
1586 #if defined(HAVE_FUTIMES) || defined(HAVE_FUTIMESAT)
1587 if (!atime->QuadPart || !mtime->QuadPart)
1588 {
1589
1590 tv[0].tv_sec = tv[0].tv_usec = 0;
1591 tv[1].tv_sec = tv[1].tv_usec = 0;
1592 if (!fstat( fd, &st ))
1593 {
1594 tv[0].tv_sec = st.st_atime;
1595 tv[1].tv_sec = st.st_mtime;
1596 #ifdef HAVE_STRUCT_STAT_ST_ATIM
1597 tv[0].tv_usec = st.st_atim.tv_nsec / 1000;
1598 #elif defined(HAVE_STRUCT_STAT_ST_ATIMESPEC)
1599 tv[0].tv_usec = st.st_atimespec.tv_nsec / 1000;
1600 #endif
1601 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1602 tv[1].tv_usec = st.st_mtim.tv_nsec / 1000;
1603 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC)
1604 tv[1].tv_usec = st.st_mtimespec.tv_nsec / 1000;
1605 #endif
1606 }
1607 }
1608 if (atime->QuadPart)
1609 {
1610 tv[0].tv_sec = atime->QuadPart / 10000000 - SECS_1601_TO_1970;
1611 tv[0].tv_usec = (atime->QuadPart % 10000000) / 10;
1612 }
1613 if (mtime->QuadPart)
1614 {
1615 tv[1].tv_sec = mtime->QuadPart / 10000000 - SECS_1601_TO_1970;
1616 tv[1].tv_usec = (mtime->QuadPart % 10000000) / 10;
1617 }
1618 #ifdef HAVE_FUTIMES
1619 if (futimes( fd, tv ) == -1) status = errno_to_status( errno );
1620 #elif defined(HAVE_FUTIMESAT)
1621 if (futimesat( fd, NULL, tv ) == -1) status = errno_to_status( errno );
1622 #endif
1623
1624 #else /* HAVE_FUTIMES || HAVE_FUTIMESAT */
1625 FIXME( "setting file times not supported\n" );
1626 status = STATUS_NOT_IMPLEMENTED;
1627 #endif
1628 return status;
1629 }
1630
1631
1632 static inline void get_file_times( const struct stat *st, LARGE_INTEGER *mtime, LARGE_INTEGER *ctime,
1633 LARGE_INTEGER *atime, LARGE_INTEGER *creation )
1634 {
1635 mtime->QuadPart = ticks_from_time_t( st->st_mtime );
1636 ctime->QuadPart = ticks_from_time_t( st->st_ctime );
1637 atime->QuadPart = ticks_from_time_t( st->st_atime );
1638 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1639 mtime->QuadPart += st->st_mtim.tv_nsec / 100;
1640 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC)
1641 mtime->QuadPart += st->st_mtimespec.tv_nsec / 100;
1642 #endif
1643 #ifdef HAVE_STRUCT_STAT_ST_CTIM
1644 ctime->QuadPart += st->st_ctim.tv_nsec / 100;
1645 #elif defined(HAVE_STRUCT_STAT_ST_CTIMESPEC)
1646 ctime->QuadPart += st->st_ctimespec.tv_nsec / 100;
1647 #endif
1648 #ifdef HAVE_STRUCT_STAT_ST_ATIM
1649 atime->QuadPart += st->st_atim.tv_nsec / 100;
1650 #elif defined(HAVE_STRUCT_STAT_ST_ATIMESPEC)
1651 atime->QuadPart += st->st_atimespec.tv_nsec / 100;
1652 #endif
1653 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1654 creation->QuadPart = ticks_from_time_t( st->st_birthtime );
1655 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIM
1656 creation->QuadPart += st->st_birthtim.tv_nsec / 100;
1657 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC)
1658 creation->QuadPart += st->st_birthtimespec.tv_nsec / 100;
1659 #endif
1660 #elif defined(HAVE_STRUCT_STAT___ST_BIRTHTIME)
1661 creation->QuadPart = ticks_from_time_t( st->__st_birthtime );
1662 #ifdef HAVE_STRUCT_STAT___ST_BIRTHTIM
1663 creation->QuadPart += st->__st_birthtim.tv_nsec / 100;
1664 #endif
1665 #else
1666 *creation = *mtime;
1667 #endif
1668 }
1669
1670
1671 /* fill in the file information that depends on the stat and attribute info */
1672 static NTSTATUS fill_file_info( const struct stat *st, ULONG attr, void *ptr,
1673 FILE_INFORMATION_CLASS class )
1674 {
1675 switch (class)
1676 {
1677 case FileBasicInformation:
1678 {
1679 FILE_BASIC_INFORMATION *info = ptr;
1680
1681 get_file_times( st, &info->LastWriteTime, &info->ChangeTime,
1682 &info->LastAccessTime, &info->CreationTime );
1683 info->FileAttributes = attr;
1684 }
1685 break;
1686 case FileStandardInformation:
1687 {
1688 FILE_STANDARD_INFORMATION *info = ptr;
1689
1690 if ((info->Directory = S_ISDIR(st->st_mode)))
1691 {
1692 info->AllocationSize.QuadPart = 0;
1693 info->EndOfFile.QuadPart = 0;
1694 info->NumberOfLinks = 1;
1695 }
1696 else
1697 {
1698 info->AllocationSize.QuadPart = (ULONGLONG)st->st_blocks * 512;
1699 info->EndOfFile.QuadPart = st->st_size;
1700 info->NumberOfLinks = st->st_nlink;
1701 }
1702 }
1703 break;
1704 case FileInternalInformation:
1705 {
1706 FILE_INTERNAL_INFORMATION *info = ptr;
1707 info->IndexNumber.QuadPart = st->st_ino;
1708 }
1709 break;
1710 case FileEndOfFileInformation:
1711 {
1712 FILE_END_OF_FILE_INFORMATION *info = ptr;
1713 info->EndOfFile.QuadPart = S_ISDIR(st->st_mode) ? 0 : st->st_size;
1714 }
1715 break;
1716 case FileAllInformation:
1717 {
1718 FILE_ALL_INFORMATION *info = ptr;
1719 fill_file_info( st, attr, &info->BasicInformation, FileBasicInformation );
1720 fill_file_info( st, attr, &info->StandardInformation, FileStandardInformation );
1721 fill_file_info( st, attr, &info->InternalInformation, FileInternalInformation );
1722 }
1723 break;
1724 /* all directory structures start with the FileDirectoryInformation layout */
1725 case FileBothDirectoryInformation:
1726 case FileFullDirectoryInformation:
1727 case FileDirectoryInformation:
1728 {
1729 FILE_DIRECTORY_INFORMATION *info = ptr;
1730
1731 get_file_times( st, &info->LastWriteTime, &info->ChangeTime,
1732 &info->LastAccessTime, &info->CreationTime );
1733 if (S_ISDIR(st->st_mode))
1734 {
1735 info->AllocationSize.QuadPart = 0;
1736 info->EndOfFile.QuadPart = 0;
1737 }
1738 else
1739 {
1740 info->AllocationSize.QuadPart = (ULONGLONG)st->st_blocks * 512;
1741 info->EndOfFile.QuadPart = st->st_size;
1742 }
1743 info->FileAttributes = attr;
1744 }
1745 break;
1746 case FileIdFullDirectoryInformation:
1747 {
1748 FILE_ID_FULL_DIRECTORY_INFORMATION *info = ptr;
1749 info->FileId.QuadPart = st->st_ino;
1750 fill_file_info( st, attr, info, FileDirectoryInformation );
1751 }
1752 break;
1753 case FileIdBothDirectoryInformation:
1754 {
1755 FILE_ID_BOTH_DIRECTORY_INFORMATION *info = ptr;
1756 info->FileId.QuadPart = st->st_ino;
1757 fill_file_info( st, attr, info, FileDirectoryInformation );
1758 }
1759 break;
1760 case FileIdGlobalTxDirectoryInformation:
1761 {
1762 FILE_ID_GLOBAL_TX_DIR_INFORMATION *info = ptr;
1763 info->FileId.QuadPart = st->st_ino;
1764 fill_file_info( st, attr, info, FileDirectoryInformation );
1765 }
1766 break;
1767
1768 default:
1769 return STATUS_INVALID_INFO_CLASS;
1770 }
1771 return STATUS_SUCCESS;
1772 }
1773
1774
1775 static NTSTATUS server_get_unix_name( HANDLE handle, char **unix_name )
1776 {
1777 data_size_t size = 1024;
1778 NTSTATUS ret;
1779 char *name;
1780
1781 for (;;)
1782 {
1783 if (!(name = malloc( size + 1 ))) return STATUS_NO_MEMORY;
1784
1785 SERVER_START_REQ( get_handle_unix_name )
1786 {
1787 req->handle = wine_server_obj_handle( handle );
1788 wine_server_set_reply( req, name, size );
1789 ret = wine_server_call( req );
1790 size = reply->name_len;
1791 }
1792 SERVER_END_REQ;
1793
1794 if (!ret)
1795 {
1796 name[size] = 0;
1797 *unix_name = name;
1798 break;
1799 }
1800 free( name );
1801 if (ret != STATUS_BUFFER_OVERFLOW) break;
1802 }
1803 return ret;
1804 }
1805
1806 static NTSTATUS fill_name_info( const char *unix_name, FILE_NAME_INFORMATION *info, LONG *name_len )
1807 {
1808 WCHAR *nt_name;
1809 NTSTATUS status;
1810
1811 if (!(status = unix_to_nt_file_name( unix_name, &nt_name )))
1812 {
1813 const WCHAR *ptr = nt_name;
1814 const WCHAR *end = ptr + wcslen( nt_name );
1815
1816 /* Skip the volume mount point. */
1817 while (ptr != end && *ptr == '\\') ++ptr;
1818 while (ptr != end && *ptr != '\\') ++ptr;
1819 while (ptr != end && *ptr == '\\') ++ptr;
1820 while (ptr != end && *ptr != '\\') ++ptr;
1821
1822 info->FileNameLength = (end - ptr) * sizeof(WCHAR);
1823 if (*name_len < info->FileNameLength) status = STATUS_BUFFER_OVERFLOW;
1824 else *name_len = info->FileNameLength;
1825
1826 memcpy( info->FileName, ptr, *name_len );
1827 free( nt_name );
1828 }
1829
1830 return status;
1831 }
1832
1833
1834 static NTSTATUS server_get_file_info( HANDLE handle, IO_STATUS_BLOCK *io, void *buffer,
1835 ULONG length, FILE_INFORMATION_CLASS info_class )
1836 {
1837 SERVER_START_REQ( get_file_info )
1838 {
1839 req->handle = wine_server_obj_handle( handle );
1840 req->info_class = info_class;
1841 wine_server_set_reply( req, buffer, length );
1842 io->u.Status = wine_server_call( req );
1843 io->Information = wine_server_reply_size( reply );
1844 }
1845 SERVER_END_REQ;
1846 if (io->u.Status == STATUS_NOT_IMPLEMENTED)
1847 FIXME( "Unsupported info class %x\n", info_class );
1848 return io->u.Status;
1849
1850 }
1851
1852
1853 /* retrieve device/inode number for all the drives */
1854 static unsigned int get_drives_info( struct file_identity info[MAX_DOS_DRIVES] )
1855 {
1856 static pthread_mutex_t cache_mutex = PTHREAD_MUTEX_INITIALIZER;
1857 static struct file_identity cache[MAX_DOS_DRIVES];
1858 static time_t last_update;
1859 static unsigned int nb_drives;
1860 unsigned int ret;
1861 time_t now = time(NULL);
1862
1863 mutex_lock( &cache_mutex );
1864 if (now != last_update)
1865 {
1866 char *buffer, *p;
1867 struct stat st;
1868 unsigned int i;
1869
1870 if ((buffer = malloc( strlen(config_dir) + sizeof("/dosdevices/a:") )))
1871 {
1872 strcpy( buffer, config_dir );
1873 strcat( buffer, "/dosdevices/a:" );
1874 p = buffer + strlen(buffer) - 2;
1875
1876 for (i = nb_drives = 0; i < MAX_DOS_DRIVES; i++)
1877 {
1878 *p = 'a' + i;
1879 if (!stat( buffer, &st ))
1880 {
1881 cache[i].dev = st.st_dev;
1882 cache[i].ino = st.st_ino;
1883 nb_drives++;
1884 }
1885 else
1886 {
1887 cache[i].dev = 0;
1888 cache[i].ino = 0;
1889 }
1890 }
1891 free( buffer );
1892 }
1893 last_update = now;
1894 }
1895 memcpy( info, cache, sizeof(cache) );
1896 ret = nb_drives;
1897 mutex_unlock( &cache_mutex );
1898 return ret;
1899 }
1900
1901
1902 /* Find a DOS device which can act as the root of "path".
1903 * Similar to find_drive_root(), but returns -1 instead of crossing volumes. */
1904 static int find_dos_device( const char *path )
1905 {
1906 int len = strlen(path);
1907 int drive;
1908 char *buffer;
1909 struct stat st;
1910 struct file_identity info[MAX_DOS_DRIVES];
1911 dev_t dev_id;
1912
1913 if (!get_drives_info( info )) return -1;
1914
1915 if (stat( path, &st ) < 0) return -1;
1916 dev_id = st.st_dev;
1917
1918 /* strip off trailing slashes */
1919 while (len > 1 && path[len - 1] == '/') len--;
1920
1921 /* make a copy of the path */
1922 if (!(buffer = malloc( len + 1 ))) return -1;
1923 memcpy( buffer, path, len );
1924 buffer[len] = 0;
1925
1926 for (;;)
1927 {
1928 if (!stat( buffer, &st ) && S_ISDIR( st.st_mode ))
1929 {
1930 if (st.st_dev != dev_id) break;
1931
1932 for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
1933 {
1934 if ((info[drive].dev == st.st_dev) && (info[drive].ino == st.st_ino))
1935 {
1936 TRACE( "%s -> drive %c:, root=%s, name=%s\n",
1937 debugstr_a(path), 'A' + drive, debugstr_a(buffer), debugstr_a(path + len));
1938 free( buffer );
1939 return drive;
1940 }
1941 }
1942 }
1943 if (len <= 1) break; /* reached root */
1944 while (len > 1 && path[len - 1] != '/') len--;
1945 while (len > 1 && path[len - 1] == '/') len--;
1946 buffer[len] = 0;
1947 }
1948 free( buffer );
1949 return -1;
1950 }
1951
1952 static NTSTATUS get_mountmgr_fs_info( HANDLE handle, int fd, struct mountmgr_unix_drive *drive, ULONG size )
1953 {
1954 OBJECT_ATTRIBUTES attr;
1955 UNICODE_STRING string;
1956 char *unix_name;
1957 IO_STATUS_BLOCK io;
1958 HANDLE mountmgr;
1959 NTSTATUS status;
1960 int letter;
1961
1962 if ((status = server_get_unix_name( handle, &unix_name ))) return status;
1963 letter = find_dos_device( unix_name );
1964 free( unix_name );
1965
1966 if (letter == -1)
1967 {
1968 struct stat st;
1969
1970 fstat( fd, &st );
1971 drive->unix_dev = st.st_rdev ? st.st_rdev : st.st_dev;
1972 drive->letter = 0;
1973 }
1974 else
1975 drive->letter = 'a' + letter;
1976
1977 string.Buffer = (WCHAR *)MOUNTMGR_DEVICE_NAME;
1978 string.Length = sizeof(MOUNTMGR_DEVICE_NAME) - sizeof(WCHAR);
1979 InitializeObjectAttributes( &attr, &string, 0, NULL, NULL );
1980 status = NtOpenFile( &mountmgr, GENERIC_READ | SYNCHRONIZE, &attr, &io,
1981 FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_NONALERT );
1982 if (status) return status;
1983
1984 status = NtDeviceIoControlFile( mountmgr, NULL, NULL, NULL, &io, IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE,
1985 drive, sizeof(*drive), drive, size );
1986 NtClose( mountmgr );
1987 if (status == STATUS_BUFFER_OVERFLOW) status = STATUS_SUCCESS;
1988 else if (status) WARN("failed to retrieve filesystem type from mountmgr, status %#x\n", status);
1989 return status;
1990 }
1991
1992
1993 /***********************************************************************
1994 * get_dir_data_entry
1995 *
1996 * Return a directory entry from the cached data.
1997 */
1998 static NTSTATUS get_dir_data_entry( struct dir_data *dir_data, void *info_ptr, IO_STATUS_BLOCK *io,
1999 ULONG max_length, FILE_INFORMATION_CLASS class,
2000 union file_directory_info **last_info )
2001 {
2002 const struct dir_data_names *names = &dir_data->names[dir_data->pos];
2003 union file_directory_info *info;
2004 struct stat st;
2005 ULONG name_len, start, dir_size, attributes;
2006
2007 if (get_file_info( names->unix_name, &st, &attributes ) == -1)
2008 {
2009 TRACE( "file no longer exists %s\n", names->unix_name );
2010 return STATUS_SUCCESS;
2011 }
2012 if (is_ignored_file( &st ))
2013 {
2014 TRACE( "ignoring file %s\n", names->unix_name );
2015 return STATUS_SUCCESS;
2016 }
2017 start = dir_info_align( io->Information );
2018 dir_size = dir_info_size( class, 0 );
2019 if (start + dir_size > max_length) return STATUS_MORE_ENTRIES;
2020
2021 max_length -= start + dir_size;
2022 name_len = wcslen( names->long_name ) * sizeof(WCHAR);
2023 /* if this is not the first entry, fail; the first entry is always returned (but truncated) */
2024 if (*last_info && name_len > max_length) return STATUS_MORE_ENTRIES;
2025
2026 info = (union file_directory_info *)((char *)info_ptr + start);
2027 info->dir.NextEntryOffset = 0;
2028 info->dir.FileIndex = 0; /* NTFS always has 0 here, so let's not bother with it */
2029
2030 /* all the structures except FileNamesInformation start with a FileDirectoryInformation layout */
2031 if (class != FileNamesInformation)
2032 {
2033 if (st.st_dev != dir_data->id.dev) st.st_ino = 0; /* ignore inode if on a different device */
2034
2035 if (!show_dot_files && names->long_name[0] == '.' && names->long_name[1] &&
2036 (names->long_name[1] != '.' || names->long_name[2]))
2037 attributes |= FILE_ATTRIBUTE_HIDDEN;
2038
2039 fill_file_info( &st, attributes, info, class );
2040 }
2041
2042 switch (class)
2043 {
2044 case FileDirectoryInformation:
2045 info->dir.FileNameLength = name_len;
2046 break;
2047
2048 case FileFullDirectoryInformation:
2049 info->full.EaSize = 0; /* FIXME */
2050 info->full.FileNameLength = name_len;
2051 break;
2052
2053 case FileIdFullDirectoryInformation:
2054 info->id_full.EaSize = 0; /* FIXME */
2055 info->id_full.FileNameLength = name_len;
2056 break;
2057
2058 case FileBothDirectoryInformation:
2059 info->both.EaSize = 0; /* FIXME */
2060 info->both.ShortNameLength = wcslen( names->short_name ) * sizeof(WCHAR);
2061 memcpy( info->both.ShortName, names->short_name, info->both.ShortNameLength );
2062 info->both.FileNameLength = name_len;
2063 break;
2064
2065 case FileIdBothDirectoryInformation:
2066 info->id_both.EaSize = 0; /* FIXME */
2067 info->id_both.ShortNameLength = wcslen( names->short_name ) * sizeof(WCHAR);
2068 memcpy( info->id_both.ShortName, names->short_name, info->id_both.ShortNameLength );
2069 info->id_both.FileNameLength = name_len;
2070 break;
2071
2072 case FileIdGlobalTxDirectoryInformation:
2073 info->id_tx.TxInfoFlags = 0;
2074 info->id_tx.FileNameLength = name_len;
2075 break;
2076
2077 case FileNamesInformation:
2078 info->names.FileNameLength = name_len;
2079 break;
2080
2081 default:
2082 assert(0);
2083 return 0;
2084 }
2085
2086 memcpy( (char *)info + dir_size, names->long_name, min( name_len, max_length ) );
2087 io->Information = start + dir_size + min( name_len, max_length );
2088 if (*last_info) (*last_info)->next = (char *)info - (char *)*last_info;
2089 *last_info = info;
2090 return name_len > max_length ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
2091 }
2092
2093 #ifdef VFAT_IOCTL_READDIR_BOTH
2094
2095 /***********************************************************************
2096 * read_directory_vfat
2097 *
2098 * Read a directory using the VFAT ioctl; helper for NtQueryDirectoryFile.
2099 */
2100 static NTSTATUS read_directory_data_vfat( struct dir_data *data, int fd, const UNICODE_STRING *mask )
2101 {
2102 char *short_name, *long_name;
2103 KERNEL_DIRENT de[2];
2104 NTSTATUS status = STATUS_NO_MEMORY;
2105 off_t old_pos = lseek( fd, 0, SEEK_CUR );
2106
2107 lseek( fd, 0, SEEK_SET );
2108
2109 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1)
2110 {
2111 if (errno != ENOENT)
2112 {
2113 status = STATUS_NOT_SUPPORTED;
2114 goto done;
2115 }
2116 de[0].d_reclen = 0;
2117 }
2118
2119 if (!append_entry( data, ".", NULL, mask )) goto done;
2120 if (!append_entry( data, "..", NULL, mask )) goto done;
2121
2122 while (de[0].d_reclen)
2123 {
2124 if (strcmp( de[0].d_name, "." ) && strcmp( de[0].d_name, ".." ))
2125 {
2126 if (de[1].d_name[0])
2127 {
2128 short_name = de[0].d_name;
2129 long_name = de[1].d_name;
2130 }
2131 else
2132 {
2133 long_name = de[0].d_name;
2134 short_name = NULL;
2135 }
2136 if (!append_entry( data, long_name, short_name, mask )) goto done;
2137 }
2138 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)de ) == -1) break;
2139 }
2140 status = STATUS_SUCCESS;
2141 done:
2142 lseek( fd, old_pos, SEEK_SET );
2143 return status;
2144 }
2145 #endif /* VFAT_IOCTL_READDIR_BOTH */
2146
2147
2148 #ifdef HAVE_GETATTRLIST
2149 /***********************************************************************
2150 * read_directory_getattrlist
2151 *
2152 * Read a single file from a directory by determining whether the file
2153 * identified by mask exists using getattrlist.
2154 */
2155 static NTSTATUS read_directory_data_getattrlist( struct dir_data *data, const char *unix_name )
2156 {
2157 struct attrlist attrlist;
2158 #include "pshpack4.h"
2159 struct
2160 {
2161 u_int32_t length;
2162 struct attrreference name_reference;
2163 fsobj_type_t type;
2164 char name[NAME_MAX * 3 + 1];
2165 } buffer;
2166 #include "poppack.h"
2167
2168 memset( &attrlist, 0, sizeof(attrlist) );
2169 attrlist.bitmapcount = ATTR_BIT_MAP_COUNT;
2170 attrlist.commonattr = ATTR_CMN_NAME | ATTR_CMN_OBJTYPE;
2171 if (getattrlist( unix_name, &attrlist, &buffer, sizeof(buffer), FSOPT_NOFOLLOW ) == -1)
2172 return STATUS_NO_SUCH_FILE;
2173 /* If unix_name named a symlink, the above may have succeeded even if the symlink is broken.
2174 Check that with another call without FSOPT_NOFOLLOW. We don't ask for any attributes. */
2175 if (buffer.type == VLNK)
2176 {
2177 u_int32_t dummy;
2178 attrlist.commonattr = 0;
2179 if (getattrlist( unix_name, &attrlist, &dummy, sizeof(dummy), 0 ) == -1)
2180 return STATUS_NO_SUCH_FILE;
2181 }
2182
2183 TRACE( "found %s\n", buffer.name );
2184
2185 if (!append_entry( data, buffer.name, NULL, NULL )) return STATUS_NO_MEMORY;
2186
2187 return STATUS_SUCCESS;
2188 }
2189 #endif /* HAVE_GETATTRLIST */
2190
2191
2192 /***********************************************************************
2193 * read_directory_stat
2194 *
2195 * Read a single file from a directory by determining whether the file
2196 * identified by mask exists using stat.
2197 */
2198 static NTSTATUS read_directory_data_stat( struct dir_data *data, const char *unix_name )
2199 {
2200 struct stat st;
2201
2202 /* if the file system is not case sensitive we can't find the actual name through stat() */
2203 if (!get_dir_case_sensitivity(".")) return STATUS_NO_SUCH_FILE;
2204 if (stat( unix_name, &st ) == -1) return STATUS_NO_SUCH_FILE;
2205
2206 TRACE( "found %s\n", unix_name );
2207
2208 if (!append_entry( data, unix_name, NULL, NULL )) return STATUS_NO_MEMORY;
2209
2210 return STATUS_SUCCESS;
2211 }
2212
2213
2214 /***********************************************************************
2215 * read_directory_readdir
2216 *
2217 * Read a directory using the POSIX readdir interface; helper for NtQueryDirectoryFile.
2218 */
2219 static NTSTATUS read_directory_data_readdir( struct dir_data *data, const UNICODE_STRING *mask )
2220 {
2221 struct dirent *de;
2222 NTSTATUS status = STATUS_NO_MEMORY;
2223 DIR *dir = opendir( "." );
2224
2225 if (!dir) return STATUS_NO_SUCH_FILE;
2226
2227 if (!append_entry( data, ".", NULL, mask )) goto done;
2228 if (!append_entry( data, "..", NULL, mask )) goto done;
2229 while ((de = readdir( dir )))
2230 {
2231 if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
2232 if (!append_entry( data, de->d_name, NULL, mask )) goto done;
2233 }
2234 status = STATUS_SUCCESS;
2235
2236 done:
2237 closedir( dir );
2238 return status;
2239 }
2240
2241
2242 /***********************************************************************
2243 * read_directory_data
2244 *
2245 * Read the full contents of a directory, using one of the above helper functions.
2246 */
2247 static NTSTATUS read_directory_data( struct dir_data *data, int fd, const UNICODE_STRING *mask )
2248 {
2249 NTSTATUS status;
2250
2251 #ifdef VFAT_IOCTL_READDIR_BOTH
2252 if (!(status = read_directory_data_vfat( data, fd, mask ))) return status;
2253 #endif
2254
2255 if (!has_wildcard( mask ))
2256 {
2257 /* convert the mask to a Unix name and check for it */
2258 char unix_name[MAX_DIR_ENTRY_LEN * 3 + 1];
2259 int ret = ntdll_wcstoumbs( mask->Buffer, mask->Length / sizeof(WCHAR),
2260 unix_name, sizeof(unix_name) - 1, TRUE );
2261 if (ret > 0)
2262 {
2263 unix_name[ret] = 0;
2264 #ifdef HAVE_GETATTRLIST
2265 if (!(status = read_directory_data_getattrlist( data, unix_name ))) return status;
2266 #endif
2267 if (!(status = read_directory_data_stat( data, unix_name ))) return status;
2268 }
2269 }
2270
2271 return read_directory_data_readdir( data, mask );
2272 }
2273
2274
2275 /* compare file names for directory sorting */
2276 static int name_compare( const void *a, const void *b )
2277 {
2278 const struct dir_data_names *file_a = (const struct dir_data_names *)a;
2279 const struct dir_data_names *file_b = (const struct dir_data_names *)b;
2280 int ret = wcsicmp( file_a->long_name, file_b->long_name );
2281 if (!ret) ret = wcscmp( file_a->long_name, file_b->long_name );
2282 return ret;
2283 }
2284
2285
2286 /***********************************************************************
2287 * init_cached_dir_data
2288 *
2289 * Initialize the cached directory contents.
2290 */
2291 static NTSTATUS init_cached_dir_data( struct dir_data **data_ret, int fd, const UNICODE_STRING *mask )
2292 {
2293 struct dir_data *data;
2294 struct stat st;
2295 NTSTATUS status;
2296 unsigned int i;
2297
2298 if (!(data = calloc( 1, sizeof(*data) ))) return STATUS_NO_MEMORY;
2299
2300 if ((status = read_directory_data( data, fd, mask )))
2301 {
2302 free_dir_data( data );
2303 return status;
2304 }
2305
2306 /* sort filenames, but not "." and ".." */
2307 i = 0;
2308 if (i < data->count && !strcmp( data->names[i].unix_name, "." )) i++;
2309 if (i < data->count && !strcmp( data->names[i].unix_name, ".." )) i++;
2310 if (i < data->count) qsort( data->names + i, data->count - i, sizeof(*data->names), name_compare );
2311
2312 if (data->count)
2313 {
2314 fstat( fd, &st );
2315 data->id.dev = st.st_dev;
2316 data->id.ino = st.st_ino;
2317 }
2318
2319 TRACE( "mask %s found %u files\n", debugstr_us( mask ), data->count );
2320 for (i = 0; i < data->count; i++)
2321 TRACE( "%s %s\n", debugstr_w(data->names[i].long_name), debugstr_w(data->names[i].short_name) );
2322
2323 *data_ret = data;
2324 return data->count ? STATUS_SUCCESS : STATUS_NO_SUCH_FILE;
2325 }
2326
2327
2328 /***********************************************************************
2329 * get_cached_dir_data
2330 *
2331 * Retrieve the cached directory data, or initialize it if necessary.
2332 */
2333 static NTSTATUS get_cached_dir_data( HANDLE handle, struct dir_data **data_ret, int fd,
2334 const UNICODE_STRING *mask )
2335 {
2336 unsigned int i;
2337 int entry = -1, free_entries[16];
2338 NTSTATUS status;
2339
2340 SERVER_START_REQ( get_directory_cache_entry )
2341 {
2342 req->handle = wine_server_obj_handle( handle );
2343 wine_server_set_reply( req, free_entries, sizeof(free_entries) );
2344 if (!(status = wine_server_call( req ))) entry = reply->entry;
2345
2346 for (i = 0; i < wine_server_reply_size( reply ) / sizeof(*free_entries); i++)
2347 {
2348 int free_idx = free_entries[i];
2349 if (free_idx < dir_data_cache_size)
2350 {
2351 free_dir_data( dir_data_cache[free_idx] );
2352 dir_data_cache[free_idx] = NULL;
2353 }
2354 }
2355 }
2356 SERVER_END_REQ;
2357
2358 if (status)
2359 {
2360 if (status == STATUS_SHARING_VIOLATION) FIXME( "shared directory handle not supported yet\n" );
2361 return status;
2362 }
2363
2364 if (entry >= dir_data_cache_size)
2365 {
2366 unsigned int size = max( dir_data_cache_initial_size, max( dir_data_cache_size * 2, entry + 1 ) );
2367 struct dir_data **new_cache = realloc( dir_data_cache, size * sizeof(*new_cache) );
2368
2369 if (!new_cache) return STATUS_NO_MEMORY;
2370 memset( new_cache + dir_data_cache_size, 0, (size - dir_data_cache_size) * sizeof(*new_cache) );
2371 dir_data_cache = new_cache;
2372 dir_data_cache_size = size;
2373 }
2374
2375 if (!dir_data_cache[entry]) status = init_cached_dir_data( &dir_data_cache[entry], fd, mask );
2376
2377 *data_ret = dir_data_cache[entry];
2378 return status;
2379 }
2380
2381
2382 /******************************************************************************
2383 * NtQueryDirectoryFile (NTDLL.@)
2384 */
2385 NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc_routine,
2386 void *apc_context, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
2387 FILE_INFORMATION_CLASS info_class, BOOLEAN single_entry,
2388 UNICODE_STRING *mask, BOOLEAN restart_scan )
2389 {
2390 int cwd, fd, needs_close;
2391 enum server_fd_type type;
2392 struct dir_data *data;
2393 NTSTATUS status;
2394
2395 TRACE("(%p %p %p %p %p %p 0x%08x 0x%08x 0x%08x %s 0x%08x\n",
2396 handle, event, apc_routine, apc_context, io, buffer,
2397 length, info_class, single_entry, debugstr_us(mask),
2398 restart_scan);
2399
2400 if (event || apc_routine)
2401 {
2402 FIXME( "Unsupported yet option\n" );
2403 return STATUS_NOT_IMPLEMENTED;
2404 }
2405 switch (info_class)
2406 {
2407 case FileDirectoryInformation:
2408 case FileBothDirectoryInformation:
2409 case FileFullDirectoryInformation:
2410 case FileIdBothDirectoryInformation:
2411 case FileIdFullDirectoryInformation:
2412 case FileIdGlobalTxDirectoryInformation:
2413 case FileNamesInformation:
2414 if (length < dir_info_align( dir_info_size( info_class, 1 ))) return STATUS_INFO_LENGTH_MISMATCH;
2415 break;
2416 case FileObjectIdInformation:
2417 if (length != sizeof(FILE_OBJECTID_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
2418 return STATUS_INVALID_INFO_CLASS;
2419 case FileQuotaInformation:
2420 if (length != sizeof(FILE_QUOTA_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
2421 return STATUS_INVALID_INFO_CLASS;
2422 case FileReparsePointInformation:
2423 if (length != sizeof(FILE_REPARSE_POINT_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
2424 return STATUS_INVALID_INFO_CLASS;
2425 default:
2426 return STATUS_INVALID_INFO_CLASS;
2427 }
2428 if (!buffer) return STATUS_ACCESS_VIOLATION;
2429
2430 if ((status = server_get_unix_fd( handle, FILE_LIST_DIRECTORY, &fd, &needs_close, &type, NULL )))
2431 return status;
2432
2433 if (type != FD_TYPE_DIR)
2434 {
2435 if (needs_close) close( fd );
2436 return STATUS_INVALID_PARAMETER;
2437 }
2438
2439 io->Information = 0;
2440
2441 mutex_lock( &dir_mutex );
2442
2443 cwd = open( ".", O_RDONLY );
2444 if (fchdir( fd ) != -1)
2445 {
2446 if (!(status = get_cached_dir_data( handle, &data, fd, mask )))
2447 {
2448 union file_directory_info *last_info = NULL;
2449
2450 if (restart_scan) data->pos = 0;
2451
2452 while (!status && data->pos < data->count)
2453 {
2454 status = get_dir_data_entry( data, buffer, io, length, info_class, &last_info );
2455 if (!status || status == STATUS_BUFFER_OVERFLOW) data->pos++;
2456 if (single_entry && last_info) break;
2457 }
2458
2459 if (!last_info) status = STATUS_NO_MORE_FILES;
2460 else if (status == STATUS_MORE_ENTRIES) status = STATUS_SUCCESS;
2461
2462 io->u.Status = status;
2463 }
2464 if (cwd == -1 || fchdir( cwd ) == -1) chdir( "/" );
2465 }
2466 else status = errno_to_status( errno );
2467
2468 mutex_unlock( &dir_mutex );
2469
2470 if (needs_close) close( fd );
2471 if (cwd != -1) close( cwd );
2472 TRACE( "=> %x (%ld)\n", status, io->Information );
2473 return status;
2474 }
2475
2476
2477 /***********************************************************************
2478 * find_file_in_dir
2479 *
2480 * Find a file in a directory the hard way, by doing a case-insensitive search.
2481 * The file found is appended to unix_name at pos.
2482 * There must be at least MAX_DIR_ENTRY_LEN+2 chars available at pos.
2483 */
2484 static NTSTATUS find_file_in_dir( char *unix_name, int pos, const WCHAR *name, int length,
2485 BOOLEAN check_case, BOOLEAN *is_win_dir )
2486 {
2487 WCHAR buffer[MAX_DIR_ENTRY_LEN];
2488 BOOLEAN is_name_8_dot_3;
2489 DIR *dir;
2490 struct dirent *de;
2491 struct stat st;
2492 int ret;
2493
2494 /* try a shortcut for this directory */
2495
2496 unix_name[pos++] = '/';
2497 ret = ntdll_wcstoumbs( name, length, unix_name + pos, MAX_DIR_ENTRY_LEN + 1, TRUE );
2498 if (ret >= 0 && ret <= MAX_DIR_ENTRY_LEN)
2499 {
2500 unix_name[pos + ret] = 0;
2501 if (!stat( unix_name, &st ))
2502 {
2503 if (is_win_dir) *is_win_dir = is_same_file( &windir, &st );
2504 return STATUS_SUCCESS;
2505 }
2506 }
2507 if (check_case) goto not_found; /* we want an exact match */
2508
2509 if (pos > 1) unix_name[pos - 1] = 0;
2510 else unix_name[1] = 0; /* keep the initial slash */
2511
2512 /* check if it fits in 8.3 so that we don't look for short names if we won't need them */
2513
2514 is_name_8_dot_3 = is_legal_8dot3_name( name, length );
2515 #ifndef VFAT_IOCTL_READDIR_BOTH
2516 is_name_8_dot_3 = is_name_8_dot_3 && length >= 8 && name[4] == '~';
2517 #endif
2518
2519 if (!is_name_8_dot_3 && !get_dir_case_sensitivity( unix_name )) goto not_found;
2520
2521 /* now look for it through the directory */
2522
2523 #ifdef VFAT_IOCTL_READDIR_BOTH
2524 if (is_name_8_dot_3)
2525 {
2526 int fd = open( unix_name, O_RDONLY | O_DIRECTORY );
2527 if (fd != -1)
2528 {
2529 KERNEL_DIRENT kde[2];
2530
2531 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)kde ) != -1)
2532 {
2533 unix_name[pos - 1] = '/';
2534 while (kde[0].d_reclen)
2535 {
2536 if (kde[1].d_name[0])
2537 {
2538 ret = ntdll_umbstowcs( kde[1].d_name, strlen(kde[1].d_name),
2539 buffer, MAX_DIR_ENTRY_LEN );
2540 if (ret == length && !wcsnicmp( buffer, name, ret ))
2541 {
2542 strcpy( unix_name + pos, kde[1].d_name );
2543 close( fd );
2544 goto success;
2545 }
2546 }
2547 ret = ntdll_umbstowcs( kde[0].d_name, strlen(kde[0].d_name),
2548 buffer, MAX_DIR_ENTRY_LEN );
2549 if (ret == length && !wcsnicmp( buffer, name, ret ))
2550 {
2551 strcpy( unix_name + pos,
2552 kde[1].d_name[0] ? kde[1].d_name : kde[0].d_name );
2553 close( fd );
2554 goto success;
2555 }
2556 if (ioctl( fd, VFAT_IOCTL_READDIR_BOTH, (long)kde ) == -1)
2557 {
2558 close( fd );
2559 goto not_found;
2560 }
2561 }
2562 /* if that did not work, restore previous state of unix_name */
2563 unix_name[pos - 1] = 0;
2564 }
2565 close( fd );
2566 }
2567 /* fall through to normal handling */
2568 }
2569 #endif /* VFAT_IOCTL_READDIR_BOTH */
2570
2571 if (!(dir = opendir( unix_name ))) return errno_to_status( errno );
2572
2573 unix_name[pos - 1] = '/';
2574 while ((de = readdir( dir )))
2575 {
2576 ret = ntdll_umbstowcs( de->d_name, strlen(de->d_name), buffer, MAX_DIR_ENTRY_LEN );
2577 if (ret == length && !wcsnicmp( buffer, name, ret ))
2578 {
2579 strcpy( unix_name + pos, de->d_name );
2580 closedir( dir );
2581 goto success;
2582 }
2583
2584 if (!is_name_8_dot_3) continue;
2585
2586 if (!is_legal_8dot3_name( buffer, ret ))
2587 {
2588 WCHAR short_nameW[12];
2589 ret = hash_short_file_name( buffer, ret, short_nameW );
2590 if (ret == length && !wcsnicmp( short_nameW, name, length ))
2591 {
2592 strcpy( unix_name + pos, de->d_name );
2593 closedir( dir );
2594 goto success;
2595 }
2596 }
2597 }
2598 closedir( dir );
2599
2600 not_found:
2601 unix_name[pos - 1] = 0;
2602 return STATUS_OBJECT_PATH_NOT_FOUND;
2603
2604 success:
2605 if (is_win_dir && !stat( unix_name, &st )) *is_win_dir = is_same_file( &windir, &st );
2606 return STATUS_SUCCESS;
2607 }
2608
2609
2610 #ifndef _WIN64
2611
2612 static const WCHAR catrootW[] = {'s','y','s','t','e','m','3','2','\\','c','a','t','r','o','o','t',0};
2613 static const WCHAR catroot2W[] = {'s','y','s','t','e','m','3','2','\\','c','a','t','r','o','o','t','2',0};
2614 static const WCHAR driversstoreW[] = {'s','y','s','t','e','m','3','2','\\','d','r','i','v','e','r','s','s','t','o','r','e',0};
2615 static const WCHAR driversetcW[] = {'s','y','s','t','e','m','3','2','\\','d','r','i','v','e','r','s','\\','e','t','c',0};
2616 static const WCHAR logfilesW[] = {'s','y','s','t','e','m','3','2','\\','l','o','g','f','i','l','e','s',0};
2617 static const WCHAR spoolW[] = {'s','y','s','t','e','m','3','2','\\','s','p','o','o','l',0};
2618 static const WCHAR system32W[] = {'s','y','s','t','e','m','3','2',0};
2619 static const WCHAR sysnativeW[] = {'s','y','s','n','a','t','i','v','e',0};
2620 static const WCHAR regeditW[] = {'r','e','g','e','d','i','t','.','e','x','e',0};
2621
2622 static struct
2623 {
2624 const WCHAR *source;
2625 const char *unix_target;
2626 } redirects[] =
2627 {
2628 { catrootW, NULL },
2629 { catroot2W, NULL },
2630 { driversstoreW, NULL },
2631 { driversetcW, NULL },
2632 { logfilesW, NULL },
2633 { spoolW, NULL },
2634 { system32W, "syswow64" },
2635 { sysnativeW, "system32" },
2636 { regeditW, "syswow64/regedit.exe" }
2637 };
2638
2639 static unsigned int nb_redirects;
2640
2641
2642 /***********************************************************************
2643 * init_redirects
2644 */
2645 static void init_redirects(void)
2646 {
2647 static const char windows_dir[] = "/dosdevices/c:/windows";
2648 char *dir;
2649 struct stat st;
2650
2651 if (!(dir = malloc( strlen(config_dir) + sizeof(windows_dir) ))) return;
2652 strcpy( dir, config_dir );
2653 strcat( dir, windows_dir );
2654 if (!stat( dir, &st ))
2655 {
2656 windir.dev = st.st_dev;
2657 windir.ino = st.st_ino;
2658 nb_redirects = ARRAY_SIZE( redirects );
2659 }
2660 else ERR( "%s: %s\n", dir, strerror(errno) );
2661 free( dir );
2662
2663 }
2664
2665
2666 /***********************************************************************
2667 * match_redirect
2668 *
2669 * Check if path matches a redirect name. If yes, return matched length.
2670 */
2671 static int match_redirect( const WCHAR *path, int len, const WCHAR *redir, BOOLEAN check_case )
2672 {
2673 int i = 0;
2674
2675 while (i < len)
2676 {
2677 int start = i;
2678 while (i < len && !IS_SEPARATOR(path[i])) i++;
2679 if (check_case)
2680 {
2681 if (wcsncmp( path + start, redir, i - start )) return 0;
2682 }
2683 else
2684 {
2685 if (wcsnicmp( path + start, redir, i - start )) return 0;
2686 }
2687 redir += i - start;
2688 while (i < len && IS_SEPARATOR(path[i])) i++;
2689 if (!*redir) return i;
2690 if (*redir++ != '\\') return 0;
2691 }
2692 return 0;
2693 }
2694
2695
2696 /***********************************************************************
2697 * get_redirect_path
2698 *
2699 * Retrieve the Unix path corresponding to a redirected path if any.
2700 */
2701 static int get_redirect_path( char *unix_name, int pos, const WCHAR *name, int length, BOOLEAN check_case )
2702 {
2703 unsigned int i;
2704 int len;
2705
2706 for (i = 0; i < nb_redirects; i++)
2707 {
2708 if ((len = match_redirect( name, length, redirects[i].source, check_case )))
2709 {
2710 if (!redirects[i].unix_target) break;
2711 unix_name[pos++] = '/';
2712 strcpy( unix_name + pos, redirects[i].unix_target );
2713 return len;
2714 }
2715 }
2716 return 0;
2717 }
2718
2719 #else /* _WIN64 */
2720
2721 /* there are no redirects on 64-bit */
2722 static int get_redirect_path( char *unix_name, int pos, const WCHAR *name, int length, BOOLEAN check_case )
2723 {
2724 return 0;
2725 }
2726
2727 #endif
2728
2729 /***********************************************************************
2730 * init_files
2731 */
2732 void init_files(void)
2733 {
2734 #ifndef _WIN64
2735 if (is_wow64) init_redirects();
2736 #endif
2737 /* a couple of directories that we don't want to return in directory searches */
2738 ignore_file( config_dir );
2739 ignore_file( "/dev" );
2740 ignore_file( "/proc" );
2741 #ifdef linux
2742 ignore_file( "/sys" );
2743 #endif
2744 /* retrieve initial umask */
2745 start_umask = umask( 0777 );
2746 umask( start_umask );
2747 }
2748
2749
2750 /******************************************************************************
2751 * get_dos_device
2752 *
2753 * Get the Unix path of a DOS device.
2754 */
2755 static NTSTATUS get_dos_device( const WCHAR *name, UINT name_len, char **unix_name_ret )
2756 {
2757 struct stat st;
2758 char *unix_name, *new_name, *dev;
2759 unsigned int i;
2760 int unix_len;
2761
2762 /* make sure the device name is ASCII */
2763 for (i = 0; i < name_len; i++)
2764 if (name[i] <= 32 || name[i] >= 127) return STATUS_BAD_DEVICE_TYPE;
2765
2766 unix_len = strlen(config_dir) + sizeof("/dosdevices/") + name_len + 1;
2767
2768 if (!(unix_name = malloc( unix_len ))) return STATUS_NO_MEMORY;
2769
2770 strcpy( unix_name, config_dir );
2771 strcat( unix_name, "/dosdevices/" );
2772 dev = unix_name + strlen(unix_name);
2773
2774 for (i = 0; i < name_len; i++) dev[i] = (name[i] >= 'A' && name[i] <= 'Z' ? name[i] + 32 : name[i]);
2775 dev[i] = 0;
2776
2777 /* special case for drive devices */
2778 if (name_len == 2 && dev[1] == ':')
2779 {
2780 dev[i++] = ':';
2781 dev[i] = 0;
2782 }
2783
2784 for (;;)
2785 {
2786 if (!stat( unix_name, &st ))
2787 {
2788 TRACE( "%s -> %s\n", debugstr_wn(name,name_len), debugstr_a(unix_name) );
2789 *unix_name_ret = unix_name;
2790 return STATUS_SUCCESS;
2791 }
2792 if (!dev) break;
2793
2794 /* now try some defaults for it */
2795 if (!strcmp( dev, "aux" ))
2796 {
2797 strcpy( dev, "com1" );
2798 continue;
2799 }
2800 if (!strcmp( dev, "prn" ))
2801 {
2802 strcpy( dev, "lpt1" );
2803 continue;
2804 }
2805
2806 new_name = NULL;
2807 if (dev[1] == ':' && dev[2] == ':') /* drive device */
2808 {
2809 dev[2] = 0; /* remove last ':' to get the drive mount point symlink */
2810 new_name = get_default_drive_device( unix_name );
2811 }
2812
2813 if (!new_name) break;
2814 free( unix_name );
2815 unix_name = new_name;
2816 dev = NULL; /* last try */
2817 }
2818 free( unix_name );
2819 return STATUS_BAD_DEVICE_TYPE;
2820 }
2821
2822
2823 /* return the length of the DOS namespace prefix if any */
2824 static inline int get_dos_prefix_len( const UNICODE_STRING *name )
2825 {
2826 static const WCHAR nt_prefixW[] = {'\\','?','?','\\'};
2827 static const WCHAR dosdev_prefixW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\'};
2828
2829 if (name->Length >= sizeof(nt_prefixW) &&
2830 !memcmp( name->Buffer, nt_prefixW, sizeof(nt_prefixW) ))
2831 return ARRAY_SIZE( nt_prefixW );
2832
2833 if (name->Length >= sizeof(dosdev_prefixW) &&
2834 !wcsnicmp( name->Buffer, dosdev_prefixW, ARRAY_SIZE( dosdev_prefixW )))
2835 return ARRAY_SIZE( dosdev_prefixW );
2836
2837 return 0;
2838 }
2839
2840
2841 /***********************************************************************
2842 * remove_last_componentA
2843 *
2844 * Remove the last component of the path. Helper for find_drive_rootA.
2845 */
2846 static inline unsigned int remove_last_componentA( const char *path, unsigned int len )
2847 {
2848 int level = 0;
2849
2850 while (level < 1)
2851 {
2852 /* find start of the last path component */
2853 unsigned int prev = len;
2854 if (prev <= 1) break; /* reached root */
2855 while (prev > 1 && path[prev - 1] != '/') prev--;
2856 /* does removing it take us up a level? */
2857 if (len - prev != 1 || path[prev] != '.') /* not '.' */
2858 {
2859 if (len - prev == 2 && path[prev] == '.' && path[prev+1] == '.') /* is it '..'? */
2860 level--;
2861 else
2862 level++;
2863 }
2864 /* strip off trailing slashes */
2865 while (prev > 1 && path[prev - 1] == '/') prev--;
2866 len = prev;
2867 }
2868 return len;
2869 }
2870
2871
2872 /***********************************************************************
2873 * find_drive_rootA
2874 *
2875 * Find a drive for which the root matches the beginning of the given path.
2876 * This can be used to translate a Unix path into a drive + DOS path.
2877 * Return value is the drive, or -1 on error. On success, ppath is modified
2878 * to point to the beginning of the DOS path.
2879 */
2880 static NTSTATUS find_drive_rootA( LPCSTR *ppath, unsigned int len, int *drive_ret )
2881 {
2882 /* Starting with the full path, check if the device and inode match any of
2883 * the wine 'drives'. If not then remove the last path component and try
2884 * again. If the last component was a '..' then skip a normal component
2885 * since it's a directory that's ascended back out of.
2886 */
2887 int drive;
2888 char *buffer;
2889 const char *path = *ppath;
2890 struct stat st;
2891 struct file_identity info[MAX_DOS_DRIVES];
2892
2893 /* get device and inode of all drives */
2894 if (!get_drives_info( info )) return STATUS_OBJECT_PATH_NOT_FOUND;
2895
2896 /* strip off trailing slashes */
2897 while (len > 1 && path[len - 1] == '/') len--;
2898
2899 /* make a copy of the path */
2900 if (!(buffer = malloc( len + 1 ))) return STATUS_NO_MEMORY;
2901 memcpy( buffer, path, len );
2902 buffer[len] = 0;
2903
2904 for (;;)
2905 {
2906 if (!stat( buffer, &st ) && S_ISDIR( st.st_mode ))
2907 {
2908 /* Find the drive */
2909 for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
2910 {
2911 if ((info[drive].dev == st.st_dev) && (info[drive].ino == st.st_ino))
2912 {
2913 if (len == 1) len = 0; /* preserve root slash in returned path */
2914 TRACE( "%s -> drive %c:, root=%s, name=%s\n",
2915 debugstr_a(path), 'A' + drive, debugstr_a(buffer), debugstr_a(path + len));
2916 *ppath += len;
2917 *drive_ret = drive;
2918 free( buffer );
2919 return STATUS_SUCCESS;
2920 }
2921 }
2922 }
2923 if (len <= 1) break; /* reached root */
2924 len = remove_last_componentA( buffer, len );
2925 buffer[len] = 0;
2926 }
2927 free( buffer );
2928 return STATUS_OBJECT_PATH_NOT_FOUND;
2929 }
2930
2931
2932 /******************************************************************************
2933 * rebuild_nt_name
2934 */
2935 static void rebuild_nt_name( const UNICODE_STRING *nameW, DWORD prefix_len,
2936 const char *unix_name, UNICODE_STRING *nt_name )
2937 {
2938 WCHAR *buf;
2939 DWORD len;
2940
2941 while (*unix_name == '/') unix_name++;
2942 nt_name->MaximumLength = (prefix_len + strlen(unix_name) + 2) * sizeof(WCHAR);
2943 if (!(buf = malloc( nt_name->MaximumLength ))) return;
2944 nt_name->Buffer = buf;
2945 memcpy( buf, nameW->Buffer, prefix_len * sizeof(WCHAR) );
2946 if (prefix_len && buf[prefix_len - 1] != '\\') buf[prefix_len++] = '\\';
2947 buf += prefix_len;
2948 len = ntdll_umbstowcs( unix_name, strlen(unix_name), buf, strlen(unix_name) );
2949 for (; len; len--, buf++) if (*buf == '/') *buf = '\\';
2950 *buf = 0;
2951 nt_name->Length = (buf - nt_name->Buffer) * sizeof(WCHAR);
2952 }
2953
2954
2955 /******************************************************************************
2956 * find_file_id
2957 *
2958 * Recursively search directories from the dir queue for a given inode.
2959 */
2960 static NTSTATUS find_file_id( char **unix_name, ULONG *len, ULONGLONG file_id, dev_t dev )
2961 {
2962 unsigned int pos;
2963 DIR *dir;
2964 struct dirent *de;
2965 NTSTATUS status;
2966 struct stat st;
2967 char *name = *unix_name;
2968
2969 while (!(status = next_dir_in_queue( name )))
2970 {
2971 if (!(dir = opendir( name ))) continue;
2972 TRACE( "searching %s for %s\n", debugstr_a(name), wine_dbgstr_longlong(file_id) );
2973 pos = strlen( name );
2974 if (pos + MAX_DIR_ENTRY_LEN >= *len / sizeof(WCHAR))
2975 {
2976 if (!(name = realloc( name, *len * 2 )))
2977 {
2978 closedir( dir );
2979 return STATUS_NO_MEMORY;
2980 }
2981 *len *= 2;
2982 *unix_name = name;
2983 }
2984 name[pos++] = '/';
2985 while ((de = readdir( dir )))
2986 {
2987 if (!strcmp( de->d_name, "." ) || !strcmp( de->d_name, ".." )) continue;
2988 strcpy( name + pos, de->d_name );
2989 if (lstat( name, &st ) == -1) continue;
2990 if (st.st_dev != dev) continue;
2991 if (st.st_ino == file_id)
2992 {
2993 closedir( dir );
2994 return STATUS_SUCCESS;
2995 }
2996 if (!S_ISDIR( st.st_mode )) continue;
2997 if ((status = add_dir_to_queue( name )) != STATUS_SUCCESS)
2998 {
2999 closedir( dir );
3000 return status;
3001 }
3002 }
3003 closedir( dir );
3004 }
3005 return status;
3006 }
3007
3008
3009 /******************************************************************************
3010 * file_id_to_unix_file_name
3011 *
3012 * Lookup a file from its file id instead of its name.
3013 */
3014 static NTSTATUS file_id_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char **unix_name_ret,
3015 UNICODE_STRING *nt_name )
3016 {
3017 enum server_fd_type type;
3018 int old_cwd, root_fd, needs_close;
3019 char *unix_name;
3020 ULONG len;
3021 NTSTATUS status;
3022 ULONGLONG file_id;
3023 struct stat st, root_st;
3024
3025 if (attr->ObjectName->Length != sizeof(ULONGLONG)) return STATUS_OBJECT_PATH_SYNTAX_BAD;
3026 if (!attr->RootDirectory) return STATUS_INVALID_PARAMETER;
3027 memcpy( &file_id, attr->ObjectName->Buffer, sizeof(file_id) );
3028
3029 len = 2 * MAX_DIR_ENTRY_LEN + 4;
3030 if (!(unix_name = malloc( len ))) return STATUS_NO_MEMORY;
3031 strcpy( unix_name, "." );
3032
3033 if ((status = server_get_unix_fd( attr->RootDirectory, 0, &root_fd, &needs_close, &type, NULL )))
3034 goto done;
3035
3036 if (type != FD_TYPE_DIR)
3037 {
3038 status = STATUS_OBJECT_TYPE_MISMATCH;
3039 goto done;
3040 }
3041
3042 fstat( root_fd, &root_st );
3043 if (root_st.st_ino == file_id) /* shortcut for "." */
3044 {
3045 status = STATUS_SUCCESS;
3046 goto done;
3047 }
3048
3049 mutex_lock( &dir_mutex );
3050 if ((old_cwd = open( ".", O_RDONLY )) != -1 && fchdir( root_fd ) != -1)
3051 {
3052 /* shortcut for ".." */
3053 if (!stat( "..", &st ) && st.st_dev == root_st.st_dev && st.st_ino == file_id)
3054 {
3055 strcpy( unix_name, ".." );
3056 status = STATUS_SUCCESS;
3057 }
3058 else
3059 {
3060 status = add_dir_to_queue( "." );
3061 if (!status)
3062 status = find_file_id( &unix_name, &len, file_id, root_st.st_dev );
3063 if (!status) /* get rid of "./" prefix */
3064 memmove( unix_name, unix_name + 2, strlen(unix_name) - 1 );
3065 flush_dir_queue();
3066 }
3067 if (fchdir( old_cwd ) == -1) chdir( "/" );
3068 }
3069 else status = errno_to_status( errno );
3070 mutex_unlock( &dir_mutex );
3071 if (old_cwd != -1) close( old_cwd );
3072
3073 done:
3074 if (status == STATUS_SUCCESS)
3075 {
3076 TRACE( "%s -> %s\n", wine_dbgstr_longlong(file_id), debugstr_a(unix_name) );
3077 *unix_name_ret = unix_name;
3078 if (nt_name) rebuild_nt_name( attr->ObjectName, 0, unix_name, nt_name );
3079 }
3080 else
3081 {
3082 TRACE( "%s not found in dir %p\n", wine_dbgstr_longlong(file_id), attr->RootDirectory );
3083 free( unix_name );
3084 }
3085 if (needs_close) close( root_fd );
3086 return status;
3087 }
3088
3089
3090 /******************************************************************************
3091 * lookup_unix_name
3092 *
3093 * Helper for nt_to_unix_file_name
3094 */
3095 static NTSTATUS lookup_unix_name( const WCHAR *name, int name_len, char **buffer, int unix_len, int pos,
3096 UINT disposition, BOOLEAN check_case )
3097 {
3098 NTSTATUS status;
3099 int ret, len;
3100 struct stat st;
3101 char *unix_name = *buffer;
3102 #ifdef _WIN64
3103 const BOOL redirect = FALSE;
3104 #else
3105 const BOOL redirect = NtCurrentTeb64() && !NtCurrentTeb64()->TlsSlots[WOW64_TLS_FILESYSREDIR];
3106 #endif
3107
3108 /* try a shortcut first */
3109
3110 while (name_len && IS_SEPARATOR(*name))
3111 {
3112 name++;
3113 name_len--;
3114 }
3115
3116 unix_name[pos] = '/';
3117 ret = ntdll_wcstoumbs( name, name_len, unix_name + pos + 1, unix_len - pos - 1, TRUE );
3118 if (ret >= 0 && ret < unix_len - pos - 1)
3119 {
3120 char *p;
3121 unix_name[pos + 1 + ret] = 0;
3122 for (p = unix_name + pos ; *p; p++) if (*p == '\\') *p = '/';
3123 if (!name_len || !redirect || (!strstr( unix_name, "/windows/") && strncmp( unix_name, "windows/", 8 )))
3124 {
3125 if (!stat( unix_name, &st ))
3126 {
3127 if (disposition == FILE_CREATE)
3128 return STATUS_OBJECT_NAME_COLLISION;
3129 return STATUS_SUCCESS;
3130 }
3131 }
3132 }
3133
3134 if (!name_len) /* empty name -> drive root doesn't exist */
3135 return STATUS_OBJECT_PATH_NOT_FOUND;
3136 if (check_case && !redirect && (disposition == FILE_OPEN || disposition == FILE_OVERWRITE))
3137 return STATUS_OBJECT_NAME_NOT_FOUND;
3138
3139 /* now do it component by component */
3140
3141 while (name_len)
3142 {
3143 const WCHAR *end, *next;
3144 BOOLEAN is_win_dir = FALSE;
3145
3146 end = name;
3147 while (end < name + name_len && !IS_SEPARATOR(*end)) end++;
3148 next = end;
3149 while (next < name + name_len && IS_SEPARATOR(*next)) next++;
3150 name_len -= next - name;
3151
3152 /* grow the buffer if needed */
3153
3154 if (unix_len - pos < MAX_DIR_ENTRY_LEN + 2)
3155 {
3156 char *new_name;
3157 unix_len += 2 * MAX_DIR_ENTRY_LEN;
3158 if (!(new_name = realloc( unix_name, unix_len ))) return STATUS_NO_MEMORY;
3159 unix_name = *buffer = new_name;
3160 }
3161
3162 status = find_file_in_dir( unix_name, pos, name, end - name,
3163 check_case, redirect ? &is_win_dir : NULL );
3164
3165 /* if this is the last element, not finding it is not necessarily fatal */
3166 if (!name_len)
3167 {
3168 if (status == STATUS_OBJECT_PATH_NOT_FOUND)
3169 {
3170 status = STATUS_OBJECT_NAME_NOT_FOUND;
3171 if (disposition != FILE_OPEN && disposition != FILE_OVERWRITE)
3172 {
3173 ret = ntdll_wcstoumbs( name, end - name, unix_name + pos + 1, MAX_DIR_ENTRY_LEN + 1, TRUE );
3174 if (ret > 0 && ret <= MAX_DIR_ENTRY_LEN)
3175 {
3176 unix_name[pos] = '/';
3177 unix_name[pos + 1 + ret] = 0;
3178 status = STATUS_NO_SUCH_FILE;
3179 break;
3180 }
3181 }
3182 }
3183 else if (status == STATUS_SUCCESS && disposition == FILE_CREATE)
3184 {
3185 status = STATUS_OBJECT_NAME_COLLISION;
3186 }
3187 }
3188
3189 if (status != STATUS_SUCCESS) break;
3190
3191 pos += strlen( unix_name + pos );
3192 name = next;
3193
3194 if (is_win_dir && (len = get_redirect_path( unix_name, pos, name, name_len, check_case )))
3195 {
3196 name += len;
3197 name_len -= len;
3198 pos += strlen( unix_name + pos );
3199 TRACE( "redirecting -> %s + %s\n", debugstr_a(unix_name), debugstr_w(name) );
3200 }
3201 }
3202
3203 return status;
3204 }
3205
3206
3207 /******************************************************************************
3208 * nt_to_unix_file_name_attr
3209 */
3210 static NTSTATUS nt_to_unix_file_name_attr( const OBJECT_ATTRIBUTES *attr, char **name_ret,
3211 UNICODE_STRING *nt_name, UINT disposition )
3212 {
3213 static const WCHAR invalid_charsW[] = { INVALID_NT_CHARS, 0 };
3214 enum server_fd_type type;
3215 int old_cwd, root_fd, needs_close;
3216 const WCHAR *name, *p;
3217 char *unix_name;
3218 int name_len, unix_len;
3219 NTSTATUS status;
3220
3221 if (!attr->RootDirectory) /* without root dir fall back to normal lookup */
3222 return nt_to_unix_file_name( attr->ObjectName, name_ret, nt_name, disposition );
3223
3224 name = attr->ObjectName->Buffer;
3225 name_len = attr->ObjectName->Length / sizeof(WCHAR);
3226
3227 if (name_len && IS_SEPARATOR(name[0])) return STATUS_INVALID_PARAMETER;
3228
3229 /* check for invalid characters */
3230 for (p = name; p < name + name_len; p++)
3231 if (*p < 32 || wcschr( invalid_charsW, *p )) return STATUS_OBJECT_NAME_INVALID;
3232
3233 unix_len = name_len * 3 + MAX_DIR_ENTRY_LEN + 3;
3234 if (!(unix_name = malloc( unix_len ))) return STATUS_NO_MEMORY;
3235 unix_name[0] = '.';
3236
3237 if (!(status = server_get_unix_fd( attr->RootDirectory, 0, &root_fd, &needs_close, &type, NULL )))
3238 {
3239 if (type != FD_TYPE_DIR)
3240 {
3241 if (needs_close) close( root_fd );
3242 status = STATUS_BAD_DEVICE_TYPE;
3243 }
3244 else
3245 {
3246 mutex_lock( &dir_mutex );
3247 if ((old_cwd = open( ".", O_RDONLY )) != -1 && fchdir( root_fd ) != -1)
3248 {
3249 status = lookup_unix_name( name, name_len, &unix_name, unix_len, 1,
3250 disposition, FALSE );
3251 if (fchdir( old_cwd ) == -1) chdir( "/" );
3252 }
3253 else status = errno_to_status( errno );
3254 mutex_unlock( &dir_mutex );
3255 if (old_cwd != -1) close( old_cwd );
3256 if (needs_close) close( root_fd );
3257 }
3258 }
3259 else if (status == STATUS_OBJECT_TYPE_MISMATCH) status = STATUS_BAD_DEVICE_TYPE;
3260
3261 if (status == STATUS_SUCCESS || status == STATUS_NO_SUCH_FILE)
3262 {
3263 TRACE( "%s -> %s\n", debugstr_us(attr->ObjectName), debugstr_a(unix_name) );
3264 *name_ret = unix_name;
3265 if (nt_name) rebuild_nt_name( attr->ObjectName, 0, unix_name, nt_name );
3266 }
3267 else
3268 {
3269 TRACE( "%s not found in %s\n", debugstr_w(name), unix_name );
3270 free( unix_name );
3271 }
3272 return status;
3273 }
3274
3275
3276 /******************************************************************************
3277 * nt_to_unix_file_name
3278 *
3279 * Convert a file name from NT namespace to Unix namespace.
3280 *
3281 * If disposition is not FILE_OPEN or FILE_OVERWRITE, the last path
3282 * element doesn't have to exist; in that case STATUS_NO_SUCH_FILE is
3283 * returned, but the unix name is still filled in properly.
3284 */
3285 NTSTATUS nt_to_unix_file_name( const UNICODE_STRING *nameW, char **unix_name_ret,
3286 UNICODE_STRING *nt_name, UINT disposition )
3287 {
3288 static const WCHAR unixW[] = {'u','n','i','x'};
3289 static const WCHAR invalid_charsW[] = { INVALID_NT_CHARS, 0 };
3290
3291 NTSTATUS status = STATUS_SUCCESS;
3292 const WCHAR *name, *p;
3293 struct stat st;
3294 char *unix_name;
3295 int pos, ret, name_len, unix_len, prefix_len;
3296 WCHAR prefix[MAX_DIR_ENTRY_LEN + 1];
3297 BOOLEAN check_case = FALSE;
3298 BOOLEAN is_unix = FALSE;
3299
3300 name = nameW->Buffer;
3301 name_len = nameW->Length / sizeof(WCHAR);
3302
3303 if (!name_len || !IS_SEPARATOR(name[0])) return STATUS_OBJECT_PATH_SYNTAX_BAD;
3304
3305 if (!(pos = get_dos_prefix_len( nameW )))
3306 return STATUS_BAD_DEVICE_TYPE; /* no DOS prefix, assume NT native name */
3307
3308 name += pos;
3309 name_len -= pos;
3310
3311 if (!name_len) return STATUS_OBJECT_NAME_INVALID;
3312
3313 /* check for sub-directory */
3314 for (pos = 0; pos < name_len && pos <= MAX_DIR_ENTRY_LEN; pos++)
3315 {
3316 if (IS_SEPARATOR(name[pos])) break;
3317 if (name[pos] < 32 || wcschr( invalid_charsW, name[pos] ))
3318 return STATUS_OBJECT_NAME_INVALID;
3319 prefix[pos] = (name[pos] >= 'A' && name[pos] <= 'Z') ? name[pos] + 'a' - 'A' : name[pos];
3320 }
3321 if (pos > MAX_DIR_ENTRY_LEN) return STATUS_OBJECT_NAME_INVALID;
3322
3323 if (pos == name_len) /* no subdir, plain DOS device */
3324 return get_dos_device( name, name_len, unix_name_ret );
3325
3326 prefix_len = pos;
3327 prefix[prefix_len] = 0;
3328
3329 name += prefix_len;
3330 name_len -= prefix_len;
3331
3332 /* check for invalid characters (all chars except 0 are valid for unix) */
3333 is_unix = (prefix_len == 4 && !memcmp( prefix, unixW, sizeof(unixW) ));
3334 if (is_unix)
3335 {
3336 for (p = name; p < name + name_len; p++)
3337 if (!*p) return STATUS_OBJECT_NAME_INVALID;
3338 check_case = TRUE;
3339 }
3340 else
3341 {
3342 for (p = name; p < name + name_len; p++)
3343 if (*p < 32 || wcschr( invalid_charsW, *p )) return STATUS_OBJECT_NAME_INVALID;
3344 }
3345
3346 unix_len = (prefix_len + name_len) * 3 + MAX_DIR_ENTRY_LEN + 3;
3347 unix_len += strlen(config_dir) + sizeof("/dosdevices/");
3348 if (!(unix_name = malloc( unix_len ))) return STATUS_NO_MEMORY;
3349 strcpy( unix_name, config_dir );
3350 strcat( unix_name, "/dosdevices/" );
3351 pos = strlen(unix_name);
3352
3353 ret = ntdll_wcstoumbs( prefix, prefix_len, unix_name + pos, unix_len - pos - 1, TRUE );
3354 if (ret <= 0)
3355 {
3356 free( unix_name );
3357 return STATUS_OBJECT_NAME_INVALID;
3358 }
3359 pos += ret;
3360
3361 /* check if prefix exists (except for DOS drives to avoid extra stat calls) */
3362
3363 if (prefix_len != 2 || prefix[1] != ':')
3364 {
3365 unix_name[pos] = 0;
3366 if (lstat( unix_name, &st ) == -1 && errno == ENOENT)
3367 {
3368 if (!is_unix)
3369 {
3370 free( unix_name );
3371 return STATUS_BAD_DEVICE_TYPE;
3372 }
3373 pos = 0; /* fall back to unix root */
3374 }
3375 }
3376
3377 status = lookup_unix_name( name, name_len, &unix_name, unix_len, pos, disposition, check_case );
3378 if (status == STATUS_SUCCESS || status == STATUS_NO_SUCH_FILE)
3379 {
3380 TRACE( "%s -> %s\n", debugstr_us(nameW), debugstr_a(unix_name) );
3381 *unix_name_ret = unix_name;
3382 if (nt_name) rebuild_nt_name( nameW, name - nameW->Buffer, unix_name + pos, nt_name );
3383 }
3384 else
3385 {
3386 TRACE( "%s not found in %s\n", debugstr_w(name), unix_name );
3387 free( unix_name );
3388 }
3389 return status;
3390 }
3391
3392
3393 /******************************************************************************
3394 * wine_nt_to_unix_file_name
3395 *
3396 * Convert a file name from NT namespace to Unix namespace.
3397 *
3398 * If disposition is not FILE_OPEN or FILE_OVERWRITE, the last path
3399 * element doesn't have to exist; in that case STATUS_NO_SUCH_FILE is
3400 * returned, but the unix name is still filled in properly.
3401 */
3402 NTSTATUS CDECL wine_nt_to_unix_file_name( const UNICODE_STRING *nameW, char *nameA, SIZE_T *size,
3403 UINT disposition )
3404 {
3405 char *buffer = NULL;
3406 NTSTATUS status = nt_to_unix_file_name( nameW, &buffer, NULL, disposition );
3407
3408 if (buffer)
3409 {
3410 if (*size > strlen(buffer)) strcpy( nameA, buffer );
3411 else status = STATUS_BUFFER_TOO_SMALL;
3412 *size = strlen(buffer) + 1;
3413 free( buffer );
3414 }
3415 return status;
3416 }
3417
3418
3419 /******************************************************************
3420 * unix_to_nt_file_name
3421 */
3422 NTSTATUS unix_to_nt_file_name( const char *name, WCHAR **nt )
3423 {
3424 static const WCHAR unix_prefixW[] = {'\\','?','?','\\','u','n','i','x',0};
3425 WCHAR dos_prefixW[] = {'\\','?','?','\\','A',':','\\',0};
3426 const WCHAR *prefix = unix_prefixW;
3427 unsigned int lenW, lenA = strlen(name);
3428 const char *path = name;
3429 NTSTATUS status;
3430 WCHAR *p, *buffer;
3431 int drive;
3432
3433 status = find_drive_rootA( &path, lenA, &drive );
3434 lenA -= path - name;
3435
3436 if (status == STATUS_SUCCESS)
3437 {
3438 while (lenA && path[0] == '/') { lenA--; path++; }
3439 dos_prefixW[4] += drive;
3440 prefix = dos_prefixW;
3441 }
3442 else if (status != STATUS_OBJECT_PATH_NOT_FOUND) return status;
3443
3444 lenW = wcslen( prefix );
3445 if (!(buffer = malloc( (lenA + lenW + 1) * sizeof(WCHAR) ))) return STATUS_NO_MEMORY;
3446 memcpy( buffer, prefix, lenW * sizeof(WCHAR) );
3447 lenW += ntdll_umbstowcs( path, lenA, buffer + lenW, lenA );
3448 buffer[lenW] = 0;
3449 for (p = buffer; *p; p++) if (*p == '/') *p = '\\';
3450 *nt = buffer;
3451 return STATUS_SUCCESS;
3452 }
3453
3454
3455 /******************************************************************
3456 * wine_unix_to_nt_file_name
3457 */
3458 NTSTATUS CDECL wine_unix_to_nt_file_name( const char *name, WCHAR *buffer, SIZE_T *size )
3459 {
3460 WCHAR *nt_name = NULL;
3461 NTSTATUS status;
3462
3463 if (name[0] != '/') return STATUS_INVALID_PARAMETER; /* relative paths are not supported */
3464
3465 status = unix_to_nt_file_name( name, &nt_name );
3466 if (nt_name)
3467 {
3468 if (*size > wcslen(nt_name)) wcscpy( buffer, nt_name );
3469 else status = STATUS_BUFFER_TOO_SMALL;
3470 *size = wcslen(nt_name) + 1;
3471 free( nt_name );
3472 }
3473 return status;
3474 }
3475
3476
3477 /***********************************************************************
3478 * unmount_device
3479 *
3480 * Unmount the specified device.
3481 */
3482 static NTSTATUS unmount_device( HANDLE handle )
3483 {
3484 NTSTATUS status;
3485 int unix_fd, needs_close;
3486
3487 if (!(status = server_get_unix_fd( handle, 0, &unix_fd, &needs_close, NULL, NULL )))
3488 {
3489 struct stat st;
3490 char *mount_point = NULL;
3491
3492 if (fstat( unix_fd, &st ) == -1 || !is_valid_mounted_device( &st ))
3493 status = STATUS_INVALID_PARAMETER;
3494 else
3495 {
3496 if ((mount_point = get_device_mount_point( st.st_rdev )))
3497 {
3498 #ifdef __APPLE__
3499 static const char umount[] = "diskutil unmount >/dev/null 2>&1 ";
3500 #else
3501 static const char umount[] = "umount >/dev/null 2>&1 ";
3502 #endif
3503 char *cmd = malloc( strlen(mount_point)+sizeof(umount));
3504 if (cmd)
3505 {
3506 strcpy( cmd, umount );
3507 strcat( cmd, mount_point );
3508 system( cmd );
3509 free( cmd );
3510 #ifdef linux
3511 /* umount will fail to release the loop device since we still have
3512 a handle to it, so we release it here */
3513 if (major(st.st_rdev) == LOOP_MAJOR) ioctl( unix_fd, 0x4c01 /*LOOP_CLR_FD*/, 0 );
3514 #endif
3515 }
3516 free( mount_point );
3517 }
3518 }
3519 if (needs_close) close( unix_fd );
3520 }
3521 return status;
3522 }
3523
3524
3525 /***********************************************************************
3526 * set_show_dot_files
3527 */
3528 void CDECL set_show_dot_files( BOOL enable )
3529 {
3530 show_dot_files = enable;
3531 }
3532
3533
3534 /******************************************************************************
3535 * open_unix_file
3536 *
3537 * Helper for NtCreateFile that takes a Unix path.
3538 */
3539 NTSTATUS open_unix_file( HANDLE *handle, const char *unix_name, ACCESS_MASK access,
3540 OBJECT_ATTRIBUTES *attr, ULONG attributes, ULONG sharing, ULONG disposition,
3541 ULONG options, void *ea_buffer, ULONG ea_length )
3542 {
3543 struct object_attributes *objattr;
3544 NTSTATUS status;
3545 data_size_t len;
3546
3547 if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
3548
3549 SERVER_START_REQ( create_file )
3550 {
3551 req->access = access;
3552 req->sharing = sharing;
3553 req->create = disposition;
3554 req->options = options;
3555 req->attrs = attributes;
3556 wine_server_add_data( req, objattr, len );
3557 wine_server_add_data( req, unix_name, strlen(unix_name) );
3558 status = wine_server_call( req );
3559 *handle = wine_server_ptr_handle( reply->handle );
3560 }
3561 SERVER_END_REQ;
3562 free( objattr );
3563 return status;
3564 }
3565
3566
3567 /******************************************************************************
3568 * NtCreateFile (NTDLL.@)
3569 */
3570 NTSTATUS WINAPI NtCreateFile( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
3571 IO_STATUS_BLOCK *io, LARGE_INTEGER *alloc_size,
3572 ULONG attributes, ULONG sharing, ULONG disposition,
3573 ULONG options, void *ea_buffer, ULONG ea_length )
3574 {
3575 UNICODE_STRING nt_name = { 0 };
3576 char *unix_name;
3577 BOOL created = FALSE;
3578
3579 TRACE( "handle=%p access=%08x name=%s objattr=%08x root=%p sec=%p io=%p alloc_size=%p "
3580 "attr=%08x sharing=%08x disp=%d options=%08x ea=%p.0x%08x\n",
3581 handle, access, debugstr_us(attr->ObjectName), attr->Attributes,
3582 attr->RootDirectory, attr->SecurityDescriptor, io, alloc_size,
3583 attributes, sharing, disposition, options, ea_buffer, ea_length );
3584
3585 if (!attr || !attr->ObjectName) return STATUS_INVALID_PARAMETER;
3586
3587 if (alloc_size) FIXME( "alloc_size not supported\n" );
3588
3589 if (options & FILE_OPEN_BY_FILE_ID)
3590 io->u.Status = file_id_to_unix_file_name( attr, &unix_name, &nt_name );
3591 else
3592 io->u.Status = nt_to_unix_file_name_attr( attr, &unix_name, &nt_name, disposition );
3593
3594 if (io->u.Status == STATUS_BAD_DEVICE_TYPE)
3595 {
3596 SERVER_START_REQ( open_file_object )
3597 {
3598 req->access = access;
3599 req->attributes = attr->Attributes;
3600 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
3601 req->sharing = sharing;
3602 req->options = options;
3603 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
3604 io->u.Status = wine_server_call( req );
3605 *handle = wine_server_ptr_handle( reply->handle );
3606 }
3607 SERVER_END_REQ;
3608 if (io->u.Status == STATUS_SUCCESS) io->Information = FILE_OPENED;
3609 return io->u.Status;
3610 }
3611
3612 if (io->u.Status == STATUS_NO_SUCH_FILE && disposition != FILE_OPEN && disposition != FILE_OVERWRITE)
3613 {
3614 created = TRUE;
3615 io->u.Status = STATUS_SUCCESS;
3616 }
3617
3618 if (io->u.Status == STATUS_SUCCESS)
3619 {
3620 OBJECT_ATTRIBUTES nt_attr = *attr;
3621
3622 if (nt_name.Buffer) nt_attr.ObjectName = &nt_name;
3623 io->u.Status = open_unix_file( handle, unix_name, access, &nt_attr, attributes,
3624 sharing, disposition, options, ea_buffer, ea_length );
3625 free( nt_name.Buffer );
3626 free( unix_name );
3627 }
3628 else WARN( "%s not found (%x)\n", debugstr_us(attr->ObjectName), io->u.Status );
3629
3630 if (io->u.Status == STATUS_SUCCESS)
3631 {
3632 if (created) io->Information = FILE_CREATED;
3633 else switch(disposition)
3634 {
3635 case FILE_SUPERSEDE:
3636 io->Information = FILE_SUPERSEDED;
3637 break;
3638 case FILE_CREATE:
3639 io->Information = FILE_CREATED;
3640 break;
3641 case FILE_OPEN:
3642 case FILE_OPEN_IF:
3643 io->Information = FILE_OPENED;
3644 break;
3645 case FILE_OVERWRITE:
3646 case FILE_OVERWRITE_IF:
3647 io->Information = FILE_OVERWRITTEN;
3648 break;
3649 }
3650 }
3651 else if (io->u.Status == STATUS_TOO_MANY_OPENED_FILES)
3652 {
3653 static int once;
3654 if (!once++) ERR_(winediag)( "Too many open files, ulimit -n probably needs to be increased\n" );
3655 }
3656
3657 return io->u.Status;
3658 }
3659
3660
3661 /******************************************************************************
3662 * NtOpenFile (NTDLL.@)
3663 */
3664 NTSTATUS WINAPI NtOpenFile( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
3665 IO_STATUS_BLOCK *io, ULONG sharing, ULONG options )
3666 {
3667 return NtCreateFile( handle, access, attr, io, NULL, 0, sharing, FILE_OPEN, options, NULL, 0 );
3668 }
3669
3670
3671 /******************************************************************************
3672 * NtCreateMailslotFile (NTDLL.@)
3673 */
3674 NTSTATUS WINAPI NtCreateMailslotFile( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
3675 IO_STATUS_BLOCK *io, ULONG options, ULONG quota, ULONG msg_size,
3676 LARGE_INTEGER *timeout )
3677 {
3678 NTSTATUS status;
3679 data_size_t len;
3680 struct object_attributes *objattr;
3681
3682 TRACE( "%p %08x %p %p %08x %08x %08x %p\n",
3683 handle, access, attr, io, options, quota, msg_size, timeout );
3684
3685 if (!handle) return STATUS_ACCESS_VIOLATION;
3686 if (!attr) return STATUS_INVALID_PARAMETER;
3687
3688 if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
3689
3690 SERVER_START_REQ( create_mailslot )
3691 {
3692 req->access = access;
3693 req->max_msgsize = msg_size;
3694 req->read_timeout = timeout ? timeout->QuadPart : -1;
3695 wine_server_add_data( req, objattr, len );
3696 if (!(status = wine_server_call( req ))) *handle = wine_server_ptr_handle( reply->handle );
3697 }
3698 SERVER_END_REQ;
3699
3700 free( objattr );
3701 return status;
3702 }
3703
3704
3705 /******************************************************************
3706 * NtCreateNamedPipeFile (NTDLL.@)
3707 */
3708 NTSTATUS WINAPI NtCreateNamedPipeFile( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
3709 IO_STATUS_BLOCK *io, ULONG sharing, ULONG dispo, ULONG options,
3710 ULONG pipe_type, ULONG read_mode, ULONG completion_mode,
3711 ULONG max_inst, ULONG inbound_quota, ULONG outbound_quota,
3712 LARGE_INTEGER *timeout )
3713 {
3714 NTSTATUS status;
3715 data_size_t len;
3716 struct object_attributes *objattr;
3717
3718 if (!attr) return STATUS_INVALID_PARAMETER;
3719
3720 TRACE( "(%p %x %s %p %x %d %x %d %d %d %d %d %d %p)\n",
3721 handle, access, debugstr_us(attr->ObjectName), io, sharing, dispo,
3722 options, pipe_type, read_mode, completion_mode, max_inst, inbound_quota,
3723 outbound_quota, timeout );
3724
3725 /* assume we only get relative timeout */
3726 if (timeout->QuadPart > 0) FIXME( "Wrong time %s\n", wine_dbgstr_longlong(timeout->QuadPart) );
3727
3728 if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
3729
3730 SERVER_START_REQ( create_named_pipe )
3731 {
3732 req->access = access;
3733 req->options = options;
3734 req->sharing = sharing;
3735 req->flags =
3736 (pipe_type ? NAMED_PIPE_MESSAGE_STREAM_WRITE : 0) |
3737 (read_mode ? NAMED_PIPE_MESSAGE_STREAM_READ : 0) |
3738 (completion_mode ? NAMED_PIPE_NONBLOCKING_MODE : 0);
3739 req->maxinstances = max_inst;
3740 req->outsize = outbound_quota;
3741 req->insize = inbound_quota;
3742 req->timeout = timeout->QuadPart;
3743 wine_server_add_data( req, objattr, len );
3744 if (!(status = wine_server_call( req ))) *handle = wine_server_ptr_handle( reply->handle );
3745 }
3746 SERVER_END_REQ;
3747
3748 free( objattr );
3749 return status;
3750 }
3751
3752
3753 /******************************************************************
3754 * NtDeleteFile (NTDLL.@)
3755 */
3756 NTSTATUS WINAPI NtDeleteFile( OBJECT_ATTRIBUTES *attr )
3757 {
3758 HANDLE handle;
3759 NTSTATUS status;
3760 IO_STATUS_BLOCK io;
3761
3762 status = NtCreateFile( &handle, GENERIC_READ | GENERIC_WRITE | DELETE, attr, &io, NULL, 0,
3763 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OPEN,
3764 FILE_DELETE_ON_CLOSE, NULL, 0 );
3765 if (status == STATUS_SUCCESS) NtClose( handle );
3766 return status;
3767 }
3768
3769
3770 /******************************************************************************
3771 * NtQueryFullAttributesFile (NTDLL.@)
3772 */
3773 NTSTATUS WINAPI NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES *attr,
3774 FILE_NETWORK_OPEN_INFORMATION *info )
3775 {
3776 char *unix_name;
3777 NTSTATUS status;
3778
3779 if (!(status = nt_to_unix_file_name_attr( attr, &unix_name, NULL, FILE_OPEN )))
3780 {
3781 ULONG attributes;
3782 struct stat st;
3783
3784 if (get_file_info( unix_name, &st, &attributes ) == -1)
3785 status = errno_to_status( errno );
3786 else if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
3787 status = STATUS_INVALID_INFO_CLASS;
3788 else
3789 {
3790 FILE_BASIC_INFORMATION basic;
3791 FILE_STANDARD_INFORMATION std;
3792
3793 fill_file_info( &st, attributes, &basic, FileBasicInformation );
3794 fill_file_info( &st, attributes, &std, FileStandardInformation );
3795
3796 info->CreationTime = basic.CreationTime;
3797 info->LastAccessTime = basic.LastAccessTime;
3798 info->LastWriteTime = basic.LastWriteTime;
3799 info->ChangeTime = basic.ChangeTime;
3800 info->AllocationSize = std.AllocationSize;
3801 info->EndOfFile = std.EndOfFile;
3802 info->FileAttributes = basic.FileAttributes;
3803 if (is_hidden_file( attr->ObjectName )) info->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
3804 }
3805 free( unix_name );
3806 }
3807 else WARN( "%s not found (%x)\n", debugstr_us(attr->ObjectName), status );
3808 return status;
3809 }
3810
3811
3812 /******************************************************************************
3813 * NtQueryAttributesFile (NTDLL.@)
3814 */
3815 NTSTATUS WINAPI NtQueryAttributesFile( const OBJECT_ATTRIBUTES *attr, FILE_BASIC_INFORMATION *info )
3816 {
3817 char *unix_name;
3818 NTSTATUS status;
3819
3820 if (!(status = nt_to_unix_file_name_attr( attr, &unix_name, NULL, FILE_OPEN )))
3821 {
3822 ULONG attributes;
3823 struct stat st;
3824
3825 if (get_file_info( unix_name, &st, &attributes ) == -1)
3826 status = errno_to_status( errno );
3827 else if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
3828 status = STATUS_INVALID_INFO_CLASS;
3829 else
3830 {
3831 status = fill_file_info( &st, attributes, info, FileBasicInformation );
3832 if (is_hidden_file( attr->ObjectName )) info->FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
3833 }
3834 free( unix_name );
3835 }
3836 else WARN( "%s not found (%x)\n", debugstr_us(attr->ObjectName), status );
3837 return status;
3838 }
3839
3840
3841 /******************************************************************************
3842 * NtQueryInformationFile (NTDLL.@)
3843 */
3844 NTSTATUS WINAPI NtQueryInformationFile( HANDLE handle, IO_STATUS_BLOCK *io,
3845 void *ptr, LONG len, FILE_INFORMATION_CLASS class )
3846 {
3847 static const size_t info_sizes[] =
3848 {
3849 0,
3850 sizeof(FILE_DIRECTORY_INFORMATION), /* FileDirectoryInformation */
3851 sizeof(FILE_FULL_DIRECTORY_INFORMATION), /* FileFullDirectoryInformation */
3852 sizeof(FILE_BOTH_DIRECTORY_INFORMATION), /* FileBothDirectoryInformation */
3853 sizeof(FILE_BASIC_INFORMATION), /* FileBasicInformation */
3854 sizeof(FILE_STANDARD_INFORMATION), /* FileStandardInformation */
3855 sizeof(FILE_INTERNAL_INFORMATION), /* FileInternalInformation */
3856 sizeof(FILE_EA_INFORMATION), /* FileEaInformation */
3857 0, /* FileAccessInformation */
3858 sizeof(FILE_NAME_INFORMATION), /* FileNameInformation */
3859 sizeof(FILE_RENAME_INFORMATION)-sizeof(WCHAR), /* FileRenameInformation */
3860 0, /* FileLinkInformation */
3861 sizeof(FILE_NAMES_INFORMATION)-sizeof(WCHAR), /* FileNamesInformation */
3862 sizeof(FILE_DISPOSITION_INFORMATION), /* FileDispositionInformation */
3863 sizeof(FILE_POSITION_INFORMATION), /* FilePositionInformation */
3864 sizeof(FILE_FULL_EA_INFORMATION), /* FileFullEaInformation */
3865 0, /* FileModeInformation */
3866 sizeof(FILE_ALIGNMENT_INFORMATION), /* FileAlignmentInformation */
3867 sizeof(FILE_ALL_INFORMATION), /* FileAllInformation */
3868 sizeof(FILE_ALLOCATION_INFORMATION), /* FileAllocationInformation */
3869 sizeof(FILE_END_OF_FILE_INFORMATION), /* FileEndOfFileInformation */
3870 0, /* FileAlternateNameInformation */
3871 sizeof(FILE_STREAM_INFORMATION)-sizeof(WCHAR), /* FileStreamInformation */
3872 sizeof(FILE_PIPE_INFORMATION), /* FilePipeInformation */
3873 sizeof(FILE_PIPE_LOCAL_INFORMATION), /* FilePipeLocalInformation */
3874 0, /* FilePipeRemoteInformation */
3875 sizeof(FILE_MAILSLOT_QUERY_INFORMATION), /* FileMailslotQueryInformation */
3876 0, /* FileMailslotSetInformation */
3877 0, /* FileCompressionInformation */
3878 0, /* FileObjectIdInformation */
3879 0, /* FileCompletionInformation */
3880 0, /* FileMoveClusterInformation */
3881 0, /* FileQuotaInformation */
3882 0, /* FileReparsePointInformation */
3883 sizeof(FILE_NETWORK_OPEN_INFORMATION), /* FileNetworkOpenInformation */
3884 sizeof(FILE_ATTRIBUTE_TAG_INFORMATION), /* FileAttributeTagInformation */
3885 0, /* FileTrackingInformation */
3886 0, /* FileIdBothDirectoryInformation */
3887 0, /* FileIdFullDirectoryInformation */
3888 0, /* FileValidDataLengthInformation */
3889 0, /* FileShortNameInformation */
3890 0, /* FileIoCompletionNotificationInformation, */
3891 0, /* FileIoStatusBlockRangeInformation */
3892 0, /* FileIoPriorityHintInformation */
3893 0, /* FileSfioReserveInformation */
3894 0, /* FileSfioVolumeInformation */
3895 0, /* FileHardLinkInformation */
3896 0, /* FileProcessIdsUsingFileInformation */
3897 0, /* FileNormalizedNameInformation */
3898 0, /* FileNetworkPhysicalNameInformation */
3899 0, /* FileIdGlobalTxDirectoryInformation */
3900 0, /* FileIsRemoteDeviceInformation */
3901 0, /* FileAttributeCacheInformation */
3902 0, /* FileNumaNodeInformation */
3903 0, /* FileStandardLinkInformation */
3904 0, /* FileRemoteProtocolInformation */
3905 0, /* FileRenameInformationBypassAccessCheck */
3906 0, /* FileLinkInformationBypassAccessCheck */
3907 0, /* FileVolumeNameInformation */
3908 sizeof(FILE_ID_INFORMATION), /* FileIdInformation */
3909 0, /* FileIdExtdDirectoryInformation */
3910 0, /* FileReplaceCompletionInformation */
3911 0, /* FileHardLinkFullIdInformation */
3912 0, /* FileIdExtdBothDirectoryInformation */
3913 };
3914
3915 struct stat st;
3916 int fd, needs_close = FALSE;
3917 ULONG attr;
3918 unsigned int options;
3919
3920 TRACE( "(%p,%p,%p,0x%08x,0x%08x)\n", handle, io, ptr, len, class);
3921
3922 io->Information = 0;
3923
3924 if (class <= 0 || class >= FileMaximumInformation)
3925 return io->u.Status = STATUS_INVALID_INFO_CLASS;
3926 if (!info_sizes[class])
3927 return server_get_file_info( handle, io, ptr, len, class );
3928 if (len < info_sizes[class])
3929 return io->u.Status = STATUS_INFO_LENGTH_MISMATCH;
3930
3931 if ((io->u.Status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, &options )))
3932 {
3933 if (io->u.Status != STATUS_BAD_DEVICE_TYPE) return io->u.Status;
3934 return server_get_file_info( handle, io, ptr, len, class );
3935 }
3936
3937 switch (class)
3938 {
3939 case FileBasicInformation:
3940 if (fd_get_file_info( fd, options, &st, &attr ) == -1)
3941 io->u.Status = errno_to_status( errno );
3942 else if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
3943 io->u.Status = STATUS_INVALID_INFO_CLASS;
3944 else
3945 fill_file_info( &st, attr, ptr, class );
3946 break;
3947 case FileStandardInformation:
3948 {
3949 FILE_STANDARD_INFORMATION *info = ptr;
3950
3951 if (fd_get_file_info( fd, options, &st, &attr ) == -1) io->u.Status = errno_to_status( errno );
3952 else
3953 {
3954 fill_file_info( &st, attr, info, class );
3955 info->DeletePending = FALSE; /* FIXME */
3956 }
3957 }
3958 break;
3959 case FilePositionInformation:
3960 {
3961 FILE_POSITION_INFORMATION *info = ptr;
3962 off_t res = lseek( fd, 0, SEEK_CUR );
3963 if (res == (off_t)-1) io->u.Status = errno_to_status( errno );
3964 else info->CurrentByteOffset.QuadPart = res;
3965 }
3966 break;
3967 case FileInternalInformation:
3968 if (fd_get_file_info( fd, options, &st, &attr ) == -1) io->u.Status = errno_to_status( errno );
3969 else fill_file_info( &st, attr, ptr, class );
3970 break;
3971 case FileEaInformation:
3972 {
3973 FILE_EA_INFORMATION *info = ptr;
3974 info->EaSize = 0;
3975 }
3976 break;
3977 case FileEndOfFileInformation:
3978 if (fd_get_file_info( fd, options, &st, &attr ) == -1) io->u.Status = errno_to_status( errno );
3979 else fill_file_info( &st, attr, ptr, class );
3980 break;
3981 case FileAllInformation:
3982 {
3983 FILE_ALL_INFORMATION *info = ptr;
3984 char *unix_name;
3985
3986 if (fd_get_file_info( fd, options, &st, &attr ) == -1) io->u.Status = errno_to_status( errno );
3987 else if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
3988 io->u.Status = STATUS_INVALID_INFO_CLASS;
3989 else if (!(io->u.Status = server_get_unix_name( handle, &unix_name )))
3990 {
3991 LONG name_len = len - FIELD_OFFSET(FILE_ALL_INFORMATION, NameInformation.FileName);
3992
3993 fill_file_info( &st, attr, info, FileAllInformation );
3994 info->StandardInformation.DeletePending = FALSE; /* FIXME */
3995 info->EaInformation.EaSize = 0;
3996 info->AccessInformation.AccessFlags = 0; /* FIXME */
3997 info->PositionInformation.CurrentByteOffset.QuadPart = lseek( fd, 0, SEEK_CUR );
3998 info->ModeInformation.Mode = 0; /* FIXME */
3999 info->AlignmentInformation.AlignmentRequirement = 1; /* FIXME */
4000
4001 io->u.Status = fill_name_info( unix_name, &info->NameInformation, &name_len );
4002 free( unix_name );
4003 io->Information = FIELD_OFFSET(FILE_ALL_INFORMATION, NameInformation.FileName) + name_len;
4004 }
4005 }
4006 break;
4007 case FileMailslotQueryInformation:
4008 {
4009 FILE_MAILSLOT_QUERY_INFORMATION *info = ptr;
4010
4011 SERVER_START_REQ( set_mailslot_info )
4012 {
4013 req->handle = wine_server_obj_handle( handle );
4014 req->flags = 0;
4015 io->u.Status = wine_server_call( req );
4016 if( io->u.Status == STATUS_SUCCESS )
4017 {
4018 info->MaximumMessageSize = reply->max_msgsize;
4019 info->MailslotQuota = 0;
4020 info->NextMessageSize = 0;
4021 info->MessagesAvailable = 0;
4022 info->ReadTimeout.QuadPart = reply->read_timeout;
4023 }
4024 }
4025 SERVER_END_REQ;
4026 if (!io->u.Status)
4027 {
4028 char *tmpbuf;
4029 ULONG size = info->MaximumMessageSize ? info->MaximumMessageSize : 0x10000;
4030 if (size > 0x10000) size = 0x10000;
4031 if ((tmpbuf = malloc( size )))
4032 {
4033 if (!server_get_unix_fd( handle, FILE_READ_DATA, &fd, &needs_close, NULL, NULL ))
4034 {
4035 int res = recv( fd, tmpbuf, size, MSG_PEEK );
4036 info->MessagesAvailable = (res > 0);
4037 info->NextMessageSize = (res >= 0) ? res : MAILSLOT_NO_MESSAGE;
4038 if (needs_close) close( fd );
4039 }
4040 free( tmpbuf );
4041 }
4042 }
4043 }
4044 break;
4045 case FileNameInformation:
4046 {
4047 FILE_NAME_INFORMATION *info = ptr;
4048 char *unix_name;
4049
4050 if (!(io->u.Status = server_get_unix_name( handle, &unix_name )))
4051 {
4052 LONG name_len = len - FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
4053 io->u.Status = fill_name_info( unix_name, info, &name_len );
4054 free( unix_name );
4055 io->Information = FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + name_len;
4056 }
4057 }
4058 break;
4059 case FileNetworkOpenInformation:
4060 {
4061 FILE_NETWORK_OPEN_INFORMATION *info = ptr;
4062 char *unix_name;
4063
4064 if (!(io->u.Status = server_get_unix_name( handle, &unix_name )))
4065 {
4066 ULONG attributes;
4067 struct stat st;
4068
4069 if (get_file_info( unix_name, &st, &attributes ) == -1)
4070 io->u.Status = errno_to_status( errno );
4071 else if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
4072 io->u.Status = STATUS_INVALID_INFO_CLASS;
4073 else
4074 {
4075 FILE_BASIC_INFORMATION basic;
4076 FILE_STANDARD_INFORMATION std;
4077
4078 fill_file_info( &st, attributes, &basic, FileBasicInformation );
4079 fill_file_info( &st, attributes, &std, FileStandardInformation );
4080
4081 info->CreationTime = basic.CreationTime;
4082 info->LastAccessTime = basic.LastAccessTime;
4083 info->LastWriteTime = basic.LastWriteTime;
4084 info->ChangeTime = basic.ChangeTime;
4085 info->AllocationSize = std.AllocationSize;
4086 info->EndOfFile = std.EndOfFile;
4087 info->FileAttributes = basic.FileAttributes;
4088 }
4089 free( unix_name );
4090 }
4091 }
4092 break;
4093 case FileIdInformation:
4094 if (fd_get_file_info( fd, options, &st, &attr ) == -1) io->u.Status = errno_to_status( errno );
4095 else
4096 {
4097 struct mountmgr_unix_drive drive;
4098 FILE_ID_INFORMATION *info = ptr;
4099
4100 info->VolumeSerialNumber = 0;
4101 if (!(io->u.Status = get_mountmgr_fs_info( handle, fd, &drive, sizeof(drive) )))
4102 info->VolumeSerialNumber = drive.serial;
4103 memset( &info->FileId, 0, sizeof(info->FileId) );
4104 *(ULONGLONG *)&info->FileId = st.st_ino;
4105 }
4106 break;
4107 case FileAttributeTagInformation:
4108 if (fd_get_file_info( fd, options, &st, &attr ) == -1) io->u.Status = errno_to_status( errno );
4109 else
4110 {
4111 FILE_ATTRIBUTE_TAG_INFORMATION *info = ptr;
4112 info->FileAttributes = attr;
4113 info->ReparseTag = 0; /* FIXME */
4114 if ((options & FILE_OPEN_REPARSE_POINT) && fd_is_mount_point( fd, &st ))
4115 info->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
4116 }
4117 break;
4118 default:
4119 FIXME("Unsupported class (%d)\n", class);
4120 io->u.Status = STATUS_NOT_IMPLEMENTED;
4121 break;
4122 }
4123 if (needs_close) close( fd );
4124 if (io->u.Status == STATUS_SUCCESS && !io->Information) io->Information = info_sizes[class];
4125 return io->u.Status;
4126 }
4127
4128
4129 /******************************************************************************
4130 * NtSetInformationFile (NTDLL.@)
4131 */
4132 NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io,
4133 void *ptr, ULONG len, FILE_INFORMATION_CLASS class )
4134 {
4135 int fd, needs_close;
4136
4137 TRACE( "(%p,%p,%p,0x%08x,0x%08x)\n", handle, io, ptr, len, class );
4138
4139 io->u.Status = STATUS_SUCCESS;
4140 switch (class)
4141 {
4142 case FileBasicInformation:
4143 if (len >= sizeof(FILE_BASIC_INFORMATION))
4144 {
4145 struct stat st;
4146 const FILE_BASIC_INFORMATION *info = ptr;
4147 LARGE_INTEGER mtime, atime;
4148
4149 if ((io->u.Status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, NULL )))
4150 return io->u.Status;
4151
4152 mtime.QuadPart = info->LastWriteTime.QuadPart == -1 ? 0 : info->LastWriteTime.QuadPart;
4153 atime.QuadPart = info->LastAccessTime.QuadPart == -1 ? 0 : info->LastAccessTime.QuadPart;
4154
4155 if (atime.QuadPart || mtime.QuadPart)
4156 io->u.Status = set_file_times( fd, &mtime, &atime );
4157
4158 if (io->u.Status == STATUS_SUCCESS && info->FileAttributes)
4159 {
4160 if (fstat( fd, &st ) == -1) io->u.Status = errno_to_status( errno );
4161 else
4162 {
4163 if (info->FileAttributes & FILE_ATTRIBUTE_READONLY)
4164 {
4165 if (S_ISDIR( st.st_mode))
4166 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
4167 else
4168 st.st_mode &= ~0222; /* clear write permission bits */
4169 }
4170 else
4171 {
4172 /* add write permission only where we already have read permission */
4173 st.st_mode |= (0600 | ((st.st_mode & 044) >> 1)) & (~start_umask);
4174 }
4175 if (fchmod( fd, st.st_mode ) == -1) io->u.Status = errno_to_status( errno );
4176 }
4177 }
4178
4179 if (needs_close) close( fd );
4180 }
4181 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4182 break;
4183
4184 case FilePositionInformation:
4185 if (len >= sizeof(FILE_POSITION_INFORMATION))
4186 {
4187 const FILE_POSITION_INFORMATION *info = ptr;
4188
4189 if ((io->u.Status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, NULL )))
4190 return io->u.Status;
4191
4192 if (lseek( fd, info->CurrentByteOffset.QuadPart, SEEK_SET ) == (off_t)-1)
4193 io->u.Status = errno_to_status( errno );
4194
4195 if (needs_close) close( fd );
4196 }
4197 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4198 break;
4199
4200 case FileEndOfFileInformation:
4201 if (len >= sizeof(FILE_END_OF_FILE_INFORMATION))
4202 {
4203 struct stat st;
4204 const FILE_END_OF_FILE_INFORMATION *info = ptr;
4205
4206 if ((io->u.Status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, NULL )))
4207 return io->u.Status;
4208
4209 /* first try normal truncate */
4210 if (ftruncate( fd, (off_t)info->EndOfFile.QuadPart ) != -1) break;
4211
4212 /* now check for the need to extend the file */
4213 if (fstat( fd, &st ) != -1 && (off_t)info->EndOfFile.QuadPart > st.st_size)
4214 {
4215 static const char zero;
4216
4217 /* extend the file one byte beyond the requested size and then truncate it */
4218 /* this should work around ftruncate implementations that can't extend files */
4219 if (pwrite( fd, &zero, 1, (off_t)info->EndOfFile.QuadPart ) != -1 &&
4220 ftruncate( fd, (off_t)info->EndOfFile.QuadPart ) != -1) break;
4221 }
4222 io->u.Status = errno_to_status( errno );
4223
4224 if (needs_close) close( fd );
4225 }
4226 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4227 break;
4228
4229 case FilePipeInformation:
4230 if (len >= sizeof(FILE_PIPE_INFORMATION))
4231 {
4232 FILE_PIPE_INFORMATION *info = ptr;
4233
4234 if ((info->CompletionMode | info->ReadMode) & ~1)
4235 {
4236 io->u.Status = STATUS_INVALID_PARAMETER;
4237 break;
4238 }
4239
4240 SERVER_START_REQ( set_named_pipe_info )
4241 {
4242 req->handle = wine_server_obj_handle( handle );
4243 req->flags = (info->CompletionMode ? NAMED_PIPE_NONBLOCKING_MODE : 0) |
4244 (info->ReadMode ? NAMED_PIPE_MESSAGE_STREAM_READ : 0);
4245 io->u.Status = wine_server_call( req );
4246 }
4247 SERVER_END_REQ;
4248 }
4249 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4250 break;
4251
4252 case FileMailslotSetInformation:
4253 {
4254 FILE_MAILSLOT_SET_INFORMATION *info = ptr;
4255
4256 SERVER_START_REQ( set_mailslot_info )
4257 {
4258 req->handle = wine_server_obj_handle( handle );
4259 req->flags = MAILSLOT_SET_READ_TIMEOUT;
4260 req->read_timeout = info->ReadTimeout.QuadPart;
4261 io->u.Status = wine_server_call( req );
4262 }
4263 SERVER_END_REQ;
4264 }
4265 break;
4266
4267 case FileCompletionInformation:
4268 if (len >= sizeof(FILE_COMPLETION_INFORMATION))
4269 {
4270 FILE_COMPLETION_INFORMATION *info = ptr;
4271
4272 SERVER_START_REQ( set_completion_info )
4273 {
4274 req->handle = wine_server_obj_handle( handle );
4275 req->chandle = wine_server_obj_handle( info->CompletionPort );
4276 req->ckey = info->CompletionKey;
4277 io->u.Status = wine_server_call( req );
4278 }
4279 SERVER_END_REQ;
4280 } else
4281 io->u.Status = STATUS_INVALID_PARAMETER_3;
4282 break;
4283
4284 case FileIoCompletionNotificationInformation:
4285 if (len >= sizeof(FILE_IO_COMPLETION_NOTIFICATION_INFORMATION))
4286 {
4287 FILE_IO_COMPLETION_NOTIFICATION_INFORMATION *info = ptr;
4288
4289 if (info->Flags & FILE_SKIP_SET_USER_EVENT_ON_FAST_IO)
4290 FIXME( "FILE_SKIP_SET_USER_EVENT_ON_FAST_IO not supported\n" );
4291
4292 SERVER_START_REQ( set_fd_completion_mode )
4293 {
4294 req->handle = wine_server_obj_handle( handle );
4295 req->flags = info->Flags;
4296 io->u.Status = wine_server_call( req );
4297 }
4298 SERVER_END_REQ;
4299 } else
4300 io->u.Status = STATUS_INFO_LENGTH_MISMATCH;
4301 break;
4302
4303 case FileIoPriorityHintInformation:
4304 if (len >= sizeof(FILE_IO_PRIORITY_HINT_INFO))
4305 {
4306 FILE_IO_PRIORITY_HINT_INFO *info = ptr;
4307 if (info->PriorityHint < MaximumIoPriorityHintType)
4308 TRACE( "ignoring FileIoPriorityHintInformation %u\n", info->PriorityHint );
4309 else
4310 io->u.Status = STATUS_INVALID_PARAMETER;
4311 }
4312 else io->u.Status = STATUS_INFO_LENGTH_MISMATCH;
4313 break;
4314
4315 case FileAllInformation:
4316 io->u.Status = STATUS_INVALID_INFO_CLASS;
4317 break;
4318
4319 case FileValidDataLengthInformation:
4320 if (len >= sizeof(FILE_VALID_DATA_LENGTH_INFORMATION))
4321 {
4322 struct stat st;
4323 const FILE_VALID_DATA_LENGTH_INFORMATION *info = ptr;
4324
4325 if ((io->u.Status = server_get_unix_fd( handle, FILE_WRITE_DATA, &fd, &needs_close, NULL, NULL )))
4326 return io->u.Status;
4327
4328 if (fstat( fd, &st ) == -1) io->u.Status = errno_to_status( errno );
4329 else if (info->ValidDataLength.QuadPart <= 0 || (off_t)info->ValidDataLength.QuadPart > st.st_size)
4330 io->u.Status = STATUS_INVALID_PARAMETER;
4331 else
4332 {
4333 #ifdef HAVE_FALLOCATE
4334 if (fallocate( fd, 0, 0, (off_t)info->ValidDataLength.QuadPart ) == -1)
4335 {
4336 NTSTATUS status = errno_to_status( errno );
4337 if (status == STATUS_NOT_SUPPORTED) WARN( "fallocate not supported on this filesystem\n" );
4338 else io->u.Status = status;
4339 }
4340 #else
4341 FIXME( "setting valid data length not supported\n" );
4342 #endif
4343 }
4344 if (needs_close) close( fd );
4345 }
4346 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4347 break;
4348
4349 case FileDispositionInformation:
4350 if (len >= sizeof(FILE_DISPOSITION_INFORMATION))
4351 {
4352 FILE_DISPOSITION_INFORMATION *info = ptr;
4353
4354 SERVER_START_REQ( set_fd_disp_info )
4355 {
4356 req->handle = wine_server_obj_handle( handle );
4357 req->unlink = info->DoDeleteFile;
4358 io->u.Status = wine_server_call( req );
4359 }
4360 SERVER_END_REQ;
4361 } else
4362 io->u.Status = STATUS_INVALID_PARAMETER_3;
4363 break;
4364
4365 case FileRenameInformation:
4366 if (len >= sizeof(FILE_RENAME_INFORMATION))
4367 {
4368 FILE_RENAME_INFORMATION *info = ptr;
4369 UNICODE_STRING name_str, nt_name = { 0 };
4370 OBJECT_ATTRIBUTES attr;
4371 char *unix_name;
4372
4373 name_str.Buffer = info->FileName;
4374 name_str.Length = info->FileNameLength;
4375 name_str.MaximumLength = info->FileNameLength + sizeof(WCHAR);
4376
4377 attr.Length = sizeof(attr);
4378 attr.ObjectName = &name_str;
4379 attr.RootDirectory = info->RootDirectory;
4380 attr.Attributes = OBJ_CASE_INSENSITIVE;
4381
4382 io->u.Status = nt_to_unix_file_name_attr( &attr, &unix_name, &nt_name, FILE_OPEN_IF );
4383 if (io->u.Status != STATUS_SUCCESS && io->u.Status != STATUS_NO_SUCH_FILE)
4384 break;
4385
4386 SERVER_START_REQ( set_fd_name_info )
4387 {
4388 req->handle = wine_server_obj_handle( handle );
4389 req->rootdir = wine_server_obj_handle( attr.RootDirectory );
4390 req->namelen = nt_name.Length;
4391 req->link = FALSE;
4392 req->replace = info->ReplaceIfExists;
4393 wine_server_add_data( req, nt_name.Buffer, nt_name.Length );
4394 wine_server_add_data( req, unix_name, strlen(unix_name) );
4395 io->u.Status = wine_server_call( req );
4396 }
4397 SERVER_END_REQ;
4398
4399 free( unix_name );
4400 free( nt_name.Buffer );
4401 }
4402 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4403 break;
4404
4405 case FileLinkInformation:
4406 if (len >= sizeof(FILE_LINK_INFORMATION))
4407 {
4408 FILE_LINK_INFORMATION *info = ptr;
4409 UNICODE_STRING name_str, nt_name = { 0 };
4410 OBJECT_ATTRIBUTES attr;
4411 char *unix_name;
4412
4413 name_str.Buffer = info->FileName;
4414 name_str.Length = info->FileNameLength;
4415 name_str.MaximumLength = info->FileNameLength + sizeof(WCHAR);
4416
4417 attr.Length = sizeof(attr);
4418 attr.ObjectName = &name_str;
4419 attr.RootDirectory = info->RootDirectory;
4420 attr.Attributes = OBJ_CASE_INSENSITIVE;
4421
4422 io->u.Status = nt_to_unix_file_name_attr( &attr, &unix_name, &nt_name, FILE_OPEN_IF );
4423 if (io->u.Status != STATUS_SUCCESS && io->u.Status != STATUS_NO_SUCH_FILE)
4424 break;
4425
4426 SERVER_START_REQ( set_fd_name_info )
4427 {
4428 req->handle = wine_server_obj_handle( handle );
4429 req->rootdir = wine_server_obj_handle( attr.RootDirectory );
4430 req->namelen = nt_name.Length;
4431 req->link = TRUE;
4432 req->replace = info->ReplaceIfExists;
4433 wine_server_add_data( req, nt_name.Buffer, nt_name.Length );
4434 wine_server_add_data( req, unix_name, strlen(unix_name) );
4435 io->u.Status = wine_server_call( req );
4436 }
4437 SERVER_END_REQ;
4438
4439 free( unix_name );
4440 free( nt_name.Buffer );
4441 }
4442 else io->u.Status = STATUS_INVALID_PARAMETER_3;
4443 break;
4444
4445 default:
4446 FIXME("Unsupported class (%d)\n", class);
4447 io->u.Status = STATUS_NOT_IMPLEMENTED;
4448 break;
4449 }
4450 io->Information = 0;
4451 return io->u.Status;
4452 }
4453
4454
4455 /***********************************************************************
4456 * Asynchronous file I/O *
4457 */
4458
4459 typedef NTSTATUS async_callback_t( void *user, IO_STATUS_BLOCK *io, NTSTATUS status );
4460
4461 struct async_fileio
4462 {
4463 async_callback_t *callback; /* must be the first field */
4464 struct async_fileio *next;
4465 HANDLE handle;
4466 };
4467
4468 struct async_fileio_read
4469 {
4470 struct async_fileio io;
4471 char *buffer;
4472 unsigned int already;
4473 unsigned int count;
4474 BOOL avail_mode;
4475 };
4476
4477 struct async_fileio_write
4478 {
4479 struct async_fileio io;
4480 const char *buffer;
4481 unsigned int already;
4482 unsigned int count;
4483 };
4484
4485 struct async_fileio_read_changes
4486 {
4487 struct async_fileio io;
4488 void *buffer;
4489 ULONG buffer_size;
4490 ULONG data_size;
4491 char data[1];
4492 };
4493
4494 struct async_irp
4495 {
4496 struct async_fileio io;
4497 void *buffer; /* buffer for output */
4498 ULONG size; /* size of buffer */
4499 };
4500
4501 static struct async_fileio *fileio_freelist;
4502
4503 static void release_fileio( struct async_fileio *io )
4504 {
4505 for (;;)
4506 {
4507 struct async_fileio *next = fileio_freelist;
4508 io->next = next;
4509 if (InterlockedCompareExchangePointer( (void **)&fileio_freelist, io, next ) == next) return;
4510 }
4511 }
4512
4513 static struct async_fileio *alloc_fileio( DWORD size, async_callback_t callback, HANDLE handle )
4514 {
4515 /* first free remaining previous fileinfos */
4516 struct async_fileio *io = InterlockedExchangePointer( (void **)&fileio_freelist, NULL );
4517
4518 while (io)
4519 {
4520 struct async_fileio *next = io->next;
4521 free( io );
4522 io = next;
4523 }
4524
4525 if ((io = malloc( size )))
4526 {
4527 io->callback = callback;
4528 io->handle = handle;
4529 }
4530 return io;
4531 }
4532
4533 static async_data_t server_async( HANDLE handle, struct async_fileio *user, HANDLE event,
4534 PIO_APC_ROUTINE apc, void *apc_context, IO_STATUS_BLOCK *io )
4535 {
4536 async_data_t async;
4537 async.handle = wine_server_obj_handle( handle );
4538 async.user = wine_server_client_ptr( user );
4539 async.iosb = wine_server_client_ptr( io );
4540 async.event = wine_server_obj_handle( event );
4541 async.apc = wine_server_client_ptr( apc );
4542 async.apc_context = wine_server_client_ptr( apc_context );
4543 return async;
4544 }
4545
4546 static NTSTATUS wait_async( HANDLE handle, BOOL alertable, IO_STATUS_BLOCK *io )
4547 {
4548 if (NtWaitForSingleObject( handle, alertable, NULL )) return STATUS_PENDING;
4549 return io->u.Status;
4550 }
4551
4552 /* callback for irp async I/O completion */
4553 static NTSTATUS irp_completion( void *user, IO_STATUS_BLOCK *io, NTSTATUS status )
4554 {
4555 struct async_irp *async = user;
4556 ULONG information = 0;
4557
4558 if (status == STATUS_ALERTED)
4559 {
4560 SERVER_START_REQ( get_async_result )
4561 {
4562 req->user_arg = wine_server_client_ptr( async );
4563 wine_server_set_reply( req, async->buffer, async->size );
4564 status = virtual_locked_server_call( req );
4565 information = reply->size;
4566 }
4567 SERVER_END_REQ;
4568 }
4569 if (status != STATUS_PENDING)
4570 {
4571 io->u.Status = status;
4572 io->Information = information;
4573 release_fileio( &async->io );
4574 }
4575 return status;
4576 }
4577
4578 static NTSTATUS async_read_proc( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
4579 {
4580 struct async_fileio_read *fileio = user;
4581 int fd, needs_close, result;
4582
4583 switch (status)
4584 {
4585 case STATUS_ALERTED: /* got some new data */
4586 /* check to see if the data is ready (non-blocking) */
4587 if ((status = server_get_unix_fd( fileio->io.handle, FILE_READ_DATA, &fd,
4588 &needs_close, NULL, NULL )))
4589 break;
4590
4591 result = virtual_locked_read(fd, &fileio->buffer[fileio->already], fileio->count-fileio->already);
4592 if (needs_close) close( fd );
4593
4594 if (result < 0)
4595 {
4596 if (errno == EAGAIN || errno == EINTR)
4597 status = STATUS_PENDING;
4598 else /* check to see if the transfer is complete */
4599 status = errno_to_status( errno );
4600 }
4601 else if (result == 0)
4602 {
4603 status = fileio->already ? STATUS_SUCCESS : STATUS_PIPE_BROKEN;
4604 }
4605 else
4606 {
4607 fileio->already += result;
4608 if (fileio->already >= fileio->count || fileio->avail_mode)
4609 status = STATUS_SUCCESS;
4610 else
4611 status = STATUS_PENDING;
4612 }
4613 break;
4614
4615 case STATUS_TIMEOUT:
4616 case STATUS_IO_TIMEOUT:
4617 if (fileio->already) status = STATUS_SUCCESS;
4618 break;
4619 }
4620 if (status != STATUS_PENDING)
4621 {
4622 iosb->u.Status = status;
4623 iosb->Information = fileio->already;
4624 release_fileio( &fileio->io );
4625 }
4626 return status;
4627 }
4628
4629 static NTSTATUS async_write_proc( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
4630 {
4631 struct async_fileio_write *fileio = user;
4632 int result, fd, needs_close;
4633 enum server_fd_type type;
4634
4635 switch (status)
4636 {
4637 case STATUS_ALERTED:
4638 /* write some data (non-blocking) */
4639 if ((status = server_get_unix_fd( fileio->io.handle, FILE_WRITE_DATA, &fd,
4640 &needs_close, &type, NULL )))
4641 break;
4642
4643 if (!fileio->count && (type == FD_TYPE_MAILSLOT || type == FD_TYPE_SOCKET))
4644 result = send( fd, fileio->buffer, 0, 0 );
4645 else
4646 result = write( fd, &fileio->buffer[fileio->already], fileio->count - fileio->already );
4647
4648 if (needs_close) close( fd );
4649
4650 if (result < 0)
4651 {
4652 if (errno == EAGAIN || errno == EINTR) status = STATUS_PENDING;
4653 else status = errno_to_status( errno );
4654 }
4655 else
4656 {
4657 fileio->already += result;
4658 status = (fileio->already < fileio->count) ? STATUS_PENDING : STATUS_SUCCESS;
4659 }
4660 break;
4661
4662 case STATUS_TIMEOUT:
4663 case STATUS_IO_TIMEOUT:
4664 if (fileio->already) status = STATUS_SUCCESS;
4665 break;
4666 }
4667 if (status != STATUS_PENDING)
4668 {
4669 iosb->u.Status = status;
4670 iosb->Information = fileio->already;
4671 release_fileio( &fileio->io );
4672 }
4673 return status;
4674 }
4675
4676 /* do a read call through the server */
4677 static NTSTATUS server_read_file( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
4678 IO_STATUS_BLOCK *io, void *buffer, ULONG size,
4679 LARGE_INTEGER *offset, ULONG *key )
4680 {
4681 struct async_irp *async;
4682 NTSTATUS status;
4683 HANDLE wait_handle;
4684 ULONG options;
4685
4686 if (!(async = (struct async_irp *)alloc_fileio( sizeof(*async), irp_completion, handle )))
4687 return STATUS_NO_MEMORY;
4688
4689 async->buffer = buffer;
4690 async->size = size;
4691
4692 SERVER_START_REQ( read )
4693 {
4694 req->async = server_async( handle, &async->io, event, apc, apc_context, io );
4695 req->pos = offset ? offset->QuadPart : 0;
4696 wine_server_set_reply( req, buffer, size );
4697 status = virtual_locked_server_call( req );
4698 wait_handle = wine_server_ptr_handle( reply->wait );
4699 options = reply->options;
4700 if (wait_handle && status != STATUS_PENDING)
4701 {
4702 io->u.Status = status;
4703 io->Information = wine_server_reply_size( reply );
4704 }
4705 }
4706 SERVER_END_REQ;
4707
4708 if (status != STATUS_PENDING) free( async );
4709
4710 if (wait_handle) status = wait_async( wait_handle, (options & FILE_SYNCHRONOUS_IO_ALERT), io );
4711 return status;
4712 }
4713
4714 /* do a write call through the server */
4715 static NTSTATUS server_write_file( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
4716 IO_STATUS_BLOCK *io, const void *buffer, ULONG size,
4717 LARGE_INTEGER *offset, ULONG *key )
4718 {
4719 struct async_irp *async;
4720 NTSTATUS status;
4721 HANDLE wait_handle;
4722 ULONG options;
4723
4724 if (!(async = (struct async_irp *)alloc_fileio( sizeof(*async), irp_completion, handle )))
4725 return STATUS_NO_MEMORY;
4726
4727 async->buffer = NULL;
4728 async->size = 0;
4729
4730 SERVER_START_REQ( write )
4731 {
4732 req->async = server_async( handle, &async->io, event, apc, apc_context, io );
4733 req->pos = offset ? offset->QuadPart : 0;
4734 wine_server_add_data( req, buffer, size );
4735 status = wine_server_call( req );
4736 wait_handle = wine_server_ptr_handle( reply->wait );
4737 options = reply->options;
4738 if (wait_handle && status != STATUS_PENDING)
4739 {
4740 io->u.Status = status;
4741 io->Information = reply->size;
4742 }
4743 }
4744 SERVER_END_REQ;
4745
4746 if (status != STATUS_PENDING) free( async );
4747
4748 if (wait_handle) status = wait_async( wait_handle, (options & FILE_SYNCHRONOUS_IO_ALERT), io );
4749 return status;
4750 }
4751
4752 /* do an ioctl call through the server */
4753 static NTSTATUS server_ioctl_file( HANDLE handle, HANDLE event,
4754 PIO_APC_ROUTINE apc, PVOID apc_context,
4755 IO_STATUS_BLOCK *io, ULONG code,
4756 const void *in_buffer, ULONG in_size,
4757 PVOID out_buffer, ULONG out_size )
4758 {
4759 struct async_irp *async;
4760 NTSTATUS status;
4761 HANDLE wait_handle;
4762 ULONG options;
4763
4764 if (!(async = (struct async_irp *)alloc_fileio( sizeof(*async), irp_completion, handle )))
4765 return STATUS_NO_MEMORY;
4766 async->buffer = out_buffer;
4767 async->size = out_size;
4768
4769 SERVER_START_REQ( ioctl )
4770 {
4771 req->code = code;
4772 req->async = server_async( handle, &async->io, event, apc, apc_context, io );
4773 wine_server_add_data( req, in_buffer, in_size );
4774 if ((code & 3) != METHOD_BUFFERED) wine_server_add_data( req, out_buffer, out_size );
4775 wine_server_set_reply( req, out_buffer, out_size );
4776 status = virtual_locked_server_call( req );
4777 wait_handle = wine_server_ptr_handle( reply->wait );
4778 options = reply->options;
4779 if (wait_handle && status != STATUS_PENDING)
4780 {
4781 io->u.Status = status;
4782 io->Information = wine_server_reply_size( reply );
4783 }
4784 }
4785 SERVER_END_REQ;
4786
4787 if (status == STATUS_NOT_SUPPORTED)
4788 WARN("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
4789 code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
4790
4791 if (status != STATUS_PENDING) free( async );
4792
4793 if (wait_handle) status = wait_async( wait_handle, (options & FILE_SYNCHRONOUS_IO_ALERT), io );
4794 return status;
4795 }
4796
4797
4798 struct io_timeouts
4799 {
4800 int interval; /* max interval between two bytes */
4801 int total; /* total timeout for the whole operation */
4802 int end_time; /* absolute time of end of operation */
4803 };
4804
4805 /* retrieve the I/O timeouts to use for a given handle */
4806 static NTSTATUS get_io_timeouts( HANDLE handle, enum server_fd_type type, ULONG count, BOOL is_read,
4807 struct io_timeouts *timeouts )
4808 {
4809 NTSTATUS status = STATUS_SUCCESS;
4810
4811 timeouts->interval = timeouts->total = -1;
4812
4813 switch(type)
4814 {
4815 case FD_TYPE_SERIAL:
4816 {
4817 /* GetCommTimeouts */
4818 SERIAL_TIMEOUTS st;
4819 IO_STATUS_BLOCK io;
4820
4821 status = NtDeviceIoControlFile( handle, NULL, NULL, NULL, &io,
4822 IOCTL_SERIAL_GET_TIMEOUTS, NULL, 0, &st, sizeof(st) );
4823 if (status) break;
4824
4825 if (is_read)
4826 {
4827 if (st.ReadIntervalTimeout)
4828 timeouts->interval = st.ReadIntervalTimeout;
4829
4830 if (st.ReadTotalTimeoutMultiplier || st.ReadTotalTimeoutConstant)
4831 {
4832 timeouts->total = st.ReadTotalTimeoutConstant;
4833 if (st.ReadTotalTimeoutMultiplier != MAXDWORD)
4834 timeouts->total += count * st.ReadTotalTimeoutMultiplier;
4835 }
4836 else if (st.ReadIntervalTimeout == MAXDWORD)
4837 timeouts->interval = timeouts->total = 0;
4838 }
4839 else /* write */
4840 {
4841 if (st.WriteTotalTimeoutMultiplier || st.WriteTotalTimeoutConstant)
4842 {
4843 timeouts->total = st.WriteTotalTimeoutConstant;
4844 if (st.WriteTotalTimeoutMultiplier != MAXDWORD)
4845 timeouts->total += count * st.WriteTotalTimeoutMultiplier;
4846 }
4847 }
4848 break;
4849 }
4850 case FD_TYPE_MAILSLOT:
4851 if (is_read)
4852 {
4853 timeouts->interval = 0; /* return as soon as we got something */
4854 SERVER_START_REQ( set_mailslot_info )
4855 {
4856 req->handle = wine_server_obj_handle( handle );
4857 req->flags = 0;
4858 if (!(status = wine_server_call( req )) &&
4859 reply->read_timeout != TIMEOUT_INFINITE)
4860 timeouts->total = reply->read_timeout / -10000;
4861 }
4862 SERVER_END_REQ;
4863 }
4864 break;
4865 case FD_TYPE_SOCKET:
4866 case FD_TYPE_CHAR:
4867 if (is_read) timeouts->interval = 0; /* return as soon as we got something */
4868 break;
4869 default:
4870 break;
4871 }
4872 if (timeouts->total != -1) timeouts->end_time = NtGetTickCount() + timeouts->total;
4873 return STATUS_SUCCESS;
4874 }
4875
4876
4877 /* retrieve the timeout for the next wait, in milliseconds */
4878 static inline int get_next_io_timeout( const struct io_timeouts *timeouts, ULONG already )
4879 {
4880 int ret = -1;
4881
4882 if (timeouts->total != -1)
4883 {
4884 ret = timeouts->end_time - NtGetTickCount();
4885 if (ret < 0) ret = 0;
4886 }
4887 if (already && timeouts->interval != -1)
4888 {
4889 if (ret == -1 || ret > timeouts->interval) ret = timeouts->interval;
4890 }
4891 return ret;
4892 }
4893
4894
4895 /* retrieve the avail_mode flag for async reads */
4896 static NTSTATUS get_io_avail_mode( HANDLE handle, enum server_fd_type type, BOOL *avail_mode )
4897 {
4898 NTSTATUS status = STATUS_SUCCESS;
4899
4900 switch(type)
4901 {
4902 case FD_TYPE_SERIAL:
4903 {
4904 /* GetCommTimeouts */
4905 SERIAL_TIMEOUTS st;
4906 IO_STATUS_BLOCK io;
4907
4908 status = NtDeviceIoControlFile( handle, NULL, NULL, NULL, &io,
4909 IOCTL_SERIAL_GET_TIMEOUTS, NULL, 0, &st, sizeof(st) );
4910 if (status) break;
4911 *avail_mode = (!st.ReadTotalTimeoutMultiplier &&
4912 !st.ReadTotalTimeoutConstant &&
4913 st.ReadIntervalTimeout == MAXDWORD);
4914 break;
4915 }
4916 case FD_TYPE_MAILSLOT:
4917 case FD_TYPE_SOCKET:
4918 case FD_TYPE_CHAR:
4919 *avail_mode = TRUE;
4920 break;
4921 default:
4922 *avail_mode = FALSE;
4923 break;
4924 }
4925 return status;
4926 }
4927
4928 /* register an async I/O for a file read; helper for NtReadFile */
4929 static NTSTATUS register_async_file_read( HANDLE handle, HANDLE event,
4930 PIO_APC_ROUTINE apc, void *apc_user,
4931 IO_STATUS_BLOCK *iosb, void *buffer,
4932 ULONG already, ULONG length, BOOL avail_mode )
4933 {
4934 struct async_fileio_read *fileio;
4935 NTSTATUS status;
4936
4937 if (!(fileio = (struct async_fileio_read *)alloc_fileio( sizeof(*fileio), async_read_proc, handle )))
4938 return STATUS_NO_MEMORY;
4939
4940 fileio->already = already;
4941 fileio->count = length;
4942 fileio->buffer = buffer;
4943 fileio->avail_mode = avail_mode;
4944
4945 SERVER_START_REQ( register_async )
4946 {
4947 req->type = ASYNC_TYPE_READ;
4948 req->count = length;
4949 req->async = server_async( handle, &fileio->io, event, apc, apc_user, iosb );
4950 status = wine_server_call( req );
4951 }
4952 SERVER_END_REQ;
4953
4954 if (status != STATUS_PENDING) free( fileio );
4955 return status;
4956 }
4957
4958 static void add_completion( HANDLE handle, ULONG_PTR value, NTSTATUS status, ULONG info, BOOL async )
4959 {
4960 SERVER_START_REQ( add_fd_completion )
4961 {
4962 req->handle = wine_server_obj_handle( handle );
4963 req->cvalue = value;
4964 req->status = status;
4965 req->information = info;
4966 req->async = async;
4967 wine_server_call( req );
4968 }
4969 SERVER_END_REQ;
4970 }
4971
4972 static NTSTATUS set_pending_write( HANDLE device )
4973 {
4974 NTSTATUS status;
4975
4976 SERVER_START_REQ( set_serial_info )
4977 {
4978 req->handle = wine_server_obj_handle( device );
4979 req->flags = SERIALINFO_PENDING_WRITE;
4980 status = wine_server_call( req );
4981 }
4982 SERVER_END_REQ;
4983 return status;
4984 }
4985
4986
4987 /******************************************************************************
4988 * NtReadFile (NTDLL.@)
4989 */
4990 NTSTATUS WINAPI NtReadFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
4991 IO_STATUS_BLOCK *io, void *buffer, ULONG length,
4992 LARGE_INTEGER *offset, ULONG *key )
4993 {
4994 int result, unix_handle, needs_close;
4995 unsigned int options;
4996 struct io_timeouts timeouts;
4997 NTSTATUS status, ret_status;
4998 ULONG total = 0;
4999 enum server_fd_type type;
5000 ULONG_PTR cvalue = apc ? 0 : (ULONG_PTR)apc_user;
5001 BOOL send_completion = FALSE, async_read, timeout_init_done = FALSE;
5002
5003 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p)\n",
5004 handle, event, apc, apc_user, io, buffer, length, offset, key );
5005
5006 if (!io) return STATUS_ACCESS_VIOLATION;
5007
5008 status = server_get_unix_fd( handle, FILE_READ_DATA, &unix_handle, &needs_close, &type, &options );
5009 if (status && status != STATUS_BAD_DEVICE_TYPE) return status;
5010
5011 if (!virtual_check_buffer_for_write( buffer, length )) return STATUS_ACCESS_VIOLATION;
5012
5013 if (status == STATUS_BAD_DEVICE_TYPE)
5014 return server_read_file( handle, event, apc, apc_user, io, buffer, length, offset, key );
5015
5016 async_read = !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
5017
5018 if (type == FD_TYPE_FILE)
5019 {
5020 if (async_read && (!offset || offset->QuadPart < 0))
5021 {
5022 status = STATUS_INVALID_PARAMETER;
5023 goto done;
5024 }
5025
5026 if (offset && offset->QuadPart != FILE_USE_FILE_POINTER_POSITION)
5027 {
5028 /* async I/O doesn't make sense on regular files */
5029 while ((result = virtual_locked_pread( unix_handle, buffer, length, offset->QuadPart )) == -1)
5030 {
5031 if (errno != EINTR)
5032 {
5033 status = errno_to_status( errno );
5034 goto done;
5035 }
5036 }
5037 if (!async_read) /* update file pointer position */
5038 lseek( unix_handle, offset->QuadPart + result, SEEK_SET );
5039
5040 total = result;
5041 status = (total || !length) ? STATUS_SUCCESS : STATUS_END_OF_FILE;
5042 goto done;
5043 }
5044 }
5045 else if (type == FD_TYPE_SERIAL || type == FD_TYPE_DEVICE)
5046 {
5047 if (async_read && (!offset || offset->QuadPart < 0))
5048 {
5049 status = STATUS_INVALID_PARAMETER;
5050 goto done;
5051 }
5052 }
5053
5054 if (type == FD_TYPE_SERIAL && async_read && length)
5055 {
5056 /* an asynchronous serial port read with a read interval timeout needs to
5057 skip the synchronous read to make sure that the server starts the read
5058 interval timer after the first read */
5059 if ((status = get_io_timeouts( handle, type, length, TRUE, &timeouts ))) goto err;
5060 if (timeouts.interval)
5061 {
5062 status = register_async_file_read( handle, event, apc, apc_user, io,
5063 buffer, total, length, FALSE );
5064 goto err;
5065 }
5066 }
5067
5068 for (;;)
5069 {
5070 if ((result = virtual_locked_read( unix_handle, (char *)buffer + total, length - total )) >= 0)
5071 {
5072 total += result;
5073 if (!result || total == length)
5074 {
5075 if (total)
5076 {
5077 status = STATUS_SUCCESS;
5078 goto done;
5079 }
5080 switch (type)
5081 {
5082 case FD_TYPE_FILE:
5083 case FD_TYPE_CHAR:
5084 case FD_TYPE_DEVICE:
5085 status = length ? STATUS_END_OF_FILE : STATUS_SUCCESS;
5086 goto done;
5087 case FD_TYPE_SERIAL:
5088 if (!length)
5089 {
5090 status = STATUS_SUCCESS;
5091 goto done;
5092 }
5093 break;
5094 default:
5095 status = STATUS_PIPE_BROKEN;
5096 goto err;
5097 }
5098 }
5099 else if (type == FD_TYPE_FILE) continue; /* no async I/O on regular files */
5100 }
5101 else if (errno != EAGAIN)
5102 {
5103 if (errno == EINTR) continue;
5104 if (!total) status = errno_to_status( errno );
5105 goto err;
5106 }
5107
5108 if (async_read)
5109 {
5110 BOOL avail_mode;
5111
5112 if ((status = get_io_avail_mode( handle, type, &avail_mode ))) goto err;
5113 if (total && avail_mode)
5114 {
5115 status = STATUS_SUCCESS;
5116 goto done;
5117 }
5118 status = register_async_file_read( handle, event, apc, apc_user, io,
5119 buffer, total, length, avail_mode );
5120 goto err;
5121 }
5122 else /* synchronous read, wait for the fd to become ready */
5123 {
5124 struct pollfd pfd;
5125 int ret, timeout;
5126
5127 if (!timeout_init_done)
5128 {
5129 timeout_init_done = TRUE;
5130 if ((status = get_io_timeouts( handle, type, length, TRUE, &timeouts ))) goto err;
5131 if (event) NtResetEvent( event, NULL );
5132 }
5133 timeout = get_next_io_timeout( &timeouts, total );
5134
5135 pfd.fd = unix_handle;
5136 pfd.events = POLLIN;
5137
5138 if (!timeout || !(ret = poll( &pfd, 1, timeout )))
5139 {
5140 if (total) /* return with what we got so far */
5141 status = STATUS_SUCCESS;
5142 else
5143 status = (type == FD_TYPE_MAILSLOT) ? STATUS_IO_TIMEOUT : STATUS_TIMEOUT;
5144 goto done;
5145 }
5146 if (ret == -1 && errno != EINTR)
5147 {
5148 status = errno_to_status( errno );
5149 goto done;
5150 }
5151 /* will now restart the read */
5152 }
5153 }
5154
5155 done:
5156 send_completion = cvalue != 0;
5157
5158 err:
5159 if (needs_close) close( unix_handle );
5160 if (status == STATUS_SUCCESS || (status == STATUS_END_OF_FILE && (!async_read || type == FD_TYPE_FILE)))
5161 {
5162 io->u.Status = status;
5163 io->Information = total;
5164 TRACE("= SUCCESS (%u)\n", total);
5165 if (event) NtSetEvent( event, NULL );
5166 if (apc && (!status || async_read)) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)apc,
5167 (ULONG_PTR)apc_user, (ULONG_PTR)io, 0 );
5168 }
5169 else
5170 {
5171 TRACE("= 0x%08x\n", status);
5172 if (status != STATUS_PENDING && event) NtResetEvent( event, NULL );
5173 }
5174
5175 ret_status = async_read && type == FD_TYPE_FILE && (status == STATUS_SUCCESS || status == STATUS_END_OF_FILE)
5176 ? STATUS_PENDING : status;
5177
5178 if (send_completion) add_completion( handle, cvalue, status, total, ret_status == STATUS_PENDING );
5179 return ret_status;
5180 }
5181
5182
5183 /******************************************************************************
5184 * NtReadFileScatter (NTDLL.@)
5185 */
5186 NTSTATUS WINAPI NtReadFileScatter( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
5187 IO_STATUS_BLOCK *io, FILE_SEGMENT_ELEMENT *segments,
5188 ULONG length, LARGE_INTEGER *offset, ULONG *key )
5189 {
5190 int result, unix_handle, needs_close;
5191 unsigned int options;
5192 NTSTATUS status;
5193 ULONG pos = 0, total = 0;
5194 enum server_fd_type type;
5195 ULONG_PTR cvalue = apc ? 0 : (ULONG_PTR)apc_user;
5196 BOOL send_completion = FALSE;
5197
5198 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
5199 file, event, apc, apc_user, io, segments, length, offset, key );
5200
5201 if (!io) return STATUS_ACCESS_VIOLATION;
5202
5203 status = server_get_unix_fd( file, FILE_READ_DATA, &unix_handle, &needs_close, &type, &options );
5204 if (status) return status;
5205
5206 if ((type != FD_TYPE_FILE) ||
5207 (options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)) ||
5208 !(options & FILE_NO_INTERMEDIATE_BUFFERING))
5209 {
5210 status = STATUS_INVALID_PARAMETER;
5211 goto error;
5212 }
5213
5214 while (length)
5215 {
5216 if (offset && offset->QuadPart != FILE_USE_FILE_POINTER_POSITION)
5217 result = pread( unix_handle, (char *)segments->Buffer + pos,
5218 min( length - pos, page_size - pos ), offset->QuadPart + total );
5219 else
5220 result = read( unix_handle, (char *)segments->Buffer + pos, min( length - pos, page_size - pos ) );
5221
5222 if (result == -1)
5223 {
5224 if (errno == EINTR) continue;
5225 status = errno_to_status( errno );
5226 break;
5227 }
5228 if (!result) break;
5229 total += result;
5230 length -= result;
5231 if ((pos += result) == page_size)
5232 {
5233 pos = 0;
5234 segments++;
5235 }
5236 }
5237
5238 if (total == 0) status = STATUS_END_OF_FILE;
5239
5240 send_completion = cvalue != 0;
5241
5242 if (needs_close) close( unix_handle );
5243 io->u.Status = status;
5244 io->Information = total;
5245 TRACE("= 0x%08x (%u)\n", status, total);
5246 if (event) NtSetEvent( event, NULL );
5247 if (apc) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)apc,
5248 (ULONG_PTR)apc_user, (ULONG_PTR)io, 0 );
5249 if (send_completion) add_completion( file, cvalue, status, total, TRUE );
5250
5251 return STATUS_PENDING;
5252
5253 error:
5254 if (needs_close) close( unix_handle );
5255 if (event) NtResetEvent( event, NULL );
5256 TRACE("= 0x%08x\n", status);
5257 return status;
5258 }
5259
5260
5261 /******************************************************************************
5262 * NtWriteFile (NTDLL.@)
5263 */
5264 NTSTATUS WINAPI NtWriteFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
5265 IO_STATUS_BLOCK *io, const void *buffer, ULONG length,
5266 LARGE_INTEGER *offset, ULONG *key )
5267 {
5268 int result, unix_handle, needs_close;
5269 unsigned int options;
5270 struct io_timeouts timeouts;
5271 NTSTATUS status, ret_status;
5272 ULONG total = 0;
5273 enum server_fd_type type;
5274 ULONG_PTR cvalue = apc ? 0 : (ULONG_PTR)apc_user;
5275 BOOL send_completion = FALSE, async_write, append_write = FALSE, timeout_init_done = FALSE;
5276 LARGE_INTEGER offset_eof;
5277
5278 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p)\n",
5279 handle, event, apc, apc_user, io, buffer, length, offset, key );
5280
5281 if (!io) return STATUS_ACCESS_VIOLATION;
5282
5283 status = server_get_unix_fd( handle, FILE_WRITE_DATA, &unix_handle, &needs_close, &type, &options );
5284 if (status == STATUS_ACCESS_DENIED)
5285 {
5286 status = server_get_unix_fd( handle, FILE_APPEND_DATA, &unix_handle,
5287 &needs_close, &type, &options );
5288 append_write = TRUE;
5289 }
5290 if (status && status != STATUS_BAD_DEVICE_TYPE) return status;
5291
5292 async_write = !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
5293
5294 if (!virtual_check_buffer_for_read( buffer, length ))
5295 {
5296 status = STATUS_INVALID_USER_BUFFER;
5297 goto done;
5298 }
5299
5300 if (status == STATUS_BAD_DEVICE_TYPE)
5301 return server_write_file( handle, event, apc, apc_user, io, buffer, length, offset, key );
5302
5303 if (type == FD_TYPE_FILE)
5304 {
5305 if (async_write &&
5306 (!offset || (offset->QuadPart < 0 && offset->QuadPart != FILE_WRITE_TO_END_OF_FILE)))
5307 {
5308 status = STATUS_INVALID_PARAMETER;
5309 goto done;
5310 }
5311
5312 if (append_write)
5313 {
5314 offset_eof.QuadPart = FILE_WRITE_TO_END_OF_FILE;
5315 offset = &offset_eof;
5316 }
5317
5318 if (offset && offset->QuadPart != FILE_USE_FILE_POINTER_POSITION)
5319 {
5320 off_t off = offset->QuadPart;
5321
5322 if (offset->QuadPart == FILE_WRITE_TO_END_OF_FILE)
5323 {
5324 struct stat st;
5325
5326 if (fstat( unix_handle, &st ) == -1)
5327 {
5328 status = errno_to_status( errno );
5329 goto done;
5330 }
5331 off = st.st_size;
5332 }
5333 else if (offset->QuadPart < 0)
5334 {
5335 status = STATUS_INVALID_PARAMETER;
5336 goto done;
5337 }
5338
5339 /* async I/O doesn't make sense on regular files */
5340 while ((result = pwrite( unix_handle, buffer, length, off )) == -1)
5341 {
5342 if (errno != EINTR)
5343 {
5344 if (errno == EFAULT) status = STATUS_INVALID_USER_BUFFER;
5345 else status = errno_to_status( errno );
5346 goto done;
5347 }
5348 }
5349
5350 if (!async_write) /* update file pointer position */
5351 lseek( unix_handle, off + result, SEEK_SET );
5352
5353 total = result;
5354 status = STATUS_SUCCESS;
5355 goto done;
5356 }
5357 }
5358 else if (type == FD_TYPE_SERIAL || type == FD_TYPE_DEVICE)
5359 {
5360 if (async_write &&
5361 (!offset || (offset->QuadPart < 0 && offset->QuadPart != FILE_WRITE_TO_END_OF_FILE)))
5362 {
5363 status = STATUS_INVALID_PARAMETER;
5364 goto done;
5365 }
5366 }
5367
5368 for (;;)
5369 {
5370 /* zero-length writes on sockets may not work with plain write(2) */
5371 if (!length && (type == FD_TYPE_MAILSLOT || type == FD_TYPE_SOCKET))
5372 result = send( unix_handle, buffer, 0, 0 );
5373 else
5374 result = write( unix_handle, (const char *)buffer + total, length - total );
5375
5376 if (result >= 0)
5377 {
5378 total += result;
5379 if (total == length)
5380 {
5381 status = STATUS_SUCCESS;
5382 goto done;
5383 }
5384 if (type == FD_TYPE_FILE) continue; /* no async I/O on regular files */
5385 }
5386 else if (errno != EAGAIN)
5387 {
5388 if (errno == EINTR) continue;
5389 if (!total)
5390 {
5391 if (errno == EFAULT) status = STATUS_INVALID_USER_BUFFER;
5392 else status = errno_to_status( errno );
5393 }
5394 goto err;
5395 }
5396
5397 if (async_write)
5398 {
5399 struct async_fileio_write *fileio;
5400
5401 fileio = (struct async_fileio_write *)alloc_fileio( sizeof(*fileio), async_write_proc, handle );
5402 if (!fileio)
5403 {
5404 status = STATUS_NO_MEMORY;
5405 goto err;
5406 }
5407 fileio->already = total;
5408 fileio->count = length;
5409 fileio->buffer = buffer;
5410
5411 SERVER_START_REQ( register_async )
5412 {
5413 req->type = ASYNC_TYPE_WRITE;
5414 req->count = length;
5415 req->async = server_async( handle, &fileio->io, event, apc, apc_user, io );
5416 status = wine_server_call( req );
5417 }
5418 SERVER_END_REQ;
5419
5420 if (status != STATUS_PENDING) free( fileio );
5421 goto err;
5422 }
5423 else /* synchronous write, wait for the fd to become ready */
5424 {
5425 struct pollfd pfd;
5426 int ret, timeout;
5427
5428 if (!timeout_init_done)
5429 {
5430 timeout_init_done = TRUE;
5431 if ((status = get_io_timeouts( handle, type, length, FALSE, &timeouts )))
5432 goto err;
5433 if (event) NtResetEvent( event, NULL );
5434 }
5435 timeout = get_next_io_timeout( &timeouts, total );
5436
5437 pfd.fd = unix_handle;
5438 pfd.events = POLLOUT;
5439
5440 if (!timeout || !(ret = poll( &pfd, 1, timeout )))
5441 {
5442 /* return with what we got so far */
5443 status = total ? STATUS_SUCCESS : STATUS_TIMEOUT;
5444 goto done;
5445 }
5446 if (ret == -1 && errno != EINTR)
5447 {
5448 status = errno_to_status( errno );
5449 goto done;
5450 }
5451 /* will now restart the write */
5452 }
5453 }
5454
5455 done:
5456 send_completion = cvalue != 0;
5457
5458 err:
5459 if (needs_close) close( unix_handle );
5460
5461 if (type == FD_TYPE_SERIAL && (status == STATUS_SUCCESS || status == STATUS_PENDING))
5462 set_pending_write( handle );
5463
5464 if (status == STATUS_SUCCESS)
5465 {
5466 io->u.Status = status;
5467 io->Information = total;
5468 TRACE("= SUCCESS (%u)\n", total);
5469 if (event) NtSetEvent( event, NULL );
5470 if (apc) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)apc,
5471 (ULONG_PTR)apc_user, (ULONG_PTR)io, 0 );
5472 }
5473 else
5474 {
5475 TRACE("= 0x%08x\n", status);
5476 if (status != STATUS_PENDING && event) NtResetEvent( event, NULL );
5477 }
5478
5479 ret_status = async_write && type == FD_TYPE_FILE && status == STATUS_SUCCESS ? STATUS_PENDING : status;
5480 if (send_completion) add_completion( handle, cvalue, status, total, ret_status == STATUS_PENDING );
5481 return ret_status;
5482 }
5483
5484
5485 /******************************************************************************
5486 * NtWriteFileGather (NTDLL.@)
5487 */
5488 NTSTATUS WINAPI NtWriteFileGather( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
5489 IO_STATUS_BLOCK *io, FILE_SEGMENT_ELEMENT *segments,
5490 ULONG length, LARGE_INTEGER *offset, ULONG *key )
5491 {
5492 int result, unix_handle, needs_close;
5493 unsigned int options;
5494 NTSTATUS status;
5495 ULONG pos = 0, total = 0;
5496 enum server_fd_type type;
5497 ULONG_PTR cvalue = apc ? 0 : (ULONG_PTR)apc_user;
5498 BOOL send_completion = FALSE;
5499
5500 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
5501 file, event, apc, apc_user, io, segments, length, offset, key );
5502
5503 if (length % page_size) return STATUS_INVALID_PARAMETER;
5504 if (!io) return STATUS_ACCESS_VIOLATION;
5505
5506 status = server_get_unix_fd( file, FILE_WRITE_DATA, &unix_handle, &needs_close, &type, &options );
5507 if (status) return status;
5508
5509 if ((type != FD_TYPE_FILE) ||
5510 (options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)) ||
5511 !(options & FILE_NO_INTERMEDIATE_BUFFERING))
5512 {
5513 status = STATUS_INVALID_PARAMETER;
5514 goto done;
5515 }
5516
5517 while (length)
5518 {
5519 if (offset && offset->QuadPart != FILE_USE_FILE_POINTER_POSITION)
5520 result = pwrite( unix_handle, (char *)segments->Buffer + pos,
5521 page_size - pos, offset->QuadPart + total );
5522 else
5523 result = write( unix_handle, (char *)segments->Buffer + pos, page_size - pos );
5524
5525 if (result == -1)
5526 {
5527 if (errno == EINTR) continue;
5528 if (errno == EFAULT)
5529 {
5530 status = STATUS_INVALID_USER_BUFFER;
5531 goto done;
5532 }
5533 status = errno_to_status( errno );
5534 break;
5535 }
5536 if (!result)
5537 {
5538 status = STATUS_DISK_FULL;
5539 break;
5540 }
5541 total += result;
5542 length -= result;
5543 if ((pos += result) == page_size)
5544 {
5545 pos = 0;
5546 segments++;
5547 }
5548 }
5549
5550 send_completion = cvalue != 0;
5551
5552 done:
5553 if (needs_close) close( unix_handle );
5554 if (status == STATUS_SUCCESS)
5555 {
5556 io->u.Status = status;
5557 io->Information = total;
5558 TRACE("= SUCCESS (%u)\n", total);
5559 if (event) NtSetEvent( event, NULL );
5560 if (apc) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC)apc,
5561 (ULONG_PTR)apc_user, (ULONG_PTR)io, 0 );
5562 }
5563 else
5564 {
5565 TRACE("= 0x%08x\n", status);
5566 if (status != STATUS_PENDING && event) NtResetEvent( event, NULL );
5567 }
5568 if (send_completion) add_completion( file, cvalue, status, total, FALSE );
5569 return status;
5570 }
5571
5572
5573 /******************************************************************************
5574 * NtDeviceIoControlFile (NTDLL.@)
5575 */
5576 NTSTATUS WINAPI NtDeviceIoControlFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
5577 IO_STATUS_BLOCK *io, ULONG code, void *in_buffer, ULONG in_size,
5578 void *out_buffer, ULONG out_size )
5579 {
5580 ULONG device = (code >> 16);
5581 NTSTATUS status = STATUS_NOT_SUPPORTED;
5582
5583 TRACE( "(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
5584 handle, event, apc, apc_context, io, code, in_buffer, in_size, out_buffer, out_size );
5585
5586 switch (device)
5587 {
5588 case FILE_DEVICE_DISK:
5589 case FILE_DEVICE_CD_ROM:
5590 case FILE_DEVICE_DVD:
5591 case FILE_DEVICE_CONTROLLER:
5592 case FILE_DEVICE_MASS_STORAGE:
5593 status = cdrom_DeviceIoControl( handle, event, apc, apc_context, io, code,
5594 in_buffer, in_size, out_buffer, out_size );
5595 break;
5596 case FILE_DEVICE_SERIAL_PORT:
5597 status = serial_DeviceIoControl( handle, event, apc, apc_context, io, code,
5598 in_buffer, in_size, out_buffer, out_size );
5599 break;
5600 case FILE_DEVICE_TAPE:
5601 status = tape_DeviceIoControl( handle, event, apc, apc_context, io, code,
5602 in_buffer, in_size, out_buffer, out_size );
5603 break;
5604 }
5605
5606 if (status == STATUS_NOT_SUPPORTED || status == STATUS_BAD_DEVICE_TYPE)
5607 return server_ioctl_file( handle, event, apc, apc_context, io, code,
5608 in_buffer, in_size, out_buffer, out_size );
5609
5610 if (status != STATUS_PENDING) io->u.Status = status;
5611 return status;
5612 }
5613
5614
5615 /* Tell Valgrind to ignore any holes in structs we will be passing to the
5616 * server */
5617 static void ignore_server_ioctl_struct_holes( ULONG code, const void *in_buffer, ULONG in_size )
5618 {
5619 #ifdef VALGRIND_MAKE_MEM_DEFINED
5620 # define IGNORE_STRUCT_HOLE(buf, size, t, f1, f2) \
5621 do { \
5622 if (FIELD_OFFSET(t, f1) + sizeof(((t *)0)->f1) < FIELD_OFFSET(t, f2)) \
5623 if ((size) >= FIELD_OFFSET(t, f2)) \
5624 VALGRIND_MAKE_MEM_DEFINED( \
5625 (const char *)(buf) + FIELD_OFFSET(t, f1) + sizeof(((t *)0)->f1), \
5626 FIELD_OFFSET(t, f2) - FIELD_OFFSET(t, f1) + sizeof(((t *)0)->f1)); \
5627 } while (0)
5628
5629 switch (code)
5630 {
5631 case FSCTL_PIPE_WAIT:
5632 IGNORE_STRUCT_HOLE(in_buffer, in_size, FILE_PIPE_WAIT_FOR_BUFFER, TimeoutSpecified, Name);
5633 break;
5634 }
5635 #endif
5636 }
5637
5638
5639 /******************************************************************************
5640 * NtFsControlFile (NTDLL.@)
5641 */
5642 NTSTATUS WINAPI NtFsControlFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
5643 IO_STATUS_BLOCK *io, ULONG code, void *in_buffer, ULONG in_size,
5644 void *out_buffer, ULONG out_size )
5645 {
5646 NTSTATUS status;
5647
5648 TRACE( "(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
5649 handle, event, apc, apc_context, io, code, in_buffer, in_size, out_buffer, out_size );
5650
5651 if (!io) return STATUS_INVALID_PARAMETER;
5652
5653 ignore_server_ioctl_struct_holes( code, in_buffer, in_size );
5654
5655 switch (code)
5656 {
5657 case FSCTL_DISMOUNT_VOLUME:
5658 status = server_ioctl_file( handle, event, apc, apc_context, io, code,
5659 in_buffer, in_size, out_buffer, out_size );
5660 if (!status) status = unmount_device( handle );
5661 return status;
5662
5663 case FSCTL_PIPE_IMPERSONATE:
5664 FIXME("FSCTL_PIPE_IMPERSONATE: impersonating self\n");
5665 return server_ioctl_file( handle, event, apc, apc_context, io, code,
5666 in_buffer, in_size, out_buffer, out_size );
5667
5668 case FSCTL_IS_VOLUME_MOUNTED:
5669 case FSCTL_LOCK_VOLUME:
5670 case FSCTL_UNLOCK_VOLUME:
5671 FIXME("stub! return success - Unsupported fsctl %x (device=%x access=%x func=%x method=%x)\n",
5672 code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
5673 status = STATUS_SUCCESS;
5674 break;
5675
5676 case FSCTL_GET_RETRIEVAL_POINTERS:
5677 {
5678 RETRIEVAL_POINTERS_BUFFER *buffer = (RETRIEVAL_POINTERS_BUFFER *)out_buffer;
5679
5680 FIXME("stub: FSCTL_GET_RETRIEVAL_POINTERS\n");
5681
5682 if (out_size >= sizeof(RETRIEVAL_POINTERS_BUFFER))
5683 {
5684 buffer->ExtentCount = 1;
5685 buffer->StartingVcn.QuadPart = 1;
5686 buffer->Extents[0].NextVcn.QuadPart = 0;
5687 buffer->Extents[0].Lcn.QuadPart = 0;
5688 io->Information = sizeof(RETRIEVAL_POINTERS_BUFFER);
5689 status = STATUS_SUCCESS;
5690 }
5691 else
5692 {
5693 io->Information = 0;
5694 status = STATUS_BUFFER_TOO_SMALL;
5695 }
5696 break;
5697 }
5698
5699 case FSCTL_GET_OBJECT_ID:
5700 {
5701 FILE_OBJECTID_BUFFER *info = out_buffer;
5702 int fd, needs_close;
5703 struct stat st;
5704
5705 io->Information = 0;
5706 if (out_size >= sizeof(*info))
5707 {
5708 status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, NULL );
5709 if (status) break;
5710 fstat( fd, &st );
5711 if (needs_close) close( fd );
5712 memset( info, 0, sizeof(*info) );
5713 memcpy( info->ObjectId, &st.st_dev, sizeof(st.st_dev) );
5714 memcpy( info->ObjectId + 8, &st.st_ino, sizeof(st.st_ino) );
5715 io->Information = sizeof(*info);
5716 }
5717 else status = STATUS_BUFFER_TOO_SMALL;
5718 break;
5719 }
5720
5721 case FSCTL_SET_SPARSE:
5722 TRACE("FSCTL_SET_SPARSE: Ignoring request\n");
5723 io->Information = 0;
5724 status = STATUS_SUCCESS;
5725 break;
5726 default:
5727 return server_ioctl_file( handle, event, apc, apc_context, io, code,
5728 in_buffer, in_size, out_buffer, out_size );
5729 }
5730
5731 if (status != STATUS_PENDING) io->u.Status = status;
5732 return status;
5733 }
5734
5735
5736 /******************************************************************************
5737 * NtFlushBuffersFile (NTDLL.@)
5738 */
5739 NTSTATUS WINAPI NtFlushBuffersFile( HANDLE handle, IO_STATUS_BLOCK *io )
5740 {
5741 NTSTATUS ret;
5742 HANDLE wait_handle;
5743 enum server_fd_type type;
5744 int fd, needs_close;
5745
5746 if (!io || !virtual_check_buffer_for_write( io, sizeof(*io) )) return STATUS_ACCESS_VIOLATION;
5747
5748 ret = server_get_unix_fd( handle, FILE_WRITE_DATA, &fd, &needs_close, &type, NULL );
5749 if (ret == STATUS_ACCESS_DENIED)
5750 ret = server_get_unix_fd( handle, FILE_APPEND_DATA, &fd, &needs_close, &type, NULL );
5751
5752 if (!ret && (type == FD_TYPE_FILE || type == FD_TYPE_DIR || type == FD_TYPE_CHAR))
5753 {
5754 if (fsync(fd)) ret = errno_to_status( errno );
5755 io->u.Status = ret;
5756 io->Information = 0;
5757 }
5758 else if (!ret && type == FD_TYPE_SERIAL)
5759 {
5760 ret = serial_FlushBuffersFile( fd );
5761 }
5762 else if (ret != STATUS_ACCESS_DENIED)
5763 {
5764 struct async_irp *async;
5765
5766 if (!(async = (struct async_irp *)alloc_fileio( sizeof(*async), irp_completion, handle )))
5767 return STATUS_NO_MEMORY;
5768 async->buffer = NULL;
5769 async->size = 0;
5770
5771 SERVER_START_REQ( flush )
5772 {
5773 req->async = server_async( handle, &async->io, NULL, NULL, NULL, io );
5774 ret = wine_server_call( req );
5775 wait_handle = wine_server_ptr_handle( reply->event );
5776 if (wait_handle && ret != STATUS_PENDING)
5777 {
5778 io->u.Status = ret;
5779 io->Information = 0;
5780 }
5781 }
5782 SERVER_END_REQ;
5783
5784 if (ret != STATUS_PENDING) free( async );
5785
5786 if (wait_handle) ret = wait_async( wait_handle, FALSE, io );
5787 }
5788
5789 if (needs_close) close( fd );
5790 return ret;
5791 }
5792
5793
5794 /**************************************************************************
5795 * NtCancelIoFile (NTDLL.@)
5796 */
5797 NTSTATUS WINAPI NtCancelIoFile( HANDLE handle, IO_STATUS_BLOCK *io_status )
5798 {
5799 TRACE( "%p %p\n", handle, io_status );
5800
5801 SERVER_START_REQ( cancel_async )
5802 {
5803 req->handle = wine_server_obj_handle( handle );
5804 req->only_thread = TRUE;
5805 io_status->u.Status = wine_server_call( req );
5806 }
5807 SERVER_END_REQ;
5808 return io_status->u.Status;
5809 }
5810
5811
5812 /**************************************************************************
5813 * NtCancelIoFileEx (NTDLL.@)
5814 */
5815 NTSTATUS WINAPI NtCancelIoFileEx( HANDLE handle, IO_STATUS_BLOCK *io, IO_STATUS_BLOCK *io_status )
5816 {
5817 TRACE( "%p %p %p\n", handle, io, io_status );
5818
5819 SERVER_START_REQ( cancel_async )
5820 {
5821 req->handle = wine_server_obj_handle( handle );
5822 req->iosb = wine_server_client_ptr( io );
5823 io_status->u.Status = wine_server_call( req );
5824 }
5825 SERVER_END_REQ;
5826 return io_status->u.Status;
5827 }
5828
5829
5830 /******************************************************************
5831 * NtLockFile (NTDLL.@)
5832 */
5833 NTSTATUS WINAPI NtLockFile( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void* apc_user,
5834 IO_STATUS_BLOCK *io_status, LARGE_INTEGER *offset,
5835 LARGE_INTEGER *count, ULONG *key, BOOLEAN dont_wait, BOOLEAN exclusive )
5836 {
5837 static int warn;
5838 NTSTATUS ret;
5839 HANDLE handle;
5840 BOOLEAN async;
5841
5842 if (apc || io_status || key)
5843 {
5844 FIXME("Unimplemented yet parameter\n");
5845 return STATUS_NOT_IMPLEMENTED;
5846 }
5847 if (apc_user && !warn++) FIXME("I/O completion on lock not implemented yet\n");
5848
5849 for (;;)
5850 {
5851 SERVER_START_REQ( lock_file )
5852 {
5853 req->handle = wine_server_obj_handle( file );
5854 req->offset = offset->QuadPart;
5855 req->count = count->QuadPart;
5856 req->shared = !exclusive;
5857 req->wait = !dont_wait;
5858 ret = wine_server_call( req );
5859 handle = wine_server_ptr_handle( reply->handle );
5860 async = reply->overlapped;
5861 }
5862 SERVER_END_REQ;
5863 if (ret != STATUS_PENDING)
5864 {
5865 if (!ret && event) NtSetEvent( event, NULL );
5866 return ret;
5867 }
5868 if (async)
5869 {
5870 FIXME( "Async I/O lock wait not implemented, might deadlock\n" );
5871 if (handle) NtClose( handle );
5872 return STATUS_PENDING;
5873 }
5874 if (handle)
5875 {
5876 NtWaitForSingleObject( handle, FALSE, NULL );
5877 NtClose( handle );
5878 }
5879 else /* Unix lock conflict, sleep a bit and retry */
5880 {
5881 LARGE_INTEGER time;
5882 time.QuadPart = -100 * (ULONGLONG)10000;
5883 NtDelayExecution( FALSE, &time );
5884 }
5885 }
5886 }
5887
5888
5889 /******************************************************************
5890 * NtUnlockFile (NTDLL.@)
5891 */
5892 NTSTATUS WINAPI NtUnlockFile( HANDLE handle, IO_STATUS_BLOCK *io_status, LARGE_INTEGER *offset,
5893 LARGE_INTEGER *count, ULONG *key )
5894 {
5895 NTSTATUS status;
5896
5897 TRACE( "%p %x%08x %x%08x\n",
5898 handle, offset->u.HighPart, offset->u.LowPart, count->u.HighPart, count->u.LowPart );
5899
5900 if (io_status || key)
5901 {
5902 FIXME("Unimplemented yet parameter\n");
5903 return STATUS_NOT_IMPLEMENTED;
5904 }
5905
5906 SERVER_START_REQ( unlock_file )
5907 {
5908 req->handle = wine_server_obj_handle( handle );
5909 req->offset = offset->QuadPart;
5910 req->count = count->QuadPart;
5911 status = wine_server_call( req );
5912 }
5913 SERVER_END_REQ;
5914 return status;
5915 }
5916
5917
5918 static NTSTATUS read_changes_apc( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS status )
5919 {
5920 struct async_fileio_read_changes *fileio = user;
5921 int size = 0;
5922
5923 if (status == STATUS_ALERTED)
5924 {
5925 SERVER_START_REQ( read_change )
5926 {
5927 req->handle = wine_server_obj_handle( fileio->io.handle );
5928 wine_server_set_reply( req, fileio->data, fileio->data_size );
5929 status = wine_server_call( req );
5930 size = wine_server_reply_size( reply );
5931 }
5932 SERVER_END_REQ;
5933
5934 if (status == STATUS_SUCCESS && fileio->buffer)
5935 {
5936 FILE_NOTIFY_INFORMATION *pfni = fileio->buffer;
5937 int i, left = fileio->buffer_size;
5938 DWORD *last_entry_offset = NULL;
5939 struct filesystem_event *event = (struct filesystem_event*)fileio->data;
5940
5941 while (size && left >= sizeof(*pfni))
5942 {
5943 DWORD len = (left - offsetof(FILE_NOTIFY_INFORMATION, FileName)) / sizeof(WCHAR);
5944
5945 /* convert to an NT style path */
5946 for (i = 0; i < event->len; i++)
5947 if (event->name[i] == '/') event->name[i] = '\\';
5948
5949 pfni->Action = event->action;
5950 pfni->FileNameLength = ntdll_umbstowcs( event->name, event->len, pfni->FileName, len );
5951 last_entry_offset = &pfni->NextEntryOffset;
5952
5953 if (pfni->FileNameLength == len) break;
5954
5955 i = offsetof(FILE_NOTIFY_INFORMATION, FileName[pfni->FileNameLength]);
5956 pfni->FileNameLength *= sizeof(WCHAR);
5957 pfni->NextEntryOffset = i;
5958 pfni = (FILE_NOTIFY_INFORMATION*)((char*)pfni + i);
5959 left -= i;
5960
5961 i = (offsetof(struct filesystem_event, name[event->len])
5962 + sizeof(int)-1) / sizeof(int) * sizeof(int);
5963 event = (struct filesystem_event*)((char*)event + i);
5964 size -= i;
5965 }
5966
5967 if (size)
5968 {
5969 status = STATUS_NOTIFY_ENUM_DIR;
5970 size = 0;
5971 }
5972 else
5973 {
5974 if (last_entry_offset) *last_entry_offset = 0;
5975 size = fileio->buffer_size - left;
5976 }
5977 }
5978 else
5979 {
5980 status = STATUS_NOTIFY_ENUM_DIR;
5981 size = 0;
5982 }
5983 }
5984
5985 if (status != STATUS_PENDING)
5986 {
5987 iosb->u.Status = status;
5988 iosb->Information = size;
5989 release_fileio( &fileio->io );
5990 }
5991 return status;
5992 }
5993
5994 #define FILE_NOTIFY_ALL ( \
5995 FILE_NOTIFY_CHANGE_FILE_NAME | \
5996 FILE_NOTIFY_CHANGE_DIR_NAME | \
5997 FILE_NOTIFY_CHANGE_ATTRIBUTES | \
5998 FILE_NOTIFY_CHANGE_SIZE | \
5999 FILE_NOTIFY_CHANGE_LAST_WRITE | \
6000 FILE_NOTIFY_CHANGE_LAST_ACCESS | \
6001 FILE_NOTIFY_CHANGE_CREATION | \
6002 FILE_NOTIFY_CHANGE_SECURITY )
6003
6004 /******************************************************************************
6005 * NtNotifyChangeDirectoryFile (NTDLL.@)
6006 */
6007 NTSTATUS WINAPI NtNotifyChangeDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
6008 void *apc_context, IO_STATUS_BLOCK *iosb, void *buffer,
6009 ULONG buffer_size, ULONG filter, BOOLEAN subtree )
6010 {
6011 struct async_fileio_read_changes *fileio;
6012 NTSTATUS status;
6013 ULONG size = max( 4096, buffer_size );
6014
6015 TRACE( "%p %p %p %p %p %p %u %u %d\n",
6016 handle, event, apc, apc_context, iosb, buffer, buffer_size, filter, subtree );
6017
6018 if (!iosb) return STATUS_ACCESS_VIOLATION;
6019 if (filter == 0 || (filter & ~FILE_NOTIFY_ALL)) return STATUS_INVALID_PARAMETER;
6020
6021 fileio = (struct async_fileio_read_changes *)alloc_fileio(
6022 offsetof(struct async_fileio_read_changes, data[size]), read_changes_apc, handle );
6023 if (!fileio) return STATUS_NO_MEMORY;
6024
6025 fileio->buffer = buffer;
6026 fileio->buffer_size = buffer_size;
6027 fileio->data_size = size;
6028
6029 SERVER_START_REQ( read_directory_changes )
6030 {
6031 req->filter = filter;
6032 req->want_data = (buffer != NULL);
6033 req->subtree = subtree;
6034 req->async = server_async( handle, &fileio->io, event, apc, apc_context, iosb );
6035 status = wine_server_call( req );
6036 }
6037 SERVER_END_REQ;
6038
6039 if (status != STATUS_PENDING) free( fileio );
6040 return status;
6041 }
6042
6043
6044 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__APPLE__)
6045 /* helper for FILE_GetDeviceInfo to hide some platform differences in fstatfs */
6046 static inline void get_device_info_fstatfs( FILE_FS_DEVICE_INFORMATION *info, const char *fstypename,
6047 unsigned int flags )
6048 {
6049 if (!strcmp("cd9660", fstypename) || !strcmp("udf", fstypename))
6050 {
6051 info->DeviceType = FILE_DEVICE_CD_ROM_FILE_SYSTEM;
6052 /* Don't assume read-only, let the mount options set it below */
6053 info->Characteristics |= FILE_REMOVABLE_MEDIA;
6054 }
6055 else if (!strcmp("nfs", fstypename) || !strcmp("nwfs", fstypename) ||
6056 !strcmp("smbfs", fstypename) || !strcmp("afpfs", fstypename))
6057 {
6058 info->DeviceType = FILE_DEVICE_NETWORK_FILE_SYSTEM;
6059 info->Characteristics |= FILE_REMOTE_DEVICE;
6060 }
6061 else if (!strcmp("procfs", fstypename))
6062 info->DeviceType = FILE_DEVICE_VIRTUAL_DISK;
6063 else
6064 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6065
6066 if (flags & MNT_RDONLY)
6067 info->Characteristics |= FILE_READ_ONLY_DEVICE;
6068
6069 if (!(flags & MNT_LOCAL))
6070 {
6071 info->DeviceType = FILE_DEVICE_NETWORK_FILE_SYSTEM;
6072 info->Characteristics |= FILE_REMOTE_DEVICE;
6073 }
6074 }
6075 #endif
6076
6077 static inline BOOL is_device_placeholder( int fd )
6078 {
6079 static const char wine_placeholder[] = "Wine device placeholder";
6080 char buffer[sizeof(wine_placeholder)-1];
6081
6082 if (pread( fd, buffer, sizeof(wine_placeholder) - 1, 0 ) != sizeof(wine_placeholder) - 1)
6083 return FALSE;
6084 return !memcmp( buffer, wine_placeholder, sizeof(wine_placeholder) - 1 );
6085 }
6086
6087 static NTSTATUS get_device_info( int fd, FILE_FS_DEVICE_INFORMATION *info )
6088 {
6089 struct stat st;
6090
6091 info->Characteristics = 0;
6092 if (fstat( fd, &st ) < 0) return errno_to_status( errno );
6093 if (S_ISCHR( st.st_mode ))
6094 {
6095 info->DeviceType = FILE_DEVICE_UNKNOWN;
6096 #ifdef linux
6097 switch(major(st.st_rdev))
6098 {
6099 case MEM_MAJOR:
6100 info->DeviceType = FILE_DEVICE_NULL;
6101 break;
6102 case TTY_MAJOR:
6103 info->DeviceType = FILE_DEVICE_SERIAL_PORT;
6104 break;
6105 case LP_MAJOR:
6106 info->DeviceType = FILE_DEVICE_PARALLEL_PORT;
6107 break;
6108 case SCSI_TAPE_MAJOR:
6109 info->DeviceType = FILE_DEVICE_TAPE;
6110 break;
6111 }
6112 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__APPLE__)
6113 {
6114 int d_type;
6115 if (ioctl(fd, FIODTYPE, &d_type) == 0)
6116 {
6117 switch(d_type)
6118 {
6119 case D_TAPE:
6120 info->DeviceType = FILE_DEVICE_TAPE;
6121 break;
6122 case D_DISK:
6123 info->DeviceType = FILE_DEVICE_DISK;
6124 break;
6125 case D_TTY:
6126 info->DeviceType = FILE_DEVICE_SERIAL_PORT;
6127 break;
6128 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
6129 case D_MEM:
6130 info->DeviceType = FILE_DEVICE_NULL;
6131 break;
6132 #endif
6133 }
6134 /* no special d_type for parallel ports */
6135 }
6136 }
6137 #endif
6138 }
6139 else if (S_ISBLK( st.st_mode ))
6140 {
6141 info->DeviceType = FILE_DEVICE_DISK;
6142 }
6143 else if (S_ISFIFO( st.st_mode ) || S_ISSOCK( st.st_mode ))
6144 {
6145 info->DeviceType = FILE_DEVICE_NAMED_PIPE;
6146 }
6147 else if (is_device_placeholder( fd ))
6148 {
6149 info->DeviceType = FILE_DEVICE_DISK;
6150 }
6151 else /* regular file or directory */
6152 {
6153 #if defined(linux) && defined(HAVE_FSTATFS)
6154 struct statfs stfs;
6155
6156 /* check for floppy disk */
6157 if (major(st.st_dev) == FLOPPY_MAJOR)
6158 info->Characteristics |= FILE_REMOVABLE_MEDIA;
6159
6160 if (fstatfs( fd, &stfs ) < 0) stfs.f_type = 0;
6161 switch (stfs.f_type)
6162 {
6163 case 0x9660: /* iso9660 */
6164 case 0x9fa1: /* supermount */
6165 case 0x15013346: /* udf */
6166 info->DeviceType = FILE_DEVICE_CD_ROM_FILE_SYSTEM;
6167 info->Characteristics |= FILE_REMOVABLE_MEDIA|FILE_READ_ONLY_DEVICE;
6168 break;
6169 case 0x6969: /* nfs */
6170 case 0xff534d42: /* cifs */
6171 case 0xfe534d42: /* smb2 */
6172 case 0x517b: /* smbfs */
6173 case 0x564c: /* ncpfs */
6174 info->DeviceType = FILE_DEVICE_NETWORK_FILE_SYSTEM;
6175 info->Characteristics |= FILE_REMOTE_DEVICE;
6176 break;
6177 case 0x1373: /* devfs */
6178 case 0x9fa0: /* procfs */
6179 info->DeviceType = FILE_DEVICE_VIRTUAL_DISK;
6180 break;
6181 case 0x01021994: /* tmpfs */
6182 case 0x28cd3d45: /* cramfs */
6183 /* Don't map these to FILE_DEVICE_VIRTUAL_DISK by default. Virtual
6184 * filesystems are rare on Windows, and some programs refuse to
6185 * recognize them as valid. */
6186 default:
6187 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6188 break;
6189 }
6190 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__APPLE__)
6191 struct statfs stfs;
6192
6193 if (fstatfs( fd, &stfs ) < 0)
6194 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6195 else
6196 get_device_info_fstatfs( info, stfs.f_fstypename, stfs.f_flags );
6197 #elif defined(__NetBSD__)
6198 struct statvfs stfs;
6199
6200 if (fstatvfs( fd, &stfs) < 0)
6201 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6202 else
6203 get_device_info_fstatfs( info, stfs.f_fstypename, stfs.f_flag );
6204 #elif defined(sun)
6205 /* Use dkio to work out device types */
6206 {
6207 # include <sys/dkio.h>
6208 # include <sys/vtoc.h>
6209 struct dk_cinfo dkinf;
6210 int retval = ioctl(fd, DKIOCINFO, &dkinf);
6211 if(retval==-1){
6212 WARN("Unable to get disk device type information - assuming a disk like device\n");
6213 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6214 }
6215 switch (dkinf.dki_ctype)
6216 {
6217 case DKC_CDROM:
6218 info->DeviceType = FILE_DEVICE_CD_ROM_FILE_SYSTEM;
6219 info->Characteristics |= FILE_REMOVABLE_MEDIA|FILE_READ_ONLY_DEVICE;
6220 break;
6221 case DKC_NCRFLOPPY:
6222 case DKC_SMSFLOPPY:
6223 case DKC_INTEL82072:
6224 case DKC_INTEL82077:
6225 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6226 info->Characteristics |= FILE_REMOVABLE_MEDIA;
6227 break;
6228 case DKC_MD:
6229 /* Don't map these to FILE_DEVICE_VIRTUAL_DISK by default. Virtual
6230 * filesystems are rare on Windows, and some programs refuse to
6231 * recognize them as valid. */
6232 default:
6233 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6234 }
6235 }
6236 #else
6237 static int warned;
6238 if (!warned++) FIXME( "device info not properly supported on this platform\n" );
6239 info->DeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;
6240 #endif
6241 info->Characteristics |= FILE_DEVICE_IS_MOUNTED;
6242 }
6243 return STATUS_SUCCESS;
6244 }
6245
6246
6247 /******************************************************************************
6248 * NtQueryVolumeInformationFile (NTDLL.@)
6249 */
6250 NTSTATUS WINAPI NtQueryVolumeInformationFile( HANDLE handle, IO_STATUS_BLOCK *io,
6251 void *buffer, ULONG length,
6252 FS_INFORMATION_CLASS info_class )
6253 {
6254 int fd, needs_close;
6255 struct stat st;
6256
6257 io->u.Status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, NULL );
6258 if (io->u.Status == STATUS_BAD_DEVICE_TYPE)
6259 {
6260 struct async_irp *async;
6261 HANDLE wait_handle;
6262 NTSTATUS status;
6263
6264 if (!(async = (struct async_irp *)alloc_fileio( sizeof(*async), irp_completion, handle )))
6265 return STATUS_NO_MEMORY;
6266 async->buffer = buffer;
6267 async->size = length;
6268
6269 SERVER_START_REQ( get_volume_info )
6270 {
6271 req->async = server_async( handle, &async->io, NULL, NULL, NULL, io );
6272 req->handle = wine_server_obj_handle( handle );
6273 req->info_class = info_class;
6274 wine_server_set_reply( req, buffer, length );
6275 status = wine_server_call( req );
6276 if (status != STATUS_PENDING)
6277 {
6278 io->u.Status = status;
6279 io->Information = wine_server_reply_size( reply );
6280 }
6281 wait_handle = wine_server_ptr_handle( reply->wait );
6282 }
6283 SERVER_END_REQ;
6284 if (status != STATUS_PENDING) free( async );
6285 if (wait_handle) status = wait_async( wait_handle, FALSE, io );
6286 return status;
6287 }
6288 else if (io->u.Status) return io->u.Status;
6289
6290 io->u.Status = STATUS_NOT_IMPLEMENTED;
6291 io->Information = 0;
6292
6293 switch( info_class )
6294 {
6295 case FileFsLabelInformation:
6296 FIXME( "%p: label info not supported\n", handle );
6297 break;
6298
6299 case FileFsSizeInformation:
6300 if (length < sizeof(FILE_FS_SIZE_INFORMATION))
6301 io->u.Status = STATUS_BUFFER_TOO_SMALL;
6302 else
6303 {
6304 FILE_FS_SIZE_INFORMATION *info = buffer;
6305
6306 if (fstat( fd, &st ) < 0)
6307 {
6308 io->u.Status = errno_to_status( errno );
6309 break;
6310 }
6311 if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
6312 {
6313 io->u.Status = STATUS_INVALID_DEVICE_REQUEST;
6314 }
6315 else
6316 {
6317 ULONGLONG bsize;
6318 /* Linux's fstatvfs is buggy */
6319 #if !defined(linux) || !defined(HAVE_FSTATFS)
6320 struct statvfs stfs;
6321
6322 if (fstatvfs( fd, &stfs ) < 0)
6323 {
6324 io->u.Status = errno_to_status( errno );
6325 break;
6326 }
6327 bsize = stfs.f_frsize;
6328 #else
6329 struct statfs stfs;
6330 if (fstatfs( fd, &stfs ) < 0)
6331 {
6332 io->u.Status = errno_to_status( errno );
6333 break;
6334 }
6335 bsize = stfs.f_bsize;
6336 #endif
6337 if (bsize == 2048) /* assume CD-ROM */
6338 {
6339 info->BytesPerSector = 2048;
6340 info->SectorsPerAllocationUnit = 1;
6341 }
6342 else
6343 {
6344 info->BytesPerSector = 512;
6345 info->SectorsPerAllocationUnit = 8;
6346 }
6347 info->TotalAllocationUnits.QuadPart = bsize * stfs.f_blocks / (info->BytesPerSector * info->SectorsPerAllocationUnit);
6348 info->AvailableAllocationUnits.QuadPart = bsize * stfs.f_bavail / (info->BytesPerSector * info->SectorsPerAllocationUnit);
6349 io->Information = sizeof(*info);
6350 io->u.Status = STATUS_SUCCESS;
6351 }
6352 }
6353 break;
6354
6355 case FileFsDeviceInformation:
6356 if (length < sizeof(FILE_FS_DEVICE_INFORMATION))
6357 io->u.Status = STATUS_BUFFER_TOO_SMALL;
6358 else
6359 {
6360 FILE_FS_DEVICE_INFORMATION *info = buffer;
6361
6362 if ((io->u.Status = get_device_info( fd, info )) == STATUS_SUCCESS)
6363 io->Information = sizeof(*info);
6364 }
6365 break;
6366
6367 case FileFsAttributeInformation:
6368 {
6369 static const WCHAR fatW[] = {'F','A','T'};
6370 static const WCHAR fat32W[] = {'F','A','T','3','2'};
6371 static const WCHAR ntfsW[] = {'N','T','F','S'};
6372 static const WCHAR cdfsW[] = {'C','D','F','S'};
6373 static const WCHAR udfW[] = {'U','D','F'};
6374
6375 FILE_FS_ATTRIBUTE_INFORMATION *info = buffer;
6376 struct mountmgr_unix_drive drive;
6377 enum mountmgr_fs_type fs_type = MOUNTMGR_FS_TYPE_NTFS;
6378
6379 if (length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION))
6380 {
6381 io->u.Status = STATUS_INFO_LENGTH_MISMATCH;
6382 break;
6383 }
6384
6385 if (!get_mountmgr_fs_info( handle, fd, &drive, sizeof(drive) )) fs_type = drive.fs_type;
6386 else
6387 {
6388 struct statfs stfs;
6389
6390 if (!fstatfs( fd, &stfs ))
6391 {
6392 #if defined(linux) && defined(HAVE_FSTATFS)
6393 switch (stfs.f_type)
6394 {
6395 case 0x9660:
6396 fs_type = MOUNTMGR_FS_TYPE_ISO9660;
6397 break;
6398 case 0x15013346:
6399 fs_type = MOUNTMGR_FS_TYPE_UDF;
6400 break;
6401 case 0x4d44:
6402 fs_type = MOUNTMGR_FS_TYPE_FAT32;
6403 break;
6404 }
6405 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__APPLE__)
6406 if (!strcmp( stfs.f_fstypename, "cd9660" ))
6407 fs_type = MOUNTMGR_FS_TYPE_ISO9660;
6408 else if (!strcmp( stfs.f_fstypename, "udf" ))
6409 fs_type = MOUNTMGR_FS_TYPE_UDF;
6410 else if (!strcmp( stfs.f_fstypename, "msdos" )) /* FreeBSD < 5, Apple */
6411 fs_type = MOUNTMGR_FS_TYPE_FAT32;
6412 else if (!strcmp( stfs.f_fstypename, "msdosfs" )) /* FreeBSD >= 5 */
6413 fs_type = MOUNTMGR_FS_TYPE_FAT32;
6414 #endif
6415 }
6416 }
6417
6418 switch (fs_type)
6419 {
6420 case MOUNTMGR_FS_TYPE_ISO9660:
6421 info->FileSystemAttributes = FILE_READ_ONLY_VOLUME;
6422 info->MaximumComponentNameLength = 221;
6423 info->FileSystemNameLength = min( sizeof(cdfsW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
6424 memcpy(info->FileSystemName, cdfsW, info->FileSystemNameLength);
6425 break;
6426 case MOUNTMGR_FS_TYPE_UDF:
6427 info->FileSystemAttributes = FILE_READ_ONLY_VOLUME | FILE_UNICODE_ON_DISK | FILE_CASE_SENSITIVE_SEARCH;
6428 info->MaximumComponentNameLength = 255;
6429 info->FileSystemNameLength = min( sizeof(udfW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
6430 memcpy(info->FileSystemName, udfW, info->FileSystemNameLength);
6431 break;
6432 case MOUNTMGR_FS_TYPE_FAT:
6433 info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; /* FIXME */
6434 info->MaximumComponentNameLength = 255;
6435 info->FileSystemNameLength = min( sizeof(fatW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
6436 memcpy(info->FileSystemName, fatW, info->FileSystemNameLength);
6437 break;
6438 case MOUNTMGR_FS_TYPE_FAT32:
6439 info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; /* FIXME */
6440 info->MaximumComponentNameLength = 255;
6441 info->FileSystemNameLength = min( sizeof(fat32W), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
6442 memcpy(info->FileSystemName, fat32W, info->FileSystemNameLength);
6443 break;
6444 default:
6445 info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES | FILE_PERSISTENT_ACLS;
6446 info->MaximumComponentNameLength = 255;
6447 info->FileSystemNameLength = min( sizeof(ntfsW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
6448 memcpy(info->FileSystemName, ntfsW, info->FileSystemNameLength);
6449 break;
6450 }
6451
6452 io->Information = offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) + info->FileSystemNameLength;
6453 io->u.Status = STATUS_SUCCESS;
6454 break;
6455 }
6456
6457 case FileFsVolumeInformation:
6458 {
6459 FILE_FS_VOLUME_INFORMATION *info = buffer;
6460 ULONGLONG data[64];
6461 struct mountmgr_unix_drive *drive = (struct mountmgr_unix_drive *)data;
6462 const WCHAR *label;
6463
6464 if (length < sizeof(FILE_FS_VOLUME_INFORMATION))
6465 {
6466 io->u.Status = STATUS_INFO_LENGTH_MISMATCH;
6467 break;
6468 }
6469
6470 if (get_mountmgr_fs_info( handle, fd, drive, sizeof(data) ))
6471 {
6472 io->u.Status = STATUS_NOT_IMPLEMENTED;
6473 break;
6474 }
6475
6476 label = (WCHAR *)((char *)drive + drive->label_offset);
6477 info->VolumeCreationTime.QuadPart = 0; /* FIXME */
6478 info->VolumeSerialNumber = drive->serial;
6479 info->VolumeLabelLength = min( wcslen( label ) * sizeof(WCHAR),
6480 length - offsetof( FILE_FS_VOLUME_INFORMATION, VolumeLabel ) );
6481 info->SupportsObjects = (drive->fs_type == MOUNTMGR_FS_TYPE_NTFS);
6482 memcpy( info->VolumeLabel, label, info->VolumeLabelLength );
6483 io->Information = offsetof( FILE_FS_VOLUME_INFORMATION, VolumeLabel ) + info->VolumeLabelLength;
6484 io->u.Status = STATUS_SUCCESS;
6485 break;
6486 }
6487
6488 case FileFsControlInformation:
6489 FIXME( "%p: control info not supported\n", handle );
6490 break;
6491
6492 case FileFsFullSizeInformation:
6493 FIXME( "%p: full size info not supported\n", handle );
6494 break;
6495
6496 case FileFsObjectIdInformation:
6497 FIXME( "%p: object id info not supported\n", handle );
6498 break;
6499
6500 case FileFsMaximumInformation:
6501 FIXME( "%p: maximum info not supported\n", handle );
6502 break;
6503
6504 default:
6505 io->u.Status = STATUS_INVALID_PARAMETER;
6506 break;
6507 }
6508 if (needs_close) close( fd );
6509 return io->u.Status;
6510 }
6511
6512
6513 /******************************************************************************
6514 * NtSetVolumeInformationFile (NTDLL.@)
6515 */
6516 NTSTATUS WINAPI NtSetVolumeInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, void *info,
6517 ULONG length, FS_INFORMATION_CLASS class )
6518 {
6519 FIXME( "(%p,%p,%p,0x%08x,0x%08x) stub\n", handle, io, info, length, class );
6520 return STATUS_SUCCESS;
6521 }
6522
6523
6524 /******************************************************************
6525 * NtQueryEaFile (NTDLL.@)
6526 */
6527 NTSTATUS WINAPI NtQueryEaFile( HANDLE handle, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
6528 BOOLEAN single_entry, void *list, ULONG list_len,
6529 ULONG *index, BOOLEAN restart )
6530 {
6531 FIXME( "(%p,%p,%p,%d,%d,%p,%d,%p,%d) stub\n",
6532 handle, io, buffer, length, single_entry, list, list_len, index, restart );
6533 return STATUS_ACCESS_DENIED;
6534 }
6535
6536
6537 /******************************************************************
6538 * NtSetEaFile (NTDLL.@)
6539 */
6540 NTSTATUS WINAPI NtSetEaFile( HANDLE handle, IO_STATUS_BLOCK *io, void *buffer, ULONG length )
6541 {
6542 FIXME( "(%p,%p,%p,%d) stub\n", handle, io, buffer, length );
6543 return STATUS_ACCESS_DENIED;
6544 }
6545
6546
6547 /* convert type information from server format; helper for NtQueryObject */
6548 static void *put_object_type_info( OBJECT_TYPE_INFORMATION *p, struct object_type_info *info )
6549 {
6550 const ULONG align = sizeof(DWORD_PTR) - 1;
6551
6552 memset( p, 0, sizeof(*p) );
6553 p->TypeName.Buffer = (WCHAR *)(p + 1);
6554 p->TypeName.Length = info->name_len;
6555 p->TypeName.MaximumLength = info->name_len + sizeof(WCHAR);
6556 p->TotalNumberOfObjects = info->obj_count;
6557 p->TotalNumberOfHandles = info->handle_count;
6558 p->HighWaterNumberOfObjects = info->obj_max;
6559 p->HighWaterNumberOfHandles = info->handle_max;
6560 p->TypeIndex = info->index + 2;
6561 p->GenericMapping.GenericRead = info->mapping.read;
6562 p->GenericMapping.GenericWrite = info->mapping.write;
6563 p->GenericMapping.GenericExecute = info->mapping.exec;
6564 p->GenericMapping.GenericAll = info->mapping.all;
6565 p->ValidAccessMask = info->valid_access;
6566 memcpy( p->TypeName.Buffer, info + 1, info->name_len );
6567 p->TypeName.Buffer[info->name_len / sizeof(WCHAR)] = 0;
6568 return (char *)(p + 1) + ((p->TypeName.MaximumLength + align) & ~align);
6569 }
6570
6571 /**************************************************************************
6572 * NtQueryObject (NTDLL.@)
6573 */
6574 NTSTATUS WINAPI NtQueryObject( HANDLE handle, OBJECT_INFORMATION_CLASS info_class,
6575 void *ptr, ULONG len, ULONG *used_len )
6576 {
6577 NTSTATUS status;
6578
6579 TRACE("(%p,0x%08x,%p,0x%08x,%p)\n", handle, info_class, ptr, len, used_len);
6580
6581 if (used_len) *used_len = 0;
6582
6583 switch (info_class)
6584 {
6585 case ObjectBasicInformation:
6586 {
6587 OBJECT_BASIC_INFORMATION *p = ptr;
6588
6589 if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
6590
6591 SERVER_START_REQ( get_object_info )
6592 {
6593 req->handle = wine_server_obj_handle( handle );
6594 status = wine_server_call( req );
6595 if (status == STATUS_SUCCESS)
6596 {
6597 memset( p, 0, sizeof(*p) );
6598 p->GrantedAccess = reply->access;
6599 p->PointerCount = reply->ref_count;
6600 p->HandleCount = reply->handle_count;
6601 if (used_len) *used_len = sizeof(*p);
6602 }
6603 }
6604 SERVER_END_REQ;
6605 break;
6606 }
6607
6608 case ObjectNameInformation:
6609 {
6610 OBJECT_NAME_INFORMATION *p = ptr;
6611 char *unix_name;
6612 WCHAR *nt_name;
6613
6614 /* first try as a file object */
6615
6616 if (!(status = server_get_unix_name( handle, &unix_name )))
6617 {
6618 if (!(status = unix_to_nt_file_name( unix_name, &nt_name )))
6619 {
6620 ULONG size = (wcslen(nt_name) + 1) * sizeof(WCHAR);
6621 if (len < sizeof(*p)) status = STATUS_INFO_LENGTH_MISMATCH;
6622 else if (len < sizeof(*p) + size) status = STATUS_BUFFER_OVERFLOW;
6623 else
6624 {
6625 p->Name.Buffer = (WCHAR *)(p + 1);
6626 p->Name.Length = size - sizeof(WCHAR);
6627 p->Name.MaximumLength = size;
6628 wcscpy( p->Name.Buffer, nt_name );
6629 }
6630 if (used_len) *used_len = sizeof(*p) + size;
6631 free( nt_name );
6632 }
6633 free( unix_name );
6634 break;
6635 }
6636 else if (status != STATUS_OBJECT_TYPE_MISMATCH) break;
6637
6638 /* not a file, treat as a generic object */
6639
6640 SERVER_START_REQ( get_object_info )
6641 {
6642 req->handle = wine_server_obj_handle( handle );
6643 if (len > sizeof(*p)) wine_server_set_reply( req, p + 1, len - sizeof(*p) );
6644 status = wine_server_call( req );
6645 if (status == STATUS_SUCCESS)
6646 {
6647 if (!reply->total) /* no name */
6648 {
6649 if (sizeof(*p) > len) status = STATUS_INFO_LENGTH_MISMATCH;
6650 else memset( p, 0, sizeof(*p) );
6651 if (used_len) *used_len = sizeof(*p);
6652 }
6653 else if (sizeof(*p) + reply->total + sizeof(WCHAR) > len)
6654 {
6655 if (used_len) *used_len = sizeof(*p) + reply->total + sizeof(WCHAR);
6656 status = STATUS_INFO_LENGTH_MISMATCH;
6657 }
6658 else
6659 {
6660 ULONG res = wine_server_reply_size( reply );
6661 p->Name.Buffer = (WCHAR *)(p + 1);
6662 p->Name.Length = res;
6663 p->Name.MaximumLength = res + sizeof(WCHAR);
6664 p->Name.Buffer[res / sizeof(WCHAR)] = 0;
6665 if (used_len) *used_len = sizeof(*p) + p->Name.MaximumLength;
6666 }
6667 }
6668 }
6669 SERVER_END_REQ;
6670 break;
6671 }
6672
6673 case ObjectTypeInformation:
6674 {
6675 OBJECT_TYPE_INFORMATION *p = ptr;
6676 char buffer[sizeof(struct object_type_info) + 64];
6677 struct object_type_info *info = (struct object_type_info *)buffer;
6678
6679 SERVER_START_REQ( get_object_type )
6680 {
6681 req->handle = wine_server_obj_handle( handle );
6682 wine_server_set_reply( req, buffer, sizeof(buffer) );
6683 status = wine_server_call( req );
6684 }
6685 SERVER_END_REQ;
6686 if (status) break;
6687 if (sizeof(*p) + info->name_len + sizeof(WCHAR) <= len)
6688 {
6689 put_object_type_info( p, info );
6690 if (used_len) *used_len = sizeof(*p) + p->TypeName.MaximumLength;
6691 }
6692 else
6693 {
6694 if (used_len) *used_len = sizeof(*p) + info->name_len + sizeof(WCHAR);
6695 status = STATUS_INFO_LENGTH_MISMATCH;
6696 }
6697 break;
6698 }
6699
6700 case ObjectTypesInformation:
6701 {
6702 OBJECT_TYPES_INFORMATION *types = ptr;
6703 OBJECT_TYPE_INFORMATION *p;
6704 struct object_type_info *buffer;
6705 /* assume at most 32 types, with an average 16-char name */
6706 ULONG size = 32 * (sizeof(struct object_type_info) + 16 * sizeof(WCHAR));
6707 ULONG i, count, pos, total, align = sizeof(DWORD_PTR) - 1;
6708
6709 buffer = malloc( size );
6710 SERVER_START_REQ( get_object_types )
6711 {
6712 wine_server_set_reply( req, buffer, size );
6713 status = wine_server_call( req );
6714 count = reply->count;
6715 }
6716 SERVER_END_REQ;
6717 if (!status)
6718 {
6719 if (len >= sizeof(*types)) types->NumberOfTypes = count;
6720 total = (sizeof(*types) + align) & ~align;
6721 p = (OBJECT_TYPE_INFORMATION *)((char *)ptr + total);
6722 for (i = pos = 0; i < count; i++)
6723 {
6724 struct object_type_info *info = (struct object_type_info *)((char *)buffer + pos);
6725 pos += sizeof(*info) + ((info->name_len + 3) & ~3);
6726 total += sizeof(*p) + ((info->name_len + sizeof(WCHAR) + align) & ~align);
6727 if (total <= len) p = put_object_type_info( p, info );
6728 }
6729 if (used_len) *used_len = total;
6730 if (total > len) status = STATUS_INFO_LENGTH_MISMATCH;
6731 }
6732 else if (status == STATUS_BUFFER_OVERFLOW) FIXME( "size %u too small\n", size );
6733
6734 free( buffer );
6735 break;
6736 }
6737
6738 case ObjectDataInformation:
6739 {
6740 OBJECT_DATA_INFORMATION* p = ptr;
6741
6742 if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
6743
6744 SERVER_START_REQ( set_handle_info )
6745 {
6746 req->handle = wine_server_obj_handle( handle );
6747 req->flags = 0;
6748 req->mask = 0;
6749 status = wine_server_call( req );
6750 if (status == STATUS_SUCCESS)
6751 {
6752 p->InheritHandle = (reply->old_flags & HANDLE_FLAG_INHERIT) != 0;
6753 p->ProtectFromClose = (reply->old_flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) != 0;
6754 if (used_len) *used_len = sizeof(*p);
6755 }
6756 }
6757 SERVER_END_REQ;
6758 break;
6759 }
6760
6761 default:
6762 FIXME("Unsupported information class %u\n", info_class);
6763 status = STATUS_NOT_IMPLEMENTED;
6764 break;
6765 }
6766 return status;
6767 }
6768
6769
6770 /**************************************************************************
6771 * NtSetInformationObject (NTDLL.@)
6772 */
6773 NTSTATUS WINAPI NtSetInformationObject( HANDLE handle, OBJECT_INFORMATION_CLASS info_class,
6774 void *ptr, ULONG len )
6775 {
6776 NTSTATUS status;
6777
6778 TRACE("(%p,0x%08x,%p,0x%08x)\n", handle, info_class, ptr, len);
6779
6780 switch (info_class)
6781 {
6782 case ObjectDataInformation:
6783 {
6784 OBJECT_DATA_INFORMATION* p = ptr;
6785
6786 if (len < sizeof(*p)) return STATUS_INVALID_BUFFER_SIZE;
6787
6788 SERVER_START_REQ( set_handle_info )
6789 {
6790 req->handle = wine_server_obj_handle( handle );
6791 req->mask = HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE;
6792 if (p->InheritHandle) req->flags |= HANDLE_FLAG_INHERIT;
6793 if (p->ProtectFromClose) req->flags |= HANDLE_FLAG_PROTECT_FROM_CLOSE;
6794 status = wine_server_call( req );
6795 }
6796 SERVER_END_REQ;
6797 break;
6798 }
6799
6800 default:
6801 FIXME("Unsupported information class %u\n", info_class);
6802 status = STATUS_NOT_IMPLEMENTED;
6803 break;
6804 }
6805 return status;
6806 }
Zebediah Figura's local tree