version 1.24, 2005/02/24 02:52:29
|
version 1.29, 2005/02/24 23:33:35
|
|
|
/* | /* |
* 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 |
* | * |
|
|
#include <winsock.h> | #include <winsock.h> |
#include <wtypes.h> | #include <wtypes.h> |
#include <winerror.h> | #include <winerror.h> |
#include <string.h> |
|
| |
#ifndef STANDALONE | #ifndef STANDALONE |
#include "wine/test.h" | #include "wine/test.h" |
|
|
// global test data; server sends it to client, then client verifies it | // global test data; server sends it to client, then client verifies it |
char *gTestData; | char *gTestData; |
| |
struct MyThread { |
struct ThreadInfo { |
HANDLE Handle; | HANDLE Handle; |
DWORD ID; | 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); |
static void test_ClientServerBlocking_1(void); | static void test_ClientServerBlocking_1(void); |
static void test_Cleanup(void); | static void test_Cleanup(void); |
| |
static void StartBlockingClients(int *serverPort); |
|
static void BlockingClient(int *serverPort); | static void BlockingClient(int *serverPort); |
static void BlockingServer(); |
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) |
// StartNetworkApp creates socket sock of type type and returns assigned port number in addr. |
|
void StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr) |
|
{ |
|
SOCKADDR_IN tmpAddr; |
|
int tmpAddrSize; |
|
int bindOK; |
|
|
|
// create socket |
|
*sock = socket(AF_INET, type, 0); |
|
ok( *sock != INVALID_SOCKET , "Error in socket()\n"); |
|
if (*sock == INVALID_SOCKET) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
|
|
|
addr->sin_family = AF_INET; |
|
addr->sin_addr.s_addr = INADDR_ANY; |
|
addr->sin_port = htons(0); |
|
|
|
// bind socket to port |
|
bindOK = !bind(*sock, (const SOCKADDR *) addr, sizeof(*addr)); |
|
ok( bindOK , "Error binding client to socket\n"); |
|
if( !bindOK ) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
|
|
|
// get port number |
|
tmpAddrSize = sizeof(tmpAddr); |
|
getsockname(*sock, (SOCKADDR *) &tmpAddr, &tmpAddrSize); |
|
addr->sin_port = tmpAddr.sin_port; |
|
} |
|
|
|
void BlockingClient(int *serverPort) |
|
{ | { |
SOCKET sock; | SOCKET sock; |
SOCKADDR_IN client, server; |
SOCKADDR_IN server; |
HOSTENT *hp; | HOSTENT *hp; |
int connectError; | int connectError; |
int totCharsReceived = 0; | int totCharsReceived = 0; |
int numCharsReceived; | int numCharsReceived; |
int memSame; | int memSame; |
int yieldCounter = 0; |
|
char buf[1001]; | char buf[1001]; |
| |
StartNetworkApp(SOCK_STREAM, &sock, &client); |
// create socket |
|
sock = socket(AF_INET, SOCK_STREAM, 0); |
//trace("client port %d\n",ntohs(client.sin_port)); |
ok( sock != INVALID_SOCKET , "Error in socket()\n"); |
|
if (sock == INVALID_SOCKET) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
| |
hp = gethostbyname("localhost"); | hp = gethostbyname("localhost"); |
| |
|
|
memSame = ! memcmp(buf,gTestData+totCharsReceived,numCharsReceived); | memSame = ! memcmp(buf,gTestData+totCharsReceived,numCharsReceived); |
ok( memSame, "data integrity lost during transfer\n" ); | ok( memSame, "data integrity lost during transfer\n" ); |
totCharsReceived += numCharsReceived; | totCharsReceived += numCharsReceived; |
|
|
// yield to our other threads |
|
if(yieldCounter % 20 == 0) { |
|
//Sleep(100); |
|
} | } |
yieldCounter++; |
|
} | } |
| |
//trace("client done\n"); |
static int BlockingServer_Init(int type, SOCKET *sock, SOCKADDR_IN *addr) |
} |
|
|
|
void BlockingServer_ProcessConnection(struct ServerThread *t) |
|
{ | { |
// this will handle all connections to the server, it's in its own function to allow for multithreading |
// BlockingServer_Init creates socket sock of type type and returns assigned port number in addr. |
int bClosed; |
// returns server port number |
int totCharsSent = 0; |
|
int numCharsSent; |
|
int yieldCounter = 0; |
|
const int charsPerSend = 2000; |
|
| |
// loop and send data |
SOCKADDR_IN tmpAddr; |
while( totCharsSent < TEST_DATA_SIZE ) { |
int bindOK; |
numCharsSent = send(t->ConnectedSocket, gTestData+totCharsSent, (totCharsSent + charsPerSend <= TEST_DATA_SIZE) ? charsPerSend : TEST_DATA_SIZE - totCharsSent, 0); |
int listenReturn; |
ok( numCharsSent != SOCKET_ERROR, "socket error\n" ); |
|
if(numCharsSent == SOCKET_ERROR) { |
|
printf("error code: %d",WSAGetLastError()); |
|
} |
|
totCharsSent += numCharsSent; |
|
|
|
// yield to our other threads |
|
if(yieldCounter % 20 == 0) { |
|
//Sleep(100); |
|
} |
|
yieldCounter++; |
|
} |
|
| |
bClosed = !closesocket(t->ConnectedSocket); |
// create socket |
ok(bClosed,"Error closing socket\n"); |
*sock = socket(AF_INET, type, 0); |
|
ok( *sock != INVALID_SOCKET , "Error in socket()\n"); |
|
if (*sock == INVALID_SOCKET) { |
|
WSACleanup(); |
|
exit(0); |
} | } |
| |
void BlockingServer() // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
addr->sin_family = AF_INET; |
{ |
addr->sin_addr.s_addr = INADDR_ANY; |
struct ServerThread *Threads; |
addr->sin_port = htons(0); |
int ThreadIndex = 0; |
|
int serverPort = 0; |
|
|
|
SOCKET sock; |
|
SOCKADDR_IN server; |
|
int ListenReturn; |
|
| |
StartNetworkApp(SOCK_STREAM, &sock, &server); |
// bind socket to port |
|
bindOK = !bind(*sock, (const SOCKADDR *) addr, sizeofSOCKADDR_IN); |
|
ok( bindOK , "Error binding client to socket\n"); |
|
if( !bindOK ) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
| |
// allocate enough space to keep track of NUM_CLIENTS connections |
// get port number |
Threads = malloc(sizeof(struct ServerThread) * NUM_CLIENTS); |
getsockname(*sock, (SOCKADDR *) &tmpAddr, &sizeofSOCKADDR_IN); |
memset(Threads, 0, sizeof(struct ServerThread) * NUM_CLIENTS); |
addr->sin_port = tmpAddr.sin_port; |
| |
// listen on port | // listen on port |
ListenReturn = listen(sock, NUM_CLIENTS); |
listenReturn = listen(*sock, NUM_CLIENTS); |
ok(ListenReturn != SOCKET_ERROR, "error listening on socket\n"); |
ok(listenReturn != SOCKET_ERROR, "error listening on socket\n"); |
| |
// set the port parameter; clients now know we're ready to accept connections |
return addr->sin_port; |
serverPort = server.sin_port; |
} |
| |
// bound to port; now we can start clients |
static void BlockingServer(SOCKET *sock) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &StartBlockingClients, &serverPort, 0, NULL); |
{ |
|
struct BlockingServerConnection *connections[NUM_CLIENTS]; |
|
int connIndex = 0; |
|
SOCKET tmpSock; |
|
SOCKADDR_IN tmpSockAddr; |
| |
// we require one connection from each client thread | // we require one connection from each client thread |
for (ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
for (connIndex = 0; connIndex < NUM_CLIENTS; connIndex++) { |
// accept connection | // accept connection |
Threads[ThreadIndex].ConnectedSocket = accept(sock, (SOCKADDR *) &Threads[ThreadIndex].Client, &sizeofSOCKADDR_IN); // this can be modified to include the address of the remote socket |
tmpSock = accept(*sock, (SOCKADDR *) &tmpSockAddr, &sizeofSOCKADDR_IN); |
ok(Threads[ThreadIndex].ConnectedSocket != INVALID_SOCKET, "error accepting socket\n"); |
ok(tmpSock != INVALID_SOCKET, "error accepting socket\n"); |
| |
// spawn thread to handle sending data |
// handle new connection |
Threads[ThreadIndex].ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer_ProcessConnection, &Threads[ThreadIndex], 0, &Threads[ThreadIndex].ServerThreadID); |
connections[connIndex] = BlockingServerConnection_New(tmpSock, tmpSockAddr); |
} | } |
| |
// wait for all clients to receive data before cleaning up |
// clean up connections |
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
for(connIndex = 0; connIndex < NUM_CLIENTS; connIndex++) { |
WaitForSingleObject(Threads[ThreadIndex].ServerThread, INFINITE); |
BlockingServerConnection_Delete(connections[connIndex]); |
|
} |
} | } |
| |
free(Threads); |
static struct BlockingServerConnection * BlockingServerConnection_New(SOCKET sock, SOCKADDR_IN clientAddr) |
|
{ |
|
struct BlockingServerConnection *connection; |
|
connection = malloc(sizeof(struct BlockingServerConnection)); |
|
memset(connection, 0, sizeof(struct BlockingServerConnection)); |
|
|
|
connection->connectedSocket = sock; |
|
connection->clientAddr = clientAddr; |
|
|
|
// spawn thread to handle sending data |
|
connection->serverThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServerConnection_Run, connection, 0, &connection->serverThread.ID); |
|
|
|
return connection; |
} | } |
| |
static void StartBlockingClients(int *serverPort) |
static void BlockingServerConnection_Run(struct BlockingServerConnection *connection) |
{ | { |
int ThreadIndex = 0; |
// this will handle all connections to the server, it's in its own function to allow for multithreading |
struct MyThread *ClientThreads; |
int bClosed; |
|
int totCharsSent = 0; |
|
int numCharsSent; |
|
const int charsPerSend = 2000; |
| |
ClientThreads = malloc(sizeof(struct MyThread) * NUM_CLIENTS); |
// loop and send data |
memset(ClientThreads, 0, sizeof(struct MyThread) * NUM_CLIENTS); |
while( totCharsSent < TEST_DATA_SIZE ) { |
|
numCharsSent = send(connection->connectedSocket, gTestData+totCharsSent, (totCharsSent + charsPerSend <= TEST_DATA_SIZE) ? charsPerSend : TEST_DATA_SIZE - totCharsSent, 0); |
|
ok( numCharsSent != SOCKET_ERROR, "socket error\n" ); |
| |
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
// pass if send buffer is full |
ClientThreads[ThreadIndex].Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, (void *) serverPort, 0, &ClientThreads[ThreadIndex].ID); |
if(numCharsSent == 0) { |
|
Sleep(100); |
} | } |
trace("%d clients started\n", NUM_CLIENTS); |
|
| |
// wait for all clients to receive data before cleaning up |
totCharsSent += numCharsSent; |
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
|
WaitForSingleObject(ClientThreads[ThreadIndex].Handle, INFINITE); |
|
} | } |
| |
free(ClientThreads); |
bClosed = !closesocket(connection->connectedSocket); |
|
ok(bClosed,"Error closing socket\n"); |
|
} |
|
|
|
static void BlockingServerConnection_Delete(struct BlockingServerConnection *c) |
|
{ |
|
// wait for client to receive data before cleaning up |
|
WaitForSingleObject(c->serverThread.Handle, INFINITE); |
|
|
|
free(c); |
} | } |
| |
static void test_ClientServerBlocking_1(void) | static void test_ClientServerBlocking_1(void) |
{ | { |
struct MyThread ServerThread; |
struct ThreadInfo serverThread; |
|
struct ThreadInfo *clientThreads; |
DWORD waitStatus; | DWORD waitStatus; |
|
SOCKET sock; |
|
SOCKADDR_IN server; |
|
int serverPort; |
|
int threadIndex = 0; |
|
|
|
// create socket, bind server and start listening |
|
serverPort = BlockingServer_Init(SOCK_STREAM, &sock, &server); |
| |
// start server thread | // start server thread |
// server starts client threads after it binds to a port. |
trace("starting server thread\n"); |
trace("starting main server thread\n"); |
serverThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, &sock, 0, &serverThread.ID); |
ServerThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, NULL, 0, &ServerThread.ID); |
|
|
// start client threads |
|
clientThreads = malloc(sizeof(struct ThreadInfo) * NUM_CLIENTS); |
|
memset(clientThreads, 0, sizeof(struct ThreadInfo) * NUM_CLIENTS); |
|
|
|
for(threadIndex = 0; threadIndex < NUM_CLIENTS; 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 | // server thread needs to end before cleaning up |
waitStatus = WaitForSingleObject(ServerThread.Handle, TEST_TIMEOUT * 1000); |
waitStatus = WaitForSingleObject(serverThread.Handle, TEST_TIMEOUT * 1000); |
ok( waitStatus != WAIT_TIMEOUT, "test did not complete in time\n" ); | 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) |