windows-server-2003/termsrv/newclient/util/autil.cpp

/****************************************************************************/
// autil.c
//
// RDP client utilities
//
// Copyright(C) Microsoft Corporation 1997-1999
/****************************************************************************/

#include <adcg.h>
/****************************************************************************/
/* Define TRC_FILE and TRC_GROUP.                                           */
/****************************************************************************/
extern "C" {
#ifndef OS_WINCE
#include <hydrix.h>
#endif

#ifndef OS_WINCE
#include <process.h>
#endif
}

#define TRC_FILE    "autil"
#define TRC_GROUP   TRC_GROUP_UTILITIES
#include <atrcapi.h>

#include "autil.h"

#ifdef OS_WINCE
#include "cryptkey.h"

#ifndef MAX_COMPUTERNAME_LENGTH
#define MAX_COMPUTERNAME_LENGTH 15
#endif
#define HWID_COMPUTER_NAME_STR_LEN ((MAX_COMPUTERNAME_LENGTH + 1)*sizeof(WCHAR)) // 15 hex characters + one NULL
#define REG_WBT_RDP_COMPUTER_NAME_KEY   _T("Software\\Microsoft\\WBT")
#define REG_WBT_RDP_COMPUTER_NAME_VALUE     _T("Client Name")   

#define BAD_HARDCODED_NAME1 "WBT"
#define BAD_HARDCODED_NAME2 "WinCE"

DCBOOL UT_GetWBTComputerName(PDCTCHAR szBuff, DCUINT32 len);
TCHAR MakeValidChar(BYTE data);

#endif

/****************************************************************************/
/*                                                                          */
/* External DLL                                                             */
/*                                                                          *
/****************************************************************************/
#ifndef OS_WINCE
#ifdef UNICODE
#define T  "W"
#else
#define T  "A"
#endif
#else //OS_WINCE
#define T  _T("W")
#endif //OS_WINCE
#ifndef OS_WINCE
#define MAKE_API_NAME(nm)    CHAR  c_sz##nm[] = #nm
#else
#define MAKE_API_NAME(nm)    TCHAR  c_sz##nm[] = CE_WIDETEXT(#nm)
#endif //OS_WINCE

/****************************************************************************/
/* IMM32 DLL                                                                */
/****************************************************************************/
MAKE_API_NAME(ImmAssociateContext);
MAKE_API_NAME(ImmGetIMEFileNameW);
MAKE_API_NAME(ImmGetIMEFileNameA);

/****************************************************************************/
/* WINNLS DLL                                                               */
/****************************************************************************/
MAKE_API_NAME(WINNLSEnableIME);
#ifdef OS_WIN32
MAKE_API_NAME(IMPGetIMEW);
MAKE_API_NAME(IMPGetIMEA);
#else
MAKE_API_NAME(IMPGetIME);
#endif

/****************************************************************************/
/* F3AHVOAS DLL                                                             */
/****************************************************************************/
MAKE_API_NAME(FujitsuOyayubiControl);


CUT::CUT()
{
    #ifdef DC_DEBUG
    _UT.dwDebugThreadWaitTimeout = INFINITE;
    #endif
}

CUT::~CUT()
{
}


//
// API members
//

/****************************************************************************/
/* Name:      UT_Init                                                       */
/*                                                                          */
/* Purpose:   Initialize UT                                                 */
/*                                                                          */
/* Returns:   None                                                          */
/*                                                                          */
/* Params:    None                                                          */
/*                                                                          */
/****************************************************************************/
DCVOID DCAPI CUT::UT_Init(DCVOID)
{
#ifdef DC_DEBUG
    DCUINT seed;
#endif

    DC_BEGIN_FN("UT_Init");
    DC_MEMSET(&_UT, 0, sizeof(_UT));

#ifdef DC_DEBUG
    _UT.dwDebugThreadWaitTimeout = INFINITE;
    //
    // On checked builds we look at a reg setting to determine
    // if we should wait with a smaller timeout to help catch deadlocks
    //
    if (!UTReadRegistryInt(
            UTREG_SECTION,
            UTREG_DEBUG_THREADTIMEOUT,
            (PDCINT)&_UT.dwDebugThreadWaitTimeout)) {
        _UT.dwDebugThreadWaitTimeout = INFINITE;
    }
#endif    


#if defined(OS_WIN32)
    /********************************************************************/
    /*                                                                  */
    /* IMM32 DLL                                                        */
    /*                                                                  */
    /********************************************************************/

    _UT.Imm32Dll.func.rgFunctionPort[0].pszFunctionName = c_szImmAssociateContext;
    _UT.Imm32Dll.func.rgFunctionPort[1].pszFunctionName = c_szImmGetIMEFileNameW;
#ifndef OS_WINCE
    _UT.Imm32Dll.func.rgFunctionPort[2].pszFunctionName = c_szImmGetIMEFileNameA;
#endif
#endif // OS_WIN32

#if !defined(OS_WINCE)
    /********************************************************************/
    /*                                                                  */
    /* WINNLS DLL                                                       */
    /*                                                                  */
    /********************************************************************/

    _UT.WinnlsDll.func.rgFunctionPort[0].pszFunctionName = c_szWINNLSEnableIME;
    _UT.WinnlsDll.func.rgFunctionPort[1].pszFunctionName = c_szIMPGetIMEW;
    _UT.WinnlsDll.func.rgFunctionPort[2].pszFunctionName = c_szIMPGetIMEA;
#endif  // !defined(OS_WINCE)

#if defined(OS_WINNT)
    /********************************************************************/
    /*                                                                  */
    /* F3AHVOAS DLL                                                     */
    /*                                                                  */
    /********************************************************************/

    _UT.F3AHVOasysDll.func.rgFunctionPort[0].pszFunctionName = c_szFujitsuOyayubiControl;
#endif // OS_WINNT

#ifdef DC_DEBUG
    seed = (DCUINT)UT_GetCurrentTimeMS();
    srand(seed);

    TRC_NRM((TB, _T("Random seed : %d"), seed));
    UT_SetRandomFailureItem(UT_FAILURE_MALLOC, 0);
    UT_SetRandomFailureItem(UT_FAILURE_MALLOC_HUGE, 0);
#endif /* DC_DEBUG */

    /************************************************************************/
    /* Set the OS version                                                   */
    /************************************************************************/
	OSVERSIONINFO   osVersionInfo;
	DCBOOL			bRc;
    osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
    bRc = GetVersionEx(&osVersionInfo);

    TRC_ASSERT((bRc), (TB,_T("GetVersionEx failed")));
#ifdef OS_WINCE
    TRC_ASSERT((osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_CE),
               (TB,_T("Unknown os version %d"), osVersionInfo.dwPlatformId));
#else
    TRC_ASSERT(((osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ||
                (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)),
                (TB,_T("Unknown os version %d"), osVersionInfo.dwPlatformId));
#endif

    _UT.osMinorType =
                  (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ?
                        TS_OSMINORTYPE_WINDOWS_95 : TS_OSMINORTYPE_WINDOWS_NT;


    DC_END_FN();

    return;

} /* UT_Init */


/****************************************************************************/
/* Name:      UT_Term                                                       */
/*                                                                          */
/* Purpose:   Terminate UT                                                  */
/****************************************************************************/
DCVOID DCAPI CUT::UT_Term(DCVOID)
{
    DC_BEGIN_FN("UT_Term");
    DC_END_FN();
} /* UT_Term */


/****************************************************************************/
/* Name:      UT_MallocReal                                                 */
/*                                                                          */
/* Purpose:   Attempts to dynamically allocate memory of a size which is    */
/*            specified using a DCUINT, ie for Win16 this allocates up to   */
/*            one 64K segement.                                             */
/*                                                                          */
/* Returns:   pointer to allocated memory, or NULL if the function fails.   */
/*                                                                          */
/* Params:    length - length in bytes of the memory to allocate.           */
/*                                                                          */
/****************************************************************************/
PDCVOID DCAPI CUT::UT_MallocReal(DCUINT length)
{
    PDCVOID rc;

    DC_BEGIN_FN("UT_MallocReal");

#ifdef DC_DEBUG
    if (UT_TestRandomFailure(UT_FAILURE_MALLOC))
    {
        rc = NULL;
        TRC_NRM((TB, _T("Fake Malloc failure of %#x bytes"), length));
        DC_QUIT;
    }
#endif /* DC_DEBUG */

    rc = UTMalloc(length);

    if (rc == NULL)
    {
        TRC_ERR((TB, _T("Failed to allocate %#x bytes"), length));
    }
    else
    {
        TRC_NRM((TB, _T("Allocated %#x bytes at %p"), length, rc));
    }

DC_EXIT_POINT:
    DC_END_FN();
    return(rc);
}


/****************************************************************************/
/* Name:      UT_MallocHugeReal                                             */
/*                                                                          */
/* Purpose:   Attempts to dynamically allocate memory of a size which is    */
/*            specified using a DCUINT32, ie for Win16 this returns a HUGE  */
/*            pointer which can be used to address memory straddling more   */
/*            than one 64K segment. For Win32, this is identical to         */
/*            UT_Malloc.                                                    */
/*                                                                          */
/* Returns:   pointer to allocated memory, or NULL if the function fails.   */
/*                                                                          */
/* Params:    length - length in bytes of the memory to allocate.           */
/*                                                                          */
/****************************************************************************/
HPDCVOID DCAPI CUT::UT_MallocHugeReal(DCUINT32 length)
{
    HPDCVOID rc;

    DC_BEGIN_FN("UT_MallocHugeReal");

#ifdef DC_DEBUG
    if (UT_TestRandomFailure(UT_FAILURE_MALLOC_HUGE))
    {
        rc = NULL;
        TRC_NRM((TB, _T("Fake MallocHuge failure of %#lx bytes"), length));
        DC_QUIT;
    }
#endif /* DC_DEBUG */

    rc = UTMallocHuge(length);

    if (rc == NULL)
    {
        TRC_ERR((TB, _T("Failed to HUGE allocate %#lx bytes"), length));
    }
    else
    {
        TRC_NRM((TB, _T("Allocated %#lx bytes at %p"), length, rc));
    }

DC_EXIT_POINT:
    DC_END_FN();
    return(rc);
}


/****************************************************************************/
/* Name:      UT_FreeReal                                                   */
/*                                                                          */
/* Purpose:   Frees dynamically allocated memory obtained using UT_Malloc   */
/*                                                                          */
/* Params:    pMemory - pointer to memory to free                           */
/****************************************************************************/
DCVOID DCAPI CUT::UT_FreeReal(PDCVOID pMemory)
{
#ifndef OS_WINCE
    UINT32 size;
#endif

    DC_BEGIN_FN("UT_FreeReal");

#ifdef OS_WIN32
#ifndef OS_WINCE
    size = (UINT32)LocalSize(LocalHandle(pMemory));
#endif
#else
    size = GlobalSize((HGLOBAL)LOWORD(GlobalHandle(SELECTOROF(pMemory))));
#endif
#ifndef OS_WINCE
    TRC_NRM((TB, _T("Free %#lx bytes at %p"), size, pMemory));
#endif

    UTFree(pMemory);

    DC_END_FN();
}


/****************************************************************************/
/* Name:      UT_ReadRegistryString                                         */
/*                                                                          */
/* Purpose:   Read a string from the registry                               */
/*                                                                          */
/* Returns:   None                                                          */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      pEntry        - entry name                            */
/*            IN      pDefaultValue - default value                         */
/*            OUT     pBuffer       - output buffer                         */
/*            IN      bufferSize    - output buffer size                    */
/****************************************************************************/
DCVOID DCAPI CUT::UT_ReadRegistryString(PDCTCHAR pSection,
                                   PDCTCHAR pEntry,
                                   PDCTCHAR pDefaultValue,
                                   PDCTCHAR pBuffer,
                                   DCINT    bufferSize)
{
    DC_BEGIN_FN("UT_ReadRegistryString");

    /************************************************************************/
    /* Check for NULL parameters                                            */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));

    /************************************************************************/
    /* Allow NULL default (returns empty string).                           */
    /************************************************************************/
    TRC_ASSERT(!((pDefaultValue != NULL) &&
                 (((DCINT)DC_TSTRBYTELEN(pDefaultValue) > bufferSize))),
               (TB, _T("Default string NULL, or too long for entry %s"), pEntry));

    /************************************************************************/
    /* Read the registry entry                                              */
    /************************************************************************/
    if (!UTReadRegistryString(pSection, pEntry, pBuffer, bufferSize))
    {
        TRC_NRM((TB, _T("Failed to read registry entry [%s] %s"),
                                                           pSection, pEntry));

        if (pDefaultValue != NULL)
        {
            StringCchCopy(pBuffer, bufferSize, pDefaultValue);
        }
        else
        {
            pBuffer[0] = 0;
        }

        DC_QUIT;
    }

DC_EXIT_POINT:
    DC_END_FN();
} /* UT_ReadRegistryString */


//
// Caller must free return buffer ppBuffer
//
DCBOOL DCAPI CUT::UT_ReadRegistryExpandSZ(PDCTCHAR  pSection,
                                       PDCTCHAR   pEntry,
                                       PDCTCHAR*  ppBuffer,
                                       PDCINT     pBufferSize )
{
    DC_BEGIN_FN("UT_ReadRegistryExpandSZ");

    /************************************************************************/
    /* Check for NULL parameters                                            */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));
    TRC_ASSERT((ppBuffer != NULL), (TB,_T("NULL pBuffer")));
    TRC_ASSERT((pBufferSize != NULL), (TB,_T("NULL pBufferSize")));

    /************************************************************************/
    /* Read the registry entry                                              */
    /************************************************************************/
    if (!UTReadRegistryExpandString(pSection, pEntry, ppBuffer, pBufferSize))
    {
        TRC_NRM((TB, _T("Failed to read registry entry [%s] %s"),
                                                           pSection, pEntry));

        *ppBuffer = NULL;
        *pBufferSize = 0;

        return FALSE;
    }
    else
    {
        return TRUE;
    }

DC_EXIT_POINT:
    DC_END_FN();
}


/****************************************************************************/
/* Name:      UT_ReadRegistryInt                                            */
/*                                                                          */
/* Purpose:   Read an INT from the registry                                 */
/*                                                                          */
/* Returns:   Integer read from registry / default                          */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      pEntry        - entry name                            */
/*            IN      defaultValue  - default value                         */
/****************************************************************************/
DCINT DCAPI CUT::UT_ReadRegistryInt(PDCTCHAR pSection,
                               PDCTCHAR pEntry,
                               DCINT    defaultValue)
{
    DCINT rc;

    DC_BEGIN_FN("UT_ReadRegistryInt");

    /************************************************************************/
    /* Check for NULL parameters                                            */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));

    /************************************************************************/
    /* Read the registry entry.                                             */
    /************************************************************************/
    if (!UTReadRegistryInt(pSection, pEntry, &rc))
    {
        TRC_NRM((TB, _T("Failed to read registry entry [%s] %s"),
                                                           pSection, pEntry));
        rc = defaultValue;
    }

    DC_END_FN();
    return(rc);
} /* UT_ReadRegistryInt */


/****************************************************************************/
/* Name:      UT_ReadRegistryBinary                                         */
/*                                                                          */
/* Purpose:   Read binary data from the registry                            */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      pEntry        - entry name                            */
/*            OUT     pBuffer       - output buffer                         */
/*            IN      bufferSize    - output buffer size                    */
/****************************************************************************/
DCVOID DCAPI CUT::UT_ReadRegistryBinary(PDCTCHAR pSection,
                                   PDCTCHAR pEntry,
                                   PDCTCHAR pBuffer,
                                   DCINT    bufferSize)
{
    DC_BEGIN_FN("UT_ReadRegistryBinary");

    /************************************************************************/
    /* Check for NULL parameters                                            */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));

    /************************************************************************/
    /* Read the registry entry                                              */
    /************************************************************************/
    if (!UTReadRegistryBinary(pSection, pEntry, pBuffer, bufferSize))
    {
        TRC_NRM((TB, _T("Failed to read reg entry [%s] %s"), pSection, pEntry));
        *pBuffer = 0;
    }

    DC_END_FN();
} /* UT_ReadRegistryBinary */


/****************************************************************************/
/* Name:      UT_EnumRegistry                                               */
/*                                                                          */
/* Purpose:   Enumerate registry keys from a section                        */
/*                                                                          */
/* Returns:   TRUE  - registry key returned                                 */
/*            FALSE - no more registry keys to enumerate                    */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      index         - index of key to enumerate             */
/*            OUT     pBuffer       - output buffer                         */
/*            IN      bufferSize    - output buffer size                    */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_EnumRegistry( PDCTCHAR pSection,
                              DCUINT32 index,
                              PDCTCHAR pBuffer,
                              PDCINT   pBufferSize )
{
    DCBOOL rc;
    DC_BEGIN_FN("UT_EnumRegistry");

    rc = UTEnumRegistry(pSection, index, pBuffer, pBufferSize);

    DC_END_FN();
    return(rc);
} /* UT_EnumRegistry */


/****************************************************************************/
/* Name:      UT_WriteRegistryString                                        */
/*                                                                          */
/* Purpose:   Write a string to the registry                                */
/*                                                                          */
/* Returns:   TRUE if successful, FALSE otherwise                           */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      pEntry        - entry name                            */
/*            IN      pDefaultValue - default value                         */
/*            IN      pBuffer       - string to write                       */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_WriteRegistryString(PDCTCHAR pSection,
                                    PDCTCHAR pEntry,
                                    PDCTCHAR pDefaultValue,
                                    PDCTCHAR pBuffer)
{
    DCBOOL rc = FALSE;

    DC_BEGIN_FN("UT_WriteRegistryString");

    /************************************************************************/
    /* Check for NULL parameters.                                           */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));
    TRC_ASSERT((pBuffer != NULL), (TB, _T("NULL pointer to value")));

    /************************************************************************/
    /* Check the passed value against the default.                          */
    /************************************************************************/
    if (pDefaultValue != NULL)
    {
        if (0 == DC_TSTRICMP(pBuffer, pDefaultValue))
        {
            /****************************************************************/
            /* They match - in this case we just need to delete any         */
            /* existing entry from the registry.                            */
            /****************************************************************/
            if (UTDeleteEntry(pSection, pEntry))
            {
                rc = TRUE;
                DC_QUIT;
            }
        }
    }

    /************************************************************************/
    /* Write the registry string.                                           */
    /************************************************************************/
    if (!UTWriteRegistryString(pSection, pEntry, pBuffer))
    {
        TRC_NRM((TB, _T("Failed to write registry entry [%s] %s"),
                                                           pSection, pEntry));
        DC_QUIT;
    }
    rc = TRUE;

DC_EXIT_POINT:
    DC_END_FN();
    return(rc);
} /* UT_WriteRegistryString */


/****************************************************************************/
/* Name:      UT_WriteRegistryInt                                           */
/*                                                                          */
/* Purpose:   Write an INT to the registry                                  */
/*                                                                          */
/* Returns:   TRUE if successful, FALSE otherwise                           */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      pEntry        - entry name                            */
/*            IN      defaultValue  - default value                         */
/*            IN      value         - value to write                        */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_WriteRegistryInt(PDCTCHAR pSection,
                                 PDCTCHAR pEntry,
                                 DCINT    defaultValue,
                                 DCINT    value)
{
    DCBOOL rc = FALSE;

    DC_BEGIN_FN("UT_WriteRegistryInt");

    /************************************************************************/
    /* Check for NULL parameters.                                           */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));

    /************************************************************************/
    /* Check the passed value against the default.                          */
    /************************************************************************/
    if (value == defaultValue)
    {
        /********************************************************************/
        /* They match - in this case we just need to delete any             */
        /* existing entry from the registry.                                */
        /********************************************************************/
        if (UTDeleteEntry(pSection, pEntry))
        {
            rc = TRUE;
            DC_QUIT;
        }
    }

    /************************************************************************/
    /* Write the registry value.                                            */
    /************************************************************************/
    if (!UTWriteRegistryInt(pSection, pEntry, (DCINT) value))
    {
        TRC_NRM((TB, _T("Bad rc %hd for entry [%s] %s"), rc, pSection, pEntry));
        DC_QUIT;
    }
    rc = TRUE;

DC_EXIT_POINT:
    DC_END_FN();
    return(rc);
} /* UT_WriteRegistryInt */


/****************************************************************************/
/* Name:      UT_ParseUserData                                              */
/*                                                                          */
/* Purpose:   Parses the user data and finds the type of data requested     */
/*                                                                          */
/* Returns:   A pointer to the value requested                              */
/*                                                                          */
/* Params:                                                                  */
/*   pUserData:         The data to be parsed.                              */
/*   userDataLen:       The total length of the data.                       */
/*   typeRequested:     The type of data requested.                         */
/****************************************************************************/
PRNS_UD_HEADER DCAPI CUT::UT_ParseUserData(PRNS_UD_HEADER  pUserData,
                                      DCUINT          userDataLen,
                                      DCUINT16        typeRequested)
{
    PDCUINT8       pUDEnd;
    PRNS_UD_HEADER pUDRequested;

    DC_BEGIN_FN("UT_ParseUserData");

    /************************************************************************/
    /* Check that the user data to be parsed is valid.                      */
    /************************************************************************/
    TRC_ASSERT((pUserData != NULL),(TB, _T("Null User Data in UT_ParseUserData")));
    TRC_ASSERT((userDataLen != 0), (TB,_T("Null user data in UT_ParseUserData")));
    pUDRequested = NULL;
    pUDEnd = (PDCUINT8)pUserData + userDataLen;
    TRC_NRM((TB, _T("Parsing user data(len:%u) from %p to %p for type %#hx"),
                  userDataLen,
                  (PDCUINT8)pUserData,
                  pUDEnd,
                  typeRequested));

    /************************************************************************/
    /* We shouldn't trust that the PRNS_UD_HEADER is even valid, or we may  */
    /* AV trying to read it.                                                */
    /************************************************************************/
    if ((PDCUINT8)pUserData + sizeof(PRNS_UD_HEADER) > pUDEnd)
    {
        TRC_ABORT((TB, _T("Invalid UserData")));
        DC_QUIT;
    }

    /************************************************************************/
    /* Parse user data until the typeRequested is found.                    */
    /************************************************************************/
    while (pUserData->length != 0 && (pUserData->type) != typeRequested)
    {
        TRC_NRM((TB, _T("Skip UserData type %#hx len %hu"),
                     pUserData->type, pUserData->length));
        pUserData = (PRNS_UD_HEADER)((PDCUINT8)pUserData + pUserData->length);
        if ((PDCUINT8)pUserData >= pUDEnd)
        {
            TRC_ERR((TB, _T("No data of type %#hx"),typeRequested));
            DC_QUIT;
        }

        /************************************************************************/
        /* Again, don't trust the PRNS_UD_HEADER to be there...                 */
        /************************************************************************/
        if ((PDCUINT8)pUserData + sizeof(PRNS_UD_HEADER) > pUDEnd)
        {
            TRC_ABORT((TB, _T("Invalid UserData")));
            DC_QUIT;
        }
    }

    if (pUserData->length == 0) {
        TRC_ERR((TB, _T("Invalid UserData")));
        DC_QUIT;
    }
    /**************************************************************************/
    /* we found the requested user data type, check to see we have sufficient */
    /* data                                                                   */
    /**************************************************************************/

    if( ((PDCUINT8)pUserData + pUserData->length) > pUDEnd ) {
        TRC_ERR((TB, _T("Insufficient user data of type %#hx"),typeRequested));
        DC_QUIT;

    }

    pUDRequested = pUserData;

DC_EXIT_POINT:
    DC_END_FN();
    return(pUDRequested);
} /* UT_ParseUserData */


/****************************************************************************/
/* Name:      UT_WriteRegistryBinary                                        */
/*                                                                          */
/* Purpose:   Write binary data to the registry                             */
/*                                                                          */
/* Returns:   TRUE if successful, FALSE otherwise                           */
/*                                                                          */
/* Params:    IN      pSection      - registy section                       */
/*            IN      pEntry        - entry name                            */
/*            IN      pBuffer       - string to write                       */
/*            IN      bufferSize    - Buffer size                           */
/*                                                                          */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_WriteRegistryBinary(PDCTCHAR pSection,
                                    PDCTCHAR pEntry,
                                    PDCTCHAR pBuffer,
                                    DCINT    bufferSize)
{
    DCBOOL rc = FALSE;

    DC_BEGIN_FN("UT_WriteRegistryBinary");

    /************************************************************************/
    /* Check for NULL parameters.                                           */
    /************************************************************************/
    TRC_ASSERT((pSection != NULL), (TB, _T("NULL pointer to section name")));
    TRC_ASSERT((pEntry != NULL), (TB, _T("NULL pointer to entry name")));
    TRC_ASSERT((pBuffer != NULL), (TB, _T("NULL pointer to value")));

    /************************************************************************/
    /* Write the registry data.                                           */
    /************************************************************************/
    if (!UTWriteRegistryBinary(pSection, pEntry, pBuffer, bufferSize))
    {
        TRC_NRM((TB, _T("Failed to write registry entry [%s] %s"),
                                                           pSection, pEntry));
        DC_QUIT;
    }

    rc = TRUE;

DC_EXIT_POINT:
    DC_END_FN();
    return(rc);
} /* UT_WriteRegistryBinary */


/****************************************************************************/
// UT_GetCapsSet
//
// Extracts the specified capability set from the combined caps.
//
// Returns: Pointer to the capability set within the combined caps, or NULL
// if the requested capability type was not found.
//
// Params:    IN: capsLength - number of bytes pointed to by pCaps
//            IN: pCaps - pointer to the combined capabilities
//            IN: capsSet - caps set to get
/****************************************************************************/
PDCVOID DCINTERNAL CUT::UT_GetCapsSet(DCUINT capsLength,
                                 PTS_COMBINED_CAPABILITIES pCaps,
                                 DCUINT capsSet)
{
    PTS_CAPABILITYHEADER pCapsHeader;
    unsigned capsOffset;

    DC_BEGIN_FN("UT_GetCapsSet");

    TRC_ASSERT((!IsBadReadPtr(pCaps, sizeof(*pCaps) + sizeof(*pCapsHeader))),
               (TB, _T("Invalid combined capabilities pointer")));
    TRC_ASSERT((pCaps->numberCapabilities >= 1), (TB, _T("No capability sets")));

    TRC_NRM((TB, _T("%u capability sets present, length %u, getting %u"),
                                           (DCUINT)pCaps->numberCapabilities,
                                            capsLength,
                                            capsSet));

    /************************************************************************/
    /* Find the specified capability set in the combined caps.              */
    /* First, get a pointer to the header for the first capability set.     */
    /************************************************************************/
    pCapsHeader = (PTS_CAPABILITYHEADER)pCaps->data;
    capsOffset = sizeof(TS_COMBINED_CAPABILITIES) - 1;
    TRC_ASSERT((!IsBadReadPtr(pCapsHeader, sizeof(*pCapsHeader))),
            (TB, _T("Invalid capability header")));
    TRC_ASSERT((!IsBadReadPtr(pCapsHeader, pCapsHeader->lengthCapability)),
               (TB, _T("Invalid initial capability set")));
    while (pCapsHeader->lengthCapability != 0 && pCapsHeader->capabilitySetType != capsSet)
    {
        /********************************************************************/
        /* Add the length of this capability to the offset, to keep track   */
        /* of how much of the combined caps we have processed.              */
        /********************************************************************/
        capsOffset += pCapsHeader->lengthCapability;
        if (capsOffset >= capsLength)
        {
            TRC_NRM((TB, _T("Capability set not found (type %d)"), capsSet));
            pCapsHeader = NULL;
            DC_QUIT;
        }

        /********************************************************************/
        /* Add the length of this capability to the header pointer, so it   */
        /* points to the next capability set.                               */
        /********************************************************************/
        pCapsHeader = (PTS_CAPABILITYHEADER)
                (((PDCUINT8)pCapsHeader) + pCapsHeader->lengthCapability);
        TRC_ASSERT((!IsBadReadPtr(pCapsHeader, sizeof(*pCapsHeader))),
                (TB, _T("Invalid capability header")));
        TRC_ASSERT((!IsBadReadPtr(pCapsHeader,
                pCapsHeader->lengthCapability)),
                (TB, _T("Invalid combined capability set")));
        TRC_NRM((TB, _T("Next order set: %u"), pCapsHeader->capabilitySetType));
    }

    if (pCapsHeader->lengthCapability == 0) {
        TRC_ERR((TB, _T("Invalid capsheader")));
        pCapsHeader = NULL;
        DC_QUIT;
    }

DC_EXIT_POINT:
    DC_END_FN();
    return pCapsHeader;
} /* UT_GetCapsSet */


#if !defined(OS_WINCE)
/****************************************************************************/
/* Name:      UT_GetFullPathName                                            */
/*                                                                          */
/* Purpose:   Retrieves the full path and filename of a specified file      */
/*                                                                          */
/* Returns:   If the function succeeds, the return value is the length,     */
/*            in characters, of the string copied to lpBuffer,              */
/*            not including the terminating null character.                 */
/*                                                                          */
/* Params:    IN: lpFileName - address of name of file to find path for     */
/*            IN: nBufferLength - size, in characters, of path buffer       */
/*            OUT: lpBuffer - address of path buffer                        */
/*            OUT: *lpFilePart - address of filename in path                */
/****************************************************************************/
DCUINT DCINTERNAL CUT::UT_GetFullPathName(PDCTCHAR lpFileName,
                                     DCUINT   nBufferLength,
                                     PDCTCHAR lpBuffer,
                                     PDCTCHAR *lpFilePart)
{
    DCUINT ret = FALSE;

    DC_BEGIN_FN("UT_GetFullPathName");

    ret = GetFullPathName(lpFileName,nBufferLength,lpBuffer,lpFilePart);

    DC_END_FN();
    return(ret);
} /* UT_GetFullPathName */
#endif // !defined(OS_WINCE)


#ifdef OS_WIN32

/****************************************************************************/
/* Name:      UT_StartThread                                                */
/*                                                                          */
/* Purpose:   Start a new thread                                            */
/*                                                                          */
/* Returns:   TRUE if successful, FALSE otherwise                           */
/*                                                                          */
/* Params:    IN      entryFunction - pointer to thread startup function    */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_StartThread(UTTHREAD_PROC   entryFunction,
                            PUT_THREAD_DATA pThreadData, PDCVOID threadParam)
{
    DCBOOL rc;

    DC_BEGIN_FN("UT_StartThread");

    /************************************************************************/
    /* Call onto the internal function, requiring no userParam.             */
    /* Note that this is OS-specific.                                       */
    /************************************************************************/
    rc = UTStartThread(entryFunction, pThreadData, threadParam);

    DC_END_FN();
    return(rc);
} /* UT_StartThread  */


//
// WaitWithMessageLoop
// Waits on a handle while allowing window messages to be processed
// 
// Params:
//      hEvent  - event to wait on
//      Timeout - timeout value to wait for
//
// Returns:
//      Results of wait see MsgWaitForMultipleObjects in MSDN
//
//
DWORD CUT::UT_WaitWithMessageLoop(HANDLE hEvent, ULONG Timeout)
{
    DWORD dwRet;
    DWORD dwTemp;
    MSG msg;
    DWORD dwStartTime = GetTickCount();
    while (1) 
    {
        dwRet = MsgWaitForMultipleObjects( 1,        // One event to wait for
                                           &hEvent,  // The array of events
                                           FALSE,    // Wait for 1 event
                                           Timeout,  // Timeout value
                                           QS_ALLINPUT);   // Any message wakes up
        if (dwRet == WAIT_OBJECT_0 + 1) {

            // There is a window message available. Dispatch it.
            while (PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE)) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }

            if (INFINITE != Timeout) {
                //
                // If we keep getting flooded by messages the timer will constantly
                // reset and the timeout interval will be _very_ long. So do a check
                // and bail out
                //
                dwTemp = GetTickCount();
                if (dwTemp - dwStartTime >= Timeout) {
                    dwRet = WAIT_TIMEOUT;
                    break;
                }
                Timeout -= dwTemp - dwStartTime;
                dwStartTime = dwTemp;
            }
        }
        else 
        {
            break;
        }
    }
 
    return dwRet;
}

/****************************************************************************/
/* Name:      UT_DestroyThread                                              */
/*                                                                          */
/* Purpose:   Terminate a thread                                            */
/*                                                                          */
/* Returns:   TRUE - success                                                */
/*            FALSE  - failed                                               */
/*                                                                          */
/* Params:    IN      threadID   - thread ID                                */
/*            fPumpMessages      - TRUE if wait should pump messages        */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_DestroyThread(UT_THREAD_DATA threadData,
                                   BOOL fPumpMessages)
{
    DCBOOL rc;

    DC_BEGIN_FN("UT_DestroyThread");

    rc = UTStopThread(threadData, fPumpMessages);

    DC_END_FN();
    return(rc);
} /* UT_DestroyThread */

#endif /* OS_WIN32 */





#ifdef DC_DEBUG
/****************************************************************************/
/* Name: UT_SetRandomFailureItem                                            */
/*                                                                          */
/* Purpose: Sets the percentage failure of a specified function             */
/*                                                                          */
/* Params: IN - itemID - identifies the function                            */
/*         IN - percent - the new percentage failure                        */
/****************************************************************************/
DCVOID DCAPI CUT::UT_SetRandomFailureItem(DCUINT itemID, DCINT percent)
{
    DC_BEGIN_FN("UT_SetRandomFailureItem");

    TRC_ASSERT( ( (percent >= 0) && (percent <= 100) ) ,
                 (TB,_T("Bad failure percentage passed to UT")));

    TRC_ASSERT(( ( itemID >= UT_FAILURE_BASE ) &&
                 ( itemID <= (UT_FAILURE_BASE + UT_FAILURE_MAX_INDEX ) ) ),
                 (TB,_T("Bad itemID")));

    TRC_NRM((TB, _T("Setting item %d"), itemID));

    _UT.failPercent[itemID - UT_FAILURE_BASE] = percent;

    DC_END_FN();
} /* UT_SetRandomFailureItem */


/****************************************************************************/
/* Name: UT_GetRandomFailureItem                                            */
/*                                                                          */
/* Purpose: Gets the percentage failure for a specified function            */
/*                                                                          */
/* Returns: The percentage                                                  */
/*                                                                          */
/* Params: IN - itemID - identifies the function                            */
/****************************************************************************/
DCINT DCAPI CUT::UT_GetRandomFailureItem(DCUINT itemID)
{
    DCINT rc = 0;

    DC_BEGIN_FN("UT_GetRandomFailureItem");

    TRC_ASSERT(( ( itemID >= UT_FAILURE_BASE ) &&
                 ( itemID <= UT_FAILURE_BASE + UT_FAILURE_MAX_INDEX ) ),
                 (TB,_T("Bad itemID")));

    rc = _UT.failPercent[itemID - UT_FAILURE_BASE];

    DC_END_FN();
    return(rc);
} /* UT_GetRandomFailureItem */


/****************************************************************************/
/* Name: UT_TestRandomFailure                                               */
/*                                                                          */
/* Purpose: Simulates random failure of a function specified, according to  */
/*          the percentage asscociated with that function                   */
/*                                                                          */
/* Returns: TRUE if function is simualted as failed                         */
/*                                                                          */
/* Params: IN - itemID - specifies function on which to simulate failure    */
/*                                                                          */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_TestRandomFailure(DCUINT itemID)
{
    DCBOOL rc = FALSE;

    DC_BEGIN_FN("UT_TestRandomFailure");

    TRC_ASSERT(( itemID >= UT_FAILURE_BASE &&
                 itemID <= UT_FAILURE_BASE + UT_FAILURE_MAX_INDEX ),
                 (TB,_T("Bad itemID")));

    if ((rand() % 100) < _UT.failPercent[itemID - UT_FAILURE_BASE])
    {
        rc = TRUE;
    }
    else
    {
        rc = FALSE;
    }

    DC_END_FN();
    return(rc);
} /* UT_TestRandomFailure */

#endif /* DC_DEBUG */


/****************************************************************************/
/* Name:      UT_GetANSICodePage                                             */
/*                                                                          */
/* Purpose:   Get the local ANSI code page                                  */
/*                                                                          */
/* Returns:   Code page                                                     */
/*                                                                          */
/* Operation: Look at the version info for GDI.EXE                          */
/****************************************************************************/
DCUINT DCINTERNAL CUT::UT_GetANSICodePage(DCVOID)
{
    DCUINT     codePage;

    DC_BEGIN_FN("UT_GetANSICodePage");

    //
    // Get the ANSI code page.  This function always returns a valid value.
    //
    codePage = GetACP();

    TRC_NRM((TB, _T("Return codepage %u"), codePage));

    DC_END_FN();
    return(codePage);
} /* UT_GetANSICodePage */


/****************************************************************************/
/* Name:      UT_IsNEC98platform                                            */
/*                                                                          */
/* Purpose:   Is client platform a NEC PC-98 ?                              */
/*                                                                          */
/* Returns:   TRUE if platform is it.                                       */
/****************************************************************************/
DCBOOL DCINTERNAL CUT::UT_IsNEC98platform(DCVOID)
{
#if !defined(OS_WINCE)
    if (GetKeyboardType(0) == 7 &&                     /* 7 is a Japanese */
        HIBYTE(LOWORD(GetKeyboardType(1))) == 0x0D)    /* 0x0d is a NEC */
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
#else // !defined(OS_WINCE)
    return FALSE;
#endif // !defined(OS_WINCE)
}


/****************************************************************************/
/* Name:      UT_IsNX98Key                                                  */
/*                                                                          */
/* Purpose:   Is client configured with a NEC PC-98NX keyboard ?            */
/*                                                                          */
/* Returns:   TRUE if NEC PC-98NX keyboard is attached.                     */
/****************************************************************************/
DCBOOL DCINTERNAL CUT::UT_IsNX98Key(DCVOID)
{
#if !defined(OS_WINCE)
    if (GetKeyboardType(0) == 7 &&                     /* 7 is a Japanese */
        GetKeyboardType(1) == 2 &&                     /* 2 is a 106 keyboard */
        GetKeyboardType(2) == 15)                      /* Number of function key is 15 */
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
#else // !defined(OS_WINCE)
    return FALSE;
#endif // !defined(OS_WINCE)
}


/****************************************************************************/
/* Name:      UT_GetRealDriverNameNT                                        */
/*                                                                          */
/* Purpose:   Get real keyboard driver name for NT.                         */
/*                                                                          */
/* Returns:   TRUE if get driver name.                                      */
/****************************************************************************/
#if !defined(OS_WINCE)
DCBOOL DCINTERNAL CUT::UT_GetRealDriverNameNT(
    PDCTCHAR lpszRealDriverName,
    UINT     cchDriverName
    )
{
    DCBOOL   fRet = FALSE;
    HKEY     hKey = NULL;
    DWORD    DataType = REG_SZ;
    DCTCHAR  SubKey[MAX_PATH];
    DCTCHAR  Buffer[MAX_PATH];
    DWORD    DataSize;
    DCTCHAR  kbdName[KL_NAMELENGTH];
    HRESULT  hr;
    DC_BEGIN_FN("UT_GetRealDriverNameNT");

    if (GetKeyboardLayoutName(kbdName))
    {
        hr = StringCchPrintf(
                        SubKey,
                        SIZE_TCHARS(SubKey),
                        _T("System\\CurrentControlSet\\Control\\Keyboard Layouts\\%s"),
                        kbdName
                        );
        if (FAILED(hr)) {
            TRC_ERR((TB,_T("Failed to printf subkey: 0x%x"),hr));
            return FALSE;
        }


        if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                         SubKey,
                         0,                      /* reserved                 */
                         KEY_READ,
                         &hKey) == ERROR_SUCCESS)
        {
            DataSize = sizeof(Buffer);
            if (RegQueryValueEx(hKey,
                                _T("Layout File"),
                                0,                   /* reserved                 */
                                &DataType,
                                (LPBYTE)Buffer,
                                &DataSize) == ERROR_SUCCESS)
            {
                if (_tcsicmp(Buffer, _T("KBDJPN.DLL")) == 0)
                {
                    HMODULE hLibModule;
                    BOOL (*pfnDriverNT4)(LPWSTR);
                    BOOL (*pfnDriver)(HKL, LPWSTR, LPVOID, LPVOID);

                    hLibModule = LoadLibrary(Buffer);
                    if (hLibModule != NULL)
                    {
                        /*
                         * if the layout driver is not "REAL" layout driver, the driver has
                         * "3" and "5" entry point, then we call this to get real layout driver..
                         * This is nessesary for Japanese and Korean system. because thier
                         * keyboard layout driver is "KBDJPN.DLL" or "KBDKOR.DLL", but its
                         * "REAL" driver become diffrent thier keyboard hardware.
                         */
                        /*
                         * Get the entrypoint.
                         */
                        pfnDriver = (BOOL(*)(HKL, LPWSTR, LPVOID, LPVOID))GetProcAddress((HMODULE)hLibModule, (LPCSTR)5);
                        pfnDriverNT4 = (BOOL(*)(LPWSTR))GetProcAddress((HMODULE)hLibModule, (LPCSTR)3);

                        if (pfnDriver != NULL ||
                            pfnDriverNT4 != NULL ) {
                            DCWCHAR wBuffer[MAX_PATH];
                            /*
                             * Call the entry.
                             * a. NT5 / Hydra (oridinal=4)
                             * b. NT4 compatible (3)
                             */
                            if ((pfnDriver && pfnDriver((HKL)MAKELANGID(LANG_JAPANESE,SUBLANG_DEFAULT),
                                                        wBuffer,NULL,NULL)) ||
                                (pfnDriverNT4 && pfnDriverNT4(wBuffer)))
                            {
#ifndef UNICODE
                                Buffer[0] = _T('\0');
                                wcstombs(Buffer, wBuffer, sizeof(Buffer));
                                hr = StringCchCopy(lpszRealDriverName,
                                                  cchDriverName,
                                                  wBuffer);
#else
                                hr = StringCchCopy(lpszRealDriverName,
                                                  cchDriverName,
                                                  wBuffer);
#endif
                                if (SUCCEEDED(hr)) {
                                    fRet = TRUE;
                                }
                                else {
                                    TRC_ERR((TB,
                                     _T("Failed to copy real driver name: 0x%x"),hr));
                                }
                            }
                        }
                        FreeLibrary((HMODULE)hLibModule);
                    }
                }
            }
            RegCloseKey(hKey);
        }
    }

    DC_END_FN();
    return fRet;
}
#endif // !OS_WINCE


/****************************************************************************/
/* Name:      UT_IsNew106Layout                                             */
/*                                                                          */
/* Purpose:   Is client configured with an new 106 keyboard layout ?        */
/*                                                                          */
/* Returns:   TRUE if new 106 keyboard is attached.                         */
/****************************************************************************/
DCBOOL DCINTERNAL CUT::UT_IsNew106Layout(DCVOID)
{
#if !defined(OS_WINCE)
    if (GetKeyboardType(0) == 7 &&                     /* 7 is a Japanese */
        GetKeyboardType(1) == 2 &&                     /* 2 is a 106 keyboard */
        GetKeyboardType(2) == 12)                      /* Number of function key is 12 */
    {
        DCBOOL  fRet = FALSE;
        HKEY    hKey = NULL;
        DWORD   DataType = REG_SZ;
        DCTCHAR SubKey[MAX_PATH];
        DCTCHAR Buffer[MAX_PATH];
        DWORD   DataSize;

        if (UT_GetOsMinorType() == TS_OSMINORTYPE_WINDOWS_95)
        {
            /***************************************************************************\
             * Get value of new 106 from the registry
             * PATH:"HKCU\Control Panel\Keyboard"
             * VALUE:"New106Keyboard" (REG_SZ)
             * DATA: "Yes" or "No"
            \***************************************************************************/
            if (RegOpenKeyEx(HKEY_CURRENT_USER,
                             _T("Control Panel\\Keyboard"),
                             0,                          /* reserved                 */
                             KEY_READ,
                             &hKey) == ERROR_SUCCESS)
            {
                DataSize = sizeof(Buffer);
                if (RegQueryValueEx(hKey,
                                    _T("New106Keyboard"),
                                    0,                   /* reserved                 */
                                    &DataType,
                                    (LPBYTE)Buffer,
                                    &DataSize) == ERROR_SUCCESS)
                {
                    if (_tcsicmp(Buffer, _T("Yes")) == 0)
                    {
                        fRet = TRUE;
                    }
                }

                RegCloseKey(hKey);
            }
        }
        else if (UT_GetOsMinorType() == TS_OSMINORTYPE_WINDOWS_NT)
        {
            if (UT_GetRealDriverNameNT(Buffer, SIZE_TCHARS(Buffer)))
            {
                if (_tcsicmp(Buffer, _T("kbd106n.dll")) == 0)
                {
                    fRet = TRUE;
                }
            }
        }
        return fRet;
    }
    else
    {
        return FALSE;
    }
#else // !defined(OS_WINCE)
    return FALSE;
#endif // !defined(OS_WINCE)
}

/****************************************************************************/
/* Name:      UT_IsFujitsuLayout                                            */
/*                                                                          */
/* Purpose:   Is client configured with Fujitsu keyboard layout ?           */
/*                                                                          */
/* Returns:   TRUE if Fujitsu keyboard is attached.                         */
/****************************************************************************/
DCBOOL DCINTERNAL CUT::UT_IsFujitsuLayout(DCVOID)
{
#if !defined(OS_WINCE)
    if (GetKeyboardType(0) == 7 &&                     /* 7 is a Japanese */
        GetKeyboardType(1) == 2 &&                     /* 2 is a 106 keyboard */
        GetKeyboardType(2) == 12)                      /* Number of function key is 12 */
    {
        DCBOOL  fRet = FALSE;
        HKEY    hKey = NULL;
        DWORD   DataType = REG_SZ;
        DCTCHAR SubKey[MAX_PATH];
        DCTCHAR Buffer[MAX_PATH];
        DWORD   DataSize;

        if (UT_GetOsMinorType() == TS_OSMINORTYPE_WINDOWS_95)
        {
            /***************************************************************************\
             * Windows 95/98 doesn't support
            \***************************************************************************/
        }
        else if (UT_GetOsMinorType() == TS_OSMINORTYPE_WINDOWS_NT)
        {
            if (UT_GetRealDriverNameNT(Buffer, SIZE_TCHARS(Buffer)))
            {
                if (_tcsicmp(Buffer, _T("f3ahvoas.dll")) == 0)
                {
                    fRet = TRUE;

                    if (_UT.F3AHVOasysDll.hInst == NULL) {
                        _UT.F3AHVOasysDll.hInst = LoadExternalDll(
                            _T("f3ahvoas.dll"),
                            _UT.F3AHVOasysDll.func.rgFunctionPort,
                            sizeof(_UT.F3AHVOasysDll.func.rgFunctionPort)/sizeof(_UT.F3AHVOasysDll.func.rgFunctionPort[0]));
                    }
                }
            }
        }
        return fRet;
    }
    else
    {
        return FALSE;
    }
#else // !defined(OS_WINCE)
    return FALSE;
#endif // !defined(OS_WINCE)
}


/****************************************************************************/
/* Name:      UT_IsKorean101LayoutForWin9x                                  */
/*                                                                          */
/* Purpose:   Is Win9x client configured with a Korean 101A/B/C keyboard ?  */
/*                                                                          */
/* Returns:   TRUE if Korean 101A/B/C keyboard is attached.                 */
/****************************************************************************/
DCBOOL DCINTERNAL CUT::UT_IsKorean101LayoutForWin9x(DCVOID)
{
#if !defined(OS_WINCE)
    if (UT_GetOsMinorType() == TS_OSMINORTYPE_WINDOWS_95)
    {
        int subtype = GetKeyboardType(1);

        if (GetKeyboardType(0) == 8 &&                     /* 8 is a Korean */
            (subtype == 3 ||                               /* 3 is a 101A keyboard */
             subtype == 4 ||                               /* 4 is a 101B keyboard */
             subtype == 5   )          )                   /* 5 is a 101C keyboard */
        {
            return TRUE;
        }
    }
    return FALSE;
#else // !defined(OS_WINCE)
    return FALSE;
#endif // !defined(OS_WINCE)
}


/****************************************************************************/
/* Name:      UT_IsKorean101LayoutForNT351                                  */
/*                                                                          */
/* Purpose:   Is NT 3.51 client configured with a Korean 101A/B keyboard ?  */
/*                                                                          */
/* Returns:   TRUE if Korean 101A/B keyboard is attached.                   */
/****************************************************************************/
DCBOOL DCINTERNAL CUT::UT_IsKorean101LayoutForNT351(DCVOID)
{
#if !defined(OS_WINCE)
    if (UT_GetOsMinorType() == TS_OSMINORTYPE_WINDOWS_NT)
    {
        int subtype = GetKeyboardType(1);

        if (GetKeyboardType(0) == 8 &&                     /* 8 is a Korean */
            (subtype == 3 ||                               /* 3 is a 101A keyboard */
             subtype == 4   )          )                   /* 4 is a 101B keyboard */
        {
            OSVERSIONINFO    osVersionInfo;
            BOOL             bRc;

            osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
            bRc = GetVersionEx(&osVersionInfo);
            if (osVersionInfo.dwMajorVersion == 3 &&
                osVersionInfo.dwMinorVersion == 51  )
            {
                return TRUE;
            }
        }
    }
    return FALSE;
#else // !defined(OS_WINCE)
    return FALSE;
#endif // !defined(OS_WINCE)
}

#ifdef OS_WINCE
TCHAR MakeValidChar(BYTE data)
/*++

Routine Description:

    MakeValidChar.

Arguments:

    data - BYTE data which we need to convert to a printable character 
           which is a valid character that can be used in a computer name.

Return Value:

    Returns the character

More Info:
    
    A valid character that can be used in a computer name is from the range 0x30 to 0x39
    and again from 0x40 to 0x5A, and  from 0x61 to 0x7A. (See the ascii table for these ranges).
    To be precise, it includes the numbers 0 to 9, characters 'A' to 'Z'and characters 'a' to 'z'

 --*/
{
    BYTE temp = (BYTE)(data & (BYTE)0x7F);

    if ((temp >= 0x30 && temp <= 0x39) ||
        (temp >= 0x40 && temp <= 0x5A) ||
        (temp >= 0x61 && temp <= 0x7A)) {
        return (TCHAR)temp;
    }
    else {
        //
        // generate a random number in the above range, and return it
        //
        // The number of valid combinations is (0x30 to 0x39) + (0x40 to 0x5A) + (0x61 to 0x7A)
        // That is 10 + 27 + 26 = 63
        DWORD dw = rand() % 63; 
        if (dw < 10)
            return (TCHAR)(0x30 + dw);
        else
        if (dw < 37)
            return (TCHAR)(dw - 10 + 0x40);
        else
            return (TCHAR)(dw - 37 + 0x61);
    }
}

DCBOOL UT_GetWBTComputerName(PDCTCHAR szBuff, DCUINT32 len)
/*++

Routine Description:

    UT_GetWBTComputerName.

Arguments:

    szBuff - pointer to a buffer where the computer name is returned.

    len - length of the above buffer.

Return Value:

    TRUE - If a computer name which is non-trivial is found or generated.
    FALSE - Otherwise.

 --*/
{
    CHAR achHostName[MAX_PATH+1];
    BOOL fGetHostNameSuccess = FALSE;
    HWID hwid;

    HKEY hKey = NULL;
    DWORD dwBufLen, dwValueType;
    DWORD dwResult = 0;

    BOOL fSuccess = FALSE;

    DC_BEGIN_FN("UT_GetWBTComputerName");

    // get the host name of the device
    if (0 == gethostname( achHostName, sizeof(achHostName) )) {

        fGetHostNameSuccess = TRUE;

        // Check for bad hardcoded values
        if ((0 == strcmp(achHostName,BAD_HARDCODED_NAME1))
            || (0 == strcmp(achHostName,BAD_HARDCODED_NAME2))
            || (len < ((strlen(achHostName) + 1)))) {
            goto use_registry;
        }
        else {
            // gethostname success
            goto use_gethostname;
        }
    }
    
use_registry:

    //
    // Try if we have previously stored a computername in the registry
    //
    dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                        REG_WBT_RDP_COMPUTER_NAME_KEY,
                        0,
                        KEY_READ,
                        &hKey );

    if (dwResult != ERROR_SUCCESS) {
        goto use_uuid;
    }

    dwBufLen = len * sizeof (TCHAR);
    dwResult = RegQueryValueEx( hKey,
                    REG_WBT_RDP_COMPUTER_NAME_VALUE,
                    0,
                    &dwValueType,
                    (LPBYTE)szBuff,
                    &dwBufLen );

    RegCloseKey(hKey);
    hKey = NULL;

    if (dwResult == ERROR_SUCCESS &&
        szBuff[0] != _T('\0')) {
        fSuccess = TRUE;
        goto Cleanup;
    }

use_uuid:
    
    if (len >= HWID_COMPUTER_NAME_STR_LEN) {

        // Use UUID instead
        if (LICENSE_STATUS_OK == GenerateClientHWID(&hwid)) {

            DWORD dwDisposition = 0;

            DWORD dw1 = (hwid.dwPlatformID ^ hwid.Data4);
            DWORD dw2 = (hwid.Data4 ^ hwid.Data1);
            DWORD dw3 = (hwid.Data1 ^ hwid.Data2);
            DWORD dw4 = (hwid.Data2 ^ hwid.Data3);

            srand((UINT)GetTickCount());

            //
            // The generated string will be of the form {abcdefghijklm}
            //
            szBuff[0] = _T('{');

            szBuff[1] = MakeValidChar((BYTE)(dw1 & 0x000000FF));
            szBuff[2] = MakeValidChar((BYTE)((dw1 & 0x0000FF00) >> 8));
            szBuff[3] = MakeValidChar((BYTE)((dw1 & 0x00FF0000) >> 16));
            szBuff[4] = MakeValidChar((BYTE)((dw1 & 0xFF000000) >> 24));
            
            szBuff[5] = MakeValidChar((BYTE)(dw2 & 0x000000FF));
            szBuff[6] = MakeValidChar((BYTE)((dw2 & 0x0000FF00) >> 8));
            szBuff[7] = MakeValidChar((BYTE)((dw2 & 0x00FF0000) >> 16));
            szBuff[8] = MakeValidChar((BYTE)((dw2 & 0xFF000000) >> 24));
            
            szBuff[9] = MakeValidChar((BYTE)(dw3 & 0x000000FF));
            szBuff[10] = MakeValidChar((BYTE)((dw3 & 0x0000FF00) >> 8));
            szBuff[11] = MakeValidChar((BYTE)((dw3 & 0x00FF0000) >> 16));
            szBuff[12] = MakeValidChar((BYTE)((dw3 & 0xFF000000) >> 24));

            szBuff[13] = MakeValidChar((BYTE)(dw4 & 0x000000FF));
            
            szBuff[14] = _T('}');
            szBuff[15] = _T('\0');

            //
            // Write the string to the registry.
            //
            dwResult = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
                              REG_WBT_RDP_COMPUTER_NAME_KEY,
                              0,
                              NULL,
                              REG_OPTION_NON_VOLATILE,
                              KEY_ALL_ACCESS,
                              NULL,
                              &hKey,
                              &dwDisposition );

            if (dwResult == ERROR_SUCCESS) {
                RegSetValueEx(hKey,
                    REG_WBT_RDP_COMPUTER_NAME_VALUE,
                    0,
                    REG_SZ,
                    (LPBYTE)szBuff,
                    (_tcslen(szBuff) + 1) * sizeof(TCHAR));

                RegCloseKey(hKey);
            }
            fSuccess = TRUE;
            goto Cleanup;
        }
    }

use_gethostname:
    
    if (fGetHostNameSuccess &&
       (len >= ((strlen(achHostName) + 1)))) {
        mbstowcs(szBuff, achHostName, (strlen(achHostName) + 1));
        fSuccess = TRUE;
    }

Cleanup:
    
    if (!fSuccess) {
        if (len > 0) {
            szBuff[0] = _T('\0');
        }
    }

    DC_END_FN();
    return (fSuccess);
}
#endif



/****************************************************************************/
/* Name:      UT_GetComputerName                                            */
/*                                                                          */
/* Purpose:   Retrieves the computer name.                                  */
/*                                                                          */
/* Returns:   Success                                                       */
/*                                                                          */
/* Params:    OUT szBuff - Computer name                                    */
/*            IN  len - length of buffer                                    */
/****************************************************************************/
DCBOOL DCAPI CUT::UT_GetComputerName(PDCTCHAR szBuff, DCUINT32 len)
{
    DCBOOL    rc;
    DC_BEGIN_FN("UT_GetComputerName");

#ifdef OS_WINCE
    rc = UT_GetWBTComputerName(szBuff, len);
#else // !OS_WINCE
    rc = GetComputerName(szBuff, &len);
#endif // OS_WINCE

    DC_END_FN();
    return(rc);
}

#ifdef OS_WINCE
#define DIRECTORY_LENGTH 256
#endif

/****************************************************************************/
/* Name:      UT_GetClientDirW                                              */
/*                                                                          */
/* Purpose:   Retrieves the client directory                                */
/****************************************************************************/
BOOL DCAPI CUT::UT_GetClientDirW(PDCUINT8 szBuff)
{
   BOOL rc = FALSE;
   UINT dirlength;
   TCHAR clientDir[DIRECTORY_LENGTH];
 
   DC_BEGIN_FN("UT_GetClientDirW");

   // initialize client dir length
   *((PDCUINT16_UA)szBuff) = 0;
   memset(clientDir, 0, sizeof(clientDir));

   dirlength = GetModuleFileName(UT_GetInstanceHandle(),
           clientDir, DIRECTORY_LENGTH) + 1;

   if (dirlength > 1) {
       // client dir length
       *((PDCUINT16_UA)szBuff) = (USHORT)(dirlength * 2);
       szBuff += sizeof(DCUINT16);

       // client dir name
#ifdef UNICODE
       memcpy(szBuff, clientDir, dirlength * 2);
#else // UNICODE
       {
       USHORT pstrW[DIRECTORY_LENGTH];
       
#ifdef OS_WIN32
       ULONG ulRetVal;

       ulRetVal = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
               clientDir, -1, pstrW, DIRECTORY_LENGTH);
       pstrW[ulRetVal] = 0;

       memcpy(szBuff, pstrW, (ulRetVal + 1) * 2);
#else // !OS_WIN32
       mbstowcs(pstrW, clientDir, dirlength);
       memcpy(szBuff, pstrW, dirlength * 2);
#endif // OS_WIN32
       }
#endif // UNICODE

       rc = TRUE;
   }

   DC_END_FN();
   return rc;
}

/***************************************************************************/
// UT_ValidateProductSuite and UT_IsTerminalServices determine 
// if the platform is terminal service enabled.
// Note that the UT_ValidateProductSuite() and UT_IsTerminalServices()
// APIs use ANSI versions of functions in order to maintain
// compatibility with Win9X platforms.
/***************************************************************************/
#ifdef OS_WINNT
BOOL DCAPI CUT::UT_ValidateProductSuite(LPSTR SuiteName)
{
    BOOL rVal = FALSE;
    LONG Rslt;
    HKEY hKey = NULL;
    DWORD Type = 0;
    DWORD Size = 0;
    LPSTR ProductSuite = NULL;
    LPSTR p;

    Rslt = RegOpenKeyA(
        HKEY_LOCAL_MACHINE,
        "System\\CurrentControlSet\\Control\\ProductOptions",
        &hKey
        );
    if (Rslt != ERROR_SUCCESS)
        goto exit;

    Rslt = RegQueryValueExA( hKey, "ProductSuite", NULL, &Type, NULL, &Size );
    if (Rslt != ERROR_SUCCESS || !Size)
        goto exit;

    ProductSuite = (LPSTR) LocalAlloc( LPTR, Size );
    if (!ProductSuite)
        goto exit;

    Rslt = RegQueryValueExA( hKey, "ProductSuite", NULL, &Type,
        (LPBYTE) ProductSuite, &Size );
     if (Rslt != ERROR_SUCCESS || Type != REG_MULTI_SZ)
        goto exit;

    p = ProductSuite;
    while (*p) {
        if (lstrcmpA( p, SuiteName ) == 0) {
            rVal = TRUE;
            break;
        }
        p += (lstrlenA( p ) + 1);
    }

exit:
    if (ProductSuite)
        LocalFree( ProductSuite );

    if (hKey)
        RegCloseKey( hKey );

    return rVal;
}


BOOL DCAPI CUT::UT_IsTerminalServicesEnabled(VOID)
{
    BOOL  bResult = FALSE;
    DWORD dwVersion;

    dwVersion = GetVersion();
    if (!(dwVersion & 0x80000000)) {
        if (LOBYTE(LOWORD(dwVersion)) > 4) {

            // In NT5 we need to use the Product Suite APIs
            // Don't static link because it won't load on non-NT5 systems

            HMODULE hmodK32;
            HMODULE hmodNTDLL;

            DWORDLONG dwlConditionMask = 0;

            typedef BOOL (FNVerifyVersionInfoA)(POSVERSIONINFOEXA, DWORD, DWORDLONG);
            FNVerifyVersionInfoA *pfnVerifyVersionInfoA;

            typedef ULONGLONG (FNVerSetConditionMask)(ULONGLONG, ULONG, UCHAR);
            FNVerSetConditionMask *pfnVerSetConditionMask;

            hmodNTDLL = GetModuleHandleA( "NTDLL.DLL" );
            
            if (hmodNTDLL != NULL) {
                pfnVerSetConditionMask = (FNVerSetConditionMask *)GetProcAddress( hmodNTDLL, "VerSetConditionMask");

                if (pfnVerSetConditionMask != NULL) {
                    dwlConditionMask = (*pfnVerSetConditionMask) (dwlConditionMask, VER_SUITENAME, VER_AND);

                    hmodK32 = GetModuleHandleA( "KERNEL32.DLL" );
                   
                    if (hmodK32 != NULL) {

                        pfnVerifyVersionInfoA = (FNVerifyVersionInfoA *)GetProcAddress( hmodK32, "VerifyVersionInfoA");

                        if (pfnVerifyVersionInfoA != NULL) {
                    
                            OSVERSIONINFOEXA osVersionInfo;

                            ZeroMemory(&osVersionInfo, sizeof(osVersionInfo));
                            osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
                            osVersionInfo.wSuiteMask = VER_SUITE_TERMINAL;
                    
                    
                            //VER_SET_CONDITION( dwlConditionMask, VER_SUITENAME, VER_AND );
                            bResult = (*pfnVerifyVersionInfoA)(
                                      &osVersionInfo,
                                      VER_SUITENAME,
                                      dwlConditionMask);
                        }
                    }
                }
            }
        } 
        else {
           bResult = UT_ValidateProductSuite( "Terminal Server" );
        }
    }

    return bResult;
}
#endif


/********************************************************************/
/*                                                                  */
/* Load External Dll                                                */
/*                                                                  */
/********************************************************************/
HINSTANCE
CUT::LoadExternalDll(
    LPCTSTR       pszLibraryName,
    PFUNCTIONPORT rgFunction,
    DWORD         dwItem
    )
{
    DWORD     i;
    HINSTANCE hInst;
    BOOL      fGetModule = FALSE;

#ifdef OS_WIN32
    hInst = GetModuleHandle(pszLibraryName);
    if (hInst != NULL) {
        fGetModule = TRUE;
    }
    else {
        hInst = LoadLibrary(pszLibraryName);
    }
#else
    hInst = LoadLibrary(pszLibraryName);
    if (hInst <= HINSTANCE_ERROR) {
        hInst = NULL;
    }
#endif

    if (hInst) {
        for (i=0; i < dwItem; i++) {
            rgFunction[i].lpfnFunction = GetProcAddress(hInst, rgFunction[i].pszFunctionName);
            if (rgFunction[i].lpfnFunction == NULL) {
                if (!fGetModule) {
                    FreeLibrary(hInst);
                }
                hInst = NULL;
                break;
            }
        }
    }

    if (hInst == NULL) {
        for (i=0; i < dwItem; i++) {
            rgFunction[i].lpfnFunction = NULL;
        }
    }

    return hInst;
}

/********************************************************************/
/*                                                                  */
/* External Dll Initialize                                          */
/*                                                                  */
/********************************************************************/
VOID
CUT::InitExternalDll(
    VOID
    )
{
#if defined(OS_WIN32)
    _UT.Imm32Dll.hInst = LoadExternalDll(
#if defined (OS_WINCE)
        _T("COREDLL.DLL"),
#else
        _T("IMM32.DLL"),
#endif // OS_WINCE        
        _UT.Imm32Dll.func.rgFunctionPort,
        sizeof(_UT.Imm32Dll.func.rgFunctionPort)/sizeof(_UT.Imm32Dll.func.rgFunctionPort[0]));
#endif // OS_WIN32

#if !defined(OS_WINCE)
    _UT.WinnlsDll.hInst = LoadExternalDll(
#ifdef OS_WIN32
        _T("USER32.DLL"),
#else
        _T("WINNLS.DLL"),
#endif
        _UT.WinnlsDll.func.rgFunctionPort,
        sizeof(_UT.WinnlsDll.func.rgFunctionPort)/sizeof(_UT.WinnlsDll.func.rgFunctionPort[0]));
#endif  // !defined(OS_WINCE)

}

/**PROC+*********************************************************************/
/* Name:      StringtoBinary                                                */
/*                                                                          */
/* Purpose:   Converts a given string to equivalent binary                  */
/*                                                                          */
/* Returns:   TRUE if successful, FALSE otherwise                           */
/*                                                                          */
/* Params:    IN      cbInBuffer - Size of the string buffer.               */
/*            IN      pbInBuffer - String buffer.                           */
/*            OUT     pszOutBuffer - Binary string buffer.                  */
/*            IN/OUT  cchOutBuffer - Size of the binary string buffer.      */
/**PROC-*********************************************************************/

BOOL CUT::StringtoBinary(size_t cbInBuffer, PBYTE pbInBuffer,
                         TCHAR *pszOutBuffer, DWORD *pcchOutBuffer)
{
    UINT i = 0, j = 0;
    TCHAR digits[] = _T("0123456789ABCDEF");
    BOOL fRet = FALSE;

    DC_BEGIN_FN("StringtoBinary");

    //
    // Validate pbInBuffer and pcchOutBuffer.
    //

    if (pbInBuffer == NULL || pcchOutBuffer == NULL) {
        fRet = FALSE;
        DC_QUIT;
    }

    //
    // Return how much space is needed for bytes converted to textual
    // binary if pszOutBuffer is NULL.
    //
    // Example:
    //
    // pbInBuffer = "ABCD" and cbInBuffer = 4
    // then
    // pszOutBuffer = "4142434400\0" and *pcchOutBuffer = 11
    //
    // Essentially, we need two characters for every byte and an additional
    // three characters for two trailing '0's and a NULL. I'm not sure why the
    // trailing zeros are there. They were produced by this code before I
    // fixed it.
    //
    
    if(pszOutBuffer == NULL) {
        *pcchOutBuffer = 2 * cbInBuffer + 3;
        fRet = TRUE;
        DC_QUIT;
    }

    //
    // j loops through the input buffer and i loops through the output
    // buffer. The check on j keeps us inside the input buffer. The
    // check on i makes sure that we can always write three characters:
    // two for the high and low nibble, and the last for a NULL which
    // will happen outside the loop.
    //

    while (j < cbInBuffer && i <= *pcchOutBuffer - 3) {
        //
        // Convert the left-most nibble in pbInBuffer[j] into 
        // a character and place it in pszOutBuffer[i].
        //
        
        pszOutBuffer[i++] = digits[(pbInBuffer[j] >> 4) & 0x0F];

        //
        // Convert the right-most nibble in pbInBuffer[j] into 
        // a character and place it in pszOutBuffer[i].
        //

        pszOutBuffer[i++] = digits[pbInBuffer[j] & 0x0F];

        j++;
    }
    
    if (i <= *pcchOutBuffer - 3) {
        //
        // We had enough space for the transformation, so finish off
        // by writing the two trailing zeros and a NULL. The count
        // returned in pcchOutBuffer includes the NULL.
        //

        pszOutBuffer[i] = _T('0');
        pszOutBuffer[i + 1] = _T('0');
        pszOutBuffer[i + 2] = NULL;
        
        *pcchOutBuffer = (DWORD) (i + 3);
        fRet = TRUE;
    } else {
        //
        // Oops! There is not enough space to write the trailing zeros.
        // We may have written the rest of the string successfully, but
        // an error is still returned. The count returned in pcchOutBuffer 
        // includes the NULL.
        //

        pszOutBuffer[i] = NULL;
    
        *pcchOutBuffer = (DWORD) (i + 1);
        fRet = FALSE;
    }


DC_EXIT_POINT:
    
    DC_END_FN();

    return fRet;
}


/**PROC+*********************************************************************/
/* Name:      BinarytoString                                                */
/*                                                                          */
/* Purpose:   Converts a given binary to equivalent string                  */
/*                                                                          */
/* Returns:   TRUE if successful, FALSE otherwise                           */
/*                                                                          */
/* Params:    IN      cchInBuffer - Size of the binary string buffer.       */
/*            IN      pszInBuffer - Binary string buffer.                   */
/*            OUT     pbOutBuffer - String buffer.                          */
/*            IN/OUT  pcbOutBuffer - Size of the string buffer.             */
/**PROC-*********************************************************************/

BOOL CUT::BinarytoString(size_t cchInBuffer, TCHAR *pszInBuffer,
                         PBYTE pbOutBuffer, DWORD *pcbOutBuffer)
{
    UINT i = 0, j = 0;
    TCHAR c = 0;
    BOOL fRet = FALSE;

    DC_BEGIN_FN("BinarytoString");
    
    //
    // Validate pszInBuffer and pcbOutBuffer.
    //

    if (pszInBuffer == NULL || pcbOutBuffer == NULL) {
        fRet = FALSE;
        DC_QUIT;
    }

    
    //
    // Check that the input buffer length parameter is correct.
    //

    if (_tcslen(pszInBuffer) != cchInBuffer) {
        fRet = FALSE;
        DC_QUIT;
    }

    //
    // If we are trying to convert an empty binary string, or a
    // string consisting of a single nibble, write nothing and 
    // return FALSE. We don't even NULL terminate the output, 
    // as this would imply that the binary string contained "00".
    //

    if (cchInBuffer < 2) {
        fRet = FALSE;
        DC_QUIT;
    }

    //
    // Return how much space is needed for bytes converted from our
    // textual binary if pbOutBuffer is NULL. 
    //
    // Examples:
    //
    // 1. pszInBuffer = "4142434400\0" and cchInBuffer = 10
    //    then
    //    pszOutBuffer = "ABCD\0" and *pcbOutBuffer = 5
    //
    // 2. pszInBuffer = "414243\0" and cchInBuffer = 6
    //    then
    //    pszOutBuffer = "ABC\0" and *pcbOutBuffer = 4
    //
    // Note that from the above we can see that there are
    // two cases to handle. The textual binary may have two trailing 
    // zero characters, or if it was truncated during conversion, 
    // these will not be present.    
    //

    if(pbOutBuffer == NULL) {
        if (pszInBuffer[cchInBuffer - 2] == _T('0') 
              && pszInBuffer[cchInBuffer - 1] == _T('0')) {

            *pcbOutBuffer = cchInBuffer / 2;
        } else {
            *pcbOutBuffer = cchInBuffer / 2 + 1;
        }
        fRet = TRUE;

        
        DC_QUIT;
    }

    //
    // i loops through the output buffer and j loops through the
    // input buffer. The check on i makes sure that we do not overshoot 
    // the size of the output buffer. We must leave space for a NULL at 
    // the end of this buffer. The check on j makes sure that there are 
    // always two characters to read from the input string, a high nibble 
    // and a low nibble.
    //

    while (i < *pcbOutBuffer - 1 && j <= cchInBuffer - 2) {
        //
        // Obtain the left-most nibble of the resultant byte. Do this
        // by determining the ASCII value in pszInBuffer[j] and then
        // checking if it is above or below 'A'. If it is below 'A', we 
        // subtract '0' to give a number in the range 0x0 - 0x9, else 
        // we subtract '7' to give a number in the range 0xA - 0xF.
        //
        // Examples:
        //
        // 'A' - '7' = 0x41 - 0x37 = 0x0A
        // '4' - '0' = 0x34 - 0x30 = 0x04
        //
        // Once we have the value, shift left to put the result in the
        // left-most nibble of pbOutBuffer[i]. 
        //

        c = pszInBuffer[j++];
        pbOutBuffer[i] = (c >= _T('A')) ? c - _T('7') : c - _T('0');
        pbOutBuffer[i] <<= 4;

        //
        // Do the same as above, but this time the result goes in the
        // right-most nibble of pszInBuffer[i].
        //
        
        c = pszInBuffer[j++];
        pbOutBuffer[i] |= (c >= _T('A')) ? c - _T('7') : c - _T('0');
        
        i++;
    }


    //
    // NULL terminate and return the size including the NULL.
    //

    pbOutBuffer[i] = NULL;
    *pcbOutBuffer = (DWORD) (i + 1);

    fRet = TRUE;

DC_EXIT_POINT:
    
    DC_END_FN();

    return fRet;
}


//
// Validates the server name.
// format - server[:port]
//
// Params: szServerName - name of server to validate
//         fAllowPortSuffix - allow optional :port suffix
//
BOOL CUT::ValidateServerName(LPCTSTR szServerName, BOOL fAllowPortSuffix)
{
    DC_BEGIN_FN("ValidateServerName");
    //server name should not be empty
    if(!szServerName || !*szServerName)
    {
        return FALSE;
    }

    //Check for ;  "  <  >  *  +  =  |  ?  space and tab in the server name field.
    //Also validate for the :port sequence (it must appear at the end and port must
    //be numeric
    while(*szServerName)
    {
        if( (*szServerName == _T(';')) ||
            (*szServerName == _T('"')) || (*szServerName == _T('<')) ||
            (*szServerName == _T('>')) || (*szServerName == _T('*')) ||
            (*szServerName == _T('+')) || (*szServerName == _T('=')) ||
            (*szServerName == _T('|')) || (*szServerName == _T('?')) ||
            (*szServerName == _T(',')) || (*szServerName == _T(' ')) ||
            (*szServerName == _T('\t')))

        {
            return FALSE;
        }
        else if((*szServerName == _T(':')))
        {
            if(fAllowPortSuffix)
            {
                //Reached optional [:port] suffix
                szServerName++;
                //Rest of string can only contain numerics otherwise it's invalid
                //also port number must be less thant 65535
                LPCTSTR szStartNum = szServerName;
                if(!*szStartNum)
                {
                    return FALSE; //0 length number
                }
                while(*szServerName)
                {
                    if(!isdigit(*szServerName++))
                    {
                        return FALSE;
                    }
                }
                if((szServerName - szStartNum) > 5) //5 digit max
                {
                    return FALSE;
                }
                int port = _ttoi(szStartNum);
                if (port < 0 || port > 65535) {
                    return FALSE;
                }
                return TRUE; // reached end case
            }
            else
            {
                return FALSE;
            }
        }
        szServerName++;
    }

    return TRUE;

    DC_END_FN();
}

//
// Parse port number from server name
// if the server is specified as server:port
// if no port number could be found then return -1
//
// Params:
//  szServer - server name in form server[:port]
// Returns:
//  port number or -1 if none found
//
INT CUT::GetPortNumberFromServerName(LPTSTR szServer)
{
    DC_BEGIN_FN("GetPortNumberFromServerName");

    if(szServer && ValidateServerName(szServer, TRUE))
    {
        //Walk to the :
        while(*szServer && *szServer++ != _T(':'));
        if(*szServer)
        {
            //Because server name has been validate
            //and it has the port delimeter ':' it is
            //guaranteed to have a valid (syntax wise)
            //port number.
            return _ttoi(szServer);
        }
        else
        {
            //no port specified
            return -1;
        }
    }
    else
    {
        return -1;
    }

    DC_END_FN();
}

//
// GetServerNameFromFullAddress
// Splits the server name from a full address of the form
//  server:port
//
// Params:
//  IN - szFullName (full server name e.g. myserver:3389
//  IN/OUT - buffer for result string 
//  IN - length of output buffer
//
VOID CUT::GetServerNameFromFullAddress(
                    LPCTSTR szFullName,
                    LPTSTR szServerOnly,
                    ULONG len
                    )
{
    LPTSTR sz;
    DC_BEGIN_FN("GetServerNameFromFullAddress");

    _tcsncpy(szServerOnly, szFullName, len - 1);
    szServerOnly[len-1] = 0;
    sz = szServerOnly;
    while(*sz)
    {
        if (*sz == _T(':'))
        {
            *sz = NULL;
            break;
        }
        sz++;
    }

    DC_END_FN();
}

//
// Return a canonical server name from a longer connect string
// i.e. strip out all 'argument' portions from a long connect string
// and keep only the 'connect target' portion
//
// E.g a server name could be
//
// myserver:3398 /console
//
// return just myserver:3389
//
// Params:
//      IN  szFullConnectString - the full connection string
//      OUT szCanonicalServerName - the server name
//      IN  ccLenOut - length of output buffer in TCHARS
//      OUT pszArgs - if arguments are found return a pointer to the
//                    start of the arg list.
//      NOTE: do NOT free pszArgs it's a pointer within the
//            the return string szCanonicalServerName.
//
// Returns:
//      VOID
//
//
HRESULT CUT::GetCanonicalServerNameFromConnectString(
                IN LPCTSTR szFullConnectString,
                OUT LPTSTR  szCanonicalServerName,
                ULONG cchLenOut
                )
{
    LPTSTR szDelim;
    HRESULT hr = E_FAIL;

    DC_BEGIN_FN("GetCanonicalServerNameFromConnectString");

    szDelim = _tcspbrk(szFullConnectString, _T(" \\"));

    if (szDelim == NULL) {
        hr = StringCchCopy(
            szCanonicalServerName, cchLenOut,
            szFullConnectString
            );
    }
    else {
        ULONG cchCopyLen = (szDelim - szFullConnectString);
        hr = StringCchCopyN(
            szCanonicalServerName, cchLenOut,
            szFullConnectString, cchCopyLen);
    }

    if (FAILED(hr)) {
        TRC_ERR((TB,_T("Copy to result string failed: 0x%x"),hr));
    }

    DC_END_FN();
    return hr;
}


#ifndef OS_WINCE
typedef HANDLE (WINAPI FN_SCARDACCESSSTARTEDEVENT)(VOID);
typedef FN_SCARDACCESSSTARTEDEVENT * PFN_SCARDACCESSSTARTEDEVENT ;

BOOL CUT::IsSCardReaderInstalled()
{
    HMODULE hDll = NULL;
    PFN_SCARDACCESSSTARTEDEVENT pSCardAccessStartedEvent ;
    HANDLE hCalaisStarted = NULL;
    BOOL fEnable =FALSE;

    DC_BEGIN_FN("IsSCardReaderInstalled");

    hDll = LoadLibrary( _T("WINSCARD.DLL"));
    if (hDll)
    {
        pSCardAccessStartedEvent = (PFN_SCARDACCESSSTARTEDEVENT)
            GetProcAddress( hDll,
                            "SCardAccessStartedEvent");

        if (pSCardAccessStartedEvent)
        {
            hCalaisStarted = pSCardAccessStartedEvent();
    
            if (hCalaisStarted)
            {
                 if  (WAIT_OBJECT_0 == WaitForSingleObject(hCalaisStarted, 0))
                 {
                    fEnable = TRUE;
                 }
            }
        }
        FreeLibrary(hDll);
    }

    TRC_NRM((TB,_T("Detected scard %d"),fEnable));

    DC_END_FN();

    return fEnable;
}

#else

#ifdef WINCE_SDKBUILD

BOOL CUT::IsSCardReaderInstalled()
{
	return FALSE;
}

#else

#include <winscard.h>
typedef LONG (WINAPI *PFN_SCARDESTABLISHCONTEXT)(DWORD, LPCVOID, LPCVOID, LPSCARDCONTEXT);

BOOL CUT::IsSCardReaderInstalled()
{
    HMODULE hDll = NULL;
    PFN_SCARDESTABLISHCONTEXT pSCardEstablishContext;
    BOOL fEnable =FALSE;

    DC_BEGIN_FN("IsSCardReaderInstalled");

    hDll = LoadLibrary( _T("WINSCARD.DLL"));
    if (hDll)
    {
        pSCardEstablishContext = (PFN_SCARDESTABLISHCONTEXT) GetProcAddress( hDll, L"SCardEstablishContext");
        FreeLibrary(hDll);
		fEnable = (pSCardEstablishContext != NULL);
    }

    TRC_NRM((TB,_T("Detected scard %d"),fEnable));

    DC_END_FN();

    return fEnable;
}
#endif //WINCE_SDKBUILD

#endif //OS_WINCE


#ifndef OS_WINCE
//
// Notify the shell of our fullscreen mode transitions
// to 'fix' all the badness associated with the shell
// taskbar rude app autohide issues
// 
// Params:
// [in] hwndMarkFullScreen - window to mark as fullscreen
// [in] fNowFullScreen - TRUE if the window is now fullscreen
// [in/out] ppTsbl - interface pointer to taskbar (gets set
//                   if fQueriedForTaskbar is false).
// [in/out] fQueriedForTaskbar - if TRUE does not query for taskbar
//                               interface
//
// Return:
// Success flag
//
// Environment: CAN ONLY BE CALLED between CoIninitalize() and
//              CoUninitialize()
//
BOOL CUT::NotifyShellOfFullScreen(HWND hwndMarkFullScreen,
                                  BOOL fNowFullScreen,
                                  ITaskbarList2** ppTsbl2,
                                  PBOOL pfQueriedForTaskbar)
{
    ITaskbarList* ptsbl = NULL;
    HRESULT hr = E_FAIL;
    DC_BEGIN_FN("NotifyShellOfFullScreen");

    if (!ppTsbl2)
    {
        TRC_ERR((TB,_T("ppTsbl2 is NULL")));
        return FALSE;
    }

    if (!pfQueriedForTaskbar)
    {
        TRC_ERR((TB,_T("pfQueriedForTaskbar is NULL")));
        return FALSE;
    }


    if (!*ppTsbl2)
    {
        //On demand create unless already failed
        //in which case bail now
        if (!*pfQueriedForTaskbar)
        {
            hr = CoCreateInstance( CLSID_TaskbarList, NULL,
                                   CLSCTX_INPROC_SERVER, IID_ITaskbarList,
                                   (void**) &ptsbl );
            if(SUCCEEDED(hr))
            {
                //
                // Note we cache the ITaskBarList2
                // it is freed in the destructor on CContainerWnd
                //
                hr = ptsbl->QueryInterface( __uuidof(ITaskbarList2),
                                            (void**) ppTsbl2 );
                ptsbl->Release();
                ptsbl = NULL;
            }
            *pfQueriedForTaskbar = TRUE;

            if(FAILED(hr))
            {
                TRC_ERR((TB,_T("Failed to get ITaskBarList: 0x%x"),hr));
                return FALSE;
            }
        }
        else
        {
            TRC_NRM((TB,_T("Bailing out of shell notify")));
            return FALSE;
        }
    }

    if (*ppTsbl2)
    {
        hr = (*ppTsbl2)->MarkFullscreenWindow( hwndMarkFullScreen,
                                               fNowFullScreen );
        if(FAILED(hr))
        {
            TRC_ERR((TB,_T("MarkFullScreenWindow failed: 0x%x"),hr));
            return FALSE;
        }
    }

    DC_END_FN();
    return TRUE;
}
#endif

//
// Dynamic thunk for ImmGetIMEFileName
//
//
UINT CUT::UT_ImmGetIMEFileName(IN HKL hkl, OUT LPTSTR szName, IN UINT uBufLen)
{
    UINT result = 0;
    DC_BEGIN_FN("UT_ImmGetIMEFileName");

#ifndef UNIWRAP
    //
    // Not using a unicode wrapper make direct calls to the
    // appropriate entry points
    // 
    #ifdef  UNICODE
    if (_UT.Imm32Dll.func._ImmGetIMEFileNameW)
    {
        result = _UT.Imm32Dll.func._ImmGetIMEFileNameW(hkl, szName, uBufLen);
    }
    #else
    if (_UT.Imm32Dll.func._ImmGetIMEFileNameA)
    {
        result = _UT.Imm32Dll.func._ImmGetIMEFileNameA(hkl, szName, uBufLen);
    }
    #endif
    else
    {
        result = 0;
        TRC_ERR((TB,_T("_ImmGetIMEFileName entry point not loaded")));
        DC_QUIT;
    }
#else //UNIWRAP
    //
    // Call needs to go thru a unicode wrapper
    // pass both the Wide and Ansi entry points to the wrapper
    //
    result = ImmGetIMEFileName_DynWrapW(hkl, szName, uBufLen,
                                        _UT.Imm32Dll.func._ImmGetIMEFileNameW,
                                        _UT.Imm32Dll.func._ImmGetIMEFileNameA);
#endif

DC_EXIT_POINT:
    DC_END_FN();
    return result;
}

#if ! defined (OS_WINCE)
//
// Dynamic thunk for IMPGetIME
//
//
BOOL CUT::UT_IMPGetIME( IN HWND hwnd, OUT LPIMEPRO pImePro)
{
    BOOL fRes = FALSE;
    DC_BEGIN_FN("UT_IMPGetIME");

#ifndef UNIWRAP
    //
    // Not using a unicode wrapper make direct calls to the
    // appropriate entry points
    // 
    #ifdef  UNICODE
    if (_UT.WinnlsDll.func._IMPGetIMEW)
    {
        fRes = _UT.WinnlsDll.func._IMPGetIMEW(hwnd, pImePro);
    }
    #else
    if (_UT.WinnlsDll.func._IMPGetIMEA)
    {
        fRes = _UT.WinnlsDll.func._IMPGetIMEA(hwnd, pImePro);
    }
    #endif
    else
    {
        fRes = FALSE;
        TRC_ERR((TB,_T("_IMPGetIMEA entry point not loaded")));
        DC_QUIT;
    }
#else //UNIWRAP
    //
    // Call needs to go thru a unicode wrapper
    // pass both the Wide and Ansi entry points to the wrapper
    //
    fRes = ImpGetIME_DynWrapW(hwnd, pImePro,
                              _UT.WinnlsDll.func._IMPGetIMEW,
                              _UT.WinnlsDll.func._IMPGetIMEA);
#endif


DC_EXIT_POINT:
    DC_END_FN();
    return fRes;
}

//
// Get and return the palette for the bitmap
//
// Params:
//  hDCSrc  - src DC to base palette on
//  hBitmap - bitmap to get palette from
//
// Returns:
//  Handle to palette - caller must delete
//
HPALETTE CUT::UT_GetPaletteForBitmap(HDC hDCSrc, HBITMAP hBitmap)
{
    HPALETTE hPal = NULL;
    HDC hDCMem = NULL;
    HBITMAP hbmSrcOld = NULL;
    INT nCol = 0;
    LPLOGPALETTE pLogPalette = NULL;
    RGBQUAD rgb[256];

    DC_BEGIN_FN("UT_GetPaletteForBitmap");

    hDCMem = CreateCompatibleDC(hDCSrc);

    if (hDCMem) {

        hbmSrcOld = (HBITMAP)SelectObject(hDCMem, hBitmap);
        nCol = GetDIBColorTable(hDCMem, 0, 256, rgb);
        if (256 == nCol) {
            pLogPalette = (LPLOGPALETTE)LocalAlloc(LPTR,
                            sizeof(LOGPALETTE)*(sizeof(PALETTEENTRY)*256));
            if (pLogPalette)
            {
                pLogPalette->palVersion = 0x0300;
                pLogPalette->palNumEntries = 256;

                for (INT i=0; i<256; i++)
                {
                    pLogPalette->palPalEntry[i].peRed =  rgb[i].rgbRed;
                    pLogPalette->palPalEntry[i].peGreen = rgb[i].rgbGreen;
                    pLogPalette->palPalEntry[i].peBlue = rgb[i].rgbBlue;
                    pLogPalette->palPalEntry[i].peFlags = 0;
                }

                hPal = CreatePalette(pLogPalette);
                LocalFree(pLogPalette);
                pLogPalette = NULL;
            }
        }
        else {
            TRC_ALT((TB,_T("Did not get 256 color table entires!")));
        }

        if (hbmSrcOld) {
            SelectObject(hDCMem, hbmSrcOld);
        }

        DeleteDC(hDCMem);
    }

    DC_END_FN();
    return hPal;
}
#endif //OS_WINCE

//
// Safer generic string property put function.
//
// Does length validation before writing the string so that
// in the failure case we don't leave partially written
// property strings (even though they would still be NULL terminated).
//
// Params:
//      szDestString    - string to write to
//      cchDestLen      - destination length in characters (TCHARS)
//      szSourceString  - the source string
//
// Returns:
//      HRESULT
//
HRESULT
CUT::StringPropPut(
            LPTSTR szDestString,
            UINT   cchDestLen,
            LPTSTR szSourceString
            )
{
    HRESULT hr = E_FAIL;
    DC_BEGIN_FN("StringPropPut");

    if (szDestString && szSourceString) {

        if (_tcslen(szSourceString) <= (cchDestLen - 1)) {
            hr = StringCchCopy(szDestString,
                               cchDestLen,
                               szSourceString);
        }
        else {
            hr = E_INVALIDARG;
        }
    }
    else {
        hr = E_INVALIDARG;
    }

    DC_END_FN();
    return hr;
}