rapid7/metasploit-framework

#pragma once

#include <windows.h>

#include <string>

//
//    By Pavel
//
//    This class is used for holding some data in the memory that can be accessed
//    from any saparate process in the system by its name.
//    It uses memeory mapped files with fixed size sections. Size is enough to hold
//    as many chars as system supports for file paths.
//
//    Once instance was created, it can be accessed from the another progect by the name.
//    This shared object will be cleaned up when the last instance of this class will be destroyed
//    across whole system.
//
//    Generally, it is used following:
//    1. Create the first instance, set up data, keep it alive forever
//    2. Access to created object by its name from another prject by creating
//       temporary instance of that object. After you dont need this object, destroy it.
//

class CInterprocessStorage {
public:
    static const size_t MaxSize = MAX_PATH;
    static const size_t MaxCount = MAX_PATH / sizeof(TCHAR);

    //
    //    Creates initial named object or opens existing, incrementing its reference count.
    //    Resets all object's contents.
    //
    static CInterprocessStorage *Create( const TCHAR * Name );
    //
    //    Creates initial named object or opens existing, incrementing its reference count, 
    //    sets its value to the specified string
    //
    static CInterprocessStorage *Create( const TCHAR * Name, std::wstring& String );

    //
    //    Opens existing named object. Does not modify its data.
    //
    static CInterprocessStorage *Open( const TCHAR * Name );

    //
    //    Queries object's name.
    //
    std::wstring GetName();

    //
    //    Queries object's value
    //
    void GetString( std::wstring& String );

    //
    //    Tries to get named object's value, accessing one by the name.
    //
    static bool GetString( const TCHAR *Name, std::wstring& String );

    //
    //    Sets object's Value
    //
    void SetString( std::wstring& String );

    ~CInterprocessStorage();

private:
    const HANDLE _hMapping;
    const LPVOID _pBase;
    const TCHAR *_Name;
    CInterprocessStorage( const TCHAR *Name, HANDLE Mapping, LPVOID Base );
};

//    
//    Logs data to file.
//    Log takes place ony if one special file exists. File is named as its hosting application
//    appended by .debug
//    Example: Code runs in the explorer.exe => log will be allowed if near the exe 
//    will be placed file explorer.exe.debug
//    
//    It uses mutual execution to prevent unreadable content of the log file.
//    Log file has path = %temp%w7e.og
//
//    FILE_FLAG_WRITE_THROUGH flag is used to prevent log to be unsaved if application crashed.
//
class CLogger {
public:
    static void LogLine( std::wstring& Text );
    static void LogLine( const TCHAR *Text );
    static void LogLine( );
    static void Log( std::wstring& Text );
    static void Log( const TCHAR *Text );
    static void Log( const TCHAR Char );
    static void Reset( );

private:
    static std::wstring GetPath();
};

//
//    Formats system error codes that were obtained by calling GetLastError.
//    
class CError {
public:
    static std::wstring Format( DWORD ErrorCode );
    static std::wstring Format( DWORD ErrorCode, const TCHAR *Title, const TCHAR *API );
};