//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: scmif.cxx
//
// Contents: Entry points for scm interface.
//
// Functions: StartObjectService
// SvcActivateObject
// SvcCreateActivateObject
// ObjectServerStarted
// StopServer
//
// History: 01-May-93 Ricksa Created
// 31-Dec-93 ErikGav Chicago port
//
//--------------------------------------------------------------------------
#include <headers.cxx>
#pragma hdrstop
#include <scm.h>
#include "rawdscm.h"
#include "scm.hxx"
#include "port.hxx"
#include "cls.hxx"
#include <caller.hxx>
#include "dbgprt.hxx"
#include "rotif.hxx"
#include "clckpath.hxx"
#include <valid.h>
#include "or.hxx"
#ifndef _CHICAGO_
#include <shrtbl.hxx>
extern CScmShrdTbl *g_pScmShrdTbl;
#endif
//+-------------------------------------------------------------------------
//
// Function: Dummy1
//
// Synopsis: Needed for IDL hack. Never called.
//
// Arguments: [hRpc] - RPC handle
// [orpcthis] - ORPC handle
// [localthis] - ORPC call data
// [orpcthat] - ORPC reply data
//
// Returns: HRESULT
//
// History: 14 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT DummyQueryInterfaceIOSCM(
handle_t hRpc,
ORPCTHIS *orpcthis,
LOCALTHIS *localthis,
ORPCTHAT *orpcthat,
DWORD dummy )
{
CairoleDebugOut((DEB_ERROR, "SCM Dummy function should never be called!\n" ));
orpcthat->flags = 0;
orpcthat->extensions = NULL;
return E_FAIL;
}
//+-------------------------------------------------------------------------
//
// Function: Dummy2
//
// Synopsis: Needed for IDL hack. Never called.
//
// Arguments: [hRpc] - RPC handle
// [orpcthis] - ORPC handle
// [localthis] - ORPC call data
// [orpcthat] - ORPC reply data
//
// Returns: HRESULT
//
// History: 14 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT DummyAddRefIOSCM(
handle_t hRpc,
ORPCTHIS *orpcthis,
LOCALTHIS *localthis,
ORPCTHAT *orpcthat,
DWORD dummy )
{
CairoleDebugOut((DEB_ERROR, "SCM Dummy function should never be called!\n" ));
orpcthat->flags = 0;
orpcthat->extensions = NULL;
return E_FAIL;
}
//+-------------------------------------------------------------------------
//
// Function: Dummy3
//
// Synopsis: Needed for IDL hack. Never called.
//
// Arguments: [hRpc] - RPC handle
// [orpcthis] - ORPC handle
// [localthis] - ORPC call data
// [orpcthat] - ORPC reply data
//
// Returns: HRESULT
//
// History: 14 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT DummyReleaseIOSCM(
handle_t hRpc,
ORPCTHIS *orpcthis,
LOCALTHIS *localthis,
ORPCTHAT *orpcthat,
DWORD dummy )
{
CairoleDebugOut((DEB_ERROR, "SCM Dummy function should never be called!\n" ));
orpcthat->flags = 0;
orpcthat->extensions = NULL;
return E_FAIL;
}
//+-------------------------------------------------------------------------
//
// Function: ServerRegisterClsid
//
// Synopsis: Notifies SCM that server is started for a class
//
// Arguments: [hRpc] - RPC handle
// [phProcess] - context handle
// [lpDeskTop] - caller's desktop
// [pregin] - array of registration entries
// [ppregout] - array of registration cookies to return
// [rpcstat] - status code
//
// Returns: HRESULT
//
// History: 01-May-93 Ricksa Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT ServerRegisterClsid(
handle_t hRpc,
PHPROCESS phProcess,
WCHAR * pwszWinstaDesktop,
RegInput *pregin,
RegOutput **ppregout,
error_status_t *rpcstat)
{
CheckLocalCall( hRpc );
*rpcstat = 0;
HRESULT hr = S_OK;
#if DBG == 1
CairoleDebugOut((DEB_SCM, "_IN ObjectServerStarted\n"));
#if defined(_NT1X_) && !defined(_CHICAGO_)
CairoleDebugOut((DEB_SCM, "_IN Desk Top: %s\n", pwszWinstaDesktop));
#endif // _NT1X_ && !_CHICAGO_
DbgPrintRegIn("_IN Classes To Register", pregin);
#endif // DBG == 1
VDATEHEAP();
// Initialize the output structure.
int cOutBytes = sizeof(RegOutput)
+ (pregin->dwSize - 1) * sizeof(RegOutputEnt);
RegOutput *pregout = (RegOutput *) PrivMemAlloc(cOutBytes);
*ppregout = pregout;
if (pregout == NULL)
return E_OUTOFMEMORY;
memset(pregout, 0, cOutBytes);
pregout->dwSize = pregin->dwSize;
hr = GetClassCache().SetEndPoints(
#ifndef _CHICAGO_
phProcess,
((CProcess *)phProcess)->GetToken()->GetSid(),
pwszWinstaDesktop,
#else
NULL,
#endif
pregin,
pregout );
VDATEHEAP();
#if DBG == 1
CairoleDebugOut((DEB_SCM, "OUT ObjectServerStarted\n"));
CairoleDebugOut((DEB_SCM, "OUT Hresult : %lx\n", hr));
if (SUCCEEDED(hr))
{
DbgPrintRegOut("OUT Register Information", ppregout);
}
#endif // DBG == 1
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: StopServer
//
// Synopsis: Get notification that class server is stopping
//
// Arguments: [hRpc] - RPC handle
// [prevcls] - list of classes/registrations to stop
//
// History: 01-May-93 Ricksa Created
//
//--------------------------------------------------------------------------
extern "C" void ServerRevokeClsid(
handle_t hRpc,
PHPROCESS phProcess,
RevokeClasses *prevcls,
error_status_t *rpcstat)
{
#if DBG == 1
CairoleDebugOut((DEB_SCM, "_IN StopServer\n"));
DbgPrintRevokeClasses("_IN RevokeClasses:", prevcls);
#endif // DBG == 1
CheckLocalCall( hRpc );
VDATEHEAP();
*rpcstat = 0;
DWORD cLoops = prevcls->dwSize;
RevokeEntry *prevent = prevcls->revent;
for (DWORD i = 0; i < cLoops; i++, prevent++)
{
GetClassCache().StopServer(prevent->clsid,
IFSECURITY( ((CProcess *)phProcess)->GetToken()->GetSid() )
prevent->dwReg);
((CProcess *)phProcess)->RemoveClassReg( prevent->clsid, prevent->dwReg );
}
VDATEHEAP();
CairoleDebugOut((DEB_SCM, "OUT StopServer\n"));
}
void GetThreadID(
handle_t hRpc,
DWORD * pThreadID,
error_status_t *prpcstat)
{
CheckLocalCall( hRpc );
*prpcstat = 0;
*pThreadID = InterlockedExchangeAdd((long *)&gNextThreadID,1);
}
#ifndef _CHICAGO_
//+-------------------------------------------------------------------------
//
// Function: UpdateShrdTbls
//
// Synopsis: Update the shared memory tables.
//
// Arguments: [hRpc] - RPC handle
// [prpcstat] - communication status
//
// History: 11-Jul-94 Rickhi Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT UpdateShrdTbls(
handle_t hRpc,
error_status_t *prpcstat)
{
CheckLocalCall( hRpc );
*prpcstat = 0;
CairoleDebugOut((DEB_SCM, "_IN UpdateShrdTbls\n"));
VDATEHEAP();
// we dont take the lock because the caller is holding it for us.
g_pScmShrdTbl->UpdateWithLock();
VDATEHEAP();
CairoleDebugOut((DEB_SCM, "OUT UpdateShrdTbls\n"));
return S_OK;
}
//+-------------------------------------------------------------------------
//
// Function: UpdateActivationSettings
//
// Synopsis: Re-read default activation settings.
//
// Arguments: [hRpc] - RPC handle
// [prpcstat] - communication status
//
//--------------------------------------------------------------------------
extern void ComputeSecurity();
extern "C" void UpdateActivationSettings(
handle_t hRpc,
error_status_t *prpcstat)
{
CheckLocalCall( hRpc );
*prpcstat = 0;
gpClassCache->ReadRemoteActivationKeys();
ComputeSecurity();
}
#endif // !_CHICAGO_
#ifdef _CHICAGO_
//+-------------------------------------------------------------------------
//
// Function: StartObjectService
//
// Synopsis: Get a class object for a client
//
// Arguments: [hRpc] - RPC handle
// [orpcthis] - ORPC handle
// [localthis] - ORPC call data
// [orpcthat] - ORPC reply data
// [rclsid] - class id for reequest
// [dwCtrl] - type of server required
// [ppIFDClassObj] - where to return the serialized class object
// [ppwszDllToLoad] - where to return DLL path
//
// Returns: HRESULT
//
// History: 01-May-93 Ricksa Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT StartObjectService(
handle_t hRpc,
ORPCTHIS *orpcthis,
LOCALTHIS *localthis,
ORPCTHAT *orpcthat,
WCHAR *lpDesktop,
const GUID *guidCLSID,
DWORD dwCtrl,
WCHAR *pwszServer,
InterfaceData **ppIFDClassObj,
DWORD *pdwDllType,
WCHAR **ppwszDllToLoad )
{
REFCLSID rclsid = *guidCLSID;
#if DBG ==1
CairoleDebugOut((DEB_SCM, "_IN StartObjectServer\n"));
CairoleDebugOut((DEB_SCM, "_IN Desk Top: %s\n", lpDesktop));
DbgPrintGuid("_IN ThreadId: ", &orpcthis->cid);
DbgPrintGuid("_IN CLSID: ", guidCLSID);
CairoleDebugOut((DEB_SCM, "_IN Context: %lX\n", dwCtrl));
CairoleDebugOut((DEB_SCM, "_IN DLL Type: %lX\n", *pdwDllType));
#endif // DBG == 1
orpcthat->flags = 0;
orpcthat->extensions = NULL;
VDATEHEAP();
CBaseData bd( GETCLASSOBJECT,
lpDesktop, &orpcthis->cid, rclsid, dwCtrl,
pdwDllType, ppwszDllToLoad, ppIFDClassObj,
NULL, FALSE, NULL, NULL, NULL, NULL,FALSE);
HRESULT hr = GetClassCache().ProcessScmMessage(&bd, NULL);
VDATEHEAP();
#if DBG == 1
CairoleDebugOut((DEB_SCM, "OUT StartObjectServer\n"));
CairoleDebugOut((DEB_SCM, "OUT Hresult : %lx\n", hr));
if (SUCCEEDED(hr))
{
if (*ppIFDClassObj)
{
DbgPrintIFD("OUT Class Obj:", *ppIFDClassObj);
}
if (*ppwszDllToLoad)
{
CairoleDebugOut((DEB_SCM, "OUT DLL Type: %lX\n", *pdwDllType));
CairoleDebugOut((DEB_SCM, "OUT DLL: %ws\n", *ppwszDllToLoad));
}
}
#endif // DBG == 1
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: SvcActivateObject
//
// Synopsis: Instantiate an object with interface
//
// Arguments: [hRpc] - RPC handle
// [orpcthis] - ORPC handle
// [localthis] - ORPC call data
// [orpcthat] - ORPC reply data
// [rclsid] - class id for object
// [dwOptions] - type of server needed
// [grfMode] - how to open file if specified
// [pwszPath] - path to object
// [pIFDstg] - marshaled storage
// [pwszDllPath] - path to DLL
//
// Returns: HRESULT
//
// History: 01-May-93 Ricksa Created
// 18-Aug-94 AlexT Add caller, callee thread id
//
//--------------------------------------------------------------------------
// BUGBUG [mikese] The pwszServerAddress parameter is redundant, and should
// be removed from the IDL
// BUGBUG: hash value is an obsolete field as well.
extern "C" HRESULT SvcActivateObject(
handle_t hRpc,
ORPCTHIS *orpcthis,
LOCALTHIS *localthis,
ORPCTHAT *orpcthat,
WCHAR *lpDesktop,
WCHAR *pwszProtseq,
const GUID *pclsid,
DWORD dwOptions,
DWORD grfMode,
DWORD dwHash,
WCHAR *pwszPath,
InterfaceData *pIFDstg,
InterfaceData **ppIFDunk,
DWORD *pdwDllType,
WCHAR **ppwszDllPath,
WCHAR *pwszServerAddress )
{
#if DBG ==1
CairoleDebugOut((DEB_SCM, "_IN SvcActivateObject\n"));
CairoleDebugOut((DEB_SCM, "_IN Desk Top: %s\n", lpDesktop));
CairoleDebugOut((DEB_SCM, "_IN Protocol Seq: %ws\n",
(pwszProtseq == NULL) ? L"None" : pwszProtseq));
DbgPrintGuid("_IN ThreadId: ", &orpcthis->cid);
DbgPrintGuid("_IN CLSID: ", pclsid);
CairoleDebugOut((DEB_SCM, "_IN Context: %lX\n", dwOptions));
CairoleDebugOut((DEB_SCM, "_IN Mode: %lX\n", grfMode));
CairoleDebugOut((DEB_SCM, "_IN Path: %ws\n",
(pwszPath == NULL) ? L"None" : pwszPath));
CairoleDebugOut((DEB_SCM, "_IN Stg: %lX\n", pIFDstg));
CairoleDebugOut((DEB_SCM, "_IN DLL Type: %lX\n", *pdwDllType));
#endif // DBG == 1
orpcthat->flags = 0;
orpcthat->extensions = NULL;
VDATEHEAP();
HRESULT hr = S_OK;
InterfaceData *pifdFromROT = NULL;
BEGIN_BLOCK
// Lock the path so that only one path may be bound at a time
CLockPath lckpath(pwszPath, hr);
if (FAILED(hr))
{
// Couldn't lock the path -- memory problem maybe. Anyway, we
// can't go anywhere from here.
CairoleDebugOut((DEB_ERROR,
"SvcActivateObject Lock of Path Failed %lx\n", hr));
EXIT_BLOCK;
}
// If there is a path Look for path in the Directory ROT
if (pwszPath != NULL)
{
// Remember that pdwDllType is overloaded here. We use it to
// indicate that we got an object from the ROT. We need to do
// this because there is no guarantee that the ROT entry will
// not be bad by the time we get back to the caller and therefore,
// the caller will want to retry in this case.
if (GetObjectFromRot(pwszPath, &pifdFromROT) == S_OK)
{
// Is this a local operatoin?
if (pwszProtseq == NULL)
{
// Return the marshaled interface from the ROT to the
// caller.
*ppIFDunk = pifdFromROT;
// So we remember not to clean up the buffer
pifdFromROT = NULL;
// Let caller know that we got this from the ROT so
// if it doesn't work they should try again.
*pdwDllType = GOT_FROM_ROT;
// We got what we came for from the ROT so we can exit
CairoleDebugOut((DEB_TRACE, "Found object in the ROT\n"));
EXIT_BLOCK;
}
// Because a tabled marshaled interface is not enought
// to get unmarshaled locally, we need to send it back
// to the object server to get something we can pass back
// to another machine.
}
}
// BUGBUG - Until we can decide how to pass back the callee's thread
// id, just hold it here.
DWORD dwTIDCallee;
IID IIDs[1];
HRESULT Results[1];
IIDs[0] = IID_IUnknown;
CGetCreateData gcd(pwszProtseq, dwOptions, grfMode, pwszPath,
pIFDstg, NULL, ppIFDunk, localthis->dwClientThread,
&dwTIDCallee, pifdFromROT,
1, IIDs, Results);
CBaseData bd(GETPERSISTENTOBJ,
lpDesktop, &orpcthis->cid, *pclsid, dwOptions, pdwDllType,
ppwszDllPath, ppIFDunk,
NULL, FALSE, NULL, NULL, NULL, NULL,FALSE);
hr = GetClassCache().ProcessScmMessage(&bd, &gcd);
END_BLOCK;
VDATEHEAP();
#if DBG == 1
CairoleDebugOut((DEB_SCM, "OUT SvcActivateObject\n"));
CairoleDebugOut((DEB_SCM, "OUT Hresult : %lx\n", hr));
if (SUCCEEDED(hr))
{
if (*ppIFDunk)
{
DbgPrintIFD("OUT Object:", *ppIFDunk);
}
if (*ppwszDllPath)
{
CairoleDebugOut((DEB_SCM, "OUT DLL Type: %lX\n", *pdwDllType));
CairoleDebugOut((DEB_SCM, "OUT DLL: %ws\n", *ppwszDllPath));
}
}
#endif // DBG == 1
if (pifdFromROT != NULL)
{
MIDL_user_free(pifdFromROT);
}
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: SvcCreateActivateObject
//
// Synopsis: Create and activate a new object
//
// Arguments: [hRpc] - RPC handle
// [orpcthis] - ORPC handle
// [localthis] - ORPC call data
// [orpcthat] - ORPC reply data
// [rclsid] - class id for object to create
// [dwOptions] - type of server required
// [dwMode] - how to open storage
// [pwszPath] - path to the storage
// [pIFDstg] - marshaled storage
// [pwszNewName] - new name of object
// [ppIFDunk] - marshaled IUnknown to return
// [ppwszDllPath] - path to DLL for handler or server
//
// Returns: HRESULT
//
// History: 01-May-93 Ricksa Created
// 18-Aug-94 AlexT Add caller, callee thread id
//
//--------------------------------------------------------------------------
// BUGBUG [mikese] The pwszServerAddress parameter is redundant, and should
// be removed from the IDL
extern "C" HRESULT SvcCreateActivateObject(
handle_t hRpc,
ORPCTHIS *orpcthis,
LOCALTHIS *localthis,
ORPCTHAT *orpcthat,
WCHAR * lpDesktop,
WCHAR *pwszProtseq,
const GUID *guidCLSID,
DWORD dwOptions,
DWORD dwMode,
WCHAR *pwszPath,
InterfaceData *pIFDstg,
WCHAR *pwszNewName,
InterfaceData **ppIFDunk,
DWORD *pdwDllType,
WCHAR **ppwszDllPath,
WCHAR *pwszServerAddress )
{
REFCLSID rclsid = *guidCLSID;
#if DBG ==1
CairoleDebugOut((DEB_SCM, "_IN SvcCreateActivateObject\n"));
CairoleDebugOut((DEB_SCM, "_IN Desk Top: %s\n", lpDesktop));
CairoleDebugOut((DEB_SCM, "_IN Protocol Seq: %ws\n",
(pwszProtseq == NULL) ? L"None" : pwszProtseq));
DbgPrintGuid("_IN ThreadId: ", &orpcthis->cid);
DbgPrintGuid("_IN CLSID: ", guidCLSID);
CairoleDebugOut((DEB_SCM, "_IN Context: %lX\n", dwOptions));
CairoleDebugOut((DEB_SCM, "_IN Mode: %lX\n", dwMode));
CairoleDebugOut((DEB_SCM, "_IN Path: %ws\n",
(pwszPath == NULL) ? L"None" : pwszPath));
CairoleDebugOut((DEB_SCM, "_IN Stg: %lX\n", pIFDstg));
CairoleDebugOut((DEB_SCM, "_IN New Path: %ws\n",
(pwszNewName == NULL) ? L"None" : pwszNewName));
CairoleDebugOut((DEB_SCM, "_IN DLL Type: %lX\n", *pdwDllType));
#endif // DBG == 1
orpcthat->flags = 0;
orpcthat->extensions = NULL;
VDATEHEAP();
// Error return from function
HRESULT hr=S_OK;
// Lock the path so that only one path may be bound at a time. Note
// that for create we don't look in the ROT since we don't want to
// get an already running entry but create a new one.
CLockPath lckpath(pwszPath, hr);
if (FAILED(hr))
{
// Couldn't lock the path -- memory problem maybe. Anyway, we
// can't go anywhere from here.
CairoleDebugOut((DEB_ERROR, "GetClass Failed %lx\n", hr));
return hr;
}
// BUGBUG - Until we can decide how to pass back the callee's thread
// id, just hold it here.
DWORD dwTIDCallee;
IID IIDs[1];
HRESULT Results[1];
IIDs[0] = IID_IUnknown;
CGetCreateData gcd(pwszProtseq, dwOptions, dwMode, pwszPath, pIFDstg, pwszNewName,
ppIFDunk, localthis->dwClientThread, &dwTIDCallee, NULL,
1, IIDs, Results );
CBaseData bd(CREATEPERSISTENTOBJ, lpDesktop, &orpcthis->cid, rclsid,
dwOptions, pdwDllType, ppwszDllPath, ppIFDunk,
NULL, FALSE, NULL, NULL, NULL, NULL,FALSE);
hr = GetClassCache().ProcessScmMessage(&bd, &gcd);
CairoleDebugOut((DEB_TRACE,
"Result %lx\nDll Path %ws\n", hr, *ppwszDllPath));
VDATEHEAP();
#if DBG == 1
CairoleDebugOut((DEB_SCM, "OUT SvcActivateObject\n"));
CairoleDebugOut((DEB_SCM, "OUT Hresult : %lx\n", hr));
if (SUCCEEDED(hr))
{
if (*ppIFDunk)
{
DbgPrintIFD("OUT Object:", *ppIFDunk);
}
if (*ppwszDllPath)
{
CairoleDebugOut((DEB_SCM, "OUT DLL Type: %lX\n", *pdwDllType));
CairoleDebugOut((DEB_SCM, "OUT DLL: %ws\n", *ppwszDllPath));
}
}
#endif // DBG == 1
return hr;
}
#endif // _CHICAGO_
#ifdef DCOM
//+-------------------------------------------------------------------------
//
// Structure: WIPEntry (Window Interface Property)
//
// Synopsis: Stores marshaled interface info associated with a given window.
// It is an entry in the CWIPTable (see below).
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
typedef struct tagWIPEntry
{
DWORD hWnd; // window the interface property is stored in
DWORD dwFlags; // flags (see WIPFLAGS)
STDOBJREF std; // marshaled interface data
OXID_INFO oxidInfo; // data needed to resolve the OXID
} WIPEntry;
typedef enum tagWIPFLAGS
{
WIPF_VACANT = 0x1, // slot is vacant
WIPF_OCCUPIED = 0x2 // slot is occupied
} WIPFLAGS;
#define WIPTBL_GROW_SIZE 10 // grow table by 10 entries at a time
//+-------------------------------------------------------------------------
//
// Class: CWIPTable (Window Interface Property Table)
//
// Synopsis: Stores marshaled interface info associated with a given window.
// This is used for registering drag/drop interfaces.
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
class CWIPTable
{
public:
HRESULT AddEntry(DWORD hWnd, STDOBJREF *pStd, OXID_INFO *pOxidInfo, DWORD *pdwCookie);
HRESULT GetEntry(DWORD hWnd, DWORD dwCookie, BOOL fRevoke,
STDOBJREF *pStd, OXID_INFO *pOxidInfo);
private:
DWORD Grow();
static DWORD s_cEntries; // count of entries in the table
static DWORD s_iNextFree; // index to first free entry in table
static WIPEntry *s_pTbl; // ptr to the first entry in table
static CMutexSem s_mxs; // critical section to protect data
};
// static data for the table (avoids running a ctor for the class)
DWORD CWIPTable::s_cEntries = 0;
DWORD CWIPTable::s_iNextFree = 0xffffffff;
WIPEntry *CWIPTable::s_pTbl = NULL;
CMutexSem CWIPTable::s_mxs;
CWIPTable gWIPTbl; // global instance of the class
//+-------------------------------------------------------------------------
//
// Function: CopyDualStringArray
//
// Synopsis: makes a copy of the given string array
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
HRESULT CopyDualStringArray(DUALSTRINGARRAY *psa, DUALSTRINGARRAY **ppsaNew)
{
ULONG ulSize = sizeof(DUALSTRINGARRAY) + (psa->wNumEntries * sizeof(WCHAR));
*ppsaNew = (DUALSTRINGARRAY *) PrivMemAlloc(ulSize);
if (*ppsaNew == NULL)
{
return E_OUTOFMEMORY;
}
memcpy(*ppsaNew, psa, ulSize);
return S_OK;
}
//+-------------------------------------------------------------------------
//
// Member: CWIPTable::AddEntry, public
//
// Synopsis: Adds a WIPEntry to the table.
//
// Arguments: [hWnd] - window handle
// [pStd] - standard marshaled interface STDOBJREF
// [pOxidInfo] - info needed to resolve the OXID
// [pdwCookie] - cookie to return (to be placed on the window)
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
HRESULT CWIPTable::AddEntry(DWORD hWnd, STDOBJREF *pStd, OXID_INFO *pOxidInfo,
DWORD *pdwCookie)
{
// make a copy of the string array in the OxidInfo since MIDL will
// delete it on the way back out of the call.
DUALSTRINGARRAY *psaNew;
HRESULT hr = CopyDualStringArray(pOxidInfo->psa, &psaNew);
if (FAILED(hr))
{
return hr;
}
CLock lck(s_mxs);
// find a free slot in the table
DWORD dwIndex = s_iNextFree;
if (dwIndex == 0xffffffff)
{
// grow the table
dwIndex = Grow();
}
if (dwIndex != 0xffffffff)
{
// get the pointer to the entry,
WIPEntry *pEntry = s_pTbl + dwIndex;
// update the next free index.
s_iNextFree = pEntry->hWnd;
// copy in the data
memcpy(&pEntry->std, pStd, sizeof(STDOBJREF));
memcpy(&pEntry->oxidInfo, pOxidInfo, sizeof(OXID_INFO));
pEntry->oxidInfo.psa = psaNew;
pEntry->hWnd = hWnd;
pEntry->dwFlags = WIPF_OCCUPIED;
// return success
hr = S_OK;
}
else
{
// free the allocated string array
PrivMemFree(psaNew);
}
// set the cookie to return
*pdwCookie = dwIndex+5000;
return hr;
}
//+-------------------------------------------------------------------------
//
// Member: CWIPTable::GetEntry, public
//
// Synopsis: Retrieves and optionally delets a WIPEntry from the table.
//
// Arguments: [hWnd] - window handle
// [dwCookie] - cookie from the window
// [pStd] - place to return STDOBJREF data
// [pOxidInfo] - place to return info needed to resolve the OXID
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
HRESULT CWIPTable::GetEntry(DWORD hWnd, DWORD dwCookie, BOOL fRevoke,
STDOBJREF *pStd, OXID_INFO *pOxidInfo)
{
HRESULT hr = E_INVALIDARG;
// validate the cookie
DWORD dwIndex = dwCookie - 5000;
if (dwIndex < 0 || dwIndex >= s_cEntries)
{
return hr;
}
CLock lck(s_mxs);
// get the pointer to the entry,
WIPEntry *pEntry = s_pTbl + dwIndex;
// make sure the entry is occupied
if (pEntry->dwFlags & WIPF_OCCUPIED)
{
DUALSTRINGARRAY *psaNew;
hr = CopyDualStringArray(pEntry->oxidInfo.psa, &psaNew);
if (SUCCEEDED(hr))
{
// copy out the data to return
memcpy(pStd, &pEntry->std, sizeof(STDOBJREF));
memcpy(pOxidInfo, &pEntry->oxidInfo, sizeof(OXID_INFO));
pOxidInfo->psa = psaNew;
if (fRevoke)
{
// free the entry by updating the flags and the next free index
PrivMemFree(pEntry->oxidInfo.psa);
pEntry->dwFlags = WIPF_VACANT;
pEntry->hWnd = s_iNextFree;
s_iNextFree = dwIndex;
}
}
}
return hr;
}
//+-------------------------------------------------------------------------
//
// Member: CWIPTable::Grow, private
//
// Synopsis: grows the WIPTable size.
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
DWORD CWIPTable::Grow()
{
// compute the size and allocate a new table
DWORD dwSize = (s_cEntries + WIPTBL_GROW_SIZE) * sizeof(WIPEntry);
WIPEntry *pNewTbl = (WIPEntry *) PrivMemAlloc(dwSize);
if (pNewTbl != NULL)
{
// copy the old table in
memcpy(pNewTbl, s_pTbl, (s_cEntries * sizeof(WIPEntry)));
// free the old table
if (s_pTbl)
{
PrivMemFree(s_pTbl);
}
// replace the old table ptr
s_pTbl = pNewTbl;
// update the free list and mark the new entries as vacant
s_iNextFree = s_cEntries;
WIPEntry *pNext = s_pTbl + s_cEntries;
for (ULONG i=0; i< WIPTBL_GROW_SIZE; i++)
{
pNext->hWnd = ++s_cEntries;
pNext->dwFlags = WIPF_VACANT;
pNext++;
}
(pNext-1)->hWnd = 0xffffffff; // last entry has END_OF_LIST marker
}
return s_iNextFree;
}
//+-------------------------------------------------------------------------
//
// Function: RegisterWindowPropInterface
//
// Synopsis: Associate a window property with a (standard) marshaled
// interface.
//
// Arguments: [hRpc] - RPC handle
// [hWnd] - window handle
// [pStd] - standard marshaled interface STDOBJREF
// [pOxidInfo] - info needed to resolve the OXID
// [pdwCookie] - cookie to return (to be placed on the window)
// [prpcstat] - communication status
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT RegisterWindowPropInterface(
handle_t hRpc,
DWORD hWnd,
STDOBJREF *pStd,
OXID_INFO *pOxidInfo,
DWORD *pdwCookie,
error_status_t *prpcstat)
{
CheckLocalCall( hRpc );
*prpcstat = 0;
CairoleDebugOut((DEB_SCM,
"_IN RegisterWindowPropInterface hWnd:%x pStd:%x pOxidInfo:%x\n",
hWnd, pStd, pOxidInfo));
VDATEHEAP();
HRESULT hr = gWIPTbl.AddEntry(hWnd, pStd, pOxidInfo, pdwCookie);
CairoleDebugOut((DEB_SCM, "_OUT RegisterWindowPropInterface dwCookie:%x\n",
*pdwCookie));
VDATEHEAP();
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: GetWindowPropInterface
//
// Synopsis: Get the marshaled interface associated with a window property.
//
// Arguments: [hRpc] - RPC handle
// [hWnd] - window handle
// [dwCookie] - cookie from the window
// [fRevoke] - whether to revoke entry or not
// [pStd] - standard marshaled interface STDOBJREF to return
// [pOxidInfo] - info needed to resolve the OXID
// [prpcstat] - communication status
//
// History: 22-Jan-96 Rickhi Created
//
//--------------------------------------------------------------------------
extern "C" HRESULT GetWindowPropInterface(
handle_t hRpc,
DWORD hWnd,
DWORD dwCookie,
BOOL fRevoke,
STDOBJREF *pStd,
OXID_INFO *pOxidInfo,
error_status_t *prpcstat)
{
CheckLocalCall( hRpc );
*prpcstat = 0;
CairoleDebugOut((DEB_SCM,
"_IN GetWindowPropInterface hWnd:%x dwCookie:%x fRevoke:%x\n",
hWnd, dwCookie, fRevoke));
VDATEHEAP();
HRESULT hr = gWIPTbl.GetEntry(hWnd, dwCookie, fRevoke, pStd, pOxidInfo);
CairoleDebugOut((DEB_SCM,
"_OUT GetWindowPropInterface pStd:%x pOxidInfo:%x\n", pStd, pOxidInfo));
VDATEHEAP();
return hr;
}
#endif // DCOM
