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_HANDSHAKE_MESSAGE_H_
6#define NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
7
8#include <string>
9#include <vector>
10
11#include "base/memory/scoped_ptr.h"
12#include "base/strings/string_piece.h"
13#include "net/base/net_export.h"
14#include "net/quic/quic_protocol.h"
15
16namespace net {
17
18// An intermediate format of a handshake message that's convenient for a
19// CryptoFramer to serialize from or parse into.
20class NET_EXPORT_PRIVATE CryptoHandshakeMessage {
21 public:
22  CryptoHandshakeMessage();
23  CryptoHandshakeMessage(const CryptoHandshakeMessage& other);
24  ~CryptoHandshakeMessage();
25
26  CryptoHandshakeMessage& operator=(const CryptoHandshakeMessage& other);
27
28  // Clears state.
29  void Clear();
30
31  // GetSerialized returns the serialized form of this message and caches the
32  // result. Subsequently altering the message does not invalidate the cache.
33  const QuicData& GetSerialized() const;
34
35  // MarkDirty invalidates the cache created by |GetSerialized|.
36  void MarkDirty();
37
38  // SetValue sets an element with the given tag to the raw, memory contents of
39  // |v|.
40  template<class T> void SetValue(QuicTag tag, const T& v) {
41    tag_value_map_[tag] =
42        std::string(reinterpret_cast<const char*>(&v), sizeof(v));
43  }
44
45  // SetVector sets an element with the given tag to the raw contents of an
46  // array of elements in |v|.
47  template<class T> void SetVector(QuicTag tag, const std::vector<T>& v) {
48    if (v.empty()) {
49      tag_value_map_[tag] = std::string();
50    } else {
51      tag_value_map_[tag] = std::string(reinterpret_cast<const char*>(&v[0]),
52                                        v.size() * sizeof(T));
53    }
54  }
55
56  // Returns the message tag.
57  QuicTag tag() const { return tag_; }
58  // Sets the message tag.
59  void set_tag(QuicTag tag) { tag_ = tag; }
60
61  const QuicTagValueMap& tag_value_map() const { return tag_value_map_; }
62
63  // SetTaglist sets an element with the given tag to contain a list of tags,
64  // passed as varargs. The argument list must be terminated with a 0 element.
65  void SetTaglist(QuicTag tag, ...);
66
67  void SetStringPiece(QuicTag tag, base::StringPiece value);
68
69  // Erase removes a tag/value, if present, from the message.
70  void Erase(QuicTag tag);
71
72  // GetTaglist finds an element with the given tag containing zero or more
73  // tags. If such a tag doesn't exist, it returns false. Otherwise it sets
74  // |out_tags| and |out_len| to point to the array of tags and returns true.
75  // The array points into the CryptoHandshakeMessage and is valid only for as
76  // long as the CryptoHandshakeMessage exists and is not modified.
77  QuicErrorCode GetTaglist(QuicTag tag, const QuicTag** out_tags,
78                           size_t* out_len) const;
79
80  bool GetStringPiece(QuicTag tag, base::StringPiece* out) const;
81
82  // GetNthValue24 interprets the value with the given tag to be a series of
83  // 24-bit, length prefixed values and it returns the subvalue with the given
84  // index.
85  QuicErrorCode GetNthValue24(QuicTag tag,
86                              unsigned index,
87                              base::StringPiece* out) const;
88  QuicErrorCode GetUint16(QuicTag tag, uint16* out) const;
89  QuicErrorCode GetUint32(QuicTag tag, uint32* out) const;
90  QuicErrorCode GetUint64(QuicTag tag, uint64* out) const;
91
92  // size returns 4 (message tag) + 2 (uint16, number of entries) +
93  // (4 (tag) + 4 (end offset))*tag_value_map_.size() + ∑ value sizes.
94  size_t size() const;
95
96  // set_minimum_size sets the minimum number of bytes that the message should
97  // consume. The CryptoFramer will add a PAD tag as needed when serializing in
98  // order to ensure this. Setting a value of 0 disables padding.
99  //
100  // Padding is useful in order to ensure that messages are a minimum size. A
101  // QUIC server can require a minimum size in order to reduce the
102  // amplification factor of any mirror DoS attack.
103  void set_minimum_size(size_t min_bytes);
104
105  size_t minimum_size() const;
106
107  // DebugString returns a multi-line, string representation of the message
108  // suitable for including in debug output.
109  std::string DebugString() const;
110
111 private:
112  // GetPOD is a utility function for extracting a plain-old-data value. If
113  // |tag| exists in the message, and has a value of exactly |len| bytes then
114  // it copies |len| bytes of data into |out|. Otherwise |len| bytes at |out|
115  // are zeroed out.
116  //
117  // If used to copy integers then this assumes that the machine is
118  // little-endian.
119  QuicErrorCode GetPOD(QuicTag tag, void* out, size_t len) const;
120
121  std::string DebugStringInternal(size_t indent) const;
122
123  QuicTag tag_;
124  QuicTagValueMap tag_value_map_;
125
126  size_t minimum_size_;
127
128  // The serialized form of the handshake message. This member is constructed
129  // lasily.
130  mutable scoped_ptr<QuicData> serialized_;
131};
132
133}  // namespace net
134
135#endif  // NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
136