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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
// Copyright (c) 2012 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_WEBSOCKETS_WEBSOCKET_FRAME_H_
#define NET_WEBSOCKETS_WEBSOCKET_FRAME_H_
#include <vector>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
namespace net {
class IOBuffer;
class IOBufferWithSize;
// Represents a WebSocket frame header.
//
// Members of this class correspond to each element in WebSocket frame header
// (see http://tools.ietf.org/html/rfc6455#section-5.2).
struct NET_EXPORT WebSocketFrameHeader {
typedef int OpCode;
// Originally these constants were static const int, but to make it possible
// to use them in a switch statement they were changed to an enum.
enum OpCodeEnum {
kOpCodeContinuation = 0x0,
kOpCodeText = 0x1,
kOpCodeBinary = 0x2,
kOpCodeDataUnused = 0x3,
kOpCodeClose = 0x8,
kOpCodePing = 0x9,
kOpCodePong = 0xA,
kOpCodeControlUnused = 0xB,
};
// Return true if |opcode| is one of the data opcodes known to this
// implementation.
static bool IsKnownDataOpCode(OpCode opcode) {
return opcode == kOpCodeContinuation || opcode == kOpCodeText ||
opcode == kOpCodeBinary;
}
// Return true if |opcode| is one of the control opcodes known to this
// implementation.
static bool IsKnownControlOpCode(OpCode opcode) {
return opcode == kOpCodeClose || opcode == kOpCodePing ||
opcode == kOpCodePong;
}
// These values must be a compile-time constant. "enum hack" is used here
// to make MSVC happy.
enum {
kBaseHeaderSize = 2,
kMaximumExtendedLengthSize = 8,
kMaskingKeyLength = 4
};
// Constructor to avoid a lot of repetitive initialisation.
explicit WebSocketFrameHeader(OpCode opCode)
: final(false),
reserved1(false),
reserved2(false),
reserved3(false),
opcode(opCode),
masked(false),
payload_length(0) {}
// Create a clone of this object on the heap.
scoped_ptr<WebSocketFrameHeader> Clone() const;
// Overwrite this object with the fields from |source|.
void CopyFrom(const WebSocketFrameHeader& source);
// Members below correspond to each item in WebSocket frame header.
// See <http://tools.ietf.org/html/rfc6455#section-5.2> for details.
bool final;
bool reserved1;
bool reserved2;
bool reserved3;
OpCode opcode;
bool masked;
uint64 payload_length;
private:
DISALLOW_COPY_AND_ASSIGN(WebSocketFrameHeader);
};
// Contains an entire WebSocket frame including payload. This is used by APIs
// that are not concerned about retaining the original frame boundaries (because
// frames may need to be split in order for the data to fit in memory).
struct NET_EXPORT_PRIVATE WebSocketFrame {
// A frame must always have an opcode, so this parameter is compulsory.
explicit WebSocketFrame(WebSocketFrameHeader::OpCode opcode);
~WebSocketFrame();
// |header| is always present.
WebSocketFrameHeader header;
// |data| is always unmasked even if the frame is masked. The size of |data|
// is given by |header.payload_length|.
scoped_refptr<IOBuffer> data;
};
// Structure describing one chunk of a WebSocket frame.
//
// The payload of a WebSocket frame may be divided into multiple chunks.
// You need to look at |final_chunk| member variable to detect the end of a
// series of chunk objects of a WebSocket frame.
//
// Frame dissection is necessary to handle frames that are too large to store in
// the browser memory without losing information about the frame boundaries. In
// practice, most code does not need to worry about the original frame
// boundaries and can use the WebSocketFrame type declared above.
//
// Users of this struct should treat WebSocket frames as a data stream; it's
// important to keep the frame data flowing, especially in the browser process.
// Users should not let the data stuck somewhere in the pipeline.
//
// This struct is used for reading WebSocket frame data (created by
// WebSocketFrameParser). To construct WebSocket frames, use functions below.
struct NET_EXPORT WebSocketFrameChunk {
WebSocketFrameChunk();
~WebSocketFrameChunk();
// Non-null |header| is provided only if this chunk is the first part of
// a series of chunks.
scoped_ptr<WebSocketFrameHeader> header;
// Indicates this part is the last chunk of a frame.
bool final_chunk;
// |data| is always unmasked even if the frame is masked. |data| might be
// null in the first chunk.
scoped_refptr<IOBufferWithSize> data;
};
// Contains four-byte data representing "masking key" of WebSocket frames.
struct WebSocketMaskingKey {
char key[WebSocketFrameHeader::kMaskingKeyLength];
};
// Returns the size of WebSocket frame header. The size of WebSocket frame
// header varies from 2 bytes to 14 bytes depending on the payload length
// and maskedness.
NET_EXPORT int GetWebSocketFrameHeaderSize(const WebSocketFrameHeader& header);
// Writes wire format of a WebSocket frame header into |output|, and returns
// the number of bytes written.
//
// WebSocket frame format is defined at:
// <http://tools.ietf.org/html/rfc6455#section-5.2>. This function writes
// everything but payload data in a WebSocket frame to |buffer|.
//
// If |header->masked| is true, |masking_key| must point to a valid
// WebSocketMaskingKey object containing the masking key for that frame
// (possibly generated by GenerateWebSocketMaskingKey() function below).
// Otherwise, |masking_key| must be NULL.
//
// |buffer| should have enough size to contain the frame header.
// GetWebSocketFrameHeaderSize() can be used to know the size of header
// beforehand. If the size of |buffer| is insufficient, this function returns
// ERR_INVALID_ARGUMENT and does not write any data to |buffer|.
NET_EXPORT int WriteWebSocketFrameHeader(const WebSocketFrameHeader& header,
const WebSocketMaskingKey* masking_key,
char* buffer,
int buffer_size);
// Generates a masking key suitable for use in a new WebSocket frame.
NET_EXPORT WebSocketMaskingKey GenerateWebSocketMaskingKey();
// Masks WebSocket frame payload.
//
// A client must mask every WebSocket frame by XOR'ing the frame payload
// with four-byte random data (masking key). This function applies the masking
// to the given payload data.
//
// This function masks |data| with |masking_key|, assuming |data| is partial
// data starting from |frame_offset| bytes from the beginning of the payload
// data.
//
// Since frame masking is a reversible operation, this function can also be
// used for unmasking a WebSocket frame.
NET_EXPORT void MaskWebSocketFramePayload(
const WebSocketMaskingKey& masking_key,
uint64 frame_offset,
char* data,
int data_size);
} // namespace net
#endif // NET_WEBSOCKETS_WEBSOCKET_FRAME_H_
|
