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