/****************************************************************************/ // jetrpcfn.cpp // // TS Directory Integrity Service Jet RPC server-side implementations. // // Copyright (C) 2000, Microsoft Corporation /****************************************************************************/ #include "dis.h" #include "tssdshrd.h" #include "jetrpc.h" #include "jetsdis.h" #pragma warning (push, 4) /****************************************************************************/ // MIDL_user_allocate // MIDL_user_free // // RPC-required allocation functions. /****************************************************************************/ void __RPC_FAR * __RPC_USER MIDL_user_allocate(size_t Size) { return LocalAlloc(LMEM_FIXED, Size); } void __RPC_USER MIDL_user_free(void __RPC_FAR *p) { LocalFree(p); } /****************************************************************************/ // OutputAllTables (debug only) // // Output all tables to debug output. /****************************************************************************/ #ifdef DBG void OutputAllTables() { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; JET_TABLEID clusdirtableid; JET_RETRIEVECOLUMN rcSessDir[NUM_SESSDIRCOLUMNS]; WCHAR UserNameBuf[256]; WCHAR DomainBuf[127]; WCHAR ApplicationBuf[256]; WCHAR ServerNameBuf[128]; WCHAR ClusterNameBuf[128]; unsigned count; long num_vals[NUM_SESSDIRCOLUMNS]; char state; char SingleSessMode; CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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)); TSDISErrorOut(L"SESSION DIRECTORY\n"); err = JetMove(sesid, sessdirtableid, JET_MoveFirst, 0); if (JET_errNoCurrentRecord == err) { TSDISErrorOut(L" (empty database)\n"); } while (JET_errNoCurrentRecord != err) { // Retrieve all the columns memset(&rcSessDir[0], 0, sizeof(JET_RETRIEVECOLUMN) * NUM_SESSDIRCOLUMNS); for (count = 0; count < NUM_SESSDIRCOLUMNS; count++) { rcSessDir[count].columnid = sesdircolumnid[count]; rcSessDir[count].pvData = &num_vals[count]; rcSessDir[count].cbData = sizeof(long); rcSessDir[count].itagSequence = 1; } // fix up pvData, cbData for non-int fields rcSessDir[SESSDIR_USERNAME_INTERNAL_INDEX].pvData = UserNameBuf; rcSessDir[SESSDIR_USERNAME_INTERNAL_INDEX].cbData = sizeof(UserNameBuf); rcSessDir[SESSDIR_DOMAIN_INTERNAL_INDEX].pvData = DomainBuf; rcSessDir[SESSDIR_DOMAIN_INTERNAL_INDEX].cbData = sizeof(DomainBuf); rcSessDir[SESSDIR_APPTYPE_INTERNAL_INDEX].pvData = ApplicationBuf; rcSessDir[SESSDIR_APPTYPE_INTERNAL_INDEX].cbData = sizeof(ApplicationBuf); rcSessDir[SESSDIR_STATE_INTERNAL_INDEX].pvData = &state; rcSessDir[SESSDIR_STATE_INTERNAL_INDEX].cbData = sizeof(state); CALL(JetRetrieveColumns(sesid, sessdirtableid, &rcSessDir[0], NUM_SESSDIRCOLUMNS)); TSDISErrorOut(L"%8s, %s, %d, %d, %d\n", UserNameBuf, DomainBuf, num_vals[SESSDIR_SERVERID_INTERNAL_INDEX], num_vals[SESSDIR_SESSIONID_INTERNAL_INDEX], num_vals[SESSDIR_TSPROTOCOL_INTERNAL_INDEX]); TSDISErrorTimeOut(L" %s, ", num_vals[SESSDIR_CTLOW_INTERNAL_INDEX], num_vals[SESSDIR_CTHIGH_INTERNAL_INDEX]); TSDISErrorTimeOut(L"%s\n", num_vals[SESSDIR_DTLOW_INTERNAL_INDEX], num_vals[SESSDIR_DTHIGH_INTERNAL_INDEX]); TSDISErrorOut(L" %s, %d, %d, %d, %s\n", ApplicationBuf ? L"(no application)" : ApplicationBuf, num_vals[SESSDIR_RESWIDTH_INTERNAL_INDEX], num_vals[SESSDIR_RESHEIGHT_INTERNAL_INDEX], num_vals[SESSDIR_COLORDEPTH_INTERNAL_INDEX], state ? L"disconnected" : L"connected"); err = JetMove(sesid, sessdirtableid, JET_MoveNext, 0); } // Output Server Directory (we are reusing the rcSessDir structure). TSDISErrorOut(L"SERVER DIRECTORY\n"); err = JetMove(sesid, servdirtableid, JET_MoveFirst, 0); if (JET_errNoCurrentRecord == err) { TSDISErrorOut(L" (empty database)\n"); } while (JET_errNoCurrentRecord != err) { // Retrieve all the columns. memset(&rcSessDir[0], 0, sizeof(JET_RETRIEVECOLUMN) * NUM_SERVDIRCOLUMNS); for (count = 0; count < NUM_SERVDIRCOLUMNS; count++) { rcSessDir[count].columnid = servdircolumnid[count]; rcSessDir[count].pvData = &num_vals[count]; rcSessDir[count].cbData = sizeof(long); rcSessDir[count].itagSequence = 1; } rcSessDir[SERVDIR_SERVADDR_INTERNAL_INDEX].pvData = ServerNameBuf; rcSessDir[SERVDIR_SERVADDR_INTERNAL_INDEX].cbData = sizeof(ServerNameBuf); rcSessDir[SERVDIR_SINGLESESS_INTERNAL_INDEX].pvData = &SingleSessMode; rcSessDir[SERVDIR_SINGLESESS_INTERNAL_INDEX].cbData = sizeof(SingleSessMode); CALL(JetRetrieveColumns(sesid, servdirtableid, &rcSessDir[0], NUM_SERVDIRCOLUMNS)); TSDISErrorOut(L"%d, %s, %d, %d, %d, %d, %s\n", num_vals[ SERVDIR_SERVID_INTERNAL_INDEX], ServerNameBuf, num_vals[ SERVDIR_CLUSID_INTERNAL_INDEX], num_vals[ SERVDIR_AITLOW_INTERNAL_INDEX], num_vals[ SERVDIR_AITHIGH_INTERNAL_INDEX], num_vals[ SERVDIR_NUMFAILPINGS_INTERNAL_INDEX], SingleSessMode ? L"single session mode" : L"multi-session mode"); err = JetMove(sesid, servdirtableid, JET_MoveNext, 0); } // Output Cluster Directory TSDISErrorOut(L"CLUSTER DIRECTORY\n"); err = JetMove(sesid, clusdirtableid, JET_MoveFirst, 0); if (JET_errNoCurrentRecord == err) { TSDISErrorOut(L" (empty database)\n"); } while (JET_errNoCurrentRecord != err) { memset(&rcSessDir[0], 0, sizeof(JET_RETRIEVECOLUMN) * NUM_CLUSDIRCOLUMNS); for (count = 0; count < NUM_CLUSDIRCOLUMNS; count++) { rcSessDir[count].columnid = clusdircolumnid[count]; rcSessDir[count].pvData = &num_vals[count]; rcSessDir[count].cbData = sizeof(long); rcSessDir[count].itagSequence = 1; } rcSessDir[CLUSDIR_CLUSNAME_INTERNAL_INDEX].pvData = ClusterNameBuf; rcSessDir[CLUSDIR_CLUSNAME_INTERNAL_INDEX].cbData = sizeof(ClusterNameBuf); rcSessDir[CLUSDIR_SINGLESESS_INTERNAL_INDEX].pvData = &SingleSessMode; rcSessDir[CLUSDIR_SINGLESESS_INTERNAL_INDEX].cbData = sizeof(SingleSessMode); CALL(JetRetrieveColumns(sesid, clusdirtableid, &rcSessDir[0], NUM_CLUSDIRCOLUMNS)); TSDISErrorOut(L"%d, %s, %s\n", num_vals[CLUSDIR_CLUSID_INTERNAL_INDEX], ClusterNameBuf, SingleSessMode ? L"single session mode" : L"multi-session mode"); err = JetMove(sesid, clusdirtableid, JET_MoveNext, 0); } TSDISErrorOut(L"\n"); CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, clusdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); return; 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); } } #endif //DBG typedef DWORD CLIENTINFO; /****************************************************************************/ // TSSDRpcServerOnline // // Called for server-active indications on each cluster TS machine. /****************************************************************************/ DWORD TSSDRpcServerOnline( handle_t Binding, WCHAR __RPC_FAR *ClusterName, /* out */ HCLIENTINFO *hCI, DWORD SrvOnlineFlags) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID clusdirtableid; JET_TABLEID servdirtableid; JET_SETCOLUMN scServDir[NUM_SERVDIRCOLUMNS]; WCHAR *StringBinding = NULL; WCHAR *ServerAddress = NULL; RPC_BINDING_HANDLE ServerBinding = 0; unsigned long cbActual; long ClusterID; long ServerID = 0; long zero = 0; char czero = 0; // The single session mode of this server. char SingleSession = (char) SrvOnlineFlags & SINGLE_SESSION_FLAG; char ClusSingleSessionMode; unsigned count; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"In ServOnline, ClusterName=%s, SrvOnlineFlags=%u\n", ClusterName, SrvOnlineFlags); // Determine client address. if (RpcBindingServerFromClient(Binding, &ServerBinding) != RPC_S_OK) { TSDISErrorOut(L"ServOn: BindingServerFromClient failed!\n"); goto HandleError; } if (RpcBindingToStringBinding(ServerBinding, &StringBinding) != RPC_S_OK) { TSDISErrorOut(L"ServOn: BindingToStringBinding failed!\n"); goto HandleError; } if (RpcStringBindingParse(StringBinding, NULL, NULL, &ServerAddress, NULL, NULL) != RPC_S_OK) { TSDISErrorOut(L"ServOn: StringBindingParse failed!\n"); goto HandleError; } CALL(JetBeginSession(g_instance, &sesid, "user", "")); CALL(JetOpenDatabase(sesid, JETDBFILENAME, "", &dbid, 0)); CALL(JetOpenTable(sesid, dbid, "ClusterDirectory", NULL, 0, 0, &clusdirtableid)); CALL(JetOpenTable(sesid, dbid, "ServerDirectory", NULL, 0, 0, &servdirtableid)); // First, delete all entries for this server from the session/server //directories CALL(JetBeginTransaction(sesid)); CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServNameIndex")); CALL(JetMakeKey(sesid, servdirtableid, ServerAddress, (unsigned) (wcslen(ServerAddress) + 1) * sizeof(WCHAR), JET_bitNewKey)); err = JetSeek(sesid, servdirtableid, JET_bitSeekEQ); if (JET_errSuccess == err) { CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_SERVID_INTERNAL_INDEX], &ServerID, sizeof(ServerID), &cbActual, 0, NULL)); if (TSSDPurgeServer(ServerID) != 0) TSDISErrorOut(L"ServOn: PurgeServer %d failed.\n", ServerID); } else if (JET_errRecordNotFound != err) { CALL(err); } CALL(JetCommitTransaction(sesid, 0)); // We have to do the add in a loop, because we have to: // 1) Check if the record is there. // 2) If it's not, add it. (The next time through the loop, therefore, // we'll go step 1->3, and we're done.) // 3) If it is, retrieve the value of clusterID and break out. // // There is an additional complication in that someone else may be in the // thread simultaneously, doing the same thing. Therefore, someone might // be in step 2 and try to add a new cluster, but fail because someone // else added it. So they have to keep trying, because though the other // thread has added it, it may not have committed the change. To try to // keep that to a minimum, we sleep a short time before trying again. for ( ; ; ) { // Now do the actual add. CALL(JetBeginTransaction(sesid)); // Search for the cluster in the cluster directory. CALL(JetSetCurrentIndex(sesid, clusdirtableid, "ClusNameIndex")); CALL(JetMakeKey(sesid, clusdirtableid, ClusterName, (unsigned) (wcslen(ClusterName) + 1) * sizeof(WCHAR), JET_bitNewKey)); err = JetSeek(sesid, clusdirtableid, JET_bitSeekEQ); // If the cluster does not exist, create it. if (JET_errRecordNotFound == err) { CALL(JetPrepareUpdate(sesid, clusdirtableid, JET_prepInsert)); // ClusterName CALL(JetSetColumn(sesid, clusdirtableid, clusdircolumnid[ CLUSDIR_CLUSNAME_INTERNAL_INDEX], ClusterName, (unsigned) (wcslen(ClusterName) + 1) * sizeof(WCHAR), 0, NULL)); // SingleSessionMode // Since this is the only server in the cluster, the single session // mode is simply the mode of this server. CALL(JetSetColumn(sesid, clusdirtableid, clusdircolumnid[ CLUSDIR_SINGLESESS_INTERNAL_INDEX], &SingleSession, sizeof(SingleSession), 0, NULL)); err = JetUpdate(sesid, clusdirtableid, NULL, 0, &cbActual); // If it's a duplicate key, someone else made the key so we should // be ok. Yield the processor and try the query again, next time // through the loop. if (JET_errKeyDuplicate == err) { CALL(JetCommitTransaction(sesid, 0)); Sleep(100); } else { CALL(err); // Now we've succeeded. Just continue through the loop. // The next time through, we will retrieve the autoincrement // column we just added and break out. CALL(JetCommitTransaction(sesid, 0)); } } else { CALL(err); // If the above check makes it here, we have found the row. // Now retrieve the clusid, commit, and break out of the loop. CALL(JetRetrieveColumn(sesid, clusdirtableid, clusdircolumnid[ CLUSDIR_CLUSID_INTERNAL_INDEX], &ClusterID, sizeof(ClusterID), &cbActual, 0, NULL)); CALL(JetCommitTransaction(sesid, 0)); break; } } CALL(JetBeginTransaction(sesid)); // Insert the servername, clusterid, 0, 0 into the server directory table err = JetMove(sesid, servdirtableid, JET_MoveLast, 0); CALL(JetPrepareUpdate(sesid, servdirtableid, JET_prepInsert)); memset(&scServDir[0], 0, sizeof(JET_SETCOLUMN) * NUM_SERVDIRCOLUMNS); for (count = 0; count < NUM_SERVDIRCOLUMNS; count++) { scServDir[count].columnid = servdircolumnid[count]; scServDir[count].cbData = 4; // most of them, set the rest individually scServDir[count].itagSequence = 1; } scServDir[SERVDIR_SERVADDR_INTERNAL_INDEX].pvData = ServerAddress; scServDir[SERVDIR_SERVADDR_INTERNAL_INDEX].cbData = (unsigned) (wcslen(ServerAddress) + 1) * sizeof(WCHAR); scServDir[SERVDIR_CLUSID_INTERNAL_INDEX].pvData = &ClusterID; scServDir[SERVDIR_AITLOW_INTERNAL_INDEX].pvData = &zero; scServDir[SERVDIR_AITHIGH_INTERNAL_INDEX].pvData = &zero; scServDir[SERVDIR_NUMFAILPINGS_INTERNAL_INDEX].pvData = &zero; scServDir[SERVDIR_SINGLESESS_INTERNAL_INDEX].pvData = &SingleSession; scServDir[SERVDIR_SINGLESESS_INTERNAL_INDEX].cbData = sizeof(SingleSession); // Don't set the first column (index 0)--it is autoincrement. CALL(JetSetColumns(sesid, servdirtableid, &scServDir[ SERVDIR_SERVADDR_INTERNAL_INDEX], NUM_SERVDIRCOLUMNS - 1)); CALL(JetUpdate(sesid, servdirtableid, NULL, 0, &cbActual)); CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServNameIndex")); CALL(JetMakeKey(sesid, servdirtableid, ServerAddress, (unsigned) (wcslen(ServerAddress) + 1) * sizeof(WCHAR), JET_bitNewKey)); CALL(JetSeek(sesid, servdirtableid, JET_bitSeekEQ)); CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_SERVID_INTERNAL_INDEX], &ServerID, sizeof(ServerID), &cbActual, 0, NULL)); *hCI = ULongToPtr(ServerID); // Now that the server is all set up, we have to set the cluster to the // correct mode. If any server in the cluster is in multisession mode, then // we stick with multisession. If they are all single session, though, we // turn on single session in this cluster. We do some database magic // to make this work. We have an index on the ClusterID and the Single // Session mode. We query for this cluster with single session mode 0 // (i.e., multi-session mode). If we get any results back, we are multi- // session, otherwise we're single session. // Set up the key. CALL(JetSetCurrentIndex(sesid, servdirtableid, "SingleSessionIndex")); CALL(JetMakeKey(sesid, servdirtableid, &ClusterID, sizeof(ClusterID), JET_bitNewKey)); CALL(JetMakeKey(sesid, servdirtableid, &czero, sizeof(czero), 0)); err = JetSeek(sesid, servdirtableid, JET_bitSeekEQ | JET_bitSetIndexRange); // NOTE REUSE OF SingleSession VARIABLE! Up there it meant what the flag // passed in meant. Here it means what we determine the cluster's state to // be based on our logic. if (err == JET_errRecordNotFound) { SingleSession = 1; } else { // CALL the error value to make sure it's success CALL(err); // If we got here then everything is ok. SingleSession = 0; } // Check the cluster to see if it is already in that mode. CALL(JetSetCurrentIndex(sesid, clusdirtableid, "ClusIDIndex")); CALL(JetMakeKey(sesid, clusdirtableid, (const void *)&ClusterID, sizeof(ClusterID), JET_bitNewKey)); CALL(JetSeek(sesid, clusdirtableid, JET_bitSeekEQ)); CALL(JetRetrieveColumn(sesid, clusdirtableid, clusdircolumnid[ CLUSDIR_SINGLESESS_INTERNAL_INDEX], &ClusSingleSessionMode, sizeof( ClusSingleSessionMode), &cbActual, 0, NULL)); // If not, change the mode. if (SingleSession != ClusSingleSessionMode) { CALL(JetPrepareUpdate(sesid, clusdirtableid, JET_prepReplace)); CALL(JetSetColumn(sesid, clusdirtableid, clusdircolumnid[ CLUSDIR_SINGLESESS_INTERNAL_INDEX], &SingleSession, sizeof(SingleSession), 0, NULL)); CALL(JetUpdate(sesid, clusdirtableid, NULL, 0, &cbActual)); } CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseTable(sesid, clusdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); if (ServerBinding != NULL) RpcBindingFree(&ServerBinding); if (StringBinding != NULL) RpcStringFree(&StringBinding); if (ServerAddress != NULL) RpcStringFree(&ServerAddress); 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 (ServerBinding != NULL) RpcBindingFree(&ServerBinding); if (StringBinding != NULL) RpcStringFree(&StringBinding); if (ServerAddress != NULL) RpcStringFree(&ServerAddress); // Just in case we got to commit. TSSDPurgeServer(ServerID); // Close the context handle. *hCI = NULL; return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcServerOffline // // Called for server-shutdown indications on each cluster TS machine. /****************************************************************************/ DWORD TSSDRpcServerOffline( handle_t Binding, HCLIENTINFO *hCI) { DWORD retval = 0; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"In ServOff, hCI = 0x%x\n", *hCI); CLIENTINFO *pCI = (CLIENTINFO *) hCI; if (pCI != NULL) retval = TSSDPurgeServer(*pCI); *hCI = NULL; return retval; } /****************************************************************************/ // TSSDPurgeServer // // Delete a server and all its sessions from the session directory. /****************************************************************************/ DWORD TSSDPurgeServer( DWORD ServerID) { JET_SESID sesid = JET_sesidNil; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; JET_DBID dbid; JET_ERR err; TSDISErrorOut(L"In PurgeServer, ServerID=%d\n", ServerID); CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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(JetBeginTransaction(sesid)); // Delete all sessions in session directory that have this serverid CALL(JetSetCurrentIndex(sesid, sessdirtableid, "ServerIndex")); CALL(JetMakeKey(sesid, sessdirtableid, &ServerID, sizeof(ServerID), JET_bitNewKey)); err = JetSeek(sesid, sessdirtableid, JET_bitSeekEQ); while (0 == err) { CALL(JetDelete(sesid, sessdirtableid)); CALL(JetMakeKey(sesid, sessdirtableid, &ServerID, sizeof(ServerID), JET_bitNewKey)); err = JetSeek(sesid, sessdirtableid, JET_bitSeekEQ); } // Should be err -1601 -- JET_errRecordNotFound // Delete the server in the server directory with this serverid CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServerIDIndex")); CALL(JetMakeKey(sesid, servdirtableid, &ServerID, sizeof(ServerID), JET_bitNewKey)); err = JetSeek(sesid, servdirtableid, JET_bitSeekEQ); if (JET_errSuccess == err) CALL(JetDelete(sesid, servdirtableid)); CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcGetUserDisconnectedSessions // // Queries disconnected sessions from the session database. /****************************************************************************/ DWORD TSSDRpcGetUserDisconnectedSessions( handle_t Binding, HCLIENTINFO *hCI, WCHAR __RPC_FAR *UserName, WCHAR __RPC_FAR *Domain, /* out */ DWORD __RPC_FAR *pNumSessions, /* out */ TSSD_DiscSessInfo __RPC_FAR __RPC_FAR **padsi) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; JET_TABLEID clusdirtableid; *pNumSessions = 0; unsigned i = 0; unsigned j = 0; unsigned long cbActual; DWORD tempClusterID; DWORD CallingServersClusID; long ServerID; CLIENTINFO *pCI = (CLIENTINFO *) hCI; TSSD_DiscSessInfo *adsi = NULL; char one = 1; char bSingleSession = 0; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"In GetUserDiscSess: ServID = %d, User: %s, " L"Domain: %s\n", *pCI, UserName, Domain); *padsi = (TSSD_DiscSessInfo *) MIDL_user_allocate(sizeof(TSSD_DiscSessInfo) * TSSD_MaxDisconnectedSessions); adsi = *padsi; if (adsi == NULL) { TSDISErrorOut(L"GetUserDisc: Memory alloc failed!\n"); goto HandleError; } // Set the pointers to 0 to be safe, and so that we can free uninitialized // ones later without AVing. for (j = 0; j < TSSD_MaxDisconnectedSessions; j++) { adsi[j].ServerAddress = NULL; adsi[j].AppType = NULL; } CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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)); // Verify that the ServerID passed in was OK. if (TSSDVerifyServerIDValid(sesid, servdirtableid, PtrToUlong(*hCI)) == FALSE) { TSDISErrorOut(L"Invalid ServerID was passed in\n"); goto HandleError; } // First, get the cluster ID for the server making the query. CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServerIDIndex")); CALL(JetMakeKey(sesid, servdirtableid, (const void *)pCI, sizeof(DWORD), JET_bitNewKey)); CALL(JetSeek(sesid, servdirtableid, JET_bitSeekEQ)); CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_CLUSID_INTERNAL_INDEX], &CallingServersClusID, sizeof( CallingServersClusID), &cbActual, 0, NULL)); // Now that we have the cluster id, check to see whether this cluster // is in single session mode. CALL(JetSetCurrentIndex(sesid, clusdirtableid, "ClusIDIndex")); CALL(JetMakeKey(sesid, clusdirtableid, (const void *)&CallingServersClusID, sizeof(CallingServersClusID), JET_bitNewKey)); CALL(JetSeek(sesid, clusdirtableid, JET_bitSeekEQ)); CALL(JetRetrieveColumn(sesid, clusdirtableid, clusdircolumnid[ CLUSDIR_SINGLESESS_INTERNAL_INDEX], &bSingleSession, sizeof( bSingleSession), &cbActual, 0, NULL)); // Now, get all the disconnected or all sessions for this cluster, depending // on the single session mode retrieved above. if (bSingleSession == FALSE) { CALL(JetSetCurrentIndex(sesid, sessdirtableid, "DiscSessionIndex")); CALL(JetMakeKey(sesid, sessdirtableid, UserName, (unsigned) (wcslen(UserName) + 1) * sizeof(WCHAR), JET_bitNewKey)); CALL(JetMakeKey(sesid, sessdirtableid, Domain, (unsigned) (wcslen(Domain) + 1) * sizeof(WCHAR), 0)); CALL(JetMakeKey(sesid, sessdirtableid, &one, sizeof(one), 0)); } else { CALL(JetSetCurrentIndex(sesid, sessdirtableid, "AllSessionIndex")); CALL(JetMakeKey(sesid, sessdirtableid, UserName, (unsigned) (wcslen(UserName) + 1) * sizeof(WCHAR), JET_bitNewKey)); CALL(JetMakeKey(sesid, sessdirtableid, Domain, (unsigned) (wcslen(Domain) + 1) * sizeof(WCHAR), 0)); } err = JetSeek(sesid, sessdirtableid, JET_bitSeekEQ | JET_bitSetIndexRange); while ((i < TSSD_MaxDisconnectedSessions) && (JET_errSuccess == err)) { // Remember the initial retrieval does not have cluster id in the // index, so filter by cluster id for each one. // Get the ServerID for this record. CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_SERVERID_INTERNAL_INDEX], &ServerID, sizeof(ServerID), &cbActual, 0, NULL)); // Get the clusterID CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServerIDIndex")); CALL(JetMakeKey(sesid, servdirtableid, &ServerID, sizeof(ServerID), JET_bitNewKey)); CALL(JetSeek(sesid, servdirtableid, JET_bitSeekEQ)); CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_CLUSID_INTERNAL_INDEX], &tempClusterID, sizeof(tempClusterID), &cbActual, 0, NULL)); // Compare to the passed-in cluster id. if (tempClusterID == CallingServersClusID) { // Allocate space. adsi[i].ServerAddress = (WCHAR *) MIDL_user_allocate(64 * sizeof(WCHAR)); adsi[i].AppType = (WCHAR *) MIDL_user_allocate(256 * sizeof(WCHAR)); if ((adsi[i].ServerAddress == NULL) || (adsi[i].AppType == NULL)) { TSDISErrorOut(L"GetUserDisc: Memory alloc failed!\n"); goto HandleError; } // ServerAddress comes out of the server table CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_SERVADDR_INTERNAL_INDEX], adsi[i].ServerAddress, 128, &cbActual, 0, NULL)); // The rest come out of the session directory // Session ID CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_SESSIONID_INTERNAL_INDEX], &(adsi[i].SessionID), sizeof(DWORD), &cbActual, 0, NULL)); // TSProtocol CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_TSPROTOCOL_INTERNAL_INDEX], &(adsi[i].TSProtocol), sizeof(DWORD), &cbActual, 0, NULL)); // Application Type CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_APPTYPE_INTERNAL_INDEX], adsi[i].AppType, 512, &cbActual, 0, NULL)); // ResolutionWidth CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_RESWIDTH_INTERNAL_INDEX], &(adsi[i].ResolutionWidth), sizeof(DWORD), &cbActual, 0, NULL)); // ResolutionHeight CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_RESHEIGHT_INTERNAL_INDEX], &(adsi[i].ResolutionHeight), sizeof(DWORD), &cbActual, 0, NULL)); // Color Depth CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_COLORDEPTH_INTERNAL_INDEX], &(adsi[i].ColorDepth), sizeof(DWORD), &cbActual, 0, NULL)); // CreateTimeLow CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_CTLOW_INTERNAL_INDEX], &(adsi[i].CreateTimeLow), sizeof(DWORD), &cbActual, 0, NULL)); // CreateTimeHigh CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_CTHIGH_INTERNAL_INDEX], &(adsi[i].CreateTimeHigh), sizeof(DWORD), &cbActual, 0, NULL)); // DisconnectTimeLow CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_DTLOW_INTERNAL_INDEX], &(adsi[i].DisconnectTimeLow), sizeof(DWORD), &cbActual, 0, NULL)); // DisconnectTimeHigh CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_DTHIGH_INTERNAL_INDEX], &(adsi[i].DisconnectTimeHigh), sizeof(DWORD), &cbActual, 0, NULL)); // State // This is retrieving a byte that is 0xff or 0x0 into a DWORD // pointer. CALL(JetRetrieveColumn(sesid, sessdirtableid, sesdircolumnid[SESSDIR_STATE_INTERNAL_INDEX], &(adsi[i].State), sizeof(BYTE), &cbActual, 0, NULL)); i += 1; } // Move to the next matching record. err = JetMove(sesid, sessdirtableid, JET_MoveNext, 0); } *pNumSessions = i; CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, clusdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); #ifdef DBG OutputAllTables(); #endif // DBG return 0; HandleError: // Deallocate memory. for (j = 0; j < TSSD_MaxDisconnectedSessions; j++) { MIDL_user_free(adsi[j].ServerAddress); MIDL_user_free(adsi[j].AppType); } // Can't really recover. Just bail out. if (sesid != JET_sesidNil) { (VOID) JetRollback(sesid, JET_bitRollbackAll); // Force the session closed. (VOID) JetEndSession(sesid, JET_bitForceSessionClosed); } // Delete the server and close the context handle. Their states are bad. TSSDPurgeServer(PtrToUlong(*hCI)); *hCI = NULL; return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcCreateSession // // Called on a session logon. /****************************************************************************/ DWORD TSSDRpcCreateSession( handle_t Binding, HCLIENTINFO *hCI, WCHAR __RPC_FAR *UserName, WCHAR __RPC_FAR *Domain, DWORD SessionID, DWORD TSProtocol, WCHAR __RPC_FAR *AppType, DWORD ResolutionWidth, DWORD ResolutionHeight, DWORD ColorDepth, DWORD CreateTimeLow, DWORD CreateTimeHigh) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; JET_SETCOLUMN scSessDir[NUM_SESSDIRCOLUMNS]; CLIENTINFO *pCI = (CLIENTINFO *) hCI; unsigned count; int zero = 0; unsigned long cbActual; char state = 0; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"Inside TSSDRpcCreateSession, ServID=%d, " L"UserName=%s, Domain=%s, SessID=%d, TSProt=%d, AppType=%s, " L"ResWidth=%d, ResHeight=%d, ColorDepth=%d\n", *pCI, UserName, Domain, SessionID, TSProtocol, AppType, ResolutionWidth, ResolutionHeight, ColorDepth); TSDISErrorTimeOut(L" CreateTime=%s\n", CreateTimeLow, CreateTimeHigh); memset(&scSessDir[0], 0, sizeof(JET_SETCOLUMN) * NUM_SESSDIRCOLUMNS); CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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(JetBeginTransaction(sesid)); // Verify that the ServerID passed in was OK. if (TSSDVerifyServerIDValid(sesid, servdirtableid, PtrToUlong(*hCI)) == FALSE) { TSDISErrorOut(L"Invalid ServerID was passed in\n"); goto HandleError; } err = JetMove(sesid, sessdirtableid, JET_MoveLast, 0); CALL(JetPrepareUpdate(sesid, sessdirtableid, JET_prepInsert)); for (count = 0; count < NUM_SESSDIRCOLUMNS; count++) { scSessDir[count].columnid = sesdircolumnid[count]; scSessDir[count].cbData = 4; // most of them, set the rest individually scSessDir[count].itagSequence = 1; } scSessDir[SESSDIR_USERNAME_INTERNAL_INDEX].cbData = (unsigned) (wcslen(UserName) + 1) * sizeof(WCHAR); scSessDir[SESSDIR_DOMAIN_INTERNAL_INDEX].cbData = (unsigned) (wcslen(Domain) + 1) * sizeof(WCHAR); scSessDir[SESSDIR_APPTYPE_INTERNAL_INDEX].cbData = (unsigned) (wcslen(AppType) + 1) * sizeof(WCHAR); scSessDir[SESSDIR_STATE_INTERNAL_INDEX].cbData = sizeof(char); scSessDir[SESSDIR_USERNAME_INTERNAL_INDEX].pvData = UserName; scSessDir[SESSDIR_DOMAIN_INTERNAL_INDEX].pvData = Domain; scSessDir[SESSDIR_SERVERID_INTERNAL_INDEX].pvData = pCI; scSessDir[SESSDIR_SESSIONID_INTERNAL_INDEX].pvData = &SessionID; scSessDir[SESSDIR_TSPROTOCOL_INTERNAL_INDEX].pvData = &TSProtocol; scSessDir[SESSDIR_CTLOW_INTERNAL_INDEX].pvData = &CreateTimeLow; scSessDir[SESSDIR_CTHIGH_INTERNAL_INDEX].pvData = &CreateTimeHigh; scSessDir[SESSDIR_DTLOW_INTERNAL_INDEX].pvData = &zero; scSessDir[SESSDIR_DTHIGH_INTERNAL_INDEX].pvData = &zero; scSessDir[SESSDIR_APPTYPE_INTERNAL_INDEX].pvData = AppType; scSessDir[SESSDIR_RESWIDTH_INTERNAL_INDEX].pvData = &ResolutionWidth; scSessDir[SESSDIR_RESHEIGHT_INTERNAL_INDEX].pvData = &ResolutionHeight; scSessDir[SESSDIR_COLORDEPTH_INTERNAL_INDEX].pvData = &ColorDepth; scSessDir[SESSDIR_STATE_INTERNAL_INDEX].pvData = &state; CALL(JetSetColumns(sesid, sessdirtableid, scSessDir, NUM_SESSDIRCOLUMNS)); CALL(JetUpdate(sesid, sessdirtableid, NULL, 0, &cbActual)); CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } // Delete the server and close the context handle. Their states are bad. TSSDPurgeServer(PtrToUlong(*hCI)); *hCI = NULL; return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcDeleteSession // // Called on a session logoff. /****************************************************************************/ DWORD TSSDRpcDeleteSession( handle_t Binding, HCLIENTINFO *hCI, DWORD SessionID) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; CLIENTINFO *pCI = (CLIENTINFO *) hCI; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"In DelSession, ServID=%d, " L"SessID=%d\n", *pCI, SessionID); CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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(JetBeginTransaction(sesid)); // Verify that the ServerID passed in was OK. if (TSSDVerifyServerIDValid(sesid, servdirtableid, PtrToUlong(*hCI)) == FALSE) { TSDISErrorOut(L"Invalid ServerID was passed in\n"); goto HandleError; } // Delete all sessions in session directory that have this serverid CALL(JetSetCurrentIndex(sesid, sessdirtableid, "primaryIndex")); CALL(JetMakeKey(sesid, sessdirtableid, pCI, sizeof(*pCI), JET_bitNewKey)); CALL(JetMakeKey(sesid, sessdirtableid, &SessionID, sizeof(SessionID), 0)); err = JetSeek(sesid, sessdirtableid, JET_bitSeekEQ); CALL(JetDelete(sesid, sessdirtableid)); CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } // Delete the server and close the context handle. Their states are bad. TSSDPurgeServer(PtrToUlong(*hCI)); *hCI = NULL; return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcSetSessionDisconnected // // Called on a session disconnection. /****************************************************************************/ DWORD TSSDRpcSetSessionDisconnected( handle_t Binding, HCLIENTINFO *hCI, DWORD SessionID, DWORD DiscTimeLow, DWORD DiscTimeHigh) { unsigned long cbActual; JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; CLIENTINFO *pCI = (CLIENTINFO *) hCI; char one = 1; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"In SetSessDisc, ServID=%d, SessID=%d\n", *pCI, SessionID); TSDISErrorTimeOut(L" DiscTime=%s\n", DiscTimeLow, DiscTimeHigh); CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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(JetBeginTransaction(sesid)); // Verify that the ServerID passed in was OK. if (TSSDVerifyServerIDValid(sesid, servdirtableid, PtrToUlong(*hCI)) == FALSE) { TSDISErrorOut(L"Invalid ServerID was passed in\n"); goto HandleError; } CALL(JetSetCurrentIndex(sesid, sessdirtableid, "primaryIndex")); // find the record with the serverid, sessionid we are looking for CALL(JetMakeKey(sesid, sessdirtableid, pCI, sizeof(DWORD), JET_bitNewKey)); CALL(JetMakeKey(sesid, sessdirtableid, &SessionID, sizeof(DWORD), 0)); CALL(JetSeek(sesid, sessdirtableid, JET_bitSeekEQ)); CALL(JetPrepareUpdate(sesid, sessdirtableid, JET_prepReplace)); CALL(JetSetColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_STATE_INTERNAL_INDEX], &one, sizeof(one), 0, NULL)); CALL(JetUpdate(sesid, sessdirtableid, NULL, 0, &cbActual)); CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } // Delete the server and close the context handle. Their states are bad. TSSDPurgeServer(PtrToUlong(*hCI)); *hCI = NULL; return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcSetSessionReconnected // // Called on a session reconnection. /****************************************************************************/ DWORD TSSDRpcSetSessionReconnected( handle_t Binding, HCLIENTINFO *hCI, DWORD SessionID, DWORD TSProtocol, DWORD ResWidth, DWORD ResHeight, DWORD ColorDepth) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; CLIENTINFO *pCI = (CLIENTINFO *) hCI; char zero = 0; unsigned long cbActual; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"In SetSessRec, ServID=%d, SessID=%d, TSProt=%d, " L"ResWid=%d, ResHt=%d, ColDepth=%d\n", *pCI, SessionID, TSProtocol, ResWidth, ResHeight, ColorDepth); CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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(JetBeginTransaction(sesid)); // Verify that the ServerID passed in was OK. if (TSSDVerifyServerIDValid(sesid, servdirtableid, PtrToUlong(*hCI)) == FALSE) { TSDISErrorOut(L"Invalid ServerID was passed in\n"); goto HandleError; } CALL(JetSetCurrentIndex(sesid, sessdirtableid, "primaryIndex")); // Find the record with the serverid, sessionid we are looking for. CALL(JetMakeKey(sesid, sessdirtableid, pCI, sizeof(DWORD), JET_bitNewKey)); CALL(JetMakeKey(sesid, sessdirtableid, &SessionID, sizeof(DWORD), 0)); CALL(JetSeek(sesid, sessdirtableid, JET_bitSeekEQ)); CALL(JetPrepareUpdate(sesid, sessdirtableid, JET_prepReplace)); CALL(JetSetColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_TSPROTOCOL_INTERNAL_INDEX], &TSProtocol, sizeof(TSProtocol), 0, NULL)); CALL(JetSetColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_RESWIDTH_INTERNAL_INDEX], &ResWidth, sizeof(ResWidth), 0, NULL)); CALL(JetSetColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_RESHEIGHT_INTERNAL_INDEX], &ResHeight, sizeof(ResHeight), 0, NULL)); CALL(JetSetColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_COLORDEPTH_INTERNAL_INDEX], &ColorDepth, sizeof(ColorDepth), 0, NULL)); CALL(JetSetColumn(sesid, sessdirtableid, sesdircolumnid[ SESSDIR_STATE_INTERNAL_INDEX], &zero, sizeof(zero), 0, NULL)); CALL(JetUpdate(sesid, sessdirtableid, NULL, 0, &cbActual)); CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } // Delete the server and close the context handle. Their states are bad. TSSDPurgeServer(PtrToUlong(*hCI)); *hCI = NULL; return (DWORD) E_FAIL; } DWORD TSSDRpcSetServerReconnectPending( handle_t Binding, WCHAR __RPC_FAR *ServerAddress, DWORD AlmostTimeLow, DWORD AlmostTimeHigh) { // Ignored parameters Binding; AlmostTimeLow; AlmostTimeHigh; return TSSDSetServerAITInternal(ServerAddress, FALSE, NULL); } /****************************************************************************/ // TSSDRpcUpdateConfigurationSetting // // Extensible interface to update a configuration setting. /****************************************************************************/ DWORD TSSDSetServerAddress(HCLIENTINFO *hCI, WCHAR *ServerName) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID servdirtableid; unsigned long cbActual; CALL(JetBeginSession(g_instance, &sesid, "user", "")); CALL(JetOpenDatabase(sesid, JETDBFILENAME, "", &dbid, 0)); CALL(JetOpenTable(sesid, dbid, "ServerDirectory", NULL, 0, 0, &servdirtableid)); // Find the server in the server directory CALL(JetBeginTransaction(sesid)); CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServerIDIndex")); CALL(JetMakeKey(sesid, servdirtableid, (const void *)hCI, sizeof(DWORD), JET_bitNewKey)); CALL(JetSeek(sesid, servdirtableid, JET_bitSeekEQ)); // Prepare to update. CALL(JetPrepareUpdate(sesid, servdirtableid, JET_prepReplace)); // Now set the column to what we want CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_SERVADDR_INTERNAL_INDEX], (void *) ServerName, (unsigned) (wcslen(ServerName) + 1) * sizeof(WCHAR), 0, NULL)); CALL(JetUpdate(sesid, servdirtableid, NULL, 0, &cbActual)); CALL(JetCommitTransaction(sesid, 0)); // Clean up. CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } TSSDPurgeServer(PtrToUlong(*hCI)); // Close the context handle. *hCI = NULL; return (DWORD) E_FAIL; } /****************************************************************************/ // TSSDRpcUpdateConfigurationSetting // // Extensible interface to update a configuration setting. /****************************************************************************/ DWORD TSSDRpcUpdateConfigurationSetting( handle_t Binding, HCLIENTINFO *hCI, DWORD dwSetting, DWORD dwSettingLength, BYTE __RPC_FAR *pbValue) { // Unreferenced parameters. Binding; hCI; dwSetting; dwSettingLength; pbValue; if (dwSetting == SDCONFIG_SERVER_ADDRESS) { TSDISErrorOut(L"Server is setting its address as %s\n", (WCHAR *) pbValue); return TSSDSetServerAddress(hCI, (WCHAR *) pbValue); } return (DWORD) E_NOTIMPL; } /****************************************************************************/ // TSSDSetServerAITInternal // // Called on a client redirection from one server to another, to let the // integrity service determine how to ping the redirection target machine. // // Args: // ServerAddress (in) - the server address to set values for // bResetToZero (in) - whether to reset all AIT values to 0 // FailureCount (in/out) - Pointer to nonzero on entry means increment the // failure count. Returns the result failure count. /****************************************************************************/ DWORD TSSDSetServerAITInternal( WCHAR *ServerAddress, DWORD bResetToZero, DWORD *FailureCount) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID servdirtableid; DWORD AITFromServDirLow; DWORD AITFromServDirHigh; unsigned long cbActual; TSDISErrorOut(L"SetServAITInternal: ServAddr=%s, bResetToZero=%d, bIncFail" L"=%d\n", ServerAddress, bResetToZero, (FailureCount == NULL) ? 0 : *FailureCount); CALL(JetBeginSession(g_instance, &sesid, "user", "")); CALL(JetOpenDatabase(sesid, JETDBFILENAME, "", &dbid, 0)); CALL(JetOpenTable(sesid, dbid, "ServerDirectory", NULL, 0, 0, &servdirtableid)); CALL(JetBeginTransaction(sesid)); CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServNameIndex")); CALL(JetMakeKey(sesid, servdirtableid, ServerAddress, (unsigned) (wcslen(ServerAddress) + 1) * sizeof(WCHAR), JET_bitNewKey)); CALL(JetSeek(sesid, servdirtableid, JET_bitSeekEQ)); // Algorithm for set reconnect pending: // 1) If server is not already pending a reconnect, // 2) Set the AlmostTimeLow and High to locally computed times (using // the times from the wire is dangerous and requires clocks to be the // same). // Retrieve the current values of AlmostInTimeLow and High CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_AITLOW_INTERNAL_INDEX], &AITFromServDirLow, sizeof(AITFromServDirLow), &cbActual, 0, NULL)); CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_AITHIGH_INTERNAL_INDEX], &AITFromServDirHigh, sizeof(AITFromServDirHigh), &cbActual, 0, NULL)); // If it's time to reset, reset to 0. if (bResetToZero != 0) { DWORD zero = 0; CALL(JetPrepareUpdate(sesid, servdirtableid, JET_prepReplace)); // Set the columns: Low, High, and NumFailedPings. CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_AITLOW_INTERNAL_INDEX], &zero, sizeof(zero), 0, NULL)); CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_AITHIGH_INTERNAL_INDEX], &zero, sizeof(zero), 0, NULL)); CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_NUMFAILPINGS_INTERNAL_INDEX], &zero, sizeof(zero), 0, NULL)); CALL(JetUpdate(sesid, servdirtableid, NULL, 0, &cbActual)); } // Otherwise, if the server isn't already pending a reconnect, else if ((AITFromServDirLow == 0) && (AITFromServDirHigh == 0)) { FILETIME ft; SYSTEMTIME st; // Retrieve the time. GetSystemTime(&st); SystemTimeToFileTime(&st, &ft); CALL(JetPrepareUpdate(sesid, servdirtableid, JET_prepReplace)); // Set the columns. CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_AITLOW_INTERNAL_INDEX], &(ft.dwLowDateTime), sizeof(ft.dwLowDateTime), 0, NULL)); CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_AITHIGH_INTERNAL_INDEX], &(ft.dwHighDateTime), sizeof(ft.dwHighDateTime), 0, NULL)); CALL(JetUpdate(sesid, servdirtableid, NULL, 0, &cbActual)); } // Else if we were told to increment the failure count else if (FailureCount != NULL) { if (*FailureCount != 0) { DWORD FailureCountFromServDir; // Get the current failure count. CALL(JetRetrieveColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_NUMFAILPINGS_INTERNAL_INDEX], &FailureCountFromServDir, sizeof(FailureCountFromServDir), &cbActual, 0, NULL)); // Set return value, also value used for update. *FailureCount = FailureCountFromServDir + 1; CALL(JetPrepareUpdate(sesid, servdirtableid, JET_prepReplace)); // Set the column. CALL(JetSetColumn(sesid, servdirtableid, servdircolumnid[ SERVDIR_NUMFAILPINGS_INTERNAL_INDEX], FailureCount, sizeof(*FailureCount), 0, NULL)); CALL(JetUpdate(sesid, servdirtableid, NULL, 0, &cbActual)); } } CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } return (DWORD) E_FAIL; } DWORD TSSDRpcRepopulateAllSessions( handle_t Binding, HCLIENTINFO *hCI, DWORD NumSessions, TSSD_RepopInfo rpi[]) { JET_ERR err; JET_SESID sesid = JET_sesidNil; JET_DBID dbid; JET_TABLEID sessdirtableid; JET_TABLEID servdirtableid; JET_SETCOLUMN scSessDir[NUM_SESSDIRCOLUMNS]; CLIENTINFO *pCI = (CLIENTINFO *) hCI; unsigned count; // inside each record unsigned iCurrSession; unsigned long cbActual; char State; // "unreferenced" parameter (referenced by RPC) Binding; TSDISErrorOut(L"RepopAllSess: ServID = %d, NumSessions = %d, ...\n", *pCI, NumSessions); memset(&scSessDir[0], 0, sizeof(JET_SETCOLUMN) * NUM_SESSDIRCOLUMNS); CALL(JetBeginSession(g_instance, &sesid, "user", "")); 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(JetBeginTransaction(sesid)); // Verify that the ServerID passed in was OK. if (TSSDVerifyServerIDValid(sesid, servdirtableid, PtrToUlong(*hCI)) == FALSE) { TSDISErrorOut(L"Invalid ServerID was passed in\n"); goto HandleError; } // Set up some constants for all updates. for (count = 0; count < NUM_SESSDIRCOLUMNS; count++) { scSessDir[count].columnid = sesdircolumnid[count]; scSessDir[count].cbData = 4; // most of them, set the rest individually scSessDir[count].itagSequence = 1; } scSessDir[SESSDIR_STATE_INTERNAL_INDEX].cbData = sizeof(char); // Now do each update in a loop. for (iCurrSession = 0; iCurrSession < NumSessions; iCurrSession += 1) { err = JetMove(sesid, sessdirtableid, JET_MoveLast, 0); CALL(JetPrepareUpdate(sesid, sessdirtableid, JET_prepInsert)); scSessDir[SESSDIR_USERNAME_INTERNAL_INDEX].cbData = (unsigned) (wcslen(rpi[iCurrSession].UserName) + 1) * sizeof(WCHAR); scSessDir[SESSDIR_DOMAIN_INTERNAL_INDEX].cbData = (unsigned) (wcslen(rpi[iCurrSession].Domain) + 1) * sizeof(WCHAR); scSessDir[SESSDIR_APPTYPE_INTERNAL_INDEX].cbData = (unsigned) (wcslen(rpi[iCurrSession].AppType) + 1) * sizeof(WCHAR); scSessDir[SESSDIR_USERNAME_INTERNAL_INDEX].pvData = rpi[iCurrSession].UserName; scSessDir[SESSDIR_DOMAIN_INTERNAL_INDEX].pvData = rpi[iCurrSession].Domain; scSessDir[SESSDIR_SERVERID_INTERNAL_INDEX].pvData = pCI; scSessDir[SESSDIR_SESSIONID_INTERNAL_INDEX].pvData = &rpi[iCurrSession].SessionID; scSessDir[SESSDIR_TSPROTOCOL_INTERNAL_INDEX].pvData = &rpi[iCurrSession].TSProtocol; scSessDir[SESSDIR_CTLOW_INTERNAL_INDEX].pvData = &rpi[iCurrSession].CreateTimeLow; scSessDir[SESSDIR_CTHIGH_INTERNAL_INDEX].pvData = &rpi[iCurrSession].CreateTimeHigh; scSessDir[SESSDIR_DTLOW_INTERNAL_INDEX].pvData = &rpi[iCurrSession].DisconnectTimeLow; scSessDir[SESSDIR_DTHIGH_INTERNAL_INDEX].pvData = &rpi[iCurrSession].DisconnectTimeHigh; scSessDir[SESSDIR_APPTYPE_INTERNAL_INDEX].pvData = rpi[iCurrSession].AppType; scSessDir[SESSDIR_RESWIDTH_INTERNAL_INDEX].pvData = &rpi[iCurrSession].ResolutionWidth; scSessDir[SESSDIR_RESHEIGHT_INTERNAL_INDEX].pvData = &rpi[iCurrSession].ResolutionHeight; scSessDir[SESSDIR_COLORDEPTH_INTERNAL_INDEX].pvData = &rpi[iCurrSession].ColorDepth; State = (char) rpi[iCurrSession].State; scSessDir[SESSDIR_STATE_INTERNAL_INDEX].pvData = &State; CALL(JetSetColumns(sesid, sessdirtableid, scSessDir, NUM_SESSDIRCOLUMNS)); CALL(JetUpdate(sesid, sessdirtableid, NULL, 0, &cbActual)); } CALL(JetCommitTransaction(sesid, 0)); CALL(JetCloseTable(sesid, sessdirtableid)); CALL(JetCloseTable(sesid, servdirtableid)); CALL(JetCloseDatabase(sesid, dbid, 0)); CALL(JetEndSession(sesid, 0)); 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); } return (DWORD) E_FAIL; } // Called to determine whether a ServerID passed in is valid. TRUE if valid, // FALSE otherwise. // // Must be inside a transaction, and sesid and servdirtableid must be ready to // go. BOOL TSSDVerifyServerIDValid(JET_SESID sesid, JET_TABLEID servdirtableid, DWORD ServerID) { JET_ERR err; CALL(JetSetCurrentIndex(sesid, servdirtableid, "ServerIDIndex")); CALL(JetMakeKey(sesid, servdirtableid, (const void *) &ServerID, sizeof(DWORD), JET_bitNewKey)); // If the ServerID is there, this will succeed, otherwise it will fail and // jump to HandleError. CALL(JetSeek(sesid, servdirtableid, JET_bitSeekEQ)); return TRUE; HandleError: return FALSE; } // Rundown procedure for when a CLIENTINFO is destroyed as a result of a // connection loss or client termination. void HCLIENTINFO_rundown(HCLIENTINFO hCI) { CLIENTINFO CI = PtrToUlong(hCI); TSDISErrorOut(L"In HCLIENTINFO_rundown: ServerID=%d\n", CI); if (CI != NULL) TSSDPurgeServer(CI); hCI = NULL; } #pragma warning (pop)