dlls/netio.sys/netio.c

   1 /*
   2  * WSK (Winsock Kernel) driver library.
   3  *
   4  * Copyright 2020 Paul Gofman <pgofman@codeweavers.com> for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define NONAMELESSUNION
  24 #define NONAMELESSSTRUCT
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winioctl.h"
  30 #include "winternl.h"
  31 #include "ddk/wdm.h"
  32 #include "ddk/wsk.h"
  33 #include "wine/debug.h"
  34 #include "winsock2.h"
  35 #include "ws2tcpip.h"
  36
  37 #include "wine/heap.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(netio);
  40
  41 struct _WSK_CLIENT
  42 {
  43     WSK_REGISTRATION *registration;
  44     WSK_CLIENT_NPI *client_npi;
  45 };
  46
  47 struct listen_socket_callback_context
  48 {
  49     SOCKADDR *local_address;
  50     SOCKADDR *remote_address;
  51     const void *client_dispatch;
  52     void *client_context;
  53     char addr_buffer[2 * (sizeof(SOCKADDR) + 16)];
  54     SOCKET acceptor;
  55 };
  56
  57 #define MAX_PENDING_IO 10
  58
  59 struct wsk_pending_io
  60 {
  61     OVERLAPPED ovr;
  62     TP_WAIT *tp_wait;
  63     void *callback;
  64     IRP *irp;
  65 };
  66
  67 struct wsk_socket_internal
  68 {
  69     WSK_SOCKET wsk_socket;
  70     SOCKET s;
  71     const void *client_dispatch;
  72     void *client_context;
  73     ULONG flags;
  74     ADDRESS_FAMILY address_family;
  75     USHORT socket_type;
  76     ULONG protocol;
  77     BOOL bound;
  78
  79     CRITICAL_SECTION cs_socket;
  80
  81     struct wsk_pending_io pending_io[MAX_PENDING_IO];
  82
  83     union
  84     {
  85         struct listen_socket_callback_context listen_socket_callback_context;
  86     }
  87     callback_context;
  88 };
  89
  90 static LPFN_ACCEPTEX pAcceptEx;
  91 static LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs;
  92 static LPFN_CONNECTEX pConnectEx;
  93
  94 static const WSK_PROVIDER_CONNECTION_DISPATCH wsk_provider_connection_dispatch;
  95
  96 static inline struct wsk_socket_internal *wsk_socket_internal_from_wsk_socket(WSK_SOCKET *wsk_socket)
  97 {
  98     return CONTAINING_RECORD(wsk_socket, struct wsk_socket_internal, wsk_socket);
  99 }
 100
 101 static NTSTATUS sock_error_to_ntstatus(DWORD err)
 102 {
 103     switch (err)
 104     {
 105         case 0:                    return STATUS_SUCCESS;
 106         case WSAEBADF:             return STATUS_INVALID_HANDLE;
 107         case WSAEACCES:            return STATUS_ACCESS_DENIED;
 108         case WSAEFAULT:            return STATUS_NO_MEMORY;
 109         case WSAEINVAL:            return STATUS_INVALID_PARAMETER;
 110         case WSAEMFILE:            return STATUS_TOO_MANY_OPENED_FILES;
 111         case WSAEWOULDBLOCK:       return STATUS_CANT_WAIT;
 112         case WSAEINPROGRESS:       return STATUS_PENDING;
 113         case WSAEALREADY:          return STATUS_NETWORK_BUSY;
 114         case WSAENOTSOCK:          return STATUS_OBJECT_TYPE_MISMATCH;
 115         case WSAEDESTADDRREQ:      return STATUS_INVALID_PARAMETER;
 116         case WSAEMSGSIZE:          return STATUS_BUFFER_OVERFLOW;
 117         case WSAEPROTONOSUPPORT:
 118         case WSAESOCKTNOSUPPORT:
 119         case WSAEPFNOSUPPORT:
 120         case WSAEAFNOSUPPORT:
 121         case WSAEPROTOTYPE:        return STATUS_NOT_SUPPORTED;
 122         case WSAENOPROTOOPT:       return STATUS_INVALID_PARAMETER;
 123         case WSAEOPNOTSUPP:        return STATUS_NOT_IMPLEMENTED;
 124         case WSAEADDRINUSE:        return STATUS_ADDRESS_ALREADY_ASSOCIATED;
 125         case WSAEADDRNOTAVAIL:     return STATUS_INVALID_PARAMETER;
 126         case WSAECONNREFUSED:      return STATUS_CONNECTION_REFUSED;
 127         case WSAESHUTDOWN:         return STATUS_PIPE_DISCONNECTED;
 128         case WSAENOTCONN:          return STATUS_CONNECTION_DISCONNECTED;
 129         case WSAETIMEDOUT:         return STATUS_IO_TIMEOUT;
 130         case WSAENETUNREACH:       return STATUS_NETWORK_UNREACHABLE;
 131         case WSAENETDOWN:          return STATUS_NETWORK_BUSY;
 132         case WSAECONNRESET:        return STATUS_CONNECTION_RESET;
 133         case WSAECONNABORTED:      return STATUS_CONNECTION_ABORTED;
 134         case WSAHOST_NOT_FOUND:    return STATUS_NOT_FOUND;
 135         default:
 136             FIXME("Unmapped error %lu.\n", err);
 137             return STATUS_UNSUCCESSFUL;
 138     }
 139 }
 140
 141 static inline void lock_socket(struct wsk_socket_internal *socket)
 142 {
 143     EnterCriticalSection(&socket->cs_socket);
 144 }
 145
 146 static inline void unlock_socket(struct wsk_socket_internal *socket)
 147 {
 148     LeaveCriticalSection(&socket->cs_socket);
 149 }
 150
 151 static void socket_init(struct wsk_socket_internal *socket)
 152 {
 153     InitializeCriticalSection(&socket->cs_socket);
 154 }
 155
 156 static void dispatch_irp(IRP *irp, NTSTATUS status)
 157 {
 158     irp->IoStatus.u.Status = status;
 159     --irp->CurrentLocation;
 160     --irp->Tail.Overlay.s.u2.CurrentStackLocation;
 161     IoCompleteRequest(irp, IO_NO_INCREMENT);
 162 }
 163
 164 static struct wsk_pending_io *allocate_pending_io(struct wsk_socket_internal *socket,
 165         PTP_WAIT_CALLBACK socket_async_callback, IRP *irp)
 166 {
 167     struct wsk_pending_io *io = socket->pending_io;
 168     unsigned int i, io_index;
 169
 170     io_index = ~0u;
 171     for (i = 0; i < ARRAY_SIZE(socket->pending_io); ++i)
 172     {
 173         if (!io[i].irp)
 174         {
 175             if (io[i].callback == socket_async_callback)
 176             {
 177                 io[i].irp = irp;
 178                 return &io[i];
 179             }
 180
 181             if (io_index == ~0u)
 182                 io_index = i;
 183         }
 184     }
 185
 186     if (io_index == ~0u)
 187     {
 188         FIXME("Pending io requests count exceeds limit.\n");
 189         return NULL;
 190     }
 191
 192     io[io_index].irp = irp;
 193
 194     if (io[io_index].tp_wait)
 195         CloseThreadpoolWait(io[io_index].tp_wait);
 196     else
 197         io[io_index].ovr.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
 198
 199     io[io_index].tp_wait = CreateThreadpoolWait(socket_async_callback, socket, NULL);
 200     io[io_index].callback = socket_async_callback;
 201
 202     return &io[io_index];
 203 }
 204
 205 static struct wsk_pending_io *find_pending_io(struct wsk_socket_internal *socket, TP_WAIT *tp_wait)
 206 {
 207     unsigned int i;
 208
 209     for (i = 0; i < ARRAY_SIZE(socket->pending_io); ++i)
 210     {
 211         if (socket->pending_io[i].tp_wait == tp_wait)
 212             return &socket->pending_io[i];
 213     }
 214
 215     FIXME("Pending io not found for tp_wait %p.\n", tp_wait);
 216     return NULL;
 217 }
 218
 219 static void dispatch_pending_io(struct wsk_pending_io *io, NTSTATUS status, ULONG_PTR information)
 220 {
 221     TRACE("io %p, status %#lx, information %#Ix.\n", io, status, information);
 222
 223     io->irp->IoStatus.Information = information;
 224     dispatch_irp(io->irp, status);
 225     io->irp = NULL;
 226 }
 227
 228 static NTSTATUS WINAPI wsk_control_socket(WSK_SOCKET *socket, WSK_CONTROL_SOCKET_TYPE request_type,
 229         ULONG control_code, ULONG level, SIZE_T input_size, void *input_buffer, SIZE_T output_size,
 230         void *output_buffer, SIZE_T *output_size_returned, IRP *irp)
 231 {
 232     FIXME("socket %p, request_type %u, control_code %#lx, level %lu, input_size %Iu, input_buffer %p, "
 233             "output_size %Iu, output_buffer %p, output_size_returned %p, irp %p stub.\n",
 234             socket, request_type, control_code, level, input_size, input_buffer, output_size,
 235             output_buffer, output_size_returned, irp);
 236
 237     return STATUS_NOT_IMPLEMENTED;
 238 }
 239
 240 static NTSTATUS WINAPI wsk_close_socket(WSK_SOCKET *socket, IRP *irp)
 241 {
 242     struct wsk_socket_internal *s = wsk_socket_internal_from_wsk_socket(socket);
 243     NTSTATUS status;
 244     unsigned int i;
 245
 246     TRACE("socket %p, irp %p.\n", socket, irp);
 247
 248     lock_socket(s);
 249
 250     for (i = 0; i < ARRAY_SIZE(s->pending_io); ++i)
 251     {
 252         struct wsk_pending_io *io = &s->pending_io[i];
 253
 254         if (io->tp_wait)
 255         {
 256             CancelIoEx((HANDLE)s->s, &io->ovr);
 257             SetThreadpoolWait(io->tp_wait, NULL, NULL);
 258             unlock_socket(s);
 259             WaitForThreadpoolWaitCallbacks(io->tp_wait, FALSE);
 260             lock_socket(s);
 261             CloseThreadpoolWait(io->tp_wait);
 262             CloseHandle(io->ovr.hEvent);
 263         }
 264
 265         if (io->irp)
 266             dispatch_pending_io(io, STATUS_CANCELLED, 0);
 267     }
 268
 269     if (s->flags & WSK_FLAG_LISTEN_SOCKET && s->callback_context.listen_socket_callback_context.acceptor)
 270         closesocket(s->callback_context.listen_socket_callback_context.acceptor);
 271
 272     status = closesocket(s->s) ? sock_error_to_ntstatus(WSAGetLastError()) : STATUS_SUCCESS;
 273
 274     unlock_socket(s);
 275     DeleteCriticalSection(&s->cs_socket);
 276     heap_free(socket);
 277
 278     irp->IoStatus.Information = 0;
 279     dispatch_irp(irp, status);
 280
 281     return status ? status : STATUS_PENDING;
 282 }
 283
 284 static NTSTATUS WINAPI wsk_bind(WSK_SOCKET *socket, SOCKADDR *local_address, ULONG flags, IRP *irp)
 285 {
 286     struct wsk_socket_internal *s = wsk_socket_internal_from_wsk_socket(socket);
 287     NTSTATUS status;
 288
 289     TRACE("socket %p, local_address %p, flags %#lx, irp %p.\n",
 290             socket, local_address, flags, irp);
 291
 292     if (!irp)
 293         return STATUS_INVALID_PARAMETER;
 294
 295     if (bind(s->s, local_address, sizeof(*local_address)))
 296         status = sock_error_to_ntstatus(WSAGetLastError());
 297     else if (s->flags & WSK_FLAG_LISTEN_SOCKET && listen(s->s, SOMAXCONN))
 298         status = sock_error_to_ntstatus(WSAGetLastError());
 299     else
 300         status = STATUS_SUCCESS;
 301
 302     if (status == STATUS_SUCCESS)
 303         s->bound = TRUE;
 304
 305     TRACE("status %#lx.\n", status);
 306     irp->IoStatus.Information = 0;
 307     dispatch_irp(irp, status);
 308     return STATUS_PENDING;
 309 }
 310
 311 static void create_accept_socket(struct wsk_socket_internal *socket, struct wsk_pending_io *io)
 312 {
 313     struct listen_socket_callback_context *context
 314             = &socket->callback_context.listen_socket_callback_context;
 315     INT local_address_len, remote_address_len;
 316     SOCKADDR *local_address, *remote_address;
 317     struct wsk_socket_internal *accept_socket;
 318
 319     if (!(accept_socket = heap_alloc_zero(sizeof(*accept_socket))))
 320     {
 321         ERR("No memory.\n");
 322         dispatch_pending_io(io, STATUS_NO_MEMORY, 0);
 323     }
 324     else
 325     {
 326         TRACE("accept_socket %p.\n", accept_socket);
 327         accept_socket->wsk_socket.Dispatch = &wsk_provider_connection_dispatch;
 328         accept_socket->s = context->acceptor;
 329         accept_socket->client_dispatch = context->client_dispatch;
 330         accept_socket->client_context = context->client_context;
 331         accept_socket->socket_type = socket->socket_type;
 332         accept_socket->address_family = socket->address_family;
 333         accept_socket->protocol = socket->protocol;
 334         accept_socket->flags = WSK_FLAG_CONNECTION_SOCKET;
 335         socket_init(accept_socket);
 336
 337         pGetAcceptExSockaddrs(context->addr_buffer, 0, sizeof(SOCKADDR) + 16, sizeof(SOCKADDR) + 16,
 338                 &local_address, &local_address_len, &remote_address, &remote_address_len);
 339
 340         if (context->local_address)
 341             memcpy(context->local_address, local_address,
 342                     min(sizeof(*context->local_address), local_address_len));
 343
 344         if (context->remote_address)
 345             memcpy(context->remote_address, remote_address,
 346                     min(sizeof(*context->remote_address), remote_address_len));
 347
 348         dispatch_pending_io(io, STATUS_SUCCESS, (ULONG_PTR)&accept_socket->wsk_socket);
 349     }
 350 }
 351
 352 static void WINAPI accept_callback(TP_CALLBACK_INSTANCE *instance, void *socket_, TP_WAIT *wait,
 353         TP_WAIT_RESULT wait_result)
 354 {
 355     struct listen_socket_callback_context *context;
 356     struct wsk_socket_internal *socket = socket_;
 357     struct wsk_pending_io *io;
 358     DWORD size;
 359
 360     TRACE("instance %p, socket %p, wait %p, wait_result %#lx.\n", instance, socket, wait, wait_result);
 361
 362     lock_socket(socket);
 363     context = &socket->callback_context.listen_socket_callback_context;
 364     io = find_pending_io(socket, wait);
 365
 366     if (GetOverlappedResult((HANDLE)socket->s, &io->ovr, &size, FALSE))
 367     {
 368         create_accept_socket(socket, io);
 369     }
 370     else
 371     {
 372         closesocket(context->acceptor);
 373         context->acceptor = 0;
 374         dispatch_pending_io(io, io->ovr.Internal, 0);
 375     }
 376     unlock_socket(socket);
 377 }
 378
 379 static BOOL WINAPI init_accept_functions(INIT_ONCE *once, void *param, void **context)
 380 {
 381     GUID get_acceptex_guid = WSAID_GETACCEPTEXSOCKADDRS;
 382     GUID acceptex_guid = WSAID_ACCEPTEX;
 383     SOCKET s = (SOCKET)param;
 384     DWORD size;
 385
 386     if (WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptex_guid, sizeof(acceptex_guid),
 387             &pAcceptEx, sizeof(pAcceptEx), &size, NULL, NULL))
 388     {
 389         ERR("Could not get AcceptEx address, error %u.\n", WSAGetLastError());
 390         return FALSE;
 391     }
 392
 393     if (WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &get_acceptex_guid, sizeof(get_acceptex_guid),
 394             &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &size, NULL, NULL))
 395     {
 396         ERR("Could not get AcceptEx address, error %u.\n", WSAGetLastError());
 397         return FALSE;
 398     }
 399
 400     return TRUE;
 401 }
 402
 403 static NTSTATUS WINAPI wsk_accept(WSK_SOCKET *listen_socket, ULONG flags, void *accept_socket_context,
 404         const WSK_CLIENT_CONNECTION_DISPATCH *accept_socket_dispatch, SOCKADDR *local_address,
 405         SOCKADDR *remote_address, IRP *irp)
 406 {
 407     struct wsk_socket_internal *s = wsk_socket_internal_from_wsk_socket(listen_socket);
 408     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 409     struct listen_socket_callback_context *context;
 410     struct wsk_pending_io *io;
 411     SOCKET acceptor;
 412     DWORD size;
 413     int error;
 414
 415     TRACE("listen_socket %p, flags %#lx, accept_socket_context %p, accept_socket_dispatch %p, "
 416             "local_address %p, remote_address %p, irp %p.\n",
 417             listen_socket, flags, accept_socket_context, accept_socket_dispatch, local_address,
 418             remote_address, irp);
 419
 420     if (!irp)
 421         return STATUS_INVALID_PARAMETER;
 422
 423     if (!InitOnceExecuteOnce(&init_once, init_accept_functions, (void *)s->s, NULL))
 424     {
 425         dispatch_irp(irp, STATUS_UNSUCCESSFUL);
 426         return STATUS_PENDING;
 427     }
 428
 429     lock_socket(s);
 430     if (!(io = allocate_pending_io(s, accept_callback, irp)))
 431     {
 432         irp->IoStatus.Information = 0;
 433         dispatch_irp(irp, STATUS_UNSUCCESSFUL);
 434         unlock_socket(s);
 435         return STATUS_PENDING;
 436     }
 437
 438     context = &s->callback_context.listen_socket_callback_context;
 439     if ((acceptor = WSASocketW(s->address_family, s->socket_type, s->protocol, NULL, 0, WSA_FLAG_OVERLAPPED))
 440             == INVALID_SOCKET)
 441     {
 442         dispatch_pending_io(io, sock_error_to_ntstatus(WSAGetLastError()), 0);
 443         unlock_socket(s);
 444         return STATUS_PENDING;
 445     }
 446
 447     context->local_address = local_address;
 448     context->remote_address = remote_address;
 449     context->client_dispatch = accept_socket_dispatch;
 450     context->client_context = accept_socket_context;
 451     context->acceptor = acceptor;
 452
 453     if (pAcceptEx(s->s, acceptor, context->addr_buffer, 0,
 454             sizeof(SOCKADDR) + 16, sizeof(SOCKADDR) + 16, &size, &io->ovr))
 455     {
 456         create_accept_socket(s, io);
 457     }
 458     else if ((error = WSAGetLastError()) == ERROR_IO_PENDING)
 459     {
 460         SetThreadpoolWait(io->tp_wait, io->ovr.hEvent, NULL);
 461     }
 462     else
 463     {
 464         closesocket(acceptor);
 465         context->acceptor = 0;
 466         dispatch_pending_io(io, sock_error_to_ntstatus(error), 0);
 467     }
 468     unlock_socket(s);
 469
 470     return STATUS_PENDING;
 471 }
 472
 473 static NTSTATUS WINAPI wsk_inspect_complete(WSK_SOCKET *listen_socket, WSK_INSPECT_ID *inspect_id,
 474         WSK_INSPECT_ACTION action, IRP *irp)
 475 {
 476     FIXME("listen_socket %p, inspect_id %p, action %u, irp %p stub.\n",
 477             listen_socket, inspect_id, action, irp);
 478
 479     return STATUS_NOT_IMPLEMENTED;
 480 }
 481
 482 static NTSTATUS WINAPI wsk_get_local_address(WSK_SOCKET *socket, SOCKADDR *local_address, IRP *irp)
 483 {
 484     FIXME("socket %p, local_address %p, irp %p stub.\n", socket, local_address, irp);
 485
 486     return STATUS_NOT_IMPLEMENTED;
 487 }
 488
 489 static const WSK_PROVIDER_LISTEN_DISPATCH wsk_provider_listen_dispatch =
 490 {
 491     {
 492         wsk_control_socket,
 493         wsk_close_socket,
 494     },
 495     wsk_bind,
 496     wsk_accept,
 497     wsk_inspect_complete,
 498     wsk_get_local_address,
 499 };
 500
 501 static void WINAPI connect_callback(TP_CALLBACK_INSTANCE *instance, void *socket_, TP_WAIT *wait,
 502         TP_WAIT_RESULT wait_result)
 503 {
 504     struct wsk_socket_internal *socket = socket_;
 505     struct wsk_pending_io *io;
 506     DWORD size;
 507
 508     TRACE("instance %p, socket %p, wait %p, wait_result %#lx.\n", instance, socket, wait, wait_result);
 509
 510     lock_socket(socket);
 511     io = find_pending_io(socket, wait);
 512
 513     GetOverlappedResult((HANDLE)socket->s, &io->ovr, &size, FALSE);
 514     dispatch_pending_io(io, io->ovr.Internal, 0);
 515     unlock_socket(socket);
 516 }
 517
 518 static BOOL WINAPI init_connect_functions(INIT_ONCE *once, void *param, void **context)
 519 {
 520     GUID connectex_guid = WSAID_CONNECTEX;
 521     SOCKET s = (SOCKET)param;
 522     DWORD size;
 523
 524     if (WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid),
 525             &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL))
 526     {
 527         ERR("Could not get AcceptEx address, error %u.\n", WSAGetLastError());
 528         return FALSE;
 529     }
 530     return TRUE;
 531 }
 532
 533 static NTSTATUS WINAPI wsk_connect(WSK_SOCKET *socket, SOCKADDR *remote_address, ULONG flags, IRP *irp)
 534 {
 535     struct wsk_socket_internal *s = wsk_socket_internal_from_wsk_socket(socket);
 536     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 537     struct wsk_pending_io *io;
 538     int error;
 539
 540     TRACE("socket %p, remote_address %p, flags %#lx, irp %p.\n",
 541             socket, remote_address, flags, irp);
 542
 543     if (!irp)
 544         return STATUS_INVALID_PARAMETER;
 545
 546     if (!InitOnceExecuteOnce(&init_once, init_connect_functions, (void *)s->s, NULL))
 547     {
 548         dispatch_irp(irp, STATUS_UNSUCCESSFUL);
 549         return STATUS_PENDING;
 550     }
 551
 552     lock_socket(s);
 553
 554     if (!(io = allocate_pending_io(s, connect_callback, irp)))
 555     {
 556         irp->IoStatus.Information = 0;
 557         dispatch_irp(irp, STATUS_UNSUCCESSFUL);
 558         unlock_socket(s);
 559         return STATUS_PENDING;
 560     }
 561
 562     if (!s->bound)
 563     {
 564         dispatch_pending_io(io, STATUS_INVALID_DEVICE_STATE, 0);
 565         unlock_socket(s);
 566         return STATUS_INVALID_DEVICE_STATE;
 567     }
 568
 569     if (pConnectEx(s->s, remote_address, sizeof(*remote_address), NULL, 0, NULL, &io->ovr))
 570         dispatch_pending_io(io, STATUS_SUCCESS, 0);
 571     else if ((error = WSAGetLastError()) == ERROR_IO_PENDING)
 572         SetThreadpoolWait(io->tp_wait, io->ovr.hEvent, NULL);
 573     else
 574         dispatch_pending_io(io, sock_error_to_ntstatus(error), 0);
 575
 576     unlock_socket(s);
 577
 578     return STATUS_PENDING;
 579 }
 580
 581 static NTSTATUS WINAPI wsk_get_remote_address(WSK_SOCKET *socket, SOCKADDR *remote_address, IRP *irp)
 582 {
 583     FIXME("socket %p, remote_address %p, irp %p stub.\n", socket, remote_address, irp);
 584
 585     return STATUS_NOT_IMPLEMENTED;
 586 }
 587
 588 static void WINAPI send_receive_callback(TP_CALLBACK_INSTANCE *instance, void *socket_, TP_WAIT *wait,
 589         TP_WAIT_RESULT wait_result)
 590 {
 591     struct wsk_socket_internal *socket = socket_;
 592     struct wsk_pending_io *io;
 593     DWORD length, flags;
 594
 595     TRACE("instance %p, socket %p, wait %p, wait_result %#lx.\n", instance, socket, wait, wait_result);
 596
 597     lock_socket(socket);
 598     io = find_pending_io(socket, wait);
 599
 600     if (WSAGetOverlappedResult(socket->s, &io->ovr, &length, FALSE, &flags))
 601         dispatch_pending_io(io, STATUS_SUCCESS, length);
 602     else
 603         dispatch_pending_io(io, io->ovr.Internal, 0);
 604
 605     unlock_socket(socket);
 606 }
 607
 608 static NTSTATUS do_send_receive(WSK_SOCKET *socket, WSK_BUF *wsk_buf, ULONG flags, IRP *irp, BOOL is_send)
 609 {
 610     struct wsk_socket_internal *s = wsk_socket_internal_from_wsk_socket(socket);
 611     struct wsk_pending_io *io;
 612     DWORD wsa_flags;
 613     WSABUF wsa_buf;
 614     DWORD length;
 615     int error;
 616
 617     TRACE("socket %p, buffer %p, flags %#lx, irp %p, is_send %#x.\n",
 618             socket, wsk_buf, flags, irp, is_send);
 619
 620     if (!irp)
 621         return STATUS_INVALID_PARAMETER;
 622
 623     if (!wsk_buf->Mdl && wsk_buf->Length)
 624         return STATUS_INVALID_PARAMETER;
 625
 626     if (wsk_buf->Mdl && wsk_buf->Mdl->Next)
 627     {
 628         FIXME("Chained MDLs are not supported.\n");
 629         irp->IoStatus.Information = 0;
 630         dispatch_irp(irp, STATUS_UNSUCCESSFUL);
 631         return STATUS_PENDING;
 632     }
 633
 634     if (flags)
 635         FIXME("flags %#lx not implemented.\n", flags);
 636
 637     lock_socket(s);
 638     if (!(io = allocate_pending_io(s, send_receive_callback, irp)))
 639     {
 640         irp->IoStatus.Information = 0;
 641         dispatch_irp(irp, STATUS_UNSUCCESSFUL);
 642         unlock_socket(s);
 643         return STATUS_PENDING;
 644     }
 645
 646     wsa_buf.len = wsk_buf->Length;
 647     wsa_buf.buf = wsk_buf->Mdl ? (CHAR *)wsk_buf->Mdl->StartVa
 648             + wsk_buf->Mdl->ByteOffset + wsk_buf->Offset : NULL;
 649
 650     wsa_flags = 0;
 651
 652     if (!(is_send ? WSASend(s->s, &wsa_buf, 1, &length, wsa_flags, &io->ovr, NULL)
 653             : WSARecv(s->s, &wsa_buf, 1, &length, &wsa_flags, &io->ovr, NULL)))
 654     {
 655         dispatch_pending_io(io, STATUS_SUCCESS, length);
 656     }
 657     else if ((error = WSAGetLastError()) == WSA_IO_PENDING)
 658     {
 659         SetThreadpoolWait(io->tp_wait, io->ovr.hEvent, NULL);
 660     }
 661     else
 662     {
 663         dispatch_pending_io(io, sock_error_to_ntstatus(error), 0);
 664     }
 665     unlock_socket(s);
 666
 667     return STATUS_PENDING;
 668 }
 669
 670 static NTSTATUS WINAPI wsk_send(WSK_SOCKET *socket, WSK_BUF *buffer, ULONG flags, IRP *irp)
 671 {
 672     TRACE("socket %p, buffer %p, flags %#lx, irp %p.\n", socket, buffer, flags, irp);
 673
 674     return do_send_receive(socket, buffer, flags, irp, TRUE);
 675 }
 676
 677 static NTSTATUS WINAPI wsk_receive(WSK_SOCKET *socket, WSK_BUF *buffer, ULONG flags, IRP *irp)
 678 {
 679     TRACE("socket %p, buffer %p, flags %#lx, irp %p.\n", socket, buffer, flags, irp);
 680
 681     return do_send_receive(socket, buffer, flags, irp, FALSE);
 682 }
 683
 684 static NTSTATUS WINAPI wsk_disconnect(WSK_SOCKET *socket, WSK_BUF *buffer, ULONG flags, IRP *irp)
 685 {
 686     FIXME("socket %p, buffer %p, flags %#lx, irp %p stub.\n", socket, buffer, flags, irp);
 687
 688     return STATUS_NOT_IMPLEMENTED;
 689 }
 690
 691 static NTSTATUS WINAPI wsk_release(WSK_SOCKET *socket, WSK_DATA_INDICATION *data_indication)
 692 {
 693     FIXME("socket %p, data_indication %p stub.\n", socket, data_indication);
 694
 695     return STATUS_NOT_IMPLEMENTED;
 696 }
 697
 698 static NTSTATUS WINAPI wsk_connext_ex(WSK_SOCKET *socket, SOCKADDR *remote_address, WSK_BUF *buffer,
 699         ULONG flags, IRP *irp)
 700 {
 701     FIXME("socket %p, remote_address %p, buffer %p, flags %#lx, irp %p stub.\n",
 702             socket, remote_address, buffer, flags, irp);
 703
 704     return STATUS_NOT_IMPLEMENTED;
 705 }
 706
 707 static NTSTATUS WINAPI wsk_send_ex(void)
 708 {
 709     FIXME("stub (no prototype, will crash).\n");
 710
 711     return STATUS_NOT_IMPLEMENTED;
 712 }
 713
 714 static NTSTATUS WINAPI wsk_receive_ex(void)
 715 {
 716     FIXME("stub (no prototype, will crash).\n");
 717
 718     return STATUS_NOT_IMPLEMENTED;
 719 }
 720
 721 static const WSK_PROVIDER_CONNECTION_DISPATCH wsk_provider_connection_dispatch =
 722 {
 723     {
 724         wsk_control_socket,
 725         wsk_close_socket,
 726     },
 727     wsk_bind,
 728     wsk_connect,
 729     wsk_get_local_address,
 730     wsk_get_remote_address,
 731     wsk_send,
 732     wsk_receive,
 733     wsk_disconnect,
 734     wsk_release,
 735     wsk_connext_ex,
 736     wsk_send_ex,
 737     wsk_receive_ex,
 738 };
 739
 740 static NTSTATUS WINAPI wsk_socket(WSK_CLIENT *client, ADDRESS_FAMILY address_family, USHORT socket_type,
 741         ULONG protocol, ULONG flags, void *socket_context, const void *dispatch, PEPROCESS owning_process,
 742         PETHREAD owning_thread, SECURITY_DESCRIPTOR *security_descriptor, IRP *irp)
 743 {
 744     struct wsk_socket_internal *socket;
 745     NTSTATUS status;
 746     SOCKET s;
 747
 748     TRACE("client %p, address_family %#x, socket_type %#x, protocol %#lx, flags %#lx, socket_context %p, dispatch %p, "
 749             "owning_process %p, owning_thread %p, security_descriptor %p, irp %p.\n",
 750             client, address_family, socket_type, protocol, flags, socket_context, dispatch, owning_process,
 751             owning_thread, security_descriptor, irp);
 752
 753     if (!irp)
 754         return STATUS_INVALID_PARAMETER;
 755
 756     if (!client)
 757         return STATUS_INVALID_HANDLE;
 758
 759     irp->IoStatus.Information = 0;
 760
 761     if ((s = WSASocketW(address_family, socket_type, protocol, NULL, 0, WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)
 762     {
 763         status = sock_error_to_ntstatus(WSAGetLastError());
 764         goto done;
 765     }
 766
 767     if (!(socket = heap_alloc_zero(sizeof(*socket))))
 768     {
 769         status = STATUS_NO_MEMORY;
 770         closesocket(s);
 771         goto done;
 772     }
 773
 774     socket->s = s;
 775     socket->client_dispatch = dispatch;
 776     socket->client_context = socket_context;
 777     socket->socket_type = socket_type;
 778     socket->flags = flags;
 779     socket->address_family = address_family;
 780     socket->protocol = protocol;
 781
 782     switch (flags)
 783     {
 784         case WSK_FLAG_LISTEN_SOCKET:
 785             socket->wsk_socket.Dispatch = &wsk_provider_listen_dispatch;
 786             break;
 787
 788         case WSK_FLAG_CONNECTION_SOCKET:
 789             socket->wsk_socket.Dispatch = &wsk_provider_connection_dispatch;
 790             break;
 791
 792         default:
 793             FIXME("Flags %#lx not implemented.\n", flags);
 794             closesocket(s);
 795             heap_free(socket);
 796             status = STATUS_NOT_IMPLEMENTED;
 797             goto done;
 798     }
 799
 800     socket_init(socket);
 801
 802     irp->IoStatus.Information = (ULONG_PTR)&socket->wsk_socket;
 803     status = STATUS_SUCCESS;
 804
 805 done:
 806     dispatch_irp(irp, status);
 807     return status ? status : STATUS_PENDING;
 808 }
 809
 810 static NTSTATUS WINAPI wsk_socket_connect(WSK_CLIENT *client, USHORT socket_type, ULONG protocol,
 811         SOCKADDR *local_address, SOCKADDR *remote_address, ULONG flags, void *socket_context,
 812         const WSK_CLIENT_CONNECTION_DISPATCH *dispatch, PEPROCESS owning_process, PETHREAD owning_thread,
 813         SECURITY_DESCRIPTOR *security_descriptor, IRP *irp)
 814 {
 815     FIXME("client %p, socket_type %#x, protocol %#lx, local_address %p, remote_address %p, "
 816             "flags %#lx, socket_context %p, dispatch %p, owning_process %p, owning_thread %p, "
 817             "security_descriptor %p, irp %p stub.\n",
 818             client, socket_type, protocol, local_address, remote_address, flags, socket_context,
 819             dispatch, owning_process, owning_thread, security_descriptor, irp);
 820
 821     return STATUS_NOT_IMPLEMENTED;
 822 }
 823
 824 static NTSTATUS WINAPI wsk_control_client(WSK_CLIENT *client, ULONG control_code, SIZE_T input_size,
 825         void *input_buffer, SIZE_T output_size, void *output_buffer, SIZE_T *output_size_returned,
 826         IRP *irp
 827 )
 828 {
 829     FIXME("client %p, control_code %#lx, input_size %Iu, input_buffer %p, output_size %Iu, "
 830             "output_buffer %p, output_size_returned %p, irp %p, stub.\n",
 831             client, control_code, input_size, input_buffer, output_size, output_buffer,
 832             output_size_returned, irp);
 833
 834     return STATUS_NOT_IMPLEMENTED;
 835 }
 836
 837 struct wsk_get_address_info_context
 838 {
 839     UNICODE_STRING *node_name;
 840     UNICODE_STRING *service_name;
 841     ULONG namespace;
 842     GUID *provider;
 843     ADDRINFOEXW *hints;
 844     ADDRINFOEXW **result;
 845     IRP *irp;
 846 };
 847
 848 static void WINAPI get_address_info_callback(TP_CALLBACK_INSTANCE *instance, void *context_)
 849 {
 850     struct wsk_get_address_info_context *context = context_;
 851     INT ret;
 852
 853     TRACE("instance %p, context %p.\n", instance, context);
 854
 855     ret = GetAddrInfoExW( context->node_name ? context->node_name->Buffer : NULL,
 856             context->service_name ? context->service_name->Buffer : NULL, context->namespace,
 857             context->provider, context->hints, context->result, NULL, NULL, NULL, NULL);
 858
 859     context->irp->IoStatus.Information = 0;
 860     dispatch_irp(context->irp, sock_error_to_ntstatus(ret));
 861     heap_free(context);
 862 }
 863
 864 static NTSTATUS WINAPI wsk_get_address_info(WSK_CLIENT *client, UNICODE_STRING *node_name,
 865         UNICODE_STRING *service_name, ULONG name_space, GUID *provider, ADDRINFOEXW *hints,
 866         ADDRINFOEXW **result, PEPROCESS owning_process, PETHREAD owning_thread, IRP *irp)
 867 {
 868     struct wsk_get_address_info_context *context;
 869     NTSTATUS status;
 870
 871     TRACE("client %p, node_name %p, service_name %p, name_space %#lx, provider %p, hints %p, "
 872             "result %p, owning_process %p, owning_thread %p, irp %p.\n",
 873             client, node_name, service_name, name_space, provider, hints, result,
 874             owning_process, owning_thread, irp);
 875
 876     if (!irp)
 877         return STATUS_INVALID_PARAMETER;
 878
 879     if (!(context = heap_alloc(sizeof(*context))))
 880     {
 881         ERR("No memory.\n");
 882         status = STATUS_NO_MEMORY;
 883         dispatch_irp(irp, status);
 884         return status;
 885     }
 886
 887     context->node_name = node_name;
 888     context->service_name = service_name;
 889     context->namespace = name_space;
 890     context->provider = provider;
 891     context->hints = hints;
 892     context->result = result;
 893     context->irp = irp;
 894
 895     if (!TrySubmitThreadpoolCallback(get_address_info_callback, context, NULL))
 896     {
 897         ERR("Could not submit thread pool callback.\n");
 898         status = STATUS_UNSUCCESSFUL;
 899         dispatch_irp(irp, status);
 900         heap_free(context);
 901         return status;
 902     }
 903     TRACE("Submitted threadpool callback, context %p.\n", context);
 904     return STATUS_PENDING;
 905 }
 906
 907 static void WINAPI wsk_free_address_info(WSK_CLIENT *client, ADDRINFOEXW *addr_info)
 908 {
 909     TRACE("client %p, addr_info %p.\n", client, addr_info);
 910
 911     FreeAddrInfoExW(addr_info);
 912 }
 913
 914 static NTSTATUS WINAPI wsk_get_name_info(WSK_CLIENT *client, SOCKADDR *sock_addr, ULONG sock_addr_length,
 915         UNICODE_STRING *node_name, UNICODE_STRING *service_name, ULONG flags, PEPROCESS owning_process,
 916         PETHREAD owning_thread, IRP *irp)
 917 {
 918     FIXME("client %p, sock_addr %p, sock_addr_length %lu, node_name %p, service_name %p, "
 919             "flags %#lx, owning_process %p, owning_thread %p, irp %p stub.\n",
 920             client, sock_addr, sock_addr_length, node_name, service_name, flags,
 921             owning_process, owning_thread, irp);
 922
 923     return STATUS_NOT_IMPLEMENTED;
 924 }
 925
 926 static const WSK_PROVIDER_DISPATCH wsk_dispatch =
 927 {
 928     MAKE_WSK_VERSION(1, 0), 0,
 929     wsk_socket,
 930     wsk_socket_connect,
 931     wsk_control_client,
 932     wsk_get_address_info,
 933     wsk_free_address_info,
 934     wsk_get_name_info,
 935 };
 936
 937 NTSTATUS WINAPI WskCaptureProviderNPI(WSK_REGISTRATION *wsk_registration, ULONG wait_timeout,
 938         WSK_PROVIDER_NPI *wsk_provider_npi)
 939 {
 940     WSK_CLIENT *client = wsk_registration->ReservedRegistrationContext;
 941
 942     TRACE("wsk_registration %p, wait_timeout %lu, wsk_provider_npi %p.\n",
 943             wsk_registration, wait_timeout, wsk_provider_npi);
 944
 945     wsk_provider_npi->Client = client;
 946     wsk_provider_npi->Dispatch = &wsk_dispatch;
 947     return STATUS_SUCCESS;
 948 }
 949
 950 void WINAPI WskReleaseProviderNPI(WSK_REGISTRATION *wsk_registration)
 951 {
 952     TRACE("wsk_registration %p.\n", wsk_registration);
 953
 954 }
 955
 956 NTSTATUS WINAPI WskRegister(WSK_CLIENT_NPI *wsk_client_npi, WSK_REGISTRATION *wsk_registration)
 957 {
 958     static const WORD version = MAKEWORD( 2, 2 );
 959     WSADATA data;
 960
 961     WSK_CLIENT *client;
 962
 963     TRACE("wsk_client_npi %p, wsk_registration %p.\n", wsk_client_npi, wsk_registration);
 964
 965     if (!(client = heap_alloc(sizeof(*client))))
 966     {
 967         ERR("No memory.\n");
 968         return STATUS_NO_MEMORY;
 969     }
 970
 971     client->registration = wsk_registration;
 972     client->client_npi = wsk_client_npi;
 973     wsk_registration->ReservedRegistrationContext = client;
 974
 975     if (WSAStartup(version, &data))
 976         return STATUS_INTERNAL_ERROR;
 977
 978     return STATUS_SUCCESS;
 979 }
 980
 981 void WINAPI WskDeregister(WSK_REGISTRATION *wsk_registration)
 982 {
 983     TRACE("wsk_registration %p.\n", wsk_registration);
 984
 985     heap_free(wsk_registration->ReservedRegistrationContext);
 986 }
 987
 988 static void WINAPI driver_unload(DRIVER_OBJECT *driver)
 989 {
 990     TRACE("driver %p.\n", driver);
 991 }
 992
 993 NTSTATUS WINAPI DriverEntry(DRIVER_OBJECT *driver, UNICODE_STRING *path)
 994 {
 995     TRACE("driver %p, path %s.\n", driver, debugstr_w(path->Buffer));
 996
 997     driver->DriverUnload = driver_unload;
 998     return STATUS_SUCCESS;
 999 }