version 1.28, 2005/02/24 22:20:13
|
version 1.30, 2005/02/25 06:39:52
|
|
|
* Unit tests for 32-bit WinSock 1.1 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 <wtypes.h> | #include <wtypes.h> |
#include <winerror.h> | #include <winerror.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 |
| |
// clients threads to create | // clients threads to create |
|
|
// 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 |
| |
// max time (seconds) to run test |
// max time (seconds) to run test. |
#define TEST_TIMEOUT 10 |
// On a 650 Mhz Linux system with tcpdump running, it takes 8 seconds. |
|
#define TEST_TIMEOUT 20 |
| |
// 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); |
|
|
DWORD ID; | DWORD ID; |
}; | }; |
| |
struct ServerInfo { |
struct BlockingServerConnection { |
HANDLE threadHandle; |
struct ThreadInfo serverThread; |
DWORD threadID; |
|
SOCKET connectedSocket; // socket to communicate with client | SOCKET connectedSocket; // socket to communicate with client |
SOCKADDR_IN clientAddr; // client info | SOCKADDR_IN clientAddr; // client info |
}; | }; |
|
|
static void BlockingClient(int *serverPort); | static void BlockingClient(int *serverPort); |
static int BlockingServer_Init(int type, SOCKET *sock, SOCKADDR_IN *addr); | static int BlockingServer_Init(int type, SOCKET *sock, SOCKADDR_IN *addr); |
static void BlockingServer(SOCKET *sock); | static void BlockingServer(SOCKET *sock); |
static void BlockingServer_ProcessConnection(struct ServerInfo *t); |
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) | static void BlockingClient(int *serverPort) |
{ | { |
|
|
} | } |
} | } |
| |
// BlockingServer_Init creates socket sock of type type and returns assigned port number in addr. |
|
// returns server port number |
|
static int BlockingServer_Init(int type, SOCKET *sock, SOCKADDR_IN *addr) | 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 bindOK; | int bindOK; |
int listenReturn; | int listenReturn; |
|
|
| |
static void BlockingServer(SOCKET *sock) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once | static void BlockingServer(SOCKET *sock) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
{ | { |
struct ServerInfo *threads; |
struct BlockingServerConnection *connections[NUM_CLIENTS]; |
int threadIndex = 0; |
int connIndex = 0; |
|
SOCKET tmpSock; |
// allocate enough space to keep track of NUM_CLIENTS connections |
SOCKADDR_IN tmpSockAddr; |
threads = malloc(sizeof(struct ServerInfo) * NUM_CLIENTS); |
|
memset(threads, 0, sizeof(struct ServerInfo) * NUM_CLIENTS); |
|
| |
// 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].clientAddr, &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].threadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer_ProcessConnection, &threads[threadIndex], 0, &threads[threadIndex].threadID); |
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].threadHandle, 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 BlockingServer_ProcessConnection(struct ServerInfo *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; |
|
|
| |
// 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(connection->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" ); |
| |
// pass if send buffer is full | // pass if send buffer is full |
|
|
totCharsSent += numCharsSent; | totCharsSent += numCharsSent; |
} | } |
| |
bClosed = !closesocket(t->connectedSocket); |
bClosed = !closesocket(connection->connectedSocket); |
ok(bClosed,"Error closing socket\n"); | 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 ThreadInfo serverThread; | struct ThreadInfo serverThread; |
|
struct ThreadInfo *clientThreads; |
DWORD waitStatus; | DWORD waitStatus; |
SOCKET sock; | SOCKET sock; |
SOCKADDR_IN server; | SOCKADDR_IN server; |
int serverPort; | int serverPort; |
int threadIndex = 0; | int threadIndex = 0; |
struct ThreadInfo *clientThreads; |
|
| |
// create socket, bind server and start listening | // create socket, bind server and start listening |
serverPort = BlockingServer_Init(SOCK_STREAM, &sock, &server); | serverPort = BlockingServer_Init(SOCK_STREAM, &sock, &server); |
|
|
trace("test 3 of %d:\n", numTests); | trace("test 3 of %d:\n", numTests); |
test_Cleanup(); | test_Cleanup(); |
| |
trace("all tests done\n"); |
trace("all " __FILE__ " tests done\n"); |
| |
free(gTestData); | free(gTestData); |
} | } |