int MCT_Task::open (void *) { MCT_Event_Handler *handler; ACE_INET_Addr addr = this->config_.group_start (); int groups = this->config_.groups (); for (int i = 0; i < groups; ++i) { ACE_NEW_RETURN (handler, MCT_Event_Handler (this->config_.options ()), -1); // We subscribe to all groups for the first one and one each for // all the others. if (i == 0) { // go ahead and hide the other one since we want our own. ACE_INET_Addr addr = this->config_.group_start (); for (int j = 0; j < groups; ++j) { // If OPT_BINDADDR_YES is set, this will fail after the first // join, so just break and keep on going, otherwise it's a // real error. if (j > 0 && ACE_BIT_ENABLED (ACE_SOCK_Dgram_Mcast::OPT_BINDADDR_YES, this->config_.options ())) break; if (handler->join (addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("MCT_Task::open - join error\n")), -1); advance_addr (addr); } } else { if (handler->join (addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("MCT_Task::open - join error\n")), -1); } advance_addr (addr); if (this->reactor ()->register_handler (handler, READ_MASK) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("MCT_Task::open - cannot register ") ACE_TEXT ("handler\n")), -1); } if (this->activate (THR_NEW_LWP) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("MCT_TASK:open - activate failed")), -1); return 0; }
int run_test (u_long unload_mask = 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Running test with mask = %s|%s\n"), ACE_BIT_ENABLED(unload_mask, ACE_DLL_UNLOAD_POLICY_PER_DLL) == 0 ? ACE_TEXT ("PER_PROCESS") : ACE_TEXT ("PER_DLL"), ACE_BIT_ENABLED(unload_mask, ACE_DLL_UNLOAD_POLICY_LAZY) == 0 ? ACE_TEXT ("EAGER") : ACE_TEXT ("LAZY"))); ACE_DLL_Manager::instance ()->unload_policy (unload_mask); // Now, let the ACE Service Configurator framework load our service from a // dll, which contains a singleton. ACE_Service_Config::open (ACE_TEXT ("Framework_Component_Test"), ACE_DEFAULT_LOGGER_KEY, 1, 1, 1); // Now add server 1. ACE_Service_Config::process_directive (ADD_SERVICE(1)); // And unload the first one, could unload the dll. ACE_Service_Config::process_directive (REMOVE_SERVICE(1)); // Now readd server 1. ACE_Service_Config::process_directive (ADD_SERVICE(1)); // And load another service from the same library. ACE_Service_Config::process_directive (ADD_SERVICE(2)); // Unload the first one again, should *not* unload the dll this time. ACE_Service_Config::process_directive (REMOVE_SERVICE(1)); // And unload the second service. Since the ACE_DLL_Handle will no longer // have any references, the ACE_DLL_Manager will apply it's current unloading // strategy and either call ACE_OS::dlclose() immediately, schedule a timeout // the the reactor to call dlclose() some time in the future, or keep the // dll loaded until program termination. ACE_Service_Config::process_directive (REMOVE_SERVICE(2)); // Force unloading so we'll be ready for the next test. ACE_DLL_Manager::instance ()->unload_policy (ACE_DLL_UNLOAD_POLICY_DEFAULT); ACE_Service_Config::close (); return 0; }
template <ACE_SYNCH_DECL> int ACE_Stream_Head<ACE_SYNCH_USE>::canonical_flush (ACE_Message_Block *mb) { ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::canonical_flush"); char *cp = mb->rd_ptr (); if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHR)) { this->flush (ACE_Task_Flags::ACE_FLUSHALL); ACE_CLR_BITS (*cp, ACE_Task_Flags::ACE_FLUSHR); } if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHW)) return this->reply (mb); else mb->release (); return 0; }
int JAWS_IO_Reactive_Handler::handle_close (ACE_HANDLE, ACE_Reactor_Mask) { if (this->completer_) { if (ACE_BIT_ENABLED (this->mask_, ACE_Event_Handler::WRITE_MASK)) this->completer_->output_complete (this->io_result_, this->act_); else if (ACE_BIT_ENABLED (this->mask_, ACE_Event_Handler::READ_MASK)) this->completer_->input_complete (this->io_result_, this->act_); } ACE_Reactor::instance () ->remove_handler ( this , ACE_Event_Handler::RWE_MASK|ACE_Event_Handler::DONT_CALL ); delete this; return 0; }
void ACE_Select_Reactor_Impl::clear_dispatch_mask (ACE_HANDLE handle, ACE_Reactor_Mask mask) { ACE_TRACE ("ACE_Select_Reactor_Impl::clear_dispatch_mask"); // Use handle and mask in order to modify the sets // (wait/suspend/ready/dispatch), that way, the dispatch_io_set loop // will not be interrupt, and there will no reason to rescan the // wait_set and re-calling select function, which is *very* // expensive. It seems that wait/suspend/ready sets are getting // updated in register/remove bind/unbind etc functions. The only // thing need to be updated is the dispatch_set (also can be found // in that file code as dispatch_mask). Because of that, we need // that dispatch_set to be member of the ACE_Select_Reactor_impl in // Select_Reactor_Base.h file That way we will have access to that // member in that function. // We kind of invalidate the iterator in dispatch_io_set because its // an array and index built from the original dispatch-set. Take a // look at dispatch_io_set for more details. // We only need to clr_bit, because we are interested in clearing the // handles that was removed, so no dispatching to these handles will // occur. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK)) { this->dispatch_set_.rd_mask_.clr_bit (handle); } if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)) { this->dispatch_set_.wr_mask_.clr_bit (handle); } if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) { this->dispatch_set_.ex_mask_.clr_bit (handle); } // That will make the dispatch_io_set iterator re-start and rescan // the dispatch set. this->state_changed_ = true; }
int JAWS_IO_Reactive_Handler::handle_timeout (const ACE_Time_Value &, const void *) { if (this->was_active_) { this->was_active_ = 0; this->timer_id_ = ACE_Reactor::instance ()->schedule_timer (this, 0, this->tv_); return 0; } ACE_Reactor::instance () ->remove_handler ( this , ACE_Event_Handler::RWE_MASK|ACE_Event_Handler::DONT_CALL ); this->timer_id_ = -1; if (ACE_BIT_ENABLED (this->mask_, ACE_Event_Handler::WRITE_MASK)) { JAWS_Event_Result io_result ( 0 , JAWS_Event_Result::JE_ERROR , JAWS_Event_Result::JE_SEND_TIMEOUT , ETIME ); this->io_result_ = io_result; } else if (ACE_BIT_ENABLED (this->mask_, ACE_Event_Handler::READ_MASK)) { JAWS_Event_Result io_result ( 0 , JAWS_Event_Result::JE_ERROR , JAWS_Event_Result::JE_RECV_TIMEOUT , ETIME ); this->io_result_ = io_result; } return -1; }
Connection_Handler * Connection_Handler_Factory::make_connection_handler (const Connection_Config_Info &pci) { Connection_Handler *connection_handler = 0; // The next few lines of code are dependent on whether we are making // a threaded/reactive Supplier_Handler/Consumer_Handler. if (pci.connection_role_ == 'C') // Configure a Consumer_Handler. { // Create a threaded Consumer_Handler. if (ACE_BIT_ENABLED (Options::instance ()->threading_strategy (), Options::OUTPUT_MT)) ACE_NEW_RETURN (connection_handler, Thr_Consumer_Handler (pci), 0); // Create a reactive Consumer_Handler. else ACE_NEW_RETURN (connection_handler, Consumer_Handler (pci), 0); } else // connection_role == 'S', so configure a Supplier_Handler. { // Create a threaded Supplier_Handler. if (ACE_BIT_ENABLED (Options::instance ()->threading_strategy (), Options::INPUT_MT)) ACE_NEW_RETURN (connection_handler, Thr_Supplier_Handler (pci), 0); // Create a reactive Supplier_Handler. else ACE_NEW_RETURN (connection_handler, Supplier_Handler (pci), 0); } return connection_handler; }
static void handle_data (size_t &n_handles) { // Handle pending logging messages first (s_handle + 1 is guaranteed // to be lowest client descriptor). for (size_t index = 1; index < n_handles; index++) { if (ACE_BIT_ENABLED (poll_array[index].revents, POLLIN)) { // First time in, we need to initialize the buffer. if (buffer_array[index].buf_ == 0 && init_buffer (index) == -1) { ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "init_buffer")); continue; } // Read data from client (terminate on error). ssize_t n = ACE::recv (poll_array[index].fd, buffer_array[index].buf_, buffer_array[index].len_); // <recv> will not block in this case! if (n == -1) ACE_ERROR ((LM_ERROR, "%p\n", "read failed")); else if (n == 0) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) closing oneway server at handle %d\n", poll_array[index].fd)); // Handle client connection shutdown. ACE_OS::close (poll_array[index].fd); poll_array[index].fd = poll_array[--n_handles].fd; ACE_OS::free ((void *) buffer_array[index].buf_); buffer_array[index].buf_ = 0; buffer_array[index].len_ = 0; } else if (verbose) ACE_DEBUG ((LM_DEBUG, "(%P|%t) %*s", n, buffer_array[index].buf_)); } } }
int Sender::initiate_io (ACE_Reactor_Mask mask) { if (ACE_BIT_ENABLED (flg_mask_, mask)) return 0; if (ACE_Reactor::instance ()->schedule_wakeup (this, mask) == -1) return -1; ACE_SET_BITS (flg_mask_, mask); return 0; }
int JAWS_IO_Reactive_Handler::handle_exception (ACE_HANDLE handle) { if (handle == ACE_INVALID_HANDLE) { // We are being called back from a notify call. // This is our cue to register ourselves with the Reactor. int result; result = ACE_Reactor::instance () ->register_handler (this, this->mask_|ACE_Event_Handler::EXCEPT_MASK); if (result < 0) this->close (result); return 0; } // back to our regularly scheduled except mask handling. if (ACE_BIT_ENABLED (this->mask_, ACE_Event_Handler::WRITE_MASK)) { JAWS_Event_Result io_result ( this->bytes_ , JAWS_Event_Result::JE_ERROR , JAWS_Event_Result::JE_SEND_SHORT ); this->io_result_ = io_result; } else if (ACE_BIT_ENABLED (this->mask_, ACE_Event_Handler::READ_MASK)) { JAWS_Event_Result io_result ( this->bytes_ , JAWS_Event_Result::JE_ERROR , JAWS_Event_Result::JE_RECV_SHORT ); this->io_result_ = io_result; } return -1; }
void MCT_Config::dump (void) const { ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" Dumping MCT_Config\n"))); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\tIP_MAX_MEMBERSHIPS = %d\n"), IP_MAX_MEMBERSHIPS)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\tgroups_ = %d\n"), this->groups_)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\trole_ = %s\n"), (ACE_BIT_ENABLED (this->role_, PRODUCER) && ACE_BIT_ENABLED (this->role_, CONSUMER)) ? ACE_TEXT ("PRODUCER/CONSUMER") : ACE_BIT_ENABLED (this->role_, PRODUCER) ? ACE_TEXT ("PRODUCER") : ACE_TEXT ("CONSUMER"))); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\tsdm_options_ = %d\n"), this->sdm_opts_)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\titerations_ = %d\n"), this->iterations_)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\tttl_ = %d\n"), this->ttl_)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\twait_ = %d\n"), this->wait_)); // Note that this call to get_host_addr is the non-reentrant // version, but it's okay for us. ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\tgroups_start_ = %s:%d\n"), this->group_start_.get_host_addr (), this->group_start_.get_port_number ())); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }
template <ACE_SYNCH_DECL, class TIME_POLICY> int ACE_Stream_Tail<ACE_SYNCH_USE, TIME_POLICY>::canonical_flush (ACE_Message_Block *mb) { ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE, TIME_POLICY>::canonical_flush"); char *cp = mb->rd_ptr (); if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHW)) { this->flush (ACE_Task_Flags::ACE_FLUSHALL); ACE_CLR_BITS (*cp, ACE_Task_Flags::ACE_FLUSHW); } if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHR)) { this->sibling ()->flush (ACE_Task_Flags::ACE_FLUSHALL); return this->reply (mb); } else mb->release (); return 0; }
int ACE_Process_Manager::reap (pid_t pid, ACE_exitcode *stat_loc, int options) { ACE_TRACE ("ACE_Process_Manager::reap"); return this->wait (pid, (ACE_BIT_ENABLED (options, WNOHANG) ? ACE_Time_Value::zero : ACE_Time_Value::max_time), stat_loc); }
template <ACE_SYNCH_DECL> int ACE_Module<ACE_SYNCH_USE>::close_i (int which, int flags) { ACE_TRACE ("ACE_Module<ACE_SYNCH_USE>::close_i"); if (this->q_pair_[which] == 0) return 0; // Copy task pointer to prevent problems when ACE_Task::close // changes the task pointer ACE_Task<ACE_SYNCH_USE> *task = this->q_pair_[which]; // Change so that close doesn't get called again from the task base. // Now close the task. int result = 0; if (task->module_closed () == -1) result = -1; task->flush (); task->next (0); // Should we also delete it ? if (flags != M_DELETE_NONE && ACE_BIT_ENABLED (flags_, which + 1)) { // Only delete the Tasks if there aren't any more threads // running in them. task->wait (); // If this assert happens it is likely because the task was // activated with the THR_DETACHED flag, which means that we // can't join() with the thread. Not using THR_DETACHED should // solve this problem. ACE_ASSERT (task->thr_count () == 0); delete task; } // Set the tasks pointer to 0 so that we don't try to close() // this object again if the destructor gets called. this->q_pair_[which] = 0; // Finally remove the delete bit. ACE_CLR_BITS (flags_, which + 1); return result; }
bool Eager_Transport_Queueing_Strategy::timer_check ( const TAO::BufferingConstraint &buffering_constraint, const ACE_Time_Value ¤t_deadline, bool &set_timer, ACE_Time_Value &new_deadline) const { set_timer = false; if (!ACE_BIT_ENABLED (buffering_constraint.mode, TAO::BUFFER_TIMEOUT)) { return false; } // Compute the next deadline... ACE_Time_Value const now = ACE_OS::gettimeofday (); ACE_Time_Value timeout = this->time_conversion (buffering_constraint.timeout); new_deadline = now + timeout; // Check if the new deadline is more stringent, or if the deadline // has expired and thus must be reset anyway. if (current_deadline > new_deadline || current_deadline < now) { set_timer = true; } // ... if there is no deadline we don't want to schedule output (the // deadline will be set because set_timer is set to 1 in that case). // If there is a deadline but but it has not been reached, we // don't want to schedule any output either... if (current_deadline == ACE_Time_Value::zero || current_deadline >= now) { return false; } if (TAO_debug_level > 6) { TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - TAO_Eager_Buffering_Sync_Strategy::timer_check, " "Now = %u, Current = %u, New = %u\n", now.msec (), current_deadline.msec (), new_deadline.msec ())); } return true; }
int ACE_Service_Type_Impl::fini (void) const { ACE_TRACE ("ACE_Service_Type_Impl::fini"); delete [] const_cast <ACE_TCHAR *> (this->name_); (const_cast <ACE_Service_Type_Impl *> (this))->name_ = 0; if (ACE_BIT_ENABLED (this->flags_, ACE_Service_Type::DELETE_OBJ)) { if (gobbler_ != 0) gobbler_ (this->object ()); else // Cast to remove const-ness. operator delete ((void *) this->object ()); } if (ACE_BIT_ENABLED (this->flags_, ACE_Service_Type::DELETE_THIS)) delete const_cast <ACE_Service_Type_Impl *> (this); return 0; }
int ACE_XtReactor::compute_Xt_condition(ACE_HANDLE handle) { ACE_TRACE ("ACE_XtReactor::compute_Xt_condition"); // Retrieve current wait mask from base class. // The returned value is either a combination of READ/WRITE/EXCEPT_MASK // or -1. int mask =this->bit_ops(handle, 0, this->wait_set_, ACE_Reactor::GET_MASK); if (mask == -1) // No active mask. return 0; int condition = 0; #if !defined ACE_WIN32 if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK)) ACE_SET_BITS (condition, XtInputReadMask); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)) ACE_SET_BITS (condition, XtInputWriteMask); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) ACE_SET_BITS (condition, XtInputExceptMask); #else if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK)) ACE_SET_BITS (condition, XtInputReadWinsock); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)) ACE_SET_BITS (condition, XtInputWriteWinsock); // EXCEPT_MASK is not supported for WIN32. As this was // already handled in register_handler_i, no check here. #endif /* !ACE_WIN32 */ return condition; }
TAO_Queued_Data * TAO_Queued_Data::duplicate (TAO_Queued_Data &sqd) { // Check to see if the underlying block is on the stack. If not it // is fine. If the datablock is on stack, try to make a copy of that // before doing a duplicate. // @@ todo: Theoretically this should be within the Message Block, // but we dont have much scope to do this in that mess. Probably in // the next stage of MB rewrite we should be okay ACE_Message_Block::Message_Flags fl = sqd.msg_block_->self_flags (); if (ACE_BIT_ENABLED (fl, ACE_Message_Block::DONT_DELETE)) (void) TAO_Queued_Data::replace_data_block (*sqd.msg_block_); TAO_Queued_Data *qd = 0; if (sqd.allocator_) { ACE_NEW_MALLOC_RETURN (qd, static_cast<TAO_Queued_Data *> ( sqd.allocator_->malloc (sizeof (TAO_Queued_Data))), TAO_Queued_Data (sqd), 0); return qd; } // No allocator, so use the global pool! // @@ TODO: We should be removing this at some point of time! if (TAO_debug_level == 4) { // This debug is for testing purposes! TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Queued_Data[%d]::duplicate\n", "Using global pool for allocation\n")); } ACE_NEW_RETURN (qd, TAO_Queued_Data (sqd), 0); return qd; }
int TRB_POSIX_Proactor::register_handle (ACE_HANDLE handle, const void *completion_key, int operations) { TRB_POSIX_AIO_Processor * aio_processor = this->find_processor(operations); if (aio_processor != 0) return aio_processor->register_handle (handle, completion_key, operations); if (ACE_BIT_ENABLED(operations, TRB_Asynch_Result::OP_READ_MASK | TRB_Asynch_Result::OP_WRITE_MASK)) { return -1; // we need provider for these operations } return 0; }
int ACE_Service_Object_Type::fini (void) const { ACE_TRACE ("ACE_Service_Object_Type::fini"); void *obj = this->object (); ACE_Service_Object *so = (ACE_Service_Object *) obj; if (so) { so->fini (); #if 0 if (ACE_BIT_ENABLED (this->flags_, ACE_Service_Type::DELETE_OBJ)) delete so; #endif /* 1 */ } return ACE_Service_Type_Impl::fini (); }
int ACE_XtReactor::register_handler_i (ACE_HANDLE handle, ACE_Event_Handler *handler, ACE_Reactor_Mask mask) { ACE_TRACE ("ACE_XtReactor::register_handler_i"); // Make sure we have a valid context ACE_ASSERT (this->context_ != 0); #if defined ACE_WIN32 // Let's handle this special case before we do any real work. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) ACE_NOTSUP_RETURN(-1); #endif /* ACE_WIN32 */ int result = ACE_Select_Reactor::register_handler_i (handle, handler, mask); if (result == -1) return -1; synchronize_XtInput (handle); return 0; }
int ACE_QtReactor::set_enable_flag_by_mask (int flag_value, ACE_HANDLE handle, ACE_Reactor_Mask mask) { QSocketNotifier *qs_not; if (ACE_BIT_ENABLED(mask, ACE_Event_Handler::READ_MASK) || ACE_BIT_ENABLED( mask, ACE_Event_Handler::ACCEPT_MASK)) { // Find the current notifier qs_not = 0; if ((this->read_notifier_.find (handle, qs_not) == -1)) return -1; qs_not->setEnabled (flag_value); } if (ACE_BIT_ENABLED( mask, ACE_Event_Handler::WRITE_MASK) || ACE_BIT_ENABLED( mask, ACE_Event_Handler::ACCEPT_MASK) || ACE_BIT_ENABLED( mask, ACE_Event_Handler::CONNECT_MASK)) { qs_not = 0; if ((this->write_notifier_.find (handle, qs_not) == -1)) return -1; qs_not->setEnabled (flag_value); } if (ACE_BIT_ENABLED( mask, ACE_Event_Handler::EXCEPT_MASK)) { qs_not = 0; if ((this->exception_notifier_.find (handle, qs_not) == -1)) return -1; qs_not->setEnabled (flag_value); } return 0; }
int ACE_SOCK_Dgram_Bcast::mk_broadcast (const ACE_TCHAR *host_name) { ACE_TRACE ("ACE_SOCK_Dgram_Bcast::mk_broadcast"); int one = 1; if (ACE_OS::setsockopt (this->get_handle (), SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof one) == -1) ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: setsockopt failed")), -1); #if !defined (ACE_WIN32) && !defined(__INTERIX) ACE_HANDLE s = this->get_handle (); char buf[BUFSIZ]; struct ifconf ifc; ifc.ifc_len = sizeof buf; ifc.ifc_buf = buf; // Get interface structure and initialize the addresses using UNIX // techniques. if (ACE_OS::ioctl (s, SIOCGIFCONF, (char *) &ifc) == -1) ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: ioctl (get interface configuration)")), ACE_INVALID_HANDLE); struct ifreq *ifr = ifc.ifc_req; struct sockaddr_in host_addr; // Get host ip address if (host_name) { hostent *hp = ACE_OS::gethostbyname (ACE_TEXT_ALWAYS_CHAR (host_name)); if (hp == 0) return -1; else ACE_OS::memcpy ((char *) &host_addr.sin_addr.s_addr, # ifdef ACE_HOSTENT_H_ADDR (char *) hp->ACE_HOSTENT_H_ADDR, # else (char *) hp->h_addr, # endif hp->h_length); } #if !defined(AIX) && !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_VXWORKS) && !defined(__APPLE__) for (int n = ifc.ifc_len / sizeof (struct ifreq) ; n > 0; n--, ifr++) #else /* There are addresses longer than sizeof (struct sockaddr) eg. IPv6 or QNX::links. In this case address does not fit into struct ifreq. The code below could be applied everywhere, but not every system provides sockaddr.sa_len field. */ for (int nbytes = ifc.ifc_len; nbytes >= (int) sizeof (struct ifreq) && ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ? (nbytes >= (int) sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len) : 1); ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ? (nbytes -= sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len, ifr = (struct ifreq *) ((caddr_t) &ifr->ifr_addr + ifr->ifr_addr.sa_len)) : (nbytes -= sizeof (struct ifreq), ifr++))) #endif /* !defined(AIX) && !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_VXWORKS) && !defined(__APPLE__) */ { #if defined (__QNX__) || defined (ACE_VXWORKS) // Silently skip link interfaces if (ifr->ifr_addr.sa_family == AF_LINK) continue; #endif /* __QNX__ || ACE_VXWORKS */ // Compare host ip address with interface ip address. if (host_name) { struct sockaddr_in if_addr; ACE_OS::memcpy (&if_addr, &ifr->ifr_addr, sizeof if_addr); if (host_addr.sin_addr.s_addr != if_addr.sin_addr.s_addr) continue; } if (ifr->ifr_addr.sa_family != AF_INET) { // Note that some systems seem to generate 0 (AF_UNDEF) for // the sa_family, even when there are no errors! Thus, we // only print an error if this is not the case, or if we're // in "debugging" mode. if (ifr->ifr_addr.sa_family != 0 || ACE::debug ()) ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT("warning %p: sa_family: %d\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: Not AF_INET"), ifr->ifr_addr.sa_family)); continue; } struct ifreq flags = *ifr; struct ifreq if_req = *ifr; if (ACE_OS::ioctl (s, SIOCGIFFLAGS, (char *) &flags) == -1) { ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p [%s]\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: ioctl (get interface flags)"), flags.ifr_name)); continue; } if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_UP) == 0) { ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p [%s]\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: Network interface is not up"), flags.ifr_name)); continue; } if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_LOOPBACK)) continue; if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_BROADCAST)) { if (ACE_OS::ioctl (s, SIOCGIFBRDADDR, (char *) &if_req) == -1) ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p [%s]\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: ioctl (get broadaddr)"), flags.ifr_name)); else { ACE_INET_Addr addr (reinterpret_cast <sockaddr_in *> (&if_req.ifr_broadaddr), sizeof if_req.ifr_broadaddr); ACE_NEW_RETURN (this->if_list_, ACE_Bcast_Node (addr, this->if_list_), -1); } } else { if (host_name != 0) ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p [%s]\n"), ACE_TEXT("ACE_SOCK_Dgram_Bcast::mk_broadcast: Broadcast is not enabled for this interface."), flags.ifr_name)); } } #else ACE_UNUSED_ARG (host_name); ACE_INET_Addr addr (u_short (0), ACE_UINT32 (INADDR_BROADCAST)); ACE_NEW_RETURN (this->if_list_, ACE_Bcast_Node (addr, this->if_list_), -1); #endif /* !ACE_WIN32 && !__INTERIX */ if (this->if_list_ == 0) { errno = ENXIO; return -1; } else return 0; }
int Cubit_Client::check_enabled (u_int mask) const { return ACE_BIT_ENABLED (this->test_enable_bitset_, mask); }
// Perform GET, CLR, SET, and ADD operations on the Handle_Sets. // // GET = 1, Retrieve current value // SET = 2, Set value of bits to new mask (changes the entire mask) // ADD = 3, Bitwise "or" the value into the mask (only changes // enabled bits) // CLR = 4 Bitwise "and" the negation of the value out of the mask // (only changes enabled bits) // // Returns the original mask. Must be called with locks held. int ACE_Select_Reactor_Impl::bit_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Select_Reactor_Handle_Set &handle_set, int ops) { ACE_TRACE ("ACE_Select_Reactor_Impl::bit_ops"); if (this->handler_rep_.handle_in_range (handle) == 0) return -1; #if !defined (ACE_WIN32) ACE_Sig_Guard sb (0, this->mask_signals_); // Block out all signals until method returns. #endif /* ACE_WIN32 */ ACE_FDS_PTMF ptmf = &ACE_Handle_Set::set_bit; u_long omask = ACE_Event_Handler::NULL_MASK; // Find the old reactor masks. This automatically does the work of // the GET_MASK operation. if (handle_set.rd_mask_.is_set (handle)) ACE_SET_BITS (omask, ACE_Event_Handler::READ_MASK); if (handle_set.wr_mask_.is_set (handle)) ACE_SET_BITS (omask, ACE_Event_Handler::WRITE_MASK); if (handle_set.ex_mask_.is_set (handle)) ACE_SET_BITS (omask, ACE_Event_Handler::EXCEPT_MASK); switch (ops) { case ACE_Reactor::GET_MASK: // The work for this operation is done in all cases at the // begining of the function. break; case ACE_Reactor::CLR_MASK: ptmf = &ACE_Handle_Set::clr_bit; // State was changed. we need to reflect that change in the // dispatch_mask I assume that only ACE_Reactor::CLR_MASK should // be treated here which means we need to clear the handle|mask // from the current dispatch handler this->clear_dispatch_mask (handle, mask); /* FALLTHRU */ case ACE_Reactor::SET_MASK: /* FALLTHRU */ case ACE_Reactor::ADD_MASK: // The following code is rather subtle... Note that if we are // doing a ACE_Reactor::SET_MASK then if the bit is not enabled // in the mask we need to clear the bit from the ACE_Handle_Set. // On the other hand, if we are doing a ACE_Reactor::CLR_MASK or // a ACE_Reactor::ADD_MASK we just carry out the operations // specified by the mask. // READ, ACCEPT, and CONNECT flag will place the handle in the // read set. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)) { (handle_set.rd_mask_.*ptmf) (handle); } else if (ops == ACE_Reactor::SET_MASK) handle_set.rd_mask_.clr_bit (handle); // WRITE and CONNECT flag will place the handle in the write set if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)) { (handle_set.wr_mask_.*ptmf) (handle); } else if (ops == ACE_Reactor::SET_MASK) handle_set.wr_mask_.clr_bit (handle); // EXCEPT (and CONNECT on Win32) flag will place the handle in // the except set. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK) #if defined (ACE_WIN32) || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK) #endif /* ACE_WIN32 */ ) { (handle_set.ex_mask_.*ptmf) (handle); } else if (ops == ACE_Reactor::SET_MASK) handle_set.ex_mask_.clr_bit (handle); break; default: return -1; } return omask; }
int ACE_Select_Reactor_Handler_Repository::unbind ( ACE_HANDLE handle, map_type::iterator pos, ACE_Reactor_Mask mask) { ACE_TRACE ("ACE_Select_Reactor_Handler_Repository::unbind"); // Retrieve event handler before unbinding it from the map. The // iterator pointing to it will no longer be valid once the handler // is unbound. ACE_Event_Handler * const event_handler = (pos == this->event_handlers_.end () ? 0 : ACE_SELECT_REACTOR_EVENT_HANDLER (pos)); // Clear out the <mask> bits in the Select_Reactor's wait_set. this->select_reactor_.bit_ops (handle, mask, this->select_reactor_.wait_set_, ACE_Reactor::CLR_MASK); // And suspend_set. this->select_reactor_.bit_ops (handle, mask, this->select_reactor_.suspend_set_, ACE_Reactor::CLR_MASK); // Note the fact that we've changed the state of the <wait_set_>, // which is used by the dispatching loop to determine whether it can // keep going or if it needs to reconsult select(). // this->select_reactor_.state_changed_ = 1; // If there are no longer any outstanding events on this <handle> // then we can totally shut down the Event_Handler. bool const has_any_wait_mask = (this->select_reactor_.wait_set_.rd_mask_.is_set (handle) || this->select_reactor_.wait_set_.wr_mask_.is_set (handle) || this->select_reactor_.wait_set_.ex_mask_.is_set (handle)); bool const has_any_suspend_mask = (this->select_reactor_.suspend_set_.rd_mask_.is_set (handle) || this->select_reactor_.suspend_set_.wr_mask_.is_set (handle) || this->select_reactor_.suspend_set_.ex_mask_.is_set (handle)); bool complete_removal = false; if (!has_any_wait_mask && !has_any_suspend_mask) { #if defined (ACE_WIN32) if (event_handler != 0 && this->event_handlers_.unbind (pos) == -1) return -1; // Should not happen! #else this->event_handlers_[handle] = 0; if (this->max_handlep1_ == handle + 1) { // We've deleted the last entry, so we need to figure out // the last valid place in the array that is worth looking // at. ACE_HANDLE const wait_rd_max = this->select_reactor_.wait_set_.rd_mask_.max_set (); ACE_HANDLE const wait_wr_max = this->select_reactor_.wait_set_.wr_mask_.max_set (); ACE_HANDLE const wait_ex_max = this->select_reactor_.wait_set_.ex_mask_.max_set (); ACE_HANDLE const suspend_rd_max = this->select_reactor_.suspend_set_.rd_mask_.max_set (); ACE_HANDLE const suspend_wr_max = this->select_reactor_.suspend_set_.wr_mask_.max_set (); ACE_HANDLE const suspend_ex_max = this->select_reactor_.suspend_set_.ex_mask_.max_set (); // Compute the maximum of six values. this->max_handlep1_ = wait_rd_max; if (this->max_handlep1_ < wait_wr_max) this->max_handlep1_ = wait_wr_max; if (this->max_handlep1_ < wait_ex_max) this->max_handlep1_ = wait_ex_max; if (this->max_handlep1_ < suspend_rd_max) this->max_handlep1_ = suspend_rd_max; if (this->max_handlep1_ < suspend_wr_max) this->max_handlep1_ = suspend_wr_max; if (this->max_handlep1_ < suspend_ex_max) this->max_handlep1_ = suspend_ex_max; ++this->max_handlep1_; } #endif /* ACE_WIN32 */ // The handle has been completely removed. complete_removal = true; } if (event_handler == 0) return -1; bool const requires_reference_counting = event_handler->reference_counting_policy ().value () == ACE_Event_Handler::Reference_Counting_Policy::ENABLED; // Close down the <Event_Handler> unless we've been instructed not // to. if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::DONT_CALL) == 0) (void) event_handler->handle_close (handle, mask); // Call remove_reference() if the removal is complete and reference // counting is needed. if (complete_removal && requires_reference_counting) { (void) event_handler->remove_reference (); } return 0; }
TAO::Collocation_Strategy Invocation_Adapter::collocation_strategy (CORBA::Object_ptr object) { TAO::Collocation_Strategy strategy = TAO::TAO_CS_REMOTE_STRATEGY; TAO_Stub *stub = object->_stubobj (); if (!CORBA::is_nil (stub->servant_orb_var ().in ()) && stub->servant_orb_var ()->orb_core () != 0) { TAO_ORB_Core *orb_core = stub->servant_orb_var ()->orb_core (); if (orb_core->collocation_resolver ().is_collocated (object)) { switch (orb_core->get_collocation_strategy ()) { case TAO_ORB_Core::TAO_COLLOCATION_THRU_POA: { // check opportunity if (ACE_BIT_ENABLED (this->collocation_opportunity_, TAO::TAO_CO_THRU_POA_STRATEGY)) { strategy = TAO::TAO_CS_THRU_POA_STRATEGY; } else { if (TAO_debug_level > 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("Invocation_Adapter::collocation_strategy, ") ACE_TEXT ("request for through poa collocation ") ACE_TEXT ("without needed collocation opportunity.\n"))); } // collocation object, but no collocation_opportunity for Thru_poa throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO); } break; } case TAO_ORB_Core::TAO_COLLOCATION_DIRECT: { if (ACE_BIT_ENABLED (this->collocation_opportunity_, TAO::TAO_CO_DIRECT_STRATEGY) && (object->_servant () != 0)) { strategy = TAO::TAO_CS_DIRECT_STRATEGY; } else { if (TAO_debug_level > 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("Invocation_Adapter::collocation_strategy, ") ACE_TEXT ("request for direct collocation ") ACE_TEXT ("without needed collocation opportunity.\n"))); } // collocation object, but no collocation_opportunity for Direct // or servant() == 0 throw ::CORBA::INTERNAL ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO); } break; } case TAO_ORB_Core::TAO_COLLOCATION_BEST: { if (ACE_BIT_ENABLED (this->collocation_opportunity_, TAO::TAO_CO_DIRECT_STRATEGY) && (object->_servant () != 0)) { strategy = TAO::TAO_CS_DIRECT_STRATEGY; } else if (ACE_BIT_ENABLED (this->collocation_opportunity_, TAO::TAO_CO_THRU_POA_STRATEGY)) { strategy = TAO::TAO_CS_THRU_POA_STRATEGY; } else { strategy = TAO::TAO_CS_REMOTE_STRATEGY; } break; } } } } return strategy; }
int ACE_Log_Record::format_msg (const ACE_TCHAR host_name[], u_long verbose_flag, ACE_TCHAR *verbose_msg) { /* 0123456789012345678901234 */ /* Oct 18 14:25:36.000 1989<nul> */ ACE_TCHAR timestamp[26]; // Only used by VERBOSE and VERBOSE_LITE. // The sprintf format needs to be different for Windows and POSIX // in the wide-char case. #if defined (ACE_WIN32) || !defined (ACE_USES_WCHAR) const ACE_TCHAR *time_fmt = ACE_TEXT ("%s.%03ld %s"); const ACE_TCHAR *verbose_fmt = ACE_TEXT ("%s@%s@%u@%s@%s"); const ACE_TCHAR *verbose_lite_fmt = ACE_TEXT ("%s@%s@%s"); #else const ACE_TCHAR *time_fmt = ACE_TEXT ("%ls.%03ld %ls"); const ACE_TCHAR *verbose_fmt = ACE_TEXT ("%ls@%ls@%u@%ls@%ls"); const ACE_TCHAR *verbose_lite_fmt = ACE_TEXT ("%ls@%ls@%ls"); #endif if (ACE_BIT_ENABLED (verbose_flag, ACE_Log_Msg::VERBOSE) || ACE_BIT_ENABLED (verbose_flag, ACE_Log_Msg::VERBOSE_LITE)) { time_t const now = this->secs_; ACE_TCHAR ctp[26]; // 26 is a magic number... if (ACE_OS::ctime_r (&now, ctp, sizeof ctp / sizeof (ACE_TCHAR)) == 0) return -1; /* 01234567890123456789012345 */ /* Wed Oct 18 14:25:36 1989n0 */ ctp[19] = '\0'; // NUL-terminate after the time. ctp[24] = '\0'; // NUL-terminate after the date. ACE_OS::sprintf (timestamp, time_fmt, ctp + 4, ((long) this->usecs_) / 1000, ctp + 20); } if (ACE_BIT_ENABLED (verbose_flag, ACE_Log_Msg::VERBOSE)) { const ACE_TCHAR *lhost_name = ((host_name == 0) ? ACE_TEXT ("<local_host>") : host_name); ACE_OS::sprintf (verbose_msg, verbose_fmt, timestamp, lhost_name, this->pid_, ACE_Log_Record::priority_name (ACE_Log_Priority (this->type_)), this->msg_data_); } else if (ACE_BIT_ENABLED (verbose_flag, ACE_Log_Msg::VERBOSE_LITE)) ACE_OS::sprintf (verbose_msg, verbose_lite_fmt, timestamp, ACE_Log_Record::priority_name (ACE_Log_Priority (this->type_)), this->msg_data_); else ACE_OS::strcpy (verbose_msg, this->msg_data_); return 0; }
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; }
int ACE_TkReactor::register_handler_i (ACE_HANDLE handle, ACE_Event_Handler *handler, ACE_Reactor_Mask mask) { ACE_TRACE ("ACE_TkReactor::register_handler_i"); int result = ACE_Select_Reactor::register_handler_i (handle, handler, mask); if (result == -1) return -1; int condition = 0; #if !defined ACE_WIN32 if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK)) ACE_SET_BITS (condition, TK_READABLE); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)) ACE_SET_BITS (condition, TK_WRITABLE); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) ACE_SET_BITS (condition, TK_EXCEPTION); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK)) ACE_SET_BITS (condition, TK_READABLE); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)){ ACE_SET_BITS (condition, TK_READABLE); // connected, you may write ACE_SET_BITS (condition, TK_WRITABLE); // connected, you have data/err } #else if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK)) ACE_SET_BITS (condition, TK_READABLE); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)) ACE_SET_BITS (condition, TK_WRITABLE); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) ACE_NOTSUP_RETURN(-1); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK)) ACE_SET_BITS (condition, TK_READABLE); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)){ ACE_SET_BITS (condition, TK_READABLE); // connected, you may write ACE_SET_BITS (condition, TK_WRITABLE); // connected, you have data/err } #endif /* !ACE_WIN32 */ if (condition != 0) { ACE_TkReactorID *TkID = this->ids_; while(TkID) { if (TkID->handle_ == handle) { ::Tk_DeleteFileHandler (TkID->handle_); ACE_TkReactor_Input_Callback *callback; ACE_NEW_RETURN (callback, ACE_TkReactor_Input_Callback, -1); callback->reactor_ = this; callback->handle_ = handle; ::Tk_CreateFileHandler ((int) handle, condition, InputCallbackProc, (ClientData) callback); return 0; } else TkID = TkID->next_; } ACE_NEW_RETURN (TkID, ACE_TkReactorID, -1); TkID->next_ = this->ids_; TkID->handle_ = handle; ACE_TkReactor_Input_Callback *callback; ACE_NEW_RETURN (callback, ACE_TkReactor_Input_Callback, -1); callback->reactor_ = this; callback->handle_ = handle; ::Tk_CreateFileHandler ((int) handle, condition, InputCallbackProc, (ClientData) callback); this->ids_ = TkID; } return 0; }