xref: /illumos-gate/usr/src/lib/libcommputil/common/sdp.c (revision 1da57d55)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Contains implementation of various interfaces exported by library
 */

#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sdp.h>

#include "sdp_parse.h"
#include "commp_util.h"

#define	FIELD_EQUALS_CRLF_LEN		4  /* first two characters and CRLF */

#define	SDP_ATTR_TO_STR(m_attr) {					\
	while ((m_attr) != NULL) {					\
		if ((m_attr)->a_value != NULL) {			\
			wrote = snprintf(buf, len, "a=%s%c%s%s",	\
			    (m_attr)->a_name, COMMP_COLON, (m_attr)->  	\
			    a_value, COMMP_CRLF);			\
		} else {						\
			wrote = snprintf(buf, len, "a=%s%s", (m_attr)-> \
			    a_name, COMMP_CRLF);			\
		}							\
		len = len - wrote;					\
		buf = buf + wrote;					\
		(m_attr) = (m_attr)->a_next;				\
	}								\
}

#define	SDP_KEY_TO_STR(m_key) {						\
	if ((m_key) != NULL) {						\
		if ((m_key)->k_enckey != NULL) {			\
			wrote = snprintf(buf, len, "k=%s%c%s%s",	\
			    (m_key)->k_method, COMMP_COLON, (m_key)->	\
			    k_enckey, COMMP_CRLF);			\
		} else {						\
			wrote = snprintf(buf, len, "k=%s%s", (m_key)->	\
			    k_method, COMMP_CRLF);			\
		}							\
		len = len - wrote;					\
		buf = buf + wrote;					\
	}								\
}

#define	SDP_BANDWIDTH_TO_STR(m_bw) {					\
	while ((m_bw) != NULL) {					\
		wrote = snprintf(buf, len, "b=%s%c%llu%s", (m_bw)->	\
		    b_type, COMMP_COLON, (m_bw)->b_value, COMMP_CRLF);	\
		len = len - wrote;					\
		buf = buf + wrote;					\
		(m_bw) = (m_bw)->b_next;				\
	}								\
}

#define	SDP_INFORMATION_TO_STR(m_info) {				       \
	if ((m_info) != NULL) {						       \
		wrote = snprintf(buf, len, "i=%s%s", (m_info), COMMP_CRLF);    \
		len = len - wrote;					       \
		buf = buf + wrote;					       \
	}								       \
}

#define	SDP_CONNECTION_TO_STR(m_conn) {					       \
	while ((m_conn) != NULL) {					       \
		if (strcasecmp((m_conn)->c_addrtype,			       \
		    COMMP_ADDRTYPE_IP4) == 0) {				       \
			if ((m_conn)->c_addrcount > 1) {		       \
				wrote = snprintf(buf, len, "c=%s %s %s/%d/%d"  \
				    "%s", (m_conn)->c_nettype, (m_conn)->      \
				    c_addrtype, (m_conn)->c_address, (m_conn)->\
				    c_ttl, (m_conn)->c_addrcount, COMMP_CRLF); \
			} else if ((m_conn)->c_addrcount == 1) {	       \
				wrote = snprintf(buf, len, "c=%s %s %s/%d%s",  \
				    (m_conn)->c_nettype, (m_conn)->c_addrtype, \
				    (m_conn)->c_address, (m_conn)->c_ttl,      \
				    COMMP_CRLF);			       \
			} else {					       \
				wrote = snprintf(buf, len, "c=%s %s %s%s",     \
				    (m_conn)->c_nettype, (m_conn)->c_addrtype, \
				    (m_conn)->c_address, COMMP_CRLF);	       \
			}						       \
		} else if (strcasecmp((m_conn)->c_addrtype,		       \
		    COMMP_ADDRTYPE_IP6) == 0) {                                \
			if ((m_conn)->c_addrcount <= 1) {		       \
				wrote = snprintf(buf, len, "c=%s %s %s%s",     \
				    (m_conn)->c_nettype, (m_conn)->c_addrtype, \
				    (m_conn)->c_address, COMMP_CRLF);	       \
			} else {					       \
				wrote = snprintf(buf, len, "c=%s %s %s/%d%s",  \
				    (m_conn)->c_nettype, (m_conn)->c_addrtype, \
				    (m_conn)->c_address, (m_conn)->c_addrcount,\
				    COMMP_CRLF);			       \
			}						       \
		} else {						       \
			wrote = snprintf(buf, len, "c=%s %s %s%s", (m_conn)->  \
			    c_nettype, (m_conn)->c_addrtype, (m_conn)->        \
			    c_address, COMMP_CRLF);			       \
		}							       \
		len = len - wrote;					       \
		buf = buf + wrote;					       \
		(m_conn) = (m_conn)->c_next;				       \
	}								       \
}

#define	SDP_ADD_KEY(d_key, s_key) {					\
	if ((s_key) != NULL) {						\
		if (sdp_add_key(&(d_key), (s_key)->k_method,		\
		    (s_key)->k_enckey) != 0) {				\
			sdp_free_session(new_sess);			\
			return (NULL);					\
		}							\
	}								\
}

#define	SDP_ADD_ATTRIBUTE(d_attr, s_attr) {				\
	while ((s_attr) != NULL) {					\
		if (sdp_add_attribute(&(d_attr), (s_attr)->a_name,	\
		    (s_attr)->a_value) != 0) {		 		\
			sdp_free_session(new_sess);			\
			return (NULL);					\
		}							\
		(s_attr) = (s_attr)->a_next;				\
	}								\
}

#define	SDP_ADD_BANDWIDTH(d_bw, s_bw) {					\
	while ((s_bw) != NULL) {					\
		if (sdp_add_bandwidth(&(d_bw), (s_bw)->b_type,		\
		    (s_bw)->b_value) != 0) {				\
			sdp_free_session(new_sess);			\
			return (NULL);					\
		}							\
		(s_bw) = (s_bw)->b_next;				\
	}								\
}

#define	SDP_ADD_CONNECTION(d_conn, s_conn) {				\
	while ((s_conn) != NULL) {					\
		if (sdp_add_connection(&(d_conn), (s_conn)->c_nettype,	\
		    (s_conn)->c_addrtype, (s_conn)->c_address,		\
		    (s_conn)->c_ttl, (s_conn)->c_addrcount) != 0) {	\
			sdp_free_session(new_sess);			\
			return (NULL);					\
		}							\
		(s_conn) = (s_conn)->c_next;				\
	}								\
}

#define	SDP_LEN_CONNECTION(m_conn) {					  \
	while ((m_conn) != NULL) {					  \
		len += FIELD_EQUALS_CRLF_LEN;				  \
		len += strlen((m_conn)->c_nettype);			  \
		len += strlen((m_conn)->c_addrtype) + 1;		  \
		len += strlen((m_conn)->c_address) + 1;			  \
		len += snprintf(buf, 1, "%u", (m_conn)->c_ttl) + 1;	  \
		len += snprintf(buf, 1, "%d", (m_conn)->c_addrcount) + 1; \
		(m_conn) = (m_conn)->c_next;				  \
	}								  \
}

#define	SDP_LEN_BANDWIDTH(m_bw) {					\
	while ((m_bw) != NULL) {					\
		len += FIELD_EQUALS_CRLF_LEN;				\
		len += strlen((m_bw)->b_type);				\
		len += snprintf(buf, 1, "%llu", (m_bw)->b_value) + 1;	\
		(m_bw) = (m_bw)->b_next;				\
	}								\
}

#define	SDP_LEN_KEY(m_key) {						\
	if ((m_key) != NULL) {						\
		len += FIELD_EQUALS_CRLF_LEN;				\
		len += strlen((m_key)->k_method);			\
		if ((m_key)->k_enckey != NULL)				\
			len += strlen((m_key)->k_enckey) + 1;		\
	}								\
}

#define	SDP_LEN_ATTRIBUTE(m_attr) {					\
	while ((m_attr) != NULL) {					\
		len += FIELD_EQUALS_CRLF_LEN;				\
		len += strlen((m_attr)->a_name);			\
		if ((m_attr)->a_value != NULL)				\
			len += strlen((m_attr)->a_value) + 1;		\
		(m_attr) = (m_attr)->a_next;				\
	}								\
}

/*
 * Given a media list and media name ("audio", "video", et al), it searches
 * the list for that media. Returns NULL if media not present.
 */
sdp_media_t *
sdp_find_media(sdp_media_t *media, const char *name)
{
	if (media == NULL || name == NULL || (strlen(name) == 0)) {
		return (NULL);
	}
	while (media != NULL) {
		if (media->m_name != NULL) {
			if (strcasecmp(name, media->m_name) == 0)
				return (media);
		}
		media = media->m_next;
	}
	return (media);
}

/*
 * Given a attribute list and name of the attribute ("rtpmap", "fmtp", et al),
 * this API searches the list for that attribute. Returns NULL if not found.
 */
sdp_attr_t *
sdp_find_attribute(sdp_attr_t *attr, const char *name)
{
	if (attr == NULL || name == NULL || (strlen(name) == 0)) {
		return (NULL);
	}
	while (attr != NULL) {
		if (attr->a_name != NULL) {
			if (strcasecmp(attr->a_name, name) == 0)
				return (attr);
		}
		attr = attr->a_next;
	}
	return (attr);
}

/*
 * Given a media list and a format number, this API will return the rtpmap
 * attribute matching the format number.
 */
sdp_attr_t *
sdp_find_media_rtpmap(sdp_media_t *media, const char *format)
{
	sdp_attr_t		*attr = NULL;
	char			*tmp = NULL;

	if (media == NULL || format == NULL || (strlen(format) == 0)) {
		return (NULL);
	}
	attr = media->m_attr;
	while (attr != NULL) {
		if (attr->a_name != NULL && (strcasecmp(attr->a_name,
		    SDP_RTPMAP) == 0)) {
			if (attr->a_value != NULL) {
				tmp = attr->a_value;
				while (isspace(*tmp))
					++tmp;
				if (strncasecmp(tmp, format,
				    strlen(format)) == 0) {
					return (attr);
				}
			}
		}
		attr = attr->a_next;
	}
	return (attr);
}

/*
 * Adds origin field to the session.
 * o=<username> <sess-id> <sess-version> <nettype> <addrtype> <unicast-address>
 */
int
sdp_add_origin(sdp_session_t *session, const char *name, uint64_t id,
    uint64_t ver, const char *nettype, const char *addrtype,
    const char *address)
{
	sdp_origin_t		*origin;
	int			ret = 0;

	if (session == NULL || name == NULL || nettype == NULL ||
	    addrtype == NULL || address == NULL) {
		return (EINVAL);
	}
	if (session->s_origin != NULL)
		return (EPROTO);
	origin = calloc(1, sizeof (sdp_origin_t));
	if (origin == NULL)
		return (ENOMEM);
	origin->o_id = id;
	origin->o_version = ver;
	if ((ret = commp_add_str(&origin->o_username, name, strlen(name))) != 0)
		goto err_ret;
	if ((ret = commp_add_str(&origin->o_nettype, nettype,
	    strlen(nettype))) != 0) {
		goto err_ret;
	}
	if ((ret = commp_add_str(&origin->o_addrtype, addrtype,
	    strlen(addrtype))) != 0) {
		goto err_ret;
	}
	if ((ret = commp_add_str(&origin->o_address, address,
	    strlen(address))) != 0) {
		goto err_ret;
	}
	session->s_origin = origin;
	return (ret);
err_ret:
	sdp_free_origin(origin);
	return (ret);
}

/*
 * Adds session name field to the session.
 * s=<session name>
 */
int
sdp_add_name(sdp_session_t *session, const char *name)
{
	if (session == NULL || name == NULL)
		return (EINVAL);
	if (session->s_name != NULL)
		return (EPROTO);
	return (commp_add_str(&session->s_name, name, strlen(name)));
}

/*
 * Adds session information field to the session or media section of SDP.
 * i=<session description>
 */
int
sdp_add_information(char **information, const char *value)
{
	if (information == NULL || value == NULL)
		return (EINVAL);
	if (*information != NULL)
		return (EPROTO);
	return (commp_add_str(information, value, strlen(value)));
}

/*
 * Adds uri field to the session.
 * u=<uri>
 */
int
sdp_add_uri(sdp_session_t *session, const char *uri)
{
	if (session == NULL || uri == NULL)
		return (EINVAL);
	if (session->s_uri != NULL)
		return (EPROTO);
	return (commp_add_str(&session->s_uri, uri, strlen(uri)));
}

/*
 * Adds email address field to the session.
 * e=<email-address>
 */
int
sdp_add_email(sdp_session_t *session, const char *email)
{
	if (session == NULL || email == NULL || (strlen(email) == 0))
		return (EINVAL);
	return (add_value_to_list(&session->s_email, email, strlen(email),
	    B_TRUE));
}

/*
 * Adds phone number field to the session.
 * p=<phone-number>
 */
int
sdp_add_phone(sdp_session_t *session, const char *phone)
{
	if (session == NULL || phone == NULL || (strlen(phone) == 0))
		return (EINVAL);
	return (add_value_to_list(&session->s_phone, phone, strlen(phone),
	    B_TRUE));
}

/*
 * Adds connection field to the session or media section of SDP
 * c=<nettype> <addrtype> <connection-address>[/ttl]/<number of addresses>
 */
int
sdp_add_connection(sdp_conn_t **conn, const char *nettype, const char *addrtype,
    const char *address, uint8_t ttl, int addrcount)
{
	sdp_conn_t		*tmp;
	sdp_conn_t		*new_conn;
	int			ret = 0;

	if (conn == NULL || nettype == NULL || addrtype == NULL ||
	    address == NULL) {
		return (EINVAL);
	}
	new_conn = calloc(1, sizeof (sdp_conn_t));
	if (new_conn == NULL)
		return (ENOMEM);
	new_conn->c_ttl = ttl;
	new_conn->c_addrcount = addrcount;
	if ((ret = commp_add_str(&new_conn->c_nettype, nettype,
	    strlen(nettype))) != 0) {
		goto err_ret;
	}
	if ((ret = commp_add_str(&new_conn->c_addrtype, addrtype,
	    strlen(addrtype))) != 0) {
		goto err_ret;
	}
	if ((ret = commp_add_str(&new_conn->c_address, address,
	    strlen(address))) != 0) {
		goto err_ret;
	}
	if (*conn == NULL) {
		*conn = new_conn;
	} else {
		tmp = *conn;
		while (tmp->c_next != NULL)
			tmp = tmp->c_next;
		tmp->c_next = new_conn;
	}
	return (ret);
err_ret:
	sdp_free_connection(new_conn);
	return (ret);
}

/*
 * Adds bandwidth field to the session or media section of SDP.
 * b=<bwtype>:<bandwidth>
 */
int
sdp_add_bandwidth(sdp_bandwidth_t **bw, const char *type, uint64_t value)
{
	sdp_bandwidth_t		*new_bw;
	sdp_bandwidth_t		*tmp;
	int			ret = 0;

	if (bw == NULL || type == NULL)
		return (EINVAL);
	new_bw = calloc(1, sizeof (sdp_bandwidth_t));
	if (new_bw == NULL)
		return (ENOMEM);
	new_bw->b_value = value;
	if ((ret = commp_add_str(&new_bw->b_type, type, strlen(type))) != 0) {
		free(new_bw);
		return (ret);
	}
	if (*bw == NULL) {
		*bw = new_bw;
	} else {
		tmp = *bw;
		while (tmp->b_next != NULL)
			tmp = tmp->b_next;
		tmp->b_next = new_bw;
	}
	return (ret);
}

/*
 * Adds time field to the session
 * t=<start-time> <stop-time>
 */
int
sdp_add_time(sdp_session_t *session, uint64_t starttime, uint64_t stoptime,
    sdp_time_t **time)
{
	sdp_time_t		*new_time;
	sdp_time_t		*tmp;

	if (time != NULL)
		*time = NULL;
	if (session == NULL) {
		return (EINVAL);
	}
	new_time = calloc(1, sizeof (sdp_time_t));
	if (new_time == NULL) {
		return (ENOMEM);
	}
	new_time->t_start = starttime;
	new_time->t_stop = stoptime;
	tmp = session->s_time;
	if (tmp == NULL)
		session->s_time = new_time;
	else {
		while (tmp->t_next != NULL)
			tmp = tmp->t_next;
		tmp->t_next = new_time;
	}
	if (time != NULL)
		*time = new_time;
	return (0);
}

/*
 * Adds repeat field to the time structure of session
 * r=<repeat interval> <active duration> <offsets from start-time>
 */
int
sdp_add_repeat(sdp_time_t *time, uint64_t interval, uint64_t duration,
    const char *offset)
{
	sdp_repeat_t		*tmp;
	sdp_repeat_t		*new_repeat;
	int			ret = 0;

	if (time == NULL || offset == NULL)
		return (EINVAL);
	new_repeat = calloc(1, sizeof (sdp_repeat_t));
	if (new_repeat == NULL)
		return (ENOMEM);
	new_repeat->r_interval = interval;
	new_repeat->r_duration = duration;
	if ((ret = sdp_str_to_list(&new_repeat->r_offset, offset,
	    strlen(offset), B_FALSE)) != 0) {
		goto err_ret;
	}
	tmp = time->t_repeat;
	if (tmp == NULL) {
		time->t_repeat = new_repeat;
	} else {
		while (tmp->r_next != NULL)
			tmp = tmp->r_next;
		tmp->r_next = new_repeat;
	}
	return (ret);
err_ret:
	sdp_free_repeat(new_repeat);
	return (ret);
}

/*
 * Adds time zone field to the session
 * z=<adjustment time> <offset> <adjustment time> <offset> ....
 */
int
sdp_add_zone(sdp_session_t *session, uint64_t time, const char *offset)
{
	sdp_zone_t		*new_zone;
	sdp_zone_t		*tmp;
	int			ret = 0;

	if (session == NULL || offset == NULL)
		return (EINVAL);
	new_zone = calloc(1, sizeof (sdp_zone_t));
	if (new_zone == NULL)
		return (ENOMEM);
	new_zone->z_time = time;
	if ((ret = commp_add_str(&new_zone->z_offset, offset,
	    strlen(offset))) != 0) {
		free(new_zone);
		return (ret);
	}
	tmp = session->s_zone;
	if (tmp == NULL) {
		session->s_zone = new_zone;
	} else {
		while (tmp->z_next != NULL) {
			tmp = tmp->z_next;
		}
		tmp->z_next = new_zone;
	}
	return (ret);
}

/*
 * Adds key field to session or media section of SDP.
 * k=<method>
 * k=<method>:<encryption key>
 */
int
sdp_add_key(sdp_key_t **key, const char *method, const char *enckey)
{
	int			ret = 0;

	if (key == NULL || method == NULL)
		return (EINVAL);
	if (*key != NULL)
		return (EPROTO);
	*key = calloc(1, sizeof (sdp_key_t));
	if (*key == NULL)
		return (ENOMEM);
	if ((ret = commp_add_str(&((*key)->k_method), method,
	    strlen(method))) != 0) {
		goto err_ret;
	}
	if (enckey != NULL) {
		if ((ret = commp_add_str(&((*key)->k_enckey), enckey,
		    strlen(enckey))) != 0) {
			goto err_ret;
		}
	}
	return (ret);
err_ret:
	sdp_free_key(*key);
	*key = NULL;
	return (ret);
}

/*
 * Adds attribute field to session or media section of SDP.
 * a=<attribute>
 * a=<attribute>:<value>
 */
int
sdp_add_attribute(sdp_attr_t **attr, const char *name, const char *value)
{
	sdp_attr_t		*tmp;
	sdp_attr_t		*new_attr;
	int			ret = 0;

	if (attr == NULL || name == NULL)
		return (EINVAL);
	new_attr = calloc(1, sizeof (sdp_attr_t));
	if (new_attr == NULL)
		return (ENOMEM);
	if ((ret = commp_add_str(&new_attr->a_name, name, strlen(name))) != 0)
		goto err_ret;
	if (value != NULL) {
		if ((ret = commp_add_str(&new_attr->a_value, value,
		    strlen(value))) != 0) {
			goto err_ret;
		}
	}
	tmp = *attr;
	if (tmp == NULL) {
		*attr = new_attr;
	} else {
		while (tmp->a_next != NULL)
			tmp = tmp->a_next;
		tmp->a_next = new_attr;
	}
	return (ret);
err_ret:
	sdp_free_attribute(new_attr);
	return (ret);
}

/*
 * Adds media field to the session.
 * m=<media> <port>[/portcount] <proto> <fmt> ...
 */
int
sdp_add_media(sdp_session_t *session, const char *name, uint_t port,
    int portcount, const char *protocol, const char *fmt, sdp_media_t **media)
{
	sdp_media_t		*tmp;
	sdp_media_t		*new_media;
	int			ret = 0;

	if (media != NULL)
		*media = NULL;
	if (session == NULL || name == NULL || protocol == NULL ||
	    portcount <= 0 || fmt == NULL) {
		return (EINVAL);
	}
	new_media = calloc(1, sizeof (sdp_media_t));
	if (new_media == NULL) {
		return (ENOMEM);
	}
	new_media->m_session = session;
	new_media->m_port = port;
	new_media->m_portcount = portcount;
	if ((ret = commp_add_str(&new_media->m_name, name, strlen(name))) != 0)
		goto err_ret;
	if ((ret = commp_add_str(&new_media->m_proto, protocol,
	    strlen(protocol))) != 0) {
		goto err_ret;
	}
	if ((ret = sdp_str_to_list(&new_media->m_format, fmt,
	    strlen(fmt), B_TRUE)) != 0) {
		goto err_ret;
	}
	tmp = session->s_media;
	if (tmp == NULL) {
		session->s_media = new_media;
	} else {
		while (tmp->m_next != NULL)
			tmp = tmp->m_next;
		tmp->m_next = new_media;
	}
	if (media != NULL)
		*media = new_media;
	return (0);
err_ret:
	sdp_free_media(new_media);
	return (ret);
}

/*
 * This internal API is required by sdp_session_to_str(). It determines the
 * length of buffer that is required to hold the session. Since the RFC does
 * not limit the size of various sub-fields in the field. We need to scan
 * through the structure to determine the length.
 */
int
sdp_get_length(const sdp_session_t *session)
{
	int			len = 0;
	char			buf[1];
	sdp_list_t		*list;
	sdp_conn_t		*conn;
	sdp_bandwidth_t		*bw;
	sdp_zone_t		*zone;
	sdp_time_t		*time;
	sdp_repeat_t		*repeat;
	sdp_attr_t		*attr;
	sdp_media_t		*media;

	len += FIELD_EQUALS_CRLF_LEN;
	len += snprintf(buf, 1, "%d", session->s_version);
	if (session->s_origin != NULL) {
		len += FIELD_EQUALS_CRLF_LEN;
		len += strlen(session->s_origin->o_username);
		len += snprintf(buf, 1, "%llu", session->s_origin->o_id) + 1;
		len += snprintf(buf, 1, "%llu", session->s_origin->o_version)
		    + 1;
		len += strlen(session->s_origin->o_nettype) + 1;
		len += strlen(session->s_origin->o_addrtype) + 1;
		len += strlen(session->s_origin->o_address) + 1;
	}
	if (session->s_name != NULL)
		len += strlen(session->s_name) + FIELD_EQUALS_CRLF_LEN;
	if (session->s_info != NULL)
		len += strlen(session->s_info) + FIELD_EQUALS_CRLF_LEN;
	if (session->s_uri != NULL)
		len += strlen(session->s_uri) + FIELD_EQUALS_CRLF_LEN;
	list = session->s_email;
	while (list != NULL) {
		len += strlen((char *)list->value) + FIELD_EQUALS_CRLF_LEN;
		list = list->next;
	}
	list = session->s_phone;
	while (list != NULL) {
		len += strlen((char *)list->value) + FIELD_EQUALS_CRLF_LEN;
		list = list->next;
	}
	conn = session->s_conn;
	SDP_LEN_CONNECTION(conn);
	bw = session->s_bw;
	SDP_LEN_BANDWIDTH(bw);
	time = session->s_time;
	while (time != NULL) {
		len += FIELD_EQUALS_CRLF_LEN;
		len += snprintf(buf, 1, "%llu", time->t_start);
		len += snprintf(buf, 1, "%llu", time->t_stop) + 1;
		repeat = time->t_repeat;
		while (repeat != NULL) {
			len += FIELD_EQUALS_CRLF_LEN;
			len += snprintf(buf, 1, "%llu", repeat->r_interval);
			len += snprintf(buf, 1, "%llu", repeat->r_duration) + 1;
			list = repeat->r_offset;
			while (list != NULL) {
				len += snprintf(buf, 1, "%llu",
				    *(uint64_t *)list->value) + 1;
				list = list->next;
			}
			repeat = repeat->r_next;
		}
		time = time->t_next;
	}
	if (session->s_zone != NULL)
		len += FIELD_EQUALS_CRLF_LEN;
	zone = session->s_zone;
	while (zone != NULL) {
		len += snprintf(buf, 1, "%llu", zone->z_time) + 1;
		len += strlen(zone->z_offset) + 1;
		zone = zone->z_next;
	}
	SDP_LEN_KEY(session->s_key);
	attr = session->s_attr;
	SDP_LEN_ATTRIBUTE(attr);
	media = session->s_media;
	while (media != NULL) {
		len += FIELD_EQUALS_CRLF_LEN;
		len += strlen(media->m_name);
		len += snprintf(buf, 1, "%u", media->m_port) + 1;
		len += snprintf(buf, 1, "%d", media->m_portcount) + 1;
		len += strlen(media->m_proto) + 1;
		list = media->m_format;
		while (list != NULL) {
			len += strlen((char *)list->value) + 1;
			list = list->next;
		}
		if (media->m_info != NULL)
			len += strlen(media->m_info) + FIELD_EQUALS_CRLF_LEN;
		conn = media->m_conn;
		SDP_LEN_CONNECTION(conn);
		bw = media->m_bw;
		SDP_LEN_BANDWIDTH(bw);
		SDP_LEN_KEY(media->m_key);
		attr = media->m_attr;
		SDP_LEN_ATTRIBUTE(attr);
		media = media->m_next;
	}
	return (len);
}

/*
 * Given a session structure it clones (deep copy) and returns the cloned copy
 */
sdp_session_t *
sdp_clone_session(const sdp_session_t *session)
{
	sdp_session_t		*new_sess;
	sdp_origin_t		*origin;
	sdp_list_t		*list;
	sdp_time_t		*time;
	sdp_time_t		*new_time;
	sdp_repeat_t		*repeat;
	sdp_media_t		*media;
	sdp_media_t		*new_media;
	sdp_conn_t		*conn;
	sdp_bandwidth_t		*bw;
	sdp_attr_t		*attr;
	sdp_zone_t		*zone;
	char			*offset = NULL;
	char			*format = NULL;

	if (session == NULL)
		return (NULL);
	new_sess = calloc(1, sizeof (sdp_session_t));
	if (new_sess == NULL)
		return (NULL);
	new_sess->sdp_session_version = session->sdp_session_version;
	new_sess->s_version = session->s_version;
	origin = session->s_origin;
	if (origin != NULL && (sdp_add_origin(new_sess, origin->o_username,
	    origin->o_id, origin->o_version, origin->o_nettype, origin->
	    o_addrtype, origin->o_address) != 0)) {
		goto err_ret;
	}
	if (session->s_name != NULL && sdp_add_name(new_sess, session->
	    s_name) != 0) {
		goto err_ret;
	}
	if (session->s_info != NULL && sdp_add_information(&new_sess->
	    s_info, session->s_info) != 0) {
		goto err_ret;
	}
	if (session->s_uri != NULL && sdp_add_uri(new_sess, session->
	    s_uri) != 0) {
		goto err_ret;
	}
	list = session->s_email;
	while (list != NULL) {
		if (sdp_add_email(new_sess, (char *)list->value) != 0)
			goto err_ret;
		list = list->next;
	}
	list = session->s_phone;
	while (list != NULL) {
		if (sdp_add_phone(new_sess, (char *)list->value) != 0)
			goto err_ret;
		list = list->next;
	}
	conn = session->s_conn;
	SDP_ADD_CONNECTION(new_sess->s_conn, conn);
	bw = session->s_bw;
	SDP_ADD_BANDWIDTH(new_sess->s_bw, bw);
	time = session->s_time;
	while (time != NULL) {
		if (sdp_add_time(new_sess, time->t_start, time->t_stop,
		    &new_time) != 0) {
			goto err_ret;
		}
		repeat = time->t_repeat;
		while (repeat != NULL) {
			if (sdp_list_to_str(repeat->r_offset, &offset,
			    B_FALSE) != 0) {
				goto err_ret;
			}
			if (sdp_add_repeat(new_time, repeat->r_interval,
			    repeat->r_duration, offset) != 0) {
				free(offset);
				goto err_ret;
			}
			free(offset);
			repeat = repeat->r_next;
		}
		time = time->t_next;
	}
	zone = session->s_zone;
	while (zone != NULL) {
		if (sdp_add_zone(new_sess, zone->z_time, zone->z_offset) != 0)
			goto err_ret;
		zone = zone->z_next;
	}
	SDP_ADD_KEY(new_sess->s_key, session->s_key);
	attr = session->s_attr;
	SDP_ADD_ATTRIBUTE(new_sess->s_attr, attr);
	media = session->s_media;
	while (media != NULL) {
		if (sdp_list_to_str(media->m_format, &format, B_TRUE) != 0)
			goto err_ret;
		if (sdp_add_media(new_sess, media->m_name,
		    media->m_port, media->m_portcount, media->m_proto,
		    format, &new_media) != 0) {
			free(format);
			goto err_ret;
		}
		free(format);
		if (media->m_info != NULL) {
			if (sdp_add_information(&new_media->m_info,
			    media->m_info) != 0) {
				goto err_ret;
			}
		}
		conn = media->m_conn;
		SDP_ADD_CONNECTION(new_media->m_conn, conn);
		bw = media->m_bw;
		SDP_ADD_BANDWIDTH(new_media->m_bw, bw);
		SDP_ADD_KEY(new_media->m_key, media->m_key);
		attr = media->m_attr;
		SDP_ADD_ATTRIBUTE(new_media->m_attr, attr);
		new_media->m_session = new_sess;
		media = media->m_next;
	}
	return (new_sess);
err_ret:
	sdp_free_session(new_sess);
	return (NULL);
}

/*
 * should i check if individual members are NULL, if not snprintf
 * will core dump.
 */
/*
 * Given a session structure, this API converts it into character
 * buffer, which will be used as a payload later on.
 */
char *
sdp_session_to_str(const sdp_session_t *session, int *error)
{
	char			*ret = NULL;
	char			*buf = NULL;
	int			len = 0;
	int			s_len = 0;
	int			wrote = 0;
	sdp_origin_t		*origin;
	sdp_list_t		*list;
	sdp_conn_t		*conn;
	sdp_attr_t		*attr;
	sdp_bandwidth_t		*bw;
	sdp_time_t		*time;
	sdp_repeat_t		*repeat;
	sdp_zone_t		*zone;
	sdp_media_t		*media;

	if (error != NULL)
		*error = 0;
	if (session == NULL) {
		if (error != NULL)
			*error = EINVAL;
		return (NULL);
	}
	s_len = sdp_get_length(session);
	ret = malloc(s_len + 1);
	if (ret == NULL) {
		if (error != NULL)
			*error = ENOMEM;
		return (NULL);
	}
	buf = ret;
	len = s_len + 1;
	wrote = snprintf(buf, len, "v=%d%s", session->s_version, COMMP_CRLF);
	len = len - wrote;
	buf = buf + wrote;
	origin = session->s_origin;
	if (origin != NULL) {
		wrote = snprintf(buf, len, "o=%s %llu %llu %s %s %s%s",
		    origin->o_username, origin->o_id, origin->o_version,
		    origin->o_nettype, origin->o_addrtype, origin->o_address,
		    COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
	}
	if (session->s_name != NULL) {
		wrote = snprintf(buf, len, "s=%s%s", session->s_name,
		    COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
	}
	SDP_INFORMATION_TO_STR(session->s_info);
	if (session->s_uri != NULL) {
		wrote = snprintf(buf, len, "u=%s%s", session->s_uri,
		    COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
	}
	list = session->s_email;
	while (list != NULL) {
		wrote = snprintf(buf, len, "e=%s%s", (char *)list->value,
		    COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
		list = list->next;
	}
	list = session->s_phone;
	while (list != NULL) {
		wrote = snprintf(buf, len, "p=%s%s", (char *)list->value,
		    COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
		list = list->next;
	}
	conn = session->s_conn;
	SDP_CONNECTION_TO_STR(conn);
	bw = session->s_bw;
	SDP_BANDWIDTH_TO_STR(bw);
	time = session->s_time;
	while (time != NULL) {
		wrote = snprintf(buf, len, "t=%llu %llu%s", time->t_start,
		    time->t_stop, COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
		repeat = time->t_repeat;
		while (repeat != NULL) {
			wrote = snprintf(buf, len, "r=%llu %llu", repeat->
			    r_interval, repeat->r_duration);
			len = len - wrote;
			buf = buf + wrote;
			list = repeat->r_offset;
			while (list != NULL) {
				wrote = snprintf(buf, len, " %llu",
				    *(uint64_t *)list->value);
				len = len - wrote;
				buf = buf + wrote;
				list = list->next;
			}
			wrote = snprintf(buf, len, "%s", COMMP_CRLF);
			len = len - wrote;
			buf = buf + wrote;
			repeat = repeat->r_next;
		}
		time = time->t_next;
	}
	zone = session->s_zone;
	if (zone != NULL) {
		wrote = snprintf(buf, len, "z=%llu %s", zone->z_time,
		    zone->z_offset);
		len = len - wrote;
		buf = buf + wrote;
		zone = zone->z_next;
		while (zone != NULL) {
			wrote = snprintf(buf, len, " %llu %s", zone->z_time,
			    zone->z_offset);
			len = len - wrote;
			buf = buf + wrote;
			zone = zone->z_next;
		}
		wrote = snprintf(buf, len, "%s", COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
	}
	SDP_KEY_TO_STR(session->s_key);
	attr = session->s_attr;
	SDP_ATTR_TO_STR(attr);
	media = session->s_media;
	while (media != NULL) {
		if (media->m_portcount == 1) {
			wrote = snprintf(buf, len, "m=%s %d %s", media->m_name,
			    media->m_port, media->m_proto);
		} else {
			wrote = snprintf(buf, len, "m=%s %d/%d %s", media->
			    m_name, media->m_port, media->m_portcount, media->
			    m_proto);
		}
		len = len - wrote;
		buf = buf + wrote;
		list = media->m_format;
		while (list != NULL) {
			wrote = snprintf(buf, len, " %s", (char *)list->value);
			len = len - wrote;
			buf = buf + wrote;
			list = list->next;
		}
		wrote = snprintf(buf, len, "%s", COMMP_CRLF);
		len = len - wrote;
		buf = buf + wrote;
		SDP_INFORMATION_TO_STR(media->m_info);
		conn = media->m_conn;
		SDP_CONNECTION_TO_STR(conn);
		bw = media->m_bw;
		SDP_BANDWIDTH_TO_STR(bw);
		SDP_KEY_TO_STR(media->m_key);
		attr = media->m_attr;
		SDP_ATTR_TO_STR(attr);
		media = media->m_next;
	}
	assert(len >= 1);
	*buf = '\0';
	return (ret);
}

/*
 * Given a session structure and the field ('v', 'o', 's', et al), this API
 * deletes the corresponding structure element. It frees the memory and sets the
 * pointer to NULL
 */
int
sdp_delete_all_field(sdp_session_t *session, const char field)
{
	if (session == NULL)
		return (EINVAL);
	switch (field) {
		case SDP_ORIGIN_FIELD:
			sdp_free_origin(session->s_origin);
			session->s_origin = NULL;
			break;
		case SDP_NAME_FIELD:
			free(session->s_name);
			session->s_name = NULL;
			break;
		case SDP_INFO_FIELD:
			free(session->s_info);
			session->s_info = NULL;
			break;
		case SDP_URI_FIELD:
			free(session->s_uri);
			session->s_uri = NULL;
			break;
		case SDP_EMAIL_FIELD:
			sdp_free_list(session->s_email);
			session->s_email = NULL;
			break;
		case SDP_PHONE_FIELD:
			sdp_free_list(session->s_phone);
			session->s_phone = NULL;
			break;
		case SDP_CONNECTION_FIELD:
			sdp_free_connection(session->s_conn);
			session->s_conn = NULL;
			break;
		case SDP_BANDWIDTH_FIELD:
			sdp_free_bandwidth(session->s_bw);
			session->s_bw = NULL;
			break;
		case SDP_TIME_FIELD:
			sdp_free_time(session->s_time);
			session->s_time = NULL;
			break;
		case SDP_ZONE_FIELD:
			sdp_free_zone(session->s_zone);
			session->s_zone = NULL;
			break;
		case SDP_KEY_FIELD:
			sdp_free_key(session->s_key);
			session->s_key = NULL;
			break;
		case SDP_ATTRIBUTE_FIELD:
			sdp_free_attribute(session->s_attr);
			session->s_attr = NULL;
			break;
		case SDP_MEDIA_FIELD:
			sdp_free_media(session->s_media);
			session->s_media = NULL;
			break;
		default:
			return (EINVAL);
	}
	return (0);
}

/*
 * Given a media structure and the field ('i', 'b', 'c', et al), this API
 * deletes the corresponding structure element. It frees the memory and sets
 * the pointer to NULL.
 */
int
sdp_delete_all_media_field(sdp_media_t *media, const char field)
{
	if (media == NULL)
		return (EINVAL);
	switch (field) {
		case SDP_INFO_FIELD:
			free(media->m_info);
			media->m_info = NULL;
			break;
		case SDP_CONNECTION_FIELD:
			sdp_free_connection(media->m_conn);
			media->m_conn = NULL;
			break;
		case SDP_BANDWIDTH_FIELD:
			sdp_free_bandwidth(media->m_bw);
			media->m_bw = NULL;
			break;
		case SDP_KEY_FIELD:
			sdp_free_key(media->m_key);
			media->m_key = NULL;
			break;
		case SDP_ATTRIBUTE_FIELD:
			sdp_free_attribute(media->m_attr);
			media->m_attr = NULL;
			break;
		default:
			return (EINVAL);
	}
	return (0);
}

/*
 * Given a media list and the media, this API deletes that media from the
 * list. It frees the memory corresponding to that media.
 */
int
sdp_delete_media(sdp_media_t **l_media, sdp_media_t *media)
{
	sdp_media_t		*cur;
	sdp_media_t		*prev;

	if (l_media == NULL || *l_media == NULL || media == NULL)
		return (EINVAL);
	cur = *l_media;
	prev = NULL;
	while (cur != NULL && cur != media) {
		prev = cur;
		cur = cur->m_next;
	}
	if (cur == NULL)
		return (EINVAL);
	if (cur == *l_media)
		*l_media = cur->m_next;
	else
		prev->m_next = cur->m_next;
	cur->m_next = NULL;
	sdp_free_media(cur);
	return (0);
}

/*
 * Given an attribute list and an attribute, this API deletes that attribue
 * from the list. It frees the memory corresponding to that attribute.
 */
int
sdp_delete_attribute(sdp_attr_t **l_attr, sdp_attr_t *attr)
{
	sdp_attr_t		*cur;
	sdp_attr_t		*prev;

	if (l_attr == NULL || *l_attr == NULL || attr == NULL)
		return (EINVAL);
	cur = *l_attr;
	prev = NULL;
	while (cur != NULL && cur != attr) {
		prev = cur;
		cur = cur->a_next;
	}
	if (cur == NULL)
		return (EINVAL);
	if (cur == *l_attr)
		*l_attr = cur->a_next;
	else
		prev->a_next = cur->a_next;
	cur->a_next = NULL;
	sdp_free_attribute(cur);
	return (0);
}

/*
 * Allocates a new sdp session structure and assigns a version number to it.
 * Currently one version is defined and it is 1. This will be useful in future
 * in the unlikely need to change the structure.
 */
sdp_session_t *
sdp_new_session()
{
	sdp_session_t	*session = NULL;

	session = calloc(1, sizeof (sdp_session_t));
	if (session != NULL)
		session->sdp_session_version = SDP_SESSION_VERSION_1;
	return (session);
}