Resize IPC input buffer to fit the next message.

ipc/ipc_channel_reader_unittest.cc

 // Copyright 2015 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 "build/build_config.h"
 
+#include <limits>
 #include <set>
 
 #include "ipc/attachment_broker.h"
 #include "ipc/brokerable_attachment.h"
 #include "ipc/ipc_channel_reader.h"
 #include "ipc/placeholder_brokerable_attachment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if USE_ATTACHMENT_BROKER
 namespace IPC {
 namespace internal {
 
 namespace {
 
+#if USE_ATTACHMENT_BROKER
+
 class MockAttachment : public BrokerableAttachment {
  public:
   MockAttachment() {}
   MockAttachment(BrokerableAttachment::AttachmentId id)
       : BrokerableAttachment(id) {}
 
 #if defined(OS_POSIX)
   base::PlatformFile TakePlatformFile() override {
     return base::PlatformFile();
   }
@@ skipping 15 matching lines @@
   }
 
   bool OnMessageReceived(const Message& message) override { return false; }
 
   void AddAttachment(scoped_refptr<BrokerableAttachment> attachment) {
     get_attachments()->push_back(attachment);
     NotifyObservers(attachment->GetIdentifier());
   }
 };
 
+#endif  // USE_ATTACHMENT_BROKER
+
 class MockChannelReader : public ChannelReader {
  public:
   MockChannelReader()
       : ChannelReader(nullptr), last_dispatched_message_(nullptr) {}
 
   ReadState ReadData(char* buffer, int buffer_len, int* bytes_read) override {
     return READ_FAILED;
   }
 
   bool ShouldDispatchInputMessage(Message* msg) override { return true; }
@@ skipping 19 matching lines @@
 
   Message* get_last_dispatched_message() { return last_dispatched_message_; }
 
   void set_broker(AttachmentBroker* broker) { broker_ = broker; }
 
  private:
   Message* last_dispatched_message_;
   AttachmentBroker* broker_;
 };
 
+class ExposedMessage: public Message {
+ public:
+  using Message::Header;
+  using Message::header;
+};
+
 }  // namespace
 
+#if USE_ATTACHMENT_BROKER
+
 TEST(ChannelReaderTest, AttachmentAlreadyBrokered) {
   MockAttachmentBroker broker;
   MockChannelReader reader;
   reader.set_broker(&broker);
   scoped_refptr<MockAttachment> attachment(new MockAttachment);
   broker.AddAttachment(attachment);
 
   Message* m = new Message;
   PlaceholderBrokerableAttachment* needs_brokering_attachment =
       new PlaceholderBrokerableAttachment(attachment->GetIdentifier());
@@ skipping 15 matching lines @@
   EXPECT_TRUE(m->WriteAttachment(needs_brokering_attachment));
   reader.AddMessageForDispatch(m);
   EXPECT_EQ(ChannelReader::DISPATCH_WAITING_ON_BROKER,
             reader.DispatchMessages());
   EXPECT_EQ(nullptr, reader.get_last_dispatched_message());
 
   broker.AddAttachment(attachment);
   EXPECT_EQ(m, reader.get_last_dispatched_message());
 }
 
+#endif  // USE_ATTACHMENT_BROKER
+
+#if !USE_ATTACHMENT_BROKER

[Maria, 2015/09/25 22:23:00]

should we just do #else here? instead of another if?

[Dmitry Skiba, 2015/09/28 17:37:18]

The effect of #else will be the same, but it's just a matter of taste - I don't
like the implication (in my view) that #else branch is somehow related to #if
branch.

+
+// We can determine message size from its header (and hence resize the buffer)
+// only when attachment broker is not used, see IPC::Message::FindNext().
+
+TEST(ChannelReaderTest, ResizeOverflowBuffer) {
+  MockChannelReader reader;
+
+  ExposedMessage::Header header = {};
+
+  header.payload_size = 128 * 1024;
+  EXPECT_LT(reader.input_overflow_buf_.capacity(), header.payload_size);
+  EXPECT_TRUE(reader.TranslateInputData(
+      reinterpret_cast<const char*>(&header), sizeof(header)));
+
+  // Once message header is available we resize overflow buffer to
+  // fit the entire message.
+  EXPECT_GE(reader.input_overflow_buf_.capacity(), header.payload_size);
+}
+
+TEST(ChannelReaderTest, InvalidMessageSize) {
+  MockChannelReader reader;
+
+  ExposedMessage::Header header = {};
+
+  size_t capacity_before = reader.input_overflow_buf_.capacity();
+
+  // Message is slightly larger than maximum allowed size
+  header.payload_size = Channel::kMaximumMessageSize + 1;
+  EXPECT_FALSE(reader.TranslateInputData(
+      reinterpret_cast<const char*>(&header), sizeof(header)));
+  EXPECT_LE(reader.input_overflow_buf_.capacity(), capacity_before);
+
+  // Payload size is negative, overflow is detected by Pickle::PeekNext()
+  header.payload_size = static_cast<uint32_t>(-1);
+  EXPECT_FALSE(reader.TranslateInputData(
+      reinterpret_cast<const char*>(&header), sizeof(header)));
+  EXPECT_LE(reader.input_overflow_buf_.capacity(), capacity_before);
+
+  // Payload size is maximum int32 value
+  header.payload_size = std::numeric_limits<int32_t>::max();
+  EXPECT_FALSE(reader.TranslateInputData(
+      reinterpret_cast<const char*>(&header), sizeof(header)));
+  EXPECT_LE(reader.input_overflow_buf_.capacity(), capacity_before);
+}
+
+#endif  // !USE_ATTACHMENT_BROKER
+
 }  // namespace internal
 }  // namespace IPC
-#endif  // USE_ATTACHMENT_BROKER