Byte wo sind die?

Halo Epvp ich habe mal ne frage yoshii hat gesagt das wenn der fehler kommt error while log in...dann muss man im Ah die byte ändern und die wären in buffer in der source..

Aber da ist nichts mit byte:

#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 'F' // Normal message header
#define SYSHEADERMARK 'E' // 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__

Alter du nervst langsam mit deinen Threats!!!!!!!

Schreib ihm einfach eine PN und fertig

#define HEADERMARK 'F' . Den Buchstaben in Hexadezimal umwandeln und vor dem Ergebnis ein 0x machen.


Lg
derGunga
Das sollte man aber wissen.

aha geht trotzdem ned

Quote:

Originally Posted by dergunga #define HEADERMARK 'F' . Den Buchstaben in Hexadezimal umwandeln und vor dem Ergebnis ein 0x machen. Lg derGunga Das sollte man aber wissen.

Das ist schon rcihtig so. Das sollte man aber wissen.

Mach das F zum ^ und test es nochmal.

nö geht nicht

Quote:

Originally Posted by PowerSkillz nö geht nicht

Achja.

Also hast du innerhalb 4minuten (1minuten ziehen wir ab wegen dem lesen des posts und antworten) also 3minuten die..

Solution KOMPLETT durchkompiliert.
Alle Exen ersetzt und gestartet.
Client gestartet eingeloggt und getestet.

Wenn du keine Hilfe willst geh dich begraben du bob.

Wieso helft ihr solchen überhaupt noch wenn sie nicht mal die Hilfe annehmen?

ich habs doch vorhin schon gehabt...das ging ja nicht....sollte ich da das^ oder ne 1 machen?

Quote:

Originally Posted by Joshiix3 Wieso helft ihr solchen überhaupt noch wenn sie nicht mal die Hilfe annehmen?

Haben gedacht er würde hilfe annehmen. Mir kommt es so vor wie das er nur Posts farmen will.

Bei der aussage "#define HEADERMARK 'F' . Den Buchstaben in Hexadezimal umwandeln und vor dem Ergebnis ein 0x machen." vom gunga und die Aussage "Nö geht trotzdem nicht" von ihm müsste ich eigentlich schon merken das er es garnicht gemacht hat.

Selbst ich kapier nicht ganz was uns da Gunga sagen wollte^^

doch habe ich

Dummheit sollte man manchmal wirklich bestrafen...
wenn ich dir schon helfe und du nochnichtmal alles was ich gesagt habe hier als frage stellst ist das schon mies... ein BYTE kannste zwar ändern bringt dir nicht viel...

vlt wärs gut für dich nochmal grundschule zu machen und C&P lernen...

Da der TE es geschafft hat gebannt zu werden, mach ich hier zu.
Er kann den rest doch eh nicht mehr lesen.