Creating a Component (Recap)

• Define the interfaces for the component and assign them

IIDs
• Define a class implementing the interfaces of the
Local/Remote Transparency component and assign it a CLSID
• Define the class factory which implements at least the
IClassFactory interface for creating the component
• Create a DLL and export the function
DLLGetClassObject which provides the class factory
interface
• Register the component with the Windows Registry
• The DLL is an in-proc server for the component

Check the registry

Client: usage sequence (Recap)
for the server
Servers in EXEs
Client COM Library DLL • Every EXE runs in a different process
Calls CoGetClassObject CoGetClassObject
CoGetClassObject DllGetClassObject
DllGetClassObject • Every process has a separate address space
creates Process 1
returns IClassFactory CFactory Process 1 address space
0x00001234
Calls CreateInstance pFoo 0x0000ABBA
pIClassFactory IClassFactory
IClassFactory pFoo

creates
returns ISprite Process 2
Sprite
Process 2 address space 0x0BAD0ADD
pISprite uses ISprite ISprite
ISprite
pFoo 0x0000ABBA
pFoo

• DLL is called an in-process (in-proc) server Interface and Process boundary

• EXE is an out-of-process (out-of-proc) server
called local server
• Out-of-process server may reside on a
different machine, in which case it is called
remote server
• Interface is an array of function pointers
which the client should be able to access
– easy with an in-proc server sharing the same
address space
• For an interface to cross a process boundary
following conditions should be satisfied
– a process needs to be able to call a function in
another process
– process should be able to pass data to another
process
– client should not care whether it is accessing
in-proc or out-of-proc components

1
Local Procedure Call (LPC)
• LPCs are for communication between
different processes on the same machine
– single machine, inter-process communication
technique based on remote procedure call (RPC)
• Implemented by the operating system
– OS knows the physical addresses of the
corresponding logical address for each process
• OS can call functions in any process
IMarshal
• IMarshal is an interface used by COM to
marshal and unmarshal the parameters
before and after calling the functions
• COM queries the component for
IMarshal as part of the creation strategy
• A standard IMarshal implementation is
provided by the COM library
• A custom version of IMarshal could be
implemented for optimising performance
EXE
Client
in-proc service
EXE
process boundary
Client
DLL Proxy
Proxy
out-of-proc service
Marshaling
• Marshaling is, passing of parameters from
the address space of the client to the address
space of the component
• Local Server
– data in one process needs to be copied to the
address space of the other process
• Remote Server
– data has to be put in a standard format to
account for difference between machine
Proxy / Stub
• The client should communicate with in-proc,
local and remote server in the same way
• Proxy is a DLL to which the client talks
– it mimics the component
– does the marshaling and LPC calls for the client
• Stub is the DLL which the component uses
– unmarshals the data sent from the client
– marshals the data to be sent to the client
DLL
Component
Component
Interface Description Language
• IDL richly describes the interface and data
shared by the client and the component
EXE
• From Open Software Foundation’s (OSF)
Distributed Computing Environment (DCE)
Component • COM use a subset of IDL with several non-
standard extensions to describe interfaces
Stub DLL
Stub • IDL syntax resembles C++ and is easy to use
than directly writing code for proxy and stub
2
 import " unknwn.idl" ; includes definitions from other IDL file
[
// Interface ISprite attribute list uuid(B0A0A1E2 -00EC- 11d2- 9B2C-00C04FCCA483),
[ version(1.0),
object, interface is a COM interface helpstring("Sprite1.0 For LocalServer")
uuid(B0A0A1E0 -00EC- 11d2- 9B2C-00C04FCCA483), interface IID ]
helpstring("ISprite interface"),
pointer_default(unique) how to treat pointers library SpriteTypeLibrary
] {
importlib("stdole32.tlb") ;
// Interface ISprite description MIDL requires COM interface
interface ISprite : IUnknown functions to return HRESULT // Sprite implementation
{ [
HRESULT Load( [in] char* fileName ) = 0; uuid(B0A0A1E1 -00EC- 11d2- 9B2C-00C04FCCA483), class CLSID
HRESULT SetPose( [in] int pose ) = 0; helpstring("Sprite Class For Local Server")
HRESULT SetPosition ( [in] int x, [in] int y) = 0; ]
coclass Sprite class Sprite implements the
HRESULT Draw( [in] HWND win ) = 0; { ISprite interface
}; [default ] interface ISprite;
};
[in] parameter goes from the client to the component, stub does not send information back };
All this goes into a file sprite.idl
[out] parameter goes from the component to the client , proxy does not need to marshal

midl /h sprite.h /iid guid.c /proxy proxy.c

MIDL /dlldata dlldata .c sprite. idl

• Compiles the IDL file to generate code for the Will generate,
DLL that implements proxy and stub sprite.h , guid.c, proxy.c and dlldata .c
midl sprite.idl
Generates, You provide,
sprite.h defines interfaces described in the IDL file proxy.def exporting functions for the proxy/stub DLL
sprite_i.c defines the GUIDs used in the IDL file sprite. cpp implementing the component for the
sprite_p.c implements the proxy and stub for interfaces component’s server
described in the IDL file client. cpp implementing the client
dlldata .c implements the DLL that contain the proxy and
stub code

; proxy.def file

LIBRARY proxy.dll
DESCRIPTION ’Proxy/Stub DLL' Registering the Proxy/Stub
EXPORTS
DllGetClassObject @1 PRIVATE
• Define REGISTER_PROXY_DLL for
DllCanUnloadNow @2 PRIVATE compiling files proxy.c and dlldata.c
GetProxyDllInfo @3 PRIVATE
DllRegisterServer @4 PRIVATE – code for registering proxy/stub is generated
DllUnegisterServer @5 PRIVATE
• Proxy is registered using
guids.c regsvr32 /s proxy.dll
sprite.idl midl.exe proxy.c Compiler
and
• Makes an entry into the registry indicating
dlldata.c Linker – ISprite is served by a proxy/stub
sprite.h
Building the Proxy DLL proxy.dll
– in-proc server is proxy.dll

3
 Local Server implementation CoRegisterClassObject
CoCreateInstance->CoGetClassObject- >->DllGetClassObject
= IClassFactory pointer for creating components using
• CoRegisterClassObject is used by
in-proc server the local server to register class factories
• Local server is an EXE
STDAPI CoRegisterClassObject(
– cannot export functions
REFCLSID clsid , // Component class id.
– has to have a main
IUnknown* iUnknown, // Factory interface
• COM maintains a private table of registered DWORD dwClsContext, // Server context
class factories DWORD flags, // connection type
• CoGetClassObject first checks the LPDWORD ppv ); // return registration id.

private table and then checks the Registry

void main(int argc, char* argv [])

{
HRESULT hr;
Initialize COM for free-threading • No export functions DllGetClassObject,
hr = CoInitializeEx (NULL, COINIT_MULTITHREADED) ;
if (FAILED(hr)) return; // cannot initialize COM DllCanUnloadNow, DllRegisterServer
DWORD dwRegister;
Register the Class Factory DllUnegisterServer
IClassFactory * pIFactory = new CFactory;
• Define _WIN32_DCOM while compiling
hr = ::CoRegisterClassObject(CLSID_Sprite,
static_cast<IUnknown*>(pIFactory), sprite.cpp if you have to use
inproc-server for itself CLSCTX_SERVER , REGCLS_MULTIPLEUSE,
&dwRegister); can server multiple clients CoInitializeEx for free-threading
if (FAILED(hr)) return; // Cannot register factory
guids.c
char choice; Compiler
while (cin >> choice) { Wait for user input to shutdown the server sprite.cpp
and
if (choice == 'q') break;
} sprite.h Linker
Unregister the Class Factory
::CoRevokeClassObject(dwRegister);
pIFactory->Release();
• Run sprite.exe to sprite.exe

CoUninitialize(); start the server

}

Client Going Remote

int main()
{ • No changes are required in the client or the
CoInitialize(NULL);
local server to distribute them on two
ISprite* pISprite = NULL;
HRESULT hr = :: CoCreateInstance ( CLSID_Sprite, NULL,
CLSCTX_ALL ,
separate machines connected by a network
Any server
IID_ ISprite,
(void**)&pISprite ); • Operating system support for Distributed
if (SUCCEEDED(hr)) { COM (DCOM ) is required
// Use the sprite
– Windows NT 4.0, Windows 95 with DCOM
pISprite ->Release();
}
Compile and link with guids.c
• There should be an entry in the registry
CoUninitialize();
return 0; indicating that the server is remote
}

4
DCOMCNFG.EXE Registry entry
• A DCOM configuration tool allows to set
HKEY_CLASSES_ROOT\
various parameters of the application CLSID\

– set application parameters to indicate whether it

runs locally or remotely
– set the name of the server which will run the
application, in case it runs remotely HKEY_CLASSES_ROOT\
AppID\

• DCOMCNFG.EXE makes the appropriate

changes in the registry

How does it work ? CoCreateInstanceEx

• DCOM enhances the COM library
implementation of
CoGetClassObject
• CoGetClassObject does the following
– locates the CLSID in the registry
– checks whether it has an AppID
– locates the AppId entry and checks for the
RemoteServerName
– attempts to run the server remotely
• Client can specify in the program that it wants
to access a remote server
• Retreive multiple interfaces to the component
HRESULT __stdcall CoCreateInstanceEx (
const CLSID& clsid, //Component class id.
IUnknown* iUnknown, //for aggregation
DWORD dwClsContext, //Server context
CONSERVERINFO* pServerInfo , //Server info
ULONG cmq , //count of interfaces requested
MULTI_QI* pResults); //interfaces returned

MULTI_QI Summary
• Structure defined by DCOM to query for • IDL helps a lot in creating out-of-proc
several interfaces in one call components
typedef struct _MULTI_QI { • DCOM helps in converting local servers to
const IID* pIID, //interface id.
remote servers just by making changes in
IUnknown* pItf , //interface requested
the Registry
HRESULT hr //QueryInterface return value
} MULTI_QI;
• Remote proxy provides implementation for
an interface IMultiQI which has a
funtion QueryMultipleInterfaces