netmsgs.h File Reference

Network Messaging declarations. More...

#include <stdio.h>
#include "rnr/rnrconfig.h"

Go to the source code of this file.

Classes
struct	NMFieldThisPad_T
struct	NMFieldThisU8_T
struct	NMFieldThisU16_T
struct	NMFieldThisU32_T
struct	NMFieldThisU64_T
struct	NMFieldThisF32_T
struct	NMFieldThisF64_T
struct	NMFieldThisString_T
struct	NMFieldThisVector_T
union	NMFieldThis_T
struct	_nm_field_def_struct
struct	NMVec_T
struct	_nm_msg_def_struct

Macros
#define	NMFTYPE_IS_COMPOUND(ft)   (((ft)==NMFTypeString) || ((ft)==NMFTypeStruct) || ((ft)==NMFTypeVector))
	Returns true if field type is a compoound type. More...
#define	NMFTYPE_IS_SIMPLE(ft)   (!NMFTYPE_IS_COMPOUND(ft))
	Returns true if field type is a simple type. More...
#define	NMFVAL_LEN_CHAR   1
	character field length More...
#define	NMFVAL_LEN_U8   1
	unsigned 8-bit field value length
#define	NMFVAL_LEN_S8   1
	signed 8-bit field value length
#define	NMFVAL_LEN_BOOL   1
	boolean field length
#define	NMFVAL_LEN_U16   2
	unsigned 16-bit field value length
#define	NMFVAL_LEN_S16   2
	signed 16-bit field value length
#define	NMFVAL_LEN_U32   4
	unsigned 32-bit field value length
#define	NMFVAL_LEN_S32   4
	signed 32-bit field value length
#define	NMFVAL_LEN_U64   8
	unsigned 64-bit field value length
#define	NMFVAL_LEN_S64   8
	signed 64-bit field value length
#define	NMFVAL_LEN_F32   4
	32-bit floating-point number field val len
#define	NMFVAL_LEN_F64   8
	64-bit floating-point number field val len
#define	NMFVAL_LEN_P32   4
	32-bit pointer field value length
#define	NMFVAL_LEN_P64   8
	64-bit pointer field value length
#define	NMFVAL_LEN_BYTE   NMFVAL_LEN_U8
	unsigned char field length
#define	NMFVAL_LEN_SCHAR   NMFVAL_LEN_S8
	signed char field length
#define	NMFVAL_LEN_USHORT   NMFVAL_LEN_U16
	unsigned short field length
#define	NMFVAL_LEN_SHORT   NMFVAL_LEN_S16
	short field length
#define	NMFVAL_LEN_UINT   NMFVAL_LEN_U32
	signed int field length
#define	NMFVAL_LEN_INT   NMFVAL_LEN_U32
	unsigned int field length
#define	NMFVAL_LEN_ULONGLONG   NMFVAL_LEN_U64
	signed long long field length
#define	NMFVAL_LEN_LONGLONG   NMFVAL_LEN_U64
	unsigned long long field len
#define	NMFVAL_LEN_FLOAT   NMFVAL_LEN_F32
	float field length
#define	NMFVAL_LEN_DOUBLE   NMFVAL_LEN_F64
	double field length
#define	NMFVAL_LEN_POINTER   NMFVAL_LEN_P32
	4-byte void* field length
#define	NMFVAL_LEN_LONGPOINTER   NMFVAL_LEN_P64
	8-byte void* field length
#define	NMFVAL_LEN_STRING   0
	char[] variable field length
#define	NMFVAL_LEN_MAX_STRING   255
	max string length (excluding null)
#define	NMFVAL_LEN_STRUCT   0
	struct T variable field length
#define	NMFVAL_LEN_VECTOR   0
	VType[[] variable field length.
#define	NMFVAL_LEN_MAX_VECTOR   255
	max vector field length (num of items)
#define	NMFVAL_PAD   ((byte_t)NMFTypePadTr)
	pad field value same as tr id
#define	NMMSG_ID_NONE   0
	no message id (reserved)
#define	NMFID_NONE   0
	no field id (reserved)
#define	NMITV_MSGID_SIZE   2
	2 byte message id size More...
#define	NMITV_FID_SIZE   1
	1 byte field id size
#define	NMITV_FTYPE_SIZE   1
	1 byte field type size
#define	NMITV_FCOUNT_SIZE   1
	1 byte field count size
#define	NMITV_MSGHDR_SIZE   (NMITV_MSGID_SIZE + NMITV_FCOUNT_SIZE)
#define	NMITV_FHDR_SIZE_BASE   (NMITV_FID_SIZE + NMITV_FTYPE_SIZE)
#define	NMITV_FHDR_SIZE_SIMPLE   NMITV_FHDR_SIZE_BASE
#define	NMITV_FHDR_SIZE_STRING   (NMITV_FHDR_SIZE_BASE + NMITV_FCOUNT_SIZE)
#define	NMITV_FHDR_SIZE_STRUCT   (NMITV_FHDR_SIZE_BASE + NMITV_FCOUNT_SIZE)
#define	NMITV_FHDR_SIZE_VECTOR   (NMITV_FHDR_SIZE_BASE + NMITV_FCOUNT_SIZE + NMITV_FTYPE_SIZE)
#define	NMBITS_HAS_MIN   0x01
	field has a minimum value
#define	NMBITS_HAS_MAX   0x02
	field has a maximum value
#define	NMBITS_HAS_CONST   0x04
	field has a constant value
#define	NM_OK   0
	not an error, success More...
#define	NM_ECODE_GEN   1
	general, unspecified error
#define	NM_ECODE_NOMEM   2
	not enough buffer memory available
#define	NM_ECODE_ARCH_NOTSUP   3
	machine architecture not supported
#define	NM_ECODE_RANGE   4
	field size or value out-of-range
#define	NM_ECODE_FTYPE   5
	unknown field type
#define	NM_ECODE_EMSG   6
	bad message
#define	NM_ECODE_MSGID   7
	bad/unknown message id
#define	NM_ECODE_INTERNAL   8
	internal inconsistency or bug
#define	NM_ECODE_BADEC   9
	internal inconsistency or bug
#define	NM_ECODE_NUMOF   10
	number of error codes

Typedefs
typedef const struct _nm_field_def_struct *	NMFieldDef_P
	msg def struct More...
typedef const struct _nm_msg_def_struct *	NMMsgDef_P
	msg def pointer
typedef NMMsgDef_P	NMFieldThisStruct_T
typedef struct _nm_field_def_struct	NMFieldDef_T
typedef struct _nm_msg_def_struct	NMMsgDef_T

Enumerations
enum	NMEncoding_T {   NMEncodingFlat,   NMEncodingITV,   NMEncodingCLI,   NMEncodingNumOf }
enum	NMEndian_T {   NMEndianBig,   NMEndianLittle,   NMEndianNative }
enum	NMFType_T {   NMFTypeNone = 0,   NMFTypePadTr = 0,   NMFTypeBool = '?',   NMFTypeU8 = 'B',   NMFTypeByte = 'B',   NMFTypeF64 = 'F',   NMFTypeDouble = 'F',   NMFTypeU16 = 'H',   NMFTypeUShort = 'H',   NMFTypeU32 = 'I',   NMFTypeUInt = 'I',   NMFTypeP64 = 'P',   NMFTypeLongPointer = 'P',   NMFTypeU64 = 'Q',   NMFTypeULongLong = 'Q',   NMFTypeVector = '[',   NMFTypeS8 = 'b',   NMFTypeSChar = 'b',   NMFTypeChar = 'c',   NMFTypeF32 = 'f',   NMFTypeFloat = 'f',   NMFTypeS16 = 'h',   NMFTypeShort = 'h',   NMFTypeS32 = 'i',   NMFTypeInt = 'i',   NMFTypeP32 = 'p',   NMFTypePointer = 'p',   NMFTypeS64 = 'q',   NMFTypeLongLong = 'q',   NMFTypeString = 's',   NMFTypePad = 'x',   NMFTypeStruct = '{',   NMFTypeNumOf = 18 }

Functions
const char *	nmStrError (int ecode)
	Get the error string describing the BotSense error code. More...
void	nmPrintBuf (FILE *fp, const char *sPreface, byte_t buf[], size_t uCount, size_t uNLFreq, uint_t uCol)
	Pretty print buffer to opened file stream. More...
void	nmPrintBits (FILE *fp, const char *sPreface, ulonglong_t uVal, uint_t uMsb, uint_t uCnt)
	Pretty print bits in value. More...
size_t	nmGetFieldValSize (NMFType_T eFType)
	Get the field value byte size. More...
const NMFieldDef_T *	nmFindFieldDef (const NMMsgDef_T *pMsgDef, byte_t byFId)
	Find the field definition in the message definition, given the field id. More...
int	nmPackU8 (byte_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 8-bit byte into the message buffer. More...
int	nmPackU16 (ushort_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 16-bit integer into the message buffer. More...
int	nmPackU32 (uint_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 32-bit integer into the message buffer. More...
int	nmPackU64 (ulonglong_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 64-bit integer into the message buffer. More...
int	nmPackS64 (long long val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an signed 64-bit integer into the message buffer. More...
int	nmPackF32 (float val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 32-bit float into the message buffer. More...
int	nmPackF64 (double val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 64-bit float into the message buffer. More...
int	nmPackP32 (void *val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 32-bit pointer into the message buffer. More...
int	nmPackP64 (void *val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 64-bit pointer into the message buffer. More...
int	nmPackBuf (byte_t bufSrc[], size_t uCount, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a byte buffer into the message buffer. More...
INLINE_IN_H int	nmPackS8 (signed char val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a signed 8-bit byte into the message buffer. More...
INLINE_IN_H int	nmPackS16 (short val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a signed 16-bit integer into the message buffer. More...
INLINE_IN_H int	nmPackS32 (int val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a signed 32-bit integer into the message buffer. More...
INLINE_IN_H int	nmPackByte (byte_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a one byte value into the message buffer. More...
INLINE_IN_H int	nmPackSChar (signed char val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a signed char integer value into the message buffer. More...
INLINE_IN_H int	nmPackChar (char val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 8-bit ASCII character into the message buffer. More...
INLINE_IN_H int	nmPackBool (bool_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a boolean value into the message buffer. More...
INLINE_IN_H int	nmPackUShort (ushort_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned short integer into the message buffer. More...
INLINE_IN_H int	nmPackShort (short val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an signed short integer into the message buffer. More...
INLINE_IN_H int	nmPackUInt (uint_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned int integer into the message buffer. More...
INLINE_IN_H int	nmPackInt (int val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an signed int integer into the message buffer. More...
INLINE_IN_H int	nmPackULong (ulong_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned long integer into the message buffer. More...
INLINE_IN_H int	nmPackLong (long val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an signed long integer into the message buffer. More...
INLINE_IN_H int	nmPackULongLong (ulonglong_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned long long integer into the message buffer. More...
INLINE_IN_H int	nmPackLongLong (long long val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an signed long long integer into the message buffer. More...
INLINE_IN_H int	nmPackPointer (void *val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a (overloaded) void* pointer into the message buffer. More...
int	nmUnpackU8 (byte_t buf[], size_t bufSize, byte_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 8-bit byte from the message buffer. More...
int	nmUnpackU16 (byte_t buf[], size_t bufSize, ushort_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 16-bit integer from the message buffer. More...
int	nmUnpackU32 (byte_t buf[], size_t bufSize, uint_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 32-bit integer from the message buffer. More...
int	nmUnpackU64 (byte_t buf[], size_t bufSize, ulonglong_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 64-bit integer from the message buffer. More...
int	nmUnpackS64 (byte_t buf[], size_t bufSize, long long *pVal, NMEndian_T eEndian)
	Unpack an signed 64-bit integer from the message buffer. More...
int	nmUnpackF32 (byte_t buf[], size_t bufSize, float *pVal, NMEndian_T eEndian)
	Unpack a 32-bit float from the message buffer. More...
int	nmUnpackF64 (byte_t buf[], size_t bufSize, double *pVal, NMEndian_T eEndian)
	Unpack a 64-bit float from the message buffer. More...
int	nmUnpackP32 (byte_t buf[], size_t bufSize, void *pVal, NMEndian_T eEndian)
	Unpack a 32-bit pointer from the message buffer. More...
int	nmUnpackP64 (byte_t buf[], size_t bufSize, void *pVal, NMEndian_T eEndian)
	Unpack a 64-bit pointer from the message buffer. More...
int	nmUnpackBuf (byte_t buf[], size_t bufSize, byte_t bufDst[], size_t uCount, NMEndian_T eEndian)
	Unpack a byte buffer from the message buffer. More...
INLINE_IN_H int	nmUnpackS8 (byte_t buf[], size_t bufSize, signed char *pVal, NMEndian_T eEndian)
	Unpack a signed 8-bit byte from the message buffer. More...
INLINE_IN_H int	nmUnpackS16 (byte_t buf[], size_t bufSize, short *pVal, NMEndian_T eEndian)
	Unpack a signed 16-bit integer from the message buffer. More...
INLINE_IN_H int	nmUnpackS32 (byte_t buf[], size_t bufSize, int *pVal, NMEndian_T eEndian)
	Unpack a signed 32-bit integer from the message buffer. More...
INLINE_IN_H int	nmUnpackByte (byte_t buf[], size_t bufSize, byte_t *pVal, NMEndian_T eEndian)
	Unpack one byte from the message buffer. More...
INLINE_IN_H int	nmUnpackSChar (byte_t buf[], size_t bufSize, signed char *pVal, NMEndian_T eEndian)
	Unpack an signed short integer from the message buffer. More...
INLINE_IN_H int	nmUnpackChar (byte_t buf[], size_t bufSize, char *pVal, NMEndian_T eEndian)
	Unpack an 8-bit ASCII character from the message buffer. More...
INLINE_IN_H int	nmUnpackBool (byte_t buf[], size_t bufSize, bool_t *pVal, NMEndian_T eEndian)
	Unpack a boolean value from the message buffer. More...
INLINE_IN_H int	nmUnpackUShort (byte_t buf[], size_t bufSize, ushort_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned short integer from the message buffer. More...
INLINE_IN_H int	nmUnpackShort (byte_t buf[], size_t bufSize, short *pVal, NMEndian_T eEndian)
	Unpack an signed short integer from the message buffer. More...
INLINE_IN_H int	nmUnpackUInt (byte_t buf[], size_t bufSize, uint_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned int integer from the message buffer. More...
INLINE_IN_H int	nmUnpackInt (byte_t buf[], size_t bufSize, int *pVal, NMEndian_T eEndian)
	Unpack an signed int integer from the message buffer. More...
INLINE_IN_H int	nmUnpackULong (byte_t buf[], size_t bufSize, ulong_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned long integer from the message buffer. More...
INLINE_IN_H int	nmUnpackLong (byte_t buf[], size_t bufSize, long *pVal, NMEndian_T eEndian)
	Unpack an signed long integer from the message buffer. More...
INLINE_IN_H int	nmUnpackULongLong (byte_t buf[], size_t bufSize, ulonglong_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned long long integer from the message buffer. More...
INLINE_IN_H int	nmUnpackLongLong (byte_t buf[], size_t bufSize, long long *pVal, NMEndian_T eEndian)
	Unpack an signed long long integer from the message buffer. More...
INLINE_IN_H int	nmUnpackPointer (byte_t buf[], size_t bufSize, void *pVal, NMEndian_T eEndian)
	Unpack a (overloaded)void* pointer from the message buffer. More...
int	nmPackITVMsg (const NMMsgDef_T *pMsgDef, void *pStruct, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an ITV message. More...
int	nmPackITVMsgDebug (const NMMsgDef_T *pMsgDef, void *pStruct, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an ITV message, tracing message packing to stderr. More...
int	nmUnpackITVMsg (const NMMsgDef_T *pMsgDef, byte_t buf[], size_t uMsgLen, void *pStruct, NMEndian_T eEndian)
	Unpack a ITV message. More...
int	nmUnpackITVMsgDebug (const NMMsgDef_T *pMsgDef, byte_t buf[], size_t uMsgLen, void *pStruct, NMEndian_T eEndian)
	Unpack a ITV message, tracing unpacking to stderr. More...
uint_t	nmGetITVMsgId (byte_t buf[], size_t uMsgLen, NMEndian_T eEndian)
	Get ITV message id from input buffer. More...
int	nmPackFlatMsg (const NMMsgDef_T *pMsgDef, void *pStruct, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an Flat message. More...
int	nmPackFlatMsgDebug (const NMMsgDef_T *pMsgDef, void *pStruct, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an Flat message, tracing message packing to stderr. More...
int	nmUnpackFlatMsg (const NMMsgDef_T *pMsgDef, byte_t buf[], size_t uMsgLen, void *pStruct, NMEndian_T eEndian)
	Unpack a Flat message. More...
int	nmUnpackFlatMsgDebug (const NMMsgDef_T *pMsgDef, byte_t buf[], size_t uMsgLen, void *pStruct, NMEndian_T eEndian)
	Unpack a Flat message, tracing unpacking to stderr. More...

Detailed Description

Network Messaging declarations.

LastChangedDate

2010-07-31 08:48:56 -0600 (Sat, 31 Jul 2010)

Rev

521

Note

This file must be swig-able to generate a python extension module.

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2009-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file netmsgs.h.

Macro Definition Documentation

#define NMFTYPE_IS_COMPOUND

(

ft

)

(((ft)==NMFTypeString) || ((ft)==NMFTypeStruct) || ((ft)==NMFTypeVector))

Returns true if field type is a compoound type.

Parameters

ft	Field type.

Definition at line 156 of file netmsgs.h.

#define NMFTYPE_IS_SIMPLE

(

ft

)

(!NMFTYPE_IS_COMPOUND(ft))

Returns true if field type is a simple type.

Parameters

ft	Field type.

Definition at line 164 of file netmsgs.h.

Referenced by nmPackFlatVector(), nmPackITVVector(), and nmUnpackITVVector().

#define NMFVAL_LEN_CHAR   1

character field length

Message packed field value lengths in bytes.

Definition at line 171 of file netmsgs.h.

#define NMITV_FHDR_SIZE_BASE   (NMITV_FID_SIZE + NMITV_FTYPE_SIZE)

number of bytes in header to identify and quatify field (fid, ftype)

Definition at line 225 of file netmsgs.h.

Referenced by nmUnpackITVStream().

#define NMITV_FHDR_SIZE_SIMPLE   NMITV_FHDR_SIZE_BASE

number of bytes in simple field header (fid, ftype)

Definition at line 228 of file netmsgs.h.

Referenced by nmPackITVHdrSimple(), nmUnpackITVBool(), nmUnpackITVF32(), nmUnpackITVF64(), nmUnpackITVP32(), nmUnpackITVP64(), nmUnpackITVS16(), nmUnpackITVS32(), nmUnpackITVS64(), nmUnpackITVS8(), nmUnpackITVU16(), nmUnpackITVU32(), nmUnpackITVU64(), and nmUnpackITVU8().

#define NMITV_FHDR_SIZE_STRING   (NMITV_FHDR_SIZE_BASE + NMITV_FCOUNT_SIZE)

number of bytes in string field header (fid, ftype, count)

Definition at line 231 of file netmsgs.h.

Referenced by nmPackITVHdrSimple(), nmPackITVHdrString(), and nmUnpackITVString().

#define NMITV_FHDR_SIZE_STRUCT   (NMITV_FHDR_SIZE_BASE + NMITV_FCOUNT_SIZE)

number of bytes in struct field header (fid, ftype, count)

Definition at line 234 of file netmsgs.h.

Referenced by nmPackITVHdrStruct(), and nmUnpackITVStruct().

#define NMITV_FHDR_SIZE_VECTOR   (NMITV_FHDR_SIZE_BASE + NMITV_FCOUNT_SIZE + NMITV_FTYPE_SIZE)

number of bytes in vector field header (fid, ftype, count, vtype)

Definition at line 237 of file netmsgs.h.

Referenced by nmPackITVHdrVector(), and nmUnpackITVVector().

#define NMITV_MSGHDR_SIZE   (NMITV_MSGID_SIZE + NMITV_FCOUNT_SIZE)

message leading number of bytes for message header (msgid, fcount)

Definition at line 222 of file netmsgs.h.

Referenced by nmGetITVMsgId(), nmPackITVMsg(), nmPackITVMsgDebug(), nmUnpackITVMsg(), and nmUnpackITVMsgDebug().

#define NMITV_MSGID_SIZE   2

2 byte message id size

ITV Messge and Field encodings/decodings.

Definition at line 216 of file netmsgs.h.

Typedef Documentation

typedef const struct _nm_field_def_struct* NMFieldDef_P

msg def struct

field def pointer

Definition at line 250 of file netmsgs.h.

typedef struct _nm_field_def_struct NMFieldDef_T

Message Field Definition Type

typedef NMMsgDef_P NMFieldThisStruct_T

This strcuture field definition specific information. (equivalent to a submessage)

Definition at line 347 of file netmsgs.h.

typedef struct _nm_msg_def_struct NMMsgDef_T

Message Definition Type

Enumeration Type Documentation

enum NMEncoding_T

Message Encoding Type Enumeration

Enumerator
NMEncodingFlat	flat (no field header and fixed size) encoding
NMEncodingITV	id-type-value encoding
NMEncodingCLI	command-line interface encoding (future)
NMEncodingNumOf	number of different encodings supported

Definition at line 89 of file netmsgs.h.

{
  NMEncodingFlat,     ///< flat (no field header and fixed size) encoding
  NMEncodingITV,      ///< id-type-value encoding
  NMEncodingCLI,      ///< command-line interface encoding (future)
  NMEncodingNumOf     ///< number of different encodings supported
} NMEncoding_T;

enum NMEndian_T

Message Byte Ordering Type Enumeration

Enumerator
NMEndianBig	Most Significant Byte first.
NMEndianLittle	Least Significant Byte first.
NMEndianNative	native processor order

Definition at line 100 of file netmsgs.h.

{
  NMEndianBig,        ///< Most Significant Byte first
  NMEndianLittle,     ///< Least Significant Byte first
  NMEndianNative      ///< native processor order
} NMEndian_T;

enum NMFType_T

Message Field Type Code Enumeration

Enumerator
NMFTypeNone	no field type -
NMFTypePadTr	translated pad type for packed stream
NMFTypeBool	8-bit bool 0/1 bool_t
NMFTypeU8	unsigned 8-bit integer unsigned char
NMFTypeByte	U8 alias.
NMFTypeF64	64-bit IEEE 754 FPN double
NMFTypeDouble	F64 alias.
NMFTypeU16	unsigned 16-bit integer unsigned short
NMFTypeUShort	U16 alias.
NMFTypeU32	unsigned 32-bit integer unsigned int
NMFTypeUInt	U32 alias.
NMFTypeP64	64-bit pointer (overloaded) void*
NMFTypeLongPointer	P64 alias.
NMFTypeU64	unsigned 64-bit integer unsigned long long
NMFTypeULongLong	U64 alias.
NMFTypeVector	one dimensional array VType[]
NMFTypeS8	signed 8-bit integer signed char
NMFTypeSChar	S8 alias.
NMFTypeChar	8-bit ASCII characters char
NMFTypeF32	32-bit IEEE 754 FPN float
NMFTypeFloat	F32 alias.
NMFTypeS16	signed 16-bit integer short
NMFTypeShort	S16 alias.
NMFTypeS32	signed 32-bit integer int
NMFTypeInt	S32 alias.
NMFTypeP32	32-bit pointer (overloaded) void*
NMFTypePointer	P32 alias.
NMFTypeS64	signed 64-bit integer long long
NMFTypeLongLong	S64 alias.
NMFTypeString	string char[]
NMFTypePad	pad internal field type
NMFTypeStruct	structure struct T
NMFTypeNumOf	number of

Definition at line 110 of file netmsgs.h.

{
  NMFTypeNone       = 0,      ///< no field type            -
  NMFTypePadTr      = 0,      ///< translated pad type for packed stream

  // enum             value        message field            C data type
  // ----             -----        -------------            ------------
  NMFTypeBool         = '?',  ///< 8-bit bool 0/1           bool_t
  NMFTypeU8           = 'B',  ///< unsigned 8-bit integer   unsigned char
  NMFTypeByte         = 'B',  ///< U8 alias
  NMFTypeF64          = 'F',  ///< 64-bit IEEE 754 FPN      double
  NMFTypeDouble       = 'F',  ///< F64 alias
  NMFTypeU16          = 'H',  ///< unsigned 16-bit integer  unsigned short
  NMFTypeUShort       = 'H',  ///< U16 alias
  NMFTypeU32          = 'I',  ///< unsigned 32-bit integer  unsigned int
  NMFTypeUInt         = 'I',  ///< U32 alias
  NMFTypeP64          = 'P',  ///< 64-bit pointer           (overloaded) void*
  NMFTypeLongPointer  = 'P',  ///< P64 alias
  NMFTypeU64          = 'Q',  ///< unsigned 64-bit integer  unsigned long long
  NMFTypeULongLong    = 'Q',  ///< U64 alias
  NMFTypeVector       = '[',  ///< one dimensional array    VType[]
  NMFTypeS8           = 'b',  ///< signed 8-bit integer     signed char
  NMFTypeSChar        = 'b',  ///< S8 alias
  NMFTypeChar         = 'c',  ///< 8-bit ASCII characters   char
  NMFTypeF32          = 'f',  ///< 32-bit IEEE 754 FPN      float
  NMFTypeFloat        = 'f',  ///< F32 alias
  NMFTypeS16          = 'h',  ///< signed 16-bit integer    short
  NMFTypeShort        = 'h',  ///< S16 alias
  NMFTypeS32          = 'i',  ///< signed 32-bit integer    int
  NMFTypeInt          = 'i',  ///< S32 alias
  NMFTypeP32          = 'p',  ///< 32-bit pointer           (overloaded) void*
  NMFTypePointer      = 'p',  ///< P32 alias
  NMFTypeS64          = 'q',  ///< signed 64-bit integer    long long
  NMFTypeLongLong     = 'q',  ///< S64 alias
  NMFTypeString       = 's',  ///< string                   char[]
  NMFTypePad          = 'x',  ///< pad internal field type
  NMFTypeStruct       = '{',  ///< structure                struct T

  NMFTypeNumOf        = 18    ///< number of
} NMFType_T;

Function Documentation

const NMFieldDef_T* nmFindFieldDef	(	const NMMsgDef_T *	pMsgDef,
		byte_t	byFId
	)

Find the field definition in the message definition, given the field id.

Parameters

pMsgDef	Pointer to message definition.
byFId	Field Id.

Returns

If the field definition is found, then the pointer to the field definition is returned. Else NULL is return.

Definition at line 235 of file nmLibUtils.c.

References _nm_field_def_struct::m_eFId, _nm_msg_def_struct::m_pFields, and _nm_msg_def_struct::m_uCount.

Referenced by nmUnpackITVStream().

{
  size_t  i;

  for(i=0; i<pMsgDef->m_uCount; ++i)
  { 
    if( pMsgDef->m_pFields[i].m_eFId == byFId )
    {
      return &(pMsgDef->m_pFields[i]);
    }
  }

  return NULL;
}

size_t nmGetFieldValSize

(

NMFType_T

eFType

)

Get the field value byte size.

Parameters

eFType

Field type.

Returns

Returns field value byte size. Returns 0 if field type is unknown or is variable in length.

Definition at line 209 of file nmLibUtils.c.

References NMFValLenLookupTbl, NMHashFType(), and NMHashNoIdx.

{
  int idx;
 
  idx = NMHashFType(eFType);

  if( (idx != NMHashNoIdx) && (idx < arraysize(NMFValLenLookupTbl)) )
  {
    return NMFValLenLookupTbl[idx];
  }
  else
  {
    return (size_t)0;
  }
}

uint_t nmGetITVMsgId	(	byte_t	buf[],
		size_t	uMsgLen,
		NMEndian_T	eEndian
	)

Get ITV message id from input buffer.

Parameters

[in]	buf	Input message buffer.
	uMsgLen	Length of message (bytes) in input buffer.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns unpacked message id.
On error, returns NMMSG_ID_NONE (0).

Definition at line 2482 of file nmLibPackITV.c.

References NMITV_MSGHDR_SIZE, NMMSG_ID_NONE, and nmUnpackU16().

Referenced by nmUnpackPointer().

{
  ushort_t  eMsgId; // message id in buffer
  int       n;

  // too small
  if( uMsgLen < NMITV_MSGHDR_SIZE )
  {
    return (uint_t)NMMSG_ID_NONE;
  }
  
  // unpack message id
  else if( (n = nmUnpackU16(buf, uMsgLen, &eMsgId, eEndian)) < 0 )
  {
    return (uint_t)NMMSG_ID_NONE;
  }

  else
  {
    return (uint_t)eMsgId;
  }
}

INLINE_IN_H int nmPackBool	(	bool_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a boolean value into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 564 of file netmsgs.h.

References nmPackU8().

Referenced by nmPackFlatBool(), and nmPackITVBool().

{
  val &= 0xff;  // clear unused upper bits
  return nmPackU8((byte_t)val, buf, bufSize, eEndian);
}

int nmPackBuf	(	byte_t	bufSrc[],
		size_t	uCount,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a byte buffer into the message buffer.

The source and message buffer memory areas can overlap.

Note

The buffer is always packed in sequential order ignoring the byte order parameter.

Parameters

[in]	bufSrc	Source buffer.
	uCount	Number of bytes to copy.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1215 of file nmLibPack.c.

References _NM_CHK_MEM.

{
  _NM_CHK_MEM(bufSize, uCount);

  // safe copy 
  memmove(buf, bufSrc, uCount);

  return (int)uCount;
}

INLINE_IN_H int nmPackByte	(	byte_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a one byte value into the message buffer.

Alias for nmPackU8().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 526 of file netmsgs.h.

References nmPackU8().

{
  return nmPackU8((byte_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackChar	(	char	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 8-bit ASCII character into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 552 of file netmsgs.h.

References nmPackU8().

{
  return nmPackU8((byte_t)val, buf, bufSize, eEndian);
}

int nmPackF32	(	float	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 32-bit float into the message buffer.

The IEEE 754 32-bit format is used with both the big and little endian byte orders.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 957 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, IEEE754_F32_EXPONENT_MASK, IEEE754_F32_EXPONENT_SHIFT, IEEE754_F32_MANTISSA_MASK, IEEE754_F32_MANTISSA_SHIFT, IEEE754_F32_SIGN_MASK, IEEE754_F32_SIGN_SHIFT, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatF32(), and nmPackITVF32().

{
  static size_t fvalLen = NMFVAL_LEN_F32;     // message field value length

  union ieee754_float f;      // 4 byte floating-point number
  uint_t              uBits;  // bits

  _NM_CHK_MEM(bufSize, fvalLen);
  _NM_CHK_ARCH(val, fvalLen);

  f.f = val;

  uBits  = (uint_t)((f.ieee.negative & IEEE754_F32_SIGN_MASK)
                      << IEEE754_F32_SIGN_SHIFT);
  uBits |= (uint_t)((f.ieee.exponent & IEEE754_F32_EXPONENT_MASK)
                      << IEEE754_F32_EXPONENT_SHIFT);
  uBits |= (uint_t)((f.ieee.mantissa & IEEE754_F32_MANTISSA_MASK)
                      << IEEE754_F32_MANTISSA_SHIFT);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACKLITTLE(uBits, buf);
      break;
    case NMEndianNative:
      PACKNATIVE(f.f, buf);
      break;
    case NMEndianBig:
    default:
      PACKBIG(uBits, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackF64	(	double	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 64-bit float into the message buffer.

The IEEE 754 64-bit format is used with both the big and little endian byte orders. If the machine architecture only supports 32-bit doubles, then a conversion to 64-bit representation is performed first.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1013 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, IEEE754_F32_F64_MANTISSA0_SHIFT, IEEE754_F32_F64_MANTISSA1_MASK, IEEE754_F32_F64_MANTISSA1_SHIFT, ieee754_f32_is_inf(), ieee754_f32_is_nan(), ieee754_f32_is_zero(), IEEE754_F64_EXPONENT_MASK, IEEE754_F64_EXPONENT_SHIFT, IEEE754_F64_Inf, IEEE754_F64_MANTISSA0_MASK, IEEE754_F64_MANTISSA0_SHIFT, IEEE754_F64_MANTISSA1_MASK, IEEE754_F64_MANTISSA1_SHIFT, IEEE754_F64_NaN, IEEE754_F64_SIGN_MASK, IEEE754_F64_SIGN_SHIFT, IEEE754_F64_Zero, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, NMFVAL_LEN_F64, PACK64BIG, PACK64LITTLE, and PACK64NATIVE.

Referenced by nmPackFlatF64(), and nmPackITVF64().

{
  static size_t fvalLen = NMFVAL_LEN_F64;     // message field value length

  union ieee754_float   f;        // 4-byte floating-point number
  union ieee754_double  d;        // 8-byte floating-point number
  uint_t                uMSB;     // Most Signifcant Bytes
  uint_t                uLSB;     // Least Signifcant Bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte double
  if( sizeof(double) == fvalLen )
  {
    d.d = val;
  }

  // 4-byte double
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_F32);

    f.f = (float)val;

    // special infinity cases
    if( ieee754_f32_is_inf(f) )
    {
      d = IEEE754_F64_Inf;
    }

    // special zero cases
    else if( ieee754_f32_is_zero(f) )
    {
      d = IEEE754_F64_Zero;
    }

    // special Not-a-Number case
    else if( ieee754_f32_is_nan(f) )
    {
      d = IEEE754_F64_NaN;
    }
    
    // "normal" floating-point numbers
    else
    {
      d.ieee.exponent   = (f.ieee.exponent  + (uint_t)IEEE754_DOUBLE_BIAS
                                            - (uint_t)IEEE754_FLOAT_BIAS)
                            & IEEE754_F64_EXPONENT_MASK;
      d.ieee.mantissa0  = ((uint_t)(f.ieee.mantissa 
                                  >> (uint_t)IEEE754_F32_F64_MANTISSA0_SHIFT))
                            & IEEE754_F64_MANTISSA0_MASK;
      d.ieee.mantissa1  = (((uint_t)(f.ieee.mantissa)) 
                                  & (uint_t)IEEE754_F32_F64_MANTISSA1_MASK)
                            << IEEE754_F32_F64_MANTISSA1_SHIFT;
    }

    // preserve the sign
    d.ieee.negative = f.ieee.negative;
  }

  //
  // Stuff the bits into two 4-byte unsigned integers.
  //
  uMSB  = (uint_t)((d.ieee.negative & IEEE754_F64_SIGN_MASK)
                        << IEEE754_F64_SIGN_SHIFT);
  uMSB |= (uint_t)((d.ieee.exponent & IEEE754_F64_EXPONENT_MASK)
                        << IEEE754_F64_EXPONENT_SHIFT);
  uMSB |= (uint_t)((d.ieee.mantissa0 & IEEE754_F64_MANTISSA0_MASK)
                        << IEEE754_F64_MANTISSA0_SHIFT);
  uLSB  = (uint_t)((d.ieee.mantissa1 & IEEE754_F64_MANTISSA1_MASK)
                        << IEEE754_F64_MANTISSA1_SHIFT);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACK64LITTLE(uMSB, uLSB, buf);
      break;
    case NMEndianNative:
      PACK64NATIVE(uMSB, uLSB, buf);
      break;
    case NMEndianBig:
    default:
      PACK64BIG(uMSB, uLSB, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackFlatMsg	(	const NMMsgDef_T *	pMsgDef,
		void *	pStruct,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an Flat message.

Parameters

	pMsgDef	Pointer to message definition.
[in]	pStruct	Pointer to the associated, populated message structure.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1417 of file nmLibPackFlat.c.

References NMCtl_T::m_bNoHdr, NMCTL_INIT_DECL, and nmPackFlatStream().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  int       n;      // byte count/error code

  ctl.m_bNoHdr  = true;

  // pack stream
  n = nmPackFlatStream(pMsgDef, pStruct, buf, bufSize, eEndian, &ctl);

  return n;
}

int nmPackFlatMsgDebug	(	const NMMsgDef_T *	pMsgDef,
		void *	pStruct,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an Flat message, tracing message packing to stderr.

Parameters

	pMsgDef	Pointer to message definition.
[in]	pStruct	Pointer to the associated, populated message structure.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1446 of file nmLibPackFlat.c.

References NMCtl_T::m_bNoHdr, NMCtl_T::m_bTrace, _nm_msg_def_struct::m_eMsgId, _nm_msg_def_struct::m_sMsgName, _nm_msg_def_struct::m_uCount, NMCTL_INIT_DECL, nmPackFlatStream(), and nmPrintBuf().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  int       n;      // byte count/error code

  ctl.m_bNoHdr  = true;
  ctl.m_bTrace  = true;

  // trace
  fprintf(stderr, "\n--- Packing Flat Message %s(%u): field_count=%zu\n",
                  pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, pMsgDef->m_uCount);

  // pack stream
  n = nmPackFlatStream(pMsgDef, pStruct, buf, bufSize, eEndian, &ctl);

  // trace final buffer
  if( n > 0 )
  {
    fprintf(stderr, "Output Buffer (%zu bytes):\n", (size_t)n);
    nmPrintBuf(stderr, NULL, buf, (size_t)n, 16, 0);
    fprintf(stderr, "\n");
  }

  return n;
}

INLINE_IN_H int nmPackInt	(	int	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an signed int integer into the message buffer.

Alias for nmPackS32().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 621 of file netmsgs.h.

References nmPackU32().

{
  return nmPackU32((uint_t)val, buf, bufSize, eEndian);
}

int nmPackITVMsg	(	const NMMsgDef_T *	pMsgDef,
		void *	pStruct,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an ITV message.

Parameters

	pMsgDef	Pointer to message definition.
[in]	pStruct	Pointer to the associated, populated message structure.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 2254 of file nmLibPackITV.c.

References _nm_msg_def_struct::m_eMsgId, _nm_msg_def_struct::m_sMsgName, _nm_msg_def_struct::m_uCount, NM_ECODE_NOMEM, NMCTL_INIT_DECL, NMITV_MSGHDR_SIZE, NMLIB_RAISE_ERROR, nmPackITVStream(), and nmPackU16().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  int       n;      // byte count/error code
  int       k;      // subbyte count/error code

  // too small
  if( bufSize < NMITV_MSGHDR_SIZE )
  {
    NMLIB_RAISE_ERROR(NM_ECODE_NOMEM, "%s(%u): msg_len=%u, hdr_size=%u",
            pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, bufSize, NMITV_MSGHDR_SIZE);
  }

  // pack message id
  if( (n = nmPackU16((ushort)(pMsgDef->m_eMsgId), buf, bufSize, eEndian)) < 0 )
  {
    return n;
  }

  // pack field count
  buf[n++] = (byte_t)pMsgDef->m_uCount;

  // pack stream
  k = nmPackITVStream(pMsgDef, pStruct, &buf[n], bufSize-(size_t)n, eEndian,
                                &ctl);

  return k >= 0? n+k: k;
}

int nmPackITVMsgDebug	(	const NMMsgDef_T *	pMsgDef,
		void *	pStruct,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an ITV message, tracing message packing to stderr.

Parameters

	pMsgDef	Pointer to message definition.
[in]	pStruct	Pointer to the associated, populated message structure.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 2299 of file nmLibPackITV.c.

References NMCtl_T::m_bTrace, _nm_msg_def_struct::m_eMsgId, _nm_msg_def_struct::m_sMsgName, _nm_msg_def_struct::m_uCount, NM_ECODE_NOMEM, NMCTL_INIT_DECL, NMITV_MSGHDR_SIZE, NMLIB_RAISE_ERROR, nmPackITVStream(), nmPackU16(), and nmPrintBuf().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  int       n;      // byte count/error code
  int       k;      // subbyte count/error code

  ctl.m_bTrace  = true;

  // too small
  if( bufSize < NMITV_MSGHDR_SIZE )
  {
    NMLIB_RAISE_ERROR(NM_ECODE_NOMEM, "%s(%u): msg_len=%u, hdr_size=%u",
            pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, bufSize, NMITV_MSGHDR_SIZE);
  }

  // pack message id
  if( (n = nmPackU16((ushort)(pMsgDef->m_eMsgId), buf, bufSize, eEndian)) < 0 )
  {
    return n;
  }

  // pack field count
  buf[n++] = (byte_t)pMsgDef->m_uCount;

  // trace
  fprintf(stderr, "\n--- Packing ITV Message %s(%u): field_count=%zu\n",
                  pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, pMsgDef->m_uCount);

  // pack stream
  k = nmPackITVStream(pMsgDef, pStruct, &buf[n], bufSize-(size_t)n, eEndian,
                                &ctl);

  if( k < 0 )
  {
    return k;
  }

  n += k;

  // trace final buffer
  fprintf(stderr, "Output Buffer (%zu bytes):\n", (size_t)n);
  nmPrintBuf(stderr, NULL, buf, (size_t)n, 16, 0);
  fprintf(stderr, "\n");

  return n;
}

INLINE_IN_H int nmPackLong	(	long	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an signed long integer into the message buffer.

Alias for nmPackS32() or nmPackS64() depending on sizeof(long).

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 651 of file netmsgs.h.

References nmPackS32(), and nmPackS64().

{
  return sizeof(long) == 4?
              nmPackS32((int)val, buf, bufSize, eEndian):
              nmPackS64((long long)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackLongLong	(	long long	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an signed long long integer into the message buffer.

Alias for nmPackS64().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 681 of file netmsgs.h.

References nmPackS64().

{
  return nmPackS64((long long)val, buf, bufSize, eEndian);
}

int nmPackP32	(	void *	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 32-bit pointer into the message buffer.

If the machine architecture has 64-bit pointers, then only the LSB 4 bytes are packed.

Note

Pointer is always packed in native byte order.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1113 of file nmLibPack.c.

References _NM_CHK_MEM, NMFVAL_LEN_P32, NMFVAL_LEN_P64, NMLIB_WARNING, and PACKNATIVE.

Referenced by nmPackFlatP32(), nmPackITVP32(), and nmPackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P32;     // message field value length
  ulong_t       luVal;
  uint_t        uVal;

  _NM_CHK_MEM(bufSize, fvalLen);

  // long's are same size as void *'s. exceptions?
  luVal = *((ulong_t *)val);

  // 4-byte natvie pointer
  if( sizeof(void *) == fvalLen )
  {
    PACKNATIVE(luVal, buf);
  }

  // 8-byte native pointer - "convert"
  if( sizeof(void *) == NMFVAL_LEN_P64 )
  {
#if HOST_WORD_SIZE == 64
    //if( luVal & 0xffffffff00000000 )
    if( (luVal) & 0xffffffff00000000 )
    {
      NMLIB_WARNING("%p: Packing 64-bit pointer in 32 bits lost non-zero "
                    "significance.", (void *)luVal);
    }
#endif // HOST_WORD_SIZE
    uVal = (uint_t)(luVal & 0xffffffff);
    PACKNATIVE(uVal, buf);
  }


  return (int)fvalLen;
}

int nmPackP64	(	void *	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 64-bit pointer into the message buffer.

If the machine architecture only supports 32-bit pointers, then the 4 MSBs are padded with 0's.

Note

Pointer is always packed in native byte order.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1160 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMFVAL_LEN_P32, NMFVAL_LEN_P64, and PACK64NATIVE.

Referenced by nmPackFlatP64(), nmPackITVP64(), and nmPackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P64;     // message field value length

  ulong_t               luVal;
  uint_t                uMSB;     // Most Signifcant Bytes
  uint_t                uLSB;     // Least Signifcant Bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // long's are same size as void *'s. exceptions?
  luVal = *((ulong_t *)val);

  // 8-byte pointer
  if( sizeof(void *) == fvalLen )
  {
#if HOST_WORD_SIZE == 64
    uMSB  = (uint_t)(luVal >> 32);
    uLSB  = (uint_t)(luVal & 0xffffffff);
#else
    uMSB  = 0;
    uLSB  = (uint_t)luVal;
#endif // HOST_WORD_SIZE
  }

  // 4-byte pointer
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_P32);

    uMSB  = 0;
    uLSB  = (uint_t)luVal;
  }

  PACK64NATIVE(uMSB, uLSB, buf);

  return (int)fvalLen;
}

INLINE_IN_H int nmPackPointer	(	void *	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a (overloaded) void* pointer into the message buffer.

Alias for nmPackP32() or nmPackP64() depending on sizeof(void*).

Note

Pointer is always packed in native byte order.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 697 of file netmsgs.h.

References nmPackP32(), nmPackP64(), nmUnpackBuf(), nmUnpackF32(), nmUnpackF64(), nmUnpackP32(), nmUnpackP64(), nmUnpackS64(), nmUnpackU16(), nmUnpackU32(), nmUnpackU64(), and nmUnpackU8().

{
  return sizeof(void*) == 4?
              nmPackP32(val, buf, bufSize, eEndian):
              nmPackP64(val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackS16	(	short	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a signed 16-bit integer into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 500 of file netmsgs.h.

References nmPackU16().

Referenced by nmPackFlatS16(), and nmPackITVS16().

{
  return nmPackU16((ushort_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackS32	(	int	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a signed 32-bit integer into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 512 of file netmsgs.h.

References nmPackU32().

Referenced by nmPackFlatS32(), nmPackITVS32(), and nmPackLong().

{
  return nmPackU32((uint_t)val, buf, bufSize, eEndian);
}

int nmPackS64	(	long long	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an signed 64-bit integer into the message buffer.

If the machine architecture only supports 32-bit long longs, then the 4 MSBs are signed extended.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 885 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_S32, NMFVAL_LEN_S64, PACK64BIG, PACK64LITTLE, PACK64NATIVE, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatS64(), nmPackITVS64(), nmPackLong(), and nmPackLongLong().

{
  static size_t fvalLen = NMFVAL_LEN_S64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte signed long long
  if( sizeof(long long) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        PACKLITTLE(val, buf);
        break;
      case NMEndianNative:
        PACKNATIVE(val, buf);
        break;
      case NMEndianBig:
      default:
        PACKBIG(val, buf);
        break;
    }
  }

  // 4-byte signed long long
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_S32);

    uMSB = val & 0x80000000? 0xffffffff: 0x00000000;  // extend sign
    uLSB = (uint_t)val;

    switch( eEndian )
    {
      case NMEndianLittle:
        PACK64LITTLE(uMSB, uLSB, buf);
        break;
      case NMEndianNative:
        PACK64NATIVE(uMSB, uLSB, buf);
        break;
      case NMEndianBig:
      default:
        PACK64BIG(uMSB, uLSB, buf);
        break;
    }
  }

  return (int)fvalLen;
}

INLINE_IN_H int nmPackS8	(	signed char	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a signed 8-bit byte into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 488 of file netmsgs.h.

References nmPackU8().

Referenced by nmPackFlatS8(), and nmPackITVS8().

{
  return nmPackU8((byte_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackSChar	(	signed char	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a signed char integer value into the message buffer.

Alias for nmPackS8().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 540 of file netmsgs.h.

References nmPackU8().

{
  return nmPackU8((byte_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackShort	(	short	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an signed short integer into the message buffer.

Alias for nmPackS16().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 593 of file netmsgs.h.

References nmPackU16().

{
  return nmPackU16((ushort_t)val, buf, bufSize, eEndian);
}

int nmPackU16	(	ushort_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 16-bit integer into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 762 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U16, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatU16(), nmPackITVMsg(), nmPackITVMsgDebug(), nmPackITVU16(), nmPackS16(), nmPackShort(), and nmPackUShort().

{
  static size_t fvalLen = NMFVAL_LEN_U16;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACKLITTLE(val, buf);
      break;
    case NMEndianNative:
      PACKNATIVE(val, buf);
      break;
    case NMEndianBig:
    default:
      PACKBIG(val, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackU32	(	uint_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 32-bit integer into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 791 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatU32(), nmPackInt(), nmPackITVU32(), nmPackS32(), nmPackUInt(), and nmPackULong().

{
  static size_t fvalLen = NMFVAL_LEN_U32;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACKLITTLE(val, buf);
      break;
    case NMEndianNative:
      PACKNATIVE(val, buf);
      break;
    case NMEndianBig:
    default:
      PACKBIG(val, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackU64	(	ulonglong_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 64-bit integer into the message buffer.

If the machine architecture only supports 32-bit long longs, then the 4 MSBs are padded with zero's.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 823 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, NMFVAL_LEN_U64, PACK64BIG, PACK64LITTLE, PACK64NATIVE, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatU64(), nmPackITVU64(), nmPackULong(), and nmPackULongLong().

{
  static size_t fvalLen = NMFVAL_LEN_U64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte unsigned long long
  if( sizeof(ulonglong_t) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        PACKLITTLE(val, buf);
        break;
      case NMEndianNative:
        PACKNATIVE(val, buf);
        break;
      case NMEndianBig:
      default:
        PACKBIG(val, buf);
        break;
    }
  }

  // 4-byte unsigned long long
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_U32);

    uMSB = 0;
    uLSB = (uint_t)val;

    switch( eEndian )
    {
      case NMEndianLittle:
        PACK64LITTLE(uMSB, uLSB, buf);
        break;
      case NMEndianNative:
        PACK64NATIVE(uMSB, uLSB, buf);
        break;
      case NMEndianBig:
      default:
        PACK64BIG(uMSB, uLSB, buf);
        break;
    }
  }

  return (int)fvalLen;
}

int nmPackU8	(	byte_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 8-bit byte into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 745 of file nmLibPack.c.

References _NM_CHK_MEM, and NMFVAL_LEN_U8.

Referenced by nmPackBool(), nmPackByte(), nmPackChar(), nmPackFlatU8(), nmPackITVU8(), nmPackS8(), and nmPackSChar().

{
  static size_t fvalLen = NMFVAL_LEN_U8;      // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  buf[0] = val & 0xff;

  return (int)fvalLen;
}

INLINE_IN_H int nmPackUInt	(	uint_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned int integer into the message buffer.

Alias for nmPackU32().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 607 of file netmsgs.h.

References nmPackU32().

{
  return nmPackU32((uint_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackULong	(	ulong_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned long integer into the message buffer.

Alias for nmPackU32() or nmPackU64() depending on sizeof(ulong_t).

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 635 of file netmsgs.h.

References nmPackU32(), and nmPackU64().

{
  return sizeof(ulong_t) == 4?
              nmPackU32((uint_t)val, buf, bufSize, eEndian):
              nmPackU64((ulonglong_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackULongLong	(	ulonglong_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned long long integer into the message buffer.

Alias for nmPackU64().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 667 of file netmsgs.h.

References nmPackU64().

{
  return nmPackU64((ulonglong_t)val, buf, bufSize, eEndian);
}

INLINE_IN_H int nmPackUShort	(	ushort_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned short integer into the message buffer.

Alias for nmPackU16().

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 579 of file netmsgs.h.

References nmPackU16().

{
  return nmPackU16((ushort_t)val, buf, bufSize, eEndian);
}

void nmPrintBits	(	FILE *	fp,
		const char *	sPreface,
		ulonglong_t	uVal,
		uint_t	uMsb,
		uint_t	uCnt
	)

Pretty print bits in value.

Parameters

fp	File pointer.
sPreface	Optional bit preface string (set to NULL for no preface).
uVal	Bits to print.
uMsb	Starting most significant bit.
uCnt	Number of bits.

Definition at line 174 of file nmLibUtils.c.

{
  uint_t i;

  if( sPreface && *sPreface )
  {
    fprintf(fp, "%s:", sPreface);
  }

  for(i=0; i<uCnt; ++i)
  {
    if( (uMsb % 8) == 7 )
    {
      if( i != 0 )
      {
        printf(" ");
      }
    }
    (uVal >> uMsb) & 0x01?  printf("1"): printf("0");
    --uMsb;
  }
}

void nmPrintBuf	(	FILE *	fp,
		const char *	sPreface,
		byte_t	buf[],
		size_t	uCount,
		size_t	uNLFreq,
		uint_t	uCol
	)

Pretty print buffer to opened file stream.

Parameters

fp	File pointer.
sPreface	Optional buffer preface string (set to NULL for no preface).
buf	Buffer to print.
uCount	Number of bytes to print.
uNLFreq	Newline frequency (set to 0 for no newlines).
uCol	Column alignment number.

Definition at line 138 of file nmLibUtils.c.

Referenced by nmPackFlatMsgDebug(), nmPackITVMsgDebug(), nmTraceField(), nmUnpackFlatMsgDebug(), and nmUnpackITVMsgDebug().

{
  size_t  i;

  if( sPreface && *sPreface )
  {
    fprintf(fp, "%s:", sPreface);
  }

  for(i=0; i<uCount; ++i)
  {
    if( (uNLFreq > 0) && ((i % uNLFreq) == 0) )
    {
      if( i != 0 )
      {
        fprintf(fp, "\n%*s", uCol, "");
      }
    }
    fprintf(fp, " 0x%02x", buf[i]);
  }
}

const char* nmStrError

(

int

ecode

)

Get the error string describing the BotSense error code.

The absolute value of the error code is taken prior retrieving the string. An unknown or out-of-range error code will be mapped to NM_ECODE_BADEC.

Parameters

ecode

BotSense error code.

Returns

Returns the appropriate error code string.

Definition at line 114 of file nmLibUtils.c.

References NM_ECODE_BADEC, and nmEcodeStrTbl.

{
  if( ecode < 0 )
  {
    ecode = -ecode;
  }

  if( ecode >= arraysize(nmEcodeStrTbl) )
  {
    ecode = NM_ECODE_BADEC;
  }
  return nmEcodeStrTbl[ecode];
}

INLINE_IN_H int nmUnpackBool	(	byte_t	buf[],
		size_t	bufSize,
		bool_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack a boolean value from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 823 of file netmsgs.h.

References nmUnpackU8().

Referenced by nmUnpackFlatBool(), and nmUnpackITVBool().

{
  *pVal = 0;  // clear all sizeof(int) bits
  return nmUnpackU8(buf, bufSize, (byte_t *)pVal, eEndian);
}

int nmUnpackBuf	(	byte_t	buf[],
		size_t	bufSize,
		byte_t	bufDst[],
		size_t	uCount,
		NMEndian_T	eEndian
	)

Unpack a byte buffer from the message buffer.

The source and message buffer memory areas can overlap.

Note

The buffer is always packed in sequential order ignoring the byte order parameter.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	bufDst	Destination output buffer.
	uCount	Number of bytes to copy.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1735 of file nmLibPack.c.

References _NM_CHK_MEM.

Referenced by nmPackPointer().

{
  _NM_CHK_MEM(bufSize, uCount);

  // safe copy 
  memmove(bufDst, buf, uCount);

  return (int)uCount;
}

INLINE_IN_H int nmUnpackByte	(	byte_t	buf[],
		size_t	bufSize,
		byte_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack one byte from the message buffer.

Alias for nmUnpackU8().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 785 of file netmsgs.h.

References nmUnpackU8().

{
  return nmUnpackU8(buf, bufSize, (byte_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackChar	(	byte_t	buf[],
		size_t	bufSize,
		char *	pVal,
		NMEndian_T	eEndian
	)

Unpack an 8-bit ASCII character from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 811 of file netmsgs.h.

References nmUnpackU8().

{
  return nmUnpackU8(buf, bufSize, (byte_t *)pVal, eEndian);
}

int nmUnpackF32	(	byte_t	buf[],
		size_t	bufSize,
		float *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 32-bit float from the message buffer.

The IEEE 754 32-bit format is used with both the big and little endian byte orders.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1472 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatF32(), and nmUnpackITVF32().

{
  static size_t fvalLen = NMFVAL_LEN_F32;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);
  _NM_CHK_ARCH(*pVal, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      UNPACKLITTLE(buf, pVal);
      break;
    case NMEndianNative:
      UNPACKNATIVE(buf, pVal);
      break;
    case NMEndianBig:
    default:
      UNPACKBIG(buf, pVal);
      break;
  }


  return (int)fvalLen;
}

int nmUnpackF64	(	byte_t	buf[],
		size_t	bufSize,
		double *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 64-bit float from the message buffer.

The IEEE 754 64-bit format is used with both the big and little endian byte orders. If the machine architecture only supports 32-bit doubles, then mantissa truncation will occur.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1517 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, IEEE754_F32_EXP_MAX, IEEE754_F32_EXP_MIN, IEEE754_F32_F64_MANTISSA0_SHIFT, IEEE754_F32_F64_MANTISSA1_MASK, IEEE754_F32_F64_MANTISSA1_SHIFT, IEEE754_F32_Inf, IEEE754_F32_MANTISSA_MASK, IEEE754_F32_NaN, IEEE754_F32_Zero, IEEE754_F64_EXPONENT_MASK, IEEE754_F64_EXPONENT_SHIFT, ieee754_f64_is_inf(), ieee754_f64_is_nan(), ieee754_f64_is_zero(), IEEE754_F64_MANTISSA0_MASK, IEEE754_F64_MANTISSA0_SHIFT, IEEE754_F64_MANTISSA1_MASK, IEEE754_F64_MANTISSA1_SHIFT, IEEE754_F64_SIGN_MASK, IEEE754_F64_SIGN_SHIFT, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, NMFVAL_LEN_F64, NMLIB_WARNING, UNPACK64BIG, UNPACK64LITTLE, UNPACK64NATIVE, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatF64(), and nmUnpackITVF64().

{
  static size_t fvalLen = NMFVAL_LEN_F64;     // message field value length

  uint_t                uMSB;       // Most Signifcant Bytes
  uint_t                uLSB;       // Least Signifcant Bytes
  int                   exponent;   // ieee754 unbiased exponent
  union ieee754_float   f;          // 4-byte floating-point number
  union ieee754_double  d;          // 8-byte floating-point number

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte doubles
  if( sizeof(double) == (size_t)NMFVAL_LEN_F64 )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACKLITTLE(buf, &d.d);
        break;
      case NMEndianNative:
        UNPACKNATIVE(buf, &d.d);
        break;
      case NMEndianBig:
      default:
        UNPACKBIG(buf, &d.d);
        break;
    }

    *pVal = d.d;
  }

  else // 4-byte doubles
  {
    _NM_CHK_ARCH(*pVal, (size_t)NMFVAL_LEN_F32);

    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACK64LITTLE(buf, &uMSB, &uLSB);
        break;
      case NMEndianNative:
        UNPACK64NATIVE(buf, &uMSB, &uLSB);
        break;
      case NMEndianBig:
      default:
        UNPACK64BIG(buf, &uMSB, &uLSB);
        break;
    }

    d.ieee.negative   = ((uMSB >> IEEE754_F64_SIGN_SHIFT)
                            & IEEE754_F64_SIGN_MASK)? 1: 0;
    d.ieee.exponent   = (uMSB >> IEEE754_F64_EXPONENT_SHIFT)
                            & IEEE754_F64_EXPONENT_MASK;
    d.ieee.mantissa0  = (uMSB >> IEEE754_F64_MANTISSA0_SHIFT)
                            & IEEE754_F64_MANTISSA0_MASK;
    d.ieee.mantissa1  = (uLSB >> IEEE754_F64_MANTISSA1_SHIFT)
                            & IEEE754_F64_MANTISSA1_MASK;

    // unbias the exponent
    exponent  = (int)d.ieee.exponent - IEEE754_DOUBLE_BIAS;

    // special Not-a-Number case
    if( ieee754_f64_is_nan(d) )
    {
      f = IEEE754_F32_NaN;
    }

    // special infinity cases
    else if( ieee754_f64_is_inf(d) )
    {
      f = IEEE754_F32_Inf;
    }

    // exponent overflow
    else if( exponent > IEEE754_F32_EXP_MAX )
    {
      f = IEEE754_F32_Inf;
      NMLIB_WARNING("floating-point number overflow.");
    }

    // exponent overflow
    else if( exponent < IEEE754_F32_EXP_MIN )
    {
      f = IEEE754_F32_Zero;
      NMLIB_WARNING("floating-point number underflow.");
    }

    // special zero cases
    else if( ieee754_f64_is_zero(d) )
    {
      f = IEEE754_F32_Zero;
    }

    // "normal" floating-point numbers
    else
    {
      f.ieee.exponent   = (byte_t)(exponent + IEEE754_FLOAT_BIAS);
      f.ieee.mantissa = ( (uint_t)((d.ieee.mantissa0
                                    & IEEE754_F64_MANTISSA0_MASK)
                                << IEEE754_F32_F64_MANTISSA0_SHIFT)
                        | (uint_t)((d.ieee.mantissa1
                                    >> IEEE754_F32_F64_MANTISSA1_SHIFT)
                                & IEEE754_F32_F64_MANTISSA1_MASK) )
                        & IEEE754_F32_MANTISSA_MASK;
      if( (d.ieee.mantissa1 & (uint_t)~IEEE754_F32_F64_MANTISSA1_MASK) != 0 )
      {
        NMLIB_WARNING("floating-point number mantissa truncation.");
      }
    }

    // preserve the sign
    f.ieee.negative   = d.ieee.negative;

    *pVal = (double)f.f;
  }

  return (int)fvalLen;
}

int nmUnpackFlatMsg	(	const NMMsgDef_T *	pMsgDef,
		byte_t	buf[],
		size_t	uMsgLen,
		void *	pStruct,
		NMEndian_T	eEndian
	)

Unpack a Flat message.

Parameters

	pMsgDef	Pointer to message definition.
[in]	buf	Input message buffer.
	uMsgLen	Length of message (bytes) in input buffer.
[out]	pStruct	Pointer to the associated message structure to populate.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, returns < 0.

Definition at line 1490 of file nmLibPackFlat.c.

References NMCtl_T::m_bNoHdr, NMCTL_INIT_DECL, and nmUnpackFlatStream().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  int       n;      // byte count/error code

  ctl.m_bNoHdr  = true;

  // unpack stream
  n = nmUnpackFlatStream(pMsgDef, buf, uMsgLen, pStruct, eEndian, &ctl);

  // return code
  return n;
}

int nmUnpackFlatMsgDebug	(	const NMMsgDef_T *	pMsgDef,
		byte_t	buf[],
		size_t	uMsgLen,
		void *	pStruct,
		NMEndian_T	eEndian
	)

Unpack a Flat message, tracing unpacking to stderr.

Parameters

	pMsgDef	Pointer to message definition.
[in]	buf	Input message buffer.
	uMsgLen	Length of message (bytes) in input buffer.
[out]	pStruct	Pointer to the associated message structure to populate.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1520 of file nmLibPackFlat.c.

References NMCtl_T::m_bNoHdr, NMCtl_T::m_bTrace, _nm_msg_def_struct::m_eMsgId, _nm_msg_def_struct::m_sMsgName, _nm_msg_def_struct::m_uCount, NMCTL_INIT_DECL, nmPrintBuf(), and nmUnpackFlatStream().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  int       n;      // byte count/error code

  ctl.m_bNoHdr  = true;
  ctl.m_bTrace  = true;

  // trace
  fprintf(stderr, "\n--- Unpacking Flat Message %s(%u): field_count=%zu\n",
                  pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, pMsgDef->m_uCount);
  fprintf(stderr, "Input Buffer (%zu bytes):\n", uMsgLen);
  nmPrintBuf(stderr, NULL, buf, uMsgLen, 16, 0);
  fprintf(stderr, "\n");

  // unpack stream
  n = nmUnpackFlatStream(pMsgDef, buf, uMsgLen, pStruct, eEndian, &ctl);

  // return code
  return n;
}

INLINE_IN_H int nmUnpackInt	(	byte_t	buf[],
		size_t	bufSize,
		int *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed int integer from the message buffer.

Alias for nmUnpackS32().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 880 of file netmsgs.h.

References nmUnpackU32().

{
  return nmUnpackU32(buf, bufSize, (uint_t *)pVal, eEndian);
}

int nmUnpackITVMsg	(	const NMMsgDef_T *	pMsgDef,
		byte_t	buf[],
		size_t	uMsgLen,
		void *	pStruct,
		NMEndian_T	eEndian
	)

Unpack a ITV message.

Parameters

	pMsgDef	Pointer to message definition.
[in]	buf	Input message buffer.
	uMsgLen	Length of message (bytes) in input buffer.
[out]	pStruct	Pointer to the associated message structure to populate.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, returns < 0.

Definition at line 2364 of file nmLibPackITV.c.

References _nm_msg_def_struct::m_eMsgId, _nm_msg_def_struct::m_sMsgName, NM_ECODE_MSGID, NM_ECODE_NOMEM, NMCTL_INIT_DECL, NMITV_MSGHDR_SIZE, NMLIB_RAISE_ERROR, nmUnpackITVStream(), and nmUnpackU16().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  ushort_t  eMsgId; // message id in buffer
  size_t    uCount; // field count in buffer
  int       n;      // byte count/error code
  int       k;      // subbyte count/error code

  // too small
  if( uMsgLen < NMITV_MSGHDR_SIZE )
  {
    NMLIB_RAISE_ERROR(NM_ECODE_NOMEM, "%s(%u): msg_len=%u, hdr_size=%u",
            pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, uMsgLen, NMITV_MSGHDR_SIZE);
  }

  // unpack message id
  if( (n = nmUnpackU16(buf, uMsgLen, &eMsgId, eEndian)) < 0 )
  {
    return n;
  }

  // field count
  uCount = (size_t)buf[n++];

  // mismatch error
  if( (uint_t)(pMsgDef->m_eMsgId) != (uint_t)eMsgId )
  {
    NMLIB_RAISE_ERROR(NM_ECODE_MSGID, "%s(%u): rcv'd msgid=%u != msgdef's",
            pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, eMsgId);
  }

  // unpack stream
  k = nmUnpackITVStream(pMsgDef, &buf[n], uMsgLen-(size_t)n, uCount,
                            pStruct, eEndian, &ctl);

  // return code
  return k>=0? n+k: k;
}

int nmUnpackITVMsgDebug	(	const NMMsgDef_T *	pMsgDef,
		byte_t	buf[],
		size_t	uMsgLen,
		void *	pStruct,
		NMEndian_T	eEndian
	)

Unpack a ITV message, tracing unpacking to stderr.

Parameters

	pMsgDef	Pointer to message definition.
[in]	buf	Input message buffer.
	uMsgLen	Length of message (bytes) in input buffer.
[out]	pStruct	Pointer to the associated message structure to populate.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 2419 of file nmLibPackITV.c.

References NMCtl_T::m_bTrace, _nm_msg_def_struct::m_eMsgId, _nm_msg_def_struct::m_sMsgName, NM_ECODE_MSGID, NM_ECODE_NOMEM, NMCTL_INIT_DECL, NMITV_MSGHDR_SIZE, NMLIB_RAISE_ERROR, nmPrintBuf(), nmUnpackITVStream(), and nmUnpackU16().

Referenced by nmUnpackPointer().

{
  NMCtl_T   ctl = NMCTL_INIT_DECL;
  ushort_t  eMsgId; // message id in buffer
  size_t    uCount; // field count in buffer
  int       n;      // byte count/error code
  int       k;      // subbyte count/error code

  ctl.m_bTrace  = true;

  // too small
  if( uMsgLen < NMITV_MSGHDR_SIZE )
  {
    NMLIB_RAISE_ERROR(NM_ECODE_NOMEM, "%s(%u): msg_len=%u, hdr_size=%u",
            pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, uMsgLen, NMITV_MSGHDR_SIZE);
  }

  // unpack message id
  if( (n = nmUnpackU16(buf, uMsgLen, &eMsgId, eEndian)) < 0 )
  {
    return n;
  }

  // field count
  uCount = (size_t)buf[n++];

  // mismatch error
  if( (uint_t)(pMsgDef->m_eMsgId) != (uint_t)eMsgId )
  {
    NMLIB_RAISE_ERROR(NM_ECODE_MSGID, "%s(%u): rcv'd msgid=%u != msgdef's",
            pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, eMsgId);
  }

  // trace
  fprintf(stderr, "\n--- Unpacking ITV Message %s(%u): field_count=%zu\n",
                  pMsgDef->m_sMsgName, pMsgDef->m_eMsgId, uCount);
  fprintf(stderr, "Input Buffer (%zu bytes):\n", uMsgLen);
  nmPrintBuf(stderr, NULL, buf, uMsgLen, 16, 0);
  fprintf(stderr, "\n");

  // unpack stream
  k = nmUnpackITVStream(pMsgDef, &buf[n], uMsgLen-(size_t)n, uCount,
                            pStruct, eEndian, &ctl);

  // return code
  return k>=0? n+k: k;
}

INLINE_IN_H int nmUnpackLong	(	byte_t	buf[],
		size_t	bufSize,
		long *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed long integer from the message buffer.

Alias for nmUnpackS32() or nmUnpackS64() depending on sizeof(long).

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 910 of file netmsgs.h.

References nmUnpackS32(), and nmUnpackS64().

{
  return sizeof(ulong_t) == 4?
              nmUnpackS32(buf, bufSize, (int *)pVal, eEndian):
              nmUnpackS64(buf, bufSize, (long long *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackLongLong	(	byte_t	buf[],
		size_t	bufSize,
		long long *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed long long integer from the message buffer.

Alias for nmUnpackS64().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 940 of file netmsgs.h.

References nmUnpackS64().

{
  return nmUnpackS64(buf, bufSize, (long long *)pVal, eEndian);
}

int nmUnpackP32	(	byte_t	buf[],
		size_t	bufSize,
		void *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 32-bit pointer from the message buffer.

If the machine architecture has 64-bit pointers, then only the LSB 4 bytes are packed.

Note

Pointer is always unpacked in native byte order.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1648 of file nmLibPack.c.

References _NM_CHK_MEM, NMFVAL_LEN_P32, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatP32(), nmUnpackITVP32(), and nmUnpackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P32;     // message field value length

  ulong_t  *pluVal;   // longs are same size as pointers on 32/64 bit machines
  uint_t    uP32;

  _NM_CHK_MEM(bufSize, fvalLen);
  
  pluVal = (ulong_t *)pVal;

  UNPACKNATIVE(buf, &uP32);

  *pluVal = (ulong_t)uP32;

  return (int)fvalLen;

}

int nmUnpackP64	(	byte_t	buf[],
		size_t	bufSize,
		void *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 64-bit pointer from the message buffer.

If the machine architecture only supports 32-bit pointers, then the 4 MSBs are padded with 0's.

Note

Pointer is always unpacked in native byte order.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1678 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMFVAL_LEN_P32, NMFVAL_LEN_P64, NMLIB_WARNING, and UNPACK64NATIVE.

Referenced by nmPackPointer(), nmUnpackFlatP64(), nmUnpackITVP64(), and nmUnpackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P64;     // message field value length

  uint_t    uMSB;     // Most Signifcant Bytes
  uint_t    uLSB;     // Least Signifcant Bytes
  ulong_t  *pluVal;   // longs are same size as pointers on 32/64 bit machines

  _NM_CHK_MEM(bufSize, fvalLen);
  
  pluVal = (ulong_t *)pVal;

  UNPACK64NATIVE(buf, &uMSB, &uLSB);

  // 8-byte pointer
  if( sizeof(void *) == fvalLen )
  {
#if HOST_WORD_SIZE == 64
    *pluVal = (ulong_t)(((ulong_t)uMSB  << 32) | (uLSB & 0xffffffff));
#else
    *pluVal = (ulong_t)uLSB;
#endif // HOST_WORD_SIZE
  }

  // 4-byte pointer
  else
  {
    _NM_CHK_ARCH(pVal, (size_t)NMFVAL_LEN_P32);

    if( uMSB != 0 )
    {
      NMLIB_WARNING("0x%08x%08x: Unpacking 64-bit pointer into 32 bits "
                    "lost non-zero significance.\n",
                    uMSB, uLSB);
    }
    *pluVal = (ulong_t)uLSB;
  }

  return (int)fvalLen;
}

INLINE_IN_H int nmUnpackPointer	(	byte_t	buf[],
		size_t	bufSize,
		void *	pVal,
		NMEndian_T	eEndian
	)

Unpack a (overloaded)void* pointer from the message buffer.

Alias for nmUnpackP32() or nmUnpackP64() depending on sizeof(void*).

Note

Pointer is always unpacked in native byte order.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 956 of file netmsgs.h.

References NMEndianNative, nmGetITVMsgId(), nmPackFlatMsg(), nmPackFlatMsgDebug(), nmPackITVMsg(), nmPackITVMsgDebug(), nmUnpackFlatMsg(), nmUnpackFlatMsgDebug(), nmUnpackITVMsg(), nmUnpackITVMsgDebug(), nmUnpackP32(), and nmUnpackP64().

{
  return sizeof(void*) == 4?
              nmUnpackP32(buf, bufSize, pVal, NMEndianNative):
              nmUnpackP64(buf, bufSize, pVal, NMEndianNative);
}

INLINE_IN_H int nmUnpackS16	(	byte_t	buf[],
		size_t	bufSize,
		short *	pVal,
		NMEndian_T	eEndian
	)

Unpack a signed 16-bit integer from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 759 of file netmsgs.h.

References nmUnpackU16().

Referenced by nmUnpackFlatS16(), and nmUnpackITVS16().

{
  return nmUnpackU16(buf, bufSize, (ushort_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackS32	(	byte_t	buf[],
		size_t	bufSize,
		int *	pVal,
		NMEndian_T	eEndian
	)

Unpack a signed 32-bit integer from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 771 of file netmsgs.h.

References nmUnpackU32().

Referenced by nmUnpackFlatS32(), nmUnpackITVS32(), and nmUnpackLong().

{
  return nmUnpackU32(buf, bufSize, (uint_t *)pVal, eEndian);
}

int nmUnpackS64	(	byte_t	buf[],
		size_t	bufSize,
		long long *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed 64-bit integer from the message buffer.

If the machine architecture only supports 32-bit long longs, then the 4 MSBs are truncated.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1391 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_S32, NMFVAL_LEN_S64, NMLIB_WARNING, UNPACK64BIG, UNPACK64LITTLE, UNPACK64NATIVE, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatS64(), nmUnpackITVS64(), nmUnpackLong(), and nmUnpackLongLong().

{
  static size_t fvalLen = NMFVAL_LEN_S64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte unsigned long long
  if( sizeof(ulonglong_t) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACKLITTLE(buf, pVal);
        break;
      case NMEndianNative:
        UNPACKNATIVE(buf, pVal);
        break;
      case NMEndianBig:
      default:
        UNPACKBIG(buf, pVal);
        break;
    }
  }

  // 4-byte unsigned long long
  else
  {
    _NM_CHK_ARCH(*pVal, (size_t)NMFVAL_LEN_S32);

    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACK64LITTLE(buf, &uMSB, &uLSB);
        break;
      case NMEndianNative:
        UNPACK64NATIVE(buf, &uMSB, &uLSB);
        break;
      case NMEndianBig:
      default:
        UNPACK64BIG(buf, &uMSB, &uLSB);
        break;
    }

    if( (uMSB != 0) && (uMSB != 0xffffffff) )
    {
      NMLIB_WARNING("0x%08x%08x: Unpacking signed 64-bit integer into "
                    "32 bits lost non-zero significance.",
                    uMSB, uLSB);
    }

    *pVal = (long long)uLSB;
  }

  return (int)fvalLen;
}

INLINE_IN_H int nmUnpackS8	(	byte_t	buf[],
		size_t	bufSize,
		signed char *	pVal,
		NMEndian_T	eEndian
	)

Unpack a signed 8-bit byte from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 747 of file netmsgs.h.

References nmUnpackU8().

Referenced by nmUnpackFlatS8(), and nmUnpackITVS8().

{
  return nmUnpackU8(buf, bufSize, (byte_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackSChar	(	byte_t	buf[],
		size_t	bufSize,
		signed char *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed short integer from the message buffer.

Alias for nmUnpackS8().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 799 of file netmsgs.h.

References nmUnpackU8().

{
  return nmUnpackU8(buf, bufSize, (byte_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackShort	(	byte_t	buf[],
		size_t	bufSize,
		short *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed short integer from the message buffer.

Alias for nmUnpackS16().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 852 of file netmsgs.h.

References nmUnpackU16().

{
  return nmUnpackU16(buf, bufSize, (ushort_t *)pVal, eEndian);
}

int nmUnpackU16	(	byte_t	buf[],
		size_t	bufSize,
		ushort_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 16-bit integer from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1256 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U16, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmGetITVMsgId(), nmPackPointer(), nmUnpackFlatU16(), nmUnpackITVMsg(), nmUnpackITVMsgDebug(), nmUnpackITVU16(), nmUnpackS16(), nmUnpackShort(), and nmUnpackUShort().

{
  static size_t fvalLen = NMFVAL_LEN_U16;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      UNPACKLITTLE(buf, pVal);
      break;
    case NMEndianNative:
      UNPACKNATIVE(buf, pVal);
      break;
    case NMEndianBig:
    default:
      UNPACKBIG(buf, pVal);
      break;
  }

  return (int)fvalLen;
}

int nmUnpackU32	(	byte_t	buf[],
		size_t	bufSize,
		uint_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 32-bit integer from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1288 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatU32(), nmUnpackInt(), nmUnpackITVU32(), nmUnpackS32(), nmUnpackUInt(), and nmUnpackULong().

{
  static size_t fvalLen = NMFVAL_LEN_U32;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      UNPACKLITTLE(buf, pVal);
      break;
    case NMEndianNative:
      UNPACKNATIVE(buf, pVal);
      break;
    case NMEndianBig:
    default:
      UNPACKBIG(buf, pVal);
      break;
  }

  return (int)fvalLen;
}

int nmUnpackU64	(	byte_t	buf[],
		size_t	bufSize,
		ulonglong_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 64-bit integer from the message buffer.

If the machine architecture only supports 32-bit unsigned long longs, then the 4 MSBs are truncated.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1320 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, NMFVAL_LEN_U64, NMLIB_WARNING, UNPACK64BIG, UNPACK64LITTLE, UNPACK64NATIVE, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatU64(), nmUnpackITVU64(), nmUnpackULong(), and nmUnpackULongLong().

{
  static size_t fvalLen = NMFVAL_LEN_U64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte unsigned long long
  if( sizeof(ulonglong_t) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACKLITTLE(buf, pVal);
        break;
      case NMEndianNative:
        UNPACKNATIVE(buf, pVal);
        break;
      case NMEndianBig:
      default:
        UNPACKBIG(buf, pVal);
        break;
    }
  }

  // 4-byte unsigned long long
  else
  {
    _NM_CHK_ARCH(*pVal, (size_t)NMFVAL_LEN_U32);

    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACK64LITTLE(buf, &uMSB, &uLSB);
        break;
      case NMEndianNative:
        UNPACK64NATIVE(buf, &uMSB, &uLSB);
        break;
      case NMEndianBig:
      default:
        UNPACK64BIG(buf, &uMSB, &uLSB);
        break;
    }

    if( uMSB != 0 )
    {
      NMLIB_WARNING("0x%08x%08x: Unpacking unsigned 64-bit integer into "
                    "32 bits lost non-zero significance.",
                    uMSB, uLSB);
    }

    *pVal = (ulonglong_t)uLSB;
  }

  return (int)fvalLen;
}

int nmUnpackU8	(	byte_t	buf[],
		size_t	bufSize,
		byte_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 8-bit byte from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1239 of file nmLibPack.c.

References _NM_CHK_MEM, and NMFVAL_LEN_U8.

Referenced by nmPackPointer(), nmUnpackBool(), nmUnpackByte(), nmUnpackChar(), nmUnpackFlatU8(), nmUnpackITVU8(), nmUnpackS8(), and nmUnpackSChar().

{
  static size_t fvalLen = NMFVAL_LEN_U8;      // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  *pVal = buf[0];

  return (int)fvalLen;
}

INLINE_IN_H int nmUnpackUInt	(	byte_t	buf[],
		size_t	bufSize,
		uint_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned int integer from the message buffer.

Alias for nmUnpackU32().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 866 of file netmsgs.h.

References nmUnpackU32().

{
  return nmUnpackU32(buf, bufSize, (uint_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackULong	(	byte_t	buf[],
		size_t	bufSize,
		ulong_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned long integer from the message buffer.

Alias for nmUnpackU32() or nmUnpackU64() depending on sizeof(ulong_t).

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 894 of file netmsgs.h.

References nmUnpackU32(), and nmUnpackU64().

{
  return sizeof(ulong_t) == 4?
              nmUnpackU32(buf, bufSize, (uint_t *)pVal, eEndian):
              nmUnpackU64(buf, bufSize, (ulonglong_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackULongLong	(	byte_t	buf[],
		size_t	bufSize,
		ulonglong_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned long long integer from the message buffer.

Alias for nmUnpackU64().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 926 of file netmsgs.h.

References nmUnpackU64().

{
  return nmUnpackU64(buf, bufSize, (ulonglong_t *)pVal, eEndian);
}

INLINE_IN_H int nmUnpackUShort	(	byte_t	buf[],
		size_t	bufSize,
		ushort_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned short integer from the message buffer.

Alias for nmUnpackU16().

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 838 of file netmsgs.h.

References nmUnpackU16().

{
  return nmUnpackU16(buf, bufSize, (ushort_t *)pVal, eEndian);
}