text: /*
   *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
   *
   *  Use of this source code is governed by a BSD-style license
   *  that can be found in the LICENSE file in the root of the source
   *  tree. An additional intellectual property rights grant can be found
   *  in the file PATENTS.  All contributing project authors may
   *  be found in the AUTHORS file in the root of the source tree.
   */
  
  #include <string>
  #include <vector>
  
  #include "webrtc/pc/iceserverparsing.h"
  #include "webrtc/rtc_base/gunit.h"
  
  namespace webrtc {
  
  class IceServerParsingTest : public testing::Test {
   public:
    // Convenience functions for parsing a single URL. Result is stored in
    // |stun_servers_| and |turn_servers_|.
    bool ParseUrl(const std::string& url) {
      return ParseUrl(url, std::string(), std::string());
    }
  
    bool ParseTurnUrl(const std::string& url) {
      return ParseUrl(url, "username", "password");
    }
  
    bool ParseUrl(const std::string& url,
                  const std::string& username,
                  const std::string& password) {
      return ParseUrl(
          url, username, password,
          PeerConnectionInterface::TlsCertPolicy::kTlsCertPolicySecure);
    }
  
    bool ParseUrl(const std::string& url,
                  const std::string& username,
                  const std::string& password,
                  PeerConnectionInterface::TlsCertPolicy tls_certificate_policy) {
      return ParseUrl(url, username, password, tls_certificate_policy, "");
    }
  
    bool ParseUrl(const std::string& url,
                  const std::string& username,
                  const std::string& password,
                  PeerConnectionInterface::TlsCertPolicy tls_certificate_policy,
                  const std::string& hostname) {
      stun_servers_.clear();
      turn_servers_.clear();
      PeerConnectionInterface::IceServers servers;
      PeerConnectionInterface::IceServer server;
      server.urls.push_back(url);
      server.username = username;
      server.password = password;
      server.tls_cert_policy = tls_certificate_policy;
      server.hostname = hostname;
      servers.push_back(server);
      return webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_) ==
             webrtc::RTCErrorType::NONE;
    }
  
   protected:
    cricket::ServerAddresses stun_servers_;
    std::vector<cricket::RelayServerConfig> turn_servers_;
  };
  
  // Make sure all STUN/TURN prefixes are parsed correctly.
  TEST_F(IceServerParsingTest, ParseStunPrefixes) {
    EXPECT_TRUE(ParseUrl("stun:hostname"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ(0U, turn_servers_.size());
  
    EXPECT_TRUE(ParseUrl("stuns:hostname"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ(0U, turn_servers_.size());
  
    EXPECT_TRUE(ParseTurnUrl("turn:hostname"));
    EXPECT_EQ(0U, stun_servers_.size());
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto);
  
    EXPECT_TRUE(ParseTurnUrl("turns:hostname"));
    EXPECT_EQ(0U, stun_servers_.size());
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto);
    EXPECT_TRUE(turn_servers_[0].tls_cert_policy ==
                cricket::TlsCertPolicy::TLS_CERT_POLICY_SECURE);
  
    EXPECT_TRUE(ParseUrl(
        "turns:hostname", "username", "password",
        PeerConnectionInterface::TlsCertPolicy::kTlsCertPolicyInsecureNoCheck));
    EXPECT_EQ(0U, stun_servers_.size());
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_TRUE(turn_servers_[0].tls_cert_policy ==
                cricket::TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK);
    EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto);
  
    // invalid prefixes
    EXPECT_FALSE(ParseUrl("stunn:hostname"));
    EXPECT_FALSE(ParseUrl(":hostname"));
    EXPECT_FALSE(ParseUrl(":"));
    EXPECT_FALSE(ParseUrl(""));
  }
  
  TEST_F(IceServerParsingTest, VerifyDefaults) {
    // TURNS defaults
    EXPECT_TRUE(ParseTurnUrl("turns:hostname"));
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ(5349, turn_servers_[0].ports[0].address.port());
    EXPECT_EQ(cricket::PROTO_TLS, turn_servers_[0].ports[0].proto);
  
    // TURN defaults
    EXPECT_TRUE(ParseTurnUrl("turn:hostname"));
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ(3478, turn_servers_[0].ports[0].address.port());
    EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto);
  
    // STUN defaults
    EXPECT_TRUE(ParseUrl("stun:hostname"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ(3478, stun_servers_.begin()->port());
  }
  
  // Check that the 6 combinations of IPv4/IPv6/hostname and with/without port
  // can be parsed correctly.
  TEST_F(IceServerParsingTest, ParseHostnameAndPort) {
    EXPECT_TRUE(ParseUrl("stun:1.2.3.4:1234"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ("1.2.3.4", stun_servers_.begin()->hostname());
    EXPECT_EQ(1234, stun_servers_.begin()->port());
  
    EXPECT_TRUE(ParseUrl("stun:[1:2:3:4:5:6:7:8]:4321"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ("1:2:3:4:5:6:7:8", stun_servers_.begin()->hostname());
    EXPECT_EQ(4321, stun_servers_.begin()->port());
  
    EXPECT_TRUE(ParseUrl("stun:hostname:9999"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ("hostname", stun_servers_.begin()->hostname());
    EXPECT_EQ(9999, stun_servers_.begin()->port());
  
    EXPECT_TRUE(ParseUrl("stun:1.2.3.4"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ("1.2.3.4", stun_servers_.begin()->hostname());
    EXPECT_EQ(3478, stun_servers_.begin()->port());
  
    EXPECT_TRUE(ParseUrl("stun:[1:2:3:4:5:6:7:8]"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ("1:2:3:4:5:6:7:8", stun_servers_.begin()->hostname());
    EXPECT_EQ(3478, stun_servers_.begin()->port());
  
    EXPECT_TRUE(ParseUrl("stun:hostname"));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ("hostname", stun_servers_.begin()->hostname());
    EXPECT_EQ(3478, stun_servers_.begin()->port());
  
    // Both TURN IP and host exist
    EXPECT_TRUE(
        ParseUrl("turn:1.2.3.4:1234", "username", "password",
                 PeerConnectionInterface::TlsCertPolicy::kTlsCertPolicySecure,
                 "hostname"));
    EXPECT_EQ(1U, turn_servers_.size());
    rtc::SocketAddress address = turn_servers_[0].ports[0].address;
    EXPECT_EQ("hostname", address.hostname());
    EXPECT_EQ(1234, address.port());
    EXPECT_FALSE(address.IsUnresolvedIP());
    EXPECT_EQ("1.2.3.4", address.ipaddr().ToString());
  
    // Try some invalid hostname:port strings.
    EXPECT_FALSE(ParseUrl("stun:hostname:99a99"));
    EXPECT_FALSE(ParseUrl("stun:hostname:-1"));
    EXPECT_FALSE(ParseUrl("stun:hostname:port:more"));
    EXPECT_FALSE(ParseUrl("stun:hostname:port more"));
    EXPECT_FALSE(ParseUrl("stun:hostname:"));
    EXPECT_FALSE(ParseUrl("stun:[1:2:3:4:5:6:7:8]junk:1000"));
    EXPECT_FALSE(ParseUrl("stun::5555"));
    EXPECT_FALSE(ParseUrl("stun:"));
  }
  
  // Test parsing the "?transport=xxx" part of the URL.
  TEST_F(IceServerParsingTest, ParseTransport) {
    EXPECT_TRUE(ParseTurnUrl("turn:hostname:1234?transport=tcp"));
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ(cricket::PROTO_TCP, turn_servers_[0].ports[0].proto);
  
    EXPECT_TRUE(ParseTurnUrl("turn:hostname?transport=udp"));
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ(cricket::PROTO_UDP, turn_servers_[0].ports[0].proto);
  
    EXPECT_FALSE(ParseTurnUrl("turn:hostname?transport=invalid"));
    EXPECT_FALSE(ParseTurnUrl("turn:hostname?transport="));
    EXPECT_FALSE(ParseTurnUrl("turn:hostname?="));
    EXPECT_FALSE(ParseTurnUrl("turn:hostname?"));
    EXPECT_FALSE(ParseTurnUrl("?"));
  }
  
  // Test parsing ICE username contained in URL.
  TEST_F(IceServerParsingTest, ParseUsername) {
    EXPECT_TRUE(ParseTurnUrl("turn:user@hostname"));
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ("user", turn_servers_[0].credentials.username);
  
    EXPECT_FALSE(ParseTurnUrl("turn:@hostname"));
    EXPECT_FALSE(ParseTurnUrl("turn:username@"));
    EXPECT_FALSE(ParseTurnUrl("turn:@"));
    EXPECT_FALSE(ParseTurnUrl("turn:user@name@hostname"));
  }
  
  // Test that username and password from IceServer is copied into the resulting
  // RelayServerConfig.
  TEST_F(IceServerParsingTest, CopyUsernameAndPasswordFromIceServer) {
    EXPECT_TRUE(ParseUrl("turn:hostname", "username", "password"));
    EXPECT_EQ(1U, turn_servers_.size());
    EXPECT_EQ("username", turn_servers_[0].credentials.username);
    EXPECT_EQ("password", turn_servers_[0].credentials.password);
  }
  
  // Ensure that if a server has multiple URLs, each one is parsed.
  TEST_F(IceServerParsingTest, ParseMultipleUrls) {
    PeerConnectionInterface::IceServers servers;
    PeerConnectionInterface::IceServer server;
    server.urls.push_back("stun:hostname");
    server.urls.push_back("turn:hostname");
    server.username = "foo";
    server.password = "bar";
    servers.push_back(server);
    EXPECT_EQ(webrtc::RTCErrorType::NONE,
              webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
    EXPECT_EQ(1U, stun_servers_.size());
    EXPECT_EQ(1U, turn_servers_.size());
  }
  
  // Ensure that TURN servers are given unique priorities,
  // so that their resulting candidates have unique priorities.
  TEST_F(IceServerParsingTest, TurnServerPrioritiesUnique) {
    PeerConnectionInterface::IceServers servers;
    PeerConnectionInterface::IceServer server;
    server.urls.push_back("turn:hostname");
    server.urls.push_back("turn:hostname2");
    server.username = "foo";
    server.password = "bar";
    servers.push_back(server);
    EXPECT_EQ(webrtc::RTCErrorType::NONE,
              webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
    EXPECT_EQ(2U, turn_servers_.size());
    EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority);
  }
  
  }  // namespace webrtc
  