int ACE_UPIPE_Acceptor::accept (ACE_UPIPE_Stream &new_stream, ACE_UPIPE_Addr *remote_addr, ACE_Time_Value *timeout, bool restart, bool reset_new_handle) { ACE_TRACE ("ACE_UPIPE_Acceptor::accept"); ACE_UNUSED_ARG (reset_new_handle); ACE_SPIPE_Stream new_io; if (this->ACE_SPIPE_Acceptor::accept (new_io, remote_addr, timeout, restart) == -1) return -1; else { ACE_UPIPE_Stream *remote_stream = 0; ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, new_stream.lock_, -1)); new_stream.set_handle (new_io.get_handle ()); new_stream.reference_count_++; // Transfer address ownership. new_io.get_local_addr (new_stream.local_addr_); new_io.get_remote_addr (new_stream.remote_addr_); // Now that we got the handle, we'll read the address of the // connector-side ACE_UPIPE_Stream out of the pipe and link that // ACE_UPIPE_Stream to our ACE_UPIPE_Stream. if (ACE_OS::read (new_stream.get_handle (), (char *) &remote_stream, sizeof remote_stream) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_UPIPE_Acceptor: %p\n"), ACE_TEXT ("read stream address failed"))); else if (new_stream.stream_.link (remote_stream->stream_) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_UPIPE_Acceptor: %p\n"), ACE_TEXT ("link streams failed"))); // Send a message over the new streampipe to confirm acceptance. else if (new_stream.send (&mb_, 0) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_UPIPE_Acceptor: %p\n"), ACE_TEXT ("linked stream.put failed"))); // Close down the new_stream at this point in order to conserve // handles. Note that we don't need the SPIPE connection // anymore since we're now linked via the <Message_Queue>. new_stream.ACE_SPIPE::close (); return 0; } }
int ACE_UPIPE_Connector::connect (ACE_UPIPE_Stream &new_stream, const ACE_UPIPE_Addr &addr, ACE_Time_Value *timeout, const ACE_Addr & /* local_sap */, int /* reuse_addr */, int flags, int perms) { ACE_TRACE ("ACE_UPIPE_Connector::connect"); ACE_ASSERT (new_stream.get_handle () == ACE_INVALID_HANDLE); ACE_HANDLE handle = ACE::handle_timed_open (timeout, addr.get_path_name (), flags, perms); if (handle == ACE_INVALID_HANDLE) return -1; #if !defined (ACE_WIN32) else if (ACE_OS::isastream (handle) != 1) return -1; #endif else // We're connected! { ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, new_stream.lock_, -1)); ACE_UPIPE_Stream *ustream = &new_stream; new_stream.set_handle (handle); new_stream.remote_addr_ = addr; // class copy. new_stream.reference_count_++; // Now send the address of our ACE_UPIPE_Stream over this pipe // to our corresponding ACE_UPIPE_Acceptor, so he may link the // two streams. ssize_t result = ACE_OS::write (handle, (const char *) &ustream, sizeof ustream); if (result == -1) ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE_UPIPE_Connector %p\n"), ACE_TEXT ("write to pipe failed"))); // Wait for confirmation of stream linking. ACE_Message_Block *mb_p = 0; // Our part is done, wait for server to confirm connection. result = new_stream.recv (mb_p, 0); // Do *not* coalesce the following two checks for result == -1. // They perform different checks and cannot be merged. if (result == -1) ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE_UPIPE_Connector %p\n"), ACE_TEXT ("no confirmation from server"))); else // Close down the new_stream at this point in order to // conserve handles. Note that we don't need the SPIPE // connection anymore since we're linked via the Message_Queue // now. new_stream.ACE_SPIPE::close (); return static_cast<int> (result); } }