Add FIDO U2F message and packet classes

device/u2f/u2f_message.cc

+// Copyright 2016 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 "device/u2f/u2f_message.h"
+#include "device/u2f/u2f_packet.h"
+
+namespace device {
+
+// static
+scoped_refptr<U2fMessage> U2fMessage::Create(const uint32_t channel_id,
+                                             const Type type,
+                                             const std::vector<uint8_t>& data) {
+  if (data.size() > kMaxMessageSize)
+    return nullptr;
+
+  return make_scoped_refptr(new U2fMessage(channel_id, type, data));
+}
+
+// static
+scoped_refptr<U2fMessage> U2fMessage::CreateFromSerializedData(
+    scoped_refptr<net::IOBufferWithSize> buf) {
+  if (buf == nullptr ||
+      static_cast<size_t>(buf->size()) > U2fPacket::kPacketSize ||
+      static_cast<size_t>(buf->size()) < kInitPacketHeader)
+    return nullptr;
+
+  return make_scoped_refptr(new U2fMessage(buf));
+}
+
+U2fMessage::U2fMessage(scoped_refptr<net::IOBufferWithSize> buf)
+    : packets_(), remaining_size_(0), channel_id_() {

[Reilly Grant (use Gerrit), 2016/12/09 20:55:20]

Initializing packets_ and channel_id_ is unnecessary.

[Casey Piper, 2016/12/09 21:43:38]

Acknowledged.

+  scoped_refptr<U2fInitPacket> init_packet =
+      U2fInitPacket::CreateFromSerializedData(buf, &remaining_size_);
+  channel_id_ = init_packet->channel_id();
+
+  packets_.push_back(init_packet);
+}
+
+U2fMessage::U2fMessage(const uint32_t channel_id,
+                       const Type type,
+                       const std::vector<uint8_t>& data)
+    : packets_(), remaining_size_(), channel_id_(channel_id) {
+  size_t remaining_bytes = data.size();
+  uint8_t sequence = 0;
+
+  std::vector<uint8_t>::const_iterator first = data.begin();
+  std::vector<uint8_t>::const_iterator last;
+
+  if (remaining_bytes > kInitPacketDataSize) {
+    last = data.begin() + kInitPacketDataSize;
+    remaining_bytes -= kInitPacketDataSize;
+  } else {
+    last = data.begin() + remaining_bytes;
+    remaining_bytes = 0;
+  }
+
+  packets_.push_back(make_scoped_refptr(
+      new U2fInitPacket(channel_id, static_cast<uint8_t>(type),
+                        std::vector<uint8_t>(first, last), data.size())));
+
+  while (remaining_bytes > 0) {
+    first = last;
+    if (remaining_bytes > kContinuationPacketDataSize) {
+      last = first + kContinuationPacketDataSize;
+      remaining_bytes -= kContinuationPacketDataSize;
+    } else {
+      last = first + remaining_bytes;
+      remaining_bytes = 0;
+    }
+
+    packets_.push_back(make_scoped_refptr(new U2fContinuationPacket(
+        channel_id, sequence, std::vector<uint8_t>(first, last))));
+    sequence++;
+  }
+}
+
+U2fMessage::~U2fMessage() {}
+
+std::list<scoped_refptr<U2fPacket>>::const_iterator U2fMessage::begin() {
+  return packets_.cbegin();
+}
+
+std::list<scoped_refptr<U2fPacket>>::const_iterator U2fMessage::end() {
+  return packets_.cend();
+}
+
+scoped_refptr<net::IOBufferWithSize> U2fMessage::PopNextPacket() {
+  if (NumPackets() > 0) {
+    scoped_refptr<net::IOBufferWithSize> buf =
+        packets_.front()->GetSerializedBuffer();
+    packets_.pop_front();
+    return buf;
+  }
+  return nullptr;
+}
+
+bool U2fMessage::AddContinuationPacket(
+    scoped_refptr<net::IOBufferWithSize> buf) {
+  size_t remaining_size = remaining_size_;
+  scoped_refptr<U2fContinuationPacket> cont_packet =
+      U2fContinuationPacket::CreateFromSerializedData(buf, &remaining_size_);

[Reilly Grant (use Gerrit), 2016/12/09 20:55:20]

I think you meant to pass remaining_size here.

[Casey Piper, 2016/12/09 21:43:38]

Done, good catch!

[Casey Piper, 2016/12/09 21:49:14]

Actually, I now realize I didn't, but I edited the logic slightly. What I'm
doing is if there is a failure (we received something with a different channel
ID), I revert back to the original remaining_size.

+
+  // Reject packets with a different channel id
+  if (channel_id_ != cont_packet->channel_id()) {
+    remaining_size_ = remaining_size;
+    return false;
+  }
+
+  packets_.push_back(cont_packet);
+  return true;
+}
+
+bool U2fMessage::MessageComplete() {
+  return remaining_size_ == 0;
+}
+
+std::vector<uint8_t> U2fMessage::GetMessagePayload() const {
+  std::vector<uint8_t> data;
+
+  for (const auto& packet : packets_) {
+    std::vector<uint8_t> packet_data = packet->GetPacketPayload();
+    data.insert(std::end(data), packet_data.cbegin(), packet_data.cend());
+  }
+
+  return data;
+}
+
+size_t U2fMessage::NumPackets() {
+  return packets_.size();
+}
+
+}  // namespace device