version 1.20, 2005/02/23 06:07:24
|
version 1.24, 2005/02/24 02:52:29
|
|
|
#endif | #endif |
| |
// clients threads to create | // clients threads to create |
#define NUM_CLIENTS 1500 |
#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 145243 | #define TEST_DATA_SIZE 145243 |
| |
// tracks number of clients that have successfull transferred data |
// max time (seconds) to run test |
int clientsDone = 0; |
#define TEST_TIMEOUT 10 |
| |
// we often pass this size by reference | // we often pass this size by reference |
int sizeofSOCKADDR_IN = sizeof(SOCKADDR_IN); | int sizeofSOCKADDR_IN = sizeof(SOCKADDR_IN); |
| |
// 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 *testData; |
char *gTestData; |
|
|
struct TestParams { |
|
int serverSock; |
|
int serverType; |
|
int serverPort; |
|
int clientPort[NUM_CLIENTS]; |
|
}; |
|
|
|
struct ClientParams { |
|
struct TestParams *test; |
|
int clientNum; // 1...NUM_CLIENTS |
|
}; |
|
| |
struct MyThread { | struct MyThread { |
HANDLE Handle; | HANDLE Handle; |
|
|
}; | }; |
| |
static void test_Startup(void); | static void test_Startup(void); |
void BlockingClient(volatile int *serverPort); |
|
void BlockingServer(volatile int *port); |
|
static void test_ClientServerBlocking_1(void); | static void test_ClientServerBlocking_1(void); |
static void test_Startup(void); |
static void test_Cleanup(void); |
|
|
|
static void StartBlockingClients(int *serverPort); |
|
static void BlockingClient(int *serverPort); |
|
static void BlockingServer(); |
|
|
| |
// StartNetworkApp creates socket sock of type type and returns assigned port number in addr. | // StartNetworkApp creates socket sock of type type and returns assigned port number in addr. |
void StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr) | void StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr) |
|
|
| |
// create socket | // create socket |
*sock = socket(AF_INET, type, 0); | *sock = socket(AF_INET, type, 0); |
ok( *sock != INVALID_SOCKET , "Error in socket()"); |
ok( *sock != INVALID_SOCKET , "Error in socket()\n"); |
if (*sock == INVALID_SOCKET) { | if (*sock == INVALID_SOCKET) { |
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
|
|
| |
// bind socket to port | // bind socket to port |
bindOK = !bind(*sock, (const SOCKADDR *) addr, sizeof(*addr)); | bindOK = !bind(*sock, (const SOCKADDR *) addr, sizeof(*addr)); |
ok( bindOK , "Error binding client to socket"); |
ok( bindOK , "Error binding client to socket\n"); |
if( !bindOK ) { | if( !bindOK ) { |
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
|
|
addr->sin_port = tmpAddr.sin_port; | addr->sin_port = tmpAddr.sin_port; |
} | } |
| |
void BlockingClient(volatile int *serverPort) |
void BlockingClient(int *serverPort) |
{ | { |
SOCKET sock; | SOCKET sock; |
SOCKADDR_IN client, server; | SOCKADDR_IN client, server; |
|
|
| |
hp = gethostbyname("localhost"); | hp = gethostbyname("localhost"); |
| |
// yield until server determines its random port number |
|
while(*serverPort == 0) |
|
SwitchToThread(); |
|
|
|
server.sin_family = AF_INET; | server.sin_family = AF_INET; |
server.sin_addr = *(struct in_addr *) hp->h_addr; | server.sin_addr = *(struct in_addr *) hp->h_addr; |
server.sin_port = *serverPort; | server.sin_port = *serverPort; |
|
|
// start receiving data from server | // start receiving data from server |
while( totCharsReceived < TEST_DATA_SIZE ) { | while( totCharsReceived < TEST_DATA_SIZE ) { |
numCharsReceived = recv(sock, buf, 1000, 0); | numCharsReceived = recv(sock, buf, 1000, 0); |
ok( numCharsReceived > 0, "socket was closed unexpectedly" ); |
ok( numCharsReceived > 0, "socket was closed unexpectedly\n" ); |
| |
// check received data againt global test data | // check received data againt global test data |
memSame = ! memcmp(buf,testData+totCharsReceived,numCharsReceived); |
memSame = ! memcmp(buf,gTestData+totCharsReceived,numCharsReceived); |
ok( memSame, "data integrity lost during transfer" ); |
ok( memSame, "data integrity lost during transfer\n" ); |
totCharsReceived += numCharsReceived; | totCharsReceived += numCharsReceived; |
| |
// yield to our other threads | // yield to our other threads |
if(yieldCounter % 20 == 0) { | if(yieldCounter % 20 == 0) { |
//SwitchToThread(); |
//Sleep(100); |
} | } |
yieldCounter++; | yieldCounter++; |
} | } |
| |
trace("client done\n"); |
//trace("client done\n"); |
clientsDone++; |
|
} | } |
| |
void ProcessConnection(struct ServerThread *t) |
void BlockingServer_ProcessConnection(struct ServerThread *t) |
{ | { |
// 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; |
|
|
| |
// loop and send data | // loop and send data |
while( totCharsSent < TEST_DATA_SIZE ) { | while( totCharsSent < TEST_DATA_SIZE ) { |
numCharsSent = send(t->ConnectedSocket, testData+totCharsSent, (totCharsSent + charsPerSend <= TEST_DATA_SIZE) ? charsPerSend : TEST_DATA_SIZE - totCharsSent, 0); |
numCharsSent = send(t->ConnectedSocket, gTestData+totCharsSent, (totCharsSent + charsPerSend <= TEST_DATA_SIZE) ? charsPerSend : TEST_DATA_SIZE - totCharsSent, 0); |
ok( numCharsSent != SOCKET_ERROR, "socket error" ); |
ok( numCharsSent != SOCKET_ERROR, "socket error\n" ); |
if(numCharsSent == SOCKET_ERROR) { | if(numCharsSent == SOCKET_ERROR) { |
printf("error code: %d",WSAGetLastError()); | printf("error code: %d",WSAGetLastError()); |
} | } |
|
|
| |
// yield to our other threads | // yield to our other threads |
if(yieldCounter % 20 == 0) { | if(yieldCounter % 20 == 0) { |
//SwitchToThread(); |
//Sleep(100); |
} | } |
yieldCounter++; | yieldCounter++; |
} | } |
| |
bClosed = !closesocket(t->ConnectedSocket); | bClosed = !closesocket(t->ConnectedSocket); |
ok(bClosed,"Error closing socket"); |
ok(bClosed,"Error closing socket\n"); |
} | } |
| |
void BlockingServer(volatile int *port) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
void BlockingServer() // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
{ | { |
struct ServerThread *Threads; | struct ServerThread *Threads; |
int ThreadIndex = 0; | int ThreadIndex = 0; |
|
int serverPort = 0; |
| |
SOCKET sock; | SOCKET sock; |
SOCKADDR_IN server; | SOCKADDR_IN server; |
|
|
| |
// listen on port | // listen on port |
ListenReturn = listen(sock, NUM_CLIENTS); | ListenReturn = listen(sock, NUM_CLIENTS); |
ok(ListenReturn != SOCKET_ERROR, "error listening on socket"); |
ok(ListenReturn != SOCKET_ERROR, "error listening on socket\n"); |
| |
// set the port parameter; clients now know we're ready to accept connections | // set the port parameter; clients now know we're ready to accept connections |
*port = server.sin_port; |
serverPort = server.sin_port; |
|
|
|
// bound to port; now we can start clients |
|
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &StartBlockingClients, &serverPort, 0, NULL); |
| |
// we require one connection from each client thread | // we require one connection from each client thread |
for (ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { | for (ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
// 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 | 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"); |
ok(Threads[ThreadIndex].ConnectedSocket != INVALID_SOCKET, "error accepting socket\n"); |
| |
// spawn thread to handle sending data | // spawn thread to handle sending data |
Threads[ThreadIndex].ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &ProcessConnection, &Threads[ThreadIndex], 0, &Threads[ThreadIndex].ServerThreadID); |
Threads[ThreadIndex].ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer_ProcessConnection, &Threads[ThreadIndex], 0, &Threads[ThreadIndex].ServerThreadID); |
} | } |
| |
// wait for all clients to receive data before cleaning up | // wait for all clients to receive data before cleaning up |
while (clientsDone != NUM_CLIENTS) |
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
SwitchToThread(); |
WaitForSingleObject(Threads[ThreadIndex].ServerThread, INFINITE); |
|
} |
| |
free(Threads); | free(Threads); |
} | } |
| |
static void test_ClientServerBlocking_1(void) |
static void StartBlockingClients(int *serverPort) |
{ | { |
int ThreadIndex = 0; | int ThreadIndex = 0; |
// tell the compiler not to optimize code relating to serverPort |
|
volatile int serverPort = 0; |
|
struct MyThread ServerThread; |
|
struct MyThread *ClientThreads; | struct MyThread *ClientThreads; |
| |
ClientThreads = malloc(sizeof(struct MyThread) * NUM_CLIENTS); | ClientThreads = malloc(sizeof(struct MyThread) * NUM_CLIENTS); |
memset(ClientThreads, 0, sizeof(struct MyThread) * NUM_CLIENTS); | memset(ClientThreads, 0, sizeof(struct MyThread) * NUM_CLIENTS); |
| |
trace("starting main server thread\n"); |
|
ClientThreads[ThreadIndex].Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, (void *) &serverPort, 0, &ClientThreads[ThreadIndex].ID); |
|
|
|
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { | for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
ServerThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, (void *) &serverPort, 0, &ServerThread.ID); |
ClientThreads[ThreadIndex].Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, (void *) serverPort, 0, &ClientThreads[ThreadIndex].ID); |
} | } |
trace("%d clients started\n", NUM_CLIENTS); | trace("%d clients started\n", NUM_CLIENTS); |
| |
// wait for all clients to receive data before cleaning up | // wait for all clients to receive data before cleaning up |
while (clientsDone != NUM_CLIENTS) |
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
SwitchToThread(); |
WaitForSingleObject(ClientThreads[ThreadIndex].Handle, INFINITE); |
|
} |
| |
free(ClientThreads); | free(ClientThreads); |
|
} |
|
|
|
static void test_ClientServerBlocking_1(void) |
|
{ |
|
struct MyThread ServerThread; |
|
DWORD waitStatus; |
|
|
|
// start server thread |
|
// server starts client threads after it binds to a port. |
|
trace("starting main server thread\n"); |
|
ServerThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, NULL, 0, &ServerThread.ID); |
|
|
|
// 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"); | trace("test_ClientServerBlocking_1 done\n"); |
} | } |
|
|
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"); | 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"); |
|
| |
// wait for all clients to receive data before cleaning up |
trace("test 3 of %d:\n", numTests); |
while (clientsDone != NUM_CLIENTS) |
test_Cleanup(); |
SwitchToThread(); |
|
|
trace("all tests done\n"); |
| |
free(testData); |
free(gTestData); |
} | } |