3
* Copyright 2011, Google Inc.
5
* Redistribution and use in source and binary forms, with or without
6
* modification, are permitted provided that the following conditions are met:
8
* 1. Redistributions of source code must retain the above copyright notice,
9
* this list of conditions and the following disclaimer.
10
* 2. Redistributions in binary form must reproduce the above copyright notice,
11
* this list of conditions and the following disclaimer in the documentation
12
* and/or other materials provided with the distribution.
13
* 3. The name of the author may not be used to endorse or promote products
14
* derived from this software without specific prior written permission.
16
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
#include "talk/app/webrtc/roapmessages.h"
30
#include "talk/app/webrtc/webrtcsdp.h"
31
#include "talk/base/common.h"
32
#include "talk/base/json.h"
36
// ROAP message types. Must match the enum RoapMessageType.
37
static const char* kMessageTypes[] = {
45
// ROAP error messages. Must match the enum RoapErrorCode.
46
static const char* kErrorMessages[] = {
56
static const char kOffererSessionId[] = "offererSessionId";
57
static const char kAnswererSessionId[] = "answererSessionId";
58
static const char kSetSessionToken[] = "setSessionToken";
59
static const char kSetResponseToken[] = "setResponseToken";
60
static const char kResponseToken[] = "responseToken";
61
static const char kSessionToken[] = "sessionToken";
62
static const char kMessageType[] = "messageType";
63
static const char kSequenceNumber[] = "seq";
64
static const char kSessionDescription[] = "sdp";
65
static const char kErrorType[] = "errorType";
66
static const char kTieBreaker[] = "tieBreaker";
67
static const char kMoreComing[] = "moreComing";
69
RoapMessageBase::RoapMessageBase() : type_(kInvalid), seq_(0) {
72
RoapMessageBase::RoapMessageBase(RoapMessageType type,
73
const std::string& offer_session_id,
74
const std::string& answer_session_id,
75
const std::string& session_token,
76
const std::string& response_token,
79
offer_session_id_(offer_session_id),
80
answer_session_id_(answer_session_id),
81
session_token_(session_token),
82
response_token_(response_token),
86
bool RoapMessageBase::Parse(const std::string& message) {
88
if (!reader.parse(message, jmessage_))
91
std::string message_type;
92
GetStringFromJsonObject(jmessage_, kMessageType, &message_type);
93
if (message_type.empty())
95
bool valid_message_type = false;
96
for (int i = 0; i < kInvalid; i++) {
97
if (message_type == kMessageTypes[i]) {
98
type_ = static_cast<RoapMessageType>(i);
99
valid_message_type = true;
103
if (!valid_message_type)
106
if (!GetStringFromJsonObject(jmessage_, kOffererSessionId,
107
&offer_session_id_) ||
108
offer_session_id_.empty()) {
109
// Parse offererSessionId. Allow error messages to not have an
115
// answererSessionId does not necessarily need to exist in MessageBase.
116
GetStringFromJsonObject(jmessage_, kAnswererSessionId, &answer_session_id_);
117
// setSessionToken and setResponseToken is not required.
118
GetStringFromJsonObject(jmessage_, kSetSessionToken, &session_token_);
119
GetStringFromJsonObject(jmessage_, kSetResponseToken, &response_token_);
121
unsigned int temp_seq;
122
if (!GetUIntFromJsonObject(jmessage_, kSequenceNumber, &temp_seq)) {
125
if (temp_seq > 0xFFFFFFFF)
127
seq_ = static_cast<uint32>(temp_seq);
132
std::string RoapMessageBase::Serialize() {
134
SerializeElement(&message);
135
Json::StyledWriter writer;
136
return writer.write(message);
139
void RoapMessageBase::SerializeElement(Json::Value* message) {
140
ASSERT(message != NULL);
141
(*message)[kMessageType] = kMessageTypes[type_];
142
(*message)[kOffererSessionId] = offer_session_id_;
143
if (!answer_session_id_.empty())
144
(*message)[kAnswererSessionId] = answer_session_id_;
145
if (!session_token_.empty())
146
(*message)[kSessionToken] = session_token_;
147
if (!response_token_.empty())
148
(*message)[kResponseToken] = response_token_;
149
(*message)[kSequenceNumber] = seq_;
152
RoapOffer::RoapOffer(const std::string& offer_session_id,
153
const std::string& answer_session_id,
154
const std::string& session_token,
157
const std::string& desc)
158
: RoapMessageBase(kOffer, offer_session_id, answer_session_id,
159
session_token, "", seq),
160
tie_breaker_(tie_breaker),
164
RoapOffer::RoapOffer(const RoapMessageBase& base)
165
: RoapMessageBase(base) {}
167
bool RoapOffer::Parse() {
168
if (!GetUIntFromJsonObject(jmessage_, kTieBreaker, &tie_breaker_)) {
172
std::string sdp_message;
173
if (!GetStringFromJsonObject(jmessage_, kSessionDescription, &sdp_message))
177
return !desc_.empty();
180
void RoapOffer::SerializeElement(Json::Value* message) {
181
ASSERT(message != NULL);
182
RoapMessageBase::SerializeElement(message);
183
(*message)[kTieBreaker] = tie_breaker_;
184
(*message)[kSessionDescription] = desc_;
187
RoapAnswer::RoapAnswer(const std::string& offer_session_id,
188
const std::string& answer_session_id,
189
const std::string& session_token,
190
const std::string& response_token,
192
const std::string& desc)
193
: RoapMessageBase(kAnswer, offer_session_id, answer_session_id,
194
session_token, response_token, seq),
198
RoapAnswer::RoapAnswer(const RoapMessageBase& base)
199
: RoapMessageBase(base),
200
more_coming_(false) {}
202
bool RoapAnswer::Parse() {
204
if (GetStringFromJsonObject(jmessage_, kMoreComing, &more) && more == "true")
207
std::string sdp_message;
208
if (!GetStringFromJsonObject(jmessage_, kSessionDescription, &sdp_message))
212
return !desc_.empty();
215
void RoapAnswer::SerializeElement(Json::Value* message) {
216
ASSERT(message != NULL);
217
RoapMessageBase::SerializeElement(message);
219
(*message)[kSessionDescription] = desc_;
222
RoapError::RoapError(const RoapMessageBase& base)
223
: RoapMessageBase(base), error_(kFailed) {
226
RoapError::RoapError(const std::string& offer_session_id,
227
const std::string& answer_session_id,
228
const std::string& session_token,
229
const std::string& response_token,
232
: RoapMessageBase(kError, offer_session_id, answer_session_id,
233
session_token, response_token, seq),
237
bool RoapError::Parse() {
238
std::string error_string;
239
GetStringFromJsonObject(jmessage_, kErrorType, &error_string);
240
if (error_string.empty())
242
for (int i = 0; i < ARRAY_SIZE(kErrorMessages); i++) {
243
if (error_string == kErrorMessages[i]) {
244
error_ = static_cast<RoapErrorCode>(i);
251
void RoapError::SerializeElement(Json::Value* message) {
252
ASSERT(message != NULL);
253
ASSERT(error_< ARRAY_SIZE(kErrorMessages));
254
RoapMessageBase::SerializeElement(message);
256
(*message)[kErrorType] = kErrorMessages[error_];
259
RoapOk::RoapOk(const RoapMessageBase& base)
260
: RoapMessageBase(base) {
263
RoapOk::RoapOk(const std::string& offer_session_id,
264
const std::string& answer_session_id,
265
const std::string& session_token,
266
const std::string& response_token,
268
: RoapMessageBase(kOk, offer_session_id, answer_session_id, session_token,
269
response_token, seq) {
272
RoapShutdown::RoapShutdown(const RoapMessageBase& base)
273
: RoapMessageBase(base) {
276
RoapShutdown::RoapShutdown(const std::string& offer_session_id,
277
const std::string& answer_session_id,
278
const std::string& session_token,
280
: RoapMessageBase(kShutdown, offer_session_id, answer_session_id,
281
session_token, "", seq) {
284
} // namespace webrtc