serialization.c

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

				  "%.100e",
				  ( type == CMPI_real32 )?
				  (double) value->real32:
				  value->real64 );
			return __serialize_string ( fd, real_str );
		}

		TRACE_CRITICAL(("non-supported floating point data type."));
	}

	error_at_line ( -1, 0, __FILE__, __LINE__,
			"Unable to serialize requested data type: 0x%x",
			type );

	return -1;
}


static CMPIValue __deserialize_CMPIValue ( int fd,
					   CMPIType type,
					   CONST CMPIBroker * broker )
{
	int failed = 0;
	CMPIValue v;

	TRACE_VERBOSE(("entered function."));

	bzero ( &v, sizeof ( CMPIValue ) );

	TRACE_NORMAL(("deserializing type 0x%x CMPIValue.", type));

	if ( type & CMPI_ARRAY ) {

		TRACE_INFO(("deserializing array object type."));
		v.array = __deserialize_CMPIArray ( fd, broker );

	} else if ( type & CMPI_ENC ) {

		TRACE_INFO(("trying to deserialize encapsulated data type."));
		switch ( type ) {
		case CMPI_instance:
			v.inst = __deserialize_CMPIInstance ( fd, broker );
			break;

		case CMPI_ref:
			v.ref = __deserialize_CMPIObjectPath ( fd, broker );
			break;

		case CMPI_args:
			v.args = __deserialize_CMPIArgs ( fd, broker );
			break;

		case CMPI_filter:
			v.filter = __deserialize_CMPISelectExp (
                                          fd,
                                          broker,
                                          PEGASUS_INDICATION_GLOBAL_CONTEXT);
			break;

		case CMPI_string:
		case CMPI_numericString:
		case CMPI_booleanString:
		case CMPI_dateTimeString:
		case CMPI_classNameString:
			v.string = __deserialize_CMPIString ( fd, broker );
			break;

		case CMPI_dateTime:
			v.dateTime = __deserialize_CMPIDateTime ( fd, broker );
			break;

		default:
			TRACE_CRITICAL(("non-supported encapsulated data."));
			failed = 1;
		}

	} else if ( type & CMPI_SIMPLE ) {

		TRACE_INFO(("deserializing simple value."));

		switch ( type ) {
		case CMPI_boolean:
			v.boolean = __deserialize_UINT8 ( fd );
			break;

		case CMPI_char16:
			v.char16 = __deserialize_UINT16 ( fd );
			break;

		default:
			TRACE_CRITICAL(("non-supported simple data type."));
			failed = 1;
		}

	} else if ( type & CMPI_INTEGER ) {

		TRACE_INFO(("deserializing integer value."));

		switch ( type ) {
		case CMPI_uint8:
		case CMPI_sint8:
			v.uint8 = __deserialize_UINT8 ( fd );
			break;

		case CMPI_uint16:
		case CMPI_sint16:
			v.uint16 = __deserialize_UINT16 ( fd );
			break;

		case CMPI_uint32:
		case CMPI_sint32:
			v.uint32 = __deserialize_UINT32 ( fd );
			break;

		case CMPI_uint64:
		case CMPI_sint64:
			v.uint64 = __deserialize_UINT64 ( fd );
			break;

		default:
			TRACE_CRITICAL(("non-supported integer data type."));
			failed = 1;
		}

	} else if ( type & CMPI_REAL ) {

		char * real_str;
		double r;

		switch ( type ) {
		case CMPI_real32:
		case CMPI_real64:
			real_str = __deserialize_string ( fd, broker );
			sscanf ( real_str, "%le", (double *) &r );

			if ( type == CMPI_real32 ) {
				v.real32 = r;
			} else  v.real64 = r;
			break;

		default:
			TRACE_CRITICAL(("non-supported floating point "
					"data type."));
			failed = 1;
		}
	}

	if ( failed ) error_at_line ( -1, 0, __FILE__, __LINE__,
				      "Unable to deserialize requested "
				      "data type: 0x%x", type );

	TRACE_VERBOSE(("leaving function."));
	return v;
}


static ssize_t __serialize_CMPIData ( int fd, CMPIData data )
{
	ssize_t tmp, out;

	TRACE_VERBOSE(("entered function."));
	TRACE_NORMAL(("serializing CMPIData."));

	TRACE_INFO(("state: 0x%x\ntype: 0x%x", data.state, data.type ));

	out = __serialize_UINT16 ( fd, data.state );
	if ( out < 0 ) return -1;

	if ( ( tmp = __serialize_CMPIType ( fd, data.type ) ) < 0 ) {
		return -1;
	}

	out += tmp;

	if ( ! ( data.state & CMPI_nullValue ) ) {

		out += __serialize_CMPIValue ( fd, data.type, &data.value );
	}

	TRACE_VERBOSE(("leaving function."));
	return out;
}


static CMPIData __deserialize_CMPIData ( int fd, CONST CMPIBroker * broker )
{
	CMPIData data={0,0,{0}};

	TRACE_VERBOSE(("entered function."));
	TRACE_NORMAL(("deserializing CMPIData."));

	data.state = __deserialize_UINT16 ( fd );
	data.type  = __deserialize_CMPIType ( fd );

	TRACE_INFO(("state: 0x%x\ntype: 0x%x", data.state, data.type ));

	if ( ! ( data.state & CMPI_nullValue ) ) {

		data.value = __deserialize_CMPIValue ( fd,
						       data.type,
						       broker );
//                if (data.type & CMPI_ENC)
//                        data.state |= CMPI_nullValue;
	}

	TRACE_VERBOSE(("leaving function."));
	return data;
}


static ssize_t __serialize_CMPIStatus ( int fd, CMPIStatus * rc )
{
	ssize_t out, tmp;

	TRACE_VERBOSE(("entered function."));
	TRACE_NORMAL(("serializing CMPIStatus."));

	tmp = __serialize_UINT32 ( fd, rc->rc );
	if ( tmp < 0 ) return -1;

	TRACE_INFO(("rc: %d\nmsg: %s",
		    rc->rc,
		    rc->msg ? (CMGetCharsPtr ( rc->msg, NULL )) : "" ));

	out = __serialize_CMPIString ( fd, rc->msg );
	if ( out ) return -1;

	TRACE_VERBOSE(("leaving function."));
	return out + tmp;
}


static CMPIStatus __deserialize_CMPIStatus ( int fd, CONST CMPIBroker * broker )
{
	CMPIStatus rc = { CMPI_RC_ERR_FAILED, NULL };

	TRACE_VERBOSE(("entered function."));
	TRACE_NORMAL(("deserializing CMPIStatus."));

	rc.rc  = (CMPIrc) __deserialize_UINT32 ( fd );
	rc.msg = __deserialize_CMPIString ( fd, broker );

	TRACE_INFO(("rc: %d\nmsg: %s",
		    rc.rc,
		    rc.msg ? (CMGetCharsPtr ( rc.msg, NULL )) : "" ));

	TRACE_VERBOSE(("leaving function."));
	return rc;
}


static ssize_t __serialize_string ( int fd, const char * str )
{
	size_t len;
	ssize_t out;

	if ( __serialized_NULL ( fd, str ) ) return 0;

	len = strlen ( str );
	out = __serialize_UINT32 ( fd, len );
	if ( out < 0 ) return -1;

	if ( io_write_fixed_length ( fd, str, len ) ) return -1;

	return len + out;
}


static char * __deserialize_string_alloc ( int fd )
{
	size_t len;
	char * str;

	if ( __deserialized_NULL ( fd ) ) return NULL;

	len = __deserialize_UINT32 ( fd );

	str = (char *) calloc ( len + 1, sizeof ( char ) );

	if ( io_read_fixed_length ( fd, str, len ) ) {

		free ( str );
		return NULL;
	}
	return str;
}


static char * __deserialize_string ( int fd, CONST CMPIBroker * broker )
{
	char * tmp = __deserialize_string_alloc ( fd );

	if ( tmp ) {
		CMPIString * str = CMNewString ( broker, tmp, NULL );
		free ( tmp );
		return CMGetCharsPtr ( str, NULL );
	}
	return NULL;
}


static ssize_t __serialize_CMPIString ( int fd, CONST CMPIString * string )
{
	if ( __serialized_NULL ( fd, string ) ) return 0;
	return __serialize_string ( fd, CMGetCharsPtr ( string, NULL ) );
}


static CMPIString * __deserialize_CMPIString ( int fd, CONST CMPIBroker * broker )
{
	CMPIString * str;
	char * tmp;

	if ( __deserialized_NULL ( fd ) ) return NULL;

	tmp = __deserialize_string_alloc ( fd );
	str = CMNewString ( broker, tmp, NULL );

	free ( tmp );
	return str;
}


static ssize_t __serialize_CMPIArgs ( int fd, CONST CMPIArgs * args )
{
	ssize_t out;
	unsigned int i, arg_count;

	TRACE_VERBOSE(("entered function."));

	if ( __serialized_NULL ( fd, args ) ) return 0;

	TRACE_NORMAL(("serializing non-NULL CMPIArgs."));

	arg_count = CMGetArgCount ( args, NULL );
	out = __serialize_UINT32 ( fd, arg_count );
	if ( out < 0 ) return -1;

	TRACE_INFO(("arg count: %d", arg_count ));

	for ( i = 0; i < arg_count; i++ ) {
		CMPIString * argName;
		CMPIData data = CMGetArgAt ( args, i, &argName, NULL );

		TRACE_INFO(("arg(%d):\nname: %s\ntype: 0x%x\nstate: 0x%x.",
			    i, CMGetCharsPtr ( argName, NULL ),
			    data.type, data.state ));

		out += __serialize_CMPIString ( fd, argName );
		out += __serialize_CMPIData ( fd, data );
	}

	TRACE_VERBOSE(("leaving function."));
	return out;
}


static CMPIArgs * __deserialize_CMPIArgs ( int fd, CONST CMPIBroker * broker )
{
	CMPIArgs * args;
	unsigned int arg_count;

	TRACE_VERBOSE(("entered function."));

	if ( __deserialized_NULL ( fd ) ) return NULL;

	TRACE_NORMAL(("deserializing non-NULL CMPIArgs."));

	args = CMNewArgs ( broker, NULL );
	arg_count = __deserialize_UINT32 ( fd );

	TRACE_INFO(("arg count: %d", arg_count ));

	while ( arg_count-- ) {
		CMPIString * argName = __deserialize_CMPIString ( fd, broker );
		CMPIData data        = __deserialize_CMPIData ( fd, broker );

		TRACE_INFO(("arg:\nname: %s\ntype: 0x%x\nstate: 0x%x.",
			    CMGetCharsPtr ( argName, NULL ),
			    data.type, data.state ));

		CMAddArg ( args,
			   CMGetCharsPtr ( argName, NULL ),
			   &data.value,
			   data.type );
	}

	TRACE_VERBOSE(("leaving function."));
	return args;
}


static ssize_t __serialize_CMPIObjectPath ( int fd, CONST CMPIObjectPath * cop )
{
	ssize_t out, tmp;
	unsigned int key_count, i;
	CMPIString * classname, * namespace;

	TRACE_VERBOSE(("entered function."));

	if ( __serialized_NULL ( fd, cop ) ) return 0;

	TRACE_NORMAL(("serializing non-NULL CMPIObjectPath."));

	classname = CMGetClassName ( cop, NULL );
	namespace = CMGetNameSpace ( cop, NULL );
	key_count = CMGetKeyCount ( cop, NULL );

	TRACE_INFO(("classname: %s.", CMGetCharsPtr ( classname, NULL )));
	TRACE_INFO(("namespace: %s.", CMGetCharsPtr ( namespace, NULL )));
	TRACE_INFO(("key count: %d", key_count ));

	out =__serialize_CMPIString ( fd, classname );
	if ( out < 0 ) {