windows-xp/Source/XPSP1/NT/termsrv/sessdir/tssdsql/tssdsql.cpp

/****************************************************************************/
// tssdsql.cpp
//
// Terminal Server Session Directory Interface common component code.
//
// Copyright (C) 2000 Microsoft Corporation
/****************************************************************************/

#include <windows.h>
#include <stdio.h>
#include <process.h>

#include <ole2.h>
#include <objbase.h>
#include <comdef.h>
#include <adoid.h>
#include <adoint.h>
#include <regapi.h>
#include "tssdsql.h"
#include "trace.h"
#include "resource.h"


/****************************************************************************/
// Types
/****************************************************************************/

// Shortcut VARIANT class to handle cleanup on destruction and common code
// inlining.
class CVar : public VARIANT
{
public:
    CVar() { VariantInit(this); }
    CVar(VARTYPE vt, SCODE scode = 0) {
        VariantInit(this);
        this->vt = vt;
        this->scode = scode;
    }
    CVar(VARIANT var) { *this = var; }
    ~CVar() { VariantClear(this); }

    void InitNull() { this->vt = VT_NULL; }
    void InitFromLong(long L) { this->vt = VT_I4; this->lVal = L; }
    void InitNoParam() {
        this->vt = VT_ERROR;
        this->lVal = DISP_E_PARAMNOTFOUND;
    }

    HRESULT InitFromWSTR(PCWSTR WStr) {
        this->bstrVal = SysAllocString(WStr);
        if (this->bstrVal != NULL) {
            this->vt = VT_BSTR;
            return S_OK;
        }
        else {
            return E_OUTOFMEMORY;
        }
    }

    // Inits from a non-NULL-terminated set of WCHARs.
    HRESULT InitFromWChars(WCHAR *WChars, unsigned Len) {
        this->bstrVal = SysAllocStringLen(WChars, Len);
        if (this->bstrVal != NULL) {
            this->vt = VT_BSTR;
            return S_OK;
        }
        else {
            return E_OUTOFMEMORY;
        }
    }

    HRESULT InitEmptyBSTR(unsigned Size) {
        this->bstrVal = SysAllocStringLen(L"", Size);
        if (this->bstrVal != NULL) {
            this->vt = VT_BSTR;
            return S_OK;
        }
        else {
            return E_OUTOFMEMORY;
        }
    }

    HRESULT Clear() { return VariantClear(this); }
};


/****************************************************************************/
// Prototypes
/****************************************************************************/
INT_PTR CALLBACK CustomUIDlg(HWND, UINT, WPARAM, LPARAM);
void FindSqlValue(LPTSTR, LPTSTR, LPTSTR);
LPTSTR ModifySqlValue( LPTSTR * , LPTSTR , LPTSTR );
LPTSTR FindField( LPTSTR pszString , LPTSTR pszKeyName );
VOID strtrim( TCHAR **pszStr);

/****************************************************************************/
// Globals
/****************************************************************************/
extern HINSTANCE g_hInstance;

// The COM object counter (declared in server.cpp)
extern long g_lObjects;


/****************************************************************************/
// CTSSessionDirectory::CTSSessionDirectory
// CTSSessionDirectory::~CTSSessionDirectory
//
// Constructor and destructor
/****************************************************************************/
CTSSessionDirectory::CTSSessionDirectory() :
        m_RefCount(0), m_pConnection(NULL)
{
    InterlockedIncrement(&g_lObjects);

    m_LocalServerAddress[0] = L'\0';
    m_DBConnectStr = NULL;
    m_DBPwdStr = NULL;
    m_DBUserStr = NULL;
    m_fEnabled = 0;

    m_pszOpaqueString = NULL;
    
}

CTSSessionDirectory::~CTSSessionDirectory()
{
    HRESULT hr;

    // If the database connection exists, release it.
    if (m_pConnection != NULL) {
        hr = ExecServerOffline();
        if (FAILED(hr)) {
            ERR((TB,"Destr: ExecSvrOffline failed, hr=0x%X", hr));
        }
        hr = m_pConnection->Close();
        if (FAILED(hr)) {
            ERR((TB,"pConn->Close() failed, hr=0x%X", hr));
        }
        m_pConnection->Release();
        m_pConnection = NULL;
    }

    // Decrement the global COM object counter
    InterlockedDecrement(&g_lObjects);

    if (m_DBConnectStr != NULL)
        SysFreeString(m_DBConnectStr);
    if (m_DBPwdStr != NULL)
        SysFreeString(m_DBPwdStr);
    if (m_DBUserStr != NULL)
        SysFreeString(m_DBUserStr);
}


/****************************************************************************/
// CTSSessionDirectory::QueryInterface
//
// Standard COM IUnknown function.
/****************************************************************************/
HRESULT STDMETHODCALLTYPE CTSSessionDirectory::QueryInterface(
        REFIID riid,
        void **ppv)
{
    if (riid == IID_IUnknown) {
        *ppv = (LPVOID)(IUnknown *)(ITSSessionDirectory *)this;
    }
    else if (riid == IID_ITSSessionDirectory) {
        *ppv = (LPVOID)(ITSSessionDirectory *)this;
    }
    else if (riid == IID_IExtendServerSettings) {
        *ppv = (LPVOID)(IExtendServerSettings *)this;
    }
    else {
        ERR((TB,"QI: Unknown interface"));
        return E_NOINTERFACE;
    }

    ((IUnknown *)*ppv)->AddRef();
    return S_OK;
}


/****************************************************************************/
// CTSSessionDirectory::AddRef
//
// Standard COM IUnknown function.
/****************************************************************************/
ULONG STDMETHODCALLTYPE CTSSessionDirectory::AddRef()
{
    return InterlockedIncrement(&m_RefCount);
}


/****************************************************************************/
// CTSSessionDirectory::Release
//
// Standard COM IUnknown function.
/****************************************************************************/
ULONG STDMETHODCALLTYPE CTSSessionDirectory::Release()
{
    long lRef = InterlockedDecrement(&m_RefCount);

    if (lRef == 0)
        delete this;
    return lRef;
}


/****************************************************************************/
// CTSSessionDirectory::Initialize
//
// ITSSessionDirectory function. Called soon after object instantiation to
// intiialize the directory. LocalServerAddress provides a text representation
// of the local server's load balance IP address. This information should be
// used as the server IP address in the session directory for client
// redirection by other pool servers to this server. StoreServerName,
// ClusterName, and OpaqueSettings are generic reg entries known to TermSrv
// which cover config info across any type of session directory
// implementation. The contents of these strings are designed to be parsed
// by the session directory providers.
/****************************************************************************/
HRESULT STDMETHODCALLTYPE CTSSessionDirectory::Initialize(
        LPWSTR LocalServerAddress,
        LPWSTR StoreServerName,
        LPWSTR ClusterName,
        LPWSTR OpaqueSettings,
        DWORD Flags,
        DWORD (*repopfn)())
{
    HRESULT hr = S_OK;
    unsigned Len;
    WCHAR *pSearch;
    WCHAR ConnectString[384];

    ASSERT((LocalServerAddress != NULL),(TB,"Init: LocalServerAddr null!"));
    ASSERT((StoreServerName != NULL),(TB,"Init: StoreServerName null!"));
    ASSERT((ClusterName != NULL),(TB,"Init: ClusterName null!"));
    ASSERT((OpaqueSettings != NULL),(TB,"Init: OpaqueSettings null!"));

    // Copy off the server address and cluster name for later use.
    wcsncpy(m_LocalServerAddress, LocalServerAddress,
            sizeof(m_LocalServerAddress) / sizeof(WCHAR) - 1);
    m_LocalServerAddress[sizeof(m_LocalServerAddress) / sizeof(WCHAR) - 1] =
            L'\0';
    wcsncpy(m_ClusterName, ClusterName,
            sizeof(m_ClusterName) / sizeof(WCHAR) - 1);
    m_ClusterName[sizeof(m_ClusterName) / sizeof(WCHAR) - 1] = L'\0';

    // Create the SQL connect string using the OpaqueSettings string
    // (which should contain some of the conn str including SQL security
    // username and password, sub-table names, provider type, etc.).
    // We add onto the end a semicolon (if not already present) and the
    // data source (from StoreServerName), if the "data source" substring
    // is not already in the connect string.
    pSearch = OpaqueSettings;
    while (*pSearch != L'\0') {
        if (*pSearch == L'D' || *pSearch == L'd') {
            if (!_wcsnicmp(pSearch, L"data source", wcslen(L"data source"))) {
                // Transfer the OpaqueSettings string as a whole to become
                // the connect str.
                wcscpy(ConnectString, OpaqueSettings);
                goto PostConnStrSetup;
            }
        }
        pSearch++;
    }

    Len = wcslen(OpaqueSettings);
    if (Len == 0 || OpaqueSettings[Len - 1] == L';')
        wsprintfW(ConnectString, L"%sData Source=%s", OpaqueSettings,
                StoreServerName);
    else
        wsprintfW(ConnectString, L"%s;Data Source=%s", OpaqueSettings,
                StoreServerName);

PostConnStrSetup:
    TRC1((TB,"Initialize: Svr addr=%S, StoreSvrName=%S, ClusterName=%S, "
            "OpaqueSettings=%S, final connstr=%S",
            m_LocalServerAddress, StoreServerName, m_ClusterName,
            OpaqueSettings, ConnectString));

    // Alloc the BSTRs for the connection strings.
    m_DBConnectStr = SysAllocString(ConnectString);
    if (m_DBConnectStr != NULL) {
        m_DBUserStr = SysAllocString(L"");
        if (m_DBUserStr != NULL) {
            m_DBPwdStr = SysAllocString(L"");
            if (m_DBPwdStr == NULL) {
                ERR((TB,"Failed alloc bstr for pwdstr"));
                goto ExitFunc;
            }
        }
        else {
            ERR((TB,"Failed alloc bstr for userstr"));
            goto ExitFunc;
        }
    }
    else {
        ERR((TB,"Failed alloc bstr for connstr"));
        goto ExitFunc;
    }

    // Create an ADO connection instance and connect.
    hr = CoCreateInstance(CLSID_CADOConnection, NULL,
            CLSCTX_INPROC_SERVER, IID_IADOConnection,
            (LPVOID *)&m_pConnection);
    if (SUCCEEDED(hr)) {
        // Set the connection timeout to only 8 seconds. Standard is 15
        // but we don't want to be holding up TermSrv's initialization.
        m_pConnection->put_ConnectionTimeout(8);

        // Do the open.
        hr = OpenConnection();
        if (SUCCEEDED(hr)) {
            // Signal the server is online.
            hr = ExecServerOnline();
        }
        else {
            m_pConnection->Release();
            m_pConnection = NULL;
        }
    }
    else {
        ERR((TB,"CoCreate(ADOConn) returned 0x%X", hr));
    }

ExitFunc:
    return hr;
}


HRESULT STDMETHODCALLTYPE CTSSessionDirectory::Update(
        LPWSTR LocalServerAddress,
        LPWSTR StoreServerName,
        LPWSTR ClusterName,
        LPWSTR OpaqueSettings,
        DWORD Flags)
{
    return E_NOTIMPL;
}


/****************************************************************************/
// CTSSessionDirectory::OpenConnection
//
// Opens the connection to the SQL server based on the pre-existing
// connect string and allocated connection. This is called at init time,
// plus whenever the database connection times out and gets closed, but is
// still required 
/****************************************************************************/
HRESULT CTSSessionDirectory::OpenConnection()
{
    HRESULT hr;

    ASSERT((m_pConnection != NULL),(TB,"OpenConn: NULL pconn"));
    ASSERT((m_DBConnectStr != NULL),(TB,"OpenConn: NULL connstr"));
    ASSERT((m_DBUserStr != NULL),(TB,"OpenConn: NULL userstr"));
    ASSERT((m_DBPwdStr != NULL),(TB,"OpenConn: NULL pwdstr"));

    hr = m_pConnection->Open(m_DBConnectStr, m_DBUserStr, m_DBPwdStr,
            adOpenUnspecified);
    if (FAILED(hr)) {
        ERR((TB,"OpenConn: Failed open DB, connstring=%S, hr=0x%X",
                m_DBConnectStr, hr));
    }

    return hr;
}


/****************************************************************************/
// GetRowArrayStringField
//
// Retrieves a WSTR from a specified row and field of the given SafeArray.
// Returns failure if the target field is not a string. MaxOutStr is max
// WCHARs not including NULL.
/****************************************************************************/
HRESULT GetRowArrayStringField(
        SAFEARRAY *pSA,
        unsigned RowIndex,
        unsigned FieldIndex,
        WCHAR *OutStr,
        unsigned MaxOutStr)
{
    HRESULT hr;
    CVar varField;
    long DimIndices[2];

    DimIndices[0] = FieldIndex;
    DimIndices[1] = RowIndex;
    SafeArrayGetElement(pSA, DimIndices, &varField);

    if (varField.vt == VT_BSTR) {
        wcsncpy(OutStr, varField.bstrVal, MaxOutStr);
        hr = S_OK;
    }
    else if (varField.vt == VT_NULL) {
        OutStr[0] = L'\0';
        hr = S_OK;
    }
    else {
        ERR((TB,"GetRowStrField: Row %u Col %u value %d is not a string",
                RowIndex, FieldIndex, varField.vt));
        hr = E_FAIL;
    }

    return hr;
}


/****************************************************************************/
// GetRowArrayDWORDField
//
// Retrieves a DWORD from a specified row and field of the given SafeArray.
// Returns failure if the target field is not a 4-byte integer.
/****************************************************************************/
HRESULT GetRowArrayDWORDField(
        SAFEARRAY *pSA,
        unsigned RowIndex,
        unsigned FieldIndex,
        DWORD *pOutValue)
{
    HRESULT hr;
    CVar varField;
    long DimIndices[2];

    DimIndices[0] = FieldIndex;
    DimIndices[1] = RowIndex;
    SafeArrayGetElement(pSA, DimIndices, &varField);

    if (varField.vt == VT_I4) {
        *pOutValue = (DWORD)varField.lVal;
        hr = S_OK;
    }
    else if (varField.vt == VT_NULL) {
        *pOutValue = 0;
        hr = S_OK;
    }
    else {
        ERR((TB,"GetRowDWField: Row %u Col %u value %d is not a VT_I4",
                RowIndex, FieldIndex, varField.vt));
        hr = E_FAIL;
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::GetUserDisconnectedSessions
//
// Called to perform a query against the session directory, to provide the
// list of disconnected sessions for the provided username and domain.
// Returns zero or more TSSD_DisconnectedSessionInfo blocks in SessionBuf.
// *pNumSessionsReturned receives the number of blocks.
/****************************************************************************/
#define NumOutputFields 11

HRESULT STDMETHODCALLTYPE CTSSessionDirectory::GetUserDisconnectedSessions(
        LPWSTR UserName,
        LPWSTR Domain,
        DWORD __RPC_FAR *pNumSessionsReturned,
        TSSD_DisconnectedSessionInfo __RPC_FAR SessionBuf[
            TSSD_MaxDisconnectedSessions])
{
    DWORD NumSessions = 0;
    long State;
    long NumRecords;
    HRESULT hr;
    unsigned i, j;
    unsigned NumFailed;
    TSSD_DisconnectedSessionInfo *pInfo;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;
    ADOFields *pFields;
    CVar varRows;
    CVar varFields;
    CVar varStart;
    HRESULT hrFields[NumOutputFields];

    TRC2((TB,"GetUserDisconnectedSessions"));

    ASSERT((pNumSessionsReturned != NULL),(TB,"NULL pNumSess"));
    ASSERT((SessionBuf != NULL),(TB,"NULL SessionBuf"));

    hr = CreateADOStoredProcCommand(L"SP_TSSDGetUserDisconnectedSessions",
            &pCommand, &pParameters);
    if (SUCCEEDED(hr)) {
        hr = AddADOInputStringParam(UserName, L"UserName", pCommand,
                pParameters, FALSE);
        if (SUCCEEDED(hr)) {
            hr = AddADOInputStringParam(Domain, L"Domain", pCommand,
                    pParameters, FALSE);
            if (SUCCEEDED(hr)) {
                hr = AddADOInputDWORDParam(m_ClusterID, L"ClusterID",
                        pCommand, pParameters);
                if (SUCCEEDED(hr)) {
                    // Execute the command.
                    hr = pCommand->Execute(NULL, NULL, adCmdStoredProc,
                            &pResultRecordSet);
                    if (FAILED(hr)) {
                        // If we've not used the connection for awhile, it
                        // might have been disconnected and the connection
                        // object will be invalid. Attempt a reopen then
                        // reissue the command.
                        TRC2((TB,"GetUserDisc: Failed cmd, hr=0x%X, retrying",
                                hr));
                        m_pConnection->Close();
                        hr = OpenConnection();
                        if (SUCCEEDED(hr)) {
                            hr = pCommand->Execute(NULL, NULL,
                                    adCmdStoredProc, &pResultRecordSet);
                            if (FAILED(hr)) {
                                ERR((TB,"GetUserDisc: Failed cmd, hr=0x%X",
                                        hr));
                            }
                        }
                        else {
                            ERR((TB,"GetUserDisc: Failed reopen conn, hr=0x%X",
                                    hr));
                        }
                    }
                }
                else {
                    ERR((TB,"GetUserDisc: Failed add cluster, hr=0x%X", hr));
                }
            }
            else {
                ERR((TB,"GetUserDisc: Failed add sessid, hr=0x%X", hr));
            }
        }
        else {
            ERR((TB,"GetUserDisc: Failed add svraddr, hr=0x%X", hr));
        }

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"GetUserDisc: Failed create cmd, hr=0x%X", hr));
    }
        
    // At this point we have a result recordset containing the server rows
    // corresponding to all of the disconnected sessions.
    if (SUCCEEDED(hr)) {
        long State;

        NumSessions = 0;

        hr = pResultRecordSet->get_State(&State);
        if (SUCCEEDED(hr)) {
            if (!(State & adStateClosed)) {
                VARIANT_BOOL VB;

                // If EOF the recordset is empty.
                hr = pResultRecordSet->get_EOF(&VB);
                if (SUCCEEDED(hr)) {
                    if (VB) {
                        TRC1((TB,"GetUserDisc: Result recordset EOF, 0 rows"));
                        goto PostUnpackResultSet;
                    }
                }
                else {
                    ERR((TB,"GetUserDisc: Failed get_EOF, hr=0x%X", hr));
                    goto PostUnpackResultSet;
                }
            }
            else {
                ERR((TB,"GetUserDisc: Closed result recordset"));
                goto PostUnpackResultSet;
            }
        }
        else {
            ERR((TB,"GetUserDisc: get_State failed, hr=0x%X", hr));
            goto PostUnpackResultSet;
        }

        // Grab the result data into a safearray, starting with the default
        // current row and all fields.
        varStart.InitNoParam();
        varFields.InitNoParam();
        hr = pResultRecordSet->GetRows(TSSD_MaxDisconnectedSessions, varStart,
                varFields, &varRows);
        if (SUCCEEDED(hr)) {
            NumRecords = 0;
            hr = SafeArrayGetUBound(varRows.parray, 2, &NumRecords);
            if (SUCCEEDED(hr)) {
                // 0-based array bound was returned, num rows is that + 1.
                NumRecords++;
                ASSERT((NumRecords <= TSSD_MaxDisconnectedSessions),
                        (TB,"GetUserDisc: NumRecords %u greater than expected %u",
                        NumRecords, TSSD_MaxDisconnectedSessions));

                TRC1((TB,"%d rows retrieved from safearray", NumRecords));
            }
            else {
                ERR((TB,"GetUserDisc: Failed safearray getubound, hr=0x%X", hr));
                goto PostUnpackResultSet;
            }
        }
        else {
            ERR((TB,"GetUserDisc: Failed to get rows, hr=0x%X", hr));
            goto PostUnpackResultSet;
        }

        // Loop through and get the contents of each row, translating into
        // the output DiscSession structs.
        pInfo = SessionBuf;
        for (i = 0; i < (unsigned)NumRecords; i++) {
            // Stack up the hr's for each field before checking them all.
            hrFields[0] = GetRowArrayStringField(varRows.parray, i, 0,
                    pInfo->ServerAddress, sizeof(pInfo->ServerAddress) /
                    sizeof(TCHAR) - 1);
            hrFields[1] = GetRowArrayDWORDField(varRows.parray, i, 1,
                    &pInfo->SessionID);
            hrFields[2] = GetRowArrayDWORDField(varRows.parray, i, 2,
                    &pInfo->TSProtocol);
            hrFields[3] = GetRowArrayStringField(varRows.parray, i, 7,
                    pInfo->ApplicationType, sizeof(pInfo->ApplicationType) /
                    sizeof(TCHAR) - 1);
            hrFields[4] = GetRowArrayDWORDField(varRows.parray, i, 8,
                    &pInfo->ResolutionWidth);
            hrFields[5] = GetRowArrayDWORDField(varRows.parray, i, 9,
                    &pInfo->ResolutionHeight);
            hrFields[6] = GetRowArrayDWORDField(varRows.parray, i, 10,
                    &pInfo->ColorDepth);
            hrFields[7] = GetRowArrayDWORDField(varRows.parray, i, 3,
                    &pInfo->CreateTime.dwLowDateTime);
            hrFields[8] = GetRowArrayDWORDField(varRows.parray, i, 4,
                    &pInfo->CreateTime.dwHighDateTime);
            hrFields[9] = GetRowArrayDWORDField(varRows.parray, i, 5,
                    &pInfo->DisconnectionTime.dwLowDateTime);
            hrFields[10] = GetRowArrayDWORDField(varRows.parray, i, 6,
                    &pInfo->DisconnectionTime.dwHighDateTime);

            NumFailed = 0;
            for (j = 0; j < NumOutputFields; j++) {
                if (SUCCEEDED(hrFields[j])) {
                    continue;
                }
                else {
                    ERR((TB,"GetUserDisc: Row %u field %u returned hr=0x%X",
                            i, j, hrFields[j]));
                    NumFailed++;
                }
            }
            if (!NumFailed) {
                NumSessions++;
                pInfo++;
            }
        }


PostUnpackResultSet:
        pResultRecordSet->Release();
    }
    else {
        ERR((TB,"GetUserDisc: Failed exec, hr=0x%X", hr));
    }

    *pNumSessionsReturned = NumSessions;
    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::NotifyCreateLocalSession
//
// ITSSessionDirectory function. Called when a session is created to add the
// session to the session directory. Note that other interface functions
// access the session directory by either the username/domain or the
// session ID; the directory schema should take this into account for
// performance optimization.
/****************************************************************************/
#define NumCreateParams 11

HRESULT STDMETHODCALLTYPE CTSSessionDirectory::NotifyCreateLocalSession(
        TSSD_CreateSessionInfo __RPC_FAR *pCreateInfo)
{
    unsigned i, NumFailed;
    HRESULT hr;
    HRESULT hrParam[NumCreateParams];
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;

    TRC2((TB,"NotifyCreateLocalSession, SessID=%u", pCreateInfo->SessionID));

    ASSERT((pCreateInfo != NULL),(TB,"NotifyCreate: NULL CreateInfo"));

    hr = CreateADOStoredProcCommand(L"SP_TSSDCreateSession", &pCommand,
            &pParameters);
    if (SUCCEEDED(hr)) {
        // Create and add the params in one fell swoop. We'll check all
        // of the return values in a batch later.
        hrParam[0] = AddADOInputStringParam(pCreateInfo->UserName,
                L"UserName", pCommand, pParameters, FALSE);
        hrParam[1] = AddADOInputStringParam(pCreateInfo->Domain,
                L"Domain", pCommand, pParameters, FALSE);
        hrParam[2] = AddADOInputDWORDParam(m_ServerID,
                L"ServerID", pCommand, pParameters);
        hrParam[3] = AddADOInputDWORDParam(pCreateInfo->SessionID,
                L"SessionID", pCommand, pParameters);
        hrParam[4] = AddADOInputDWORDParam(pCreateInfo->TSProtocol,
                L"TSProtocol", pCommand, pParameters);
        hrParam[5] = AddADOInputStringParam(pCreateInfo->ApplicationType,
                L"AppType", pCommand, pParameters);
        hrParam[6] = AddADOInputDWORDParam(pCreateInfo->ResolutionWidth,
                L"ResolutionWidth", pCommand, pParameters);
        hrParam[7] = AddADOInputDWORDParam(pCreateInfo->ResolutionHeight,
                L"ResolutionHeight", pCommand, pParameters);
        hrParam[8] = AddADOInputDWORDParam(pCreateInfo->ColorDepth,
                L"ColorDepth", pCommand, pParameters);
        hrParam[9] = AddADOInputDWORDParam(pCreateInfo->CreateTime.dwLowDateTime,
                L"CreateTimeLow", pCommand, pParameters);
        hrParam[10] = AddADOInputDWORDParam(pCreateInfo->CreateTime.dwHighDateTime,
                L"CreateTimeHigh", pCommand, pParameters);

        NumFailed = 0;
        for (i = 0; i < NumCreateParams; i++) {
            if (SUCCEEDED(hrParam[i])) {
                continue;
            }
            else {
                ERR((TB,"NotifyCreate: Failed param create %u", i));
                NumFailed++;
                hr = hrParam[i];
            }
        }
        if (NumFailed == 0) {
            // Execute the command.
            hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                    adExecuteNoRecords, &pResultRecordSet);
            if (FAILED(hr)) {
                // If we've not used the connection for awhile, it might
                // have been disconnected and the connection object will
                // be invalid. Attempt a reopen then reissue the command.
                TRC2((TB,"NotifyCreate: Failed cmd, hr=0x%X, retrying",
                        hr));
                m_pConnection->Close();
                hr = OpenConnection();
                if (SUCCEEDED(hr)) {
                    hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                            adExecuteNoRecords, &pResultRecordSet);
                    if (FAILED(hr)) {
                        ERR((TB,"NotifyCreate: Failed exec, hr=0x%X", hr));
                    }
                }
                else {
                    ERR((TB,"NotifyCreate: Failed reopen conn, hr=0x%X",
                            hr));
                }
            }
        }

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"NotifyCreate: Failed create cmd, hr=0x%X", hr));
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::NotifyDestroyLocalSession
//
// ITSSessionDirectory function. Removes a session from the session database.
/****************************************************************************/
HRESULT STDMETHODCALLTYPE CTSSessionDirectory::NotifyDestroyLocalSession(
        DWORD SessionID)
{
    HRESULT hr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;

    TRC2((TB,"NotifyDestroyLocalSession, SessionID=%u", SessionID));

    hr = CreateADOStoredProcCommand(L"SP_TSSDDeleteSession", &pCommand,
            &pParameters);
    if (SUCCEEDED(hr)) {
        hr = AddADOInputDWORDParam(m_ServerID, L"ServerID",
                pCommand, pParameters);
        if (SUCCEEDED(hr)) {
            hr = AddADOInputDWORDParam(SessionID, L"SessionID", pCommand,
                    pParameters);
            if (SUCCEEDED(hr)) {
                // Execute the command.
                hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                        adExecuteNoRecords, &pResultRecordSet);
                if (FAILED(hr)) {
                    // If we've not used the connection for awhile, it might
                    // have been disconnected and the connection object will
                    // be invalid. Attempt a reopen then reissue the command.
                    TRC2((TB,"NotifyDestroy: Failed cmd, hr=0x%X, retrying",
                            hr));
                    m_pConnection->Close();
                    hr = OpenConnection();
                    if (SUCCEEDED(hr)) {
                        hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                                adExecuteNoRecords, &pResultRecordSet);
                        if (FAILED(hr)) {
                            ERR((TB,"NotifyDestroy: Failed exec, hr=0x%X", hr));
                        }
                    }
                    else {
                        ERR((TB,"NotifyDestroy: Failed reopen conn, hr=0x%X",
                                hr));
                    }
                }
            }
            else {
                ERR((TB,"NotifyDestroy: Failed add sessid, hr=0x%X", hr));
            }
        }
        else {
            ERR((TB,"NotifyDestroy: Failed add svraddr, hr=0x%X", hr));
        }

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"NotifyDestroy: Failed create cmd, hr=0x%X", hr));
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::NotifyDisconnectLocalSession
//
// ITSSessionDirectory function. Changes the state of an existing session to
// disconnected. The provided time should be returned in disconnected session
// queries performed by any machine in the server pool.
/****************************************************************************/
HRESULT STDMETHODCALLTYPE CTSSessionDirectory::NotifyDisconnectLocalSession(
        DWORD SessionID,
        FILETIME DiscTime)
{
    HRESULT hr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;

    TRC2((TB,"NotifyDisconnectLocalSession, SessionID=%u", SessionID));

    hr = CreateADOStoredProcCommand(L"SP_TSSDSetSessionDisconnected",
            &pCommand, &pParameters);
    if (SUCCEEDED(hr)) {
        hr = AddADOInputDWORDParam(m_ServerID, L"ServerID",
                pCommand, pParameters);
        if (SUCCEEDED(hr)) {
            hr = AddADOInputDWORDParam(SessionID, L"SessionID", pCommand,
                    pParameters);
            if (SUCCEEDED(hr)) {
                hr = AddADOInputDWORDParam(DiscTime.dwLowDateTime,
                        L"DiscTimeLow", pCommand, pParameters);
                if (SUCCEEDED(hr)) {
                    hr = AddADOInputDWORDParam(DiscTime.dwHighDateTime,
                            L"DiscTimeHigh", pCommand, pParameters);
                    if (SUCCEEDED(hr)) {
                        // Execute the command.
                        hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                                adExecuteNoRecords, &pResultRecordSet);
                        if (FAILED(hr)) {
                            // If we've not used the connection for awhile, it
                            // might have been disconnected and the connection
                            // object will be invalid. Attempt a reopen then
                            // reissue the command.
                            TRC2((TB,"NotifyDisc: Failed cmd, hr=0x%X, "
                                    "retrying", hr));
                            m_pConnection->Close();
                            hr = OpenConnection();
                            if (SUCCEEDED(hr)) {
                                hr = pCommand->Execute(NULL, NULL,
                                        adCmdStoredProc | adExecuteNoRecords,
                                        &pResultRecordSet);
                                if (FAILED(hr)) {
                                    ERR((TB,"NotifyDisc: Failed exec, hr=0x%X",
                                            hr));
                                }
                            }
                            else {
                                ERR((TB,"NotifyDisc: Failed reopen conn, "
                                        "hr=0x%X", hr));
                            }
                        }
                    }
                    else {
                        ERR((TB,"NotifyDisconn: Failed add disctimehigh, "
                                "hr=0x%X", hr));
                    }
                }
                else {
                    ERR((TB,"NotifyDisconn: Failed add disctimelow, hr=0x%X",
                            hr));
                }
            }
            else {
                ERR((TB,"NotifyDisconn: Failed add sessid, hr=0x%X", hr));
            }
        }
        else {
            ERR((TB,"NotifyDisconn: Failed add svraddr, hr=0x%X", hr));
        }

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"NotifyDisconn: Failed create cmd, hr=0x%X", hr));
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::NotifyReconnectLocalSession
//
// ITSSessionDirectory function. Changes the state of an existing session
// from disconnected to connected.
/****************************************************************************/
#define NumReconnParams 6

HRESULT STDMETHODCALLTYPE CTSSessionDirectory::NotifyReconnectLocalSession(
        TSSD_ReconnectSessionInfo __RPC_FAR *pReconnInfo)
{
    HRESULT hr;
    HRESULT hrParam[NumReconnParams];
    unsigned i, NumFailed;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;

    TRC2((TB,"NotifyReconnectLocalSession, SessionID=%u",
            pReconnInfo->SessionID));

    hr = CreateADOStoredProcCommand(L"SP_TSSDSetSessionReconnected",
            &pCommand, &pParameters);
    if (SUCCEEDED(hr)) {
        // Add the 5 parameters.
        hrParam[0] = AddADOInputDWORDParam(m_ServerID,
                L"ServerID", pCommand, pParameters);
        hrParam[1] = AddADOInputDWORDParam(pReconnInfo->SessionID,
                L"SessionID", pCommand, pParameters);
        hrParam[2] = AddADOInputDWORDParam(pReconnInfo->TSProtocol,
                L"TSProtocol", pCommand, pParameters);
        hrParam[3] = AddADOInputDWORDParam(pReconnInfo->ResolutionWidth,
                L"ResWidth", pCommand, pParameters);
        hrParam[4] = AddADOInputDWORDParam(pReconnInfo->ResolutionHeight,
                L"ResHeight", pCommand, pParameters);
        hrParam[5] = AddADOInputDWORDParam(pReconnInfo->ColorDepth,
                L"ColorDepth", pCommand, pParameters);
                
        NumFailed = 0;
        for (i = 0; i < NumReconnParams; i++) {
            if (SUCCEEDED(hrParam[i])) {
                continue;
            }
            else {
                ERR((TB,"NotifyReconn: Failed param create %u", i));
                NumFailed++;
                hr = hrParam[i];
            }
        }
        if (NumFailed == 0) {
            // Execute the command.
            hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                    adExecuteNoRecords, &pResultRecordSet);
            if (FAILED(hr)) {
                // If we've not used the connection for awhile, it might
                // have been disconnected and the connection object will
                // be in a bad state. Close, reopen, and reissue the
                // command.
                TRC2((TB,"NotifyReconn: Failed exec, hr=0x%X, retrying",
                        hr));
                m_pConnection->Close();
                hr = OpenConnection();
                if (SUCCEEDED(hr)) {
                    hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                            adExecuteNoRecords, &pResultRecordSet);
                    if (FAILED(hr)) {
                        ERR((TB,"NotifyReconn: Failed exec, hr=0x%X", hr));
                    }
                }
                else {
                    ERR((TB,"NotifyReconn: Failed reopen conn, hr=0x%X",
                            hr));
                }
            }
        }

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"NotifyReconn: Failed create cmd, hr=0x%X", hr));
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::NotifyReconnectPending
//
// ITSSessionDirectory function. Informs session directory that a reconnect
// is pending soon because of a revectoring.  Used by DIS to determine
// when a server might have gone down.  (DIS is the Directory Integrity
// Service, which runs on the machine with the session directory.)
//
// This is a two-phase procedure--we first check the fields, and then we
// add the timestamp only if there is no outstanding timestamp already (i.e., 
// the two Almost-In-Time fields are 0).  This prevents constant revectoring
// from updating the timestamp fields, which would prevent the DIS from 
// figuring out that a server is down.
//
// These two steps are done in the stored procedure to make the operation
// atomic.
/****************************************************************************/
#define NumReconPendParams 3

HRESULT STDMETHODCALLTYPE CTSSessionDirectory::NotifyReconnectPending(
        WCHAR *ServerName)
{
    HRESULT hr;
    HRESULT hrParam[NumReconPendParams];
    unsigned NumFailed, i;

    FILETIME ft;
    SYSTEMTIME st;
    
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;

    TRC2((TB,"NotifyReconnectPending"));

    ASSERT((ServerName != NULL),(TB,"NotifyReconnectPending: NULL ServerName"));

    // Get the current system time.
    GetSystemTime(&st);
    SystemTimeToFileTime(&st, &ft);

    // Call the stored procedure, which will update the fields if they are 0.
    hr = CreateADOStoredProcCommand(L"SP_TSSDSetServerReconnectPending",
            &pCommand, &pParameters);
    if (SUCCEEDED(hr)) {
        // Add the 3 parameters.
        hrParam[0] = AddADOInputStringParam(ServerName,
                L"ServerAddress", pCommand, pParameters, FALSE);
        hrParam[1] = AddADOInputDWORDParam(ft.dwLowDateTime,
                L"AlmostTimeLow", pCommand, pParameters);
        hrParam[2] = AddADOInputDWORDParam(ft.dwHighDateTime,
                L"AlmostTimeHigh", pCommand, pParameters);

        NumFailed = 0;
        for (i = 0; i < NumReconPendParams; i++) {
            if (SUCCEEDED(hrParam[i])) {
                continue;
            }
            else {
                ERR((TB,"NotifyReconPending: Failed param create %u", i));
                NumFailed++;
                hr = hrParam[i];
            }
        }
        if (NumFailed == 0) {
            // Execute the command.
            hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                    adExecuteNoRecords, &pResultRecordSet);
            if (FAILED(hr)) {
                // If we've not used the connection for awhile, it might
                // have been disconnected and the connection object will
                // be in a bad state. Close, reopen, and reissue the
                // command.
                TRC2((TB,"NotifyReconPending: Failed exec, hr=0x%X, retrying",
                        hr));
                m_pConnection->Close();
                hr = OpenConnection();
                if (SUCCEEDED(hr)) {
                    hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                            adExecuteNoRecords, &pResultRecordSet);
                    if (FAILED(hr)) {
                        ERR((TB,"NotifyReconPending: Failed exec, hr=0x%X", hr));
                    }
                }
                else {
                    ERR((TB,"NotifyReconPending: Failed reopen conn, hr=0x%X",
                            hr));
                }
            }
        }

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"NotifyReconnectPending: Failed create cmd, hr=0x%X", hr));
    }


    return hr;
}


HRESULT STDMETHODCALLTYPE CTSSessionDirectory::Repopulate(
        DWORD WinStationCount, 
        TSSD_RepopulateSessionInfo *rsi)
{
    return E_NOTIMPL;
}


/****************************************************************************/
// CreateADOStoredProcCommand
//
// Creates and returns a stored proc ADOCommand, plus a ref to its
// associated Parameters.
/****************************************************************************/
HRESULT CTSSessionDirectory::CreateADOStoredProcCommand(
        PWSTR CmdName,
        ADOCommand **ppCommand,
        ADOParameters **ppParameters)
{
    HRESULT hr;
    BSTR CmdStr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;

    CmdStr = SysAllocString(CmdName);
    if (CmdStr != NULL) {
        hr = CoCreateInstance(CLSID_CADOCommand, NULL, CLSCTX_INPROC_SERVER,
                IID_IADOCommand25, (LPVOID *)&pCommand);
        if (SUCCEEDED(hr)) {
            // Set the connection.
            hr = pCommand->putref_ActiveConnection(m_pConnection);
            if (SUCCEEDED(hr)) {
                // Set the command text.
                hr = pCommand->put_CommandText(CmdStr);
                if (SUCCEEDED(hr)) {
                    // Set the command type.
                    hr = pCommand->put_CommandType(adCmdStoredProc);
                    if (SUCCEEDED(hr)) {
                        // Get the Parameters pointer from the Command to
                        // allow appending params.
                        hr = pCommand->get_Parameters(&pParameters);
                        if (FAILED(hr)) {
                            ERR((TB,"Failed getParams for command, "
                                    "hr=0x%X", hr));
                            goto PostCreateCommand;
                        }
                    }
                    else {
                        ERR((TB,"Failed set cmdtype for command, hr=0x%X",
                                hr));
                        goto PostCreateCommand;
                    }
                }
                else {
                    ERR((TB,"Failed set cmdtext for command, hr=0x%X", hr));
                    goto PostCreateCommand;
                }
            }
            else {
                ERR((TB,"Command::putref_ActiveConnection hr=0x%X", hr));
                goto PostCreateCommand;
            }
        }
        else {
            ERR((TB,"CoCreate(Command) returned 0x%X", hr));
            goto PostAllocCmdStr;
        }

        SysFreeString(CmdStr);
    }
    else {
        ERR((TB,"Failed to alloc cmd str"));
        hr = E_OUTOFMEMORY;
        goto ExitFunc;
    }

    *ppCommand = pCommand;
    *ppParameters = pParameters;
    return hr;

// Error handling.

PostCreateCommand:
    pCommand->Release();

PostAllocCmdStr:
    SysFreeString(CmdStr);

ExitFunc:
    *ppCommand = NULL;
    *ppParameters = NULL;
    return hr;
}


/****************************************************************************/
// AddADOInputDWORDParam
//
// Creates and adds to the given ADOParameters object a DWORD-initialized
// parameter value.
/****************************************************************************/
HRESULT CTSSessionDirectory::AddADOInputDWORDParam(
        DWORD Param,
        PWSTR ParamName,
        ADOCommand *pCommand,
        ADOParameters *pParameters)
{
    HRESULT hr;
    CVar varParam;
    BSTR ParamStr;
    ADOParameter *pParam;

    ParamStr = SysAllocString(ParamName);
    if (ParamStr != NULL) {
        varParam.vt = VT_I4;
        varParam.lVal = Param;
        hr = pCommand->CreateParameter(ParamStr, adInteger, adParamInput, -1,
                varParam, &pParam);
        if (SUCCEEDED(hr)) {
            hr = pParameters->Append(pParam);
            if (FAILED(hr)) {
                ERR((TB,"InDWParam: Failed append param %S, hr=0x%X",
                        ParamName, hr));
            }

            // ADO will have its own ref for the param.
            pParam->Release();
        }
        else {
            ERR((TB,"InDWParam: Failed CreateParam %S, hr=0x%X",
                    ParamName, hr));
        }

        SysFreeString(ParamStr);
    }
    else {
        ERR((TB,"InDWParam: Failed alloc paramname"));
        hr = E_OUTOFMEMORY;
    }

    return hr;
}


/****************************************************************************/
// AddADOInputStringParam
//
// Creates and adds to the given ADOParameters object a WSTR-initialized
// parameter value.
/****************************************************************************/
HRESULT CTSSessionDirectory::AddADOInputStringParam(
        PWSTR Param,
        PWSTR ParamName,
        ADOCommand *pCommand,
        ADOParameters *pParameters,
        BOOL bNullOnNull)
{
    HRESULT hr;
    CVar varParam;
    BSTR ParamStr;
    ADOParameter *pParam;
    int Len;

    ParamStr = SysAllocString(ParamName);
    if (ParamStr != NULL) {
        // ADO does not seem to like accepting string params that are zero
        // length. So, if the string we have is zero length and bNullOnNull says
        // we can, we send a null VARIANT type, resulting in a null value at
        // the SQL server.
        if (wcslen(Param) > 0 || !bNullOnNull) {
            hr = varParam.InitFromWSTR(Param);
            Len = wcslen(Param);
        }
        else {
            varParam.vt = VT_NULL;
            varParam.bstrVal = NULL;
            Len = -1;
            hr = S_OK;
        }

        if (SUCCEEDED(hr)) {
            hr = pCommand->CreateParameter(ParamStr, adVarWChar, adParamInput,
                    Len, varParam, &pParam);
            if (SUCCEEDED(hr)) {
                hr = pParameters->Append(pParam);
                if (FAILED(hr)) {
                    ERR((TB,"InStrParam: Failed append param %S, hr=0x%X",
                            ParamName, hr));
                }

                // ADO will have its own ref for the param.
                pParam->Release();
            }
            else {
                ERR((TB,"InStrParam: Failed CreateParam %S, hr=0x%X",
                        ParamName, hr));
            }
        }
        else {
            ERR((TB,"InStrParam: Failed alloc variant bstr, "
                    "param %S, hr=0x%X", ParamName, hr));
        }

        SysFreeString(ParamStr);
    }
    else {
        ERR((TB,"InStrParam: Failed alloc paramname"));
        hr = E_OUTOFMEMORY;
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::ExecServerOnline
//
// Encapsulates creation and execution of the SP_TSSDServerOnline
// stored procedure on the server. Assumes that m_ClusterName is already set.
/****************************************************************************/
HRESULT CTSSessionDirectory::ExecServerOnline()
{
    HRESULT hr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;
    CVar varRows;
    CVar varFields;
    CVar varStart;
    long NumRecords;

    if (m_pConnection != NULL) {
        // Create the command.
        hr = CreateADOStoredProcCommand(L"SP_TSSDServerOnline", &pCommand,
                &pParameters);
        if (SUCCEEDED(hr)) {
            // Server name param.
            hr = AddADOInputStringParam(m_LocalServerAddress,
                    L"ServerAddress", pCommand, pParameters, FALSE);
            if (SUCCEEDED(hr)) {
                // Cluster name param.
                hr = AddADOInputStringParam(m_ClusterName,
                        L"ClusterName", pCommand, pParameters, TRUE);
                if (SUCCEEDED(hr)) {
                    // Execute the command.
                    hr = pCommand->Execute(NULL, NULL, adCmdStoredProc,
                            &pResultRecordSet);
                    if (SUCCEEDED(hr)) {
                        TRC2((TB,"ExecOn: Success"));
                    }
                    else {
                        ERR((TB,"Failed exec ServerOnline, hr=0x%X", hr));
                    }
                }
                else {
                    ERR((TB,"ExecOn: Failed adding ClusterName, hr=0x%X", hr));
                }
            }
            else {
                ERR((TB,"ExecOn: Failed adding ServerAddress, hr=0x%X",
                        hr));
            }

            pParameters->Release();
            pCommand->Release();
        }
        else {
            ERR((TB,"ExecOn: Failed create command, hr=0x%X", hr));
        }
    }
    else {
        ERR((TB,"ExecOn: Connection invalid"));
        hr = E_FAIL;
    }

    // Parse out the ServerID and ClusterID from the result recordset.
    if (SUCCEEDED(hr)) {
        long State;

        hr = pResultRecordSet->get_State(&State);
        if (SUCCEEDED(hr)) {
            if (!(State & adStateClosed)) {
                VARIANT_BOOL VB;

                // If EOF the recordset is empty.
                hr = pResultRecordSet->get_EOF(&VB);
                if (SUCCEEDED(hr)) {
                    if (VB) {
                        TRC1((TB,"ExecOnline: Result recordset EOF"));
                        hr = E_FAIL;
                        goto PostUnpackResultSet;
                    }
                }
                else {
                    ERR((TB,"GetUserDisc: Failed get_EOF, hr=0x%X", hr));
                    goto PostUnpackResultSet;
                }
            }
            else {
                ERR((TB,"GetUserDisc: Closed result recordset"));
                hr = E_FAIL;
                goto PostUnpackResultSet;
            }
        }
        else {
            ERR((TB,"GetUserDisc: get_State failed, hr=0x%X", hr));
            goto PostUnpackResultSet;
        }

        // Grab the result data into a safearray, starting with the default
        // current row and all fields.
        varStart.InitNoParam();
        varFields.InitNoParam();
        hr = pResultRecordSet->GetRows(1, varStart, varFields, &varRows);
        if (SUCCEEDED(hr)) {
            NumRecords = 0;
            hr = SafeArrayGetUBound(varRows.parray, 2, &NumRecords);
            if (SUCCEEDED(hr)) {
                // 0-based array bound was returned, num rows is that + 1.
                NumRecords++;
                ASSERT((NumRecords == 1),
                        (TB,"ExecOnline: NumRecords %u != expected %u",
                        NumRecords, 1));

                TRC1((TB,"%d rows retrieved from safearray", NumRecords));
            }
            else {
                ERR((TB,"ExecOnline: Failed safearray getubound, hr=0x%X", hr));
                goto PostUnpackResultSet;
            }
        }
        else {
            ERR((TB,"ExecOnline: Failed to get rows, hr=0x%X", hr));
            goto PostUnpackResultSet;
        }

        // Get the fields.
        hr = GetRowArrayDWORDField(varRows.parray, 0, 0, &m_ServerID);
        if (SUCCEEDED(hr)) {
            hr = GetRowArrayDWORDField(varRows.parray, 0, 1, &m_ClusterID);
            if (FAILED(hr)) {
                ERR((TB,"ExecOnline: Failed retrieve ClusterID, hr=0x%X", hr));
            }
        }
        else {
            ERR((TB,"ExecOnline: Failed retrieve ServerID, hr=0x%X", hr));
        }

PostUnpackResultSet:
        pResultRecordSet->Release();
    }

    return hr;
}


/****************************************************************************/
// CTSSessionDirectory::ExecServerOffline
//
// Encapsulates creation and execution of the SP_TSSDServerOffline
// stored procedure on the server.
/****************************************************************************/
HRESULT CTSSessionDirectory::ExecServerOffline()
{
    HRESULT hr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;

    if (m_pConnection != NULL) {
        // Create the command.
        hr = CreateADOStoredProcCommand(L"SP_TSSDServerOffline", &pCommand,
                &pParameters);
        if (SUCCEEDED(hr)) {
            // On an offline request, we need fast turn-around since we're
            // likely being called when the system is going down. Set the
            // timeout value for the command to 2 seconds.
            pCommand->put_CommandTimeout(2);

            hr = AddADOInputDWORDParam(m_ServerID,
                    L"ServerID", pCommand, pParameters);
            if (SUCCEEDED(hr)) {
                // Execute the command.
                hr = pCommand->Execute(NULL, NULL, adCmdStoredProc |
                        adExecuteNoRecords, &pResultRecordSet);
                if (SUCCEEDED(hr)) {
                    TRC2((TB,"ExecOff: Success"));
                }
                else {
                    ERR((TB,"Failed exec ServerOffline, hr=0x%X", hr));
                }
            }
            else {
                ERR((TB,"ExecOnOff: Failed adding ServerAddress, hr=0x%X",
                        hr));
            }

            pParameters->Release();
            pCommand->Release();
        }
        else {
            ERR((TB,"ExecOff: Failed create command, hr=0x%X", hr));
        }
    }
    else {
        ERR((TB,"ExecOff: Connection invalid"));
        hr = E_FAIL;
    }

    return hr;
}


/* ------------------------------------------------------------------------
   Plug-in UI interface for TSCC
   ------------------------------------------------------------------------*/


/* -------------------------------------------------------------------------------
 * describes the name of this entry in server settins
 * -------------------------------------------------------------------------------
 */
STDMETHODIMP CTSSessionDirectory::GetAttributeName(/* out */ WCHAR *pwszAttribName)
{
    TCHAR szAN[256];

    ASSERT((pwszAttribName != NULL),(TB,"NULL attrib ptr"));
    LoadString(g_hInstance, IDS_ATTRIBUTE_NAME, szAN, sizeof(szAN) / sizeof(TCHAR));
    lstrcpy(pwszAttribName, szAN);
    return S_OK;
}


/* -------------------------------------------------------------------------------
 * for this component the attribute value would indicate if its enabled or not
 * -------------------------------------------------------------------------------
 */
STDMETHODIMP CTSSessionDirectory::GetDisplayableValueName(
        /* out */WCHAR *pwszAttribValueName)
{
    TCHAR szAvn[256];    

    ASSERT((pwszAttribValueName != NULL),(TB,"NULL attrib ptr"));

    m_fEnabled = IsSessionDirectoryEnabled();
    if (m_fEnabled)
        LoadString(g_hInstance, IDS_ENABLE, szAvn, sizeof(szAvn) / sizeof(TCHAR));
    else
        LoadString(g_hInstance, IDS_DISABLE, szAvn, sizeof(szAvn) / sizeof(TCHAR));

    lstrcpy(pwszAttribValueName, szAvn);

    return S_OK;
}


/* -------------------------------------------------------------------------------
 * Custom UI provided here
 * pdwStatus informs Terminal Service Config to update termsrv
 * -------------------------------------------------------------------------------
 */
STDMETHODIMP CTSSessionDirectory::InvokeUI( /* in */ HWND hParent , /* out */ PDWORD pdwStatus )
{
    INT_PTR iRet = DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_DIALOG_SDS),
            hParent, (DLGPROC)CustomUIDlg, (LPARAM)this);

    TRC1((TB,"DialogBox returned 0x%x", iRet));

    *pdwStatus = ( DWORD )iRet;

    return S_OK;
}


/* -------------------------------------------------------------------------------
 * Custom menu items -- must be freed by LocalFree
 * this is called everytime the user right clicks the listitem
 * so you can alter the settings ( i.e. enable to disable and vice versa )
 * -------------------------------------------------------------------------------
 */
STDMETHODIMP CTSSessionDirectory::GetMenuItems(
        /* out */ int *pcbItems,
        /* out */ PMENUEXTENSION *pMex)
{
    ASSERT((pcbItems != NULL),(TB,"NULL items ptr"));

    *pcbItems = 2;

    *pMex = ( PMENUEXTENSION )LocalAlloc( LMEM_FIXED, *pcbItems * sizeof( MENUEXTENSION ) );

    if( *pMex != NULL )
    {
        // display enable or disable
        if( m_fEnabled )
        {
            LoadString(g_hInstance, IDS_DISABLE, (*pMex)[0].MenuItemName,
                    sizeof((*pMex)[0].MenuItemName) / sizeof(WCHAR));
        }
        else
        {
            LoadString(g_hInstance, IDS_ENABLE, (*pMex)[0].MenuItemName,
                    sizeof((*pMex)[0].MenuItemName) / sizeof(WCHAR));
        }
        
        LoadString(g_hInstance, IDS_DESCRIP_ENABLE, (*pMex)[0].StatusBarText,
                sizeof((*pMex)[0].StatusBarText) / sizeof(WCHAR));

        // menu items id -- this id will be passed back to u in ExecMenuCmd

        (*pMex)[0].cmd = IDM_MENU_ENABLE;

        LoadString(g_hInstance, IDS_PROPERTIES,  (*pMex)[1].MenuItemName,
                sizeof((*pMex)[1].MenuItemName) / sizeof(WCHAR));

        LoadString(g_hInstance, IDS_DESCRIP_PROPS, (*pMex)[1].StatusBarText,
                sizeof((*pMex)[1].StatusBarText) / sizeof(WCHAR));

        // menu items id -- this id will be passed back to u in ExecMenuCmd
        (*pMex)[1].cmd = IDM_MENU_PROPS;

        return S_OK;
    }
    else
    {
        return E_OUTOFMEMORY;
    }
}


/* -------------------------------------------------------------------------------
 * When the user selects a menu item the cmd id is passed to this component.
 * the provider ( which is us )
 * -------------------------------------------------------------------------------
 */
STDMETHODIMP CTSSessionDirectory::ExecMenuCmd(
        /* in */ UINT cmd,
        /* in */ HWND hParent ,
        /* out*/ PDWORD pdwStatus )
{
    switch (cmd) {
        case IDM_MENU_ENABLE:
            m_fEnabled = m_fEnabled ? 0 : 1;
            TRC1((TB,"%ws was selected", m_fEnabled ? L"Disable" : L"Enable"));
            if( SetSessionDirectoryState( m_fEnabled ) == ERROR_SUCCESS )
            {
                *pdwStatus = UPDATE_TERMSRV_SESSDIR;
            }
            break;

        case IDM_MENU_PROPS:
            INT_PTR iRet = DialogBoxParam(g_hInstance,
                    MAKEINTRESOURCE(IDD_DIALOG_SDS),
                    hParent,
                    (DLGPROC)CustomUIDlg,
                    (LPARAM)this);

            *pdwStatus = ( DWORD )iRet;
    }

    return S_OK;
}


/* -------------------------------------------------------------------------------
 * Tscc provides a default help menu item,  when selected this method is called
 * if we want tscc to handle ( or provide ) help return any value other than zero
 * for those u can't follow logic return zero if you're handling help.
 * -------------------------------------------------------------------------------
 */
STDMETHODIMP CTSSessionDirectory::OnHelp( /* out */ int *piRet)
{
    ASSERT((piRet != NULL),(TB,"NULL ret ptr"));
    *piRet = 0;
    return S_OK;
}


/* -------------------------------------------------------------------------------
 * IsSessionDirectoryEnabled returns a bool
 * -------------------------------------------------------------------------------
 */
BOOL CTSSessionDirectory::IsSessionDirectoryEnabled()
{
    LONG lRet;
    HKEY hKey;
    DWORD dwEnabled = 0;
    DWORD dwSize = sizeof(DWORD);
    
    lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
            REG_CONTROL_TSERVER,
            0,
            KEY_READ,
            &hKey);

    if (lRet == ERROR_SUCCESS)
    {
        lRet = RegQueryValueEx( hKey ,
                                REG_TS_SESSDIRACTIVE,
                                NULL ,
                                NULL ,
                                ( LPBYTE )&dwEnabled ,
                                &dwSize );

        RegCloseKey( hKey );
    }  

    return ( BOOL )dwEnabled;
}


/* -------------------------------------------------------------------------------
 * SetSessionDirectoryState - sets SessionDirectoryActive regkey to bVal
 * -------------------------------------------------------------------------------
 */
DWORD CTSSessionDirectory::SetSessionDirectoryState( BOOL bVal )
{
    LONG lRet;
    HKEY hKey;
    DWORD dwSize = sizeof( DWORD );
    
    lRet = RegOpenKeyEx( 
                        HKEY_LOCAL_MACHINE ,
                        REG_CONTROL_TSERVER ,
                        0,
                        KEY_WRITE,
                        &hKey );
    if (lRet == ERROR_SUCCESS)
    {
        lRet = RegSetValueEx( hKey ,
                              REG_TS_SESSDIRACTIVE,
                              0,
                              REG_DWORD ,
                              ( LPBYTE )&bVal ,
                              dwSize );
        
        RegCloseKey( hKey );
    } 
    else
    {
        ErrorMessage( NULL , IDS_ERROR_TEXT3 , ( DWORD )lRet );
    }

    return ( DWORD )lRet;
}


/* -------------------------------------------------------------------------------
 * ErrorMessage --
 * -------------------------------------------------------------------------------
 */
void CTSSessionDirectory::ErrorMessage( HWND hwnd , UINT res , DWORD dwStatus )
{
    TCHAR tchTitle[ 64 ];
    TCHAR tchText[ 64 ];
    TCHAR tchErrorMessage[ 256 ];
    LPTSTR pBuffer = NULL;
    
    // report error
    ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
            FORMAT_MESSAGE_FROM_SYSTEM,
            NULL,                                         //ignored
            ( DWORD )dwStatus,                            //message ID
            MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ),  //message language
            (LPTSTR)&pBuffer,                             //address of buffer pointer
            0,                                            //minimum buffer size
            NULL);  
    
    LoadString(g_hInstance, IDS_ERROR_TITLE, tchTitle, sizeof(tchTitle) / sizeof(TCHAR));
    LoadString(g_hInstance, res, tchText, sizeof(tchText) / sizeof(TCHAR));
    wsprintf( tchErrorMessage , tchText , pBuffer );
    ::MessageBox(hwnd, tchErrorMessage, tchTitle, MB_OK | MB_ICONINFORMATION);
}


/* -------------------------------------------------------------------------------
 * Custom UI msg handler dealt with here
 * -------------------------------------------------------------------------------
 */
INT_PTR CALLBACK CustomUIDlg(HWND hwnd, UINT umsg, WPARAM wp, LPARAM lp)
{
    static BOOL s_fServerNameChanged;
    static BOOL s_fClusterNameChanged;
    static BOOL s_fOpaqueStringChanged;
    static BOOL s_fPreviousButtonState;

    CTSSessionDirectory *pCTssd;

    switch (umsg)
    {
        case WM_INITDIALOG:
        {
            pCTssd = ( CTSSessionDirectory * )lp;

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

            SendMessage( GetDlgItem( hwnd , IDC_EDIT_SERVERNAME ) ,
                    EM_LIMITTEXT ,
                    ( WPARAM )64 ,
                    0 );
            SendMessage( GetDlgItem( hwnd , IDC_EDIT_CLUSTERNAME ) ,
                    EM_LIMITTEXT ,
                    ( WPARAM )64 ,
                    0 );
            SendMessage( GetDlgItem( hwnd , IDC_EDIT_ACCOUNTNAME ) ,
                    EM_LIMITTEXT ,
                    ( WPARAM )64 ,
                    0 );
            SendMessage( GetDlgItem( hwnd , IDC_EDIT_PASSWORD ) ,
                    EM_LIMITTEXT ,
                    ( WPARAM )64 ,
                    0 );
                 
            LONG lRet;
            HKEY hKey;
            
            TCHAR szString[ 256 ];
            DWORD cbData = sizeof( szString );

            lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE ,
                    REG_TS_CLUSTERSETTINGS ,
                    0,
                    KEY_READ | KEY_WRITE , 
                    &hKey );
            if( lRet == ERROR_SUCCESS )
            {
                lRet = RegQueryValueEx(hKey ,
                        REG_TS_CLUSTER_STORESERVERNAME,
                        NULL , 
                        NULL ,
                        ( LPBYTE )szString , 
                        &cbData );
                if( lRet == ERROR_SUCCESS )
                {
                    SetWindowText( GetDlgItem( hwnd , IDC_EDIT_SERVERNAME ) , szString );
                }
            
                cbData = sizeof( szString );

                lRet = RegQueryValueEx(hKey,
                        REG_TS_CLUSTER_CLUSTERNAME,
                        NULL,
                        NULL,
                        (LPBYTE)szString,
                        &cbData);           
                if( lRet == ERROR_SUCCESS )
                {
                    SetWindowText(GetDlgItem(hwnd, IDC_EDIT_CLUSTERNAME), szString);
                }

                cbData = 0;                

                lRet = RegQueryValueEx( hKey ,
                        REG_TS_CLUSTER_OPAQUESETTINGS,
                        NULL , 
                        NULL ,
                        (LPBYTE)NULL,
                        &cbData);

                if( lRet == ERROR_SUCCESS )
                {
                    pCTssd->m_pszOpaqueString =  ( LPTSTR )LocalAlloc( LMEM_FIXED , cbData );

                    if( pCTssd->m_pszOpaqueString != NULL )
                    {
                        lRet = RegQueryValueEx( hKey ,
                            REG_TS_CLUSTER_OPAQUESETTINGS,
                            NULL , 
                            NULL ,
                            (LPBYTE)pCTssd->m_pszOpaqueString ,
                            &cbData );
                    }
                    else
                    {
                        lRet = ERROR_OUTOFMEMORY;
                    }
                }                    

                if( lRet == ERROR_SUCCESS )
                {
                    // jump to user_id
                    TCHAR tchUserId[64] = { 0 };
                    TCHAR tchPassword[64] = { 0 };

                    LPTSTR pszUserId = tchUserId;
                    LPTSTR pszPassword = tchPassword;
                    
                    FindSqlValue( pCTssd->m_pszOpaqueString , TEXT("User Id"), pszUserId );
                    
                    strtrim( &pszUserId );                    

                    FindSqlValue( pCTssd->m_pszOpaqueString , TEXT("Password"), pszPassword );

                    strtrim( &pszPassword );                    
                     
                    SetWindowText( GetDlgItem( hwnd , IDC_EDIT_ACCOUNTNAME ) , pszUserId );
                    SetWindowText( GetDlgItem( hwnd , IDC_EDIT_PASSWORD ) , pszPassword );
                } 

                RegCloseKey(hKey);
            }
            else
            {
                if( pCTssd != NULL )
                {
                    pCTssd->ErrorMessage( hwnd , IDS_ERROR_TEXT , ( DWORD )lRet );
                }
                
                EndDialog(hwnd, lRet);                
            }

            if( pCTssd != NULL )
            {
                BOOL bEnable;
                
                bEnable = pCTssd->IsSessionDirectoryEnabled();

                CheckDlgButton( hwnd , IDC_CHECK_ENABLE , bEnable ? BST_CHECKED : BST_UNCHECKED );
                
                s_fPreviousButtonState = bEnable;

                EnableWindow(GetDlgItem(hwnd, IDC_EDIT_SERVERNAME), bEnable);
                EnableWindow(GetDlgItem(hwnd, IDC_EDIT_CLUSTERNAME), bEnable);
                EnableWindow(GetDlgItem(hwnd, IDC_EDIT_ACCOUNTNAME), bEnable);
                EnableWindow(GetDlgItem(hwnd, IDC_EDIT_PASSWORD), bEnable);      
                EnableWindow(GetDlgItem(hwnd, IDC_STATIC_SQLNAME), bEnable);
                EnableWindow(GetDlgItem(hwnd, IDC_STATIC_CLUSTERNAME), bEnable);
                EnableWindow(GetDlgItem(hwnd, IDC_STATIC_SQLACCOUNT), bEnable);
                EnableWindow(GetDlgItem(hwnd, IDC_STATIC_SQLPWD), bEnable);
            }

            s_fServerNameChanged = FALSE;
            s_fClusterNameChanged = FALSE;
            s_fOpaqueStringChanged = FALSE;    
        }

        break;

                            
        case WM_COMMAND:
            if( LOWORD( wp ) == IDCANCEL )
            {
                pCTssd = ( CTSSessionDirectory * )GetWindowLongPtr( hwnd , DWLP_USER );

                if( pCTssd->m_pszOpaqueString != NULL )
                {
                    LocalFree( pCTssd->m_pszOpaqueString );
                }

                EndDialog(hwnd , 0);
            }
            else if( LOWORD( wp ) == IDOK )
            {
                BOOL bEnabled;

                DWORD dwRetStatus = 0;

                pCTssd = ( CTSSessionDirectory * )GetWindowLongPtr(hwnd, DWLP_USER);
                bEnabled = IsDlgButtonChecked( hwnd , IDC_CHECK_ENABLE ) == BST_CHECKED;

                if( bEnabled != s_fPreviousButtonState )
                {
                    DWORD dwStatus;

                    TRC1((TB,"EnableButtonChanged"));
                    dwStatus = pCTssd->SetSessionDirectoryState( bEnabled );
                    if( dwStatus != ERROR_SUCCESS )
                    {
                        return 0;
                    }

                    dwRetStatus = UPDATE_TERMSRV_SESSDIR;
                }

                if( s_fServerNameChanged || s_fClusterNameChanged || s_fOpaqueStringChanged )
                {
                    HKEY hKey;

                    LONG lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE ,
                            REG_TS_CLUSTERSETTINGS ,
                            0,
                            KEY_READ | KEY_WRITE , 
                            &hKey );
                    
                    if( lRet == ERROR_SUCCESS )
                    {
                        TCHAR szName[ 64 ];

                        if( s_fServerNameChanged )
                        {
                            TRC1((TB,"SQLServerNameChanged" )) ;
                    
                            GetWindowText( GetDlgItem( hwnd , IDC_EDIT_SERVERNAME ) , szName , sizeof( szName ) / sizeof( TCHAR )  );

                            RegSetValueEx( hKey ,
                                REG_TS_CLUSTER_STORESERVERNAME,
                                0,
                                REG_SZ,
                                ( CONST LPBYTE )szName ,
                                sizeof( szName ) );
                        }

                        if( s_fClusterNameChanged )
                        {
                            TRC1((TB,"ClusterNameChanged"));
                    
                            GetWindowText( GetDlgItem( hwnd , IDC_EDIT_CLUSTERNAME ) , szName , sizeof( szName ) / sizeof( TCHAR )  );

                            RegSetValueEx( hKey ,
                                REG_TS_CLUSTER_CLUSTERNAME,
                                0,
                                REG_SZ,
                                ( CONST LPBYTE )szName ,
                                sizeof( szName ) );
                        }
                        if( s_fOpaqueStringChanged )
                        {
                            TRC1((TB,"OpaqueStringChanged" )) ;  
                            
                            LPTSTR pszNewOpaqueString = NULL;

                            LPTSTR pszName = NULL;
                                                        
                            GetWindowText( GetDlgItem( hwnd , IDC_EDIT_ACCOUNTNAME ) , szName , sizeof( szName ) / sizeof( TCHAR )  );

                            pszName = szName;

                            strtrim( &pszName );

                            ModifySqlValue( &pCTssd->m_pszOpaqueString , L"User Id" , pszName );

                            GetWindowText( GetDlgItem( hwnd , IDC_EDIT_PASSWORD ) , szName , sizeof( szName ) / sizeof( TCHAR )  );

                            pszName = szName;

                            strtrim( &pszName );

                            if( ModifySqlValue( &pCTssd->m_pszOpaqueString , L"Password" , pszName ) != NULL )
                            {
                                RegSetValueEx( hKey ,
                                        REG_TS_CLUSTER_OPAQUESETTINGS,
                                        0,
                                        REG_SZ,
                                        ( CONST LPBYTE )pCTssd->m_pszOpaqueString ,
                                        lstrlen( pCTssd->m_pszOpaqueString ) * sizeof( TCHAR ) );
                            }
                        }

                        RegCloseKey(hKey);

                        dwRetStatus = UPDATE_TERMSRV_SESSDIR;
                    }
                    else
                    {
                        pCTssd->ErrorMessage(hwnd , IDS_ERROR_TEXT2 , (DWORD)lRet);
                        return 0;
                    }
                }

                if( pCTssd->m_pszOpaqueString != NULL )
                {
                    LocalFree( pCTssd->m_pszOpaqueString );
                }

                EndDialog( hwnd , ( INT_PTR )dwRetStatus );
            }
            else 
            {
                switch (HIWORD(wp)) 
                {            
                    case EN_CHANGE:
                        if( LOWORD( wp ) == IDC_EDIT_SERVERNAME )
                        {
                            s_fServerNameChanged = TRUE;
                        }
                        else if( LOWORD( wp ) == IDC_EDIT_CLUSTERNAME )
                        {
                            s_fClusterNameChanged = TRUE;
                        }
                        else if( LOWORD( wp ) == IDC_EDIT_ACCOUNTNAME || LOWORD( wp ) == IDC_EDIT_PASSWORD )
                        {
                            s_fOpaqueStringChanged = TRUE;
                        }                
                        break;

                    case BN_CLICKED:
                        if( LOWORD( wp ) == IDC_CHECK_ENABLE)
                        {
                            BOOL bEnable;

                            if( IsDlgButtonChecked( hwnd , IDC_CHECK_ENABLE ) == BST_CHECKED )
                            {
                                // enabled all controls
                                bEnable = TRUE;
                            }
                            else
                            {
                                // disable all controls
                                bEnable = FALSE;                       
                            }
                            
                            // set flags 
                            s_fServerNameChanged = bEnable;
                            s_fClusterNameChanged = bEnable;
                            s_fOpaqueStringChanged = bEnable;

                            EnableWindow( GetDlgItem( hwnd , IDC_EDIT_SERVERNAME ) , bEnable );
                            EnableWindow( GetDlgItem( hwnd , IDC_EDIT_CLUSTERNAME ) , bEnable );
                            EnableWindow( GetDlgItem( hwnd , IDC_EDIT_ACCOUNTNAME ) , bEnable );
                            EnableWindow( GetDlgItem( hwnd , IDC_EDIT_PASSWORD ) , bEnable );      
                            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_SQLNAME ) , bEnable );
                            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_CLUSTERNAME ) , bEnable ); 
                            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_SQLACCOUNT ) , bEnable ); 
                            EnableWindow( GetDlgItem( hwnd , IDC_STATIC_SQLPWD ) , bEnable ); 

                        }
                        break;
                }
            }        

            break;
    }

    return 0;
}

/********************************************************************************************
 [in ] lpString is the buffer containing the OpaqueSettings
 [in ] lpKeyName is the field name within the OpaqueSettings string
 [out] pszValue is a buffer that will contain the field name value

 Ret: None
 *******************************************************************************************/
void FindSqlValue(LPTSTR lpString, LPTSTR lpKeyName, LPTSTR pszValue)
{    
    int i;

    LPTSTR lpszStart = lpString;
    LPTSTR lpszTemp;

    UINT nKeyName;

    if( lpString != NULL && lpKeyName != NULL )
    {
        // find field name

        lpString = FindField( lpString , lpKeyName );

        if( *lpString != 0 )
        {
            i = 0;

            while( *lpString != 0 && *lpString != ( TCHAR )';' )
            {
                pszValue[i] = *lpString;
                i++;
                lpString++;            
            }

            pszValue[ i ] = 0;
        }
    }
}
        
/********************************************************************************************

 [in/out ] lpszOpaqueSettings is the buffer containing the OpaqueSettings
 [in ] lpKeyName is the field name within the OpaqueSettings string
 [in ] lpszNewValue contains the value that will replace the original value in the field

 Ret: A new OpaqueSetting string is constructed and must be freed with LocalFree

********************************************************************************************/
LPTSTR ModifySqlValue( LPTSTR* lppszOpaqueSettings , LPTSTR lpszKeyName , LPTSTR lpszNewValue )
{
    LPTSTR szEndPos       = NULL;
    LPTSTR szSecondPos    = NULL;
    LPTSTR pszNewSettings = NULL;
    LPTSTR lpszOpaqueSettings = *lppszOpaqueSettings;
    LPTSTR pszTempSettings = lpszOpaqueSettings;    
    UINT cbSize = 0;
    
    //a ) find value
    //b ) set pos2 after ';'
    //c ) set endpos1 after '='  to null
    //d ) create a buffer the length of first string + value + ; + second string
    //e ) strcpy first string + value + ; + second string
    //f ) return buffer

    if( lpszKeyName != NULL && lpszOpaqueSettings != NULL  )
    {
        
        szEndPos = FindField( lpszOpaqueSettings , lpszKeyName );

        if( *szEndPos != 0 )
        {            
            lpszOpaqueSettings = szEndPos;

            while( *lpszOpaqueSettings != 0 ) 
            {
                if( *lpszOpaqueSettings == ( TCHAR )';' )
                {
                    szSecondPos = lpszOpaqueSettings + 1;

                    break;
                }

                lpszOpaqueSettings++;
            }                   

            *szEndPos = 0;

            cbSize = lstrlen( pszTempSettings );

            cbSize += lstrlen( lpszNewValue );

            cbSize += 2; // for the semicolon and null

            if( szSecondPos != NULL && *szSecondPos != 0 )
            {
                cbSize += lstrlen( szSecondPos );
            }

            pszNewSettings = ( LPTSTR )LocalAlloc( LMEM_FIXED , cbSize * sizeof( TCHAR ) );

            if( pszNewSettings != NULL )
            {
                lstrcpy( pszNewSettings , pszTempSettings );

                lstrcat( pszNewSettings , lpszNewValue );

                lstrcat( pszNewSettings , TEXT( ";" ) );

                if( szSecondPos != NULL )
                {
                    lstrcat( pszNewSettings , szSecondPos );
                }

                LocalFree( pszTempSettings );

                *lppszOpaqueSettings = pszNewSettings;                                    
            }                    

        }
        else
        {
            // we're here because either the field name didnot exist or is unattainable
            // so we're slapping the field name and value at the end.

            cbSize = lstrlen( pszTempSettings );

            // add the size of the keyname and = and ;
            cbSize += lstrlen( lpszKeyName ) + 2;

            // add the new value
            cbSize += lstrlen( lpszNewValue ) + 1;

            pszNewSettings = ( LPTSTR )LocalAlloc( LMEM_FIXED , cbSize * sizeof( TCHAR ) );

            if( pszNewSettings != NULL )
            {
                lstrcpy( pszNewSettings , pszTempSettings );
                lstrcat( pszNewSettings , lpszKeyName );
                lstrcat( pszNewSettings , TEXT( "=" ) );
                lstrcat( pszNewSettings , lpszNewValue );
                lstrcat( pszNewSettings , TEXT( ";" ) );

                LocalFree( pszTempSettings );

                *lppszOpaqueSettings = pszNewSettings;                    
            }

        }
    }

    return pszNewSettings;
}

/********************************************************************************************
 FindField -- greps the OpaqueString passed in
   pszString and searches for field name in pszKeyName

  [ in ] pszString - OpaqueString
  [ in ] pszKeyName - field name

  ret: the position of the field value ( after the " = " )

 *******************************************************************************************/
LPTSTR FindField( LPTSTR pszString , LPTSTR pszKeyName )
{
    LPTSTR lpszStart = pszString;
    LPTSTR lpszTemp;
    LPTSTR lpszFieldName;

    UINT nKeyName;

    // find field name

    nKeyName = lstrlen( pszKeyName );

    while( *pszString != 0 )
    {
        while( *pszString != 0 && *pszString != ( TCHAR )'=' )
        {            
            pszString++;
        }

        // ok move backwards to check for name
        if( *pszString != 0 )
        {
            lpszTemp = pszString - 1;            

            while(  lpszStart <= lpszTemp )
            {               

                if( IsCharAlphaNumeric( *lpszTemp ) )
                {
                    break;
                }

                lpszTemp--;
            }

            lpszFieldName = ( lpszTemp - nKeyName + 1 );            

            if( lpszStart <= lpszFieldName && _tcsncicmp( lpszFieldName , pszKeyName , nKeyName ) == 0 )
            {
                // found the name skip '='                
                pszString++;
                break;
            }
        }

        pszString++;
    }

    return pszString;
}

/*********************************************************************************************
 * borrowed from Ting Cai (tingcai) with slight modifications
 * net\upnp\ssdp\common\ssdpparser\parser.cpp
 *
 ********************************************************************************************/    
VOID strtrim( TCHAR **pszStr)
{

    TCHAR *end;
    TCHAR *begin;

    begin = *pszStr;
    end = begin + lstrlen( *pszStr ) - 1;

    while (*begin == ( TCHAR )' ' || *begin == ( TCHAR )'\t')
    {
        begin++;
    }

    *pszStr = begin;

    while (*end == ( TCHAR )' ' || *end == ( TCHAR )'\t')
    {
        end--;
    }

    *(end+1) = '\0';    
}