|
version 1.24, 2005/02/24 02:52:29
|
version 1.25, 2005/02/24 03:16:30
|
|
|
|
| #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 ServerInfo { |
| HANDLE ServerThread; |
HANDLE threadHandle; |
| DWORD ServerThreadID; |
DWORD threadID; |
| SOCKET ConnectedSocket; // socket to communicate with client |
SOCKET connectedSocket; // socket to communicate with client |
| SOCKADDR_IN Client; // client info |
SOCKADDR_IN clientAddr; // 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 StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr); |
| |
static void BlockingServer_ProcessConnection(struct ServerInfo *t); |
| static void StartBlockingClients(int *serverPort); | static void StartBlockingClients(int *serverPort); |
| static void BlockingClient(int *serverPort); | static void BlockingClient(int *serverPort); |
| static void BlockingServer(); | 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) |
static void StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr) |
| { | { |
| SOCKADDR_IN tmpAddr; | SOCKADDR_IN tmpAddr; |
| int tmpAddrSize; | int tmpAddrSize; |
|
|
|
| addr->sin_port = tmpAddr.sin_port; | addr->sin_port = tmpAddr.sin_port; |
| } | } |
| | |
| void BlockingClient(int *serverPort) |
static void BlockingClient(int *serverPort) |
| { | { |
| SOCKET sock; | SOCKET sock; |
| SOCKADDR_IN client, server; | SOCKADDR_IN client, server; |
|
|
|
| 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); | StartNetworkApp(SOCK_STREAM, &sock, &client); |
| | |
| //trace("client port %d\n",ntohs(client.sin_port)); |
|
| |
|
| hp = gethostbyname("localhost"); | hp = gethostbyname("localhost"); |
| | |
| server.sin_family = AF_INET; | server.sin_family = AF_INET; |
|
|
|
| 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"); |
|
| } | } |
| | |
| void BlockingServer_ProcessConnection(struct ServerThread *t) |
static void BlockingServer_ProcessConnection(struct ServerInfo *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; |
| int totCharsSent = 0; | int totCharsSent = 0; |
| int numCharsSent; | int numCharsSent; |
| int yieldCounter = 0; |
|
| const int charsPerSend = 2000; | const int charsPerSend = 2000; |
| | |
| // loop and send data | // loop and send data |
| while( totCharsSent < TEST_DATA_SIZE ) { | while( totCharsSent < TEST_DATA_SIZE ) { |
| numCharsSent = send(t->ConnectedSocket, gTestData+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\n" ); | ok( numCharsSent != SOCKET_ERROR, "socket error\n" ); |
| if(numCharsSent == SOCKET_ERROR) { |
|
| printf("error code: %d",WSAGetLastError()); |
|
| } |
|
| totCharsSent += numCharsSent; |
|
| | |
| // yield to our other threads |
// pass if send buffer is full |
| if(yieldCounter % 20 == 0) { |
if(numCharsSent == 0) { |
| //Sleep(100); |
Sleep(100); |
| } | } |
| yieldCounter++; |
|
| |
totCharsSent += numCharsSent; |
| } | } |
| | |
| bClosed = !closesocket(t->ConnectedSocket); |
bClosed = !closesocket(t->connectedSocket); |
| ok(bClosed,"Error closing socket\n"); | ok(bClosed,"Error closing socket\n"); |
| } | } |
| | |
| void BlockingServer() // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
static void BlockingServer() // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
| { | { |
| struct ServerThread *Threads; |
struct ServerInfo *threads; |
| int ThreadIndex = 0; |
int threadIndex = 0; |
| int serverPort = 0; | int serverPort = 0; |
| | |
| SOCKET sock; | SOCKET sock; |
| SOCKADDR_IN server; | SOCKADDR_IN server; |
| int ListenReturn; |
int listenReturn; |
| | |
| StartNetworkApp(SOCK_STREAM, &sock, &server); | StartNetworkApp(SOCK_STREAM, &sock, &server); |
| | |
| // allocate enough space to keep track of NUM_CLIENTS connections | // allocate enough space to keep track of NUM_CLIENTS connections |
| Threads = malloc(sizeof(struct ServerThread) * NUM_CLIENTS); |
threads = malloc(sizeof(struct ServerInfo) * NUM_CLIENTS); |
| memset(Threads, 0, sizeof(struct ServerThread) * NUM_CLIENTS); |
memset(threads, 0, sizeof(struct ServerInfo) * NUM_CLIENTS); |
| | |
| // 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 | // set the port parameter; clients now know we're ready to accept connections |
| serverPort = server.sin_port; | serverPort = server.sin_port; |
|
|
|
| CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &StartBlockingClients, &serverPort, 0, NULL); | 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].clientAddr, &sizeofSOCKADDR_IN); // this can be modified to include the address of the remote socket |
| ok(Threads[ThreadIndex].ConnectedSocket != INVALID_SOCKET, "error accepting socket\n"); |
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) &BlockingServer_ProcessConnection, &Threads[ThreadIndex], 0, &Threads[ThreadIndex].ServerThreadID); |
threads[threadIndex].threadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer_ProcessConnection, &threads[threadIndex], 0, &threads[threadIndex].threadID); |
| } | } |
| | |
| // wait for all clients to receive data before cleaning up | // wait for all clients to receive data before cleaning up |
| for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
for(threadIndex = 0; threadIndex < NUM_CLIENTS; threadIndex++) { |
| WaitForSingleObject(Threads[ThreadIndex].ServerThread, INFINITE); |
WaitForSingleObject(threads[threadIndex].threadHandle, INFINITE); |
| } | } |
| | |
| free(Threads); |
free(threads); |
| } | } |
| | |
| static void StartBlockingClients(int *serverPort) | static void StartBlockingClients(int *serverPort) |
| { | { |
| int ThreadIndex = 0; |
int threadIndex = 0; |
| struct MyThread *ClientThreads; |
struct ThreadInfo *clientThreads; |
| | |
| ClientThreads = malloc(sizeof(struct MyThread) * NUM_CLIENTS); |
clientThreads = malloc(sizeof(struct ThreadInfo) * NUM_CLIENTS); |
| memset(ClientThreads, 0, sizeof(struct MyThread) * 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].Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, (void *) serverPort, 0, &ClientThreads[ThreadIndex].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 |
| for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
for(threadIndex = 0; threadIndex < NUM_CLIENTS; threadIndex++) { |
| WaitForSingleObject(ClientThreads[ThreadIndex].Handle, INFINITE); |
WaitForSingleObject(clientThreads[threadIndex].Handle, INFINITE); |
| } | } |
| | |
| free(ClientThreads); |
free(clientThreads); |
| } | } |
| | |
| static void test_ClientServerBlocking_1(void) | static void test_ClientServerBlocking_1(void) |
| { | { |
| struct MyThread ServerThread; |
struct ThreadInfo serverThread; |
| DWORD waitStatus; | DWORD waitStatus; |
| | |
| // start server thread | // start server thread |
| // server starts client threads after it binds to a port. | // server starts client threads after it binds to a port. |
| trace("starting main server thread\n"); | trace("starting main server thread\n"); |
| ServerThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, NULL, 0, &ServerThread.ID); |
serverThread.Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, NULL, 0, &serverThread.ID); |
| | |
| // 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"); |
|
| } | } |
| | |
| static void test_Startup(void) | static void test_Startup(void) |