/*++

Copyright (C) Microsoft Corporation, All Rights Reserved

Module Name:

ComSup.cpp

Abstract:

This module contains implementations for the functions and methods

used for providing COM support.

Environment:

Windows User-Mode Driver Framework (WUDF)

--*/

#include "internal.h"

#include "comsup.tmh"

//

// Implementation of CUnknown methods.

//

CUnknown::CUnknown(

VOID

) : m_ReferenceCount(1)

/*++

Routine Description:

Constructor for an instance of the CUnknown class. This simply initializes

the reference count of the object to 1. The caller is expected to

call Release() if it wants to delete the object once it has been allocated.

Arguments:

None

Return Value:

None

--*/

{

// do nothing.

}

HRESULT

STDMETHODCALLTYPE

CUnknown::QueryInterface(

_In_ REFIID InterfaceId,

_Out_ PVOID *Object

)

/*++

Routine Description:

This method provides the basic support for query interface on CUnknown.

If the interface requested is IUnknown it references the object and

returns an interface pointer. Otherwise it returns an error.

Arguments:

InterfaceId - the IID being requested

Object - a location to store the interface pointer to return.

Return Value:

S_OK or E_NOINTERFACE

--*/

{

if (IsEqualIID(InterfaceId, __uuidof(IUnknown)))

{

*Object = QueryIUnknown();

return S_OK;

}

else

{

*Object = NULL;

return E_NOINTERFACE;

}

}

IUnknown *

CUnknown::QueryIUnknown(

VOID

)

/*++

Routine Description:

This helper method references the object and returns a pointer to the

object's IUnknown interface.

This allows other methods to convert a CUnknown pointer into an IUnknown

pointer without a typecast and without calling QueryInterface and dealing

with the return value.

Arguments:

None

Return Value:

A pointer to the object's IUnknown interface.

--*/

{

AddRef();

return static_cast<IUnknown *>(this);

}

ULONG

STDMETHODCALLTYPE

CUnknown::AddRef(

VOID

)

/*++

Routine Description:

This method adds one to the object's reference count.

Arguments:

None

Return Value:

The new reference count. The caller should only use this for debugging

as the object's actual reference count can change while the caller

examines the return value.

--*/

{

return InterlockedIncrement(&m_ReferenceCount);

}

ULONG

STDMETHODCALLTYPE

CUnknown::Release(

VOID

)

/*++

Routine Description:

This method subtracts one to the object's reference count. If the count

goes to zero, this method deletes the object.

Arguments:

None

Return Value:

The new reference count. If the caller uses this value it should only be

to check for zero (i.e. this call caused or will cause deletion) or

non-zero (i.e. some other call may have caused deletion, but this one

didn't).

--*/

{

ULONG count = InterlockedDecrement(&m_ReferenceCount);

if (count == 0)

{

delete this;

}

return count;

}

//

// Implementation of CClassFactory methods.

//

//

// Define storage for the factory's static lock count variable.

//

LONG CClassFactory::s_LockCount = 0;

IClassFactory *

CClassFactory::QueryIClassFactory(

VOID

)

/*++

Routine Description:

This helper method references the object and returns a pointer to the

object's IClassFactory interface.

This allows other methods to convert a CClassFactory pointer into an

IClassFactory pointer without a typecast and without dealing with the

return value QueryInterface.

Arguments:

None

Return Value:

A referenced pointer to the object's IClassFactory interface.

--*/

{

AddRef();

return static_cast<IClassFactory *>(this);

}

HRESULT

CClassFactory::QueryInterface(

_In_ REFIID InterfaceId,

_Out_ PVOID *Object

)

/*++

Routine Description:

This method attempts to retrieve the requested interface from the object.

If the interface is found then the reference count on that interface (and

thus the object itself) is incremented.

Arguments:

InterfaceId - the interface the caller is requesting.

Object - a location to store the interface pointer.

Return Value:

S_OK or E_NOINTERFACE

--*/

{

//

// This class only supports IClassFactory so check for that.

//

if (IsEqualIID(InterfaceId, __uuidof(IClassFactory)))

{

*Object = QueryIClassFactory();

return S_OK;

}

else

{

//

// See if the base class supports the interface.

//

return CUnknown::QueryInterface(InterfaceId, Object);

}

}

HRESULT

STDMETHODCALLTYPE

CClassFactory::CreateInstance(

_In_opt_ IUnknown * /* OuterObject */,

_In_ REFIID InterfaceId,

_Out_ PVOID *Object

)

/*++

Routine Description:

This COM method is the factory routine - it creates instances of the driver

callback class and returns the specified interface on them.

Arguments:

OuterObject - only used for aggregation, which our driver callback class

does not support.

InterfaceId - the interface ID the caller would like to get from our

new object.

Object - a location to store the referenced interface pointer to the new

object.

Return Value:

Status.

--*/

{

HRESULT hr;

PCMyDriver driver;

*Object = NULL;

hr = CMyDriver::CreateInstance(&driver);

if (SUCCEEDED(hr))

{

hr = driver->QueryInterface(InterfaceId, Object);

driver->Release();

}

return hr;

}

HRESULT

STDMETHODCALLTYPE

CClassFactory::LockServer(

_In_ BOOL Lock

)

/*++

Routine Description:

This COM method can be used to keep the DLL in memory. However since the

driver's DllCanUnloadNow function always returns false, this has little

effect. Still it tracks the number of lock and unlock operations.

Arguments:

Lock - Whether the caller wants to lock or unlock the "server"

Return Value:

S_OK

--*/

{

if (Lock)

{

InterlockedIncrement(&s_LockCount);

}

else

{

InterlockedDecrement(&s_LockCount);

}

return S_OK;

}