Add functions used for building WebSocket frame data.

net/websockets/websocket_frame.cc

 // 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.
 
 #include "net/websockets/websocket_frame.h"
 
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/rand_util.h"
+#include "net/base/big_endian.h"
+
+namespace {
+
+const uint8 kFinalBit = 0x80;
+const uint8 kReserved1Bit = 0x40;
+const uint8 kReserved2Bit = 0x20;
+const uint8 kReserved3Bit = 0x10;
+const uint8 kOpCodeMask = 0xF;
+const uint8 kMaskBit = 0x80;
+const uint64 kMaxPayloadLengthWithoutExtendedLengthField = 125;
+const uint64 kPayloadLengthWithTwoByteExtendedLengthField = 126;
+const uint64 kPayloadLengthWithEightByteExtendedLengthField = 127;
+
+}  // Unnamed namespace.
+
 namespace net {
 
 // Definitions for in-struct constants.
 const WebSocketFrameHeader::OpCode WebSocketFrameHeader::kOpCodeContinuation =
     0x0;
 const WebSocketFrameHeader::OpCode WebSocketFrameHeader::kOpCodeText = 0x1;
 const WebSocketFrameHeader::OpCode WebSocketFrameHeader::kOpCodeBinary = 0x2;
 const WebSocketFrameHeader::OpCode WebSocketFrameHeader::kOpCodeClose = 0x8;
 const WebSocketFrameHeader::OpCode WebSocketFrameHeader::kOpCodePing = 0x9;
 const WebSocketFrameHeader::OpCode WebSocketFrameHeader::kOpCodePong = 0xA;

[mmenke, 2012/05/21 15:08:37]

Seems like web_socket.cc should be using these.  Suggest sharing the other
constants as well.

[Yuta Kitamura, 2012/05/22 10:29:35]

Will do in another change, because web_socket.cc is owned by other folks
(devtools people).

[mmenke, 2012/05/22 17:12:41]

Sorry about that, I actually meant what you landed last time -
net/websockets/websocket_frame_parser.cc

[Yuta Kitamura, 2012/06/06 18:06:47]

OK, but I realized that this cleanup causes many diffs and I'd like to do in a
separate patch.

 
 WebSocketFrameChunk::WebSocketFrameChunk() : final_chunk(false) {
 }
 
 WebSocketFrameChunk::~WebSocketFrameChunk() {
 }
 
+void WriteWebSocketFrameHeader(const WebSocketFrameHeader* header,
+                               const char* masking_key,
+                               std::vector<char>* output) {

[willchan no longer on Chromium, 2012/05/21 19:19:52]

I think this interface is not correct. The use of std::vector<char>* as an
output param gives the buffer allocation responsibility to
WriteWebSocketFrameHeader, whereas I believe, for optimal performance, it's
necessary to burden the caller with it.

[Yuta Kitamura, 2012/05/22 10:29:35]

The problem here is the header size varies (2 - 14 bytes). I don't think of a
good solution to this... I think GrowableIOBuffer is as bad as vector.

+  DCHECK(header);
+  DCHECK((header->opcode & kOpCodeMask) == header->opcode)
+      << "header->opcode must fit to kOpCodeMask.";
+  DCHECK(header->payload_length <= static_cast<uint64>(kint64max))
+      << "WebSocket specification doesn't allow a frame longer than "
+      << "kint64max (0x7FFFFFFFFFFFFFFF) bytes.";
+
+  // WebSocket frame format is as follows:
+  // - Common header (2 bytes)
+  // - Optional extended payload length
+  //   (2 or 8 bytes, present if actual payload length is more than 125 bytes)
+  // - Optional masking key (4 bytes, present if MASK bit is on)
+  // - Actual payload (XOR masked with masking key if MASK bit is on)
+  //
+  // This function constructs frame header (the first three in the list
+  // above).
+
+  uint8 first_byte = 0u;
+  first_byte |= header->final ? kFinalBit : 0u;
+  first_byte |= header->reserved1 ? kReserved1Bit : 0u;
+  first_byte |= header->reserved2 ? kReserved2Bit : 0u;
+  first_byte |= header->reserved3 ? kReserved3Bit : 0u;
+  first_byte |= header->opcode;
+
+  uint8 second_byte = 0u;
+  second_byte |= header->masked ? kMaskBit : 0u;
+  if (header->payload_length <=
+      kMaxPayloadLengthWithoutExtendedLengthField) {
+    second_byte |= header->payload_length;
+  } else if (header->payload_length <= kuint16max) {
+    second_byte |= kPayloadLengthWithTwoByteExtendedLengthField;
+  } else {
+    second_byte |= kPayloadLengthWithEightByteExtendedLengthField;
+  }
+
+  output->push_back(first_byte);
+  output->push_back(second_byte);
+
+  // Writes "extended payload length" field.
+  if (header->payload_length > kMaxPayloadLengthWithoutExtendedLengthField &&
+      header->payload_length <= kuint16max) {
+    uint16 payload_length_16 = static_cast<uint16>(header->payload_length);
+    char encoded[sizeof(uint16)];
+    WriteBigEndian(encoded, payload_length_16);
+    output->insert(output->end(), encoded, encoded + sizeof(uint16));
+  } else if (header->payload_length > kuint16max) {
+    char encoded[sizeof(uint64)];
+    WriteBigEndian(encoded, header->payload_length);
+    output->insert(output->end(), encoded, encoded + sizeof(uint64));
+  }
+
+  // Writes "masking key" field, if needed.
+  if (header->masked) {
+    DCHECK(masking_key);
+    output->insert(output->end(), masking_key,
+                   masking_key + WebSocketFrameHeader::kMaskingKeyLength);
+  } else {
+    DCHECK(!masking_key);
+  }
+}
+
+void GenerateWebSocketMaskingKey(char* masking_key) {
+  // Masking keys should be generated from a cryptographically secure random
+  // number generator, which means web application authors should not be able
+  // to guess the next value of masking key.
+  base::RandBytes(masking_key, WebSocketFrameHeader::kMaskingKeyLength);
+}
+
+void MaskWebSocketFramePayload(const char* masking_key,
+                               uint64 frame_offset,
+                               std::vector<char>* frame_data) {
+  static const size_t kMaskingKeyLength =
+      WebSocketFrameHeader::kMaskingKeyLength;
+
+  // TODO(yutak): Make masking more efficient by XOR'ing every machine word
+  // (4 or 8 bytes), instead of XOR'ing every byte.
+  size_t masking_key_offset = frame_offset % kMaskingKeyLength;
+  for (std::vector<char>::iterator iter = frame_data->begin();
+       iter != frame_data->end(); ++iter) {
+    *iter ^= masking_key[masking_key_offset++];
+    if (masking_key_offset == kMaskingKeyLength)
+      masking_key_offset = 0;
+  }
+}
+
 }  // namespace net