version 1.7, 2005/02/21 21:27:59
|
version 1.11, 2005/02/22 04:33:16
|
|
|
#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" |
|
|
clientsDone++; | clientsDone++; |
} | } |
| |
void BlockingServer(int *port) |
void ProcessConnection(SOCKET *ConnectedSocket) |
{ | { |
|
// this will handle all connections to the server, it's in its own function to allow for multithreading |
|
int bClosed; |
|
bClosed = close(ConnectedSocket); |
|
//ok(bClosed,"Error closing socket"); |
|
} |
|
|
|
void BlockingServer(int *port) // listens for incoming connections and accepts up to NUM_CLIENTS connections at once |
|
{ |
|
HANDLE* ServerThreads; // the handles for the threads that process connections |
|
DWORD* ServerThreadIDs; // the thread ids for the threads that process connections |
|
SOCKET* ConnectedSockets; // the threads created by accept() that get sent to the processing function |
|
int ThreadIndex = 0; |
|
|
SOCKET sock; | SOCKET sock; |
SOCKADDR_IN server; | SOCKADDR_IN server; |
|
Handle* ServerThreads; |
|
DWORD* ServerThreadIDs; |
|
int ThreadIndex = 0; |
|
|
StartNetworkApp(SOCK_STREAM, &sock, &server); | StartNetworkApp(SOCK_STREAM, &sock, &server); |
*port = server.sin_port; | *port = server.sin_port; |
| |
|
ServerThreads = malloc(sizeof(HANDLE) * NUM_CLIENTS); |
|
memset(ServerThreads, 0, sizeof(HANDLE) * NUM_CLIENTS); |
|
|
|
ServerThreadIDs = malloc(sizeof(DWORD) * NUM_CLIENTS); |
|
memset(ServerThreadIDs, 0, sizeof(DWORD) * NUM_CLIENTS); |
|
|
|
ConnectedSockets = malloc(sizeof(DWORD) * NUM_CLIENTS); |
|
memset(ConnectedSockets, 0, sizeof(DWORD) * NUM_CLIENTS); |
|
|
|
//SOCKADDR_IN RemoteAddress; |
|
|
|
ListenReturn = listen(sock, 5); |
|
ok(ListenReturn != SOCKET_ERROR, "error listening on socket"); |
|
|
|
for (ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) |
|
{ |
|
ConnectedSocket = accept(sock); // this can be modified to include the address of the remote socket |
|
ok(ConnectedSocket != INVALID_SOCKET, "error accepting socket"); |
|
|
|
ServerThreads[ThreadIndex] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &ProcessConnection, &ConnectedSockets[ThreadIndex], 0, &ServerThreadIDs[ThreadIndex]); |
|
} |
|
|
// network code here | // network code here |
| |
|
free(ServerThreads); |
|
free(ServerThreadIDs); |
|
free(ConnectedSockets); |
trace("blocking server done\n"); | trace("blocking server done\n"); |
} | } |
| |
static void test_ClientServerBlocking_1(void) | static void test_ClientServerBlocking_1(void) |
{ | { |
int serverPort = 0; |
int ThreadIndex = 0; |
HANDLE Thread1, Thread2; |
int serverPort = 0; // I think the server port would work better as a #DEFINE rather than a variable that gets passed around everywhere |
DWORD ThreadId1, ThreadId2; |
HANDLE ServerThread; |
Thread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, &serverPort, 0, &ThreadId1); |
DWORD ServerThreadId; |
Thread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, &serverPort, 0, &ThreadId2); |
DWORD *ClientThreadIds; |
|
HANDLE *ClientThreads; |
|
|
|
ServerThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingClient, &serverPort, 0, &ServerThreadId); |
|
|
|
ClientThreads = malloc(sizeof(HANDLE) * NUM_CLIENTS); |
|
memset(ClientThreads, 0, sizeof(HANDLE) * NUM_CLIENTS); |
|
|
|
ClientThreadIds = malloc(sizeof(DWORD) * NUM_CLIENTS); |
|
memset(ClientThreadIds, 0, sizeof(DWORD) * NUM_CLIENTS); |
|
|
|
for(ThreadIndex = 0; ThreadIndex < NUM_CLIENTS; ThreadIndex++) { |
|
ClientThreads[ThreadIndex] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) &BlockingServer, &serverPort, 0, &ClientThreadIds[ThreadIndex]); |
|
} |
|
|
trace("test_ClientServerBlocking_1 done\n"); | trace("test_ClientServerBlocking_1 done\n"); |
} | } |
| |