2 * daemon.c: The handle daemon
5 * Dick Porter (dick@ximian.com)
7 * (C) 2002 Ximian, Inc.
14 #include <sys/types.h>
15 #include <sys/socket.h>
29 #include <mono/io-layer/io-layer.h>
30 #include <mono/io-layer/handles-private.h>
31 #include <mono/io-layer/wapi-private.h>
32 #include <mono/io-layer/daemon-messages.h>
33 #include <mono/io-layer/timefuncs-private.h>
34 #include <mono/io-layer/daemon-private.h>
35 #include <mono/io-layer/socket-wrappers.h>
39 /* The shared thread codepath doesn't seem to work yet... */
40 #undef _POSIX_THREAD_PROCESS_SHARED
42 /* Keep track of the number of clients */
45 /* Arrays to keep track of channel data for the
46 * daemon and clients indexed by file descriptor
50 typedef struct _channel_data {
51 int io_source; /* the ID given back by g_io_add_watch */
52 guint32 *open_handles; /* array of open handles for this client */
55 static ChannelData *daemon_channel_data=NULL;
56 static ChannelData *channels=NULL;
57 static int channels_length=0;
59 /* The socket which we listen to new connections on */
62 /* Set to TRUE by the SIGCHLD signal handler */
63 static volatile gboolean check_processes=FALSE;
65 /* The file_share_hash is used to emulate the windows file sharing mode */
66 typedef struct _share_key
72 typedef struct _share_data
78 static GHashTable *file_share_hash = NULL;
80 static gboolean fd_activity (GIOChannel *channel, GIOCondition condition,
82 static void check_sharing (dev_t device, ino_t inode);
84 /* Deletes the shared memory segment. If we're exiting on error,
85 * clients will get EPIPEs.
87 static void cleanup (void)
91 #ifdef NEED_LINK_UNLINK
92 unlink(_wapi_shared_data[0]->daemon);
94 for(i=1; i<_wapi_shared_data[0]->num_segments; i++) {
95 unlink (_wapi_shm_file (WAPI_SHM_DATA, i));
97 unlink (_wapi_shm_file (WAPI_SHM_DATA, 0));
99 /* There's only one scratch file */
100 unlink (_wapi_shm_file (WAPI_SHM_SCRATCH, 0));
103 /* If there is only one socket, and no child processes, we can exit.
104 * We test for child processes by counting handle references held by
107 static void maybe_exit (void)
112 g_message (G_GNUC_PRETTY_FUNCTION ": Seeing if we should exit");
117 g_message (G_GNUC_PRETTY_FUNCTION ": Still got clients");
122 /* Prevent new clients from connecting... */
123 _wapi_shared_data[0]->daemon_running=DAEMON_CLOSING;
126 i<_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT;
128 if(daemon_channel_data->open_handles[i]>0) {
130 g_message (G_GNUC_PRETTY_FUNCTION
131 ": Still got handle references");
134 _wapi_shared_data[0]->daemon_running=DAEMON_RUNNING;
140 /* Last check, make sure no client came along while we were
141 * checking the handle lists.
143 * Use poll() directly here, as glib doesn't seem to have any
144 * exposed way of seeing if a file descriptor is ready
145 * (g_io_channel_get_buffer_condition() isn't it.)
147 * Crappy systems that don't have poll() will just have to
148 * lump it (for them there is still the very slight chance
149 * that someone tried to connect just as the DAEMON_CLOSING
150 * flag was being set.)
153 struct pollfd fds[1];
156 fds[0].events=POLLIN;
160 g_message (G_GNUC_PRETTY_FUNCTION ": Last connect check");
163 if(poll (fds, 1, 0)>0) {
164 /* Someone did connect, so carry on running */
166 g_message (G_GNUC_PRETTY_FUNCTION
167 ": Someone connected");
170 _wapi_shared_data[0]->daemon_running=DAEMON_RUNNING;
177 g_message (G_GNUC_PRETTY_FUNCTION ": Byebye");
188 * Called if daemon receives a SIGTERM or SIGINT
190 static void signal_handler (int signo)
193 g_message (G_GNUC_PRETTY_FUNCTION ": daemon received signal %d", signo);
203 * Called if daemon receives a SIGCHLD, and notes that a process needs
204 * to be wait()ed for.
206 static void sigchld_handler (int unused)
208 /* Notice that a child process died */
209 check_processes=TRUE;
212 static guint sharedata_hash (gconstpointer key)
214 ShareKey *sharekey = (ShareKey *)key;
216 return(g_int_hash (&(sharekey->inode)));
219 static gboolean sharedata_equal (gconstpointer a, gconstpointer b)
221 ShareKey *share_a = (ShareKey *)a;
222 ShareKey *share_b = (ShareKey *)b;
224 return(share_a->device == share_b->device &&
225 share_a->inode == share_b->inode);
231 * Bind signals, attach to shared memory and set up any internal data
234 static void startup (void)
238 sa.sa_handler=signal_handler;
239 sigemptyset (&sa.sa_mask);
241 sigaction (SIGINT, &sa, NULL);
242 sigaction (SIGTERM, &sa, NULL);
244 #ifndef HAVE_MSG_NOSIGNAL
245 sa.sa_handler=SIG_IGN;
246 sigaction (SIGPIPE, &sa, NULL);
249 sa.sa_handler=sigchld_handler;
250 sa.sa_flags=SA_NOCLDSTOP;
251 sigaction (SIGCHLD, &sa, NULL);
253 #ifdef NEED_LINK_UNLINK
254 /* Here's a more portable method... */
255 snprintf (_wapi_shared_data[0]->daemon, MONO_SIZEOF_SUNPATH-1,
256 "/tmp/mono-handle-daemon-%d-%ld-%ld", getuid (), random (),
259 /* Leave the first byte NULL so we create the socket in the
260 * abstrace namespace, not on the filesystem. (Lets see how
261 * portable _that_ is :)
263 * The name is intended to be unique, not cryptographically
266 snprintf (_wapi_shared_data[0]->daemon+1, MONO_SIZEOF_SUNPATH-2,
267 "mono-handle-daemon-%d-%d-%ld", getuid (), getpid (),
271 file_share_hash = g_hash_table_new_full (sharedata_hash,
272 sharedata_equal, g_free,
279 * @channel_data: Channel data for calling client
280 * @handle: handle to inc refcnt
282 * Increase ref count of handle for the calling client. Handle 0 is
285 static void ref_handle (ChannelData *channel_data, guint32 handle)
287 guint32 segment, idx;
293 _wapi_handle_segment (GUINT_TO_POINTER (handle), &segment, &idx);
295 _wapi_shared_data[segment]->handles[idx].ref++;
296 channel_data->open_handles[handle]++;
299 g_message (G_GNUC_PRETTY_FUNCTION
300 ": handle 0x%x ref now %d (%d this process)", handle,
301 _wapi_shared_data[segment]->handles[idx].ref,
302 channel_data->open_handles[handle]);
308 * @channel_data: Channel data for calling client
309 * @handle: handle to inc refcnt
311 * Decrease ref count of handle for the calling client. If global ref
312 * count reaches 0 it is free'ed. Return TRUE if the local ref count
313 * is 0. Handle 0 is ignored.
315 static gboolean unref_handle (ChannelData *channel_data, guint32 handle)
317 gboolean destroy=FALSE;
318 guint32 segment, idx;
324 if (channel_data->open_handles[handle] == 0) {
325 g_warning(G_GNUC_PRETTY_FUNCTION
326 ": unref on %d called when ref was already 0",
331 _wapi_handle_segment (GUINT_TO_POINTER (handle), &segment, &idx);
333 _wapi_shared_data[segment]->handles[idx].ref--;
334 channel_data->open_handles[handle]--;
337 g_message (G_GNUC_PRETTY_FUNCTION
338 ": handle 0x%x ref now %d (%d this process)", handle,
339 _wapi_shared_data[segment]->handles[idx].ref,
340 channel_data->open_handles[handle]);
343 if(channel_data->open_handles[handle]==0) {
344 /* This client has released the handle */
348 if(_wapi_shared_data[segment]->handles[idx].ref==0) {
353 if (channel_data->open_handles[handle]!=0) {
354 g_warning (G_GNUC_PRETTY_FUNCTION ": per-process open_handles mismatch, set to %d, should be 0",
355 channel_data->open_handles[handle]);
359 g_message (G_GNUC_PRETTY_FUNCTION ": Destroying handle 0x%x",
363 /* if this was a file handle, save the device and
364 * inode numbers so we can scan the share info data
365 * later to see if the last handle to a file has been
366 * closed, and delete the data if so.
368 was_file = (_wapi_shared_data[segment]->handles[idx].type == WAPI_HANDLE_FILE);
370 struct _WapiHandle_file *file_handle;
373 ok = _wapi_lookup_handle (GUINT_TO_POINTER (handle),
375 (gpointer *)&file_handle,
378 g_warning (G_GNUC_PRETTY_FUNCTION
379 ": error looking up file handle %x",
382 device = file_handle->device;
383 inode = file_handle->inode;
387 _wapi_handle_ops_close_shared (GUINT_TO_POINTER (handle));
389 #if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
390 mono_mutex_destroy (&_wapi_shared_data[segment]->handles[idx].signal_mutex);
391 pthread_cond_destroy (&_wapi_shared_data[segment]->handles[idx].signal_cond);
394 memset (&_wapi_shared_data[segment]->handles[idx].u, '\0', sizeof(_wapi_shared_data[segment]->handles[idx].u));
395 _wapi_shared_data[segment]->handles[idx].type=WAPI_HANDLE_UNUSED;
398 check_sharing (device, inode);
402 if(channel_data == daemon_channel_data) {
403 /* The daemon released a reference, so see if it's
414 * @fd: Filehandle to add
416 * Create a new GIOChannel, and add it to the main loop event sources.
418 static void add_fd(int fd, GMainContext *context)
420 GIOChannel *io_channel;
424 io_channel=g_io_channel_unix_new (fd);
426 /* Turn off all encoding and buffering crap */
427 g_io_channel_set_encoding (io_channel, NULL, NULL);
428 g_io_channel_set_buffered (io_channel, FALSE);
430 refs=g_new0 (guint32,_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT);
432 if(fd>=channels_length) {
433 /* Add a bit of padding, so we dont resize for _every_
436 int old_len=channels_length * sizeof(ChannelData);
438 channels_length=fd+10;
440 channels=g_new0 (ChannelData, channels_length);
441 /* We rely on the daemon channel being created first.
442 * That's safe, because every other channel is the
443 * result of an accept() on the daemon channel.
445 daemon_channel_data = &channels[fd];
447 int daemon_index=daemon_channel_data - channels;
449 /* Can't use g_renew here, because the unused
450 * elements must be NULL and g_renew doesn't
451 * initialise the memory it returns
453 channels=_wapi_g_renew0 (channels, old_len, channels_length * sizeof(ChannelData));
454 daemon_channel_data = channels + daemon_index;
459 channels[fd].open_handles=refs;
461 source = g_io_create_watch (io_channel,
462 G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL);
463 g_source_set_callback (source, (GSourceFunc)fd_activity,
465 channels[fd].io_source=g_source_attach (source, context);
466 g_source_unref (source);
473 * @channel: GIOChannel to close
475 * Closes the IO channel. Closes all handles that it may have open. If
476 * only main_sock is left, the daemon is shut down.
478 static void rem_fd(GIOChannel *channel, ChannelData *channel_data)
480 guint32 handle_count;
483 fd=g_io_channel_unix_get_fd (channel);
485 if(fd == main_sock) {
486 /* We shouldn't be deleting the daemon's fd */
487 g_warning (G_GNUC_PRETTY_FUNCTION ": Deleting daemon fd!");
493 g_message (G_GNUC_PRETTY_FUNCTION ": Removing client fd %d", fd);
496 if (channel_data->io_source == 0) {
498 g_message (G_GNUC_PRETTY_FUNCTION ": channel already closed for fd %d", fd);
504 g_io_channel_shutdown (channel, TRUE, NULL);
505 g_source_remove (channel_data->io_source);
506 g_io_channel_unref (channel);
509 i<_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT;
511 handle_count=channel_data->open_handles[i];
513 for(j=0; j<handle_count; j++) {
515 g_message (G_GNUC_PRETTY_FUNCTION ": closing handle 0x%x for client at index %d", i, g_io_channel_unix_get_fd (channel));
517 /* Ignore the hint to the client to destroy
518 * the handle private data
520 unref_handle (channel_data, i);
524 g_free (channel_data->open_handles);
525 channel_data->open_handles=NULL;
526 channel_data->io_source=0;
530 /* Just the master socket left, so see if we can
537 static void sharemode_set (dev_t device, ino_t inode, guint32 sharemode,
541 ShareData *sharedata;
543 sharekey = g_new (ShareKey, 1);
544 sharekey->device = device;
545 sharekey->inode = inode;
547 sharedata = g_new (ShareData, 1);
548 sharedata->sharemode = sharemode;
549 sharedata->access = access;
551 /* Setting share mode to include all access bits is really
552 * removing the share info
554 if (sharemode == (FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE)) {
555 g_hash_table_remove (file_share_hash, sharekey);
557 g_hash_table_insert (file_share_hash, sharekey, sharedata);
561 static gboolean sharemode_get (dev_t device, ino_t inode, guint32 *sharemode,
565 ShareData *sharedata;
567 sharekey.device = device;
568 sharekey.inode = inode;
570 sharedata = (ShareData *)g_hash_table_lookup (file_share_hash,
572 if (sharedata == NULL) {
576 *sharemode = sharedata->sharemode;
577 *access = sharedata->access;
582 static gboolean share_compare (gpointer handle, gpointer user_data)
584 struct _WapiHandle_file *file_handle;
586 ShareKey *sharekey = (ShareKey *)user_data;
588 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_FILE,
589 (gpointer *)&file_handle, NULL);
591 g_warning (G_GNUC_PRETTY_FUNCTION
592 ": error looking up file handle %p", handle);
596 if (file_handle->device == sharekey->device &&
597 file_handle->inode == sharekey->inode) {
599 g_message (G_GNUC_PRETTY_FUNCTION ": found one, handle %p",
608 static void check_sharing (dev_t device, ino_t inode)
611 gpointer file_handle;
614 g_message (G_GNUC_PRETTY_FUNCTION ": Checking if anything has (dev 0x%llx, inode %lld) still open", device, inode);
617 sharekey.device = device;
618 sharekey.inode = inode;
620 file_handle = _wapi_search_handle (WAPI_HANDLE_FILE, share_compare,
621 &sharekey, NULL, NULL);
623 if (file_handle == NULL) {
624 /* Delete this share info, as the last handle to it
628 g_message (G_GNUC_PRETTY_FUNCTION ": Deleting share data for (dev 0x%llx inode %lld)", device, inode);
631 g_hash_table_remove (file_share_hash, &sharekey);
635 static gboolean process_compare (gpointer handle, gpointer user_data)
637 struct _WapiHandle_process *process_handle;
640 guint32 segment, idx;
642 ok=_wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
643 (gpointer *)&process_handle, NULL);
645 g_warning (G_GNUC_PRETTY_FUNCTION
646 ": error looking up process handle %p", handle);
650 _wapi_handle_segment (handle, &segment, &idx);
651 if (_wapi_shared_data[segment]->handles[idx].signalled) {
655 pid=GPOINTER_TO_UINT (user_data);
656 if(process_handle->id==pid) {
663 static gboolean process_thread_compare (gpointer handle, gpointer user_data)
665 struct _WapiHandle_thread *thread_handle;
667 guint32 segment, idx;
669 ok=_wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
670 (gpointer *)&thread_handle, NULL);
672 g_warning (G_GNUC_PRETTY_FUNCTION
673 ": error looking up thread handle %p", handle);
677 if(thread_handle->process_handle==user_data) {
678 /* Signal the handle. Don't use
679 * _wapi_handle_set_signal_state() unless we have
680 * process-shared pthread support.
683 g_message (G_GNUC_PRETTY_FUNCTION ": Set thread handle %p signalled, because its process died", handle);
686 thread_handle->exitstatus=0;
688 #if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
689 _wapi_handle_lock_handle (handle);
690 _wapi_handle_set_signal_state (handle, TRUE, TRUE);
691 _wapi_handle_unlock_handle (handle);
693 /* Just tweak the signal state directly. This is not
694 * recommended behaviour, but it works for threads
695 * because they can never become unsignalled. There
696 * are some nasty kludges in the handle waiting code
697 * to cope with missing condition signals for when
698 * process-shared pthread support is missing.
700 _wapi_handle_segment (handle, &segment, &idx);
701 _wapi_shared_data[segment]->handles[idx].signalled=TRUE;
702 #endif /* _POSIX_THREAD_PROCESS_SHARED */
705 /* Return false to keep searching */
709 /* Find the handle associated with pid, mark it dead and record exit
710 * status. Finds all thread handles associated with this process
711 * handle, and marks those signalled too, with exitstatus '0'. It
712 * also drops the daemon's reference to the handle, and the thread
713 * pointed at by main_thread.
715 static void process_post_mortem (pid_t pid, int status)
717 gpointer process_handle;
718 struct _WapiHandle_process *process_handle_data;
719 guint32 segment, idx;
721 process_handle=_wapi_search_handle (WAPI_HANDLE_PROCESS,
723 GUINT_TO_POINTER (pid),
724 (gpointer *)&process_handle_data,
726 if(process_handle==0) {
729 * This may happen if we use Process.EnableRaisingEvents +
730 * process.Exited event and the parent has finished.
732 g_warning (G_GNUC_PRETTY_FUNCTION
733 ": Couldn't find handle for process %d!", pid);
736 /* Signal the handle. Don't use
737 * _wapi_handle_set_signal_state() unless we have
738 * process-shared pthread support.
743 g_message (G_GNUC_PRETTY_FUNCTION
744 ": Set process %d exitstatus to %d", pid,
745 WEXITSTATUS (status));
748 /* If the child terminated due to the receipt of a signal,
749 * the exit status must be based on WTERMSIG, since WEXITSTATUS
750 * returns 0 in this case.
752 if (WIFSIGNALED(status))
753 process_handle_data->exitstatus=128 + WTERMSIG (status);
755 process_handle_data->exitstatus=WEXITSTATUS (status);
758 gettimeofday (&tv, NULL);
759 _wapi_timeval_to_filetime (&tv,
760 &process_handle_data->exit_time);
762 #if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
763 _wapi_handle_lock_handle (process_handle);
764 _wapi_handle_set_signal_state (process_handle, TRUE, TRUE);
765 _wapi_handle_unlock_handle (process_handle);
767 /* Just tweak the signal state directly. This is not
768 * recommended behaviour, but it works for processes
769 * because they can never become unsignalled. There
770 * are some nasty kludges in the handle waiting code
771 * to cope with missing condition signals for when
772 * process-shared pthread support is missing.
774 _wapi_handle_segment (process_handle, &segment, &idx);
775 _wapi_shared_data[segment]->handles[idx].signalled=TRUE;
776 #endif /* _POSIX_THREAD_PROCESS_SHARED */
779 /* Find all threads that have their process
780 * handle==process_handle. Ignore the return value, all the
781 * work will be done in the compare func
783 (void)_wapi_search_handle (WAPI_HANDLE_THREAD, process_thread_compare,
784 process_handle, NULL, NULL);
786 unref_handle (daemon_channel_data,
787 GPOINTER_TO_UINT (process_handle_data->main_thread));
788 unref_handle (daemon_channel_data, GPOINTER_TO_UINT (process_handle));
791 static void process_died (void)
796 check_processes=FALSE;
799 g_message (G_GNUC_PRETTY_FUNCTION ": Reaping processes");
803 pid=waitpid (-1, &status, WNOHANG);
804 if(pid==0 || pid==-1) {
805 /* Finished waiting. I was checking pid==-1
806 * separately but was getting ECHILD when
807 * there were no more child processes (which
808 * doesnt seem to conform to the man page)
812 /* pid contains the ID of a dead process */
814 g_message (G_GNUC_PRETTY_FUNCTION ": process %d reaped", pid);
816 process_post_mortem (pid, status);
824 * @channel: channel to send reply to
825 * @resp: Package to send
827 * Send a package to a client
829 static void send_reply (GIOChannel *channel, WapiHandleResponse *resp)
832 _wapi_daemon_response (g_io_channel_unix_get_fd (channel), resp);
837 * @channel: The client making the request
838 * @channel_data: Our data for this channel
839 * @type: type to init handle to
841 * Find a free handle and initialize it to 'type', increase refcnt and
842 * send back a reply to the client.
844 static void process_new (GIOChannel *channel, ChannelData *channel_data,
848 WapiHandleResponse resp={0};
850 handle=_wapi_handle_new_internal (type);
852 /* Try and allocate a new shared segment, and have
855 guint32 segment=_wapi_shared_data[0]->num_segments;
858 _wapi_handle_ensure_mapped (segment);
859 if(_wapi_shared_data[segment]!=NULL) {
860 /* Got a new segment */
861 gulong old_len, new_len;
863 old_len=_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT * sizeof(guint32);
864 _wapi_shared_data[0]->num_segments++;
865 new_len=_wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT * sizeof(guint32);
867 /* Need to expand all the handle reference
871 for(i=0; i<channels_length; i++) {
872 if(channels[i].open_handles!=NULL) {
873 channels[i].open_handles=_wapi_g_renew0 (channels[i].open_handles, old_len, new_len);
877 handle=_wapi_handle_new_internal (type);
879 /* Map failed. Just return 0 meaning "out of
885 /* handle might still be set to 0. This is handled at the
889 ref_handle (channel_data, handle);
892 g_message (G_GNUC_PRETTY_FUNCTION ": returning new handle 0x%x",
896 resp.type=WapiHandleResponseType_New;
897 resp.u.new.type=type;
898 resp.u.new.handle=handle;
900 send_reply (channel, &resp);
905 * @channel: The client making the request
906 * @channel_data: Our data for this channel
907 * @handle: handle no.
909 * Increase refcnt on a previously created handle and send back a
910 * response to the client.
912 static void process_open (GIOChannel *channel, ChannelData *channel_data,
915 WapiHandleResponse resp={0};
916 guint32 segment, idx;
917 struct _WapiHandleShared *shared;
919 _wapi_handle_segment (GUINT_TO_POINTER (handle), &segment, &idx);
920 shared=&_wapi_shared_data[segment]->handles[idx];
922 if(shared->type!=WAPI_HANDLE_UNUSED && handle!=0) {
923 ref_handle (channel_data, handle);
926 g_message (G_GNUC_PRETTY_FUNCTION
927 ": returning new handle 0x%x", handle);
930 resp.type=WapiHandleResponseType_Open;
931 resp.u.new.type=shared->type;
932 resp.u.new.handle=handle;
934 send_reply (channel, &resp);
939 resp.type=WapiHandleResponseType_Open;
942 send_reply (channel, &resp);
947 * @channel: The client making the request
948 * @channel_data: Our data for this channel
949 * @handle: handle no.
951 * Decrease refcnt on a previously created handle and send back a
952 * response to the client with notice of it being destroyed.
954 static void process_close (GIOChannel *channel, ChannelData *channel_data,
957 WapiHandleResponse resp={0};
959 resp.type=WapiHandleResponseType_Close;
960 resp.u.close.destroy=unref_handle (channel_data, handle);
963 g_message (G_GNUC_PRETTY_FUNCTION ": unreffing handle 0x%x", handle);
966 send_reply (channel, &resp);
971 * @channel: The client making the request
972 * @length: allocate this much scratch space
974 * Allocate some scratch space and send a reply to the client.
976 static void process_scratch (GIOChannel *channel, guint32 length)
978 WapiHandleResponse resp={0};
980 resp.type=WapiHandleResponseType_Scratch;
981 resp.u.scratch.idx=_wapi_handle_scratch_store_internal (length, &resp.u.scratch.remap);
983 g_message (G_GNUC_PRETTY_FUNCTION ": allocating scratch index 0x%x",
987 send_reply (channel, &resp);
991 * process_scratch_free:
992 * @channel: The client making the request
993 * @scratch_idx: deallocate this scratch space
995 * Deallocate scratch space and send a reply to the client.
997 static void process_scratch_free (GIOChannel *channel, guint32 scratch_idx)
999 WapiHandleResponse resp={0};
1001 resp.type=WapiHandleResponseType_ScratchFree;
1002 _wapi_handle_scratch_delete_internal (scratch_idx);
1005 g_message (G_GNUC_PRETTY_FUNCTION ": deleting scratch index 0x%x",
1009 send_reply (channel, &resp);
1013 * process_process_kill:
1014 * @channel: The client making the request
1015 * @process_kill: pid and signal to send to the pid.
1017 * Sends the specified signal to the process.
1020 process_process_kill (GIOChannel *channel,
1021 WapiHandleRequest_ProcessKill process_kill)
1023 WapiHandleResponse resp = {0};
1025 resp.type = WapiHandleResponseType_ProcessKill;
1028 g_message (G_GNUC_PRETTY_FUNCTION ": kill (%d, %d)",
1029 process_kill.pid, process_kill.signo);
1031 if (kill (process_kill.pid, process_kill.signo) == -1) {
1032 resp.u.process_kill.err = errno;
1034 g_message (G_GNUC_PRETTY_FUNCTION ": kill (%d, %d) failed: %d",
1035 process_kill.pid, process_kill.signo, resp.u.process_kill.err);
1039 send_reply (channel, &resp);
1043 * process_process_fork:
1044 * @channel: The client making the request
1045 * @process_fork: Describes the process to fork
1046 * @fds: stdin, stdout, and stderr for the new process
1048 * Forks a new process, and returns the process and thread data to the
1051 static void process_process_fork (GIOChannel *channel, ChannelData *channel_data,
1052 WapiHandleRequest_ProcessFork process_fork,
1055 WapiHandleResponse resp={0};
1056 guint32 process_handle, thread_handle;
1057 struct _WapiHandle_process *process_handle_data;
1058 struct _WapiHandle_thread *thread_handle_data;
1061 resp.type=WapiHandleResponseType_ProcessFork;
1063 /* Create handles first, so the child process can store exec
1064 * errors. Either handle might be set to 0, if this happens
1065 * just reply to the client without bothering to fork. The
1066 * client must check if either handle is 0 and take
1067 * appropriate error handling action.
1069 process_handle=_wapi_handle_new_internal (WAPI_HANDLE_PROCESS);
1070 ref_handle (daemon_channel_data, process_handle);
1071 ref_handle (channel_data, process_handle);
1073 thread_handle=_wapi_handle_new_internal (WAPI_HANDLE_THREAD);
1074 ref_handle (daemon_channel_data, thread_handle);
1075 ref_handle (channel_data, thread_handle);
1077 if(process_handle==0 || thread_handle==0) {
1078 /* unref_handle() copes with the handle being 0 */
1079 unref_handle (daemon_channel_data, process_handle);
1080 unref_handle (channel_data, process_handle);
1081 unref_handle (daemon_channel_data, thread_handle);
1082 unref_handle (channel_data, thread_handle);
1086 char *cmd=NULL, *dir=NULL, **argv, **env;
1091 /* Get usable copies of the cmd, dir and env now
1092 * rather than in the child process. This is to
1093 * prevent the race condition where the parent can
1094 * return the reply to the client, which then promptly
1095 * deletes the scratch data before the new process
1096 * gets to see it. Also explode argv here so we can
1097 * use it to set the process name.
1099 cmd=_wapi_handle_scratch_lookup (process_fork.cmd);
1100 dir=_wapi_handle_scratch_lookup (process_fork.dir);
1101 env=_wapi_handle_scratch_lookup_string_array (process_fork.env);
1103 ret=g_shell_parse_argv (cmd, NULL, &argv, &gerr);
1105 /* FIXME: Could do something with the
1108 process_handle_data->exec_errno=gerr->code;
1111 g_message (G_GNUC_PRETTY_FUNCTION ": forking");
1114 _wapi_lookup_handle (GUINT_TO_POINTER (process_handle),
1115 WAPI_HANDLE_PROCESS,
1116 (gpointer *)&process_handle_data,
1119 _wapi_lookup_handle (GUINT_TO_POINTER (thread_handle),
1121 (gpointer *)&thread_handle_data,
1124 /* Fork, exec cmd with args and optional env,
1125 * and return the handles with pid and blank
1130 process_handle_data->exec_errno=errno;
1131 } else if (pid==0) {
1135 /* should we detach from the process
1136 * group? We're already running
1137 * without a controlling tty...
1140 /* Connect stdin, stdout and stderr */
1145 if(process_fork.inherit!=TRUE) {
1146 /* FIXME: do something here */
1149 /* Close all file descriptors */
1150 for (i = getdtablesize () - 1; i > 2; i--) {
1154 /* pass process and thread handle info
1155 * to the child, so it doesn't have to
1156 * do an expensive search over the
1162 while(env[env_count]!=NULL) {
1166 env=(char **)g_renew (char **, env, env_count+3);
1168 env[env_count]=g_strdup_printf ("_WAPI_PROCESS_HANDLE=%d", process_handle);
1169 env[env_count+1]=g_strdup_printf ("_WAPI_THREAD_HANDLE=%d", thread_handle);
1170 env[env_count+2]=NULL;
1174 g_message (G_GNUC_PRETTY_FUNCTION
1175 ": exec()ing [%s] in dir [%s]",
1179 while(argv[i]!=NULL) {
1180 g_message ("arg %d: [%s]",
1186 while(env[i]!=NULL) {
1187 g_message ("env %d: [%s]",
1195 if(chdir (dir)==-1) {
1196 process_handle_data->exec_errno=errno;
1201 execve (argv[0], argv, env);
1204 process_handle_data->exec_errno=errno;
1210 /* store process name, based on the last section of the cmd */
1212 char *slash=strrchr (argv[0], '/');
1215 process_handle_data->proc_name=_wapi_handle_scratch_store (slash+1, strlen (slash+1));
1217 process_handle_data->proc_name=_wapi_handle_scratch_store (argv[0], strlen (argv[0]));
1221 /* These seem to be the defaults on w2k */
1222 process_handle_data->min_working_set=204800;
1223 process_handle_data->max_working_set=1413120;
1235 process_handle_data->id=pid;
1236 process_handle_data->main_thread=GUINT_TO_POINTER (thread_handle);
1238 gettimeofday (&tv, NULL);
1239 _wapi_timeval_to_filetime (&tv,
1240 &process_handle_data->create_time);
1242 /* FIXME: if env==0, inherit the env from the current
1245 process_handle_data->env=process_fork.env;
1247 thread_handle_data->process_handle=GUINT_TO_POINTER (process_handle);
1249 resp.u.process_fork.pid=pid;
1252 resp.u.process_fork.process_handle=process_handle;
1253 resp.u.process_fork.thread_handle=thread_handle;
1255 send_reply (channel, &resp);
1259 * process_set_share:
1260 * @channel: The client making the request
1261 * @channel_data: The channel data
1262 * @set_share: Set share data passed from the client
1264 * Sets file share info
1266 static void process_set_share (GIOChannel *channel, ChannelData *channel_data,
1267 WapiHandleRequest_SetShare set_share)
1269 WapiHandleResponse resp = {0};
1271 resp.type = WapiHandleResponseType_SetShare;
1274 g_message (G_GNUC_PRETTY_FUNCTION ": Setting share for file (dev:0x%llx, ino:%lld) mode 0x%x access 0x%x", set_share.device, set_share.inode, set_share.sharemode, set_share.access);
1277 sharemode_set (set_share.device, set_share.inode, set_share.sharemode,
1280 send_reply (channel, &resp);
1284 * process_get_or_set_share:
1285 * @channel: The client making the request
1286 * @channel_data: The channel data
1287 * @get_share: GetOrSetShare data passed from the client
1289 * Gets a file share status, and sets the status if it doesn't already
1292 static void process_get_or_set_share (GIOChannel *channel,
1293 ChannelData *channel_data,
1294 WapiHandleRequest_GetOrSetShare get_share)
1296 WapiHandleResponse resp = {0};
1298 resp.type = WapiHandleResponseType_GetOrSetShare;
1301 g_message (G_GNUC_PRETTY_FUNCTION
1302 ": Getting share status for file (dev:0x%llx, ino:%lld)",
1303 get_share.device, get_share.inode);
1306 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);
1308 if (resp.u.get_or_set_share.exists) {
1310 g_message (G_GNUC_PRETTY_FUNCTION ": Share mode: 0x%x",
1311 resp.u.get_or_set_share.sharemode);
1315 g_message (G_GNUC_PRETTY_FUNCTION
1316 ": file share info not already known, setting");
1318 sharemode_set (get_share.device, get_share.inode,
1319 get_share.new_sharemode, get_share.new_access);
1322 send_reply (channel, &resp);
1327 * @channel: The client to read the request from
1328 * @open_handles: An array of handles referenced by this client
1330 * Read a message (A WapiHandleRequest) from a client and dispatch
1331 * whatever it wants to the process_* calls. Return TRUE if the message
1332 * was read successfully, FALSE otherwise.
1334 static gboolean read_message (GIOChannel *channel, ChannelData *channel_data)
1336 WapiHandleRequest req;
1337 int fds[3]={0, 1, 2};
1339 gboolean has_fds=FALSE;
1342 ret=_wapi_daemon_request (g_io_channel_unix_get_fd (channel), &req,
1345 /* Other end went away */
1347 g_message ("Read 0 bytes on fd %d, closing it",
1348 g_io_channel_unix_get_fd (channel));
1350 rem_fd (channel, channel_data);
1355 g_message ("Process request %d", req.type);
1358 case WapiHandleRequestType_New:
1359 process_new (channel, channel_data, req.u.new.type);
1361 case WapiHandleRequestType_Open:
1363 g_assert(req.u.open.handle < _wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT);
1365 process_open (channel, channel_data, req.u.open.handle);
1367 case WapiHandleRequestType_Close:
1369 g_assert(req.u.close.handle < _wapi_shared_data[0]->num_segments * _WAPI_HANDLES_PER_SEGMENT);
1371 process_close (channel, channel_data, req.u.close.handle);
1373 case WapiHandleRequestType_Scratch:
1374 process_scratch (channel, req.u.scratch.length);
1376 case WapiHandleRequestType_ScratchFree:
1377 process_scratch_free (channel, req.u.scratch_free.idx);
1379 case WapiHandleRequestType_ProcessFork:
1380 process_process_fork (channel, channel_data,
1381 req.u.process_fork, fds);
1383 case WapiHandleRequestType_ProcessKill:
1384 process_process_kill (channel, req.u.process_kill);
1386 case WapiHandleRequestType_SetShare:
1387 process_set_share (channel, channel_data, req.u.set_share);
1389 case WapiHandleRequestType_GetOrSetShare:
1390 process_get_or_set_share (channel, channel_data,
1391 req.u.get_or_set_share);
1393 case WapiHandleRequestType_Error:
1396 /* Catch bogus requests */
1397 /* FIXME: call rem_fd? */
1403 g_message (G_GNUC_PRETTY_FUNCTION ": closing %d", fds[0]);
1404 g_message (G_GNUC_PRETTY_FUNCTION ": closing %d", fds[1]);
1405 g_message (G_GNUC_PRETTY_FUNCTION ": closing %d", fds[2]);
1418 * @channel: The IO channel that is active
1419 * @condition: The condition that has been satisfied
1420 * @data: A pointer to an array of handles referenced by this client
1422 * The callback called by the main loop when there is activity on an
1425 static gboolean fd_activity (GIOChannel *channel, GIOCondition condition,
1428 int fd=g_io_channel_unix_get_fd (channel);
1429 ChannelData *channel_data=&channels[fd];
1430 GMainContext *context=data;
1432 if(condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
1434 g_message ("fd %d error", fd);
1437 rem_fd (channel, channel_data);
1441 if(condition & (G_IO_IN | G_IO_PRI)) {
1444 struct sockaddr addr;
1445 socklen_t addrlen=sizeof(struct sockaddr);
1447 newsock=accept (main_sock, &addr, &addrlen);
1449 g_critical ("accept error: %s",
1450 g_strerror (errno));
1456 g_message ("accept returning %d", newsock);
1459 add_fd (newsock, context);
1462 g_message ("reading data on fd %d", fd);
1465 return(read_message (channel, channel_data));
1470 return(FALSE); /* remove source */
1474 * _wapi_daemon_main:
1476 * Open socket, create shared mem segment and begin listening for
1479 void _wapi_daemon_main(gpointer data, gpointer scratch)
1481 struct sockaddr_un main_socket_address;
1483 GMainContext *context;
1486 g_message ("Starting up...");
1489 _wapi_shared_data[0]=data;
1490 _wapi_shared_scratch=scratch;
1491 _wapi_shared_scratch->is_shared=TRUE;
1493 /* Note that we've got the starting segment already */
1494 _wapi_shared_data[0]->num_segments=1;
1495 _wapi_shm_mapped_segments=1;
1499 main_sock=socket(PF_UNIX, SOCK_STREAM, 0);
1501 main_socket_address.sun_family=AF_UNIX;
1502 memcpy(main_socket_address.sun_path, _wapi_shared_data[0]->daemon,
1503 MONO_SIZEOF_SUNPATH);
1505 ret=bind(main_sock, (struct sockaddr *)&main_socket_address,
1506 sizeof(struct sockaddr_un));
1508 g_critical ("bind failed: %s", g_strerror (errno));
1509 _wapi_shared_data[0]->daemon_running=DAEMON_DIED_AT_STARTUP;
1517 ret=listen(main_sock, 5);
1519 g_critical ("listen failed: %s", g_strerror (errno));
1520 _wapi_shared_data[0]->daemon_running=DAEMON_DIED_AT_STARTUP;
1525 g_message("listening");
1528 context = g_main_context_new ();
1530 add_fd(main_sock, context);
1532 /* We're finished setting up, let everyone else know we're
1533 * ready. From now on, it's up to us to delete the shared
1534 * memory segment when appropriate.
1536 _wapi_shared_data[0]->daemon_running=DAEMON_RUNNING;
1539 if(check_processes==TRUE) {
1544 g_message ("polling");
1547 /* Block until something happens. We don't use
1548 * g_main_loop_run() because we rely on the SIGCHLD
1549 * signal interrupting poll() so we can reap child
1550 * processes as soon as they die, without burning cpu
1551 * time by polling the flag.
1553 g_main_context_iteration (context, TRUE);