components/pairing/proto_decoder.cc

   1 // Copyright 2014 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 #include "components/pairing/proto_decoder.h"
   6
   7 #include "components/pairing/pairing_api.pb.h"
   8 #include "net/base/io_buffer.h"
   9
  10 namespace {
  11 enum {
  12   MESSAGE_NONE,
  13   MESSAGE_HOST_STATUS,
  14   MESSAGE_CONFIGURE_HOST,
  15   MESSAGE_PAIR_DEVICES,
  16   MESSAGE_COMPLETE_SETUP,
  17   MESSAGE_ERROR,
  18   NUM_MESSAGES,
  19 };
  20 }
  21
  22 namespace pairing_chromeos {
  23
  24 ProtoDecoder::ProtoDecoder(Observer* observer)
  25     : observer_(observer),
  26       next_message_type_(MESSAGE_NONE),
  27       next_message_size_(0) {
  28   DCHECK(observer_);
  29 }
  30
  31 ProtoDecoder::~ProtoDecoder() {}
  32
  33 bool ProtoDecoder::DecodeIOBuffer(int size,
  34                                   ProtoDecoder::IOBufferRefPtr io_buffer) {
  35   // Update the message buffer.
  36   message_buffer_.AddIOBuffer(io_buffer, size);
  37
  38   // If there is no current message, the next byte is the message type.
  39   if (next_message_type_ == MESSAGE_NONE) {
  40     if (message_buffer_.AvailableBytes() < static_cast<int>(sizeof(uint8_t)))
  41       return true;
  42
  43     uint8_t message_type = MESSAGE_NONE;
  44     message_buffer_.ReadBytes(reinterpret_cast<char*>(&message_type),
  45                                sizeof(message_type));
  46
  47     if (message_type == MESSAGE_NONE || message_type >= NUM_MESSAGES) {
  48       LOG(ERROR) << "Unknown message type received: " << message_type;
  49       return false;
  50     }
  51     next_message_type_ = message_type;
  52   }
  53
  54   // If the message size isn't set, the next two bytes are the message size.
  55   if (next_message_size_ == 0) {
  56     if (message_buffer_.AvailableBytes() < static_cast<int>(sizeof(uint16_t)))
  57       return true;
  58
  59     // The size is sent in network byte order.
  60     uint8_t high_byte = 0;
  61     message_buffer_.ReadBytes(reinterpret_cast<char*>(&high_byte),
  62                                sizeof(high_byte));
  63     uint8_t low_byte = 0;
  64     message_buffer_.ReadBytes(reinterpret_cast<char*>(&low_byte),
  65                                sizeof(low_byte));
  66
  67     next_message_size_ = (high_byte << 8) + low_byte;
  68   }
  69
  70   // If the whole proto buffer is not yet available, return early.
  71   if (message_buffer_.AvailableBytes() < next_message_size_)
  72     return true;
  73
  74   std::vector<char> buffer(next_message_size_);
  75   message_buffer_.ReadBytes(&buffer[0], next_message_size_);
  76
  77   switch (next_message_type_) {
  78     case MESSAGE_HOST_STATUS: {
  79         pairing_api::HostStatus message;
  80         message.ParseFromArray(&buffer[0], buffer.size());
  81         observer_->OnHostStatusMessage(message);
  82       }
  83       break;
  84     case MESSAGE_CONFIGURE_HOST: {
  85         pairing_api::ConfigureHost message;
  86         message.ParseFromArray(&buffer[0], buffer.size());
  87         observer_->OnConfigureHostMessage(message);
  88       }
  89       break;
  90     case MESSAGE_PAIR_DEVICES: {
  91         pairing_api::PairDevices message;
  92         message.ParseFromArray(&buffer[0], buffer.size());
  93         observer_->OnPairDevicesMessage(message);
  94       }
  95       break;
  96     case MESSAGE_COMPLETE_SETUP: {
  97         pairing_api::CompleteSetup message;
  98         message.ParseFromArray(&buffer[0], buffer.size());
  99         observer_->OnCompleteSetupMessage(message);
 100       }
 101       break;
 102     case MESSAGE_ERROR: {
 103         pairing_api::Error message;
 104         message.ParseFromArray(&buffer[0], buffer.size());
 105         observer_->OnErrorMessage(message);
 106       }
 107       break;
 108
 109     default:
 110       NOTREACHED();
 111       break;
 112   }
 113
 114   // Reset the message data.
 115   next_message_type_ = MESSAGE_NONE;
 116   next_message_size_ = 0;
 117
 118   return true;
 119 }
 120
 121 ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendHostStatus(
 122     const pairing_api::HostStatus& message, int* size) {
 123   std::string serialized_proto;
 124   if (!message.SerializeToString(&serialized_proto)) {
 125     NOTREACHED();
 126   }
 127
 128   return SendMessage(MESSAGE_HOST_STATUS, serialized_proto, size);
 129 }
 130
 131 ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendConfigureHost(
 132     const pairing_api::ConfigureHost& message, int* size) {
 133   std::string serialized_proto;
 134   if (!message.SerializeToString(&serialized_proto)) {
 135     NOTREACHED();
 136   }
 137
 138   return SendMessage(MESSAGE_CONFIGURE_HOST, serialized_proto, size);
 139 }
 140
 141 ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendPairDevices(
 142     const pairing_api::PairDevices& message, int* size) {
 143   std::string serialized_proto;
 144   if (!message.SerializeToString(&serialized_proto)) {
 145     NOTREACHED();
 146   }
 147
 148   return SendMessage(MESSAGE_PAIR_DEVICES, serialized_proto, size);
 149 }
 150
 151 ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendCompleteSetup(
 152     const pairing_api::CompleteSetup& message, int* size) {
 153   std::string serialized_proto;
 154   if (!message.SerializeToString(&serialized_proto)) {
 155     NOTREACHED();
 156   }
 157
 158   return SendMessage(MESSAGE_COMPLETE_SETUP, serialized_proto, size);
 159 }
 160
 161 ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendError(
 162     const pairing_api::Error& message, int* size) {
 163   std::string serialized_proto;
 164   if (!message.SerializeToString(&serialized_proto)) {
 165     NOTREACHED();
 166   }
 167
 168   return SendMessage(MESSAGE_ERROR, serialized_proto, size);
 169 }
 170
 171 ProtoDecoder::IOBufferRefPtr ProtoDecoder::SendMessage(
 172     uint8_t message_type,
 173     const std::string& message,
 174     int* size) {
 175   uint16_t message_size = message.size();
 176
 177   *size = sizeof(message_type) + sizeof(message_size) + message.size();
 178   IOBufferRefPtr io_buffer(new net::IOBuffer(*size));
 179
 180   // Write the message type.
 181   int offset = 0;
 182   memcpy(&io_buffer->data()[offset], &message_type, sizeof(message_type));
 183   offset += sizeof(message_type);
 184
 185   // Network byte order.
 186   // Write the high byte of the size.
 187   uint8_t data = (message_size >> 8) & 0xFF;
 188   memcpy(&io_buffer->data()[offset], &data, sizeof(data));
 189   offset += sizeof(data);
 190   // Write the low byte of the size.
 191   data = message_size & 0xFF;
 192   memcpy(&io_buffer->data()[offset], &data, sizeof(data));
 193   offset += sizeof(data);
 194
 195   // Write the actual message.
 196   memcpy(&io_buffer->data()[offset], message.data(), message.size());
 197
 198   return io_buffer;
 199 }
 200
 201 }  // namespace pairing_chromeos