2010-02-13 Jb Evain <jbevain@novell.com>

[mono-project.git] / mono / io-layer / daemon.c

/*
 * daemon.c:  The handle daemon
 *
 * Author:
 *      Dick Porter (dick@ximian.com)
 *
 * (C) 2002 Ximian, Inc.
 */

#include <config.h>
#include <glib.h>

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
#include <string.h>
#include <sys/time.h>

#ifdef HAVE_POLL
#include <sys/poll.h>
#endif

#include <mono/io-layer/io-layer.h>
#include <mono/io-layer/handles-private.h>
#include <mono/io-layer/wapi-private.h>
#include <mono/io-layer/daemon-messages.h>
#include <mono/io-layer/timefuncs-private.h>
#include <mono/io-layer/daemon-private.h>
#include <mono/io-layer/socket-wrappers.h>

#define LOGDEBUG(...)
#undef DEBUG
// #define LOGDEBUG(...) g_message(__VA_ARGS__)

/* The shared thread codepath doesn't seem to work yet... */
#undef _POSIX_THREAD_PROCESS_SHARED

/* Keep track of the number of clients */
static int nfds=0;

/* Arrays to keep track of channel data for the 
 * daemon and clients indexed by file descriptor
 * value.
 */

typedef struct _channel_data {
        int io_source; /* the ID given back by g_io_add_watch */
        guint32 *open_handles; /* array of open handles for this client */
} ChannelData;

static ChannelData *daemon_channel_data=NULL;
static ChannelData *channels=NULL;
static int channels_length=0;

/* The socket which we listen to new connections on */
static int main_sock;

/* Set to TRUE by the SIGCHLD signal handler */
static volatile gboolean check_processes=FALSE;

/* The file_share_hash is used to emulate the windows file sharing mode */
typedef struct _share_key
{
        dev_t device;
        ino_t inode;
} ShareKey;

typedef struct _share_data
{
        guint32 sharemode;
        guint32 access;
} ShareData;

static GHashTable *file_share_hash = NULL;

static gboolean fd_activity (GIOChannel *channel, GIOCondition condition,
                             gpointer data);
static void check_sharing (dev_t device, ino_t inode);

/* Deletes the shared memory segment.  If we're exiting on error,
 * clients will get EPIPEs.
 */
static void cleanup (void)
{
        int i;
        
#ifdef NEED_LINK_UNLINK
        unlink(_wapi_shared_data[0]->daemon);
#endif 
        for(i=1; i<_wapi_shared_data[0]->num_segments; i++) {
                unlink (_wapi_shm_file (WAPI_SHM_DATA, i));
        }
        unlink (_wapi_shm_file (WAPI_SHM_DATA, 0));
        
        /* There's only one scratch file */
        unlink (_wapi_shm_file (WAPI_SHM_SCRATCH, 0));
}

/* If there is only one socket, and no child processes, we can exit.
 * We test for child processes by counting handle references held by
 * the daemon.
 */
static void maybe_exit (void)
{
        guint32 i;

        LOGDEBUG ("%s: Seeing if we should exit", __func__);

        if(nfds>1) {
                LOGDEBUG ("%s: Still got clients", __func__);
                return;
        }

        /* Prevent new clients from connecting... */
        _wapi_shared_data[0]->daemon_running=DAEMON_CLOSING;

        for(i=0;
            i<_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT;
            i++) {
                if(daemon_channel_data->open_handles[i]>0) {
                        LOGDEBUG ("%s: Still got handle references", __func__);
                        _wapi_shared_data[0]->daemon_running=DAEMON_RUNNING;
                        return;
                }
        }
        
#ifdef HAVE_POLL
        /* Last check, make sure no client came along while we were
         * checking the handle lists.
         *
         * Use poll() directly here, as glib doesn't seem to have any
         * exposed way of seeing if a file descriptor is ready
         * (g_io_channel_get_buffer_condition() isn't it.)
         *
         * Crappy systems that don't have poll() will just have to
         * lump it (for them there is still the very slight chance
         * that someone tried to connect just as the DAEMON_CLOSING
         * flag was being set.)
         */
        {
                struct pollfd fds[1];
                
                fds[0].fd=main_sock;
                fds[0].events=POLLIN;
                fds[0].revents=0;
                
                LOGDEBUG ("%s: Last connect check", __func__);

                if(poll (fds, 1, 0)>0) {
                        /* Someone did connect, so carry on running */
                        LOGDEBUG ("%s: Someone connected", __func__);

                        _wapi_shared_data[0]->daemon_running=DAEMON_RUNNING;
                        return;
                }
        }
#endif
        
        LOGDEBUG ("%s: Byebye", __func__);
        
        cleanup ();
        exit (0);
}

/*
 * signal_handler:
 * @unused: unused
 *
 * Called if daemon receives a SIGTERM or SIGINT
 */
static void signal_handler (int signo)
{
        LOGDEBUG ("%s: daemon received signal %d", __func__, signo);

        cleanup ();
        exit (-1);
}

/*
 * sigchld_handler:
 * @unused: unused
 *
 * Called if daemon receives a SIGCHLD, and notes that a process needs
 * to be wait()ed for.
 */
static void sigchld_handler (int unused)
{
        /* Notice that a child process died */
        check_processes=TRUE;
}

static guint sharedata_hash (gconstpointer key)
{
        ShareKey *sharekey = (ShareKey *)key;
        
        return(g_int_hash (&(sharekey->inode)));
}

static gboolean sharedata_equal (gconstpointer a, gconstpointer b)
{
        ShareKey *share_a = (ShareKey *)a;
        ShareKey *share_b = (ShareKey *)b;
        
        return(share_a->device == share_b->device &&
               share_a->inode == share_b->inode);
}

/* Catch this here rather than corrupt the shared data at runtime */
#if MONO_SIZEOF_SUNPATH==0
#error configure failed to discover size of unix socket path
#endif

/*
 * startup:
 *
 * Bind signals, attach to shared memory and set up any internal data
 * structures needed.
 */
static void startup (void)
{
        struct sigaction sa;
        
        sa.sa_handler=signal_handler;
        sigemptyset (&sa.sa_mask);
        sa.sa_flags=0;
        sigaction (SIGINT, &sa, NULL);
        sigaction (SIGTERM, &sa, NULL);
        
#ifndef HAVE_MSG_NOSIGNAL
        sa.sa_handler=SIG_IGN;
        sigaction (SIGPIPE, &sa, NULL);
#endif

        sa.sa_handler=sigchld_handler;
        sa.sa_flags=SA_NOCLDSTOP;
        sigaction (SIGCHLD, &sa, NULL);
        
#ifdef NEED_LINK_UNLINK
        /* Here's a more portable method... */
        snprintf (_wapi_shared_data[0]->daemon, MONO_SIZEOF_SUNPATH-1,
                  "/tmp/mono-handle-daemon-%d-%ld-%ld", getuid (), random (),
                  time (NULL));
#else
        /* Leave the first byte NULL so we create the socket in the
         * abstrace namespace, not on the filesystem.  (Lets see how
         * portable _that_ is :)
         *
         * The name is intended to be unique, not cryptographically
         * secure...
         */
        snprintf (_wapi_shared_data[0]->daemon+1, MONO_SIZEOF_SUNPATH-2,
                  "mono-handle-daemon-%d-%d-%ld", getuid (), getpid (),
                  time (NULL));
#endif

        file_share_hash = g_hash_table_new_full (sharedata_hash,
                                                 sharedata_equal, g_free,
                                                 g_free);
}


/*
 * ref_handle:
 * @channel_data: Channel data for calling client
 * @handle: handle to inc refcnt
 *
 * Increase ref count of handle for the calling client.  Handle 0 is
 * ignored.
 */
static void ref_handle (ChannelData *channel_data, guint32 handle)
{
        guint32 segment, idx;
        
        if(handle==0) {
                return;
        }
        
        _wapi_handle_segment (GUINT_TO_POINTER (handle), &segment, &idx);
        
        _wapi_shared_data[segment]->handles[idx].ref++;
        channel_data->open_handles[handle]++;
        
        LOGDEBUG ("%s: handle 0x%x ref now %d (%d this process)", __func__, handle,
                  _wapi_shared_data[segment]->handles[idx].ref,
                  channel_data->open_handles[handle]);
}

/*
 * unref_handle:
 * @channel_data: Channel data for calling client
 * @handle: handle to inc refcnt
 *
 * Decrease ref count of handle for the calling client. If global ref
 * count reaches 0 it is free'ed. Return TRUE if the local ref count
 * is 0. Handle 0 is ignored.
 */
static gboolean unref_handle (ChannelData *channel_data, guint32 handle)
{
        gboolean destroy=FALSE;
        guint32 segment, idx;
        
        if(handle==0) {
                return(FALSE);
        }
        
        if (channel_data->open_handles[handle] == 0) {
                g_warning("%s: unref on %d called when ref was already 0", __func__, handle);
                return TRUE;
        }

        _wapi_handle_segment (GUINT_TO_POINTER (handle), &segment, &idx);
        
        _wapi_shared_data[segment]->handles[idx].ref--;
        channel_data->open_handles[handle]--;
        
        LOGDEBUG ("%s: handle 0x%x ref now %d (%d this process)", __func__, handle,
                   _wapi_shared_data[segment]->handles[idx].ref,
                   channel_data->open_handles[handle]);

        if (_wapi_shared_data[segment]->handles[idx].ref == 0) {
                gboolean was_file;
                dev_t device = 0;
                ino_t inode = 0;
                
                /* This client has released the handle */
                destroy=TRUE;
        
                if (channel_data->open_handles[handle]!=0) {
                        g_warning ("%s: per-process open_handles mismatch, set to %d, should be 0",__func__, channel_data->open_handles[handle]);
                }
                
                LOGDEBUG ("%s: Destroying handle 0x%x", __func__, handle);

                /* if this was a file handle, save the device and
                 * inode numbers so we can scan the share info data
                 * later to see if the last handle to a file has been
                 * closed, and delete the data if so.
                 */
                was_file = (_wapi_shared_data[segment]->handles[idx].type == WAPI_HANDLE_FILE);
                if (was_file) {
                        struct _WapiHandle_file *file_handle;
                        gboolean ok;
                        
                        ok = _wapi_lookup_handle (GUINT_TO_POINTER (handle),
                                                  WAPI_HANDLE_FILE,
                                                  (gpointer *)&file_handle,
                                                  NULL);
                        if (ok == FALSE) {
                                g_warning ("%s: error looking up file handle %x", __func__, handle);
                        } else {
                                device = file_handle->device;
                                inode = file_handle->inode;
                        }
                }
                
                _wapi_handle_ops_close_shared (GUINT_TO_POINTER (handle));
                
#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
                mono_mutex_destroy (&_wapi_shared_data[segment]->handles[idx].signal_mutex);
                pthread_cond_destroy (&_wapi_shared_data[segment]->handles[idx].signal_cond);
#endif

                memset (&_wapi_shared_data[segment]->handles[idx].u, '\0', sizeof(_wapi_shared_data[segment]->handles[idx].u));
                _wapi_shared_data[segment]->handles[idx].type=WAPI_HANDLE_UNUSED;

                if (was_file) {
                        check_sharing (device, inode);
                }
        }

        if(channel_data == daemon_channel_data) {
                /* The daemon released a reference, so see if it's
                 * ready to exit
                 */
                maybe_exit ();
        }
        
        return(destroy);
}

/*
 * add_fd:
 * @fd: Filehandle to add
 *
 * Create a new GIOChannel, and add it to the main loop event sources.
 */
static void add_fd(int fd, GMainContext *context)
{
        GIOChannel *io_channel;
        GSource *source;
        guint32 *refs;
        
        io_channel=g_io_channel_unix_new (fd);
        
        /* Turn off all encoding and buffering crap */
        g_io_channel_set_encoding (io_channel, NULL, NULL);
        g_io_channel_set_buffered (io_channel, FALSE);
        
        refs=g_new0 (guint32,_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT);

        if(fd>=channels_length) {
                /* Add a bit of padding, so we dont resize for _every_
                 * new connection
                 */
                int old_len=channels_length * sizeof(ChannelData);
                
                channels_length=fd+10;
                if(channels==NULL) {
                        channels=g_new0 (ChannelData, channels_length);
                        /* We rely on the daemon channel being created first.
                         * That's safe, because every other channel is the
                         * result of an accept() on the daemon channel.
                         */
                        daemon_channel_data = &channels[fd];
                } else {
                        int daemon_index=daemon_channel_data - channels;

                        /* Can't use g_renew here, because the unused
                         * elements must be NULL and g_renew doesn't
                         * initialise the memory it returns
                         */
                        channels=_wapi_g_renew0 (channels, old_len, channels_length * sizeof(ChannelData));
                        daemon_channel_data = channels + daemon_index;
                }

        }

        channels[fd].open_handles=refs;

        source = g_io_create_watch (io_channel, 
                                    G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL);
        g_source_set_callback (source, (GSourceFunc)fd_activity, 
                               context, NULL);
        channels[fd].io_source=g_source_attach (source, context);
        g_source_unref (source);

        nfds++;
}

/*
 * rem_fd:
 * @channel: GIOChannel to close
 *
 * Closes the IO channel. Closes all handles that it may have open. If
 * only main_sock is left, the daemon is shut down.
 */
static void rem_fd(GIOChannel *channel, ChannelData *channel_data)
{
        guint32 handle_count;
        int i, j, fd;
        
        fd=g_io_channel_unix_get_fd (channel);
        
        if(fd == main_sock) {
                /* We shouldn't be deleting the daemon's fd */
                g_warning ("%s: Deleting daemon fd!", __func__);
                cleanup ();
                exit (-1);
        }
        
        LOGDEBUG ("%s: Removing client fd %d", __func__, fd);

        if (channel_data->io_source == 0) {
                LOGDEBUG ("%s: channel already closed for fd %d", __func__, fd);
                return;
        }


        g_io_channel_shutdown (channel, TRUE, NULL);
        g_source_remove (channel_data->io_source);
        g_io_channel_unref (channel);

        for(i=0;
            i<_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT;
            i++) {
                handle_count=channel_data->open_handles[i];
                
                for(j=0; j<handle_count; j++) {
                        LOGDEBUG ("%s: closing handle 0x%x for client at index %d", __func__, i, g_io_channel_unix_get_fd (channel));
                        /* Ignore the hint to the client to destroy
                         * the handle private data
                         */
                        unref_handle (channel_data, i);
                }
        }
        
        g_free (channel_data->open_handles);
        channel_data->open_handles=NULL;
        channel_data->io_source=0;
        
        nfds--;
        if(nfds==1) {
                /* Just the master socket left, so see if we can
                 * cleanup and exit
                 */
                maybe_exit ();
        }
}

static void sharemode_set (dev_t device, ino_t inode, guint32 sharemode,
                           guint32 access)
{
        ShareKey *sharekey;
        ShareData *sharedata;
        
        sharekey = g_new (ShareKey, 1);
        sharekey->device = device;
        sharekey->inode = inode;

        sharedata = g_new (ShareData, 1);
        sharedata->sharemode = sharemode;
        sharedata->access = access;
        
        /* Setting share mode to include all access bits is really
         * removing the share info
         */
        if (sharemode == (FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE)) {
                g_hash_table_remove (file_share_hash, sharekey);
        } else {
                g_hash_table_insert (file_share_hash, sharekey, sharedata);
        }
}

static gboolean sharemode_get (dev_t device, ino_t inode, guint32 *sharemode,
                               guint32 *access)
{
        ShareKey sharekey;
        ShareData *sharedata;
        
        sharekey.device = device;
        sharekey.inode = inode;
        
        sharedata = (ShareData *)g_hash_table_lookup (file_share_hash,
                                                       &sharekey);
        if (sharedata == NULL) {
                return(FALSE);
        }
        
        *sharemode = sharedata->sharemode;
        *access = sharedata->access;
        
        return(TRUE);
}

static gboolean share_compare (gpointer handle, gpointer user_data)
{
        struct _WapiHandle_file *file_handle;
        gboolean ok;
        ShareKey *sharekey = (ShareKey *)user_data;
        
        ok = _wapi_lookup_handle (handle, WAPI_HANDLE_FILE,
                                  (gpointer *)&file_handle, NULL);
        if (ok == FALSE) {
                g_warning ("%s: error looking up file handle %p", __func__, handle);
                return(FALSE);
        }
        
        if (file_handle->device == sharekey->device &&
            file_handle->inode == sharekey->inode) {
                LOGDEBUG ("%s: found one, handle %p", __func__, handle);
                return(TRUE);
        } else {
                return(FALSE);
        }
}

static void check_sharing (dev_t device, ino_t inode)
{
        ShareKey sharekey;
        gpointer file_handle;
        
        LOGDEBUG ("%s: Checking if anything has (dev 0x%llx, inode %lld) still open", __func__, device, inode);

        sharekey.device = device;
        sharekey.inode = inode;
        
        file_handle = _wapi_search_handle (WAPI_HANDLE_FILE, share_compare,
                                           &sharekey, NULL, NULL);

        if (file_handle == NULL) {
                /* Delete this share info, as the last handle to it
                 * has been closed
                 */
                LOGDEBUG ("%s: Deleting share data for (dev 0x%llx inode %lld)", __func__, device, inode);
                
                g_hash_table_remove (file_share_hash, &sharekey);
        }
}

static gboolean process_compare (gpointer handle, gpointer user_data)
{
        struct _WapiHandle_process *process_handle;
        gboolean ok;
        pid_t pid;
        guint32 segment, idx;
        
        ok=_wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
                                (gpointer *)&process_handle, NULL);
        if(ok==FALSE) {
                g_warning ("%s: error looking up process handle %p", __func__, handle);
                return(FALSE);
        }

        _wapi_handle_segment (handle, &segment, &idx);
        if (_wapi_shared_data[segment]->handles[idx].signalled) {
                return(FALSE);
        }

        pid=GPOINTER_TO_UINT (user_data);
        if(process_handle->id==pid) {
                return(TRUE);
        } else {
                return(FALSE);
        }
}

static gboolean process_thread_compare (gpointer handle, gpointer user_data)
{
        struct _WapiHandle_thread *thread_handle;
        gboolean ok;
        guint32 segment, idx;
        
        ok=_wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
                                (gpointer *)&thread_handle, NULL);
        if(ok==FALSE) {
                g_warning ("%s: error looking up thread handle %p", __func__, handle);
                return(FALSE);
        }

        if(thread_handle->process_handle==user_data) {
                /* Signal the handle.  Don't use
                 * _wapi_handle_set_signal_state() unless we have
                 * process-shared pthread support.
                 */
                LOGDEBUG ("%s: Set thread handle %p signalled, because its process died", __func__, handle);

                thread_handle->exitstatus=0;

#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
                _wapi_handle_lock_handle (handle);
                _wapi_handle_set_signal_state (handle, TRUE, TRUE);
                _wapi_handle_unlock_handle (handle);
#else
                /* Just tweak the signal state directly.  This is not
                 * recommended behaviour, but it works for threads
                 * because they can never become unsignalled.  There
                 * are some nasty kludges in the handle waiting code
                 * to cope with missing condition signals for when
                 * process-shared pthread support is missing.
                 */
                _wapi_handle_segment (handle, &segment, &idx);
                _wapi_shared_data[segment]->handles[idx].signalled=TRUE;
#endif /* _POSIX_THREAD_PROCESS_SHARED */
        }
        
        /* Return false to keep searching */
        return(FALSE);
}

/* Find the handle associated with pid, mark it dead and record exit
 * status.  Finds all thread handles associated with this process
 * handle, and marks those signalled too, with exitstatus '0'.  It
 * also drops the daemon's reference to the handle, and the thread
 * pointed at by main_thread.
 */
static void process_post_mortem (pid_t pid, int status)
{
        gpointer process_handle;
        struct _WapiHandle_process *process_handle_data;
        guint32 segment, idx;
        
        process_handle=_wapi_search_handle (WAPI_HANDLE_PROCESS,
                                            process_compare,
                                            GUINT_TO_POINTER (pid),
                                            (gpointer *)&process_handle_data,
                                            NULL);
        if(process_handle==0) {
                /*
                 * This may happen if we use Process.EnableRaisingEvents +
                 * process.Exited event and the parent has finished.
                 */
                LOGDEBUG ("%s: Couldn't find handle for process %d!", __func__, pid);
        } else {
                /* Signal the handle.  Don't use
                 * _wapi_handle_set_signal_state() unless we have
                 * process-shared pthread support.
                 */
                struct timeval tv;
                
                LOGDEBUG ("%s: Set process %d exitstatus to %d", __func__, pid,
                           WEXITSTATUS (status));
                
                /* If the child terminated due to the receipt of a signal,
                 * the exit status must be based on WTERMSIG, since WEXITSTATUS
                 * returns 0 in this case.
                 */
                if (WIFSIGNALED(status))
                        process_handle_data->exitstatus=128 + WTERMSIG (status);
                else
                        process_handle_data->exitstatus=WEXITSTATUS (status);

                /* Ignore errors */
                gettimeofday (&tv, NULL);
                _wapi_timeval_to_filetime (&tv,
                                           &process_handle_data->exit_time);

#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
                _wapi_handle_lock_handle (process_handle);
                _wapi_handle_set_signal_state (process_handle, TRUE, TRUE);
                _wapi_handle_unlock_handle (process_handle);
#else
                /* Just tweak the signal state directly.  This is not
                 * recommended behaviour, but it works for processes
                 * because they can never become unsignalled.  There
                 * are some nasty kludges in the handle waiting code
                 * to cope with missing condition signals for when
                 * process-shared pthread support is missing.
                 */
                _wapi_handle_segment (process_handle, &segment, &idx);
                _wapi_shared_data[segment]->handles[idx].signalled=TRUE;
#endif /* _POSIX_THREAD_PROCESS_SHARED */
        }

        /* Find all threads that have their process
         * handle==process_handle.  Ignore the return value, all the
         * work will be done in the compare func
         */
        (void)_wapi_search_handle (WAPI_HANDLE_THREAD, process_thread_compare,
                                   process_handle, NULL, NULL);

        unref_handle (daemon_channel_data,
                      GPOINTER_TO_UINT (process_handle_data->main_thread));
        unref_handle (daemon_channel_data, GPOINTER_TO_UINT (process_handle));
}

static void process_died (void)
{
        int status;
        pid_t pid;
        
        check_processes=FALSE;

        LOGDEBUG ("%s: Reaping processes", __func__);

        while(TRUE) {
                pid=waitpid (-1, &status, WNOHANG);
                if(pid==0 || pid==-1) {
                        /* Finished waiting.  I was checking pid==-1
                         * separately but was getting ECHILD when
                         * there were no more child processes (which
                         * doesnt seem to conform to the man page)
                         */
                        return;
                } else {
                        /* pid contains the ID of a dead process */
                        LOGDEBUG ( "%s: process %d reaped", __func__, pid);
                        process_post_mortem (pid, status);
                }
        }
}


/*
 * send_reply:
 * @channel: channel to send reply to
 * @resp: Package to send
 *
 * Send a package to a client
 */
static void send_reply (GIOChannel *channel, WapiHandleResponse *resp)
{
        /* send message */
        _wapi_daemon_response (g_io_channel_unix_get_fd (channel), resp);
}

static guint32 new_handle_with_shared_check (WapiHandleType type)
{
        guint32 handle = 0;

        while ((handle = _wapi_handle_new_internal (type)) == 0) {
                /* Try and allocate a new shared segment, and have
                 * another go
                 */
                guint32 segment=_wapi_shared_data[0]->num_segments;
                int i;
                
                _wapi_handle_ensure_mapped (segment);
                if(_wapi_shared_data[segment]!=NULL) {
                        /* Got a new segment */
                        gulong old_len, new_len;
                        
                        old_len=_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT * sizeof(guint32);
                        _wapi_shared_data[0]->num_segments++;
                        new_len=_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT * sizeof(guint32);

                        /* Need to expand all the handle reference
                         * count arrays
                         */

                        for(i=0; i<channels_length; i++) {
                                if(channels[i].open_handles!=NULL) {
                                        channels[i].open_handles=_wapi_g_renew0 (channels[i].open_handles, old_len, new_len);
                                }
                        }
                } else {
                        /* Map failed.  Just return 0 meaning "out of
                         * handles"
                         */
                        break;
                }
        }
        
        return(handle);
}

/*
 * process_new:
 * @channel: The client making the request
 * @channel_data: Our data for this channel
 * @type: type to init handle to
 *
 * Find a free handle and initialize it to 'type', increase refcnt and
 * send back a reply to the client.
 */
static void process_new (GIOChannel *channel, ChannelData *channel_data,
                         WapiHandleType type)
{
        guint32 handle;
        WapiHandleResponse resp={0};
        
        handle = new_handle_with_shared_check (type);
        
        /* handle might still be set to 0.  This is handled at the
         * client end
         */

        ref_handle (channel_data, handle);

        LOGDEBUG ("%s: returning new handle 0x%x", __func__, handle);

        resp.type=WapiHandleResponseType_New;
        resp.u.new.type=type;
        resp.u.new.handle=handle;
                        
        send_reply (channel, &resp);
}

/*
 * process_open:
 * @channel: The client making the request
 * @channel_data: Our data for this channel
 * @handle: handle no.
 *
 * Increase refcnt on a previously created handle and send back a
 * response to the client.
 */
static void process_open (GIOChannel *channel, ChannelData *channel_data,
                          guint32 handle)
{
        WapiHandleResponse resp={0};
        guint32 segment, idx;
        struct _WapiHandleShared *shared;

        _wapi_handle_segment (GUINT_TO_POINTER (handle), &segment, &idx);
        shared=&_wapi_shared_data[segment]->handles[idx];
                
        if(shared->type!=WAPI_HANDLE_UNUSED && handle!=0) {
                ref_handle (channel_data, handle);

                LOGDEBUG ("%s: returning new handle 0x%x", __func__, handle);

                resp.type=WapiHandleResponseType_Open;
                resp.u.new.type=shared->type;
                resp.u.new.handle=handle;
                        
                send_reply (channel, &resp);

                return;
        }

        resp.type=WapiHandleResponseType_Open;
        resp.u.new.handle=0;
                        
        send_reply (channel, &resp);
}

/*
 * process_close:
 * @channel: The client making the request
 * @channel_data: Our data for this channel
 * @handle: handle no.
 *
 * Decrease refcnt on a previously created handle and send back a
 * response to the client with notice of it being destroyed.
 */
static void process_close (GIOChannel *channel, ChannelData *channel_data,
                           guint32 handle)
{
        WapiHandleResponse resp={0};
        
        resp.type=WapiHandleResponseType_Close;
        resp.u.close.destroy=unref_handle (channel_data, handle);

        LOGDEBUG ("%s: unreffing handle 0x%x", __func__, handle);

        send_reply (channel, &resp);
}

/*
 * process_scratch:
 * @channel: The client making the request
 * @length: allocate this much scratch space
 *
 * Allocate some scratch space and send a reply to the client.
 */
static void process_scratch (GIOChannel *channel, guint32 length)
{
        WapiHandleResponse resp={0};
        
        resp.type=WapiHandleResponseType_Scratch;
        resp.u.scratch.idx=_wapi_handle_scratch_store_internal (length, &resp.u.scratch.remap);

        LOGDEBUG ("%s: allocating scratch index 0x%x", __func__, resp.u.scratch.idx);
                        
        send_reply (channel, &resp);
}

/*
 * process_scratch_free:
 * @channel: The client making the request
 * @scratch_idx: deallocate this scratch space
 *
 * Deallocate scratch space and send a reply to the client.
 */
static void process_scratch_free (GIOChannel *channel, guint32 scratch_idx)
{
        WapiHandleResponse resp={0};
        
        resp.type=WapiHandleResponseType_ScratchFree;
        _wapi_handle_scratch_delete_internal (scratch_idx);

        LOGDEBUG ("%s: deleting scratch index 0x%x", __func__, scratch_idx);
                        
        send_reply (channel, &resp);
}

/*
 * process_process_kill:
 * @channel: The client making the request
 * @process_kill: pid and signal to send to the pid.
 *
 * Sends the specified signal to the process.
 */
static void
process_process_kill (GIOChannel *channel,
                      WapiHandleRequest_ProcessKill process_kill)
{
        WapiHandleResponse resp = {0};

        resp.type = WapiHandleResponseType_ProcessKill;

        LOGDEBUG ("%s: kill (%d, %d)", __func__, process_kill.pid, process_kill.signo);

        if (kill (process_kill.pid, process_kill.signo) == -1) {
                resp.u.process_kill.err = errno;
                LOGDEBUG ("%s: kill (%d, %d) failed: %d", __func__, process_kill.pid, process_kill.signo, resp.u.process_kill.err);
        }

        send_reply (channel, &resp);
}

/*
 * process_process_fork:
 * @channel: The client making the request
 * @process_fork: Describes the process to fork
 * @fds: stdin, stdout, and stderr for the new process
 *
 * Forks a new process, and returns the process and thread data to the
 * client.
 */
static void process_process_fork (GIOChannel *channel, ChannelData *channel_data,
                                  WapiHandleRequest_ProcessFork process_fork,
                                  int *fds)
{
        WapiHandleResponse resp={0};
        guint32 process_handle, thread_handle;
        struct _WapiHandle_process *process_handle_data;
        struct _WapiHandle_thread *thread_handle_data;
        pid_t pid = 0;
        
        resp.type=WapiHandleResponseType_ProcessFork;
        
        /* Create handles first, so the child process can store exec
         * errors.  Either handle might be set to 0, if this happens
         * just reply to the client without bothering to fork.  The
         * client must check if either handle is 0 and take
         * appropriate error handling action.
         */
        process_handle = new_handle_with_shared_check (WAPI_HANDLE_PROCESS);
        ref_handle (daemon_channel_data, process_handle);
        ref_handle (channel_data, process_handle);
        
        thread_handle = new_handle_with_shared_check (WAPI_HANDLE_THREAD);
        ref_handle (daemon_channel_data, thread_handle);
        ref_handle (channel_data, thread_handle);
        
        if(process_handle==0 || thread_handle==0) {
                /* unref_handle() copes with the handle being 0 */
                unref_handle (daemon_channel_data, process_handle);
                unref_handle (channel_data, process_handle);
                unref_handle (daemon_channel_data, thread_handle);
                unref_handle (channel_data, thread_handle);
                process_handle=0;
                thread_handle=0;
        } else {
                char *cmd=NULL, *dir=NULL, **argv, **env;
                GError *gerr=NULL;
                gboolean ret;
                struct timeval tv;
                
                /* Get usable copies of the cmd, dir and env now
                 * rather than in the child process.  This is to
                 * prevent the race condition where the parent can
                 * return the reply to the client, which then promptly
                 * deletes the scratch data before the new process
                 * gets to see it.  Also explode argv here so we can
                 * use it to set the process name.
                 */
                cmd=_wapi_handle_scratch_lookup (process_fork.cmd);
                dir=_wapi_handle_scratch_lookup (process_fork.dir);
                env=_wapi_handle_scratch_lookup_string_array (process_fork.env);

                _wapi_lookup_handle (GUINT_TO_POINTER (process_handle),
                                     WAPI_HANDLE_PROCESS,
                                     (gpointer *)&process_handle_data,
                                     NULL);

                _wapi_lookup_handle (GUINT_TO_POINTER (thread_handle),
                                     WAPI_HANDLE_THREAD,
                                     (gpointer *)&thread_handle_data,
                                     NULL);
                
                ret=g_shell_parse_argv (cmd, NULL, &argv, &gerr);
                if(ret==FALSE) {
                        /* FIXME: Could do something with the
                         * GError here
                         */
                        process_handle_data->exec_errno=gerr->code;
                } else {
                        LOGDEBUG ("%s: forking", __func__);

                        /* Fork, exec cmd with args and optional env,
                         * and return the handles with pid and blank
                         * thread id
                         */
                        pid=fork ();
                        if(pid==-1) {
                                process_handle_data->exec_errno=errno;
                        } else if (pid==0) {
                                /* child */
                                int i;
                                
                                /* should we detach from the process
                                 * group? We're already running
                                 * without a controlling tty...
                                 */

                                /* Connect stdin, stdout and stderr */
                                dup2 (fds[0], 0);
                                dup2 (fds[1], 1);
                                dup2 (fds[2], 2);

                                if(process_fork.inherit!=TRUE) {
                                        /* FIXME: do something here */
                                }
                                
                                /* Close all file descriptors */
                                for (i = getdtablesize () - 1; i > 2; i--) {
                                        close (i);
                                }
                        
                                /* pass process and thread handle info
                                 * to the child, so it doesn't have to
                                 * do an expensive search over the
                                 * whole list
                                 */
                                {
                                        guint env_count=0;
                                        
                                        while(env[env_count]!=NULL) {
                                                env_count++;
                                        }

                                        env=(char **)g_renew (char **, env, env_count+3);
                                        
                                        env[env_count]=g_strdup_printf ("_WAPI_PROCESS_HANDLE=%d", process_handle);
                                        env[env_count+1]=g_strdup_printf ("_WAPI_THREAD_HANDLE=%d", thread_handle);
                                        env[env_count+2]=NULL;
                                }

#ifdef DEBUG
                                LOGDEBUG ("%s: exec()ing [%s] in dir [%s]", __func__, cmd, dir);
                                {
                                        i=0;
                                        while(argv[i]!=NULL) {
                                                LOGDEBUG ("arg %d: [%s]", i, argv[i]);
                                                i++;
                                        }

                                        i=0;
                                        while(env[i]!=NULL) {
                                                LOGDEBUG ("env %d: [%s]", i, env[i]);
                                                i++;
                                        }
                                }
#endif
                        
                                /* set cwd */
                                if(chdir (dir)==-1) {
                                        process_handle_data->exec_errno=errno;
                                        exit (-1);
                                }
                                
                                /* exec */
                                execve (argv[0], argv, env);
                
                                /* bummer! */
                                process_handle_data->exec_errno=errno;
                                exit (-1);
                        }
                }
                /* parent */

                /* store process name, based on the last section of the cmd */
                {
                        char *slash;
                        
                        /* This should never fail, but it seems it can...
                         */
                        if (argv[0] != NULL) {
                                slash=strrchr (argv[0], '/');
                        
                                if(slash!=NULL) {
                                        process_handle_data->proc_name=_wapi_handle_scratch_store (slash+1, strlen (slash+1));
                                } else {
                                        process_handle_data->proc_name=_wapi_handle_scratch_store (argv[0], strlen (argv[0]));
                                }
                        } else {
                                process_handle_data->proc_name = _wapi_handle_scratch_store (cmd, strlen(cmd));
                        }
                }
                
                /* These seem to be the defaults on w2k */
                process_handle_data->min_working_set=204800;
                process_handle_data->max_working_set=1413120;
                
                if(cmd!=NULL) {
                        g_free (cmd);
                }
                if(dir!=NULL) {
                        g_free (dir);
                }
                g_strfreev (argv);
                g_strfreev (env);
                
                /* store pid */
                process_handle_data->id=pid;
                process_handle_data->main_thread=GUINT_TO_POINTER (thread_handle);
                /* Ignore errors */
                gettimeofday (&tv, NULL);
                _wapi_timeval_to_filetime (&tv,
                                           &process_handle_data->create_time);
                
                /* FIXME: if env==0, inherit the env from the current
                 * process
                 */
                process_handle_data->env=process_fork.env;

                thread_handle_data->process_handle=GUINT_TO_POINTER (process_handle);

                resp.u.process_fork.pid=pid;
        }

        resp.u.process_fork.process_handle=process_handle;
        resp.u.process_fork.thread_handle=thread_handle;

        send_reply (channel, &resp);
}

/*
 * process_set_share:
 * @channel: The client making the request
 * @channel_data: The channel data
 * @set_share: Set share data passed from the client
 *
 * Sets file share info
 */
static void process_set_share (GIOChannel *channel, ChannelData *channel_data,
                               WapiHandleRequest_SetShare set_share)
{
        WapiHandleResponse resp = {0};

        resp.type = WapiHandleResponseType_SetShare;
        
        LOGDEBUG ("%s: Setting share for file (dev:0x%llx, ino:%lld) mode 0x%x access 0x%x", __func__, set_share.device, set_share.inode, set_share.sharemode, set_share.access);
        
        sharemode_set (set_share.device, set_share.inode, set_share.sharemode,
                       set_share.access);
        
        send_reply (channel, &resp);
}

/*
 * process_get_or_set_share:
 * @channel: The client making the request
 * @channel_data: The channel data
 * @get_share: GetOrSetShare data passed from the client
 *
 * Gets a file share status, and sets the status if it doesn't already
 * exist
 */
static void process_get_or_set_share (GIOChannel *channel,
                                      ChannelData *channel_data,
                                      WapiHandleRequest_GetOrSetShare get_share)
{
        WapiHandleResponse resp = {0};
        
        resp.type = WapiHandleResponseType_GetOrSetShare;
        
        LOGDEBUG ("%s: Getting share status for file (dev:0x%llx, ino:%lld)", __func__, get_share.device, get_share.inode);

        resp.u.get_or_set_share.exists = sharemode_get (get_share.device, get_share.inode, &resp.u.get_or_set_share.sharemode, &resp.u.get_or_set_share.access);
        
        if (resp.u.get_or_set_share.exists) {
                LOGDEBUG ("%s: Share mode: 0x%x", __func__, resp.u.get_or_set_share.sharemode);
        } else {
                LOGDEBUG ("%s: file share info not already known, setting", __func__);
                sharemode_set (get_share.device, get_share.inode,
                               get_share.new_sharemode, get_share.new_access);
        }
        
        send_reply (channel, &resp);
}

/*
 * read_message:
 * @channel: The client to read the request from
 * @open_handles: An array of handles referenced by this client
 *
 * Read a message (A WapiHandleRequest) from a client and dispatch
 * whatever it wants to the process_* calls.  Return TRUE if the message
 * was read successfully, FALSE otherwise.
 */
static gboolean read_message (GIOChannel *channel, ChannelData *channel_data)
{
        WapiHandleRequest req;
        int fds[3]={0, 1, 2};
        int ret;
        gboolean has_fds=FALSE;
        
        /* Reading data */
        ret=_wapi_daemon_request (g_io_channel_unix_get_fd (channel), &req,
                                  fds, &has_fds);
        if(ret==0) {
                /* Other end went away */
                LOGDEBUG ("Read 0 bytes on fd %d, closing it",
                           g_io_channel_unix_get_fd (channel));
                rem_fd (channel, channel_data);
                return(FALSE);
        }
        
        LOGDEBUG ("Process request %d", req.type);
        switch(req.type) {
        case WapiHandleRequestType_New:
                process_new (channel, channel_data, req.u.new.type);
                break;
        case WapiHandleRequestType_Open:
#ifdef DEBUG
                g_assert(req.u.open.handle < _wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT);
#endif
                process_open (channel, channel_data, req.u.open.handle);
                break;
        case WapiHandleRequestType_Close:
#ifdef DEBUG
                g_assert(req.u.close.handle < _wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT);
#endif
                process_close (channel, channel_data, req.u.close.handle);
                break;
        case WapiHandleRequestType_Scratch:
                process_scratch (channel, req.u.scratch.length);
                break;
        case WapiHandleRequestType_ScratchFree:
                process_scratch_free (channel, req.u.scratch_free.idx);
                break;
        case WapiHandleRequestType_ProcessFork:
                process_process_fork (channel, channel_data,
                                      req.u.process_fork, fds);
                break;
        case WapiHandleRequestType_ProcessKill:
                process_process_kill (channel, req.u.process_kill);
                break;
        case WapiHandleRequestType_SetShare:
                process_set_share (channel, channel_data, req.u.set_share);
                break;
        case WapiHandleRequestType_GetOrSetShare:
                process_get_or_set_share (channel, channel_data,
                                          req.u.get_or_set_share);
                break;
        case WapiHandleRequestType_Error:
                /* fall through */
        default:
                /* Catch bogus requests */
                /* FIXME: call rem_fd? */
                break;
        }

        if(has_fds==TRUE) {
                LOGDEBUG ("%s: closing %d", __func__, fds[0]);
                LOGDEBUG ("%s: closing %d", __func__, fds[1]);
                LOGDEBUG ("%s: closing %d", __func__, fds[2]);
                
                close (fds[0]);
                close (fds[1]);
                close (fds[2]);
        }

        return(TRUE);
}

/*
 * fd_activity:
 * @channel: The IO channel that is active
 * @condition: The condition that has been satisfied
 * @data: A pointer to an array of handles referenced by this client
 *
 * The callback called by the main loop when there is activity on an
 * IO channel.
 */
static gboolean fd_activity (GIOChannel *channel, GIOCondition condition,
                             gpointer data)
{
        int fd=g_io_channel_unix_get_fd (channel);
        ChannelData *channel_data=&channels[fd];
        GMainContext *context=data;
        
        if(condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
                LOGDEBUG ("fd %d error", fd);
                rem_fd (channel, channel_data);
                return(FALSE);
        }

        if(condition & (_IO_PRI)) {
                if(fd==main_sock) {
                        int newsock;
                        struct sockaddr addr;
                        socklen_t addrlen=sizeof(struct sockaddr);
                        
                        newsock=accept (main_sock, &addr, &addrlen);
                        if(newsock==-1) {
                                g_critical ("%s accept error: %s", __func__, g_strerror (errno));
                                cleanup ();
                                exit (-1);
                        }

                        LOGDEBUG ("accept returning %d", newsock);
                        add_fd (newsock, context);
                } else {
                        LOGDEBUG ("reading data on fd %d", fd);

                        return(read_message (channel, channel_data));
                }
                return(TRUE);
        }
        
        return(FALSE);  /* remove source */
}

/*
 * _wapi_daemon_main:
 *
 * Open socket, create shared mem segment and begin listening for
 * clients.
 */
void _wapi_daemon_main(gpointer data, gpointer scratch)
{
        struct sockaddr_un main_socket_address;
        int ret;
        GMainContext *context;

        LOGDEBUG ("Starting up...");

        _wapi_shared_data[0]=data;
        _wapi_shared_scratch=scratch;
        _wapi_shared_scratch->is_shared=TRUE;
        
        /* Note that we've got the starting segment already */
        _wapi_shared_data[0]->num_segments=1;
        _wapi_shm_mapped_segments=1;

        _wapi_fd_offset_table_size=getdtablesize ();
        _wapi_shared_data[0]->fd_offset_table_size = _wapi_fd_offset_table_size;
        
        startup ();
        
        main_sock=socket(PF_UNIX, SOCK_STREAM, 0);

        main_socket_address.sun_family=AF_UNIX;
        memcpy(main_socket_address.sun_path, _wapi_shared_data[0]->daemon,
               MONO_SIZEOF_SUNPATH);

        ret=bind(main_sock, (struct sockaddr *)&main_socket_address,
                 sizeof(struct sockaddr_un));
        if(ret==-1) {
                g_critical ("bind failed: %s", g_strerror (errno));
                _wapi_shared_data[0]->daemon_running=DAEMON_DIED_AT_STARTUP;
                exit(-1);
        }

        LOGDEBUG("bound");

        ret=listen(main_sock, 5);
        if(ret==-1) {
                g_critical ("listen failed: %s", g_strerror (errno));
                _wapi_shared_data[0]->daemon_running=DAEMON_DIED_AT_STARTUP;
                exit(-1);
        }
        LOGDEBUG("listening");

        context = g_main_context_new ();

        add_fd(main_sock, context);

        /* We're finished setting up, let everyone else know we're
         * ready.  From now on, it's up to us to delete the shared
         * memory segment when appropriate.
         */
        _wapi_shared_data[0]->daemon_running=DAEMON_RUNNING;

        while(TRUE) {
                if(check_processes==TRUE) {
                        process_died ();
                }
                
                LOGDEBUG ("polling");

                /* Block until something happens. We don't use
                 * g_main_loop_run() because we rely on the SIGCHLD
                 * signal interrupting poll() so we can reap child
                 * processes as soon as they die, without burning cpu
                 * time by polling the flag.
                 */
                g_main_context_iteration (context, TRUE);
        }
}