// 
// MODULE: Launch.cpp
//
// PURPOSE: Starts the container that will query the LaunchServ for 
//			troubleshooter network and nodes.
//
// PROJECT: Local Troubleshooter Launcher for the Device Manager
//
// COMPANY: Saltmine Creative, Inc. (206)-633-4743 support@saltmine.com
//
// AUTHOR: Richard Meadows
// 
// ORIGINAL DATE: 2-26-98
//
//
// Version	Date		By		Comments
//--------------------------------------------------------------------
// V0.1		-			RM		Original
///////////////////////

#include "stdafx.h"
#include "StateInfo.h"

#include "RSSTACK.H"

#include "TSMapAbstract.h"
#include "TSMap.h"
#include "TSMapClient.h"

#include "Launch.h"
#include "ComGlobals.h"
#include "TSLError.h"
#include "Registry.h"

#include <rpc.h> 

#define LAUNCH_WAIT_TIMEOUT 60 * 1000   // One minute wait.

#define SZ_WEB_PAGE _T("asklibrary.htm") // name of hardcoded .htm file that contains troubleshooter OCX


// uncomment the following line to turn on Joe's hard-core debugging
//#define JDEBUG 1

#ifdef JDEBUG
#include <stdio.h>
// Convert TCHAR *szt to char *sz.  *sz should point to a big enough buffer
//	to contain an SNCS version of *szt.  count indicates the size of buffer *sz.
// returns sz (convenient for use in string functions).
static char* ToSBCS (char * const sz, const TCHAR * szt, size_t count)
{
	if (sz)
	{
		if (count != 0 && !szt)
			sz[0] = '\0';
		else
		{
			#ifdef  _UNICODE
				wcstombs( sz, szt, count );
			#else
				strcpy(sz, szt);
			#endif
		}
	}
	return sz;
}
#endif


CLaunch::CLaunch()
{
	InitFiles();
	InitRequest();
	m_lLaunchWaitTimeOut = LAUNCH_WAIT_TIMEOUT;
	m_bPreferOnline = false;
}

CLaunch::~CLaunch()
{
	if (m_pMap)
		delete(m_pMap);
}

// This initialization happens exactly once for the object.
// Once we've looked in the registry and found a file, it isn't going anywhere.
void CLaunch::InitFiles()
{
	DWORD dwBufSize;
	CRegKey reg;
	DWORD dwBytesUsed;

	m_bHaveMapPath = false;
	m_bHaveDefMapFile = false;
	m_bHaveDszPath = false;
	m_szLauncherResources[0] = NULL;
	m_szDefMapFile[0] = NULL;
	m_szLaunchMapFile[0] = NULL;
	m_szDszResPath[0] = NULL;
	m_szMapFile[0] = NULL;
	m_pMap = NULL;

	if (ERROR_SUCCESS == reg.Open(
				HKEY_LOCAL_MACHINE, SZ_LAUNCHER_ROOT))
	{
		dwBufSize = MAX_PATH;
		TCHAR szLauncherResources[MAX_PATH];
		if (ERROR_SUCCESS == reg.QueryValue(
			szLauncherResources, SZ_GLOBAL_LAUNCHER_RES, &dwBufSize))
		{
			if ('\\' != szLauncherResources[_tcslen(szLauncherResources) - 1])
				_tcscat(szLauncherResources, _T("\\"));

			dwBufSize = MAX_PATH;
			dwBytesUsed = ExpandEnvironmentStrings(szLauncherResources, m_szLauncherResources, dwBufSize);	// The value returned by ExpandEnviromentStrings is larger than the required size.

		}
		dwBufSize = MAX_PATH;
		TCHAR szDefMapFile[MAX_PATH];
		if (ERROR_SUCCESS == reg.QueryValue(
					szDefMapFile, SZ_GLOBAL_MAP_FILE, &dwBufSize))
		{
			WIN32_FIND_DATA data;
			HANDLE hFind;

			dwBufSize = MAX_PATH;
			dwBytesUsed = ExpandEnvironmentStrings(szDefMapFile, m_szDefMapFile, dwBufSize);	// The value returned by ExpandEnviromentStrings is larger than the required size.
			if (0 != dwBytesUsed)
			{
				m_bHaveMapPath = true;
				_tcscpy(m_szLaunchMapFile, m_szLauncherResources);
				_tcscat(m_szLaunchMapFile, m_szDefMapFile);
				hFind = FindFirstFile(m_szLaunchMapFile, &data);
				if (INVALID_HANDLE_VALUE != hFind)
				{
					m_bHaveDefMapFile = true;
					FindClose(hFind);
				}
				else
				{
					m_bHaveDefMapFile = false;
				}
			}
		}
		reg.Close();
	}
	// Need the TShoot.ocx resource path to verify that the networks exist.
	if (ERROR_SUCCESS == reg.Open(HKEY_LOCAL_MACHINE, SZ_TSHOOT_ROOT))
	{
		dwBufSize = MAX_PATH;
		TCHAR szDszResPath[MAX_PATH];
		if (ERROR_SUCCESS == reg.QueryValue(szDszResPath, SZ_TSHOOT_RES, &dwBufSize))
		{
			if ('\\' != szDszResPath[_tcslen(szDszResPath) - 1])
				_tcscat(szDszResPath, _T("\\"));
			
			dwBufSize = MAX_PATH;
			dwBytesUsed = ExpandEnvironmentStrings(szDszResPath, m_szDszResPath, dwBufSize);	// The value returned by ExpandEnviromentStrings is larger than the required size.
			if (0 == dwBytesUsed)
				m_bHaveDszPath = false;
			else
				m_bHaveDszPath = true;
		}
		reg.Close();
	}

	return;
}

// This initialization can happen more than once for the object.
// If we are going to use the same object to make a second request, there are things we
//	want to clean up.
void CLaunch::InitRequest()
{
	m_szAppName[0] = NULL;
	m_szAppVersion[0] = NULL;
	m_szAppProblem[0] = NULL;
	m_stkStatus.RemoveAll();
	m_Item.ReInit();
}

// >>> Why does this exist distinct from InitRequest()?
void CLaunch::ReInit()
{
	InitRequest();	
	return;
}

// >>> What exactly is the use of this? What is the distinction from InitRequest()?
void CLaunch::Clear()
{
	m_szAppName[0] = NULL;
	m_szAppVersion[0] = NULL;
	m_szAppProblem[0] = NULL;
	m_stkStatus.RemoveAll();
	m_Item.Clear();
	return;
}

// Verify that a given troubleshooting belief network exists.
bool CLaunch::VerifyNetworkExists(LPCTSTR szNetwork)
{
	bool bResult = true;
	if (NULL == szNetwork || NULL == szNetwork[0])
	{
		// Null name, don't even bother with a lookup.		
		m_stkStatus.Push(TSL_E_NETWORK_NF);
		bResult = false;
	}
	else
	{
		if (m_bHaveDszPath)
		{
			WIN32_FIND_DATA data;
			HANDLE hFind;
			TCHAR szDszFile[MAX_PATH];

			_tcscpy(szDszFile, m_szDszResPath);
			_tcscat(szDszFile, szNetwork);
			_tcscat(szDszFile, _T(".ds?"));
			
			hFind = FindFirstFile(szDszFile, &data);
			if (INVALID_HANDLE_VALUE == hFind)
			{
				m_stkStatus.Push(TSL_E_NETWORK_NF);
				bResult = false;
			}
			FindClose(hFind);
		}
		else
		{
			// we don't know what directory to look in.
			m_stkStatus.Push(TSL_E_NETWORK_REG);
			bResult = false;
		}
	}
	return bResult;
}

// Allows explicit specification of the troubleshooting network (and, optionally, 
//	problem node) to launch to.
// This is an alternative to determining network/node via a mapping.
// INPUT szNetwork
// INPUT szProblem: null pointer of null string ==> no problem node
//					any other value is symbolic name of problem node
bool CLaunch::SpecifyProblem(LPCTSTR szNetwork, LPCTSTR szProblem)
{
	bool bResult = true;
	if (!VerifyNetworkExists(szNetwork))	// Sets the network not found error.
	{
		bResult = false;
	}
	else
	{
		m_Item.SetNetwork(szNetwork);

		// Set problem node, if any.  OK if there is none.
		if (NULL != szProblem && NULL != szProblem[0])
			m_Item.SetProblem(szProblem);
	}
	return bResult;
}

// Allows explicit setting of a non-problem node.
// Obviously, node names only acquire meaning in the context of a belief network.
// INPUT szNode: symbolic node name
// INPUT szState: >>> not sure what is intended.  The corresponding value in TSLaunch API is
//	an integer state value.  Is this the decimal representation of that value or what? JM

bool CLaunch::SetNode(LPCTSTR szNode, LPCTSTR szState)
{
	bool bResult = true;
	if (NULL != szNode && NULL != szState)
	{
		m_Item.SetNode(szNode, szState);
	}
	else
	{
		m_stkStatus.Push(TSL_E_NODE_EMP);		
		bResult = false;
	}
	return bResult;
}

// Sets machine ID so that WBEM can sniff on a remote machine.
HRESULT CLaunch::MachineID(BSTR &bstrMachineID, DWORD *pdwResult)
{
	HRESULT hRes = S_OK;
	if (!BSTRToTCHAR(m_Item.m_szMachineID, bstrMachineID, CItem::GUID_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		hRes = TSL_E_FAIL;
	}
	return hRes;
}

// Sets Device Instance ID so that WBEM can sniff correct device
HRESULT CLaunch::DeviceInstanceID(BSTR &bstrDeviceInstanceID, DWORD *pdwResult)
{
	HRESULT hRes = S_OK;
	if (!BSTRToTCHAR(m_Item.m_szDeviceInstanceID, bstrDeviceInstanceID, CItem::GUID_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		hRes = TSL_E_FAIL;
	}
	return hRes;
}

void CLaunch::SetPreferOnline(short bPreferOnline)
{
	// The next line's ugly, but correct.  bPreferOnline is not necessarily a valid
	//	Boolean; we want to make sure we get a valid Boolean in	m_bPreferOnline.
	m_bPreferOnline = (0 != bPreferOnline);
	return;
}

// CheckMapFile:  Uses szAppName member to set szMapFile.  
// First, check the registry for an application-specific map file.  If we can't find one,
//	check for a default map file.  If that doesn't exist either, fail.
// INPUT szAppName
// OUTPUT szMapFile
bool CLaunch::CheckMapFile(TCHAR * szAppName, TCHAR szMapFile[MAX_PATH], DWORD *pdwResult)
{
	bool bHaveMapFile = false;

	if (NULL == szAppName || NULL == szAppName[0])
	{
		// Application name may not be null.
		m_stkStatus.Push(TSL_ERROR_UNKNOWN_APP);
		*pdwResult = TSL_ERROR_GENERAL;
		return false;
	}
	else
	{
		DWORD dwBufSize;
		CRegKey reg;
		if (ERROR_SUCCESS == reg.Open(HKEY_LOCAL_MACHINE, SZ_LAUNCHER_APP_ROOT))
		{
			dwBufSize = MAX_PATH;
			if (ERROR_SUCCESS == reg.Open(reg.m_hKey, szAppName))
			{
				if (ERROR_SUCCESS == reg.QueryValue(szMapFile, SZ_APPS_MAP_FILE, &dwBufSize))
					return true;
			}
		}
	}

	// Does a default map file exist?
	if (m_bHaveDefMapFile)
	{
		_tcscpy(szMapFile, m_szLaunchMapFile);
	}
	else
	{	// Either the registry setting is missing or the file is not 
		// where the registry says it is.
		if (m_bHaveMapPath)	// Have the registry entry.
			m_stkStatus.Push(TSL_E_MAPPING_DB_NF);
		else
			m_stkStatus.Push(TSL_E_MAPPING_DB_REG);
		*pdwResult = TSL_ERROR_GENERAL;
	}
	return m_bHaveDefMapFile;
}

// Uses the mapping classes to map Caller() and DeviceID() information, then copies the 
//	CItem to global memory.
// >> Why is this called TestPut()?
// Returns false when the mapping fails.
bool CLaunch::TestPut()
{
	extern CSMStateInfo g_StateInfo;
	DWORD dwResult;
	Map(&dwResult);
	if (TSL_OK != dwResult)
		return false;
	g_StateInfo.TestPut(m_Item);	// Copies m_Item to global memory.
	return true;
}

// Perform any necessary mapping, then launch the Local Troubleshooter.
bool CLaunch::Go(DWORD dwTimeOut, DWORD *pdwResult)
{
	DWORD dwRes;
	bool bResult = true;
	extern CSMStateInfo g_StateInfo;
	TCHAR szContainerPathName[MAX_PATH];  szContainerPathName[0] = 0;
	TCHAR szSniffScriptFile[MAX_PATH];    szSniffScriptFile[0] = 0;
	TCHAR szSniffStandardFile[MAX_PATH];  szSniffStandardFile[0] = 0;
	TCHAR szWebPage[MAX_PATH];            szWebPage[0] = 0;
	TCHAR szDefaultNetwork[SYM_LEN];      szDefaultNetwork[0] = 0;
	TCHAR *szCmd = NULL, *szNetwork = NULL;

	if (TSL_OK == (dwRes = GetContainerPathName(szContainerPathName)))
	{
		m_Item.SetContainerPathName(szContainerPathName);
		m_Item.SetSniffScriptFile(szSniffScriptFile);
	}
	else 
	{
		m_stkStatus.Push(dwRes);
		// if container is not found - no reason to continue
		*pdwResult = TSL_ERROR_GENERAL;
		return false;
	}

	if (!m_Item.NetworkSet())	
	{
		if (Map(&dwRes) &&
			TSL_OK == (dwRes = GetWebPage(szWebPage)) // get web page
		   )
		{
			m_Item.SetWebPage(szWebPage);
			// network and problem are set by Map function
			m_Item.SetLaunchRegime(launchMap);
		}
		else
		{
			m_stkStatus.Push(dwRes);
			if (TSL_OK == (dwRes = GetDefaultURL(szWebPage))) // get "DEFAULT PAGE",
												// actually a URL which might (for example)
												// refernce a page compiled into a .CHM file
			{
				m_Item.SetWebPage(szWebPage);
				m_Item.SetNetwork(NULL); // network are set to NULL in this case
				m_Item.SetProblem(NULL); // problem are set to NULL in this case
				m_Item.SetLaunchRegime(launchDefaultWebPage);
			}
			else
			{	
				if (TSL_OK == (dwRes = GetDefaultNetwork(szDefaultNetwork)) && // get default network 
					TSL_OK == (dwRes = GetWebPage(szWebPage)) // get web page
				   )  
				{
					m_Item.SetWebPage(szWebPage);
					m_Item.SetNetwork(szDefaultNetwork);
					m_Item.SetProblem(NULL); // problem is set to NULL in this case
					m_Item.SetLaunchRegime(launchDefaultNetwork);
				}
				else
				{
					// complete failure
					m_stkStatus.Push(dwRes);
					*pdwResult = TSL_ERROR_GENERAL;
					m_Item.SetLaunchRegime(launchIndefinite);
					return false; 
				}
			}
		}
	}							  
	else
	{
		if (TSL_OK == (dwRes = GetWebPage(szWebPage)))
		{
			m_Item.SetWebPage(szWebPage);
			// network is known, problem can be either known(set) or unknown(not set)
			m_Item.SetLaunchRegime(launchKnownNetwork);
		}
		else
		{
			// complete failure
			m_stkStatus.Push(dwRes);
			*pdwResult = TSL_ERROR_GENERAL;
			m_Item.SetLaunchRegime(launchIndefinite);
			return false; 
		}
	}
								  
	// set sniff script and standard file
	m_Item.GetNetwork(&szCmd, &szNetwork);
	if (TSL_OK == (dwRes = GetSniffScriptFile(szSniffScriptFile, szNetwork[0] ? szNetwork : NULL)) &&
		TSL_OK == (dwRes = GetSniffStandardFile(szSniffStandardFile))
	   )
	{
		m_Item.SetSniffScriptFile(szSniffScriptFile);
		m_Item.SetSniffStandardFile(szSniffStandardFile);
	}
	else
	{
		// can not find script file path - failure
		m_stkStatus.Push(dwRes);
		*pdwResult = TSL_ERROR_GENERAL;
		m_Item.SetLaunchRegime(launchIndefinite);
		return false; 
	}
    
	// parse warnings according to the launch regime
	//
	if (launchMap == m_Item.GetLaunchRegime() ||
		launchKnownNetwork == m_Item.GetLaunchRegime()
	   )
	{
		if (!m_Item.ProblemSet())
		{
				m_stkStatus.Push(TSL_WARNING_NO_PROBLEM_NODE);
				*pdwResult = TSL_WARNING_GENERAL;
		}
	}

	// parse launches according to the launch regime
	//
	if (launchMap == m_Item.GetLaunchRegime() ||
		launchDefaultNetwork == m_Item.GetLaunchRegime()
	   )
	{
		if (m_Item.NetworkSet())
		{

#ifdef JDEBUG
			HANDLE hDebugFile;
			char* szStart = "START\n";
			char* szEnd = "END\n";
			DWORD dwBytesWritten;

			hDebugFile = CreateFile(
				_T("jdebug.txt"),  
				GENERIC_WRITE, 
				FILE_SHARE_READ, 
				NULL, 
				CREATE_ALWAYS,
				FILE_ATTRIBUTE_NORMAL,
				NULL);
			WriteFile( 
				hDebugFile, 
				szStart, 
				strlen(szStart),
				&dwBytesWritten,
				NULL);
				
			TCHAR *sztCmd, *sztVal;
			char sz[200], szCmd[100], szVal[100];

			m_Item.GetNetwork(&sztCmd, &sztVal);

			ToSBCS (szCmd, sztCmd, 100);
			ToSBCS (szVal, sztVal, 100);

			sprintf(sz, "%s %s\n", szCmd, szVal);

			WriteFile( 
				hDebugFile, 
				sz, 
				strlen(sz),
				&dwBytesWritten,
				NULL);
				
			if (m_Item.ProblemSet())
			{
				m_Item.GetProblem(&sztCmd, &sztVal);

				ToSBCS (szCmd, sztCmd, 100);
				ToSBCS (szVal, sztVal, 100);

				sprintf(sz, "%s %s\n", szCmd, szVal);

				WriteFile( 
					hDebugFile, 
					sz, 
					strlen(sz),
					&dwBytesWritten,
					NULL);
			}

			WriteFile( 
				hDebugFile, 
				szEnd, 
				strlen(szEnd),
				&dwBytesWritten,
				NULL);
			CloseHandle(hDebugFile);
#endif
			bResult = g_StateInfo.GoGo(dwTimeOut, m_Item, pdwResult);
		}
		else
		{
			*pdwResult = TSL_ERROR_GENERAL;
			m_stkStatus.Push(TSL_ERROR_NO_NETWORK);
			bResult = false;
		}
	}

	if (launchKnownNetwork == m_Item.GetLaunchRegime() )
	{
		bResult = g_StateInfo.GoGo(dwTimeOut, m_Item, pdwResult);
	}

	if (launchDefaultWebPage == m_Item.GetLaunchRegime())
	{
		bResult = g_StateInfo.GoURL(m_Item, pdwResult);

	}	

	return bResult;
}

HRESULT CLaunch::LaunchKnown(DWORD * pdwResult)
{
	HRESULT hRes = S_OK;
	// Launch the shooter.
	if (!Go(m_lLaunchWaitTimeOut, pdwResult))
		hRes = TSL_E_FAIL;
	return hRes;
}

HRESULT CLaunch::Launch(BSTR bstrCallerName, BSTR bstrCallerVersion, 
								BSTR bstrAppProblem, short bLaunch, DWORD * pdwResult)
{
	HRESULT hRes = S_OK;
	Clear();
	if (!BSTRToTCHAR(m_szAppName, bstrCallerName, SYM_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (!BSTRToTCHAR(m_szAppVersion, bstrCallerVersion, SYM_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (!BSTRToTCHAR(m_szAppProblem, bstrAppProblem, SYM_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (bLaunch)
	{
		if (!Go(m_lLaunchWaitTimeOut, pdwResult))
			hRes = TSL_E_FAIL;
	}
	else
	{
		if (!Map(pdwResult))
			hRes = TSL_E_FAIL;
	}
	return hRes;
}

HRESULT CLaunch::LaunchDevice(BSTR bstrCallerName, BSTR bstrCallerVersion, BSTR bstrPNPDeviceID, 
							  BSTR bstrDeviceClassGUID, BSTR bstrAppProblem, short bLaunch, DWORD * pdwResult)
{
	HRESULT hRes;
	Clear();

	if (!BSTRToTCHAR(m_szAppName, bstrCallerName, SYM_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (!BSTRToTCHAR(m_szAppVersion, bstrCallerVersion, SYM_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (!BSTRToTCHAR(m_szAppProblem, bstrAppProblem, SYM_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (!BSTRToTCHAR(m_Item.m_szPNPDeviceID, bstrPNPDeviceID, CItem::GUID_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (!BSTRToTCHAR(m_Item.m_szGuidClass, bstrDeviceClassGUID, CItem::GUID_LEN))
	{
		*pdwResult = TSL_E_MEM_EXCESSIVE;
		return TSL_E_FAIL;
	}
	if (m_Item.m_szGuidClass[0])
	{
		// Device Class GUID is non-null.  Make sure it's a valid GUID.
		GUID guidClass;
#ifdef _UNICODE
		RPC_STATUS rpcstatus = UuidFromString(
			m_Item.m_szGuidClass, &guidClass );
#else
		RPC_STATUS rpcstatus = UuidFromString(
			(unsigned char *) m_Item.m_szGuidClass, &guidClass );
#endif
		if ( rpcstatus == RPC_S_INVALID_STRING_UUID)
		{
			m_stkStatus.Push(TSL_WARNING_ILLFORMED_CLASS_GUID);
		}
	}

	if (bLaunch)
	{
		if (!Go(m_lLaunchWaitTimeOut, pdwResult))
			hRes = TSL_E_FAIL;
	}
	else
	{
		if (!Map(pdwResult))
			hRes = TSL_E_FAIL;
	}
	return hRes;
}

DWORD CLaunch::GetStatus()
{
	DWORD dwStatus = TSL_OK;
	if (!m_stkStatus.Empty())
		dwStatus = m_stkStatus.Pop();
	return dwStatus;
}

// OUTPUT *szPathName = Name of application to launch to (either IE or HTML Help System)
// Returns:
//	TSL_OK - success
//	TSL_E_CONTAINER_REG - failure to find IE (Internet Explorer) in registry
//	TSL_E_CONTAINER_NF - IE isn't where registry says to find it.
int CLaunch::GetContainerPathName(TCHAR szPathName[MAX_PATH])
{
	DWORD dwPathNameLen = MAX_PATH;
	int tslaHaveContainer = TSL_OK;
#ifndef _HH_CHM
	// use IE instead of HTML Help System
	if (!ReadRegSZ(HKEY_LOCAL_MACHINE,
				SZ_CONTAINER_APP_KEY,
				SZ_CONTAINER_APP_VALUE, szPathName, &dwPathNameLen))
	{
		tslaHaveContainer = TSL_E_CONTAINER_REG;
	}
	else
	{	// Need to verify that the container exists.
		WIN32_FIND_DATA data;
		HANDLE hContainer = FindFirstFile(szPathName, &data);
		if (INVALID_HANDLE_VALUE == hContainer)
			tslaHaveContainer = TSL_E_CONTAINER_NF;
		else
			FindClose(hContainer);
	}
#else
	_tcscpy(szPathName, _T("hh.exe"));
#endif
	return tslaHaveContainer;
}

// OUTPUT *szWebPage = Name of web page to launch to 
// We always launch to the same web page.  The information passed in m_Item ditinguishes
//	what will actually show on the screen.
// Path is from registry.  We concatenate on a backslash and SZ_WEB_PAGE (== "asklibrary.htm")
// Returns:
//	TSL_OK - success
//	TSL_E_WEB_PAGE_REG - failure to find web page for this purpose in registry
//	TSL_E_MEM_EXCESSIVE - Web page name longer than we can handle
//	TSL_E_WEB_PAGE_NF - Web page isn't where registry says to find it.
int CLaunch::GetWebPage(TCHAR szWebPage[MAX_PATH])
{
	int tslaHavePage = TSL_OK;
	DWORD dwWebPageLen = MAX_PATH;
	if (!ReadRegSZ(HKEY_LOCAL_MACHINE,
				SZ_LAUNCHER_ROOT,
				SZ_GLOBAL_LAUNCHER_RES, 
				szWebPage, 
				&dwWebPageLen))
	{
		tslaHavePage = TSL_E_WEB_PAGE_REG;
	}
	else
	{
		int Len = _tcslen(szWebPage);
		dwWebPageLen = Len + 1 + _tcslen(SZ_WEB_PAGE); 
		if (dwWebPageLen > MAX_PATH)
		{
			tslaHavePage = TSL_E_MEM_EXCESSIVE;
		}
		else
		{
			if (szWebPage[Len - 1] != '\\')
				_tcscat(szWebPage, _T("\\"));
			_tcscat(szWebPage, SZ_WEB_PAGE);

			WIN32_FIND_DATA data;
			HANDLE hWebPage = FindFirstFile(szWebPage, &data);
			if (INVALID_HANDLE_VALUE == hWebPage)
				tslaHavePage = TSL_E_WEB_PAGE_NF;
			else
				FindClose(hWebPage);
		}
	}
	return tslaHavePage;
}

// OUTPUT *szSniffScriptFile = full path and file name either to "network"_sniff.htm file or null len string if file is not found
//	TSL_OK - success
//	TSL_E_SNIFF_SCRIPT_REG - failure to find file for this purpose in registry
int CLaunch::GetSniffScriptFile(TCHAR szSniffScriptFile[MAX_PATH], TCHAR* szNetwork)
{
	int tslaHavePage = TSL_OK;
	DWORD dwSniffScriptLen = MAX_PATH;
	TCHAR szSniffScriptPath[MAX_PATH] = {0};

	if (ReadRegSZ(HKEY_LOCAL_MACHINE,
			      SZ_TSHOOT_ROOT,
				  SZ_TSHOOT_RES, 
				  szSniffScriptPath, 
				  &dwSniffScriptLen))
	{
		int Len = _tcslen(szSniffScriptPath);

		dwSniffScriptLen = Len + 1 + (szNetwork ? _tcslen(szNetwork) + _tcslen(SZ_SNIFF_SCRIPT_APPENDIX) 
												: 0); 

		if (dwSniffScriptLen > MAX_PATH)
		{
			tslaHavePage = TSL_E_MEM_EXCESSIVE;
		}
		else
		{
			if (szSniffScriptPath[Len - 1] != '\\')
				_tcscat(szSniffScriptPath, _T("\\"));

			if (szNetwork)
			{
				TCHAR tmp[MAX_PATH] = {0};
				_tcscpy(tmp, szSniffScriptPath);
				_tcscat(tmp, szNetwork);
				_tcscat(tmp, SZ_SNIFF_SCRIPT_APPENDIX);

				WIN32_FIND_DATA data;
				HANDLE hSniffScript = FindFirstFile(tmp, &data);

				if (INVALID_HANDLE_VALUE == hSniffScript)
				{
					szSniffScriptFile[0] = 0;
				}
				else
				{
					_tcscpy(szSniffScriptFile, tmp);
					FindClose(hSniffScript);
				}
			}
			else
			{
				szSniffScriptFile[0] = 0;
			}
		}
	}
	else
	{
		tslaHavePage = TSL_E_SNIFF_SCRIPT_REG;
	}

	return tslaHavePage;
}

// OUTPUT *szSniffScriptFile = full path and file name of tssniffAsk.htm file no matter if it exists
//	TSL_OK - success
//	TSL_E_SNIFF_SCRIPT_REG - failure to find file for this purpose in registry
int CLaunch::GetSniffStandardFile(TCHAR szSniffStandardFile[MAX_PATH])
{
	int tslaHavePage = TSL_OK;
	DWORD dwSniffStandardLen = MAX_PATH;
	TCHAR szSniffStandardPath[MAX_PATH] = {0};

	if (ReadRegSZ(HKEY_LOCAL_MACHINE,
			      SZ_LAUNCHER_ROOT,
				  SZ_GLOBAL_LAUNCHER_RES, 
				  szSniffStandardPath, 
				  &dwSniffStandardLen))
	{
		int Len = _tcslen(szSniffStandardPath);

		dwSniffStandardLen = Len + 1 + _tcslen(SZ_SNIFF_SCRIPT_NAME);

		if (dwSniffStandardLen > MAX_PATH)
		{
			tslaHavePage = TSL_E_MEM_EXCESSIVE;
		}
		else
		{
			if (szSniffStandardPath[Len - 1] != '\\')
				_tcscat(szSniffStandardPath, _T("\\"));

			_tcscpy(szSniffStandardFile, szSniffStandardPath);
			_tcscat(szSniffStandardFile, SZ_SNIFF_SCRIPT_NAME);
		}
	}
	else
	{
		tslaHavePage = TSL_E_SNIFF_SCRIPT_REG;
	}

	return tslaHavePage;
}

// OUTPUT *szURL = URL to go to when mapping fails.  We get this from registry.
//	TSL_OK - success
//	TSL_E_WEB_PAGE_REG - failure to find web page for this purpose in registry
int CLaunch::GetDefaultURL(TCHAR szURL[MAX_PATH])
{
	int tslaHaveURL = TSL_OK;
	DWORD dwURLLen = MAX_PATH;
	if (!ReadRegSZ(HKEY_LOCAL_MACHINE,
				SZ_LAUNCHER_ROOT,
				SZ_DEFAULT_PAGE, 
				szURL, 
				&dwURLLen))
	{
		tslaHaveURL = TSL_E_WEB_PAGE_REG;
	}
	return tslaHaveURL;
}

// Returns TSL_OK and default network name in szDefaultNetwork
// if successful
int CLaunch::GetDefaultNetwork(TCHAR szDefaultNetwork[SYM_LEN])
{
	DWORD dwLen = SYM_LEN;

	if (ReadRegSZ(HKEY_LOCAL_MACHINE, SZ_LAUNCHER_ROOT, SZ_DEFAULT_NETWORK,
		     	  szDefaultNetwork, &dwLen))
		if (VerifyNetworkExists(szDefaultNetwork))

			return TSL_OK;

	return TSL_E_NO_DEFAULT_NET;
}

bool CLaunch::Map(DWORD *pdwResult)
{
	bool bOK = true;
	TCHAR szMapFile[MAX_PATH];
	TCHAR szNetwork[SYM_LEN];           szNetwork[0] = NULL;
	TCHAR szTShootProblem[SYM_LEN];     szTShootProblem[0] = NULL;

	bOK = CheckMapFile(m_szAppName, szMapFile, pdwResult);

	// bOK false at this point means either the registry setting is missing or the file 
	//	is not where the registry says it is.  PdwResult has already been set in CheckMapFile.

	if (bOK && _tcscmp(m_szMapFile, szMapFile))
	{
		// The mapping file we desire is _not_ already loaded
		if (m_pMap)
		{
			// we were using a different mapping file.  We have to get rid of it.
			delete m_pMap;
		}
		// else we weren't using a mapping file yet.

		m_pMap = new TSMapClient(szMapFile);
		if (TSL_OK != m_pMap->GetStatus())
		{
			*pdwResult = m_pMap->GetStatus();
			bOK = false;
		}
		else
		{
			// We've successfully init'd m_pMap on the basis of the new map file.
			// Indicate that it's loaded.
			_tcscpy(m_szMapFile, szMapFile);
		}
	}

	if (bOK)
    {
		DWORD dwRes;
		
		// Now perform mapping itself
		//		
		dwRes = m_pMap->FromAppVerDevAndClassToTS(m_szAppName, m_szAppVersion,
				m_Item.m_szPNPDeviceID, m_Item.m_szGuidClass, m_szAppProblem,
				szNetwork, szTShootProblem);

		// As documented for TSMapRuntimeAbstract::FromAppVerDevAndClassToTS(), there are two
		//	return values here which require that we check for further status details: TSL_OK
		//	(which means we found a mapping, but doesn't rule out warnings) and 
		//	TSL_ERROR_NO_NETWORK (which means we didn't find a mapping, and is typically 
		//	accompanied by further clarifications).
		if (TSL_OK == dwRes || TSL_ERROR_NO_NETWORK == dwRes)
		{
			DWORD dwStatus;
			while (0 != (dwStatus = m_pMap->MoreStatus()))
				m_stkStatus.Push(dwStatus);
		}

		if (TSL_OK != dwRes)
			m_stkStatus.Push(dwRes);	// save the precise error status

		if (TSLIsError(dwRes) )
			bOK = false;

		if (bOK)
		{
			// We have a network name.
			bOK = VerifyNetworkExists(szNetwork);
		}

		if (bOK)
		{
			// We have a network name and we've verified that the network exists.
			// Set the item's network and tshoot problem.
			m_Item.SetNetwork(szNetwork);
			m_Item.SetProblem(szTShootProblem);
		}
		else
			*pdwResult = TSL_ERROR_GENERAL;
	} 
	
    return bOK;
}