예제 #1
0
void CCrashHandler::Init ( const SString& strInServerPath )
{
    SString strServerPath = strInServerPath;
    if ( strServerPath == "" )
        strServerPath = GetSystemCurrentDirectory();
    ms_strDumpPath = PathJoin( strServerPath, SERVER_DUMP_PATH );

    // Set a global filter
    #ifdef WIN32
        SetCrashHandlerFilter ( HandleExceptionGlobal );
    #else
        // Prepare initial dumpfile name
        time_t pTime = time( NULL );
        struct tm* tm = localtime( &pTime );
        SString strFilename( "server_%s_%04d%02d%02d_%02d%02d.dmp",
                                        MTA_DM_BUILDTAG_LONG,
                                        tm->tm_year + 1900,
                                        tm->tm_mon + 1,
                                        tm->tm_mday,
                                        tm->tm_hour,
                                        tm->tm_min
                                    );
        ms_strDumpPathFilename = PathJoin( ms_strDumpPath, strFilename );
        MakeSureDirExists( ms_strDumpPathFilename );

        #ifdef WITH_BACKTRACE_ONLY
            signal ( SIGSEGV, HandleExceptionGlobal );
        #else
            google_breakpad::MinidumpDescriptor descriptor( ms_strDumpPath );
            static google_breakpad::ExceptionHandler eh( descriptor, NULL, DumpCallback, NULL, true, -1 );
        #endif
    #endif
}
예제 #2
0
int CLuaFileDefs::fileDelete ( lua_State* luaVM )
{
//  bool fileDelete ( string filePath )
    SString strFile;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( strFile );

    if ( argStream.NextIsUserData () )
        m_pScriptDebugging->LogCustom ( luaVM, "fileDelete may be using an outdated syntax. Please check and update." );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
        if ( pLuaMain )
        {
            std::string strPath;

            // We have a resource argument?
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pResource = pThisResource;
            if ( CResourceManager::ParseResourcePathInput ( strFile, pResource, &strPath, NULL ) )
            {
                // Do we have permissions?
                if ( pResource == pThisResource ||
                     m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                        CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                        "ModifyOtherObjects",
                                                        CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                        false ) )
                {
                    // Make sure the dir exists so we can remove the file
                    MakeSureDirExists ( strPath.c_str () );
                    if ( remove ( strPath.c_str () ) == 0 )
                    {
                        // If file removed return success
                        lua_pushboolean ( luaVM, true );
                        return 1;
                    }
                    else
                    {
                        // Output error
                        m_pScriptDebugging->LogWarning ( luaVM, "%s; unable to delete file", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ) );
                    }
                }
                else
                    m_pScriptDebugging->LogError ( luaVM, "%s failed; ModifyOtherObjects in ACL denied resource %s to access %s", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ), pThisResource->GetName ().c_str (), pResource->GetName ().c_str () );
            }
        }    
    }
    else
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #3
0
void SharedUtil::AddReportLog ( uint uiId, const SString& strText )
{
    SString strPathFilename = PathJoin ( GetMTADataPath (), "report.log" );
    MakeSureDirExists ( strPathFilename );

    SString strMessage ( "%u: %s %s - %s\n", uiId, GetTimeString ( true, false ).c_str (), GetReportLogHeaderText ().c_str (), strText.c_str () );
    FileAppend ( strPathFilename, &strMessage.at ( 0 ), strMessage.length () );
#if MTA_DEBUG
    OutputDebugLine ( SStringX ( "[ReportLog] " ) + strMessage );
#endif
}
예제 #4
0
bool Converter::MakeSureDirExists(wxFileName& path) {
  wxFileName parent(path);
  parent.RemoveLastDir();
  if (parent.GetDirCount() > 0 && !parent.DirExists()) {
    if (!MakeSureDirExists(parent)) {
      return false;
    }
  }
  if (!path.DirExists()) {
    return path.Mkdir();
  }
  return true;
}
예제 #5
0
void CCrashHandler::HandleExceptionGlobal ( int iSig )
{
    MakeSureDirExists ( "dumps/" );

    // Collect backtrace information
    void * buffer [ 100 ];
    int iAmount = backtrace ( buffer, sizeof buffer );
    char ** symbols = backtrace_symbols ( buffer, iAmount );

    // Generate a .log file
    time_t pTime = time ( NULL );
    struct tm * tm = localtime ( &pTime );

    SString sFileName;
    sFileName.Format ( "dumps/server_%s_%04d%02d%02d_%02d%02d.log", MTA_DM_BUILDTYPE, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min );

    SString sContent;
    sContent += SString ( "MTA:SA Server v%s-r%d-%s crash report.\n", MTA_DM_VERSIONSTRING, MTASA_VERSION_BUILD, MTA_DM_BUILDTYPE );
    sContent += SString ( "%04d-%02d-%02d %02d:%02d\n", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min );
    sContent += SString ( "Caught %d addresses ...\n\n", iAmount );
    sContent += "Backtrace:\n";

    for ( int i = 0; i < iAmount; i++ )
    {
        if ( symbols [ i ] )
        {
            sContent += SString ( "#%d - %s\n", i, symbols [ i ] );
        }
    }
    sContent += std::string( 80, '-' ) + "\n";

    // Write the content to the file and close
    FileAppend( sFileName, sContent );
    FileAppend( "dumps/server_pending_upload.log", sContent );

    free ( symbols );

    // Try to close window gracefully 
    if ( !g_bSilent && !g_bNoCurses && m_wndInput )
    {
        if ( m_wndMenu )
        {
            delwin ( m_wndMenu );
            m_wndMenu = NULL;
        }
        delwin ( m_wndInput );
        m_wndInput = NULL;
        endwin ( );
    }
    exit ( EXIT_FAILURE );
}
예제 #6
0
void Converter::ConvertPhoto(Photo& photo, const wxString& root,
                             const wxString& group_name, const wxString& extension) {  
  boost::scoped_ptr<Bitmap> bitmap(Bitmap::Read(photo.m_path.GetFullPath()));

  wxFileName output_path(root, photo.m_path.GetName());
  output_path.MakeAbsolute();
  output_path.AppendDir(group_name);
  output_path.SetExt(extension);
  if (!MakeSureDirExists(output_path)) {
      m_listener.OnConvertFail(photo);
      return;
  }

  if (bitmap.get() == NULL) {
    m_listener.OnConvertFail(photo);
    return;
  }
  if (!photo.IsSizeSet()) {
    photo.m_size = bitmap->GetSize();
  }
//  wxRect rect = m_project.HasPhotoCrop(photo) ?
//                m_project.GetPhotoCrop(photo) :
//                wxRect(wxPoint(-1, -1), m_project.GetResizer().GetSize(photo.m_size));
//  if (wxPoint(-1, -1) == rect.GetPosition()) {
//    bitmap->Scale(rect.GetSize());
//  } else {
//    bitmap->Crop(rect);
//  }

  const Resizer& resizer = m_project.GetResizer();
  if (resizer.NeedsCrop(photo.m_size)) {
    wxRect crop = m_project.HasPhotoCrop(photo) ?
                m_project.GetPhotoCrop(photo) :
                wxRect(wxPoint(0, 0), resizer.GetCropSize(photo.m_size));
    bitmap->Crop(crop);
  }

  if (resizer.NeedsRescale(photo.m_size)) {
    bitmap->Scale(resizer.GetScaleSize(photo.m_size));
  }

  if (!bitmap->Write(output_path.GetFullPath())) {    
    m_listener.OnConvertFail(photo);
    return;
  }
  Photo dest(output_path.GetFullPath());
  dest.m_size = bitmap->GetSize();
  m_listener.OnConvertSuccess(photo, dest);
  // Log::d << "ConvertPhoto to [" << output_path.GetFullPath() << "]." << Log::ENDL;
}
예제 #7
0
static void SaveBacktraceSummary()
{
    // Collect backtrace information
    void * buffer [ 100 ];
    int iAmount = backtrace ( buffer, sizeof buffer );
    iAmount = std::min < int > ( iAmount, NUMELMS( buffer ) );
    char ** symbols = backtrace_symbols ( buffer, iAmount );

    // Generate a .log file
    time_t pTime = time ( NULL );
    struct tm * tm = localtime ( &pTime );

    SString sFileName;
    sFileName.Format ( "server_%s_%04d%02d%02d_%02d%02d.log", MTA_DM_BUILDTYPE, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min );

    SString sContent;
    sContent += SString ( "MTA:SA Server v%s-r%d-%s crash report.\n", MTA_DM_VERSIONSTRING, MTASA_VERSION_BUILD, MTA_DM_BUILDTYPE );
    sContent += SString ( "%04d-%02d-%02d %02d:%02d\n", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min );
    sContent += SString ( "Caught %d addresses ...\n\n", iAmount );
    sContent += "Backtrace:\n";

    for ( int i = 0; i < iAmount; i++ )
    {
        if ( symbols [ i ] )
        {
            sContent += SString ( "#%d - %s\n", i, symbols [ i ] );
        }
    }
    sContent += std::string( 80, '-' ) + "\n";

    // Write the content to the file and close
    MakeSureDirExists ( PathJoin( ms_strDumpPath, sFileName ) );
    FileAppend( PathJoin( ms_strDumpPath, sFileName ), sContent );
    FileAppend( PathJoin( ms_strDumpPath, "server_pending_upload.log" ), sContent );

    free ( symbols );

    // Try to close window gracefully 
    if ( !g_bSilent && !g_bNoCurses && m_wndInput )
    {
        if ( m_wndMenu )
        {
            delwin ( m_wndMenu );
            m_wndMenu = NULL;
        }
        delwin ( m_wndInput );
        m_wndInput = NULL;
        endwin ( );
    }
}
예제 #8
0
///////////////////////////////////////////////////////////////
//
// CServerIdManagerImpl::CServerIdManagerImpl
//
//
//
///////////////////////////////////////////////////////////////
CServerIdManagerImpl::CServerIdManagerImpl ( void )
{
    // Calc private dir root
    m_strServerIdLookupBaseDir = PathJoin ( g_pClientGame->GetFileCacheRoot(), MTA_SERVERID_LOOKUP_DIR );
    MakeSureDirExists ( PathJoin ( m_strServerIdLookupBaseDir, "" ) );

    // Calc temp dir path incase of server id error
    m_strTempErrorDir = PathJoin ( m_strServerIdLookupBaseDir, "_error" );

    // If temp dir has been used, clean it
    if ( DirectoryExists ( m_strTempErrorDir ) )
        DelTree ( m_strTempErrorDir, m_strServerIdLookupBaseDir );

    LoadServerIdMap ();
}
///////////////////////////////////////////////////////////////
//
// CDatabaseConnectionSqlite::CDatabaseConnectionSqlite
//
//
//
///////////////////////////////////////////////////////////////
CDatabaseConnectionSqlite::CDatabaseConnectionSqlite ( CDatabaseType* pManager, const SString& strPath, const SString& strOptions )
    : m_iRefCount ( 1 )
    , m_pManager ( pManager )
{
    g_pStats->iDbConnectionCount++;

    // Parse options string
    GetOption < CDbOptionsMap > ( strOptions, "batch", m_bAutomaticTransactionsEnabled, 1 );

    MakeSureDirExists ( strPath );
    if ( sqlite3_open ( strPath, &m_handle ) )
    {
        SetLastError ( sqlite3_errcode ( m_handle ), sqlite3_errmsg ( m_handle ) );
    }
    else
    {
        m_bOpened = true;
    }
}
예제 #10
0
//
// Save binary data to a file
//
bool SharedUtil::FileSave ( const SString& strFilename, const void* pBuffer, unsigned long ulSize, bool bForce )
{
#ifdef WIN32
    if ( bForce )
        SetFileAttributes ( strFilename, FILE_ATTRIBUTE_NORMAL );
#endif

    if ( bForce )
        MakeSureDirExists ( strFilename );

    FILE* fh = fopen ( strFilename, "wb" );
    if ( !fh )
        return false;

    bool bSaveOk = true;
    if ( ulSize )
        bSaveOk = ( fwrite ( pBuffer, 1, ulSize, fh ) == ulSize );
    fclose ( fh );
    return bSaveOk;
}
예제 #11
0
void CCrashHandler::HandleExceptionGlobal ( int iSig )
{
    MakeSureDirExists ( "dumps/" );

    // Collect backtrace information
    void * buffer [ 100 ];
    int iAmount = backtrace ( buffer, sizeof buffer );
    char ** symbols = backtrace_symbols ( buffer, iAmount );

    // Generate a .log file
    time_t pTime = time ( NULL );
    struct tm * tm = localtime ( &pTime );

    SString sFileName;
    sFileName.Format ( "dumps/server_%s_%04d%02d%02d_%02d%02d.log", MTA_DM_BUILDTYPE, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min );
    FILE * pFile = fopen ( sFileName.c_str ( ), "w" );

    if ( pFile )
    {
        SString sContent;
        sContent += SString ( "MTA:SA Server v%s-r%d-%s crash report.\n", MTA_DM_VERSIONSTRING, MTASA_VERSION_BUILD, MTA_DM_BUILDTYPE );
        sContent += SString ( "Caught %d addresses ...\n\n", iAmount );
        sContent += "Backtrace:\n";

        for ( int i = 0; i < iAmount; i++ )
        {
            if ( symbols [ i ] )
            {
                sContent += SString ( "#%d - %s\n", i, symbols [ i ] );
            }
        }

        // Write the content to the file and close
        fprintf ( pFile, sContent.c_str ( ) );
        fclose ( pFile );
    }

    free ( symbols );
    exit ( EXIT_FAILURE );
}
예제 #12
0
bool CScriptFile::Load ( eMode Mode )
{
    // If we haven't already got a file
    if ( !m_pFile )
    {
        string strFilePath;

        switch ( Mode )
        {
            // Open file in read only binary mode
            case MODE_READ:
                if ( m_pResource->GetFilePath ( m_strFilename.c_str(), strFilePath ) )
                    m_pFile = fopen ( strFilePath.c_str (), "rb" );
                break;

            // Open file in read write binary mode.
            case MODE_READWRITE:
                // Try to load the file in rw mode. Use existing content.
                if ( m_pResource->GetFilePath ( m_strFilename.c_str(), strFilePath ) )
                    m_pFile = fopen ( strFilePath.c_str (), "rb+" );
                break;

            // Open file in read write binary mode. Truncate size to 0.
            case MODE_CREATE:
                strFilePath = m_pResource->GetResourceDirectoryPath () + m_strFilename;
                MakeSureDirExists ( strFilePath.c_str () );
                m_pFile = fopen ( strFilePath.c_str (), "wb+" );
                break;
        }

        // Return whether we successfully opened it or not
        return m_pFile != NULL;
    }

    // Failed
    return false;
}
예제 #13
0
///////////////////////////////////////////////////////////////
//
// FileCopy
//
// Copies a single file.
//
///////////////////////////////////////////////////////////////
bool SharedUtil::FileCopy ( const SString& strSrc, const SString& strDest, bool bForce )
{
    if ( bForce )
        MakeSureDirExists ( strDest );

#ifdef WIN32
    if ( bForce )
        SetFileAttributes ( strDest, FILE_ATTRIBUTE_NORMAL );
#endif

    FILE* fhSrc = fopen ( strSrc, "rb" );
    if ( !fhSrc )
    {
        return false;
    }

    FILE* fhDst = fopen ( strDest, "wb" );
    if ( !fhDst )
    {
        fclose ( fhSrc );
        return false;
    }

    char cBuffer[65536];
    while ( true )
    {
        size_t dataLength = fread ( cBuffer, 1, 65536, fhSrc );
        if ( dataLength == 0 )
            break;
        fwrite ( cBuffer, 1, dataLength, fhDst );
    }

    fclose ( fhSrc );
    fclose ( fhDst );
    return true;
}
예제 #14
0
int CLuaXMLDefs::xmlCreateFile ( lua_State* luaVM )
{
#ifndef MTA_CLIENT
    if ( lua_type ( luaVM, 3 ) == LUA_TLIGHTUSERDATA )
        m_pScriptDebugging->LogCustom ( luaVM, "xmlCreateFile may be using an outdated syntax. Please check and update." );
#endif // !MTA_CLIENT

    // Grab our resource
    CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
    if ( pLuaMain )
    {
        SString strInputPath, strRootNodeName;

        CScriptArgReader argStream ( luaVM );
        argStream.ReadString ( strInputPath );
        argStream.ReadString ( strRootNodeName );

        if ( !argStream.HasErrors () )
        {
            SString strPath;
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pOtherResource = pThisResource; // clientside, this variable will always be pThisResource

            // Resolve other resource from name
            if ( CResourceManager::ParseResourcePathInput ( strInputPath, pOtherResource, &strPath, nullptr ) )
            {
#ifndef MTA_CLIENT
                // We have access to modify other resource?
                if ( pOtherResource == pThisResource ||
                    m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                        CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                        "ModifyOtherObjects",
                        CAccessControlListRight::RIGHT_TYPE_GENERAL,
                        false ) )
#endif // !MTA_CLIENT
                {
                    // Make sure the dir exists so we can successfully make the file
                    MakeSureDirExists ( strPath );

                    // Create the XML file
                    CXMLFile * xmlFile = pLuaMain->CreateXML ( strPath );
                    if ( xmlFile )
                    {
                        // Create its root node
                        CXMLNode* pRootNode = xmlFile->CreateRootNode ( strRootNodeName );
                        if ( pRootNode )
                        {
                            lua_pushxmlnode ( luaVM, pRootNode );
                            return 1;
                        }
                        // Destroy it if we failed
                        pLuaMain->DestroyXML ( xmlFile );
                    }
                }
#ifndef MTA_CLIENT
                else
                    argStream.SetCustomError ( SString ( "ModifyOtherObjects in ACL denied resource '%s' to access '%s'", pThisResource->GetName ().c_str (), pOtherResource->GetName ().c_str () ), "Access denied" );
#endif // !MTA_CLIENT
            }
        }

        if ( argStream.HasErrors () )
            m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
    }

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #15
0
int CLuaXMLDefs::xmlCopyFile ( lua_State* luaVM )
{
#ifndef MTA_CLIENT
    if ( lua_type ( luaVM, 3 ) == LUA_TLIGHTUSERDATA )
        m_pScriptDebugging->LogCustom ( luaVM, "xmlCopyFile may be using an outdated syntax. Please check and update." );
#endif // !MTA_CLIENT

    // Grab our resource
    CLuaMain* pLUA = m_pLuaManager->GetVirtualMachine ( luaVM );
    if ( pLUA )
    {
        SString strFile;
        CXMLNode* pSourceNode;

        CScriptArgReader argStream ( luaVM );
        argStream.ReadUserData ( pSourceNode );
        argStream.ReadString ( strFile );

        if ( !argStream.HasErrors () )
        {
            SString strPath;
            CResource* pThisResource = pLUA->GetResource ();
            CResource* pOtherResource = pThisResource;

            // Resolve other resource from name
            if ( CResourceManager::ParseResourcePathInput ( strFile, pOtherResource, &strPath, NULL ) )
            {
#ifndef MTA_CLIENT
                // We have access to modify other resource?
                if ( pOtherResource == pThisResource ||
                    m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                        CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                        "ModifyOtherObjects",
                        CAccessControlListRight::RIGHT_TYPE_GENERAL,
                        false ) )
#endif // !MTA_CLIENT
                {
                    if ( pSourceNode ) {

                        // Make sure the dir exists so we can successfully make the file
                        MakeSureDirExists ( strPath );

                        // Grab the roots tag name
                        std::string strRootTagName;
                        strRootTagName = pSourceNode->GetTagName ();

                        // Create the new XML file and its root node
                        CXMLFile* pNewXML = pLUA->CreateXML ( strPath.c_str () );
                        if ( pNewXML )
                        {
                            // Grab the root of the new XML
                            CXMLNode* pNewRoot = pNewXML->CreateRootNode ( strRootTagName );
                            if ( pNewRoot )
                            {
                                // Copy over the attributes from the root
                                int iAttributeCount = pSourceNode->GetAttributes ().Count ();
                                int i = 0;
                                CXMLAttribute* pAttribute;
                                for ( ; i < iAttributeCount; i++ )
                                {
                                    pAttribute = pSourceNode->GetAttributes ().Get ( i );
                                    if ( pAttribute )
                                        pNewRoot->GetAttributes ().Create ( *pAttribute );
                                }

                                // Copy the stuff from the given source node to the destination root
                                if ( pSourceNode->CopyChildrenInto ( pNewRoot, true ) )
                                {
                                    lua_pushxmlnode ( luaVM, pNewRoot );
                                    return 1;
                                }
                            }

                            // Delete the XML again
                            pLUA->DestroyXML ( pNewXML );
                        }
                    }
                    else
                        argStream.SetCustomError ( SString ( "Unable to copy XML file %s", strFile.c_str () ), "Bad filepath" );
                }
#ifndef MTA_CLIENT
                else
                    argStream.SetCustomError ( SString ( "ModifyOtherObjects in ACL denied resource '%s' to access '%s'", pThisResource->GetName ().c_str (), pOtherResource->GetName ().c_str () ), "Access denied" );
#endif
            }
        }

        if ( argStream.HasErrors () )
            m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
    }

    // Error
    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #16
0
int CLuaFileDefs::fileCopy ( lua_State* luaVM )
{
//  bool fileCopy ( string filePath, string newFilePath, bool overwrite = false )
    SString filePath; SString newFilePath; bool bOverwrite;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( filePath );
    argStream.ReadString ( newFilePath );
    argStream.ReadBool ( bOverwrite, false );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );

        if ( !g_pNet->ValidateBinaryFileName ( newFilePath ) )
        {
            argStream.SetCustomError ( SString ( "Filename not allowed %s", *newFilePath ), "File error" );
        }
        else
        if ( pLuaMain )
        {
            std::string strCurAbsPath;
            std::string strNewAbsPath;

            // We have a resource arguments?
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pCurResource = pThisResource;
            CResource* pNewResource = pThisResource;
            if ( CResourceManager::ParseResourcePathInput ( filePath, pCurResource, strCurAbsPath ) &&
                 CResourceManager::ParseResourcePathInput ( newFilePath, pNewResource, strNewAbsPath ) )
            {
                 // Does source file exist?
                if ( FileExists ( strCurAbsPath ) )
                {
                    // Does destination file exist?
                    if ( !bOverwrite && FileExists ( strNewAbsPath ) )
                    {
                        argStream.SetCustomError ( SString ( "Destination file already exists (%s)", *newFilePath ), "File error" );
                    }
                    else
                    {
                        // Inform file verifier
                        g_pClientGame->GetResourceManager()->FileModifedByScript( strNewAbsPath );

                        // Make sure the destination folder exists so we can copy the file
                        MakeSureDirExists ( strNewAbsPath );

                        if ( FileCopy ( strCurAbsPath, strNewAbsPath ) )
                        {
                            // If file copied return success
                            lua_pushboolean ( luaVM, true );
                            return 1;
                        }
                        else
                        {
                            argStream.SetCustomError ( SString ( "Unable to copy %s to %s", *filePath, *newFilePath ), "File error" );
                        }
                    }
                }
                else
                {
                    argStream.SetCustomError ( SString ( "Source file doesn't exist (%s)", *filePath ), "File error" );
                }
            }
        }
    }

    if ( argStream.HasErrors () )
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    // Failed
    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #17
0
int CLuaFileDefs::fileCreate ( lua_State* luaVM )
{
//  file fileCreate ( string filePath )
    SString filePath;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( filePath );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );

        if ( !g_pNet->ValidateBinaryFileName ( filePath ) )
        {
            argStream.SetCustomError ( SString ( "Filename not allowed %s", *filePath ), "File error" );
        }
        else
        if ( pLuaMain )
        {
            SString strAbsPath;
            SString strMetaPath;
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pResource = pThisResource;
            if ( CResourceManager::ParseResourcePathInput ( filePath, pResource, strAbsPath, strMetaPath ) )
            {
                // Inform file verifier
                g_pClientGame->GetResourceManager()->FileModifedByScript( strAbsPath );

                // Make sure the destination folder exist so we can create the file
                MakeSureDirExists ( strAbsPath.c_str () );

                // Create the file to create
                eAccessType accessType = filePath[0] == '@' ? eAccessType::ACCESS_PRIVATE : eAccessType::ACCESS_PUBLIC;
                CScriptFile* pFile = new CScriptFile( pThisResource->GetScriptID( ), strMetaPath.c_str(), DEFAULT_MAX_FILESIZE, accessType);
                assert ( pFile );

                // Try to load it
                if ( pFile->Load ( pResource, CScriptFile::MODE_CREATE ) )
                {
                    // Make it a child of the resource's file root
                    pFile->SetParent ( pResource->GetResourceDynamicEntity () );

                    // Add it to the scrpt resource element group
                    CElementGroup* pGroup = pThisResource->GetElementGroup ();
                    if ( pGroup )
                    {
                        pGroup->Add ( pFile );
                    }

                    // Success. Return the file.
                    lua_pushelement ( luaVM, pFile );
                    return 1;
                }
                else
                {
                    // Delete the file again
                    delete pFile;

                    // Output error
                    argStream.SetCustomError ( SString ( "Unable to create %s", *filePath ), "File error" );
                }
            }
        }
    }

    if ( argStream.HasErrors () )
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    // Failed
    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #18
0
void SharedUtil::SetReportLogContents ( const SString& strText )
{
    SString strPathFilename = PathJoin ( GetMTADataPath (), "report.log" );
    MakeSureDirExists ( strPathFilename );
    FileSave ( strPathFilename, strText.length () ? &strText.at ( 0 ) : NULL, strText.length () );
}
예제 #19
0
int CLuaXMLDefs::xmlLoadFile ( lua_State* luaVM )
{
     if ( lua_type ( luaVM, 2 ) == LUA_TLIGHTUSERDATA )
        m_pScriptDebugging->LogCustom ( luaVM, "xmlLoadFile may be using an outdated syntax. Please check and update." );

    // Grab our resource
    CLuaMain* pLUA = m_pLuaManager->GetVirtualMachine ( luaVM );
    if ( pLUA )
    {
        CResource* pThisResource = pLUA->GetResource ();
        CResource* pResource = pThisResource;
        
        // Filename
        if ( lua_type ( luaVM, 1 ) != LUA_TSTRING )
        {
            m_pScriptDebugging->LogBadType ( luaVM, "xmlLoadFile" );

            lua_pushboolean ( luaVM, false );
            return 1;
        }
        // Grab the filename passed
        std::string strFile = lua_tostring ( luaVM, 1 );
        std::string strPath;


        if ( CResourceManager::ParseResourcePathInput ( strFile, pResource, &strPath, NULL ) )
        {
            if ( pResource == pThisResource ||
                m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                "ModifyOtherObjects",
                                                CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                false ) )
            {
                // Make sure the dir exists so we can successfully make the file
                MakeSureDirExists ( strPath.c_str () );

                // Create the XML
                CXMLFile* xmlFile = pLUA->CreateXML ( strPath.c_str () );
                if ( xmlFile )
                {
                    // Try to parse it
                    if ( xmlFile->Parse () )
                    {
                        // Grab the root node. If it didn't exist, create one
                        CXMLNode * pRootNode = xmlFile->GetRootNode ();
                        if ( !pRootNode )
                            pRootNode = xmlFile->CreateRootNode ( "root" );

                        // Could we create one?
                        if ( pRootNode )
                        {
                            // Return the root node
                            lua_pushxmlnode ( luaVM, pRootNode );
                            return 1;
                        }
                    }

                    // Destroy it if we failed
                    pLUA->DestroyXML ( xmlFile );
                }
            }
            else
                m_pScriptDebugging->LogError ( luaVM, "xmlLoadFile failed; ModifyOtherObjects in ACL denied resource %s to access %s", pThisResource->GetName ().c_str (), pResource->GetName ().c_str () );
        }
    }

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #20
0
int CLuaXMLDefs::xmlCopyFile ( lua_State* luaVM )
{
    if ( lua_type ( luaVM, 3 ) == LUA_TLIGHTUSERDATA )
        m_pScriptDebugging->LogCustom ( luaVM, "xmlCopyFile may be using an outdated syntax. Please check and update." );

    // Grab our resource
    CLuaMain* pLUA = m_pLuaManager->GetVirtualMachine ( luaVM );
    if ( pLUA )
    {
        CResource* pThisResource = pLUA->GetResource ();
        CResource* pResource = pThisResource;

        // Verify the argument types passed
        if ( lua_type ( luaVM, 1 ) == LUA_TLIGHTUSERDATA  &&
            lua_type ( luaVM, 2 ) == LUA_TSTRING )
        {
            // Grab the filename passed
            std::string strFile = lua_tostring ( luaVM, 2 );
            std::string strPath;
            if ( CResourceManager::ParseResourcePathInput ( strFile, pResource, &strPath, NULL ) )
            {
                // We have access to modify this resource?
                if ( pResource == pThisResource ||
                    m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                    CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                    "ModifyOtherObjects",
                                                    CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                    false ) )
                {
                    // Make sure the dir exists so we can successfully make the file
                    MakeSureDirExists ( strPath.c_str () );

                    // Grab the source node
                    CXMLNode* pSourceNode = lua_toxmlnode ( luaVM, 1 );
                    if ( pSourceNode )
                    {
                        // Grab the roots tag name
                        std::string strRootTagName;
                        strRootTagName = pSourceNode->GetTagName ();

                        // Create the new XML file and its root node
                        CXMLFile* pNewXML = pLUA->CreateXML ( strPath.c_str () );
                        if ( pNewXML )
                        {
                            // Grab the root of the new XML
                            CXMLNode* pNewRoot = pNewXML->CreateRootNode ( strRootTagName );
                            if ( pNewRoot )
                            {
                                // Copy over the attributes from the root
                                int iAttributeCount = pSourceNode->GetAttributes ().Count ();
                                int i = 0;
                                CXMLAttribute* pAttribute;
                                for ( ; i < iAttributeCount; i++ )
                                {
                                    pAttribute = pSourceNode->GetAttributes ().Get ( i );
                                    if ( pAttribute )
                                        pNewRoot->GetAttributes ().Create ( *pAttribute );
                                }

                                // Copy the stuff from the given source node to the destination root
                                if ( pSourceNode->CopyChildrenInto ( pNewRoot, true ) )
                                {
                                    lua_pushxmlnode ( luaVM, pNewRoot );
                                    return 1;
                                }
                            }

                            // Delete the XML again
                            pLUA->DestroyXML ( pNewXML );
                        }
                    }
                    else
                        CLogger::ErrorPrintf ( "Unable to copy xml file; bad filepath" );
                }
                else
                    m_pScriptDebugging->LogError ( luaVM,"xmlCopyFile failed; ModifyOtherObjects in ACL denied resource %s to access %s", pThisResource->GetName ().c_str (), pResource->GetName ().c_str () );
            }
        }
        else
            m_pScriptDebugging->LogBadType ( luaVM, "xmlCopyFile" );
    }

    // Error
    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #21
0
int CLuaFileDefs::fileCopy ( lua_State* luaVM )
{
//  bool fileCopy ( string filePath, string newFilePath, bool overwrite = false )
    SString filePath; SString newFilePath; bool bOverwrite;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( filePath );
    argStream.ReadString ( newFilePath );
    argStream.ReadBool ( bOverwrite, false );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
        if ( pLuaMain )
        {
            std::string strCurAbsPath;
            std::string strNewAbsPath;
            std::string strCurMetaPath;
            std::string strNewMetaPath;

            // We have a resource arguments?
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pCurResource = pThisResource;
            CResource* pNewResource = pThisResource;
            if ( CResourceManager::ParseResourcePathInput ( filePath, pCurResource, &strCurAbsPath, &strCurMetaPath ) &&
                 CResourceManager::ParseResourcePathInput ( newFilePath, pNewResource, &strNewAbsPath, &strNewMetaPath ) )
            {
                // Do we have permissions?
                if ( ( pCurResource == pThisResource && 
                       pNewResource == pThisResource ) ||
                     m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                        CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                        "ModifyOtherObjects",
                                                        CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                        false ) )
                {
                    std::string strCurFilePath;     // Same as strCurAbsPath
                    std::string strNewFilePath;     // Same as strNewAbsPath

                     // Does source file exist?
                    if ( pCurResource->GetFilePath ( strCurMetaPath.c_str(), strCurFilePath ) )
                    {
                        // Does destination file exist?
                        if ( !bOverwrite && pNewResource->GetFilePath ( strNewMetaPath.c_str(), strNewFilePath ) )
                        {
                            argStream.SetCustomError ( SString ( "Destination file already exists (%s)", *newFilePath ), "File error" );
                        }
                        else
                        {
                            // Make sure the destination folder exists so we can copy the file
                            MakeSureDirExists ( strNewAbsPath );

                            if ( FileCopy ( strCurAbsPath, strNewAbsPath ) )
                            {
                                // If file copied return success
                                lua_pushboolean ( luaVM, true );
                                return 1;
                            }
                            else
                            {
                                argStream.SetCustomError ( SString ( "Unable to copy %s to %s", *filePath, *newFilePath ), "File error" );
                            }
                        }
                    }
                    else
                    {
                        argStream.SetCustomError ( SString ( "Source file doesn't exist (%s)", *filePath ), "File error" );
                    }
                }
                else
                {
                    // Make permissions error message
                    SString strWho;
                    if ( pThisResource != pCurResource )
                        strWho += pCurResource->GetName ();
                    if ( pThisResource != pNewResource )
                    {
                        if ( !strWho.empty () )
                            strWho += " and ";
                        strWho += pNewResource->GetName ();
                    }
                    argStream.SetCustomError ( SString ( "ModifyOtherObjects in ACL denied resource %s to access %s", pThisResource->GetName ().c_str (), *strWho ), "ACL issue" );
                }
            }
        }
    }

    if ( argStream.HasErrors () )
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    // Failed
    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #22
0
int CLuaFileDefs::fileCreate ( lua_State* luaVM )
{
//  file fileCreate ( string filePath )
    SString strFile;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( strFile );

    if ( argStream.NextIsUserData () )
        m_pScriptDebugging->LogCustom ( luaVM, "fileCreate may be using an outdated syntax. Please check and update." );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
        if ( pLuaMain )
        {
            // Grab the filename
            std::string strAbsPath;
            std::string strSubPath;

            // We have a resource argument?
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pResource = pThisResource;
            if ( CResourceManager::ParseResourcePathInput ( strFile, pResource, &strAbsPath, &strSubPath ) )
            {
                // Do we have permissions?
                if ( pResource == pThisResource ||
                     m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                        CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                        "ModifyOtherObjects",
                                                        CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                        false ) )
                {
                    // Make sure the destination folder exist so we can create the file
                    MakeSureDirExists ( strAbsPath.c_str () );
                    
                    // Create the file to create
                    CScriptFile* pFile = new CScriptFile ( pThisResource->GetScriptID(), strSubPath.c_str (), DEFAULT_MAX_FILESIZE );
                    assert ( pFile );

                    // Try to load it
                    if ( pFile->Load ( pResource, CScriptFile::MODE_CREATE ) )
                    {
                        // Add it to the scrpt resource element group
                        CElementGroup* pGroup = pThisResource->GetElementGroup ();
                        if ( pGroup )
                        {
                            pGroup->Add ( pFile );
                        }

                        // Success. Return the file.
                        lua_pushelement ( luaVM, pFile );
                        return 1;
                    }
                    else
                    {
                        // Delete the file again
                        delete pFile;

                        // Output error
                        m_pScriptDebugging->LogWarning ( luaVM, "%s; unable to load file", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ) );
                    }
                }
                else
                    m_pScriptDebugging->LogError ( luaVM, "%s failed; ModifyOtherObjects in ACL denied resource %s to access %s", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ), pThisResource->GetName ().c_str (), pResource->GetName ().c_str () );
            }
        }
    }
    else
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    // Failed
    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #23
0
int CLuaFileDefs::fileRename ( lua_State* luaVM )
{
//  bool fileRename ( string filePath, string newFilePath )
    SString strCurFile; SString strNewFile;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( strCurFile );
    argStream.ReadString ( strNewFile );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
        if ( pLuaMain )
        {
            std::string strCurPath;
            std::string strNewPath;
            std::string strCurSubPath;
            std::string strNewSubPath;

            // We have a resource arguments?
            CResource* pThisResource = pLuaMain->GetResource ();
            CResource* pCurResource = pThisResource;
            CResource* pNewResource = pThisResource;
            if ( CResourceManager::ParseResourcePathInput ( strCurFile, pCurResource, &strCurPath, &strCurSubPath ) &&
                 CResourceManager::ParseResourcePathInput ( strNewFile, pNewResource, &strNewPath, &strNewSubPath ) )
            {
                // Do we have permissions?
                if ( ( pCurResource == pThisResource && 
                       pNewResource == pThisResource ) ||
                     m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                        CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                        "ModifyOtherObjects",
                                                        CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                        false ) )
                {
                    string strCurFilePath;
                    string strNewFilePath;

                    // Does `current` file path exist and `new` file path doesn't exist?
                    if ( pCurResource->GetFilePath ( strCurSubPath.c_str(), strCurFilePath ) &&
                        !pNewResource->GetFilePath ( strNewSubPath.c_str(), strNewFilePath ) )
                    {
                        // Make sure the destination folder exist so we can move the file
                        MakeSureDirExists ( strNewPath.c_str () );

                        if ( FileRename ( strCurPath.c_str (), strNewPath.c_str () ) )
                        {
                            // If file renamed/moved return success
                            lua_pushboolean ( luaVM, true );
                            return 1;
                        }
                        else
                        {
                            // Output error
                            m_pScriptDebugging->LogWarning ( luaVM, "%s; unable to rename/move file", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ) );
                        }
                    }
                    else
                    {
                        // Output error
                        m_pScriptDebugging->LogWarning ( luaVM, "%s failed; source file doesn't exist or destination file already exists", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ) );
                    }
                }
                // Do we have not permissions to both - `current` and `new` resources?
                else if ( pThisResource != pCurResource && pThisResource != pNewResource )
                    m_pScriptDebugging->LogError ( luaVM, "%s failed; ModifyOtherObjects in ACL denied resource %s to access %s and %s", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ), pThisResource->GetName ().c_str (), pCurResource->GetName ().c_str (), pNewResource->GetName ().c_str () );
                // Do we have not permissions to `current` resource?
                else if ( pThisResource != pCurResource && pThisResource == pNewResource )
                    m_pScriptDebugging->LogError ( luaVM, "%s failed; ModifyOtherObjects in ACL denied resource %s to access %s", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ), pThisResource->GetName ().c_str (), pCurResource->GetName ().c_str () );
                // Do we have not permissions to `new` resource?
                else
                    m_pScriptDebugging->LogError ( luaVM, "%s failed; ModifyOtherObjects in ACL denied resource %s to access %s", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ), pThisResource->GetName ().c_str (), pNewResource->GetName ().c_str () );
            }
        }
    }
    else
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #24
0
int CLuaXMLDefs::xmlCreateFile ( lua_State* luaVM )
{
    if ( lua_type ( luaVM, 3 ) == LUA_TLIGHTUSERDATA )
        m_pScriptDebugging->LogCustom ( luaVM, "xmlCreateFile may be using an outdated syntax. Please check and update." );

    // Grab our resource
    CLuaMain* pLUA = m_pLuaManager->GetVirtualMachine ( luaVM );
    if ( pLUA )
    {
        CResource* pThisResource = pLUA->GetResource ();
        CResource* pResource = pThisResource;

        // Filename
        if ( ( lua_type ( luaVM, 1 ) != LUA_TSTRING ) ||
             ( lua_type ( luaVM, 2 ) != LUA_TSTRING ) )
        {
            m_pScriptDebugging->LogBadType ( luaVM, "xmlCreateFile" );

            lua_pushboolean ( luaVM, false );
            return 1;
        }
        else
        {
            std::string strFile = lua_tostring ( luaVM, 1 );
            std::string strPath;

            if ( CResourceManager::ParseResourcePathInput ( strFile, pResource, &strPath, NULL ) )
            {
                // We have access to modify this resource?
                if ( pResource == pThisResource ||
                    m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                    CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                    "ModifyOtherObjects",
                                                    CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                    false ) )
                {

                    // Make sure the dir exists so we can successfully make the file
                    MakeSureDirExists ( strPath.c_str () );

                    // Grab the root
                    const char* szRootName = lua_tostring ( luaVM, 2 );

                    // Create the XML file
                    CXMLFile * xmlFile = pLUA->CreateXML ( strPath.c_str () );
                    if ( xmlFile )
                    {
                        // Create its root node
                        CXMLNode* pRootNode = xmlFile->CreateRootNode ( szRootName );
                        if ( pRootNode )
                        {
                            lua_pushxmlnode ( luaVM, pRootNode );
                            return 1;
                        }

                        // Delete it again
                        pLUA->DestroyXML ( xmlFile );
                    }
                }
            }
        }
    }

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #25
0
// Callback for threaded save
// Static function
DWORD CScreenShot::ThreadProc ( LPVOID lpdwThreadParam )
{
    unsigned long ulScreenHeight = ms_uiHeight;
    unsigned long ulScreenWidth = ms_uiWidth;
    uint uiReqDataSize = ulScreenHeight * ulScreenWidth * 4;
    uint uiLinePitch = ulScreenWidth * 4;

    if ( uiReqDataSize != ms_uiDataSize )
    {
        ms_bIsSaving = false;
        return 0;
    }

    // Create the screen data buffer
    BYTE** ppScreenData = NULL;
    ppScreenData = new BYTE* [ ulScreenHeight ];
    for ( unsigned short y = 0; y < ulScreenHeight; y++ ) {
        ppScreenData[y] = new BYTE [ ulScreenWidth * 4 ];
    }

    // Copy the surface data into a row-based buffer for libpng
    #define BYTESPERPIXEL 4
    unsigned long ulLineWidth = ulScreenWidth * 4;
    for ( unsigned int i = 0; i < ulScreenHeight; i++ ) {
        memcpy ( ppScreenData[i], (BYTE*) ms_pData + i* uiLinePitch, ulLineWidth );
        for ( unsigned int j = 3; j < ulLineWidth; j += BYTESPERPIXEL ) {
            ppScreenData[i][j] = 0xFF;
        }
    }

    MakeSureDirExists( ms_strFileName );
    FILE *file = fopen (ms_strFileName, "wb");
    if ( file )
    {
        png_struct* png_ptr = png_create_write_struct ( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
        png_info* info_ptr = png_create_info_struct ( png_ptr );
        png_init_io ( png_ptr, file );
        png_set_filter ( png_ptr, 0, PNG_FILTER_NONE );
        png_set_compression_level ( png_ptr, 1 );
        png_set_IHDR ( png_ptr, info_ptr, ulScreenWidth, ulScreenHeight, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );
        png_set_rows ( png_ptr, info_ptr, ppScreenData );
        png_write_png ( png_ptr, info_ptr, PNG_TRANSFORM_BGR | PNG_TRANSFORM_STRIP_ALPHA, NULL );
        png_write_end ( png_ptr, info_ptr );
        png_destroy_write_struct ( &png_ptr, &info_ptr );
        fclose(file);
    }
    else
    {
        CCore::GetSingleton ().GetConsole ()->Printf ( "Could not create screenshot file '%s'", *ms_strFileName );
    }

    // Clean up the screen data buffer
    if ( ppScreenData ) {
        for ( unsigned short y = 0; y < ulScreenHeight; y++ ) {
            delete [] ppScreenData[y];
        }
        delete [] ppScreenData;
    }

    ms_bIsSaving = false;
    return 0;
}
예제 #26
0
int CLuaFileDefs::fileRename ( lua_State* luaVM )
{
//  bool fileRename ( string filePath, string newFilePath )
    SString strInputSrcPath; SString strInputDestPath;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( strInputSrcPath );
    argStream.ReadString ( strInputDestPath );

    if ( !argStream.HasErrors () )
    {
        // Grab our lua VM
        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
        if ( !pLuaMain )
        {
            lua_pushboolean ( luaVM, false );
            return 1;
        }

#ifdef MTA_CLIENT
        if ( !g_pNet->ValidateBinaryFileName ( strInputDestPath ) )
        {
            argStream.SetCustomError ( SString ( "Filename not allowed %s", *strInputDestPath ), "File error" );
            m_pScriptDebugging->LogError ( luaVM, argStream.GetFullErrorMessage () );

            lua_pushboolean ( luaVM, false );
            return 1;
        }
#endif

        // absPath: the real absolute path to the file
        // metaPath: path relative to the target resource (as would be defined in the meta.xml file)
        SString strSrcAbsPath; SString strDestAbsPath;

        CResource* pThisResource = pLuaMain->GetResource ();
        CResource* pSrcResource = pThisResource;
        CResource* pDestResource = pThisResource;

        if ( CResourceManager::ParseResourcePathInput ( strInputSrcPath, pSrcResource, &strSrcAbsPath ) &&
                CResourceManager::ParseResourcePathInput ( strInputDestPath, pDestResource, &strDestAbsPath ) )
        {
            CheckCanModifyOtherResource( argStream, pThisResource, pSrcResource, pDestResource );
            CheckCanAccessOtherResourceFile( argStream, pThisResource, pSrcResource, strSrcAbsPath );
            CheckCanAccessOtherResourceFile( argStream, pThisResource, pDestResource, strDestAbsPath );
            if ( !argStream.HasErrors() )
            {
                // Does `current` file path exist and `new` file path doesn't exist?
                if ( FileExists(strSrcAbsPath) )
                {
                    if ( !FileExists ( strDestAbsPath ) ) {
#ifdef MTA_CLIENT
                        // Inform file verifier
                        g_pClientGame->GetResourceManager ()->OnFileModifedByScript ( strSrcAbsPath, "fileRename" );
#endif
                        // Make sure the destination folder exists so we can move the file
                        MakeSureDirExists ( strDestAbsPath );

                        if ( FileRename ( strSrcAbsPath, strDestAbsPath ) )
                        {
                            // If file renamed/moved return success
                            lua_pushboolean ( luaVM, true );
                            return 1;
                        }

                        // Output error
                        m_pScriptDebugging->LogWarning ( luaVM, "fileRename failed; unable to rename file" );
                    }
                    else
                    {
                        m_pScriptDebugging->LogWarning ( luaVM, "fileRename failed; destination file already exists" );
                    }
                }
                else
                {
                    m_pScriptDebugging->LogWarning ( luaVM, "fileRename failed; source file doesn't exist" );
                }
            }
        }
    }
    
    if ( argStream.HasErrors () )
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #27
0
int CLuaXMLDefs::xmlLoadFile ( lua_State* luaVM )
{
     if ( lua_type ( luaVM, 2 ) == LUA_TLIGHTUSERDATA )
        m_pScriptDebugging->LogCustom ( luaVM, "xmlLoadFile may be using an outdated syntax. Please check and update." );

    // Grab our resource
    CLuaMain* pLUA = m_pLuaManager->GetVirtualMachine ( luaVM );
    if ( pLUA )
    {
        SString strFile;
        
        CScriptArgReader argStream ( luaVM );
        argStream.ReadString ( strFile );

        if ( !argStream.HasErrors () )
        {
            SString strPath;
            CResource* pThisResource = pLUA->GetResource ();
            CResource* pOtherResource = pThisResource;
            
            // Resolve other resource from name
            if ( CResourceManager::ParseResourcePathInput ( strFile, pOtherResource, &strPath, NULL ) )
            {
                // We have access to modify other resource?
                if ( pOtherResource == pThisResource ||
                    m_pACLManager->CanObjectUseRight ( pThisResource->GetName ().c_str (),
                                                    CAccessControlListGroupObject::OBJECT_TYPE_RESOURCE,
                                                    "ModifyOtherObjects",
                                                    CAccessControlListRight::RIGHT_TYPE_GENERAL,
                                                    false ) )
                {

                    // Make sure the dir exists so we can successfully make the file
                    MakeSureDirExists ( strPath );

                    // Create the XML
                    CXMLFile* xmlFile = pLUA->CreateXML ( strPath.c_str () );
                    if ( xmlFile )
                    {
                        // Try to parse it
                        if ( xmlFile->Parse () )
                        {
                            // Grab the root node. If it didn't exist, create one
                            CXMLNode * pRootNode = xmlFile->GetRootNode ();
                            if ( !pRootNode )
                                pRootNode = xmlFile->CreateRootNode ( "root" );

                            // Could we create one?
                            if ( pRootNode )
                            {
                                // Return the root node
                                lua_pushxmlnode ( luaVM, pRootNode );
                                return 1;
                            }
                        }

                        // Destroy it if we failed
                        pLUA->DestroyXML ( xmlFile );
                    }
                }
                else
                    argStream.SetCustomError( SString( "ModifyOtherObjects in ACL denied resource '%s' to access '%s'", pThisResource->GetName ().c_str (), pOtherResource->GetName ().c_str () ), "Access denied" );
            }
        }

        if ( argStream.HasErrors () )
            m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
    }

    lua_pushboolean ( luaVM, false );
    return 1;
}
예제 #28
0
///////////////////////////////////////////////////////////////
//
// MkDir
//
// Returns true if the directory is created or already exists
// TODO: Make bTree off option work
//
///////////////////////////////////////////////////////////////
bool SharedUtil::MkDir ( const SString& strInPath, bool bTree )
{
    SString strPath = PathConform ( strInPath );
    MakeSureDirExists ( strPath + PATH_SEPERATOR );
    return DirectoryExists ( strPath );
}