diff options
| -rw-r--r-- | winsup/cygwin/ChangeLog | 19 | ||||
| -rw-r--r-- | winsup/cygwin/Makefile.in | 41 | ||||
| -rw-r--r-- | winsup/cygwin/autoload.cc | 1 | ||||
| -rwxr-xr-x | winsup/cygwin/cygserver.cc | 546 | ||||
| -rwxr-xr-x | winsup/cygwin/cygserver_client.cc | 225 | ||||
| -rwxr-xr-x | winsup/cygwin/cygserver_shm.cc | 530 | ||||
| -rw-r--r-- | winsup/cygwin/cygserver_shm.h | 80 | ||||
| -rwxr-xr-x | winsup/cygwin/cygserver_transport.cc | 154 | ||||
| -rwxr-xr-x | winsup/cygwin/cygserver_transport_pipes.cc | 195 | ||||
| -rw-r--r-- | winsup/cygwin/cygwin.din | 4 | ||||
| -rw-r--r-- | winsup/cygwin/dcrt0.cc | 5 | ||||
| -rw-r--r-- | winsup/cygwin/fhandler.h | 2 | ||||
| -rw-r--r-- | winsup/cygwin/fhandler_tty.cc | 108 | ||||
| -rw-r--r-- | winsup/cygwin/fork.cc | 3 | ||||
| -rwxr-xr-x | winsup/cygwin/include/cygwin/cygserver.h | 126 | ||||
| -rwxr-xr-x | winsup/cygwin/include/cygwin/cygserver_transport.h | 53 | ||||
| -rw-r--r-- | winsup/cygwin/include/sys/ipc.h | 52 | ||||
| -rw-r--r-- | winsup/cygwin/include/sys/shm.h | 89 | ||||
| -rw-r--r-- | winsup/cygwin/ipc.cc | 39 | ||||
| -rw-r--r-- | winsup/cygwin/pinfo.h | 2 | ||||
| -rw-r--r-- | winsup/cygwin/security.h | 2 | ||||
| -rw-r--r-- | winsup/cygwin/shm.cc | 446 | ||||
| -rw-r--r-- | winsup/cygwin/tty.cc | 5 | ||||
| -rw-r--r-- | winsup/cygwin/winsup.h | 2 |
24 files changed, 2692 insertions, 37 deletions
diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog index 5c438d30e..a669828e7 100644 --- a/winsup/cygwin/ChangeLog +++ b/winsup/cygwin/ChangeLog @@ -1,3 +1,22 @@ +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. + Mon Sep 24 18:46:39 2001 Christopher Faylor <cgf@cygnus.com> * select.cc (peek_pipe): Only grab mutex when we actually got something diff --git a/winsup/cygwin/Makefile.in b/winsup/cygwin/Makefile.in index 23012c75d..edcf6de15 100644 --- a/winsup/cygwin/Makefile.in +++ b/winsup/cygwin/Makefile.in @@ -116,16 +116,19 @@ MALLOC_OFILES=@MALLOC_OFILES@ DLL_IMPORTS:=$(w32api_lib)/libkernel32.a -DLL_OFILES:=assert.o autoload.o cygheap.o dcrt0.o debug.o delqueue.o dir.o \ +DLL_OFILES:=assert.o autoload.o cygheap.o cygserver_client.o cygserver_shm.o \ + cygserver_transport.o cygserver_transport_pipes.o dcrt0.o debug.o \ + delqueue.o dir.o \ dlfcn.o dll_init.o dtable.o environ.o errno.o exceptions.o exec.o \ external.o fcntl.o fhandler.o fhandler_clipboard.o fhandler_console.o \ fhandler_dsp.o fhandler_floppy.o fhandler_mem.o fhandler_random.o \ fhandler_raw.o fhandler_serial.o fhandler_socket.o fhandler_tape.o \ fhandler_termios.o fhandler_tty.o fhandler_windows.o fhandler_zero.o \ - fork.o glob.o grp.o heap.o init.o ioctl.o localtime.o malloc.o \ + fork.o glob.o grp.o heap.o init.o ioctl.o ipc.o localtime.o malloc.o \ miscfuncs.o mmap.o net.o ntea.o passwd.o path.o pinfo.o pipe.o poll.o \ pthread.o regexp.o regerror.o regsub.o registry.o resource.o scandir.o \ - sched.o sec_acl.o sec_helper.o security.o select.o shared.o shortcut.o signal.o sigproc.o \ + sched.o sec_acl.o sec_helper.o security.o select.o shared.o shm.o \ + shortcut.o signal.o sigproc.o \ smallprint.o spawn.o strace.o strsep.o sync.o syscalls.o sysconf.o \ syslog.o termios.o thread.o times.o tty.o uinfo.o uname.o wait.o \ wincap.o window.o \ @@ -144,13 +147,16 @@ install_host=@install_host@ all: all_target $(all_host) -all_target: $(LIB_NAME) automode.o binmode.o textmode.o $(LIBGMON_A) +all_target: $(LIB_NAME) automode.o binmode.o textmode.o $(LIBGMON_A) cygserver.exe all_host: new-$(LIB_NAME) cygrun.exe force: -install: install-libs install-headers $(install_host) $(install_target) +install: install-bin install-libs install-headers $(install_host) $(install_target) + +install-bin: cygserver.exe + $(INSTALL_PROGRAM) cygserver.exe $(bindir)/cygserver.exe install-libs: $(LIB_NAME) $(INSTALL_DATA) new-$(DLL_NAME) $(bindir)/$(DLL_NAME); \ @@ -210,13 +216,34 @@ version.cc winver.o: winver_stamp winver_stamp: mkvers.sh include/cygwin/version.h winver.rc $(DLL_OFILES) @echo "Making version.o and winver.o";\ $(SHELL) ${word 1,$^} ${word 2,$^} ${word 3,$^} $(WINDRES) && \ - touch $@ && \ - $(COMPILE_CXX) -o version.o version.cc + $(CXX) -c -o version.o version.cc &&\ + touch $@ cygrun.exe : cygrun.o $(LIB_NAME) $(w32api_lib)/libuser32.a \ $(w32api_lib)/libshell32.a $(w32api_lib)/libkernel32.a $(CC) -nodefaultlibs -o $@ $^ +cygserver_transport_outside.o: cygserver_transport.cc + $(COMPILE_CXX) -D__OUTSIDE_CYGWIN__ -o $@ $< + +cygserver_transport_pipes_outside.o: cygserver_transport_pipes.cc + $(COMPILE_CXX) -D__OUTSIDE_CYGWIN__ -o $@ $< + +cygserver_client_outside.o: cygserver_client.cc + $(COMPILE_CXX) -D__OUTSIDE_CYGWIN__ -o $@ $< + +cygserver_shm_outside.o: cygserver_shm.cc + $(COMPILE_CXX) -D__OUTSIDE_CYGWIN__ -o $@ $< + +cygserver.exe: cygserver.o cygserver_shm_outside.o cygserver_transport_outside.o cygserver_transport_pipes_outside.o cygserver_client_outside.o wincap.o smallprint.o + $(CXX) -o $@ $^ +#ifdef VERBOSE +# $(CXX) $(MINGW_CXXFLAGS) -o $@ ${wordlist 1,3,$^} -B$(mingw_build)/ $(MINGW_LDFLAGS) +#else +# @echo $(CXX) -o $@ ${wordlist 1,3,$^} ${filter-out -B%, $(MINGW_CXXFLAGS) $(MINGW_LDFLAGS)};\ +# $(CXX) $(MINGW_CXXFLAGS) -o $@ ${wordlist 1,3,$^} -B$(mingw_build)/ $(MINGW_LDFLAGS) +#endif + # Makefile: cygwin.din diff --git a/winsup/cygwin/autoload.cc b/winsup/cygwin/autoload.cc index d1cbd59cc..ffd9f0078 100644 --- a/winsup/cygwin/autoload.cc +++ b/winsup/cygwin/autoload.cc @@ -327,6 +327,7 @@ LoadDLLfunc (GetSidSubAuthorityCount, 4, advapi32) LoadDLLfunc (GetTokenInformation, 20, advapi32) LoadDLLfunc (GetUserNameA, 8, advapi32) LoadDLLfunc (ImpersonateLoggedOnUser, 4, advapi32) +LoadDLLfunc (ImpersonateNamedPipeClient, 4, advapi32) LoadDLLfunc (InitializeAcl, 12, advapi32) LoadDLLfunc (InitializeSecurityDescriptor, 8, advapi32) LoadDLLfunc (InitializeSid, 12, advapi32) diff --git a/winsup/cygwin/cygserver.cc b/winsup/cygwin/cygserver.cc new file mode 100755 index 000000000..34141d3bf --- /dev/null +++ b/winsup/cygwin/cygserver.cc @@ -0,0 +1,546 @@ +/* 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 "wincap.h" + +#include "getopt.h" + +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" +#include "cygserver_shm.h" + + +GENERIC_MAPPING access_mapping; +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) +{ + 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; + } + + ret_val = 0; + +out: + if (local_handle && from_process != GetCurrentProcess ()) + CloseHandle (local_handle); + + 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) +{ + return check_and_dup_handle(from_process,to_process,from_process_token,access,from_handle,to_handle_ptr,FALSE); +} + +void +client_request_attach_tty::serve(transport_layer_base *conn) +{ + 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; + } + +#ifdef DEBUG + printf ("%d:(%d,%d) -> %d\n", req.master_pid, + req.from_master, req.to_master, + req.pid); +#endif + + from_process_handle = OpenProcess (PROCESS_DUP_HANDLE, FALSE, req.master_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; + } + + transport->impersonate_client (); + + rc = OpenThreadToken (GetCurrentThread (), + TOKEN_QUERY, + TRUE, + &token_handle); + + transport->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) != 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) != 0) + { + printf ("error duplicating to_master handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; + goto out; + } + } + +#ifdef DEBUG + printf ("%d -> %d(%d,%d)\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) +{ + 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: + class server_request *next; + server_request (transport_layer_base *newconn); + void process (); + private: + char request_buffer [MAX_REQUEST_SIZE]; + transport_layer_base *conn; +}; + +class server_request_queue +{ + public: + CRITICAL_SECTION queuelock; + HANDLE event; + server_request * request; + bool active; + unsigned int initial_workers; + unsigned int running; + void create_workers (); + void cleanup (); + void add (transport_layer_base *conn); +}; +class server_request_queue request_queue; + +void +client_request_shutdown::serve (transport_layer_base *conn) +{ + /* 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) +{ + conn = newconn; + next = NULL; +} + +void +server_request::process () +{ + ssize_t bytes_read, bytes_written; + struct request_header* req_ptr = (struct request_header*) &request_buffer; + client_request *req = NULL; + 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; + } + 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_get (); break; + default: + req = new client_request (CYGSERVER_REQUEST_INVALID); + req->header.error_code = ENOSYS; + printf ("Bad client request - returning ENOSYS\n"); + } + + if (req->header.cb != req_ptr->cb) + { + 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) + { + printf ("error reading from connection (%lu)\n", GetLastError ()); + goto out; + } + 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); + + if ((bytes_written = conn->write ((char *)&req->header, sizeof (req->header))) + != sizeof(req->header) || + (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; + } + + printf("Sent reply, size (%ld)\n",bytes_written); + +out: + conn->close (); + delete conn; + if (req) + delete (req); +} + +DWORD WINAPI +worker_function( LPVOID LpParam ) +{ + class server_request_queue *queue = (class server_request_queue *) LpParam; + class server_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 server_request *)InterlockedExchangePointer (&queue->request, queue->request->next); + LeaveCriticalSection (&queue->queuelock); + request->process (); + delete request; + } + queue->running--; + ExitThread (0); +} + +void +server_request_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 +server_request_queue::cleanup () +{ + /* harvest the threads */ + active = false; + if (!running) + return; + printf ("Waiting for current connections to terminate\n"); + for (int n=running; n; n--) + PulseEvent (event); + while (running) + sleep (1); + DeleteCriticalSection (&queuelock); + CloseHandle (event); +} + +void +server_request_queue::add (transport_layer_base *conn) +{ + /* 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"); + conn->close (); + delete conn; + } + server_request * listrequest; + if (!request) + { + request = new server_request (conn); + listrequest = request; + } + else + { + /* add to the queue end. */ + listrequest = request; + while (listrequest->next) + listrequest = listrequest->next; + listrequest->next = new server_request (conn); + listrequest = listrequest->next; + } + PulseEvent (event); + LeaveCriticalSection (&queuelock); +} + +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); + } + + transport->listen (); + request_queue.initial_workers = 10; + request_queue.create_workers(); + while (request_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 && request_queue.active) + request_queue.add (new_conn); + } + printf ("No longer accepting requests.\n"); + request_queue.cleanup (); + transport->close (); +} diff --git a/winsup/cygwin/cygserver_client.cc b/winsup/cygwin/cygserver_client.cc new file mode 100755 index 000000000..1dc8f2d6e --- /dev/null +++ b/winsup/cygwin/cygserver_client.cc @@ -0,0 +1,225 @@ +/* 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.h" + +/* 0 = untested, 1 = running, 2 = dead */ +int cygserver_running=CYGSERVER_UNKNOWN; + +client_request_get_version::client_request_get_version () : client_request (CYGSERVER_REQUEST_GET_VERSION) +{ + header.cb = sizeof (version); + buffer = (char *)&version; +} + +#ifdef __INSIDE_CYGWIN__ +void +client_request_get_version::serve (transport_layer_base *conn) +{ +} +#endif + +client_request_attach_tty::client_request_attach_tty () : client_request (CYGSERVER_REQUEST_ATTACH_TTY) +{ + header.cb = 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) +{ + header.cb = sizeof (req); + buffer = (char *)&req; + req.pid = npid; + req.master_pid = nmaster_pid; + req.from_master = nfrom_master; + req.to_master = nto_master; +} + +#ifdef __INSIDE_CYGWIN__ +void +client_request_attach_tty::serve (transport_layer_base *conn) +{ +} +#endif + +client_request_shutdown::client_request_shutdown () : client_request (CYGSERVER_REQUEST_SHUTDOWN) +{ + header.cb = 0; + buffer = NULL; +} + +#ifdef __INSIDE_CYGWIN__ +void +client_request_shutdown::serve (transport_layer_base *conn) +{ +} +#endif + +client_request::client_request (cygserver_request_code id) +{ + header.req_id = id; + header.error_code = 0; +} + +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) + 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 (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/cygwin/cygserver_shm.cc b/winsup/cygwin/cygserver_shm.cc new file mode 100755 index 000000000..97246f0e3 --- /dev/null +++ b/winsup/cygwin/cygserver_shm.cc @@ -0,0 +1,530 @@ +/* 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 system_printf printf +#define debug_printf 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 "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_get::client_request_shm_get () : client_request (CYGSERVER_REQUEST_SHM_GET) +{ + header.cb = sizeof (parameters); + buffer = (char *) ¶meters; + header.error_code = 0; +} + +client_request_shm_get::client_request_shm_get (int nshm_id, pid_t npid) : client_request (CYGSERVER_REQUEST_SHM_GET) +{ + header.cb = sizeof (parameters); + buffer = (char *) ¶meters; + header.error_code = 0; + parameters.in.shm_id = nshm_id; + parameters.in.type = SHM_REATTACH; + parameters.in.pid = npid; +} + +client_request_shm_get::client_request_shm_get (key_t nkey, size_t nsize, + int nshmflg, char psdbuf[4096], pid_t npid): client_request (CYGSERVER_REQUEST_SHM_GET) +{ + header.cb = sizeof (parameters); + buffer = (char *) ¶meters; + parameters.in.key = nkey; + parameters.in.size = nsize; + parameters.in.shmflg = nshmflg; + parameters.in.type = SHM_CREATE; + parameters.in.pid = npid; + memcpy (parameters.in.sd_buf, psdbuf, 4096); +} + +/* 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. + */ + +/* for dll size */ +#ifdef __INSIDE_CYGWIN__ +void +client_request_shm_get::serve (transport_layer_base * conn) +{ +} +#else + +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_get::serve (transport_layer_base * conn) +{ +// 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 = OpenProcess (PROCESS_DUP_HANDLE, FALSE, parameters.in.pid); + if (!from_process_handle) + { + 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) + { + 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]; + + 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, ¶meters.out.filemap, TRUE) != 0) + { + printf ("error duplicating filemap handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; + CloseHandle (from_process_handle); + } + if (check_and_dup_handle (GetCurrentProcess (),from_process_handle, + token_handle, + DUPLICATE_SAME_ACCESS, + tempnode->attachmap, ¶meters.out.attachmap, TRUE) != 0) + { + printf ("error duplicating attachmap handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; + CloseHandle (from_process_handle); + } + return; + } + tempnode = tempnode->next; + } + header.error_code = EINVAL; + 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; + 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 + 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, ¶meters.out.filemap,TRUE) != 0) + { + printf ("error duplicating filemap handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; +/*mutex*/ + CloseHandle (from_process_handle); + return; + } +if (check_and_dup_handle (GetCurrentProcess (),from_process_handle, + token_handle, + DUPLICATE_SAME_ACCESS, + tempnode->attachmap, ¶meters.out.attachmap, TRUE) != 0) + { + printf ("error duplicating attachmap handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; +/*mutex*/ + CloseHandle (from_process_handle); +return; + } + + 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; + 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; + 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; + 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; + 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 */ + 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 */ + 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, ¶meters.out.filemap, TRUE) != 0) + { + printf ("error duplicating filemap handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; + CloseHandle (from_process_handle); +/* mutex et al */ +return; + } +if (check_and_dup_handle (GetCurrentProcess (),from_process_handle, + token_handle, + DUPLICATE_SAME_ACCESS, + tempnode->attachmap, ¶meters.out.attachmap, TRUE) != 0) + { + printf ("error duplicating attachmap handle (%lu)\n", GetLastError ()); + header.error_code = EACCES; + CloseHandle (from_process_handle); +/* more cleanup... yay! */ +return; + } + return; +} +#endif diff --git a/winsup/cygwin/cygserver_shm.h b/winsup/cygwin/cygserver_shm.h new file mode 100644 index 000000000..fe4018d32 --- /dev/null +++ b/winsup/cygwin/cygserver_shm.h @@ -0,0 +1,80 @@ +/* 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 <sys/socket.h> +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" + +#define SHM_CREATE 0 +#define SHM_REATTACH 1 + + +class client_request_shm_get : public client_request +{ + public: + virtual void serve (transport_layer_base *conn); + client_request_shm_get::client_request_shm_get(key_t, size_t, int, char psdbuf[4096], pid_t); + client_request_shm_get::client_request_shm_get(); + client_request_shm_get::client_request_shm_get(int,pid_t); + 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; +}; + +#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/cygwin/cygserver_transport.cc b/winsup/cygwin/cygserver_transport.cc new file mode 100755 index 000000000..d18e0436a --- /dev/null +++ b/winsup/cygwin/cygserver_transport.cc @@ -0,0 +1,154 @@ +/* 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" + +/* 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 + +/* 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 (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_base::transport_layer_base (): 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_base::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_base * +transport_layer_base::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_base *new_conn = new transport_layer_base (new_fd); + + return new_conn; + +} + +void +transport_layer_base::close() +{ + /* FIXME - are we open? */ + ::close (fd); +} + +ssize_t +transport_layer_base::read (char *buf, size_t len) +{ + /* FIXME: are we open? */ + return ::read (fd, buf, len); +} + +ssize_t +transport_layer_base::write (char *buf, size_t len) +{ + /* FIXME: are we open? */ + return ::write (fd, buf, len); +} + +bool +transport_layer_base::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; +} + +void +transport_layer_base::impersonate_client () +{ +} + +void +transport_layer_base::revert_to_self () +{ +} + diff --git a/winsup/cygwin/cygserver_transport_pipes.cc b/winsup/cygwin/cygserver_transport_pipes.cc new file mode 100755 index 000000000..77eede492 --- /dev/null +++ b/winsup/cygwin/cygserver_transport_pipes.cc @@ -0,0 +1,195 @@ +/* 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" + +/* 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 + +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() +{ + if (pipe && pipe != INVALID_HANDLE_VALUE) + { + FlushFileBuffers (pipe); + DisconnectNamedPipe (pipe); + CloseHandle (pipe); + } +} + +ssize_t +transport_layer_pipes::read (char *buf, size_t len) +{ + DWORD bytes_read, rc; + if (!pipe || pipe == INVALID_HANDLE_VALUE) + return -1; + + 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) +{ + 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 () +{ + if (pipe && pipe != INVALID_HANDLE_VALUE) + ImpersonateNamedPipeClient (pipe); + 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/cygwin/cygwin.din b/winsup/cygwin/cygwin.din index 66ba82e03..09f39f83f 100644 --- a/winsup/cygwin/cygwin.din +++ b/winsup/cygwin/cygwin.din @@ -1220,3 +1220,7 @@ acltotext _acltotext = acltotext aclfromtext _aclfromtext = aclfromtext +ftok +shmat +shmctl +shmget diff --git a/winsup/cygwin/dcrt0.cc b/winsup/cygwin/dcrt0.cc index f347ade63..00059f272 100644 --- a/winsup/cygwin/dcrt0.cc +++ b/winsup/cygwin/dcrt0.cc @@ -34,6 +34,9 @@ details. */ #include "shared_info.h" #include "cygwin_version.h" #include "dll_init.h" +#include <sys/socket.h> +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" #define MAX_AT_FILE_LEVEL 10 @@ -688,6 +691,8 @@ dll_crt0_1 () /* Initialize signal/subprocess handling. */ sigproc_init (); + cygserver_init (); + /* Connect to tty. */ tty_init (); diff --git a/winsup/cygwin/fhandler.h b/winsup/cygwin/fhandler.h index ed9ca350b..72c80c392 100644 --- a/winsup/cygwin/fhandler.h +++ b/winsup/cygwin/fhandler.h @@ -839,6 +839,8 @@ public: off_t lseek (off_t, int) { return 0; } select_record *select_read (select_record *s); int ready_for_read (int fd, DWORD howlong, int ignra); + + int cygserver_attach_tty (HANDLE*, HANDLE*); }; class fhandler_pty_master: public fhandler_tty_common diff --git a/winsup/cygwin/fhandler_tty.cc b/winsup/cygwin/fhandler_tty.cc index 1a46ecb3b..8a2abb77a 100644 --- a/winsup/cygwin/fhandler_tty.cc +++ b/winsup/cygwin/fhandler_tty.cc @@ -25,6 +25,9 @@ details. */ #include "pinfo.h" #include "cygheap.h" #include "shared_info.h" +#include <sys/socket.h> +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" /* Tty master stuff */ @@ -523,38 +526,52 @@ fhandler_tty_slave::open (const char *, int flags, mode_t) return 0; } - HANDLE tty_owner = OpenProcess (PROCESS_DUP_HANDLE, FALSE, - get_ttyp ()->master_pid); - if (tty_owner == NULL) - { - termios_printf ("can't open tty (%d) handle process %d", - ttynum, get_ttyp ()->master_pid); - __seterrno (); - return 0; - } + HANDLE from_master_local, to_master_local; - HANDLE nh; - if (!DuplicateHandle (tty_owner, get_ttyp ()->from_master, hMainProc, &nh, 0, TRUE, - DUPLICATE_SAME_ACCESS)) + if (!wincap.has_security () || + cygserver_running!=CYGSERVER_OK || + !cygserver_attach_tty ( &from_master_local, &to_master_local)) { - termios_printf ("can't duplicate input, %E"); - __seterrno (); - return 0; - } - set_io_handle (nh); - ProtectHandle1 (nh, from_pty); - termios_printf ("duplicated from_master %p->%p from tty_owner %p", - get_ttyp ()->from_master, nh, tty_owner); - if (!DuplicateHandle (tty_owner, get_ttyp ()->to_master, hMainProc, &nh, 0, TRUE, - DUPLICATE_SAME_ACCESS)) - { - termios_printf ("can't duplicate output, %E"); - __seterrno (); - return 0; + termios_printf ("cannot dup handles via server. using old method."); + + HANDLE tty_owner = OpenProcess (PROCESS_DUP_HANDLE, FALSE, + get_ttyp ()->master_pid); + if (tty_owner == NULL) + { + termios_printf ("can't open tty (%d) handle process %d", + ttynum, get_ttyp ()->master_pid); + __seterrno (); + return 0; + } + + if (!DuplicateHandle (tty_owner, get_ttyp ()->from_master, + hMainProc, &from_master_local, 0, TRUE, + DUPLICATE_SAME_ACCESS)) + { + termios_printf ("can't duplicate input, %E"); + __seterrno (); + return 0; + } + termios_printf ("duplicated from_master %p->%p from tty_owner %p", + get_ttyp ()->from_master, from_master_local, tty_owner); + + if (!DuplicateHandle (tty_owner, get_ttyp ()->to_master, + hMainProc, &to_master_local, 0, TRUE, + DUPLICATE_SAME_ACCESS)) + { + termios_printf ("can't duplicate output, %E"); + __seterrno (); + return 0; + } + termios_printf ("duplicated to_master %p->%p from tty_owner %p", + get_ttyp ()->to_master, to_master_local, tty_owner); + CloseHandle (tty_owner); } - set_output_handle (nh); - ProtectHandle1 (nh, to_pty); - CloseHandle (tty_owner); + + set_io_handle (from_master_local); + ProtectHandle1 (from_master_local, from_pty); + set_output_handle (to_master_local); + ProtectHandle1 (to_master_local, to_pty); set_open_status (); termios_printf ("tty%d opened", ttynum); @@ -562,6 +579,39 @@ fhandler_tty_slave::open (const char *, int flags, mode_t) return 1; } +int +fhandler_tty_slave::cygserver_attach_tty (LPHANDLE from_master_ptr, + LPHANDLE to_master_ptr) +{ + if (!from_master_ptr || !to_master_ptr) + return 0; + + client_request_attach_tty *request = + new client_request_attach_tty ((DWORD) GetCurrentProcessId (), + (DWORD) get_ttyp ()->master_pid, + (HANDLE) get_ttyp ()->from_master, + (HANDLE) get_ttyp ()->to_master); + + if (cygserver_request (request) != 0 || + request->header.error_code != 0) + return 0; + +/* + struct request_attach_tty req; + INIT_REQUEST (req, CYGSERVER_REQUEST_ATTACH_TTY); + req.pid = GetCurrentProcessId (); + req.master_pid = get_ttyp ()->master_pid; + req.from_master = get_ttyp ()->from_master; + req.to_master = get_ttyp ()->to_master; + if (cygserver_request ((struct request_header*) &req) != 0) + return 0; +*/ + *from_master_ptr = request->from_master (); + *to_master_ptr = request->to_master (); + delete request; + return 1; +} + void fhandler_tty_slave::init (HANDLE, DWORD a, mode_t) { diff --git a/winsup/cygwin/fork.cc b/winsup/cygwin/fork.cc index ffd48e47a..0903ae9a5 100644 --- a/winsup/cygwin/fork.cc +++ b/winsup/cygwin/fork.cc @@ -302,6 +302,9 @@ fork_child (HANDLE& hParent, dll *&first_dll, bool& load_dlls) if (fixup_mmaps_after_fork ()) api_fatal ("recreate_mmaps_after_fork_failed"); + if (fixup_shms_after_fork ()) + api_fatal ("recreate_shm areas after fork failed"); + /* Set thread local stuff to zero. Under Windows 95/98 this is sometimes non-zero, for some reason. FIXME: There is a memory leak here after a fork. */ diff --git a/winsup/cygwin/include/cygwin/cygserver.h b/winsup/cygwin/include/cygwin/cygserver.h new file mode 100755 index 000000000..bf21e9904 --- /dev/null +++ b/winsup/cygwin/include/cygwin/cygserver.h @@ -0,0 +1,126 @@ +/* cygserver.h + + 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. */ + +#ifndef _CYGSERVER_H_ +#define _CYGSERVER_H_ + +#define MAX_REQUEST_SIZE 128 + +#define CYGWIN_SERVER_VERSION_MAJOR 1 +#define CYGWIN_SERVER_VERSION_API 1 +#define CYGWIN_SERVER_VERSION_MINOR 0 +#define CYGWIN_SERVER_VERSION_PATCH 0 + + +typedef enum { + CYGSERVER_UNKNOWN=0, + CYGSERVER_OK=1, + CYGSERVER_DEAD=2 +} cygserver_states; + +typedef enum { + CYGSERVER_REQUEST_INVALID = 0, + CYGSERVER_REQUEST_GET_VERSION, + CYGSERVER_REQUEST_ATTACH_TTY, + CYGSERVER_REQUEST_SHUTDOWN, + CYGSERVER_REQUEST_SHM_GET, + CYGSERVER_REQUEST_LAST +} cygserver_request_code; + +class request_header +{ + public: + ssize_t cb; + cygserver_request_code req_id; + ssize_t error_code; +} +#ifdef __GNUC__ + __attribute__ ((packed)) +#endif +; + +extern void cygserver_init (); + +#define INIT_REQUEST(req,id) \ + (req).header.cb = sizeof (req); \ + (req).header.req_id = id; + +struct request_get_version +{ + DWORD major, api, minor, patch; +} +#ifdef __GNUC__ + __attribute__ ((packed)) +#endif +; + +struct request_shutdown +{ + int foo; +} +#ifdef __GNUC__ + __attribute__ ((packed)) +#endif +; + +struct request_attach_tty +{ + DWORD pid, master_pid; + HANDLE from_master, to_master; +} +#ifdef __GNUC__ + __attribute__ ((packed)) +#endif +; + +class client_request +{ + public: + client_request (cygserver_request_code id); + virtual void send (transport_layer_base *conn); + virtual void serve (transport_layer_base *conn) {}; + virtual operator struct request_header (); + cygserver_request_code req_id () {return header.req_id;}; + virtual ~client_request(); + request_header header; + char *buffer; +}; + +class client_request_get_version : public client_request +{ + public: + virtual void serve (transport_layer_base *conn); + client_request_get_version::client_request_get_version(); + struct request_get_version version; +}; + +class client_request_shutdown : public client_request +{ + public: + virtual void serve (transport_layer_base *conn); + client_request_shutdown (); +}; + +class client_request_attach_tty : public client_request +{ + public: + virtual void serve (transport_layer_base *conn); + client_request_attach_tty (); + client_request_attach_tty (DWORD npid, DWORD nmaster_pid, HANDLE nfrom_master, HANDLE nto_master); + HANDLE from_master () {return req.from_master;}; + HANDLE to_master () {return req.to_master;}; + struct request_attach_tty req; +}; + +extern int cygserver_request (client_request *); + +#endif /* _CYGSERVER+H+ */ diff --git a/winsup/cygwin/include/cygwin/cygserver_transport.h b/winsup/cygwin/include/cygwin/cygserver_transport.h new file mode 100755 index 000000000..e4405d2d4 --- /dev/null +++ b/winsup/cygwin/include/cygwin/cygserver_transport.h @@ -0,0 +1,53 @@ + +#ifndef _CYGSERVER_SHM_ +#define _CYGSERVER_SHM_ +class transport_layer_base *create_server_transport(); + +/* the base class uses AF_UNIX sockets,but other classes are possible. */ +class transport_layer_base +{ + public: + virtual void listen (); + virtual class transport_layer_base * accept (); + virtual void close (); + virtual ssize_t read (char *buf, size_t len); + virtual ssize_t write (char *buf, size_t len); + virtual bool connect(); + virtual void impersonate_client (); + virtual void revert_to_self (); + transport_layer_base (); + + private: + /* for socket based communications */ + int fd; + struct sockaddr sockdetails; + int sdlen; + transport_layer_base (int newfd); +}; + +/* Named pipes based transport, for security on NT */ +class transport_layer_pipes : public transport_layer_base +{ + public: + virtual void listen (); + virtual class transport_layer_pipes * accept (); + virtual void close (); + virtual ssize_t read (char *buf, size_t len); + virtual ssize_t write (char *buf, size_t len); + virtual bool connect(); + virtual void impersonate_client (); + virtual void revert_to_self (); + transport_layer_pipes (); + + private: + /* for pipe based communications */ + void init_security (); + SECURITY_DESCRIPTOR sd; + SECURITY_ATTRIBUTES sec_none_nih, sec_all_nih; + char pipe_name [MAX_PATH]; + HANDLE pipe; + bool inited; + transport_layer_pipes (HANDLE new_pipe); +}; + +#endif /* _CYGSERVER_SHM_ */ diff --git a/winsup/cygwin/include/sys/ipc.h b/winsup/cygwin/include/sys/ipc.h new file mode 100644 index 000000000..8ddec6d50 --- /dev/null +++ b/winsup/cygwin/include/sys/ipc.h @@ -0,0 +1,52 @@ +/* sys/ipc.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. */ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifndef _SYS_IPC_H +#define _SYS_IPC_H + +/* sys/types must be included before sys/ipc.h. We aren't meant to automatically + * include it however + */ + +struct ipc_perm { + uid_t uid; + gid_t gid; + uid_t cuid; + gid_t cgid; + mode_t mode; +}; + +/* the mode flags used with the _get functions use the low order 9 bits for a mode + * request + */ +#define IPC_CREAT 0x0200 +#define IPC_EXCL 0x0400 +#define IPC_NOWAIT 0x0800 + +/* this is a value that will _never_ be a valid key from ftok */ +#define IPC_PRIVATE -2 + +#define IPC_RMID 0x0003 +#define IPC_SET 0x0002 +#define IPC_STAT 0x0001 + +key_t ftok(const char *, int); + +#endif /* _SYS_IPC_H */ + +#ifdef __cplusplus +} +#endif diff --git a/winsup/cygwin/include/sys/shm.h b/winsup/cygwin/include/sys/shm.h new file mode 100644 index 000000000..208c5f29f --- /dev/null +++ b/winsup/cygwin/include/sys/shm.h @@ -0,0 +1,89 @@ +/* sys/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. */ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifndef _SYS_SHM_H +#define _SYS_SHM_H + +#include <sys/ipc.h> + +#define SHM_RDONLY 1 +/* 64 Kb was hardcoded for x86. MS states this may change, but we need it in the header + * file. + */ +#define SHMLBA 65536 +#define SHM_RND 1 + +typedef long int shmatt_t; + +#if defined(__INSIDE_CYGWIN__) && defined(__cplusplus) + +class _shmattach { +public: + void *data; + int shmflg; + 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; + void *mapptr; +}; + +class shmnode { +public: + class shmid_ds * shmds; + int shm_id; + class shmnode *next; + key_t key; + HANDLE filemap; + HANDLE attachmap; + class _shmattach *attachhead; +}; + +#else +/* this is what we return when queried. It has no bitwise correspondence + * the internal structures + */ +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; +}; +#endif /* __INSIDE_CYGWIN__ */ + +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 /* _SYS_SHM_H */ + +#ifdef __cplusplus +} +#endif diff --git a/winsup/cygwin/ipc.cc b/winsup/cygwin/ipc.cc new file mode 100644 index 000000000..192a124d5 --- /dev/null +++ b/winsup/cygwin/ipc.cc @@ -0,0 +1,39 @@ +/* ipc.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. */ + +#include "winsup.h" +#include <sys/ipc.h> +#include <sys/stat.h> + +extern "C" +{ + +/* Notes: we return a valid key even if id's low order 8 bits are 0. */ +key_t +ftok(const char *path, int id) +{ + struct stat statbuf; + if (stat(path, &statbuf)) + { + /* stat set the appropriate errno for us */ + return (key_t) -1; + } + + /* dev_t is short for cygwin + * ino_t is long for cygwin + * and we need 8 bits for the id. + * thus key_t is long long. + */ + return ((long long) statbuf.st_dev << (5*8)) | (statbuf.st_ino << (8) ) | (id & 0x00ff); +} + +} diff --git a/winsup/cygwin/pinfo.h b/winsup/cygwin/pinfo.h index 950f2c272..f62614d58 100644 --- a/winsup/cygwin/pinfo.h +++ b/winsup/cygwin/pinfo.h @@ -201,6 +201,8 @@ extern HANDLE hexec_proc; /* For mmaps across fork(). */ int __stdcall fixup_mmaps_after_fork (); +/* for shm areas across fork (). */ +int __stdcall fixup_shms_after_fork (); void __stdcall fill_rusage (struct rusage *, HANDLE); void __stdcall add_rusage (struct rusage *, struct rusage *); diff --git a/winsup/cygwin/security.h b/winsup/cygwin/security.h index 95f97b8ca..8555fe461 100644 --- a/winsup/cygwin/security.h +++ b/winsup/cygwin/security.h @@ -204,3 +204,5 @@ extern SECURITY_ATTRIBUTES *__stdcall sec_user_nih (PVOID sa_buf, PSID sid2 = NU int __stdcall NTReadEA (const char *file, const char *attrname, char *buf, int len); BOOL __stdcall NTWriteEA (const char *file, const char *attrname, const char *buf, int len); +PSECURITY_DESCRIPTOR alloc_sd (uid_t uid, gid_t gid, const char *logsrv, int attribute, + PSECURITY_DESCRIPTOR sd_ret, DWORD *sd_size_ret); diff --git a/winsup/cygwin/shm.cc b/winsup/cygwin/shm.cc new file mode 100644 index 000000000..840c0f23a --- /dev/null +++ b/winsup/cygwin/shm.cc @@ -0,0 +1,446 @@ +/* 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. */ + +#include "winsup.h" +#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" +#include <sys/shm.h> +#include "perprocess.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. + */ +extern "C" 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; +} + +static shmnode *shm_head = NULL; + +static shmnode * +build_inprocess_shmds (HANDLE hfilemap, HANDLE hattachmap, key_t key, + int shm_id) +{ + HANDLE filemap = hfilemap; + void *mapptr = MapViewOfFile (filemap, FILE_MAP_WRITE, 0, 0, 0); + + if (!mapptr) + { + CloseHandle (hfilemap); + CloseHandle (hattachmap); + //FIXME: close filemap and free the mutex + /* we couldn't access the mapped area with the requested permissions */ + set_errno (EACCES); + return NULL; + } + + /* Now get the user data */ + HANDLE attachmap = hattachmap; + shmid_ds *shmtemp = new shmid_ds; + if (!shmtemp) + { + system_printf ("failed to malloc shm node\n"); + set_errno (ENOMEM); + UnmapViewOfFile (mapptr); + CloseHandle (filemap); + CloseHandle (attachmap); + /* exit mutex */ + return NULL; + } + + /* get the system node data */ + *shmtemp = *(shmid_ds *) mapptr; + + /* process local data */ + shmnode *tempnode = new shmnode; + + tempnode->filemap = filemap; + tempnode->attachmap = attachmap; + shmtemp->mapptr = mapptr; + + /* no need for InterlockedExchange here, we're serialised by the global mutex */ + tempnode->shmds = shmtemp; + tempnode->shm_id = shm_id; + tempnode->key = key; + tempnode->next = shm_head; + tempnode->attachhead = NULL; + shm_head = tempnode; + + /* FIXME: leave the system wide shm mutex */ + + return tempnode; +} + +int __stdcall +fixup_shms_after_fork () +{ + shmnode *tempnode = shm_head; + while (tempnode) + { + void *newshmds = + MapViewOfFile (tempnode->filemap, FILE_MAP_WRITE, 0, 0, 0); + if (!newshmds) + { + /* don't worry about handle cleanup, we're dying! */ + system_printf("failed to reattach to shm control file view %x\n",tempnode); + return 1; + } + tempnode->shmds = (class shmid_ds *) newshmds; + tempnode->shmds->mapptr = newshmds; + _shmattach *attachnode = tempnode->attachhead; + while (attachnode) + { + void *newdata = MapViewOfFileEx (tempnode->attachmap, + (attachnode->shmflg & SHM_RDONLY) ? + FILE_MAP_READ : FILE_MAP_WRITE, 0, + 0, 0, attachnode->data); + if (newdata != attachnode->data) + { + /* don't worry about handle cleanup, we're dying! */ + system_printf("failed to reattach to mapped file view %x\n",attachnode->data); + return 1; + } + attachnode = attachnode->next; + } + tempnode = tempnode->next; + } + return 0; +} + +/* this is ugly. Yes, I know that. + * FIXME: abstract the lookup functionality, + * So that it can be an array, list, whatever without us being worried + */ + +/* FIXME: after fork, every memory area needs to have the attach count + * incremented and the mappings potentially reestablished, perhaps allowing + * inherit will work?!? + */ + +/* FIXME: are inherited mapped IPC_PRIVATE id's shared between process's + * YES from linux. + */ + +extern "C" void * +shmat (int shmid, const void *shmaddr, int shmflg) +{ + shmnode *tempnode = shm_head; + while (tempnode && tempnode->shm_id != shmid) + tempnode = tempnode->next; + + if (!tempnode) + { + /* couldn't find a currently open shm control area for the key - probably because + * shmget hasn't been called. + * Allocate a new control block - this has to be handled by the daemon */ + client_request_shm_get *req = + new client_request_shm_get (shmid, GetCurrentProcessId ()); + + int rc; + if ((rc = cygserver_request (req))) + { + delete req; + set_errno (ENOSYS); /* daemon communication failed */ + return (void *) -1; + } + + if (req->header.error_code) /* shm_get failed in the daemon */ + { + set_errno (req->header.error_code); + delete req; + return (void *) -1; + } + + /* we've got the id, now we open the memory area ourselves. + * This tests security automagically + * FIXME: make this a method of shmnode ? + */ + tempnode = + build_inprocess_shmds (req->parameters.out.filemap, + req->parameters.out.attachmap, + req->parameters.out.key, + req->parameters.out.shm_id); + delete req; + if (!tempnode) + return (void *) -1; + + } + + class shmid_ds *shm = tempnode->shmds; + + if (shmaddr) + { + //FIXME: requested base address ?! (Don't forget to fix the fixup_after_fork too) + set_errno (EINVAL); + return (void *) -1; + } + + void *rv = MapViewOfFile (tempnode->attachmap, + (shmflg & SHM_RDONLY) ? FILE_MAP_READ : + FILE_MAP_WRITE, 0, 0, 0); + + if (!rv) + { + //FIXME: translate GetLastError() + set_errno (EACCES); + return (void *) -1; + } + + InterlockedIncrement (&shm->shm_nattch); + _shmattach *attachnode = new _shmattach; + + attachnode->data = rv; + attachnode->shmflg = shmflg; + attachnode->next = + (_shmattach *) InterlockedExchangePointer (&tempnode->attachhead, attachnode); + + + return rv; +} + +//FIXME: who is allowed to perform STAT? +extern "C" int +shmctl (int shmid, int cmd, struct shmid_ds *buf) +{ + shmnode *tempnode = shm_head; + while (tempnode && tempnode->shm_id != shmid) + tempnode = tempnode->next; + if (!tempnode) + { + /* couldn't find a currently open shm control area for the key - probably because + * shmget hasn't been called. + * Allocate a new control block - this has to be handled by the daemon */ + client_request_shm_get *req = + new client_request_shm_get (shmid, GetCurrentProcessId ()); + + int rc; + if ((rc = cygserver_request (req))) + { + delete req; + set_errno (ENOSYS); /* daemon communication failed */ + return -1; + } + + if (req->header.error_code) /* shm_get failed in the daemon */ + { + set_errno (req->header.error_code); + delete req; + return -1; + } + + /* we've got the id, now we open the memory area ourselves. + * This tests security automagically + * FIXME: make this a method of shmnode ? + */ + tempnode = + build_inprocess_shmds (req->parameters.out.filemap, + req->parameters.out.attachmap, + req->parameters.out.key, + req->parameters.out.shm_id); + delete req; + if (!tempnode) + return -1; + } + + switch (cmd) + { + case IPC_STAT: + buf->shm_perm = tempnode->shmds->shm_perm; + buf->shm_segsz = tempnode->shmds->shm_segsz; + buf->shm_lpid = tempnode->shmds->shm_lpid; + buf->shm_cpid = tempnode->shmds->shm_cpid; + buf->shm_nattch = tempnode->shmds->shm_nattch; + buf->shm_atime = tempnode->shmds->shm_atime; + buf->shm_dtime = tempnode->shmds->shm_dtime; + buf->shm_ctime = tempnode->shmds->shm_ctime; + break; + case IPC_RMID: + { + /* TODO: check permissions. Or possibly, the daemon gets to be the only + * one with write access to the memory area? + */ + if (tempnode->shmds->shm_nattch) + system_printf ("call to shmctl with cmd= IPC_RMID when memory area still has" + " attachees\n"); + /* how does this work? + * we mark the ds area as "deleted", and the at and get calls all fail from now on + * on, when nattch becomes 0, the mapped data area is destroyed. + * and each process, as they touch this area detaches. eventually only the + * daemon has an attach. The daemon gets asked to detach immediately. + */ +#if 0 + client_request_shm_get *req = + new client_request_shm_get (SHM_DEL, shmid, GetCurrentProcessId ()); + int rc; + if ((rc = cygserver_request (req))) + { + delete req; + set_errno (ENOSYS); /* daemon communication failed */ + return -1; + } + + if (req->header.error_code) /* shm_del failed in the daemon */ + { + set_errno (req->header.error_code); + delete req; + return -1; + } + + /* the daemon has deleted it's references */ + /* now for us */ +#endif +} + break; + case IPC_SET: + default: + set_errno (EINVAL); + return -1; + } + return 0; +} + +/* 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 "C" int +shmget (key_t key, size_t size, int shmflg) +{ + DWORD sd_size = 4096; + char sd_buf[4096]; + PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) sd_buf; + /* create a sd for our open requests based on shmflag & 0x01ff */ + psd = alloc_sd (getuid (), getgid (), cygheap->user.logsrv (), + shmflg & 0x01ff, psd, &sd_size); + + if (key == (key_t) - 1) + { + set_errno (ENOENT); + return -1; + } + + /* FIXME: enter the checking for existing keys mutex. This mutex _must_ be system wide + * to prevent races on shmget. + */ + + /* walk the list of currently open keys and return the id if found + */ + shmnode *tempnode = shm_head; + while (tempnode) + { + if (tempnode->key == key && key != IPC_PRIVATE) + { + // FIXME: free the mutex + if (size && tempnode->shmds->shm_segsz < size) + { + set_errno (EINVAL); + return -1; + } + if ((shmflg & IPC_CREAT) && (shmflg & IPC_EXCL)) + { + set_errno (EEXIST); + // FIXME: free the mutex + return -1; + } + // FIXME: do we need to other tests of the requested mode with the + // tempnode->shmid mode ? testcase on unix needed. + // FIXME do we need a security test? We are only examining the keys we already have open. + // FIXME: what are the sec implications for fork () if we don't check here? + return tempnode->shm_id; + } + tempnode = tempnode->next; + } + /* couldn't find a currently open shm control area for the key. + * Allocate a new control block - this has to be handled by the daemon */ + client_request_shm_get *req = + new client_request_shm_get (key, size, shmflg, sd_buf, + GetCurrentProcessId ()); + + int rc; + if ((rc = cygserver_request (req))) + { + delete req; + set_errno (ENOSYS); /* daemon communication failed */ + return -1; + } + + if (req->header.error_code) /* shm_get failed in the daemon */ + { + set_errno (req->header.error_code); + delete req; + return -1; + } + + /* we've got the id, now we open the memory area ourselves. + * This tests security automagically + * FIXME: make this a method of shmnode ? + */ + shmnode *shmtemp = build_inprocess_shmds (req->parameters.out.filemap, + req->parameters.out.attachmap, + key, + req->parameters.out.shm_id); + delete req; + if (shmtemp) + return shmtemp->shm_id; + return -1; + + +#if 0 + /* 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 = 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 = size; + *(shmid_ds *) mapptr = *shmtemp; + shmtemp->filemap = filemap; + shmtemp->attachmap = attachmap; + shmtemp->mapptr = mapptr; + +#endif +} diff --git a/winsup/cygwin/tty.cc b/winsup/cygwin/tty.cc index b3d753c8d..baa05cd62 100644 --- a/winsup/cygwin/tty.cc +++ b/winsup/cygwin/tty.cc @@ -23,6 +23,9 @@ details. */ #include "sync.h" #include "sigproc.h" #include "pinfo.h" +#include <sys/socket.h> +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" #include "shared_info.h" extern fhandler_tty_master *tty_master; @@ -392,7 +395,7 @@ tty::common_init (fhandler_pty_master *ptym) /* Allow the others to open us (for handle duplication) */ - if (wincap.has_security () && + if (wincap.has_security () && cygserver_running==CYGSERVER_OK && (SetKernelObjectSecurity (hMainProc, DACL_SECURITY_INFORMATION, get_null_sd ()) == FALSE)) small_printf ("Can't set process security, %E"); diff --git a/winsup/cygwin/winsup.h b/winsup/cygwin/winsup.h index e1f59b761..e40dfb68a 100644 --- a/winsup/cygwin/winsup.h +++ b/winsup/cygwin/winsup.h @@ -69,6 +69,8 @@ extern "C" DWORD WINAPI GetLastError (void); enum codepage_type {ansi_cp, oem_cp}; extern codepage_type current_codepage; +extern int cygserver_running; + /* Used to check if Cygwin DLL is dynamically loaded. */ extern int dynamically_loaded; |