prinstallroutines.cpp

虚拟打印机

/*
 *
 * prinstallroutines.cpp
 *
 *
   Copyright (C) 2006 Michael H. Overlin

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   
   Contact at [e-mail]
 */

#include "prinstallroutines.h"

#include "debug.h"
#include "myfilemap.h"
#include "printResizerCommon.h"
#include "prutils.h"
#include "spoolutils.h"
#include "utils.h"
#include "workerthread.h"

#include <windows.h>
//#include "C:\Program Files\Microsoft Platform SDK\Include\lzexpand.h"
extern "C" {
INT
APIENTRY
LZOpenFileW(
	LPWSTR,
	LPOFSTRUCT,
	WORD
	);
#define LZOpenFile  LZOpenFileW

LONG
APIENTRY
LZSeek(
	INT,
	LONG,
	INT
	);

INT
APIENTRY
LZRead(
	INT,
	LPSTR,
	INT
	);

VOID
APIENTRY
LZClose(
	INT
	);
}

#include <tchar.h>
#include <strsafe.h>
#include <shlobj.h>
#include <shellapi.h>

// ***********************************************************************************************
// **  MODULE PRIVATE PROTOTYPES  ****************************************************************
// ***********************************************************************************************

LPTSTR GetInstallFolderPath(const int clsidFolderParent, LPCTSTR lptstrFolderName) ;
// A NULL TERMINATED LIST WITH DIRECTORY NAME FIRST
BOOL DoUninstallFileList(LPTSTR *plist) ;
BOOL DoUninstallAlternateFileList(LPCTSTR lptstr) ;

// *************************************************************************************************
// **  class InstallProgressDialog  ****************************************************************
// *************************************************************************************************

InstallProgressDialog::InstallProgressDialog(HINSTANCE hinst, const tstring& tstrTitle, const tstring& tstrJob, IN BOOL bHideCancel)
: ProgressDialogWindow(hinst, tstrTitle, tstrJob, bHideCancel) 
{
	m_pwt = NULL;
}

InstallProgressDialog::~InstallProgressDialog() {
	// NOTHING TO DO
}

void InstallProgressDialog::SetInstallThread(WorkerThread* pwt) {
	m_pwt = pwt;
}

// protected:  class InstallProgressDialog  
BOOL InstallProgressDialog::EndDialog(INT_PTR nResult) {
	if (m_pwt != NULL) {
		m_pwt->PeekMessagesUntilTerminate(::WorkerThread::eDefaultTimeSliceMS, INFINITE);
	}
	return ProgressDialogWindow::EndDialog(nResult);
}

// *************************************************************************************************
// **  class InstallStatusString   *****************************************************************
// *************************************************************************************************

InstallStatusString::InstallStatusString(void) {
	m_bTerminalError = FALSE;
	m_bUserCanceled = FALSE;
	m_bAllDone = FALSE;
}

InstallStatusString::~InstallStatusString() {
	// NOTHING TO DELETE
}

void InstallStatusString::SetWorkInProgress(IN LPCTSTR lptstrWorkInProgress) {
	m_tstrWorkInProgress = lptstrWorkInProgress;
}

void InstallStatusString::SetAllDone(void) {
	m_bAllDone = TRUE;
}

void InstallStatusString::SetErrorItem(IN LPCTSTR lptstrErrorItem, IN BOOL bTerminal) {
	m_bTerminalError = m_bTerminalError || bTerminal;

	if (m_tstrErrorItems.length() == 0) {
		m_tstrErrorItems = lptstrErrorItem;
	} else {
		m_tstrErrorItems += TEXT(";  ");
		m_tstrErrorItems += lptstrErrorItem;
	}
}

void InstallStatusString::SetUserCanceled(void) {
	m_bUserCanceled = TRUE;
}

const tstring& InstallStatusString::GetStatusString(void) {
	if (m_bUserCanceled) {
		m_tstrStatusString = TEXT("USER CANCELED.  Aborting.\n");
		m_tstrStatusString += m_tstrWorkInProgress;
	} else {
		m_tstrStatusString = m_tstrWorkInProgress;
		if (m_tstrErrorItems.length() != 0) {
			m_tstrStatusString += TEXT("\nThere have been errors:\n");
			m_tstrStatusString += m_tstrErrorItems;
			if ( m_bTerminalError ) {
				m_tstrStatusString += TEXT("\n\nAborting.");
			} else {
				m_tstrStatusString += TEXT("\n\nAttempting to continue."); 
			}
		}
	} 
	return m_tstrStatusString;

	//if (m_bUserCanceled) {
	//	m_tstrStatusString = TEXT("USER CANCELED.  Aborting.");
	//} else {
	//	m_tstrStatusString = m_tstrWorkInProgress;
	//	if (m_tstrErrorItems.length() != 0) {
	//		m_tstrStatusString += TEXT("\n\n");
	//		if ( m_bTerminalError ) {
	//			m_tstrStatusString += TEXT("Aborting.");
	//		} else {
	//			m_tstrStatusString += TEXT("Attempting to continuing."); 
	//		}
	//		m_tstrStatusString += TEXT("  There have been errors:\n");
	//		m_tstrStatusString += m_tstrErrorItems;
	//	} else if (m_bAllDone) {
	//		// DEBUG - FIX -- THE PROGRESS DIALOG APPENDS "DONE" CURRENTLY
	//		// DEBUG - FIX -- MAKE THE STATUS WINDOW BIGGER
	//		m_tstrStatusString = TEXT(".");
	//	}
	//}
	//return m_tstrStatusString;
}

// ***********************************************************************************************
// **  MODULE PUBLIC ROUTINES  *******************************************************************
// ***********************************************************************************************

BOOL DoAllUnInstall(ProgressDialogWindow *pdw, InstallStatusString *piss) {
	BOOL bError = FALSE;
	// NOTE WE SHOULD LOOP THRU THE VARIOUS OS TYPES, NOT JUST THE LOCAL MACHINE
	// IN CASE THE DRIVERS WERE INSTALLED FOR ADDITIONAL OS'S
	// FOR THOSE OTHER OS'S WE SHOULDN'T NEED TO CHECK FOR PRINTERS THAT USE THEM ... UNLESS THERE ARE
	// SERVER COMPLICATIONS

	DWORD dwcPrinterDrivers;
	::PDRIVER_INFO_3 pinfoDrivers = ::GetInstalledPrinterDrivers(dwcPrinterDrivers);
	if (pinfoDrivers != NULL) {
		for(uint kDriver = 0; kDriver < dwcPrinterDrivers; ++kDriver) {
		   // IS THIS DRIVER OURS?
		   if ( ::lstrcmp( pinfoDrivers[kDriver].pName, PRINTRESIZER_DRIVERNAME) == 0 ) {
				DWORD dwcPrinter;
				::PPRINTER_INFO_2 pinfoPrinters = ::GetInstalledPrintersInfo2(&dwcPrinter);
				if (pinfoPrinters != NULL) {
					// FIND ALL PRINTERS THAT USE THIS DRIVER
					for(uint kPrinter = 0; kPrinter < dwcPrinter; ++kPrinter) {
						if ( ::lstrcmp(pinfoPrinters[kPrinter].pDriverName, pinfoDrivers[kDriver].pName) == 0) {
							// DELETE THIS PRINTER
							HANDLE hPrinter = NULL;
							// IF WE'RE INSIDE DRIVER CODE, MAYBE WE SHOULD USE REVERTTOSELF
							::PRINTER_DEFAULTS pd = { NULL, NULL, PRINTER_ALL_ACCESS };
							::OpenPrinter(pinfoPrinters[kPrinter].pPrinterName, &hPrinter, &pd);
							if (hPrinter != NULL) {
								// DELETE FIRST ANY JOBS IT HAS PENDING
								if (pinfoPrinters[kPrinter].cJobs > 0) {
									DWORD dwcJobs;
									::PJOB_INFO_1 pinfoJobs = ::GetPrintersJobs(hPrinter, pinfoPrinters[kPrinter].cJobs, dwcJobs);
									if (pinfoJobs != NULL) {
										for(uint kJob = 0; kJob < dwcJobs; ++kJob) {
											DWORD dwDeleteCommand = ::GetPrinterJobDeletionCommand();
											if (! ::SetJob(hPrinter, pinfoJobs[kJob].JobId, 1, (LPBYTE) & pinfoJobs[kJob], dwDeleteCommand) ) {
												bError = TRUE;
											}
										} // for(uint kJob = 0; kJob < dwcJobs; ++kJob) 
										free(pinfoJobs);
									} else { // if (pinfoJobs != NULL) 
										bError = TRUE;
									}
								} // if (pinfoPrinters[k].cJobs > 0) 
								// NOW WE SHOULD BE ABLE TO DELETE THE PRINTER
								if (! ::DeletePrinter(hPrinter)) {
									bError = TRUE;
								}
								::ClosePrinter(hPrinter);
							} else { // if (hPrinter != NULL)
								bError = TRUE;
							}
						} // if ( ::lstrcmp(pinfoPrinters[kPrinter].pDriverName, pinfoDrivers[kDriver].pName) )
					} // for(uint kPrinter = 0; kPrinter < dwcPrinter; ++kPrinter)
					free(pinfoPrinters);
				} else { // if (pinfoPrinters != NULL)
					bError = TRUE;
				}
			} // if ( ::lstrcmp( pinfoDrivers[kDriver].pName, PRINTRESIZER_DRIVERNAME) == 0 ) 
		} // for(uint kDriver = 0; kDriver < dwcPrinterDrivers; ++k) 

		// ALL PRINTERS THAT USE THIS DRIVER SHOULD NOW BE DELETED
		for(uint kDriver = 0; kDriver < dwcPrinterDrivers; ++kDriver) {
			// IS THIS DRIVER OURS?
			if ( ::lstrcmp( pinfoDrivers[kDriver].pName, PRINTRESIZER_DRIVERNAME) == 0 ) {
				if (! ::DeletePrinterDriver(NULL, NULL, pinfoDrivers[kDriver].pName)) {
					bError = TRUE;
				}

				if (!::MyDeleteFile(pinfoDrivers[kDriver].pConfigFile )) {
					bError = TRUE;
				}
				if (!::MyDeleteFile(pinfoDrivers[kDriver].pDataFile )) {
					bError = TRUE;
				}
				if (!::MyDeleteFile(pinfoDrivers[kDriver].pDriverPath)) {
					bError = TRUE;
				}
				if (!::MyDeleteFile(pinfoDrivers[kDriver].pHelpFile)) {
					bError = TRUE;
				}

				// DELETE ALL THE DRIVERS DEPENDENT FILES
				// ACCORDING TO DOCS THIS SHOULD INCLUDE THE ABOVE, BUT EXAMINATION OF
				// ACTUAL DATA SETS SHOWS THEY ARE DISTINCT
				LPTSTR lptstrDependentFile = pinfoDrivers[kDriver].pDependentFiles;
				if (lptstrDependentFile != NULL) {
					DWORD dwcLen = 0;
					while ( (dwcLen = ::lstrlen(lptstrDependentFile)) != 0 ) {
						if (!::MyDeleteFile(lptstrDependentFile)) {
							bError = TRUE;
						}
						lptstrDependentFile += dwcLen + 1;
					}
				}
			} // if ( ::lstrcmp( pinfoDrivers[kDriver].pName, PRINTRESIZER_DRIVERNAME) == 0 ) 
		} // for(uint kDriver = 0; kDriver < dwcPrinterDrivers; ++k) 

		free(pinfoDrivers);
	} else { // if (pinfoDrivers != NULL) 
		bError = TRUE;
	}

	// NOW DELETE OUR PRINTPROCESSORS
	::DeletePrintProcessor(NULL, NULL, PRINTRESIZER_PRINTPROCESSOR_NAME);
	LPTSTR lptstrPrintProcessorDirectory = MyGetPrintProcessorDirectory();
	if (lptstrPrintProcessorDirectory != NULL) {
		LPTSTR lptstr = ::MakeFullFileName(lptstrPrintProcessorDirectory, PRINTRESIZER_PRINTPROCESSOR_FILENAME);
		if (lptstr != NULL) {
			if (! ::DeleteFile(lptstr)) {
				bError = TRUE;
			}
			free(lptstr);
		} else {
			// OUT OF MEMORY ERROR
			bError = TRUE;
		}
		free(lptstrPrintProcessorDirectory);
	} else { 
		// ERROR GETTING PRINTPROCESSOR DIRECTORY
		bError = TRUE;
	}

	::DoLinksFolderCommand(TEXT("close"));

	LPTSTR *plptstrLinks = ::GetLinkFileNames();
	if (plptstrLinks != NULL) {
		if (! ::DoUninstallFileList(plptstrLinks)) {
			// THERE WAS AN ERROR DELETING THE LINKS AND FOLDER
			bError = TRUE;
		}
		::MyFreeStringPtrs(plptstrLinks);
	} else {
		// ERROR GETTING NAMES OF LINKS DIRECTORY AND LINK NAMES
		bError = TRUE;
	}

	LPTSTR *plptstrAddProgs = ::GetAdditionalProgFileNames();
	if (plptstrAddProgs != NULL) {
		if (! ::DoUninstallFileList(plptstrAddProgs)) {
			// THERE WAS AN ERROR DELETING THE ADITIOANL PROGRAMS AND FOLDER
			bError = TRUE;
		}
		::MyFreeStringPtrs(plptstrAddProgs);
	} else {
		// ERROR GETTING NAMES OF ADDITIONAL PROGRAMS DIRECTORY AND FILE NAMES
		bError = TRUE;
	}

	return !bError;
} // BOOL DoAllUnInstall(void) 

#if 0
LPTSTR MyGetPrinterDriverDirectory(void) {
	LPTSTR lptstrRetValue = NULL;
	DWORD dwCbNeeded;
	::GetPrinterDriverDirectory(NULL, NULL, 1, 0, 0, &dwCbNeeded);
	if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
		lptstrRetValue = (LPTSTR) malloc(dwCbNeeded);
		if (lptstrRetValue != NULL) {
			if ( ! ::GetPrinterDriverDirectory(NULL, NULL, 1, (LPBYTE) lptstrRetValue, dwCbNeeded, &dwCbNeeded)) {
				free(lptstrRetValue);
				lptstrRetValue = NULL;
			}
		}
	} 
	return lptstrRetValue;
}
#endif

//BOOL GetReosourceSize(IN HINSTANCE hinst, IN WORD wID, IN WORD wIDType, OUT DWORD& dwCb) {
//	BOOL bRetValue = FALSE;
//	HRSRC hResInfo = ::FindResource(hInst, MAKEINTRESOURCE(wIDResource), MAKEINTRESOURCE(wIDType));
//	if (hResInfo != NULL) {
//		dwCb = ::SizeofResource(hInst, hResInfo);
//		bRetValue = TRUE;
//	}
//	return bRetValue;
//}

BOOL WriteResourceToFile(HINSTANCE hInst, LPCTSTR lptstrFileName, WORD wIDResource, WORD wIDType/*, const ::SYSTEMTIME* psystimeStamp*/) {
	BOOL bRetValue = FALSE;
	HRSRC hResInfo = ::FindResource(hInst, MAKEINTRESOURCE(wIDResource), MAKEINTRESOURCE(wIDType));
	if (hResInfo != NULL) {
		HGLOBAL hgRes = ::LoadResource(hInst, hResInfo);
		if (hgRes != NULL) {
			void *pvRes = ::LockResource(hgRes);
			if (pvRes != NULL) {
				DWORD dwcRes = ::SizeofResource(hInst, hResInfo);
				try {
					::MyFileReadWriteMap mfm;
					if (mfm.Create(lptstrFileName, dwcRes)) {
						::CopyMemory( mfm.GetBasePtr(), pvRes, dwcRes );
						bRetValue = TRUE;
					}
				} catch( ... ) {
					bRetValue = FALSE;
				}

				//HANDLE hFile = ::CreateFile(lptstrFileName, 
				//	GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
				//if (hFile != INVALID_HANDLE_VALUE) {
				//	try {
				//		DWORD dwcWritten;
				//		if ( ::WriteFile(hFile, pvRes, dwcRes, &dwcWritten, 0)) {
				//			if (dwcWritten == dwcRes) {
				//				bRetValue = TRUE;
				//			} 
				//		}
				//		//if (bRetValue) {
				//		//	if (psystimeStamp != NULL) {
				//		//		::FILETIME ft;
				//		//		if (::SystemTimeToFileTime(psystimeStamp, &ft)) {
				//		//			if (! ::SetFileTime(hFile, &ft, NULL, &ft)) {
				//		//				bRetValue = FALSE;
				//		//			}
				//		//		} else {
				//		//			bRetValue = FALSE;
				//		//		}
				//		//	}
				//		//}
				//		CloseHandle(hFile);
				//	} catch( ...) {
				//		CloseHandle(hFile);
				//	}
				//}
				UnlockResource(hgRes);
			}
			::FreeResource(hgRes);
		}
	}

	if (!bRetValue) {
		try { ::DeleteFile(lptstrFileName); } catch (...) {}
	}

	return bRetValue;
}

BOOL StampFileTime(LPCTSTR lptstrFileName, const ::SYSTEMTIME& st) {
	BOOL bRetValue = FALSE;
	//HANDLE hFile = CreateFile(
	//	lptstrFileName,
	//	FILE_APPEND_DATA,   
	//	FILE_SHARE_READ,    
	//	NULL,               
	//	OPEN_EXISTING,        
	//	FILE_ATTRIBUTE_NORMAL, 
	//	NULL
	//	);             
	HANDLE hFile = ::CreateFile(
		lptstrFileName, 
		GENERIC_WRITE, 
		0, 
		0, 
		OPEN_EXISTING, 
		FILE_ATTRIBUTE_NORMAL, 
		0
		);

	if (hFile != INVALID_HANDLE_VALUE) {
		try {
			::FILETIME ft;
			if (::SystemTimeToFileTime(&st, &ft)) {
				if (::SetFileTime(hFile, &ft, NULL, &ft)) {
					bRetValue = TRUE;
				}
			} 
			::CloseHandle(hFile);
		} catch( ... ) {
			::CloseHandle(hFile);
		}
	}

	return bRetValue;
}