Пример #1
0
static BOOL
RemoveFile (LPTSTR lpFileName, DWORD dwFlags, WIN32_FIND_DATA* f)
{
	/*This function is called by CommandDelete and
	does the actual process of deleting the single
	file*/
		if(CheckCtrlBreak(BREAK_INPUT))
			return 1;

        /*check to see if it is read only and if this is done based on /A
          if it is done by file name, access is denied. However, if it is done
          using the /A switch you must un-read only the file and allow it to be
          deleted*/
        if((dwFlags & DEL_ATTRIBUTES) || (dwFlags & DEL_FORCE))
        {
                if(f->dwFileAttributes & FILE_ATTRIBUTE_READONLY)
		{
			/*setting file to normal, not saving old attrs first
			  because the file is going to be deleted anyways
			  so the only thing that matters is that it isnt
			  read only.*/
                        SetFileAttributes(lpFileName,FILE_ATTRIBUTE_NORMAL);
                }
        }

        if (dwFlags & DEL_WIPE)
        {

	        HANDLE file;
	        DWORD temp;
#define BufferSize 65536
	        BYTE buffer[BufferSize];
	        LONGLONG i;
	        LARGE_INTEGER FileSize;

	        FileSize.u.HighPart = f->nFileSizeHigh;
                FileSize.u.LowPart = f->nFileSizeLow;

	        for(i = 0; i < BufferSize; i++)
	        {
		        buffer[i]=rand() % 256;
	        }
	        file = CreateFile (lpFileName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,  FILE_FLAG_WRITE_THROUGH, NULL);
                if (file != INVALID_HANDLE_VALUE)
                {
                        for(i = 0; i < (FileSize.QuadPart - BufferSize); i += BufferSize)
		        {
			        WriteFile (file, buffer, BufferSize, &temp, NULL);
			        ConOutPrintf (_T("%I64d%% %s\r"),(i * (LONGLONG)100)/FileSize.QuadPart,szDeleteWipe);
		        }
		        WriteFile (file, buffer, (DWORD)(FileSize.QuadPart - i), &temp, NULL);
		        ConOutPrintf (_T("100%% %s\n"),szDeleteWipe);
		        CloseHandle (file);
                }
        }

	return DeleteFile (lpFileName);
}
Пример #2
0
void NormalEntry(){
	SYSTEMTIME st={0,0,0,0,0,0,0,0};
	FILE * fp=NULL,*_=NULL;
	GetLocalTime(&st);
	_tprintf(_T("    LICENSE:MIT LICENSE\n%s\n    Copyright (C) 2016 @Too-Naive\n"),welcomeShow);
	_tprintf(_T("    Project website:%s\n"),objectwebsite);
	_tprintf(_T("    Bug report:sweheartiii[at]hotmail.com \n\t       Or open new issue\n\n\n"));
	_tprintf(_T("    Start replace hosts file:\n    Step1:Get System Driver..."));
	try {
		if (!GetEnvironmentVariable(_T("SystemRoot"),buf3,BUFSIZ))
			THROWERR(_T("GetEnvironmentVariable() Error!\n\tCannot get system path!"));
		_stprintf(buf1,_T("%s\\system32\\drivers\\etc\\hosts"),buf3);
		_stprintf(buf2,_T("%s\\system32\\drivers\\etc\\hosts.%04d%02d%02d.%02d%02d%02d"),
		buf3,st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);
		_tprintf(_T("\t\tDone.\n    Step2:Download hosts file..."));
		for (int _count=0;!Func_Download(hostsfile,DownLocated);
			_count++,_tprintf(pWait),Sleep(5000),_tprintf(_T("\tDownload hosts file...")))
			if (_count>2) for (_count=0,_tprintf(_T("\tDownload hosts file..."));
								!Func_Download(hostsfile,DownLocated);_count++,Sleep(5000))
									if (_count>2) THROWERR(_T("DownLoad hosts file Error!"));
		_tprintf(_T("\t100%%\n    Step3:Change Line Endings..."));
		if (!((fp=_tfopen(DownLocated,_T("r"))) && (_=_tfopen(ChangeCTLR,_T("w")))))
			THROWERR(_T("Open file Error!"));
		while (!feof(fp)){
			_fgetts(szline,1000,fp);
			_fputts(szline,_);
		}
		fclose(fp);fclose(_);
		fp=NULL,_=NULL;
		if (!DeleteFile(DownLocated));
		if (Func_CheckDiff(ChangeCTLR,buf1)){
			_tprintf(_T("\t100%%\n\n    diff exited with value 0(0x00)\n    Finish:Hosts file Not update.\n\n"));
			DeleteFile(ChangeCTLR);
			system("pause");
			return ;
		}
		else {
			_tprintf(_T("\t100%%\n    Step4:Copy Backup File..."));
			if (!SetFileAttributes(buf1,FILE_ATTRIBUTE_NORMAL)); //for avoid CopyFile failed.
			if (!CopyFile(buf1,buf2,FALSE))
				THROWERR(_T("CopyFile() Error on copy a backup file"));
			_tprintf(_T("\t\t100%%\n    Step5:Replace Default Hosts File..."));
			if (!CopyFile(ChangeCTLR,buf1,FALSE))
				THROWERR(_T("CopyFile() Error on copy hosts file to system path"));
			if (!DeleteFile(ChangeCTLR));
			_tprintf(_T("Replace File Successfully\n"));

		}
	}
	catch(expection runtimeerr){
		_tprintf(_T("\nFatal Error:\n%s (GetLastError():%ld)\n\
Please contact the application's support team for more information.\n"),runtimeerr.Message,GetLastError());
		_tprintf(_T("\n[Debug Message]\n%s\n%s\n%s\n"),buf1,buf2,buf3);
		abort();
	}
	MessageBox(NULL,_T("Hosts File Set Success!"),_T("Congratulations!"),MB_ICONINFORMATION|MB_SETFOREGROUND);
	return ;
}
Пример #3
0
int KTestCommon::SetAllFilesAttributes(const TCHAR cszPath[], DWORD dwFileAttributes)
{
	int nRetCode = false;
	int nResult	 = false;
	TCHAR szPathName[MAX_PATH];
	TCHAR szFullPathFile[MAX_PATH];
	TCHAR* pszFile	 = NULL;
	HANDLE hFindFile = INVALID_HANDLE_VALUE;
	WIN32_FIND_DATA FindFileData;

	ASSERT(cszPath);

	nRetCode = _sntprintf(szPathName, MAX_PATH, _T("%s\\%s"), cszPath, _T("*.*"));
	KGLOG_PROCESS_ERROR(nRetCode != -1);
	szPathName[MAX_PATH - 1] = _T('\0');

	hFindFile = ::FindFirstFile(szPathName, &FindFileData);
	KGLOG_PROCESS_ERROR(hFindFile != INVALID_HANDLE_VALUE);
	while (true)
	{
		pszFile = FindFileData.cFileName;
		if (_tcsncmp(pszFile, _T("."), MAX_PATH) != 0 &&
			_tcsncmp(pszFile, _T(".."), MAX_PATH) != 0)
		{
			nRetCode = _sntprintf(szFullPathFile, MAX_PATH, _T("%s\\%s"), cszPath, pszFile);
			KGLOG_PROCESS_ERROR(nRetCode != -1);
			szFullPathFile[MAX_PATH - 1] = _T('\0');
			if (FindFileData.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
			{
				//nRetCode = _tremove(szFullPathFile);
				nRetCode = SetFileAttributes(szFullPathFile, dwFileAttributes);
				KGLOG_PROCESS_ERROR(nRetCode);
			}
			else
			{
				nRetCode = SetAllFilesAttributes(szFullPathFile, dwFileAttributes);
				KGLOG_PROCESS_ERROR(nRetCode);
			}
		}
		nRetCode = ::FindNextFile(hFindFile, &FindFileData);
		if (!nRetCode)
		{
			nRetCode = ::GetLastError();
			KG_PROCESS_SUCCESS(nRetCode == ERROR_NO_MORE_FILES);
		}
	}

Exit1:
	nResult = true;
Exit0:
	if (hFindFile != INVALID_HANDLE_VALUE)
	{
		::FindClose(hFindFile);
		hFindFile = INVALID_HANDLE_VALUE;
	}
	return nResult;
}
Пример #4
0
bool unprotect( TCHAR* fileName ) {
 bool result = true;
 DWORD fileAttrs = GetFileAttributes( fileName );
 if ( fileAttrs & FILE_ATTRIBUTE_READONLY )
  result = SetFileAttributes( fileName, fileAttrs - FILE_ATTRIBUTE_READONLY );
 if ( fileAttrs & FILE_ATTRIBUTE_DIRECTORY )
  result = RemoveDirectory( fileName );
 return result;
}
Пример #5
0
BOOL ringFile::SetAttrib(DWORD dwFileAttributes)
{
	if(SetFileAttributes(m_szFilename,dwFileAttributes))
	{
		m_dwFileAttr = dwFileAttributes;
		return TRUE;
	}
	return FALSE;
}
Пример #6
0
BOOL SetFileAttributes(const WCHAR* lpFileName, DWORD dwFileAttributes)
{
	std::string fileName;

	if (!convertToUtf8(lpFileName, fileName))
		return FALSE;

	return SetFileAttributes(fileName.c_str(), dwFileAttributes);
}
Пример #7
0
BOOL CUtils::SafeDeleteFile( const CString& strFilePath )
{
    if(PathFileExists(strFilePath))
    {
        SetFileAttributes(strFilePath, FILE_ATTRIBUTE_NORMAL);
        return DeleteFile(strFilePath); 
    }
    return TRUE;
}
Пример #8
0
bool CEditModel::BinSave( const string& str )
{
	string FileName = str;
	if( !DecideAllIsSet() )
	{
		string log = FileName;
		log += "中有piece没有设置rs,或者rs为绝对路径,或者有纹理为绝对路径,不能保存";
		MessageBox( 0, log.c_str(), "提示",0 );
		return 0;
	}

	size_t npos = FileName.find(".mod");
	if( npos == -1 )
		FileName = FileName + ".mod";

	SetFileAttributes( FileName.c_str(), FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE );
	locale loc = locale::global(locale("")); //要打开的文件路径包含中文,设置全局locale为本地环境
	ofstream File( FileName.c_str(), ios::binary|ios::out );
	locale::global(loc);
	if( File.fail() )
		return false;
	
	// zjtemp
#if 0
	CEditPieceGroup* pPieceGroup = GeneratePieceGroupForSave();
	CModFormat modFormat;
	modFormat.Save(FileName, pPieceGroup);
	pPieceGroup->Clear();
	SafeDelete(pPieceGroup);
#else
	//DWORD Res = MAKEFOURCC( 'A', 'R', 'P', 0 );
	DWORD Res = MAKEFOURCC( 'M', 'O', 'D', 0 );
	DWORD Version = ENABLECP(ARP_COMP_VERSION);
	Version = ENABLEBOX(Version);
	File.write( (TCHAR*)&Res, sizeof(DWORD) );
	File.write( (TCHAR*)&Version, sizeof(DWORD) );

	int Size = 0;
	CModel::RenderPieceMap::iterator it,eit = m_MeshsPiece.end();

	for( it = m_MeshsPiece.begin(); it!=eit; ++it )
		Size += (int)it->second.m_Pieces.size();
	File.write( (TCHAR*)&Size, sizeof(int) );
	for( it = m_MeshsPiece.begin(); it!=eit; ++it )
	{
		for ( int i = 0; i < (int)it->second.m_Pieces.size(); i++ )
			((CEditPiece*)it->second.m_Pieces[i].m_pPiece)->BinSave( File );
	}

	// 头像信息
	File.write( (const char*)(&PortraitInfo::PICC),sizeof(FourCC) );
	File.write(reinterpret_cast<TCHAR*>(&m_PortraitInfo), sizeof(m_PortraitInfo));
	File.close();
#endif

	return true;
}
Пример #9
0
bool CFileSystemWin32::SetFileReadOnly(const nString& Path, bool ReadOnly)
{
	nString AbsPath = DataSrv->ManglePath(Path);
	DWORD FileAttrs = GetFileAttributes(AbsPath.Get());
	if (FileAttrs == INVALID_FILE_ATTRIBUTES) FAIL;
	if (ReadOnly) FileAttrs |= FILE_ATTRIBUTE_READONLY;
	else FileAttrs &= ~FILE_ATTRIBUTE_READONLY;
	return SetFileAttributes(AbsPath.Get(), FileAttrs) != FALSE;
}
Пример #10
0
// @fname: 须是文件
BOOL delfile(char *fname)
{
	WIN32_FILE_ATTRIBUTE_DATA		fattrdata;

	// 去掉只读属性
	GetFileAttributesEx(fname, GetFileExInfoStandard, &fattrdata);
	SetFileAttributes(fname, fattrdata.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
	return DeleteFile(fname);
}
Пример #11
0
void SetFileAttributesReadOnly( LPCTSTR szFile )
{
	DWORD dwFileAttributes	= GetFileAttributes( szFile );
	if( 0xFFFFFFFF != dwFileAttributes )
	{
		dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
		SetFileAttributes( szFile, dwFileAttributes );
	}
}
Пример #12
0
int ArchiveFile::ExtractItem(int index, const char* outFilename) const
{
	assert(!s_formatInfos.empty());
	//assert(index >= 0 && index < m_numItems);
	if(!(index >= 0 && index < m_numItems)) return 0;

	ArchiveItem& item = m_items[index];
	int rv = item.size;

	DWORD outAttributes = GetFileAttributes(outFilename);
	if(outAttributes & FILE_ATTRIBUTE_READONLY)
		SetFileAttributes(outFilename, outAttributes & ~FILE_ATTRIBUTE_READONLY); // temporarily remove read-only attribute so we can decompress to there

	if(m_typeIndex < 0)
	{
		// uncompressed
		if(!CopyFile(m_filename, outFilename, false))
			rv = 0;
	}
	else
	{
		IInArchive* object = NULL;
		HRESULT hr = E_FAIL;
		if(SUCCEEDED(CreateObject(&s_formatInfos[m_typeIndex].guid, &IID_IInArchive, (void**)&object)))
		{
			InFileStream* ifs = new InFileStream(m_filename);
			if(SUCCEEDED(object->Open(ifs,0,0)))
			{
				OutStream* os = new OutStream(index, outFilename);
				const UInt32 indices [1] = {index};
				hr = object->Extract(indices, 1, 0, os);
				object->Close();
			}
			object->Release();
		}
		if(FAILED(hr))
			rv = 0;
	}

	if(outAttributes & FILE_ATTRIBUTE_READONLY)
		SetFileAttributes(outFilename, outAttributes); // restore read-only attribute

	return rv;
}
/*
================
rvGEWorkspace::LoadFile

Loads the given gui file.
================
*/
bool rvGEWorkspace::LoadFile( const char *filename, idStr *error ) {
	delete mInterface;
	idStr tempfile;
	idStr ospath;
	bool  result;
	tempfile = "guis/temp.guied";
	ospath = fileSystem->RelativePathToOSPath( tempfile, "fs_basepath" );
	// Make sure the gui directory exists
	idStr createDir = ospath;
	createDir.StripFilename( );
	CreateDirectory( createDir, NULL );
	SetFileAttributes( ospath, FILE_ATTRIBUTE_NORMAL );
	DeleteFile( ospath );
	if( !CopyFile( filename, ospath, FALSE ) ) {
		if( error ) {
			*error = "File not found";
		}
		return false;
	}
	SetFileAttributes( ospath, FILE_ATTRIBUTE_NORMAL );
	mFilename = filename;
	UpdateTitle( );
	// Let the real window system parse it first
	mInterface = NULL;
	result     = true;
	try {
		mInterface = reinterpret_cast< idUserInterfaceLocal * >( uiManager->FindGui( tempfile, true, true ) );
		if( !mInterface && error ) {
			*error = "File not found";
		}
	} catch( idException &e ) {
		result = false;
		if( error ) {
			*error = e.error;
		}
		return false;
	}
	if( result ) {
		rvGEWindowWrapper::GetWrapper( mInterface->GetDesktop( ) )->Expand( );
	} else {
		DeleteFile( ospath );
	}
	return result;
}
Пример #14
0
// Open the Log
bool CLog::Open( const char *pFilename )
{
    // Check if there already is an opened file
    if( m_bOpen )
    {
        // Close it first
        Close();
    }

    // Make sure the file is NOT read-only
#ifdef WIN32
    SetFileAttributes( pFilename, FILE_ATTRIBUTE_NORMAL );
#endif

    // Open the Log
    m_theLog.open( pFilename );
    if( !m_theLog.fail() )
    {
        // Set indicator bOpen to true
        m_bOpen = true;

        // Get current time
#ifdef WIN32
        SYSTEMTIME LocalTime;
        GetLocalTime (&LocalTime);
#else
        struct tm *LocalTime;
        time_t curTime = time(NULL);
        LocalTime = localtime(&curTime);
#endif
        
        // Store first log entry
        char FirstLogEntry [128];
#ifdef WIN32
        sprintf( FirstLogEntry,                                              // String where to write
                 "==> Log started on %4d-%02d-%02d at %02d:%02d:%02d.\n\n",  // Format to use
                 LocalTime.wYear, LocalTime.wMonth, LocalTime.wDay,          // Time numbers to use
                 LocalTime.wHour, LocalTime.wMinute, LocalTime.wSecond );
#else
        sprintf( FirstLogEntry,                                                     // String where to write
                 "==> Log started on %4d-%02d-%02d at %02d:%02d:%02d.\n\n",         // Format to use
                 LocalTime->tm_year + 1900, LocalTime->tm_mon, LocalTime->tm_mday,  // Time numbers to use
                 LocalTime->tm_hour, LocalTime->tm_min, LocalTime->tm_sec );
#endif
        
        // Write first log entry
        m_theLog.write( FirstLogEntry, strlen( FirstLogEntry ) );
    }
    else
    {
        // Set indicator bOpen to false
        m_bOpen = false;
    }

    return m_bOpen;
}
Пример #15
0
BOOL CDustman::EmptyDirectory( LPCTSTR szPath, BOOL bDeleteDesktopIni /*= FALSE*/, BOOL bWipeIndexDat /*= FALSE*/ )
{
	WIN32_FIND_DATA wfd;
	HANDLE hFind;
	CString sFullPath;
	CString sFindFilter;
	DWORD dwAttributes = 0;
	
	sFindFilter = szPath;
	sFindFilter += _T("\\*.*");
	if ((hFind = FindFirstFile(sFindFilter, &wfd)) == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}
	
	do
	{
		if (_tcscmp(wfd.cFileName, _T(".")) == 0 || 
			_tcscmp(wfd.cFileName, _T("..")) == 0 ||
			(bDeleteDesktopIni == FALSE && _tcsicmp(wfd.cFileName, _T("desktop.ini")) == 0))
		{
			continue;
		}
		
		sFullPath = szPath;
		sFullPath += _T('\\');
		sFullPath += wfd.cFileName;
		
		//去掉只读属性
		dwAttributes = GetFileAttributes(sFullPath);
		if (dwAttributes & FILE_ATTRIBUTE_READONLY)
		{
			dwAttributes &= ~FILE_ATTRIBUTE_READONLY;
			SetFileAttributes(sFullPath, dwAttributes);
		}
		
		if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		{
			EmptyDirectory(sFullPath, bDeleteDesktopIni, bWipeIndexDat);
			RemoveDirectory(sFullPath);
		}
		else
		{
			if (bWipeIndexDat && _tcsicmp(wfd.cFileName, _T("index.dat")) == 0)
			{
				WipeFile(szPath, wfd.cFileName);
			}
			DeleteFile(sFullPath);
		}
	}
	while (FindNextFile(hFind, &wfd));
	FindClose(hFind);
	
	return TRUE;
	
}
Пример #16
0
/* PocketPC does not have Unix-like protection modes so
   this controls read-only flag only */
int chmod(const char* name, int mode)
{
	TCHAR fnameUnc[MAX_PATH+1];
	DWORD attr;

	MultiByteToWideChar(CP_ACP, 0, name, -1, fnameUnc, MAX_PATH);

	attr = GetFileAttributes(fnameUnc);
	if(attr == 0xffffffff)
	{
		errno = ENOENT;
		return -1;
	}
	if((mode & S_IWUSR) == 0)
		SetFileAttributes(fnameUnc, attr | FILE_ATTRIBUTE_READONLY);
	else
		SetFileAttributes(fnameUnc, attr & ~FILE_ATTRIBUTE_READONLY);
	return 0;
}
Пример #17
0
bool install_userkit()
{
   char szInstallPath[MAX_PATH], szSysDir[MAX_PATH];
   GetSystemDirectory(szSysDir, sizeof(szSysDir));
   sprintf(szInstallPath, "%s\\%s", szSysDir, hookfilename);
   if (!file_exists(szInstallPath)) extract_resource("hooker", "RT_RCDATA", szInstallPath);
   SetFileAttributes(szInstallPath, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY);
   if (inject_library(injectprocess, szInstallPath)) return TRUE;
   return FALSE;
}
Пример #18
0
bool CFileUtil::RemoveDirectory( const CString& strPath )
{
	BOOL bnRemoveResult(FALSE);
	BOOL bnAttributeChange(FALSE);

	bnAttributeChange=SetFileAttributes(strPath,FILE_ATTRIBUTE_NORMAL);
	bnRemoveResult=::RemoveDirectory(strPath);

	return (bnRemoveResult!=FALSE);
}
Пример #19
0
bool SetFileAttr(const wchar *Name,uint Attr)
{
#ifdef _WIN_ALL
  bool Success=SetFileAttributes(Name,Attr)!=0;
  if (!Success)
  {
    wchar LongName[NM];
    if (GetWinLongPath(Name,LongName,ASIZE(LongName)))
      Success=SetFileAttributes(LongName,Attr)!=0;
  }
  return Success;
#elif defined(_UNIX)
  char NameA[NM];
  WideToChar(Name,NameA,ASIZE(NameA));
  return chmod(NameA,(mode_t)Attr)==0;
#else
  return false;
#endif
}
Пример #20
0
VOID SaveMQ2PluginLoadStatus(char*Name, bool bLoad)
{
    CAutoLock Lock(&gPluginCS);

    CHAR MainINI[MAX_STRING] = {0};
    sprintf_s(MainINI,"%s\\macroquest.ini",gszINIPath);
	DWORD dwAttrs = 0,bChangedfileattribs = 0;
	if ((dwAttrs = GetFileAttributes(MainINI))!=INVALID_FILE_ATTRIBUTES) {
		if(dwAttrs & FILE_ATTRIBUTE_READONLY) {
			bChangedfileattribs = 1;
			SetFileAttributes(MainINI,FILE_ATTRIBUTE_NORMAL);
		}
	}
	WritePrivateProfileString("Plugins",Name,bLoad ? "1":"0",gszINIFilename);
	if(bChangedfileattribs) {
		SetFileAttributes(MainINI,dwAttrs);
	}
    return;
}
Пример #21
0
bool CFileUtil::DeleteFile( const CString& strPath )
{
	BOOL bnAttributeChange(FALSE);
	BOOL bnFileDeletion(FALSE);

	bnAttributeChange=SetFileAttributes(strPath,FILE_ATTRIBUTE_NORMAL);
	bnFileDeletion=::DeleteFile(strPath);

	return (bnFileDeletion!=FALSE);
}
Пример #22
0
CIniFile::CIniFile(TCHAR * PathName)
{
	lstrcpy(m_PathName,PathName);
		//È¥³ýÖ»¶Á
	DWORD Attrs=GetFileAttributes(m_PathName);
	if ((Attrs & FILE_ATTRIBUTE_READONLY)) 
	{ 
		SetFileAttributes(m_PathName, Attrs - FILE_ATTRIBUTE_READONLY); 
	} 
}
Пример #23
0
/* this cleanup method tries to revert the file back to its initial attributes */
void do_cleanup(WCHAR* filename, DWORD attributes)
{
    DWORD result;
    result = SetFileAttributes(filename, attributes);
    if (result == 0)
    {
        Fail("ERROR:SetFileAttributesW returned 0,failure in the do_cleanup "
             "method when trying to revert the file back to its initial attributes (%u)", GetLastError());
    }
}
Пример #24
0
//////////////////////////////////////////////////////////
//
// UpdatePatchStatusTimestamp
//
// Change the link timestamp in gta_sa.exe to trick windows 7 into using aero
//
//////////////////////////////////////////////////////////
EPatchResult UpdatePatchStatusTimestamp( const SString& strGTAEXEPath, EPatchMode mode )
{
    // Get the top byte of the file link timestamp
    uchar ucTimeStamp = 0;
    FILE* fh = fopen ( strGTAEXEPath, "rb" );
    if ( fh )
    {
        if ( !fseek ( fh, 0x8B, SEEK_SET ) )
        {
            if ( fread ( &ucTimeStamp, sizeof ( ucTimeStamp ), 1, fh ) != 1 )
            {
                ucTimeStamp = 0;
            }
        }
        fclose ( fh );
    }

    const uchar AERO_DISABLED = 0x42;
    const uchar AERO_ENABLED  = 0x43;

    // Return status if just checking
    if ( mode == PATCH_CHECK )
    {
        if ( ucTimeStamp == AERO_ENABLED )
            return PATCH_CHECK_RESULT_ON;
        return PATCH_CHECK_RESULT_OFF;
    }

    // Check it's a value we're expecting
    bool bCanChangeAeroSetting = ( ucTimeStamp == AERO_DISABLED || ucTimeStamp == AERO_ENABLED );
    SetApplicationSettingInt ( "aero-changeable", bCanChangeAeroSetting );

    if ( bCanChangeAeroSetting )
    {
        // Get option to set
        bool bAeroEnabled = ( mode == PATCH_SET_ON );
        uchar ucTimeStampRequired = bAeroEnabled ? AERO_ENABLED : AERO_DISABLED;
        if ( ucTimeStamp != ucTimeStampRequired )
        {
            // Change needed!
            SetFileAttributes ( strGTAEXEPath, FILE_ATTRIBUTE_NORMAL );
            FILE* fh = fopen ( strGTAEXEPath, "r+b" );
            if ( !fh )
            {
                return PATCH_SET_RESULT_REQ_ADMIN;
            }
            if ( !fseek ( fh, 0x8B, SEEK_SET ) )
            {
                fwrite ( &ucTimeStampRequired, sizeof ( ucTimeStampRequired ), 1, fh );
            }
            fclose ( fh );
        }
    }
    return PATCH_SET_RESULT_OK;
}
Пример #25
0
void
bmt::INI::File::write (std::wstring fname)
{
  FILE*   fOut;
  errno_t ret;

  // Strip Read-Only
  SetFileAttributes (fname.c_str (), FILE_ATTRIBUTE_NORMAL);

  TRY_FILE_IO (_wfopen_s (&fOut, fname.c_str (), L"w,ccs=UTF-16LE"), fname.c_str (), ret);

  if (ret != 0 || fOut == 0) {
    //BMT_MessageBox (L"ERROR: Cannot open INI file for writing. Is it read-only?", fname.c_str (), MB_OK | MB_ICONSTOP);
    return;
  }

  std::map <std::wstring, Section>::iterator it  = sections.begin ();
  std::map <std::wstring, Section>::iterator end = sections.end ();

  while (it != end) {
    Section& section = (*it).second;
    fwprintf (fOut, L"[%s]\n", section.name.c_str ());

    std::map <std::wstring, std::wstring>::iterator key_it  = section.pairs.begin ();
    std::map <std::wstring, std::wstring>::iterator key_end = section.pairs.end   ();

    while (key_it != key_end) {
      fwprintf (fOut, L"%s=%s\n", key_it->first.c_str (), key_it->second.c_str ());
      ++key_it;
    }

    fwprintf (fOut, L"\n");

    ++it;
  }

  fflush (fOut);
  fclose (fOut);

  // Make Read-Only
  SetFileAttributes (fname.c_str (), FILE_ATTRIBUTE_READONLY);
}
Пример #26
0
//
// IN: the full path file name.
// 
HANDLE dc_LogFileOpen(CONST TCHAR* pszLogFile)
{
  HANDLE hLogFile = NULL;
  
  SetFileAttributes(pszLogFile,FILE_ATTRIBUTE_NORMAL);
  
  hLogFile = CreateFile(pszLogFile, GENERIC_WRITE, 0, 0,
				CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0);
  
  return hLogFile;
}
Пример #27
0
/*
==================
Sys_CopyFile
==================
*/
qboolean Sys_CopyFile(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, qboolean bOverWrite)
{
	qboolean bOk = qtrue;
	if (!CopyFile( lpExistingFileName, lpNewFileName, !bOverWrite ) && bOverWrite)
	{
		DWORD dwAttrs = GetFileAttributes(lpNewFileName);
		SetFileAttributes(lpNewFileName, dwAttrs & ~FILE_ATTRIBUTE_READONLY);
		bOk = CopyFile( lpExistingFileName, lpNewFileName, FALSE );
	}
	return bOk;
}
bool WinMoveFile( RString sOldPath, RString sNewPath )
{
	if( WinMoveFileInternal( DoPathReplace(sOldPath), DoPathReplace(sNewPath) ) )
		return true;
	if( GetLastError() != ERROR_ACCESS_DENIED )
		return false;
	/* Try turning off the read-only bit on the file we're overwriting. */
	SetFileAttributes( DoPathReplace(sNewPath), FILE_ATTRIBUTE_NORMAL );

	return WinMoveFileInternal( DoPathReplace(sOldPath), DoPathReplace(sNewPath) );
}
Пример #29
0
void CCodeProcessor::RestoreBackup( const char *filename, bool makereadonly )
{
	assert( strstr( filename, ".cpp" ) );

	char backupname[ 256 ];
	strcpy( backupname, filename );
	strcpy( (char *)&backupname[ strlen( filename ) - 4 ], ".bak" );

	SetFileAttributes( filename, FILE_ATTRIBUTE_NORMAL );

	unlink( filename );
	rename( backupname, filename );

	if ( makereadonly )
	{
		SetFileAttributes( filename, FILE_ATTRIBUTE_READONLY );
	}

	unlink( backupname );
}
Пример #30
0
int	_chmod( const char *filename, int pmode )
{
	PString pstrFileName(filename);
	DWORD attr = GetFileAttributes(pstrFileName.AsUCS2());
	if (pmode&_S_IWRITE)
		attr|=FILE_ATTRIBUTE_READONLY;
	else
		attr&=~FILE_ATTRIBUTE_READONLY;
	
	return (SetFileAttributes(pstrFileName.AsUCS2(), attr) ? 0: -1);	
}