/* ------------------------------------------------------------------
* Copyright (C) 1998-2009 PacketVideo
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied.
* See the License for the specific language governing permissions
* and limitations under the License.
* -------------------------------------------------------------------
*/
#include "session_info_parser.h"
#include "oscl_string_utils.h"
#include "rtsp_time_formats.h"
#include "sdp_info.h"
#include "oscl_str_ptr_len.h"
#include "rtsp_range_utils.h"
#include "oscl_string_containers.h"
SDP_ERROR_CODE parseSDPSessionInfo(const char *sdp_text, int length, SDPInfo *sdp)
{
sessionDescription *session = sdp->getSessionInfo();
bool o_field_found = false;
bool s_field_found = false;
bool a_control_found = false;
bool a_range_found = false;
bool t_field_found = false;
bool u_field_found = false;
const char *end = sdp_text + length;
const char *current_start = sdp_text;
const char *line_start_ptr, *line_end_ptr;
OsclMemoryFragment memFrag;
// setup the known attribute fields here
StrPtrLen author("a=author:");
StrPtrLen version("a=version:");
StrPtrLen copyright("a=copyright:");
StrPtrLen rating("a=rating:");
StrPtrLen range("a=range:");
StrPtrLen wmf_version("a=X-wmfversion:");
StrPtrLen allowrecord("a=X-allowrecord");
StrPtrLen random_access("a=random_access_denied");
StrPtrLen control("a=control:");
StrPtrLen creation_date("a=creation_date:");
StrPtrLen video_only_allowed_true("a=video_only_allowed:true");
StrPtrLen video_only_allowed_false("a=video_only_allowed:false");
StrPtrLen etag("a=etag:");
//StrPtrLen security("a=X-security_flag:");
StrPtrLen random_filler("a=X-random_filler:");
StrPtrLen digital_signature("a=X-digital_signature:");
StrPtrLen end_of_clip("a=X-end_of_clip:");
StrPtrLen launch_URL("a=X-launch_URL:");
StrPtrLen app_specific_string("a=X-app_specific_string:");
StrPtrLen pause_denied("a=X-pause_denied");
StrPtrLen qoe_metrics("a=3GPP-QoE-Metrics:");
StrPtrLen sdp_int_key("a=3GPP-Integrity-Key:");
StrPtrLen sdp_auth("a=3GPP-SDP-Auth:");
StrPtrLen alt_gp("a=alt-group:");
StrPtrLen asset_info("a=3GPP-Asset-Information:");
// added for RM
StrPtrLen sdpplinversion("a=SdpplinVersion:");
StrPtrLen flags("a=Flags:");
StrPtrLen isrealdatatype("a=IsRealDataType:");
StrPtrLen streamcount("a=StreamCount:");
StrPtrLen title("a=Title:");
StrPtrLen keywords("a=Keywords:");
StrPtrLen abstract("a=Abstract:");
StrPtrLen ASMrulebook("a=ASMRuleBook");
while (get_next_line(current_start, end,
line_start_ptr, line_end_ptr))
{
// check for line type
switch (*line_start_ptr)
{
case 'v':
{
uint32 version;
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
if (PV_atoi(line_start_ptr + 2, 'd', line_end_ptr - line_start_ptr - 2, version) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
if (version)
return SDP_BAD_SESSION_FORMAT;
session->setProtocolVersion(version);
break;
}
case 'o':
{
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
o_field_found = true;
// parse through each field
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
// get the username
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setOUsername(memFrag);
// get the sessionID
sptr = skip_whitespace(eptr, line_end_ptr);
//o=- -1586996066 -1586996066 IN IP4 172.31.105.21
//workaround for server found during IOT. 12/12/06
while ((*sptr < '0') || (*sptr > '9'))
{
sptr++;
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
uint64 sessionId64;
if (!PV_atoi(sptr, 'd', eptr - sptr, sessionId64)) // session ID should be numeric
return SDP_BAD_SESSION_FORMAT;
uint32 sessionId =
Oscl_Int64_Utils::get_uint64_lower32(sessionId64);
session->setOSessionID(sessionId);
// get the version
sptr = skip_whitespace(eptr, line_end_ptr);
//o=- -1586996066 -1586996066 IN IP4 172.31.105.21
//workaround for server found during IOT. 12/12/06
while ((*sptr < '0') || (*sptr > '9'))
{
sptr++;
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
uint64 version64;
if (!PV_atoi(sptr, 'd', eptr - sptr, version64))
return SDP_BAD_SESSION_FORMAT;
uint32 version =
Oscl_Int64_Utils::get_uint64_lower32(version64);
session->setOVersion(version);
// get the network type
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setONetworkType(memFrag);
// get the address type
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setOAddressType(memFrag);
// get the orginator address
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setOAddress(memFrag);
break;
}
case 's':
{
// the session Name is a string which can contain whitespace
if (s_field_found) // only one s field allowed at session level
return SDP_BAD_SESSION_FORMAT;
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
s_field_found = true;
// parse through each field
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
// get the session name
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setSessionName(memFrag);
break;
}
case 'u':
{
// the session Name is a string which can contain whitespace
if (u_field_found) // only one s field allowed at session level
return SDP_BAD_SESSION_FORMAT;
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
u_field_found = true;
// parse through each field
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
// get the session name
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setSessionURI(memFrag);
break;
}
case 'i':
{
// the session info is a string which can contain whitespace
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
// parse through each field
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
// get the session name
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setSessionInformation(memFrag);
break;
}
case 'c':
{
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
session->setCFieldStatus(true);
// parse through each field
const char *sptr, *eptr;
// get the connection network type
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setCNetworkType(memFrag);
// get the address type
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setCAddressType(memFrag);
uint32 len = OSCL_MIN((uint32)(eptr - sptr), oscl_strlen("IP6"));
if (oscl_strncmp(sptr, "IP6", len) == 0)
{
//TBD
break;
}
// get the address
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr < sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setCAddress(memFrag);
uint32 address;
const char *addrend = sptr;
for (; *addrend != '.'; ++addrend);
PV_atoi(sptr, 'd', addrend - sptr, address);
if (address >= 224 && address <= 239) //multicast address look for TTL
{
for (; (*sptr != '/') && (sptr < eptr); ++sptr);
if (sptr == eptr)
return SDP_BAD_SESSION_FORMAT; // no TTL found in multicast address.
else
{
uint32 ttl;
sptr = sptr + 1;
if (!PV_atoi(sptr, 'd', eptr - sptr, ttl))
return SDP_BAD_SESSION_FORMAT;
if (!(ttl <= 255))
return SDP_BAD_SESSION_FORMAT; // ttl out of range.
}
}
else // unicast address
{
for (; (*sptr != '/') && (sptr < eptr); ++sptr);
if (!oscl_strncmp(sptr, "/", 1))
return SDP_BAD_SESSION_FORMAT; //unicast address can not have TTL.
}
if (eptr < line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
break;
}
case 't':
{
uint64 start_time, stop_time;
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
t_field_found = true;
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
if (PV_atoi(sptr, 'd', (eptr - sptr), start_time) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
session->setSessionStartTime(start_time);
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
if (PV_atoi(sptr, 'd', (eptr - sptr), stop_time) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
session->setSessionStopTime(stop_time);
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setExpiryDate(memFrag);
break;
}
case 'r':
{
uint32 repeat_interval, active_duration;
char convert_to_sec = NULL_TERM_CHAR;
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
int size = 0;
if (!oscl_strncmp((eptr - 1), "d", 1) || !oscl_strncmp((eptr - 1), "h", 1) || !oscl_strncmp((eptr - 1), "m", 1) || !oscl_strncmp((eptr - 1), "s", 1))
{
convert_to_sec = *(eptr - 1);
size = eptr - 1 - sptr;
}
else
size = eptr - sptr;
if (PV_atoi(sptr, 'd', size, repeat_interval) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
if (convert_to_sec == 'd')
{
repeat_interval = repeat_interval * 24 * 3600;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 'h')
{
repeat_interval = repeat_interval * 3600;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 'm')
{
repeat_interval = repeat_interval * 60;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 's')
{
convert_to_sec = NULL_TERM_CHAR; // already in seconds.
}
session->setRepeatInterval(repeat_interval);
eptr = skip_whitespace(eptr, line_end_ptr);
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
if (!oscl_strncmp((eptr - 1), "d", 1) || !oscl_strncmp((eptr - 1), "h", 1) || !oscl_strncmp((eptr - 1), "m", 1) || !oscl_strncmp((eptr - 1), "s", 1))
{
convert_to_sec = *(eptr - 1);
size = eptr - 1 - sptr;
}
else
size = eptr - sptr;
if (PV_atoi(sptr, 'd', size, active_duration) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
if (convert_to_sec == 'd')
{
active_duration = active_duration * 24 * 3600;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 'h')
{
active_duration = active_duration * 3600;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 'm')
{
active_duration = active_duration * 60;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 's')
{
convert_to_sec = NULL_TERM_CHAR;
}
session->setActiveDuration(active_duration);
while (sptr < line_end_ptr)
{
uint32 offset;
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
if (!oscl_strncmp((eptr - 1), "d", 1) || !oscl_strncmp((eptr - 1), "h", 1) || !oscl_strncmp((eptr - 1), "m", 1) || !oscl_strncmp((eptr - 1), "s", 1))
{
size = eptr - 1 - sptr;
convert_to_sec = *(eptr - 1);
}
else
size = eptr - sptr;
if (PV_atoi(sptr, 'd', size, offset) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
if (convert_to_sec == 'd')
{
offset = offset * 24 * 3600;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 'h')
{
offset = offset * 3600;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 'm')
{
offset = offset * 60;
convert_to_sec = NULL_TERM_CHAR;
}
else if (convert_to_sec == 's')
{
convert_to_sec = NULL_TERM_CHAR;
}
session->addOffset(offset);
sptr = eptr;
}
break;
}
case 'b':
{
if (!oscl_strncmp(line_start_ptr, "b=AS:", oscl_strlen("b=AS:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=AS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
uint32 bitRate;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), bitRate) == true)
{
session->setBitrate(1000*bitRate);
}
else
{
return SDP_BAD_SESSION_FORMAT;
}
}
else if (!oscl_strncmp(line_start_ptr, "b=RS:", oscl_strlen("b=RS:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=AS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
uint32 rtcpBWSender;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), rtcpBWSender) == true)
{
session->setRTCPSenderBitRate(rtcpBWSender);
}
else
{
return SDP_BAD_SESSION_FORMAT;
}
}
else if (!oscl_strncmp(line_start_ptr, "b=RR:", oscl_strlen("b=RR:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=AS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
uint32 rtcpBWReceiver;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), rtcpBWReceiver) == true)
{
session->setRTCPReceiverBitRate(rtcpBWReceiver);
}
else
{
return SDP_BAD_SESSION_FORMAT;
}
}
else if (!oscl_strncmp(line_start_ptr, "b=TIAS:", oscl_strlen("b=TIAS:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=TIAS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
uint32 bMod;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), bMod) == true)
{
session->setBWtias(1000 * bMod);
}
else
{
return SDP_BAD_SESSION_FORMAT;
}
}
break;
}
case 'k':
{
const char *sptr, *eptr;
if (!oscl_strncmp(line_start_ptr, "k=clear:", oscl_strlen("k=clear:")))
{
sptr = line_start_ptr + oscl_strlen("k=clear:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setEncryptionKey(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, "k=base64:", oscl_strlen("k=base64:")))
{
sptr = line_start_ptr + oscl_strlen("k=base64:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setEncryptionKey(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, "k=uri:", oscl_strlen("k=uri:")))
{
sptr = line_start_ptr + oscl_strlen("k=uri:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setEncryptionKey(memFrag);
}
else
{
sptr = line_start_ptr;
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
}
break;
}
case 'a':
{
// check to see if it is a known attribute -- otherwise ignore it.
const char *sptr, *eptr;
if (!oscl_strncmp(line_start_ptr, author.c_str(), author.length()))
{
sptr = skip_whitespace(line_start_ptr + author.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setAuthor(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, version.c_str(),
version.length()))
{
sptr = skip_whitespace(line_start_ptr + version.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setVersion(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, copyright.c_str(),
copyright.length()))
{
sptr = skip_whitespace(line_start_ptr + copyright.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setCopyright(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, rating.c_str(), rating.length()))
{
sptr = skip_whitespace(line_start_ptr + rating.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setRating(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, range.c_str(), range.length()))
{
RtspRangeType rangeVal;
if (parseRtspRange((line_start_ptr + range.length()), (line_end_ptr - line_start_ptr - range.length()),
rangeVal))
{
session->setRange(rangeVal);
a_range_found = true;
}
}
else if (!oscl_strncmp(line_start_ptr, wmf_version.c_str(),
wmf_version.length()))
{
sptr = skip_whitespace(line_start_ptr + wmf_version.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setWmfVersion(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, allowrecord.c_str(),
allowrecord.length()))
{
session->setAllowRecord(true);
}
else if (!oscl_strncmp(line_start_ptr, random_access.c_str(),
random_access.length()))
{
session->setRandomAccessDenied(true);
}
else if (!oscl_strncmp(line_start_ptr, control.c_str(),
control.length()))
{
sptr = skip_whitespace(line_start_ptr + control.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
OSCL_HeapString<SDPParserAlloc> control_str(sptr, eptr - sptr);
session->setControlURL(control_str);
a_control_found = true;
}
else if (!oscl_strncmp(line_start_ptr, creation_date.c_str(),
creation_date.length()))
{
sptr = skip_whitespace(line_start_ptr + creation_date.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setCreationDate(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, video_only_allowed_true.c_str(),
video_only_allowed_true.length()))
{
session->setVideoOnlyAllowed(ALLOWED);
}
else if (!oscl_strncmp(line_start_ptr, video_only_allowed_false.c_str(),
video_only_allowed_false.length()))
{
session->setVideoOnlyAllowed(NOT_ALLOWED);
}
else if (!oscl_strncmp(line_start_ptr, etag.c_str(), etag.length()))
{
sptr = skip_whitespace(line_start_ptr + etag.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setETag(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, random_filler.c_str(), random_filler.length()))
{
sptr = skip_whitespace(line_start_ptr + random_filler.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setRandomFiller(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, digital_signature.c_str(),
digital_signature.length()))
{
sptr = skip_whitespace(line_start_ptr + digital_signature.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setDigitalSignature(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, launch_URL.c_str(), launch_URL.length()))
{
sptr = skip_whitespace(line_start_ptr + launch_URL.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setLaunchURL(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, end_of_clip.c_str(), end_of_clip.length()))
{
sptr = skip_whitespace(line_start_ptr + end_of_clip.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
//uint32 action = 0;
StrPtrLen nothing("NOTHING");
StrPtrLen close("CLOSE");
StrPtrLen launch("LAUNCH");
if (!oscl_strncmp(nothing.c_str(), sptr, nothing.length()))
{
session->setEndOfClipAction(DEFAULT);
}
else if (!oscl_strncmp(close.c_str(), sptr, close.length()))
{
session->setEndOfClipAction(CLOSE_PLAYER);
}
else if (!oscl_strncmp(launch.c_str(), sptr, launch.length()))
{
session->setEndOfClipAction(LAUNCH_URL);
}
}
// added for RM
else if (!oscl_strncmp(line_start_ptr, sdpplinversion.c_str(),
sdpplinversion.length()))
{
uint32 version;
sptr = skip_whitespace(line_start_ptr + sdpplinversion.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
if (PV_atoi(sptr, 'd', (eptr - sptr), version) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
session->setSdpplinVersion(version);
}
else if (!oscl_strncmp(line_start_ptr, flags.c_str(),
flags.length()))
{
uint32 flag;
sptr = skip_whitespace(line_start_ptr + flags.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
if (PV_atoi(sptr, 'd', (eptr - sptr), flag) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
session->setFlags(flag);
}
else if (!oscl_strncmp(line_start_ptr, streamcount.c_str(),
streamcount.length()))
{
uint32 count;
sptr = skip_whitespace(line_start_ptr + streamcount.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
if (PV_atoi(sptr, 'd', (eptr - sptr), count) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
session->setStreamCount(count);
}
else if (!oscl_strncmp(line_start_ptr, isrealdatatype.c_str(),
isrealdatatype.length()))
{
uint32 isrealdata;
sptr = skip_whitespace(line_start_ptr + isrealdatatype.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
if (PV_atoi(sptr, 'd', (eptr - sptr), isrealdata) == false)
{
return SDP_BAD_SESSION_FORMAT;
}
session->setIsRealDataType(isrealdata);
}
else if (!oscl_strncmp(line_start_ptr, "a=Author:", author.length()))
{
sptr = skip_whitespace(line_start_ptr + author.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setAuthor(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, "a=Copyright:", copyright.length()))
{
sptr = skip_whitespace(line_start_ptr + copyright.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setCopyright(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, title.c_str(),
title.length()))
{
sptr = skip_whitespace(line_start_ptr + title.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
memFrag.ptr = (void*)(sptr + 1);
memFrag.len = ((eptr - 2) - sptr);
session->setTitle(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, keywords.c_str(),
keywords.length()))
{
sptr = skip_whitespace(line_start_ptr + keywords.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
memFrag.ptr = (void*)(sptr + 1);
memFrag.len = ((eptr - 2) - sptr);
session->setKeywords(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, abstract.c_str(),
abstract.length()))
{
sptr = skip_whitespace(line_start_ptr + abstract.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
memFrag.ptr = (void*)(sptr + 1);
memFrag.len = ((eptr - 2) - sptr);
session->setAbstract(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, ASMrulebook.c_str(),
ASMrulebook.length()))
{
sptr = skip_whitespace(line_start_ptr + ASMrulebook.length(),
line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
// return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
for (; *sptr != ';'; sptr++);
sptr = sptr + 1;
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setASMRuleBook(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, app_specific_string.c_str(), app_specific_string.length()))
{
sptr = skip_whitespace(line_start_ptr + app_specific_string.length(), line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setAppSpecificString(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, pause_denied.c_str(),
pause_denied.length()))
{
session->setPauseDenied(true);
}
else if (!oscl_strncmp(line_start_ptr, qoe_metrics.c_str(),
qoe_metrics.length()))
{
const char *sptr;
sptr = line_start_ptr + qoe_metrics.length();
QoEMetricsType qMetrics;
oscl_memset(qMetrics.name, 0, 7);
qMetrics.rateFmt = QoEMetricsType::VAL;
qMetrics.rateVal = 0;
qMetrics.paramFmt = QoEMetricsType::IDIGIT;
qMetrics.paramExtIdigit = 0;
if (!parseQoEMetrics(sptr, line_end_ptr, qMetrics))
return SDP_BAD_SESSION_FORMAT;
session->setQoEMetrics(qMetrics);
}
else if (!oscl_strncmp(line_start_ptr, sdp_int_key.c_str(),
sdp_int_key.length()))
{
const char *sptr = line_start_ptr + sdp_int_key.length();
const char *eptr = sptr;
bool found_OMADRMv2_keyMethod = false;
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
if (oscl_strncmp(sptr, "OMADRMv2:", oscl_strlen("OMADRMv2:")))
{
for (; *eptr != ':' ; ++eptr);
session->setKeyMethod(sptr, eptr - sptr);
}
else
{
found_OMADRMv2_keyMethod = true;
eptr = sptr + oscl_strlen("OMADRMv2:");
session->setKeyMethod(sptr, eptr - sptr);
}
sptr = eptr ;
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
else if (sptr == line_end_ptr)
break;
if (!found_OMADRMv2_keyMethod)
{
session->setKeyData(sptr, line_end_ptr - sptr);
break;
}
eptr = sptr;
for (; *eptr != ','; ++eptr);
session->setKeyData(sptr, (eptr - sptr));
sptr = eptr + 1;
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
if (oscl_strncmp(sptr, "\"", 1))
return SDP_BAD_SESSION_FORMAT;
else
sptr = sptr + 1;
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
eptr = sptr;
for (; *eptr != '\"'; ++eptr);
session->setKeyContentIdURI(sptr , (eptr - sptr));
sptr = eptr + 1;
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
if (oscl_strncmp(sptr, ",", 1))
return SDP_BAD_SESSION_FORMAT;
sptr = sptr + 1;
if (oscl_strncmp(sptr, "\"", 1))
return SDP_BAD_SESSION_FORMAT;
else
sptr = sptr + 1;
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
eptr = sptr;
for (; *eptr != '"'; ++eptr);
session->setKeyRightIssuerURI(sptr , ((eptr - 1) - sptr));
sptr = eptr + 1;
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr > line_end_ptr)
return SDP_BAD_SESSION_FORMAT;
session->setKeyFreshToken(sptr, (line_end_ptr - sptr));
}
else if (!oscl_strncmp(line_start_ptr, sdp_auth.c_str(),
sdp_auth.length()))
{
const char *sptr = line_start_ptr + sdp_auth.length();
memFrag.ptr = (void *)sptr;
memFrag.len = line_end_ptr - sptr;
session->setSdpAuthTag(memFrag);
}
else if (!oscl_strncmp(line_start_ptr, asset_info.c_str(),
asset_info.length()))
{
const char *sptr = line_start_ptr + asset_info.length();
AssetInfoType assetInfo;
if (!parseAssetInfo(sptr, line_end_ptr, assetInfo))
return SDP_BAD_SESSION_FORMAT;
session->setAssetInfo(assetInfo);
}
else if (!oscl_strncmp(line_start_ptr, alt_gp.c_str(),
alt_gp.length()))
{
const char *sptr = line_start_ptr + alt_gp.length();
sptr = skip_whitespace(sptr, line_end_ptr);
if (!oscl_strncmp(sptr, "BW", oscl_strlen("BW")))
session->setAltGroupBW(sptr, line_end_ptr - sptr);
else if (!oscl_strncmp(sptr, "LANG", oscl_strlen("LANG")))
session->setAltGroupLANG(sptr, line_end_ptr - sptr);
else
return SDP_BAD_SESSION_FORMAT;
}
if (!oscl_strncmp(line_start_ptr, "a=maxprate:", oscl_strlen("a=maxprate:")))
{
line_start_ptr += oscl_strlen("a=maxprate:");
OsclFloat rate;
if (!PV_atof(line_start_ptr, line_end_ptr - line_start_ptr, rate))
return SDP_BAD_SESSION_FORMAT;
session->setMaxprate(rate);
}
break;
}
case 'e':
{
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setEmail(memFrag);
break;
}
case 'p':
{
if (*(line_start_ptr + 1) != '=')
{
return SDP_BAD_SESSION_FORMAT;
}
const char *sptr, *eptr;
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
break;
}
eptr = skip_to_line_term(sptr, line_end_ptr);
if (eptr <= sptr)
{
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
session->setPhoneNumber(memFrag);
break;
}
}
current_start = line_end_ptr;
}
return SDP_SUCCESS;
}