able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/sessdir/dis/jetrpcfn.cpp

1686 lines
59 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/****************************************************************************/
// 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)
Reference in a new issue Copy permalink