[PATCH v9 3/6] ws2_32: Add support for AF_UNIX sockets.

[Ally Sommers]

From: Ally Sommers

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/ws2_32/socket.c         | 68 +++++++++++++++++++++++++++++++---
 dlls/ws2_32/ws2_32_private.h | 14 +++++++
 server/sock.c                | 72 +++++++++++++++++++++++++++++++++++-
 3 files changed, 148 insertions(+), 6 deletions(-)

diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c
index 5eb926a408b..471d6b910ee 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 = sizeof(struct sockaddr_un) - sizeof((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,9 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
     HANDLE sync_event;
     NTSTATUS status;

+    char *unix_path = NULL;
+    int unix_path_len = 0;
+
     TRACE( "socket %#Ix, addr %s\n", s, debugstr_sockaddr(addr) );

if (!addr)
@@ -1148,6 +1169,14 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
             }
             break;

+        case AF_UNIX:
+            if (len < sizeof(struct sockaddr_un))
+            {
+                SetLastError( WSAEFAULT );
+                return -1;
+            }
+            break;
+
         default:
             FIXME( "unknown protocol %u\n", addr->sa_family );
             SetLastError( WSAEAFNOSUPPORT );
@@ -1156,8 +1185,18 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )

if (!(sync_event = get_sync_event())) return -1;

-    params = malloc( sizeof(int) + len );
-    ret_addr = malloc( 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;
+    }
+
+    params = malloc( sizeof(int) + len + unix_path_len );
+    ret_addr = malloc( len + unix_path_len );
     if (!params || !ret_addr)
     {
         free( params );
@@ -1167,9 +1206,11 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )
     }
     params->unknown = 0;
     memcpy( &params->addr, addr, len );
+    if (unix_path)
+        memcpy( (char *)&params->addr + 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_path_len, ret_addr, len + unix_path_len );
     if (status == STATUS_PENDING)
     {
         if (WaitForSingleObject( sync_event, INFINITE ) == WAIT_FAILED)
@@ -1182,6 +1223,8 @@ int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len )

free( params );
     free( ret_addr );
+    if (unix_path)
+        free( unix_path );

SetLastError( NtStatusToWSAError( status ) );
     return status ? -1 : 0;
@@ -1222,11 +1265,24 @@ 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;
+
     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;
+    }
+
+    if (!(params = malloc( sizeof(*params) + len + unix_path_len )))
     {
         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
         return -1;
@@ -1234,9 +1290,11 @@ 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, 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_path_len, NULL, 0 );
     free( params );
     if (status == STATUS_PENDING)
     {
diff --git a/dlls/ws2_32/ws2_32_private.h b/dlls/ws2_32/ws2_32_private.h
index 41d9e512488..8e5da235801 100644
--- a/dlls/ws2_32/ws2_32_private.h
+++ b/dlls/ws2_32/ws2_32_private.h
@@ -46,6 +46,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"
@@ -73,6 +74,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 088e6d63079..35cc755840e 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
@@ -83,6 +84,8 @@
 # define HAS_IRDA
 #endif

+#include <sys/un.h>
+
 #include "ntstatus.h"
 #define WIN32_NO_STATUS
 #include "windef.h"
@@ -93,6 +96,7 @@
 #include "ws2tcpip.h"
 #include "wsipx.h"
 #include "af_irda.h"
+#include "afunix.h"
 #include "wine/afd.h"
 #include "wine/rbtree.h"

@@ -116,6 +120,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
@@ -129,6 +134,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 );
@@ -546,6 +552,17 @@ static int sockaddr_from_unix( const union unix_sockaddr *uaddr, struct WS_socka
     }
 #endif

+    case AF_UNIX:
+    {
+        struct WS_sockaddr_un win = {0};
+
+        if (wsaddrlen < sizeof(win)) return -1;
+        win.sun_family = WS_AF_UNIX;
+        memcpy( win.sun_path, uaddr->un.sun_path, sizeof(win.sun_path) );
+        memcpy( wsaddr, &win, sizeof(win) );
+        return sizeof(win);
+    }
+
     case AF_UNSPEC:
         return 0;

@@ -646,6 +663,17 @@ static socklen_t sockaddr_to_unix( const struct WS_sockaddr *wsaddr, int wsaddrl
             return sizeof(uaddr->in6);
         }

+    case WS_AF_UNIX:
+    {
+        struct WS_sockaddr_un win = {0};
+
+        if (wsaddrlen < sizeof(win.sun_family) + strlen( wsaddr->sa_data ) + 1) return 0;
+        memcpy( &win, wsaddr, sizeof(win) );
+        uaddr->un.sun_family = AF_UNIX;
+        memcpy( uaddr->un.sun_path, win.sun_path, sizeof(win.sun_path) );
+        return sizeof(uaddr->un);
+    }
+
     default:
         return 0;
     }
@@ -672,6 +700,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;
     }
@@ -1757,6 +1788,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;
     }
@@ -2607,6 +2639,19 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
         if (unix_addr.addr.sa_family == AF_INET && !memcmp( &unix_addr.in.sin_addr, magic_loopback_addr, 4 ))
             unix_addr.in.sin_addr.s_addr = htonl( INADDR_LOOPBACK );

+        if (sock->family == WS_AF_UNIX && *((char *)(params + 1) + params->addr_len))
+        {
+            char *unix_path = (char *)(params + 1) + params->addr_len;
+            char unix_path_copy[PATH_MAX];
+            strcpy(unix_path_copy, unix_path);
+            if (chdir( dirname( unix_path_copy ) ) == -1)
+            {
+                set_error( sock_get_ntstatus( errno ) );
+                return;
+            }
+            memcpy( unix_addr.un.sun_path, basename( unix_path ), sizeof(unix_addr.un.sun_path) );
+        }
+
         ret = connect( unix_fd, &unix_addr.addr, unix_len );
         if (ret < 0 && errno == ECONNABORTED)
         {
@@ -2619,6 +2664,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 && *(char *)(params + 1))
+            fchdir(server_dir_fd);
+
         if (ret < 0 && errno != EINPROGRESS)
         {
             set_error( sock_get_ntstatus( errno ) );
@@ -2878,7 +2926,7 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
     case IOCTL_AFD_BIND:
     {
         const struct afd_bind_params *params = get_req_data();
-        union unix_sockaddr unix_addr, bind_addr;
+        union unix_sockaddr unix_addr, bind_addr, win_addr;
         data_size_t in_size;
         socklen_t unix_len;
         int v6only = 1;
@@ -2943,12 +2991,29 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
         if (check_addr_usage( sock, &bind_addr, v6only ))
             return;

+        if (sock->family == WS_AF_UNIX && *params->addr.sa_data)
+        {
+            char *unix_path = (char *)&params->addr + sizeof(unix_addr.un);
+            char unix_path_copy[PATH_MAX];
+            strcpy(unix_path_copy, unix_path);
+            if (chdir( dirname( unix_path_copy ) ) == -1)
+            {
+                set_error( sock_get_ntstatus( errno ) );
+                return;
+            }
+
+            win_addr = bind_addr;
+            memcpy( bind_addr.un.sun_path, basename( unix_path ), sizeof(bind_addr.un.sun_path) );
+        }
+
         if (bind( unix_fd, &bind_addr.addr, unix_len ) < 0)
         {
             if (errno == EADDRINUSE && sock->reuseaddr)
                 errno = EACCES;

set_error( sock_get_ntstatus( errno ) );
+            if (sock->family == WS_AF_UNIX && *(char *)(params + 1))
+                fchdir(server_dir_fd);
             return;
         }

@@ -2961,6 +3026,8 @@ 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;
+            if (bind_addr.addr.sa_family == AF_UNIX)
+                bind_addr = win_addr;
             sock->addr_len = sockaddr_from_unix( &bind_addr, &sock->addr.addr, sizeof(sock->addr) );
         }

@@ -2968,6 +3035,9 @@ static void sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )

if (get_reply_max_size() >= sock->addr_len)
             set_reply_data( &sock->addr, sock->addr_len );
+
+        if (sock->family == WS_AF_UNIX && *(char *)(params + 1))
+            fchdir(server_dir_fd);
         return;
     }