windows-server-2003/termsrv/tsuserex/tsusrsht.cpp

//---------------------------------------------------------------------------
// Copyright (c) 1998, Microsoft Corporation
// All Rights Reserved
// Information Contained Herein Is Proprietary and Confidential
//
// Author: alhen
//---------------------------------------------------------------------------

#include "stdafx.h"
#include "resource.h"
#include "tsusrsht.h"
//#include <dsgetdc.h>
#include <icanon.h>
#include <shlwapi.h>

// extern BOOL g_bPagesHaveBeenInvoked;
/*NTSTATUS GetDomainName( PWCHAR ServerNamePtr, // name of server to get domain of
                        LPTSTR DomainNamePtr // alloc and set ptr (free with NetApiBufferFree)
                       );
*/

WNDPROC CTimeOutDlg::m_pfWndproc = 0;

//-------------------------------------------------------------------------------
/*
static TOKTABLE tokday[ 4 ] = {
    { NULL , IDS_D },
    { NULL , IDS_DAY },
    { NULL , IDS_DAYS },
    { NULL , ( DWORD )-1 }
};

static TOKTABLE tokhour[ 6 ] = {
    { NULL , IDS_H     },
    { NULL , IDS_HR    },
    { NULL , IDS_HRS   },
    { NULL , IDS_HOUR  },
    { NULL , IDS_HOURS },
    { NULL , ( DWORD )-1 }
};

static TOKTABLE tokmin[ 5 ] = {
    { NULL , IDS_M       },
    { NULL , IDS_MIN     },
    { NULL , IDS_MINUTE  },
    { NULL , IDS_MINUTES },
    { NULL , ( DWORD )-1 }
};

  */
TCHAR * GetNextToken( TCHAR *pszString , TCHAR *tchToken );

void ErrorMessage1( HWND hParent , DWORD dwStatus );
void ErrorMessage2( HWND hParent , DWORD dwStatus );
void xxErrorMessage( HWND hParent , DWORD dwStatus , UINT );


//-------------------------------------------------------------------------------
// CTUSerDlg::ctor
//-------------------------------------------------------------------------------
CTSUserSheet::CTSUserSheet( )
{
    m_pstrMachinename = NULL;

    m_pstrUsername    = NULL;

    m_cref            = 0;

    m_bIsConfigLoaded = FALSE;

    m_szRemoteServerName[0] = 0;

	m_pUserSid = NULL;

    for( int tt = 0 ; tt < NUM_OF_PAGES ; ++tt )
    {
        m_pDlg[ tt ] = NULL;
    }
}

//-------------------------------------------------------------------------------
// CTUSerDlg::dtor
//-------------------------------------------------------------------------------
CTSUserSheet::~CTSUserSheet()
{
    if( m_pstrMachinename != NULL )
    {
        delete[] m_pstrMachinename;
    }

    if( m_pstrUsername != NULL )
    {
        delete[] m_pstrUsername;
    }

    for( int tt = 0 ; tt < NUM_OF_PAGES ; ++tt )
    {
        if( m_pDlg[ tt ] != NULL )
        {
            delete m_pDlg[ tt ];
        }
    }

	if( m_pUserSid != NULL )
	{
		delete[] m_pUserSid;		
	}

    ODS( TEXT("Main object released!\n") );
}

//ptstrMachineName will be allocated by this routine so it is up 
//to the calling function to delete it. FALSE will be returned
//if the parameter is not allocated
BOOL CTSUserSheet::GetServer(PWSTR *ptstrMachineName)
{
    if (m_pstrMachinename)
    {
        DWORD dwLen = wcslen(m_pstrMachinename);
        *ptstrMachineName = new WCHAR[dwLen + 1];

        if (*ptstrMachineName)
        {
            wcscpy(*ptstrMachineName, m_pstrMachinename);
            return TRUE;
        }
    }

    return FALSE;
}


//-------------------------------------------------------------------------------
// SetServerAndUser
//-------------------------------------------------------------------------------
BOOL CTSUserSheet::SetServerAndUser( LPWSTR pwstrMachineName , LPWSTR pwstrUserName )
{
    if( pwstrMachineName != NULL && pwstrUserName != NULL )
    {
        KdPrint( ("TSUSEREX : SystemName %ws UserName %ws\n",pwstrMachineName,pwstrUserName) );

        DWORD dwLen = wcslen( pwstrMachineName );

        m_pstrMachinename = ( LPTSTR )new TCHAR [ dwLen + 1 ];

        if( m_pstrMachinename != NULL )
        {
            COPYWCHAR2TCHAR( m_pstrMachinename , pwstrMachineName );
        }

        dwLen = wcslen( pwstrUserName );

        m_pstrUsername = ( LPTSTR )new TCHAR[ dwLen + 1 ];

        if( m_pstrUsername != NULL )
        {
            COPYWCHAR2TCHAR( m_pstrUsername , pwstrUserName );
        }

        return TRUE;
    }

    return FALSE;
}

//-------------------------------------------------------------------------------
// AddPagesToPropSheet
//-------------------------------------------------------------------------------
HRESULT CTSUserSheet::AddPagesToPropSheet( LPPROPERTYSHEETCALLBACK pProvider )
{
    PROPSHEETPAGE psp;

    //
    // List of objects goes here
    //

    m_pDlg[0] = new CEnviroDlg( this );

    m_pDlg[1] = new CTimeOutDlg( this );

    m_pDlg[2] = new CShadowDlg( this );

    m_pDlg[3] = new CProfileDlg( this );

    //
    // Let each object initialize there own propsheet
    //

    for( int idx = 0; idx < NUM_OF_PAGES; ++idx )
    {
        if( m_pDlg[ idx ] != NULL )
        {
            if( !m_pDlg[ idx ]->GetPropertySheetPage( psp ) )
            {
                continue;
            }

            if( FAILED( pProvider->AddPage( CreatePropertySheetPage( &psp ) ) ) )
            {
                return E_FAIL;
            }

        }

    }

    return S_OK;
}

//-------------------------------------------------------------------------------
// AddPagesToDSAPropSheet
//-------------------------------------------------------------------------------
HRESULT CTSUserSheet::AddPagesToDSAPropSheet( LPFNADDPROPSHEETPAGE lpfnAddPage , LPARAM lp )
{
	PROPSHEETPAGE psp;

    //
    // List of objects goes here
    //

    m_pDlg[0] = new CEnviroDlg( this );

    m_pDlg[1] = new CTimeOutDlg( this );

    m_pDlg[2] = new CShadowDlg( this );

    m_pDlg[3] = new CProfileDlg( this );

    //
    // Let each object initialize there own propsheet
    //

    for( int idx = 0; idx < NUM_OF_PAGES; ++idx )
    {
        if( m_pDlg[ idx ] != NULL )
        {
            if( !m_pDlg[ idx ]->GetPropertySheetPage( psp ) )
            {
                continue;
            }

            lpfnAddPage( CreatePropertySheetPage( &psp ) , lp );
        }

    }

    return S_OK;
}

//-------------------------------------------------------------------------------
// SetUserConfig
//-------------------------------------------------------------------------------
BOOL CTSUserSheet::SetUserConfig( USERCONFIG& uc , PDWORD pdwStatus )
{
    ASSERT_( pdwStatus != NULL );

    if( IsBadReadPtr( &uc , sizeof( USERCONFIG ) ) )
    {
        return FALSE;
    }

    //
    //
    // mov         esi,dword ptr [uc]
    // mov         edi,dword ptr [this]
    // add         edi,1Ch
    // mov         ecx,27Ah
    // rep movs    dword ptr es:[edi],dword ptr [esi]
    //
    // is the codegen for struct = struct
    //
    m_userconfig = uc;

#if BETA_3

    TCHAR tchServerName[ MAX_PATH ];

    if( m_bDC )
    {
        ODS( L"TSUSEREX - Saving settings on remote or local-dc system\n" );

        lstrcpy( tchServerName , m_szRemoteServerName );
    }
    else
    {
        lstrcpy( tchServerName , m_pstrMachinename );
    }

#endif // BETA_3

    if( ( *pdwStatus = RegUserConfigSet( m_pstrMachinename , m_pstrUsername ,  &m_userconfig , sizeof( USERCONFIG ) ) ) == ERROR_SUCCESS )
    {
        return TRUE;
    }

    return FALSE;

}

//-------------------------------------------------------------------------------
// GetCurrentUserConfig
//-------------------------------------------------------------------------------
USERCONFIG& CTSUserSheet::GetCurrentUserConfig( PDWORD pdwStatus )
{
    *pdwStatus = ERROR_SUCCESS;

    if( !m_bIsConfigLoaded )
    {
        m_bIsConfigLoaded = GetUserConfig( pdwStatus );
    }

    // ASSERT_( m_bIsConfigLoaded );

    return m_userconfig;
}

//-------------------------------------------------------------------------------
// GetUserConfig
//-------------------------------------------------------------------------------
BOOL CTSUserSheet::GetUserConfig( PDWORD pdwStatus )
{
    ASSERT_( pdwStatus != NULL );
    //
    // This should only be called once
    //

    DWORD cbWritten = 0;

#if BETA_3

    PSERVER_INFO_101 psinfo;

    // check to see if we're trying to administer a local system that happens to be a dc

    *pdwStatus = NetServerGetInfo( NULL , 101 , ( LPBYTE * )&psinfo );

    KdPrint( ("TSUSEREX : NetServerGetInfo returned 0x%x\n",*pdwStatus ) );

    KdPrint( ("TSUSEREX : LastError was 0x%x\n",GetLastError( ) ) );

    if( *pdwStatus == NERR_Success )
    {
        // used to avoid access violation

        if( psinfo != NULL )
        {
            KdPrint( ("TSUSEREX : PSERVER_INFO_101 returned 0x%x\n",psinfo->sv101_type ) );

            m_bDC = ( BOOL )( psinfo->sv101_type & ( SV_TYPE_DOMAIN_CTRL | SV_TYPE_DOMAIN_BAKCTRL ) );

            if( m_bDC )
            {
                // get the domaincontroller name of the remote machine

                DOMAIN_CONTROLLER_INFO *pdinfo;

                // m_pstrMachinename is really the domain name.  This was obtain
                // from LookUpAccountSid in interfaces.cpp

                *pdwStatus = DsGetDcName( NULL , m_pstrMachinename , NULL , NULL , DS_PDC_REQUIRED , &pdinfo );

                KdPrint( ( "TSUSEREX : DsGetDcName: %ws returned 0x%x\n", pdinfo->DomainControllerName , *pdwStatus ) );

                if( *pdwStatus == NO_ERROR )
                {
                    lstrcpy( m_szRemoteServerName , pdinfo->DomainControllerName );

                    NetApiBufferFree( pdinfo );
                }
                else
                {
                    m_szRemoteServerName[0] = 0;
                }

            }

            // not documented in the docs but NetServerGetInfo leaves it up to the caller to free up this blob

            NetApiBufferFree( psinfo );

        }

        TCHAR tchServerName[ MAX_PATH ];

        if( m_bDC )
        {
            lstrcpy( tchServerName , m_szRemoteServerName );
        }
        else
        {
            lstrcpy( tchServerName , m_pstrMachinename );
        }



        if( ( *pdwStatus = ( DWORD )RegUserConfigQuery( tchServerName , m_pstrUsername , &m_userconfig , sizeof( USERCONFIG ) , &cbWritten ) ) == ERROR_SUCCESS )
        {
            return TRUE;
        }

    }

#endif // BETA_3

    if( ( *pdwStatus = ( DWORD )RegUserConfigQuery( m_pstrMachinename , m_pstrUsername , &m_userconfig , sizeof( USERCONFIG ) , &cbWritten ) ) == ERROR_SUCCESS )
    {
        return TRUE;
    }


    ODS( L"TSUSEREX: We're getting default properties\n" );

    RegDefaultUserConfigQuery( m_pstrMachinename , &m_userconfig , sizeof( USERCONFIG ) , &cbWritten );

    return FALSE;
}

void CTSUserSheet::CopyUserSid( PSID psid )
{
	if( !IsValidSid( psid ) )
	{
		ODS( L"TSUSEREX : CTSUserSheet::CopyUserSid invalid arg\n" ) ;

		return;
	}

	m_pUserSid = psid;

}


//----------------------------------------------------------
// This provides reference counting for the dialog boxes
// and destroys the sheet (thus destroying the dialog boxes)
// when the ref count reaches 0
//----------------------------------------------------------
UINT CALLBACK CDialogBase::PageCallback(HWND hDlg, UINT uMsg, LPPROPSHEETPAGE ppsp)
{
    if (!ppsp)
        return FALSE;

    // We need to recover a pointer to the current instance.  We can't just use
    // "this" because we are in a static function
    CDialogBase* pMe = reinterpret_cast<CDialogBase*>(ppsp->lParam);
    if (!pMe)
        return FALSE;

    if (uMsg == 0)
        ++(pMe->m_pUSht->m_cref);

    if (uMsg == PSPCB_RELEASE)
    {
        if( --(pMe->m_pUSht->m_cref) == 0 )
            delete (pMe->m_pUSht);
    }

    return TRUE;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

//-------------------------------------------------------------------------------
// Base class initi
//-------------------------------------------------------------------------------
CDialogBase::CDialogBase( )
{
     m_hWnd = NULL;
}

//-------------------------------------------------------------------------------
// Base initialization
//-------------------------------------------------------------------------------
BOOL CDialogBase::OnInitDialog( HWND hwnd , WPARAM , LPARAM )
{
    m_hWnd = hwnd;

    return FALSE;
}

//-------------------------------------------------------------------------------
// OnNotify - base class method
//-------------------------------------------------------------------------------
BOOL CDialogBase::OnNotify( int , LPNMHDR pnmh , HWND hDlg )
{
    if( pnmh->code == PSN_APPLY )
    {
        if( !m_bPersisted )
        {
            m_bPersisted = PersistSettings( hDlg );
        }
    }

    else if( pnmh->code == PSN_KILLACTIVE )
    {
        if( !m_bPersisted )
        {
            if( !IsValidSettings( hDlg ) )
            {
                SetWindowLongPtr( hDlg , DWLP_MSGRESULT , PSNRET_INVALID_NOCHANGEPAGE );

                return TRUE;
            }

        }
    }

    return FALSE;
}

//-------------------------------------------------------------------------------
// OnCOntextMenu -- base class operation
//-------------------------------------------------------------------------------
BOOL CDialogBase::OnContextMenu( HWND hwnd , POINT& )
{
    TCHAR tchHelpFile[ MAX_PATH ];

    if( m_hWnd == GetParent( hwnd ) )
    {
        //
        // Make sure its not a dummy window
        //

        if( GetDlgCtrlID( hwnd ) <= ( int )-1 )
        {
            return FALSE;
        }

        DWORD rgdw[ 2 ];

        rgdw[ 0 ] = GetDlgCtrlID( hwnd );

        rgdw[ 1 ] = GetWindowContextHelpId( hwnd );

        LoadString( _Module.GetModuleInstance( ) , IDS_HELPFILE , tchHelpFile , sizeof( tchHelpFile ) / sizeof( TCHAR ) );

        WinHelp( hwnd , tchHelpFile , HELP_CONTEXTMENU , (ULONG_PTR)&rgdw );

    }

    return TRUE;
}

//-------------------------------------------------------------------------------
// Each control has a helpid assign to them.  Some controls share the same topic
// check for these.
//-------------------------------------------------------------------------------
BOOL CDialogBase::OnHelp( HWND hwnd , LPHELPINFO lphi )
{
    TCHAR tchHelpFile[ MAX_PATH ];

    //
    // For the information to winhelp api
    //

    if( IsBadReadPtr( lphi , sizeof( HELPINFO ) ) )
    {
        return FALSE;
    }

    if( (short)lphi->iCtrlId <= -1 )
    {
        return FALSE;
    }

    LoadString( _Module.GetModuleInstance( ) , IDS_HELPFILE , tchHelpFile , sizeof( tchHelpFile ) / sizeof( TCHAR ) );

    WinHelp( hwnd , tchHelpFile , HELP_CONTEXTPOPUP , lphi->dwContextId );

    return TRUE;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

//-------------------------------------------------------------------------------
// CEnviroDlg::ctor
//-------------------------------------------------------------------------------
CEnviroDlg::CEnviroDlg( CTSUserSheet *pUSht )
{
    m_pUSht = pUSht;
}

//-------------------------------------------------------------------------------
// InitDialog for ProfileDlg
//-------------------------------------------------------------------------------
BOOL CEnviroDlg::OnInitDialog( HWND hwnd , WPARAM wp , LPARAM lp )
{
    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht ,sizeof(  CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    // This means any true problems from obtaining user info from the sam
    // will disable this dialog

    if( dwStatus != ERROR_FILE_NOT_FOUND && dwStatus != ERROR_SUCCESS )
    {
        INT nId[ ] = {
                        IDC_CHECK_USEDEFAULT,
                        IDC_EDIT_CMDLINE,
                        IDC_EDIT_WDIR,
                        IDC_CHECK_CCDL,
                        IDC_CHECK_CCPL,
                        IDC_CHECK_DMCP,
                        -1
        };

        for( int idx = 0; nId[ idx ] != -1 ; ++idx )
        {
            EnableWindow( GetDlgItem( hwnd , nId[ idx ] ) , FALSE );
        }

        ErrorMessage1( hwnd , dwStatus );

        return FALSE;
    }

    SendMessage( GetDlgItem( hwnd , IDC_EDIT_CMDLINE  ) , EM_SETLIMITTEXT , ( WPARAM )DIRECTORY_LENGTH , 0 );

    SendMessage( GetDlgItem( hwnd , IDC_EDIT_WDIR  ) , EM_SETLIMITTEXT , ( WPARAM )DIRECTORY_LENGTH , 0 );

    //
    // Set controls to default status
    //

    SendMessage( GetDlgItem( hwnd , IDC_CHECK_USEDEFAULT ) , BM_SETCHECK , !( WPARAM )uc.fInheritInitialProgram , 0 );

    SetWindowText( GetDlgItem( hwnd , IDC_EDIT_WDIR ) , uc.WorkDirectory );

    SetWindowText( GetDlgItem( hwnd , IDC_EDIT_CMDLINE ) , uc.InitialProgram ) ;

    EnableWindow( GetDlgItem( hwnd , IDC_EDIT_WDIR ) , !uc.fInheritInitialProgram );

    EnableWindow( GetDlgItem( hwnd , IDC_EDIT_CMDLINE ) , !uc.fInheritInitialProgram );

    EnableWindow( GetDlgItem( hwnd , IDC_STATIC_WD ) , !uc.fInheritInitialProgram );

    EnableWindow( GetDlgItem( hwnd , IDC_STATIC_CMD ) , !uc.fInheritInitialProgram );

    //
    // The controls are initially enabled - - resetting them is done
    // via WM_COMMAND
    //

    SendMessage( GetDlgItem( hwnd , IDC_CHECK_CCDL ) , BM_SETCHECK , ( WPARAM )uc.fAutoClientDrives , 0 );

    SendMessage( GetDlgItem( hwnd , IDC_CHECK_CCPL ) , BM_SETCHECK , ( WPARAM )uc.fAutoClientLpts , 0 );

    SendMessage( GetDlgItem( hwnd , IDC_CHECK_DMCP ) , BM_SETCHECK , ( WPARAM )uc.fForceClientLptDef , 0 );

    m_bPersisted = TRUE;

    return CDialogBase::OnInitDialog( hwnd , wp , lp );
}

//-------------------------------------------------------------------------------
// Environment Dialog Page
// -- static methods lacks this ptr
//-------------------------------------------------------------------------------
INT_PTR CALLBACK CEnviroDlg::DlgProc( HWND hwnd , UINT msg , WPARAM wp , LPARAM lp )
{
    CEnviroDlg *pDlg;

    if( msg == WM_INITDIALOG )
    {
        CEnviroDlg *pDlg = ( CEnviroDlg * )( ( PROPSHEETPAGE *)lp )->lParam ;

        //
        // Don't use a static pointer here
        // There will be concurrency issues
        //

        SetWindowLongPtr( hwnd , DWLP_USER , ( LONG_PTR )pDlg );

        if( !IsBadReadPtr( pDlg , sizeof( CEnviroDlg ) ) )
        {
            pDlg->OnInitDialog( hwnd , wp , lp );
        }

        return 0;
    }

    else
    {
        pDlg = ( CEnviroDlg * )GetWindowLongPtr( hwnd , DWLP_USER );

        if( IsBadReadPtr( pDlg , sizeof( CEnviroDlg ) ) )
        {
            return FALSE;
        }
    }

    switch( msg )
    {

    case WM_NCDESTROY:

        pDlg->OnDestroy( );

        break;

    case WM_COMMAND:

        pDlg->OnCommand( HIWORD( wp ) , LOWORD( wp ) , ( HWND )lp );

        break;

    case WM_NOTIFY:

        pDlg->OnNotify( ( int )wp , ( LPNMHDR )lp , hwnd );

        break;

    case WM_HELP:

        pDlg->OnHelp( hwnd , ( LPHELPINFO )lp );

        break;

    case WM_RBUTTONUP:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            HWND hChild = ChildWindowFromPoint( hwnd , pt );

            ClientToScreen( hwnd , &pt );

            pDlg->OnContextMenu( hChild , pt );
        }

        break;

     case WM_CONTEXTMENU:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            pDlg->OnContextMenu( ( HWND )wp , pt );
        }

    }

    return 0;
}

//-------------------------------------------------------------------------------
// Basic control notification handler
//-------------------------------------------------------------------------------
void CEnviroDlg::OnCommand( WORD wNotifyCode , WORD wID , HWND hwndCtl )
{
    switch( wNotifyCode )
    {

    case BN_CLICKED:

        if( wID == IDC_CHECK_USEDEFAULT )
        {
            //
            // Remember if its checked we want to disable the options
            //
            HWND hwnd = GetParent( hwndCtl );

            BOOL bChecked = SendMessage( hwndCtl , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

            EnableWindow( GetDlgItem( hwnd , IDC_EDIT_WDIR ) , bChecked );

            EnableWindow( GetDlgItem( hwnd , IDC_EDIT_CMDLINE ) , bChecked );

            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_WD ) , bChecked );

            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_CMD ) , bChecked );

        }   // FALL THROUGH !!!!

    case EN_CHANGE:

        m_bPersisted = FALSE;

        break;

    case ALN_APPLY:

        //This is being removed for consinstency with the rest of MMC dialogs, even though it would
        //make more sense to the user for Cancel to be disabled after applying the changes, since
        //cancellation is not a real option at that point.
        //SendMessage( GetParent( hwndCtl ) , PSM_CANCELTOCLOSE , 0 , 0 );

        break;
    }

    if( !m_bPersisted )
    {
        SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
    }

}

//-------------------------------------------------------------------------------
// OnDestroy
//-------------------------------------------------------------------------------
BOOL CEnviroDlg::OnDestroy( )
{
    return CDialogBase::OnDestroy( );
}

//-------------------------------------------------------------------------------
// GetPropertySheetPage - each dialog object should be responsible for its own data
//-------------------------------------------------------------------------------
BOOL CEnviroDlg::GetPropertySheetPage( PROPSHEETPAGE &psp)
{
    ZeroMemory( &psp , sizeof( PROPSHEETPAGE ) );

    psp.dwSize      = sizeof( PROPSHEETPAGE );

    psp.dwFlags     = PSP_DEFAULT | PSP_USECALLBACK;

    psp.hInstance   = _Module.GetModuleInstance( );

    psp.pszTemplate = MAKEINTRESOURCE( IDD_PAGE_ENVIRO );

    psp.lParam      = (LPARAM)this;

    psp.pfnCallback = CDialogBase::PageCallback;

    psp.pfnDlgProc  = CEnviroDlg::DlgProc;

    return TRUE;
}


//-------------------------------------------------------------------------------
// PersistSettings
//-------------------------------------------------------------------------------
BOOL CEnviroDlg::PersistSettings( HWND hDlg )
{
    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht , sizeof( CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    TCHAR tchBuffer[ DIRECTORY_LENGTH + 1 ];

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    //
    // if use default is checked -- lets flag it and move on to client devices
    //

    //
    // if the chkbx is unchecked we inherit from client side settings
    //

    uc.fInheritInitialProgram = SendMessage( GetDlgItem( hDlg , IDC_CHECK_USEDEFAULT ) , BM_GETCHECK ,
        0 , 0 ) == BST_CHECKED ? FALSE : TRUE;

    if( !uc.fInheritInitialProgram )
    {
        //
        // Read buffer and commit to USERCONFIG buffer
        //

        GetWindowText( GetDlgItem( hDlg , IDC_EDIT_WDIR ) , &tchBuffer[ 0 ] , sizeof( tchBuffer ) / sizeof( TCHAR ) );

        lstrcpy( uc.WorkDirectory , tchBuffer );

        GetWindowText( GetDlgItem( hDlg , IDC_EDIT_CMDLINE ) , &tchBuffer[ 0 ] , sizeof( tchBuffer ) / sizeof( TCHAR ) );

        lstrcpy( uc.InitialProgram , tchBuffer );
    }
    else
    {
        lstrcpy(uc.WorkDirectory, L"");
        lstrcpy(uc.InitialProgram, L"");
    }

    uc.fAutoClientDrives  = SendMessage( GetDlgItem( hDlg , IDC_CHECK_CCDL ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

    uc.fAutoClientLpts    = SendMessage( GetDlgItem( hDlg , IDC_CHECK_CCPL ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

    uc.fForceClientLptDef = SendMessage( GetDlgItem( hDlg , IDC_CHECK_DMCP ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

    if( !m_pUSht->SetUserConfig( uc , &dwStatus ) )
    {
        ErrorMessage2( hDlg , dwStatus );

        return TRUE;
    }


    PostMessage( hDlg , WM_COMMAND , MAKELPARAM( 0 , ALN_APPLY ) , ( LPARAM )hDlg );

    SendMessage( GetParent( hDlg ) , PSM_UNCHANGED , ( WPARAM )hDlg , 0 );

    return TRUE;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

DWORD rgdwTime[] = { 0 , 1 , 5 , 10 , 15 , 30 , 60 , 120 , 180 , 1440 , 2880 , ( DWORD )-1 };

//-------------------------------------------------------------------------------
// CTimeOutDlg::ctor
//-------------------------------------------------------------------------------
CTimeOutDlg::CTimeOutDlg( CTSUserSheet *pUSht )
{
    m_pUSht = pUSht;

    ZeroMemory( &m_cbxst , sizeof( CBXSTATE ) * 3 );

    m_wAction = ( WORD)-1;

    m_wCon = ( WORD )-1;

    ZeroMemory( &m_tokday , sizeof( TOKTABLE ) * 4  );

    ZeroMemory( &m_tokhour , sizeof( TOKTABLE ) * 6 );

    ZeroMemory( &m_tokmin , sizeof( TOKTABLE ) * 5 );
}

//-------------------------------------------------------------------------------
void CTimeOutDlg::InitTokTables( )
{
    TOKTABLE tday[4] = { { NULL , IDS_D },
                         { NULL , IDS_DAY },
                         { NULL , IDS_DAYS },
                         { NULL , ( DWORD )-1 }
                       };

    TOKTABLE thour[ 6 ] = {
                            { NULL , IDS_H     },
                            { NULL , IDS_HR    },
                            { NULL , IDS_HRS   },
                            { NULL , IDS_HOUR  },
                            { NULL , IDS_HOURS },
                            { NULL , ( DWORD )-1 }
                          };

    TOKTABLE tmin[ 5 ] = {
                            { NULL , IDS_M       },
                            { NULL , IDS_MIN     },
                            { NULL , IDS_MINUTE  },
                            { NULL , IDS_MINUTES },
                            { NULL , ( DWORD )-1 }
                         };

    CopyMemory( &m_tokday[0] , &tday[0] , sizeof( TOKTABLE )  * 4 );
    CopyMemory( &m_tokhour[0] , &thour[0] , sizeof( TOKTABLE )  * 6 );
    CopyMemory( &m_tokmin[0] , &tmin[0] , sizeof( TOKTABLE )  * 5 );


}
//-------------------------------------------------------------------------------
// InitDialog for TimeOutDlg
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::OnInitDialog( HWND hwnd , WPARAM wp , LPARAM lp )
{
    TCHAR tchBuffer[ 80 ];

    DWORD dwStatus;

    USERCONFIG uc;

    if( IsBadReadPtr( m_pUSht , sizeof( CTSUserSheet ) ) )
    {
        return FALSE;
    }

    InitTokTables( );

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    if( dwStatus != ERROR_FILE_NOT_FOUND && dwStatus != ERROR_SUCCESS )
    {
        INT nId[ ] = {
                        IDC_COMBO_CONNECT,
                        IDC_COMBO_DISCON,
                        IDC_COMBO_IDLE,
                        IDC_RADIO_RESET,
                        IDC_RADIO_DISCON,
                        IDC_RADIO_PREVCLIENT,
                        IDC_RADIO_ANYCLIENT,
                        -1
        };

        for( int idx = 0; nId[ idx ] != -1 ; ++idx )
        {
            EnableWindow( GetDlgItem( hwnd , nId[ idx ] ) , FALSE );
        }

        ErrorMessage1( hwnd , dwStatus );

        return FALSE;
    }
    //
    // First thing is to set the default values for all the controls
    //

    HWND hCombo[ 3 ] =
    {

        GetDlgItem( hwnd , IDC_COMBO_CONNECT ),

        GetDlgItem( hwnd , IDC_COMBO_DISCON ),

        GetDlgItem( hwnd , IDC_COMBO_IDLE )
    };


    for( int idx = 0; rgdwTime[ idx ] != ( DWORD)-1; ++idx )
    {
        if( rgdwTime[ idx ] == 0 )
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_NOTIMEOUT , tchBuffer , sizeof( tchBuffer ) / sizeof( TCHAR ) );
        }
        else
        {
            ConvertToDuration( rgdwTime[ idx ] , tchBuffer );
        }

        for( int inner = 0 ; inner < 3 ; ++inner )
        {
            SendMessage( hCombo[ inner ] , CB_ADDSTRING , 0 , ( LPARAM )&tchBuffer[0] );

            SendMessage( hCombo[ inner ] , CB_SETITEMDATA , idx , rgdwTime[ idx ] );
        }
    }

    ULONG ulTime;

    if( uc.MaxConnectionTime > 0 )
    {
        ulTime = uc.MaxConnectionTime / kMilliMinute;

        // hCombo[ 0 ] == IDC_COMBO_CONNECT

        InsertSortedAndSetCurSel( hCombo[ 0 ] , ulTime );

    }
    else
    {
        SendMessage( hCombo[ 0 ] , CB_SETCURSEL , 0 , 0 );
    }

    //
    // Set the current or default disconnection timeout
    //

    if( uc.MaxDisconnectionTime > 0 )
    {
        ulTime = uc.MaxDisconnectionTime / kMilliMinute;

        // hCombo[ 1 ] == IDC_COMBO_DISCON

        InsertSortedAndSetCurSel( hCombo[ 1 ] , ulTime );

    }
    else
    {
        SendMessage( hCombo[ 1] , CB_SETCURSEL , 0 , 0 );
    }

    //
    // Set the current or default idle timeout
    //

    if( uc.MaxIdleTime > 0 )
    {
        ulTime = uc.MaxIdleTime / kMilliMinute;

        // hCombo[ 2 ] == IDC_COMBO_IDLE

        InsertSortedAndSetCurSel( hCombo[ 2 ] , ulTime );

    }
    else
    {
        SendMessage( hCombo[ 2 ] , CB_SETCURSEL , 0 , 0 );
    }

    //
    // Set remaining controls to current settings
    //

    if( uc.fResetBroken )
    {
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_RESET ) , BM_CLICK , 0 , 0 );

        m_wAction = IDC_RADIO_RESET;
    }
    else
    {
       SendMessage( GetDlgItem( hwnd , IDC_RADIO_DISCON ) , BM_CLICK , 0 , 0 );

       m_wAction = IDC_RADIO_DISCON;
    }

    if( uc.fReconnectSame )
    {
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_PREVCLIENT ) , BM_CLICK , 0 ,0 );

        m_wCon = IDC_RADIO_PREVCLIENT;
    }
    else
    {
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_ANYCLIENT ) , BM_CLICK , 0 , 0 );

        m_wCon = IDC_RADIO_ANYCLIENT;

    }

    LoadAbbreviates( );

    m_bPersisted = TRUE;

    return CDialogBase::OnInitDialog( hwnd , wp , lp );

}

//-------------------------------------------------------------------------------
// TimeOutDlg Dialog Page
// -- static methods lacks this ptr
//-------------------------------------------------------------------------------
INT_PTR CALLBACK CTimeOutDlg::DlgProc( HWND hwnd , UINT msg , WPARAM wp , LPARAM lp )
{
    CTimeOutDlg *pDlg;

    if( msg == WM_INITDIALOG )
    {
        CTimeOutDlg *pDlg = ( CTimeOutDlg * )( ( PROPSHEETPAGE *)lp )->lParam ;

        SetWindowLongPtr( hwnd , DWLP_USER , ( LONG_PTR )pDlg );

        if( !IsBadReadPtr( pDlg , sizeof( CTimeOutDlg ) ) )
        {
            pDlg->OnInitDialog( hwnd , wp , lp );
        }

        return 0;
    }

    else
    {
        pDlg = ( CTimeOutDlg * )GetWindowLongPtr( hwnd , DWLP_USER );

        if( IsBadReadPtr( pDlg , sizeof( CTimeOutDlg ) ) )
        {
            return FALSE;
        }
    }


    switch( msg )
    {

    case WM_NCDESTROY:

        pDlg->OnDestroy( );

        break;

    case WM_COMMAND:

        pDlg->OnCommand( HIWORD( wp ) , LOWORD( wp ) , ( HWND )lp );

        break;

    case WM_NOTIFY:

        return pDlg->OnNotify( ( int )wp , ( LPNMHDR )lp , hwnd );

    case WM_HELP:

        pDlg->OnHelp( hwnd , ( LPHELPINFO )lp );

        break;

    case WM_RBUTTONUP:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            HWND hChild = ChildWindowFromPoint( hwnd , pt );

            ClientToScreen( hwnd , &pt );

            pDlg->OnContextMenu( hChild , pt );
        }

        break;

    case WM_CONTEXTMENU:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            pDlg->OnContextMenu( ( HWND )wp , pt );
        }
    }

    return 0;
}

BOOL CTimeOutDlg::OnDestroy( )
{
    xxxUnLoadAbbreviate( &m_tokday[0] );

    xxxUnLoadAbbreviate( &m_tokhour[0] );

    xxxUnLoadAbbreviate( &m_tokmin[0] );

    return CDialogBase::OnDestroy( );
}

//-------------------------------------------------------------------------------
// GetPropertySheetPage - each dialog object should be responsible for its own data
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::GetPropertySheetPage( PROPSHEETPAGE &psp)
{
    ZeroMemory( &psp , sizeof( PROPSHEETPAGE ) );

    psp.dwSize      = sizeof( PROPSHEETPAGE );

    psp.dwFlags     = PSP_DEFAULT | PSP_USECALLBACK;

    psp.hInstance   = _Module.GetModuleInstance( );

    psp.pszTemplate = MAKEINTRESOURCE( IDD_PAGE_TIMEOUTS );

    psp.lParam      = (LPARAM)this;

    psp.pfnCallback = CDialogBase::PageCallback;

    psp.pfnDlgProc  = CTimeOutDlg::DlgProc;

    return TRUE;
}

//-------------------------------------------------------------------------------
// OnCommand
//-------------------------------------------------------------------------------
void CTimeOutDlg::OnCommand( WORD wNotifyCode , WORD wID , HWND hwndCtl )
{
    switch( wNotifyCode )
    {

    case CBN_EDITCHANGE:

        OnCBEditChange( hwndCtl );

        m_bPersisted = FALSE;

        break;

    case CBN_SELCHANGE:

        if( SendMessage( hwndCtl , CB_GETDROPPEDSTATE , 0 ,0  ) == TRUE )
        {
            return;
        }

        OnCBNSELCHANGE( hwndCtl );    // FALLTHROUGH

//        m_bPersisted = FALSE;

        break;

    case BN_CLICKED:

        if( wID == IDC_RADIO_DISCON || wID == IDC_RADIO_RESET )
        {
            if( m_wAction != wID )
            {
                m_wAction = wID;

                m_bPersisted = FALSE;
            }
        }
        else if( wID == IDC_RADIO_PREVCLIENT || wID == IDC_RADIO_ANYCLIENT )
        {
            if( m_wCon != wID )
            {
                m_wCon = wID;

                m_bPersisted = FALSE;
            }
        }



        break;

    //case CBN_DROPDOWN:               // FALLTHROUGH

    case CBN_KILLFOCUS:

        ODS( L"CBN_KILLFOCUS\n");

        if( !OnCBDropDown( hwndCtl ) )
        {
            return;
        }

        m_bPersisted = FALSE;

        break;

    case ALN_APPLY:

        //This is being removed for consinstency with the rest of MMC dialogs, even though it would
        //make more sense to the user for Cancel to be disabled after applying the changes, since
        //cancellation is not a real option at that point.
        //SendMessage( GetParent( hwndCtl ) , PSM_CANCELTOCLOSE , 0 , 0 );

        return;

    }

    if( !m_bPersisted )
    {
        SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
    }

}

//-------------------------------------------------------------------------------
// Update the entry if it has been modified by user
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::OnCBDropDown( HWND hCombo )
{
    TCHAR tchBuffer[ 80 ];

    ULONG ulTime = 0;

    int i = GetCBXSTATEindex( hCombo );

    if( i < 0 )
    {
        return FALSE;
    }

    if( m_cbxst[ i ].bEdit )
    {
        GetWindowText( hCombo , tchBuffer , sizeof( tchBuffer ) / sizeof( TCHAR ) );

        if( ParseDurationEntry( tchBuffer , &ulTime ) == E_SUCCESS )
        {
            InsertSortedAndSetCurSel( hCombo , ulTime );
        }
    }

    return m_cbxst[ i ].bEdit;

}
//-------------------------------------------------------------------------------
// Use this flag to distinguish between hand entry or listbox selection
// setting it to true implies that the use has edit the cbx via typing
//-------------------------------------------------------------------------------
void CTimeOutDlg::OnCBEditChange( HWND hCombo )
{
    int i = GetCBXSTATEindex( hCombo );

    if( i > -1 )
    {
        m_cbxst[ i ].bEdit = TRUE;
    }
}

//-------------------------------------------------------------------------------
// Determine if user wants to enter a custom time
//-------------------------------------------------------------------------------
void CTimeOutDlg::OnCBNSELCHANGE( HWND hwnd )
{
    if( SaveChangedSelection( hwnd ) )
    {
        m_bPersisted = FALSE;
    }
}

//-------------------------------------------------------------------------------
// Saves selected item.
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::SaveChangedSelection( HWND hCombo )
{
    LRESULT idx = SendMessage( hCombo , CB_GETCURSEL , 0 , 0 );

    int i = GetCBXSTATEindex( hCombo );

    if( i > -1 )
    {
        if( idx != ( LRESULT )m_cbxst[ i ].icbxSel )
        {
            m_cbxst[ i ].icbxSel = (int)idx;

            m_cbxst[ i ].bEdit = FALSE;

            return TRUE;
        }
    }

    return FALSE;
}

//-------------------------------------------------------------------------------
// Restore previous setting
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::RestorePreviousValue( HWND hwnd )
{
    int iSel;

    if( ( iSel = GetCBXSTATEindex( hwnd ) ) > -1 )
    {
        SendMessage( hwnd , CB_SETCURSEL , m_cbxst[ iSel ].icbxSel , 0 );

        return TRUE;
    }

    return FALSE;
}
//-------------------------------------------------------------------------------
// returns the indx in m_cbxst of which hcombo is assoc. with
//-------------------------------------------------------------------------------
int CTimeOutDlg::GetCBXSTATEindex( HWND hCombo )
{
    int idx = -1;

    switch( GetDlgCtrlID( hCombo ) )
    {
    case IDC_COMBO_CONNECT:

        idx = 0;

        break;

    case IDC_COMBO_DISCON:

        idx = 1;

        break;

    case IDC_COMBO_IDLE:

        idx = 2;

        break;
    }

    return idx;
}

//-------------------------------------------------------------------------------
// ConvertToMinutes -- helper for CTimeOutDlg::OnNotify
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::ConvertToMinutes( HWND hwndCtl , PULONG pulMinutes )
{
    TCHAR tchBuffer[ 80 ];

    TCHAR tchErrTitle[ 80 ];

    TCHAR tchErrMsg[ 256 ];

    TCHAR tchErrItem[ 80 ];

    TCHAR tchErrTot[ 336 ];

    int nComboResID[] = { IDS_COMBO_CONNECTION , IDS_COMBO_DISCONNECTION , IDS_COMBO_IDLECONNECTION };

    int idx = GetCBXSTATEindex( hwndCtl );

    if( idx < 0 )
    {
        return FALSE;
    }

    LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_TITLE , tchErrTitle , sizeof( tchErrTitle ) / sizeof( TCHAR ) );

    if( m_cbxst[ idx ].bEdit )
    {
        ODS( TEXT( "Manual Entry parsing\n") );

        if( GetWindowText( hwndCtl , tchBuffer , sizeof( tchBuffer ) / sizeof( TCHAR ) ) < 1 )
        {
            *pulMinutes = 0;

            return TRUE;
        }

        LRESULT lr = ParseDurationEntry( tchBuffer , pulMinutes );

        if( lr != E_SUCCESS )
        {
            LoadString( _Module.GetResourceInstance( ) , nComboResID[ idx ] , tchErrItem , sizeof( tchErrItem ) / sizeof( TCHAR ) );

            if( lr == E_PARSE_VALUEOVERFLOW )
            {
                LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_TOOMANYDIGITS , tchErrMsg , sizeof( tchErrMsg ) / sizeof( TCHAR ) );

                wsprintf( tchErrTot , tchErrMsg , tchErrItem );

                MessageBox( hwndCtl , tchErrTot , tchErrTitle , MB_OK | MB_ICONERROR );

                SetFocus( hwndCtl );
            }
            else if( lr == E_PARSE_MISSING_DIGITS || lr == E_PARSE_INVALID )
            {
                LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_PARSEINVALID , tchErrMsg , sizeof( tchErrMsg ) / sizeof( TCHAR ) );

                wsprintf( tchErrTot , tchErrMsg , tchErrItem );

                MessageBox( hwndCtl , tchErrTot , tchErrTitle , MB_OK | MB_ICONERROR );

                SetFocus( hwndCtl );
            }
            return FALSE;
        }
    }
    else
    {
        ODS( L"Getting current selection\n" );

        LONG_PTR iCurSel = SendMessage( hwndCtl , CB_GETCURSEL , 0 , 0 );
        LONG_PTR lData;

        // See if user wants "No Timeout"

        if( iCurSel == 0 )
        {
            *pulMinutes = 0;

           return TRUE;
        }

        if( ( lData = SendMessage( hwndCtl , CB_GETITEMDATA , iCurSel , 0 ) ) == CB_ERR  )
        {
            *pulMinutes = 0;
        } else {

            *pulMinutes = (ULONG)lData;
        }
    }

    if( *pulMinutes > kMaxTimeoutMinute )
    {
        LoadString( _Module.GetResourceInstance( ) , nComboResID[ idx ] , tchErrItem , sizeof( tchErrItem ) / sizeof( TCHAR ) );

        LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_MAXVALEXCEEDED , tchErrMsg , sizeof( tchErrMsg ) / sizeof( TCHAR ) );

        wsprintf( tchErrTot , tchErrMsg , tchErrItem );

        MessageBox( hwndCtl , tchErrTot , tchErrTitle , MB_OK | MB_ICONERROR );

        SetFocus( hwndCtl );

        return FALSE;
    }

    *pulMinutes *= kMilliMinute;

    return TRUE;
}


//-------------------------------------------------------------------------------
// PersistSettings
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::PersistSettings( HWND hDlg )
{
    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht , sizeof( CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    if( !ConvertToMinutes( GetDlgItem( hDlg , IDC_COMBO_CONNECT ) , &uc.MaxConnectionTime ) )
    {
        return FALSE;
    }

    if( !ConvertToMinutes( GetDlgItem( hDlg , IDC_COMBO_DISCON ) , &uc.MaxDisconnectionTime ) )
    {
        return FALSE;
    }

    if( !ConvertToMinutes( GetDlgItem( hDlg , IDC_COMBO_IDLE ) , &uc.MaxIdleTime ) )
    {
        return FALSE;
    }   

    uc.fResetBroken = SendMessage( GetDlgItem( hDlg , IDC_RADIO_RESET ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

    uc.fReconnectSame = SendMessage( GetDlgItem( hDlg , IDC_RADIO_PREVCLIENT ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

    if( !m_pUSht->SetUserConfig( uc , &dwStatus ) )
    {
        ErrorMessage2( hDlg , dwStatus );

        return TRUE;
    }

    PostMessage( hDlg , WM_COMMAND , MAKELPARAM( 0 , ALN_APPLY )  , ( LPARAM )hDlg );

    SendMessage( GetParent( hDlg ) , PSM_UNCHANGED , ( WPARAM )hDlg , 0 );

    return TRUE;

}

//-------------------------------------------------------------------------------
// Making sure the user has entered valid info
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::IsValidSettings( HWND hDlg )
{
    DWORD dwDummy;

    if( IsBadReadPtr( m_pUSht , sizeof( CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    uc = m_pUSht->GetCurrentUserConfig( &dwDummy );

    if( !ConvertToMinutes( GetDlgItem( hDlg , IDC_COMBO_CONNECT ) , &uc.MaxConnectionTime ) )
    {
        return FALSE;
    }

    if( !ConvertToMinutes( GetDlgItem( hDlg , IDC_COMBO_DISCON ) , &uc.MaxDisconnectionTime ) )
    {
        return FALSE;
    }

    if( !ConvertToMinutes( GetDlgItem( hDlg , IDC_COMBO_IDLE ) , &uc.MaxIdleTime ) )
    {
        return FALSE;
    }

    return TRUE;
}

#if 0
//-------------------------------------------------------------------------------
// Lets cut to the chase and find out if this is even worth parsing
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::DoesContainDigits( LPTSTR pszString )
{
    while( *pszString )
    {
        if( iswdigit( *pszString ) )
        {
            return TRUE;
        }

        pszString++;
    }

    return FALSE;
}


//-------------------------------------------------------------------------------
LRESULT CTimeOutDlg::ParseDurationEntry( LPTSTR pszTime , PULONG pTime )
{
    TCHAR tchNoTimeout[ 80 ];

    LPTSTR pszTemp = pszTime;

    UINT uDec = 0;

    float fFrac = 0.0f;

    float fT;

    UINT uPos = 1;

    LoadString( _Module.GetResourceInstance( ) , IDS_NOTIMEOUT , tchNoTimeout , sizeof( tchNoTimeout ) / sizeof( TCHAR ) );

    if( lstrcmpi( pszTime , tchNoTimeout ) == 0 )
    {
        *pTime = 0;

        return E_SUCCESS;
    }

    if( !DoesContainDigits( pszTime ) )
    {
        return E_PARSE_MISSING_DIGITS;
    }

    while( *pszTemp )
    {
        if( !iswdigit( *pszTemp ) )
        {
            break;
        }

        // check for overflow

        if( uDec >= 1000000000 )
        {
            return E_PARSE_VALUEOVERFLOW ;
        }

        uDec *= 10;

        uDec += ( *pszTemp - '0' );

        pszTemp++;

    }

    TCHAR tchSDecimal[ 5 ];

    GetLocaleInfo( LOCALE_USER_DEFAULT , LOCALE_SDECIMAL , tchSDecimal , sizeof( tchSDecimal ) / sizeof( TCHAR ) );

    if( *pszTemp == *tchSDecimal )
    {
        pszTemp++;

        while( *pszTemp )
        {
            if( !iswdigit( *pszTemp ) )
            {
                break;
            }

            // check for overflow

            if( uDec >= 1000000000 )
            {
                return E_PARSE_VALUEOVERFLOW;
            }

            uPos *= 10;

            fFrac += ( ( float )( *pszTemp - '0' ) ) / ( float )uPos; //+ 0.05f;

            pszTemp++;
        }
    }

    // remove white space

    while( *pszTemp == L' ' )
    {
        pszTemp++;
    }


    if( *pszTemp != NULL )
    {
        if( IsToken( pszTemp , TOKEN_DAY ) )
        {
            *pTime = uDec * 24 * 60;

            fT = ( fFrac * 1440.0f + 0.5f );

            *pTime += ( ULONG )fT;

            return E_SUCCESS;
        }
        else if( IsToken( pszTemp , TOKEN_HOUR ) )
        {
            *pTime = uDec * 60;

            fT = ( fFrac * 60.0f + 0.5f );

            *pTime += ( ULONG )fT;

            return E_SUCCESS;
        }
        else if( IsToken( pszTemp , TOKEN_MINUTE ) )
        {
            // minutes are rounded up in the 1/10 place

            fT = fFrac + 0.5f;

            *pTime = uDec;

            *pTime += ( ULONG )( fT );

            return E_SUCCESS;

        }

    }

    if( *pszTemp == NULL )
    {

        // if no text is defined considered the entry in hours

        *pTime = uDec * 60;

         fT = ( fFrac * 60.0f + 0.5f );

        *pTime += ( ULONG )fT ;

        return E_SUCCESS;
    }


    return E_PARSE_INVALID;

}

#endif


//-------------------------------------------------------------------------------
// Adds strings to table from resource
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::LoadAbbreviates( )
{
    xxxLoadAbbreviate( &m_tokday[0] );

    xxxLoadAbbreviate( &m_tokhour[0] );

    xxxLoadAbbreviate( &m_tokmin[0] );

    return TRUE;
}

//-------------------------------------------------------------------------------
// Take cares some repetitive work for us
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::xxxLoadAbbreviate( PTOKTABLE ptoktbl )
{
    int idx;

    int nSize;

    TCHAR tchbuffer[ 80 ];

    if( ptoktbl == NULL )
    {
        return FALSE;
    }

    for( idx = 0; ptoktbl[ idx ].dwresourceid != ( DWORD )-1 ; ++idx )
    {
        nSize = LoadString( _Module.GetResourceInstance( ) , ptoktbl[ idx ].dwresourceid , tchbuffer , sizeof( tchbuffer ) / sizeof( TCHAR ) );

        if( nSize > 0 )
        {
            ptoktbl[ idx ].pszAbbrv = ( TCHAR *)new TCHAR[ nSize + 1 ];

            if( ptoktbl[ idx ].pszAbbrv != NULL )
            {
                lstrcpy( ptoktbl[ idx ].pszAbbrv , tchbuffer );
            }
        }
    }

    return TRUE;
}

//-------------------------------------------------------------------------------
// Frees up allocated resources
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::xxxUnLoadAbbreviate( PTOKTABLE ptoktbl )
{
    if( ptoktbl == NULL )
    {
        return FALSE;
    }

    for( int idx = 0; ptoktbl[ idx ].dwresourceid != ( DWORD )-1 ; ++idx )
    {
        if( ptoktbl[ idx ].pszAbbrv != NULL )
        {
            delete[] ptoktbl[ idx ].pszAbbrv;

        }
    }

    return TRUE;
}

//-------------------------------------------------------------------------------
// tear-off token tables
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::IsToken( LPTSTR pszString , TOKEN tok )
{
    TOKTABLE *ptoktable;

    if( tok == TOKEN_DAY )
    {
        ptoktable = &m_tokday[0];
    }
    else if( tok == TOKEN_HOUR )
    {
        ptoktable = &m_tokhour[0];
    }
    else if( tok == TOKEN_MINUTE )
    {
        ptoktable = &m_tokmin[0];
    }
    else
    {
        return FALSE;
    }


    for( int idx = 0 ; ptoktable[ idx ].dwresourceid != -1 ; ++idx )
    {
        if( lstrcmpi( pszString , ptoktable[ idx ].pszAbbrv ) == 0 )
        {
            return TRUE;
        }
    }

    return FALSE;

}

#if 0
//-------------------------------------------------------------------------------
// Converts the number minutes into a formated string
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::ConvertToDuration( ULONG ulTime , LPTSTR pszDuration )
{
    INT_PTR dw[3];

    TCHAR tchTimeUnit[ 40 ];

    TCHAR tchTimeFormat[ 40 ];

    TCHAR tchOutput[ 80 ];

    ASSERT_( ulTime != 0 );

    int iHour= ( int ) ( ( float )ulTime / 60.0f );

    int iDays = iHour / 24;

    dw[ 2 ] = ( INT_PTR )&tchTimeUnit[ 0 ];

    LoadString( _Module.GetResourceInstance( ) , IDS_DIGIT_DOT_DIGIT_TU , tchTimeFormat , sizeof( tchTimeFormat ) / sizeof( TCHAR ) );

    if( iDays != 0 )
    {
        int iRemainingHours = iHour % 24;

        float fx = ( float )iRemainingHours / 24.0f + 0.05f;

        int iRemainingMinutes = ulTime % 60;

        float mfx = ( float )iRemainingMinutes / 60.0f + 0.05f;

        //if( ( iRemainingHours != 0 || iRemainingMinutes != 0 ) && iDays < 2 )

        if( mfx > 0.05f || ( fx > 0.05f && fx < 0.10f && iDays < 2 ) )//
        {
            iRemainingMinutes = ( int ) ( mfx * 10 );

            dw[ 0 ] = iHour;

            dw[ 1 ] = iRemainingMinutes;

            iDays = 0;

            LoadString( _Module.GetResourceInstance( ) , IDS_HOURS , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );

        }
        else
        {
            iRemainingHours = ( int )( fx * 10 );

            LoadString( _Module.GetResourceInstance( ) , IDS_DAYS , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );

            dw[ 0 ] = iDays;

            dw[ 1 ] = iRemainingHours;
        }

        if( dw[ 1 ] == 0 )
        {
            // formatted string requires two arguments

            dw[ 1 ] = ( INT_PTR )&tchTimeUnit[ 0 ];

            LoadString( _Module.GetResourceInstance( ) , IDS_DIGIT_TU , tchTimeFormat , sizeof( tchTimeFormat ) / sizeof( TCHAR ) );

            if( iDays == 1 )
            {
                LoadString( _Module.GetResourceInstance( ) , IDS_DAY , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
            }
        }

    }

    else if( iHour != 0 )
    {
        int iRemainingMinutes = ulTime % 60;

        float fx = ( float )iRemainingMinutes / 60.0f ;//+ 0.05f;

        if( fx > 0.0f && fx < 0.10f && iHour < 2 )//
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_MINUTES , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );

            LoadString( _Module.GetResourceInstance( ) , IDS_DIGIT_TU , tchTimeFormat , sizeof( tchTimeFormat ) / sizeof( TCHAR ) );

            dw[ 0 ] = ulTime ;

            dw[ 1 ] = ( INT_PTR )&tchTimeUnit[ 0 ];

            if( ulTime > 1 )
            {
                LoadString( _Module.GetResourceInstance( ) , IDS_MINUTES , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
            }
            else
            {
                LoadString( _Module.GetResourceInstance( ) , IDS_MINUTE , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
            }
        }//
        else
        {
            fx += 0.05f;

            iRemainingMinutes = ( int ) ( fx * 10 );

            dw[ 0 ] = iHour;

            dw[ 1 ] = iRemainingMinutes;

            LoadString( _Module.GetResourceInstance( ) , IDS_HOURS , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );

            if( iRemainingMinutes == 0 )
            {
                dw[ 1 ] = ( INT_PTR )&tchTimeUnit[ 0 ];

                LoadString( _Module.GetResourceInstance( ) , IDS_DIGIT_TU , tchTimeFormat , sizeof( tchTimeFormat ) / sizeof( TCHAR ) );

                if( iHour == 1 )
                {
                    LoadString( _Module.GetResourceInstance( ) , IDS_HOUR , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
                }
            }
        }
    }
    else
    {
        LoadString( _Module.GetResourceInstance( ) , IDS_MINUTES , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );

        LoadString( _Module.GetResourceInstance( ) , IDS_DIGIT_TU , tchTimeFormat , sizeof( tchTimeFormat ) / sizeof( TCHAR ) );

        dw[ 0 ] = ulTime ;

        dw[ 1 ] = ( INT_PTR )&tchTimeUnit[ 0 ];

        if( ulTime > 1 )
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_MINUTES , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }
        else
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_MINUTE , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }
    }

    FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, tchTimeFormat , 0 , 0 , tchOutput , sizeof( tchOutput )/sizeof( TCHAR ) , ( va_list * )&dw );

    lstrcpy( pszDuration , tchOutput );

    return TRUE;
}

#endif

//-------------------------------------------------------------------------------
// Place entry in listbox and set as current selection
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::InsertSortedAndSetCurSel( HWND hCombo , DWORD dwMinutes )
{
    ASSERT_( dwMinutes != ( DWORD )-1 );

    TCHAR tchBuffer[ 80 ];

    LRESULT iCount = SendMessage( hCombo , CB_GETCOUNT , 0 , 0 );

    for( INT_PTR idx = 0 ; idx < iCount ; ++idx )
    {
        // Don't insert an item that's already in the list

        if( dwMinutes == ( DWORD )SendMessage( hCombo , CB_GETITEMDATA , idx , 0 ) )
        {
            SendMessage( hCombo , CB_SETCURSEL , idx , 0 ) ;

            SaveChangedSelection( hCombo );

            return TRUE;
        }

        if( dwMinutes < ( DWORD )SendMessage( hCombo , CB_GETITEMDATA , idx , 0 ) )
        {
            break;
        }
    }

    // hey if the value has exceeded the max timeout don't bother entering it in our list

    if( dwMinutes > kMaxTimeoutMinute )
    {
        return FALSE;
    }

    if( ConvertToDuration ( dwMinutes , tchBuffer ) )
    {
        idx = SendMessage( hCombo , CB_INSERTSTRING , idx , ( LPARAM )&tchBuffer[ 0 ] );

        if( idx != CB_ERR )
        {
            SendMessage( hCombo , CB_SETITEMDATA , idx , dwMinutes );

        }

        SendMessage( hCombo , CB_SETCURSEL , idx , 0 ) ;
    }

    // must call this here because CB_SETCURSEL does not send CBN_SELCHANGE

    SaveChangedSelection( hCombo );

    return TRUE;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

//-------------------------------------------------------------------------------
// CShadowDlg::ctor
//-------------------------------------------------------------------------------
CShadowDlg::CShadowDlg( CTSUserSheet *pUSht )
{
    m_pUSht = pUSht;

    m_wOldRad = ( WORD )-1;
}

//-------------------------------------------------------------------------------
// CShadowDlg Dialog Page
// -- static methods lacks this ptr
//-------------------------------------------------------------------------------
INT_PTR CALLBACK CShadowDlg::DlgProc( HWND hwnd , UINT msg , WPARAM wp , LPARAM lp )
{
    CShadowDlg *pDlg;

    if( msg == WM_INITDIALOG )
    {
        CShadowDlg *pDlg = ( CShadowDlg * )( ( PROPSHEETPAGE *)lp )->lParam ;

        SetWindowLongPtr( hwnd , DWLP_USER , ( LONG_PTR )pDlg );

        if( !IsBadReadPtr( pDlg , sizeof( CShadowDlg ) ) )
        {
            pDlg->OnInitDialog( hwnd , wp , lp );
        }

        return 0;
    }

    else
    {
        pDlg = ( CShadowDlg * )GetWindowLongPtr( hwnd , DWLP_USER );

        if( IsBadReadPtr( pDlg , sizeof( CShadowDlg ) ) )
        {
            return FALSE;
        }
    }

    switch( msg )
    {

    case WM_NCDESTROY:

        pDlg->OnDestroy( );

        break;

    case WM_COMMAND:

        pDlg->OnCommand( HIWORD( wp ) , LOWORD( wp ) , ( HWND )lp );

        break;

    case WM_NOTIFY:

        return pDlg->OnNotify( ( int )wp , ( LPNMHDR )lp , hwnd );

    case WM_HELP:

        pDlg->OnHelp( hwnd , ( LPHELPINFO )lp );

        break;

    case WM_RBUTTONUP:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            HWND hChild = ChildWindowFromPoint( hwnd , pt );

            ClientToScreen( hwnd , &pt );

            pDlg->OnContextMenu( hChild , pt );
        }

        break;

    case WM_CONTEXTMENU:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            pDlg->OnContextMenu( ( HWND )wp , pt );
        }

    }

    return 0;
}

//-------------------------------------------------------------------------------
// InitDialog for CShadowDlg
//-------------------------------------------------------------------------------
BOOL CShadowDlg::OnInitDialog( HWND hwnd , WPARAM wp , LPARAM lp )
{
    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht ,sizeof(  CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    // No userconfig loaded most likey access denied donot allow users to modify anything

    if( dwStatus != ERROR_FILE_NOT_FOUND && dwStatus != ERROR_SUCCESS )
    {
        INT nId[ ] = {
                        IDC_CHECK_SHADOW,
                        IDC_RADIO_WATCH,
                        IDC_RADIO_CONTROL,
                        IDC_CHECK_NOTIFY,
                        -1
        };

        for( int idx = 0; nId[ idx ] != -1 ; ++idx )
        {
            EnableWindow( GetDlgItem( hwnd , nId[ idx ] ) , FALSE );
        }

        ErrorMessage1( hwnd , dwStatus );

        return FALSE;
    }

    if( uc.Shadow == Shadow_Disable )
    {
        SendMessage( GetDlgItem( hwnd , IDC_CHECK_SHADOW ) , BM_SETCHECK , ( WPARAM )FALSE , 0  );

        EnableWindow( GetDlgItem( hwnd , IDC_RADIO_WATCH ) , FALSE );

        EnableWindow( GetDlgItem( hwnd , IDC_RADIO_CONTROL ) , FALSE );

        EnableWindow( GetDlgItem( hwnd , IDC_CHECK_NOTIFY ) , FALSE );

        EnableWindow( GetDlgItem( hwnd , IDC_STATIC_LEVELOFCTRL ) , FALSE );
    }
    else
    {
        //
        // Controls are initially enabled,  set current status
        //

        SendMessage( GetDlgItem( hwnd , IDC_CHECK_SHADOW ) , BM_SETCHECK , ( WPARAM )TRUE , 0  );

        switch( uc.Shadow )
        {
        case Shadow_EnableInputNotify:

            SendMessage( GetDlgItem( hwnd , IDC_CHECK_NOTIFY ) , BM_SETCHECK , ( WPARAM )TRUE , 0 );

            SendMessage( GetDlgItem( hwnd , IDC_RADIO_CONTROL ) , BM_CLICK , 0 , 0 );

            break;

        case Shadow_EnableInputNoNotify:

            SendMessage( GetDlgItem( hwnd , IDC_CHECK_NOTIFY ) , BM_SETCHECK , ( WPARAM )FALSE , 0 );

            SendMessage( GetDlgItem( hwnd , IDC_RADIO_CONTROL ) , BM_CLICK , 0 , 0 );

            break;

        case Shadow_EnableNoInputNotify:

            SendMessage( GetDlgItem( hwnd , IDC_CHECK_NOTIFY ) , BM_SETCHECK , ( WPARAM )TRUE , 0 );

            SendMessage( GetDlgItem( hwnd , IDC_RADIO_WATCH ) , BM_CLICK , 0 , 0 );

            break;

        case Shadow_EnableNoInputNoNotify:

            SendMessage( GetDlgItem( hwnd , IDC_CHECK_NOTIFY ) , BM_SETCHECK , ( WPARAM )FALSE , 0 );

            SendMessage( GetDlgItem( hwnd , IDC_RADIO_WATCH ) , BM_CLICK , 0 , 0 );

            break;
        }

        m_wOldRad = ( WORD )( IsDlgButtonChecked( hwnd , IDC_RADIO_WATCH ) ? IDC_RADIO_WATCH : IDC_RADIO_CONTROL ) ;

    }

    m_bPersisted = TRUE;

    return CDialogBase::OnInitDialog( hwnd , wp , lp );
}


BOOL CShadowDlg::OnDestroy( )
{
    return CDialogBase::OnDestroy( );
}

//-------------------------------------------------------------------------------
// GetPropertySheetPage - each dialog object should be responsible for its own data
//-------------------------------------------------------------------------------
BOOL CShadowDlg::GetPropertySheetPage( PROPSHEETPAGE &psp )
{
    ZeroMemory( &psp , sizeof( PROPSHEETPAGE ) );

    psp.dwSize      = sizeof( PROPSHEETPAGE );

    psp.dwFlags     = PSP_DEFAULT | PSP_USECALLBACK;

    psp.hInstance   = _Module.GetModuleInstance( );

    psp.pszTemplate = MAKEINTRESOURCE( IDD_PAGE_SHADOW );

    psp.lParam      = (LPARAM)this;

    psp.pfnCallback = CDialogBase::PageCallback;

    psp.pfnDlgProc  = CShadowDlg::DlgProc;

    return TRUE;
}

//-------------------------------------------------------------------------------
// Basic control notification handler
//-------------------------------------------------------------------------------
void CShadowDlg::OnCommand( WORD wNotifyCode , WORD wID , HWND hwndCtl )
{
    switch( wNotifyCode )
    {
    case BN_CLICKED:
        if( wID == IDC_CHECK_SHADOW )
        {
            HWND hwnd = GetParent( hwndCtl );

            BOOL bChecked = SendMessage( hwndCtl , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? TRUE : FALSE;

            SendMessage( GetDlgItem( hwnd , IDC_CHECK_SHADOW ) , BM_SETCHECK , ( WPARAM )bChecked , 0  );

            EnableWindow( GetDlgItem( hwnd , IDC_RADIO_WATCH ) , bChecked );

            EnableWindow( GetDlgItem( hwnd , IDC_RADIO_CONTROL ) , bChecked );

            EnableWindow( GetDlgItem( hwnd , IDC_CHECK_NOTIFY ) , bChecked );

            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_LEVELOFCTRL ) , bChecked );

            //
            // if neither radio buttons are selected force IDC_RADIO_CONTROL to be selected
            //

            if(
                ( SendMessage( GetDlgItem( hwnd , IDC_RADIO_WATCH ) , BM_GETSTATE , 0 , 0 ) == BST_UNCHECKED )
                &&
                ( SendMessage( GetDlgItem( hwnd , IDC_RADIO_CONTROL ) , BM_GETSTATE , 0 , 0 ) == BST_UNCHECKED )
               )
            {
                SendMessage( GetDlgItem( hwnd , IDC_RADIO_CONTROL ) , BM_SETCHECK , ( WPARAM )BST_CHECKED , 0 );

                m_wOldRad = IDC_RADIO_CONTROL;
            }

            m_bPersisted = FALSE;

            SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );

        }
        else if( wID == IDC_RADIO_WATCH || wID == IDC_RADIO_CONTROL )
        {
            if( wID != m_wOldRad )
            {
                m_wOldRad = wID;

                m_bPersisted = FALSE;

                SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
            }
        }
        else if( wID == IDC_CHECK_NOTIFY )
        {
            m_bPersisted = FALSE;

            SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
        }


        break;

    case ALN_APPLY:

        //This is being removed for consinstency with the rest of MMC dialogs, even though it would
        //make more sense to the user for Cancel to be disabled after applying the changes, since
        //cancellation is not a real option at that point.
        //SendMessage( GetParent( hwndCtl ) , PSM_CANCELTOCLOSE , 0 , 0 );

        break;
    }
}

//-------------------------------------------------------------------------------
// PersisitSettings
//-------------------------------------------------------------------------------
BOOL CShadowDlg::PersistSettings( HWND hDlg )
{
    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht , sizeof( CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    //
    // Record all changes
    //

    if( SendMessage( GetDlgItem( hDlg , IDC_CHECK_SHADOW ) , BM_GETCHECK , 0 , 0 ) != BST_CHECKED )
    {
        uc.Shadow = Shadow_Disable;
    }

    else
    {
        BOOL bCheckNotify = (BOOL)SendMessage( GetDlgItem( hDlg , IDC_CHECK_NOTIFY ) , BM_GETCHECK , 0 , 0 );

        BOOL bRadioControl = (BOOL)SendMessage( GetDlgItem( hDlg , IDC_RADIO_CONTROL ) , BM_GETCHECK , 0 , 0 );

        if( bCheckNotify )
        {
            if( bRadioControl )
            {
                uc.Shadow = Shadow_EnableInputNotify;
            }
            else
            {
                uc.Shadow = Shadow_EnableNoInputNotify;
            }
        }
        else
        {
            if( bRadioControl )
            {
                uc.Shadow = Shadow_EnableInputNoNotify;
            }
            else
            {
                uc.Shadow = Shadow_EnableNoInputNoNotify;
            }
        }
    }

    if( !m_pUSht->SetUserConfig( uc , &dwStatus ) )
    {
        ErrorMessage2( hDlg , dwStatus );

        return TRUE;
    }

    PostMessage( hDlg , WM_COMMAND , MAKELPARAM( 0 , ALN_APPLY )  , ( LPARAM )hDlg );

    SendMessage( GetParent( hDlg ) , PSM_UNCHANGED , ( WPARAM )hDlg , 0 );

    return TRUE;

}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

CProfileDlg::CProfileDlg( CTSUserSheet *pUsh )
{
    m_pUSht = pUsh;

    m_wOldRadio = ( WORD )-1;
    
    m_ncbxOld = -1;
}

//-------------------------------------------------------------------------------
// GetPropertySheetPage - each dialog object should be responsible for its own data
//-------------------------------------------------------------------------------
BOOL CProfileDlg::GetPropertySheetPage( PROPSHEETPAGE &psp )
{
    ZeroMemory( &psp , sizeof( PROPSHEETPAGE ) );

    psp.dwSize      = sizeof( PROPSHEETPAGE );

    psp.dwFlags     = PSP_DEFAULT | PSP_USECALLBACK;

    psp.hInstance   = _Module.GetModuleInstance( );

    psp.pszTemplate = MAKEINTRESOURCE( IDD_PAGE_PROFILE );

    psp.lParam      = (LPARAM)this;

    psp.pfnCallback = CDialogBase::PageCallback;

    psp.pfnDlgProc  = CProfileDlg::DlgProc;

    return TRUE;
}

//-------------------------------------------------------------------------------
// CProfileDlg Dialog Page
// -- static methods lacks this ptr
//-------------------------------------------------------------------------------
INT_PTR CALLBACK CProfileDlg::DlgProc( HWND hwnd , UINT msg , WPARAM wp , LPARAM lp )
{
    CProfileDlg *pDlg;

    if( msg == WM_INITDIALOG )
    {
        CProfileDlg *pDlg = ( CProfileDlg * )( ( PROPSHEETPAGE *)lp )->lParam ;

        SetWindowLongPtr( hwnd , DWLP_USER , ( LONG_PTR )pDlg );

        if( !IsBadReadPtr( pDlg , sizeof( CProfileDlg ) ) )
        {
            pDlg->OnInitDialog( hwnd , wp , lp );
        }

        return 0;
    }

    else
    {
        pDlg = ( CProfileDlg * )GetWindowLongPtr( hwnd , DWLP_USER );

        if( IsBadReadPtr( pDlg , sizeof( CProfileDlg ) ) )
        {
            return FALSE;
        }
    }


    switch( msg )
    {

    case WM_NCDESTROY:

        pDlg->OnDestroy( );

        break;

    case WM_COMMAND:

        pDlg->OnCommand( HIWORD( wp ) , LOWORD( wp ) , ( HWND )lp );

        break;

    case WM_NOTIFY:

        return pDlg->OnNotify( ( int )wp , ( LPNMHDR )lp , hwnd );

    case WM_HELP:

        pDlg->OnHelp( hwnd , ( LPHELPINFO )lp );

        break;

    case WM_RBUTTONUP:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            HWND hChild = ChildWindowFromPoint( hwnd , pt );

            ClientToScreen( hwnd , &pt );

            pDlg->OnContextMenu( hChild , pt );
        }

        break;

    case WM_CONTEXTMENU:
        {
            POINT pt;

            pt.x = LOWORD( lp );

            pt.y = HIWORD( lp );

            pDlg->OnContextMenu( ( HWND )wp , pt );
        }

    }

    return 0;
}

//-------------------------------------------------------------------------------
// InitDialog for CProfileDlg
//-------------------------------------------------------------------------------
BOOL CProfileDlg::OnInitDialog( HWND hwnd , WPARAM wp , LPARAM lp )
{
    TCHAR tchDrv[3];

    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht ,sizeof(  CTSUserSheet ) ) )
    {
        return FALSE;
    }

    USERCONFIG uc;

    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    if( dwStatus != ERROR_FILE_NOT_FOUND && dwStatus != ERROR_SUCCESS )
    {
        INT nId[ ] = {
                        IDC_CHECK_ALLOWLOGON,
                        IDC_COMBO_DRIVES,
                        IDC_EDIT_REMOTEPATH,
                        IDC_RADIO_REMOTE,
                        IDC_EDIT_LOCALPATH,
                        IDC_RADIO_LOCAL,
                        IDC_EDIT_USRPROFILE,
                        -1
        };

        for( int idx = 0; nId[ idx ] != -1 ; ++idx )
        {
            EnableWindow( GetDlgItem( hwnd , nId[ idx ] ) , FALSE );
        }

        ErrorMessage1( hwnd , dwStatus );

        return FALSE;
    }

    SendMessage( GetDlgItem( hwnd , IDC_CHECK_ALLOWLOGON ) , BM_SETCHECK , ( WPARAM )( !uc.fLogonDisabled ) , 0 );

    SendMessage( GetDlgItem( hwnd , IDC_EDIT_LOCALPATH  ) , EM_SETLIMITTEXT , ( WPARAM )DIRECTORY_LENGTH , 0 );

    SendMessage( GetDlgItem( hwnd , IDC_EDIT_REMOTEPATH  ) , EM_SETLIMITTEXT , ( WPARAM )DIRECTORY_LENGTH , 0 );

    SendMessage( GetDlgItem( hwnd , IDC_EDIT_USRPROFILE  ) , EM_SETLIMITTEXT , ( WPARAM )DIRECTORY_LENGTH , 0 );


    for( TCHAR DrvLetter = 'C'; DrvLetter <= 'Z'; DrvLetter++ )
    {
        tchDrv[0] = DrvLetter;

        tchDrv[1] = ':';

        tchDrv[2] = 0;

        SendMessage( GetDlgItem( hwnd , IDC_COMBO_DRIVES ) , CB_ADDSTRING , 0 , ( LPARAM )&tchDrv[ 0 ] );
    }

	if( PathIsUNC( uc.WFHomeDir ) )
	{
		ODS( L"TSUSEREX: Path is UNC\n" );

		CharUpper( &uc.WFHomeDirDrive[0] );

		if( uc.WFHomeDirDrive[ 0 ] >= 'C' && uc.WFHomeDirDrive[ 0 ] <= 'Z' )
        {
            m_ncbxOld = (int)SendMessage( GetDlgItem( hwnd , IDC_COMBO_DRIVES ) , CB_SETCURSEL , ( WPARAM )( uc.WFHomeDirDrive[ 0 ] - 'C' ) , 0 );
        }
		else
		{
			// default it to Z drive

			m_ncbxOld = (int)SendMessage( GetDlgItem( hwnd , IDC_COMBO_DRIVES ) , CB_SETCURSEL , ( WPARAM )( 'Z' - 'C' ) , 0 );
		}


        SetWindowText( GetDlgItem( hwnd , IDC_EDIT_REMOTEPATH ) , uc.WFHomeDir );

        //SendMessage( GetDlgItem( hwnd , IDC_RADIO_REMOTE ) , BM_CLICK , 0 , 0 );
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_REMOTE ) , BM_SETCHECK , ( WPARAM )BST_CHECKED , 0 );
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_LOCAL ) , BM_SETCHECK , ( WPARAM )BST_UNCHECKED , 0 );

        m_wOldRadio = IDC_RADIO_REMOTE;
    }
	else
    {
		ODS( L"TSUSEREX: Path is Local\n" );
        SendMessage( GetDlgItem( hwnd , IDC_EDIT_LOCALPATH ) , WM_SETTEXT , 0 , ( LPARAM )&uc.WFHomeDir[ 0 ] );

        // SendMessage( GetDlgItem( hwnd , IDC_RADIO_LOCAL ) , BM_CLICK , 0 , 0 );
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_LOCAL ) , BM_SETCHECK , ( WPARAM )BST_CHECKED , 0 );
        SendMessage( GetDlgItem( hwnd , IDC_RADIO_REMOTE ) , BM_SETCHECK , ( WPARAM )BST_UNCHECKED , 0 );

        m_wOldRadio = IDC_RADIO_LOCAL;
    }

    EnableRemoteHomeDirectory( hwnd , ( BOOL )( m_wOldRadio == IDC_RADIO_REMOTE ) );


    SendMessage( GetDlgItem( hwnd , IDC_EDIT_USRPROFILE ) , WM_SETTEXT , 0 , ( LPARAM )&uc.WFProfilePath[ 0 ] );

    m_bPersisted = TRUE;

    m_bTSHomeFolderChanged = FALSE;

    return CDialogBase::OnInitDialog( hwnd , wp , lp );
}

//-------------------------------------------------------------------------------
// EnableRemoteHomeDirectory -- basically enables or disables dlg controls
//-------------------------------------------------------------------------------
BOOL CProfileDlg::EnableRemoteHomeDirectory( HWND hwnd , BOOL bHDMR )
{
    //
    // Local home directory
    //

    EnableWindow( GetDlgItem( hwnd , IDC_EDIT_LOCALPATH ) , !bHDMR );

    //
    // Network'd home directory
    //

    EnableWindow( GetDlgItem( hwnd , IDC_COMBO_DRIVES ) , bHDMR );
   
    EnableWindow( GetDlgItem( hwnd , IDC_EDIT_REMOTEPATH ) , bHDMR );
    
    return TRUE;
}


BOOL CProfileDlg::OnDestroy( )
{
    return CDialogBase::OnDestroy( );
}

//-------------------------------------------------------------------------------
// Basic control notification handler
//-------------------------------------------------------------------------------
void CProfileDlg::OnCommand( WORD wNotifyCode , WORD wID , HWND hwndCtl )
{
    switch( wNotifyCode )
    {
    case EN_CHANGE:

        m_bPersisted = FALSE;

        if( wID == IDC_EDIT_REMOTEPATH || wID == IDC_EDIT_LOCALPATH )
        {
            ODS( L"EN_CHANGE m_bTSHomeFolderChanged = TRUE;\n" );

            m_bTSHomeFolderChanged = TRUE;
        }

        SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );

        break;

    //case CBN_DROPDOWN:
    case CBN_SELCHANGE:
        {
            int nCurSel = (int)SendMessage( hwndCtl , CB_GETCURSEL , 0 , 0 );
        
            if( m_ncbxOld != nCurSel )
            {
                m_ncbxOld = nCurSel;

                ODS( L"CBN_SELCHANGE m_bTSHomeFolderChanged = TRUE;\n" );

                m_bTSHomeFolderChanged = TRUE;

                m_bPersisted = FALSE;
            
                SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
            }
        }
        
        break;        

    case BN_CLICKED:

        if( wID == IDC_RADIO_REMOTE || wID == IDC_RADIO_LOCAL )
        {
            if( wID != m_wOldRadio )
            {
                EnableRemoteHomeDirectory( GetParent( hwndCtl ) , ( BOOL )( wID == IDC_RADIO_REMOTE ) );

                m_wOldRadio = wID;

                m_bPersisted = FALSE;
                
                ODS( L"Setting m_bTSHomeFolderChanged to true\n" );

                m_bTSHomeFolderChanged = TRUE;

                SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
            }

            if( wID == IDC_RADIO_LOCAL )
            {
                SetFocus( GetDlgItem( GetParent( hwndCtl ) , IDC_EDIT_LOCALPATH ) );

                SendMessage( GetDlgItem( GetParent( hwndCtl ) , IDC_EDIT_LOCALPATH ) , EM_SETSEL , ( WPARAM )0 , ( LPARAM )-1 );
            }
            else if( wID == IDC_RADIO_REMOTE )
            {
                if( SendMessage( GetDlgItem( GetParent( hwndCtl ) , IDC_COMBO_DRIVES ) , 
                                 CB_GETCURSEL,
                                 0,
                                 0 ) == CB_ERR )
                {
                    SendMessage( GetDlgItem( GetParent( hwndCtl ) , IDC_COMBO_DRIVES ) ,
                                 CB_SETCURSEL,
                                 ( WPARAM )( 'Z' - 'C' ),
                                 0 );
                }

                SetFocus( GetDlgItem( GetParent( hwndCtl ) , IDC_COMBO_DRIVES ) );
            }

        }
        else if( wID == IDC_CHECK_ALLOWLOGON )
        {
            m_bPersisted = FALSE;

            SendMessage( GetParent( GetParent( hwndCtl ) ) , PSM_CHANGED , ( WPARAM )GetParent( hwndCtl ) , 0 );
        }

        break;

    case ALN_APPLY:

        //This is being removed for consinstency with the rest of MMC dialogs, even though it would
        //make more sense to the user for Cancel to be disabled after applying the changes, since
        //cancellation is not a real option at that point.
        //SendMessage( GetParent( hwndCtl ) , PSM_CANCELTOCLOSE , 0 , 0 );

        break;
    }


}

//-------------------------------------------------------------------------------
// PersistSettings -- remember TRUE is bad FALSE is good
//-------------------------------------------------------------------------------
BOOL CProfileDlg::PersistSettings( HWND hDlg )
{
    BOOL bRet = TRUE;;

    DWORD dwStatus;

    if( IsBadReadPtr( m_pUSht , sizeof( CTSUserSheet ) ) )
    {
        return TRUE;
    }


    USERCONFIG uc;


    uc = m_pUSht->GetCurrentUserConfig( &dwStatus );

    //
    // expensive but necessary id34393
    //
    if( !m_pUSht->SetUserConfig( uc , &dwStatus ) )
    {
        ErrorMessage2( hDlg , dwStatus );

        m_bTSHomeFolderChanged = FALSE;

        return TRUE;
    }

    //
    // Determine whether to enable user to logon to a terminal server
    //

    uc.fLogonDisabled = SendMessage( GetDlgItem( hDlg , IDC_CHECK_ALLOWLOGON ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED ? FALSE : TRUE;
    
    //
    // Profile path is under the admin discretion
    //

    SetWTSProfilePath( hDlg , uc );

    //
    // Parse and flag corrupt data
    //

    if( m_bTSHomeFolderChanged )
    {
        ODS( L"Persisting home folder settings\n" );

        if( SendMessage( GetDlgItem( hDlg , IDC_RADIO_LOCAL ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED )
        {
            bRet = SetWTSLocalPath( hDlg , uc );
            // Set WFHomeDirDrive to NULL because Home folder is a Local folder
            wcscpy(uc.WFHomeDirDrive, L"\0");
        }
        else
        {
            bRet = SetWTSRemotePath( hDlg , uc );
        }

        m_bTSHomeFolderChanged = FALSE;
    }

    if( bRet )
    {
        if( !m_pUSht->SetUserConfig( uc , &dwStatus ) )
        {
            ErrorMessage2( hDlg , dwStatus );

            return TRUE;
        }
        
        PostMessage( hDlg , WM_COMMAND , MAKELPARAM( 0 , ALN_APPLY )  , ( LPARAM )hDlg );

        SendMessage( GetParent( hDlg ) , PSM_UNCHANGED , ( WPARAM )hDlg , 0 );

    }

    return bRet;
}

//-------------------------------------------------------------------------------
// IsValidSettings doesnot persist the information
//-------------------------------------------------------------------------------
BOOL CProfileDlg::IsValidSettings( HWND hDlg )
{
    BOOL bRet = TRUE;

    //
    // Parse and flag corrupt data
    //

    if( m_bTSHomeFolderChanged )
    {
        ODS( L"Checking validity of home folders\n" );

        if( SendMessage( GetDlgItem( hDlg , IDC_RADIO_LOCAL ) , BM_GETCHECK , 0 , 0 ) == BST_CHECKED )
        {
            bRet = IsLocalPathValid( hDlg );
        }
        else
        {
            bRet = IsRemotePathValid( hDlg );
        }
    }

    return bRet;
}


//-------------------------------------------------------------------------------
// SetWTSProfilePath
//-------------------------------------------------------------------------------
BOOL CProfileDlg::SetWTSProfilePath( HWND hDlg , USERCONFIG& uc )
{
    //
    // It looks like we don't care what the user enters
    // I'm borrowing the behavior from the current usrmgr profile page
    //

    GetWindowText( GetDlgItem( hDlg , IDC_EDIT_USRPROFILE ) , uc.WFProfilePath , sizeof( uc.WFProfilePath ) / sizeof( TCHAR ) );

    ExpandUserName( uc.WFProfilePath );

    SetWindowText( GetDlgItem( hDlg , IDC_EDIT_USRPROFILE ) , uc.WFProfilePath );

    return TRUE;
}

// Create all the folders required, up to and including the leaf folder.
// Path is expected to be of the form \\server\share\...
HRESULT CProfileDlg::CreateRemoteFolder(LPCTSTR path)
{
    HRESULT hr = S_OK;

    LPTSTR current = (LPTSTR)path;
    DWORD  dwError;

    //Find the first whack after the 1st 2
    current = wcschr(current + 2, L'\\');

    //Now find the next one. We should be at the end of the share name
    current = wcschr(current + 1, L'\\');

    //Now find the next one. We should be at the end of the drive name
    current = wcschr(current + 1, L'\\');

    while (SUCCEEDED(hr))
    {
        //Mark the trailing backslash as the end of the string.  This
        //makes path point to a truncated path (containing only the folder
        //names we have walked thru so far).
        if (current)
            *current = 0;



        // create a secure ACL'd directory if it already exists it will
        // return a success
        if (!CreateSecureDir((LPTSTR)path , &dwError))
        {
            ODS(L"CreateSecureDir failed\n");
            hr = E_FAIL;
        }

        if (current)
        {
            //Replace the original trailing backslash, and move on to the
            //next backslash after that.
            *current = L'\\';
            current = wcschr(current + 1, L'\\');
        }
        else
        {
            //No more folders are on the path.  We're done.
            break;
        }
    }

    return hr;
}

BOOL CProfileDlg::IsLocalComputer(WCHAR* pwchMachinename)
{
    BOOL bLocal = FALSE;

    WCHAR pwchComputerName[MAX_COMPUTERNAME_LENGTH + 1];

    DWORD dwLen = sizeof(pwchComputerName)/sizeof(WCHAR);

    if (GetComputerNameEx(ComputerNameNetBIOS, pwchComputerName, &dwLen))
    {
        if (_wcsicmp(pwchComputerName, pwchMachinename) == 0)
            bLocal = TRUE;
    }

    if (GetComputerNameEx(ComputerNameDnsFullyQualified, pwchComputerName, &dwLen))
    {
        if (_wcsicmp(pwchComputerName, pwchMachinename) == 0)
            bLocal = TRUE;
    }

    return bLocal;
}



//Put the absolute path into the form \\machinename\drive$\path
BOOL CProfileDlg::CreateSystemPath(WCHAR* chPath)
{
    WCHAR* pstrMachinename = NULL;

    if (m_pUSht->GetServer(&pstrMachinename))
    {
        if (pstrMachinename)
        {
            //Start constructing the system path
            WCHAR chSystemPath[MAX_PATH];
            wcscpy(chSystemPath, L"\\\\");
            wcsncat(chSystemPath, pstrMachinename, MAX_PATH - wcslen(chSystemPath) - 1);

            //Now set the local flag accordingly
            BOOL bLocalMachine = IsLocalComputer(pstrMachinename);

            //We've got no use for this anymore
            if (pstrMachinename)
                delete[] pstrMachinename;

            if (bLocalMachine)
            {
                DWORD dwErr = 0;
                return createdir(chPath, FALSE, &dwErr);
            }

            //It's not local so continue contructing the path
            wcsncat(chSystemPath, L"\\", MAX_PATH - wcslen(chSystemPath) - 1);

            //The path should be valid by this point, but we might 
            //as well verify that for ourselves
            if ((wcslen(chPath) >= 4) && 
                (IsCharAlpha(chPath[0])) &&
                (chPath[1] == L':') &&
                (chPath[2] == L'\\') &&
                (IsCharAlpha(chPath[3])))
            {
                size_t nCurrentLength = wcslen(chSystemPath);
                if (nCurrentLength < (MAX_PATH - 2))
                {
                    chSystemPath[nCurrentLength] = chPath[0];
                    chSystemPath[nCurrentLength + 1] = L'\0';

                    wcsncat(chSystemPath, L"$", MAX_PATH - wcslen(chSystemPath) - 1);
                    wcsncat(chSystemPath, chPath + 2, MAX_PATH - wcslen(chSystemPath) - 1);
                }

                //Now that the system path is constructed, let's create the folder
                return SUCCEEDED(CreateRemoteFolder(chSystemPath));
            }
        }
    }

    return FALSE;
}

//-------------------------------------------------------------------------------
// IsLocalPathValid
//-------------------------------------------------------------------------------
BOOL CProfileDlg::IsLocalPathValid( HWND hDlg )
{
    LPVOID tchBuf = NULL;

    TCHAR tchErr[ MAX_PATH ] = { 0 };

    TCHAR tchErrTitle[ 80 ]= { 0 };

    TCHAR tchPath[ MAX_PATH ]= { 0 };

    INT_PTR dw = ( INT_PTR )&tchPath[0];

    if( SendMessage( GetDlgItem( hDlg , IDC_EDIT_LOCALPATH ) , WM_GETTEXT , sizeof( tchPath ) / sizeof( TCHAR ) , ( LPARAM )&tchPath[ 0 ] ) > 0 )
    {
        ExpandUserName( tchPath );

        SetWindowText( GetDlgItem( hDlg , IDC_EDIT_LOCALPATH ) , tchPath );

        if( !IsPathValid( tchPath , FALSE ) )
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_PATH , tchErr , sizeof( tchErr ) / sizeof( TCHAR ) );

            LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_TITLE , tchErrTitle , sizeof( tchErrTitle ) / sizeof( TCHAR ) );

            FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                            tchErr , 0 , 0 , (WCHAR*)&tchBuf , sizeof( tchErr ) / sizeof( TCHAR ) , ( va_list * )&dw );

            if (tchBuf)
            {
                MessageBox(hDlg, (WCHAR*)tchBuf, tchErrTitle, MB_OK | MB_ICONERROR);
                LocalFree(tchBuf);
            }
            else
                MessageBox(hDlg, tchErr, tchErrTitle, MB_OK | MB_ICONERROR);

            return FALSE;
        }
    }

    return TRUE;
}


//-------------------------------------------------------------------------------
// SetWTSLocalPath - copies the contents over - IsPathValid would have return
// true inorder for us to get here!
//-------------------------------------------------------------------------------
BOOL CProfileDlg::SetWTSLocalPath( HWND hDlg , USERCONFIG& uc )
{
    SendMessage( GetDlgItem( hDlg , IDC_EDIT_LOCALPATH ) , WM_GETTEXT , sizeof( uc.WFHomeDir ) / sizeof( TCHAR ) , ( LPARAM )&uc.WFHomeDir[ 0 ] );

    if (!m_pUSht->GetDSAType())
    {
        //We won't return the result from this because,
        //even if the path isn't created, the setting
        //may still be persisted and the admin can add
        //the directory after the fact
        CreateSystemPath(uc.WFHomeDir);
    }

    return TRUE;
}

//-------------------------------------------------------------------------------
// IsRemotePathValid - verifies UNC is correct
//-------------------------------------------------------------------------------
BOOL CProfileDlg::IsRemotePathValid( HWND hDlg )
{
    TCHAR tchErr1[ 768 ] = { 0 };

    TCHAR tchError[ 768 ] = { 0 };

    TCHAR tchHomeDir[ MAX_PATH ] = { 0 };

    if( GetWindowText( GetDlgItem( hDlg , IDC_EDIT_REMOTEPATH ) , tchHomeDir , sizeof( tchHomeDir ) / sizeof( TCHAR ) ) > 0 )
    {
        ExpandUserName( tchHomeDir );

        SetWindowText( GetDlgItem( hDlg , IDC_EDIT_REMOTEPATH ) , tchHomeDir );

        if( !IsPathValid( tchHomeDir , TRUE ) )
        {
            if( LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_REMOTEPATH , tchErr1 , sizeof( tchErr1 ) / sizeof( TCHAR ) ) > 0 )
            {
                INT_PTR dw = ( INT_PTR )&tchHomeDir[ 0 ];

                FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, tchErr1 , 0 , 0 , tchError , sizeof( tchError ) / sizeof( TCHAR ) , ( va_list * )&dw );

                LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_TITLE , tchErr1 , sizeof( tchErr1 ) / sizeof( TCHAR ) );

                MessageBox( hDlg , tchError , tchErr1 , MB_OK | MB_ICONERROR );
            }

            return FALSE;
        }
    }
    else
    {
        LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_NETPATH , tchError , sizeof( tchError ) / sizeof( TCHAR ) );

        LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_TITLE , tchErr1 , sizeof( tchErr1 ) / sizeof( TCHAR ) );

        MessageBox( hDlg , tchError , tchErr1 , MB_OK | MB_ICONERROR );

        return FALSE;
    }

    return TRUE;
}

//-------------------------------------------------------------------------------
// SetWTSRemotePath - IsRemotePathValid must return TRUE in order to get here
//-------------------------------------------------------------------------------
BOOL CProfileDlg::SetWTSRemotePath( HWND hDlg , USERCONFIG& uc )
{
    TCHAR tchErr1[ 768 ] = { 0 };

    TCHAR tchError[ 768 ] = { 0 };

    GetWindowText( GetDlgItem( hDlg , IDC_EDIT_REMOTEPATH ) , uc.WFHomeDir , sizeof( uc.WFHomeDir ) / sizeof( TCHAR ) );

    if( GetWindowText( GetDlgItem( hDlg , IDC_COMBO_DRIVES ) ,  uc.WFHomeDirDrive , sizeof( uc.WFHomeDirDrive ) / sizeof( TCHAR ) ) == 0 )
    {
        SendMessage( GetDlgItem( hDlg , IDC_COMBO_DRIVES ) , CB_GETLBTEXT , 0 , ( LPARAM )&uc.WFHomeDirDrive );
    }

    DWORD dwErr = 0;

    if( !createdir( uc.WFHomeDir , TRUE , &dwErr ) )
	{
		if( dwErr != 0 )
		{

			UINT rId;

			switch( dwErr )
			{
			case ERROR_ALREADY_EXISTS:
			case ERROR_LOGON_FAILURE:
			case ERROR_PATH_NOT_FOUND:
				{
					rId = ( ERROR_ALREADY_EXISTS == dwErr) ?
							IDS_HOME_DIR_EXISTS :
							( ERROR_PATH_NOT_FOUND == dwErr ) ?
							IDS_HOME_DIR_CREATE_FAILED :
							IDS_HOME_DIR_CREATE_NO_ACCESS;

					LoadString( _Module.GetResourceInstance( ) , rId , tchErr1 , sizeof( tchErr1 ) / sizeof( TCHAR ) );
					
					wsprintf( tchError , tchErr1 , uc.WFHomeDir );

					LoadString( _Module.GetResourceInstance( ) , IDS_ERROR_TITLE , tchErr1 , sizeof( tchErr1 ) / sizeof( TCHAR ) );

					MessageBox( hDlg , tchError , tchErr1 , MB_OK | MB_ICONERROR );
				}
				break;

			default:
				xxErrorMessage( hDlg , dwErr , IDS_ERR_CREATE_DIR );				
			}

		}
	}

    // uc.fHomeDirectoryMapRoot = TRUE;

    return TRUE;
}


//-------------------------------------------------------------------------------
// This is cool - I_NetPathType really does a lot of work for us
//-------------------------------------------------------------------------------
BOOL CProfileDlg::IsPathValid( LPTSTR pszPath , BOOL bUnc )
{
    DWORD dwRetflags;

    if( I_NetPathType( NULL, pszPath, &dwRetflags, 0) != NERR_Success )
        return FALSE;

    if( !bUnc )
        return ((dwRetflags == ITYPE_PATH_ABSD) ? TRUE : FALSE);

    return ((dwRetflags == ITYPE_UNC) ? TRUE : FALSE);

}

//-------------------------------------------------------------------------------
// If the string contains %username% expand it to the current user.
//-------------------------------------------------------------------------------
void CProfileDlg::ExpandUserName( LPTSTR szPath )
{
    TCHAR tchSubPath[ MAX_PATH];
    TCHAR szUserName[ 40 ];

    if( szPath == NULL )
    {
        return;
    }

    // remove any leading or trailing spaces

    TCHAR tchTrim[] = TEXT( " " );

    StrTrim( szPath , tchTrim );

    int nSz = LoadString( _Module.GetResourceInstance( ) , IDS_USERNAME , szUserName , sizeof( szUserName ) / sizeof( TCHAR ) );

    //CharLowerBuff( szPath , lstrlen( szPath ) );

    // Find %username%

    LPTSTR pFound = StrStrI( szPath , szUserName ); //_tcsstr( szPath , szUserName );

    if( pFound != NULL )
    {
        INT_PTR nPos = ( INT_PTR )( pFound - szPath );

        lstrcpy( tchSubPath , ( szPath + nPos + nSz ) );

        szPath[ nPos ] = 0;

        lstrcat( szPath , m_pUSht->GetUserName() );

        lstrcat( szPath , tchSubPath );
    }

}

//-------------------------------------------------------------------------------
// Removing decimal entries
//-------------------------------------------------------------------------------
LRESULT CTimeOutDlg::ParseDurationEntry( LPTSTR pszTime , PULONG pTime )
{
    TCHAR tchNoTimeout[ 80 ];

    LPTSTR pszTemp = pszTime;

    UINT uDec = 0;

    BOOL bSetDay  = FALSE;
    BOOL bSetHour = FALSE;
    BOOL bSetMin  = FALSE;
    BOOL bEOL     = FALSE;
    BOOL bHasDigit= FALSE;

    *pTime = 0;

    LoadString( _Module.GetResourceInstance( ) , IDS_NOTIMEOUT , tchNoTimeout , sizeof( tchNoTimeout ) / sizeof( TCHAR ) );

    if( lstrcmpi( pszTime , tchNoTimeout ) == 0 )
    {
        // *pTime = 0;

        return E_SUCCESS;
    }

    while( !bEOL )
    {
        // remove leading white spaces

        while( *pszTemp == L' ' )
        {
            pszTemp++;
        }

        while( *pszTemp )
        {
            if( !iswdigit( *pszTemp ) )
            {
                if( !bHasDigit )
                {
                    return E_PARSE_MISSING_DIGITS;
                }

                break;
            }

            // check for overflow

            if( uDec >= 1000000000 )
            {
                return E_PARSE_VALUEOVERFLOW ;
            }

            uDec *= 10;

            uDec += ( *pszTemp - '0' );

            if( !bHasDigit )
            {
                bHasDigit = TRUE;
            }

            pszTemp++;
        }

        // remove intermediate white spaces

        while( *pszTemp == L' ' )
        {
            pszTemp++;
        }

        if( *pszTemp != NULL )
        {
            // Get next token

            TCHAR tchToken[ 80 ];

            pszTemp = GetNextToken( pszTemp , tchToken );


            if( IsToken( tchToken , TOKEN_DAY ) )
            {
                if( !bSetDay )
                {
                    *pTime += uDec * 1440;

                    bSetDay = TRUE;
                }

            }
            else if( IsToken( tchToken , TOKEN_HOUR ) )
            {
                if( !bSetHour )
                {
                    *pTime += uDec * 60;

                    bSetHour = TRUE;
                }

            }
            else if( IsToken( tchToken , TOKEN_MINUTE ) )
            {
                if( !bSetMin )
                {
                    *pTime += uDec;

                    bSetMin = TRUE;
                }

            }
            else
            {
                return E_PARSE_INVALID;
            }

        }
        else
        {
            if( !bSetHour )
            {
                *pTime += uDec * 60;
            }

            bEOL = TRUE;
        }

        uDec = 0;

        bHasDigit = FALSE;

    }

    return E_SUCCESS;
}

//-------------------------------------------------------------------------------
// replacing older api
//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::ConvertToDuration( ULONG ulTime , LPTSTR pszDuration )
{
//    TCHAR dw[] = L"dhm";

    TCHAR tchTimeUnit[ 40 ];

    TCHAR tchTimeFormat[ 40 ];

    TCHAR tchOutput[ 80 ];

    ASSERT_( ulTime != 0 );

    int iHour = ( ulTime / 60 );

    int iDays = iHour / 24;

    int iMinute = ulTime % 60;

    // Resolve format

    tchOutput[0] = 0;


    if( iDays > 0 )
    {
        if( iDays == 1 )
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_DAY , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }
        else
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_DAYS , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }

        iHour = iHour % 24;

        wsprintf( tchTimeFormat , L"%d %s", iDays , tchTimeUnit );

        lstrcat( tchOutput , tchTimeFormat );

        lstrcat( tchOutput , L" " );
    }

    if( iHour > 0 )
    {
        if( iHour == 1 )
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_HOUR , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }
        else
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_HOURS , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }

        wsprintf( tchTimeFormat , L"%d %s", iHour , tchTimeUnit );

        lstrcat( tchOutput , tchTimeFormat );

        lstrcat( tchOutput , L" " );
    }

    if( iMinute > 0 )
    {
        if( iMinute == 1 )
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_MINUTE , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }
        else
        {
            LoadString( _Module.GetResourceInstance( ) , IDS_MINUTES , tchTimeUnit , sizeof( tchTimeUnit ) / sizeof( TCHAR ) );
        }

        wsprintf( tchTimeFormat , L"%d %s", iMinute , tchTimeUnit );

        lstrcat( tchOutput , tchTimeFormat );

        lstrcat( tchOutput , L" " );
    }

    lstrcpy( pszDuration , tchOutput );

    return TRUE;

}

//-------------------------------------------------------------------------------
BOOL CTimeOutDlg::DoesContainDigits( LPTSTR pszString )
{
    while( *pszString )
    {
        if( *pszString != L' ')
        {
            if( iswdigit( *pszString ) )
            {
                return TRUE;
            }
            else
            {
                return FALSE;
            }

            pszString++;
        }
    }

    return FALSE;
}

//-------------------------------------------------------------------------------
TCHAR * GetNextToken( TCHAR *pszString , TCHAR *tchToken )
{
    while( *pszString )
    {
        if( IsCharAlpha( *pszString ) )
        {
            *tchToken = *pszString;
        }
        else
        {
            break;
        }

        tchToken++;

        pszString++;
    }

    *tchToken = '\0';

    return pszString;
}

//-------------------------------------------------------------------------------
void ErrorMessage1( HWND hParent , DWORD dwStatus )
{
    xxErrorMessage( hParent , dwStatus , IDS_TSGETPROPSFAILED );
}

//-------------------------------------------------------------------------------
void ErrorMessage2( HWND hParent , DWORD dwStatus )
{
    xxErrorMessage( hParent , dwStatus , IDS_TSOPSFAILED );
}

//-------------------------------------------------------------------------------
void xxErrorMessage( HWND hParent , DWORD dwStatus , UINT nResID )
{
    LPTSTR pBuffer = NULL;

    TCHAR tchBuffer[ 256 ];

    TCHAR tchErr[ 128 ];

    TCHAR tchTitle[ 80 ];

    LoadString( _Module.GetModuleInstance( ) , nResID , tchErr , sizeof( tchErr ) / sizeof( TCHAR ) );

    LoadString( _Module.GetModuleInstance( ) , IDS_TSGETPROPTITLE , tchTitle , sizeof( tchTitle ) / sizeof( TCHAR ) );

    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                 FORMAT_MESSAGE_FROM_SYSTEM,
                 NULL,                                          //ignored
                 dwStatus    ,                                //message ID
                 MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ), //message language
                 (LPTSTR)&pBuffer,                              //address of buffer pointer
                 0,                                             //minimum buffer size
                 NULL);                                         //no other arguments

    wsprintf( tchBuffer , tchErr , pBuffer );

    ::MessageBox( hParent , tchBuffer , tchTitle , MB_OK | MB_ICONERROR );

    if( pBuffer != NULL )
    {
        LocalFree( pBuffer );
    }

}




#if 0
//-------------------------------------------------------------------------------
NTSTATUS GetDomainName( PWCHAR ServerNamePtr, // name of server to get domain of
                        LPTSTR DomainNamePtr // alloc and set ptr (free with NetApiBufferFree)
                       )

/*++

Routine Description:

    Returns the name of the domain or workgroup this machine belongs to.

Arguments:

    DomainNamePtr - The name of the domain or workgroup

    IsWorkgroupName - Returns TRUE if the name is a workgroup name.
        Returns FALSE if the name is a domain name.

Return Value:

   NERR_Success - Success.
   NERR_CfgCompNotFound - There was an error determining the domain name

--*/
{
    NTSTATUS status;
    LSA_HANDLE PolicyHandle;
    PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
    OBJECT_ATTRIBUTES ObjAttributes;
    UNICODE_STRING UniServerName;


    //
    // Check for caller's errors.
    //
    if ( DomainNamePtr == NULL ) {
        return STATUS_INVALID_PARAMETER;
    }

    //
    // Open a handle to the local security policy.  Initialize the
    // objects attributes structure first.
    //
    InitializeObjectAttributes(
        &ObjAttributes,
        NULL,
        0L,
        NULL,
        NULL
        );

    RtlInitUnicodeString( &UniServerName, ServerNamePtr );
    status = LsaOpenPolicy(
                   &UniServerName,
                   &ObjAttributes,
                   POLICY_VIEW_LOCAL_INFORMATION,
                   &PolicyHandle
                   );


    KdPrint( ( "TSUSEREX - GetDomainName: LsaOpenPolicy returned NTSTATUS = 0x%x\n", status ) );



    if (! NT_SUCCESS(status)) {
        return( status );
    }

    //
    // Get the name of the primary domain from LSA
    //
    status = LsaQueryInformationPolicy(
                   PolicyHandle,
                   PolicyAccountDomainInformation,
                   (PVOID *)&DomainInfo
                   );


    KdPrint( ( "TSUSEREX - GetDomainName: LsaQueryInformationPolicy returned NTSTATUS = 0x%x\n", status ) );



    if (! NT_SUCCESS(status)) {
        (void) LsaClose(PolicyHandle);
        return( status );
    }

    (void) LsaClose(PolicyHandle);

    lstrcpy( DomainNamePtr , DomainInfo->DomainName.Buffer );

    (void) LsaFreeMemory((PVOID) DomainInfo);

    return( STATUS_SUCCESS );
}
#endif


BOOL CProfileDlg::createdir( LPTSTR szPath , BOOL bIsRemote , PDWORD pdwErr )
{
    int npos = 0;

    *pdwErr = ERROR_INVALID_NAME;

    if( bIsRemote )
    {
        // skip over three four whacks		

        npos = 2;

        if( szPath[0] != TEXT( '\\' ) && szPath[1] != TEXT( '\\' ) )
        {
            return FALSE;
        }

        for( int n = 0; n < 2 ; n++ )
        {
            while( szPath[ npos ] != TEXT( '\\' ) && szPath[ npos ] != TEXT( '\0' ) )
            {
                npos++;
            }

            if( szPath[ npos ] == TEXT( '\0' ) )
            {
                return FALSE;
            }

            npos++;
        }

    }
    else
    {
        if( szPath[1] != TEXT( ':' ) && szPath[2] != TEXT( '\\' ) )
        {
            return FALSE;
        }

        npos = 3;
    }

    SECURITY_ATTRIBUTES securityAttributes;

    ZeroMemory( &securityAttributes , sizeof( SECURITY_ATTRIBUTES ) );

    // its redundant to check the bIsRemote flag since for dsadmin createdir is only called for
    // UNC paths

    if( m_pUSht->GetDSAType() && bIsRemote )
    {
        //
        // From EricB's DSPROP_CreateHomeDirectory
        PSID psidAdmins = NULL;

        SID_IDENTIFIER_AUTHORITY NtAuth = SECURITY_NT_AUTHORITY;

        if (!AllocateAndInitializeSid(&NtAuth,
                                      2,
                                      SECURITY_BUILTIN_DOMAIN_RID,
                                      DOMAIN_ALIAS_RID_ADMINS,
                                      0, 0, 0, 0, 0, 0,
                                      &psidAdmins  ) )
        {
            ODS( L"AllocateAndInitializeSid failed\n");
            *pdwErr = GetLastError( );
            return FALSE;
        }
        // build a DACL

        PACL pDacl;

        static const int nAceCount = 2;
        PSID pAceSid[nAceCount];

        pAceSid[0] = m_pUSht->GetUserSid( );
        pAceSid[1] = psidAdmins;

        EXPLICIT_ACCESS rgAccessEntry[nAceCount] = {0};

        for (int i = 0 ; i < nAceCount; i++)
        {
            rgAccessEntry[i].grfAccessPermissions = GENERIC_ALL;
            rgAccessEntry[i].grfAccessMode = GRANT_ACCESS;
            rgAccessEntry[i].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;

            // build the trustee structs
            //
            BuildTrusteeWithSid(&(rgAccessEntry[i].Trustee),
                                pAceSid[i]);
        }

        // add the entries to the ACL
        //
        *pdwErr = SetEntriesInAcl( nAceCount, rgAccessEntry, NULL, &pDacl );

        if( *pdwErr != 0 )
        {
	        ODS( L"SetEntriesInAcl() failed\n" );

	        return FALSE;
        }

        // build a security descriptor and initialize it
        // in absolute format

        SECURITY_DESCRIPTOR securityDescriptor;
        PSECURITY_DESCRIPTOR pSecurityDescriptor = &securityDescriptor;

        if( !InitializeSecurityDescriptor( pSecurityDescriptor , SECURITY_DESCRIPTOR_REVISION ) )
        {
            ODS( L"InitializeSecurityDescriptor() failed\n" );

            *pdwErr = GetLastError( );

            return FALSE;
        }

        // add DACL to security descriptor (must be in absolute format)

        if( !SetSecurityDescriptorDacl( pSecurityDescriptor,
                                        TRUE, // bDaclPresent
                                        pDacl,
                                        FALSE // bDaclDefaulted
                                        ) )
        {

            ODS( L"SetSecurityDescriptorDacl() failed\n" );

            *pdwErr = GetLastError( );

            return FALSE;
        }


        // set the owner of the directory
        if( !SetSecurityDescriptorOwner( pSecurityDescriptor ,
                                         m_pUSht->GetUserSid( ) ,
                                         FALSE // bOwnerDefaulted
                                         ) )
        {

            ODS( L"SetSecurityDescriptorOwner() failed\n" );

            *pdwErr = GetLastError( );

            return FALSE;
        }

        ASSERT_( IsValidSecurityDescriptor( pSecurityDescriptor ) );

        // build a SECURITY_ATTRIBUTES struct as argument for
        // CreateDirectory()

        securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);

        securityAttributes.lpSecurityDescriptor = pSecurityDescriptor;

        securityAttributes.bInheritHandle = FALSE;

        if( !CreateDirectory( szPath , &securityAttributes ) )
        {
            *pdwErr = GetLastError( );

            if( psidAdmins != NULL )
            {
                FreeSid( psidAdmins );
            }

            return FALSE;
        }	

        FreeSid( psidAdmins );
    }
	else
    {	
        while( szPath[ npos ] != TEXT( '\0' ) )
        {
            while( szPath[ npos ] != TEXT( '\\' ) && szPath[ npos ] != TEXT( '\0' ) )
            {
                npos++;
            }

            if( szPath[ npos ] == TEXT( '\0' ) )
            {
                if (!CreateSecureDir(szPath , pdwErr))
                {
                    ODS(L"CreateSecureDir failed\n");
                    return FALSE;
                }
            }
            else
            {
                szPath[ npos ] = 0;

                if (!CreateSecureDir(szPath , pdwErr))
                {
                    ODS(L"CreateSecureDir failed\n");
                    return FALSE;
                }

                szPath[ npos ] = TEXT( '\\' );

                npos++;
            }
        }
    }

    *pdwErr = 0;

    return TRUE;
}

DWORD
GetUserSid(LPCTSTR pwszAccountName, 
           LPCTSTR pwszServerName, 
           PSID* ppUserSid)
{
    DWORD        cbSid     = 0;
    DWORD        cbDomain  = 0;
    PSID         pSID      = NULL;
    LPTSTR       pszDomain = NULL;
    BOOL         bStatus;
    DWORD        dwStatus  = ERROR_SUCCESS;    
    SID_NAME_USE seUse;   

    bStatus = LookupAccountName(pwszServerName,
                                pwszAccountName,
                                NULL,
                                &cbSid,
                                NULL,
                                &cbDomain,
                                &seUse);
    if(!bStatus)
    {
        dwStatus = GetLastError();
        if(dwStatus != ERROR_INSUFFICIENT_BUFFER)
        {
            goto Cleanup;
        }
    }

    dwStatus = ERROR_SUCCESS;

    pSID = (PSID)LocalAlloc(LMEM_FIXED, cbSid );
    pszDomain = (LPTSTR)LocalAlloc(LMEM_FIXED, sizeof(TCHAR) * (cbDomain + 1));

    if(pSID == NULL || pszDomain == NULL)
    {
        dwStatus = GetLastError();
        goto Cleanup;
    }

    bStatus = LookupAccountName(pwszServerName,
                                pwszAccountName,
                                pSID,
                                &cbSid,
                                pszDomain,
                                &cbDomain,
                                &seUse);

    if(!bStatus)
    {
        dwStatus = GetLastError();
        goto Cleanup;
    }

    *ppUserSid = pSID;
    pSID = NULL;


Cleanup:
    if(pszDomain != NULL)
    {
        LocalFree(pszDomain);
    }

    if(pSID != NULL)
    {
        LocalFree(pSID);
    }

    return dwStatus;
} 


BOOL 
CProfileDlg::CreateSecureDir(LPTSTR szPath ,  PDWORD pdwErr)
{
    BOOL                     bRetVal    = TRUE;
    static const int         nAceCount  = 2;
    PACL                     pDacl      = NULL;
    PSID                     psidAdmins = NULL;
    PSID                     psidUser   = NULL;
    PSECURITY_DESCRIPTOR     pSD        = NULL;
    SID_IDENTIFIER_AUTHORITY NtAuth     = SECURITY_NT_AUTHORITY;
    EXPLICIT_ACCESS          rgAccessEntry[nAceCount] = {0};
    SECURITY_ATTRIBUTES      securityAttributes;
    DWORD                    dwStatus;
    LPWSTR                   pszServer  = NULL;

    
    _ASSERT(szPath);   


    // Make sure a valid string is passed in
    if (szPath == NULL)
    {
        ODS( L"Path not valid.\n");
        return FALSE;
    }

    // Create a SID for the BUILTIN Administrators group.
    if (!AllocateAndInitializeSid(&NtAuth,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &psidAdmins))
    {		
        ODS( L"AllocateAndInitializeSid failed\n");
        goto Error;
    }

    // Initialize an EXPLICIT_ACCESS structure for an ACE.
    // The ACE will allow the Administrators group full access to the key.
    rgAccessEntry[0].grfAccessPermissions = GENERIC_ALL;
    rgAccessEntry[0].grfAccessMode = GRANT_ACCESS;
    rgAccessEntry[0].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;

    // build the trustee structs  
    BuildTrusteeWithSid(&(rgAccessEntry[0].Trustee), psidAdmins);

    // Get the SID for the user
    m_pUSht->GetServer(&pszServer);
    if (pszServer == NULL)
    {
        ODS(L"GetServer() failed\n");
        bRetVal = FALSE;
        goto Cleanup;
    }

    dwStatus = GetUserSid(m_pUSht->GetUserName(), pszServer, &psidUser);
    if (dwStatus != ERROR_SUCCESS)
    {
        ODS(L"GetUserSid() failed\n");
        bRetVal = FALSE;
        goto Cleanup;
    }

    // Specify the access control for the selected User, (full access)
    rgAccessEntry[1].grfAccessPermissions = GENERIC_ALL;
    rgAccessEntry[1].grfAccessMode = GRANT_ACCESS;
    rgAccessEntry[1].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
    rgAccessEntry[1].Trustee.TrusteeForm = TRUSTEE_IS_SID;
    rgAccessEntry[1].Trustee.TrusteeType = TRUSTEE_IS_USER;  
    rgAccessEntry[1].Trustee.ptstrName = (LPWSTR)psidUser;
        
    // Create a new ACL that contains the new ACEs.
    *pdwErr = SetEntriesInAcl(nAceCount, rgAccessEntry, NULL, &pDacl);
    if(*pdwErr != 0)
    {   
        ODS(L"SetEntriesInAcl() failed\n");
        bRetVal = FALSE;
        goto Cleanup;
    }

    // Initialize a security descriptor.
    pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, 
                                            SECURITY_DESCRIPTOR_MIN_LENGTH); 
    if (pSD == NULL) 
    { 
        ODS( L"LocalAlloc Error\n" );
        goto Error;
    } 
     
    if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)) {  
        ODS( L"InitializeSecurityDescriptor() failed\n" );
        goto Error;
    } 

    // Add the ACL to the security descriptor
    if(!SetSecurityDescriptorDacl(pSD,
                                  TRUE,   // bDaclPresent
                                  pDacl,
                                  FALSE)) // bDaclDefaulted
    {		
        ODS( L"SetSecurityDescriptorDacl() failed\n" );
        goto Error;
    }

    // Initialize a security attributes structure.
    ZeroMemory(&securityAttributes , sizeof(SECURITY_ATTRIBUTES));

    securityAttributes.nLength              = sizeof(pSD);
    securityAttributes.lpSecurityDescriptor = pSD;
    securityAttributes.bInheritHandle       = FALSE;

    if(!CreateDirectory(szPath, &securityAttributes))
    {
        *pdwErr = GetLastError();

        // If the directory already exists it's ok
        if (*pdwErr != ERROR_ALREADY_EXISTS)
        {
            ODS(L"CreateDirectory failed\n");
            ODS(szPath);
            goto Error;
        }
    }	

    *pdwErr = 0;


Cleanup:
    if (pDacl != NULL)
        LocalFree(pDacl);

    if (pSD != NULL)
        LocalFree(pSD); 
    
    if (psidAdmins != NULL)
        FreeSid(psidAdmins);

    if (pszServer != NULL)
        delete[] pszServer;

    if (psidUser != NULL)
        LocalFree(psidUser);

    return bRetVal;

Error:
    *pdwErr = GetLastError();
    bRetVal = FALSE;
    goto Cleanup;
}