Started moving functions that deal with Unix file descriptors to a
separate fd object. This will be needed for file locking.
diff --git a/server/fd.c b/server/fd.c
new file mode 100644
index 0000000..1dff6ef
--- /dev/null
+++ b/server/fd.c
@@ -0,0 +1,244 @@
+/*
+ * Server-side file descriptor management
+ *
+ * Copyright (C) 2003 Alexandre Julliard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+
+#include "config.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "object.h"
+#include "file.h"
+#include "handle.h"
+#include "process.h"
+#include "request.h"
+
+struct fd
+{
+ struct object obj; /* object header */
+ const struct fd_ops *fd_ops; /* file descriptor operations */
+ struct object *user; /* object using this file descriptor */
+ int unix_fd; /* unix file descriptor */
+ int mode; /* file protection mode */
+};
+
+static void fd_dump( struct object *obj, int verbose );
+static void fd_destroy( struct object *obj );
+
+static const struct object_ops fd_ops =
+{
+ sizeof(struct fd), /* size */
+ fd_dump, /* dump */
+ no_add_queue, /* add_queue */
+ NULL, /* remove_queue */
+ NULL, /* signaled */
+ NULL, /* satisfied */
+ default_get_fd, /* get_fd */
+ no_get_file_info, /* get_file_info */
+ fd_destroy /* destroy */
+};
+
+
+static void fd_dump( struct object *obj, int verbose )
+{
+ struct fd *fd = (struct fd *)obj;
+ fprintf( stderr, "Fd unix_fd=%d mode=%06o user=%p\n", fd->unix_fd, fd->mode, fd->user );
+}
+
+static void fd_destroy( struct object *obj )
+{
+#if 0
+ struct fd *fd = (struct fd *)obj;
+ close( fd->unix_fd );
+#endif
+}
+
+/* allocate an object that has an associated fd */
+void *alloc_fd_object( const struct object_ops *ops,
+ const struct fd_ops *fd_user_ops, int unix_fd )
+{
+ struct object *user;
+ struct fd *fd = alloc_object( &fd_ops, -1 );
+
+ if (!fd) return NULL;
+ if (!(user = alloc_object( ops, unix_fd )))
+ {
+ release_object( fd );
+ return NULL;
+ }
+ fd->fd_ops = fd_user_ops;
+ fd->user = user;
+ fd->unix_fd = unix_fd;
+ fd->mode = 0;
+
+ user->fd_obj = fd;
+ return user;
+}
+
+/* retrieve the unix fd for an object */
+int get_unix_fd( struct object *obj )
+{
+ struct fd *fd = obj->ops->get_fd( obj );
+ int unix_fd = -1;
+
+ if (fd)
+ {
+ unix_fd = fd->unix_fd;
+ release_object( fd );
+ }
+ return unix_fd;
+}
+
+/* set the unix fd for an object; can only be done once */
+void set_unix_fd( struct object *obj, int unix_fd )
+{
+ struct fd *fd = obj->fd_obj;
+
+ assert( fd );
+ assert( fd->unix_fd == -1 );
+
+ fd->unix_fd = unix_fd;
+ obj->fd = unix_fd;
+}
+
+/* close a file descriptor */
+void close_fd( struct fd *fd )
+{
+ release_object( fd );
+}
+
+/* callback for event happening in the main poll() loop */
+void fd_poll_event( struct object *obj, int event )
+{
+ struct fd *fd = obj->fd_obj;
+ return fd->fd_ops->poll_event( fd->user, event );
+}
+
+/* default add_queue() routine for objects that poll() on an fd */
+int default_fd_add_queue( struct object *obj, struct wait_queue_entry *entry )
+{
+ struct fd *fd = obj->fd_obj;
+
+ if (!obj->head) /* first on the queue */
+ set_select_events( obj, fd->fd_ops->get_poll_events( fd->user ) );
+ add_queue( obj, entry );
+ return 1;
+}
+
+/* default remove_queue() routine for objects that poll() on an fd */
+void default_fd_remove_queue( struct object *obj, struct wait_queue_entry *entry )
+{
+ grab_object( obj );
+ remove_queue( obj, entry );
+ if (!obj->head) /* last on the queue is gone */
+ set_select_events( obj, 0 );
+ release_object( obj );
+}
+
+/* default signaled() routine for objects that poll() on an fd */
+int default_fd_signaled( struct object *obj, struct thread *thread )
+{
+ struct fd *fd = obj->fd_obj;
+ int events = fd->fd_ops->get_poll_events( obj );
+
+ if (check_select_events( fd->unix_fd, events ))
+ {
+ /* stop waiting on select() if we are signaled */
+ set_select_events( obj, 0 );
+ return 1;
+ }
+ /* restart waiting on select() if we are no longer signaled */
+ if (obj->head) set_select_events( obj, events );
+ return 0;
+}
+
+/* default flush() routine */
+int no_flush( struct object *obj )
+{
+ set_error( STATUS_OBJECT_TYPE_MISMATCH );
+ return 0;
+}
+
+/* default queue_async() routine */
+void no_queue_async( struct object *obj, void* ptr, unsigned int status, int type, int count )
+{
+ set_error( STATUS_OBJECT_TYPE_MISMATCH );
+}
+
+/* same as get_handle_obj but retrieve the struct fd associated to the object */
+static struct fd *get_handle_fd_obj( struct process *process, obj_handle_t handle,
+ unsigned int access )
+{
+ struct fd *fd = NULL;
+ struct object *obj;
+
+ if ((obj = get_handle_obj( process, handle, 0, NULL )))
+ {
+ if (obj->fd_obj) fd = (struct fd *)grab_object( obj->fd_obj );
+ else set_error( STATUS_OBJECT_TYPE_MISMATCH );
+ release_object( obj );
+ }
+ return fd;
+}
+
+
+/* flush a file buffers */
+DECL_HANDLER(flush_file)
+{
+ struct fd *fd = get_handle_fd_obj( current->process, req->handle, 0 );
+
+ if (fd)
+ {
+ fd->fd_ops->flush( fd->user );
+ release_object( fd );
+ }
+}
+
+/* create / reschedule an async I/O */
+DECL_HANDLER(register_async)
+{
+ struct fd *fd = get_handle_fd_obj( current->process, req->handle, 0 );
+
+/*
+ * The queue_async method must do the following:
+ *
+ * 1. Get the async_queue for the request of given type.
+ * 2. Call find_async() to look for the specific client request in the queue (=> NULL if not found).
+ * 3. If status is STATUS_PENDING:
+ * a) If no async request found in step 2 (new request): call create_async() to initialize one.
+ * b) Set request's status to STATUS_PENDING.
+ * c) If the "queue" field of the async request is NULL: call async_insert() to put it into the queue.
+ * Otherwise:
+ * If the async request was found in step 2, destroy it by calling destroy_async().
+ * 4. Carry out any operations necessary to adjust the object's poll events
+ * Usually: set_elect_events (obj, obj->ops->get_poll_events()).
+ *
+ * See also the implementations in file.c, serial.c, and sock.c.
+*/
+
+ if (fd)
+ {
+ fd->fd_ops->queue_async( fd->user, req->overlapped, req->status, req->type, req->count );
+ release_object( fd );
+ }
+}
