net/socket/unix_domain_socket_posix_unittest.cc

   1 // Copyright (c) 2012 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 <errno.h>
   6 #include <fcntl.h>
   7 #include <poll.h>
   8 #include <sys/socket.h>
   9 #include <sys/stat.h>
  10 #include <sys/time.h>
  11 #include <sys/types.h>
  12 #include <sys/un.h>
  13 #include <unistd.h>
  14
  15 #include <cstring>
  16 #include <queue>
  17 #include <string>
  18
  19 #include "base/bind.h"
  20 #include "base/callback.h"
  21 #include "base/compiler_specific.h"
  22 #include "base/file_util.h"
  23 #include "base/files/file_path.h"
  24 #include "base/memory/ref_counted.h"
  25 #include "base/memory/scoped_ptr.h"
  26 #include "base/message_loop/message_loop.h"
  27 #include "base/posix/eintr_wrapper.h"
  28 #include "base/synchronization/condition_variable.h"
  29 #include "base/synchronization/lock.h"
  30 #include "base/threading/platform_thread.h"
  31 #include "base/threading/thread.h"
  32 #include "net/socket/socket_descriptor.h"
  33 #include "net/socket/unix_domain_socket_posix.h"
  34 #include "testing/gtest/include/gtest/gtest.h"
  35
  36 using std::queue;
  37 using std::string;
  38
  39 namespace net {
  40 namespace {
  41
  42 const char kSocketFilename[] = "unix_domain_socket_for_testing";
  43 const char kInvalidSocketPath[] = "/invalid/path";
  44 const char kMsg[] = "hello";
  45
  46 enum EventType {
  47   EVENT_ACCEPT,
  48   EVENT_AUTH_DENIED,
  49   EVENT_AUTH_GRANTED,
  50   EVENT_CLOSE,
  51   EVENT_LISTEN,
  52   EVENT_READ,
  53 };
  54
  55 string MakeSocketPath(const string& socket_file_name) {
  56   base::FilePath temp_dir;
  57   base::GetTempDir(&temp_dir);
  58   return temp_dir.Append(socket_file_name).value();
  59 }
  60
  61 string MakeSocketPath() {
  62   return MakeSocketPath(kSocketFilename);
  63 }
  64
  65 class EventManager : public base::RefCounted<EventManager> {
  66  public:
  67   EventManager() : condition_(&mutex_) {}
  68
  69   bool HasPendingEvent() {
  70     base::AutoLock lock(mutex_);
  71     return !events_.empty();
  72   }
  73
  74   void Notify(EventType event) {
  75     base::AutoLock lock(mutex_);
  76     events_.push(event);
  77     condition_.Broadcast();
  78   }
  79
  80   EventType WaitForEvent() {
  81     base::AutoLock lock(mutex_);
  82     while (events_.empty())
  83       condition_.Wait();
  84     EventType event = events_.front();
  85     events_.pop();
  86     return event;
  87   }
  88
  89  private:
  90   friend class base::RefCounted<EventManager>;
  91   virtual ~EventManager() {}
  92
  93   queue<EventType> events_;
  94   base::Lock mutex_;
  95   base::ConditionVariable condition_;
  96 };
  97
  98 class TestListenSocketDelegate : public StreamListenSocket::Delegate {
  99  public:
 100   explicit TestListenSocketDelegate(
 101       const scoped_refptr<EventManager>& event_manager)
 102       : event_manager_(event_manager) {}
 103
 104   virtual void DidAccept(StreamListenSocket* server,
 105                          scoped_ptr<StreamListenSocket> connection) OVERRIDE {
 106     LOG(ERROR) << __PRETTY_FUNCTION__;
 107     connection_ = connection.Pass();
 108     Notify(EVENT_ACCEPT);
 109   }
 110
 111   virtual void DidRead(StreamListenSocket* connection,
 112                        const char* data,
 113                        int len) OVERRIDE {
 114     {
 115       base::AutoLock lock(mutex_);
 116       DCHECK(len);
 117       data_.assign(data, len - 1);
 118     }
 119     Notify(EVENT_READ);
 120   }
 121
 122   virtual void DidClose(StreamListenSocket* sock) OVERRIDE {
 123     Notify(EVENT_CLOSE);
 124   }
 125
 126   void OnListenCompleted() {
 127     Notify(EVENT_LISTEN);
 128   }
 129
 130   string ReceivedData() {
 131     base::AutoLock lock(mutex_);
 132     return data_;
 133   }
 134
 135  private:
 136   void Notify(EventType event) {
 137     event_manager_->Notify(event);
 138   }
 139
 140   const scoped_refptr<EventManager> event_manager_;
 141   scoped_ptr<StreamListenSocket> connection_;
 142   base::Lock mutex_;
 143   string data_;
 144 };
 145
 146 bool UserCanConnectCallback(
 147     bool allow_user, const scoped_refptr<EventManager>& event_manager,
 148     uid_t, gid_t) {
 149   event_manager->Notify(
 150       allow_user ? EVENT_AUTH_GRANTED : EVENT_AUTH_DENIED);
 151   return allow_user;
 152 }
 153
 154 class UnixDomainSocketTestHelper : public testing::Test {
 155  public:
 156   void CreateAndListen() {
 157     socket_ = UnixDomainSocket::CreateAndListen(
 158         file_path_.value(), socket_delegate_.get(), MakeAuthCallback());
 159     socket_delegate_->OnListenCompleted();
 160   }
 161
 162  protected:
 163   UnixDomainSocketTestHelper(const string& path, bool allow_user)
 164       : file_path_(path),
 165         allow_user_(allow_user) {}
 166
 167   virtual void SetUp() OVERRIDE {
 168     event_manager_ = new EventManager();
 169     socket_delegate_.reset(new TestListenSocketDelegate(event_manager_));
 170     DeleteSocketFile();
 171   }
 172
 173   virtual void TearDown() OVERRIDE {
 174     DeleteSocketFile();
 175     socket_.reset();
 176     socket_delegate_.reset();
 177     event_manager_ = NULL;
 178   }
 179
 180   UnixDomainSocket::AuthCallback MakeAuthCallback() {
 181     return base::Bind(&UserCanConnectCallback, allow_user_, event_manager_);
 182   }
 183
 184   void DeleteSocketFile() {
 185     ASSERT_FALSE(file_path_.empty());
 186     base::DeleteFile(file_path_, false /* not recursive */);
 187   }
 188
 189   SocketDescriptor CreateClientSocket() {
 190     const SocketDescriptor sock = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0);
 191     if (sock < 0) {
 192       LOG(ERROR) << "socket() error";
 193       return kInvalidSocket;
 194     }
 195     sockaddr_un addr;
 196     memset(&addr, 0, sizeof(addr));
 197     addr.sun_family = AF_UNIX;
 198     socklen_t addr_len;
 199     strncpy(addr.sun_path, file_path_.value().c_str(), sizeof(addr.sun_path));
 200     addr_len = sizeof(sockaddr_un);
 201     if (connect(sock, reinterpret_cast<sockaddr*>(&addr), addr_len) != 0) {
 202       LOG(ERROR) << "connect() error";
 203       return kInvalidSocket;
 204     }
 205     return sock;
 206   }
 207
 208   scoped_ptr<base::Thread> CreateAndRunServerThread() {
 209     base::Thread::Options options;
 210     options.message_loop_type = base::MessageLoop::TYPE_IO;
 211     scoped_ptr<base::Thread> thread(new base::Thread("socketio_test"));
 212     thread->StartWithOptions(options);
 213     thread->message_loop()->PostTask(
 214         FROM_HERE,
 215         base::Bind(&UnixDomainSocketTestHelper::CreateAndListen,
 216                    base::Unretained(this)));
 217     return thread.Pass();
 218   }
 219
 220   const base::FilePath file_path_;
 221   const bool allow_user_;
 222   scoped_refptr<EventManager> event_manager_;
 223   scoped_ptr<TestListenSocketDelegate> socket_delegate_;
 224   scoped_ptr<UnixDomainSocket> socket_;
 225 };
 226
 227 class UnixDomainSocketTest : public UnixDomainSocketTestHelper {
 228  protected:
 229   UnixDomainSocketTest()
 230       : UnixDomainSocketTestHelper(MakeSocketPath(), true /* allow user */) {}
 231 };
 232
 233 class UnixDomainSocketTestWithInvalidPath : public UnixDomainSocketTestHelper {
 234  protected:
 235   UnixDomainSocketTestWithInvalidPath()
 236       : UnixDomainSocketTestHelper(kInvalidSocketPath, true) {}
 237 };
 238
 239 class UnixDomainSocketTestWithForbiddenUser
 240     : public UnixDomainSocketTestHelper {
 241  protected:
 242   UnixDomainSocketTestWithForbiddenUser()
 243       : UnixDomainSocketTestHelper(MakeSocketPath(), false /* forbid user */) {}
 244 };
 245
 246 TEST_F(UnixDomainSocketTest, CreateAndListen) {
 247   CreateAndListen();
 248   EXPECT_FALSE(socket_.get() == NULL);
 249 }
 250
 251 TEST_F(UnixDomainSocketTestWithInvalidPath, CreateAndListenWithInvalidPath) {
 252   CreateAndListen();
 253   EXPECT_TRUE(socket_.get() == NULL);
 254 }
 255
 256 #ifdef SOCKET_ABSTRACT_NAMESPACE_SUPPORTED
 257 // Test with an invalid path to make sure that the socket is not backed by a
 258 // file.
 259 TEST_F(UnixDomainSocketTestWithInvalidPath,
 260        CreateAndListenWithAbstractNamespace) {
 261   socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
 262       file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
 263   EXPECT_FALSE(socket_.get() == NULL);
 264 }
 265
 266 TEST_F(UnixDomainSocketTest, TestFallbackName) {
 267   scoped_ptr<UnixDomainSocket> existing_socket =
 268       UnixDomainSocket::CreateAndListenWithAbstractNamespace(
 269           file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
 270   EXPECT_FALSE(existing_socket.get() == NULL);
 271   // First, try to bind socket with the same name with no fallback name.
 272   socket_ =
 273       UnixDomainSocket::CreateAndListenWithAbstractNamespace(
 274           file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
 275   EXPECT_TRUE(socket_.get() == NULL);
 276   // Now with a fallback name.
 277   const char kFallbackSocketName[] = "unix_domain_socket_for_testing_2";
 278   socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
 279       file_path_.value(),
 280       MakeSocketPath(kFallbackSocketName),
 281       socket_delegate_.get(),
 282       MakeAuthCallback());
 283   EXPECT_FALSE(socket_.get() == NULL);
 284 }
 285 #endif
 286
 287 TEST_F(UnixDomainSocketTest, TestWithClient) {
 288   const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread();
 289   EventType event = event_manager_->WaitForEvent();
 290   ASSERT_EQ(EVENT_LISTEN, event);
 291
 292   // Create the client socket.
 293   const SocketDescriptor sock = CreateClientSocket();
 294   ASSERT_NE(kInvalidSocket, sock);
 295   event = event_manager_->WaitForEvent();
 296   ASSERT_EQ(EVENT_AUTH_GRANTED, event);
 297   event = event_manager_->WaitForEvent();
 298   ASSERT_EQ(EVENT_ACCEPT, event);
 299
 300   // Send a message from the client to the server.
 301   ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0));
 302   ASSERT_NE(-1, ret);
 303   ASSERT_EQ(sizeof(kMsg), static_cast<size_t>(ret));
 304   event = event_manager_->WaitForEvent();
 305   ASSERT_EQ(EVENT_READ, event);
 306   ASSERT_EQ(kMsg, socket_delegate_->ReceivedData());
 307
 308   // Close the client socket.
 309   ret = IGNORE_EINTR(close(sock));
 310   event = event_manager_->WaitForEvent();
 311   ASSERT_EQ(EVENT_CLOSE, event);
 312 }
 313
 314 TEST_F(UnixDomainSocketTestWithForbiddenUser, TestWithForbiddenUser) {
 315   const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread();
 316   EventType event = event_manager_->WaitForEvent();
 317   ASSERT_EQ(EVENT_LISTEN, event);
 318   const SocketDescriptor sock = CreateClientSocket();
 319   ASSERT_NE(kInvalidSocket, sock);
 320
 321   event = event_manager_->WaitForEvent();
 322   ASSERT_EQ(EVENT_AUTH_DENIED, event);
 323
 324   // Wait until the file descriptor is closed by the server.
 325   struct pollfd poll_fd;
 326   poll_fd.fd = sock;
 327   poll_fd.events = POLLIN;
 328   poll(&poll_fd, 1, -1 /* rely on GTest for timeout handling */);
 329
 330   // Send() must fail.
 331   ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0));
 332   ASSERT_EQ(-1, ret);
 333   ASSERT_EQ(EPIPE, errno);
 334   ASSERT_FALSE(event_manager_->HasPendingEvent());
 335 }
 336
 337 }  // namespace
 338 }  // namespace net