able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/print/spooler/wpnpinst/exe/wpnpinst.c

1579 lines
44 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*---------------------------------------------------------------------------*\
| MODULE: WPNPINST.CXX
|
| This is the main module for the WPNPINST application.
|
| Copyright (C) 1997 Microsoft Corporation
| Copyright (C) 1997 Hewlett Packard
|
| history:
| 25-Jul-1997 <rbkunz> Created.
|
\*---------------------------------------------------------------------------*/
#include "pch.h"
#include <tchar.h>
#define strFree(pszStr) {if (pszStr) GlobalFree((HANDLE)pszStr);}
/*****************************************************************************\
* strAlloc
*
* Allocates a string from the heap. This pointer must be freed with
* a call to strFree().
*
\*****************************************************************************/
LPTSTR strAlloc(
LPCTSTR pszSrc)
{
DWORD cbSize;
LPTSTR pszDst = NULL;
cbSize = (pszSrc ? ((lstrlen(pszSrc) + 1) * sizeof(TCHAR)) : 0);
if (cbSize) {
if (pszDst = (LPTSTR)GlobalAlloc(GPTR, cbSize))
CopyMemory(pszDst, pszSrc, cbSize);
}
return pszDst;
}
/*****************************************************************************\
* strAllocAndCat
*
* Allocates a string from the heap and concattenates another onto it.
* This pointer must be freed with a call to strFree().
*
\*****************************************************************************/
LPTSTR strAllocAndCat(
LPCTSTR pszSrc1,
LPCTSTR pszSrc2)
{
DWORD cbSize;
LPTSTR pszDst = NULL;
cbSize = (pszSrc1 && pszSrc2 ? ((lstrlen(pszSrc1) + lstrlen(pszSrc2) + 1) * sizeof(TCHAR)) : 0);
if (cbSize) {
if (pszDst = (LPTSTR)GlobalAlloc(GPTR, cbSize)) {
CopyMemory(pszDst, pszSrc1, cbSize);
lstrcat( pszDst, pszSrc2 );
}
}
return pszDst;
}
/*****************************************************************************\
* strLoad
*
* Get string from resource based upon the ID passed in.
*
\*****************************************************************************/
LPTSTR strLoad(
UINT ids)
{
TCHAR szStr[MAX_RESBUF];
if (LoadString(g_hInstance, ids, szStr, sizeof(szStr) / sizeof (TCHAR)) == 0)
szStr[0] = TEXT('\0');
return strAlloc(szStr);
}
/*****************************************************************************\
* InitStrings
*
*
\*****************************************************************************/
BOOL InitStrings(VOID)
{
g_szErrorFormat = strLoad(IDS_ERR_FORMAT);
g_szError = strLoad(IDS_ERR_ERROR);
g_szEGeneric = strLoad(IDS_ERR_GENERIC);
g_szEBadCAB = strLoad(IDS_ERR_BADCAB);
g_szEInvalidParameter = strLoad(IDS_ERR_INVPARM);
g_szENoMemory = strLoad(IDS_ERR_NOMEM);
g_szEInvalidCABName = strLoad(IDS_ERR_INVNAME);
g_szENoDATFile = strLoad(IDS_ERR_NODAT);
g_szECABExtract = strLoad(IDS_ERR_CABFAIL);
g_szENoPrintUI = strLoad(IDS_ERR_NOPRTUI);
g_szENoPrintUIEntry = strLoad(IDS_ERR_PRTUIENTRY);
g_szEPrintUIEntryFail = strLoad(IDS_ERR_PRTUIFAIL);
g_szENotSupported = strLoad(IDS_ERR_NOSUPPORT);
return (g_szErrorFormat &&
g_szError &&
g_szEGeneric &&
g_szEBadCAB &&
g_szEInvalidParameter &&
g_szENoMemory &&
g_szEInvalidCABName &&
g_szENoDATFile &&
g_szECABExtract &&
g_szENoPrintUI &&
g_szENoPrintUIEntry &&
g_szEPrintUIEntryFail &&
g_szENotSupported
);
}
/*****************************************************************************\
* FreeeStrings
*
*
\*****************************************************************************/
VOID FreeStrings(VOID)
{
strFree(g_szErrorFormat);
strFree(g_szError);
strFree(g_szEGeneric);
strFree(g_szEBadCAB);
strFree(g_szEInvalidParameter);
strFree(g_szENoMemory);
strFree(g_szEInvalidCABName);
strFree(g_szENoDATFile);
strFree(g_szECABExtract);
strFree(g_szENoPrintUI);
strFree(g_szENoPrintUIEntry);
strFree(g_szEPrintUIEntryFail);
strFree(g_szENotSupported);
}
/*****************************************************************************\
*
* Win32Open (Local Routine)
*
* Translate a C-Runtime _open() call into appropriate Win32 CreateFile()
*
* NOTE: Doesn't fully implement C-Runtime _open()
* capability but it currently supports all callbacks
* that FDI will give us
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\*****************************************************************************/
HANDLE Win32Open( LPCTSTR pszFile, int oflag, int pmode )
{
HANDLE FileHandle;
BOOL fExists = FALSE;
DWORD fAccess;
DWORD fCreate;
// NOTE: No Append Mode Support
if (oflag & _O_APPEND)
return INVALID_HANDLE_VALUE;
// Set Read-Write Access
if ((oflag & _O_RDWR) || (oflag & _O_WRONLY))
fAccess = GENERIC_WRITE;
else
fAccess = GENERIC_READ;
// Set Create Flags
if (oflag & _O_CREAT) {
if (oflag & _O_EXCL)
fCreate = CREATE_NEW;
else if (oflag & _O_TRUNC)
fCreate = CREATE_ALWAYS;
else
fCreate = OPEN_ALWAYS;
} else {
if (oflag & _O_TRUNC)
fCreate = TRUNCATE_EXISTING;
else
fCreate = OPEN_EXISTING;
}
FileHandle = CreateFile( pszFile, fAccess, FILE_SHARE_READ, NULL, fCreate,
FILE_ATTRIBUTE_NORMAL, NULL );
// NOTE: Doesn't create directories like C runtime.
// We don't need this capability for this app though.
// All our directories will already exist
return FileHandle;
}
/******************************************************************************\
*
* openfunc (Local Routine)
*
* Opens a file. Used by FDI interface.
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\******************************************************************************/
INT_PTR FAR DIAMONDAPI openfunc( CHAR FAR *pszFile, INT oflag, INT pmode ) {
INT rc;
INT i;
// Find Available File Handle in Fake File Table
for ( i = 0; i < FILETABLESIZE; i++ ) {
if ( g_FileTable[i].bAvailable == TRUE ) {
break;
}
}
// Running out of file handles should never happen
if ( i == FILETABLESIZE ) {
rc = C_RUNTIME_IO_ERROR;
}
#ifdef UNICODE
{
TCHAR uchFileName[_MAX_PATH] = {0};
mbstowcs(uchFileName, pszFile, _MAX_PATH);
g_FileTable[i].hFile = Win32Open(uchFileName, oflag, pmode );
}
#else
g_FileTable[i].hFile = Win32Open(pszFile, oflag, pmode );
#endif
if ( g_FileTable[i].hFile != INVALID_HANDLE_VALUE ) {
g_FileTable[i].bAvailable = FALSE;
rc = i;
} else {
rc = C_RUNTIME_IO_ERROR;
}
return rc;
}
#ifdef UNICODE
/******************************************************************************\
*
* openfunc (Local Routine)
*
* Opens a file. Used by FDINotify.
*
\******************************************************************************/
INT_PTR FAR DIAMONDAPI openfuncW( WCHAR FAR *pszFile, INT oflag, INT pmode ) {
INT rc;
INT i;
// Find Available File Handle in Fake File Table
for ( i = 0; i < FILETABLESIZE; i++ ) {
if ( g_FileTable[i].bAvailable == TRUE ) {
break;
}
}
// Running out of file handles should never happen
if ( i == FILETABLESIZE ) {
rc = C_RUNTIME_IO_ERROR;
}
g_FileTable[i].hFile = Win32Open(pszFile, oflag, pmode );
if ( g_FileTable[i].hFile != INVALID_HANDLE_VALUE ) {
g_FileTable[i].bAvailable = FALSE;
rc = i;
} else {
rc = C_RUNTIME_IO_ERROR;
}
return rc;
}
#endif
/******************************************************************************\
*
* closefunc (Local Routine)
*
* Closes a file. Used by FDI interface.
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\******************************************************************************/
INT FAR DIAMONDAPI closefunc( INT_PTR hf ) {
INT rc;
if ( CloseHandle( g_FileTable[hf].hFile ) ) {
rc = 0;
g_FileTable[hf].bAvailable = TRUE;
} else {
rc = C_RUNTIME_IO_ERROR;
}
return rc;
}
/******************************************************************************\
*
* readfunc (Local Routine)
*
* Reads a file. Used by FDI interface.
*
\******************************************************************************/
UINT FAR DIAMONDAPI readfunc( INT_PTR hf, PVOID pv, UINT cb ) {
INT rc;
INT cbRead;
if ( ! ReadFile( g_FileTable[hf].hFile, pv, cb, (DWORD *) &cb, NULL ) ) {
rc = C_RUNTIME_IO_ERROR;
} else {
rc = cb;
}
return rc;
}
/******************************************************************************\
*
* writefunc (Local Routine)
*
* Writes a file. Used by FDI interface
*
\******************************************************************************/
UINT FAR DIAMONDAPI writefunc( INT_PTR hf, PVOID pv, UINT cb ) {
INT rc;
if ( ! WriteFile( g_FileTable[hf].hFile, pv, cb, (DWORD *) &cb, NULL ) ) {
rc = C_RUNTIME_IO_ERROR;
} else {
rc = cb;
}
return rc;
}
/******************************************************************************\
*
* seekfunc (Local Routine)
*
* Repositions the file pointer. Used by FDI interface.
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\******************************************************************************/
LONG FAR DIAMONDAPI seekfunc( INT_PTR hf, LONG dist, INT seektype ) {
LONG rc;
DWORD dwResult;
DWORD W32seektype;
switch (seektype) {
case SEEK_SET:
W32seektype = FILE_BEGIN;
break;
case SEEK_CUR:
W32seektype = FILE_CURRENT;
break;
case SEEK_END:
W32seektype = FILE_END;
break;
}
dwResult = SetFilePointer(g_FileTable[hf].hFile, dist, NULL, W32seektype);
if (dwResult == 0xFFFFFFFF) {
rc = C_RUNTIME_SEEK_ERROR;
}
else
rc = (LONG)dwResult;
return rc;
}
/******************************************************************************\
*
* allocfunc (Local Routine)
*
* Allocates memory. Used by FDI interface.
*
\******************************************************************************/
void HUGE * FAR DIAMONDAPI allocfunc(ULONG cb) {
PVOID pv;
pv = (PVOID) GlobalAlloc( GPTR, cb );
return pv;
}
/******************************************************************************\
*
* freefunc (Local Routine)
*
* Frees memory. Used by FDI interface.
*
\******************************************************************************/
void FAR DIAMONDAPI freefunc(void HUGE *pv) {
GlobalFree( pv );
}
/******************************************************************************\
*
* AdjustFileTime (Local Routine)
*
* Sets file time.
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\******************************************************************************/
BOOL AdjustFileTime( INT_PTR hf, USHORT date, USHORT time )
{
FILETIME ft;
FILETIME ftUTC;
if ( ! DosDateTimeToFileTime( date, time, &ft ) ) {
return FALSE;
}
if ( ! LocalFileTimeToFileTime( &ft, &ftUTC ) ) {
return FALSE;
}
if ( ! SetFileTime( g_FileTable[hf].hFile, &ftUTC, &ftUTC, &ftUTC ) ) {
return FALSE;
}
return TRUE;
}
/******************************************************************************\
*
* Attr32FromAttrFAT (Local Routine)
*
* Translate FAT attributes to Win32 Attributes
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\******************************************************************************/
DWORD Attr32FromAttrFAT( WORD attrMSDOS )
{
//** Quick out for normal file special case
if (attrMSDOS == _A_NORMAL) {
return FILE_ATTRIBUTE_NORMAL;
}
//** Otherwise, mask off read-only, hidden, system, and archive bits
// NOTE: These bits are in the same places in MS-DOS and Win32!
return attrMSDOS & (_A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_ARCH);
}
/******************************************************************************\
*
* fdiNotify (Local Routine)
*
* Processes Notification messages from FDI interface.
*
* Leveraged from nt\private\inet\setup\iexpress\wextract\wextract.c
*
\******************************************************************************/
INT_PTR FAR DIAMONDAPI fdiNotify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin) {
INT_PTR fh; // File Handle
LPTSTR lpszFile; // Current File
PWPNPINFO pInfo; // Pointer to a "Web-Point-N-Print" info structure
INT_PTR nReturn;
DWORD dwError;
// The user-defined 'pv' is a pointer to our saved info
pInfo = (PWPNPINFO)pfdin->pv;
nReturn = 0;
switch ( fdint ) {
//*******************************************************************
case fdintCABINET_INFO:
nReturn = 0;
break;
//*******************************************************************
case fdintCOPY_FILE:
nReturn = C_RUNTIME_IO_ERROR;
{
#ifdef UNICODE
TCHAR uchFileName[_MAX_PATH] = {0};
mbstowcs(uchFileName, pfdin->psz1, _MAX_PATH);
if (NULL != (lpszFile = BuildFileName((LPCTSTR)pInfo->pTempDir, uchFileName))) {
fh = openfuncW( lpszFile, _O_BINARY | _O_TRUNC | _O_RDWR |
_O_CREAT, _S_IREAD | _S_IWRITE );
#else
if (NULL != (lpszFile = BuildFileName((LPCTSTR)pInfo->pTempDir, (LPCTSTR)pfdin->psz1))) {
fh = openfunc( lpszFile, _O_BINARY | _O_TRUNC | _O_RDWR |
_O_CREAT, _S_IREAD | _S_IWRITE );
#endif
if (C_RUNTIME_IO_ERROR != fh) {
if (AddFileToList(pInfo, lpszFile)) {
nReturn = fh;
}
else {
closefunc(fh);
}
}
GlobalFree(lpszFile);
}
}
break;
//*******************************************************************
case fdintCLOSE_FILE_INFO:
nReturn = C_RUNTIME_IO_ERROR;
if (AdjustFileTime( pfdin->hf, pfdin->date, pfdin->time ) ) {
closefunc( pfdin->hf );
{
#ifdef UNICODE
TCHAR uchFileName[_MAX_PATH] = {0};
mbstowcs(uchFileName, pfdin->psz1, _MAX_PATH);
if (NULL != (lpszFile = BuildFileName((LPCTSTR)pInfo->pTempDir, uchFileName))) {
#else
if (NULL != (lpszFile = BuildFileName((LPCTSTR)pInfo->pTempDir, (LPCTSTR)pfdin->psz1))) {
#endif
if (SetFileAttributes( lpszFile, Attr32FromAttrFAT( pfdin->attribs ) ) ) {
nReturn = TRUE;
}
GlobalFree(lpszFile);
}
}
}
break;
//*******************************************************************
case fdintPARTIAL_FILE:
nReturn = 0;
break;
//*******************************************************************
case fdintNEXT_CABINET:
nReturn = 0;
break;
//*******************************************************************
case fdintENUMERATE:
nReturn = 0;
break;
//*******************************************************************
default:
break;
}
return nReturn;
}
/*****************************************************************************\
* GetCurDir
*
* Returns string indicating current-directory.
*
\*****************************************************************************/
LPTSTR GetCurDir(VOID)
{
DWORD cbSize;
LPTSTR lpszDir = NULL;
cbSize = GetCurrentDirectory(0, NULL);
if (cbSize && (lpszDir = (LPTSTR)GlobalAlloc(GPTR, (cbSize * sizeof(TCHAR)))))
GetCurrentDirectory(cbSize, lpszDir);
return lpszDir;
}
/*****************************************************************************\
* WCFromMB (Local Routine)
*
* This routine returns a buffer of wide-character representation of a
* ansi string. The caller is responsible for freeing this pointer returned
* by this function.
*
\*****************************************************************************/
LPWSTR WCFromMB(
LPCSTR lpszStr)
{
DWORD cbSize;
DWORD dwChars;
LPWSTR lpwszBuf = NULL;
cbSize = 0;
dwChars = (DWORD)MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
lpszStr,
-1,
lpwszBuf,
(int)(cbSize / sizeof(WCHAR)));
cbSize = dwChars * sizeof(WCHAR);
if (cbSize && (lpwszBuf = (LPWSTR)GlobalAlloc(GPTR, cbSize)))
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
lpszStr,
-1,
lpwszBuf,
(int)(cbSize / sizeof(WCHAR)));
return lpwszBuf;
}
/*****************************************************************************\
* WCFromTC (Local Routine)
*
* This routine returns a buffer of wide-character representation of a
* TCHAR string. The caller is responsible for freeing this pointer returned
* by this function.
*
\*****************************************************************************/
LPWSTR WCFromTC(
LPCTSTR lpszStr)
{
DWORD cbSize;
DWORD dwChars;
LPWSTR lpwszBuf = NULL;
cbSize = 0;
#ifdef UNICODE
return (LPWSTR) lpszStr;
#else
return WCFromMB(lpszStr);
#endif
}
/******************************************************************************\
*
* BuildFileName (Local Routine)
*
* Concatenates a path and file to produce a full pathname.
*
\******************************************************************************/
LPTSTR BuildFileName(
LPCTSTR lpszPath,
LPCTSTR lpszName)
{
BOOL bReturn = FALSE;
LPTSTR lpszMessage = NULL;
INT cch = 0;
UINT_PTR Args[MAX_ARGS];
// Calculate the size necessary to hold the full-path filename.
//
cch += (lpszPath ? lstrlen(lpszPath) : 0);
cch += (lpszName ? lstrlen(lpszName) : 0);
// Concatenate the path and file
//
if (lpszPath) {
Args[0] = (UINT_PTR) lpszPath;
Args[1] = (UINT_PTR) lpszName;
Args[2] = 0;
if (0 != (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
g_szFNFmt,
0,
0,
(LPTSTR)&lpszMessage,
0,
(va_list*)Args ))) {
bReturn = TRUE;
}
}
return lpszMessage;
}
/******************************************************************************\
*
* GetDirectory (Local Routine)
*
* Returns the directory portion of a full pathname.
*
\******************************************************************************/
LPTSTR GetDirectory(LPTSTR lpszFile, LPDWORD lpdwReturn) {
LPTSTR lpszSlash;
LPTSTR lpszDir;
lpszSlash = _tcsrchr(lpszFile, g_chBackslash);
if (lpszSlash != NULL) {
if (NULL != (lpszDir = (LPTSTR)GlobalAlloc(GPTR, (lpszSlash - lpszFile + 2) * sizeof(TCHAR)))) {
lstrcpyn(lpszDir, lpszFile, (UINT32)((UINT_PTR)lpszSlash - (UINT_PTR)lpszFile) / sizeof(TCHAR) + 2);
*lpdwReturn = ERR_NONE;
return lpszDir;
}
else {
*lpdwReturn = ERR_NO_MEMORY;
}
}
else {
*lpdwReturn = ERR_INVALID_PARAMETER;
}
return NULL;
}
/******************************************************************************\
*
* GetName (Local Routine)
*
* Returns the filename portion of a full pathname.
*
\******************************************************************************/
LPTSTR GetName(LPTSTR lpszFile, LPDWORD lpdwReturn) {
LPTSTR lpszSlash;
LPTSTR lpszName;
int nLength;
lpszSlash = _tcsrchr(lpszFile, g_chBackslash);
if (lpszSlash != NULL) {
nLength = lstrlen(lpszSlash);
if (NULL != (lpszName = (LPTSTR)GlobalAlloc(GPTR, (nLength * sizeof(TCHAR))))) {
lstrcpyn(lpszName, ++lpszSlash, nLength);
*lpdwReturn = ERR_NONE;
return lpszName;
}
else {
*lpdwReturn = ERR_NO_MEMORY;
}
}
else {
*lpdwReturn = ERR_INVALID_PARAMETER;
}
return NULL;
}
/******************************************************************************\
*
* CreateTempDirectory (Local Routine)
*
* Creates a unique temp directory to extract files into.
*
\******************************************************************************/
LPTSTR CreateTempDirectory() {
LPTSTR pReturnDir = NULL;
LPTSTR pTempDir;
LPTSTR pCurrDir;
LPTSTR pWinDir;
DWORD dwRequired = 0;
// Save the current directory in pCurrDir
//
if (dwRequired = GetCurrentDirectory(0, NULL)) {
if (pCurrDir = (LPTSTR)GlobalAlloc(GPTR, dwRequired * sizeof(TCHAR))) {
if (GetCurrentDirectory(dwRequired, pCurrDir) <= dwRequired) {
// We need to set the current directory to something reasonable (something
// besides the desktop), because GetTempPath() will use the current directory
// if no TEMP or TMP variable is set. This will ensure that a user that saves the
// downloaded .wpnp cab file on the desktop and later runs it will not get the cab
// files extracted to the desktop.
//
if (dwRequired = GetWindowsDirectory(NULL, 0)) {
if (pWinDir = (LPTSTR)GlobalAlloc(GPTR, dwRequired * sizeof(TCHAR))) {
if (GetWindowsDirectory(pWinDir, dwRequired) <= dwRequired) {
if (SetCurrentDirectory(pWinDir)) {
// Get the temp path, so we can create a temp directory
// to extract the cabinet file into
//
if (dwRequired = GetTempPath(0, NULL)) {
if (pTempDir = (LPTSTR)GlobalAlloc(GPTR, dwRequired * sizeof(TCHAR))) {
if (GetTempPath(dwRequired, pTempDir) <= dwRequired) {
// Now create a unique temp file name.
//
if (pReturnDir = (LPTSTR)GlobalAlloc(GPTR, MAX_PATH * sizeof(TCHAR))) {
if (GetTempFileName(pTempDir, g_szTNFmt, 0, pReturnDir)) {
// But what we really needed was a directory, so delete the file (now that
// we know that we have a unique name) and create a directory with
// the same name as the file.
//
DeleteFile(pReturnDir);
if (!CreateDirectory(pReturnDir, NULL)) {
GlobalFree(pReturnDir);
pReturnDir = NULL;
}
// else We succeeded in creating the temp dir.
//
}
// else we can't create a temp directory...cleanup.
//
else {
GlobalFree(pReturnDir);
pReturnDir = NULL;
}
}
}
GlobalFree(pTempDir);
}
}
}
}
GlobalFree(pWinDir);
}
}
// Restore saved current directory
SetCurrentDirectory(pCurrDir);
}
GlobalFree(pCurrDir);
}
}
return pReturnDir;
}
#if 0
// The following 4 functions #ifdef'ed out on 11/6/97 RK
// PrintUI will call SetupX Catalog Verification APIs
// We don't need to verify any more
/******************************************************************************\
*
* RemoveExecutableFiles (Local Routine)
*
* Deletes executable files in the file list.
*
\******************************************************************************/
BOOL RemoveExecutableFiles(PWPNPINFO pInfo) {
PFILENODE pFileNode;
pFileNode = pInfo->pFileList;
while (pFileNode) {
if (IsExecutableFile(pFileNode->pFileName)) {
DeleteFile(pFileNode->pFileName);
}
pFileNode = pFileNode->pNextFile;
}
return TRUE;
}
/******************************************************************************\
*
* IsExecutableFile (Local Routine)
*
* Determines if a file is an executable module.
*
* NOTE: Can we check the actual file rather than just the extension?
*
\******************************************************************************/
BOOL IsExecutableFile(LPTSTR pFile) {
BOOL bReturn = FALSE;
LPTSTR pTemp = NULL;
if (NULL != (pTemp = _tcsrchr(pFile, g_chDot)) ) {
if (!lstrcmpi(pTemp, g_szDotDLL) || !lstrcmpi(pTemp, g_szDotEXE)) {
bReturn = TRUE;
}
}
return bReturn;
}
/******************************************************************************\
*
* CheckFile (Local Routine)
*
* Does an Authenticode check on a file.
*
\******************************************************************************/
DWORD CheckFile(LPTSTR lpszFile, LPDWORD lpAuthError) {
GUID gV2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
WINTRUST_DATA sWTD;
WINTRUST_FILE_INFO sWTFI;
LPWSTR lpwszFileName;
DWORD dwReturn;
dwReturn = ERR_GENERIC;
if (NULL != (lpwszFileName = WCFromTC(lpszFile))) {
memset(&sWTD, 0x00, sizeof(WINTRUST_DATA));
memset(&sWTFI, 0x00, sizeof(WINTRUST_FILE_INFO));
sWTD.cbStruct = sizeof(WINTRUST_DATA);
sWTD.dwUIChoice = WTD_UI_ALL;
sWTD.dwUnionChoice = WTD_CHOICE_FILE;
sWTD.pFile = &sWTFI;
sWTFI.cbStruct = sizeof(WINTRUST_FILE_INFO);
sWTFI.hFile = NULL;
sWTFI.pcwszFilePath = lpwszFileName;
*lpAuthError = WinVerifyTrust(NULL, &gV2, &sWTD);
dwReturn = ERR_NONE;
GlobalFree(lpwszFileName);
}
else {
dwReturn = ERR_NO_MEMORY;
}
return dwReturn;
}
/******************************************************************************\
*
* VerifyFiles (Local Routine)
*
* Does Authenticode verification on all executable files in the filelist.
*
\******************************************************************************/
DWORD VerifyFiles(PWPNPINFO pInfo, LPDWORD lpAuthError) {
DWORD dwReturn;
BOOL bContinue;
PFILENODE pFileNode;
pFileNode = pInfo->pFileList;
bContinue = TRUE;
dwReturn = ERR_NONE;
*lpAuthError = ERROR_SUCCESS;
while (bContinue && pFileNode) {
if (IsExecutableFile(pFileNode->pFileName)) {
bContinue = FALSE;
dwReturn = CheckFile(pFileNode->pFileName, lpAuthError);
if (*lpAuthError == ERROR_SUCCESS) {
bContinue = TRUE;
}
else {
if (*lpAuthError == TRUST_E_SUBJECT_NOT_TRUSTED) {
// The user didn't accept the signed/unsigned files
// Delete the executable files here, so that the print wizard
// will prompt the user for the files instead of using the downloaded files.
RemoveExecutableFiles(pInfo);
*lpAuthError = ERROR_SUCCESS;
}
else {
dwReturn = ERR_AUTHENTICODE;
}
}
}
pFileNode = pFileNode->pNextFile;
}
return dwReturn;
}
#endif
/******************************************************************************\
*
* GetCABName (Local Routine)
*
* Parses the CAB name from the command line.
*
\******************************************************************************/
PTSTR GetCABName(PTSTR pCmdLine, LPDWORD lpdwReturn) {
PTSTR pEnd = 0;
PTSTR pPtr;
PTSTR pName;
pPtr = pCmdLine;
if (pPtr) {
if (*pPtr == g_chDoubleQuote) {
pPtr++;
pEnd = _tcschr(pPtr, g_chDoubleQuote);
if (pEnd)
*pEnd = 0;
}
// If we haven't found an End-Quote, treat it as the end of the string.
if (pEnd == NULL)
pEnd = pPtr + lstrlen(pPtr);
if (pName = (PTSTR)GlobalAlloc(GPTR, (pEnd - pPtr + 1) * sizeof(TCHAR))) {
lstrcpyn(pName, pPtr, (UINT32) (pEnd - pPtr + 1));
*lpdwReturn = ERR_NONE;
}
else {
*lpdwReturn = ERR_NO_MEMORY;
}
return pName;
}
else {
*lpdwReturn = ERR_INVALID_PARAMETER;
}
return NULL;
}
/******************************************************************************\
*
* AddFileToList (Local Routine)
*
* Adds a file to the list of extracted files.
*
\******************************************************************************/
BOOL AddFileToList(PWPNPINFO pInfo, PTSTR lpszFile) {
PFILENODE pInsertHere;
BOOL bReturn;
bReturn = FALSE;
if (NULL == (pInfo->pFileList)) {
if (NULL != (pInfo->pFileList = (PFILENODE)GlobalAlloc(GPTR, sizeof(FILENODE)))) {
pInsertHere = pInfo->pFileList;
pInsertHere->pNextFile = NULL;
bReturn = TRUE;
}
}
else {
if (NULL != (pInsertHere = (PFILENODE)GlobalAlloc(GPTR, sizeof(FILENODE)))) {
pInsertHere->pNextFile = pInfo->pFileList;
pInfo->pFileList = pInsertHere;
bReturn = TRUE;
}
}
if (bReturn && (NULL != (pInsertHere->pFileName = (LPTSTR)GlobalAlloc(GPTR, (lstrlen(lpszFile) + 1) *sizeof(TCHAR))) ) ) {
lstrcpyn(pInsertHere->pFileName, lpszFile, lstrlen(lpszFile) + 1);
bReturn = TRUE;
}
else {
bReturn = FALSE;
}
return bReturn;
}
/******************************************************************************\
*
* FreeFileList (Local Routine)
*
* Frees memory allocated for file list.
*
\******************************************************************************/
VOID CleanupFileList(PWPNPINFO pInfo) {
PFILENODE pCurrentNode, pNextNode;
HANDLE hFindFind;
LPTSTR lpstrPos;
LPTSTR lpstrTemp;
WIN32_FIND_DATA FindData;
pCurrentNode = pInfo->pFileList;
// Erase all extracted files and cleanup our memory structure.
while (pCurrentNode) {
if (!DeleteFile(pCurrentNode->pFileName)) {
// We might have renamed one of our original cat files to this name. So
// look for poem*.cat in the same directory
lpstrPos = _tcsrchr(pCurrentNode->pFileName, TEXT('\\') );
if (lpstrPos) {
lpstrPos[1] = TEXT('\0');
// Now pCurrentNode->pFileName has our directory path
lpstrTemp = strAllocAndCat( pCurrentNode->pFileName , TEXT("poem*.cat") );
if (lpstrTemp) {
hFindFind = FindFirstFile( lpstrTemp , &FindData );
if (hFindFind != INVALID_HANDLE_VALUE) {
// Delete the file
DeleteFile( FindData.cFileName );
FindClose( hFindFind );
}
strFree( lpstrTemp );
}
}
}
pNextNode = pCurrentNode->pNextFile;
GlobalFree(pCurrentNode);
pCurrentNode = pNextNode;
}
pInfo->pFileList = NULL;
}
/******************************************************************************\
*
* Extract (Local Routine)
*
* Extracts all files from the CAB file and adds them to a file list.
*
\******************************************************************************/
BOOL Extract(PWPNPINFO pInfo) {
HFDI hfdi;
ERF erf;
INT nError;
BOOL bReturn;
int i;
bReturn = FALSE;
// Initialize file table
for ( i = 0; i < FILETABLESIZE; i++ ) {
g_FileTable[i].bAvailable = TRUE;
}
hfdi = FDICreate( allocfunc, freefunc, openfunc, readfunc, writefunc,
closefunc, seekfunc, cpu80386, &erf);
if (NULL != hfdi){
#ifdef UNICODE
char achCABName[_MAX_PATH]={0}, achCABDir[_MAX_DIR]={0};
wcstombs(achCABName, pInfo->pCABName, sizeof(achCABName));
wcstombs(achCABDir, pInfo->pCABDir, sizeof(achCABDir));
if (0 != (nError = FDICopy(hfdi, achCABName, achCABDir, 0, fdiNotify, NULL, (LPVOID)(pInfo))))
#else
if (0 != (nError = FDICopy(hfdi, pInfo->pCABName, pInfo->pCABDir, 0, fdiNotify, NULL, (LPVOID)(pInfo))))
#endif
bReturn = TRUE;
else {
CleanupFileList(pInfo);
}
FDIDestroy(hfdi);
}
return bReturn;
}
/******************************************************************************\
*
* GetWPNPSetupLibName (Local Routine)
*
* Returns the name of the print wizard library (NT5 and above)
* or equivalent for older clients (NT4 and Win9x)
*
\******************************************************************************/
LPTSTR GetWPNPSetupLibName(LPDWORD lpdwReturn) {
LPTSTR lpszLibName;
OSVERSIONINFO OSVersionInfo;
*lpdwReturn = ERR_GENERIC;
OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (GetVersionEx(&OSVersionInfo)) {
switch (OSVersionInfo.dwPlatformId) {
// NT clients
case VER_PLATFORM_WIN32_NT:
// NT 5 or better
if (OSVersionInfo.dwMajorVersion >= NT_VER_5) {
*lpdwReturn = ERR_NONE;
return (LPTSTR)g_szPrintUIMod;
}
// NT 4 clients
else if (OSVersionInfo.dwMajorVersion >= NT_VER_4) {
*lpdwReturn = ERR_NONE;
return (LPTSTR)g_szPrintUIEquiv;
}
// NT clients: ver < 4.0
else {
*lpdwReturn = ERR_PLATFORM_NOT_SUPPORTED;
return NULL;
}
// Win9x clients
case VER_PLATFORM_WIN32_WINDOWS:
*lpdwReturn = ERR_NONE;
return (LPTSTR)g_szPrintUIEquiv;
// Other clients ?
default:
*lpdwReturn = ERR_PLATFORM_NOT_SUPPORTED;
return NULL;
}
}
return NULL;
}
/******************************************************************************\
*
* InvokePrintWizard (Local Routine)
*
* Calls the PrintWizard (or 9x/NT4 equivalent)
* for printer setup and installation.
*
\******************************************************************************/
DWORD InvokePrintWizard(PWPNPINFO pInfo, LPDWORD lpAuthError) {
DWORD dwReturn;
DWORD dwErr;
LPTSTR lpszSetupLibName;
HMODULE hLibrary;
FARPROC lpProc;
// Get the name of the print wizard module
//
if (NULL != (lpszSetupLibName = GetWPNPSetupLibName(&dwReturn)) ) {
// Load the print wizard module
//
if (NULL != (hLibrary = LoadLibrary(lpszSetupLibName)) ) {
// Find the webpnp installation proc address
//
if (NULL != (lpProc = GetProcAddress(hLibrary, g_szPrintUIEntryW) ) ) {
// Call the webpnp installation entry point with the correct parameters
//
if ((*lpAuthError) = (UINT32) (*lpProc)(NULL, g_hInstance, g_wszParmString, SW_SHOWDEFAULT))
dwReturn = ERR_AUTHENTICODE;
else
dwReturn = ERR_NONE;
} else {
dwReturn = ERR_NO_PRINTUIENTRY;
}
FreeLibrary(hLibrary);
} else {
dwReturn = ERR_NO_PRINTUI;
}
}
return dwReturn;
}
/******************************************************************************\
*
* WebPnPCABInstall (Local Routine)
*
* Takes a CAB file and does the driver extraction and printer installation.
*
\******************************************************************************/
DWORD WebPnPCABInstall(PTSTR pCABName, PDWORD lpAuthError)
{
PTSTR pFileList;
PTSTR pOldDir;
PWPNPINFO pInfo;
DWORD dwReturn = ERR_NONE;
if (NULL != (pInfo = (PWPNPINFO)GlobalAlloc(GPTR, sizeof(WPNPINFO)))) {
if (NULL != (pInfo->pFullCABPath = (PTSTR)GlobalAlloc(GPTR, (lstrlen(pCABName) + 1) * sizeof(TCHAR)))) {
lstrcpy(pInfo->pFullCABPath, pCABName);
if (pInfo->pCABDir = GetDirectory(pInfo->pFullCABPath, &dwReturn)) {
if (pOldDir = GetCurDir()) {
if (pInfo->pTempDir = CreateTempDirectory() ) {
SetCurrentDirectory(pInfo->pTempDir);
if (pInfo->pCABName = GetName(pInfo->pFullCABPath, &dwReturn)) {
if (Extract(pInfo)) {
// Verification of files removed
// if (ERR_NONE == (dwReturn = VerifyFiles(pInfo, lpAuthError))) {
dwReturn = InvokePrintWizard(pInfo, lpAuthError);
// }
CleanupFileList(pInfo);
} else {
dwReturn = ERR_CAB_EXTRACT;
}
GlobalFree(pInfo->pCABName);
}
SetCurrentDirectory(pOldDir);
RemoveDirectory(pInfo->pTempDir);
GlobalFree(pInfo->pTempDir);
}
GlobalFree(pOldDir);
}
GlobalFree(pInfo->pCABDir);
}
GlobalFree(pInfo->pFullCABPath);
} else {
dwReturn = ERR_NO_MEMORY;
}
GlobalFree(pInfo);
} else {
dwReturn = ERR_NO_MEMORY;
}
return dwReturn;
}
/******************************************************************************\
*
* LookupErrorString (Local Routine)
*
* Returns an error string associated with dwErrorCode
*
\******************************************************************************/
LPCTSTR LookupErrorString(DWORD dwErrorCode) {
int i;
int nCount;
static ERROR_MAPPING s_ErrorMap[] = {
{ ERR_NO_MEMORY, &g_szENoMemory },
{ ERR_BAD_CAB, &g_szEBadCAB },
{ ERR_INVALID_PARAMETER, &g_szEInvalidParameter },
{ ERR_INVALID_CAB_NAME, &g_szEInvalidCABName },
{ ERR_CAB_EXTRACT, &g_szECABExtract },
{ ERR_NO_DAT_FILE, &g_szENoDATFile },
{ ERR_NO_PRINTUI, &g_szENoPrintUI },
{ ERR_NO_PRINTUIENTRY, &g_szENoPrintUIEntry },
{ ERR_PRINTUIENTRY_FAIL, &g_szEPrintUIEntryFail },
{ ERR_PLATFORM_NOT_SUPPORTED, &g_szENotSupported }
};
nCount = sizeof(s_ErrorMap) / sizeof(s_ErrorMap[0]);
for (i=0; i < nCount; i++) {
if (0 != ((s_ErrorMap[i].dwErrorCode) & dwErrorCode & ~(ERR_GENERIC)) )
return *(s_ErrorMap[i].lpszError);
}
return g_szEGeneric;
}
/******************************************************************************\
*
* CheckErrors (Local Routine)
*
* Checks dwErrorCode for any error conditions
*
\******************************************************************************/
VOID CheckErrors(DWORD dwErrorCode, DWORD dwAuthError) {
LPTSTR lpszMessage = NULL;
LPTSTR lpszErrorString = NULL;
BOOL bAuthErrorAllocated;
UINT_PTR Args[MAX_ARGS];
bAuthErrorAllocated = FALSE;
if (dwErrorCode != ERR_NONE) {
// Check for Authenticode errors here
if (dwErrorCode == ERR_AUTHENTICODE) {
// Format the authenticode error message.
// If the message can't be found in the system, use our generic error message
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, dwAuthError, 0, (LPTSTR)&lpszErrorString, 0, NULL)) {
bAuthErrorAllocated = TRUE;
}
else {
lpszErrorString = (LPTSTR)LookupErrorString(ERR_GENERIC);
}
}
// If the error is not Authenticode, it must be ours.
// Look it up in our error string table.
else {
lpszErrorString = (LPTSTR)LookupErrorString(dwErrorCode);
}
// Set up our arg list.
Args[0] = (UINT_PTR) lpszErrorString;
if (dwErrorCode == ERR_AUTHENTICODE) {
Args[1] = dwAuthError;
}
else
Args[1] = dwErrorCode;
Args[2] = 0;
// Format our error message and display it in a message box.
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
g_szErrorFormat, 0, 0, (LPTSTR)&lpszMessage, 0, (va_list*)Args )) {
if (lpszMessage) {
MessageBox(NULL, lpszMessage, g_szError, MB_ICONEXCLAMATION | MB_OK);
// Free the buffer
LocalFree(lpszMessage);
}
}
}
// Free up the Authenticode error string allocated for us by FormatMessage().
if (bAuthErrorAllocated)
LocalFree(lpszErrorString);
}
/******************************************************************************\
*
* WinMain
*
* Main entrypoint for the program.
*
\******************************************************************************/
INT WINAPI _tWinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpszCmdLine, INT nCmdShow)
{
LPTSTR lpszCABName;
DWORD dwReturn = ERR_NONE;
DWORD dwAuthError = ERROR_SUCCESS;
g_hInstance = hInstance;
if (InitStrings()) {
if (NULL != (lpszCABName = GetCABName(lpszCmdLine, &dwReturn))) {
dwReturn = WebPnPCABInstall(lpszCABName, &dwAuthError);
GlobalFree(lpszCABName);
}
#if 0
// We disable the error since oleprn will
// prompt users with the correct error
//
CheckErrors(dwReturn, dwAuthError);
#endif
// Decide which error code we must return
//
if (dwReturn == ERR_NONE) {
dwReturn = SUCCESS_EXITCODE;
} else {
if (dwReturn == ERR_AUTHENTICODE) {
if (dwAuthError == ERROR_SUCCESS) {
dwReturn = SUCCESS_EXITCODE;
} else {
dwReturn = dwAuthError;
}
}
}
FreeStrings();
}
return dwReturn;
}
Reference in a new issue Copy permalink