Clean up channel modes

ipc/ipc_channel_posix.cc

 // Copyright (c) 2010 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 "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
@@ skipping 300 matching lines @@
       pipe_(-1),
       client_pipe_(-1),
 #if defined(IPC_USES_READWRITE)
       fd_pipe_(-1),
       remote_fd_pipe_(-1),
 #endif  // IPC_USES_READWRITE
       pipe_name_(channel_handle.name),
       listener_(listener),
       must_unlink_(false),
       factory_(this) {
-  // Check to see if we want to implement using domain sockets.
-  bool uses_domain_socket = false;
-  bool listening_socket = false;
-  if (mode_ == MODE_NAMED_SERVER) {
-    uses_domain_socket = true;
-    listening_socket = true;
-    mode_ = MODE_SERVER;
-  } else if (mode_ == MODE_NAMED_CLIENT) {
-    uses_domain_socket = true;
-    mode_ = MODE_CLIENT;
-  }
-  if (!CreatePipe(channel_handle, uses_domain_socket, listening_socket)) {
+  if (!CreatePipe(channel_handle)) {
     // The pipe may have been closed already.
-    const char *modestr = (mode_ == MODE_SERVER
-                           || mode_ == MODE_NAMED_SERVER) ? "server" : "client";
+    const char *modestr = (mode_ & MODE_SERVER_FLAG) ? "server" : "client";
     // The pipe may have been closed already.
     LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name
                  << "\" in " << modestr << " mode";
   }
 }
 
 Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
 
@@ skipping 14 matching lines @@
       PLOG(ERROR) << "close";
     return false;
   }
 
   *fd1 = pipe_fds[0];
   *fd2 = pipe_fds[1];
 
   return true;
 }
 
-bool Channel::ChannelImpl::CreatePipe(const IPC::ChannelHandle& channel_handle,
-                                      bool uses_domain_sockets,
-                                      bool listening_socket) {
+bool Channel::ChannelImpl::CreatePipe(
+    const IPC::ChannelHandle& channel_handle) {
   DCHECK(server_listen_pipe_ == -1 && pipe_ == -1);
 
   // Four possible cases:
   // 1) It's a channel wrapping a pipe that is given to us.
   // 2) It's for a named channel, so we create it.
   // 3) It's for a client that we implement ourself. This is used
   //    in unittesting.
   // 4) It's the initial IPC channel:
   //   4a) Client side: Pull the pipe out of the GlobalDescriptors set.
   //   4b) Server side: create the pipe.
 
   if (channel_handle.socket.fd != -1) {
     // Case 1 from comment above.
     pipe_ = channel_handle.socket.fd;
 #if defined(IPC_USES_READWRITE)
     // Test the socket passed into us to make sure it is nonblocking.
     // We don't want to call read/write on a blocking socket.
     int value = fcntl(pipe_, F_GETFL);
     if (value == -1) {
       PLOG(ERROR) << "fcntl(F_GETFL) " << pipe_name_;
       return false;
     }
     if (!(value & O_NONBLOCK)) {
       LOG(ERROR) << "Socket " << pipe_name_ << " must be O_NONBLOCK";
       return false;
     }
 #endif   // IPC_USES_READWRITE
-  } else if (uses_domain_sockets) {
+  } else if (mode_ & MODE_NAMED_FLAG) {
     // Case 2 from comment above.
     must_unlink_ = true;
-    if (mode_ == MODE_SERVER) {
+    if (mode_ & MODE_SERVER_FLAG) {
       if (!CreateServerUnixDomainSocket(pipe_name_, &pipe_)) {
         return false;
       }
-    } else if (mode_ == MODE_CLIENT) {
+    } else if (mode_ & MODE_CLIENT_FLAG) {
       if (!CreateClientUnixDomainSocket(pipe_name_, &pipe_)) {
         return false;
       }
+    } else {
+      NOTREACHED();
+      return false;
     }
   } else {
     pipe_ = PipeMap::GetInstance()->Lookup(pipe_name_);
-    if (mode_ == MODE_CLIENT) {
+    if (mode_ & MODE_CLIENT_FLAG) {
       if (pipe_ != -1) {
         // Case 3 from comment above.
         // We only allow one connection.
         pipe_ = HANDLE_EINTR(dup(pipe_));
         PipeMap::GetInstance()->RemoveAndClose(pipe_name_);
       } else {
         // Case 4a from comment above.
         // Guard against inappropriate reuse of the initial IPC channel.  If
         // an IPC channel closes and someone attempts to reuse it by name, the
         // initial channel must not be recycled here.  http://crbug.com/26754.
         static bool used_initial_channel = false;
         if (used_initial_channel) {
           LOG(FATAL) << "Denying attempt to reuse initial IPC channel for "
                      << pipe_name_;
           return false;
         }
         used_initial_channel = true;
 
         pipe_ = base::GlobalDescriptors::GetInstance()->Get(kPrimaryIPCChannel);
       }
-    } else if (mode_ == MODE_SERVER) {
+    } else if (mode_ & MODE_SERVER_FLAG) {
       // Case 4b from comment above.
       if (pipe_ != -1) {
         LOG(ERROR) << "Server already exists for " << pipe_name_;
         return false;
       }
       if (!SocketPair(&pipe_, &client_pipe_))
         return false;
       PipeMap::GetInstance()->Insert(pipe_name_, client_pipe_);
     } else {
-      LOG(FATAL) << "Unknown mode " << mode_;
+      NOTREACHED();
       return false;
     }
   }
 
-  if (mode_ == MODE_SERVER) {
-    if (listening_socket) {
-      server_listen_pipe_ = pipe_;
-      pipe_ = -1;
-    }
+  if ((mode_ & MODE_SERVER_FLAG) && (mode_ & MODE_NAMED_FLAG)) {
+    server_listen_pipe_ = pipe_;
+    pipe_ = -1;
   }
 
 #if defined(IPC_USES_READWRITE)
   // Create a dedicated socketpair() for exchanging file descriptors.
   // See comments for IPC_USES_READWRITE for details.
-  if (mode_ == MODE_CLIENT) {
+  if (mode_ & MODE_CLIENT_FLAG) {
     if (!SocketPair(&fd_pipe_, &remote_fd_pipe_)) {
       return false;
     }
   }
 #endif  // IPC_USES_READWRITE
 
   return true;
 }
 
 bool Channel::ChannelImpl::Connect() {
@@ skipping 251 matching lines @@
         DVLOG(2) << "received message on channel @" << this
                  << " with type " << m.type() << " on fd " << pipe_;
         if (IsHelloMessage(&m)) {
           // The Hello message contains only the process id.
           void *iter = NULL;
           int pid;
           if (!m.ReadInt(&iter, &pid)) {
             NOTREACHED();
           }
 #if defined(IPC_USES_READWRITE)
-          if (mode_ == MODE_SERVER) {
+          if (mode_ & MODE_SERVER_FLAG) {
             // With IPC_USES_READWRITE, the Hello message from the client to the
             // server also contains the fd_pipe_, which  will be used for all
             // subsequent file descriptor passing.
             DCHECK_EQ(m.file_descriptor_set()->size(), 1U);
             base::FileDescriptor descriptor;
             if (!m.ReadFileDescriptor(&iter, &descriptor)) {
               NOTREACHED();
             }
             fd_pipe_ = descriptor.fd;
             CHECK(descriptor.auto_close);
@@ skipping 102 matching lines @@
         if (bytes_written > 0) {
           msg->file_descriptor_set()->CommitAll();
         }
       }
 #endif  // IPC_USES_READWRITE
     }
 
     if (bytes_written == 1) {
       fd_written = pipe_;
 #if defined(IPC_USES_READWRITE)
-      if (mode_ != MODE_SERVER && IsHelloMessage(msg)) {
+      if ((mode_ & MODE_CLIENT_FLAG) && IsHelloMessage(msg)) {
         DCHECK_EQ(msg->file_descriptor_set()->size(), 1U);
       }
       if (!msgh.msg_controllen) {
         bytes_written = HANDLE_EINTR(write(pipe_, out_bytes, amt_to_write));
       } else
 #endif  // IPC_USES_READWRITE
       {
         bytes_written = HANDLE_EINTR(sendmsg(pipe_, &msgh, MSG_DONTWAIT));
       }
     }
@@ skipping 134 matching lines @@
       return;
     }
     pipe_ = new_pipe;
 
     if (!AcceptConnection()) {
       NOTREACHED() << "AcceptConnection should not fail on server";
     }
     send_server_hello_msg = true;
     waiting_connect_ = false;
   } else if (fd == pipe_) {
-    if (waiting_connect_ && mode_ == MODE_SERVER) {
+    if (waiting_connect_ && (mode_ & MODE_SERVER_FLAG)) {
       send_server_hello_msg = true;
       waiting_connect_ = false;
     }
     if (!ProcessIncomingMessages()) {
       ClosePipeOnError();
     }
   } else {
     NOTREACHED() << "Unknown pipe " << fd;
   }
 
@@ skipping 16 matching lines @@
 }
 
 bool Channel::ChannelImpl::AcceptConnection() {
   MessageLoopForIO::current()->WatchFileDescriptor(pipe_,
                                                    true,
                                                    MessageLoopForIO::WATCH_READ,
                                                    &read_watcher_,
                                                    this);
   QueueHelloMessage();
 
-  if (mode_ == MODE_CLIENT) {
+  if (mode_ & MODE_CLIENT_FLAG) {
     // If we are a client we want to send a hello message out immediately.
     // In server mode we will send a hello message when we receive one from a
     // client.
     waiting_connect_ = false;
     return ProcessOutgoingMessages();
-  } else {
+  } else if (mode_ & MODE_SERVER_FLAG) {
     waiting_connect_ = true;
     return true;
+  } else {
+    NOTREACHED();
+    return false;
   }
 }
 
 void Channel::ChannelImpl::ClosePipeOnError() {
   if (HasAcceptedConnection()) {
     ResetToAcceptingConnectionState();
     listener_->OnChannelError();
   } else {
     Close();
     if (AcceptsConnections()) {
@@ skipping 91 matching lines @@
 
 bool Channel::HasAcceptedConnection() const {
   return channel_impl_->HasAcceptedConnection();
 }
 
 void Channel::ResetToAcceptingConnectionState() {
   channel_impl_->ResetToAcceptingConnectionState();
 }
 
 }  // namespace IPC