18a3896bd2
Broke build steps in other code that uses securetunnelsessionclient.cc and others. TBR=tommi@webrtc.org,pthatcher@webrtc.org BUG= Review URL: https://webrtc-codereview.appspot.com/36439004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@7890 4adac7df-926f-26a2-2b94-8c16560cd09d
388 lines
13 KiB
C++
388 lines
13 KiB
C++
/*
|
|
* libjingle
|
|
* Copyright 2010 Google Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Documentation is in mediamessages.h.
|
|
*/
|
|
|
|
#include "talk/session/media/mediamessages.h"
|
|
|
|
#include "webrtc/p2p/base/constants.h"
|
|
#include "webrtc/p2p/base/parsing.h"
|
|
#include "talk/session/media/mediasessionclient.h"
|
|
#include "webrtc/libjingle/xmllite/xmlelement.h"
|
|
#include "webrtc/base/logging.h"
|
|
#include "webrtc/base/stringencode.h"
|
|
|
|
namespace cricket {
|
|
|
|
namespace {
|
|
|
|
// NOTE: There is no check here for duplicate streams, so check before
|
|
// adding.
|
|
void AddStream(std::vector<StreamParams>* streams, const StreamParams& stream) {
|
|
streams->push_back(stream);
|
|
}
|
|
|
|
bool ParseSsrc(const std::string& string, uint32* ssrc) {
|
|
return rtc::FromString(string, ssrc);
|
|
}
|
|
|
|
// Builds a <view> element according to the following spec:
|
|
// goto/jinglemuc
|
|
buzz::XmlElement* CreateViewElem(const std::string& name,
|
|
const std::string& type) {
|
|
buzz::XmlElement* view_elem =
|
|
new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
|
|
view_elem->AddAttr(QN_NAME, name);
|
|
view_elem->SetAttr(QN_TYPE, type);
|
|
return view_elem;
|
|
}
|
|
|
|
buzz::XmlElement* CreateVideoViewElem(const std::string& content_name,
|
|
const std::string& type) {
|
|
return CreateViewElem(content_name, type);
|
|
}
|
|
|
|
buzz::XmlElement* CreateNoneVideoViewElem(const std::string& content_name) {
|
|
return CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_NONE);
|
|
}
|
|
|
|
buzz::XmlElement* CreateStaticVideoViewElem(const std::string& content_name,
|
|
const StaticVideoView& view) {
|
|
buzz::XmlElement* view_elem =
|
|
CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
|
|
AddXmlAttr(view_elem, QN_SSRC, view.selector.ssrc);
|
|
|
|
buzz::XmlElement* params_elem = new buzz::XmlElement(QN_JINGLE_DRAFT_PARAMS);
|
|
AddXmlAttr(params_elem, QN_WIDTH, view.width);
|
|
AddXmlAttr(params_elem, QN_HEIGHT, view.height);
|
|
AddXmlAttr(params_elem, QN_FRAMERATE, view.framerate);
|
|
AddXmlAttr(params_elem, QN_PREFERENCE, view.preference);
|
|
view_elem->AddElement(params_elem);
|
|
|
|
return view_elem;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool MediaStreams::GetAudioStream(
|
|
const StreamSelector& selector, StreamParams* stream) {
|
|
return GetStream(audio_, selector, stream);
|
|
}
|
|
|
|
bool MediaStreams::GetVideoStream(
|
|
const StreamSelector& selector, StreamParams* stream) {
|
|
return GetStream(video_, selector, stream);
|
|
}
|
|
|
|
bool MediaStreams::GetDataStream(
|
|
const StreamSelector& selector, StreamParams* stream) {
|
|
return GetStream(data_, selector, stream);
|
|
}
|
|
|
|
void MediaStreams::CopyFrom(const MediaStreams& streams) {
|
|
audio_ = streams.audio_;
|
|
video_ = streams.video_;
|
|
data_ = streams.data_;
|
|
}
|
|
|
|
void MediaStreams::AddAudioStream(const StreamParams& stream) {
|
|
AddStream(&audio_, stream);
|
|
}
|
|
|
|
void MediaStreams::AddVideoStream(const StreamParams& stream) {
|
|
AddStream(&video_, stream);
|
|
}
|
|
|
|
void MediaStreams::AddDataStream(const StreamParams& stream) {
|
|
AddStream(&data_, stream);
|
|
}
|
|
|
|
bool MediaStreams::RemoveAudioStream(
|
|
const StreamSelector& selector) {
|
|
return RemoveStream(&audio_, selector);
|
|
}
|
|
|
|
bool MediaStreams::RemoveVideoStream(
|
|
const StreamSelector& selector) {
|
|
return RemoveStream(&video_, selector);
|
|
}
|
|
|
|
bool MediaStreams::RemoveDataStream(
|
|
const StreamSelector& selector) {
|
|
return RemoveStream(&data_, selector);
|
|
}
|
|
|
|
bool IsJingleViewRequest(const buzz::XmlElement* action_elem) {
|
|
return action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW) != NULL;
|
|
}
|
|
|
|
bool ParseStaticVideoView(const buzz::XmlElement* view_elem,
|
|
StaticVideoView* view,
|
|
ParseError* error) {
|
|
uint32 ssrc;
|
|
if (!ParseSsrc(view_elem->Attr(QN_SSRC), &ssrc)) {
|
|
return BadParse("Invalid or missing view ssrc.", error);
|
|
}
|
|
view->selector = StreamSelector(ssrc);
|
|
|
|
const buzz::XmlElement* params_elem =
|
|
view_elem->FirstNamed(QN_JINGLE_DRAFT_PARAMS);
|
|
if (params_elem) {
|
|
view->width = GetXmlAttr(params_elem, QN_WIDTH, 0);
|
|
view->height = GetXmlAttr(params_elem, QN_HEIGHT, 0);
|
|
view->framerate = GetXmlAttr(params_elem, QN_FRAMERATE, 0);
|
|
view->preference = GetXmlAttr(params_elem, QN_PREFERENCE, 0);
|
|
} else {
|
|
return BadParse("Missing view params.", error);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParseJingleViewRequest(const buzz::XmlElement* action_elem,
|
|
ViewRequest* view_request,
|
|
ParseError* error) {
|
|
for (const buzz::XmlElement* view_elem =
|
|
action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW);
|
|
view_elem != NULL;
|
|
view_elem = view_elem->NextNamed(QN_JINGLE_DRAFT_VIEW)) {
|
|
std::string type = view_elem->Attr(QN_TYPE);
|
|
if (STR_JINGLE_DRAFT_VIEW_TYPE_NONE == type) {
|
|
view_request->static_video_views.clear();
|
|
return true;
|
|
} else if (STR_JINGLE_DRAFT_VIEW_TYPE_STATIC == type) {
|
|
StaticVideoView static_video_view(StreamSelector(0), 0, 0, 0);
|
|
if (!ParseStaticVideoView(view_elem, &static_video_view, error)) {
|
|
return false;
|
|
}
|
|
view_request->static_video_views.push_back(static_video_view);
|
|
} else {
|
|
LOG(LS_INFO) << "Ingnoring unknown view type: " << type;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool WriteJingleViewRequest(const std::string& content_name,
|
|
const ViewRequest& request,
|
|
XmlElements* elems,
|
|
WriteError* error) {
|
|
if (request.static_video_views.empty()) {
|
|
elems->push_back(CreateNoneVideoViewElem(content_name));
|
|
} else {
|
|
for (StaticVideoViews::const_iterator view =
|
|
request.static_video_views.begin();
|
|
view != request.static_video_views.end(); ++view) {
|
|
elems->push_back(CreateStaticVideoViewElem(content_name, *view));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ParseSsrcAsLegacyStream(const buzz::XmlElement* desc_elem,
|
|
std::vector<StreamParams>* streams,
|
|
ParseError* error) {
|
|
const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
|
|
if (!ssrc_str.empty()) {
|
|
uint32 ssrc;
|
|
if (!ParseSsrc(ssrc_str, &ssrc)) {
|
|
return BadParse("Missing or invalid ssrc.", error);
|
|
}
|
|
|
|
streams->push_back(StreamParams::CreateLegacy(ssrc));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ParseSsrcs(const buzz::XmlElement* parent_elem,
|
|
std::vector<uint32>* ssrcs,
|
|
ParseError* error) {
|
|
for (const buzz::XmlElement* ssrc_elem =
|
|
parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC);
|
|
ssrc_elem != NULL;
|
|
ssrc_elem = ssrc_elem->NextNamed(QN_JINGLE_DRAFT_SSRC)) {
|
|
uint32 ssrc;
|
|
if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
|
|
return BadParse("Missing or invalid ssrc.", error);
|
|
}
|
|
|
|
ssrcs->push_back(ssrc);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ParseSsrcGroups(const buzz::XmlElement* parent_elem,
|
|
std::vector<SsrcGroup>* ssrc_groups,
|
|
ParseError* error) {
|
|
for (const buzz::XmlElement* group_elem =
|
|
parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC_GROUP);
|
|
group_elem != NULL;
|
|
group_elem = group_elem->NextNamed(QN_JINGLE_DRAFT_SSRC_GROUP)) {
|
|
std::string semantics = group_elem->Attr(QN_SEMANTICS);
|
|
std::vector<uint32> ssrcs;
|
|
if (!ParseSsrcs(group_elem, &ssrcs, error)) {
|
|
return false;
|
|
}
|
|
ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ParseJingleStream(const buzz::XmlElement* stream_elem,
|
|
std::vector<StreamParams>* streams,
|
|
ParseError* error) {
|
|
StreamParams stream;
|
|
// We treat the nick as a stream groupid.
|
|
stream.groupid = stream_elem->Attr(QN_NICK);
|
|
stream.id = stream_elem->Attr(QN_NAME);
|
|
stream.type = stream_elem->Attr(QN_TYPE);
|
|
stream.display = stream_elem->Attr(QN_DISPLAY);
|
|
stream.cname = stream_elem->Attr(QN_CNAME);
|
|
if (!ParseSsrcs(stream_elem, &(stream.ssrcs), error)) {
|
|
return false;
|
|
}
|
|
std::vector<SsrcGroup> ssrc_groups;
|
|
if (!ParseSsrcGroups(stream_elem, &(stream.ssrc_groups), error)) {
|
|
return false;
|
|
}
|
|
streams->push_back(stream);
|
|
return true;
|
|
}
|
|
|
|
bool ParseJingleRtpHeaderExtensions(const buzz::XmlElement* parent_elem,
|
|
std::vector<RtpHeaderExtension>* hdrexts,
|
|
ParseError* error) {
|
|
for (const buzz::XmlElement* hdrext_elem =
|
|
parent_elem->FirstNamed(QN_JINGLE_RTP_HDREXT);
|
|
hdrext_elem != NULL;
|
|
hdrext_elem = hdrext_elem->NextNamed(QN_JINGLE_RTP_HDREXT)) {
|
|
std::string uri = hdrext_elem->Attr(QN_URI);
|
|
int id = GetXmlAttr(hdrext_elem, QN_ID, 0);
|
|
if (id <= 0) {
|
|
return BadParse("Invalid RTP header extension id.", error);
|
|
}
|
|
hdrexts->push_back(RtpHeaderExtension(uri, id));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HasJingleStreams(const buzz::XmlElement* desc_elem) {
|
|
const buzz::XmlElement* streams_elem =
|
|
desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
|
|
return (streams_elem != NULL);
|
|
}
|
|
|
|
bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
|
|
std::vector<StreamParams>* streams,
|
|
ParseError* error) {
|
|
const buzz::XmlElement* streams_elem =
|
|
desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
|
|
if (streams_elem == NULL) {
|
|
return BadParse("Missing streams element.", error);
|
|
}
|
|
for (const buzz::XmlElement* stream_elem =
|
|
streams_elem->FirstNamed(QN_JINGLE_DRAFT_STREAM);
|
|
stream_elem != NULL;
|
|
stream_elem = stream_elem->NextNamed(QN_JINGLE_DRAFT_STREAM)) {
|
|
if (!ParseJingleStream(stream_elem, streams, error)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void WriteSsrcs(const std::vector<uint32>& ssrcs,
|
|
buzz::XmlElement* parent_elem) {
|
|
for (std::vector<uint32>::const_iterator ssrc = ssrcs.begin();
|
|
ssrc != ssrcs.end(); ++ssrc) {
|
|
buzz::XmlElement* ssrc_elem =
|
|
new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC, false);
|
|
SetXmlBody(ssrc_elem, *ssrc);
|
|
|
|
parent_elem->AddElement(ssrc_elem);
|
|
}
|
|
}
|
|
|
|
void WriteSsrcGroups(const std::vector<SsrcGroup>& groups,
|
|
buzz::XmlElement* parent_elem) {
|
|
for (std::vector<SsrcGroup>::const_iterator group = groups.begin();
|
|
group != groups.end(); ++group) {
|
|
buzz::XmlElement* group_elem =
|
|
new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC_GROUP, false);
|
|
AddXmlAttrIfNonEmpty(group_elem, QN_SEMANTICS, group->semantics);
|
|
WriteSsrcs(group->ssrcs, group_elem);
|
|
|
|
parent_elem->AddElement(group_elem);
|
|
}
|
|
}
|
|
|
|
void WriteJingleStream(const StreamParams& stream,
|
|
buzz::XmlElement* parent_elem) {
|
|
buzz::XmlElement* stream_elem =
|
|
new buzz::XmlElement(QN_JINGLE_DRAFT_STREAM, false);
|
|
// We treat the nick as a stream groupid.
|
|
AddXmlAttrIfNonEmpty(stream_elem, QN_NICK, stream.groupid);
|
|
AddXmlAttrIfNonEmpty(stream_elem, QN_NAME, stream.id);
|
|
AddXmlAttrIfNonEmpty(stream_elem, QN_TYPE, stream.type);
|
|
AddXmlAttrIfNonEmpty(stream_elem, QN_DISPLAY, stream.display);
|
|
AddXmlAttrIfNonEmpty(stream_elem, QN_CNAME, stream.cname);
|
|
WriteSsrcs(stream.ssrcs, stream_elem);
|
|
WriteSsrcGroups(stream.ssrc_groups, stream_elem);
|
|
|
|
parent_elem->AddElement(stream_elem);
|
|
}
|
|
|
|
void WriteJingleStreams(const std::vector<StreamParams>& streams,
|
|
buzz::XmlElement* parent_elem) {
|
|
buzz::XmlElement* streams_elem =
|
|
new buzz::XmlElement(QN_JINGLE_DRAFT_STREAMS, true);
|
|
for (std::vector<StreamParams>::const_iterator stream = streams.begin();
|
|
stream != streams.end(); ++stream) {
|
|
WriteJingleStream(*stream, streams_elem);
|
|
}
|
|
|
|
parent_elem->AddElement(streams_elem);
|
|
}
|
|
|
|
void WriteJingleRtpHeaderExtensions(
|
|
const std::vector<RtpHeaderExtension>& hdrexts,
|
|
buzz::XmlElement* parent_elem) {
|
|
for (std::vector<RtpHeaderExtension>::const_iterator hdrext = hdrexts.begin();
|
|
hdrext != hdrexts.end(); ++hdrext) {
|
|
buzz::XmlElement* hdrext_elem =
|
|
new buzz::XmlElement(QN_JINGLE_RTP_HDREXT, false);
|
|
AddXmlAttr(hdrext_elem, QN_URI, hdrext->uri);
|
|
AddXmlAttr(hdrext_elem, QN_ID, hdrext->id);
|
|
parent_elem->AddElement(hdrext_elem);
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace cricket
|