Multithreaded PROXY source code

[Ladisla...@swh.sk]

Im trying to create multithreaded proxy server
I limited in on Winsock 1.1 due to fact so many 95 users don't have
winsock 2
One listen thread creates client thread on accept()
C -----> P
and serverthread on successfull connection to server
P -----> S
both are started
that proxy works but it have one problem
And there is my question "Why Clients are dropping connections when
transferring something bigger (like pictures) in recv() in clientthread
?"
I tried everithing,but it still leads to 10053 WSAECONNABORT or 10057

Please help if you know answer.

im including source code

////////////////////////////////////////////////////////////////////////
//////////////////////

#include<windows.h>
#include "winsock.h"

HANDLE proxy_thread;
int ThreadID;
static SOCKET proxy_socket;
char* sServer_name = "proxy" ;
char* sServer_port = "80" ;
char* sPort = "63336";

typedef struct RELLAY
{
SOCKET client_socket;
SOCKET server_socket;
SOCKET client_thread;
SOCKET server_thread;
}*PRELLAY;

unsigned __stdcall ClientThread(void *pVoid)
{
int status;
BYTE Buffer[1024];
PRELLAY pRellay = (PRELLAY)pVoid;
struct RELLAY rellay ;
rellay.client_socket=pRellay->client_socket;
rellay.server_socket=pRellay->server_socket;

while(1)
{
memset(Buffer, 0, sizeof(Buffer));
status = recv(rellay.client_socket, Buffer, sizeof(Buffer), 0);
if(status == INVALID_SOCKET) break;
if(status == 0) break;
status = send(rellay.server_socket, Buffer, status, 0);
if(status == INVALID_SOCKET) break;
}
printf("Client [%d] leaved\n",rellay.client_socket);
return 0;
}

unsigned __stdcall ServerThread(void *pVoid)
{
int status;
BYTE Buffer[1024];
PRELLAY pRellay = (PRELLAY)pVoid;
struct RELLAY rellay ;
rellay.client_socket=pRellay->client_socket;
rellay.server_socket=pRellay->server_socket;

while(1)
{
memset(Buffer, 0, sizeof(Buffer));
status = recv(rellay.server_socket, Buffer, sizeof(Buffer), 0);
if(status == INVALID_SOCKET) break;
if(status == 0) break;
status = send(rellay.client_socket, Buffer, status, 0);
if(status == INVALID_SOCKET) break;
}
printf("Server [%d] leaved\n",rellay.server_socket);
closesocket(rellay.client_socket);
closesocket(rellay.server_socket);
return 0;
}

unsigned __stdcall ProxyThread()
{
int status;
struct RELLAY rellay;
LPHOSTENT ServerEntry;
SOCKADDR_IN Client;
SOCKADDR_IN Server;
int server_port;

ServerEntry = gethostbyname(sServer_name);
Server.sin_family = AF_INET;
Server.sin_addr = *((LPIN_ADDR)*ServerEntry->h_addr_list);
server_port = atoi(sServer_port);
Server.sin_port = htons(server_port);

while(1)
{
rellay.client_socket = accept(proxy_socket,
(LPSOCKADDR)&Client, NULL);
if (rellay.client_socket == INVALID_SOCKET) break;
rellay.server_socket = socket(AF_INET, SOCK_STREAM,
IPPROTO_TCP);
if (rellay.server_socket == INVALID_SOCKET) break;
status = connect(rellay.server_socket,
(LPSOCKADDR)&Server, sizeof(struct sockaddr));
if (status == SOCKET_ERROR) continue;
rellay.client_thread = CreateThread( NULL, 0,
ClientThread, &rellay, 0, &ThreadID);
rellay.server_thread = CreateThread( NULL, 0,
ServerThread, &rellay, 0, &ThreadID);
CloseHandle((HANDLE)rellay.client_thread);
CloseHandle((HANDLE)rellay.server_thread);
}
return 0;
}

BOOL StartProxy(int port)
{
WORD wVersionRequested = MAKEWORD(1,1);
WSADATA wsaData;
SOCKADDR_IN Proxy;
int status;

Proxy.sin_family = AF_INET;
Proxy.sin_addr.s_addr = INADDR_ANY;
Proxy.sin_port = htons(port);

status = WSAStartup(wVersionRequested, &wsaData);
if (wsaData.wVersion != wVersionRequested) return;
proxy_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (proxy_socket == INVALID_SOCKET) return FALSE;
status = bind(proxy_socket, (LPSOCKADDR)&Proxy, sizeof(struct
sockaddr));
if (status == SOCKET_ERROR)
{
closesocket(proxy_socket);
return FALSE;
}

status = listen(proxy_socket, 6000);
if (status == SOCKET_ERROR)
{
closesocket(proxy_socket);
return FALSE;
}

proxy_thread = CreateThread( NULL, 0, ProxyThread, NULL, 0,
&ThreadID);
if (!proxy_thread)
{
closesocket(proxy_socket);
return FALSE;
}

return TRUE;
}

void StopProxy()
{
int status;
status = closesocket(proxy_socket);
status = WaitForSingleObject((HANDLE)proxy_thread, 10000);
CloseHandle((HANDLE)proxy_thread);
}

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmdLine,
int nCmdShow)
{
WNDCLASS wndclass;
HWND hwndMain;
BOOL status;
int port;
HANDLE g_module=GetModuleHandle(NULL);
wndclass.style = 0;
wndclass.lpfnWndProc = DefWindowProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = g_module;
wndclass.hIcon = NULL;
wndclass.hCursor = NULL;
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = "WSCLAS";
RegisterClass(&wndclass);
// I don't wana GUI
port = atoi(sPort);
while(1)
{
status = StartProxy(port);
Sleep(INFINITE);
StopProxy();
}

return 0;
}

////////////////////////////////////////////////////////////////////////
///////////////////
i tryed one rellay thread console solution but this recv didn't return
0 on receive completion
and hangs there forever !!#@#!
[WHY ?]

////////////////////////////////////////////////////////////////////////
//////////////////////
#include<windows.h>
#include "winsock.h"

HANDLE proxy_thread;
int ThreadID;
static SOCKET proxy_socket;
char* sServer_name = "localhost";
char* sServer_port = "80" ;
char* sPort = "63336";
int num_clients = 0;
int max_clients = 0;

typedef struct RELLAY
{
SOCKET client_socket;
SOCKET server_socket;
}*PRELLAY;

unsigned __stdcall ClientThread(void *pVoid)
{
int status;
BYTE Buffer[10];
PRELLAY pRellay = (PRELLAY)pVoid;
SOCKADDR_IN Server;
LPHOSTENT ServerEntry;
SOCKET client_socket;
SOCKET server_socket;

int buf_size = sizeof(Buffer);
ServerEntry = gethostbyname(sServer_name);
Server.sin_family = AF_INET;
Server.sin_addr = *((LPIN_ADDR)*ServerEntry->h_addr_list);
Server.sin_port = htons(atoi(sServer_port));

client_socket = pRellay->client_socket;
server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if (server_socket == INVALID_SOCKET) return 0;
status = connect(server_socket, (LPSOCKADDR)&Server, sizeof
(struct sockaddr));
if (status == SOCKET_ERROR) return 0;

while(1)
{
memset(Buffer, 0, buf_size);
status = recv(client_socket, Buffer, buf_size,
0);
if(status == SOCKET_ERROR) break;
if(status == 0){printf("[X]"); break;}
printf("%d bytes received from Client",status);
status = send(server_socket, Buffer, status, 0);
if(status == SOCKET_ERROR) {printf(" Send
Error\n");break;}
printf(" was successfully send to
Server\n",status);
status=0;
}

printf("Request send to Server\n");
while(1)
{
memset(Buffer, 0, sizeof(Buffer));
if(status = recv(server_socket, Buffer, sizeof
(Buffer), 0)==0)break;
if(status == SOCKET_ERROR) break;

printf("%d bytes received from Server",status);
status = send(client_socket, Buffer, status, 0);
if(status == SOCKET_ERROR) {printf(" Send
Error\n");break;}
printf(" was successfully send to
Client\n",status);
}
printf("Reply send to Client\n");

status = WSAGetLastError();
if(status!=0) printf("C%d=%d\n",client_socket,status);
closesocket(client_socket);
closesocket(server_socket);
return 0;
}

unsigned __stdcall ProxyThread(void * pVoid)
{
struct RELLAY rellay;
HANDLE client_thread;
SOCKADDR_IN Client;

while(1)
{
rellay.client_socket = accept(proxy_socket,
(LPSOCKADDR)&Client, NULL);
if (rellay.client_socket == INVALID_SOCKET)
break;
client_thread = CreateThread( NULL,
0, ClientThread, &rellay, 0, &ThreadID);
CloseHandle((HANDLE)client_thread);
}
return 0;
}

BOOL StartProxy(int port)
{
int status;
WSADATA wsaData;
SOCKADDR_IN Proxy;
WORD wVersionRequested = MAKEWORD(1,1);

Proxy.sin_family = AF_INET;
Proxy.sin_addr.s_addr = INADDR_ANY;
Proxy.sin_port = htons(port);

status = WSAStartup(wVersionRequested, &wsaData);
if (wsaData.wVersion != wVersionRequested) return FALSE;
proxy_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (proxy_socket == INVALID_SOCKET) return FALSE;
status = bind(proxy_socket, (LPSOCKADDR)&Proxy, sizeof(struct
sockaddr));
if (status == SOCKET_ERROR)
{
closesocket(proxy_socket);
return FALSE;
}

status = listen(proxy_socket, SOMAXCONN);
if (status == SOCKET_ERROR)
{
closesocket(proxy_socket);
return FALSE;
}

proxy_thread = CreateThread( NULL, 0, ProxyThread, NULL, 0,
&ThreadID);
if (!proxy_thread)
{
closesocket(proxy_socket);
return FALSE;
}

return TRUE;
}

void StopProxy()
{
int status;
status = closesocket(proxy_socket);
status = WaitForSingleObject((HANDLE)proxy_thread, 10000);
CloseHandle((HANDLE)proxy_thread);
}

int main(char*argv[] , int argc)
{
BOOL status;
int port;
port = atoi(sPort);
status = StartProxy(port);
Sleep(INFINITE);
StopProxy();
WSACleanup();
return 0;
}

Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.