net/quic/crypto/crypto_server_config_protobuf.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_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
   6 #define NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/logging.h"
  12 #include "base/stl_util.h"
  13 #include "base/strings/string_piece.h"
  14 #include "net/base/net_export.h"
  15 #include "net/quic/crypto/crypto_protocol.h"
  16
  17 namespace net {
  18
  19 // QuicServerConfigProtobuf contains QUIC server config block and the private
  20 // keys needed to prove ownership.
  21 // TODO(rch): sync with server more rationally.
  22 class NET_EXPORT_PRIVATE QuicServerConfigProtobuf {
  23  public:
  24   // PrivateKey contains a QUIC tag of a key exchange algorithm and a
  25   // serialised private key for that algorithm. The format of the serialised
  26   // private key is specific to the algorithm in question.
  27   class NET_EXPORT_PRIVATE PrivateKey {
  28    public:
  29     QuicTag tag() const {
  30       return tag_;
  31     }
  32     void set_tag(QuicTag tag) {
  33       tag_ = tag;
  34     }
  35     std::string private_key() const {
  36       return private_key_;
  37     }
  38     void set_private_key(std::string key) {
  39       private_key_ = key;
  40     }
  41
  42    private:
  43     QuicTag tag_;
  44     std::string private_key_;
  45   };
  46
  47   QuicServerConfigProtobuf();
  48   ~QuicServerConfigProtobuf();
  49
  50   size_t key_size() const {
  51     return keys_.size();
  52   }
  53
  54   const PrivateKey& key(size_t i) const {
  55     DCHECK_GT(keys_.size(), i);
  56     return *keys_[i];
  57   }
  58
  59   std::string config() const {
  60     return config_;
  61   }
  62
  63   void set_config(base::StringPiece config) {
  64     config_ = config.as_string();
  65   }
  66
  67   QuicServerConfigProtobuf::PrivateKey* add_key() {
  68     keys_.push_back(new PrivateKey);
  69     return keys_.back();
  70   }
  71
  72   void clear_key() {
  73     STLDeleteElements(&keys_);
  74   }
  75
  76   bool has_primary_time() const {
  77     return primary_time_ > 0;
  78   }
  79
  80   int64 primary_time() const {
  81     return primary_time_;
  82   }
  83
  84   void set_primary_time(int64 primary_time) {
  85     primary_time_ = primary_time;
  86   }
  87
  88   bool has_priority() const {
  89     return priority_ > 0;
  90   }
  91
  92   int64 priority() const {
  93     return priority_;
  94   }
  95
  96   void set_priority(int64 priority) {
  97     priority_ = priority;
  98   }
  99
 100  private:
 101   std::vector<PrivateKey*> keys_;
 102
 103   // config_ is a serialised config in QUIC wire format.
 104   std::string config_;
 105
 106   // primary_time_ contains a UNIX epoch seconds value that indicates when this
 107   // config should become primary.
 108   int64 primary_time_;
 109
 110   // Relative priority of this config vs other configs with the same
 111   // primary time.  For use as a secondary sort key when selecting the
 112   // primary config.
 113   uint64 priority_;
 114 };
 115
 116 }  // namespace net
 117
 118 #endif  // NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_