archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/inetcore/connectionwizard/icwhelp/misc.cpp

1578 lines
48 KiB
Raw Permalink Blame History

/*-----------------------------------------------------------------------------
misc.cpp
service functions
History:
1/7/98 DONALDM Moved to new ICW project and string
and nuked 16 bit stuff
-----------------------------------------------------------------------------*/
#include "stdafx.h"
#include <stdio.h>
#if defined (DEBUG)
#include "refdial.h"
#endif
#define DIR_SIGNUP TEXT("signup")
#define DIR_WINDOWS TEXT("windows")
#define DIR_SYSTEM TEXT("system")
#define DIR_TEMP TEXT("temp")
BOOL g_bGotProxy=FALSE;
#if defined (DEBUG)
extern TCHAR g_BINTOHEXLookup[16];
#endif
//+---------------------------------------------------------------------------
//
// Function: ProcessDBCS
//
// Synopsis: Converts control to use DBCS compatible font
// Use this at the beginning of the dialog procedure
//
// Note that this is required due to a bug in Win95-J that prevents
// it from properly mapping MS Shell Dlg. This hack is not needed
// under winNT.
//
// Arguments: hwnd - Window handle of the dialog
// cltID - ID of the control you want changed.
//
// Returns: ERROR_SUCCESS
//
// History: 4/31/97 a-frankh Created
// 5/13/97 jmazner Stole from CM to use here
//----------------------------------------------------------------------------
void ProcessDBCS(HWND hDlg, int ctlID)
{
HFONT hFont = NULL;
if( IsNT() )
{
return;
}
hFont = (HFONT) GetStockObject(DEFAULT_GUI_FONT);
if (hFont == NULL)
hFont = (HFONT) GetStockObject(SYSTEM_FONT);
if (hFont != NULL)
SendMessage(GetDlgItem(hDlg,ctlID), WM_SETFONT, (WPARAM) hFont, MAKELPARAM(TRUE, 0));
}
// ############################################################################
// StoreInSignUpReg
//
// Created 3/18/96, Chris Kauffman
// ############################################################################
HRESULT StoreInSignUpReg(LPBYTE lpbData, DWORD dwSize, DWORD dwType, LPCTSTR pszKey)
{
HRESULT hr = ERROR_ACCESS_DENIED;
HKEY hKey;
hr = RegCreateKey(HKEY_LOCAL_MACHINE,SIGNUPKEY,&hKey);
if (hr != ERROR_SUCCESS) goto StoreInSignUpRegExit;
hr = RegSetValueEx(hKey,pszKey,0,dwType,lpbData,sizeof(TCHAR)*dwSize);
RegCloseKey(hKey);
StoreInSignUpRegExit:
return hr;
}
HRESULT ReadSignUpReg(LPBYTE lpbData, DWORD *pdwSize, DWORD dwType, LPCTSTR pszKey)
{
HRESULT hr = ERROR_ACCESS_DENIED;
HKEY hKey = 0;
hr = RegOpenKey(HKEY_LOCAL_MACHINE,SIGNUPKEY,&hKey);
if (hr != ERROR_SUCCESS) goto ReadSignUpRegExit;
hr = RegQueryValueEx(hKey,pszKey,0,&dwType,lpbData,pdwSize);
ReadSignUpRegExit:
if (hKey) RegCloseKey (hKey);
return hr;
}
// ############################################################################
// GetDataFromISPFile
//
// This function will read a specific piece of information from an ISP file.
//
// Created 3/16/96, Chris Kauffman
// ############################################################################
HRESULT GetDataFromISPFile
(
LPTSTR pszISPCode,
LPTSTR pszSection,
LPTSTR pszDataName,
LPTSTR pszOutput,
DWORD dwOutputLength)
{
LPTSTR pszTemp;
HRESULT hr = ERROR_SUCCESS;
TCHAR szTempPath[MAX_PATH];
TCHAR szBuff256[256];
// Locate ISP file
if (!SearchPath(NULL,pszISPCode,INF_SUFFIX,MAX_PATH,szTempPath,&pszTemp))
{
wsprintf(szBuff256,TEXT("Can not find:%s%s (%d) (connect.exe)"),pszISPCode,INF_SUFFIX,GetLastError());
AssertMsg(0,szBuff256);
lstrcpyn(szTempPath,pszISPCode,MAX_PATH);
lstrcpyn(&szTempPath[lstrlen(szTempPath)],INF_SUFFIX,MAX_PATH-lstrlen(szTempPath));
wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),szTempPath);
MessageBox(NULL,szBuff256,GetSz(IDS_TITLE),MB_MYERROR);
hr = ERROR_FILE_NOT_FOUND;
} else if (!GetPrivateProfileString(pszSection,pszDataName,INF_DEFAULT,
pszOutput, (int)dwOutputLength,szTempPath))
{
TraceMsg(TF_GENERAL, TEXT("ICWHELP: %s not specified in ISP file.\n"),pszDataName);
hr = ERROR_FILE_NOT_FOUND;
}
// 10/23/96 jmazner Normandy #9921
// CompareString does _not_ have same return values as lsrtcmp!
// Return value of 2 indicates strings are equal.
//if (!CompareString(LOCALE_SYSTEM_DEFAULT,0,INF_DEFAULT,lstrlen(INF_DEFAULT),pszOutput,lstrlen(pszOutput)))
if (2 == CompareString(LOCALE_SYSTEM_DEFAULT,0,INF_DEFAULT,lstrlen(INF_DEFAULT),pszOutput,lstrlen(pszOutput)))
{
hr = ERROR_FILE_NOT_FOUND;
}
if (hr != ERROR_SUCCESS && dwOutputLength)
*pszOutput = TEXT('\0');
return hr;
}
// ############################################################################
// GetINTFromISPFile
//
// This function will read a specific integer from an ISP file.
//
//
// ############################################################################
HRESULT GetINTFromISPFile
(
LPTSTR pszISPCode,
LPTSTR pszSection,
LPTSTR pszDataName,
int far *lpData,
int iDefaultValue
)
{
LPTSTR pszTemp;
HRESULT hr = ERROR_SUCCESS;
TCHAR szTempPath[MAX_PATH];
TCHAR szBuff256[256];
// Locate ISP file
if (!SearchPath(NULL,pszISPCode,INF_SUFFIX,MAX_PATH,szTempPath,&pszTemp))
{
wsprintf(szBuff256,TEXT("Can not find:%s%s (%d) (connect.exe)"),pszISPCode,INF_SUFFIX,GetLastError());
AssertMsg(0,szBuff256);
lstrcpyn(szTempPath,pszISPCode,MAX_PATH);
lstrcpyn(&szTempPath[lstrlen(szTempPath)],INF_SUFFIX,MAX_PATH-lstrlen(szTempPath));
wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),szTempPath);
MessageBox(NULL,szBuff256,GetSz(IDS_TITLE),MB_MYERROR);
hr = ERROR_FILE_NOT_FOUND;
}
*lpData = GetPrivateProfileInt(pszSection,
pszDataName,
iDefaultValue,
szTempPath);
return hr;
}
//+-------------------------------------------------------------------
//
// Function: IsNT
//
// Synopsis: findout If we are running on NT
//
// Arguements: none
//
// Return: TRUE - Yes
// FALSE - No
//
//--------------------------------------------------------------------
BOOL
IsNT (
VOID
)
{
OSVERSIONINFO OsVersionInfo;
ZeroMemory(&OsVersionInfo, sizeof(OSVERSIONINFO));
OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&OsVersionInfo);
return (VER_PLATFORM_WIN32_NT == OsVersionInfo.dwPlatformId);
} //end of IsNT function call
//+-------------------------------------------------------------------
//
// Function: IsNT4SP3Lower
//
// Synopsis: findout If we are running on NTSP3 or lower
//
// Arguements: none
//
// Return: TRUE - Yes
// FALSE - No
//
//--------------------------------------------------------------------
BOOL IsNT4SP3Lower()
{
OSVERSIONINFO os;
os.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&os);
if(os.dwPlatformId != VER_PLATFORM_WIN32_NT)
return FALSE;
// Exclude NT5 or higher
if(os.dwMajorVersion > 4)
return FALSE;
if(os.dwMajorVersion < 4)
return TRUE;
// version 4.0
if ( os.dwMinorVersion > 0)
return FALSE; // assume that sp3 is not needed for nt 4.1 or higher
int nServicePack;
if(_stscanf(os.szCSDVersion, TEXT("Service Pack %d"), &nServicePack) != 1)
return TRUE;
if(nServicePack < 4)
return TRUE;
return FALSE;
}
//+---------------------------------------------------------------------------
//
// Function: MyGetTempPath()
//
// Synopsis: Gets the path to temporary directory
// - Use GetTempFileName to get a file name
// and strips off the filename portion to get the temp path
//
// Arguments: [uiLength - Length of buffer to contain the temp path]
// [szPath - Buffer in which temp path will be returned]
//
// Returns: Length of temp path if successful
// 0 otherwise
//
// History: 7/6/96 VetriV Created
// 8/23/96 VetriV Delete the temp file
// 12/4/96 jmazner Modified to serve as a wrapper of sorts;
// if TMP or TEMP don't exist, setEnv our own
// vars that point to conn1's installed path
// (Normandy #12193)
//
//----------------------------------------------------------------------------
DWORD MyGetTempPath(UINT uiLength, LPTSTR szPath)
{
# define ICWHELPPATHKEY TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\ICWHELP.EXE")
# define PATHKEYNAME TEXT("Path")
TCHAR szEnvVarName[MAX_PATH + 1] = TEXT("\0unitialized szEnvVarName\0");
DWORD dwFileAttr = 0;
lstrcpyn( szPath, TEXT("\0unitialized szPath\0"), 20 );
// is the TMP variable set?
lstrcpyn(szEnvVarName,GetSz(IDS_TMPVAR),ARRAYSIZE(szEnvVarName));
if( GetEnvironmentVariable( szEnvVarName, szPath, uiLength ) )
{
// 1/7/96 jmazner Normandy #12193
// verify validity of directory name
dwFileAttr = GetFileAttributes(szPath);
// if there was any error, this directory isn't valid.
if( 0xFFFFFFFF != dwFileAttr )
{
if( FILE_ATTRIBUTE_DIRECTORY & dwFileAttr )
{
return( lstrlen(szPath) );
}
}
}
lstrcpyn( szEnvVarName, TEXT("\0unitialized again\0"), 19 );
// if not, is the TEMP variable set?
lstrcpyn(szEnvVarName,GetSz(IDS_TEMPVAR),ARRAYSIZE(szEnvVarName));
if( GetEnvironmentVariable( szEnvVarName, szPath, uiLength ) )
{
// 1/7/96 jmazner Normandy #12193
// verify validity of directory name
dwFileAttr = GetFileAttributes(szPath);
if( 0xFFFFFFFF != dwFileAttr )
{
if( FILE_ATTRIBUTE_DIRECTORY & dwFileAttr )
{
return( lstrlen(szPath) );
}
}
}
// neither one is set, so let's use the path to the installed icwhelp.dll
// from the registry SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\ICWHELP.DLL\Path
HKEY hkey = NULL;
#ifdef UNICODE
uiLength = sizeof(TCHAR)*uiLength;
#endif
if ((RegOpenKeyEx(HKEY_LOCAL_MACHINE,ICWHELPPATHKEY, 0, KEY_QUERY_VALUE, &hkey)) == ERROR_SUCCESS)
RegQueryValueEx(hkey, PATHKEYNAME, NULL, NULL, (LPBYTE)szPath, (DWORD *)&uiLength);
if (hkey)
{
RegCloseKey(hkey);
}
//The path variable is supposed to have a semicolon at the end of it.
// if it's there, remove it.
if( TEXT(';') == szPath[uiLength - 2] )
szPath[uiLength - 2] = TEXT('\0');
TraceMsg(TF_GENERAL, TEXT("ICWHELP: using path %s\r\n"), szPath);
// go ahead and set the TEMP variable for future reference
// (only effects currently running process)
if( szEnvVarName[0] )
{
SetEnvironmentVariable( szEnvVarName, szPath );
}
else
{
lstrcpyn( szPath, TEXT("\0unitialized again\0"), 19 );
return( 0 );
}
return( uiLength );
}
// ############################################################################
HRESULT ClearProxySettings()
{
HINSTANCE hinst = NULL;
FARPROC fp;
HRESULT hr = ERROR_SUCCESS;
hinst = LoadLibrary(TEXT("INETCFG.DLL"));
if (hinst)
{
fp = GetProcAddress(hinst,"InetGetProxy");
if (!fp)
{
hr = GetLastError();
goto ClearProxySettingsExit;
}
hr = ((PFNINETGETPROXY)fp)(&g_bProxy,NULL,0,NULL,0);
if (hr == ERROR_SUCCESS)
g_bGotProxy = TRUE;
else
goto ClearProxySettingsExit;
if (g_bProxy)
{
fp = GetProcAddress(hinst, "InetSetProxy");
if (!fp)
{
hr = GetLastError();
goto ClearProxySettingsExit;
}
((PFNINETSETPROXY)fp)(FALSE,NULL,NULL);
}
} else {
hr = GetLastError();
}
ClearProxySettingsExit:
if (hinst)
FreeLibrary(hinst);
return hr;
}
// ############################################################################
HRESULT RestoreProxySettings()
{
HINSTANCE hinst = NULL;
FARPROC fp;
HRESULT hr = ERROR_SUCCESS;
hinst = LoadLibrary(TEXT("INETCFG.DLL"));
if (hinst && g_bGotProxy)
{
fp = GetProcAddress(hinst, "InetSetProxy");
if (!fp)
{
hr = GetLastError();
goto RestoreProxySettingsExit;
}
((PFNINETSETPROXY)fp)(g_bProxy,NULL,NULL);
} else {
hr = GetLastError();
}
RestoreProxySettingsExit:
if (hinst)
FreeLibrary(hinst);
return hr;
}
// ############################################################################
BOOL FSz2Dw(LPCTSTR pSz,LPDWORD dw)
{
DWORD val = 0;
while (*pSz && *pSz != TEXT('.'))
{
if (*pSz >= TEXT('0') && *pSz <= TEXT('9'))
{
val *= 10;
val += *pSz++ - TEXT('0');
}
else
{
return FALSE; //bad number
}
}
*dw = val;
return (TRUE);
}
// ############################################################################
LPTSTR GetNextNumericChunk(LPTSTR psz, LPTSTR pszLim, LPTSTR* ppszNext)
{
LPTSTR pszEnd;
// init for error case
*ppszNext = NULL;
// skip non numerics if any to start of next numeric chunk
while(*psz<TEXT('0') || *psz>TEXT('9'))
{
if(psz >= pszLim) return NULL;
psz++;
}
// skip all numerics to end of country code
for(pszEnd=psz; *pszEnd>=TEXT('0') && *pszEnd<=TEXT('9') && pszEnd<pszLim; pszEnd++)
;
// zap whatever delimiter there was to terminate this chunk
*pszEnd++ = TEXT('\0');
// return ptr to next chunk (pszEnd now points to it)
if(pszEnd<pszLim)
*ppszNext = pszEnd;
return psz; // return ptr to start of chunk
}
// ############################################################################
BOOL BreakUpPhoneNumber(LPRASENTRY prasentry, LPTSTR pszPhone)
{
LPTSTR pszStart,pszNext, pszLim, pszArea;
// LPPHONENUM ppn;
if (!pszPhone) return FALSE; // skip if no number
pszLim = pszPhone + lstrlen(pszPhone); // find end of string
//ppn = (fMain) ? &(pic->PhoneNum) : &(pic->PhoneNum2);
////Get the country ID...
//ppn->dwCountryID = PBKDWCountryId();
// Get Country Code from phone number...
pszStart = _tcschr(pszPhone,TEXT('+'));
if(!pszStart) goto error; // bad format
// get country code
pszStart = GetNextNumericChunk(pszStart, pszLim, &pszNext);
if(!pszStart) goto error; // bad format
//ppn->dwCountryCode = Sz2Dw(pszStart);
FSz2Dw(pszStart,&prasentry->dwCountryCode);
pszStart = pszNext;
//Now get the area code
if(!pszStart) goto error; // bad format
pszStart = GetNextNumericChunk(pszStart, pszLim, &pszNext);
if(!pszStart) goto error; // bad format //icw bug 8950
//lstrcpy(ppn->szAreaCode, pszStart);
lstrcpyn(prasentry->szAreaCode,pszStart,ARRAYSIZE(prasentry->szAreaCode));
//
// Keep track of the start of the area code, because it may actually be the
// local phone number.
//
pszArea = pszStart;
pszStart = pszNext;
// If pszStart is NULL then we don't have an area code, just a country code and a local
// phone number. Therefore we will copy what we thought was the area code into the
// phone number and replace the area code with a space (which seems to make RAS happy).
//
if (pszStart)
{
//now the local phone number (everything from here to : or end)
pszNext = _tcschr(pszStart, TEXT(':'));
if(pszNext) *pszNext=TEXT('\0');
lstrcpyn(prasentry->szLocalPhoneNumber,pszStart,ARRAYSIZE(prasentry->szLocalPhoneNumber));
} else {
//
// Turns out that there is no area code. So copy what we thought was the area code
// into the local phone number and make the area code NULL
//
lstrcpyn(prasentry->szLocalPhoneNumber,pszArea,ARRAYSIZE(prasentry->szLocalPhoneNumber));
//lstrcpyn(prasentry->szAreaCode," ",sizeof(prasentry->szAreaCode));
prasentry->szAreaCode[0] = TEXT('\0');
}
//no extension. what is extension?
//ppn->szExtension[0] = TEXT('\0');
//LocalFree(pszPhone);
return TRUE;
error:
// This means number is not canonical. Set it as local number anyway!
// memset(ppn, 0, sizeof(*ppn));
// Bug#422: need to strip stuff after : or dial fails!!
pszNext = _tcschr(pszPhone, TEXT(':'));
if(pszNext) *pszNext=TEXT('\0');
//lstrcpy(ppn->szLocal,pszPhone);
lstrcpy(prasentry->szLocalPhoneNumber,pszPhone);
//LocalFree(pszPhone);
return TRUE;
}
// ############################################################################
int Sz2W (LPCTSTR szBuf)
{
DWORD dw;
if (FSz2Dw(szBuf,&dw))
{
return (WORD)dw;
}
return 0;
}
// ############################################################################
int FIsDigit( int c )
{
TCHAR szIn[2];
WORD rwOut[2];
szIn[0] = (TCHAR)c;
szIn[1] = TEXT('\0');
GetStringTypeEx(LOCALE_USER_DEFAULT,CT_CTYPE1,szIn,-1,rwOut);
return rwOut[0] & C1_DIGIT;
}
// ############################################################################
LPBYTE MyMemSet(LPBYTE dest,int c, size_t count)
{
LPVOID pv = dest;
LPVOID pvEnd = (LPVOID)(dest + (WORD)count);
while (pv < pvEnd)
{
*(LPINT)pv = c;
//((WORD)pv)++;
pv=((LPINT)pv)+1;
}
return dest;
}
// ############################################################################
LPBYTE MyMemCpy(LPBYTE dest,const LPBYTE src, size_t count)
{
LPBYTE pbDest = (LPBYTE)dest;
LPBYTE pbSrc = (LPBYTE)src;
LPBYTE pbEnd = (LPBYTE)((DWORD_PTR)src + count);
while (pbSrc < pbEnd)
{
*pbDest = *pbSrc;
pbSrc++;
pbDest++;
}
return dest;
}
// ############################################################################
BOOL ShowControl(HWND hDlg,int idControl,BOOL fShow)
{
HWND hWnd;
if (NULL == hDlg)
{
AssertMsg(0,TEXT("Null Param"));
return FALSE;
}
hWnd = GetDlgItem(hDlg,idControl);
if (hWnd)
{
ShowWindow(hWnd,fShow ? SW_SHOW : SW_HIDE);
}
return TRUE;
}
BOOL isAlnum(TCHAR c)
{
if ((c >= TEXT('0') && c <= TEXT('9') ) ||
(c >= TEXT('a') && c <= TEXT('z') ) ||
(c >= TEXT('A') && c <= TEXT('Z') ))
return TRUE;
return FALSE;
}
// ############################################################################
HRESULT ANSI2URLValue(TCHAR *s, TCHAR *buf, UINT uiLen)
{
HRESULT hr;
TCHAR *t;
hr = ERROR_SUCCESS;
for (t=buf;*s; s++)
{
if (*s == TEXT(' ')) *t++ = TEXT('+');
else if (isAlnum(*s)) *t++ = *s;
else {
wsprintf(t, TEXT("%%%02X"), (unsigned char) *s);
t += 3;
}
}
*t = TEXT('\0');
return hr;
}
// ############################################################################
LPTSTR FileToPath(LPTSTR pszFile)
{
TCHAR szBuf[MAX_PATH+1];
TCHAR szTemp[MAX_PATH+1];
LPTSTR pszTemp;
LPTSTR pszTemp2;
LPTSTR pszHold = pszFile;
int j;
for(j=0; *pszFile; pszFile++)
{
if(j>=MAX_PATH)
return NULL;
if(*pszFile==TEXT('%'))
{
pszFile++;
pszTemp = _tcschr(pszFile, TEXT('%'));
if(!pszTemp)
return NULL;
*pszTemp = 0;
if(lstrcmpi(pszFile, DIR_SIGNUP)==0)
{
LPTSTR pszCmdLine = GetCommandLine();
_tcsncpy(szTemp, pszCmdLine, MAX_PATH);
szBuf[MAX_PATH] = 0;
pszTemp = _tcstok(szTemp, TEXT(" \t\r\n"));
pszTemp2 = _tcsrchr(pszTemp, TEXT('\\'));
if(!pszTemp2) pszTemp2 = _tcsrchr(pszTemp, TEXT('/'));
if(pszTemp2)
{
*pszTemp2 = 0;
lstrcpy(szBuf+j, pszTemp);
}
else
{
Assert(FALSE);
GetCurrentDirectory(MAX_PATH, szTemp);
szTemp[MAX_PATH] = 0;
lstrcpy(szBuf+j, pszTemp);
}
j+= lstrlen(pszTemp);
}
else if(lstrcmpi(pszFile, DIR_WINDOWS)==0)
{
GetWindowsDirectory(szTemp, MAX_PATH);
szTemp[MAX_PATH] = 0;
lstrcpy(szBuf+j, szTemp);
j+= lstrlen(szTemp);
}
else if(lstrcmpi(pszFile, DIR_SYSTEM)==0)
{
GetSystemDirectory(szTemp, MAX_PATH);
szTemp[MAX_PATH] = 0;
lstrcpy(szBuf+j, szTemp);
j+= lstrlen(szTemp);
}
else if(lstrcmpi(pszFile, DIR_TEMP)==0)
{
// 3/18/97 ChrisK Olympus 304
MyGetTempPath(MAX_PATH, &szTemp[0]);
szTemp[MAX_PATH] = 0;
if(szTemp[lstrlen(szTemp)-1]==TEXT('\\'))
szTemp[lstrlen(szTemp)-1]=0;
lstrcpy(szBuf+j, szTemp);
j+= lstrlen(szTemp);
}
else
return NULL;
pszFile=pszTemp;
}
else
szBuf[j++] = *pszFile;
}
szBuf[j] = 0;
TraceMsg(TF_GENERAL, TEXT("CONNECT:File to Path output ,%s.\n"),szBuf);
return lstrcpy(pszHold,&szBuf[0]);
}
// ############################################################################
BOOL FShouldRetry2(HRESULT hrErr)
{
BOOL bRC;
if (hrErr == ERROR_LINE_BUSY ||
hrErr == ERROR_VOICE_ANSWER ||
hrErr == ERROR_NO_ANSWER ||
hrErr == ERROR_NO_CARRIER ||
hrErr == ERROR_AUTHENTICATION_FAILURE ||
hrErr == ERROR_PPP_TIMEOUT ||
hrErr == ERROR_REMOTE_DISCONNECTION ||
hrErr == ERROR_AUTH_INTERNAL ||
hrErr == ERROR_PROTOCOL_NOT_CONFIGURED ||
hrErr == ERROR_PPP_NO_PROTOCOLS_CONFIGURED)
{
bRC = TRUE;
} else {
bRC = FALSE;
}
return bRC;
}
#if 0
// DJM I don't this we will need this
//+----------------------------------------------------------------------------
//
// Function: FGetSystemShutdownPrivledge
//
// Synopsis: For windows NT the process must explicitly ask for permission
// to reboot the system.
//
// Arguements: none
//
// Return: TRUE - privledges granted
// FALSE - DENIED
//
// History: 8/14/96 ChrisK Created
//
// Note: BUGBUG for Win95 we are going to have to softlink to these
// entry points. Otherwise the app won't even load.
// Also, this code was originally lifted out of MSDN July96
// "Shutting down the system"
//-----------------------------------------------------------------------------
BOOL FGetSystemShutdownPrivledge()
{
HANDLE hToken = NULL;
TOKEN_PRIVILEGES tkp;
BOOL bRC = FALSE;
if (VER_PLATFORM_WIN32_NT == g_dwPlatform)
{
//
// Get the current process token handle
// so we can get shutdown privilege.
//
if (!OpenProcessToken(GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
goto FGetSystemShutdownPrivledgeExit;
//
// Get the LUID for shutdown privilege.
//
ZeroMemory(&tkp,sizeof(tkp));
LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
&tkp.Privileges[0].Luid);
tkp.PrivilegeCount = 1; /* one privilege to set */
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
//
// Get shutdown privilege for this process.
//
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
(PTOKEN_PRIVILEGES) NULL, 0);
if (ERROR_SUCCESS == GetLastError())
bRC = TRUE;
}
else
{
bRC = TRUE;
}
FGetSystemShutdownPrivledgeExit:
if (hToken) CloseHandle(hToken);
return bRC;
}
#endif
//+----------------------------------------------------------------------------
//
// Function: LoadTestingLocaleOverride
//
// Synopsis: Allow the testers to override the locale information sent to
// the referal server
//
// Arguments: lpdwCountryID - pointer to country ID
// lplcid - pointer to current lcid
//
// Returns: none
//
// History: 8/15/96 ChrisK Created
//
//-----------------------------------------------------------------------------
#if defined(DEBUG)
void LoadTestingLocaleOverride(LPDWORD lpdwCountryID, LCID FAR *lplcid)
{
HKEY hkey = NULL;
LONG lRC = ERROR_SUCCESS;
DWORD dwTemp = 0;
LCID lcidTemp = 0;
DWORD dwSize = 0;
DWORD dwType = 0;
BOOL fWarn = FALSE;
Assert(lpdwCountryID && lplcid);
//
// Open debug key
//
lRC = RegOpenKey(HKEY_LOCAL_MACHINE,TEXT("Software\\Microsoft\\ISignup\\Debug"),&hkey);
if (ERROR_SUCCESS != lRC)
goto LoadTestingLocaleOverrideExit;
//
// Get CountryID
//
dwSize = sizeof(dwTemp);
lRC = RegQueryValueEx(hkey,TEXT("CountryID"),0,&dwType,(LPBYTE)&dwTemp,&dwSize);
AssertMsg(lRC || REG_DWORD == dwType,TEXT("Wrong value type for CountryID. Must be DWORD.\r\n"));
if (ERROR_SUCCESS==lRC)
{
*lpdwCountryID = dwTemp;
fWarn = TRUE;
}
//
// Get LCID
//
dwSize = sizeof(lcidTemp);
lRC = RegQueryValueEx(hkey,TEXT("LCID"),0,&dwType,(LPBYTE)&lcidTemp,&dwSize);
AssertMsg(lRC || REG_DWORD == dwType,TEXT("Wrong value type for LCID. Must be DWORD.\r\n"));
if (ERROR_SUCCESS==lRC)
{
*lplcid = lcidTemp;
fWarn = TRUE;
}
//
// Inform the user that overrides have been used
//
if (fWarn)
{
MessageBox(NULL,TEXT("DEBUG ONLY: LCID and/or CountryID overrides from the registry are now being used."),TEXT("Testing Override"),0);
}
LoadTestingLocaleOverrideExit:
if (hkey)
RegCloseKey(hkey);
hkey = NULL;
return;
}
#endif //DEBUG
//+----------------------------------------------------------------------------
//
// Function: FCampusNetOverride
//
// Synopsis: Detect if the dial should be skipped for the campus network
//
// Arguments: None
//
// Returns: TRUE - overide enabled
//
// History: 8/15/96 ChrisK Created
//
//-----------------------------------------------------------------------------
#if defined(DEBUG)
BOOL FCampusNetOverride()
{
HKEY hkey = NULL;
BOOL bRC = FALSE;
DWORD dwType = 0;
DWORD dwSize = 0;
DWORD dwData = 0;
if (ERROR_SUCCESS != RegOpenKey(HKEY_LOCAL_MACHINE,
TEXT("Software\\Microsoft\\ISignup\\Debug"),&hkey))
goto FCampusNetOverrideExit;
dwSize = sizeof(dwData);
if (ERROR_SUCCESS != RegQueryValueEx(hkey,TEXT("CampusNet"),0,&dwType,
(LPBYTE)&dwData,&dwSize))
goto FCampusNetOverrideExit;
AssertMsg(REG_DWORD == dwType,TEXT("Wrong value type for CampusNet. Must be DWORD.\r\n"));
bRC = (0 != dwData);
if (bRC)
{
if (IDOK != MessageBox(NULL,TEXT("DEBUG ONLY: CampusNet will be used."),TEXT("Testing Override"),MB_OKCANCEL))
bRC = FALSE;
}
FCampusNetOverrideExit:
if (hkey)
RegCloseKey(hkey);
return bRC;
}
#endif //DEBUG
#if defined(DEBUG)
BOOL FRefURLOverride()
{
HKEY hkey = NULL;
BOOL bRC = FALSE;
DWORD dwType = 0;
DWORD dwSize = 0;
DWORD dwData = 0;
if (ERROR_SUCCESS != RegOpenKey(HKEY_LOCAL_MACHINE,
TEXT("Software\\Microsoft\\ISignup\\Debug"),&hkey))
goto FRefURLOverrideExit;
dwSize = sizeof(dwData);
if (ERROR_SUCCESS != RegQueryValueEx(hkey,TEXT("TweakURL"),0,&dwType,
(LPBYTE)&dwData,&dwSize))
goto FRefURLOverrideExit;
AssertMsg(REG_DWORD == dwType,TEXT("Wrong value type for TweakURL. Must be DWORD.\r\n"));
bRC = (0 != dwData);
if (bRC)
{
if (IDOK != MessageBox(NULL,TEXT("DEBUG ONLY: TweakURL settings will be used."),TEXT("Testing Override"),MB_OKCANCEL))
bRC = FALSE;
}
FRefURLOverrideExit:
if (hkey)
RegCloseKey(hkey);
return bRC;
}
void TweakRefURL( TCHAR* szUrl,
LCID* lcid,
DWORD* dwOS,
DWORD* dwMajorVersion,
DWORD* dwMinorVersion,
WORD* wArchitecture,
TCHAR* szPromo,
TCHAR* szOEM,
TCHAR* szArea,
DWORD* dwCountry,
TCHAR* szSUVersion,//&m_lpGatherInfo->m_szSUVersion[0],
TCHAR* szProd,
DWORD* dwBuildNumber,
TCHAR* szRelProd,
TCHAR* szRelProdVer,
DWORD* dwCONNWIZVersion,
TCHAR* szPID,
long* lAllOffers)
{
HKEY hKey = NULL;
BOOL bRC = FALSE;
BYTE bData[MAX_PATH*3];
DWORD cbData = MAX_PATH*3;
DWORD dwType = 0;
DWORD dwSize = 0;
DWORD dwData = 0;
dwSize = sizeof(dwData);
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\ISignup\\Debug\\TweakURLValues"),&hKey))
{
//szURL
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("URL"), NULL ,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szUrl, (TCHAR*)&bData);
}
}
//lcid
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("LCID"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*lcid = dwData;
}
//dwOS
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("OS"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*dwOS = dwData;
}
//dwMajorVersion
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("MajorVer"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*dwMajorVersion = dwData;
}
//dwMinorVersion
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("MinorVer"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*dwMinorVersion = dwData;
}
//wArchitecture
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("SysArch"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*wArchitecture = (WORD)dwData;
}
//szPromo
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("Promo"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szPromo, (TCHAR*)&bData);
}
}
//szOEM
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("OEM"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szOEM, (TCHAR*)&bData);
}
}
//szArea
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("Area"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szArea, (TCHAR*)&bData);
}
}
//dwCountry
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("Country"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*dwCountry = dwData;
}
//szSUVersion
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("SUVer"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_VERSION_LEN))
{
lstrcpy(szSUVersion, (TCHAR*)&bData);
}
}
//szProd
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("Product"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szProd, (TCHAR*)&bData);
}
}
//dwBuildNumber
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("BuildNum"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*dwBuildNumber = dwData;
}
//szRelProd
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("RelProd"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szRelProd, (TCHAR*)&bData);
}
}
//szRelProdVer
cbData = sizeof(TCHAR)*(MAX_PATH*3);
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("RelProdVer"),0,&dwType, bData, &cbData))
{
if ((cbData > 1) && (cbData <= MAX_PATH))
{
lstrcpy(szRelProdVer, (TCHAR*)&bData);
}
}
//dwCONNWIZVersion
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("ConnwizVer"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*dwCONNWIZVersion = dwData;
}
//szPID
BYTE byDigitalPID[MAX_DIGITAL_PID];
DWORD dwType2 = REG_BINARY;
DWORD dwSize2 = sizeof(byDigitalPID);
if (RegQueryValueEx(hKey,
TEXT("PID"),
NULL,
&dwType2,
(LPBYTE)byDigitalPID,
&dwSize2) == ERROR_SUCCESS)
{
if ((dwSize2 > 1) && (dwSize2 <= ((MAX_DIGITAL_PID * 2) + 1)))
{
// BINHEX the digital PID data so we can send it to the ref_server
int i = 0;
BYTE by;
for (DWORD dwX = 0; dwX < dwSize2; dwX++)
{
by = byDigitalPID[dwX];
szPID[i++] = g_BINTOHEXLookup[((by & 0xF0) >> 4)];
szPID[i++] = g_BINTOHEXLookup[(by & 0x0F)];
}
szPID[i] = TEXT('\0');
}
else
{
szPID[0] = TEXT('\0');
}
}
//lAllOffers
if (ERROR_SUCCESS == RegQueryValueEx(hKey,TEXT("AllOffers"),0,&dwType, (LPBYTE)&dwData, &dwSize))
{
if (dwData != 0)
*lAllOffers = dwData;
}
}
if (hKey)
RegCloseKey(hKey);
}
#endif //DEBUG
//+----------------------------------------------------------------------------
// Function CopyUntil
//
// Synopsis Copy from source until destination until running out of source
// or until the next character of the source is the chend character
//
// Arguments dest - buffer to recieve characters
// src - source buffer
// lpdwLen - length of dest buffer
// chend - the terminating character
//
// Returns FALSE - ran out of room in dest buffer
//
// Histroy 10/25/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL CopyUntil(LPTSTR *dest, LPTSTR *src, LPDWORD lpdwLen, TCHAR chend)
{
while ((TEXT('\0') != **src) && (chend != **src) && (0 != *lpdwLen))
{
**dest = **src;
(*lpdwLen)--;
(*dest)++;
(*src)++;
}
return (0 != *lpdwLen);
}
//+----------------------------------------------------------------------------
// Function ConvertToLongFilename
//
// Synopsis convert a file to the full long file name
// ie. c:\progra~1\icw-in~1\isignup.exe becomes
// c:\program files\icw-internet connection wizard\isignup.exe
//
// Arguments szOut - output buffer
// szIn - filename to be converted
// dwSize - size of the output buffer
//
// Returns TRUE - success
//
// History 10/25/96 ChrisK Created
//-----------------------------------------------------------------------------
BOOL ConvertToLongFilename(LPTSTR szOut, LPTSTR szIn, DWORD dwSize)
{
BOOL bRC = FALSE;
LPTSTR pCur = szIn;
LPTSTR pCurOut = szOut;
LPTSTR pCurOutFilename = NULL;
WIN32_FIND_DATA fd;
DWORD dwSizeTemp;
LPTSTR pTemp = NULL;
ZeroMemory(pCurOut,dwSize);
//
// Validate parameters
//
if (NULL != pCurOut && NULL != pCur && 0 != dwSize)
{
//
// Copy drive letter
//
if (!CopyUntil(&pCurOut,&pCur,&dwSize,TEXT('\\')))
goto ConvertToLongFilenameExit;
pCurOut[0] = TEXT('\\');
dwSize--;
pCur++;
pCurOut++;
pCurOutFilename = pCurOut;
while (*pCur)
{
//
// Copy over possibly short name
//
pCurOut = pCurOutFilename;
dwSizeTemp = dwSize;
if (!CopyUntil(&pCurOut,&pCur,&dwSize,TEXT('\\')))
goto ConvertToLongFilenameExit;
ZeroMemory(&fd, sizeof(fd));
//
// Get long filename
//
if (INVALID_HANDLE_VALUE != FindFirstFile(szOut,&fd))
{
//
// Replace short filename with long filename
//
dwSize = dwSizeTemp;
pTemp = &(fd.cFileName[0]);
if (!CopyUntil(&pCurOutFilename,&pTemp,&dwSize,TEXT('\0')))
goto ConvertToLongFilenameExit;
if (*pCur)
{
//
// If there is another section then we just copied a directory
// name. Append a \ character;
//
pTemp = (LPTSTR)memcpy(TEXT("\\X"),TEXT("\\X"),0);
if (!CopyUntil(&pCurOutFilename,&pTemp,&dwSize,TEXT('X')))
goto ConvertToLongFilenameExit;
pCur++;
}
}
else
{
break;
}
}
//
// Did we get to the end (TRUE) or fail before that (FALSE)?
//
bRC = (TEXT('\0') == *pCur);
}
ConvertToLongFilenameExit:
return bRC;
}
#if 0
// DJM I don't think we need this
//+----------------------------------------------------------------------------
//
// Function: GetIEVersion
//
// Synopsis: Gets the major and minor version # of the installed copy of Internet Explorer
//
// Arguments: pdwVerNumMS - pointer to a DWORD;
// On succesful return, the top 16 bits will contain the major version number,
// and the lower 16 bits will contain the minor version number
// (this is the data in VS_FIXEDFILEINFO.dwProductVersionMS)
// pdwVerNumLS - pointer to a DWORD;
// On succesful return, the top 16 bits will contain the release number,
// and the lower 16 bits will contain the build number
// (this is the data in VS_FIXEDFILEINFO.dwProductVersionLS)
//
// Returns: TRUE - Success. *pdwVerNumMS and LS contains installed IE version number
// FALSE - Failure. *pdVerNumMS == *pdVerNumLS == 0
//
// History: jmazner Created 8/19/96 (as fix for Normandy #4571)
// jmazner updated to deal with release.build as well 10/11/96
// jmazner stolen from isign32\isignup.cpp 11/21/96
// (for Normandy #11812)
//
//-----------------------------------------------------------------------------
BOOL GetIEVersion(PDWORD pdwVerNumMS, PDWORD pdwVerNumLS)
{
HRESULT hr;
HKEY hKey = 0;
LPVOID lpVerInfoBlock;
VS_FIXEDFILEINFO *lpTheVerInfo;
UINT uTheVerInfoSize;
DWORD dwVerInfoBlockSize, dwUnused, dwPathSize;
TCHAR szIELocalPath[MAX_PATH + 1] = TEXT("");
*pdwVerNumMS = 0;
*pdwVerNumLS = 0;
// get path to the IE executable
hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, IE_PATHKEY,0, KEY_READ, &hKey);
if (hr != ERROR_SUCCESS) return( FALSE );
dwPathSize = sizeof (szIELocalPath);
hr = RegQueryValueEx(hKey, NULL, NULL, NULL, (LPBYTE) szIELocalPath, &dwPathSize);
RegCloseKey( hKey );
if (hr != ERROR_SUCCESS) return( FALSE );
// now go through the convoluted process of digging up the version info
dwVerInfoBlockSize = GetFileVersionInfoSize( szIELocalPath, &dwUnused );
if ( 0 == dwVerInfoBlockSize ) return( FALSE );
lpVerInfoBlock = GlobalAlloc( GPTR, dwVerInfoBlockSize );
if( NULL == lpVerInfoBlock ) return( FALSE );
if( !GetFileVersionInfo( szIELocalPath, NULL, dwVerInfoBlockSize, lpVerInfoBlock ) )
return( FALSE );
if( !VerQueryValue(lpVerInfoBlock, TEXT("\\"), (void **)&lpTheVerInfo, &uTheVerInfoSize) )
return( FALSE );
*pdwVerNumMS = lpTheVerInfo->dwProductVersionMS;
*pdwVerNumLS = lpTheVerInfo->dwProductVersionLS;
GlobalFree( lpVerInfoBlock );
return( TRUE );
}
#endif
//+---------------------------------------------------------------------------
//
// Function: GenericMsg
//
//----------------------------------------------------------------------------
void GenericMsg
(
HWND hwnd,
UINT uId,
LPCTSTR lpszArg,
UINT uType
)
{
TCHAR szTemp[MAX_STRING + 1];
TCHAR szMsg[MAX_STRING + MAX_PATH + 1];
Assert( lstrlen( GetSz((USHORT)uId) ) <= MAX_STRING );
lstrcpy( szTemp, GetSz( (USHORT)uId ) );
if (lpszArg)
{
Assert( lstrlen( lpszArg ) <= MAX_PATH );
wsprintf(szMsg, szTemp, lpszArg);
}
else
{
lstrcpy(szMsg, szTemp);
}
MessageBox(hwnd,
szMsg,
GetSz(IDS_TITLE),
uType);
}
//+---------------------------------------------------------------------------
//
// Function: ErrorMsg1()
//
// Synopsis: 1 stop shopping for showing a msgBox when you need to wsprintf the string to be displayed
//
// Displays an error dialog from a string resource with a "%s" format command,
// and a string argument to stick into it.
//
// Arguments: hwnd -- Handle of parent window
// uID -- ID of a string resource with a %s argument
// lpszArg -- pointer to a string to fill into the %s in uID string
//
//
// History: 9/18/96 jmazner copied from isign32\utils.cpp (for Normandy 7537)
// modified to work in conn1
//
//----------------------------------------------------------------------------
void ErrorMsg1(HWND hwnd, UINT uId, LPCTSTR lpszArg)
{
GenericMsg(hwnd,
uId,
lpszArg,
MB_ICONERROR | MB_SETFOREGROUND | MB_OK | MB_APPLMODAL);
}
//+---------------------------------------------------------------------------
//
// Function: InfoMsg1()
//
//----------------------------------------------------------------------------
void InfoMsg1(HWND hwnd, UINT uId, LPCTSTR lpszArg)
{
GenericMsg(hwnd,
uId,
lpszArg,
MB_ICONINFORMATION | MB_SETFOREGROUND | MB_OK | MB_APPLMODAL);
}
//=--------------------------------------------------------------------------=
// MakeWideFromAnsi
//=--------------------------------------------------------------------------=
// given a string, make a BSTR out of it.
//
// Parameters:
// LPTSTR - [in]
// BYTE - [in]
//
// Output:
// LPWSTR - needs to be cast to final desired result
//
// Notes:
//
LPWSTR MakeWideStrFromAnsi
(
LPSTR psz,
BYTE bType
)
{
LPWSTR pwsz;
int i;
// arg checking.
//
if (!psz)
return NULL;
// compute the length of the required BSTR
//
i = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
if (i <= 0) return NULL;
// allocate the widestr
//
switch (bType) {
case STR_BSTR:
// -1 since it'll add it's own space for a NULL terminator
//
pwsz = (LPWSTR) SysAllocStringLen(NULL, i - 1);
break;
case STR_OLESTR:
pwsz = (LPWSTR) CoTaskMemAlloc(i * sizeof(WCHAR));
break;
default:
AssertMsg(0,TEXT("Bogus String Type."));
}
if (!pwsz) return NULL;
MultiByteToWideChar(CP_ACP, 0, psz, -1, pwsz, i);
pwsz[i - 1] = 0;
return pwsz;
}
//=--------------------------------------------------------------------------=
// MakeWideStrFromResId
//=--------------------------------------------------------------------------=
// given a resource ID, load it, and allocate a wide string for it.
//
// Parameters:
// WORD - [in] resource id.
// BYTE - [in] type of string desired.
//
// Output:
// LPWSTR - needs to be cast to desired string type.
//
// Notes:
//
#ifndef UNICODE // this module is not necessary for Unicode.
LPWSTR MakeWideStrFromResourceId
(
WORD wId,
BYTE bType
)
{
int i;
TCHAR szTmp[512];
// load the string from the resources.
//
i = LoadString(_Module.GetModuleInstance(), wId, szTmp, 512);
if (!i) return NULL;
return MakeWideStrFromAnsi(szTmp, bType);
}
#endif
//=--------------------------------------------------------------------------=
// MakeWideStrFromWide
//=--------------------------------------------------------------------------=
// given a wide string, make a new wide string with it of the given type.
//
// Parameters:
// LPWSTR - [in] current wide str.
// BYTE - [in] desired type of string.
//
// Output:
// LPWSTR
//
// Notes:
//
LPWSTR MakeWideStrFromWide
(
LPWSTR pwsz,
BYTE bType
)
{
LPWSTR pwszTmp;
int i;
if (!pwsz) return NULL;
// just copy the string, depending on what type they want.
//
switch (bType) {
case STR_OLESTR:
i = lstrlenW(pwsz);
pwszTmp = (LPWSTR)CoTaskMemAlloc((i * sizeof(WCHAR)) + sizeof(WCHAR));
if (!pwszTmp) return NULL;
memcpy(pwszTmp, pwsz, (sizeof(WCHAR) * i) + sizeof(WCHAR));
break;
case STR_BSTR:
pwszTmp = (LPWSTR)SysAllocString(pwsz);
break;
}
return pwszTmp;
}