Commands.cpp File Reference

#include "eve-tool.h"
#include "Commands.h"

Include dependency graph for Commands.cpp:

Go to the source code of this file.

Classes
struct	FileHeader
struct	FileHeaderObj

Functions
void	DestinyDumpLogText (const Seperator &cmd)
void	CRC32Text (const Seperator &cmd)
void	ExitProgram (const Seperator &cmd)
void	PrintHelp (const Seperator &cmd)
void	ObjectToSQL (const Seperator &cmd)
void	PrintTimeNow (const Seperator &cmd)
void	LoadScript (const Seperator &cmd)
void	TimeToString (const Seperator &cmd)
void	TriToOBJ (const Seperator &cmd)
void	UnmarshalLogText (const Seperator &cmd)
void	StuffExtract (const Seperator &cmd)
const EVEToolCommand *	FindCommand (const char *name)
	Finds a command. More...
const EVEToolCommand *	FindCommand (const std::string &name)
	Finds a command. More...
void	ProcessCommand (const Seperator &cmd)
	Processed given command. More...

Variables
const EVEToolCommand	EVETOOL_COMMANDS []
const size_t	EVETOOL_COMMAND_COUNT = ( sizeof( EVETOOL_COMMANDS ) / sizeof( EVEToolCommand ) )

Function Documentation

void CRC32Text

(

const Seperator &

cmd

)

Definition at line 121 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), CRC32::Generate(), and sLog.

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 1 == cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s text-to-checksum [text-to-checksum] ...", cmdName );
        return;
    }

    for( size_t i = 1; i < cmd.argCount(); ++i )
    {
        const std::string& s = cmd.arg( i );

        sLog.Log( cmdName, "%X", CRC32::Generate( (const uint8*)s.c_str(), s.size() ) );
    }
}

Here is the call graph for this function:

void DestinyDumpLogText

(

const Seperator &

cmd

)

Definition at line 96 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), Destiny::DumpUpdate(), PyDecodeEscape(), Buffer::size(), and sLog.

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 1 == cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s destiny-binary [destiny-binary] ...", cmdName );
        return;
    }

    for( size_t i = 1; i < cmd.argCount(); ++i )
    {
        const std::string& destinyBinaryStr = cmd.arg( i );

        Buffer destinyBinary;
        if( !PyDecodeEscape( destinyBinaryStr.c_str(), destinyBinary ) )
        {
            sLog.Error( cmdName, "Failed to decode destiny binary." );
            continue;
        }

        Destiny::DumpUpdate( DESTINY__MESSAGE, &destinyBinary[0], destinyBinary.size() );
    }
}

Here is the call graph for this function:

void ExitProgram

(

const Seperator &

cmd

)

Definition at line 139 of file Commands.cpp.

{
    // just close standart input
    fclose( stdin );
}

const EVEToolCommand* FindCommand

(

const char *

name

)

Finds a command.

Parameters

[in]

name

Name of command.

Returns

Found command; NULL if not found.

Definition at line 64 of file Commands.cpp.

References FindCommand().

Referenced by FindCommand(), PrintHelp(), and ProcessCommand().

{
    return FindCommand( std::string( name ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

const EVEToolCommand* FindCommand

(

const std::string &

name

)

Finds a command.

Parameters

[in]

name

Name of command.

Returns

Found command; NULL if not found.

Definition at line 69 of file Commands.cpp.

References EVETOOL_COMMAND_COUNT, and EVEToolCommand::name.

{
    for( size_t i = 0; i < EVETOOL_COMMAND_COUNT; ++i )
    {
        const EVEToolCommand* c = &EVETOOL_COMMANDS[i];

        if( c->name == name )
            return c;
    }

    return NULL;
}

void LoadScript

(

const Seperator &

cmd

)

Definition at line 240 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), ProcessFile(), and sLog.

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 1 == cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s file [file] ...", cmdName );
        return;
    }

    for( size_t i = 1; i < cmd.argCount(); ++i )
        ProcessFile( cmd.arg( i ) );
}

Here is the call graph for this function:

void ObjectToSQL

(

const Seperator &

cmd

)

Definition at line 184 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), PyCachedObjectDecoder::cache, PySubStream::decoded(), PySubStream::DecodeData(), CachedObjectMgr::LoadCachedObject(), SafeDelete(), sLog, and PyRep::visit().

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 5 != cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s [cache_file] [table_name] [key_field] [file_name]", cmdName );
        return;
    }
    const std::string& cacheFile = cmd.arg( 1 );
    const std::string& tableName = cmd.arg( 2 );
    const std::string& keyField = cmd.arg( 3 );
    const std::string& fileName = cmd.arg( 4 );

    std::string abs_fname( "../data/cache/" );
    abs_fname += cacheFile;
    abs_fname += ".cache";

    sLog.Log( cmdName, "Converting cached object %s:\n", abs_fname.c_str() );

    CachedObjectMgr mgr;
    PyCachedObjectDecoder* obj = mgr.LoadCachedObject( abs_fname.c_str(), cacheFile.c_str() );
    if( obj == NULL )
    {
        sLog.Error( cmdName, "Unable to load or decode '%s'!", abs_fname.c_str() );
        return;
    }

    obj->cache->DecodeData();
    if( obj->cache->decoded() == NULL )
    {
        sLog.Error( cmdName, "Unable to load or decode body of '%s'!", abs_fname.c_str() );

        SafeDelete( obj );
        return;
    }

    FILE* out = fopen( fileName.c_str(), "w" );
    if( out == NULL )
    {
        sLog.Error( cmdName, "Unable to open output file '%s'", fileName.c_str() );

        SafeDelete( obj );
        return;
    }

    SetSQLDumper dumper( tableName.c_str(), keyField.c_str(), out );
    if( obj->cache->decoded()->visit( dumper ) )
        sLog.Success( cmdName, "Dumping of %s succeeded.", tableName.c_str() );
    else
        sLog.Error( cmdName, "Dumping of %s failed.", tableName.c_str() );

    fclose( out );
    SafeDelete( obj );
}

Here is the call graph for this function:

void PrintHelp

(

const Seperator &

cmd

)

Definition at line 145 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), EVEToolCommand::description, EVETOOL_COMMAND_COUNT, FindCommand(), EVEToolCommand::name, and sLog.

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 1 == cmd.argCount() )
    {
        sLog.Log( cmdName, "Available commands:" );

        for( size_t i = 0; i < EVETOOL_COMMAND_COUNT; ++i )
        {
            const EVEToolCommand* c = &EVETOOL_COMMANDS[i];

            sLog.Log( cmdName, "%s", c->name );
        }

        sLog.Log( cmdName, "You can get detailed help by typing '%s <command> [<command>] ...'.", cmdName );
    }
    else
    {
        for( size_t i = 1; i < cmd.argCount(); ++i )
        {
            const std::string& cmdStr = cmd.arg( i );
            const EVEToolCommand* c = FindCommand( cmdStr );

            if( NULL == c )
                sLog.Error( cmdName, "Unknown command '%s'.", cmdStr.c_str() );
            else
                sLog.Log( cmdName, "%s: %s", c->name, c->description );
        }
    }
}

Here is the call graph for this function:

void PrintTimeNow

(

const Seperator &

cmd

)

Definition at line 177 of file Commands.cpp.

References Seperator::arg(), PRIu64, sLog, and Win32TimeNow().

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    sLog.Log( cmdName, "Now in Win32 time: %" PRIu64 ".", Win32TimeNow() );
}

Here is the call graph for this function:

void ProcessCommand

(

const Seperator &

cmd

)

Processed given command.

Parameters

[in]

cmd

Command to be processed.

Definition at line 82 of file Commands.cpp.

References Seperator::arg(), EVEToolCommand::callback, FindCommand(), and sLog.

Referenced by ProcessString().

{
    const char* cmdName = cmd.arg( 0 ).c_str();
    const EVEToolCommand* c = FindCommand( cmdName );

    if( NULL == c )
        sLog.Error( "input", "Unknown command '%s'.", cmdName );
    else
        ( *c->callback )( cmd );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void StuffExtract

(

const Seperator &

cmd

)

Definition at line 351 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), CreateDirectory(), FileHeader::file_size, FileHeaderObj::filename, FileHeaderObj::length, FileHeaderObj::offset, FileHeader::path_len, sLog, and SplitPath().

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 2 != cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s [.stuff file]", cmdName );
        return;
    }
    const std::string& filename = cmd.arg( 1 );

    FILE* in = fopen( filename.c_str(), "rb" );
    if( NULL == in )
    {
        sLog.Error( cmdName, "Unable to open %s.", filename.c_str() );
        return;
    }

    uint32 file_count;
    if( 1 != fread( &file_count, sizeof( file_count ), 1, in ) )
    {
        sLog.Log( cmdName, "Unable to read file count." );
        return;
    }

    sLog.Log( cmdName, "There are %u files in %s.", file_count, filename.c_str() );

    std::vector<FileHeaderObj> headers;
    headers.resize( file_count );

    size_t offset = 0;
    for( uint32 i = 0; i < file_count; i++ )
    {
        FileHeader head;
        if( 1 != fread( &head, sizeof( head ), 1, in ) )
        {
            sLog.Error( cmdName, "Unable to read header of file #%u.", i );
            return;
        }

        FileHeaderObj& obj = headers[ i ];
        obj.length = head.file_size;
        obj.offset = offset;

        ++head.path_len; // NULL term

        //read path name.
        obj.filename.resize( head.path_len );
        if( head.path_len != fread( &obj.filename[0], 1, head.path_len, in ) )
        {
            sLog.Error( cmdName, "Unable to read name of file #%u.", i );
            return;
        }
        //drop read NULL term
        obj.filename.resize( head.path_len - 1 );

        sLog.Log( cmdName, "File #%u has length %u and path %s.", i, obj.length, obj.filename.c_str() );
        offset += head.file_size;
    }

    std::vector<FileHeaderObj>::const_iterator cur, end;
    cur = headers.begin();
    end = headers.end();
    for(; cur != end; cur++)
    {
        //split the path into components, make the intermediate directories
        //if needed, and then finally open the file and write it out.
        std::vector<std::string> components;
        SplitPath( cur->filename, components );

        std::string pathname = ".";

        std::vector<std::string>::const_iterator curc, endc;
        curc = components.begin();
        endc = components.end();
        for(; curc != endc; curc++ )
        {
            pathname += "/";
            pathname += *curc;

            if( ( curc + 1 ) == endc )
            {
                //this is the file component.
                FILE* out = fopen( pathname.c_str(), "wb" );
                if( NULL == out )
                {
                    sLog.Error( cmdName, "Unable to create file %s: %s.", pathname.c_str(), strerror( errno ) );
                    break;
                }

                sLog.Log( cmdName, "Extracting file %s of length %u.", pathname.c_str(), cur->length );

                Buffer buf( cur->length );
                if( cur->length != fread( &buf[0], 1, cur->length, in ) )
                {
                    sLog.Error( cmdName, "Unable to read file %s: %s.", cur->filename.c_str(), strerror( errno ) );
                    break;
                }

                if( cur->length != fwrite( &buf[0], 1, cur->length, out ) )
                {
                    sLog.Error( cmdName, "Unable to write file %s: %s", pathname.c_str(), strerror( errno ) );
                    break;
                }

                fclose( out );
            }
            else
            {
                //this is an intermediate directory.
                struct stat stat_struct;

                if( -1 == stat( pathname.c_str(), &stat_struct ) )
                {
                    if( ENOENT == errno )
                    {
                        if( 0 == CreateDirectory( pathname.c_str(), NULL ) )
                        {
                            sLog.Error( cmdName, "Failed to make intermediate directory %s: %s", pathname.c_str(), strerror( errno ) );
                            break;
                        }
                    }
                    else
                    {
                        sLog.Error( cmdName, "Unable to stat %s: %s", pathname.c_str(), strerror( errno ) );
                        break;
                    }
                }
            }
        }
    }

    fclose( in );

    sLog.Log( cmdName, "Extracting from archive %s finished.", filename.c_str() );
}

Here is the call graph for this function:

void TimeToString

(

const Seperator &

cmd

)

Definition at line 254 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), SCNu64, sLog, and Win32TimeToString().

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 1 == cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s win32-time [win32-time] ...", cmdName );
        return;
    }

    for( size_t i = 1; i < cmd.argCount(); ++i )
    {
        const std::string& timeStr = cmd.arg( i );

        uint64 t;
        sscanf( timeStr.c_str(), "%" SCNu64, &t );
        const std::string time = Win32TimeToString( t );

        sLog.Log( cmdName, "%s is %s.", timeStr.c_str(), time.c_str() );
    }
}

Here is the call graph for this function:

void TriToOBJ

(

const Seperator &

cmd

)

Definition at line 276 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), and sLog.

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 4 != cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s [trifile] [objout] [mtlout]", cmdName );
        return;
    }
    const std::string& trifile = cmd.arg( 1 );
    const std::string& objout = cmd.arg( 2 );
    const std::string& mtlout = cmd.arg( 3 );

    TriExporter::TriFile f;
    if( !f.LoadFile( trifile.c_str() ) )
    {
        sLog.Error( cmdName, "Failed to load trifile '%s'.", trifile.c_str() );
        return;
    }

    f.DumpHeaders();
    f.ExportObj( objout.c_str(), mtlout.c_str() );

    sLog.Success( cmdName, "%s - %s - written.", objout.c_str(), mtlout.c_str() );
}

Here is the call graph for this function:

void UnmarshalLogText

(

const Seperator &

cmd

)

Definition at line 302 of file Commands.cpp.

References Seperator::arg(), Seperator::argCount(), PyRep::Dump(), InflateUnmarshal(), PyDecodeEscape(), PyDecRef, and sLog.

{
    const char* cmdName = cmd.arg( 0 ).c_str();

    if( 1 == cmd.argCount() )
    {
        sLog.Error( cmdName, "Usage: %s marshal-binary [marshal-binary] ...", cmdName );
        return;
    }

    for( size_t i = 1; i < cmd.argCount(); ++i )
    {
        const std::string& marshalBinaryStr = cmd.arg( i );

        Buffer marshalBinary;
        if( !PyDecodeEscape( marshalBinaryStr.c_str(), marshalBinary ) )
        {
            sLog.Error( cmdName, "Failed to decode string into binary." );
            continue;
        }

        PyRep* r = InflateUnmarshal( marshalBinary );
        if( NULL == r )
            sLog.Error( cmdName, "Failed to unmarshal binary." );
        else
        {
            sLog.Success( cmdName, "Result:" );
            r->Dump( stdout, "    " );

            PyDecRef( r );
        }
    }
}

Here is the call graph for this function:

Variable Documentation

const size_t EVETOOL_COMMAND_COUNT = ( sizeof( EVETOOL_COMMANDS ) / sizeof( EVEToolCommand ) )

Number of available commands.

Definition at line 62 of file Commands.cpp.

Referenced by FindCommand(), and PrintHelp().

const EVEToolCommand EVETOOL_COMMANDS[]

Initial value:

=
{
    { "destiny",   &DestinyDumpLogText, "Converts given string to binary and dumps it as destiny binary." },
    { "crc32",     &CRC32Text,          "Computes CRC-32 checksum of given arguments."                    },
    { "exit",      &ExitProgram,        "Quits current session."                                          },
    { "help",      &PrintHelp,          "Lists available commands or prints help about specified one."    },
    { "now",       &PrintTimeNow,       "Prints current time in Win32 time format."                       },
    { "obj2sql",   &ObjectToSQL,        "Converts specified cache object into an SQL update."             },
    { "script",    &LoadScript,         "Loads input from specified file(s)."                             },
    { "time",      &TimeToString,       "Interprets given integer as Win32 time."                         },
    { "tri2obj",   &TriToOBJ,           "Dumps specified TRI file."                                       },
    { "unmarshal", &UnmarshalLogText,   "Converts given string to binary and unmarshals it."              },
    { "xstuff",    &StuffExtract,       "Dumps specified STUFF file."                                     }
}

Array of all available commands in eve-tool.

Definition at line 48 of file Commands.cpp.