dbus: add support for passing file descriptors

dbus/message_unittest.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 "dbus/message.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "dbus/object_path.h"
@@ skipping 22 matching lines @@
 
   // Try to get another byte. Should fail.
   ASSERT_FALSE(reader.PopByte(&byte_value));
 }
 
 // Check all basic types can be properly written and read.
 TEST(MessageTest, AppendAndPopBasicDataTypes) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
 
-  // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
+  // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path", stdout.

[satorux1, 2012/03/28 20:49:37]

nit: remove ", stdout"

[Sam Leffler, 2012/03/28 22:06:33]

Done.

   writer.AppendByte(0);
   writer.AppendBool(true);
   writer.AppendInt16(2);
   writer.AppendUint16(3);
   writer.AppendInt32(4);
   writer.AppendUint32(5);
   writer.AppendInt64(6);
   writer.AppendUint64(7);
   writer.AppendDouble(8.0);
   writer.AppendString("string");
@@ skipping 33 matching lines @@
   EXPECT_EQ(3U, uint16_value);
   EXPECT_EQ(4, int32_value);
   EXPECT_EQ(5U, uint32_value);
   EXPECT_EQ(6, int64_value);
   EXPECT_EQ(7U, uint64_value);
   EXPECT_DOUBLE_EQ(8.0, double_value);
   EXPECT_EQ("string", string_value);
   EXPECT_EQ(dbus::ObjectPath("/object/path"), object_path_value);
 }
 
+// Check all basic types can be properly written and read.
+TEST(MessageTest, AppendAndPopFileDescriptor) {
+  if (!dbus::kDBusTypeUnixFdIsSupported)
+    return;

[satorux1, 2012/03/28 20:49:37]

Could you add some logging like

if (!dbus::kDBusTypeUnixFdIsSupported) {
  LOG(WARNING) << "FD passing is not supported";
  return;
}

so we can tell if the test is run or not.

[Sam Leffler, 2012/03/28 22:06:33]

Done.

+
+  scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(message.get());
+
+  // Append stdout.
+  dbus::FileDescriptor temp(1);
+  writer.AppendFileDescriptor(temp);
+
+  dbus::FileDescriptor fd_value;
+
+  dbus::MessageReader reader(message.get());
+  ASSERT_TRUE(reader.HasMoreData());
+  ASSERT_TRUE(reader.PopFileDescriptor(&fd_value));
+  ASSERT_FALSE(reader.HasMoreData());
+
+  // stdout should be returned.
+  // TODO(sleffler) need to fstat each fd to compare

[keybuk, 2012/03/28 20:41:30]

This should be trivial enough, fstat will get you a matching rdev right? Worth
doing before committing so the test tests the right thing

[satorux1, 2012/03/28 20:49:37]

Why cannot we do EXPECT_EQ(1, fd_value.value())?

Here, we are just storing 1 in DBusMessage and popping from it. 

I thought dbus_message_iter_append_basic() and dbus_message_iter_get_basic()
just preserved 1 as-is, but I may be wrong. I didn't check the implementation.

Would be nice to leave some comment why we are not checking fd_value.value()
here.

[keybuk, 2012/03/28 20:56:18]

No, dbus calls dup() all over the place like crazy on those fds so it can deal
with ownership in its own way

It may be that it comes out as 1, but that might be just by luck on some phases
of the moon (and it didn't when I tested here with a debug version of dbus).

[satorux1, 2012/03/28 21:09:32]

Then, we need some comment about it. :)

[Sam Leffler, 2012/03/28 22:06:33]

Implemented the test case.  I used fstat calls which I assume are ok since this
code is only built on posix systems.  If not then we'll need to figure out a way
to #ifdef the code (since we can't use DBUS_TYPE_UNIX_FD).

[satorux1, 2012/03/28 22:20:41]

No need to worry about #ifdef. This only compiles for Linux and Chrome OS.

+}
+
 // Check all variant types can be properly written and read.
 TEST(MessageTest, AppendAndPopVariantDataTypes) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
 
   // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
   writer.AppendVariantOfByte(0);
   writer.AppendVariantOfBool(true);
   writer.AppendVariantOfInt16(2);
   writer.AppendVariantOfUint16(3);
@@ skipping 426 matching lines @@
 
   EXPECT_EQ("org.chromium.destination", message->GetDestination());
   EXPECT_EQ(dbus::ObjectPath("/org/chromium/path"), message->GetPath());
   EXPECT_EQ("org.chromium.interface", message->GetInterface());
   EXPECT_EQ("member", message->GetMember());
   EXPECT_EQ("org.chromium.error", message->GetErrorName());
   EXPECT_EQ(":1.2", message->GetSender());
   EXPECT_EQ(123U, message->GetSerial());
   EXPECT_EQ(456U, message->GetReplySerial());
 }