www.pudn.com > NETINFO.rar > UserFunc.h

/////////////////////////////////////////////////////////////////////////////////////////// 
//---------------------- base user connection class begin --------------------------------- 
class CUserConnection 
{ 
public: 
	CUserConnection(HNETINFO hNi, const TCP_ADDR* connecter, const TCP_ADDR* listener); 
	virtual ~CUserConnection(); 
	virtual void OnTcpData(HNETINFO hNi, HTCPCONNECT hConnect, BOOL bConnecterToListener,  
		const BYTE*pData, DWORD length){}; 
protected: 
	HNETINFO m_hNi; 
	TCP_ADDR m_connecter; 
	TCP_ADDR m_listener; 
}; 
 
CUserConnection::CUserConnection(HNETINFO hNi, const TCP_ADDR* connecter, const TCP_ADDR* listener) 
:m_hNi(hNi), m_connecter(*connecter), m_listener(*listener) 
{ 
} 
 
CUserConnection::~CUserConnection() 
{ 
} 
 
 
/*------------------------debug begin----------------------------------- 
void CUserConnection::OnTcpData(HNETINFO hNi, HTCPCONNECT hConnect,  
			BOOL bConnecterToListener, const BYTE*pData, DWORD length) 
{ 
	char buffer[64000]; 
	if( length < sizeof(buffer) ) 
	{ 
		memcpy(buffer, pData, length); 
		buffer[length] = 0; 
		for(char *p1 = buffer; p1-buffer<(int)length; p1 = p1 + strlen(p1) + 1 ) 
		{ 
			strlwr(p1); 
			if( strstr(p1, "post") ) 
			{ 
				BreakDownConnect(hConnect); 
				printf("%d.%d.%d.%d:%d --> %d.%d.%d.%d:%d breaking......\n",  
					m_connecter.ip.b1, m_connecter.ip.b2, m_connecter.ip.b3, m_connecter.ip.b4, m_connecter.port,  
					m_listener.ip.b1, m_listener.ip.b2, m_listener.ip.b3, m_listener.ip.b4, m_listener.port); 
				break; 
			} 
		} 
	} 
} 
-----------------------debug end--------------------------------------*/ 
 
 
//---------------------- base user connection class end --------------------------------- 
/////////////////////////////////////////////////////////////////////////////////////////// 
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////// 
//---------------------- dump to txt file user connection class begin -------------------- 
class CUserDumpConnection:public CUserConnection 
{ 
public: 
	CUserDumpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
				const TCP_ADDR* listener, const char szDumpDir[]); 
	virtual ~CUserDumpConnection(); 
	virtual void OnTcpData(HNETINFO hNi, HTCPCONNECT hConnect, BOOL bConnecterToListener,  
					const BYTE*pData, DWORD length); 
protected: 
	char m_szFileName[MAX_PATH]; 
	FILE *m_fp; 
}; 
 
CUserDumpConnection::CUserDumpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
										 const TCP_ADDR* listener, const char szDumpDir[]) 
:CUserConnection(hNi, connecter, listener) 
{ 
	char szFileName[MAX_PATH]; 
	GetConnectionTempFileName(connecter, listener, szFileName); 
	sprintf(m_szFileName, "%s%s", szDumpDir, szFileName); 
	m_fp = fopen(m_szFileName, "wb"); 
} 
 
CUserDumpConnection::~CUserDumpConnection() 
{ 
	if( m_fp ) 
		fclose(m_fp); 
	DeleteEmptyFile(m_szFileName); 
} 
 
void CUserDumpConnection::OnTcpData(HNETINFO hNi, HTCPCONNECT hConnect, BOOL bConnecterToListener,  
					const BYTE*pData, DWORD length) 
{ 
	if( m_fp ) 
	{ 
		char title[MAX_PATH]; 
		if( bConnecterToListener ) 
			sprintf(title, "%lu;Sender=Connecter;<<<<<<<<<<------=------>>>>>>>>>>\r\n", length); 
		else 
			sprintf(title, "%lu;Sender=Listener;<<<<<<<<<<------=------>>>>>>>>>>\r\n", length); 
		fwrite(title, 1, strlen(title), m_fp); 
		fwrite(pData, 1, length, m_fp); 
		fwrite("\r\n", 1, 2, m_fp); 
	} 
} 
//---------------------- dump to txt file connection class end --------------------------- 
/////////////////////////////////////////////////////////////////////////////////////////// 
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////// 
//---------------------- ftp user connection class begin --------------------------------- 
class CUserFtpConnection: public CUserConnection 
{ 
public: 
	CUserFtpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
		const TCP_ADDR* listener, const char *szFtpDir); 
	virtual ~CUserFtpConnection(); 
 
	void OnFtpCommand(HNETINFO hNi, HFTPCONNECT hFtpConnect, const char* szCommand); 
	void OnFtpReply(HNETINFO hNi, HFTPCONNECT hFtpConnect,  
						const char* szCommand, const char* szReply); 
	void OnFtpFileTransferBegin(HNETINFO hNi, HFTPCONNECT hFtpConnect, DWORD dwStartPos, 
						BOOL bClientToServer, const char* szFullUnixFilePath);						 
	void OnFtpFileData(HNETINFO hNi, HFTPCONNECT hFtpConnect,  
						const BYTE*pData, DWORD length); 
	void OnFtpFileTransferEnd(HNETINFO hNi, HFTPCONNECT hFtpConnect); 
protected: 
	void CloseFile(); 
 
protected: 
	char m_szFtpDir[MAX_PATH]; 
	char m_szFilePath[MAX_PATH]; 
	FILE *m_fp; 
}; 
 
 
CUserFtpConnection::CUserFtpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
									   const TCP_ADDR* listener, const char *szFtpDir) 
:CUserConnection(hNi, connecter, listener) 
{ 
	strcpy(m_szFtpDir, szFtpDir); 
	strcpy(m_szFilePath, ""); 
	m_fp = NULL; 
} 
 
CUserFtpConnection::~CUserFtpConnection() 
{ 
	CloseFile(); 
} 
 
void CUserFtpConnection::CloseFile() 
{ 
	if( m_fp ) 
	{ 
		fclose(m_fp); 
		m_fp = NULL; 
		DeleteEmptyFile(m_szFilePath); 
		strcpy(m_szFilePath, ""); 
	} 
} 
 
void CUserFtpConnection::OnFtpCommand(HNETINFO hNi, HFTPCONNECT hFtpConnect, const char* szCommand) 
{ 
} 
 
void CUserFtpConnection::OnFtpReply(HNETINFO hNi, HFTPCONNECT hFtpConnect,  
						const char* szCommand, const char* szReply) 
{ 
} 
 
void CUserFtpConnection::OnFtpFileTransferBegin(HNETINFO hNi, HFTPCONNECT hFtpConnect, DWORD dwStartPos, 
						BOOL bClientToServer, const char* szFullUnixFilePath) 
{ 
	CloseFile(); 
	char *mode =  bClientToServer ? "put" : "get"; 
	char szTemp[MAX_PATH]; 
	sprintf(szTemp, "%s%s\\%d.%d.%d.%d__%d.%d.%d.%d%s", m_szFtpDir, mode,  
			m_connecter.ip.b1, m_connecter.ip.b2, m_connecter.ip.b3, m_connecter.ip.b4,  
			m_listener.ip.b1, m_listener.ip.b2, m_listener.ip.b3, m_listener.ip.b4,  
			szFullUnixFilePath); 
	UnixPath2DosPath(szTemp, m_szFilePath); 
	CreateFilePath(m_szFilePath); 
	m_fp = fopen(m_szFilePath, "wb"); 
} 
 
void CUserFtpConnection::OnFtpFileData(HNETINFO hNi, HFTPCONNECT hFtpConnect,  
						const BYTE*pData, DWORD length) 
{ 
	if( m_fp ) 
		fwrite(pData, 1, length, m_fp); 
} 
 
void CUserFtpConnection::OnFtpFileTransferEnd(HNETINFO hNi, HFTPCONNECT hFtpConnect) 
{ 
	CloseFile(); 
} 
//---------------------- ftp user connection class end ----------------------------------- 
/////////////////////////////////////////////////////////////////////////////////////////// 
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////// 
//---------------------- http user connection class begin --------------------------------- 
class CUserHttpConnection: public CUserConnection 
{ 
public: 
	CUserHttpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
		const TCP_ADDR* listener, const char *szHttpDir); 
	virtual ~CUserHttpConnection(); 
 
	void OnHttpClientBegin(HNETINFO hNi, HHTTPCONNECT hHttpConnect); 
	void OnHttpClientHeader(HNETINFO hNi, HHTTPCONNECT hHttpConnect, 
						const HTTP_HEADER_INFO* pClientHeader); 
	void OnHttpClientBody(HNETINFO hNi, HHTTPCONNECT hHttpConnect,  
					const BYTE* pData, DWORD length); 
	void OnHttpClientEnd(HNETINFO hNi, HHTTPCONNECT hHttpConnect); 
 
	void OnHttpServerBegin(HNETINFO hNi, HHTTPCONNECT hHttpConnect); 
	void OnHttpServerHeader(HNETINFO hNi, HHTTPCONNECT hHttpConnect, 
						const HTTP_HEADER_INFO* pClientHeader, const HTTP_HEADER_INFO* pServerHeader); 
	void OnHttpServerBody(HNETINFO hNi, HHTTPCONNECT hHttpConnect,  
					const BYTE* pData, DWORD length); 
	void OnHttpServerEnd(HNETINFO hNi, HHTTPCONNECT hHttpConnect); 
 
private: 
	BOOL GetHttpFilePath(BOOL bClientToServer,  
		const HTTP_HEADER_INFO *pClient, const HTTP_HEADER_INFO *pServer,  
		const TCP_ADDR *listener, const TCP_ADDR *connecter, 
		const char szHttpDir[MAX_PATH], char szFilePath[MAX_PATH]); 
	void OpenHttpFile(HHTTPCONNECT hHttpConnect); 
	void CloseHttpFile(); 
	void PreWriteRequestHttpHeader(const HTTP_HEADER_INFO* pHeader, FILE *fp); 
 
private: 
	BOOL m_bClientToServer; 
	BOOL m_bHasTryToCreateFile; 
	char m_szHttpDir[MAX_PATH]; 
	char m_szFilePath[MAX_PATH]; 
	FILE *m_fp; 
}; 
 
CUserHttpConnection::CUserHttpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
		const TCP_ADDR* listener, const char *szHttpDir) 
:CUserConnection(hNi, connecter, listener) 
{ 
	m_bClientToServer = TRUE; 
	m_bHasTryToCreateFile = FALSE; 
	strcpy(m_szHttpDir, szHttpDir); 
	strcpy(m_szFilePath, ""); 
	m_fp = NULL; 
} 
 
CUserHttpConnection::~CUserHttpConnection() 
{ 
	CloseHttpFile(); 
} 
 
BOOL CUserHttpConnection::GetHttpFilePath(BOOL bClientToServer,  
	const HTTP_HEADER_INFO *pClient, const HTTP_HEADER_INFO *pServer,  
	const TCP_ADDR *listener, const TCP_ADDR *connecter, 
	const char szHttpDir[MAX_PATH], char szFilePath[MAX_PATH]) 
{ 
	BOOL result = FALSE; 
 
	//request message body 
	if( bClientToServer ) 
	{ 
		char host[MAX_HOST_LENGTH]; 
		strcpy(host, ""); 
 
		//get host from m_request.host 
		if( stricmp(host,"")==0 ) 
			strcpy(host, pClient->host); 
 
		//get host from url if url has host infomation 
		if( stricmp(host, "")==0 ) 
			GetHostFromUrl(pClient->url, host); 
 
		//get host from dest ip 
		if( stricmp(host, "")==0 ) 
			sprintf(host, "%d.%d.%d.%d", 	listener->ip.b1, listener->ip.b2, listener->ip.b3, listener->ip.b4); 
 
		//get filename 
		SYSTEMTIME lt; 
		GetLocalTime(<); 
		sprintf(szFilePath, "%s%04d%02d%02d_%02d%02d%02d_%03d_%d__%d_%d_%d_%d__%s.txt", szHttpDir, 
			lt.wYear, lt.wMonth, lt.wDay, lt.wHour, lt.wMinute, lt.wSecond, lt.wMilliseconds, rand(), 
			connecter->ip.b1, connecter->ip.b2, connecter->ip.b3, connecter->ip.b4,  
			host); 
		result = TRUE; 
	} 
	//response message body 
	else  
	{ 
		if( strcmp(pServer->status_Code, "200")!=0 ) 
			return FALSE; 
 
		char host[MAX_HOST_LENGTH], url[MAX_URL_LENGTH]; 
		strcpy(host, pClient->host); 
		strcpy(url, pClient->url); 
 
		//make host non-empty  
		//get host from response.host if it's non-empty 
		if( strcmp(host, "") == 0 ) 
		{ 
			strcpy(host, pClient->host); 
		} 
 
		//get host from request.url if it's abs-url 
		if(  strcmp(host, "") == 0 ) 
		{ 
			GetHostFromUrl(url, host); 
		} 
 
		//make host from ip address  
		if(  strcmp(host, "") == 0 ) 
		{ 
			sprintf(host, "%d.%d.%d.%d",  
				listener->ip.b1, listener->ip.b2, listener->ip.b3, listener->ip.b4); 
		} 
 
		//get source ip address in string 
		char szSrcIpStr[30]; 
		sprintf(szSrcIpStr, "%d.%d.%d.%d",  
				connecter->ip.b1, connecter->ip.b2, connecter->ip.b3, connecter->ip.b4); 
 
		//make url abs-path 
		if( url[0]!='/' && strstr(url, "://") ) 
		{ 
			char *pStart, *pEnd; 
			pStart = strstr(url, "://"); 
			pStart += 3; 
			pEnd = strchr(pStart, '/'); 
			if( pEnd ) 
			{ 
				memmove(url, pEnd, strlen(pEnd)+1); 
			} 
			else 
			{ 
				strcpy(url, "/index.htm"); 
			} 
		} 
 
		//search URL for '?' 
		char *pQuestion = strchr(url, '?'); 
 
		//filename can be got from url 
		if( !pQuestion ) 
		{ 
			//url hasn't filename, we must add a filename to it 
			if( url[strlen(url)-1] == '/' ) 
				strcat(url, "index.htm"); 
 
			//make filename 
			char unixPath[MAX_PATH]; 
			sprintf(unixPath, "%s%s__%s%s", szHttpDir, szSrcIpStr, host, url); 
			UnixPath2DosPath(unixPath, szFilePath); 
			result = TRUE; 
		} 
		//filename can only be got from content-type 
		else 
		{ 
			char *pChar; 
			//look for the last '/' in url( now it's abs-path ) 
			//make url abs-path without filename and '?' 
			for(pChar = pQuestion; pChar>=url && *pChar!='/'; pChar--)NULL; 
			pChar++; 
			*pChar = 0; 
 
			//get extension of filename 
			char unixPath[MAX_PATH], ext[MAX_PATH]; 
			GetExtFromMimeType(pServer->content_MainType, pServer->content_SubType, ext); 
 
			//get filename 
			SYSTEMTIME lst; 
			GetLocalTime(&lst); 
			char pureName[MAX_PATH]; 
			sprintf(pureName, "%4d%02d%02d_%02d%02d%02d_%d",  
						lst.wYear, lst.wMonth, lst.wDay, lst.wHour, lst.wMinute, lst.wSecond, rand() ); 
			sprintf(unixPath, "%s%s__%s%s%s.%s", szHttpDir, szSrcIpStr, host,  
							url, pureName, ext); 
			UnixPath2DosPath(unixPath, szFilePath); 
			result = TRUE; 
		} 
	} 
 
	return result; 
} 
 
void CUserHttpConnection::PreWriteRequestHttpHeader(const HTTP_HEADER_INFO* pHeader, FILE *fp) 
{ 
	fprintf(fp, "%s %s %s\r\n", pHeader->method, pHeader->url, pHeader->http_Version); 
	if( strcmp(pHeader->host, "")!=0 ) 
		fprintf(fp, "Host: %s\r\n", pHeader->host); 
	if( strcmp(pHeader->content_Encoding, "")!=0 ) 
		fprintf(fp, "Content-Encoding: %s\r\n", pHeader->content_Encoding); 
	if( strcmp(pHeader->content_Length, "")!=0 ) 
		fprintf(fp, "Content-Length: %s\r\n", pHeader->content_Length); 
	if( strcmp(pHeader->content_MainType, "")!=0 ) 
		fprintf(fp, "Content-Type: %s/%s\r\n", pHeader->content_MainType, pHeader->content_SubType); 
	if( strcmp(pHeader->content_Range, "")!=0 ) 
		fprintf(fp, "Content_Range: %s\r\n", pHeader->content_Range); 
	if( strcmp(pHeader->referer, "")!=0 ) 
		fprintf(fp, "Referer: %s\r\n", pHeader->referer); 
	if( strcmp(pHeader->transfer_Encoding, "")!=0 ) 
		fprintf(fp, "Transfer_Encoding: %s\r\n", pHeader->transfer_Encoding); 
	if( strcmp(pHeader->connection, "")!=0 ) 
		fprintf(fp, "Connection: %s\r\n", pHeader->connection); 
	fprintf(fp, "\r\n"); 
} 
 
 
void CUserHttpConnection::OpenHttpFile(HHTTPCONNECT hHttpConnect) 
{ 
	const HTTP_HEADER_INFO *pClient, *pServer; 
	GetHttpHeader(hHttpConnect, &pClient, &pServer); 
	if( GetHttpFilePath(m_bClientToServer, pClient, pServer,  
						&m_listener, &m_connecter, m_szHttpDir, m_szFilePath) ) 
	{ 
		CreateFilePath(m_szFilePath); 
		m_fp = fopen(m_szFilePath, "wb"); 
		if( m_fp && m_bClientToServer ) 
			PreWriteRequestHttpHeader(pClient, m_fp); 
	} 
} 
 
void CUserHttpConnection::CloseHttpFile() 
{ 
	if( m_fp ) 
	{ 
		fclose(m_fp); 
		m_fp = NULL; 
		DeleteEmptyFile(m_szFilePath); 
	} 
} 
 
void CUserHttpConnection::OnHttpClientBegin(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CloseHttpFile(); 
	m_bClientToServer = TRUE; 
	m_bHasTryToCreateFile = FALSE; 
} 
 
void CUserHttpConnection::OnHttpClientHeader(HNETINFO hNi, HHTTPCONNECT hHttpConnect, 
						const HTTP_HEADER_INFO* pClientHeader) 
{ 
} 
 
void CUserHttpConnection::OnHttpClientBody(HNETINFO hNi, HHTTPCONNECT hHttpConnect,  
					const BYTE* pData, DWORD length) 
{ 
	if( !m_fp && !m_bHasTryToCreateFile ) 
	{ 
		OpenHttpFile(hHttpConnect); 
		m_bHasTryToCreateFile = TRUE; 
	} 
 
	if( m_fp ) 
		fwrite(pData, 1, length, m_fp); 
} 
 
void CUserHttpConnection::OnHttpClientEnd(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CloseHttpFile(); 
} 
 
void CUserHttpConnection::OnHttpServerBegin(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CloseHttpFile(); 
	m_bClientToServer = FALSE; 
	m_bHasTryToCreateFile = FALSE; 
} 
 
void CUserHttpConnection::OnHttpServerHeader(HNETINFO hNi, HHTTPCONNECT hHttpConnect, 
						const HTTP_HEADER_INFO* pClientHeader, const HTTP_HEADER_INFO* pServerHeader) 
{ 
} 
 
void CUserHttpConnection::OnHttpServerBody(HNETINFO hNi, HHTTPCONNECT hHttpConnect,  
					const BYTE* pData, DWORD length) 
{ 
	if( !m_fp && !m_bHasTryToCreateFile ) 
	{ 
		OpenHttpFile(hHttpConnect); 
		m_bHasTryToCreateFile = TRUE; 
	} 
 
	if( m_fp ) 
		fwrite(pData, 1, length, m_fp); 
} 
 
void CUserHttpConnection::OnHttpServerEnd(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CloseHttpFile(); 
} 
//---------------------- http user connection class end ----------------------------------- 
/////////////////////////////////////////////////////////////////////////////////////////// 
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////// 
//---------------------- smtp user connection class begin --------------------------------- 
class CUserSmtpConnection:public CUserConnection 
{ 
public: 
	CUserSmtpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
						const TCP_ADDR* listener, const char* szSmtpDir); 
	virtual ~CUserSmtpConnection(); 
 
	void OnSmtpCommand(HNETINFO hNi, HSMTPCONNECT hSmtpConnect, const char* szCommand); 
	void OnSmtpReply(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
						const char* szCommand, const char* szReply); 
	void OnSmtpMessageTransferBegin(HNETINFO hNi, HSMTPCONNECT hSmtpConnect); 
	void OnSmtpMessageHeader(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
							const char* from, const char* to, const char* subject); 
	void OnSmtpMessageEntityHeader(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
							const char* mimeMainType, const char* mimeSubType,  
							const char* filename); 
	void OnSmtpMessageEntityBody(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
			const BYTE* pData, DWORD length); 
	void OnSmtpMessageEntityBodyEnd(HNETINFO hNi, HSMTPCONNECT hSmtpConnect); 
	void OnSmtpMessageTransferEnd(HNETINFO hNi, HSMTPCONNECT hSmtpConnect); 
private: 
	void CloseFile(); 
private: 
	char m_szSmtpDir[MAX_PATH]; 
	char m_szMessageDir[MAX_PATH]; 
	char m_szFilePath[MAX_PATH]; 
	FILE *m_fp; 
}; 
 
CUserSmtpConnection::CUserSmtpConnection(HNETINFO hNi, const TCP_ADDR* connecter,  
						const TCP_ADDR* listener, const char* szSmtpDir) 
:CUserConnection(hNi, connecter, listener) 
{ 
	strcpy(m_szSmtpDir, szSmtpDir); 
	strcpy(m_szMessageDir, ""); 
	strcpy(m_szFilePath, ""); 
	m_fp = NULL; 
} 
 
void CUserSmtpConnection::CloseFile() 
{ 
	if( m_fp ) 
	{ 
		fclose(m_fp); 
		m_fp = NULL; 
	} 
	strcpy(m_szFilePath, ""); 
} 
 
CUserSmtpConnection::~CUserSmtpConnection() 
{ 
	CloseFile(); 
} 
 
void CUserSmtpConnection::OnSmtpCommand(HNETINFO hNi, HSMTPCONNECT hSmtpConnect, const char* szCommand) 
{ 
} 
 
void CUserSmtpConnection::OnSmtpReply(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
						const char* szCommand, const char* szReply) 
{ 
} 
 
void CUserSmtpConnection::OnSmtpMessageTransferBegin(HNETINFO hNi, HSMTPCONNECT hSmtpConnect) 
{ 
	SYSTEMTIME lt; 
	GetLocalTime(<); 
	sprintf(m_szMessageDir, "%04d%02d%02d_%02d%02d%02d_%04d_%d__%d_%d_%d_%d_%d__%d_%d_%d_%d_%d",  
		lt.wYear, lt.wMonth, lt.wDay, lt.wHour, lt.wMinute, lt.wSecond, lt.wMilliseconds, rand(), 
		m_connecter.ip.b1, m_connecter.ip.b2, m_connecter.ip.b3, m_connecter.ip.b4, m_connecter.port, 
		m_listener.ip.b1, m_listener.ip.b2, m_listener.ip.b3, m_listener.ip.b4, m_listener.port); 
} 
 
void CUserSmtpConnection::OnSmtpMessageHeader(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
							const char* from, const char* to, const char* subject) 
{ 
	char filename[MAX_PATH]; 
	sprintf(filename, "%s%s\\header%d.txt", m_szSmtpDir, m_szMessageDir, rand() ); 
	CreateFilePath(filename); 
	FILE* fp = fopen(filename, "wt"); 
	if( fp ) 
	{ 
		fprintf(fp, "From: %s\n", from); 
		fprintf(fp, "To: %s\n", to); 
		fprintf(fp, "Subject: %s\n", subject); 
		fclose(fp); 
	} 
} 
 
void CUserSmtpConnection::OnSmtpMessageEntityHeader(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
							const char* mimeMainType, const char* mimeSubType,  
							const char* filename) 
{ 
	CloseFile(); 
	sprintf(m_szFilePath, "%s%s\\%s", m_szSmtpDir, m_szMessageDir, filename); 
	CreateFilePath(m_szFilePath); 
	m_fp = fopen(m_szFilePath, "wb"); 
} 
 
void CUserSmtpConnection::OnSmtpMessageEntityBody(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
			const BYTE* pData, DWORD length) 
{ 
	if( m_fp ) 
		fwrite(pData, 1, length, m_fp); 
} 
 
void CUserSmtpConnection::OnSmtpMessageEntityBodyEnd(HNETINFO hNi, HSMTPCONNECT hSmtpConnect) 
{ 
	CloseFile(); 
} 
 
void CUserSmtpConnection::OnSmtpMessageTransferEnd(HNETINFO hNi, HSMTPCONNECT hSmtpConnect) 
{ 
	strcpy(m_szMessageDir, ""); 
} 
//---------------------- smtp user connection class end ----------------------------------- 
/////////////////////////////////////////////////////////////////////////////////////////// 
 
 
/////////////////////////////////////////////////////////////////////////////////////////// 
//---------------------- smtp user connection class begin --------------------------------- 
class CUserPop3Connection:public CUserConnection 
{ 
public: 
	CUserPop3Connection(HNETINFO hNi, const TCP_ADDR* connecter,  
						const TCP_ADDR* listener, const char* szPop3Dir); 
	virtual ~CUserPop3Connection(); 
 
	void OnPop3Command(HNETINFO hNi, HPOP3CONNECT hPop3Connect, const char* szCommand); 
	void OnPop3Reply(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
						const char* szCommand, const char* szReply); 
	void OnPop3MessageTransferBegin(HNETINFO hNi, HPOP3CONNECT hPop3Connect); 
	void OnPop3MessageHeader(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
							const char* from, const char* to, const char* subject); 
	void OnPop3MessageEntityHeader(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
							const char* mimeMainType, const char* mimeSubType,  
							const char* filename); 
	void OnPop3MessageEntityBody(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
			const BYTE* pData, DWORD length); 
	void OnPop3MessageEntityBodyEnd(HNETINFO hNi, HPOP3CONNECT hPop3Connect); 
	void OnPop3MessageTransferEnd(HNETINFO hNi, HPOP3CONNECT hPop3Connect); 
private: 
	void CloseFile(); 
private: 
	char m_szPop3Dir[MAX_PATH]; 
	char m_szMessageDir[MAX_PATH]; 
	char m_szFilePath[MAX_PATH]; 
	FILE *m_fp; 
}; 
 
CUserPop3Connection::CUserPop3Connection(HNETINFO hNi, const TCP_ADDR* connecter,  
						const TCP_ADDR* listener, const char* szPop3Dir) 
:CUserConnection(hNi, connecter, listener) 
{ 
	strcpy(m_szPop3Dir, szPop3Dir); 
	strcpy(m_szMessageDir, ""); 
	strcpy(m_szFilePath, ""); 
	m_fp = NULL; 
} 
 
void CUserPop3Connection::CloseFile() 
{ 
	if( m_fp ) 
	{ 
		fclose(m_fp); 
		m_fp = NULL; 
	} 
	strcpy(m_szFilePath, ""); 
} 
 
CUserPop3Connection::~CUserPop3Connection() 
{ 
	CloseFile(); 
} 
 
void CUserPop3Connection::OnPop3Command(HNETINFO hNi, HPOP3CONNECT hPop3Connect, const char* szCommand) 
{ 
} 
 
void CUserPop3Connection::OnPop3Reply(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
						const char* szCommand, const char* szReply) 
{ 
} 
 
void CUserPop3Connection::OnPop3MessageTransferBegin(HNETINFO hNi, HPOP3CONNECT hPop3Connect) 
{ 
	SYSTEMTIME lt; 
	GetLocalTime(<); 
	sprintf(m_szMessageDir, "%04d%02d%02d_%02d%02d%02d_%04d_%d__%d_%d_%d_%d_%d__%d_%d_%d_%d_%d",  
		lt.wYear, lt.wMonth, lt.wDay, lt.wHour, lt.wMinute, lt.wSecond, lt.wMilliseconds, rand(), 
		m_connecter.ip.b1, m_connecter.ip.b2, m_connecter.ip.b3, m_connecter.ip.b4, m_connecter.port, 
		m_listener.ip.b1, m_listener.ip.b2, m_listener.ip.b3, m_listener.ip.b4, m_listener.port); 
} 
 
void CUserPop3Connection::OnPop3MessageHeader(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
							const char* from, const char* to, const char* subject) 
{ 
	char filename[MAX_PATH]; 
	sprintf(filename, "%s%s\\header%d.txt", m_szPop3Dir, m_szMessageDir, rand() ); 
	CreateFilePath(filename); 
	FILE* fp = fopen(filename, "wt"); 
	if( fp ) 
	{ 
		fprintf(fp, "From: %s\n", from); 
		fprintf(fp, "To: %s\n", to); 
		fprintf(fp, "Subject: %s\n", subject); 
		fclose(fp); 
	} 
} 
 
void CUserPop3Connection::OnPop3MessageEntityHeader(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
							const char* mimeMainType, const char* mimeSubType,  
							const char* filename) 
{ 
	CloseFile(); 
	sprintf(m_szFilePath, "%s%s\\%s", m_szPop3Dir, m_szMessageDir, filename); 
	CreateFilePath(m_szFilePath); 
	m_fp = fopen(m_szFilePath, "wb"); 
} 
 
void CUserPop3Connection::OnPop3MessageEntityBody(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
			const BYTE* pData, DWORD length) 
{ 
	if( m_fp ) 
		fwrite(pData, 1, length, m_fp); 
} 
 
void CUserPop3Connection::OnPop3MessageEntityBodyEnd(HNETINFO hNi, HPOP3CONNECT hPop3Connect) 
{ 
	CloseFile(); 
} 
 
void CUserPop3Connection::OnPop3MessageTransferEnd(HNETINFO hNi, HPOP3CONNECT hPop3Connect) 
{ 
	strcpy(m_szMessageDir, ""); 
} 
//---------------------- smtp user connection class end ----------------------------------- 
/////////////////////////////////////////////////////////////////////////////////////////// 
 
 
//通知用户并由用户决定此连接是否打开，及其打开类型，返回TRUE表明打开， 返回FALSE表明不打开 
BOOL OnOpenConnect(HNETINFO hNi, const TCP_ADDR* connecter, const TCP_ADDR* listener,  
						enum CONNECT_TYPE *retType, DWORD* pdwAttachData) 
{ 
	CUserConnection *pUserConnect = NULL; 
	BOOL retVal = FALSE;//The [retval] attribute designates the parameter that receives the return value of the member. 
//return-type function-name([out, retval [, optional-attributes]] data-type * param-name, ...); 
 
	if( g_bSaveRawContent )//netinfo.cpp(31):BOOL g_bSaveRawContent = FALSE; 
	{ 
		*retType = TCP_CONNECT; 
		if( g_wTcpListenPort == 0 ) 
		{ 
			retVal = TRUE; 
			pUserConnect = new CUserDumpConnection(hNi, connecter, listener, g_szTxtPrintDir); 
		} 
		else 
		{ 
			if( listener->port == g_wTcpListenPort ) 
			{ 
				retVal = TRUE; 
				pUserConnect = new CUserDumpConnection(hNi, connecter, listener, g_szTxtPrintDir); 
			} 
		} 
	} 
	else if( g_bOnlyShow ) 
	{ 
		*retType = TCP_CONNECT; 
		retVal = TRUE; 
		pUserConnect = new CUserConnection(hNi, connecter, listener); 
	} 
	else 
	{ 
		*retType = TCP_CONNECT; 
		retVal = TRUE; 
		if( listener->port == TCP_PORT_HTTP || listener->port == 3128 || listener->port == 8080 ) 
		{ 
			*retType = HTTP_CONNECT; 
			pUserConnect = new CUserHttpConnection(hNi, connecter, listener, g_szHttpDir); 
		} 
		else if( listener->port == TCP_PORT_FTP ) 
		{ 
			*retType = FTP_CONNECT; 
			pUserConnect = new CUserFtpConnection(hNi, connecter, listener, g_szFtpDir); 
		} 
		else if( listener->port == TCP_PORT_SMTP ) 
		{ 
			*retType = SMTP_CONNECT; 
			pUserConnect = new CUserSmtpConnection(hNi, connecter, listener, g_szSmtpDir); 
		} 
		else if( listener->port == TCP_PORT_POP3 ) 
		{ 
			*retType = POP3_CONNECT; 
			pUserConnect = new CUserPop3Connection(hNi, connecter, listener, g_szPop3Dir); 
		} 
		else if( g_bAllConnectionSaved ) 
			pUserConnect = new CUserDumpConnection(hNi, connecter, listener, g_szTxtPrintDir); 
		else 
			pUserConnect = new CUserConnection(hNi, connecter, listener); 
	} 
	*pdwAttachData = (DWORD)pUserConnect; 
 
	return retVal; 
} 
 
//通知用户某连接将关闭 
void OnCloseConnect(HNETINFO hNi, HTCPCONNECT hConnect) 
{ 
	CUserConnection *pUserConnect = (CUserConnection *)GetConnectAttachData((HTCPCONNECT)hConnect); 
	if( pUserConnect )	delete pUserConnect; 
} 
	 
//通知用户某TCP连接有数据到达 
void OnTcpDataStub(HNETINFO hNi, HTCPCONNECT hConnect, BOOL bConnecterToListener,  
					const BYTE*pData, DWORD length) 
{ 
	CUserConnection *pUserConnect = (CUserConnection *)GetConnectAttachData((HTCPCONNECT)hConnect); 
	if( pUserConnect )	pUserConnect->OnTcpData(hNi, hConnect, bConnecterToListener, pData, length); 
} 
 
//通知用户某ftp连接客户端已发出命令，此命令行尾部的CRLF已被去掉 
void OnFtpCommandStub(HNETINFO hNi, HFTPCONNECT hFtpConnect, const char* szCommand) 
{ 
	CUserFtpConnection *pFtp = (CUserFtpConnection *)GetConnectAttachData((HTCPCONNECT)hFtpConnect); 
	if( pFtp )	pFtp->OnFtpCommand(hNi, hFtpConnect, szCommand); 
} 
 
//通知用户某ftp连接服务端已发出应答，此应答及对应的行尾部的CRLF已被去掉 
void OnFtpReplyStub(HNETINFO hNi, HFTPCONNECT hFtpConnect,  
		const char* szCommand, const char* szReply) 
{ 
	CUserFtpConnection *pFtp = (CUserFtpConnection *)GetConnectAttachData((HTCPCONNECT)hFtpConnect); 
	if( pFtp )	pFtp->OnFtpReply(hNi, hFtpConnect, szCommand, szReply); 
} 
 
//通知用户某ftp连接已准备传送一个文件,  
//参数szFullUnixFilePath已包含了'/'为目录分隔符的全路径 
void OnFtpFileTransferBeginStub(HNETINFO hNi, HFTPCONNECT hFtpConnect, DWORD dwStartPos, 
						BOOL bClientToServer, const char* szFullUnixFilePath) 
{ 
	CUserFtpConnection *pFtp = (CUserFtpConnection *)GetConnectAttachData((HTCPCONNECT)hFtpConnect); 
	if( pFtp )	pFtp->OnFtpFileTransferBegin(hNi, hFtpConnect, dwStartPos,  
											bClientToServer, szFullUnixFilePath); 
} 
 
//通知用户某FTP连接的某文件有一段数据已被传输 
void OnFtpFileDataStub(HNETINFO hNi, HFTPCONNECT hFtpConnect,  
						const BYTE*pData, DWORD length) 
{ 
	CUserFtpConnection *pFtp = (CUserFtpConnection *)GetConnectAttachData((HTCPCONNECT)hFtpConnect); 
	if( pFtp )	pFtp->OnFtpFileData(hNi, hFtpConnect, pData, length); 
} 
 
//通知用户某FTP连接的某文件已传输完毕 
void OnFtpFileTransferEndStub(HNETINFO hNi, HFTPCONNECT hFtpConnect) 
{ 
	CUserFtpConnection *pFtp = (CUserFtpConnection *)GetConnectAttachData((HTCPCONNECT)hFtpConnect); 
	if( pFtp )	pFtp->OnFtpFileTransferEnd(hNi, hFtpConnect); 
} 
 
 
 
//通知用户某HTTP连接的客户端即将发消息 
void OnHttpClientBeginStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpClientBegin(hNi, hHttpConnect); 
} 
 
//通知用户某HTTP连接的客户端发送的消息头 
void OnHttpClientHeaderStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect, 
						const HTTP_HEADER_INFO* pClientHeader) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpClientHeader(hNi, hHttpConnect, pClientHeader); 
} 
 
//通知用户某HTTP连接的客户端即将发送的已解码的消息体数据 
void OnHttpClientBodyStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect,  
					const BYTE* pData, DWORD length) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpClientBody(hNi, hHttpConnect, pData, length); 
} 
 
//通知用户某HTTP连接的客户端发送的消息体数据结束 
void OnHttpClientEndStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpClientEnd(hNi, hHttpConnect); 
} 
 
//通知用户某HTTP连接的服务器端即将发消息 
void OnHttpServerBeginStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpServerBegin(hNi, hHttpConnect); 
} 
 
//通知用户某HTTP连接的服务器端发送的消息头 
void OnHttpServerHeaderStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect, 
						const HTTP_HEADER_INFO* pClientHeader, const HTTP_HEADER_INFO* pServerHeader) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpServerHeader(hNi, hHttpConnect, pClientHeader, pServerHeader); 
} 
 
//通知用户某HTTP连接的服务器端发送的已解码的消息体数据 
void OnHttpServerBodyStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect,  
					const BYTE* pData, DWORD length) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpServerBody(hNi, hHttpConnect, pData, length); 
} 
 
//通知用户某HTTP连接的服务器端发送的消息体数据结束 
void OnHttpServerEndStub(HNETINFO hNi, HHTTPCONNECT hHttpConnect) 
{ 
	CUserHttpConnection *pHttp = (CUserHttpConnection*) GetConnectAttachData((HTCPCONNECT)hHttpConnect); 
	if( pHttp ) pHttp->OnHttpServerEnd(hNi, hHttpConnect); 
} 
 
 
 
 
void OnSmtpCommandStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect, const char* szCommand) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpCommand(hNi, hSmtpConnect, szCommand); 
} 
 
void OnSmtpReplyStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
						const char* szCommand, const char* szReply) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpReply(hNi, hSmtpConnect, szCommand, szReply); 
} 
 
void OnSmtpMessageTransferBeginStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpMessageTransferBegin(hNi, hSmtpConnect); 
} 
 
void OnSmtpMessageHeaderStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
							const char* from, const char* to, const char* subject) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpMessageHeader(hNi, hSmtpConnect, from,  to, subject); 
} 
 
void OnSmtpMessageEntityHeaderStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
							const char* mimeMainType, const char* mimeSubType,  
							const char* filename) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpMessageEntityHeader(hNi, hSmtpConnect, mimeMainType,  
												mimeSubType, filename); 
} 
 
void OnSmtpMessageEntityBodyStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect,  
			const BYTE* pData, DWORD length) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpMessageEntityBody(hNi, hSmtpConnect, pData, length); 
} 
 
void OnSmtpMessageEntityBodyEndStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpMessageEntityBodyEnd(hNi, hSmtpConnect); 
} 
 
void OnSmtpMessageTransferEndStub(HNETINFO hNi, HSMTPCONNECT hSmtpConnect) 
{ 
	CUserSmtpConnection *pSmtp = (CUserSmtpConnection*) GetConnectAttachData((HTCPCONNECT)hSmtpConnect); 
	if( pSmtp ) pSmtp->OnSmtpMessageTransferEnd(hNi, hSmtpConnect); 
} 
 
 
void OnPop3CommandStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect, const char* szCommand) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3Command(hNi, hPop3Connect, szCommand); 
} 
 
void OnPop3ReplyStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
						const char* szCommand, const char* szReply) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3Reply(hNi, hPop3Connect, szCommand, szReply); 
} 
 
 
 
 
 
void OnPop3MessageTransferBeginStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3MessageTransferBegin(hNi, hPop3Connect); 
} 
 
void OnPop3MessageHeaderStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
							const char* from, const char* to, const char* subject) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3MessageHeader(hNi, hPop3Connect, from,  to, subject); 
} 
 
void OnPop3MessageEntityHeaderStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
							const char* mimeMainType, const char* mimeSubType,  
							const char* filename) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3MessageEntityHeader(hNi, hPop3Connect, mimeMainType,  
												mimeSubType, filename); 
} 
 
void OnPop3MessageEntityBodyStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect,  
			const BYTE* pData, DWORD length) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3MessageEntityBody(hNi, hPop3Connect, pData, length); 
} 
 
void OnPop3MessageEntityBodyEndStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3MessageEntityBodyEnd(hNi, hPop3Connect); 
} 
 
void OnPop3MessageTransferEndStub(HNETINFO hNi, HPOP3CONNECT hPop3Connect) 
{ 
	CUserPop3Connection *pPop3 = (CUserPop3Connection*) GetConnectAttachData((HTCPCONNECT)hPop3Connect); 
	if( pPop3 ) pPop3->OnPop3MessageTransferEnd(hNi, hPop3Connect); 
}