net/quic/crypto/quic_server_info.cc

   1 // Copyright 2014 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 #include "net/quic/crypto/quic_server_info.h"
   6
   7 #include <limits>
   8
   9 #include "base/pickle.h"
  10
  11 using std::string;
  12
  13 namespace {
  14
  15 const int kQuicCryptoConfigVersion = 1;
  16
  17 }  // namespace
  18
  19 namespace net {
  20
  21 QuicServerInfo::State::State() {}
  22
  23 QuicServerInfo::State::~State() {}
  24
  25 void QuicServerInfo::State::Clear() {
  26   server_config.clear();
  27   source_address_token.clear();
  28   server_config_sig.clear();
  29   certs.clear();
  30 }
  31
  32 QuicServerInfo::QuicServerInfo(const QuicServerId& server_id)
  33     : server_id_(server_id) {
  34 }
  35
  36 QuicServerInfo::~QuicServerInfo() {
  37 }
  38
  39 const QuicServerInfo::State& QuicServerInfo::state() const {
  40   return state_;
  41 }
  42
  43 QuicServerInfo::State* QuicServerInfo::mutable_state() {
  44   return &state_;
  45 }
  46
  47 bool QuicServerInfo::Parse(const string& data) {
  48   State* state = mutable_state();
  49
  50   state->Clear();
  51
  52   bool r = ParseInner(data);
  53   if (!r)
  54     state->Clear();
  55   return r;
  56 }
  57
  58 bool QuicServerInfo::ParseInner(const string& data) {
  59   State* state = mutable_state();
  60
  61   // No data was read from the disk cache.
  62   if (data.empty()) {
  63     return false;
  64   }
  65
  66   Pickle p(data.data(), data.size());
  67   PickleIterator iter(p);
  68
  69   int version = -1;
  70   if (!p.ReadInt(&iter, &version)) {
  71     DVLOG(1) << "Missing version";
  72     return false;
  73   }
  74
  75   if (version != kQuicCryptoConfigVersion) {
  76     DVLOG(1) << "Unsupported version";
  77     return false;
  78   }
  79
  80   if (!p.ReadString(&iter, &state->server_config)) {
  81     DVLOG(1) << "Malformed server_config";
  82     return false;
  83   }
  84   if (!p.ReadString(&iter, &state->source_address_token)) {
  85     DVLOG(1) << "Malformed source_address_token";
  86     return false;
  87   }
  88   if (!p.ReadString(&iter, &state->server_config_sig)) {
  89     DVLOG(1) << "Malformed server_config_sig";
  90     return false;
  91   }
  92
  93   // Read certs.
  94   uint32 num_certs;
  95   if (!p.ReadUInt32(&iter, &num_certs)) {
  96     DVLOG(1) << "Malformed num_certs";
  97     return false;
  98   }
  99
 100   for (uint32 i = 0; i < num_certs; i++) {
 101     string cert;
 102     if (!p.ReadString(&iter, &cert)) {
 103       DVLOG(1) << "Malformed cert";
 104       return false;
 105     }
 106     state->certs.push_back(cert);
 107   }
 108
 109   return true;
 110 }
 111
 112 string QuicServerInfo::Serialize() {
 113   string pickled_data = SerializeInner();
 114   state_.Clear();
 115   return pickled_data;
 116 }
 117
 118 string QuicServerInfo::SerializeInner() const {
 119   Pickle p(sizeof(Pickle::Header));
 120
 121   if (!p.WriteInt(kQuicCryptoConfigVersion) ||
 122       !p.WriteString(state_.server_config) ||
 123       !p.WriteString(state_.source_address_token) ||
 124       !p.WriteString(state_.server_config_sig) ||
 125       state_.certs.size() > std::numeric_limits<uint32>::max() ||
 126       !p.WriteUInt32(state_.certs.size())) {
 127     return string();
 128   }
 129
 130   for (size_t i = 0; i < state_.certs.size(); i++) {
 131     if (!p.WriteString(state_.certs[i])) {
 132       return string();
 133     }
 134   }
 135
 136   return string(reinterpret_cast<const char *>(p.data()), p.size());
 137 }
 138
 139 QuicServerInfoFactory::~QuicServerInfoFactory() {}
 140
 141 }  // namespace net