mirsocket.cpp

这是传奇代码私服之二

// MirSocket.cpp : implementation file
//

#include "stdafx.h"
#include "MirX.h"
#include "MirSocket.h"
#include "bindef.h"

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

/////////////////////////////////////////////////////////////////////////////
// CMirSocket

CMirSocket::CMirSocket()
{
	m_ConvBuffer = new char[MSGBUFFERSIZE];
	m_RecvBuffer = new char[MSGBUFFERSIZE];
	m_SendBuffer = new char[MSGBUFFERSIZE];
	CMirSocket::m_msgflag='1';
	m_Socket=INVALID_SOCKET;
}

CMirSocket::~CMirSocket()
{
	delete	m_ConvBuffer;
	delete	m_RecvBuffer;
	delete	m_SendBuffer;
}


/////////////////////////////////////////////////////////////////////////////
// CMirSocket member functions

int CMirSocket::UnGameCode(char *p, BYTE *out)
{
	int	i=0;
	int ilen=0,olen=0;
	int	iptr=0,optr=0;
	BYTE * pb=(BYTE*)p;
	BYTE b1,b2,b3,b4;
	if(p==NULL || out==NULL)
		return 0;
	ilen = strlen( p );
	if( ilen <= 0 )
		return 0;
	*((DWORD*)&p[ilen]) = 0x3c3c3c;
	olen = (ilen * 6) / 8;
	for( i =0;i < ((ilen + 3)/4);i ++ )
	{
		b1 = (pb[iptr++] - 0x3c) & 0x3f;
		b2 = (pb[iptr++] - 0x3c) & 0x3f;
		b3 = (pb[iptr++] - 0x3c) & 0x3f;
		b4 = (pb[iptr++] - 0x3c) & 0x3f;
		out[optr++] =(( b1 & b00111111) << 2 )| ((b2 & b00110000) >> 4);
		out[optr++] =(( b2 & b00001111) << 4 )| ((b3 & b00111100) >> 2);
		out[optr++] =(( b3 & b00000011) << 6 )| b4;
	}
	out[olen] = '\0';
	return olen;
}

int CMirSocket::UnGateCode(char *in, char *out)
{
	if(in==NULL)
		return 0;
	int lcnt=strlen(in)>>1;
	if(lcnt==0)
		return 0;
	if(in[0]==(char)0)
		return 0;
	int i=0;
	int icode=0;
	

	int _edi=0xf667;

	for(i=0;i<lcnt;i++)
	{
		out[i]=((hex2int(ucase(in[i*2]))&0xf)<<4);
		out[i]+=hex2int(ucase(in[i*2+1]))&0xf;
		icode=((int)out[i])&0xff;
		out[i]^=((_edi & 0xffff)>>8);
		_edi=(((_edi+icode)* 0xce6d)&0xffff)+0x58bf;
	}
	out[lcnt]=(char)0;
	return 1;
}

int CMirSocket::CodeGateCode(char *in, char *out)
{
	int lcnt=strlen(in) ;
	int i=0;
	int icode=0;
	int tcode=0;
	int hbyte=0;
	int lbyte=0;
	int _edi=0xf667;
	for(i=0;i<lcnt;i++)
	{
		icode=((int)in[i])&0xff;
		tcode=icode;
		tcode^=((_edi&0xffff)>>8);
		hbyte=(tcode&0xf0)>>4;
		lbyte=(tcode&0xf);
		out[i*2]=int2hex(hbyte);
		out[i*2+1]=int2hex(lbyte);
		_edi=(((_edi+tcode)*0xce6d)&0xffff)+0x58bf;
	}
	out[i * 2] = '\0';
	return 1;
}

int CMirSocket::CodeGameCode(BYTE *in, int size, BYTE *out)
{
	int i = 0,ilen = 0;
	int idxout = 0;
	int	idxin = 0;
	int reallen = 0;
	ilen = size;
	ilen = (size + 2)/3;
	BYTE	b1,b2,b3;
	reallen = (size  * 8 + 5) / 6;
	
	(*(DWORD*)&in[size])=0;
	for( i = 0;i < ilen;i ++ )
	{

		b1 = in[idxin++];
		b2 = in[idxin++];
		b3 = in[idxin++];
		
		out[idxout++] = ((b1 & b11111100) >> 2)+'<'; 
		out[idxout++] = (((b1 & b00000011) << 4)|((b2 & b11110000) >> 4))+'<';
		out[idxout++] = (((b2 & b00001111) << 2)|((b3 & b11000000) >> 6))+'<';
		out[idxout++] = (b3 & b00111111)+'<';
	}
	out[reallen]= '\0';
	return 1;
}

int CMirSocket::UnNameCode(char *in, char *out)
{
	int i = 0;
	while( in[i] != '\0' )
	{
		out[i] = (in[i] & 0x3f ) << 2;
		out[i] |= (in[i + 1] & 0xc0 ) >> 6;
		i ++;
	}
	out[i] = '\0';
	return 1;
}

int CMirSocket::RecvGateMsg(MMSG *pmsg)
{
	int ierr;
	ierr = RecvString(m_RecvBuffer, MSGLENGTH );
	if( ierr == -1 )
	{
		return -1;
	}
	if( m_RecvBuffer[0] != '<' )
		return 0;
	if( m_RecvBuffer[ierr-1] != '>' )
		return 0;

	m_RecvBuffer[ierr-1] = '\0';

	ierr = UnGateCode( &m_RecvBuffer[1], m_ConvBuffer );
	ierr = strlen( m_ConvBuffer );
	if( m_ConvBuffer[0] != '#' )
		return 0;
	if(m_ConvBuffer[ierr-1] == '!' )
	{
		m_ConvBuffer[ierr-1] = '\0';
	}
	ierr = UnGameCode( &m_ConvBuffer[1], (BYTE*)pmsg );
	return ierr;
}

int CMirSocket::RecvMsg(MMSG *pmsg)
{
	int ierr;
	ierr = RecvString(m_RecvBuffer, MSGBUFFERSIZE );
	if( ierr == -1 )
	{
		return -1;
	}
	if( m_RecvBuffer[0] != '#' )
	{
		return 0;
	}
	if(m_RecvBuffer[ierr-1] == '!' )
	{
		m_RecvBuffer[ierr-1] = '\0';
	}
	ierr = UnGameCode( &m_RecvBuffer[1], (BYTE*)pmsg );
	return ierr;
}

int CMirSocket::RecvString(char *string, int maxlen)
{
	int ierr = 0;
	ierr=Receive(m_RecvBuffer,MSGBUFFERSIZE);
	if( ierr !=- 1 )
	{
		if( m_RecvBuffer[0] == '*' )
		{
			ierr --;
			memcpy( (void*)string, &m_RecvBuffer[1], ierr );
		}
		else
		{
			memcpy( (void*)string, m_RecvBuffer, ierr );
		}
		string[ierr] = '\0';
	}
	return ierr;
}

int CMirSocket::SendGateMsg(MMSG *pmsg)
{
	int msize = 0;
	msize = strlen(pmsg->data ) + MSGHEADERSIZE;
	CodeGameCode( (BYTE*)pmsg, msize, (BYTE*)m_ConvBuffer );
	sprintf(m_SendBuffer , "#%c%s!",m_msgflag, m_ConvBuffer );
	CodeGateCode(m_SendBuffer, m_ConvBuffer );
	sprintf(m_SendBuffer, "<%s>", m_ConvBuffer );

	return SendString(m_SendBuffer );
}

int CMirSocket::SendMsg(MMSG *pmsg)
{
	int msize = 0;
	msize = strlen(pmsg->data ) + MSGHEADERSIZE;
	CodeGameCode( (BYTE*)pmsg, msize, (BYTE*)m_ConvBuffer );
	sprintf( m_SendBuffer , "#%c%s!",m_msgflag, m_ConvBuffer );
	return SendString(m_SendBuffer );
}

int CMirSocket::SendString(char *string)
{
	int ierr = 0;
	int ilen = strlen( string );
	ierr=Send(string,ilen);

	if( ierr == ilen )
	{
		if( string[0] == '*' )
			return ierr;
		m_msgflag ++;
		if( m_msgflag > '9' )
			m_msgflag = '1';
	}
	return ierr;
}

int CMirSocket::GetString(char *string)
{
	int ilen=strlen(string);
	int i=0;
	int cnt=0;
	int sptr=0;
	for(i=0;i<20;i++)
		m_StringList[i].Empty();
	for(i=0;i<ilen;i++)
	{
		if(string[i]=='/' && i!=0 )
		{
			m_StringList[cnt]+='\0';
			sptr = 0;
			cnt++;
		}
		else
		{
			m_StringList[cnt]+=string[i];
			sptr++;
		}
	}
	if(sptr>0)
	{
		m_StringList[cnt]+='\0';
		cnt++;
	}
	return cnt;
}

char CMirSocket::GetMsgFlag()
{
	return m_msgflag;
}

int CMirSocket::hex2int(char c)
{
	if(c>='A' && c<='F')
		return(int)(c-'A'+10);
	else if(c>='a' && c<='f')
		return(int)(c-'a'+10);
	else if(c>='0' && c<='9')
		return(int)(c-'0');
	return 0;
}

char CMirSocket::int2hex(int v)
{
	char hextable[]="0123456789ABCDEF";
	v &= 0xf;
	return hextable[v];
}

char CMirSocket::ucase(char c)
{
	if(c>='a' && c<='z')
		c+='A'-'a';
	return c;
}

///////////////////////////////////////////////////////////////////////
//
// 下面的函数都是迫不得已的
//
///////////////////////////////////////////////////////////////////////


BOOL CMirSocket::Create()
{
	m_Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if(m_Socket==INVALID_SOCKET)
		return FALSE;
	return TRUE;
}

BOOL CMirSocket::Connect(LPCTSTR ip, unsigned short port)
{
	if(m_Socket==INVALID_SOCKET)
		return FALSE;

	LPHOSTENT m_pHost;
	struct	sockaddr_in ServAddr;
	int retval;

	m_pHost=gethostbyname(ip);

	ServAddr.sin_family=AF_INET;
	ServAddr.sin_addr.s_addr=*(ULONG*)m_pHost->h_addr_list[0];
	ServAddr.sin_port=htons(port);

	retval=connect(m_Socket,(struct sockaddr*)&ServAddr,sizeof(ServAddr));
	if(retval==SOCKET_ERROR)
		return FALSE;
	return TRUE;
}

void CMirSocket::Close()
{
	closesocket(m_Socket);
	m_Socket=INVALID_SOCKET;
}

int CMirSocket::Send(const void* lpBuf, int nBufLen, int nFlags)
{
	if(m_Socket!=INVALID_SOCKET)
		return send(m_Socket,(char*)lpBuf,nBufLen,nFlags);
	else
		return SOCKET_ERROR;
}

int CMirSocket::Receive(void* lpBuf, int nBufLen, int nFlags)
{
	if(m_Socket!=INVALID_SOCKET)
		return recv(m_Socket,(char*)lpBuf,nBufLen,nFlags);
	else
		return SOCKET_ERROR;
}

BOOL CMirSocket::IOCtl(long lCommand, DWORD *lpArgument)
{
	if(m_Socket==INVALID_SOCKET)
		return FALSE;
	if(ioctlsocket(m_Socket,lCommand,lpArgument)==SOCKET_ERROR)
		return FALSE;
	else
		return TRUE;
}