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);
}
