kernel32: Fix build on newer Mac OS X.
[wine/multimedia.git] / server / file.c
blobcceb8ad5c139747f6d8f85a44df31377f7e82551
1 /*
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
21 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <fcntl.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <stdlib.h>
30 #include <errno.h>
31 #include <sys/stat.h>
32 #include <sys/time.h>
33 #include <sys/types.h>
34 #include <time.h>
35 #include <unistd.h>
36 #ifdef HAVE_UTIME_H
37 #include <utime.h>
38 #endif
39 #ifdef HAVE_POLL_H
40 #include <poll.h>
41 #endif
43 #include "ntstatus.h"
44 #define WIN32_NO_STATUS
45 #include "windef.h"
46 #include "winternl.h"
48 #include "file.h"
49 #include "handle.h"
50 #include "thread.h"
51 #include "request.h"
52 #include "process.h"
53 #include "security.h"
55 struct file
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 fd *file_get_fd( struct object *obj );
68 static struct security_descriptor *file_get_sd( struct object *obj );
69 static int file_set_sd( struct object *obj, const struct security_descriptor *sd, unsigned int set_info );
70 static void file_destroy( struct object *obj );
72 static int file_get_poll_events( struct fd *fd );
73 static void file_flush( struct fd *fd, struct event **event );
74 static enum server_fd_type file_get_fd_type( struct fd *fd );
76 static const struct object_ops file_ops =
78 sizeof(struct file), /* size */
79 file_dump, /* dump */
80 no_get_type, /* get_type */
81 add_queue, /* add_queue */
82 remove_queue, /* remove_queue */
83 default_fd_signaled, /* signaled */
84 no_satisfied, /* satisfied */
85 no_signal, /* signal */
86 file_get_fd, /* get_fd */
87 default_fd_map_access, /* map_access */
88 file_get_sd, /* get_sd */
89 file_set_sd, /* set_sd */
90 no_lookup_name, /* lookup_name */
91 no_open_file, /* open_file */
92 fd_close_handle, /* close_handle */
93 file_destroy /* destroy */
96 static const struct fd_ops file_fd_ops =
98 file_get_poll_events, /* get_poll_events */
99 default_poll_event, /* poll_event */
100 file_flush, /* flush */
101 file_get_fd_type, /* get_fd_type */
102 default_fd_ioctl, /* ioctl */
103 default_fd_queue_async, /* queue_async */
104 default_fd_reselect_async, /* reselect_async */
105 default_fd_cancel_async /* cancel_async */
108 static inline int is_overlapped( const struct file *file )
110 return !(get_fd_options( file->fd ) & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT));
113 /* create a file from a file descriptor */
114 /* if the function fails the fd is closed */
115 struct file *create_file_for_fd( int fd, unsigned int access, unsigned int sharing )
117 struct file *file;
118 struct stat st;
120 if (fstat( fd, &st ) == -1)
122 file_set_error();
123 return NULL;
126 if ((file = alloc_object( &file_ops )))
128 file->mode = st.st_mode;
129 file->access = default_fd_map_access( &file->obj, access );
130 if (!(file->fd = create_anonymous_fd( &file_fd_ops, fd, &file->obj,
131 FILE_SYNCHRONOUS_IO_NONALERT )))
133 release_object( file );
134 return NULL;
136 allow_fd_caching( file->fd );
138 return file;
141 /* create a file by duplicating an fd object */
142 struct file *create_file_for_fd_obj( struct fd *fd, unsigned int access, unsigned int sharing )
144 struct file *file;
145 struct stat st;
147 if (fstat( get_unix_fd(fd), &st ) == -1)
149 file_set_error();
150 return NULL;
153 if ((file = alloc_object( &file_ops )))
155 file->mode = st.st_mode;
156 file->access = default_fd_map_access( &file->obj, access );
157 if (!(file->fd = dup_fd_object( fd, access, sharing, FILE_SYNCHRONOUS_IO_NONALERT )))
159 release_object( file );
160 return NULL;
162 set_fd_user( file->fd, &file_fd_ops, &file->obj );
164 return file;
167 static struct object *create_file_obj( struct fd *fd, unsigned int access, mode_t mode )
169 struct file *file = alloc_object( &file_ops );
171 if (!file) return NULL;
172 file->access = access;
173 file->mode = mode;
174 file->uid = ~(uid_t)0;
175 file->fd = fd;
176 grab_object( fd );
177 set_fd_user( fd, &file_fd_ops, &file->obj );
178 return &file->obj;
181 static struct object *create_file( struct fd *root, const char *nameptr, data_size_t len,
182 unsigned int access, unsigned int sharing, int create,
183 unsigned int options, unsigned int attrs,
184 const struct security_descriptor *sd )
186 struct object *obj = NULL;
187 struct fd *fd;
188 int flags;
189 char *name;
190 mode_t mode;
192 if (!len || ((nameptr[0] == '/') ^ !root))
194 set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
195 return NULL;
197 if (!(name = mem_alloc( len + 1 ))) return NULL;
198 memcpy( name, nameptr, len );
199 name[len] = 0;
201 switch(create)
203 case FILE_CREATE: flags = O_CREAT | O_EXCL; break;
204 case FILE_OVERWRITE_IF: /* FIXME: the difference is whether we trash existing attr or not */
205 access |= FILE_WRITE_ATTRIBUTES;
206 case FILE_SUPERSEDE: flags = O_CREAT | O_TRUNC; break;
207 case FILE_OPEN: flags = 0; break;
208 case FILE_OPEN_IF: flags = O_CREAT; break;
209 case FILE_OVERWRITE: flags = O_TRUNC;
210 access |= FILE_WRITE_ATTRIBUTES; break;
211 default: set_error( STATUS_INVALID_PARAMETER ); goto done;
214 if (sd)
216 const SID *owner = sd_get_owner( sd );
217 if (!owner)
218 owner = token_get_user( current->process->token );
219 mode = sd_to_mode( sd, owner );
221 else if (options & FILE_DIRECTORY_FILE)
222 mode = (attrs & FILE_ATTRIBUTE_READONLY) ? 0555 : 0777;
223 else
224 mode = (attrs & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
226 if (len >= 4 &&
227 (!strcasecmp( name + len - 4, ".exe" ) || !strcasecmp( name + len - 4, ".com" )))
229 if (mode & S_IRUSR)
230 mode |= S_IXUSR;
231 if (mode & S_IRGRP)
232 mode |= S_IXGRP;
233 if (mode & S_IROTH)
234 mode |= S_IXOTH;
237 access = generic_file_map_access( access );
239 /* FIXME: should set error to STATUS_OBJECT_NAME_COLLISION if file existed before */
240 fd = open_fd( root, name, flags | O_NONBLOCK | O_LARGEFILE, &mode, access, sharing, options );
241 if (!fd) goto done;
243 if (S_ISDIR(mode))
244 obj = create_dir_obj( fd, access, mode );
245 else if (S_ISCHR(mode) && is_serial_fd( fd ))
246 obj = create_serial( fd );
247 else
248 obj = create_file_obj( fd, access, mode );
250 release_object( fd );
252 done:
253 free( name );
254 return obj;
257 /* check if two file objects point to the same file */
258 int is_same_file( struct file *file1, struct file *file2 )
260 return is_same_file_fd( file1->fd, file2->fd );
263 static void file_dump( struct object *obj, int verbose )
265 struct file *file = (struct file *)obj;
266 assert( obj->ops == &file_ops );
267 fprintf( stderr, "File fd=%p\n", file->fd );
270 static int file_get_poll_events( struct fd *fd )
272 struct file *file = get_fd_user( fd );
273 int events = 0;
274 assert( file->obj.ops == &file_ops );
275 if (file->access & FILE_UNIX_READ_ACCESS) events |= POLLIN;
276 if (file->access & FILE_UNIX_WRITE_ACCESS) events |= POLLOUT;
277 return events;
280 static void file_flush( struct fd *fd, struct event **event )
282 int unix_fd = get_unix_fd( fd );
283 if (unix_fd != -1 && fsync( unix_fd ) == -1) file_set_error();
286 static enum server_fd_type file_get_fd_type( struct fd *fd )
288 struct file *file = get_fd_user( fd );
290 if (S_ISREG(file->mode) || S_ISBLK(file->mode)) return FD_TYPE_FILE;
291 if (S_ISDIR(file->mode)) return FD_TYPE_DIR;
292 return FD_TYPE_CHAR;
295 static struct fd *file_get_fd( struct object *obj )
297 struct file *file = (struct file *)obj;
298 assert( obj->ops == &file_ops );
299 return (struct fd *)grab_object( file->fd );
302 static unsigned int generic_file_map_access( unsigned int access )
304 if (access & GENERIC_READ) access |= FILE_GENERIC_READ;
305 if (access & GENERIC_WRITE) access |= FILE_GENERIC_WRITE;
306 if (access & GENERIC_EXECUTE) access |= FILE_GENERIC_EXECUTE;
307 if (access & GENERIC_ALL) access |= FILE_ALL_ACCESS;
308 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
311 struct security_descriptor *mode_to_sd( mode_t mode, const SID *user, const SID *group )
313 struct security_descriptor *sd;
314 size_t dacl_size;
315 ACE_HEADER *current_ace;
316 ACCESS_ALLOWED_ACE *aaa;
317 ACL *dacl;
318 SID *sid;
319 char *ptr;
320 const SID *world_sid = security_world_sid;
321 const SID *local_system_sid = security_local_system_sid;
323 dacl_size = sizeof(ACL) + FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) +
324 security_sid_len( local_system_sid );
325 if (mode & S_IRWXU)
326 dacl_size += FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + security_sid_len( user );
327 if ((!(mode & S_IRUSR) && (mode & (S_IRGRP|S_IROTH))) ||
328 (!(mode & S_IWUSR) && (mode & (S_IWGRP|S_IWOTH))) ||
329 (!(mode & S_IXUSR) && (mode & (S_IXGRP|S_IXOTH))))
330 dacl_size += FIELD_OFFSET(ACCESS_DENIED_ACE, SidStart) + security_sid_len( user );
331 if (mode & S_IRWXO)
332 dacl_size += FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + security_sid_len( world_sid );
334 sd = mem_alloc( sizeof(struct security_descriptor) +
335 security_sid_len( user ) + security_sid_len( group ) +
336 dacl_size );
337 if (!sd) return sd;
339 sd->control = SE_DACL_PRESENT;
340 sd->owner_len = security_sid_len( user );
341 sd->group_len = security_sid_len( group );
342 sd->sacl_len = 0;
343 sd->dacl_len = dacl_size;
345 ptr = (char *)(sd + 1);
346 memcpy( ptr, user, sd->owner_len );
347 ptr += sd->owner_len;
348 memcpy( ptr, group, sd->group_len );
349 ptr += sd->group_len;
351 dacl = (ACL *)ptr;
352 dacl->AclRevision = ACL_REVISION;
353 dacl->Sbz1 = 0;
354 dacl->AclSize = dacl_size;
355 dacl->AceCount = 1 + (mode & S_IRWXU ? 1 : 0) + (mode & S_IRWXO ? 1 : 0);
356 if ((!(mode & S_IRUSR) && (mode & (S_IRGRP|S_IROTH))) ||
357 (!(mode & S_IWUSR) && (mode & (S_IWGRP|S_IWOTH))) ||
358 (!(mode & S_IXUSR) && (mode & (S_IXGRP|S_IXOTH))))
359 dacl->AceCount++;
360 dacl->Sbz2 = 0;
362 /* always give FILE_ALL_ACCESS for Local System */
363 aaa = (ACCESS_ALLOWED_ACE *)(dacl + 1);
364 current_ace = &aaa->Header;
365 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
366 aaa->Header.AceFlags = 0;
367 aaa->Header.AceSize = FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + security_sid_len( local_system_sid );
368 aaa->Mask = FILE_ALL_ACCESS;
369 sid = (SID *)&aaa->SidStart;
370 memcpy( sid, local_system_sid, security_sid_len( local_system_sid ));
372 if (mode & S_IRWXU)
374 /* appropriate access rights for the user */
375 aaa = (ACCESS_ALLOWED_ACE *)ace_next( current_ace );
376 current_ace = &aaa->Header;
377 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
378 aaa->Header.AceFlags = 0;
379 aaa->Header.AceSize = FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + security_sid_len( user );
380 aaa->Mask = WRITE_DAC | WRITE_OWNER;
381 if (mode & S_IRUSR)
382 aaa->Mask |= FILE_GENERIC_READ | FILE_GENERIC_EXECUTE;
383 if (mode & S_IWUSR)
384 aaa->Mask |= FILE_GENERIC_WRITE | DELETE | FILE_DELETE_CHILD;
385 sid = (SID *)&aaa->SidStart;
386 memcpy( sid, user, security_sid_len( user ));
388 if ((!(mode & S_IRUSR) && (mode & (S_IRGRP|S_IROTH))) ||
389 (!(mode & S_IWUSR) && (mode & (S_IWGRP|S_IWOTH))) ||
390 (!(mode & S_IXUSR) && (mode & (S_IXGRP|S_IXOTH))))
392 /* deny just in case the user is a member of the group */
393 ACCESS_DENIED_ACE *ada = (ACCESS_DENIED_ACE *)ace_next( current_ace );
394 current_ace = &ada->Header;
395 ada->Header.AceType = ACCESS_DENIED_ACE_TYPE;
396 ada->Header.AceFlags = 0;
397 ada->Header.AceSize = FIELD_OFFSET(ACCESS_DENIED_ACE, SidStart) + security_sid_len( user );
398 ada->Mask = 0;
399 if (!(mode & S_IRUSR) && (mode & (S_IRGRP|S_IROTH)))
400 ada->Mask |= FILE_GENERIC_READ | FILE_GENERIC_EXECUTE;
401 if (!(mode & S_IWUSR) && (mode & (S_IWGRP|S_IROTH)))
402 ada->Mask |= FILE_GENERIC_WRITE | DELETE | FILE_DELETE_CHILD;
403 ada->Mask &= ~STANDARD_RIGHTS_ALL; /* never deny standard rights */
404 sid = (SID *)&ada->SidStart;
405 memcpy( sid, user, security_sid_len( user ));
407 if (mode & S_IRWXO)
409 /* appropriate access rights for Everyone */
410 aaa = (ACCESS_ALLOWED_ACE *)ace_next( current_ace );
411 current_ace = &aaa->Header;
412 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
413 aaa->Header.AceFlags = 0;
414 aaa->Header.AceSize = FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + security_sid_len( world_sid );
415 aaa->Mask = 0;
416 if (mode & S_IROTH)
417 aaa->Mask |= FILE_GENERIC_READ | FILE_GENERIC_EXECUTE;
418 if (mode & S_IWOTH)
419 aaa->Mask |= FILE_GENERIC_WRITE | DELETE | FILE_DELETE_CHILD;
420 sid = (SID *)&aaa->SidStart;
421 memcpy( sid, world_sid, security_sid_len( world_sid ));
424 return sd;
427 static struct security_descriptor *file_get_sd( struct object *obj )
429 struct file *file = (struct file *)obj;
430 struct stat st;
431 int unix_fd;
432 struct security_descriptor *sd;
434 assert( obj->ops == &file_ops );
436 unix_fd = get_file_unix_fd( file );
438 if (unix_fd == -1 || fstat( unix_fd, &st ) == -1)
439 return obj->sd;
441 /* mode and uid the same? if so, no need to re-generate security descriptor */
442 if (obj->sd && (st.st_mode & (S_IRWXU|S_IRWXO)) == (file->mode & (S_IRWXU|S_IRWXO)) &&
443 (st.st_uid == file->uid))
444 return obj->sd;
446 sd = mode_to_sd( st.st_mode,
447 security_unix_uid_to_sid( st.st_uid ),
448 token_get_primary_group( current->process->token ));
449 if (!sd) return obj->sd;
451 file->mode = st.st_mode;
452 file->uid = st.st_uid;
453 free( obj->sd );
454 obj->sd = sd;
455 return sd;
458 static mode_t file_access_to_mode( unsigned int access )
460 mode_t mode = 0;
462 access = generic_file_map_access( access );
463 if (access & FILE_READ_DATA) mode |= 4;
464 if (access & (FILE_WRITE_DATA|FILE_APPEND_DATA)) mode |= 2;
465 if (access & FILE_EXECUTE) mode |= 1;
466 return mode;
469 mode_t sd_to_mode( const struct security_descriptor *sd, const SID *owner )
471 mode_t new_mode = 0;
472 mode_t denied_mode = 0;
473 mode_t mode;
474 int present;
475 const ACL *dacl = sd_get_dacl( sd, &present );
476 const SID *user = token_get_user( current->process->token );
477 if (present && dacl)
479 const ACE_HEADER *ace = (const ACE_HEADER *)(dacl + 1);
480 ULONG i;
481 for (i = 0; i < dacl->AceCount; i++, ace = ace_next( ace ))
483 const ACCESS_ALLOWED_ACE *aa_ace;
484 const ACCESS_DENIED_ACE *ad_ace;
485 const SID *sid;
487 if (ace->AceFlags & INHERIT_ONLY_ACE) continue;
489 switch (ace->AceType)
491 case ACCESS_DENIED_ACE_TYPE:
492 ad_ace = (const ACCESS_DENIED_ACE *)ace;
493 sid = (const SID *)&ad_ace->SidStart;
494 mode = file_access_to_mode( ad_ace->Mask );
495 if (security_equal_sid( sid, security_world_sid ))
497 denied_mode |= (mode << 6) | (mode << 3) | mode; /* all */
499 else if ((security_equal_sid( user, owner ) &&
500 token_sid_present( current->process->token, sid, TRUE )))
502 denied_mode |= (mode << 6) | (mode << 3); /* user + group */
504 else if (security_equal_sid( sid, owner ))
506 denied_mode |= (mode << 6); /* user only */
508 break;
509 case ACCESS_ALLOWED_ACE_TYPE:
510 aa_ace = (const ACCESS_ALLOWED_ACE *)ace;
511 sid = (const SID *)&aa_ace->SidStart;
512 mode = file_access_to_mode( aa_ace->Mask );
513 if (security_equal_sid( sid, security_world_sid ))
515 new_mode |= (mode << 6) | (mode << 3) | mode; /* all */
517 else if ((security_equal_sid( user, owner ) &&
518 token_sid_present( current->process->token, sid, FALSE )))
520 new_mode |= (mode << 6) | (mode << 3); /* user + group */
522 else if (security_equal_sid( sid, owner ))
524 new_mode |= (mode << 6); /* user only */
526 break;
530 else
531 /* no ACL means full access rights to anyone */
532 new_mode = S_IRWXU | S_IRWXG | S_IRWXO;
534 return new_mode & ~denied_mode;
537 static int file_set_sd( struct object *obj, const struct security_descriptor *sd,
538 unsigned int set_info )
540 struct file *file = (struct file *)obj;
541 const SID *owner;
542 struct stat st;
543 mode_t mode;
544 int unix_fd;
546 assert( obj->ops == &file_ops );
548 unix_fd = get_file_unix_fd( file );
550 if (unix_fd == -1 || fstat( unix_fd, &st ) == -1) return 1;
552 if (set_info & OWNER_SECURITY_INFORMATION)
554 owner = sd_get_owner( sd );
555 if (!owner)
557 set_error( STATUS_INVALID_SECURITY_DESCR );
558 return 0;
560 if (!obj->sd || !security_equal_sid( owner, sd_get_owner( obj->sd ) ))
562 /* FIXME: get Unix uid and call fchown */
565 else if (obj->sd)
566 owner = sd_get_owner( obj->sd );
567 else
568 owner = token_get_user( current->process->token );
570 /* group and sacl not supported */
572 if (set_info & DACL_SECURITY_INFORMATION)
574 /* keep the bits that we don't map to access rights in the ACL */
575 mode = st.st_mode & (S_ISUID|S_ISGID|S_ISVTX);
576 mode |= sd_to_mode( sd, owner );
578 if (((st.st_mode ^ mode) & (S_IRWXU|S_IRWXG|S_IRWXO)) && fchmod( unix_fd, mode ) == -1)
580 file_set_error();
581 return 0;
584 return 1;
587 static void file_destroy( struct object *obj )
589 struct file *file = (struct file *)obj;
590 assert( obj->ops == &file_ops );
592 if (file->fd) release_object( file->fd );
595 /* set the last error depending on errno */
596 void file_set_error(void)
598 switch (errno)
600 case ETXTBSY:
601 case EAGAIN: set_error( STATUS_SHARING_VIOLATION ); break;
602 case EBADF: set_error( STATUS_INVALID_HANDLE ); break;
603 case ENOSPC: set_error( STATUS_DISK_FULL ); break;
604 case EACCES:
605 case ESRCH:
606 case EROFS:
607 case EPERM: set_error( STATUS_ACCESS_DENIED ); break;
608 case EBUSY: set_error( STATUS_FILE_LOCK_CONFLICT ); break;
609 case ENOENT: set_error( STATUS_NO_SUCH_FILE ); break;
610 case EISDIR: set_error( STATUS_FILE_IS_A_DIRECTORY ); break;
611 case ENFILE:
612 case EMFILE: set_error( STATUS_TOO_MANY_OPENED_FILES ); break;
613 case EEXIST: set_error( STATUS_OBJECT_NAME_COLLISION ); break;
614 case EINVAL: set_error( STATUS_INVALID_PARAMETER ); break;
615 case ESPIPE: set_error( STATUS_ILLEGAL_FUNCTION ); break;
616 case ENOTEMPTY: set_error( STATUS_DIRECTORY_NOT_EMPTY ); break;
617 case EIO: set_error( STATUS_ACCESS_VIOLATION ); break;
618 case ENOTDIR: set_error( STATUS_NOT_A_DIRECTORY ); break;
619 case EFBIG: set_error( STATUS_SECTION_TOO_BIG ); break;
620 case ENODEV: set_error( STATUS_NO_SUCH_DEVICE ); break;
621 case ENXIO: set_error( STATUS_NO_SUCH_DEVICE ); break;
622 #ifdef EOVERFLOW
623 case EOVERFLOW: set_error( STATUS_INVALID_PARAMETER ); break;
624 #endif
625 default:
626 perror("wineserver: file_set_error() can't map error");
627 set_error( STATUS_UNSUCCESSFUL );
628 break;
632 struct file *get_file_obj( struct process *process, obj_handle_t handle, unsigned int access )
634 return (struct file *)get_handle_obj( process, handle, access, &file_ops );
637 int get_file_unix_fd( struct file *file )
639 return get_unix_fd( file->fd );
642 /* create a file */
643 DECL_HANDLER(create_file)
645 struct object *file;
646 struct fd *root_fd = NULL;
647 const struct object_attributes *objattr = get_req_data();
648 const struct security_descriptor *sd;
649 const char *name;
650 data_size_t name_len;
652 reply->handle = 0;
654 if (!objattr_is_valid( objattr, get_req_data_size() ))
655 return;
656 /* name is transferred in the unix codepage outside of the objattr structure */
657 if (objattr->name_len)
659 set_error( STATUS_INVALID_PARAMETER );
660 return;
663 if (objattr->rootdir)
665 struct dir *root;
667 if (!(root = get_dir_obj( current->process, objattr->rootdir, 0 ))) return;
668 root_fd = get_obj_fd( (struct object *)root );
669 release_object( root );
670 if (!root_fd) return;
673 sd = objattr->sd_len ? (const struct security_descriptor *)(objattr + 1) : NULL;
675 name = (const char *)get_req_data() + sizeof(*objattr) + objattr->sd_len;
676 name_len = get_req_data_size() - sizeof(*objattr) - objattr->sd_len;
678 reply->handle = 0;
679 if ((file = create_file( root_fd, name, name_len, req->access, req->sharing,
680 req->create, req->options, req->attrs, sd )))
682 reply->handle = alloc_handle( current->process, file, req->access, req->attributes );
683 release_object( file );
685 if (root_fd) release_object( root_fd );
688 /* allocate a file handle for a Unix fd */
689 DECL_HANDLER(alloc_file_handle)
691 struct file *file;
692 int fd;
694 reply->handle = 0;
695 if ((fd = thread_get_inflight_fd( current, req->fd )) == -1)
697 set_error( STATUS_INVALID_HANDLE );
698 return;
700 if ((file = create_file_for_fd( fd, req->access, FILE_SHARE_READ | FILE_SHARE_WRITE )))
702 reply->handle = alloc_handle( current->process, file, req->access, req->attributes );
703 release_object( file );
707 /* lock a region of a file */
708 DECL_HANDLER(lock_file)
710 struct file *file;
712 if ((file = get_file_obj( current->process, req->handle, 0 )))
714 reply->handle = lock_fd( file->fd, req->offset, req->count, req->shared, req->wait );
715 reply->overlapped = is_overlapped( file );
716 release_object( file );
720 /* unlock a region of a file */
721 DECL_HANDLER(unlock_file)
723 struct file *file;
725 if ((file = get_file_obj( current->process, req->handle, 0 )))
727 unlock_fd( file->fd, req->offset, req->count );
728 release_object( file );