ApfelTeeSaft/reactos
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/reactos.git synced 2026-09-02 12:23:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AUDIT]

Browse Source 
ws2_32
- All exported functions are fully documented on MSDN
- All internal functions are clearly written with no signs of reversing
- Reformat all code to ReactOS standard

svn path=/trunk/; revision=23580
This commit is contained in:
Ged Murphy
2006-08-14 17:26:36 +00:00
parent 4fe1ff2259
commit 546f463b79
12 changed files with 2527 additions and 2247 deletions
Download Patch File Download Diff File Expand all files Collapse all files
reactos/dll/win32/ws2_32/include/catalog.h
+2 -1
View File
@@ -7,7 +7,8 @@
#ifndef __CATALOG_H
#define __CATALOG_H
typedef struct _CATALOG_ENTRY {
typedef struct _CATALOG_ENTRY
{
LIST_ENTRY ListEntry;
ULONG ReferenceCount;
CRITICAL_SECTION Lock;
reactos/dll/win32/ws2_32/include/handle.h
+4 -2
View File
@@ -9,14 +9,16 @@
#include <catalog.h>
typedef struct _PROVIDER_HANDLE {
typedef struct _PROVIDER_HANDLE
{
HANDLE Handle;
PCATALOG_ENTRY Provider;
} PROVIDER_HANDLE, *PPROVIDER_HANDLE;
#define HANDLE_BLOCK_ENTRIES ((1024-sizeof(LIST_ENTRY))/sizeof(PROVIDER_HANDLE))
typedef struct _PROVIDER_HANDLE_BLOCK {
typedef struct _PROVIDER_HANDLE_BLOCK
{
LIST_ENTRY Entry;
PROVIDER_HANDLE Handles[HANDLE_BLOCK_ENTRIES];
} PROVIDER_HANDLE_BLOCK, *PPROVIDER_HANDLE_BLOCK;
reactos/dll/win32/ws2_32/include/ws2_32.h
+7 -4
View File
@@ -34,24 +34,27 @@ extern WSPUPCALLTABLE UpcallTable;
#define WS2_INTERNAL_MAX_ALIAS 16
typedef struct _WINSOCK_GETSERVBYNAME_CACHE {
typedef struct _WINSOCK_GETSERVBYNAME_CACHE
{
UINT Size;
SERVENT ServerEntry;
PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS];
CHAR Data[1];
} WINSOCK_GETSERVBYNAME_CACHE, *PWINSOCK_GETSERVBYNAME_CACHE;
typedef struct _WINSOCK_GETSERVBYPORT_CACHE {
typedef struct _WINSOCK_GETSERVBYPORT_CACHE
{
UINT Size;
SERVENT ServerEntry;
PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS];
CHAR Data[1];
} WINSOCK_GETSERVBYPORT_CACHE, *PWINSOCK_GETSERVBYPORT_CACHE;
typedef struct _WINSOCK_THREAD_BLOCK {
typedef struct _WINSOCK_THREAD_BLOCK
{
INT LastErrorValue; /* Error value from last function that failed */
CHAR Intoa[16]; /* Buffer for inet_ntoa() */
PWINSOCK_GETSERVBYNAME_CACHE
PWINSOCK_GETSERVBYNAME_CACHE
Getservbyname; /* Buffer used by getservbyname */
PWINSOCK_GETSERVBYPORT_CACHE
Getservbyport; /* Buffer used by getservbyname */
reactos/dll/win32/ws2_32/misc/bsd.c
+8 -12
View File
@@ -14,10 +14,9 @@
*/
ULONG
EXPORT
htonl(
IN ULONG hostlong)
htonl(IN ULONG hostlong)
{
return DH2N(hostlong);
return DH2N(hostlong);
}
@@ -26,10 +25,9 @@ htonl(
*/
USHORT
EXPORT
htons(
IN USHORT hostshort)
htons(IN USHORT hostshort)
{
return WH2N(hostshort);
return WH2N(hostshort);
}
@@ -38,10 +36,9 @@ htons(
*/
ULONG
EXPORT
ntohl(
IN ULONG netlong)
ntohl(IN ULONG netlong)
{
return DN2H(netlong);
return DN2H(netlong);
}
@@ -50,10 +47,9 @@ ntohl(
*/
USHORT
EXPORT
ntohs(
IN USHORT netshort)
ntohs(IN USHORT netshort)
{
return WN2H(netshort);
return WN2H(netshort);
}
/* EOF */
reactos/dll/win32/ws2_32/misc/catalog.c
+271 -253
View File
@@ -14,8 +14,8 @@
LIST_ENTRY CatalogListHead;
CRITICAL_SECTION CatalogLock;
VOID ReferenceProviderByPointer(
PCATALOG_ENTRY Provider)
VOID
ReferenceProviderByPointer(PCATALOG_ENTRY Provider)
{
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
@@ -27,15 +27,16 @@ VOID ReferenceProviderByPointer(
}
VOID DereferenceProviderByPointer(
PCATALOG_ENTRY Provider)
VOID
DereferenceProviderByPointer(PCATALOG_ENTRY Provider)
{
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
#ifdef DBG
if (Provider->ReferenceCount <= 0) {
if (Provider->ReferenceCount <= 0)
{
WS_DbgPrint(MIN_TRACE, ("Provider at 0x%X has invalid reference count (%ld).\n",
Provider, Provider->ReferenceCount));
Provider, Provider->ReferenceCount));
}
#endif
@@ -43,295 +44,312 @@ VOID DereferenceProviderByPointer(
Provider->ReferenceCount--;
//LeaveCriticalSection(&Provider->Lock);
if (Provider->ReferenceCount == 0) {
if (Provider->ReferenceCount == 0)
{
WS_DbgPrint(MAX_TRACE, ("Provider at 0x%X has reference count 0 (unloading).\n",
Provider));
Provider));
DestroyCatalogEntry(Provider);
}
}
PCATALOG_ENTRY CreateCatalogEntry(
LPWSTR LibraryName)
PCATALOG_ENTRY
CreateCatalogEntry(LPWSTR LibraryName)
{
PCATALOG_ENTRY Provider;
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("LibraryName (%S).\n", LibraryName));
WS_DbgPrint(MAX_TRACE, ("LibraryName (%S).\n", LibraryName));
Provider = HeapAlloc(GlobalHeap, 0, sizeof(CATALOG_ENTRY));
if (!Provider) {
return NULL;
}
Provider = HeapAlloc(GlobalHeap, 0, sizeof(CATALOG_ENTRY));
if (!Provider)
return NULL;
ZeroMemory(Provider, sizeof(CATALOG_ENTRY));
ZeroMemory(Provider, sizeof(CATALOG_ENTRY));
if (!RtlCreateUnicodeString(&Provider->LibraryName, LibraryName)) {
RtlFreeHeap(GlobalHeap, 0, Provider);
return NULL;
}
Provider->ReferenceCount = 1;
InitializeCriticalSection(&Provider->Lock);
Provider->hModule = NULL;
Provider->Mapping = NULL;
//EnterCriticalSection(&CatalogLock);
InsertTailList(&CatalogListHead, &Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
return Provider;
}
INT DestroyCatalogEntry(
PCATALOG_ENTRY Provider)
{
INT Status;
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
//EnterCriticalSection(&CatalogLock);
RemoveEntryList(&Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
HeapFree(GlobalHeap, 0, Provider->Mapping);
if (NULL != Provider->hModule) {
Status = UnloadProvider(Provider);
} else {
Status = NO_ERROR;
}
//DeleteCriticalSection(&Provider->Lock);
HeapFree(GlobalHeap, 0, Provider);
return Status;
}
PCATALOG_ENTRY LocateProvider(
LPWSAPROTOCOL_INFOW lpProtocolInfo)
{
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
UINT i;
WS_DbgPrint(MAX_TRACE, ("lpProtocolInfo (0x%X).\n", lpProtocolInfo));
//EnterCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead) {
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
for (i = 0; i < Provider->Mapping->Rows; i++) {
if ((lpProtocolInfo->iAddressFamily == (INT) Provider->Mapping->Mapping[i].AddressFamily) &&
(lpProtocolInfo->iSocketType == (INT) Provider->Mapping->Mapping[i].SocketType) &&
((lpProtocolInfo->iProtocol == (INT) Provider->Mapping->Mapping[i].Protocol) ||
(lpProtocolInfo->iSocketType == SOCK_RAW))) {
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Returning provider at (0x%X).\n", Provider));
return Provider;
}
if (!RtlCreateUnicodeString(&Provider->LibraryName, LibraryName))
{
RtlFreeHeap(GlobalHeap, 0, Provider);
return NULL;
}
CurrentEntry = CurrentEntry->Flink;
}
//LeaveCriticalSection(&CatalogLock);
return NULL;
}
PCATALOG_ENTRY LocateProviderById(
DWORD CatalogEntryId)
{
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("CatalogEntryId (%d).\n", CatalogEntryId));
//EnterCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead) {
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
if (Provider->ProtocolInfo.dwCatalogEntryId == CatalogEntryId) {
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Returning provider at (0x%X) Name (%wZ).\n",
Provider, &Provider->LibraryName));
return Provider;
}
CurrentEntry = CurrentEntry->Flink;
}
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Provider was not found.\n"));
return NULL;
}
INT LoadProvider(
PCATALOG_ENTRY Provider,
LPWSAPROTOCOL_INFOW lpProtocolInfo)
{
INT Status;
WS_DbgPrint(MID_TRACE, ("Loading provider at (0x%X) Name (%wZ).\n",
Provider, &Provider->LibraryName));
if (NULL == Provider->hModule)
{
/* DLL is not loaded so load it now
* UNICODE_STRING objects are not null-terminated, but LoadLibraryW
* expects a null-terminated string
*/
Provider->LibraryName.Buffer[Provider->LibraryName.Length / sizeof(WCHAR)] = L'\0';
Provider->hModule = LoadLibraryW(Provider->LibraryName.Buffer);
if (NULL != Provider->hModule) {
Provider->WSPStartup = (LPWSPSTARTUP)GetProcAddress(
Provider->hModule,
"WSPStartup");
if (Provider->WSPStartup) {
WS_DbgPrint(MAX_TRACE, ("Calling WSPStartup at (0x%X).\n",
Provider->WSPStartup));
Status = Provider->WSPStartup(
MAKEWORD(2, 2),
&Provider->WSPData,
lpProtocolInfo,
UpcallTable,
&Provider->ProcTable);
/* FIXME: Validate the procedure table */
} else
Status = ERROR_BAD_PROVIDER;
} else
Status = ERROR_DLL_NOT_FOUND;
} else
Status = NO_ERROR;
WS_DbgPrint(MID_TRACE, ("Status (%d).\n", Status));
return Status;
}
INT UnloadProvider(
PCATALOG_ENTRY Provider)
{
INT Status = NO_ERROR;
WS_DbgPrint(MAX_TRACE, ("Unloading provider at (0x%X)\n", Provider));
if (NULL != Provider->hModule) {
WS_DbgPrint(MAX_TRACE, ("Calling WSPCleanup at (0x%X).\n",
Provider->ProcTable.lpWSPCleanup));
Provider->ProcTable.lpWSPCleanup(&Status);
WS_DbgPrint(MAX_TRACE, ("Calling FreeLibrary(0x%X).\n", Provider->hModule));
if (!FreeLibrary(Provider->hModule)) {
WS_DbgPrint(MIN_TRACE, ("Could not free library at (0x%X).\n", Provider->hModule));
Status = GetLastError();
}
Provider->ReferenceCount = 1;
InitializeCriticalSection(&Provider->Lock);
Provider->hModule = NULL;
}
WS_DbgPrint(MAX_TRACE, ("Status (%d).\n", Status));
Provider->Mapping = NULL;
return Status;
//EnterCriticalSection(&CatalogLock);
InsertTailList(&CatalogListHead, &Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
return Provider;
}
VOID CreateCatalog(VOID)
INT
DestroyCatalogEntry(PCATALOG_ENTRY Provider)
{
PCATALOG_ENTRY Provider;
INT Status;
InitializeCriticalSection(&CatalogLock);
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
InitializeListHead(&CatalogListHead);
//EnterCriticalSection(&CatalogLock);
RemoveEntryList(&Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
HeapFree(GlobalHeap, 0, Provider->Mapping);
if (NULL != Provider->hModule)
{
Status = UnloadProvider(Provider);
}
else
{
Status = NO_ERROR;
}
//DeleteCriticalSection(&Provider->Lock);
HeapFree(GlobalHeap, 0, Provider);
return Status;
}
PCATALOG_ENTRY
LocateProvider(LPWSAPROTOCOL_INFOW lpProtocolInfo)
{
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
UINT i;
WS_DbgPrint(MAX_TRACE, ("lpProtocolInfo (0x%X).\n", lpProtocolInfo));
//EnterCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead)
{
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
for (i = 0; i < Provider->Mapping->Rows; i++)
{
if ((lpProtocolInfo->iAddressFamily == (INT) Provider->Mapping->Mapping[i].AddressFamily) &&
(lpProtocolInfo->iSocketType == (INT) Provider->Mapping->Mapping[i].SocketType) &&
((lpProtocolInfo->iProtocol == (INT) Provider->Mapping->Mapping[i].Protocol) ||
(lpProtocolInfo->iSocketType == SOCK_RAW)))
{
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Returning provider at (0x%X).\n", Provider));
return Provider;
}
}
CurrentEntry = CurrentEntry->Flink;
}
//LeaveCriticalSection(&CatalogLock);
return NULL;
}
PCATALOG_ENTRY
LocateProviderById(DWORD CatalogEntryId)
{
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("CatalogEntryId (%d).\n", CatalogEntryId));
//EnterCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead)
{
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
if (Provider->ProtocolInfo.dwCatalogEntryId == CatalogEntryId)
{
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Returning provider at (0x%X) Name (%wZ).\n",
Provider, &Provider->LibraryName));
return Provider;
}
CurrentEntry = CurrentEntry->Flink;
}
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Provider was not found.\n"));
return NULL;
}
INT
LoadProvider(PCATALOG_ENTRY Provider,
LPWSAPROTOCOL_INFOW lpProtocolInfo)
{
INT Status;
WS_DbgPrint(MID_TRACE, ("Loading provider at (0x%X) Name (%wZ).\n",
Provider, &Provider->LibraryName));
if (NULL == Provider->hModule)
{
/* DLL is not loaded so load it now
* UNICODE_STRING objects are not null-terminated, but LoadLibraryW
* expects a null-terminated string
*/
Provider->LibraryName.Buffer[Provider->LibraryName.Length / sizeof(WCHAR)] = L'\0';
Provider->hModule = LoadLibraryW(Provider->LibraryName.Buffer);
if (NULL != Provider->hModule)
{
Provider->WSPStartup = (LPWSPSTARTUP)GetProcAddress(Provider->hModule,
"WSPStartup");
if (Provider->WSPStartup)
{
WS_DbgPrint(MAX_TRACE, ("Calling WSPStartup at (0x%X).\n",
Provider->WSPStartup));
Status = Provider->WSPStartup(MAKEWORD(2, 2),
&Provider->WSPData,
lpProtocolInfo,
UpcallTable,
&Provider->ProcTable);
/* FIXME: Validate the procedure table */
}
else
Status = ERROR_BAD_PROVIDER;
}
else
Status = ERROR_DLL_NOT_FOUND;
}
else
Status = NO_ERROR;
WS_DbgPrint(MID_TRACE, ("Status (%d).\n", Status));
return Status;
}
INT
UnloadProvider(PCATALOG_ENTRY Provider)
{
INT Status = NO_ERROR;
WS_DbgPrint(MAX_TRACE, ("Unloading provider at (0x%X)\n", Provider));
if (NULL != Provider->hModule)
{
WS_DbgPrint(MAX_TRACE, ("Calling WSPCleanup at (0x%X).\n",
Provider->ProcTable.lpWSPCleanup));
Provider->ProcTable.lpWSPCleanup(&Status);
WS_DbgPrint(MAX_TRACE, ("Calling FreeLibrary(0x%X).\n", Provider->hModule));
if (!FreeLibrary(Provider->hModule))
{
WS_DbgPrint(MIN_TRACE, ("Could not free library at (0x%X).\n", Provider->hModule));
Status = GetLastError();
}
Provider->hModule = NULL;
}
WS_DbgPrint(MAX_TRACE, ("Status (%d).\n", Status));
return Status;
}
VOID
CreateCatalog(VOID)
{
PCATALOG_ENTRY Provider;
InitializeCriticalSection(&CatalogLock);
InitializeListHead(&CatalogListHead);
/* FIXME: Read service provider catalog from registry
Catalog info is saved somewhere under
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WinSock2
*/
/* FIXME: Read service provider catalog from registry
Catalog info is saved somewhere under
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WinSock2
*/
#if 1
Provider = CreateCatalogEntry(L"msafd.dll");
if (!Provider) {
WS_DbgPrint(MIN_TRACE, ("Could not create catalog entry.\n"));
return;
}
/* Assume one Service Provider with id 1 */
Provider->ProtocolInfo.dwCatalogEntryId = 1;
if (!Provider)
{
WS_DbgPrint(MIN_TRACE, ("Could not create catalog entry.\n"));
return;
}
Provider->Mapping = HeapAlloc(GlobalHeap,
0,
6 * sizeof(WINSOCK_MAPPING) + 3 * sizeof(DWORD));
if (!Provider->Mapping)
return;
/* Assume one Service Provider with id 1 */
Provider->ProtocolInfo.dwCatalogEntryId = 1;
Provider->Mapping->Rows = 6;
Provider->Mapping->Columns = 3;
Provider->Mapping = HeapAlloc(GlobalHeap,
0,
6 * sizeof(WINSOCK_MAPPING) + 3 * sizeof(DWORD));
if (!Provider->Mapping)
return;
Provider->Mapping->Mapping[0].AddressFamily = AF_INET;
Provider->Mapping->Mapping[0].SocketType = SOCK_STREAM;
Provider->Mapping->Mapping[0].Protocol = 0;
Provider->Mapping->Rows = 6;
Provider->Mapping->Columns = 3;
Provider->Mapping->Mapping[1].AddressFamily = AF_INET;
Provider->Mapping->Mapping[1].SocketType = SOCK_STREAM;
Provider->Mapping->Mapping[1].Protocol = IPPROTO_TCP;
Provider->Mapping->Mapping[0].AddressFamily = AF_INET;
Provider->Mapping->Mapping[0].SocketType = SOCK_STREAM;
Provider->Mapping->Mapping[0].Protocol = 0;
Provider->Mapping->Mapping[2].AddressFamily = AF_INET;
Provider->Mapping->Mapping[2].SocketType = SOCK_DGRAM;
Provider->Mapping->Mapping[2].Protocol = 0;
Provider->Mapping->Mapping[1].AddressFamily = AF_INET;
Provider->Mapping->Mapping[1].SocketType = SOCK_STREAM;
Provider->Mapping->Mapping[1].Protocol = IPPROTO_TCP;
Provider->Mapping->Mapping[3].AddressFamily = AF_INET;
Provider->Mapping->Mapping[3].SocketType = SOCK_DGRAM;
Provider->Mapping->Mapping[3].Protocol = IPPROTO_UDP;
Provider->Mapping->Mapping[2].AddressFamily = AF_INET;
Provider->Mapping->Mapping[2].SocketType = SOCK_DGRAM;
Provider->Mapping->Mapping[2].Protocol = 0;
Provider->Mapping->Mapping[4].AddressFamily = AF_INET;
Provider->Mapping->Mapping[4].SocketType = SOCK_RAW;
Provider->Mapping->Mapping[4].Protocol = IPPROTO_ICMP;
Provider->Mapping->Mapping[3].AddressFamily = AF_INET;
Provider->Mapping->Mapping[3].SocketType = SOCK_DGRAM;
Provider->Mapping->Mapping[3].Protocol = IPPROTO_UDP;
Provider->Mapping->Mapping[5].AddressFamily = AF_INET;
Provider->Mapping->Mapping[5].SocketType = SOCK_RAW;
Provider->Mapping->Mapping[5].Protocol = 0;
Provider->Mapping->Mapping[4].AddressFamily = AF_INET;
Provider->Mapping->Mapping[4].SocketType = SOCK_RAW;
Provider->Mapping->Mapping[4].Protocol = IPPROTO_ICMP;
Provider->Mapping->Mapping[5].AddressFamily = AF_INET;
Provider->Mapping->Mapping[5].SocketType = SOCK_RAW;
Provider->Mapping->Mapping[5].Protocol = 0;
#endif
}
VOID DestroyCatalog(VOID)
{
PLIST_ENTRY CurrentEntry;
PLIST_ENTRY NextEntry;
PCATALOG_ENTRY Provider;
PLIST_ENTRY CurrentEntry;
PLIST_ENTRY NextEntry;
PCATALOG_ENTRY Provider;
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead) {
NextEntry = CurrentEntry->Flink;
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
DestroyCatalogEntry(Provider);
CurrentEntry = NextEntry;
}
//DeleteCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead)
{
NextEntry = CurrentEntry->Flink;
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
DestroyCatalogEntry(Provider);
CurrentEntry = NextEntry;
}
//DeleteCriticalSection(&CatalogLock);
}
/* EOF */
reactos/dll/win32/ws2_32/misc/dllmain.c
+525 -437
View File
File diff suppressed because it is too large Load Diff
reactos/dll/win32/ws2_32/misc/event.c
+131 -115
View File
@@ -16,22 +16,22 @@
*/
BOOL
EXPORT
WSACloseEvent(
IN WSAEVENT hEvent)
WSACloseEvent(IN WSAEVENT hEvent)
{
BOOL Success;
BOOL Success;
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Success = CloseHandle((HANDLE)hEvent);
Success = CloseHandle((HANDLE)hEvent);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
return Success;
return Success;
}
@@ -42,19 +42,20 @@ WSAEVENT
EXPORT
WSACreateEvent(VOID)
{
HANDLE Event;
HANDLE Event;
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Event = CreateEventW(NULL, TRUE, FALSE, NULL);
Event = CreateEventW(NULL, TRUE, FALSE, NULL);
if (Event == INVALID_HANDLE_VALUE)
WSASetLastError(WSA_INVALID_HANDLE);
if (Event == INVALID_HANDLE_VALUE)
WSASetLastError(WSA_INVALID_HANDLE);
return (WSAEVENT)Event;
return (WSAEVENT)Event;
}
@@ -63,22 +64,22 @@ WSACreateEvent(VOID)
*/
BOOL
EXPORT
WSAResetEvent(
IN WSAEVENT hEvent)
WSAResetEvent(IN WSAEVENT hEvent)
{
BOOL Success;
BOOL Success;
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Success = ResetEvent((HANDLE)hEvent);
Success = ResetEvent((HANDLE)hEvent);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
return Success;
return Success;
}
@@ -87,22 +88,22 @@ WSAResetEvent(
*/
BOOL
EXPORT
WSASetEvent(
IN WSAEVENT hEvent)
WSASetEvent(IN WSAEVENT hEvent)
{
BOOL Success;
BOOL Success;
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Success = SetEvent((HANDLE)hEvent);
Success = SetEvent((HANDLE)hEvent);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
return Success;
return Success;
}
@@ -111,35 +112,40 @@ WSASetEvent(
*/
DWORD
EXPORT
WSAWaitForMultipleEvents(
IN DWORD cEvents,
IN CONST WSAEVENT FAR* lphEvents,
IN BOOL fWaitAll,
IN DWORD dwTimeout,
IN BOOL fAlertable)
WSAWaitForMultipleEvents(IN DWORD cEvents,
IN CONST WSAEVENT FAR* lphEvents,
IN BOOL fWaitAll,
IN DWORD dwTimeout,
IN BOOL fAlertable)
{
DWORD Status;
DWORD Status;
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Status = WaitForMultipleObjectsEx(cEvents, lphEvents, fWaitAll, dwTimeout, fAlertable);
if (Status == WAIT_FAILED) {
Status = GetLastError();
Status = WaitForMultipleObjectsEx(cEvents,
lphEvents,
fWaitAll,
dwTimeout,
fAlertable);
if (Status == WAIT_FAILED)
{
Status = GetLastError();
if (Status == ERROR_NOT_ENOUGH_MEMORY)
WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
else if (Status == ERROR_INVALID_HANDLE)
WSASetLastError(WSA_INVALID_HANDLE);
else
WSASetLastError(WSA_INVALID_PARAMETER);
if (Status == ERROR_NOT_ENOUGH_MEMORY)
WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
else if (Status == ERROR_INVALID_HANDLE)
WSASetLastError(WSA_INVALID_HANDLE);
else
WSASetLastError(WSA_INVALID_PARAMETER);
return WSA_WAIT_FAILED;
}
return WSA_WAIT_FAILED;
}
return Status;
return Status;
}
@@ -148,45 +154,52 @@ WSAWaitForMultipleEvents(
*/
INT
EXPORT
WSAEnumNetworkEvents(
IN SOCKET s,
IN WSAEVENT hEventObject,
OUT LPWSANETWORKEVENTS lpNetworkEvents)
WSAEnumNetworkEvents(IN SOCKET s,
IN WSAEVENT hEventObject,
OUT LPWSANETWORKEVENTS lpNetworkEvents)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
WS_DbgPrint(MID_TRACE,("Called (Socket %x, hEventObject %x, "
"lpNetworkEvents %x)\n",
s, hEventObject, lpNetworkEvents));
WS_DbgPrint(MID_TRACE,("Called (Socket %x, hEventObject %x, "
"lpNetworkEvents %x)\n",
s,
hEventObject,
lpNetworkEvents));
if (!lpNetworkEvents) {
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
}
if (!lpNetworkEvents)
{
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
}
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s,
&Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
Status = Provider->ProcTable.lpWSPEnumNetworkEvents(
s, hEventObject, lpNetworkEvents, &Errno);
Status = Provider->ProcTable.lpWSPEnumNetworkEvents(s,
hEventObject,
lpNetworkEvents,
&Errno);
DereferenceProviderByPointer(Provider);
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
WS_DbgPrint(MID_TRACE,("Leaving %x\n", Status));
WS_DbgPrint(MID_TRACE,("Leaving %x\n", Status));
return Status;
return Status;
}
@@ -195,34 +208,37 @@ WSAEnumNetworkEvents(
*/
INT
EXPORT
WSAEventSelect(
IN SOCKET s,
IN WSAEVENT hEventObject,
IN LONG lNetworkEvents)
WSAEventSelect(IN SOCKET s,
IN WSAEVENT hEventObject,
IN LONG lNetworkEvents)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
if (!WSAINITIALIZED) {
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
Status = Provider->ProcTable.lpWSPEventSelect(
s, hEventObject, lNetworkEvents, &Errno);
Status = Provider->ProcTable.lpWSPEventSelect(s,
hEventObject,
lNetworkEvents,
&Errno);
DereferenceProviderByPointer(Provider);
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
return Status;
return Status;
}
/* EOF */
reactos/dll/win32/ws2_32/misc/handle.c
+164 -150
View File
@@ -15,9 +15,8 @@ PPROVIDER_HANDLE_BLOCK ProviderHandleTable;
CRITICAL_SECTION ProviderHandleTableLock;
PPROVIDER_HANDLE
GetProviderByHandle(
PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle)
GetProviderByHandle(PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle)
/*
* FUNCTION: Get the data structure for a handle
* ARGUMENTS:
@@ -28,80 +27,84 @@ GetProviderByHandle(
* NULL on failure
*/
{
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
ULONG i;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X).\n", HandleTable, Handle));
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
ULONG i;
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry) {
Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X).\n", HandleTable, Handle));
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++) {
if ((Current->Handles[i].Provider != NULL) &&
(Current->Handles[i].Handle == Handle)) {
return &Current->Handles[i];
}
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry)
{
Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++)
{
if ((Current->Handles[i].Provider != NULL) &&
(Current->Handles[i].Handle == Handle))
{
return &Current->Handles[i];
}
}
CurrentEntry = CurrentEntry->Flink;
}
CurrentEntry = CurrentEntry->Flink;
}
return NULL;
return NULL;
}
VOID
CloseAllHandles(
PPROVIDER_HANDLE_BLOCK HandleTable)
CloseAllHandles(PPROVIDER_HANDLE_BLOCK HandleTable)
{
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
ULONG i;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X).\n", HandleTable));
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
ULONG i;
CurrentEntry = HandleTable->Entry.Flink;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X).\n", HandleTable));
while (CurrentEntry != &HandleTable->Entry) {
Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
CurrentEntry = HandleTable->Entry.Flink;
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++) {
Provider = Current->Handles[i].Provider;
if (Provider != NULL) {
DereferenceProviderByPointer(Provider);
Current->Handles[i].Handle = (HANDLE)0;
Current->Handles[i].Provider = NULL;
}
}
CurrentEntry = CurrentEntry->Flink;
}
while (CurrentEntry != &HandleTable->Entry)
{
Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++)
{
Provider = Current->Handles[i].Provider;
if (Provider != NULL)
{
DereferenceProviderByPointer(Provider);
Current->Handles[i].Handle = (HANDLE)0;
Current->Handles[i].Provider = NULL;
}
}
CurrentEntry = CurrentEntry->Flink;
}
}
VOID
DeleteHandleTable(
PPROVIDER_HANDLE_BLOCK HandleTable)
DeleteHandleTable(PPROVIDER_HANDLE_BLOCK HandleTable)
{
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
CloseAllHandles(HandleTable);
CurrentEntry = RemoveHeadList(&HandleTable->Entry);
while (CurrentEntry != &HandleTable->Entry) {
Current = CONTAINING_RECORD(
CurrentEntry,
PROVIDER_HANDLE_BLOCK,
Entry);
CloseAllHandles(HandleTable);
HeapFree(GlobalHeap, 0, Current);
CurrentEntry = RemoveHeadList(&HandleTable->Entry);
CurrentEntry = RemoveHeadList(&HandleTable->Entry);
}
while (CurrentEntry != &HandleTable->Entry)
{
Current = CONTAINING_RECORD(CurrentEntry,
PROVIDER_HANDLE_BLOCK,
Entry);
HeapFree(GlobalHeap, 0, Current);
CurrentEntry = RemoveHeadList(&HandleTable->Entry);
}
}
@@ -109,97 +112,103 @@ PCATALOG_ENTRY
DeleteProviderHandle(PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle)
{
PPROVIDER_HANDLE Entry;
PCATALOG_ENTRY Provider;
PPROVIDER_HANDLE Entry;
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X).\n", HandleTable, Handle));
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X).\n", HandleTable, Handle));
Entry = GetProviderByHandle(HandleTable, Handle);
if (!Entry)
return NULL;
Entry = GetProviderByHandle(HandleTable, Handle);
if (!Entry)
return NULL;
Provider = Entry->Provider;
Entry->Handle = (HANDLE)0;
Entry->Provider = NULL;
Provider = Entry->Provider;
Entry->Handle = (HANDLE)0;
Entry->Provider = NULL;
return Provider;
return Provider;
}
HANDLE
CreateProviderHandleTable(
PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle,
PCATALOG_ENTRY Provider)
CreateProviderHandleTable(PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle,
PCATALOG_ENTRY Provider)
{
PPROVIDER_HANDLE_BLOCK NewBlock;
PLIST_ENTRY CurrentEntry;
ULONG i;
PPROVIDER_HANDLE_BLOCK NewBlock;
PLIST_ENTRY CurrentEntry;
ULONG i;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X) Provider (0x%X).\n",
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X) Provider (0x%X).\n",
HandleTable, Handle, Provider));
/* Scan through the currently allocated handle blocks looking for a free slot */
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry) {
PPROVIDER_HANDLE_BLOCK Block = CONTAINING_RECORD(
CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
/* Scan through the currently allocated handle blocks looking for a free slot */
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry)
{
PPROVIDER_HANDLE_BLOCK Block = CONTAINING_RECORD(CurrentEntry,
PROVIDER_HANDLE_BLOCK,
Entry);
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++) {
WS_DbgPrint(MAX_TRACE, ("Considering slot %ld containing 0x%X.\n",
i, Block->Handles[i].Provider));
if (Block->Handles[i].Provider == NULL) {
Block->Handles[i].Handle = Handle;
Block->Handles[i].Provider = Provider;
return Handle;
}
}
CurrentEntry = CurrentEntry->Flink;
}
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++)
{
WS_DbgPrint(MAX_TRACE, ("Considering slot %ld containing 0x%X.\n",
i,
Block->Handles[i].Provider));
if (Block->Handles[i].Provider == NULL)
{
Block->Handles[i].Handle = Handle;
Block->Handles[i].Provider = Provider;
return Handle;
}
}
CurrentEntry = CurrentEntry->Flink;
}
/* Add a new handle block to the end of the list */
NewBlock = (PPROVIDER_HANDLE_BLOCK)HeapAlloc(
GlobalHeap, 0, sizeof(PROVIDER_HANDLE_BLOCK));
/* Add a new handle block to the end of the list */
NewBlock = (PPROVIDER_HANDLE_BLOCK)HeapAlloc(GlobalHeap,
0,
sizeof(PROVIDER_HANDLE_BLOCK));
WS_DbgPrint(MID_TRACE,("using table entry %x\n", NewBlock));
WS_DbgPrint(MID_TRACE,("using table entry %x\n", NewBlock));
if (!NewBlock)
return (HANDLE)0;
if (!NewBlock)
return (HANDLE)0;
ZeroMemory(NewBlock, sizeof(PROVIDER_HANDLE_BLOCK));
InsertTailList(&HandleTable->Entry, &NewBlock->Entry);
ZeroMemory(NewBlock, sizeof(PROVIDER_HANDLE_BLOCK));
InsertTailList(&HandleTable->Entry,
&NewBlock->Entry);
NewBlock->Handles[0].Handle = Handle;
NewBlock->Handles[0].Provider = Provider;
NewBlock->Handles[0].Handle = Handle;
NewBlock->Handles[0].Provider = Provider;
return Handle;
return Handle;
}
HANDLE
CreateProviderHandle(
HANDLE Handle,
PCATALOG_ENTRY Provider)
CreateProviderHandle(HANDLE Handle,
PCATALOG_ENTRY Provider)
{
HANDLE h;
HANDLE h;
EnterCriticalSection(&ProviderHandleTableLock);
EnterCriticalSection(&ProviderHandleTableLock);
h = CreateProviderHandleTable(ProviderHandleTable, Handle, Provider);
h = CreateProviderHandleTable(ProviderHandleTable,
Handle,
Provider);
LeaveCriticalSection(&ProviderHandleTableLock);
LeaveCriticalSection(&ProviderHandleTableLock);
if (h != NULL)
ReferenceProviderByPointer(Provider);
if (h != NULL)
ReferenceProviderByPointer(Provider);
return h;
return h;
}
BOOL
ReferenceProviderByHandle(
HANDLE Handle,
PCATALOG_ENTRY* Provider)
ReferenceProviderByHandle(HANDLE Handle,
PCATALOG_ENTRY* Provider)
/*
* FUNCTION: Increments the reference count for a provider and returns a pointer to it
* ARGUMENTS:
@@ -209,75 +218,80 @@ ReferenceProviderByHandle(
* TRUE if handle was valid, FALSE if not
*/
{
PPROVIDER_HANDLE ProviderHandle;
PPROVIDER_HANDLE ProviderHandle;
WS_DbgPrint(MID_TRACE, ("Handle (0x%X) Provider (0x%X).\n", Handle, Provider));
WS_DbgPrint(MID_TRACE, ("Handle (0x%X) Provider (0x%X).\n", Handle, Provider));
EnterCriticalSection(&ProviderHandleTableLock);
EnterCriticalSection(&ProviderHandleTableLock);
ProviderHandle = GetProviderByHandle(ProviderHandleTable, Handle);
ProviderHandle = GetProviderByHandle(ProviderHandleTable,
Handle);
WS_DbgPrint(MID_TRACE, ("ProviderHanddle is %x\n", ProviderHandle));
WS_DbgPrint(MID_TRACE, ("ProviderHanddle is %x\n", ProviderHandle));
LeaveCriticalSection(&ProviderHandleTableLock);
LeaveCriticalSection(&ProviderHandleTableLock);
if (ProviderHandle) {
ReferenceProviderByPointer(ProviderHandle->Provider);
*Provider = ProviderHandle->Provider;
}
if (ProviderHandle)
{
ReferenceProviderByPointer(ProviderHandle->Provider);
*Provider = ProviderHandle->Provider;
}
return (ProviderHandle != NULL);
return (ProviderHandle != NULL);
}
BOOL
CloseProviderHandle(
HANDLE Handle)
CloseProviderHandle(HANDLE Handle)
{
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("Handle (0x%X).\n", Handle));
PCATALOG_ENTRY Provider;
EnterCriticalSection(&ProviderHandleTableLock);
WS_DbgPrint(MAX_TRACE, ("Handle (0x%X).\n", Handle));
Provider = DeleteProviderHandle(ProviderHandleTable, Handle);
if (!Provider)
return FALSE;
EnterCriticalSection(&ProviderHandleTableLock);
LeaveCriticalSection(&ProviderHandleTableLock);
Provider = DeleteProviderHandle(ProviderHandleTable,
Handle);
if (!Provider)
return FALSE;
DereferenceProviderByPointer(Provider);
LeaveCriticalSection(&ProviderHandleTableLock);
return TRUE;
DereferenceProviderByPointer(Provider);
return TRUE;
}
BOOL
InitProviderHandleTable(VOID)
{
ProviderHandleTable = (PPROVIDER_HANDLE_BLOCK)
HeapAlloc(GlobalHeap, 0, sizeof(PROVIDER_HANDLE_BLOCK));
if (!ProviderHandleTable)
return FALSE;
ProviderHandleTable =
(PPROVIDER_HANDLE_BLOCK)HeapAlloc(GlobalHeap,
0,
sizeof(PROVIDER_HANDLE_BLOCK));
if (!ProviderHandleTable)
return FALSE;
WS_DbgPrint(MID_TRACE,("Called\n"));
WS_DbgPrint(MID_TRACE,("Called\n"));
ZeroMemory(ProviderHandleTable, sizeof(PROVIDER_HANDLE_BLOCK));
ZeroMemory(ProviderHandleTable,
sizeof(PROVIDER_HANDLE_BLOCK));
InitializeListHead(&ProviderHandleTable->Entry);
InitializeListHead(&ProviderHandleTable->Entry);
InitializeCriticalSection(&ProviderHandleTableLock);
InitializeCriticalSection(&ProviderHandleTableLock);
return TRUE;
return TRUE;
}
VOID
FreeProviderHandleTable(VOID)
{
DeleteHandleTable(ProviderHandleTable);
DeleteHandleTable(ProviderHandleTable);
DeleteCriticalSection(&ProviderHandleTableLock);
DeleteCriticalSection(&ProviderHandleTableLock);
}
/* EOF */
reactos/dll/win32/ws2_32/misc/ns.c
+699 -588
View File
File diff suppressed because it is too large Load Diff
reactos/dll/win32/ws2_32/misc/sndrcv.c
+262 -179
View File
@@ -20,25 +20,36 @@
*/
INT
EXPORT
recv(
IN SOCKET s,
OUT CHAR FAR* buf,
IN INT len,
IN INT flags)
recv(IN SOCKET s,
OUT CHAR FAR* buf,
IN INT len,
IN INT flags)
{
DWORD Error;
DWORD BytesReceived;
WSABUF WSABuf;
DWORD Error;
DWORD BytesReceived;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s, buf, len, flags));
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSARecv(s, &WSABuf, 1, &BytesReceived, (LPDWORD)&flags, NULL, NULL);
Error = WSARecv(s,
&WSABuf,
1,
&BytesReceived,
(LPDWORD)&flags,
NULL,
NULL);
if( Error ) return -1; else return BytesReceived;
if( Error )
return -1;
else
return BytesReceived;
}
@@ -47,27 +58,40 @@ recv(
*/
INT
EXPORT
recvfrom(
IN SOCKET s,
OUT CHAR FAR* buf,
IN INT len,
IN INT flags,
OUT LPSOCKADDR from,
IN OUT INT FAR* fromlen)
recvfrom(IN SOCKET s,
OUT CHAR FAR* buf,
IN INT len,
IN INT flags,
OUT LPSOCKADDR from,
IN OUT INT FAR* fromlen)
{
DWORD Error;
DWORD BytesReceived;
WSABUF WSABuf;
DWORD Error;
DWORD BytesReceived;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s, buf, len, flags));
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSARecvFrom(s, &WSABuf, 1, &BytesReceived, (LPDWORD)&flags, from, fromlen, NULL, NULL);
Error = WSARecvFrom(s,
&WSABuf,
1,
&BytesReceived,
(LPDWORD)&flags,
from,
fromlen,
NULL,
NULL);
if( Error ) return -1; else return BytesReceived;
if( Error )
return -1;
else
return BytesReceived;
}
@@ -76,31 +100,42 @@ recvfrom(
*/
INT
EXPORT
send(
IN SOCKET s,
IN CONST CHAR FAR* buf,
IN INT len,
IN INT flags)
send(IN SOCKET s,
IN CONST CHAR FAR* buf,
IN INT len,
IN INT flags)
{
DWORD BytesSent;
DWORD Error;
WSABUF WSABuf;
DWORD BytesSent;
DWORD Error;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s, buf, len, flags));
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSASend(s, &WSABuf, 1, &BytesSent, flags, NULL, NULL);
Error = WSASend(s,
&WSABuf,
1,
&BytesSent,
flags,
NULL,
NULL);
if( Error ) {
WS_DbgPrint(MAX_TRACE,("Reporting error %d\n", Error));
return -1;
} else {
WS_DbgPrint(MAX_TRACE,("Read %d bytes\n", BytesSent));
return BytesSent;
}
if( Error )
{
WS_DbgPrint(MAX_TRACE,("Reporting error %d\n", Error));
return -1;
}
else
{
WS_DbgPrint(MAX_TRACE,("Read %d bytes\n", BytesSent));
return BytesSent;
}
}
@@ -109,27 +144,40 @@ send(
*/
INT
EXPORT
sendto(
IN SOCKET s,
IN CONST CHAR FAR* buf,
IN INT len,
IN INT flags,
IN CONST struct sockaddr *to,
IN INT tolen)
sendto(IN SOCKET s,
IN CONST CHAR FAR* buf,
IN INT len,
IN INT flags,
IN CONST struct sockaddr *to,
IN INT tolen)
{
DWORD Error;
DWORD BytesSent;
WSABUF WSABuf;
DWORD Error;
DWORD BytesSent;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s, buf, len, flags));
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSASendTo(s, &WSABuf, 1, &BytesSent, flags, to, tolen, NULL, NULL);
Error = WSASendTo(s,
&WSABuf,
1,
&BytesSent,
flags,
to,
tolen,
NULL,
NULL);
if( Error ) return -1; else return BytesSent;
if( Error )
return -1;
else
return BytesSent;
}
@@ -138,38 +186,45 @@ sendto(
*/
INT
EXPORT
WSARecv(
IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
WSARecv(IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s,
&Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPRecv);
assert(Provider->ProcTable.lpWSPRecv);
Code = Provider->ProcTable.lpWSPRecv(s, lpBuffers, dwBufferCount,
lpNumberOfBytesRecvd, lpFlags, lpOverlapped,
lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
Code = Provider->ProcTable.lpWSPRecv(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesRecvd,
lpFlags,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
return Code;
}
@@ -178,13 +233,12 @@ WSARecv(
*/
INT
EXPORT
WSARecvDisconnect(
IN SOCKET s,
OUT LPWSABUF lpInboundDisconnectData)
WSARecvDisconnect(IN SOCKET s,
OUT LPWSABUF lpInboundDisconnectData)
{
UNIMPLEMENTED
UNIMPLEMENTED
return 0;
return 0;
}
@@ -193,40 +247,48 @@ WSARecvDisconnect(
*/
INT
EXPORT
WSARecvFrom(
IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
OUT LPSOCKADDR lpFrom,
IN OUT LPINT lpFromlen,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
WSARecvFrom(IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
OUT LPSOCKADDR lpFrom,
IN OUT LPINT lpFromlen,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPRecvFrom);
assert(Provider->ProcTable.lpWSPRecvFrom);
Code = Provider->ProcTable.lpWSPRecvFrom(s, lpBuffers, dwBufferCount,
lpNumberOfBytesRecvd, lpFlags, lpFrom, lpFromlen, lpOverlapped,
lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
Code = Provider->ProcTable.lpWSPRecvFrom(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesRecvd,
lpFlags,
lpFrom,
lpFromlen,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
return Code;
}
@@ -235,38 +297,44 @@ WSARecvFrom(
*/
INT
EXPORT
WSASend(
IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
WSASend(IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPSend);
assert(Provider->ProcTable.lpWSPSend);
Code = Provider->ProcTable.lpWSPSend(s, lpBuffers, dwBufferCount,
lpNumberOfBytesSent, dwFlags, lpOverlapped,
lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
Code = Provider->ProcTable.lpWSPSend(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesSent,
dwFlags,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
return Code;
}
@@ -275,13 +343,12 @@ WSASend(
*/
INT
EXPORT
WSASendDisconnect(
IN SOCKET s,
IN LPWSABUF lpOutboundDisconnectData)
WSASendDisconnect(IN SOCKET s,
IN LPWSABUF lpOutboundDisconnectData)
{
UNIMPLEMENTED
UNIMPLEMENTED
return 0;
return 0;
}
@@ -290,46 +357,62 @@ WSASendDisconnect(
*/
INT
EXPORT
WSASendTo(
IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN CONST struct sockaddr *lpTo,
IN INT iToLen,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
WSASendTo(IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN CONST struct sockaddr *lpTo,
IN INT iToLen,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPSendTo);
assert(Provider->ProcTable.lpWSPSendTo);
#if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
Code = Provider->ProcTable.lpWSPSendTo(s, lpBuffers, dwBufferCount,
lpNumberOfBytesSent, dwFlags, (CONST LPSOCKADDR) lpTo, iToLen, lpOverlapped,
lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
Code = Provider->ProcTable.lpWSPSendTo(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesSent,
dwFlags,
(CONST LPSOCKADDR)lpTo,
iToLen,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
#else
Code = Provider->ProcTable.lpWSPSendTo(s, lpBuffers, dwBufferCount,
lpNumberOfBytesSent, dwFlags, lpTo, iToLen, lpOverlapped,
lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
Code = Provider->ProcTable.lpWSPSendTo(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesSent,
dwFlags,
lpTo,
iToLen,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
#endif /* __W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5 */
DereferenceProviderByPointer(Provider);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
return Code;
}
/* EOF */
reactos/dll/win32/ws2_32/misc/stubs.c
+401 -439
View File
File diff suppressed because it is too large Load Diff
reactos/dll/win32/ws2_32/misc/upcall.c
+53 -67
View File
@@ -17,9 +17,8 @@
*/
BOOL
WSPAPI
WPUCloseEvent(
IN WSAEVENT hEvent,
OUT LPINT lpErrno)
WPUCloseEvent(IN WSAEVENT hEvent,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -32,9 +31,8 @@ WPUCloseEvent(
*/
INT
WSPAPI
WPUCloseSocketHandle(
IN SOCKET s,
OUT LPINT lpErrno)
WPUCloseSocketHandle(IN SOCKET s,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -47,9 +45,8 @@ WPUCloseSocketHandle(
*/
INT
WSPAPI
WPUCloseThread(
IN LPWSATHREADID lpThreadId,
OUT LPINT lpErrno)
WPUCloseThread(IN LPWSATHREADID lpThreadId,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -62,8 +59,7 @@ WPUCloseThread(
*/
WSAEVENT
WSPAPI
WPUCreateEvent(
OUT LPINT lpErrno)
WPUCreateEvent(OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -76,10 +72,9 @@ WPUCreateEvent(
*/
SOCKET
WSPAPI
WPUCreateSocketHandle(
IN DWORD dwCatalogEntryId,
IN DWORD dwContext,
OUT LPINT lpErrno)
WPUCreateSocketHandle(IN DWORD dwCatalogEntryId,
IN DWORD dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -92,9 +87,8 @@ WPUCreateSocketHandle(
*/
SOCKET
WSPAPI
WPUFDIsSet(
IN SOCKET s,
IN LPFD_SET set)
WPUFDIsSet(IN SOCKET s,
IN LPFD_SET set)
{
UNIMPLEMENTED
@@ -107,11 +101,10 @@ WPUFDIsSet(
*/
INT
WSPAPI
WPUGetProviderPath(
IN LPGUID lpProviderId,
OUT LPWSTR lpszProviderDllPath,
IN OUT LPINT lpProviderDllPathLen,
OUT LPINT lpErrno)
WPUGetProviderPath(IN LPGUID lpProviderId,
OUT LPWSTR lpszProviderDllPath,
IN OUT LPINT lpProviderDllPathLen,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -124,34 +117,33 @@ WPUGetProviderPath(
*/
SOCKET
WSPAPI
WPUModifyIFSHandle(
IN DWORD dwCatalogEntryId,
IN SOCKET ProposedHandle,
OUT LPINT lpErrno)
WPUModifyIFSHandle(IN DWORD dwCatalogEntryId,
IN SOCKET ProposedHandle,
OUT LPINT lpErrno)
{
PCATALOG_ENTRY Provider;
SOCKET Socket;
PCATALOG_ENTRY Provider;
SOCKET Socket;
WS_DbgPrint(MID_TRACE, ("dwCatalogEntryId (%d) ProposedHandle (0x%X).\n",
WS_DbgPrint(MID_TRACE, ("dwCatalogEntryId (%d) ProposedHandle (0x%X).\n",
dwCatalogEntryId, ProposedHandle));
Provider = LocateProviderById(dwCatalogEntryId);
if (!Provider) {
WS_DbgPrint(MIN_TRACE, ("Provider with catalog entry id (%d) was not found.\n",
dwCatalogEntryId));
if( lpErrno ) *lpErrno = WSAEINVAL;
WS_DbgPrint(MID_TRACE, ("Returning invalid socket\n"));
return INVALID_SOCKET;
}
Provider = LocateProviderById(dwCatalogEntryId);
if (!Provider)
{
WS_DbgPrint(MIN_TRACE, ("Provider with catalog entry id (%d) was not found.\n",
dwCatalogEntryId));
if( lpErrno ) *lpErrno = WSAEINVAL;
WS_DbgPrint(MID_TRACE, ("Returning invalid socket\n"));
return INVALID_SOCKET;
}
Socket = (SOCKET)CreateProviderHandle(
(HANDLE)ProposedHandle,
Provider);
Socket = (SOCKET)CreateProviderHandle((HANDLE)ProposedHandle,
Provider);
if( lpErrno ) *lpErrno = NO_ERROR;
if( lpErrno ) *lpErrno = NO_ERROR;
WS_DbgPrint(MID_TRACE, ("Socket: %x\n", Socket));
return Socket;
WS_DbgPrint(MID_TRACE, ("Socket: %x\n", Socket));
return Socket;
}
@@ -160,9 +152,8 @@ WPUModifyIFSHandle(
*/
INT
WSPAPI
WPUOpenCurrentThread(
OUT LPWSATHREADID lpThreadId,
OUT LPINT lpErrno)
WPUOpenCurrentThread(OUT LPWSATHREADID lpThreadId,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -175,11 +166,10 @@ WPUOpenCurrentThread(
*/
INT
WSPAPI
WPUQueryBlockingCallback(
IN DWORD dwCatalogEntryId,
OUT LPBLOCKINGCALLBACK FAR* lplpfnCallback,
OUT LPDWORD lpdwContext,
OUT LPINT lpErrno)
WPUQueryBlockingCallback(IN DWORD dwCatalogEntryId,
OUT LPBLOCKINGCALLBACK FAR* lplpfnCallback,
OUT LPDWORD lpdwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -192,10 +182,9 @@ WPUQueryBlockingCallback(
*/
INT
WSPAPI
WPUQuerySocketHandleContext(
IN SOCKET s,
OUT LPDWORD lpContext,
OUT LPINT lpErrno)
WPUQuerySocketHandleContext(IN SOCKET s,
OUT LPDWORD lpContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -208,11 +197,10 @@ WPUQuerySocketHandleContext(
*/
INT
WSPAPI
WPUQueueApc(
IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
IN DWORD dwContext,
OUT LPINT lpErrno)
WPUQueueApc(IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
IN DWORD dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -225,9 +213,8 @@ WPUQueueApc(
*/
BOOL
WSPAPI
WPUResetEvent(
IN WSAEVENT hEvent,
OUT LPINT lpErrno)
WPUResetEvent(IN WSAEVENT hEvent,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
@@ -240,9 +227,8 @@ WPUResetEvent(
*/
BOOL
WSPAPI
WPUSetEvent(
IN WSAEVENT hEvent,
OUT LPINT lpErrno)
WPUSetEvent(IN WSAEVENT hEvent,
OUT LPINT lpErrno)
{
UNIMPLEMENTED