Re: Problem marshalling interface pointer into local server

Hi,

Alexander and Brian, thank you very much for the advise.

I created a new ATL project for the common marshaller proxy/stub with the
IDL file I posted previously then used the ATL generated PS project output
binary as the common marshaller for all the interfaces. After the local
server took out the proxy/stub code for the common interfaces and use the
common marshaller, it is working like charm. Only one query here, the local
server only "#import" the common IDL file, but NOT "#import" the TypLib that
is generated from the common IDL file. Although it seems OK when I run the
Appz, I would like to know whether it is "compulsory" to import the common
interface TypeLib in the various COM projects' library blocks.

By the way, by saying "registration ref count issue", I mean since I have
multiple COM (both in-proc and out-proc) projects that need to use the
common PS, this common PS must be regsvr during deployment of the various
COM projects and, the common PS can only be unRegsvr/remove when all the COM
objects that reply on it are removed. Therefore, I need some sort of
reference counting scheme for the Regsvr/UnRegsvr of the common PS.

Thank you very much.

Angela


"Alexander Nickolov" <agnickolov@xxxxxxxx> wrote in message
news:usrLTuoqGHA.928@xxxxxxxxxxxxxxxxxxxxxxx
I hope by main you mean the project for the shared IDL, not
any of the client projects that expose your actual COM objects.

One option would be to create the shared IDL project as an
ATL project with merge proxy/stub checked. Don't add any
COM objects, only populate the IDL file with all shared interfaces.
Mind you this is not the most efficient way of producing a DLL
containing both the type library and the marshaling code, but
it's much easier for beginners to achieve...

BTW, you mention that some of your interfaces deriving from
IUnkown have the [dual] attribute. Note that's a lie. Dual
interfaces must derive from IDispatch, not IUnknown. Go ahead
and change all such attributes from [dual] to [oleautomation].
Now that would be correct - an Automation-compatible interface
which is not dual since it doesn't derive from IDispatch. Note
that [dual] implies [oleautomation] and that's what you only
care about as far as marshaling support with the type library.

A final note is that you want to move all [oleautomation]
interfaces within the library block, otherwise you get marshaling
support both from the proxy/stub code and through the type
library. Or you may want to forgo the type library altogether
and use the proxy/stub code for all interfaces. In that case
you only need to build the extra project the ATL appwizard
creates for you in VC7 and above. You won't need the DLL
produced by the IDL project at all. (In case you didn't know,
MIDL does not generate proxy/stub marshaling code for any
interfaces within the library block.)

--
=====================================
Alexander Nickolov
Microsoft MVP [VC], MCSD
email: agnickolov@xxxxxxxx
MVP VC FAQ: http://www.mvps.org/vcfaq
=====================================

"Angela Yan" <yanyan9@xxxxxxxxxxx> wrote in message
news:e3ikEeoqGHA.3648@xxxxxxxxxxxxxxxxxxxxxxx
Hi,

I found some sources regarding this issue. As most of the interfaces in
my common IDL is not oleautomation or dispatch interfaces, I think what
my local servers need is what we call "standard mashalling", mashall via
a proxy/stub dll instead of mashalling via TypLib. Furthermore, the
parameter types used by the interfaces are also not ole-compatible.

But when I read the book about creating of the proxy/stub dll, they
mention something about using MIDL to compile the IDL file, creating a
DLL project and adding the generated _p.c,_i.c,dlldata.c and .DEF file
into the project and build the project to get the proxy/stub dll. I am
not sure whether the book mentions this method because it uses VC6 to
compile. I believe that in VC7, I can use the common IDL file (below) as
the main project IDL file. By building the project, it will auto generate
the typeLib, _p.c, _i.c and dlldata.c. In fact, when I create a COM dll
project, there is a default PS project generated. So in this case, can I
just compile the main DLL project and then the PS project, and use the PS
project binary as the common proxy/stub dll for all the local servers?

IDL file:

import "oaidl.idl";
import "ocidl.idl";

typedef enum abc_TYPE
{
abc= 0,
def,
ghi
} abc_UNION_TYPE;

..... //other enum structure info

[
object,
uuid(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx),
helpstring("IFaceB Interface"),
pointer_default(unique)
]
interface IFaceB : IUnknown{
[helpstring("method GetStatusB")] HRESULT GetStatusB([out] DWORD*
pStatus);
};
typedef IFaceB* PFaceB;

[
object,
uuid(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx),
helpstring("IFaceD Interface"),
pointer_default(unique)
]
interface IFaceD : IUnknown{
[helpstring("method GetStatusD")] HRESULT GetStatusD([out] DWORD*
pStatus);
};
typedef IFaceD* PFaceD;

...... //other interface info
......

[
uuid(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx),
version(1.0),
helpstring("CommonInterface 1.0 Type Library")
]
library CommonInterfaceLib
{
importlib("stdole2.tlb");

interface IFaceB;
interface IFaceD;
}


Further to this, I had an issue where I have a in-proc server (server A),
that uses the merged proxy/stub, and a local out-proc server(server B)
both running on 1 system. Both servers implements IFace and register
their own proxy/stub for IFace. Server A was regsvr after server B, and
from what I saw in the registry, the proxy that was registered for IFace
is server A's proxy.

So during one of the use, I had an application that is trying to access
IFace on server B, but as the proxy is pointing to server A, server A's
proxy is used to call to server B. The application then called
CoFreeUnusedLibrary(), which triggers the DLLCanUnloadNow() call in both
server A's proxy and server B. Server B returns FALSE since it's CoClass
is in used, but server A's proxy actually return TRUE. So after 10 mins,
which the default delay before libraries deems unused by the system is
unloaded, server A's proxy got unloaded as a result. When that happen,
and the application tries to use IFace on server B which it previously
obtained before the CoFreeUnusedLibrary() call, an ACCESS_VIOLATION error
was triggered since the proxy is no longer loaded.

I would like to know would the current method to create a common
proxy/stub dll face the same issue as what I describe above?

Thank you very much.
Angela


"Angela Yan" <yanyan9@xxxxxxxxxxx> wrote in message
news:OiucGLiqGHA.1976@xxxxxxxxxxxxxxxxxxxxxxx
Hi,

Thanks for your reply.

I replied my 'misplaced' post. But just in case it is too deep down the
valley. I copied the reply here together with some of the findings.

- From "Alexander Nickolov"
...
You'll probably want to group all shared interfaces as a separate
project that only produces a proxy/stub DLL (or a type library,
whatever is appropriate). Then in the other projects you only
refer to those interfaces, but do not generate any marshaling info
for them. That means you import the shared IDL and importlib()
the shared type library.

- My reply to the post:
So am I correct to say that there are 2 methods to deal with the
problem:

1. Compile the common IDL file that containing all the shared
interfaces into a typlib. Then all the projects import the IDL file and
the typlib in their respective 'main' IDL files. During deployment, it
needs to register the common typlib (hmm.. how to register??) and take
care of the registration refCount issue.

2. Compile a DLL project that describes all the shared interfaces. Then
all the projects can use wizard "implement interface" to point to that
DLL project and implement the respective interfaces. The imported DLL
project path will be auto added into stdafx.h. In this case, does it
need to take care refCount issue for the common DLL during deployment??

My findings to option 1:

I've managed to compile the common IDL into a typeLib and register it
using "LoadTypeLib() and RegisterTypeLib()". But according to the MSDN
and I also confirmed subsequently that during the registeration of the
TypeLib, only dispatch interface type and dual interface type will go
into registry HKCR->Interface key.

All interfaces in the common IDL file inherits from IUnknown interface,
the only difference is that some is marked with 'dual' attribute (I am
not sure whether it is correct..). I noticed that after registering the
typelib, only those interfaces marked with 'dual' attribute will go into
registry but not the other interfaces. Thus my local server still lack
of the marshalling information for those non-dual IUnknown interfaces.

Can please kindly point out which step I did is wrong? Compile the IDL?
Register the TypeLib or..?

Thank you very much.

Angela






"Alexander Nickolov" <agnickolov@xxxxxxxx> wrote in message
news:%23SqctJcqGHA.4912@xxxxxxxxxxxxxxxxxxxxxxx
Neither. Make a sepaarte proxy/stub DLL with B's marshaling
support. Also see my reply on your other (misplaced) post.

--
=====================================
Alexander Nickolov
Microsoft MVP [VC], MCSD
email: agnickolov@xxxxxxxx
MVP VC FAQ: http://www.mvps.org/vcfaq
=====================================

"Angela Yan" <yanyan9@xxxxxxxxxxx> wrote in message
news:e$E5woPqGHA.3244@xxxxxxxxxxxxxxxxxxxxxxx
Hi,

Did you register the proxy-stub for interface B? Remember, it is not
marked as automation-compliant.

Hmm.. No, I didn't register the proxy/stub for interface B. The local
server only 'uses' the interface B, but did not implement it. As for
the client of the local server, which is an in-proc dll, it also does
not register the proxy/stub for interface B. Interface B is in defined
in a common IDL file that is shared between several COM servers. I
experimented it and confirmed that once the proxy/stub for interface B
gets registered, everything works fine.

But I have another question here. I am not sure which COM server
should register the proxy/stub for interface B in this case, since it
is in a common IDL file that several COM servers will 'import' from.
And COM servers may include 2 or more local servers.

In this case, should I register one or both local server's proxy/stub?
Or, should I compile the common IDL file into a
common typelib and register it? Or is there any other recommendation?

Thank you.

Angela


"Brian Muth" <bmuth@xxxxxxxx> wrote in message
news:OVP7Kk1pGHA.3564@xxxxxxxxxxxxxxxxxxxxxxx

Can you explain more on why a dual interface cannot accept other
interface, other than IUnknown, as its method's paramter?

A dual interface supports IDispatch, and therefore the parameters
must be ole-automation compliant. Passing a custom interface is not
ole-automation compliant. But you can pass IDispatch* and IUnknown*.


And actually I tried the method of passing the IUnknown of Interface
B over to the local server, and local server then QI to get the
actual interface B. However, although my client does receive the QI
from the local server and returns the interface B, the local server
cannot get the interface B over. The error code is E_NOINTERFACE.

Did you register the proxy-stub for interface B? Remember, it is not
marked as automation-compliant.


By the way, I am not using attributed ATL. At least, when I created
the project, I unticked the 'attributed' check box... :p

Excellent.

Brian














.

Relevant Pages

  • Re: I have a COM object installed on my machine...
    ... depending on the type of interface. ... Dual interfaces are usually marshaled via type libraries, ... cannot be marshaled with a proxy/stub DLL. ... the proxy/stub DLL from its IDL file is the way to go. ...
    (microsoft.public.vc.atl)
  • Re: Problem marshalling interface pointer into local server
    ... It can be applied to the proxy/stub DLL as well. ... Mind you this is not the most efficient way of producing a DLL ... Now that would be correct - an Automation-compatible interface ... I had an issue where I have a in-proc server (server ...
    (microsoft.public.vc.atl)
  • Re: Tired of 100s of stupid Getter/Setter methods
    ... but interface does not hide the other methods of implementing ... telling you that you need to refactor a new common superclass. ... Again, composition instead of inheritance. ... A StringVector cannot take Integer parameters. ...
    (comp.lang.java.programmer)
  • Re: Weird 0x80010105 error
    ... As for the proxy/stub DLL - simply rebuild and reregister it. ... In order to catch the crash, attach a debugger (or start in the ... > (client-side and server-side) components are running at the same computer. ... >>> interface I call a dedicated method, which will give me the interface. ...
    (microsoft.public.vc.atl)
  • Re: Do all OOM objects support the IMessage interface?
    ... works of a generic interface to Outlook items. ... the closest I have come to this with the OOM objects is the common ... if I could use the Outlook objects directly. ... > Why would adding a new sticky nore fire the OnSubmit callback? ...
    (microsoft.public.win32.programmer.messaging)
Loading