rvsdpobjs.c

h.248协议源码

/******************************************************************************
Filename    :rvsdpobjs.c
Description :Definitions and structures for SDP message objects

******************************************************************************
                Copyright (c) 1999 RADVision Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:1.0$
$Date:7/18/99$
$Author:Dan Elbert$
******************************************************************************/
#include <stdio.h>

#include "rvsdpobjs.h"
#include "rvutil.h"
#include "rvstring.h"


/******* List declarations *****************************/
rvDefineList(RvSdpEmail)
rvDefineListAt(RvSdpEmail)
rvDefineListAllocBack(RvSdpEmail)

rvDefineList(RvSdpPhone)
rvDefineListAt(RvSdpPhone)
rvDefineListAllocBack(RvSdpPhone)

rvDefineList(RvSdpSessionTime)
rvDefineListAt(RvSdpSessionTime)
rvDefineListAllocBack(RvSdpSessionTime)

#ifdef RV_SDPTIME_FULL
rvDefineList(RvSdpTypedTime)
rvDefineListAt(RvSdpTypedTime)
rvDefineListAllocBack(RvSdpTypedTime)

rvDefineList(RvSdpRepeatInterval)
rvDefineListAt(RvSdpRepeatInterval)
rvDefineListAllocBack(RvSdpRepeatInterval)

rvDefineList(RvSdpTimeZoneAdjust)
rvDefineListAt(RvSdpTimeZoneAdjust)
rvDefineListAllocBack(RvSdpTimeZoneAdjust)
#endif
rvDefineList(RvSdpAttribute)
rvDefineListAt(RvSdpAttribute)
rvDefineListAllocBack(RvSdpAttribute)

rvDefineList(RvSdpRtpMap)
rvDefineListAt(RvSdpRtpMap)
rvDefineListAllocBack(RvSdpRtpMap)

/************* Private helper functions ******************/
RvString* rvSdpStringAssign(RvString* s, const char* v) {
	return rvStringAssign(s, v); 
}
const char* rvSdpStringGetData(const RvString* s) { 
	return rvStringGetData(s); 
}

/************* Origin Methods ****************************/

RvSdpOrigin * rvSdpOriginConstructN(RvSdpOrigin *x,
					   const char * username,size_t ulen,
					   const char * session_id,size_t slen,
					   const char * version,size_t vlen,
					   RvSdpNetType nettype,RvSdpAddrType addrtype,
					   const char * address,size_t alen,RvAlloc * alloc) {
	rvStringConstructN(&x->username,username,ulen,alloc);
	rvStringConstructN(&x->session_id,session_id,slen,alloc);
	rvStringConstructN(&x->version,version,vlen,alloc);
	x->nettype = nettype;
	x->addrtype = addrtype;
#ifdef RV_SDPSYMB_USESTRING
	rvStringConstructN(&x->nettype_str,"",0,alloc);
	rvStringConstructN(&x->addrtype_str,"",0,alloc);
#endif
	rvStringConstructN(&x->address,address,alen,alloc);	

	return x;
}

RvSdpOrigin * rvSdpOriginConstructCopyA(RvSdpOrigin *d,const RvSdpOrigin *s, RvAlloc *a) { 
	rvSdpOriginConstructA(d,rvSdpOriginGetUsername(s),rvSdpOriginGetSessionId(s),
							rvSdpOriginGetVersion(s),rvSdpOriginGetNetType(s),
							rvSdpOriginGetAddressType(s),rvSdpOriginGetAddress(s),
							a);					  
	if(s->nettype==RV_SDPNETTYPE_UNKNOWN)
		rvSdpOriginSetNetTypeStr(d,rvSdpOriginGetNetTypeStr(s));
	if(s->addrtype==RV_SDPADDRTYPE_UNKNOWN)
		rvSdpOriginSetAddressTypeStr(d,rvSdpOriginGetAddressTypeStr(s));

	return d;
}

RvSdpOrigin * rvSdpOriginConstructCopy(RvSdpOrigin *d,const RvSdpOrigin *s) { 
	return rvSdpOriginConstructCopyA(d,s,&rvDefaultAlloc);
}

void rvSdpOriginDestruct(RvSdpOrigin *x) {
	rvStringDestruct(&x->username);
	rvStringDestruct(&x->session_id);
	rvStringDestruct(&x->version);
	rvStringDestruct(&x->address);	
#ifdef RV_SDPSYMB_USESTRING
	rvStringDestruct(&x->nettype_str);
	rvStringDestruct(&x->addrtype_str);
#endif
}

RvSdpOrigin * rvSdpOriginCopy(RvSdpOrigin *d,const RvSdpOrigin *s, RvAlloc *a) { 
	rvSdpOriginDestruct(d);
	rvSdpOriginConstructA(d,rvSdpOriginGetUsername(s),rvSdpOriginGetSessionId(s),
							rvSdpOriginGetVersion(s),rvSdpOriginGetNetType(s),
							rvSdpOriginGetAddressType(s),rvSdpOriginGetAddress(s),
							a);		
#ifdef RV_SDPSYMB_USESTRING
	if(s->nettype==RV_SDPNETTYPE_UNKNOWN)
		rvSdpOriginSetNetTypeStr(d,rvSdpOriginGetNetTypeStr(s));
	if(s->addrtype==RV_SDPADDRTYPE_UNKNOWN)
		rvSdpOriginSetAddressTypeStr(d,rvSdpOriginGetAddressTypeStr(s));
#endif
	return d;
}

/* Make macro 
const char * rvSdpOriginGetUsername(const RvSdpOrigin * x) {
	return rvStringGetData(&x->username);
}

const char * rvSdpOriginGetSessionId(const RvSdpOrigin * x) {
	return rvStringGetData(&x->session_id);
}

const char * rvSdpOriginGetVersion(const RvSdpOrigin * x) {
	return rvStringGetData(&x->version);
}

RvSdpNetType rvSdpOriginGetNetType(const RvSdpOrigin * x) {
	return x->nettype;
}

RvSdpAddrType rvSdpOriginGetAddressType(const RvSdpOrigin * x) {
	return x->addrtype;
}

const char * rvSdpOriginGetAddress(const RvSdpOrigin * x) {
	return rvStringGetData(&x->address);
}
*/
const char *  rvSdpOriginGetNetTypeStr(const RvSdpOrigin * x) {
#ifdef RV_SDPSYMB_USESTRING
	return rvStringGetData(&(x)->nettype_str);
#else
	return empty_str;
#endif
}

void rvSdpOriginSetNetTypeStr(RvSdpOrigin * x,const char * type) {
#ifdef RV_SDPSYMB_USESTRING
	x->nettype = RV_SDPNETTYPE_UNKNOWN;
	rvStringAssign(&(x)->nettype_str,type);
#endif
}
void rvSdpOriginSetNetTypeStrN(RvSdpOrigin * x,const char * type,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	x->nettype = RV_SDPNETTYPE_UNKNOWN;
	rvStringAssignN(&(x)->nettype_str,type,n);
#endif
}

const char * rvSdpOriginGetAddressTypeStr(const RvSdpOrigin * x) {
#ifdef RV_SDPSYMB_USESTRING
	return rvStringGetData(&(x)->addrtype_str);
#else
	return empty_str;
#endif
}

void rvSdpOriginSetAddressTypeStr(RvSdpOrigin * x,const char * t) {
#ifdef RV_SDPSYMB_USESTRING
	x->addrtype = RV_SDPADDRTYPE_UNKNOWN;
	rvStringAssign(&(x)->addrtype_str,t);
#endif
}
void rvSdpOriginSetAddressTypeStrN(RvSdpOrigin * x,const char * t,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	x->addrtype = RV_SDPADDRTYPE_UNKNOWN;
	rvStringAssignN(&(x)->addrtype_str,t,n);
#endif
}

/******************* Email methods ********************************/

RvSdpEmail * rvSdpEmailConstructN(RvSdpEmail * x,
					 const char * address,size_t alen,
					 const char * text,size_t tlen,
					 RvAlloc * alloc) {
	rvStringConstructN(&x->address,address,alen,alloc);
	rvStringConstructN(&x->text,text,tlen,alloc);
	return x;
}

RvSdpEmail * rvSdpEmailConstructCopyA(RvSdpEmail *d,const RvSdpEmail *s,RvAlloc * alloc) {
	rvSdpEmailConstructA(d,rvSdpEmailGetAddress(s),rvSdpEmailGetText(s),alloc);	
	return d;
}

RvSdpEmail *  rvSdpEmailConstructCopy(RvSdpEmail *d,const RvSdpEmail *s) {
	return rvSdpEmailConstructCopyA(d,s,&rvDefaultAlloc);		
}

void rvSdpEmailDestruct(RvSdpEmail *x) {
	rvStringDestruct(&x->address);
	rvStringDestruct(&x->text);
}

RvSdpEmail *  rvSdpEmailCopy(RvSdpEmail *d,const RvSdpEmail *s) {
	rvStringAssign(&d->address,rvSdpEmailGetAddress(s));
	rvStringAssign(&d->text,rvSdpEmailGetText(s));
	return d;
}

/* Make macro 
const char * rvSdpEmailGetAddress(const RvSdpEmail * x) {
	return rvStringGetData(&x->address);
}

const char * rvSdpEmailGetText(const RvSdpEmail * x) {
	return rvStringGetData(&x->text);
}
*/

/************** Phone fields ******************************/

RvSdpPhone* rvSdpPhoneConstructN(RvSdpPhone * x,
					 const char * number,size_t nlen,
					 const char * text,size_t tlen,
					 RvAlloc * alloc) {
	rvStringConstructN(&x->phone_number,number,nlen,alloc);
	rvStringConstructN(&x->text,text,tlen,alloc);
	return x;
}


RvSdpPhone* rvSdpPhoneConstructCopyA(RvSdpPhone *d,const RvSdpPhone *s,RvAlloc * alloc) {
	rvSdpPhoneConstructA(d,rvSdpPhoneGetNumber(s),rvSdpPhoneGetText(s),alloc);		
	return d;
}

RvSdpPhone* rvSdpPhoneConstructCopy(RvSdpPhone *d,const RvSdpPhone *s) {
	return rvSdpPhoneConstructCopyA(d,s,&rvDefaultAlloc);
}

void rvSdpPhoneDestruct(RvSdpPhone *x) {
	rvStringDestruct(&x->phone_number);
	rvStringDestruct(&x->text);
}

RvSdpPhone* rvSdpPhoneCopy(RvSdpPhone *d,const RvSdpPhone *s) {
	rvStringAssign(&d->phone_number,rvSdpPhoneGetNumber(s));
	rvStringAssign(&d->text,rvSdpPhoneGetText(s));
	return d;
}

/* Make macro 
const char * rvSdpPhoneGetNumber(const RvSdpPhone * x) {
	return rvStringGetData(&x->phone_number);
}

const char * rvSdpPhoneGetText(const RvSdpPhone * x) {
	return rvStringGetData(&x->text);
}
*/

/************** Typed time fields ******************************/

void rvSdpTypedTimeConstruct(RvSdpTypedTime * x,RvSdpTimeUnit units,RvUint32 time) {
	x->type = units;
	x->time = time;
}

void rvSdpTypedTimeConstructA(RvSdpTypedTime * x,RvSdpTimeUnit units,RvUint32 time,RvAlloc * a) {
	rvSdpTypedTimeConstruct(x,units,time);
}

void rvSdpTypedTimeConstructCopy(RvSdpTypedTime *d,const RvSdpTypedTime *s,RvAlloc * alloc) {
	rvSdpTypedTimeConstructA(d,rvSdpTypedTimeGetUnits(s),rvSdpTypedTimeGetTime(s),alloc);
}

void rvSdpTypedTimeDestruct(RvSdpTypedTime * x) {
	return;
}

void rvSdpTypedTimeCopy(RvSdpTypedTime *d,const RvSdpTypedTime *s,RvAlloc * alloc) {
	rvSdpTypedTimeConstructA(d,rvSdpTypedTimeGetUnits(s),rvSdpTypedTimeGetTime(s),alloc);
}

/* Make macro 
RvSdpTimeUnit rvSdpTypedTimeGetUnits(const RvSdpTypedTime * x) {
	return x->type;
}

RvUint32 rvSdpTypedTimeGetTime(const RvSdpTypedTime * x) {
	return x->time;
}
*/

/****************************************************************/
RV_SDP_DECLSPEC RvSdpTypedTimeList* rvSdpTypedTimeListConstruct(RvSdpTypedTimeList *x)
{
	return rvSdpTypedTimeListConstructA(x,&rvDefaultAlloc);
}

/****************************************************************/

RvSdpRepeatInterval * rvSdpRepeatIntervalConstructA(RvSdpRepeatInterval * x,
							   RvUint32 time,RvSdpTimeUnit t_units,
							   RvUint32 duration ,RvSdpTimeUnit d_units,RvAlloc * a) {
#ifdef RV_SDPTIME_FULL
	rvSdpTypedTimeConstruct(&x->interval,t_units,time);