Passing reference to COM interface from COM library - com

Question

How do I pass reference to a COM interface as an argument from within a COM library?
Here's the sample:
1) Client code successfully creates coclass and receives the interface pointer in pFunctionDiscovery as below:
hr = CoCreateInstance(
__uuidof(FunctionDiscovery),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IFunctionDiscovery),
(LPVOID*)&pFunctionDiscovery );
if (FAILED(hr))
{
TRACE_MESSAGE(Error,"Failed to get IFunctionDiscovery COM %08x\n",hr);
goto Exit;
}
2) Now calling member function of pFunctionDiscovery as below gives error message: 800706f4, which corresponds to A null reference pointer was passed to the stub.
hr = pFunctionDiscovery->GetInstanceCollection(
FCTN_CATEGORY_DEVICEDISPLAYOBJECTS,
NULL,
FALSE,
&pFICollection );
3) COM library is written with aid of ATL library and the code is as below:
// The module attribute is specified in order to implement DllMain,
// DllRegisterServer and DllUnregisterServer
[ module(dll, name = "MyServer", helpstring = "MyServer 1.0 Type Library") ];
[ emitidl ];
/////////////////////////////////////////////////////////////////////////////
// IFunctionInstanceCollection interface
[
object,
uuid("F0A3D895-855C-42A2-948D-2F97D450ECB1"),
oleautomation,
helpstring("IFunctionInstanceCollection Interface"),
pointer_default(unique)
]
__interface IFunctionInstanceCollection : IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetCount(__RPC__out DWORD *pdwCount) = 0;
};
// IFunctionDiscovery interface
[
object,
uuid("4df99b70-e148-4432-b004-4c9eeb535a5e"),\
oleautomation,
helpstring("IFunctionDiscovery Interface"),
pointer_default(unique)
]
__interface IFunctionDiscovery : IUnknown
{
virtual HRESULT GetInstanceCollection(
__RPC__in_string const WCHAR* functionCategory,
__RPC__in_opt_string const WCHAR* subcategory,
BOOL fIncludeAllSubCategories,
__RPC__deref_out_opt IFunctionInstanceCollection **ppIFunctionInstanceCollection
) = 0;
};
/////////////////////////////////////////////////////////////////////////////
// FunctionDiscovery class
[
coclass,
threading(apartment),
vi_progid("FunctionDiscovery.Discovery"),
progid("FunctionDiscovery.Discovery.1"),
version(1.0),
uuid("C72BE2EC-8E90-452c-B29A-AB8FF1C071FC"),
helpstring("FunctionDiscovery Class")
]
class ATL_NO_VTABLE FunctionDiscovery :
public IFunctionDiscovery
{
public:
FunctionDiscovery() {};
virtual ~FunctionDiscovery(){};
virtual HRESULT GetInstanceCollection(
__RPC__in_string const WCHAR* functionCategory,
__RPC__in_opt_string const WCHAR* subcategory,
BOOL fIncludeAllSubCategories,
__RPC__deref_out_opt IFunctionInstanceCollection **ppIFunctionInstanceCollection
)
{
printf("GetInstanceCollection called");
return 0;
}
DECLARE_PROTECT_FINAL_CONSTRUCT()
HRESULT FinalConstruct()
{
return S_OK;
}
void FinalRelease()
{
}
static BOOL DllMainAttach();
static void DllMainDetach();
};
Please let me know where the problem is?
Thanks
Nick
Ok, passing a non null string in the call from client, worked fine. The way I am assigning object to *ppIFunctionInstanceCollection is as below:
On the Server side, I declare a new class like this and create an object from within GetInstanceCollection. When client calls GetInstanceCOllection, this created object is returned. I do get a valid instance on the server side, but on the client side, it shows up as NULL.
1)
class CFunctionInstanceCollection : public IFunctionInstanceCollection
{
public:
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID IID, void **pv) throw()
{ return 0; };
ULONG STDMETHODCALLTYPE AddRef(void) throw()
{ return 0; };
ULONG STDMETHODCALLTYPE Release(void) throw()
{ return 0; };
virtual HRESULT STDMETHODCALLTYPE GetCount(__RPC__out DWORD *pdwCount)
{ return 10; };
};
2) From within GetInstanceCollection, I am doing:
*ppIFunctionInstanceCollection = new CFunctionInstanceCollection();
I was hoping that the above assignment valid instance of CFunctionInstanceCollection into last parameter of GetInstanceCollection() method, which is *ppIFunctionInstanceCollection. I have verified this on the server side and it prints valid pointer, with size of class as 4 (presence of virtual functions yields class size as 4).
But on the client side, value is NULL. I think there is something more in passing of parameters between client/server. If you see anything else, please let me know that too. Thanks!!!

Answer 1

Apologies if I'm telling you things you already know.
In RPC (and COM), a proxy is the piece of code the client actually invokes when it calls a remote procedure. The proxy generally marshals the input parameters and then sends the request to the server where a piece of code called the stub unmarshals the parameters and then uses them to invoke the actual procedure being called.
When the called procedure returns a result, the stub marshals the out parameters and the result and sends the response back to the proxy which in turn unmarshals the out parameters etc. and hands them back to the client.
That's the general model anyway, things are sometimes optimised away (e.g., in the case of in process COM objects) in which case there may not be an actual stub and an actual proxy. Still, that's the background we can use to understand what a "proxy" and a "stub" are.
The "A null reference pointer was passed to the stub" error suggests that the problem is happening at the stub (i.e., server) side. The two pieces of code that might be passing things to the stub are the proxy and the implementation of GetInstanceCollection with GetInstanceCollection being the more likely culprit.
I suspect your problem is that the GetInstanceCollection implementation does not assign a value to *ppIFunctionInstanceCollection.
Try adding code to assign *ppIFunctionInstanceCollection before GetInstanceCollection returns.
updated 3/15
Your updated implementation of GetCount returns the value 10. But, that will be interpreted as the HRESULT 10 not the count value 10. The implementation of GetCount should really look something like this...
virtual HRESULT STDMETHODCALLTYPE GetCount(__RPC__out DWORD *pdwCount)
{
*pdwCount = 10;
return S_OK;
};
That said, it really isn't a good idea to dummy up the IUnknown methods (QueryInterface, AddRef and Release) because you can break all sorts of things unexpectedly. For example, every time you call GetInstanceCollection your program is going to leak a CFunctionInstanceCollection instance because one is created and never destroyed.
The code you have is okay for an experiment but it would be better to use ATL to do a full implementation of IUnknown for CFunctionInstanceCollection just as you did for your FunctionDiscovery class.
Updated 3/16
For completeness, I should probably also have mentioned that assigning *ppIFunctionInstanceCollection the way you do is valid but potentially risky in general.
You've written the CFunctionInstanceCollection class, so you know it implements the IFunctionInstanceCollection interface directly, so you know your assignment is safe. But in the more general case where you didn't write the class, the CFunctionInstanceCollection class might do something less straight forward - for example it might aggregate some other class that implements the interface. To be really really safe you should use QueryInterface to retrieve the IFunctionInstanceCollection interface pointer.

Answer 2

This blog post explains why you have this problem, pointer_default(unique) does not do what you think it does. Attribute the subcategory argument with [unique].