ReactOS 0.4.15-dev-7942-gd23573b
Macros | Functions | Variables
WSARecv.c File Reference
#include "ws2_32.h"
Include dependency graph for WSARecv.c:

Go to the source code of this file.

Macros

#define RECV_BUF   4
 
#define WSARecv_TIMEOUT   2000
 

Functions

void CALLBACK completion (DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)
 
void Test_WSARecv ()
 
 START_TEST (WSARecv)
 

Variables

static int count = 0
 

Macro Definition Documentation

◆ RECV_BUF

#define RECV_BUF   4

Definition at line 10 of file WSARecv.c.

◆ WSARecv_TIMEOUT

#define WSARecv_TIMEOUT   2000

Definition at line 11 of file WSARecv.c.

Function Documentation

◆ completion()

void CALLBACK completion ( DWORD  dwError,
DWORD  cbTransferred,
LPWSAOVERLAPPED  lpOverlapped,
DWORD  dwFlags 
)

Definition at line 16 of file WSARecv.c.

21{
22 //trace("completion called dwFlags %ld cbTransferred %ld lpOverlapped %p dwFlags %ld\n", dwError, cbTransferred, lpOverlapped, dwFlags);
23 count++;
24 ok(count == 1, "completion sould be called only once count = %d\n", count);
25 ok(dwError == 0, "dwError = %ld\n", dwError);
26 ok(cbTransferred == RECV_BUF, "cbTransferred %ld != %d\n", cbTransferred, RECV_BUF);
27 ok(lpOverlapped != NULL, "lpOverlapped %p\n", lpOverlapped);
28 if (lpOverlapped)
29 {
30 ok(lpOverlapped->hEvent != INVALID_HANDLE_VALUE, "lpOverlapped->hEvent %p\n", lpOverlapped->hEvent);
31 if (lpOverlapped->hEvent != INVALID_HANDLE_VALUE)
32 WSASetEvent(lpOverlapped->hEvent);
33 }
34}
RECV_BUF
#define RECV_BUF
Definition: WSARecv.c:10
ok
#define ok(value,...)
Definition: atltest.h:57
NULL
#define NULL
Definition: types.h:112
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
WSASetEvent
BOOL WSAAPI WSASetEvent(IN WSAEVENT hEvent)
Definition: event.c:64
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
lpOverlapped
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:93

Referenced by _check_pipe_handle_state(), and Test_WSARecv().

◆ START_TEST()

START_TEST ( WSARecv  )

Definition at line 203 of file WSARecv.c.

204{
205 Test_WSARecv();
206}
Test_WSARecv
void Test_WSARecv()
Definition: WSARecv.c:36

◆ Test_WSARecv()

void Test_WSARecv ( )

Definition at line 36 of file WSARecv.c.

37{
38 const char szDummyBytes[RECV_BUF] = { 0xFF, 0x00, 0xFF, 0x00 };
39
40 char szBuf[RECV_BUF];
41 char szRecvBuf[RECV_BUF];
42 int iResult, err;
43 SOCKET sck;
44 WSADATA wdata;
45 WSABUF buffers;
46 DWORD dwRecv, dwSent, dwFlags;
47 WSAOVERLAPPED overlapped;
48 char szGetRequest[] = "GET / HTTP/1.0\r\n\r\n";
49 struct fd_set readable;
50 BOOL ret;
51
52 /* Start up Winsock */
53 iResult = WSAStartup(MAKEWORD(2, 2), &wdata);
54 ok(iResult == 0, "WSAStartup failed, iResult == %d\n", iResult);
55
56 /* If we call recv without a socket, it should return with an error and do nothing. */
57 memcpy(szBuf, szDummyBytes, RECV_BUF);
58 buffers.buf = szBuf;
59 buffers.len = sizeof(szBuf);
60 dwFlags = 0;
61 dwRecv = 0;
62 iResult = WSARecv(0, &buffers, 1, &dwRecv, &dwFlags, NULL, NULL);
63 ok(iResult == SOCKET_ERROR, "iRseult = %d\n", iResult);
64 ok(!memcmp(szBuf, szDummyBytes, RECV_BUF), "not equal\n");
65
66 /* Create the socket */
67 sck = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
68 if(sck == INVALID_SOCKET)
69 {
70 WSACleanup();
71 skip("CreateSocket failed. Aborting test.\n");
72 return;
73 }
74
75 /* Now we can pass at least a socket, but we have no connection yet. Should return with an error and do nothing. */
76 memcpy(szBuf, szDummyBytes, RECV_BUF);
77 buffers.buf = szBuf;
78 buffers.len = sizeof(szBuf);
79 dwFlags = 0;
80 dwRecv = 0;
81 iResult = WSARecv(sck, &buffers, 1, &dwRecv, &dwFlags, NULL, NULL);
82 ok(iResult == SOCKET_ERROR, "iResult = %d\n", iResult);
83 ok(!memcmp(szBuf, szDummyBytes, RECV_BUF), "not equal\n");
84
85 /* Connect to "www.reactos.org" */
86 if (!ConnectToReactOSWebsite(sck))
87 {
88 WSACleanup();
89 skip("ConnectToReactOSWebsite failed. Aborting test.\n");
90 return;
91 }
92
93 /* prepare overlapped */
94 memset(&overlapped, 0, sizeof(overlapped));
95 overlapped.hEvent = WSACreateEvent();
96
97 /* Send the GET request */
98 buffers.buf = szGetRequest;
99 buffers.len = lstrlenA(szGetRequest);
100 dwSent = 0;
101 WSASetLastError(0xdeadbeef);
102 iResult = WSASend(sck, &buffers, 1, &dwSent, 0, &overlapped, NULL);
103 err = WSAGetLastError();
104 ok(iResult == 0 || (iResult == SOCKET_ERROR && err == WSA_IO_PENDING), "iResult = %d, %d\n", iResult, err);
105 if (err == WSA_IO_PENDING)
106 {
107 iResult = WSAWaitForMultipleEvents(1, &overlapped.hEvent, TRUE, WSARecv_TIMEOUT, TRUE);
108 ok(iResult == WSA_WAIT_EVENT_0, "WSAWaitForMultipleEvents failed %d\n", iResult);
109 ret = WSAGetOverlappedResult(sck, &overlapped, &dwSent, TRUE, &dwFlags);
110 ok(ret, "WSAGetOverlappedResult failed %d\n", WSAGetLastError());
111 }
112 ok(dwSent == strlen(szGetRequest), "dwSent %ld != %d\n", dwSent, strlen(szGetRequest));
113#if 0 /* break windows too */
114 /* Shutdown the SEND connection */
115 iResult = shutdown(sck, SD_SEND);
116 ok(iResult != SOCKET_ERROR, "iResult = %d\n", iResult);
117#endif
118 /* Wait until we're ready to read */
119 FD_ZERO(&readable);
120 FD_SET(sck, &readable);
121
122 iResult = select(0, &readable, NULL, NULL, NULL);
123 ok(iResult != SOCKET_ERROR, "iResult = %d\n", iResult);
124
125 /* Receive the data. */
126 buffers.buf = szBuf;
127 buffers.len = sizeof(szBuf);
128 dwRecv = sizeof(szBuf);
129 iResult = WSARecv(sck, &buffers, 1, &dwRecv, &dwFlags, NULL, NULL);
130 ok(iResult != SOCKET_ERROR, "iResult = %d\n", iResult);
131 ok(dwRecv == sizeof(szBuf), "dwRecv %ld != %d\n", dwRecv, sizeof(szBuf));
132 /* MSG_PEEK is invalid for overlapped (MSDN), but passes??? */
133 buffers.buf = szRecvBuf;
134 buffers.len = sizeof(szRecvBuf);
135 dwFlags = MSG_PEEK;
136 dwRecv = sizeof(szRecvBuf);
137 ok(overlapped.hEvent != NULL, "WSACreateEvent failed %d\n", WSAGetLastError());
138 WSASetLastError(0xdeadbeef);
139 iResult = WSARecv(sck, &buffers, 1, &dwRecv, &dwFlags, &overlapped, NULL);
140 err = WSAGetLastError();
141 ok(iResult == 0 || (iResult == SOCKET_ERROR && err == WSA_IO_PENDING), "iResult = %d, %d\n", iResult, err);
142 if (err == WSA_IO_PENDING)
143 {
144 iResult = WSAWaitForMultipleEvents(1, &overlapped.hEvent, TRUE, WSARecv_TIMEOUT, TRUE);
145 ok(iResult == WSA_WAIT_EVENT_0, "WSAWaitForMultipleEvents failed %d\n", iResult);
146 ret = WSAGetOverlappedResult(sck, &overlapped, &dwRecv, TRUE, &dwFlags);
147 ok(ret, "WSAGetOverlappedResult failed %d\n", WSAGetLastError());
148 }
149 ok(dwRecv == sizeof(szRecvBuf), "dwRecv %ld != %d\n", dwRecv, sizeof(szRecvBuf));
150 /* normal overlapped, no completion */
151 buffers.buf = szBuf;
152 buffers.len = sizeof(szBuf);
153 dwFlags = 0;
154 dwRecv = sizeof(szBuf);
155 WSAResetEvent(overlapped.hEvent);
156 WSASetLastError(0xdeadbeef);
157 iResult = WSARecv(sck, &buffers, 1, &dwRecv, &dwFlags, &overlapped, NULL);
158 err = WSAGetLastError();
159 ok(iResult == 0 || (iResult == SOCKET_ERROR && err == WSA_IO_PENDING), "iResult = %d, %d\n", iResult, err);
160 if (err == WSA_IO_PENDING)
161 {
162 iResult = WSAWaitForMultipleEvents(1, &overlapped.hEvent, TRUE, WSARecv_TIMEOUT, TRUE);
163 ok(iResult == WSA_WAIT_EVENT_0, "WSAWaitForMultipleEvents failed %d\n", iResult);
164 ret = WSAGetOverlappedResult(sck, &overlapped, &dwRecv, TRUE, &dwFlags);
165 ok(ret, "WSAGetOverlappedResult failed %d\n", WSAGetLastError());
166 }
167 ok(dwRecv == sizeof(szBuf), "dwRecv %ld != %d\n", dwRecv, sizeof(szBuf));
168 ok(memcmp(szRecvBuf, szBuf, sizeof(szBuf)) == 0, "MSG_PEEK shouldn't have moved the pointer\n");
169 /* overlapped with completion */
170 dwFlags = 0;
171 dwRecv = sizeof(szBuf);
172 WSAResetEvent(overlapped.hEvent);
173 WSASetLastError(0xdeadbeef);
174 iResult = WSARecv(sck, &buffers, 1, &dwRecv, &dwFlags, &overlapped, &completion);
175 err = WSAGetLastError();
176 ok(iResult == 0 || (iResult == SOCKET_ERROR && err == WSA_IO_PENDING), "iResult = %d, %d\n", iResult, err);
177 if (err == WSA_IO_PENDING)
178 {
179 iResult = WSAWaitForMultipleEvents(1, &overlapped.hEvent, TRUE, WSARecv_TIMEOUT, TRUE);
180 ok(iResult == WSA_WAIT_EVENT_0, "WSAWaitForMultipleEvents failed %d\n", iResult);
181 ret = WSAGetOverlappedResult(sck, &overlapped, &dwRecv, TRUE, &dwFlags);
182 ok(ret, "WSAGetOverlappedResult failed %d\n", WSAGetLastError());
183 }
184 ret = WSACloseEvent(overlapped.hEvent);
185 ok(ret, "WSACloseEvent failed %d\n", WSAGetLastError());
186 ok(dwRecv == sizeof(szBuf), "dwRecv %ld != %d\n", dwRecv, sizeof(szBuf));
187 /* no overlapped with completion */
188 dwFlags = 0;
189 dwRecv = sizeof(szBuf);
190 WSASetLastError(0xdeadbeef);
191 /* call doesn't fail, but completion is not called */
192 iResult = WSARecv(sck, &buffers, 1, &dwRecv, &dwFlags, NULL, &completion);
193 err = WSAGetLastError();
194 ok(iResult == 0 || (iResult == SOCKET_ERROR && err == WSA_IO_PENDING), "iResult = %d, %d\n", iResult, err);
195 ok(err == 0, "WSARecv failed %d\n", err);
196 ok(dwRecv == sizeof(szBuf), "dwRecv %ld != %d and 0\n", dwRecv, sizeof(szBuf));
197
198 closesocket(sck);
199 WSACleanup();
200 return;
201}
WSARecv_TIMEOUT
#define WSARecv_TIMEOUT
Definition: WSARecv.c:11
completion
void CALLBACK completion(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)
Definition: WSARecv.c:16
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
skip
#define skip(...)
Definition: atltest.h:64
TRUE
#define TRUE
Definition: types.h:120
WSASetLastError
VOID WSAAPI WSASetLastError(IN INT iError)
Definition: dllmain.c:123
WSAResetEvent
BOOL WSAAPI WSAResetEvent(IN WSAEVENT hEvent)
Definition: event.c:53
WSACloseEvent
BOOL WSAAPI WSACloseEvent(IN WSAEVENT hEvent)
Definition: event.c:23
WSAWaitForMultipleEvents
DWORD WSAAPI WSAWaitForMultipleEvents(IN DWORD cEvents, IN CONST WSAEVENT FAR *lphEvents, IN BOOL fWaitAll, IN DWORD dwTimeout, IN BOOL fAlertable)
Definition: event.c:75
WSARecv
INT WSAAPI 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)
Definition: recv.c:155
select
INT WSAAPI select(IN INT s, IN OUT LPFD_SET readfds, IN OUT LPFD_SET writefds, IN OUT LPFD_SET exceptfds, IN CONST struct timeval *timeout)
Definition: select.c:41
WSASend
INT WSAAPI WSASend(IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, OUT LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
Definition: send.c:145
WSAStartup
INT WINAPI WSAStartup(IN WORD wVersionRequested, OUT LPWSADATA lpWSAData)
Definition: startup.c:113
IPPROTO_TCP
#define IPPROTO_TCP
Definition: ip.h:196
SOCK_STREAM
#define SOCK_STREAM
Definition: tcpip.h:118
AF_INET
#define AF_INET
Definition: tcpip.h:117
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
buffers
const GLuint * buffers
Definition: glext.h:5916
lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ConnectToReactOSWebsite
int ConnectToReactOSWebsite(SOCKET sck)
Definition: helpers.c:27
closesocket
#define closesocket
Definition: ncftp.h:477
err
#define err(...)
Definition: reactos_support_code.h:30
memset
#define memset(x, y, z)
Definition: compat.h:39
overlapped
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:81
shutdown
INT WSAAPI shutdown(IN SOCKET s, IN INT how)
Definition: sockctrl.c:506
WSAGetOverlappedResult
BOOL WSAAPI WSAGetOverlappedResult(IN SOCKET s, IN LPWSAOVERLAPPED lpOverlapped, OUT LPDWORD lpcbTransfer, IN BOOL fWait, OUT LPDWORD lpdwFlags)
Definition: sockctrl.c:603
WSASocketW
SOCKET WSAAPI WSASocketW(IN INT af, IN INT type, IN INT protocol, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, IN GROUP g, IN DWORD dwFlags)
Definition: socklife.c:490
_WSABUF
Definition: ws2def.h:518
_WSAOVERLAPPED
Definition: winsock2.h:608
fd_set
Definition: winsock.h:66
MAKEWORD
#define MAKEWORD(a, b)
Definition: typedefs.h:248
ret
int ret
Definition: wcstombs-tests.c:31
dwFlags
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
WSA_WAIT_EVENT_0
#define WSA_WAIT_EVENT_0
Definition: winsock2.h:626
WSA_FLAG_OVERLAPPED
#define WSA_FLAG_OVERLAPPED
Definition: winsock2.h:466
WSACreateEvent
WINSOCK_API_LINKAGE WSAEVENT WSAAPI WSACreateEvent(void)
Definition: event.c:42
WSA_IO_PENDING
#define WSA_IO_PENDING
Definition: winsock2.h:616
WSAGetLastError
int PASCAL FAR WSAGetLastError(void)
Definition: dllmain.c:112
FD_ZERO
#define FD_ZERO(set)
Definition: winsock.h:96
WSACleanup
int PASCAL FAR WSACleanup(void)
Definition: startup.c:60
INVALID_SOCKET
#define INVALID_SOCKET
Definition: winsock.h:332
SOCKET
UINT_PTR SOCKET
Definition: winsock.h:47
MSG_PEEK
#define MSG_PEEK
Definition: winsock.h:222
SOCKET_ERROR
#define SOCKET_ERROR
Definition: winsock.h:333
SD_SEND
#define SD_SEND
Definition: winsock.h:55
FD_SET
#define FD_SET(fd, set)
Definition: winsock.h:89

Referenced by START_TEST().

Variable Documentation

◆ count

int count = 0
static

Definition at line 13 of file WSARecv.c.