OLD | NEW |
---|---|
(Empty) | |
1 /* | |
2 * Copyright 2012 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #include <string> | |
12 #include <vector> | |
13 | |
14 #include "webrtc/base/gunit.h" | |
15 #include "webrtc/pc/iceserverparsing.h" | |
16 | |
17 namespace webrtc { | |
18 | |
19 class IceServerParsingTest : public testing::Test { | |
20 public: | |
21 // Convenience for parsing a single URL. | |
22 bool ParseUrl(const std::string& url) { | |
23 return ParseUrl(url, std::string(), std::string()); | |
24 } | |
25 | |
26 bool ParseTurnUrl(const std::string& url) { | |
27 return ParseUrl(url, "username", "password"); | |
28 } | |
29 | |
30 bool ParseUrl(const std::string& url, | |
31 const std::string& username, | |
32 const std::string& password) { | |
33 return ParseUrl( | |
34 url, username, password, | |
35 PeerConnectionInterface::TlsCertPolicy::kTlsCertPolicySecure); | |
36 } | |
37 | |
38 bool ParseUrl(const std::string& url, | |
39 const std::string& username, | |
40 const std::string& password, | |
41 PeerConnectionInterface::TlsCertPolicy tls_certificate_policy) { | |
42 PeerConnectionInterface::IceServers servers; | |
43 PeerConnectionInterface::IceServer server; | |
44 server.urls.push_back(url); | |
45 server.username = username; | |
46 server.password = password; | |
47 server.tls_cert_policy = tls_certificate_policy; | |
48 servers.push_back(server); | |
49 return webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_) == | |
50 webrtc::RTCErrorType::NONE; | |
51 } | |
52 | |
53 protected: | |
54 cricket::ServerAddresses stun_servers_; | |
55 std::vector<cricket::RelayServerConfig> turn_servers_; | |
56 }; | |
57 | |
58 // Make sure all STUN/TURN prefixes are parsed correctly. | |
59 TEST_F(IceServerParsingTest, ParseStunPrefixes) { | |
pthatcher1
2017/03/20 18:23:17
ParsePrefixes?
Taylor Brandstetter
2017/03/23 04:46:25
Well a TURN server is a type of STUN server so tec
| |
60 EXPECT_TRUE(ParseUrl("stun:hostname")); | |
61 EXPECT_EQ(1U, stun_servers_.size()); | |
62 EXPECT_EQ(0U, turn_servers_.size()); | |
63 stun_servers_.clear(); | |
pthatcher1
2017/03/20 18:23:16
It's only test code, so it doesn't matter, but thi
Taylor Brandstetter
2017/03/23 04:46:25
I have a simpler idea: Do the clear in ParseUrl. I
| |
64 | |
65 EXPECT_TRUE(ParseUrl("stuns:hostname")); | |
66 EXPECT_EQ(1U, stun_servers_.size()); | |
67 EXPECT_EQ(0U, turn_servers_.size()); | |
68 stun_servers_.clear(); | |
69 | |
70 EXPECT_TRUE(ParseTurnUrl("turn:hostname")); | |
71 EXPECT_EQ(0U, stun_servers_.size()); | |
72 EXPECT_EQ(1U, turn_servers_.size()); | |
73 EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto); | |
74 turn_servers_.clear(); | |
75 | |
76 EXPECT_TRUE(ParseTurnUrl("turns:hostname")); | |
77 EXPECT_EQ(0U, stun_servers_.size()); | |
78 EXPECT_EQ(1U, turn_servers_.size()); | |
79 EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto); | |
80 EXPECT_TRUE(turn_servers_[0].tls_cert_policy == | |
81 cricket::TlsCertPolicy::TLS_CERT_POLICY_SECURE); | |
82 turn_servers_.clear(); | |
83 | |
84 EXPECT_TRUE(ParseUrl( | |
85 "turns:hostname", "username", "password", | |
86 PeerConnectionInterface::TlsCertPolicy::kTlsCertPolicyInsecureNoCheck)); | |
87 EXPECT_EQ(0U, stun_servers_.size()); | |
88 EXPECT_EQ(1U, turn_servers_.size()); | |
89 EXPECT_TRUE(turn_servers_[0].tls_cert_policy == | |
90 cricket::TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK); | |
91 EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto); | |
92 turn_servers_.clear(); | |
93 | |
94 // invalid prefixes | |
95 EXPECT_FALSE(ParseUrl("stunn:hostname")); | |
96 EXPECT_FALSE(ParseUrl(":hostname")); | |
97 EXPECT_FALSE(ParseUrl(":")); | |
98 EXPECT_FALSE(ParseUrl("")); | |
99 } | |
100 | |
101 TEST_F(IceServerParsingTest, VerifyDefaults) { | |
102 // TURNS defaults | |
103 EXPECT_TRUE(ParseTurnUrl("turns:hostname")); | |
104 EXPECT_EQ(1U, turn_servers_.size()); | |
105 EXPECT_EQ(5349, turn_servers_[0].ports[0].address.port()); | |
106 EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto); | |
107 turn_servers_.clear(); | |
108 | |
109 // TURN defaults | |
110 EXPECT_TRUE(ParseTurnUrl("turn:hostname")); | |
111 EXPECT_EQ(1U, turn_servers_.size()); | |
112 EXPECT_EQ(3478, turn_servers_[0].ports[0].address.port()); | |
113 EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto); | |
114 turn_servers_.clear(); | |
115 | |
116 // STUN defaults | |
117 EXPECT_TRUE(ParseUrl("stun:hostname")); | |
118 EXPECT_EQ(1U, stun_servers_.size()); | |
119 EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
120 stun_servers_.clear(); | |
121 } | |
122 | |
123 // Check that the 6 combinations of IPv4/IPv6/hostname and with/without port | |
124 // can be parsed correctly. | |
125 TEST_F(IceServerParsingTest, ParseHostnameAndPort) { | |
126 EXPECT_TRUE(ParseUrl("stun:1.2.3.4:1234")); | |
127 EXPECT_EQ(1U, stun_servers_.size()); | |
128 EXPECT_EQ("1.2.3.4", stun_servers_.begin()->hostname()); | |
129 EXPECT_EQ(1234, stun_servers_.begin()->port()); | |
130 stun_servers_.clear(); | |
131 | |
132 EXPECT_TRUE(ParseUrl("stun:[1:2:3:4:5:6:7:8]:4321")); | |
133 EXPECT_EQ(1U, stun_servers_.size()); | |
134 EXPECT_EQ("1:2:3:4:5:6:7:8", stun_servers_.begin()->hostname()); | |
135 EXPECT_EQ(4321, stun_servers_.begin()->port()); | |
136 stun_servers_.clear(); | |
137 | |
138 EXPECT_TRUE(ParseUrl("stun:hostname:9999")); | |
139 EXPECT_EQ(1U, stun_servers_.size()); | |
140 EXPECT_EQ("hostname", stun_servers_.begin()->hostname()); | |
141 EXPECT_EQ(9999, stun_servers_.begin()->port()); | |
142 stun_servers_.clear(); | |
143 | |
144 EXPECT_TRUE(ParseUrl("stun:1.2.3.4")); | |
145 EXPECT_EQ(1U, stun_servers_.size()); | |
146 EXPECT_EQ("1.2.3.4", stun_servers_.begin()->hostname()); | |
147 EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
148 stun_servers_.clear(); | |
149 | |
150 EXPECT_TRUE(ParseUrl("stun:[1:2:3:4:5:6:7:8]")); | |
151 EXPECT_EQ(1U, stun_servers_.size()); | |
152 EXPECT_EQ("1:2:3:4:5:6:7:8", stun_servers_.begin()->hostname()); | |
153 EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
154 stun_servers_.clear(); | |
155 | |
156 EXPECT_TRUE(ParseUrl("stun:hostname")); | |
157 EXPECT_EQ(1U, stun_servers_.size()); | |
158 EXPECT_EQ("hostname", stun_servers_.begin()->hostname()); | |
159 EXPECT_EQ(3478, stun_servers_.begin()->port()); | |
160 stun_servers_.clear(); | |
161 | |
162 // Try some invalid hostname:port strings. | |
163 EXPECT_FALSE(ParseUrl("stun:hostname:99a99")); | |
164 EXPECT_FALSE(ParseUrl("stun:hostname:-1")); | |
165 EXPECT_FALSE(ParseUrl("stun:hostname:port:more")); | |
166 EXPECT_FALSE(ParseUrl("stun:hostname:port more")); | |
167 EXPECT_FALSE(ParseUrl("stun:hostname:")); | |
168 EXPECT_FALSE(ParseUrl("stun:[1:2:3:4:5:6:7:8]junk:1000")); | |
169 EXPECT_FALSE(ParseUrl("stun::5555")); | |
170 EXPECT_FALSE(ParseUrl("stun:")); | |
171 } | |
172 | |
173 // Test parsing the "?transport=xxx" part of the URL. | |
174 TEST_F(IceServerParsingTest, ParseTransport) { | |
175 EXPECT_TRUE(ParseTurnUrl("turn:hostname:1234?transport=tcp")); | |
176 EXPECT_EQ(1U, turn_servers_.size()); | |
177 EXPECT_EQ(cricket::PROTO_TCP, turn_servers_[0].ports[0].proto); | |
178 turn_servers_.clear(); | |
179 | |
180 EXPECT_TRUE(ParseTurnUrl("turn:hostname?transport=udp")); | |
181 EXPECT_EQ(1U, turn_servers_.size()); | |
182 EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto); | |
183 turn_servers_.clear(); | |
184 | |
185 EXPECT_FALSE(ParseTurnUrl("turn:hostname?transport=invalid")); | |
186 EXPECT_FALSE(ParseTurnUrl("turn:hostname?transport=")); | |
187 EXPECT_FALSE(ParseTurnUrl("turn:hostname?=")); | |
188 EXPECT_FALSE(ParseTurnUrl("turn:hostname?")); | |
189 EXPECT_FALSE(ParseTurnUrl("?")); | |
190 } | |
191 | |
192 // Test parsing ICE username contained in URL. | |
193 TEST_F(IceServerParsingTest, ParseUsername) { | |
194 EXPECT_TRUE(ParseTurnUrl("turn:user@hostname")); | |
195 EXPECT_EQ(1U, turn_servers_.size()); | |
196 EXPECT_EQ("user", turn_servers_[0].credentials.username); | |
197 turn_servers_.clear(); | |
198 | |
199 EXPECT_FALSE(ParseTurnUrl("turn:@hostname")); | |
200 EXPECT_FALSE(ParseTurnUrl("turn:username@")); | |
201 EXPECT_FALSE(ParseTurnUrl("turn:@")); | |
202 EXPECT_FALSE(ParseTurnUrl("turn:user@name@hostname")); | |
203 } | |
204 | |
205 // Test that username and password from IceServer is copied into the resulting | |
206 // RelayServerConfig. | |
207 TEST_F(IceServerParsingTest, CopyUsernameAndPasswordFromIceServer) { | |
208 EXPECT_TRUE(ParseUrl("turn:hostname", "username", "password")); | |
209 EXPECT_EQ(1U, turn_servers_.size()); | |
210 EXPECT_EQ("username", turn_servers_[0].credentials.username); | |
211 EXPECT_EQ("password", turn_servers_[0].credentials.password); | |
212 } | |
213 | |
214 // Ensure that if a server has multiple URLs, each one is parsed. | |
215 TEST_F(IceServerParsingTest, ParseMultipleUrls) { | |
216 PeerConnectionInterface::IceServers servers; | |
217 PeerConnectionInterface::IceServer server; | |
218 server.urls.push_back("stun:hostname"); | |
219 server.urls.push_back("turn:hostname"); | |
220 server.username = "foo"; | |
221 server.password = "bar"; | |
222 servers.push_back(server); | |
223 EXPECT_EQ(webrtc::RTCErrorType::NONE, | |
224 webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_)); | |
225 EXPECT_EQ(1U, stun_servers_.size()); | |
226 EXPECT_EQ(1U, turn_servers_.size()); | |
227 } | |
228 | |
229 // Ensure that TURN servers are given unique priorities, | |
230 // so that their resulting candidates have unique priorities. | |
231 TEST_F(IceServerParsingTest, TurnServerPrioritiesUnique) { | |
232 PeerConnectionInterface::IceServers servers; | |
233 PeerConnectionInterface::IceServer server; | |
234 server.urls.push_back("turn:hostname"); | |
235 server.urls.push_back("turn:hostname2"); | |
236 server.username = "foo"; | |
237 server.password = "bar"; | |
238 servers.push_back(server); | |
239 EXPECT_EQ(webrtc::RTCErrorType::NONE, | |
240 webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_)); | |
241 EXPECT_EQ(2U, turn_servers_.size()); | |
242 EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority); | |
243 } | |
244 | |
245 } // namespace webrtc | |
OLD | NEW |