ndr.h

Go to the documentation of this file.

 
#ifndef WINPR_NDR_H_
#define WINPR_NDR_H_
 
#include <winpr/stream.h>
 
#define WINPR_NDR_PTR_NULL (0UL)
 
#define WINPR_NDR_SIMPLE_TYPE_DECL(PREFIX, LOWER, UPPER)                                          \
  WINPR_ATTR_NODISCARD                                                                          \
  WINPR_API BOOL PREFIX##_decoder_read_##LOWER(WinPrNdrDecoder* context, wStream* s, UPPER* v); \
  WINPR_ATTR_NODISCARD                                                                          \
  WINPR_API BOOL PREFIX##_decoder_read_##LOWER##_(WinPrNdrDecoder* context, wStream* s,         \
                                                  const void* hints, void* v);                  \
  WINPR_ATTR_NODISCARD                                                                          \
  WINPR_API BOOL PREFIX##_encoder_write_##LOWER(WinPrNdrEncoder* context, wStream* s, UPPER v); \
  WINPR_ATTR_NODISCARD                                                                          \
  WINPR_API BOOL PREFIX##_encoder_write_##LOWER##_(WinPrNdrEncoder* context, wStream* s,        \
                                                   const void* hints, const void* v);           \
  WINPR_API extern const WinPrNdrMessageDescr PREFIX##_##LOWER##_descr_s;                       \
  WINPR_ATTR_NODISCARD                                                                          \
  WINPR_API WinPrNdrMessageType PREFIX##_##LOWER##_descr(void)
 
#define WINPR_NDR_ARRAY_OF_TYPE_DECL(PREFIX, TYPE, UPPERTYPE)                                 \
  WINPR_ATTR_NODISCARD                                                                      \
  WINPR_API BOOL PREFIX##_decoder_read_##TYPE##Array(WinPrNdrDecoder* context, wStream* s,  \
                                                     const void* hints, void* v);           \
  WINPR_ATTR_NODISCARD                                                                      \
  WINPR_API BOOL PREFIX##_encoder_write_##TYPE##Array(WinPrNdrEncoder* context, wStream* s, \
                                                      const void* hints, const void* v);    \
  WINPR_API void PREFIX##_destroy_##TYPE##Array(const void* hints, void* obj);              \
  WINPR_API extern const WinPrNdrMessageDescr PREFIX##_##TYPE##Array_descr_s;               \
  WINPR_ATTR_NODISCARD                                                                      \
  WINPR_API WinPrNdrMessageType PREFIX##_##TYPE##Array_descr(void);                         \
                                                                                              \
  WINPR_ATTR_NODISCARD                                                                      \
  WINPR_API BOOL PREFIX##_decoder_read_##TYPE##VaryingArray(                                \
      WinPrNdrDecoder* context, wStream* s, const void* hints, void* v);                    \
  WINPR_ATTR_NODISCARD                                                                      \
  WINPR_API BOOL PREFIX##_encoder_write_##TYPE##VaryingArray(                               \
      WinPrNdrEncoder* context, wStream* s, const void* hints, const void* v);              \
  WINPR_API extern const WinPrNdrMessageDescr PREFIX##_##TYPE##VaryingArray_descr_s;        \
  WINPR_ATTR_NODISCARD                                                                      \
  WINPR_API WinPrNdrMessageType PREFIX##_##TYPE##VaryingArray_descr(void)
 
#define WINPR_NDR_STRUCT_MESSAGE_DEFINE(PREFIX, CTYPE)                                             \
  static BOOL PREFIX##_read(WinPrNdrDecoder* context, wStream* s, const void* hints, void* obj)  \
  {                                                                                              \
    WINPR_UNUSED(hints);                                                                       \
    return winpr_ndr_decoder_read_fromDescr(context, s, &PREFIX##_struct, obj);                \
  }                                                                                              \
  static BOOL PREFIX##_write(WinPrNdrEncoder* context, wStream* s, const void* hints,            \
                             const void* obj)                                                    \
  {                                                                                              \
    WINPR_UNUSED(hints);                                                                       \
    return winpr_ndr_encoder_write_fromDescr(context, s, &PREFIX##_struct, obj);               \
  }                                                                                              \
  static void PREFIX##_destroy(const void* hints, void* obj)                                     \
  {                                                                                              \
    WINPR_UNUSED(hints);                                                                       \
    winpr_ndr_struct_destroy(&PREFIX##_struct, obj);                                           \
  }                                                                                              \
  static void PREFIX##_dump(wLog* logger, UINT32 lvl, size_t indentLevel, const void* obj)       \
  {                                                                                              \
    winpr_ndr_struct_dump_fromDescr(logger, lvl, indentLevel, &PREFIX##_struct, obj);          \
  }                                                                                              \
  static const WinPrNdrMessageDescr PREFIX##_descr_s = { WINPR_NDR_ARITY_SIMPLE, sizeof(CTYPE),  \
                                                       PREFIX##_read,          PREFIX##_write, \
                                                       PREFIX##_destroy,       PREFIX##_dump }
 
#define WINPR_NDR_ARRAY_MESSAGE_DEFINE(PREFIX, ITEMPREFIX, CTYPE)                                 \
  static BOOL PREFIX##_read(WinPrNdrDecoder* context, wStream* s, const void* hints, void* obj) \
  {                                                                                             \
    return winpr_ndr_decoder_read_uconformant_array(context, s, hints, &ITEMPREFIX##_descr_s, \
                                                    obj);                                     \
  }                                                                                             \
  static BOOL PREFIX##_write(WinPrNdrEncoder* context, wStream* s, const void* hints,           \
                             const void* obj)                                                   \
  {                                                                                             \
    WINPR_ASSERT(hints);                                                                      \
    const WinPrNdrArrayHints* ahints = hints;                                                 \
    return winpr_ndr_encoder_write_uconformant_array(context, s, ahints->count,               \
                                                     &ITEMPREFIX##_descr_s, obj);             \
  }                                                                                             \
  static void PREFIX##_destroy(const void* hints, void* obj)                                    \
  {                                                                                             \
    WINPR_ASSERT(hints);                                                                      \
    const WinPrNdrArrayHints* ahints = hints;                                                 \
    CTYPE* items = obj;                                                                       \
    for (UINT32 i = 0; i < ahints->count; i++)                                                \
      ITEMPREFIX##_destroy(nullptr, &items[i]);                                             \
  }                                                                                             \
  static const WinPrNdrMessageDescr PREFIX##_descr_s = {                                        \
    WINPR_NDR_ARITY_ARRAYOF, sizeof(CTYPE),    PREFIX##_read,                                 \
    PREFIX##_write,          PREFIX##_destroy, nullptr                                        \
  }
 
#define WINPR_NDR_UNION_MESSAGE_DEFINE(PREFIX, CTYPE)                                              \
  static BOOL PREFIX##_read(WinPrNdrDecoder* context, wStream* s, const void* hints, void* obj)  \
  {                                                                                              \
    WINPR_ASSERT(hints);                                                                       \
    return winpr_ndr_decoder_read_union(context, s, &PREFIX##_union,                           \
                                        winpr_ndr_union_switch_value(&PREFIX##_union, hints),  \
                                        obj);                                                  \
  }                                                                                              \
  static BOOL PREFIX##_write(WinPrNdrEncoder* context, wStream* s, const void* hints,            \
                             const void* obj)                                                    \
  {                                                                                              \
    WINPR_ASSERT(hints);                                                                       \
    return winpr_ndr_encoder_write_union(context, s, &PREFIX##_union,                          \
                                         winpr_ndr_union_switch_value(&PREFIX##_union, hints), \
                                         obj);                                                 \
  }                                                                                              \
  static void PREFIX##_destroy(const void* hints, void* obj)                                     \
  {                                                                                              \
    if (hints)                                                                                 \
      winpr_ndr_union_destroy(&PREFIX##_union,                                               \
                              winpr_ndr_union_switch_value(&PREFIX##_union, hints), obj);    \
  }                                                                                              \
  static const WinPrNdrMessageDescr PREFIX##_descr_s = { WINPR_NDR_ARITY_SIMPLE, sizeof(CTYPE),  \
                                                       PREFIX##_read,          PREFIX##_write, \
                                                       PREFIX##_destroy,       nullptr }
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef struct WinPrNdrDecoder_s WinPrNdrDecoder;
 
  typedef struct WinPrNdrEncoder_s WinPrNdrEncoder;
 
  typedef UINT32 winpr_ndr_refid;
 
  typedef BOOL (*WINPR_NDR_READER_FN)(WinPrNdrDecoder* context, wStream* s, const void* hints,
                                      void* target);
 
  typedef BOOL (*WINPR_NDR_WRITER_FN)(WinPrNdrEncoder* context, wStream* s, const void* hints,
                                      const void* obj);
 
  typedef void (*WINPR_NDR_DESTROY_FN)(const void* hints, void* obj);
 
  typedef void (*WINPR_NDR_DUMP_FN)(wLog* logger, UINT32 lvl, size_t indentLevel,
                                    const void* obj);
 
  typedef enum
  {
    WINPR_NDR_ARITY_SIMPLE,          
    WINPR_NDR_ARITY_ARRAYOF,         
    WINPR_NDR_ARITY_VARYING_ARRAYOF, 
    WINPR_NDR_ARITY_SELF_ALLOCATED,  
  } WinPrNdrTypeArity;
 
  typedef struct
  {
    WinPrNdrTypeArity arity;
    size_t itemSize;                
    WINPR_NDR_READER_FN readFn;     
    WINPR_NDR_WRITER_FN writeFn;    
    WINPR_NDR_DESTROY_FN destroyFn; 
    WINPR_NDR_DUMP_FN dumpFn;       
  } WinPrNdrMessageDescr;
 
  typedef const WinPrNdrMessageDescr* WinPrNdrMessageType;
 
  typedef enum
  {
    WINPR_NDR_NOT_POINTER,      
    WINPR_NDR_POINTER_NON_NULL, 
    WINPR_NDR_POINTER,          
    WINPR_NDR_FIXED_ARRAY,      
    WINPR_NDR_POINTER_FULL      
  } WinPrNdrPointerType;
 
  typedef struct
  {
    const char* name;                
    size_t structOffset;             
    WinPrNdrPointerType pointerType; 
    SSIZE_T hintsField; 
    WinPrNdrMessageType typeDescr; 
    size_t fixedArraySize;         
    UINT32 rangeMax; 
  } WinPrNdrFieldStruct;
 
  typedef struct
  {
    const char* name;                  
    size_t nfields;                    
    const WinPrNdrFieldStruct* fields; 
    size_t alignment; 
  } WinPrNdrStructDescr;
 
  typedef struct
  {
    UINT32 discriminant;       
    WinPrNdrFieldStruct field; 
  } WinPrNdrUnionArm;
 
  typedef struct
  {
    const char* name;             
    size_t narms;                 
    const WinPrNdrUnionArm* arms; 
    size_t switchSize; 
    const WinPrNdrUnionArm* defaultArm; 
  } WinPrNdrUnionDescr;
 
  typedef struct
  {
    winpr_ndr_refid ptrId; 
    const char* name;      
    void* hints;           
    void* target;  
    BOOL allocate; 
    WinPrNdrMessageType msg; 
  } WinPrNdrDeferredEntry;
 
  WINPR_API void winpr_ndr_encoder_free(WinPrNdrEncoder* context);
 
  static INLINE void winpr_ndr_encoder_destroy(WinPrNdrEncoder** pcontext)
  {
    WINPR_ASSERT(pcontext);
    winpr_ndr_encoder_free(*pcontext);
    *pcontext = nullptr;
  }
 
  WINPR_ATTR_MALLOC(winpr_ndr_encoder_free, 1)
  WINPR_API WinPrNdrEncoder* winpr_ndr_encoder_new(BOOL bigEndianDrep, BYTE version);
 
  WINPR_ATTR_MALLOC(winpr_ndr_encoder_free, 1)
  WINPR_API WinPrNdrEncoder* winpr_ndr_encoder_from_decoder(const WinPrNdrDecoder* src);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_header(WinPrNdrEncoder* context, wStream* s);
 
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, uint8, UINT8);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, int8, INT8);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, uint16, UINT16);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, int16, INT16);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, int32, INT32);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, uint32, UINT32);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, int64, INT64);
  WINPR_NDR_SIMPLE_TYPE_DECL(winpr_ndr, uint64, UINT64);
 
  WINPR_NDR_ARRAY_OF_TYPE_DECL(winpr_ndr, uint8, BYTE);
  WINPR_NDR_ARRAY_OF_TYPE_DECL(winpr_ndr, uint16, UINT16);
 
  WINPR_API void winpr_ndr_encoder_bytes_written(WinPrNdrEncoder* context, size_t len);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_align(WinPrNdrEncoder* context, wStream* s, size_t sz);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_data(WinPrNdrEncoder* context, wStream* s,
                                              const void* data, size_t sz);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_start_object(WinPrNdrEncoder* context, wStream* s);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_end_object(WinPrNdrEncoder* context, wStream* s);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_toplevel_refid(WinPrNdrEncoder* context, wStream* s);
 
  typedef struct
  {
    UINT32 length;    
    UINT32 maxLength; 
  } WinPrNdrVaryingArrayHints;
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_uconformant_varying_array(
      WinPrNdrEncoder* context, wStream* s, const WinPrNdrVaryingArrayHints* hints,
      WinPrNdrMessageType itemType, const void* src);
 
  typedef struct
  {
    UINT32 count; 
  } WinPrNdrArrayHints;
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_uconformant_array(WinPrNdrEncoder* context, wStream* s,
                                                           UINT32 len,
                                                           WinPrNdrMessageType itemType,
                                                           const BYTE* ptr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_fromDescr(WinPrNdrEncoder* context, wStream* s,
                                                   const WinPrNdrStructDescr* descr,
                                                   const void* src);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_union(WinPrNdrEncoder* context, wStream* s,
                                               const WinPrNdrUnionDescr* descr,
                                               UINT32 switchValue, const void* src);
 
  WINPR_ATTR_NODISCARD
  WINPR_API winpr_ndr_refid winpr_ndr_pointer_refid(const void* ptr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_allocatePtr(WinPrNdrEncoder* context, const void* ptr,
                                               winpr_ndr_refid* prefId, BOOL* pnewPtr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_treat_deferreds(WinPrNdrEncoder* context, wStream* s);
 
  /* ====================================== decoder ========================================= */
 
  WINPR_API void winpr_ndr_decoder_free(WinPrNdrDecoder* context);
 
  static INLINE void winpr_ndr_decoder_destroy(WinPrNdrDecoder** pcontext)
  {
    WINPR_ASSERT(pcontext);
    winpr_ndr_decoder_free(*pcontext);
    *pcontext = nullptr;
  }
 
  WINPR_ATTR_MALLOC(winpr_ndr_decoder_free, 1)
  WINPR_API WinPrNdrDecoder* winpr_ndr_decoder_new(BOOL bigEndianDrep, BYTE version);
 
  WINPR_ATTR_MALLOC(winpr_ndr_decoder_free, 1)
  WINPR_API WinPrNdrDecoder* winpr_ndr_decoder_new_fromStream(wStream* s);
 
  WINPR_API void winpr_ndr_decoder_bytes_read(WinPrNdrDecoder* context, size_t len);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_object(WinPrNdrDecoder* context, wStream* s,
                                               wStream* object);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_push_deferreds(WinPrNdrDecoder* context,
                                                  WinPrNdrDeferredEntry* deferreds,
                                                  size_t ndeferred);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_treat_deferreds(WinPrNdrDecoder* context, wStream* s);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_refpointer(WinPrNdrDecoder* context, wStream* s,
                                                   UINT32* refId);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_pointer_ex(WinPrNdrDecoder* context, wStream* s,
                                                   const char* name, WinPrNdrMessageType descr,
                                                   void* hints, void** target);
 
  WINPR_API void winpr_ndr_pointer_release(void* ptr);
 
  WINPR_ATTR_MALLOC(winpr_ndr_pointer_release, 1)
  WINPR_API void* winpr_ndr_pointer_new(WinPrNdrMessageType descr, const void* hints,
                                        size_t size);
 
  WINPR_API void* winpr_ndr_pointer_ref(void* ptr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API size_t winpr_ndr_pointer_size(const void* ptr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_skip_bytes(WinPrNdrDecoder* context, wStream* s,
                                              size_t nbytes);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_align(WinPrNdrDecoder* context, wStream* s, size_t sz);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_wchar(WinPrNdrDecoder* context, wStream* s, WCHAR* ptr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_encoder_write_wchar(WinPrNdrEncoder* context, wStream* s,
                                               const WCHAR* ptr);
 
  WINPR_API extern const WinPrNdrMessageDescr winpr_ndr_wchar_descr_s;
 
  WINPR_ATTR_NODISCARD
  WINPR_API WinPrNdrMessageType winpr_ndr_wchar_descr(void);
 
  WINPR_NDR_ARRAY_OF_TYPE_DECL(winpr_ndr, wchar, WCHAR);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_pointedMessageEx(WinPrNdrDecoder* context, wStream* s,
                                                         winpr_ndr_refid ptrId,
                                                         WinPrNdrMessageType descr, void* hints,
                                                         void** target);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_fromDescr(WinPrNdrDecoder* context, wStream* s,
                                                  const WinPrNdrStructDescr* descr, void* target);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_union(WinPrNdrDecoder* context, wStream* s,
                                              const WinPrNdrUnionDescr* descr, UINT32 switchValue,
                                              void* target);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_uconformant_array(WinPrNdrDecoder* context, wStream* s,
                                                          const WinPrNdrArrayHints* hints,
                                                          WinPrNdrMessageType itemType,
                                                          void* vtarget);
 
  WINPR_ATTR_NODISCARD
  WINPR_API BOOL winpr_ndr_decoder_read_uconformant_varying_array(
      WinPrNdrDecoder* context, wStream* s, const WinPrNdrVaryingArrayHints* hints,
      WinPrNdrMessageType itemType, void* ptarget);
 
  WINPR_API extern const WinPrNdrMessageDescr winpr_ndr_string_conformant_descr_s;
 
  WINPR_ATTR_NODISCARD
  WINPR_API WinPrNdrMessageType winpr_ndr_string_conformant_descr(void);
 
  WINPR_API extern const WinPrNdrMessageDescr winpr_ndr_string_varying_descr_s;
 
  WINPR_ATTR_NODISCARD
  WINPR_API WinPrNdrMessageType winpr_ndr_string_varying_descr(void);
 
  WINPR_API extern const WinPrNdrMessageDescr winpr_ndr_wstring_varying_descr_s;
 
  WINPR_ATTR_NODISCARD
  WINPR_API WinPrNdrMessageType winpr_ndr_wstring_varying_descr(void);
 
  WINPR_API void winpr_ndr_struct_dump_fromDescr(wLog* logger, UINT32 lvl, size_t identLevel,
                                                 const WinPrNdrStructDescr* descr,
                                                 const void* obj);
 
  WINPR_API void winpr_ndr_struct_destroy(const WinPrNdrStructDescr* descr, void* pptr);
 
  WINPR_ATTR_NODISCARD
  WINPR_API UINT32 winpr_ndr_union_switch_value(const WinPrNdrUnionDescr* descr,
                                                const void* switchField);
 
  WINPR_API void winpr_ndr_union_destroy(const WinPrNdrUnionDescr* descr, UINT32 switchValue,
                                         void* obj);
 
#ifdef __cplusplus
}
#endif
 
#endif /* WINPR_NDR_H_ */