void
ACE_DLL_Manager::unload_policy (u_long unload_policy)
{
ACE_TRACE ("ACE_DLL_Manager::unload_policy");
ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->lock_));
u_long old_policy = this->unload_policy_;
this->unload_policy_ = unload_policy;
// If going from LAZY to EAGER or from PER_DLL to PER_PROCESS|EAGER,
// call close(1) on all the ACE_DLL_Handle objects with refcount == 0
// which will force those that are still loaded to be unloaded.
if (this->handle_vector_)
if (( ACE_BIT_ENABLED (old_policy, ACE_DLL_UNLOAD_POLICY_LAZY) &&
ACE_BIT_DISABLED (this->unload_policy_, ACE_DLL_UNLOAD_POLICY_LAZY) ) ||
( ACE_BIT_DISABLED (this->unload_policy_, ACE_DLL_UNLOAD_POLICY_LAZY) &&
ACE_BIT_ENABLED (old_policy, ACE_DLL_UNLOAD_POLICY_PER_DLL) &&
ACE_BIT_DISABLED (this->unload_policy_, ACE_DLL_UNLOAD_POLICY_PER_DLL) ))
{
for (int i = this->current_size_ - 1; i >= 0; i--)
{
if (this->handle_vector_[i] &&
this->handle_vector_[i]->refcount () == 0)
this->handle_vector_[i]->close (1);
}
}
}
int
ACE_DLL_Manager::unload_dll (ACE_DLL_Handle *dll_handle, int force_unload)
{
ACE_TRACE ("ACE_DLL_Manager::unload_dll");
if (dll_handle)
{
int unload = force_unload;
if (unload == 0)
{
// apply strategy
if (ACE_BIT_DISABLED (this->unload_policy_,
ACE_DLL_UNLOAD_POLICY_PER_DLL))
{
unload = ACE_BIT_DISABLED (this->unload_policy_,
ACE_DLL_UNLOAD_POLICY_LAZY);
}
else
{
// Declare the type of the symbol:
typedef int (*dll_unload_policy)(void);
dll_unload_policy the_policy = 0;
void *unload_policy_ptr =
dll_handle->symbol (ACE_LIB_TEXT ("_get_dll_unload_policy"), 1);
ptrdiff_t temp_p =
reinterpret_cast<ptrdiff_t> (unload_policy_ptr);
the_policy =
reinterpret_cast<dll_unload_policy> (temp_p);
if (the_policy != 0)
unload = ACE_BIT_DISABLED (the_policy (),
ACE_DLL_UNLOAD_POLICY_LAZY);
else
unload = ACE_BIT_DISABLED (this->unload_policy_,
ACE_DLL_UNLOAD_POLICY_LAZY);
}
}
if (dll_handle->close (unload) != 0)
{
if (ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("ACE_DLL_Manager::unload error.\n")));
return -1;
}
}
else
{
if (ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("ACE_DLL_Manager::unload_dll called with ")
ACE_LIB_TEXT ("null pointer.\n")));
return -1;
}
return 0;
}
int
ACE_Data_Block::size (size_t length)
{
ACE_TRACE ("ACE_Data_Block::size");
if (length <= this->max_size_)
this->cur_size_ = length;
else
{
// We need to resize!
char *buf = 0;
ACE_ALLOCATOR_RETURN (buf,
(char *) this->allocator_strategy_->malloc (length),
-1);
ACE_OS::memcpy (buf,
this->base_,
this->cur_size_);
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE))
this->allocator_strategy_->free ((void *) this->base_);
else
// We now assume ownership.
ACE_CLR_BITS (this->flags_,
ACE_Message_Block::DONT_DELETE);
this->max_size_ = length;
this->cur_size_ = length;
this->base_ = buf;
}
return 0;
}
// Helper method
CORBA::NamedValue_ptr
CORBA::NVList::add_element (CORBA::Flags flags)
{
this->evaluate ();
if (ACE_BIT_DISABLED (flags,
CORBA::ARG_IN | CORBA::ARG_OUT | CORBA::ARG_INOUT))
{
throw ::CORBA::BAD_PARAM ();
}
CORBA::NamedValue_ptr nv;
// allocate a new NamedValue
ACE_NEW_THROW_EX (nv,
CORBA::NamedValue,
CORBA::NO_MEMORY ());
// set the flags and enqueue in the queue
nv->flags_ = flags;
if (this->values_.enqueue_tail (nv) == -1)
{
delete nv;
return 0;
}
++this->max_;
return nv; // success
}
int
ACE_SOCK_Acceptor::shared_accept_start (ACE_Time_Value *timeout,
int restart,
int &in_blocking_mode) const
{
ACE_TRACE ("ACE_SOCK_Acceptor::shared_accept_start");
ACE_HANDLE handle = this->get_handle ();
// Handle the case where we're doing a timed <accept>.
if (timeout != 0)
{
if (ACE::handle_timed_accept (handle,
timeout,
restart) == -1)
return -1;
else
{
in_blocking_mode = ACE_BIT_DISABLED (ACE::get_flags (handle),
ACE_NONBLOCK);
// Set the handle into non-blocking mode if it's not already
// in it.
if (in_blocking_mode
&& ACE::set_flags (handle,
ACE_NONBLOCK) == -1)
return -1;
}
}
return 0;
}
int
ACE_Message_Block::release_i (ACE_Lock *lock)
{
ACE_TRACE ("ACE_Message_Block::release_i");
// Free up all the continuation messages.
if (this->cont_)
{
ACE_Message_Block *mb = this->cont_;
ACE_Message_Block *tmp = 0;
do
{
tmp = mb;
mb = mb->cont_;
tmp->cont_ = 0;
ACE_Data_Block *db = tmp->data_block ();
if (tmp->release_i (lock) != 0)
{
ACE_Allocator *allocator = db->data_block_allocator ();
ACE_DES_FREE (db,
allocator->free,
ACE_Data_Block);
}
}
while (mb);
this->cont_ = 0;
}
int result = 0;
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE) &&
this->data_block ())
{
if (this->data_block ()->release_no_delete (lock) == 0)
result = 1;
this->data_block_ = 0;
}
// We will now commit suicide: this object *must* have come from the
// allocator given.
if (this->message_block_allocator_ == 0)
delete this;
else
{
ACE_Allocator *allocator = this->message_block_allocator_;
ACE_DES_FREE (this,
allocator->free,
ACE_Message_Block);
}
return result;
}
int
TAO_DII_Asynch_Reply_Dispatcher::dispatch_reply (
TAO_Pluggable_Reply_Params ¶ms)
{
this->reply_status_ = params.reply_status ();
this->locate_reply_status_ = params.locate_reply_status ();
// Transfer the <params.input_cdr_>'s content to this->reply_cdr_
ACE_Data_Block *db =
this->reply_cdr_.clone_from (*params.input_cdr_);
// See whether we need to delete the data block by checking the
// flags. We cannot be happy that we initally allocated the
// datablocks of the stack. If this method is called twice, as is in
// some cases where the same invocation object is used to make two
// invocations like forwarding, the release becomes essential.
if (ACE_BIT_DISABLED (db->flags (),
ACE_Message_Block::DONT_DELETE))
db->release ();
// Steal the buffer, that way we don't do any unnecesary copies of
// this data.
CORBA::ULong max = params.svc_ctx_.maximum ();
CORBA::ULong len = params.svc_ctx_.length ();
IOP::ServiceContext* context_list = params.svc_ctx_.get_buffer (1);
this->reply_service_info_.replace (max, len, context_list, 1);
if (TAO_debug_level >= 4)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P | %t):")
ACE_TEXT ("TAO_DII_Asynch_Reply_Dispatcher::dispatch_reply: status = %d\n"),
this->reply_status_));
}
try
{
// Call the handler with the reply data.
CORBA::Request::_tao_reply_stub (this->reply_cdr_,
this->callback_,
this->reply_status_);
}
catch (const CORBA::Exception& ex)
{
if (TAO_debug_level >= 4)
{
ex._tao_print_exception ("Exception during reply handler");
}
}
// This was dynamically allocated. Now the job is done.
this->intrusive_remove_ref (this);
return 1;
}
ACE_Message_Block::~ACE_Message_Block (void)
{
ACE_TRACE ("ACE_Message_Block::~ACE_Message_Block");
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE)&&
this->data_block ())
this->data_block ()->release ();
this->prev_ = 0;
this->next_ = 0;
}
int
Sender::terminate_io (ACE_Reactor_Mask mask)
{
if (ACE_BIT_DISABLED (flg_mask_, mask))
return 0;
if (ACE_Reactor::instance ()->cancel_wakeup (this, mask) == -1)
return -1;
ACE_CLR_BITS (flg_mask_, mask);
return 0;
}
void
ACE_Data_Block::base (char *msg_data,
size_t msg_length,
ACE_Message_Block::Message_Flags msg_flags)
{
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE))
this->allocator_strategy_->free (this->base_);
this->max_size_ = msg_length;
this->cur_size_ = msg_length;
this->base_ = msg_data;
this->flags_ = msg_flags;
}
ACE_Data_Block::~ACE_Data_Block (void)
{
// Sanity check...
ACE_ASSERT (this->reference_count_ <= 1);
// Just to be safe...
this->reference_count_ = 0;
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE))
{
this->allocator_strategy_->free ((void *) this->base_);
this->base_ = 0;
}
}
void
ACE_Message_Block::data_block (ACE_Data_Block *db)
{
ACE_TRACE ("ACE_Message_Block::data_block");
if (ACE_BIT_DISABLED (this->flags_,
ACE_Message_Block::DONT_DELETE)
&& this->data_block_ != 0)
this->data_block_->release ();
this->data_block_ = db;
// Set the read and write pointers in the <Message_Block> to point
// to the buffer in the <ACE_Data_Block>.
this->rd_ptr (this->data_block ()->base ());
this->wr_ptr (this->data_block ()->base ());
}
int
TAO::SSLIOP::Acceptor::verify_secure_configuration (TAO_ORB_Core *orb_core,
int major,
int minor)
{
// Sanity check.
if (major < 1)
{
// There is no such thing as IIOP 0.x.
errno = EINVAL;
return -1;
}
// In order to support a secure connection, the SSLIOP::SSL tagged
// component must be embedded in the IOR. This isn't possible if
// the user elects to disable standard profile components.
// Similarly, IIOP 1.0 does not support tagged components, which
// makes it impossible to embed the SSLIOP::SSL tagged component
// within the IOR. If the given object explicitly disallows
// insecure invocations and standard profile components are
// disabled, then return with an error since secure invocations
// cannot be supported without standard profile components.
//
// Note that it isn't enough to support NoProtection. NoProtection
// must be required since "support" does not preclude the secure
// port from being used.
if ((orb_core->orb_params ()->std_profile_components () == 0
|| (major == 1 && minor == 0))
&& ACE_BIT_DISABLED (this->ssl_component_.target_requires,
::Security::NoProtection))
{
if (TAO_debug_level > 0)
ORBSVCS_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) Cannot support secure ")
ACE_TEXT ("IIOP over SSL connection if\n")
ACE_TEXT ("(%P|%t) standard profile ")
ACE_TEXT ("components are disabled\n")
ACE_TEXT ("(%P|%t) or IIOP 1.0 endpoint is ")
ACE_TEXT ("used.\n")));
errno = EINVAL;
return -1;
}
return 0;
}
void
CORBA::NVList::_tao_decode (TAO_InputCDR &incoming, int flag)
{
if (TAO_debug_level > 3)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode\n")));
}
// Then unmarshal each "in" and "inout" parameter.
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
for (i.first (); !i.done (); i.advance ())
{
CORBA::NamedValue_ptr *item = 0;
(void) i.next (item);
CORBA::NamedValue_ptr nv = *item;
// check if it is an in or inout parameter
// @@ this is where we assume that the NVList is coming from
// a Server-side request, we could probably handle both
// cases with a flag, but there is no clear need for that.
if (ACE_BIT_DISABLED (nv->flags (), flag))
{
continue;
}
if (TAO_debug_level > 3)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode - %C\n"),
nv->name ()? nv->name () : "(no name given)" ));
}
CORBA::Any_ptr any = nv->value ();
any->impl ()->_tao_decode (incoming
);
}
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
int retval = 0;
MCT_Config config;
retval = config.open (argc, argv);
if (retval != 0)
return 1;
const ACE_TCHAR *temp = ACE_TEXT ("Multicast_Test");
ACE_TString test = temp;
u_long role = config.role ();
if (ACE_BIT_DISABLED (role, MCT_Config::PRODUCER)
|| ACE_BIT_DISABLED (role, MCT_Config::CONSUMER))
{
if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER))
test += ACE_TEXT ("-PRODUCER");
else
test += ACE_TEXT ("-CONSUMER");
}
// Start test only if options are valid.
ACE_START_TEST (test.c_str ());
// Register a signal handler to close down application gracefully.
ACE_Sig_Action sa ((ACE_SignalHandler) handler, SIGINT);
// Dump the configuration info to the log if caller passed debug option.
if (config.debug ())
config.dump ();
ACE_Reactor *reactor = ACE_Reactor::instance ();
MCT_Task *task = new MCT_Task (config, reactor);
if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER))
{
ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting consumer...\n")));
// Open makes it an active object.
retval += task->open ();
}
// now produce the datagrams...
if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER))
retval += producer (config);
if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER))
{
// and wait for everything to finish
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("start waiting for consumer to finish...\n")));
// Wait for the threads to exit.
// But, wait for a limited time since we could hang if the last udp
// message isn't received.
ACE_Time_Value max_wait ( config.wait ()/* seconds */);
ACE_Time_Value wait_time (ACE_OS::gettimeofday () + max_wait);
ACE_Time_Value *ptime = ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)
? &wait_time : 0;
if (ACE_Thread_Manager::instance ()->wait (ptime) == -1)
{
// We will no longer wait for this thread, so we must
// force it to exit otherwise the thread will be referencing
// deleted memory.
finished = 1;
reactor->end_reactor_event_loop ();
if (errno == ETIME)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("maximum wait time of %d msec exceeded\n"),
max_wait.msec ()));
else
ACE_OS::perror (ACE_TEXT ("wait"));
++error;
// This should exit now that we ended the reactor loop.
task->wait ();
}
}
delete task;
ACE_END_TEST;
return (retval == 0 && error == 0) ? 0 : 1;
}
// Dispatch the reply.
int
TAO_Asynch_Reply_Dispatcher::dispatch_reply (TAO_Pluggable_Reply_Params ¶ms)
{
if (this->timeout_handler_)
{
// If we had registered timeout handlers just cancel them and
// loose ownership of the handlers
this->timeout_handler_->cancel ();
this->timeout_handler_->remove_reference ();
this->timeout_handler_ = 0;
// AMI Timeout Handling End
}
// With Asynch requests the invocation handler can't call idle_after_reply ()
// since it does not handle the reply.
// So we have to do that here in case f.i. the Exclusive TMS left the transport
// busy after the send
if (this->transport_ != 0)
this->transport_->tms ()->idle_after_reply ();
if (!params.input_cdr_)
return -1;
if (!this->try_dispatch_reply ())
return 0;
this->reply_status_ = params.reply_status ();
this->locate_reply_status_ = params.locate_reply_status ();
// Transfer the <params.input_cdr_>'s content to this->reply_cdr_
ACE_Data_Block *db = this->reply_cdr_.clone_from (*params.input_cdr_);
if (db == 0)
{
if (TAO_debug_level > 2)
{
TAOLIB_ERROR ((
LM_ERROR,
ACE_TEXT ("TAO_Messaging (%P|%t) - Asynch_Reply_Dispatcher::dispatch_reply ")
ACE_TEXT ("clone_from failed\n")));
}
return -1;
}
// See whether we need to delete the data block by checking the
// flags. We cannot be happy that we initially allocated the
// datablocks of the stack. If this method is called twice, as is in
// some cases where the same invocation object is used to make two
// invocations like forwarding, the release becomes essential.
if (ACE_BIT_DISABLED (db->flags (), ACE_Message_Block::DONT_DELETE))
{
db->release ();
}
if (!CORBA::is_nil (this->reply_handler_.in ()))
{
// Steal the buffer, that way we don't do any unnecesary copies of
// this data.
CORBA::ULong const max = params.svc_ctx_.maximum ();
CORBA::ULong const len = params.svc_ctx_.length ();
IOP::ServiceContext *context_list = params.svc_ctx_.get_buffer (1);
this->reply_service_info_.replace (max, len, context_list, 1);
if (TAO_debug_level >= 4)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO_Messaging (%P|%t) - Asynch_Reply_Dispatcher")
ACE_TEXT ("::dispatch_reply status = %d\n"),
this->reply_status_));
}
CORBA::ULong reply_error = TAO_AMI_REPLY_NOT_OK;
switch (this->reply_status_)
{
case GIOP::NO_EXCEPTION:
reply_error = TAO_AMI_REPLY_OK;
break;
case GIOP::USER_EXCEPTION:
reply_error = TAO_AMI_REPLY_USER_EXCEPTION;
break;
case GIOP::SYSTEM_EXCEPTION:
reply_error = TAO_AMI_REPLY_SYSTEM_EXCEPTION;
break;
case GIOP::LOCATION_FORWARD:
reply_error = TAO_AMI_REPLY_LOCATION_FORWARD;
break;
case GIOP::LOCATION_FORWARD_PERM:
reply_error = TAO_AMI_REPLY_LOCATION_FORWARD_PERM;
break;
default:
// @@ Michael: Not even the spec mentions this case.
// We have to think about this case.
// Handle the forwarding and return so the stub restarts the
// request!
reply_error = TAO_AMI_REPLY_NOT_OK;
break;
}
try
{
// Call the Reply Handler's stub.
this->reply_handler_stub_ (this->reply_cdr_,
this->reply_handler_.in (),
reply_error);
}
catch (const ::CORBA::Exception& ex)
{
if (TAO_debug_level >= 4)
ex._tao_print_exception ("Exception during reply handler");
}
}
this->intrusive_remove_ref (this);
return 1;
}
int
TAO_Synch_Reply_Dispatcher::dispatch_reply (
TAO_Pluggable_Reply_Params ¶ms)
{
if (params.input_cdr_ == 0)
return -1;
this->reply_status_ = params.reply_status ();
this->locate_reply_status_ = params.locate_reply_status ();
// Steal the buffer, that way we don't do any unnecesary copies of
// this data.
CORBA::ULong const max = params.svc_ctx_.maximum ();
CORBA::ULong const len = params.svc_ctx_.length ();
IOP::ServiceContext* context_list = params.svc_ctx_.get_buffer (true);
this->reply_service_info_.replace (max, len, context_list, true);
if (this->reply_service_info_.length() > 0)
{
orb_core_->service_context_registry ().
process_service_contexts (this->reply_service_info_, *(params.transport_), 0);
}
// Must reset the message state, it is possible that the same reply
// dispatcher is used because the request must be re-sent.
// this->message_state_.reset (0);
// Transfer the <params.input_cdr_>'s content to this->reply_cdr_
if (ACE_BIT_DISABLED ((*params.input_cdr_).start()->data_block()->flags(),
ACE_Message_Block::DONT_DELETE))
{
// Data block is on the heap, so just duplicate it.
this->reply_cdr_ = *params.input_cdr_;
this->reply_cdr_.clr_mb_flags (ACE_Message_Block::DONT_DELETE);
}
else
{
ACE_Data_Block *db = this->reply_cdr_.clone_from (*params.input_cdr_);
if (db == 0)
{
if (TAO_debug_level > 2)
{
TAOLIB_ERROR ((LM_ERROR,
"TAO (%P|%t) - Synch_Reply_Dispatcher::dispatch_reply "
"clone_from failed\n"));
}
return -1;
}
// See whether we need to delete the data block by checking the
// flags. We cannot be happy that we initally allocated the
// datablocks of the stack. If this method is called twice, as is in
// some cases where the same invocation object is used to make two
// invocations like forwarding, the release becomes essential.
if (ACE_BIT_DISABLED (db->flags (),
ACE_Message_Block::DONT_DELETE))
{
db->release ();
}
}
this->state_changed (TAO_LF_Event::LFS_SUCCESS,
this->orb_core_->leader_follower ());
return 1;
}
int
ACE_SOCK_Dgram_Mcast::open_i (const ACE_INET_Addr &mcast_addr,
const ACE_TCHAR *net_if,
int reuse_addr)
{
ACE_TRACE ("ACE_SOCK_Dgram_Mcast::open_i");
// ACE_SOCK::open calls this if reuse_addr is set, so we only need to
// process port reuse option.
if (reuse_addr)
{
#if defined (SO_REUSEPORT)
int one = 1;
if (this->ACE_SOCK::set_option (SOL_SOCKET,
SO_REUSEPORT,
&one,
sizeof one) == -1)
return -1;
#endif /* SO_REUSEPORT */
}
// Create an address/port# to bind the socket to. Use mcast_addr to
// initialize bind_addy to pick up the correct protocol family. If
// OPT_BINDADDR_YES is set, then we're done. Else use mcast_addr's
// port number and use the "any" address.
ACE_INET_Addr bind_addy (mcast_addr);
if (ACE_BIT_DISABLED (this->opts_, OPT_BINDADDR_YES))
{
#if defined (ACE_HAS_IPV6)
if (mcast_addr.get_type () == PF_INET6)
{
if (bind_addy.set (mcast_addr.get_port_number (), "::",
1, AF_INET6) == -1)
return -1;
}
else
// Bind to "any" address and explicit port#.
if (bind_addy.set (mcast_addr.get_port_number ()) == -1)
return -1;
#else
// Bind to "any" address and explicit port#.
if (bind_addy.set (mcast_addr.get_port_number ()) == -1)
return -1;
#endif /* ACE_HAS_IPV6 */
}
// Bind to the address (which may be INADDR_ANY) and port# (which may be 0)
if (ACE_SOCK_Dgram::shared_open (bind_addy, bind_addy.get_type ()) == -1)
return -1;
// Cache the actual bound address (which may be INADDR_ANY)
// and the actual bound port# (which will be a valid, non-zero port#).
ACE_INET_Addr bound_addy;
if (this->get_local_addr (bound_addy) == -1)
{
// (Unexpected failure - should be bound to something)
if (bound_addy.set (bind_addy) == -1)
{
// (Shouldn't happen - bind_addy is a valid addy; punt.)
return -1;
}
}
this->send_addr_ = mcast_addr;
this->send_addr_.set_port_number (bound_addy.get_port_number ());
if (net_if)
{
if (this->set_nic (net_if, mcast_addr.get_type ()))
return -1;
this->send_net_if_ = new ACE_TCHAR[ACE_OS::strlen (net_if) + 1];
ACE_OS::strcpy (this->send_net_if_, net_if);
}
return 0;
}
int
ACE_SSL_SOCK_Acceptor::ssl_accept (ACE_SSL_SOCK_Stream &new_stream,
ACE_Time_Value *timeout) const
{
SSL *ssl = new_stream.ssl ();
if (SSL_is_init_finished (ssl))
return 0;
if (!SSL_in_accept_init (ssl))
::SSL_set_accept_state (ssl);
ACE_HANDLE handle = new_stream.get_handle ();
// We're going to call SSL_accept, optionally doing ACE::select and
// retrying the SSL_accept, until the SSL handshake is done or
// it fails.
// To get the timeout affect, set the socket to nonblocking mode
// before beginning if there is a timeout specified. If the timeout
// is 0 (wait as long as it takes) then don't worry about the blocking
// status; we'll block in SSL_accept if the socket is blocking, and
// block in ACE::select if not.
int reset_blocking_mode = 0;
if (timeout != 0)
{
reset_blocking_mode = ACE_BIT_DISABLED (ACE::get_flags (handle),
ACE_NONBLOCK);
// Set the handle into non-blocking mode if it's not already
// in it.
if (reset_blocking_mode
&& ACE::set_flags (handle,
ACE_NONBLOCK) == -1)
return -1;
}
// Take into account the time between each select() call below.
ACE_Countdown_Time countdown (timeout);
int status;
do
{
// These handle sets are used to set up for whatever SSL_accept
// says it wants next. They're reset on each pass around the loop.
ACE_Handle_Set rd_handle;
ACE_Handle_Set wr_handle;
status = ::SSL_accept (ssl);
switch (::SSL_get_error (ssl, status))
{
case SSL_ERROR_NONE:
status = 0; // To tell caller about success
break; // Done
case SSL_ERROR_WANT_WRITE:
wr_handle.set_bit (handle);
status = 1; // Wait for more activity
break;
case SSL_ERROR_WANT_READ:
rd_handle.set_bit (handle);
status = 1; // Wait for more activity
break;
case SSL_ERROR_ZERO_RETURN:
// The peer has notified us that it is shutting down via
// the SSL "close_notify" message so we need to
// shutdown, too.
status = -1;
break;
case SSL_ERROR_SYSCALL:
// On some platforms (e.g. MS Windows) OpenSSL does not
// store the last error in errno so explicitly do so.
//
// Explicitly check for EWOULDBLOCK since it doesn't get
// converted to an SSL_ERROR_WANT_{READ,WRITE} on some
// platforms. If SSL_accept failed outright, though, don't
// bother checking more. This can happen if the socket gets
// closed during the handshake.
if (ACE_OS::set_errno_to_last_error () == EWOULDBLOCK &&
status == -1)
{
// Although the SSL_ERROR_WANT_READ/WRITE isn't getting
// set correctly, the read/write state should be valid.
// Use that to decide what to do.
status = 1; // Wait for more activity
if (SSL_want_write (ssl))
wr_handle.set_bit (handle);
else if (SSL_want_read (ssl))
rd_handle.set_bit (handle);
else
status = -1; // Doesn't want anything - bail out
}
else
status = -1;
break;
default:
ACE_SSL_Context::report_error ();
status = -1;
break;
}
if (status == 1)
{
// Must have at least one handle to wait for at this point.
ACE_ASSERT (rd_handle.num_set() == 1 || wr_handle.num_set () == 1);
status = ACE::select (int (handle) + 1,
&rd_handle,
&wr_handle,
0,
timeout);
(void) countdown.update ();
// 0 is timeout, so we're done.
// -1 is error, so we're done.
// Could be both handles set (same handle in both masks) so
// set to 1.
if (status >= 1)
status = 1;
else // Timeout or failure
status = -1;
}
} while (status == 1 && !SSL_is_init_finished (ssl));
if (reset_blocking_mode)
{
ACE_Errno_Guard eguard (errno);
ACE::clr_flags (handle, ACE_NONBLOCK);
}
return (status == -1 ? -1 : 0);
}
static VALUE _r2tao_invoke_request(CORBA::Request_ptr _req, bool& _raise)
{
CORBA::ULong ret_num = 0;
// get the ORB we're using for the request
CORBA::ORB_var _orb = _req->target ()->_get_orb ();
CORBA::TypeCode_var _ret_tc = _req->return_value ().type ();
// invoke twoway if resulttype specified (could be void!)
if (_ret_tc->kind () != CORBA::tk_null)
{
if (_ret_tc->kind () != CORBA::tk_void)
++ret_num;
CORBA::ULong arg_num = _req->arguments ()->count ();
for (CORBA::ULong a=0; a<arg_num ;++a)
{
CORBA::NamedValue_ptr _arg = _req->arguments ()->item (a);
if (ACE_BIT_DISABLED (_arg->flags (), CORBA::ARG_IN))
++ret_num;
}
// invoke request
try
{
_req->invoke ();
}
catch (CORBA::UnknownUserException& user_ex)
{
CORBA::Any& _excany = user_ex.exception ();
CORBA::ULong exc_len = _req->exceptions ()->count ();
for (CORBA::ULong x=0; x<exc_len ;++x)
{
CORBA::TypeCode_var _xtc = _req->exceptions ()->item (x);
if (ACE_OS::strcmp (_xtc->id (),
_excany._tao_get_typecode ()->id ()) == 0)
{
VALUE x_rtc = r2tao_Typecode_t2r(_xtc.in (), _orb.in ());
VALUE rexc = r2tao_Typecode_Any2Ruby (_excany,
_xtc.in (),
x_rtc, x_rtc,
_orb.in ());
_raise = true;
return rexc;
}
}
// rethrow if we were not able to identify the exception
// will be caught and handled in outer exception handler
throw;
}
// handle result and OUT arguments
VALUE result = (ret_num>1 ? rb_ary_new () : Qnil);
if (_ret_tc->kind () != CORBA::tk_void)
{
CORBA::Any& retval = _req->return_value ();
VALUE result_type = r2tao_Typecode_t2r(_ret_tc.in (), _orb.in ());
// return value
if (ret_num>1)
rb_ary_push (result, r2tao_Typecode_Any2Ruby (retval, _ret_tc.in (), result_type, result_type, _orb.in ()));
else
result = r2tao_Typecode_Any2Ruby (retval, _ret_tc.in (), result_type, result_type, _orb.in ());
--ret_num; // return value handled
}
// (in)out args
if (ret_num > 0)
{
for (CORBA::ULong a=0; a<arg_num ;++a)
{
CORBA::NamedValue_ptr _arg = _req->arguments ()->item (a);
if (ACE_BIT_DISABLED (_arg->flags (), CORBA::ARG_IN))
{
CORBA::TypeCode_var _arg_tc = _arg->value ()->type ();
VALUE arg_rtc = r2tao_Typecode_t2r(_arg_tc.in (), _orb.in ());
if (result != Qnil)
rb_ary_push (result, r2tao_Typecode_Any2Ruby (*_arg->value (), _arg_tc.in (), arg_rtc, arg_rtc, _orb.in ()));
else
result = r2tao_Typecode_Any2Ruby (*_arg->value (), _arg_tc.in (), arg_rtc, arg_rtc, _orb.in ());
}
}
}
return result;
}
else // invoke oneway
{
// oneway
_req->send_oneway ();
return Qtrue;
}
}
int
ACE_DLL_Manager::unload_dll (ACE_DLL_Handle *dll_handle, int force_unload)
{
ACE_TRACE ("ACE_DLL_Manager::unload_dll");
if (dll_handle)
{
int unload = force_unload;
if (unload == 0)
{
// apply strategy
if (ACE_BIT_DISABLED (this->unload_policy_,
ACE_DLL_UNLOAD_POLICY_PER_DLL))
{
unload = ACE_BIT_DISABLED (this->unload_policy_,
ACE_DLL_UNLOAD_POLICY_LAZY);
}
else
{
// Declare the type of the symbol:
typedef int (*dll_unload_policy)(void);
void * const unload_policy_ptr =
dll_handle->symbol (ACE_TEXT ("_get_dll_unload_policy"), 1);
#if defined (ACE_OPENVMS) && (!defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64))
int const temp_p =
reinterpret_cast<int> (unload_policy_ptr);
#else
intptr_t const temp_p =
reinterpret_cast<intptr_t> (unload_policy_ptr);
#endif
dll_unload_policy const the_policy =
reinterpret_cast<dll_unload_policy> (temp_p);
if (the_policy != 0)
unload = ACE_BIT_DISABLED (the_policy (),
ACE_DLL_UNLOAD_POLICY_LAZY);
else
unload = ACE_BIT_DISABLED (this->unload_policy_,
ACE_DLL_UNLOAD_POLICY_LAZY);
}
}
if (dll_handle->close (unload) != 0)
{
if (ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_DLL_Manager::unload error.\n")));
return -1;
}
}
else
{
if (ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_DLL_Manager::unload_dll called with ")
ACE_TEXT ("null pointer.\n")));
return -1;
}
return 0;
}
ACE_Message_Block::ACE_Message_Block (const ACE_Message_Block &mb,
size_t align)
:flags_ (0),
data_block_ (0)
{
ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
if (ACE_BIT_DISABLED (mb.flags_,
ACE_Message_Block::DONT_DELETE))
{
if (this->init_i (0, // size
MB_NORMAL, // type
0, // cont
0, // data
0, // allocator
0, // locking strategy
0, // flags
0, // priority
ACE_Time_Value::zero, // execution time
ACE_Time_Value::max_time, // absolute time of deadline
mb.data_block ()->duplicate (), // data block
mb.data_block ()->data_block_allocator (),
mb.message_block_allocator_) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
#if !defined (ACE_LACKS_CDR_ALIGNMENT)
// Align ourselves
char *start = ACE_ptr_align_binary (this->base (),
align);
#else
char *start = this->base ();
#endif /* ACE_LACKS_CDR_ALIGNMENT */
// Set our rd & wr pointers
this->rd_ptr (start);
this->wr_ptr (start);
}
else
{
if (this->init_i (0, // size
MB_NORMAL, // type
0, // cont
0, // data
0, // allocator
0, // locking strategy
0, // flags
0, // priority
ACE_Time_Value::zero, // execution time
ACE_Time_Value::max_time, // absolute time of deadline
mb.data_block ()->clone_nocopy (),// data block
mb.data_block ()->data_block_allocator (),
mb.message_block_allocator_) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Message_Block")));
#if !defined (ACE_LACKS_CDR_ALIGNMENT)
// Align ourselves
char *start = ACE_ptr_align_binary (this->base (),
align);
#else
char *start = this->base ();
#endif /* ACE_LACKS_CDR_ALIGNMENT */
// Set our rd & wr pointers
this->rd_ptr (start);
this->wr_ptr (start);
#if !defined (ACE_LACKS_CDR_ALIGNMENT)
// Get the alignment offset of the incoming ACE_Message_Block
start = ACE_ptr_align_binary (mb.base (),
align);
#else
start = mb.base ();
#endif /* ACE_LACKS_CDR_ALIGNMENT */
// Actual offset for the incoming message block assuming that it
// is also aligned to the same "align" byte
size_t const wr_offset = mb.wr_ptr_ - (start - mb.base ());
// Copy wr_offset amount of data in to <this->data_block>
(void) ACE_OS::memcpy (this->wr_ptr (),
start,
wr_offset);
// Dont move the write pointer, just leave it to the application
// to do what it wants
}
#if defined (ACE_LACKS_CDR_ALIGNMENT)
ACE_UNUSED_ARG (align);
#endif /* ACE_LACKS_CDR_ALIGNMENT */
}
void
CORBA::NVList::_tao_encode (TAO_OutputCDR &cdr, int flag)
{
ACE_GUARD (TAO_SYNCH_MUTEX,
ace_mon,
this->lock_);
if (this->incoming_ != 0)
{
if (this->max_ == 0)
{
// The list is empty aggressively reduce copies and just send
// the CDR stream, we assume that
// TAO_Server_Request::init_reply
// has inserted appropriated padding already to make this
// operation correct
cdr.write_octet_array_mb (this->incoming_->start ());
return;
}
// Then unmarshal each "in" and "inout" parameter.
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
for (i.first (); !i.done (); i.advance ())
{
CORBA::NamedValue_ptr *item = 0;
(void) i.next (item);
CORBA::NamedValue_ptr nv = *item;
if (ACE_BIT_DISABLED (nv->flags (), flag))
{
continue;
}
if (TAO_debug_level > 3)
{
const char* arg = nv->name ();
if (arg == 0)
{
arg = "(nil)";
}
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("NVList::_tao_encode - parameter <%C>\n"),
arg));
}
CORBA::TypeCode_ptr tc = nv->value ()->_tao_get_typecode ();
(void) TAO_Marshal_Object::perform_append (tc,
this->incoming_,
&cdr);
}
delete this->incoming_;
this->incoming_ = 0;
return;
}
// The list is already evaluated, we cannot optimize the copies, go
// ahead with the slow way to do things.
// Then marshal each "in" and "inout" parameter.
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
for (i.first (); !i.done (); i.advance ())
{
CORBA::NamedValue_ptr *item = 0;
(void) i.next (item);
CORBA::NamedValue_ptr nv = *item;
if (ACE_BIT_DISABLED (nv->flags (), flag))
{
continue;
}
nv->value ()->impl ()->marshal_value (cdr);
}
}
int
ACE_SOCK_Dgram_Mcast::open_i (const ACE_INET_Addr &mcast_addr,
const ACE_TCHAR *net_if,
int reuse_addr)
{
ACE_TRACE ("ACE_SOCK_Dgram_Mcast::open_i");
// ACE_SOCK::open calls this if reuse_addr is set, so we only need to
// process port reuse option.
if (reuse_addr)
{
#if defined (SO_REUSEPORT)
int one = 1;
if (this->ACE_SOCK::set_option (SOL_SOCKET,
SO_REUSEPORT,
&one,
sizeof one) == -1)
return -1;
#endif /* SO_REUSEPORT */
}
// Create an address/port# to bind the socket to. Use mcast_addr to
// initialize bind_addy to pick up the correct protocol family. If
// OPT_BINDADDR_YES is set, then we're done. Else use mcast_addr's
// port number and use the "any" address.
ACE_INET_Addr bind_addy (mcast_addr);
if (ACE_BIT_DISABLED (this->opts_, OPT_BINDADDR_YES))
{
#if defined (ACE_HAS_IPV6)
if (mcast_addr.get_type () == PF_INET6)
{
if (bind_addy.set (mcast_addr.get_port_number (), "::",
1, AF_INET6) == -1)
return -1;
}
else
// Bind to "any" address and explicit port#.
if (bind_addy.set (mcast_addr.get_port_number ()) == -1)
return -1;
#else
// Bind to "any" address and explicit port#.
if (bind_addy.set (mcast_addr.get_port_number ()) == -1)
return -1;
#endif /* ACE_HAS_IPV6 */
}
// Bind to the address (which may be INADDR_ANY) and port# (which may be 0)
if (ACE_SOCK_Dgram::shared_open (bind_addy, bind_addy.get_type ()) == -1)
return -1;
// Cache the actual bound address (which may be INADDR_ANY)
// and the actual bound port# (which will be a valid, non-zero port#).
ACE_INET_Addr bound_addy;
if (this->get_local_addr (bound_addy) == -1)
{
// (Unexpected failure - should be bound to something)
if (bound_addy.set (bind_addy) == -1)
{
// (Shouldn't happen - bind_addy is a valid addy; punt.)
return -1;
}
}
this->send_addr_ = mcast_addr;
this->send_addr_.set_port_number (bound_addy.get_port_number ());
if (net_if)
{
#if defined (IP_MULTICAST_IF) && (IP_MULTICAST_IF != 0)
#if defined (__linux__) && defined (ACE_HAS_IPV6)
if (mcast_addr.get_type () == AF_INET6)
{
ipv6_mreq send_mreq;
if (this->make_multicast_ifaddr6 (&send_mreq,
mcast_addr,
net_if) == -1)
return -1;
if (this->ACE_SOCK::set_option
(IPPROTO_IPV6, IPV6_MULTICAST_IF,
&(send_mreq.ipv6mr_interface),
sizeof send_mreq.ipv6mr_interface) == -1)
return -1;
}
else
{
ip_mreq send_mreq;
if (this->make_multicast_ifaddr (&send_mreq,
mcast_addr,
net_if) == -1)
return -1;
if (this->ACE_SOCK::set_option (IPPROTO_IP,
IP_MULTICAST_IF,
&(send_mreq.imr_interface),
sizeof send_mreq.imr_interface) == -1)
return -1;
}
#else
ip_mreq send_mreq;
if (this->make_multicast_ifaddr (&send_mreq,
mcast_addr,
net_if) == -1)
return -1;
if (this->ACE_SOCK::set_option (IPPROTO_IP,
IP_MULTICAST_IF,
&(send_mreq.imr_interface),
sizeof send_mreq.imr_interface) == -1)
return -1;
#endif /* __linux__ && ACE_HAS_IPV6 */
this->send_net_if_ = new ACE_TCHAR[ACE_OS::strlen (net_if) + 1];
ACE_OS::strcpy (this->send_net_if_, net_if);
#else
// Send interface option not supported - ignore it.
// (We may have been invoked by ::subscribe, so we have to allow
// a non-null interface parameter in this function.)
ACE_DEBUG ((LM_DEBUG,
ACE_LIB_TEXT ("Send interface specification not ")
ACE_LIB_TEXT ("supported - IGNORED.\n")));
#endif // IP_MULTICAST_IF
}
return 0;
}
