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 3868 of file dllmain.c.
3869{
3870 IO_STATUS_BLOCK IOSB;
3871 SOCKET_CONTEXT ContextData;
3874
3876 EVENT_ALL_ACCESS,
3877 NULL,
3878 SynchronizationEvent,
3879 FALSE);
3880
3883
3884 /* Create Context */
3886 ContextData.SizeOfHelperData = 0;
3888 Socket->LocalAddress,
3891 Socket->RemoteAddress,
3893
3894 /* Send IOCTL */
3896 SockEvent,
3897 NULL,
3898 NULL,
3899 &IOSB,
3900 IOCTL_AFD_SET_CONTEXT,
3901 &ContextData,
3902 sizeof(ContextData),
3903 NULL,
3904 0);
3905
3906 /* Wait for Completion */
3908 {
3911 }
3912
3914
3916}
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 4368 of file dllmain.c.
4371{
4372
4374 {
4376
4378
4379 /* Don't need thread attach notifications
4380 so disable them to improve performance */
4381 DisableThreadLibraryCalls(hInstDll);
4382
4383 /* List of DLL Helpers */
4385
4386 /* Heap to use when allocating */
4388
4389 /* Initialize the lock that protects our socket list */
4391
4393
4394 break;
4395
4397 break;
4398
4400 break;
4401
4403
4404 /* Delete the socket list lock */
4406
4407 break;
4408 }
4409
4411
4413}
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:158
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 3597 of file dllmain.c.
3604{
3605 PIO_STATUS_BLOCK IOSB;
3606 IO_STATUS_BLOCK DummyIOSB;
3607 PAFD_INFO InfoData;
3609 PMSAFD_INFO_APC_CONTEXT APCContext;
3610 PIO_APC_ROUTINE APCFunction;
3613
3615 if (!InfoData)
3617
3619 EVENT_ALL_ACCESS,
3620 NULL,
3621 SynchronizationEvent,
3622 FALSE);
3624 {
3627 }
3628
3629 /* Set Info Class */
3630 InfoData->InformationClass = AfdInformationClass;
3631
3632 /* Verify if we should use APC */
3633 if (!Overlapped)
3634 {
3635 /* Not using Overlapped structure, so use normal blocking on event */
3636 APCContext = NULL;
3637 APCFunction = NULL;
3639 IOSB = &DummyIOSB;
3640 }
3641 else
3642 {
3643 /* Overlapped request for non overlapped opened socket */
3645 {
3650 }
3651
3653 if (!APCContext)
3654 {
3659 }
3661 APCContext->lpOverlapped = Overlapped;
3662 APCContext->lpInfoData = InfoData;
3663 APCFunction = &MsafdInfoAPC;
3664
3666 Event = Overlapped->hEvent;
3667
3668 IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
3669 }
3670
3672
3673 /* Send IOCTL */
3675 Event,
3676 APCFunction,
3677 APCContext,
3678 IOSB,
3679 IOCTL_AFD_GET_INFO,
3680 InfoData,
3681 sizeof(*InfoData),
3682 InfoData,
3683 sizeof(*InfoData));
3684
3685 /* Wait for completion if not overlapped */
3687 {
3690 }
3691
3693
3695 {
3696 /* Return Information */
3698 {
3700 }
3702 {
3704 }
3706 {
3708 }
3709 }
3710
3712 if (!APCFunction)
3713 {
3714 /* When using APC, this will be freed by the APC function */
3716 }
3717
3719}
static VOID NTAPI MsafdInfoAPC(_In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved)
Definition: dllmain.c:3578
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: filtergraph.c:51
Definition: shared.h:28
union _AFD_INFO::@3574 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 3845 of file dllmain.c.
3846{
3847 PSOCKET_INFORMATION CurrentSocket;
3848
3850
3851 CurrentSocket = SocketListHead;
3852 while (CurrentSocket)
3853 {
3855 {
3857 return CurrentSocket;
3858 }
3859
3860 CurrentSocket = CurrentSocket->NextSocket;
3861 }
3862
3864
3866}
Definition: msafd.h:45
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
Referenced by MsafdConnectAPC(), MsafdUpdateConnectionContext(), WSPAccept(), 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 1848 of file dllmain.c.
1852{
1854
1855 TRACE("MsafdConnectAPC(%p %lx %lx)\n", ApcContext, IoStatusBlock->Status, IoStatusBlock->Information);
1856
1858 if (!Socket)
1859 {
1860 // FIXME: Socket is closed before this APC could run
1862 return;
1863 }
1864
1867 {
1871 }
1872
1873 /* Re-enable Async Event */
1875
1876 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1878
1880 {
1882 Socket->Handle,
1883 Socket->TdiAddressHandle,
1884 Socket->TdiConnectionHandle,
1885 WSH_NOTIFY_CONNECT);
1886 }
1887 else if (IoStatusBlock->Status != STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_CONNECT_ERROR))
1888 {
1890 Socket->Handle,
1891 Socket->TdiAddressHandle,
1892 Socket->TdiConnectionHandle,
1893 WSH_NOTIFY_CONNECT_ERROR);
1894 }
1895
1897}
VOID SockReenableAsyncSelectEvent(IN PSOCKET_INFORMATION Socket, IN ULONG Event)
Definition: dllmain.c:4321
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE _In_opt_ PVOID ApcContext
Definition: iofuncs.h:727
Definition: compobj.c:4795
Definition: msafd.h:106
Referenced by WSPConnect().
◆ MsafdInfoAPC()
|
static |
Definition at line 3578 of file dllmain.c.
3582{
3584
3585 TRACE("MsafdInfoAPC(%p %lx %lx)\n", ApcContext, IoStatusBlock->Status, IoStatusBlock->Information);
3586
3588 Context->lpCompletionRoutine(IoStatusBlock->Status, IoStatusBlock->Information, Context->lpOverlapped, 0);
3589
3590 /* Free IOCTL buffer */
3592
3594}
Referenced by GetSocketInformation(), and SetSocketInformation().
◆ MsafdUpdateConnectionContext()
Definition at line 2991 of file dllmain.c.
2994{
2995 IO_STATUS_BLOCK DummyIOSB;
2996 PIO_STATUS_BLOCK IOSB = &DummyIOSB;
2998 SOCK_SHARED_INFO SharedData;
2999 AFD_TDI_HANDLE_DATA HandleData;
3002
3003 if (!Socket)
3004 {
3007 }
3008
3010 {
3012 }
3013
3014 /* Get the socket context from AFD because when ConnectEx is used, this information is not updated. */
3016 EVENT_ALL_ACCESS,
3017 NULL,
3018 SynchronizationEvent,
3019 FALSE);
3021 goto Quit;
3022
3024 SockEvent,
3025 NULL,
3026 NULL,
3027 IOSB,
3028 IOCTL_AFD_GET_CONTEXT,
3029 NULL,
3030 0,
3031 &SharedData,
3032 sizeof(SharedData));
3033
3035 {
3038 }
3039
3041 goto Quit;
3042
3044
3045 /* Get TDI handles from AFD */
3047 SockEvent,
3048 NULL,
3049 NULL,
3050 IOSB,
3052 &flags,
3054 &HandleData,
3055 sizeof(HandleData));
3056
3058 {
3061 }
3062
3063 /* Bail out if the socket was destroyed */
3065 goto Quit;
3066
3068
3070 {
3071 /* Socket is now connected, update usermode msafd socket structure, same as the end of WSPConnect */
3075
3076 /* Re-enable Async Event */
3078
3079 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3081
3083 Socket->Handle,
3084 Socket->TdiAddressHandle,
3085 Socket->TdiConnectionHandle,
3086 WSH_NOTIFY_CONNECT);
3087 }
3088
3090
3091Quit:
3096}
Definition: shared.h:153
Definition: shared.h:369
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 3723 of file dllmain.c.
3730{
3731 PIO_STATUS_BLOCK IOSB;
3732 IO_STATUS_BLOCK DummyIOSB;
3733 PAFD_INFO InfoData;
3735 PMSAFD_INFO_APC_CONTEXT APCContext;
3736 PIO_APC_ROUTINE APCFunction;
3739
3741 if (!InfoData)
3743
3745 EVENT_ALL_ACCESS,
3746 NULL,
3747 SynchronizationEvent,
3748 FALSE);
3750 {
3753 }
3754
3755 /* Set Info Class */
3756 InfoData->InformationClass = AfdInformationClass;
3757
3758 /* Set Information */
3760 {
3762 }
3764 {
3766 }
3768 {
3770 }
3771
3772 /* Verify if we should use APC */
3773 if (!Overlapped)
3774 {
3775 /* Not using Overlapped structure, so use normal blocking on event */
3776 APCContext = NULL;
3777 APCFunction = NULL;
3779 IOSB = &DummyIOSB;
3780 }
3781 else
3782 {
3783 /* Overlapped request for non overlapped opened socket */
3785 {
3790 }
3791
3793 if (!APCContext)
3794 {
3799 }
3801 APCContext->lpOverlapped = Overlapped;
3802 APCContext->lpInfoData = InfoData;
3803 APCFunction = &MsafdInfoAPC;
3804
3806 Event = Overlapped->hEvent;
3807
3808 IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
3809 }
3810
3812
3813 /* Send IOCTL */
3815 Event,
3816 APCFunction,
3817 APCContext,
3818 IOSB,
3819 IOCTL_AFD_SET_INFO,
3820 InfoData,
3821 sizeof(*InfoData),
3822 NULL,
3823 0);
3824
3825 /* Wait for completion if not overlapped */
3827 {
3830 }
3831
3833
3835 if (!APCFunction)
3836 {
3837 /* When using APC, this will be freed by the APC function */
3839 }
3840
3842}
Referenced by WSPAsyncSelect(), WSPEventSelect(), WSPIoctl(), and WSPSetSockOpt().
◆ SockAsyncSelectCompletionRoutine()
| VOID SockAsyncSelectCompletionRoutine | ( | PVOID | Context, |
| PIO_STATUS_BLOCK | IoStatusBlock | ||
| ) |
Definition at line 4075 of file dllmain.c.
4076{
4077
4079 PSOCKET_INFORMATION Socket;
4081
4082 /* Get the Socket */
4083 Socket = AsyncData->ParentSocket;
4084
4085 /* Check if the Sequence Number Changed behind our back */
4087 {
4088 return;
4089 }
4090
4091 /* Check we were manually called b/c of a failure */
4093 {
4094 /* FIXME: Perform Upcall */
4095 return;
4096 }
4097
4099 {
4101 {
4105 {
4106 /* Make the Notification */
4109 Socket->Handle,
4111 /* Disable this event until the next read(); */
4113 }
4114 break;
4115
4119 {
4120 /* Make the Notification */
4123 Socket->Handle,
4125 /* Disable this event until the next read(); */
4127 }
4128 break;
4129
4133 {
4134 /* Make the Notification */
4137 Socket->Handle,
4139 /* Disable this event until the next write(); */
4141 }
4142 break;
4143
4144 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
4149 {
4150 /* Make the Notification */
4153 Socket->Handle,
4155 /* Disable this event forever; */
4157 }
4158 break;
4159
4163 {
4164 /* Make the Notification */
4167 Socket->Handle,
4169 /* Disable this event until the next accept(); */
4171 }
4172 break;
4173
4179 {
4180 /* Make the Notification */
4183 Socket->Handle,
4185 /* Disable this event forever; */
4187 }
4188 break;
4189 /* FIXME: Support QOS */
4190 }
4191 }
4192
4193 /* Check if there are any events left for us to check */
4195 {
4196 return;
4197 }
4198
4199 /* Keep Polling */
4200 SockProcessAsyncSelect(Socket, AsyncData);
4201 return;
4202}
VOID SockProcessAsyncSelect(PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
Definition: dllmain.c:4204
Definition: msafd.h:76
Referenced by SockGetAsyncSelectHelperAfdHandle(), and SockProcessAsyncSelect().
◆ SockAsyncThread()
Definition at line 3979 of file dllmain.c.
3980{
3981 PVOID AsyncContext;
3982 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine;
3983 IO_STATUS_BLOCK IOSB;
3985
3986 /* Make the Thread Higher Priority */
3988
3989 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
3990 do
3991 {
3993 (PVOID*)&AsyncCompletionRoutine,
3994 &AsyncContext,
3995 &IOSB,
3996 NULL);
3997 /* Call the Async Function */
3999 {
4000 (*AsyncCompletionRoutine)(AsyncContext, &IOSB);
4001 }
4002 else
4003 {
4004 /* It Failed, sleep for a second */
4005 Sleep(1000);
4006 }
4008
4009 /* The Thread has Ended */
4010 return 0;
4011}
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
Definition: thread.c:700
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 3918 of file dllmain.c.
3919{
3920 HANDLE hAsyncThread;
3921 DWORD AsyncThreadId;
3922 HANDLE AsyncEvent;
3923 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags;
3925
3926 /* Check if the Thread Already Exists */
3928 {
3931 }
3932
3933 /* Create the Completion Port */
3935 {
3937 IO_COMPLETION_ALL_ACCESS,
3938 NULL,
3939 2); // Allow 2 threads only
3941 {
3944 }
3945 /* Protect Handle */
3950 &HandleFlags,
3951 sizeof(HandleFlags));
3952 }
3953
3954 /* Create the Async Event */
3956 EVENT_ALL_ACCESS,
3957 NULL,
3958 NotificationEvent,
3959 FALSE);
3960
3961 /* Create the Async Thread */
3963 0,
3964 SockAsyncThread,
3965 NULL,
3966 0,
3967 &AsyncThreadId);
3968
3969 /* Close the Handle */
3970 NtClose(hAsyncThread);
3971
3972 /* Increase the Reference Count */
3973 SockAsyncThreadRefCount++;
3975}
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 PVOID ObjectInformation, IN ULONG Length)
Definition: oblife.c:1824
BOOLEAN ProtectFromClose
Definition: obtypes.h:273
Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().
◆ SockGetAsyncSelectHelperAfdHandle()
Definition at line 4013 of file dllmain.c.
4014{
4015 UNICODE_STRING AfdHelper;
4017 IO_STATUS_BLOCK IoSb;
4018 FILE_COMPLETION_INFORMATION CompletionInfo;
4019 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags;
4020
4021 /* First, make sure we're not already initialized */
4023 {
4025 }
4026
4027 /* Set up Handle Name and Object */
4030 &AfdHelper,
4032 NULL,
4033 NULL);
4034
4035 /* Open the Handle to AFD */
4038 &ObjectAttributes,
4039 &IoSb,
4040 NULL,
4041 0,
4043 FILE_OPEN_IF,
4044 0,
4045 NULL,
4046 0);
4047
4048 /*
4049 * Now Set up the Completion Port Information
4050 * This means that whenever a Poll is finished, the routine will be executed
4051 */
4055 &IoSb,
4056 &CompletionInfo,
4057 sizeof(CompletionInfo),
4058 FileCompletionInformation);
4059
4060
4061 /* Protect the Handle */
4066 &HandleFlags,
4067 sizeof(HandleFlags));
4068
4069
4070 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
4073}
VOID SockAsyncSelectCompletionRoutine(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:4075
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 4204 of file dllmain.c.
4205{
4206
4207 ULONG lNetworkEvents;
4209
4210 /* Set up the Async Data Event Info */
4217
4218 /* Remove unwanted events */
4220
4221 /* Set Events to wait for */
4223 {
4225 }
4226
4228 {
4230 }
4231
4233 {
4235 }
4236
4238 {
4240 }
4241
4242 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
4244 {
4246 }
4247
4249 {
4250 AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE;
4251 }
4252
4254 {
4256 }
4257
4259 {
4261 }
4262
4263 /* Send IOCTL */
4265 NULL,
4266 NULL,
4267 AsyncData,
4268 &AsyncData->IoStatusBlock,
4269 IOCTL_AFD_SELECT,
4270 &AsyncData->AsyncSelectInfo,
4272 &AsyncData->AsyncSelectInfo,
4274
4275 /* I/O Manager Won't call the completion routine, let's do it manually */
4277 {
4278 return;
4279 }
4280 else
4281 {
4284 }
4285}
Referenced by SockAsyncSelectCompletionRoutine(), and SockProcessQueuedAsyncSelect().
◆ SockProcessQueuedAsyncSelect()
| VOID SockProcessQueuedAsyncSelect | ( | PVOID | Context, |
| PIO_STATUS_BLOCK | IoStatusBlock | ||
| ) |
Definition at line 4287 of file dllmain.c.
4288{
4291 PSOCKET_INFORMATION Socket;
4292
4293 /* Get the Socket */
4294 Socket = AsyncData->ParentSocket;
4295
4296 /* If someone closed it, stop the function */
4298 {
4299 /* Check if the Sequence Number changed by now, in which case quit */
4301 {
4302 /* Do the actual select, if needed */
4304 {
4305 SockProcessAsyncSelect(Socket, AsyncData);
4306 FreeContext = FALSE;
4307 }
4308 }
4309 }
4310
4311 /* Free the Context */
4312 if (FreeContext)
4313 {
4315 }
4316
4317 return;
4318}
Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().
◆ SockReenableAsyncSelectEvent()
| VOID SockReenableAsyncSelectEvent | ( | IN PSOCKET_INFORMATION | Socket, |
| IN ULONG | Event | ||
| ) |
Definition at line 4321 of file dllmain.c.
4323{
4324 PASYNC_DATA AsyncData;
4325
4326 /* Make sure the event is actually disabled */
4328 {
4329 return;
4330 }
4331
4332 /* Re-enable it */
4333 Socket->SharedData->AsyncDisabledEvents &= ~Event;
4334
4335 /* Return if no more events are being polled */
4336 if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
4337 {
4338 return;
4339 }
4340
4341 /* Wait on new events */
4343 if (!AsyncData) return;
4344
4345 /* Create the Asynch Thread if Needed */
4346 SockCreateOrReferenceAsyncThread();
4347
4348 /* Increase the sequence number to stop anything else */
4349 Socket->SharedData->SequenceNumber++;
4350
4351 /* Set up the Async Data */
4352 AsyncData->ParentSocket = Socket;
4353 AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
4354
4355 /* Begin Async Select by using I/O Completion */
4358 AsyncData,
4359 0,
4360 0);
4361
4362 /* All done */
4363 return;
4364}
BOOLEAN SockCreateOrReferenceAsyncThread(VOID)
Definition: dllmain.c:3918
VOID SockProcessQueuedAsyncSelect(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:4287
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(), 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:79
Definition: shared.h:73
Definition: shared.h:68
Definition: ws2def.h:518
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().
◆ 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 3381 of file dllmain.c.
3387{
3391
3392 if (!lpsaAddress || !lpszAddressString || !lpdwAddressStringLength)
3393 {
3396 }
3397
3398 switch (lpsaAddress->sa_family)
3399 {
3402 {
3405 }
3413
3416 {
3417 *p = 0;
3418 }
3419 break;
3420 default:
3423 }
3424
3426
3428 {
3429 *lpdwAddressStringLength = size;
3432 }
3433
3434 *lpdwAddressStringLength = size;
3436 return 0;
3437}
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 3565 of file dllmain.c.
3567{
3569
3571
3572 return 0;
3573}
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:3597
Definition: shared.h:141
NTSYSAPI LONGLONG WINAPI RtlConvertLongToLargeInteger(LONG)
Definition: largeint.c:31
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 1901 of file dllmain.c.
1909{
1910 IO_STATUS_BLOCK DummyIOSB;
1911 PIO_STATUS_BLOCK IOSB = &DummyIOSB;
1913 PSOCKET_INFORMATION Socket;
1915 INT Errno;
1916 ULONG ConnectDataLength;
1917 ULONG InConnectDataLength;
1919 int SocketDataLength;
1923
1925
1926 /* Get the Socket Structure associate to this Socket*/
1928 if (!Socket)
1929 {
1932 }
1933
1934 /* Bind us First */
1936 {
1937 INT BindAddressLength;
1938 PSOCKADDR BindAddress;
1939 INT BindError;
1940
1941 /* Get the Wildcard Address */
1944 if (!BindAddress)
1945 {
1947 }
1949 BindAddress,
1950 &BindAddressLength);
1951 /* Bind it */
1956 }
1957
1959 EVENT_ALL_ACCESS,
1960 NULL,
1961 SynchronizationEvent,
1962 FALSE);
1965
1966 /* Set the Connect Data */
1968 {
1969 ConnectDataLength = lpCallerData->len;
1971 SockEvent,
1972 NULL,
1973 NULL,
1974 IOSB,
1976 lpCallerData->buf,
1977 ConnectDataLength,
1978 NULL,
1979 0);
1980 /* Wait for return */
1982 {
1985 }
1986
1988 goto Leave;
1989 }
1990
1991 /* Calculate the size of SocketAddress->sa_data */
1993
1995
1996 int connectionInfoSize = FIELD_OFFSET(AFD_CONNECT_INFO, RemoteAddress.Address[0].Address[SocketDataLength]);
1997
1998 if (connectionInfoSize > 128)
1999 {
2000 *lpErrno = WSAEFAULT;
2002 }
2003
2004 /* Set up Address in TDI Format */
2009 SocketAddress->sa_data,
2010 SocketDataLength);
2011
2012 /*
2013 * Disable FD_WRITE and FD_CONNECT
2014 * The latter fixes a race condition where the FD_CONNECT is re-enabled
2015 * at the end of this function right after the Async Thread disables it.
2016 * This should only happen at the *next* WSPConnect
2017 */
2019 {
2021 }
2022
2023 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
2025 {
2026 InConnectDataLength = lpCalleeData->len;
2028 SockEvent,
2029 NULL,
2030 NULL,
2031 IOSB,
2033 &InConnectDataLength,
2034 sizeof(InConnectDataLength),
2035 NULL,
2036 0);
2037
2038 /* Wait for return */
2040 {
2043 }
2044
2046 goto Leave;
2047 }
2048
2049 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
2050 ConnectInfo->Root = 0;
2052 ConnectInfo->Unknown = 0;
2053
2054 /* Verify if we should use APC */
2056 {
2058 if (!APCContext)
2059 {
2062 goto Leave;
2063 }
2065 APCFunction = &MsafdConnectAPC;
2066
2067 IOSB = &APCContext->IoStatusBlock;
2068 }
2069
2071 IOSB->Information = 0;
2072
2073 /* Send IOCTL */
2076 APCFunction,
2077 APCContext,
2078 IOSB,
2079 IOCTL_AFD_CONNECT,
2080 ConnectInfo,
2081 connectionInfoSize,
2082 NULL,
2083 0);
2085 {
2087 {
2089 goto Leave;
2090 }
2091 else
2092 {
2093 /* HACK: Allow APC to be processed */
2095 }
2096 }
2097 else
2098 {
2099 /* Wait for completion if blocking */
2101 {
2104 }
2105
2108 goto Leave;
2109
2113 }
2114
2115 /* Get any pending connect data */
2117 {
2118 IOSB = &DummyIOSB;
2120 SockEvent,
2121 NULL,
2122 NULL,
2123 IOSB,
2125 NULL,
2126 0,
2127 lpCalleeData->buf,
2128 lpCalleeData->len);
2129 /* Wait for return */
2131 {
2134 }
2135 }
2136
2137Leave:
2139
2141
2142 /* Re-enable Async Event */
2144
2145 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2147
2149 {
2151 Socket->Handle,
2152 Socket->TdiAddressHandle,
2153 Socket->TdiConnectionHandle,
2154 WSH_NOTIFY_CONNECT);
2155
2156 if (Errno)
2157 {
2158 if (lpErrno) *lpErrno = Errno;
2160 }
2161 }
2163 {
2165 Socket->Handle,
2166 Socket->TdiAddressHandle,
2167 Socket->TdiConnectionHandle,
2168 WSH_NOTIFY_CONNECT_ERROR);
2169
2170 if (Errno)
2171 {
2172 if (lpErrno) *lpErrno = Errno;
2174 }
2175 }
2176
2178}
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:1848
Definition: shared.h:117
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 2182 of file dllmain.c.
2190{
2191 IO_STATUS_BLOCK DummyIOSB;
2192 PIO_STATUS_BLOCK IOSB = &DummyIOSB;
2194 PSOCKET_INFORMATION Socket;
2196 int SocketDataLength;
2198
2200 {
2203 }
2204
2205 if (!lpSendBuffer && dwSendDataLength)
2206 {
2209 }
2210
2211 /* Get the Socket Structure associate to this Socket*/
2213 if (!Socket)
2214 {
2217 }
2218
2219
2220 /* Cannot call on connectionless socket */
2221 if (SocketAddressLength > ARRAYSIZE(Buffer) - sizeof(AFD_CONNECT_INFO) || Socket->SharedData->ServiceFlags1 & XP1_CONNECTIONLESS)
2222 {
2225 }
2226
2228 {
2229 /* Socket already must be bound */
2232 }
2233
2236
2237 /* Calculate the size of SocketAddress->sa_data */
2239
2240 /* Set up Address in TDI Format */
2245 SocketAddress->sa_data,
2246 SocketDataLength);
2247
2248 /*
2249 * Disable FD_WRITE and FD_CONNECT.
2250 * The latter fixes a race condition where the FD_CONNECT is re-enabled
2251 * at the end of this function right after the Async Thread disables it.
2252 * This should only happen at the *next* WSPConnect.
2253 */
2255 {
2257 }
2258
2261
2262 /* Send IOCTL */
2264 lpOverlapped->hEvent,
2265 NULL,
2267 IOSB,
2268 IOCTL_AFD_SUPER_CONNECT,
2269 ConnectInfo,
2271 lpSendBuffer,
2272 dwSendDataLength);
2273
2275
2277}
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:93
Definition: shared.h:125
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:1225
#define PROCESS_DUP_HANDLE
#define DUPLICATE_SAME_ACCESS
Referenced by WSPStartup().
◆ WSPGetPeerName()
| INT WSPAPI WSPGetPeerName | ( | IN SOCKET | s, |
| OUT LPSOCKADDR | Name, | ||
| IN OUT LPINT | NameLength, | ||
| OUT LPINT | lpErrno | ||
| ) |
Definition at line 2463 of file dllmain.c.
2467{
2468 IO_STATUS_BLOCK IOSB;
2469 ULONG TdiAddressSize;
2470 PTRANSPORT_ADDRESS SocketAddress;
2474
2475 /* Get the Socket Structure associate to this Socket*/
2477 if (!Socket)
2478 {
2481 }
2482
2484 {
2487 }
2488
2490 {
2493 }
2494
2496 EVENT_ALL_ACCESS,
2497 NULL,
2498 SynchronizationEvent,
2499 FALSE);
2500
2503
2504 /* Allocate a buffer for the address */
2507
2509 {
2513 }
2514
2515 /* Send IOCTL */
2517 SockEvent,
2518 NULL,
2519 NULL,
2520 &IOSB,
2521 IOCTL_AFD_GET_PEER_NAME,
2522 NULL,
2523 0,
2524 SocketAddress,
2525 TdiAddressSize);
2526
2527 /* Wait for return */
2529 {
2532 }
2533
2535
2537 {
2539 {
2549 return 0;
2550 }
2551 else
2552 {
2556 }
2557 }
2558
2560
2562}
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 2361 of file dllmain.c.
2365{
2366 IO_STATUS_BLOCK IOSB;
2367 ULONG TdiAddressSize;
2368 PTDI_ADDRESS_INFO TdiAddress;
2369 PTRANSPORT_ADDRESS SocketAddress;
2373
2374 /* Get the Socket Structure associate to this Socket*/
2376 if (!Socket)
2377 {
2380 }
2381
2383 {
2386 }
2387
2389 EVENT_ALL_ACCESS,
2390 NULL,
2391 SynchronizationEvent,
2392 FALSE);
2393
2396
2397 /* Allocate a buffer for the address */
2398 TdiAddressSize =
2401
2403 {
2407 }
2408
2409 SocketAddress = &TdiAddress->Address;
2410
2411 /* Send IOCTL */
2413 SockEvent,
2414 NULL,
2415 NULL,
2416 &IOSB,
2417 IOCTL_AFD_GET_SOCK_NAME,
2418 NULL,
2419 0,
2420 TdiAddress,
2421 TdiAddressSize);
2422
2423 /* Wait for return */
2425 {
2428 }
2429
2431
2433 {
2435 {
2445 return 0;
2446 }
2447 else
2448 {
2452 }
2453 }
2454
2456
2458}
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 2814 of file dllmain.c.
2820{
2824 BOOL BoolBuffer;
2825 DWORD DwordBuffer;
2826 INT Errno;
2827
2829
2830 /* Get the Socket Structure associate to this Socket*/
2833 {
2836 }
2837 if (!OptionLength || !OptionValue)
2838 {
2841 }
2842
2844 {
2846 switch (OptionName)
2847 {
2851 break;
2852
2856 break;
2857
2861 break;
2862
2865 Buffer = &BoolBuffer;
2867 break;
2868
2871 Buffer = &BoolBuffer;
2873 break;
2874
2877 Buffer = &BoolBuffer;
2879 break;
2880
2883 Buffer = &BoolBuffer;
2885 break;
2886
2889 {
2892 }
2895 break;
2896
2899 Buffer = &BoolBuffer;
2901 break;
2902
2905 /* These guys go directly to the helper */
2906 goto SendToHelper;
2907
2910 Buffer = &BoolBuffer;
2912 break;
2913
2916 Buffer = &BoolBuffer;
2918 break;
2919
2922 Buffer = &BoolBuffer;
2924 break;
2925
2929 break;
2930
2933 Buffer = &DwordBuffer;
2935 break;
2936
2940 break;
2944 break;
2948 break;
2949
2953
2954 default:
2958 }
2959
2961 {
2963 *OptionLength = BufferSize;
2965 }
2967
2968 return 0;
2969
2970 default:
2973 }
2974
2975SendToHelper:
2977 Handle,
2978 Socket->TdiAddressHandle,
2979 Socket->TdiConnectionHandle,
2980 Level,
2981 OptionName,
2982 OptionValue,
2983 (LPINT)OptionLength);
2984 if (lpErrno) *lpErrno = Errno;
2986}
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 2566 of file dllmain.c.
2577{
2580 BOOLEAN NonBlocking;
2582 DWORD cbRet = 0;
2583
2584 /* Get the Socket Structure associate to this Socket*/
2586 if (!Socket)
2587 {
2588 if(lpErrno)
2589 *lpErrno = WSAENOTSOCK;
2591 }
2592
2594 {
2595 if(lpErrno)
2596 *lpErrno = WSAEFAULT;
2598 }
2599
2601 {
2604 {
2605 Errno = WSAEFAULT;
2606 break;
2607 }
2609 /* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
2610 if (!NonBlocking)
2611 {
2612 /* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
2614 {
2615 Errno = WSAEINVAL;
2616 break;
2617 }
2618 /* If there is an WSPEventSelect pending, fail with WSAEINVAL */
2620 {
2621 Errno = WSAEINVAL;
2622 break;
2623 }
2624 }
2626 NeedsCompletion = FALSE;
2627 Errno = SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &NonBlocking, NULL, NULL, lpOverlapped, lpCompletionRoutine);
2629 Ret = NO_ERROR;
2630 break;
2633 {
2635 Errno = WSAEFAULT;
2636 break;
2637 }
2639 {
2640 Errno = WSAEINVAL;
2641 break;
2642 }
2643 NeedsCompletion = FALSE;
2644 Errno = GetSocketInformation(Socket, AFD_INFO_RECEIVE_CONTENT_SIZE, NULL, (PULONG)lpvOutBuffer, NULL, lpOverlapped, lpCompletionRoutine);
2646 {
2648 Ret = NO_ERROR;
2649 }
2650 break;
2653 {
2655 Errno = WSAEFAULT;
2656 break;
2657 }
2659 {
2660 Errno = WSAEINVAL;
2661 break;
2662 }
2664 {
2665 Errno = WSAEINVAL;
2666 break;
2667 }
2668
2669 /* FIXME: Return false if OOBINLINE is true for now
2670 We should MSG_PEEK|MSG_OOB check with driver
2671 */
2673
2675 Errno = NO_ERROR;
2676 Ret = NO_ERROR;
2677 break;
2679 if (cbOutBuffer == 0)
2680 {
2682 Errno = WSAEFAULT;
2683 break;
2684 }
2685
2688 {
2689 Errno = WSAEINVAL;
2690 break;
2691 }
2692
2693 {
2695 GUID ConnectExGUID = WSAID_CONNECTEX;
2696 GUID DisconnectExGUID = WSAID_DISCONNECTEX;
2698
2700 {
2703 Errno = NO_ERROR;
2704 Ret = NO_ERROR;
2705 }
2707 {
2710 Errno = NO_ERROR;
2711 Ret = NO_ERROR;
2712 }
2714 {
2717 Errno = NO_ERROR;
2718 Ret = NO_ERROR;
2719 }
2721 {
2724 Errno = NO_ERROR;
2725 /* See CORE-14966 and associated commits.
2726 * Original line below was 'Ret = NO_ERROR:'.
2727 * This caused winetest ws2_32:sock to hang.
2728 * This new Ret value allows the test to complete. */
2730 Ret = SOCKET_ERROR;
2731 }
2732 else
2733 {
2735 Errno = WSAEOPNOTSUPP;
2736 }
2737 }
2738
2739 break;
2742 {
2744 Errno = WSAEFAULT;
2745 break;
2746 }
2748 {
2749 Errno = WSAEINVAL;
2750 break;
2751 }
2752
2754
2755 ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->iAddressCount = 1;
2756
2758 {
2759 Errno = WSAEFAULT;
2760 break;
2761 }
2762
2763 ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].iSockaddrLength = sizeof(Socket->SharedData->WSLocalAddress);
2764 ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].lpSockaddr = &Socket->SharedData->WSLocalAddress;
2765
2766 Errno = NO_ERROR;
2767 Ret = NO_ERROR;
2768 break;
2769 default:
2771 Handle,
2772 Socket->TdiAddressHandle,
2773 Socket->TdiConnectionHandle,
2774 dwIoControlCode,
2775 lpvInBuffer,
2776 cbInBuffer,
2777 lpvOutBuffer,
2778 cbOutBuffer,
2779 &cbRet,
2780 lpOverlapped,
2781 lpCompletionRoutine,
2782 &NeedsCompletion);
2783
2785 Ret = NO_ERROR;
2786 break;
2787 }
2789 {
2790 lpOverlapped->Internal = Errno;
2791 lpOverlapped->InternalHigh = cbRet;
2793 {
2794 lpCompletionRoutine(Errno, cbRet, lpOverlapped, 0);
2795 }
2799 {
2801 }
2803 }
2804 if (lpErrno)
2805 *lpErrno = Errno;
2806 if (lpcbBytesReturned)
2807 *lpcbBytesReturned = cbRet;
2808 return Ret;
2809}
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:2182
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:3723
BOOL WSPAPI WSPAcceptEx(IN SOCKET sListenSocket, IN SOCKET sAcceptSocket, OUT PVOID lpOutputBuffer, IN DWORD dwReceiveDataLength, IN DWORD dwLocalAddressLength, IN DWORD dwRemoteAddressLength, OUT LPDWORD lpdwBytesReceived, IN OUT LPOVERLAPPED lpOverlapped)
Definition: stubs.c:58
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: stubs.c:88
BOOL WSPAPI WSPDisconnectEx(IN SOCKET hSocket, IN LPOVERLAPPED lpOverlapped, IN DWORD dwFlags, IN DWORD reserved)
Definition: stubs.c:75
Definition: shobjidl.idl:3021
BOOL WINAPI PostQueuedCompletionStatus(IN HANDLE CompletionHandle, IN DWORD dwNumberOfBytesTransferred, IN ULONG_PTR dwCompletionKey, IN LPOVERLAPPED lpOverlapped)
Definition: iocompl.c:192
Definition: ws2def.h:379
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 3100 of file dllmain.c.
3107{
3108 PSOCKET_INFORMATION Socket;
3109 INT Errno;
3110
3111 /* Get the Socket Structure associate to this Socket*/
3114 {
3117 }
3118 if (!optval && optlen)
3119 {
3122 }
3123
3124
3125 /* FIXME: We should handle some more cases here */
3127 {
3128 switch (optname)
3129 {
3132 {
3135 }
3138
3141 {
3144 }
3147
3150 {
3153 }
3156
3159 {
3162 }
3165
3168 {
3171 }
3174
3177 {
3180 }
3182 optval,
3185
3188 {
3191 }
3192
3193 SetSocketInformation(Socket,
3195 NULL,
3196 (PULONG)optval,
3197 NULL,
3198 NULL,
3199 NULL);
3200 GetSocketInformation(Socket,
3202 NULL,
3204 NULL,
3205 NULL,
3206 NULL);
3207
3209
3212 {
3215 }
3216
3217 /* FIXME: We should not have to limit the packet receive buffer size like this. workaround for CORE-15804 */
3219 *(PULONG)optval = 0x2000;
3220
3221 SetSocketInformation(Socket,
3223 NULL,
3224 (PULONG)optval,
3225 NULL,
3226 NULL,
3227 NULL);
3228 GetSocketInformation(Socket,
3230 NULL,
3232 NULL,
3233 NULL,
3234 NULL);
3235
3237
3238 case SO_UPDATE_CONNECT_CONTEXT:
3240
3243 {
3246 }
3247
3249 optval,
3252
3255 {
3258 }
3259
3261 optval,
3264
3267 {
3270 }
3271
3273 optval,
3276
3279 /* These go directly to the helper dll */
3280 goto SendToHelper;
3281
3282 default:
3283 /* Obviously this is a hack */
3286 }
3287 }
3288
3289SendToHelper:
3291 s,
3292 Socket->TdiAddressHandle,
3293 Socket->TdiConnectionHandle,
3294 level,
3295 optname,
3296 (PCHAR)optval,
3297 optlen);
3298 if (lpErrno) *lpErrno = Errno;
3300}
static INT NTAPI MsafdUpdateConnectionContext(_In_ SOCKET Handle, _Out_ LPINT lpErrno)
Definition: dllmain.c:2991
PWSH_SET_SOCKET_INFORMATION WSHSetSocketInformation
Definition: helpers.h:27
Referenced by WSPStartup().
◆ WSPShutdown()
Definition at line 2281 of file dllmain.c.
2285{
2286 IO_STATUS_BLOCK IOSB;
2287 AFD_DISCONNECT_INFO DisconnectInfo;
2291
2293
2294 /* Get the Socket Structure associate to this Socket*/
2296 if (!Socket)
2297 {
2300 }
2301
2303 EVENT_ALL_ACCESS,
2304 NULL,
2305 SynchronizationEvent,
2306 FALSE);
2307
2310
2311 /* Set AFD Disconnect Type */
2312 switch (HowTo)
2313 {
2317 break;
2321 break;
2326 break;
2327 }
2328
2330
2331 /* Send IOCTL */
2333 SockEvent,
2334 NULL,
2335 NULL,
2336 &IOSB,
2337 IOCTL_AFD_DISCONNECT,
2338 &DisconnectInfo,
2339 sizeof(DisconnectInfo),
2340 NULL,
2341 0);
2342
2343 /* Wait for return */
2345 {
2348 }
2349
2351
2353
2356}
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:92
Definition: urlmon_main.h:97
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 3316 of file dllmain.c.
3322{
3324
3326 (LOBYTE(wVersionRequested) < 2))
3327 {
3330 }
3331 else
3333 /* FIXME: Enable all cases of WSPStartup status */
3334 Upcalls = UpcallTable;
3335
3337 {
3338 lpProcTable->lpWSPAccept = WSPAccept;
3339 lpProcTable->lpWSPAddressToString = WSPAddressToString;
3340 lpProcTable->lpWSPAsyncSelect = WSPAsyncSelect;
3341 lpProcTable->lpWSPBind = WSPBind;
3342 lpProcTable->lpWSPCancelBlockingCall = WSPCancelBlockingCall;
3343 lpProcTable->lpWSPCleanup = WSPCleanup;
3344 lpProcTable->lpWSPCloseSocket = WSPCloseSocket;
3345 lpProcTable->lpWSPConnect = WSPConnect;
3346 lpProcTable->lpWSPDuplicateSocket = WSPDuplicateSocket;
3347 lpProcTable->lpWSPEnumNetworkEvents = WSPEnumNetworkEvents;
3348 lpProcTable->lpWSPEventSelect = WSPEventSelect;
3349 lpProcTable->lpWSPGetOverlappedResult = WSPGetOverlappedResult;
3350 lpProcTable->lpWSPGetPeerName = WSPGetPeerName;
3351 lpProcTable->lpWSPGetSockName = WSPGetSockName;
3352 lpProcTable->lpWSPGetSockOpt = WSPGetSockOpt;
3353 lpProcTable->lpWSPGetQOSByName = WSPGetQOSByName;
3354 lpProcTable->lpWSPIoctl = WSPIoctl;
3355 lpProcTable->lpWSPJoinLeaf = WSPJoinLeaf;
3356 lpProcTable->lpWSPListen = WSPListen;
3357 lpProcTable->lpWSPRecv = WSPRecv;
3358 lpProcTable->lpWSPRecvDisconnect = WSPRecvDisconnect;
3359 lpProcTable->lpWSPRecvFrom = WSPRecvFrom;
3360 lpProcTable->lpWSPSelect = WSPSelect;
3361 lpProcTable->lpWSPSend = WSPSend;
3362 lpProcTable->lpWSPSendDisconnect = WSPSendDisconnect;
3363 lpProcTable->lpWSPSendTo = WSPSendTo;
3364 lpProcTable->lpWSPSetSockOpt = WSPSetSockOpt;
3365 lpProcTable->lpWSPShutdown = WSPShutdown;
3366 lpProcTable->lpWSPSocket = WSPSocket;
3367 lpProcTable->lpWSPStringToAddress = WSPStringToAddress;
3368 lpWSPData->wVersion = MAKEWORD(2, 2);
3369 lpWSPData->wHighVersion = MAKEWORD(2, 2);
3370 /* Save CatalogEntryId for all upcalls */
3371 CatalogEntryId = lpProtocolInfo->dwCatalogEntryId;
3372 }
3373
3376}
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:3381
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:3100
int WSPAPI WSPConnect(SOCKET Handle, const struct sockaddr *SocketAddress, int SocketAddressLength, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS, LPINT lpErrno)
Definition: dllmain.c:1901
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:2814
INT WSPAPI WSPGetPeerName(IN SOCKET s, OUT LPSOCKADDR Name, IN OUT LPINT NameLength, OUT LPINT lpErrno)
Definition: dllmain.c:2463
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:2281
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:3441
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:2566
_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:2361
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 3441 of file dllmain.c.
3447{
3448 int numdots = 0;
3450 LONG inetaddr = 0, ip_part;
3453
3454 if (!lpAddressLength || !lpAddress || !AddressString)
3455 {
3458 }
3459
3461
3462 /* Set right address family */
3464 {
3465 sockaddr->sin_family = lpProtocolInfo->iAddressFamily;
3466 }
3467 else
3468 {
3470 }
3471
3472 /* Report size */
3474 {
3476 {
3478 }
3479 else
3480 {
3481 // translate ip string to ip
3482
3483 /* Get ip number */
3484 bp = &AddressString;
3485 inetaddr = 0;
3486
3488 {
3489 ip_part = wcstol(*bp, bp, 10);
3490 /* ip part number should be in range 0-255 */
3491 if (ip_part < 0 || ip_part > 255)
3492 {
3495 }
3496 inetaddr = (inetaddr << 8) + ip_part;
3497 /* we end on string end or port separator */
3499 break;
3500 /* ip parts are dot separated. verify it */
3502 {
3505 }
3506 /* count the dots */
3507 numdots++;
3508 /* move over the dot to next ip part */
3509 (*bp)++;
3510 }
3511
3512 /* check dots count */
3513 if (numdots != 3)
3514 {
3517 }
3518
3519 /* Get port number */
3521 {
3522 /* move over the column to port part */
3523 (*bp)++;
3524 /* next char should be numeric */
3526 {
3529 }
3531 }
3532 else
3533 {
3534 port = 0;
3535 }
3536
3538 /* rest sockaddr.sin_addr.s_addr
3539 for we need to be sure it is zero when we come to while */
3540 *lpAddressLength = sizeof(*sockaddr);
3543 sockaddr->sin_addr.s_addr = inetaddr;
3545 }
3546 }
3547
3548 if (lpErrno && !*lpErrno)
3549 {
3550 return 0;
3551 }
3552
3554}
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().
