libcommputil/common/sdp.c

/*
 * 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.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * 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);
}