chunk of straightforward ifdef/include changes for BSD port...

ipc/ipc_channel_posix.cc

 // Copyright (c) 2008 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 255 matching lines @@
 Channel::ChannelImpl::ChannelImpl(const std::string& channel_id, Mode mode,
                                   Listener* listener)
     : mode_(mode),
       is_blocked_on_write_(false),
       message_send_bytes_written_(0),
       uses_fifo_(CommandLine::ForCurrentProcess()->HasSwitch(
                      switches::kIPCUseFIFO)),
       server_listen_pipe_(-1),
       pipe_(-1),
       client_pipe_(-1),
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
       fd_pipe_(-1),
       remote_fd_pipe_(-1),
 #endif
       listener_(listener),
       waiting_connect_(true),
       factory_(this) {
   if (!CreatePipe(channel_id, mode)) {
     // The pipe may have been closed already.
     PLOG(WARNING) << "Unable to create pipe named \"" << channel_id
                   << "\" in " << (mode == MODE_SERVER ? "server" : "client")
@@ skipping 90 matching lines @@
       }
     } else {
       waiting_connect_ = mode == MODE_SERVER;
     }
   }
 
   // Create the Hello message to be sent when Connect is called
   scoped_ptr<Message> msg(new Message(MSG_ROUTING_NONE,
                                       HELLO_MESSAGE_TYPE,
                                       IPC::Message::PRIORITY_NORMAL));
-  #if defined(OS_LINUX)
+  #if !defined(OS_MACOSX)
   if (!uses_fifo_) {
     // On Linux, the seccomp sandbox makes it very expensive to call
     // recvmsg() and sendmsg(). Often, we are perfectly OK with resorting to
     // read() and write(), which are cheap.
     //
     // As we cannot anticipate, when the sender will provide us with file
     // handles, we have to make the decision about whether we call read() or
     // recvmsg() before we actually make the call. The easiest option is to
     // create a dedicated socketpair() for exchanging file handles.
     if (mode == MODE_SERVER) {
@@ skipping 55 matching lines @@
   for (;;) {
     msg.msg_iov = &iov;
 
     if (bytes_read == 0) {
       if (pipe_ == -1)
         return false;
 
       // Read from pipe.
       // recvmsg() returns 0 if the connection has closed or EAGAIN if no data
       // is waiting on the pipe.
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
       if (fd_pipe_ >= 0) {
         bytes_read = HANDLE_EINTR(read(pipe_, input_buf_,
                                        Channel::kReadBufferSize));
         msg.msg_controllen = 0;
       } else
 #endif
       {
         msg.msg_controllen = sizeof(input_cmsg_buf_);
         bytes_read = HANDLE_EINTR(recvmsg(pipe_, &msg, MSG_DONTWAIT));
       }
@@ skipping 111 matching lines @@
       if (message_tail) {
         int len = static_cast<int>(message_tail - p);
         Message m(p, len);
 
         if (m.header()->num_fds) {
           // the message has file descriptors
           const char* error = NULL;
           if (m.header()->num_fds > num_fds - fds_i) {
             // the message has been completely received, but we didn't get
             // enough file descriptors.
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
             if (!uses_fifo_) {
               char dummy;
               struct iovec fd_pipe_iov = { &dummy, 1 };
               msg.msg_iov = &fd_pipe_iov;
               msg.msg_controllen = sizeof(input_cmsg_buf_);
               ssize_t n = HANDLE_EINTR(recvmsg(fd_pipe_, &msg, MSG_DONTWAIT));
               if (n == 1 && msg.msg_controllen > 0) {
                 for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg;
                      cmsg = CMSG_NXTHDR(&msg, cmsg)) {
                   if (cmsg->cmsg_level == SOL_SOCKET &&
@@ skipping 69 matching lines @@
                       " with type " << m.type();
 #endif
         if (m.routing_id() == MSG_ROUTING_NONE &&
             m.type() == HELLO_MESSAGE_TYPE) {
           // The Hello message contains only the process id.
           void *iter = NULL;
           int pid;
           if (!m.ReadInt(&iter, &pid)) {
             NOTREACHED();
           }
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
           if (mode_ == MODE_SERVER && !uses_fifo_) {
             // On Linux, the Hello message from the client to the server

[Evan Martin, 2010/05/19 11:50:11]

s/Linux/non-Mac/

             // also contains the fd_pipe_, which  will be used for all
             // subsequent file descriptor passing.
             DCHECK_EQ(m.file_descriptor_set()->size(), 1);
             base::FileDescriptor descriptor;
             if (!m.ReadFileDescriptor(&iter, &descriptor)) {
               NOTREACHED();
             }
             fd_pipe_ = descriptor.fd;
             CHECK(descriptor.auto_close);
           }
@@ skipping 40 matching lines @@
 
   if (pipe_ == -1) {
     return false;
   }
 
   // Write out all the messages we can till the write blocks or there are no
   // more outgoing messages.
   while (!output_queue_.empty()) {
     Message* msg = output_queue_.front();
 
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
     scoped_ptr<Message> hello;
     if (remote_fd_pipe_ != -1 &&
         msg->routing_id() == MSG_ROUTING_NONE &&
         msg->type() == HELLO_MESSAGE_TYPE) {
       hello.reset(new Message(MSG_ROUTING_NONE,
                               HELLO_MESSAGE_TYPE,
                               IPC::Message::PRIORITY_NORMAL));
       void* iter = NULL;
       int pid;
       if (!msg->ReadInt(&iter, &pid) ||
@@ skipping 40 matching lines @@
       cmsg->cmsg_type = SCM_RIGHTS;
       cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
       msg->file_descriptor_set()->GetDescriptors(
           reinterpret_cast<int*>(CMSG_DATA(cmsg)));
       msgh.msg_controllen = cmsg->cmsg_len;
 
       // DCHECK_LE above already checks that
       // num_fds < MAX_DESCRIPTORS_PER_MESSAGE so no danger of overflow.
       msg->header()->num_fds = static_cast<uint16>(num_fds);
 
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
       if (!uses_fifo_ &&
           (msg->routing_id() != MSG_ROUTING_NONE ||
            msg->type() != HELLO_MESSAGE_TYPE)) {
         // Only the Hello message sends the file descriptor with the message.
         // Subsequently, we can send file descriptors on the dedicated
         // fd_pipe_ which makes Seccomp sandbox operation more efficient.
         struct iovec fd_pipe_iov = { const_cast<char *>(""), 1 };
         msgh.msg_iov = &fd_pipe_iov;
         fd_written = fd_pipe_;
         bytes_written = HANDLE_EINTR(sendmsg(fd_pipe_, &msgh, MSG_DONTWAIT));
         msgh.msg_iov = &iov;
         msgh.msg_controllen = 0;
         if (bytes_written > 0) {
           msg->file_descriptor_set()->CommitAll();
         }
       }
 #endif
     }
 
     if (bytes_written == 1) {
       fd_written = pipe_;
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
       if (mode_ != MODE_SERVER && !uses_fifo_ &&
           msg->routing_id() == MSG_ROUTING_NONE &&
           msg->type() == HELLO_MESSAGE_TYPE) {
         DCHECK_EQ(msg->file_descriptor_set()->size(), 1);
       }
       if (!uses_fifo_ && !msgh.msg_controllen) {
         bytes_written = HANDLE_EINTR(write(pipe_, out_bytes, amt_to_write));
       } else
 #endif
       {
@@ skipping 150 matching lines @@
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
   if (pipe_ != -1) {
     HANDLE_EINTR(close(pipe_));
     pipe_ = -1;
   }
   if (client_pipe_ != -1) {
     Singleton<PipeMap>()->RemoveAndClose(pipe_name_);
     client_pipe_ = -1;
   }
-#if defined(OS_LINUX)
+#if !defined(OS_MACOSX)
   if (fd_pipe_ != -1) {
     HANDLE_EINTR(close(fd_pipe_));
     fd_pipe_ = -1;
   }
   if (remote_fd_pipe_ != -1) {
     HANDLE_EINTR(close(remote_fd_pipe_));
     remote_fd_pipe_ = -1;
   }
 #endif
 
@@ skipping 41 matching lines @@
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 int Channel::GetClientFileDescriptor() const {
   return channel_impl_->GetClientFileDescriptor();
 }
 
 }  // namespace IPC