/****************************************************************************/
// Directory Integrity Service
//
// Copyright (C) 2000, Microsoft Corporation
/****************************************************************************/

#include "dis.h"
#include "jetrpc.h"
#include "jetsdis.h"
#include "sdevent.h"
#include "resource.h"
#include "tssdshrd.h"
#include "sdrpc.h"


#pragma warning (push, 4)

#define SERVER_ADDRESS_LENGTH 64
#define NUM_JETRPC_THREADS 10
#define MAX_DRIVE_LETTER_LENGTH 24
#define SD_QUERY_ENDPOINT_NAME L"TSSessionDirectoryQueryApi"
// Number of 100-nanosecond periods in 1 second.
#define FILETIME_INTERVAL_TO_SECONDS_MULTIPLIER 10000000

#define DEBUG_LOG_FILENAME L"tssdis.log"

#define REG_SESSION_DIRECTROY_CONTROL L"System\\CurrentControlSet\\Services\\Tssdis\\Parameters"

#define MAX_TSSERVERS_TO_RECOVER 0xFFFF
#define NO_RECOVER_WHEN_START 0
//do we recover previous jet database when starting SD
DWORD g_RecoverWhenStart = 1; 
//  if asking TS to repopulate session when it rejoins
//  RepoluateSession is set to FALSE only when tssdis is 
//  running on failover cluster and it's restarted within a time limit
BOOL  g_RepopulateSession = TRUE;
// If tssdis is not restarted within this time (3 mins), we think the db is not consistent
ULONGLONG g_TimeLimitToDeleteDB = 3 * 60 * FILETIME_INTERVAL_TO_SECONDS_MULTIPLIER;

//
// Global for fail-over cluster
//
DWORD g_dwClusterState;
// Cluster network name
WCHAR *g_ClusterNetworkName = NULL;
// Cluster account token
HANDLE g_hClusterToken = NULL;

// File Handle for the database timestamp file
HANDLE g_hTimeFile;

#define SDLOCALGROUPNAMELENGTH 64
#define SDLOCALGROUPDESLENGTH 128

const DIRCOLUMNS SessionDirectoryColumns[NUM_SESSDIRCOLUMNS] = {
    { "UserName", JET_coltypLongText, 512 },
    { "Domain", JET_coltypLongText, 254 },
    { "ServerID", JET_coltypLong, 0 },
    { "SessionID", JET_coltypLong, 0 },
    { "TSProtocol", JET_coltypLong, 0 },
    { "CreateTimeLow", JET_coltypLong, 0 },
    { "CreateTimeHigh", JET_coltypLong, 0 },
    { "DisconnectTimeLow", JET_coltypLong, 0 },
    { "DisconnectTimeHigh", JET_coltypLong, 0 },
    { "ApplicationType", JET_coltypLongText, 512 },
    { "ResolutionWidth", JET_coltypLong, 0 },
    { "ResolutionHeight", JET_coltypLong, 0 },
    { "ColorDepth", JET_coltypLong, 0 },
    { "State", JET_coltypBit, 0 },
};


const DIRCOLUMNS ServerDirectoryColumns[NUM_SERVDIRCOLUMNS] = {
    { "ServerID", JET_coltypLong, 0 },
    { "ServerAddress", JET_coltypLongText, 128 },
    { "ClusterID", JET_coltypLong, 0 },
    { "AlmostInTimeLow", JET_coltypLong, 0 },
    { "AlmostInTimeHigh", JET_coltypLong, 0 },
    { "NumberFailedPings", JET_coltypLong, 0 },
    { "SingleSessionMode", JET_coltypBit, 0 },
    { "ServerDNSName", JET_coltypLongText, 128 },
};


const DIRCOLUMNS ClusterDirectoryColumns[NUM_CLUSDIRCOLUMNS] = {
    { "ClusterID", JET_coltypLong, 0 },
    { "ClusterName", JET_coltypLongText, 128 },
    { "SingleSessionMode", JET_coltypBit, 0 },
};


JET_COLUMNID sesdircolumnid[NUM_SESSDIRCOLUMNS];
JET_COLUMNID servdircolumnid[NUM_SERVDIRCOLUMNS];
JET_COLUMNID clusdircolumnid[NUM_CLUSDIRCOLUMNS];

JET_INSTANCE g_instance = 0;

ADOConnection *g_pConnection;
HANDLE g_hStopServiceEvent;

SERVICE_STATUS g_DISStatus;
SERVICE_STATUS_HANDLE g_DISStatusHandle;

BOOL g_bDebug = FALSE;

PSID g_pSid = NULL;                    //Sid for SD local group 
PSID g_pAdminSid = NULL;               //Sid for admin on the SD server

// Registry settings follow
#if 0
DWORD g_bUseSQL = 0;
#endif


enum TraceOutputMode {
    NoTraceOutput,
    DebugPrintOutput,
    StdOutput,
    FileOutput
};

TraceOutputMode g_TraceOutputMode = NoTraceOutput;
HANDLE g_hFileOutput = INVALID_HANDLE_VALUE;

// For debugging purposes, we can set the ping mode to something other than
// WinStationOpenServer using the registry.
enum PingMode {
    NormalMode,
    AlwaysSucceed,
    AlwaysFail
};

PingMode g_PingMode = NormalMode;

ULONGLONG g_TimeServerSilentBeforePing = 60 * FILETIME_INTERVAL_TO_SECONDS_MULTIPLIER;
DWORD DISNumberSecondsBetweenPings = 10;
DWORD g_NumberFailedPingsBeforePurge = 3;


#ifdef DBG
void OutputAllTables();
#endif

void DISDeleteLocalGroupSecDes();
RPC_STATUS SDInitQueryRPC(VOID);

void TSDISErrorOut(wchar_t *format_string, ...)
{
    // Immediately bail out if we are in NoTraceOutput mode.
    if (g_TraceOutputMode == NoTraceOutput) {
        return;
    }
    else {
        // Otherwise, do the right thing.
        wchar_t TotalString[MAX_DEBUG_STRING_LENGTH + MAX_THREADIDSTR_LENGTH];
        wchar_t *ThreadIDString = TotalString;
        wchar_t *DebugOutString = NULL;
        va_list args;
        int ThreadStrLength;

        // Get the current thread ID
        ThreadStrLength = _snwprintf(ThreadIDString, MAX_THREADIDSTR_LENGTH, 
                L"%d: ", GetCurrentThreadId());

        // Set the place for the out string to after the string, or after the whole
        // buffer if _snwprintf didn't have enough space.
        if (ThreadStrLength > 0)
            DebugOutString = &TotalString[ThreadStrLength];
        else
            DebugOutString = &TotalString[MAX_THREADIDSTR_LENGTH];
            
        va_start(args, format_string);

        // Create the debug output string.
        _vsnwprintf(DebugOutString, MAX_DEBUG_STRING_LENGTH, format_string, args);
        DebugOutString[MAX_DEBUG_STRING_LENGTH - 1] = '\0';

        // Output to the correct place.
        switch (g_TraceOutputMode) {
            
        case DebugPrintOutput:
            OutputDebugString(TotalString);
            break;

        case StdOutput:
            wprintf(TotalString);
            break;

        case FileOutput:
            {
                char TotalStringA[MAX_DEBUG_STRING_LENGTH + 
                        MAX_THREADIDSTR_LENGTH];
                DWORD dwBytes = 0;

                // Convert to ANSI.
                dwBytes = WideCharToMultiByte(CP_ACP, 0, TotalString, 
                        -1, TotalStringA, MAX_DEBUG_STRING_LENGTH + 
                        MAX_THREADIDSTR_LENGTH, 0, 0);

                // Don't write the terminating NULL (3rd argument)!
                // Ignore return value.
                WriteFile(g_hFileOutput, TotalStringA, dwBytes - 1, 
                        &dwBytes, NULL);
                
                break;
            }
        }

        va_end(args);
    }
}


// TSDISErrorTimeOut
//
// This function is used to output a single FILETIME low, high pair.  The format
// string, given as the first argument, MUST specify a %s format specifier for
// where the date/time should go.
//
// Example:
//  TSDISErrorTimeOut(L"The date and time are %s\n", CurrTimeLow, CurrTimeHigh);
void TSDISErrorTimeOut(wchar_t *format_string, DWORD TimeLow, DWORD TimeHigh)
{
    if (g_TraceOutputMode == NoTraceOutput) {
        return;
    }
    else {
        // We just need to convert the FILETIME we have into a SYSTEMTIME,
        // and then output the SYSTEMTIME using GetDateFormat and GetTimeFormat.
        FILETIME ft;
        SYSTEMTIME st;
        SYSTEMTIME stloc;
        int offset = 0;
        wchar_t DateString[MAX_DATE_TIME_STRING_LENGTH];

        ft.dwLowDateTime = TimeLow;
        ft.dwHighDateTime = TimeHigh;

        if (FileTimeToSystemTime(&ft, &st) != 0) {
            // st is the system time.

            // UTC format?
            if (SystemTimeToTzSpecificLocalTime(NULL, &st, &stloc) != 0) {
                offset = GetDateFormat(LOCALE_SYSTEM_DEFAULT, DATE_SHORTDATE, 
                        &stloc, NULL, DateString, MAX_DATE_TIME_STRING_LENGTH);

                if (offset != 0) {
                    // Turn the terminating NULL into a space.
                    DateString[offset - 1] = ' ';
                    
                    // Write the time after the space.
                    offset = GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &stloc, 
                            NULL, &DateString[offset], 
                            MAX_DATE_TIME_STRING_LENGTH - offset);

                    if (offset != 0) {
                        // Output the string.
                        TSDISErrorOut(format_string, DateString);
                    }
                }
            }
        }
    }
}


// This function is duplicated from \nt\termsrv\winsta\server\sessdir.cpp.
//
// PostSessDirErrorValueEvent
//
// Utility function used to create a system log wType event containing one
// hex DWORD code value.
void PostSessDirErrorValueEvent(unsigned EventCode, DWORD ErrVal, WORD wType)
{
    HANDLE hLog;
    WCHAR hrString[128];
    PWSTR String = NULL;
    static DWORD numInstances = 0;
    //
    //count the numinstances of out of memory error, if this is more than
    //a specified number, we just won't log them
    //
    if( MY_STATUS_COMMITMENT_LIMIT == ErrVal )
    {
        if( numInstances > MAX_INSTANCE_MEMORYERR )
            return;
         //
        //if applicable, tell the user that we won't log any more of the out of memory errors
        //
        if( numInstances >= MAX_INSTANCE_MEMORYERR - 1 ) {
            wsprintfW(hrString, L"0x%X. This type of error will not be logged again to avoid eventlog fillup.", ErrVal);
            String = hrString;
        }
        numInstances++;
    }

    hLog = RegisterEventSource(NULL, L"TermServSessDir");
   if (hLog != NULL) {
        if( NULL == String ) {
            wsprintfW(hrString, L"0x%X", ErrVal);
            String = hrString;
        }
        ReportEvent(hLog, wType, 0, EventCode, NULL, 1, 0,
                (const WCHAR **)&String, NULL);
        DeregisterEventSource(hLog);
    }
}

// PostSessDirErrorMsgEvent
//
// Utility function used to create a system log wType event containing one
// WCHAR msg.
void PostSessDirErrorMsgEvent(unsigned EventCode, WCHAR *szMsg, WORD wType)
{
    HANDLE hLog;
    
    hLog = RegisterEventSource(NULL, L"TermServSessDir");
    if (hLog != NULL) {
        ReportEvent(hLog, wType, 0, EventCode, NULL, 1, 0,
                (const WCHAR **)&szMsg, NULL);
        DeregisterEventSource(hLog);
    }
}


// DISJetGetServersPendingReconnects
//
// Returns arrays of max length 10 of servers pending reconnects, where the
// reconnect is greater than g_TimeServerSilentBeforePing seconds.
HRESULT STDMETHODCALLTYPE DISJetGetServersPendingReconnects(
        OUT long __RPC_FAR *pNumSessionsReturned,
        OUT WCHAR ServerAddressRows[10][SERVER_ADDRESS_LENGTH],
        OUT DWORD ServerIDs[10])
{
    JET_ERR err;
    JET_SESID sesid = JET_sesidNil;
    JET_DBID dbid;
    JET_TABLEID servdirtableid;
    DWORD zero = 0;
    *pNumSessionsReturned = 0;
    unsigned i = 0;
    unsigned long cbActual;
    // These are really FILETIMEs, but we want to do 64-bit math on them,
    // and they're the same structure as FILETIMEs.
    ULARGE_INTEGER ulCurrentTime;
    ULARGE_INTEGER ulAITTime;
        
    //TSDISErrorOut(L"GetPendRec...");
    CALL(JetBeginSession(g_instance, &sesid, "user", ""));
    CALL(JetOpenDatabase(sesid, JETDBFILENAME, "", &dbid, 0));

    CALL(JetOpenTable(sesid, dbid, "ServerDirectory", NULL, 0, 0, 
            &servdirtableid));

    // Get the current file time.
    SYSTEMTIME st;
    
    // Retrieve the time.
    GetSystemTime(&st);
    SystemTimeToFileTime(&st, (FILETIME *) &ulCurrentTime);

    // Set the current time to the sd timestamp file    
    SetFileTime(g_hTimeFile, NULL, NULL, (FILETIME *)&ulCurrentTime);

    CALL(JetBeginTransaction(sesid));
    
    // Since Jet has no unsigned long type, go through the servers first
    // looking for keys greater than 0, 0, then looking for keys less than 0, 0
    // TODO: Consider how to do this with JET_coltypDateTime or using NULLs
    for (int j = 0; j < 2; j++) {
        CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServerAlmostInTimes"));

        CALL(JetMakeKey(sesid, servdirtableid, &zero, sizeof(zero), 
                JET_bitNewKey));
        CALL(JetMakeKey(sesid, servdirtableid, &zero, sizeof(zero), 0));

        if (0 == j)
            err = JetSeek(sesid, servdirtableid, JET_bitSeekGT);
        else
            err = JetSeek(sesid, servdirtableid, JET_bitSeekLT);

        while ((i < TSSD_MaxDisconnectedSessions) && (JET_errSuccess == err)) {

            // Get AlmostInTimeLow, AlmostInTimeHigh (3 + 4) for computation.
            CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[
                    SERVDIR_AITLOW_INTERNAL_INDEX], &(ulAITTime.LowPart), 
                    sizeof(ulAITTime.LowPart), &cbActual, 0, NULL));
            CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[
                    SERVDIR_AITHIGH_INTERNAL_INDEX], &(ulAITTime.HighPart), 
                    sizeof(ulAITTime.HighPart), &cbActual, 0, NULL));

            // If the difference between the current time and the time the
            // server was stamped is greater than the set 
            // TimeServerSilentBeforePing, then put it in the return array, 
            // else don't.
            if ((ulCurrentTime.QuadPart - ulAITTime.QuadPart) > 
                    g_TimeServerSilentBeforePing) {

                // Get ServerID
                CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[
                        SERVDIR_SERVID_INTERNAL_INDEX], &ServerIDs[i], 
                        sizeof(ServerIDs[i]), &cbActual, 0, NULL));

                // Get the ServerAddress for this record.
                CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[
                        SERVDIR_SERVADDR_INTERNAL_INDEX], 
                        &ServerAddressRows[i][0], sizeof(ServerAddressRows[i]),
                        &cbActual, 0, NULL));

                i += 1;
            }

            // Move to the next matching record.
            if (0 == j)
                err = JetMove(sesid, servdirtableid, JET_MoveNext, 0);
            else
                err = JetMove(sesid, servdirtableid, JET_MovePrevious, 0);
        }
    }

    *pNumSessionsReturned = i;
    
    CALL(JetCommitTransaction(sesid, 0));

    CALL(JetCloseTable(sesid, servdirtableid));

    CALL(JetCloseDatabase(sesid, dbid, 0));

    CALL(JetEndSession(sesid, 0));

    return S_OK;

HandleError:
    if (sesid != JET_sesidNil) {
        // Can't really recover.  Just bail out.
        (VOID) JetRollback(sesid, JET_bitRollbackAll);

        // Force the session closed
        (VOID) JetEndSession(sesid, JET_bitForceSessionClosed);
    }
    
    return E_FAIL;
}


#if 0
HRESULT STDMETHODCALLTYPE DISSQLGetServersPendingReconnects(
        OUT long __RPC_FAR *pNumSessionsReturned, 
        OUT CVar *pVarRows)
{
    long NumRecords = 0;
    HRESULT hr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;
    CVar varFields;
    CVar varStart;

    TRC2((TB,"GetServersWithDisconnectedSessions"));

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

    hr = CreateADOStoredProcCommand(L"SP_TSDISGetServersPendingReconnects",
            &pCommand, &pParameters);
    if (SUCCEEDED(hr)) {
        // Execute the command.
        hr = pCommand->Execute(NULL, NULL, adCmdStoredProc,
                &pResultRecordSet);

        pParameters->Release();
        pCommand->Release();
    }
    else {
        ERR((TB,"GetServersWDiscSess: 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;

        NumRecords = 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,"GetServersWDiscSess: Result recordset EOF, "
                                "0 rows"));
                        goto PostUnpackResultSet;
                    }
                }
                else {
                    ERR((TB,"GetServersWDiscSess: Failed get_EOF, hr=0x%X", 
                            hr));
                    goto PostUnpackResultSet;
                }
            }
            else {
                ERR((TB,"GetServersWDiscSess: Closed result recordset"));
                goto PostUnpackResultSet;
            }
        }
        else {
            ERR((TB,"GetServersWDiscSess: 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(adGetRowsRest, varStart,
                varFields, pVarRows);
        if (SUCCEEDED(hr)) {
            hr = SafeArrayGetUBound(pVarRows->parray, 2, &NumRecords);
            if (SUCCEEDED(hr)) {
                // 0-based array bound was returned, num rows is that + 1.
                NumRecords++;

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


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

    *pNumSessionsReturned = NumRecords;
    return hr;
}
#endif


/****************************************************************************/
// DISDebugControlHandler
//
// Handle console control events for when service is in debug mode.
/****************************************************************************/
BOOL WINAPI DISDebugControlHandler(DWORD dwCtrlType) {

    switch(dwCtrlType)
    {
    case CTRL_BREAK_EVENT:
    case CTRL_C_EVENT:
        TSDISErrorOut(L"Stopping service\n");

        SetEvent(g_hStopServiceEvent);
        // Should I wait for that to complete?

        return TRUE;
        break;
    }
    return FALSE;
}


/****************************************************************************/
// DISPingServer
//
// Given the IP address of a server, pings it.  Returns TRUE on success, FALSE 
// on failure.
/****************************************************************************/
BOOLEAN DISPingServer(WCHAR *ServerAddress) {
    HANDLE hServer = NULL;
    hServer = WinStationOpenServer(ServerAddress);

    // The only case where we return false is where hServer is NULL and the
    // reason is not ERROR_ACCESS_DENIED.
    if (hServer == NULL) {
        if (GetLastError() != ERROR_ACCESS_DENIED)
            return FALSE;
    }
    else {
        // The hServer is valid, so clean up.
        WinStationCloseServer(hServer);
    }
    return TRUE;
}


/****************************************************************************/
// DISGetServerStatus
//
// Given the IP address of a server, determines its state (Responding or 
// NotResponding).
// 
// Currently implemented as a ping.  See lengthy comment in main for one
// possible future optimization.
/****************************************************************************/
SERVER_STATUS DISGetServerStatus(WCHAR *ServerAddress) {

    switch (g_PingMode) {

    case AlwaysFail:
        return NotResponding;

    case AlwaysSucceed:
        return Responding;

    case NormalMode:
        // NOTE INTENTIONAL FALLTHROUGH.
    default:
        if (DISPingServer(ServerAddress) == TRUE)
            return Responding;
        else
            return NotResponding;

    }

}


#if 0
HRESULT DISSQLInitialize() {
    // Retrieve number of seconds to wait from the registry -- NOT IMPLEMENTED
    HRESULT hr = S_OK;
    BSTR ConnectString = NULL;
    LONG RegRetVal;
    HKEY hKey;
    BSTR ConnectStr = NULL;
    BSTR UserStr = NULL;
    BSTR PwdStr = NULL;

    RegRetVal = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
            TEXT("Software\\Microsoft\\DIS"), 0, KEY_READ, &hKey);
    if (RegRetVal == ERROR_SUCCESS) {
        DWORD Type, DataSize;

        // Determine the needed size.
        DataSize = 0;
        RegRetVal = RegQueryValueExW(hKey, L"ConnectString", NULL,
                &Type, NULL, &DataSize);
        DataSize &= ~1;
        if (RegRetVal == ERROR_SUCCESS && Type == REG_SZ) {
            ConnectString = SysAllocStringLen(L"", DataSize /
                    sizeof(WCHAR));
            if (ConnectString != NULL) {
                RegRetVal = RegQueryValueExW(hKey, L"ConnectString",
                        NULL, &Type, (BYTE *)ConnectString,
                        &DataSize);
                if (RegRetVal == ERROR_SUCCESS) {
                    // Hold onto the connect string for use below.
                    TRC1((TB,"Retrieved conn str %S", ConnectString));
                }
                else {
                    ERR((TB,"Final RegQuery failed, err=%u", RegRetVal));
                    hr = E_FAIL;
                    goto Cleanup;
                }
            }
            else {
                ERR((TB,"Failed alloc connect string"));
                hr = E_OUTOFMEMORY;
                goto Cleanup;
            }
        }
        else {
            ERR((TB,"Failed RegQuery - err=%u, DataSize=%u, type=%u",
                    RegRetVal, DataSize, Type));
            hr = E_FAIL;
            goto Cleanup;
        }

        RegCloseKey(hKey);
    }
    else {
        ERR((TB,"RegOpenKeyEx returned err %u", RegRetVal));
        hr = E_FAIL;
        goto Cleanup;
    }

    hr = CoInitialize(NULL);

    // Alloc the BSTRs for the connection.
    ConnectStr = SysAllocString(ConnectString);
    UserStr = SysAllocString(L"");
    PwdStr = SysAllocString(L"");

    if ((ConnectStr == NULL) || (UserStr == NULL) || (PwdStr == NULL)) {
        ERR((TB, "Failed alloc Connect, User, or PwdStr"));
        hr = E_OUTOFMEMORY;
        goto Cleanup;
    }

    // Create an ADO connection instance and connect.
    hr = CoCreateInstance(CLSID_CADOConnection, NULL,
            CLSCTX_INPROC_SERVER, IID_IADOConnection,
            (LPVOID *)&g_pConnection);
    if (SUCCEEDED(hr)) {
        // Do the open.
        hr = g_pConnection->Open(ConnectStr, UserStr, PwdStr,
                adOpenUnspecified);
        if (!SUCCEEDED(hr)) {
            ERR((TB,"Failed open DB, hr=0x%X", hr));
            g_pConnection->Release();
            g_pConnection = NULL;
        }
    }
    else {
        ERR((TB,"CoCreate(ADOConn) returned 0x%X", hr));
    }

Cleanup:

    // SysFreeString(NULL) is ok.
    SysFreeString(ConnectString);
    SysFreeString(ConnectStr);
    SysFreeString(UserStr);
    SysFreeString(PwdStr);

    return hr;
}
#endif


// Call each TS Server to ask them to rejoin SD
void __cdecl DISOpenServer(void *Para)
{
    HRESULT hr;
    WCHAR *pBindingString = NULL;
    RPC_BINDING_HANDLE hRPCBinding = NULL;
    WCHAR *szPrincipalName = NULL;
    WCHAR *ServerName = NULL;
    SDRecoverServerNames *SDRRecoverServerPara = (SDRecoverServerNames *)Para;
    unsigned int count = SDRRecoverServerPara->count;
    WCHAR ** ServerNameArray = SDRRecoverServerPara->ServerNameArray;
    unsigned int i;
    unsigned long RpcException;
    DWORD dwRejoinFlag = 0;

    dwRejoinFlag |= TSSD_FORCEREJOIN;

    // Impersonate the cluster account to make the rejoin RPC call
    if (g_dwClusterState == ClusterStateRunning) {
        if (g_hClusterToken) {
            if(!ImpersonateLoggedOnUser(g_hClusterToken)) {
                // If we failed to impersonate the cluster account, don't ask TS to rejoin, since it will 
                //  fail anyway due to access denied
                TSDISErrorOut(L"SD Recover: Error %d in ImpersonateLoggedOnUser\n", GetLastError());
                goto HandleError;
            }
        }
        else {
            // If g_hClusterToken is NULL, don't ask TS to rejoin, since it will 
            //  fail anyway due to access denied
            goto HandleError;
        }
    }

    // If it's on failover cluster, set the flag to tell server not to repopulate its sessions
    if (g_RepopulateSession == FALSE) {
        dwRejoinFlag |= TSSD_NOREPOPULATE;
    }

    for (i=0;i<count;i++) {
        if (NULL != hRPCBinding) {
            RpcBindingFree(&hRPCBinding);
            hRPCBinding = NULL;
        }
    
        ServerName = *(ServerNameArray + i);
        // Connect to the tssdjet RPC server according to the server name provided.
        // We first create an RPC binding handle from a composed binding string.
        hr = RpcStringBindingCompose(/*(WCHAR *)g_RPCUUID,*/
                0,
                L"ncacn_ip_tcp", ServerName,
                0,
                NULL, &pBindingString);

        if (hr == RPC_S_OK) {
            // Generate the RPC binding from the canonical RPC binding string.
            hr = RpcBindingFromStringBinding(pBindingString, &hRPCBinding);
            if (hr != RPC_S_OK) {
                ERR((TB,"SD Recover: Error %d in RpcBindingFromStringBinding\n", hr));
                goto LogError;
            } 
        }
        else {
            ERR((TB,"SD Recover: Error %d in RpcStringBindingCompose\n", hr));
            goto LogError;
        }

        hr = RpcEpResolveBinding(hRPCBinding, TSSDTOJETRPC_ClientIfHandle);
        if (hr != RPC_S_OK) {
            ERR((TB, "SD Recover: Error %d in RpcEpResolveBinding", hr));
            goto LogError;
        }

        hr = RpcMgmtInqServerPrincName(hRPCBinding,
                                       RPC_C_AUTHN_GSS_NEGOTIATE,
                                       &szPrincipalName);
        if (hr != RPC_S_OK) {
            ERR((TB,"SD Recover: Error %d in RpcMgmtIngServerPrincName", hr));
            goto LogError;
        }

        hr = RpcBindingSetAuthInfo(hRPCBinding,
                                szPrincipalName,
                                RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
                                RPC_C_AUTHN_GSS_NEGOTIATE,
                                NULL,  //CurrentIdentity
                                NULL);
        RpcStringFree(&szPrincipalName);

        if (hr != RPC_S_OK) {
            ERR((TB,"SD Recover: Error %d in RpcBindingSetAuthInfo", hr));
            goto LogError;
        } 

        RpcTryExcept {
            // Make the call to TS to ask it to rejoin
            hr = TSSDRPCRejoinSD(hRPCBinding, dwRejoinFlag);
        }
        RpcExcept(TSSDRpcExceptionFilter(RpcExceptionCode())) {
            RpcException = RpcExceptionCode();
            hr = RpcException;
            ERR((TB,"ForceRejoin: RPC Exception %d\n", RpcException));
        }
        RpcEndExcept
                
LogError:
        if (hr != RPC_S_OK) {
            PostSessDirErrorMsgEvent(EVENT_FAIL_CALL_TS_REJOIN, ServerName, EVENTLOG_ERROR_TYPE);
        }
    }

    // Stop Impersonating
    if (g_dwClusterState == ClusterStateRunning) {
        RevertToSelf();
    }

HandleError:

    if (NULL != hRPCBinding) {
        RpcBindingFree(&hRPCBinding);
        hRPCBinding = NULL;
    }
    // Free 
    for (i=0;i<count;i++) {
        LocalFree(*(ServerNameArray + i));
    }
    LocalFree(ServerNameArray);
    LocalFree(SDRRecoverServerPara);
    
    return;
}

// When SD service is restarted, try to recover the Servers in the SD
// Jet database and ask them to rejoin SD
BOOL DISJetRecover()
{
    JET_SESID sesid = JET_sesidNil;;
    JET_TABLEID servdirtableid;
    JET_DBID dbid = JET_dbidNil;
    JET_COLUMNDEF jcd;
    JET_COLUMNID ServerAddrCId;
    JET_ERR err = JET_errSuccess;
    unsigned long i, count = 0;
    WCHAR ServerName[SERVER_ADDRESS_LENGTH];
    WCHAR **ServerNameArray = NULL;
    unsigned long cbActual;
    SDRecoverServerNames *pSDRecoverServerPara;

    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramSystemPath, 
            0, JETDISDBDIRECTORY));
    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramTempPath,
            0, JETDISDBDIRECTORY));
    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramLogFilePath,
            0, JETDISDBDIRECTORY));
    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramCircularLog,
            1, NULL));
    
    CALL(JetInit(&g_instance));
    CALL(JetBeginSession(g_instance, &sesid, "user", ""));

        

    CALL(JetAttachDatabase(sesid, JETDBFILENAME, 0));

    // Populate our columnid arrays
    CALL(JetOpenDatabase(sesid, JETDBFILENAME, "", &dbid, 0));

    CALL(JetOpenTable(sesid, dbid, "ServerDirectory", NULL, 0, 0, 
                &servdirtableid));

    CALL(JetBeginTransaction(sesid));

    CALL(JetGetColumnInfo(sesid, dbid, "ServerDirectory",
                    ServerDirectoryColumns[SERVDIR_SERVADDR_INTERNAL_INDEX].szColumnName, &jcd,
                    sizeof(jcd), 0));
    ServerAddrCId = jcd.columnid;

    pSDRecoverServerPara = (SDRecoverServerNames *)LocalAlloc(LMEM_FIXED, sizeof(SDRecoverServerNames));
    if (NULL == pSDRecoverServerPara) {
        goto HandleError;
    }
    // Get number of TS Servers in the SD
    err = JetIndexRecordCount(sesid, servdirtableid, &count, MAX_TSSERVERS_TO_RECOVER);

    if (err != JET_errSuccess)
        goto HandleError;
    if (count) {
        CALL(JetMove(sesid, servdirtableid, JET_MoveFirst, 0));
        ServerNameArray = (WCHAR **)LocalAlloc(LMEM_FIXED, count * sizeof(WCHAR *));
        if (NULL == ServerNameArray) {
            goto HandleError;
        }
    }
    TSDISErrorOut(L"We have %d Servers to recover\n", count);
    for(i=0;i<count;i++)
    {
        CALL(JetRetrieveColumn(sesid, servdirtableid, ServerAddrCId,
                          ServerName, SERVER_ADDRESS_LENGTH, &cbActual, 0, NULL));
        TSDISErrorOut(L"Server %d is %s\n", i+1, ServerName);

        *(ServerNameArray + i) = (WCHAR *)LocalAlloc(LMEM_FIXED, sizeof(ServerName));
        if (NULL == *(ServerNameArray+i)) {
            goto HandleError;
        }
        memcpy((BYTE *)(*(ServerNameArray + i)), (BYTE*)ServerName, sizeof(ServerName));

        if (i != (count-1))
            CALL(JetMove(sesid, servdirtableid, JET_MoveNext, 0));
    }
    // Spin a thread to call TS servers to rejoin SD
    pSDRecoverServerPara->count = count;
    pSDRecoverServerPara->ServerNameArray = ServerNameArray;
    if(-1 == _beginthread(DISOpenServer, 0, (PVOID)pSDRecoverServerPara)) {
        TSDISErrorOut(L"Unable to begin DISOpenServer thread\n");
        // Free mem
        for (i=0;i<count;i++) {
            LocalFree(*(pSDRecoverServerPara->ServerNameArray + i));
        }
        LocalFree(pSDRecoverServerPara->ServerNameArray);
        LocalFree(pSDRecoverServerPara);

    }

    CALL(JetCommitTransaction(sesid, 0));


    CALL(JetCloseTable(sesid, servdirtableid));

    CALL(JetCloseDatabase(sesid, dbid, 0));

    CALL(JetEndSession(sesid, 0));

    CALL(JetTerm(g_instance));
    g_instance = 0;

    return TRUE;

HandleError: 
    if (sesid != JET_sesidNil) {
        // Can't really recover.  Just bail out.
        (VOID) JetRollback(sesid, JET_bitRollbackAll);

        // Force the session closed
        (VOID) JetEndSession(sesid, JET_bitForceSessionClosed);
    }
    
    JetTerm(g_instance);
    g_instance = 0;

    return FALSE;
}

// Delete the database and all other JET files (if present)
void DeleteJetFiles()
{
    HANDLE hFileFind;
    WIN32_FIND_DATA FindFileData;
    WCHAR filename[MAX_LOGFILE_LENGTH];
    DWORD dwError;

    // Delete the database and all other JET files (if present), and start anew.
    (void) DeleteFile(JETDBFILENAMEW);
    (void) DeleteFile(JETAUXFILENAME1W);
    (void) DeleteFile(JETAUXFILENAME2W);
    (void) DeleteFile(JETAUXFILENAME3W);
    (void) DeleteFile(JETAUXFILENAME4W);
    (void) DeleteFile(JETAUXFILENAME5W);
    (void) DeleteFile(JETAUXFILENAME6W);

    // Delete numbered log files.  Jet can create a bunch of log files
    // of the form edb00001.log, edb00002.log, . . ., edb0000a.log,
    // edb0000b.log, . . ., edb0000f.log, edb00010.log, . . .
    hFileFind = FindFirstFile(JETLOGFILENAME, &FindFileData);
    if (hFileFind != INVALID_HANDLE_VALUE) {
        swprintf(filename, JETDISDBDIRECTORYW);
        wcsncat(filename, FindFileData.cFileName, MAX_LOGFILE_LENGTH - sizeof(JETDISDBDIRECTORYW) / sizeof(WCHAR) - 1);
        if (DeleteFile(filename) == 0) {
            dwError = GetLastError();
            if (dwError != ERROR_FILE_NOT_FOUND) {
                PostSessDirErrorValueEvent(EVENT_PROBLEM_DELETING_LOGS, 
                        dwError, EVENTLOG_ERROR_TYPE);
            }
        }
        while (FindNextFile(hFileFind, &FindFileData)) {
            swprintf(filename, JETDISDBDIRECTORYW);
            wcsncat(filename, FindFileData.cFileName, MAX_LOGFILE_LENGTH - sizeof(JETDISDBDIRECTORYW) / sizeof(WCHAR) - 1);
            if (DeleteFile(filename) == 0) {
                dwError = GetLastError();
                if (dwError != ERROR_FILE_NOT_FOUND) {
                    PostSessDirErrorValueEvent(EVENT_PROBLEM_DELETING_LOGS, 
                            dwError, EVENTLOG_ERROR_TYPE);
                    break;
                }
            }
        }

        FindClose(hFileFind);
    }
}

//
// Session directory initialization on fail-over cluster
//
// Return True on success
//
BOOL DISJetInitInCluster()
{
    BOOL fRet = FALSE;
    DWORD dwError;
    HCLUSTER hclus = NULL;
    HRESOURCE hrSD = NULL;
    WCHAR *pszDriveLetter = NULL;
    DWORD cchDriveLetter = MAX_DRIVE_LETTER_LENGTH;
    HCLUSENUM hClusEnum = NULL;
    DWORD dwIndex, dwCount;
    WCHAR ResourceName[256], *ServiceName;
    DWORD dwSize, dwType;
    LPVOID pPropertyList = NULL;
    DWORD rc;
    BOOL bFindSDService = FALSE;
    HRESOURCE hrNetworkName = NULL;
    struct CLUS_NETNAME_VS_TOKEN_INFO VsTokenInfo;
    DWORD dwReturnSize = 0;
    HANDLE hVSToken = NULL;

    // Change the current directory to the right place on the shared
    // drive.

    // Open the cluster.
    hclus = OpenCluster(NULL);

    if (hclus == NULL) {
        // TODO: Log event.
        TSDISErrorOut(L"Unable to open cluster, error %d\n", 
                      GetLastError());
        goto HandleError;
    }

    // Enuerate all the resources in the cluster to find the generic service
    // resource named "tssdis" i.e. the session directory service
    hClusEnum = ClusterOpenEnum(hclus, CLUSTER_ENUM_RESOURCE);
    if (hClusEnum == NULL) {
        // TODO: Log event.
        TSDISErrorOut(L"Unable to open cluster enum, error %d\n",
                      GetLastError());
        goto HandleError;
    }
    dwCount = ClusterGetEnumCount(hClusEnum);

    for (dwIndex=0; dwIndex<dwCount; dwIndex++) {
        if (pPropertyList != NULL) {
            LocalFree(pPropertyList);
            pPropertyList = NULL;
        }
        if (hrSD != NULL) {
            CloseClusterResource(hrSD);
            hrSD = NULL;
        }

        dwSize = sizeof(ResourceName) / sizeof(WCHAR);
        if (ClusterEnum(hClusEnum, dwIndex, &dwType, 
                        ResourceName, &dwSize) != ERROR_SUCCESS) {
            TSDISErrorOut(L"ClusterEnum fails with error %d\n",
                          GetLastError());
            continue;
        }
        hrSD = OpenClusterResource(hclus, ResourceName);
        if (hrSD == NULL) {
            TSDISErrorOut(L"OpenClusterResource fails with error %d\n",
                          GetLastError());
            continue;
        }
        pPropertyList = NULL;
        dwSize = 0;
        rc = ClusterResourceControl(hrSD,                                           // hResource
                                    NULL,                                           // hHostNode
                                    CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES,        // dwControlCode
                                    NULL,                                           // lpInBuffer
                                    0,                                              // cbInBufferSize
                                    NULL,                                           // lpOutBuffer
                                    0,                                              // cbOutBufferSiz 
                                    &dwSize);                                       // lpcbByteReturned


        if (rc != ERROR_SUCCESS) {
            TSDISErrorOut(L"ResourceControl fails with error %d\n", rc);
            continue;
        }
        dwSize += sizeof(WCHAR);
        pPropertyList = LocalAlloc(LMEM_FIXED, dwSize);
        if (pPropertyList == NULL) {
            TSDISErrorOut(L"Can't allocate memory for propertylist with size %d\n", dwSize);
            continue;
        }
        rc = ClusterResourceControl(hrSD, 
                                    NULL, 
                                    CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES, 
                                    NULL, 
                                    0, 
                                    pPropertyList, 
                                    dwSize,
                                    NULL);
        if (rc != ERROR_SUCCESS) {
            TSDISErrorOut(L"ResourceControl fails with error %d\n", rc);
            continue;
        }

        rc = ResUtilFindSzProperty(pPropertyList, dwSize, L"ServiceName", &ServiceName);
        if (rc == ERROR_SUCCESS) {
            if (_wcsicmp(ServiceName, L"tssdis") == 0) {
                TSDISErrorOut(L"Find tssdis resource\n");
                bFindSDService = TRUE;
                LocalFree(ServiceName);
                break;
            }
            if (ServiceName != NULL) {
                LocalFree(ServiceName);
                ServiceName = NULL;
            }
        }

        CloseClusterResource(hrSD);
        hrSD = NULL;
    }
    if (pPropertyList != NULL) {
        LocalFree(pPropertyList);
        pPropertyList = NULL;
    }
    ClusterCloseEnum(hClusEnum);

    // Bail out if can't find tssdis resource
    if (!bFindSDService) {
        // TODO: Log event.
        TSDISErrorOut(L"Unable to find the resource with service name tssdis\n");
        goto HandleError;
    }

    // Find the network name resource
    hrNetworkName = ResUtilGetResourceDependency(hrSD, L"Network Name");
    if (hrNetworkName == NULL) {
        TSDISErrorOut(L"Unable to get the dependent NetworkName resource, error is %d\n", GetLastError());
        goto HandleError;
    }

    pPropertyList = NULL;
    dwSize = 0;
    // Get the property of the network name resource
    // This is the 1st call, just get the size of the porperty list
    rc = ClusterResourceControl(hrNetworkName,                                  // hResource
                                NULL,                                           // hHostNode
                                CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES,        // dwControlCode
                                NULL,                                           // lpInBuffer
                                0,                                              // cbInBufferSize
                                NULL,                                           // lpOutBuffer
                                0,                                              // cbOutBufferSiz 
                                &dwSize);                                       // lpcbByteReturned


    if (rc != ERROR_SUCCESS) {
        TSDISErrorOut(L"ResourceControl fails with error %d\n", rc);
        goto HandleError;
    }
    dwSize += sizeof(WCHAR);
    pPropertyList = LocalAlloc(LMEM_FIXED, dwSize);
    if (pPropertyList == NULL) {
        TSDISErrorOut(L"Can't allocate memory for propertylist with size %d\n", dwSize);
        goto HandleError;
    }
    // Get the property of the network name resource
    rc = ClusterResourceControl(hrNetworkName, 
                                NULL, 
                                CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES, 
                                NULL, 
                                0, 
                                pPropertyList, 
                                dwSize,
                                NULL);
    if (rc != ERROR_SUCCESS) {
        TSDISErrorOut(L"ResourceControl fails with error %d\n", rc);
        goto HandleError;
    }

    // Find the "name" propery in the property list
    rc = ResUtilFindSzProperty(pPropertyList, dwSize, L"Name", &g_ClusterNetworkName);
    if (rc != ERROR_SUCCESS) {
        g_ClusterNetworkName = NULL;
        TSDISErrorOut(L"ResUtilFindSzProperty fails with error %d\n", rc);
        goto HandleError;
    }
    if (pPropertyList != NULL) {
        LocalFree(pPropertyList);
        pPropertyList = NULL;
    }

    VsTokenInfo.ProcessID = GetCurrentProcessId();
    VsTokenInfo.DesiredAccess = 0;
    VsTokenInfo.InheritHandle = FALSE;

    // Get the token of the virtual server
    rc = ClusterResourceControl(
                       hrNetworkName,
                       0,
                       CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN,
                       &VsTokenInfo,
                       sizeof(CLUS_NETNAME_VS_TOKEN_INFO),
                       &hVSToken,
                       sizeof(HANDLE),
                       &dwReturnSize
                       );
    if (rc != ERROR_SUCCESS) {
        TSDISErrorOut(L"Get the virtual server token failed with error %d\n", rc);
        hVSToken = NULL;
        goto HandleError;
    }

    // Duplicate the virtual server token
    if(!DuplicateTokenEx(
            hVSToken,
            MAXIMUM_ALLOWED,
            NULL,
            SecurityImpersonation,
            TokenImpersonation,
            &g_hClusterToken)) {
        TSDISErrorOut(L"DuplicateTokenEx failed with error %d\n", GetLastError());
        CloseHandle(hVSToken);
        hVSToken = NULL;
        g_hClusterToken = NULL;

        goto HandleError;
    }
    if (hVSToken) {
        CloseHandle(hVSToken);
        hVSToken = NULL;
    }


    pszDriveLetter = new WCHAR[cchDriveLetter];

    if (pszDriveLetter == NULL) {
        TSDISErrorOut(L"Failed to allocate memory for drive letter.\n");
        goto HandleError;
    }

    // Get the drive we're supposed to use.
    dwError = ResUtilFindDependentDiskResourceDriveLetter(hclus, hrSD,
                                                          pszDriveLetter, &cchDriveLetter);

    if (dwError == ERROR_MORE_DATA) {
        // Wow, big drive letter!
        delete [] pszDriveLetter;
        pszDriveLetter = new WCHAR[cchDriveLetter];

        if (pszDriveLetter == NULL) {
            TSDISErrorOut(L"Failed to allocate memory for drive letter\n");
            goto HandleError;
        }

        dwError = ResUtilFindDependentDiskResourceDriveLetter(hclus, hrSD,
                                                              pszDriveLetter, &cchDriveLetter);
    }

    if (dwError != ERROR_SUCCESS) {
        TSDISErrorOut(L"Could not determine resource drive letter.\n");
        delete [] pszDriveLetter;
        pszDriveLetter = NULL;
        goto HandleError;
    }

    // Switch the working directory to that drive.
    if (SetCurrentDirectory(pszDriveLetter) == FALSE) {
        TSDISErrorOut(L"Could not set current directory to that of "
                      L"shared disk %s.  Error=%d\n", pszDriveLetter, 
                      GetLastError());
        delete [] pszDriveLetter;
        pszDriveLetter = NULL;
        goto HandleError;
    }
    fRet = TRUE;

HandleError:

    if (pszDriveLetter != NULL) {
        delete [] pszDriveLetter;
        pszDriveLetter = NULL;
    }
    if (pPropertyList != NULL) {
        LocalFree(pPropertyList);
        pPropertyList = NULL;
    }
    if (hrSD != NULL) {
        CloseClusterResource(hrSD);
        hrSD = NULL;
    }  
    if (hrNetworkName != NULL) {
        CloseClusterResource(hrNetworkName);
        hrNetworkName = NULL;
    }
    if (hclus != NULL) {
        CloseCluster(hclus);
        hclus = NULL;
    }
    return fRet;
}


HRESULT DISJetInitialize()
{
    JET_SESID sesid = JET_sesidNil;;
    JET_TABLEID sessdirtableid;
    JET_TABLEID servdirtableid;
    JET_TABLEID clusdirtableid;
    JET_DBID dbid = JET_dbidNil;

    JET_ERR err = JET_errSuccess;
    JET_TABLECREATE tSess;
    JET_COLUMNCREATE cSess[NUM_SESSDIRCOLUMNS];
    JET_TABLECREATE tServ;
    JET_COLUMNCREATE cServ[NUM_SERVDIRCOLUMNS];
    JET_TABLECREATE tClus;
    JET_COLUMNCREATE cClus[NUM_CLUSDIRCOLUMNS];
    unsigned count;
    DWORD dwError;
    BOOL br;
    SECURITY_ATTRIBUTES SA;
    SYSTEMTIME SystemTime;
    ULARGE_INTEGER ulCurrentTime;
    ULARGE_INTEGER ulLastTime;


    g_dwClusterState = ClusterStateNotInstalled;

    //
    // This is a string security descriptor.  Look up "Security Descriptor 
    // Definition Language" in MSDN for more details.
    //
    // This one says:
    //
    // D: <we are creating a DACL>
    // (A; <Allow ACE>
    // OICI; <Perform object and container inheritance, i.e., let files and 
    //        directories under this one have these attributes>
    // GA <Generic All Access--Full Control>
    // ;;;SY) <SYSTEM>
    // (A;OICI;GA;;;BA) <same for Builtin Administrators group>
    // (A;OICI;GA;;;CO) <same for creator/owner>
    //
    // We'll use it below to create our directory with the right permissions.

    WCHAR *pwszSD = L"D:(A;OICI;GA;;;SY)(A;OICI;GA;;;BA)(A;OICI;GA;;;CO)";

    // Failover support--before reactivating, check logic versus reading curr directory from registry.


    // First, determine whether we are running in a cluster.  If so, files
    // will have to go on the shared drive.  If not, files will go in
    // JETDISDBDIRECTORYW.
    dwError = GetNodeClusterState(NULL, &g_dwClusterState);

    if (dwError != ERROR_SUCCESS) {
        g_dwClusterState = ClusterStateNotInstalled;
        TSDISErrorOut(L"TSDIS: Unable to get cluster state, err = %d\n", 
                      dwError);
    }

    // Do initialization if running on fail-over cluster
    if (g_dwClusterState == ClusterStateRunning) {
        if (!DISJetInitInCluster()) {
            goto HandleError;
        }
    }


    // Create security descriptor for database directory

    SA.nLength = sizeof(SECURITY_ATTRIBUTES);
    SA.bInheritHandle = FALSE;
    SA.lpSecurityDescriptor = NULL;
    br = ConvertStringSecurityDescriptorToSecurityDescriptor(pwszSD, 
                                                             SDDL_REVISION_1, &(SA.lpSecurityDescriptor), NULL);

    if (br == 0) {
        PostSessDirErrorValueEvent(EVENT_COULDNOTSECUREDIR, GetLastError(), EVENTLOG_ERROR_TYPE);
        goto HandleError;
    }

    // Create the system32\tssesdir directory.
    if (CreateDirectory(JETDISDBDIRECTORYW, &SA) == 0) {
        if (ERROR_ALREADY_EXISTS != (dwError = GetLastError())) {
            PostSessDirErrorValueEvent(EVENT_COULDNOTCREATEDIR, dwError, EVENTLOG_ERROR_TYPE);
            goto HandleError;
        }
    } else {
        // We created it successfully, so set the directory attributes to not 
        // compress.

        // Obtain a handle to the directory.
        HANDLE hSDDirectory = CreateFile(JETDISDBDIRECTORYW, GENERIC_READ | 
                                         GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
                                         OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

        if (INVALID_HANDLE_VALUE != hSDDirectory) {
            // We've succeeded opening the directory.

            USHORT CompressionState = COMPRESSION_FORMAT_NONE;
            USHORT OldCompressionState;
            DWORD BytesReturned = 0;

            // Get the current compression state.
            if (DeviceIoControl(hSDDirectory, FSCTL_GET_COMPRESSION,
                                NULL, 0, &OldCompressionState, sizeof(USHORT), 
                                &BytesReturned, NULL) != 0) {

                // If the current compression state is compressed, uncompress.
                if (OldCompressionState != COMPRESSION_FORMAT_NONE) {
                    if (DeviceIoControl(hSDDirectory, FSCTL_SET_COMPRESSION, 
                                        &CompressionState, sizeof(USHORT), NULL, 0, 
                                        &BytesReturned, NULL) == 0) {
                        // Set compression state failed--this should only be a trace,
                        // it may merely mean that the drive is FAT.
                        TSDISErrorOut(L"TSDIS: Set compression state off failed, "
                                      L"lasterr=0x%X\n", GetLastError());
                    } else {
                        PostSessDirErrorValueEvent(EVENT_UNDID_COMPRESSION, 0, EVENTLOG_ERROR_TYPE);
                    }
                }
            }

            CloseHandle(hSDDirectory);

        } else {
            // Nonfatal to have an error opening the directory
            TSDISErrorOut(L"TSDIS: Open directory to change compression state "
                          L"failed, lasterr=0x%X\n", GetLastError());
        }
    }

    // Open the timestamp file, compare with current time
    //  If the time difference is less than a limit, reuse the db
    //  otherwise delete db files
    g_hTimeFile = CreateFile(JETTIMESTAMPFILEW,
                             GENERIC_WRITE,
                             FILE_SHARE_WRITE,
                             &SA,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL,
                             NULL);
    if (g_hTimeFile == INVALID_HANDLE_VALUE) {
        // This file doesn't exist, create new one
        g_hTimeFile = CreateFile(JETTIMESTAMPFILEW,
                                 GENERIC_WRITE,
                                 FILE_SHARE_WRITE,
                                 &SA,
                                 CREATE_NEW,
                                 FILE_ATTRIBUTE_NORMAL,
                                 NULL);           
    } 
    else {
        if (GetFileTime(g_hTimeFile, NULL, NULL, (FILETIME *)&ulLastTime)) {
            GetSystemTime(&SystemTime);
            if (SystemTimeToFileTime(&SystemTime, (FILETIME *) &ulCurrentTime)) {
                if ((ulCurrentTime.QuadPart - ulLastTime.QuadPart) < g_TimeLimitToDeleteDB) {
                    if (g_dwClusterState == ClusterStateRunning) {
                        g_RepopulateSession = FALSE;
                        TSDISErrorOut(L"SD in restarted within a time limit, database can be reused\n");
                    }
                }
            }
        } 
        else
            TSDISErrorOut(L"SD is not restarted within a time limit, need to delete DB files \n");
    }

    // Recover Servers in Jet Database 
    if (g_RecoverWhenStart > NO_RECOVER_WHEN_START)
        DISJetRecover();
    // Delete database files if tssdis is not running on failover cluster
    //if (g_dwClusterState != ClusterStateRunning)
    if (g_RepopulateSession == TRUE)
        DeleteJetFiles();

    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramSystemPath, 
                               0, JETDISDBDIRECTORY));
    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramTempPath,
                               0, JETDISDBDIRECTORY));
    //CALL(JetSetSystemParameter(&g_instance, 0, JET_paramMaxSessions,
    //        JETDISMAXSESSIONS, NULL));
    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramLogFilePath,
                               0, JETDISDBDIRECTORY));
    CALL(JetSetSystemParameter(&g_instance, 0, JET_paramCircularLog,
                               1, NULL));

    CALL(JetInit(&g_instance));
    CALL(JetBeginSession(g_instance, &sesid, "user", ""));
    err = JetCreateDatabase(sesid, JETDBFILENAME, "", &dbid, 0);

    if (JET_errDatabaseDuplicate == err) {
        JET_COLUMNDEF jcd;

        err = JetAttachDatabase(sesid, JETDBFILENAME, 0);

        // if we get a wrnDatabaseAttached, then we have recovered.  Otherwise,
        // check the return value as usual.
        if (JET_wrnDatabaseAttached != err) {
            CALL(err);
        }

        // Populate our columnid arrays
        CALL(JetOpenDatabase(sesid, JETDBFILENAME, "", &dbid, 0));

        CALL(JetOpenTable(sesid, dbid, "SessionDirectory", NULL, 0, 0, 
                          &sessdirtableid));
        CALL(JetOpenTable(sesid, dbid, "ServerDirectory", NULL, 0, 0, 
                          &servdirtableid));
        CALL(JetOpenTable(sesid, dbid, "ClusterDirectory", NULL, 0, 0, 
                          &clusdirtableid));

        CALL(JetBeginTransaction(sesid));

        for (count = 0; count < NUM_SESSDIRCOLUMNS; count++) {
            CALL(JetGetColumnInfo(sesid, dbid, "SessionDirectory", 
                                  SessionDirectoryColumns[count].szColumnName, &jcd, 
                                  sizeof(jcd), 0));
            sesdircolumnid[count] = jcd.columnid;
        }
        for (count = 0; count < NUM_SERVDIRCOLUMNS; count++) {
            CALL(JetGetColumnInfo(sesid, dbid, "ServerDirectory",
                                  ServerDirectoryColumns[count].szColumnName, &jcd,
                                  sizeof(jcd), 0));
            servdircolumnid[count] = jcd.columnid;
        }
        for (count = 0; count < NUM_CLUSDIRCOLUMNS; count++) {
            CALL(JetGetColumnInfo(sesid, dbid, "ClusterDirectory",
                                  ClusterDirectoryColumns[count].szColumnName, &jcd,
                                  sizeof(jcd), 0));
            clusdircolumnid[count] = jcd.columnid;
        }

        CALL(JetCommitTransaction(sesid, 0));

        goto NormalExit;
    } else {
        CALL(err);
    }

    CALL(JetBeginTransaction(sesid));

    // Set up to create session directory schema
    tSess.cbStruct = sizeof(tSess);
    tSess.szTableName = "SessionDirectory";
    tSess.szTemplateTableName = NULL;
    tSess.ulPages = 0;
    tSess.ulDensity = 100;
    tSess.rgcolumncreate = &cSess[0];
    tSess.cColumns = NUM_SESSDIRCOLUMNS;
    tSess.rgindexcreate = NULL;
    tSess.cIndexes = 0;
    tSess.grbit = JET_bitTableCreateFixedDDL;

    for (count = 0; count < NUM_SESSDIRCOLUMNS; count++) {
        cSess[count].cbStruct = sizeof(JET_COLUMNCREATE);
        cSess[count].szColumnName = SessionDirectoryColumns[count].szColumnName;
        cSess[count].coltyp = SessionDirectoryColumns[count].coltyp;
        cSess[count].cbMax = SessionDirectoryColumns[count].colMaxLen;
        cSess[count].grbit = 0;
        cSess[count].pvDefault = NULL;
        cSess[count].cbDefault = 0;
        cSess[count].cp = 1200;
        cSess[count].columnid = 0;
        cSess[count].err = JET_errSuccess;
    }


    // Actually create the session directory table.
    CALL(JetCreateTableColumnIndex(sesid, dbid, &tSess));

    // Store columnids, tableid for later reference.
    for (count = 0; count < NUM_SESSDIRCOLUMNS; count++) {
        sesdircolumnid[count] = cSess[count].columnid;
    }
    sessdirtableid = tSess.tableid;

    // Create server, session index.
    CALL(JetCreateIndex(sesid, sessdirtableid, "primaryIndex", 0, 
                        "+ServerID\0+SessionID\0", sizeof("+ServerID\0+SessionID\0"), 
                        100));
    // Create index by server for deletion.
    CALL(JetCreateIndex(sesid, sessdirtableid, "ServerIndex", 0,
                        "+ServerID\0", sizeof("+ServerID\0"), 100));
    // Create index for disconnected session retrieval.
    CALL(JetCreateIndex(sesid, sessdirtableid, "DiscSessionIndex", 0,
                        "+UserName\0+Domain\0+State\0", 
                        sizeof("+UserName\0+Domain\0+State\0"), 100));
    // Create index for all session retrieval.
    CALL(JetCreateIndex(sesid, sessdirtableid, "AllSessionIndex", 0,
                        "+UserName\0+Domain\0",
                        sizeof("+UserName\0+Domain\0"), 100));

    // Create server directory.
    tServ.cbStruct = sizeof(tServ);
    tServ.szTableName = "ServerDirectory";
    tServ.szTemplateTableName = NULL;
    tServ.ulPages = 0;
    tServ.ulDensity = 100;
    tServ.rgcolumncreate = &cServ[0];
    tServ.cColumns = NUM_SERVDIRCOLUMNS;
    tServ.rgindexcreate = NULL;
    tServ.cIndexes = 0;
    tServ.grbit = JET_bitTableCreateFixedDDL;

    for (count = 0; count < NUM_SERVDIRCOLUMNS; count++) {
        cServ[count].cbStruct = sizeof(JET_COLUMNCREATE);
        cServ[count].szColumnName = ServerDirectoryColumns[count].szColumnName;
        cServ[count].coltyp = ServerDirectoryColumns[count].coltyp;
        cServ[count].cbMax = ServerDirectoryColumns[count].colMaxLen;
        cServ[count].grbit = 0;
        cServ[count].pvDefault = NULL;
        cServ[count].cbDefault = 0;
        cServ[count].cp = 1200;
        cServ[count].columnid = 0;
        cServ[count].err = JET_errSuccess;
    }
    // Set the autoincrement column to autoincrement
    cServ[0].grbit |= JET_bitColumnAutoincrement;

    CALL(JetCreateTableColumnIndex(sesid, dbid, &tServ));

    for (count = 0; count < NUM_SERVDIRCOLUMNS; count++) {
        servdircolumnid[count] = cServ[count].columnid;
    }
    servdirtableid = tServ.tableid;

    // Create Server Name (IP) index.
    CALL(JetCreateIndex(sesid, servdirtableid, "ServNameIndex", 0,
                        "+ServerAddress\0", sizeof("+ServerAddress\0"), 100));
    // Create Server DNS host Name index.
    CALL(JetCreateIndex(sesid, servdirtableid, "ServDNSNameIndex", 0,
                        "+ServerDNSName\0", sizeof("+ServerDNSName\0"), 100));
    // Create Server ID index.
    CALL(JetCreateIndex(sesid, servdirtableid, "ServerIDIndex", 0,
                        "+ServerID\0", sizeof("+ServerID\0"), 100));
    // Create Pending Reconnect index.
    CALL(JetCreateIndex(sesid, servdirtableid, "ServerAlmostInTimes", 0,
                        "+AlmostInTimeLow\0+AlmostInTimeHigh\0", 
                        sizeof("+AlmostInTimeLow\0+AlmostInTimeHigh\0"), 100));
    // Create the single session index.
    CALL(JetCreateIndex(sesid, servdirtableid, "SingleSessionIndex", 0,
                        "+ClusterID\0+SingleSessionMode\0", 
                        sizeof("+ClusterID\0+SingleSessionMode\0"), 100));
    // Create the ClusterID index.
    CALL(JetCreateIndex(sesid, servdirtableid, "ClusterIDIndex", 0,
                        "+ClusterID\0", sizeof("+ClusterID\0"), 100));

    // Create cluster directory.
    tClus.cbStruct = sizeof(tClus);
    tClus.szTableName = "ClusterDirectory";
    tClus.szTemplateTableName = NULL;
    tClus.ulPages = 0;
    tClus.ulDensity = 100;
    tClus.rgcolumncreate = &cClus[0];
    tClus.cColumns = NUM_CLUSDIRCOLUMNS;
    tClus.rgindexcreate = NULL;
    tClus.cIndexes = 0;
    tClus.grbit = JET_bitTableCreateFixedDDL;

    for (count = 0; count < NUM_CLUSDIRCOLUMNS; count++) {
        cClus[count].cbStruct = sizeof(JET_COLUMNCREATE);
        cClus[count].szColumnName = ClusterDirectoryColumns[count].szColumnName;
        cClus[count].coltyp = ClusterDirectoryColumns[count].coltyp;
        cClus[count].cbMax = ClusterDirectoryColumns[count].colMaxLen;
        cClus[count].grbit = 0;
        cClus[count].pvDefault = NULL;
        cClus[count].cbDefault = 0;
        cClus[count].cp = 1200;
        cClus[count].columnid = 0;
        cClus[count].err = JET_errSuccess;
    }
    // Set the autoincrement column to autoincrement
    cClus[0].grbit |= JET_bitColumnAutoincrement;

    CALL(JetCreateTableColumnIndex(sesid, dbid, &tClus));

    for (count = 0; count < NUM_CLUSDIRCOLUMNS; count++) {
        clusdircolumnid[count] = cClus[count].columnid;
    }
    clusdirtableid = tClus.tableid;

    // Create Cluster Name index.
    CALL(JetCreateIndex(sesid, clusdirtableid, "ClusNameIndex", 
                        JET_bitIndexUnique, "+ClusterName\0", sizeof("+ClusterName\0"), 
                        100));
    // Create cluster ID index.
    CALL(JetCreateIndex(sesid, clusdirtableid, "ClusIDIndex", 0,
                        "+ClusterID\0", sizeof("+ClusterID\0"), 100));


    CALL(JetCommitTransaction(sesid, 0));

    // Tables were opened with exclusive access from CreateTableColumnIndex.
    // Close them now.
NormalExit:
    CALL(JetCloseTable(sesid, sessdirtableid));
    CALL(JetCloseTable(sesid, servdirtableid));
    CALL(JetCloseTable(sesid, clusdirtableid));

    CALL(JetCloseDatabase(sesid, dbid, 0));

    CALL(JetEndSession(sesid, 0));

    LocalFree(SA.lpSecurityDescriptor);
    SA.lpSecurityDescriptor = NULL;

#ifdef DBG
    OutputAllTables();
#endif // DBG

    return 0;

HandleError:
    if (sesid != JET_sesidNil) {
        // Can't really recover.  Just bail out.
        (VOID) JetRollback(sesid, JET_bitRollbackAll);

        // Force the session closed
        (VOID) JetEndSession(sesid, JET_bitForceSessionClosed);
    }

    if (SA.lpSecurityDescriptor != NULL) {
        LocalFree(SA.lpSecurityDescriptor);
        SA.lpSecurityDescriptor = NULL;
    }                                             

    PostSessDirErrorValueEvent(EVENT_JET_COULDNT_INIT, err, EVENTLOG_ERROR_TYPE);

    exit(1);
}


/****************************************************************************/
// DISCleanupGlobals
//
// Common cleanup code for SQL and Jet code paths.
/****************************************************************************/
void DISCleanupGlobals()
{
    if (g_hStopServiceEvent != NULL) {
        CloseHandle(g_hStopServiceEvent);
        g_hStopServiceEvent = NULL;
    }

    if (g_hFileOutput != INVALID_HANDLE_VALUE) {
        if (CloseHandle(g_hFileOutput) == 0) {
            ERR((TB, "CloseHandle on output file failed: lasterr=0x%X", 
                    GetLastError()));
        }
        g_hFileOutput = INVALID_HANDLE_VALUE;
    }

    if (g_hTimeFile != INVALID_HANDLE_VALUE) {
        CloseHandle(g_hTimeFile);
        g_hTimeFile =  INVALID_HANDLE_VALUE;
    }

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

    if (g_hClusterToken) {
        CloseHandle(g_hClusterToken);
        g_hClusterToken = NULL;
    }
}


#if 0
/****************************************************************************/
// DISCallSPForServer
//
// Generic function to call a stored procedure that takes a ServerAddress as an
// argument.
/****************************************************************************/
void DISCallSPForServer(WCHAR *StoredProcName, WCHAR *ServerAddress) {
    HRESULT hr;
    ADOCommand *pCommand;
    ADOParameters *pParameters;
    ADORecordset *pResultRecordSet;


    hr = CreateADOStoredProcCommand(StoredProcName, &pCommand, &pParameters);

    if (SUCCEEDED(hr)) {
        hr = AddADOInputStringParam(ServerAddress, L"ServerAddress", 
                pCommand, pParameters, FALSE);
        if (SUCCEEDED(hr)) {
            // Execute the command.
            hr = pCommand->Execute(NULL, NULL, adCmdStoredProc, 
                    &pResultRecordSet);
            if (SUCCEEDED(hr)) {
                pResultRecordSet->Release();
            } else {
                ERR((TB, "DISCallSPForServer: Failed Execute, hr = 0x%X", 
                        hr));
            }
        }
        else {
            ERR((TB,"DISCallSPForServer: Failed add parameter, hr=0x%X", hr));
        }

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


/****************************************************************************/
// DISJetHandleDeadServer
//
// When a server is not responding, this function call sends the command to the
// Jet database to remove all entries pertaining to that server.
/****************************************************************************/
void DISJetHandleDeadServer(WCHAR *ServerAddress, DWORD ServerID) {
    // FailureCount is initially set to 1, TRUE, to tell SetServerAITInternal
    // to increment the failure count and return the resultant count.
    DWORD FailureCount = 1;

    TSSDSetServerAITInternal(ServerAddress, FALSE, &FailureCount);

    TSDISErrorOut(L"Server %s (%d) not responding (Failure Count: %d).\n",
            ServerAddress, ServerID, FailureCount);

    if (FailureCount >= g_NumberFailedPingsBeforePurge)
        TSSDPurgeServer(ServerID);
}


// TODO: Possible optimization: pass in ServerID
void DISJetSetServerPingSuccessful(WCHAR *ServerAddress) {
    TSSDSetServerAITInternal(ServerAddress, TRUE, NULL);
}


#if 0
/****************************************************************************/
// DISSQLHandleDeadServer
//
// When a server is not responding, this function call sends the command to the
// database to execute SP_TSDISServerNotResponding.
/****************************************************************************/
void DISSQLHandleDeadServer(WCHAR *ServerAddress) {
    DISCallSPForServer(L"SP_TSDISServerNotResponding", ServerAddress);
}


void DISSQLSetServerPingSuccessful(WCHAR *ServerAddress) {
    DISCallSPForServer(L"SP_TSDISSetServerPingSuccessful", ServerAddress);
}
#endif


VOID DISCtrlHandler(DWORD opcode) {

    switch(opcode)
    {
    //case SERVICE_CONTROL_PAUSE:
        // pause
    //    g_DISStatus.dwCurrentState = SERVICE_PAUSED;
    //    break;

    //case SERVICE_CONTROL_CONTINUE:
        // continue
    //    g_DISStatus.dwCurrentState = SERVICE_RUNNING;
    //    break;

    case SERVICE_CONTROL_STOP:
        //stop
        g_DISStatus.dwWin32ExitCode = 0;
        g_DISStatus.dwCurrentState = SERVICE_STOP_PENDING;
        g_DISStatus.dwCheckPoint = 0;
        g_DISStatus.dwWaitHint = 0;

        if (!SetServiceStatus(g_DISStatusHandle, &g_DISStatus)) {
            ERR((TB, "SetServiceStatus failed"));
        }

        // Here is where to actually stop the service
        SetEvent(g_hStopServiceEvent);
        // Should I wait for that to complete?

        return;

    case SERVICE_CONTROL_INTERROGATE:
        // fall through to return current status
        break;

    default:
        ERR((TB, "Unrecognized opcode to DISCtrlHandler - 0x%08x", opcode));
    }

    // send current status
    if (!SetServiceStatus(g_DISStatusHandle, &g_DISStatus)) {
        ERR((TB, "SetServiceStatus failed"));
    }
}


void DISDirectoryIntegrityLoop() {
    CVar varRows;
    WCHAR *ServerAddress;
#if 0
    WCHAR ServerAddressBuf[SERVER_ADDRESS_LENGTH];
#endif
    WCHAR ServerAddressRows[10][SERVER_ADDRESS_LENGTH];
    DWORD ServerIDs[10];
    long NumSessionsReturned = 0;
#if 0
    HRESULT hr = S_OK;
#endif
    SERVER_STATUS ServerStatus;
    DWORD EventStatus;

#if 0
    ServerAddress = ServerAddressBuf; // In SQL case, we need a static buffer
#endif

#if 0
    TSDISErrorOut(L"%s active\n", g_bUseSQL ? L"Directory Integrity Service" : 
            L"Session Directory");
#endif

    TSDISErrorOut(L"Session Directory Active\n");
            
    // Loop forever
    for ( ; ; ) {
        // Retrieve set of servers that have disconnected sessions pending
        // reconnects
#if 0
        if (g_bUseSQL == FALSE)
#endif
            DISJetGetServersPendingReconnects(&NumSessionsReturned,
                    ServerAddressRows, ServerIDs);
#if 0
        else
            DISSQLGetServersPendingReconnects(&NumSessionsReturned, 
                    &varRows);
#endif

        // For each server,
        for (DWORD i = 0; i < (unsigned)NumSessionsReturned; i++) {
#if 0
            if (g_bUseSQL == FALSE)
#endif

            ServerAddress = ServerAddressRows[i];

#if 0
            else
                hr = GetRowArrayStringField(varRows.parray, i, 0,
                        ServerAddress, sizeof(ServerAddressBuf) /
                        sizeof(WCHAR) - 1);

            if (FAILED(hr)) {
                ERR((TB,"DISDirectoryIntegrityLoop: Row %u returned hr=0x%X",
                        i, hr));
            }
#endif

            ServerStatus = DISGetServerStatus(ServerAddress);

            // if the server does not respond, handle dead server.
            // The function we call will do the right thing, which may be
            // to purge immediately, or may be to simply increment a failure
            // count.
            if (ServerStatus == NotResponding) {
#if 0
                if (FALSE == g_bUseSQL)
#endif
                DISJetHandleDeadServer(ServerAddress, ServerIDs[i]);
#if 0
                else
                    DISSQLHandleDeadServer(ServerAddress);
#endif

#ifdef DBG
                OutputAllTables();
#endif // DBG
            } 
            // else stop pinging
            else if (ServerStatus == Responding) {
#if 0
                if (FALSE == g_bUseSQL)
#endif
                    DISJetSetServerPingSuccessful(ServerAddress);
#if 0
                else
                    DISSQLSetServerPingSuccessful(ServerAddress);
#endif
            }
            else {
                ERR((TB, "DISDirectoryIntegrityLoop: ServerStatus enum has bad "
                        "value %d", ServerStatus));
            }
        }
        // Wait DISNumberSecondsBetweenPings
        EventStatus = WaitForSingleObjectEx(g_hStopServiceEvent, 
                DISNumberSecondsBetweenPings * 1000, FALSE);
        if (EventStatus == WAIT_TIMEOUT) {
            // do normal stuff
            continue;
        } else if (EventStatus == WAIT_OBJECT_0) {
            // the event was signaled -- clean up
            DISDeleteLocalGroupSecDes();
            break;
        } else if (EventStatus == -1) {
            // there is an error
        } else {
            // weird output from that function
        } 
    }
}
    

#if 0
/****************************************************************************/
// DISSQLStart
//
// Service main entry point for when the service is configured to verify
// SQL tables.
/****************************************************************************/
VOID DISSQLStart(DWORD argc, LPTSTR *argv) {
    HRESULT hr = S_OK;

    // unreferenced parameters
    argv;
    argc;
    
    g_DISStatus.dwServiceType = SERVICE_WIN32;
    g_DISStatus.dwCurrentState = SERVICE_START_PENDING;
    g_DISStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
    g_DISStatus.dwWin32ExitCode = 0;
    g_DISStatus.dwServiceSpecificExitCode = 0;
    g_DISStatus.dwCheckPoint = 0;
    g_DISStatus.dwWaitHint = 0;
    g_DISStatusHandle = RegisterServiceCtrlHandler(
            _T("Directory Integrity Service"), DISCtrlHandler);
    if (g_DISStatusHandle == (SERVICE_STATUS_HANDLE)0) {
        ERR((TB, "DISSQLStart: RegisterServiceCtrlHandler failed"));
        goto ExitFunc;
    }

    // Initialization code goes here
    hr = DISSQLInitialize();
    if (FAILED(hr)) {
        ERR((TB, "DISSQLStart: DISSQLInitialize failed"));
        goto PostRegisterService;
    }

    g_DISStatus.dwCurrentState = SERVICE_RUNNING;
    g_DISStatus.dwCheckPoint = 1;
    if (!SetServiceStatus(g_DISStatusHandle, &g_DISStatus)) {
        ERR((TB, "DISSQLStart: SetServiceHandler failed"));
        goto PostRegisterService;
    }

    DISDirectoryIntegrityLoop();

PostRegisterService:
    g_DISStatus.dwCurrentState = SERVICE_STOPPED;
    g_DISStatus.dwCheckPoint = 2;
    SetServiceStatus(g_DISStatusHandle, &g_DISStatus);

ExitFunc:
    DISCleanupGlobals();
}
#endif


BOOL DISGetSDAdminSid()
{
    DWORD cbSid = 0;
    DWORD dwErr;
    BOOL rc = FALSE;

    if (!CreateWellKnownSid(WinBuiltinAdministratorsSid, NULL, NULL, &cbSid)) {
        dwErr = GetLastError();
        if (dwErr == ERROR_INSUFFICIENT_BUFFER) {
            g_pAdminSid = LocalAlloc(LMEM_FIXED, cbSid);
        }
        else {
            TSDISErrorOut(L"DISGetSDAdminSid: CreateWellKnownSid fails with %u\n", GetLastError());
            goto HandleError;
        }
    }
    else {
        goto HandleError;
    }

    if (NULL == g_pAdminSid) {
        TSDISErrorOut(L"DISGetSDAdminSid: Memory allocation fails with %u\n", GetLastError());
        goto HandleError;
    }

	if (!CreateWellKnownSid(WinBuiltinAdministratorsSid, NULL, g_pAdminSid, &cbSid)) {
        g_pAdminSid = NULL;
        TSDISErrorOut(L"DISGetSDAdminSid: CreateWellKnownSid fails with %u\n", GetLastError());
        goto HandleError;
    }
    rc = TRUE;

HandleError:
    return rc;
}


/****************************************************************************/
// DISCreateLocalGroupSecDes
//
// Create Session Directory Computers local group if not exist
// and create the security descriptor of this local group
/****************************************************************************/
BOOL DISCreateLocalGroupSecDes()
{
    DWORD Error;
    ULONG SidSize, ReferencedDomainNameSize;
    LPWSTR ReferencedDomainName = NULL;
    SID_NAME_USE SidNameUse;
    WCHAR SDLocalGroupName[SDLOCALGROUPNAMELENGTH];
    WCHAR SDLocalGroupDes[SDLOCALGROUPDESLENGTH];
    GROUP_INFO_1 SDGroupInfo = {SDLocalGroupName, SDLocalGroupDes};
    HMODULE HModule = NULL;
    LPBYTE pbBuffer = NULL;
    DWORD dwEntriesRead = 0, dwTotalEntry = 0;
    DWORD_PTR resumehandle = NULL;
   
    NET_API_STATUS NetStatus;
    BOOL rc = FALSE;

    HModule = GetModuleHandle(NULL);
    if (HModule == NULL) {
        Error = GetLastError();
        TSDISErrorOut(L"GetModuleHandle returns error : %u\n", Error);
        goto HandleError;
    }
    if (!LoadString(HModule, IDS_SDLOCALGROUP_NAME, SDLocalGroupName, sizeof(SDLocalGroupName) / sizeof(WCHAR)) ||
        !LoadString(HModule, IDS_SDLOCALGROUP_DES, SDLocalGroupDes, sizeof(SDLocalGroupDes) / sizeof(WCHAR)))
    {
        TSDISErrorOut(L"LoadString fails with %u\n", GetLastError());
        goto HandleError;
    }
    // Create local group if not exist
    NetStatus = NetLocalGroupAdd(
                NULL,
                1,
                (LPBYTE)&SDGroupInfo,
                NULL
                );

    if(NERR_Success != NetStatus) {
        if((NERR_GroupExists != NetStatus)
           && (ERROR_ALIAS_EXISTS != NetStatus)) {
            //
            // Didn't create the group and group doesn't exist either.
            //
            
            TSDISErrorOut(L"NetLocalGroupAdd(%s) returns error: %u\n",
                            SDGroupInfo.grpi1_name, NetStatus);
            goto HandleError;
        }
    }
    
    //
    // Group created. Now lookup the SID.
    //
    SidSize = ReferencedDomainNameSize = 0;
    ReferencedDomainName = NULL;
    NetStatus = LookupAccountName(
                NULL,
                SDGroupInfo.grpi1_name,
                g_pSid,
                &SidSize,
                ReferencedDomainName,
                &ReferencedDomainNameSize,
                &SidNameUse);
    if( NetStatus ) 
        goto HandleError;       
        
    Error = GetLastError();
    if( ERROR_INSUFFICIENT_BUFFER != Error ) 
        goto HandleError;
        
    g_pSid = (PSID)LocalAlloc(LMEM_FIXED, SidSize);
    if (NULL == g_pSid) {
        goto HandleError;
    }
    ReferencedDomainName = (LPWSTR)LocalAlloc(LMEM_FIXED,
                                              sizeof(WCHAR)*(1+ReferencedDomainNameSize));
    if (NULL == ReferencedDomainName) {
        goto HandleError;
    }
        
    NetStatus = LookupAccountName(
                NULL,
                SDGroupInfo.grpi1_name,
                g_pSid,
                &SidSize,
                ReferencedDomainName,
                &ReferencedDomainNameSize,
                &SidNameUse
                );
    if( 0 == NetStatus ) {
        //
        // Failed.
        //
        Error = GetLastError();
        TSDISErrorOut(L"LookupAccountName failed with %u\n", Error);            
        goto HandleError;
    }
        
    // Get the members of the local group
    NetStatus = NetLocalGroupGetMembers(
                    NULL,
                    SDGroupInfo.grpi1_name,
                    0,
                    &pbBuffer,
                    MAX_PREFERRED_LENGTH,
                    &dwEntriesRead,
                    &dwTotalEntry,
                    &resumehandle
                    );
    if (NERR_Success == NetStatus) {
        if (dwEntriesRead == 0) {
            // Th group is emptry, throw the event log
            PostSessDirErrorMsgEvent(EVENT_SD_GROUP_EMPTY, SDGroupInfo.grpi1_name, EVENTLOG_WARNING_TYPE);
        }
        else {
            if (pbBuffer) {
                NetApiBufferFree(pbBuffer);
                pbBuffer = NULL;
            }
        }
    }
    else {
        TSDISErrorOut(L"NetLocalGroupGetMembersfailed with %d\n", NetStatus);
    }

    rc = TRUE;
    return rc;

HandleError:
    if (ReferencedDomainName)
        LocalFree(ReferencedDomainName);
    // Clean
    DISDeleteLocalGroupSecDes();

    return rc;
}

void DISDeleteLocalGroupSecDes()
{
    if (g_pSid) {
        LocalFree(g_pSid);
        g_pSid = NULL;
    }

    if (g_pAdminSid) {
        LocalFree(g_pAdminSid);
        g_pAdminSid = NULL;
    }
}

/****************************************************************************/
// DISJetStart
//
// Service main entry point for when the service is configured to act as
// an RPC server and use Jet for all session directory transactions.
/****************************************************************************/
VOID DISJetStart(DWORD argc, LPTSTR *argv) {
    RPC_STATUS Status;
    RPC_BINDING_VECTOR *pBindingVector = 0;
    RPC_POLICY rpcpol = {sizeof(rpcpol), 0, 0};
    WCHAR *szPrincipalName = NULL;

    // unreferenced parameters
    argv;
    argc;


    g_DISStatus.dwServiceType = SERVICE_WIN32;
    g_DISStatus.dwCurrentState = SERVICE_START_PENDING;
    g_DISStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
    g_DISStatus.dwWin32ExitCode = 0;
    g_DISStatus.dwServiceSpecificExitCode = 0;
    g_DISStatus.dwCheckPoint = 0;
    g_DISStatus.dwWaitHint = 0;

    if (g_bDebug == FALSE) {
        g_DISStatusHandle = RegisterServiceCtrlHandler(
                _T("Directory Integrity Service"), DISCtrlHandler);

        if (g_DISStatusHandle == (SERVICE_STATUS_HANDLE)0) {
            ERR((TB, "DISJetStart: RegisterServiceCtrlHandler failed"));
            goto ExitFunc;
        }
    }

    // Init the RPC server interface.
    // Register the named pipe. This uses NT domain authentication.

    /*
    Status = RpcServerUseProtseqEp(
            L"ncacn_np",  // Protocol Sequence
            NUM_JETRPC_THREADS,  // Maximum calls at one time
            L"\\pipe\\TSSD_Jet_RPC_Service",  // Endpoint
            NULL);  // Security
    */

    if (!DISCreateLocalGroupSecDes()) {
        ERR((TB,"DISJetStart: Error in DISCreateLocalGroupSecDEs"));
        goto PostRegisterService;
    }

    // Get the Sid of the Admin of SD machine
    DISGetSDAdminSid();

    Status = RpcServerUseProtseqEx(L"ncacn_ip_tcp", 3, 0, &rpcpol);
    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d RpcUseProtseqEp on ncacn_ip_tcp", 
                Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_INIT_USEPROTSEQ, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }

    // Register our interface handle (found in jetrpc.h).
    Status = RpcServerRegisterIfEx(TSSDJetRPC_ServerIfHandle, NULL, NULL,
                                    0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, SDRPCAccessCheck);
    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d RegIf", Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_INIT_REGISTERIF, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }   

    Status = RpcServerInqBindings(&pBindingVector);

    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d InqBindings", Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_INIT_INQBINDINGS, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }

    Status = RpcEpRegister(TSSDJetRPC_ServerIfHandle, pBindingVector, 0, 0);
    // TODO: Probably need to unregister, maybe delete some binding vector.

    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d EpReg", Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_INIT_EPREGISTER, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }

    Status = RpcServerInqDefaultPrincName(RPC_C_AUTHN_GSS_NEGOTIATE, &szPrincipalName);
    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d ServerIngDefaultPrincName", Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_INIT_INGPRINCNAME, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }

    Status = RpcServerRegisterAuthInfo(szPrincipalName, RPC_C_AUTHN_GSS_NEGOTIATE, NULL, NULL);
    RpcStringFree(&szPrincipalName);
    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d ServerRegisterAuthInfo", Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_INIT_REGAUTHINFO, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }


    // Now initialize the JET database
    DISJetInitialize();

    // Init the RPC to support the query for SD
    Status = SDInitQueryRPC();
    if (Status != RPC_S_OK) {
        TSDISErrorOut(L"SDInitQueryRPC fails with %d\n", Status);
    }

    // Now do the RPC listen to service calls
    Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE);
    if (Status != RPC_S_OK) {
        ERR((TB,"DISJetStart: Error %d ServerListen", Status));
        PostSessDirErrorValueEvent(EVENT_FAIL_RPC_LISTEN, Status, EVENTLOG_ERROR_TYPE);
        goto PostRegisterService;
    }

    // We are now up.
    g_DISStatus.dwCurrentState = SERVICE_RUNNING;
    g_DISStatus.dwCheckPoint = 1;
    if (g_bDebug == FALSE)
        SetServiceStatus(g_DISStatusHandle, &g_DISStatus);

    // Now we have the RPC server running, we can just wait for the
    // service-stop event to be fired to let us know we need to exit.
    // We do this inside the Directory Integrity Loop.
    DISDirectoryIntegrityLoop();

    // Time to clean up.
    // Kill the RPC listener.
    RpcServerUnregisterIf(TSSDJetRPC_ServerIfHandle, NULL, NULL);
    RpcServerUnregisterIf(TSSDQUERYRPC_ServerIfHandle, NULL, NULL);
    
    TSDISErrorOut(L"Session Directory Stopped\n");

    JetTerm(g_instance);

PostRegisterService:    

    g_DISStatus.dwCurrentState = SERVICE_STOPPED;
    g_DISStatus.dwCheckPoint = 2;
    if (g_bDebug == FALSE) {
        if (!SetServiceStatus(g_DISStatusHandle, &g_DISStatus)) {
            ERR((TB, "SetServiceStatus failed: %d", GetLastError()));
        }
    }

ExitFunc:
    DISCleanupGlobals();
}


/****************************************************************************/
// DISInstallService
//
// Used to install the service, returns 0 on success, nonzero otherwise.
/****************************************************************************/
int DISInstallService() {
    WCHAR wzModulePathname[MAX_PATH];
    SC_HANDLE hSCM = NULL, hService = NULL;

    if (0 != GetModuleFileNameW(NULL, wzModulePathname, MAX_PATH)) {
        hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
        if (hSCM != NULL) {
            hService = CreateServiceW(hSCM, L"Directory Integrity Service",
                    L"Directory Integrity Service", 0, 
                    SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START,
                    SERVICE_ERROR_NORMAL, wzModulePathname, NULL, NULL, NULL,
                    NULL, NULL);
            if (hService != NULL) {
                CloseServiceHandle(hService);
                CloseServiceHandle(hSCM);
            } else {
                ERR((TB, "CreateService failed, error = 0x%X", GetLastError()));
                CloseServiceHandle(hSCM);
                return -1;
            }
        } else {
            ERR((TB, "OpenSCManager failed, error = 0x%X", GetLastError()));
            return -1;
        }
    } else {
        ERR((TB, "GetModuleFileNameW failed, error = 0x%X", GetLastError()));
        return -1;
    }

    return 0;
}


/****************************************************************************/
// DISRemoveService()
//
// Used to remove the service, returns 0 on success, nonzero otherwise.
/****************************************************************************/
int DISRemoveService() {
    SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);

    if (hSCM != NULL) {
        // Open this service for DELETE access
        SC_HANDLE hService = OpenServiceW(hSCM, L"Directory Integrity Service",
                DELETE);
        if (hService != NULL) {
            // Remove this service from the SCM's database.
            DeleteService(hService);
            CloseServiceHandle(hService);
            CloseServiceHandle(hSCM);

            return 0;
        } else {
            ERR((TB, "Failure opening service for delete, error = 0x%X", 
                    GetLastError()));
        }
        CloseServiceHandle(hService);
    } else {
        ERR((TB, "Failure opening SC Manager, error = 0x%X", GetLastError()));
    }

    return -1;
}


// Reads a DWORD value out of the registry.
//
// In:
//  hKey - an open HKEY
//  RegValName - the name of the registry value
//  pValue - pointer to the value.  The value will be set to the registry value
//    if the registry operation is a success, else it will remain untouched.
//
// Out:
//  0 if success, nonzero otherwise
int ReadRegVal(HKEY hKey, WCHAR *RegValName, DWORD *pValue)
{
    DWORD RegRetVal;
    DWORD Type, Temp, Size;

    Size = sizeof(Temp);
    RegRetVal = RegQueryValueExW(hKey, RegValName, NULL, &Type,
            (BYTE *)&Temp, &Size);
    if (RegRetVal == ERROR_SUCCESS) {
        *pValue = Temp;
        return 0;
    }
    else {
        TRC1((TB, "TSSDIS: Failed RegQuery for %S - "
                "err=%u, DataSize=%u, type=%u\n",
                RegValName, RegRetVal, Size, Type));
        return -1;
    }

}


// Reads a Unicode text value out of the registry.
//
// hKey (IN) - an open HKEY
// RegValName (IN) - the name of the registry value
// pText (IN/OUT) - pointer to the buffer to which to write.
// cbData (IN) - size of buffer IN BYTES
//
// returns 0 if success, nonzero otherwise.
int ReadRegTextVal(HKEY hKey, WCHAR *RegValName, WCHAR *pText, DWORD cbData)
{
    DWORD RegRetVal;
    DWORD Type, Size;

    Size = cbData;

    RegRetVal = RegQueryValueExW(hKey, RegValName, NULL, &Type,
            (BYTE *)pText, &Size);

    if (RegRetVal == ERROR_SUCCESS) {
        return 0;
    }
    else {
        TRC1((TB, "TSSDIS: Failed RegQuery for %S - err=%u, DataSize=%u, "
                "type=%u\n", RegValName, RegRetVal, Size, Type));
        return -1;
    }
}

// Reads configuration from the registry and sets global variables.
void ReadConfigAndSetGlobals()
{
    DWORD RegRetVal;
    HKEY hKey;
    DWORD Temp;
    WCHAR WorkingDirectory[MAX_PATH];
    WCHAR *pwszSD = L"D:(A;OICI;GA;;;SY)(A;OICI;GA;;;BA)(A;OICI;GA;;;CO)";
    SECURITY_ATTRIBUTES SA;
    BOOL br;

    // Open the service settings regkey and grab the UseJet flag.
    // Absence of the key or the setting means no jet.
#if 0
    g_bUseSQL = FALSE;
#endif
    RegRetVal = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
            REG_SESSION_DIRECTROY_CONTROL, 0, KEY_READ, &hKey);
    if (RegRetVal == ERROR_SUCCESS) {

        // With each of these calls, an error is non-fatal.
#if 0
        // Query UseSQL value.
        ReadRegVal(hKey, L"UseSQL", &g_bUseSQL);
#endif

        // Query PingMode value.  Note this is an enum so sending the variable
        // in directly is illegal.
        if (ReadRegVal(hKey, L"PingMode", &Temp) == 0) {

            // Make sure this is a legal value for the enum.
            if (Temp > AlwaysFail)
                Temp = NormalMode;

            g_PingMode = (PingMode) Temp;
        }

        // Query TraceOutputMode value.  As above, enum means don't set it
        // directly.
        if (ReadRegVal(hKey, L"TraceOutputMode", &Temp) == 0) {

            // Make sure this is a legal value for the enum.
            if (Temp > FileOutput)
                Temp = NoTraceOutput;

            g_TraceOutputMode = (TraceOutputMode) Temp;

        }

        // Query NumberFailedPingsBeforePurge.
        ReadRegVal(hKey, L"NumberFailedPingsBeforePurge", 
                &g_NumberFailedPingsBeforePurge);

        // Query TimeBetweenPings.
        ReadRegVal(hKey, L"TimeBetweenPings", &DISNumberSecondsBetweenPings);

        // Query TimeServerSilentBeforePing.
        if (ReadRegVal(hKey, L"TimeServerSilentBeforePing", &Temp) == 0) {
            g_TimeServerSilentBeforePing = (ULONGLONG) Temp * 
                    FILETIME_INTERVAL_TO_SECONDS_MULTIPLIER;
        }

        // Query Working Directory
        if (ReadRegTextVal(hKey, L"WorkingDirectory", WorkingDirectory, 
                sizeof(WorkingDirectory)) == 0) {
            if (SetCurrentDirectory(WorkingDirectory) == 0) {
                DWORD Err;

                Err = GetLastError();
                PostSessDirErrorValueEvent(EVENT_PROBLEM_SETTING_WORKDIR, Err, EVENTLOG_ERROR_TYPE);
                ERR((TB, "TERMSRV: Unable to set directory to value read from "
                        "registry.  LastErr=0x%X", Err));
            }
        }
        
        // Query if we reover previous jet database when starting SD
        ReadRegVal(hKey, L"RecoverWhenStart", &g_RecoverWhenStart);
        
        RegCloseKey(hKey);

        // Now, if in file output mode, open the file.
        if (g_TraceOutputMode == FileOutput) {
            // Create security descriptor for the log file
            SA.nLength = sizeof(SECURITY_ATTRIBUTES);
            SA.bInheritHandle = FALSE;
            SA.lpSecurityDescriptor = NULL;
            br = ConvertStringSecurityDescriptorToSecurityDescriptor(pwszSD, 
                SDDL_REVISION_1, &(SA.lpSecurityDescriptor), NULL);

            if (br == TRUE) {
                g_hFileOutput = CreateFile(DEBUG_LOG_FILENAME, GENERIC_WRITE,
                        FILE_SHARE_READ, &SA, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL,
                        NULL);

                if (g_hFileOutput == INVALID_HANDLE_VALUE) {
                    ERR((TB, "Could not open debug log file, lasterror=0x%X", 
                            GetLastError()));
                    g_TraceOutputMode = NoTraceOutput;
                } 
                else {
                    DWORD dwRetVal = 0;
                    // Set the insertion point to the end of the file and output 
                    // something.
                    dwRetVal = SetFilePointer(g_hFileOutput, 0, NULL, FILE_END);

                    if (dwRetVal == INVALID_SET_FILE_POINTER) {
                        ERR((TB, "Could not set to end of file, lasterror=0x%X",
                                GetLastError()));
                        g_TraceOutputMode = NoTraceOutput;
                    }
                    else {
                        DWORD dwBytesWritten = 0;
                        char *pszIntro = "\n\nNEW INSTANCE\n";
                    
                        if (WriteFile(g_hFileOutput, pszIntro, 
                                (DWORD) strlen(pszIntro), &dwBytesWritten, 
                                NULL) == 0) {
                            ERR((TB, "WriteFile failed, lasterr=0x%X", 
                                    GetLastError()));
                        }
                    }
                }
            }
            else {
                ERR((TB, "ConvertStringSecurityDescriptorToSecurityDescriptor fails with 0x%X",
                                GetLastError()));
                g_TraceOutputMode = NoTraceOutput;
            }
        }

    }
    else {
        WRN((TB,"TERMSRV: Unable to open settings key in HKLM, "
                "lasterr=0x%X", GetLastError()));
    }
}


/*****************************************************************************
 *  SDInitQueryRPC
 *
 *   Setup the RPC bindings, and listen for incoming requests.
 ****************************************************************************/
RPC_STATUS
SDInitQueryRPC(VOID)
{
    RPC_STATUS Status;

    // register the LPC (local only) interface
    Status = RpcServerUseProtseqEp(
                 L"ncalrpc",      // Protocol Sequence (LPC)
                 NUM_JETRPC_THREADS,  // Maximum calls at one time
                 SD_QUERY_ENDPOINT_NAME,    // Endpoint
                 NULL           // Security
                 );

    if( Status != RPC_S_OK ) {
        ERR((TB,"SDInitQueryRPC: Error %d RpcuseProtseqEp on ncalrpc", Status));
        return( Status );
    }

    Status = RpcServerRegisterIfEx(TSSDQUERYRPC_ServerIfHandle, NULL, NULL,
                                    0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, SDQueryRPCAccessCheck);
    if( Status != RPC_S_OK ) {
        ERR((TB,"SDInitQueryRPC: Error %d RpcServerRegisterIf", Status));
        return( Status );
    }

    return RPC_S_OK;
}


int __cdecl main() {
    int nArgc;
    WCHAR **ppArgv = (WCHAR **) CommandLineToArgvW(GetCommandLineW(), &nArgc);
    BOOL fStartService = (nArgc < 2);
    int i;
    HANDLE hMutex;

    if ((fStartService == FALSE) && (ppArgv == NULL)) {
        PostSessDirErrorValueEvent(EVENT_NO_COMMANDLINE, GetLastError(), EVENTLOG_ERROR_TYPE);
        return -1;
    }
    
    SERVICE_TABLE_ENTRY DispatchTable[] =
    {
        { _T("Directory Integrity Service"), DISJetStart },  // Default to the
                                                             // Jet version.
        { NULL, NULL }
    };

    for (i = 1; i < nArgc; i++) {
        if ((ppArgv[i][0] == '-') || (ppArgv[i][0] == '/')) {
            if (wcscmp(&ppArgv[i][1], L"install") == 0) {
                if (DISInstallService()) {
                    ERR((TB, "Could not install service"));
                }
            }
            if (wcscmp(&ppArgv[i][1], L"remove") == 0) {
                if (DISRemoveService()) {
                    ERR((TB, "Could not remove service"));
                }
            }
            if (wcscmp(&ppArgv[i][1], L"debug") == 0) {
                TSDISErrorOut(L"Debugging Jet-based Session Directory\n");

                g_hStopServiceEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

                g_bDebug = TRUE;

                // Only allow one session directory at a time.  System will close the
                // handle automatically when the process terminates.
                hMutex = CreateMutex(NULL, FALSE, 
                        _T("Global\\Windows Terminal Server Session Directory"));

                if (hMutex == NULL) {
                    // Handle creation failed, not because it already existed.
                    PostSessDirErrorValueEvent(EVENT_PROBLEM_CREATING_MUTEX, 
                    GetLastError(), EVENTLOG_ERROR_TYPE);
                    return -1;
                }
    
                if (GetLastError() == ERROR_ALREADY_EXISTS) {
                    // Already a session directory out there.
                    PostSessDirErrorValueEvent(EVENT_TWO_SESSDIRS, 0, EVENTLOG_ERROR_TYPE);
                    return -1;
                }


                // Log to stdout by default in this mode, but can be
                // overridden by the registry.
                g_TraceOutputMode = StdOutput;
                
                ReadConfigAndSetGlobals();

                SetConsoleCtrlHandler(DISDebugControlHandler, TRUE);

                DISJetStart(nArgc, ppArgv);
            }
        }
    }

    HeapFree(GetProcessHeap(), 0, (PVOID) ppArgv);

    if (fStartService) {
        // Stop event - signals for the ServiceMain thread to exit.
        g_hStopServiceEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

        ReadConfigAndSetGlobals();

#if 0
        if (g_bUseSQL) {
            // Switch from the default to the SQL service start.
            DispatchTable[0].lpServiceProc = DISSQLStart;
        }
#endif

        if (!StartServiceCtrlDispatcher(DispatchTable)) {
#ifdef DBG
            DWORD dw = GetLastError();
#endif // DBG
            ERR((TB, "Could not start service control dispatcher, error 0x%X",
                    dw));
        }
    }

    return 0;
}

#pragma warning (pop)