version 1.4, 2005/02/20 22:33:10
|
version 1.23, 2005/02/24 02:13:45
|
|
|
#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" |
|
|
#define todo_wine | #define todo_wine |
#endif | #endif |
| |
#define NUM_CLIENTS 5 |
// clients threads to create |
|
#define NUM_CLIENTS 64 |
|
|
|
// amount of data to transfer from each client to server |
|
#define TEST_DATA_SIZE 145243 |
|
|
|
// tracks number of clients that have successfull transferred data |
|
volatile int clientsDone = 0; |
|
|
|
// we often pass this size by reference |
|
int sizeofSOCKADDR_IN = sizeof(SOCKADDR_IN); |
|
|
|
// global test data; server sends it to client, then client verifies it |
|
char *testData; |
| |
struct TestParams { | struct TestParams { |
int sock; |
int serverSock; |
int type; |
int serverType; |
int serverPort; | int serverPort; |
int clientPort[NUM_CLIENTS]; | int clientPort[NUM_CLIENTS]; |
}; | }; |
|
|
int clientNum; // 1...NUM_CLIENTS | int clientNum; // 1...NUM_CLIENTS |
}; | }; |
| |
|
struct MyThread { |
|
HANDLE Handle; |
|
DWORD ID; |
|
}; |
|
|
|
struct ServerThread { |
|
HANDLE ServerThread; |
|
DWORD ServerThreadID; |
|
SOCKET ConnectedSocket; // socket to communicate with client |
|
SOCKADDR_IN Client; // client info |
|
}; |
|
|
static void test_Startup(void); | static void test_Startup(void); |
void BlockingClient(); |
|
void BlockingServer(); |
|
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(volatile int *serverPort); |
|
static void BlockingClient(volatile int *serverPort); |
|
static void BlockingServer(volatile int *port); |
| |
void BlockingClient() |
|
|
// StartNetworkApp creates socket sock of type type and returns assigned port number in addr. |
|
void StartNetworkApp(int type, SOCKET *sock, SOCKADDR_IN *addr) |
{ | { |
SOCKET sock; |
SOCKADDR_IN tmpAddr; |
SOCKADDR_IN client; |
int tmpAddrSize; |
|
int bindOK; |
|
|
|
// create socket |
|
*sock = socket(AF_INET, type, 0); |
|
ok( *sock != INVALID_SOCKET , "Error in socket()"); |
|
if (*sock == INVALID_SOCKET) { |
|
WSACleanup(); |
|
exit(0); |
|
} |
| |
sock = socket(AF_INET, SOCK_DGRAM, 0); |
addr->sin_family = AF_INET; |
if (sock == INVALID_SOCKET) { |
addr->sin_addr.s_addr = INADDR_ANY; |
ok( 0 , "Error in socket()"); |
addr->sin_port = htons(0); |
|
|
|
// bind socket to port |
|
bindOK = !bind(*sock, (const SOCKADDR *) addr, sizeof(*addr)); |
|
ok( bindOK , "Error binding client to socket"); |
|
if( !bindOK ) { |
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
} | } |
trace("socket() ok\n"); |
|
| |
client.sin_family = AF_INET; |
// get port number |
client.sin_addr.s_addr = INADDR_ANY; |
tmpAddrSize = sizeof(tmpAddr); |
client.sin_port = htons(0); |
getsockname(*sock, (SOCKADDR *) &tmpAddr, &tmpAddrSize); |
|
addr->sin_port = tmpAddr.sin_port; |
|
} |
| |
bind(sock, (const SOCKADDR *) &client, sizeof(client)); |
void BlockingClient(volatile int *serverPort) |
|
{ |
|
SOCKET sock; |
|
SOCKADDR_IN client, server; |
|
HOSTENT *hp; |
|
int connectError; |
|
int totCharsReceived = 0; |
|
int numCharsReceived; |
|
int memSame; |
|
int yieldCounter = 0; |
|
char buf[1001]; |
|
|
|
StartNetworkApp(SOCK_STREAM, &sock, &client); |
|
|
|
//trace("client port %d\n",ntohs(client.sin_port)); |
|
|
|
hp = gethostbyname("localhost"); |
|
|
|
// yield until server determines its random port number |
|
while(*serverPort == 0) |
|
Sleep(100); |
|
|
|
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" ); |
|
|
|
// check received data againt global test data |
|
memSame = ! memcmp(buf,testData+totCharsReceived,numCharsReceived); |
|
ok( memSame, "data integrity lost during transfer" ); |
|
totCharsReceived += numCharsReceived; |
|
|
|
// yield to our other threads |
|
if(yieldCounter % 20 == 0) { |
|
//Sleep(100); |
|
} |
|
yieldCounter++; |
|
} |
| |
|
//trace("client done\n"); |
|
clientsDone++; |
|
} |
|
|
|
void ProcessConnection(struct ServerThread *t) |
|
{ |
|
// this will handle all connections to the server, it's in its own function to allow for multithreading |
|
int bClosed; |
|
int totCharsSent = 0; |
|
int numCharsSent; |
|
int yieldCounter = 0; |
|
const int charsPerSend = 2000; |
|
|
|
// loop and send data |
|
while( totCharsSent < TEST_DATA_SIZE ) { |
|
numCharsSent = send(t->ConnectedSocket, testData+totCharsSent, (totCharsSent + charsPerSend <= TEST_DATA_SIZE) ? charsPerSend : TEST_DATA_SIZE - totCharsSent, 0); |
|
ok( numCharsSent != SOCKET_ERROR, "socket error" ); |
|
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); |
|
ok(bClosed,"Error closing socket"); |
|
} |
| |
//while(1) |
void BlockingServer(volatile int *port) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
{ | { |
printf("Thread 1\n"); |
struct ServerThread *Threads; |
|
int ThreadIndex = 0; |
|
|
|
SOCKET sock; |
|
SOCKADDR_IN server; |
|
int ListenReturn; |
|
|
|
StartNetworkApp(SOCK_STREAM, &sock, &server); |
|
|
|
// allocate enough space to keep track of NUM_CLIENTS connections |
|
Threads = malloc(sizeof(struct ServerThread) * NUM_CLIENTS); |
|
memset(Threads, 0, sizeof(struct ServerThread) * NUM_CLIENTS); |
|
|
|
// listen on port |
|
ListenReturn = listen(sock, NUM_CLIENTS); |
|
ok(ListenReturn != SOCKET_ERROR, "error listening on socket"); |
|
|
|
// set the port parameter; clients now know we're ready to accept connections |
|
*port = server.sin_port; |
|
|
|
// bound to port; now we can start clients |
|
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &StartBlockingClients, port, 0, NULL); |
|
|
|
// we require one connection from each client thread |
|
for (ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
|
// 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 |
|
ok(Threads[ThreadIndex].ConnectedSocket != INVALID_SOCKET, "error accepting socket"); |
|
|
|
// spawn thread to handle sending data |
|
Threads[ThreadIndex].ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &ProcessConnection, &Threads[ThreadIndex], 0, &Threads[ThreadIndex].ServerThreadID); |
} | } |
|
|
|
// wait for all clients to receive data before cleaning up |
|
while (clientsDone != NUM_CLIENTS) |
|
Sleep(100); |
|
|
|
free(Threads); |
} | } |
| |
void BlockingServer() |
static void StartBlockingClients(volatile int *serverPort) |
{ | { |
trace("blocking server\n"); |
int ThreadIndex = 0; |
|
struct MyThread *ClientThreads; |
|
|
|
ClientThreads = malloc(sizeof(struct MyThread) * NUM_CLIENTS); |
|
memset(ClientThreads, 0, sizeof(struct MyThread) * 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); |
|
|
|
// wait for all clients to receive data before cleaning up |
|
while (clientsDone != NUM_CLIENTS) |
|
Sleep(100); |
|
|
|
free(ClientThreads); |
} | } |
| |
static void test_ClientServerBlocking_1(void) | static void test_ClientServerBlocking_1(void) |
{ | { |
HANDLE Thread1, Thread2; |
// tell the compiler not to optimize code relating to serverPort |
DWORD ThreadId1, ThreadId2; |
volatile int *serverPort; |
Thread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, NULL, 0, &ThreadId1); |
struct MyThread ServerThread; |
Thread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, NULL, 0, &ThreadId2); |
|
//trace("In test_ClientServerBlocking_1\n"); |
serverPort = malloc(sizeof(int)); |
|
*serverPort = 0; |
|
|
|
// 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, (void *) serverPort, 0, &ServerThread.ID); |
|
|
|
// wait for all clients to receive data before cleaning up |
|
while (clientsDone != NUM_CLIENTS) |
|
Sleep(100); |
|
|
|
trace("test_ClientServerBlocking_1 done\n"); |
} | } |
| |
static void test_Startup(void) | static void test_Startup(void) |
{ | { |
// initialize application | // initialize application |
WSADATA wsaData; | WSADATA wsaData; |
int wsastartup_result = WSAStartup(MAKEWORD(1,1), &wsaData); |
int wsastartup_result; |
if ( (LOBYTE(wsaData.wVersion) != 1) && (HIBYTE(wsaData.wVersion) != 1) ) |
int versionOK; |
{ |
|
ok( 0 , "WSAStartup returns an incompatible sockets version"); |
// check for compatible winsock version |
|
wsastartup_result = WSAStartup(MAKEWORD(1,1), &wsaData); |
|
versionOK = (LOBYTE(wsaData.wVersion) == 1) && (HIBYTE(wsaData.wVersion) == 1); |
|
|
|
ok( versionOK , "WSAStartup returns an incompatible sockets version"); |
|
if ( !versionOK ) { |
WSACleanup(); | WSACleanup(); |
exit(0); | exit(0); |
} | } |
| |
ok((wsastartup_result == NO_ERROR), "Error in WSAStartup()"); | ok((wsastartup_result == NO_ERROR), "Error in WSAStartup()"); |
|
trace("startup ok\n"); |
} | } |
| |
| |
|
static void test_Cleanup(void) |
|
{ |
|
int cleanupOK; |
|
|
|
cleanupOK = ! WSACleanup(); |
|
|
|
ok( cleanupOK , "error in WSACleanup()"); |
|
trace("cleanup ok\n"); |
|
} |
|
|
START_TEST(wsock32_main) | START_TEST(wsock32_main) |
{ | { |
trace("test 1 of 2:\n"); |
const int numTests = 3; |
|
testData = 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("test 3 of %d:\n", numTests); |
|
test_Cleanup(); |
|
|
trace("all tests done\n"); | trace("all tests done\n"); |
|
|
|
free(testData); |
} | } |