aboutsummaryrefslogtreecommitdiff
path: root/winsup/cygserver
diff options
context:
space:
mode:
authorRobert Collins <rbtcollins@hotmail.com>2002-02-28 14:30:38 +0000
committerRobert Collins <rbtcollins@hotmail.com>2002-02-28 14:30:38 +0000
commitf449bfef408685a2e4c0fc40c601c584fbc7bc82 (patch)
tree90167807132514f02fd751fbbae71e3b09c2fa65 /winsup/cygserver
parent062401c9b4bf8a203d7e694194307d84e351fce0 (diff)
downloadnewlib-f449bfef408685a2e4c0fc40c601c584fbc7bc82.zip
newlib-f449bfef408685a2e4c0fc40c601c584fbc7bc82.tar.gz
newlib-f449bfef408685a2e4c0fc40c601c584fbc7bc82.tar.bz2
2002-02-28 Robert Collins <rbtcollins@hotmail.com>
* Merged cygwin_daemon into head minus the new shm and ipc exports. 2002-02-28 Robert Collins <rbtcollins@hotmail.com> * fhandler_tty.cc (fhandler_tty_slave::open): More debugging. (fhandler_tty_slave::read): Fix printf type for the handle. * tty.cc (tty::common_init): Add a FIXME for security. 2002-01-29 Robert Collins <rbtcollins@hotmail.com> * Makefile.in (OBJS): Remove duplicate localtime.o. 2002-01-17 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (check_and_dup_handle): Consolidate the two variants for simplicity. Add Some basic debug output. (client_request_attach_tty::serve): Use the new debug_printf for clarity. Mark the duplicated handles as inheritable - fixup_after_fork() doesn't reopen tty's. 2002-01-16 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (transport): Correct scope. (client_request_attach_tty::serve): Add more debug information. Fix erroneous use of transport instead of conn. * cygserver_transport_pipes.cc (transport_layer_pipes::close): More debug. (transport_layer_pipes::read): Ditto. (transport_layer_pipes::write): Ditto. (transport_layer_pipes::impersonate_client): Ditto. Mon Oct 8 7:41:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (server_request::process): Rename client_request_shm_get to client_request_shm. * cygserver_process.cc (process_cache::add): Rename to add_task. Use process_cleanup instead of process_request. (process_cache::remove_process): New method. (process::process): Initialize new members. (process::~process): New member. (process::cleanup): New method. (process::add_cleanup_routine): New method. (process_request::process): Rename to process_cleanup. Call the process object's cleanup method and then delete it. (process_process_param::request_loop): Remove the signalling process. * cygserver_shm.cc: Globally rename client_request_shm_get to client_request_shm. (client_request_shm_get::serve): Handle attach request counting. * cygserver_shm.h: Globally rename client_request_shm_get to client_request_shm. (class shm_cleanup): New class. * shm.cc: Globally rename client_request_shm_get to client_request_shm. (client_request_shm::client_request_shm): New constructor for attach requests. (shmat): Use it. * include/cygwin/cygserver_process.h (class process_request): Rename to process_cleanup. (class cleanup_routine): New class. (class process): New members and methods to allow calling back when the process terminates. Thu Oct 4 14:12:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (request_loop): Make static. (main): Use new cache constructor syntax. Start cache worker threads. Cleanup the cache at shutdown. * cygserver_process.cc: Run indent. (process_cache::process_cache): Add a trigger to use when adding a process. (process_cache::process): Move process_entry to process. Insert at the end of the list. Trigger the request loop when new process's inserted. (process_cache::process_requests): Do it. (process_cache::add): New method. (process_cache::handle_snapshot): New method. (process::process): Merge in the process_entry fields. (process::handle): Make a stub function. (process::exit_code): New method. (process_request::process): New method. (process_process_param::request_loop): New method. * cygserver_shm.cc: New header dependency - threaded_queue.h. * threaded_queue.cc (threaded_queue::cleanup): Clearer messages. (queue_process_param::stop): Short spinlock on interruptible threads. * threaded_queue.h (class threaded_queue): New constructor. * include/cygwin/cygserver_process.h (process_request): New class. (process_entry): Remove. (process): Merge in process_entry. (process_cache): Inherit from threaded_queue. Tue Oct 2 23:24:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (class server_process_param): Use new constructor syntax. * cygserver_process.cc (process_cache::~process_cache): New function. * threaded_queue.cc: Define condition debug_printf. Run indent. (threaded_queue::cleanup): Move queue_process_param guts to a method. (threaded_queue::process_requests): Ditto. (queue_process_param::queue_process_param): New method. (queue_process_param::~queue_process_param): Ditto. (queue_process_param::start): Ditto. (queue_process_param::stop): Ditto. * threaded_queue.h (class queue_process_param): Add support for interruptible request loops. * cygwin/include/cygwin/cygserver_process.h (class process_cache): Add destructor. Tue Oct 2 23:24:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver_client.cc: New flag allow_daemon to disable the daemon completely. (cygserver_request): Check it. (cygserver_init): Ditto. * environ.cc (parse_thing): Add (no)daemon option. Tue Oct 2 23:00:00 2001 Robert Collins <rbtcollins@hotmail.com> * shm.cc: Update to handle include changes from HEAD. Tue Oct 2 16:06:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: Remove cygserver_shm.o from cygwin1.dll. Rename cygserver_shm_outside.o to cygserver_shm.o. * cygserver.cc (server_request::process): Use the new client_request constructor. * cygserver_client.cc: Remove the #ifdef's stubs for the server method within cygwin. (client_request_attach_tty::client_request_attach_tty): Use the new client_request constructor. (client_request_shutdown::client_request_shutdown): Ditto. (client_request::client_request): Ditto. * cygserver_shm.cc (client_request_shm_get::serve): Remove the #ifdef'd stub for in-cygwin builds. (client_request_shm_get::client_request_shm_get): Use the new client_request constructor, and remove the in-cygwin variants. * cygserver_shm.h (class client_request_shm_get): #ifndef test the serve method - it's only used in cygserver. * shm.cc (client_request_shm_get::client_request_shm_get): New function. * include/cygwin/cygserver.h (request_header): New constructor. (class client_request): Use it. New constructor accepting the header size. #ifndef test the server method - it's only used within cygserver. (client_request_get_version): #ifdef test the server method. (client_request_shutdown): Ditto. (client_request_attach_tty): Ditto. Tue Oct 2 9:57:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: add threaded_queue.o to cygserver.exe. * cygserver.cc: Include threaded_queue.h (class server_request): Inherit from queue_request. (class server_process_param): Inherit from queue_process_param. (class server_request_queue): Inherit from threaded_queue. (request_loop): Adjust for new types. (server_request_queue::process_requests): Remove guts to threaded_queue::process_requests. (server_request::server_request): Adjust for new types. (worker_function): Delete. (server_request_queue::create_workers): Delete. (server_request_queue::cleanup): Delete. (server_request_queue::add): Move guts to threaded_queue::add. * threaded_queue.cc: New file. * threaded_queue.h: New file. Mon Oct 1 12:38:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (client_request::serve): New function. * cygserver_process.cc: Inlude <pthread.h> for pthread_once. (process_cache::process_cache): Initialise a crtiical section for write access. (process_cache::process): Use the critical section. Also add missing entries to the cache. (do_process_init): New function to initalise class process static variables. (process::process): Ensure that the process access critical section is initialised. (process::handle): Close the handle of old process's when they have terminated and we are returning the handle for a process with the same pid. * cygserver_shm.cc: Run indent. Include cygserver_process.h to allow process cache functionality. (client_request_shm_get::serve): New parameter for process cache support. Use the process cache, not OpenProcess to get a handle to the originating process. Fix a handle leak with token_handle. * cygserver_shm.h (class client_request_shm_get): Update ::serve for process cache support. * cygserver_transport_pipes.cc: Redefine debug_printf to be conditional on DEBUG. * include/cygwin/cygserver.h: Do not implement client_request::serve in the header. * include/cygwin/cygserver_process.h (class process_cache): Add a write access critical section to prevent races when requests from a multithreaded application arrive. Sun Sep 30 23:41:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: Add cygserver_process.o to cygserver.exe. * cygserver.cc: Include signal.h and cygwin_version.h. Define debug_printf as a macro. Define DEBUG to a value. (client_request_attach_tty::serve): Add beginning of process cache support. Change from #ifdef DEBUG to work with new DEBUG style. (client_request_get_version::serve): Add beginning of process cache support. (class server_request): New prototype for support of process cache. (class queue_process_param): New class to allow request loop threading. (class server_request_queue): Add beginning of process cache support. Allow request loop threading. (request_loop): Thread function for request loops. (server_request_queue::process_requests): Initiator for threaded request loops. (client_request_shutdown::serve): Add beginning of process cache support. (server_request::server_request): Ditto. (server_request::process): Use debug_printf. Add beginning of process cache support. (server_request_queue::cleanup): Kill off any request loop threads. (server_request_queue::add): Add beginning of process cache support. (handle_signal): Trigger a shutdown. (main): Print out some useful info at startup - version, date time. Add process cache support. Spawn a separate thread for the transport request loop, thus allowing concurrent support for multiple transports. * cygserver_client.cc (client_request_get_version::serve): Add process cache support. (client_request_attach_tty::serve): Add process cache support. (client_request_shutdown::serve): Add process cache support. * cygsserver_process.cc: New file with the process cache support. * cygserver_shm.cc: Redefine debug_printf to allow conditional output. * cygwin.din: Export shmdt(). * shm.cc: Run indent. Update FIXME's. (shmdt): New function. * include/cygwin/cygserver.h (class client_request): Add process cache support. (class client_request_get_version): Ditto. (class client_request_shutdown): Ditto. (class client_request_attach_tty): Ditto. * include/cygwin/cygserver_process.h: New header for process cache support. Sun Sep 30 8:52:00 2001 Robert Collins <rbtcollins@hotmail.com> * include/cygwin/cygserver_transport.h: Add copyright header. * include/cygwin/cygserver_transport_pipes.h: Ditto. * include/cygwin/cygserver_transport_sockets.h: Ditto. Sat Sep 29 20:40:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: Add cygserver_transport_sockets.o to DLL_OFILES. Add cygserver_transport_sockets_outside.o to cygserver.exe. * cygserver.cc: Include new include files. * cygserver_client.cc: Ditto. * cygserver_shm.h: No need to include <sys/socket.h> now. * cygerver_transport.cc: Include new include files. (transport_layer_base::transport_layer_base): Strip back to a stub. (transport_layer_base::listen): Ditto. (transport_layer_base::accept): Ditto. (transport_layer_base::close): Ditto. (transport_layer_base::read): Ditto. (transport_layer_base::write): Ditto. (transport_layer_base::connect): Ditto. * cygserver_transport_pipes.cc: Include new header "cygwin/cygserver_transport_pipes.h". * cygserver_transport_sockets.cc: New file. * dcrt0.cc: No need to include <sys/socket.h> now. * fhandler_tty.cc: Ditto. * tty.cc: Ditto. * include/cygwin/cygserver_transport.h: Strip the base class to a stub. Remove the cygserver_transport_pipes class. * include/cygwin/cygserver_transport_pipes.h: New file. * include/cygwin/cygserver_transport_sockets.h: New file. Tue Sep 25 16:22:00 2001 Robert Collins <rbtcollins@hotmail.com> * autoload.cc: Add dynamic load statement for 'ImpersonateNamedPipeClient'. * Makefile.in: Add new object files, and build instructions for cygserver.exe. * cygwin.din: Export ftok, shmat, shmctl and shmget. * dcrt0.cc: Additional includes for cygserver support. (dll_crt0_1): Initialise the cygserver client. * fhandler.h (fhandler_tty): New method cygserver_attach_tty. * fhandler_tty.cc: Additional includes for cygserver support. (fhandler_tty_slave::open): Attempt to use the cygserver when obtaining handles from the parent process. On failure or 9x use the current method. (fhandler_tty_slave::cygserver_attach_tty): New function. * fork.cc (fork_child): Fixup shm memory mapped areas. * pinfo.h: Declare fixup_shms_after_fork(). * security.h: Declare alloc_sd(). * tty.cc: Additonal includes to support cygserver. (tty::common_init): Don't allow others to open us if the cygserver is running. * winsup.h: Declare cygserver_running. * cygserver.cc: New file. * cygserver_client.cc: New file. * cygserver_shm.cc: New file. * cygserver_shm.h: New file. * cygserver_transport.cc: New file. * cygserver_transport_pipes.cc: New file. * ipc.cc: New file. * shm.cc: New file. * include/cygwin/cygserver.h: New file. * include/cygwin/cygserver_transport.h: New file. * include/sys/ipc.h: New file. * include/sys/shm.h: New file. 2002-02-28 Robert Collins <rbtcollins@hotmail.com> * thread.cc (semaphore::TryWait): Set errno as required by posix 1003.1. (__sem_wait): Ditto. (__sem_trywait): Ditto.
Diffstat (limited to 'winsup/cygserver')
-rw-r--r--winsup/cygserver/client.cc207
-rw-r--r--winsup/cygserver/cygserver.cc548
-rw-r--r--winsup/cygserver/process.cc389
-rw-r--r--winsup/cygserver/shm.cc552
-rwxr-xr-xwinsup/cygserver/shm.h91
-rw-r--r--winsup/cygserver/threaded_queue.cc249
-rw-r--r--winsup/cygserver/transport.cc92
-rw-r--r--winsup/cygserver/transport_pipes.cc205
-rw-r--r--winsup/cygserver/transport_sockets.cc131
9 files changed, 2464 insertions, 0 deletions
diff --git a/winsup/cygserver/client.cc b/winsup/cygserver/client.cc
new file mode 100644
index 0000000..8a1eeaf
--- /dev/null
+++ b/winsup/cygserver/client.cc
@@ -0,0 +1,207 @@
+/* cygserver_client.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Egor Duda <deo@logos-m.ru>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#ifdef __OUTSIDE_CYGWIN__
+#undef __INSIDE_CYGWIN__
+#else
+#include "winsup.h"
+#endif
+
+#ifndef __INSIDE_CYGWIN__
+#define debug_printf printf
+#define api_fatal printf
+#include <stdio.h>
+#include <windows.h>
+#endif
+#include <sys/socket.h>
+#include <errno.h>
+#include <unistd.h>
+//#include "security.h"
+#include "cygwin/cygserver_transport.h"
+#include "cygwin/cygserver_transport_pipes.h"
+#include "cygwin/cygserver_transport_sockets.h"
+#include "cygwin/cygserver.h"
+
+/* 0 = untested, 1 = running, 2 = dead */
+int cygserver_running=CYGSERVER_UNKNOWN;
+/* on by default during development. For release, we probably want off by default */
+int allow_daemon = TRUE;
+
+client_request_get_version::client_request_get_version () : client_request (CYGSERVER_REQUEST_GET_VERSION, sizeof (version))
+{
+ buffer = (char *)&version;
+}
+
+client_request_attach_tty::client_request_attach_tty () : client_request (CYGSERVER_REQUEST_ATTACH_TTY, sizeof (req))
+{
+ buffer = (char *)&req;
+ req.pid = 0;
+ req.master_pid = 0;
+ req.from_master = NULL;
+ req.to_master = NULL;
+}
+
+client_request_attach_tty::client_request_attach_tty (DWORD npid, DWORD nmaster_pid, HANDLE nfrom_master, HANDLE nto_master) : client_request (CYGSERVER_REQUEST_ATTACH_TTY, sizeof (req))
+{
+ buffer = (char *)&req;
+ req.pid = npid;
+ req.master_pid = nmaster_pid;
+ req.from_master = nfrom_master;
+ req.to_master = nto_master;
+}
+
+client_request_shutdown::client_request_shutdown () : client_request (CYGSERVER_REQUEST_SHUTDOWN, 0)
+{
+ buffer = NULL;
+}
+
+client_request::client_request (cygserver_request_code id, ssize_t buffer_size) : header (id, buffer_size)
+{
+}
+
+client_request::~client_request ()
+{
+}
+
+client_request::operator class request_header ()
+{
+ return header;
+}
+
+void
+client_request::send (transport_layer_base *conn)
+{
+ if (!conn)
+ return;
+ debug_printf("this=%p, conn=%p\n",this, conn);
+ ssize_t bytes_written, bytes_read;
+ debug_printf("header.cb = %ld\n",header.cb);
+ if ((bytes_written = conn->write ((char *)&header, sizeof (header)))
+ != sizeof(header) || (header.cb &&
+ (bytes_written = conn->write (buffer, header.cb)) != header.cb))
+ {
+ header.error_code = -1;
+ debug_printf ("bytes written != request size\n");
+ return;
+ }
+
+ debug_printf("Sent request, size (%ld)\n",bytes_written);
+
+ if ((bytes_read = conn->read ((char *)&header, sizeof (header)))
+ != sizeof (header) || (header.cb &&
+ (bytes_read = conn->read (buffer, header.cb) ) != header.cb))
+ {
+ header.error_code = -1;
+ debug_printf("failed reading response \n");
+ return;
+ }
+ debug_printf ("completed ok\n");
+}
+
+/* Oh, BTW: Fix the procedural basis and make this more intuitive. */
+
+int
+cygserver_request (client_request * req)
+{
+ class transport_layer_base *transport;
+
+ if (!req || allow_daemon != TRUE)
+ return -1;
+
+ /* dont' retry every request if the server's not there */
+ if (cygserver_running==CYGSERVER_DEAD && req->header.req_id != CYGSERVER_REQUEST_GET_VERSION)
+ return -1;
+
+ transport = create_server_transport ();
+
+ /* FIXME: have at most one connection per thread. use TLS to store the details */
+ /* logic is:
+ * if not tlskey->conn, new conn,
+ * then; transport=conn;
+ */
+ if (!transport->connect ())
+ {
+ delete transport;
+ return -1;
+ }
+
+ debug_printf ("connected to server %p\n", transport);
+
+ req->send(transport);
+
+ transport->close ();
+
+ delete transport;
+
+ return 0;
+}
+
+#if 0
+BOOL
+check_cygserver_available ()
+{
+ BOOL ret_val = FALSE;
+ HANDLE pipe = CreateFile (pipe_name,
+ GENERIC_READ | GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ &sec_all_nih,
+ OPEN_EXISTING,
+ 0,
+ NULL);
+ if (pipe != INVALID_HANDLE_VALUE || GetLastError () != ERROR_PIPE_BUSY)
+ ret_val = TRUE;
+
+ if (pipe && pipe != INVALID_HANDLE_VALUE)
+ CloseHandle (pipe);
+
+ return (ret_val);
+}
+#endif
+
+void
+cygserver_init ()
+{
+ int rc;
+ if (allow_daemon != TRUE)
+ {
+ cygserver_running = CYGSERVER_DEAD;
+ return;
+ }
+
+ if (cygserver_running==CYGSERVER_OK)
+ return;
+
+ client_request_get_version *req =
+ new client_request_get_version ();
+
+ rc = cygserver_request (req);
+ delete req;
+ if (rc < 0)
+ cygserver_running = CYGSERVER_DEAD;
+ else if (rc > 0)
+ api_fatal ( "error connecting to cygwin server. error: %d", rc );
+ else if (req->version.major != CYGWIN_SERVER_VERSION_MAJOR ||
+ req->version.api != CYGWIN_SERVER_VERSION_API ||
+ req->version.minor > CYGWIN_SERVER_VERSION_MINOR)
+ api_fatal ( "incompatible version of cygwin server.\n\
+ client version %d.%d.%d.%d, server version%ld.%ld.%ld.%ld",
+ CYGWIN_SERVER_VERSION_MAJOR,
+ CYGWIN_SERVER_VERSION_API,
+ CYGWIN_SERVER_VERSION_MINOR,
+ CYGWIN_SERVER_VERSION_PATCH,
+ req->version.major,
+ req->version.api,
+ req->version.minor,
+ req->version.patch );
+ else
+ cygserver_running = CYGSERVER_OK;
+}
diff --git a/winsup/cygserver/cygserver.cc b/winsup/cygserver/cygserver.cc
new file mode 100644
index 0000000..57f92c2
--- /dev/null
+++ b/winsup/cygserver/cygserver.cc
@@ -0,0 +1,548 @@
+/* cygserver.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Egor Duda <deo@logos-m.ru>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <signal.h>
+#include "wincap.h"
+#include "cygwin_version.h"
+
+#include "getopt.h"
+
+#include "cygwin/cygserver_transport.h"
+#include "cygwin/cygserver_transport_pipes.h"
+#include "cygwin/cygserver_transport_sockets.h"
+#include "threaded_queue.h"
+#include "cygwin/cygserver_process.h"
+#include "cygwin/cygserver.h"
+#include "cygserver_shm.h"
+
+/* for quieter operation, set to 0 */
+#define DEBUG 0
+#define debug_printf if (DEBUG) printf
+
+GENERIC_MAPPING access_mapping;
+static class transport_layer_base *transport;
+
+DWORD request_count = 0;
+
+BOOL
+setup_privileges ()
+{
+ BOOL rc, ret_val;
+ HANDLE hToken = NULL;
+ TOKEN_PRIVILEGES sPrivileges;
+
+ rc = OpenProcessToken ( GetCurrentProcess() , TOKEN_ALL_ACCESS , &hToken ) ;
+ if ( !rc )
+ {
+ printf ( "error opening process token (%lu)\n", GetLastError () );
+ ret_val = FALSE;
+ goto out;
+ }
+ rc = LookupPrivilegeValue ( NULL, SE_DEBUG_NAME, &sPrivileges.Privileges[0].Luid );
+ if ( !rc )
+ {
+ printf ( "error getting prigilege luid (%lu)\n", GetLastError () );
+ ret_val = FALSE;
+ goto out;
+ }
+ sPrivileges.PrivilegeCount = 1 ;
+ sPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED ;
+ rc = AdjustTokenPrivileges ( hToken, FALSE, &sPrivileges, 0, NULL, NULL ) ;
+ if ( !rc )
+ {
+ printf ( "error adjusting prigilege level. (%lu)\n", GetLastError () );
+ ret_val = FALSE;
+ goto out;
+ }
+
+ access_mapping.GenericRead = FILE_READ_DATA;
+ access_mapping.GenericWrite = FILE_WRITE_DATA;
+ access_mapping.GenericExecute = 0;
+ access_mapping.GenericAll = FILE_READ_DATA | FILE_WRITE_DATA;
+
+ ret_val = TRUE;
+
+out:
+ CloseHandle ( hToken );
+ return ret_val;
+}
+
+int
+check_and_dup_handle (HANDLE from_process, HANDLE to_process,
+ HANDLE from_process_token,
+ DWORD access,
+ HANDLE from_handle,
+ HANDLE* to_handle_ptr, BOOL bInheritHandle = FALSE)
+{
+ HANDLE local_handle = NULL;
+ int ret_val = EACCES;
+ char sd_buf [1024];
+ PSECURITY_DESCRIPTOR sd = (PSECURITY_DESCRIPTOR) &sd_buf;
+ DWORD bytes_needed;
+ PRIVILEGE_SET ps;
+ DWORD ps_len = sizeof (ps);
+ BOOL status;
+
+ if (from_process != GetCurrentProcess ())
+{
+
+ if (!DuplicateHandle (from_process, from_handle,
+ GetCurrentProcess (), &local_handle,
+ 0, bInheritHandle,
+ DUPLICATE_SAME_ACCESS))
+ {
+ printf ( "error getting handle(%u) to server (%lu)\n", (unsigned int)from_handle, GetLastError ());
+ goto out;
+ }
+} else
+ local_handle = from_handle;
+
+ if (!GetKernelObjectSecurity (local_handle,
+ OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
+ sd, sizeof (sd_buf), &bytes_needed))
+ {
+ printf ( "error getting handle SD (%lu)\n", GetLastError ());
+ goto out;
+ }
+
+ MapGenericMask (&access, &access_mapping);
+
+ if (!AccessCheck (sd, from_process_token, access, &access_mapping,
+ &ps, &ps_len, &access, &status))
+ {
+ printf ( "error checking access rights (%lu)\n", GetLastError ());
+ goto out;
+ }
+
+ if (!status)
+ {
+ printf ( "access to object denied\n");
+ goto out;
+ }
+
+ if (!DuplicateHandle (from_process, from_handle,
+ to_process, to_handle_ptr,
+ access, bInheritHandle, 0))
+ {
+ printf ( "error getting handle to client (%lu)\n", GetLastError ());
+ goto out;
+ }
+ debug_printf ("Duplicated %p to %p\n", from_handle, *to_handle_ptr);
+
+ ret_val = 0;
+
+out:
+ if (local_handle && from_process != GetCurrentProcess ())
+ CloseHandle (local_handle);
+
+ return (ret_val);
+}
+
+void
+client_request::serve (transport_layer_base *conn, class process_cache *cache)
+{
+ printf ("*****************************************\n"
+ "A call to the base client_request class has occured\n"
+ "This indicates a mismatch in a virtual function definition somewhere\n");
+ exit (1);
+}
+
+void
+client_request_attach_tty::serve(transport_layer_base *conn, class process_cache *cache)
+{
+ HANDLE from_process_handle = NULL;
+ HANDLE to_process_handle = NULL;
+ HANDLE token_handle = NULL;
+ DWORD rc;
+
+ if (header.cb != sizeof (req))
+ {
+ header.error_code = EINVAL;
+ return;
+ }
+
+ debug_printf ("pid %ld:(%p,%p) -> pid %ld\n", req.master_pid,
+ req.from_master, req.to_master,
+ req.pid);
+
+ debug_printf ("opening process %ld\n", req.master_pid);
+ from_process_handle = OpenProcess (PROCESS_DUP_HANDLE, FALSE, req.master_pid);
+ debug_printf ("opening process %ld\n", req.pid);
+ to_process_handle = OpenProcess (PROCESS_DUP_HANDLE, FALSE, req.pid);
+ if (!from_process_handle || !to_process_handle)
+ {
+ printf ("error opening process (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ goto out;
+ }
+
+ debug_printf ("Impersonating client\n");
+ conn->impersonate_client ();
+
+ debug_printf ("about to open thread token\n");
+ rc = OpenThreadToken (GetCurrentThread (),
+ TOKEN_QUERY,
+ TRUE,
+ &token_handle);
+
+ debug_printf ("opened thread token, rc=%lu\n", rc);
+ conn->revert_to_self ();
+
+ if (!rc)
+ {
+ printf ("error opening thread token (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ goto out;
+ }
+
+ if (check_and_dup_handle (from_process_handle, to_process_handle,
+ token_handle,
+ GENERIC_READ,
+ req.from_master,
+ &req.from_master, TRUE) != 0)
+ {
+ printf ("error duplicating from_master handle (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ goto out;
+ }
+
+ if (req.to_master)
+ {
+ if (check_and_dup_handle (from_process_handle, to_process_handle,
+ token_handle,
+ GENERIC_WRITE,
+ req.to_master,
+ &req.to_master, TRUE) != 0)
+ {
+ printf ("error duplicating to_master handle (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ goto out;
+ }
+ }
+
+#if DEBUG
+ printf ("%ld -> %ld(%p,%p)\n", req.master_pid, req.pid,
+ req.from_master, req.to_master);
+#endif
+
+ header.error_code = 0;
+
+out:
+ if (from_process_handle)
+ CloseHandle (from_process_handle);
+ if (to_process_handle)
+ CloseHandle (to_process_handle);
+ if (token_handle)
+ CloseHandle (token_handle);
+}
+
+void
+client_request_get_version::serve(transport_layer_base *conn, class process_cache *cache)
+{
+ if (header.cb != sizeof (version))
+ {
+ header.error_code = EINVAL;
+ return;
+ }
+ header.error_code = 0;
+ version.major = CYGWIN_SERVER_VERSION_MAJOR;
+ version.api = CYGWIN_SERVER_VERSION_API;
+ version.minor = CYGWIN_SERVER_VERSION_MINOR;
+ version.patch = CYGWIN_SERVER_VERSION_PATCH;
+}
+
+class server_request : public queue_request
+{
+ public:
+ server_request (transport_layer_base *newconn, class process_cache *newcache);
+ virtual void process ();
+ private:
+ char request_buffer [MAX_REQUEST_SIZE];
+ transport_layer_base *conn;
+ class process_cache *cache;
+};
+
+class server_process_param : public queue_process_param
+{
+ public:
+ transport_layer_base *transport;
+ server_process_param () : queue_process_param (false) {};
+};
+
+class server_request_queue : public threaded_queue
+{
+ public:
+ class process_cache *cache;
+ void process_requests (transport_layer_base *transport);
+ virtual void add (transport_layer_base *conn);
+};
+class server_request_queue request_queue;
+
+static DWORD WINAPI
+request_loop (LPVOID LpParam)
+{
+ class server_process_param *params = (server_process_param *) LpParam;
+ class server_request_queue *queue = (server_request_queue *) params->queue;
+ class transport_layer_base * transport = params->transport;
+ while (queue->active)
+ {
+ transport_layer_base * new_conn = transport->accept ();
+ /* FIXME: this is a little ugly. What we really want is to wait on two objects:
+ * one for the pipe/socket, and one for being told to shutdown. Otherwise
+ * this will stay a problem (we won't actually shutdown until the request
+ * _AFTER_ the shutdown request. And sending ourselves a request is ugly
+ */
+ if (new_conn && queue->active)
+ queue->add (new_conn);
+ }
+ return 0;
+}
+
+/* TODO: check we are not being asked to service a already serviced transport */
+void
+server_request_queue::process_requests (transport_layer_base *transport)
+{
+ class server_process_param *params = new server_process_param;
+ params->transport = transport;
+ threaded_queue::process_requests (params, request_loop);
+}
+
+void
+client_request_shutdown::serve (transport_layer_base *conn, class process_cache *cache)
+{
+ /* FIXME: link upwards, and then this becomes a trivial method call to
+ * only shutdown _this queue_
+ */
+ /* tell the main thread to shutdown */
+ request_queue.active=false;
+}
+
+server_request::server_request (transport_layer_base *newconn, class process_cache *newcache)
+{
+ conn = newconn;
+ cache = newcache;
+}
+
+void
+server_request::process ()
+{
+ ssize_t bytes_read, bytes_written;
+ struct request_header* req_ptr = (struct request_header*) &request_buffer;
+ client_request *req = NULL;
+ debug_printf ("about to read\n");
+
+ bytes_read = conn->read (request_buffer, sizeof (struct request_header));
+ if (bytes_read != sizeof (struct request_header))
+ {
+ printf ("error reading from connection (%lu)\n", GetLastError ());
+ goto out;
+ }
+ debug_printf ("got header (%ld)\n", bytes_read);
+
+ switch (req_ptr->req_id)
+ {
+ case CYGSERVER_REQUEST_GET_VERSION:
+ req = new client_request_get_version (); break;
+ case CYGSERVER_REQUEST_ATTACH_TTY:
+ req = new client_request_attach_tty (); break;
+ case CYGSERVER_REQUEST_SHUTDOWN:
+ req = new client_request_shutdown (); break;
+ case CYGSERVER_REQUEST_SHM_GET:
+ req = new client_request_shm (); break;
+ default:
+ req = new client_request (CYGSERVER_REQUEST_INVALID, 0);
+ req->header.error_code = ENOSYS;
+ debug_printf ("Bad client request - returning ENOSYS\n");
+ }
+
+ if (req->header.cb != req_ptr->cb)
+ {
+ debug_printf ("Mismatch in request buffer sizes\n");
+ goto out;
+ }
+
+ if (req->header.cb)
+ {
+
+ bytes_read = conn->read (req->buffer, req->header.cb);
+ if (bytes_read != req->header.cb)
+ {
+ debug_printf ("error reading from connection (%lu)\n", GetLastError ());
+ goto out;
+ }
+ debug_printf ("got body (%ld)\n",bytes_read);
+ }
+
+ /* this is not allowed to fail. We must return ENOSYS at a minimum to the client */
+ req->serve (conn, cache);
+
+ if ((bytes_written = conn->write ((char *)&req->header, sizeof (req->header)))
+ != sizeof(req->header) || (req->header.cb &&
+ (bytes_written = conn->write (req->buffer, req->header.cb)) != req->header.cb))
+ {
+ req->header.error_code = -1;
+ printf ("error writing to connection (%lu)\n", GetLastError ());
+ goto out;
+ }
+
+ debug_printf("Sent reply, size (%ld)\n",bytes_written);
+ printf (".");
+
+out:
+ conn->close ();
+ delete conn;
+ if (req)
+ delete (req);
+}
+
+void
+server_request_queue::add (transport_layer_base *conn)
+{
+ /* safe to not "Try" because workers don't hog this, they wait on the event
+ */
+ /* every derived ::add must enter the section! */
+ EnterCriticalSection (&queuelock);
+ if (!running)
+ {
+ conn->close ();
+ delete conn;
+ LeaveCriticalSection (&queuelock);
+ return;
+ }
+ queue_request * listrequest = new server_request (conn, cache);
+ threaded_queue::add (listrequest);
+ LeaveCriticalSection (&queuelock);
+}
+
+void
+handle_signal (int signal)
+{
+ /* any signal makes us die :} */
+ /* FIXME: link upwards, and then this becomes a trivial method call to
+ * only shutdown _this queue_
+ */
+ /* tell the main thread to shutdown */
+ request_queue.active=false;
+}
+
+struct option longopts[] = {
+ {"shutdown", no_argument, NULL, 's'},
+ {0, no_argument, NULL, 0}
+};
+
+char opts[] = "s";
+
+int
+main (int argc, char **argv)
+{
+ int shutdown=0;
+ char i;
+
+ while ((i = getopt_long (argc, argv, opts, longopts, NULL)) != EOF)
+ switch (i)
+ {
+ case 's':
+ shutdown = 1;
+ break;
+ default:
+ break;
+ /*NOTREACHED*/
+ }
+
+ wincap.init();
+ if (wincap.has_security ())
+ setup_privileges ();
+ transport = create_server_transport ();
+
+ if (shutdown)
+ {
+ if (!transport->connect())
+ {
+ printf ("couldn't establish connection with server\n");
+ exit (1);
+ }
+ client_request_shutdown *request =
+ new client_request_shutdown ();
+ request->send (transport);
+ transport->close();
+ delete transport;
+ delete request;
+ exit(0);
+ }
+
+ char version[200];
+ /* Cygwin dll release */
+ snprintf (version, 200, "%d.%d.%d(%d.%d/%d/%d)-(%d.%d.%d.%d) %s",
+ cygwin_version.dll_major / 1000,
+ cygwin_version.dll_major % 1000,
+ cygwin_version.dll_minor,
+ cygwin_version.api_major,
+ cygwin_version.api_minor,
+ cygwin_version.shared_data,
+ CYGWIN_SERVER_VERSION_MAJOR,
+ CYGWIN_SERVER_VERSION_API,
+ CYGWIN_SERVER_VERSION_MINOR,
+ CYGWIN_SERVER_VERSION_PATCH,
+ cygwin_version.mount_registry,
+ cygwin_version.dll_build_date);
+ setbuf (stdout, NULL);
+ printf ("daemon version %s starting up", version);
+ if (signal (SIGQUIT, handle_signal) == SIG_ERR)
+ {
+ printf ("\ncould not install signal handler (%d)- aborting startup\n", errno);
+ exit (1);
+ }
+ printf (".");
+ transport->listen ();
+ printf (".");
+ class process_cache cache (2);
+ request_queue.initial_workers = 10;
+ request_queue.cache = &cache;
+ request_queue.create_workers ();
+ printf (".");
+ request_queue.process_requests (transport);
+ printf (".");
+ cache.create_workers ();
+ printf (".");
+ cache.process_requests ();
+ printf (".complete\n");
+ /* TODO: wait on multiple objects - the thread handle for each request loop +
+ * all the process handles. This should be done by querying the request_queue and
+ * the process cache for all their handles, and then waiting for (say) 30 seconds.
+ * after that we recreate the list of handles to wait on, and wait again.
+ * the point of all this abstraction is that we can trivially server both sockets
+ * and pipes simply by making a new transport, and then calling
+ * request_queue.process_requests (transport2);
+ */
+ /* WaitForMultipleObjects abort && request_queue && process_queue && signal
+ -- if signal event then retrigger it
+ */
+ while (1 && request_queue.active)
+ {
+ sleep (1);
+ }
+ printf ("\nShutdown request recieved - new requests will be denied\n");
+ request_queue.cleanup ();
+ printf ("All pending requests processed\n");
+ transport->close ();
+ printf ("No longer accepting requests - cygwin will operate in daemonless mode\n");
+ cache.cleanup ();
+ printf ("All outstanding process-cache activities completed\n");
+ printf ("daemon shutdown\n");
+}
diff --git a/winsup/cygserver/process.cc b/winsup/cygserver/process.cc
new file mode 100644
index 0000000..a5173af
--- /dev/null
+++ b/winsup/cygserver/process.cc
@@ -0,0 +1,389 @@
+/* cygserver_process.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Robert Collins <rbtcollins@hotmail.com>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include "wincap.h"
+#include <pthread.h>
+#include <threaded_queue.h>
+#include <cygwin/cygserver_process.h>
+
+#define debug_printf if (DEBUG) printf
+#define DEBUG 1
+
+/* the cache structures and classes are designed for one cache per server process.
+ * To make multiple process caches, a redesign will be needed
+ */
+
+/* process cache */
+process_cache::process_cache (unsigned int num_initial_workers):
+head (NULL)
+{
+ /* there can only be one */
+ InitializeCriticalSection (&cache_write_access);
+ if ((cache_add_trigger = CreateEvent (NULL, FALSE, FALSE, NULL)) == NULL)
+ {
+ printf ("Failed to create cache add trigger (%lu), terminating\n",
+ GetLastError ());
+ exit (1);
+ }
+ initial_workers = num_initial_workers;
+}
+
+process_cache::~process_cache ()
+{
+}
+
+class process *
+process_cache::process (long pid)
+{
+ class process *entry = head;
+ /* TODO: make this more granular, so a search doesn't involve the write lock */
+ EnterCriticalSection (&cache_write_access);
+ if (!entry)
+ {
+ entry = new class process (pid);
+ entry->next =
+ (class process *) InterlockedExchangePointer (&head, entry);
+ PulseEvent (cache_add_trigger);
+ }
+ else
+ {
+ while (entry->winpid != pid && entry->next)
+ entry = entry->next;
+ if (entry->winpid != pid)
+ {
+ class process *new_entry = new class process (pid);
+ new_entry->next =
+ (class process *) InterlockedExchangePointer (&entry->next,
+ new_entry);
+ entry = new_entry;
+ PulseEvent (cache_add_trigger);
+ }
+ }
+ LeaveCriticalSection (&cache_write_access);
+ return entry;
+}
+
+static DWORD WINAPI
+request_loop (LPVOID LpParam)
+{
+ class process_process_param *params = (process_process_param *) LpParam;
+ return params->request_loop ();
+}
+
+void
+process_cache::process_requests ()
+{
+ class process_process_param *params = new process_process_param;
+ threaded_queue::process_requests (params, request_loop);
+}
+
+void
+process_cache::add_task (class process * theprocess)
+{
+ /* safe to not "Try" because workers don't hog this, they wait on the event
+ */
+ /* every derived ::add must enter the section! */
+ EnterCriticalSection (&queuelock);
+ queue_request *listrequest = new process_cleanup (theprocess);
+ threaded_queue::add (listrequest);
+ LeaveCriticalSection (&queuelock);
+}
+
+/* NOT fully MT SAFE: must be called by only one thread in a program */
+void
+process_cache::remove_process (class process *theprocess)
+{
+ class process *entry = head;
+ /* unlink */
+ EnterCriticalSection (&cache_write_access);
+ if (entry == theprocess)
+ {
+ entry = (class process *) InterlockedExchangePointer (&head, theprocess->next);
+ if (entry != theprocess)
+ {
+ printf ("Bug encountered, process cache corrupted\n");
+ exit (1);
+ }
+ }
+ else
+ {
+ while (entry->next && entry->next != theprocess)
+ entry = entry->next;
+ class process *temp = (class process *) InterlockedExchangePointer (&entry->next, theprocess->next);
+ if (temp != theprocess)
+ {
+ printf ("Bug encountered, process cache corrupted\n");
+ exit (1);
+ }
+ }
+ LeaveCriticalSection (&cache_write_access);
+ /* Process any cleanup tasks */
+ add_task (theprocess);
+}
+
+
+/* copy <= max_copy HANDLEs to dest[], starting at an offset into _our list_ of
+ * begin_at. (Ie begin_at = 5, the first copied handle is still written to dest[0]
+ * NOTE: Thread safe, but not thread guaranteed - a newly added process may be missed.
+ * Who cares - It'll get caught the next time.
+ */
+int
+process_cache::handle_snapshot (HANDLE * hdest, class process ** edest,
+ ssize_t max_copy, int begin_at)
+{
+ /* TODO:? grab a delete-lock, to prevent deletes during this process ? */
+ class process *entry = head;
+ int count = begin_at;
+ /* skip begin_at entries */
+ while (entry && count)
+ {
+ if (entry->exit_code () == STILL_ACTIVE)
+ count--;
+ entry = entry->next;
+ }
+ /* hit the end of the list within begin_at entries */
+ if (count)
+ return 0;
+ HANDLE *hto = hdest;
+ class process **eto = edest;
+ while (entry && count < max_copy)
+ {
+ /* hack */
+ if (entry->exit_code () == STILL_ACTIVE)
+ {
+ *hto = entry->handle ();
+ *eto = entry;
+ count++;
+ hto++;
+ eto++;
+ }
+ entry = entry->next;
+ }
+ return count;
+}
+
+/* process's */
+/* global process crit section */
+static CRITICAL_SECTION process_access;
+static pthread_once_t process_init;
+
+void
+do_process_init (void)
+{
+ InitializeCriticalSection (&process_access);
+ /* we don't have a cache shutdown capability today */
+}
+
+process::process (long pid):
+winpid (pid), next (NULL), cleaning_up (0), head (NULL), _exit_status (STILL_ACTIVE)
+{
+ pthread_once (&process_init, do_process_init);
+ EnterCriticalSection (&process_access);
+ thehandle = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid);
+ if (!thehandle)
+ {
+ printf ("unable to obtain handle for new cache process %ld\n", pid);
+ thehandle = INVALID_HANDLE_VALUE;
+ }
+ debug_printf ("Got handle %p for new cache process %ld\n", thehandle, pid);
+ InitializeCriticalSection (&access);
+ LeaveCriticalSection (&process_access);
+}
+
+process::~process ()
+{
+ DeleteCriticalSection (&access);
+}
+
+HANDLE
+process::handle ()
+{
+// DWORD exitstate = exit_code ();
+// if (exitstate == STILL_ACTIVE)
+ return thehandle;
+
+ /* FIXME: call the cleanup list ? */
+
+// CloseHandle (thehandle);
+// debug_printf ("Process id %ld has terminated, attempting to open a new handle\n",
+// winpid);
+// thehandle = OpenProcess (PROCESS_ALL_ACCESS, FALSE, winpid);
+// debug_printf ("Got handle %p when refreshing cache process %ld\n", thehandle, winpid);
+// /* FIXME: what if OpenProcess fails ? */
+// if (thehandle)
+// {
+// _exit_status = STILL_ACTIVE;
+// exit_code ();
+// }
+// else
+// thehandle = INVALID_HANDLE_VALUE;
+// return thehandle;
+}
+
+DWORD process::exit_code ()
+{
+ if (_exit_status != STILL_ACTIVE)
+ return _exit_status;
+ bool
+ err = GetExitCodeProcess (thehandle, &_exit_status);
+ if (!err)
+ {
+ debug_printf ("Failed to retrieve exit code (%ld)\n", GetLastError ());
+ thehandle = INVALID_HANDLE_VALUE;
+ return _exit_status;
+ }
+ else if (_exit_status == STILL_ACTIVE)
+ return _exit_status;
+ /* add new cleanup task etc etc ? */
+ return _exit_status;
+}
+
+/* this is single threaded. It's called after the process is removed from the cache,
+ * but inserts may be attemped by worker threads that have a pointer to it */
+void
+process::cleanup ()
+{
+ /* Serialize this */
+ EnterCriticalSection (&access);
+ InterlockedIncrement (&(long)cleaning_up);
+ class cleanup_routine *entry = head;
+ while (entry)
+ {
+ class cleanup_routine *temp;
+ entry->cleanup (winpid);
+ temp = entry->next;
+ delete entry;
+ entry = temp;
+ }
+ LeaveCriticalSection (&access);
+}
+
+bool
+process::add_cleanup_routine (class cleanup_routine *new_cleanup)
+{
+ if (cleaning_up)
+ return false;
+ EnterCriticalSection (&access);
+ /* check that we didn't block with ::cleanup ()
+ * This rigmarole is to get around win9x's glaring missing TryEnterCriticalSection call
+ * which would be a whole lot easier
+ */
+ if (cleaning_up)
+ {
+ LeaveCriticalSection (&access);
+ return false;
+ }
+ new_cleanup->next = head;
+ head = new_cleanup;
+ LeaveCriticalSection (&access);
+ return true;
+}
+
+/* process_cleanup */
+void
+process_cleanup::process ()
+{
+ theprocess->cleanup ();
+ delete theprocess;
+}
+
+/* process_process_param */
+DWORD
+process_process_param::request_loop ()
+{
+ process_cache *cache = (process_cache *) queue;
+ /* always malloc one, so there is no special case in the loop */
+ ssize_t HandlesSize = 2;
+ HANDLE *Handles = (HANDLE *) malloc (sizeof (HANDLE) * HandlesSize);
+ process **Entries = (process **) malloc (sizeof (LPVOID) * HandlesSize);
+ /* TODO: put [1] at the end as it will also get done if a process dies? */
+ Handles[0] = interrupt;
+ Handles[1] = cache->cache_add_trigger;
+ while (cache->active && !shutdown)
+ {
+ int copied;
+ copied = -1;
+ int offset;
+ offset = 1;
+ int count;
+ count = 2;
+ while ((copied == HandlesSize - 2 - offset) || copied < 0)
+ {
+ /* we need more storage to cope with all the HANDLES */
+ if (copied == HandlesSize - 2 - offset)
+ {
+ HANDLE *temp = (HANDLE *) realloc (Handles,
+ sizeof (HANDLE) *
+ HandlesSize + 10);
+ if (!temp)
+ {
+ printf
+ ("cannot allocate more storage for the handle array!\n");
+ exit (1);
+ }
+ Handles = temp;
+ process **ptemp = (process **) realloc (Entries,
+ sizeof (LPVOID) *
+ HandlesSize + 10);
+ if (!ptemp)
+ {
+ printf
+ ("cannot allocate more storage for the handle array!\n");
+ exit (1);
+ }
+ Entries = ptemp;
+ HandlesSize += 10;
+ }
+ offset += copied;
+ copied =
+ cache->handle_snapshot (&Handles[2], &Entries[2],
+ HandlesSize - 2 - offset, offset);
+ count += copied;
+ }
+ debug_printf ("waiting on %u objects\n", count);
+ DWORD rc = WaitForMultipleObjects (count, Handles, FALSE, INFINITE);
+ if (rc == WAIT_FAILED)
+ {
+ printf ("Could not wait on the process handles (%ld)!\n",
+ GetLastError ());
+ exit (1);
+ }
+ int objindex = rc - WAIT_OBJECT_0;
+ if (objindex > 1 && objindex < count)
+ {
+ debug_printf ("Process %ld has left the building\n",
+ Entries[objindex]->winpid);
+ /* fire off the termination routines */
+ cache->remove_process (Entries[objindex]);
+ }
+ else if (objindex >= 0 && objindex < 2)
+ {
+ /* 0 is shutdown - do nothing */
+ /* 1 is a cache add event - just rebuild the object list */
+ }
+ else
+ {
+ printf
+ ("unexpected return code from WaitForMultiple objects in process_process_param::request_loop\n");
+ }
+ }
+ running = false;
+ return 0;
+}
diff --git a/winsup/cygserver/shm.cc b/winsup/cygserver/shm.cc
new file mode 100644
index 0000000..c29938b
--- /dev/null
+++ b/winsup/cygserver/shm.cc
@@ -0,0 +1,552 @@
+/* cygserver_shm.cc: Single unix specification IPC interface for Cygwin
+
+ Copyright 2001 Red Hat, Inc.
+
+ Originally written by Robert Collins <robert.collins@hotmail.com>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+
+#ifdef __OUTSIDE_CYGWIN__
+#undef __INSIDE_CYGWIN__
+#else
+#include "winsup.h"
+#endif
+
+#ifndef __INSIDE_CYGWIN__
+#define DEBUG 0
+#define system_printf printf
+#define debug_printf if (DEBUG) printf
+#define api_fatal printf
+#include <stdio.h>
+#include <windows.h>
+#endif
+
+#include <sys/stat.h>
+#include <errno.h>
+#include "cygerrno.h"
+#include <unistd.h>
+#include "security.h"
+//#include "fhandler.h"
+//#include "dtable.h"
+//#include "cygheap.h"
+#include <stdio.h>
+//#include "thread.h"
+#ifndef __INSIDE_CYGWIN__
+#define __INSIDE_CYGWIN__
+#include <sys/shm.h>
+#undef __INSIDE_CYGWIN__
+#else
+#include <sys/shm.h>
+#endif
+//#include "perprocess.h"
+#include <threaded_queue.h>
+#include <cygwin/cygserver_process.h>
+#include "cygserver_shm.h"
+
+// FIXME IS THIS CORRECT
+/* Implementation notes: We use two shared memory regions per key:
+ * One for the control structure, and one for the shared memory.
+ * While this has a higher overhead tham a single shared area,
+ * It allows more flexability. As the entire code is transparent to the user
+ * We can merge these in the future should it be needed.
+ * Also, IPC_PRIVATE keys create unique mappings each time. The shm_ids just
+ * keep monotonically incrementing - system wide.
+ */
+size_t
+getsystemallocgranularity ()
+{
+ SYSTEM_INFO sysinfo;
+ static size_t buffer_offset = 0;
+ if (buffer_offset)
+ return buffer_offset;
+ GetSystemInfo (&sysinfo);
+ buffer_offset = sysinfo.dwAllocationGranularity;
+ return buffer_offset;
+}
+
+
+client_request_shm::client_request_shm ():client_request (CYGSERVER_REQUEST_SHM_GET, sizeof (parameters))
+{
+ buffer = (char *) &parameters;
+}
+
+/* FIXME: If building on a 64-bit compiler, the address->int typecast will fail.
+ * Solution: manually calculate the next id value
+ */
+
+#if 0
+extern "C" void *
+shmat (int shmid, const void *shmaddr, int parameters.in.shmflg)
+{
+ class shmid_ds *shm = (class shmid_ds *) shmid; //FIXME: verifyable object test
+
+ if (shmaddr)
+ {
+ //FIXME: requested base address ?!
+ set_errno (EINVAL);
+ return (void *) -1;
+ }
+
+ void *rv = MapViewOfFile (shm->attachmap,
+
+
+ (parameters.in.shmflg & SHM_RDONLY) ?
+ FILE_MAP_READ : FILE_MAP_WRITE, 0,
+ 0, 0);
+
+ if (!rv)
+ {
+ //FIXME: translate GetLastError()
+ set_errno (EACCES);
+ return (void *) -1;
+ }
+
+/* FIXME: this needs to be globally protected to prevent a mismatch betwen
+ * attach count and attachees list
+ */
+
+ InterlockedIncrement (&shm->shm_nattch);
+ _shmattach *attachnode = new _shmattach;
+
+ attachnode->data = rv;
+ attachnode->next =
+ (_shmattach *) InterlockedExchangePointer ((LONG *) & shm->attachhead,
+ (long int) attachnode);
+ return rv;
+}
+#endif
+
+/* FIXME: evaluate getuid() and getgid() against the requested mode. Then
+ * choose PAGE_READWRITE | PAGE_READONLY and FILE_MAP_WRITE | FILE_MAP_READ
+ * appropriately
+ */
+
+/* Test result from openbsd: shm ids are persistent cross process if a handle is left
+ * open. This could lead to resource starvation: we're not copying that behaviour
+ * unless we have to. (It will involve acygwin1.dll gloal shared list :[ ).
+ */
+/* FIXME: shmid should be a verifyable object
+ */
+
+/* FIXME: on NT we should check everything against the SD. On 95 we just emulate.
+ */
+
+extern GENERIC_MAPPING access_mapping;
+
+extern int
+check_and_dup_handle (HANDLE from_process, HANDLE to_process,
+ HANDLE from_process_token,
+ DWORD access,
+ HANDLE from_handle,
+ HANDLE * to_handle_ptr, BOOL bInheritHandle);
+
+//FIXME: where should this live
+static shmnode *shm_head = NULL;
+/* must be long for InterlockedIncrement */
+static long new_id = 0;
+static long new_private_key = 0;
+
+void
+client_request_shm::serve (transport_layer_base * conn,
+ process_cache * cache)
+{
+// DWORD sd_size = 4096;
+// char sd_buf[4096];
+ PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) parameters.in.sd_buf;
+// /* create a sd for our open requests based on shmflag & 0x01ff */
+// psd = alloc_sd (getuid (), getgid (), cygheap->user.logsrv (),
+// parameters.in.shmflg & 0x01ff, psd, &sd_size);
+
+ HANDLE from_process_handle = NULL;
+ HANDLE token_handle = NULL;
+ DWORD rc;
+
+ from_process_handle = cache->process (parameters.in.pid)->handle ();
+ /* possible TODO: reduce the access on the handle before we use it */
+ /* Note that unless we do this, we don't need to call CloseHandle - it's kept open
+ * by the process cache until the process terminates.
+ * We may need a refcount on the cache however...
+ */
+ if (!from_process_handle)
+ {
+ debug_printf ("error opening process (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ return;
+ }
+
+ conn->impersonate_client ();
+
+ rc = OpenThreadToken (GetCurrentThread (),
+ TOKEN_QUERY, TRUE, &token_handle);
+
+ conn->revert_to_self ();
+
+ if (!rc)
+ {
+ debug_printf ("error opening thread token (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ CloseHandle (from_process_handle);
+ return;
+ }
+
+
+ /* we trust the clients request - we will be doing it as them, and
+ * the worst they can do is open their own permissions
+ */
+
+
+ SECURITY_ATTRIBUTES sa;
+ sa.nLength = sizeof (sa);
+ sa.lpSecurityDescriptor = psd;
+ sa.bInheritHandle = TRUE; /* the memory structures inherit ok */
+
+ char *shmname = NULL, *shmaname = NULL;
+ char stringbuf[29], stringbuf1[29];
+
+ /* TODO: make this code block a function! */
+ if (parameters.in.type == SHM_REATTACH)
+ {
+ /* just find and fill out the existing shm_id */
+ shmnode *tempnode = shm_head;
+ while (tempnode)
+ {
+ if (tempnode->shm_id == parameters.in.shm_id)
+ {
+ parameters.out.shm_id = tempnode->shm_id;
+ parameters.out.key = tempnode->key;
+ if (check_and_dup_handle
+ (GetCurrentProcess (), from_process_handle, token_handle,
+ DUPLICATE_SAME_ACCESS, tempnode->filemap,
+ &parameters.out.filemap, TRUE) != 0)
+ {
+ debug_printf ("error duplicating filemap handle (%lu)\n",
+ GetLastError ());
+ header.error_code = EACCES;
+ }
+ if (check_and_dup_handle
+ (GetCurrentProcess (), from_process_handle, token_handle,
+ DUPLICATE_SAME_ACCESS, tempnode->attachmap,
+ &parameters.out.attachmap, TRUE) != 0)
+ {
+ debug_printf ("error duplicating attachmap handle (%lu)\n",
+ GetLastError ());
+ header.error_code = EACCES;
+ }
+ CloseHandle (token_handle);
+ return;
+ }
+ tempnode = tempnode->next;
+ }
+ header.error_code = EINVAL;
+ CloseHandle (token_handle);
+ return;
+ }
+
+ /* someone attached */
+ /* someone can send shm_id's they don't have and currently we will increment those
+ * attach counts. If someone wants to fix that, please go ahead.
+ * The problem is that shm_get has nothing to do with the ability to attach. Attach
+ * requires a permission check, which we get the OS to do in MapViewOfFile.
+ */
+ if (parameters.in.type == SHM_ATTACH)
+ {
+ shmnode *tempnode = shm_head;
+ while (tempnode)
+ {
+ if (tempnode->shm_id == parameters.in.shm_id)
+ {
+ InterlockedIncrement (&tempnode->shmds->shm_nattch);
+ header.error_code = 0;
+ CloseHandle (token_handle);
+ return;
+ }
+ tempnode = tempnode->next;
+ }
+ header.error_code = EINVAL;
+ CloseHandle (token_handle);
+ return;
+ }
+
+ /* it's a original request from the users */
+
+ /* FIXME: enter the checking for existing keys mutex. This mutex _must_ be system wide
+ * to prevent races on shmget.
+ */
+
+ if (parameters.in.key == IPC_PRIVATE)
+ {
+ /* create the mapping name (CYGWINSHMKPRIVATE_0x01234567 */
+ /* The K refers to Key, the actual mapped area has D */
+ long private_key = (int) InterlockedIncrement (&new_private_key);
+ snprintf (stringbuf, 29, "CYGWINSHMKPRIVATE_0x%0x", private_key);
+ shmname = stringbuf;
+ snprintf (stringbuf1, 29, "CYGWINSHMDPRIVATE_0x%0x", private_key);
+ shmaname = stringbuf1;
+ }
+ else
+ {
+ /* create the mapping name (CYGWINSHMK0x0123456789abcdef */
+ /* The K refers to Key, the actual mapped area has D */
+
+ snprintf (stringbuf, 29, "CYGWINSHMK0x%0qx", parameters.in.key);
+ shmname = stringbuf;
+ snprintf (stringbuf1, 29, "CYGWINSHMD0x%0qx", parameters.in.key);
+ shmaname = stringbuf1;
+ debug_printf ("system id strings are \n%s\n%s\n", shmname, shmaname);
+ debug_printf ("key input value is 0x%0qx\n", parameters.in.key);
+ }
+
+ /* attempt to open the key */
+
+ /* get an existing key */
+ /* On unix the same shmid identifier is returned on multiple calls to shm_get
+ * with the same key and size. Different modes is a ?.
+ */
+
+
+
+ /* walk the list of known keys and return the id if found. remember, we are
+ * authoritative...
+ */
+
+ shmnode *tempnode = shm_head;
+ while (tempnode)
+ {
+ if (tempnode->key == parameters.in.key
+ && parameters.in.key != IPC_PRIVATE)
+ {
+ // FIXME: free the mutex
+ if (parameters.in.size
+ && tempnode->shmds->shm_segsz < parameters.in.size)
+ {
+ header.error_code = EINVAL;
+ CloseHandle (token_handle);
+ return;
+ }
+ /* FIXME: can the same process call this twice without error ? test
+ * on unix
+ */
+ if ((parameters.in.shmflg & IPC_CREAT)
+ && (parameters.in.shmflg & IPC_EXCL))
+ {
+ header.error_code = EEXIST;
+ debug_printf
+ ("attempt to exclusively create already created shm_area with key 0x%0qx\n",
+ parameters.in.key);
+ // FIXME: free the mutex
+ CloseHandle (token_handle);
+ return;
+ }
+ // FIXME: do we need to other tests of the requested mode with the
+ // tempnode->shm_id mode ? testcase on unix needed.
+ // FIXME how do we do the security test? or
+ // do we wait for shmat to bother with that?
+ /* One possibly solution: impersonate the client, and then test we can
+ * reopen the area. In fact we'll probably have to do that to get
+ * handles back to them, alternatively just tell them the id, and then
+ * let them attempt the open.
+ */
+ parameters.out.shm_id = tempnode->shm_id;
+ if (check_and_dup_handle (GetCurrentProcess (), from_process_handle,
+ token_handle,
+ DUPLICATE_SAME_ACCESS,
+ tempnode->filemap,
+ &parameters.out.filemap, TRUE) != 0)
+ {
+ printf ("error duplicating filemap handle (%lu)\n",
+ GetLastError ());
+ header.error_code = EACCES;
+/*mutex*/
+ CloseHandle (token_handle);
+ return;
+ }
+ if (check_and_dup_handle (GetCurrentProcess (), from_process_handle,
+ token_handle,
+ DUPLICATE_SAME_ACCESS,
+ tempnode->attachmap,
+ &parameters.out.attachmap, TRUE) != 0)
+ {
+ printf ("error duplicating attachmap handle (%lu)\n",
+ GetLastError ());
+ header.error_code = EACCES;
+/*mutex*/
+ CloseHandle (token_handle);
+ return;
+ }
+
+ CloseHandle (token_handle);
+ return;
+ }
+ tempnode = tempnode->next;
+ }
+ /* couldn't find a currently open shm area. */
+
+ /* create one */
+ /* do this as the client */
+ conn->impersonate_client ();
+ /* This may need sh_none... it's only a control structure */
+ HANDLE filemap = CreateFileMapping (INVALID_HANDLE_VALUE, // system pagefile.
+ &sa,
+ PAGE_READWRITE, // protection
+ 0x00000000,
+ getsystemallocgranularity (),
+ shmname // object name
+ );
+ int lasterr = GetLastError ();
+ conn->revert_to_self ();
+
+ if (filemap == NULL)
+ {
+ /* We failed to open the filemapping ? */
+ system_printf ("failed to open file mapping: %lu\n", GetLastError ());
+ // free the mutex
+ // we can assume that it exists, and that it was an access problem.
+ header.error_code = EACCES;
+ CloseHandle (token_handle);
+ return;
+ }
+
+ /* successfully opened the control region mapping */
+ /* did we create it ? */
+ int oldmapping = lasterr == ERROR_ALREADY_EXISTS;
+ if (oldmapping)
+ {
+ /* should never happen - we are the global daemon! */
+#if 0
+ if ((parameters.in.shmflg & IPC_CREAT)
+ && (parameters.in.shmflg & IPC_EXCL))
+#endif
+ {
+ /* FIXME free mutex */
+ CloseHandle (filemap);
+ header.error_code = EEXIST;
+ CloseHandle (token_handle);
+ return;
+ }
+ }
+
+ /* we created a new mapping */
+ if (parameters.in.key != IPC_PRIVATE &&
+ (parameters.in.shmflg & IPC_CREAT) == 0)
+ {
+ CloseHandle (filemap);
+ /* FIXME free mutex */
+ header.error_code = ENOENT;
+ CloseHandle (token_handle);
+ return;
+ }
+
+ conn->impersonate_client ();
+ void *mapptr = MapViewOfFile (filemap, FILE_MAP_WRITE, 0, 0, 0);
+ conn->revert_to_self ();
+
+ if (!mapptr)
+ {
+ CloseHandle (filemap);
+ //FIXME: close filemap and free the mutex
+ /* we couldn't access the mapped area with the requested permissions */
+ header.error_code = EACCES;
+ CloseHandle (token_handle);
+ return;
+ }
+
+ conn->impersonate_client ();
+ /* Now get the user data */
+ HANDLE attachmap = CreateFileMapping (INVALID_HANDLE_VALUE, // system pagefile
+ &sa,
+ PAGE_READWRITE, // protection (FIXME)
+ 0x00000000,
+ parameters.in.size +
+ parameters.in.size %
+ getsystemallocgranularity (),
+ shmaname // object name
+ );
+ conn->revert_to_self ();
+
+ if (attachmap == NULL)
+ {
+ system_printf ("failed to get shm attachmap\n");
+ header.error_code = ENOMEM;
+ UnmapViewOfFile (mapptr);
+ CloseHandle (filemap);
+ /* FIXME exit the mutex */
+ CloseHandle (token_handle);
+ return;
+ }
+
+ shmid_ds *shmtemp = new shmid_ds;
+ if (!shmtemp)
+ {
+ system_printf ("failed to malloc shm node\n");
+ header.error_code = ENOMEM;
+ UnmapViewOfFile (mapptr);
+ CloseHandle (filemap);
+ CloseHandle (attachmap);
+ /* FIXME exit mutex */
+ CloseHandle (token_handle);
+ return;
+ }
+
+ /* fill out the node data */
+ shmtemp->shm_perm.cuid = getuid ();
+ shmtemp->shm_perm.uid = shmtemp->shm_perm.cuid;
+ shmtemp->shm_perm.cgid = getgid ();
+ shmtemp->shm_perm.gid = shmtemp->shm_perm.cgid;
+ shmtemp->shm_perm.mode = parameters.in.shmflg & 0x01ff;
+ shmtemp->shm_lpid = 0;
+ shmtemp->shm_nattch = 0;
+ shmtemp->shm_atime = 0;
+ shmtemp->shm_dtime = 0;
+ shmtemp->shm_ctime = time (NULL);
+ shmtemp->shm_segsz = parameters.in.size;
+ *(shmid_ds *) mapptr = *shmtemp;
+ shmtemp->mapptr = mapptr;
+
+ /* no need for InterlockedExchange here, we're serialised by the global mutex */
+ tempnode = new shmnode;
+ tempnode->shmds = shmtemp;
+ tempnode->shm_id = (int) InterlockedIncrement (&new_id);
+ tempnode->key = parameters.in.key;
+ tempnode->filemap = filemap;
+ tempnode->attachmap = attachmap;
+ tempnode->next = shm_head;
+ shm_head = tempnode;
+
+ /* we now have the area in the daemon list, opened.
+
+ FIXME: leave the system wide shm mutex */
+
+ parameters.out.shm_id = tempnode->shm_id;
+ if (check_and_dup_handle (GetCurrentProcess (), from_process_handle,
+ token_handle,
+ DUPLICATE_SAME_ACCESS,
+ tempnode->filemap, &parameters.out.filemap,
+ TRUE) != 0)
+ {
+ printf ("error duplicating filemap handle (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ CloseHandle (token_handle);
+/* mutex et al */
+ return;
+ }
+ if (check_and_dup_handle (GetCurrentProcess (), from_process_handle,
+ token_handle,
+ DUPLICATE_SAME_ACCESS,
+ tempnode->attachmap, &parameters.out.attachmap,
+ TRUE) != 0)
+ {
+ printf ("error duplicating attachmap handle (%lu)\n", GetLastError ());
+ header.error_code = EACCES;
+ CloseHandle (from_process_handle);
+ CloseHandle (token_handle);
+/* more cleanup... yay! */
+ return;
+ }
+ CloseHandle (token_handle);
+ return;
+}
diff --git a/winsup/cygserver/shm.h b/winsup/cygserver/shm.h
new file mode 100755
index 0000000..32947f8
--- /dev/null
+++ b/winsup/cygserver/shm.h
@@ -0,0 +1,91 @@
+/* cygserver_shm.h
+
+ Copyright 2001 Red Hat Inc.
+ Written by Robert Collins <rbtcollins@hotmail.com>
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <sys/types.h>
+#include "cygwin/cygserver_transport.h"
+#include "cygwin/cygserver.h"
+
+#define SHM_CREATE 0
+#define SHM_REATTACH 1
+#define SHM_ATTACH 2
+#define SHM_DETACH 3
+
+
+class client_request_shm : public client_request
+{
+ public:
+#ifndef __INSIDE_CYGWIN__
+ virtual void serve (transport_layer_base *conn, process_cache *cache);
+#endif
+ client_request_shm (key_t, size_t, int, char psdbuf[4096], pid_t);
+ client_request_shm ();
+ client_request_shm (int, int, pid_t);
+ client_request_shm (int, int);
+ union {
+ struct {int type; pid_t pid; int shm_id; key_t key; size_t size; int shmflg; char sd_buf[4096];} in;
+ struct {int shm_id; HANDLE filemap; HANDLE attachmap; key_t key;} out;
+ } parameters;
+};
+
+#ifndef __INSIDE_CYGWIN__
+class shm_cleanup : cleanup_routine
+{
+public:
+ virtual void cleanup (long winpid);
+};
+#endif
+#if 0
+class _shmattach {
+public:
+ void *data;
+ class _shmattach *next;
+};
+
+class shmid_ds {
+public:
+ struct ipc_perm shm_perm;
+ size_t shm_segsz;
+ pid_t shm_lpid;
+ pid_t shm_cpid;
+ shmatt_t shm_nattch;
+ time_t shm_atime;
+ time_t shm_dtime;
+ time_t shm_ctime;
+ HANDLE filemap;
+ HANDLE attachmap;
+ void *mapptr;
+ class _shmattach *attachhead;
+};
+
+class shmnode {
+public:
+ class shmid_ds * shmid;
+ class shmnode *next;
+ key_t key;
+};
+//....
+struct shmid_ds {
+ struct ipc_perm shm_perm;
+ size_t shm_segsz;
+ pid_t shm_lpid;
+ pid_t shm_cpid;
+ shmatt_t shm_nattch;
+ time_t shm_atime;
+ time_t shm_dtime;
+ time_t shm_ctime;
+};
+
+void *shmat(int, const void *, int);
+int shmctl(int, int, struct shmid_ds *);
+int shmdt(const void *);
+int shmget(key_t, size_t, int);
+
+#endif
diff --git a/winsup/cygserver/threaded_queue.cc b/winsup/cygserver/threaded_queue.cc
new file mode 100644
index 0000000..5fb22b1
--- /dev/null
+++ b/winsup/cygserver/threaded_queue.cc
@@ -0,0 +1,249 @@
+/* threaded_queue.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Robert Collins <rbtcollins@hotmail.com>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <windows.h>
+#include <sys/types.h>
+#include "wincap.h"
+#include "threaded_queue.h"
+#define DEBUG 1
+#define debug_printf if (DEBUG) printf
+
+/* threaded_queue */
+
+DWORD WINAPI
+worker_function (LPVOID LpParam)
+{
+ class threaded_queue *queue = (class threaded_queue *) LpParam;
+ class queue_request *request;
+ /* FIXME use a threadsafe pop instead for speed? */
+ while (queue->active)
+ {
+ EnterCriticalSection (&queue->queuelock);
+ while (!queue->request && queue->active)
+ {
+ LeaveCriticalSection (&queue->queuelock);
+ DWORD rc = WaitForSingleObject (queue->event, INFINITE);
+ if (rc == WAIT_FAILED)
+ {
+ printf ("Wait for event failed\n");
+ queue->running--;
+ ExitThread (0);
+ }
+ EnterCriticalSection (&queue->queuelock);
+ }
+ if (!queue->active)
+ {
+ queue->running--;
+ LeaveCriticalSection (&queue->queuelock);
+ ExitThread (0);
+ }
+ /* not needed, but it is efficient */
+ request =
+ (class queue_request *) InterlockedExchangePointer (&queue->request,
+ queue->request->
+ next);
+ LeaveCriticalSection (&queue->queuelock);
+ request->process ();
+ delete request;
+ }
+ queue->running--;
+ ExitThread (0);
+}
+
+void
+threaded_queue::create_workers ()
+{
+ InitializeCriticalSection (&queuelock);
+ if ((event = CreateEvent (NULL, FALSE, FALSE, NULL)) == NULL)
+ {
+ printf ("Failed to create event queue (%lu), terminating\n",
+ GetLastError ());
+ exit (1);
+ }
+ active = true;
+
+ /* FIXME: Use a stack pair and create threads on the fly whenever
+ * we have to to service a request.
+ */
+ for (unsigned int i = 0; i < initial_workers; i++)
+ {
+ HANDLE hThread;
+ DWORD tid;
+ hThread = CreateThread (NULL, 0, worker_function, this, 0, &tid);
+ if (hThread == NULL)
+ {
+ printf ("Failed to create thread (%lu), terminating\n",
+ GetLastError ());
+ exit (1);
+ }
+ CloseHandle (hThread);
+ running++;
+ }
+}
+
+void
+threaded_queue::cleanup ()
+{
+ /* harvest the threads */
+ active = false;
+ /* kill the request processing loops */
+ queue_process_param *reqloop;
+ /* make sure we don't race with a incoming request creation */
+ EnterCriticalSection (&queuelock);
+ reqloop =
+ (queue_process_param *) InterlockedExchangePointer (&process_head, NULL);
+ while (reqloop)
+ {
+ queue_process_param *t = reqloop;
+ reqloop = reqloop->next;
+ delete t;
+ }
+ LeaveCriticalSection (&queuelock);
+ if (!running)
+ return;
+ printf ("Waiting for current queue threads to terminate\n");
+ for (int n = running; n; n--)
+ PulseEvent (event);
+ while (running)
+ sleep (1);
+ DeleteCriticalSection (&queuelock);
+ CloseHandle (event);
+}
+
+/* FIXME: return success or failure */
+void
+threaded_queue::add (queue_request * therequest)
+{
+ /* safe to not "Try" because workers don't hog this, they wait on the event
+ */
+ EnterCriticalSection (&queuelock);
+ if (!running)
+ {
+ printf ("No worker threads to handle request!\n");
+ }
+ if (!request)
+ request = therequest;
+ else
+ {
+ /* add to the queue end. */
+ queue_request *listrequest = request;
+ while (listrequest->next)
+ listrequest = listrequest->next;
+ listrequest->next = therequest;
+ }
+ PulseEvent (event);
+ LeaveCriticalSection (&queuelock);
+}
+
+/* FIXME: return success or failure rather than quitting */
+void
+threaded_queue::process_requests (queue_process_param * params,
+ threaded_queue_thread_function *
+ request_loop)
+{
+ if (params->start (request_loop, this) == false)
+ exit (1);
+ params->next =
+ (queue_process_param *) InterlockedExchangePointer (&process_head,
+ params);
+}
+
+/* queue_process_param */
+/* How does a constructor return an error? */
+queue_process_param::queue_process_param (bool ninterruptible):running (false), shutdown (false),
+interruptible
+(ninterruptible)
+{
+ if (!interruptible)
+ return;
+ debug_printf ("creating an interruptible processing thread\n");
+ if ((interrupt = CreateEvent (NULL, FALSE, FALSE, NULL)) == NULL)
+ {
+ printf ("Failed to create interrupt event (%lu), terminating\n",
+ GetLastError ());
+ exit (1);
+ }
+}
+
+queue_process_param::~queue_process_param ()
+{
+ if (running)
+ stop ();
+ if (!interruptible)
+ return;
+ CloseHandle (interrupt);
+}
+
+bool
+ queue_process_param::start (threaded_queue_thread_function * request_loop,
+ threaded_queue * thequeue)
+{
+ queue = thequeue;
+ hThread = CreateThread (NULL, 0, request_loop, this, 0, &tid);
+ if (hThread)
+ {
+ running = true;
+ return true;
+ }
+ printf ("Failed to create thread (%lu), terminating\n", GetLastError ());
+ return false;
+}
+
+void
+queue_process_param::stop ()
+{
+ if (interruptible)
+ {
+ InterlockedExchange (&shutdown, true);
+ PulseEvent (interrupt);
+ /* Wait up to 50 ms for the thread to exit. If it doesn't _and_ we get
+ * scheduled again, we print an error and exit. We _should_ loop or
+ * try resignalling. We don't want to hand here though...
+ */
+ int n = 5;
+ while (n-- && WaitForSingleObject (hThread, 1000) == WAIT_TIMEOUT);
+ if (!n)
+ {
+ printf ("Process thread didn't shutdown cleanly after 200ms!\n");
+ exit (1);
+ }
+ else
+ running = false;
+ }
+ else
+ {
+ printf ("killing request loop thread %ld\n", tid);
+ int rc;
+ if (!(rc = TerminateThread (hThread, 0)))
+ {
+ printf ("error shutting down request loop worker thread\n");
+ }
+ running = false;
+ }
+ CloseHandle (hThread);
+}
+
+/* queue_request */
+queue_request::queue_request ():next (NULL)
+{
+}
+
+void
+queue_request::process (void)
+{
+ printf ("\n**********************************************\n"
+ "Oh no! we've hit the base queue_request process() function, and this indicates a coding\n"
+ "fault !!!\n" "***********************************************\n");
+}
diff --git a/winsup/cygserver/transport.cc b/winsup/cygserver/transport.cc
new file mode 100644
index 0000000..7c6e5fe
--- /dev/null
+++ b/winsup/cygserver/transport.cc
@@ -0,0 +1,92 @@
+/* cygserver_transport.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Robert Collins <rbtcollins@hotmail.com>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include "wincap.h"
+#include "cygwin/cygserver_transport.h"
+#include "cygwin/cygserver_transport_pipes.h"
+#include "cygwin/cygserver_transport_sockets.h"
+
+/* to allow this to link into cygwin and the .dll, a little magic is needed. */
+#ifndef __OUTSIDE_CYGWIN__
+#include "winsup.h"
+#else
+#define debug_printf printf
+#endif
+
+/* The factory */
+class transport_layer_base *create_server_transport()
+{
+ transport_layer_base *temp;
+ /* currently there is only the base class! */
+ if (wincap.is_winnt ())
+ temp = new transport_layer_pipes ();
+ else
+ temp = new transport_layer_base ();
+ return temp;
+}
+
+
+transport_layer_base::transport_layer_base ()
+{
+ /* should we throw an error of some sort ? */
+}
+
+void
+transport_layer_base::listen ()
+{
+}
+
+class transport_layer_base *
+transport_layer_base::accept ()
+{
+ return NULL;
+}
+
+void
+transport_layer_base::close()
+{
+}
+
+ssize_t
+transport_layer_base::read (char *buf, size_t len)
+{
+ return 0;
+}
+
+ssize_t
+transport_layer_base::write (char *buf, size_t len)
+{
+ return 0;
+}
+
+bool
+transport_layer_base::connect ()
+{
+ return false;
+}
+
+void
+transport_layer_base::impersonate_client ()
+{
+}
+
+void
+transport_layer_base::revert_to_self ()
+{
+}
diff --git a/winsup/cygserver/transport_pipes.cc b/winsup/cygserver/transport_pipes.cc
new file mode 100644
index 0000000..5b5a017
--- /dev/null
+++ b/winsup/cygserver/transport_pipes.cc
@@ -0,0 +1,205 @@
+/* cygserver_transport_pipes.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Robert Collins <rbtcollins@hotmail.com>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include "wincap.h"
+#include "cygwin/cygserver_transport.h"
+#include "cygwin/cygserver_transport_pipes.h"
+
+/* to allow this to link into cygwin and the .dll, a little magic is needed. */
+#ifndef __OUTSIDE_CYGWIN__
+#include "winsup.h"
+#else
+#define DEBUG 0
+#define debug_printf if (DEBUG) printf
+#endif
+
+transport_layer_pipes::transport_layer_pipes (HANDLE new_pipe)
+{
+ pipe = new_pipe;
+ if (inited != true)
+ init_security();
+};
+
+transport_layer_pipes::transport_layer_pipes ()
+{
+ pipe = NULL;
+ strcpy(pipe_name, "\\\\.\\pipe\\cygwin_lpc");
+ if (inited != true)
+ init_security();
+}
+
+
+void
+transport_layer_pipes::init_security()
+{
+ /* FIXME: pthread_once or equivalent needed */
+ InitializeSecurityDescriptor (&sd, SECURITY_DESCRIPTOR_REVISION);
+ SetSecurityDescriptorDacl (&sd, TRUE, 0, FALSE);
+
+ sec_none_nih.nLength = sec_all_nih.nLength = sizeof (SECURITY_ATTRIBUTES);
+ sec_none_nih.bInheritHandle = sec_all_nih.bInheritHandle = FALSE;
+ sec_none_nih.lpSecurityDescriptor = NULL;
+ sec_all_nih.lpSecurityDescriptor = &sd;
+ inited = true;
+}
+
+void
+transport_layer_pipes::listen ()
+{
+ /* no-op */
+}
+
+class transport_layer_pipes *
+transport_layer_pipes::accept ()
+{
+ if (pipe)
+ {
+ debug_printf ("Already have a pipe in this %p\n",this);
+ return NULL;
+ }
+
+ pipe = CreateNamedPipe (pipe_name,
+ PIPE_ACCESS_DUPLEX,
+ PIPE_TYPE_BYTE | PIPE_WAIT,
+ PIPE_UNLIMITED_INSTANCES,
+ 0, 0, 1000,
+ &sec_all_nih );
+ if (pipe == INVALID_HANDLE_VALUE)
+ {
+ debug_printf ("error creating pipe (%lu)\n.", GetLastError ());
+ return NULL;
+ }
+
+ if ( !ConnectNamedPipe ( pipe, NULL ) &&
+ GetLastError () != ERROR_PIPE_CONNECTED)
+ {
+ printf ("error connecting to pipe (%lu)\n.", GetLastError ());
+ CloseHandle (pipe);
+ pipe = NULL;
+ return NULL;
+ }
+
+ transport_layer_pipes *new_conn = new transport_layer_pipes (pipe);
+ pipe = NULL;
+
+ return new_conn;
+}
+
+void
+transport_layer_pipes::close()
+{
+ debug_printf ("closing pipe %p\n", pipe);
+ if (pipe && pipe != INVALID_HANDLE_VALUE)
+ {
+ FlushFileBuffers (pipe);
+ DisconnectNamedPipe (pipe);
+ CloseHandle (pipe);
+ }
+}
+
+ssize_t
+transport_layer_pipes::read (char *buf, size_t len)
+{
+ debug_printf ("reading from pipe %p\n", pipe);
+ if (!pipe || pipe == INVALID_HANDLE_VALUE)
+ return -1;
+
+ DWORD bytes_read;
+ DWORD rc = ReadFile (pipe, buf, len, &bytes_read, NULL);
+ if (!rc)
+ {
+ debug_printf ("error reading from pipe (%lu)\n", GetLastError ());
+ return -1;
+ }
+ return bytes_read;
+}
+
+ssize_t
+transport_layer_pipes::write (char *buf, size_t len)
+{
+ debug_printf ("writing to pipe %p\n", pipe);
+ DWORD bytes_written, rc;
+ if (!pipe || pipe == INVALID_HANDLE_VALUE)
+ return -1;
+
+ rc = WriteFile (pipe, buf, len, &bytes_written, NULL);
+ if (!rc)
+ {
+ debug_printf ("error writing to pipe (%lu)\n", GetLastError ());
+ return -1;
+ }
+ return bytes_written;
+}
+
+bool
+transport_layer_pipes::connect ()
+{
+ if (pipe && pipe != INVALID_HANDLE_VALUE)
+ {
+ debug_printf ("Already have a pipe in this %p\n",this);
+ return false;
+ }
+
+ while (1)
+ {
+ pipe = CreateFile (pipe_name,
+ GENERIC_READ | GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ &sec_all_nih,
+ OPEN_EXISTING,
+ 0, NULL);
+
+ if (pipe != INVALID_HANDLE_VALUE)
+ /* got the pipe */
+ return true;
+
+ if (GetLastError () != ERROR_PIPE_BUSY)
+ {
+ debug_printf ("Error opening the pipe (%lu)\n", GetLastError ());
+ pipe = NULL;
+ return false;
+ }
+ if (!WaitNamedPipe (pipe_name, 20000))
+ debug_printf ( "error connecting to server pipe after 20 seconds (%lu)\n", GetLastError () );
+ /* We loop here, because the pipe exists but is busy. If it doesn't exist
+ * the != ERROR_PIPE_BUSY will catch it.
+ */
+ }
+}
+
+void
+transport_layer_pipes::impersonate_client ()
+{
+ debug_printf ("impersonating pipe %p\n", pipe);
+ if (pipe && pipe != INVALID_HANDLE_VALUE)
+ {
+ BOOL rv = ImpersonateNamedPipeClient (pipe);
+ if (!rv)
+ debug_printf ("Failed to Impersonate the client, (%lu)\n", GetLastError ());
+ }
+ debug_printf("I am who you are\n");
+}
+
+void
+transport_layer_pipes::revert_to_self ()
+{
+ RevertToSelf ();
+ debug_printf("I am who I yam\n");
+}
+
diff --git a/winsup/cygserver/transport_sockets.cc b/winsup/cygserver/transport_sockets.cc
new file mode 100644
index 0000000..6b75365
--- /dev/null
+++ b/winsup/cygserver/transport_sockets.cc
@@ -0,0 +1,131 @@
+/* cygserver_transport_sockets.cc
+
+ Copyright 2001 Red Hat Inc.
+
+ Written by Robert Collins <rbtcollins@hotmail.com>
+
+ This file is part of Cygwin.
+
+ This software is a copyrighted work licensed under the terms of the
+ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
+ details. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include "wincap.h"
+#include "cygwin/cygserver_transport.h"
+#include "cygwin/cygserver_transport_sockets.h"
+
+/* to allow this to link into cygwin and the .dll, a little magic is needed. */
+#ifndef __OUTSIDE_CYGWIN__
+#include "winsup.h"
+extern "C" int
+cygwin_socket (int af, int type, int protocol);
+extern "C" int
+cygwin_connect (int fd,
+ const struct sockaddr *name,
+ int namelen);
+extern "C" int
+cygwin_accept (int fd, struct sockaddr *peer, int *len);
+extern "C" int
+cygwin_listen (int fd, int backlog);
+extern "C" int
+cygwin_bind (int fd, const struct sockaddr *my_addr, int addrlen);
+
+#else
+#define cygwin_accept(A,B,C) ::accept(A,B,C)
+#define cygwin_socket(A,B,C) ::socket(A,B,C)
+#define cygwin_listen(A,B) ::listen(A,B)
+#define cygwin_bind(A,B,C) ::bind(A,B,C)
+#define cygwin_connect(A,B,C) ::connect(A,B,C)
+#define debug_printf printf
+#endif
+
+transport_layer_sockets::transport_layer_sockets (int newfd): fd(newfd)
+{
+ /* This may not be needed in this constructor - it's only used
+ * when creating a connection via bind or connect
+ */
+ sockdetails.sa_family = AF_UNIX;
+ strcpy (sockdetails.sa_data, "/tmp/cygdaemo");
+ sdlen = strlen(sockdetails.sa_data) + sizeof(sockdetails.sa_family);
+};
+
+transport_layer_sockets::transport_layer_sockets (): fd (-1)
+{
+ sockdetails.sa_family = AF_UNIX;
+ strcpy (sockdetails.sa_data, "/tmp/cygdaemo");
+ sdlen = strlen(sockdetails.sa_data) + sizeof(sockdetails.sa_family);
+}
+
+void
+transport_layer_sockets::listen ()
+{
+ /* we want a thread pool based approach. */
+ if ((fd = cygwin_socket (AF_UNIX, SOCK_STREAM,0)) < 0)
+ printf ("Socket not created error %d\n", errno);
+ if (cygwin_bind(fd, &sockdetails, sdlen))
+ printf ("Bind doesn't like you. Tsk Tsk. Bind said %d\n", errno);
+ if (cygwin_listen(fd, 5) < 0)
+ printf ("And the OS just isn't listening, all it says is %d\n", errno);
+}
+
+class transport_layer_sockets *
+transport_layer_sockets::accept ()
+{
+ /* FIXME: check we have listened */
+ int new_fd;
+
+ if ((new_fd = cygwin_accept(fd, &sockdetails, &sdlen)) < 0)
+ {
+ printf ("Nup, could' accept. %d\n",errno);
+ return NULL;
+ }
+
+ transport_layer_sockets *new_conn = new transport_layer_sockets (new_fd);
+
+ return new_conn;
+
+}
+
+void
+transport_layer_sockets::close()
+{
+ /* FIXME - are we open? */
+ ::close (fd);
+}
+
+ssize_t
+transport_layer_sockets::read (char *buf, size_t len)
+{
+ /* FIXME: are we open? */
+ return ::read (fd, buf, len);
+}
+
+ssize_t
+transport_layer_sockets::write (char *buf, size_t len)
+{
+ /* FIXME: are we open? */
+ return ::write (fd, buf, len);
+}
+
+bool
+transport_layer_sockets::connect ()
+{
+ /* are we already connected? */
+ if (fd != -1)
+ return false;
+ fd = cygwin_socket (AF_UNIX, SOCK_STREAM, 0);
+ if (cygwin_connect (fd, &sockdetails, sdlen) < 0)
+ {
+ debug_printf("client connect failure %d\n", errno);
+ ::close (fd);
+ return false;
+ }
+ return true;
+}