#include <msafd.h>#include <winuser.h>#include <wchar.h>
Include dependency graph for dllmain.c:
Go to the source code of this file.
Function Documentation
◆ CreateContext()
| int CreateContext | ( | PSOCKET_INFORMATION | Socket | ) |
Definition at line 3983 of file dllmain.c.
3984{
3985 IO_STATUS_BLOCK IOSB;
3986 SOCKET_CONTEXT ContextData;
3989
3991 EVENT_ALL_ACCESS,
3992 NULL,
3993 SynchronizationEvent,
3994 FALSE);
3995
3998
3999 /* Create Context */
4001 ContextData.SizeOfHelperData = 0;
4003 Socket->LocalAddress,
4006 Socket->RemoteAddress,
4008
4009 /* Send IOCTL */
4011 SockEvent,
4012 NULL,
4013 NULL,
4014 &IOSB,
4015 IOCTL_AFD_SET_CONTEXT,
4016 &ContextData,
4017 sizeof(ContextData),
4018 NULL,
4019 0);
4020
4021 /* Wait for Completion */
4023 {
4026 }
4027
4029
4031}
HANDLE SockEvent
Definition: nsiface.idl:2307
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:96
Definition: env_spec_w32.h:870
Definition: msafd.h:67
Referenced by WSPSocket().
◆ DllMain()
Definition at line 4483 of file dllmain.c.
4486{
4487
4489 {
4491
4493
4494 /* Don't need thread attach notifications
4495 so disable them to improve performance */
4496 DisableThreadLibraryCalls(hInstDll);
4497
4498 /* List of DLL Helpers */
4500
4501 /* Heap to use when allocating */
4503
4504 /* Initialize the lock that protects our socket list */
4506
4508
4509 break;
4510
4512 break;
4513
4515 break;
4516
4518
4519 /* Delete the socket list lock */
4521
4522 break;
4523 }
4524
4526
4528}
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:687
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
◆ GetCurrentTimeInSeconds()
Definition at line 1434 of file dllmain.c.
1435{
1436 SYSTEMTIME st1970 = { 1970, 1, 0, 1, 0, 0, 0, 0 };
1437 union
1438 {
1439 FILETIME ft;
1441 } u1970, Time;
1442
1444 SystemTimeToFileTime(&st1970, &u1970.ft);
1446}
VOID WINAPI GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
Definition: time.c:128
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:153
Definition: mapidefs.h:60
Definition: minwinbase.h:255
Referenced by MsafdConnectAPC(), WSPAccept(), WSPConnect(), and WSPGetSockOpt().
◆ GetSocketInformation()
| int GetSocketInformation | ( | PSOCKET_INFORMATION | Socket, |
| ULONG | AfdInformationClass, | ||
| PBOOLEAN Boolean | OPTIONAL, | ||
| PULONG Ulong | OPTIONAL, | ||
| PLARGE_INTEGER LargeInteger | OPTIONAL, | ||
| LPWSAOVERLAPPED Overlapped | OPTIONAL, | ||
| LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine | OPTIONAL | ||
| ) |
Definition at line 3712 of file dllmain.c.
3719{
3720 PIO_STATUS_BLOCK IOSB;
3721 IO_STATUS_BLOCK DummyIOSB;
3722 PAFD_INFO InfoData;
3724 PMSAFD_INFO_APC_CONTEXT APCContext;
3725 PIO_APC_ROUTINE APCFunction;
3728
3730 if (!InfoData)
3732
3734 EVENT_ALL_ACCESS,
3735 NULL,
3736 SynchronizationEvent,
3737 FALSE);
3739 {
3742 }
3743
3744 /* Set Info Class */
3745 InfoData->InformationClass = AfdInformationClass;
3746
3747 /* Verify if we should use APC */
3748 if (!Overlapped)
3749 {
3750 /* Not using Overlapped structure, so use normal blocking on event */
3751 APCContext = NULL;
3752 APCFunction = NULL;
3754 IOSB = &DummyIOSB;
3755 }
3756 else
3757 {
3758 /* Overlapped request for non overlapped opened socket */
3760 {
3765 }
3766
3768 if (!APCContext)
3769 {
3774 }
3776 APCContext->lpOverlapped = Overlapped;
3777 APCContext->lpInfoData = InfoData;
3778 APCFunction = &MsafdInfoAPC;
3779
3781 Event = Overlapped->hEvent;
3782
3783 IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
3784 }
3785
3787
3788 /* Send IOCTL */
3790 Event,
3791 APCFunction,
3792 APCContext,
3793 IOSB,
3794 IOCTL_AFD_GET_INFO,
3795 InfoData,
3796 sizeof(*InfoData),
3797 InfoData,
3798 sizeof(*InfoData));
3799
3800 /* Wait for completion if not overlapped */
3802 {
3805 }
3806
3808
3810 {
3811 /* Return Information */
3813 {
3815 }
3817 {
3819 }
3821 {
3823 }
3824 }
3825
3827 if (!APCFunction)
3828 {
3829 /* When using APC, this will be freed by the APC function */
3831 }
3832
3834}
static VOID NTAPI MsafdInfoAPC(_In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved)
Definition: dllmain.c:3693
FORCEINLINE DWORD MsafdReturnWithErrno(_In_ NTSTATUS Status, _Out_opt_ LPINT Errno, _In_ DWORD Received, _Out_opt_ LPDWORD ReturnedBytes)
Definition: msafd.h:515
VOID(* PIO_APC_ROUTINE)(IN PVOID ApcContext, IN PIO_STATUS_BLOCK IoStatusBlock, IN ULONG Reserved)
Definition: nt_native.h:880
Definition: shared.h:28
union _AFD_INFO::@4118 Information
Definition: msafd.h:84
LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
Definition: msafd.h:86
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine
Definition: wdfrequest.h:895
Referenced by WSPCloseSocket(), WSPIoctl(), WSPSetSockOpt(), and WSPSocket().
◆ GetSocketStructure()
| PSOCKET_INFORMATION GetSocketStructure | ( | SOCKET | Handle | ) |
Definition at line 3960 of file dllmain.c.
3961{
3962 PSOCKET_INFORMATION CurrentSocket;
3963
3965
3966 CurrentSocket = SocketListHead;
3967 while (CurrentSocket)
3968 {
3970 {
3972 return CurrentSocket;
3973 }
3974
3975 CurrentSocket = CurrentSocket->NextSocket;
3976 }
3977
3979
3981}
Definition: msafd.h:45
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
Referenced by MsafdConnectAPC(), MsafdUpdateConnectionContext(), WSPAccept(), WSPAcceptEx(), WSPAsyncSelect(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPConnectEx(), WSPDuplicateSocket(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetOverlappedResult(), WSPGetPeerName(), WSPGetSockName(), WSPGetSockOpt(), WSPIoctl(), WSPListen(), WSPRecv(), WSPRecvFrom(), WSPSelect(), WSPSend(), WSPSendTo(), WSPSetSockOpt(), and WSPShutdown().
◆ MsafdConnectAPC()
|
static |
Definition at line 1964 of file dllmain.c.
1968{
1970
1971 TRACE("MsafdConnectAPC(%p %lx %lx)\n", ApcContext, IoStatusBlock->Status, IoStatusBlock->Information);
1972
1974 if (!Socket)
1975 {
1976 // FIXME: Socket is closed before this APC could run
1978 return;
1979 }
1980
1983 {
1987 }
1988
1989 /* Re-enable Async Event */
1991
1992 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1994
1996 {
1998 Socket->Handle,
1999 Socket->TdiAddressHandle,
2000 Socket->TdiConnectionHandle,
2001 WSH_NOTIFY_CONNECT);
2002 }
2003 else if (IoStatusBlock->Status != STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_CONNECT_ERROR))
2004 {
2006 Socket->Handle,
2007 Socket->TdiAddressHandle,
2008 Socket->TdiConnectionHandle,
2009 WSH_NOTIFY_CONNECT_ERROR);
2010 }
2011
2013}
VOID SockReenableAsyncSelectEvent(IN PSOCKET_INFORMATION Socket, IN ULONG Event)
Definition: dllmain.c:4436
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE _In_opt_ PVOID ApcContext
Definition: iofuncs.h:727
Definition: msafd.h:106
Referenced by WSPConnect().
◆ MsafdInfoAPC()
|
static |
Definition at line 3693 of file dllmain.c.
3697{
3699
3700 TRACE("MsafdInfoAPC(%p %lx %lx)\n", ApcContext, IoStatusBlock->Status, IoStatusBlock->Information);
3701
3703 Context->lpCompletionRoutine(IoStatusBlock->Status, IoStatusBlock->Information, Context->lpOverlapped, 0);
3704
3705 /* Free IOCTL buffer */
3707
3709}
Referenced by GetSocketInformation(), and SetSocketInformation().
◆ MsafdUpdateConnectionContext()
Definition at line 3105 of file dllmain.c.
3108{
3109 IO_STATUS_BLOCK DummyIOSB;
3110 PIO_STATUS_BLOCK IOSB = &DummyIOSB;
3112 SOCK_SHARED_INFO SharedData;
3113 AFD_TDI_HANDLE_DATA HandleData;
3116
3117 if (!Socket)
3118 {
3121 }
3122
3124 {
3126 }
3127
3128 /* Get the socket context from AFD because when ConnectEx is used, this information is not updated. */
3130 EVENT_ALL_ACCESS,
3131 NULL,
3132 SynchronizationEvent,
3133 FALSE);
3135 goto Quit;
3136
3138 SockEvent,
3139 NULL,
3140 NULL,
3141 IOSB,
3142 IOCTL_AFD_GET_CONTEXT,
3143 NULL,
3144 0,
3145 &SharedData,
3146 sizeof(SharedData));
3147
3149 {
3152 }
3153
3155 goto Quit;
3156
3158
3159 /* Get TDI handles from AFD */
3161 SockEvent,
3162 NULL,
3163 NULL,
3164 IOSB,
3166 &flags,
3168 &HandleData,
3169 sizeof(HandleData));
3170
3172 {
3175 }
3176
3177 /* Bail out if the socket was destroyed */
3179 goto Quit;
3180
3182
3184 {
3185 /* Socket is now connected, update usermode msafd socket structure, same as the end of WSPConnect */
3189
3190 /* Re-enable Async Event */
3192
3193 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3195
3197 Socket->Handle,
3198 Socket->TdiAddressHandle,
3199 Socket->TdiConnectionHandle,
3200 WSH_NOTIFY_CONNECT);
3201 }
3202
3204
3205Quit:
3210}
Definition: shared.h:163
Definition: shared.h:382
Referenced by WSPSetSockOpt().
◆ MsafdWaitForAlert()
Definition at line 614 of file dllmain.c.
616{
618
619 for (;;)
620 {
623 break;
624 }
625}
DWORD WINAPI WaitForSingleObjectEx(IN HANDLE hHandle, IN DWORD dwMilliseconds, IN BOOL bAlertable)
Definition: synch.c:94
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by CreateContext(), GetSocketInformation(), MsafdUpdateConnectionContext(), SetSocketInformation(), WSPAccept(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetPeerName(), WSPGetSockName(), WSPListen(), WSPRecv(), WSPRecvFrom(), WSPSelect(), WSPSend(), WSPSendTo(), and WSPShutdown().
◆ SetSocketInformation()
| int SetSocketInformation | ( | PSOCKET_INFORMATION | Socket, |
| ULONG | AfdInformationClass, | ||
| PBOOLEAN Boolean | OPTIONAL, | ||
| PULONG Ulong | OPTIONAL, | ||
| PLARGE_INTEGER LargeInteger | OPTIONAL, | ||
| LPWSAOVERLAPPED Overlapped | OPTIONAL, | ||
| LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine | OPTIONAL | ||
| ) |
Definition at line 3838 of file dllmain.c.
3845{
3846 PIO_STATUS_BLOCK IOSB;
3847 IO_STATUS_BLOCK DummyIOSB;
3848 PAFD_INFO InfoData;
3850 PMSAFD_INFO_APC_CONTEXT APCContext;
3851 PIO_APC_ROUTINE APCFunction;
3854
3856 if (!InfoData)
3858
3860 EVENT_ALL_ACCESS,
3861 NULL,
3862 SynchronizationEvent,
3863 FALSE);
3865 {
3868 }
3869
3870 /* Set Info Class */
3871 InfoData->InformationClass = AfdInformationClass;
3872
3873 /* Set Information */
3875 {
3877 }
3879 {
3881 }
3883 {
3885 }
3886
3887 /* Verify if we should use APC */
3888 if (!Overlapped)
3889 {
3890 /* Not using Overlapped structure, so use normal blocking on event */
3891 APCContext = NULL;
3892 APCFunction = NULL;
3894 IOSB = &DummyIOSB;
3895 }
3896 else
3897 {
3898 /* Overlapped request for non overlapped opened socket */
3900 {
3905 }
3906
3908 if (!APCContext)
3909 {
3914 }
3916 APCContext->lpOverlapped = Overlapped;
3917 APCContext->lpInfoData = InfoData;
3918 APCFunction = &MsafdInfoAPC;
3919
3921 Event = Overlapped->hEvent;
3922
3923 IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
3924 }
3925
3927
3928 /* Send IOCTL */
3930 Event,
3931 APCFunction,
3932 APCContext,
3933 IOSB,
3934 IOCTL_AFD_SET_INFO,
3935 InfoData,
3936 sizeof(*InfoData),
3937 NULL,
3938 0);
3939
3940 /* Wait for completion if not overlapped */
3942 {
3945 }
3946
3948
3950 if (!APCFunction)
3951 {
3952 /* When using APC, this will be freed by the APC function */
3954 }
3955
3957}
Referenced by WSPAsyncSelect(), WSPEventSelect(), WSPIoctl(), and WSPSetSockOpt().
◆ SockAsyncSelectCompletionRoutine()
| VOID SockAsyncSelectCompletionRoutine | ( | PVOID | Context, |
| PIO_STATUS_BLOCK | IoStatusBlock | ||
| ) |
Definition at line 4190 of file dllmain.c.
4191{
4192
4194 PSOCKET_INFORMATION Socket;
4196
4197 /* Get the Socket */
4198 Socket = AsyncData->ParentSocket;
4199
4200 /* Check if the Sequence Number Changed behind our back */
4202 {
4203 return;
4204 }
4205
4206 /* Check we were manually called b/c of a failure */
4208 {
4209 /* FIXME: Perform Upcall */
4210 return;
4211 }
4212
4214 {
4216 {
4220 {
4221 /* Make the Notification */
4224 Socket->Handle,
4226 /* Disable this event until the next read(); */
4228 }
4229 break;
4230
4234 {
4235 /* Make the Notification */
4238 Socket->Handle,
4240 /* Disable this event until the next read(); */
4242 }
4243 break;
4244
4248 {
4249 /* Make the Notification */
4252 Socket->Handle,
4254 /* Disable this event until the next write(); */
4256 }
4257 break;
4258
4259 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
4264 {
4265 /* Make the Notification */
4268 Socket->Handle,
4270 /* Disable this event forever; */
4272 }
4273 break;
4274
4278 {
4279 /* Make the Notification */
4282 Socket->Handle,
4284 /* Disable this event until the next accept(); */
4286 }
4287 break;
4288
4294 {
4295 /* Make the Notification */
4298 Socket->Handle,
4300 /* Disable this event forever; */
4302 }
4303 break;
4304 /* FIXME: Support QOS */
4305 }
4306 }
4307
4308 /* Check if there are any events left for us to check */
4310 {
4311 return;
4312 }
4313
4314 /* Keep Polling */
4315 SockProcessAsyncSelect(Socket, AsyncData);
4316 return;
4317}
VOID SockProcessAsyncSelect(PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
Definition: dllmain.c:4319
Definition: msafd.h:76
Referenced by SockGetAsyncSelectHelperAfdHandle(), and SockProcessAsyncSelect().
◆ SockAsyncThread()
Definition at line 4094 of file dllmain.c.
4095{
4096 PVOID AsyncContext;
4097 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine;
4098 IO_STATUS_BLOCK IOSB;
4100
4101 /* Make the Thread Higher Priority */
4103
4104 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
4105 do
4106 {
4108 (PVOID*)&AsyncCompletionRoutine,
4109 &AsyncContext,
4110 &IOSB,
4111 NULL);
4112 /* Call the Async Function */
4114 {
4115 (*AsyncCompletionRoutine)(AsyncContext, &IOSB);
4116 }
4117 else
4118 {
4119 /* It Failed, sleep for a second */
4120 Sleep(1000);
4121 }
4123
4124 /* The Thread has Ended */
4125 return 0;
4126}
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
Definition: thread.c:758
VOID(* PASYNC_COMPLETION_ROUTINE)(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: msafd.h:511
NTSTATUS NTAPI NtRemoveIoCompletion(IN HANDLE IoCompletionHandle, OUT PVOID *KeyContext, OUT PVOID *ApcContext, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: iocomp.c:445
Referenced by SockCreateOrReferenceAsyncThread().
◆ SockCreateOrReferenceAsyncThread()
Definition at line 4033 of file dllmain.c.
4034{
4035 HANDLE hAsyncThread;
4036 DWORD AsyncThreadId;
4037 HANDLE AsyncEvent;
4038 OBJECT_HANDLE_FLAG_INFORMATION HandleFlags;
4040
4041 /* Check if the Thread Already Exists */
4043 {
4046 }
4047
4048 /* Create the Completion Port */
4050 {
4052 IO_COMPLETION_ALL_ACCESS,
4053 NULL,
4054 2); // Allow 2 threads only
4056 {
4059 }
4060 /* Protect Handle */
4065 &HandleFlags,
4066 sizeof(HandleFlags));
4067 }
4068
4069 /* Create the Async Event */
4071 EVENT_ALL_ACCESS,
4072 NULL,
4073 NotificationEvent,
4074 FALSE);
4075
4076 /* Create the Async Thread */
4078 0,
4079 SockAsyncThread,
4080 NULL,
4081 0,
4082 &AsyncThreadId);
4083
4084 /* Close the Handle */
4085 NtClose(hAsyncThread);
4086
4087 /* Increase the Reference Count */
4088 SockAsyncThreadRefCount++;
4090}
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
NTSTATUS NTAPI NtCreateIoCompletion(OUT PHANDLE IoCompletionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG NumberOfConcurrentThreads)
Definition: iocomp.c:253
NTSTATUS NTAPI NtSetInformationObject(_In_ HANDLE ObjectHandle, _In_ OBJECT_INFORMATION_CLASS ObjectInformationClass, _In_reads_bytes_(Length) PVOID ObjectInformation, _In_ ULONG Length)
Sets information for an object or for a handle to an object.
Definition: oblife.c:1845
Definition: obtypes.h:349
Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().
◆ SockGetAsyncSelectHelperAfdHandle()
Definition at line 4128 of file dllmain.c.
4129{
4130 UNICODE_STRING AfdHelper;
4132 IO_STATUS_BLOCK IoSb;
4133 FILE_COMPLETION_INFORMATION CompletionInfo;
4134 OBJECT_HANDLE_FLAG_INFORMATION HandleFlags;
4135
4136 /* First, make sure we're not already initialized */
4138 {
4140 }
4141
4142 /* Set up Handle Name and Object */
4145 &AfdHelper,
4147 NULL,
4148 NULL);
4149
4150 /* Open the Handle to AFD */
4153 &ObjectAttributes,
4154 &IoSb,
4155 NULL,
4156 0,
4158 FILE_OPEN_IF,
4159 0,
4160 NULL,
4161 0);
4162
4163 /*
4164 * Now Set up the Completion Port Information
4165 * This means that whenever a Poll is finished, the routine will be executed
4166 */
4170 &IoSb,
4171 &CompletionInfo,
4172 sizeof(CompletionInfo),
4173 FileCompletionInformation);
4174
4175
4176 /* Protect the Handle */
4181 &HandleFlags,
4182 sizeof(HandleFlags));
4183
4184
4185 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
4188}
VOID SockAsyncSelectCompletionRoutine(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:4190
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSYSAPI NTSTATUS NTAPI NtSetInformationFile(IN HANDLE hFile, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN PVOID FileInformationBuffer, IN ULONG FileInformationBufferLength, IN FILE_INFORMATION_CLASS FileInfoClass)
Definition: iofunc.c:3096
NTSTATUS NTAPI NtCreateFile(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG CreateDisposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength)
Definition: winternl.h:3779
Definition: umtypes.h:184
Definition: env_spec_w32.h:368
Referenced by WSPAsyncSelect().
◆ SockProcessAsyncSelect()
| VOID SockProcessAsyncSelect | ( | PSOCKET_INFORMATION | Socket, |
| PASYNC_DATA | AsyncData | ||
| ) |
Definition at line 4319 of file dllmain.c.
4320{
4321
4322 ULONG lNetworkEvents;
4324
4325 /* Set up the Async Data Event Info */
4332
4333 /* Remove unwanted events */
4335
4336 /* Set Events to wait for */
4338 {
4340 }
4341
4343 {
4345 }
4346
4348 {
4350 }
4351
4353 {
4355 }
4356
4357 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
4359 {
4361 }
4362
4364 {
4365 AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE;
4366 }
4367
4369 {
4371 }
4372
4374 {
4376 }
4377
4378 /* Send IOCTL */
4380 NULL,
4381 NULL,
4382 AsyncData,
4383 &AsyncData->IoStatusBlock,
4384 IOCTL_AFD_SELECT,
4385 &AsyncData->AsyncSelectInfo,
4387 &AsyncData->AsyncSelectInfo,
4389
4390 /* I/O Manager Won't call the completion routine, let's do it manually */
4392 {
4393 return;
4394 }
4395 else
4396 {
4399 }
4400}
Referenced by SockAsyncSelectCompletionRoutine(), and SockProcessQueuedAsyncSelect().
◆ SockProcessQueuedAsyncSelect()
| VOID SockProcessQueuedAsyncSelect | ( | PVOID | Context, |
| PIO_STATUS_BLOCK | IoStatusBlock | ||
| ) |
Definition at line 4402 of file dllmain.c.
4403{
4406 PSOCKET_INFORMATION Socket;
4407
4408 /* Get the Socket */
4409 Socket = AsyncData->ParentSocket;
4410
4411 /* If someone closed it, stop the function */
4413 {
4414 /* Check if the Sequence Number changed by now, in which case quit */
4416 {
4417 /* Do the actual select, if needed */
4419 {
4420 SockProcessAsyncSelect(Socket, AsyncData);
4421 FreeContext = FALSE;
4422 }
4423 }
4424 }
4425
4426 /* Free the Context */
4427 if (FreeContext)
4428 {
4430 }
4431
4432 return;
4433}
Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().
◆ SockReenableAsyncSelectEvent()
| VOID SockReenableAsyncSelectEvent | ( | IN PSOCKET_INFORMATION | Socket, |
| IN ULONG | Event | ||
| ) |
Definition at line 4436 of file dllmain.c.
4438{
4439 PASYNC_DATA AsyncData;
4440
4441 /* Make sure the event is actually disabled */
4443 {
4444 return;
4445 }
4446
4447 /* Re-enable it */
4448 Socket->SharedData->AsyncDisabledEvents &= ~Event;
4449
4450 /* Return if no more events are being polled */
4451 if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
4452 {
4453 return;
4454 }
4455
4456 /* Wait on new events */
4458 if (!AsyncData) return;
4459
4460 /* Create the Asynch Thread if Needed */
4461 SockCreateOrReferenceAsyncThread();
4462
4463 /* Increase the sequence number to stop anything else */
4464 Socket->SharedData->SequenceNumber++;
4465
4466 /* Set up the Async Data */
4467 AsyncData->ParentSocket = Socket;
4468 AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
4469
4470 /* Begin Async Select by using I/O Completion */
4473 AsyncData,
4474 0,
4475 0);
4476
4477 /* All done */
4478 return;
4479}
BOOLEAN SockCreateOrReferenceAsyncThread(VOID)
Definition: dllmain.c:4033
VOID SockProcessQueuedAsyncSelect(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:4402
NTSTATUS NTAPI NtSetIoCompletion(IN HANDLE IoCompletionPortHandle, IN PVOID CompletionKey, IN PVOID CompletionContext, IN NTSTATUS CompletionStatus, IN ULONG CompletionInformation)
Definition: iocomp.c:569
Referenced by MsafdConnectAPC(), MsafdRecvAPC(), MsafdSendAPC(), MsafdUpdateConnectionContext(), WSPAccept(), WSPConnect(), WSPGetOverlappedResult(), WSPRecv(), WSPRecvFrom(), WSPSend(), and WSPSendTo().
◆ TranslateNtStatusError()
Definition at line 537 of file dllmain.c.
538{
540 {
543
546
549
552
555
558
562
566
569
572
575
579
582
585
588
591
594
597
600
603
606
607 default:
610 }
611}
Referenced by MsafdConnectAPC(), MsafdReturnWithErrno(), MsafdUpdateConnectionContext(), WSPAccept(), WSPAcceptEx(), WSPBind(), WSPConnect(), WSPConnectEx(), WSPEnumNetworkEvents(), WSPGetOverlappedResult(), WSPListen(), WSPShutdown(), and WSPSocket().
◆ WSPAccept()
| _Must_inspect_result_ SOCKET WSPAPI WSPAccept | ( | _In_ SOCKET | Handle, |
| _Out_writes_bytes_to_opt_ *, *addrlen struct sockaddr FAR * | SocketAddress, | ||
| _Inout_opt_ LPINT | SocketAddressLength, | ||
| _In_opt_ LPCONDITIONPROC | lpfnCondition, | ||
| _In_opt_ DWORD_PTR | dwCallbackData, | ||
| _Out_ LPINT | lpErrno | ||
| ) |
Definition at line 1451 of file dllmain.c.
1458{
1459 IO_STATUS_BLOCK IOSB;
1460 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData;
1461 AFD_ACCEPT_DATA AcceptData;
1462 AFD_DEFER_ACCEPT_DATA DeferData;
1463 AFD_PENDING_ACCEPT_DATA PendingAcceptData;
1469 ULONG PendingDataLength = 0;
1470 PVOID CalleeDataBuffer;
1471 WSABUF CallerData, CalleeID, CallerID, CalleeData;
1473 GROUP GroupID = 0;
1474 ULONG CallBack;
1476 PSOCKET_INFORMATION AcceptSocketInfo;
1477 UCHAR ReceiveBuffer[0x1A];
1479
1480 /* Get the Socket Structure associate to this Socket*/
1482 if (!Socket)
1483 {
1486 }
1488 {
1491 }
1492 if ((SocketAddress && !SocketAddressLength) ||
1493 (SocketAddressLength && !SocketAddress) ||
1495 {
1498 }
1499
1501 EVENT_ALL_ACCESS,
1502 NULL,
1503 SynchronizationEvent,
1504 FALSE);
1505
1507 {
1509 }
1510
1511 /* Dynamic Structure...ugh */
1512 ListenReceiveData = (PAFD_RECEIVED_ACCEPT_DATA)ReceiveBuffer;
1513
1514 /* If this is non-blocking, make sure there's something for us to accept */
1516 {
1517 FD_ZERO(&ReadSet);
1519 Timeout.tv_sec=0;
1520 Timeout.tv_usec=0;
1521
1523 {
1526 }
1527
1529 {
1533 }
1534 }
1535
1536 /* Send IOCTL */
1538 SockEvent,
1539 NULL,
1540 NULL,
1541 &IOSB,
1543 NULL,
1544 0,
1545 ListenReceiveData,
1546 0xA + sizeof(*ListenReceiveData));
1547
1548 /* Wait for return */
1550 {
1553 }
1554
1556 {
1559 }
1560
1562 {
1564 {
1565 /* Find out how much data is pending */
1568
1569 /* Send IOCTL */
1571 SockEvent,
1572 NULL,
1573 NULL,
1574 &IOSB,
1576 &PendingAcceptData,
1577 sizeof(PendingAcceptData),
1578 &PendingAcceptData,
1579 sizeof(PendingAcceptData));
1580
1581 /* Wait for return */
1583 {
1586 }
1587
1589 {
1592 }
1593
1594 /* How much data to allocate */
1595 PendingDataLength = IOSB.Information;
1596
1597 if (PendingDataLength)
1598 {
1599 /* Allocate needed space */
1601 if (!PendingData)
1602 {
1604 }
1605
1606 /* We want the data now */
1608
1609 /* Send IOCTL */
1611 SockEvent,
1612 NULL,
1613 NULL,
1614 &IOSB,
1616 &PendingAcceptData,
1617 sizeof(PendingAcceptData),
1618 PendingData,
1619 PendingDataLength);
1620
1621 /* Wait for return */
1623 {
1626 }
1627
1629 {
1632 }
1633 }
1634 }
1635
1637 {
1638 /* I don't support this yet */
1639 }
1640
1641 /* Build Callee ID */
1644
1647 {
1649 }
1650
1651 /* Set up Address in SOCKADDR Format */
1655
1656 /* Build Caller ID */
1659
1660 /* Build Caller Data */
1661 CallerData.buf = PendingData;
1662 CallerData.len = PendingDataLength;
1663
1664 /* Check if socket supports Conditional Accept */
1666 {
1667 /* Allocate Buffer for Callee Data */
1669 if (!CalleeDataBuffer) {
1671 }
1672 CalleeData.buf = CalleeDataBuffer;
1673 CalleeData.len = 4096;
1674 }
1675 else
1676 {
1677 /* Nothing */
1678 CalleeData.buf = 0;
1679 CalleeData.len = 0;
1680 }
1681
1682 /* Call the Condition Function */
1683 CallBack = (lpfnCondition)(&CallerID,
1685 NULL,
1686 NULL,
1687 &CalleeID,
1689 &GroupID,
1690 dwCallbackData);
1691
1693 {
1694 /* TBD: Check for Validity */
1695 }
1696
1698 {
1700 {
1701 /* I don't support this yet */
1702 }
1703 if (CalleeData.buf)
1704 {
1705 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1706 }
1707 }
1708 else
1709 {
1710 /* Callback rejected. Build Defer Structure */
1713
1714 /* Send IOCTL */
1716 SockEvent,
1717 NULL,
1718 NULL,
1719 &IOSB,
1720 IOCTL_AFD_DEFER_ACCEPT,
1721 &DeferData,
1722 sizeof(DeferData),
1723 NULL,
1724 0);
1725
1726 /* Wait for return */
1728 {
1731 }
1732
1734
1736 {
1738 }
1739
1741 {
1744 }
1745 else
1746 {
1749 }
1750 }
1751 }
1752
1753 /* Create a new Socket */
1757 &Socket->ProtocolInfo,
1758 GroupID,
1760 lpErrno);
1763
1764 /* Set up the Accept Structure */
1767
1768 /* Send IOCTL to Accept */
1770 SockEvent,
1771 NULL,
1772 NULL,
1773 &IOSB,
1774 IOCTL_AFD_ACCEPT,
1775 &AcceptData,
1776 sizeof(AcceptData),
1777 NULL,
1778 0);
1779
1780 /* Wait for return */
1782 {
1785 }
1786
1789 {
1793 }
1794
1796 if (!AcceptSocketInfo)
1797 {
1801 }
1802
1806
1807 /* Return Address in SOCKADDR FORMAT */
1808 if( SocketAddress )
1809 {
1810 RtlCopyMemory (SocketAddress,
1813 if( SocketAddressLength )
1814 *SocketAddressLength = sizeof(*RemoteAddress);
1815 }
1816
1818
1819 /* Re-enable Async Event */
1821
1823
1825 {
1827 Socket->Handle,
1828 Socket->TdiAddressHandle,
1829 Socket->TdiConnectionHandle,
1830 WSH_NOTIFY_ACCEPT);
1831
1833 {
1836 }
1837 }
1838
1840
1841 /* Return Socket */
1843}
int WSPAPI WSPSelect(IN int nfds, IN OUT fd_set *readfds OPTIONAL, IN OUT fd_set *writefds OPTIONAL, IN OUT fd_set *exceptfds OPTIONAL, IN const struct timeval *timeout OPTIONAL, OUT LPINT lpErrno)
Definition: dllmain.c:1082
INT WSPAPI WSPCloseSocket(IN SOCKET Handle, OUT LPINT lpErrno)
Definition: dllmain.c:637
SOCKET WSPAPI WSPSocket(int AddressFamily, int SocketType, int Protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags, LPINT lpErrno)
Definition: dllmain.c:48
Definition: shared.h:62
Definition: shared.h:89
Definition: shared.h:83
Definition: shared.h:78
Definition: ws2def.h:524
Definition: winsock.h:60
Definition: tcpcore.h:1189
Definition: linux.h:1737
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _In_opt_ PWSK_SOCKET AcceptSocket
Definition: wsk.h:173
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR RemoteAddress
Definition: wsk.h:172
Referenced by WSPStartup().
◆ WSPAcceptEx()
| BOOL WSPAPI WSPAcceptEx | ( | _In_ SOCKET | sListenSocket, |
| _In_ SOCKET | sAcceptSocket, | ||
| _Out_ PVOID | lpOutputBuffer, | ||
| _In_ DWORD | dwReceiveDataLength, | ||
| _In_ DWORD | dwLocalAddressLength, | ||
| _In_ DWORD | dwRemoteAddressLength, | ||
| _Out_ LPDWORD | lpdwBytesReceived, | ||
| _Inout_ LPOVERLAPPED | lpOverlapped | ||
| ) |
Definition at line 1847 of file dllmain.c.
1856{
1859 AFD_SUPER_ACCEPT_INFO AcceptInfo;
1862
1863 /* Validate sockets */
1865 {
1868 }
1869
1871 {
1874 }
1875
1876 /* Check if this socket is listening and that AcceptEx hasn't already been invoked */
1878 {
1881 }
1882
1883 /* Make sure that the accept socket is not already opened or connected */
1885 {
1888 }
1889
1891 {
1894 }
1895
1896 /* Populate IOCTL super accept structure */
1903
1904 IoStatusBlock->Information = 0;
1906
1908 lpOverlapped->hEvent,
1909 NULL,
1911 IoStatusBlock,
1912 IOCTL_AFD_SUPER_ACCEPT,
1913 &AcceptInfo,
1914 sizeof(AcceptInfo),
1915 lpOutputBuffer,
1917
1919 {
1922 }
1923
1926
1928
1930}
_In_ SOCKET _In_ DWORD _In_ DWORD _In_ DWORD _Out_ LPDWORD lpdwBytesReceived
Definition: mswsock.h:105
_In_ SOCKET _In_ DWORD _In_ DWORD _In_ DWORD dwRemoteAddressLength
Definition: mswsock.h:104
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:93
Definition: shared.h:69
Referenced by WSPIoctl().
◆ WSPAddressToString()
| INT WSPAPI WSPAddressToString | ( | IN LPSOCKADDR | lpsaAddress, |
| IN DWORD | dwAddressLength, | ||
| IN LPWSAPROTOCOL_INFOW | lpProtocolInfo, | ||
| OUT LPWSTR | lpszAddressString, | ||
| IN OUT LPDWORD | lpdwAddressStringLength, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 3496 of file dllmain.c.
3502{
3506
3507 if (!lpsaAddress || !lpszAddressString || !lpdwAddressStringLength)
3508 {
3511 }
3512
3513 switch (lpsaAddress->sa_family)
3514 {
3517 {
3520 }
3528
3531 {
3532 *p = 0;
3533 }
3534 break;
3535 default:
3538 }
3539
3541
3543 {
3544 *lpdwAddressStringLength = size;
3547 }
3548
3549 *lpdwAddressStringLength = size;
3551 return 0;
3552}
Definition: winsock.h:503
Referenced by WSPStartup().
◆ WSPBind()
| INT WSPAPI WSPBind | ( | SOCKET | Handle, |
| const struct sockaddr * | SocketAddress, | ||
| int | SocketAddressLength, | ||
| LPINT | lpErrno | ||
| ) |
Definition at line 860 of file dllmain.c.
864{
865 IO_STATUS_BLOCK IOSB;
866 PAFD_BIND_DATA BindData;
869 SOCKADDR_INFO SocketInfo;
871 ULONG connectSize;
872
873 /* Get the Socket Structure associate to this Socket*/
875 if (!Socket)
876 {
879 }
881 {
884 }
885 if (!SocketAddress || SocketAddressLength < Socket->SharedData->SizeOfLocalAddress)
886 {
889 }
890
891 /* Get Address Information */
893 SocketAddressLength,
894 &SocketInfo);
895
897 {
900 }
901
903 EVENT_ALL_ACCESS,
904 NULL,
905 SynchronizationEvent,
906 FALSE);
907
909 {
911 }
912
914
915 /* See below */
917 if (!BindData)
918 {
920 }
921
922 /* Set up Address in TDI Format */
924 BindData->Address.Address[0].AddressLength = (USHORT)(SocketAddressLength - sizeof(SocketAddress->sa_family));
927 SocketAddress->sa_data,
929
930 /* Set the Share Type */
932 {
934 }
936 {
938 }
940 {
942 }
943 else
944 {
946 }
947
948 /* Send IOCTL */
950 SockEvent,
951 NULL,
952 NULL,
953 &IOSB,
954 IOCTL_AFD_BIND,
955 BindData,
956 connectSize,
957 BindData,
958 connectSize);
959
960 /* Wait for return */
962 {
965 }
966
969
973
974 /* Set up Socket Data */
977
979 {
981 Socket->Handle,
982 Socket->TdiAddressHandle,
983 Socket->TdiConnectionHandle,
984 WSH_NOTIFY_BIND);
985
987 {
990 }
991 }
992
994}
Definition: shared.h:38
Definition: wsahelp.h:43
Referenced by WSPConnect(), WSPRecvFrom(), WSPSendTo(), and WSPStartup().
◆ WSPCleanup()
Definition at line 3680 of file dllmain.c.
3682{
3684
3686
3687 return 0;
3688}
Referenced by WSPStartup(), and WsTpWSPCleanup().
◆ WSPCloseSocket()
Definition at line 637 of file dllmain.c.
639{
644 AFD_DISCONNECT_INFO DisconnectInfo;
645 SOCKET_STATE OldState;
646 LONG LingerWait = -1;
647 DWORD References;
648
649 /* Get the Socket Structure associate to this Socket*/
651 if (!Socket)
652 {
655 }
656
657 /* HACK: Allow APC to be processed */
659
661 {
663 Socket->Handle,
664 Socket->TdiAddressHandle,
665 Socket->TdiConnectionHandle,
666 WSH_NOTIFY_CLOSE);
667
669 {
673 }
674 }
675
676 /* If a Close is already in Process, give up */
678 {
682 }
683
684 /* Create the Wait Event */
686 EVENT_ALL_ACCESS,
687 NULL,
688 SynchronizationEvent,
689 FALSE);
691 {
694 }
695
696 /* Decrement reference count on SharedData */
698 if (References)
700
701 /* Set the state to close */
704
705 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
706 /* FIXME: Should we do this on Datagram Sockets too? */
708 {
709 ULONG SendsInProgress;
710 ULONG SleepWait;
711
712 /* We need to respect the timeout */
713 SleepWait = 100;
715
716 /* Loop until no more sends are pending, within the timeout */
717 while (LingerWait)
718 {
719 /* Find out how many Sends are in Progress */
722 NULL,
723 &SendsInProgress,
724 NULL,
725 NULL,
726 NULL))
727 {
728 /* Bail out if anything but NO_ERROR */
729 LingerWait = 0;
730 break;
731 }
732
733 /* Bail out if no more sends are pending */
734 if (!SendsInProgress)
735 {
736 LingerWait = -1;
737 break;
738 }
739
740 /*
741 * We have to execute a sleep, so it's kind of like
742 * a block. If the socket is Nonblock, we cannot
743 * go on since asynchronous operation is expected
744 * and we cannot offer it
745 */
747 {
753 }
754
755 /* Now we can sleep, and decrement the linger wait */
756 /*
757 * FIXME: It seems Windows does some funky acceleration
758 * since the waiting seems to be longer and longer. I
759 * don't think this improves performance so much, so we
760 * wait a fixed time instead.
761 */
762 Sleep(SleepWait);
763 LingerWait -= SleepWait;
764 }
765 }
766
768 {
769 if (LingerWait <= 0)
770 {
773
774 if (((DisconnectInfo.DisconnectType & AFD_DISCONNECT_SEND) && (!Socket->SharedData->SendShutdown)) ||
775 ((DisconnectInfo.DisconnectType & AFD_DISCONNECT_ABORT) && (!Socket->SharedData->ReceiveShutdown)))
776 {
777 /* Send IOCTL */
779 SockEvent,
780 NULL,
781 NULL,
782 &IoStatusBlock,
783 IOCTL_AFD_DISCONNECT,
784 &DisconnectInfo,
785 sizeof(DisconnectInfo),
786 NULL,
787 0);
788
789 /* Wait for return */
791 {
794 }
795 }
796 }
797 }
798
799 /* Cleanup Time! */
806ok:
809 {
811 }
812 else
813 {
814 CurrentSocket = SocketListHead;
815 while (CurrentSocket->NextSocket)
816 {
817 if (CurrentSocket->NextSocket == Socket)
818 {
819 CurrentSocket->NextSocket = CurrentSocket->NextSocket->NextSocket;
820 break;
821 }
822
823 CurrentSocket = CurrentSocket->NextSocket;
824 }
825 }
827
828 /* Close the handle */
831
833 {
834 /* It is a duplicated socket, so unmap the memory */
838 }
840 {
842 }
845}
int GetSocketInformation(PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
Definition: dllmain.c:3712
Definition: shared.h:151
enum _SOCKET_STATE SOCKET_STATE
Referenced by WSPAccept(), and WSPStartup().
◆ WSPConnect()
| int WSPAPI WSPConnect | ( | SOCKET | Handle, |
| const struct sockaddr * | SocketAddress, | ||
| int | SocketAddressLength, | ||
| LPWSABUF | lpCallerData, | ||
| LPWSABUF | lpCalleeData, | ||
| LPQOS | lpSQOS, | ||
| LPQOS | lpGQOS, | ||
| LPINT | lpErrno | ||
| ) |
Definition at line 2017 of file dllmain.c.
2025{
2026 IO_STATUS_BLOCK DummyIOSB;
2027 PIO_STATUS_BLOCK IOSB = &DummyIOSB;
2029 PSOCKET_INFORMATION Socket;
2031 INT Errno;
2032 ULONG ConnectDataLength;
2033 ULONG InConnectDataLength;
2035 int SocketDataLength;
2039
2041
2042 /* Get the Socket Structure associate to this Socket*/
2044 if (!Socket)
2045 {
2048 }
2049
2050 /* Bind us First */
2052 {
2053 INT BindAddressLength;
2054 PSOCKADDR BindAddress;
2055 INT BindError;
2056
2057 /* Get the Wildcard Address */
2060 if (!BindAddress)
2061 {
2063 }
2065 BindAddress,
2066 &BindAddressLength);
2067 /* Bind it */
2072 }
2073
2075 EVENT_ALL_ACCESS,
2076 NULL,
2077 SynchronizationEvent,
2078 FALSE);
2081
2082 /* Set the Connect Data */
2084 {
2085 ConnectDataLength = lpCallerData->len;
2087 SockEvent,
2088 NULL,
2089 NULL,
2090 IOSB,
2092 lpCallerData->buf,
2093 ConnectDataLength,
2094 NULL,
2095 0);
2096 /* Wait for return */
2098 {
2101 }
2102
2104 goto Leave;
2105 }
2106
2107 /* Calculate the size of SocketAddress->sa_data */
2109
2111
2112 int connectionInfoSize = FIELD_OFFSET(AFD_CONNECT_INFO, RemoteAddress.Address[0].Address[SocketDataLength]);
2113
2114 if (connectionInfoSize > 128)
2115 {
2116 *lpErrno = WSAEFAULT;
2118 }
2119
2120 /* Set up Address in TDI Format */
2125 SocketAddress->sa_data,
2126 SocketDataLength);
2127
2128 /*
2129 * Disable FD_WRITE and FD_CONNECT
2130 * The latter fixes a race condition where the FD_CONNECT is re-enabled
2131 * at the end of this function right after the Async Thread disables it.
2132 * This should only happen at the *next* WSPConnect
2133 */
2135 {
2137 }
2138
2139 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
2141 {
2142 InConnectDataLength = lpCalleeData->len;
2144 SockEvent,
2145 NULL,
2146 NULL,
2147 IOSB,
2149 &InConnectDataLength,
2150 sizeof(InConnectDataLength),
2151 NULL,
2152 0);
2153
2154 /* Wait for return */
2156 {
2159 }
2160
2162 goto Leave;
2163 }
2164
2165 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
2166 ConnectInfo->Root = 0;
2168 ConnectInfo->Unknown = 0;
2169
2170 /* Verify if we should use APC */
2172 {
2174 if (!APCContext)
2175 {
2178 goto Leave;
2179 }
2181 APCFunction = &MsafdConnectAPC;
2182
2183 IOSB = &APCContext->IoStatusBlock;
2184 }
2185
2187 IOSB->Information = 0;
2188
2189 /* Send IOCTL */
2192 APCFunction,
2193 APCContext,
2194 IOSB,
2195 IOCTL_AFD_CONNECT,
2196 ConnectInfo,
2197 connectionInfoSize,
2198 NULL,
2199 0);
2201 {
2203 {
2205 goto Leave;
2206 }
2207 else
2208 {
2209 /* HACK: Allow APC to be processed */
2211 }
2212 }
2213 else
2214 {
2215 /* Wait for completion if blocking */
2217 {
2220 }
2221
2224 goto Leave;
2225
2229 }
2230
2231 /* Get any pending connect data */
2233 {
2234 IOSB = &DummyIOSB;
2236 SockEvent,
2237 NULL,
2238 NULL,
2239 IOSB,
2241 NULL,
2242 0,
2243 lpCalleeData->buf,
2244 lpCalleeData->len);
2245 /* Wait for return */
2247 {
2250 }
2251 }
2252
2253Leave:
2255
2257
2258 /* Re-enable Async Event */
2260
2261 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2263
2265 {
2267 Socket->Handle,
2268 Socket->TdiAddressHandle,
2269 Socket->TdiConnectionHandle,
2270 WSH_NOTIFY_CONNECT);
2271
2272 if (Errno)
2273 {
2274 if (lpErrno) *lpErrno = Errno;
2276 }
2277 }
2279 {
2281 Socket->Handle,
2282 Socket->TdiAddressHandle,
2283 Socket->TdiConnectionHandle,
2284 WSH_NOTIFY_CONNECT_ERROR);
2285
2286 if (Errno)
2287 {
2288 if (lpErrno) *lpErrno = Errno;
2290 }
2291 }
2292
2294}
Definition: bufpool.h:45
INT WSPAPI WSPBind(SOCKET Handle, const struct sockaddr *SocketAddress, int SocketAddressLength, LPINT lpErrno)
Definition: dllmain.c:860
static VOID NTAPI MsafdConnectAPC(_In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved)
Definition: dllmain.c:1964
Definition: shared.h:127
PWSH_GET_WILDCARD_SOCKADDR WSHGetWildcardSockaddr
Definition: helpers.h:29
Referenced by WSPStartup().
◆ WSPConnectEx()
| BOOL WSPAPI WSPConnectEx | ( | _In_ SOCKET | Handle, |
| _In_ const struct sockaddr * | SocketAddress, | ||
| _In_ int | SocketAddressLength, | ||
| _In_ PVOID | lpSendBuffer, | ||
| _In_ DWORD | dwSendDataLength, | ||
| _Out_ LPDWORD | lpdwBytesSent, | ||
| _Inout_ LPOVERLAPPED | lpOverlapped | ||
| ) |
Definition at line 2298 of file dllmain.c.
2306{
2307 IO_STATUS_BLOCK DummyIOSB;
2308 PIO_STATUS_BLOCK IOSB = &DummyIOSB;
2310 PSOCKET_INFORMATION Socket;
2312 int SocketDataLength;
2314
2316 {
2319 }
2320
2321 if (!lpSendBuffer && dwSendDataLength)
2322 {
2325 }
2326
2327 /* Get the Socket Structure associate to this Socket*/
2329 if (!Socket)
2330 {
2333 }
2334
2335
2336 /* Cannot call on connectionless socket */
2337 if (SocketAddressLength > ARRAYSIZE(Buffer) - sizeof(AFD_CONNECT_INFO) || Socket->SharedData->ServiceFlags1 & XP1_CONNECTIONLESS)
2338 {
2341 }
2342
2344 {
2345 /* Socket already must be bound */
2348 }
2349
2352
2353 /* Calculate the size of SocketAddress->sa_data */
2355
2356 /* Set up Address in TDI Format */
2361 SocketAddress->sa_data,
2362 SocketDataLength);
2363
2364 /*
2365 * Disable FD_WRITE and FD_CONNECT.
2366 * The latter fixes a race condition where the FD_CONNECT is re-enabled
2367 * at the end of this function right after the Async Thread disables it.
2368 * This should only happen at the *next* WSPConnect.
2369 */
2371 {
2373 }
2374
2377
2378 /* Send IOCTL */
2380 lpOverlapped->hEvent,
2381 NULL,
2383 IOSB,
2384 IOCTL_AFD_SUPER_CONNECT,
2385 ConnectInfo,
2387 lpSendBuffer,
2388 dwSendDataLength);
2389
2391
2393}
Definition: shared.h:135
Referenced by WSPIoctl().
◆ WSPDuplicateSocket()
| INT WSPAPI WSPDuplicateSocket | ( | IN SOCKET | Handle, |
| IN DWORD | dwProcessId, | ||
| OUT LPWSAPROTOCOL_INFOW | lpProtocolInfo, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 449 of file dllmain.c.
454{
456 PSOCKET_INFORMATION Socket;
457 PSOCK_SHARED_INFO pSharedData, pOldSharedData;
458 BOOL bDuplicated;
459
463 if( !Socket )
464 {
465 if( lpErrno )
466 *lpErrno = WSAENOTSOCK;
468 }
471
472 /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
474 {
476 NULL,
478 0,
480 NULL);
484 FILE_MAP_ALL_ACCESS,
485 0,
486 0,
488
490 pOldSharedData = Socket->SharedData;
491 Socket->SharedData = pSharedData;
493 }
494 /* Duplicate the handles for the new process */
496 Socket->SharedDataHandle,
497 hProcess,
498 (LPHANDLE)&hDuplicatedSharedData,
499 0,
500 FALSE,
501 DUPLICATE_SAME_ACCESS);
502 if (!bDuplicated)
503 {
506 }
509 hProcess,
510 (LPHANDLE)&hDuplicatedHandle,
511 0,
512 FALSE,
513 DUPLICATE_SAME_ACCESS);
515 if( !bDuplicated )
517
518
519 if (!lpProtocolInfo)
521
523
527 lpProtocolInfo->dwServiceFlags3 = HandleToUlong(hDuplicatedSharedData);
528 lpProtocolInfo->dwServiceFlags4 = HandleToUlong(hDuplicatedHandle);
529
530 if( lpErrno )
531 *lpErrno = NO_ERROR;
532
534}
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1274
#define PROCESS_DUP_HANDLE
#define DUPLICATE_SAME_ACCESS
Referenced by WSPStartup().
◆ WSPGetAcceptExSockaddrs()
| VOID WSPAPI WSPGetAcceptExSockaddrs | ( | IN PVOID | lpOutputBuffer, |
| IN DWORD | dwReceiveDataLength, | ||
| IN DWORD | dwLocalAddressLength, | ||
| IN DWORD | dwRemoteAddressLength, | ||
| OUT struct sockaddr ** | LocalSockaddr, | ||
| OUT LPINT | LocalSockaddrLength, | ||
| OUT struct sockaddr ** | RemoteSockaddr, | ||
| OUT LPINT | RemoteSockaddrLength | ||
| ) |
Definition at line 1934 of file dllmain.c.
1943{
1944 /* AFD_SUPER_ACCEPT outputs receive data + local address + local address length + remote address + remote address length */
1945 /* Length is located 2 bytes before address length */
1948 {
1951 }
1952
1954 {
1958 }
1959}
_In_ DWORD _In_ DWORD _In_ DWORD _Outptr_result_bytebuffer_ LocalSockaddrLength struct sockaddr ** LocalSockaddr
Definition: mswsock.h:114
_In_ DWORD _In_ DWORD _In_ DWORD _Outptr_result_bytebuffer_ LocalSockaddrLength struct sockaddr _Out_ LPINT LocalSockaddrLength
Definition: mswsock.h:115
_In_ DWORD _In_ DWORD _In_ DWORD _Outptr_result_bytebuffer_ LocalSockaddrLength struct sockaddr _Out_ LPINT _Outptr_result_bytebuffer_ RemoteSockaddrLength struct sockaddr ** RemoteSockaddr
Definition: mswsock.h:116
_In_ DWORD _In_ DWORD _In_ DWORD _Outptr_result_bytebuffer_ LocalSockaddrLength struct sockaddr _Out_ LPINT _Outptr_result_bytebuffer_ RemoteSockaddrLength struct sockaddr _Out_ LPINT RemoteSockaddrLength
Definition: mswsock.h:117
Referenced by WSPIoctl().
◆ WSPGetPeerName()
| INT WSPAPI WSPGetPeerName | ( | IN SOCKET | s, |
| OUT LPSOCKADDR | Name, | ||
| IN OUT LPINT | NameLength, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 2579 of file dllmain.c.
2583{
2584 IO_STATUS_BLOCK IOSB;
2585 ULONG TdiAddressSize;
2586 PTRANSPORT_ADDRESS SocketAddress;
2590
2591 /* Get the Socket Structure associate to this Socket*/
2593 if (!Socket)
2594 {
2597 }
2598
2600 {
2603 }
2604
2606 {
2609 }
2610
2612 EVENT_ALL_ACCESS,
2613 NULL,
2614 SynchronizationEvent,
2615 FALSE);
2616
2619
2620 /* Allocate a buffer for the address */
2623
2625 {
2629 }
2630
2631 /* Send IOCTL */
2633 SockEvent,
2634 NULL,
2635 NULL,
2636 &IOSB,
2637 IOCTL_AFD_GET_PEER_NAME,
2638 NULL,
2639 0,
2640 SocketAddress,
2641 TdiAddressSize);
2642
2643 /* Wait for return */
2645 {
2648 }
2649
2651
2653 {
2655 {
2665 return 0;
2666 }
2667 else
2668 {
2672 }
2673 }
2674
2676
2678}
Definition: tdi.h:375
struct _TRANSPORT_ADDRESS TRANSPORT_ADDRESS
Referenced by WSPStartup().
◆ WSPGetSockName()
| INT WSPAPI WSPGetSockName | ( | IN SOCKET | Handle, |
| OUT LPSOCKADDR | Name, | ||
| IN OUT LPINT | NameLength, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 2477 of file dllmain.c.
2481{
2482 IO_STATUS_BLOCK IOSB;
2483 ULONG TdiAddressSize;
2484 PTDI_ADDRESS_INFO TdiAddress;
2485 PTRANSPORT_ADDRESS SocketAddress;
2489
2490 /* Get the Socket Structure associate to this Socket*/
2492 if (!Socket)
2493 {
2496 }
2497
2499 {
2502 }
2503
2505 EVENT_ALL_ACCESS,
2506 NULL,
2507 SynchronizationEvent,
2508 FALSE);
2509
2512
2513 /* Allocate a buffer for the address */
2514 TdiAddressSize =
2517
2519 {
2523 }
2524
2525 SocketAddress = &TdiAddress->Address;
2526
2527 /* Send IOCTL */
2529 SockEvent,
2530 NULL,
2531 NULL,
2532 &IOSB,
2533 IOCTL_AFD_GET_SOCK_NAME,
2534 NULL,
2535 0,
2536 TdiAddress,
2537 TdiAddressSize);
2538
2539 /* Wait for return */
2541 {
2544 }
2545
2547
2549 {
2551 {
2561 return 0;
2562 }
2563 else
2564 {
2568 }
2569 }
2570
2572
2574}
Definition: tdi.h:386
Referenced by WSPStartup().
◆ WSPGetSockOpt()
| INT WSPAPI WSPGetSockOpt | ( | IN SOCKET | Handle, |
| IN INT | Level, | ||
| IN INT | OptionName, | ||
| OUT CHAR FAR * | OptionValue, | ||
| IN OUT LPINT | OptionLength, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 2925 of file dllmain.c.
2931{
2935 BOOL BoolBuffer;
2936 DWORD DwordBuffer;
2937 INT Errno;
2938
2940
2941 /* Get the Socket Structure associate to this Socket*/
2944 {
2947 }
2948 if (!OptionLength || !OptionValue)
2949 {
2952 }
2953
2955 {
2957 switch (OptionName)
2958 {
2962 break;
2963
2967 break;
2968
2972 break;
2973
2976 Buffer = &BoolBuffer;
2978 break;
2979
2982 Buffer = &BoolBuffer;
2984 break;
2985
2988 Buffer = &BoolBuffer;
2990 break;
2991
2994 Buffer = &BoolBuffer;
2996 break;
2997
3000 {
3003 }
3006 break;
3007
3010 Buffer = &BoolBuffer;
3012 break;
3013
3016 /* These guys go directly to the helper */
3017 goto SendToHelper;
3018
3021 Buffer = &BoolBuffer;
3023 break;
3024
3027 Buffer = &BoolBuffer;
3029 break;
3030
3033 Buffer = &BoolBuffer;
3035 break;
3036
3040 break;
3041
3045 else
3046 DwordBuffer = -1;
3047 Buffer = &DwordBuffer;
3049 break;
3050
3054 break;
3058 break;
3062 break;
3063
3067
3068 default:
3072 }
3073
3075 {
3077 *OptionLength = BufferSize;
3079 }
3081
3082 return 0;
3083
3084 default:
3087 }
3088
3089SendToHelper:
3091 Handle,
3092 Socket->TdiAddressHandle,
3093 Socket->TdiConnectionHandle,
3094 Level,
3095 OptionName,
3096 OptionValue,
3097 (LPINT)OptionLength);
3098 if (lpErrno) *lpErrno = Errno;
3100}
PWSH_GET_SOCKET_INFORMATION WSHGetSocketInformation
Definition: helpers.h:26
Definition: winsock.h:135
Referenced by WSPStartup().
◆ WSPIoctl()
| INT WSPAPI WSPIoctl | ( | IN SOCKET | Handle, |
| IN DWORD | dwIoControlCode, | ||
| IN LPVOID | lpvInBuffer, | ||
| IN DWORD | cbInBuffer, | ||
| OUT LPVOID | lpvOutBuffer, | ||
| IN DWORD | cbOutBuffer, | ||
| OUT LPDWORD | lpcbBytesReturned, | ||
| IN LPWSAOVERLAPPED | lpOverlapped, | ||
| IN LPWSAOVERLAPPED_COMPLETION_ROUTINE | lpCompletionRoutine, | ||
| IN LPWSATHREADID | lpThreadId, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 2682 of file dllmain.c.
2693{
2696 BOOLEAN NonBlocking;
2698 DWORD cbRet = 0;
2699
2700 /* Get the Socket Structure associate to this Socket*/
2702 if (!Socket)
2703 {
2704 if(lpErrno)
2705 *lpErrno = WSAENOTSOCK;
2707 }
2708
2710 {
2711 if(lpErrno)
2712 *lpErrno = WSAEFAULT;
2714 }
2715
2717 {
2720 {
2721 Errno = WSAEFAULT;
2722 break;
2723 }
2725 /* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
2726 if (!NonBlocking)
2727 {
2728 /* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
2730 {
2731 Errno = WSAEINVAL;
2732 break;
2733 }
2734 /* If there is an WSPEventSelect pending, fail with WSAEINVAL */
2736 {
2737 Errno = WSAEINVAL;
2738 break;
2739 }
2740 }
2742 NeedsCompletion = FALSE;
2743 Errno = SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &NonBlocking, NULL, NULL, lpOverlapped, lpCompletionRoutine);
2745 Ret = NO_ERROR;
2746 break;
2749 {
2751 Errno = WSAEFAULT;
2752 break;
2753 }
2755 {
2756 Errno = WSAEINVAL;
2757 break;
2758 }
2759 NeedsCompletion = FALSE;
2760 Errno = GetSocketInformation(Socket, AFD_INFO_RECEIVE_CONTENT_SIZE, NULL, (PULONG)lpvOutBuffer, NULL, lpOverlapped, lpCompletionRoutine);
2762 {
2764 Ret = NO_ERROR;
2765 }
2766 break;
2769 {
2771 Errno = WSAEFAULT;
2772 break;
2773 }
2775 {
2776 Errno = WSAEINVAL;
2777 break;
2778 }
2780 {
2781 Errno = WSAEINVAL;
2782 break;
2783 }
2784
2785 /* FIXME: Return false if OOBINLINE is true for now
2786 We should MSG_PEEK|MSG_OOB check with driver
2787 */
2789
2791 Errno = NO_ERROR;
2792 Ret = NO_ERROR;
2793 break;
2795 if (cbOutBuffer == 0)
2796 {
2798 Errno = WSAEFAULT;
2799 break;
2800 }
2801
2804 {
2805 Errno = WSAEINVAL;
2806 break;
2807 }
2808
2809 {
2811 GUID ConnectExGUID = WSAID_CONNECTEX;
2812 GUID DisconnectExGUID = WSAID_DISCONNECTEX;
2814
2816 {
2819 Errno = NO_ERROR;
2820 Ret = NO_ERROR;
2821 }
2823 {
2826 Errno = NO_ERROR;
2827 Ret = NO_ERROR;
2828 }
2830 {
2833 Errno = NO_ERROR;
2834 Ret = NO_ERROR;
2835 }
2837 {
2840 Errno = NO_ERROR;
2841 Ret = NO_ERROR;
2842 }
2843 else
2844 {
2846 Errno = WSAEOPNOTSUPP;
2847 }
2848 }
2849
2850 break;
2853 {
2855 Errno = WSAEFAULT;
2856 break;
2857 }
2859 {
2860 Errno = WSAEINVAL;
2861 break;
2862 }
2863
2865
2866 ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->iAddressCount = 1;
2867
2869 {
2870 Errno = WSAEFAULT;
2871 break;
2872 }
2873
2874 ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].iSockaddrLength = sizeof(Socket->SharedData->WSLocalAddress);
2875 ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].lpSockaddr = &Socket->SharedData->WSLocalAddress;
2876
2877 Errno = NO_ERROR;
2878 Ret = NO_ERROR;
2879 break;
2880 default:
2882 Handle,
2883 Socket->TdiAddressHandle,
2884 Socket->TdiConnectionHandle,
2885 dwIoControlCode,
2886 lpvInBuffer,
2887 cbInBuffer,
2888 lpvOutBuffer,
2889 cbOutBuffer,
2890 &cbRet,
2891 lpOverlapped,
2892 lpCompletionRoutine,
2893 &NeedsCompletion);
2894
2896 Ret = NO_ERROR;
2897 break;
2898 }
2900 {
2901 lpOverlapped->Internal = Errno;
2902 lpOverlapped->InternalHigh = cbRet;
2904 {
2905 lpCompletionRoutine(Errno, cbRet, lpOverlapped, 0);
2906 }
2910 {
2912 }
2914 }
2915 if (lpErrno)
2916 *lpErrno = Errno;
2917 if (lpcbBytesReturned)
2918 *lpcbBytesReturned = cbRet;
2919 return Ret;
2920}
BOOL WSPAPI WSPConnectEx(_In_ SOCKET Handle, _In_ const struct sockaddr *SocketAddress, _In_ int SocketAddressLength, _In_ PVOID lpSendBuffer, _In_ DWORD dwSendDataLength, _Out_ LPDWORD lpdwBytesSent, _Inout_ LPOVERLAPPED lpOverlapped)
Definition: dllmain.c:2298
VOID WSPAPI WSPGetAcceptExSockaddrs(IN PVOID lpOutputBuffer, IN DWORD dwReceiveDataLength, IN DWORD dwLocalAddressLength, IN DWORD dwRemoteAddressLength, OUT struct sockaddr **LocalSockaddr, OUT LPINT LocalSockaddrLength, OUT struct sockaddr **RemoteSockaddr, OUT LPINT RemoteSockaddrLength)
Definition: dllmain.c:1934
int SetSocketInformation(PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
Definition: dllmain.c:3838
BOOL WSPAPI WSPAcceptEx(_In_ SOCKET sListenSocket, _In_ SOCKET sAcceptSocket, _Out_ PVOID lpOutputBuffer, _In_ DWORD dwReceiveDataLength, _In_ DWORD dwLocalAddressLength, _In_ DWORD dwRemoteAddressLength, _Out_ LPDWORD lpdwBytesReceived, _Inout_ LPOVERLAPPED lpOverlapped)
Definition: dllmain.c:1847
BOOL WSPAPI WSPDisconnectEx(IN SOCKET hSocket, IN LPOVERLAPPED lpOverlapped, IN DWORD dwFlags, IN DWORD reserved)
Definition: stubs.c:58
Definition: shobjidl.idl:3066
BOOL WINAPI PostQueuedCompletionStatus(IN HANDLE CompletionHandle, IN DWORD dwNumberOfBytesTransferred, IN ULONG_PTR dwCompletionKey, IN LPOVERLAPPED lpOverlapped)
Definition: iocompl.c:192
Definition: ws2def.h:385
struct _SOCKET_ADDRESS_LIST SOCKET_ADDRESS_LIST
#define SIO_GET_EXTENSION_FUNCTION_POINTER
Definition: ws2def.h:167
Referenced by WSPStartup().
◆ WSPListen()
Definition at line 998 of file dllmain.c.
1001{
1002 IO_STATUS_BLOCK IOSB;
1003 AFD_LISTEN_DATA ListenData;
1007
1008 /* Get the Socket Structure associate to this Socket*/
1010 if (!Socket)
1011 {
1014 }
1015
1018
1020 EVENT_ALL_ACCESS,
1021 NULL,
1022 SynchronizationEvent,
1023 FALSE);
1024
1027
1028 /* Set Up Listen Structure */
1031 ListenData.Backlog = Backlog;
1032
1033 /* Send IOCTL */
1035 SockEvent,
1036 NULL,
1037 NULL,
1038 &IOSB,
1039 IOCTL_AFD_START_LISTEN,
1040 &ListenData,
1041 sizeof(ListenData),
1042 NULL,
1043 0);
1044
1045 /* Wait for return */
1047 {
1050 }
1051
1053
1057
1058 /* Set to Listening */
1060
1062 {
1064 Socket->Handle,
1065 Socket->TdiAddressHandle,
1066 Socket->TdiConnectionHandle,
1067 WSH_NOTIFY_LISTEN);
1068
1070 {
1073 }
1074 }
1075
1077}
Definition: shared.h:43
Referenced by WSPStartup().
◆ WSPSelect()
| int WSPAPI WSPSelect | ( | IN int | nfds, |
| IN OUT fd_set *readfds | OPTIONAL, | ||
| IN OUT fd_set *writefds | OPTIONAL, | ||
| IN OUT fd_set *exceptfds | OPTIONAL, | ||
| IN const struct timeval *timeout | OPTIONAL, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 1082 of file dllmain.c.
1088{
1089 IO_STATUS_BLOCK IOSB;
1090 PAFD_POLL_INFO PollInfo;
1093 ULONG PollBufferSize;
1094 PVOID PollBuffer;
1098 PSOCKET_INFORMATION Socket;
1101 fd_set selectfds;
1102
1103 /* Find out how many sockets we have, and how large the buffer needs
1104 * to be */
1105 FD_ZERO(&selectfds);
1107 {
1109 {
1111 }
1112 }
1114 {
1116 {
1118 }
1119 }
1121 {
1123 {
1125 }
1126 }
1127
1129
1131 {
1135 }
1136
1138
1140
1141 /* Convert Timeout to NT Format */
1143 {
1144 Timeout.u.LowPart = -1;
1145 Timeout.u.HighPart = 0x7FFFFFFF;
1147 }
1148 else
1149 {
1152 /* Negative timeouts are illegal. Since the kernel represents an
1153 * incremental timeout as a negative number, we check for a positive
1154 * result.
1155 */
1157 {
1160 }
1163 Timeout.u.LowPart);
1164 }
1165
1167 EVENT_ALL_ACCESS,
1168 NULL,
1169 SynchronizationEvent,
1170 FALSE);
1171
1173 {
1174 if (lpErrno)
1175 *lpErrno = WSAEFAULT;
1176
1179 }
1180
1181 /* Allocate */
1183
1184 if (!PollBuffer)
1185 {
1186 if (lpErrno)
1187 *lpErrno = WSAEFAULT;
1190 }
1191
1192 PollInfo = (PAFD_POLL_INFO)PollBuffer;
1193
1194 RtlZeroMemory( PollInfo, PollBufferSize );
1195
1196 /* Number of handles for AFD to Check */
1199
1201 {
1203 }
1206 {
1208 {
1210 break;
1211 }
1213 {
1219 }
1221 if (!Socket)
1222 {
1228 }
1230 AFD_EVENT_DISCONNECT |
1231 AFD_EVENT_ABORT |
1232 AFD_EVENT_CLOSE |
1233 AFD_EVENT_ACCEPT;
1234 //if (Socket->SharedData->OobInline != 0)
1235 // PollInfo->Handles[j].Events |= AFD_EVENT_OOB_RECEIVE;
1236 }
1237 }
1239 {
1241 {
1243 {
1245 break;
1246 }
1248 {
1254 }
1256 if (!Socket)
1257 {
1263 }
1268 }
1269 }
1271 {
1273 {
1275 {
1277 break;
1278 }
1280 {
1286 }
1288 if (!Socket)
1289 {
1295 }
1301 }
1302 }
1303
1305 PollBufferSize = FIELD_OFFSET(AFD_POLL_INFO, Handles) + PollInfo->HandleCount * sizeof(AFD_HANDLE);
1306
1307 /* Send IOCTL */
1309 SockEvent,
1310 NULL,
1311 NULL,
1312 &IOSB,
1313 IOCTL_AFD_SELECT,
1314 PollInfo,
1315 PollBufferSize,
1316 PollInfo,
1317 PollBufferSize);
1318
1320
1321 /* Wait for Completion */
1323 {
1326 }
1327
1328 /* Clear the Structures */
1329 if( readfds )
1330 FD_ZERO(readfds);
1331 if( writefds )
1332 FD_ZERO(writefds);
1333 if( exceptfds )
1334 FD_ZERO(exceptfds);
1335
1336 /* Loop through return structure */
1338
1339 /* Return in FDSET Format */
1341 {
1345 {
1347 if (!Socket)
1348 {
1354 }
1356 {
1363 Events,
1364 Handle);
1369 if( readfds )
1371 break;
1374 Events,
1375 Handle);
1376 if (writefds)
1378 break;
1381 Events,
1382 Handle);
1385 break;
1388 Events,
1389 Handle);
1394 break;
1397 Events,
1398 Handle);
1401 break;
1402 }
1403 }
1404 }
1405
1408
1409 if( lpErrno )
1410 {
1412 {
1415 *lpErrno = 0;
1416 break;
1417 default:
1418 *lpErrno = WSAEINVAL;
1419 break;
1420 }
1422 }
1423
1424 HandleCount = (readfds ? readfds->fd_count : 0) +
1425 (writefds && writefds != readfds ? writefds->fd_count : 0) +
1426 (exceptfds && exceptfds != readfds && exceptfds != writefds ? exceptfds->fd_count : 0);
1427
1429
1431}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Definition: shared.h:49
Definition: shared.h:55
Definition: dhcpd.h:248
Definition: typedefs.h:103
NTSYSAPI LONGLONG WINAPI RtlEnlargedIntegerMultiply(INT, INT)
Referenced by select(), WSPAccept(), and WSPStartup().
◆ WSPSetSockOpt()
| INT WSPAPI WSPSetSockOpt | ( | IN SOCKET | s, |
| IN INT | level, | ||
| IN INT | optname, | ||
| IN CONST CHAR FAR * | optval, | ||
| IN INT | optlen, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 3214 of file dllmain.c.
3221{
3222 PSOCKET_INFORMATION Socket;
3223 INT Errno;
3224
3225 /* Get the Socket Structure associate to this Socket*/
3228 {
3231 }
3232 if (!optval && optlen)
3233 {
3236 }
3237
3238
3239 /* FIXME: We should handle some more cases here */
3241 {
3242 switch (optname)
3243 {
3246 {
3249 }
3252
3255 {
3258 }
3261
3264 {
3267 }
3270
3273 {
3276 }
3279
3282 {
3285 }
3288
3291 {
3294 }
3296 optval,
3299
3302 {
3305 }
3306
3307 SetSocketInformation(Socket,
3309 NULL,
3310 (PULONG)optval,
3311 NULL,
3312 NULL,
3313 NULL);
3314 GetSocketInformation(Socket,
3316 NULL,
3318 NULL,
3319 NULL,
3320 NULL);
3321
3323
3326 {
3329 }
3330
3331 /* FIXME: We should not have to limit the packet receive buffer size like this. workaround for CORE-15804 */
3333 *(PULONG)optval = 0x2000;
3334
3335 SetSocketInformation(Socket,
3337 NULL,
3338 (PULONG)optval,
3339 NULL,
3340 NULL,
3341 NULL);
3342 GetSocketInformation(Socket,
3344 NULL,
3346 NULL,
3347 NULL,
3348 NULL);
3349
3351
3352 case SO_UPDATE_CONNECT_CONTEXT:
3355
3358 {
3361 }
3362
3364 optval,
3367
3370 {
3373 }
3374
3376 optval,
3379
3382 {
3385 }
3386
3388 optval,
3391
3394 /* These go directly to the helper dll */
3395 goto SendToHelper;
3396
3397 default:
3398 /* Obviously this is a hack */
3401 }
3402 }
3403
3404SendToHelper:
3406 s,
3407 Socket->TdiAddressHandle,
3408 Socket->TdiConnectionHandle,
3409 level,
3410 optname,
3411 (PCHAR)optval,
3412 optlen);
3413 if (lpErrno) *lpErrno = Errno;
3415}
static INT NTAPI MsafdUpdateConnectionContext(_In_ SOCKET Handle, _Out_ LPINT lpErrno)
Definition: dllmain.c:3105
PWSH_SET_SOCKET_INFORMATION WSHSetSocketInformation
Definition: helpers.h:27
Referenced by WSPStartup().
◆ WSPShutdown()
Definition at line 2397 of file dllmain.c.
2401{
2402 IO_STATUS_BLOCK IOSB;
2403 AFD_DISCONNECT_INFO DisconnectInfo;
2407
2409
2410 /* Get the Socket Structure associate to this Socket*/
2412 if (!Socket)
2413 {
2416 }
2417
2419 EVENT_ALL_ACCESS,
2420 NULL,
2421 SynchronizationEvent,
2422 FALSE);
2423
2426
2427 /* Set AFD Disconnect Type */
2428 switch (HowTo)
2429 {
2433 break;
2437 break;
2442 break;
2443 }
2444
2446
2447 /* Send IOCTL */
2449 SockEvent,
2450 NULL,
2451 NULL,
2452 &IOSB,
2453 IOCTL_AFD_DISCONNECT,
2454 &DisconnectInfo,
2455 sizeof(DisconnectInfo),
2456 NULL,
2457 0);
2458
2459 /* Wait for return */
2461 {
2464 }
2465
2467
2469
2472}
Referenced by WSPStartup().
◆ WSPSocket()
| SOCKET WSPAPI WSPSocket | ( | int | AddressFamily, |
| int | SocketType, | ||
| int | Protocol, | ||
| LPWSAPROTOCOL_INFOW | lpProtocolInfo, | ||
| GROUP | g, | ||
| DWORD | dwFlags, | ||
| LPINT | lpErrno | ||
| ) |
Definition at line 48 of file dllmain.c.
55{
57 IO_STATUS_BLOCK IOSB;
58 USHORT SizeOfPacket;
59 ULONG SizeOfEA;
60 PAFD_CREATE_PACKET AfdPacket;
61 HANDLE Sock;
64 PHELPER_DATA HelperData;
65 PVOID HelperDLLContext;
66 DWORD HelperEvents;
67 UNICODE_STRING TransportName;
68 UNICODE_STRING DevName;
72
75
76 if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags3 != 0 && lpProtocolInfo->dwServiceFlags4 != 0)
77 {
78 /* Duplpicating socket from different process */
80 {
83 }
85 {
88 }
91 0,
92 0,
94 if (!SharedData)
95 {
98 }
103 }
104
106 {
109 }
110
111 /* Set the defaults */
114
116 {
118 {
121 break;
124 break;
127 break;
128 default:
131 break;
132 }
133 }
134
136 {
138 {
141 break;
144 break;
147 break;
148 default:
151 break;
152 }
153 }
154
155 /* Get Helper Data and Transport */
157 &SocketType,
158 &Protocol,
159 g,
160 dwFlags,
161 &TransportName,
162 &HelperDLLContext,
163 &HelperData,
164 &HelperEvents);
165
166 /* Check for error */
168 {
171 }
172
173 /* AFD Device Name */
175
176 /* Set Socket Data */
178 if (!Socket)
179 {
182 }
184 if (SharedData)
185 {
186 Socket->SharedData = SharedData;
190 }
191 else
192 {
196 {
199 }
218
219 /* Ask alex about this */
222 {
225 }
227 }
228
229 Socket->HelperContext = HelperDLLContext;
230 Socket->HelperData = HelperData;
231 Socket->HelperEvents = HelperEvents;
236 if (SharedData)
238
239 /* Packet Size */
241
242 /* EA Size */
244
245 /* Set up EA Buffer */
247 if (!EABuffer)
248 {
251 }
252
253 RtlZeroMemory(EABuffer, SizeOfEA);
254 EABuffer->NextEntryOffset = 0;
255 EABuffer->Flags = 0;
256 EABuffer->EaNameLength = AFD_PACKET_COMMAND_LENGTH;
257 RtlCopyMemory (EABuffer->EaName,
258 AfdCommand,
259 AFD_PACKET_COMMAND_LENGTH + 1);
260 EABuffer->EaValueLength = SizeOfPacket;
261
262 /* Set up AFD Packet */
263 AfdPacket = (PAFD_CREATE_PACKET)(EABuffer->EaName + EABuffer->EaNameLength + 1);
266 TransportName.Buffer,
269
270 /* Set up Endpoint Flags */
272 {
274 {
275 /* Only RAW or UDP can be Connectionless */
278 }
280 }
281
283 {
285 {
287 {
288 /* The Provider doesn't actually support Message Oriented Streams */
291 }
292 }
294 }
295
297
302 {
304 {
305 /* The Provider doesn't actually support Multipoint */
308 }
310
312 {
315 {
316 /* The Provider doesn't support Control Planes, or you already gave a leaf */
319 }
321 }
322
324 {
327 {
328 /* The Provider doesn't support Data Planes, or you already gave a leaf */
331 }
333 }
334 }
335
336 /* Set up Object Attributes */
338 &DevName,
340 0,
341 0);
342
343 /* Create the Socket as asynchronous. That means we have to block
344 ourselves after every call to NtDeviceIoControlFile. This is
345 because the kernel doesn't support overlapping synchronous I/O
346 requests (made from multiple threads) at this time (Sep 2005) */
349 &Object,
350 &IOSB,
351 NULL,
352 0,
354 FILE_OPEN_IF,
355 0,
356 EABuffer,
357 SizeOfEA);
358
360
362 {
366 }
367
368 /* Save Handle */
370
371 /* Save Group Info */
373 {
374 GetSocketInformation(Socket,
376 NULL,
377 NULL,
378 &GroupData,
379 NULL,
380 NULL);
383 }
384
385 /* Get Window Sizes and Save them */
386 GetSocketInformation (Socket,
388 NULL,
390 NULL,
391 NULL,
392 NULL);
393
394 GetSocketInformation (Socket,
396 NULL,
398 NULL,
399 NULL,
400 NULL);
401ok:
402
403 /* Save in Process Sockets List */
406 SocketListHead = Socket;
408
409 /* Create the Socket Context */
410 CreateContext(Socket);
411
412 /* Notify Winsock */
414
415 /* Return Socket Handle */
417
419
420error:
422
423 if( SharedData )
424 {
425 UnmapViewOfFile(SharedData);
427 }
428 else
429 {
432 }
433
434 if( Socket )
436
437 if( EABuffer )
439
440 if( lpErrno )
441 *lpErrno = Status;
442
444}
int SockGetTdiName(PINT AddressFamily, PINT SocketType, PINT Protocol, GROUP Group, DWORD Flags, PUNICODE_STRING TransportName, PVOID *HelperDllContext, PHELPER_DATA *HelperDllData, PDWORD Events)
Definition: helpers.c:22
struct _FILE_FULL_EA_INFORMATION FILE_FULL_EA_INFORMATION
Definition: dplay_global.h:111
Definition: urlmon_main.h:93
Definition: shared.h:21
Definition: from_kernel.h:193
Definition: helpers.h:12
LPWPUMODIFYIFSHANDLE lpWPUModifyIFSHandle
Definition: ws2spi.h:608
Referenced by WSPAccept(), and WSPStartup().
◆ WSPStartup()
| _Must_inspect_result_ int WSPAPI WSPStartup | ( | _In_ WORD | wVersionRequested, |
| _In_ LPWSPDATA | lpWSPData, | ||
| _In_ LPWSAPROTOCOL_INFOW | lpProtocolInfo, | ||
| _In_ WSPUPCALLTABLE | UpcallTable, | ||
| _Out_ LPWSPPROC_TABLE | lpProcTable | ||
| ) |
Definition at line 3431 of file dllmain.c.
3437{
3439
3441 (LOBYTE(wVersionRequested) < 2))
3442 {
3445 }
3446 else
3448 /* FIXME: Enable all cases of WSPStartup status */
3449 Upcalls = UpcallTable;
3450
3452 {
3453 lpProcTable->lpWSPAccept = WSPAccept;
3454 lpProcTable->lpWSPAddressToString = WSPAddressToString;
3455 lpProcTable->lpWSPAsyncSelect = WSPAsyncSelect;
3456 lpProcTable->lpWSPBind = WSPBind;
3457 lpProcTable->lpWSPCancelBlockingCall = WSPCancelBlockingCall;
3458 lpProcTable->lpWSPCleanup = WSPCleanup;
3459 lpProcTable->lpWSPCloseSocket = WSPCloseSocket;
3460 lpProcTable->lpWSPConnect = WSPConnect;
3461 lpProcTable->lpWSPDuplicateSocket = WSPDuplicateSocket;
3462 lpProcTable->lpWSPEnumNetworkEvents = WSPEnumNetworkEvents;
3463 lpProcTable->lpWSPEventSelect = WSPEventSelect;
3464 lpProcTable->lpWSPGetOverlappedResult = WSPGetOverlappedResult;
3465 lpProcTable->lpWSPGetPeerName = WSPGetPeerName;
3466 lpProcTable->lpWSPGetSockName = WSPGetSockName;
3467 lpProcTable->lpWSPGetSockOpt = WSPGetSockOpt;
3468 lpProcTable->lpWSPGetQOSByName = WSPGetQOSByName;
3469 lpProcTable->lpWSPIoctl = WSPIoctl;
3470 lpProcTable->lpWSPJoinLeaf = WSPJoinLeaf;
3471 lpProcTable->lpWSPListen = WSPListen;
3472 lpProcTable->lpWSPRecv = WSPRecv;
3473 lpProcTable->lpWSPRecvDisconnect = WSPRecvDisconnect;
3474 lpProcTable->lpWSPRecvFrom = WSPRecvFrom;
3475 lpProcTable->lpWSPSelect = WSPSelect;
3476 lpProcTable->lpWSPSend = WSPSend;
3477 lpProcTable->lpWSPSendDisconnect = WSPSendDisconnect;
3478 lpProcTable->lpWSPSendTo = WSPSendTo;
3479 lpProcTable->lpWSPSetSockOpt = WSPSetSockOpt;
3480 lpProcTable->lpWSPShutdown = WSPShutdown;
3481 lpProcTable->lpWSPSocket = WSPSocket;
3482 lpProcTable->lpWSPStringToAddress = WSPStringToAddress;
3483 lpWSPData->wVersion = MAKEWORD(2, 2);
3484 lpWSPData->wHighVersion = MAKEWORD(2, 2);
3485 /* Save CatalogEntryId for all upcalls */
3486 CatalogEntryId = lpProtocolInfo->dwCatalogEntryId;
3487 }
3488
3491}
INT WSPAPI WSPAddressToString(IN LPSOCKADDR lpsaAddress, IN DWORD dwAddressLength, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPWSTR lpszAddressString, IN OUT LPDWORD lpdwAddressStringLength, OUT LPINT lpErrno)
Definition: dllmain.c:3496
INT WSPAPI WSPSetSockOpt(IN SOCKET s, IN INT level, IN INT optname, IN CONST CHAR FAR *optval, IN INT optlen, OUT LPINT lpErrno)
Definition: dllmain.c:3214
int WSPAPI WSPConnect(SOCKET Handle, const struct sockaddr *SocketAddress, int SocketAddressLength, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS, LPINT lpErrno)
Definition: dllmain.c:2017
INT WSPAPI WSPGetSockOpt(IN SOCKET Handle, IN INT Level, IN INT OptionName, OUT CHAR FAR *OptionValue, IN OUT LPINT OptionLength, OUT LPINT lpErrno)
Definition: dllmain.c:2925
INT WSPAPI WSPGetPeerName(IN SOCKET s, OUT LPSOCKADDR Name, IN OUT LPINT NameLength, OUT LPINT lpErrno)
Definition: dllmain.c:2579
INT WSPAPI WSPDuplicateSocket(IN SOCKET Handle, IN DWORD dwProcessId, OUT LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPINT lpErrno)
Definition: dllmain.c:449
int WSPAPI WSPShutdown(SOCKET Handle, int HowTo, LPINT lpErrno)
Definition: dllmain.c:2397
INT WSPAPI WSPStringToAddress(IN LPWSTR AddressString, IN INT AddressFamily, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPSOCKADDR lpAddress, IN OUT LPINT lpAddressLength, OUT LPINT lpErrno)
Definition: dllmain.c:3556
INT WSPAPI WSPIoctl(IN SOCKET Handle, IN DWORD dwIoControlCode, IN LPVOID lpvInBuffer, IN DWORD cbInBuffer, OUT LPVOID lpvOutBuffer, IN DWORD cbOutBuffer, OUT LPDWORD lpcbBytesReturned, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT LPINT lpErrno)
Definition: dllmain.c:2682
_Must_inspect_result_ SOCKET WSPAPI WSPAccept(_In_ SOCKET Handle, _Out_writes_bytes_to_opt_(*addrlen, *addrlen) struct sockaddr FAR *SocketAddress, _Inout_opt_ LPINT SocketAddressLength, _In_opt_ LPCONDITIONPROC lpfnCondition, _In_opt_ DWORD_PTR dwCallbackData, _Out_ LPINT lpErrno)
Definition: dllmain.c:1451
INT WSPAPI WSPGetSockName(IN SOCKET Handle, OUT LPSOCKADDR Name, IN OUT LPINT NameLength, OUT LPINT lpErrno)
Definition: dllmain.c:2477
INT WSPAPI WSPEnumNetworkEvents(IN SOCKET Handle, IN WSAEVENT hEventObject, OUT LPWSANETWORKEVENTS lpNetworkEvents, OUT LPINT lpErrno)
Definition: event.c:133
int WSPAPI WSPEventSelect(IN SOCKET Handle, IN WSAEVENT hEventObject, IN long lNetworkEvents, OUT LPINT lpErrno)
Definition: event.c:17
SOCKET WSPAPI WSPJoinLeaf(IN SOCKET s, IN CONST SOCKADDR *name, IN INT namelen, IN LPWSABUF lpCallerData, OUT LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, IN DWORD dwFlags, OUT LPINT lpErrno)
Definition: stubs.c:40
BOOL WSPAPI WSPGetQOSByName(IN SOCKET s, IN OUT LPWSABUF lpQOSName, OUT LPQOS lpQOS, OUT LPINT lpErrno)
Definition: stubs.c:26
INT WSPAPI WSPSendDisconnect(IN SOCKET s, IN LPWSABUF lpOutboundDisconnectData, OUT LPINT lpErrno)
Definition: sndrcv.c:1064
int WSPAPI WSPRecvFrom(SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRead, LPDWORD ReceiveFlags, struct sockaddr *SocketAddress, int *SocketAddressLength, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
Definition: sndrcv.c:430
BOOL WSPAPI WSPGetOverlappedResult(IN SOCKET Handle, IN LPWSAOVERLAPPED lpOverlapped, OUT LPDWORD lpdwBytes, IN BOOL fWait, OUT LPDWORD lpdwFlags, OUT LPINT lpErrno)
Definition: sndrcv.c:96
INT WSPAPI WSPAsyncSelect(IN SOCKET Handle, IN HWND hWnd, IN UINT wMsg, IN LONG lEvent, OUT LPINT lpErrno)
Definition: sndrcv.c:17
int WSPAPI WSPSendTo(SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD iFlags, const struct sockaddr *SocketAddress, int SocketAddressLength, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
Definition: sndrcv.c:843
int WSPAPI WSPSend(SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD iFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
Definition: sndrcv.c:668
int WSPAPI WSPRecv(SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRead, LPDWORD ReceiveFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
Definition: sndrcv.c:221
INT WSPAPI WSPRecvDisconnect(IN SOCKET s, OUT LPWSABUF lpInboundDisconnectData, OUT LPINT lpErrno)
Definition: sndrcv.c:1052
◆ WSPStringToAddress()
| INT WSPAPI WSPStringToAddress | ( | IN LPWSTR | AddressString, |
| IN INT | AddressFamily, | ||
| IN LPWSAPROTOCOL_INFOW | lpProtocolInfo, | ||
| OUT LPSOCKADDR | lpAddress, | ||
| IN OUT LPINT | lpAddressLength, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 3556 of file dllmain.c.
3562{
3563 int numdots = 0;
3565 LONG inetaddr = 0, ip_part;
3568
3569 if (!lpAddressLength || !lpAddress || !AddressString)
3570 {
3573 }
3574
3576
3577 /* Set right address family */
3579 {
3580 sockaddr->sin_family = lpProtocolInfo->iAddressFamily;
3581 }
3582 else
3583 {
3585 }
3586
3587 /* Report size */
3589 {
3591 {
3593 }
3594 else
3595 {
3596 // translate ip string to ip
3597
3598 /* Get ip number */
3599 bp = &AddressString;
3600 inetaddr = 0;
3601
3603 {
3604 ip_part = wcstol(*bp, bp, 10);
3605 /* ip part number should be in range 0-255 */
3606 if (ip_part < 0 || ip_part > 255)
3607 {
3610 }
3611 inetaddr = (inetaddr << 8) + ip_part;
3612 /* we end on string end or port separator */
3614 break;
3615 /* ip parts are dot separated. verify it */
3617 {
3620 }
3621 /* count the dots */
3622 numdots++;
3623 /* move over the dot to next ip part */
3624 (*bp)++;
3625 }
3626
3627 /* check dots count */
3628 if (numdots != 3)
3629 {
3632 }
3633
3634 /* Get port number */
3636 {
3637 /* move over the column to port part */
3638 (*bp)++;
3639 /* next char should be numeric */
3641 {
3644 }
3646 }
3647 else
3648 {
3649 port = 0;
3650 }
3651
3653 /* rest sockaddr.sin_addr.s_addr
3654 for we need to be sure it is zero when we come to while */
3655 *lpAddressLength = sizeof(*sockaddr);
3658 sockaddr->sin_addr.s_addr = inetaddr;
3660 }
3661 }
3662
3663 if (lpErrno && !*lpErrno)
3664 {
3665 return 0;
3666 }
3667
3669}
Referenced by WSPStartup().
Variable Documentation
◆ CatalogEntryId
| DWORD CatalogEntryId |
Definition at line 21 of file dllmain.c.
Referenced by WSAAddressToStringA(), WSAAddressToStringW(), WSAStringToAddressA(), WSAStringToAddressW(), WSPStartup(), and WsTcGetEntryFromCatalogEntryId().
◆ GlobalHeap
| HANDLE GlobalHeap |
Definition at line 19 of file dllmain.c.
Referenced by DllMain(), ExitThreadApc(), GetSocketInformation(), MsafdConnectAPC(), MsafdInfoAPC(), MsafdRecvAPC(), MsafdSendAPC(), SetSocketInformation(), SockGetTdiName(), SockLoadHelperDll(), SockLoadTransportList(), SockLoadTransportMapping(), WahCreateHandleContextTable(), WahDestroyHandleContextTable(), WahInsertHandleContext(), WahOpenHandleHelper(), Ws2HelpDllMain(), WSPAccept(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPDuplicateSocket(), WSPGetPeerName(), WSPGetSockName(), WSPRecv(), WSPRecvFrom(), WSPSelect(), WSPSend(), WSPSendTo(), and WSPSocket().
◆ lpWPUCompleteOverlappedRequest
| LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest |
◆ SockAsyncCompletionPort
Definition at line 28 of file dllmain.c.
Referenced by SockAsyncThread(), SockCreateOrReferenceAsyncThread(), SockGetAsyncSelectHelperAfdHandle(), SockReenableAsyncSelectEvent(), and WSPAsyncSelect().
◆ SockAsyncHelperAfdHandle
| HANDLE SockAsyncHelperAfdHandle |
Definition at line 27 of file dllmain.c.
Referenced by SockGetAsyncSelectHelperAfdHandle(), and SockProcessAsyncSelect().
◆ SockAsyncSelectCalled
| BOOLEAN SockAsyncSelectCalled |
Definition at line 29 of file dllmain.c.
Referenced by SockGetAsyncSelectHelperAfdHandle().
◆ SockAsyncThreadRefCount
| ULONG SockAsyncThreadRefCount |
Definition at line 26 of file dllmain.c.
Referenced by SockCreateOrReferenceAsyncThread().
◆ SocketListHead
| PSOCKET_INFORMATION SocketListHead = NULL |
Definition at line 23 of file dllmain.c.
Referenced by GetSocketStructure(), WSPCloseSocket(), and WSPSocket().
◆ SocketListLock
| CRITICAL_SECTION SocketListLock |
Definition at line 24 of file dllmain.c.
Referenced by DllMain(), GetSocketStructure(), WSPCloseSocket(), and WSPSocket().
◆ SockHelpersListHead
| LIST_ENTRY SockHelpersListHead = { NULL, NULL } |
Definition at line 25 of file dllmain.c.
Referenced by DllMain(), SockGetTdiName(), and SockLoadHelperDll().
◆ Upcalls
| WSPUPCALLTABLE Upcalls |
Definition at line 20 of file dllmain.c.
Referenced by SockAsyncSelectCompletionRoutine(), WSPSocket(), and WSPStartup().
