Register for your free account! | Forgot your password?

Go Back   elitepvpers › MMORPGs › Flyff › Flyff Private Server
Anti hack fehler ^^ Anti hack fehler ^^
You last visited: Today at 08:14

  • Please register to post and access all features, it's quick, easy and FREE!

Advertisement


Advertise with us!

Anti hack fehler ^^

Discussion on Anti hack fehler ^^ within the Flyff Private Server forum part of the Flyff category.

Reply
 
Old   #1

 
elite*gold: 353
The Black Market: 20/0/0
Join Date: Jan 2013
Posts: 924
Received Thanks: 617
Anti hack fehler ^^

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 ^^
Kiseku is offline  
Old   #2
 
Shinji-MRT's Avatar
 
elite*gold: 0
The Black Market: 0/0/0
Join Date: May 2010
Posts: 155
Received Thanks: 62
Quote:
Originally Posted by Arcitc™ View Post
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
Shinji-MRT is offline  
Old   #3

 
elite*gold: 353
The Black Market: 20/0/0
Join Date: Jan 2013
Posts: 924
Received Thanks: 617
getestet geht immer noch nicht....
Kiseku is offline  
Old   #4
 
TrøublêMakêr's Avatar
 
elite*gold: 51
The Black Market: 55/0/0
Join Date: Sep 2012
Posts: 1,141
Received Thanks: 575
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
TrøublêMakêr is offline  
Old   #5

 
elite*gold: 353
The Black Market: 20/0/0
Join Date: Jan 2013
Posts: 924
Received Thanks: 617
Quote:
Originally Posted by TrøublêMakêr View Post
Die 5000 war glaube ich irgendwas mit Shout. Hatte doch recht mit Shout.
ausprobiert geht immer noch nicht :/
Kiseku is offline  
Old   #6
ベトナム警察




 
Lumi's Avatar
 
elite*gold: 0
The Black Market: 517/0/0
Join Date: Jan 2012
Posts: 16,516
Received Thanks: 3,538
Headmarks sind falsch und die 7; und 8; sind vertauscht. Die 7; sind die Ports die in dem Config einzustellen sind.
Lumi is offline  
Old   #7

 
elite*gold: 353
The Black Market: 20/0/0
Join Date: Jan 2013
Posts: 924
Received Thanks: 617
Quote:
Originally Posted by ​Lumi View Post
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
Kiseku is offline  
Old   #8
 
elite*gold: 0
The Black Market: 9/0/0
Join Date: Jan 2014
Posts: 773
Received Thanks: 374
ich hätte heute abend kurz zeit.

mirko_ogc
Drabur is offline  
Reply

« flyff encryptor | Virtuos v19 crash =? »

Similar Threads Similar Threads
[FRAGE]Anti Cheat - Anti Hack - Keiner soll cheats benutzen können?
10/14/2010 - Metin2 Private Server - 12 Replies
Gibt es einen Tipp wie man 1) 4x Skill 2) Multi Hack 3) Disconnect 4) und was es noch so gibt ... verbieten kann auf dem server ? ich kann es mittlerweile bei 20.000 spielern nicht mehr kontrollieren ! verliere dadurch extrem viele gute spieler weil alle cheaten ! Bannen bringt nicht da sie sofort wieder neue Accouts eröffnen !



All times are GMT +2. The time now is 08:15.

elitepvpers - play less, get more - Top

Powered by vBulletin®
Copyright ©2000 - 2026, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.

Support | Contact Us | FAQ | Advertising | Privacy Policy | Terms of Service | Abuse
Copyright ©2026 elitepvpers All Rights Reserved.