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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// 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_HANDSHAKE_MESSAGE_H_
#define NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
#include <string>
#include <vector>
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/quic_protocol.h"
namespace net {
// An intermediate format of a handshake message that's convenient for a
// CryptoFramer to serialize from or parse into.
class NET_EXPORT_PRIVATE CryptoHandshakeMessage {
public:
CryptoHandshakeMessage();
CryptoHandshakeMessage(const CryptoHandshakeMessage& other);
~CryptoHandshakeMessage();
CryptoHandshakeMessage& operator=(const CryptoHandshakeMessage& other);
// Clears state.
void Clear();
// GetSerialized returns the serialized form of this message and caches the
// result. Subsequently altering the message does not invalidate the cache.
const QuicData& GetSerialized() const;
// MarkDirty invalidates the cache created by |GetSerialized|.
void MarkDirty();
// SetValue sets an element with the given tag to the raw, memory contents of
// |v|.
template<class T> void SetValue(QuicTag tag, const T& v) {
tag_value_map_[tag] =
std::string(reinterpret_cast<const char*>(&v), sizeof(v));
}
// SetVector sets an element with the given tag to the raw contents of an
// array of elements in |v|.
template<class T> void SetVector(QuicTag tag, const std::vector<T>& v) {
if (v.empty()) {
tag_value_map_[tag] = std::string();
} else {
tag_value_map_[tag] = std::string(reinterpret_cast<const char*>(&v[0]),
v.size() * sizeof(T));
}
}
// Returns the message tag.
QuicTag tag() const { return tag_; }
// Sets the message tag.
void set_tag(QuicTag tag) { tag_ = tag; }
const QuicTagValueMap& tag_value_map() const { return tag_value_map_; }
// SetTaglist sets an element with the given tag to contain a list of tags,
// passed as varargs. The argument list must be terminated with a 0 element.
void SetTaglist(QuicTag tag, ...);
void SetStringPiece(QuicTag tag, base::StringPiece value);
// Erase removes a tag/value, if present, from the message.
void Erase(QuicTag tag);
// GetTaglist finds an element with the given tag containing zero or more
// tags. If such a tag doesn't exist, it returns false. Otherwise it sets
// |out_tags| and |out_len| to point to the array of tags and returns true.
// The array points into the CryptoHandshakeMessage and is valid only for as
// long as the CryptoHandshakeMessage exists and is not modified.
QuicErrorCode GetTaglist(QuicTag tag, const QuicTag** out_tags,
size_t* out_len) const;
bool GetStringPiece(QuicTag tag, base::StringPiece* out) const;
// GetNthValue24 interprets the value with the given tag to be a series of
// 24-bit, length prefixed values and it returns the subvalue with the given
// index.
QuicErrorCode GetNthValue24(QuicTag tag,
unsigned index,
base::StringPiece* out) const;
QuicErrorCode GetUint16(QuicTag tag, uint16* out) const;
QuicErrorCode GetUint32(QuicTag tag, uint32* out) const;
QuicErrorCode GetUint64(QuicTag tag, uint64* out) const;
// size returns 4 (message tag) + 2 (uint16, number of entries) +
// (4 (tag) + 4 (end offset))*tag_value_map_.size() + ∑ value sizes.
size_t size() const;
// set_minimum_size sets the minimum number of bytes that the message should
// consume. The CryptoFramer will add a PAD tag as needed when serializing in
// order to ensure this. Setting a value of 0 disables padding.
//
// Padding is useful in order to ensure that messages are a minimum size. A
// QUIC server can require a minimum size in order to reduce the
// amplification factor of any mirror DoS attack.
void set_minimum_size(size_t min_bytes);
size_t minimum_size() const;
// DebugString returns a multi-line, string representation of the message
// suitable for including in debug output.
std::string DebugString() const;
private:
// GetPOD is a utility function for extracting a plain-old-data value. If
// |tag| exists in the message, and has a value of exactly |len| bytes then
// it copies |len| bytes of data into |out|. Otherwise |len| bytes at |out|
// are zeroed out.
//
// If used to copy integers then this assumes that the machine is
// little-endian.
QuicErrorCode GetPOD(QuicTag tag, void* out, size_t len) const;
std::string DebugStringInternal(size_t indent) const;
QuicTag tag_;
QuicTagValueMap tag_value_map_;
size_t minimum_size_;
// The serialized form of the handshake message. This member is constructed
// lasily.
mutable scoped_ptr<QuicData> serialized_;
};
} // namespace net
#endif // NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
|
