rvsdpmsg.c

h.248协议源码

/******************************************************************************
Filename    :rvsdpmsg.c
Description : Access functions for SDP structure
******************************************************************************
                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:12/20/99$
$Author:Dan Elbert$
******************************************************************************/

#include "rvtypes.h"
#include "rvsdpmsg.h"
#include "rvalloc.h"
#include "rvdefalloc.h"

#define RV_SDPVERSION "0"


RvSdpMsg *rvSdpMsgConstructA(RvSdpMsg * sdp, RvAlloc * a) 
{
	sdp->alloc = a;

	strcpy(sdp->sdp_version,RV_SDPVERSION);
	sdp->origin = NULL;
	rvStringConstruct(&sdp->session_id, "", a);
	rvStringConstruct(&sdp->uri, "", a);
	rvListConstruct(RvSdpEmail)(&sdp->email_list,a);
	rvListConstruct(RvSdpPhone)(&sdp->phone_list,a);
	rvSdpCommonFieldsConstruct(&sdp->fields,a);
	rvListConstruct(RvSdpSessionTime)(&sdp->session_time,a);
#ifdef RV_SDPTIME_FULL
	rvListConstruct(RvSdpTimeZoneAdjust)(&sdp->zone_adjustment_list,a);
#endif
	rvListConstruct(RvSdpMediaDescr)(&sdp->media_descriptors,a);
		
	sdp->sdp_msg = NULL;
	sdp->msg_len = 0;

	return sdp;
}

/* Public functions */
RvSdpMsg*  rvSdpMsgConstruct(RvSdpMsg * sdp) {
	return rvSdpMsgConstructA(sdp, &rvDefaultAlloc);
}

void rvSdpMsgDestruct(RvSdpMsg * sdp)  {

	rvSdpCommonFieldsDestruct(&sdp->fields,sdp->alloc);

	if(sdp->origin!=NULL) {
		rvSdpOriginDestruct(sdp->origin);
		rvAllocDeallocate(sdp->alloc,sizeof(RvSdpOrigin),sdp->origin);
	}

	rvStringDestruct(&sdp->session_id);
	rvStringDestruct(&sdp->uri);
	rvListDestruct(RvSdpEmail)(&sdp->email_list);
	rvListDestruct(RvSdpPhone)(&sdp->phone_list);
	rvListDestruct(RvSdpSessionTime)(&sdp->session_time);
#ifdef RV_SDPTIME_FULL
	rvListDestruct(RvSdpTimeZoneAdjust)(&sdp->zone_adjustment_list);
#endif
	rvListDestruct(RvSdpMediaDescr)(&sdp->media_descriptors);
}


RvSdpMsg* rvSdpMsgCopy(RvSdpMsg *d, const RvSdpMsg *s) {
	rvSdpMsgDestruct(d);
	return rvSdpMsgConstructCopyA(d,s,d->alloc);
}


RvSdpMsg* rvSdpMsgConstructCopyA(RvSdpMsg *d, const RvSdpMsg *s, RvAlloc *a) 
{
	RvSdpOrigin * origin;
	RvSdpConnection * s_conn;
	RvSdpKey * key;
	RvSdpBandwidth * bandwidth;
	size_t i;
	RvSdpAttribute * attr;
	RvSdpRtpMap * map,* new_map;

	rvSdpMsgConstructA(d,a);

	rvSdpMsgSetVersionN(d,rvSdpMsgGetVersion(s),strlen(rvSdpMsgGetVersion(s)));
	if( (origin = rvSdpMsgGetOrigin(s))!=NULL ) {
		d->origin = (RvSdpOrigin *)rvAllocAllocate(d->alloc,sizeof(RvSdpOrigin));
		rvSdpOriginConstructCopyA(d->origin,origin,d->alloc);
	}

	rvSdpMsgSetSessionName(d,rvSdpMsgGetSessionName(s));
	rvSdpMsgSetSessionInformation(d,rvSdpMsgGetSessionInformation(s));
	rvSdpMsgSetURI(d,rvSdpMsgGetURI(s));
	rvSdpEmailListCopy(&d->email_list,&s->email_list);
	rvSdpPhoneListCopy(&d->phone_list,&s->phone_list);

	if( (s_conn = rvSdpMsgGetConnection(s))!=NULL ) {
		d->fields.connection = (RvSdpConnection *)rvAllocAllocate(d->alloc,sizeof(RvSdpConnection));
		rvSdpConnectionConstructCopyA(d->fields.connection,s_conn,d->alloc);
	}
	
	if( (key = rvSdpMsgGetKey(s))!=NULL ) 
		rvSdpCommonFieldsSetKeyCopy(&d->fields,key,d->alloc);

	if( (bandwidth = rvSdpMsgGetBandwidth(s))!=NULL )
		rvSdpMsgSetBandwidth(d,rvSdpBandwidthGetType(bandwidth),rvSdpBandwidthGetValue(bandwidth));

	rvSdpSessionTimeListCopy(&d->session_time,&s->session_time);
#ifdef RV_SDPTIME_FULL
	rvSdpTimeZoneAdjustListCopy(&d->zone_adjustment_list,&s->zone_adjustment_list);
#endif
	for(i=0;i<rvSdpMsgGetNumOfAttr(s);i++) {
		attr = rvSdpMsgGetAttribute(s,i);
		rvSdpMsgAddAttr(d,rvSdpAttributeGetName(attr),rvSdpAttributeGetValue(attr));
	}

	for(i=0;i<rvSdpMsgGetNumOfRtpMap(s);i++) {	
		map = rvSdpMsgGetRtpMap(s,i);
		new_map = rvSdpMsgAddRtpMap(d,rvSdpRtpMapGetPayload(map),rvSdpRtpMapGetEncodingName(map),
										rvSdpRtpMapGetClockRate(map));
		rvSdpRtpMapSetEncodingParameters(new_map,rvSdpRtpMapGetEncodingParameters(map));
	}

	rvSdpMsgSetConnectionMode(d,rvSdpMsgGetConnectionMode(s));

	rvSdpMediaDescrListCopy(&d->media_descriptors,&s->media_descriptors);

	return d;
}

RvSdpMsg* rvSdpMsgConstructCopy(RvSdpMsg *d, const RvSdpMsg *s) {
	return rvSdpMsgConstructCopyA(d,s,&rvDefaultAlloc);
}


/****************************************************/
/*		Method to get the SIP text  				*/
/****************************************************/
const char * rvSdpMsgGetText(RvSdpMsg *d,int * len) {
	*len = d->msg_len;
	return d->sdp_msg;
}



/****************************************************/
/*		SESSION LEVEL METHODS						*/
/****************************************************/

/*------ Version Field ---------------------------------*/

void rvSdpMsgSetVersionN(RvSdpMsg* x,const char * version,size_t len) {
	strncpy(x->sdp_version,version,len);
}

/*------ Origin Field ---------------------------------*/
void rvSdpMsgSetOriginN(RvSdpMsg *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) {
	if(x->origin!=NULL)
		rvSdpOriginDestruct(x->origin);
	else
		x->origin = (RvSdpOrigin *)rvAllocAllocate(x->alloc,sizeof(RvSdpOrigin));
	rvSdpOriginConstructN(x->origin,username,ulen,
							session_id,slen,version,vlen,nettype,addrtype,
							address,alen,x->alloc);
}

/*------ Session Id Field -----------------------------*/
void rvSdpMsgSetSessionNameN(RvSdpMsg* x,const char * sess_id,size_t len) {
	rvStringAssignN(&x->session_id,sess_id,len);
}

/*------ Uri Field ------------------------------------*/
void rvSdpMsgSetURIN(RvSdpMsg* x,const char * uri,size_t len) {
	rvStringAssignN(&(x)->uri,uri,len);
}

/*------ Email Field ---------------------------------*/
RvSdpEmail* rvSdpMsgAddEmailN(RvSdpMsg* x,const char * email_addr,size_t len,const char* string,size_t slen) {
	RvSdpEmail * email = rvListAllocBack(RvSdpEmail)(&x->email_list);
	rvSdpEmailConstructN(email,email_addr,len,string,slen,x->alloc);
	return email;
}

size_t	rvSdpMsgGetNumOfEmail(const RvSdpMsg* x) {
	return rvListSize(&x->email_list);
}
RvSdpEmail * rvSdpMsgGetEmail(const RvSdpMsg* x,size_t i) {
	return rvListAt(RvSdpEmail)(&x->email_list,i);
}
void rvSdpMsgRemoveEmail(RvSdpMsg* x,size_t index) {
	size_t j;
	RvListIter(RvSdpEmail) iter = rvListBegin(&x->email_list);
	if (index < rvListSize(&x->email_list)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpEmail)(&x->email_list, iter);
	}
}
void rvSdpMsgClearEmail(RvSdpMsg* x) {
	rvListClear(RvSdpEmail)(&x->email_list);
}


/*------ Phone Field ---------------------------------*/
RvSdpPhone * rvSdpMsgAddPhoneN(RvSdpMsg* x,const char * phone_number,size_t plen,const char* string,size_t slen) {
	RvSdpPhone * phone = rvListAllocBack(RvSdpPhone)(&x->phone_list);
	rvSdpPhoneConstructN(phone,phone_number,plen,string,slen,x->alloc);
	return phone;
}
size_t	rvSdpMsgGetNumOfPhones(const RvSdpMsg* x) {
	return rvListSize(&x->phone_list);
}
RvSdpPhone * rvSdpMsgGetPhone(const RvSdpMsg* x,size_t i) {
	return rvListAt(RvSdpPhone)(&x->phone_list,i);
}

void rvSdpMsgRemovePhone(RvSdpMsg* x, size_t index) {
	size_t j;
	RvListIter(RvSdpPhone) iter = rvListBegin(&x->phone_list);
	if (index < rvListSize(&x->phone_list)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpPhone)(&x->phone_list, iter);
	}
}

void rvSdpMsgClearPhones(RvSdpMsg* x) {
	rvListClear(RvSdpPhone)(&x->phone_list);
}

/*------ Connection Field ---------------------------*/
RvSdpConnection* rvSdpMsgGetConnection(const RvSdpMsg* x) {
	return x->fields.connection;
}

void rvSdpMsgSetConnection(RvSdpMsg* x,RvSdpNetType net_type,RvSdpAddrType addr_type,const char* addr) {

	rvSdpCommonFieldsSetConnectionN(&x->fields,net_type,addr_type,addr,strlen(addr),x->alloc); 
}

/*------ Bandwidth Field ---------------------------*/
void rvSdpMsgSetBandwidth(RvSdpMsg* x,const char *bwtype,int b) {
	rvSdpCommonFieldsSetBandwidthN(&x->fields,bwtype,strlen(bwtype),b,x->alloc);
}

/*------ Key Field ----------------------------------*/
RvSdpKey*	rvSdpMsgGetKey(const RvSdpMsg* x) {
	return x->fields.key;
}

void rvSdpMsgSetKey(RvSdpMsg* x,RvSdpEncrMethod em,const char* key) {	
	rvSdpCommonFieldsSetKeyN(&x->fields,em,key,strlen(key),x->alloc);
}

/*------ Time Fields  ---------------------------------*/
RvSdpSessionTime * rvSdpMsgAddSessionTime(RvSdpMsg* x,RvUint32 start,RvUint32 stop) {
	RvSdpSessionTime * time = rvListAllocBack(RvSdpSessionTime)(&x->session_time);
	rvSdpSessionTimeConstructA(time,start,stop,x->alloc);
	return time;
}

void rvSdpMsgClearSessionTime(RvSdpMsg* descr) {
	rvListClear(RvSdpSessionTime)(&descr->session_time);
}

size_t rvSdpMsgGetNumOfSessionTime(RvSdpMsg* descr) {
	return rvListSize(&descr->session_time);
}

RvSdpSessionTime* rvSdpMsgGetSessionTime(RvSdpMsg* descr,size_t i) {
	return rvListAt(RvSdpSessionTime)(&descr->session_time,i);
}

void rvSdpMsgRemoveSessionTime(RvSdpMsg* descr, size_t index) {
	size_t j;
	RvListIter(RvSdpSessionTime) iter = rvListBegin(&descr->session_time);
	if (index < rvListSize(&descr->session_time)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpSessionTime)(&descr->session_time, iter);
	}
}

RvSdpTimeZoneAdjust * rvSdpMsgTimeAddZoneAdjustment(RvSdpMsg* x,RvUint32 time,RvInt32 adjust_time,RvSdpTimeUnit units) {
	RvSdpTimeZoneAdjust * zone = NULL;