libcommputil/common/sdp_parse.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"

/*
 * Parses the SDP description as per the SDP grammar defined in Section 9 of
 * RFC 4566
 */

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

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

/*
 * proto-version-field (v=)
 * %x76 "=" 1*DIGIT CRLF
 */
static void
sdp_parse_version(int *version, const char *begin, const char *end,
    uint_t *p_error)
{
    if (*begin++ != COMMP_EQUALS || commp_atoi(begin, end, version) != 0)
        *p_error |= SDP_VERSION_ERROR;
}

/*
 * session-name-field (s=)
 * %x73 "=" text CRLF
 * text = byte-string
 * byte-string = 1*(%x01-09/%x0B-0C/%x0E-FF)
 *               ;any byte except NUL, CR, or LF
 */
static void
sdp_parse_name(char **name, const char *begin, const char *end,
    uint_t *p_error)
{
    int len;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_NAME_ERROR;
        return;
    }
    /* there can be only one name field */
    if (*name != NULL)
        return;
    len = end - begin;
    if (len < 1) {
        *p_error |= SDP_NAME_ERROR;
    } else {
        COMMP_COPY_STR(*name, begin, len);
        if (*name == NULL) {
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
}

/*
 * information-field (i=)
 * [%x69 "=" text CRLF]
 * text = byte-string
 * byte-string = 1*(%x01-09/%x0B-0C/%x0E-FF)
 *          any byte except NUL, CR, or LF
 */
static void
sdp_parse_info(char **info, const char *begin, const char *end,
    uint_t *p_error)
{
    int     len;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_INFO_ERROR;
        return;
    }
    /* There can be only one info field */
    if (*info != NULL)
        return;
    len = end - begin;
    if (len < 1) {
        *p_error |= SDP_INFO_ERROR;
    } else {
        COMMP_COPY_STR(*info, begin, len);
        if (*info == NULL) {
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
}

/*
 * uri-field (u=)
 * [%x75 "=" uri CRLF]
 * anything between "=" and "CRLF" is considered to be URI.
 */
static void
sdp_parse_uri(char **uri, const char *begin, const char *end, uint_t *p_error)
{
    int     len;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_URI_ERROR;
        return;
    }
    /* There can be only one uri field */
    if (*uri != NULL)
        return;
    len = end - begin;
    if (len < 1 || isspace(*begin) || isspace (*(end - 1))) {
        *p_error |= SDP_URI_ERROR;
    } else {
        COMMP_COPY_STR(*uri, begin, len);
        if (*uri == NULL) {
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
}

/*
 * phone-fields (p=)
 * *(%x70 "=" phone-number CRLF)
 * anything between "=" and "CRLF" is considered to be phone-number
 */
static void
sdp_parse_phone(sdp_list_t **phone, const char *begin, const char *end,
    uint_t *p_error)
{
    int         len;
    sdp_list_t  *new_phone = NULL;
    sdp_list_t  *tmp = NULL;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_PHONE_ERROR;
        return;
    }
    len = end - begin;
    if (len < 1 || isspace(*begin) || isspace(*(end - 1))) {
        *p_error |= SDP_PHONE_ERROR;
    } else {
        new_phone = calloc(1, sizeof (sdp_list_t));
        if (new_phone == NULL) {
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
        COMMP_COPY_STR(new_phone->value, begin, len);
        if (new_phone->value == NULL) {
            free(new_phone);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
        if (*phone == NULL) {
            *phone = new_phone;
        } else {
            tmp = *phone;
            while (tmp->next != NULL)
                tmp = tmp->next;
            tmp->next = new_phone;
        }
    }
}

/*
 * email-fields (e=)
 * *(%x65 "=" email-address CRLF)
 * anything between "=" and "CRLF" is considered to be email-address
 */
static void
sdp_parse_email(sdp_list_t **email, const char *begin, const char *end,
    uint_t *p_error)
{
    int         len;
    sdp_list_t  *new_email = NULL;
    sdp_list_t  *tmp = NULL;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_EMAIL_ERROR;
        return;
    }
    len = end - begin;
    if (len < 1 || isspace(*begin) || isspace(*(end - 1))) {
        *p_error |= SDP_EMAIL_ERROR;
    } else {
        new_email = calloc(1, sizeof (sdp_list_t));
        if (new_email == NULL) {
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
        COMMP_COPY_STR(new_email->value, begin, len);
        if (new_email->value == NULL) {
            free(new_email);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
        if (*email == NULL) {
            *email = new_email;
        } else {
            tmp = *email;
            while (tmp->next != NULL)
                tmp = tmp->next;
            tmp->next = new_email;
        }
    }
}

/*
 * origin-field (o=)
 * %x6f "=" username SP sess-id SP sess-version SP nettype SP addrtype SP
 * unicast-address CRLF
 *
 * username = non-ws-string
 * sess-id = 1*DIGIT
 * sess-version = 1*DIGIT
 * nettype = token
 * addrtype = token
 * token = 1*(token-char)
 * token-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39 / %x41-5A / %x5E-7E
 * i.e. no space in token-char
 */
static void
sdp_parse_origin(sdp_origin_t **origin, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current = NULL;
    sdp_origin_t    *new_origin = NULL;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_ORIGIN_ERROR;
        return;
    }
    /* There can be only one origin field */
    if (*origin != NULL)
        return;
    new_origin = calloc(1, sizeof (sdp_origin_t));
    if (new_origin == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    /* Get username */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_origin->o_username, begin, current - begin);
        if (new_origin->o_username == NULL) {
            sdp_free_origin(new_origin);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    /* Get Session-ID */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0)
        goto err_ret;
    if (commp_strtoull(begin, current, &new_origin->o_id) != 0)
        goto err_ret;
    /* Get Version */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0)
        goto err_ret;
    if (commp_strtoull(begin, current, &new_origin->o_version) != 0)
        goto err_ret;
    /* Get nettype */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_origin->o_nettype, begin, current - begin);
        if (new_origin->o_nettype == NULL) {
            sdp_free_origin(new_origin);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    /* Get addrtype */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_origin->o_addrtype, begin, current - begin);
        if (new_origin->o_addrtype == NULL) {
            sdp_free_origin(new_origin);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    /* Get address. Its the last sub-field */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_TRUE) != 0)
        goto err_ret;
    COMMP_COPY_STR(new_origin->o_address, begin, current - begin);
    if (new_origin->o_address == NULL) {
        sdp_free_origin(new_origin);
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    *origin = new_origin;
    return;
err_ret:
    *p_error |= SDP_ORIGIN_ERROR;
    sdp_free_origin(new_origin);
}

/*
 * time-fields (t=)
 * 1*( %x74 "=" start-time SP stop-time CRLF)
 * start-time = time / "0"
 * stop-time = time / "0"
 * time = POS-DIGIT 9*DIGIT
 * POS-DIGIT = %x31-39 ; 1 - 9
 */
static sdp_time_t *
sdp_parse_time(sdp_time_t **time, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    sdp_time_t  *new_time;
    sdp_time_t  *tmp;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_TIME_ERROR;
        return (NULL);
    }
    new_time = calloc(1, sizeof (sdp_time_t));
    if (new_time == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return (NULL);
    }
    /* Get start-time */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0)
        goto err_ret;
    if (commp_strtoull(begin, current, &new_time->t_start) != 0)
        goto err_ret;
    /* Get stop-time */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_TRUE) != 0)
        goto err_ret;
    if (commp_strtoull(begin, current, &new_time->t_stop) != 0)
        goto err_ret;
    /* Now assign time to session structure */
    if (*time == NULL) {
        *time = new_time;
    } else {
        tmp = *time;
        while (tmp->t_next != NULL)
            tmp = tmp->t_next;
        tmp->t_next = new_time;
    }
    return (new_time);
err_ret:
    *p_error |= SDP_TIME_ERROR;
    sdp_free_time(new_time);
    return (NULL);
}

/*
 * connection-field (c=)
 * [%x63 "=" nettype SP addrtype SP connection-address CRLF]
 * nettype = token
 * addrtype = token
 * connection-address =  multicast-address / unicast-address
 * here, connection-address is parsed as a string.
 */
static void
sdp_parse_connection(sdp_conn_t **conn, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    const char  *t_begin;
    const char  *t_current;
    sdp_conn_t  *new_conn;
    sdp_conn_t  *tmp;
    boolean_t   is_IP4 = B_FALSE;
    boolean_t   is_IP6 = B_FALSE;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_CONNECTION_ERROR;
        return;
    }
    new_conn = calloc(1, sizeof (sdp_conn_t));
    if (new_conn == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    /* Get NetworkType */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_conn->c_nettype, begin, current - begin);
        if (new_conn->c_nettype == NULL) {
            sdp_free_connection(new_conn);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    /* Get AddressType */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_conn->c_addrtype, begin, current - begin);
        if (new_conn->c_addrtype == NULL) {
            sdp_free_connection(new_conn);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    if ((strlen(COMMP_ADDRTYPE_IP4) == strlen(new_conn->c_addrtype)) &&
        (strncasecmp(new_conn->c_addrtype, COMMP_ADDRTYPE_IP4,
        strlen(COMMP_ADDRTYPE_IP4)) == 0)) {
        is_IP4 = B_TRUE;
    } else if ((strlen(COMMP_ADDRTYPE_IP6) == strlen(new_conn->
        c_addrtype)) && (strncasecmp(new_conn->c_addrtype,
        COMMP_ADDRTYPE_IP6, strlen(COMMP_ADDRTYPE_IP6)) == 0)) {
        is_IP6 = B_TRUE;
    }
    /* Get Address. Parsing depends if its IP4,IP6 or something else */
    begin = ++current;
    if (!is_IP4 && !is_IP6) {
        if (commp_find_token(&begin, &current, end, COMMP_SP,
            B_TRUE) != 0) {
            goto err_ret;
        }
    } else {
        if (commp_find_token(&begin, &current, end, COMMP_SLASH,
            B_FALSE) != 0) {
            goto err_ret;
        }
        if (current != end) {
            /* SLASH is present. Needs further parsing */
            t_current = current;
            t_begin = ++t_current;
            if (commp_find_token(&t_begin, &t_current, end,
                COMMP_SLASH, B_FALSE) != 0) {
                goto err_ret;
            }
            if (t_current != end) {
                /*
                 * Another SLASH present. If is_IP4 true then
                 * this is Address count. If is_IP6 true then
                 * incorrect field as per RFC.
                 */
                if (is_IP6) {
                    goto err_ret;
                } else {
                    if (commp_atoi((t_current + 1), end,
                        &new_conn->c_addrcount) != 0) {
                        goto err_ret;
                    }
                }
            }
            if (is_IP6) {
                if (commp_atoi((current + 1), t_current,
                    &new_conn->c_addrcount) != 0) {
                    goto err_ret;
                }
            } else {
                if (commp_strtoub((current + 1), t_current,
                    &new_conn->c_ttl) != 0) {
                    goto err_ret;
                }
                if (new_conn->c_addrcount == 0)
                    new_conn->c_addrcount = 1;
            }
        }
    }
    COMMP_COPY_STR(new_conn->c_address, begin, current - begin);
    if (new_conn->c_address == NULL) {
        sdp_free_connection(new_conn);
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    if (*conn == NULL) {
        *conn = new_conn;
    } else {
        tmp = *conn;
        while (tmp->c_next != NULL)
            tmp = tmp->c_next;
        tmp->c_next = new_conn;
    }
    return;
err_ret:
    *p_error |= SDP_CONNECTION_ERROR;
    sdp_free_connection(new_conn);
}

/*
 * bandwidth-fields (b=)
 * *(%x62 "=" bwtype ":" bandwidth CRLF)
 * bwtype = token
 * bandwidth = 1*DIGIT
 */
static void
sdp_parse_bandwidth(sdp_bandwidth_t **bw, const char *begin, const char *end,
    uint_t *p_error)
{
    const char      *current;
    sdp_bandwidth_t     *new_bw = NULL;
    sdp_bandwidth_t     *tmp = NULL;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_BANDWIDTH_ERROR;
        return;
    }
    new_bw = calloc(1, sizeof (sdp_bandwidth_t));
    if (new_bw == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_COLON,
        B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_bw->b_type, begin, current - begin);
        if (new_bw->b_type == NULL) {
            sdp_free_bandwidth(new_bw);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    if (current == end)
        goto err_ret;
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_TRUE) != 0)
        goto err_ret;
    if (commp_strtoull(begin, current, &new_bw->b_value) != 0)
        goto err_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;
err_ret:
    *p_error |= SDP_BANDWIDTH_ERROR;
    sdp_free_bandwidth(new_bw);
}

/*
 * repeat-fields (r=)
 * Not stand-alone. One or more repeat field appear after time field.
 * %x72 "=" repeat-interval SP typed-time 1*(SP typed-time)
 * repeat-interval = POS-DIGIT *DIGIT [fixed-len-time-unit]
 * typed-time = 1*DIGIT [fixed-len-time-unit]
 * fixed-len-time-unit = %x64 / %x68 / %x6d / %x73
 */
static void
sdp_parse_repeat(sdp_time_t *time, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    sdp_repeat_t    *repeat;
    sdp_repeat_t    *new_repeat;
    int     ret;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_REPEAT_TIME_ERROR;
        return;
    }
    /*
     * A time field should be present before this field can occur, if
     * time is NULL then repeat field has occured before time field and
     * hence fields are out of order.
     */
    if (time == NULL)
        return;
    /*
     * Get the latest time field and associate this repeat field
     * with it.
     */
    while (time->t_next != NULL)
        time = time->t_next;
    new_repeat = calloc(1, sizeof (sdp_repeat_t));
    if (new_repeat == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    /*
     * for a given time field, there could be several repeat fields
     * add the new repeat field at the end of it.
     */
    repeat = time->t_repeat;
    if (repeat == NULL) {
        time->t_repeat = new_repeat;
    } else {
        while (repeat->r_next != NULL)
            repeat = repeat->r_next;
        repeat->r_next = new_repeat;
    }
    /*
     * Populate the elements of sdp_repeat.
     * Get time-interval
     */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0)
        goto err_ret;
    if (commp_time_to_secs(begin, current, &new_repeat->r_interval) != 0)
        goto err_ret;
    /* Get duration. It could be the last sub-field */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0)
        goto err_ret;
    if (commp_time_to_secs(begin, current, &new_repeat->r_duration) != 0)
        goto err_ret;
    ++current;
    /* Get offsets into sdp_list */
    if (current >= end)
        goto err_ret;
    while (current < end) {
        begin = current;
        if (commp_find_token(&begin, &current, end, COMMP_SP,
            B_FALSE) != 0) {
            goto err_ret;
        }
        if ((ret = add_value_to_list(&new_repeat->r_offset, begin,
            current - begin, B_FALSE)) != 0) {
            if (ret == ENOMEM) {
                *p_error |= SDP_MEMORY_ERROR;
                return;
            } else {
                goto err_ret;
            }
        }
        ++current;
    }
    /* check for trailing white space character. */
    if (isspace(*(end - 1)))
        goto err_ret;
    return;
err_ret:
    *p_error |= SDP_REPEAT_TIME_ERROR;
    if (repeat != NULL)
        repeat->r_next = NULL;
    else
        time->t_repeat = NULL;
    sdp_free_repeat(new_repeat);
}

/*
 * zone-adjustments (z=)
 * %x7a "=" time SP ["-"] typed-time *(SP time SP ["-"] typed-time)
 */
static void
sdp_parse_zone(sdp_zone_t **zone, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    sdp_zone_t  *new_zone = NULL;
    sdp_zone_t  *tmp = NULL;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_ZONE_ERROR;
        return;
    }
    /* There can be atmost one zone field. */
    if (*zone != NULL)
        return;
    /* Get time and offset */
    current = begin;
    while (current < end) {
        new_zone = calloc(1, sizeof (sdp_zone_t));
        if (new_zone == NULL) {
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
        if (*zone == NULL) {
            *zone = new_zone;
            tmp = *zone;
        } else {
            tmp->z_next = new_zone;
            tmp = new_zone;
        }
        begin = current;
        if (commp_find_token(&begin, &current, end, COMMP_SP,
            B_FALSE) != 0) {
            goto err_ret;
        }
        if (commp_strtoull(begin, current, &new_zone->z_time) != 0)
            goto err_ret;
        begin = ++current;
        if (commp_find_token(&begin, &current, end, COMMP_SP,
            B_FALSE) != 0) {
            goto err_ret;
        } else {
            COMMP_COPY_STR(new_zone->z_offset, begin, current -
                begin);
            if (new_zone->z_offset == NULL) {
                *p_error |= SDP_MEMORY_ERROR;
                return;
            }

        }
        ++current;
    }
    if (isspace(*(end - 1)))
        goto err_ret;
    return;
err_ret:
    *p_error |= SDP_ZONE_ERROR;
    sdp_free_zone(*zone);
    *zone = NULL;
}

/*
 * key-field (k=)
 * [%x6b "=" key-type CRLF]
 * key-type = %x70 %x72 %x6f %x6d %x70 %x74 /     ; "prompt"
 *            %x63 %x6c %x65 %x61 %x72 ":" text / ; "clear:"
 *            %x62 %x61 %x73 %x65 "64:" base64 /  ; "base64:"
 *            %x75 %x72 %x69 ":" uri              ; "uri:"
 */
static void
sdp_parse_key(sdp_key_t **key, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    sdp_key_t   *new_key;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_KEY_ERROR;
        return;
    }
    /* There can be only one key field */
    if (*key != NULL)
        return;
    new_key = calloc(1, sizeof (sdp_key_t));
    if (new_key == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    /* Get Method name */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_COLON,
        B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_key->k_method, begin, current - begin);
        if (new_key->k_method == NULL) {
            sdp_free_key(new_key);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    /* Get key, if exists. */
    if (*current == COMMP_COLON) {
        ++current;
        if (current == end)
            goto err_ret;
        COMMP_COPY_STR(new_key->k_enckey, current, end - current);
        if (new_key->k_enckey == NULL) {
            sdp_free_key(new_key);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    *key = new_key;
    return;
err_ret:
    *p_error |= SDP_KEY_ERROR;
    sdp_free_key(new_key);
}

/*
 * attribute-fields (a=)
 * *(%x61 "=" attribute CRLF)
 * attribute = (att-field ":" att-value) / att-field
 * att-field = token
 * att-value = byte-string
 */
static void
sdp_parse_attribute(sdp_attr_t **attr, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    sdp_attr_t  *new_attr;
    sdp_attr_t  *tmp;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_ATTRIBUTE_ERROR;
        return;
    }
    new_attr = calloc(1, sizeof (sdp_attr_t));
    if (new_attr == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return;
    }
    /* Get Attribute Name */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_COLON,
        B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_attr->a_name, begin, current - begin);
        if (new_attr->a_name == NULL) {
            sdp_free_attribute(new_attr);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    /* Get Attribute Value */
    if (*current == COMMP_COLON) {
        ++current;
        if (current == end)
            goto err_ret;
        COMMP_COPY_STR(new_attr->a_value, current, end - current);
        if (new_attr->a_value == NULL) {
            sdp_free_attribute(new_attr);
            *p_error |= SDP_MEMORY_ERROR;
            return;
        }
    }
    if (*attr == NULL) {
        *attr = new_attr;
    } else {
        tmp = *attr;
        while (tmp->a_next != NULL)
            tmp = tmp->a_next;
        tmp->a_next = new_attr;
    }
    return;
err_ret:
    *p_error |= SDP_ATTRIBUTE_ERROR;
    sdp_free_attribute(new_attr);
}

/*
 * media-field (m=)
 * %x6d "=" media SP port ["/" integer] SP proto 1*(SP fmt) CRLF
 */
static sdp_media_t *
sdp_parse_media(sdp_session_t *session, const char *begin, const char *end,
    uint_t *p_error)
{
    const char  *current;
    const char  *fake_end;
    sdp_media_t *new_media;
    sdp_media_t *tmp;

    if (*begin++ != COMMP_EQUALS) {
        *p_error |= SDP_MEDIA_ERROR;
        return (NULL);
    }

    new_media = calloc(1, sizeof (sdp_media_t));
    if (new_media == NULL) {
        *p_error |= SDP_MEMORY_ERROR;
        return (NULL);
    }
    new_media->m_session = session;
    /* Get media name */
    current = begin;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_media->m_name, begin, current - begin);
        if (new_media->m_name == NULL) {
            sdp_free_media(new_media);
            *p_error |= SDP_MEMORY_ERROR;
            return (NULL);
        }
    }
    /* Get port */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0)
        goto err_ret;
    fake_end = current;
    current = begin;
    if (commp_find_token(&begin, &current, fake_end, COMMP_SLASH,
        B_FALSE) != 0) {
        goto err_ret;
    }
    if (commp_atoui(begin, current, &new_media->m_port) != 0)
        goto err_ret;
    /* Get portcount */
    if (*current == COMMP_SLASH) {
        begin = ++current;
        if (commp_find_token(&begin, &current, fake_end, COMMP_SP,
            B_FALSE) != 0) {
            goto err_ret;
        }
        if (commp_atoi(begin, current, &new_media->m_portcount) != 0)
            goto err_ret;
    } else {
        new_media->m_portcount = 1;
    }
    /* Get Protocol */
    begin = ++current;
    if (commp_find_token(&begin, &current, end, COMMP_SP, B_FALSE) != 0) {
        goto err_ret;
    } else {
        COMMP_COPY_STR(new_media->m_proto, begin, current - begin);
        if (new_media->m_proto == NULL) {
            sdp_free_media(new_media);
            *p_error |= SDP_MEMORY_ERROR;
            return (NULL);
        }
    }
    ++current;
    /* Get format list */
    if (current >= end)
        goto err_ret;
    while (current < end) {
        begin = current;
        if (commp_find_token(&begin, &current, end, COMMP_SP,
            B_FALSE) != 0) {
            goto err_ret;
        }
        if (add_value_to_list(&new_media->m_format, begin,
            current - begin, B_TRUE) != 0) {
            sdp_free_media(new_media);
            *p_error |= SDP_MEMORY_ERROR;
            return (NULL);
        }
        ++current;
    }
    /* check for trailing white space character. */
    if (isspace(*(end - 1)))
        goto err_ret;
    /* Assign new media to the media list */
    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;
    }
    return (new_media);
err_ret:
    *p_error |= SDP_MEDIA_ERROR;
    sdp_free_media(new_media);
    return (NULL);
}

/*
 * This function ensures that a field is in the right order in SDP descripton.
 * It also identifies cases where a field ('v', 'o, 'i', et al) that must occur
 * once but occurs several times in SDP description. error cannot be NULL.
 */
static void
sdp_check_order(char prev, char *order, int *error)
{
    *error = 0;
    while (*order != '\0') {
        if (*order++ == prev)
            return;
    }
    *error = 1;
}

/*
 * This function determines the SDP field and calls the appropriate parse
 * function. It also ensures that the SDP fields are in strict order.
 */
static void
sdp_handle_fields(sdp_description_t *description, sdp_session_t *_session,
    const char *begin, const char *end)
{
    boolean_t   u_field = B_FALSE;
    int     error = 0;          /* fields order error */
    char        prev = description->d_prev;
    char        m_prev = description->d_mprev;

    switch (*begin) {
        case SDP_VERSION_FIELD:
            sdp_check_order(prev, SDP_VERSION_ORDER, &error);
            description->d_version = B_TRUE;
            sdp_parse_version(&_session->s_version, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_ORIGIN_FIELD:
            sdp_check_order(prev, SDP_ORIGIN_ORDER, &error);
            description->d_origin = B_TRUE;
            sdp_parse_origin(&_session->s_origin, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_NAME_FIELD:
            sdp_check_order(prev, SDP_NAME_ORDER, &error);
            description->d_name = B_TRUE;
            sdp_parse_name(&_session->s_name, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_INFO_FIELD:
            if (description->d_mparsed) {
                sdp_check_order(m_prev, SDP_M_INFO_ORDER,
                    &error);
                if (description->d_lmedia == NULL)
                    break;
                sdp_parse_info(&(description->d_lmedia->
                    m_info), begin + 1, end, &description->
                    d_perror);
            } else {
                sdp_check_order(prev, SDP_INFO_ORDER, &error);
                sdp_parse_info(&_session->s_info, begin + 1,
                    end, &description->d_perror);
            }
            break;
        case SDP_URI_FIELD:
            sdp_check_order(prev, SDP_URI_ORDER, &error);
            sdp_parse_uri(&_session->s_uri, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_EMAIL_FIELD:
            sdp_check_order(prev, SDP_EMAIL_ORDER, &error);
            sdp_parse_email(&_session->s_email, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_PHONE_FIELD:
            sdp_check_order(prev, SDP_PHONE_ORDER, &error);
            sdp_parse_phone(&_session->s_phone, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_CONNECTION_FIELD:
            if (description->d_mparsed) {
                sdp_check_order(m_prev, SDP_M_CONN_ORDER,
                    &error);
                --description->d_mccount;
                if (description->d_lmedia == NULL)
                    break;
                sdp_parse_connection(&(description->d_lmedia->
                    m_conn), begin + 1, end,
                    &description->d_perror);
            } else {
                /*
                 * RFC - 4566 says that session section  should
                 * have only one connection field, while media
                 * section can have many
                 */
                sdp_check_order(prev, SDP_CONN_ORDER, &error);
                description->d_conn = B_TRUE;
                if (_session->s_conn != NULL)
                    break;
                sdp_parse_connection(&_session->s_conn,
                    begin + 1, end, &description->d_perror);
            }
            break;
        case SDP_BANDWIDTH_FIELD:
            if (description->d_mparsed) {
                sdp_check_order(m_prev, SDP_M_BW_ORDER, &error);
                if (description->d_lmedia == NULL)
                    break;
                sdp_parse_bandwidth(&(description->d_lmedia->
                    m_bw), begin + 1, end,
                    &description->d_perror);
            } else {
                sdp_check_order(prev, SDP_BW_ORDER, &error);
                sdp_parse_bandwidth(&_session->s_bw,
                    begin + 1, end, &description->d_perror);
            }
            break;
        case SDP_TIME_FIELD:
            if (!description->d_tparsed || description->d_prev !=
                SDP_REPEAT_FIELD) {
                sdp_check_order(prev, SDP_TIME_ORDER, &error);
            }
            description->d_tparsed = B_TRUE;
            description->d_ltime = sdp_parse_time(&_session->
                s_time, begin + 1, end, &description->d_perror);
            break;
        case SDP_REPEAT_FIELD:
            sdp_check_order(prev, SDP_REPEAT_ORDER, &error);
            if (description->d_ltime == NULL)
                break;
            /* we pass time, as repeat is associated with time */
            sdp_parse_repeat(description->d_ltime, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_ZONE_FIELD:
            sdp_check_order(prev, SDP_ZONE_ORDER, &error);
            sdp_parse_zone(&_session->s_zone, begin + 1, end,
                &description->d_perror);
            break;
        case SDP_KEY_FIELD:
            if (description->d_mparsed) {
                sdp_check_order(m_prev, SDP_M_KEY_ORDER,
                    &error);
                if (description->d_lmedia == NULL)
                    break;
                sdp_parse_key(&(description->d_lmedia->m_key),
                    begin + 1, end, &description->d_perror);
            } else {
                sdp_check_order(prev, SDP_KEY_ORDER, &error);
                sdp_parse_key(&_session->s_key, begin + 1, end,
                    &description->d_perror);
            }
            break;
        case SDP_ATTRIBUTE_FIELD:
            if (description->d_mparsed) {
                sdp_check_order(m_prev, SDP_M_ATTR_ORDER,
                    &error);
                if (description->d_lmedia == NULL)
                    break;
                sdp_parse_attribute(&(description->d_lmedia->
                    m_attr), begin + 1, end,
                    &description->d_perror);
            } else {
                sdp_check_order(prev, SDP_ATTR_ORDER, &error);
                sdp_parse_attribute(&_session->s_attr,
                    begin + 1, end, &description->d_perror);
            }
            break;
        case SDP_MEDIA_FIELD:
            if (!description->d_mparsed) {
                sdp_check_order(prev, SDP_MEDIA_ORDER, &error);
                description->d_mccount = 1;
            } else {
                if (description->d_mccount == 1)
                    description->d_mconn = B_FALSE;
                description->d_mccount = 1;
            }
            description->d_mparsed = B_TRUE;
            description->d_lmedia = sdp_parse_media(_session,
                begin + 1, end, &description->d_perror);
            break;
        default:
            /* Unknown field type. Ignore it */
            u_field = B_TRUE;
            break;
    }
    if (error)
        description->d_perror |= SDP_FIELDS_ORDER_ERROR;
    if (!u_field) {
        if (!description->d_mparsed)
            description->d_prev = *begin;
        else
            description->d_mprev = *begin;
    }
}

/*
 * Parses the SDP info
 */
int
sdp_parse(const char *sdp_info, int len, int flags, sdp_session_t **session,
    uint_t *p_error)
{

    const char      *f_begin;
    const char      *f_end;
    sdp_description_t   *description;
    const char      *start;
    const char      *end;
    const char      *current;

    if (sdp_info == NULL || len == 0 || p_error == NULL || flags != 0 ||
        session == NULL) {
        if (session != NULL)
            *session = NULL;
        return (EINVAL);
    }
    *session = NULL;
    *p_error = 0;
    description = calloc(1, sizeof (sdp_description_t));
    if (description == NULL) {
        return (ENOMEM);
    }
    /* Needed later to check for mandatory fields */
    description->d_prev = COMMP_SP;
    description->d_mconn = B_TRUE;
    *session = sdp_new_session();
    if (*session == NULL) {
        free(description);
        return (ENOMEM);
    }
    start = sdp_info;
    end = start + len;
    if (commp_skip_white_space(&start, end) != 0) {
        free(description);
        free(*session);
        *session = NULL;
        return (EINVAL);
    }
    current = start;
    f_begin = current;
    while ((current < end) && !(description->d_perror &
        SDP_MEMORY_ERROR)) {
        /*
         * RFC says parser SHOULD be tolerant to records ending
         * with a single newline character too.
         */
        if (strncmp(COMMP_CRLF, current, strlen(COMMP_CRLF)) == 0) {
            f_end = current;
            sdp_handle_fields(description, *session, f_begin,
                f_end);
            COMMP_SKIP_CRLF(current);
            (void) commp_skip_white_space(&current, end);
            f_begin = current;
        } else if (strncmp(COMMP_LF, current, strlen(COMMP_LF)) == 0) {
            f_end = current;
            sdp_handle_fields(description, *session, f_begin,
                f_end);
            COMMP_SKIP_LF(current);
            (void) commp_skip_white_space(&current, end);
            f_begin = current;
        } else {
            current++;
        }
    }
    if (description->d_perror & SDP_MEMORY_ERROR) {
        free(description);
        sdp_free_session(*session);
        *session = NULL;
        return (ENOMEM);
    }
    /*
     * Check for mandatory fields v, o, s, t fields. For connection field,
     * RFC says; a connection field must be present in every media
     * description or at the session-level
     */
    if (description->d_mccount == 1)
        description->d_mconn = B_FALSE;
    if (!(description->d_version && description->d_origin &&
        description->d_name && description->d_tparsed &&
        (description->d_conn || (description->d_mparsed &&
        description->d_mconn)))) {
        description->d_perror |= SDP_MISSING_FIELDS;
    }
    *p_error = description->d_perror;
    free(description);
    return (0);
}