2002-02-28 Robert Collins <rbtcollins@hotmail.com>

	* Merged cygwin_daemon into head minus the new shm and ipc exports.

2002-02-28  Robert Collins  <rbtcollins@hotmail.com>

	* fhandler_tty.cc (fhandler_tty_slave::open): More debugging.
	(fhandler_tty_slave::read): Fix printf type for the handle.
	* tty.cc (tty::common_init): Add a FIXME for security.

2002-01-29  Robert Collins  <rbtcollins@hotmail.com>

	* Makefile.in (OBJS): Remove duplicate localtime.o.

2002-01-17  Robert Collins  <rbtcollins@hotmail.com>

	* cygserver.cc (check_and_dup_handle): Consolidate the two variants for
	simplicity.
	Add Some basic debug output.
	(client_request_attach_tty::serve): Use the new debug_printf for clarity.
	Mark the duplicated handles as inheritable - fixup_after_fork() doesn't reopen
	tty's.

2002-01-16  Robert Collins  <rbtcollins@hotmail.com>

	* cygserver.cc (transport): Correct scope.
	(client_request_attach_tty::serve): Add more debug information.
	Fix erroneous use of transport instead of conn.
	* cygserver_transport_pipes.cc (transport_layer_pipes::close): More debug.
	(transport_layer_pipes::read): Ditto.
	(transport_layer_pipes::write): Ditto.
	(transport_layer_pipes::impersonate_client): Ditto.

Mon Oct  8  7:41:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* cygserver.cc (server_request::process): Rename client_request_shm_get to
	client_request_shm.
	* cygserver_process.cc (process_cache::add): Rename to add_task.
	Use process_cleanup instead of process_request.
	(process_cache::remove_process): New method.
	(process::process): Initialize new members.
	(process::~process): New member.
	(process::cleanup): New method.
	(process::add_cleanup_routine): New method.
	(process_request::process): Rename to process_cleanup.
	Call the process object's cleanup method and then delete it.
	(process_process_param::request_loop): Remove the signalling process.
	* cygserver_shm.cc: Globally rename client_request_shm_get to client_request_shm.
	(client_request_shm_get::serve): Handle attach request counting.
	* cygserver_shm.h: Globally rename client_request_shm_get to client_request_shm.
	(class shm_cleanup): New class.
	* shm.cc: Globally rename client_request_shm_get to client_request_shm.
	(client_request_shm::client_request_shm): New constructor for attach requests.
	(shmat): Use it.
	* include/cygwin/cygserver_process.h (class process_request): Rename to
	process_cleanup.
	(class cleanup_routine): New class.
	(class process): New members and methods to allow calling back when the process
	terminates.

Thu Oct  4 14:12:00 2001  Robert Collins <rbtcollins@hotmail.com>
	* cygserver.cc (request_loop): Make static.
	(main): Use new cache constructor syntax.
	Start cache worker threads.
	Cleanup the cache at shutdown.
	* cygserver_process.cc: Run indent.
	(process_cache::process_cache): Add a trigger to use when adding a process.
	(process_cache::process): Move process_entry to process.
	Insert at the end of the list.
	Trigger the request loop when new process's inserted.
	(process_cache::process_requests): Do it.
	(process_cache::add): New method.
	(process_cache::handle_snapshot): New method.
	(process::process): Merge in the process_entry fields.
	(process::handle): Make a stub function.
	(process::exit_code): New method.
	(process_request::process): New method.
	(process_process_param::request_loop): New method.
	* cygserver_shm.cc: New header dependency - threaded_queue.h.
	* threaded_queue.cc (threaded_queue::cleanup): Clearer messages.
	(queue_process_param::stop): Short spinlock on interruptible threads.
	* threaded_queue.h (class threaded_queue): New constructor.
	* include/cygwin/cygserver_process.h (process_request): New class.
	(process_entry): Remove.
	(process): Merge in process_entry.
	(process_cache): Inherit from threaded_queue.

Tue Oct  2 23:24:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* cygserver.cc (class server_process_param): Use new constructor syntax.
	* cygserver_process.cc (process_cache::~process_cache): New function.
	* threaded_queue.cc: Define condition debug_printf.
	Run indent.
	(threaded_queue::cleanup): Move queue_process_param guts to a method.
	(threaded_queue::process_requests): Ditto.
	(queue_process_param::queue_process_param): New method.
	(queue_process_param::~queue_process_param): Ditto.
	(queue_process_param::start): Ditto.
	(queue_process_param::stop): Ditto.
	* threaded_queue.h (class queue_process_param): Add support for
	interruptible request loops.
	* cygwin/include/cygwin/cygserver_process.h (class process_cache): Add
	destructor.

Tue Oct  2 23:24:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* cygserver_client.cc: New flag allow_daemon to disable the daemon completely.
	(cygserver_request): Check it.
	(cygserver_init): Ditto.
	* environ.cc (parse_thing): Add (no)daemon option.

Tue Oct  2 23:00:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* shm.cc: Update to handle include changes from HEAD.

Tue Oct  2 16:06:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* Makefile.in: Remove cygserver_shm.o from cygwin1.dll.
	Rename cygserver_shm_outside.o to cygserver_shm.o.
	* cygserver.cc (server_request::process): Use the new client_request
	constructor.
	* cygserver_client.cc: Remove the #ifdef's stubs for the server method
	within cygwin.
	(client_request_attach_tty::client_request_attach_tty): Use the new
	client_request constructor.
	(client_request_shutdown::client_request_shutdown): Ditto.
	(client_request::client_request): Ditto.
	* cygserver_shm.cc (client_request_shm_get::serve): Remove the
	#ifdef'd stub for in-cygwin builds.
	(client_request_shm_get::client_request_shm_get): Use the new
	client_request constructor, and remove the in-cygwin variants.
	* cygserver_shm.h (class client_request_shm_get): #ifndef test the
	serve method - it's only used in cygserver.
	* shm.cc (client_request_shm_get::client_request_shm_get): New function.
	* include/cygwin/cygserver.h (request_header): New constructor.
	(class client_request): Use it.
	New constructor accepting the header size.
	#ifndef test the server method - it's only used within cygserver.
	(client_request_get_version): #ifdef test the server method.
	(client_request_shutdown): Ditto.
	(client_request_attach_tty): Ditto.

Tue Oct  2  9:57:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* Makefile.in: add threaded_queue.o to cygserver.exe.
	* cygserver.cc: Include threaded_queue.h
	(class server_request): Inherit from queue_request.
	(class server_process_param): Inherit from queue_process_param.
	(class server_request_queue): Inherit from threaded_queue.
	(request_loop): Adjust for new types.
	(server_request_queue::process_requests): Remove guts to
	threaded_queue::process_requests.
	(server_request::server_request): Adjust for new types.
	(worker_function): Delete.
	(server_request_queue::create_workers): Delete.
	(server_request_queue::cleanup): Delete.
	(server_request_queue::add): Move guts to threaded_queue::add.
	* threaded_queue.cc: New file.
	* threaded_queue.h: New file.

Mon Oct  1 12:38:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* cygserver.cc (client_request::serve): New function.
	* cygserver_process.cc: Inlude <pthread.h> for pthread_once.
	(process_cache::process_cache): Initialise a crtiical section for write access.
	(process_cache::process): Use the critical section. Also add missing entries to
	the cache.
	(do_process_init): New function to initalise class process static variables.
	(process::process): Ensure that the process access critical section is
	initialised.
	(process::handle): Close the handle of old process's when they have terminated
	and we are returning the handle for a process with the same pid.
	* cygserver_shm.cc: Run indent.
	Include cygserver_process.h to allow process cache functionality.
	(client_request_shm_get::serve): New parameter for process cache support.
	Use the process cache, not OpenProcess to get a handle to the originating process.
	Fix a handle leak with token_handle.
	* cygserver_shm.h (class client_request_shm_get): Update ::serve for process
	cache support.
	* cygserver_transport_pipes.cc: Redefine debug_printf to be conditional on DEBUG.
	* include/cygwin/cygserver.h: Do not implement client_request::serve in the
	header.
	* include/cygwin/cygserver_process.h (class process_cache): Add a write access
	critical section to prevent races when requests from a  multithreaded
	application arrive.

Sun Sep 30 23:41:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* Makefile.in: Add cygserver_process.o to cygserver.exe.
	* cygserver.cc: Include signal.h and cygwin_version.h.
	Define debug_printf as a macro.
	Define DEBUG to a value.
	(client_request_attach_tty::serve): Add beginning of process cache support.
	Change from #ifdef DEBUG to work with new DEBUG style.
	(client_request_get_version::serve): Add beginning of process cache support.
	(class server_request): New prototype for support of process cache.
	(class queue_process_param): New class to allow request loop threading.
	(class server_request_queue): Add beginning of process cache support.
	Allow request loop threading.
	(request_loop): Thread function for request loops.
	(server_request_queue::process_requests): Initiator for threaded request loops.
	(client_request_shutdown::serve): Add beginning of process cache support.
	(server_request::server_request): Ditto.
	(server_request::process): Use debug_printf. Add beginning of process cache
	support.
	(server_request_queue::cleanup): Kill off any request loop threads.
	(server_request_queue::add): Add beginning of process cache support.
	(handle_signal): Trigger a shutdown.
	(main): Print out some useful info at startup - version, date time.
	Add process cache support.
	Spawn a separate thread for the transport request loop, thus allowing concurrent
	support for multiple transports.
	* cygserver_client.cc (client_request_get_version::serve): Add process cache
	support.
	(client_request_attach_tty::serve): Add process cache support.
	(client_request_shutdown::serve): Add process cache support.
	* cygsserver_process.cc: New file with the process cache support.
	* cygserver_shm.cc: Redefine debug_printf to allow conditional output.
	* cygwin.din: Export shmdt().
	* shm.cc: Run indent.
	Update FIXME's.
	(shmdt): New function.
	* include/cygwin/cygserver.h (class client_request): Add process cache support.
	(class client_request_get_version): Ditto.
	(class client_request_shutdown): Ditto.
	(class client_request_attach_tty): Ditto.
	* include/cygwin/cygserver_process.h: New header for process cache support.

Sun Sep 30  8:52:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* include/cygwin/cygserver_transport.h: Add copyright header.
	* include/cygwin/cygserver_transport_pipes.h: Ditto.
	* include/cygwin/cygserver_transport_sockets.h: Ditto.

Sat Sep 29 20:40:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* Makefile.in: Add cygserver_transport_sockets.o to DLL_OFILES.
	Add cygserver_transport_sockets_outside.o to cygserver.exe.
	* cygserver.cc: Include new include files.
	* cygserver_client.cc: Ditto.
	* cygserver_shm.h: No need to include <sys/socket.h> now.
	* cygerver_transport.cc: Include new include files.
	(transport_layer_base::transport_layer_base): Strip back to a stub.
	(transport_layer_base::listen): Ditto.
	(transport_layer_base::accept): Ditto.
	(transport_layer_base::close): Ditto.
	(transport_layer_base::read): Ditto.
	(transport_layer_base::write): Ditto.
	(transport_layer_base::connect): Ditto.
	* cygserver_transport_pipes.cc: Include new header
	"cygwin/cygserver_transport_pipes.h".
	* cygserver_transport_sockets.cc: New file.
	* dcrt0.cc: No need to include <sys/socket.h> now.
	* fhandler_tty.cc: Ditto.
	* tty.cc: Ditto.
	* include/cygwin/cygserver_transport.h: Strip the base class to a stub.
	Remove the cygserver_transport_pipes class.
	* include/cygwin/cygserver_transport_pipes.h: New file.
	* include/cygwin/cygserver_transport_sockets.h: New file.

Tue Sep 25 16:22:00 2001  Robert Collins <rbtcollins@hotmail.com>

	* autoload.cc: Add dynamic load statement for 'ImpersonateNamedPipeClient'.
	* Makefile.in: Add new object files, and build instructions for cygserver.exe.
	* cygwin.din: Export ftok, shmat, shmctl and shmget.
	* dcrt0.cc: Additional includes for cygserver support.
	(dll_crt0_1): Initialise the cygserver client.
	* fhandler.h (fhandler_tty): New method cygserver_attach_tty.
	* fhandler_tty.cc: Additional includes for cygserver support.
	(fhandler_tty_slave::open): Attempt to use the cygserver when obtaining
	handles from the parent process. On failure or 9x use the current method.
	(fhandler_tty_slave::cygserver_attach_tty): New function.
	* fork.cc (fork_child): Fixup shm memory mapped areas.
	* pinfo.h: Declare fixup_shms_after_fork().
	* security.h: Declare alloc_sd().
	* tty.cc: Additonal includes to support cygserver.
	(tty::common_init): Don't allow others to open us if the cygserver is running.
	* winsup.h: Declare cygserver_running.
	* cygserver.cc: New file.
	* cygserver_client.cc: New file.
	* cygserver_shm.cc: New file.
	* cygserver_shm.h: New file.
	* cygserver_transport.cc: New file.
	* cygserver_transport_pipes.cc: New file.
	* ipc.cc: New file.
	* shm.cc: New file.
	* include/cygwin/cygserver.h: New file.
	* include/cygwin/cygserver_transport.h: New file.
	* include/sys/ipc.h: New file.
	* include/sys/shm.h: New file.

2002-02-28  Robert Collins  <rbtcollins@hotmail.com>

	* thread.cc (semaphore::TryWait): Set errno as required by posix 1003.1.
	(__sem_wait): Ditto.
	(__sem_trywait): Ditto.

1 files changed, 499 insertions, 0 deletions

diff --git a/winsup/cygwin/shm.cc b/winsup/cygwin/shm.cc
new file mode 100644
index 000000000..dbe9bb0e9
--- /dev/null
+++ b/winsup/cygwin/shm.cc
@@ -0,0 +1,499 @@
+/* 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 "path.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;
+}
+
+client_request_shm::client_request_shm (int ntype, int nshm_id):
+client_request (CYGSERVER_REQUEST_SHM_GET, sizeof (parameters))
+{
+  buffer = (char *) &parameters;
+  parameters.in.shm_id = nshm_id;
+  parameters.in.type = SHM_REATTACH;
+  parameters.in.pid = GetCurrentProcessId ();
+}
+
+client_request_shm::client_request_shm (int ntype, int nshm_id, pid_t npid):
+client_request (CYGSERVER_REQUEST_SHM_GET, sizeof (parameters))
+{
+  buffer = (char *) &parameters;
+  parameters.in.shm_id = nshm_id;
+  parameters.in.type = ntype;
+  parameters.in.pid = npid;
+}
+
+client_request_shm::client_request_shm (key_t nkey, size_t nsize,
+                                                int nshmflg,
+                                                char psdbuf[4096],
+                                                pid_t npid):
+client_request (CYGSERVER_REQUEST_SHM_GET, sizeof (parameters))
+{
+  buffer = (char *) &parameters;
+  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);
+}
+
+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. This should be done in the server?
+ */
+
+/* FIXME: tell the daemon when we attach, so at process close it can clean up
+ * the attach count
+ */
+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 *req =
+	new client_request_shm (SHM_REATTACH, 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;
+    }
+  /* tell the daemon we have attached */
+  client_request_shm *req =
+    new client_request_shm (SHM_ATTACH, shmid);
+  int rc;
+  if ((rc = cygserver_request (req)))
+    {
+      debug_printf ("failed to tell deaemon that we have attached\n");
+    }
+  delete req;
+
+  _shmattach *attachnode = new _shmattach;
+  attachnode->data = rv;
+  attachnode->shmflg = shmflg;
+  attachnode->next =
+    (_shmattach *) InterlockedExchangePointer (&tempnode->attachhead,
+					       attachnode);
+
+
+  return rv;
+}
+
+/* FIXME: tell the daemon when we detach so it doesn't cleanup incorrectly.
+ */
+extern "C" int
+shmdt (const void *shmaddr)
+{
+  /* this should be "rare" so a hefty search is ok. If this is common, then we
+   * should alter the data structs to allow more optimisation
+   */
+  
+}
+
+//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 *req =
+	new client_request_shm (SHM_REATTACH, 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
+//waiting for the daemon to handle terminating process's
+	client_request_shm *req =
+	  new client_request_shm (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
+ */
+
+/* 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 *req =
+    new client_request_shm (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
+}