[PATCH v59 0/6] MR2786: Add support for AF_UNIX sockets

[Ally Sommers (＠dropbear)]

Windows 10 [received support](https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/) for AF_UNIX sockets in Insider Build 17063. This merge request adds basic support for AF_UNIX sockets to ws2_32 and wineserver.

Of particular note is the difficulty in handling `sun_path`. Most of the functions that allow for translating Windows paths to Unix paths are not accessible from ws2_32. I considered the following options:
 * Pass the Windows path to wineserver and do the conversion there.
   * This is, as far as I can tell, not possible without major rearchitecting. wineserver does not have functions to translate Windows paths to Unix paths, for obvious reasons.
 * Obtain the current working directory of the requesting process and temporarily change directories to there.
   * This only handles relative paths and fails for absolute paths, UNC paths, etc.
 * Conditionally change directories based on whether the path is relative or not.
   * This is error-prone and wineserver does not have the requisite functions to do this cleanly.

I ultimately decided to pass the translated Unix path to wineserver, which changes directories to `dirname(path)`. It then provides `bind` and `connect` with `basename(path)`. This is not threadsafe, but wineserver is not (currently) multithreaded.

Abstract sockets are not fully supported by this patch, matching the behavior of Windows.

--
  v59: ws2_32/tests: Add test for AF_UNIX sockets.
       server: Fix getsockname() and accept() on AF_UNIX sockets.
       server: Introduce error when attempting to create a SOCK_DGRAM AF_UNIX socket.
       server: Allow for deletion of socket files.
       ws2_32: Add support for AF_UNIX sockets.
       ws2_32: Add afunix.h header.
 
https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 1/6] ws2_32: Add afunix.h header.

[Ally Sommers]

From: Ally Sommers <dropbear.sh(a)gmail.com>

This header is needed for support of AF_UNIX sockets.
---
 include/Makefile.in |  1 +
 include/afunix.h    | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+)
 create mode 100644 include/afunix.h

diff --git a/include/Makefile.in b/include/Makefile.in
index d2df2383ea2..882ecb1821a 100644
--- a/include/Makefile.in
+++ b/include/Makefile.in
@@ -12,6 +12,7 @@ SOURCES = \
 	adshlp.h \
 	advpub.h \
 	af_irda.h \
+	afunix.h \
 	amaudio.h \
 	amsi.idl \
 	amstream.idl \
diff --git a/include/afunix.h b/include/afunix.h
new file mode 100644
index 00000000000..8118dda271b
--- /dev/null
+++ b/include/afunix.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2023 Ally Sommers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef _WS2AFUNIX_
+#define _WS2AFUNIX_
+
+#include "windef.h"
+#include "ws2def.h"
+
+#ifdef USE_WS_PREFIX
+# define WS(x)    WS_##x
+#else
+# define WS(x)    x
+#endif
+
+#define UNIX_PATH_MAX 108
+
+typedef struct WS(sockaddr_un) {
+    USHORT sun_family;
+    char sun_path[UNIX_PATH_MAX];
+} SOCKADDR_UN, *PSOCKADDR_UN;
+
+#endif /* _WS2AFUNIX_ */
\ No newline at end of file
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 2/6] ws2_32: Add support for AF_UNIX sockets.

[Ally Sommers]

From: Ally Sommers <dropbear.sh(a)gmail.com>

This commit additionally modifies wineserver's sock_ioctl to handle the
provided pathname by changing directories and then returning after the
native call. This is NOT threadsafe, but wineserver is not
multithreaded.
---
 dlls/ntdll/unix/socket.c     |  12 +++
 dlls/ws2_32/socket.c         |  91 ++++++++++++++++++++--
 dlls/ws2_32/ws2_32_private.h |  14 ++++
 server/sock.c                | 144 ++++++++++++++++++++++++++++++++---
 4 files changed, 247 insertions(+), 14 deletions(-)

diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c
index e09bf34b07d..efd3904983a 100644
--- a/dlls/ntdll/unix/socket.c
+++ b/dlls/ntdll/unix/socket.c
@@ -67,6 +67,8 @@
 # define HAS_IRDA
 #endif
 
+#include <sys/un.h>
+
 #include "ntstatus.h"
 #define WIN32_NO_STATUS
 #include "windef.h"
@@ -78,6 +80,7 @@
 #include "ws2tcpip.h"
 #include "wsipx.h"
 #include "af_irda.h"
+#include "afunix.h"
 #include "wine/afd.h"
 
 #include "unix_private.h"
@@ -106,6 +109,7 @@ union unix_sockaddr
 #ifdef HAS_IRDA
     struct sockaddr_irda irda;
 #endif
+    struct sockaddr_un un;
 };
 
 struct async_recv_ioctl
@@ -1953,6 +1957,14 @@ NTSTATUS sock_ioctl( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc
                 break;
             }
 
+            if (unix_addr.addr.sa_family == AF_UNIX)
+            {
+                FIXME( "getpeername called on AF_UNIX socket\n" );
+                io->Information = sizeof(unix_addr.un);
+                status = STATUS_SUCCESS;
+                break;
+            }
+
             len = sockaddr_from_unix( &unix_addr, out_buffer, out_size );
             if (out_size < len)
             {
diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c
index 8ef7920e0fc..c61f03909c2 100644
--- a/dlls/ws2_32/socket.c
+++ b/dlls/ws2_32/socket.c
@@ -167,6 +167,19 @@ static const WSAPROTOCOL_INFOW supported_protocols[] =
         .dwMessageSize = UINT_MAX,
         .szProtocol = L"SPX II",
     },
+    {
+        .dwServiceFlags1 = XP1_GUARANTEED_DELIVERY | XP1_GUARANTEED_ORDER | XP1_IFS_HANDLES,
+        .dwProviderFlags = PFL_MATCHES_PROTOCOL_ZERO,
+        .ProviderId = {0xa00943d9, 0x9c2e, 0x4633, {0x9b, 0x59, 0x00, 0x57, 0xa3, 0x16, 0x09, 0x94}},
+        .dwCatalogEntryId = 1007,
+        .ProtocolChain.ChainLen = 1,
+        .iVersion = 2,
+        .iAddressFamily = AF_UNIX,
+        .iMaxSockAddr = sizeof(struct sockaddr_un),
+        .iMinSockAddr = offsetof(struct sockaddr_un, sun_path),
+        .iSocketType = SOCK_STREAM,
+        .szProtocol = L"AF_UNIX",
+    },
 };
 
 DECLARE_CRITICAL_SECTION(cs_socket_list);
@@ -226,6 +239,11 @@ const char *debugstr_sockaddr( const struct sockaddr *a )
                                 addr,
                                 ((const SOCKADDR_IRDA *)a)->irdaServiceName);
     }
+    case AF_UNIX:
+    {
+        return wine_dbg_sprintf("{ family AF_UNIX, path %s }",
+                                ((const SOCKADDR_UN *)a)->sun_path);
+    }
     default:
         return wine_dbg_sprintf("{ family %d }", a->sa_family);
     }
@@ -1106,6 +1124,11 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
     HANDLE sync_event;
     NTSTATUS status;
 
+    const int bind_len = len;
+    char *unix_path = NULL;
+    int unix_path_len = 0;
+    int unix_varargs_size = 0;
+
     TRACE( "socket %#Ix, addr %s\n", s, debugstr_sockaddr(addr) );
 
     if (!addr)
@@ -1148,6 +1171,14 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
             }
             break;
 
+        case AF_UNIX:
+            if (len < offsetof(struct sockaddr_un, sun_path))
+            {
+                SetLastError( WSAEFAULT );
+                return -1;
+            }
+            break;
+
         default:
             FIXME( "unknown protocol %u\n", addr->sa_family );
             SetLastError( WSAEAFNOSUPPORT );
@@ -1156,7 +1187,30 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
 
     if (!(sync_event = get_sync_event())) return -1;
 
-    params = malloc( sizeof(int) + len );
+    if (addr->sa_family == AF_UNIX && *addr->sa_data)
+    {
+        struct sockaddr_un sun = { 0 };
+        WCHAR *sun_pathW;
+        memcpy(&sun, addr, len);
+        if (strlen( sun.sun_path ))
+        {
+            sun_pathW = strdupAtoW( sun.sun_path );
+            unix_path = wine_get_unix_file_name( sun_pathW );
+            free( sun_pathW );
+            if (!unix_path)
+                return SOCKET_ERROR;
+        }
+        else
+        {
+            unix_path = malloc(1);
+            *unix_path = '\0';
+        }
+        unix_path_len = strlen( unix_path ) + 1;
+        len = sizeof(sun);
+        unix_varargs_size = sizeof(unix_path_len) + unix_path_len;
+    }
+
+    params = malloc( sizeof(int) + len + unix_varargs_size );
     ret_addr = malloc( len );
     if (!params || !ret_addr)
     {
@@ -1166,10 +1220,15 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
         return -1;
     }
     params->unknown = 0;
-    memcpy( ¶ms->addr, addr, len );
+    memcpy( ¶ms->addr, addr, bind_len );
+    if (unix_path)
+    {
+        memcpy( (char *)¶ms->addr + len, &unix_path_len, sizeof(unix_path_len) );
+        memcpy( (char *)¶ms->addr + len + sizeof(unix_path_len), unix_path, unix_path_len );
+    }
 
     status = NtDeviceIoControlFile( (HANDLE)s, sync_event, NULL, NULL, &io, IOCTL_AFD_BIND,
-                                    params, sizeof(int) + len, ret_addr, len );
+                                    params, sizeof(int) + len + unix_varargs_size, ret_addr, len );
     if (status == STATUS_PENDING)
     {
         if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
@@ -1182,6 +1241,7 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
 
     free( params );
     free( ret_addr );
+    free( unix_path );
 
     SetLastError( NtStatusToWSAError( status ) );
     return status ? -1 : 0;
@@ -1222,11 +1282,26 @@ int WINAPI connect( SOCKET s, const struct sockaddr *addr, int len )
     HANDLE sync_event;
     NTSTATUS status;
 
+    char *unix_path = NULL;
+    int unix_path_len = 0;
+    int unix_varargs_size = 0;
+
     TRACE( "socket %#Ix, addr %s, len %d\n", s, debugstr_sockaddr(addr), len );
 
     if (!(sync_event = get_sync_event())) return -1;
 
-    if (!(params = malloc( sizeof(*params) + len )))
+    if (addr->sa_family == AF_UNIX && *addr->sa_data)
+    {
+        WCHAR *sun_pathW = strdupAtoW(addr->sa_data);
+        unix_path = wine_get_unix_file_name(sun_pathW);
+        free(sun_pathW);
+        if (!unix_path)
+            return SOCKET_ERROR;
+        unix_path_len = strlen(unix_path) + 1;
+        unix_varargs_size = sizeof(unix_path_len) + unix_path_len;
+    }
+
+    if (!(params = malloc( sizeof(*params) + len + unix_path_len )))
     {
         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
         return -1;
@@ -1234,10 +1309,16 @@ int WINAPI connect( SOCKET s, const struct sockaddr *addr, int len )
     params->addr_len = len;
     params->synchronous = TRUE;
     memcpy( params + 1, addr, len );
+    if (unix_path_len)
+    {
+        memcpy( (char *)(params + 1) + len, &unix_path_len, sizeof(unix_path_len) );
+        memcpy( (char *)(params + 1) + len + sizeof(unix_path_len), unix_path, unix_path_len );
+    }
 
     status = NtDeviceIoControlFile( (HANDLE)s, sync_event, NULL, NULL, &io, IOCTL_AFD_WINE_CONNECT,
-                                    params, sizeof(*params) + len, NULL, 0 );
+                                    params, sizeof(*params) + len + unix_varargs_size, NULL, 0 );
     free( params );
+    free( unix_path );
     if (status == STATUS_PENDING)
     {
         if (wait_event_alertable( sync_event ) == WAIT_FAILED) return -1;
diff --git a/dlls/ws2_32/ws2_32_private.h b/dlls/ws2_32/ws2_32_private.h
index a009a1eefd3..e64caedcef9 100644
--- a/dlls/ws2_32/ws2_32_private.h
+++ b/dlls/ws2_32/ws2_32_private.h
@@ -44,6 +44,7 @@
 #include "mstcpip.h"
 #include "af_irda.h"
 #include "winnt.h"
+#include "afunix.h"
 #define USE_WC_PREFIX   /* For CMSG_DATA */
 #include "iphlpapi.h"
 #include "ip2string.h"
@@ -71,6 +72,19 @@ static inline char *strdupWtoA( const WCHAR *str )
     return ret;
 }
 
+static inline WCHAR *strdupAtoW( const char *str )
+{
+    WCHAR *ret = NULL;
+    if (str)
+    {
+        DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
+        if ((ret = malloc( len * sizeof(WCHAR) )))
+            MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
+    }
+    return ret;
+}
+
+
 static const char magic_loopback_addr[] = {127, 12, 34, 56};
 
 const char *debugstr_sockaddr( const struct sockaddr *addr ) DECLSPEC_HIDDEN;
diff --git a/server/sock.c b/server/sock.c
index 52175b08987..054521ab81f 100644
--- a/server/sock.c
+++ b/server/sock.c
@@ -53,6 +53,7 @@
 #include <time.h>
 #include <unistd.h>
 #include <limits.h>
+#include <libgen.h>
 #ifdef HAVE_LINUX_FILTER_H
 # include <linux/filter.h>
 #endif
@@ -84,6 +85,8 @@
 # define HAS_IRDA
 #endif
 
+#include <sys/un.h>
+
 #include "ntstatus.h"
 #define WIN32_NO_STATUS
 #include "windef.h"
@@ -94,6 +97,7 @@
 #include "ws2tcpip.h"
 #include "wsipx.h"
 #include "af_irda.h"
+#include "afunix.h"
 #include "wine/afd.h"
 #include "wine/rbtree.h"
 
@@ -117,6 +121,7 @@ union win_sockaddr
     struct WS_sockaddr_in6 in6;
     struct WS_sockaddr_ipx ipx;
     SOCKADDR_IRDA irda;
+    struct WS_sockaddr_un un;
 };
 
 union unix_sockaddr
@@ -130,6 +135,7 @@ union unix_sockaddr
 #ifdef HAS_IRDA
     struct sockaddr_irda irda;
 #endif
+    struct sockaddr_un un;
 };
 
 static struct list poll_list = LIST_INIT( poll_list );
@@ -675,6 +681,9 @@ static socklen_t get_unix_sockaddr_any( union unix_sockaddr *uaddr, int ws_famil
             uaddr->irda.sir_family = AF_IRDA;
             return sizeof(uaddr->irda);
 #endif
+        case WS_AF_UNIX:
+            uaddr->un.sun_family = AF_UNIX;
+            return sizeof(uaddr->un);
         default:
             return 0;
     }
@@ -1764,6 +1773,7 @@ static int get_unix_family( int family )
 #ifdef AF_IRDA
         case WS_AF_IRDA: return AF_IRDA;
 #endif
+        case WS_AF_UNIX: return AF_UNIX;
         case WS_AF_UNSPEC: return AF_UNSPEC;
         default: return -1;
     }
@@ -2547,8 +2557,13 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 
         if (listen( unix_fd, params->backlog ) < 0)
         {
-            set_error( sock_get_ntstatus( errno ) );
-            return;
+            /* Due to the way we handle the Windows AF_UNIX bind edge case, we also need to
+             * ignore listen's error. */
+            if (!(errno == EINVAL && sock->family == WS_AF_UNIX && !*sock->addr.un.sun_path))
+            {
+                set_error( sock_get_ntstatus( errno ) );
+                return;
+            }
         }
 
         sock->state = SOCK_LISTENING;
@@ -2618,7 +2633,47 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
                 break;
         }
 
-        unix_len = sockaddr_to_unix( addr, params->addr_len, &unix_addr );
+        if (sock->family == WS_AF_UNIX)
+        {
+            if (*((struct WS_sockaddr_un *)&addr)->sun_path)
+            {
+                int unix_path_len = *(int *)((char *)(params + 1) + params->addr_len);
+                char *unix_path = (char *)(params + 1) + params->addr_len + sizeof(unix_path_len);
+                char *base_name;
+                unix_path[unix_path_len - 1] = '\0';
+                
+                base_name = strrchr(unix_path, '/');
+                if (base_name)
+                {
+                    if (base_name != unix_path)
+                        (++base_name)[-1] = '\0';
+                }
+                else
+                    base_name = unix_path;
+
+                if (chdir( unix_path ) == -1)
+                {
+                    set_error( sock_get_ntstatus( errno ) );
+                    return;
+                }
+
+                unix_len = sizeof(unix_addr.un);
+                memset( &unix_addr.un, 0, sizeof(unix_addr.un) );
+                unix_addr.un.sun_family = AF_UNIX;
+                memcpy( unix_addr.un.sun_path, base_name, strlen( base_name ) );
+            }
+            else
+            {
+                /* Contrary to documentation, Windows does not currently support abstract Unix
+                 * sockets. connect() throws WSAEINVAL if sun_family is AF_UNIX and sun_path
+                 * begins with '\0', even though bind() will succeed. */
+                set_win32_error( WSAEINVAL );
+                return;
+            }
+        }
+        else
+            unix_len = sockaddr_to_unix( addr, params->addr_len, &unix_addr );
+
         if (!unix_len)
         {
             set_error( STATUS_INVALID_ADDRESS );
@@ -2639,6 +2694,9 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
             ret = connect( unix_fd, &unix_addr.addr, unix_len );
         }
 
+        if (sock->family == WS_AF_UNIX && *((struct WS_sockaddr_un *)&addr)->sun_path)
+            fchdir(server_dir_fd);
+
         if (ret < 0 && errno != EINPROGRESS)
         {
             set_error( sock_get_ntstatus( errno ) );
@@ -2878,8 +2936,10 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
         const struct afd_bind_params *params = get_req_data();
         union unix_sockaddr unix_addr, bind_addr;
         data_size_t in_size;
+        data_size_t varargs_size;
         socklen_t unix_len;
         int v6only = 1;
+        int unix_path_len = 0;
 
         /* the ioctl is METHOD_NEITHER, so ntdll gives us the output buffer as
          * input */
@@ -2889,8 +2949,15 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
             return;
         }
         in_size = get_req_data_size() - get_reply_max_size();
+        if (params->addr.sa_family == WS_AF_UNIX)
+        {
+            unix_path_len = *(int *)((char *)¶ms->addr + sizeof(unix_addr.un));
+            varargs_size = sizeof(int) + sizeof(int) + unix_path_len;
+        }
+        else
+            varargs_size = sizeof(int);
         if (in_size < offsetof(struct afd_bind_params, addr.sa_data)
-                || get_reply_max_size() < in_size - sizeof(int))
+                || get_reply_max_size() < in_size - varargs_size)
         {
             set_error( STATUS_INVALID_PARAMETER );
             return;
@@ -2902,7 +2969,40 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
             return;
         }
 
-        unix_len = sockaddr_to_unix( ¶ms->addr, in_size - sizeof(int), &unix_addr );
+        if (sock->family == WS_AF_UNIX)
+        {
+            if (*params->addr.sa_data)
+            {
+                char *unix_path = (char *)¶ms->addr + sizeof(unix_addr.un) + sizeof(unix_path_len);
+                char *base_name;
+                unix_path[unix_path_len - 1] = '\0';
+
+                base_name = strrchr(unix_path, '/');
+                if (base_name)
+                {
+                    if (base_name != unix_path)
+                        (++base_name)[-1] = '\0';
+                }
+                else
+                    base_name = unix_path;
+
+                if (chdir( unix_path ) == -1)
+                {
+                    set_error( sock_get_ntstatus( errno ) );
+                    return;
+                }
+
+                memset( &unix_addr.un, 0, sizeof(unix_addr.un) );
+                memcpy( unix_addr.un.sun_path, base_name, strlen( base_name ) );
+            }
+            else
+                memset(unix_addr.un.sun_path, 0, sizeof(unix_addr.un.sun_path));
+            unix_addr.un.sun_family = AF_UNIX;
+            unix_len = sizeof(unix_addr.un);
+        }
+        else
+            unix_len = sockaddr_to_unix( ¶ms->addr, in_size - sizeof(int), &unix_addr );
+
         if (!unix_len)
         {
             set_error( STATUS_INVALID_ADDRESS );
@@ -2946,8 +3046,16 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
             if (errno == EADDRINUSE && sock->reuseaddr)
                 errno = EACCES;
 
-            set_error( sock_get_ntstatus( errno ) );
-            return;
+            /* Windows' AF_UNIX implementation has an edge case allowing for a socket to bind to
+             * an empty path. Linux doesn't, so it throws EINVAL. We check for this situation
+             * here and avoid early-exiting if it's the case. */
+            if (!(errno == EINVAL && sock->family == WS_AF_UNIX && !*params->addr.sa_data))
+            {
+                set_error( sock_get_ntstatus( errno ) );
+                if (sock->family == WS_AF_UNIX && *params->addr.sa_data)
+                    fchdir(server_dir_fd);
+                return;
+            }
         }
 
         sock->bound = 1;
@@ -2959,13 +3067,23 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
              * actual unix address */
             if (bind_addr.addr.sa_family == AF_INET)
                 bind_addr.in.sin_addr = unix_addr.in.sin_addr;
-            sock->addr_len = sockaddr_from_unix( &bind_addr, &sock->addr.addr, sizeof(sock->addr) );
+            if (bind_addr.addr.sa_family == AF_UNIX)
+            {
+                sock->addr.un.sun_family = WS_AF_UNIX;
+                memcpy(sock->addr.un.sun_path, params->addr.sa_data, sizeof(sock->addr.un.sun_path));
+                sock->addr_len = sizeof(sock->addr.un);
+            }
+            else
+                sock->addr_len = sockaddr_from_unix( &bind_addr, &sock->addr.addr, sizeof(sock->addr) );
         }
 
         update_addr_usage( sock, &bind_addr, v6only );
 
         if (get_reply_max_size() >= sock->addr_len)
             set_reply_data( &sock->addr, sock->addr_len );
+
+        if (sock->family == WS_AF_UNIX && *params->addr.sa_data)
+            fchdir(server_dir_fd);
         return;
     }
 
@@ -2982,7 +3100,15 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
             return;
         }
 
-        set_reply_data( &sock->addr, sock->addr_len );
+        if (sock->family == WS_AF_UNIX)
+        {
+            if (*sock->addr.un.sun_path)
+                set_reply_data( &sock->addr, sizeof(sock->addr.un.sun_family) + strlen(sock->addr.un.sun_path) + 1 );
+            else
+                set_reply_data( &sock->addr, sizeof(sock->addr.un) );
+        }
+        else
+            set_reply_data( &sock->addr, sock->addr_len );
         return;
 
     case IOCTL_AFD_WINE_DEFER:
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 3/6] server: Allow for deletion of socket files.

[Ally Sommers]

From: Ally Sommers <dropbear.sh(a)gmail.com>

Deleting the socket file is a common pattern with AF_UNIX sockets, and
is analogous to unbinding.
---
 server/fd.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/server/fd.c b/server/fd.c
index 7cdd329bcbb..e8451587eea 100644
--- a/server/fd.c
+++ b/server/fd.c
@@ -1932,6 +1932,19 @@ struct fd *open_fd( struct fd *root, const char *name, struct unicode_str nt_nam
                 fd->unix_fd = open( name, O_RDONLY | (flags & ~(O_TRUNC | O_CREAT | O_EXCL)), *mode );
         }
 
+        /* POSIX requires that open(2) throws EOPNOTSUPP when `path` is a Unix
+         * socket. *BSD throws EOPNOTSUPP in this case and the additional case of
+         * O_SHLOCK or O_EXLOCK being passed when `path` resides on a filesystem
+         * without lock support.
+         *
+         * Contrary to POSIX, Linux returns ENXIO in this case, so we also check
+         * that error code here. */
+        if (errno == EOPNOTSUPP || errno == ENXIO)
+        {
+            if (!stat(name, &st) && S_ISSOCK(st.st_mode) && (options & FILE_DELETE_ON_CLOSE))
+                goto skip_open_fail;
+        }
+
         if (fd->unix_fd == -1)
         {
             /* check for trailing slash on file path */
@@ -1943,6 +1956,7 @@ struct fd *open_fd( struct fd *root, const char *name, struct unicode_str nt_nam
         }
     }
 
+skip_open_fail:
     fd->nt_name = dup_nt_name( root, nt_name, &fd->nt_namelen );
     fd->unix_name = NULL;
     if ((path = dup_fd_name( root, name )))
@@ -1954,11 +1968,12 @@ struct fd *open_fd( struct fd *root, const char *name, struct unicode_str nt_nam
     closed_fd->unix_fd = fd->unix_fd;
     closed_fd->disp_flags = 0;
     closed_fd->unix_name = fd->unix_name;
-    fstat( fd->unix_fd, &st );
+    if (fd->unix_fd != -1)
+        fstat( fd->unix_fd, &st );
     *mode = st.st_mode;
 
-    /* only bother with an inode for normal files and directories */
-    if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode))
+    /* only bother with an inode for normal files, directories, and socket files */
+    if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode) || S_ISSOCK(st.st_mode))
     {
         unsigned int err;
         struct inode *inode = get_inode( st.st_dev, st.st_ino, fd->unix_fd );
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 4/6] server: Introduce error when attempting to create a SOCK_DGRAM AF_UNIX socket.

[Ally Sommers]

From: Ally Sommers <dropbear.sh(a)gmail.com>

---
 server/sock.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/server/sock.c b/server/sock.c
index 054521ab81f..52d3db1cb5d 100644
--- a/server/sock.c
+++ b/server/sock.c
@@ -1866,6 +1866,12 @@ static int init_socket( struct sock *sock, int family, int type, int protocol )
         return -1;
     }
 
+    if (unix_family == AF_UNIX && unix_type == SOCK_DGRAM)
+    {
+        set_win32_error(WSAEAFNOSUPPORT);
+        return -1;
+    }
+
     sockfd = socket( unix_family, unix_type, unix_protocol );
 
 #ifdef linux
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 5/6] server: Fix getsockname() and accept() on AF_UNIX sockets.

[Ally Sommers]

From: Ally Sommers <dropbear.sh(a)gmail.com>

---
 server/sock.c | 33 ++++++++++++++++++++++++++++++---
 1 file changed, 30 insertions(+), 3 deletions(-)

diff --git a/server/sock.c b/server/sock.c
index 52d3db1cb5d..cc06766e1d1 100644
--- a/server/sock.c
+++ b/server/sock.c
@@ -2050,7 +2050,19 @@ static struct sock *accept_socket( struct sock *sock )
         }
         unix_len = sizeof(unix_addr);
         if (!getsockname( acceptfd, &unix_addr.addr, &unix_len ))
-            acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
+        {
+            if (sock->family == WS_AF_UNIX)
+            {
+                acceptsock->addr_len = sock->addr_len;
+                acceptsock->addr.un = sock->addr.un;
+            }
+            else
+            {
+                acceptsock->addr_len = sockaddr_from_unix( &unix_addr,
+                                                           &acceptsock->addr.addr,
+                                                           sizeof(acceptsock->addr) );
+            }
+        }
     }
     clear_error();
     sock->pending_events &= ~AFD_POLL_ACCEPT;
@@ -2106,7 +2118,19 @@ static int accept_into_socket( struct sock *sock, struct sock *acceptsock )
 
     unix_len = sizeof(unix_addr);
     if (!getsockname( get_unix_fd( newfd ), &unix_addr.addr, &unix_len ))
-        acceptsock->addr_len = sockaddr_from_unix( &unix_addr, &acceptsock->addr.addr, sizeof(acceptsock->addr) );
+    {
+        if (sock->family == WS_AF_UNIX)
+        {
+            acceptsock->addr_len = sock->addr_len;
+            acceptsock->addr.un = sock->addr.un;
+        }
+        else
+        {
+            acceptsock->addr_len = sockaddr_from_unix( &unix_addr,
+                                                       &acceptsock->addr.addr,
+                                                       sizeof(acceptsock->addr) );
+        }
+    }
 
     clear_error();
     sock->pending_events &= ~AFD_POLL_ACCEPT;
@@ -2714,7 +2738,10 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 
         unix_len = sizeof(unix_addr);
         if (!getsockname( unix_fd, &unix_addr.addr, &unix_len ))
-            sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
+        {
+            if (sock->family != WS_AF_UNIX)
+                sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) );
+        }
         sock->bound = 1;
 
         if (!ret)
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 6/6] ws2_32/tests: Add test for AF_UNIX sockets.

[Ally Sommers]

From: Ally Sommers <dropbear.sh(a)gmail.com>

---
 dlls/ws2_32/tests/sock.c | 292 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 292 insertions(+)

diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c
index 5ab21060a62..22af234dc22 100644
--- a/dlls/ws2_32/tests/sock.c
+++ b/dlls/ws2_32/tests/sock.c
@@ -29,6 +29,7 @@
 #include <iphlpapi.h>
 #include <ws2tcpip.h>
 #include <wsipx.h>
+#include <afunix.h>
 #include <wsnwlink.h>
 #include <mswsock.h>
 #include <mstcpip.h>
@@ -13903,6 +13904,296 @@ static void test_tcp_sendto_recvfrom(void)
     closesocket(server);
 }
 
+static void test_afunix(void)
+{
+    SOCKET listener, client, server = 0;
+    SOCKADDR_UN addr = { AF_UNIX, "test_afunix.sock" };
+    char serverBuf[] = "ws2_32/AF_UNIX socket test";
+    char clientBuf[sizeof(serverBuf)] = { 0 };
+
+    char paths[4][sizeof(addr.sun_path)] = { "./tmp.sock", "../tmp.sock" };
+    char dosPath[sizeof(addr.sun_path)];
+    WCHAR dosWidePath[sizeof(addr.sun_path)];
+    UNICODE_STRING ntPath = { 0 };
+    SOCKADDR_UN outAddr = { 0 };
+    int outAddrSize = sizeof(outAddr);
+    SOCKADDR_UN truncatedAddr = { 0 };
+    ULONG zero = 0;
+    ULONG one = 1;
+    int ret;
+
+    /* Test connection and send/recv */
+    listener = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (listener == INVALID_SOCKET && GetLastError() == WSAEAFNOSUPPORT)
+    {
+        win_skip("AF_UNIX sockets are unsupported, skipping...\n");
+        return;
+    }
+
+    ok(listener != INVALID_SOCKET, "Could not create Unix socket: %lu\n",
+        GetLastError());
+
+    ret = bind(listener, (SOCKADDR *)&addr, 0);
+    ok(ret && GetLastError() == WSAEFAULT, "Incorrect error: %lu\n", GetLastError());
+    ret = bind(listener, (SOCKADDR *)&addr, 2);
+    ok(!ret, "Could not bind Unix socket: %lu\n", GetLastError());
+    ret = listen(listener, 1);
+    ok(!ret, "Could not listen on Unix socket: %lu\n", GetLastError());
+    closesocket(listener);
+
+    listener = socket(AF_UNIX, SOCK_STREAM, 0);
+    ok(listener != INVALID_SOCKET, "Could not create Unix socket: %lu\n",
+        GetLastError());
+    ret = bind(listener, (SOCKADDR *)&addr, 3);
+    ok(!ret, "Could not bind Unix socket: %lu\n", GetLastError());
+
+    memcpy(&truncatedAddr, &addr, 3);
+    ret = getsockname(listener, (SOCKADDR *)&outAddr, &outAddrSize);
+    ok(!ret, "Could not get info on Unix socket: %lu\n", GetLastError());
+    ok(!memcmp(truncatedAddr.sun_path, outAddr.sun_path, sizeof(addr.sun_path)),
+        "getsockname returned incorrect path '%s' for provided path '%s'\n",
+        outAddr.sun_path,
+        truncatedAddr.sun_path);
+    ok(outAddrSize == sizeof(outAddr.sun_family) + strlen(outAddr.sun_path) + 1,
+        "getsockname returned incorrect size '%d' for provided path '%s'\n",
+        outAddrSize,
+        truncatedAddr.sun_path);
+    closesocket(listener);
+    ret = DeleteFileA(truncatedAddr.sun_path);
+    ok(ret, "DeleteFileA on socket file failed: %lu\n", GetLastError());
+    ok(GetFileAttributesA(truncatedAddr.sun_path) == INVALID_FILE_ATTRIBUTES &&
+        GetLastError() == ERROR_FILE_NOT_FOUND,
+        "Failed to delete socket file at path '%s'\n",
+        truncatedAddr.sun_path);
+
+    listener = socket(AF_UNIX, SOCK_STREAM, 0);
+    ok(listener != INVALID_SOCKET, "Could not create Unix socket: %lu\n",
+        GetLastError());
+
+    ret = bind(listener, (SOCKADDR *)&addr, sizeof(SOCKADDR_UN));
+    ok(!ret, "Could not bind Unix socket: %lu\n", GetLastError());
+
+    ret = listen(listener, 1);
+    ok(!ret, "Could not listen on Unix socket: %lu\n", GetLastError());
+
+    client = socket(AF_UNIX, SOCK_STREAM, 0);
+    ok(client != INVALID_SOCKET, "Failed to create second Unix socket: %lu\n",
+        GetLastError());
+
+    ret = ioctlsocket(client, FIONBIO, &one);
+    ok(!ret, "Could not set AF_UNIX socket to nonblocking: %lu; skipping connection\n", GetLastError());
+    if (!ret)
+    {
+        ret = connect(client, (SOCKADDR *)&addr, sizeof(addr));
+        ok(!ret || (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK),
+            "Error when connecting to Unix socket: %lu\n",
+            GetLastError());
+        server = accept(listener, NULL, NULL);
+        ok(server != INVALID_SOCKET, "Could not accept Unix socket connection: %lu\n",
+            GetLastError());
+        ret = ioctlsocket(client, FIONBIO, &zero);
+        ok(!ret, "Could not set AF_UNIX socket to blocking: %lu\n", GetLastError());
+    }
+
+    ret = send(server, serverBuf, sizeof(serverBuf), 0);
+    ok(ret == sizeof(serverBuf), "Incorrect return value from send: %d\n", ret);
+    ret = recv(client, clientBuf, sizeof(serverBuf), 0);
+    ok(ret == sizeof(serverBuf), "Incorrect return value from recv: %d\n", ret);
+    ok(!memcmp(serverBuf, clientBuf, sizeof(serverBuf)), "Data mismatch over Unix socket\n");
+
+    memset(clientBuf, 0, sizeof(clientBuf));
+
+    ret = sendto(server, serverBuf, sizeof(serverBuf), 0, NULL, 0);
+    ok(ret == sizeof(serverBuf), "Incorrect return value from sendto: %d\n", ret);
+    ret = recvfrom(client, clientBuf, sizeof(serverBuf), 0, NULL, 0);
+    ok(ret == sizeof(serverBuf), "Incorrect return value from recvfrom: %d\n", ret);
+    ok(!memcmp(serverBuf, clientBuf, sizeof(serverBuf)), "Data mismatch over Unix socket\n");
+
+    memset(serverBuf, 0, sizeof(serverBuf));
+
+    ret = send(client, clientBuf, sizeof(clientBuf), 0);
+    ok(ret == sizeof(clientBuf), "Incorrect return value from send: %d\n", ret);
+    ret = recv(server, serverBuf, sizeof(clientBuf), 0);
+    ok(ret == sizeof(serverBuf), "Incorrect return value from recv: %d\n", ret);
+    ok(!memcmp(serverBuf, clientBuf, sizeof(clientBuf)), "Data mismatch over Unix socket\n");
+
+    memset(serverBuf, 0, sizeof(serverBuf));
+
+    ret = sendto(client, clientBuf, sizeof(clientBuf), 0, NULL, 0);
+    ok(ret == sizeof(clientBuf), "Incorrect return value from sendto: %d\n", ret);
+    ret = recvfrom(server, serverBuf, sizeof(clientBuf), 0, NULL, 0);
+    ok(ret == sizeof(serverBuf), "Incorrect return value from recvfrom: %d\n", ret);
+    ok(!memcmp(serverBuf, clientBuf, sizeof(clientBuf)), "Data mismatch over Unix socket\n");
+
+    closesocket(listener);
+    closesocket(client);
+    closesocket(server);
+
+    /* Test socket file deletion */
+    ret = DeleteFileA("test_afunix.sock");
+    ok(ret, "DeleteFileA on socket file failed: %lu\n", GetLastError());
+    ok(GetFileAttributesA("test_afunix.sock") == INVALID_FILE_ATTRIBUTES &&
+        GetLastError() == ERROR_FILE_NOT_FOUND,
+        "Failed to delete socket file at path '%s'\n",
+        addr.sun_path);
+
+    /* Test failure modes */
+    listener = socket(AF_UNIX, SOCK_STREAM, 0);
+    ok(listener != INVALID_SOCKET, "Could not create Unix socket: %lu\n",
+        GetLastError());
+    ret = bind(listener, (SOCKADDR *)&addr, sizeof(SOCKADDR_UN));
+    ok(!ret, "Could not bind Unix socket to path '%s': %lu\n", addr.sun_path, GetLastError());
+    closesocket(listener);
+    listener = socket(AF_UNIX, SOCK_STREAM, 0);
+    ok(listener != INVALID_SOCKET, "Could not create Unix socket: %lu\n",
+        GetLastError());
+    ret = bind(listener, (SOCKADDR *)&addr, sizeof(SOCKADDR_UN));
+    ok(ret && GetLastError() == WSAEADDRINUSE,
+        "Bound Unix socket to path '%s' despite existing socket file: %lu\n",
+        addr.sun_path,
+        GetLastError());
+    closesocket(listener);
+    ret = DeleteFileA(addr.sun_path);
+    ok(ret, "DeleteFileA on socket file failed: %lu\n", GetLastError());
+    ok(GetFileAttributesA("test_afunix.sock") == INVALID_FILE_ATTRIBUTES &&
+        GetLastError() == ERROR_FILE_NOT_FOUND,
+        "Failed to delete socket file at path '%s'\n",
+        addr.sun_path);
+
+    /* Test different path types (relative, NT, etc.) */
+    GetTempPathA(sizeof(paths[0]) - 1, paths[2]);
+    strcat(paths[2], "tmp.sock");
+    MultiByteToWideChar(CP_ACP, 0, paths[2], -1, dosWidePath, sizeof(dosPath));
+    RtlDosPathNameToNtPathName_U(dosWidePath, &ntPath, NULL, NULL);
+    RtlUnicodeToMultiByteN(paths[3], sizeof(addr.sun_path) - 1, NULL, ntPath.Buffer, ntPath.Length);
+
+    for (int i = 0; i < sizeof(paths) / sizeof(paths[0]); i++)
+    {
+        memcpy(addr.sun_path, paths[i], sizeof(paths[i]));
+
+        listener = socket(AF_UNIX, SOCK_STREAM, 0);
+        ok(listener != INVALID_SOCKET, "Could not create Unix socket: %lu\n",
+            GetLastError());
+
+        ret = bind(listener, (SOCKADDR *)&addr, sizeof(SOCKADDR_UN));
+        ok(!ret, "Could not bind Unix socket to path '%s': %lu\n", addr.sun_path, GetLastError());
+
+        ret = listen(listener, 1);
+        ok(!ret, "Could not listen on Unix socket: %lu\n", GetLastError());
+
+        client = socket(AF_UNIX, SOCK_STREAM, 0);
+        ok(client != INVALID_SOCKET, "Failed to create second Unix socket: %lu\n",
+            GetLastError());
+
+        ret = ioctlsocket(client, FIONBIO, &one);
+        ok(!ret, "Could not set AF_UNIX socket to nonblocking: %lu; skipping connection\n", GetLastError());
+        if (!ret)
+        {
+            ret = connect(client, (SOCKADDR *)&addr, sizeof(addr));
+            ok(!ret || (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK),
+                "Error when connecting to Unix socket: %lu\n",
+                GetLastError());
+            server = accept(listener, NULL, NULL);
+            ok(server != INVALID_SOCKET, "Could not accept Unix socket connection: %lu\n",
+                GetLastError());
+            ret = ioctlsocket(client, FIONBIO, &zero);
+            ok(!ret, "Could not set AF_UNIX socket to blocking: %lu\n", GetLastError());
+        }
+
+        memset(&outAddr, 0, sizeof(outAddr));
+        outAddrSize = sizeof(outAddr);
+        ret = getsockname(listener, (SOCKADDR *)&outAddr, &outAddrSize);
+        ok(!ret, "Could not get info on Unix socket: %lu\n", GetLastError());
+        ok(!memcmp(addr.sun_path, outAddr.sun_path, sizeof(addr.sun_path)),
+            "getsockname returned incorrect path '%s' for provided path '%s'\n",
+            outAddr.sun_path,
+            addr.sun_path);
+        ok(outAddrSize == sizeof(outAddr.sun_family) + strlen(outAddr.sun_path) + 1,
+            "getsockname returned incorrect size '%d' for provided path '%s'\n",
+            outAddrSize,
+            addr.sun_path);
+
+        memset(&outAddr, 0, sizeof(outAddr));
+        outAddrSize = sizeof(outAddr);
+        ret = getsockname(client, (SOCKADDR *)&outAddr, &outAddrSize);
+        ok(!ret, "Could not get info on Unix socket: %lu\n", GetLastError());
+        ok(!memcmp((char[108]){0}, outAddr.sun_path, sizeof(addr.sun_path)),
+            "getsockname returned incorrect path '%s' for provided path '%s'\n",
+            outAddr.sun_path,
+            addr.sun_path);
+        ok(outAddrSize == sizeof(outAddr),
+            "getsockname returned incorrect size '%d' for provided path '%s'\n",
+            outAddrSize,
+            addr.sun_path);
+
+        memset(&outAddr, 0, sizeof(outAddr));
+        outAddrSize = sizeof(outAddr);
+        ret = getsockname(server, (SOCKADDR *)&outAddr, &outAddrSize);
+        ok(!ret, "Could not get info on Unix socket: %lu\n", GetLastError());
+        ok(!memcmp(addr.sun_path, outAddr.sun_path, sizeof(addr.sun_path)),
+            "getsockname returned incorrect path '%s' for provided path '%s'\n",
+            outAddr.sun_path,
+            addr.sun_path);
+        ok(outAddrSize == sizeof(outAddr.sun_family) + strlen(outAddr.sun_path) + 1,
+            "getsockname returned incorrect size '%d' for provided path '%s'\n",
+            outAddrSize,
+            addr.sun_path);
+
+        memset(&outAddr, 0, sizeof(outAddr));
+        outAddrSize = sizeof(outAddr);
+        ret = getpeername(listener, (SOCKADDR *)&outAddr, &outAddrSize);
+        ok(ret == -1, "Got info on Unix socket: %lu\n", GetLastError());
+        ok(GetLastError() == WSAENOTCONN,
+            "Incorrect error returned from getpeername on Unix socket: %ld\n",
+            GetLastError());
+        ok(!memcmp((char[108]){0}, outAddr.sun_path, sizeof(addr.sun_path)),
+            "getpeername returned incorrect path '%s' for provided path '%s'\n",
+            outAddr.sun_path,
+            addr.sun_path);
+        ok(outAddrSize == sizeof(outAddr),
+            "getpeername returned incorrect size '%d' for provided path '%s'\n",
+            outAddrSize,
+            addr.sun_path);
+
+        memset(&outAddr, 0, sizeof(outAddr));
+        outAddrSize = sizeof(outAddr);
+        ret = getpeername(client, (SOCKADDR *)&outAddr, &outAddrSize);
+        ok(!ret, "Could not get info on Unix socket: %lu\n", GetLastError());
+        todo_wine ok(!memcmp(addr.sun_path, outAddr.sun_path, sizeof(addr.sun_path)),
+            "getpeername returned incorrect path '%s' for provided path '%s'\n",
+            outAddr.sun_path,
+            addr.sun_path);
+        ok(outAddrSize == sizeof(outAddr),
+            "getpeername returned incorrect size '%d' for provided path '%s'\n",
+            outAddrSize,
+            addr.sun_path);
+
+        memset(&outAddr, 0, sizeof(outAddr));
+        outAddrSize = sizeof(outAddr);
+        ret = getpeername(server, (SOCKADDR *)&outAddr, &outAddrSize);
+        ok(!ret, "Could not get info on Unix socket: %lu\n", GetLastError());
+        ok(!memcmp((char[108]){0}, outAddr.sun_path, sizeof(addr.sun_path)),
+            "getpeername returned incorrect path '%s' for provided path '%s'\n",
+            outAddr.sun_path,
+            addr.sun_path);
+        ok(outAddrSize == sizeof(outAddr),
+            "getpeername returned incorrect size '%d' for provided path '%s'\n",
+            outAddrSize,
+            addr.sun_path);
+
+        closesocket(listener);
+        closesocket(client);
+        closesocket(server);
+
+        ret = DeleteFileA(addr.sun_path);
+        ok(ret, "DeleteFileA on socket file failed: %lu\n", GetLastError());
+        ok(GetFileAttributesA(addr.sun_path) == INVALID_FILE_ATTRIBUTES &&
+            GetLastError() == ERROR_FILE_NOT_FOUND,
+            "Failed to delete socket file at path '%s'\n",
+            addr.sun_path);
+    }
+}
+
 START_TEST( sock )
 {
     int i;
@@ -13984,6 +14275,7 @@ START_TEST( sock )
     test_icmp();
     test_connect_udp();
     test_tcp_sendto_recvfrom();
+    test_afunix();
 
     /* There is apparently an obscure interaction between this test and
      * test_WSAGetOverlappedResult().
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/2786

[PATCH v59 6/6] ws2_32/tests: Add test for AF_UNIX sockets.

[Marvin]

Hi,

It looks like your patch introduced the new failures shown below.
Please investigate and fix them before resubmitting your patch.
If they are not new, fixing them anyway would help a lot. Otherwise
please ask for the known failures list to be updated.

The tests also ran into some preexisting test failures. If you know how
to fix them that would be helpful. See the TestBot job for the details:

The full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=137726

Your paranoid android.


=== w1064_adm (64 bit report) ===

ws2_32:
sock.c:12922: Test failed: wait timed out
sock.c:12938: Test failed: wait timed out
sock.c:12951: Test failed: got size 5
sock.c:12952: Test failed: got "datad"
sock.c:12785: Test failed: got error 996
sock.c:12786: Test failed: got size 0
sock.c:12787: Test failed: got ""
sock.c:12785: Test failed: got error 996
sock.c:12786: Test failed: got size 0
sock.c:12787: Test failed: got ""

=== debian11 (32 bit report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit ar:MA report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit de report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit fr report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit he:IL report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit hi:IN report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit ja:JP report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11 (32 bit zh:CN report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022

=== debian11b (32 bit WoW report) ===

ws2_32:
sock.c:13939: Test failed: Could not bind Unix socket: 10022
sock.c:13941: Test failed: Could not listen on Unix socket: 10022