LosaDev source snapshot 2019

extra/LS_TTBot/network/FSM.cpp

@@ -0,0 +1,44 @@
+
+#include "../stdafx.h"
+#include "FSM.h"
+
+FSM::FSM()
+{
+	InitState();
+}
+
+void FSM::InitState()
+{
+	m_iState = MAGIC_TOKEN_FSM;
+}
+
+bool FSM::IsFirst()
+{
+	if( MAGIC_TOKEN_FSM == m_iState )
+		return true;
+
+	return false;
+}
+
+int FSM::GetState()
+{
+	return m_iState;
+}
+
+void FSM::SetState(int iState)
+{
+	m_iState = iState;
+}
+
+void FSM::UpdateState()
+{
+	if( !IsFirst() )
+	{
+		m_iState = ( (~m_iState) + 5371 ) * 31;
+		m_iState = m_iState ^ ( m_iState >> 16);
+
+		if( m_iState < 0 )
+			m_iState = -m_iState;
+	}
+}
+

extra/LS_TTBot/network/FSM.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#define MAGIC_TOKEN_FSM		-1
+
+class FSM
+{
+protected:
+	int m_iState;
+
+public:
+	void InitState();
+	void UpdateState();
+
+public:
+	bool IsFirst();	
+	int GetState();
+	void SetState(int iState);
+
+public:
+	FSM();
+};

extra/LS_TTBot/network/NetworkSecurity.cpp

@@ -0,0 +1,60 @@
+#include "../StdAfx.h"
+#include "FSM.h"
+#include "NetworkSecurity.h"
+
+NetworkSecurity::NetworkSecurity()
+{
+}
+
+NetworkSecurity::~NetworkSecurity()
+{
+}
+
+// DoS Attack
+bool NetworkSecurity::UpdateReceiveCount()
+{
+	return true;
+}
+		
+// Packet CheckSum
+bool NetworkSecurity::IsCheckSum( CPacket &rkPacket )
+{
+	return true;
+}
+		
+// Packet Replay
+int NetworkSecurity::GetSndState()
+{
+	return MAGIC_TOKEN_FSM;
+}
+
+void NetworkSecurity::UpdateSndState()
+{
+
+}
+
+int NetworkSecurity::GetRcvState()
+{
+	return MAGIC_TOKEN_FSM;
+}
+
+void NetworkSecurity::UpdateRcvState()
+{
+
+}
+
+bool NetworkSecurity::CheckState( CPacket &rkPacket )
+{
+	return true;
+}
+
+
+void NetworkSecurity::PrepareMsg( CPacket &rkPacket )
+{
+	
+}
+
+void NetworkSecurity::CompletionMsg( CPacket &rkPacket )
+{
+	
+}

extra/LS_TTBot/network/NetworkSecurity.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "Packet.h"
+
+class NetworkSecurity
+{
+	// DoS Attack
+	public:
+	virtual bool UpdateReceiveCount();
+	
+	// Packet CheckSum
+	public:
+	virtual bool IsCheckSum( CPacket &rkPacket );
+
+	// Packet Replay
+	public:
+	virtual int	 GetSndState();
+	virtual void UpdateSndState();
+	virtual int  GetRcvState();
+	virtual void UpdateRcvState();
+	virtual bool CheckState( CPacket &rkPacket );
+
+	// Send 
+	public:
+	virtual void PrepareMsg( CPacket &rkPacket );
+	virtual void CompletionMsg( CPacket &rkPacket );
+
+	public:
+	NetworkSecurity();
+	virtual ~NetworkSecurity();
+};

extra/LS_TTBot/network/Packet.cpp

@@ -0,0 +1,157 @@
+// Packet.cpp: implementation of the CPacket class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "../stdafx.h"
+#include "Packet.h"
+
+#include "../LS_TTBotDlg.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CPacket::CPacket()
+{
+	Clear();
+}
+
+CPacket::CPacket(DWORD ID)
+{
+	Clear();
+	*m_packet_header.m_ID = ID;
+	m_currentPos = sizeof(PACKETHEADER);	
+}
+
+CPacket::CPacket(const uint8 *buffer, uint32 size) 
+{
+	Clear();
+
+	if( size >= sizeof(PACKETHEADER) )
+	{
+		memcpy( m_pBuffer , buffer, sizeof(PACKETHEADER) );
+		m_currentPos = sizeof(PACKETHEADER);
+	
+		if( size >= GetBufferSize() )
+		{
+			if( GetBufferSize() < m_currentPos )
+			{
+				MessageBox(NULL, "CPacket error", "error", MB_OK );
+				exit(1);
+				return;
+			}
+			memcpy( &m_pBuffer[m_currentPos], &buffer[m_currentPos], GetBufferSize() - m_currentPos );			
+		}
+	}
+}
+
+CPacket::~CPacket()
+{
+
+}
+
+void CPacket::Clear()
+{
+	memset(m_pBuffer,0,MAX_BUFFER);
+	m_currentPos = 0;
+	m_packet_header.m_ID		= (DWORD*)&m_pBuffer[PK_ID_ADDR];
+	m_packet_header.m_Size		= (DWORD*)&m_pBuffer[PK_SIZE_ADDR];
+	m_packet_header.m_CheckSum  = (DWORD*)&m_pBuffer[PK_CKSUM_ADDR];
+	m_packet_header.m_iState    = (int*)&m_pBuffer[PK_FSM_ADDR];
+	*m_packet_header.m_Size = sizeof(PACKETHEADER);
+}
+
+void CPacket::SetBufferCopy(char *pBuf,int size)
+{
+	Clear();
+
+	memcpy( m_pBuffer, pBuf, size );
+	m_currentPos = sizeof(PACKETHEADER);
+}
+
+void CPacket::SetDataAdd(char *pBuf,int size)
+{
+	memcpy( &m_pBuffer[m_currentPos], pBuf, size );
+	m_currentPos += size;
+	*m_packet_header.m_Size = m_currentPos;
+}
+
+void CPacket::SetCheckSum( DWORD dwSum )
+{
+	*m_packet_header.m_CheckSum = dwSum;
+}
+
+void CPacket::SetState( int iState )
+{
+	*m_packet_header.m_iState = iState;
+}
+
+const uint8* CPacket::GetBuffer() const
+{
+	return &m_pBuffer[0];
+}
+
+const uint8* CPacket::GetData() const
+{
+	return &m_pBuffer[0] + sizeof(PACKETHEADER);
+}
+
+uint32 CPacket::GetBufferSize() const
+{
+	return *m_packet_header.m_Size;
+}
+
+uint32 CPacket::GetDataSize() const
+{
+	return *m_packet_header.m_Size - sizeof(PACKETHEADER);
+}
+
+DWORD CPacket::GetPacketID() const
+{
+	return *m_packet_header.m_ID;
+}
+
+DWORD CPacket::GetCheckSum() const
+{
+	return *m_packet_header.m_CheckSum;
+}
+
+int CPacket::GetState() const
+{
+	return *m_packet_header.m_iState;
+}
+
+bool CPacket::IsValidHeader() const
+{
+	return (GetBufferSize() >= sizeof(PACKETHEADER) );
+}
+
+bool CPacket::IsValidPacket() const
+{
+	if(!IsValidHeader()) return false;
+
+	return (GetBufferSize() >= m_currentPos);
+}
+
+bool CPacket::CheckLeftPacketSize( int iAddSize )
+{	
+	if( m_currentPos + iAddSize >= MAX_BUFFER )
+	{
+		//LOG.PrintTimeAndLog( 0,"[ID:%d - SIZE:%d] << Packat Size Overflow!", GetPacketID(), m_currentPos + iAddSize );
+		return false;
+	}
+
+	return true;
+}
+
+bool CPacket::CheckRightPacketSize( int iAddSize )
+{	
+	if( m_currentPos + iAddSize >= MAX_BUFFER )
+	{
+		//LOG.PrintTimeAndLog( 0,"[ID:%d - SIZE:%d] >> Packat Size Overflow!", GetPacketID(), m_currentPos + iAddSize );
+		return false;
+	}
+
+	return true;
+}
+

extra/LS_TTBot/network/Packet.h

@@ -0,0 +1,64 @@
+#pragma once
+
+
+const int MAX_BUFFER = 1024 * 32;
+
+enum 
+{
+	PK_ID_ADDR		= 0,
+	PK_SIZE_ADDR    = 4,
+	PK_CKSUM_ADDR   = 8,
+	PK_FSM_ADDR     = 12,
+	PK_HEADER_SIZE  = 16,
+};
+
+class CPacket
+{
+public:
+	struct PACKETHEADER
+	{
+		DWORD *m_ID;
+		DWORD *m_Size;
+		DWORD *m_CheckSum;
+		int   *m_iState;
+		PACKETHEADER()
+		{
+			m_ID = m_Size = m_CheckSum = NULL;
+			m_iState = NULL;
+		}
+	};
+
+protected:
+	PACKETHEADER m_packet_header;
+	uint32 m_currentPos;
+	uint8 m_pBuffer[MAX_BUFFER];
+
+	bool CheckLeftPacketSize( int iAddSize );
+	bool CheckRightPacketSize( int iAddSize );
+public:
+	void Clear();
+	void SetBufferCopy(char *pBuf,int size);
+	void SetDataAdd(char *pBuf,int size);
+	void SetCheckSum( DWORD dwSum );
+	void SetState( int iState );
+	
+public:
+	const uint8* GetBuffer() const;            //패킷 버퍼의 모든 내용(헤더 포함).
+	const uint8* GetData() const;              //패킷 버퍼의 데이터 내용(헤더 미포함).
+	
+	uint32 GetBufferSize() const;
+	uint32 GetDataSize() const;
+
+	DWORD GetPacketID() const;
+	DWORD GetCheckSum() const;
+	int GetState() const;
+
+	bool IsValidHeader() const;
+	bool IsValidPacket() const;
+
+public:
+	CPacket();
+	CPacket( DWORD ID );
+	CPacket( const uint8 *buffer, uint32 size );
+	virtual ~CPacket();
+};

extra/LS_TTBot/network/RecvBuffer.cpp

@@ -0,0 +1,51 @@
+
+
+#include "../stdafx.h"
+#include "RecvBuffer.h"
+
+RecvBuffer::RecvBuffer()
+{
+	InitBuffer();
+}
+
+RecvBuffer::~RecvBuffer()
+{
+}
+
+void RecvBuffer::InitBuffer()
+{
+	m_iCurRcvSize = 0;
+}
+
+void RecvBuffer::UpdateRecvSize( int iCurRcvSize )
+{
+	m_iCurRcvSize += iCurRcvSize;
+}
+
+void RecvBuffer::RewindBuffer( int iRewindSize )
+{
+	m_iCurRcvSize -= iRewindSize;
+
+	memcpy( m_pRewindBuf, ( m_pBuf + iRewindSize ), m_iCurRcvSize );
+	memcpy( m_pBuf, m_pRewindBuf, m_iCurRcvSize );
+}
+
+char* RecvBuffer::GetStartPtr()
+{
+	return m_pBuf;
+}
+
+char* RecvBuffer::GetFreeSpacePtr()
+{
+	return m_pBuf + m_iCurRcvSize;
+}
+
+int RecvBuffer::GetCurRcvSize() const
+{
+	return m_iCurRcvSize;
+}
+
+int RecvBuffer::GetFreeSpaceSize() const
+{
+	return MAX_BUFFER - m_iCurRcvSize;
+}

extra/LS_TTBot/network/RecvBuffer.h

@@ -0,0 +1,31 @@
+
+
+#ifndef _RecvBuffer_h_
+#define _RecvBuffer_h_
+
+#include "ioPortalHelp.h"
+
+class RecvBuffer
+{
+private:
+	char m_pBuf[MAX_BUFFER];
+	int	 m_iCurRcvSize;
+
+	char m_pRewindBuf[MAX_BUFFER];
+
+public:
+	void InitBuffer();
+	void UpdateRecvSize( int iCurRcvSize );
+	void RewindBuffer( int iRewindSize );
+
+public:
+	char* GetStartPtr();
+	char* GetFreeSpacePtr();
+	int GetCurRcvSize() const;
+	int GetFreeSpaceSize() const;
+
+public:
+	RecvBuffer();
+	~RecvBuffer();
+};
+#endif

extra/LS_TTBot/network/SP2Packet.cpp

@@ -0,0 +1,397 @@
+#include "../stdafx.h"
+#include "SP2Packet.h"
+
+SP2Packet::SP2Packet()
+{
+}
+
+SP2Packet::SP2Packet( const SP2Packet &rhs )
+{
+	Clear();
+	memcpy( m_pBuffer, rhs.GetBuffer(), rhs.GetBufferSize() );
+	m_currentPos = rhs.m_currentPos;
+}
+
+SP2Packet::SP2Packet(DWORD ID) : CPacket( ID )
+{
+}
+
+SP2Packet::SP2Packet(const uint8* buffer,int size) : CPacket( buffer, size )
+{
+}
+
+SP2Packet::SP2Packet( DWORD dwUserIndex, SP2Packet &rhs )
+{
+	Clear();
+
+	*m_packet_header.m_ID = rhs.GetPacketID();
+	m_currentPos = sizeof(PACKETHEADER);
+	*this << dwUserIndex;
+	SetDataAdd( (char*)rhs.GetData(), rhs.GetDataSize() );
+}
+
+SP2Packet::~SP2Packet()
+{
+}
+
+const uint8* SP2Packet::GetData() const
+{
+	return &m_pBuffer[0] + sizeof(PACKETHEADER);
+}
+
+int SP2Packet::GetDataSize() const
+{
+	return *m_packet_header.m_Size - sizeof(PACKETHEADER);
+}
+
+const uint8* SP2Packet::GetBuffer() const
+{
+	return &m_pBuffer[0];
+}
+
+int SP2Packet::GetBufferSize() const
+{
+	return *m_packet_header.m_Size;
+}
+
+void SP2Packet::SetDataAdd( char *buffer, int size, bool bCurPosReSet )
+{
+	memcpy( &m_pBuffer[m_currentPos], buffer, size );
+	m_currentPos += size;
+	*m_packet_header.m_Size = m_currentPos;
+	if( bCurPosReSet )
+		m_currentPos = sizeof(PACKETHEADER);
+}
+
+void SP2Packet::SetDataAddCreateUDP( DWORD dwIP, DWORD dwPort, char *buffer, int size, bool bCurPosReSet /* = false  */ )
+{
+	*this << dwIP << dwPort;
+	memcpy( &m_pBuffer[m_currentPos], buffer, size );
+	m_currentPos += size;
+	*m_packet_header.m_Size = m_currentPos;
+	if( bCurPosReSet )
+		m_currentPos = sizeof(PACKETHEADER);
+}
+
+void SP2Packet::MovePointer( DWORD dwMoveBytes )
+{
+	m_currentPos += dwMoveBytes;
+	m_currentPos = min( m_currentPos, GetBufferSize() );
+}
+
+void SP2Packet::SetPosBegin()
+{
+	m_currentPos = sizeof(PACKETHEADER);
+}
+
+
+//operator
+SP2Packet& SP2Packet::operator = (const SP2Packet &packet)
+{
+	Clear();
+	memcpy(&m_pBuffer[0],packet.GetBuffer(),packet.GetBufferSize());
+	m_currentPos = packet.m_currentPos;
+
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (BYTE arg)
+{
+	if( !CheckLeftPacketSize( sizeof(BYTE) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(BYTE));
+	m_currentPos += sizeof(BYTE);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (bool arg)
+{
+	if( !CheckLeftPacketSize( sizeof(bool) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(bool));
+	m_currentPos += sizeof(bool);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (int arg)
+{
+	if( !CheckLeftPacketSize( sizeof(int) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(int));
+	m_currentPos += sizeof(int);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (LONG arg)
+{
+	if( !CheckLeftPacketSize( sizeof(LONG) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(LONG));
+	m_currentPos += sizeof(LONG);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (WORD arg)
+{
+	if( !CheckLeftPacketSize( sizeof(WORD) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(WORD));
+	m_currentPos += sizeof(WORD);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (DWORD arg)
+{
+	if( !CheckLeftPacketSize( sizeof(DWORD) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(DWORD));
+	m_currentPos += sizeof(DWORD);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (__int64 arg)
+{
+	if( !CheckLeftPacketSize( sizeof(__int64) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(__int64));
+	m_currentPos += sizeof(__int64);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (LPTSTR arg)
+{
+	int nlen = lstrlen(arg) * sizeof( TCHAR ) + sizeof( TCHAR );
+
+	if( !CheckLeftPacketSize( nlen ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],arg,nlen);
+	m_currentPos += nlen;
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (double arg)
+{
+	if( !CheckLeftPacketSize( sizeof(double) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(double));
+	m_currentPos += sizeof(double);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (float arg)
+{
+	if( !CheckLeftPacketSize( sizeof(float) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(float));
+	m_currentPos += sizeof(float);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (short arg)
+{
+	if( !CheckLeftPacketSize( sizeof(short) ) ) return *this;
+
+	memcpy(&m_pBuffer[m_currentPos],&arg,sizeof(short));
+	m_currentPos += sizeof(short);
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+//SP2Packet& SP2Packet::operator << ( CHARACTER &arg )
+//{
+//	arg.FillData( *this );
+//	return *this;
+//}
+
+SP2Packet& SP2Packet::operator << ( const ioHashString &arg )
+{
+	int nlen = lstrlen( arg.c_str() ) + 1;
+
+	if( !CheckLeftPacketSize( nlen ) ) return *this;
+
+	memcpy( &m_pBuffer[m_currentPos], arg.c_str(), nlen );
+	m_currentPos += nlen;
+	*m_packet_header.m_Size = m_currentPos;
+
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (CQueryData &arg)
+{
+	memcpy(&m_pBuffer[m_currentPos],arg.GetHeader(),sizeof(QueryHeader));
+	m_currentPos += sizeof(QueryHeader);
+	memcpy(&m_pBuffer[m_currentPos],arg.GetBuffer(),arg.GetBufferSize());
+	m_currentPos += arg.GetBufferSize();
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator << (CQueryResultData &arg)
+{
+	memcpy(&m_pBuffer[m_currentPos],arg.GetHeader(),sizeof(QueryResultHeader));
+	m_currentPos += sizeof(QueryResultHeader);
+	memcpy(&m_pBuffer[m_currentPos],arg.GetBuffer(),arg.GetResultBufferSize());
+	m_currentPos += arg.GetResultBufferSize();
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+
+SP2Packet&  SP2Packet::operator >> (BYTE &arg)
+{
+	if( !CheckRightPacketSize( sizeof(BYTE) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(BYTE));
+	m_currentPos += sizeof(BYTE);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (bool &arg)
+{
+	if( !CheckRightPacketSize( sizeof(bool) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(bool));
+	m_currentPos += sizeof(bool);
+
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (int &arg)
+{
+	if( !CheckRightPacketSize( sizeof(int) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(int));
+	m_currentPos += sizeof(int);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (LONG &arg)
+{
+	if( !CheckRightPacketSize( sizeof(LONG) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(LONG));
+	m_currentPos += sizeof(LONG);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (WORD &arg)
+{
+	if( !CheckRightPacketSize( sizeof(WORD) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(WORD));
+	m_currentPos += sizeof(WORD);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (DWORD &arg)
+{
+	if( !CheckRightPacketSize( sizeof(DWORD) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(DWORD));
+	m_currentPos += sizeof(DWORD);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (__int64 &arg)
+{	
+	if( !CheckRightPacketSize( sizeof(__int64) ) ) return *this;
+	
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(__int64));
+	m_currentPos += sizeof(__int64);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (LPTSTR arg)
+{
+	int nlen = lstrlen((LPTSTR)&m_pBuffer[m_currentPos]) * sizeof( TCHAR ) + sizeof( TCHAR );
+
+	if( !CheckRightPacketSize( nlen ) ) return *this;
+
+	memcpy(arg,&m_pBuffer[m_currentPos],nlen);
+	m_currentPos += nlen;
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (double &arg)
+{
+	if( !CheckRightPacketSize( sizeof(double) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(double));
+	m_currentPos += sizeof(double);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (float &arg)
+{
+	if( !CheckRightPacketSize( sizeof(float) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(float));
+	m_currentPos += sizeof(float);
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (short &arg)
+{
+	if( !CheckRightPacketSize( sizeof(short) ) ) return *this;
+
+	memcpy(&arg,&m_pBuffer[m_currentPos],sizeof(short));
+	m_currentPos += sizeof(short);
+
+	return *this;
+}
+
+//SP2Packet&  SP2Packet::operator >> (CHARACTER &arg)
+//{
+//	arg.ApplyData( *this );
+//
+//	return *this;
+//}
+
+SP2Packet& SP2Packet::operator >> ( ioHashString &arg )
+{
+	int nlen = lstrlen((LPTSTR)&m_pBuffer[m_currentPos]) * sizeof( TCHAR ) + sizeof( TCHAR );
+
+	if( !CheckRightPacketSize( nlen ) ) return *this;
+
+	arg = reinterpret_cast<const char*>(&m_pBuffer[m_currentPos]);
+	m_currentPos += nlen;
+	
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (CQueryData &arg)
+{
+	arg.SetBuffer(&m_pBuffer[m_currentPos]);
+	m_currentPos += sizeof(QueryHeader);
+	m_currentPos += arg.GetBufferSize();
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}
+
+SP2Packet&  SP2Packet::operator >> (CQueryResultData &arg)
+{
+	arg.SetBuffer(&m_pBuffer[m_currentPos]);
+	m_currentPos += sizeof(QueryResultHeader);
+	m_currentPos += arg.GetResultBufferSize();
+	*m_packet_header.m_Size = m_currentPos;
+	return *this;
+}

extra/LS_TTBot/network/SP2Packet.h

@@ -0,0 +1,66 @@
+#ifndef _SP2Packet_h_
+#define _SP2Packet_h_
+
+#include "Packet.h"
+#include "ioHashString.h"
+
+
+class SP2Packet : public CPacket
+{
+	public:
+	SP2Packet();
+	SP2Packet( const SP2Packet &rhs );
+	SP2Packet(DWORD ID);
+	SP2Packet(const uint8* buffer,int size);
+	SP2Packet( DWORD dwUserIndex, SP2Packet &rhs );
+	virtual ~SP2Packet();
+
+	const uint8* GetData() const;
+	int GetDataSize() const;
+	const uint8* GetBuffer() const;	
+	int   GetBufferSize() const;
+	void  SetDataAdd( char *buffer, int size, bool bCurPosReSet = false );
+	void  SetDataAddCreateUDP( DWORD dwIP, DWORD dwPort, char *buffer, int size, bool bCurPosReSet = false );
+	// >> ÂÊÀ¸·Î current_pos À̵¿
+	void  MovePointer( DWORD dwMoveBytes );
+	void  SetPosBegin();
+
+	//operator
+public:
+	SP2Packet&  operator =  ( const SP2Packet& packet );
+	SP2Packet&  operator << (BYTE arg);
+	SP2Packet&  operator << (bool arg);
+	SP2Packet&  operator << (int arg);
+	SP2Packet&  operator << (LONG arg);
+	SP2Packet&  operator << (WORD arg);
+	SP2Packet&  operator << (DWORD arg);
+	SP2Packet&  operator << (__int64 arg);
+	SP2Packet&  operator << (LPTSTR arg);
+	SP2Packet&  operator << (double arg);	
+	SP2Packet&  operator << (float arg);
+	SP2Packet&  operator << (short arg);
+	//SP2Packet&  operator << ( CHARACTER &arg );
+	SP2Packet&  operator << ( const ioHashString &arg );
+
+	SP2Packet&  operator << (CQueryData &arg);
+	SP2Packet&  operator << (CQueryResultData &arg);
+	
+	SP2Packet&  operator >> (BYTE &arg);
+	SP2Packet&  operator >> (bool &arg);
+	SP2Packet&  operator >> (int &arg);
+	SP2Packet&  operator >> (LONG &arg);
+	SP2Packet&  operator >> (WORD &arg);
+	SP2Packet&  operator >> (DWORD &arg);
+	SP2Packet&  operator >> (__int64 &arg);
+	SP2Packet&  operator >> (LPTSTR arg);
+	SP2Packet&  operator >> (double &arg);	
+	SP2Packet&  operator >> (float &arg);	
+	SP2Packet&  operator >> (short &arg);
+	//SP2Packet&  operator >> (CHARACTER &arg);
+	SP2Packet&  operator >> ( ioHashString &arg );
+
+	SP2Packet&  operator >> (CQueryData &arg);
+	SP2Packet&  operator >> (CQueryResultData &arg);
+
+};
+#endif

extra/LS_TTBot/network/SecurityTCP.cpp

@@ -0,0 +1,108 @@
+#include "../StdAfx.h"
+#include "cryption.h"
+#include "SecurityTCP.h"
+
+SecurityTCP::SecurityTCP(void)
+{
+	InitState();
+}
+
+SecurityTCP::~SecurityTCP(void)
+{
+}
+
+void SecurityTCP::InitState()
+{
+	m_SndState.InitState();
+	m_RcvState.InitState();
+}
+
+// Packet CheckSum
+void SecurityTCP::EncryptMsg( CPacket &rkPacket )
+{
+	// Check Sum
+	DWORD dwResult = MakeDigest(  (BYTE*)rkPacket.GetBuffer(), rkPacket.GetBufferSize()  );
+	rkPacket.SetCheckSum( dwResult );
+	
+	// Encryption
+	BYTE *pSrc;
+	pSrc = (BYTE*)rkPacket.GetBuffer() + PK_CKSUM_ADDR;
+	Encrypt( pSrc, rkPacket.GetBufferSize() - PK_CKSUM_ADDR );		
+}
+
+void SecurityTCP::DecryptMsg( CPacket &rkPacket )
+{
+	// Decryption
+	BYTE *pSrc;
+	pSrc = (BYTE*)rkPacket.GetBuffer() + PK_CKSUM_ADDR;
+	Decrypt( pSrc, rkPacket.GetBufferSize() - PK_CKSUM_ADDR );
+}
+
+bool SecurityTCP::IsCheckSum( CPacket &rkPacket )
+{
+	//Decrypt
+	DecryptMsg( rkPacket );
+
+	DWORD	dwTemp = rkPacket.GetCheckSum();   //Àӽà ÀúÀå.
+	rkPacket.SetCheckSum( 0 );
+	
+	DWORD dwResult = MakeDigest( (BYTE*)rkPacket.GetBuffer(), rkPacket.GetBufferSize() );
+
+	rkPacket.SetCheckSum( dwTemp );
+
+	// Check Sum
+	return ( dwResult == rkPacket.GetCheckSum() );
+}
+
+// Packet Replay
+int SecurityTCP::GetSndState()
+{
+	return m_SndState.GetState();
+}
+
+void SecurityTCP::UpdateSndState()
+{
+	m_SndState.UpdateState();
+}
+
+int SecurityTCP::GetRcvState()
+{
+	return m_RcvState.GetState();
+}
+
+void SecurityTCP::UpdateRcvState()
+{
+	m_RcvState.UpdateState();
+}
+
+bool SecurityTCP::CheckState( CPacket &rkPacket )
+{
+	if( GetRcvState() == MAGIC_TOKEN_FSM )
+	{
+		m_RcvState.SetState( rkPacket.GetState() );
+		m_SndState.SetState( rkPacket.GetState() );		
+		UpdateSndState();
+	}
+	else
+	{
+		if( GetRcvState() != rkPacket.GetState() )
+			return false;
+	}
+	
+	UpdateRcvState();	
+	return true;
+}
+
+void SecurityTCP::PrepareMsg( CPacket &rkPacket )
+{
+	rkPacket.SetState( GetSndState() );
+
+	EncryptMsg( rkPacket );
+
+	UpdateSndState();
+}
+
+void SecurityTCP::CompletionMsg( CPacket &rkPacket )
+{	
+}
+

extra/LS_TTBot/network/SecurityTCP.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "FSM.h"
+#include "NetworkSecurity.h"
+
+
+class SecurityTCP : public NetworkSecurity
+{
+public:
+	SecurityTCP(void);
+	~SecurityTCP(void);
+
+public:
+	void InitState();
+		
+	// Packet CheckSum
+protected:	
+	void  EncryptMsg( CPacket &rkPacket );
+	void  DecryptMsg( CPacket &rkPacket );
+	public:
+	virtual bool IsCheckSum( CPacket &rkPacket );
+	
+	// Packet Replay
+public:
+	virtual int	 GetSndState();
+	virtual void UpdateSndState();
+	virtual int  GetRcvState();
+	virtual void UpdateRcvState();
+	virtual bool CheckState( CPacket &rkPacket );
+	
+	// Send 
+public:
+	virtual void PrepareMsg( CPacket &rkPacket );
+	virtual void CompletionMsg( CPacket &rkPacket );
+
+private:
+	FSM m_SndState;
+	FSM m_RcvState;
+};

extra/LS_TTBot/network/SecurityUDP.cpp

@@ -0,0 +1,127 @@
+#include "../StdAfx.h"
+#include "cryption.h"
+#include "SecurityUDP.h"
+
+SecurityUDP::SecurityUDP(void)
+{
+	m_SndState.InitState();
+	m_RcvState.InitState();
+
+	m_recent_rcv_port = 0;
+	memset(m_recent_rcv_ip, 0, sizeof(m_recent_rcv_ip));	
+	m_pre_recent_rcv_port = 0;
+	memset( m_pre_recent_rcv_ip, 0, sizeof(m_pre_recent_rcv_ip) );
+}
+
+SecurityUDP::~SecurityUDP(void)
+{
+}
+
+void SecurityUDP::RcvPeerInfo( char *iip, int iPort )
+{
+	sprintf( m_recent_rcv_ip, iip );
+	m_recent_rcv_port = iPort;
+}
+
+// Packet CheckSum
+void SecurityUDP::EncryptMsg( CPacket &rkPacket )
+{
+	// Check Sum
+	DWORD dwResult = MakeDigest(  (BYTE*)rkPacket.GetBuffer(), rkPacket.GetBufferSize()  );
+	rkPacket.SetCheckSum( dwResult );
+	
+	// Encryption
+	BYTE *pSrc;
+	pSrc = (BYTE*)rkPacket.GetBuffer() + PK_CKSUM_ADDR;
+	Encrypt( pSrc, rkPacket.GetBufferSize() - PK_CKSUM_ADDR );	
+}
+
+void SecurityUDP::DecryptMsg( CPacket &rkPacket )
+{
+	// Decryption
+	BYTE *pSrc;
+	pSrc = (BYTE*)rkPacket.GetBuffer() + PK_CKSUM_ADDR;
+	Decrypt( pSrc, rkPacket.GetBufferSize() - PK_CKSUM_ADDR );
+}
+
+bool SecurityUDP::IsCheckSum( CPacket &rkPacket )
+{
+	//Decrypt
+	DecryptMsg( rkPacket );
+
+	DWORD	dwTemp = rkPacket.GetCheckSum();   //Àӽà ÀúÀå.
+	rkPacket.SetCheckSum( 0 );
+	
+	DWORD dwResult = MakeDigest( (BYTE*)rkPacket.GetBuffer(), rkPacket.GetBufferSize() );
+
+	rkPacket.SetCheckSum( dwTemp );
+	
+	// Check Sum
+	if( dwResult != rkPacket.GetCheckSum() )
+	{
+		//LOG.PrintTimeAndLog( LOG_DEBUG_LEVEL, "SecurityUDP::IsCheckSum Check Sum Fail!! [0x%x](%s:%d)", rkPacket.GetPacketID(), m_recent_rcv_ip, m_recent_rcv_port );
+		return false;
+	}
+	return true;
+}
+
+// Packet Replay
+int SecurityUDP::GetSndState()
+{
+	return m_SndState.GetState();
+}
+
+void SecurityUDP::UpdateSndState()
+{
+	m_SndState.UpdateState();
+}
+
+int SecurityUDP::GetRcvState()
+{
+	return m_RcvState.GetState();
+}
+
+void SecurityUDP::UpdateRcvState()
+{
+	m_RcvState.UpdateState();
+}
+
+bool SecurityUDP::CheckState( CPacket &rkPacket )
+{
+	if( rkPacket.GetState() != MAGIC_TOKEN_FSM )
+	{
+		if( GetRcvState() == rkPacket.GetState() )
+		{
+			if( !strcmp( m_recent_rcv_ip, m_pre_recent_rcv_ip ) && m_recent_rcv_port == m_pre_recent_rcv_port )
+			{
+				//LOG.PrintTimeAndLog( LOG_DEBUG_LEVEL, "SecurityUDP::CheckState Type:[0x%x] State Not Same %d(%s:%d)", 
+				//						rkPacket.GetPacketID(), rkPacket.GetState(), m_recent_rcv_ip, m_recent_rcv_port );
+				return false;
+			}
+		}
+		
+		strcpy(m_pre_recent_rcv_ip, m_recent_rcv_ip);
+		m_pre_recent_rcv_port = m_recent_rcv_port;
+
+		m_RcvState.SetState( rkPacket.GetState() );
+	}
+	return true;
+}
+
+void SecurityUDP::PrepareMsg( CPacket &rkPacket )
+{
+	if( GetSndState() == MAGIC_TOKEN_FSM )	// First
+		m_SndState.SetState( rand() );
+	
+	rkPacket.SetCheckSum( 0 ); 
+	rkPacket.SetState( GetSndState() );
+
+	EncryptMsg( rkPacket );
+
+	UpdateSndState();
+}
+
+void SecurityUDP::CompletionMsg( CPacket &rkPacket )
+{
+//	DecryptMsg( rkPacket );	
+}

extra/LS_TTBot/network/SecurityUDP.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "FSM.h"
+#include "NetworkSecurity.h"
+
+class SecurityUDP : public NetworkSecurity
+{
+public:
+	SecurityUDP(void);
+	~SecurityUDP(void);
+
+	// Packet CheckSum
+protected:	
+	void  EncryptMsg( CPacket &rkPacket );
+	void  DecryptMsg( CPacket &rkPacket );
+	
+public:
+	virtual bool IsCheckSum( CPacket &rkPacket );
+	
+	// Packet Replay	
+public:
+	virtual int	 GetSndState();
+	virtual void UpdateSndState();
+	virtual int  GetRcvState();
+	virtual void UpdateRcvState();
+	virtual bool CheckState( CPacket &rkPacket );
+	
+	// Send 
+public:
+	virtual void PrepareMsg( CPacket &rkPacket );
+	virtual void CompletionMsg( CPacket &rkPacket );
+	
+public:
+	void RcvPeerInfo( char *iip, int iPort );
+
+protected:
+	FSM m_SndState;
+	FSM m_RcvState;
+	char m_recent_rcv_ip[16];
+	int	 m_recent_rcv_port;
+	char m_pre_recent_rcv_ip[16];
+	int	 m_pre_recent_rcv_port;
+
+};

extra/LS_TTBot/network/SendBuffer.cpp

@@ -0,0 +1,117 @@
+
+
+#include "../stdafx.h"
+#include "SendBuffer.h"
+
+SendBuffer::SendBuffer()
+{
+	InitBuffer();
+}
+
+SendBuffer::~SendBuffer()
+{
+	ClearBuffer();
+}
+
+void SendBuffer::InitBuffer()
+{
+	memset(m_pBuffer, 0, sizeof(m_pBuffer) );
+	m_pStart = m_pEnd = m_pBuffer;
+	m_iRestCnt = 0;
+	m_bBlock = false;
+}
+
+void SendBuffer::ClearBuffer()
+{
+	memset(m_pBuffer, 0, sizeof(m_pBuffer) );
+	m_pStart = m_pEnd = m_pBuffer;
+	m_iRestCnt = 0;
+	m_bBlock = false;
+}
+
+bool SendBuffer::EnqueueData( const char *pData, int iPacketSize)
+{
+	if( m_iRestCnt + iPacketSize > MAX_BUFFER )
+		return false;
+	
+	memcpy(m_pEnd, pData, iPacketSize);
+
+	int iExtra = 0;
+	iExtra = m_pEnd + iPacketSize - m_pBuffer - MAX_BUFFER;
+	if( iExtra >= 0)		// MAX_TEMP_BUFF 까지 복사가 되었는지
+	{
+		memcpy(m_pBuffer, m_pBuffer + MAX_BUFFER, iExtra);
+		m_pEnd = m_pBuffer + iExtra;
+	}
+	else
+	{
+		m_pEnd += iPacketSize;
+	}
+	
+	m_iRestCnt += iPacketSize;
+	
+	return true;
+}
+
+int SendBuffer::DequeueData(int iTransfered)
+{
+	int iExtra = m_pStart + iTransfered - m_pBuffer - MAX_BUFFER;
+	int iRestSize = 0;
+
+	if( iExtra >= 0)	
+		m_pStart = m_pBuffer + iExtra;	
+	else	
+		m_pStart += iTransfered;
+	
+	m_iRestCnt -= iTransfered;
+	iRestSize = m_iRestCnt;
+	
+	if( iRestSize > 0)
+	{
+		if( iRestSize > MAX_TEMP_BUFF ) iRestSize = MAX_TEMP_BUFF;
+
+		iExtra = m_pBuffer + MAX_BUFFER - m_pStart;
+
+		if( iExtra < iRestSize )	// 앞쪽에 있는 데이터를 뒤로 복사해옴
+		{
+			memcpy( m_pBuffer + MAX_BUFFER, m_pBuffer, iRestSize - iExtra );
+		}
+	}
+
+	return iRestSize;
+}
+
+int SendBuffer::GetRestCnt()
+{
+	int iRestSize = m_iRestCnt;
+	int iExtra = 0;
+
+	if( iRestSize > 0)
+	{
+		if( iRestSize > MAX_TEMP_BUFF )	iRestSize = MAX_TEMP_BUFF;
+
+		iExtra = m_pBuffer + MAX_BUFFER - m_pStart;
+
+		if( iExtra < iRestSize )
+		{
+			memcpy( m_pBuffer + MAX_BUFFER, m_pBuffer, iRestSize - iExtra);
+		}
+	}
+
+	return iRestSize;
+}
+
+char* SendBuffer::GetQueuePtr() const
+{
+	return m_pStart;
+}
+
+void SendBuffer::SetBlock( bool bBlock )
+{
+	m_bBlock = bBlock;
+}
+
+bool SendBuffer::IsBlocked() const
+{
+	return m_bBlock;
+}

extra/LS_TTBot/network/SendBuffer.h

@@ -0,0 +1,39 @@
+
+
+#ifndef _SendBuffer_h_
+#define _SendBuffer_h_
+
+#include "ioPortalHelp.h"
+
+class SendBuffer
+{
+private:
+	char m_pBuffer[MAX_BUFFER + MAX_TEMP_BUFF];
+	char *m_pStart;
+	char *m_pEnd;
+
+	int	 m_iRestCnt;	
+	bool m_bBlock;
+
+public:
+	void InitBuffer();
+	void ClearBuffer();
+
+public:
+	bool EnqueueData( const char *pData, int iPacketSize );		// return : Can Now Send ?	
+	int  DequeueData( int iTransfered );
+
+public:
+	int GetRestCnt();
+	char* GetQueuePtr() const;
+
+public:
+	void SetBlock( bool bBlock );
+	bool IsBlocked() const;
+
+public:
+	SendBuffer();
+	~SendBuffer();
+};
+
+#endif

extra/LS_TTBot/network/TownPortal.h

@@ -0,0 +1,28 @@
+
+
+#ifndef _TownPortal_h_
+#define _TownPortal_h_
+
+
+#ifdef STATIC_TOWN_PORTAL_API
+	#define TOWN_PORTAL_API
+#else
+	#ifdef EXPORT_TOWN_PORTAL
+		#define TOWN_PORTAL_API __declspec(dllexport)
+	#else
+		#define TOWN_PORTAL_API __declspec(dllimport)
+	#endif
+#endif
+
+#include <winsock2.h>
+
+#pragma comment(lib, "ws2_32.lib")
+
+#include "ioPortalHelp.h"
+#include "Packet.h"
+#include "ioClientTCPSocket.h"
+#include "ioUDPSocket.h"
+#include "NetworkSecurity.h"
+#include "FSM.h"
+#include "cryption.h"
+#endif

extra/LS_TTBot/network/cryption.cpp

@@ -0,0 +1,50 @@
+#include "../stdafx.h"
+#include "md5.h"
+#include "cryption.h"
+
+void Encrypt(BYTE *szSrc, int len)
+{
+	BYTE ch;
+	BYTE temp;
+
+	for( int i=0 ; i<len ; i++ )
+	{
+		ch = szSrc[i];
+		ch ^= 0xff;
+		temp = (ch & 0xe0) >> 5;
+		ch <<= 3;
+		ch |= temp;
+		szSrc[i] = ch;
+	}
+}
+
+void Decrypt(BYTE *szSrc, int len)
+{
+	BYTE ch;
+	BYTE temp;
+
+	for( int i=0 ; i<len ; i++ )
+	{
+		ch = szSrc[i];
+		temp = (ch & 0x07) << 5;
+		ch>>=3;
+		ch |= temp;
+		ch ^= 0xff;
+		szSrc[i] = ch;
+	}	
+}
+
+DWORD MakeDigest( BYTE *szSrc, int len )
+{
+	MD5Context md5_ctx;
+	DWORD	dwDigest[4];
+	
+	MD5Init( &md5_ctx );
+	MD5Update( &md5_ctx, (unsigned char const *)szSrc, len );
+	MD5Final( (BYTE*)&dwDigest, &md5_ctx );
+	
+	DWORD dwResult;
+	dwResult = dwDigest[0] ^ dwDigest[1] ^ dwDigest[2] ^ dwDigest[3];
+	
+	return dwResult;
+}

extra/LS_TTBot/network/cryption.h

@@ -0,0 +1,5 @@
+#pragma once
+
+void Encrypt(BYTE *szSrc, int len);
+void Decrypt(BYTE *szSrc, int len);
+DWORD MakeDigest( BYTE *szSrc, int len );

extra/LS_TTBot/network/ioClientTCPSocket.cpp

@@ -0,0 +1,345 @@
+
+
+#include "../StdAfx.h"
+
+#include "Packet.h"
+#include "ioPortalHelp.h"
+#include "ioClientTCPSocket.h"
+#include "NetworkSecurity.h"
+#include "SendBuffer.h"
+#include "RecvBuffer.h"
+
+ioClientTCPSocket::ioClientTCPSocket()
+{
+	m_Socket = INVALID_SOCKET;
+	m_hWnd	 = 0;
+	m_WndMsg = 0;
+
+	m_pSndBuf = new SendBuffer;
+	m_pRcvBuf = new RecvBuffer;
+
+	memset( m_szConnectedIP, 0, MAX_PATH );
+	m_iConnectedPort = 0;
+
+	m_bConnected = false;
+	m_pNS = NULL;
+	m_bNoNagle   = FALSE;
+}
+
+ioClientTCPSocket::~ioClientTCPSocket()
+{
+	CloseClientTCP();
+
+	SAFEDELETE(m_pSndBuf);
+	SAFEDELETE(m_pRcvBuf);
+}
+
+bool ioClientTCPSocket::InitClientTCP( HWND hWnd, UINT uMsg, const char *szIP, int iPort )
+{
+	m_pSndBuf->InitBuffer();
+	m_pRcvBuf->InitBuffer();
+
+	m_Socket = socket( AF_INET, SOCK_STREAM, 0 );
+	if( m_Socket == INVALID_SOCKET )
+	{
+		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::InitClientTCP - socket setting error" );
+		ioPortalHelp::CheckSocketError( __FILE__, __LINE__ );
+		return false;
+	}
+
+	m_hWnd = hWnd;
+	m_WndMsg = uMsg;
+	m_bNoNagle   = FALSE;
+
+	int iMaxSize = MAX_BUFFER * 8;
+    setsockopt( m_Socket, SOL_SOCKET, SO_SNDBUF, (const char *)&iMaxSize,  sizeof(int) );
+    setsockopt( m_Socket, SOL_SOCKET, SO_RCVBUF, (const char *)&iMaxSize,  sizeof(int) );
+
+	BOOL bFlag = TRUE;
+	setsockopt( m_Socket, SOL_SOCKET, SO_KEEPALIVE, (const char*)&bFlag, sizeof(BOOL) );
+
+	SOCKADDR_IN kLocalSockIn;
+    memset( &kLocalSockIn, 0, sizeof(kLocalSockIn) );
+    kLocalSockIn.sin_family		 = AF_INET;
+    kLocalSockIn.sin_addr.s_addr = htonl(INADDR_ANY);
+    kLocalSockIn.sin_port		 = htons(iPort);
+    kLocalSockIn.sin_addr.s_addr = inet_addr(szIP);
+
+    if( WSAAsyncSelect( m_Socket, m_hWnd, m_WndMsg, FD_CONNECT) == SOCKET_ERROR )
+	{
+		DebugMBox( __FILE__, __LINE__, NULL,
+				   "ioClientTCPSocket::InitClientTCP-WSAAsyncSelect setting error" );
+    	return false;
+    }
+	else
+	{
+    	if( connect( m_Socket, (LPSOCKADDR)&kLocalSockIn, sizeof(kLocalSockIn) ) == SOCKET_ERROR ) 
+		{
+    	 	if( WSAGetLastError() != WSAEWOULDBLOCK )
+			{
+    			 DebugMBox( __FILE__, __LINE__, NULL,
+						    "ioClientTCPSocket::InitClientTCP-WSAAsyncSelect setting error" );
+    	 		return false;
+    		}
+    	}
+    }
+
+	strcpy( m_szConnectedIP, szIP );
+	m_iConnectedPort = iPort;
+
+	return true;
+}
+
+void ioClientTCPSocket::SetNS( NetworkSecurity *pNS )
+{
+	m_pNS = pNS;
+}
+
+bool ioClientTCPSocket::ReConnect()
+{
+	if( m_hWnd == NULL )
+	{
+		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::ReConnect -"
+								    "Window Handle NULL" );
+		return false;
+	}
+
+	if( strcmp( m_szConnectedIP, "" ) == 0 )
+	{
+		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::ReConnect -"
+								    " Connect IP Zero" );
+		return false;
+	}
+
+	if( m_iConnectedPort == 0 )
+	{
+		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::ReConnect -"
+								    " Connect PORT Zero" );
+		return false;
+	}
+
+	if( m_WndMsg == 0 )
+	{
+		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::ReConnect -"
+								    " Window Message Zero" );
+		return false;
+	}
+
+	return InitClientTCP( m_hWnd, m_WndMsg, m_szConnectedIP, m_iConnectedPort );
+}
+
+void ioClientTCPSocket::CloseClientTCP()
+{
+	if( m_Socket != INVALID_SOCKET )
+		closesocket( m_Socket );
+
+	m_Socket = INVALID_SOCKET;
+	m_bConnected = false;
+	m_bNoNagle   = FALSE;
+}
+
+bool ioClientTCPSocket::EvaluateSocket( WPARAM wParam, LPARAM lParam )
+{
+	switch( WSAGETSELECTEVENT(lParam) )
+	{
+	case FD_CONNECT:
+		if( WSAAsyncSelect( m_Socket, m_hWnd, m_WndMsg, FD_READ|FD_WRITE|FD_CLOSE) == SOCKET_ERROR )
+    	{
+    		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::EvaluateSocket -"
+								    "AsyncSelect can not request FD_READ|FD_WRITE|FD_CLOSE" );
+    		return false;
+    	}
+		break;
+	case FD_CLOSE:
+		CloseClientTCP();
+		DisconnectProcess();
+		break;
+	case FD_WRITE:
+		if( !m_bConnected )
+		{
+			m_bConnected = true;
+			ConnectProcess();
+		}
+		else
+		{
+			m_pSndBuf->SetBlock( false );
+			BufferSendLoop();
+		}
+		break;
+	case FD_READ:
+		RecvLoop( (SOCKET)wParam );
+		break;
+	default:
+		break;
+	}
+
+	return true;
+}
+
+bool ioClientTCPSocket::SendLoop( CPacket &rkPacket )
+{
+	if( m_Socket == INVALID_SOCKET || !m_bConnected )
+		return false;
+
+	if( m_pNS )
+		m_pNS->PrepareMsg( rkPacket );
+
+	if( m_pSndBuf->EnqueueData( rkPacket.GetBuffer(), rkPacket.GetBufferSize() ) )
+	{
+		bool bResult = BufferSendLoop();
+		
+		if( m_pNS )
+			m_pNS->CompletionMsg( rkPacket );
+
+		return bResult;
+	}
+
+	LOG.DebugLog( 0, __FILE__, __LINE__, "ioClientTCPSocket::SendLoop - Buffer Over Flow!!!" );
+	return false;
+}
+
+bool ioClientTCPSocket::RecvLoop( SOCKET cSocket )
+{
+	int iRecvSize = recv( cSocket, m_pRcvBuf->GetFreeSpacePtr(), m_pRcvBuf->GetFreeSpaceSize(), 0 );
+
+	if( iRecvSize > 0 )
+	{
+		m_pRcvBuf->UpdateRecvSize( iRecvSize );
+
+		while( m_pRcvBuf->GetCurRcvSize() > 0 )
+		{
+			int iCurBufferRcvSize = m_pRcvBuf->GetCurRcvSize();
+
+			CPacket kPacket( m_pRcvBuf->GetStartPtr(), iCurBufferRcvSize );
+			if( kPacket.IsValidPacket() && 
+				iCurBufferRcvSize >= kPacket.GetBufferSize() )
+			{
+				if( CheckNS( kPacket ) )
+					ProcessPacket( kPacket );
+				m_pRcvBuf->RewindBuffer( kPacket.GetBufferSize() );
+			}
+			else
+			{
+				break;	// 아직 패킷을 다 받지 못했다.
+			}
+		}
+
+		return true;
+	}
+	else if( iRecvSize == 0 )
+	{
+		LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::RecvLoop - Client TCP Socket Graceful Close" );
+    	return false;
+	}
+	else if( iRecvSize == SOCKET_ERROR )
+	{
+		int iLastError = WSAGetLastError();
+		if ( iLastError == WSAEWOULDBLOCK )
+		{
+			return true;
+		}
+		else
+    	{
+			LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::RecvLoop - Client TCP Socket recv Error" );
+    		return false;
+    	}
+	}
+
+	LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::RecvLoop - EXCEPT : Exception TCP recv state" );
+	return false;
+}
+
+bool ioClientTCPSocket::CheckNS( CPacket &rkPacket )
+{
+	if( !m_pNS ) return true;
+	
+	if( !m_pNS->UpdateReceiveCount() ) 
+		return false;
+	
+	if( !m_pNS->IsCheckSum( rkPacket ) )
+		return false;
+	
+	if( !m_pNS->CheckState( rkPacket ) )
+		return false;
+	
+	return true;
+}
+
+bool ioClientTCPSocket::BufferSendLoop()
+{
+	if( m_pSndBuf->IsBlocked() )
+		return true;
+
+	int nleft = m_pSndBuf->GetRestCnt();
+	int nRet = 0;
+
+	while(nleft>0)
+	{
+		nRet = send( m_Socket, m_pSndBuf->GetQueuePtr(), nleft, 0 );
+
+		if( nRet == SOCKET_ERROR )
+		{
+			if( WSAGetLastError() == WSAEWOULDBLOCK)
+			{
+				m_pSndBuf->SetBlock( true );
+				return true;
+			}
+			else
+			{
+				LOG.PrintTimeAndLog( 0, "ioClientTCPSocket::BufferSendLoop - Send Error" );
+				return false;
+			}
+		}
+		else
+		{
+			nleft = m_pSndBuf->DequeueData(nRet);
+		}
+	};
+
+	return true;
+}
+
+const char* ioClientTCPSocket::GetConnectedIP() const
+{
+	return m_szConnectedIP;
+}
+
+int ioClientTCPSocket::GetConnectedPort() const
+{
+	return m_iConnectedPort;
+}
+
+bool ioClientTCPSocket::IsConnected() const
+{
+	return m_bConnected;
+}
+
+SOCKET ioClientTCPSocket::GetSocket() const
+{
+	return m_Socket;
+}
+
+void ioClientTCPSocket::SetNagleAlgorithm( bool bOn )
+{
+	if( m_Socket == INVALID_SOCKET )
+		return;
+
+	if( bOn )
+	{
+		// Nagle On
+		if( m_bNoNagle == FALSE )
+			return;
+
+		m_bNoNagle = FALSE;
+		::setsockopt( m_Socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&m_bNoNagle, sizeof(m_bNoNagle) ); 
+	}
+	else
+	{
+		// Nagle Off
+		if( m_bNoNagle == TRUE )
+			return;
+
+		m_bNoNagle = TRUE;
+		::setsockopt( m_Socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&m_bNoNagle, sizeof(m_bNoNagle) ); 
+	}
+}

extra/LS_TTBot/network/ioClientTCPSocket.h

@@ -0,0 +1,68 @@
+
+
+#ifndef _ioClientTCPSocket_h_
+#define _ioClientTCPSocket_h_
+
+class CPacket;
+class SendBuffer;
+class RecvBuffer;
+class NetworkSecurity;
+
+class TOWN_PORTAL_API ioClientTCPSocket
+{
+protected:
+	SOCKET  m_Socket;
+	HWND	m_hWnd;
+	UINT	m_WndMsg;
+
+	SendBuffer *m_pSndBuf;
+	RecvBuffer *m_pRcvBuf;
+	
+	char	m_szConnectedIP[MAX_PATH];
+	int		m_iConnectedPort;
+	bool	m_bConnected;
+	BOOL    m_bNoNagle;
+
+public:
+	bool InitClientTCP( HWND hWnd, UINT uMsg, const char *szIP, int iPort );
+	void CloseClientTCP();
+	bool ReConnect();
+
+public:
+	bool EvaluateSocket( WPARAM wParam, LPARAM lParam );
+
+	virtual bool SendLoop( CPacket &rkPacket );
+	virtual bool RecvLoop( SOCKET cSocket );
+
+protected:
+	bool BufferSendLoop();
+
+public:
+	virtual void ConnectProcess() = 0;
+	virtual void DisconnectProcess() = 0;
+	virtual void ProcessPacket( CPacket &rkPacket ) = 0;
+
+public:
+	const char* GetConnectedIP() const;
+	int  GetConnectedPort() const;
+	bool IsConnected() const;
+
+	SOCKET GetSocket() const;
+
+public:
+	void SetNagleAlgorithm( bool bOn );
+
+protected:
+	NetworkSecurity *m_pNS;
+	
+public:
+	void SetNS( NetworkSecurity *pNS );
+	virtual bool CheckNS( CPacket &rkPacket );
+
+public:
+	ioClientTCPSocket();
+	virtual ~ioClientTCPSocket();
+};
+
+#endif
+

extra/LS_TTBot/network/ioHashString.cpp

@@ -0,0 +1,196 @@
+#include "../stdafx.h"
+#include "ioHashString.h"
+
+ioHashString::ioHashString()
+{
+	m_iCapacity = DEFAULT_CAPACITY;
+	m_pString = new char[ m_iCapacity ];
+
+	Clear();
+
+	m_dwHashCode = CalcHashCode( m_pString );
+}
+
+ioHashString::ioHashString( const char* str ) : m_pString(NULL)
+{
+	m_iLength = strlen( str );
+
+	int iCapacity = max( m_iLength + 1, DEFAULT_CAPACITY );
+	ReAllocCapacity( iCapacity );
+
+	strcpy( m_pString, str );
+	m_dwHashCode = CalcHashCode( str );
+}
+
+ioHashString::ioHashString( const ioHashString &rhs ) : m_pString(NULL)
+{
+	m_iLength = rhs.Length();
+
+	ReAllocCapacity( rhs.m_iCapacity );
+
+	strcpy( m_pString, rhs.m_pString );
+	m_dwHashCode = rhs.m_dwHashCode;
+}
+
+ioHashString::~ioHashString()
+{
+	if( m_pString )
+	{
+		delete[] m_pString;
+		m_pString = NULL;
+	}
+}
+
+bool ioHashString::IsEmpty() const
+{
+	return ( m_iLength == 0 );
+}
+
+int ioHashString::Length() const
+{
+	return m_iLength;
+}
+
+void ioHashString::Clear()
+{
+	memset( m_pString, 0, m_iCapacity );
+	m_iLength = 0;
+}
+
+const char* ioHashString::c_str() const
+{
+	return m_pString;
+}
+
+void ioHashString::ReAllocCapacity( int iNewCapacity )
+{
+	if( m_pString )
+	{
+		delete[] m_pString;
+		m_pString = NULL;
+	}
+
+	m_iCapacity = iNewCapacity;
+	m_pString = new char[iNewCapacity];
+}
+
+DWORD ioHashString::CalcHashCode( const char *str )
+{
+	DWORD dwLen, dwCh, dwResult;
+
+	dwLen    = strlen( str );
+	dwResult = HASH_CONST;
+
+	for( DWORD i=0; i<dwLen ; i++ )
+	{
+		dwCh     = (DWORD)str[i];
+		dwResult = ((dwResult<< 5) + dwResult) + dwCh; // hash * 33 + ch
+	}
+
+	return dwResult;
+}
+
+DWORD ioHashString::GetHashCode() const
+{
+	return m_dwHashCode;
+}
+
+void ioHashString::MakeLower()
+{
+	if( m_pString )
+	{
+		strlwr( m_pString );
+		m_dwHashCode = CalcHashCode( m_pString );
+	}
+}
+
+void ioHashString::MakeUpper()
+{
+	if( m_pString )
+	{
+		strupr( m_pString );
+		m_dwHashCode = CalcHashCode( m_pString );
+	}
+}
+
+bool ioHashString::operator<( const ioHashString &rhs ) const
+{
+	if( m_dwHashCode != rhs.m_dwHashCode )
+		return ( m_dwHashCode < rhs.m_dwHashCode );
+
+	return ( strcmp( m_pString, rhs.m_pString ) < 0 );
+}
+
+char ioHashString::At( int i ) const
+{
+	if( m_iLength < i || !m_pString )
+	{
+		//assert( false );
+		return 0;
+	}
+
+	return m_pString[i];
+}
+
+ioHashString& ioHashString::operator=( const ioHashString &rhs )
+{
+	m_iLength = rhs.Length();
+	if( m_iCapacity < m_iLength + 1 )
+	{
+		ReAllocCapacity( m_iLength + 1 );
+	}
+
+	strcpy(m_pString, rhs.m_pString );
+	m_dwHashCode = rhs.m_dwHashCode;
+
+	return *this;
+}
+
+ioHashString& ioHashString::operator=( const char *szText )
+{
+	m_iLength = strlen( szText );
+	if( m_iCapacity < m_iLength + 1 )
+	{
+		ReAllocCapacity( m_iLength + 1 );
+	}
+
+	strcpy( m_pString, szText );
+	m_dwHashCode = CalcHashCode( szText );
+
+	return *this;
+}
+
+bool ioHashString::operator==( const ioHashString &rhs ) const
+{
+	if( m_dwHashCode != rhs.m_dwHashCode )
+		return false;
+
+	if( strcmp( m_pString, rhs.m_pString ) != 0 )
+		return false;
+
+	return true;
+}
+
+bool ioHashString::operator==( const char *szText ) const
+{
+	if( strcmp( m_pString, szText ) != 0 )
+		return false;
+
+	return true;
+}
+
+bool ioHashString::operator!=( const ioHashString &rhs ) const
+{
+	if( *this == rhs )
+		return false;
+
+	return true;
+}
+
+bool ioHashString::operator!=( const char *szText ) const
+{
+	if( *this == szText )
+		return false;
+
+	return true;
+}

extra/LS_TTBot/network/ioHashString.h

@@ -0,0 +1,64 @@
+
+#ifndef _ioHashString_h_
+#define _ioHashString_h_
+
+#define HASH_CONST	5381
+
+#ifdef THAILAND_LONG_ID
+#define DEFAULT_CAPACITY	44 // SetReturnData() size을 사용하므로 ID_NUM_PLUS_ONE 길이 보다 길어야함
+#else
+#define DEFAULT_CAPACITY	32 // SetReturnData() size을 사용하므로 ID_NUM_PLUS_ONE 길이 보다 길어야함
+#endif
+
+// Original version is www.gamza.net
+#include <vector>
+
+class ioHashString
+{
+private:
+	char	*m_pString;
+	DWORD	m_dwHashCode;
+	int		m_iLength;
+	int		m_iCapacity;
+
+private:
+	void ReAllocCapacity( int iNewCapacity );
+
+public:
+	void Clear();
+
+	bool IsEmpty() const;
+	int  Length() const;
+	char At( int i ) const;
+
+	DWORD GetHashCode() const;
+	const char* c_str() const;
+	
+	void MakeLower();
+	void MakeUpper();
+
+public:
+	static DWORD CalcHashCode( const char *str );
+
+public:
+	bool operator < ( const ioHashString &rhs )	const;
+
+	ioHashString& operator=( const ioHashString &rhs );
+	ioHashString& operator=( const char *szText );
+
+	bool operator==( const ioHashString &rhs ) const;
+	bool operator==( const char *szText ) const;
+
+	bool operator!=( const ioHashString &rhs ) const;
+	bool operator!=( const char *szText ) const;
+
+public:
+	ioHashString();
+	ioHashString( const char *str );
+	ioHashString( const ioHashString &rhs );
+	~ioHashString();
+};
+
+typedef std::vector< ioHashString > ioHashStringVec;
+
+#endif

extra/LS_TTBot/network/ioPortalHelp.cpp

@@ -0,0 +1,137 @@
+
+
+#include "../StdAfx.h"
+
+#include "ioPortalHelp.h"
+
+bool ioPortalHelp::InitWinSock()
+{
+	WSADATA WOSAdata;
+    if( WSAStartup(0x0002, &WOSAdata) != 0 )
+        return false;
+
+    return true;
+}
+
+void ioPortalHelp::CloseWinSock()
+{
+	WSACleanup();
+}
+
+int ioPortalHelp::CheckSocketError( LPSTR szFileName, int iLineNum )
+{
+    int iErrorCode = WSAGetLastError();
+
+	switch( iErrorCode )
+    {
+  	case WSAEACCES:
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEACCES");break;
+	case WSAEADDRINUSE:
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEADDRINUSE");break;
+	case WSAEADDRNOTAVAIL :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEADDRNOTAVAIL ");break;
+	case WSAEAFNOSUPPORT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEAFNOSUPPORT ");break;
+	case WSAEALREADY :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEALREADY ");break;
+	case WSAECONNABORTED :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAECONNABORTED ");break;
+	case WSAECONNREFUSED :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAECONNREFUSED ");break;
+	case WSAECONNRESET :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAECONNRESET ");break;
+	case WSAEDESTADDRREQ :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEDESTADDRREQ ");break;
+	case WSAEFAULT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEFAULT ");break;
+	case WSAEHOSTDOWN :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEHOSTDOWN ");break;
+	case WSAEHOSTUNREACH :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEHOSTUNREACH ");break;
+	case WSAEINPROGRESS :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEINPROGRESS ");break;
+	case WSAEINTR :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEINTR ");break;
+	case WSAEINVAL :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEINVAL ");break;
+	case WSAEISCONN :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEISCONN ");break;
+	case WSAEMFILE :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEMFILE ");break;
+	case WSAEMSGSIZE :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEMSGSIZE ");break;
+	case WSAENETDOWN :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENETDOWN ");break;
+	case WSAENETRESET :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENETRESET ");break;
+	case WSAENETUNREACH :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENETUNREACH ");break;
+	case WSAENOBUFS :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENOBUFS ");break;
+	case WSAENOPROTOOPT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENOPROTOOPT ");break;
+	case WSAENOTCONN :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENOTCONN ");break;
+	case WSAENOTSOCK :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAENOTSOCK ");break;
+	case WSAEOPNOTSUPP :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEOPNOTSUPP ");break;
+	case WSAEPFNOSUPPORT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEPFNOSUPPORT ");break;
+	case WSAEPROCLIM :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEPROCLIM ");break;
+	case WSAEPROTONOSUPPORT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEPROTONOSUPPORT ");break;
+	case WSAEPROTOTYPE :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEPROTOTYPE ");break;
+	case WSAESHUTDOWN :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAESHUTDOWN ");break;
+	case WSAESOCKTNOSUPPORT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAESOCKTNOSUPPORT ");break;
+	case WSAETIMEDOUT :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAETIMEDOUT ");break;
+//	case WSATYPE_NOT_FOUND :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSATYPE_NOT_FOUND ");break;
+	case WSAEWOULDBLOCK :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEWOULDBLOCK ");break;
+	case WSAHOST_NOT_FOUND :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAHOST_NOT_FOUND ");break;
+//	case WSA_INVALID_HANDLE :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSA_INVALID_HANDLE ");break;
+//	case WSA_INVALID_PARAMETER :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSA_INVALID_PARAMETER ");break;
+//	case WSAINVALIDPROCTABLE :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAINVALIDPROCTABLE ");break;
+//	case WSAINVALIDPROVIDER :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAINVALIDPROVIDER ");break;
+//	case WSA_IO_INCOMPLETE :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSA_IO_INCOMPLETE ");break;
+//	case WSA_IO_PENDING :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSA_IO_PENDING ");break;
+//	case WSA_NOT_ENOUGH_MEMORY :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSA_NOT_ENOUGH_MEMORY ");break;
+	case WSANOTINITIALISED :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSANOTINITIALISED ");break;
+	case WSANO_DATA :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSANO_DATA ");break;
+	case WSANO_RECOVERY :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSANO_RECOVERY ");break;
+//	case WSASYSCALLFAILURE :
+//		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSASYSCALLFAILURE ");break;
+	case WSASYSNOTREADY :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSASYSNOTREADY ");break;
+	case WSATRY_AGAIN :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSATRY_AGAIN ");break;
+	case WSAVERNOTSUPPORTED :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAVERNOTSUPPORTED ");break;
+	case WSAEDISCON :
+		LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError:WSAEDISCON ");break;
+    default:
+    	LOG.DebugLog(0, szFileName, iLineNum,"CheckSocketError	: Exception (%d)", iErrorCode );
+    	break;
+    }
+	
+    return iErrorCode;
+}
+
+

extra/LS_TTBot/network/ioPortalHelp.h

@@ -0,0 +1,17 @@
+
+
+#ifndef _ioPortalHelp_h_
+#define _ioPortalHelp_h_
+
+namespace ioPortalHelp
+{
+	TOWN_PORTAL_API bool InitWinSock();
+	TOWN_PORTAL_API void CloseWinSock();
+
+	TOWN_PORTAL_API int CheckSocketError( LPSTR szFileName, int iLineNum );
+};
+
+#define MAX_BUFFER		32768         //8192 * 4
+#define MAX_TEMP_BUFF	MAX_BUFFER
+
+#endif

extra/LS_TTBot/network/ioUDPSocket.cpp

@@ -0,0 +1,266 @@
+
+
+#include "../stdafx.h"
+
+#include "ioPortalHelp.h"
+#include "ioUDPSocket.h"
+#include "Packet.h"
+#include "NetworkSecurity.h"
+
+#define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
+
+
+ioUDPSocket::ioUDPSocket()
+{
+	m_Socket = INVALID_SOCKET;
+	m_hWnd   = 0;
+	m_WndMsg = 0;
+	m_pNS    = NULL;
+
+	ClearIPInfo();
+}
+
+ioUDPSocket::~ioUDPSocket()
+{
+	CloseUDP();
+}
+
+void ioUDPSocket::ClearIPInfo()
+{
+	memset( m_RecentRcvIP, 0, sizeof(m_RecentRcvIP) );
+	m_iRecentRcvPort = 0;
+	m_iMainPort = 0;
+
+	memset( m_PreRecentRcvIP, 0, sizeof(m_PreRecentRcvIP) );
+	m_iPreRecentRcvPort = 0;
+
+	memset( m_szMyIP, 0, sizeof(m_szMyIP) );
+}
+
+bool ioUDPSocket::InitUDP( HWND hWnd, UINT uMsg, int iPort )
+{
+	ClearIPInfo();
+
+	m_Socket = socket( AF_INET, SOCK_DGRAM, 0 );
+	if( m_Socket == INVALID_SOCKET )
+	{
+		DebugMBox(__FILE__,__LINE__,NULL,"ioUDPSocket::InitUDP - socket setting error");
+		return false;
+	}
+
+	DWORD dwBytesReturned = 0;
+	BOOL  bNewBehavior = FALSE;
+	DWORD status;
+	status = WSAIoctl( m_Socket, SIO_UDP_CONNRESET, &bNewBehavior, sizeof( dwBytesReturned ), NULL, 0, &dwBytesReturned, NULL, NULL );
+	if( status == SOCKET_ERROR )
+	{
+		LOG.PrintTimeAndLog( 0, "ioUDPSocket::InitUDP Opt None SIO_UDP_CONNRESET : %d", WSAGetLastError() );
+	}
+
+	m_hWnd = hWnd;
+	m_WndMsg = uMsg;
+
+	SOCKADDR_IN kLocalSockIn;
+	memset( &kLocalSockIn, 0, sizeof(kLocalSockIn) );
+	kLocalSockIn.sin_family		 = AF_INET;
+	kLocalSockIn.sin_addr.s_addr = htonl( INADDR_ANY );
+	kLocalSockIn.sin_port		 = htons( iPort );
+	m_iMainPort = iPort;
+
+	if( bind( m_Socket, (LPSOCKADDR)&kLocalSockIn, sizeof(kLocalSockIn) ) == SOCKET_ERROR )
+	{
+		DebugMBox(__FILE__,__LINE__,NULL, "ioUDPSocket::InitUDP - bind setting error" );
+		return false;
+	}
+
+	int iMaxSize = MAX_BUFFER * 8;
+	setsockopt( m_Socket, SOL_SOCKET, SO_SNDBUF, (const char *)&iMaxSize,  sizeof(iMaxSize));
+	setsockopt( m_Socket, SOL_SOCKET, SO_RCVBUF, (const char *)&iMaxSize,  sizeof(iMaxSize));
+
+	//    BOOL is_flag = TRUE;
+	//     setsockopt(m_socket_object, SOL_SOCKET, SO_KEEPALIVE , (const char *)&is_flag,  sizeof(is_flag));
+
+	//     BOOL	no_nagle = TRUE;
+	//     setsockopt(m_socket_object, IPPROTO_TCP,  TCP_NODELAY, (const char *)&no_nagle,  sizeof(no_nagle));
+
+	if( WSAAsyncSelect( m_Socket, hWnd, uMsg, FD_READ) > 0 )
+	{
+		DebugMBox(__FILE__,__LINE__,NULL,"ioUDPSocket::InitUDP - WSAAsyncSelect error");
+		return false;
+	}
+
+	return true;
+}
+
+void ioUDPSocket::SetNS( NetworkSecurity *pNS )
+{
+	m_pNS = pNS;
+}
+
+void ioUDPSocket::CloseUDP()
+{
+	if( m_Socket != INVALID_SOCKET )
+	{
+		closesocket( m_Socket );
+		m_Socket = INVALID_SOCKET;
+	}
+}
+
+void ioUDPSocket::RcvPeerInfo( char *iip, int iPort )
+{
+	//¿ÜºÎ ó¸®.
+}
+
+bool ioUDPSocket::EvaluateSocket( WPARAM wParam, LPARAM lParam )
+{
+	if( WSAGETSELECTEVENT( lParam ) == FD_READ )
+		return RecvLoop( wParam );
+
+	return true;
+}
+
+bool ioUDPSocket::SendLoop( const char *szIP, int iPort, CPacket &rkPacket )
+{
+	SOCKADDR_IN server_sin;
+	server_sin.sin_family	   = AF_INET;
+	server_sin.sin_addr.s_addr = inet_addr( szIP );
+	server_sin.sin_port		   = htons( iPort );
+
+	int server_sin_len = sizeof( server_sin );
+
+	if( m_pNS )
+		m_pNS->PrepareMsg( rkPacket );
+	
+	int iSendSize = sendto( m_Socket, rkPacket.GetBuffer(), rkPacket.GetBufferSize(), 0, (struct sockaddr FAR	*)&server_sin, server_sin_len );
+	if( iSendSize == 0 )
+	{
+		LOG.PrintTimeAndLog( 0, "ioUDPSocket::SendLoop(%s:%d) : SizeZero( %d ) PacketType:%d", szIP, iPort, WSAGetLastError(), rkPacket.GetPacketID()  );
+		ioPortalHelp::CheckSocketError(__FILE__, __LINE__);
+	}
+	else if( iSendSize == SOCKET_ERROR )
+	{
+		LOG.PrintTimeAndLog( 0, "ioUDPSocket::SendLoop(%s:%d) : SocketError( %d ) PacketType:%d", szIP, iPort, WSAGetLastError(), rkPacket.GetPacketID()  );
+		ioPortalHelp::CheckSocketError(__FILE__, __LINE__);
+	}
+
+	if( m_pNS )
+		m_pNS->CompletionMsg( rkPacket );
+
+	return true;
+}
+
+bool ioUDPSocket::RecvLoop( SOCKET cSocket )
+{
+	int iRecvSize;
+	
+	SOCKADDR_IN kPeerSockIn;
+	int iPeerSockInSize = sizeof(kPeerSockIn);
+
+	iRecvSize = recvfrom( cSocket, 
+		                  m_szRcvBuf,
+						  MAX_BUFFER,
+						  0,
+						  (struct sockaddr FAR *)&kPeerSockIn,
+						  &iPeerSockInSize );
+
+	if( iRecvSize > 0 )
+	{
+		wsprintf( m_RecentRcvIP, "%d.%d.%d.%d", kPeerSockIn.sin_addr.s_net, 
+												kPeerSockIn.sin_addr.s_host, 
+												kPeerSockIn.sin_addr.s_lh,
+												kPeerSockIn.sin_addr.s_impno );
+
+		m_iRecentRcvPort = ntohs(kPeerSockIn.sin_port);
+		
+		CPacket kPacket( m_szRcvBuf, iRecvSize );
+		if( kPacket.IsValidPacket() && kPacket.GetBufferSize() == iRecvSize )
+		{
+			RcvPeerInfo( m_RecentRcvIP, m_iRecentRcvPort );
+			if( CheckNS( kPacket ) == false ) return false;
+			
+			ProcessPacket( kPacket, m_RecentRcvIP, m_iRecentRcvPort );
+			return true;
+		}
+		else
+		{
+			LOG.PrintTimeAndLog( 0, "ioUDPSocket::RecvLoop - Packet Error" );
+			LOG.PrintTimeAndLog( 0, "ioUDPSocket::RecvLoop - Valid(%d), BufSize:(%d), ID(%d), RecvSize(%d)",
+									kPacket.IsValidPacket(), kPacket.GetBufferSize(),
+									kPacket.GetPacketID(), iRecvSize );
+			ioPortalHelp::CheckSocketError( __FILE__, __LINE__ );
+			return false;
+		}
+	}
+	else if( iRecvSize == 0 )
+	{
+		LOG.PrintTimeAndLog( 0, "ioUDPSocket::RecvLoop - UDP Socket Graceful Close");
+		ioPortalHelp::CheckSocketError(__FILE__, __LINE__);
+		return false;
+	}
+	else if( iRecvSize==SOCKET_ERROR )
+	{
+		int iWSAError = WSAGetLastError();
+		if( iWSAError != WSAEWOULDBLOCK )
+		{
+			LOG.PrintTimeAndLog( 0, "ioUDPSocket::RecvLoop - UDP Socket SOCKET_ERROR(%d)", iWSAError );
+			ioPortalHelp::CheckSocketError(__FILE__, __LINE__);
+			return false;
+		}
+	}
+
+	LOG.PrintTimeAndLog( 0, "ioUDPSocket::RecvLoop - Except Unknown Error" );
+	ioPortalHelp::CheckSocketError( __FILE__, __LINE__ );
+
+	return false;
+}
+
+bool ioUDPSocket::CheckNS( CPacket &rkPacket )
+{
+	if( !m_pNS ) return true;
+	
+	if( !m_pNS->UpdateReceiveCount() ) 
+		return false;
+	
+	if( !m_pNS->IsCheckSum( rkPacket ) )
+		return false;
+	
+	if( !m_pNS->CheckState( rkPacket ) )
+		return false;
+	
+	return true;
+}
+
+void ioUDPSocket::SocketErrorMsg( const char *szError )
+{
+	if( szError )
+	{
+		LOG.PrintTimeAndLog( 0, "%s:%d - %s", m_RecentRcvIP, m_iRecentRcvPort, szError );
+	}
+}
+
+void ioUDPSocket::GetRecentIPPort( char *szIP, int &iPort )
+{
+	strcpy( szIP, m_RecentRcvIP );
+	iPort = m_iRecentRcvPort;
+}
+
+const char* ioUDPSocket::GetMyIP()
+{
+	char szHost[MAX_PATH];
+	gethostname( szHost, MAX_PATH );
+
+	HOSTENT *pHost = gethostbyname( szHost );
+	if( !pHost )
+	{   
+		sprintf(m_szMyIP, "%d.%d.%d.%d", 127,0,0,1);
+	}
+	else
+	{
+		sprintf(m_szMyIP, "%d.%d.%d.%d", (BYTE)pHost->h_addr_list[0][0],
+										 (BYTE)pHost->h_addr_list[0][1],
+										 (BYTE)pHost->h_addr_list[0][2],
+										 (BYTE)pHost->h_addr_list[0][3]);
+	}
+
+	return m_szMyIP;
+}

extra/LS_TTBot/network/ioUDPSocket.h

@@ -0,0 +1,62 @@
+
+
+#ifndef _ioUDPSocket_h_
+#define _ioUDPSocket_h_
+
+#include "ioPortalHelp.h"
+
+class CPacket;
+class NetworkSecurity;
+
+class TOWN_PORTAL_API ioUDPSocket
+{
+protected:
+	SOCKET  m_Socket;
+	HWND	m_hWnd;
+	UINT	m_WndMsg;
+
+	char	m_RecentRcvIP[16];
+	int		m_iRecentRcvPort;
+
+	int		m_iMainPort;
+
+	char	m_PreRecentRcvIP[16];
+	int		m_iPreRecentRcvPort;
+
+	char	m_szRcvBuf[MAX_BUFFER];
+	char	m_szMyIP[MAX_PATH];
+
+protected:
+	void ClearIPInfo();
+
+public:
+	bool InitUDP( HWND hWnd, UINT uMsg, int iPort );
+	void CloseUDP();
+
+public:
+	bool EvaluateSocket( WPARAM wParam, LPARAM lParam );
+	bool SendLoop( const char *szIP, int iPort, CPacket &rkPacket );
+
+protected:
+	bool RecvLoop( SOCKET cSocket );
+	virtual void ProcessPacket( CPacket &rkPacket, char *RcvIP, int iRcvPort ) = 0;
+
+public:
+	virtual void RcvPeerInfo( char *iip, int iPort );
+	virtual void SocketErrorMsg( const char *szError );
+	void GetRecentIPPort( char *szIP, int &iPort );
+	const char* GetMyIP();
+
+protected:
+	NetworkSecurity *m_pNS;
+	
+public:
+	void SetNS( NetworkSecurity *pNS );
+	virtual bool CheckNS( CPacket &rkPacket );
+
+public:
+	ioUDPSocket();
+	virtual ~ioUDPSocket();
+};
+
+#endif

extra/LS_TTBot/network/md5.cpp

@@ -0,0 +1,254 @@
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+#include "../stdafx.h"
+#include "md5.h"
+#include <memory.h>
+
+#ifndef HIGHFIRST
+#define byteReverse(buf, len)	/* Nothing */
+#else
+void byteReverse(unsigned char *buf, unsigned longs);
+
+#ifndef ASM_MD5
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+void byteReverse(unsigned char *buf, unsigned longs)
+{
+    DWORD t;
+    do {
+	t = (DWORD) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+	    ((unsigned) buf[1] << 8 | buf[0]);
+	*(DWORD *) buf = t;
+	buf += 4;
+    } while (--longs);
+}
+#endif
+#endif
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void MD5Init(MD5Context *ctx)
+{
+    ctx->buf[0] = 0x67452301;
+    ctx->buf[1] = 0xefcdab89;
+    ctx->buf[2] = 0x98badcfe;
+    ctx->buf[3] = 0x10325476;
+
+    ctx->bits[0] = 0;
+    ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void MD5Update(MD5Context *ctx, unsigned char const *buf, unsigned len)
+{
+    DWORD t;
+
+    /* Update bitcount */
+
+    t = ctx->bits[0];
+    if ((ctx->bits[0] = t + ((DWORD) len << 3)) < t)
+	ctx->bits[1]++;		/* Carry from low to high */
+    ctx->bits[1] += len >> 29;
+
+    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
+
+    /* Handle any leading odd-sized chunks */
+
+    if (t) {
+	unsigned char *p = (unsigned char *) ctx->in + t;
+
+	t = 64 - t;
+	if (len < t) {
+	    memcpy(p, buf, len);
+	    return;
+	}
+	memcpy(p, buf, t);
+	byteReverse(ctx->in, 16);
+	MD5Transform(ctx->buf, (DWORD *) ctx->in);
+	buf += t;
+	len -= t;
+    }
+    /* Process data in 64-byte chunks */
+
+    while (len >= 64) {
+	memcpy(ctx->in, buf, 64);
+	byteReverse(ctx->in, 16);
+	MD5Transform(ctx->buf, (DWORD *) ctx->in);
+	buf += 64;
+	len -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+
+    memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void MD5Final(unsigned char digest[16], MD5Context *ctx)
+{
+    unsigned count;
+    unsigned char *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (ctx->bits[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = ctx->in + count;
+    *p++ = 0x80;
+
+    /* Bytes of padding needed to make 64 bytes */
+    count = 64 - 1 - count;
+
+    /* Pad out to 56 mod 64 */
+    if (count < 8) {
+	/* Two lots of padding:  Pad the first block to 64 bytes */
+	memset(p, 0, count);
+	byteReverse(ctx->in, 16);
+	MD5Transform(ctx->buf, (DWORD *) ctx->in);
+
+	/* Now fill the next block with 56 bytes */
+	memset(ctx->in, 0, 56);
+    } else {
+	/* Pad block to 56 bytes */
+	memset(p, 0, count - 8);
+    }
+    byteReverse(ctx->in, 14);
+
+    /* Append length in bits and transform */
+    ((DWORD *) ctx->in)[14] = ctx->bits[0];
+    ((DWORD *) ctx->in)[15] = ctx->bits[1];
+
+    MD5Transform(ctx->buf, (DWORD *) ctx->in);
+    byteReverse((unsigned char *) ctx->buf, 4);
+    memcpy(digest, ctx->buf, 16);
+    memset(ctx, 0, sizeof(ctx));	/* In case it's sensitive */
+}
+
+#ifndef ASM_MD5
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void MD5Transform(DWORD buf[4], DWORD const in[16])
+{
+    register DWORD a, b, c, d;
+
+    a = buf[0];
+    b = buf[1];
+    c = buf[2];
+    d = buf[3];
+
+    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+    buf[0] += a;
+    buf[1] += b;
+    buf[2] += c;
+    buf[3] += d;
+}
+
+#endif

extra/LS_TTBot/network/md5.h

@@ -0,0 +1,20 @@
+#pragma once
+
+typedef struct tagMD5Context
+{
+   DWORD buf[4];
+   DWORD bits[2];
+   unsigned char in[64];
+}MD5Context;
+
+void MD5Init( MD5Context *context );
+void MD5Update( MD5Context *context, unsigned char const *buf,
+			    unsigned len );
+void MD5Final( unsigned char digest[16], MD5Context *context );
+void MD5Transform( DWORD buf[4], DWORD const in[16] );
+
+/*
+ * This is needed to make RSAREF happy on some MS-DOS compilers.
+ */
+
+