cast_framer_unittest.cc 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163
  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. #include "components/cast_channel/cast_framer.h"
  5. #include <stddef.h>
  6. #include <algorithm>
  7. #include <memory>
  8. #include <string>
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. #include "third_party/openscreen/src/cast/common/channel/proto/cast_channel.pb.h"
  11. namespace cast_channel {
  12. using ::cast_channel::ChannelError;
  13. class CastFramerTest : public testing::Test {
  14. public:
  15. CastFramerTest() {}
  16. ~CastFramerTest() override {}
  17. void SetUp() override {
  18. cast_message_.set_protocol_version(CastMessage::CASTV2_1_0);
  19. cast_message_.set_source_id("source");
  20. cast_message_.set_destination_id("destination");
  21. cast_message_.set_namespace_("namespace");
  22. cast_message_.set_payload_type(CastMessage::STRING);
  23. cast_message_.set_payload_utf8("payload");
  24. ASSERT_TRUE(MessageFramer::Serialize(cast_message_, &cast_message_str_));
  25. buffer_ = base::MakeRefCounted<net::GrowableIOBuffer>();
  26. buffer_->SetCapacity(MessageFramer::MessageHeader::max_message_size());
  27. framer_ = std::make_unique<MessageFramer>(buffer_.get());
  28. }
  29. void WriteToBuffer(const std::string& data) {
  30. memcpy(buffer_->StartOfBuffer(), data.data(), data.size());
  31. }
  32. protected:
  33. CastMessage cast_message_;
  34. std::string cast_message_str_;
  35. scoped_refptr<net::GrowableIOBuffer> buffer_;
  36. std::unique_ptr<MessageFramer> framer_;
  37. };
  38. TEST_F(CastFramerTest, TestMessageFramerCompleteMessage) {
  39. ChannelError error;
  40. size_t message_length;
  41. WriteToBuffer(cast_message_str_);
  42. // Receive 1 byte of the header, framer demands 3 more bytes.
  43. EXPECT_EQ(4u, framer_->BytesRequested());
  44. EXPECT_EQ(nullptr, framer_->Ingest(1, &message_length, &error).get());
  45. EXPECT_EQ(ChannelError::NONE, error);
  46. EXPECT_EQ(3u, framer_->BytesRequested());
  47. // Ingest remaining 3, expect that the framer has moved on to requesting the
  48. // body contents.
  49. EXPECT_EQ(nullptr, framer_->Ingest(3, &message_length, &error).get());
  50. EXPECT_EQ(ChannelError::NONE, error);
  51. EXPECT_EQ(
  52. cast_message_str_.size() - MessageFramer::MessageHeader::header_size(),
  53. framer_->BytesRequested());
  54. // Remainder of packet sent over the wire.
  55. std::unique_ptr<CastMessage> message;
  56. message = framer_->Ingest(framer_->BytesRequested(), &message_length, &error);
  57. EXPECT_NE(static_cast<CastMessage*>(nullptr), message.get());
  58. EXPECT_EQ(ChannelError::NONE, error);
  59. EXPECT_EQ(message->SerializeAsString(), cast_message_.SerializeAsString());
  60. EXPECT_EQ(4u, framer_->BytesRequested());
  61. EXPECT_EQ(message->SerializeAsString().size(), message_length);
  62. }
  63. TEST_F(CastFramerTest, TestSerializeErrorMessageTooLarge) {
  64. std::string serialized;
  65. CastMessage big_message;
  66. big_message.CopyFrom(cast_message_);
  67. std::string payload;
  68. payload.append(MessageFramer::MessageHeader::max_body_size() + 1, 'x');
  69. big_message.set_payload_utf8(payload);
  70. EXPECT_FALSE(MessageFramer::Serialize(big_message, &serialized));
  71. }
  72. TEST_F(CastFramerTest, TestIngestIllegalLargeMessage) {
  73. std::string mangled_cast_message = cast_message_str_;
  74. mangled_cast_message[0] = 88;
  75. mangled_cast_message[1] = 88;
  76. mangled_cast_message[2] = 88;
  77. mangled_cast_message[3] = 88;
  78. WriteToBuffer(mangled_cast_message);
  79. size_t bytes_ingested;
  80. ChannelError error;
  81. EXPECT_EQ(4u, framer_->BytesRequested());
  82. EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
  83. EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
  84. EXPECT_EQ(0u, framer_->BytesRequested());
  85. // Test that the parser enters a terminal error state.
  86. WriteToBuffer(cast_message_str_);
  87. EXPECT_EQ(0u, framer_->BytesRequested());
  88. EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
  89. EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
  90. EXPECT_EQ(0u, framer_->BytesRequested());
  91. }
  92. TEST_F(CastFramerTest, TestIngestIllegalLargeMessage2) {
  93. std::string mangled_cast_message = cast_message_str_;
  94. // Header indicates body size is 0x00010001 = 65537
  95. mangled_cast_message[0] = 0;
  96. mangled_cast_message[1] = 0x1;
  97. mangled_cast_message[2] = 0;
  98. mangled_cast_message[3] = 0x1;
  99. WriteToBuffer(mangled_cast_message);
  100. size_t bytes_ingested;
  101. ChannelError error;
  102. EXPECT_EQ(4u, framer_->BytesRequested());
  103. EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
  104. EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
  105. EXPECT_EQ(0u, framer_->BytesRequested());
  106. // Test that the parser enters a terminal error state.
  107. WriteToBuffer(cast_message_str_);
  108. EXPECT_EQ(0u, framer_->BytesRequested());
  109. EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
  110. EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
  111. EXPECT_EQ(0u, framer_->BytesRequested());
  112. }
  113. TEST_F(CastFramerTest, TestUnparsableBodyProto) {
  114. // Message header is OK, but the body is replaced with "x"en.
  115. std::string mangled_cast_message = cast_message_str_;
  116. for (size_t i = MessageFramer::MessageHeader::header_size();
  117. i < mangled_cast_message.size(); ++i) {
  118. std::fill(mangled_cast_message.begin() +
  119. MessageFramer::MessageHeader::header_size(),
  120. mangled_cast_message.end(), 'x');
  121. }
  122. WriteToBuffer(mangled_cast_message);
  123. // Send header.
  124. size_t message_length;
  125. ChannelError error;
  126. EXPECT_EQ(4u, framer_->BytesRequested());
  127. EXPECT_EQ(nullptr, framer_->Ingest(4, &message_length, &error).get());
  128. EXPECT_EQ(ChannelError::NONE, error);
  129. EXPECT_EQ(cast_message_str_.size() - 4, framer_->BytesRequested());
  130. // Send body, expect an error.
  131. std::unique_ptr<CastMessage> message;
  132. EXPECT_EQ(nullptr,
  133. framer_->Ingest(framer_->BytesRequested(), &message_length, &error)
  134. .get());
  135. EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
  136. }
  137. } // namespace cast_channel