proxyserver1.cpp

这是一个代理服务器实例

// ProxyServer1.cpp: implementation of the CProxyServer class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ProxyServer.h"
#include "ProxyServer1.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CProxyServer::CProxyServer()
{

}

CProxyServer::~CProxyServer()
{

}


UINT CProxyServer::ListenThread(LPVOID lpVoid)
{
    int iRet, addrLen;
	sockaddr_in addr, addrAccept;
	SOCKET sckListen, sckAccept;
	char pszMsg[512];
	int nErrCount;
   
	CProxyServer* pServer = (CProxyServer*)lpVoid;
    pServer->OUTPUT(pServer,"going to create socket.\r\n");

	sckListen = socket(AF_INET, SOCK_STREAM, 0);
	if(sckListen == INVALID_SOCKET)
	{
		sprintf(pszMsg, "INVALID_SOCKET, WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		return 0;
	}
	pServer->OUTPUT(pServer,"Listening socket created successfully.\r\n");

	iRet = gethostname(pszMsg, 256);
	if(iRet)
	{
		sprintf(pszMsg, "Error occur when gethostname(), WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		return 0;
	}

	hostent* pEnt = gethostbyname(pszMsg);
	if(!pEnt)
	{
		sprintf(pszMsg, "Error occur when gethostbyname(), WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		return 0;
	}
    
	memcpy(&(addr.sin_addr), pEnt->h_addr, pEnt->h_length);
	addr.sin_family = AF_INET;
	addr.sin_port = htons(pServer->m_Info.nPort);
	
	pServer->m_Info.strLocalAddr.Format("%s", inet_ntoa(addr.sin_addr));

	iRet = bind(sckListen, (const sockaddr*)&addr, sizeof(addr));
	if(iRet==SOCKET_ERROR)
	{
		sprintf(pszMsg, "SOCKET_ERROR, WSAGetLastError()=%d", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		return 0;
	}

	nErrCount = 0;
	pServer->OUTPUT(pServer,"Listening...\r\n");
	iRet = listen(sckListen, SOMAXCONN);
	if(iRet==SOCKET_ERROR)
	{
		sprintf(pszMsg, "INVALID_SOCKET, WSAGetLastError()=%d", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		nErrCount++;
		if(nErrCount>=10)
		{
			sprintf(pszMsg, "nErrCount>=10, listening thread terminated.\r\n");
			return 0;
		}
	}
	nErrCount = 0;

	while(1)
	{
		addrLen = sizeof(addrAccept);
		sckAccept = accept(sckListen, (struct sockaddr*)&addrAccept, &addrLen);
		if(sckAccept==INVALID_SOCKET)
		{
			sprintf(pszMsg, "accept()=SOCKET_ERROR, WSAGetLastError()=%d", WSAGetLastError());
			pServer->OUTPUT(pServer,pszMsg);
			return 0;
		}
		pServer->OUTPUT(pServer,"One client accepted successfully.\r\n");

		pServer->pWorkParam = new WORKPARAM;
		pServer->pWorkParam->sckClient = sckAccept;
		pServer->pWorkParam->addr = addrAccept;

		AfxBeginThread(WorkingThread, (LPVOID)pServer, THREAD_PRIORITY_BELOW_NORMAL);
	}

	return 0;
}

void CProxyServer::OUTPUT(CProxyServer* pServer,LPCTSTR pszMsg)
{
   SendMessage(pServer->m_Info.hWnd, AGM_OUTPUT, 0, (LPARAM)pszMsg);

}

UINT CProxyServer::WorkingThread(LPVOID lpVoid)
{
    int iRet, i;
	char content[512];
	char buf[BUFFER_SIZE];
	char pszMsg[1024];
	char pszCode[256];
	char pszLine[512];
	char *pEnd;
	CProxyServer* pServer = (CProxyServer*)lpVoid;
    WORKPARAM * pThreadParam = pServer->pWorkParam;
	DWORD dwRet, dwTotal, dwSize;
	sockaddr_in addrProxy2nd;
	SOCKET sckClient;
	REQUESTHEADER requestHeader;
	HTTPHEADER httpHeader;
	FILE* pFileContent;

	dwRet = WaitForSingleObject(pServer->m_hConnectionCount, INFINITE);
	if(pServer->m_nConnectionCount >= 80)
	{
		ReleaseSemaphore(pServer->m_hConnectionCount, 1, NULL);
		pServer->OUTPUT(pServer,"Too many connections, limit reached\r\n");
		strcpy(buf, "HTTP/1.1 431 Too many connections, limit reached\r\n"); send(pThreadParam->sckClient , buf, strlen(buf), 0);
		strcpy(buf, "Proxy-agent: My-PersonalProxy/1.0\r\n");
		send(pThreadParam->sckClient, buf, strlen(buf), 0);
		strcpy(buf, "Content-type: text/html\r\n"); 
		send(pThreadParam->sckClient, buf, strlen(buf), 0);

		pFileContent = fopen("c:\\ProxyServer\\authorizationrequired.html", "rb");
		dwSize = _filelength(_fileno(pFileContent));
		sprintf(buf, "Content-length: %d\r\n", dwSize); 
		send(pThreadParam->sckClient, buf, strlen(buf), 0);
		strcpy(buf, "\r\n"); 
		send(pThreadParam->sckClient, buf, strlen(buf), 0);

		while(!feof(pFileContent))
		{
			dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
			send(pThreadParam->sckClient, buf, dwSize, 0);
		}
		closesocket(pThreadParam->sckClient);
		fclose(pFileContent);
		delete pThreadParam;
		return 0;
	}
	pServer->m_nConnectionCount++;
	ReleaseSemaphore(pServer->m_hConnectionCount, 1, NULL);

	while(1)
	{
		iRet = pServer->RecvRequest(pServer,pThreadParam->sckClient, buf, BUFFER_SIZE-1, &requestHeader);
		
		
	 	if(iRet==SOCKET_ERROR)
		{
			sprintf(pszMsg, "RecvRequest()=SOCKET_ERROR, WSAGetLastError()=%d", WSAGetLastError());
			pServer->OUTPUT(pServer,pszMsg);
			WaitForSingleObject(pServer->m_hConnectionCount, INFINITE);
			pServer->m_nConnectionCount--;
			ReleaseSemaphore(pServer->m_hConnectionCount, 1, NULL);
			delete pThreadParam;
			return 0;
		}
		dwTotal = iRet;

		for(i=0; i<pServer->m_nRefused; i++)
		{
			if(pServer->m_ulIpRefused[i]==pThreadParam->addr.sin_addr.S_un.S_addr)
			{
				pServer->OUTPUT(pServer,"refused ip:");
				sprintf(content, "\t%d.%d.%d.%d\r\n",
					pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
					pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
					pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
					pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
				pServer->OUTPUT(pServer,content);
				strcpy(buf, "HTTP/1.1 432 Ip refused\r\n"); 
				send(pThreadParam->sckClient , buf, strlen(buf), 0);
				strcpy(buf, "Proxy-agent: Ag-PersonalProxy/1.0\r\n");
				send(pThreadParam->sckClient, buf, strlen(buf), 0);
				strcpy(buf, "Content-type: text/html\r\n"); 
				send(pThreadParam->sckClient, buf, strlen(buf), 0);
				pFileContent = fopen("c:\\ProxyServer\\notification.html", "rb");
				dwSize = _filelength(_fileno(pFileContent));
				sprintf(buf, "Content-length: %d\r\n", dwSize); 
				send(pThreadParam->sckClient, buf, strlen(buf), 0);
				strcpy(buf, "\r\n");
				send(pThreadParam->sckClient, buf, strlen(buf), 0);

					dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
					buf[dwSize] = NULL;
					sprintf(content, buf,
						pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
						pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
						pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
						pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
					send(pThreadParam->sckClient, content, strlen(content), 0);
				closesocket(pThreadParam->sckClient);
				fclose(pFileContent);
				goto _ThreadExit;
			}
		}
		if(requestHeader.dwFlag & REQUEST_UNAUTHORIZED)
		{
			pServer->OUTPUT(pServer,"HTTP/1.1 407 Proxy authorization required agproxy.");
			sprintf(content, "\t%s\t%d.%d.%d.%d\r\n",
				requestHeader.pszUserPass,
				pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
				pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
				pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
				pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
			pServer->OUTPUT(pServer,content);
			//HTTP/1.0 407 Proxy authorization required
			strcpy(buf, "HTTP/1.1 407 Proxy authorization required\r\n"); send(pThreadParam->sckClient , buf, strlen(buf), 0);
			strcpy(buf, "Proxy-agent: Ag-PersonalProxy/1.0\r\n"); 
			send(pThreadParam->sckClient, buf, strlen(buf), 0);
			strcpy(buf, "Content-type: image/jpeg\r\n");
			send(pThreadParam->sckClient, buf, strlen(buf), 0);
			strcpy(buf, "Proxy-authenticate: basic realm=\"JutAg\"\r\n"); 
			send(pThreadParam->sckClient, buf, strlen(buf), 0);
			pFileContent = fopen("c:\\ProxyServer\\Authorization.jpg", "rb");
			dwSize = _filelength(_fileno(pFileContent));
			sprintf(buf, "Content-length: %d\r\n", dwSize); 
			send(pThreadParam->sckClient, buf, strlen(buf), 0);
			strcpy(buf, "\r\n");
			send(pThreadParam->sckClient, buf, strlen(buf), 0);
			
			while(!feof(pFileContent))
			{
				dwSize = fread(buf, 1, BUFFER_SIZE, pFileContent);
				send(pThreadParam->sckClient, buf, dwSize, 0);
			}
				fclose(pFileContent);
			continue;
		}
		break;
	}

	if(strstr(buf, "POST"))
	{
		pServer->OUTPUT(pServer,buf);
		pServer->OUTPUT(pServer,"\r\n");
	}
	else
	{
		strncpy(content, buf, strstr(buf, "\r\n")-buf+2);
		content[strstr(buf, "\r\n")-buf] = NULL;
		pServer->OUTPUT(pServer,content);
	}
	sprintf(content, "\t%d.%d.%d.%d\r\n",
		pThreadParam->addr.sin_addr.S_un.S_un_b.s_b1,
		pThreadParam->addr.sin_addr.S_un.S_un_b.s_b2,
		pThreadParam->addr.sin_addr.S_un.S_un_b.s_b3,
		pThreadParam->addr.sin_addr.S_un.S_un_b.s_b4);
	pServer->OUTPUT(pServer,content);

	if(requestHeader.dwFlag & VIRTUAL_RESOURCE)
	{
		pServer->HttpService(pServer,requestHeader.pszUrl, pThreadParam->sckClient, buf, &requestHeader);
		goto _ThreadExit;
	}

	pServer->OUTPUT(pServer,"Connecting to the second proxy.\r\n");
	addrProxy2nd.sin_family = AF_INET;
	addrProxy2nd.sin_port = htons(pServer->m_Info.nPort2nd);
	addrProxy2nd.sin_addr.s_addr = inet_addr(pServer->m_Info.strProxyAddr);
 
	sckClient = socket(AF_INET, SOCK_STREAM, 0);
	if(sckClient==INVALID_SOCKET)
	{
		closesocket(pThreadParam->sckClient);
		closesocket(sckClient);
		sprintf(pszMsg, "socket()=INVALID_SOCKET, WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		goto _ThreadExit1;
	}
	iRet = connect(sckClient, (const sockaddr*)&addrProxy2nd, sizeof(addrProxy2nd));
	if(iRet==SOCKET_ERROR)
	{
		closesocket(pThreadParam->sckClient);
		closesocket(sckClient);
		sprintf(pszMsg, "connect()=SOCKET_ERROR, WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
		pServer->OUTPUT(pServer,pszMsg);
		goto _ThreadExit1;
	}
	
	// send the data before	Proxy-Authorization:
	send(sckClient, buf, requestHeader.pszAuthBegin-buf, 0);
	strncpy(pszMsg, buf, requestHeader.pszAuthBegin-buf);
	pszMsg[requestHeader.pszAuthBegin-buf] = NULL;
//	TRACE(pszMsg);
	// send Authorization information to the second proxy
	sprintf(pszMsg, "%s:%s", pServer->m_Info.strUser, pServer->m_Info.strPasswd);
	pServer->Base64(pServer,pszMsg, pszCode);
	sprintf(content, "Proxy-Authorization: Basic %s==\r\n", pszCode);
	send(sckClient, content, strlen(content), 0);
//	TRACE(content);
//	send(sckClient, requestHeader.pszAuthBegin, requestHeader.pszAuthEnd-requestHeader.pszAuthBegin, 0);
	strncpy(pszMsg, requestHeader.pszAuthBegin, requestHeader.pszAuthEnd-requestHeader.pszAuthBegin);
	pszMsg[requestHeader.pszAuthBegin, requestHeader.pszAuthEnd-requestHeader.pszAuthBegin] = NULL;
//	TRACE(pszMsg);
	// send the rest information
	send(sckClient, requestHeader.pszAuthEnd, strlen(requestHeader.pszAuthEnd), 0);
	iRet = 1;
	while(dwTotal<requestHeader.dwContSize && iRet)
	{
		iRet = recv(pThreadParam->sckClient, buf, BUFFER_SIZE, 0);
		buf[iRet] = NULL;
		if(iRet==SOCKET_ERROR)
		{
			sprintf(pszMsg, "while(nTotal<requestHeader.dwContSize && iRet) recv()=SOCKET_ERROR, WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
			pServer->OUTPUT(pServer,pszMsg);
			goto _ThreadExit;
		}
		if(iRet)
		{
			pServer->OUTPUT(pServer,"_DEBUG_PRE_\t");
			pServer->OUTPUT(pServer,buf);
			send(sckClient, buf, iRet, 0);
			dwTotal += iRet;
		}
	}
//	TRACE(requestHeader.pszAuthEnd);

	// waiting for response from server
	iRet = pServer->RecvHeader(pServer,sckClient, buf, BUFFER_SIZE, &httpHeader);
	send(pThreadParam->sckClient, buf, iRet, 0);

	if(httpHeader.dwContSize==0)
	{
		goto _ThreadExit;
	}

	dwTotal = iRet-(httpHeader.pContBegin - buf);
	while(dwTotal<httpHeader.dwContSize && iRet)
	{
		iRet = recv(sckClient, buf, BUFFER_SIZE, 0);
		if(iRet==SOCKET_ERROR)
		{
			sprintf(pszMsg, "recv()=SOCKET_ERROR, WSAGetLastError()=%d\r\nListening Thread terminated.\r\n", WSAGetLastError());
			pServer->OUTPUT(pServer,pszMsg);
			goto _ThreadExit;
		}
		dwTotal += iRet;
		send(pThreadParam->sckClient, buf, iRet, 0);
	}

_ThreadExit:
	pServer->OUTPUT(pServer,"Working thread terminated.\r\n");
	closesocket(sckClient);
	closesocket(pThreadParam->sckClient);

_ThreadExit1:
	WaitForSingleObject(pServer->m_hConnectionCount, INFINITE);
	pServer->m_nConnectionCount--;
	ReleaseSemaphore(pServer->m_hConnectionCount, 1, NULL);