Anti hack fehler ^^

Kiseku · 02/28/2014, 21:00

huhu,
habe folgendes problem unzwar wenn ich meinen server starte + anti hack kommt immer : Error While Loggin in glaube das hat mein Problem beschrieben ^^ unten sind alle einträge ^^. das ändern des headmarks hat auch nichts gebracht.
Benutze Clean Files

Einträge

Anti Hack

Code:

[connection]

; The IP of the server, which is running the cache server
server_ip="localhost"

; The port the cache server is using (CacheServer.ini), may not be same as client_port
server_port=5400

; The port the client connects to
client_port=15400

; Maximum connections per IP (0 = infinite connections allowed)
max_ip_connections=0

; Maximum amount of connection attempts of a specific IP per minute (0 = infinite)
ip_connections_per_minute=0

; The leading byte of all packets. Edit it here if you did so in the FlyFF server. Else LEAVE IT at 0x5e.
leading_byte=0x5e


; Do not change if you don't know, what you do!
max_recv=70000
max_recv_space=10000

CacheServer.ini

Code:

Core	"127.0.0.1"
Port	"5400"

buffer.h

Code:

#ifndef __BUFFER_H__
#define	__BUFFER_H__

#pragma once

#include "mempooler.h"
#include "heapmng.h"
#include <dplay.h>

#ifdef __CRC
	#include "crc.h"
	using	namespace	std;
	#define	HEADERSIZE5		( sizeof(DWORD) + 1 )
#if defined( __PACKET_REPLAY_R ) || defined( __PACKET_REPLAY_W )
	#define	HEADERSIZE13	( sizeof(char) + sizeof(int) + sizeof(DWORD) + sizeof(DWORD) + sizeof(DWORD) )
#else	// __PACKET_REPLAY_R || __PACKET_REPLAY_W
	#define	HEADERSIZE13	( sizeof(char) + sizeof(DWORD) + sizeof(DWORD) + sizeof(DWORD) )
#endif	// __PACKET_REPLAY_R || __PACKET_REPLAY_W
#endif	// __CRC

#define	HEADERMARK		'^'		// Normal message header
#define	SYSHEADERMARK	'%'		// System message header
#define	MAX_BUFFER		8192
#define	MAX_WSABUF		128

enum BUFFER_TYPE 
{
	BUFFER_TYPE_5BYTE,		// ±âÁ¸ 1 + 4¹ÙÀÌÆ® Çì´õ ¹æ½Ä 
	BUFFER_TYPE_2BYTE,		// 2¹ÙÀÌÆ® Çì´õ ¹æ½Ä 
};



///////////////////////////////////////////////////////////////////////
// CBuffer
///////////////////////////////////////////////////////////////////////

class CBuffer
{
public:
	DPID		dpid;
	u_long		cb;
	BYTE		m_lpBuf[MAX_BUFFER];
	LPBYTE		m_lpBufStart;
	LPBYTE		m_lpBufMax;
	LPBYTE		m_pHead;
	LPBYTE		m_pTail;
	CBuffer*	pNext;
	CBuffer*	pPrevious;
	DWORD		m_dwHeaderSize;

public:
//	Constructions
	CBuffer( u_long uBufSize );
	virtual	~CBuffer();

//	Operations
	int		GetSize( void );
	LPBYTE	GetWritableBuffer( int* pnBufSize );
	int		GetWritableBufferSize( void );
	LPBYTE	GetReadableBuffer( int* pnBufSize );
	int		GetReadableBufferSize( void );
	
	DWORD	GetHeaderLength()
	{
		return m_dwHeaderSize;
	}

	virtual DWORD	GetPacketSize( BYTE* ptr ) 
	{
		return *(UNALIGNED LPDWORD)(ptr + 1);
	}

	virtual void SetHeader( DWORD uDataSize )
	{
		*m_pTail					= HEADERMARK;
		m_pTail++;

		*(UNALIGNED DWORD*)m_pTail	= (DWORD)uDataSize;
		m_pTail += sizeof(DWORD);
	}

public:
	static	CHeapMng*	m_pHeapMng;
#ifndef __VM_0820
#ifndef __MEM_TRACE
	static	MemPooler<CBuffer>*	m_pPool;
	void*	operator new( size_t nSize )	{	return CBuffer::m_pPool->Alloc();	}
	void*	operator new( size_t nSize, LPCSTR lpszFileName, int nLine )	{	return CBuffer::m_pPool->Alloc();	}
	void	operator delete( void* lpMem )	{	CBuffer::m_pPool->Free( (CBuffer*)lpMem );	}
	void	operator delete( void* lpMem, LPCSTR lpszFileName, int nLine )	{	CBuffer::m_pPool->Free( (CBuffer*)lpMem );	}
#endif	// __MEM_TRACE
#endif	// __VM_0820
};


inline int CBuffer::GetSize( void )
{	
	return (int)( m_lpBufMax - m_lpBufStart );	
}

inline LPBYTE CBuffer::GetWritableBuffer( int* pnBufSize )
{	
	*pnBufSize	= (int)( m_lpBufMax - m_pTail );	
	return m_pTail;	
}

inline int CBuffer::GetWritableBufferSize( void )
{	
	return (int)( m_lpBufMax - m_pTail );	
}

inline LPBYTE CBuffer::GetReadableBuffer( int* pnBufSize )
{	
	*pnBufSize	= (int)( m_pTail - m_pHead );	
	return m_pHead;	
}

inline int CBuffer::GetReadableBufferSize( void )
{	
	return (int)( m_pTail - m_pHead );	
}

///////////////////////////////////////////////////////////////////////
// CBuffer2
///////////////////////////////////////////////////////////////////////

class CBuffer2 : public CBuffer
{
public:
	CBuffer2( u_long uBufSize ) : CBuffer( uBufSize ) 
	{
		m_dwHeaderSize = 2;
	}

	virtual DWORD	GetPacketSize( BYTE* ptr ) 
	{
//		DWORD dwSize = *(WORD *)ptr;
//		dwSize -= 2;
//		return dwSize;
		DWORD dwSize = ntohs( *(WORD *)ptr );
		dwSize -= 2;
		return dwSize;
	}

	virtual void SetHeader( DWORD uDataSize )
	{
//		*(UNALIGNED WORD*)m_pTail	= (WORD)(uDataSize + 2);
//		m_pTail += sizeof(WORD);
		*(UNALIGNED WORD*)m_pTail	= htons( (WORD)(uDataSize + 2) );
		m_pTail += sizeof(WORD);
	}

#ifndef __VM_0820
#ifndef __MEM_TRACE
	static	MemPooler<CBuffer2>*	m_pPool2;
	void*	operator new( size_t nSize )	{	return CBuffer2::m_pPool2->Alloc();	}
	void*	operator new( size_t nSize, LPCSTR lpszFileName, int nLine )	{	return CBuffer2::m_pPool2->Alloc();	}
	void	operator delete( void* lpMem )	{	CBuffer2::m_pPool2->Free( (CBuffer2*)lpMem );	}
	void	operator delete( void* lpMem, LPCSTR lpszFileName, int nLine )	{	CBuffer2::m_pPool2->Free( (CBuffer2*)lpMem );	}
#endif	// __MEM_TRACE
#endif	// __VM_0820
};

///////////////////////////////////////////////////////////////////////
// CBufferQueue
///////////////////////////////////////////////////////////////////////

class CBufferQueue
{
private:
	CBuffer*	m_pHead;
	CBuffer*	m_pTail;
	u_long	m_uCount;
public:
	CMclCritSec		m_cs;
#ifdef __CRC
	CRC32*	m_pcrc;
	DWORD	m_dwWriteHeaderSize;
#endif	// __CRC

#ifdef __PROTOCOL0910
	DWORD*	m_pdwProtocolId;
#endif	// __PROTOCOL0910

public:
//	Constructions
	CBufferQueue();
	virtual	~CBufferQueue();
//	Operations
	void	AddTail( CBuffer* pBuffer );
	void	RemoveHead( void );
	CBuffer*	GetHead( void );
	CBuffer*	GetTail( void );
	void	Clear( BOOL bDelete );
	BOOL	IsEmpty( void );
	u_long	GetCount( void );
	void	AddData( LPBYTE lpData, u_long uDataSize, BUFFER_TYPE type );
	void	GetData( LPWSABUF lpBuffers, LPDWORD lpdwBufferCount );
	void	RemoveData( u_long uDataSize );
#ifdef __CRC
#ifdef __PROTOCOL0910
	void	crc( CRC32* pcrc, LPDWORD pdwProtocolId )	{	m_pcrc	= pcrc;		m_pdwProtocolId	= pdwProtocolId;	m_dwWriteHeaderSize		= HEADERSIZE13;	}
#else	// __PROTOCOL0910
	void	crc( CRC32* pcrc )	{	m_pcrc	= pcrc;		m_dwWriteHeaderSize		= HEADERSIZE13;	}
#endif	// __PROTOCOL0910
#endif	// __CRC

#ifdef __PACKET_REPLAY_W
private:
	int		m_nPacket;
#endif	// __PACKET_REPLAY_W
};

inline CBuffer* CBufferQueue::GetHead( void )
	{	return m_pHead;	}
inline CBuffer* CBufferQueue::GetTail( void )
	{	return m_pTail;	}
inline u_long CBufferQueue::GetCount( void )
	{	return m_uCount;	}
inline BOOL CBufferQueue::IsEmpty( void )
	{	return( m_uCount == 0 );	}
inline void CBufferQueue::AddTail( CBuffer* pBuffer )
{	
	CMclAutoLock	Lock( m_cs );
//	Add it to the active list	
	if( !m_pHead )
		m_pHead		= pBuffer;
	if( m_pTail )
		m_pTail->pNext	= pBuffer;
	pBuffer->pPrevious	= m_pTail;
	pBuffer->pNext	= NULL;
	m_pTail		= pBuffer;
	m_uCount++;
}
inline void CBufferQueue::RemoveHead( void )
{
//	CMclAutoLock	Lock( m_cs );
//	Remove it from active list
	if( !IsEmpty() )
	{
		if( m_pTail == m_pHead )
			m_pTail	= NULL;
		if( m_pHead->pNext )
			m_pHead->pNext->pPrevious	= NULL;
		m_pHead		= m_pHead->pNext;
	}
	m_uCount--;
}


///////////////////////////////////////////////////////////////////////
// CBufferFactory
///////////////////////////////////////////////////////////////////////

class CBufferFactory
{
public:
	CBuffer* CreateBuffer( BUFFER_TYPE type, u_long uBufSize = MAX_BUFFER );
	static CBufferFactory& GetInstance();

private:
	CBufferFactory();
};

#endif	// __BUFFER_H__

Buffer.h²

Code:

#ifndef __BUFFER_H__
#define	__BUFFER_H__

#pragma once

//#include "mempool.h"
#include "mempooler.h"
#include "heapmng.h"
#include <dplay.h>

#include "crc.h"

#define	HEADERMARK		'^'		// Normal message header
#define	SYSHEADERMARK	'%'		// System message header

#define	MAX_BUFFER	8192
#define	MAX_WSABUF	128

template <class>
class CDPMng;

class CBuffer
{
public:
	DPID	dpid;
	u_long	cb;
	BYTE	m_lpBuf[MAX_BUFFER];
	LPBYTE	m_lpBufStart;
	LPBYTE	m_lpBufMax;
	LPBYTE	m_pHead;
	LPBYTE	m_pTail;
	CBuffer*	pNext;
	CBuffer*	pPrevious;
	CRC32*	m_pcrc;

public:
//	Constructions
	CBuffer( u_long uBufSize = MAX_BUFFER );
	virtual	~CBuffer();
//	Operations
	int		GetSize( void );
	LPBYTE	GetWritableBuffer( int* pnBufSize );
	int		GetWritableBufferSize( void );
	LPBYTE	GetReadableBuffer( int* pnBufSize );
	int		GetReadableBufferSize( void );

	void	crc( CRC32* pcrc )	{	m_pcrc	= pcrc;		}
	void	MessageHandler( CDPMng<CBuffer>* pDPMng, DPID dpidFrom );
	CBuffer*	Fetch( CBuffer** ppRecvBuffer, DWORD dwBytes, CRC32* pcrc );
	virtual	void	AddSysMsg( void* pMsg, u_long uMsgSize );
	static	u_long	GetHdrSize( BOOL bcrc )
		{	if( bcrc )
				return 13;
			return 5;	// sizeof(char) + sizeof(DWORD)
		}
	virtual	void	AddHdr( LPBYTE lpData, u_long uDataSize );
	virtual	void	AddData( LPBYTE lpData, u_long uDataSize, u_long & uRemnant );
	
public:
static	\
CHeapMng*	m_pHeapMng;

static	\
BOOL	IsHeader( BYTE cHeader );

#ifndef __VM_0820
#ifndef __MEM_TRACE
static	\
//CMemPool<CBuffer>*	m_pPool;
MemPooler<CBuffer>*	m_pPool;
void*	operator new( size_t nSize )	{	return CBuffer::m_pPool->Alloc();	}
void*	operator new( size_t nSize, LPCSTR lpszFileName, int nLine )	{	return CBuffer::m_pPool->Alloc();	}
void	operator delete( void* lpMem )	{	CBuffer::m_pPool->Free( (CBuffer*)lpMem );	}
void	operator delete( void* lpMem, LPCSTR lpszFileName, int nLine )	{	CBuffer::m_pPool->Free( (CBuffer*)lpMem );	}
#endif	// __MEM_TRACE
#endif	// __VM_0820
};
inline int CBuffer::GetSize( void )
	{	return (int)( m_lpBufMax - m_lpBufStart );	}
inline LPBYTE CBuffer::GetWritableBuffer( int* pnBufSize )
	{	*pnBufSize	= (int)( m_lpBufMax - m_pTail );	return m_pTail;	}
inline int CBuffer::GetWritableBufferSize( void )
	{	return (int)( m_lpBufMax - m_pTail );	}
inline LPBYTE CBuffer::GetReadableBuffer( int* pnBufSize )
	{	*pnBufSize	= (int)( m_pTail - m_pHead );	return m_pHead;	}
inline int CBuffer::GetReadableBufferSize( void )
	{	return (int)( m_pTail - m_pHead );	}
inline BOOL CBuffer::IsHeader( BYTE cHeader )
	{	return ( cHeader == HEADERMARK || cHeader == SYSHEADERMARK );	}

/*--------------------------------------------------------------------------------*/
class CBuffer2 : public CBuffer
{
public:
	CBuffer2( u_long uBufSize = MAX_BUFFER ) : CBuffer( uBufSize )	{}
	virtual	~CBuffer2()	{}

	void	MessageHandler( CDPMng<CBuffer2>* pDPMng, DPID dpidFrom );
	CBuffer2*	Fetch( CBuffer2** ppRecvBuffer, DWORD dwBytes, CRC32* pcrc  );
	virtual	void	AddSysMsg( void* pMsg, u_long uMsgSize );
	static	u_long	GetHdrSize( BOOL bcrc )
		{	if( bcrc )
				return 10;
			return 2;
		}
	virtual	void	AddHdr( LPBYTE lpData, u_long uDataSize );

public:

static	\
CHeapMng*	m_pHeapMng;

#ifndef __VM_0820
#ifndef __MEM_TRACE
static	\
//CMemPool<CBuffer>*	m_pPool;
MemPooler<CBuffer2>*	m_pPool2;
void*	operator new( size_t nSize )	{	return CBuffer2::m_pPool2->Alloc();	}
void*	operator new( size_t nSize, LPCSTR lpszFileName, int nLine )	{	return CBuffer2::m_pPool2->Alloc();	}
void	operator delete( void* lpMem )	{	CBuffer2::m_pPool2->Free( (CBuffer2*)lpMem );	}
void	operator delete( void* lpMem, LPCSTR lpszFileName, int nLine )	{	CBuffer2::m_pPool2->Free( (CBuffer2*)lpMem );	}
#endif	// __MEM_TRACE
#endif	// __VM_0820
};
/*--------------------------------------------------------------------------------*/

class CBuffer3 : public CBuffer
{
public:
	CBuffer3( u_long uBufSize = MAX_BUFFER ) : CBuffer( uBufSize )	{}
	virtual	~CBuffer3()	{}

	void	MessageHandler( CDPMng<CBuffer3>* pDPMng, DPID dpidFrom );
	CBuffer3*	Fetch( CBuffer3** ppRecvBuffer, DWORD dwBytes, CRC32* pcrc  );
	virtual	void	AddSysMsg( void* pMsg, u_long uMsgSize );
	static	u_long	GetHdrSize( BOOL bcrc )
		{	if( bcrc )
				return 10;
			return 2;
		}
	virtual	void	AddHdr( LPBYTE lpData, u_long uDataSize );

public:

static	\
CHeapMng*	m_pHeapMng;

#ifndef __VM_0820
#ifndef __MEM_TRACE
static	\
//CMemPool<CBuffer>*	m_pPool;
MemPooler<CBuffer3>*	m_pPool2;
void*	operator new( size_t nSize )	{	return CBuffer3::m_pPool2->Alloc();	}
void*	operator new( size_t nSize, LPCSTR lpszFileName, int nLine )	{	return CBuffer3::m_pPool2->Alloc();	}
void	operator delete( void* lpMem )	{	CBuffer3::m_pPool2->Free( (CBuffer3*)lpMem );	}
void	operator delete( void* lpMem, LPCSTR lpszFileName, int nLine )	{	CBuffer3::m_pPool2->Free( (CBuffer3*)lpMem );	}
#endif	// __MEM_TRACE
#endif	// __VM_0820
};
/*--------------------------------------------------------------------------------*/

template <class T>
class CBufferQueue
{
private:
	T*	m_pHead;
	T*	m_pTail;
	u_long	m_uCount;
public:
	CMclCritSec		m_cs;
	CRC32*	m_pcrc;
public:
//	Constructions
	CBufferQueue();
	virtual	~CBufferQueue();
//	Operations
	void	AddTail( T* pBuffer );
	void	RemoveHead( void );
	T*	GetHead( void );
	T*	GetTail( void );
	void	Clear( BOOL bDelete );
	BOOL	IsEmpty( void );
	u_long	GetCount( void );
	void	AddData( LPBYTE lpData, u_long uDataSize );
	void	GetData( LPWSABUF lpBuffers, LPDWORD lpdwBufferCount );
	void	RemoveData( u_long uDataSize );
	void	crc( CRC32* pcrc )	{	m_pcrc	= pcrc;		}
};

template <class T>
inline T* CBufferQueue<T>::GetHead( void )
	{	return m_pHead;	}

template <class T>
inline T* CBufferQueue<T>::GetTail( void )
	{	return m_pTail;	}

template <class T>
inline u_long CBufferQueue<T>::GetCount( void )
	{	return m_uCount;	}

template <class T>
inline BOOL CBufferQueue<T>::IsEmpty( void )
	{	return( m_uCount == 0 );	}

template <class T>
inline void CBufferQueue<T>::AddTail( T* pBuffer )
	{
		CMclAutoLock	Lock( m_cs );
	//	Add it to the active list	
		if( !m_pHead )
			m_pHead		= pBuffer;
		if( m_pTail )
			m_pTail->pNext	= pBuffer;
		pBuffer->pPrevious	= m_pTail;
		pBuffer->pNext	= NULL;
		m_pTail		= pBuffer;
		m_uCount++;
	}

template <class T>
inline void CBufferQueue<T>::RemoveHead( void )
	{
	//	CMclAutoLock	Lock( m_cs );
	//	Remove it from active list
		if( !IsEmpty() )
		{
			if( m_pTail == m_pHead )
				m_pTail	= NULL;
			if( m_pHead->pNext )
				m_pHead->pNext->pPrevious	= NULL;
			m_pHead		= (T*)m_pHead->pNext;
		}
		m_uCount--;
	}

template <class T>
CBufferQueue<T>::CBufferQueue()
	{
		m_uCount	= 0;
		m_pHead		= m_pTail	= NULL;
		m_pcrc	= NULL;
	}

template <class T>
CBufferQueue<T>::~CBufferQueue()
	{
		Clear( TRUE );
	}

template <class T>
void CBufferQueue<T>::Clear( BOOL bDelete )
	{
		CMclAutoLock	Lock( m_cs );

		if( bDelete )
		{
			T* pBuffer	= GetHead(), *ptrtmp;
			while( pBuffer )
			{
				ptrtmp	= (T*)pBuffer->pNext;
				SAFE_DELETE( pBuffer );
				pBuffer	= ptrtmp;
			}
		}
		m_uCount	= 0;
		m_pHead	= m_pTail	= NULL;
	}

template <class T>
void CBufferQueue<T>::AddData( LPBYTE lpData, u_long uDataSize )
	{
	//	CMclAutoLock	Lock( m_cs );
		u_long	uRemnant	= uDataSize;
		T* pBuffer	= GetTail();
	//	LPBYTE ptr;
		DWORD cb;

		if( pBuffer )
		{
			cb	= pBuffer->GetWritableBufferSize();
			if( cb < T::GetHdrSize( (BOOL)m_pcrc ) )
			{
				pBuffer	= new T;
				pBuffer->crc( m_pcrc );

				AddTail( pBuffer );
			}
		}
		else
		{
			pBuffer	= new T;
			pBuffer->crc( m_pcrc );

			AddTail( pBuffer );
		}
	/*
		ptr	= pBuffer->GetWritableBuffer( &cb );
	//	header
		*ptr	= HEADERMARK;
	//	ptr++;
	//	*(UNALIGNED DWORD*)ptr	= (DWORD)uDataSize;
	//	ptr	+= sizeof(DWORD);
	//	cb	= ( cb-HEADERSIZE < uRemnant? cb-HEADERSIZE: uRemnant );
	////	data
	//	ASSERT( ptr + cb <= pBuffer->m_lpBufMax );
	//	memcpy( (void*)ptr, lpData, cb );
	//	pBuffer->m_pTail	= ptr + cb;
	//	uRemnant	-= cb;

		if( m_pcrc )
		{
			BYTE digest[sizeof(DWORD)];
			m_pcrc->Restart();
			m_pcrc->Update( (const byte*)( &uDataSize ), sizeof(u_long) );
			m_pcrc->Final( digest );
			*(UNALIGNED DWORD*)( ptr + sizeof(char) )	= *(UNALIGNED DWORD*)digest;
			*(UNALIGNED DWORD*)( ptr + sizeof(char) + sizeof(DWORD) )	= (DWORD)uDataSize;
			m_pcrc->Restart();
			m_pcrc->Update( (const byte*)( lpData ), (u_int)uDataSize );
			m_pcrc->Final( digest );
			*(UNALIGNED DWORD*)( ptr + sizeof(char) +sizeof(DWORD) + sizeof(DWORD) )	= *(UNALIGNED DWORD*)digest;
		}
		else
		{
			*(UNALIGNED DWORD*)&ptr[1]	= (DWORD)uDataSize;
		}
	*/
		pBuffer->AddHdr( lpData, uDataSize );
		pBuffer->AddData( lpData, uDataSize, uRemnant );
		while( uRemnant > 0 )
		{
			pBuffer	= new T;
			pBuffer->crc( m_pcrc );

			pBuffer->AddData( lpData, uDataSize, uRemnant );
			AddTail( pBuffer );
		}
	/*
	//	data
		cb	= ( cb-m_dwWriteHeaderSize < uRemnant? cb-m_dwWriteHeaderSize: uRemnant );
		ASSERT( &ptr[m_dwWriteHeaderSize] + cb <= pBuffer->m_lpBufMax );
		memcpy( (void*)&ptr[m_dwWriteHeaderSize], lpData, cb );
		pBuffer->m_pTail	= ptr + m_dwWriteHeaderSize + cb;

		uRemnant	-= cb;

		while( uRemnant > 0 )
		{
			pBuffer	= new CBuffer;
			ptr	= pBuffer->GetWritableBuffer( &cb );
			cb	= ( cb < uRemnant? cb: uRemnant );
			ASSERT( ptr + cb <= pBuffer->m_lpBufMax );
			memcpy( (void*)ptr, &lpData[uDataSize - uRemnant], cb );
			pBuffer->m_pTail	= ptr + cb;
			AddTail( pBuffer );
			uRemnant	-= cb;
		}
	*/
	}

template <class T>
void CBufferQueue<T>::RemoveData( u_long uDataSize )
	{
		T* pBuffer;
		
	//	CMclAutoLock	Lock( m_cs );
		u_long uRemnant;
		while( uDataSize > 0 )
		{
			pBuffer	= GetHead();
	//		ASSERT( pBuffer );
			if( NULL == pBuffer )
				return;

			uRemnant	= pBuffer->GetReadableBufferSize();
			if( uRemnant > uDataSize )
			{
				pBuffer->m_pHead	+= uDataSize;
				uDataSize	= 0;
			}
			else
			{
				RemoveHead();
	//			SAFE_DELETE( pBuffer );
				safe_delete( pBuffer );
				uDataSize	-= uRemnant;
			}
		}
	}

template <class T>
void CBufferQueue<T>::GetData( LPWSABUF lpBuffers, LPDWORD lpdwBufferCount )
	{
		T* pBuffer;
		int	i	= 0;
	//	*lpdwBufferCount	= 0;
	//	CMclAutoLock	Lock( m_cs );	
		pBuffer	= GetHead();
		while( pBuffer && i < MAX_WSABUF )
		{
			lpBuffers[i].buf	= (char*)pBuffer->GetReadableBuffer( (int*)&lpBuffers[i].len );
			i++;
			pBuffer	= (T*)pBuffer->pNext;
		}
		*lpdwBufferCount	= i;
	}

#endif	// __BUFFER_H__

und Neuz :

Code:

STRINGTABLE
LANGUAGE LANG_KOREAN, 0x1
{
1, 	"127.0.0.1"
2, 	"1"
3, 	"0"
4, 	"1"
5, 	"1"
6, 	"20140101"
7, 	"5400"                    // WEnn man das auf 15400 macht gehts auch nicht ^^
8, 	"15400"                  // wenn man das auch 5400 macht gehts auch nicht ^^
9, 	"5"
10, 	"1252"
11, 	"0"
}

so das wars hoffe ihr könnt mir i-wie helfen ^^

Shinji-MRT · 02/28/2014, 21:17

Quote:

Originally Posted by Arcitc™

huhu,

Anti Hack

Code:

[connection]

; The IP of the server, which is running the cache server
server_ip="localhost"

und Neuz :

Code:

6, 	"20140101"
7, 	"5400"                    // WEnn man das auf 15400 macht gehts auch nicht ^^
8, 	"15400"                  // wenn man das auch 5400 macht gehts auch

Die 5400 und 15400 in der Neuz sind hier Vertrauscht ich weiß net genau was die 5400 ist sorry aber bei steht ne 5000 drinne.

änder mal das localhost zu 127.0.0.1 (ja ists selbe aber hilft oftmals...)

Normal sollte es laufen sobald du die vertauscht hast, sonst rate ich dir komplett andere Ports zu nehmen ... bsp 21337. Acuh wenn es vllt sinnfrei klingt versuche mal danach deine Firewall auszumachen und zu connecten.

Mfg Shinji

Kiseku · 02/28/2014, 22:28

getestet geht immer noch nicht....

TrøublêMakêr · 03/01/2014, 02:25

Die 5000 war glaube ich irgendwas mit Shout. Hatte doch recht mit Shout.

Quote:

BEGIN
IDS_SERVER_IP "root/lokal IP"
IDS_LANG "1"
IDS_SUBLANG "0"
IDS_ENCRYPTPWD "1"
IDS_FAKEFULLMODE "1"
IDS_MSGVER "AquaFlyff" // je nachdem was bei dir in den .ini steht.
IDS_CACHE_PORT "15400"
IDS_SHOUTLIMIT_SECOND "5000"
IDS_SHOUTLIMIT_COUNT "5"
IDS_CODEPAGE "1252"
IDS_2ND_PASSWORD "0"
END

Kiseku · 03/01/2014, 18:13

Quote:

Originally Posted by TrøublêMakêr

Die 5000 war glaube ich irgendwas mit Shout. Hatte doch recht mit Shout.

ausprobiert geht immer noch nicht :/

Lumi · 03/01/2014, 19:25

Headmarks sind falsch und die 7; und 8; sind vertauscht. Die 7; sind die Ports die in dem Config einzustellen sind.

Kiseku · 03/01/2014, 23:33

Quote:

Originally Posted by Lumi

Headmarks sind falsch und die 7; und 8; sind vertauscht. Die 7; sind die Ports die in dem Config einzustellen sind.

geht auch nicht

kann wer vill per TV schauen ? skype könnt ihr mich adden

Drabur · 03/02/2014, 09:45

ich hätte heute abend kurz zeit.

mirko_ogc