version 1.15, 2005/02/22 06:04:46
|
version 1.30, 2005/02/25 06:39:52
|
|
|
/* | /* |
* Unit tests for 32-bit socket functions in Wine |
* Unit tests for 32-bit WinSock 1.1 functions in Wine |
* | * |
* Copyright (c) 2005 Thomas Kho, Fredy Garcia, Douglas Rosenberg | * Copyright (c) 2005 Thomas Kho, Fredy Garcia, Douglas Rosenberg |
|
* standalone boilerplate copyright (c) 2004,2005 Dan Kegel |
* | * |
* This library is free software; you can redistribute it and/or | * This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public | * modify it under the terms of the GNU Lesser General Public |
|
|
#include <winsock.h> | #include <winsock.h> |
#include <wtypes.h> | #include <wtypes.h> |
#include <winerror.h> | #include <winerror.h> |
#include <string.h> |
|
| |
|
/* To build outside Wine tree, compile with cl -DSTANDALONE -D_X86_ wsock32_main.c wsock32.lib */ |
#ifndef STANDALONE | #ifndef STANDALONE |
#include "wine/test.h" | #include "wine/test.h" |
#else | #else |
#include <assert.h> |
#include <stdarg.h> |
|
#include <stdio.h> |
#define START_TEST(name) main(int argc, char **argv) | #define START_TEST(name) main(int argc, char **argv) |
#define ok(condition, msg) \ | #define ok(condition, msg) \ |
do { \ | do { \ |
if(!(condition)) \ | if(!(condition)) \ |
{ \ | { \ |
fprintf(stderr,"failed at %d\n",__LINE__); \ | fprintf(stderr,"failed at %d\n",__LINE__); \ |
exit(0); \ |
exit(1); \ |
} \ | } \ |
} while(0) | } while(0) |
| |
#define todo_wine | #define todo_wine |
|
static void trace(const char *s, ...) |
|
{ |
|
va_list elipsis; |
|
va_start (elipsis, s); |
|
vprintf(s, elipsis); |
|
va_end(elipsis); |
|
} |
#endif | #endif |
| |
#define NUM_CLIENTS 1 |
// clients threads to create |
|
#define NUM_CLIENTS 64 |
|
|
// amount of data to transfer from each client to server | // amount of data to transfer from each client to server |
#define TEST_DATA_SIZE 100000 |
#define TEST_DATA_SIZE 145243 |
|
|
|
// max time (seconds) to run test. |
|
// On a 650 Mhz Linux system with tcpdump running, it takes 8 seconds. |
|
#define TEST_TIMEOUT 20 |
| |
int clientsDone = 0; |
// we often pass this size by reference |
int sizeofSOCKADDR_IN = sizeof(SOCKADDR_IN); | int sizeofSOCKADDR_IN = sizeof(SOCKADDR_IN); |
char *testData; |
|
| |
struct TestParams { |
// global test data; server sends it to client, then client verifies it |
int serverSock; |
char *gTestData; |
int serverType; |
|
int serverPort; |
|
int clientPort[NUM_CLIENTS]; |
|
}; |
|
| |
struct ClientParams { |
struct ThreadInfo { |
struct TestParams *test; |
HANDLE Handle; |
int clientNum; // 1...NUM_CLIENTS |
DWORD ID; |
}; | }; |
| |
struct ServerThread { |
struct BlockingServerConnection { |
HANDLE ServerThread; |
struct ThreadInfo serverThread; |
DWORD ServerThreadID; |
SOCKET connectedSocket; // socket to communicate with client |
SOCKET ConnectedSocket; // socket to communicate with client |
SOCKADDR_IN clientAddr; // client info |
SOCKADDR_IN Client; // client info |
|
}; | }; |
| |
static void test_Startup(void); | static void test_Startup(void); |
void BlockingClient(int *serverPort); |
|
void BlockingServer(int *port); |
|
static void test_ClientServerBlocking_1(void); | static void test_ClientServerBlocking_1(void); |
static void test_Startup(void); |
static void test_Cleanup(void); |
| |
// StartNetworkApp creates socket sock of type type and returns assigned port number in addr. |
static void BlockingClient(int *serverPort); |
void StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr) |
static int BlockingServer_Init(int type, SOCKET *sock, SOCKADDR_IN *addr); |
|
static void BlockingServer(SOCKET *sock); |
|
static struct BlockingServerConnection * BlockingServerConnection_New(SOCKET sock, SOCKADDR_IN clientAddr); |
|
static void BlockingServerConnection_Run(struct BlockingServerConnection *t); |
|
static void BlockingServerConnection_Delete(struct BlockingServerConnection *c); |
|
|
|
static void BlockingClient(int *serverPort) |
{ | { |
|
SOCKET sock; |
|
SOCKADDR_IN server; |
|
HOSTENT *hp; |
|
int connectError; |
|
int totCharsReceived = 0; |
|
int numCharsReceived; |
|
int memSame; |
|
char buf[1001]; |
|
|
|
// create socket |
|
sock = socket(AF_INET, SOCK_STREAM, 0); |
|
ok( sock != INVALID_SOCKET , "Error in socket()\n"); |
|
if (sock == INVALID_SOCKET) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
|
|
|
hp = gethostbyname("localhost"); |
|
|
|
server.sin_family = AF_INET; |
|
server.sin_addr = *(struct in_addr *) hp->h_addr; |
|
server.sin_port = *serverPort; |
|
|
|
// connect to server |
|
connectError = connect(sock, (struct sockaddr *)&server, sizeof(struct sockaddr)); |
|
ok( !connectError , "client cannot connect to host\n"); |
|
if(connectError) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
|
|
|
// start receiving data from server |
|
while( totCharsReceived < TEST_DATA_SIZE ) { |
|
numCharsReceived = recv(sock, buf, 1000, 0); |
|
ok( numCharsReceived > 0, "socket was closed unexpectedly\n" ); |
|
|
|
// check received data againt global test data |
|
memSame = ! memcmp(buf,gTestData+totCharsReceived,numCharsReceived); |
|
ok( memSame, "data integrity lost during transfer\n" ); |
|
totCharsReceived += numCharsReceived; |
|
} |
|
} |
|
|
|
static int BlockingServer_Init(int type, SOCKET *sock, SOCKADDR_IN *addr) |
|
{ |
|
// BlockingServer_Init creates socket sock of type type and returns assigned port number in addr. |
|
// returns server port number |
|
|
SOCKADDR_IN tmpAddr; | SOCKADDR_IN tmpAddr; |
int tmpAddrSize; |
int bindOK; |
|
int listenReturn; |
| |
|
// create socket |
*sock = socket(AF_INET, type, 0); | *sock = socket(AF_INET, type, 0); |
|
ok( *sock != INVALID_SOCKET , "Error in socket()\n"); |
if (*sock == INVALID_SOCKET) { | if (*sock == INVALID_SOCKET) { |
ok( 0 , "Error in socket()"); |
|
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
} | } |
trace("socket() ok\n"); |
|
| |
addr->sin_family = AF_INET; | addr->sin_family = AF_INET; |
addr->sin_addr.s_addr = INADDR_ANY; | addr->sin_addr.s_addr = INADDR_ANY; |
addr->sin_port = htons(0); | addr->sin_port = htons(0); |
| |
if( bind(*sock, (const SOCKADDR *) addr, sizeof(*addr)) ) { |
// bind socket to port |
ok( 0 , "Error binding client to socket"); |
bindOK = !bind(*sock, (const SOCKADDR *) addr, sizeofSOCKADDR_IN); |
|
ok( bindOK , "Error binding client to socket\n"); |
|
if( !bindOK ) { |
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
} | } |
| |
// get port number | // get port number |
tmpAddrSize = sizeof(tmpAddr); |
getsockname(*sock, (SOCKADDR *) &tmpAddr, &sizeofSOCKADDR_IN); |
getsockname(*sock, (SOCKADDR *) &tmpAddr, &tmpAddrSize); |
|
addr->sin_port = tmpAddr.sin_port; | addr->sin_port = tmpAddr.sin_port; |
|
|
|
// listen on port |
|
listenReturn = listen(*sock, NUM_CLIENTS); |
|
ok(listenReturn != SOCKET_ERROR, "error listening on socket\n"); |
|
|
|
return addr->sin_port; |
} | } |
| |
void BlockingClient(int *serverPort) |
static void BlockingServer(SOCKET *sock) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
{ | { |
SOCKET sock; |
struct BlockingServerConnection *connections[NUM_CLIENTS]; |
SOCKADDR_IN client, server; |
int connIndex = 0; |
HOSTENT *hp; |
SOCKET tmpSock; |
char* msg="Some message to send to server"; |
SOCKADDR_IN tmpSockAddr; |
| |
StartNetworkApp(SOCK_STREAM, &sock, &client); |
// we require one connection from each client thread |
|
for (connIndex = 0; connIndex < NUM_CLIENTS; connIndex++) { |
|
// accept connection |
|
tmpSock = accept(*sock, (SOCKADDR *) &tmpSockAddr, &sizeofSOCKADDR_IN); |
|
ok(tmpSock != INVALID_SOCKET, "error accepting socket\n"); |
| |
hp = gethostbyname("localhost"); |
// handle new connection |
|
connections[connIndex] = BlockingServerConnection_New(tmpSock, tmpSockAddr); |
|
} |
| |
while(*serverPort == 0) ; |
// clean up connections |
|
for(connIndex = 0; connIndex < NUM_CLIENTS; connIndex++) { |
|
BlockingServerConnection_Delete(connections[connIndex]); |
|
} |
|
} |
| |
// network code here |
static struct BlockingServerConnection * BlockingServerConnection_New(SOCKET sock, SOCKADDR_IN clientAddr) |
server.sin_family = AF_INET; |
{ |
server.sin_addr = *(struct in_addr *) hp->h_addr; |
struct BlockingServerConnection *connection; |
server.sin_port = *serverPort; |
connection = malloc(sizeof(struct BlockingServerConnection)); |
|
memset(connection, 0, sizeof(struct BlockingServerConnection)); |
| |
if(connect(sock, (struct sockaddr *)&server, sizeof(struct sockaddr)) < 0){ |
connection->connectedSocket = sock; |
ok( 0 , "Error connecting client to socket\n"); |
connection->clientAddr = clientAddr; |
WSACleanup(); |
|
exit(0); |
|
} |
|
| |
if((send(sock, msg, strlen(msg), 0))==-1){ |
// spawn thread to handle sending data |
ok( 0 , "Error sending message\n"); |
connection->serverThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServerConnection_Run, connection, 0, &connection->serverThread.ID); |
WSACleanup(); |
|
exit(0); |
|
} |
|
| |
trace("blocking client done\n"); |
return connection; |
clientsDone++; |
|
} | } |
| |
void ProcessConnection(struct ServerThread t) |
static void BlockingServerConnection_Run(struct BlockingServerConnection *connection) |
{ | { |
// this will handle all connections to the server, it's in its own function to allow for multithreading | // this will handle all connections to the server, it's in its own function to allow for multithreading |
int bClosed; | int bClosed; |
bClosed = close(t.ConnectedSocket); |
int totCharsSent = 0; |
//ok(bClosed,"Error closing socket"); |
int numCharsSent; |
} |
const int charsPerSend = 2000; |
| |
void BlockingServer(int *port) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
// loop and send data |
{ |
while( totCharsSent < TEST_DATA_SIZE ) { |
struct ServerThread *Threads; |
numCharsSent = send(connection->connectedSocket, gTestData+totCharsSent, (totCharsSent + charsPerSend <= TEST_DATA_SIZE) ? charsPerSend : TEST_DATA_SIZE - totCharsSent, 0); |
int ThreadIndex = 0; |
ok( numCharsSent != SOCKET_ERROR, "socket error\n" ); |
| |
SOCKET sock; |
// pass if send buffer is full |
SOCKADDR_IN server; |
if(numCharsSent == 0) { |
int ListenReturn; |
Sleep(100); |
|
} |
StartNetworkApp(SOCK_STREAM, &sock, &server); |
|
*port = server.sin_port; |
|
|
|
Threads = malloc(sizeof(struct ServerThread) * NUM_CLIENTS); |
|
memset(Threads, 0, sizeof(struct ServerThread) * NUM_CLIENTS); |
|
|
|
ListenReturn = listen(sock, 5); |
|
ok(ListenReturn != SOCKET_ERROR, "error listening on socket"); |
|
| |
for (ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) |
totCharsSent += numCharsSent; |
{ |
} |
Threads[ThreadIndex].ConnectedSocket = accept(sock, (SOCKADDR *) &Threads[ThreadIndex].Client, &sizeofSOCKADDR_IN); // this can be modified to include the address of the remote socket |
|
ok(Threads[ThreadIndex].ConnectedSocket != INVALID_SOCKET, "error accepting socket"); |
|
| |
Threads[ThreadIndex].ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &ProcessConnection, &(Threads[ThreadIndex].ConnectedSocket), 0, &Threads[ThreadIndex].ServerThreadID); |
bClosed = !closesocket(connection->connectedSocket); |
|
ok(bClosed,"Error closing socket\n"); |
} | } |
| |
// network code here |
static void BlockingServerConnection_Delete(struct BlockingServerConnection *c) |
|
{ |
|
// wait for client to receive data before cleaning up |
|
WaitForSingleObject(c->serverThread.Handle, INFINITE); |
| |
free(Threads); |
free(c); |
trace("blocking server done\n"); |
|
} | } |
| |
static void test_ClientServerBlocking_1(void) | static void test_ClientServerBlocking_1(void) |
{ | { |
int ThreadIndex = 0; |
struct ThreadInfo serverThread; |
int serverPort = 0; // I think the server port would work better as a #DEFINE rather than a variable that gets passed around everywhere |
struct ThreadInfo *clientThreads; |
HANDLE ServerThread; |
DWORD waitStatus; |
DWORD ServerThreadId; |
SOCKET sock; |
DWORD *ClientThreadIds; |
SOCKADDR_IN server; |
HANDLE *ClientThreads; |
int serverPort; |
|
int threadIndex = 0; |
| |
ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, &serverPort, 0, &ServerThreadId); |
// create socket, bind server and start listening |
|
serverPort = BlockingServer_Init(SOCK_STREAM, &sock, &server); |
| |
ClientThreads = malloc(sizeof(HANDLE) * NUM_CLIENTS); |
// start server thread |
memset(ClientThreads, 0, sizeof(HANDLE) * NUM_CLIENTS); |
trace("starting server thread\n"); |
|
serverThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, &sock, 0, &serverThread.ID); |
| |
ClientThreadIds = malloc(sizeof(DWORD) * NUM_CLIENTS); |
// start client threads |
memset(ClientThreadIds, 0, sizeof(DWORD) * NUM_CLIENTS); |
clientThreads = malloc(sizeof(struct ThreadInfo) * NUM_CLIENTS); |
|
memset(clientThreads, 0, sizeof(struct ThreadInfo) * NUM_CLIENTS); |
| |
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
for(threadIndex = 0; threadIndex < NUM_CLIENTS; threadIndex++) { |
ClientThreads[ThreadIndex] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, &serverPort, 0, &ClientThreadIds[ThreadIndex]); |
clientThreads[threadIndex].Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, (void *) &serverPort, 0, &clientThreads[threadIndex].ID); |
} | } |
|
trace("%d clients started\n", NUM_CLIENTS); |
|
|
|
// server thread needs to end before cleaning up |
|
waitStatus = WaitForSingleObject(serverThread.Handle, TEST_TIMEOUT * 1000); |
|
ok( waitStatus != WAIT_TIMEOUT, "test did not complete in time\n" ); |
| |
trace("test_ClientServerBlocking_1 done\n"); |
// wait for all clients to receive data before cleaning up |
|
for(threadIndex = 0; threadIndex < NUM_CLIENTS; threadIndex++) { |
|
WaitForSingleObject(clientThreads[threadIndex].Handle, INFINITE); |
|
} |
|
|
|
free(clientThreads); |
} | } |
| |
static void test_Startup(void) | static void test_Startup(void) |
|
|
int wsastartup_result; | int wsastartup_result; |
int versionOK; | int versionOK; |
| |
|
// check for compatible winsock version |
wsastartup_result = WSAStartup(MAKEWORD(1,1), &wsaData); | wsastartup_result = WSAStartup(MAKEWORD(1,1), &wsaData); |
versionOK = (LOBYTE(wsaData.wVersion) == 1) && (HIBYTE(wsaData.wVersion) == 1); | versionOK = (LOBYTE(wsaData.wVersion) == 1) && (HIBYTE(wsaData.wVersion) == 1); |
| |
ok( versionOK , "WSAStartup returns an incompatible sockets version"); |
ok( versionOK , "WSAStartup returns an incompatible sockets version\n"); |
if ( !versionOK ) { | if ( !versionOK ) { |
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
} | } |
| |
ok((wsastartup_result == NO_ERROR), "Error in WSAStartup()"); |
ok((wsastartup_result == NO_ERROR), "Error in WSAStartup()\n"); |
|
trace("startup ok\n"); |
|
} |
|
|
|
static void test_Cleanup(void) |
|
{ |
|
int cleanupOK; |
|
|
|
cleanupOK = ! WSACleanup(); |
|
|
|
ok( cleanupOK , "error in WSACleanup()\n"); |
|
trace("cleanup ok\n"); |
} | } |
| |
START_TEST(wsock32_main) | START_TEST(wsock32_main) |
{ | { |
testData = malloc(TEST_DATA_SIZE); |
const int numTests = 3; |
trace("test 1 of 2:\n"); |
gTestData = malloc(TEST_DATA_SIZE); |
|
|
|
trace("test 1 of %d:\n", numTests); |
test_Startup(); | test_Startup(); |
trace("test 2 of 2:\n"); |
|
|
trace("test 2 of %d:\n", numTests); |
test_ClientServerBlocking_1(); | test_ClientServerBlocking_1(); |
trace("all tests done\n"); |
|
while (clientsDone != NUM_CLIENTS) |
trace("test 3 of %d:\n", numTests); |
; |
test_Cleanup(); |
|
|
|
trace("all " __FILE__ " tests done\n"); |
|
|
|
free(gTestData); |
} | } |