int ACE_MEM_Acceptor::accept (ACE_MEM_Stream &new_stream, ACE_MEM_Addr *remote_sap, ACE_Time_Value *timeout, bool restart, bool reset_new_handle) { ACE_TRACE ("ACE_MEM_Acceptor::accept"); int in_blocking_mode = 1; if (this->shared_accept_start (timeout, restart, in_blocking_mode) == -1) return -1; else { sockaddr *addr = 0; struct sockaddr_in inet_addr; int *len_ptr = 0; int len = 0; if (remote_sap != 0) { addr = reinterpret_cast<sockaddr *> (&inet_addr); len = sizeof (inet_addr); len_ptr = &len; } do // On Win32 the third parameter to <accept> must be a NULL // pointer if to ignore the client's address. new_stream.set_handle (ACE_OS::accept (this->get_handle (), addr, len_ptr)); while (new_stream.get_handle () == ACE_INVALID_HANDLE && restart != 0 && errno == EINTR && timeout == 0); if (remote_sap != 0) { ACE_INET_Addr temp (&inet_addr, len); remote_sap->set_port_number (temp.get_port_number ()); } } if (this->shared_accept_finish (new_stream, in_blocking_mode, reset_new_handle) == -1) return -1; // Allocate 2 * MAXPATHLEN so we can accomodate the unique // name that gets appended later ACE_TCHAR buf [2 * MAXPATHLEN + 1]; ACE_INET_Addr local_addr; if (new_stream.get_local_addr (local_addr) == -1) return -1; if (this->mmap_prefix_ != 0) { ACE_OS::sprintf (buf, ACE_TEXT ("%s_%d_"), this->mmap_prefix_, local_addr.get_port_number ()); } else { ACE_TCHAR name[25]; // - 24 is so we can append name to the end. if (ACE::get_temp_dir (buf, MAXPATHLEN - 24) == -1) { ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("Temporary path too long, ") ACE_TEXT ("defaulting to current directory\n"))); buf[0] = 0; } ACE_OS::sprintf (name, ACE_TEXT ("MEM_Acceptor_%d_"), local_addr.get_port_number ()); ACE_OS::strcat (buf, name); } ACE_TCHAR unique [MAXPATHLEN]; ACE_OS::unique_name (&new_stream, unique, MAXPATHLEN); ACE_OS::strcat (buf, unique); // Make sure we have a fresh start. ACE_OS::unlink (buf); new_stream.disable (ACE_NONBLOCK); ACE_HANDLE new_handle = new_stream.get_handle (); // Protocol negociation: // Tell the client side what level of signaling strategy // we support. ACE_MEM_IO::Signal_Strategy client_signaling = #if defined (ACE_WIN32) || !defined (_ACE_USE_SV_SEM) this->preferred_strategy_; #else // We don't support MT. ACE_MEM_IO::Reactive; #endif /* ACE_WIN32 || !_ACE_USE_SV_SEM */ if (ACE::send (new_handle, &client_signaling, sizeof (ACE_INT16)) == -1) ACELIB_ERROR_RETURN ((LM_DEBUG, ACE_TEXT ("ACE_MEM_Acceptor::accept error sending strategy\n")), -1); // Now we get the signaling strategy the client support. if (ACE::recv (new_handle, &client_signaling, sizeof (ACE_INT16)) == -1) ACELIB_ERROR_RETURN ((LM_DEBUG, ACE_TEXT ("ACE_MEM_Acceptor::%p error receiving strategy\n"), ACE_TEXT ("accept")), -1); // Ensure minimum buffer size if (this->malloc_options_.minimum_bytes_ < ACE_MEM_STREAM_MIN_BUFFER) this->malloc_options_.minimum_bytes_ = ACE_MEM_STREAM_MIN_BUFFER; // Client will decide what signaling strategy to use. // Now set up the shared memory malloc pool. if (new_stream.init (buf, static_cast<ACE_MEM_IO::Signal_Strategy> (client_signaling), &this->malloc_options_) == -1) return -1; // @@ Need to handle timeout here. ACE_UINT16 buf_len = static_cast<ACE_UINT16> ((ACE_OS::strlen (buf) + 1) * sizeof (ACE_TCHAR)); // No need to worry about byte-order because both parties should always // be on the same machine. if (ACE::send (new_handle, &buf_len, sizeof (ACE_UINT16)) == -1) return -1; // Now send the pathname of the mmap file. if (ACE::send (new_handle, buf, buf_len) == -1) return -1; return 0; }