seautil.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: seautil.c,v 1.17 2002/08/06 20:09:49 dallen Exp $
__________________________________________________________________________*/

#include "DecodeStub.h"

void SEAReboot(void)
{
	BOOL IsNT;
	OSVERSIONINFO osid;

	memset(&osid,0x00,sizeof(OSVERSIONINFO));

	osid.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
	GetVersionEx (&osid);   
	IsNT=(osid.dwPlatformId == VER_PLATFORM_WIN32_NT);

	if(IsNT)
	{
		TOKEN_PRIVILEGES TpNew;
		HANDLE           hToken;
		LUID             ShutDownValue;

		OpenProcessToken( GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES |
			TOKEN_QUERY, &hToken);
		LookupPrivilegeValue( (LPSTR)NULL, SE_SHUTDOWN_NAME, &ShutDownValue);

		TpNew.PrivilegeCount = 1;
		TpNew.Privileges[0].Luid = ShutDownValue;
		TpNew.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

		AdjustTokenPrivileges( hToken, FALSE, &TpNew, sizeof(TpNew),
			(TOKEN_PRIVILEGES *)NULL, (DWORD *)NULL);
	}

	ExitWindowsEx(EWX_REBOOT,0);
}

#define RUNREGPATH "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"

BOOL WriteRunRegKey(char *filename)
{
	HKEY hKey;
	DWORD dw;

	if(RegCreateKeyEx (	HKEY_LOCAL_MACHINE, 
							RUNREGPATH, 
							0, 
							NULL,
							REG_OPTION_NON_VOLATILE, 
							KEY_ALL_ACCESS, 
							NULL, 
							&hKey, 
							&dw)==ERROR_SUCCESS)
	{
		RegSetValueEx (	hKey, 
						"Run PGP SEA Installer on Reboot", 
						0, 
						REG_SZ, 
						(LPBYTE)filename, 
						strlen(filename)+1);

		RegCloseKey (hKey);

		return TRUE;
	}

	return FALSE;
}

BOOL DeleteRunRegKey(void)
{
	HKEY hKey;

	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
						RUNREGPATH, 
						0, 
						KEY_ALL_ACCESS, 
						&hKey) == ERROR_SUCCESS) 
	{
		RegDeleteValue( hKey, 
			"Run PGP SEA Installer on Reboot");

		RegCloseKey (hKey);

		return TRUE;
	}

	return FALSE;
}

#define SEAREGPATH "Software\\PGP Corporation\\PGP"

BOOL WriteRebootRegKey(DWORD dwReboot)
{
	HKEY hKey;
//	DWORD dw;

//	if(RegCreateKeyEx (	HKEY_LOCAL_MACHINE, 
//							SEAREGPATH, 
//							0, 
//							NULL,
//							REG_OPTION_NON_VOLATILE, 
//							KEY_ALL_ACCESS, 
//							NULL, 
//							&hKey, 
//							&dw)==ERROR_SUCCESS)
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
						SEAREGPATH, 
						0, 
						KEY_ALL_ACCESS, 
						&hKey) == ERROR_SUCCESS) 
	{
		RegSetValueEx (	hKey, 
						"Reboot", 
						0, 
						REG_DWORD, 
						(LPBYTE)&dwReboot, 
						sizeof(dwReboot));
		RegCloseKey (hKey);

		return TRUE;
	}

	return FALSE;
}

#define DELPGPREGPATH "Software\\PGP Corporation"

BOOL DeletePGPRegKey(void)
{
	HKEY hKey;

	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
						DELPGPREGPATH, 
						0, 
						KEY_ALL_ACCESS, 
						&hKey) == ERROR_SUCCESS) 
	{
		RegDeleteKey( hKey, 
			"PGP");

		RegCloseKey (hKey);

		return TRUE;
	}

	return FALSE;
}

DWORD ReadRebootRegKey(void)
{
	DWORD dwReboot;
	HKEY hKey;

	dwReboot=0;

	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
						SEAREGPATH, 
						0, 
						KEY_ALL_ACCESS, 
						&hKey) == ERROR_SUCCESS) 
	{
		DWORD  size = sizeof(dwReboot);
		DWORD  type = 0;

		RegQueryValueEx(hKey, 
					"Reboot", 
					0, 
					&type, 
					(LPBYTE)&dwReboot, 
					&size);
		RegCloseKey (hKey);
	}

	return dwReboot;
}
/*

// Fake routine since we aren't using compression in SEA
void Deflate_Decompress(void *gpi)
{
	int c;

	while((c=getc_buffer(gpi))!=EOF)
	{
		putc_buffer(c,gpi);
	}
}

*/
BOOL ExecProgram(HWND hwnd,
				 char *prefpath,
				 char *filename)
{
	char *name;
	char Message[100];
	int error;
	SHELLEXECUTEINFO sei;
//	PROCESS_INFORMATION ProcessInformation;
//	STARTUPINFO StartupInfo;
	char *cmdline,*oldcmd;
	BOOL bQuote;

	bQuote=FALSE;

	error=0;

	oldcmd=cmdline=GetCommandLine();
	while(((*cmdline!=0)&&(*cmdline!=' '))||
		  ((*cmdline==' ')&&(bQuote)))
	{
		if(*cmdline=='\"')
		{
			bQuote=!bQuote;
		}

		cmdline++;
	}

	name=(char *)malloc(strlen(prefpath)+strlen(filename)+strlen(cmdline)+1);

	if(name!=0)
	{
		strcpy(name,prefpath);
		strcat(name,filename);
//		strcat(name,cmdline); command line goes in lpParameters

//		MessageBox(hwnd,name,oldcmd,MB_OK|MB_ICONINFORMATION|MB_SETFOREGROUND);

/*		memset( &StartupInfo , 0x00, sizeof(STARTUPINFO) );
		memset( &ProcessInformation , 0x00, sizeof(PROCESS_INFORMATION) );

		StartupInfo.cb = sizeof(StartupInfo);
		StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
		StartupInfo.wShowWindow = SW_SHOWNORMAL;

		error = CreateProcess(NULL,(LPTSTR)name, NULL,NULL,FALSE,
			NORMAL_PRIORITY_CLASS,NULL,NULL,
			(LPSTARTUPINFO)&StartupInfo,
			(LPPROCESS_INFORMATION)&ProcessInformation);
*/
		memset(&sei,0x00,sizeof(SHELLEXECUTEINFO));

		sei.cbSize			= sizeof(SHELLEXECUTEINFO);
		sei.fMask			= SEE_MASK_NOCLOSEPROCESS|SEE_MASK_FLAG_DDEWAIT ;
		sei.hwnd			= NULL;
		sei.lpDirectory		= NULL;
		sei.hInstApp		= NULL;

		sei.nShow			= SW_SHOW;
		sei.lpVerb			= "open";
		sei.lpFile			= name;
		sei.lpParameters	= cmdline;

		// We use the shell now since it catches termserver errors
		error=ShellExecuteEx (&sei);

		if(error==0)
		{ 
			DWORD gle;

			gle=GetLastError();

			if(gle!=1223) // Returned by TS, don't show error
			{
				sprintf(Message,"Could not start executable. Error #%d.",gle);

			//	LoadString (g_hinst, IDS_CANTSTARTEXE, Message, sizeof(Message));
				
				MessageBox(hwnd,Message,
					name,
					MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);
			}

			free(name);

			return FALSE;
		}

		free(name);
	}

	// Wait for process to end
	WaitForSingleObject(sei.hProcess,INFINITE);
	CloseHandle(sei.hProcess);

	return TRUE;
}
/*
BOOL MakeAdminFile(HWND hwnd,
				  FILE *fin,
				  char *prefpath,
				  FILELIST **p_fl,
				  char *filename,
				  DWORD offset,
				  DWORD size)
{
	char *buf;
	FILE *fout;
	char Message[100];
	char name[MAX_PATH+1];

	// No pref file to create
	if(offset==0)
		return TRUE;

	buf=(char *)malloc(size);

	if(buf==NULL)
		return FALSE;

	memset(buf,0x00,size);

	fseek(fin, offset, SEEK_SET );
	fread(buf,1,size,fin);

	strcpy(name,prefpath);
	strcat(name,filename);

	fout=fopen(name,"wb");

	if(fout==0)
	{
		LoadString (g_hinst, IDS_CANTCREATEADMIN, Message, sizeof(Message));

		MessageBox(hwnd,Message,
			name,
			MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);

		return FALSE;
	}
	else
	{
		fwrite(buf,1,size,fout);
		fclose(fout);

		// Remember file so we can delete it later
		FileListFromFile(p_fl,name,NULL);
	}

	free(buf);

	return TRUE;
}
*/
PGPError SEAGetTempPath(char *szPrefixPath)
{
	char HexString[100];
	int ret_val;

	// Note that GetTempPath returns a path with a backslash
	if(GetTempPath(MAX_PATH,szPrefixPath ) == 0)
	{	
		return kPGPError_UnknownError;
	}

	srand( (unsigned)time( NULL ) );
	sprintf(HexString,"%x",rand()*rand());
	HexString[5]=0; // Truncate at length 5

	strcat(szPrefixPath,"PGP");
	strcat(szPrefixPath,HexString);
	strcat(szPrefixPath,"\\");

	ret_val=_mkdir(szPrefixPath);

	if(ret_val!=0)
	{
		return kPGPError_UnknownError;
	}

	return kPGPError_NoErr;
}

void SEACreateAndExec(char *szFilename,
						 HWND hwnd,
						 SDAHEADER *SDAHeader,
						 char *szPrefixPath,
						 FILELIST **fl)
{
	char PrefPath[MAX_PATH+1];
	BOOL FoundProcess;
	HWND hwndWin;
	DWORD dwProcID;
	HANDLE hProcess;
//	FILE *fin;

	// Clear reboot registry key to zero so installer can set it
	WriteRebootRegKey(0);

	ShowWindow(hwnd,SW_HIDE);

	strcpy(PrefPath,szPrefixPath);

	// Kludge for PGPeros, which only has one file
	if(SDAHeader->NumFiles==1) 
	{
		// ExecProgram waits for it to close
		ExecProgram(hwnd,
				PrefPath,
				"PGPeros.exe");

		return;
	}

	strcat(PrefPath,"Disk1\\");
/*
	fin=fopen(szFilename,"rb");

	MakeAdminFile(hwnd,fin,PrefPath,fl,
			"PGPadmin.dat",
			SDAHeader->AdminOffset,
			SDAHeader->AdminSize);
	MakeAdminFile(hwnd,fin,PrefPath,fl,
			"PGPPrefs.txt",
			SDAHeader->ClientOffset,
			SDAHeader->ClientSize);
	MakeAdminFile(hwnd,fin,PrefPath,fl,
			"PGPnetPrefs.txt",
			SDAHeader->NetOffset,
			SDAHeader->NetSize);
	MakeAdminFile(hwnd,fin,PrefPath,fl,
			"setup.ini",
			SDAHeader->SetupOffset,
			SDAHeader->SetupSize);

	fclose(fin);
*/
	// Exec setup.exe and wait for it to close
	ExecProgram(hwnd,
				PrefPath,
				"Setup.exe");

	// Wait for setup.exe spawned processes to close
	do
	{
		FoundProcess=FALSE;

		// Main installshield program
		hwndWin=FindWindow("InstallShield_Win",NULL);
		
		if(hwndWin!=NULL)
		{
			FoundProcess=TRUE;

			GetWindowThreadProcessId(hwndWin,&dwProcID);
			hProcess=OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
			// Wait for process to end
			WaitForSingleObject(hProcess,INFINITE);
			CloseHandle(hProcess);
		}

		// Is delete cleanup program
		hwndWin=FindWindow("isdelete",NULL);
		
		if(hwndWin!=NULL)
		{
			FoundProcess=TRUE;

			GetWindowThreadProcessId(hwndWin,&dwProcID);
			hProcess=OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
			// Wait for process to end
			WaitForSingleObject(hProcess,INFINITE);
			CloseHandle(hProcess);
		}
	} while(FoundProcess);
}

int SEADoInstallerCommand(void)
{
	DWORD dwReboot;
	char filename[MAX_PATH+1];
	char shortfilename[MAX_PATH+1];
	int iReturn = 1;

	// Basically run once. We delete after completion.
	DeleteRunRegKey();

	// See if the installer wants us to reboot or relaunch
	dwReboot=ReadRebootRegKey();

	switch(dwReboot)
	{
		case 0:
		{
			//no key exists
			iReturn = -1;
			break;
		}

		case 1:
		{
			SEAReboot();
			break;
		}

		case 2:
		{
			ZeroMemory (filename, MAX_PATH+1);
			ZeroMemory (shortfilename, MAX_PATH+1);
			GetModuleFileName(NULL, filename, MAX_PATH);
			GetShortPathName(filename, shortfilename, MAX_PATH);
			strcat(shortfilename," rebooted");
			WriteRunRegKey(shortfilename);
			SEAReboot();
			break;
		}

		case 3:
		{
			DeletePGPRegKey();
			SEAReboot();
			break;
		}

		case 4:
		{
			//ePO build, needs reboot.
			iReturn = 1;
			break;
		}

		case 5:
		{
			//ePO build, no reboot.
			iReturn = 0;
			break;
		}
	}
	return iReturn;
}

/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/