/****************************************************************************
**.COPYRIGHT	(C)Copyright 1993
**					CSE Computer Systems Expertise
**					DNPAP (Data Network Performance Analysis) group.
**					See file COPYING 'GNU General Public Licence' for details
**.AUTHORS		Ling Thio,  CSE   ,H.L.Thio@et.tudelft.nl
**					Dirk Wisse, DNPAP ,D.M.Wisse@et.tudelft.nl
**.DATE			Sep 1993
****************************************************************************/

#include <string.h>
#include <malloc.h>
#include "winsmi.h"

#define SmiAlloc(size)				malloc(size)
#define SmiFree(ptr)					free(ptr)

/****************************************************************************
.FUNC		Creates 'Object ID' structure
.DESCR	This function allocates memory to an Object ID structure which can
			hold <len> SMI_UINT32 integers.
			.len is set to <len>.
			.ptr is set to an allocated buffer of <len> integers.
			The memory can be free through a call to SmiDestroyOid().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to allocated Object ID structure.
****************************************************************************/
SMI_POID			SMI_API SmiCreateOid(
	IN SMI_UINT32 len)		/*.PARAM Number of integers to allocate */
{
	SMI_POID oid;
	if (len==SMI_DEFAULTLEN) len = SMI_STANDARDLEN;
	oid = SmiAlloc(sizeof(SMI_OID)+len*sizeof(SMI_UINT32));
	if (oid==NULL) return oid;
	oid->len = len;
	oid->ptr = (SMI_PUINT32)(oid+1);
	return oid;
}

/****************************************************************************
.FUNC		Duplicates an 'Object ID' structure.
.DESCR	This function allocates memory for an Object ID structure and copies
			<srcOid> into the newly created structure.
			The memory can be freed by SmiDestroyOid().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to allocated Object ID structure.
****************************************************************************/
SMI_POID			SMI_API SmiDuplicateOid(
	IN SMI_POID srcOid)		/*.PARAM Source Object ID structure */
{
	SMI_POID oid;
	oid = SmiCreateOid(srcOid->len);
	if (oid==NULL) return oid;
	memcpy(oid->ptr, srcOid->ptr, oid->len*sizeof(SMI_UINT32));
	return oid;
}

/****************************************************************************
.FUNC		Frees an 'Object ID' structure.
.DESCR	Frees memory of an SMI_OID structure, previously allocated by
			SmiCreateOid() or SmiDuplicateOid().
.RETURN	.INC smi_status
****************************************************************************/
SMI_STATUS		SMI_API SmiDestroyOid(
	IN SMI_POID oid)			/*.PARAM Object ID structure pointer */
{
	SmiFree(oid);
	return SMI_SUCCESS;
}

/****************************************************************************
.FUNC		Creates 'Octet String' structure
.DESCR	This function allocates an Octet String structure which can hold
			<len> bytes.
			.len is set to <len>.
			.ptr is set to an allocated buffer of <len> SMI_UINT32 bytes.
			The memory can be freed by SmiDestroyOctets().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to allocated Octet String structure.
****************************************************************************/
SMI_POCTETS		SMI_API SmiCreateOctets(
	IN SMI_UINT32 len)		/*.PARAM Number of bytes to allocate */
{
	SMI_POCTETS octets;
	octets = SmiAlloc(sizeof(SMI_OCTETS)+len*sizeof(SMI_BYTE));
	if (octets==NULL) return octets;
	octets->len = len;
	octets->ptr = (SMI_PBYTE)(octets+1);
	return octets;
}

/****************************************************************************
.FUNC		Duplicates an 'Octet String' structure.
.DESCR	This function allocates memory for a Octet String structure and
			copies <srcOctets> into the newly created structure.
			The memory can be free through a call to SmiDestroyOctets().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to allocated Octet String structure.
****************************************************************************/
SMI_POCTETS		SMI_API SmiDuplicateOctets(
	IN SMI_POCTETS srcOctets)	/*.PARAM Octet String structure pointer */
{
	SMI_POCTETS octets;
	octets = SmiCreateOctets(srcOctets->len);
	if (octets==NULL) return octets;
	memcpy(octets->ptr, srcOctets->ptr, octets->len*sizeof(SMI_BYTE));
	return octets;
}

/****************************************************************************
.FUNC		Frees an 'Octet String' structure.
.DESCR	Frees memory of an Octet String structure, previously allocated by
			SmiCreateOctets() or SmiDuplicateOctets().
.RETURN	.INC smi_status
****************************************************************************/
SMI_STATUS		SMI_API SmiDestroyOctets(
	IN SMI_POCTETS octets)	/*.PARAM Octet String structure pointer */
{
	SmiFree(octets);
	return SMI_SUCCESS;
}

/****************************************************************************
.FUNC		Creates a 32-bit integer Value structure.
.DESCR	This function allocates memory for a numeric Value structure
			of type <type> and sets its value to <number>.
			The memory can be free by SmiDestroyValue().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to integer Value structure.
****************************************************************************/
SMI_PVALUE		SMI_API SmiCreateNumberValue(
	IN short type,				/*.PARAM 32-bit integer type */
	IN SMI_UINT32 number)	/*.PARAM 32-bit integer value */
{
	SMI_PVALUE value;

	switch (type) {
	case SMI_TYPE_INT:
	case SMI_TYPE_NULL:
		value = SmiAlloc(sizeof(SMI_VALUE));
		if (value==NULL) return value;
		value->value.sNumber = number;
		value->type = type;
		break;
	case SMI_TYPE_UINT32:
	case SMI_TYPE_CNTR32:
	case SMI_TYPE_GAUGE32:
	case SMI_TYPE_TIMETICKS:
		value = SmiAlloc(sizeof(SMI_VALUE));
		if (value==NULL) return value;
		value->value.uNumber = number;
		value->type = type;
		break;
	default:
		value = NULL;
	}	
	return value;
}

/****************************************************************************
.FUNC		Creates a 64-bit integer Value structure.
.DESCR	This function allocates memory for a 64-bit numeric Value
			structure of type <type> and sets its value to <hipart>,<lopart>.
			The memory can be free by SmiDestroyValue().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to Value structure.
****************************************************************************/
SMI_PVALUE		SMI_API SmiCreateNumber64Value(
	IN short type,				/*.PARAM 64-bit integer type */
	IN SMI_UINT32 hipart,	/*.PARAM high part of 64-bit integer value */
	IN SMI_UINT32 lopart)	/*.PARAM low part of 64-bit integer value */
{
	SMI_PVALUE value;

	switch (type) {
	case SMI_TYPE_CNTR64:
		value = SmiAlloc(sizeof(SMI_VALUE));
		if (value==NULL) return value;
		value->value.hNumber.hipart = hipart;
		value->value.hNumber.lopart = lopart;
		value->type = type;
		break;
	default:
		value = NULL;
		break;
	}	
	return value;
}

/****************************************************************************
.FUNC		Creates a Octet String Value structure.
.DESCR	This function allocates memory for a Octet String Value
			structure of type <type>.
			The memory can be free by SmiDestroyValue().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to Value structure.
****************************************************************************/
SMI_PVALUE		SMI_API SmiCreateOctetsValue(
	IN short type,				/*.PARAM Octet String type*/
	IN SMI_UINT32 len)		/*.PARAM Number of bytes to allocate */
{
	SMI_PVALUE value;

	if (len==SMI_DEFAULTLEN) {
		switch (type) {
		case SMI_TYPE_IPADDR:	len = 4;						break;
		case SMI_TYPE_NSAPADDR:	len = 6;						break;
		default:						len = SMI_STANDARDLEN;	break;
		}
	}
	switch (type) {
	case SMI_TYPE_OCTETS:
	case SMI_TYPE_BITS:
	case SMI_TYPE_OPAQUE:
	case SMI_TYPE_IPADDR:
	case SMI_TYPE_NSAPADDR:
		/* TODO: (len+1) is required because of unknown bug */
		value = SmiAlloc(sizeof(SMI_VALUE)+(len+1)*sizeof(SMI_BYTE));
		value->value.string.len = len;
		value->value.string.ptr = (SMI_PBYTE)(value+1);
		value->type = type;
		break;
	default:
		value = NULL;
		break;
	}
	return value;
}

/****************************************************************************
.FUNC		Creates a Object ID Value structure.
.DESCR	This function allocates memory for a Object ID Value
			structure of type <type>.
			The memory can be free by SmiDestroyValue().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to Value structure.
****************************************************************************/
SMI_PVALUE		SMI_API SmiCreateOidValue(
	IN short type,				/*.PARAM Object ID type */
	IN SMI_UINT32 len)		/*.PARAM Number of integers to allocate */
{
	SMI_PVALUE value;

	switch (type) {
	case SMI_TYPE_OID:
		if (len==SMI_DEFAULTLEN) len = SMI_STANDARDLEN;
		value = SmiAlloc(sizeof(SMI_VALUE)+len*sizeof(SMI_UINT32));
		value->value.oid.len = len;
		value->value.oid.ptr = (SMI_PUINT32)(value+1);
		value->type = type;
		break;
	default:
		value = NULL;
		break;
	}
	return value;
}

/****************************************************************************
.FUNC		Duplicates a Value structure.
.DESCR	This function allocates memory for a Value structure and copies
			<srcValue> into the newly allocated structure.
			The memory can be free by SmiDestroyValue().
.RETURN	NULL		Insufficient memory.
			!NULL		Pointer to Value structure.
****************************************************************************/
SMI_PVALUE		SMI_API SmiDuplicateValue(
	IN SMI_PVALUE srcValue)	/*.PARAM */
{
	SMI_PVALUE value;

	switch (srcValue->type) {
	case SMI_TYPE_INT:
	case SMI_TYPE_NULL:
		value = SmiCreateNumberValue(srcValue->type, srcValue->value.sNumber);
		break;
	case SMI_TYPE_UINT32:
	case SMI_TYPE_CNTR32:
	case SMI_TYPE_GAUGE32:
	case SMI_TYPE_TIMETICKS:
		value = SmiCreateNumberValue(srcValue->type, srcValue->value.uNumber);
		break;
	case SMI_TYPE_CNTR64:
		value = SmiCreateNumber64Value(srcValue->type, srcValue->value.hNumber.hipart, srcValue->value.hNumber.lopart);
		break;
	case SMI_TYPE_OCTETS:
	case SMI_TYPE_BITS:
	case SMI_TYPE_OPAQUE:
	case SMI_TYPE_IPADDR:
	case SMI_TYPE_NSAPADDR:
		value = SmiCreateOctetsValue(srcValue->type, srcValue->value.string.len);
		if (value==NULL) return value;
		memcpy(value->value.string.ptr, srcValue->value.string.ptr, value->value.string.len*sizeof(SMI_BYTE));
		break;
	case SMI_TYPE_OID:
		value = SmiCreateOidValue(srcValue->type, srcValue->value.string.len);
		if (value==NULL) return value;
		memcpy(value->value.oid.ptr, srcValue->value.oid.ptr, value->value.oid.len*sizeof(SMI_UINT32));
		break;
	default:
		value = NULL;
		break;
	}	
	return value;
}

/****************************************************************************
.FUNC		Frees a Value structure.
.DESCR	Frees memory of a Value structure, previously allocated by
			SmiCreateNumberValue(), SmiCreateNumber64Value(),
			SmiCreateOctetsValue() or SmiCreateOidValue().
.RETURN	.INC smi_status
****************************************************************************/
SMI_STATUS		SMI_API SmiDestroyValue(
	IN SMI_PVALUE value)		/*.PARAM Value structure pointer */
{
	SmiFree(value);
	return SMI_SUCCESS;
}