2 * Server-side file management
4 * Copyright (C) 1998 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
33 #include <sys/types.h>
44 #define WIN32_NO_STATUS
57 struct object obj
; /* object header */
58 struct fd
*fd
; /* file descriptor for this file */
59 unsigned int access
; /* file access (FILE_READ_DATA etc.) */
60 mode_t mode
; /* file stat.st_mode */
61 uid_t uid
; /* file stat.st_uid */
64 static unsigned int generic_file_map_access( unsigned int access
);
66 static void file_dump( struct object
*obj
, int verbose
);
67 static struct object_type
*file_get_type( struct object
*obj
);
68 static struct fd
*file_get_fd( struct object
*obj
);
69 static struct security_descriptor
*file_get_sd( struct object
*obj
);
70 static int file_set_sd( struct object
*obj
, const struct security_descriptor
*sd
, unsigned int set_info
);
71 static struct object
*file_lookup_name( struct object
*obj
, struct unicode_str
*name
, unsigned int attr
);
72 static struct object
*file_open_file( struct object
*obj
, unsigned int access
,
73 unsigned int sharing
, unsigned int options
);
74 static void file_destroy( struct object
*obj
);
76 static int file_get_poll_events( struct fd
*fd
);
77 static int file_flush( struct fd
*fd
, struct async
*async
);
78 static enum server_fd_type
file_get_fd_type( struct fd
*fd
);
80 static const struct object_ops file_ops
=
82 sizeof(struct file
), /* size */
84 file_get_type
, /* get_type */
85 add_queue
, /* add_queue */
86 remove_queue
, /* remove_queue */
87 default_fd_signaled
, /* signaled */
88 no_satisfied
, /* satisfied */
89 no_signal
, /* signal */
90 file_get_fd
, /* get_fd */
91 default_fd_map_access
, /* map_access */
92 file_get_sd
, /* get_sd */
93 file_set_sd
, /* set_sd */
94 file_lookup_name
, /* lookup_name */
95 no_link_name
, /* link_name */
96 NULL
, /* unlink_name */
97 file_open_file
, /* open_file */
98 fd_close_handle
, /* close_handle */
99 file_destroy
/* destroy */
102 static const struct fd_ops file_fd_ops
=
104 file_get_poll_events
, /* get_poll_events */
105 default_poll_event
, /* poll_event */
106 file_get_fd_type
, /* get_fd_type */
107 no_fd_read
, /* read */
108 no_fd_write
, /* write */
109 file_flush
, /* flush */
110 no_fd_get_volume_info
, /* get_volume_info */
111 default_fd_ioctl
, /* ioctl */
112 default_fd_queue_async
, /* queue_async */
113 default_fd_reselect_async
/* reselect_async */
116 static inline int is_overlapped( const struct file
*file
)
118 return !(get_fd_options( file
->fd
) & (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
));
121 /* create a file from a file descriptor */
122 /* if the function fails the fd is closed */
123 struct file
*create_file_for_fd( int fd
, unsigned int access
, unsigned int sharing
)
128 if (fstat( fd
, &st
) == -1)
135 if (!(file
= alloc_object( &file_ops
)))
141 file
->mode
= st
.st_mode
;
142 file
->access
= default_fd_map_access( &file
->obj
, access
);
143 if (!(file
->fd
= create_anonymous_fd( &file_fd_ops
, fd
, &file
->obj
,
144 FILE_SYNCHRONOUS_IO_NONALERT
)))
146 release_object( file
);
149 allow_fd_caching( file
->fd
);
153 /* create a file by duplicating an fd object */
154 struct file
*create_file_for_fd_obj( struct fd
*fd
, unsigned int access
, unsigned int sharing
)
159 if (fstat( get_unix_fd(fd
), &st
) == -1)
165 if ((file
= alloc_object( &file_ops
)))
167 file
->mode
= st
.st_mode
;
168 file
->access
= default_fd_map_access( &file
->obj
, access
);
169 if (!(file
->fd
= dup_fd_object( fd
, access
, sharing
, FILE_SYNCHRONOUS_IO_NONALERT
)))
171 release_object( file
);
174 set_fd_user( file
->fd
, &file_fd_ops
, &file
->obj
);
179 static struct object
*create_file_obj( struct fd
*fd
, unsigned int access
, mode_t mode
)
181 struct file
*file
= alloc_object( &file_ops
);
183 if (!file
) return NULL
;
184 file
->access
= access
;
186 file
->uid
= ~(uid_t
)0;
189 set_fd_user( fd
, &file_fd_ops
, &file
->obj
);
193 static struct object
*create_file( struct fd
*root
, const char *nameptr
, data_size_t len
,
194 unsigned int access
, unsigned int sharing
, int create
,
195 unsigned int options
, unsigned int attrs
,
196 const struct security_descriptor
*sd
)
198 struct object
*obj
= NULL
;
204 if (!len
|| ((nameptr
[0] == '/') ^ !root
))
206 set_error( STATUS_OBJECT_PATH_SYNTAX_BAD
);
209 if (!(name
= mem_alloc( len
+ 1 ))) return NULL
;
210 memcpy( name
, nameptr
, len
);
215 case FILE_CREATE
: flags
= O_CREAT
| O_EXCL
; break;
216 case FILE_OVERWRITE_IF
: /* FIXME: the difference is whether we trash existing attr or not */
217 access
|= FILE_WRITE_ATTRIBUTES
;
218 case FILE_SUPERSEDE
: flags
= O_CREAT
| O_TRUNC
; break;
219 case FILE_OPEN
: flags
= 0; break;
220 case FILE_OPEN_IF
: flags
= O_CREAT
; break;
221 case FILE_OVERWRITE
: flags
= O_TRUNC
;
222 access
|= FILE_WRITE_ATTRIBUTES
; break;
223 default: set_error( STATUS_INVALID_PARAMETER
); goto done
;
228 const SID
*owner
= sd_get_owner( sd
);
230 owner
= token_get_user( current
->process
->token
);
231 mode
= sd_to_mode( sd
, owner
);
233 else if (options
& FILE_DIRECTORY_FILE
)
234 mode
= (attrs
& FILE_ATTRIBUTE_READONLY
) ? 0555 : 0777;
236 mode
= (attrs
& FILE_ATTRIBUTE_READONLY
) ? 0444 : 0666;
239 (!strcasecmp( name
+ len
- 4, ".exe" ) || !strcasecmp( name
+ len
- 4, ".com" )))
249 access
= generic_file_map_access( access
);
251 /* FIXME: should set error to STATUS_OBJECT_NAME_COLLISION if file existed before */
252 fd
= open_fd( root
, name
, flags
| O_NONBLOCK
| O_LARGEFILE
, &mode
, access
, sharing
, options
);
256 obj
= create_dir_obj( fd
, access
, mode
);
257 else if (S_ISCHR(mode
) && is_serial_fd( fd
))
258 obj
= create_serial( fd
);
260 obj
= create_file_obj( fd
, access
, mode
);
262 release_object( fd
);
269 static void file_dump( struct object
*obj
, int verbose
)
271 struct file
*file
= (struct file
*)obj
;
272 assert( obj
->ops
== &file_ops
);
273 fprintf( stderr
, "File fd=%p\n", file
->fd
);
276 static struct object_type
*file_get_type( struct object
*obj
)
278 static const WCHAR name
[] = {'F','i','l','e'};
279 static const struct unicode_str str
= { name
, sizeof(name
) };
280 return get_object_type( &str
);
283 static int file_get_poll_events( struct fd
*fd
)
285 struct file
*file
= get_fd_user( fd
);
287 assert( file
->obj
.ops
== &file_ops
);
288 if (file
->access
& FILE_UNIX_READ_ACCESS
) events
|= POLLIN
;
289 if (file
->access
& FILE_UNIX_WRITE_ACCESS
) events
|= POLLOUT
;
293 static int file_flush( struct fd
*fd
, struct async
*async
)
295 int unix_fd
= get_unix_fd( fd
);
296 if (unix_fd
!= -1 && fsync( unix_fd
) == -1)
304 static enum server_fd_type
file_get_fd_type( struct fd
*fd
)
306 struct file
*file
= get_fd_user( fd
);
308 if (S_ISREG(file
->mode
) || S_ISBLK(file
->mode
)) return FD_TYPE_FILE
;
309 if (S_ISDIR(file
->mode
)) return FD_TYPE_DIR
;
313 static struct fd
*file_get_fd( struct object
*obj
)
315 struct file
*file
= (struct file
*)obj
;
316 assert( obj
->ops
== &file_ops
);
317 return (struct fd
*)grab_object( file
->fd
);
320 static unsigned int generic_file_map_access( unsigned int access
)
322 if (access
& GENERIC_READ
) access
|= FILE_GENERIC_READ
;
323 if (access
& GENERIC_WRITE
) access
|= FILE_GENERIC_WRITE
;
324 if (access
& GENERIC_EXECUTE
) access
|= FILE_GENERIC_EXECUTE
;
325 if (access
& GENERIC_ALL
) access
|= FILE_ALL_ACCESS
;
326 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
329 struct security_descriptor
*mode_to_sd( mode_t mode
, const SID
*user
, const SID
*group
)
331 struct security_descriptor
*sd
;
333 ACE_HEADER
*current_ace
;
334 ACCESS_ALLOWED_ACE
*aaa
;
338 const SID
*world_sid
= security_world_sid
;
339 const SID
*local_system_sid
= security_local_system_sid
;
341 dacl_size
= sizeof(ACL
) + FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
) +
342 security_sid_len( local_system_sid
);
344 dacl_size
+= FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
) + security_sid_len( user
);
345 if ((!(mode
& S_IRUSR
) && (mode
& (S_IRGRP
|S_IROTH
))) ||
346 (!(mode
& S_IWUSR
) && (mode
& (S_IWGRP
|S_IWOTH
))) ||
347 (!(mode
& S_IXUSR
) && (mode
& (S_IXGRP
|S_IXOTH
))))
348 dacl_size
+= FIELD_OFFSET(ACCESS_DENIED_ACE
, SidStart
) + security_sid_len( user
);
350 dacl_size
+= FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
) + security_sid_len( world_sid
);
352 sd
= mem_alloc( sizeof(struct security_descriptor
) +
353 security_sid_len( user
) + security_sid_len( group
) +
357 sd
->control
= SE_DACL_PRESENT
;
358 sd
->owner_len
= security_sid_len( user
);
359 sd
->group_len
= security_sid_len( group
);
361 sd
->dacl_len
= dacl_size
;
363 ptr
= (char *)(sd
+ 1);
364 memcpy( ptr
, user
, sd
->owner_len
);
365 ptr
+= sd
->owner_len
;
366 memcpy( ptr
, group
, sd
->group_len
);
367 ptr
+= sd
->group_len
;
370 dacl
->AclRevision
= ACL_REVISION
;
372 dacl
->AclSize
= dacl_size
;
373 dacl
->AceCount
= 1 + (mode
& S_IRWXU
? 1 : 0) + (mode
& S_IRWXO
? 1 : 0);
374 if ((!(mode
& S_IRUSR
) && (mode
& (S_IRGRP
|S_IROTH
))) ||
375 (!(mode
& S_IWUSR
) && (mode
& (S_IWGRP
|S_IWOTH
))) ||
376 (!(mode
& S_IXUSR
) && (mode
& (S_IXGRP
|S_IXOTH
))))
380 /* always give FILE_ALL_ACCESS for Local System */
381 aaa
= (ACCESS_ALLOWED_ACE
*)(dacl
+ 1);
382 current_ace
= &aaa
->Header
;
383 aaa
->Header
.AceType
= ACCESS_ALLOWED_ACE_TYPE
;
384 aaa
->Header
.AceFlags
= (mode
& S_IFDIR
) ? OBJECT_INHERIT_ACE
| CONTAINER_INHERIT_ACE
: 0;
385 aaa
->Header
.AceSize
= FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
) + security_sid_len( local_system_sid
);
386 aaa
->Mask
= FILE_ALL_ACCESS
;
387 sid
= (SID
*)&aaa
->SidStart
;
388 memcpy( sid
, local_system_sid
, security_sid_len( local_system_sid
));
392 /* appropriate access rights for the user */
393 aaa
= (ACCESS_ALLOWED_ACE
*)ace_next( current_ace
);
394 current_ace
= &aaa
->Header
;
395 aaa
->Header
.AceType
= ACCESS_ALLOWED_ACE_TYPE
;
396 aaa
->Header
.AceFlags
= (mode
& S_IFDIR
) ? OBJECT_INHERIT_ACE
| CONTAINER_INHERIT_ACE
: 0;
397 aaa
->Header
.AceSize
= FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
) + security_sid_len( user
);
398 aaa
->Mask
= WRITE_DAC
| WRITE_OWNER
;
400 aaa
->Mask
|= FILE_GENERIC_READ
| FILE_GENERIC_EXECUTE
;
402 aaa
->Mask
|= FILE_GENERIC_WRITE
| DELETE
| FILE_DELETE_CHILD
;
403 sid
= (SID
*)&aaa
->SidStart
;
404 memcpy( sid
, user
, security_sid_len( user
));
406 if ((!(mode
& S_IRUSR
) && (mode
& (S_IRGRP
|S_IROTH
))) ||
407 (!(mode
& S_IWUSR
) && (mode
& (S_IWGRP
|S_IWOTH
))) ||
408 (!(mode
& S_IXUSR
) && (mode
& (S_IXGRP
|S_IXOTH
))))
410 /* deny just in case the user is a member of the group */
411 ACCESS_DENIED_ACE
*ada
= (ACCESS_DENIED_ACE
*)ace_next( current_ace
);
412 current_ace
= &ada
->Header
;
413 ada
->Header
.AceType
= ACCESS_DENIED_ACE_TYPE
;
414 ada
->Header
.AceFlags
= (mode
& S_IFDIR
) ? OBJECT_INHERIT_ACE
| CONTAINER_INHERIT_ACE
: 0;
415 ada
->Header
.AceSize
= FIELD_OFFSET(ACCESS_DENIED_ACE
, SidStart
) + security_sid_len( user
);
417 if (!(mode
& S_IRUSR
) && (mode
& (S_IRGRP
|S_IROTH
)))
418 ada
->Mask
|= FILE_GENERIC_READ
| FILE_GENERIC_EXECUTE
;
419 if (!(mode
& S_IWUSR
) && (mode
& (S_IWGRP
|S_IROTH
)))
420 ada
->Mask
|= FILE_GENERIC_WRITE
| DELETE
| FILE_DELETE_CHILD
;
421 ada
->Mask
&= ~STANDARD_RIGHTS_ALL
; /* never deny standard rights */
422 sid
= (SID
*)&ada
->SidStart
;
423 memcpy( sid
, user
, security_sid_len( user
));
427 /* appropriate access rights for Everyone */
428 aaa
= (ACCESS_ALLOWED_ACE
*)ace_next( current_ace
);
429 current_ace
= &aaa
->Header
;
430 aaa
->Header
.AceType
= ACCESS_ALLOWED_ACE_TYPE
;
431 aaa
->Header
.AceFlags
= (mode
& S_IFDIR
) ? OBJECT_INHERIT_ACE
| CONTAINER_INHERIT_ACE
: 0;
432 aaa
->Header
.AceSize
= FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
) + security_sid_len( world_sid
);
435 aaa
->Mask
|= FILE_GENERIC_READ
| FILE_GENERIC_EXECUTE
;
437 aaa
->Mask
|= FILE_GENERIC_WRITE
| DELETE
| FILE_DELETE_CHILD
;
438 sid
= (SID
*)&aaa
->SidStart
;
439 memcpy( sid
, world_sid
, security_sid_len( world_sid
));
445 static struct security_descriptor
*file_get_sd( struct object
*obj
)
447 struct file
*file
= (struct file
*)obj
;
450 struct security_descriptor
*sd
;
452 assert( obj
->ops
== &file_ops
);
454 unix_fd
= get_file_unix_fd( file
);
456 if (unix_fd
== -1 || fstat( unix_fd
, &st
) == -1)
459 /* mode and uid the same? if so, no need to re-generate security descriptor */
460 if (obj
->sd
&& (st
.st_mode
& (S_IRWXU
|S_IRWXO
)) == (file
->mode
& (S_IRWXU
|S_IRWXO
)) &&
461 (st
.st_uid
== file
->uid
))
464 sd
= mode_to_sd( st
.st_mode
,
465 security_unix_uid_to_sid( st
.st_uid
),
466 token_get_primary_group( current
->process
->token
));
467 if (!sd
) return obj
->sd
;
469 file
->mode
= st
.st_mode
;
470 file
->uid
= st
.st_uid
;
476 static mode_t
file_access_to_mode( unsigned int access
)
480 access
= generic_file_map_access( access
);
481 if (access
& FILE_READ_DATA
) mode
|= 4;
482 if (access
& (FILE_WRITE_DATA
|FILE_APPEND_DATA
)) mode
|= 2;
483 if (access
& FILE_EXECUTE
) mode
|= 1;
487 mode_t
sd_to_mode( const struct security_descriptor
*sd
, const SID
*owner
)
490 mode_t bits_to_set
= ~0;
493 const ACL
*dacl
= sd_get_dacl( sd
, &present
);
494 const SID
*user
= token_get_user( current
->process
->token
);
497 const ACE_HEADER
*ace
= (const ACE_HEADER
*)(dacl
+ 1);
499 for (i
= 0; i
< dacl
->AceCount
; i
++, ace
= ace_next( ace
))
501 const ACCESS_ALLOWED_ACE
*aa_ace
;
502 const ACCESS_DENIED_ACE
*ad_ace
;
505 if (ace
->AceFlags
& INHERIT_ONLY_ACE
) continue;
507 switch (ace
->AceType
)
509 case ACCESS_DENIED_ACE_TYPE
:
510 ad_ace
= (const ACCESS_DENIED_ACE
*)ace
;
511 sid
= (const SID
*)&ad_ace
->SidStart
;
512 mode
= file_access_to_mode( ad_ace
->Mask
);
513 if (security_equal_sid( sid
, security_world_sid
))
515 bits_to_set
&= ~((mode
<< 6) | (mode
<< 3) | mode
); /* all */
517 else if ((security_equal_sid( user
, owner
) &&
518 token_sid_present( current
->process
->token
, sid
, TRUE
)))
520 bits_to_set
&= ~((mode
<< 6) | (mode
<< 3)); /* user + group */
522 else if (security_equal_sid( sid
, owner
))
524 bits_to_set
&= ~(mode
<< 6); /* user only */
527 case ACCESS_ALLOWED_ACE_TYPE
:
528 aa_ace
= (const ACCESS_ALLOWED_ACE
*)ace
;
529 sid
= (const SID
*)&aa_ace
->SidStart
;
530 mode
= file_access_to_mode( aa_ace
->Mask
);
531 if (security_equal_sid( sid
, security_world_sid
))
533 mode
= (mode
<< 6) | (mode
<< 3) | mode
; /* all */
534 new_mode
|= mode
& bits_to_set
;
535 bits_to_set
&= ~mode
;
537 else if ((security_equal_sid( user
, owner
) &&
538 token_sid_present( current
->process
->token
, sid
, FALSE
)))
540 mode
= (mode
<< 6) | (mode
<< 3); /* user + group */
541 new_mode
|= mode
& bits_to_set
;
542 bits_to_set
&= ~mode
;
544 else if (security_equal_sid( sid
, owner
))
546 mode
= (mode
<< 6); /* user only */
547 new_mode
|= mode
& bits_to_set
;
548 bits_to_set
&= ~mode
;
555 /* no ACL means full access rights to anyone */
556 new_mode
= S_IRWXU
| S_IRWXG
| S_IRWXO
;
561 static int file_set_sd( struct object
*obj
, const struct security_descriptor
*sd
,
562 unsigned int set_info
)
564 struct file
*file
= (struct file
*)obj
;
570 assert( obj
->ops
== &file_ops
);
572 unix_fd
= get_file_unix_fd( file
);
574 if (unix_fd
== -1 || fstat( unix_fd
, &st
) == -1) return 1;
576 if (set_info
& OWNER_SECURITY_INFORMATION
)
578 owner
= sd_get_owner( sd
);
581 set_error( STATUS_INVALID_SECURITY_DESCR
);
584 if (!obj
->sd
|| !security_equal_sid( owner
, sd_get_owner( obj
->sd
) ))
586 /* FIXME: get Unix uid and call fchown */
590 owner
= sd_get_owner( obj
->sd
);
592 owner
= token_get_user( current
->process
->token
);
594 /* group and sacl not supported */
596 if (set_info
& DACL_SECURITY_INFORMATION
)
598 /* keep the bits that we don't map to access rights in the ACL */
599 mode
= st
.st_mode
& (S_ISUID
|S_ISGID
|S_ISVTX
);
600 mode
|= sd_to_mode( sd
, owner
);
602 if (((st
.st_mode
^ mode
) & (S_IRWXU
|S_IRWXG
|S_IRWXO
)) && fchmod( unix_fd
, mode
) == -1)
611 static struct object
*file_lookup_name( struct object
*obj
, struct unicode_str
*name
, unsigned int attr
)
613 if (!name
|| !name
->len
) return NULL
; /* open the file itself */
615 set_error( STATUS_OBJECT_PATH_NOT_FOUND
);
619 static struct object
*file_open_file( struct object
*obj
, unsigned int access
,
620 unsigned int sharing
, unsigned int options
)
622 struct file
*file
= (struct file
*)obj
;
623 struct object
*new_file
= NULL
;
626 assert( obj
->ops
== &file_ops
);
628 if ((unix_name
= dup_fd_name( file
->fd
, "" )))
630 new_file
= create_file( NULL
, unix_name
, strlen(unix_name
), access
,
631 sharing
, FILE_OPEN
, options
, 0, NULL
);
634 else set_error( STATUS_OBJECT_TYPE_MISMATCH
);
638 static void file_destroy( struct object
*obj
)
640 struct file
*file
= (struct file
*)obj
;
641 assert( obj
->ops
== &file_ops
);
643 if (file
->fd
) release_object( file
->fd
);
646 /* set the last error depending on errno */
647 void file_set_error(void)
652 case EAGAIN
: set_error( STATUS_SHARING_VIOLATION
); break;
653 case EBADF
: set_error( STATUS_INVALID_HANDLE
); break;
654 case ENOSPC
: set_error( STATUS_DISK_FULL
); break;
658 case EPERM
: set_error( STATUS_ACCESS_DENIED
); break;
659 case EBUSY
: set_error( STATUS_FILE_LOCK_CONFLICT
); break;
660 case ENOENT
: set_error( STATUS_NO_SUCH_FILE
); break;
661 case EISDIR
: set_error( STATUS_FILE_IS_A_DIRECTORY
); break;
663 case EMFILE
: set_error( STATUS_TOO_MANY_OPENED_FILES
); break;
664 case EEXIST
: set_error( STATUS_OBJECT_NAME_COLLISION
); break;
665 case EINVAL
: set_error( STATUS_INVALID_PARAMETER
); break;
666 case ESPIPE
: set_error( STATUS_ILLEGAL_FUNCTION
); break;
667 case ENOTEMPTY
: set_error( STATUS_DIRECTORY_NOT_EMPTY
); break;
668 case EIO
: set_error( STATUS_ACCESS_VIOLATION
); break;
669 case ENOTDIR
: set_error( STATUS_NOT_A_DIRECTORY
); break;
670 case EFBIG
: set_error( STATUS_SECTION_TOO_BIG
); break;
671 case ENODEV
: set_error( STATUS_NO_SUCH_DEVICE
); break;
672 case ENXIO
: set_error( STATUS_NO_SUCH_DEVICE
); break;
674 case EOVERFLOW
: set_error( STATUS_INVALID_PARAMETER
); break;
677 perror("wineserver: file_set_error() can't map error");
678 set_error( STATUS_UNSUCCESSFUL
);
683 struct file
*get_file_obj( struct process
*process
, obj_handle_t handle
, unsigned int access
)
685 return (struct file
*)get_handle_obj( process
, handle
, access
, &file_ops
);
688 int get_file_unix_fd( struct file
*file
)
690 return get_unix_fd( file
->fd
);
694 DECL_HANDLER(create_file
)
697 struct fd
*root_fd
= NULL
;
698 struct unicode_str unicode_name
;
699 const struct security_descriptor
*sd
;
700 const struct object_attributes
*objattr
= get_req_object_attributes( &sd
, &unicode_name
, NULL
);
702 data_size_t name_len
;
704 if (!objattr
) return;
706 /* name is transferred in the unix codepage outside of the objattr structure */
707 if (unicode_name
.len
)
709 set_error( STATUS_INVALID_PARAMETER
);
713 if (objattr
->rootdir
)
717 if (!(root
= get_dir_obj( current
->process
, objattr
->rootdir
, 0 ))) return;
718 root_fd
= get_obj_fd( (struct object
*)root
);
719 release_object( root
);
720 if (!root_fd
) return;
723 name
= get_req_data_after_objattr( objattr
, &name_len
);
726 if ((file
= create_file( root_fd
, name
, name_len
, req
->access
, req
->sharing
,
727 req
->create
, req
->options
, req
->attrs
, sd
)))
729 reply
->handle
= alloc_handle( current
->process
, file
, req
->access
, objattr
->attributes
);
730 release_object( file
);
732 if (root_fd
) release_object( root_fd
);
735 /* allocate a file handle for a Unix fd */
736 DECL_HANDLER(alloc_file_handle
)
742 if ((fd
= thread_get_inflight_fd( current
, req
->fd
)) == -1)
744 set_error( STATUS_INVALID_HANDLE
);
747 if ((file
= create_file_for_fd( fd
, req
->access
, FILE_SHARE_READ
| FILE_SHARE_WRITE
)))
749 reply
->handle
= alloc_handle( current
->process
, file
, req
->access
, req
->attributes
);
750 release_object( file
);
754 /* lock a region of a file */
755 DECL_HANDLER(lock_file
)
759 if ((file
= get_file_obj( current
->process
, req
->handle
, 0 )))
761 reply
->handle
= lock_fd( file
->fd
, req
->offset
, req
->count
, req
->shared
, req
->wait
);
762 reply
->overlapped
= is_overlapped( file
);
763 release_object( file
);
767 /* unlock a region of a file */
768 DECL_HANDLER(unlock_file
)
772 if ((file
= get_file_obj( current
->process
, req
->handle
, 0 )))
774 unlock_fd( file
->fd
, req
->offset
, req
->count
);
775 release_object( file
);