ndr.h File Reference

NDR encoder and decoder ([C706] chapter 14, [MS-RPCE] 2.2.5 and 2.2.6) More...

#include <winpr/stream.h>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	WinPrNdrMessageDescr
	message descriptor More...
struct	WinPrNdrFieldStruct
	descriptor of a field in a structure More...
struct	WinPrNdrStructDescr
	structure descriptor More...
struct	WinPrNdrUnionArm
	an arm of a non-encapsulated union More...
struct	WinPrNdrUnionDescr
	a non-encapsulated union ([switch_type()]) More...
struct	WinPrNdrDeferredEntry
	a deferred pointer, a referent to read after the current construct More...
struct	WinPrNdrVaryingArrayHints
	hints for a conformant varying array More...
struct	WinPrNdrArrayHints
	hints for a conformant array More...

Macros
#define	WINPR_NDR_PTR_NULL   (0UL)
	the referent id of a null pointer
#define	WINPR_NDR_SIMPLE_TYPE_DECL(PREFIX, LOWER, UPPER)
	declares the functions and the message descriptor of a simple type
#define	WINPR_NDR_ARRAY_OF_TYPE_DECL(PREFIX, TYPE, UPPERTYPE)
	declares the functions and the message descriptors of the arrays of a simple type
#define	WINPR_NDR_STRUCT_MESSAGE_DEFINE(PREFIX, CTYPE)
	defines a static message type for a structure
#define	WINPR_NDR_ARRAY_MESSAGE_DEFINE(PREFIX, ITEMPREFIX, CTYPE)
	defines a static message type for a conformant array of ITEMPREFIX##_descr_s items
#define	WINPR_NDR_UNION_MESSAGE_DEFINE(PREFIX, CTYPE)
	defines a static message type for a non-encapsulated union

Typedefs
typedef UINT32	winpr_ndr_refid
	a referent id, the wire value of a pointer (WINPR_NDR_PTR_NULL for a null pointer)
typedef BOOL(*	WINPR_NDR_READER_FN) (WinPrNdrDecoder *context, wStream *s, const void *hints, void *target)
	reads a message
typedef BOOL(*	WINPR_NDR_WRITER_FN) (WinPrNdrEncoder *context, wStream *s, const void *hints, const void *obj)
	writes a message
typedef void(*	WINPR_NDR_DESTROY_FN) (const void *hints, void *obj)
	releases the content of a message, not the message storage itself
typedef void(*	WINPR_NDR_DUMP_FN) (wLog *logger, UINT32 lvl, size_t indentLevel, const void *obj)
	dumps a message in the logs
typedef const WinPrNdrMessageDescr *	WinPrNdrMessageType
	a message type, a pointer on its descriptor

Enumerations
enum	WinPrNdrTypeArity { WINPR_NDR_ARITY_SIMPLE , WINPR_NDR_ARITY_ARRAYOF , WINPR_NDR_ARITY_VARYING_ARRAYOF , WINPR_NDR_ARITY_SELF_ALLOCATED }
	arity of a message More...
enum	WinPrNdrPointerType {   WINPR_NDR_NOT_POINTER , WINPR_NDR_POINTER_NON_NULL , WINPR_NDR_POINTER , WINPR_NDR_FIXED_ARRAY ,   WINPR_NDR_POINTER_FULL }
	pointer or not and if null is accepted More...

Functions
WINPR_API void	winpr_ndr_encoder_free (WinPrNdrEncoder *context)
	frees an encoder
static INLINE void	winpr_ndr_encoder_destroy (WinPrNdrEncoder **pcontext)
	frees an encoder and resets the pointer
WINPR_API WinPrNdrEncoder *	winpr_ndr_encoder_new (BOOL bigEndianDrep, BYTE version)
	creates an encoder
WINPR_API WinPrNdrEncoder *	winpr_ndr_encoder_from_decoder (const WinPrNdrDecoder *src)
	creates an encoder with the same endianness and version as a decoder, to answer the message it decoded
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_header (WinPrNdrEncoder *context, wStream *s)
	writes the common type header ([MS-RPCE] 2.2.6.1): version, endianness, header length and filler
	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)
	accounts for bytes written directly in the stream, for the alignments
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_align (WinPrNdrEncoder *context, wStream *s, size_t sz)
	writes zero padding to align the current object offset
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_data (WinPrNdrEncoder *context, wStream *s, const void *data, size_t sz)
	writes raw bytes, without alignment
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_start_object (WinPrNdrEncoder *context, wStream *s)
	starts a serialized object ([MS-RPCE] 2.2.6 type serialization version 1)
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_end_object (WinPrNdrEncoder *context, wStream *s)
	ends the serialized object started with winpr_ndr_encoder_start_object()
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_toplevel_refid (WinPrNdrEncoder *context, wStream *s)
	writes a new referent id for a non-null top-level pointer
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)
	writes a conformant varying array: its maximum count, offset 0, actual count and the items
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_uconformant_array (WinPrNdrEncoder *context, wStream *s, UINT32 len, WinPrNdrMessageType itemType, const BYTE *ptr)
	writes a conformant array: its count and the items
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_fromDescr (WinPrNdrEncoder *context, wStream *s, const WinPrNdrStructDescr *descr, const void *src)
	writes a structure from its descriptor
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_union (WinPrNdrEncoder *context, wStream *s, const WinPrNdrUnionDescr *descr, UINT32 switchValue, const void *src)
	writes the discriminant and the arm of a union
WINPR_ATTR_NODISCARD WINPR_API winpr_ndr_refid	winpr_ndr_pointer_refid (const void *ptr)
	a referent id built from the value of a pointer
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_allocatePtr (WinPrNdrEncoder *context, const void *ptr, winpr_ndr_refid *prefId, BOOL *pnewPtr)
	allocates the referent id of an embedded pointer
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_treat_deferreds (WinPrNdrEncoder *context, wStream *s)
	writes the pending deferred referents
WINPR_API void	winpr_ndr_decoder_free (WinPrNdrDecoder *context)
	frees a decoder
static INLINE void	winpr_ndr_decoder_destroy (WinPrNdrDecoder **pcontext)
	frees a decoder and resets the pointer
WINPR_API WinPrNdrDecoder *	winpr_ndr_decoder_new (BOOL bigEndianDrep, BYTE version)
	creates a decoder
WINPR_API WinPrNdrDecoder *	winpr_ndr_decoder_new_fromStream (wStream *s)
	reads the common type header ([MS-RPCE] 2.2.6.1) and creates a decoder for its version and endianness
WINPR_API void	winpr_ndr_decoder_bytes_read (WinPrNdrDecoder *context, size_t len)
	accounts for bytes read directly from the stream, for the alignments
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_object (WinPrNdrDecoder *context, wStream *s, wStream *object)
	reads the private header of a serialized object ([MS-RPCE] 2.2.6 type serialization version 1)
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_push_deferreds (WinPrNdrDecoder *context, WinPrNdrDeferredEntry *deferreds, size_t ndeferred)
	adds deferred pointers, read by the next winpr_ndr_decoder_treat_deferreds()
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_treat_deferreds (WinPrNdrDecoder *context, wStream *s)
	reads the pending deferred referents
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_refpointer (WinPrNdrDecoder *context, wStream *s, UINT32 *refId)
	reads a referent id
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)
	reads a full pointer ([ptr])
WINPR_API void	winpr_ndr_pointer_release (void *ptr)
	releases a referent
WINPR_API void *	winpr_ndr_pointer_new (WinPrNdrMessageType descr, const void *hints, size_t size)
	allocates a referent
WINPR_API void *	winpr_ndr_pointer_ref (void *ptr)
	takes a reference on a referent
WINPR_ATTR_NODISCARD WINPR_API size_t	winpr_ndr_pointer_size (const void *ptr)
	the size of a referent, as allocated by winpr_ndr_pointer_new()
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_skip_bytes (WinPrNdrDecoder *context, wStream *s, size_t nbytes)
	skips bytes
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_align (WinPrNdrDecoder *context, wStream *s, size_t sz)
	skips the padding to align the current object offset
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_wchar (WinPrNdrDecoder *context, wStream *s, WCHAR *ptr)
	reads a WCHAR, aligned on 2 bytes
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_encoder_write_wchar (WinPrNdrEncoder *context, wStream *s, const WCHAR *ptr)
	writes a WCHAR stored in UTF-16LE, aligned on 2 bytes
WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType	winpr_ndr_wchar_descr (void)
	the message type of winpr_ndr_wchar_descr_s
	WINPR_NDR_ARRAY_OF_TYPE_DECL (winpr_ndr, wchar, WCHAR)
	the arrays of WCHAR, stored in UTF-16LE in memory: use them for strings instead of the uint16 arrays, which store the items in host byte order
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)
	reads the referent of a unique pointer
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_fromDescr (WinPrNdrDecoder *context, wStream *s, const WinPrNdrStructDescr *descr, void *target)
	reads a structure from its descriptor
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_union (WinPrNdrDecoder *context, wStream *s, const WinPrNdrUnionDescr *descr, UINT32 switchValue, void *target)
	reads a union, its discriminant must be switchValue
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_uconformant_array (WinPrNdrDecoder *context, wStream *s, const WinPrNdrArrayHints *hints, WinPrNdrMessageType itemType, void *vtarget)
	reads a conformant array: its count and the items
WINPR_ATTR_NODISCARD WINPR_API BOOL	winpr_ndr_decoder_read_uconformant_varying_array (WinPrNdrDecoder *context, wStream *s, const WinPrNdrVaryingArrayHints *hints, WinPrNdrMessageType itemType, void *ptarget)
	reads a conformant varying array: its maximum count, offset, actual count and the items
WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType	winpr_ndr_string_conformant_descr (void)
	the message type of winpr_ndr_string_conformant_descr_s
WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType	winpr_ndr_string_varying_descr (void)
	the message type of winpr_ndr_string_varying_descr_s
WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType	winpr_ndr_wstring_varying_descr (void)
	the message type of winpr_ndr_wstring_varying_descr_s
WINPR_API void	winpr_ndr_struct_dump_fromDescr (wLog *logger, UINT32 lvl, size_t identLevel, const WinPrNdrStructDescr *descr, const void *obj)
	dumps a structure in the logs from its descriptor
WINPR_API void	winpr_ndr_struct_destroy (const WinPrNdrStructDescr *descr, void *pptr)
	releases the content of a structure from its descriptor
WINPR_ATTR_NODISCARD WINPR_API UINT32	winpr_ndr_union_switch_value (const WinPrNdrUnionDescr *descr, const void *switchField)
	the value of the [switch_is()] field of a union
WINPR_API void	winpr_ndr_union_destroy (const WinPrNdrUnionDescr *descr, UINT32 switchValue, void *obj)
	releases the content of the arm switchValue of a union

Variables
WINPR_API const WinPrNdrMessageDescr	winpr_ndr_wchar_descr_s
	a WCHAR, stored in UTF-16LE in memory
WINPR_API const WinPrNdrMessageDescr	winpr_ndr_string_conformant_descr_s
	conformant string of char, read in a char* allocated with winpr_ndr_pointer_new()
WINPR_API const WinPrNdrMessageDescr	winpr_ndr_string_varying_descr_s
	[string] char*: a conformant varying string of char, read in a char* allocated with winpr_ndr_pointer_new()
WINPR_API const WinPrNdrMessageDescr	winpr_ndr_wstring_varying_descr_s
	[string] wchar_t*: a conformant varying string of WCHAR, read in a WCHAR* allocated with winpr_ndr_pointer_new()

Detailed Description

NDR encoder and decoder ([C706] chapter 14, [MS-RPCE] 2.2.5 and 2.2.6)

WinPR: Windows Portable Runtime NDR (Network Data Representation) encoding and decoding

Copyright 2024 David Fort conta.nosp@m.ct@h.nosp@m.arden.nosp@m.ing-.nosp@m.consu.nosp@m.ltin.nosp@m.g.com

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Messages are described with descriptors (WinPrNdrMessageDescr, WinPrNdrStructDescr, WinPrNdrUnionDescr), and read, written, dumped and destroyed from these descriptors.

The encoder (WinPrNdrEncoder) and the decoder (WinPrNdrDecoder) keep the alignment offset of the current object and the pending deferred pointers: the referents of the embedded pointers are written after the construct that contains them, so writing or reading a message is followed by a call to winpr_ndr_encoder_treat_deferreds() or winpr_ndr_decoder_treat_deferreds().

All the pointers returned by the decoder are reference counted referents allocated with winpr_ndr_pointer_new(), they must not be passed to free() but released with winpr_ndr_pointer_release() (winpr_ndr_struct_destroy() releases the pointers of a structure).

Since

version 3.33.0

Definition in file ndr.h.

---

Data Structure Documentation

WinPrNdrMessageDescr

struct WinPrNdrMessageDescr

message descriptor

Since

version 3.33.0

Definition at line 293 of file ndr.h.

Collaboration diagram for WinPrNdrMessageDescr:

Data Fields
WinPrNdrTypeArity	arity
WINPR_NDR_DESTROY_FN	destroyFn	releases its content, can be nullptr
WINPR_NDR_DUMP_FN	dumpFn	dumps it in the logs, can be nullptr
size_t	itemSize	size of the C type (of an item for an array)
WINPR_NDR_READER_FN	readFn	reads the message
WINPR_NDR_WRITER_FN	writeFn	writes the message

WinPrNdrFieldStruct

struct WinPrNdrFieldStruct

descriptor of a field in a structure

Since

version 3.33.0

Definition at line 327 of file ndr.h.

Collaboration diagram for WinPrNdrFieldStruct:

Data Fields
size_t	fixedArraySize	size in bytes of the inline storage of an array
SSIZE_T	hintsField	index of the field holding the hints of this field (the size of an array...), -1 if none
const char *	name	name of the field, for the logs
WinPrNdrPointerType	pointerType	how the field is stored
UINT32	rangeMax	for an integer field: [range(0, rangeMax)], not checked if 0
size_t	structOffset	offset of the field in the structure
WinPrNdrMessageType	typeDescr	type of the field (of its referent for a pointer)

WinPrNdrStructDescr

struct WinPrNdrStructDescr

structure descriptor

Since

version 3.33.0

Definition at line 342 of file ndr.h.

Collaboration diagram for WinPrNdrStructDescr:

Data Fields
size_t	alignment	alignment of the structure (its largest member), 0 if unspecified
const WinPrNdrFieldStruct *	fields	the fields, in their wire order
const char *	name	name of the structure, for the logs
size_t	nfields	number of fields

WinPrNdrUnionArm

struct WinPrNdrUnionArm

an arm of a non-encapsulated union

Since

version 3.33.0

Definition at line 353 of file ndr.h.

Collaboration diagram for WinPrNdrUnionArm:

Data Fields
UINT32	discriminant	the [case()] value of the arm
WinPrNdrFieldStruct	field	the arm, its structOffset is relative to the union and it has no hints. An arm without typeDescr has no body

WinPrNdrUnionDescr

struct WinPrNdrUnionDescr

a non-encapsulated union ([switch_type()])

On the wire the union is its discriminant followed by the selected arm, aligned on its own type.

Since

version 3.33.0

Definition at line 367 of file ndr.h.

Collaboration diagram for WinPrNdrUnionDescr:

Data Fields
const WinPrNdrUnionArm *	arms	the arms
const WinPrNdrUnionArm *	defaultArm	the [default] arm, its discriminant is ignored. Without it an unknown discriminant is an error
const char *	name	name of the union, for the logs
size_t	narms	number of arms
size_t	switchSize	size of the discriminant and of the [switch_is()] field: 2 for a short or an enum, 4 for a long (the default when 0)

WinPrNdrDeferredEntry

struct WinPrNdrDeferredEntry

a deferred pointer, a referent to read after the current construct

Since

version 3.33.0

Definition at line 381 of file ndr.h.

Collaboration diagram for WinPrNdrDeferredEntry:

Data Fields
BOOL	allocate	the referent is allocated with winpr_ndr_pointer_new() (or by the reader of a self allocated type)
void *	hints	hints of the referent, valid until the deferred is treated
WinPrNdrMessageType	msg	the type of the referent
const char *	name	name of the pointer, for the logs
winpr_ndr_refid	ptrId	the referent id read for the pointer
void *	target	if allocate is set, the pointer field that receives the referent, otherwise the storage the referent is read into

WinPrNdrVaryingArrayHints

struct WinPrNdrVaryingArrayHints

hints for a conformant varying array

Since

version 3.33.0

Definition at line 525 of file ndr.h.

Data Fields
UINT32	length	the actual count
UINT32	maxLength	the maximum count

WinPrNdrArrayHints

struct WinPrNdrArrayHints

hints for a conformant array

Since

version 3.33.0

Definition at line 552 of file ndr.h.

Data Fields
UINT32	count	the number of items

Macro Definition Documentation

WINPR_NDR_ARRAY_MESSAGE_DEFINE

#define WINPR_NDR_ARRAY_MESSAGE_DEFINE	(		PREFIX,
			ITEMPREFIX,
			CTYPE
	)

Value:

  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                                        \
  }

defines a static message type for a conformant array of ITEMPREFIX##_descr_s items

Defines PREFIX##_descr_s, the hints of the array field are a WinPrNdrArrayHints.

Since

version 3.33.0

Definition at line 151 of file ndr.h.

  {                                                                                             \
    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                                        \
  }

WINPR_NDR_ARRAY_OF_TYPE_DECL

#define WINPR_NDR_ARRAY_OF_TYPE_DECL	(		PREFIX,
			TYPE,
			UPPERTYPE
	)

Value:

  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)

declares the functions and the message descriptors of the arrays of a simple type

For the items of type TYPE (stored in a UPPERTYPE) this declares:

• the conformant array: PREFIX##_decoder_read_##TYPE##Array(), PREFIX##_encoder_write_##TYPE##Array(), PREFIX##_destroy_##TYPE##Array() and the message descriptor PREFIX##_##TYPE##Array_descr_s / PREFIX##_##TYPE##Array_descr(), its hints are a WinPrNdrArrayHints;
• the conformant varying array: PREFIX##_decoder_read_##TYPE##VaryingArray(), PREFIX##_encoder_write_##TYPE##VaryingArray() and the message descriptor PREFIX##_##TYPE##VaryingArray_descr_s / PREFIX##_##TYPE##VaryingArray_descr(), its hints are a WinPrNdrVaryingArrayHints.

Since

version 3.33.0

Definition at line 91 of file ndr.h.

WINPR_NDR_PTR_NULL

#define WINPR_NDR_PTR_NULL   (0UL)

the referent id of a null pointer

Since

version 3.33.0

Definition at line 48 of file ndr.h.

WINPR_NDR_SIMPLE_TYPE_DECL

#define WINPR_NDR_SIMPLE_TYPE_DECL	(		PREFIX,
			LOWER,
			UPPER
	)

Value:

  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)

declares the functions and the message descriptor of a simple type

For a type named LOWER (stored in a UPPER) this declares:

• PREFIX##_decoder_read_##LOWER() and PREFIX##_encoder_write_##LOWER(), that read and write a value aligned on its size;
• PREFIX##_decoder_read_##LOWER##_() and PREFIX##_encoder_write_##LOWER##_(), the same with the WINPR_NDR_READER_FN / WINPR_NDR_WRITER_FN prototypes;
• PREFIX##_##LOWER##_descr_s and PREFIX##_##LOWER##_descr(), the message descriptor of the type.

Since

version 3.33.0

Definition at line 62 of file ndr.h.

WINPR_NDR_STRUCT_MESSAGE_DEFINE

#define WINPR_NDR_STRUCT_MESSAGE_DEFINE	(		PREFIX,
			CTYPE
	)

Value:

  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 }

defines a static message type for a structure

Defines PREFIX##_descr_s for the CTYPE structure described by the WinPrNdrStructDescr PREFIX##_struct.

Since

version 3.33.0

Definition at line 120 of file ndr.h.

  {                                                                                              \
    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 }

WINPR_NDR_UNION_MESSAGE_DEFINE

#define WINPR_NDR_UNION_MESSAGE_DEFINE	(		PREFIX,
			CTYPE
	)

Value:

  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 }

defines a static message type for a non-encapsulated union

Defines PREFIX##_descr_s for the CTYPE union described by the WinPrNdrUnionDescr PREFIX##_union. The hints of the union field are the field of its [switch_is()], a UINT16 or a UINT32 depending on the switchSize of the union.

Since

version 3.33.0

Definition at line 186 of file ndr.h.

  {                                                                                              \
    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 }

Typedef Documentation

WINPR_NDR_DESTROY_FN

typedef void(* WINPR_NDR_DESTROY_FN) (const void *hints, void *obj)

releases the content of a message, not the message storage itself

Parameters

hints	the hints of the message, can be nullptr
obj	the message

Since

version 3.33.0

Definition at line 262 of file ndr.h.

WINPR_NDR_DUMP_FN

typedef void(* WINPR_NDR_DUMP_FN) (wLog *logger, UINT32 lvl, size_t indentLevel, const void *obj)

dumps a message in the logs

Parameters

logger	the logger to use
lvl	the log level
indentLevel	the number of tabs to prepend to each line
obj	the message

Since

version 3.33.0

Definition at line 272 of file ndr.h.

WINPR_NDR_READER_FN

typedef BOOL(* WINPR_NDR_READER_FN) (WinPrNdrDecoder *context, wStream *s, const void *hints, void *target)

reads a message

Parameters

context	the decoder
s	the stream to read from
hints	the hints of the message (the size of an array...), can be nullptr
target	where the message is stored

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 241 of file ndr.h.

winpr_ndr_refid

typedef UINT32 winpr_ndr_refid

a referent id, the wire value of a pointer (WINPR_NDR_PTR_NULL for a null pointer)

Since

version 3.33.0

Definition at line 230 of file ndr.h.

WINPR_NDR_WRITER_FN

typedef BOOL(* WINPR_NDR_WRITER_FN) (WinPrNdrEncoder *context, wStream *s, const void *hints, const void *obj)

writes a message

Parameters

context	the encoder
s	the stream to write to
hints	the hints of the message (the size of an array...), can be nullptr
obj	the message to write

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 253 of file ndr.h.

WinPrNdrMessageType

typedef const WinPrNdrMessageDescr* WinPrNdrMessageType

a message type, a pointer on its descriptor

Since

version 3.33.0

Definition at line 306 of file ndr.h.

Enumeration Type Documentation

WinPrNdrPointerType

enum WinPrNdrPointerType

pointer or not and if null is accepted

Since

version 3.33.0

Enumerator
WINPR_NDR_NOT_POINTER	the field is stored inline, an array of fixedArraySize bytes if fixedArraySize is not 0
WINPR_NDR_POINTER_NON_NULL	[ref] or a unique pointer that can't be null
WINPR_NDR_POINTER	unique pointer ([unique])
WINPR_NDR_FIXED_ARRAY	unique pointer on a conformant array stored inline in the field (fixedArraySize bytes), the pointer is null when the array is empty
WINPR_NDR_POINTER_FULL	full pointer ([ptr]): pointers with the same referent id share the same referent

Definition at line 311 of file ndr.h.

  {
    WINPR_NDR_NOT_POINTER,      
    WINPR_NDR_POINTER_NON_NULL, 
    WINPR_NDR_POINTER,          
    WINPR_NDR_FIXED_ARRAY,      
    WINPR_NDR_POINTER_FULL      
  } WinPrNdrPointerType;

WinPrNdrTypeArity

enum WinPrNdrTypeArity

arity of a message

Since

version 3.33.0

Enumerator
WINPR_NDR_ARITY_SIMPLE	a single item
WINPR_NDR_ARITY_ARRAYOF	a conformant array, the hints are a WinPrNdrArrayHints
WINPR_NDR_ARITY_VARYING_ARRAYOF	a conformant varying array, the hints are a WinPrNdrVaryingArrayHints
WINPR_NDR_ARITY_SELF_ALLOCATED	the reader allocates the referent (strings...) with winpr_ndr_pointer_new(): the target is the pointer field, itemSize is the size of an element

Definition at line 278 of file ndr.h.

  {
    WINPR_NDR_ARITY_SIMPLE,          
    WINPR_NDR_ARITY_ARRAYOF,         
    WINPR_NDR_ARITY_VARYING_ARRAYOF, 
    WINPR_NDR_ARITY_SELF_ALLOCATED,  
  } WinPrNdrTypeArity;

Function Documentation

WINPR_NDR_ARRAY_OF_TYPE_DECL()

WINPR_NDR_ARRAY_OF_TYPE_DECL	(	winpr_ndr	,
		wchar	,
		WCHAR
	)

the arrays of WCHAR, stored in UTF-16LE in memory: use them for strings instead of the uint16 arrays, which store the items in host byte order

Since

version 3.34.0

winpr_ndr_decoder_bytes_read()

WINPR_API void winpr_ndr_decoder_bytes_read	(	WinPrNdrDecoder *	context,
		size_t	len
	)

accounts for bytes read directly from the stream, for the alignments

Parameters

context	the decoder
len	the number of bytes read

Since

version 3.33.0

Definition at line 1158 of file ndr.c.

{
  WINPR_ASSERT(context);
  context->offset += len;
}

References winpr_ndr_decoder_bytes_read().

Referenced by winpr_ndr_decoder_bytes_read().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_destroy()

static INLINE void winpr_ndr_decoder_destroy ( WinPrNdrDecoder **  pcontext )

static

frees a decoder and resets the pointer

Parameters

pcontext

a pointer on the decoder to free, must not be nullptr

Since

version 3.33.0

Definition at line 657 of file ndr.h.

  {
    WINPR_ASSERT(pcontext);
    winpr_ndr_decoder_free(*pcontext);
    *pcontext = nullptr;
  }

References winpr_ndr_decoder_free().

Here is the call graph for this function:

winpr_ndr_decoder_free()

WINPR_API void winpr_ndr_decoder_free

(

WinPrNdrDecoder *

context

)

frees a decoder

The referents it decoded belong to their pointers and are not released.

Parameters

context

the decoder to free, can be nullptr

Since

version 3.33.0

Definition at line 1148 of file ndr.c.

{
  if (context)
  {
    /* the referents belong to the pointers that reference them */
    HashTable_Free(context->referents);
    free(context);
  }
}

References winpr_ndr_decoder_free().

Referenced by winpr_ndr_decoder_destroy(), winpr_ndr_decoder_free(), and winpr_ndr_decoder_new().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_new()

WINPR_API WinPrNdrDecoder * winpr_ndr_decoder_new	(	BOOL	bigEndianDrep,
		BYTE	version
	)

creates a decoder

Parameters

bigEndianDrep	TRUE to decode big endian data, FALSE for little endian
version	the type serialization version

Returns

the new decoder, nullptr on failure

Since

version 3.33.0

Definition at line 1106 of file ndr.c.

{
  WinPrNdrDecoder* ret = calloc(1, sizeof(*ret));
  if (!ret)
    return nullptr;
 
  ret->version = version;
  ret->bigEndianDrep = bigEndianDrep;
  ret->referents = HashTable_New(FALSE);
  if (!ret->referents)
  {
    winpr_ndr_decoder_free(ret);
    return nullptr;
  }
 
  return ret;
}

References winpr_ndr_decoder_free(), and winpr_ndr_decoder_new().

Referenced by winpr_ndr_decoder_new(), and winpr_ndr_decoder_new_fromStream().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_new_fromStream()

WINPR_API WinPrNdrDecoder * winpr_ndr_decoder_new_fromStream

(

wStream *

s

)

reads the common type header ([MS-RPCE] 2.2.6.1) and creates a decoder for its version and endianness

Only the version 1 is supported.

Parameters

s	the stream to read from, positioned after the header on success

Returns

the new decoder, nullptr on failure

Since

version 3.33.0

Definition at line 1124 of file ndr.c.

{
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return nullptr;
 
  BYTE version = Stream_Get_UINT8(s);
  BYTE drep = Stream_Get_UINT8(s);
  UINT16 headerLen = Stream_Get_UINT16(s);
 
  if (version != 1)
  {
    WLog_ERR(TAG, "unsupported type serialization version %" PRIu8, version);
    return nullptr;
  }
 
  if (headerLen < 4 || !Stream_CheckAndLogRequiredLength(TAG, s, headerLen - 4))
    return nullptr;
 
  /* skip filler */
  Stream_Seek(s, headerLen - 4);
 
  return winpr_ndr_decoder_new((drep != 0x10), version);
}

References winpr_ndr_decoder_new(), and winpr_ndr_decoder_new_fromStream().

Referenced by winpr_ndr_decoder_new_fromStream().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_push_deferreds()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_push_deferreds	(	WinPrNdrDecoder *	context,
		WinPrNdrDeferredEntry *	deferreds,
		size_t	ndeferred
	)

adds deferred pointers, read by the next winpr_ndr_decoder_treat_deferreds()

This is used by custom readers that read the referent ids of their pointers themselves. The entries are copied, the hints they reference must stay valid until they are treated.

Parameters

context	the decoder
deferreds	the deferred pointers, in their wire order
ndeferred	the number of entries

Returns

TRUE on success, FALSE if there are too many pending deferred pointers

Since

version 3.33.0

Definition at line 1803 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(deferreds);
 
  BOOL ok = TRUE;
  ndr_deferreds_enter(&context->deferreds);
  for (size_t i = 0; ok && (i < ndeferred); i++)
    ok = ndr_deferreds_add(&context->deferreds, &deferreds[i]);
 
  return ndr_deferreds_leave(&context->deferreds, ok);
}

References winpr_ndr_decoder_push_deferreds().

Referenced by winpr_ndr_decoder_push_deferreds().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_align()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_align	(	WinPrNdrDecoder *	context,
		wStream *	s,
		size_t	sz
	)

skips the padding to align the current object offset

Parameters

context	the decoder
s	the stream to read from
sz	the alignment, must not be 0

Returns

TRUE on success, FALSE if the stream is too short

Since

version 3.33.0

Definition at line 1176 of file ndr.c.

{
  WINPR_ASSERT(context);
 
  size_t rest = context->offset % sz;
  if (rest)
  {
    size_t padding = (sz - rest);
    if (!Stream_CheckAndLogRequiredLength(TAG, s, padding))
      return FALSE;
 
    Stream_Seek(s, padding);
    context->offset += padding;
  }
 
  return TRUE;
}

References winpr_ndr_decoder_read_align().

Referenced by winpr_ndr_decoder_read_align(), and winpr_ndr_decoder_read_fromDescr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_fromDescr()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_fromDescr	(	WinPrNdrDecoder *	context,
		wStream *	s,
		const WinPrNdrStructDescr *	descr,
		void *	target
	)

reads a structure from its descriptor

The structure is aligned on descr->alignment, the referents of its pointers are deferred. On failure the structure may be partially filled, it is released with winpr_ndr_struct_destroy().

Parameters

context	the decoder
s	the stream to read from
descr	the descriptor of the structure
target	the structure, zeroed by the caller

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1695 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(descr);
  WINPR_ASSERT(target);
 
  if ((descr->alignment > 1) && !winpr_ndr_decoder_read_align(context, s, descr->alignment))
    return FALSE;
 
  BOOL ok = TRUE;
  ndr_deferreds_enter(&context->deferreds);
  for (size_t i = 0; ok && (i < descr->nfields); i++)
    ok = ndr_decoder_read_field(context, s, descr, &descr->fields[i], target);
 
  return ndr_deferreds_leave(&context->deferreds, ok);
}

References WinPrNdrStructDescr::alignment, WinPrNdrStructDescr::fields, WinPrNdrStructDescr::nfields, winpr_ndr_decoder_read_align(), and winpr_ndr_decoder_read_fromDescr().

Referenced by winpr_ndr_decoder_read_fromDescr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_object()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_object	(	WinPrNdrDecoder *	context,
		wStream *	s,
		wStream *	object
	)

reads the private header of a serialized object ([MS-RPCE] 2.2.6 type serialization version 1)

The alignments are then relative to the start of the object data.

Parameters

context	the decoder
s	the stream to read from, positioned after the object on success
object	receives a static stream on the object data, to decode with this context. It points in the buffer of s.

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1199 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(object);
 
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return FALSE;
 
  UINT32 len = 0;
  if (context->bigEndianDrep)
    Stream_Read_UINT32_BE(s, len);
  else
    Stream_Read_UINT32(s, len);
  Stream_Seek(s, 4); /* Filler */
 
  if (!Stream_CheckAndLogRequiredLength(TAG, s, len))
    return FALSE;
 
  Stream_StaticInit(object, Stream_PointerAs(s, BYTE), len);
  Stream_Seek(s, len);
 
  /* alignments are relative to the start of the object data */
  context->offset = 0;
  return TRUE;
}

References winpr_ndr_decoder_read_object().

Referenced by winpr_ndr_decoder_read_object().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_pointedMessageEx()

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
	)

reads the referent of a unique pointer

The referent is allocated with winpr_ndr_pointer_new() (or by the reader of a self allocated type) and read. A referent id already used by another pointer is rejected.

Parameters

context	the decoder
s	the stream to read from
ptrId	the referent id of the pointer, nothing is read for WINPR_NDR_PTR_NULL
descr	the type of the referent
hints	the hints of the referent, can be nullptr for a simple type
target	receives the referent, nullptr for a null pointer

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1741 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(descr);
  WINPR_ASSERT(target);
 
  *target = nullptr;
  if (!ptrId)
    return TRUE;
 
  /* a unique pointer can't share its referent */
  if (HashTable_Contains(context->referents, (void*)(UINT_PTR)ptrId))
  {
    WLog_ERR(TAG, "unique pointer 0x%" PRIx32 " is aliased", ptrId);
    return FALSE;
  }
 
  void* ret = nullptr;
  if (descr->arity == WINPR_NDR_ARITY_SELF_ALLOCATED)
  {
    /* the reader allocates the referent with winpr_ndr_pointer_new() */
    if (!descr->readFn(context, s, hints, (void*)&ret))
      return FALSE;
    if (!ret)
      return FALSE;
  }
  else
  {
    size_t size = 0;
    if (!ndr_referent_size("unique pointer", descr, hints, &size))
      return FALSE;
 
    /* each item takes at least one byte on the wire, don't allocate for data that isn't
     * there */
    if ((descr->arity == WINPR_NDR_ARITY_ARRAYOF) &&
        !Stream_CheckAndLogRequiredLength(TAG, s, ndr_hintsCount(descr, hints)))
      return FALSE;
 
    ret = winpr_ndr_pointer_new(descr, hints, size);
    if (!ret)
      return FALSE;
 
    if (!descr->readFn(context, s, hints, ret))
    {
      winpr_ndr_pointer_release(ret);
      return FALSE;
    }
  }
 
  if (!ndr_decoder_register(context, ndr_referent(ret), ptrId, FALSE))
  {
    winpr_ndr_pointer_release(ret);
    return FALSE;
  }
 
  *target = ret;
  return TRUE;
}

References WinPrNdrMessageDescr::readFn, WINPR_NDR_ARITY_ARRAYOF, WINPR_NDR_ARITY_SELF_ALLOCATED, winpr_ndr_decoder_read_pointedMessageEx(), winpr_ndr_pointer_new(), and winpr_ndr_pointer_release().

Referenced by winpr_ndr_decoder_read_pointedMessageEx(), and winpr_ndr_decoder_treat_deferreds().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_pointer_ex()

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
	)

reads a full pointer ([ptr])

The first pointer with a referent id allocates a reference counted block for a referent of type descr, the referent is read with the deferred pointers. The next pointers with the same referent id get a new reference on that block, they must have the same type and the same size. Types allocating their referent (WINPR_NDR_ARITY_SELF_ALLOCATED) can't be used.

Parameters

context	the decoder
s	the stream to read from
name	the name of the pointer, for the logs
descr	the type of the referent
hints	the hints of the referent, they must be valid until the deferred pointers are treated
target	receives the referent with a reference, nullptr for a null pointer

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1596 of file ndr.c.

{
  WINPR_ASSERT(context);
 
  ndr_deferreds_enter(&context->deferreds);
  const BOOL ok = ndr_decoder_read_full_pointer(context, s, name, descr, hints, target);
  return ndr_deferreds_leave(&context->deferreds, ok);
}

References winpr_ndr_decoder_read_pointer_ex().

Referenced by winpr_ndr_decoder_read_pointer_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_refpointer()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_refpointer	(	WinPrNdrDecoder *	context,
		wStream *	s,
		UINT32 *	refId
	)

reads a referent id

Parameters

context	the decoder
s	the stream to read from
refId	receives the referent id, WINPR_NDR_PTR_NULL for a null pointer

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1194 of file ndr.c.

{
  return winpr_ndr_decoder_read_uint32(context, s, refId);
}

References winpr_ndr_decoder_read_refpointer().

Referenced by winpr_ndr_decoder_read_refpointer().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_uconformant_array()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_uconformant_array	(	WinPrNdrDecoder *	context,
		wStream *	s,
		const WinPrNdrArrayHints *	hints,
		WinPrNdrMessageType	itemType,
		void *	vtarget
	)

reads a conformant array: its count and the items

For simple items the count must be hints->count, otherwise the items must fit in hints->count bytes. The referents of the pointers in the items are deferred after the array.

Parameters

context	the decoder
s	the stream to read from
hints	the expected size of the array, must not be nullptr
itemType	the type of the items
vtarget	receives the items

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1361 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(itemType);
  WINPR_ASSERT(vtarget);
 
  if (!hints)
    return FALSE;
 
  if (itemType->itemSize == 0)
    return FALSE;
 
  UINT32 count = 0;
  if (!winpr_ndr_decoder_read_uint32(context, s, &count))
    return FALSE;
 
  if (!ndr_check_array_bound("conformant array", count, itemType, hints->count))
    return FALSE;
 
  return ndr_decoder_read_items(context, s, count, itemType, vtarget);
}

References WinPrNdrArrayHints::count, WinPrNdrMessageDescr::itemSize, and winpr_ndr_decoder_read_uconformant_array().

Referenced by winpr_ndr_decoder_read_uconformant_array().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_uconformant_varying_array()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_uconformant_varying_array	(	WinPrNdrDecoder *	context,
		wStream *	s,
		const WinPrNdrVaryingArrayHints *	hints,
		WinPrNdrMessageType	itemType,
		void *	ptarget
	)

reads a conformant varying array: its maximum count, offset, actual count and the items

The actual and maximum counts of items must fit in hints->length and hints->maxLength bytes. The referents of the pointers in the items are deferred after the array.

Parameters

context	the decoder
s	the stream to read from
hints	the bounds of the array, must not be nullptr
itemType	the type of the items
ptarget	receives the items

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1341 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(itemType);
  WINPR_ASSERT(target);
 
  if (!hints)
    return FALSE;
 
  UINT32 maxCount = 0;
  UINT32 length = 0;
  if (!ndr_read_varying_array_header(context, s, hints, itemType, &maxCount, &length))
    return FALSE;
 
  return ndr_decoder_read_items(context, s, length, itemType, target);
}

References winpr_ndr_decoder_read_uconformant_varying_array().

Referenced by winpr_ndr_decoder_read_uconformant_varying_array().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_union()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_union	(	WinPrNdrDecoder *	context,
		wStream *	s,
		const WinPrNdrUnionDescr *	descr,
		UINT32	switchValue,
		void *	target
	)

reads a union, its discriminant must be switchValue

Parameters

context	the decoder
s	the stream to read from
descr	the descriptor of the union
switchValue	the value of the [switch_is()] field of the union
target	the union

Returns

TRUE on success, FALSE if the discriminant doesn't match, has no arm, or on failure

Since

version 3.33.0

Definition at line 1922 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(target);
 
  UINT32 discriminant = 0;
  if (!ndr_decoder_read_discriminant(context, s, descr, &discriminant))
    return FALSE;
 
  if (discriminant != switchValue)
  {
    WLog_ERR(TAG,
             "%s: discriminant 0x%08" PRIx32 " doesn't match the switch value 0x%08" PRIx32,
             descr->name, discriminant, switchValue);
    return FALSE;
  }
 
  WinPrNdrStructDescr armStruct = WINPR_C_ARRAY_INIT;
  const WinPrNdrUnionArm* arm = ndr_union_arm(descr, switchValue, &armStruct);
  if (!arm)
    return FALSE;
 
  BOOL ok = TRUE;
  ndr_deferreds_enter(&context->deferreds);
  if (arm->field.typeDescr)
    ok = ndr_decoder_read_field(context, s, &armStruct, &arm->field, target);
  return ndr_deferreds_leave(&context->deferreds, ok);
}

References WinPrNdrUnionArm::field, WinPrNdrUnionDescr::name, WinPrNdrFieldStruct::typeDescr, and winpr_ndr_decoder_read_union().

Referenced by winpr_ndr_decoder_read_union().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_read_wchar()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_read_wchar	(	WinPrNdrDecoder *	context,
		wStream *	s,
		WCHAR *	ptr
	)

reads a WCHAR, aligned on 2 bytes

The character is stored in UTF-16LE like all the WinPR WCHAR strings, whatever the byte order of the host.

Parameters

context	the decoder
s	the stream to read from
ptr	receives the character

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 631 of file ndr.c.

{
  WINPR_ASSERT(ptr);
 
  UINT16 v = 0;
  if (!winpr_ndr_decoder_read_uint16(context, s, &v))
    return FALSE;
 
  winpr_Data_Write_UINT16(ptr, v);
  return TRUE;
}

References winpr_ndr_decoder_read_wchar().

Referenced by winpr_ndr_decoder_read_wchar().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_skip_bytes()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_skip_bytes	(	WinPrNdrDecoder *	context,
		wStream *	s,
		size_t	nbytes
	)

skips bytes

Parameters

context	the decoder
s	the stream to read from
nbytes	the number of bytes to skip

Returns

TRUE on success, FALSE if the stream is too short

Since

version 3.33.0

Definition at line 1164 of file ndr.c.

{
  WINPR_ASSERT(context);
 
  if (!Stream_CheckAndLogRequiredLength(TAG, s, nbytes))
    return FALSE;
 
  context->offset += nbytes;
  Stream_Seek(s, nbytes);
  return TRUE;
}

References winpr_ndr_decoder_skip_bytes().

Referenced by winpr_ndr_decoder_skip_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_decoder_treat_deferreds()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_treat_deferreds	(	WinPrNdrDecoder *	context,
		wStream *	s
	)

reads the pending deferred referents

Parameters

context	the decoder
s	the stream to read from

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1714 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
 
  WinPrNdrDeferredEntry current = { 0 };
  while (ndr_deferreds_pop(&context->deferreds, &current))
  {
    WLog_VRB(TAG, "treating read deferred 0x%x for %s", current.ptrId, current.name);
 
    BOOL ok = FALSE;
    if (current.allocate)
      ok = winpr_ndr_decoder_read_pointedMessageEx(context, s, current.ptrId, current.msg,
                                                   current.hints, (void**)current.target);
    else
      ok = current.msg->readFn(context, s, current.hints, current.target);
 
    if (!ok)
    {
      WLog_ERR(TAG, "error parsing deferred %s", current.name);
      return FALSE;
    }
  }
 
  return TRUE;
}

References WinPrNdrDeferredEntry::allocate, WinPrNdrDeferredEntry::hints, WinPrNdrDeferredEntry::msg, WinPrNdrDeferredEntry::name, WinPrNdrDeferredEntry::ptrId, WinPrNdrMessageDescr::readFn, WinPrNdrDeferredEntry::target, winpr_ndr_decoder_read_pointedMessageEx(), and winpr_ndr_decoder_treat_deferreds().

Referenced by winpr_ndr_decoder_treat_deferreds().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_allocatePtr()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_allocatePtr	(	WinPrNdrEncoder *	context,
		const void *	ptr,
		winpr_ndr_refid *	prefId,
		BOOL *	pnewPtr
	)

allocates the referent id of an embedded pointer

The pointers are written as unique pointers: each non-null pointer gets its own referent id, and *pnewPtr is always set to TRUE.

Parameters

context	the encoder
ptr	the pointer
prefId	receives the referent id
pnewPtr	receives TRUE if the referent is to be written

Returns

TRUE on success, FALSE when the referent ids are exhausted

Since

version 3.33.0

Definition at line 1056 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(prefId);
  WINPR_ASSERT(pnewPtr);
  WINPR_UNUSED(ptr);
 
  /* pointers are unique pointers: each non-null pointer has its own referent, the decoder
   * rejects aliased pointers */
  if (context->refIdCounter > UINT32_MAX - 4)
    return FALSE;
 
  *pnewPtr = TRUE;
  *prefId = context->refIdCounter;
  context->refIdCounter += 4;
  return TRUE;
}

References winpr_ndr_encoder_allocatePtr().

Referenced by winpr_ndr_encoder_allocatePtr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_bytes_written()

WINPR_API void winpr_ndr_encoder_bytes_written	(	WinPrNdrEncoder *	context,
		size_t	len
	)

accounts for bytes written directly in the stream, for the alignments

Parameters

context	the encoder
len	the number of bytes written

Since

version 3.33.0

Definition at line 218 of file ndr.c.

{
  WINPR_ASSERT(context);
  context->offset += len;
}

References winpr_ndr_encoder_bytes_written().

Referenced by winpr_ndr_encoder_bytes_written(), and winpr_ndr_encoder_write_data().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_destroy()

static INLINE void winpr_ndr_encoder_destroy ( WinPrNdrEncoder **  pcontext )

static

frees an encoder and resets the pointer

Parameters

pcontext

a pointer on the encoder to free, must not be nullptr

Since

version 3.33.0

Definition at line 405 of file ndr.h.

  {
    WINPR_ASSERT(pcontext);
    winpr_ndr_encoder_free(*pcontext);
    *pcontext = nullptr;
  }

References winpr_ndr_encoder_free().

Here is the call graph for this function:

winpr_ndr_encoder_end_object()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_end_object	(	WinPrNdrEncoder *	context,
		wStream *	s
	)

ends the serialized object started with winpr_ndr_encoder_start_object()

Pads the object data to a multiple of 8 bytes and fills the private header.

Parameters

context	the encoder
s	the stream given to winpr_ndr_encoder_start_object()

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 282 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
 
  if (!context->inObject)
  {
    WLog_ERR(TAG, "no object being serialized");
    return FALSE;
  }
 
  const size_t start = context->objectStart + 8;
  WINPR_ASSERT(Stream_GetPosition(s) >= start);
 
  /* the length of the object buffer must be a multiple of 8 */
  const size_t padding = (8 - ((Stream_GetPosition(s) - start) % 8)) % 8;
  if (!Stream_EnsureRemainingCapacity(s, padding))
    return FALSE;
  Stream_Zero(s, padding);
  context->offset += padding;
 
  const size_t len = Stream_GetPosition(s) - start;
  if (len > UINT32_MAX)
    return FALSE;
 
  BYTE* header = Stream_Buffer(s) + context->objectStart;
  if (context->bigEndianDrep)
    winpr_Data_Write_UINT32_BE(header, (UINT32)len);
  else
    winpr_Data_Write_UINT32(header, (UINT32)len);
 
  context->inObject = FALSE;
  return TRUE;
}

References winpr_ndr_encoder_end_object().

Referenced by winpr_ndr_encoder_end_object().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_free()

WINPR_API void winpr_ndr_encoder_free

(

WinPrNdrEncoder *

context

)

frees an encoder

Parameters

context

the encoder to free, can be nullptr

Since

version 3.33.0

Definition at line 213 of file ndr.c.

{
  free(context);
}

References winpr_ndr_encoder_free().

Referenced by winpr_ndr_encoder_destroy(), and winpr_ndr_encoder_free().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_from_decoder()

WINPR_API WinPrNdrEncoder * winpr_ndr_encoder_from_decoder

(

const WinPrNdrDecoder *

src

)

creates an encoder with the same endianness and version as a decoder, to answer the message it decoded

Parameters

src	the decoder

Returns

the new encoder, nullptr on failure

Since

version 3.33.0

Definition at line 206 of file ndr.c.

{
  WINPR_ASSERT(src);
 
  return winpr_ndr_encoder_new(src->bigEndianDrep, src->version);
}

References winpr_ndr_encoder_from_decoder(), and winpr_ndr_encoder_new().

Referenced by winpr_ndr_encoder_from_decoder().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_new()

WINPR_API WinPrNdrEncoder * winpr_ndr_encoder_new	(	BOOL	bigEndianDrep,
		BYTE	version
	)

creates an encoder

Parameters

bigEndianDrep	TRUE to encode in big endian, FALSE for little endian
version	the type serialization version written by winpr_ndr_encoder_write_header()

Returns

the new encoder, nullptr on failure

Since

version 3.33.0

Definition at line 194 of file ndr.c.

{
  WinPrNdrEncoder* ret = calloc(1, sizeof(*ret));
  if (!ret)
    return nullptr;
 
  ret->version = version;
  ret->bigEndianDrep = bigEndianDrep;
  ret->refIdCounter = 0x20000;
  return ret;
}

References winpr_ndr_encoder_new().

Referenced by winpr_ndr_encoder_from_decoder(), and winpr_ndr_encoder_new().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_start_object()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_start_object	(	WinPrNdrEncoder *	context,
		wStream *	s
	)

starts a serialized object ([MS-RPCE] 2.2.6 type serialization version 1)

Writes a placeholder for the private header, the object data is to be written after. Only one object can be serialized at a time.

Parameters

context	the encoder
s	the stream to write to

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 259 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
 
  if (context->inObject)
  {
    WLog_ERR(TAG, "an object is already being serialized");
    return FALSE;
  }
 
  if (!Stream_EnsureRemainingCapacity(s, 8))
    return FALSE;
 
  /* ObjectBufferLength, filled by winpr_ndr_encoder_end_object, and Filler */
  context->objectStart = Stream_GetPosition(s);
  Stream_Zero(s, 8);
 
  context->inObject = TRUE;
  context->offset = 0;
  return TRUE;
}

References winpr_ndr_encoder_start_object().

Referenced by winpr_ndr_encoder_start_object().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_treat_deferreds()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_treat_deferreds	(	WinPrNdrEncoder *	context,
		wStream *	s
	)

writes the pending deferred referents

Parameters

context	the encoder
s	the stream to write to

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1075 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
 
  WinPrNdrDeferredEntry current = { 0 };
  while (ndr_deferreds_pop(&context->deferreds, &current))
  {
    WLog_VRB(TAG, "treating write deferred for %s", current.name);
    if (!current.msg->writeFn(context, s, current.hints, current.target))
    {
      WLog_ERR(TAG, "error writing deferred %s", current.name);
      return FALSE;
    }
  }
 
  return TRUE;
}

References WinPrNdrDeferredEntry::hints, WinPrNdrDeferredEntry::msg, WinPrNdrDeferredEntry::name, WinPrNdrDeferredEntry::target, winpr_ndr_encoder_treat_deferreds(), and WinPrNdrMessageDescr::writeFn.

Referenced by winpr_ndr_encoder_treat_deferreds().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_align()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_align	(	WinPrNdrEncoder *	context,
		wStream *	s,
		size_t	sz
	)

writes zero padding to align the current object offset

Parameters

context	the encoder
s	the stream to write to
sz	the alignment, must not be 0

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 240 of file ndr.c.

{
  WINPR_ASSERT(context);
 
  size_t rest = context->offset % sz;
  if (rest)
  {
    size_t padding = (sz - rest);
 
    if (!Stream_EnsureRemainingCapacity(s, padding))
      return FALSE;
 
    Stream_Zero(s, padding);
    context->offset += padding;
  }
 
  return TRUE;
}

References winpr_ndr_encoder_write_align().

Referenced by winpr_ndr_encoder_write_align(), and winpr_ndr_encoder_write_fromDescr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_data()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_data	(	WinPrNdrEncoder *	context,
		wStream *	s,
		const void *	data,
		size_t	sz
	)

writes raw bytes, without alignment

Parameters

context	the encoder
s	the stream to write to
data	the bytes to write
sz	the number of bytes

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1094 of file ndr.c.

{
  if (!Stream_EnsureRemainingCapacity(s, sz))
    return FALSE;
 
  Stream_Write(s, data, sz);
  winpr_ndr_encoder_bytes_written(context, sz);
  return TRUE;
}

References winpr_ndr_encoder_bytes_written(), and winpr_ndr_encoder_write_data().

Referenced by winpr_ndr_encoder_write_data().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_fromDescr()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_fromDescr	(	WinPrNdrEncoder *	context,
		wStream *	s,
		const WinPrNdrStructDescr *	descr,
		const void *	src
	)

writes a structure from its descriptor

The structure is aligned on descr->alignment, the referents of its pointers are deferred.

Parameters

context	the encoder
s	the stream to write to
descr	the descriptor of the structure
src	the structure

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 1032 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(descr);
  WINPR_ASSERT(src);
 
  if ((descr->alignment > 1) && !winpr_ndr_encoder_write_align(context, s, descr->alignment))
    return FALSE;
 
  BOOL ok = TRUE;
  ndr_deferreds_enter(&context->deferreds);
  for (size_t i = 0; ok && (i < descr->nfields); i++)
    ok = ndr_encoder_write_field(context, s, descr, &descr->fields[i], src);
 
  return ndr_deferreds_leave(&context->deferreds, ok);
}

References WinPrNdrStructDescr::alignment, WinPrNdrStructDescr::fields, WinPrNdrStructDescr::nfields, winpr_ndr_encoder_write_align(), and winpr_ndr_encoder_write_fromDescr().

Referenced by winpr_ndr_encoder_write_fromDescr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_header()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_header	(	WinPrNdrEncoder *	context,
		wStream *	s
	)

writes the common type header ([MS-RPCE] 2.2.6.1): version, endianness, header length and filler

Parameters

context	the encoder
s	the stream to write to

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 224 of file ndr.c.

{
  WINPR_ASSERT(context);
 
  if (!Stream_EnsureRemainingCapacity(s, 8))
    return FALSE;
 
  Stream_Write_UINT8(s, context->version);
  Stream_Write_UINT8(s, context->bigEndianDrep ? 0x00 : 0x10);
  Stream_Write_UINT16(s, 0x8); /* header len */
 
  BYTE filler[] = { 0xcc, 0xcc, 0xcc, 0xcc };
  Stream_Write(s, filler, sizeof(filler));
  return TRUE;
}

References winpr_ndr_encoder_write_header().

Referenced by winpr_ndr_encoder_write_header().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_toplevel_refid()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_toplevel_refid	(	WinPrNdrEncoder *	context,
		wStream *	s
	)

writes a new referent id for a non-null top-level pointer

Parameters

context	the encoder
s	the stream to write to

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 317 of file ndr.c.

{
  WINPR_ASSERT(context);
 
  const winpr_ndr_refid refId = context->refIdCounter;
  context->refIdCounter += 4;
  return winpr_ndr_encoder_write_uint32(context, s, refId);
}

References winpr_ndr_encoder_write_toplevel_refid().

Referenced by winpr_ndr_encoder_write_toplevel_refid().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_uconformant_array()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_uconformant_array	(	WinPrNdrEncoder *	context,
		wStream *	s,
		UINT32	len,
		WinPrNdrMessageType	itemType,
		const BYTE *	ptr
	)

writes a conformant array: its count and the items

The referents of the pointers in the items are deferred after the array.

Parameters

context	the encoder
s	the stream to write to
len	the number of items
itemType	the type of the items
ptr	the items

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 935 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(itemType);
  WINPR_ASSERT(ptr);
 
  if (!winpr_ndr_encoder_write_uint32(context, s, len))
    return FALSE;
 
  return ndr_encoder_write_items(context, s, len, itemType, ptr);
}

References winpr_ndr_encoder_write_uconformant_array().

Referenced by winpr_ndr_encoder_write_uconformant_array().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_uconformant_varying_array()

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
	)

writes a conformant varying array: its maximum count, offset 0, actual count and the items

The referents of the pointers in the items are deferred after the array.

Parameters

context	the encoder
s	the stream to write to
hints	the counts of the array
itemType	the type of the items
src	the items, hints->length of them are written

Returns

TRUE on success, FALSE otherwise

Since

version 3.33.0

Definition at line 916 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
  WINPR_ASSERT(hints);
  WINPR_ASSERT(itemType);
  WINPR_ASSERT(psrc);
 
  if (!winpr_ndr_encoder_write_uint32(context, s, hints->maxLength) ||
      !winpr_ndr_encoder_write_uint32(context, s, 0) ||
      !winpr_ndr_encoder_write_uint32(context, s, hints->length))
    return FALSE;
 
  return ndr_encoder_write_items(context, s, hints->length, itemType, psrc);
}

References WinPrNdrVaryingArrayHints::length, WinPrNdrVaryingArrayHints::maxLength, and winpr_ndr_encoder_write_uconformant_varying_array().

Referenced by winpr_ndr_encoder_write_uconformant_varying_array().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_union()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_union	(	WinPrNdrEncoder *	context,
		wStream *	s,
		const WinPrNdrUnionDescr *	descr,
		UINT32	switchValue,
		const void *	src
	)

writes the discriminant and the arm of a union

Parameters

context	the encoder
s	the stream to write to
descr	the descriptor of the union
switchValue	the discriminant, the value of the [switch_is()] field
src	the union

Returns

TRUE on success, FALSE if there's no arm for switchValue or on failure

Since

version 3.33.0

Definition at line 1903 of file ndr.c.

{
  WINPR_ASSERT(context);
  WINPR_ASSERT(src);
 
  WinPrNdrStructDescr armStruct = WINPR_C_ARRAY_INIT;
  const WinPrNdrUnionArm* arm = ndr_union_arm(descr, switchValue, &armStruct);
  if (!arm || !ndr_encoder_write_discriminant(context, s, descr, switchValue))
    return FALSE;
 
  BOOL ok = TRUE;
  ndr_deferreds_enter(&context->deferreds);
  if (arm->field.typeDescr)
    ok = ndr_encoder_write_field(context, s, &armStruct, &arm->field, src);
  return ndr_deferreds_leave(&context->deferreds, ok);
}

References WinPrNdrUnionArm::field, WinPrNdrFieldStruct::typeDescr, and winpr_ndr_encoder_write_union().

Referenced by winpr_ndr_encoder_write_union().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_encoder_write_wchar()

WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_write_wchar	(	WinPrNdrEncoder *	context,
		wStream *	s,
		const WCHAR *	ptr
	)

writes a WCHAR stored in UTF-16LE, aligned on 2 bytes

Parameters

context	the encoder
s	the stream to write to
ptr	the character

Returns

TRUE on success, FALSE otherwise

Since

version 3.34.0

Definition at line 643 of file ndr.c.

{
  WINPR_ASSERT(ptr);
  return winpr_ndr_encoder_write_uint16(context, s, winpr_Data_Get_UINT16(ptr));
}

References winpr_ndr_encoder_write_wchar().

Referenced by winpr_ndr_encoder_write_wchar().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_pointer_new()

WINPR_API void * winpr_ndr_pointer_new	(	WinPrNdrMessageType	descr,
		const void *	hints,
		size_t	size
	)

allocates a referent

All the pointers returned by the decoder are reference counted referents, released with winpr_ndr_pointer_release() (winpr_ndr_struct_destroy() releases the pointers of a structure). Self allocated types allocate their referent with this function, and so must the pointers of a structure built to be encoded and destroyed with winpr_ndr_struct_destroy().

Parameters

descr	the type of the referent, its destroy function is called when the referent is released, can be nullptr
hints	the hints of the referent for the destroy function, copied, can be nullptr
size	the size of the referent, it is zeroed

Returns

the referent with a reference, nullptr on failure

Since

version 3.33.0

Definition at line 1454 of file ndr.c.

{
  NdrReferent* ref = ndr_referent_new(descr, hints, size);
  WINPR_PRAGMA_DIAG_PUSH
  WINPR_DO_COVERITY_PRAGMA(
      coverity compliance block
          deviate 'RESOURCE_LEAK' 'returning a constant offset pointer, winpr_ndr_pointer_release does the inverse')
  return ref ? ref->payload.data : nullptr;
  WINPR_PRAGMA_DIAG_POP
}

References winpr_ndr_pointer_new().

Referenced by winpr_ndr_decoder_read_pointedMessageEx(), and winpr_ndr_pointer_new().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_pointer_ref()

WINPR_API void * winpr_ndr_pointer_ref

(

void *

ptr

)

takes a reference on a referent

Parameters

ptr	the referent, can be nullptr

Returns

ptr

Since

version 3.33.0

Definition at line 1473 of file ndr.c.

{
  if (!ptr)
    return nullptr;
 
  NdrReferent* ref = ndr_referent(ptr);
  InterlockedIncrement(&ref->refCount);
  return ptr;
}

References winpr_ndr_pointer_ref().

Referenced by winpr_ndr_pointer_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_pointer_refid()

WINPR_ATTR_NODISCARD WINPR_API winpr_ndr_refid winpr_ndr_pointer_refid

(

const void *

ptr

)

a referent id built from the value of a pointer

Parameters

ptr	the pointer

Returns

the low 32 bits of ptr, WINPR_NDR_PTR_NULL for nullptr

Since

version 3.33.0

Definition at line 1051 of file ndr.c.

{
  return (winpr_ndr_refid)((ULONG_PTR)ptr);
}

References winpr_ndr_pointer_refid().

Referenced by winpr_ndr_pointer_refid().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_pointer_release()

WINPR_API void winpr_ndr_pointer_release

(

void *

ptr

)

releases a referent

When the last reference is released the referent is destroyed with the destroy function of its type, and freed.

Parameters

ptr	the referent, can be nullptr

Since

version 3.33.0

Definition at line 1483 of file ndr.c.

{
  if (!ptr)
    return;
 
  NdrReferent* ref = ndr_referent(ptr);
  if (InterlockedDecrement(&ref->refCount) > 0)
    return;
 
  if (ref->typeDescr && ref->typeDescr->destroyFn)
    ref->typeDescr->destroyFn(ref->hasHints ? &ref->hints : nullptr, ref->payload.data);
  ref->magic = 0;
  free(ref);
}

References winpr_ndr_pointer_release().

Referenced by winpr_ndr_decoder_read_pointedMessageEx(), winpr_ndr_pointer_release(), and winpr_ndr_struct_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_pointer_size()

WINPR_ATTR_NODISCARD WINPR_API size_t winpr_ndr_pointer_size

(

const void *

ptr

)

the size of a referent, as allocated by winpr_ndr_pointer_new()

Parameters

ptr	the referent, can be nullptr

Returns

the size of the referent, 0 for nullptr

Since

version 3.33.0

Definition at line 1465 of file ndr.c.

{
  if (!ptr)
    return 0;
 
  return ndr_referent(WINPR_CAST_CONST_PTR_AWAY(ptr, void*))->size;
}

References winpr_ndr_pointer_size().

Referenced by winpr_ndr_pointer_size().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_string_conformant_descr()

WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType winpr_ndr_string_conformant_descr

(

void

)

the message type of winpr_ndr_string_conformant_descr_s

Returns

the message type

Since

version 3.33.0

Definition at line 735 of file ndr.c.

{
  return &winpr_ndr_string_conformant_descr_s;
}

References winpr_ndr_string_conformant_descr(), and winpr_ndr_string_conformant_descr_s.

Referenced by winpr_ndr_string_conformant_descr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_string_varying_descr()

WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType winpr_ndr_string_varying_descr

(

void

)

the message type of winpr_ndr_string_varying_descr_s

Returns

the message type

Since

version 3.33.0

Definition at line 831 of file ndr.c.

{
  return &winpr_ndr_string_varying_descr_s;
}

References winpr_ndr_string_varying_descr(), and winpr_ndr_string_varying_descr_s.

Referenced by winpr_ndr_string_varying_descr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_struct_destroy()

WINPR_API void winpr_ndr_struct_destroy	(	const WinPrNdrStructDescr *	descr,
		void *	pptr
	)

releases the content of a structure from its descriptor

The pointer fields are released with winpr_ndr_pointer_release() and reset, the inline fields are destroyed with the destroy function of their type. The storage of the structure itself is not freed.

Parameters

descr	the descriptor of the structure
pptr	the structure

Since

version 3.33.0

Definition at line 2005 of file ndr.c.

{
  WINPR_ASSERT(descr);
  WINPR_ASSERT(pptr);
 
  for (size_t i = 0; i < descr->nfields; i++)
  {
    const WinPrNdrFieldStruct* field = &descr->fields[i];
    void* ptr = (BYTE*)pptr + field->structOffset;
    void* hints = nullptr;
 
    if (field->hintsField >= 0)
    {
      /* computes the address of the hints field if any */
      WINPR_ASSERT((size_t)field->hintsField < descr->nfields);
      const WinPrNdrFieldStruct* hintsField = &descr->fields[field->hintsField];
 
      hints = (BYTE*)pptr + hintsField->structOffset;
    }
 
    switch (field->pointerType)
    {
      case WINPR_NDR_POINTER:
      case WINPR_NDR_POINTER_NON_NULL:
      case WINPR_NDR_POINTER_FULL:
      {
        /* the referent is destroyed with its last reference */
        void** pptrField = (void**)ptr;
        winpr_ndr_pointer_release(*pptrField);
        *pptrField = nullptr;
      }
      break;
 
      default:
        /* NOT_POINTER and FIXED_ARRAY fields are stored inline in the struct */
        if (field->typeDescr->destroyFn)
          field->typeDescr->destroyFn(hints, ptr);
        break;
    }
  }
}

References WinPrNdrMessageDescr::destroyFn, WinPrNdrStructDescr::fields, WinPrNdrFieldStruct::hintsField, WinPrNdrStructDescr::nfields, WinPrNdrFieldStruct::pointerType, WinPrNdrFieldStruct::structOffset, WinPrNdrFieldStruct::typeDescr, WINPR_NDR_POINTER, WINPR_NDR_POINTER_FULL, WINPR_NDR_POINTER_NON_NULL, winpr_ndr_pointer_release(), and winpr_ndr_struct_destroy().

Referenced by winpr_ndr_struct_destroy(), and winpr_ndr_union_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_struct_dump_fromDescr()

WINPR_API void winpr_ndr_struct_dump_fromDescr	(	wLog *	logger,
		UINT32	lvl,
		size_t	identLevel,
		const WinPrNdrStructDescr *	descr,
		const void *	obj
	)

dumps a structure in the logs from its descriptor

Parameters

logger	the logger to use
lvl	the log level
identLevel	the number of tabs to prepend to each line
descr	the descriptor of the structure
obj	the structure

Since

version 3.33.0

Definition at line 1967 of file ndr.c.

{
  char tabArray[30 + 1];
  size_t ntabs = (identLevel <= 30) ? identLevel : 30;
 
  memset(tabArray, '\t', ntabs);
  tabArray[ntabs] = 0;
 
  WLog_Print(logger, lvl, "%s%s", tabArray, descr->name);
  for (size_t i = 0; i < descr->nfields; i++)
  {
    const WinPrNdrFieldStruct* field = &descr->fields[i];
    const BYTE* ptr = (const BYTE*)obj + field->structOffset;
 
    switch (field->pointerType)
    {
      case WINPR_NDR_POINTER:
      case WINPR_NDR_POINTER_NON_NULL:
      case WINPR_NDR_POINTER_FULL:
        ptr = *(WINPR_CAST_CONST_PTR_AWAY(ptr, const void**));
        break;
      case WINPR_NDR_NOT_POINTER:
      case WINPR_NDR_FIXED_ARRAY:
        break;
      default:
        WLog_ERR(TAG, "invalid field->pointerType");
        break;
    }
 
    WLog_Print(logger, lvl, "%s*%s:", tabArray, field->name);
    if (field->typeDescr->dumpFn)
      field->typeDescr->dumpFn(logger, lvl, identLevel + 1, ptr);
    else
      WLog_Print(logger, lvl, "%s\t<no dump function>", tabArray);
  }
}

References WinPrNdrMessageDescr::dumpFn, WinPrNdrStructDescr::fields, WinPrNdrFieldStruct::name, WinPrNdrStructDescr::name, WinPrNdrStructDescr::nfields, WinPrNdrFieldStruct::pointerType, WinPrNdrFieldStruct::structOffset, WinPrNdrFieldStruct::typeDescr, WINPR_NDR_FIXED_ARRAY, WINPR_NDR_NOT_POINTER, WINPR_NDR_POINTER, WINPR_NDR_POINTER_FULL, WINPR_NDR_POINTER_NON_NULL, and winpr_ndr_struct_dump_fromDescr().

Referenced by winpr_ndr_struct_dump_fromDescr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_union_destroy()

WINPR_API void winpr_ndr_union_destroy	(	const WinPrNdrUnionDescr *	descr,
		UINT32	switchValue,
		void *	obj
	)

releases the content of the arm switchValue of a union

Parameters

descr	the descriptor of the union
switchValue	the discriminant of the arm
obj	the union

Since

version 3.33.0

Definition at line 1952 of file ndr.c.

{
  WINPR_ASSERT(descr);
  WINPR_ASSERT(obj);
 
  const WinPrNdrUnionArm* arm = ndr_union_find_arm(descr, switchValue);
  if (!arm || !arm->field.typeDescr)
    return;
 
  const WinPrNdrStructDescr armStruct = { descr->name, 1, &arm->field, 0 };
  winpr_ndr_struct_destroy(&armStruct, obj);
}

References WinPrNdrUnionArm::field, WinPrNdrUnionDescr::name, WinPrNdrFieldStruct::typeDescr, winpr_ndr_struct_destroy(), and winpr_ndr_union_destroy().

Referenced by winpr_ndr_union_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_union_switch_value()

WINPR_ATTR_NODISCARD WINPR_API UINT32 winpr_ndr_union_switch_value	(	const WinPrNdrUnionDescr *	descr,
		const void *	switchField
	)

the value of the [switch_is()] field of a union

Parameters

descr	the descriptor of the union, its switchSize gives the size of the field
switchField	the [switch_is()] field, a UINT16 or a UINT32

Returns

the value of the field

Since

version 3.33.0

Definition at line 1830 of file ndr.c.

{
  WINPR_ASSERT(switchField);
 
  if (ndr_union_switch_size(descr) == 2)
    return *(const UINT16*)switchField;
  return *(const UINT32*)switchField;
}

References winpr_ndr_union_switch_value().

Referenced by winpr_ndr_union_switch_value().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_wchar_descr()

WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType winpr_ndr_wchar_descr

(

void

)

the message type of winpr_ndr_wchar_descr_s

Returns

the message type

Since

version 3.34.0

Definition at line 668 of file ndr.c.

{
  return &winpr_ndr_wchar_descr_s;
}

References winpr_ndr_wchar_descr(), and winpr_ndr_wchar_descr_s.

Referenced by winpr_ndr_wchar_descr().

Here is the call graph for this function:

Here is the caller graph for this function:

winpr_ndr_wstring_varying_descr()

WINPR_ATTR_NODISCARD WINPR_API WinPrNdrMessageType winpr_ndr_wstring_varying_descr

(

void

)

the message type of winpr_ndr_wstring_varying_descr_s

Returns

the message type

Since

version 3.33.0

Definition at line 898 of file ndr.c.

{
  return &winpr_ndr_wstring_varying_descr_s;
}

References winpr_ndr_wstring_varying_descr(), and winpr_ndr_wstring_varying_descr_s.

Referenced by winpr_ndr_wstring_varying_descr().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

winpr_ndr_string_conformant_descr_s

WINPR_API const WinPrNdrMessageDescr winpr_ndr_string_conformant_descr_s

extern

conformant string of char, read in a char* allocated with winpr_ndr_pointer_new()

Since

version 3.33.0

Definition at line 726 of file ndr.c.

                                                                 {
  WINPR_NDR_ARITY_SELF_ALLOCATED,
  sizeof(char),
  winpr_ndr_decoder_read_string_conformant,
  winpr_ndr_encoder_write_string_conformant,
  nullptr /* destroy */,
  nullptr /* dump */
};

Referenced by winpr_ndr_string_conformant_descr().

winpr_ndr_string_varying_descr_s

WINPR_API const WinPrNdrMessageDescr winpr_ndr_string_varying_descr_s

extern

[string] char*: a conformant varying string of char, read in a char* allocated with winpr_ndr_pointer_new()

Since

version 3.33.0

Definition at line 822 of file ndr.c.

                                                              {
  WINPR_NDR_ARITY_SELF_ALLOCATED,
  sizeof(char),
  winpr_ndr_decoder_read_string_varying,
  winpr_ndr_encoder_write_string_varying,
  nullptr /* destroy */,
  nullptr /* dump */
};

Referenced by winpr_ndr_string_varying_descr().

winpr_ndr_wchar_descr_s

WINPR_API const WinPrNdrMessageDescr winpr_ndr_wchar_descr_s

extern

a WCHAR, stored in UTF-16LE in memory

Since

version 3.34.0

Definition at line 663 of file ndr.c.

                                                     {
  WINPR_NDR_ARITY_SIMPLE,   sizeof(WCHAR), ndr_decoder_read_wchar_,
  ndr_encoder_write_wchar_, nullptr,       nullptr
};

Referenced by winpr_ndr_wchar_descr().

winpr_ndr_wstring_varying_descr_s

WINPR_API const WinPrNdrMessageDescr winpr_ndr_wstring_varying_descr_s

extern

[string] wchar_t*: a conformant varying string of WCHAR, read in a WCHAR* allocated with winpr_ndr_pointer_new()

Since

version 3.33.0

Definition at line 893 of file ndr.c.

                                                               {
  WINPR_NDR_ARITY_SELF_ALLOCATED,    sizeof(WCHAR),         ndr_decoder_read_wstring_varying,
  ndr_encoder_write_wstring_varying, nullptr /* destroy */, nullptr /* dump */
};

Referenced by winpr_ndr_wstring_varying_descr().