// UMDialog.cpp : implementation file
// Author: J. Eckhardt, ECO Kommunikation
// Copyright (c) 1997-1999 Microsoft Corporation
//
// History:
//		Changes 
//      Yuri Khramov
//      01-jun-99: DisplayName key used in the Dialog (Localization)
//		11-jun-99: DlgHasClosed code changed to work with app closure
//		15-jun-99: Timer delay increased 1000ms
//
//		Bug fixes and Changes Anil Kumar 1999
//---------------------------------------------------------------------
#include <afxwin.h>         // MFC core and standard components
#include <afxext.h>         // MFC extensions
#include "UManDlg.h"
#include "UMDialog.h"
#include "UMAbout.h"
#include "_UMDlg.h"
#include "_UMClnt.h"
#include "_UMTool.h"
#include "UMS_Ctrl.h"
#include "w95trace.h"
#include <WinSvc.h>
#include <htmlhelp.h>
#include <initguid.h>
#include <ole2.h>
#include "deskswitch.c"
#include "ManageShellLinks.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// --------------------------------------------
// constants
#define IDC_ABOUT 10
#define UPDATE_CLIENT_LIST_TIMER 1
// --------------------------------------------
// variables
static DWORD g_cClients = 0;
static umclient_tsp g_rgClients = NULL;
static DWORD s_dwStartMode = START_BY_OTHER;
static BOOL s_fShowWarningAgain = TRUE;
extern CUMDlgApp theApp;
// --------------------------------------------
// C prototypes
static BOOL InitClientData(void);
static BOOL StartClientsOnShow();
static BOOL WriteClientData(BOOL fRunningSecure);
static BOOL IsStartAuto();
static BOOL CantStopClient(umclient_tsp client);
static int GetClientNameFromAccelerator(WPARAM wVK);

extern "C" BOOL StartAppAsUser( LPCTSTR appPath,
					 LPTSTR cmdLine,
					 LPSTARTUPINFO lpStartupInfo,
					 LPPROCESS_INFORMATION lpProcessInformation);


// Help ID's for context sensitive help
DWORD g_rgHelpIds[] = {	
	IDC_NAME_STATUS, 3,
	IDC_START, 1001,
	IDC_STOP, 1002,
	IDC_START_AT_LOGON, 1003,	// TODO UE needs to update CS help
	IDC_START_WITH_UM, 1004,
    IDC_START_ON_LOCK, 1005,    // TODO UE needs to add to CS help
	IDOK, 1100,
	IDCANCEL, 1200,
	ID_HELP, 1300,
};

// ---------------------------------------------------------------
extern "C"{
//--------------------------------
HWND g_hWndDlg = NULL;
HWND aboutWnd = NULL;
static HANDLE s_hDlgThread = NULL;

static HDESK s_hdeskSave = 0;
static HDESK s_hdeskInput = 0;

// UnassignDesktop gets called after the thread has exited to
// close desktop handles opened in AssignDesktop.
inline void UnassignDesktop()
{
    if (s_hdeskInput)
	{
        CloseDesktop(s_hdeskInput); 
        s_hdeskInput = 0;
	}
}

BOOL AssignDesktop(DWORD dwThreadId)
{
    s_hdeskSave = GetThreadDesktop(dwThreadId);
    s_hdeskInput = OpenInputDesktop(0, FALSE, MAXIMUM_ALLOWED);
    if (!s_hdeskInput)
    {
        s_hdeskInput = OpenDesktop(_TEXT("Winlogon"),0,FALSE,MAXIMUM_ALLOWED);
    }
    
    if (s_hdeskInput)
    {
        BOOL fSet = SetThreadDesktop(s_hdeskInput);
    }
    return (s_hdeskInput)?TRUE:FALSE;
}

//--------------------------------
DWORD UManDlgThread(LPVOID /* UNUSED */ in)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	UMDialog dlg;

    // assign thread to the input desktop (have to do
    // this here so it works on the winlogon desktop)

    if (AssignDesktop(GetCurrentThreadId()))
    {
        // initialize COM *after* assign to input desktop
        // because CoInitialize creates a hidden window on
        // the current desktop.

        CoInitialize(NULL);
        InitCommonControls();

        if (InitClientData())
        {
            Sleep(10);
            dlg.DoModal();
            if (g_rgClients)
            {
                VirtualFree(g_rgClients,0,MEM_RELEASE);
                g_rgClients = NULL;
            }
            g_cClients = 0;
            g_hWndDlg = NULL;	
            s_hDlgThread = NULL;
        }

        CoUninitialize();   // uninitialize COM
    }

	return 1;
}

void StopDialog()
{
    if (aboutWnd)
    {
        EndDialog(aboutWnd,0);
        aboutWnd = NULL;
        Sleep(10);
    }
    if (g_hWndDlg)
    {
        ::PostMessage(g_hWndDlg, WM_CLOSE, 0, 0);
        g_hWndDlg = NULL;
        Sleep(10);
        UnassignDesktop();
    }
    if (g_rgClients)
    {
        VirtualFree(g_rgClients,0,MEM_RELEASE);
        g_rgClients = NULL;
    }
    g_cClients = 0;
}

//--------------------------------
#if defined(_X86_)
__declspec (dllexport)
#endif
// UManDlg - Opens or closes the utilman dialog.
//
// fShowDlg         - TRUE if dialog should be shown, FALSE if dialog should be closed
// fWaitForDlgClose - TRUE if the function should not return until the dialog
//                    is closed or a desktop switch happens else FALSE.
// dwVersion        - The utilman version
//
// returns TRUE if the dialog was opened or closed
// returns FALSE if the dialog could not be opened or it wasn't open
//
BOOL UManDlg(BOOL fShowDlg, BOOL fWaitForDlgClose, DWORD dwVersion)
{
	BOOL fRv = FALSE;
	if (dwVersion != UMANDLG_VERSION)
		return FALSE;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	if (fShowDlg)
	{
		if (!s_hDlgThread)
		{
			s_hDlgThread = CreateThread(NULL, 0, UManDlgThread, NULL, 0, NULL);
		} 
		else
		{
			SetForegroundWindow((aboutWnd)?aboutWnd:g_hWndDlg);
		}

		if (s_hDlgThread && fWaitForDlgClose)
        {
            // This code is executed on the default desktop for the following cases:
            //
            // 1. Utilman #1 run from the start menu
            // 2. Utilman #2 run from the start menu (utilman #1 is SYSTEM)
            // 3. Utilman #2 run by utilman #1 in user's context
            //
            // Wait for either the dialog to close or a desktop switch then return.
            // This will end this instance of utilman.  If there is a utilman
            // running as SYSTEM it will bring up the dialog on the other desktop.

            HANDLE rghEvents[2];

            rghEvents[0] = s_hDlgThread;
	        rghEvents[1] = OpenEvent(SYNCHRONIZE, FALSE, __TEXT("WinSta0_DesktopSwitch"));

	        while (TRUE)
            {
                DWORD dwObj = MsgWaitForMultipleObjects(2, rghEvents, FALSE, INFINITE, QS_ALLINPUT );
        
                switch (dwObj)
                {
                    case WAIT_OBJECT_0 + 1:    // the desktop is changing; close the dialog
                        StopDialog();
                        // intentional fall thru to cleanup code

                    case WAIT_OBJECT_0:        // the thread exited; clean up and return
                        CloseHandle(s_hDlgThread);
                        s_hDlgThread = 0;
                        CloseHandle(rghEvents[1]);
                        return TRUE;
                        break;

                    default:                 // process messages
                        {
                            MSG msg;
		                    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
                            {
                                TranslateMessage(&msg);
                                DispatchMessage(&msg);
                            }
                        }
                        break;
                }
            } 
        }
	}
	else
	{
        // This code is executed when utilman is running on the secure desktop.  In
        // that case, utilman brings up the dialog as a thread from its process. 
        // When the desktop switch is detected utilman calls this function to close 
        // the dialog.  It will be restarted again on the new desktop. 

		fRv = (g_hWndDlg && s_hDlgThread);

        StopDialog();
	}
	return fRv;
}

BOOL IsDialogUp()
{
    return (g_hWndDlg && s_hDlgThread)?TRUE:FALSE;
}

}//extern "C"


/////////////////////////////////////////////////////////////////////////////
// CWarningDlg dialog


CWarningDlg::CWarningDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CWarningDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CWarningDlg)
	m_fDontWarnAgain = TRUE;
	//}}AFX_DATA_INIT
}


void CWarningDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CWarningDlg)
	DDX_Check(pDX, IDC_CHK_WARN, m_fDontWarnAgain);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CWarningDlg, CDialog)
	//{{AFX_MSG_MAP(CWarningDlg)
		// NOTE: the ClassWizard will add message map macros here
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWarningDlg message handlers

/////////////////////////////////////////////////////////////////////////////
// UMDialog dialog
// --------------------------------------------
UMDialog::UMDialog(CWnd* pParent /*=NULL*/)
	: CDialog(UMDialog::IDD, pParent)
	, m_fRunningSecure(FALSE)
{
	m_szUMStr.LoadString(IDS_UM);

	//{{AFX_DATA_INIT(UMDialog)
	// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
}

UMDialog::~UMDialog()
{
	m_lbClientList.Detach();
}
// --------------------------------------------
void UMDialog::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(UMDialog)
	// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}
// --------------------------------------------
BEGIN_MESSAGE_MAP(UMDialog, CDialog)
//{{AFX_MSG_MAP(UMDialog)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_START, OnStart)
	ON_BN_CLICKED(IDC_STOP, OnStop)
	ON_WM_TIMER()
	ON_WM_HELPINFO()
	ON_COMMAND( ID_HELP, OnHelp )
	ON_LBN_SELCHANGE(IDC_NAME_STATUS, OnSelchangeNameStatus)
	ON_BN_CLICKED(IDC_START_AT_LOGON, OnStartAtLogon)
	ON_BN_CLICKED(IDC_START_WITH_UM, OnStartWithUm)
	ON_WM_CONTEXTMENU()
	ON_MESSAGE(WM_SYSCOMMAND,OnSysCommand)
	ON_BN_CLICKED(IDC_START_ON_LOCK, OnStartOnLock)
	ON_WM_SHOWWINDOW()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// UMDialog message handlers

BOOL UMDialog::PreTranslateMessage(MSG* pMsg) 
{
	// Override that allows use of function keys to launch applets when on
	// the logon desktop.  Only pay attention to key up to avoid dup calls.

	if (m_fRunningSecure && WM_KEYUP == pMsg->message) 
	{
		int iClient = GetClientNameFromAccelerator(pMsg->wParam);
		if (iClient >= 0)
		{
			m_lbClientList.SelectString(-1, g_rgClients[iClient].machine.DisplayName);
			OnStart();
			return TRUE;
		}
	}
	
	return CDialog::PreTranslateMessage(pMsg);
}

BOOL UMDialog::OnInitDialog()
{
	CDialog::OnInitDialog();

	// set the flag indicating if we are running in secure mode

	desktop_ts desktop;	
	QueryCurrentDesktop(&desktop, TRUE);
	m_fRunningSecure = RunSecure(desktop.type);

    if (s_fShowWarningAgain && s_dwStartMode == START_BY_MENU)
    {
        CWarningDlg dlgWarn;
        dlgWarn.m_fDontWarnAgain = !s_fShowWarningAgain;
        dlgWarn.DoModal();
        s_fShowWarningAgain = !dlgWarn.m_fDontWarnAgain;
    }

	g_hWndDlg = m_hWnd;	

	// change system menu

	CMenu *hSysMenu = GetSystemMenu(FALSE);
	if (hSysMenu)
	{
		CString str;
		hSysMenu->AppendMenu(MF_SEPARATOR);
		str.LoadString(IDS_ABOUT_STRING);
		hSysMenu->AppendMenu(MF_STRING,IDC_ABOUT,LPCTSTR(str));
	}

    // handle any "start when utility manager starts" applets

    StartClientsOnShow();

	// attach ListBox to member data and populate w/list of applications

	m_lbClientList.Attach(GetDlgItem(IDC_NAME_STATUS)->m_hWnd);
	ListClients();

	// Disable Help button if we are at WinLogon because the help 
	// dialog supports "Jump to URL..." exposing security risk.
	// The m_fRunningSecure variable is TRUE if UI shouldn't expose help.

	if (m_fRunningSecure)
	{
		EnableDlgItem(ID_HELP, FALSE, IDOK); 
	}

    // Disable "Start when UtilMan starts" unless user is an admin
    // and we are running in non-secure mode.

    if (s_dwStartMode != START_BY_MENU)
    {
        GetDlgItem(IDC_START_WITH_UM)->EnableWindow(IsAdmin() && !m_fRunningSecure);
    }

	// Bring dialog to top and center on desktop window

	RECT rectUmanDlg,rectDesktop;
	GetDesktopWindow()->GetWindowRect(&rectDesktop);
	GetWindowRect(&rectUmanDlg);

	long lDlgWidth = rectUmanDlg.right - rectUmanDlg.left;
	long lDlgHieght = rectUmanDlg.bottom - rectUmanDlg.top;
	if (!m_fRunningSecure)
	{
		rectUmanDlg.left = (rectDesktop.right - lDlgWidth)/2;
		rectUmanDlg.top = (rectDesktop.bottom - lDlgHieght)/2;
	} else
	{
		rectUmanDlg.left = rectDesktop.left + (long)(lDlgWidth/10);
		rectUmanDlg.top = rectDesktop.bottom - lDlgHieght - (long)(lDlgHieght/10);
	}

    // This looks a bit odd (SetForegroundWindow should also be activating 
    // the window) but if you don't call SetActiveWindow on the secure
    // desktop then the second, etc... WinKey+U will bring up UM hidden
    // behind the welcome "screen".

    SetActiveWindow();
    SetForegroundWindow();
	SetWindowPos(&wndTopMost,rectUmanDlg.left,rectUmanDlg.top,0,0,SWP_NOSIZE);
    
	if (!m_fRunningSecure)
    {
        // on default desktop the above SetWindowPos makes the dialog initially
        // on top and this call allows other apps to then be on top.
	    SetWindowPos(&wndNoTopMost,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
    }

    // start checking every so often to see if we need to update our display

	SetTimer(UPDATE_CLIENT_LIST_TIMER, 3000, NULL);

	return TRUE;  // return TRUE unless you set the focus to a control
}

// -----------------------------------------------------
void UMDialog::OnSysCommand(UINT nID,LPARAM lParam)
{
	if (nID == IDC_ABOUT)
	{
		UMAbout dlg;
		dlg.DoModal();
		aboutWnd = NULL;	
	}
	else
	{
		CDialog::OnSysCommand(nID,lParam);
	}
}//UMDialog::OnSysCommand
// ------------------------------------

// --------------------------------------------
// CanStartOnLockedDesktop - returns TRUE if applets can 
// be configured to be auto-started on the secure desktop
//
inline BOOL CanStartOnLockedDesktop(int iWhichClient, BOOL fRunningSecure)
{
    // user can ask for auto start on secure desktop if they are logged on, the
    // applet is OK'd to run on the secure desktop and the machine isn't using
    // fast user switching (FUS) (w/FUS Ctrl+Alt+Del disconnects the user session
    // rather than switching desktops).

    BOOL fCanStartOnLockedDesktop = 
        (
            !fRunningSecure && 
            g_rgClients[iWhichClient].user.fCanRunSecure &&
            CanLockDesktopWithoutDisconnect()
        )?TRUE:FALSE;

    return fCanStartOnLockedDesktop;
}

// --------------------------------------------
// OnSelchangeNameStatus is called when the user navigates the list
// box items by clicking with the mouse or using up/down arrows.
//
void UMDialog::OnSelchangeNameStatus() 
{
	// Get the currently selected item and update the controls for
	// the currently selected item.

	int iSel;
	if (GetSelectedClient((int)g_cClients, iSel))
	{
		// Group box label
		CString str(g_rgClients[iSel].machine.DisplayName);
		CString optStr;
		optStr.Format(IDS_OPTIONS, str);
		GetDlgItem(IDC_OPTIONS)->SetWindowText(optStr);

        // only enable options when started via WinKey+U 

        if (s_dwStartMode != START_BY_MENU)
        {
            // Disable "start at logon" at secure desktop to avoid mischief

            if (!m_fRunningSecure)
            {
                GetDlgItem(IDC_START_AT_LOGON)->EnableWindow(TRUE);
            } else
            {
                // this may be set in an upgrade situation; clear it
                g_rgClients[iSel].user.fStartAtLogon = FALSE;
                GetDlgItem(IDC_START_AT_LOGON)->EnableWindow(FALSE);
            }

            // Enable "start on locked desktop" if at default desktop and
            // when applet can run on secure desktop

            if (CanStartOnLockedDesktop(iSel, m_fRunningSecure))
            {
                GetDlgItem(IDC_START_ON_LOCK)->EnableWindow(TRUE);
            } else
            {
                // this may be set in an upgrade situation; clear it
                g_rgClients[iSel].user.fStartOnLockDesktop = FALSE;
                GetDlgItem(IDC_START_ON_LOCK)->EnableWindow(FALSE);
            }
		    
		    // Start option checkboxes

		    CheckDlgButton(IDC_START_AT_LOGON, (g_rgClients[iSel].user.fStartAtLogon)?TRUE:FALSE);
            CheckDlgButton(IDC_START_ON_LOCK, (g_rgClients[iSel].user.fStartOnLockDesktop)?TRUE:FALSE);
		    CheckDlgButton(IDC_START_WITH_UM, (g_rgClients[iSel].user.fStartWithUtilityManager)?TRUE:FALSE);
        } else
        {
            GetDlgItem(IDC_START_AT_LOGON)->EnableWindow(FALSE);
            GetDlgItem(IDC_START_ON_LOCK)->EnableWindow(FALSE);
            GetDlgItem(IDC_START_WITH_UM)->EnableWindow(FALSE);
		    CheckDlgButton(IDC_START_AT_LOGON, FALSE);
            CheckDlgButton(IDC_START_ON_LOCK, FALSE);
		    CheckDlgButton(IDC_START_WITH_UM, FALSE);
        }

		// Start and stop buttons
		DWORD dwState = g_rgClients[iSel].state;

		if ((dwState == UM_CLIENT_RUNNING) 
			&& (g_rgClients[iSel].runCount >= g_rgClients[iSel].machine.MaxRunCount))
			EnableDlgItem(IDC_START, FALSE, IDC_NAME_STATUS);
		else
			EnableDlgItem(IDC_START, TRUE, IDC_NAME_STATUS);

		if ((dwState == UM_CLIENT_NOT_RUNNING) || CantStopClient(&g_rgClients[iSel]))
			EnableDlgItem(IDC_STOP, FALSE, IDC_NAME_STATUS);
		else
			EnableDlgItem(IDC_STOP, TRUE, IDC_NAME_STATUS);

	}// else ignore selections not in a valid range
}

// --------------------------------------------
void UMDialog::OnClose()
{
	// behave like cancel
	CDialog::OnClose();
}//UMDialog::OnClose

// --------------------------------------------
// OnStart is called when the Start button is clicked.  It starts
// the client ap then lets the timer update saved state.
//
void UMDialog::OnStart()
{
    int iSel;
    if (GetSelectedClient((int)g_cClients, iSel))
    {
        if (StartClient(m_hWnd, &g_rgClients[iSel]))
        {
            KillTimer(UPDATE_CLIENT_LIST_TIMER);
            EnableDlgItem(IDC_STOP, TRUE, IDC_NAME_STATUS);
			ListClients();
            SetTimer(UPDATE_CLIENT_LIST_TIMER, 3000, NULL);
            
            if (g_rgClients[iSel].runCount+1 >= g_rgClients[iSel].machine.MaxRunCount)
                EnableDlgItem(IDC_START, FALSE, IDC_STOP);
        }
        else if (g_rgClients[iSel].runCount < g_rgClients[iSel].machine.MaxRunCount)
        {
            // Unable to start
            CString str;	
            str.LoadString((m_fRunningSecure)?IDS_SECUREMODE:IDS_ERRSTART);
            MessageBox(str, m_szUMStr, MB_OK);	
        }
    }
}

// --------------------------------------------
// OnStop is called when the Stop button is clicked.  It stops
// the client ap then lets the timer update saved state.
//
void UMDialog::OnStop()
{
	int iSel;
	if (GetSelectedClient((int)g_cClients, iSel))
	{
		if (StopClient(&g_rgClients[iSel]))
		{
            KillTimer(UPDATE_CLIENT_LIST_TIMER);
            GetDlgItem(IDC_START)->EnableWindow(TRUE);
			ListClients();
			EnableDlgItem(IDC_STOP, FALSE, IDOK);
            SetTimer(UPDATE_CLIENT_LIST_TIMER, 3000, NULL);
		}
		else
		{
			// Unable to stop
			CString str;
			str.LoadString(IDS_ERRSTOP);
			MessageBox(str, m_szUMStr, MB_OK);	
		}
	}
}

void UMDialog::SaveCurrentState()
{
	int iSel;
	if (GetSelectedClient((int)g_cClients, iSel))
	{
		g_rgClients[iSel].user.fStartAtLogon
			= (IsDlgButtonChecked(IDC_START_AT_LOGON))?TRUE:FALSE;
		g_rgClients[iSel].user.fStartWithUtilityManager
			= (IsDlgButtonChecked(IDC_START_WITH_UM))?TRUE:FALSE;
        g_rgClients[iSel].user.fStartOnLockDesktop
            = (IsDlgButtonChecked(IDC_START_ON_LOCK))?TRUE:FALSE;
	}
}

// --------------------------------------------
// OnOK is called when the user clicks the OK button to
// dismiss the UtilMan dialog.
//
void UMDialog::OnOK()
{
	SaveCurrentState();

	WriteClientData(m_fRunningSecure);

	CDialog::OnOK();
}//UMDialog::OnOK

// ----------------------------------------------------------------------------
// OnTimer is called to check the status of client apps that are displayed
// in the UI.  This keeps the UI consistent with the running client app's.
//
void UMDialog::OnTimer(UINT nIDEvent)
{
	if (nIDEvent == UPDATE_CLIENT_LIST_TIMER)
	{
		UINT uiElapsed = 3000; 
		KillTimer(UPDATE_CLIENT_LIST_TIMER);

        // get current status and pick up new apps
		if (CheckStatus(g_rgClients, g_cClients))
        {
		    ListClients();          // something has changed - update the UI
			uiElapsed = 500;
        }

		SetTimer(UPDATE_CLIENT_LIST_TIMER, uiElapsed, NULL);
	}
	CDialog::OnTimer(nIDEvent);
}

// --------------------------------------------
// OnHelpInfo provides context sensitive help.  It only does
// this if not on the WinLogon desktop.
//
BOOL UMDialog::OnHelpInfo(HELPINFO* pHelpInfo)
{
	if (m_fRunningSecure)	
		return FALSE;

	if ( pHelpInfo->iCtrlId == IDC_OPTIONS )
		return TRUE;

	::WinHelp((HWND)pHelpInfo->hItemHandle, __TEXT("utilmgr.hlp"), HELP_WM_HELP,
				(DWORD_PTR) (LPSTR) g_rgHelpIds);

	return TRUE;
}

// --------------------------------------------
// OnHelpInfo provides context sensitive help when the user
// right-clicks the dialog.  It only does this if not on the 
// WinLogon desktop.
//
void UMDialog::OnContextMenu(CWnd* pWnd, CPoint point) 
{
	if (m_fRunningSecure)	
		return;

	::WinHelp(pWnd->m_hWnd, __TEXT("utilmgr.hlp"), HELP_CONTEXTMENU
		, (DWORD_PTR) (LPSTR) g_rgHelpIds);
}

// --------------------------------------------
// OnHelp provides standard help.  It only does this if not
// on the WinLogon desktop.
//
void UMDialog::OnHelp()
{
    if (m_fRunningSecure)	
        return;
    
    ::HtmlHelp(m_hWnd , TEXT("utilmgr.chm"), HH_DISPLAY_TOPIC, 0);
}

// ----------------------------------
void UMDialog::EnableDlgItem(DWORD dwEnableMe, BOOL fEnable, DWORD dwFocusHere)
{
	// when disabling a control that currently has focs switch it to dwFocusHere
	if (!fEnable && (GetFocus() == GetDlgItem(dwEnableMe)))
        GetDlgItem(dwFocusHere)->SetFocus();

    GetDlgItem(dwEnableMe)->EnableWindow(fEnable);
}

void UMDialog::SetStateStr(int iClient)
{
	switch (g_rgClients[iClient].state)
	{
		case UM_CLIENT_NOT_RUNNING:
		m_szStateStr.Format(IDS_NOT_RUNNING, g_rgClients[iClient].machine.DisplayName);
		break;

		case UM_CLIENT_RUNNING:
		m_szStateStr.Format(IDS_RUNNING, g_rgClients[iClient].machine.DisplayName);
		break;

		case UM_CLIENT_NOT_RESPONDING:
		m_szStateStr.Format(IDS_NOT_RESPONDING, g_rgClients[iClient].machine.DisplayName);
		break;

		default:
		m_szStateStr.Empty();
		break;
	}
}

// --------------------------------------------
void UMDialog::ListClients()
{
	// Re-do the client list box with latest state info

    int iCurSel = m_lbClientList.GetCurSel();
    if (iCurSel == LB_ERR)
        iCurSel = 0;

	m_lbClientList.ResetContent();
	
	for (DWORD i = 0; i < g_cClients; i++)
	{
		SetStateStr(i);

		if (!m_szStateStr.IsEmpty())
        {
            m_lbClientList.AddString(m_szStateStr);
        }
	}
	m_lbClientList.SetCurSel(iCurSel);

	// Refresh button states in case they've changed 
	// (this happens on desktop switch)

	OnSelchangeNameStatus();
}

// --------------------------------------------
// UpdateClientState updates the client list box with the current state
// of the application (running, not running, not responding)
//
void UMDialog::UpdateClientState(int iSel)
{
	SetStateStr(iSel);
	m_lbClientList.DeleteString(iSel);
	m_lbClientList.InsertString(iSel, m_szStateStr);
	m_lbClientList.SetCurSel(iSel);

}

// --------------------------------------------
// OnStartAtLogon updates the state of the client in memory when the
// Start with Windows checkbox is checked or unchecked.
//
void UMDialog::OnStartAtLogon() 
{
	SaveCurrentState();
}

// --------------------------------------------
// OnStartWithUm updates the state of the client in memory when the
// Start with Utility Manager checkbox is checked or unchecked.
//
void UMDialog::OnStartWithUm() 
{
	SaveCurrentState();
}

// --------------------------------------------
// OnStartOnLock updates the state of the client in memory when the
// Start when I lock my desktop checkbox is checked or unchecked.
//
void UMDialog::OnStartOnLock() 
{
	SaveCurrentState();
}

// --------------------------------------------
// OnShowWindow 
// This was added for a timing problem where utilman came up running in the system context on the users desktop
// this code here makes sure that that cannot happen by cheching right when the dialog is about to appear
//
void UMDialog::OnShowWindow(BOOL bShow, UINT nStatus) 
{
    HDESK hdesk;
    SID *desktopSID = NULL;
    
	hdesk = OpenInputDesktop(0, FALSE, MAXIMUM_ALLOWED);
	// this is expected to fail for the winlogon desktop and thats ok
	if (hdesk)     
	{
        TCHAR desktopName[NAME_LEN];
        DWORD nl, SIDLen = 0;
        
    	if (!GetUserObjectInformation(hdesk, UOI_NAME, desktopName, NAME_LEN, &nl))
    	    goto StopDialog;

    	if (!GetUserObjectInformation(hdesk, UOI_USER_SID, desktopSID, 0, &SIDLen))
    	{
        	if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        	    goto StopDialog;
    	}
    	
    	if (SIDLen > 0 && !lstrcmpi(desktopName, TEXT("Default")))
    	{
    	    desktopSID = (SID*)new BYTE[SIDLen];
    	    if (!desktopSID)
    	        goto StopDialog;
    	    
        	if (!GetUserObjectInformation(hdesk, UOI_USER_SID, desktopSID, SIDLen, &SIDLen))
        	    goto StopDialog;

        	BOOL fError;
            HANDLE hUserToken = GetUserAccessToken(TRUE, &fError);
            if (fError)
                goto StopDialog;
            
            // We get a token only if there is a logged on user.  
            // If there is not then we can come up as system with no worries.
            if (!hUserToken)
                goto LetDialogComeup;

            BOOL fStatus = FALSE;
        	BOOL fIsInteractiveUser = FALSE;
            PSID psidInteractive = InteractiveUserSid(TRUE);

            if (!psidInteractive)
                goto StopDialog;

            fStatus = CheckTokenMembership(hUserToken, psidInteractive, &fIsInteractiveUser);

            //If the logged on user is the interactive user and we are running as system then it is a
            // security risk to show UI.  This can happen when rappidly switching desktops.
            if ( fStatus && fIsInteractiveUser && IsSystem()) 
                goto StopDialog;
            
        }
    	
	}

    LetDialogComeup:
        if (desktopSID)
            delete [] desktopSID;
        return;
    
	StopDialog:
        StopDialog();
        if (desktopSID)
            delete [] desktopSID;

}


/////////////////////////////////////////////////////////////////////////////
// C code
//-----------------------------------------------------------------

__inline void ReplaceDisplayName(LPTSTR szName, int iRID)
{
	TCHAR szBuf[MAX_APPLICATION_NAME_LEN];
	if (LoadString(AfxGetInstanceHandle(), iRID, szBuf, MAX_APPLICATION_NAME_LEN))
		lstrcpy(szName, szBuf);
}

void SetLocalizedDisplayName()
{
	// Make localization easier; don't require them to localize registry entries.
    // Instead, replace our copy with the localized version.  This appears to be
    // duplicate code to that in umanrun.c however, that part of the code always
    // runs as system and therefore the DisplayName is set to the default system
    // language.  This part of the code (the UI) runs as the logged on user when
    // there is one so these resources will be the user's language.  The resources
    // and associated code should be removed from utilman.exe and this code and
    // resources (from umandlg.dll) should be used.

    for (DWORD i=0;i<g_cClients;i++)
    {
	    if ( lstrcmp( g_rgClients[i].machine.ApplicationName, TEXT("Magnifier") ) == 0 )
	    {
		    ReplaceDisplayName(g_rgClients[i].machine.DisplayName, IDS_DISPLAY_NAME_MAGNIFIER);
	    }
	    else if ( lstrcmp( g_rgClients[i].machine.ApplicationName, TEXT("Narrator") ) == 0 ) 
	    {
		    ReplaceDisplayName(g_rgClients[i].machine.DisplayName, IDS_DISPLAY_NAME_NARRATOR);
	    }
	    else if ( lstrcmp( g_rgClients[i].machine.ApplicationName, TEXT("On-Screen Keyboard") ) == 0 ) 
	    {
		    ReplaceDisplayName(g_rgClients[i].machine.DisplayName, IDS_DISPLAY_NAME_OSK);
	    }
    }
}

static BOOL InitClientData(void)
{
    BOOL fRv = TRUE;

    // On initial run allocate and initialize client array
    
    if (!g_rgClients || !g_cClients)
    {
        umc_header_tsp pHdr = 0;
        umclient_tsp c = 0;
        DWORD_PTR accessID,accessID2;
        
        g_cClients = 0;
        g_rgClients = NULL;
        
        fRv = FALSE;

        pHdr = (umc_header_tsp)AccessIndependentMemory(
									UMC_HEADER_FILE, 
									sizeof(umc_header_ts), 
									FILE_MAP_READ,
									&accessID);
        if (!pHdr)
        {
            goto Cleanup;
        }
        
        s_dwStartMode = pHdr->dwStartMode;              // capture the Utilman start mode
        s_fShowWarningAgain = pHdr->fShowWarningAgain;  // and warning dialog flag
        
        if (!pHdr->numberOfClients)
        {
            goto Cleanup;
        }
        c = (umclient_tsp)AccessIndependentMemory(
								UMC_CLIENT_FILE, 
								sizeof(umclient_ts)*pHdr->numberOfClients, 
								FILE_MAP_READ,
								&accessID2);
        if (!c)
        {
            goto Cleanup;
        }
        g_rgClients = (umclient_tsp)VirtualAlloc(NULL, sizeof(umclient_ts)*pHdr->numberOfClients, MEM_RESERVE,PAGE_READWRITE);
        if (!g_rgClients)
        {
            goto Cleanup;
        }
        if (!VirtualAlloc(g_rgClients, sizeof(umclient_ts)*pHdr->numberOfClients, MEM_COMMIT, PAGE_READWRITE))
        {
            goto Cleanup;
        }

        fRv = TRUE;
        
        g_cClients = pHdr->numberOfClients;
        memcpy(g_rgClients,c,sizeof(umclient_ts)*pHdr->numberOfClients);

        SetLocalizedDisplayName();
        
Cleanup:
        if (pHdr)
        {
            UnAccessIndependentMemory(pHdr, accessID);
        }
        if (c)
        {
            UnAccessIndependentMemory(c, accessID2);
        }
        
        if (!fRv && g_rgClients)
        {
            VirtualFree(g_rgClients, 0, MEM_RELEASE);
            g_rgClients = NULL;
            g_cClients = 0;
        }

    }

    // "Start when I log on" is per-user setting so get that
    // each time the dialog is brought up

    CManageShellLinks CManageLinks(STARTUP_FOLDER);
    for (DWORD i=0;i<g_cClients;i++)
    {
        g_rgClients[i].user.fStartAtLogon 
            = CManageLinks.LinkExists(g_rgClients[i].machine.ApplicationName);
    }

	return fRv;
}

// RegSetUMDwordValue - helper function to set a DWORD string value creating it if necessary
//
BOOL RegSetUMDwordValue(HKEY hKey, LPCTSTR pszKey, LPCTSTR pszString, DWORD dwNewValue)
{
    HKEY hSubkey;
    int iRv;
    DWORD dwValue = dwNewValue;

    iRv = RegCreateKeyEx(
                  hKey
                , pszKey
                , 0, NULL
                , REG_OPTION_NON_VOLATILE
                , KEY_ALL_ACCESS
                , NULL, &hSubkey, NULL);

	if (iRv == ERROR_SUCCESS)
    {
		RegSetValueEx(
                  hSubkey
                , pszString
                , 0, REG_DWORD
                , (BYTE *)&dwValue
                , sizeof(DWORD));

		RegCloseKey(hSubkey);
    }

    return (iRv == ERROR_SUCCESS)?TRUE:FALSE;
}

void WriteUserRegData(HKEY hKeyCU, BOOL fDoAppletData)
{
    HKEY hkey;
    DWORD dwRv = RegCreateKeyEx(hKeyCU
                            , UM_HKCU_REGISTRY_KEY
                            , 0 , NULL
                            , REG_OPTION_NON_VOLATILE
                            , KEY_ALL_ACCESS, NULL
                            , &hkey, NULL);

    if (dwRv == ERROR_SUCCESS)
    {
        dwRv = RegSetValueEx(
              hkey
            , UMR_VALUE_SHOWWARNING
            , 0, REG_DWORD
            , (BYTE *)&s_fShowWarningAgain
            , sizeof(DWORD));

        if (fDoAppletData)
        {
	        for (DWORD i = 0; i < g_cClients; i++)
	        {
                RegSetUMDwordValue(
                      hkey
                    , g_rgClients[i].machine.ApplicationName
                    , UMR_VALUE_STARTLOCK
                    , g_rgClients[i].user.fStartOnLockDesktop);
	        }
        }

        RegCloseKey(hkey);
    }
}

// --------------------------------------------
static BOOL CopyClientData()
{
	umclient_tsp c;
	DWORD_PTR accessID;
	if (!g_cClients || !g_rgClients)
		return TRUE;
	c = (umclient_tsp)AccessIndependentMemory(
							UMC_CLIENT_FILE, 
							sizeof(umclient_ts)*g_cClients, 
							FILE_MAP_READ|FILE_MAP_WRITE,
							&accessID);
	if (!c)
		return FALSE;
	memcpy(c,g_rgClients,sizeof(umclient_ts)*g_cClients);
	UnAccessIndependentMemory(c, accessID);
	return TRUE;
}

static void CopyHeaderData()
{
	umc_header_tsp pHdr;
	DWORD_PTR accessID;

	pHdr = (umc_header_tsp)AccessIndependentMemory(
								UMC_HEADER_FILE, 
								sizeof(umc_header_ts), 
								FILE_MAP_READ|FILE_MAP_WRITE,
								&accessID);
	if (pHdr)
    {
        pHdr->fShowWarningAgain = s_fShowWarningAgain;
	    UnAccessIndependentMemory(pHdr, accessID);
    }
}

// ----------------------------------
// WriteClientData - save settings to the registry
//
static BOOL WriteClientData(BOOL fRunningSecure)
{
    // It only makes sense to do this if there are any applets being managed
    // (shouldn't get here) and if there is a logged on user (otherwise the
    // settings cannot be changed)

	if (!g_cClients || !g_rgClients || fRunningSecure)
		return TRUE;

	// The SYSTEM instance of utilman needs to be updated in case the user
	// changed any options.  This is so subsequent instances of the UI will
	// get the correct options without having to read the registry.

	CopyHeaderData();
	CopyClientData();

    //
    // Write utilman settings data.  Put "Start when UtilMan starts" in HKLM, 
    // "Start when I lock desktop" in HKCU, and "Start when I log on" into
    // a startup link in the logged on user's shell folder.
    //

    // "Start when UtilMan starts" settings... (only for admins)

	DWORD i;
    if (IsWindowEnabled(GetDlgItem(g_hWndDlg, IDC_START_WITH_UM)))
    {
	    HKEY hHKLM;
        DWORD dwRv = RegCreateKeyEx(HKEY_LOCAL_MACHINE
                                , UM_REGISTRY_KEY
                                , 0 , NULL
                                , REG_OPTION_NON_VOLATILE
                                , KEY_ALL_ACCESS, NULL
                                , &hHKLM, NULL);
        if (dwRv == ERROR_SUCCESS)
        {
	        for (i = 0; i < g_cClients; i++)
	        {
                RegSetUMDwordValue(
                      hHKLM
                    , g_rgClients[i].machine.ApplicationName
                    , UMR_VALUE_STARTUM
                    , g_rgClients[i].user.fStartWithUtilityManager);
	        }
	        RegCloseKey(hHKLM);
        }
    }

    //
    // "Start when I lock my desktop" settings... (any logged on user)
    // and Don't show me the warning anymore setting
    //
    WriteUserRegData(HKEY_CURRENT_USER, IsWindowEnabled(GetDlgItem(g_hWndDlg, IDC_START_ON_LOCK)));

    //
    // manage shell folder link updates (logged on user only)
    //

    if (IsWindowEnabled(GetDlgItem(g_hWndDlg, IDC_START_AT_LOGON)))
    {
        CManageShellLinks CManageLinks(STARTUP_FOLDER);

	    for (i = 0; i < g_cClients; i++)
	    {
            LPTSTR pszAppName = g_rgClients[i].machine.ApplicationName;
            BOOL fLinkExists = CManageLinks.LinkExists(pszAppName);

            // if should start at logon and there isn't a link then create one
            // and if shouldn't start at logon and there is a link then delete it

            if (g_rgClients[i].user.fStartAtLogon && !fLinkExists)
            {
                TCHAR pszAppPath[MAX_PATH];
                LPTSTR pszApp = 0;

                // Following is TRUE *only* if pszAppPath is non-null string value
                if (GetClientApplicationPath(pszAppName , pszAppPath , MAX_PATH))
                {
			        TCHAR pszFullPath[MAX_PATH*2+1]; // path + filename
				    TCHAR pszStartIn[MAX_PATH];
                    int ctch, ctchAppPath = lstrlen(pszAppPath);

				    // if pszAppPath is just base name and extension then prepend system path

				    if (wcscspn(pszAppPath, TEXT("\\")) != (size_t)ctchAppPath
                        || wcscspn(pszAppPath, TEXT(":")) != (size_t)ctchAppPath)
				    {
					    TCHAR szDrive[_MAX_DRIVE], szDir[_MAX_DIR];
					    _wsplitpath(pszAppPath, szDrive, szDir, NULL, NULL);
					    lstrcpy(pszStartIn, szDrive);
					    lstrcat(pszStartIn, szDir);

                        pszApp = pszAppPath;
				    } else
				    {
					    ctch = GetSystemDirectory(pszStartIn, MAX_PATH);

					    lstrcpy(pszFullPath, pszStartIn); // save path to build full path

					    if (ctch + ctchAppPath + 2 > MAX_PATH*2)
					    {
						    DBPRINTF(TEXT("WriteClientData:  Path is too short!\r\n"));
					    } else
					    {
						    if (*(pszFullPath + ctch - 1) != '\\')
							    lstrcat(pszFullPath, TEXT("\\"));

						    lstrcat(pszFullPath, pszAppPath);
                            pszApp = pszFullPath;
					    }
				    }

				    if (pszApp)
				    {
                        // remove ending '\' from StartIn path
                        ctch = lstrlen(pszStartIn) - 1;
				        if (*(pszStartIn + ctch) == '\\')
                            *(pszStartIn + ctch) = 0;

                        CManageLinks.CreateLink(
                                      pszAppName
                                    , pszApp
                                    , pszStartIn
                                    , g_rgClients[i].machine.DisplayName
                                    , TEXT("/UM"));
                    }
                }
            } else if (!g_rgClients[i].user.fStartAtLogon && fLinkExists)
            {
                CManageLinks.RemoveLink(pszAppName);
            }
	    }
    }

	return TRUE;
}
// --------------------------------------------
static BOOL CantStopClient(umclient_tsp client)
{
	switch (client->machine.ApplicationType)
	{
	case APPLICATION_TYPE_APPLICATION:
		break;
	case APPLICATION_TYPE_SERVICE:
		{
			SERVICE_STATUS  ssStatus;
			SC_HANDLE hService;
			SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
			if (!hSCM)
				return TRUE;
			hService = OpenService(hSCM, client->machine.ApplicationName, SERVICE_ALL_ACCESS);
			CloseServiceHandle(hSCM);
			if (!hService)
				return TRUE;
			if (!QueryServiceStatus(hService, &ssStatus) ||
				!(ssStatus.dwControlsAccepted  & SERVICE_ACCEPT_STOP))
			{
				CloseServiceHandle(hService);
				return TRUE;
			}
			CloseServiceHandle(hService);
			break;
		}
	}
	return FALSE;
}//CantStopClient

// We don't want UtilMan to startType to be Automatic
// It should only be made Automatic if it is required, When the user
// selects "Start when NT starts" through the GUI :a-anilk
static BOOL IsStartAuto()
{
#ifdef NEVER    // MICW Don't start service anymore at logon because of TS
    DWORD nClient;
	
	for(nClient = 0; nClient < g_cClients; nClient++)
	{
		if ( g_rgClients[nClient].user.fStartAtLogon == TRUE )
            return TRUE;
    }
#endif
    return FALSE;
}

static int GetClientNameFromAccelerator(WPARAM wVK)
{
	for (int i=0;i<(int)g_cClients;i++)
		if (g_rgClients[i].machine.AcceleratorKey == wVK)
			return i;
	return -1;
}

static BOOL StartClientsOnShow()
{
    BOOL fOK = TRUE;
	for (int i=0;i<(int)g_cClients;i++)
	{
		if ( g_rgClients[i].user.fStartWithUtilityManager
		  && !StartClient(g_hWndDlg, &g_rgClients[i]))
            fOK = FALSE;
	}
    return fOK;
}