[Coding] EASTL Reconstruction

[s0beit]

Good news everyone!

Since the server leak happened it has become apparent to me that EASTL is vital to anybodies hook.

EASTL is the "Electronic Arts Standard Template Library", which replaces the need in most cases to use the STL (Standard Template Library), which you might know from types such as "std::string", "std::vector" or "std::list" which you might remember from BF2 actually.

Anyway here is my EASTL Source code as of June 22nd, 2010.

PHP Code:

#ifndef __EASTL_HEADER__
#define __EASTL_HEADER__

#include <string>

// This is an EASTL reconstruction attempt by s0beit
// EASTL is the "EA Standard Template Library" which was created by EA as an optimized form of STL
// www.thisgamesux.net
// www.uc-forum.com
// www.guidtech.net

namespace eastl
{
    // If you make a class with no members and no virtuals, only static functions
    // the size of the class is 0x1, one byte, The more you know *
    // each class we make below will have its own allocators
    // strictly because it is not realistic to actually reconstruct the allocator
    // considering the allocators are static functions in the game module which proceed to jump around
    // and it gets quite complex.

    class allocator
    {
    public:
        __forceinline                    allocator(){}
        __forceinline                    allocator( eastl::allocator *__formal ){}
        __forceinline void                set_name( const char *__formal ){}
        __forceinline const char*        get_name(){ return "EASTL"; }
        __forceinline void*                allocate( unsigned int n, int flags ){ return malloc( n ); }
        __forceinline void                deallocate( void *p, unsigned int __formal ){ free( p ); }
    };

    // Aligned buffer is a buffer of bytes the size of "num", and is aligned by the second parameter
    // for example if "align" was two, it would probably contain a 2-byte value like a short
    // for example if "align" was four, it would probably contain a 4-byte value like long, int or a pointer
    // it is unknown what it is used for beyond... nothing, lol

    template< size_t num, size_t align > class aligned_buffer
    {
    public:
        unsigned char                    buffer[ num ];        //0000
    };

    template< typename T > class DequeIterator
    {
    public:
        T*                                mpCurrent;            //0000
        T*                                mpBegin;            //0004
        T*                                mpEnd;                //0008
        T*                                mpCurrentArrayPtr;    //000C
    };

    // This is the class that "vector" and "basic_string" use as a base

    template< typename T > class VectorBase
    {
    public:
        T*                                mpBegin;            //0000
        T*                                mpEnd;                //0004
        T*                                mpCapacity;            //0008

        __forceinline VectorBase & operator = ( VectorBase & From )
        {
            mpBegin        = From.mpBegin;
            mpEnd        = From.mpEnd;
            mpCapacity    = From.mpCapacity;
        }

        __forceinline bool operator == ( VectorBase & From )
        {
            return compare( From );
        }

        // This will check if the VectorBase is EXACTLY equal to the current
        __forceinline bool compare_precise( VectorBase & From )
        {
            return (
                mpBegin        == From.mpBegin &&
                mpEnd        == From.mpEnd &&
                mpCapacity    == From.mpCapacity );
        }

        // This will check if the VectorBase members are all equal to the current
        __forceinline bool compare( VectorBase & From )
        {
            size_t len_1 = length();
            size_t len_2 = From.length();

            if( len_1 != len_2 )
            {
                return false;
            }

            for( size_t i = 0; i < len_1; i++ )
            {
                if( From.at( i ) != at( i ) )
                {
                    return false;
                }
            }

            return true;
        }

        __forceinline size_t length()
        {
            return ( mpEnd - mpBegin );
        }

        __forceinline size_t capacity()
        {
            return ( mpCapacity - mpBegin );
        }

        __forceinline T at( size_t idx )
        {
            return mpBegin[ idx ];
        }

        __forceinline bool empty()
        {
            return !mpBegin || mpEnd <= mpBegin;
        }
    };

    template< typename T > class DequeBase
    {
    public:
        T*                                mpPtrArray;
        __int32                            mnPtrArraySize;
        DequeIterator< T >                mItBegin;
        DequeIterator< T >                mItEnd;
        allocator                        mAllocator;
        unsigned char                    _padding[3];
    };

    template< typename T > class vector : public VectorBase< T >
    {
    public:
        allocator                        mAllocator;            //000C
        unsigned char                    _padding[3];        //000D

        vector()
        {
            mpBegin        = 0;
            mpEnd        = 0;
            mpCapacity    = 0;
        }

        __forceinline size_t length()
        {
            return ( mpEnd - mpBegin );
        }

        __forceinline size_t capacity()
        {
            return ( mpCapacity - mpBegin );
        }

        __forceinline T at( size_t idx )
        {
            return mpBegin[ idx ];
        }

        __forceinline bool empty()
        {
            return !mpBegin || mpEnd <= mpBegin;
        }
    };

    template< typename T, size_t nodeCount > class fixed_vector : public vector< T >
    {
    public:
        aligned_buffer< nodeCount * sizeof( T ), sizeof( T ) > mBuffer;
    };

    template< typename T > class basic_string : public VectorBase< T >
    {
    public:

        __forceinline basic_string(){}

        __forceinline basic_string( T* CharArray, size_t Length )
        {
            mpBegin        = new T[ Length ];
            mpEnd        = mpBegin + Length;
            mpCapacity    = mpEnd;

            memcpy( mpBegin, CharArray, sizeof( T ) * Length );
        }

        __forceinline ~basic_string()
        {
            delete[] mpBegin;

            mpBegin        = 0;
            mpEnd        = 0;
            mpCapacity    = 0;
        }
    };

    // These are helpers, they are not part of EASTL

    class ansi_string : public basic_string< char >
    {
    public:

        __forceinline ansi_string( char *CharArray ) : basic_string< char >::basic_string( CharArray, strlen( CharArray ) ){}

        __forceinline ansi_string( std::string s ) : basic_string< char >::basic_string( const_cast< char* >( s.c_str() ), s.length() ){}

        __forceinline std::string c_str()
        {
            std::string ret;

            for( size_t l = 0; l < length(); l++ )
            {
                ret += at( l );
            }

            return ret;
        }
    };

    class unicode_string : public basic_string< wchar_t >
    {
    public:
        __forceinline unicode_string( wchar_t *CharArray ) : basic_string< wchar_t >::basic_string( CharArray, wcslen( CharArray ) ){}

        __forceinline unicode_string( std::wstring s ) : basic_string< wchar_t >::basic_string( const_cast< wchar_t* >( s.c_str() ), s.length() ){}

        __forceinline std::wstring c_str()
        {
            std::wstring ret;

            for( size_t l = 0; l < length(); l++ )
            {
                ret += at( l );
            }

            return ret;
        }
    };
};

#endif 


===== FAQ =====

Q: Hey, this looks a lot like mattdog's ID_LIST
A: Yeah, ID_LIST was really VectorBase but he did not documented them in the proper alignment and he did not add the amount of support i have added (and in proper format)

Q: what about <x>?
A: Some EASTL classes are missing or incomplete in this reverse-engineered release

Q: Can you add <x>?
A: Maybe, tell me what you need.

Q: This is crashing, how do i fix it?
A: Make a reply here and i will try to see what you did wrong.

Q: Can i call the deconstructor on strings or other EASTL objects the game created?
A: NO. EASTL natively has an allocator which handles allocation and deallocation of objects like VectorBase and basic_string, if you try to "delete" it i don't see how the game could survive and would probably crash.

Q: Who do i thank???
A: s0beit, Kanavel, GHOSTER, mattdog and domo (leaked the server files)

Q: Example?
A: Why certainly my good man.

PHP Code:

    class IClientSoldierEntity
    {
    public:

        __forceinline eastl::ansi_string* GetNetName()
        {
            _asm mov ebx, this;
            _asm mov eax, [ebx+0x0C];
            _asm add eax, 0x0C;
        }
    }; 


Then later you can.....

PHP Code:


    eastl::ansi_string* pNetName = pFirst->GetNetName();

    if( pNetName )
    {
        RenderTextCenter( SoldierOnScreen.x, SoldierOnScreen.y + 40, D3DCOLOR_RGBA( 255, 255, 255, 255 ), "%s", pNetName->c_str().c_str() );
    } 


Q: Pix?
A: Pictures of the example code (working in MOH, example code is MOH too...) are right below.

[Jesus.]

wow. this is so much fkn win.

[Roverturbo]

Yep, good job.

[learn_more]

nice work indeed

[s0beit]

notes: fixed_vector might be off in size because it seems the size of any given fixed_vector (with a template) can vary in size.

Please keep this in mind when reversing classes.

[_GHOSTER_]

Good work

[dogmatt]

Originally Posted by s0beit

notes: fixed_vector might be off in size because it seems the size of any given fixed_vector (with a template) can vary in size.

Please keep this in mind when reversing classes.

yep..
it can be vec in some struct aligned to 8 bytes - it happens if struct contains any double var (8b long ofc)
EA just didnt touch compiler settings to set alignment mode

so i added 4rd dword to my id_list struct to have 16b size

[Kosaki]

Great work!

Saves me a lot of time

[|KungFuPenguin|]

You should also thank domo - for leaking the server files.

[s0beit]

Originally Posted by |KungFuPenguin|

You should also thank domo - for leaking the server files.

Edited.

[TECSmith]

+REP!

Once again... Thank you to s0beit, Kanavel, GHOSTER, mattdog and domo!
Outstanding contribution(s), which I hope to put back into this community once I've completed my own project.

P.S: I'm sorry for the resurrection, but I thought this thread should be commended some more!!!

[HuЯЯ1cΛиΞ]

Why did you "reconstruct" EASTL, s0beit?
Didn't you know that EA released around 50 to 60% of their whole EASTL on GPL.EA.com ?

You can also get it on github by some user who uploaded it on there:
https://github.com/paulhodge/EASTL

Yet, I still didn't get it to compile though (error C2894: templates cannot be declared to have 'C' linkage).

[Freeheadshot]

Take a look at the Threaddate o.O

[Hanoi22]

Originally Posted by HuЯЯ1cΛиΞ

Why did you "reconstruct" EASTL, s0beit?
Didn't you know that EA released around 50 to 60% of their whole EASTL on GPL.EA.com ?

You can also get it on github by some user who uploaded it on there:
https://github.com/paulhodge/EASTL

Yet, I still didn't get it to compile though (error C2894: templates cannot be declared to have 'C' linkage).

This was before none of it was public I believe..

[HuЯЯ1cΛиΞ]

Nope it was released in the Sims 3 EA WebKit from March/April 2010 already (maybe even earlier).
But yeah, might have not been that much of an interest what EA did on their GPL page. :-)