1/*
2 *  Copyright 2004 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#ifndef WEBRTC_P2P_BASE_CANDIDATE_H_
12#define WEBRTC_P2P_BASE_CANDIDATE_H_
13
14#include <limits.h>
15#include <math.h>
16
17#include <algorithm>
18#include <iomanip>
19#include <sstream>
20#include <string>
21
22#include "webrtc/p2p/base/constants.h"
23#include "webrtc/base/basictypes.h"
24#include "webrtc/base/helpers.h"
25#include "webrtc/base/network.h"
26#include "webrtc/base/socketaddress.h"
27
28namespace cricket {
29
30// Candidate for ICE based connection discovery.
31
32class Candidate {
33 public:
34  // TODO: Match the ordering and param list as per RFC 5245
35  // candidate-attribute syntax. http://tools.ietf.org/html/rfc5245#section-15.1
36  Candidate()
37      : id_(rtc::CreateRandomString(8)),
38        component_(0),
39        priority_(0),
40        network_type_(rtc::ADAPTER_TYPE_UNKNOWN),
41        generation_(0) {}
42
43  Candidate(int component,
44            const std::string& protocol,
45            const rtc::SocketAddress& address,
46            uint32_t priority,
47            const std::string& username,
48            const std::string& password,
49            const std::string& type,
50            uint32_t generation,
51            const std::string& foundation)
52      : id_(rtc::CreateRandomString(8)),
53        component_(component),
54        protocol_(protocol),
55        address_(address),
56        priority_(priority),
57        username_(username),
58        password_(password),
59        type_(type),
60        network_type_(rtc::ADAPTER_TYPE_UNKNOWN),
61        generation_(generation),
62        foundation_(foundation) {}
63
64  const std::string & id() const { return id_; }
65  void set_id(const std::string & id) { id_ = id; }
66
67  int component() const { return component_; }
68  void set_component(int component) { component_ = component; }
69
70  const std::string & protocol() const { return protocol_; }
71  void set_protocol(const std::string & protocol) { protocol_ = protocol; }
72
73  // The protocol used to talk to relay.
74  const std::string& relay_protocol() const { return relay_protocol_; }
75  void set_relay_protocol(const std::string& protocol) {
76    relay_protocol_ = protocol;
77  }
78
79  const rtc::SocketAddress & address() const { return address_; }
80  void set_address(const rtc::SocketAddress & address) {
81    address_ = address;
82  }
83
84  uint32_t priority() const { return priority_; }
85  void set_priority(const uint32_t priority) { priority_ = priority; }
86
87  // TODO(pthatcher): Remove once Chromium's jingle/glue/utils.cc
88  // doesn't use it.
89  // Maps old preference (which was 0.0-1.0) to match priority (which
90  // is 0-2^32-1) to to match RFC 5245, section 4.1.2.1.  Also see
91  // https://docs.google.com/a/google.com/document/d/
92  // 1iNQDiwDKMh0NQOrCqbj3DKKRT0Dn5_5UJYhmZO-t7Uc/edit
93  float preference() const {
94    // The preference value is clamped to two decimal precision.
95    return static_cast<float>(((priority_ >> 24) * 100 / 127) / 100.0);
96  }
97
98  // TODO(pthatcher): Remove once Chromium's jingle/glue/utils.cc
99  // doesn't use it.
100  void set_preference(float preference) {
101    // Limiting priority to UINT_MAX when value exceeds uint32_t max.
102    // This can happen for e.g. when preference = 3.
103    uint64_t prio_val = static_cast<uint64_t>(preference * 127) << 24;
104    priority_ = static_cast<uint32_t>(
105        std::min(prio_val, static_cast<uint64_t>(UINT_MAX)));
106  }
107
108  // TODO(honghaiz): Change to usernameFragment or ufrag.
109  const std::string & username() const { return username_; }
110  void set_username(const std::string & username) { username_ = username; }
111
112  const std::string & password() const { return password_; }
113  void set_password(const std::string & password) { password_ = password; }
114
115  const std::string & type() const { return type_; }
116  void set_type(const std::string & type) { type_ = type; }
117
118  const std::string & network_name() const { return network_name_; }
119  void set_network_name(const std::string & network_name) {
120    network_name_ = network_name;
121  }
122
123  rtc::AdapterType network_type() const { return network_type_; }
124  void set_network_type(rtc::AdapterType network_type) {
125    network_type_ = network_type;
126  }
127
128  // Candidates in a new generation replace those in the old generation.
129  uint32_t generation() const { return generation_; }
130  void set_generation(uint32_t generation) { generation_ = generation; }
131  const std::string generation_str() const {
132    std::ostringstream ost;
133    ost << generation_;
134    return ost.str();
135  }
136  void set_generation_str(const std::string& str) {
137    std::istringstream ist(str);
138    ist >> generation_;
139  }
140
141  const std::string& foundation() const {
142    return foundation_;
143  }
144
145  void set_foundation(const std::string& foundation) {
146    foundation_ = foundation;
147  }
148
149  const rtc::SocketAddress & related_address() const {
150    return related_address_;
151  }
152  void set_related_address(
153      const rtc::SocketAddress & related_address) {
154    related_address_ = related_address;
155  }
156  const std::string& tcptype() const { return tcptype_; }
157  void set_tcptype(const std::string& tcptype){
158    tcptype_ = tcptype;
159  }
160
161  // Determines whether this candidate is equivalent to the given one.
162  bool IsEquivalent(const Candidate& c) const {
163    // We ignore the network name, since that is just debug information, and
164    // the priority, since that should be the same if the rest is (and it's
165    // a float so equality checking is always worrisome).
166    return (component_ == c.component_) && (protocol_ == c.protocol_) &&
167           (address_ == c.address_) && (username_ == c.username_) &&
168           (password_ == c.password_) && (type_ == c.type_) &&
169           (generation_ == c.generation_) && (foundation_ == c.foundation_) &&
170           (related_address_ == c.related_address_);
171  }
172
173  std::string ToString() const {
174    return ToStringInternal(false);
175  }
176
177  std::string ToSensitiveString() const {
178    return ToStringInternal(true);
179  }
180
181  uint32_t GetPriority(uint32_t type_preference,
182                       int network_adapter_preference,
183                       int relay_preference) const {
184    // RFC 5245 - 4.1.2.1.
185    // priority = (2^24)*(type preference) +
186    //            (2^8)*(local preference) +
187    //            (2^0)*(256 - component ID)
188
189    // |local_preference| length is 2 bytes, 0-65535 inclusive.
190    // In our implemenation we will partion local_preference into
191    //              0                 1
192    //       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
193    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
194    //      |  NIC Pref     |    Addr Pref  |
195    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
196    // NIC Type - Type of the network adapter e.g. 3G/Wifi/Wired.
197    // Addr Pref - Address preference value as per RFC 3484.
198    // local preference =  (NIC Type << 8 | Addr_Pref) - relay preference.
199
200    int addr_pref = IPAddressPrecedence(address_.ipaddr());
201    int local_preference = ((network_adapter_preference << 8) | addr_pref) +
202        relay_preference;
203
204    return (type_preference << 24) |
205           (local_preference << 8) |
206           (256 - component_);
207  }
208
209 private:
210  std::string ToStringInternal(bool sensitive) const {
211    std::ostringstream ost;
212    std::string address = sensitive ? address_.ToSensitiveString() :
213                                      address_.ToString();
214    ost << "Cand[" << foundation_ << ":" << component_ << ":"
215        << protocol_ << ":" << priority_ << ":"
216        << address << ":" << type_ << ":" << related_address_ << ":"
217        << username_ << ":" << password_ << "]";
218    return ost.str();
219  }
220
221  std::string id_;
222  int component_;
223  std::string protocol_;
224  std::string relay_protocol_;
225  rtc::SocketAddress address_;
226  uint32_t priority_;
227  std::string username_;
228  std::string password_;
229  std::string type_;
230  std::string network_name_;
231  rtc::AdapterType network_type_;
232  uint32_t generation_;
233  std::string foundation_;
234  rtc::SocketAddress related_address_;
235  std::string tcptype_;
236};
237
238// Used during parsing and writing to map component to channel name
239// and back.  This is primarily for converting old G-ICE candidate
240// signalling to new ICE candidate classes.
241class CandidateTranslator {
242 public:
243  virtual ~CandidateTranslator() {}
244  virtual bool GetChannelNameFromComponent(
245      int component, std::string* channel_name) const = 0;
246  virtual bool GetComponentFromChannelName(
247      const std::string& channel_name, int* component) const = 0;
248};
249
250}  // namespace cricket
251
252#endif  // WEBRTC_P2P_BASE_CANDIDATE_H_
253