int ACE_OS::sprintf (wchar_t *buf, const wchar_t *format, ...) { // ACE_OS_TRACE ("ACE_OS::sprintf"); #if defined (ACE_LACKS_VA_FUNCTIONS) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (format); ACE_NOTSUP_RETURN (-1); #else va_list ap; va_start (ap, format); int const result = ACE_OS::vsprintf (buf, format, ap); va_end (ap); return result; #endif /* ACE_LACKS_VA_FUNCTIONS */ }
// purge_pending_notifications // Removes all entries from the notify_queue_ and each one that // matches <eh> is put on the free_queue_. The rest are saved on a // local queue and copied back to the notify_queue_ at the end. // Returns the number of entries removed. Returns -1 on error. // ACE_NOTSUP_RETURN if ACE_HAS_REACTOR_NOTIFICATION_QUEUE is not defined. int ACE_Select_Reactor_Notify::purge_pending_notifications (ACE_Event_Handler *eh, ACE_Reactor_Mask mask ) { ACE_TRACE ("ACE_Select_Reactor_Notify::purge_pending_notifications"); #if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) return notification_queue_.purge_pending_notifications(eh, mask); #else /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ ACE_UNUSED_ARG (eh); ACE_UNUSED_ARG (mask); ACE_NOTSUP_RETURN (-1); #endif /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ }
int ACE_INET_Addr::set (const char port_name[], ACE_UINT32 inet_address, const char protocol[]) { ACE_TRACE ("ACE_INET_Addr::set"); int const port_number = get_port_number_from_name (port_name, protocol); if (port_number == -1) { ACE_NOTSUP_RETURN (-1); } return this->set (static_cast<u_short> (port_number), inet_address, 0); }
int ACE_SSL_Context::egd_file (const char * socket_file) { #if OPENSSL_VERSION_NUMBER < 0x00905100L // OpenSSL < 0.9.5 doesn't have EGD support. ACE_UNUSED_ARG (socket_file); ACE_NOTSUP_RETURN (-1); #else // RAND_egd() returns the amount of entropy used to seed the random // number generator. The actual value should be greater than 16, // i.e. 128 bits. if (::RAND_egd (socket_file) > 0) return 0; else return -1; #endif /* OPENSSL_VERSION_NUMBER >= 0x00905100L */ }
int ACE_Event_Handler::remove_stdin_handler (ACE_Reactor *reactor, ACE_Thread_Manager *thr_mgr) { #if defined (ACE_WIN32) ACE_UNUSED_ARG (reactor); ACE_UNUSED_ARG (thr_mgr); // What should we do here? ACE_NOTSUP_RETURN (-1); #else // Keep compilers happy. ACE_UNUSED_ARG (thr_mgr); return reactor->remove_handler (ACE_STDIN, ACE_Event_Handler::READ_MASK); #endif /* ACE_WIN32 */ }
long ACE_OS::num_processors (void) { ACE_OS_TRACE ("ACE_OS::num_processors"); #if defined (ACE_HAS_PHARLAP) return 1; #elif defined (ACE_WIN32) || defined (ACE_WIN64) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return sys_info.dwNumberOfProcessors; #elif defined (linux) || defined (sun) return ::sysconf (_SC_NPROCESSORS_CONF); #else ACE_NOTSUP_RETURN (-1); #endif }
FILE * ACE_OS::fopen (const wchar_t *filename, const ACE_TCHAR *mode) { ACE_OS_TRACE ("ACE_OS::fopen"); #if defined (ACE_LACKS_FOPEN) ACE_UNUSED_ARG (filename); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (0); #else int hmode = _O_TEXT; for (const ACE_TCHAR *mode_ptr = mode; *mode_ptr != 0; mode_ptr++) fopen_mode_to_open_mode_converter (*mode_ptr, hmode); ACE_HANDLE handle = ACE_OS::open (filename, hmode); if (handle != ACE_INVALID_HANDLE) { hmode &= _O_TEXT | _O_RDONLY | _O_APPEND; int const fd = ::_open_osfhandle (intptr_t (handle), hmode); if (fd != -1) { # if defined (ACE_HAS_NONCONST_FDOPEN) && !defined (ACE_USES_WCHAR) FILE *fp = ::_fdopen (fd, const_cast<char *> (mode)); # elif defined (ACE_HAS_NONCONST_FDOPEN) && defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, const_cast<wchar_t *> (mode)); # elif defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, mode); # else FILE *fp = ::fdopen (fd, mode); # endif /* defined(ACE_HAS_NONCONST_FDOPEN) && !defined (ACE_USES_WCHAR)) */ if (fp != 0) { return fp; } ::_close (fd); } ACE_OS::close (handle); } return 0; #endif }
int ACE_Sched_Params::previous_priority (const Policy policy, const int priority, const int scope) { #if defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (policy); ACE_UNUSED_ARG (scope); switch (priority) { case THREAD_PRIORITY_IDLE: return THREAD_PRIORITY_IDLE; case THREAD_PRIORITY_LOWEST: return THREAD_PRIORITY_IDLE; case THREAD_PRIORITY_BELOW_NORMAL: return THREAD_PRIORITY_LOWEST; case THREAD_PRIORITY_NORMAL: return THREAD_PRIORITY_BELOW_NORMAL; case THREAD_PRIORITY_ABOVE_NORMAL: return THREAD_PRIORITY_NORMAL; case THREAD_PRIORITY_HIGHEST: return THREAD_PRIORITY_ABOVE_NORMAL; case THREAD_PRIORITY_TIME_CRITICAL: return THREAD_PRIORITY_HIGHEST; default: return priority; // unknown priority: should never get here } #elif defined(ACE_HAS_THREADS) && \ (!defined(ACE_LACKS_SETSCHED) || defined (ACE_TANDEM_T1248_PTHREADS) || \ defined (ACE_HAS_PTHREAD_SCHEDPARAM)) // including STHREADS and PTHREADS int const min = priority_min (policy, scope); return priority > min ? priority - 1 : min; #elif defined (ACE_VXWORKS) return priority < priority_min (policy, scope) ? priority + 1 : priority_min (policy, scope); #else ACE_UNUSED_ARG (policy); ACE_UNUSED_ARG (scope); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }
int ACE_Shared_Memory_Pool::find_seg (const void* const searchPtr, ACE_OFF_T &offset, size_t &counter) { #ifndef ACE_HAS_SYSV_IPC ACE_UNUSED_ARG (searchPtr); ACE_UNUSED_ARG (offset); ACE_UNUSED_ARG (counter); ACE_NOTSUP_RETURN (-1); #else offset = 0; SHM_TABLE *st = reinterpret_cast<SHM_TABLE *> (this->base_addr_); shmid_ds buf; for (counter = 0; counter < this->max_segments_ && st[counter].used_ == 1; counter++) { if (ACE_OS::shmctl (st[counter].shmid_, IPC_STAT, &buf) == -1) ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("shmctl")), -1); offset += buf.shm_segsz; // If segment 'counter' starts at a location greater than the // place we are searching for. We then decrement the offset to // the start of counter-1. ([email protected]) if (((ptrdiff_t) offset + (ptrdiff_t) (this->base_addr_)) > (ptrdiff_t) searchPtr) { --counter; offset -= buf.shm_segsz; return 0; } // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) segment size = %d, offset = %d\n"), buf.shm_segsz, offset)); } return 0; #endif }
int ACE_SSL_SOCK::disable (int value) const { ACE_TRACE("ACE_SSL_SOCK::disable"); switch (value) { #ifdef SIGURG case SIGURG: case ACE_SIGURG: #endif /* SIGURG */ case SIGIO: case ACE_SIGIO: case ACE_CLOEXEC: ACE_NOTSUP_RETURN (-1); case ACE_NONBLOCK: return ACE_IPC_SAP::disable (value); default: return -1; } }
pid_t ACE_OS::fork (const ACE_TCHAR *program_name) { ACE_OS_TRACE ("ACE_OS::fork"); # if defined (ACE_LACKS_FORK) ACE_UNUSED_ARG (program_name); ACE_NOTSUP_RETURN (pid_t (-1)); # else pid_t const pid = # if defined (ACE_HAS_STHREADS) ::fork1 (); #else ::fork (); #endif /* ACE_HAS_STHREADS */ #if !defined (ACE_HAS_MINIMAL_ACE_OS) && !defined (ACE_HAS_THREADS) // ACE_Base_Thread_Adapter::sync_log_msg() is used to update the // program name and process id in ACE's log framework. However, we // can't invoke it from (the child process of) threaded programs // because it calls async signal unsafe functions, which will result // in undefined behavior (only async signal safe functions can be // called after fork() until an exec()). // // This is no great loss. Using the ACE log framework in the child // process will undoubtedly call async signal unsafe functions too. // So it doesn't really matter that the program name and process id // will not be updated. if (pid == 0) ACE_Base_Thread_Adapter::sync_log_msg (program_name); #else ACE_UNUSED_ARG (program_name); #endif /* ! ACE_HAS_MINIMAL_ACE_OS && !ACE_HAS_THREADS */ return pid; # endif /* ACE_WIN32 */ }
int Socket::enable (int value) const { #if defined (ACE_WIN32) switch (value) { case ACE_NONBLOCK: { // nonblocking argument (1) // blocking: (0) int nonblock = 1; return OS::ioctl (this->m_handle, FIONBIO, &nonblock); } default: ACE_NOTSUP_RETURN (-1); } #else /* ! ACE_WIN32 && ! VXWORKS */ switch (value) { #if defined (F_SETFD) case ACE_CLOEXEC: // Enables the close-on-exec flag. if (OS::fcntl (this->m_handle, F_SETFD, 1) == -1) return -1; break; #endif /* F_SETFD */ case ACE_NONBLOCK: if (ACE::set_flags (this->m_handle, ACE_NONBLOCK) == ACE_INVALID_HANDLE) return -1; break; default: return -1; } return 0; #endif /* ! ACE_WIN32 */ }
// Cause the specified handle to be passed to a child process // when it's spawned. int ACE_Process_Options::pass_handle (ACE_HANDLE h) { # if defined (ACE_WIN32) # if defined (ACE_HAS_WINCE) ACE_NOTSUP_RETURN (-1); # else // This is oriented towards socket handles... may need some adjustment // for non-sockets. // This is all based on an MSDN article: // http://support.microsoft.com/support/kb/articles/Q150/5/23.asp // If on Win95/98, the handle needs to be duplicated for the to-be-spawned // process. On WinNT, they get inherited by the child process automatically. // If the handle is duplicated, remember the duplicate so it can be // closed later. Can't be closed now, or the child won't get it. ACE_TEXT_OSVERSIONINFO osvi; ZeroMemory (&osvi, sizeof (osvi)); osvi.dwOSVersionInfoSize = sizeof (ACE_TEXT_OSVERSIONINFO); // If this is Win95/98 or we can't tell, duplicate the handle. if (!ACE_TEXT_GetVersionEx (&osvi) || osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) { HANDLE dup_handle; if (!DuplicateHandle (GetCurrentProcess (), static_cast<HANDLE> (h), GetCurrentProcess (), &dup_handle, 0, TRUE, // Inheritable DUPLICATE_SAME_ACCESS)) return -1; dup_handles_.set_bit (static_cast<ACE_HANDLE> (dup_handle)); } # endif /* ACE_HAS_WINCE */ #endif /* ACE_WIN32 */ this->handles_passed_.set_bit (h); return 0; }
long ACE_OS::num_processors_online (void) { ACE_OS_TRACE ("ACE_OS::num_processors_online"); #if defined (ACE_HAS_PHARLAP) return 1; #elif defined (ACE_WIN32) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); long active_processors = 0; DWORD_PTR mask = sys_info.dwActiveProcessorMask; while (mask != 0) { if (mask & 1) ++active_processors; mask >>= 1; } return active_processors; #elif defined (_SC_NPROCESSORS_ONLN) return ::sysconf (_SC_NPROCESSORS_ONLN); #elif defined (ACE_HAS_SYSCTL) int num_processors; int mib[2] = { CTL_HW, HW_NCPU }; size_t len = sizeof (num_processors); if (::sysctl (mib, 2, &num_processors, &len, 0, 0) != -1) return num_processors; else return -1; #elif defined (__hpux) struct pst_dynamic psd; if (::pstat_getdynamic (&psd, sizeof (psd), (size_t) 1, 0) != -1) return psd.psd_proc_cnt; else return -1; #else ACE_NOTSUP_RETURN (-1); #endif }
int ACE_INET_Addr::set (const char port_name[], const char host_name[], const char protocol[]) { ACE_TRACE ("ACE_INET_Addr::set"); int const port_number = get_port_number_from_name (port_name, protocol); if (port_number == -1) { ACE_NOTSUP_RETURN (-1); } int address_family = PF_UNSPEC; # if defined (ACE_HAS_IPV6) if (ACE_OS::strcmp (protocol, "tcp6") == 0) address_family = AF_INET6; # endif /* ACE_HAS_IPV6 */ return this->set (static_cast<u_short> (port_number), host_name, 0, address_family); }
long ACE_OS::num_processors_online (void) { ACE_OS_TRACE ("ACE_OS::num_processors_online"); #if defined (ACE_HAS_PHARLAP) return 1; #elif defined (ACE_WIN32) || defined (ACE_WIN64) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return sys_info.dwNumberOfProcessors; #elif defined (linux) || defined (sun) return ::sysconf (_SC_NPROCESSORS_ONLN); #elif defined (__hpux) struct pst_dynamic psd; if (::pstat_getdynamic (&psd, sizeof (psd), (size_t) 1, 0) != -1) return psd.psd_proc_cnt; else return -1; #else ACE_NOTSUP_RETURN (-1); #endif }
pid_t ACE_OS::fork (const ACE_TCHAR *program_name) { ACE_OS_TRACE ("ACE_OS::fork"); # if defined (ACE_LACKS_FORK) ACE_UNUSED_ARG (program_name); ACE_NOTSUP_RETURN (pid_t (-1)); # else pid_t pid = # if defined (ACE_HAS_STHREADS) ::fork1 (); #else ::fork (); #endif /* ACE_HAS_STHREADS */ #if !defined (ACE_HAS_MINIMAL_ACE_OS) if (pid == 0) ACE_Base_Thread_Adapter::sync_log_msg (program_name); #endif /* ! ACE_HAS_MINIMAL_ACE_OS */ return pid; # endif /* ACE_WIN32 */ }
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; }
/* static */ int TAO_RT_ORB::modify_thread_scheduling_policy (CORBA::ORB_ptr orb) { // This method changes the scheduling policy of the calling thread // to match the scheduling policy specified in the svc.conf file. // The priority of the calling thread will be set to the minimum // priority supported by that scheduling policy. // // This method make sense on those platform (e.g., Linux) where // PTHREAD_SCOPE_SYSTEM is the only scheduling scope supported. On // other platforms, this method is a no-op since the only way to get // the real-time threading behavior is to setup the // PTHREAD_SCOPE_SYSTEM scheduling scope when a thread is being // created. On such platforms, one can set the correct scheduling // scope and policy when creating the thread, thus not needing to // use this method. #if !defined (ACE_LACKS_THREAD_PROCESS_SCOPING) && defined (ACE_LACKS_PTHREAD_SCOPE_PROCESS) int const sched_policy = orb->orb_core ()->orb_params ()->ace_sched_policy (); int const minimum_priority = ACE_Sched_Params::priority_min (sched_policy); ACE_hthread_t thread_id; ACE_Thread::self (thread_id); return ACE_Thread::setprio (thread_id, minimum_priority, sched_policy); #else /* !ACE_LACKS_THREAD_PROCESS_SCOPING && ACE_LACKS_PTHREAD_SCOPE_PROCESS */ ACE_UNUSED_ARG (orb); ACE_NOTSUP_RETURN (-1); #endif /* linux */ }
int ACE_OS::snprintf (char *buf, size_t maxlen, const char *format, ...) { // ACE_OS_TRACE ("ACE_OS::snprintf"); #if defined ACE_LACKS_SNPRINTF && defined ACE_FACE_DEV ACE_UNUSED_ARG (maxlen); va_list ap; va_start (ap, format); int const result = ::vsprintf (buf, format, ap); va_end (ap); return result; #elif defined (ACE_LACKS_VA_FUNCTIONS) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (maxlen); ACE_UNUSED_ARG (format); ACE_NOTSUP_RETURN (-1); #else va_list ap; va_start (ap, format); int const result = ACE_OS::vsnprintf (buf, maxlen, format, ap); va_end (ap); return result; #endif /* ACE_LACKS_VA_FUNCTIONS */ }
long ACE_OS::num_processors (void) { ACE_OS_TRACE ("ACE_OS::num_processors"); #if defined (ACE_HAS_PHARLAP) return 1; #elif defined (ACE_WIN32) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return sys_info.dwNumberOfProcessors; #elif defined (_SC_NPROCESSORS_CONF) return ::sysconf (_SC_NPROCESSORS_CONF); #elif defined (ACE_HAS_SYSCTL) int num_processors; int mib[2] = { CTL_HW, HW_NCPU }; size_t len = sizeof (num_processors); sysctl(mib, 2, &num_processors, &len, NULL, 0); return num_processors; #else ACE_NOTSUP_RETURN (-1); #endif }
ACE_BEGIN_VERSIONED_NAMESPACE_DECL // Flags are file status flags to turn on. int ACE::set_flags (ACE_HANDLE handle, int flags) { ACE_TRACE ("ACE::set_flags"); #if defined (ACE_LACKS_FCNTL) switch (flags) { case ACE_NONBLOCK: // nonblocking argument (1) // blocking: (0) { int nonblock = 1; return ACE_OS::ioctl (handle, FIONBIO, &nonblock); } default: ACE_NOTSUP_RETURN (-1); } #else int val = ACE_OS::fcntl (handle, F_GETFL, 0); if (val == -1) return -1; // Turn on flags. ACE_SET_BITS (val, flags); if (ACE_OS::fcntl (handle, F_SETFL, val) == -1) return -1; else return 0; #endif /* ACE_LACKS_FCNTL */ }
pid_t ACE_Process::spawn (ACE_Process_Options &options) { if (this->prepare (options) < 0) return ACE_INVALID_PID; // Stash the passed/duped handle sets away in this object for later // closing if needed or requested. At the same time, figure out which // ones to include in command line options if that's needed below. ACE_Handle_Set *set_p = 0; if (options.dup_handles (this->dup_handles_)) set_p = &this->dup_handles_; else if (options.passed_handles (this->handles_passed_)) set_p = &this->handles_passed_; // If we are going to end up running a new program (i.e. Win32, or // NO_EXEC option is set) then get any handles passed in the options, // and tack them onto the command line with +H <handle> options, // unless the command line runs out of space. // Note that we're using the knowledge that all the options, argvs, etc. // passed to the options are all sitting in the command_line_buf. Any // call to get the argv then splits them out. So, regardless of the // platform, tack them all onto the command line buf and take it // from there. if (set_p && !ACE_BIT_ENABLED (options.creation_flags (), ACE_Process_Options::NO_EXEC)) { int maxlen = 0; ACE_TCHAR *cmd_line_buf = options.command_line_buf (&maxlen); size_t max_len = static_cast<size_t> (maxlen); size_t curr_len = ACE_OS::strlen (cmd_line_buf); ACE_Handle_Set_Iterator h_iter (*set_p); // Because the length of the to-be-formatted +H option is not // known, and we don't have a snprintf, guess at the space // needed (20 chars), and use that as a limit. for (ACE_HANDLE h = h_iter (); h != ACE_INVALID_HANDLE && curr_len + 20 < max_len; h = h_iter ()) { #if defined (ACE_WIN32) # if defined (ACE_WIN64) curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len], ACE_TEXT (" +H %I64p"), h); # else curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len], ACE_TEXT (" +H %p"), h); # endif /* ACE_WIN64 */ #else curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len], ACE_TEXT (" +H %d"), h); #endif /* ACE_WIN32 */ } } #if defined (ACE_HAS_WINCE) // Note that WinCE does not have process name included in the command line as argv[0] // like other OS environment. Therefore, it is user's whole responsibility to call // 'ACE_Process_Options::process_name(const ACE_TCHAR *name)' to set the proper // process name (the execution file name with path if needed). BOOL fork_result = ACE_TEXT_CreateProcess (options.process_name(), options.command_line_buf(), options.get_process_attributes(), // must be NULL in CE options.get_thread_attributes(), // must be NULL in CE options.handle_inheritance(), // must be false in CE options.creation_flags(), // must be NULL in CE options.env_buf(), // environment variables, must be NULL in CE options.working_directory(), // must be NULL in CE options.startup_info(), // must be NULL in CE &this->process_info_); if (fork_result) { parent (this->getpid ()); return this->getpid (); } return ACE_INVALID_PID; #elif defined (ACE_WIN32) void* env_buf = options.env_buf (); DWORD flags = options.creation_flags (); # if defined (ACE_HAS_WCHAR) && !defined (ACE_USES_WCHAR) wchar_t* wenv_buf = 0; if (options.use_unicode_environment ()) { wenv_buf = this->convert_env_buffer (options.env_buf ()); env_buf = wenv_buf; flags |= CREATE_UNICODE_ENVIRONMENT; } # endif BOOL fork_result = ACE_TEXT_CreateProcess (0, options.command_line_buf (), options.get_process_attributes (), options.get_thread_attributes (), options.handle_inheritance (), flags, env_buf, // environment variables options.working_directory (), options.startup_info (), &this->process_info_); # if defined (ACE_HAS_WCHAR) && !defined (ACE_USES_WCHAR) if (options.use_unicode_environment ()) delete wenv_buf; # endif if (fork_result) { parent (this->getpid ()); return this->getpid (); } return ACE_INVALID_PID; #elif defined(ACE_OPENVMS) if (ACE_BIT_ENABLED (options.creation_flags (), ACE_Process_Options::NO_EXEC)) ACE_NOTSUP_RETURN (ACE_INVALID_PID); int saved_stdin = ACE_STDIN; int saved_stdout = ACE_STDOUT; int saved_stderr = ACE_STDERR; // Save STD file descriptors and redirect if (options.get_stdin () != ACE_INVALID_HANDLE) { if ((saved_stdin = ACE_OS::dup (ACE_STDIN)) == -1 && errno != EBADF) ACE_OS::exit (errno); if (ACE_OS::dup2 (options.get_stdin (), ACE_STDIN) == -1) ACE_OS::exit (errno); } if (options.get_stdout () != ACE_INVALID_HANDLE) { if ((saved_stdout = ACE_OS::dup (ACE_STDOUT)) == -1 && errno != EBADF) ACE_OS::exit (errno); if (ACE_OS::dup2 (options.get_stdout (), ACE_STDOUT) == -1) ACE_OS::exit (errno); } if (options.get_stderr () != ACE_INVALID_HANDLE) { if ((saved_stderr = ACE_OS::dup (ACE_STDERR)) == -1 && errno != EBADF) ACE_OS::exit (errno); if (ACE_OS::dup2 (options.get_stderr (), ACE_STDERR) == -1) ACE_OS::exit (errno); } if (options.working_directory () != 0) ACE_NOTSUP_RETURN (ACE_INVALID_PID); this->child_id_ = vfork(); if (this->child_id_ == 0) { ACE_OS::execvp (options.process_name (), options.command_line_argv ()); // something went wrong this->child_id_ = ACE_INVALID_PID; } // restore STD file descriptors (if necessary) if (options.get_stdin () != ACE_INVALID_HANDLE) { if (saved_stdin == -1) ACE_OS::close (ACE_STDIN); else ACE_OS::dup2 (saved_stdin, ACE_STDIN); } if (options.get_stdout () != ACE_INVALID_HANDLE) { if (saved_stdout == -1) ACE_OS::close (ACE_STDOUT); else ACE_OS::dup2 (saved_stdout, ACE_STDOUT); } if (options.get_stderr () != ACE_INVALID_HANDLE) { if (saved_stderr == -1) ACE_OS::close (ACE_STDERR); else ACE_OS::dup2 (saved_stderr, ACE_STDERR); } return this->child_id_; #elif defined (ACE_VXWORKS) && defined (__RTP__) if (ACE_BIT_ENABLED (options.creation_flags (), ACE_Process_Options::NO_EXEC)) ACE_NOTSUP_RETURN (ACE_INVALID_PID); if (options.working_directory () != 0) ACE_NOTSUP_RETURN (ACE_INVALID_PID); int saved_stdin = ACE_STDIN; int saved_stdout = ACE_STDOUT; int saved_stderr = ACE_STDERR; // Save STD file descriptors and redirect if (options.get_stdin () != ACE_INVALID_HANDLE) { if ((saved_stdin = ACE_OS::dup (ACE_STDIN)) == -1 && errno != EBADF) ACE_OS::exit (errno); if (ACE_OS::dup2 (options.get_stdin (), ACE_STDIN) == -1) ACE_OS::exit (errno); } if (options.get_stdout () != ACE_INVALID_HANDLE) { if ((saved_stdout = ACE_OS::dup (ACE_STDOUT)) == -1 && errno != EBADF) ACE_OS::exit (errno); if (ACE_OS::dup2 (options.get_stdout (), ACE_STDOUT) == -1) ACE_OS::exit (errno); } if (options.get_stderr () != ACE_INVALID_HANDLE) { if ((saved_stderr = ACE_OS::dup (ACE_STDERR)) == -1 && errno != EBADF) ACE_OS::exit (errno); if (ACE_OS::dup2 (options.get_stderr (), ACE_STDERR) == -1) ACE_OS::exit (errno); } // Wide-char builds need narrow-char strings for commandline and // environment variables. # if defined (ACE_USES_WCHAR) wchar_t * const *wargv = options.command_line_argv (); size_t vcount, i; for (vcount = 0; wargv[vcount] != 0; ++vcount) ; char **procargv = new char *[vcount + 1]; // Need 0 at the end procargv[vcount] = 0; for (i = 0; i < vcount; ++i) procargv[i] = ACE_Wide_To_Ascii::convert (wargv[i]); char **procenv = 0; if (options.inherit_environment ()) { wargv = options.env_argv (); for (vcount = 0; wargv[vcount] != 0; ++vcount) ; procenv = new char *[vcount + 1]; // Need 0 at the end procenv[vcount] = 0; for (i = 0; i < vcount; ++i) procenv[i] = ACE_Wide_To_Ascii::convert (wargv[i]); } # else const char **procargv = const_cast<const char**> (options.command_line_argv ()); const char **procenv = const_cast<const char**> (options.env_argv ()); # endif /* ACE_USES_WCHAR */ this->child_id_ = ::rtpSpawn (procargv[0], procargv, procenv, 200, // priority 0x10000, // uStackSize 0, // options VX_FP_TASK); // taskOptions int my_errno_ = errno; if (this->child_id_ == ERROR) { // something went wrong this->child_id_ = ACE_INVALID_PID; } # if defined (ACE_USES_WCHAR) if (procenv) delete procenv; # endif /* ACE_USES_WCHAR */ // restore STD file descriptors (if necessary) if (options.get_stdin () != ACE_INVALID_HANDLE) { if (saved_stdin == -1) ACE_OS::close (ACE_STDIN); else ACE_OS::dup2 (saved_stdin, ACE_STDIN); } if (options.get_stdout () != ACE_INVALID_HANDLE) { if (saved_stdout == -1) ACE_OS::close (ACE_STDOUT); else ACE_OS::dup2 (saved_stdout, ACE_STDOUT); } if (options.get_stderr () != ACE_INVALID_HANDLE) { if (saved_stderr == -1) ACE_OS::close (ACE_STDERR); else ACE_OS::dup2 (saved_stderr, ACE_STDERR); } if (this->child_id_ == ACE_INVALID_PID) { errno = my_errno_; } return this->child_id_; #else /* ACE_WIN32 */ // Fork the new process. this->child_id_ = ACE::fork (options.process_name (), options.avoid_zombies ()); if (this->child_id_ == 0) { # if !defined (ACE_LACKS_SETPGID) // If we're the child and the options specified a non-default // process group, try to set our pgid to it. This allows the // <ACE_Process_Manager> to wait for processes by their // process-group. if (options.getgroup () != ACE_INVALID_PID && ACE_OS::setpgid (0, options.getgroup ()) < 0) { #if !defined (ACE_HAS_THREADS) // We can't emit this log message because ACE_ERROR(), etc. // will invoke async signal unsafe functions, which results // in undefined behavior in threaded programs. ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), ACE_TEXT ("ACE_Process::spawn: setpgid failed."))); #endif } # endif /* ACE_LACKS_SETPGID */ # if !defined (ACE_LACKS_SETREGID) if (options.getrgid () != (uid_t) -1 || options.getegid () != (uid_t) -1) if (ACE_OS::setregid (options.getrgid (), options.getegid ()) == -1) { #if !defined (ACE_HAS_THREADS) // We can't emit this log message because ACE_ERROR(), etc. // will invoke async signal unsafe functions, which results // in undefined behavior in threaded programs. ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), ACE_TEXT ("ACE_Process::spawn: setregid failed."))); #endif } # endif /* ACE_LACKS_SETREGID */ # if !defined (ACE_LACKS_SETREUID) // Set user and group id's. if (options.getruid () != (uid_t) -1 || options.geteuid () != (uid_t) -1) if (ACE_OS::setreuid (options.getruid (), options.geteuid ()) == -1) { #if !defined (ACE_HAS_THREADS) // We can't emit this log message because ACE_ERROR(), etc. // will invoke async signal unsafe functions, which results // in undefined behavior in threaded programs. ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), ACE_TEXT ("ACE_Process::spawn: setreuid failed."))); #endif } # endif /* ACE_LACKS_SETREUID */ this->child (ACE_OS::getppid ()); } else if (this->child_id_ != -1) this->parent (this->child_id_); // If we're not supposed to exec, return the process id. if (ACE_BIT_ENABLED (options.creation_flags (), ACE_Process_Options::NO_EXEC)) return this->child_id_; switch (this->child_id_) { case -1: // Error. return ACE_INVALID_PID; case 0: // Child process...exec the { if (options.get_stdin () != ACE_INVALID_HANDLE && ACE_OS::dup2 (options.get_stdin (), ACE_STDIN) == -1) ACE_OS::exit (errno); else if (options.get_stdout () != ACE_INVALID_HANDLE && ACE_OS::dup2 (options.get_stdout (), ACE_STDOUT) == -1) ACE_OS::exit (errno); else if (options.get_stderr () != ACE_INVALID_HANDLE && ACE_OS::dup2 (options.get_stderr (), ACE_STDERR) == -1) ACE_OS::exit (errno); // close down unneeded descriptors ACE_OS::close (options.get_stdin ()); ACE_OS::close (options.get_stdout ()); ACE_OS::close (options.get_stderr ()); if (!options.handle_inheritance ()) { // Set close-on-exec for all FDs except standard handles for (int i = ACE::max_handles () - 1; i >= 0; i--) { if (i == ACE_STDIN || i == ACE_STDOUT || i == ACE_STDERR) continue; ACE_OS::fcntl (i, F_SETFD, FD_CLOEXEC); } } // If we must, set the working directory for the child // process. if (options.working_directory () != 0) ACE_OS::chdir (options.working_directory ()); // Should check for error here! // Child process executes the command. int result = 0; // Wide-char builds not on Windows need narrow-char strings for // exec() and environment variables. Don't need to worry about // releasing any of the converted string memory since this // process will either exec() or exit() shortly. # if defined (ACE_USES_WCHAR) ACE_Wide_To_Ascii n_procname (options.process_name ()); const char *procname = n_procname.char_rep (); wchar_t * const *wargv = options.command_line_argv (); size_t vcount, i; for (vcount = 0; wargv[vcount] != 0; ++vcount) ; char **procargv = new char *[vcount + 1]; // Need 0 at the end procargv[vcount] = 0; for (i = 0; i < vcount; ++i) procargv[i] = ACE_Wide_To_Ascii::convert (wargv[i]); wargv = options.env_argv (); for (vcount = 0; wargv[vcount] != 0; ++vcount) ; char **procenv = new char *[vcount + 1]; // Need 0 at the end procenv[vcount] = 0; for (i = 0; i < vcount; ++i) procenv[i] = ACE_Wide_To_Ascii::convert (wargv[i]); # else const char *procname = options.process_name (); char *const *procargv = options.command_line_argv (); char *const *procenv = options.env_argv (); # endif /* ACE_USES_WCHAR */ if (options.inherit_environment ()) { // Add the new environment variables to the environment // context of the context before doing an <execvp>. for (size_t i = 0; procenv[i] != 0; i++) if (ACE_OS::putenv (procenv[i]) != 0) return ACE_INVALID_PID; // Now the forked process has both inherited variables and // the user's supplied variables. result = ACE_OS::execvp (procname, procargv); } else { result = ACE_OS::execve (procname, procargv, procenv); } if (result == -1) { // If the execv fails, this child needs to exit. // Exit with the errno so that the calling process can // catch this and figure out what went wrong. ACE_OS::_exit (errno); } // ... otherwise, this is never reached. return 0; } default: // Server process. The fork succeeded. return this->child_id_; } #endif /* ACE_WIN32 */ }
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); 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, 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); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK)) ACE_SET_BITS (condition, XtInputReadMask); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)){ ACE_SET_BITS (condition, XtInputWriteMask); // connected, you may write ACE_SET_BITS (condition, XtInputReadMask); // connected, you have data/err } #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); 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, XtInputReadWinsock); if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)){ ACE_SET_BITS (condition, XtInputWriteWinsock); // connected, you may write ACE_SET_BITS (condition, XtInputReadWinsock); // connected, you have data/err } #endif /* !ACE_WIN32 */ if (condition != 0) { ACE_XtReactorID *XtID = this->ids_; while(XtID) { if (XtID->handle_ == handle) { ::XtRemoveInput (XtID->id_); XtID->id_ = ::XtAppAddInput (this->context_, (int) handle, (XtPointer) condition, InputCallbackProc, (XtPointer) this); return 0; } else XtID = XtID->next_; } ACE_NEW_RETURN (XtID, ACE_XtReactorID, -1); XtID->next_ = this->ids_; XtID->handle_ = handle; XtID->id_ = ::XtAppAddInput (this->context_, (int) handle, (XtPointer) condition, InputCallbackProc, (XtPointer) this); this->ids_ = XtID; } return 0; }
int ACE_Message_Queue_Vx::peek_dequeue_head (ACE_Message_Block *&, ACE_Time_Value *) { ACE_NOTSUP_RETURN (-1); }
int ACE_Message_Queue_Vx::dequeue_deadline_i (ACE_Message_Block *& /*dequeued*/) { ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_deadline_i"); ACE_NOTSUP_RETURN (-1); }
size_t ACE_Message_Queue_Vx::message_length (void) { ACE_TRACE ("ACE_Message_Queue_Vx::message_length"); ACE_NOTSUP_RETURN ((size_t) -1); }
size_t ACE_Message_Queue_Vx::high_water_mark (void) { ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark"); ACE_NOTSUP_RETURN ((size_t) -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; }
size_t ACE_Message_Queue_Vx::message_bytes (void) { ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes"); ACE_NOTSUP_RETURN ((size_t) -1); }