server/file.c

   1 /*
   2  * Server-side file management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <fcntl.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <errno.h>
  12 #include <sys/errno.h>
  13 #include <sys/stat.h>
  14 #include <sys/time.h>
  15 #include <sys/types.h>
  16 #include <time.h>
  17 #include <unistd.h>
  18
  19 #include "winerror.h"
  20 #include "winnt.h"
  21 #include "server/thread.h"
  22
  23 struct file
  24 {
  25     struct object  obj;             /* object header */
  26     int            fd;              /* Unix file descriptor */
  27     int            event;           /* possible events on this file */
  28 };
  29
  30 static void file_dump( struct object *obj, int verbose );
  31 static int file_add_queue( struct object *obj, struct wait_queue_entry *entry );
  32 static void file_remove_queue( struct object *obj, struct wait_queue_entry *entry );
  33 static int file_signaled( struct object *obj, struct thread *thread );
  34 static int file_get_read_fd( struct object *obj );
  35 static int file_get_write_fd( struct object *obj );
  36 static int file_flush( struct object *obj );
  37 static void file_destroy( struct object *obj );
  38
  39 static const struct object_ops file_ops =
  40 {
  41     file_dump,
  42     file_add_queue,
  43     file_remove_queue,
  44     file_signaled,
  45     no_satisfied,
  46     file_get_read_fd,
  47     file_get_write_fd,
  48     file_flush,
  49     file_destroy
  50 };
  51
  52 static const struct select_ops select_ops =
  53 {
  54     default_select_event,
  55     NULL   /* we never set a timeout on a file */
  56 };
  57
  58 struct object *create_file( int fd )
  59 {
  60     struct file *file;
  61     int flags;
  62
  63     if ((flags = fcntl( fd, F_GETFL )) == -1)
  64     {
  65         perror( "fcntl" );
  66         return NULL;
  67     }
  68     if (!(file = mem_alloc( sizeof(*file) ))) return NULL;
  69     init_object( &file->obj, &file_ops, NULL );
  70     file->fd = fd;
  71     switch(flags & 3)
  72     {
  73     case O_RDONLY:
  74         file->event = READ_EVENT;
  75         break;
  76     case O_WRONLY:
  77         file->event = WRITE_EVENT;
  78         break;
  79     case O_RDWR:
  80         file->event = READ_EVENT | WRITE_EVENT;
  81         break;
  82     }
  83     CLEAR_ERROR();
  84     return &file->obj;
  85 }
  86
  87 static void file_dump( struct object *obj, int verbose )
  88 {
  89     struct file *file = (struct file *)obj;
  90     assert( obj->ops == &file_ops );
  91     printf( "File fd=%d\n", file->fd );
  92 }
  93
  94 static int file_add_queue( struct object *obj, struct wait_queue_entry *entry )
  95 {
  96     struct file *file = (struct file *)obj;
  97     assert( obj->ops == &file_ops );
  98     if (!obj->head)  /* first on the queue */
  99     {
 100         if (!add_select_user( file->fd, READ_EVENT | WRITE_EVENT, &select_ops, file ))
 101         {
 102             SET_ERROR( ERROR_OUTOFMEMORY );
 103             return 0;
 104         }
 105     }
 106     add_queue( obj, entry );
 107     return 1;
 108 }
 109
 110 static void file_remove_queue( struct object *obj, struct wait_queue_entry *entry )
 111 {
 112     struct file *file = (struct file *)grab_object(obj);
 113     assert( obj->ops == &file_ops );
 114
 115     remove_queue( obj, entry );
 116     if (!obj->head)  /* last on the queue is gone */
 117         remove_select_user( file->fd );
 118     release_object( obj );
 119 }
 120
 121 static int file_signaled( struct object *obj, struct thread *thread )
 122 {
 123     fd_set read_fds, write_fds;
 124     struct timeval tv = { 0, 0 };
 125
 126     struct file *file = (struct file *)obj;
 127     assert( obj->ops == &file_ops );
 128
 129     FD_ZERO( &read_fds );
 130     FD_ZERO( &write_fds );
 131     if (file->event & READ_EVENT) FD_SET( file->fd, &read_fds );
 132     if (file->event & WRITE_EVENT) FD_SET( file->fd, &write_fds );
 133     return select( file->fd + 1, &read_fds, &write_fds, NULL, &tv ) > 0;
 134 }
 135
 136 static int file_get_read_fd( struct object *obj )
 137 {
 138     struct file *file = (struct file *)obj;
 139     assert( obj->ops == &file_ops );
 140
 141     if (!(file->event & READ_EVENT))  /* FIXME: should not be necessary */
 142     {
 143         SET_ERROR( ERROR_ACCESS_DENIED );
 144         return -1;
 145     }
 146     return dup( file->fd );
 147 }
 148
 149 static int file_get_write_fd( struct object *obj )
 150 {
 151     struct file *file = (struct file *)obj;
 152     assert( obj->ops == &file_ops );
 153
 154     if (!(file->event & WRITE_EVENT))  /* FIXME: should not be necessary */
 155     {
 156         SET_ERROR( ERROR_ACCESS_DENIED );
 157         return -1;
 158     }
 159     return dup( file->fd );
 160 }
 161
 162 static int file_flush( struct object *obj )
 163 {
 164     int ret;
 165     struct file *file = (struct file *)grab_object(obj);
 166     assert( obj->ops == &file_ops );
 167
 168     ret = (fsync( file->fd ) != -1);
 169     if (!ret) file_set_error();
 170     release_object( file );
 171     return ret;
 172 }
 173
 174 static void file_destroy( struct object *obj )
 175 {
 176     struct file *file = (struct file *)obj;
 177     assert( obj->ops == &file_ops );
 178     close( file->fd );
 179     free( file );
 180 }
 181
 182 /* set the last error depending on errno */
 183 void file_set_error(void)
 184 {
 185     switch (errno)
 186     {
 187     case EAGAIN:    SET_ERROR( ERROR_SHARING_VIOLATION ); break;
 188     case EBADF:     SET_ERROR( ERROR_INVALID_HANDLE ); break;
 189     case ENOSPC:    SET_ERROR( ERROR_HANDLE_DISK_FULL ); break;
 190     case EACCES:
 191     case EPERM:     SET_ERROR( ERROR_ACCESS_DENIED ); break;
 192     case EROFS:     SET_ERROR( ERROR_WRITE_PROTECT ); break;
 193     case EBUSY:     SET_ERROR( ERROR_LOCK_VIOLATION ); break;
 194     case ENOENT:    SET_ERROR( ERROR_FILE_NOT_FOUND ); break;
 195     case EISDIR:    SET_ERROR( ERROR_CANNOT_MAKE ); break;
 196     case ENFILE:
 197     case EMFILE:    SET_ERROR( ERROR_NO_MORE_FILES ); break;
 198     case EEXIST:    SET_ERROR( ERROR_FILE_EXISTS ); break;
 199     case EINVAL:    SET_ERROR( ERROR_INVALID_PARAMETER ); break;
 200     case ESPIPE:    SET_ERROR( ERROR_SEEK ); break;
 201     case ENOTEMPTY: SET_ERROR( ERROR_DIR_NOT_EMPTY ); break;
 202     default:        perror("file_set_error"); SET_ERROR( ERROR_UNKNOWN ); break;
 203     }
 204 }
 205
 206 struct file *get_file_obj( struct process *process, int handle,
 207                            unsigned int access )
 208 {
 209     return (struct file *)get_handle_obj( current->process, handle,
 210                                           access, &file_ops );
 211 }
 212
 213 int file_get_mmap_fd( struct file *file )
 214 {
 215     return dup( file->fd );
 216 }
 217
 218 int set_file_pointer( int handle, int *low, int *high, int whence )
 219 {
 220     struct file *file;
 221     int result;
 222
 223     if (*high)
 224     {
 225         fprintf( stderr, "set_file_pointer: offset > 4Gb not supported yet\n" );
 226         SET_ERROR( ERROR_INVALID_PARAMETER );
 227         return 0;
 228     }
 229
 230     if (!(file = get_file_obj( current->process, handle, 0 )))
 231         return 0;
 232     if ((result = lseek( file->fd, *low, whence )) == -1)
 233     {
 234         /* Check for seek before start of file */
 235         if ((errno == EINVAL) && (whence != SEEK_SET) && (*low < 0))
 236             SET_ERROR( ERROR_NEGATIVE_SEEK );
 237         else
 238             file_set_error();
 239         release_object( file );
 240         return 0;
 241     }
 242     *low = result;
 243     release_object( file );
 244     return 1;
 245 }
 246
 247 int truncate_file( int handle )
 248 {
 249     struct file *file;
 250     int result;
 251
 252     if (!(file = get_file_obj( current->process, handle, GENERIC_WRITE )))
 253         return 0;
 254     if (((result = lseek( file->fd, 0, SEEK_CUR )) == -1) ||
 255         (ftruncate( file->fd, result ) == -1))
 256     {
 257         file_set_error();
 258         release_object( file );
 259         return 0;
 260     }
 261     release_object( file );
 262     return 1;
 263
 264 }
 265
 266 int get_file_info( int handle, struct get_file_info_reply *reply )
 267 {
 268     struct file *file;
 269     struct stat st;
 270
 271     if (!(file = get_file_obj( current->process, handle, 0 )))
 272         return 0;
 273     if (fstat( file->fd, &st ) == -1)
 274     {
 275         file_set_error();
 276         release_object( file );
 277         return 0;
 278     }
 279     if (S_ISDIR(st.st_mode)) reply->attr = FILE_ATTRIBUTE_DIRECTORY;
 280     else reply->attr = FILE_ATTRIBUTE_ARCHIVE;
 281     if (!(st.st_mode & S_IWUSR)) reply->attr |= FILE_ATTRIBUTE_READONLY;
 282     reply->access_time = st.st_atime;
 283     reply->write_time  = st.st_mtime;
 284     reply->size_high   = 0;
 285     reply->size_low    = S_ISDIR(st.st_mode) ? 0 : st.st_size;
 286     reply->links       = st.st_nlink;
 287     reply->index_high  = st.st_dev;
 288     reply->index_low   = st.st_ino;
 289     reply->serial      = 0; /* FIXME */
 290
 291     release_object( file );
 292     return 1;
 293 }