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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
30 #ifdef HAVE_SYS_ERRNO_H
31 #include <sys/errno.h>
35 #include <sys/types.h>
53 struct object obj; /* object header */
54 struct fd *fd; /* file descriptor for this file */
55 struct file *next; /* next file in hashing list */
56 char *name; /* file name */
57 unsigned int access; /* file access (GENERIC_READ/WRITE) */
58 unsigned int flags; /* flags (FILE_FLAG_*) */
59 unsigned int sharing; /* file sharing mode */
60 int drive_type; /* type of drive the file is on */
61 struct async_queue read_q;
62 struct async_queue write_q;
65 #define NAME_HASH_SIZE 37
67 static struct file *file_hash[NAME_HASH_SIZE];
69 static void file_dump( struct object *obj, int verbose );
70 static struct fd *file_get_fd( struct object *obj );
71 static void file_destroy( struct object *obj );
73 static int file_get_poll_events( struct fd *fd );
74 static void file_poll_event( struct fd *fd, int event );
75 static int file_flush( struct fd *fd );
76 static int file_get_info( struct fd *fd, struct get_file_info_reply *reply, int *flags );
77 static void file_queue_async( struct fd *fd, void *ptr, unsigned int status, int type, int count );
79 static const struct object_ops file_ops =
81 sizeof(struct file), /* size */
83 default_fd_add_queue, /* add_queue */
84 default_fd_remove_queue, /* remove_queue */
85 default_fd_signaled, /* signaled */
86 no_satisfied, /* satisfied */
87 file_get_fd, /* get_fd */
88 file_destroy /* destroy */
91 static const struct fd_ops file_fd_ops =
93 file_get_poll_events, /* get_poll_events */
94 file_poll_event, /* poll_event */
95 file_flush, /* flush */
96 file_get_info, /* get_file_info */
97 file_queue_async /* queue_async */
100 static int get_name_hash( const char *name )
103 while (*name) hash ^= (unsigned char)*name++;
104 return hash % NAME_HASH_SIZE;
107 /* check if the desired access is possible without violating */
108 /* the sharing mode of other opens of the same file */
109 static int check_sharing( const char *name, int hash, unsigned int access,
110 unsigned int sharing )
113 unsigned int existing_sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
114 unsigned int existing_access = 0;
116 for (file = file_hash[hash]; file; file = file->next)
118 if (strcmp( file->name, name )) continue;
119 existing_sharing &= file->sharing;
120 existing_access |= file->access;
122 if ((access & GENERIC_READ) && !(existing_sharing & FILE_SHARE_READ)) goto error;
123 if ((access & GENERIC_WRITE) && !(existing_sharing & FILE_SHARE_WRITE)) goto error;
124 if ((existing_access & GENERIC_READ) && !(sharing & FILE_SHARE_READ)) goto error;
125 if ((existing_access & GENERIC_WRITE) && !(sharing & FILE_SHARE_WRITE)) goto error;
128 set_error( STATUS_SHARING_VIOLATION );
132 /* create a file from a file descriptor */
133 /* if the function fails the fd is closed */
134 static struct file *create_file_for_fd( int fd, unsigned int access, unsigned int sharing,
135 unsigned int attrs, int drive_type )
139 if ((file = alloc_object( &file_ops )))
143 file->access = access;
145 file->sharing = sharing;
146 file->drive_type = drive_type;
147 if (file->flags & FILE_FLAG_OVERLAPPED)
149 init_async_queue (&file->read_q);
150 init_async_queue (&file->write_q);
152 if (!(file->fd = create_anonymous_fd( &file_fd_ops, fd, &file->obj )))
154 release_object( file );
162 static struct file *create_file( const char *nameptr, size_t len, unsigned int access,
163 unsigned int sharing, int create, unsigned int attrs,
171 if (!(name = mem_alloc( len + 1 ))) return NULL;
172 memcpy( name, nameptr, len );
175 /* check sharing mode */
176 hash = get_name_hash( name );
177 if (!check_sharing( name, hash, access, sharing )) goto error;
181 case CREATE_NEW: flags = O_CREAT | O_EXCL; break;
182 case CREATE_ALWAYS: flags = O_CREAT | O_TRUNC; break;
183 case OPEN_ALWAYS: flags = O_CREAT; break;
184 case TRUNCATE_EXISTING: flags = O_TRUNC; break;
185 case OPEN_EXISTING: flags = 0; break;
186 default: set_error( STATUS_INVALID_PARAMETER ); goto error;
188 switch(access & (GENERIC_READ | GENERIC_WRITE))
191 case GENERIC_READ: flags |= O_RDONLY; break;
192 case GENERIC_WRITE: flags |= O_WRONLY; break;
193 case GENERIC_READ|GENERIC_WRITE: flags |= O_RDWR; break;
195 mode = (attrs & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
198 (!strcasecmp( name + len - 4, ".exe" ) || !strcasecmp( name + len - 4, ".com" )))
201 if (!(file = alloc_object( &file_ops ))) goto error;
203 file->access = access;
205 file->sharing = sharing;
206 file->drive_type = drive_type;
208 file->next = file_hash[hash];
209 file_hash[hash] = file;
210 if (file->flags & FILE_FLAG_OVERLAPPED)
212 init_async_queue (&file->read_q);
213 init_async_queue (&file->write_q);
216 /* FIXME: should set error to STATUS_OBJECT_NAME_COLLISION if file existed before */
217 if (!(file->fd = alloc_fd( &file_fd_ops, &file->obj )) ||
218 !(file->fd = open_fd( file->fd, name, flags | O_NONBLOCK | O_LARGEFILE, &mode )))
220 release_object( file );
223 /* refuse to open a directory */
224 if (S_ISDIR(mode) && !(file->flags & FILE_FLAG_BACKUP_SEMANTICS))
226 set_error( STATUS_ACCESS_DENIED );
227 release_object( file );
237 /* check if two file objects point to the same file */
238 int is_same_file( struct file *file1, struct file *file2 )
240 return !strcmp( file1->name, file2->name );
243 /* get the type of drive the file is on */
244 int get_file_drive_type( struct file *file )
246 return file->drive_type;
249 /* create a temp file for anonymous mappings */
250 struct file *create_temp_file( int access )
255 sprintf( tmpfn, "anonmap.XXXXXX" ); /* create it in the server directory */
256 fd = mkstemps( tmpfn, 0 );
263 return create_file_for_fd( fd, access, 0, 0, DRIVE_FIXED );
266 static void file_dump( struct object *obj, int verbose )
268 struct file *file = (struct file *)obj;
269 assert( obj->ops == &file_ops );
270 fprintf( stderr, "File fd=%p flags=%08x name='%s'\n", file->fd, file->flags, file->name );
273 static int file_get_poll_events( struct fd *fd )
275 struct file *file = get_fd_user( fd );
277 assert( file->obj.ops == &file_ops );
278 if (file->access & GENERIC_READ) events |= POLLIN;
279 if (file->access & GENERIC_WRITE) events |= POLLOUT;
283 static void file_poll_event( struct fd *fd, int event )
285 struct file *file = get_fd_user( fd );
286 assert( file->obj.ops == &file_ops );
287 if ( file->flags & FILE_FLAG_OVERLAPPED )
289 if( IS_READY(file->read_q) && (POLLIN & event) )
291 async_notify(file->read_q.head, STATUS_ALERTED);
294 if( IS_READY(file->write_q) && (POLLOUT & event) )
296 async_notify(file->write_q.head, STATUS_ALERTED);
300 default_poll_event( fd, event );
304 static int file_flush( struct fd *fd )
306 int ret = (fsync( get_unix_fd(fd) ) != -1);
307 if (!ret) file_set_error();
311 static int file_get_info( struct fd *fd, struct get_file_info_reply *reply, int *flags )
314 struct file *file = get_fd_user( fd );
315 int unix_fd = get_unix_fd( fd );
319 if (fstat( unix_fd, &st ) == -1)
322 return FD_TYPE_INVALID;
324 if (S_ISCHR(st.st_mode) || S_ISFIFO(st.st_mode) ||
325 S_ISSOCK(st.st_mode) || isatty(unix_fd)) reply->type = FILE_TYPE_CHAR;
326 else reply->type = FILE_TYPE_DISK;
327 if (S_ISDIR(st.st_mode)) reply->attr = FILE_ATTRIBUTE_DIRECTORY;
328 else reply->attr = FILE_ATTRIBUTE_ARCHIVE;
329 if (!(st.st_mode & S_IWUSR)) reply->attr |= FILE_ATTRIBUTE_READONLY;
330 reply->access_time = st.st_atime;
331 reply->write_time = st.st_mtime;
332 if (S_ISDIR(st.st_mode))
334 reply->size_high = 0;
339 reply->size_high = st.st_size >> 32;
340 reply->size_low = st.st_size & 0xffffffff;
342 reply->links = st.st_nlink;
343 reply->index_high = st.st_dev;
344 reply->index_low = st.st_ino;
345 reply->serial = 0; /* FIXME */
348 if (file->flags & FILE_FLAG_OVERLAPPED) *flags |= FD_FLAG_OVERLAPPED;
349 return FD_TYPE_DEFAULT;
352 static void file_queue_async(struct fd *fd, void *ptr, unsigned int status, int type, int count)
354 struct file *file = get_fd_user( fd );
356 struct async_queue *q;
358 assert( file->obj.ops == &file_ops );
360 if ( !(file->flags & FILE_FLAG_OVERLAPPED) )
362 set_error ( STATUS_INVALID_HANDLE );
368 case ASYNC_TYPE_READ:
371 case ASYNC_TYPE_WRITE:
375 set_error( STATUS_INVALID_PARAMETER );
379 async = find_async ( q, current, ptr );
381 if ( status == STATUS_PENDING )
386 async = create_async ( &file->obj, current, ptr );
390 async->status = STATUS_PENDING;
392 async_insert( q, async );
394 /* Check if the new pending request can be served immediately */
395 events = check_fd_events( fd, file_get_poll_events( fd ) );
396 if (events) file_poll_event ( fd, events );
398 else if ( async ) destroy_async ( async );
399 else set_error ( STATUS_INVALID_PARAMETER );
401 set_fd_events( fd, file_get_poll_events( fd ));
404 static struct fd *file_get_fd( struct object *obj )
406 struct file *file = (struct file *)obj;
407 assert( obj->ops == &file_ops );
408 return (struct fd *)grab_object( file->fd );
411 static void file_destroy( struct object *obj )
413 struct file *file = (struct file *)obj;
414 assert( obj->ops == &file_ops );
418 /* remove it from the hashing list */
419 struct file **pptr = &file_hash[get_name_hash( file->name )];
420 while (*pptr && *pptr != file) pptr = &(*pptr)->next;
422 *pptr = (*pptr)->next;
423 if (file->flags & FILE_FLAG_DELETE_ON_CLOSE) unlink( file->name );
426 if (file->flags & FILE_FLAG_OVERLAPPED)
428 destroy_async_queue (&file->read_q);
429 destroy_async_queue (&file->write_q);
431 if (file->fd) release_object( file->fd );
434 /* set the last error depending on errno */
435 void file_set_error(void)
439 case EAGAIN: set_error( STATUS_SHARING_VIOLATION ); break;
440 case EBADF: set_error( STATUS_INVALID_HANDLE ); break;
441 case ENOSPC: set_error( STATUS_DISK_FULL ); break;
444 case EPERM: set_error( STATUS_ACCESS_DENIED ); break;
445 case EROFS: set_error( STATUS_MEDIA_WRITE_PROTECTED ); break;
446 case EBUSY: set_error( STATUS_FILE_LOCK_CONFLICT ); break;
447 case ENOENT: set_error( STATUS_NO_SUCH_FILE ); break;
448 case EISDIR: set_error( 0xc0010000 | ERROR_CANNOT_MAKE /* FIXME */ ); break;
450 case EMFILE: set_error( STATUS_NO_MORE_FILES ); break;
451 case EEXIST: set_error( STATUS_OBJECT_NAME_COLLISION ); break;
452 case EINVAL: set_error( STATUS_INVALID_PARAMETER ); break;
453 case ESPIPE: set_error( 0xc0010000 | ERROR_SEEK /* FIXME */ ); break;
454 case ENOTEMPTY: set_error( STATUS_DIRECTORY_NOT_EMPTY ); break;
455 case EIO: set_error( STATUS_ACCESS_VIOLATION ); break;
456 case EOVERFLOW: set_error( STATUS_INVALID_PARAMETER ); break;
457 default: perror("file_set_error"); set_error( ERROR_UNKNOWN /* FIXME */ ); break;
461 struct file *get_file_obj( struct process *process, obj_handle_t handle, unsigned int access )
463 return (struct file *)get_handle_obj( process, handle, access, &file_ops );
466 int get_file_unix_fd( struct file *file )
468 return get_unix_fd( file->fd );
471 static int set_file_pointer( obj_handle_t handle, unsigned int *low, int *high, int whence )
476 xto = *low+((off_t)*high<<32);
477 if (!(file = get_file_obj( current->process, handle, 0 )))
479 if ((result = lseek( get_file_unix_fd(file), xto, whence))==-1)
481 /* Check for seek before start of file */
483 /* also check EPERM due to SuSE7 2.2.16 lseek() EPERM kernel bug */
484 if (((errno == EINVAL) || (errno == EPERM))
485 && (whence != SEEK_SET) && (*high < 0))
486 set_error( 0xc0010000 | ERROR_NEGATIVE_SEEK /* FIXME */ );
489 release_object( file );
492 *low = result & 0xffffffff;
493 *high = result >> 32;
494 release_object( file );
498 /* extend a file beyond the current end of file */
499 static int extend_file( struct file *file, off_t size )
501 static const char zero;
502 int unix_fd = get_file_unix_fd( file );
504 /* extend the file one byte beyond the requested size and then truncate it */
505 /* this should work around ftruncate implementations that can't extend files */
506 if ((lseek( unix_fd, size, SEEK_SET ) != -1) &&
507 (write( unix_fd, &zero, 1 ) != -1))
509 ftruncate( unix_fd, size );
516 /* truncate file at current position */
517 static int truncate_file( struct file *file )
520 int unix_fd = get_file_unix_fd( file );
521 off_t pos = lseek( unix_fd, 0, SEEK_CUR );
522 off_t eof = lseek( unix_fd, 0, SEEK_END );
524 if (eof < pos) ret = extend_file( file, pos );
527 if (ftruncate( unix_fd, pos ) != -1) ret = 1;
528 else file_set_error();
530 lseek( unix_fd, pos, SEEK_SET ); /* restore file pos */
534 /* try to grow the file to the specified size */
535 int grow_file( struct file *file, int size_high, int size_low )
539 int unix_fd = get_file_unix_fd( file );
540 off_t old_pos, size = size_low + (((off_t)size_high)<<32);
542 if (fstat( unix_fd, &st ) == -1)
547 if (st.st_size >= size) return 1; /* already large enough */
548 old_pos = lseek( unix_fd, 0, SEEK_CUR ); /* save old pos */
549 ret = extend_file( file, size );
550 lseek( unix_fd, old_pos, SEEK_SET ); /* restore file pos */
554 static int set_file_time( obj_handle_t handle, time_t access_time, time_t write_time )
557 struct utimbuf utimbuf;
559 if (!(file = get_file_obj( current->process, handle, GENERIC_WRITE )))
563 set_error( STATUS_INVALID_HANDLE );
564 release_object( file );
567 if (!access_time || !write_time)
570 if (stat( file->name, &st ) == -1) goto error;
571 if (!access_time) access_time = st.st_atime;
572 if (!write_time) write_time = st.st_mtime;
574 utimbuf.actime = access_time;
575 utimbuf.modtime = write_time;
576 if (utime( file->name, &utimbuf ) == -1) goto error;
577 release_object( file );
581 release_object( file );
586 DECL_HANDLER(create_file)
591 if ((file = create_file( get_req_data(), get_req_data_size(), req->access,
592 req->sharing, req->create, req->attrs, req->drive_type )))
594 reply->handle = alloc_handle( current->process, file, req->access, req->inherit );
595 release_object( file );
599 /* allocate a file handle for a Unix fd */
600 DECL_HANDLER(alloc_file_handle)
606 if ((fd = thread_get_inflight_fd( current, req->fd )) == -1)
608 set_error( STATUS_INVALID_HANDLE );
611 if ((file = create_file_for_fd( fd, req->access, FILE_SHARE_READ | FILE_SHARE_WRITE,
614 reply->handle = alloc_handle( current->process, file, req->access, req->inherit );
615 release_object( file );
619 /* set a file current position */
620 DECL_HANDLER(set_file_pointer)
622 int high = req->high;
624 set_file_pointer( req->handle, &low, &high, req->whence );
625 reply->new_low = low;
626 reply->new_high = high;
629 /* truncate (or extend) a file */
630 DECL_HANDLER(truncate_file)
634 if ((file = get_file_obj( current->process, req->handle, GENERIC_WRITE )))
636 truncate_file( file );
637 release_object( file );
641 /* set a file access and modification times */
642 DECL_HANDLER(set_file_time)
644 set_file_time( req->handle, req->access_time, req->write_time );
647 /* lock a region of a file */
648 DECL_HANDLER(lock_file)
651 file_pos_t offset = ((file_pos_t)req->offset_high << 32) | req->offset_low;
652 file_pos_t count = ((file_pos_t)req->count_high << 32) | req->count_low;
654 if ((file = get_file_obj( current->process, req->handle, 0 )))
656 reply->handle = lock_fd( file->fd, offset, count, req->shared, req->wait );
657 reply->overlapped = (file->flags & FILE_FLAG_OVERLAPPED) != 0;
658 release_object( file );
662 /* unlock a region of a file */
663 DECL_HANDLER(unlock_file)
666 file_pos_t offset = ((file_pos_t)req->offset_high << 32) | req->offset_low;
667 file_pos_t count = ((file_pos_t)req->count_high << 32) | req->count_low;
669 if ((file = get_file_obj( current->process, req->handle, 0 )))
671 unlock_fd( file->fd, offset, count );
672 release_object( file );