com.h

Go to the documentation of this file.

 
#ifndef WINPR_COM_H
#define WINPR_COM_H
 
#include <string.h>
 
#include <winpr/platform.h>
#include <winpr/winpr.h>
#include <winpr/wtypes.h>
#include <winpr/error.h>
 
#if defined(_WIN32)
#define WINPR_COM_CALL __stdcall
#else
#define WINPR_COM_CALL
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef struct wIUnknown wIUnknown;
 
  typedef struct
  {
    HRESULT(WINPR_COM_CALL* QueryInterface)
    (wIUnknown* This, const IID* riid, void** ppvObject);
    ULONG(WINPR_COM_CALL* AddRef)(wIUnknown* This);
    ULONG(WINPR_COM_CALL* Release)(wIUnknown* This);
  } wIUnknownVtbl;
 
#ifdef __cplusplus
}
#endif
 
#if defined(__cplusplus) && !defined(WINPR_COM_CINTERFACE)
struct wIUnknown
{
  virtual HRESULT WINPR_COM_CALL QueryInterface(const IID* riid, void** ppvObject) = 0;
  virtual ULONG WINPR_COM_CALL AddRef() = 0;
  virtual ULONG WINPR_COM_CALL Release() = 0;
 
  protected:
  /* not virtual, which would add vtable entries: objects are freed by Release() */
  ~wIUnknown() = default;
};
#else
struct wIUnknown
{
  const wIUnknownVtbl* lpVtbl;
};
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define WINPR_COM_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
  static const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
 
  WINPR_COM_DEFINE_GUID(WINPR_IID_IUnknown, 0x00000000, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00,
                        0x00, 0x00, 0x00, 0x46);
 
  static inline BOOL winpr_com_guid_equal(const GUID* a, const GUID* b)
  {
    return memcmp(a, b, sizeof(*a)) == 0;
  }
 
#define WINPR_COM_GUID_FMT                                                                      \
  "{%08" PRIX32 "-%04" PRIX16 "-%04" PRIX16 "-%02" PRIX8 "%02" PRIX8 "-%02" PRIX8 "%02" PRIX8 \
  "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "}"
#define WINPR_COM_GUID_ARGS(g)                                                                \
  (UINT32)(g)->Data1, (UINT16)(g)->Data2, (UINT16)(g)->Data3, (g)->Data4[0], (g)->Data4[1], \
      (g)->Data4[2], (g)->Data4[3], (g)->Data4[4], (g)->Data4[5], (g)->Data4[6], (g)->Data4[7]
 
#define WINPR_COM_IUNKNOWN_VTBL(obj) ((const wIUnknownVtbl*)(obj)->lpVtbl)
 
#define WINPR_COM_QUERY_INTERFACE(obj, iid, ppv) \
  (WINPR_COM_IUNKNOWN_VTBL(obj)->QueryInterface((wIUnknown*)(obj), (iid), (void**)(ppv)))
#define WINPR_COM_ADDREF(obj) (WINPR_COM_IUNKNOWN_VTBL(obj)->AddRef((wIUnknown*)(obj)))
#define WINPR_COM_RELEASE(obj) (WINPR_COM_IUNKNOWN_VTBL(obj)->Release((wIUnknown*)(obj)))
 
  /* ---- implementing COM objects in C ----
   *
   * An object starts with a wComBase, whose first member is lpVtbl: a pointer to the object is
   * the pointer to its first interface, and methods cast This back to the object type.
   *
   *  typedef struct {
   *    wComBase com;   // IWTSFooService
   *    ...state...
   *  } CFooService;
   *
   *  WINPR_COM_IUNKNOWN_THUNKS(CFooService, &IID_IWTSFooService)
   *  static const IWTSFooServiceVtbl vtbl = {
   *    .iunknown = WINPR_COM_IUNKNOWN_ENTRIES(CFooService),
   *    .DoSomething = CFooService_DoSomething,
   *  };
   *  ...
   *  winpr_com_base_init(&foo->com, "CFooService", &vtbl.iunknown, CFooService_free);
   *  return (IWTSFooService*)foo;
   *
   * WINPR_COM_IUNKNOWN_THUNKS answers QueryInterface for IUnknown and one interface. An object
   * with several interfaces uses WINPR_COM_REFCOUNT_THUNKS and writes its own QueryInterface:
   * each interface not derived from the first one needs its own vtable pointer in the object,
   * QueryInterface hands out the address of that member, and the methods of that interface get
   * the object back from it. QueryInterface(IID_IUnknown) must always give the same pointer.
   */
 
  typedef struct s_wComBase wComBase;
 
  typedef void (*pfnwComBaseFree)(wComBase* object);
 
  struct s_wComBase
  {
    const wIUnknownVtbl* lpVtbl; /* the object's first interface, must stay first */
    volatile LONG refCount;
    const char* className; /* for logs */
    pfnwComBaseFree Free;
  };
 
  WINPR_API void winpr_com_base_init(wComBase* object, const char* className,
                                     const wIUnknownVtbl* vtbl, pfnwComBaseFree Free);
 
  WINPR_API ULONG winpr_com_base_add_ref(wComBase* object);
 
  WINPR_API ULONG winpr_com_base_release(wComBase* object);
 
  WINPR_API HRESULT winpr_com_base_query(wComBase* object, const IID* iid, const IID* riid,
                                         void** ppv);
 
/* The IUnknown entries of a vtable, as static functions of the including file: a vtable is then
 * a constant initializer (the address of a function imported from a DLL is not one for MSVC). */
 
#define WINPR_COM_REFCOUNT_THUNKS(prefix)                         \
  static ULONG WINPR_COM_CALL prefix##_AddRef(wIUnknown* This)  \
  {                                                             \
    return winpr_com_base_add_ref((wComBase*)This);           \
  }                                                             \
  static ULONG WINPR_COM_CALL prefix##_Release(wIUnknown* This) \
  {                                                             \
    return winpr_com_base_release((wComBase*)This);           \
  }
 
#define WINPR_COM_IUNKNOWN_THUNKS(prefix, iid)                                              \
  static HRESULT WINPR_COM_CALL prefix##_QueryInterface(wIUnknown* This, const IID* riid, \
                                                        void** ppvObject)                 \
  {                                                                                       \
    return winpr_com_base_query((wComBase*)This, (iid), riid, ppvObject);               \
  }                                                                                       \
  WINPR_COM_REFCOUNT_THUNKS(prefix)
 
#define WINPR_COM_IUNKNOWN_ENTRIES(prefix) \
  { prefix##_QueryInterface, prefix##_AddRef, prefix##_Release }
 
#ifdef __cplusplus
}
#endif
 
#endif /* WINPR_COM_H */