Çözüldü Client Debug - Assertion Failed !

Defacer35 · 12 Haziran 2020

Merhabalar, client src dosyalarımı uzun zamandır debug formatında build ederek kullanıyorum bu hata en başından beridir mevcut fakat normalde yoksay deyip devam edebiliyordum artık yoksay desemde uygulama ( Oyun .exe dosyası ) kapanıyor, sebebi nedir ? Yardımcı olursanız çok sevinirim.

Reached · 12 Haziran 2020

dediği konumdaki dosyayı yükler misin izo.cpp'yi

Whistle · 12 Haziran 2020

Bu hata çok ilginç. Altyapı files hazırlama rehberinde clienti vs19 ile build edebilmek için extern dosyalarını güncellemiştim. Bu sayede bu hatadan da kurtuldum. lzo'yu güncellemeyi deneyebilirsiniz.

Defacer35 · 12 Haziran 2020

Reached demiş ki:
dediği konumdaki dosyayı yükler misin izo.cpp'yi

C++:

#include "StdAfx.h"
#include <stdlib.h>
#include <lzo/lzoLibLink.h>

#include "lzo.h"
#include "tea.h"
#include "debug.h"

#define dbg_printf

static class LZOFreeMemoryMgr
{
public:
    enum
    {
        REUSING_CAPACITY = 64*1024,
    };
public:
    ~LZOFreeMemoryMgr()
    {
        std::vector<BYTE*>::iterator i;
        for (i = m_freeVector.begin(); i != m_freeVector.end(); ++i)
            delete *i;

        m_freeVector.clear();
    }
    BYTE* Alloc(unsigned capacity)
    {
        assert(capacity > 0);
        if (capacity < REUSING_CAPACITY)
        {
            if (!m_freeVector.empty())
            {
                BYTE* freeMem = m_freeVector.back();
                m_freeVector.pop_back();

                dbg_printf("lzo.reuse_alloc\t%p(%d) free\n", freeMem, capacity);
                return freeMem;
            }
            BYTE* newMem = new BYTE[REUSING_CAPACITY];
            dbg_printf("lzo.reuse_alloc\t%p(%d) real\n", newMem, capacity);
            return newMem;
        }
        BYTE* newMem = new BYTE[capacity];
        dbg_printf("lzo.real_alloc\t%p(%d)\n", newMem, capacity);
        return newMem;
    }
    void Free(BYTE* ptr, unsigned capacity)
    {
        assert(ptr != NULL);
        assert(capacity > 0);
        if (capacity < REUSING_CAPACITY)
        {
            dbg_printf("lzo.reuse_free\t%p(%d)\n", ptr, capacity);
            m_freeVector.push_back(ptr);
            return;
        }

        dbg_printf("lzo.real_free\t%p(%d)\n", ptr, capacity);
        delete [] ptr;
    }
private:
    std::vector<BYTE*> m_freeVector;
} gs_freeMemMgr;



DWORD CLZObject::ms_dwFourCC = MAKEFOURCC('M', 'C', 'O', 'Z');

CLZObject::CLZObject()
{
    Initialize();
}

void CLZObject::Initialize()
{
    m_bInBuffer = false;
    m_pbBuffer = NULL;
    m_dwBufferSize = 0;

    m_pHeader = NULL;
    m_pbIn = NULL;
    m_bCompressed = false;
}

void CLZObject::Clear()
{
    if (m_pbBuffer && !m_bInBuffer)
        gs_freeMemMgr.Free(m_pbBuffer, m_dwBufferSize);
   
    if (m_dwBufferSize > 0)
    {
        dbg_printf("lzo.free %d\n", m_dwBufferSize);
    }

    Initialize();
}

CLZObject::~CLZObject()
{
    Clear();
}

DWORD CLZObject::GetSize()
{
    assert(m_pHeader);

    if (m_bCompressed)
    {
        if (m_pHeader->dwEncryptSize)
            return sizeof(THeader) + sizeof(DWORD) + m_pHeader->dwEncryptSize;
        else
            return sizeof(THeader) + sizeof(DWORD) + m_pHeader->dwCompressedSize;
    }
    else
        return m_pHeader->dwRealSize;
}

void CLZObject::BeginCompress(const void * pvIn, UINT uiInLen)
{
    m_pbIn = (const BYTE *) pvIn;

    m_dwBufferSize = sizeof(THeader) + sizeof(DWORD) + (uiInLen + uiInLen / 64 + 16 + 3) + 8;
   
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, m_dwBufferSize);

    m_pHeader = (THeader *) m_pbBuffer;
    m_pHeader->dwFourCC = ms_dwFourCC;
    m_pHeader->dwEncryptSize = m_pHeader->dwCompressedSize = m_pHeader->dwRealSize = 0;
    m_pHeader->dwRealSize = uiInLen;
}

void CLZObject::BeginCompressInBuffer(const void * pvIn, UINT uiInLen, void * /*pvOut*/)
{
    m_pbIn = (const BYTE *) pvIn;

    m_dwBufferSize = sizeof(THeader) + sizeof(DWORD) + (uiInLen + uiInLen / 64 + 16 + 3) + 8;

    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, m_dwBufferSize);

    m_pHeader = (THeader *) m_pbBuffer;
    m_pHeader->dwFourCC = ms_dwFourCC;
    m_pHeader->dwEncryptSize = m_pHeader->dwCompressedSize = m_pHeader->dwRealSize = 0;
    m_pHeader->dwRealSize = uiInLen;
    m_bInBuffer = true;
}

bool CLZObject::Compress()
{
    UINT    iOutLen;
    BYTE *    pbBuffer;

    pbBuffer = m_pbBuffer + sizeof(THeader);
    *(DWORD *) pbBuffer = ms_dwFourCC;
    pbBuffer += sizeof(DWORD);

#if defined( LZO1X_999_MEM_COMPRESS )
    int r = lzo1x_999_compress((BYTE *) m_pbIn, m_pHeader->dwRealSize, pbBuffer, (lzo_uint*) &iOutLen, CLZO::Instance().GetWorkMemory());
#else
    int r = lzo1x_1_compress((BYTE *) m_pbIn, m_pHeader->dwRealSize, pbBuffer, (lzo_uint*) &iOutLen, CLZO::Instance().GetWorkMemory());
#endif

    if (LZO_E_OK != r)
    {
        TraceError("LZO: lzo1x_999_compress failed");
        return false;
    }

    m_pHeader->dwCompressedSize = iOutLen;
    m_bCompressed = true;
    return true;
}

bool CLZObject::BeginDecompress(const void * pvIn)
{
    THeader * pHeader = (THeader *) pvIn;

    if (pHeader->dwFourCC != ms_dwFourCC)
    {
        TraceError("LZObject: not a valid data");
        return false;
    }

    m_pHeader    = pHeader;
    m_pbIn    = (const BYTE *) pvIn + (sizeof(THeader) + sizeof(DWORD));

    /*
    static unsigned sum = 0;
    static unsigned count = 0;
    sum += pHeader->dwRealSize;
    count++;
    printf("decompress cur: %d, ave: %d\n", pHeader->dwRealSize, sum/count);
    */
    m_dwBufferSize = pHeader->dwRealSize;
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, pHeader->dwRealSize);
    return true;
}

class DecryptBuffer
{
public:
    enum
    {
        LOCAL_BUF_SIZE = 8 * 1024,
    };
public:
    DecryptBuffer(unsigned size)
    {
        static unsigned count = 0;
        static unsigned sum = 0;
        static unsigned maxSize = 0;

        sum += size;
        count++;

        maxSize = max(size, maxSize);
        if (size >= LOCAL_BUF_SIZE)
        {
            m_buf = new char[size];
            dbg_printf("DecryptBuffer - AllocHeap %d max(%d) ave(%d)\n", size, maxSize/1024, sum/count);
        }
        else
        {
            dbg_printf("DecryptBuffer - AllocStack %d max(%d) ave(%d)\n", size, maxSize/1024, sum/count);
            m_buf = m_local_buf;
        }
    }
    ~DecryptBuffer()
    {
        if (m_local_buf != m_buf)
        {
            dbg_printf("DecruptBuffer - FreeHeap\n");
            delete [] m_buf;
        }
        else
        {
            dbg_printf("DecruptBuffer - FreeStack\n");
        }
    }
    void* GetBufferPtr()
    {
        return m_buf;
    }

private:
    char*    m_buf;
    char    m_local_buf[LOCAL_BUF_SIZE];
};

bool CLZObject::Decompress(DWORD * pdwKey)
{
    UINT uiSize;
    int r;

    if (m_pHeader->dwEncryptSize)
    {
        DecryptBuffer buf(m_pHeader->dwEncryptSize);

        BYTE* pbDecryptedBuffer = (BYTE*)buf.GetBufferPtr();
           
        __Decrypt(pdwKey, pbDecryptedBuffer);
       
        if (*(DWORD *) pbDecryptedBuffer != ms_dwFourCC)
        {
            TraceError("LZObject: key incorrect");
            return false;
        }
       
        if (LZO_E_OK != (r = lzo1x_decompress(pbDecryptedBuffer + sizeof(DWORD), m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        {
            TraceError("LZObject: Decompress failed(decrypt) ret %d\n", r);
            return false;
        }
    }
    else
    {
        uiSize = m_pHeader->dwRealSize;
       
        //if (LZO_E_OK != (r = lzo1x_decompress_safe(m_pbIn, m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        if (LZO_E_OK != (r = lzo1x_decompress(m_pbIn, m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        {
            TraceError("LZObject: Decompress failed : ret %d, CompressedSize %d\n", r, m_pHeader->dwCompressedSize);
            return false;
        }
    }

    if (uiSize != m_pHeader->dwRealSize)
    {
        TraceError("LZObject: Size differs");
        return false;
    }

    return true;
}

bool CLZObject::Encrypt(DWORD * pdwKey)
{
    if (!m_bCompressed)
    {
        assert(!"not compressed yet");
        return false;
    }

    BYTE * pbBuffer = m_pbBuffer + sizeof(THeader);
    m_pHeader->dwEncryptSize = tea_encrypt((DWORD *) pbBuffer, (const DWORD *) pbBuffer, pdwKey, m_pHeader->dwCompressedSize + 19);
    return true;
}

bool CLZObject::__Decrypt(DWORD * key, BYTE* data)
{
    assert(m_pbBuffer);

    tea_decrypt((DWORD *) data, (const DWORD *) (m_pbIn - sizeof(DWORD)), key, m_pHeader->dwEncryptSize);
    return true;
}

void CLZObject::AllocBuffer(DWORD dwSrcSize)
{
    if (m_pbBuffer && !m_bInBuffer)
        gs_freeMemMgr.Free(m_pbBuffer, m_dwBufferSize);

    m_pbBuffer = gs_freeMemMgr.Alloc(dwSrcSize);
    m_dwBufferSize = dwSrcSize;
}
/*
void CLZObject::CopyBuffer(const char* pbSrc, DWORD dwSrcSize)
{
    AllocBuffer(dwSrcSize);
    memcpy(m_pbBuffer, pbSrc, dwSrcSize);
}
*/

CLZO::CLZO() : m_pWorkMem(NULL)
{
    if (lzo_init() != LZO_E_OK)
    {
        TraceError("LZO: cannot initialize");
        return;
    }

#if defined( LZO1X_999_MEM_COMPRESS )
    m_pWorkMem = (BYTE *) malloc(LZO1X_999_MEM_COMPRESS);
#else
    m_pWorkMem = (BYTE *) malloc(LZO1X_1_MEM_COMPRESS);
#endif

    if (NULL == m_pWorkMem)
    {
        TraceError("LZO: cannot alloc memory");
        return;
    }
}

CLZO::~CLZO()
{
    if (m_pWorkMem)
    {
        free(m_pWorkMem);
        m_pWorkMem = NULL;
    }
}

bool CLZO::CompressMemory(CLZObject & rObj, const void * pIn, UINT uiInLen)
{
    rObj.BeginCompress(pIn, uiInLen);
    return rObj.Compress();
}

bool CLZO::CompressEncryptedMemory(CLZObject & rObj, const void * pIn, UINT uiInLen, DWORD * pdwKey)
{
    rObj.BeginCompress(pIn, uiInLen);
   
    if (rObj.Compress())
    {
        if (rObj.Encrypt(pdwKey))
            return true;
       
        return false;
    }

    return false;
}

bool CLZO::Decompress(CLZObject & rObj, const BYTE * pbBuf, DWORD * pdwKey)
{
    if (!rObj.BeginDecompress(pbBuf))
        return false;

    if (!rObj.Decompress(pdwKey))
        return false;

    return true;
}


BYTE * CLZO::GetWorkMemory()
{
    return m_pWorkMem;
}

Whistle demiş ki:
Bu hata çok ilginç. Altyapı files hazırlama rehberinde clienti vs19 ile build edebilmek için extern dosyalarını güncellemiştim. Bu sayede bu hatadan da kurtuldum. lzo'yu güncellemeyi deneyebilirsiniz.

Ben ilk önce 2008'de sonra 2013'de en son olarakta 2019'da build ettim yani hepsini kullandım fakat bu hata en başından beri mevcut.Şuan 2019 vs kullanıyorum, lzo 2.10 kullanıyorum 2.03'ken de aynıdı 10 a yükselttim hala aynı maalesef.

Whistle · 12 Haziran 2020

Defacer35 demiş ki:
Ben ilk önce 2008'de sonra 2013'de en son olarakta 2019'da build ettim yani hepsini kullandım fakat bu hata en başından beri mevcut.Şuan 2019 vs kullanıyorum, lzo 2.10 kullanıyorum 2.03'ken de aynıdı 10 a yükselttim hala aynı maalesef.

Çok ilginç. Metin2 Sıfırdan Altyapı Server Files Hazırlama Rehberi ni hazırlarken novaline clienti vs19'da build etmek için extern güncellemesi ve kodlarda düzenlemeler yapmıştım. Bu hatada kendiliğinden kaybolmuştu.

Defacer35 · 13 Haziran 2020

Whistle demiş ki:
Çok ilginç. Metin2 Sıfırdan Altyapı Server Files Hazırlama Rehberi ni hazırlarken novaline clienti vs19'da build etmek için extern güncellemesi ve kodlarda düzenlemeler yapmıştım. Bu hatada kendiliğinden kaybolmuştu.

Konudan tekrar yaptığım İşlemleri teyit edeyim, çözülürse bildirirm.

Video gizli diyor, Client Extern videosuna nasıl ulaşabilirim ?

Whistle · 13 Haziran 2020

19 temmuzda o bölüm yayınlanır

Defacer35 · 15 Haziran 2020

Sıkıntı devam etmekte, LZO sürümünü 2.10'a güncelledim hatta bütün externler güncel ama hata devam etmekte..

Whistle · 15 Haziran 2020

Çok ilginç. Buraya lzo.cpp içeriğini ekliyorum. Karşılaştırma yapabilirsiniz.

C++:

#include "StdAfx.h"
#include <stdlib.h>
#include <lzo/lzoLibLink.h>

#include "lzo.h"
#include "tea.h"
#include "debug.h"

#define dbg_printf

static class LZOFreeMemoryMgr
{
public:
    enum
    {
        REUSING_CAPACITY = 64*1024,
    };
public:
    ~LZOFreeMemoryMgr()
    {
        std::vector<BYTE*>::iterator i;
        for (i = m_freeVector.begin(); i != m_freeVector.end(); ++i)
            delete *i;

        m_freeVector.clear();
    }
    BYTE* Alloc(unsigned capacity)
    {
        assert(capacity > 0);
        if (capacity < REUSING_CAPACITY)
        {
            if (!m_freeVector.empty())
            {
                BYTE* freeMem = m_freeVector.back();
                m_freeVector.pop_back();

                dbg_printf("lzo.reuse_alloc\t%p(%d) free\n", freeMem, capacity);
                return freeMem;
            }
            BYTE* newMem = new BYTE[REUSING_CAPACITY];
            dbg_printf("lzo.reuse_alloc\t%p(%d) real\n", newMem, capacity);
            return newMem;
        }
        BYTE* newMem = new BYTE[capacity];
        dbg_printf("lzo.real_alloc\t%p(%d)\n", newMem, capacity);
        return newMem;
    }
    void Free(BYTE* ptr, unsigned capacity)
    {
        assert(ptr != NULL);
        assert(capacity > 0);
        if (capacity < REUSING_CAPACITY)
        {
            dbg_printf("lzo.reuse_free\t%p(%d)\n", ptr, capacity);
            m_freeVector.push_back(ptr);
            return;
        }

        dbg_printf("lzo.real_free\t%p(%d)\n", ptr, capacity);
        delete [] ptr;
    }
private:
    std::vector<BYTE*> m_freeVector;
} gs_freeMemMgr;



DWORD CLZObject::ms_dwFourCC = MAKEFOURCC('M', 'C', 'O', 'Z');

CLZObject::CLZObject()
{
    Initialize();
}

void CLZObject::Initialize()
{
    m_bInBuffer = false;
    m_pbBuffer = NULL;
    m_dwBufferSize = 0;

    m_pHeader = NULL;
    m_pbIn = NULL;
    m_bCompressed = false;
}

void CLZObject::Clear()
{
    if (m_pbBuffer && !m_bInBuffer)
        gs_freeMemMgr.Free(m_pbBuffer, m_dwBufferSize);
   
    if (m_dwBufferSize > 0)
    {
        dbg_printf("lzo.free %d\n", m_dwBufferSize);
    }

    Initialize();
}

CLZObject::~CLZObject()
{
    Clear();
}

DWORD CLZObject::GetSize()
{
    assert(m_pHeader);

    if (m_bCompressed)
    {
        if (m_pHeader->dwEncryptSize)
            return sizeof(THeader) + sizeof(DWORD) + m_pHeader->dwEncryptSize;
        else
            return sizeof(THeader) + sizeof(DWORD) + m_pHeader->dwCompressedSize;
    }
    else
        return m_pHeader->dwRealSize;
}

void CLZObject::BeginCompress(const void * pvIn, UINT uiInLen)
{
    m_pbIn = (const BYTE *) pvIn;
   
    // sizeof(SHeader) +
    // 암호화를 위한 fourCC 4바이트
    // 압축된 후 만들어질 수 있는 최대 용량 +
    // 암호화를 위한 8 바이트
    m_dwBufferSize = sizeof(THeader) + sizeof(DWORD) + (uiInLen + uiInLen / 64 + 16 + 3) + 8;
   
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, m_dwBufferSize);
   
    m_pHeader = (THeader *) m_pbBuffer;
    m_pHeader->dwFourCC = ms_dwFourCC;
    m_pHeader->dwEncryptSize = m_pHeader->dwCompressedSize = m_pHeader->dwRealSize = 0;
    m_pHeader->dwRealSize = uiInLen;
}

void CLZObject::BeginCompressInBuffer(const void * pvIn, UINT uiInLen, void * /*pvOut*/)
{
    m_pbIn = (const BYTE *) pvIn;
   
    // sizeof(SHeader) +
    // 암호화를 위한 fourCC 4바이트
    // 압축된 후 만들어질 수 있는 최대 용량 +
    // 암호화를 위한 8 바이트
    m_dwBufferSize = sizeof(THeader) + sizeof(DWORD) + (uiInLen + uiInLen / 64 + 16 + 3) + 8;
   
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, m_dwBufferSize);
   
    m_pHeader = (THeader *) m_pbBuffer;
    m_pHeader->dwFourCC = ms_dwFourCC;
    m_pHeader->dwEncryptSize = m_pHeader->dwCompressedSize = m_pHeader->dwRealSize = 0;
    m_pHeader->dwRealSize = uiInLen;
    m_bInBuffer = true;
}

bool CLZObject::Compress()
{
    UINT    iOutLen;
    BYTE *    pbBuffer;
   
    pbBuffer = m_pbBuffer + sizeof(THeader);
    *(DWORD *) pbBuffer = ms_dwFourCC;
    pbBuffer += sizeof(DWORD);

#if defined( LZO1X_999_MEM_COMPRESS )
    int r = lzo1x_999_compress((BYTE *) m_pbIn, m_pHeader->dwRealSize, pbBuffer, (lzo_uint*) &iOutLen, CLZO::Instance().GetWorkMemory());
#else
    int r = lzo1x_1_compress((BYTE *) m_pbIn, m_pHeader->dwRealSize, pbBuffer, (lzo_uint*) &iOutLen, CLZO::Instance().GetWorkMemory());
#endif
   
    if (LZO_E_OK != r)
    {
        TraceError("LZO: lzo1x_999_compress failed");
        return false;
    }
   
    m_pHeader->dwCompressedSize = iOutLen;
    m_bCompressed = true;
    return true;
}

bool CLZObject::BeginDecompress(const void * pvIn)
{
    THeader * pHeader = (THeader *) pvIn;

    if (pHeader->dwFourCC != ms_dwFourCC)
    {
        TraceError("LZObject: not a valid data");
        return false;
    }
   
    m_pHeader    = pHeader;
    m_pbIn    = (const BYTE *) pvIn + (sizeof(THeader) + sizeof(DWORD));

    /*
    static unsigned sum = 0;
    static unsigned count = 0;
    sum += pHeader->dwRealSize;
    count++;
    printf("decompress cur: %d, ave: %d\n", pHeader->dwRealSize, sum/count);
    */
    m_dwBufferSize = pHeader->dwRealSize;
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, pHeader->dwRealSize);
    return true;
}

class DecryptBuffer
{
public:
    enum
    {
        LOCAL_BUF_SIZE = 8 * 1024,
    };
public:
    DecryptBuffer(unsigned size)
    {
        static unsigned count = 0;
        static unsigned sum = 0;
        static unsigned maxSize = 0;

        sum += size;
        count++;

        maxSize = max(size, maxSize);
        if (size >= LOCAL_BUF_SIZE)
        {
            m_buf = new char[size];
            dbg_printf("DecryptBuffer - AllocHeap %d max(%d) ave(%d)\n", size, maxSize/1024, sum/count);
        }
        else
        {
            dbg_printf("DecryptBuffer - AllocStack %d max(%d) ave(%d)\n", size, maxSize/1024, sum/count);
            m_buf = m_local_buf;
        }
    }
    ~DecryptBuffer()
    {
        if (m_local_buf != m_buf)
        {
            dbg_printf("DecruptBuffer - FreeHeap\n");
            delete [] m_buf;
        }
        else
        {
            dbg_printf("DecruptBuffer - FreeStack\n");
        }
    }
    void* GetBufferPtr()
    {
        return m_buf;
    }

private:
    char*    m_buf;
    char    m_local_buf[LOCAL_BUF_SIZE];
};

bool CLZObject::Decompress(DWORD * pdwKey)
{
    UINT uiSize;
    int r;
   
    if (m_pHeader->dwEncryptSize)
    {
        DecryptBuffer buf(m_pHeader->dwEncryptSize);

        BYTE* pbDecryptedBuffer = (BYTE*)buf.GetBufferPtr();
           
        __Decrypt(pdwKey, pbDecryptedBuffer);
       
        if (*(DWORD *) pbDecryptedBuffer != ms_dwFourCC)
        {
            TraceError("LZObject: key incorrect");
            return false;
        }
       
        if (LZO_E_OK != (r = lzo1x_decompress(pbDecryptedBuffer + sizeof(DWORD), m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        {
            TraceError("LZObject: Decompress failed(decrypt) ret %d\n", r);
            return false;
        }
    }
    else
    {
        uiSize = m_pHeader->dwRealSize;
       
        //if (LZO_E_OK != (r = lzo1x_decompress_safe(m_pbIn, m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        if (LZO_E_OK != (r = lzo1x_decompress(m_pbIn, m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        {
            TraceError("LZObject: Decompress failed : ret %d, CompressedSize %d\n", r, m_pHeader->dwCompressedSize);
            return false;
        }
    }
   
    if (uiSize != m_pHeader->dwRealSize)
    {
        TraceError("LZObject: Size differs");
        return false;
    }
   
    return true;
}

bool CLZObject::Encrypt(DWORD * pdwKey)
{
    if (!m_bCompressed)
    {
        assert(!"not compressed yet");
        return false;
    }
   
    BYTE * pbBuffer = m_pbBuffer + sizeof(THeader);
    m_pHeader->dwEncryptSize = tea_encrypt((DWORD *) pbBuffer, (const DWORD *) pbBuffer, pdwKey, m_pHeader->dwCompressedSize + 19);
    return true;
}

bool CLZObject::__Decrypt(DWORD * key, BYTE* data)
{
    assert(m_pbBuffer);
       
    tea_decrypt((DWORD *) data, (const DWORD *) (m_pbIn - sizeof(DWORD)), key, m_pHeader->dwEncryptSize);
    return true;
}

void CLZObject::AllocBuffer(DWORD dwSrcSize)
{
    if (m_pbBuffer && !m_bInBuffer)
        gs_freeMemMgr.Free(m_pbBuffer, m_dwBufferSize);
   
    m_pbBuffer = gs_freeMemMgr.Alloc(dwSrcSize);
    m_dwBufferSize = dwSrcSize;
}
/*
void CLZObject::CopyBuffer(const char* pbSrc, DWORD dwSrcSize)
{
    AllocBuffer(dwSrcSize);
    memcpy(m_pbBuffer, pbSrc, dwSrcSize);
}
*/

CLZO::CLZO() : m_pWorkMem(NULL)
{
    if (lzo_init() != LZO_E_OK)
    {
        TraceError("LZO: cannot initialize");
        return;
    }

#if defined( LZO1X_999_MEM_COMPRESS )
    m_pWorkMem = (BYTE *) malloc(LZO1X_999_MEM_COMPRESS);
#else
    m_pWorkMem = (BYTE *) malloc(LZO1X_1_MEM_COMPRESS);
#endif

    if (NULL == m_pWorkMem)
    {
        TraceError("LZO: cannot alloc memory");
        return;
    }
}

CLZO::~CLZO()
{
    if (m_pWorkMem)
    {
        free(m_pWorkMem);
        m_pWorkMem = NULL;
    }
}

bool CLZO::CompressMemory(CLZObject & rObj, const void * pIn, UINT uiInLen)
{
    rObj.BeginCompress(pIn, uiInLen);
    return rObj.Compress();
}

bool CLZO::CompressEncryptedMemory(CLZObject & rObj, const void * pIn, UINT uiInLen, DWORD * pdwKey)
{
    rObj.BeginCompress(pIn, uiInLen);
   
    if (rObj.Compress())
    {
        if (rObj.Encrypt(pdwKey))
            return true;
       
        return false;
    }  
   
    return false;
}  

bool CLZO::Decompress(CLZObject & rObj, const BYTE * pbBuf, DWORD * pdwKey)
{
    if (!rObj.BeginDecompress(pbBuf))
        return false;
   
    if (!rObj.Decompress(pdwKey))
        return false;
   
    return true;
}


BYTE * CLZO::GetWorkMemory()
{  
    return m_pWorkMem;
}

Defacer35 · 15 Haziran 2020

Whistle demiş ki:

Çok ilginç. Buraya lzo.cpp içeriğini ekliyorum. Karşılaştırma yapabilirsiniz.

C++:

#include "StdAfx.h"
#include <stdlib.h>
#include <lzo/lzoLibLink.h>

#include "lzo.h"
#include "tea.h"
#include "debug.h"

#define dbg_printf

static class LZOFreeMemoryMgr
{
public:
    enum
    {
        REUSING_CAPACITY = 64*1024,
    };
public:
    ~LZOFreeMemoryMgr()
    {
        std::vector<BYTE*>::iterator i;
        for (i = m_freeVector.begin(); i != m_freeVector.end(); ++i)
            delete *i;

        m_freeVector.clear();
    }
    BYTE* Alloc(unsigned capacity)
    {
        assert(capacity > 0);
        if (capacity < REUSING_CAPACITY)
        {
            if (!m_freeVector.empty())
            {
                BYTE* freeMem = m_freeVector.back();
                m_freeVector.pop_back();

                dbg_printf("lzo.reuse_alloc\t%p(%d) free\n", freeMem, capacity);
                return freeMem;
            }
            BYTE* newMem = new BYTE[REUSING_CAPACITY];
            dbg_printf("lzo.reuse_alloc\t%p(%d) real\n", newMem, capacity);
            return newMem;
        }
        BYTE* newMem = new BYTE[capacity];
        dbg_printf("lzo.real_alloc\t%p(%d)\n", newMem, capacity);
        return newMem;
    }
    void Free(BYTE* ptr, unsigned capacity)
    {
        assert(ptr != NULL);
        assert(capacity > 0);
        if (capacity < REUSING_CAPACITY)
        {
            dbg_printf("lzo.reuse_free\t%p(%d)\n", ptr, capacity);
            m_freeVector.push_back(ptr);
            return;
        }

        dbg_printf("lzo.real_free\t%p(%d)\n", ptr, capacity);
        delete [] ptr;
    }
private:
    std::vector<BYTE*> m_freeVector;
} gs_freeMemMgr;



DWORD CLZObject::ms_dwFourCC = MAKEFOURCC('M', 'C', 'O', 'Z');

CLZObject::CLZObject()
{
    Initialize();
}

void CLZObject::Initialize()
{
    m_bInBuffer = false;
    m_pbBuffer = NULL;
    m_dwBufferSize = 0;

    m_pHeader = NULL;
    m_pbIn = NULL;
    m_bCompressed = false;
}

void CLZObject::Clear()
{
    if (m_pbBuffer && !m_bInBuffer)
        gs_freeMemMgr.Free(m_pbBuffer, m_dwBufferSize);
  
    if (m_dwBufferSize > 0)
    {
        dbg_printf("lzo.free %d\n", m_dwBufferSize);
    }

    Initialize();
}

CLZObject::~CLZObject()
{
    Clear();
}

DWORD CLZObject::GetSize()
{
    assert(m_pHeader);

    if (m_bCompressed)
    {
        if (m_pHeader->dwEncryptSize)
            return sizeof(THeader) + sizeof(DWORD) + m_pHeader->dwEncryptSize;
        else
            return sizeof(THeader) + sizeof(DWORD) + m_pHeader->dwCompressedSize;
    }
    else
        return m_pHeader->dwRealSize;
}

void CLZObject::BeginCompress(const void * pvIn, UINT uiInLen)
{
    m_pbIn = (const BYTE *) pvIn;
  
    // sizeof(SHeader) +
    // 암호화를 위한 fourCC 4바이트
    // 압축된 후 만들어질 수 있는 최대 용량 +
    // 암호화를 위한 8 바이트
    m_dwBufferSize = sizeof(THeader) + sizeof(DWORD) + (uiInLen + uiInLen / 64 + 16 + 3) + 8;
  
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, m_dwBufferSize);
  
    m_pHeader = (THeader *) m_pbBuffer;
    m_pHeader->dwFourCC = ms_dwFourCC;
    m_pHeader->dwEncryptSize = m_pHeader->dwCompressedSize = m_pHeader->dwRealSize = 0;
    m_pHeader->dwRealSize = uiInLen;
}

void CLZObject::BeginCompressInBuffer(const void * pvIn, UINT uiInLen, void * /*pvOut*/)
{
    m_pbIn = (const BYTE *) pvIn;
  
    // sizeof(SHeader) +
    // 암호화를 위한 fourCC 4바이트
    // 압축된 후 만들어질 수 있는 최대 용량 +
    // 암호화를 위한 8 바이트
    m_dwBufferSize = sizeof(THeader) + sizeof(DWORD) + (uiInLen + uiInLen / 64 + 16 + 3) + 8;
  
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, m_dwBufferSize);
  
    m_pHeader = (THeader *) m_pbBuffer;
    m_pHeader->dwFourCC = ms_dwFourCC;
    m_pHeader->dwEncryptSize = m_pHeader->dwCompressedSize = m_pHeader->dwRealSize = 0;
    m_pHeader->dwRealSize = uiInLen;
    m_bInBuffer = true;
}

bool CLZObject::Compress()
{
    UINT    iOutLen;
    BYTE *    pbBuffer;
  
    pbBuffer = m_pbBuffer + sizeof(THeader);
    *(DWORD *) pbBuffer = ms_dwFourCC;
    pbBuffer += sizeof(DWORD);

#if defined( LZO1X_999_MEM_COMPRESS )
    int r = lzo1x_999_compress((BYTE *) m_pbIn, m_pHeader->dwRealSize, pbBuffer, (lzo_uint*) &iOutLen, CLZO::Instance().GetWorkMemory());
#else
    int r = lzo1x_1_compress((BYTE *) m_pbIn, m_pHeader->dwRealSize, pbBuffer, (lzo_uint*) &iOutLen, CLZO::Instance().GetWorkMemory());
#endif
  
    if (LZO_E_OK != r)
    {
        TraceError("LZO: lzo1x_999_compress failed");
        return false;
    }
  
    m_pHeader->dwCompressedSize = iOutLen;
    m_bCompressed = true;
    return true;
}

bool CLZObject::BeginDecompress(const void * pvIn)
{
    THeader * pHeader = (THeader *) pvIn;

    if (pHeader->dwFourCC != ms_dwFourCC)
    {
        TraceError("LZObject: not a valid data");
        return false;
    }
  
    m_pHeader    = pHeader;
    m_pbIn    = (const BYTE *) pvIn + (sizeof(THeader) + sizeof(DWORD));

    /*
    static unsigned sum = 0;
    static unsigned count = 0;
    sum += pHeader->dwRealSize;
    count++;
    printf("decompress cur: %d, ave: %d\n", pHeader->dwRealSize, sum/count);
    */
    m_dwBufferSize = pHeader->dwRealSize;
    m_pbBuffer = gs_freeMemMgr.Alloc(m_dwBufferSize);
    memset(m_pbBuffer, 0, pHeader->dwRealSize);
    return true;
}

class DecryptBuffer
{
public:
    enum
    {
        LOCAL_BUF_SIZE = 8 * 1024,
    };
public:
    DecryptBuffer(unsigned size)
    {
        static unsigned count = 0;
        static unsigned sum = 0;
        static unsigned maxSize = 0;

        sum += size;
        count++;

        maxSize = max(size, maxSize);
        if (size >= LOCAL_BUF_SIZE)
        {
            m_buf = new char[size];
            dbg_printf("DecryptBuffer - AllocHeap %d max(%d) ave(%d)\n", size, maxSize/1024, sum/count);
        }
        else
        {
            dbg_printf("DecryptBuffer - AllocStack %d max(%d) ave(%d)\n", size, maxSize/1024, sum/count);
            m_buf = m_local_buf;
        }
    }
    ~DecryptBuffer()
    {
        if (m_local_buf != m_buf)
        {
            dbg_printf("DecruptBuffer - FreeHeap\n");
            delete [] m_buf;
        }
        else
        {
            dbg_printf("DecruptBuffer - FreeStack\n");
        }
    }
    void* GetBufferPtr()
    {
        return m_buf;
    }

private:
    char*    m_buf;
    char    m_local_buf[LOCAL_BUF_SIZE];
};

bool CLZObject::Decompress(DWORD * pdwKey)
{
    UINT uiSize;
    int r;
  
    if (m_pHeader->dwEncryptSize)
    {
        DecryptBuffer buf(m_pHeader->dwEncryptSize);

        BYTE* pbDecryptedBuffer = (BYTE*)buf.GetBufferPtr();
          
        __Decrypt(pdwKey, pbDecryptedBuffer);
      
        if (*(DWORD *) pbDecryptedBuffer != ms_dwFourCC)
        {
            TraceError("LZObject: key incorrect");
            return false;
        }
      
        if (LZO_E_OK != (r = lzo1x_decompress(pbDecryptedBuffer + sizeof(DWORD), m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        {
            TraceError("LZObject: Decompress failed(decrypt) ret %d\n", r);
            return false;
        }
    }
    else
    {
        uiSize = m_pHeader->dwRealSize;
      
        //if (LZO_E_OK != (r = lzo1x_decompress_safe(m_pbIn, m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        if (LZO_E_OK != (r = lzo1x_decompress(m_pbIn, m_pHeader->dwCompressedSize, m_pbBuffer, (lzo_uint*) &uiSize, NULL)))
        {
            TraceError("LZObject: Decompress failed : ret %d, CompressedSize %d\n", r, m_pHeader->dwCompressedSize);
            return false;
        }
    }
  
    if (uiSize != m_pHeader->dwRealSize)
    {
        TraceError("LZObject: Size differs");
        return false;
    }
  
    return true;
}

bool CLZObject::Encrypt(DWORD * pdwKey)
{
    if (!m_bCompressed)
    {
        assert(!"not compressed yet");
        return false;
    }
  
    BYTE * pbBuffer = m_pbBuffer + sizeof(THeader);
    m_pHeader->dwEncryptSize = tea_encrypt((DWORD *) pbBuffer, (const DWORD *) pbBuffer, pdwKey, m_pHeader->dwCompressedSize + 19);
    return true;
}

bool CLZObject::__Decrypt(DWORD * key, BYTE* data)
{
    assert(m_pbBuffer);
      
    tea_decrypt((DWORD *) data, (const DWORD *) (m_pbIn - sizeof(DWORD)), key, m_pHeader->dwEncryptSize);
    return true;
}

void CLZObject::AllocBuffer(DWORD dwSrcSize)
{
    if (m_pbBuffer && !m_bInBuffer)
        gs_freeMemMgr.Free(m_pbBuffer, m_dwBufferSize);
  
    m_pbBuffer = gs_freeMemMgr.Alloc(dwSrcSize);
    m_dwBufferSize = dwSrcSize;
}
/*
void CLZObject::CopyBuffer(const char* pbSrc, DWORD dwSrcSize)
{
    AllocBuffer(dwSrcSize);
    memcpy(m_pbBuffer, pbSrc, dwSrcSize);
}
*/

CLZO::CLZO() : m_pWorkMem(NULL)
{
    if (lzo_init() != LZO_E_OK)
    {
        TraceError("LZO: cannot initialize");
        return;
    }

#if defined( LZO1X_999_MEM_COMPRESS )
    m_pWorkMem = (BYTE *) malloc(LZO1X_999_MEM_COMPRESS);
#else
    m_pWorkMem = (BYTE *) malloc(LZO1X_1_MEM_COMPRESS);
#endif

    if (NULL == m_pWorkMem)
    {
        TraceError("LZO: cannot alloc memory");
        return;
    }
}

CLZO::~CLZO()
{
    if (m_pWorkMem)
    {
        free(m_pWorkMem);
        m_pWorkMem = NULL;
    }
}

bool CLZO::CompressMemory(CLZObject & rObj, const void * pIn, UINT uiInLen)
{
    rObj.BeginCompress(pIn, uiInLen);
    return rObj.Compress();
}

bool CLZO::CompressEncryptedMemory(CLZObject & rObj, const void * pIn, UINT uiInLen, DWORD * pdwKey)
{
    rObj.BeginCompress(pIn, uiInLen);
  
    if (rObj.Compress())
    {
        if (rObj.Encrypt(pdwKey))
            return true;
      
        return false;
    } 
  
    return false;
} 

bool CLZO::Decompress(CLZObject & rObj, const BYTE * pbBuf, DWORD * pdwKey)
{
    if (!rObj.BeginDecompress(pbBuf))
        return false;
  
    if (!rObj.Decompress(pdwKey))
        return false;
  
    return true;
}


BYTE * CLZO::GetWorkMemory()
{ 
    return m_pWorkMem;
}

Dosya birebir aynı, bu sıkıntıyı başka birşey tetikliyor ama henüz bulamadım.

Whistle · 15 Haziran 2020

Packlardan kaynaklı da olabilir. Tüm packları açıp tekrardan program ile kapatmayın deneyiniz.

Defacer35 · 16 Haziran 2020

Whistle demiş ki:
Packlardan kaynaklı da olabilir. Tüm packları açıp tekrardan program ile kapatmayın deneyiniz.

Bütün packleri EPack32 ile kapatıp açtım fakat durum aynı Metin2Dev'den Vanilla şöyle bir yorum yaptı ;

Vanilla demiş ki:
you can backtrace the function calls in Visual Studio. Do this and you'll see what exactly causes the crash to happen.

The reason is: Alloc() should NOT be used with a capacity of 0. Why, you may ask?

That can be explained by two reasons: First, Alloc() is there to allocate some memory if there's not enough memory left in m_freeVector (which allocates

64*1024 bytes as stated above in the file).

So, naturally you'd think about this: HOW MUCH memory needs to be allocated? And here you got your answer to the question above. Your function gets a call with capacity == 0. This means that 0 memory is needed and 0 bytes of memory should be allocated. Does that make any sense? Nope! We have an abnormal situation here and the program needs to be terminated since something went seriously wrong.

Needless to say, removing that alloc line will NOT fix your problem.

So, how could this happen? Since we're talking about lzo maybe one of your packs has 0 size or is otherwise corrupt? I'd advise you to backtrace the function calls so you may find out what operation exactly triggers Alloc(0) and therefore causes the crash. This should solve your problem then.

Defacer35 · 16 Haziran 2020

Türkçe çevirisi ;

Visual Studio'da işlev çağrılarını geri izleyebilirsiniz. Bunu yaptığınızda, kilitlenmenin tam olarak ne olduğunu göreceksiniz.

Sebebi: Alloc () 0 kapasiteyle KULLANILMAMALIDIR. Neden sorabilirsiniz?

Bu iki nedenden dolayı açıklanabilir: Birincisi, m_freeVector'da yeterli bellek yoksa (

64 * 1024 bayt yukarıda dosyada belirtildiği gibi).

Yani, doğal olarak şunu düşünürdünüz: NE KADAR bellek tahsis edilmelidir? Ve burada yukarıdaki soruya cevabınızı aldınız. İşleviniz == 0 kapasiteli bir çağrı alır. Bu, 0 belleğe ihtiyaç duyulduğu ve 0 bayt bellek tahsis edilmesi gerektiği anlamına gelir. Bu bir anlam ifade ediyor mu? Hayır! Burada anormal bir durumumuz var ve bir şeyler ciddi şekilde yanlış gittiğinden programın sonlandırılması gerekiyor.

Söylemeye gerek yok, bu ayırma satırını kaldırmak sorununuzu DÜZELTMEZ.

Peki, bu nasıl olabilir? Lzo hakkında konuştuğumuzdan, paketlerinizden birinin 0 boyutu var mı yoksa bozuk mu? Fonksiyon çağrılarını geri izlemenizi tavsiye ederim, böylece hangi işlemin Alloc (0) 'ı tam olarak tetiklediğini ve böylece çökmeye neden olduğunu öğrenebilirsiniz. Bu, sorununuzu o zaman çözmelidir.

Whistle · 16 Haziran 2020

Linkleri görebilmek için giriş yap veya kayıt ol.

buradaki dosyayı indirip derlediğiniz exeyi deneyebilir misiniz?

Defacer35 · 17 Haziran 2020

Whistle demiş ki:
Linkleri görebilmek için giriş yap veya kayıt ol.
buradaki dosyayı indirip derlediğiniz exeyi deneyebilir misiniz?

EN versiyonunu indirip kendi locale ve rootlarımı entergre ettim sorun çözüldü, 2014 TR pack kullanıyordum sorun ondanmış şuan düzeldi, teşekkürler.

Whistle · 17 Haziran 2020

O zaman sorun packlardan kaynaklıymış.

Fakat bu sorun çoğu fileslerde mevcut nedense. Hangi pack dosyasının bunu tetiklediğini bulabilirsek daha iyi olacak.

Defacer35 · 17 Haziran 2020

Whistle demiş ki:
O zaman sorun packlardan kaynaklıymış.
Fakat bu sorun çoğu fileslerde mevcut nedense. Hangi pack dosyasının bunu tetiklediğini bulabilirsek daha iyi olacak.

Epack32 ile bir kaç pack açıp kapattıktan sonra tekrar aynı hata gelmeye başladı, hangisi olduğunu bulacağım.

Defacer35 · 17 Haziran 2020

Sorun çözüldü, kaynağı Epack32. EterNexus ile de aynı sorun yaşanabilir tavsiyem Martysama'nın paylaştığı EterPack yazılımı ona geçince sorun düzeldi.

Ara

Çözüldü Client Debug - Assertion Failed !

Defacer35

Üye

Defacer35

Reached

Geliştirici

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Defacer35

Üye

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Whistle

S İ N İ R L E N M E K

Defacer35

Üye

Defacer35

Üye

Benzer konular