Patch file generated Tue Sep 25 08:48:56 2001 from CVS branch cvsuplocal CVS repository: robertc@192.168.0.1:/home/robertc/cvsup/cygwin/src CVS module: src Index: src/newlib/libc/include/sys/types.h diff -u src/newlib/libc/include/sys/types.h:1.7 src/newlib/libc/include/sys/types.h:1.7.2.1 --- src/newlib/libc/include/sys/types.h:1.7 Thu Apr 12 10:05:57 2001 +++ src/newlib/libc/include/sys/types.h Mon Sep 24 22:25:45 2001 @@ -133,7 +133,11 @@ typedef unsigned short uid_t; typedef unsigned short gid_t; typedef int pid_t; -typedef long key_t; +#if defined (__CYGWIN__) +typedef long long int key_t; +#else +typedef long key_t; +#endif /* __CYGWIN__ */ typedef long ssize_t; #ifdef __MS_types__ Index: src/winsup/cygwin/Makefile.in diff -u src/winsup/cygwin/Makefile.in:1.62 src/winsup/cygwin/Makefile.in:1.62.2.1 --- src/winsup/cygwin/Makefile.in:1.62 Sat Sep 15 14:36:43 2001 +++ src/winsup/cygwin/Makefile.in Mon Sep 24 22:49:10 2001 @@ -116,16 +116,19 @@ 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 @@ 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,12 +216,33 @@ 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 # Index: src/winsup/cygwin/autoload.cc diff -u src/winsup/cygwin/autoload.cc:1.32 src/winsup/cygwin/autoload.cc:1.32.2.1 --- src/winsup/cygwin/autoload.cc:1.32 Thu Sep 13 03:46:35 2001 +++ src/winsup/cygwin/autoload.cc Mon Sep 24 22:49:10 2001 @@ -327,6 +327,7 @@ 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) Index: src/winsup/cygwin/cygserver.cc diff -u /dev/null src/winsup/cygwin/cygserver.cc:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/cygserver.cc Mon Sep 24 22:49:10 2001 @@ -0,0 +1,546 @@ +/* cygserver.cc + + Copyright 2001 Red Hat Inc. + + Written by Egor Duda + + 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 +#include +#include +#include +#include +#include +#include +#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; iclose (); + 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 (); +} Index: src/winsup/cygwin/cygserver_client.cc diff -u /dev/null src/winsup/cygwin/cygserver_client.cc:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/cygserver_client.cc Mon Sep 24 22:49:10 2001 @@ -0,0 +1,225 @@ +/* cygserver_client.cc + + Copyright 2001 Red Hat Inc. + + Written by Egor Duda + + 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 +#include +#endif +#include +#include +#include +//#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; +} Index: src/winsup/cygwin/cygserver_shm.cc diff -u /dev/null src/winsup/cygwin/cygserver_shm.cc:1.1.2.2 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/cygserver_shm.cc Tue Sep 25 08:16:20 2001 @@ -0,0 +1,530 @@ +/* shm.cc: Single unix specification IPC interface for Cygwin + + Copyright 2001 Red Hat, Inc. + + Originally written by Robert Collins + + 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 +#include +#endif + +#include +#include +#include "cygerrno.h" +#include +#include "security.h" +//#include "fhandler.h" +//#include "dtable.h" +//#include "cygheap.h" +#include +//#include "thread.h" +#ifndef __INSIDE_CYGWIN__ +#define __INSIDE_CYGWIN__ +#include +#undef __INSIDE_CYGWIN__ +#else +#include +#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 Index: src/winsup/cygwin/cygserver_shm.h diff -u /dev/null src/winsup/cygwin/cygserver_shm.h:1.1.2.2 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/cygserver_shm.h Tue Sep 25 08:16:20 2001 @@ -0,0 +1,80 @@ +/* cygserver_shm.h + + Copyright 2001 Red Hat Inc. + Written by Robert Collins + +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 +#include +#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 Index: src/winsup/cygwin/cygserver_transport.cc diff -u /dev/null src/winsup/cygwin/cygserver_transport.cc:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/cygserver_transport.cc Mon Sep 24 22:49:10 2001 @@ -0,0 +1,154 @@ +/* cygserver_transport.cc + + Copyright 2001 Red Hat Inc. + + Written by Robert Collins + + 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 +#include +#include +#include +#include +#include +#include +#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 () +{ +} + Index: src/winsup/cygwin/cygserver_transport_pipes.cc diff -u /dev/null src/winsup/cygwin/cygserver_transport_pipes.cc:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/cygserver_transport_pipes.cc Mon Sep 24 22:49:10 2001 @@ -0,0 +1,195 @@ +/* cygserver_transport_pipes.cc + + Copyright 2001 Red Hat Inc. + + Written by Robert Collins + + 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 +#include +#include +#include +#include +#include +#include +#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"); +} + Index: src/winsup/cygwin/cygwin.din diff -u src/winsup/cygwin/cygwin.din:1.37 src/winsup/cygwin/cygwin.din:1.37.2.1 --- src/winsup/cygwin/cygwin.din:1.37 Wed Sep 19 11:07:10 2001 +++ src/winsup/cygwin/cygwin.din Mon Sep 24 22:49:10 2001 @@ -1220,3 +1220,7 @@ _acltotext = acltotext aclfromtext _aclfromtext = aclfromtext +ftok +shmat +shmctl +shmget Index: src/winsup/cygwin/dcrt0.cc diff -u src/winsup/cygwin/dcrt0.cc:1.112 src/winsup/cygwin/dcrt0.cc:1.112.2.1 --- src/winsup/cygwin/dcrt0.cc:1.112 Sat Sep 15 14:36:43 2001 +++ src/winsup/cygwin/dcrt0.cc Mon Sep 24 22:49:10 2001 @@ -34,6 +34,9 @@ #include "shared_info.h" #include "cygwin_version.h" #include "dll_init.h" +#include +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" #define MAX_AT_FILE_LEVEL 10 @@ -687,6 +690,8 @@ /* Initialize signal/subprocess handling. */ sigproc_init (); + + cygserver_init (); /* Connect to tty. */ tty_init (); Index: src/winsup/cygwin/fhandler.h diff -u src/winsup/cygwin/fhandler.h:1.82 src/winsup/cygwin/fhandler.h:1.82.2.1 --- src/winsup/cygwin/fhandler.h:1.82 Sun Sep 23 07:44:07 2001 +++ src/winsup/cygwin/fhandler.h Mon Sep 24 22:49:10 2001 @@ -835,6 +835,8 @@ 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 Index: src/winsup/cygwin/fhandler_tty.cc diff -u src/winsup/cygwin/fhandler_tty.cc:1.48 src/winsup/cygwin/fhandler_tty.cc:1.48.2.1 --- src/winsup/cygwin/fhandler_tty.cc:1.48 Fri Sep 21 06:58:29 2001 +++ src/winsup/cygwin/fhandler_tty.cc Mon Sep 24 22:49:10 2001 @@ -25,6 +25,9 @@ #include "pinfo.h" #include "cygheap.h" #include "shared_info.h" +#include +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" /* Tty master stuff */ @@ -523,42 +526,89 @@ 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)) - { - 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; - } - set_output_handle (nh); - ProtectHandle1 (nh, to_pty); - CloseHandle (tty_owner); + if (!wincap.has_security () || + cygserver_running!=CYGSERVER_OK || + !cygserver_attach_tty ( &from_master_local, &to_master_local)) + { + 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_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); + 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; } Index: src/winsup/cygwin/fork.cc diff -u src/winsup/cygwin/fork.cc:1.68 src/winsup/cygwin/fork.cc:1.68.2.1 --- src/winsup/cygwin/fork.cc:1.68 Sun Sep 23 02:55:02 2001 +++ src/winsup/cygwin/fork.cc Mon Sep 24 22:49:10 2001 @@ -302,6 +302,9 @@ 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. */ Index: src/winsup/cygwin/ipc.cc diff -u /dev/null src/winsup/cygwin/ipc.cc:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/ipc.cc Mon Sep 24 22:49:10 2001 @@ -0,0 +1,39 @@ +/* ipc.cc: Single unix specification IPC interface for Cygwin + + Copyright 2001 Red Hat, Inc. + + Originally written by Robert Collins + + 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 +#include + +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); +} + +} Index: src/winsup/cygwin/pinfo.h diff -u src/winsup/cygwin/pinfo.h:1.31 src/winsup/cygwin/pinfo.h:1.31.2.1 --- src/winsup/cygwin/pinfo.h:1.31 Thu Sep 13 03:46:36 2001 +++ src/winsup/cygwin/pinfo.h Mon Sep 24 22:49:10 2001 @@ -201,6 +201,8 @@ /* 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 *); Index: src/winsup/cygwin/security.h diff -u src/winsup/cygwin/security.h:1.16 src/winsup/cygwin/security.h:1.16.4.1 --- src/winsup/cygwin/security.h:1.16 Sat Sep 8 07:32:05 2001 +++ src/winsup/cygwin/security.h Mon Sep 24 22:49:10 2001 @@ -204,3 +204,5 @@ 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); Index: src/winsup/cygwin/shm.cc diff -u /dev/null src/winsup/cygwin/shm.cc:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/shm.cc Mon Sep 24 22:49:11 2001 @@ -0,0 +1,446 @@ +/* shm.cc: Single unix specification IPC interface for Cygwin + + Copyright 2001 Red Hat, Inc. + + Originally written by Robert Collins + + 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 +#include +#include "cygerrno.h" +#include +#include "security.h" +#include "fhandler.h" +#include "dtable.h" +#include "cygheap.h" +#include +#include "thread.h" +#include +#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 +} Index: src/winsup/cygwin/tty.cc diff -u src/winsup/cygwin/tty.cc:1.29 src/winsup/cygwin/tty.cc:1.29.2.1 --- src/winsup/cygwin/tty.cc:1.29 Thu Sep 13 03:46:36 2001 +++ src/winsup/cygwin/tty.cc Mon Sep 24 22:49:11 2001 @@ -23,6 +23,9 @@ #include "sync.h" #include "sigproc.h" #include "pinfo.h" +#include +#include "cygwin/cygserver_transport.h" +#include "cygwin/cygserver.h" #include "shared_info.h" extern fhandler_tty_master *tty_master; @@ -392,7 +395,7 @@ /* 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"); Index: src/winsup/cygwin/winsup.h diff -u src/winsup/cygwin/winsup.h:1.69 src/winsup/cygwin/winsup.h:1.69.2.1 --- src/winsup/cygwin/winsup.h:1.69 Thu Sep 13 03:46:37 2001 +++ src/winsup/cygwin/winsup.h Mon Sep 24 22:49:11 2001 @@ -69,6 +69,8 @@ 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; Index: src/winsup/cygwin/include/cygwin/cygserver.h diff -u /dev/null src/winsup/cygwin/include/cygwin/cygserver.h:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/include/cygwin/cygserver.h Mon Sep 24 22:49:11 2001 @@ -0,0 +1,126 @@ +/* cygserver.h + + Copyright 2001 Red Hat Inc. + + Written by Egor Duda + +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+ */ Index: src/winsup/cygwin/include/cygwin/cygserver_transport.h diff -u /dev/null src/winsup/cygwin/include/cygwin/cygserver_transport.h:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/include/cygwin/cygserver_transport.h Mon Sep 24 22:49:11 2001 @@ -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_ */ Index: src/winsup/cygwin/include/sys/ipc.h diff -u /dev/null src/winsup/cygwin/include/sys/ipc.h:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/include/sys/ipc.h Mon Sep 24 22:49:11 2001 @@ -0,0 +1,52 @@ +/* sys/ipc.h + + Copyright 2001 Red Hat Inc. + Written by Robert Collins + +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 Index: src/winsup/cygwin/include/sys/shm.h diff -u /dev/null src/winsup/cygwin/include/sys/shm.h:1.1.2.1 --- /dev/null Thu Jan 1 01:00:00 1970 +++ src/winsup/cygwin/include/sys/shm.h Mon Sep 24 22:49:11 2001 @@ -0,0 +1,89 @@ +/* sys/shm.h + + Copyright 2001 Red Hat Inc. + Written by Robert Collins + +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 + +#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