net/quic/crypto/source_address_token.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_QUIC_CRYPTO_SOURCE_ADDRESS_TOKEN_H_
   6 #define NET_QUIC_CRYPTO_SOURCE_ADDRESS_TOKEN_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/strings/string_piece.h"
  12 #include "net/base/net_export.h"
  13
  14 namespace net {
  15
  16 // TODO(rtenneti): sync with server more rationally.
  17 // CachedNetworkParameters contains data that can be used to choose appropriate
  18 // connection parameters (initial RTT, initial CWND, etc.) in new connections.
  19 class NET_EXPORT_PRIVATE CachedNetworkParameters {
  20  public:
  21   // Describes the state of the connection during which the supplied network
  22   // parameters were calculated.
  23   enum PreviousConnectionState {
  24     SLOW_START = 0,
  25     CONGESTION_AVOIDANCE = 1,
  26   };
  27
  28   CachedNetworkParameters();
  29   ~CachedNetworkParameters();
  30
  31   std::string serving_region() const {
  32     return serving_region_;
  33   }
  34   void set_serving_region(base::StringPiece serving_region) {
  35     serving_region_ = serving_region.as_string();
  36   }
  37
  38   int32 bandwidth_estimate_bytes_per_second() const {
  39     return bandwidth_estimate_bytes_per_second_;
  40   }
  41   void set_bandwidth_estimate_bytes_per_second(
  42       int32 bandwidth_estimate_bytes_per_second) {
  43     bandwidth_estimate_bytes_per_second_ = bandwidth_estimate_bytes_per_second;
  44   }
  45
  46   int32 max_bandwidth_estimate_bytes_per_second() const {
  47     return max_bandwidth_estimate_bytes_per_second_;
  48   }
  49   void set_max_bandwidth_estimate_bytes_per_second(
  50       int32 max_bandwidth_estimate_bytes_per_second) {
  51     max_bandwidth_estimate_bytes_per_second_ =
  52         max_bandwidth_estimate_bytes_per_second;
  53   }
  54
  55   int64 max_bandwidth_timestamp_seconds() const {
  56     return max_bandwidth_timestamp_seconds_;
  57   }
  58   void set_max_bandwidth_timestamp_seconds(
  59       int64 max_bandwidth_timestamp_seconds) {
  60     max_bandwidth_timestamp_seconds_ = max_bandwidth_timestamp_seconds;
  61   }
  62
  63   int32 min_rtt_ms() const {
  64     return min_rtt_ms_;
  65   }
  66   void set_min_rtt_ms(int32 min_rtt_ms) {
  67     min_rtt_ms_ = min_rtt_ms;
  68   }
  69
  70   int32 previous_connection_state() const {
  71     return previous_connection_state_;
  72   }
  73   void set_previous_connection_state(int32 previous_connection_state) {
  74     previous_connection_state_ = previous_connection_state;
  75   }
  76
  77  private:
  78   // serving_region_ is used to decide whether or not the bandwidth estimate and
  79   // min RTT are reasonable and if they should be used.
  80   // For example a group of geographically close servers may share the same
  81   // serving_region_ string if they are expected to have similar network
  82   // performance.
  83   std::string serving_region_;
  84   // The server can supply a bandwidth estimate (in bytes/s) which it may re-use
  85   // on receipt of a source-address token with this field set.
  86   int32 bandwidth_estimate_bytes_per_second_;
  87   // The maximum bandwidth seen by the client, not necessarily the latest.
  88   int32 max_bandwidth_estimate_bytes_per_second_;
  89   // Timestamp (seconds since UNIX epoch) that indicates when the max bandwidth
  90   // was seen by the server.
  91   int64 max_bandwidth_timestamp_seconds_;
  92   // The min RTT seen on a previous connection can be used by the server to
  93   // inform initial connection parameters for new connections.
  94   int32 min_rtt_ms_;
  95   // Encodes the PreviousConnectionState enum.
  96   int32 previous_connection_state_;
  97 };
  98
  99 // TODO(rtenneti): sync with server more rationally.
 100 // A SourceAddressToken is serialised, encrypted and sent to clients so that
 101 // they can prove ownership of an IP address.
 102 class NET_EXPORT_PRIVATE SourceAddressToken {
 103  public:
 104   SourceAddressToken();
 105   ~SourceAddressToken();
 106
 107   std::string SerializeAsString() const;
 108
 109   bool ParseFromArray(const char* plaintext, size_t plaintext_length);
 110
 111   std::string ip() const {
 112     return ip_;
 113   }
 114   void set_ip(base::StringPiece ip) {
 115     ip_ = ip.as_string();
 116   }
 117
 118   int64 timestamp() const {
 119     return timestamp_;
 120   }
 121   void set_timestamp(int64 timestamp) {
 122     timestamp_ = timestamp;
 123   }
 124
 125   const CachedNetworkParameters& cached_network_parameters() const {
 126     return cached_network_parameters_;
 127   }
 128   void set_cached_network_parameters(
 129       const CachedNetworkParameters& cached_network_parameters) {
 130     cached_network_parameters_ = cached_network_parameters;
 131   }
 132
 133  private:
 134   // ip_ contains either 4 (IPv4) or 16 (IPv6) bytes of IP address in network
 135   // byte order.
 136   std::string ip_;
 137   // timestamp_ contains a UNIX timestamp value of the time when the token was
 138   // created.
 139   int64 timestamp_;
 140
 141   // The server can provide estimated network parameters to be used for
 142   // initial parameter selection in future connections.
 143   CachedNetworkParameters cached_network_parameters_;
 144
 145   DISALLOW_COPY_AND_ASSIGN(SourceAddressToken);
 146 };
 147
 148 }  // namespace net
 149
 150 #endif  // NET_QUIC_CRYPTO_SOURCE_ADDRESS_TOKEN_H_