/* static */
Message * Message::Demarshal(pGina::Memory::Buffer *buffer)
{
if(buffer == 0)
return 0;
return Demarshal(*buffer);
}
int
main( int argc, char *argv[] )
{
tUint8 value[4] = { 0x42, 0X43, 0X44, 0X45 };
tUint8 result[4] = { 0x11, 0x12, 0x13, 0x14 };
unsigned char buffer[256];
unsigned int s1 = Marshal( &UserDefinedType, value, buffer );
if ( s1 != 3 )
return 1;
unsigned int s2 = Demarshal( MarshalByteOrder(),
&UserDefinedType, result, buffer );
if ( s2 != 3 )
return 1;
if ( value[0] != result[0] )
return 1;
if ( value[1] != result[1] )
return 1;
if ( value[2] != result[2] )
return 1;
if ( result[3] != 0x14 )
return 1;
return 0;
}
int
HpiDemarshalReply( int byte_order, cHpiMarshal *m, const void *buffer, void **params )
{
// the first value is the error code
int rv = Demarshal( byte_order, &SaErrorType, params[0], buffer );
if ( rv < 0 )
return -1;
SaErrorT err = *(SaErrorT *)params[0];
if ( err == SA_OK )
return DemarshalArray( byte_order, m->m_reply, params, buffer );
return rv;
}
int
main( int argc, char *argv[] )
{
tUint8 value = 0x42;
tUint8 result;
unsigned int s = Demarshal( MarshalByteOrder() ? 0 : 1,
&Uint8Type, &result, &value );
if ( s != sizeof( tUint8 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tInt16 value = 0x42aa;
tInt16 swap = bswap_16( value );
tInt16 result;
unsigned int s = Demarshal( MarshalByteOrder() ? 0 : 1,
&Marshal_Int16Type, &result, &swap );
if ( s != sizeof( tInt16 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tUint16 value = 0x42aa;
tUint16 swap = GUINT16_SWAP_LE_BE( value );
tUint16 result;
unsigned int s = Demarshal( MarshalByteOrder() ? 0 : 1,
&Marshal_Uint16Type, &result, &swap );
if ( s != sizeof( tUint16 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tUint64 value = 0xfedc12345678abcdLL;
tUint64 swap = bswap_64( value );
tUint64 result;
unsigned int s = Demarshal( MarshalByteOrder() ? 0 : 1,
&Uint64Type, &result, &swap );
if ( s != sizeof( tUint64 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tInt32 value = 0x42aa1234;
tInt32 swap = bswap_32( value );
tInt32 result;
unsigned int s = Demarshal( MarshalByteOrder() ? 0 : 1,
&Int32Type, &result, &swap );
if ( s != sizeof( tInt32 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
DemarshalArray( int byte_order, const cMarshalType **types,
void **data, const void *b )
{
int i;
int size = 0;
const unsigned char *buffer = b;
for( i = 0; types[i]; i++ )
{
int s = Demarshal( byte_order, types[i], data[i], buffer );
if ( s < 0 )
return -1;
size += s;
buffer += s;
}
return size;
}
int
main( int argc, char *argv[] )
{
tInt8 value = 0xfa;
tInt8 result;
unsigned char buffer[256];
unsigned int s1 = Marshal( &Marshal_Int8Type, &value, buffer );
if ( s1 != sizeof( tInt8 ) )
return 1;
unsigned int s2 = Demarshal( G_BYTE_ORDER, &Marshal_Int8Type, &result, buffer );
if ( s2 != sizeof( tInt8 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tInt32 value = 0x42aa1234;
tInt32 result;
unsigned char buffer[256];
unsigned int s1 = Marshal( &Marshal_Int32Type, &value, buffer );
if ( s1 != sizeof( tInt32 ) )
return 1;
unsigned int s2 = Demarshal( MarshalByteOrder(), &Marshal_Int32Type, &result, buffer );
if ( s2 != sizeof( tInt32 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tUint64 value = 0xfedc12345678abcdLL;
tUint64 result;
unsigned char buffer[256];
unsigned int s1 = Marshal( &Marshal_Uint64Type, &value, buffer );
if ( s1 != sizeof( tUint64 ) )
return 1;
unsigned int s2 = Demarshal( MarshalByteOrder(), &Marshal_Uint64Type, &result, buffer );
if ( s2 != sizeof( tUint64 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tInt64 value = 0x1234567890abcdefLL;
tInt64 result;
unsigned char buffer[256];
unsigned int s1 = Marshal( &Marshal_Int64Type, &value, buffer );
if ( s1 != sizeof( tInt64 ) )
return 1;
unsigned int s2 = Demarshal( G_BYTE_ORDER, &Marshal_Int64Type, &result, buffer );
if ( s2 != sizeof( tInt64 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
int
main( int argc, char *argv[] )
{
tFloat64 value = -47.345566;
tFloat64 result;
unsigned char buffer[256];
unsigned int s1 = Marshal( &Marshal_Float64Type, &value, buffer );
if ( s1 != sizeof( tFloat64 ) )
return 1;
unsigned int s2 = Demarshal( MarshalByteOrder(), &Marshal_Float64Type, &result, buffer );
if ( s2 != sizeof( tFloat64 ) )
return 1;
if ( value != result )
return 1;
return 0;
}
static int
CheckValue( cTest *v, cTest *r )
{
unsigned char buffer[256];
unsigned int s1 = Marshal( &TestType, v, buffer );
unsigned int s2 = Demarshal( MarshalByteOrder(), &TestType, r, buffer );
if ( s1 != s2 )
return 1;
if ( v->m_pad1 != r->m_pad1 )
return 1;
if ( v->m_mod != r->m_mod )
return 1;
if ( v->m_pad2 != r->m_pad2 )
return 1;
if ( v->m_pad3 != r->m_pad3 )
return 1;
return 0;
}
int
Demarshal( int byte_order, const cMarshalType *type,
void *d, const void *b )
{
if ( IsSimpleType( type->m_type ) )
return DemarshalSimpleTypes( byte_order, type->m_type, d, b );
int size = 0;
unsigned char *data = d;
const unsigned char *buffer = b;
switch( type->m_type )
{
case eMtArray:
{
int i;
for( i = 0; i < type->m_u.m_array.m_size; i++ )
{
int s = Demarshal( byte_order, type->m_u.m_array.m_type,
data, buffer );
if ( s < 0 )
return -1;
data += s;
buffer += s;
size += s;
}
}
break;
case eMtStruct:
{
int i;
for( i = 0; type->m_u.m_struct.m_elements[i].m_type == eMtStructElement; i++ )
{
cMarshalType *struct_element = &type->m_u.m_struct.m_elements[i];
assert( struct_element->m_type == eMtStructElement );
cMarshalType *st_type = struct_element->m_u.m_struct_element.m_type;
int s = 0;
if ( st_type->m_type == eMtUnion )
{
// the mod must be before this entry.
// this is a limitation of demarshaling of unions
assert( st_type->m_u.m_union.m_offset < i );
const cMarshalType *mod = FindUnionModifierType( type, st_type, data );
if ( mod )
{
s = Demarshal( byte_order, mod, data + struct_element->m_u.m_struct_element.m_offset, buffer );
if ( s < 0 )
return -1;
}
else
return -1;
}
else if ( st_type->m_type == eMtVarArray )
{
// the array size must be before this entry.
// this is a limitation of demarshaling of var arrays
assert( st_type->m_u.m_var_array.m_size < i );
tUint32 array_size = FindArraySize( type, st_type, data );
// only simple types can be array elements
assert( IsSimpleType( st_type->m_u.m_var_array.m_type->m_type ) );
const unsigned char *bb = buffer;
unsigned char *dd = data + struct_element->m_u.m_struct_element.m_offset;
tUint32 j;
for( j = 0; j < array_size; j++ )
{
int si = Demarshal( byte_order, st_type->m_u.m_var_array.m_type,
dd, bb );
if ( si < 0 )
return -1;
bb += si;
dd += si;
s += si;
}
}
else
{
s = Demarshal( byte_order, st_type,
data + struct_element->m_u.m_struct_element.m_offset,
buffer );
if ( s < 0 )
return -1;
}
buffer += s;
size += s;
}
}
break;
case eMtUnion:
// unions must me encapsulate in structs
assert( 0 );
return -1;
case eMtStructElement:
case eMtUnionElement:
assert( 0 );
return -1;
case eMtUserDefined:
assert( type->m_u.m_user_defined.m_demarshal );
size = type->m_u.m_user_defined.m_demarshal( byte_order, type, d, b,
type->m_u.m_user_defined. m_user_data );
if ( size < 0 )
return -1;
break;
default:
assert( 0 );
return -1;
}
return size;
}
.m_v1.Oem = 0,
.m_pad2 = 48,
.m_v2.IdrId = 2,
.m_v2.Persistent = FALSE,
.m_v2.Oem = 3,
.m_v3.IdrId = 3,
.m_v3.Persistent = TRUE,
.m_v3.Oem = 2,
.m_pad3 = 49
};
unsigned char *buffer = (unsigned char *)malloc(sizeof(value));
cTest result;
unsigned int s1 = Marshal( &TestType, &value, buffer );
unsigned int s2 = Demarshal( G_BYTE_ORDER, &TestType, &result, buffer );
if ( s1 != s2 )
return 1;
if ( value.m_pad1 != result.m_pad1 )
return 1;
if ( !cmp_inventoryrec( &value.m_v1, &result.m_v1 ) )
return 1;
if ( value.m_pad2 != result.m_pad2 )
return 1;
if ( !cmp_inventoryrec( &value.m_v2, &result.m_v2 ) )
return 1;
.m_v3.ResourceCapabilities = 1,
.m_v3.HotSwapCapabilities = 1,
.m_v3.ResourceSeverity = 1,
.m_v3.ResourceFailed = FALSE,
.m_v3.ResourceTag.DataType = SAHPI_TL_TYPE_ASCII6,
.m_v3.ResourceTag.Language = SAHPI_LANG_TAJIK,
.m_v3.ResourceTag.DataLength = 0,
.m_v3.ResourceTag.Data = "",
.m_pad3 = 49
};
unsigned char *buffer = (char *)malloc(sizeof(value));
cTest result;
unsigned int s1 = Marshal( &TestType, &value, buffer );
unsigned int s2 = Demarshal( MarshalByteOrder(), &TestType, &result, buffer );
if ( s1 != s2 )
return 1;
if ( value.m_pad1 != result.m_pad1 )
return 1;
if ( !cmp_rptentry( &value.m_v1, &result.m_v1 ) )
return 1;
if ( !cmp_entities( &value.m_v1.ResourceEntity.Entry[0], &result.m_v1.ResourceEntity.Entry[0] ) )
return 1;
if ( !cmp_entities( &value.m_v1.ResourceEntity.Entry[1], &result.m_v1.ResourceEntity.Entry[1] ) )
return 1;
if ( value.m_pad2 != result.m_pad2 )
int
Demarshal( int byte_order, const cMarshalType *type, void *d, const void *b )
{
if ( IsSimpleType( type->m_type ) )
{
return DemarshalSimpleTypes( byte_order, type->m_type, d, b );
}
int size = 0;
unsigned char *data = d;
const unsigned char *buffer = b;
switch( type->m_type )
{
case eMtArray:
{
const size_t nelems = type->u.m_array.m_nelements;
size_t i;
for( i = 0; i < nelems; i++ )
{
const cMarshalType *elem = type->u.m_array.m_element;
const size_t elem_sizeof = type->u.m_array.m_element_sizeof;
int cc = Demarshal( byte_order, elem, data, buffer );
if ( cc < 0 )
{
CRIT( "Demarshal: %s[%d]: failure, cc = %d!", type->m_name, i, cc );
return cc;
}
data += elem_sizeof;
buffer += cc;
size += cc;
}
}
break;
case eMtStruct:
{
const cMarshalType *elems = &type->u.m_struct.m_elements[0];
size_t i;
for( i = 0; elems[i].m_type == eMtStructElement; i++ )
{
const cMarshalType *elem = elems[i].u.m_struct_element.m_element;
const size_t offset = elems[i].u.m_struct_element.m_offset;
int cc = 0;
if ( elem->m_type == eMtUnion )
{
const size_t mod2_idx = elem->u.m_union.m_mod_idx;
if ( mod2_idx >= i ) {
// NB: this is a limitation of demarshaling of unions
CRIT( "Demarshal: %s:%s: mod field must be before union!",
type->m_name, elems[i].m_name );
return -EINVAL;
}
const size_t mod2 = GetStructElementIntegerValue( type, mod2_idx, data );
const cMarshalType *elem2 = GetUnionElement( elem, mod2 );
if ( !elem2 ) {
CRIT( "Demarshal: %s:%s: invalid mod value %u!",
type->m_name, elems[i].m_name, (unsigned int)mod2 );
return -EINVAL;
}
cc = Demarshal( byte_order, elem2, data + offset, buffer );
if ( cc < 0 )
{
CRIT( "Demarshal: %s:%s, mod %u: failure, cc = %d!",
type->m_name, elems[i].m_name, (unsigned int)mod2, cc );
return cc;
}
}
else if ( elem->m_type == eMtVarArray )
{
const size_t nelems2_idx = elem->u.m_var_array.m_nelements_idx;
const cMarshalType *elem2 = elem->u.m_var_array.m_element;
const size_t elem2_sizeof = elem->u.m_var_array.m_element_sizeof;
if ( nelems2_idx >= i ) {
// NB: this is a limitation of demarshaling of var arrays
CRIT( "Demarshal: %s:%s: nelements field must be before vararray!",
type->m_name, elems[i].m_name );
return -EINVAL;
}
const size_t nelems2 = GetStructElementIntegerValue( type, nelems2_idx, data );
// allocate storage for var array content
unsigned char *data2 = g_new0(unsigned char, nelems2 * elem2_sizeof );
// (data + offset ) points to pointer to var array content
memcpy(data + offset, &data2, sizeof(void *));
const unsigned char *buffer2 = buffer;
size_t i2;
for( i2 = 0; i2 < nelems2; i2++ )
{
int cc2 = Demarshal( byte_order, elem2, data2, buffer2 );
if ( cc2 < 0 )
{
CRIT( "Demarshal: %s:%s[%d]: failure, cc = %d!",
type->m_name, elems[i].m_name, i2, cc2 );
return cc2;
}
data2 += elem2_sizeof;
buffer2 += cc2;
cc += cc2;
}
}
else
{
cc = Demarshal( byte_order, elem, data + offset, buffer );
if ( cc < 0 )
{
CRIT( "Demarshal: %s:%s: failure, cc = %d!",
type->m_name, elems[i].m_name, cc );
return cc;
}
}
buffer += cc;
size += cc;
}
}
break;
case eMtUserDefined:
{
tDemarshalFunction demarshaller = type->u.m_user_defined.m_demarshaller;
void * user_data = type->u.m_user_defined.m_user_data;
size = demarshaller ? demarshaller( byte_order, type, d, b, user_data ) : 0;
}
break;
default:
return -ENOSYS;
}
int
Demarshal( int byte_order, const cMarshalType *type,
void *d, const void *b )
{
if ( IsSimpleType( type->m_type ) )
return DemarshalSimpleTypes( byte_order, type->m_type, d, b );
int size = 0;
unsigned char *data = d;
const unsigned char *buffer = b;
switch( type->m_type )
{
case eMtArray:
{
int i;
for( i = 0; i < type->m_u.m_array.m_size; i++ )
{
int s = Demarshal( byte_order, type->m_u.m_array.m_type,
data, buffer );
if ( s < 0 ) {
assert( 0 );
return -1;
}
data += s;
buffer += s;
size += s;
}
}
break;
case eMtStruct:
{
int i;
for( i = 0; type->m_u.m_struct.m_elements[i].m_type == eMtStructElement; i++ )
{
cMarshalType *struct_element = &type->m_u.m_struct.m_elements[i];
assert( struct_element->m_type == eMtStructElement );
cMarshalType *st_type = struct_element->m_u.m_struct_element.m_type;
int s = 0;
if ( st_type->m_type == eMtUnion )
{
// the mod must be before this entry.
// this is a limitation of demarshaling of unions
assert( st_type->m_u.m_union.m_offset < i );
const cMarshalType *mod = FindUnionModifierType( type, st_type, data );
if ( mod )
{
s = Demarshal( byte_order, mod, data + struct_element->m_u.m_struct_element.m_offset, buffer );
if ( s < 0 ) {
assert( 0 );
return -1;
}
}
else {
assert( 0 );
return -1;
}
}
else if ( st_type->m_type == eMtVarArray )
{
// the array size must be before this entry.
// this is a limitation of demarshaling of var arrays
assert( st_type->m_u.m_var_array.m_size < i );
tUint32 array_size = FindArraySize( type, st_type, data );
// only simple types can be array elements
//assert( IsSimpleType( st_type->m_u.m_var_array.m_type->m_type ) );
const unsigned char *bb = buffer;
const cMarshalType *va_type = st_type->m_u.m_var_array.m_type;
// FIXME: This is a hack! I'm assuming the elements in
// the variable array are structs. That's because this
// is the only instance for which we use var arrays.
unsigned char *dd =
(unsigned char *)malloc(va_type->m_u.m_struct.m_size*array_size);
memset(dd, 0, va_type->m_u.m_struct.m_size*array_size);
unsigned char *vardata = data + struct_element->m_u.m_struct_element.m_offset;
tUint32 j;
memcpy(vardata, &dd, sizeof(void *));
for( j = 0; j < array_size; j++ )
{
int si = Demarshal( byte_order, st_type->m_u.m_var_array.m_type,
dd, bb );
if ( si < 0 ) {
assert( 0 );
return -1;
}
bb += si;
dd += si;
s += si;
}
}
else
{
s = Demarshal( byte_order, st_type,
data + struct_element->m_u.m_struct_element.m_offset,
buffer );
if ( s < 0 ) {
assert( 0 );
return -1;
}
}
buffer += s;
size += s;
}
}
break;
case eMtUnion:
// unions must me encapsulate in structs
assert( 0 );
return -1;
case eMtStructElement:
case eMtUnionElement:
assert( 0 );
return -1;
case eMtUserDefined:
assert( type->m_u.m_user_defined.m_demarshal );
size = type->m_u.m_user_defined.m_demarshal( byte_order, type, d, b,
type->m_u.m_user_defined. m_user_data );
if ( size < 0 ) {
assert( 0 );
return -1;
}
break;
default:
assert( 0 );
return -1;
}
return size;
}
