Cygwin: fhandler_socket_unix: implement socket, bind, and close

...plus lots of helper functions.  Add comment to explain how everything
works.  This comment will be improved while implementing the yet missing
parts.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

winsup/cygwin/fhandler.h

@@ -847,6 +847,24 @@ class sun_name_t
 
 class fhandler_socket_unix : public fhandler_socket
 {
+ protected:
+   HANDLE file;	/* Either NT symlink or reparse point */
+
+   HANDLE create_abstract_link (const sun_name_t *sun,
+				PUNICODE_STRING pipe_name);
+   HANDLE create_reparse_point (const sun_name_t *sun,
+				PUNICODE_STRING pipe_name);
+   HANDLE create_file (const sun_name_t *sun);
+   int open_abstract_link (sun_name_t *sun, PUNICODE_STRING pipe_name);
+   int open_reparse_point (sun_name_t *sun, PUNICODE_STRING pipe_name);
+   int open_file (sun_name_t *sun, int &type, PUNICODE_STRING pipe_name);
+   HANDLE autobind (sun_name_t *sun);
+   wchar_t get_type_char ();
+   void gen_pipe_name ();
+   void set_wait_state (DWORD wait_state);
+   HANDLE create_pipe ();
+   HANDLE create_pipe_instance ();
+
  protected:
   sun_name_t *sun_path;
   sun_name_t *peer_sun_path;

winsup/cygwin/fhandler_socket_unix.cc

@@ -21,19 +21,47 @@
 #include "path.h"
 #include "fhandler.h"
 #include "dtable.h"
+#include "cygheap.h"
 #include "hires.h"
 #include "shared_info.h"
 #include "ntdll.h"
 #include "miscfuncs.h"
 #include "tls_pbuf.h"
 
+/*
+   Abstract socket:
 
+     An abstract socket is represented by a symlink in the native
+     NT namespace, within the Cygin subdir in BasedNamedObjects.
+     So it's globally available but only exists as long as at least on
+     descriptor on the socket is open, as desired.
+
+     The name of the symlink is: "af-unix-<sun_path>"
+
+     <sun_path> is the transposed sun_path string, including the leading
+     NUL.  The transposition is simplified in that it uses every byte
+     in the valid sun_path name as is, no extra multibyte conversion.
+     The content of the symlink is the name of the underlying pipe.
+
+  Named socket:
+
+    A named socket is represented by a reparse point with a Cygwin-specific
+    tag and GUID.  The GenericReparseBuffer content is the name of the
+    underlying pipe.
+
+  Pipe:
+
+    The pipe is named \\.\pipe\cygwin-<installation_key>-unix-[sd]-<uniq_id>
+
+    - <installation_key> is the 8 byte hex Cygwin installation key
+    - [sd] is s for SOCK_STREAM, d for SOCK_DGRAM
+    - <uniq_id> is an 8 byte hex unique number
+
+   Note: We use MAX_PATH here for convenience where sufficient.  It's
+   big enough to hold sun_path's as well as pipe names so we don't have
+   to use tmp_pathbuf as often.
+*/
 
-/* cygwin internal: map sockaddr into internet domain address */
-static int __unused
-get_inet_addr_unix (const struct sockaddr *in, int inlen,
-		    struct sockaddr_storage *out, int *outlen,
-		    int *type = NULL)
 GUID __cygwin_socket_guid = {
   .Data1 = 0xefc1714d,
   .Data2 = 0x7b19,
@@ -42,17 +70,215 @@ GUID __cygwin_socket_guid = {
 };
 
 HANDLE
+fhandler_socket_unix::create_abstract_link (const sun_name_t *sun,
+					    PUNICODE_STRING pipe_name)
 {
-  /* Check for abstract socket. */
+  WCHAR name[MAX_PATH];
-  if (inlen >= (int) sizeof (in->sa_family) + 7
+  OBJECT_ATTRIBUTES attr;
-      && in->sa_data[0] == '\0' && in->sa_data[1] == 'd'
+  NTSTATUS status;
-      && in->sa_data[6] == '\0')
+  UNICODE_STRING uname;
+  HANDLE fh = NULL;
+
+  PWCHAR p = wcpcpy (name, L"af-unix-");
+  /* NUL bytes have no special meaning in an abstract socket name, so
+     we assume iso-8859-1 for simplicity and transpose the string.
+     transform_chars_af_unix is doing just that. */
+  transform_chars_af_unix (p, sun->un.sun_path, sun->un_len);
+  RtlInitUnicodeString (&uname, name);
+  InitializeObjectAttributes (&attr, &uname, OBJ_CASE_INSENSITIVE,
+			      get_shared_parent_dir (), NULL);
+  /* Fill symlink with name of pipe */
+  status = NtCreateSymbolicLinkObject (&fh, SYMBOLIC_LINK_ALL_ACCESS,
+				       &attr, pipe_name);
+  if (!NT_SUCCESS (status))
     {
-      /* TODO */
+      if (status == STATUS_OBJECT_NAME_EXISTS
-      return 0;
+	  || status == STATUS_OBJECT_NAME_COLLISION)
+	set_errno (EADDRINUSE);
+      else
+	__seterrno_from_nt_status (status);
+    }
+  return fh;
+}
+
+struct rep_pipe_name_t
+{
+  USHORT Length;
+  WCHAR  PipeName[1];
+};
+
+HANDLE
+fhandler_socket_unix::create_reparse_point (const sun_name_t *sun,
+					    PUNICODE_STRING pipe_name)
+{
+  ULONG access;
+  HANDLE old_trans = NULL, trans = NULL;
+  OBJECT_ATTRIBUTES attr;
+  IO_STATUS_BLOCK io;
+  NTSTATUS status;
+  HANDLE fh = NULL;
+  PREPARSE_GUID_DATA_BUFFER rp;
+  rep_pipe_name_t *rep_pipe_name;
+
+  const DWORD data_len = sizeof (*rep_pipe_name) + pipe_name->Length;
+
+  path_conv pc (sun->un.sun_path, PC_SYM_FOLLOW);
+  if (pc.error)
+    {
+      set_errno (pc.error);
+      return NULL;
+    }
+  if (pc.exists ())
+    {
+      set_errno (EADDRINUSE);
+      return NULL;
+    }
+ /* We will overwrite the DACL after the call to NtCreateFile.  This
+    requires READ_CONTROL and WRITE_DAC access, otherwise get_file_sd
+    and set_file_sd both have to open the file again.
+    FIXME: On remote NTFS shares open sometimes fails because even the
+    creator of the file doesn't have the right to change the DACL.
+    I don't know what setting that is or how to recognize such a share,
+    so for now we don't request WRITE_DAC on remote drives. */
+  access = DELETE | FILE_GENERIC_WRITE;
+  if (!pc.isremote ())
+    access |= READ_CONTROL | WRITE_DAC | WRITE_OWNER;
+  if ((pc.fs_flags () & FILE_SUPPORTS_TRANSACTIONS))
+    start_transaction (old_trans, trans);
+
+retry_after_transaction_error:
+  status = NtCreateFile (&fh, DELETE | FILE_GENERIC_WRITE,
+			 pc.get_object_attr (attr, sec_none_nih), &io,
+			 NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_CREATE,
+			 FILE_SYNCHRONOUS_IO_NONALERT
+			 | FILE_NON_DIRECTORY_FILE
+			 | FILE_OPEN_FOR_BACKUP_INTENT
+			 | FILE_OPEN_REPARSE_POINT,
+			 NULL, 0);
+  if (NT_TRANSACTIONAL_ERROR (status) && trans)
+    {
+      stop_transaction (status, old_trans, trans);
+      goto retry_after_transaction_error;
     }
 
-  path_conv pc (in->sa_data, PC_SYM_FOLLOW);
+  if (!NT_SUCCESS (status))
+    {
+      if (io.Information == FILE_EXISTS)
+	set_errno (EADDRINUSE);
+      else
+	__seterrno_from_nt_status (status);
+      goto out;
+    }
+  rp = (PREPARSE_GUID_DATA_BUFFER)
+       alloca (REPARSE_GUID_DATA_BUFFER_HEADER_SIZE + data_len);
+  rp->ReparseTag = IO_REPARSE_TAG_CYGUNIX;
+  rp->ReparseDataLength = data_len;
+  rp->Reserved = 0;
+  memcpy (&rp->ReparseGuid, CYGWIN_SOCKET_GUID, sizeof (GUID));
+  rep_pipe_name = (rep_pipe_name_t *) rp->GenericReparseBuffer.DataBuffer;
+  rep_pipe_name->Length = pipe_name->Length;
+  memcpy (rep_pipe_name->PipeName, pipe_name->Buffer, pipe_name->Length);
+  rep_pipe_name->PipeName[pipe_name->Length / sizeof (WCHAR)] = L'\0';
+  status = NtFsControlFile (fh, NULL, NULL, NULL, &io,
+			    FSCTL_SET_REPARSE_POINT, rp,
+			    REPARSE_GUID_DATA_BUFFER_HEADER_SIZE
+			    + rp->ReparseDataLength, NULL, 0);
+  if (NT_SUCCESS (status))
+    {
+      set_created_file_access (fh, pc, S_IRUSR | S_IWUSR
+				       | S_IRGRP | S_IWGRP
+				       | S_IROTH | S_IWOTH);
+      NtClose (fh);
+      /* We don't have to keep the file open, but the caller needs to
+         get a value != NULL to know the file creation went fine. */
+      fh = INVALID_HANDLE_VALUE;
+    }
+  else if (!trans)
+    {
+      FILE_DISPOSITION_INFORMATION fdi = { TRUE };
+
+      __seterrno_from_nt_status (status);
+      status = NtSetInformationFile (fh, &io, &fdi, sizeof fdi,
+				     FileDispositionInformation);
+      if (!NT_SUCCESS (status))
+	debug_printf ("Setting delete dispostion failed, status = %y",
+		      status);
+      NtClose (fh);
+      fh = NULL;
+    }
+
+out:
+  if (trans)
+    stop_transaction (status, old_trans, trans);
+  return fh;
+}
+
+HANDLE
+fhandler_socket_unix::create_file (const sun_name_t *sun)
+{
+  if (sun->un_len <= (socklen_t) sizeof (sa_family_t)
+      || (sun->un_len == 3 && sun->un.sun_path[0] == '\0')
+      || sun->un_len > (socklen_t) sizeof sun->un)
+    {
+      set_errno (EINVAL);
+      return NULL;
+    }
+  if (sun->un.sun_path[0] == '\0')
+    return create_abstract_link (sun, pc.get_nt_native_path ());
+  return create_reparse_point (sun, pc.get_nt_native_path ());
+}
+
+int
+fhandler_socket_unix::open_abstract_link (sun_name_t *sun,
+					  PUNICODE_STRING pipe_name)
+{
+  WCHAR name[MAX_PATH];
+  OBJECT_ATTRIBUTES attr;
+  NTSTATUS status;
+  UNICODE_STRING uname;
+  HANDLE fh;
+
+  PWCHAR p = wcpcpy (name, L"af-unix-");
+  p = transform_chars_af_unix (p, sun->un.sun_path, sun->un_len);
+  *p = L'\0';
+  RtlInitUnicodeString (&uname, name);
+  InitializeObjectAttributes (&attr, &uname, OBJ_CASE_INSENSITIVE,
+			      get_shared_parent_dir (), NULL);
+  status = NtOpenSymbolicLinkObject (&fh, SYMBOLIC_LINK_QUERY, &attr);
+  if (!NT_SUCCESS (status))
+    {
+      __seterrno_from_nt_status (status);
+      return -1;
+    }
+  if (pipe_name)
+    status = NtQuerySymbolicLinkObject (fh, pipe_name, NULL);
+  NtClose (fh);
+  if (pipe_name)
+    {
+      if (!NT_SUCCESS (status))
+	{
+	  __seterrno_from_nt_status (status);
+	  return -1;
+	}
+      /* Enforce NUL-terminated pipe name. */
+      pipe_name->Buffer[pipe_name->Length / sizeof (WCHAR)] = L'\0';
+    }
+  return 0;
+}
+
+int
+fhandler_socket_unix::open_reparse_point (sun_name_t *sun,
+					  PUNICODE_STRING pipe_name)
+{
+  /* TODO: Open reparse point and fetch type and pipe name */
+  NTSTATUS status;
+  HANDLE fh;
+  OBJECT_ATTRIBUTES attr;
+  IO_STATUS_BLOCK io;
+  PREPARSE_GUID_DATA_BUFFER rp;
+  tmp_pathbuf tp;
+
+  path_conv pc (sun->un.sun_path, PC_SYM_FOLLOW);
   if (pc.error)
     {
       set_errno (pc.error);
@@ -63,30 +289,15 @@ HANDLE
       set_errno (ENOENT);
       return -1;
     }
-  /* Do NOT test for the file being a socket file here.  The socket file
-     creation is not an atomic operation, so there is a chance that socket
-     files which are just in the process of being created are recognized
-     as non-socket files.  To work around this problem we now create the
-     file with all sharing disabled.  If the below NtOpenFile fails
-     with STATUS_SHARING_VIOLATION we know that the file already exists,
-     but the creating process isn't finished yet.  So we yield and try
-     again, until we can either open the file successfully, or some error
-     other than STATUS_SHARING_VIOLATION occurs.
-     Since we now don't know if the file is actually a socket file, we
-     perform this check here explicitely. */
-  NTSTATUS status;
-  HANDLE fh;
-  OBJECT_ATTRIBUTES attr;
-  IO_STATUS_BLOCK io;
-
   pc.get_object_attr (attr, sec_none_nih);
   do
     {
       status = NtOpenFile (&fh, GENERIC_READ | SYNCHRONIZE, &attr, &io,
 			   FILE_SHARE_VALID_FLAGS,
 			   FILE_SYNCHRONOUS_IO_NONALERT
+			   | FILE_NON_DIRECTORY_FILE
 			   | FILE_OPEN_FOR_BACKUP_INTENT
-			   | FILE_NON_DIRECTORY_FILE);
+			   | FILE_OPEN_REPARSE_POINT);
       if (status == STATUS_SHARING_VIOLATION)
         {
           /* While we hope that the sharing violation is only temporary, we
@@ -109,53 +320,191 @@ HANDLE
         }
     }
   while (status == STATUS_SHARING_VIOLATION);
-  /* Now test for the SYSTEM bit. */
+  rp = (PREPARSE_GUID_DATA_BUFFER) tp.c_get ();
-  FILE_BASIC_INFORMATION fbi;
+  status = NtFsControlFile (fh, NULL, NULL, NULL, &io, FSCTL_GET_REPARSE_POINT,
-  status = NtQueryInformationFile (fh, &io, &fbi, sizeof fbi,
+			    NULL, 0, rp, MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
-				   FileBasicInformation);
-  if (!NT_SUCCESS (status))
-    {
-      __seterrno_from_nt_status (status);
-      return -1;
-    }
-  if (!(fbi.FileAttributes & FILE_ATTRIBUTE_SYSTEM))
-    {
   NtClose (fh);
-      set_errno (EBADF);
+  if (rp->ReparseTag == IO_REPARSE_TAG_CYGUNIX
-      return -1;
+      && memcmp (CYGWIN_SOCKET_GUID, &rp->ReparseGuid, sizeof (GUID)) == 0)
-    }
-  /* Eventually check the content and fetch the required information. */
-  char buf[128];
-  memset (buf, 0, sizeof buf);
-  status = NtReadFile (fh, NULL, NULL, NULL, &io, buf, 128, NULL, NULL);
-  NtClose (fh);
-  if (NT_SUCCESS (status))
     {
-#if 0 /* TODO */
+      if (pipe_name)
-      struct sockaddr_in sin;
-      char ctype;
-      sin.sin_family = AF_INET;
-      if (strncmp (buf, SOCKET_COOKIE, strlen (SOCKET_COOKIE)))
 	{
-	  set_errno (EBADF);
+	  rep_pipe_name_t *rep_pipe_name = (rep_pipe_name_t *)
-	  return -1;
+					   rp->GenericReparseBuffer.DataBuffer;
+	  pipe_name->Length = rep_pipe_name->Length;
+	  /* pipe name in reparse point is NUL-terminated */
+	  memcpy (pipe_name->Buffer, rep_pipe_name->PipeName,
+		  rep_pipe_name->Length + sizeof (WCHAR));
 	}
-      sscanf (buf + strlen (SOCKET_COOKIE), "%hu %c", &sin.sin_port, &ctype);
-      sin.sin_port = htons (sin.sin_port);
-      sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-      memcpy (out, &sin, sizeof sin);
-      *outlen = sizeof sin;
-      if (type)
-	*type = (ctype == 's' ? SOCK_STREAM :
-		 ctype == 'd' ? SOCK_DGRAM
-			      : 0);
-#endif
       return 0;
     }
-  __seterrno_from_nt_status (status);
   return -1;
 }
 
+int
+fhandler_socket_unix::open_file (sun_name_t *sun, int &type,
+				 PUNICODE_STRING pipe_name)
+{
+  int ret = -1;
+
+  if (sun->un_len <= (socklen_t) sizeof (sa_family_t)
+      || (sun->un_len == 3 && sun->un.sun_path[0] == '\0')
+      || sun->un_len > (socklen_t) sizeof sun->un)
+    set_errno (EINVAL);
+  else if (sun->un.sun_path[0] == '\0')
+    ret = open_abstract_link (sun, pipe_name);
+  else
+    ret = open_reparse_point (sun, pipe_name);
+  if (!ret)
+    switch (pipe_name->Buffer[38])
+      {
+      case 'd':
+	type = SOCK_DGRAM;
+	break;
+      case 's':
+	type = SOCK_STREAM;
+	break;
+      default:
+	set_errno (EINVAL);
+	ret = -1;
+	break;
+      }
+  return ret;
+}
+
+HANDLE
+fhandler_socket_unix::autobind (sun_name_t* sun)
+{
+  uint32_t id;
+  HANDLE fh;
+
+  do
+    {
+      /* Use only 5 hex digits (up to 2^20 sockets) for Linux compat */
+      set_unique_id ();
+      id = get_unique_id () & 0xfffff;
+      sun->un.sun_path[0] = '\0';
+      sun->un_len = sizeof (sa_family_t)
+		    + 1 /* leading NUL */
+		    + __small_sprintf (sun->un.sun_path + 1, "%5X", id);
+    }
+  while ((fh = create_abstract_link (sun, pc.get_nt_native_path ())) == NULL);
+  return fh;
+}
+
+wchar_t
+fhandler_socket_unix::get_type_char ()
+{
+  switch (get_socket_type ())
+    {
+    case SOCK_STREAM:
+      return 's';
+    case SOCK_DGRAM:
+      return 'd';
+    default:
+      return '?';
+    }
+}
+
+void
+fhandler_socket_unix::gen_pipe_name ()
+{
+  WCHAR pipe_name_buf[MAX_PATH];
+  UNICODE_STRING pipe_name;
+
+  __small_swprintf (pipe_name_buf,
+		    L"\\Device\\NamedPipe\\cygwin-%S-unix-%C-%016_X",
+		    &cygheap->installation_key,
+		    get_type_char (),
+		    get_plain_ino ());
+  RtlInitUnicodeString (&pipe_name, pipe_name_buf);
+  pc.set_nt_native_path (&pipe_name);
+}
+
+void
+fhandler_socket_unix::set_wait_state (DWORD wait_state)
+{
+  if (get_handle ())
+    {
+      NTSTATUS status;
+      IO_STATUS_BLOCK io;
+      FILE_PIPE_INFORMATION fpi;
+
+      fpi.ReadMode = FILE_PIPE_MESSAGE_MODE;
+      fpi.CompletionMode = wait_state;
+      status = NtSetInformationFile (get_handle (), &io, &fpi, sizeof fpi,
+				     FilePipeInformation);
+      if (!NT_SUCCESS (status))
+	system_printf ("NtSetInformationFile(FilePipeInformation): %y", status);
+    }
+}
+
+HANDLE
+fhandler_socket_unix::create_pipe ()
+{
+  NTSTATUS status;
+  HANDLE ph;
+  ACCESS_MASK access;
+  OBJECT_ATTRIBUTES attr;
+  IO_STATUS_BLOCK io;
+  ULONG sharing;
+  ULONG nonblocking;
+  ULONG max_instances;
+  LARGE_INTEGER timeout;
+
+  access = GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE;
+  sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
+  InitializeObjectAttributes (&attr, pc.get_nt_native_path (), OBJ_INHERIT,
+			      NULL, NULL);
+  nonblocking = is_nonblocking () ? FILE_PIPE_COMPLETE_OPERATION
+				  : FILE_PIPE_QUEUE_OPERATION;
+  max_instances = (get_socket_type () == SOCK_DGRAM) ? 1 : -1;
+  timeout.QuadPart = -500000;
+  status = NtCreateNamedPipeFile (&ph, access, &attr, &io, sharing,
+				  FILE_CREATE, FILE_SYNCHRONOUS_IO_NONALERT,
+				  FILE_PIPE_MESSAGE_TYPE,
+				  FILE_PIPE_MESSAGE_MODE,
+				  nonblocking, max_instances,
+				  PREFERRED_IO_BLKSIZE, PREFERRED_IO_BLKSIZE,
+				  &timeout);
+  if (!NT_SUCCESS (status))
+    system_printf ("NtCreateNamedPipeFile: %y", status);
+  return ph;
+}
+
+HANDLE
+fhandler_socket_unix::create_pipe_instance ()
+{
+  NTSTATUS status;
+  HANDLE ph;
+  ACCESS_MASK access;
+  OBJECT_ATTRIBUTES attr;
+  IO_STATUS_BLOCK io;
+  ULONG sharing;
+  ULONG nonblocking;
+  ULONG max_instances;
+  LARGE_INTEGER timeout;
+
+  access = GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE;
+  sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
+  InitializeObjectAttributes (&attr, pc.get_nt_native_path (), OBJ_INHERIT,
+			      NULL, NULL);
+  nonblocking = is_nonblocking () ? FILE_PIPE_COMPLETE_OPERATION
+				  : FILE_PIPE_QUEUE_OPERATION;
+  max_instances = (get_socket_type () == SOCK_DGRAM) ? 1 : -1;
+  timeout.QuadPart = -500000;
+  status = NtCreateNamedPipeFile (&ph, access, &attr, &io, sharing,
+				  FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT,
+				  FILE_PIPE_MESSAGE_TYPE,
+				  FILE_PIPE_MESSAGE_MODE,
+				  nonblocking, max_instances,
+				  PREFERRED_IO_BLKSIZE, PREFERRED_IO_BLKSIZE,
+				  &timeout);
+  if (!NT_SUCCESS (status))
+    system_printf ("NtCreateNamedPipeFile: %y", status);
+  return ph;
+}
+
 fhandler_socket_unix::fhandler_socket_unix () :
   sun_path (NULL),
   peer_sun_path (NULL)
@@ -218,8 +567,16 @@ fhandler_socket_unix::socket (int af, int type, int protocol, int flags)
       set_errno (EPROTONOSUPPORT);
       return -1;
     }
-  set_errno (EAFNOSUPPORT);
+  set_addr_family (af);
-  return -1;
+  set_socket_type (type);
+  if (flags & SOCK_NONBLOCK)
+    set_nonblocking (true);
+  if (flags & SOCK_CLOEXEC)
+    set_close_on_exec (true);
+  set_io_handle (NULL);
+  set_unique_id ();
+  set_ino (get_unique_id ());
+  return 0;
 }
 
 int
@@ -243,7 +600,34 @@ fhandler_socket_unix::socketpair (int af, int type, int protocol, int flags,
 int
 fhandler_socket_unix::bind (const struct sockaddr *name, int namelen)
 {
-  set_errno (EAFNOSUPPORT);
+  __try
+    {
+      sun_name_t sun (name, namelen);
+      bool unnamed = (sun.un_len == sizeof sun.un.sun_family);
+      HANDLE pipe = NULL;
+
+      if (get_handle ())
+	{
+	  set_errno (EINVAL);
+	  __leave;
+	}
+      gen_pipe_name ();
+      pipe = create_pipe ();
+      if (pipe)
+	{
+	  file = unnamed ? autobind (&sun) : create_file (&sun);
+	  if (!file)
+	    {
+	      NtClose (pipe);
+	      __leave;
+	    }
+	  set_io_handle (pipe);
+	  set_sun_path (&sun);
+	  return 0;
+	}
+    }
+  __except (EFAULT) {}
+  __endtry
   return -1;
 }
 
@@ -312,8 +696,11 @@ fhandler_socket_unix::shutdown (int how)
 int
 fhandler_socket_unix::close ()
 {
-  set_errno (EAFNOSUPPORT);
+  if (get_handle ())
-  return -1;
+    NtClose (get_handle ());
+  if (file && file != INVALID_HANDLE_VALUE)
+    NtClose (file);
+  return 0;
 }
 
 int