able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/dcomss/objex/misc.cxx

1573 lines
43 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
Misc.cxx
Abstract:
Initalization, Heap, debug, thread manager for OR
Author:
Mario Goertzel [MarioGo]
Revision History:
MarioGo 02-11-95 Bits 'n pieces
--*/
#include <or.hxx>
#include <mach.hxx>
#include <excladdr.hxx>
#include <addrrefresh.hxx>
extern "C"
{
#define SECURITY_WIN32 // Used by security.h
#include <security.h>
}
BOOL fListened = FALSE;
BOOL gfRegisteredAuthInfo = FALSE;
extern BOOL gbDynamicIPChangesEnabled;
extern DWORD gdwTimeoutPeriodForStaleMids;
const UINT IP_MAXIMUM_RAW_NAME = 16; // xxx.xxx.xxx.xxx
const UINT IP_MAXIMUM_PRETTY_NAME = 256; // DNS limit
// Contains compressed remote protseqs and network addresses
// for this process, minus any addresses in the current
// exclusion list. This is a refcounted object
CDualStringArray* gpdsaMyBindings = 0;
// Contains all compressed remote protseqs and network addresses
// for this process. Not refcounted. We maintain this one
// to help when building a new gpdsaMyBindings above.
DUALSTRINGARRAY* gpdsaFullBindings = 0;
// Contains initial DNS name for TCP
WCHAR gwszInitialDNSName[IP_MAXIMUM_PRETTY_NAME];
// Authentication services successfully registered.
DWORD s_cRpcssSvc = 0;
SECPKG *s_aRpcssSvc = NULL;
// Unique ID used to track which global resolver bindings
// are currently in use. Note that this starts at one, and
// everybody else starts theirs at zero. Therefore any
// updates that originate from PushCurrentBindings should
// take precedence. This should be looked at\modified only
// when gpClientLock is taken, in sync with modifying
// gpdsaMyBindings. In addition, this should be incremented
// whenever gpdsaMyBindings is updated with new bindings.
DWORD64 g_dwResolverBindingsID = 1;
// Definitions used for asynchronous mid releases
const DWORD ASYNCMIDRELEASEARGS_SIG = 0xFEDCBA02;
typedef struct _ASYNCMIDRELEASEARGS
{
DWORD dwAMRASig; // see ASYNCMIDRELEASEARGS_SIG
HANDLE hTimer;
CMid* pMidToRelease;
} ASYNCMIDRELEASEARGS;
ORSTATUS
StartListeningIfNecessary()
/*++
Routine Description:
If the process has not successfully listened to remote
protocols this routine will try do to so.
Note:
Will not add ncacn_np to the list of supported Network OLE
protocols because RpcBindingServerFromClient() doesn't
work on named pipes and is required to unmarshal an in
interface pointer.
Arguments:
n/a
Return Value:
OR_OK - Success.
OR_NOMEM - Resource problems.
--*/
{
RPC_STATUS status;
PWSTR pwstr = gpwstrProtseqs;
USHORT id;
CIPAddrs* pIPAddrs = NULL;
BOOL bPushNewBindings = FALSE;
if (fListened == TRUE)
{
return(OR_OK);
}
gpClientLock->LockExclusive();
if (fListened == TRUE)
{
gpClientLock->UnlockExclusive();
return(OR_OK);
}
OrStringCopy(gwszInitialDNSName, L"");
if (pwstr)
{
while (*pwstr)
{
// skip leading white space
while ((*pwstr == L' ') || (*pwstr == L'\t'))
{
pwstr++;
}
if (*pwstr)
{
id = GetProtseqId(pwstr);
// ronans - DCOMHTTP
// we want to add http to the list of bindings even if listening does not
// succeed as this machine could still be a client of http without being a server
if (0 != id)
{
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Trying to listen to [%d]\n",
id));
if (id == ID_DCOMHTTP )
g_fClientHttp = TRUE;
status = UseProtseqIfNecessary(id);
if (status == RPC_S_OK)
{
if (id == ID_TCP)
{
gAddrRefreshMgr.ListenedOnTCP();
gAddrRefreshMgr.RegisterForAddressChanges();
// There may have been processes which connected before
// we were able to listen on tcp. To make sure they
// have the correct bindings, we must refresh them now.
bPushNewBindings = TRUE;
}
// if listening succeeded - no need to special case http as its in the normal
// list of protocols
if (id == ID_DCOMHTTP )
g_fClientHttp = FALSE;
fListened = TRUE;
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Listen succeeded on [%d]\n",
id));
}
else
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: Listen failed on [%d]\n",
id));
}
}
pwstr = OrStringSearch(pwstr, 0) + 1;
}
}
// Initialize machine name object now that winsock should be started
status = gpMachineName->Initialize();
if (status != 0)
{
gpClientLock->UnlockExclusive();
return status;
}
if ( FALSE == fListened
&& 0 != gLocalMid)
{
// Didn't manage to listen to anything new, no need to
// recompute all the global arrays.
gpClientLock->UnlockExclusive();
return(OR_OK);
}
// ??? limit to only those protseqs listed in the registry,
// if the another service used more protseqs they would show up here.
RPC_BINDING_VECTOR *pbv;
PWSTR pwstrT;
DUALSTRINGARRAY *pdsaT;
PWSTR *aAddresses;
USHORT *aProtseqs;
unsigned short psaLen;
DWORD i;
DWORD iProtseq;
status = RpcServerInqBindings(&pbv);
if (RPC_S_OK == status)
{
aAddresses = new PWSTR[pbv->Count];
aProtseqs = new USHORT[pbv->Count];
if ( !aAddresses
|| !aProtseqs)
{
RpcBindingVectorFree(&pbv);
delete aAddresses; // 0 or allocated.
delete aProtseqs; // 0 or allocated.
status = OR_NOMEM;
}
}
else
status = OR_NOMEM;
if (status != OR_OK)
{
gpClientLock->UnlockExclusive();
return(status);
}
// Build array of protseqs id's and addresses we're listening to.
pwstr = gpwstrProtseqs;
if (pwstr)
{
psaLen = 0;
iProtseq = 0;
// start with the list of allowed protocols
// listed in the registry. For each protocol, in order,
// check to see if there is an endpoint registered for it.
// NOTE: Do not change the order of these loops
// It is pertinent to correctly order the final
// string.
while (*pwstr)
{
id = GetProtseqId(pwstr);
if (0 != id)
{
for (i = 0; i < pbv->Count; i++)
{
PWSTR pwstrStringBinding;
status = RpcBindingToStringBinding(pbv->BindingH[i], &pwstrStringBinding);
if (status != RPC_S_OK)
{
break;
}
ASSERT(pwstrStringBinding);
status = RpcStringBindingParse(pwstrStringBinding,
0,
&pwstrT,
&aAddresses[iProtseq],
0,
0);
RPC_STATUS statusT = RpcStringFree(&pwstrStringBinding);
ASSERT(statusT == RPC_S_OK && pwstrStringBinding == 0);
if (status != RPC_S_OK)
{
break;
}
//
// if the protocol name matches we can use this one
//
if (lstrcmpW(pwstrT, pwstr) == 0)
{
aProtseqs[iProtseq] = id;
status = RpcStringFree(&pwstrT);
ASSERT(status == RPC_S_OK && pwstrT == 0);
// Disallow datagram protocols till they
// support SSL and snego.
if (!IsLocal(aProtseqs[iProtseq]) && aProtseqs[iProtseq] != ID_NP &&
aProtseqs[iProtseq] != ID_UDP && aProtseqs[iProtseq] != ID_IPX)
{
// Only hand out remote non-named pipes protseqs.
psaLen += 1 + OrStringLen(aAddresses[iProtseq]) + 1;
// Save the dns name RPC gave us; we will need this in future
// if the IP's change and we need to rebuild the bindings
if (aProtseqs[iProtseq] == ID_TCP)
{
OrStringCopy(gwszInitialDNSName, aAddresses[iProtseq]);
}
// compute length w/IP address(es)
if (aProtseqs[iProtseq] == ID_TCP || aProtseqs[iProtseq] == ID_UDP)
{
if (!pIPAddrs)
{
pIPAddrs = gpMachineName->GetIPAddrs();
}
if (pIPAddrs)
{
NetworkAddressVector* pNetworkAddrVector = pIPAddrs->_pIPAddresses;
ASSERT(pNetworkAddrVector);
for (ULONG j=0; j<pNetworkAddrVector->Count; j++)
{
// do not include the loopback address in resolver bindings.
if (lstrcmpW(L"127.0.0.1", pNetworkAddrVector->NetworkAddresses[j]) != 0)
{
psaLen += 1 + OrStringLen(pNetworkAddrVector->NetworkAddresses[j]) + 1;
}
}
}
}
}
iProtseq++;
break;
}
else
{
status = RpcStringFree(&pwstrT);
ASSERT(status == RPC_S_OK && pwstrT == 0);
status = RpcStringFree(&aAddresses[iProtseq]);
ASSERT(status == RPC_S_OK && pwstrT == 0);
}
}
if (status != RPC_S_OK)
{
break;
}
}
pwstr = OrStringSearch(pwstr, 0) + 1;
}
}
if (status != RPC_S_OK)
{
delete aAddresses;
delete aProtseqs;
RPC_STATUS status_tmp = RpcBindingVectorFree(&pbv);
ASSERT(pbv == 0 && status_tmp == RPC_S_OK);
gpClientLock->UnlockExclusive();
if (pIPAddrs)
pIPAddrs->DecRefCount();
return(status);
}
// string bindings final null, authn and authz service list and
// one final nulls
if (psaLen == 0)
{
// No remote bindings, leave space for an extra NULL.
psaLen = 1;
}
if (s_cRpcssSvc == 0)
{
// No authentication services, leave space for an extra NULL.
psaLen += 1;
}
psaLen += (unsigned short)(1 + 3*s_cRpcssSvc + 1);
pdsaT = new(psaLen * sizeof(WCHAR)) DUALSTRINGARRAY;
if (!pdsaT)
{
delete aAddresses;
delete aProtseqs;
status = RpcBindingVectorFree(&pbv);
ASSERT(pbv == 0 && status == RPC_S_OK);
gpClientLock->UnlockExclusive();
if (pIPAddrs)
pIPAddrs->DecRefCount();
return OR_NOMEM;
}
pdsaT->wNumEntries = psaLen;
if (s_cRpcssSvc == 0)
pdsaT->wSecurityOffset = psaLen - 2;
else
pdsaT->wSecurityOffset = (unsigned short)(psaLen - 3*s_cRpcssSvc - 1);
pwstrT = pdsaT->aStringArray;
for (i = 0; i < iProtseq; i++)
{
// Disallow datagram protocols till they
// support SSL and snego.
if (!IsLocal(aProtseqs[i]) && aProtseqs[i] != ID_NP &&
aProtseqs[i] != ID_UDP && aProtseqs[i] != ID_IPX)
{
*pwstrT = aProtseqs[i];
pwstrT++;
OrStringCopy(pwstrT, aAddresses[i]);
pwstrT = OrStringSearch(pwstrT, 0) + 1; // next
// add the IP address(es)
if (aProtseqs[i] == ID_TCP || aProtseqs[i] == ID_UDP)
{
if (!pIPAddrs)
{
pIPAddrs = gpMachineName->GetIPAddrs();
}
if (pIPAddrs)
{
NetworkAddressVector* pNetworkAddrVector = pIPAddrs->_pIPAddresses;
ASSERT(pNetworkAddrVector);
for (ULONG j=0; j<pNetworkAddrVector->Count; j++)
{
// do not include the loopback address in resolver bindings.
if (lstrcmpW(L"127.0.0.1", pNetworkAddrVector->NetworkAddresses[j]) != 0)
{
*pwstrT = aProtseqs[i];
pwstrT++;
OrStringCopy(pwstrT, pNetworkAddrVector->NetworkAddresses[j]);
pwstrT = OrStringSearch(pwstrT, 0) + 1; // next
}
}
}
}
}
status = RpcStringFree(&aAddresses[i]);
ASSERT(status == RPC_S_OK);
}
if (pdsaT->wSecurityOffset == 2)
{
// No remote bindings, put in first null.
pdsaT->aStringArray[0] = 0;
pwstrT++;
}
// Zero final terminator
*pwstrT = 0;
pwstrT++;
// Security authn services
for (i = 0; i < s_cRpcssSvc; i++)
{
// Authn service, Authz service (-1 means none), NULL principal name
*pwstrT = s_aRpcssSvc[i].wId;
pwstrT++;
*pwstrT = -1;
pwstrT++;
*pwstrT = 0;
pwstrT++;
}
// If there are no authentication services, put in an extra NULL.
if (s_cRpcssSvc == 0)
{
*pwstrT = 0;
pwstrT++;
}
// Final NULL
*pwstrT = 0;
ASSERT(dsaValid(pdsaT));
USHORT cRemoteProtseqs = 0;
// Convert aProtseqs into remote only array of protseqs and count them.
for (i = 0; i < iProtseq; i++)
{
// Disallow datagram protocols till they
// support SSL and snego.
if (!IsLocal(aProtseqs[i]) && aProtseqs[i] != ID_NP &&
aProtseqs[i] != ID_UDP && aProtseqs[i] != ID_IPX)
{
aProtseqs[cRemoteProtseqs] = aProtseqs[i];
cRemoteProtseqs++;
}
}
delete aAddresses;
status = RpcBindingVectorFree(&pbv);
ASSERT(pbv == 0 && status == RPC_S_OK);
if (pIPAddrs) pIPAddrs->DecRefCount();
pIPAddrs = NULL;
gAddrExclusionMgr.InitializeFromRegistry();
// Obtain bindings filtered by exclusion list
HRESULT hr;
DUALSTRINGARRAY* pdsaFiltered;
hr = gAddrExclusionMgr.BuildExclusionDSA(pdsaT, &pdsaFiltered);
if (FAILED(hr))
{
delete pdsaT;
gpClientLock->UnlockExclusive();
return (OR_NOMEM);
}
// The mid object makes a copy of pdsaFiltered, it doesn't own it
CMid *pMid = new(pdsaFiltered->wNumEntries * sizeof(WCHAR)) CMid(pdsaFiltered, TRUE, gLocalMid);
if (pMid)
{
CDualStringArray* pdsaWrapper = new CDualStringArray(pdsaFiltered);
if (pdsaWrapper)
{
if (gpdsaFullBindings) delete gpdsaFullBindings;
gpdsaFullBindings = pdsaT; // the full bindings
ASSERT(gpClientLock->HeldExclusive());
gpMidTable->Add(pMid);
aMyProtseqs = aProtseqs;
cMyProtseqs = cRemoteProtseqs;
if (gpdsaMyBindings) gpdsaMyBindings->Release();
gpdsaMyBindings = pdsaWrapper; // the filtered bindings
gLocalMid = pMid->Id();
// Increment id counter
g_dwResolverBindingsID++;
// Release the lock now, so we don't hold it across PushCurrentBindings.
gpClientLock->UnlockExclusive();
// Push new bindings if so called for. Not fatal if this fails
if (bPushNewBindings)
{
PushCurrentBindings();
}
return OR_OK;
}
}
// Failed to get memory
if (pMid) delete pMid;
delete pdsaT;
MIDL_user_free(pdsaFiltered);
delete aProtseqs;
gpClientLock->UnlockExclusive();
return(OR_NOMEM);
}
BOOL IsHttpClient()
/*++
Routine Description:
Returns the global client http flag while holding a lock
Return Value:
None
--*/
{
BOOL retval;
gpClientLock->LockExclusive();
retval = g_fClientHttp;
gpClientLock->UnlockExclusive();
return retval;
}
void CALLBACK
AsyncMidReleaseTimerCallback(void* pvParam, BOOLEAN TimerOrWaitFired)
/*++
Routine Description:
Releases the mid object that was queued to a timer in
DoAsyncMidRelease below.
Return Value:
None
--*/
{
BOOL fResult;
ASYNCMIDRELEASEARGS* pArgs;
ASSERT(TimerOrWaitFired);
pArgs = (ASYNCMIDRELEASEARGS*)pvParam;
ASSERT(pArgs);
ASSERT(pArgs->dwAMRASig == ASYNCMIDRELEASEARGS_SIG);
ASSERT(pArgs->hTimer);
ASSERT(pArgs->pMidToRelease);
gpClientLock->LockExclusive();
pArgs->pMidToRelease->Release();
gpClientLock->UnlockExclusive();
// Make a non-blocking call to delete the timer.
fResult = DeleteTimerQueueTimer(NULL,
pArgs->hTimer,
NULL);
ASSERT(fResult);
// Finally, delete the argument structure
delete pArgs;
return;
}
void
DoAsyncMidRelease(CMid* pMid, DWORD dwReleaseInMSec)
/*++
Routine Description:
Creates a timer callback that will call ->Release on the
supplied mid object in the specified amount of time. If
the timer creation fails, does an immediate release.
Return Value:
None
--*/
{
BOOL bResult;
HANDLE hNewTimer;
ASYNCMIDRELEASEARGS* pArgs;
ASSERT(pMid);
ASSERT(gpClientLock->HeldExclusive());
pArgs = new ASYNCMIDRELEASEARGS;
if (!pArgs)
{
// Nothing we can do -- mid will be released synchronously
// when this occurs.
return;
}
// Initialize the struct
pArgs->dwAMRASig = ASYNCMIDRELEASEARGS_SIG;
pArgs->hTimer = NULL;
pArgs->pMidToRelease = pMid;
pMid->Reference();
bResult = CreateTimerQueueTimer(&(pArgs->hTimer),
NULL,
AsyncMidReleaseTimerCallback,
pArgs,
dwReleaseInMSec,
0,
WT_EXECUTEINTIMERTHREAD);
if (!bResult)
{
// Timer failed; release struct and mid object immediately to
// avoid leaking them. Like above, mid is released sync.
pMid->Release();
delete pArgs;
}
return;
}
RPC_STATUS
ComputeNewResolverBindings(void)
/*++
Routine Description:
Creates the local OR bindings using the current IP addresses, and
places the results in gpdsaFullBindings. gpdsaFullBindings is then
passed to the address exclusion mgr object, who creates a "filtered"
set of bindings, which omits any currently excluded addresses; these
bindings are saved in gpdsaMyBindings.
Caller must be holding gpClientLock.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
--*/
{
BOOL fDoneTCP = FALSE;
BOOL fDoneUDP = FALSE;
DWORD i;
CIPAddrs* pIPAddrs;
DWORD dwNumAddrs;
ASSERT(gpdsaMyBindings);
ASSERT(gpClientLock->HeldExclusive());
pIPAddrs = gpMachineName->GetIPAddrs();
dwNumAddrs = pIPAddrs ? pIPAddrs->_pIPAddresses->Count : 0;
// compute size of new dsa (for each IP address, leave space
// for max IP name size * 2 (one for TCP/IP and one for UDP).
DWORD psaLen = (dwNumAddrs * IP_MAXIMUM_RAW_NAME * sizeof(RPC_CHAR) * 2);
psaLen += sizeof(DUALSTRINGARRAY) + (gpdsaMyBindings->DSA()->wNumEntries * sizeof(USHORT));
DWORD dwDNSLen = OrStringLen(gwszInitialDNSName);
if (dwDNSLen > 0)
{
psaLen += dwDNSLen + 2;
}
// Allocate space for the new bindings
DUALSTRINGARRAY *pdsaT = new(psaLen) DUALSTRINGARRAY;
if (pdsaT == NULL)
{
if (pIPAddrs) pIPAddrs->DecRefCount();
return RPC_S_OUT_OF_RESOURCES;
}
PWSTR pwstrT = pdsaT->aStringArray;
PWSTR pwstrSrc = gpdsaFullBindings->aStringArray;
// copy in the information. For TCP/IP and UDP, we copy in the
// new IP addresses. For all others, we leave as is.
psaLen = 0;
while (*pwstrSrc)
{
USHORT id = *pwstrSrc; // current tower id
pwstrSrc++;
if (id == NCACN_IP_TCP)
{
if (!fDoneTCP)
{
// copy in the DNS name, if any, obtained initially from RPC
// in StartListeningIfNecessary
if (dwDNSLen > 0)
{
*pwstrT = id;
pwstrT++;
OrStringCopy(pwstrT, gwszInitialDNSName);
pwstrT += dwDNSLen + 1;
psaLen += dwDNSLen + 2;
}
// copy in the new IP addresses
fDoneTCP = TRUE;
for (UINT i=0; i<dwNumAddrs; i++)
{
*pwstrT = id; // copy in the tower id
pwstrT++;
OrStringCopy(pwstrT, pIPAddrs->_pIPAddresses->NetworkAddresses[i]);
int len = OrStringLen(pIPAddrs->_pIPAddresses->NetworkAddresses[i]) + 1;
pwstrT += len;
psaLen += len + 1;
}
}
}
else if (id == NCADG_IP_UDP)
{
if (!fDoneUDP)
{
// copy in the new IP addresses
fDoneUDP = TRUE;
for (UINT i=0; i<dwNumAddrs; i++)
{
*pwstrT = id; // copy in the tower id
pwstrT++;
OrStringCopy(pwstrT, pIPAddrs->_pIPAddresses->NetworkAddresses[i]);
int len = OrStringLen(pIPAddrs->_pIPAddresses->NetworkAddresses[i]) + 1;
pwstrT += len;
psaLen += len + 1;
}
}
}
else
{
// just copy the existing entry unchanged.
*pwstrT = id; // copy in the tower id
pwstrT++;
OrStringCopy(pwstrT, pwstrSrc);
int len = OrStringLen(pwstrSrc) + 1;
pwstrT += len;
psaLen += len + 1;
}
// skip to the next towerid entry
pwstrSrc += OrStringLen(pwstrSrc) + 1;
}
// Zero final terminator
if (psaLen == 0)
{
*((DWORD*) pwstrT) = 0;
pwstrT += 2;
psaLen += 2;
}
else
{
*pwstrT = 0;
pwstrT++;
psaLen += 1;
}
// Security authn services
pdsaT->wSecurityOffset = (unsigned short) psaLen;
for (i = 0; i < s_cRpcssSvc; i++)
{
// Authn service, Authz service (-1 means none), NULL principal name
*pwstrT = s_aRpcssSvc[i].wId;
pwstrT++;
*pwstrT = -1;
pwstrT++;
*pwstrT = 0;
pwstrT++;
}
// If there are no authentication services, put in an extra NULL.
if (s_cRpcssSvc == 0)
{
*pwstrT = 0;
pwstrT++;
psaLen += 1;
}
// Final NULL
psaLen += 3*s_cRpcssSvc + 1;
*pwstrT = 0;
// update the size
pdsaT->wNumEntries = (unsigned short) psaLen;
ASSERT(dsaValid(pdsaT));
// Done with ipaddrs
if (pIPAddrs) pIPAddrs->DecRefCount();
pIPAddrs = NULL;
// Always replace the current "full" bindings, so they
// are always up-to-date.
delete gpdsaFullBindings;
gpdsaFullBindings = pdsaT;
pdsaT = NULL;
HRESULT hr;
DUALSTRINGARRAY* pdsaFiltered;
hr = gAddrExclusionMgr.BuildExclusionDSA(gpdsaFullBindings, &pdsaFiltered);
if (FAILED(hr))
return RPC_S_OUT_OF_RESOURCES;
if (dsaCompare(gpdsaMyBindings->DSA(), pdsaFiltered))
{
// the old and new local resolver strings are the same
// so don't change anything, just throw away the new one.
MIDL_user_free(pdsaFiltered);
return RPC_S_OK;
}
// The two are different. First, let's see if an old mid entry
// for the new bindings is still in the table.
CMid* pNewLocalMid = NULL;
CMid* pOldMatchingLocalMid = NULL;
pOldMatchingLocalMid = (CMid*)gpMidTable->Lookup(CMidKey(pdsaFiltered));
if (pOldMatchingLocalMid)
{
// Returned mid should be both local and stale
ASSERT(pOldMatchingLocalMid->IsLocal());
ASSERT(pOldMatchingLocalMid->IsStale());
}
else
{
// Not in the table already, create a new mid
// The mid object makes a copy of pdsaFiltered, it doesn't own it
pNewLocalMid = new(pdsaFiltered->wNumEntries * sizeof(WCHAR))
CMid(pdsaFiltered, TRUE, gLocalMid);
if (!pNewLocalMid)
{
MIDL_user_free(pdsaFiltered);
return RPC_S_OUT_OF_RESOURCES;
}
}
// Always need to construct a new gpdsaMyBindings
CDualStringArray* pdsaWrapper = new CDualStringArray(pdsaFiltered);
if (pdsaWrapper)
{
ASSERT(gpClientLock->HeldExclusive());
if (pOldMatchingLocalMid)
{
// Mark the mid that's already in the table
// as no longer stale, and reference it so it
// stays in the table.
pOldMatchingLocalMid->Reference();
pOldMatchingLocalMid->MarkStale(FALSE);
}
else
{
// Add new local mid to the table; it's "not stale" by default
ASSERT(pNewLocalMid);
gpMidTable->Add(pNewLocalMid);
}
// Mark the current mid as stale
CMid* pCurrentMid = (CMid*)gpMidTable->Lookup(CMidKey(gpdsaMyBindings->DSA()));
ASSERT(pCurrentMid);
pCurrentMid->MarkStale(TRUE);
// The old local mid object would normally be guaranteed to remain in the table
// for as long as gpClientLock is held. It is possible that an activation in-flight
// concurrent with this thread may try to look up the old local mid shortly
// after this code finishes, and if not found the oxid resolution will proceed
// as if the mid was a remote machine, not local. This leads to major problems.
// To get around this somewhat fuzzy window, we addref the old mid (thus keeping
// it in the table), and ask for a timer callback at a later time when we will
// be virtually guaranteed that all such in-flight local activations referencing
// the old mid will have completed.
DoAsyncMidRelease(pCurrentMid, gdwTimeoutPeriodForStaleMids);
// DoAsyncMidRelease takes a reference to be released later; still need
// to release it here.
pCurrentMid->Release();
// Release old bindings
gpdsaMyBindings->Release();
// Remember new ones
gpdsaMyBindings = pdsaWrapper;
// Increment id counter
g_dwResolverBindingsID++;
return RPC_S_OK;
}
// No mem
if (pNewLocalMid) delete pNewLocalMid;
MIDL_user_free(pdsaFiltered);
return RPC_S_OUT_OF_RESOURCES;
}
RPC_STATUS
CopyMyOrBindings(DUALSTRINGARRAY **ppdsaOrBindings, DWORD64* pdwBindingsID)
/*++
Routine Description:
Copies the current OR bindings to return to the
caller.
Parameters:
ppdsaOrBindings -- where to put the bindings when done
pdwBindingsID -- if successful, contains the binding id of the
returned bindings. Can be NULL if the client
does not care.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
--*/
{
HRESULT hr;
RPC_STATUS status = RPC_S_OK;
CDualStringArray* pdsaBindings;
DWORD64 dwBindingsID;
SCMVDATEHEAP();
// Take lock only long enough to take a reference on
// the current bindings
gpClientLock->LockExclusive();
pdsaBindings = gpdsaMyBindings;
if (pdsaBindings)
pdsaBindings->AddRef();
// Save id now while we're under the lock
dwBindingsID = g_dwResolverBindingsID;
// We call this here in case we failed to register for
// address change notifications. If it previously succeeded,
// then this call is a no-op, otherwise it might succeed
// this time around.
gAddrRefreshMgr.RegisterForAddressChanges();
gpClientLock->UnlockExclusive();
ASSERT(pdsaBindings);
if (!pdsaBindings)
return RPC_S_OUT_OF_RESOURCES;
hr = dsaAllocateAndCopy(ppdsaOrBindings, pdsaBindings->DSA());
if (SUCCEEDED(hr) && pdwBindingsID)
{
*pdwBindingsID = dwBindingsID;
}
pdsaBindings->Release();
SCMVDATEHEAP();
return ((hr == S_OK) ? RPC_S_OK : RPC_S_OUT_OF_RESOURCES);
}
/*
// Debugging hack: for when you only want to debug the bindings
// update stuff with one process instead of every process
// on the box.
DWORD GetUpdateablePID()
{
HKEY hOle;
DWORD error;
DWORD dwValue = -1;
DWORD dwType;
DWORD dwBufSize = sizeof(DWORD);
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\OLE",
NULL,
KEY_READ,
&hOle);
if (error == ERROR_SUCCESS)
{
error = RegQueryValueEx(
hOle,
L"UpdateablePID",
0,
&dwType,
(BYTE*)&dwValue,
&dwBufSize);
RegCloseKey(hOle);
}
return dwValue;
}
*/
void
GetCurrentBindingsAndID(DWORD64* pdwBindingsID, CDualStringArray** ppDSABindings)
/*++
Routine Description:
Returns to the caller the current bindings and their id. *ppDSABindings
will have a refcount added.
Return Value:
void
--*/
{
ASSERT(!gpClientLock->HeldExclusive());
ASSERT(pdwBindingsID && ppDSABindings);
// Take reference on gpClientLock long enough to grab a
// reference on the current bindins
gpClientLock->LockExclusive();
ASSERT(gpdsaMyBindings);
*ppDSABindings = gpdsaMyBindings;
(*ppDSABindings)->AddRef();
*pdwBindingsID = g_dwResolverBindingsID;
gpClientLock->UnlockExclusive();
return;
}
void
PushCurrentBindings()
/*++
Routine Description:
Propagates the current resolver bindings to all currently
running processes.
Return Value:
void
--*/
{
ORSTATUS status;
DWORD64 dwBindingsID;
CDualStringArray* pDSABindings = NULL;
ASSERT(!gpClientLock->HeldExclusive());
// If not enabled, don't do it
if (!gbDynamicIPChangesEnabled)
return;
GetCurrentBindingsAndID(&dwBindingsID, &pDSABindings);
ASSERT(pDSABindings);
// Take a shared lock on the process list, and copy all of
// the contained processes to a separate list, with an
// extra refcount added. Then we release the lock, and
// push the new bindings to each process. New processes
// that connect after we leave the lock will automatically
// get the newest bindings.
gpProcessListLock->LockShared();
// Allocate space on the stack to remember each process in
// the list.
DWORD i = 0;
DWORD dwTotalProcesses = gpProcessList->Size();
// Check for nothing to do. This can occur early during boot.
if (dwTotalProcesses == 0)
{
gpProcessListLock->UnlockShared();
pDSABindings->Release();
return;
}
CProcess* pprocess;
CProcess** ppProcessList =
(CProcess**)_alloca(sizeof(CProcess*) * dwTotalProcesses);
// Copy contents of current list
CBListIterator all_procs(gpProcessList);
while (pprocess = (CProcess*)all_procs.Next())
{
ppProcessList[i++] = pprocess;
pprocess->Reference();
}
ASSERT(i == dwTotalProcesses);
gpProcessListLock->UnlockShared();
// Now that we're outside the lock, update each process with
// the new bindings. Note that even if another refresh
// beats us, the process object tracks the binding id's, so
// the right thing will happen.
for (i = 0; i < dwTotalProcesses; i++)
{
status = ppProcessList[i]->UpdateResolverBindings(dwBindingsID, pDSABindings->DSA());
if (status != OR_OK)
{
// For use with the debugging hack above
// if (pprocess->GetPID() != GetUpdateablePID())
// continue;
// Right now I'm considering this a best-case effort; it
// can expectedly fail in some circumstances; eg, a process
// initializes COM, does work, then uninit's COM and stops
// listening on the ole32<->rpcss interfaces.
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR: failed to update dynamic resolver "
"bindings for process pid=%d\n",
ppProcessList[i]->GetPID()));
}
}
// Release references on process objects
gpServerLock->LockExclusive();
for (i = 0; i < dwTotalProcesses; i++)
{
ppProcessList[i]->Release();
}
gpServerLock->UnlockExclusive();
pDSABindings->Release();
return;
}
void
RegisterAuthInfoIfNecessary()
/*++
Routine Description:
Initializes all COM authentication services. The list is computed in
ComputeSecurity. Ignore failures. On normal boots the authentication
services register without error on the first call. During setup the
authentication services never register but the machine receives no
remote secure activation requests.
Return Value:
none
--*/
{
DWORD Status;
SECPKG *pSvcList;
DWORD i;
DWORD j = 0;
DWORD k;
DWORD cClientSvcs;
SECPKG* aClientSvcs;
DWORD cServerSvcs;
USHORT* aServerSvcs;
// Doesn't matter if we call RegisterAuthInfo more than once by chance.
if (gfRegisteredAuthInfo)
return;
// Retrieve client\server services
if (!GetClientServerSvcs(&cClientSvcs, &aClientSvcs, &cServerSvcs, &aServerSvcs))
return;
if (cServerSvcs == 0)
{
CleanupClientServerSvcs(cClientSvcs, aClientSvcs, cServerSvcs, aServerSvcs);
return;
}
// Allocate an array to hold the list of authentication services that
// were successfully registered.
pSvcList = new SECPKG[cServerSvcs];
if (pSvcList == NULL)
{
CleanupClientServerSvcs(cClientSvcs, aClientSvcs, cServerSvcs, aServerSvcs);
return;
}
ZeroMemory(pSvcList, sizeof(SECPKG) * cServerSvcs);
// Loop over the list of authentication services to register.
for (i = 0; i < cServerSvcs; i++)
{
Status = RpcServerRegisterAuthInfo( NULL, aServerSvcs[i], NULL, NULL );
if (Status == RPC_S_OK)
{
pSvcList[j].wId = aServerSvcs[i];
pSvcList[j].pName = NULL;
for (k= 0; k < cClientSvcs; k++)
{
if (aClientSvcs[k].wId == aServerSvcs[i])
{
if (aClientSvcs[k].pName)
{
DWORD dwLen = lstrlen(aClientSvcs[k].pName) + 1;
pSvcList[j].pName = new WCHAR[dwLen];
if (!pSvcList[j].pName)
{
// No mem; cleanup previously-allocated stuff and return
for (i = 0; i < cServerSvcs; i++)
{
if (pSvcList[i].pName)
{
delete pSvcList[i].pName;
}
}
delete pSvcList;
CleanupClientServerSvcs(cClientSvcs, aClientSvcs, cServerSvcs, aServerSvcs);
return;
}
lstrcpy(pSvcList[j].pName, aClientSvcs[k].pName);
}
break;
}
}
ASSERT( pSvcList[j].pName != NULL );
j++;
}
}
CleanupClientServerSvcs(cClientSvcs, aClientSvcs, cServerSvcs, aServerSvcs);
cClientSvcs = 0;
aClientSvcs = NULL;
cServerSvcs = 0;
aServerSvcs = NULL;
// If no authentication services were registered.
if (j == 0)
return;
// Save the new service list if no other thread has.
gpClientLock->LockExclusive();
if (!gfRegisteredAuthInfo)
{
gfRegisteredAuthInfo = TRUE;
s_cRpcssSvc = j;
s_aRpcssSvc = pSvcList;
pSvcList = NULL;
}
gpClientLock->UnlockExclusive();
// Free the service list if not saved in a global.
if (pSvcList)
{
for (i = 0; i < cServerSvcs; i++)
{
if (pSvcList[i].pName)
{
delete pSvcList[i].pName;
}
}
delete pSvcList;
}
return;
}
void *ComputeSvcList( const DUALSTRINGARRAY *pBinding )
/*++
Routine Description:
Allocates and returns an initialized auth identity structure that
contains a list of authentication services for snego.
--*/
{
SEC_WINNT_AUTH_IDENTITY_EXW *pAuthId;
DWORD cbAuthId;
DWORD i;
WCHAR *pEnd;
// Compute the size of the authentication service name strings.
cbAuthId = sizeof(*pAuthId);
for (i = 0; i < s_cRpcssSvc; i++)
if (s_aRpcssSvc[i].wId != RPC_C_AUTHN_GSS_NEGOTIATE &&
(pBinding == NULL ||
ValidAuthnSvc( pBinding, s_aRpcssSvc[i].wId )))
cbAuthId += (lstrlenW( s_aRpcssSvc[i].pName ) + 1)*
sizeof(WCHAR);
// Allocate the authentication identity structure.
pAuthId = (SEC_WINNT_AUTH_IDENTITY_EXW *)PrivMemAlloc(cbAuthId);
if (pAuthId == NULL)
return NULL;
// Initialize it.
pEnd = (WCHAR *) (pAuthId+1);
pAuthId->Version = SEC_WINNT_AUTH_IDENTITY_VERSION;
pAuthId->Length = sizeof(*pAuthId);
pAuthId->User = NULL;
pAuthId->UserLength = 0;
pAuthId->Domain = NULL;
pAuthId->DomainLength = 0;
pAuthId->Password = NULL;
pAuthId->PasswordLength = 0;
pAuthId->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
pAuthId->PackageList = pEnd;
pAuthId->PackageListLength = (cbAuthId - sizeof(*pAuthId)) /
sizeof(WCHAR);
// Copy in the authentication service name strings.
for (i = 0; i < s_cRpcssSvc; i++)
if (s_aRpcssSvc[i].wId != RPC_C_AUTHN_GSS_NEGOTIATE &&
(pBinding == NULL ||
ValidAuthnSvc( pBinding, s_aRpcssSvc[i].wId )))
{
lstrcpyW( pEnd, s_aRpcssSvc[i].pName );
pEnd += lstrlenW( pEnd );
pEnd[0] = L',';
pEnd += 1;
}
pEnd -= 1;
pEnd[0] = 0;
return pAuthId;
}
/*++
Routine Description:
Return TRUE if the specified authentication service is in the
dual string array.
--*/
BOOL ValidAuthnSvc( const DUALSTRINGARRAY *pBinding, WORD wService )
{
const WCHAR *pwstrT = &pBinding->aStringArray[pBinding->wSecurityOffset];
while (*pwstrT)
{
if (*pwstrT == wService)
{
return TRUE;
}
pwstrT = OrStringSearch((PWSTR) pwstrT, 0) + 1;
}
return FALSE;
}
//
// Local ID allocation
//
ID
AllocateId(
IN LONG cRange
)
/*++
Routine Description:
Allocates a unique local ID.
This id is 64bits. The low 32 bits are a sequence number which
is incremented with each call. The high 32bits are seconds
since 1980. The ID of 0 is not used.
Limitations:
No more then 2^32 IDs can be generated in a given second without a duplicate.
When the time stamp overflows, once every >126 years, the sequence numbers
are likely to be generated in such a way as to collide with those from 126
years ago.
There is no prevision in the code to deal with overflow or duplications.
Arguments:
cRange - Number to allocate in sequence, default is 1.
Return Value:
A 64bit id.
--*/
{
static LONG sequence = 1;
FILETIME ft;
LARGE_INTEGER id;
DWORD seconds;
BOOL fSuccess;
ASSERT(cRange > 0 && cRange < 11);
GetSystemTimeAsFileTime(&ft);
fSuccess = RtlTimeToSecondsSince1980((PLARGE_INTEGER)&ft,
&seconds);
ASSERT(fSuccess); // Only fails when time is <1980 or >2115
do
{
id.HighPart = seconds;
id.LowPart = InterlockedExchangeAdd(&sequence, cRange);
}
while (id.QuadPart == 0 );
return(id.QuadPart);
}
//
// Debug helper(s)
//
#if DBG
int __cdecl __RPC_FAR ValidateError(
IN ORSTATUS Status,
IN ...)
/*++
Routine Description
Tests that 'Status' is one of an expected set of error codes.
Used on debug builds as part of the VALIDATE() macro.
Example:
VALIDATE( (Status,
OR_BADSET,
// more error codes here
OR_OK,
0) // list must be terminated with 0
);
This function is called with the OrStatus and expected errors codes
as parameters. If OrStatus is not one of the expected error
codes and it not zero a message will be printed to the debugger
and the function will return false. The VALIDATE macro ASSERT's the
return value.
Arguments:
Status - Status code in question.
... - One or more expected status codes. Terminated with 0 (OR_OK).
Return Value:
TRUE - Status code is in the list or the status is 0.
FALSE - Status code is not in the list.
--*/
{
RPC_STATUS CurrentStatus;
va_list Marker;
if (Status == 0) return(TRUE);
va_start(Marker, Status);
while (CurrentStatus = va_arg(Marker, RPC_STATUS))
{
if (CurrentStatus == Status)
{
return(TRUE);
}
}
va_end(Marker);
KdPrintEx((DPFLTR_DCOMSS_ID,
DPFLTR_WARNING_LEVEL,
"OR Assertion: unexpected failure %lu\n",
(unsigned long)Status));
return(FALSE);
}
#endif
Reference in a new issue Copy permalink