prinstallroutines.cpp

虚拟打印机

BOOL DecompressResource(IN HINSTANCE hInst, IN WORD wIDResource, IN WORD wIDType, OUT PVOID& pv, OUT DWORD& dwCb) {
	BOOL bRetValue = FALSE;
	TCHAR atstrTempFileName[MAX_PATH+1];
	if (::GetFullTempFileName(atstrTempFileName, ARRCOUNT(atstrTempFileName))) {
		if (::WriteResourceToFile(hInst, atstrTempFileName, wIDResource, wIDType/*, psystimeStamp*/)) {
			try {
				::OFSTRUCT of;
				INT iFile = ::LZOpenFile(atstrTempFileName, &of, OF_READ);
				if (iFile >= 0) {
					PVOID pvTemp = NULL;
					try {
						LONG lCb = ::LZSeek(iFile, 0, 2);
						if (lCb > 0 && lCb <= INT_MAX) {
							if (::LZSeek(iFile, 0, 0) == 0) {
								pvTemp = malloc(lCb);
								if (pvTemp != NULL) {
									INT iRead = ::LZRead(iFile, (LPSTR) pvTemp, (INT) lCb) ;
									if (iRead == lCb) {
										pv = pvTemp;
										pvTemp = NULL;
										dwCb = lCb;
										bRetValue = TRUE;
									}
								}
							}
						}
						::LZClose(iFile);
						if (pvTemp != NULL) {
							free(pvTemp);
						}
					} catch( ... ) {
						::LZClose(iFile);
						if (pvTemp != NULL) {
							free(pvTemp);
						}
					}
				}
			} catch( ... ) {
			}
			try { ::DeleteFile(atstrTempFileName); } catch(...) {}
		}
	}
	return bRetValue;
}


BOOL WriteCompressedResourceToFile(HINSTANCE hInst, LPCTSTR lptstrFileName, 
								   WORD wIDResource, WORD wIDType/*, const ::SYSTEMTIME* psystimeStamp*/) {
	BOOL bRetValue = FALSE;
	TCHAR atstrTempFileName[MAX_PATH+1];
	if (::GetFullTempFileName(atstrTempFileName, ARRCOUNT(atstrTempFileName))) {
		if (::WriteResourceToFile(hInst, atstrTempFileName, wIDResource, wIDType/*, psystimeStamp*/)) {
			try {
				::OFSTRUCT of;
				INT iFile = ::LZOpenFile(atstrTempFileName, &of, OF_READ);
				if (iFile >= 0) {
					try {
						LONG lCb = ::LZSeek(iFile, 0, 2);
						if (lCb > 0 && lCb <= INT_MAX) {
							if (::LZSeek(iFile, 0, 0) == 0) {
								try {
									::MyFileReadWriteMap mfm;
									if (mfm.Create(lptstrFileName, lCb)) {
										void *pv = mfm.GetBasePtr();
										if (::LZRead(iFile, (LPSTR) pv, (INT) lCb) == lCb) {
											bRetValue = TRUE;
										}
									}
								} catch( ... ) {
								}
							}
						}
						::LZClose(iFile);
					} catch( ... ) {
						::LZClose(iFile);
					}
				}
			} catch( ... ) {
			}
			try { ::DeleteFile(atstrTempFileName); } catch(...) {}
		}
	}

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



LPTSTR MyGetPrintProcessorDirectory(void) {
	LPTSTR lptstr = NULL;
	DWORD dwCbNeeded;
	::GetPrintProcessorDirectory(NULL, NULL, 1, NULL, 0, &dwCbNeeded);
	if ( ::GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
		lptstr = (LPTSTR) malloc(dwCbNeeded);
		if (lptstr != NULL) {
			if ( ! ::GetPrintProcessorDirectory(NULL, NULL, 1, (LPBYTE) lptstr, dwCbNeeded, &dwCbNeeded) ) {
				free(lptstr);
				lptstr = NULL;
			}
		}

	}
	return lptstr;
}

::PJOB_INFO_1 GetPrintersJobs(IN HANDLE hPrinter, IN DWORD dwcJobs, OUT DWORD& dwcJobsReturned) {
	::PJOB_INFO_1 pinfoJobs = NULL;
	DWORD dwTemp;
	DWORD dwCbNeeded;
	::EnumJobs(hPrinter, 0, dwcJobs, 1, NULL, 0, &dwCbNeeded, &dwTemp);
	if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
		pinfoJobs = (::PJOB_INFO_1) malloc(dwCbNeeded);
		if (pinfoJobs != NULL) {
			if (::EnumJobs(hPrinter, 0, dwcJobs, 1, (LPBYTE) pinfoJobs, dwCbNeeded, &dwCbNeeded, &dwTemp)) {
				dwcJobsReturned = dwTemp;
			} else {
				free(pinfoJobs);
				pinfoJobs = NULL;
			}
		}
	}
	return pinfoJobs;
}

LPTSTR GetAdditionalProgramFolderPath(void) {
	LPTSTR lptstr = ::GetInstallFolderPath(PRINTRESIZER_ADDPROGS_FOLDER_PARENT, PRINTRESIZER_ADDPROGS_FOLDER_NAME);
	return lptstr;
}

LPTSTR GetLinkFolderPath(void) {
	LPTSTR lptstr = ::GetInstallFolderPath(PRINTRESIZER_LINKFOLDER_PARENT, PRINTRESIZER_LINK_FOLDER_NAME);
	return lptstr;
}

LPTSTR *GetLinkFileNames(void) {
	LPTSTR *plptstr = NULL;
	LPTSTR lptstrMyFolderPath = ::GetLinkFolderPath();
	if (lptstrMyFolderPath != NULL) {
		LPTSTR lptstrPreviewAppLink = ::MakeFullFileName(lptstrMyFolderPath, PRINTRESIZER_APP_NAME, TEXT(".lnk"));
		LPTSTR lptstrURLLink = ::MakeFullFileName(lptstrMyFolderPath, PRINTRESIZER_URL_LINKANME, TEXT(".url"));
		LPTSTR lptsrUninstallerStubLink = ::MakeFullFileName(lptstrMyFolderPath, PRINTRESIZER_UNINSTALLER_STUB_APP_NAME, TEXT(".lnk"));
		if (lptstrPreviewAppLink != NULL &&
			lptstrURLLink != NULL &&
			lptsrUninstallerStubLink != NULL
		) {
			plptstr = ::MyCatStringPtrs(
				lptstrMyFolderPath,
				lptstrPreviewAppLink,
				lptstrURLLink,
				lptsrUninstallerStubLink,
				NULL
				);
		}
		if (plptstr == NULL) {
			if (lptstrPreviewAppLink != NULL) 
				free(lptstrPreviewAppLink);
			if (lptstrURLLink != NULL) 
				free(lptstrURLLink);
			if (lptsrUninstallerStubLink != NULL) 
				free(lptsrUninstallerStubLink);
		}
	}
	if (plptstr == NULL) {
		if (lptstrMyFolderPath != NULL)
			free(lptstrMyFolderPath);
	}
	return plptstr;
}

LPTSTR *GetAdditionalProgFileNames(void) {
	LPTSTR *plptstr = NULL;
	BOOL bError = FALSE;
	LPTSTR lptstrProgDir = ::GetAdditionalProgramFolderPath();
	if (lptstrProgDir != NULL) {
		BOOL bTemp = ::CreateDirectory(lptstrProgDir, NULL);
		if (bTemp || ::GetLastError() == ERROR_ALREADY_EXISTS) {
			LPTSTR lptstrUninstallerFileName = ::MakeFullFileName(lptstrProgDir, PRINTRESIZER_UNINSTALLER_STUB_FILE_NAME);
			if (lptstrUninstallerFileName != NULL) {
				plptstr = MyCatStringPtrs(lptstrProgDir, lptstrUninstallerFileName, NULL);
				if (plptstr == NULL) {
					bError = TRUE;
				}
			} else {
				// OUT OF MEMORY TO CONCAT THE NAMES
				bError = TRUE;
			}
			if (bError && lptstrUninstallerFileName != NULL) {
				free(lptstrUninstallerFileName);
			}
		} else {
			// FAILED TO CREATE DIRECTORY AND IT DIDNT ALREADY EXIST			
			bError = TRUE;
		}
		if (bError && lptstrProgDir != NULL) {
			free(lptstrProgDir);
		}
	} else {
		// FAILED TO GET DIRECTORY NAME FOR OUR ADD. PROGS
		bError = TRUE;
	}

	return plptstr;
}

DWORD GetPrinterJobDeletionCommand(void) {
	DWORD dwCommand = 0;
	DWORD dwWinVer = ::GetVersion();
	// WIN 95,98, ME HAVE THE HIGH BIT SET, WHILE WIN 4.0 AND LATER DO NOT
	// WIN 3.51 ETC WASN'T DOCUMENTED
	signed char scMajorVer = (char) LOBYTE(dwWinVer);
	if (scMajorVer >= 0) {
		dwCommand = JOB_CONTROL_DELETE;
	} else {
		dwCommand = JOB_CONTROL_CANCEL;
	}
	return dwCommand;
}

BOOL MyDeleteFile( LPCTSTR lptstrFileName ) {
	BOOL b = TRUE;
	if (lptstrFileName != NULL && ::lstrlen(lptstrFileName) != 0) {
		b = ::DeleteFile( lptstrFileName );
	}
	return b;
}

void GeneratePRDriverAlternateNames(OUT PRDRIVER_FILENAME_ALTERNATES& alts, LPCTSTR lptstrFileName) {
	for(uint k = 0; k < ARRCOUNT(alts); ++k) {
		if (k == 0) {
			::StringCchCopy(alts[k], ARRCOUNT(alts[k]), lptstrFileName);
		} else {
			::StringCchPrintf(alts[k], ARRCOUNT(alts[k]), TEXT("%ls_%d"), lptstrFileName, k);
		}
	}
}

::PPRINTPROCESSOR_INFO_1 GetInstalledPrintProcessors(OUT DWORD& dwcPP) {
	::PPRINTPROCESSOR_INFO_1 pinfo = NULL;
	DWORD dwTemp;
	DWORD dwCbNeeded;
	::EnumPrintProcessors(NULL, NULL, 1, NULL, 0, &dwCbNeeded, &dwTemp);
	if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
		pinfo = (::PPRINTPROCESSOR_INFO_1) malloc(dwCbNeeded);
		if (pinfo != NULL) {
			if (::EnumPrintProcessors(NULL, NULL, 1, (LPBYTE) pinfo, dwCbNeeded, &dwCbNeeded, &dwTemp)) {
				dwcPP = dwTemp;
			} else {
				free(pinfo);
				pinfo = NULL;
			}
		}
	}
	return pinfo;
}

::PPORT_INFO_1 GetInstalledPorts(DWORD& dwcPorts) {
	::PPORT_INFO_1 pinfo = NULL;
	DWORD dwTemp;
	DWORD dwCbNeeded;
	::EnumPorts(NULL, 1, NULL, 0, &dwCbNeeded, &dwTemp);
	if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
		pinfo = (::PPORT_INFO_1) malloc(dwCbNeeded);
		if (pinfo != NULL) {
			if (::EnumPorts(NULL, 1, (LPBYTE) pinfo, dwCbNeeded, &dwCbNeeded, &dwTemp)) {
				dwcPorts = dwTemp;
			} else {
				// CANT GET INSTALLED PORTS
				free(pinfo);
				pinfo = NULL;
			}
		} // ELSE OUT OF MEMORY
	} // ELSE CANT GET INSTALLED PORTS
	return pinfo;
}

BOOL CheckPortInstalled(OUT BOOL& bInstalled, IN LPCTSTR lptstrPortName) {
	BOOL bRetValue = FALSE;
	DWORD dwcPorts;
	::PPORT_INFO_1 pinfoPorts = ::GetInstalledPorts(dwcPorts);
	if (pinfoPorts != NULL) {
		BOOL bPortInstalled = FALSE;
		for(uint kPort = 0; kPort < dwcPorts; ++kPort) {
			if ( ::lstrcmpi(pinfoPorts[kPort].pName, lptstrPortName) == 0 ) {
				bPortInstalled = TRUE;
				break;
			}
		}
		bInstalled = bPortInstalled;
		bRetValue = TRUE;
		free(pinfoPorts);
	} // else GETINSTALLEDPORTS ERROR
	return bRetValue;
}

BOOL DoLinksFolderCommand(LPCTSTR lptstrCommand) {
	BOOL bRetValue = FALSE;
	LPTSTR *plptstr = ::GetLinkFileNames();
	if (plptstr != NULL) {
		HINSTANCE hinst = ::ShellExecute(NULL, lptstrCommand, plptstr[::LinkFileNames::eFolder], NULL, NULL, SW_SHOW);
		// FROM DOCS, CAST TO INT AND COMAPRE TO 32
		if ( (int) hinst > 32 ) {
			bRetValue = TRUE;
		}
		::MyFreeStringPtrs(plptstr);
	}
	return bRetValue;
}

void SetErrorCode(LPCTSTR lptstrPrefix, ::ProgressDialogWindow *pdw, ::InstallStatusString *piss, BOOL bTerminal) {
	tstring tstr = lptstrPrefix;
	LPTSTR lptstr = ::GetPRErrorMessage( ::GetLastError() );
	if (lptstr != NULL) {
		tstr += TEXT("\n");
		tstr += lptstr;
		free(lptstr);
	}
	::SetErrorItem(tstr.c_str(), pdw, piss);
}

void SetErrorItem(LPCTSTR lptstrError, ::ProgressDialogWindow *pdw, ::InstallStatusString *piss, BOOL bTerminal) {
	if (piss != NULL) {
		piss->SetErrorItem(lptstrError, bTerminal);
		if (pdw != NULL) {
			if (pdw->GetStatusUserCanceled()) {
				piss->SetUserCanceled();
			}
			pdw->SetStatusString(piss->GetStatusString());
		}
	}
	if (pdw != NULL) {
		pdw->SetStatusErrors();
	}
}

void SetWorkInProgress(LPCTSTR lptstrWork, ::ProgressDialogWindow *pdw, ::InstallStatusString *piss) {
	if (piss != NULL) {
		piss->SetWorkInProgress(lptstrWork);
		if (pdw != NULL) {
			pdw->SetStatusString(piss->GetStatusString());
		}
	}
}

// ***********************************************************************************************
// **  MODULE PRIVATE ROUTINES  ******************************************************************
// ***********************************************************************************************

// A NULL TERMINATED LIST WITH DIRECTORY NAME FIRST
#if 0
BOOL DoUninstallFileList(LPTSTR *plist) {
	BOOL bError = FALSE;
	if (plist[0] != NULL) {
		for(uint k = 1; plist[k]; ++k) {
			if ( ::DeleteFile( plist[k])) {
				::SHChangeNotify(SHCNE_DELETE, SHCNF_PATH | SHCNF_FLUSH, plist[k], 0);
			} else {
				// FAILED TO REMOVE A FILE IN THE LIST
				bError = TRUE;
			}
		}
		if ( ::RemoveDirectory(plist[0])) {
			::SHChangeNotify(SHCNE_RMDIR, SHCNF_PATH | SHCNF_FLUSH, plist[0], 0);
		} else {
			// FAILED TO REMOVE THE DIRECTORY
			bError = TRUE;
		}
	}
	
	return !bError;
}
#else
BOOL DoUninstallFileList(LPTSTR *plist) {
	BOOL bError = FALSE;

	LPTSTR lptstrExtraNull = ::MyCatStringsString(TRUE, plist[0], NULL);	
	if (lptstrExtraNull != NULL) {
		if (! DoUninstallAlternateFileList(lptstrExtraNull)) {
			// FAILED TO REMOVE ONE OR MORE OF THE FILES
			bError = TRUE;
		}

		free(lptstrExtraNull);
	} else {
		// STRING ALLOCATION FAILED
		bError = TRUE;
	}
	
	return !bError;
}

BOOL DoUninstallAlternateFileList(LPCTSTR lptstr) {
	BOOL bError = FALSE;

	::SHFILEOPSTRUCT shfos;
	::ZeroMemory(&shfos, sizeof(shfos));
			
	shfos.pFrom = lptstr;
	shfos.wFunc = FO_DELETE;
	shfos.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;

	if (::SHFileOperation(&shfos) != 0) {
		// FAILED TO REMOVE ONE OR MORE OF THE FILES
		bError = TRUE;
	}
	return !bError;
}
#endif
#if 0
BOOL CQuickWebShortApp::DeleteLink (LPTSTR lpszShortcut)
{  
 INT iRV = 0;
 char szFile [MAX_PATH];
 SHFILEOPSTRUCT fos;

 ZeroMemory (szFile, sizeof(szFile));
 lstrcpy (szFile, lpszShortcut);

 // zero the FILEOPSTRUCT
 ZeroMemory (&fos, sizeof(fos));

 // fill the FILEOPSTRUCT
 fos.hwnd = NULL;
 fos.wFunc = FO_DELETE;
 fos.pFrom = szFile;
 fos.pTo = NULL;
 fos.fFlags = FOF_SILENT | FOF_ALLOWUNDO | FOF_NOCONFIRMATION;

 // delete the file
 iRV = SHFileOperation(&fos);
 if(iRV != 0)
  return  FALSE;

 // notify the shell
 SHChangeNotify (SHCNE_DELETE, SHCNF_PATH | SHCNF_FLUSH, szFile, 0);
 return TRUE;

} 
#endif

LPTSTR GetInstallFolderPath(const int clsidFolderParent, LPCTSTR lptstrFolderName) {
	LPTSTR lptstr = NULL;
	::LPMALLOC lpMalloc = NULL;
	HRESULT hrTemp = ::SHGetMalloc(&lpMalloc);
	if (SUCCEEDED(hrTemp)) {
		::LPITEMIDLIST lpidlFolderParent = NULL;
		hrTemp = ::SHGetSpecialFolderLocation(NULL, clsidFolderParent, &lpidlFolderParent);
		if (SUCCEEDED(hrTemp)) {
			TCHAR atstrPath[MAX_PATH];
			hrTemp = ::SHGetPathFromIDList(lpidlFolderParent, atstrPath);
			if (SUCCEEDED(hrTemp)) {
				lptstr = ::MakeFullFileName(atstrPath, lptstrFolderName);
			}
			lpMalloc->Free(lpidlFolderParent);
		}
		lpMalloc->Release();
	}
	return lptstr;
}