Защита Counter Strike Сервера

#include "extdll.h"
#include "meta_api.h"

#undef C_DLLEXPORT

#ifdef __linux__
    #include <sys/mman.h>
    #define C_DLLEXPORT extern "C" __attribute__((visibility("default")))
#else
    #define C_DLLEXPORT extern "C" __declspec(dllexport)
#endif

enum {
    PF_messageBegin,
    PF_messageByte,
    PF_messageString,
    PF_messageEnd,
    PF_Last
};

typedef struct message_s {
    BOOL done;
    char *str[4];
    int argNum;
    int sayTextId;
    int textMsgId;
} message_t;

typedef struct hooks_s {
    void *address;
    void *handler;
    unsigned char patchBytes[5];
    unsigned char originalBytes[5];

} hooks_t;

hooks_t hookMessage[PF_Last];
message_t eventMessage;

plugin_info_t Plugin_info = {

    META_INTERFACE_VERSION,
    "ChatFix",
    "1.2",
    "10/08/14",
    "s1lent",
    "http://www.aghl.ru/",
    "ChatFix",
    PT_STARTUP,
    PT_NEVER,
};

enginefuncs_t g_engfuncs;
enginefuncs_t g_engfuncs_post;

meta_globals_t *gpMetaGlobals;
gamedll_funcs_t *gpGamedllFuncs;
mutil_funcs_t *gpMetaUtilFuncs;

globalvars_t *gpGlobals;
META_FUNCTIONS gMetaFunctionTable;

C_DLLEXPORT int Meta_Query(char *,plugin_info_t **pPlugInfo,mutil_funcs_t *pMetaUtilFuncs) {
    *pPlugInfo = &Plugin_info;
    gpMetaUtilFuncs = pMetaUtilFuncs;
    return TRUE;
}
BOOL allowMemoryPatch(void *ptr) {
#ifdef __linux__
    void *addr = (void *)((long)ptr & ~(4096 - 1));
    return !mprotect(addr,sysconf(_SC_PAGESIZE),(PROT_READ|PROT_WRITE|PROT_EXEC));
#else
    static DWORD oldProtection;
    return VirtualProtect(ptr,5,PAGE_EXECUTE_READWRITE,&oldProtection);
#endif
}
BOOL doPatch(hooks_t *a) {
    if(allowMemoryPatch(a->address)) {
        memcpy(a->address,a->patchBytes,5);
    }
    return TRUE;
}
BOOL undoPatch(hooks_t *a) {
    if(allowMemoryPatch(a->address)) {
        memcpy(a->address,a->originalBytes,5);
    }
    return TRUE;
}
inline void T_MESSAGE_BEGIN(int msg_dest,int msg_type,const float *pOrigin = NULL,edict_t *ed = NULL) {
    hooks_t *a = &hookMessage[PF_messageBegin];
    if(undoPatch(a)) {
        reinterpret_cast<void (*)(int,int,const float *,edict_t *)>(a->address)(msg_dest,msg_type,pOrigin,ed);
        doPatch(a);
    }
}
inline void T_WRITE_BYTE(int iValue) {
    hooks_t *a = &hookMessage[PF_messageByte];
    if(undoPatch(a)) {
        reinterpret_cast<void (*)(int)>(a->address)(iValue);
        doPatch(a);
    }
}
inline void T_WRITE_STRING(const char *szString) {
    hooks_t *a = &hookMessage[PF_messageString];
    if(undoPatch(a)) {
        reinterpret_cast<void (*)(const char *)>(a->address)(szString);
        doPatch(a);
    }
}
inline void T_MESSAGE_END() {
    hooks_t *a = &hookMessage[PF_messageEnd];
    if(undoPatch(a)) {
        reinterpret_cast<void (*)()>(a->address)();
        doPatch(a);
    }
}
void MessageBegin(int msg_dest,int msg_type,const float *pOrigin,edict_t *ed) {

    message_t *p = &eventMessage;
    if(ed && (p->sayTextId == msg_type || p->textMsgId == msg_type)) {

        for(int i = 0; i < p->argNum; i++) {
            p->str[i] = 0;
        }
        p->argNum = 0;
        p->done = TRUE;
    }
    T_MESSAGE_BEGIN(msg_dest,msg_type,pOrigin,ed);
};
void WriteByte(int iValue) {

    message_t *p = &eventMessage;
    if(p->done && iValue != HUD_PRINTTALK) {
        p->done = FALSE;
    }
    T_WRITE_BYTE(iValue);
};
void WriteString(const char *szString) {

    message_t *p = &eventMessage;
    if(p->done) {
        p->str[p->argNum++] = const_cast<char *>(szString);
        return;
    }
    T_WRITE_STRING(szString);
};
void MessageEnd() {
    message_t *p = &eventMessage;    
    if(p->done && p->argNum) {
        switch(p->argNum) {
            case 1: {
                T_WRITE_STRING("%s");
                T_WRITE_STRING((const char *)p->str[0]);
                break;
            }
            case 2: {
                T_WRITE_STRING((const char *)p->str[0]);
                T_WRITE_STRING((const char *)p->str[1]);
                break;
            }
            case 3: {
                T_WRITE_STRING((const char *)p->str[0]);
                T_WRITE_STRING((const char *)p->str[1]);
                T_WRITE_STRING((const char *)p->str[2]);
                break;
            }
            case 4: {
                T_WRITE_STRING((const char *)p->str[0]);
                T_WRITE_STRING((const char *)p->str[1]);
                T_WRITE_STRING((const char *)p->str[2]);
                T_WRITE_STRING((const char *)p->str[3]);
                break;
            }
            default: {
                break;
            }
        }
        p->done = FALSE;
    }
    T_MESSAGE_END();
}
int RegUserMsg_Post(const char *szName,int)
{
    if(!strcmp(szName,"SayText")) {
        eventMessage.sayTextId = META_RESULT_ORIG_RET(int);
    }
    else if(!strcmp(szName,"TextMsg")) {
        eventMessage.textMsgId = META_RESULT_ORIG_RET(int);
    }
    RETURN_META_VALUE(MRES_IGNORED,0);
}
C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine,int *interfaceVersion) {
    memset(&g_engfuncs_post,0,sizeof(enginefuncs_t));
    g_engfuncs_post.pfnRegUserMsg = RegUserMsg_Post;
    memcpy(pengfuncsFromEngine,&g_engfuncs_post,sizeof(enginefuncs_t));
    return TRUE;
}
C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now,META_FUNCTIONS *pFunctionTable,meta_globals_t *pMGlobals,gamedll_funcs_t *pGamedllFuncs) {
    if(!pMGlobals) {
        return FALSE;
    }
    gpMetaGlobals = pMGlobals;
    if(!pFunctionTable) {
        return FALSE;
    }
    gpGamedllFuncs = pGamedllFuncs;

    void *r[] = {

        (void *)(*g_engfuncs.pfnMessageBegin), (void *)MessageBegin,
        (void *)(*g_engfuncs.pfnWriteByte), (void *)WriteByte,
        (void *)(*g_engfuncs.pfnWriteString), (void *)WriteString,
        (void *)(*g_engfuncs.pfnMessageEnd), (void *)MessageEnd
    };

    hooks_t *a = NULL;
    for(int j = 0; j < PF_Last * 2; j += 2) {
        a = &hookMessage[j / 2];

        a->patchBytes[0] = 0xE9;
        a->address = r[j];
        a->handler = r[j + 1];

        *((unsigned long *)(&a->patchBytes[1])) = (unsigned long)a->handler - (unsigned long)a->address - 5;

        memcpy(a->originalBytes,(void *)a->address,5);

        if(allowMemoryPatch(a->address)) {
            memcpy(a->address,a->patchBytes,5);
        }
    }
    gMetaFunctionTable.pfnGetEngineFunctions_Post = GetEngineFunctions_Post;
    memcpy(pFunctionTable,&gMetaFunctionTable,sizeof(META_FUNCTIONS));
    return TRUE;
}
C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now,PL_UNLOAD_REASON reason) {
    return FALSE;
}
#ifdef __linux__
    C_DLLEXPORT void GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine,globalvars_t *pGlobals) {
#else
    #ifdef _MSC_VER
    C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine,globalvars_t *pGlobals) {
        __asm {
            push ebp
            mov ebp,esp
            sub esp,__LOCAL_SIZE
            push ebx
            push esi
            push edi
        }
    #else    // _MSC_VER
        #ifdef __GNUC__
            C_DLLEXPORT void __stdcall GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine,globalvars_t *pGlobals) {
        #else
            #error There is no support (yet) for your compiler. Please use MSVC or GCC compilers.
        #endif
    #endif // _MSC_VER
#endif // __linux__
        memcpy(&g_engfuncs,pengfuncsFromEngine,sizeof(enginefuncs_t));
        gpGlobals = pGlobals;
        #ifdef _MSC_VER
        if(sizeof(int *) == 8) {
            __asm {
                pop edi
                pop esi
                pop ebx
                mov esp,ebp
                pop ebp
                ret 16
            }
        }
        else {
            __asm {
                pop edi
                pop esi
                pop ebx
                mov esp,ebp
                pop ebp
                ret 8
            }
        }
    #endif // #ifdef _MSC_VER
}