---

ACE_OS Class Reference

This class defines an OS independent programming API that shields developers from nonportable aspects of writing efficient system programs on Win32, POSIX and other versions of UNIX, and various real-time operating systems. More...

#include <OS.h>

Inheritance diagram for ACE_OS:

[legend]Collaboration diagram for ACE_OS:

[legend]List of all members.

Wide-character strings
typedef wchar_t	WChar
u_int	wslen (const WChar *)
WChar *	wscpy (WChar *, const WChar *)
int	wscmp (const WChar *, const WChar *)
int	wsncmp (const WChar *, const WChar *, size_t len)
A set of wrappers for threads
int	thr_continue (ACE_hthread_t target_thread)
int	thr_create (ACE_THR_FUNC func, void *args, long flags, ACE_thread_t *thr_id, ACE_hthread_t *t_handle=0, long priority=ACE_DEFAULT_THREAD_PRIORITY, void *stack=0, size_t stacksize=0, ACE_Base_Thread_Adapter *thread_adapter=0)
int	thr_join (ACE_hthread_t waiter_id, ACE_THR_FUNC_RETURN *status)
int	thr_join (ACE_thread_t waiter_id, ACE_thread_t *thr_id, ACE_THR_FUNC_RETURN *status)
int	thr_kill (ACE_thread_t thr_id, int signum)
ACE_thread_t	thr_self (void)
void	thr_self (ACE_hthread_t &)
int	thr_getprio (ACE_hthread_t id, int &priority)
int	thr_getprio (ACE_hthread_t id, int &priority, int &policy)
int	thr_setprio (ACE_hthread_t id, int priority, int policy=-1)
int	thr_setprio (const ACE_Sched_Priority prio)
int	thr_suspend (ACE_hthread_t target_thread)
int	thr_cancel (ACE_thread_t t_id)
int	thr_cmp (ACE_hthread_t t1, ACE_hthread_t t2)
int	thr_equal (ACE_thread_t t1, ACE_thread_t t2)
void	thr_exit (ACE_THR_FUNC_RETURN status=0)
int	thr_getconcurrency (void)
int	lwp_getparams (ACE_Sched_Params &)
int	thr_getspecific (ACE_thread_key_t key, void **data)
int	thr_keyfree (ACE_thread_key_t key)
int	thr_key_detach (void *inst)
int	thr_keycreate (ACE_thread_key_t *key, ACE_THR_DEST, void *inst=0)
int	thr_key_used (ACE_thread_key_t key)
size_t	thr_min_stack (void)
int	thr_setconcurrency (int hint)
int	lwp_setparams (const ACE_Sched_Params &)
int	thr_setspecific (ACE_thread_key_t key, void *data)
int	thr_sigsetmask (int how, const sigset_t *nsm, sigset_t *osm)
int	thr_setcancelstate (int new_state, int *old_state)
int	thr_setcanceltype (int new_type, int *old_type)
int	sigwait (sigset_t *set, int *sig=0)
int	sigtimedwait (const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout)
int	sigwaitinfo (const sigset_t *set, siginfo_t *info)
void	thr_testcancel (void)
void	thr_yield (void)
void	unique_name (const void *object, ACE_TCHAR *name, size_t length)
ACE_thread_t	NULL_thread
	This is necessary to deal with POSIX pthreads and their use of structures for thread ids. More...
ACE_hthread_t	NULL_hthread
	This is necessary to deal with POSIX pthreads and their use of structures for thread handles. More...
ACE_thread_key_t	NULL_key
	This is necessary to deal with POSIX pthreads and their use of structures for TSS keys. More...
Public Types
enum	ACE_HRTimer_Op { ACE_HRTIMER_START = 0x0, ACE_HRTIMER_INCR = 0x1, ACE_HRTIMER_STOP = 0x2, ACE_HRTIMER_GETTIME = 0xFFFF }
Static Public Methods
LPSECURITY_ATTRIBUTES	default_win32_security_attributes (LPSECURITY_ATTRIBUTES)
const OSVERSIONINFO &	get_win32_versioninfo (void)
	Return the win32 OSVERSIONINFO structure. More...
HINSTANCE	get_win32_resource_module (void)
	Return the handle of the module containing ACE's resources. By default, for a DLL build of ACE this is a handle to the ACE DLL itself, and for a static build it is a handle to the executable. More...
void	set_win32_resource_module (HINSTANCE)
	Allow an application to modify which module contains ACE's resources. This is mainly useful for a static build of ACE where the required resources reside somewhere other than the executable. More...
int	atoi (const char *s)
int	atoi (const wchar_t *s)
void *	atop (const char *s)
void *	atop (const wchar_t *s)
double	floor (double x)
	This method computes the largest integral value not greater than x. More...
double	ceil (double x)
	This method computes the smallest integral value not less than x. More...
char *	getenv (const char *symbol)
wchar_t *	getenv (const wchar_t *symbol)
int	putenv (const ACE_TCHAR *string)
ACE_TCHAR *	strenvdup (const ACE_TCHAR *str)
ACE_TCHAR *	getenvstrings (void)
int	getopt (int argc, char *const *argv, const char *optstring)
int	argv_to_string (ACE_TCHAR **argv, ACE_TCHAR *&buf, int substitute_env_args=1)
int	string_to_argv (ACE_TCHAR *buf, int &argc, ACE_TCHAR **&argv, int substitute_env_args=1)
long	sysconf (int)
pid_t	waitpid (pid_t pid, ACE_exitcode *status=0, int wait_options=0, ACE_HANDLE handle=0)
pid_t	wait (pid_t pid, ACE_exitcode *status, int wait_options=0, ACE_HANDLE handle=0)
pid_t	wait (int *=0)
	Calls OS <wait> function, so it's only portable to UNIX/POSIX platforms. More...
void	mutex_lock_cleanup (void *mutex)
	Handle asynchronous thread cancellation cleanup. More...
void	cleanup_tss (const u_int main_thread)
int	scheduling_class (const char *class_name, ACE_id_t &)
	Find the schedling class ID that corresponds to the class name. More...
int	set_scheduling_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
	Friendly interface to <priocntl>(2). More...
int	priority_control (ACE_idtype_t, ACE_id_t, int, void *)
	Low-level interface to <priocntl>(2). More...
long	num_processors (void)
	Get the number of CPUs configured in the machine. More...
long	num_processors_online (void)
	Get the number of CPUs currently online. More...
A set of wrappers for condition variables.
int	condattr_init (ACE_condattr_t &attributes, int type=ACE_DEFAULT_SYNCH_TYPE)
int	condattr_destroy (ACE_condattr_t &attributes)
int	cond_broadcast (ACE_cond_t *cv)
int	cond_destroy (ACE_cond_t *cv)
int	cond_init (ACE_cond_t *cv, short type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0)
int	cond_init (ACE_cond_t *cv, ACE_condattr_t &attributes, const char *name=0, void *arg=0)
int	cond_init (ACE_cond_t *cv, short type, const wchar_t *name, void *arg=0)
int	cond_init (ACE_cond_t *cv, ACE_condattr_t &attributes, const wchar_t *name, void *arg=0)
int	cond_signal (ACE_cond_t *cv)
int	cond_timedwait (ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *)
int	cond_wait (ACE_cond_t *cv, ACE_mutex_t *m)
Wrappers to obtain the current user id
char *	cuserid (char *user, size_t maxlen=ACE_MAX_USERID)
wchar_t *	cuserid (wchar_t *user, size_t maxlen=ACE_MAX_USERID)
Wrappers to obtain configuration info
int	uname (ACE_utsname *name)
long	sysinfo (int cmd, char *buf, long count)
int	hostname (char *name, size_t maxnamelen)
int	hostname (wchar_t *name, size_t maxnamelen)
A set of wrappers for explicit dynamic linking.
int	dlclose (ACE_SHLIB_HANDLE handle)
ACE_TCHAR *	dlerror (void)
ACE_SHLIB_HANDLE	dlopen (const ACE_TCHAR *filename, int mode=ACE_DEFAULT_SHLIB_MODE)
void *	dlsym (ACE_SHLIB_HANDLE handle, const ACE_TCHAR *symbol)
A set of wrappers for stdio file operations.
int	last_error (void)
void	last_error (int)
int	set_errno_to_last_error (void)
int	set_errno_to_wsa_last_error (void)
int	fclose (FILE *fp)
int	fcntl (ACE_HANDLE handle, int cmd, long arg=0)
int	fdetach (const char *file)
int	fsync (ACE_HANDLE handle)
FILE *	fopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode)
FILE *	freopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode, FILE *stream)
FILE *	fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)
ACE_TCHAR *	fgets (ACE_TCHAR *buf, int size, FILE *fp)
int	stat (const ACE_TCHAR *file, ACE_stat *)
int	truncate (const ACE_TCHAR *filename, off_t length)
int	fprintf (FILE *fp, const char *format,...)
int	sprintf (char *buf, const char *format,...)
int	snprintf (char *buf, size_t maxlen, const char *format,...)
int	vsprintf (char *buffer, const char *format, va_list argptr)
int	printf (const char *format,...)
int	sprintf (wchar_t *buf, const wchar_t *format,...)
int	snprintf (wchar_t *buf, size_t maxlen, const wchar_t *format,...)
int	fprintf (FILE *fp, const wchar_t *format,...)
int	vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr)
void	perror (const ACE_TCHAR *s)
char *	gets (char *str, int n=0)
int	puts (const ACE_TCHAR *s)
int	fputs (const ACE_TCHAR *s, FILE *stream)
int	fflush (FILE *fp)
size_t	fread (void *ptr, size_t size, size_t nelems, FILE *fp)
int	fgetc (FILE *fp)
void	clearerr (FILE *fp)
wint_t	fgetwc (FILE *fp)
wint_t	ungetwc (wint_t c, FILE *fp)
int	fseek (FILE *fp, long offset, int ptrname)
long	ftell (FILE *fp)
int	fgetpos (FILE *fp, fpos_t *pos)
int	fsetpos (FILE *fp, fpos_t *pos)
int	fstat (ACE_HANDLE, ACE_stat *)
int	lstat (const char *, ACE_stat *)
int	ftruncate (ACE_HANDLE, off_t)
size_t	fwrite (const void *ptr, size_t size, size_t nitems, FILE *fp)
void	rewind (FILE *fp)
Wrappers for searching and sorting.
void *	bsearch (const void *key, const void *base, size_t nel, size_t size, ACE_COMPARE_FUNC)
void	qsort (void *base, size_t nel, size_t width, ACE_COMPARE_FUNC)
A set of wrappers for file locks.
int	flock_init (ACE_OS::ace_flock_t *lock, int flags=0, const ACE_TCHAR *name=0, mode_t perms=0)
int	flock_destroy (ACE_OS::ace_flock_t *lock, int unlink_file=1)
void	adjust_flock_params (ACE_OS::ace_flock_t *lock, short whence, off_t &start, off_t &len)
int	flock_rdlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int	flock_tryrdlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int	flock_trywrlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int	flock_unlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int	flock_wrlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
A set of wrappers for low-level process operations.
int	atexit (ACE_EXIT_HOOK func)
int	execl (const char *path, const char *arg0,...)
int	execle (const char *path, const char *arg0,...)
int	execlp (const char *file, const char *arg0,...)
int	execv (const char *path, char *const argv[])
int	execvp (const char *file, char *const argv[])
int	execve (const char *path, char *const argv[], char *const envp[])
void	_exit (int status=0)
void	exit (int status=0)
void	abort (void)
pid_t	fork (void)
int	getpagesize (void)
int	allocation_granularity (void)
gid_t	getgid (void)
int	setgid (gid_t)
pid_t	getpid (void)
pid_t	getpgid (pid_t pid)
pid_t	getppid (void)
uid_t	getuid (void)
int	setuid (uid_t)
pid_t	setsid (void)
int	setpgid (pid_t pid, pid_t pgid)
int	setreuid (uid_t ruid, uid_t euid)
int	setregid (gid_t rgid, gid_t egid)
int	system (const ACE_TCHAR *s)
pid_t	fork (const ACE_TCHAR *program_name)
	Forks and exec's a process in a manner that works on Solaris and NT. argv[0] must be the full path name to the executable. More...
pid_t	fork_exec (ACE_TCHAR *argv[])
	Forks and exec's a process in a manner that works on Solaris and NT. argv[0] must be the full path name to the executable. More...
A set of wrappers for timers and resource stats.
u_int	alarm (u_int secs)
u_int	ualarm (u_int usecs, u_int interval=0)
u_int	ualarm (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)
ACE_hrtime_t	gethrtime (const ACE_HRTimer_Op=ACE_HRTIMER_GETTIME)
int	clock_gettime (clockid_t, struct timespec *)
ACE_Time_Value	gettimeofday (void)
int	getrusage (int who, struct rusage *rusage)
int	getrlimit (int resource, struct rlimit *rl)
int	setrlimit (int resource, ACE_SETRLIMIT_TYPE *rl)
int	sleep (u_int seconds)
int	sleep (const ACE_Time_Value &tv)
int	nanosleep (const struct timespec *requested, struct timespec *remaining=0)
A set of wrappers for operations on time.
time_t	mktime (struct tm *timeptr)
void	tzset (void)
long	timezone (void)
double	difftime (time_t t1, time_t t0)
time_t	time (time_t *tloc=0)
tm *	localtime (const time_t *clock)
tm *	localtime_r (const time_t *clock, struct tm *res)
tm *	gmtime (const time_t *clock)
tm *	gmtime_r (const time_t *clock, struct tm *res)
char *	asctime (const struct tm *tm)
char *	asctime_r (const struct tm *tm, char *buf, int buflen)
ACE_TCHAR *	ctime (const time_t *t)
ACE_TCHAR *	ctime_r (const time_t *clock, ACE_TCHAR *buf, int buflen)
size_t	strftime (char *s, size_t maxsize, const char *format, const struct tm *timeptr)
A set of wrappers for System V message queues.
int	msgctl (int msqid, int cmd, struct msqid_ds *)
int	msgget (key_t key, int msgflg)
int	msgrcv (int int_id, void *buf, size_t len, long type, int flags)
int	msgsnd (int int_id, const void *buf, size_t len, int flags)
A set of wrappers for memory mapped files.
int	madvise (caddr_t addr, size_t len, int advice)
void *	mmap (void *addr, size_t len, int prot, int flags, ACE_HANDLE handle, off_t off=0, ACE_HANDLE *file_mapping=0, LPSECURITY_ATTRIBUTES sa=0, const ACE_TCHAR *file_mapping_name=0)
int	mprotect (void *addr, size_t len, int prot)
int	msync (void *addr, size_t len, int sync)
int	munmap (void *addr, size_t len)
A set of wrappers for recursive mutex locks.
int	recursive_mutex_init (ACE_recursive_thread_mutex_t *m, const ACE_TCHAR *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int	recursive_mutex_destroy (ACE_recursive_thread_mutex_t *m)
int	recursive_mutex_lock (ACE_recursive_thread_mutex_t *m)
int	recursive_mutex_trylock (ACE_recursive_thread_mutex_t *m)
int	recursive_mutex_unlock (ACE_recursive_thread_mutex_t *m)
int	recursive_mutex_cond_unlock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)
void	recursive_mutex_cond_relock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)
A set of wrappers for mutex locks.
int	mutex_init (ACE_mutex_t *m, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int	mutex_init (ACE_mutex_t *m, int type, const wchar_t *name, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int	mutex_destroy (ACE_mutex_t *m)
int	mutex_lock (ACE_mutex_t *m)
	Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership. More...
int	mutex_lock (ACE_mutex_t *m, int &abandoned)
	This method is only implemented for Win32. For abandoned mutexes, <abandoned> is set to 1 and 0 is returned. More...
int	mutex_lock (ACE_mutex_t *m, const ACE_Time_Value &timeout)
int	mutex_lock (ACE_mutex_t *m, const ACE_Time_Value *timeout)
int	mutex_trylock (ACE_mutex_t *m)
	Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership. More...
int	mutex_trylock (ACE_mutex_t *m, int &abandoned)
	This method is only implemented for Win32. For abandoned mutexes, <abandoned> is set to 1 and 0 is returned. More...
int	mutex_unlock (ACE_mutex_t *m)
A set of wrappers for mutex locks that only work within a single process.
int	thread_mutex_init (ACE_thread_mutex_t *m, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, ACE_mutexattr_t *arg=0)
int	thread_mutex_init (ACE_thread_mutex_t *m, int type, const wchar_t *name, ACE_mutexattr_t *arg=0)
int	thread_mutex_destroy (ACE_thread_mutex_t *m)
int	thread_mutex_lock (ACE_thread_mutex_t *m)
int	thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value &timeout)
int	thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value *timeout)
int	thread_mutex_trylock (ACE_thread_mutex_t *m)
int	thread_mutex_unlock (ACE_thread_mutex_t *m)
A set of wrappers for low-level file operations.
int	access (const char *path, int amode)
int	access (const wchar_t *path, int amode)
int	close (ACE_HANDLE handle)
ACE_HANDLE	creat (const ACE_TCHAR *filename, mode_t mode)
ACE_HANDLE	dup (ACE_HANDLE handle)
int	dup2 (ACE_HANDLE oldfd, ACE_HANDLE newfd)
int	fattach (int handle, const char *path)
long	filesize (ACE_HANDLE handle)
long	filesize (const ACE_TCHAR *handle)
int	getmsg (ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *flags)
int	getpmsg (ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *band, int *flags)
int	ioctl (ACE_HANDLE handle, int cmd, void *=0)
	UNIX-style <ioctl>. More...
int	ioctl (ACE_HANDLE socket, u_long io_control_code, void *in_buffer_p, u_long in_buffer, void *out_buffer_p, u_long out_buffer, u_long *bytes_returned, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
	QoS-enabled <ioctl>. More...
int	ioctl (ACE_HANDLE socket, u_long io_control_code, ACE_QoS &ace_qos, u_long *bytes_returned, void *buffer_p=0, u_long buffer=0, ACE_OVERLAPPED *overlapped=0, ACE_OVERLAPPED_COMPLETION_FUNC func=0)
	QoS-enabled <ioctl> when the I/O control code is either SIO_SET_QOS or SIO_GET_QOS. More...
int	isastream (ACE_HANDLE handle)
int	isatty (int handle)
int	isatty (ACE_HANDLE handle)
off_t	lseek (ACE_HANDLE handle, off_t offset, int whence)
ACE_HANDLE	open (const char *filename, int mode, int perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
	The O_APPEND flag is only partly supported on Win32. If you specify O_APPEND, then the file pointer will be positioned at the end of the file initially during open, but it is not re-positioned at the end prior to each write, as specified by POSIX. This is generally good enough for typical situations, but it is ``not quite right'' in its semantics. More...
ACE_HANDLE	open (const wchar_t *filename, int mode, int perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
int	putmsg (ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int flags)
int	putpmsg (ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int band, int flags)
ssize_t	read (ACE_HANDLE handle, void *buf, size_t len)
ssize_t	read (ACE_HANDLE handle, void *buf, size_t len, ACE_OVERLAPPED *)
ssize_t	read_n (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred=0)
int	readlink (const char *path, char *buf, size_t bufsiz)
ssize_t	pread (ACE_HANDLE handle, void *buf, size_t nbyte, off_t offset)
int	recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)
int	sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags)
ssize_t	write (ACE_HANDLE handle, const void *buf, size_t nbyte)
ssize_t	write (ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_OVERLAPPED *)
ssize_t	write_n (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred=0)
ssize_t	pwrite (ACE_HANDLE handle, const void *buf, size_t nbyte, off_t offset)
ssize_t	readv (ACE_HANDLE handle, iovec *iov, int iovlen)
ssize_t	writev (ACE_HANDLE handle, const iovec *iov, int iovcnt)
ssize_t	recvv (ACE_HANDLE handle, iovec *iov, int iovlen)
ssize_t	sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt)
A set of wrappers for event demultiplexing and IPC.
int	select (int width, fd_set *rfds, fd_set *wfds=0, fd_set *efds=0, const ACE_Time_Value *tv=0)
int	select (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv)
int	poll (struct pollfd *pollfds, u_long len, const ACE_Time_Value *tv=0)
int	poll (struct pollfd *pollfds, u_long len, const ACE_Time_Value &tv)
int	pipe (ACE_HANDLE handles[])
ACE_HANDLE	shm_open (const ACE_TCHAR *filename, int mode, int perms=0, LPSECURITY_ATTRIBUTES sa=0)
int	shm_unlink (const ACE_TCHAR *path)
A set of wrappers for directory operations.
mode_t	umask (mode_t cmask)
int	chdir (const char *path)
int	chdir (const wchar_t *path)
int	mkdir (const ACE_TCHAR *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)
int	mkfifo (const ACE_TCHAR *file, mode_t mode=ACE_DEFAULT_FILE_PERMS)
ACE_TCHAR *	mktemp (ACE_TCHAR *t)
ACE_HANDLE	mkstemp (ACE_TCHAR *t)
ACE_TCHAR *	getcwd (ACE_TCHAR *, size_t)
int	rename (const ACE_TCHAR *old_name, const ACE_TCHAR *new_name, int flags=-1)
int	unlink (const ACE_TCHAR *path)
ACE_TCHAR *	tempnam (const ACE_TCHAR *dir=0, const ACE_TCHAR *pfx=0)
A set of wrappers for random number operations.
int	rand (void)
int	rand_r (ACE_RANDR_TYPE &seed)
void	srand (u_int seed)
A set of wrappers for readers/writer locks.
int	rwlock_init (ACE_rwlock_t *rw, int type=ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR *name=0, void *arg=0)
int	rwlock_destroy (ACE_rwlock_t *rw)
int	rw_rdlock (ACE_rwlock_t *rw)
int	rw_wrlock (ACE_rwlock_t *rw)
int	rw_tryrdlock (ACE_rwlock_t *rw)
int	rw_trywrlock (ACE_rwlock_t *rw)
int	rw_trywrlock_upgrade (ACE_rwlock_t *rw)
int	rw_unlock (ACE_rwlock_t *rw)
A set of wrappers for auto-reset and manual events.
int	event_init (ACE_event_t *event, int manual_reset=0, int initial_state=0, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int	event_init (ACE_event_t *event, int manual_reset, int initial_state, int type, const wchar_t *name, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int	event_destroy (ACE_event_t *event)
int	event_wait (ACE_event_t *event)
int	event_timedwait (ACE_event_t *event, ACE_Time_Value *timeout, int use_absolute_time=1)
int	event_signal (ACE_event_t *event)
int	event_pulse (ACE_event_t *event)
int	event_reset (ACE_event_t *event)
A set of wrappers for semaphores.
int	sema_destroy (ACE_sema_t *s)
int	sema_init (ACE_sema_t *s, u_int count, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
int	sema_init (ACE_sema_t *s, u_int count, int type, const wchar_t *name, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
int	sema_post (ACE_sema_t *s)
int	sema_post (ACE_sema_t *s, u_int release_count)
int	sema_trywait (ACE_sema_t *s)
int	sema_wait (ACE_sema_t *s)
int	sema_wait (ACE_sema_t *s, ACE_Time_Value &tv)
int	sema_wait (ACE_sema_t *s, ACE_Time_Value *tv)
A set of wrappers for System V semaphores.
int	semctl (int int_id, int semnum, int cmd, semun)
int	semget (key_t key, int nsems, int flags)
int	semop (int int_id, struct sembuf *sops, size_t nsops)
Thread scheduler interface.
int	sched_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
	Set scheduling parameters. An id of ACE_SELF indicates, e.g., set the parameters on the calling thread. More...
A set of wrappers for System V shared memory.
void *	shmat (int int_id, void *shmaddr, int shmflg)
int	shmctl (int int_id, int cmd, struct shmid_ds *buf)
int	shmdt (void *shmaddr)
int	shmget (key_t key, int size, int flags)
A set of wrappers for Signals.
int	kill (pid_t pid, int signum)
int	sigaction (int signum, const struct sigaction *nsa, struct sigaction *osa)
int	sigaddset (sigset_t *s, int signum)
int	sigdelset (sigset_t *s, int signum)
int	sigemptyset (sigset_t *s)
int	sigfillset (sigset_t *s)
int	sigismember (sigset_t *s, int signum)
ACE_SignalHandler	signal (int signum, ACE_SignalHandler)
int	sigsuspend (const sigset_t *set)
int	sigprocmask (int how, const sigset_t *nsp, sigset_t *osp)
int	pthread_sigmask (int how, const sigset_t *nsp, sigset_t *osp)
A set of wrappers for sockets.
ACE_HANDLE	accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
	BSD-style <accept> (no QoS). More...
ACE_HANDLE	accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen, const ACE_Accept_QoS_Params &qos_params)
int	connect (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
	BSD-style <connect> (no QoS). More...
int	connect (ACE_HANDLE handle, const sockaddr *addr, int addrlen, const ACE_QoS_Params &qos_params)
int	bind (ACE_HANDLE s, struct sockaddr *name, int namelen)
	BSD-style <accept> (no QoS). More...
int	closesocket (ACE_HANDLE s)
	BSD-style <accept> (no QoS). More...
hostent *	gethostbyaddr (const char *addr, int length, int type)
	BSD-style <accept> (no QoS). More...
hostent *	gethostbyname (const char *name)
	BSD-style <accept> (no QoS). More...
hostent *	getipnodebyname (const char *name, int family, int flags=0)
	BSD-style <accept> (no QoS). More...
hostent *	getipnodebyaddr (const void *src, size_t len, int family)
	BSD-style <accept> (no QoS). More...
hostent *	gethostbyaddr_r (const char *addr, int length, int type, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
	BSD-style <accept> (no QoS). More...
hostent *	gethostbyname_r (const char *name, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
	BSD-style <accept> (no QoS). More...
int	getpeername (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
	BSD-style <accept> (no QoS). More...
protoent *	getprotobyname (const char *name)
	BSD-style <accept> (no QoS). More...
protoent *	getprotobyname_r (const char *name, struct protoent *result, ACE_PROTOENT_DATA buffer)
	BSD-style <accept> (no QoS). More...
protoent *	getprotobynumber (int proto)
	BSD-style <accept> (no QoS). More...
protoent *	getprotobynumber_r (int proto, struct protoent *result, ACE_PROTOENT_DATA buffer)
	BSD-style <accept> (no QoS). More...
servent *	getservbyname (const char *svc, const char *proto)
	BSD-style <accept> (no QoS). More...
servent *	getservbyname_r (const char *svc, const char *proto, struct servent *result, ACE_SERVENT_DATA buf)
	BSD-style <accept> (no QoS). More...
int	getsockname (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
	BSD-style <accept> (no QoS). More...
int	getsockopt (ACE_HANDLE handle, int level, int optname, char *optval, int *optlen)
	BSD-style <accept> (no QoS). More...
unsigned long	inet_addr (const char *name)
	BSD-style <accept> (no QoS). More...
char *	inet_ntoa (const struct in_addr addr)
	BSD-style <accept> (no QoS). More...
int	inet_aton (const char *strptr, struct in_addr *addr)
	BSD-style <accept> (no QoS). More...
const char *	inet_ntop (int family, const void *addrptr, char *strptr, size_t len)
	BSD-style <accept> (no QoS). More...
int	inet_pton (int family, const char *strptr, void *addrptr)
	BSD-style <accept> (no QoS). More...
int	enum_protocols (int *protocols, ACE_Protocol_Info *protocol_buffer, u_long *buffer_length)
	Retrieve information about available transport protocols installed on the local machine. More...
ACE_HANDLE	join_leaf (ACE_HANDLE socket, const sockaddr *name, int namelen, const ACE_QoS_Params &qos_params)
	Joins a leaf node into a QoS-enabled multi-point session. More...
int	listen (ACE_HANDLE handle, int backlog)
	BSD-style <accept> (no QoS). More...
int	recv (ACE_HANDLE handle, char *buf, size_t len, int flags=0)
	BSD-style <accept> (no QoS). More...
int	recvfrom (ACE_HANDLE handle, char *buf, size_t len, int flags, struct sockaddr *addr, int *addrlen)
	BSD-style <accept> (no QoS). More...
int	recvfrom (ACE_HANDLE handle, iovec *buffers, int buffer_count, size_t &number_of_bytes_recvd, int &flags, struct sockaddr *addr, int *addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
	BSD-style <accept> (no QoS). More...
int	send (ACE_HANDLE handle, const char *buf, size_t len, int flags=0)
	BSD-style <accept> (no QoS). More...
int	sendto (ACE_HANDLE handle, const char *buf, size_t len, int flags, const struct sockaddr *addr, int addrlen)
	BSD-style <accept> (no QoS). More...
int	sendto (ACE_HANDLE handle, const iovec *buffers, int buffer_count, size_t &number_of_bytes_sent, int flags, const struct sockaddr *addr, int addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
	BSD-style <accept> (no QoS). More...
int	setsockopt (ACE_HANDLE handle, int level, int optname, const char *optval, int optlen)
	Manipulate the options associated with a socket. More...
int	shutdown (ACE_HANDLE handle, int how)
	BSD-style <accept> (no QoS). More...
ACE_HANDLE	socket (int protocol_family, int type, int proto)
	Create a BSD-style socket (no QoS). More...
ACE_HANDLE	socket (int protocol_family, int type, int proto, ACE_Protocol_Info *protocolinfo, ACE_SOCK_GROUP g, u_long flags)
	Create a QoS-enabled socket. If the OS platform doesn't support QoS-enabled <socket> then the BSD-style <socket> is called. More...
int	socketpair (int domain, int type, int protocol, ACE_HANDLE sv[2])
	BSD-style <accept> (no QoS). More...
int	socket_init (int version_high=1, int version_low=1)
	Initialize WinSock before first use (e.g., when a DLL is first loaded or the first use of a socket() call. More...
int	socket_fini (void)
	Finalize WinSock after last use (e.g., when a DLL is unloaded). More...
A set of wrappers for password routines.
void	setpwent (void)
void	endpwent (void)
passwd *	getpwent (void)
passwd *	getpwnam (const char *user)
passwd *	getpwnam_r (const char *name, struct passwd *pwent, char *buffer, int buflen)
A set of wrappers for regular expressions.
char *	compile (const char *instring, char *expbuf, char *endbuf)
int	step (const char *str, char *expbuf)
Static Public Attributes
int	socket_initialized_
	Keeps track of whether we've already initialized WinSock... More...
Private Methods
	ACE_CLASS_IS_NAMESPACE (ACE_OS)
Static Private Methods
ACE_EXIT_HOOK	set_exit_hook (ACE_EXIT_HOOK hook)
	For use by ACE_Object_Manager only, to register its exit hook.. More...
void	fopen_mode_to_open_mode_converter (ACE_TCHAR x, int &hmode)
	Translate fopen's mode char to open's mode. This helper function is here to avoid maintaining several pieces of identical code. More...
int	cond_timedwait_i (ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *)
u_int	alarm_i (u_int secs)
u_int	ualarm_i (u_int usecs, u_int interval=0)
u_int	ualarm_i (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)
int	sleep_i (u_int seconds)
int	sleep_i (const ACE_Time_Value &tv)
int	nanosleep_i (const struct timespec *requested, struct timespec *remaining=0)
int	select_i (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value *tv=0)
int	select_i (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv)
int	poll_i (struct pollfd *pollfds, u_long len, const ACE_Time_Value *tv=0)
int	poll_i (struct pollfd *pollfds, u_long len, const ACE_Time_Value &tv)
int	sema_wait_i (ACE_sema_t *s)
int	sema_wait_i (ACE_sema_t *s, ACE_Time_Value &tv)
int	sigtimedwait_i (const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout)
ACE_Time_Value	gettimeofday_i (void)
Static Private Attributes
ACE_EXIT_HOOK	exit_hook_ = 0
	Function that is called by <ACE_OS::exit>, if non-null. More...
OSVERSIONINFO	win32_versioninfo_
HINSTANCE	win32_resource_module_
Friends
class	ACE_Timeout_Manager
class	ACE_OS_Object_Manager
	Allow the ACE_OS_Object_Manager to call set_exit_hook. More...

---

Detailed Description

This class defines an OS independent programming API that shields developers from nonportable aspects of writing efficient system programs on Win32, POSIX and other versions of UNIX, and various real-time operating systems.

This class encapsulates the differences between various OS platforms. When porting ACE to a new platform, this class is the place to focus on. Once this file is ported to a new platform, pretty much everything else comes for "free." See <www.cs.wustl.edu/~schmidt/ACE_wrappers/etc/ACE-porting.html> for instructions on porting ACE. Please see the README file in this directory for complete information on the meaning of the various macros.

Definition at line 4585 of file OS.h.

---

Member Typedef Documentation

typedef wchar_t ACE_OS::WChar

Definition at line 5793 of file OS.h. Referenced by ACE_Log_Msg::log, wscmp, wscpy, and wsncmp.

---

Member Enumeration Documentation

enum ACE_OS::ACE_HRTimer_Op

Enumeration values: ACE_HRTIMER_START  ACE_HRTIMER_INCR  ACE_HRTIMER_STOP  ACE_HRTIMER_GETTIME  Definition at line 4606 of file OS.h. Referenced by ACE_High_Res_Timer::gettime, ACE_High_Res_Timer::gettimeofday, ACE_High_Res_Timer::start, ACE_High_Res_Timer::start_incr, ACE_High_Res_Timer::stop, and ACE_High_Res_Timer::stop_incr. { ACE_HRTIMER_START = 0x0, // Only use these if you can stand ACE_HRTIMER_INCR = 0x1, // for interrupts to be disabled during ACE_HRTIMER_STOP = 0x2, // the timed interval!!!! ACE_HRTIMER_GETTIME = 0xFFFF };

---

Member Function Documentation

ACE_INLINE void ACE_OS::_exit (  int    status = 0 )  [static]

Definition at line 1019 of file OS.i. References ACE_OS_TRACE. Referenced by ACE::fork, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::_exit"); #if defined (VXWORKS) ::exit (status); #elif defined (ACE_PSOSIM) ::u_exit (status); #elif defined (ACE_PSOS) # if defined (ACE_PSOS_LACKS_PREPC) /* pSoS TM does not support exit. */ ACE_UNUSED_ARG (status); return; # else ::exit (status); # endif /* defined (ACE_PSOS_LACKS_PREPC) */ #elif !defined (ACE_HAS_WINCE) ::_exit (status); #else ::TerminateProcess (::GetCurrentProcess (), status); #endif /* VXWORKS */ }

ACE_INLINE void ACE_OS::abort (  void    )  [static]

Definition at line 1042 of file OS.i. References exit. Referenced by ACE_Log_Msg::log. { #if !defined (ACE_HAS_WINCE) ::abort (); #else // @@ CE doesn't support abort? exit (1); #endif /* !ACE_HAS_WINCE */ }

ACE_HANDLE ACE_OS::accept (  ACE_HANDLE    handle, struct sockaddr *    addr, int *    addrlen, const ACE_Accept_QoS_Params &    qos_params )  [static]

QoS-enabled <accept>, which passes <qos_params> to <accept>. If the OS platform doesn't support QoS-enabled <accept> then the <qos_params> are ignored and the BSD-style <accept> is called. Definition at line 7412 of file OS.cpp. References accept, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, ACE_Accept_QoS_Params::callback_data, and ACE_Accept_QoS_Params::qos_condition_callback. { # if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) ACE_SOCKCALL_RETURN (::WSAAccept ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen, (LPCONDITIONPROC) qos_params.qos_condition_callback (), qos_params.callback_data ()), ACE_HANDLE, ACE_INVALID_HANDLE); # else ACE_UNUSED_ARG (qos_params); return ACE_OS::accept (handle, addr, addrlen); # endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE ACE_HANDLE ACE_OS::accept (  ACE_HANDLE    handle, struct sockaddr *    addr, int *    addrlen )  [static]

BSD-style <accept> (no QoS). Definition at line 4694 of file OS.i. References accept, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and EWOULDBLOCK. Referenced by ACE_SOCK_Acceptor::accept, accept, ACE_MEM_Acceptor::accept, ACE_LSOCK_Acceptor::accept, ACE_ATM_Acceptor::accept, and ACE_POSIX_Asynch_Accept::handle_input. { ACE_OS_TRACE ("ACE_OS::accept"); #if defined (ACE_PSOS) # if !defined (ACE_PSOS_DIAB_PPC) ACE_SOCKCALL_RETURN (::accept ((ACE_SOCKET) handle, (struct sockaddr_in *) addr, (ACE_SOCKET_LEN *) addrlen), ACE_HANDLE, ACE_INVALID_HANDLE); # else ACE_SOCKCALL_RETURN (::accept ((ACE_SOCKET) handle, (struct sockaddr *) addr, (ACE_SOCKET_LEN *) addrlen), ACE_HANDLE, ACE_INVALID_HANDLE); # endif /* defined ACE_PSOS_DIAB_PPC */ #else // On a non-blocking socket with no connections to accept, this // system call will return EWOULDBLOCK or EAGAIN, depending on the // platform. UNIX 98 allows either errno, and they may be the same // numeric value. So to make life easier for upper ACE layers as // well as application programmers, always change EAGAIN to // EWOULDBLOCK. Rather than hack the ACE_OSCALL_RETURN macro, it's // handled explicitly here. If the ACE_OSCALL macro ever changes, // this function needs to be reviewed. On Win32, the regular macros // can be used, as this is not an issue. # if defined (ACE_WIN32) ACE_SOCKCALL_RETURN (::accept ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), ACE_HANDLE, ACE_INVALID_HANDLE); # else # if defined (ACE_HAS_BROKEN_ACCEPT_ADDR) // Apparently some platforms like VxWorks can't correctly deal with // a NULL addr. sockaddr_in fake_addr; int fake_addrlen; if (addrlen == 0) addrlen = &fake_addrlen; if (addr == 0) { addr = (sockaddr *) &fake_addr; *addrlen = sizeof fake_addr; } # endif /* VXWORKS */ ACE_HANDLE ace_result = ::accept ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen) ; if (ace_result == ACE_INVALID_HANDLE && errno == EAGAIN) errno = EWOULDBLOCK; return ace_result; # endif /* defined (ACE_WIN32) */ #endif /* defined (ACE_PSOS) */ }

int ACE_OS::access (  const wchar_t *    path, int    amode )  [static]

ACE_INLINE int ACE_OS::access (  const char *    path, int    amode )  [static]

Definition at line 7681 of file OS.i. References access, ACE_LIB_TEXT, ACE_OS_TRACE, ACE_TEXT_CHAR_TO_TCHAR, fclose, and fopen. Referenced by access, ACE_Filecache_Object::ACE_Filecache_Object, ACE_Local_Name_Space::create_manager_i, ACE_Lib_Find::ldfind, open, and ACE_Configuration_Heap::open. { ACE_OS_TRACE ("ACE_OS::access"); #if defined (ACE_LACKS_ACCESS) # if defined (ACE_HAS_WINCE) // @@ WINCE: There should be a Win32 API that can do this. // Hard coded read access here. FILE* handle = ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR(path), ACE_LIB_TEXT ("r")); ACE_UNUSED_ARG (amode); ACE_OS::fclose (handle); return (handle == ACE_INVALID_HANDLE ? -1 : 0); # else ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (amode); ACE_NOTSUP_RETURN (-1); # endif // ACE_HAS_WINCE #else ACE_OSCALL_RETURN (::access (path, amode), int, -1); #endif /* ACE_LACKS_ACCESS */ }

ACE_OS::ACE_CLASS_IS_NAMESPACE (  ACE_OS    )  [private]

void ACE_OS::adjust_flock_params (  ACE_OS::ace_flock_t *    lock, short    whence, off_t &    start, off_t &    len )  [static]

Referenced by flock_rdlock, flock_tryrdlock, flock_trywrlock, flock_unlock, and flock_wrlock.

ACE_INLINE u_int ACE_OS::alarm (  u_int    secs )  [static]

Definition at line 7901 of file OS.i. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::alarm"); #if defined (ACE_WIN32) || defined (VXWORKS) || defined (CHORUS) || defined (ACE_PSOS) ACE_UNUSED_ARG (secs); ACE_NOTSUP_RETURN (0); #else return ::alarm (secs); #endif /* ACE_WIN32 || VXWORKS || CHORUS || ACE_PSOS */ }

u_int ACE_OS::alarm_i (  u_int    secs )  [static, private]

ACE_INLINE int ACE_OS::allocation_granularity (  void    )  [static]

Definition at line 9719 of file OS.i. References getpagesize. Referenced by ACE::round_to_allocation_granularity. { #if defined (ACE_WIN32) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return (int) sys_info.dwAllocationGranularity; #else return ACE_OS::getpagesize (); #endif /* ACE_WIN32 */ }

int ACE_OS::argv_to_string (  ACE_TCHAR **    argv, ACE_TCHAR *&    buf, int    substitute_env_args = 1 )  [static]

Definition at line 3900 of file OS.cpp. References ACE_NEW_RETURN, ACE_TCHAR, getenv, ACE_OS_String::strecpy, and ACE_OS_String::strlen. Referenced by ACE_ARGV::argv_to_string, and fork_exec. { if (argv == 0 || argv[0] == 0) return 0; size_t buf_len = 0; // Determine the length of the buffer. for (int i = 0; argv[i] != 0; i++) { ACE_TCHAR *temp = 0; #if !defined (ACE_LACKS_ENV) // Account for environment variables. if (substitute_env_args && (argv[i][0] == '$' && (temp = ACE_OS::getenv (&argv[i][1])) != 0)) buf_len += ACE_OS_String::strlen (temp); else #endif /* ACE_LACKS_ENV */ buf_len += ACE_OS_String::strlen (argv[i]); // Add one for the extra space between each string. buf_len++; } // Step through all argv params and copy each one into buf; separate // each param with white space. ACE_NEW_RETURN (buf, ACE_TCHAR[buf_len + 1], 0); // Initial null charater to make it a null string. buf[0] = '\0'; ACE_TCHAR *end = buf; int j; for (j = 0; argv[j] != 0; j++) { ACE_TCHAR *temp = 0; # if !defined (ACE_LACKS_ENV) // Account for environment variables. if (substitute_env_args && (argv[j][0] == '$' && (temp = ACE_OS::getenv (&argv[j][1])) != 0)) end = ACE_OS::strecpy (end, temp); else #endif /* ACE_LACKS_ENV */ end = ACE_OS::strecpy (end, argv[j]); // Replace the null char that strecpy put there with white // space. end[-1] = ' '; } // Null terminate the string. *end = '\0'; // The number of arguments. return j; }

ACE_INLINE char * ACE_OS::asctime (  const struct tm *    tm )  [static]

Definition at line 8811 of file OS.i. References ACE_OS_TRACE, and asctime. Referenced by asctime, asctime_r, and ctime. { #if !defined (ACE_HAS_WINCE) && !defined(ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) ACE_OS_TRACE ("ACE_OS::asctime"); ACE_OSCALL_RETURN (::asctime (t), char *, 0); #else // @@ WinCE doesn't have gmtime also. ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (0); #endif /* !ACE_HAS_WINCE && !ACE_PSOS || ACE_PSOS_HAS_TIME */ }

ACE_INLINE char * ACE_OS::asctime_r (  const struct tm *    tm, char *    buf, int    buflen )  [static]

Definition at line 8824 of file OS.i. References ACE_OS_TRACE, asctime, asctime_r, and ACE_OS_String::strsncpy. Referenced by asctime_r. { ACE_OS_TRACE ("ACE_OS::asctime_r"); #if defined (ACE_HAS_REENTRANT_FUNCTIONS) # if defined (ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R) char *result; # if defined (DIGITAL_UNIX) ACE_OSCALL (::_Pasctime_r (t, buf), char *, 0, result); # else ACE_OSCALL (::asctime_r (t, buf), char *, 0, result); # endif /* DIGITAL_UNIX */ ACE_OS::strsncpy (buf, result, buflen); return buf; # else # if defined (HPUX_10) return (::asctime_r(t, buf, buflen) == 0 ? buf : (char *)0); # else ACE_OSCALL_RETURN (::asctime_r (t, buf, buflen), char *, 0); # endif /* HPUX_10 */ # endif /* ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R */ #elif ! defined (ACE_HAS_WINCE) && !defined(ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) char *result; ACE_OSCALL (::asctime (t), char *, 0, result); ACE_OS::strsncpy (buf, result, buflen); return buf; #else // @@ Same as ACE_OS::asctime (), you need to implement it // yourself. ACE_UNUSED_ARG (t); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (buflen); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

ACE_INLINE int ACE_OS::atexit (  ACE_EXIT_HOOK    func )  [static]

Definition at line 1011 of file OS.i. References ACE_OS_Object_Manager::at_exit, and ACE_OS_Object_Manager::instance. { return ACE_OS_Object_Manager::instance ()->at_exit (func); }

int ACE_OS::atoi (  const wchar_t *    s )  [static]

ACE_INLINE int ACE_OS::atoi (  const char *    s )  [static]

Definition at line 5521 of file OS.i. References atoi. Referenced by atoi, ACE_High_Res_Timer::get_env_global_scale_factor, ACE_Service_Manager::init, ACE_SOCK_Dgram_Mcast::make_multicast_ifaddr, ACE_Service_Config::parse_args, ACE_Name_Options::parse_args, ACE_Logging_Strategy::parse_args, ACE_Registry_ImpExp::process_previous_line_format, ACE_SOCK_Dgram::set_nic, and ACE_INET_Addr::string_to_addr. { ACE_OSCALL_RETURN (::atoi (s), int, -1); }

void* ACE_OS::atop (  const wchar_t *    s )  [static]

ACE_INLINE void * ACE_OS::atop (  const char *    s )  [static]

Definition at line 5540 of file OS.i. References ACE_TRACE. Referenced by ACE_Name_Options::parse_args. { ACE_TRACE ("ACE_OS::atop"); // It would be nice to make use of Basic_Types.h here, but that // file relies on OS.h. Fortunately, most platforms have int // the same as pointer size (IA32, IA64), with Win64 being the // exception. #if defined (ACE_WIN64) __int64 ip = ::_atoi64 (s); #else int ip = ::atoi (s); #endif /* ACE_WIN64 */ void *p = ACE_reinterpret_cast (void *, ip); return p; }

ACE_INLINE int ACE_OS::bind (  ACE_HANDLE    s, struct sockaddr *    name, int    namelen )  [static]

BSD-style <accept> (no QoS). Definition at line 4781 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and bind. Referenced by bind, ACE_Sock_Connect::bind_port, ACE_WIN32_Asynch_Connect::connect_i, ACE_POSIX_Asynch_Connect::connect_i, ACE_SOCK_CODgram::open, ACE_ATM_Stream::open, ACE_ATM_Acceptor::open, ACE_Asynch_Acceptor::open, ACE_SOCK_Connector::shared_connect_start, ACE_SOCK_Dgram::shared_open, and ACE_SOCK_Acceptor::shared_open. { ACE_OS_TRACE ("ACE_OS::bind"); #if defined (ACE_PSOS) && !defined (ACE_PSOS_DIAB_PPC) ACE_SOCKCALL_RETURN (::bind ((ACE_SOCKET) handle, (struct sockaddr_in *) addr, (ACE_SOCKET_LEN) addrlen), int, -1); #else /* !defined (ACE_PSOS) || defined (ACE_PSOS_DIAB_PPC) */ ACE_SOCKCALL_RETURN (::bind ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN) addrlen), int, -1); #endif /* defined (ACE_PSOS) && !defined (ACE_PSOS_DIAB_PPC) */ }

ACE_INLINE void * ACE_OS::bsearch (  const void *    key, const void *    base, size_t    nel, size_t    size, ACE_COMPARE_FUNC    )  [static]

Definition at line 10887 of file OS.i. References ACE_COMPARE_FUNC. { #if !defined (ACE_LACKS_BSEARCH) return ::bsearch (key, base, nel, size, compar); #else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (base); ACE_UNUSED_ARG (nel); ACE_UNUSED_ARG (size); ACE_UNUSED_ARG (compar); ACE_NOTSUP_RETURN (0); #endif /* ACE_LACKS_BSEARCH */ }

ACE_INLINE double ACE_OS::ceil (  double    x )  [static]

This method computes the smallest integral value not less than x. Definition at line 5578 of file OS.i. References floor. { // This method computes the smallest integral value not less than x. double floor = ACE_OS::floor (x); if (floor == x) return floor; else return floor + 1; }

int ACE_OS::chdir (  const wchar_t *    path )  [static]

ACE_INLINE int ACE_OS::chdir (  const char *    path )  [static]

Definition at line 159 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and chdir. Referenced by chdir, ACE::daemonize, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::chdir"); #if defined (VXWORKS) ACE_OSCALL_RETURN (::chdir (ACE_const_cast (char *, path)), int, -1); #elif defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (path); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_PSOS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::change_dir ((char *) path), ace_result_), int, -1); // This #elif seems weird... is Visual Age on NT not setting ACE_WIN32? #elif !defined (ACE_WIN32) && !defined (AIX) && defined (__IBMCPP__) && (__IBMCPP__ >= 400) ACE_OSCALL_RETURN (::_chdir (path), int, -1); #elif defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (path); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::chdir (path), int, -1); #endif /* VXWORKS */ }

void ACE_OS::cleanup_tss (  const u_int    main_thread )  [static]

Call TSS destructors for the current thread. If the current thread is the main thread, then the argument must be 1. For private use of ACE_Object_Manager and ACE_Thread_Adapter only. Definition at line 2445 of file OS.cpp. References ACE_Base_Thread_Adapter::close_log_msg, ACE_TSS_Cleanup::exit, ACE_TSS_Cleanup::free_all_keys_left, and ACE_TSS_Cleanup::instance. Referenced by ACE_Object_Manager::fini, ACE_OS_Thread_Adapter::invoke, ACE_Thread_Adapter::invoke_i, and thr_exit. { #if defined (ACE_HAS_TSS_EMULATION) || defined (ACE_WIN32) || (defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS)) // Call TSS destructors for current thread. ACE_TSS_Cleanup::instance ()->exit (0); #endif /* ACE_HAS_TSS_EMULATION || ACE_WIN32 || ACE_PSOS_HAS_TSS */ if (main_thread) { #if !defined (ACE_HAS_TSS_EMULATION) && !defined (ACE_HAS_MINIMAL_ACE_OS) // Just close the ACE_Log_Msg for the current (which should be // main) thread. We don't have TSS emulation; if there's native // TSS, it should call its destructors when the main thread // exits. ACE_Base_Thread_Adapter::close_log_msg (); #endif /* ! ACE_HAS_TSS_EMULATION && ! ACE_HAS_MINIMAL_ACE_OS */ #if defined (ACE_WIN32) || defined (ACE_HAS_TSS_EMULATION) || (defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS)) #if ! defined (ACE_HAS_TSS_EMULATION) // Don't do this with TSS_Emulation, because the the // ACE_TSS_Cleanup::instance () has already exited (). We can't // safely access the TSS values that were created by the main // thread. // Remove all TSS_Info table entries. ACE_TSS_Cleanup::instance ()->free_all_keys_left (); #endif /* ! ACE_HAS_TSS_EMULATION */ // Finally, free up the ACE_TSS_Cleanup instance. This method gets // called by the ACE_Object_Manager. delete ACE_TSS_Cleanup::instance (); #endif /* WIN32 || ACE_HAS_TSS_EMULATION || ACE_PSOS_HAS_TSS */ #if defined (ACE_HAS_TSS_EMULATION) ACE_TSS_Emulation::tss_close (); #endif /* ACE_HAS_TSS_EMULATION */ } }

ACE_INLINE void ACE_OS::clearerr (  FILE *    fp )  [static]

Definition at line 9973 of file OS.i. { ::clearerr(fp); }

ACE_INLINE int ACE_OS::clock_gettime (  clockid_t   , struct timespec *    )  [static]

Definition at line 597 of file OS.i. References ACE_OS_TRACE, clock_gettime, and clockid_t. Referenced by clock_gettime, gethrtime, and gettimeofday. { ACE_OS_TRACE ("ACE_OS::clock_gettime"); #if defined (ACE_HAS_CLOCK_GETTIME) ACE_OSCALL_RETURN (::clock_gettime (clockid, ts), int, -1); # elif defined (ACE_PSOS) && ! defined (ACE_PSOS_DIAB_MIPS) ACE_UNUSED_ARG (clockid); ACE_PSOS_Time_t pt; int result = ACE_PSOS_Time_t::get_system_time (pt); *ts = ACE_static_cast (struct timespec, pt); return result; #else ACE_UNUSED_ARG (clockid); ACE_UNUSED_ARG (ts); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_CLOCK_GETTIME */ }

ACE_INLINE int ACE_OS::close (  ACE_HANDLE    handle )  [static]

Definition at line 2830 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and close. Referenced by ACE_Condition::ACE_Condition, ACE_Filecache_Object::ACE_Filecache_Object, ACE_Mutex::ACE_Mutex, ACE_WIN32_Proactor::close, ACE_TLI_Stream::close, ACE_SPIPE::close, close, ACE_FILE::close, ACE_FIFO_Recv::close, ACE_FIFO::close, ACE_Dev_Poll_Reactor::close, ACE_DEV::close, ACE_Mem_Map::close_filemapping_handle, ACE_Mem_Map::close_handle, ACE_Handle_Gobbler::close_remaining_handles, closesocket, ACE_SPIPE_Connector::connect, ACE_SPIPE_Acceptor::create_new_instance, ACE::daemonize, filesize, flock_destroy, fopen, fork_exec, ACE_Handle_Gobbler::free_handles, ACE_Sock_Connect::get_bcast_addr, ACE_Sock_Connect::get_ip_interfaces, ACE_Filecache_Object::release, ACE_Process_Options::release_handles, sema_init, ACE_Process::spawn, ACE::terminate_process, ACE_Filecache_Handle::~ACE_Filecache_Handle, ACE_Filecache_Object::~ACE_Filecache_Object, and ACE_Process::~ACE_Process. { ACE_OS_TRACE ("ACE_OS::close"); #if defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (handle), ace_result_), int, -1); #elif defined (ACE_PSOS) && ! defined (ACE_PSOS_LACKS_PHILE) u_long result = ::close_f (handle); if (result != 0) { errno = result; return ACE_static_cast (int, -1); } return ACE_static_cast (int, 0); #else ACE_OSCALL_RETURN (::close (handle), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::closesocket (  ACE_HANDLE    s )  [static]

BSD-style <accept> (no QoS). Definition at line 7668 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, close, and closesocket. Referenced by ACE_WIN32_Asynch_Accept::accept, ACE_SOCK::close, ACE_POSIX_Asynch_Accept::close, ACE_Pipe::close, ACE_Process::close_dup_handles, ACE_Process::close_passed_handles, closesocket, ACE_Asynch_Acceptor::handle_accept, ACE_Asynch_Connector::handle_connect, ACE_POSIX_Asynch_Accept::handle_input, ACE_Sock_Connect::ipv6_enabled, ACE_WIN32_Asynch_Connect::post_result, ACE_POSIX_Asynch_Connect::post_result, and ACE_AIOCB_Notify_Pipe_Manager::~ACE_AIOCB_Notify_Pipe_Manager. { ACE_OS_TRACE ("ACE_OS::closesocket"); #if defined (ACE_WIN32) ACE_SOCKCALL_RETURN (::closesocket ((SOCKET) handle), int, -1); #elif defined (ACE_PSOS_DIAB_PPC) ACE_OSCALL_RETURN (::pna_close (handle), int, -1); #else ACE_OSCALL_RETURN (::close (handle), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE char * ACE_OS::compile (  const char *    instring, char *    expbuf, char *    endbuf )  [static]

Definition at line 7637 of file OS.i. References ACE_OS_TRACE, and compile. Referenced by compile, ACE_Local_Name_Space::list_type_entries_i, and ACE_Local_Name_Space::list_types_i. { ACE_OS_TRACE ("ACE_OS::compile"); #if defined (ACE_HAS_REGEX) ACE_OSCALL_RETURN (::compile (instring, expbuf, endbuf), char *, 0); #else ACE_UNUSED_ARG (instring); ACE_UNUSED_ARG (expbuf); ACE_UNUSED_ARG (endbuf); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_REGEX */ }

ACE_INLINE int ACE_OS::cond_broadcast (  ACE_cond_t *    cv )  [static]

Definition at line 2178 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and cond_broadcast. Referenced by ACE_Condition::broadcast, ACE_Condition< ACE_Recursive_Thread_Mutex >::broadcast, ACE_Condition_Thread_Mutex::broadcast, cond_broadcast, event_pulse, event_signal, ACE_Condition::remove, and rw_unlock. { ACE_OS_TRACE ("ACE_OS::cond_broadcast"); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_cond_broadcast (cv), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_cond_broadcast (cv), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_broadcast (cv), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cv_broadcast (*cv), ace_result_), int, -1); # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (cv); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::cond_destroy (  ACE_cond_t *    cv )  [static]

Definition at line 1964 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and cond_destroy. Referenced by cond_destroy, event_destroy, recursive_mutex_destroy, ACE_Condition::remove, ACE_Condition< ACE_Recursive_Thread_Mutex >::remove, rwlock_destroy, sema_destroy, and sema_init. { ACE_OS_TRACE ("ACE_OS::cond_destroy"); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_cond_destroy (cv), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_cond_destroy (cv), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_destroy (cv), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cv_delete (*cv), ace_result_), int, -1); # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (cv); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

int ACE_OS::cond_init (  ACE_cond_t *    cv, ACE_condattr_t &    attributes, const wchar_t *    name, void *    arg = 0 )  [static]

int ACE_OS::cond_init (  ACE_cond_t *    cv, short    type, const wchar_t *    name, void *    arg = 0 )  [static]

ACE_INLINE int ACE_OS::cond_init (  ACE_cond_t *    cv, ACE_condattr_t &    attributes, const char *    name = 0, void *    arg = 0 )  [static]

Definition at line 2073 of file OS.i. References ACE_ADAPT_RETVAL, and cond_init. { // ACE_OS_TRACE ("ACE_OS::cond_init"); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) int result = -1; if ( # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_cond_init (cv, attributes) == 0 # elif defined (ACE_HAS_PTHREADS_STD) || defined (ACE_HAS_PTHREADS_DRAFT7) ACE_ADAPT_RETVAL(::pthread_cond_init (cv, &attributes), result) == 0 # else /* this is draft 6 */ ::pthread_cond_init (cv, &attributes) == 0 # endif /* ACE_HAS_PTHREADS_DRAFT4 */ ) result = 0; else result = -1; // ACE_ADAPT_RETVAL used it for intermediate status return result; # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_init (cv, attributes.type, arg), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cv_create (ACE_const_cast (char *, name), attributes, cv), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS vs. ACE_HAS_STHREADS vs. ACE_PSOS */ # else ACE_UNUSED_ARG (cv); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::cond_init (  ACE_cond_t *    cv, short    type = ACE_DEFAULT_SYNCH_TYPE, const char *    name = 0, void *    arg = 0 )  [static]

Definition at line 2133 of file OS.i. References condattr_destroy, and condattr_init. Referenced by ACE_Condition::ACE_Condition, ACE_Condition< ACE_Recursive_Thread_Mutex >::ACE_Condition, ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex, cond_init, event_init, recursive_mutex_init, and sema_init. { ACE_condattr_t attributes; if (ACE_OS::condattr_init (attributes, type) == 0 && ACE_OS::cond_init (cv, attributes, name, arg) == 0) { (void) ACE_OS::condattr_destroy (attributes); return 0; } return -1; }

ACE_INLINE int ACE_OS::cond_signal (  ACE_cond_t *    cv )  [static]

Definition at line 2154 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and cond_signal. Referenced by cond_signal, event_pulse, event_signal, recursive_mutex_cond_unlock, recursive_mutex_unlock, rw_unlock, sema_post, ACE_Condition::signal, ACE_Condition< ACE_Recursive_Thread_Mutex >::signal, and ACE_Condition_Thread_Mutex::signal. { ACE_OS_TRACE ("ACE_OS::cond_signal"); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_cond_signal (cv), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_cond_signal (cv),ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_signal (cv), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cv_signal (*cv), ace_result_), int, -1); # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (cv); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::cond_timedwait (  ACE_cond_t *    cv, ACE_mutex_t *    m, ACE_Time_Value *    )  [static]

Definition at line 2233 of file OS.i. References ACE_ADAPT_RETVAL, ACE_ONE_SECOND_IN_USECS, ACE_OS_TRACE, cond_wait, ETIME, ETIMEDOUT, gettimeofday, ACE_Time_Value::sec, ACE_Time_Value::set, and ACE_Time_Value::usec. Referenced by event_timedwait, sema_wait, ACE_Condition::wait, ACE_Condition< ACE_Recursive_Thread_Mutex >::wait, and ACE_Condition_Thread_Mutex::wait. { ACE_OS_TRACE ("ACE_OS::cond_timedwait"); # if defined (ACE_HAS_THREADS) int result; timespec_t ts; if (timeout != 0) ts = *timeout; // Calls ACE_Time_Value::operator timespec_t(). # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) if (timeout == 0) ACE_OSCALL (::pthread_cond_wait (cv, external_mutex), int, -1, result); else { # if defined (__Lynx__) // Note that we must convert between absolute time (which is // passed as a parameter) and relative time (which is what the // LynxOS pthread_cond_timedwait expects). This differs from 1003.4a // draft 4. timespec_t relative_time = *timeout - ACE_OS::gettimeofday (); ACE_OSCALL (::pthread_cond_timedwait (cv, external_mutex, &relative_time), int, -1, result); # else ACE_OSCALL (::pthread_cond_timedwait (cv, external_mutex, (ACE_TIMESPEC_PTR) &ts), int, -1, result); # endif /* __Lynx__ */ } # else ACE_OSCALL (ACE_ADAPT_RETVAL (timeout == 0 ? ::pthread_cond_wait (cv, external_mutex) : ::pthread_cond_timedwait (cv, external_mutex, (ACE_TIMESPEC_PTR) &ts), result), int, -1, result); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6*/ // We need to adjust this to make the POSIX and Solaris return // values consistent. EAGAIN is from Pthreads DRAFT4 (HP-UX 10.20 and // down); EINTR is from LynxOS. if (result == -1 && (errno == ETIMEDOUT || errno == EAGAIN || errno == EINTR)) errno = ETIME; # elif defined (ACE_HAS_STHREADS) ACE_OSCALL (ACE_ADAPT_RETVAL (timeout == 0 ? ::cond_wait (cv, external_mutex) : ::cond_timedwait (cv, external_mutex, (timestruc_t*)&ts), result), int, -1, result); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) // pSOS condition value timeout is expressed in ticks. If the // cv_wait times out, the mutex is unlocked upon return. if (timeout == 0) { ACE_OSCALL (ACE_ADAPT_RETVAL (::cv_wait (*cv, *external_mutex, 0), result), int, -1, result); } else { // Need to convert the passed absolute time to relative time // expressed in ticks. ACE_Time_Value relative_time (*timeout - ACE_OS::gettimeofday ()); int ticks = (relative_time.sec () * KC_TICKS2SEC) + (relative_time.usec () * KC_TICKS2SEC / ACE_ONE_SECOND_IN_USECS); if (ticks <= 0) ticks = 1; // Don't wait forever ACE_OSCALL (ACE_ADAPT_RETVAL (::cv_wait (*cv, *external_mutex, ticks), result), int, -1, result); if (result == -1 && errno == 1) { // cv timed out and returned pSOS timeout error 0x01, which // ACE_ADAPT_RETVAL stored in errno. ::mu_lock (*external_mutex, MU_WAIT, 0); errno = ETIME; } } return result; # endif /* ACE_HAS_STHREADS */ if (timeout != 0) timeout->set (ts); // Update the time value before returning. return result; # else ACE_UNUSED_ARG (cv); ACE_UNUSED_ARG (external_mutex); ACE_UNUSED_ARG (timeout); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

int ACE_OS::cond_timedwait_i (  ACE_cond_t *    cv, ACE_mutex_t *    m, ACE_Time_Value *    )  [static, private]

ACE_INLINE int ACE_OS::cond_wait (  ACE_cond_t *    cv, ACE_mutex_t *    m )  [static]

Definition at line 2205 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and cond_wait. Referenced by cond_timedwait, cond_wait, event_wait, recursive_mutex_cond_relock, recursive_mutex_lock, rw_rdlock, rw_trywrlock_upgrade, rw_wrlock, sema_wait, ACE_Condition::wait, ACE_Condition< ACE_Recursive_Thread_Mutex >::wait, and ACE_Condition_Thread_Mutex::wait. { ACE_OS_TRACE ("ACE_OS::cond_wait"); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_cond_wait (cv, external_mutex), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_cond_wait (cv, external_mutex), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_wait (cv, external_mutex), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cv_wait (*cv, *external_mutex, 0), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS */ # else ACE_UNUSED_ARG (cv); ACE_UNUSED_ARG (external_mutex); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::condattr_destroy (  ACE_condattr_t &    attributes )  [static]

Definition at line 2047 of file OS.i. Referenced by cond_init. { #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_condattr_delete (&attributes); # else ::pthread_condattr_destroy (&attributes); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) attributes.type = 0; # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) attributes = 0; # endif /* ACE_HAS_PTHREADS vs. ACE_HAS_STHREADS vs. ACE_PSOS */ return 0; # else ACE_UNUSED_ARG (attributes); return 0; # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::condattr_init (  ACE_condattr_t &    attributes, int    type = ACE_DEFAULT_SYNCH_TYPE )  [static]

Definition at line 1987 of file OS.i. References ACE_ADAPT_RETVAL. Referenced by cond_init. { ACE_UNUSED_ARG (type); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) int result = -1; if ( # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_condattr_create (&attributes) == 0 # elif defined (ACE_HAS_PTHREADS_STD) || defined (ACE_HAS_PTHREADS_DRAFT7) ACE_ADAPT_RETVAL(::pthread_condattr_init (&attributes), result) == 0 # if defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED) && ACE_ADAPT_RETVAL(::pthread_condattr_setpshared(&attributes, type), result) == 0 # endif /* _POSIX_THREAD_PROCESS_SHARED && ! ACE_LACKS_MUTEXATTR_PSHARED */ # else /* this is draft 6 */ ::pthread_condattr_init (&attributes) == 0 # if !defined (ACE_LACKS_CONDATTR_PSHARED) && ::pthread_condattr_setpshared (&attributes, type) == 0 # endif /* ACE_LACKS_CONDATTR_PSHARED */ # if defined (ACE_HAS_PTHREAD_CONDATTR_SETKIND_NP) && ::pthread_condattr_setkind_np (&attributes, type) == 0 # endif /* ACE_HAS_PTHREAD_CONDATTR_SETKIND_NP */ # endif /* ACE_HAS_PTHREADS_DRAFT4 */ ) result = 0; else result = -1; // ACE_ADAPT_RETVAL used it for intermediate status return result; # elif defined (ACE_HAS_STHREADS) attributes.type = type; return 0; # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_COND_T) # if defined (ACE_PSOS_HAS_PRIO_MUTEX) attributes = CV_LOCAL | CV_PRIOR; # else /* ACE_PSOS_HAS_PRIO_MUTEX */ attributes = CV_LOCAL | CV_FIFO; # endif /* ACE_PSOS_HAS_PRIO_MUTEX */ return 0; # else ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (type); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREADS vs. ACE_HAS_STHREADS vs. pSOS */ # else ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (type); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

int ACE_OS::connect (  ACE_HANDLE    handle, const sockaddr *    addr, int    addrlen, const ACE_QoS_Params &    qos_params )  [static]

QoS-enabled <connect>, which passes <qos_params> to <connect>. If the OS platform doesn't support QoS-enabled <connect> then the <qos_params> are ignored and the BSD-style <connect> is called. Definition at line 7651 of file OS.cpp. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, ACE_QoS_Params::callee_data, ACE_QoS_Params::caller_data, connect, ACE_QoS_Params::group_socket_qos, and ACE_QoS_Params::socket_qos. { ACE_OS_TRACE ("ACE_OS::connect"); # if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) ACE_SOCKCALL_RETURN (::WSAConnect ((ACE_SOCKET) handle, (const sockaddr *) addr, (ACE_SOCKET_LEN) addrlen, (WSABUF *) qos_params.caller_data (), (WSABUF *) qos_params.callee_data (), (QOS *) qos_params.socket_qos (), (QOS *) qos_params.group_socket_qos ()), int, -1); # else ACE_UNUSED_ARG (qos_params); return ACE_OS::connect (handle, (sockaddr *) addr, addrlen); # endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::connect (  ACE_HANDLE    handle, struct sockaddr *    addr, int    addrlen )  [static]

BSD-style <connect> (no QoS). Definition at line 4797 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and connect. Referenced by ACE_SOCK_Connector::connect, connect, ACE_ATM_Connector::connect, ACE_WIN32_Asynch_Connect::connect_i, ACE_POSIX_Asynch_Connect::connect_i, and ACE_SOCK_CODgram::open. { ACE_OS_TRACE ("ACE_OS::connect"); #if defined (ACE_PSOS) && !defined (ACE_PSOS_DIAB_PPC) ACE_SOCKCALL_RETURN (::connect ((ACE_SOCKET) handle, (struct sockaddr_in *) addr, (ACE_SOCKET_LEN) addrlen), int, -1); #else /* !defined (ACE_PSOS) || defined (ACE_PSOS_DIAB_PPC) */ ACE_SOCKCALL_RETURN (::connect ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN) addrlen), int, -1); #endif /* defined (ACE_PSOS) && !defined (ACE_PSOS_DIAB_PPC) */ }

ACE_INLINE ACE_HANDLE ACE_OS::creat (  const ACE_TCHAR *    filename, mode_t    mode )  [static]

Definition at line 7717 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, creat, mode_t, and open. Referenced by creat, and ACE_SPIPE_Acceptor::create_new_instance. { ACE_OS_TRACE ("ACE_OS::creat"); #if defined (ACE_WIN32) return ACE_OS::open (filename, O_CREAT|O_TRUNC|O_WRONLY, mode); #elif defined(ACE_PSOS) ACE_OSCALL_RETURN(::create_f((char *)filename, 1024, S_IRUSR | S_IWUSR | S_IXUSR), ACE_HANDLE, ACE_INVALID_HANDLE); #elif defined(ACE_PSOS_TM) ACE_UNUSED_ARG (filename); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (-1); #elif defined(ACE_PSOS) ACE_UNUSED_ARG (filename); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::creat (filename, mode), ACE_HANDLE, ACE_INVALID_HANDLE); #endif /* ACE_WIN32 */ }

ACE_INLINE ACE_TCHAR * ACE_OS::ctime (  const time_t *    t )  [static]

Definition at line 8684 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, asctime, ctime, ctime_buf_size, ctime_r, and localtime. Referenced by ctime, ctime_r, and ACE_Service_Config::reconfigure. { ACE_OS_TRACE ("ACE_OS::ctime"); #if defined (ACE_HAS_BROKEN_CTIME) ACE_OSCALL_RETURN (::asctime (::localtime (t)), char *, 0); #elif defined(ACE_PSOS) && ! defined (ACE_PSOS_HAS_TIME) return "ctime-return"; #elif defined (ACE_HAS_WINCE) static ACE_TCHAR buf [ctime_buf_size]; return ACE_OS::ctime_r (t, buf, ctime_buf_size); #elif defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wctime (t), wchar_t *, 0); #else ACE_OSCALL_RETURN (::ctime (t), char *, 0); # endif /* ACE_HAS_BROKEN_CTIME */ }

ACE_INLINE ACE_TCHAR * ACE_OS::ctime_r (  const time_t *    clock, ACE_TCHAR *    buf, int    buflen )  [static]

Definition at line 8705 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, ctime, ctime_buf_size, ctime_r, and ACE_OS_String::strsncpy. Referenced by ctime, ctime_r, ACE_Log_Record::format_msg, and ACE::timestamp. { ACE_OS_TRACE ("ACE_OS::ctime_r"); #if defined (ACE_HAS_REENTRANT_FUNCTIONS) # if defined (ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R) if (buflen < ctime_buf_size) { errno = ERANGE; return 0; } # if defined (DIGITAL_UNIX) ACE_OSCALL_RETURN (::_Pctime_r (t, buf), ACE_TCHAR *, 0); # else /* DIGITAL_UNIX */ ACE_OSCALL_RETURN (::ctime_r (t, buf), ACE_TCHAR *, 0); # endif /* DIGITAL_UNIX */ return buf; # else /* ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R */ # if defined (ACE_CTIME_R_RETURNS_INT) return (::ctime_r (t, buf, buflen) == -1 ? 0 : buf); # else /* ACE_CTIME_R_RETURNS_INT */ ACE_OSCALL_RETURN (::ctime_r (t, buf, buflen), ACE_TCHAR *, 0); # endif /* ACE_CTIME_R_RETURNS_INT */ # endif /* ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R */ #else /* ACE_HAS_REENTRANT_FUNCTIONS */ # if defined(ACE_PSOS) && ! defined (ACE_PSOS_HAS_TIME) ACE_OS::strsncpy (buf, "ctime-return", buflen); return buf; # else /* ACE_PSOS && !ACE_PSOS_HAS_TIME */ if (buflen < ctime_buf_size) { errno = ERANGE; return 0; } ACE_TCHAR *result; # if defined (ACE_USES_WCHAR) ACE_OSCALL (::_wctime (t), wchar_t *, 0, result); # else /* ACE_USES_WCHAR */ ACE_OSCALL (::ctime (t), char *, 0, result); # endif /* ACE_USES_WCHAR */ if (result != 0) ACE_OS::strsncpy (buf, result, buflen); return buf; # endif /* ACE_PSOS && !ACE_PSOS_HAS_TIME */ #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

wchar_t* ACE_OS::cuserid (  wchar_t *    user, size_t    maxlen = ACE_MAX_USERID )  [static]

ACE_INLINE char * ACE_OS::cuserid (  char *    user, size_t    maxlen = ACE_MAX_USERID )  [static]

Definition at line 883 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, ACE_OS_String::strcpy, and ACE_OS_String::strlen. { ACE_OS_TRACE ("ACE_OS::cuserid"); #if defined (VXWORKS) ACE_UNUSED_ARG (maxlen); if (user == 0) { // Require that the user field be non-null, i.e., don't // allocate or use static storage. ACE_NOTSUP_RETURN (0); } else { ::remCurIdGet (user, 0); return user; } #elif defined (CHORUS) || defined (ACE_PSOS) || defined (__QNXNTO__) ACE_UNUSED_ARG (user); ACE_UNUSED_ARG (maxlen); ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) BOOL result = GetUserNameA (user, (u_long *) &maxlen); if (result == FALSE) ACE_FAIL_RETURN (0); else return user; #elif defined (ACE_HAS_ALT_CUSERID) # if defined (ACE_LACKS_PWD_FUNCTIONS) # error Cannot use alternate cuserid() without POSIX password functions! # endif /* ACE_LACKS_PWD_FUNCTIONS */ // POSIX.1 dropped the cuserid() function. // GNU GLIBC and other platforms correctly deprecate the cuserid() // function. if (maxlen == 0) { // It doesn't make sense to have a zero length user ID. errno = EINVAL; return 0; } struct passwd *pw = 0; // Make sure the file pointer is at the beginning of the password file ::setpwent (); // Should use ACE_OS::setpwent() but I didn't want to move this // method after it. // Use the effective user ID to determine the user name. pw = ::getpwuid (::geteuid ()); // Make sure the password file is closed. ::endpwent (); size_t max_length = 0; char *userid = 0; if (user == 0) { // Not reentrant/thread-safe, but nothing else can be done if a // zero pointer was passed in as the destination. #if defined (_POSIX_SOURCE) const size_t ACE_L_cuserid = L_cuserid; #else const size_t ACE_L_cuserid = 9; // 8 character user ID + NULL #endif /* _POSIX_SOURCE */ static ACE_TCHAR tmp[ACE_L_cuserid] = { '\0' }; max_length = ACE_L_cuserid - 1; // Do not include NULL in length userid = tmp; } else { max_length = maxlen; userid = user; } // Extract the user name from the passwd structure. if (ACE_OS_String::strlen (pw->pw_name) <= max_length) { return ACE_OS_String::strcpy (userid, pw->pw_name); } else { errno = ENOSPC; // Buffer is not large enough. return 0; } #else // Hackish because of missing buffer size! ACE_UNUSED_ARG (maxlen); ACE_OSCALL_RETURN (::ace_cuserid(user), char*, 0); #endif /* VXWORKS */ }

LPSECURITY_ATTRIBUTES ACE_OS::default_win32_security_attributes (  LPSECURITY_ATTRIBUTES    )  [static]

Referenced by event_init, mmap, mutex_init, open, and sema_init.

ACE_INLINE double ACE_OS::difftime (  time_t    t1, time_t    t0 )  [static]

Definition at line 8674 of file OS.i. References ace_difftime. Referenced by ACE_Filecache_Object::update. { return ::ace_difftime (t1, t0); }

ACE_INLINE int ACE_OS::dlclose (  ACE_SHLIB_HANDLE    handle )  [static]

Definition at line 7951 of file OS.i. References ACE_ADAPT_RETVAL, ACE_LIB_TEXT, ACE_OS_TRACE, ACE_SHLIB_HANDLE, dlclose, and dlsym. Referenced by ACE_DLL_Handle::close, and dlclose. { ACE_OS_TRACE ("ACE_OS::dlclose"); #if defined (ACE_LACKS_DLCLOSE) ACE_UNUSED_ARG (handle); return 0; #elif defined (ACE_HAS_SVR4_DYNAMIC_LINKING) # if !defined (ACE_HAS_AUTOMATIC_INIT_FINI) // SunOS4 does not automatically call _fini()! void *ptr; ACE_OSCALL (::dlsym (handle, ACE_LIB_TEXT ("_fini")), void *, 0, ptr); if (ptr != 0) (*((int (*)(void)) ptr)) (); // Call _fini hook explicitly. # endif /* ACE_HAS_AUTOMATIC_INIT_FINI */ #if defined (_M_UNIX) ACE_OSCALL_RETURN (::_dlclose (handle), int, -1); #else /* _MUNIX */ ACE_OSCALL_RETURN (::dlclose (handle), int, -1); #endif /* _M_UNIX */ #elif defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FreeLibrary (handle), ace_result_), int, -1); #elif defined (__hpux) // HP-UX 10.x and 32-bit 11.00 do not pay attention to the ref count // when unloading a dynamic lib. So, if the ref count is more than // 1, do not unload the lib. This will cause a library loaded more // than once to not be unloaded until the process runs down, but // that's life. It's better than unloading a library that's in use. // So far as I know, there's no way to decrement the refcnt that the // kernel is looking at - the shl_descriptor is a copy of what the // kernel has, not the actual struct. On 64-bit HP-UX using dlopen, // this problem has been fixed. struct shl_descriptor desc; if (shl_gethandle_r (handle, &desc) == -1) return -1; if (desc.ref_count > 1) return 0; # if defined(__GNUC__) || __cplusplus >= 199707L ACE_OSCALL_RETURN (::shl_unload (handle), int, -1); # else ACE_OSCALL_RETURN (::cxxshl_unload (handle), int, -1); # endif /* aC++ vs. Hp C++ */ #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */ }

ACE_INLINE ACE_TCHAR * ACE_OS::dlerror (  void    )  [static]

Definition at line 8002 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, sprintf, and ACE_OS_String::strerror. Referenced by ACE_DLL_Handle::error. { ACE_OS_TRACE ("ACE_OS::dlerror"); # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) #if defined(_M_UNIX) ACE_OSCALL_RETURN ((char *)::_dlerror (), char *, 0); #else /* _M_UNIX */ ACE_OSCALL_RETURN ((char *)::dlerror (), char *, 0); #endif /* _M_UNIX */ # elif defined (__hpux) ACE_OSCALL_RETURN (::strerror(errno), char *, 0); # elif defined (ACE_WIN32) static ACE_TCHAR buf[128]; # if defined (ACE_HAS_PHARLAP) ACE_OS::sprintf (buf, "error code %d", GetLastError()); # else ACE_TEXT_FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, 0, ::GetLastError (), 0, buf, sizeof buf / sizeof buf[0], 0); # endif /* ACE_HAS_PHARLAP */ return buf; # else ACE_NOTSUP_RETURN (0); # endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */ }

ACE_INLINE ACE_SHLIB_HANDLE ACE_OS::dlopen (  const ACE_TCHAR *    filename, int    mode = ACE_DEFAULT_SHLIB_MODE )  [static]

Definition at line 8033 of file OS.i. References ACE_DL_TYPE, ACE_LIB_TEXT, ACE_OS_TRACE, ACE_SHLIB_HANDLE, ACE_TCHAR, dlopen, and dlsym. Referenced by dlopen, ACE_DLL_Strategy::make_svc_handler, and ACE_DLL_Handle::open. { ACE_OS_TRACE ("ACE_OS::dlopen"); // Get the correct OS type. ACE_DL_TYPE filename = ACE_const_cast (ACE_DL_TYPE, fname); # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) void *handle; # if defined (ACE_HAS_SGIDLADD) ACE_OSCALL (::sgidladd (filename, mode), void *, 0, handle); # elif defined (_M_UNIX) ACE_OSCALL (::_dlopen (filename, mode), void *, 0, handle); # else ACE_OSCALL (::dlopen (filename, mode), void *, 0, handle); # endif /* ACE_HAS_SGIDLADD */ # if !defined (ACE_HAS_AUTOMATIC_INIT_FINI) if (handle != 0) { void *ptr; // Some systems (e.g., SunOS4) do not automatically call _init(), so // we'll have to call it manually. ACE_OSCALL (::dlsym (handle, ACE_LIB_TEXT ("_init")), void *, 0, ptr); if (ptr != 0 && (*((int (*)(void)) ptr)) () == -1) // Call _init hook explicitly. { // Close down the handle to prevent leaks. ::dlclose (handle); return 0; } } # endif /* ACE_HAS_AUTOMATIC_INIT_FINI */ return handle; # elif defined (ACE_WIN32) ACE_UNUSED_ARG (mode); ACE_WIN32CALL_RETURN (ACE_TEXT_LoadLibrary (filename), ACE_SHLIB_HANDLE, 0); # elif defined (__hpux) # if defined(__GNUC__) || __cplusplus >= 199707L ACE_OSCALL_RETURN (::shl_load(filename, mode, 0L), ACE_SHLIB_HANDLE, 0); # else ACE_OSCALL_RETURN (::cxxshl_load(filename, mode, 0L), ACE_SHLIB_HANDLE, 0); # endif /* aC++ vs. Hp C++ */ # else ACE_UNUSED_ARG (filename); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (0); # endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */ }

ACE_INLINE void * ACE_OS::dlsym (  ACE_SHLIB_HANDLE    handle, const ACE_TCHAR *    symbol )  [static]

Definition at line 8088 of file OS.i. References ACE_NEW_RETURN, ACE_OS_TRACE, ACE_SHLIB_HANDLE, ACE_SHLIB_INVALID_HANDLE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, dlsym, ACE_OS_String::strcpy, and ACE_OS_String::strlen. Referenced by dlclose, dlopen, dlsym, ACE_DLL_Strategy::make_svc_handler, and ACE_DLL_Handle::symbol. { ACE_OS_TRACE ("ACE_OS::dlsym"); #if defined (ACE_HAS_DLSYM_SEGFAULT_ON_INVALID_HANDLE) // Check if the handle is valid before making any calls using it. if (handle == ACE_SHLIB_INVALID_HANDLE) return 0; #endif /* ACE_HAS_DLSYM_SEGFAULT_ON_INVALID_HANDLE */ // Get the correct OS type. #if defined (ACE_HAS_WINCE) const wchar_t *symbolname = sname; #elif defined (ACE_HAS_CHARPTR_DL) char *symbolname = ACE_const_cast (char *, sname); #elif !defined (ACE_WIN32) || !defined (ACE_USES_WCHAR) const char *symbolname = sname; #endif /* ACE_HAS_CHARPTR_DL */ # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) # if defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::dlsym (handle, symbolname), void *, 0); # elif defined (ACE_USES_ASM_SYMBOL_IN_DLSYM) int l = ACE_OS::strlen (symbolname) + 2; char *asm_symbolname = 0; ACE_NEW_RETURN (asm_symbolname, char[l], 0); ACE_OS::strcpy (asm_symbolname, "_") ; ACE_OS::strcpy (asm_symbolname + 1, symbolname) ; void *ace_result; ACE_OSCALL (::dlsym (handle, asm_symbolname), void *, 0, ace_result); delete [] asm_symbolname; return ace_result; # elif defined (_M_UNIX) ACE_OSCALL_RETURN (::_dlsym (handle, symbolname), void *, 0); # else ACE_OSCALL_RETURN (::dlsym (handle, symbolname), void *, 0); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ # elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) && !defined (ACE_HAS_WINCE) ACE_WIN32CALL_RETURN (::GetProcAddress (handle, ACE_TEXT_ALWAYS_CHAR (sname)), void *, 0); # elif defined (ACE_WIN32) ACE_WIN32CALL_RETURN (::GetProcAddress (handle, symbolname), void *, 0); # elif defined (__hpux) void *value; int status; shl_t _handle = handle; ACE_OSCALL (::shl_findsym(&_handle, symbolname, TYPE_UNDEFINED, &value), int, -1, status); return status == 0 ? value : 0; # else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (symbolname); ACE_NOTSUP_RETURN (0); # endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */ }

ACE_INLINE ACE_HANDLE ACE_OS::dup (  ACE_HANDLE    handle )  [static]

Definition at line 9474 of file OS.i. References ACE_OS_TRACE, and dup. Referenced by dup, ACE_Filecache_Handle::handle, and ACE_Process_Options::set_handles. { ACE_OS_TRACE ("ACE_OS::dup"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_HANDLE new_fd; if (::DuplicateHandle(::GetCurrentProcess (), handle, ::GetCurrentProcess(), &new_fd, 0, TRUE, DUPLICATE_SAME_ACCESS)) return new_fd; else ACE_FAIL_RETURN (ACE_INVALID_HANDLE); /* NOTREACHED */ #elif defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (0); #else ACE_OSCALL_RETURN (::dup (handle), ACE_HANDLE, ACE_INVALID_HANDLE); #endif /* ACE_WIN32 && !ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::dup2 (  ACE_HANDLE    oldfd, ACE_HANDLE    newfd )  [static]

Definition at line 9502 of file OS.i. References ACE_OS_TRACE, and dup2. Referenced by dup2, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::dup2"); #if defined (ACE_WIN32) || defined (VXWORKS) || defined (ACE_PSOS) // msvcrt has _dup2 ?! ACE_UNUSED_ARG (oldhandle); ACE_UNUSED_ARG (newhandle); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::dup2 (oldhandle, newhandle), int, -1); #endif /* ACE_WIN32 || VXWORKS || ACE_PSOS */ }

ACE_INLINE void ACE_OS::endpwent (  void    )  [static]

Definition at line 5819 of file OS.i. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) # if !defined (ACE_WIN32) ::endpwent (); # else # endif /* ACE_WIN32 */ #else #endif /* ! ACE_LACKS_PWD_FUNCTIONS */ }

ACE_INLINE int ACE_OS::enum_protocols (  int *    protocols, ACE_Protocol_Info *    protocol_buffer, u_long *    buffer_length )  [static]

Retrieve information about available transport protocols installed on the local machine. Definition at line 4759 of file OS.i. References ACE_SOCKCALL_RETURN. { #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) ACE_SOCKCALL_RETURN (::WSAEnumProtocols (protocols, protocol_buffer, buffer_length), int, SOCKET_ERROR); #else ACE_UNUSED_ARG (protocols); ACE_UNUSED_ARG (protocol_buffer); ACE_UNUSED_ARG (buffer_length); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::event_destroy (  ACE_event_t *    event )  [static]

Definition at line 4340 of file OS.i. References ACE_ADAPT_RETVAL, cond_destroy, and mutex_destroy. Referenced by ACE_WFMO_Reactor_Handler_Repository::make_changes_in_current_infos, ACE_WFMO_Reactor_Handler_Repository::make_changes_in_suspension_infos, ACE_WFMO_Reactor_Handler_Repository::make_changes_in_to_be_added_infos, ACE_Event::remove, sema_destroy, and sema_init. { #if defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (*event), ace_result_), int, -1); #elif defined (ACE_HAS_THREADS) int r1 = ACE_OS::mutex_destroy (&event->lock_); int r2 = ACE_OS::cond_destroy (&event->condition_); return r1 != 0 || r2 != 0 ? -1 : 0; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

int ACE_OS::event_init (  ACE_event_t *    event, int    manual_reset, int    initial_state, int    type, const wchar_t *    name, void *    arg = 0, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

ACE_INLINE int ACE_OS::event_init (  ACE_event_t *    event, int    manual_reset = 0, int    initial_state = 0, int    type = ACE_DEFAULT_SYNCH_TYPE, const char *    name = 0, void *    arg = 0, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

Definition at line 4251 of file OS.i. References cond_init, default_win32_security_attributes, and mutex_init. Referenced by ACE_Event::ACE_Event, and sema_init. { #if defined (ACE_WIN32) ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (arg); # if defined (ACE_HAS_WINCE) // @@todo (brunsch) This idea should be moved into ACE_OS_Win32. *event = ::CreateEventW (ACE_OS::default_win32_security_attributes(sa), manual_reset, initial_state, ACE_Ascii_To_Wide (name).wchar_rep ()); # else /* ACE_HAS_WINCE */ *event = ::CreateEventA (ACE_OS::default_win32_security_attributes(sa), manual_reset, initial_state, name); # endif /* ACE_HAS_WINCE */ if (*event == 0) ACE_FAIL_RETURN (-1); else return 0; #elif defined (ACE_HAS_THREADS) ACE_UNUSED_ARG (sa); event->manual_reset_ = manual_reset; event->is_signaled_ = initial_state; event->waiting_threads_ = 0; int result = ACE_OS::cond_init (&event->condition_, ACE_static_cast (short, type), name, arg); if (result == 0) result = ACE_OS::mutex_init (&event->lock_, type, name, (ACE_mutexattr_t *) arg); return result; #else ACE_UNUSED_ARG (event); ACE_UNUSED_ARG (manual_reset); ACE_UNUSED_ARG (initial_state); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_UNUSED_ARG (sa); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::event_pulse (  ACE_event_t *    event )  [static]

Definition at line 4577 of file OS.i. References ACE_ADAPT_RETVAL, cond_broadcast, cond_signal, mutex_lock, and mutex_unlock. Referenced by ACE_Event::pulse. { #if defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::PulseEvent (*event), ace_result_), int, -1); #elif defined (ACE_HAS_THREADS) int result = 0; int error = 0; // grab the lock first if (ACE_OS::mutex_lock (&event->lock_) == 0) { // Manual-reset event. if (event->manual_reset_ == 1) { // Wakeup all waiters. if (ACE_OS::cond_broadcast (&event->condition_) != 0) { result = -1; error = errno; } } // Auto-reset event: wakeup one waiter. else if (ACE_OS::cond_signal (&event->condition_) != 0) { result = -1; error = errno; } // Reset event. event->is_signaled_ = 0; // Now we can let go of the lock. ACE_OS::mutex_unlock (&event->lock_); if (result == -1) // Reset errno in case mutex_unlock() also fails... errno = error; } else result = -1; return result; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::event_reset (  ACE_event_t *    event )  [static]

Definition at line 4625 of file OS.i. References ACE_ADAPT_RETVAL, mutex_lock, and mutex_unlock. Referenced by ACE_Event::reset, sema_trywait, and sema_wait. { #if defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ResetEvent (*event), ace_result_), int, -1); #elif defined (ACE_HAS_THREADS) int result = 0; // Grab the lock first. if (ACE_OS::mutex_lock (&event->lock_) == 0) { // Reset event. event->is_signaled_ = 0; // Now we can let go of the lock. ACE_OS::mutex_unlock (&event->lock_); } else result = -1; return result; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::event_signal (  ACE_event_t *    event )  [static]

Definition at line 4522 of file OS.i. References ACE_ADAPT_RETVAL, cond_broadcast, cond_signal, mutex_lock, and mutex_unlock. Referenced by ACE_WIN32_Proactor::post_completion, sema_post, and ACE_Event::signal. { #if defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEvent (*event), ace_result_), int, -1); #elif defined (ACE_HAS_THREADS) int result = 0; int error = 0; // grab the lock first if (ACE_OS::mutex_lock (&event->lock_) == 0) { // Manual-reset event. if (event->manual_reset_ == 1) { // signal event event->is_signaled_ = 1; // wakeup all if (ACE_OS::cond_broadcast (&event->condition_) != 0) { result = -1; error = errno; } } // Auto-reset event else { if (event->waiting_threads_ == 0) // No waiters: signal event. event->is_signaled_ = 1; // Waiters: wakeup one waiter. else if (ACE_OS::cond_signal (&event->condition_) != 0) { result = -1; error = errno; } } // Now we can let go of the lock. ACE_OS::mutex_unlock (&event->lock_); if (result == -1) // Reset errno in case mutex_unlock() also fails... errno = error; } else result = -1; return result; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::event_timedwait (  ACE_event_t *    event, ACE_Time_Value *    timeout, int    use_absolute_time = 1 )  [static]

Definition at line 4413 of file OS.i. References cond_timedwait, ETIME, gettimeofday, ACE_Time_Value::msec, mutex_lock, mutex_unlock, ACE_Time_Value::sec, set_errno_to_last_error, ACE_Time_Value::usec, and ACE_Time_Value::zero. Referenced by ACE_Event::wait. { #if defined (ACE_WIN32) DWORD result; if (timeout == 0) // Wait forever result = ::WaitForSingleObject (*event, INFINITE); else if (timeout->sec () == 0 && timeout->usec () == 0) // Do a "poll". result = ::WaitForSingleObject (*event, 0); else { // Wait for upto <relative_time> number of milliseconds. Note // that we must convert between absolute time (which is passed // as a parameter) and relative time (which is what // WaitForSingleObjects() expects). // <timeout> parameter is given in absolute or relative value // depending on parameter <use_absolute_time>. int msec_timeout; if (use_absolute_time) { // Time is given in absolute time, we should use // gettimeofday() to calculate relative time ACE_Time_Value relative_time (*timeout - ACE_OS::gettimeofday ()); // Watchout for situations where a context switch has caused // the current time to be > the timeout. Thanks to Norbert // Rapp <NRapp@nexus-informatics.de> for pointing this. if (relative_time < ACE_Time_Value::zero) msec_timeout = 0; else msec_timeout = relative_time.msec (); } else // time is given in relative time, just convert it into // milliseconds and use it msec_timeout = timeout->msec (); result = ::WaitForSingleObject (*event, msec_timeout); } switch (result) { case WAIT_OBJECT_0: return 0; case WAIT_TIMEOUT: errno = ETIME; return -1; default: // This is a hack, we need to find an appropriate mapping... ACE_OS::set_errno_to_last_error (); return -1; } #elif defined (ACE_HAS_THREADS) int result = 0; int error = 0; // grab the lock first if (ACE_OS::mutex_lock (&event->lock_) == 0) { if (event->is_signaled_ == 1) // event is currently signaled { if (event->manual_reset_ == 0) // AUTO: reset state event->is_signaled_ = 0; } else // event is currently not signaled { event->waiting_threads_++; // cond_timewait() expects absolute time, check // <use_absolute_time> flag. if (use_absolute_time == 0 && timeout != 0) *timeout += ACE_OS::gettimeofday (); if (ACE_OS::cond_timedwait (&event->condition_, &event->lock_, timeout) != 0) { result = -1; error = errno; } event->waiting_threads_--; } // Now we can let go of the lock. ACE_OS::mutex_unlock (&event->lock_); if (result == -1) // Reset errno in case mutex_unlock() also fails... errno = error; } else result = -1; return result; #else ACE_UNUSED_ARG (event); ACE_UNUSED_ARG (timeout); ACE_UNUSED_ARG (use_absolute_time); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::event_wait (  ACE_event_t *    event )  [static]

Definition at line 4355 of file OS.i. References cond_wait, mutex_lock, mutex_unlock, and set_errno_to_last_error. Referenced by ACE_Event::wait. { #if defined (ACE_WIN32) switch (::WaitForSingleObject (*event, INFINITE)) { case WAIT_OBJECT_0: return 0; default: ACE_OS::set_errno_to_last_error (); return -1; } #elif defined (ACE_HAS_THREADS) int result = 0; int error = 0; // grab the lock first if (ACE_OS::mutex_lock (&event->lock_) == 0) { if (event->is_signaled_ == 1) // Event is currently signaled. { if (event->manual_reset_ == 0) // AUTO: reset state event->is_signaled_ = 0; } else // event is currently not signaled { event->waiting_threads_++; if (ACE_OS::cond_wait (&event->condition_, &event->lock_) != 0) { result = -1; error = errno; // Something went wrong... } event->waiting_threads_--; } // Now we can let go of the lock. ACE_OS::mutex_unlock (&event->lock_); if (result == -1) // Reset errno in case mutex_unlock() also fails... errno = error; } else result = -1; return result; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

int ACE_OS::execl (  const char *    path, const char *    arg0, ...    )  [static]

Definition at line 1230 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::execl"); #if defined (ACE_WIN32) || defined (VXWORKS) ACE_NOTSUP_RETURN (-1); #else ACE_NOTSUP_RETURN (-1); // Need to write this code. // ACE_OSCALL_RETURN (::execv (path, argv), int, -1); #endif /* ACE_WIN32 */ }

int ACE_OS::execle (  const char *    path, const char *    arg0, ...    )  [static]

Definition at line 1243 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::execle"); #if defined (ACE_WIN32) || defined (VXWORKS) ACE_NOTSUP_RETURN (-1); #else ACE_NOTSUP_RETURN (-1); // Need to write this code. // ACE_OSCALL_RETURN (::execve (path, argv, envp), int, -1); #endif /* ACE_WIN32 */ }

int ACE_OS::execlp (  const char *    file, const char *    arg0, ...    )  [static]

Definition at line 1256 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::execlp"); #if defined (ACE_WIN32) || defined (VXWORKS) ACE_NOTSUP_RETURN (-1); #else ACE_NOTSUP_RETURN (-1); // Need to write this code. // ACE_OSCALL_RETURN (::execvp (file, argv), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::execv (  const char *    path, char *const    argv[] )  [static]

Definition at line 9272 of file OS.i. References ACE_OS_TRACE, and execv. Referenced by execv, and fork_exec. { ACE_OS_TRACE ("ACE_OS::execv"); #if defined (ACE_LACKS_EXEC) ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (argv); ACE_NOTSUP_RETURN (-1); #elif defined (CHORUS) KnCap cactorcap; int result = ::afexecv (path, &cactorcap, 0, argv); if (result != -1) ACE_OS::actorcaps_[result] = cactorcap; return result; #elif defined (ACE_WIN32) # if defined (__BORLANDC__) /* VSB */ return ::execv (path, argv); # elif defined (__MINGW32__) return ::_execv (path, (char *const *) argv); # else return ::_execv (path, (const char *const *) argv); # endif /* __BORLANDC__ */ #elif defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::execv (path, (const char **) argv), int, -1); #else ACE_OSCALL_RETURN (::execv (path, argv), int, -1); #endif /* ACE_LACKS_EXEC */ }

ACE_INLINE int ACE_OS::execve (  const char *    path, char *const    argv[], char *const    envp[] )  [static]

Definition at line 9303 of file OS.i. References ACE_OS_TRACE, and execve. Referenced by execve, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::execve"); #if defined (ACE_LACKS_EXEC) ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (argv); ACE_UNUSED_ARG (envp); ACE_NOTSUP_RETURN (-1); #elif defined(CHORUS) KnCap cactorcap; int result = ::afexecve (path, &cactorcap, 0, argv, envp); if (result != -1) ACE_OS::actorcaps_[result] = cactorcap; return result; #elif defined (ACE_WIN32) # if defined (__BORLANDC__) /* VSB */ return ::execve (path, argv, envp); # elif defined (__MINGW32__) return ::_execve (path, (char *const *) argv, (char *const *) envp); # else return ::_execve (path, (const char *const *) argv, (const char *const *) envp); # endif /* __BORLANDC__ */ #elif defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::execve (path, (const char **) argv, (char **) envp), int, -1); #else ACE_OSCALL_RETURN (::execve (path, argv, envp), int, -1); #endif /* ACE_LACKS_EXEC */ }

ACE_INLINE int ACE_OS::execvp (  const char *    file, char *const    argv[] )  [static]

Definition at line 9336 of file OS.i. References ACE_OS_TRACE, and execvp. Referenced by execvp, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::execvp"); #if defined (ACE_LACKS_EXEC) ACE_UNUSED_ARG (file); ACE_UNUSED_ARG (argv); ACE_NOTSUP_RETURN (-1); #elif defined(CHORUS) KnCap cactorcap; int result = ::afexecvp (file, &cactorcap, 0, argv); if (result != -1) ACE_OS::actorcaps_[result] = cactorcap; return result; #elif defined (ACE_WIN32) # if defined (__BORLANDC__) /* VSB */ return ::execvp (file, argv); # elif defined (__MINGW32__) return ::_execvp (file, (char *const *) argv); # else return ::_execvp (file, (const char *const *) argv); # endif /* __BORLANDC__ */ #elif defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::execvp (file, (const char **) argv), int, -1); #else ACE_OSCALL_RETURN (::execvp (file, argv), int, -1); #endif /* ACE_LACKS_EXEC */ }

void ACE_OS::exit (  int    status = 0 )  [static]

Definition at line 6286 of file OS.cpp. References ACE_OS_TRACE. Referenced by abort, ACE::daemonize, fork_exec, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::exit"); #if defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER) && !defined (ACE_HAS_WINCE) && !defined (ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER) // Shut down the ACE_Object_Manager, if it had registered its exit_hook. // With ACE_HAS_NONSTATIC_OBJECT_MANAGER, the ACE_Object_Manager is // instantiated on the main's stack. ::exit () doesn't destroy it. if (exit_hook_) (*exit_hook_) (); #endif /* ACE_HAS_NONSTATIC_OBJECT_MANAGER && !ACE_HAS_WINCE && !ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER */ #if !defined (ACE_HAS_WINCE) # if defined (ACE_WIN32) ::ExitProcess ((UINT) status); # elif defined (ACE_PSOSIM) ::u_exit (status); # else ::exit (status); # endif /* ACE_WIN32 */ #else // @@ This is not exactly the same as ExitProcess. But this is the // closest one I can get. ::TerminateProcess (::GetCurrentProcess (), status); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::fattach (  int    handle, const char *    path )  [static]

Definition at line 9676 of file OS.i. References ACE_OS_TRACE, and fattach. Referenced by ACE_SPIPE_Acceptor::create_new_instance, and fattach. { ACE_OS_TRACE ("ACE_OS::fattach"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::fattach (handle, path), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (path); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_STREAM_PIPES */ }

ACE_INLINE int ACE_OS::fclose (  FILE *    fp )  [static]

Definition at line 5666 of file OS.i. References ACE_OS_TRACE, and fclose. Referenced by access, ACE_Ini_ImpExp::export_config, ACE_Registry_ImpExp::export_config, fclose, ACE_Capabilities::getent, ACE_Logging_Strategy::handle_timeout, ACE_Ini_ImpExp::import_config, ACE_Registry_ImpExp::import_config, ACE_Service_Config::process_file, ACE_Log_Msg::~ACE_Log_Msg, and ACE_Read_Buffer::~ACE_Read_Buffer. { ACE_OS_TRACE ("ACE_OS::fclose"); ACE_OSCALL_RETURN (::fclose (fp), int, -1); }

ACE_INLINE int ACE_OS::fcntl (  ACE_HANDLE    handle, int    cmd, long    arg = 0 )  [static]

Definition at line 144 of file OS.i. References ACE_OS_TRACE, and fcntl. Referenced by ACE_Flag_Manip::clr_flags, ACE_IPC_SAP::disable, ACE_IO_SAP::disable, ACE_IPC_SAP::enable, ACE_IO_SAP::enable, fcntl, flock_rdlock, flock_tryrdlock, flock_trywrlock, flock_unlock, flock_wrlock, ACE_Flag_Manip::get_flags, ACE_Select_Reactor_Notify::open, ACE_Dev_Poll_Reactor_Notify::open, and ACE_Flag_Manip::set_flags. { ACE_OS_TRACE ("ACE_OS::fcntl"); # if defined (ACE_LACKS_FCNTL) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (arg); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::fcntl (handle, cmd, arg), int, -1); # endif /* ACE_LACKS_FCNTL */ }

ACE_INLINE int ACE_OS::fdetach (  const char *    file )  [static]

Definition at line 9663 of file OS.i. References ACE_OS_TRACE, and fdetach. Referenced by ACE_SPIPE_Acceptor::close, and fdetach. { ACE_OS_TRACE ("ACE_OS::fdetach"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::fdetach (file), int, -1); #else ACE_UNUSED_ARG (file); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_STREAM_PIPES */ }

ACE_INLINE FILE * ACE_OS::fdopen (  ACE_HANDLE    handle, const ACE_TCHAR *    mode )  [static]

Definition at line 9367 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and fdopen. Referenced by fdopen. { ACE_OS_TRACE ("ACE_OS::fdopen"); # if defined (ACE_HAS_WINCE) ACE_OSCALL_RETURN (::_wfdopen (handle, mode), FILE*, 0); # elif defined (ACE_WIN32) // kernel file handle -> FILE* conversion... // Options: _O_APPEND, _O_RDONLY and _O_TEXT are lost FILE *file = 0; # if defined (ACE_WIN64) int crt_handle = ::_open_osfhandle (intptr_t (handle), 0); # else int crt_handle = ::_open_osfhandle (long (handle), 0); # endif /* ACE_WIN64 */ if (crt_handle != -1) { # if defined(__BORLANDC__) /* VSB */ file = ::_fdopen (crt_handle, (char *) mode); # elif defined (ACE_USES_WCHAR) file = ::_wfdopen (crt_handle, mode); # else file = ::_fdopen (crt_handle, mode); # endif /* __BORLANDC__ */ if (!file) { # if (defined(__BORLANDC__) && __BORLANDC__ >= 0x0530) ::_rtl_close (crt_handle); # else ::_close (crt_handle); # endif /* (defined(__BORLANDC__) && __BORLANDC__ >= 0x0530) */ } } return file; # elif defined (ACE_PSOS) // @@ it may be possible to implement this for pSOS, // but it isn't obvious how to do this (perhaps via // f_stat to glean the default volume, and then open_fn ?) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (0); # else ACE_OSCALL_RETURN (::fdopen (handle, mode), FILE *, 0); # endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::fflush (  FILE *    fp )  [static]

Definition at line 5711 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and fflush. Referenced by fflush, and ACE_Log_Record::print. { #if !defined (ACE_HAS_WINCE) ACE_OS_TRACE ("ACE_OS::fflush"); #if defined (VXWORKS) if (fp == 0) { // Do not allow fflush(0) on VxWorks return 0; } #endif /* VXWORKS */ ACE_OSCALL_RETURN (::fflush (fp), int, -1); #else ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL(::FlushFileBuffers (fp), ace_result_), int, -1); #endif /* !ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::fgetc (  FILE *    fp )  [static]

Definition at line 9966 of file OS.i. References fgetc. Referenced by fgetc. { ACE_OSCALL_RETURN (::fgetc (fp), int, -1); }

ACE_INLINE int ACE_OS::fgetpos (  FILE *    fp, fpos_t *    pos )  [static]

Definition at line 9954 of file OS.i. References fgetpos. Referenced by fgetpos. { ACE_OSCALL_RETURN (::fgetpos (fp, pos), int, -1); }

ACE_INLINE ACE_TCHAR * ACE_OS::fgets (  ACE_TCHAR *    buf, int    size, FILE *    fp )  [static]

Definition at line 5673 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and fgets. Referenced by fgets, ACE_Ini_ImpExp::import_config, and ACE_Registry_ImpExp::import_config. { ACE_OS_TRACE ("ACE_OS::fgets"); #if defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (size); ACE_UNUSED_ARG (fp); ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::fgetws (buf, size, fp), wchar_t *, 0); #else /* ACE_WIN32 */ ACE_OSCALL_RETURN (::fgets (buf, size, fp), char *, 0); #endif /* ACE_HAS_WINCE */ }

wint_t ACE_OS::fgetwc (  FILE *    fp )  [static]

ACE_INLINE long ACE_OS::filesize (  const ACE_TCHAR *    handle )  [static]

Definition at line 7652 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, close, filesize, and open. { ACE_OS_TRACE ("ACE_OS::filesize"); ACE_HANDLE h = ACE_OS::open (filename, O_RDONLY); if (h != ACE_INVALID_HANDLE) { long size = ACE_OS::filesize (h); ACE_OS::close (h); return size; } else return -1; }

ACE_INLINE long ACE_OS::filesize (  ACE_HANDLE    handle )  [static]

Definition at line 2852 of file OS.i. References ACE_OS_TRACE, fstat, and stat. Referenced by ACE_POSIX_Asynch_Transmit_Handler::ACE_POSIX_Asynch_Transmit_Handler, filesize, ACE_MMAP_Memory_Pool::handle_signal, ACE_Mem_Map::map_it, mmap, ACE_FILE_IO::recvv, ACE_MMAP_Memory_Pool::remap, ACE_POSIX_Asynch_Transmit_File::transmit_file, and ACE_Mem_Map::unmap. { ACE_OS_TRACE ("ACE_OS::filesize"); #if defined (ACE_WIN32) ACE_WIN32CALL_RETURN (::GetFileSize (handle, 0), long, -1); #else /* !ACE_WIN32 */ struct stat sb; return ACE_OS::fstat (handle, &sb) == -1 ? -1 : (long) sb.st_size; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::flock_destroy (  ACE_OS::ace_flock_t *    lock, int    unlink_file = 1 )  [static]

Definition at line 9228 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, close, flock_unlock, ACE_OS_Memory::free, ACE_OS::ace_flock_t::handle_, ACE_OS::ace_flock_t::lockname_, munmap, mutex_destroy, shm_unlink, and unlink. Referenced by ACE_File_Lock::remove. { ACE_OS_TRACE ("ACE_OS::flock_destroy"); if (lock->handle_ != ACE_INVALID_HANDLE) { ACE_OS::flock_unlock (lock); // Close the handle. ACE_OS::close (lock->handle_); lock->handle_ = ACE_INVALID_HANDLE; #if defined (CHORUS) // Are we the owner? if (lock->process_lock_ && lock->lockname_ != 0) { // Only destroy the lock if we're the owner ACE_OS::mutex_destroy (lock->process_lock_); ACE_OS::munmap (lock->process_lock_, sizeof (ACE_mutex_t)); if (unlink_file) ACE_OS::shm_unlink (lock->lockname_); ACE_OS::free (ACE_static_cast (void *, ACE_const_cast (ACE_TCHAR *, lock->lockname_))); } else if (lock->process_lock_) // Just unmap the memory. ACE_OS::munmap (lock->process_lock_, sizeof (ACE_mutex_t)); #else if (lock->lockname_ != 0) { if (unlink_file) ACE_OS::unlink (lock->lockname_); ACE_OS::free (ACE_static_cast (void *, ACE_const_cast (ACE_TCHAR *, lock->lockname_))); } #endif /* CHORUS */ lock->lockname_ = 0; } return 0; }

ACE_INLINE int ACE_OS::flock_init (  ACE_OS::ace_flock_t *    lock, int    flags = 0, const ACE_TCHAR *    name = 0, mode_t    perms = 0 )  [static]

Definition at line 8875 of file OS.i. References ACE_ALLOCATOR_RETURN, ACE_DEFAULT_FILE_PERMS, ACE_OS_TRACE, ACE_TCHAR, ftruncate, ACE_OS::ace_flock_t::handle_, ACE_OS::ace_flock_t::lockname_, MAP_FAILED, MAP_SHARED, mmap, mode_t, mutex_init, open, ACE_OS::ace_flock_t::overlapped_, PROT_RDWR, shm_open, and ACE_OS_String::strdup. Referenced by ACE_File_Lock::ACE_File_Lock, and ACE_File_Lock::open. { ACE_OS_TRACE ("ACE_OS::flock_init"); #if defined (CHORUS) lock->lockname_ = 0; // Let's see if it already exists. lock->handle_ = ACE_OS::shm_open (name, flags | O_CREAT | O_EXCL, perms); if (lock->handle_ == ACE_INVALID_HANDLE) { if (errno == EEXIST) // It's already there, so we'll just open it. lock->handle_ = ACE_OS::shm_open (name, flags | O_CREAT, ACE_DEFAULT_FILE_PERMS); else return -1; } else { // We own this shared memory object! Let's set its size. if (ACE_OS::ftruncate (lock->handle_, sizeof (ACE_mutex_t)) == -1) return -1; // Note that only the owner can destroy a file lock... ACE_ALLOCATOR_RETURN (lock->lockname_, ACE_OS::strdup (name), -1); } if (lock->handle_ == ACE_INVALID_HANDLE) return -1; lock->process_lock_ = (ACE_mutex_t *) ACE_OS::mmap (0, sizeof (ACE_mutex_t), PROT_RDWR, MAP_SHARED, lock->handle_, 0); if (lock->process_lock_ == MAP_FAILED) return -1; if (lock->lockname_ // Only initialize it if we're the one who created it. && ACE_OS::mutex_init (lock->process_lock_, USYNC_PROCESS, name, 0) != 0) return -1; return 0; #else #if defined (ACE_WIN32) // Once initialized, these values are never changed. lock->overlapped_.Internal = 0; lock->overlapped_.InternalHigh = 0; lock->overlapped_.OffsetHigh = 0; lock->overlapped_.hEvent = 0; #endif /* ACE_WIN32 */ lock->handle_ = ACE_INVALID_HANDLE; lock->lockname_ = 0; if (name != 0) { ACE_OSCALL (ACE_OS::open (name, flags, perms), ACE_HANDLE, ACE_INVALID_HANDLE, lock->handle_); lock->lockname_ = ACE_OS::strdup (name); return lock->handle_ == ACE_INVALID_HANDLE ? -1 : 0; } else return 0; #endif /* CHORUS */ }

ACE_INLINE int ACE_OS::flock_rdlock (  ACE_OS::ace_flock_t *    lock, short    whence = 0, off_t    start = 0, off_t    len = 0 )  [static]

Definition at line 9028 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, adjust_flock_params, fcntl, ACE_OS::ace_flock_t::handle_, mutex_lock, and ACE_OS::ace_flock_t::overlapped_. Referenced by ACE_File_Lock::acquire_read. { ACE_OS_TRACE ("ACE_OS::flock_rdlock"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_OS::adjust_flock_params (lock, whence, start, len); # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_, 0, 0, len, 0, &lock->overlapped_), ace_result_), int, -1); # else /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFile (lock->handle_, lock->overlapped_.Offset, 0, len, 0), ace_result_), int, -1); # endif /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ #elif defined (CHORUS) ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); return ACE_OS::mutex_lock (lock->process_lock_); #elif defined (ACE_LACKS_FILELOCKS) ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); #else lock->lock_.l_whence = whence; lock->lock_.l_start = start; lock->lock_.l_len = len; lock->lock_.l_type = F_RDLCK; // set read lock // block, if no access ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW, ACE_reinterpret_cast (long, &lock->lock_)), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::flock_tryrdlock (  ACE_OS::ace_flock_t *    lock, short    whence = 0, off_t    start = 0, off_t    len = 0 )  [static]

Definition at line 9133 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, adjust_flock_params, EBUSY, fcntl, ACE_OS::ace_flock_t::handle_, mutex_trylock, and ACE_OS::ace_flock_t::overlapped_. Referenced by ACE_File_Lock::tryacquire_read. { ACE_OS_TRACE ("ACE_OS::ace_flock_tryrdlock"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0) ACE_OS::adjust_flock_params (lock, whence, start, len); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_, LOCKFILE_FAIL_IMMEDIATELY, 0, len, 0, &lock->overlapped_), ace_result_), int, -1); # else /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ #elif defined (CHORUS) ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); return ACE_OS::mutex_trylock (lock->process_lock_); #elif defined (ACE_LACKS_FILELOCKS) ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); #else lock->lock_.l_whence = whence; lock->lock_.l_start = start; lock->lock_.l_len = len; lock->lock_.l_type = F_RDLCK; // set read lock int result = 0; // Does not block, if no access, returns -1 and set errno = EBUSY; ACE_OSCALL (ACE_OS::fcntl (lock->handle_, F_SETLK, ACE_reinterpret_cast (long, &lock->lock_)), int, -1, result); # if ! defined (ACE_PSOS) if (result == -1 && (errno == EACCES || errno == EAGAIN)) errno = EBUSY; # endif /* ! defined (ACE_PSOS) */ return result; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::flock_trywrlock (  ACE_OS::ace_flock_t *    lock, short    whence = 0, off_t    start = 0, off_t    len = 0 )  [static]

Definition at line 9076 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, adjust_flock_params, EBUSY, fcntl, ACE_OS::ace_flock_t::handle_, mutex_trylock, and ACE_OS::ace_flock_t::overlapped_. Referenced by ACE_File_Lock::tryacquire_write, and ACE_File_Lock::tryacquire_write_upgrade. { ACE_OS_TRACE ("ACE_OS::ace_flock_trywrlock"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0) ACE_OS::adjust_flock_params (lock, whence, start, len); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_, LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK, 0, len, 0, &lock->overlapped_), ace_result_), int, -1); # else /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ #elif defined (CHORUS) ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); return ACE_OS::mutex_trylock (lock->process_lock_); #elif defined (ACE_LACKS_FILELOCKS) ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); #else lock->lock_.l_whence = whence; lock->lock_.l_start = start; lock->lock_.l_len = len; lock->lock_.l_type = F_WRLCK; // set write lock int result = 0; // Does not block, if no access, returns -1 and set errno = EBUSY; ACE_OSCALL (ACE_OS::fcntl (lock->handle_, F_SETLK, ACE_reinterpret_cast (long, &lock->lock_)), int, -1, result); # if ! defined (ACE_PSOS) if (result == -1 && (errno == EACCES || errno == EAGAIN)) errno = EBUSY; # endif /* ! defined (ACE_PSOS) */ return result; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::flock_unlock (  ACE_OS::ace_flock_t *    lock, short    whence = 0, off_t    start = 0, off_t    len = 0 )  [static]

Definition at line 9189 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, adjust_flock_params, fcntl, ACE_OS::ace_flock_t::handle_, mutex_unlock, and ACE_OS::ace_flock_t::overlapped_. Referenced by flock_destroy, and ACE_File_Lock::release. { ACE_OS_TRACE ("ACE_OS::flock_unlock"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_OS::adjust_flock_params (lock, whence, start, len); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::UnlockFile (lock->handle_, lock->overlapped_.Offset, 0, len, 0), ace_result_), int, -1); #elif defined (CHORUS) ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); return ACE_OS::mutex_unlock (lock->process_lock_); #elif defined (ACE_LACKS_FILELOCKS) ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); #else lock->lock_.l_whence = whence; lock->lock_.l_start = start; lock->lock_.l_len = len; lock->lock_.l_type = F_UNLCK; // Unlock file. // release lock ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLK, ACE_reinterpret_cast (long, &lock->lock_)), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::flock_wrlock (  ACE_OS::ace_flock_t *    lock, short    whence = 0, off_t    start = 0, off_t    len = 0 )  [static]

Definition at line 8980 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, adjust_flock_params, fcntl, ACE_OS::ace_flock_t::handle_, mutex_lock, and ACE_OS::ace_flock_t::overlapped_. Referenced by ACE_File_Lock::acquire_write. { ACE_OS_TRACE ("ACE_OS::flock_wrlock"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_OS::adjust_flock_params (lock, whence, start, len); # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFileEx (lock->handle_, LOCKFILE_EXCLUSIVE_LOCK, 0, len, 0, &lock->overlapped_), ace_result_), int, -1); # else /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::LockFile (lock->handle_, lock->overlapped_.Offset, 0, len, 0), ace_result_), int, -1); # endif /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ #elif defined (CHORUS) ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); return ACE_OS::mutex_lock (lock->process_lock_); #elif defined (ACE_LACKS_FILELOCKS) ACE_UNUSED_ARG (lock); ACE_UNUSED_ARG (whence); ACE_UNUSED_ARG (start); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); #else lock->lock_.l_whence = whence; lock->lock_.l_start = start; lock->lock_.l_len = len; lock->lock_.l_type = F_WRLCK; // set write lock // block, if no access ACE_OSCALL_RETURN (ACE_OS::fcntl (lock->handle_, F_SETLKW, ACE_reinterpret_cast (long, &lock->lock_)), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE double ACE_OS::floor (  double    x )  [static]

This method computes the largest integral value not greater than x. Definition at line 5571 of file OS.i. Referenced by ceil. { // This method computes the largest integral value not greater than x. return double (ACE_static_cast (long, x)); }

ACE_INLINE FILE * ACE_OS::fopen (  const ACE_TCHAR *    filename, const ACE_TCHAR *    mode )  [static]

Definition at line 962 of file OS.cpp. References _O_TEXT, ACE_OS_TRACE, ACE_TCHAR, close, fopen_mode_to_open_mode_converter, and open. Referenced by access, ACE_Ini_ImpExp::export_config, ACE_Registry_ImpExp::export_config, ACE_Capabilities::getent, ACE_Logging_Strategy::handle_timeout, ACE_Ini_ImpExp::import_config, ACE_Registry_ImpExp::import_config, ACE_Logging_Strategy::init, ACE_Lib_Find::ldopen, and ACE_Service_Config::process_file. { ACE_OS_TRACE ("ACE_OS::fopen"); int hmode = _O_TEXT; for (const ACE_TCHAR *mode_ptr = mode; *mode_ptr != 0; mode_ptr++) ACE_OS::fopen_mode_to_open_mode_converter (*mode_ptr, hmode); ACE_HANDLE handle = ACE_OS::open (filename, hmode); if (handle != ACE_INVALID_HANDLE) { # if defined (ACE_HAS_WINCE) FILE *fp = ::_wfdopen (handle, mode); if (fp != 0) { checkUnicodeFormat(fp); return fp; } # else hmode &= _O_TEXT | _O_RDONLY | _O_APPEND; # if defined (ACE_WIN64) int fd = _open_osfhandle (intptr_t (handle), hmode); # else int fd = _open_osfhandle (long (handle), hmode); # endif /* ACE_WIN64 */ if (fd != -1) { # if defined (__BORLANDC__) && !defined (ACE_USES_WCHAR) FILE *fp = ::_fdopen (fd, ACE_const_cast (char *, mode)); # elif defined (__BORLANDC__) && defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, ACE_const_cast (wchar_t *, mode)); # elif defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, mode); # else FILE *fp = ::fdopen (fd, mode); # endif /* defined(__BORLANDC__) && !defined (ACE_USES_WCHAR)) */ if (fp != 0) { # if defined (ACE_USES_WCHAR) checkUnicodeFormat(fp); # endif // ACE_USES_WCHAR return fp; } _close (fd); } # endif // ACE_HAS_WINCE ACE_OS::close (handle); } return 0; }

void ACE_OS::fopen_mode_to_open_mode_converter (  ACE_TCHAR    x, int &    hmode )  [static, private]

Translate fopen's mode char to open's mode. This helper function is here to avoid maintaining several pieces of identical code. Referenced by fopen.

pid_t ACE_OS::fork (  const ACE_TCHAR *    program_name )  [static]

Forks and exec's a process in a manner that works on Solaris and NT. argv[0] must be the full path name to the executable. Definition at line 4714 of file OS.cpp. References ACE_OS_TRACE, ACE_TCHAR, pid_t, and ACE_Base_Thread_Adapter::sync_log_msg. { 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 */ }

ACE_INLINE pid_t ACE_OS::fork (  void    )  [static]

Definition at line 9690 of file OS.i. References ACE_OS_TRACE, fork, and pid_t. Referenced by ACE::daemonize, fork, ACE::fork, and fork_exec. { ACE_OS_TRACE ("ACE_OS::fork"); #if defined (ACE_LACKS_FORK) ACE_NOTSUP_RETURN (pid_t (-1)); #else ACE_OSCALL_RETURN (::fork (), pid_t, -1); #endif /* ACE_LACKS_FORK */ }

pid_t ACE_OS::fork_exec (  ACE_TCHAR *    argv[] )  [static]

Forks and exec's a process in a manner that works on Solaris and NT. argv[0] must be the full path name to the executable. Definition at line 4099 of file OS.cpp. References ACE_TCHAR, argv_to_string, close, execv, exit, fork, ACE_OS_String::memset, and pid_t. { # if defined (ACE_WIN32) ACE_TCHAR *buf; if (ACE_OS::argv_to_string (argv, buf) != -1) { PROCESS_INFORMATION process_info; # if !defined (ACE_HAS_WINCE) ACE_TEXT_STARTUPINFO startup_info; ACE_OS::memset ((void *) &startup_info, 0, sizeof startup_info); startup_info.cb = sizeof startup_info; if (ACE_TEXT_CreateProcess (0, buf, 0, // No process attributes. 0, // No thread attributes. TRUE, // Allow handle inheritance. 0, // Don't create a new console window. 0, // No environment. 0, // No current directory. &startup_info, &process_info)) # else if (ACE_TEXT_CreateProcess (0, buf, 0, // No process attributes. 0, // No thread attributes. FALSE, // Can's inherit handles on CE 0, // Don't create a new console window. 0, // No environment. 0, // No current directory. 0, // Can't use startup info on CE &process_info)) # endif /* ! ACE_HAS_WINCE */ { // Free resources allocated in kernel. ACE_OS::close (process_info.hThread); ACE_OS::close (process_info.hProcess); // Return new process id. delete [] buf; return process_info.dwProcessId; } } // CreateProcess failed. return -1; # elif defined (CHORUS) return ACE_OS::execv (argv[0], argv); # else pid_t result = ACE_OS::fork (); switch (result) { case -1: // Error. return -1; case 0: // Child process. if (ACE_OS::execv (argv[0], argv) == -1) { // The OS layer should not print stuff out // ACE_ERROR ((LM_ERROR, // "%p Exec failed\n")); // If the execv fails, this child needs to exit. ACE_OS::exit (errno); } default: // Server process. The fork succeeded. return result; } # endif /* ACE_WIN32 */ }

int ACE_OS::fprintf (  FILE *    fp, const wchar_t *    format, ...    )  [static]

Definition at line 1033 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::fprintf"); # if !defined (ACE_HAS_VFWPRINTF) ACE_UNUSED_ARG (fp); ACE_UNUSED_ARG (format); ACE_NOTSUP_RETURN (-1); # else int result = 0; va_list ap; va_start (ap, format); ACE_OSCALL (::vfwprintf (fp, format, ap), int, -1, result); va_end (ap); return result; # endif /* ACE_HAS_VFWPRINTF */ }

int ACE_OS::fprintf (  FILE *    fp, const char *    format, ...    )  [static]

Definition at line 1020 of file OS.cpp. References ACE_OS_TRACE. Referenced by ACE_ATM_Stream::get_vpi_vci, ACE_Log_Msg::log, ACE_Name_Options::parse_args, ACE_Log_Record::print, ACE_Stats::print_summary, socket_fini, and socket_init. { ACE_OS_TRACE ("ACE_OS::fprintf"); int result = 0; va_list ap; va_start (ap, format); ACE_OSCALL (::vfprintf (fp, format, ap), int, -1, result); va_end (ap); return result; }

ACE_INLINE int ACE_OS::fputs (  const ACE_TCHAR *    s, FILE *    stream )  [static]

Definition at line 6363 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and fputs. Referenced by ACE_Ini_ImpExp::export_section, ACE_Registry_ImpExp::export_section, and fputs. { ACE_OS_TRACE ("ACE_OS::fputs"); #if defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::fputws (s, stream), int, -1); #else /* ACE_WIN32 */ ACE_OSCALL_RETURN (::fputs (s, stream), int, -1); #endif /* ACE_WIN32 && ACE_USES_WCHAR */ }

ACE_INLINE size_t ACE_OS::fread (  void *    ptr, size_t    size, size_t    nelems, FILE *    fp )  [static]

Definition at line 5732 of file OS.i. References ACE_OS_TRACE, and fread. Referenced by fread. { ACE_OS_TRACE ("ACE_OS::fread"); #if defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::fread ((char *) ptr, size, nelems, fp), int, 0); #else ACE_OSCALL_RETURN (::fread (ptr, size, nelems, fp), int, 0); #endif /* ACE_LACKS_POSIX_PROTOTYPES */ }

ACE_INLINE FILE * ACE_OS::freopen (  const ACE_TCHAR *    filename, const ACE_TCHAR *    mode, FILE *    stream )  [static]

Definition at line 5700 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and freopen. Referenced by freopen. { ACE_OS_TRACE ("ACE_OS::freopen"); #if defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wfreopen (filename, mode, stream), FILE *, 0); #else ACE_OSCALL_RETURN (::freopen (filename, mode, stream), FILE *, 0); #endif /* ACE_WIN32 && ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::fseek (  FILE *    fp, long    offset, int    ptrname )  [static]

Definition at line 9922 of file OS.i. References fseek. Referenced by fseek, and ACE_Logging_Strategy::handle_timeout. { # if defined (ACE_WIN32) # if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END //#error Windows NT is evil AND rude! switch (whence) { case SEEK_SET: whence = FILE_BEGIN; break; case SEEK_CUR: whence = FILE_CURRENT; break; case SEEK_END: whence = FILE_END; break; default: errno = EINVAL; return -1; // rather safe than sorry } # endif /* SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END */ # endif /* ACE_WIN32 */ ACE_OSCALL_RETURN (::fseek (fp, offset, whence), int, -1); }

ACE_INLINE int ACE_OS::fsetpos (  FILE *    fp, fpos_t *    pos )  [static]

Definition at line 9960 of file OS.i. References fsetpos. Referenced by fsetpos. { ACE_OSCALL_RETURN (::fsetpos (fp, pos), int, -1); }

ACE_INLINE int ACE_OS::fstat (  ACE_HANDLE   , ACE_stat *    )  [static]

Definition at line 305 of file OS.i. References ACE_OS_TRACE, ACE_stat, and fstat. Referenced by ACE_Select_Reactor_T::check_handles, filesize, fstat, and ACE_FILE::get_info. { ACE_OS_TRACE ("ACE_OS::fstat"); #if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (stp); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_PSOS) ACE_OSCALL_RETURN (::fstat_f (handle, stp), int, -1); #else # if defined (ACE_HAS_X86_STAT_MACROS) // Solaris for intel uses an macro for fstat(), this is a wrapper // for _fxstat() use of the macro. // causes compile and runtime problems. ACE_OSCALL_RETURN (::_fxstat (_STAT_VER, handle, stp), int, -1); # elif defined (ACE_WIN32) ACE_OSCALL_RETURN (::_fstat (handle, stp), int, -1); # else ACE_OSCALL_RETURN (::fstat (handle, stp), int, -1); # endif /* !ACE_HAS_X86_STAT_MACROS */ #endif /* ACE_PSOS_LACKS_PHILE */ }

ACE_INLINE int ACE_OS::fsync (  ACE_HANDLE    handle )  [static]

Definition at line 351 of file OS.i. References ACE_OS_TRACE, and fsync. Referenced by fsync. { ACE_OS_TRACE ("ACE_OS::fsync"); # if defined (ACE_LACKS_FSYNC) ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::fsync (handle), int, -1); # endif /* ACE_LACKS_FSYNC */ }

ACE_INLINE long ACE_OS::ftell (  FILE *    fp )  [static]

Definition at line 9948 of file OS.i. References ftell. Referenced by ftell. { ACE_OSCALL_RETURN (::ftell (fp), long, -1); }

ACE_INLINE int ACE_OS::ftruncate (  ACE_HANDLE   , off_t    )  [static]

Definition at line 2864 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and ftruncate. Referenced by ACE_Condition::ACE_Condition, ACE_Mutex::ACE_Mutex, flock_init, ftruncate, ACE_Mem_Map::map_it, ACE_Mem_Map::remove, sema_init, and ACE_FILE::truncate. { ACE_OS_TRACE ("ACE_OS::ftruncate"); #if defined (ACE_WIN32) if (::SetFilePointer (handle, offset, 0, FILE_BEGIN) != (unsigned) -1) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEndOfFile (handle), ace_result_), int, -1); else ACE_FAIL_RETURN (-1); /* NOTREACHED */ #elif defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (offset); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_PSOS) ACE_OSCALL_RETURN (::ftruncate_f (handle, offset), int, -1); #else ACE_OSCALL_RETURN (::ftruncate (handle, offset), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE size_t ACE_OS::fwrite (  const void *    ptr, size_t    size, size_t    nitems, FILE *    fp )  [static]

Definition at line 5743 of file OS.i. References ACE_OS_TRACE, and fwrite. Referenced by fwrite. { ACE_OS_TRACE ("ACE_OS::fwrite"); #if defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::fwrite ((const char *) ptr, size, nitems, fp), int, 0); #else ACE_OSCALL_RETURN (::fwrite (ptr, size, nitems, fp), int, 0); #endif /* ACE_LACKS_POSIX_PROTOTYPES */ }

HINSTANCE ACE_OS::get_win32_resource_module (  void    )  [static]

Return the handle of the module containing ACE's resources. By default, for a DLL build of ACE this is a handle to the ACE DLL itself, and for a static build it is a handle to the executable.

const OSVERSIONINFO& ACE_OS::get_win32_versioninfo (  void    )  [static]

Return the win32 OSVERSIONINFO structure.

ACE_INLINE ACE_TCHAR * ACE_OS::getcwd (  ACE_TCHAR *   , size_t    )  [static]

Definition at line 10181 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, getcwd, ACE_OS_String::memset, ACE_OS_String::strcat, ACE_OS_String::strcpy, and ACE_OS_String::strlen. Referenced by getcwd. { ACE_OS_TRACE ("ACE_OS::getcwd"); #if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (size); ACE_NOTSUP_RETURN ( (char*)-1); #elif defined (ACE_PSOS) static char pathbuf [BUFSIZ]; // blank the path buffer ACE_OS::memset (pathbuf, '\0', BUFSIZ); // the following was suggested in the documentation for get_fn () u_long result; char cur_dir_name [BUFSIZ] = "."; u_long cur_dir = 0, prev_dir = 0; while ((ACE_OS::strlen (pathbuf) < BUFSIZ) && (ACE_OS::strlen (cur_dir_name) < BUFSIZ - ACE_OS::strlen ("/.."))) { // get the current directory handle result = ::get_fn (cur_dir_name, &cur_dir); // check whether we're at the root: this test is // really lame, but the get_fn documentation says // *either* condition indicates you're trying to // move above the root. if ((result != 0) || ( cur_dir == prev_dir)) { break; } // change name to the parent directory ACE_OS::strcat (cur_dir_name, "/.."); // open the parent directory XDIR xdir; result = ::open_dir (cur_dir_name, &xdir); if (result != 0) { return 0; } // look for an entry that matches the current directory handle struct dirent dir_entry; while (1) { // get the next directory entry result = ::read_dir (&xdir, &dir_entry); if (result != 0) { return 0; } // check for a match if (dir_entry.d_filno == cur_dir) { // prefix the previous path with the entry's name and break if (ACE_OS::strlen (pathbuf) + ACE_OS::strlen (dir_entry.d_name) < BUFSIZ) { ACE_OS::strcpy (pathbuf + ACE_OS::strlen (dir_entry.d_name), pathbuf); ACE_OS::strcpy (pathbuf, dir_entry.d_name); break; } else { // we're out of room in the buffer return 0; } } } // close the parent directory result = ::close_dir (&xdir); if (result != 0) { return 0; } // save the current directory handle as the previous prev_dir = cur_dir; } // return the path, if there is one return (ACE_OS::strlen (pathbuf) > 0) ? pathbuf : (char *) 0; #elif defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (size); ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) # if defined (ACE_USES_WCHAR) return ::_wgetcwd (buf, ACE_static_cast (int, size)); # else return ::getcwd (buf, ACE_static_cast (int, size)); # endif /* ACE_USES_WCHAR */ #else ACE_OSCALL_RETURN (::getcwd (buf, size), char *, 0); #endif /* ACE_PSOS_LACKS_PHILE */ }

wchar_t* ACE_OS::getenv (  const wchar_t *    symbol )  [static]

ACE_INLINE char * ACE_OS::getenv (  const char *    symbol )  [static]

Definition at line 10462 of file OS.i. References ACE_OS_TRACE, and getenv. Referenced by ACE_ARGV::ACE_ARGV, ACE_Get_Opt::ACE_Get_Opt, argv_to_string, ACE_Env_Value::fetch_value, ACE_High_Res_Timer::get_env_global_scale_factor, ACE_Lib_Find::get_temp_dir, getenv, ACE_Lib_Find::ldfind, and strenvdup. { ACE_OS_TRACE ("ACE_OS::getenv"); #if defined (ACE_LACKS_ENV) ACE_UNUSED_ARG (symbol); ACE_NOTSUP_RETURN (0); #elif defined (ACE_PSOS) ACE_UNUSED_ARG (symbol); ACE_NOTSUP_RETURN (0); #else /* ACE_PSOS */ ACE_OSCALL_RETURN (::getenv (symbol), char *, 0); #endif /* ACE_LACKS_ENV */ }

ACE_TCHAR * ACE_OS::getenvstrings (  void    )  [static]

Definition at line 7119 of file OS.cpp. Referenced by ACE_Process_Options::inherit_environment. { #if defined (ACE_LACKS_ENV) ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) # if defined (ACE_USES_WCHAR) return ::GetEnvironmentStringsW (); # else /* ACE_USES_WCHAR */ return ::GetEnvironmentStrings (); # endif /* ACE_USES_WCHAR */ #else /* ACE_WIN32 */ ACE_NOTSUP_RETURN (0); #endif /* ACE_WIN32 */ }

ACE_INLINE gid_t ACE_OS::getgid (  void    )  [static]

Definition at line 10968 of file OS.i. References ACE_OS_TRACE, getgid, and gid_t. Referenced by getgid, and ACE_SPIPE_Addr::set. { ACE_OS_TRACE ("ACE_OS::getgid"); #if defined (VXWORKS) || defined (ACE_PSOS) // getgid() is not supported: just one user anyways return 0; # elif defined (ACE_WIN32) || defined (CHORUS) ACE_NOTSUP_RETURN (ACE_static_cast (gid_t, -1)); # else ACE_OSCALL_RETURN (::getgid (), gid_t, (gid_t) -1); # endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE struct hostent * ACE_OS::gethostbyaddr (  const char *    addr, int    length, int    type )  [static]

BSD-style <accept> (no QoS). Definition at line 4835 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ACE_SOCKET_LEN. Referenced by ACE_INET_Addr::get_host_name_i, and getipnodebyaddr. { ACE_OS_TRACE ("ACE_OS::gethostbyaddr"); # if defined (ACE_PSOS) ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (length); ACE_UNUSED_ARG (type); ACE_NOTSUP_RETURN (0); # elif defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::gethostbyaddr (ACE_const_cast (char *, addr), (ACE_SOCKET_LEN) length, type), struct hostent *, 0); # else ACE_SOCKCALL_RETURN (::gethostbyaddr (addr, (ACE_SOCKET_LEN) length, type), struct hostent *, 0); # endif /* ACE_HAS_NONCONST_GETBY */ }

ACE_INLINE struct hostent * ACE_OS::gethostbyaddr_r (  const char *    addr, int    length, int    type, struct hostent *    result, ACE_HOSTENT_DATA    buffer, int *    h_errnop )  [static]

BSD-style <accept> (no QoS). Definition at line 5921 of file OS.i. References ACE_HOSTENT_DATA, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ACE_SOCKET_LEN. Referenced by ACE_INET_Addr::get_host_name_i. { ACE_OS_TRACE ("ACE_OS::gethostbyaddr_r"); # if defined (ACE_PSOS) ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (length); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (h_errnop); ACE_NOTSUP_RETURN (0); # elif defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) # if defined (AIX) || defined (DIGITAL_UNIX) || defined (HPUX_10) ::memset (buffer, 0, sizeof (ACE_HOSTENT_DATA)); if (::gethostbyaddr_r ((char *) addr, length, type, result, (struct hostent_data *) buffer)== 0) return result; else { *h_errnop = h_errno; return (struct hostent *) 0; } # elif defined (__GLIBC__) // GNU C library has a different signature ::memset (buffer, 0, sizeof (ACE_HOSTENT_DATA)); if (::gethostbyaddr_r ((char *) addr, length, type, result, buffer, sizeof (ACE_HOSTENT_DATA), &result, h_errnop) == 0) return result; else return (struct hostent *) 0; # else # if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (h_errnop); ACE_NETDBCALL_RETURN (::gethostbyaddr (addr, (ACE_SOCKET_LEN) length, type), struct hostent *, 0, buffer, sizeof (ACE_HOSTENT_DATA)); # else ACE_SOCKCALL_RETURN (::gethostbyaddr_r (addr, length, type, result, buffer, sizeof (ACE_HOSTENT_DATA), h_errnop), struct hostent *, 0); # endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */ # endif /* defined (AIX) || defined (DIGITAL_UNIX) */ # elif defined (ACE_HAS_NONCONST_GETBY) ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (h_errnop); ACE_SOCKCALL_RETURN (::gethostbyaddr (ACE_const_cast (char *, addr), (ACE_SOCKET_LEN) length, type), struct hostent *, 0); # else ACE_UNUSED_ARG (h_errnop); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (result); ACE_SOCKCALL_RETURN (::gethostbyaddr (addr, (ACE_SOCKET_LEN) length, type), struct hostent *, 0); # endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) */ }

ACE_INLINE struct hostent * ACE_OS::gethostbyname (  const char *    name )  [static]

BSD-style <accept> (no QoS). Definition at line 4816 of file OS.i. References ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. Referenced by ACE_Sock_Connect::get_bcast_addr, getipnodebyname, ACE_SOCK_Dgram_Bcast::mk_broadcast, and ACE_INET_Addr::set. { ACE_OS_TRACE ("ACE_OS::gethostbyname"); # if defined (ACE_PSOS) ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (0); # elif defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::gethostbyname (ACE_const_cast (char *, name)), struct hostent *, 0); # else ACE_SOCKCALL_RETURN (::gethostbyname (name), struct hostent *, 0); # endif /* ACE_HAS_NONCONST_GETBY */ }

ACE_INLINE struct hostent * ACE_OS::gethostbyname_r (  const char *    name, struct hostent *    result, ACE_HOSTENT_DATA    buffer, int *    h_errnop )  [static]

BSD-style <accept> (no QoS). Definition at line 6001 of file OS.i. References ACE_HOSTENT_DATA, ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. Referenced by ACE_INET_Addr::set. { ACE_OS_TRACE ("ACE_OS::gethostbyname_r"); #if defined (ACE_PSOS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (h_errnop); ACE_NOTSUP_RETURN (0); # elif defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) # if defined (DIGITAL_UNIX) || \ (defined (ACE_AIX_MINOR_VERS) && (ACE_AIX_MINOR_VERS > 2)) ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (h_errnop); // gethostbyname returns thread-specific storage on Digital Unix and // AIX 4.3 ACE_SOCKCALL_RETURN (::gethostbyname (name), struct hostent *, 0); # elif defined (AIX) || defined (HPUX_10) ::memset (buffer, 0, sizeof (ACE_HOSTENT_DATA)); if (::gethostbyname_r (name, result, (struct hostent_data *) buffer) == 0) return result; else { *h_errnop = h_errno; return (struct hostent *) 0; } # elif defined (__GLIBC__) // GNU C library has a different signature ::memset (buffer, 0, sizeof (ACE_HOSTENT_DATA)); if (::gethostbyname_r (name, result, buffer, sizeof (ACE_HOSTENT_DATA), &result, h_errnop) == 0) return result; else return (struct hostent *) 0; # else # if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (h_errnop); ACE_NETDBCALL_RETURN (::gethostbyname (name), struct hostent *, 0, buffer, sizeof (ACE_HOSTENT_DATA)); # else ACE_SOCKCALL_RETURN (::gethostbyname_r (name, result, buffer, sizeof (ACE_HOSTENT_DATA), h_errnop), struct hostent *, 0); # endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */ # endif /* defined (AIX) || defined (DIGITAL_UNIX) */ # elif defined (ACE_HAS_NONCONST_GETBY) ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (h_errnop); ACE_SOCKCALL_RETURN (::gethostbyname (ACE_const_cast (char *, name)), struct hostent *, 0); # else ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (h_errnop); ACE_SOCKCALL_RETURN (::gethostbyname (name), struct hostent *, 0); # endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) */ }

ACE_INLINE ACE_hrtime_t ACE_OS::gethrtime (  const    ACE_HRTimer_Op = ACE_HRTIMER_GETTIME )  [static]

Definition at line 9521 of file OS.i. References ACE_hrtime_t, ACE_HRTIMER_GETTIME, ACE_ONE_SECOND_IN_NSECS, ACE_OS_TRACE, ACE_UINT64, clock_gettime, CLOCK_REALTIME, gettimeofday, ACE_OS_String::memcpy, ACE_Time_Value::sec, timespec::tv_nsec, timespec::tv_sec, and ACE_Time_Value::usec. Referenced by ACE_High_Res_Timer::calibrate, ACE_High_Res_Timer::gettime, ACE_High_Res_Timer::gettimeofday, and ACE_Timeprobe::timeprobe. { ACE_OS_TRACE ("ACE_OS::gethrtime"); #if defined (ACE_HAS_HI_RES_TIMER) ACE_UNUSED_ARG (op); return ::gethrtime (); #elif defined (ACE_HAS_AIX_HI_RES_TIMER) ACE_UNUSED_ARG (op); timebasestruct_t tb; ::read_real_time(&tb, TIMEBASE_SZ); ::time_base_to_time(&tb, TIMEBASE_SZ); return ACE_hrtime_t(tb.tb_high) * ACE_ONE_SECOND_IN_NSECS + tb.tb_low; #elif defined (ghs) && defined (ACE_HAS_PENTIUM) && !defined (ACE_WIN32) ACE_UNUSED_ARG (op); // Use .obj/gethrtime.o, which was compiled with g++. return ACE_gethrtime (); #elif (defined(__KCC) || defined (__GNUG__)) && !defined (__MINGW32__) && defined (ACE_HAS_PENTIUM) ACE_UNUSED_ARG (op); # if defined (ACE_LACKS_LONGLONG_T) double now; # else /* ! ACE_LACKS_LONGLONG_T */ ACE_hrtime_t now; # endif /* ! ACE_LACKS_LONGLONG_T */ // See comments about the RDTSC Pentium instruction for the ACE_WIN32 // version of ACE_OS::gethrtime (), below. // // Read the high-res tick counter directly into memory variable "now". // The A constraint signifies a 64-bit int. asm volatile ("rdtsc" : "=A" (now) : : "memory"); # if defined (ACE_LACKS_LONGLONG_T) ACE_UINT32 least, most; ACE_OS::memcpy (&least, &now, sizeof (ACE_UINT32)); ACE_OS::memcpy (&most, (u_char *) &now + sizeof (ACE_UINT32), sizeof (ACE_UINT32)); ACE_hrtime_t ret (least, most); return ret; # else /* ! ACE_LACKS_LONGLONG_T */ return now; # endif /* ! ACE_LACKS_LONGLONG_T */ #elif defined (linux) && defined (ACE_HAS_ALPHA_TIMER) // NOTE: alphas only have a 32 bit tick (cycle) counter. The rpcc // instruction actually reads 64 bits, but the high 32 bits are // implementation-specific. Linux and Digital Unix, for example, // use them for virtual tick counts, i.e., taking into account only // the time that the process was running. This information is from // David Mosberger's article, see comment below. ACE_UINT32 now; // The following statement is based on code published by: // Mosberger, David, "How to Make Your Applications Fly, Part 1", // Linux Journal Issue 42, October 1997, page 50. It reads the // high-res tick counter directly into the memory variable. asm volatile ("rpcc %0" : "=r" (now) : : "memory"); return now; #elif defined (ACE_WIN32) ACE_UNUSED_ARG(op); LARGE_INTEGER freq; ::QueryPerformanceCounter (&freq); # if defined (ACE_LACKS_LONGLONG_T) ACE_UINT64 uint64_freq(freq.u.LowPart, ACE_static_cast (unsigned int, freq.u.HighPart)); return uint64_freq; # else return freq.QuadPart; # endif //ACE_LACKS_LONGLONG_T #elif defined (CHORUS) if (op == ACE_OS::ACE_HRTIMER_GETTIME) { struct timespec ts; ACE_OS::clock_gettime (CLOCK_REALTIME, &ts); // Carefully create the return value to avoid arithmetic overflow // if ACE_hrtime_t is ACE_U_LongLong. ACE_hrtime_t now = ts.tv_sec; now *= ACE_U_ONE_SECOND_IN_NSECS; now += ts.tv_nsec; return now; } else { // Use the sysBench timer on Chorus. On MVME177, at least, it only // has 32 bits. Be careful, because using it disables interrupts! ACE_UINT32 now; if (::sysBench (op, (int *) &now) == K_OK) { now *= 1000u /* nanoseconds/microsecond */; return (ACE_hrtime_t) now; } else { // Something went wrong. Just return 0. return (ACE_hrtime_t) 0; } } #elif defined (ACE_HAS_POWERPC_TIMER) && (defined (ghs) || defined (__GNUG__)) // PowerPC w/ GreenHills or g++. ACE_UNUSED_ARG (op); u_long most; u_long least; ACE_OS::readPPCTimeBase (most, least); #if defined (ACE_LACKS_LONGLONG_T) return ACE_U_LongLong (least, most); #else /* ! ACE_LACKS_LONGLONG_T */ return 0x100000000llu * most + least; #endif /* ! ACE_LACKS_LONGLONG_T */ #elif defined (ACE_HAS_CLOCK_GETTIME) || defined (ACE_PSOS) // e.g., VxWorks (besides POWERPC && GreenHills) . . . ACE_UNUSED_ARG (op); struct timespec ts; ACE_OS::clock_gettime (CLOCK_REALTIME, &ts); // Carefully create the return value to avoid arithmetic overflow // if ACE_hrtime_t is ACE_U_LongLong. return ACE_static_cast (ACE_hrtime_t, ts.tv_sec) * ACE_U_ONE_SECOND_IN_NSECS + ACE_static_cast (ACE_hrtime_t, ts.tv_nsec); #else ACE_UNUSED_ARG (op); const ACE_Time_Value now = ACE_OS::gettimeofday (); // Carefully create the return value to avoid arithmetic overflow // if ACE_hrtime_t is ACE_U_LongLong. return (ACE_static_cast (ACE_hrtime_t, now.sec ()) * (ACE_UINT32) 1000000 + ACE_static_cast (ACE_hrtime_t, now.usec ())) * (ACE_UINT32) 1000; #endif /* ACE_HAS_HI_RES_TIMER */ }

ACE_INLINE struct hostent * ACE_OS::getipnodebyaddr (  const void *    src, size_t    len, int    family )  [static]

BSD-style <accept> (no QoS). Definition at line 4900 of file OS.i. References gethostbyaddr. { #if defined (ACE_HAS_IPV6) # if defined (__GLIBC__) ACE_UNUSED_ARG (src); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (family); ACE_NOTSUP_RETURN (0); # else struct hostent *hptr; int errnum; if ((hptr = ::getipnodebyaddr (src, len, family, &errnum)) == 0) { errno = errnum; } return hptr; # endif /* whatever_doesnt_have_getipnodebyname */ #else // IPv4-only implementation if (family == AF_INET) return ACE_OS::gethostbyaddr (ACE_static_cast (const char *, src), ACE_static_cast (int, len), family); ACE_NOTSUP_RETURN (0); # endif /* ACE_PSOS */ }

ACE_INLINE struct hostent * ACE_OS::getipnodebyname (  const char *    name, int    family, int    flags = 0 )  [static]

BSD-style <accept> (no QoS). Definition at line 4860 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and gethostbyname. { ACE_OS_TRACE ("ACE_OS::getipnodebyname"); # if defined (ACE_PSOS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (family); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (0); # elif defined (ACE_HAS_IPV6) # if defined (__GLIBC__) ACE_UNUSED_ARG (flags); # if defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::gethostbyname2 (ACE_const_cast (char *, name), family), struct hostent *, 0); # else ACE_SOCKCALL_RETURN (::gethostbyname2 (name, family), struct hostent *, 0); # endif /* ACE_HAS_NONCONST_GETBY */ # else struct hostent *hptr; int errnum; if ((hptr = ::getipnodebyname (name, family, flags, &errnum)) == 0) { errno = errnum; } return hptr; # endif /* __GLIBC__ */ # else // IPv4-only implementation ACE_UNUSED_ARG (flags); if (family == AF_INET) return ACE_OS::gethostbyname (name); ACE_NOTSUP_RETURN (0); # endif /* ACE_PSOS */ }

ACE_INLINE int ACE_OS::getmsg (  ACE_HANDLE    handle, struct strbuf *    ctl, struct strbuf *    data, int *    flags )  [static]

Definition at line 8317 of file OS.i. References ACE_OS_TRACE, and getmsg. Referenced by getmsg, ACE_SPIPE_Stream::recv, and ACE_FIFO_Recv_Msg::recv. { ACE_OS_TRACE ("ACE_OS::getmsg"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::getmsg (handle, ctl, data, flags), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (ctl); ACE_UNUSED_ARG (data); ACE_UNUSED_ARG (flags); // I'm not sure how to implement this correctly. ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_STREAM_PIPES */ }

ACE_INLINE int ACE_OS::getopt (  int    argc, char *const *    argv, const char *    optstring )  [static]

Definition at line 363 of file OS.i. References ACE_OS_TRACE, and getopt. Referenced by getopt. { ACE_OS_TRACE ("ACE_OS::getopt"); #if defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_UNUSED_ARG (optstring); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_LACKS_GETOPT_PROTO) ACE_OSCALL_RETURN (::getopt (argc, (char**) argv, optstring), int, -1); # elif defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::getopt (argc, (const char* const *) argv, optstring), int, -1); # else ACE_OSCALL_RETURN (::getopt (argc, argv, optstring), int, -1); # endif /* VXWORKS */ }

ACE_INLINE int ACE_OS::getpagesize (  void    )  [static]

Definition at line 9701 of file OS.i. References ACE_OS_TRACE. Referenced by allocation_granularity, ACE_WIN32_Asynch_Write_File_Result::complete, ACE_WIN32_Asynch_Read_File_Result::complete, ACE_WIN32_Asynch_Read_File::readv, ACE::round_to_pagesize, and ACE_WIN32_Asynch_Write_File::writev. { ACE_OS_TRACE ("ACE_OS::getpagesize"); #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return (int) sys_info.dwPageSize; #elif defined (_SC_PAGESIZE) return (int) ::sysconf (_SC_PAGESIZE); #elif defined (ACE_HAS_GETPAGESIZE) return ::getpagesize (); #else // Use the default set in config.h return ACE_PAGE_SIZE; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::getpeername (  ACE_HANDLE    handle, struct sockaddr *    addr, int *    addrlen )  [static]

BSD-style <accept> (no QoS). Definition at line 5222 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and getpeername. Referenced by ACE_SOCK_Connector::complete, ACE_ATM_Stream::get_peer_name, ACE_SOCK::get_remote_addr, getpeername, and ACE_Asynch_Connector::parse_address. { ACE_OS_TRACE ("ACE_OS::getpeername"); #if defined (ACE_PSOS) && !defined ACE_PSOS_DIAB_PPC ACE_SOCKCALL_RETURN (::getpeername ((ACE_SOCKET) handle, (struct sockaddr_in *) addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #else ACE_SOCKCALL_RETURN (::getpeername ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #endif /* defined (ACE_PSOS) */ }

ACE_INLINE pid_t ACE_OS::getpgid (  pid_t    pid )  [static]

Definition at line 9747 of file OS.i. References ACE_OS_TRACE, getpgid, and pid_t. Referenced by getpgid. { ACE_OS_TRACE ("ACE_OS::getpgid"); #if defined (ACE_LACKS_GETPGID) ACE_UNUSED_ARG (pid); ACE_NOTSUP_RETURN (-1); #elif defined (VXWORKS) || defined (ACE_PSOS) // getpgid() is not supported, only one process anyway. ACE_UNUSED_ARG (pid); return 0; #elif defined (linux) && __GLIBC__ > 1 && __GLIBC_MINOR__ >= 0 // getpgid() is from SVR4, which appears to be the reason why GLIBC // doesn't enable its prototype by default. // Rather than create our own extern prototype, just use the one // that is visible (ugh). ACE_OSCALL_RETURN (::__getpgid (pid), pid_t, -1); #else ACE_OSCALL_RETURN (::getpgid (pid), pid_t, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE pid_t ACE_OS::getpid (  void    )  [static]

Definition at line 9731 of file OS.i. References getpid. Referenced by ACE_TPQ_Entry::ACE_TPQ_Entry, ACE_IPC_SAP::enable, ACE_IO_SAP::enable, getpid, ACE_Log_Msg::getpid, ACE_SPIPE_Stream::recv_handle, ACE_Log_Msg::sync, and unique_name. { // ACE_OS_TRACE ("ACE_OS::getpid"); #if defined (ACE_WIN32) return ::GetCurrentProcessId (); #elif defined (VXWORKS) || defined (ACE_PSOS) // getpid() is not supported: just one process anyways return 0; #elif defined (CHORUS) return (pid_t) (::agetId ()); #else ACE_OSCALL_RETURN (::getpid (), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::getpmsg (  ACE_HANDLE    handle, struct strbuf *    ctl, struct strbuf *    data, int *    band, int *    flags )  [static]

Definition at line 8337 of file OS.i. References ACE_OS_TRACE, and getpmsg. Referenced by getpmsg, and ACE_SPIPE_Stream::recv. { ACE_OS_TRACE ("ACE_OS::getpmsg"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::getpmsg (handle, ctl, data, band, flags), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (ctl); ACE_UNUSED_ARG (data); ACE_UNUSED_ARG (band); ACE_UNUSED_ARG (flags); // I'm not sure how to implement this correctly. ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_STREAM_PIPES */ }

ACE_INLINE pid_t ACE_OS::getppid (  void    )  [static]

Definition at line 9769 of file OS.i. References ACE_OS_TRACE, getppid, and pid_t. Referenced by getppid, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::getppid"); #if defined (ACE_LACKS_GETPPID) ACE_NOTSUP_RETURN (-1); #elif defined (VXWORKS) || defined (ACE_PSOS) // getppid() is not supported, only one process anyway. return 0; #else ACE_OSCALL_RETURN (::getppid (), pid_t, -1); #endif /* ACE_LACKS_GETPPID */ }

ACE_INLINE struct protoent * ACE_OS::getprotobyname (  const char *    name )  [static]

BSD-style <accept> (no QoS). Definition at line 5240 of file OS.i. References ACE_SOCKCALL_RETURN. { #if defined (VXWORKS) || defined (ACE_HAS_WINCE) || (defined (ghs) && defined (__Chorus)) || defined (ACE_PSOS) ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::getprotobyname (ACE_const_cast (char *, name)), struct protoent *, 0); #else ACE_SOCKCALL_RETURN (::getprotobyname (name), struct protoent *, 0); #endif /* VXWORKS */ }

ACE_INLINE struct protoent * ACE_OS::getprotobyname_r (  const char *    name, struct protoent *    result, ACE_PROTOENT_DATA    buffer )  [static]

BSD-style <accept> (no QoS). Definition at line 5257 of file OS.i. References ACE_PROTOENT_DATA, and ACE_SOCKCALL_RETURN. { #if defined (VXWORKS) || defined (ACE_HAS_WINCE) || (defined (ghs) && defined (__Chorus)) || defined (ACE_PSOS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) # if defined (AIX) || defined (DIGITAL_UNIX) || defined (HPUX_10) if (::getprotobyname_r (name, result, (struct protoent_data *) buffer) == 0) return result; else return 0; # elif defined (__GLIBC__) // GNU C library has a different signature if (::getprotobyname_r (name, result, buffer, sizeof (ACE_PROTOENT_DATA), &result) == 0) return result; else return 0; # else # if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) ACE_UNUSED_ARG (result); ACE_NETDBCALL_RETURN (::getprotobyname (name), struct protoent *, 0, buffer, sizeof (ACE_PROTOENT_DATA)); # else ACE_SOCKCALL_RETURN (::getprotobyname_r (name, result, buffer, sizeof (ACE_PROTOENT_DATA)), struct protoent *, 0); # endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */ # endif /* defined (AIX) || defined (DIGITAL_UNIX) */ #elif defined (ACE_HAS_NONCONST_GETBY) ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_SOCKCALL_RETURN (::getprotobyname (ACE_const_cast (char *, name)), struct protoent *, 0); #else ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (result); ACE_SOCKCALL_RETURN (::getprotobyname (name), struct protoent *, 0); #endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) !defined (UNIXWARE) */ }

ACE_INLINE struct protoent * ACE_OS::getprotobynumber (  int    proto )  [static]

BSD-style <accept> (no QoS). Definition at line 5312 of file OS.i. References ACE_SOCKCALL_RETURN. { #if defined (VXWORKS) || defined (ACE_HAS_WINCE) || (defined (ghs) && defined (__Chorus)) || defined (ACE_PSOS) ACE_UNUSED_ARG (proto); ACE_NOTSUP_RETURN (0); #else ACE_SOCKCALL_RETURN (::getprotobynumber (proto), struct protoent *, 0); #endif /* VXWORKS */ }

ACE_INLINE struct protoent * ACE_OS::getprotobynumber_r (  int    proto, struct protoent *    result, ACE_PROTOENT_DATA    buffer )  [static]

BSD-style <accept> (no QoS). Definition at line 5324 of file OS.i. References ACE_PROTOENT_DATA, and ACE_SOCKCALL_RETURN. { #if defined (VXWORKS) || defined (ACE_HAS_WINCE) || (defined (ghs) && defined (__Chorus)) || defined (ACE_PSOS) ACE_UNUSED_ARG (proto); ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buffer); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) # if defined (AIX) || defined (DIGITAL_UNIX) || defined (HPUX_10) if (::getprotobynumber_r (proto, result, (struct protoent_data *) buffer) == 0) return result; else return 0; # elif defined (__GLIBC__) // GNU C library has a different signature if (::getprotobynumber_r (proto, result, buffer, sizeof (ACE_PROTOENT_DATA), &result) == 0) return result; else return 0; # else # if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) ACE_UNUSED_ARG (result); ACE_NETDBCALL_RETURN (::getprotobynumber (proto), struct protoent *, 0, buffer, sizeof (ACE_PROTOENT_DATA)); # else ACE_SOCKCALL_RETURN (::getprotobynumber_r (proto, result, buffer, sizeof (ACE_PROTOENT_DATA)), struct protoent *, 0); # endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */ # endif /* defined (AIX) || defined (DIGITAL_UNIX) */ #else ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (result); ACE_SOCKCALL_RETURN (::getprotobynumber (proto), struct protoent *, 0); #endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) */ }

ACE_INLINE struct passwd * ACE_OS::getpwent (  void    )  [static]

Definition at line 5831 of file OS.i. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) # if !defined (ACE_WIN32) return ::getpwent (); # else ACE_NOTSUP_RETURN (0); # endif /* ACE_WIN32 */ #else ACE_NOTSUP_RETURN (0); #endif /* ! ACE_LACKS_PWD_FUNCTIONS */ }

ACE_INLINE struct passwd * ACE_OS::getpwnam (  const char *    user )  [static]

Definition at line 5791 of file OS.i. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) # if !defined (ACE_WIN32) return ::getpwnam (name); # else ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (0); # endif /* ACE_WIN32 */ #else ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (0); #endif /* ACE_LACKS_PWD_FUNCTIONS */ }

ACE_INLINE struct passwd * ACE_OS::getpwnam_r (  const char *    name, struct passwd *    pwent, char *    buffer, int    buflen )  [static]

Definition at line 5845 of file OS.i. { #if defined (ACE_HAS_POSIX_GETPWNAM_R) struct passwd *result; int status; status = ::getpwnam_r (name, pwent, buffer, buflen, &result); if (status != 0) { errno = status; result = 0; } return result; #elif !defined (ACE_LACKS_PWD_FUNCTIONS) # if defined (ACE_HAS_REENTRANT_FUNCTIONS) # if !defined (ACE_LACKS_PWD_REENTRANT_FUNCTIONS) # if defined (ACE_HAS_PTHREADS_STD) && \ !defined (ACE_HAS_STHREADS) || \ defined (HPUX_11) || \ defined (__USLC__) // Added by Roland Gigler for SCO UnixWare 7. struct passwd *result; int status; # if defined (DIGITAL_UNIX) ::_Pgetpwnam_r (name, pwent, buffer, buflen, &result); # else // VAC++ doesn't correctly grok the ::getpwnam_r - the function is redefined // in pwd.h, and that redefinition is used here # if defined (__IBMCPP__) && (__IBMCPP__ >= 400) /* VAC++ 4 */ status = _posix_getpwnam_r (name, pwent, buffer, buflen, &result); # else status = ::getpwnam_r (name, pwent, buffer, buflen, &result); # endif /* __IBMCPP__ && (__IBMCPP__ >= 400) */ if (status != 0) { errno = status; result = 0; } # endif /* (DIGITAL_UNIX) */ return result; # elif defined (AIX) || defined (HPUX_10) if (::getpwnam_r (name, pwent, buffer, buflen) == -1) return 0; else return pwent; # else return ::getpwnam_r (name, pwent, buffer, buflen); # endif /* ACE_HAS_PTHREADS_STD */ # else ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (pwent); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (buflen); ACE_NOTSUP_RETURN (0); # endif /* ! ACE_LACKS_PWD_REENTRANT_FUNCTIONS */ # else ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (pwent); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (buflen); ACE_NOTSUP_RETURN (0); # endif /* ACE_HAS_REENTRANT_FUNCTIONS */ #else ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (pwent); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (buflen); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_POSIX_GETPWNAM_R */ }

ACE_INLINE int ACE_OS::getrlimit (  int    resource, struct rlimit *    rl )  [static]

Definition at line 9418 of file OS.i. References ACE_OS_TRACE, and getrlimit. Referenced by getrlimit, ACE::max_handles, and ACE::set_handle_limit. { ACE_OS_TRACE ("ACE_OS::getrlimit"); #if defined (ACE_LACKS_RLIMIT) ACE_UNUSED_ARG (resource); ACE_UNUSED_ARG (rl); ACE_NOTSUP_RETURN (-1); #else # if defined (ACE_HAS_RLIMIT_RESOURCE_ENUM) ACE_OSCALL_RETURN (::getrlimit ((ACE_HAS_RLIMIT_RESOURCE_ENUM) resource, rl), int, -1); # else ACE_OSCALL_RETURN (::getrlimit (resource, rl), int, -1); # endif /* ACE_HAS_RLIMIT_RESOURCE_ENUM */ #endif /* ACE_LACKS_RLIMIT */ }

ACE_INLINE int ACE_OS::getrusage (  int    who, struct rusage *    rusage )  [static]

Definition at line 8359 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, getrusage, rusage::ru_stime, and rusage::ru_utime. Referenced by getrusage. { ACE_OS_TRACE ("ACE_OS::getrusage"); #if defined (ACE_HAS_SYSCALL_GETRUSAGE) // This nonsense is necessary for HP/UX... ACE_OSCALL_RETURN (::syscall (SYS_GETRUSAGE, who, ru), int, -1); #elif defined (ACE_HAS_GETRUSAGE) # if defined (ACE_WIN32) ACE_UNUSED_ARG (who); FILETIME dummy_1; FILETIME dummy_2; ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::GetProcessTimes (::GetCurrentProcess(), &dummy_1, // start &dummy_2, // exited &ru->ru_stime, &ru->ru_utime), ace_result_), int, -1); # else # if defined (ACE_HAS_RUSAGE_WHO_ENUM) ACE_OSCALL_RETURN (::getrusage ((ACE_HAS_RUSAGE_WHO_ENUM) who, ru), int, -1); # else ACE_OSCALL_RETURN (::getrusage (who, ru), int, -1); # endif /* ACE_HAS_RUSAGE_WHO_ENUM */ # endif /* ACE_WIN32 */ #else who = who; ru = ru; ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSCALL_GETRUSAGE */ }

char * ACE_OS::gets (  char *    str, int    n = 0 )  [static]

Definition at line 1196 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::gets"); int c; char *s = str; if (str == 0 || n < 0) n = 0; if (n == 0) str = 0; else n--; while ((c = getchar ()) != '\n') { if (c == EOF && errno == EINTR) { # if defined (ACE_HAS_SIGNAL_SAFE_OS_CALLS) continue; # else break; # endif /* ACE_HAS_SIGNAL_SAFE_OS_CALLS */ } if (c == EOF) break; if (n > 0) n--, *s++ = c; } if (s) *s = '\0'; return (c == EOF) ? 0 : str; }

ACE_INLINE struct servent * ACE_OS::getservbyname (  const char *    svc, const char *    proto )  [static]

BSD-style <accept> (no QoS). Definition at line 5370 of file OS.i. References ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. { ACE_OS_TRACE ("ACE_OS::getservbyname"); #if defined (ACE_LACKS_GETSERVBYNAME) ACE_UNUSED_ARG (svc); ACE_UNUSED_ARG (proto); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::getservbyname (ACE_const_cast (char *, svc), ACE_const_cast (char *, proto)), struct servent *, 0); #else ACE_SOCKCALL_RETURN (::getservbyname (svc, proto), struct servent *, 0); #endif /* ACE_HAS_NONCONST_GETBY */ }

ACE_INLINE struct servent * ACE_OS::getservbyname_r (  const char *    svc, const char *    proto, struct servent *    result, ACE_SERVENT_DATA    buf )  [static]

BSD-style <accept> (no QoS). Definition at line 6094 of file OS.i. References ACE_OS_TRACE, ACE_SERVENT_DATA, and ACE_SOCKCALL_RETURN. Referenced by ACE_INET_Addr::set. { ACE_OS_TRACE ("ACE_OS::getservbyname_r"); #if defined (ACE_LACKS_GETSERVBYNAME) ACE_UNUSED_ARG (svc); ACE_UNUSED_ARG (proto); ACE_UNUSED_ARG (result); ACE_UNUSED_ARG (buf); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) # if defined (AIX) || defined (DIGITAL_UNIX) || defined (HPUX_10) ::memset (buf, 0, sizeof (ACE_SERVENT_DATA)); if (::getservbyname_r (svc, proto, result, (struct servent_data *) buf) == 0) return result; else return (struct servent *) 0; # elif defined (__GLIBC__) // GNU C library has a different signature ::memset (buf, 0, sizeof (ACE_SERVENT_DATA)); if (::getservbyname_r (svc, proto, result, buf, sizeof (ACE_SERVENT_DATA), &result) == 0) return result; else return (struct servent *) 0; # else # if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) ACE_UNUSED_ARG (result); ACE_NETDBCALL_RETURN (::getservbyname (svc, proto), struct servent *, 0, buf, sizeof (ACE_SERVENT_DATA)); # else ACE_SOCKCALL_RETURN (::getservbyname_r (svc, proto, result, buf, sizeof (ACE_SERVENT_DATA)), struct servent *, 0); # endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */ # endif /* defined (AIX) || defined (DIGITAL_UNIX) */ #elif defined (ACE_HAS_NONCONST_GETBY) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (result); ACE_SOCKCALL_RETURN (::getservbyname (ACE_const_cast (char *, svc), ACE_const_cast (char *, proto)), struct servent *, 0); #else ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (result); ACE_SOCKCALL_RETURN (::getservbyname (svc, proto), struct servent *, 0); #endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) */ }

ACE_INLINE int ACE_OS::getsockname (  ACE_HANDLE    handle, struct sockaddr *    addr, int *    addrlen )  [static]

BSD-style <accept> (no QoS). Definition at line 5391 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and getsockname. Referenced by ACE_SOCK::get_local_addr, ACE_ATM_Acceptor::get_local_addr, getsockname, and ACE_Asynch_Connector::parse_address. { ACE_OS_TRACE ("ACE_OS::getsockname"); #if defined (ACE_PSOS) && !defined (ACE_PSOS_DIAB_PPC) ACE_SOCKCALL_RETURN (::getsockname ((ACE_SOCKET) handle, (struct sockaddr_in *) addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #else ACE_SOCKCALL_RETURN (::getsockname ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #endif /* defined (ACE_PSOS) */ }

ACE_INLINE int ACE_OS::getsockopt (  ACE_HANDLE    handle, int    level, int    optname, char *    optval, int *    optlen )  [static]

BSD-style <accept> (no QoS). Definition at line 5410 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and getsockopt. Referenced by ACE_SOCK::get_option, ACE_ATM_Stream::get_vpi_vci, getsockopt, ACE_WIN32_Asynch_Connect::handle_output, ACE_POSIX_Asynch_Connect::handle_output, and ACE::handle_timed_complete. { ACE_OS_TRACE ("ACE_OS::getsockopt"); ACE_SOCKCALL_RETURN (::getsockopt ((ACE_SOCKET) handle, level, optname, optval, (ACE_SOCKET_LEN *) optlen), int, -1); }

ACE_INLINE ACE_Time_Value ACE_OS::gettimeofday (  void    )  [static]

Definition at line 616 of file OS.i. References clock_gettime, CLOCK_REALTIME, gettimeofday, timespec::tv_nsec, and timespec::tv_sec. Referenced by ACE_SPIPE_Acceptor::accept, ACE_Buffered_Svc_Handler::ACE_Buffered_Svc_Handler, ACE_Timer_Hash_T::ACE_Timer_Hash_T, ACE_TP_Token_Guard::acquire_token, ACE_High_Res_Timer::calibrate, cond_timedwait, ACE_SPIPE_Connector::connect, ACE_Dynamic_Message_Queue::dequeue_head, ACE_Dynamic_Message_Queue::enqueue_i, event_timedwait, gethrtime, ACE_High_Res_Timer::gettime, gettimeofday, ACE_High_Res_Timer::gettimeofday, ACE_TP_Token_Guard::grab_token, ACE_Log_Msg::log, mutex_lock, ACE_Timer_Wheel_T::open_i, ACE_Buffered_Svc_Handler::put, ACE::recv, ACE::recvfrom, ACE::recvmsg, ACE::recvv, ACE_Dynamic_Message_Queue::remove_messages, ACE_Async_Timer_Queue_Adapter::schedule_ualarm, sema_wait, ACE::send, ACE::sendmsg, ACE::sendto, ACE::sendv, ACE_Countdown_Time::start, ACE_Countdown_Time::stop, time, ACE::timestamp, ACE_Date_Time::update, ACE_Process_Manager::wait, and ACE_NT_Service::wait_for_service_state. { // ACE_OS_TRACE ("ACE_OS::gettimeofday"); #if !defined (ACE_HAS_WINCE)&& !defined (ACE_WIN32) timeval tv; int result = 0; #endif // !defined (ACE_HAS_WINCE)&& !defined (ACE_WIN32) #if (0) struct timespec ts; ACE_OSCALL (ACE_OS::clock_gettime (CLOCK_REALTIME, &ts), int, -1, result); tv.tv_sec = ts.tv_sec; tv.tv_usec = ts.tv_nsec / 1000L; // timespec has nsec, but timeval has usec #elif defined (ACE_HAS_WINCE) SYSTEMTIME tsys; FILETIME tfile; ::GetSystemTime (&tsys); ::SystemTimeToFileTime (&tsys, &tfile); return ACE_Time_Value (tfile); #elif defined (ACE_WIN32) FILETIME tfile; ::GetSystemTimeAsFileTime (&tfile); return ACE_Time_Value (tfile); #if 0 // From Todd Montgomery... struct _timeb tb; ::_ftime (&tb); tv.tv_sec = tb.time; tv.tv_usec = 1000 * tb.millitm; #endif /* 0 */ #elif defined (ACE_HAS_AIX_HI_RES_TIMER) timebasestruct_t tb; ::read_real_time (&tb, TIMEBASE_SZ); ::time_base_to_time (&tb, TIMEBASE_SZ); tv.tv_sec = tb.tb_high; tv.tv_usec = tb.tb_low / 1000L; #else # if defined (ACE_HAS_TIMEZONE_GETTIMEOFDAY) || \ (defined (ACE_HAS_SVR4_GETTIMEOFDAY) && !defined (m88k) && !defined (SCO)) ACE_OSCALL (::gettimeofday (&tv, 0), int, -1, result); # elif defined (VXWORKS) || defined (CHORUS) || defined (ACE_PSOS) // Assumes that struct timespec is same size as struct timeval, // which assumes that time_t is a long: it currently (VxWorks // 5.2/5.3) is. struct timespec ts; ACE_OSCALL (ACE_OS::clock_gettime (CLOCK_REALTIME, &ts), int, -1, result); tv.tv_sec = ts.tv_sec; tv.tv_usec = ts.tv_nsec / 1000L; // timespec has nsec, but timeval has usec # else ACE_OSCALL (::gettimeofday (&tv), int, -1, result); # endif /* ACE_HAS_SVR4_GETTIMEOFDAY */ #endif /* 0 */ #if !defined (ACE_HAS_WINCE)&& !defined (ACE_WIN32) if (result == -1) return -1; else return ACE_Time_Value (tv); #endif // !defined (ACE_HAS_WINCE)&& !defined (ACE_WIN32) }

ACE_Time_Value ACE_OS::gettimeofday_i (  void    )  [static, private]

ACE_INLINE uid_t ACE_OS::getuid (  void    )  [static]

Definition at line 10938 of file OS.i. References ACE_OS_TRACE, getuid, and uid_t. Referenced by getuid, and ACE_SPIPE_Addr::set. { ACE_OS_TRACE ("ACE_OS::getuid"); #if defined (VXWORKS) || defined (ACE_PSOS) // getuid() is not supported: just one user anyways return 0; # elif defined (ACE_WIN32) || defined (CHORUS) ACE_NOTSUP_RETURN (ACE_static_cast (uid_t, -1)); # else ACE_OSCALL_RETURN (::getuid (), uid_t, (uid_t) -1); # endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE struct tm * ACE_OS::gmtime (  const time_t *    clock )  [static]

Definition at line 8771 of file OS.i. References ACE_OS_TRACE. { #if !defined (ACE_HAS_WINCE) && !defined (ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) ACE_OS_TRACE ("ACE_OS::gmtime"); ACE_OSCALL_RETURN (::gmtime (t), struct tm *, 0); #else // @@ WinCE doesn't have gmtime also. ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_WINCE && !ACE_PSOS || ACE_PSOS_HAS_TIME */ }

ACE_INLINE struct tm * ACE_OS::gmtime_r (  const time_t *    clock, struct tm *    res )  [static]

Definition at line 8784 of file OS.i. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::gmtime_r"); #if defined (ACE_HAS_REENTRANT_FUNCTIONS) # if defined (DIGITAL_UNIX) ACE_OSCALL_RETURN (::_Pgmtime_r (t, res), struct tm *, 0); # elif defined (HPUX_10) return (::gmtime_r (t, res) == 0 ? res : (struct tm *) 0); # else ACE_OSCALL_RETURN (::gmtime_r (t, res), struct tm *, 0); # endif /* DIGITAL_UNIX */ #elif !defined (ACE_HAS_WINCE) && !defined(ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) struct tm *result; ACE_OSCALL (::gmtime (t), struct tm *, 0, result) ; if (result != 0) *res = *result; return res; #else // @@ Same as ACE_OS::gmtime (), you need to implement it // yourself. ACE_UNUSED_ARG (t); ACE_UNUSED_ARG (res); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

int ACE_OS::hostname (  wchar_t *    name, size_t    maxnamelen )  [static]

int ACE_OS::hostname (  char *    name, size_t    maxnamelen )  [static]

Referenced by ACE_TPQ_Entry::ACE_TPQ_Entry, ACE_INET_Addr::get_host_name_i, ACE_MEM_Addr::initialize_local, ACE_Predefined_Naming_Contexts::is_local_host, ACE_Naming_Context::open, and uname.

ACE_INLINE unsigned long ACE_OS::inet_addr (  const char *    name )  [static]

BSD-style <accept> (no QoS). Definition at line 6158 of file OS.i. References ACE_OS_TRACE, and INADDR_NONE. Referenced by inet_aton. { ACE_OS_TRACE ("ACE_OS::inet_addr"); #if defined (VXWORKS) || defined (ACE_PSOS) u_long ret = 0; u_int segment; u_int valid = 1; for (u_int i = 0; i < 4; ++i) { ret <<= 8; if (*name != '\0') { segment = 0; while (*name >= '0' && *name <= '9') { segment *= 10; segment += *name++ - '0'; } if (*name != '.' && *name != '\0') { valid = 0; break; } ret |= segment; if (*name == '.') { ++name; } } } return valid ? htonl (ret) : INADDR_NONE; #elif defined (ACE_HAS_NONCONST_GETBY) return ::inet_addr ((char *) name); #else return ::inet_addr (name); #endif /* ACE_HAS_NONCONST_GETBY */ }

int ACE_OS::inet_aton (  const char *    strptr, struct in_addr *    addr )  [static]

BSD-style <accept> (no QoS). Definition at line 4826 of file OS.cpp. References INADDR_NONE, inet_addr, inet_aton, and ACE_OS_String::strcmp. Referenced by inet_aton, inet_pton, and ACE_INET_Addr::set. { #if defined (ACE_LACKS_INET_ATON) ACE_UINT32 ip_addr = ACE_OS::inet_addr (host_name); if (ip_addr == INADDR_NONE // Broadcast addresses are weird... && ACE_OS::strcmp (host_name, "255.255.255.255") != 0) return 0; else if (addr == 0) return 0; else { addr->s_addr = ip_addr; // Network byte ordered return 1; } #elif defined (VXWORKS) // inet_aton() must returns 0 upon failure and 1 on failure, but // VxWorks inet_aton() returns OK (0) on success and ERROR (-1) on failure // like most other systems calls. We will align here. if ( host_name && addr ) { // Must reset errno first. Refer to WindRiver SPR# 34949, SPR# 36026 errnoSet(0); return ::inet_aton((char*)host_name,addr) ? 0 : 1; } return 0; #else // inet_aton() returns 0 upon failure, not -1 since -1 is a valid // address (255.255.255.255). ACE_OSCALL_RETURN (::inet_aton (host_name, addr), int, 0); #endif /* ACE_LACKS_INET_ATON */ }

ACE_INLINE char * ACE_OS::inet_ntoa (  const struct in_addr    addr )  [static]

BSD-style <accept> (no QoS). Definition at line 6204 of file OS.i. References ACE_OS_TRACE, and inet_ntoa. Referenced by ACE_INET_Addr::get_host_addr, and inet_ntoa. { ACE_OS_TRACE ("ACE_OS::inet_ntoa"); ACE_OSCALL_RETURN (::inet_ntoa (addr), char *, 0); }

ACE_INLINE const char * ACE_OS::inet_ntop (  int    family, const void *    addrptr, char *    strptr, size_t    len )  [static]

BSD-style <accept> (no QoS). Definition at line 6239 of file OS.i. References ACE_OS_TRACE, INET_ADDRSTRLEN, inet_ntop, sprintf, ACE_OS_String::strcpy, and ACE_OS_String::strlen. Referenced by ACE_INET_Addr::get_host_addr, and inet_ntop. { ACE_OS_TRACE ("ACE_OS::inet_ntop"); #if defined (ACE_HAS_IPV6) ACE_OSCALL_RETURN (::inet_ntop (family, addrptr, strptr, len), const char *, 0); #else const u_char *p = ACE_reinterpret_cast (const u_char *, addrptr); if (family == AF_INET) { char temp[INET_ADDRSTRLEN]; // Stevens uses snprintf() in his implementation but snprintf() // doesn't appear to be very portable. For now, hope that using // sprintf() will not cause any string/memory overrun problems. ACE_OS::sprintf (temp, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]); if (ACE_OS::strlen (temp) >= len) { errno = ENOSPC; return 0; // Failure } ACE_OS::strcpy (strptr, temp); return strptr; } ACE_NOTSUP_RETURN(0); #endif /* ACE_HAS_IPV6 */ }

ACE_INLINE int ACE_OS::inet_pton (  int    family, const char *    strptr, void *    addrptr )  [static]

BSD-style <accept> (no QoS). Definition at line 6214 of file OS.i. References ACE_OS_TRACE, inet_aton, inet_pton, and ACE_OS_String::memcpy. Referenced by inet_pton. { ACE_OS_TRACE ("ACE_OS::inet_pton"); #if defined (ACE_HAS_IPV6) ACE_OSCALL_RETURN (::inet_pton (family, strptr, addrptr), int, -1); #else if (family == AF_INET) { struct in_addr in_val; if (ACE_OS::inet_aton (strptr, &in_val)) { ACE_OS::memcpy (addrptr, &in_val, sizeof (struct in_addr)); return 1; // Success } return 0; // Input is not a valid presentation format } ACE_NOTSUP_RETURN(-1); #endif /* ACE_HAS_IPV6 */ }

int ACE_OS::ioctl (  ACE_HANDLE    socket, u_long    io_control_code, ACE_QoS &    ace_qos, u_long *    bytes_returned, void *    buffer_p = 0, u_long    buffer = 0, ACE_OVERLAPPED *    overlapped = 0, ACE_OVERLAPPED_COMPLETION_FUNC    func = 0 )  [static]

QoS-enabled <ioctl> when the I/O control code is either SIO_SET_QOS or SIO_GET_QOS. Definition at line 7507 of file OS.cpp. References ACE_NEW_RETURN, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, ACE_SOCKCALL_RETURN, iovec::iov_len, ACE_QoS::provider_specific, ACE_QoS::receiving_flowspec, ACE_QoS::sending_flowspec, and socket. { # if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) QOS qos; u_long qos_len = sizeof (QOS); if (io_control_code == SIO_SET_QOS) { qos.SendingFlowspec = *(ace_qos.sending_flowspec ()); qos.ReceivingFlowspec = *(ace_qos.receiving_flowspec ()); qos.ProviderSpecific = (WSABUF) ace_qos.provider_specific (); qos_len += ace_qos.provider_specific ().iov_len; ACE_SOCKCALL_RETURN (::WSAIoctl ((ACE_SOCKET) socket, io_control_code, &qos, qos_len, buffer_p, buffer, bytes_returned, (WSAOVERLAPPED *) overlapped, func), int, SOCKET_ERROR); } else { u_long dwBufferLen = 0; // Query for the buffer size. int result = ::WSAIoctl ((ACE_SOCKET) socket, io_control_code, NULL, 0, &dwBufferLen, sizeof (dwBufferLen), bytes_returned, NULL, NULL); if (result == SOCKET_ERROR) { u_long dwErr = ::WSAGetLastError (); if (dwErr == WSAEWOULDBLOCK) { errno = dwErr; return -1; } else if (dwErr != WSAENOBUFS) { errno = dwErr; return -1; } } char *qos_buf; ACE_NEW_RETURN (qos_buf, char [dwBufferLen], -1); QOS *qos = ACE_reinterpret_cast (QOS*, qos_buf); result = ::WSAIoctl ((ACE_SOCKET) socket, io_control_code, NULL, 0, qos, dwBufferLen, bytes_returned, NULL, NULL); if (result == SOCKET_ERROR) return result; ACE_Flow_Spec sending_flowspec (qos->SendingFlowspec.TokenRate, qos->SendingFlowspec.TokenBucketSize, qos->SendingFlowspec.PeakBandwidth, qos->SendingFlowspec.Latency, qos->SendingFlowspec.DelayVariation, # if defined(ACE_HAS_WINSOCK2_GQOS) qos->SendingFlowspec.ServiceType, qos->SendingFlowspec.MaxSduSize, qos->SendingFlowspec.MinimumPolicedSize, # else /* ACE_HAS_WINSOCK2_GQOS */ 0, 0, 0, # endif /* ACE_HAS_WINSOCK2_GQOS */ 0, 0); ACE_Flow_Spec receiving_flowspec (qos->ReceivingFlowspec.TokenRate, qos->ReceivingFlowspec.TokenBucketSize, qos->ReceivingFlowspec.PeakBandwidth, qos->ReceivingFlowspec.Latency, qos->ReceivingFlowspec.DelayVariation, # if defined(ACE_HAS_WINSOCK2_GQOS) qos->ReceivingFlowspec.ServiceType, qos->ReceivingFlowspec.MaxSduSize, qos->ReceivingFlowspec.MinimumPolicedSize, # else /* ACE_HAS_WINSOCK2_GQOS */ 0, 0, 0, # endif /* ACE_HAS_WINSOCK2_GQOS */ 0, 0); ace_qos.sending_flowspec (&sending_flowspec); ace_qos.receiving_flowspec (&receiving_flowspec); ace_qos.provider_specific (*((struct iovec *) (&qos->ProviderSpecific))); return result; } # else ACE_UNUSED_ARG (socket); ACE_UNUSED_ARG (io_control_code); ACE_UNUSED_ARG (ace_qos); ACE_UNUSED_ARG (bytes_returned); ACE_UNUSED_ARG (buffer_p); ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (overlapped); ACE_UNUSED_ARG (func); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_WINSOCK2 */ }

int ACE_OS::ioctl (  ACE_HANDLE    socket, u_long    io_control_code, void *    in_buffer_p, u_long    in_buffer, void *    out_buffer_p, u_long    out_buffer, u_long *    bytes_returned, ACE_OVERLAPPED *    overlapped, ACE_OVERLAPPED_COMPLETION_FUNC    func )  [static]

QoS-enabled <ioctl>. Definition at line 7469 of file OS.cpp. References ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, ACE_SOCKCALL_RETURN, and socket. { # if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) ACE_SOCKCALL_RETURN (::WSAIoctl ((ACE_SOCKET) socket, io_control_code, in_buffer_p, in_buffer, out_buffer_p, out_buffer, bytes_returned, (WSAOVERLAPPED *) overlapped, func), int, SOCKET_ERROR); # else ACE_UNUSED_ARG (socket); ACE_UNUSED_ARG (io_control_code); ACE_UNUSED_ARG (in_buffer_p); ACE_UNUSED_ARG (in_buffer); ACE_UNUSED_ARG (out_buffer_p); ACE_UNUSED_ARG (out_buffer); ACE_UNUSED_ARG (bytes_returned); ACE_UNUSED_ARG (overlapped); ACE_UNUSED_ARG (func); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::ioctl (  ACE_HANDLE    handle, int    cmd, void *    = 0 )  [static]

UNIX-style <ioctl>. Definition at line 10109 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ioctl. Referenced by ACE_SPIPE_Acceptor::accept, ACE_Dev_Poll_Reactor::close, ACE_Flag_Manip::clr_flags, ACE_TLI_Connector::complete, ACE_TLI_Connector::connect, ACE_IPC_SAP::control, ACE_IO_SAP::control, ACE_Sock_Connect::count_interfaces, ACE_SPIPE_Acceptor::create_new_instance, ACE_IPC_SAP::disable, ACE_IPC_SAP::enable, ACE_Sock_Connect::get_bcast_addr, ACE_Sock_Connect::get_ip_interfaces, ACE_TLI::get_local_addr, ACE_TLI_Stream::get_remote_addr, ioctl, ACE_SOCK_Dgram_Mcast::make_multicast_ifaddr, ACE_SOCK_Dgram_Bcast::mk_broadcast, ACE_Pipe::open, ACE_Dev_Poll_Reactor::open, ACE_ATM_Acceptor::open, open_new_endpoint, ACE_SOCK_Dgram::recv, ACE_SPIPE_Stream::recv_handle, ACE_SOCK_IO::recvv, ACE_SPIPE_Stream::send_handle, ACE_Flag_Manip::set_flags, ACE_SOCK_Dgram::set_nic, and ACE_Dev_Poll_Reactor::work_pending_i. { ACE_OS_TRACE ("ACE_OS::ioctl"); #if defined (ACE_WIN32) ACE_SOCKET sock = (ACE_SOCKET) handle; ACE_SOCKCALL_RETURN (::ioctlsocket (sock, cmd, (u_long *) val), int, -1); #elif defined (VXWORKS) ACE_OSCALL_RETURN (::ioctl (handle, cmd, ACE_reinterpret_cast (int, val)), int, -1); #elif defined (ACE_PSOS) ACE_OSCALL_RETURN (::ioctl (handle, cmd, (char *) val), int, -1); #elif defined (__CYGWIN32__) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (val); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::ioctl (handle, cmd, val), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::isastream (  ACE_HANDLE    handle )  [static]

Definition at line 8394 of file OS.i. References ACE_OS_TRACE, and isastream. Referenced by ACE_UPIPE_Connector::connect, and isastream. { ACE_OS_TRACE ("ACE_OS::isastream"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::isastream (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_STREAM_PIPES */ }

int ACE_OS::isatty (  ACE_HANDLE    handle )  [static]

ACE_INLINE int ACE_OS::isatty (  int    handle )  [static]

Definition at line 10990 of file OS.i. References ACE_OS_TRACE, and isatty. Referenced by isatty. { #if defined (ACE_LACKS_ISATTY) ACE_UNUSED_ARG (handle); return 0; # elif defined (ACE_WIN32) ACE_OS_TRACE ("ACE_OS::isatty"); return ::_isatty (handle); # else ACE_OS_TRACE ("ACE_OS::isatty"); ACE_OSCALL_RETURN (::isatty (handle), int, -1); # endif /* defined (ACE_LACKS_ISATTY) */ }

ACE_HANDLE ACE_OS::join_leaf (  ACE_HANDLE    socket, const sockaddr *    name, int    namelen, const ACE_QoS_Params &    qos_params )  [static]

Joins a leaf node into a QoS-enabled multi-point session. Definition at line 7434 of file OS.cpp. References ACE_SOCKCALL_RETURN, ACE_QoS_Params::callee_data, ACE_QoS_Params::caller_data, ACE_QoS_Params::flags, ACE_QoS_Params::group_socket_qos, ACE_QoS::provider_specific, ACE_QoS::receiving_flowspec, ACE_QoS::sending_flowspec, socket, and ACE_QoS_Params::socket_qos. Referenced by ACE_ATM_Connector::add_leaf. { # if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) QOS qos; // Construct the WinSock2 QOS structure. qos.SendingFlowspec = *(qos_params.socket_qos ()->sending_flowspec ()); qos.ReceivingFlowspec = *(qos_params.socket_qos ()->receiving_flowspec ()); qos.ProviderSpecific = (WSABUF) qos_params.socket_qos ()->provider_specific (); ACE_SOCKCALL_RETURN (::WSAJoinLeaf ((ACE_SOCKET) socket, name, namelen, (WSABUF *) qos_params.caller_data (), (WSABUF *) qos_params.callee_data (), &qos, (QOS *) qos_params.group_socket_qos (), qos_params.flags ()), ACE_HANDLE, ACE_INVALID_HANDLE); # else ACE_UNUSED_ARG (socket); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (namelen); ACE_UNUSED_ARG (qos_params); ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE); # endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::kill (  pid_t    pid, int    signum )  [static]

Definition at line 10134 of file OS.i. References ACE_OS_TRACE, kill, and pid_t. Referenced by ACE_Process::kill, kill, ACE::process_active, ACE_Process::running, ACE_Process_Manager::terminate, ACE::terminate_process, and thr_kill. { ACE_OS_TRACE ("ACE_OS::kill"); #if defined (ACE_WIN32) || defined (CHORUS) || defined (ACE_PSOS) ACE_UNUSED_ARG (pid); ACE_UNUSED_ARG (signum); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::kill (pid, signum), int, -1); #endif /* ACE_WIN32 || CHORUS || ACE_PSOS */ }

ACE_INLINE void ACE_OS::last_error (  int    )  [static]

Definition at line 6327 of file OS.i. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::last_error"); #if defined (ACE_WIN32) ::SetLastError (error); #else errno = error; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::last_error (  void    )  [static]

Definition at line 6313 of file OS.i. Referenced by ACE_Log_Msg::last_error_adapter, set_errno_to_last_error, set_errno_to_wsa_last_error, and set_scheduling_params. { // ACE_OS_TRACE ("ACE_OS::last_error"); #if defined (ACE_WIN32) int lerror = ::GetLastError (); int lerrno = errno; return lerrno == 0 ? lerror : lerrno; #else return errno; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::listen (  ACE_HANDLE    handle, int    backlog )  [static]

BSD-style <accept> (no QoS). Definition at line 5427 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and listen. Referenced by listen, ACE_ATM_Acceptor::open, ACE_Asynch_Acceptor::open, and ACE_SOCK_Acceptor::shared_open. { ACE_OS_TRACE ("ACE_OS::listen"); ACE_SOCKCALL_RETURN (::listen ((ACE_SOCKET) handle, backlog), int, -1); }

ACE_INLINE struct tm * ACE_OS::localtime (  const time_t *    clock )  [static]

Definition at line 8757 of file OS.i. References ACE_OS_TRACE. Referenced by ctime. { #if !defined (ACE_HAS_WINCE) && !defined (ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) ACE_OS_TRACE ("ACE_OS::localtime"); ACE_OSCALL_RETURN (::localtime (t), struct tm *, 0); #else // @@ Don't you start wondering what kind of functions // does WinCE really support? ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_WINCE && !ACE_PSOS || ACE_PSOS_HAS_TIME */ }

struct tm * ACE_OS::localtime_r (  const time_t *    clock, struct tm *    res )  [static]

Definition at line 4861 of file OS.cpp. References ACE_OS_GUARD, and ACE_OS_TRACE. Referenced by ACE_Date_Time::update. { ACE_OS_TRACE ("ACE_OS::localtime_r"); #if defined (ACE_HAS_REENTRANT_FUNCTIONS) # if defined (DIGITAL_UNIX) ACE_OSCALL_RETURN (::_Plocaltime_r (t, res), struct tm *, 0); # elif defined (HPUX_10) return (::localtime_r (t, res) == 0 ? res : (struct tm *)0); # else ACE_OSCALL_RETURN (::localtime_r (t, res), struct tm *, 0); # endif /* DIGITAL_UNIX */ #elif !defined (ACE_HAS_WINCE) && !defined(ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) ACE_OS_GUARD ACE_UNUSED_ARG (res); struct tm * res_ptr; ACE_OSCALL (::localtime (t), struct tm *, 0, res_ptr); if (res_ptr == 0) return 0; else { *res = *res_ptr; return res; } #else // @@ Same as ACE_OS::localtime (), you need to implement it // yourself. ACE_UNUSED_ARG (t); ACE_UNUSED_ARG (res); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

ACE_INLINE off_t ACE_OS::lseek (  ACE_HANDLE    handle, off_t    offset, int    whence )  [static]

Definition at line 9837 of file OS.i. References ACE_OS_TRACE, ACE_SYSCALL_FAILED, and lseek. Referenced by ACE_MMAP_Memory_Pool::commit_backing_store_name, lseek, pread, ACE_MMAP_Memory_Pool::protect, pwrite, ACE_FILE::seek, ACE_MMAP_Memory_Pool::sync, ACE_FILE::tell, and ACE_Mem_Map::unmap. { ACE_OS_TRACE ("ACE_OS::lseek"); #if defined (ACE_WIN32) # if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END //#error Windows NT is evil AND rude! switch (whence) { case SEEK_SET: whence = FILE_BEGIN; break; case SEEK_CUR: whence = FILE_CURRENT; break; case SEEK_END: whence = FILE_END; break; default: errno = EINVAL; return ACE_static_cast (off_t, -1); // rather safe than sorry } # endif /* SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END */ DWORD result = ::SetFilePointer (handle, offset, 0, whence); if (result == ACE_SYSCALL_FAILED) ACE_FAIL_RETURN (ACE_static_cast (off_t, -1)); else return result; #elif defined (ACE_PSOS) # if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (offset); ACE_UNUSED_ARG (whence); ACE_NOTSUP_RETURN (ACE_static_cast (off_t, -1)); # else unsigned long oldptr, newptr, result; // seek to the requested position result = ::lseek_f (handle, whence, offset, &oldptr); if (result != 0) { errno = result; return ACE_static_cast (off_t, -1); } // now do a dummy seek to the current position to obtain the position result = ::lseek_f (handle, SEEK_CUR, 0, &newptr); if (result != 0) { errno = result; return ACE_static_cast (off_t, -1); } return ACE_static_cast (off_t, newptr); # endif /* defined (ACE_PSOS_LACKS_PHILE */ #else ACE_OSCALL_RETURN (::lseek (handle, offset, whence), off_t, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::lstat (  const char *   , ACE_stat *    )  [static]

Definition at line 329 of file OS.i. References ACE_OS_TRACE, ACE_stat, and lstat. Referenced by lstat. { ACE_OS_TRACE ("ACE_OS::lstat"); # if defined (ACE_LACKS_LSTAT) || \ defined (ACE_HAS_WINCE) || defined (ACE_WIN32) ACE_UNUSED_ARG (file); ACE_UNUSED_ARG (stp); ACE_NOTSUP_RETURN (-1); # else # if defined (ACE_HAS_X86_STAT_MACROS) // Solaris for intel uses an macro for lstat(), this macro is a // wrapper for _lxstat(). ACE_OSCALL_RETURN (::_lxstat (_STAT_VER, file, stp), int, -1); # elif defined (ACE_WIN32) ACE_OSCALL_RETURN (::_lstat (file, stp), int, -1); # else /* !ACE_HAS_X86_STAT_MACROS */ ACE_OSCALL_RETURN (::lstat (file, stp), int, -1); # endif /* !ACE_HAS_X86_STAT_MACROS */ # endif /* ACE_LACKS_LSTAT */ }

int ACE_OS::lwp_getparams (  ACE_Sched_Params &    )  [static]

Definition at line 3497 of file OS.cpp. References ACE_id_t, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_SCOPE_THREAD, ACE_OS_String::memcpy, ACE_OS_String::memset, ACE_Sched_Params::policy, ACE_Sched_Params::priority, priority_control, ACE_Sched_Params::quantum, scheduling_class, and ACE_Sched_Params::scope. Referenced by thr_setprio. { # if defined (ACE_HAS_STHREADS) || defined (sun) // Get the class TS and RT class IDs. ACE_id_t rt_id; ACE_id_t ts_id; if (ACE_OS::scheduling_class ("RT", rt_id) == -1 || ACE_OS::scheduling_class ("TS", ts_id) == -1) return -1; // Get this LWP's scheduling parameters. pcparms_t pcparms; // The following is just to avoid Purify warnings about unitialized // memory reads. ACE_OS::memset (&pcparms, 0, sizeof pcparms); pcparms.pc_cid = PC_CLNULL; if (ACE_OS::priority_control (P_LWPID, P_MYID, PC_GETPARMS, (char *) &pcparms) == -1) return -1; else if (pcparms.pc_cid == rt_id) { // RT class. rtparms_t rtparms; ACE_OS::memcpy (&rtparms, pcparms.pc_clparms, sizeof rtparms); sched_params.policy (ACE_SCHED_FIFO); sched_params.priority (rtparms.rt_pri); sched_params.scope (ACE_SCOPE_THREAD); ACE_Time_Value quantum (rtparms.rt_tqsecs, rtparms.rt_tqnsecs == RT_TQINF ? 0 : rtparms.rt_tqnsecs * 1000); sched_params.quantum (quantum); return 0; } else if (pcparms.pc_cid == ts_id) { /* TS class */ tsparms_t tsparms; ACE_OS::memcpy (&tsparms, pcparms.pc_clparms, sizeof tsparms); sched_params.policy (ACE_SCHED_OTHER); sched_params.priority (tsparms.ts_upri); sched_params.scope (ACE_SCOPE_THREAD); return 0; } else return -1; # else /* ! ACE_HAS_STHREADS && ! sun */ ACE_UNUSED_ARG (sched_params); ACE_NOTSUP_RETURN (-1); # endif /* ! ACE_HAS_STHREADS && ! sun */ }

int ACE_OS::lwp_setparams (  const ACE_Sched_Params &    )  [static]

Definition at line 3555 of file OS.cpp. References ACE_SCOPE_LWP, sched_params, and ACE_Sched_Params::scope. Referenced by thr_create, and thr_setprio. { # if defined (ACE_HAS_STHREADS) || defined (sun) ACE_Sched_Params lwp_params (sched_params); lwp_params.scope (ACE_SCOPE_LWP); return ACE_OS::sched_params (lwp_params); # else /* ! ACE_HAS_STHREADS && ! sun */ ACE_UNUSED_ARG (sched_params); ACE_NOTSUP_RETURN (-1); # endif /* ! ACE_HAS_STHREADS && ! sun */ }

ACE_INLINE int ACE_OS::madvise (  caddr_t    addr, size_t    len, int    advice )  [static]

Definition at line 8469 of file OS.i. References ACE_OS_TRACE, caddr_t, and madvise. Referenced by ACE_Mem_Map::advise, and madvise. { ACE_OS_TRACE ("ACE_OS::madvise"); #if defined (ACE_WIN32) ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (advice); ACE_NOTSUP_RETURN (-1); #elif !defined (ACE_LACKS_MADVISE) ACE_OSCALL_RETURN (::madvise (addr, len, advice), int, -1); #else ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (advice); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::mkdir (  const ACE_TCHAR *    path, mode_t    mode = ACE_DEFAULT_DIR_PERMS )  [static]

Definition at line 10398 of file OS.i. References ACE_ADAPT_RETVAL, ACE_TCHAR, ACE_OS_Memory::free, ACE_OS_Memory::malloc, mkdir, mode_t, printf, ACE_OS_String::strcpy, and ACE_OS_String::strlen. Referenced by mkdir. { #if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_PSOS) //The pSOS make_dir fails if the last character is a '/' int location; char *phile_path; phile_path = (char *)ACE_OS::malloc(strlen(path)); if (phile_path == 0) { ACE_OS::printf ("malloc in make_dir failed: [%X]\n", errno); return -1; } else ACE_OS::strcpy (phile_path, path); location = ACE_OS::strlen(phile_path); if(phile_path[location-1] == '/') { phile_path[location-1] = 0; } u_long result; result = ::make_dir ((char *) phile_path, mode); if (result == 0x2011) // Directory already exists { result = 0; } else if (result != 0) { result = -1; } ACE_OS::free(phile_path); return result; #elif defined (VXWORKS) ACE_UNUSED_ARG (mode); ACE_OSCALL_RETURN (::mkdir ((char *) path), int, -1); #elif defined (ACE_WIN32) && defined (__IBMCPP__) && (__IBMCPP__ >= 400) ACE_UNUSED_ARG (mode); ACE_OSCALL_RETURN (::_mkdir ((char *) path), int, -1); #elif defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (mode); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CreateDirectory (path, 0), ace_result_), int, -1); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_UNUSED_ARG (mode); ACE_OSCALL_RETURN (::_wmkdir (path), int, -1); #elif defined (ACE_WIN32) ACE_UNUSED_ARG (mode); ACE_OSCALL_RETURN (::mkdir (path), int, -1); #else ACE_OSCALL_RETURN (::mkdir (path, mode), int, -1); #endif /* ACE_PSOS_LACKS_PHILE */ }

ACE_INLINE int ACE_OS::mkfifo (  const ACE_TCHAR *    file, mode_t    mode = ACE_DEFAULT_FILE_PERMS )  [static]

Definition at line 223 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, mkfifo, and mode_t. Referenced by mkfifo, and ACE_FIFO::open. { ACE_OS_TRACE ("ACE_OS::mkfifo"); #if defined (ACE_LACKS_MKFIFO) ACE_UNUSED_ARG (file); ACE_UNUSED_ARG (mode); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::mkfifo (file, mode), int, -1); #endif /* ACE_LACKS_MKFIFO */ }

ACE_INLINE ACE_HANDLE ACE_OS::mkstemp (  ACE_TCHAR *    t )  [static]

Definition at line 216 of file OS.i. References ACE_TCHAR. Referenced by ACE_FILE_Connector::connect. { return ::mkstemp (s); }

ACE_INLINE ACE_TCHAR * ACE_OS::mktemp (  ACE_TCHAR *    t )  [static]

Definition at line 202 of file OS.i. References ACE_TCHAR. Referenced by ACE_FILE_Addr::set. { # if defined (ACE_WIN32) && defined (ACE_USES_WCHAR) return ::_wmktemp (s); # elif defined (ACE_WIN32) return ::_mktemp (s); # else /* ACE_WIN32 */ return ::mktemp (s); # endif /* ACE_WIN32 */ }

time_t ACE_OS::mktime (  struct tm *    timeptr )  [static]

Definition at line 5545 of file OS.cpp. References ACE_OS_GUARD, ACE_OS_TRACE, mktime, and ACE_Time_Value::sec. Referenced by mktime. { ACE_OS_TRACE ("ACE_OS::mktime"); # if defined (ACE_PSOS) && ! defined (ACE_PSOS_HAS_TIME) ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_WINCE) SYSTEMTIME t_sys; FILETIME t_file; t_sys.wSecond = t->tm_sec; t_sys.wMinute = t->tm_min; t_sys.wHour = t->tm_hour; t_sys.wDay = t->tm_mday; t_sys.wMonth = t->tm_mon + 1; // SYSTEMTIME is 1-indexed, tm is 0-indexed t_sys.wYear = t->tm_year + 1900; // SYSTEMTIME is real; tm is since 1900 t_sys.wDayOfWeek = t->tm_wday; // Ignored in below function call. if (SystemTimeToFileTime (&t_sys, &t_file) == 0) return -1; ACE_Time_Value tv (t_file); return tv.sec (); # else # if defined (ACE_HAS_THREADS) && !defined (ACE_HAS_MT_SAFE_MKTIME) ACE_OS_GUARD # endif /* ACE_HAS_THREADS && ! ACE_HAS_MT_SAFE_MKTIME */ ACE_OSCALL_RETURN (::mktime (t), time_t, (time_t) -1); # endif /* ACE_PSOS && ! ACE_PSOS_HAS_TIME */ }

ACE_INLINE void * ACE_OS::mmap (  void *    addr, size_t    len, int    prot, int    flags, ACE_HANDLE    handle, off_t    off = 0, ACE_HANDLE *    file_mapping = 0, LPSECURITY_ATTRIBUTES    sa = 0, const ACE_TCHAR *    file_mapping_name = 0 )  [static]

Definition at line 2885 of file OS.i. References ACE_BIT_ENABLED, ACE_DEFAULT_FILE_PERMS, ACE_MMAP_TYPE, ACE_OS_TRACE, ACE_TCHAR, default_win32_security_attributes, filesize, MAP_FAILED, MAP_FIXED, MAP_PRIVATE, MAP_SHARED, and sprintf. Referenced by ACE_Condition::ACE_Condition, ACE_Mutex::ACE_Mutex, flock_init, ACE_Mem_Map::map_it, ACE_Dev_Poll_Reactor::open, and sema_init. { ACE_OS_TRACE ("ACE_OS::mmap"); #if !defined (ACE_WIN32) || defined (ACE_HAS_PHARLAP) ACE_UNUSED_ARG (file_mapping_name); #endif /* !defined (ACE_WIN32) || defined (ACE_HAS_PHARLAP) */ #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP) # if defined(ACE_HAS_WINCE) ACE_UNUSED_ARG (addr); if (ACE_BIT_ENABLED (flags, MAP_FIXED)) // not supported { errno = EINVAL; return MAP_FAILED; } # else if (!ACE_BIT_ENABLED (flags, MAP_FIXED)) addr = 0; else if (addr == 0) // can not map to address 0 { errno = EINVAL; return MAP_FAILED; } # endif int nt_flags = 0; ACE_HANDLE local_handle = ACE_INVALID_HANDLE; // Ensure that file_mapping is non-zero. if (file_mapping == 0) file_mapping = &local_handle; if (ACE_BIT_ENABLED (flags, MAP_PRIVATE)) { # if !defined(ACE_HAS_WINCE) prot = PAGE_WRITECOPY; # endif // ACE_HAS_WINCE nt_flags = FILE_MAP_COPY; } else if (ACE_BIT_ENABLED (flags, MAP_SHARED)) { if (ACE_BIT_ENABLED (prot, PAGE_READONLY)) nt_flags = FILE_MAP_READ; if (ACE_BIT_ENABLED (prot, PAGE_READWRITE)) nt_flags = FILE_MAP_WRITE; } // Only create a new handle if we didn't have a valid one passed in. if (*file_mapping == ACE_INVALID_HANDLE) { # if !defined(ACE_HAS_WINCE) && (!defined (ACE_HAS_WINNT4) || (ACE_HAS_WINNT4 == 0)) int try_create = 1; if ((file_mapping_name != 0) && (*file_mapping_name != 0)) { // On Win9x, we first try to OpenFileMapping to // file_mapping_name. Only if there is no mapping object // with that name, and the desired name is valid, do we try // CreateFileMapping. *file_mapping = ACE_TEXT_OpenFileMapping (nt_flags, 0, file_mapping_name); if (*file_mapping != 0 || (::GetLastError () == ERROR_INVALID_NAME && ::GetLastError () == ERROR_FILE_NOT_FOUND)) try_create = 0; } if (try_create) # endif /* !ACE_HAS_WINCE && (ACE_HAS_WINNT4 || ACE_HAS_WINNT4 == 0) */ { const LPSECURITY_ATTRIBUTES attr = ACE_OS::default_win32_security_attributes (sa); *file_mapping = ACE_TEXT_CreateFileMapping (file_handle, attr, prot, 0, 0, file_mapping_name); } } if (*file_mapping == 0) ACE_FAIL_RETURN (MAP_FAILED); # if defined (ACE_OS_EXTRA_MMAP_FLAGS) nt_flags |= ACE_OS_EXTRA_MMAP_FLAGS; # endif /* ACE_OS_EXTRA_MMAP_FLAGS */ # if !defined (ACE_HAS_WINCE) void *addr_mapping = ::MapViewOfFileEx (*file_mapping, nt_flags, 0, off, len, addr); # else void *addr_mapping = ::MapViewOfFile (*file_mapping, nt_flags, 0, off, len); # endif /* ! ACE_HAS_WINCE */ // Only close this down if we used the temporary. if (file_mapping == &local_handle) ::CloseHandle (*file_mapping); if (addr_mapping == 0) ACE_FAIL_RETURN (MAP_FAILED); else return addr_mapping; #elif defined (__Lynx__) // The LynxOS 2.5.0 mmap doesn't allow operations on plain // file descriptors. So, create a shm object and use that. ACE_UNUSED_ARG (sa); char name [128]; sprintf (name, "%d", file_handle); // Assumes that this was called by ACE_Mem_Map, so &file_mapping != // 0. Otherwise, we don't support the incomplete LynxOS mmap // implementation. We do support it by creating a hidden shared // memory object, and using that for the mapping. int shm_handle; if (! file_mapping) file_mapping = &shm_handle; if ((*file_mapping = ::shm_open (name, O_RDWR | O_CREAT | O_TRUNC, ACE_DEFAULT_FILE_PERMS)) == -1) return MAP_FAILED; else { // The size of the shared memory object must be explicitly set on LynxOS. const off_t filesize = ACE_OS::filesize (file_handle); if (::ftruncate (*file_mapping, filesize) == -1) return MAP_FAILED; else { # if defined (ACE_OS_EXTRA_MMAP_FLAGS) flags |= ACE_OS_EXTRA_MMAP_FLAGS; # endif /* ACE_OS_EXTRA_MMAP_FLAGS */ char *map = (char *) ::mmap ((ACE_MMAP_TYPE) addr, len, prot, flags, *file_mapping, off); if (map == MAP_FAILED) return MAP_FAILED; else // Finally, copy the file contents to the shared memory object. return ::read (file_handle, map, (int) filesize) == filesize ? map : MAP_FAILED; } } #elif !defined (ACE_LACKS_MMAP) ACE_UNUSED_ARG (sa); # if defined (ACE_OS_EXTRA_MMAP_FLAGS) flags |= ACE_OS_EXTRA_MMAP_FLAGS; # endif /* ACE_OS_EXTRA_MMAP_FLAGS */ ACE_UNUSED_ARG (file_mapping); ACE_OSCALL_RETURN ((void *) ::mmap ((ACE_MMAP_TYPE) addr, len, prot, flags, file_handle, off), void *, MAP_FAILED); #else ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (prot); ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (file_handle); ACE_UNUSED_ARG (off); ACE_UNUSED_ARG (file_mapping); ACE_UNUSED_ARG (sa); ACE_NOTSUP_RETURN (MAP_FAILED); #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */ }

ACE_INLINE int ACE_OS::mprotect (  void *    addr, size_t    len, int    prot )  [static]

Definition at line 8412 of file OS.i. References ACE_MMAP_TYPE, ACE_OS_TRACE, and mprotect. Referenced by mprotect, ACE_MMAP_Memory_Pool::protect, and ACE_Mem_Map::protect. { ACE_OS_TRACE ("ACE_OS::mprotect"); #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP) DWORD dummy; // Sigh! return ::VirtualProtect(addr, len, prot, &dummy) ? 0 : -1; #elif !defined (ACE_LACKS_MPROTECT) ACE_OSCALL_RETURN (::mprotect ((ACE_MMAP_TYPE) addr, len, prot), int, -1); #else ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (prot); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */ }

ACE_INLINE int ACE_OS::msgctl (  int    msqid, int    cmd, struct msqid_ds *    )  [static]

Definition at line 7826 of file OS.i. References ACE_OS_TRACE, and msgctl. Referenced by ACE_SV_Message_Queue::control, and msgctl. { ACE_OS_TRACE ("ACE_OS::msgctl"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::msgctl (msqid, cmd, val), int, -1); #else ACE_UNUSED_ARG (msqid); ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (val); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::msgget (  key_t    key, int    msgflg )  [static]

Definition at line 7841 of file OS.i. References ACE_OS_TRACE, and msgget. Referenced by msgget, and ACE_SV_Message_Queue::open. { ACE_OS_TRACE ("ACE_OS::msgget"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::msgget (key, msgflg), int, -1); #else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (msgflg); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::msgrcv (  int    int_id, void *    buf, size_t    len, long    type, int    flags )  [static]

Definition at line 7855 of file OS.i. References ACE_OS_TRACE, and msgrcv. Referenced by msgrcv, and ACE_SV_Message_Queue::recv. { ACE_OS_TRACE ("ACE_OS::msgrcv"); #if defined (ACE_HAS_SYSV_IPC) # if defined (ACE_LACKS_POSIX_PROTOTYPES) || defined (ACE_LACKS_SOME_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::msgrcv (int_id, (msgbuf *) buf, len, type, flags), int, -1); # else ACE_OSCALL_RETURN (::msgrcv (int_id, buf, len, type, flags), int, -1); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ #else ACE_UNUSED_ARG (int_id); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::msgsnd (  int    int_id, const void *    buf, size_t    len, int    flags )  [static]

Definition at line 7879 of file OS.i. References ACE_OS_TRACE, and msgsnd. Referenced by msgsnd, and ACE_SV_Message_Queue::send. { ACE_OS_TRACE ("ACE_OS::msgsnd"); #if defined (ACE_HAS_SYSV_IPC) # if defined (ACE_HAS_NONCONST_MSGSND) ACE_OSCALL_RETURN (::msgsnd (int_id, (void *) buf, len, flags), int, -1); # elif defined (ACE_LACKS_POSIX_PROTOTYPES) || defined (ACE_LACKS_SOME_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::msgsnd (int_id, (msgbuf *) buf, len, flags), int, -1); # else ACE_OSCALL_RETURN (::msgsnd (int_id, buf, len, flags), int, -1); # endif /* ACE_LACKS_POSIX_PROTOTYPES || ACE_HAS_NONCONST_MSGSND */ #else ACE_UNUSED_ARG (int_id); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::msync (  void *    addr, size_t    len, int    sync )  [static]

Definition at line 8429 of file OS.i. References ACE_ADAPT_RETVAL, ACE_MMAP_TYPE, ACE_OS_TRACE, and msync. Referenced by msync, ACE_MMAP_Memory_Pool::sync, and ACE_Mem_Map::sync. { ACE_OS_TRACE ("ACE_OS::msync"); #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP) ACE_UNUSED_ARG (sync); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushViewOfFile (addr, len), ace_result_), int, -1); #elif !defined (ACE_LACKS_MSYNC) # if !defined (ACE_HAS_BROKEN_NETBSD_MSYNC) ACE_OSCALL_RETURN (::msync ((ACE_MMAP_TYPE) addr, len, sync), int, -1); # else ACE_OSCALL_RETURN (::msync ((ACE_MMAP_TYPE) addr, len), int, -1); ACE_UNUSED_ARG (sync); # endif /* ACE_HAS_BROKEN_NETBSD_MSYNC */ #else ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (sync); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */ }

ACE_INLINE int ACE_OS::munmap (  void *    addr, size_t    len )  [static]

Definition at line 8452 of file OS.i. References ACE_ADAPT_RETVAL, ACE_MMAP_TYPE, ACE_OS_TRACE, and munmap. Referenced by ACE_Dev_Poll_Reactor::close, flock_destroy, munmap, ACE_Condition::remove, ACE_Mutex::remove, and ACE_Mem_Map::unmap. { ACE_OS_TRACE ("ACE_OS::munmap"); #if defined (ACE_WIN32) ACE_UNUSED_ARG (len); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::UnmapViewOfFile (addr), ace_result_), int, -1); #elif !defined (ACE_LACKS_MMAP) ACE_OSCALL_RETURN (::munmap ((ACE_MMAP_TYPE) addr, len), int, -1); #else ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::mutex_destroy (  ACE_mutex_t *    m )  [static]

Definition at line 1327 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, mutex_destroy, and thread_mutex_destroy. Referenced by event_destroy, flock_destroy, mutex_destroy, ACE_Mutex::remove, rwlock_destroy, sema_destroy, sema_init, and thread_mutex_destroy. { ACE_OS_TRACE ("ACE_OS::mutex_destroy"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if (defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6)) ACE_OSCALL_RETURN (::pthread_mutex_destroy (m), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_mutex_destroy (m), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6*/ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_destroy (m), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) switch (m->type_) { case USYNC_PROCESS: ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (m->proc_mutex_), ace_result_), int, -1); case USYNC_THREAD: return ACE_OS::thread_mutex_destroy (&m->thr_mutex_); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_PSOS) # if defined (ACE_PSOS_HAS_MUTEX) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mu_delete (*m), ace_result_), int, -1); # else /* ! ACE_PSOS_HAS_MUTEX */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sm_delete (*m), ace_result_), int, -1); # endif /* ACE_PSOS_HAS_MUTEX */ # elif defined (VXWORKS) return ::semDelete (*m) == OK ? 0 : -1; # endif /* Threads variety case */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::mutex_init (  ACE_mutex_t *    m, int    type, const wchar_t *    name, ACE_mutexattr_t *    arg = 0, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

ACE_INLINE int ACE_OS::mutex_init (  ACE_mutex_t *    m, int    type = ACE_DEFAULT_SYNCH_TYPE, const char *    name = 0, ACE_mutexattr_t *    arg = 0, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

Definition at line 1091 of file OS.i. References ACE_ADAPT_RETVAL, default_win32_security_attributes, mutex_init, set_errno_to_last_error, and thread_mutex_init. Referenced by ACE_Mutex::ACE_Mutex, event_init, flock_init, mutex_init, sema_init, and thread_mutex_init. { // ACE_OS_TRACE ("ACE_OS::mutex_init"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (sa); pthread_mutexattr_t l_attributes; if (attributes == 0) attributes = &l_attributes; int result = 0; int attr_init = 0; // have we initialized the local attributes. // Only do these initializations if the <attributes> parameter // wasn't originally set. if (attributes == &l_attributes) { # if defined (ACE_HAS_PTHREADS_DRAFT4) if (::pthread_mutexattr_create (attributes) == 0) # elif defined (ACE_HAS_PTHREADS_DRAFT7) || defined (ACE_HAS_PTHREADS_STD) if (ACE_ADAPT_RETVAL (::pthread_mutexattr_init (attributes), result) == 0) # else /* draft 6 */ if (::pthread_mutexattr_init (attributes) == 0) # endif /* ACE_HAS_PTHREADS_DRAFT4 */ { result = 0; attr_init = 1; // we have initialized these attributes } else result = -1; // ACE_ADAPT_RETVAL used it for intermediate status } if (result == 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) if ( # if defined (ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP) ::pthread_mutexattr_setkind_np (attributes, type) == 0 && # endif /* ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP */ ::pthread_mutex_init (m, *attributes) == 0) # elif defined (ACE_HAS_PTHREADS_DRAFT7) || defined (ACE_HAS_PTHREADS_STD) if ( # if defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED) ACE_ADAPT_RETVAL (::pthread_mutexattr_setpshared (attributes, type), result) == 0 && # endif /* _POSIX_THREAD_PROCESS_SHARED && ! ACE_LACKS_MUTEXATTR_PSHARED */ ACE_ADAPT_RETVAL (::pthread_mutex_init (m, attributes), result) == 0) # else if ( # if !defined (ACE_LACKS_MUTEXATTR_PSHARED) ::pthread_mutexattr_setpshared (attributes, type) == 0 && # endif /* ACE_LACKS_MUTEXATTR_PSHARED */ # if defined (ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP) ::pthread_mutexattr_setkind_np (attributes, type) == 0 && # endif /* ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP */ ::pthread_mutex_init (m, attributes) == 0) # endif /* ACE_HAS_PTHREADS_DRAFT4 */ result = 0; else result = -1; // ACE_ADAPT_RETVAL used it for intermediate status } # if (!defined (ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP) && !defined (_POSIX_THREAD_PROCESS_SHARED) || defined (ACE_LACKS_MUTEXATTR_PSHARED)) \ || ((defined (ACE_HAS_PTHREADS_DRAFT7) || defined (ACE_HAS_PTHREADS_STD)) && !defined (_POSIX_THREAD_PROCESS_SHARED)) ACE_UNUSED_ARG (type); # endif /* ! ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP */ // Only do the deletions if the <attributes> parameter wasn't // originally set. if (attributes == &l_attributes && attr_init) # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_mutexattr_delete (&l_attributes); # else ::pthread_mutexattr_destroy (&l_attributes); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return result; # elif defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (sa); ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_init (m, type, attributes), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) m->type_ = type; switch (type) { case USYNC_PROCESS: # if defined (ACE_HAS_WINCE) // @@todo (brunsch) This idea should be moved into ACE_OS_Win32. m->proc_mutex_ = ::CreateMutexW (ACE_OS::default_win32_security_attributes (sa), FALSE, ACE_Ascii_To_Wide (name).wchar_rep ()); # else /* ACE_HAS_WINCE */ m->proc_mutex_ = ::CreateMutexA (ACE_OS::default_win32_security_attributes (sa), FALSE, name); # endif /* ACE_HAS_WINCE */ if (m->proc_mutex_ == 0) ACE_FAIL_RETURN (-1); else { // Make sure to set errno to ERROR_ALREADY_EXISTS if necessary. ACE_OS::set_errno_to_last_error (); return 0; } case USYNC_THREAD: return ACE_OS::thread_mutex_init (&m->thr_mutex_, type, name, attributes); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_PSOS) ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (sa); # if defined (ACE_PSOS_HAS_MUTEX) u_long flags = MU_LOCAL; u_long ceiling = 0; # if defined (ACE_HAS_RECURSIVE_MUTEXES) flags |= MU_RECURSIVE; # else /* ! ACE_HAS_RECURSIVE_MUTEXES */ flags |= MU_NONRECURSIVE; # endif /* ACE_HAS_RECURSIVE_MUTEXES */ # if defined (ACE_PSOS_HAS_PRIO_MUTEX) flags |= MU_PRIOR; # if defined (ACE_PSOS_HAS_PRIO_INHERIT_MUTEX) flags |= MU_PRIO_INHERIT; # elif defined (ACE_PSOS_HAS_PRIO_PROTECT_MUTEX) ceiling = PSOS_TASK_MAX_PRIORITY; flags |= MU_PRIO_PROTECT; # else flags |= MU_PRIO_NONE; # endif /* ACE_PSOS_HAS_PRIO_INHERIT_MUTEX */ # else /* ! ACE_PSOS_HAS_PRIO_MUTEX */ flags |= MU_FIFO | MU_PRIO_NONE; # endif // Fake a pSOS name - it can be any 4-byte value, not necessarily needing // to be ASCII. So use the mutex pointer passed in. That should identify // each one uniquely. union { ACE_mutex_t *p; char n[4]; } m_name; m_name.p = m; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mu_create (m_name.n, flags, ceiling, m), ace_result_), int, -1); # else /* ! ACE_PSOS_HAS_MUTEX */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sm_create ((char *) name, 1, SM_LOCAL | SM_PRIOR, m), ace_result_), int, -1); # endif /* ACE_PSOS_HAS_MUTEX */ # elif defined (VXWORKS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (sa); return (*m = ::semMCreate (type)) == 0 ? -1 : 0; # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (sa); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::mutex_lock (  ACE_mutex_t *    m, const ACE_Time_Value *    timeout )  [static]

If <timeout> == 0, calls <ACE_OS::mutex_lock(m)>. Otherwise, this method attempts to acquire a lock, but gives up if the lock has not been acquired by the given time, in which case it returns -1 with an <ETIME> errno on platforms that actually support timed mutexes. The timeout should be an absolute time. Note that the mutex should not be a recursive one, i.e., it should only be a standard mutex or an error checking mutex. Definition at line 1703 of file OS.i. References mutex_lock. { return timeout == 0 ? ACE_OS::mutex_lock (m) : ACE_OS::mutex_lock (m, *timeout); }

ACE_INLINE int ACE_OS::mutex_lock (  ACE_mutex_t *    m, const ACE_Time_Value &    timeout )  [static]

This method attempts to acquire a lock, but gives up if the lock has not been acquired by the given time. If the lock is not acquired within the given amount of time, then this method returns -1 with an <ETIME> errno on platforms that actually support timed mutexes. The timeout should be an absolute time. Note that the mutex should not be a recursive one, i.e., it should only be a standard mutex or an error checking mutex. Definition at line 1600 of file OS.i. References ACE_ADAPT_RETVAL, ACE_ONE_SECOND_IN_USECS, EBUSY, ETIME, ETIMEDOUT, gettimeofday, ACE_Time_Value::msec, ACE_Time_Value::sec, set_errno_to_last_error, and ACE_Time_Value::usec. { #if defined (ACE_HAS_THREADS) && defined (ACE_HAS_MUTEX_TIMEOUTS) # if defined (ACE_HAS_PTHREADS) int result; // "timeout" should be an absolute time. timespec_t ts = timeout; // Calls ACE_Time_Value::operator timespec_t(). // Note that the mutex should not be a recursive one, i.e., it // should only be a standard mutex or an error checking mutex. ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_mutex_timedlock (m, &ts), result), int, -1, result); // We need to adjust this to make the errno values consistent. if (result == -1 && errno == ETIMEDOUT) errno = ETIME; return result; # elif defined (ACE_HAS_WTHREADS) // Note that we must convert between absolute time (which is passed // as a parameter) and relative time (which is what the system call // expects). ACE_Time_Value relative_time (timeout - ACE_OS::gettimeofday ()); switch (m->type_) { case USYNC_PROCESS: switch (::WaitForSingleObject (m->proc_mutex_, relative_time.msec ())) { case WAIT_OBJECT_0: case WAIT_ABANDONED: // We will ignore abandonments in this method // Note that we still hold the lock return 0; case WAIT_TIMEOUT: errno = ETIME; return -1; default: // This is a hack, we need to find an appropriate mapping... ACE_OS::set_errno_to_last_error (); return -1; } case USYNC_THREAD: ACE_NOTSUP_RETURN (-1); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_PSOS) // Note that we must convert between absolute time (which is // passed as a parameter) and relative time (which is what // the system call expects). ACE_Time_Value relative_time (timeout - ACE_OS::gettimeofday ()); u_long ticks = relative_time.sec() * KC_TICKS2SEC + relative_time.usec () * KC_TICKS2SEC / ACE_ONE_SECOND_IN_USECS; if (ticks == 0) ACE_OSCALL_RETURN (::sm_p (*m, SM_NOWAIT, 0), int, -1); // no timeout else ACE_OSCALL_RETURN (::sm_p (*m, SM_WAIT, ticks), int, -1); # elif defined (VXWORKS) // Note that we must convert between absolute time (which is passed // as a parameter) and relative time (which is what the system call // expects). ACE_Time_Value relative_time (timeout - ACE_OS::gettimeofday ()); int ticks_per_sec = ::sysClkRateGet (); int ticks = relative_time.sec() * ticks_per_sec + relative_time.usec () * ticks_per_sec / ACE_ONE_SECOND_IN_USECS; if (::semTake (*m, ticks) == ERROR) { if (errno == S_objLib_OBJ_TIMEOUT) // Convert the VxWorks errno to one that's common for to ACE // platforms. errno = ETIME; else if (errno == S_objLib_OBJ_UNAVAILABLE) errno = EBUSY; return -1; } else return 0; # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (timeout); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS && ACE_HAS_MUTEX_TIMEOUTS */ }

ACE_INLINE int ACE_OS::mutex_lock (  ACE_mutex_t *    m, int &    abandoned )  [static]

This method is only implemented for Win32. For abandoned mutexes, <abandoned> is set to 1 and 0 is returned. Definition at line 1432 of file OS.i. References ACE_OS_TRACE, set_errno_to_last_error, and thread_mutex_lock. { ACE_OS_TRACE ("ACE_OS::mutex_lock"); #if defined (ACE_HAS_THREADS) && defined (ACE_HAS_WTHREADS) abandoned = 0; switch (m->type_) { case USYNC_PROCESS: switch (::WaitForSingleObject (m->proc_mutex_, INFINITE)) { // // Timeout can't occur, so don't bother checking... // case WAIT_OBJECT_0: return 0; case WAIT_ABANDONED: abandoned = 1; return 0; // something goofed, but we hold the lock ... default: // This is a hack, we need to find an appropriate mapping... ACE_OS::set_errno_to_last_error (); return -1; } case USYNC_THREAD: return ACE_OS::thread_mutex_lock (&m->thr_mutex_); default: errno = EINVAL; return -1; } /* NOTREACHED */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (abandoned); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS and ACE_HAS_WTHREADS */ }

ACE_INLINE int ACE_OS::mutex_lock (  ACE_mutex_t *    m )  [static]

Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership. Definition at line 1372 of file OS.i. References ACE_ADAPT_RETVAL, mutex_lock, set_errno_to_last_error, and thread_mutex_lock. Referenced by ACE_Mutex::acquire, ACE_Mutex::acquire_read, ACE_Mutex::acquire_write, event_pulse, event_reset, event_signal, event_timedwait, event_wait, flock_rdlock, flock_wrlock, ACE_Recursive_Thread_Mutex::get_nesting_level, ACE_Recursive_Thread_Mutex::get_thread_id, mutex_lock, rw_rdlock, rw_tryrdlock, rw_trywrlock, rw_trywrlock_upgrade, rw_unlock, rw_wrlock, sema_init, sema_post, sema_trywait, sema_wait, and thread_mutex_lock. { // ACE_OS_TRACE ("ACE_OS::mutex_lock"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) // Note, don't use "::" here since the following call is often a macro. # if (defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6)) ACE_OSCALL_RETURN (pthread_mutex_lock (m), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_mutex_lock (m), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_lock (m), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) switch (m->type_) { case USYNC_PROCESS: switch (::WaitForSingleObject (m->proc_mutex_, INFINITE)) { // // Timeout can't occur, so don't bother checking... // case WAIT_OBJECT_0: case WAIT_ABANDONED: // We will ignore abandonments in this method // Note that we still hold the lock return 0; default: // This is a hack, we need to find an appropriate mapping... ACE_OS::set_errno_to_last_error (); return -1; } case USYNC_THREAD: return ACE_OS::thread_mutex_lock (&m->thr_mutex_); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_PSOS) # if defined (ACE_PSOS_HAS_MUTEX) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mu_lock (*m, MU_WAIT, 0), ace_result_), int, -1); # else /* ACE_PSOS_HAS_MUTEX */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sm_p (*m, SM_WAIT, 0), ace_result_), int, -1); # endif /* ACE_PSOS_HAS_MUTEX */ # elif defined (VXWORKS) return ::semTake (*m, WAIT_FOREVER) == OK ? 0 : -1; # endif /* Threads variety case */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

void ACE_OS::mutex_lock_cleanup (  void *    mutex )  [static]

Handle asynchronous thread cancellation cleanup. Definition at line 915 of file OS.cpp. References ACE_OS_TRACE, and mutex_unlock. Referenced by ace_mutex_lock_cleanup_adapter. { ACE_OS_TRACE ("ACE_OS::mutex_lock_cleanup"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) ACE_mutex_t *p_lock = (ACE_mutex_t *) mutex; ACE_OS::mutex_unlock (p_lock); # else ACE_UNUSED_ARG (mutex); # endif /* ACE_HAS_PTHREADS */ # else ACE_UNUSED_ARG (mutex); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::mutex_trylock (  ACE_mutex_t *    m, int &    abandoned )  [static]

This method is only implemented for Win32. For abandoned mutexes, <abandoned> is set to 1 and 0 is returned. Definition at line 1561 of file OS.i. References EBUSY, set_errno_to_last_error, and thread_mutex_trylock. { #if defined (ACE_HAS_THREADS) && defined (ACE_HAS_WTHREADS) abandoned = 0; switch (m->type_) { case USYNC_PROCESS: { // Try for 0 milliseconds - i.e. nonblocking. switch (::WaitForSingleObject (m->proc_mutex_, 0)) { case WAIT_OBJECT_0: return 0; case WAIT_ABANDONED: abandoned = 1; return 0; // something goofed, but we hold the lock ... case WAIT_TIMEOUT: errno = EBUSY; return -1; default: ACE_OS::set_errno_to_last_error (); return -1; } } case USYNC_THREAD: return ACE_OS::thread_mutex_trylock (&m->thr_mutex_); default: errno = EINVAL; return -1; } /* NOTREACHED */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (abandoned); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS and ACE_HAS_WTHREADS */ }

ACE_INLINE int ACE_OS::mutex_trylock (  ACE_mutex_t *    m )  [static]

Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership. Definition at line 1471 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, EBUSY, mutex_trylock, set_errno_to_last_error, and thread_mutex_trylock. Referenced by flock_tryrdlock, flock_trywrlock, mutex_trylock, thread_mutex_trylock, ACE_Mutex::tryacquire, ACE_Mutex::tryacquire_read, and ACE_Mutex::tryacquire_write. { ACE_OS_TRACE ("ACE_OS::mutex_trylock"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) // Note, don't use "::" here since the following call is often a macro. # if (defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6)) int status = pthread_mutex_trylock (m); if (status == 1) status = 0; else if (status == 0) { status = -1; errno = EBUSY; } return status; # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_mutex_trylock (m), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_trylock (m), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) switch (m->type_) { case USYNC_PROCESS: { // Try for 0 milliseconds - i.e. nonblocking. switch (::WaitForSingleObject (m->proc_mutex_, 0)) { case WAIT_OBJECT_0: return 0; case WAIT_ABANDONED: // We will ignore abandonments in this method. Note that // we still hold the lock. return 0; case WAIT_TIMEOUT: errno = EBUSY; return -1; default: ACE_OS::set_errno_to_last_error (); return -1; } } case USYNC_THREAD: return ACE_OS::thread_mutex_trylock (&m->thr_mutex_); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_PSOS) # if defined (ACE_PSOS_HAS_MUTEX) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mu_lock (*m, MU_NOWAIT, 0), ace_result_), int, -1); # else /* ! ACE_PSOS_HAS_MUTEX */ switch (::sm_p (*m, SM_NOWAIT, 0)) { case 0: return 0; case ERR_NOSEM: errno = EBUSY; // intentional fall through default: return -1; } # endif /* ACE_PSOS_HAS_MUTEX */ # elif defined (VXWORKS) if (::semTake (*m, NO_WAIT) == ERROR) if (errno == S_objLib_OBJ_UNAVAILABLE) { // couldn't get the semaphore errno = EBUSY; return -1; } else // error return -1; else // got the semaphore return 0; # endif /* Threads variety case */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::mutex_unlock (  ACE_mutex_t *    m )  [static]

Definition at line 1710 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, mutex_unlock, and thread_mutex_unlock. Referenced by event_pulse, event_reset, event_signal, event_timedwait, event_wait, flock_unlock, ACE_Recursive_Thread_Mutex::get_nesting_level, ACE_Recursive_Thread_Mutex::get_thread_id, mutex_lock_cleanup, mutex_unlock, ACE_Mutex::release, rw_rdlock, rw_tryrdlock, rw_trywrlock, rw_trywrlock_upgrade, rw_unlock, rw_wrlock, sema_init, sema_post, sema_trywait, sema_wait, and thread_mutex_unlock. { ACE_OS_TRACE ("ACE_OS::mutex_unlock"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) // Note, don't use "::" here since the following call is often a macro. # if (defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6)) ACE_OSCALL_RETURN (pthread_mutex_unlock (m), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_mutex_unlock (m), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_unlock (m), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) switch (m->type_) { case USYNC_PROCESS: ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ReleaseMutex (m->proc_mutex_), ace_result_), int, -1); case USYNC_THREAD: return ACE_OS::thread_mutex_unlock (&m->thr_mutex_); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_PSOS) # if defined (ACE_PSOS_HAS_MUTEX) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mu_unlock (*m), ace_result_), int, -1); # else /* ! ACE_PSOS_HAS_MUTEX */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sm_v (*m), ace_result_), int, -1); # endif /* ACE_PSOS_HAS_MUTEX */ # elif defined (VXWORKS) return ::semGive (*m) == OK ? 0 : -1; # endif /* Threads variety case */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::nanosleep (  const struct timespec *    requested, struct timespec *    remaining = 0 )  [static]

Definition at line 10337 of file OS.i. References ACE_ONE_SECOND_IN_NSECS, ACE_OS_TRACE, sleep, timespec::tv_nsec, and timespec::tv_sec. Referenced by sleep. { ACE_OS_TRACE ("ACE_OS::nanosleep"); #if defined (ACE_HAS_CLOCK_GETTIME) // ::nanosleep () is POSIX 1003.1b. So is ::clock_gettime (). So, // if ACE_HAS_CLOCK_GETTIME is defined, then ::nanosleep () should // be available on the platform. On Solaris 2.x, both functions // require linking with -lposix4. return ::nanosleep ((ACE_TIMESPEC_PTR) requested, remaining); #elif defined (ACE_PSOS) # if ! defined (ACE_PSOS_DIAB_MIPS) double ticks = KC_TICKS2SEC * requested->tv_sec + ( ACE_static_cast (double, requested->tv_nsec) * ACE_static_cast (double, KC_TICKS2SEC) ) / ACE_static_cast (double, ACE_ONE_SECOND_IN_NSECS); if (ticks > ACE_static_cast (double, ACE_PSOS_Time_t::max_ticks)) { ticks -= ACE_static_cast (double, ACE_PSOS_Time_t::max_ticks); remaining->tv_sec = ACE_static_cast (time_t, (ticks / ACE_static_cast (double, KC_TICKS2SEC))); ticks -= ACE_static_cast (double, remaining->tv_sec) * ACE_static_cast (double, KC_TICKS2SEC); remaining->tv_nsec = ACE_static_cast (long, (ticks * ACE_static_cast (double, ACE_ONE_SECOND_IN_NSECS)) / ACE_static_cast (double, KC_TICKS2SEC)); ::tm_wkafter (ACE_PSOS_Time_t::max_ticks); } else { remaining->tv_sec = 0; remaining->tv_nsec = 0; ::tm_wkafter (ACE_static_cast (u_long, ticks)); } // tm_wkafter always returns 0 # endif /* ACE_PSOS_DIAB_MIPS */ return 0; #else ACE_UNUSED_ARG (remaining); // Convert into seconds and microseconds. # if ! defined(ACE_HAS_BROKEN_TIMESPEC_MEMBERS) ACE_Time_Value tv (requested->tv_sec, requested->tv_nsec / 1000); # else ACE_Time_Value tv (requested->ts_sec, requested->ts_nsec / 1000); # endif /* ACE_HAS_BROKEN_TIMESPEC_MEMBERS */ return ACE_OS::sleep (tv); #endif /* ACE_HAS_CLOCK_GETTIME */ }

int ACE_OS::nanosleep_i (  const struct timespec *    requested, struct timespec *    remaining = 0 )  [static, private]

long ACE_OS::num_processors (  void    )  [static]

Get the number of CPUs configured in the machine. Definition at line 7676 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::num_processors"); #if 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 }

long ACE_OS::num_processors_online (  void    )  [static]

Get the number of CPUs currently online. Definition at line 7692 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::num_processors_online"); #if 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 }

ACE_HANDLE ACE_OS::open (  const wchar_t *    filename, int    mode, int    perms = ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

Definition at line 5280 of file OS.cpp. References access, ACE_BIT_ENABLED, ACE_MT, default_win32_security_attributes, open, ACE_OS_Object_Manager::preallocated_object, thread_mutex_lock, and thread_mutex_unlock. { #if defined (ACE_WIN32) // @@ (brunsch) Yuck, maybe there is a way to combine the code // here with the char version DWORD access = GENERIC_READ; if (ACE_BIT_ENABLED (mode, O_WRONLY)) access = GENERIC_WRITE; else if (ACE_BIT_ENABLED (mode, O_RDWR)) access = GENERIC_READ | GENERIC_WRITE; DWORD creation = OPEN_EXISTING; if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL)) creation = CREATE_NEW; else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC)) creation = CREATE_ALWAYS; else if (ACE_BIT_ENABLED (mode, _O_CREAT)) creation = OPEN_ALWAYS; else if (ACE_BIT_ENABLED (mode, _O_TRUNC)) creation = TRUNCATE_EXISTING; DWORD flags = 0; if (ACE_BIT_ENABLED (mode, _O_TEMPORARY)) flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY; if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH)) flags |= FILE_FLAG_WRITE_THROUGH; if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED)) flags |= FILE_FLAG_OVERLAPPED; if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING)) flags |= FILE_FLAG_NO_BUFFERING; if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS)) flags |= FILE_FLAG_RANDOM_ACCESS; if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN)) flags |= FILE_FLAG_SEQUENTIAL_SCAN; if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE)) flags |= FILE_FLAG_DELETE_ON_CLOSE; if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS)) flags |= FILE_FLAG_BACKUP_SEMANTICS; if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS)) flags |= FILE_FLAG_POSIX_SEMANTICS; ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;) if (ACE_BIT_ENABLED (mode, _O_APPEND)) { ACE_MT ( ace_os_monitor_lock = (ACE_thread_mutex_t *) ACE_OS_Object_Manager::preallocated_object[ ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]; ACE_OS::thread_mutex_lock (ace_os_monitor_lock); ) } DWORD shared_mode = perms; ACE_HANDLE h = ::CreateFileW (filename, access, shared_mode, ACE_OS::default_win32_security_attributes (sa), creation, flags, 0); if (ACE_BIT_ENABLED (mode, _O_APPEND)) { if (h != ACE_INVALID_HANDLE) { ::SetFilePointer (h, 0, 0, FILE_END); } ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);) } if (h == ACE_INVALID_HANDLE) ACE_FAIL_RETURN (h); else return h; #else /* ACE_WIN32 */ // Just emulate with ascii version return ACE_OS::open (ACE_Wide_To_Ascii (filename).char_rep (), mode, perms, sa); #endif /* ACE_WIN32 */ }

ACE_HANDLE ACE_OS::open (  const char *    filename, int    mode, int    perms = ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

The O_APPEND flag is only partly supported on Win32. If you specify O_APPEND, then the file pointer will be positioned at the end of the file initially during open, but it is not re-positioned at the end prior to each write, as specified by POSIX. This is generally good enough for typical situations, but it is ``not quite right'' in its semantics. Definition at line 5139 of file OS.cpp. References access, ACE_BIT_ENABLED, ACE_MT, ACE_OS_TRACE, default_win32_security_attributes, open, ACE_OS_Object_Manager::preallocated_object, thread_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Filecache_Object::ACE_Filecache_Object, ACE_SPIPE_Connector::connect, ACE_Handle_Gobbler::consume_handles, creat, filesize, flock_init, fopen, ACE_Sock_Connect::get_handle, ACE_Handle_Ops::handle_timed_open, open, ACE_Mem_Map::open, ACE_FIFO_Recv::open, ACE_FIFO::open, ACE_Dev_Poll_Reactor::open, ACE_Lib_Find::open_temp_file, ACE_Filecache_Object::release, shm_open, and truncate. { ACE_OS_TRACE ("ACE_OS::open"); #if defined (ACE_WIN32) DWORD access = GENERIC_READ; if (ACE_BIT_ENABLED (mode, O_WRONLY)) access = GENERIC_WRITE; else if (ACE_BIT_ENABLED (mode, O_RDWR)) access = GENERIC_READ | GENERIC_WRITE; DWORD creation = OPEN_EXISTING; if ((mode & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL)) creation = CREATE_NEW; else if ((mode & (_O_CREAT | _O_TRUNC)) == (_O_CREAT | _O_TRUNC)) creation = CREATE_ALWAYS; else if (ACE_BIT_ENABLED (mode, _O_CREAT)) creation = OPEN_ALWAYS; else if (ACE_BIT_ENABLED (mode, _O_TRUNC)) creation = TRUNCATE_EXISTING; DWORD flags = 0; if (ACE_BIT_ENABLED (mode, _O_TEMPORARY)) flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY; if (ACE_BIT_ENABLED (mode, FILE_FLAG_WRITE_THROUGH)) flags |= FILE_FLAG_WRITE_THROUGH; if (ACE_BIT_ENABLED (mode, FILE_FLAG_OVERLAPPED)) flags |= FILE_FLAG_OVERLAPPED; if (ACE_BIT_ENABLED (mode, FILE_FLAG_NO_BUFFERING)) flags |= FILE_FLAG_NO_BUFFERING; if (ACE_BIT_ENABLED (mode, FILE_FLAG_RANDOM_ACCESS)) flags |= FILE_FLAG_RANDOM_ACCESS; if (ACE_BIT_ENABLED (mode, FILE_FLAG_SEQUENTIAL_SCAN)) flags |= FILE_FLAG_SEQUENTIAL_SCAN; if (ACE_BIT_ENABLED (mode, FILE_FLAG_DELETE_ON_CLOSE)) flags |= FILE_FLAG_DELETE_ON_CLOSE; if (ACE_BIT_ENABLED (mode, FILE_FLAG_BACKUP_SEMANTICS)) flags |= FILE_FLAG_BACKUP_SEMANTICS; if (ACE_BIT_ENABLED (mode, FILE_FLAG_POSIX_SEMANTICS)) flags |= FILE_FLAG_POSIX_SEMANTICS; ACE_MT (ACE_thread_mutex_t *ace_os_monitor_lock = 0;) if (ACE_BIT_ENABLED (mode, _O_APPEND)) { ACE_MT ( ace_os_monitor_lock = (ACE_thread_mutex_t *) ACE_OS_Object_Manager::preallocated_object[ ACE_OS_Object_Manager::ACE_OS_MONITOR_LOCK]; ACE_OS::thread_mutex_lock (ace_os_monitor_lock); ) } DWORD shared_mode = perms; #if defined (ACE_HAS_WINCE) ACE_HANDLE h = ::CreateFileW (ACE_Ascii_To_Wide (filename).wchar_rep (), access, shared_mode, ACE_OS::default_win32_security_attributes (sa), creation, flags, 0); #else /* ACE_HAS_WINCE */ ACE_HANDLE h = ::CreateFileA (filename, access, shared_mode, ACE_OS::default_win32_security_attributes (sa), creation, flags, 0); #endif /* ACE_HAS_WINCE */ if (ACE_BIT_ENABLED (mode, _O_APPEND)) { if (h != ACE_INVALID_HANDLE) { ::SetFilePointer (h, 0, 0, FILE_END); } ACE_MT (ACE_OS::thread_mutex_unlock (ace_os_monitor_lock);) } if (h == ACE_INVALID_HANDLE) { ACE_FAIL_RETURN (h); } else { return h; } #elif defined (ACE_PSOS) ACE_UNUSED_ARG (perms); ACE_UNUSED_ARG (sa); # if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (filename); return 0; # else unsigned long result, handle; result = ::open_f (&handle, ACE_const_cast(char *, filename), 0); if (result != 0) { // We need to clean this up...not 100% correct! // To correct we should handle all the cases of TRUNC and CREAT if ((result == 0x200B) && (ACE_BIT_ENABLED (mode, O_CREAT))) { result = ::create_f(ACE_const_cast(char *, filename),1,0); if (result != 0) { errno = result; return ACE_static_cast (ACE_HANDLE, -1); } else //File created...try to open it again { result = ::open_f (&handle, ACE_const_cast(char *, filename), 0); if (result != 0) { errno = result; return ACE_static_cast (ACE_HANDLE, -1); } } } else { errno = result; return ACE_static_cast (ACE_HANDLE, -1); } } return ACE_static_cast (ACE_HANDLE, handle); # endif /* defined (ACE_PSOS_LACKS_PHILE) */ #else ACE_UNUSED_ARG (sa); ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE void ACE_OS::perror (  const ACE_TCHAR *    s )  [static]

Definition at line 6338 of file OS.i. References ACE_OS_TRACE, and ACE_TCHAR. Referenced by ACE_ATM_Stream::get_peer_name, and ACE_ATM_Acceptor::open. { ACE_OS_TRACE ("ACE_OS::perror"); #if defined (ACE_HAS_WINCE) // @@ WINCE: How should this be handled ACE_UNUSED_ARG (s); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ::_wperror (s); #else ::perror (s); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::pipe (  ACE_HANDLE    handles[] )  [static]

Definition at line 381 of file OS.i. References ACE_OS_TRACE, and pipe. Referenced by ACE_SPIPE_Acceptor::create_new_instance, ACE_Pipe::open, and pipe. { ACE_OS_TRACE ("ACE_OS::pipe"); # if defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (fds); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::pipe (fds), int, -1); # endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE int ACE_OS::poll (  struct pollfd *    pollfds, u_long    len, const ACE_Time_Value &    tv )  [static]

Definition at line 7622 of file OS.i. References ACE_OS_TRACE, ACE_Time_Value::msec, and poll. { ACE_OS_TRACE ("ACE_OS::poll"); #if defined (ACE_HAS_POLL) ACE_OSCALL_RETURN (::poll (pollfds, len, int (timeout.msec ())), int, -1); #else ACE_UNUSED_ARG (timeout); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (pollfds); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_POLL */ }

ACE_INLINE int ACE_OS::poll (  struct pollfd *    pollfds, u_long    len, const ACE_Time_Value *    tv = 0 )  [static]

Definition at line 7606 of file OS.i. References ACE_OS_TRACE, ACE_Time_Value::msec, and poll. Referenced by ACE::handle_ready, ACE::handle_timed_accept, ACE::handle_timed_complete, and poll. { ACE_OS_TRACE ("ACE_OS::poll"); #if defined (ACE_HAS_POLL) int to = timeout == 0 ? -1 : int (timeout->msec ()); ACE_OSCALL_RETURN (::poll (pollfds, len, to), int, -1); #else ACE_UNUSED_ARG (timeout); ACE_UNUSED_ARG (len); ACE_UNUSED_ARG (pollfds); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_POLL */ }

int ACE_OS::poll_i (  struct pollfd *    pollfds, u_long    len, const ACE_Time_Value &    tv )  [static, private]

int ACE_OS::poll_i (  struct pollfd *    pollfds, u_long    len, const ACE_Time_Value *    tv = 0 )  [static, private]

ssize_t ACE_OS::pread (  ACE_HANDLE    handle, void *    buf, size_t    nbyte, off_t    offset )  [static]

Definition at line 4895 of file OS.cpp. References ACE_OS_GUARD, lseek, read, and ssize_t. { # if defined (ACE_HAS_P_READ_WRITE) # if defined (ACE_WIN32) ACE_OS_GUARD // Remember the original file pointer position DWORD original_position = ::SetFilePointer (handle, 0, 0, FILE_CURRENT); if (original_position == 0xFFFFFFFF) return -1; // Go to the correct position DWORD altered_position = ::SetFilePointer (handle, offset, 0, FILE_BEGIN); if (altered_position == 0xFFFFFFFF) return -1; DWORD bytes_read; # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0) OVERLAPPED overlapped; overlapped.Internal = 0; overlapped.InternalHigh = 0; overlapped.Offset = offset; overlapped.OffsetHigh = 0; overlapped.hEvent = 0; BOOL result = ::ReadFile (handle, buf, ACE_static_cast (DWORD, nbytes), &bytes_read, &overlapped); if (result == FALSE) { if (::GetLastError () != ERROR_IO_PENDING) return -1; else { result = ::GetOverlappedResult (handle, &overlapped, &bytes_read, TRUE); if (result == FALSE) return -1; } } # else /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ BOOL result = ::ReadFile (handle, buf, nbytes, &bytes_read, 0); if (result == FALSE) return -1; # endif /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ // Reset the original file pointer position if (::SetFilePointer (handle, original_position, 0, FILE_BEGIN) == 0xFFFFFFFF) return -1; return (ssize_t) bytes_read; # else /* ACE_WIN32 */ return ::pread (handle, buf, nbytes, offset); # endif /* ACE_WIN32 */ # else /* ACE_HAS_P_READ_WRITE */ ACE_OS_GUARD // Remember the original file pointer position off_t original_position = ACE_OS::lseek (handle, 0, SEEK_CUR); if (original_position == -1) return -1; // Go to the correct position off_t altered_position = ACE_OS::lseek (handle, offset, SEEK_SET); if (altered_position == -1) return -1; ssize_t bytes_read = ACE_OS::read (handle, buf, nbytes); if (bytes_read == -1) return -1; if (ACE_OS::lseek (handle, original_position, SEEK_SET) == -1) return -1; return bytes_read; # endif /* ACE_HAD_P_READ_WRITE */ }

int ACE_OS::printf (  const char *    format, ...    )  [static]

Definition at line 1055 of file OS.cpp. References ACE_OS_TRACE. Referenced by ACE_ATM_Acceptor::accept, ACE_ATM_Connector::add_leaf, ACE_ATM_Connector::connect, ACE_ATM_Acceptor::get_local_addr, ACE_ATM_Stream::get_vpi_vci, mkdir, ACE_ATM_Stream::open, ACE_ATM_Acceptor::open, ACE_ATM_QoS::set_cbr_rate, and ACE_ATM_Addr::string_to_addr. { ACE_OS_TRACE ("ACE_OS::printf"); int result; va_list ap; va_start (ap, format); ACE_OSCALL (::vprintf (format, ap), int, -1, result); va_end (ap); return result; }

ACE_INLINE int ACE_OS::priority_control (  ACE_idtype_t   , ACE_id_t   , int   , void *    )  [static]

Low-level interface to <priocntl>(2). Can't call the following priocntl, because that's a macro on Solaris. Definition at line 7440 of file OS.i. References ACE_id_t, ACE_idtype_t, ACE_OS_TRACE, and caddr_t. Referenced by lwp_getparams, ACE_Sched_Params::priority_max, ACE_Sched_Params::priority_min, scheduling_class, and set_scheduling_params. { ACE_OS_TRACE ("ACE_OS::priority_control"); #if defined (ACE_HAS_PRIOCNTL) ACE_OSCALL_RETURN (priocntl (idtype, id, cmd, ACE_static_cast (caddr_t, arg)), int, -1); #else /* ! ACE_HAS_PRIOCNTL*/ ACE_UNUSED_ARG (idtype); ACE_UNUSED_ARG (id); ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (arg); ACE_NOTSUP_RETURN (-1); #endif /* ! ACE_HAS_PRIOCNTL*/ }

ACE_INLINE int ACE_OS::pthread_sigmask (  int    how, const sigset_t *    nsp, sigset_t *    osp )  [static]

Definition at line 10848 of file OS.i. References ACE_ADAPT_RETVAL, and pthread_sigmask. Referenced by pthread_sigmask, ACE_Asynch_Pseudo_Task::svc, and thr_sigsetmask. { #if defined (ACE_HAS_PTHREADS_STD) && !defined (ACE_LACKS_PTHREAD_SIGMASK) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsp, osp), ace_result_), int, -1); #else /* !ACE_HAS_PTHREADS_STD && !ACE_LACKS_PTHREAD_SIGMASK */ ACE_UNUSED_ARG (how); ACE_UNUSED_ARG (nsp); ACE_UNUSED_ARG (osp); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_PTHREADS_STD && !ACE_LACKS_PTHREAD_SIGMASK */ }

ACE_INLINE int ACE_OS::putenv (  const ACE_TCHAR *    string )  [static]

Definition at line 10490 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and putenv. Referenced by putenv, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::putenv"); #if defined (ACE_HAS_WINCE) || defined (ACE_PSOS) // WinCE and pSOS don't have the concept of environment variables. ACE_UNUSED_ARG (string); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_LACKS_ENV) ACE_UNUSED_ARG (string); ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wputenv (string), int, -1); #else /* ! ACE_HAS_WINCE && ! ACE_PSOS */ // VxWorks declares ::putenv with a non-const arg. ACE_OSCALL_RETURN (::putenv ((char *) string), int, -1); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::putmsg (  ACE_HANDLE    handle, const struct strbuf *    ctl, const struct strbuf *    data, int    flags )  [static]

Definition at line 8489 of file OS.i. References ACE_NEW_RETURN, ACE_OS_TRACE, strbuf::buf, strbuf::len, ACE_OS_String::memcpy, putmsg, and write. Referenced by putmsg, putpmsg, ACE_SPIPE_Stream::send, and ACE_FIFO_Send_Msg::send. { ACE_OS_TRACE ("ACE_OS::putmsg"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::putmsg (handle, (ACE_STRBUF_TYPE) ctl, (ACE_STRBUF_TYPE) data, flags), int, -1); #else ACE_UNUSED_ARG (flags); if (ctl == 0 && data == 0) { errno = EINVAL; return 0; } // Handle the two easy cases. else if (ctl != 0) return ACE_OS::write (handle, ctl->buf, ctl->len); else if (data != 0) return ACE_OS::write (handle, data->buf, data->len); else { // This is the hard case. char *buf; ACE_NEW_RETURN (buf, char [ctl->len + data->len], -1); ACE_OS::memcpy (buf, ctl->buf, ctl->len); ACE_OS::memcpy (buf + ctl->len, data->buf, data->len); int result = ACE_OS::write (handle, buf, ctl->len + data->len); delete [] buf; return result; } #endif /* ACE_HAS_STREAM_PIPES */ }

ACE_INLINE int ACE_OS::putpmsg (  ACE_HANDLE    handle, const struct strbuf *    ctl, const struct strbuf *    data, int    band, int    flags )  [static]

Definition at line 8525 of file OS.i. References ACE_OS_TRACE, putmsg, and putpmsg. Referenced by putpmsg, and ACE_SPIPE_Stream::send. { ACE_OS_TRACE ("ACE_OS::putpmsg"); #if defined (ACE_HAS_STREAM_PIPES) ACE_OSCALL_RETURN (::putpmsg (handle, (ACE_STRBUF_TYPE) ctl, (ACE_STRBUF_TYPE) data, band, flags), int, -1); #else ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (band); return ACE_OS::putmsg (handle, ctl, data, flags); #endif /* ACE_HAS_STREAM_PIPES */ }

ACE_INLINE int ACE_OS::puts (  const ACE_TCHAR *    s )  [static]

Definition at line 6352 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and puts. Referenced by puts. { ACE_OS_TRACE ("ACE_OS::puts"); #if defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_putws (s), int, -1); #else /* ACE_WIN32 */ ACE_OSCALL_RETURN (::puts (s), int, -1); #endif /* ACE_WIN32 && ACE_USES_WCHAR */ }

ssize_t ACE_OS::pwrite (  ACE_HANDLE    handle, const void *    buf, size_t    nbyte, off_t    offset )  [static]

Definition at line 5020 of file OS.cpp. References ACE_OS_GUARD, lseek, ssize_t, and write. Referenced by ACE_Filecache_Object::ACE_Filecache_Object, and ACE_Mem_Map::map_it. { # if defined (ACE_HAS_P_READ_WRITE) # if defined (ACE_WIN32) ACE_OS_GUARD // Remember the original file pointer position DWORD original_position = ::SetFilePointer (handle, 0, 0, FILE_CURRENT); if (original_position == 0xFFFFFFFF) return -1; // Go to the correct position DWORD altered_position = ::SetFilePointer (handle, offset, 0, FILE_BEGIN); if (altered_position == 0xFFFFFFFF) return -1; DWORD bytes_written; # if defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0) OVERLAPPED overlapped; overlapped.Internal = 0; overlapped.InternalHigh = 0; overlapped.Offset = offset; overlapped.OffsetHigh = 0; overlapped.hEvent = 0; BOOL result = ::WriteFile (handle, buf, ACE_static_cast (DWORD, nbytes), &bytes_written, &overlapped); if (result == FALSE) { if (::GetLastError () != ERROR_IO_PENDING) return -1; else { result = ::GetOverlappedResult (handle, &overlapped, &bytes_written, TRUE); if (result == FALSE) return -1; } } # else /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ BOOL result = ::WriteFile (handle, buf, nbytes, &bytes_written, 0); if (result == FALSE) return -1; # endif /* ACE_HAS_WINNT4 && (ACE_HAS_WINNT4 != 0) */ // Reset the original file pointer position if (::SetFilePointer (handle, original_position, 0, FILE_BEGIN) == 0xFFFFFFFF) return -1; return (ssize_t) bytes_written; # else /* ACE_WIN32 */ return ::pwrite (handle, buf, nbytes, offset); # endif /* ACE_WIN32 */ # else /* ACE_HAS_P_READ_WRITE */ ACE_OS_GUARD // Remember the original file pointer position off_t original_position = ACE_OS::lseek (handle, 0, SEEK_CUR); if (original_position == -1) return -1; // Go to the correct position off_t altered_position = ACE_OS::lseek (handle, offset, SEEK_SET); if (altered_position == -1) return -1; ssize_t bytes_written = ACE_OS::write (handle, buf, nbytes); if (bytes_written == -1) return -1; if (ACE_OS::lseek (handle, original_position, SEEK_SET) == -1) return -1; return bytes_written; # endif /* ACE_HAD_P_READ_WRITE */ }

ACE_INLINE void ACE_OS::qsort (  void *    base, size_t    nel, size_t    width, ACE_COMPARE_FUNC    )  [static]

Definition at line 10906 of file OS.i. References ACE_COMPARE_FUNC. Referenced by ACE_OS_Dirent::scandir_emulation. { #if !defined (ACE_LACKS_QSORT) ::qsort (base, nel, width, compar); #else ACE_UNUSED_ARG (base); ACE_UNUSED_ARG (nel); ACE_UNUSED_ARG (width); ACE_UNUSED_ARG (compar); #endif /* !ACE_LACKS_QSORT */ }

ACE_INLINE int ACE_OS::rand (  void    )  [static]

Definition at line 764 of file OS.i. References ACE_OS_TRACE, and rand. Referenced by rand, and rand_r. { ACE_OS_TRACE ("ACE_OS::rand"); ACE_OSCALL_RETURN (::rand (), int, -1); }

ACE_INLINE int ACE_OS::rand_r (  ACE_RANDR_TYPE &    seed )  [static]

Definition at line 414 of file OS.i. References ACE_OS_TRACE, ACE_RANDR_TYPE, rand, and rand_r. Referenced by rand_r. { ACE_OS_TRACE ("ACE_OS::rand_r"); # if defined (ACE_HAS_REENTRANT_FUNCTIONS) && \ !defined (ACE_LACKS_RAND_REENTRANT_FUNCTIONS) # if defined (DIGITAL_UNIX) ACE_OSCALL_RETURN (::_Prand_r (&seed), int, -1); # elif defined (HPUX_10) // rand() is thread-safe on HP-UX 10. rand_r's signature is not consistent // with latest POSIX and will change in a future HP-UX release so that it // is consistent. At that point, this #elif section can be changed or // removed, and just call rand_r. ACE_UNUSED_ARG (seed); ACE_OSCALL_RETURN (::rand(), int, -1); # elif defined (ACE_HAS_BROKEN_RANDR) ACE_OSCALL_RETURN (::rand_r (seed), int, -1); # else ACE_OSCALL_RETURN (::rand_r (&seed), int, -1); # endif /* DIGITAL_UNIX */ # else ACE_UNUSED_ARG (seed); ACE_OSCALL_RETURN (::rand (), int, -1); # endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

ACE_INLINE ssize_t ACE_OS::read (  ACE_HANDLE    handle, void *    buf, size_t    len, ACE_OVERLAPPED *    )  [static]

Definition at line 8280 of file OS.i. References ACE_OS_TRACE, ACE_OVERLAPPED, and read. { ACE_OS_TRACE ("ACE_OS::read"); overlapped = overlapped; #if defined (ACE_WIN32) DWORD ok_len; DWORD short_len = ACE_static_cast (DWORD, len); if (::ReadFile (handle, buf, short_len, &ok_len, overlapped)) return (ssize_t) ok_len; else ACE_FAIL_RETURN (-1); #else return ACE_OS::read (handle, buf, len); #endif /* ACE_WIN32 */ }

ACE_INLINE ssize_t ACE_OS::read (  ACE_HANDLE    handle, void *    buf, size_t    len )  [static]

Definition at line 8241 of file OS.i. References ACE_OS_TRACE, EWOULDBLOCK, read, and ssize_t. Referenced by ACE_UPIPE_Acceptor::accept, pread, read, read_n, ACE_SPIPE_Stream::recv, ACE_SOCK_IO::recv, ACE_FILE_IO::recv, ACE_FIFO_Recv_Msg::recv, ACE_FIFO_Recv::recv, ACE_DEV_IO::recv, and ACE::recv_i. { ACE_OS_TRACE ("ACE_OS::read"); #if defined (ACE_WIN32) DWORD ok_len; if (::ReadFile (handle, buf, ACE_static_cast (DWORD, len), &ok_len, 0)) return (ssize_t) ok_len; else ACE_FAIL_RETURN (-1); #elif defined (ACE_PSOS) # if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (len); ACE_NOTSUP_RETURN (-1); # else u_long count; u_long result = ::read_f (handle, buf, len, &count); if (result != 0) return ACE_static_cast (ssize_t, -1); else return ACE_static_cast (ssize_t, count == len ? count : 0); # endif /* defined (ACE_PSOS_LACKS_PHILE */ #else int result; # if defined (ACE_LACKS_POSIX_PROTOTYPES) || defined (ACE_HAS_CHARPTR_SOCKOPT) ACE_OSCALL (::read (handle, (char *) buf, len), ssize_t, -1, result); # else ACE_OSCALL (::read (handle, buf, len), ssize_t, -1, result); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ if (result == -1 && errno == EAGAIN) errno = EWOULDBLOCK; return result; #endif /* ACE_WIN32 */ }

ssize_t ACE_OS::read_n (  ACE_HANDLE    handle, void *    buf, size_t    len, size_t *    bytes_transferred = 0 )  [static]

Receive <len> bytes into <buf> from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been transmitted will be returned to the caller through <bytes_transferred>. Definition at line 4177 of file OS.cpp. References read, and ssize_t. Referenced by ACE::read_n. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { n = ACE_OS::read (handle, (char *) buf + bytes_transferred, len - bytes_transferred); if (n == -1 || n == 0) return n; } return bytes_transferred; }

ACE_INLINE int ACE_OS::readlink (  const char *    path, char *    buf, size_t    bufsiz )  [static]

Definition at line 8298 of file OS.i. References ACE_OS_TRACE, and readlink. Referenced by readlink. { ACE_OS_TRACE ("ACE_OS::readlink"); # if defined (ACE_LACKS_READLINK) || \ defined (ACE_HAS_WINCE) || defined (ACE_WIN32) ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (bufsiz); ACE_NOTSUP_RETURN (-1); # else # if !defined(ACE_HAS_NONCONST_READLINK) ACE_OSCALL_RETURN (::readlink (path, buf, bufsiz), int, -1); # else ACE_OSCALL_RETURN (::readlink ((char *)path, buf, bufsiz), int, -1); # endif # endif /* ACE_LACKS_READLINK */ }

ACE_INLINE ssize_t ACE_OS::readv (  ACE_HANDLE    handle, iovec *    iov, int    iovlen )  [static]

Definition at line 7468 of file OS.i. References ACE_OS_TRACE, readv, and ssize_t. Referenced by readv, ACE::readv_n, ACE_SPIPE_Stream::recv, ACE_FILE_IO::recv, ACE_DEV_IO::recv, recvv, ACE_SPIPE_Stream::recvv_n, and ACE_FILE_IO::recvv_n. { ACE_OS_TRACE ("ACE_OS::readv"); #if defined (ACE_LACKS_READV) ACE_OSCALL_RETURN (ACE_OS::readv_emulation (handle, iov, iovlen), ssize_t, -1); #else /* ACE_LACKS_READV */ ACE_OSCALL_RETURN (::readv (handle, iov, iovlen), ssize_t, -1); #endif /* ACE_LACKS_READV */ }

ACE_INLINE void ACE_OS::recursive_mutex_cond_relock (  ACE_recursive_thread_mutex_t *    m, ACE_recursive_mutex_state &    state )  [static]

Definition at line 2710 of file OS.i. References ACE_OS_TRACE, cond_wait, ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_mutex_state::nesting_level_, ACE_recursive_thread_mutex_t::nesting_level_, ACE_recursive_thread_mutex_t::nesting_mutex_, ACE_recursive_mutex_state::owner_id_, ACE_recursive_thread_mutex_t::owner_id_, recursive_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Condition< ACE_Recursive_Thread_Mutex >::wait. { #if defined (ACE_HAS_THREADS) ACE_OS_TRACE ("ACE_OS::recursive_mutex_cond_relock"); # if defined (ACE_HAS_RECURSIVE_MUTEXES) // Windows need special handling since it has recursive mutexes, but // does not integrate them into a condition variable. // On entry, the OS has already reacquired the lock for us. Just // reacquire it the proper number of times so the recursion is the same as // before waiting on the condition. # if defined (ACE_WIN32) while (state.relock_count_ > 0) { ACE_OS::recursive_mutex_lock (m); --state.relock_count_; } return; # else /* not ACE_WIN32 */ // prevent warnings for unused variables ACE_UNUSED_ARG (state); ACE_UNUSED_ARG (m); # endif /* ACE_WIN32 */ # else // Without recursive mutex support, it's somewhat trickier. On entry, // the current thread holds the nesting_mutex_, but another thread may // still be holding the ACE_recursive_mutex_t. If so, mimic the code // in ACE_OS::recursive_mutex_lock that waits to acquire the mutex. // After acquiring it, restore the nesting counts and release the // nesting mutex. This will restore the conditions to what they were // before calling ACE_OS::recursive_mutex_cond_unlock(). while (m->nesting_level_ > 0) ACE_OS::cond_wait (&m->lock_available_, &m->nesting_mutex_); // At this point, we still have nesting_mutex_ and the mutex is free. m->nesting_level_ = state.nesting_level_; m->owner_id_ = state.owner_id_; ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); return; # endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (state); return; #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_cond_unlock (  ACE_recursive_thread_mutex_t *    m, ACE_recursive_mutex_state &    state )  [static]

Definition at line 2619 of file OS.i. References ACE_OS_TRACE, cond_signal, ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_mutex_state::nesting_level_, ACE_recursive_thread_mutex_t::nesting_level_, ACE_recursive_thread_mutex_t::nesting_mutex_, NULL_thread, ACE_recursive_mutex_state::owner_id_, ACE_recursive_thread_mutex_t::owner_id_, recursive_mutex_unlock, thr_equal, thr_self, thread_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Condition< ACE_Recursive_Thread_Mutex >::wait. { #if defined (ACE_HAS_THREADS) ACE_OS_TRACE ("ACE_OS::recursive_mutex_cond_unlock"); # if defined (ACE_HAS_RECURSIVE_MUTEXES) // Windows need special handling since it has recursive mutexes, but // does not integrate them into a condition variable. # if defined (ACE_WIN32) // For Windows, the OS takes care of the mutex and its recursion. We just // need to release the lock one fewer times than this thread has acquired // it. Remember how many times, and reacquire it that many more times when // the condition is signaled. state.relock_count_ = 0; while (m->LockCount > 0 # if !defined (ACE_HAS_WINCE) /* WinCE doesn't have RecursionCount */ && m->RecursionCount > 1 # endif ) { // This may fail if the current thread doesn't own the mutex. If it // does fail, it'll be on the first try, so don't worry about resetting // the state. if (ACE_OS::recursive_mutex_unlock (m) == -1) return -1; ++state.relock_count_; } # else /* not ACE_WIN32 */ // prevent warnings for unused variables ACE_UNUSED_ARG (state); ACE_UNUSED_ARG (m); # endif /* ACE_WIN32 */ return 0; # else /* ACE_HAS_RECURSIVE_MUTEXES */ // For platforms without recursive mutexes, we obtain the nesting mutex // to gain control over the mutex internals. Then set the internals to say // the mutex is available. If there are waiters, signal the condition // to notify them (this is mostly like the recursive_mutex_unlock() method). // Then, return with the nesting mutex still held. The condition wait // will release it atomically, allowing mutex waiters to continue. // Note that this arrangement relies on the fact that on return from // the condition wait, this thread will again own the nesting mutex // and can either set the mutex internals directly or get in line for // the mutex... this part is handled in recursive_mutex_cond_relock(). if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1) return -1; # if !defined (ACE_NDEBUG) if (m->nesting_level_ == 0 || ACE_OS::thr_equal (ACE_OS::thr_self (), m->owner_id_) == 0) { ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); errno = EINVAL; return -1; } # endif /* ACE_NDEBUG */ // To make error recovery a bit easier, signal the condition now. Any // waiter won't regain control until the mutex is released, which won't // be until the caller returns and does the wait on the condition. if (ACE_OS::cond_signal (&m->lock_available_) == -1) { // Save/restore errno. ACE_Errno_Guard error (errno); ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); return -1; } // Ok, the nesting_mutex_ lock is still held, the condition has been // signaled... reset the nesting info and return _WITH_ the lock // held. The lock will be released when the condition waits, in the // caller. state.nesting_level_ = m->nesting_level_; state.owner_id_ = m->owner_id_; m->nesting_level_ = 0; m->owner_id_ = ACE_OS::NULL_thread; return 0; # endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (state); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_destroy (  ACE_recursive_thread_mutex_t *    m )  [static]

Definition at line 2443 of file OS.i. References cond_destroy, ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_thread_mutex_t::nesting_mutex_, and thread_mutex_destroy. Referenced by ACE_OS_Object_Manager::fini, and ACE_Recursive_Thread_Mutex::remove. { #if defined (ACE_HAS_THREADS) #if defined (ACE_HAS_RECURSIVE_MUTEXES) return ACE_OS::thread_mutex_destroy (m); #else if (ACE_OS::thread_mutex_destroy (&m->nesting_mutex_) == -1) return -1; else if (ACE_OS::cond_destroy (&m->lock_available_) == -1) return -1; else return 0; #endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_init (  ACE_recursive_thread_mutex_t *    m, const ACE_TCHAR *    name = 0, ACE_mutexattr_t *    arg = 0, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

Definition at line 2410 of file OS.i. References ACE_TCHAR, cond_init, ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_thread_mutex_t::nesting_level_, ACE_recursive_thread_mutex_t::nesting_mutex_, NULL_thread, ACE_recursive_thread_mutex_t::owner_id_, and thread_mutex_init. Referenced by ACE_Recursive_Thread_Mutex::ACE_Recursive_Thread_Mutex, and ACE_OS_Object_Manager::init. { ACE_UNUSED_ARG (sa); #if defined (ACE_HAS_THREADS) #if defined (ACE_HAS_RECURSIVE_MUTEXES) return ACE_OS::thread_mutex_init (m, 0, name, arg); #else if (ACE_OS::thread_mutex_init (&m->nesting_mutex_, 0, name, arg) == -1) return -1; else if (ACE_OS::cond_init (&m->lock_available_, (short) USYNC_THREAD, name, 0) == -1) return -1; else { m->nesting_level_ = 0; m->owner_id_ = ACE_OS::NULL_thread; return 0; } #endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_lock (  ACE_recursive_thread_mutex_t *    m )  [static]

Definition at line 2463 of file OS.i. References ACE_thread_t, cond_wait, ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_thread_mutex_t::nesting_level_, ACE_recursive_thread_mutex_t::nesting_mutex_, ACE_recursive_thread_mutex_t::owner_id_, thr_equal, thr_self, thread_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Recursive_Thread_Mutex::acquire, and recursive_mutex_cond_relock. { #if defined (ACE_HAS_THREADS) #if defined (ACE_HAS_RECURSIVE_MUTEXES) return ACE_OS::thread_mutex_lock (m); #else ACE_thread_t t_id = ACE_OS::thr_self (); int result = 0; // Acquire the guard. if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1) result = -1; else { // If there's no contention, just grab the lock immediately // (since this is the common case we'll optimize for it). if (m->nesting_level_ == 0) m->owner_id_ = t_id; // If we already own the lock, then increment the nesting level // and return. else if (ACE_OS::thr_equal (t_id, m->owner_id_) == 0) { // Wait until the nesting level has dropped to zero, at // which point we can acquire the lock. while (m->nesting_level_ > 0) ACE_OS::cond_wait (&m->lock_available_, &m->nesting_mutex_); // At this point the nesting_mutex_ is held... m->owner_id_ = t_id; } // At this point, we can safely increment the nesting_level_ no // matter how we got here! m->nesting_level_++; } { // Save/restore errno. ACE_Errno_Guard error (errno); ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); } return result; #endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_trylock (  ACE_recursive_thread_mutex_t *    m )  [static]

Definition at line 2514 of file OS.i. References ACE_thread_t, EBUSY, ACE_recursive_thread_mutex_t::nesting_level_, ACE_recursive_thread_mutex_t::nesting_mutex_, ACE_recursive_thread_mutex_t::owner_id_, thr_equal, thr_self, thread_mutex_lock, thread_mutex_trylock, and thread_mutex_unlock. Referenced by ACE_Recursive_Thread_Mutex::tryacquire. { #if defined (ACE_HAS_THREADS) #if defined (ACE_HAS_RECURSIVE_MUTEXES) return ACE_OS::thread_mutex_trylock (m); #else ACE_thread_t t_id = ACE_OS::thr_self (); int result = 0; // Acquire the guard. if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1) result = -1; else { // If there's no contention, just grab the lock immediately. if (m->nesting_level_ == 0) { m->owner_id_ = t_id; m->nesting_level_ = 1; } // If we already own the lock, then increment the nesting level // and proceed. else if (ACE_OS::thr_equal (t_id, m->owner_id_)) m->nesting_level_++; else { errno = EBUSY; result = -1; } } { // Save/restore errno. ACE_Errno_Guard error (errno); ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); } return result; #endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_unlock (  ACE_recursive_thread_mutex_t *    m )  [static]

Definition at line 2559 of file OS.i. References ACE_OS_TRACE, ACE_thread_t, cond_signal, ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_thread_mutex_t::nesting_level_, ACE_recursive_thread_mutex_t::nesting_mutex_, NULL_thread, ACE_recursive_thread_mutex_t::owner_id_, thr_equal, thr_self, thread_mutex_lock, and thread_mutex_unlock. Referenced by recursive_mutex_cond_unlock, and ACE_Recursive_Thread_Mutex::release. { #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_RECURSIVE_MUTEXES) return ACE_OS::thread_mutex_unlock (m); # else ACE_OS_TRACE ("ACE_OS::recursive_mutex_unlock"); # if !defined (ACE_NDEBUG) ACE_thread_t t_id = ACE_OS::thr_self (); # endif /* ACE_NDEBUG */ int result = 0; if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1) result = -1; else { # if !defined (ACE_NDEBUG) if (m->nesting_level_ == 0 || ACE_OS::thr_equal (t_id, m->owner_id_) == 0) { errno = EINVAL; result = -1; } else # endif /* ACE_NDEBUG */ { m->nesting_level_--; if (m->nesting_level_ == 0) { // This may not be strictly necessary, but it does put // the mutex into a known state... m->owner_id_ = ACE_OS::NULL_thread; // Inform a waiter that the lock is free. if (ACE_OS::cond_signal (&m->lock_available_) == -1) result = -1; } } } { // Save/restore errno. ACE_Errno_Guard error (errno); ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); } return result; # endif /* ACE_HAS_RECURSIVE_MUTEXES */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recv (  ACE_HANDLE    handle, char *    buf, size_t    len, int    flags = 0 )  [static]

BSD-style <accept> (no QoS). Definition at line 4983 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, EWOULDBLOCK, and recv. Referenced by recv, ACE::recv, ACE::recv_i, and ACE::recv_n_i. { ACE_OS_TRACE ("ACE_OS::recv"); // On UNIX, a non-blocking socket with no data to receive, this // system call will return EWOULDBLOCK or EAGAIN, depending on the // platform. UNIX 98 allows either errno, and they may be the same // numeric value. So to make life easier for upper ACE layers as // well as application programmers, always change EAGAIN to // EWOULDBLOCK. Rather than hack the ACE_OSCALL_RETURN macro, it's // handled explicitly here. If the ACE_OSCALL macro ever changes, // this function needs to be reviewed. On Win32, the regular macros // can be used, as this is not an issue. #if defined (ACE_WIN32) ACE_SOCKCALL_RETURN (::recv ((ACE_SOCKET) handle, buf, ACE_static_cast (int, len), flags), int, -1); #else int ace_result_; ace_result_ = ::recv ((ACE_SOCKET) handle, buf, len, flags); if (ace_result_ == -1 && errno == EAGAIN) errno = EWOULDBLOCK; return ace_result_; #endif /* defined (ACE_WIN32) */ }

ACE_INLINE int ACE_OS::recvfrom (  ACE_HANDLE    handle, iovec *    buffers, int    buffer_count, size_t &    number_of_bytes_recvd, int &    flags, struct sockaddr *    addr, int *    addrlen, ACE_OVERLAPPED *    overlapped, ACE_OVERLAPPED_COMPLETION_FUNC    func )  [static]

BSD-style <accept> (no QoS). Definition at line 5086 of file OS.i. References ACE_OS_TRACE, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, and set_errno_to_last_error. { ACE_OS_TRACE ("ACE_OS::recvfrom"); #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) DWORD bytes_recvd; DWORD the_flags = flags; int result = ::WSARecvFrom ((SOCKET) handle, (WSABUF*)buffers, buffer_count, &bytes_recvd, &the_flags, addr, addrlen, overlapped, func); if (result != 0) { ACE_OS::set_errno_to_last_error (); } flags = the_flags; number_of_bytes_recvd = ACE_static_cast (size_t, bytes_recvd); return result; #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (buffers); ACE_UNUSED_ARG (buffer_count); ACE_UNUSED_ARG (number_of_bytes_recvd); ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (addr); ACE_UNUSED_ARG (addrlen); ACE_UNUSED_ARG (overlapped); ACE_UNUSED_ARG (func); ACE_NOTSUP_RETURN (-1); #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */ }

ACE_INLINE int ACE_OS::recvfrom (  ACE_HANDLE    handle, char *    buf, size_t    len, int    flags, struct sockaddr *    addr, int *    addrlen )  [static]

BSD-style <accept> (no QoS). Definition at line 5009 of file OS.i. References ACE_BIT_ENABLED, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, recvfrom, and set_errno_to_wsa_last_error. Referenced by ACE_WIN32_Asynch_Read_Dgram::recv, ACE_SOCK_Dgram::recv, recvfrom, and ACE::recvfrom. { ACE_OS_TRACE ("ACE_OS::recvfrom"); #if defined (ACE_PSOS) # if !defined ACE_PSOS_DIAB_PPC ACE_SOCKCALL_RETURN (::recvfrom ((ACE_SOCKET) handle, buf, len, flags, (struct sockaddr_in *) addr, (ACE_SOCKET_LEN *) addrlen), int, -1); # else ACE_SOCKCALL_RETURN (::recvfrom ((ACE_SOCKET) handle, buf, len, flags, (struct sockaddr *) addr, (ACE_SOCKET_LEN *) addrlen), int, -1); # endif /* defined ACE_PSOS_DIAB_PPC */ #elif defined (ACE_WIN32) int shortened_len = ACE_static_cast (int, len); int result = ::recvfrom ((ACE_SOCKET) handle, buf, shortened_len, flags, addr, (ACE_SOCKET_LEN *) addrlen); if (result == SOCKET_ERROR) { ACE_OS::set_errno_to_wsa_last_error (); if (errno == WSAEMSGSIZE && ACE_BIT_ENABLED (flags, MSG_PEEK)) return shortened_len; else return -1; } else return result; #else /* non Win32 and non PSOS */ ACE_SOCKCALL_RETURN (::recvfrom ((ACE_SOCKET) handle, buf, len, flags, addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #endif /* defined (ACE_PSOS) */ }

ACE_INLINE int ACE_OS::recvmsg (  ACE_HANDLE    handle, struct msghdr *    msg, int    flags )  [static]

Definition at line 5589 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, msghdr::msg_iov, msghdr::msg_iovlen, msghdr::msg_name, msghdr::msg_namelen, recvmsg, and set_errno_to_last_error. Referenced by recvmsg, and ACE::recvmsg. { ACE_OS_TRACE ("ACE_OS::recvmsg"); #if !defined (ACE_LACKS_RECVMSG) # if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)) DWORD bytes_received = 0; int result = ::WSARecvFrom ((SOCKET) handle, (WSABUF *) msg->msg_iov, msg->msg_iovlen, &bytes_received, (DWORD *) &flags, msg->msg_name, &msg->msg_namelen, 0, 0); if (result != 0) { ACE_OS::set_errno_to_last_error (); return -1; } else return (ssize_t) bytes_received; # else /* ACE_HAS_WINSOCK2 */ ACE_SOCKCALL_RETURN (::recvmsg (handle, msg, flags), int, -1); # endif /* ACE_HAS_WINSOCK2 */ #else ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (msg); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_LACKS_RECVMSG */ }

ACE_INLINE ssize_t ACE_OS::recvv (  ACE_HANDLE    handle, iovec *    iov, int    iovlen )  [static]

Definition at line 7500 of file OS.i. References iovec::iov_base, iovec::iov_len, readv, and set_errno_to_wsa_last_error. Referenced by ACE_SOCK_IO::recv, ACE::recv, ACE::recvv, and ACE::recvv_n_i. { #if defined (ACE_HAS_WINSOCK2) DWORD bytes_received = 0; int result = 1; // Winsock 2 has WSARecv and can do this directly, but Winsock 1 needs // to do the recvs piece-by-piece. # if (ACE_HAS_WINSOCK2 != 0) DWORD flags = 0; result = ::WSARecv ((SOCKET) handle, (WSABUF *) buffers, n, &bytes_received, &flags, 0, 0); # else int i, chunklen; char *chunkp = 0; // Step through the buffers requested by caller; for each one, cycle // through reads until it's filled or an error occurs. for (i = 0; i < n && result > 0; i++) { chunkp = buffers[i].iov_base; // Point to part of chunk being read chunklen = buffers[i].iov_len; // Track how much to read to chunk while (chunklen > 0 && result > 0) { result = ::recv ((SOCKET) handle, chunkp, chunklen, 0); if (result > 0) { chunkp += result; chunklen -= result; bytes_received += result; } } } # endif /* ACE_HAS_WINSOCK2 != 0 */ if (result == SOCKET_ERROR) { ACE_OS::set_errno_to_wsa_last_error (); return -1; } else return (ssize_t) bytes_received; #else return ACE_OS::readv (handle, buffers, n); #endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::rename (  const ACE_TCHAR *    old_name, const ACE_TCHAR *    new_name, int    flags = -1 )  [static]

Definition at line 797 of file OS.i. References ACE_TCHAR, and rename. Referenced by ACE_Logging_Strategy::handle_timeout, and rename. { # if defined (ACE_LACKS_RENAME) ACE_UNUSED_ARG (old_name); ACE_UNUSED_ARG (new_name); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (flags); if (MoveFile (old_name, new_name) != 0) ACE_FAIL_RETURN (-1); return 0; # elif defined (ACE_WIN32) && defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 == 1) // NT4 (and up) provides a way to rename/move a file with similar semantics // to what's usually done on UNIX - if there's an existing file with // <new_name> it is removed before the file is renamed/moved. The // MOVEFILE_COPY_ALLOWED is specified to allow such a rename across drives. if (flags == -1) flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING; if (ACE_TEXT_MoveFileEx(old_name, new_name, flags) == 0) ACE_FAIL_RETURN (-1); return 0; # elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_UNUSED_ARG (flags); ACE_OSCALL_RETURN (::_wrename (old_name, new_name), int, -1); # else /* ACE_LACKS_RENAME */ ACE_UNUSED_ARG (flags); ACE_OSCALL_RETURN (::rename (old_name, new_name), int, -1); # endif /* ACE_LACKS_RENAME */ }

ACE_INLINE void ACE_OS::rewind (  FILE *    fp )  [static]

Definition at line 7456 of file OS.i. References ACE_OS_TRACE. { #if !defined (ACE_HAS_WINCE) ACE_OS_TRACE ("ACE_OS::rewind"); ::rewind (fp); #else // In WinCE, "FILE *" is actually a HANDLE. ::SetFilePointer (fp, 0L, 0L, FILE_BEGIN); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::rw_rdlock (  ACE_rwlock_t *    rw )  [static]

Definition at line 3966 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_wait, mutex_lock, mutex_unlock, and rw_rdlock. Referenced by ACE_RW_Mutex::acquire_read, and rw_rdlock. { ACE_OS_TRACE ("ACE_OS::rw_rdlock"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_rdlock (rw), ace_result_), int, -1); # else /* Solaris */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_rdlock (rw), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # else /* NT, POSIX, and VxWorks don't support this natively. */ # if defined (ACE_HAS_PTHREADS) ACE_PTHREAD_CLEANUP_PUSH (&rw->lock_); # endif /* ACE_HAS_PTHREADS */ int result = 0; if (ACE_OS::mutex_lock (&rw->lock_) == -1) result = -1; // -1 means didn't get the mutex. else { // Give preference to writers who are waiting. while (rw->ref_count_ < 0 || rw->num_waiting_writers_ > 0) { rw->num_waiting_readers_++; if (ACE_OS::cond_wait (&rw->waiting_readers_, &rw->lock_) == -1) { result = -2; // -2 means that we need to release the mutex. break; } rw->num_waiting_readers_--; } } if (result == 0) rw->ref_count_++; if (result != -1) ACE_OS::mutex_unlock (&rw->lock_); # if defined (ACE_HAS_PTHREADS) ACE_PTHREAD_CLEANUP_POP (0); # endif /* defined (ACE_HAS_PTHREADS) */ return 0; # endif /* ! ACE_LACKS_RWLOCK_T */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::rw_tryrdlock (  ACE_rwlock_t *    rw )  [static]

Definition at line 3884 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, EBUSY, mutex_lock, mutex_unlock, and rw_tryrdlock. Referenced by rw_tryrdlock, and ACE_RW_Mutex::tryacquire_read. { ACE_OS_TRACE ("ACE_OS::rw_tryrdlock"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_tryrdlock (rw), ace_result_), int, -1); # else /* Solaris */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_tryrdlock (rw), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # else /* NT, POSIX, and VxWorks don't support this natively. */ int result = -1; if (ACE_OS::mutex_lock (&rw->lock_) != -1) { ACE_Errno_Guard error (errno); if (rw->ref_count_ == -1 || rw->num_waiting_writers_ > 0) { error = EBUSY; result = -1; } else { rw->ref_count_++; result = 0; } ACE_OS::mutex_unlock (&rw->lock_); } return result; # endif /* ! ACE_LACKS_RWLOCK_T */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::rw_trywrlock (  ACE_rwlock_t *    rw )  [static]

Definition at line 3925 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, EBUSY, mutex_lock, mutex_unlock, and rw_trywrlock. Referenced by rw_trywrlock, and ACE_RW_Mutex::tryacquire_write. { ACE_OS_TRACE ("ACE_OS::rw_trywrlock"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_trywrlock (rw), ace_result_), int, -1); # else /* Solaris */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_trywrlock (rw), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # else /* NT, POSIX, and VxWorks don't support this natively. */ int result = -1; if (ACE_OS::mutex_lock (&rw->lock_) != -1) { ACE_Errno_Guard error (errno); if (rw->ref_count_ != 0) { error = EBUSY; result = -1; } else { rw->ref_count_ = -1; result = 0; } ACE_OS::mutex_unlock (&rw->lock_); } return result; # endif /* ! ACE_LACKS_RWLOCK_T */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::rw_trywrlock_upgrade (  ACE_rwlock_t *    rw )  [static]

Definition at line 4127 of file OS.i. References ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_wait, EBUSY, mutex_lock, and mutex_unlock. Referenced by ACE_RW_Mutex::tryacquire_write_upgrade. { ACE_OS_TRACE ("ACE_OS::rw_trywrlock_upgrade"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) // Some native rwlocks, such as those on Solaris and HP-UX 11, don't // support the upgrade feature . . . ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); # else /* NT, POSIX, and VxWorks don't support this natively. */ // The ACE rwlock emulation does support upgrade . . . int result = 0; # if defined (ACE_HAS_PTHREADS) ACE_PTHREAD_CLEANUP_PUSH (&rw->lock_); # endif /* defined (ACE_HAS_PTHREADS) */ if (ACE_OS::mutex_lock (&rw->lock_) == -1) return -1; // -1 means didn't get the mutex, error else if (rw->important_writer_) // an other reader upgrades already { result = -1; errno = EBUSY; } else { while (rw->ref_count_ > 1) // wait until only I am left { rw->num_waiting_writers_++; // prohibit any more readers rw->important_writer_ = 1; if (ACE_OS::cond_wait (&rw->waiting_important_writer_, &rw->lock_) == -1) { result = -1; // we know that we have the lock again, we have this guarantee, // but something went wrong } rw->important_writer_ = 0; rw->num_waiting_writers_--; } if (result == 0) { // nothing bad happend rw->ref_count_ = -1; // now I am a writer // everything is O.K. } } ACE_OS::mutex_unlock (&rw->lock_); # if defined (ACE_HAS_PTHREADS) ACE_PTHREAD_CLEANUP_POP (0); # endif /* defined (ACE_HAS_PTHREADS) */ return result; # endif /* ! ACE_LACKS_RWLOCK_T */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::rw_unlock (  ACE_rwlock_t *    rw )  [static]

Definition at line 4066 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, cond_broadcast, cond_signal, mutex_lock, mutex_unlock, and rw_unlock. Referenced by ACE_RW_Mutex::release, and rw_unlock. { ACE_OS_TRACE ("ACE_OS::rw_unlock"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_unlock (rw), ace_result_), int, -1); # else /* Solaris */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_unlock (rw), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # else /* NT, POSIX, and VxWorks don't support this natively. */ if (ACE_OS::mutex_lock (&rw->lock_) == -1) return -1; if (rw->ref_count_ > 0) // Releasing a reader. rw->ref_count_--; else if (rw->ref_count_ == -1) // Releasing a writer. rw->ref_count_ = 0; else return -1; // @@ ACE_ASSERT (!"count should not be 0!\n"); int result = 0; ACE_Errno_Guard error (errno); if (rw->important_writer_ && rw->ref_count_ == 1) // only the reader requesting to upgrade its lock is left over. { result = ACE_OS::cond_signal (&rw->waiting_important_writer_); error = errno; } else if (rw->num_waiting_writers_ > 0 && rw->ref_count_ == 0) // give preference to writers over readers... { result = ACE_OS::cond_signal (&rw->waiting_writers_); error = errno; } else if (rw->num_waiting_readers_ > 0 && rw->num_waiting_writers_ == 0) { result = ACE_OS::cond_broadcast (&rw->waiting_readers_); error = errno; } ACE_OS::mutex_unlock (&rw->lock_); return result; # endif /* ! ace_lacks_rwlock_t */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ace_has_threads */ }

ACE_INLINE int ACE_OS::rw_wrlock (  ACE_rwlock_t *    rw )  [static]

Definition at line 4015 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_wait, mutex_lock, mutex_unlock, and rw_wrlock. Referenced by ACE_RW_Mutex::acquire, ACE_RW_Mutex::acquire_write, and rw_wrlock. { ACE_OS_TRACE ("ACE_OS::rw_wrlock"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_wrlock (rw), ace_result_), int, -1); # else /* Solaris */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_wrlock (rw), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # else /* NT, POSIX, and VxWorks don't support this natively. */ # if defined (ACE_HAS_PTHREADS) ACE_PTHREAD_CLEANUP_PUSH (&rw->lock_); # endif /* defined (ACE_HAS_PTHREADS) */ int result = 0; if (ACE_OS::mutex_lock (&rw->lock_) == -1) result = -1; // -1 means didn't get the mutex. else { while (rw->ref_count_ != 0) { rw->num_waiting_writers_++; if (ACE_OS::cond_wait (&rw->waiting_writers_, &rw->lock_) == -1) { result = -2; // -2 means we need to release the mutex. break; } rw->num_waiting_writers_--; } } if (result == 0) rw->ref_count_ = -1; if (result != -1) ACE_OS::mutex_unlock (&rw->lock_); # if defined (ACE_HAS_PTHREADS) ACE_PTHREAD_CLEANUP_POP (0); # endif /* defined (ACE_HAS_PTHREADS) */ return 0; # endif /* ! ACE_LACKS_RWLOCK_T */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::rwlock_destroy (  ACE_rwlock_t *    rw )  [static]

Definition at line 4226 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, cond_destroy, mutex_destroy, and rwlock_destroy. Referenced by ACE_RW_Mutex::remove, and rwlock_destroy. { ACE_OS_TRACE ("ACE_OS::rwlock_destroy"); #if defined (ACE_HAS_THREADS) # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_destroy (rw), ace_result_), int, -1); # else /* Solaris */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rwlock_destroy (rw), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # else /* NT, POSIX, and VxWorks don't support this natively. */ ACE_OS::mutex_destroy (&rw->lock_); ACE_OS::cond_destroy (&rw->waiting_readers_); ACE_OS::cond_destroy (&rw->waiting_important_writer_); return ACE_OS::cond_destroy (&rw->waiting_writers_); # endif /* ACE_HAS_STHREADS && !defined (ACE_LACKS_RWLOCK_T) */ #else ACE_UNUSED_ARG (rw); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::rwlock_init (  ACE_rwlock_t *    rw, int    type = ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR *    name = 0, void *    arg = 0 )  [static]

Referenced by ACE_RW_Mutex::ACE_RW_Mutex.

int ACE_OS::sched_params (  const ACE_Sched_Params &   , ACE_id_t    id = ACE_SELF )  [static]

Set scheduling parameters. An id of ACE_SELF indicates, e.g., set the parameters on the calling thread. Definition at line 1433 of file OS.cpp. References ACE_ADAPT_RETVAL, ACE_id_t, ACE_OS_TRACE, ACE_SCHED_FIFO, ACE_SCOPE_LWP, ACE_SCOPE_PROCESS, ACE_SCOPE_THREAD, ACE_SELF, ACE_thread_t, ACE_Time_Value::msec, ACE_Sched_Params::policy, ACE_Sched_Params::priority, ACE_Sched_Params::quantum, ACE_Sched_Params::scope, set_errno_to_last_error, set_scheduling_params, thr_self, thr_setprio, and ACE_Time_Value::zero. Referenced by lwp_setparams, thr_create, and thr_setprio. { ACE_OS_TRACE ("ACE_OS::sched_params"); # if defined (CHORUS) ACE_UNUSED_ARG (id); int result; struct sched_param param; ACE_thread_t thr_id = ACE_OS::thr_self (); param.sched_priority = sched_params.priority (); ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setschedparam (thr_id, sched_params.policy (), &param), result), int, -1); # elif defined (ACE_HAS_STHREADS) return ACE_OS::set_scheduling_params (sched_params, id); # elif defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_SETSCHED) ACE_UNUSED_ARG (id); if (sched_params.quantum () != ACE_Time_Value::zero) { // quantums not supported errno = EINVAL; return -1; } // Thanks to Thilo Kielmann <kielmann@informatik.uni-siegen.de> for // providing this code for 1003.1c PThreads. Please note that this // has only been tested for POSIX 1003.1c threads, and may cause // problems with other PThreads flavors! struct sched_param param; param.sched_priority = sched_params.priority (); if (sched_params.scope () == ACE_SCOPE_PROCESS) { int result = ::sched_setscheduler (0, // this process sched_params.policy (), &param) == -1 ? -1 : 0; # if defined (DIGITAL_UNIX) return result == 0 ? // Use priocntl (2) to set the process in the RT class, // if using an RT policy. ACE_OS::set_scheduling_params (sched_params) : result; # else /* ! DIGITAL_UNIX */ return result; # endif /* ! DIGITAL_UNIX */ } else if (sched_params.scope () == ACE_SCOPE_THREAD) { ACE_thread_t thr_id = ACE_OS::thr_self (); # if defined (ACE_HAS_PTHREADS_DRAFT4) return (::pthread_setscheduler (thr_id, sched_params.policy (), sched_params.priority()) == -1 ? -1 : 0); # else int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setschedparam (thr_id, sched_params.policy (), &param), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ } # if defined (sun) // We need to be able to set LWP priorities on Suns, even without // ACE_HAS_STHREADS, to obtain preemption. else if (sched_params.scope () == ACE_SCOPE_LWP) return ACE_OS::set_scheduling_params (sched_params, id); # endif /* sun */ else // sched_params.scope () == ACE_SCOPE_LWP, which isn't POSIX { errno = EINVAL; return -1; } # elif defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) // PharLap ETS can act on the current thread - it can set the // quantum also, unlike Win32. All this only works on the RT // version. # if defined (ACE_HAS_PHARLAP_RT) if (id != ACE_SELF) ACE_NOTSUP_RETURN (-1); if (sched_params.quantum() != ACE_Time_Value::zero) EtsSetTimeSlice (sched_params.quantum().msec()); # else ACE_UNUSED_ARG (id); if (sched_params.scope () != ACE_SCOPE_PROCESS || sched_params.quantum () != ACE_Time_Value::zero) { // Win32 only allows setting priority class (therefore, policy) // at the process level. I don't know of a way to set the // quantum. errno = EINVAL; return -1; } #ifndef ACE_DISABLE_WIN32_INCREASE_PRIORITY // Set the priority class of this process to the REALTIME process class // _if_ the policy is ACE_SCHED_FIFO. Otherwise, set to NORMAL. if (!::SetPriorityClass (::GetCurrentProcess (), sched_params.policy () == ACE_SCHED_FIFO ? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS)) { ACE_OS::set_errno_to_last_error (); return -1; } #endif # endif /* ACE_HAS_PHARLAP_RT */ // Set the thread priority on the current thread. return ACE_OS::thr_setprio (sched_params.priority ()); # elif defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (id); // There is only one class of priorities on VxWorks, and no time // quanta. So, just set the current thread's priority. if (sched_params.policy () != ACE_SCHED_FIFO || sched_params.scope () != ACE_SCOPE_PROCESS || sched_params.quantum () != ACE_Time_Value::zero) { errno = EINVAL; return -1; } // Set the thread priority on the current thread. return ACE_OS::thr_setprio (sched_params.priority ()); # else ACE_UNUSED_ARG (sched_params); ACE_UNUSED_ARG (id); ACE_NOTSUP_RETURN (-1); # endif /* CHORUS */ }

int ACE_OS::scheduling_class (  const char *    class_name, ACE_id_t &    )  [static]

Find the schedling class ID that corresponds to the class name. Definition at line 1269 of file OS.cpp. References ACE_id_t, ACE_OS_String::memset, priority_control, and ACE_OS_String::strcpy. Referenced by lwp_getparams, and set_scheduling_params. { #if defined (ACE_HAS_PRIOCNTL) // Get the priority class ID. pcinfo_t pcinfo; // The following is just to avoid Purify warnings about unitialized // memory reads. ACE_OS::memset (&pcinfo, 0, sizeof pcinfo); ACE_OS::strcpy (pcinfo.pc_clname, class_name); if (ACE_OS::priority_control (P_ALL /* ignored */, P_MYID /* ignored */, PC_GETCID, (char *) &pcinfo) == -1) { return -1; } else { id = pcinfo.pc_cid; return 0; } #else /* ! ACE_HAS_PRIOCNTL */ ACE_UNUSED_ARG (class_name); ACE_UNUSED_ARG (id); ACE_NOTSUP_RETURN (-1); #endif /* ! ACE_HAS_PRIOCNTL */ }

ACE_INLINE int ACE_OS::select (  int    width, fd_set *    rfds, fd_set *    wfds, fd_set *    efds, const ACE_Time_Value &    tv )  [static]

Definition at line 4961 of file OS.i. References ACE_FD_SET_TYPE, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and select. { ACE_OS_TRACE ("ACE_OS::select"); #if defined (ACE_HAS_NONCONST_SELECT_TIMEVAL) # define ___ACE_TIMEOUT &copy timeval copy = timeout; #else # define ___ACE_TIMEOUT timep const timeval *timep = timeout; #endif /* ACE_HAS_NONCONST_SELECT_TIMEVAL */ ACE_SOCKCALL_RETURN (::select (width, (ACE_FD_SET_TYPE *) rfds, (ACE_FD_SET_TYPE *) wfds, (ACE_FD_SET_TYPE *) efds, ___ACE_TIMEOUT), int, -1); #undef ___ACE_TIMEOUT }

ACE_INLINE int ACE_OS::select (  int    width, fd_set *    rfds, fd_set *    wfds = 0, fd_set *    efds = 0, const ACE_Time_Value *    tv = 0 )  [static]

Definition at line 4932 of file OS.i. References ACE_FD_SET_TYPE, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and select. Referenced by ACE_Select_Reactor_T::check_handles, ACE_FlReactor::fl_io_proc, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::handle_input, ACE::handle_ready, ACE::handle_timed_accept, ACE::handle_timed_complete, ACE_XtReactor::InputCallbackProc, ACE_TkReactor::InputCallbackProc, ACE_QtReactor::QtWaitForMultipleEvents, ACE_SOCK_Dgram::recv, ACE_SOCK_Dgram_SC::recv, ACE_SOCK_IO::recvv, select, ACE::select, ACE_SOCK_Dgram::send, sleep, ACE_TkReactor::TkWaitForMultipleEvents, ACE_Select_Reactor_T::wait_for_multiple_events, ACE_FlReactor::wait_for_multiple_events, ACE_Select_Reactor_T::work_pending, and ACE_XtReactor::XtWaitForMultipleEvents. { ACE_OS_TRACE ("ACE_OS::select"); #if defined (ACE_HAS_NONCONST_SELECT_TIMEVAL) // We must defend against non-conformity! timeval copy; timeval *timep; if (timeout != 0) { copy = *timeout; timep = &copy; } else timep = 0; #else const timeval *timep = (timeout == 0 ? (const timeval *)0 : *timeout); #endif /* ACE_HAS_NONCONST_SELECT_TIMEVAL */ ACE_SOCKCALL_RETURN (::select (width, (ACE_FD_SET_TYPE *) rfds, (ACE_FD_SET_TYPE *) wfds, (ACE_FD_SET_TYPE *) efds, timep), int, -1); }

int ACE_OS::select_i (  int    width, fd_set *    rfds, fd_set *    wfds, fd_set *    efds, const ACE_Time_Value &    tv )  [static, private]

int ACE_OS::select_i (  int    width, fd_set *    rfds, fd_set *    wfds, fd_set *    efds, const ACE_Time_Value *    tv = 0 )  [static, private]

ACE_INLINE int ACE_OS::sema_destroy (  ACE_sema_t *    s )  [static]

Definition at line 2760 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, cond_destroy, event_destroy, ACE_OS_Memory::free, mutex_destroy, sema_destroy, shm_unlink, and thread_mutex_destroy. Referenced by ACE_Semaphore::remove, and sema_destroy. { ACE_OS_TRACE ("ACE_OS::sema_destroy"); # if defined (ACE_HAS_POSIX_SEM) int result; # if defined (ACE_LACKS_NAMED_POSIX_SEM) if (s->name_) { // Only destroy the semaphore if we're the ones who // initialized it. ACE_OSCALL (::sem_destroy (s->sema_),int, -1, result); ACE_OS::shm_unlink (s->name_); delete s->name_; return result; } # else if (s->name_) { ACE_OSCALL (::sem_unlink (s->name_), int, -1, result); ACE_OS::free ((void *) s->name_); ACE_OSCALL_RETURN (::sem_close (s->sema_), int, -1); } # endif /* ACE_LACKS_NAMED_POSIX_SEM */ else { ACE_OSCALL (::sem_destroy (s->sema_), int, -1, result); # if defined (ACE_LACKS_NAMED_POSIX_SEM) if (s->new_sema_ != 0) # endif /* ACE_LACKS_NAMED_POSIX_SEM */ delete s->sema_; s->sema_ = 0; return result; } # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_destroy (s), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) int r1 = ACE_OS::mutex_destroy (&s->lock_); int r2 = ACE_OS::cond_destroy (&s->count_nonzero_); return r1 != 0 || r2 != 0 ? -1 : 0; # elif defined (ACE_HAS_WTHREADS) # if !defined (ACE_USES_WINCE_SEMA_SIMULATION) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (*s), ace_result_), int, -1); # else /* ACE_USES_WINCE_SEMA_SIMULATION */ // Free up underlying objects of the simulated semaphore. int r1 = ACE_OS::thread_mutex_destroy (&s->lock_); int r2 = ACE_OS::event_destroy (&s->count_nonzero_); return r1 != 0 || r2 != 0 ? -1 : 0; # endif /* ACE_USES_WINCE_SEMA_SIMULATION */ # elif defined (ACE_PSOS) int result; ACE_OSCALL (ACE_ADAPT_RETVAL (::sm_delete (s->sema_), result), int, -1, result); s->sema_ = 0; return result; # elif defined (VXWORKS) int result; ACE_OSCALL (::semDelete (s->sema_), int, -1, result); s->sema_ = 0; return result; # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (s); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_POSIX_SEM */ }

int ACE_OS::sema_init (  ACE_sema_t *    s, u_int    count, int    type, const wchar_t *    name, void *    arg = 0, int    max = 0x7fffffff, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

ACE_INLINE int ACE_OS::sema_init (  ACE_sema_t *    s, u_int    count, int    type = ACE_DEFAULT_SYNCH_TYPE, const char *    name = 0, void *    arg = 0, int    max = 0x7fffffff, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

Definition at line 3083 of file OS.i. References ACE_ADAPT_RETVAL, ACE_ALLOCATOR_RETURN, ACE_DEFAULT_FILE_PERMS, ACE_NEW_RETURN, ACE_OS_TRACE, close, cond_destroy, cond_init, default_win32_security_attributes, event_destroy, event_init, ftruncate, MAP_FAILED, MAP_SHARED, MAXPATHLEN, ACE_OS_String::memcpy, mmap, mutex_destroy, mutex_init, mutex_lock, mutex_unlock, PROT_RDWR, sema_init, shm_open, ACE_OS_String::strcat, ACE_OS_String::strcpy, ACE_OS_String::strdup, ACE_OS_String::strrchr, thread_mutex_destroy, thread_mutex_init, thread_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Semaphore::ACE_Semaphore, and sema_init. { ACE_OS_TRACE ("ACE_OS::sema_init"); #if defined (ACE_HAS_POSIX_SEM) ACE_UNUSED_ARG (arg); ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); s->name_ = 0; # if defined (ACE_LACKS_NAMED_POSIX_SEM) s->new_sema_ = 0; if (type == USYNC_PROCESS) { // Let's see if it already exists. ACE_HANDLE fd = ACE_OS::shm_open (name, O_RDWR | O_CREAT | O_EXCL, ACE_DEFAULT_FILE_PERMS); if (fd == ACE_INVALID_HANDLE) { if (errno == EEXIST) fd = ACE_OS::shm_open (name, O_RDWR | O_CREAT, ACE_DEFAULT_FILE_PERMS); else return -1; } else { // We own this shared memory object! Let's set its // size. if (ACE_OS::ftruncate (fd, sizeof (ACE_sema_t)) == -1) return -1; s->name_ = ACE_OS::strdup (name); if (s->name_ == 0) return -1; } if (fd == -1) return -1; s->sema_ = (sem_t *) ACE_OS::mmap (0, sizeof (ACE_sema_t), PROT_RDWR, MAP_SHARED, fd, 0); ACE_OS::close (fd); if (s->sema_ == (sem_t *) MAP_FAILED) return -1; if (s->name_ // @@ According UNIX Network Programming V2 by Stevens, // sem_init() is currently not required to return zero on // success, but it *does* return -1 upon failure. For // this reason, check for failure by comparing to -1, // instead of checking for success by comparing to zero. // -Ossama // Only initialize it if we're the one who created it. && ::sem_init (s->sema_, type == USYNC_PROCESS, count) == -1) return -1; return 0; } # else if (name) { # if defined (sun) || defined (HPUX) // Solaris and HP-UX require the name to start with a slash. Solaris // further requires that there be no other slashes than the first. const char *last_slash = ACE_OS::strrchr (name, '/'); char name2[MAXPATHLEN]; if (0 == last_slash) { ACE_OS::strcpy (name2, "/"); ACE_OS::strcat (name2, name); name = name2; } # if defined (sun) else name = last_slash; // Chop off chars preceding last slash # endif /* sun */ # endif /* sun || HPUX */ ACE_ALLOCATOR_RETURN (s->name_, ACE_OS::strdup (name), -1); s->sema_ = ::sem_open (s->name_, O_CREAT, ACE_DEFAULT_FILE_PERMS, count); if (s->sema_ == (sem_t *) SEM_FAILED) return -1; else return 0; } # endif /* ACE_LACKS_NAMED_POSIX_SEM */ else { ACE_NEW_RETURN (s->sema_, sem_t, -1); # if defined (ACE_LACKS_NAMED_POSIX_SEM) s->new_sema_ = 1; # endif /* ACE_LACKS_NAMED_POSIX_SEM */ ACE_OSCALL_RETURN (::sem_init (s->sema_, type != USYNC_THREAD, count), int, -1); } #elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_init (s, count, type, arg), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); int result = -1; if (ACE_OS::mutex_init (&s->lock_, type, name, (ACE_mutexattr_t *) arg) == 0 && ACE_OS::cond_init (&s->count_nonzero_, type, name, arg) == 0 && ACE_OS::mutex_lock (&s->lock_) == 0) { s->count_ = count; s->waiters_ = 0; if (ACE_OS::mutex_unlock (&s->lock_) == 0) result = 0; } if (result == -1) { ACE_OS::mutex_destroy (&s->lock_); ACE_OS::cond_destroy (&s->count_nonzero_); } return result; # elif defined (ACE_HAS_WTHREADS) # if ! defined (ACE_USES_WINCE_SEMA_SIMULATION) ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (arg); // Create the semaphore with its value initialized to <count> and // its maximum value initialized to <max>. *s = ::CreateSemaphoreA (ACE_OS::default_win32_security_attributes (sa), count, max, name); if (*s == 0) ACE_FAIL_RETURN (-1); /* NOTREACHED */ else return 0; # else /* ACE_USES_WINCE_SEMA_SIMULATION */ int result = -1; // Initialize internal object for semaphore simulation. // Grab the lock as soon as possible when we initializing // the semaphore count. Notice that we initialize the // event object as "manually reset" so we can amortize the // cost for singling/reseting the event. // @@ I changed the mutex type to thread_mutex. Notice that this // is basically a CriticalSection object and doesn't not has // any security attribute whatsoever. However, since this // semaphore implementation only works within a process, there // shouldn't any security issue at all. if (ACE_OS::thread_mutex_init (&s->lock_, type, name, (ACE_mutexattr_t *)arg) == 0 && ACE_OS::event_init (&s->count_nonzero_, 1, count > 0, type, name, arg, sa) == 0 && ACE_OS::thread_mutex_lock (&s->lock_) == 0) { s->count_ = count; if (ACE_OS::thread_mutex_unlock (&s->lock_) == 0) result = 0; } // Destroy the internal objects if we didn't initialize // either of them successfully. Don't bother to check // for errors. if (result == -1) { ACE_OS::thread_mutex_destroy (&s->lock_); ACE_OS::event_destroy (&s->count_nonzero_); } return result; # endif /* ACE_USES_WINCE_SEMA_SIMULATION */ # elif defined (ACE_PSOS) u_long result; ACE_OS::memcpy (s->name_, name, sizeof (s->name_)); // default semaphore creation flags to priority based, global across nodes u_long flags = 0; flags |= (type & SM_LOCAL) ? SM_LOCAL : SM_GLOBAL; flags |= (type & SM_FIFO) ? SM_FIFO : SM_PRIOR; result = ::sm_create (s->name_, count, flags, &(s->sema_)); return (result == 0) ? 0 : -1; # elif defined (VXWORKS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); s->name_ = 0; s->sema_ = ::semCCreate (type, count); return s->sema_ ? 0 : -1; # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (s); ACE_UNUSED_ARG (count); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_POSIX_SEM */ }

ACE_INLINE int ACE_OS::sema_post (  ACE_sema_t *    s, u_int    release_count )  [static]

Definition at line 3438 of file OS.i. References ACE_ADAPT_RETVAL, and sema_post. { #if defined (ACE_WIN32) && !defined (ACE_USES_WINCE_SEMA_SIMULATION) // Win32 supports this natively. ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ReleaseSemaphore (*s, release_count, 0), ace_result_), int, -1); #else // On POSIX platforms we need to emulate this ourselves. // @@ We can optimize on this implementation. However, // the semaphore promitive on Win32 doesn't allow one // to increase a semaphore to more than the count it was // first initialized. Posix and solaris don't seem to have // this restriction. Should we impose the restriction in // our semaphore simulation? for (size_t i = 0; i < release_count; i++) if (ACE_OS::sema_post (s) == -1) return -1; return 0; #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::sema_post (  ACE_sema_t *    s )  [static]

Definition at line 3377 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, cond_signal, event_signal, mutex_lock, mutex_unlock, sema_post, thread_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Semaphore::release, and sema_post. { ACE_OS_TRACE ("ACE_OS::sema_post"); # if defined (ACE_HAS_POSIX_SEM) ACE_OSCALL_RETURN (::sem_post (s->sema_), int, -1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_post (s), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) int result = -1; if (ACE_OS::mutex_lock (&s->lock_) == 0) { // Always allow a waiter to continue if there is one. if (s->waiters_ > 0) result = ACE_OS::cond_signal (&s->count_nonzero_); else result = 0; s->count_++; ACE_OS::mutex_unlock (&s->lock_); } return result; # elif defined (ACE_HAS_WTHREADS) # if !defined (ACE_USES_WINCE_SEMA_SIMULATION) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ReleaseSemaphore (*s, 1, 0), ace_result_), int, -1); # else /* ACE_USES_WINCE_SEMA_SIMULATION */ int result = -1; // Since we are simulating semaphores, we need to update semaphore // count manually. Grab the lock to prevent race condition first. if (ACE_OS::thread_mutex_lock (&s->lock_) == 0) { // Check the original state of event object. Single the event // object in transition from semaphore not available to // semaphore available. if (s->count_++ <= 0) result = ACE_OS::event_signal (&s->count_nonzero_); else result = 0; ACE_OS::thread_mutex_unlock (&s->lock_); } return result; # endif /* ACE_USES_WINCE_SEMA_SIMULATION */ # elif defined (ACE_PSOS) int result; ACE_OSCALL (ACE_ADAPT_RETVAL (::sm_v (s->sema_), result), int, -1, result); return result; # elif defined (VXWORKS) ACE_OSCALL_RETURN (::semGive (s->sema_), int, -1); # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (s); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_POSIX_SEM */ }

ACE_INLINE int ACE_OS::sema_trywait (  ACE_sema_t *    s )  [static]

Definition at line 3461 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, EBUSY, event_reset, mutex_lock, mutex_unlock, sema_trywait, set_errno_to_last_error, thread_mutex_lock, and thread_mutex_unlock. Referenced by sema_trywait, and ACE_Semaphore::tryacquire. { ACE_OS_TRACE ("ACE_OS::sema_trywait"); # if defined (ACE_HAS_POSIX_SEM) // POSIX semaphores set errno to EAGAIN if trywait fails ACE_OSCALL_RETURN (::sem_trywait (s->sema_), int, -1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) // STHREADS semaphores set errno to EBUSY if trywait fails. ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_trywait (s), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) int result = -1; if (ACE_OS::mutex_lock (&s->lock_) == 0) { if (s->count_ > 0) { --s->count_; result = 0; } else errno = EBUSY; ACE_OS::mutex_unlock (&s->lock_); } return result; # elif defined (ACE_HAS_WTHREADS) # if !defined (ACE_USES_WINCE_SEMA_SIMULATION) int result = ::WaitForSingleObject (*s, 0); if (result == WAIT_OBJECT_0) return 0; else { if (result == WAIT_TIMEOUT) errno = EBUSY; else ACE_OS::set_errno_to_last_error (); // This is a hack, we need to find an appropriate mapping... return -1; } # else /* ACE_USES_WINCE_SEMA_SIMULATION */ // Check the status of semaphore first. Return immediately // if the semaphore is not available and avoid grabing the // lock. int result = ::WaitForSingleObject (s->count_nonzero_, 0); if (result == WAIT_OBJECT_0) // Proceed when it is available. { ACE_OS::thread_mutex_lock (&s->lock_); // Need to double check if the semaphore is still available. // The double checking scheme will slightly affect the // efficiency if most of the time semaphores are not blocked. result = ::WaitForSingleObject (s->count_nonzero_, 0); if (result == WAIT_OBJECT_0) { // Adjust the semaphore count. Only update the event // object status when the state changed. s->count_--; if (s->count_ <= 0) ACE_OS::event_reset (&s->count_nonzero_); result = 0; } ACE_OS::thread_mutex_unlock (&s->lock_); } // Translate error message to errno used by ACE. if (result == WAIT_TIMEOUT) errno = EBUSY; else ACE_OS::set_errno_to_last_error (); // This is taken from the hack above. ;) return -1; # endif /* ACE_USES_WINCE_SEMA_SIMULATION */ # elif defined (ACE_PSOS) switch (::sm_p (s->sema_, SM_NOWAIT, 0)) { case 0: return 0; case ERR_NOSEM: errno = EBUSY; // intentional fall through default: return -1; } # elif defined (VXWORKS) if (::semTake (s->sema_, NO_WAIT) == ERROR) if (errno == S_objLib_OBJ_UNAVAILABLE) { // couldn't get the semaphore errno = EBUSY; return -1; } else // error return -1; else // got the semaphore return 0; # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (s); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_POSIX_SEM */ }

ACE_INLINE int ACE_OS::sema_wait (  ACE_sema_t *    s, ACE_Time_Value *    tv )  [static]

Definition at line 3878 of file OS.i. References sema_wait. { return tv == 0 ? ACE_OS::sema_wait (s) : ACE_OS::sema_wait (s, *tv); }

ACE_INLINE int ACE_OS::sema_wait (  ACE_sema_t *    s, ACE_Time_Value &    tv )  [static]

Definition at line 3681 of file OS.i. References ACE_ONE_SECOND_IN_USECS, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_timedwait, EBUSY, ETIME, event_reset, gettimeofday, ACE_Time_Value::msec, mutex_lock, mutex_unlock, ACE_Time_Value::sec, set_errno_to_last_error, thread_mutex_lock, thread_mutex_unlock, ACE_Time_Value::usec, and ACE_Time_Value::zero. { ACE_OS_TRACE ("ACE_OS::sema_wait"); # if defined (ACE_HAS_POSIX_SEM) ACE_UNUSED_ARG (s); ACE_UNUSED_ARG (tv); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (s); ACE_UNUSED_ARG (tv); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_PTHREADS) int result = 0; ACE_Errno_Guard error (errno); ACE_PTHREAD_CLEANUP_PUSH (&s->lock_); if (ACE_OS::mutex_lock (&s->lock_) != 0) result = -1; else { // Keep track of the number of waiters so that we can signal // them properly in <ACE_OS::sema_post>. s->waiters_++; // Wait until the semaphore count is > 0 or until we time out. while (s->count_ == 0) if (ACE_OS::cond_timedwait (&s->count_nonzero_, &s->lock_, &tv) == -1) { error = errno; result = -2; // -2 means that we need to release the mutex. break; } --s->waiters_; } if (result == 0) { # if defined (ACE_LACKS_COND_TIMEDWAIT_RESET) tv = ACE_OS::gettimeofday (); # endif /* ACE_LACKS_COND_TIMEDWAIT_RESET */ --s->count_; } if (result != -1) ACE_OS::mutex_unlock (&s->lock_); ACE_PTHREAD_CLEANUP_POP (0); return result < 0 ? -1 : result; # elif defined (ACE_HAS_WTHREADS) # if !defined (ACE_USES_WINCE_SEMA_SIMULATION) int msec_timeout; if (tv.sec () == 0 && tv.usec () == 0) msec_timeout = 0; // Do a "poll." else { // Note that we must convert between absolute time (which is // passed as a parameter) and relative time (which is what // <WaitForSingleObjects> expects). ACE_Time_Value relative_time (tv - ACE_OS::gettimeofday ()); // Watchout for situations where a context switch has caused the // current time to be > the timeout. if (relative_time < ACE_Time_Value::zero) msec_timeout = 0; else msec_timeout = relative_time.msec (); } switch (::WaitForSingleObject (*s, msec_timeout)) { case WAIT_OBJECT_0: tv = ACE_OS::gettimeofday (); // Update time to when acquired return 0; case WAIT_TIMEOUT: errno = ETIME; return -1; default: // This is a hack, we need to find an appropriate mapping... ACE_OS::set_errno_to_last_error (); return -1; } /* NOTREACHED */ # else /* ACE_USES_WINCE_SEMA_SIMULATION */ // Note that in this mode, the acquire is done in two steps, and // we may get signaled but cannot grab the semaphore before // timeout. In that case, we'll need to restart the process with // updated timeout value. // <tv> is an absolute time ACE_Time_Value relative_time = tv - ACE_OS::gettimeofday (); int result = -1; // While we are not timeout yet. while (relative_time > ACE_Time_Value::zero) { // Wait for our turn to get the object. switch (::WaitForSingleObject (s->count_nonzero_, relative_time.msec ())) { case WAIT_OBJECT_0: ACE_OS::thread_mutex_lock (&s->lock_); // Need to double check if the semaphore is still available. // We can only do a "try lock" styled wait here to avoid // blocking threads that want to signal the semaphore. if (::WaitForSingleObject (s->count_nonzero_, 0) == WAIT_OBJECT_0) { // As before, only reset the object when the semaphore // is no longer available. s->count_--; if (s->count_ <= 0) ACE_OS::event_reset (&s->count_nonzero_); result = 0; } ACE_OS::thread_mutex_unlock (&s->lock_); // Only return when we successfully get the semaphore. if (result == 0) { tv = ACE_OS::gettimeofday (); // Update to time acquired return 0; } break; // We have timed out. case WAIT_TIMEOUT: errno = ETIME; return -1; // What? default: ACE_OS::set_errno_to_last_error (); // This is taken from the hack above. ;) return -1; }; // Haven't been able to get the semaphore yet, update the // timeout value to reflect the remaining time we want to wait. relative_time = tv - ACE_OS::gettimeofday (); } // We have timed out. errno = ETIME; return -1; # endif /* ACE_USES_WINCE_SEMA_SIMULATION */ # elif defined (ACE_PSOS) // Note that we must convert between absolute time (which is // passed as a parameter) and relative time (which is what // the system call expects). ACE_Time_Value relative_time (tv - ACE_OS::gettimeofday ()); u_long ticks = relative_time.sec() * KC_TICKS2SEC + relative_time.usec () * KC_TICKS2SEC / ACE_ONE_SECOND_IN_USECS; if(ticks == 0) ACE_OSCALL_RETURN (::sm_p (s->sema_, SM_NOWAIT, 0), int, -1); //no timeout else ACE_OSCALL_RETURN (::sm_p (s->sema_, SM_WAIT, ticks), int, -1); # elif defined (VXWORKS) // Note that we must convert between absolute time (which is // passed as a parameter) and relative time (which is what // the system call expects). ACE_Time_Value relative_time (tv - ACE_OS::gettimeofday ()); int ticks_per_sec = ::sysClkRateGet (); int ticks = relative_time.sec() * ticks_per_sec + relative_time.usec () * ticks_per_sec / ACE_ONE_SECOND_IN_USECS; if (::semTake (s->sema_, ticks) == ERROR) { if (errno == S_objLib_OBJ_TIMEOUT) // Convert the VxWorks errno to one that's common for to ACE // platforms. errno = ETIME; else if (errno == S_objLib_OBJ_UNAVAILABLE) errno = EBUSY; return -1; } else { tv = ACE_OS::gettimeofday (); // Update to time acquired return 0; } # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (s); ACE_UNUSED_ARG (tv); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_POSIX_SEM */ }

ACE_INLINE int ACE_OS::sema_wait (  ACE_sema_t *    s )  [static]

Definition at line 3573 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_wait, event_reset, mutex_lock, mutex_unlock, sema_wait, set_errno_to_last_error, thread_mutex_lock, and thread_mutex_unlock. Referenced by ACE_Semaphore::acquire, and sema_wait. { ACE_OS_TRACE ("ACE_OS::sema_wait"); # if defined (ACE_HAS_POSIX_SEM) ACE_OSCALL_RETURN (::sem_wait (s->sema_), int, -1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_wait (s), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) int result = 0; ACE_PTHREAD_CLEANUP_PUSH (&s->lock_); if (ACE_OS::mutex_lock (&s->lock_) != 0) result = -1; else { // Keep track of the number of waiters so that we can signal // them properly in <ACE_OS::sema_post>. s->waiters_++; // Wait until the semaphore count is > 0. while (s->count_ == 0) if (ACE_OS::cond_wait (&s->count_nonzero_, &s->lock_) == -1) { result = -2; // -2 means that we need to release the mutex. break; } --s->waiters_; } if (result == 0) --s->count_; if (result != -1) ACE_OS::mutex_unlock (&s->lock_); ACE_PTHREAD_CLEANUP_POP (0); return result < 0 ? -1 : result; # elif defined (ACE_HAS_WTHREADS) # if !defined (ACE_USES_WINCE_SEMA_SIMULATION) switch (::WaitForSingleObject (*s, INFINITE)) { case WAIT_OBJECT_0: return 0; default: // This is a hack, we need to find an appropriate mapping... ACE_OS::set_errno_to_last_error (); return -1; } /* NOTREACHED */ # else /* ACE_USES_WINCE_SEMA_SIMULATION */ // Timed wait. int result = -1; for (;;) // Check if the semaphore is avialable or not and wait forever. // Don't bother to grab the lock if it is not available (to avoid // deadlock.) switch (::WaitForSingleObject (s->count_nonzero_, INFINITE)) { case WAIT_OBJECT_0: ACE_OS::thread_mutex_lock (&s->lock_); // Need to double check if the semaphore is still available. // This time, we shouldn't wait at all. if (::WaitForSingleObject (s->count_nonzero_, 0) == WAIT_OBJECT_0) { // Decrease the internal counter. Only update the event // object's status when the state changed. s->count_--; if (s->count_ <= 0) ACE_OS::event_reset (&s->count_nonzero_); result = 0; } ACE_OS::thread_mutex_unlock (&s->lock_); // if we didn't get a hold on the semaphore, the result won't // be 0 and thus, we'll start from the beginning again. if (result == 0) return 0; break; default: // Since we wait indefinitely, anything other than // WAIT_OBJECT_O indicates an error. ACE_OS::set_errno_to_last_error (); // This is taken from the hack above. ;) return -1; } /* NOTREACHED */ # endif /* ACE_USES_WINCE_SEMA_SIMULATION */ # elif defined (ACE_PSOS) int result; ACE_OSCALL (ACE_ADAPT_RETVAL (::sm_p (s->sema_, SM_WAIT, 0), result), int, -1, result); return result; # elif defined (VXWORKS) ACE_OSCALL_RETURN (::semTake (s->sema_, WAIT_FOREVER), int, -1); # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (s); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_POSIX_SEM */ }

int ACE_OS::sema_wait_i (  ACE_sema_t *    s, ACE_Time_Value &    tv )  [static, private]

int ACE_OS::sema_wait_i (  ACE_sema_t *    s )  [static, private]

ACE_INLINE int ACE_OS::semctl (  int    int_id, int    semnum, int    cmd, semun    )  [static]

Definition at line 8545 of file OS.i. References ACE_OS_TRACE, and semctl. Referenced by ACE_SV_Semaphore_Simple::control, ACE_SV_Semaphore_Simple::open, and semctl. { ACE_OS_TRACE ("ACE_OS::semctl"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::semctl (int_id, semnum, cmd, value), int, -1); #else ACE_UNUSED_ARG (int_id); ACE_UNUSED_ARG (semnum); ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (value); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::semget (  key_t    key, int    nsems, int    flags )  [static]

Definition at line 8561 of file OS.i. References ACE_OS_TRACE, and semget. Referenced by ACE_SV_Semaphore_Simple::open, ACE_SV_Semaphore_Complex::open, and semget. { ACE_OS_TRACE ("ACE_OS::semget"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::semget (key, nsems, flags), int, -1); #else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (nsems); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::semop (  int    int_id, struct sembuf *    sops, size_t    nsops )  [static]

Definition at line 8576 of file OS.i. References ACE_OS_TRACE, and semop. Referenced by ACE_SV_Semaphore_Complex::close, ACE_SV_Semaphore_Simple::op, ACE_SV_Semaphore_Complex::open, and semop. { ACE_OS_TRACE ("ACE_OS::semop"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::semop (int_id, sops, nsops), int, -1); #else ACE_UNUSED_ARG (int_id); ACE_UNUSED_ARG (sops); ACE_UNUSED_ARG (nsops); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::send (  ACE_HANDLE    handle, const char *    buf, size_t    len, int    flags = 0 )  [static]

BSD-style <accept> (no QoS). Definition at line 5054 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, EWOULDBLOCK, and send. Referenced by send, ACE::send, ACE::send_i, and ACE::send_n_i. { ACE_OS_TRACE ("ACE_OS::send"); // On UNIX, a non-blocking socket with no data to receive, this // system call will return EWOULDBLOCK or EAGAIN, depending on the // platform. UNIX 98 allows either errno, and they may be the same // numeric value. So to make life easier for upper ACE layers as // well as application programmers, always change EAGAIN to // EWOULDBLOCK. Rather than hack the ACE_OSCALL_RETURN macro, it's // handled explicitly here. If the ACE_OSCALL macro ever changes, // this function needs to be reviewed. On Win32, the regular macros // can be used, as this is not an issue. #if defined (ACE_WIN32) ACE_SOCKCALL_RETURN (::send ((ACE_SOCKET) handle, buf, ACE_static_cast (int, len), flags), int, -1); #else int ace_result_; # if defined (VXWORKS) || defined (HPUX) || defined (ACE_PSOS) ace_result_ = ::send ((ACE_SOCKET) handle, (char *) buf, len, flags); # else ace_result_ = ::send ((ACE_SOCKET) handle, buf, len, flags); # endif /* VXWORKS */ if (ace_result_ == -1 && errno == EAGAIN) errno = EWOULDBLOCK; return ace_result_; #endif /* defined (ACE_WIN32) */ }

ACE_INLINE int ACE_OS::sendmsg (  ACE_HANDLE    handle, const struct msghdr *    msg, int    flags )  [static]

Definition at line 5626 of file OS.i. References ACE_OS_TRACE, ACE_SENDMSG_TYPE, ACE_SOCKCALL_RETURN, msghdr::msg_iov, msghdr::msg_iovlen, msghdr::msg_name, msghdr::msg_namelen, sendmsg, and set_errno_to_last_error. Referenced by sendmsg, and ACE::sendmsg. { ACE_OS_TRACE ("ACE_OS::sendmsg"); #if !defined (ACE_LACKS_SENDMSG) # if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)) DWORD bytes_sent = 0; int result = ::WSASendTo ((SOCKET) handle, (WSABUF *) msg->msg_iov, msg->msg_iovlen, &bytes_sent, flags, msg->msg_name, msg->msg_namelen, 0, 0); if (result != 0) { ACE_OS::set_errno_to_last_error (); return -1; } else return (ssize_t) bytes_sent; # elif defined (ACE_LACKS_POSIX_PROTOTYPES) || defined (ACE_PSOS) ACE_SOCKCALL_RETURN (::sendmsg (handle, (struct msghdr *) msg, flags), int, -1); # else ACE_SOCKCALL_RETURN (::sendmsg (handle, (ACE_SENDMSG_TYPE *) msg, flags), int, -1); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ #else ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (msg); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_LACKS_SENDMSG */ }

ACE_INLINE int ACE_OS::sendto (  ACE_HANDLE    handle, const iovec *    buffers, int    buffer_count, size_t &    number_of_bytes_sent, int    flags, const struct sockaddr *    addr, int    addrlen, ACE_OVERLAPPED *    overlapped, ACE_OVERLAPPED_COMPLETION_FUNC    func )  [static]

BSD-style <accept> (no QoS). Definition at line 5168 of file OS.i. References ACE_OS_TRACE, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, sendto, and set_errno_to_last_error. { ACE_OS_TRACE ("ACE_OS::sendto"); #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) DWORD bytes_sent; int result = ::WSASendTo ((SOCKET) handle, (WSABUF*)buffers, buffer_count, &bytes_sent, flags, addr, addrlen, overlapped, func); if (result != 0) { ACE_OS::set_errno_to_last_error (); } number_of_bytes_sent = ACE_static_cast (size_t, bytes_sent); return result; #else ACE_UNUSED_ARG (overlapped); ACE_UNUSED_ARG (func); number_of_bytes_sent = 0; int result = 0; for (int i = 0; i < buffer_count; i++) { result = ACE_OS::sendto (handle, ACE_reinterpret_cast (char *ACE_CAST_CONST, buffers[i].iov_base), buffers[i].iov_len, flags, addr, addrlen); if (result == -1) break; number_of_bytes_sent += result; } return result; #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */ }

ACE_INLINE int ACE_OS::sendto (  ACE_HANDLE    handle, const char *    buf, size_t    len, int    flags, const struct sockaddr *    addr, int    addrlen )  [static]

BSD-style <accept> (no QoS). Definition at line 5131 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and sendto. Referenced by ACE_WIN32_Asynch_Write_Dgram::send, ACE_SOCK_Dgram_Bcast::send, ACE_SOCK_Dgram::send, sendto, and ACE::sendto. { ACE_OS_TRACE ("ACE_OS::sendto"); #if defined (VXWORKS) ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, (char *) buf, len, flags, ACE_const_cast (struct sockaddr *, addr), addrlen), int, -1); #elif defined (ACE_PSOS) # if !defined (ACE_PSOS_DIAB_PPC) ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, (char *) buf, len, flags, (struct sockaddr_in *) addr, addrlen), int, -1); # else ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, (char *) buf, len, flags, (struct sockaddr *) addr, addrlen), int, -1); # endif /*defined ACE_PSOS_DIAB_PPC */ #else # if defined (ACE_WIN32) ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, buf, ACE_static_cast (int, len), flags, ACE_const_cast (struct sockaddr *, addr), addrlen), int, -1); # else ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, buf, len, flags, ACE_const_cast (struct sockaddr *, addr), addrlen), int, -1); # endif /* ACE_WIN32 */ #endif /* VXWORKS */ }

ACE_INLINE ssize_t ACE_OS::sendv (  ACE_HANDLE    handle, const iovec *    iov, int    iovcnt )  [static]

Definition at line 7557 of file OS.i. References iovec::iov_base, iovec::iov_len, set_errno_to_wsa_last_error, and writev. Referenced by ACE_SOCK_IO::send, ACE::send, ACE::sendv, and ACE::sendv_n_i. { #if defined (ACE_HAS_WINSOCK2) DWORD bytes_sent = 0; int result = 0; // Winsock 2 has WSASend and can do this directly, but Winsock 1 // needs to do the sends one-by-one. # if (ACE_HAS_WINSOCK2 != 0) result = ::WSASend ((SOCKET) handle, (WSABUF *) buffers, n, &bytes_sent, 0, 0, 0); # else int i; for (i = 0; i < n && result != SOCKET_ERROR; i++) { result = ::send ((SOCKET) handle, buffers[i].iov_base, buffers[i].iov_len, 0); // Gets ignored on error anyway bytes_sent += buffers[i].iov_len; // If the transfer isnt complete just drop out of the loop. if (result < (int)buffers[i].iov_len) break; } # endif /* ACE_HAS_WINSOCK2 != 0 */ if (result == SOCKET_ERROR) { ACE_OS::set_errno_to_wsa_last_error (); return -1; } else return (ssize_t) bytes_sent; #else return ACE_OS::writev (handle, buffers, n); #endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::set_errno_to_last_error (  void    )  [static]

Definition at line 6275 of file OS.i. References last_error. Referenced by ACE_WIN32_Asynch_Accept::accept, ACE_TTY_IO::control, ACE_WFMO_Reactor::dispatch, ACE_WFMO_Reactor::dispatch_handles, event_timedwait, event_wait, ACE_WIN32_Proactor::handle_events, ACE_NT_Service::insert, mutex_init, mutex_lock, mutex_trylock, ACE_WFMO_Reactor::ok_to_wait, ACE_WIN32_Asynch_Read_File::readv, ACE_WIN32_Asynch_Read_Stream::readv, ACE_WIN32_Asynch_Read_Dgram::recv, recvfrom, recvmsg, ACE_WIN32_Proactor::register_handle, sched_params, sema_trywait, sema_wait, ACE_WIN32_Asynch_Write_Dgram::send, sendmsg, sendto, ACE_WIN32_Asynch_Read_Stream::shared_read, ACE_WIN32_Asynch_Write_Stream::shared_write, stat, ACE_NT_Service::svc_sc_handle, ACE_WIN32_Asynch_Transmit_File::transmit_file, ACE_Process::wait, waitpid, ACE_WIN32_Asynch_Write_File::writev, and ACE_WIN32_Asynch_Write_Stream::writev. { # if defined (ACE_WIN32) // Borland C++ Builder 4 has a bug in the RTL that resets the // <GetLastError> value to zero when errno is accessed. Thus, we have // to use this to set errno to GetLastError. It's bad, but only for // WIN32. # if defined(__BORLANDC__) && (__BORLANDC__ == 0x540) || defined (__IBMCPP__) && (__IBMCPP__ >= 400) int last_error = ::GetLastError (); return errno = last_error; # else /* defined(__BORLANDC__) && (__BORLANDC__ == 0x540) */ return errno = ::GetLastError (); # endif /* defined(__BORLANDC__) && (__BORLANDC__ == 0x540) */ #else return errno; # endif /* defined(ACE_WIN32) */ }

ACE_INLINE int ACE_OS::set_errno_to_wsa_last_error (  void    )  [static]

Definition at line 6294 of file OS.i. References last_error. Referenced by recvfrom, recvv, ACE_SPIPE_Stream::send_handle, and sendv. { # if defined (ACE_WIN32) // Borland C++ Builder 4 has a bug in the RTL that resets the // <GetLastError> value to zero when errno is accessed. Thus, we have // to use this to set errno to GetLastError. It's bad, but only for // WIN32 # if defined(__BORLANDC__) && (__BORLANDC__ == 0x540) || defined (__IBMCPP__) && (__IBMCPP__ >= 400) int last_error = ::WSAGetLastError (); return errno = last_error; # else /* defined(__BORLANDC__) && (__BORLANDC__ == 0x540) */ return errno = ::WSAGetLastError (); # endif /* defined(__BORLANDC__) && (__BORLANDC__ == 0x540) */ #else return errno; # endif /* defined(ACE_WIN32) */ }

ACE_INLINE ACE_EXIT_HOOK ACE_OS::set_exit_hook (  ACE_EXIT_HOOK    hook )  [static, private]

For use by ACE_Object_Manager only, to register its exit hook.. Definition at line 10982 of file OS.i. References exit_hook_. Referenced by ACE_OS_Object_Manager::init. { ACE_EXIT_HOOK old_hook = exit_hook_; exit_hook_ = exit_hook; return old_hook; }

int ACE_OS::set_scheduling_params (  const ACE_Sched_Params &   , ACE_id_t    id = ACE_SELF )  [static]

Friendly interface to <priocntl>(2). Definition at line 1299 of file OS.cpp. References ACE_id_t, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_SCHED_RR, ACE_SCOPE_PROCESS, ACE_SCOPE_THREAD, last_error, ACE_OS_String::memcpy, ACE_OS_String::memset, ACE_Sched_Params::policy, ACE_Sched_Params::priority, priority_control, ACE_Sched_Params::quantum, scheduling_class, ACE_Sched_Params::scope, ACE_Time_Value::sec, ACE_Time_Value::usec, and ACE_Time_Value::zero. Referenced by sched_params. { #if defined (ACE_HAS_PRIOCNTL) // Set priority class, priority, and quantum of this LWP or process as // specified in sched_params. // Get the priority class ID. ACE_id_t class_id; if (ACE_OS::scheduling_class (sched_params.policy() == ACE_SCHED_OTHER ? "TS" : "RT", class_id) == -1) { return -1; } pcparms_t pcparms; // The following is just to avoid Purify warnings about unitialized // memory reads. ACE_OS::memset (&pcparms, 0, sizeof pcparms); pcparms.pc_cid = class_id; if (sched_params.policy () == ACE_SCHED_OTHER && sched_params.quantum () == ACE_Time_Value::zero) // SunOS doesn't support non-zero quantums in time-sharing class: use // real-time class instead. { tsparms_t tsparms; // The following is just to avoid Purify warnings about unitialized // memory reads. ACE_OS::memset (&tsparms, 0, sizeof tsparms); // Don't change ts_uprilim (user priority limit) tsparms.ts_uprilim = TS_NOCHANGE; tsparms.ts_upri = sched_params.priority (); // Package up the TS class ID and parameters for the // priority_control () call. ACE_OS::memcpy (pcparms.pc_clparms, &tsparms, sizeof tsparms); } else if (sched_params.policy () == ACE_SCHED_FIFO || (sched_params.policy () == ACE_SCHED_RR && sched_params.quantum () != ACE_Time_Value::zero)) // must have non-zero quantum for RR, to make it meaningful // A zero quantum with FIFO has special significance: it actually // means infinite time quantum, i.e., run-to-completion. { rtparms_t rtparms; // The following is just to avoid Purify warnings about unitialized // memory reads. ACE_OS::memset (&rtparms, 0, sizeof rtparms); rtparms.rt_pri = sched_params.priority (); if (sched_params.quantum () == ACE_Time_Value::zero) { // rtparms.rt_tqsecs is ignored with RT_TQINF rtparms.rt_tqnsecs = RT_TQINF; } else { rtparms.rt_tqsecs = (ulong) sched_params.quantum ().sec (); rtparms.rt_tqnsecs = sched_params.quantum ().usec () * 1000; } // Package up the RT class ID and parameters for the // priority_control () call. ACE_OS::memcpy (pcparms.pc_clparms, &rtparms, sizeof rtparms); } else { errno = EINVAL; return -1; } if (ACE_OS::priority_control ((idtype_t) (sched_params.scope () == ACE_SCOPE_THREAD ? ACE_SCOPE_PROCESS : sched_params.scope ()), id, PC_SETPARMS, (char *) &pcparms) < 0) { return ACE_OS::last_error (); } return 0; #else /* ! ACE_HAS_PRIOCNTL */ ACE_UNUSED_ARG (sched_params); ACE_UNUSED_ARG (id); ACE_NOTSUP_RETURN (-1); #endif /* ! ACE_HAS_PRIOCNTL */ }

void ACE_OS::set_win32_resource_module (  HINSTANCE    )  [static]

Allow an application to modify which module contains ACE's resources. This is mainly useful for a static build of ACE where the required resources reside somewhere other than the executable.

ACE_INLINE int ACE_OS::setgid (  gid_t    )  [static]

Definition at line 10952 of file OS.i. References ACE_OS_TRACE, gid_t, and setgid. Referenced by setgid. { ACE_OS_TRACE ("ACE_OS::setgid"); #if defined (VXWORKS) || defined (ACE_PSOS) // setgid() is not supported: just one user anyways ACE_UNUSED_ARG (gid); return 0; # elif defined (ACE_WIN32) || defined (CHORUS) ACE_UNUSED_ARG (gid); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::setgid (gid), int, -1); # endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE int ACE_OS::setpgid (  pid_t    pid, pid_t    pgid )  [static]

Definition at line 9783 of file OS.i. References ACE_OS_TRACE, pid_t, and setpgid. Referenced by setpgid, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::setpgid"); #if defined (ACE_LACKS_SETPGID) ACE_UNUSED_ARG (pid); ACE_UNUSED_ARG (pgid); ACE_NOTSUP_RETURN (-1); #elif defined (VXWORKS) || defined (ACE_PSOS) // <setpgid> is not supported, only one process anyway. ACE_UNUSED_ARG (pid); ACE_UNUSED_ARG (pgid); return 0; #else ACE_OSCALL_RETURN (::setpgid (pid, pgid), int, -1); #endif /* ACE_LACKS_SETPGID */ }

ACE_INLINE void ACE_OS::setpwent (  void    )  [static]

Definition at line 5807 of file OS.i. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) # if !defined (ACE_WIN32) ::setpwent (); # else # endif /* ACE_WIN32 */ #else #endif /* ! ACE_LACKS_PWD_FUNCTIONS */ }

ACE_INLINE int ACE_OS::setregid (  gid_t    rgid, gid_t    egid )  [static]

Definition at line 9819 of file OS.i. References ACE_OS_TRACE, gid_t, and setregid. Referenced by setregid, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::setregid"); #if defined (ACE_LACKS_SETREGID) ACE_UNUSED_ARG (rgid); ACE_UNUSED_ARG (egid); ACE_NOTSUP_RETURN (-1); #elif defined (VXWORKS) || defined (ACE_PSOS) // <setregid> is not supported, only one process anyway. ACE_UNUSED_ARG (rgid); ACE_UNUSED_ARG (egid); return 0; #else ACE_OSCALL_RETURN (::setregid (rgid, egid), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::setreuid (  uid_t    ruid, uid_t    euid )  [static]

Definition at line 9801 of file OS.i. References ACE_OS_TRACE, setreuid, and uid_t. Referenced by setreuid, and ACE_Process::spawn. { ACE_OS_TRACE ("ACE_OS::setreuid"); #if defined (ACE_LACKS_SETREUID) ACE_UNUSED_ARG (ruid); ACE_UNUSED_ARG (euid); ACE_NOTSUP_RETURN (-1); #elif defined (VXWORKS) || defined (ACE_PSOS) // <setpgid> is not supported, only one process anyway. ACE_UNUSED_ARG (ruid); ACE_UNUSED_ARG (euid); return 0; #else ACE_OSCALL_RETURN (::setreuid (ruid, euid), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::setrlimit (  int    resource, ACE_SETRLIMIT_TYPE *    rl )  [static]

Definition at line 9437 of file OS.i. References ACE_OS_TRACE, ACE_SETRLIMIT_TYPE, and setrlimit. Referenced by ACE::set_handle_limit, and setrlimit. { ACE_OS_TRACE ("ACE_OS::setrlimit"); #if defined (ACE_LACKS_RLIMIT) ACE_UNUSED_ARG (resource); ACE_UNUSED_ARG (rl); ACE_NOTSUP_RETURN (-1); #else # if defined (ACE_HAS_RLIMIT_RESOURCE_ENUM) ACE_OSCALL_RETURN (::setrlimit ((ACE_HAS_RLIMIT_RESOURCE_ENUM) resource, rl), int, -1); # else ACE_OSCALL_RETURN (::setrlimit (resource, rl), int, -1); # endif /* ACE_HAS_RLIMIT_RESOURCE_ENUM */ #endif /* ACE_LACKS_RLIMIT */ }

ACE_INLINE pid_t ACE_OS::setsid (  void    )  [static]

Definition at line 440 of file OS.i. References ACE_OS_TRACE, and setsid. Referenced by ACE::daemonize, and setsid. { ACE_OS_TRACE ("ACE_OS::setsid"); # if defined (VXWORKS) || defined (CHORUS) || defined (ACE_PSOS) ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::setsid (), int, -1); # endif /* VXWORKS || CHORUS || ACE_PSOS */ }

ACE_INLINE int ACE_OS::setsockopt (  ACE_HANDLE    handle, int    level, int    optname, const char *    optval, int    optlen )  [static]

Manipulate the options associated with a socket. Definition at line 5434 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKOPT_TYPE1, and setsockopt. Referenced by ACE_ATM_Acceptor::accept, ACE_ATM_Connector::connect, ACE_WIN32_Asynch_Connect::connect_i, ACE_POSIX_Asynch_Connect::connect_i, ACE_Asynch_Acceptor::handle_accept, ACE_SOCK_Dgram_Bcast::mk_broadcast, ACE_Pipe::open, ACE_ATM_Acceptor::open, ACE_Asynch_Acceptor::open, ACE_SOCK::set_option, and setsockopt. { ACE_OS_TRACE ("ACE_OS::setsockopt"); #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) && defined(SO_REUSEPORT) // To work around an inconsistency with Microsofts implementation of // sockets, we will check for SO_REUSEADDR, and ignore it. Winsock // always behaves as if SO_REUSEADDR=1. Some implementations have the // same behaviour as Winsock, but use a new name for it. SO_REUSEPORT. // If you want the normal behaviour for SO_REUSEADDR=0, then NT 4 sp4 and later // supports SO_EXCLUSIVEADDRUSE. This also requires using an updated Platform SDK // so it was decided to ignore the option for now. (Especially since ACE always // sets SO_REUSEADDR=1, which we can mimic by doing nothing.) if (level == SOL_SOCKET) { if (optname == SO_REUSEADDR) { return 0; // Not supported by Winsock } if (optname == SO_REUSEPORT) { optname = SO_REUSEADDR; } } #endif /*ACE_HAS_WINSOCK2*/ ACE_SOCKCALL_RETURN (::setsockopt ((ACE_SOCKET) handle, level, optname, (ACE_SOCKOPT_TYPE1) optval, optlen), int, -1); }

ACE_INLINE int ACE_OS::setuid (  uid_t    )  [static]

Definition at line 10922 of file OS.i. References ACE_OS_TRACE, setuid, and uid_t. Referenced by setuid. { ACE_OS_TRACE ("ACE_OS::setuid"); #if defined (VXWORKS) || defined (ACE_PSOS) // setuid() is not supported: just one user anyways ACE_UNUSED_ARG (uid); return 0; # elif defined (ACE_WIN32) || defined(CHORUS) ACE_UNUSED_ARG (uid); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::setuid (uid), int, -1); # endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE ACE_HANDLE ACE_OS::shm_open (  const ACE_TCHAR *    filename, int    mode, int    perms = 0, LPSECURITY_ATTRIBUTES    sa = 0 )  [static]

Definition at line 854 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, open, and shm_open. Referenced by ACE_Condition::ACE_Condition, ACE_Mutex::ACE_Mutex, flock_init, ACE_Mem_Map::open, sema_init, and shm_open. { ACE_OS_TRACE ("ACE_OS::shm_open"); # if defined (ACE_HAS_SHM_OPEN) ACE_UNUSED_ARG (sa); ACE_OSCALL_RETURN (::shm_open (filename, mode, perms), ACE_HANDLE, -1); # else /* ! ACE_HAS_SHM_OPEN */ // Just use ::open. return ACE_OS::open (filename, mode, perms, sa); # endif /* ACE_HAS_SHM_OPEN */ }

ACE_INLINE int ACE_OS::shm_unlink (  const ACE_TCHAR *    path )  [static]

Definition at line 870 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, shm_unlink, and unlink. Referenced by flock_destroy, ACE_Condition::remove, ACE_Mutex::remove, ACE_Mem_Map::remove, sema_destroy, and shm_unlink. { ACE_OS_TRACE ("ACE_OS::shm_unlink"); # if defined (ACE_HAS_SHM_OPEN) ACE_OSCALL_RETURN (::shm_unlink (path), int, -1); # else /* ! ACE_HAS_SHM_OPEN */ // Just use ::unlink. return ACE_OS::unlink (path); # endif /* ACE_HAS_SHM_OPEN */ }

ACE_INLINE void * ACE_OS::shmat (  int    int_id, void *    shmaddr, int    shmflg )  [static]

Definition at line 8591 of file OS.i. References ACE_OS_TRACE, and shmat. Referenced by ACE_SV_Shared_Memory::attach, ACE_Shared_Memory_Pool::commit_backing_store_name, ACE_Shared_Memory_Pool::handle_signal, ACE_Shared_Memory_Pool::init_acquire, and shmat. { ACE_OS_TRACE ("ACE_OS::shmat"); #if defined (ACE_HAS_SYSV_IPC) # if defined (ACE_LACKS_POSIX_PROTOTYPES) || defined (ACE_LACKS_SOME_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::shmat (int_id, (char *)shmaddr, shmflg), void *, (void *) -1); # else ACE_OSCALL_RETURN (::shmat (int_id, shmaddr, shmflg), void *, (void *) -1); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ #else ACE_UNUSED_ARG (int_id); ACE_UNUSED_ARG (shmaddr); ACE_UNUSED_ARG (shmflg); ACE_NOTSUP_RETURN ((void *) -1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::shmctl (  int    int_id, int    cmd, struct shmid_ds *    buf )  [static]

Definition at line 8610 of file OS.i. References ACE_OS_TRACE, and shmctl. Referenced by ACE_SV_Shared_Memory::control, ACE_Shared_Memory_Pool::find_seg, ACE_Shared_Memory_Pool::in_use, ACE_Shared_Memory_Pool::release, ACE_SV_Shared_Memory::remove, and shmctl. { ACE_OS_TRACE ("ACE_OS::shmctl"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::shmctl (int_id, cmd, buf), int, -1); #else ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (int_id); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::shmdt (  void *    shmaddr )  [static]

Definition at line 8625 of file OS.i. References ACE_OS_TRACE, and shmdt. Referenced by ACE_SV_Shared_Memory::detach, and shmdt. { ACE_OS_TRACE ("ACE_OS::shmdt"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::shmdt ((char *) shmaddr), int, -1); #else ACE_UNUSED_ARG (shmaddr); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::shmget (  key_t    key, int    size, int    flags )  [static]

Definition at line 8638 of file OS.i. References ACE_OS_TRACE, and shmget. Referenced by ACE_Shared_Memory_Pool::commit_backing_store_name, ACE_Shared_Memory_Pool::init_acquire, ACE_SV_Shared_Memory::open, and shmget. { ACE_OS_TRACE ("ACE_OS::shmget"); #if defined (ACE_HAS_SYSV_IPC) ACE_OSCALL_RETURN (::shmget (key, size, flags), int, -1); #else ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (size); ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::shutdown (  ACE_HANDLE    handle, int    how )  [static]

BSD-style <accept> (no QoS). Definition at line 5471 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and shutdown. Referenced by ACE_SOCK_Stream::close_reader, ACE_MEM_Stream::close_reader, ACE_SOCK_Stream::close_writer, ACE_MEM_Stream::close_writer, and shutdown. { ACE_OS_TRACE ("ACE_OS::shutdown"); ACE_SOCKCALL_RETURN (::shutdown ((ACE_SOCKET) handle, how), int, -1); }

ACE_INLINE int ACE_OS::sigaction (  int    signum, const struct sigaction *    nsa, struct sigaction *    osa )  [static]

Definition at line 10147 of file OS.i. References ACE_OS_TRACE, SIG_ERR, SIG_IGN, and sigaction. Referenced by ACE_Sig_Action::ACE_Sig_Action, ACE_Sig_Action::register_action, ACE_Sig_Action::restore_action, ACE_Sig_Action::retrieve_action, and sigaction. { ACE_OS_TRACE ("ACE_OS::sigaction"); if (signum == 0) return 0; #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) struct sigaction sa; if (osa == 0) osa = &sa; if (nsa == 0) { osa->sa_handler = ::signal (signum, SIG_IGN); ::signal (signum, osa->sa_handler); } else osa->sa_handler = ::signal (signum, nsa->sa_handler); return osa->sa_handler == SIG_ERR ? -1 : 0; #elif defined (CHORUS) || defined (ACE_HAS_WINCE) || defined(ACE_PSOS) ACE_UNUSED_ARG (signum); ACE_UNUSED_ARG (nsa); ACE_UNUSED_ARG (osa); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_LACKS_POSIX_PROTOTYPES) || defined (ACE_LACKS_SOME_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::sigaction (signum, (struct sigaction*) nsa, osa), int, -1); #else ACE_OSCALL_RETURN (::sigaction (signum, nsa, osa), int, -1); #endif /* ACE_WIN32 !ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::sigaddset (  sigset_t *    s, int    signum )  [static]

Definition at line 10674 of file OS.i. References ACE_NSIG, ACE_OS_TRACE, and sigaddset. Referenced by ACE_Sig_Set::sig_add, and sigaddset. { ACE_OS_TRACE ("ACE_OS::sigaddset"); #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) if (s == 0) { errno = EFAULT; return -1; } else if (signum < 1 || signum >= ACE_NSIG) { errno = EINVAL; return -1; // Invalid signum, return error } # if defined (ACE_PSOS) && defined (__DIAB) && ! defined(ACE_PSOS_DIAB_MIPS) && !defined (ACE_PSOS_DIAB_PPC) // treat 0th u_long of sigset_t as high bits, // and 1st u_long of sigset_t as low bits. if (signum <= ACE_BITS_PER_ULONG) s->s[1] |= (1 << (signum - 1)); else s->s[0] |= (1 << (signum - ACE_BITS_PER_ULONG - 1)); # else *s |= (1 << (signum - 1)) ; # endif /* defined (ACE_PSOS) && defined (__DIAB) */ return 0 ; #else ACE_OSCALL_RETURN (::sigaddset (s, signum), int, -1); #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE int ACE_OS::sigdelset (  sigset_t *    s, int    signum )  [static]

Definition at line 10705 of file OS.i. References ACE_NSIG, and sigdelset. Referenced by ACE_Sig_Set::sig_del, and sigdelset. { #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) if (s == 0) { errno = EFAULT; return -1; } else if (signum < 1 || signum >= ACE_NSIG) { errno = EINVAL; return -1; // Invalid signum, return error } # if defined (ACE_PSOS) && defined (__DIAB) && ! defined (ACE_PSOS_DIAB_MIPS) && !defined (ACE_PSOS_DIAB_PPC) // treat 0th u_long of sigset_t as high bits, // and 1st u_long of sigset_t as low bits. if (signum <= ACE_BITS_PER_ULONG) s->s[1] &= ~(1 << (signum - 1)); else s->s[0] &= ~(1 << (signum - ACE_BITS_PER_ULONG - 1)); # else *s &= ~(1 << (signum - 1)) ; # endif /* defined (ACE_PSOS) && defined (__DIAB) */ return 0; #else ACE_OSCALL_RETURN (::sigdelset (s, signum), int, -1); #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE int ACE_OS::sigemptyset (  sigset_t *    s )  [static]

Definition at line 10735 of file OS.i. References sigemptyset. Referenced by ACE_Sig_Action::ACE_Sig_Action, ACE_Sig_Set::ACE_Sig_Set, ACE_Sig_Set::empty_set, sigemptyset, sigsuspend, and ACE_Sig_Set::~ACE_Sig_Set. { #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) if (s == 0) { errno = EFAULT; return -1; } # if defined (ACE_PSOS) && defined (__DIAB) && ! defined (ACE_PSOS_DIAB_MIPS) && !defined (ACE_PSOS_DIAB_PPC) s->s[0] = 0; s->s[1] = 0; # else *s = 0 ; # endif /* defined (ACE_PSOS) && defined (__DIAB) */ return 0 ; #else ACE_OSCALL_RETURN (::sigemptyset (s), int, -1); #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE int ACE_OS::sigfillset (  sigset_t *    s )  [static]

Definition at line 10756 of file OS.i. References sigfillset. Referenced by ACE_Sig_Set::ACE_Sig_Set, ACE_Sig_Set::fill_set, ACE_OS_Object_Manager::init, and sigfillset. { #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) if (s == 0) { errno = EFAULT; return -1; } # if defined (ACE_PSOS) && defined (__DIAB) && ! defined (ACE_PSOS_DIAB_MIPS) && !defined (ACE_PSOS_DIAB_PPC) s->s[0] = ~(u_long) 0; s->s[1] = ~(u_long) 0; # else *s = ~(sigset_t) 0; # endif /* defined (ACE_PSOS) && defined (__DIAB) */ return 0 ; #else ACE_OSCALL_RETURN (::sigfillset (s), int, -1); #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE int ACE_OS::sigismember (  sigset_t *    s, int    signum )  [static]

Definition at line 10777 of file OS.i. References ACE_NSIG, and sigismember. Referenced by ACE_Sig_Set::is_member, and sigismember. { #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) if (s == 0) { errno = EFAULT; return -1; } else if (signum < 1 || signum >= ACE_NSIG) { errno = EINVAL; return -1; // Invalid signum, return error } # if defined (ACE_PSOS) && defined (__DIAB) && ! defined (ACE_PSOS_DIAB_MIPS) && !defined (ACE_PSOS_DIAB_PPC) // treat 0th u_long of sigset_t as high bits, // and 1st u_long of sigset_t as low bits. if (signum <= ACE_BITS_PER_ULONG) return ((s->s[1] & (1 << (signum - 1))) != 0); else return ((s->s[0] & (1 << (signum - ACE_BITS_PER_ULONG - 1))) != 0); # else return ((*s & (1 << (signum - 1))) != 0) ; # endif /* defined (ACE_PSOS) && defined (__DIAB) */ #else # if defined (ACE_HAS_SIGISMEMBER_BUG) if (signum < 1 || signum >= ACE_NSIG) { errno = EINVAL; return -1; // Invalid signum, return error } # endif /* ACE_HAS_SIGISMEMBER_BUG */ ACE_OSCALL_RETURN (::sigismember (s, signum), int, -1); #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE ACE_SignalHandler ACE_OS::signal (  int    signum, ACE_SignalHandler    )  [static]

Definition at line 6374 of file OS.i. References ACE_SignalHandler. Referenced by ACE::daemonize. { if (signum == 0) return 0; else #if defined (ACE_PSOS) && !defined (ACE_PSOS_TM) && !defined (ACE_PSOS_DIAB_MIPS) && !defined (ACE_PSOS_DIAB_PPC) return (ACE_SignalHandler) ::signal (signum, (void (*)(void)) func); #elif defined (ACE_PSOS_DIAB_MIPS) || defined (ACE_PSOS_DIAB_PPC) return 0; #elif defined (ACE_PSOS_TM) // @@ It would be good to rework this so the ACE_PSOS_TM specific // branch is not needed, but prying it out of ACE_LACKS_UNIX_SIGNALS // will take some extra work - deferred for now. return (ACE_SignalHandler) ::signal (signum, (void (*)(int)) func); #elif defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) || !defined (ACE_LACKS_UNIX_SIGNALS) # if !defined (ACE_HAS_TANDEM_SIGNALS) && !defined (ACE_HAS_LYNXOS_SIGNALS) return ::signal (signum, func); # else return (ACE_SignalHandler) ::signal (signum, (void (*)(int)) func); # endif /* !ACE_HAS_TANDEM_SIGNALS */ #else // @@ WINCE: Don't know how to implement signal on WinCE (yet.) ACE_UNUSED_ARG (signum); ACE_UNUSED_ARG (func); ACE_NOTSUP_RETURN (0); // Should return SIG_ERR but it is not defined on WinCE. #endif /* ACE_PSOS && !ACE_PSOS_TM && !ACE_PSOS_DIAB_MIPS && !ACE_PSOS_DIAB_PPC */ }

ACE_INLINE int ACE_OS::sigprocmask (  int    how, const sigset_t *    nsp, sigset_t *    osp )  [static]

Definition at line 10831 of file OS.i. References sigprocmask. Referenced by ACE_Sig_Guard::ACE_Sig_Guard, sigprocmask, thr_sigsetmask, and ACE_Sig_Guard::~ACE_Sig_Guard. { #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) ACE_UNUSED_ARG (how); ACE_UNUSED_ARG (nsp); ACE_UNUSED_ARG (osp); ACE_NOTSUP_RETURN (-1); #else # if defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::sigprocmask (how, (int*) nsp, osp), int, -1); # else ACE_OSCALL_RETURN (::sigprocmask (how, nsp, osp), int, -1); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE int ACE_OS::sigsuspend (  const sigset_t *    set )  [static]

Definition at line 10813 of file OS.i. References sigemptyset, and sigsuspend. Referenced by sigsuspend. { #if defined (ACE_HAS_SIGSUSPEND) sigset_t s; if (sigset == 0) { sigset = &s; ACE_OS::sigemptyset (&s); } ACE_OSCALL_RETURN (::sigsuspend (sigset), int, -1); #else ACE_UNUSED_ARG (sigset); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SIGSUSPEND */ }

ACE_INLINE int ACE_OS::sigtimedwait (  const sigset_t *    set, siginfo_t *    info, const ACE_Time_Value *    timeout )  [static]

Definition at line 7038 of file OS.i. References ACE_OS_TRACE, and sigtimedwait. Referenced by sigtimedwait. { ACE_OS_TRACE ("ACE_OS::sigtimedwait"); #if defined (ACE_HAS_SIGTIMEDWAIT) timespec_t ts; timespec_t *tsp; if (timeout != 0) { ts = *timeout; // Calls ACE_Time_Value::operator timespec_t(). tsp = &ts; } else tsp = 0; ACE_OSCALL_RETURN (::sigtimedwait (sset, info, tsp), int, -1); #else ACE_UNUSED_ARG (sset); ACE_UNUSED_ARG (info); ACE_UNUSED_ARG (timeout); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SIGTIMEDWAIT */ }

int ACE_OS::sigtimedwait_i (  const sigset_t *    set, siginfo_t *    info, const ACE_Time_Value *    timeout )  [static, private]

ACE_INLINE int ACE_OS::sigwait (  sigset_t *    set, int *    sig = 0 )  [static]

Definition at line 6978 of file OS.i. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::sigwait"); int local_sig; if (sig == 0) sig = &local_sig; #if defined (ACE_HAS_THREADS) # if (defined (__FreeBSD__) && (__FreeBSD__ < 3)) || defined (CHORUS) || defined (ACE_PSOS) ACE_UNUSED_ARG (sset); ACE_NOTSUP_RETURN (-1); # elif (defined (ACE_HAS_STHREADS) && !defined (_POSIX_PTHREAD_SEMANTICS)) *sig = ::sigwait (sset); return *sig; # elif defined (ACE_HAS_PTHREADS) // LynxOS and Digital UNIX have their own hoops to jump through. # if defined (__Lynx__) // Second arg is a void **, which we don't need (the selected // signal number is returned). *sig = ::sigwait (sset, 0); return *sig; # elif defined (DIGITAL_UNIX) && defined (__DECCXX_VER) // DEC cxx (but not g++) needs this direct call to its internal // sigwait (). This allows us to #undef sigwait, so that we can // have ACE_OS::sigwait. cxx gets confused by ACE_OS::sigwait // if sigwait is _not_ #undef'ed. errno = ::_Psigwait (sset, sig); return errno == 0 ? *sig : -1; # else /* ! __Lynx __ && ! (DIGITAL_UNIX && __DECCXX_VER) */ # if (defined (ACE_HAS_PTHREADS_DRAFT4) || (defined (ACE_HAS_PTHREADS_DRAFT6)) && !defined(ACE_HAS_FSU_PTHREADS)) || (defined (_UNICOS) && _UNICOS == 9) # if defined (HPUX_10) *sig = cma_sigwait (sset); # else *sig = ::sigwait (sset); # endif /* HPUX_10 */ return *sig; # elif defined(ACE_HAS_FSU_PTHREADS) return ::sigwait (sset, sig); # else /* this is draft 7 or std */ errno = ::sigwait (sset, sig); return errno == 0 ? *sig : -1; # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ # endif /* ! __Lynx__ && ! (DIGITAL_UNIX && __DECCXX_VER) */ # elif defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (sset); ACE_NOTSUP_RETURN (-1); # elif defined (VXWORKS) // Second arg is a struct siginfo *, which we don't need (the // selected signal number is returned). Third arg is timeout: 0 // means forever. *sig = ::sigtimedwait (sset, 0, 0); return *sig; # endif /* __FreeBSD__ */ #else ACE_UNUSED_ARG (sset); ACE_UNUSED_ARG (sig); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::sigwaitinfo (  const sigset_t *    set, siginfo_t *    info )  [static]

Definition at line 7066 of file OS.i. References ACE_OS_TRACE, and sigwaitinfo. Referenced by sigwaitinfo. { ACE_OS_TRACE ("ACE_OS::sigwaitinfo"); // If this platform has sigtimedwait, it should have sigwaitinfo as well. // If this isn't true somewhere, let me know and I'll fix this. // -Steve Huston <shuston@riverace.com>. #if defined (ACE_HAS_SIGTIMEDWAIT) ACE_OSCALL_RETURN (::sigwaitinfo (sset, info), int, -1); #else ACE_UNUSED_ARG (sset); ACE_UNUSED_ARG (info); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SIGTIMEDWAIT */ }

ACE_INLINE int ACE_OS::sleep (  const ACE_Time_Value &    tv )  [static]

Definition at line 10317 of file OS.i. References ACE_OS_TRACE, ACE_Time_Value::msec, and select. { ACE_OS_TRACE ("ACE_OS::sleep"); #if defined (ACE_WIN32) ::Sleep (tv.msec ()); return 0; #else # if defined (ACE_HAS_NONCONST_SELECT_TIMEVAL) // Copy the timeval, because this platform doesn't declare the timeval // as a pointer to const. timeval tv_copy = tv; ACE_OSCALL_RETURN (::select (0, 0, 0, 0, &tv_copy), int, -1); # else /* ! ACE_HAS_NONCONST_SELECT_TIMEVAL */ const timeval *tvp = tv; ACE_OSCALL_RETURN (::select (0, 0, 0, 0, tvp), int, -1); # endif /* ACE_HAS_NONCONST_SELECT_TIMEVAL */ #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::sleep (  u_int    seconds )  [static]

Definition at line 10284 of file OS.i. References ACE_ONE_SECOND_IN_MSECS, ACE_OS_TRACE, nanosleep, select, sleep, timespec::tv_nsec, timespec::tv_sec, and wait. Referenced by ACE_High_Res_Timer::calibrate, ACE_SOCK_Connector::complete, ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::handle_output, nanosleep, sleep, ACE_Process_Manager::wait, and ACE_Process::wait. { ACE_OS_TRACE ("ACE_OS::sleep"); #if defined (ACE_WIN32) ::Sleep (seconds * ACE_ONE_SECOND_IN_MSECS); return 0; #if 0 #elif defined (HPUX_10) && defined (ACE_HAS_PTHREADS_DRAFT4) // On HP-UX 10, _CMA_NOWRAPPERS_ disables the mapping from sleep to cma_sleep // which makes sleep() put the whole process to sleep, and keeps it from // noticing pending cancels. So, in this case, use pthread_delay_np struct timespec rqtp; rqtp.tv_sec = seconds; rqtp.tv_nsec = 0L; return pthread_delay_np (&rqtp); #endif /* 0 */ #elif defined (ACE_HAS_CLOCK_GETTIME) struct timespec rqtp; // Initializer doesn't work with Green Hills 1.8.7 rqtp.tv_sec = seconds; rqtp.tv_nsec = 0L; ACE_OSCALL_RETURN (::nanosleep (&rqtp, 0), int, -1); #elif defined (ACE_PSOS) timeval wait; wait.tv_sec = seconds; wait.tv_usec = 0; ACE_OSCALL_RETURN (::select (0, 0, 0, 0, &wait), int, -1); #else ACE_OSCALL_RETURN (::sleep (seconds), int, -1); #endif /* ACE_WIN32 */ }

int ACE_OS::sleep_i (  const ACE_Time_Value &    tv )  [static, private]

int ACE_OS::sleep_i (  u_int    seconds )  [static, private]

int ACE_OS::snprintf (  wchar_t *    buf, size_t    maxlen, const wchar_t *    format, ...    )  [static]

Definition at line 1156 of file OS.cpp. References ACE_SPRINTF_ADAPTER. { // ACE_OS_TRACE ("ACE_OS::snprintf"); #if (defined (_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500)) || defined (ACE_WIN32) int result; va_list ap; va_start (ap, format); # if defined (ACE_WIN32) // Microsoft's vswprintf() doesn't have the maxlen argument that // XPG4/UNIX98 define. They do, however, recommend use of _vsnwprintf() // as a substitute, which does have the same signature as the UNIX98 one. ACE_OSCALL (ACE_SPRINTF_ADAPTER (::_vsnwprintf (buf, maxlen, format, ap)), int, -1, result); // Win32 doesn't 0-terminate the string if it overruns maxlen. if (result == -1) buf[maxlen-1] = '\0'; # else ACE_OSCALL (ACE_SPRINTF_ADAPTER (::vswprintf (buf, maxlen, format, ap)), int, -1, result); # endif /* ACE_WIN32 */ va_end (ap); // In out-of-range conditions, C99 defines vsnprintf to return the number // of characters that would have been written if enough space was available. // Earlier variants of the vsnprintf() (e.g. UNIX98) defined it to return // -1. This method follows the C99 standard, but needs to guess at the // value; uses maxlen + 1. if (result == -1) result = ACE_static_cast (int, (maxlen + 1)); return result; #else ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (maxlen); ACE_UNUSED_ARG (format); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SNPRINTF */ }

int ACE_OS::snprintf (  char *    buf, size_t    maxlen, const char *    format, ...    )  [static]

Definition at line 1119 of file OS.cpp. References ACE_SPRINTF_ADAPTER. Referenced by ACE_Log_Msg::log. { // ACE_OS_TRACE ("ACE_OS::snprintf"); #if defined (ACE_HAS_SNPRINTF) int result; va_list ap; va_start (ap, format); # if defined (ACE_WIN32) ACE_OSCALL (ACE_SPRINTF_ADAPTER (::_vsnprintf (buf, maxlen, format, ap)), int, -1, result); // Win32 doesn't 0-terminate the string if it overruns maxlen. if (result == -1) buf[maxlen-1] = '\0'; # else ACE_OSCALL (ACE_SPRINTF_ADAPTER (::vsnprintf (buf, maxlen, format, ap)), int, -1, result); # endif /* ACE_WIN32 */ va_end (ap); // In out-of-range conditions, C99 defines vsnprintf to return the number // of characters that would have been written if enough space was available. // Earlier variants of the vsnprintf() (e.g. UNIX98) defined it to return // -1. This method follows the C99 standard, but needs to guess at the // value; uses maxlen + 1. if (result == -1) result = ACE_static_cast (int, (maxlen + 1)); return result; #else ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (maxlen); ACE_UNUSED_ARG (format); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SNPRINTF */ }

ACE_INLINE ACE_HANDLE ACE_OS::socket (  int    protocol_family, int    type, int    proto, ACE_Protocol_Info *    protocolinfo, ACE_SOCK_GROUP    g, u_long    flags )  [static]

Create a QoS-enabled socket. If the OS platform doesn't support QoS-enabled <socket> then the BSD-style <socket> is called. Definition at line 5491 of file OS.i. References ACE_OS_TRACE, ACE_SOCK_GROUP, ACE_SOCKCALL_RETURN, and socket. { ACE_OS_TRACE ("ACE_OS::socket"); #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) ACE_SOCKCALL_RETURN (::WSASocket (domain, type, proto, protocolinfo, g, flags), ACE_HANDLE, ACE_INVALID_HANDLE); #else ACE_UNUSED_ARG (protocolinfo); ACE_UNUSED_ARG (g); ACE_UNUSED_ARG (flags); return ACE_OS::socket (domain, type, proto); #endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE ACE_HANDLE ACE_OS::socket (  int    protocol_family, int    type, int    proto )  [static]

Create a BSD-style socket (no QoS). Definition at line 5478 of file OS.i. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and socket. Referenced by ACE_WIN32_Asynch_Accept::accept, ACE_WIN32_Asynch_Connect::connect_i, ACE_POSIX_Asynch_Connect::connect_i, ACE_Sock_Connect::get_bcast_addr, ACE_Sock_Connect::get_handle, ioctl, ACE_Sock_Connect::ipv6_enabled, join_leaf, ACE_SOCK::open, ACE_ATM_Acceptor::open, ACE_Asynch_Acceptor::open, ACE_SPIPE_Stream::recv_handle, and socket. { ACE_OS_TRACE ("ACE_OS::socket"); ACE_SOCKCALL_RETURN (::socket (domain, type, proto), ACE_HANDLE, ACE_INVALID_HANDLE); }

int ACE_OS::socket_fini (  void    )  [static]

Finalize WinSock after last use (e.g., when a DLL is unloaded). Definition at line 4432 of file OS.cpp. References ACE_LIB_TEXT, fprintf, socket_initialized_, and sprintf. Referenced by ACE_OS_Object_Manager::fini. { # if defined (ACE_WIN32) if (ACE_OS::socket_initialized_ != 0) { if (WSACleanup () != 0) { int error = ::WSAGetLastError (); # if defined (ACE_HAS_WINCE) wchar_t fmt[] = ACE_LIB_TEXT ("%s failed, WSAGetLastError returned %d"); wchar_t buf[80]; // @@ Eliminate magic number. ACE_OS::sprintf (buf, fmt, ACE_LIB_TEXT ("WSACleanup"), error); ::MessageBox (0, buf , ACE_LIB_TEXT ("WSACleanup failed!"), MB_OK); # else ACE_OS::fprintf (stderr, "ACE_OS::socket_fini; WSACleanup failed, " "WSAGetLastError returned %d\n", error); # endif /* ACE_HAS_WINCE */ } ACE_OS::socket_initialized_ = 0; } # endif /* ACE_WIN32 */ return 0; }

int ACE_OS::socket_init (  int    version_high = 1, int    version_low = 1 )  [static]

Initialize WinSock before first use (e.g., when a DLL is first loaded or the first use of a socket() call. Definition at line 4398 of file OS.cpp. References ACE_LIB_TEXT, fprintf, socket_initialized_, and sprintf. Referenced by ACE_OS_Object_Manager::init. { # if defined (ACE_WIN32) if (ACE_OS::socket_initialized_ == 0) { WORD version_requested = MAKEWORD (version_high, version_low); WSADATA wsa_data; int error = WSAStartup (version_requested, &wsa_data); if (error != 0) # if defined (ACE_HAS_WINCE) { wchar_t fmt[] = ACE_LIB_TEXT ("%s failed, WSAGetLastError returned %d"); wchar_t buf[80]; // @@ Eliminate magic number. ACE_OS::sprintf (buf, fmt, ACE_LIB_TEXT ("WSAStartup"), error); ::MessageBox (0, buf, ACE_LIB_TEXT ("WSAStartup failed!"), MB_OK); } # else ACE_OS::fprintf (stderr, "ACE_OS::socket_init; WSAStartup failed, " "WSAGetLastError returned %d\n", error); # endif /* ACE_HAS_WINCE */ ACE_OS::socket_initialized_ = 1; } # else ACE_UNUSED_ARG (version_high); ACE_UNUSED_ARG (version_low); # endif /* ACE_WIN32 */ return 0; }

ACE_INLINE int ACE_OS::socketpair (  int    domain, int    type, int    protocol, ACE_HANDLE    sv[2] )  [static]

BSD-style <accept> (no QoS). Definition at line 9456 of file OS.i. References ACE_OS_TRACE, and socketpair. Referenced by ACE_Pipe::open, and socketpair. { ACE_OS_TRACE ("ACE_OS::socketpair"); #if defined (ACE_WIN32) || defined (ACE_LACKS_SOCKETPAIR) ACE_UNUSED_ARG (domain); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (protocol); ACE_UNUSED_ARG (sv); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::socketpair (domain, type, protocol, sv), int, -1); #endif /* ACE_WIN32 */ }

int ACE_OS::sprintf (  wchar_t *    buf, const wchar_t *    format, ...    )  [static]

Definition at line 1081 of file OS.cpp. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::sprintf"); # if defined (_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500) // The XPG4/UNIX98/C99 signature of the wide-char sprintf has a // maxlen argument. Since this method doesn't supply one, pass in // the max possible length. If this isn't ok, use ACE_OS::snprintf(). int result; va_list ap; va_start (ap, format); ACE_OSCALL (::vswprintf (buf, ULONG_MAX, format, ap), int, -1, result); va_end (ap); return result; # elif defined (ACE_WIN32) // Windows has vswprintf, but the signature is from the older ISO C // standard. Also see ACE_OS::snprintf() for more info on this. int result; va_list ap; va_start (ap, format); ACE_OSCALL (::vswprintf (buf, format, ap), int, -1, result); va_end (ap); return result; # else ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (format); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_VSWPRINTF */ }

int ACE_OS::sprintf (  char *    buf, const char *    format, ...    )  [static]

Definition at line 1067 of file OS.cpp. References ACE_SPRINTF_ADAPTER, and vsprintf. Referenced by ACE_MEM_Acceptor::accept, ACE_STATIC_SVC_DEFINE, ACE_TPQ_Entry::ACE_TPQ_Entry, ACE_INET_Addr::addr_to_string, ACE_ATM_Addr::addr_to_string, dlerror, ACE_ATM_Addr::dump, ACE_Ini_ImpExp::export_section, ACE_Registry_ImpExp::export_section, ACE::format_hexdump, ACE_Log_Record::format_msg, ACE_Sock_Connect::get_ip_interfaces, ACE_Logging_Strategy::handle_timeout, inet_ntop, ACE_Stream_Type::info, ACE_Module_Type::info, ACE_Service_Manager::info, ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::info, ACE_Oneshot_Acceptor::info, ACE_Strategy_Acceptor::info, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::info, ACE_Lib_Find::ldfind, ACE_Log_Msg::log, ACE_Log_Msg::log_hexdump, mmap, ACE_Token_Proxy::open, ACE_Timeprobe::print_absolute_times, ACE_High_Res_Timer::print_ave, ACE_Stats::print_summary, ACE_High_Res_Timer::print_total, ACE_Process_Options::setenv, ACE::sock_error, socket_fini, socket_init, ACE_Process::spawn, ACE::timestamp, uname, and unique_name. { // ACE_OS_TRACE ("ACE_OS::sprintf"); int result; va_list ap; va_start (ap, format); ACE_OSCALL (ACE_SPRINTF_ADAPTER (::vsprintf (buf, format, ap)), int, -1, result); va_end (ap); return result; }

ACE_INLINE void ACE_OS::srand (  u_int    seed )  [static]

Definition at line 757 of file OS.i. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::srand"); ::srand (seed); }

ACE_INLINE int ACE_OS::stat (  const ACE_TCHAR *    file, ACE_stat *    )  [static]

Definition at line 683 of file OS.i. References ACE_OS_TRACE, ACE_stat, ACE_TCHAR, set_errno_to_last_error, and stat. Referenced by ACE_Filecache_Object::ACE_Filecache_Object, filesize, ACE_Filecache_Object::release, stat, and ACE_Filecache_Object::update. { ACE_OS_TRACE ("ACE_OS::stat"); #if defined (VXWORKS) ACE_OSCALL_RETURN (::stat ((char *) file, stp), int, -1); #elif defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (file); ACE_UNUSED_ARG (stp); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_PSOS) ACE_OSCALL_RETURN (::stat_f ((char *) file, stp), int, -1); #elif defined (ACE_HAS_WINCE) ACE_TEXT_WIN32_FIND_DATA fdata; HANDLE fhandle; fhandle = ::FindFirstFile (file, &fdata); if (fhandle == INVALID_HANDLE_VALUE) { ACE_OS::set_errno_to_last_error (); return -1; } else if (fdata.nFileSizeHigh != 0) { errno = EINVAL; return -1; } else { stp->st_size = fdata.nFileSizeLow; stp->st_atime = ACE_Time_Value (fdata.ftLastAccessTime); stp->st_mtime = ACE_Time_Value (fdata.ftLastWriteTime); } return 0; #elif defined (ACE_HAS_X86_STAT_MACROS) // Solaris for intel uses an macro for stat(), this macro is a // wrapper for _xstat(). ACE_OSCALL_RETURN (::_xstat (_STAT_VER, file, stp), int, -1); #elif defined (__BORLANDC__) && (__BORLANDC__ <= 0x540) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wstat (file, stp), int, -1); #elif defined (ACE_WIN32) # if defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wstat (file, (struct _stat *) stp), int, -1); # else ACE_OSCALL_RETURN (::_stat (file, (struct _stat *) stp), int, -1); # endif /* ACE_USES_WCHAR */ #else /* VXWORKS */ ACE_OSCALL_RETURN (::stat (file, stp), int, -1); #endif /* VXWORKS */ }

ACE_INLINE int ACE_OS::step (  const char *    str, char *    expbuf )  [static]

Definition at line 8154 of file OS.i. References ACE_OS_TRACE, and step. Referenced by ACE_Local_Name_Space::list_type_entries_i, ACE_Local_Name_Space::list_types_i, and step. { ACE_OS_TRACE ("ACE_OS::step"); #if defined (ACE_HAS_REGEX) ACE_OSCALL_RETURN (::step (str, expbuf), int, -1); #else ACE_UNUSED_ARG (str); ACE_UNUSED_ARG (expbuf); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_REGEX */ }

ACE_INLINE ACE_TCHAR * ACE_OS::strenvdup (  const ACE_TCHAR *    str )  [static]

Definition at line 11074 of file OS.i. References ACE_LIB_TEXT, ACE_TCHAR, getenv, and ACE_OS_String::strdup. Referenced by ACE::strenvdup, and string_to_argv. { #if defined (ACE_HAS_WINCE) // WinCE doesn't have environment variables so we just skip it. return ACE_OS::strdup (str); #elif defined (ACE_LACKS_ENV) ACE_UNUSED_ARG (str); ACE_NOTSUP_RETURN (0); #else ACE_TCHAR *temp = 0; if (str[0] == ACE_LIB_TEXT ('$') && (temp = ACE_OS::getenv (&str[1])) != 0) return ACE_OS::strdup (temp); else return ACE_OS::strdup (str); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE size_t ACE_OS::strftime (  char *    s, size_t    maxsize, const char *    format, const struct tm *    timeptr )  [static]

Definition at line 8860 of file OS.i. { #if !defined (ACE_HAS_WINCE) && !defined(ACE_PSOS) || defined (ACE_PSOS_HAS_TIME) return ::strftime (s, maxsize, format, timeptr); #else ACE_UNUSED_ARG (s); ACE_UNUSED_ARG (maxsize); ACE_UNUSED_ARG (format); ACE_UNUSED_ARG (timeptr); ACE_NOTSUP_RETURN (0); #endif /* !ACE_HAS_WINCE && !ACE_PSOS || ACE_PSOS_HAS_TIME */ }

int ACE_OS::string_to_argv (  ACE_TCHAR *    buf, int &    argc, ACE_TCHAR **&    argv, int    substitute_env_args = 1 )  [static]

Definition at line 3967 of file OS.cpp. References ACE_DEFAULT_ARGV_BUFSIZ, ACE_OS_String::ace_isspace, ACE_NEW_RETURN, ACE_TCHAR, ACE_OS_String::strdup, and strenvdup. Referenced by ACE_ARGV::string_to_argv. { // Reset the number of arguments argc = 0; if (buf == 0) return -1; ACE_TCHAR *cp = buf; // First pass: count arguments. // '#' is the start-comment token.. while (*cp != '\0' && *cp != '#') { // Skip whitespace.. while (ACE_OS::ace_isspace (*cp)) cp++; // Increment count and move to next whitespace.. if (*cp != '\0') argc++; while (*cp != '\0' && !ACE_OS::ace_isspace (*cp)) { // Grok quotes.... if (*cp == '\'' || *cp == '"') { ACE_TCHAR quote = *cp; // Scan past the string.. for (cp++; *cp != '\0' && *cp != quote; cp++) continue; // '\0' implies unmatched quote.. if (*cp == '\0') { argc--; break; } else cp++; } else cp++; } } // Second pass: copy arguments. ACE_TCHAR arg[ACE_DEFAULT_ARGV_BUFSIZ]; ACE_TCHAR *argp = arg; // Make sure that the buffer we're copying into is always large // enough. if (cp - buf >= ACE_DEFAULT_ARGV_BUFSIZ) ACE_NEW_RETURN (argp, ACE_TCHAR[cp - buf + 1], -1); // Make a new argv vector of argc + 1 elements. ACE_NEW_RETURN (argv, ACE_TCHAR *[argc + 1], -1); ACE_TCHAR *ptr = buf; for (int i = 0; i < argc; i++) { // Skip whitespace.. while (ACE_OS::ace_isspace (*ptr)) ptr++; // Copy next argument and move to next whitespace.. cp = argp; while (*ptr != '\0' && !ACE_OS::ace_isspace (*ptr)) if (*ptr == '\'' || *ptr == '"') { ACE_TCHAR quote = *ptr++; while (*ptr != '\0' && *ptr != quote) *cp++ = *ptr++; if (*ptr == quote) ptr++; } else *cp++ = *ptr++; *cp = '\0'; #if !defined (ACE_LACKS_ENV) // Check for environment variable substitution here. if (substitute_env_args) { argv[i] = ACE_OS::strenvdup(argp); if (argv[i] == 0) { if (argp != arg) delete [] argp; errno = ENOMEM; return -1; } } else #endif /* ACE_LACKS_ENV */ { argv[i] = ACE_OS::strdup(argp); if (argv[i] == 0) { if (argp != arg) delete [] argp; errno = ENOMEM; return -1; } } } if (argp != arg) delete [] argp; argv[argc] = 0; return 0; }

ACE_INLINE long ACE_OS::sysconf (  int    )  [static]

Definition at line 1079 of file OS.i. References ACE_OS_TRACE, and sysconf. Referenced by ACE_POSIX_AIOCB_Proactor::check_max_aio_num, ACE::max_handles, sysconf, and thr_min_stack. { ACE_OS_TRACE ("ACE_OS::sysconf"); #if defined (ACE_WIN32) || defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::sysconf (name), long, -1); #endif /* ACE_WIN32 || VXWORKS || ACE_PSOS */ }

ACE_INLINE long ACE_OS::sysinfo (  int    cmd, char *    buf, long    count )  [static]

Definition at line 8168 of file OS.i. References ACE_OS_TRACE, and sysinfo. Referenced by ACE_POSIX_Proactor::ACE_POSIX_Proactor, and sysinfo. { ACE_OS_TRACE ("ACE_OS::sysinfo"); #if defined (ACE_HAS_SYSINFO) ACE_OSCALL_RETURN (::sysinfo (cmd, buf, count), long, -1); #else ACE_UNUSED_ARG (cmd); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (count); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_SYSINFO */ }

ACE_INLINE int ACE_OS::system (  const ACE_TCHAR *    s )  [static]

Definition at line 6403 of file OS.i. References ACE_TCHAR, and system. Referenced by system. { // ACE_OS_TRACE ("ACE_OS::system"); #if defined (CHORUS) || defined (ACE_HAS_WINCE) || defined(ACE_PSOS) ACE_UNUSED_ARG (s); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wsystem (s), int, -1); #else ACE_OSCALL_RETURN (::system (s), int, -1); #endif /* !CHORUS */ }

ACE_INLINE ACE_TCHAR * ACE_OS::tempnam (  const ACE_TCHAR *    dir = 0, const ACE_TCHAR *    pfx = 0 )  [static]

Definition at line 831 of file OS.i. References ACE_OS_TRACE, ACE_TCHAR, and tempnam. Referenced by tempnam. { ACE_OS_TRACE ("ACE_OS::tempnam"); #if defined (VXWORKS) || defined (ACE_HAS_WINCE) || defined (ACE_LACKS_TEMPNAM) ACE_UNUSED_ARG (dir); ACE_UNUSED_ARG (pfx); ACE_NOTSUP_RETURN (0); #elif defined (ACE_PSOS) // pSOS only considers the directory prefix ACE_UNUSED_ARG (pfx); ACE_OSCALL_RETURN (::tmpnam ((char *) dir), char *, 0); #elif (defined (ACE_WIN32) && ((defined (__BORLANDC__) && !defined(ACE_USES_WCHAR)) || defined (__IBMCPP__))) ACE_OSCALL_RETURN (::_tempnam ((char *) dir, (char *) pfx), char *, 0); #elif defined(ACE_WIN32) && defined (__BORLANDC__) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wtempnam ((wchar_t*) dir, (wchar_t*) pfx), wchar_t *, 0); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wtempnam (dir, pfx), wchar_t *, 0); #else /* VXWORKS */ ACE_OSCALL_RETURN (::tempnam (dir, pfx), char *, 0); #endif /* VXWORKS */ }

ACE_INLINE int ACE_OS::thr_cancel (  ACE_thread_t    t_id )  [static]

Definition at line 6955 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and ACE_thread_t. Referenced by ACE_Thread::cancel. { ACE_OS_TRACE ("ACE_OS::thr_cancel"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_cancel (thr_id), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_cancel (thr_id), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # else /* Could be ACE_HAS_PTHREADS && ACE_LACKS_PTHREAD_CANCEL */ ACE_UNUSED_ARG (thr_id); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (thr_id); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_cmp (  ACE_hthread_t    t1, ACE_hthread_t    t2 )  [static]

Definition at line 6450 of file OS.i. References ACE_hthread_t. Referenced by ACE_Thread_Manager::find_hthread, ACE_Thread_Manager::hthread_within, ACE_Thread_Descriptor_Base::operator==, and ACE_Thread_ID::operator==. { #if defined (ACE_HAS_PTHREADS) # if defined (pthread_equal) // If it's a macro we can't say "::pthread_equal"... return pthread_equal (t1, t2); # else return ::pthread_equal (t1, t2); # endif /* pthread_equal */ #else /* For STHREADS, WTHREADS, and VXWORKS ... */ // Hum, Do we need to treat WTHREAD differently? // levine 13 oct 98 % Probably, ACE_hthread_t is a HANDLE. return t1 == t2; #endif /* ACE_HAS_PTHREADS */ }

ACE_INLINE int ACE_OS::thr_continue (  ACE_hthread_t    target_thread )  [static]

Definition at line 6417 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, ACE_SYSCALL_FAILED, and thr_continue. Referenced by ACE_Thread::resume, thr_continue, and thr_create. { ACE_OS_TRACE ("ACE_OS::thr_continue"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_continue (target_thread), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREAD_CONTINUE) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_continue (target_thread), ace_result_), int, -1); # else ACE_UNUSED_ARG (target_thread); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREAD_CONTINUE */ # elif defined (ACE_HAS_WTHREADS) DWORD result = ::ResumeThread (target_thread); if (result == ACE_SYSCALL_FAILED) ACE_FAIL_RETURN (-1); else return 0; # elif defined (ACE_PSOS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::t_resume (target_thread), ace_result_), int, -1); # elif defined (VXWORKS) ACE_OSCALL_RETURN (::taskResume (target_thread), int, -1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (target_thread); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_create (  ACE_THR_FUNC    func, void *    args, long    flags, ACE_thread_t *    thr_id, ACE_hthread_t *    t_handle = 0, long    priority = ACE_DEFAULT_THREAD_PRIORITY, void *    stack = 0, size_t    stacksize = 0, ACE_Base_Thread_Adapter *    thread_adapter = 0 )  [static]

Definition at line 2562 of file OS.cpp. References ACE_ADAPT_RETVAL, ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_DEFAULT_THREAD_PRIORITY, ACE_hthread_t, ACE_MAX, ACE_MIN, ACE_NEW_RETURN, ACE_OS_TRACE, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_SET_BITS, ACE_THR_PRI_FIFO_DEF, ACE_THR_PRI_OTHER_DEF, ACE_thread_t, ENOSYS, ENOTSUP, ACE_Base_Thread_Adapter::entry_point, lwp_setparams, ACE_OS_String::memset, sched_params, ACE_OS_String::strsncpy, thr_continue, thr_create, thr_getconcurrency, thr_self, thr_setconcurrency, and thr_setprio. Referenced by ACE_Thread::spawn, ACE_Thread::spawn_n, and thr_create. { ACE_OS_TRACE ("ACE_OS::thr_create"); if (ACE_BIT_DISABLED (flags, THR_DETACHED) && ACE_BIT_DISABLED (flags, THR_JOINABLE)) ACE_SET_BITS (flags, THR_JOINABLE); # if defined (ACE_NO_THREAD_ADAPTER) # define ACE_THREAD_FUNCTION func # define ACE_THREAD_ARGUMENT args # else /* ! defined (ACE_NO_THREAD_ADAPTER) */ # if defined (ACE_PSOS) # define ACE_THREAD_FUNCTION (PSOS_TASK_ENTRY_POINT) thread_args->entry_point () # else # define ACE_THREAD_FUNCTION thread_args->entry_point () # endif /* defined (ACE_PSOS) */ # define ACE_THREAD_ARGUMENT thread_args # endif /* ! defined (ACE_NO_THREAD_ADAPTER) */ ACE_Base_Thread_Adapter *thread_args; if (thread_adapter == 0) # if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) ACE_NEW_RETURN (thread_args, ACE_OS_Thread_Adapter (func, args, (ACE_THR_C_FUNC) ace_thread_adapter, ACE_OS_Object_Manager::seh_except_selector(), ACE_OS_Object_Manager::seh_except_handler()), -1); # else ACE_NEW_RETURN (thread_args, ACE_OS_Thread_Adapter (func, args, (ACE_THR_C_FUNC) ace_thread_adapter), -1); # endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ else thread_args = thread_adapter; # if defined (ACE_HAS_THREADS) // *** Set Stack Size # if defined (ACE_NEEDS_HUGE_THREAD_STACKSIZE) if (stacksize < ACE_NEEDS_HUGE_THREAD_STACKSIZE) stacksize = ACE_NEEDS_HUGE_THREAD_STACKSIZE; # endif /* ACE_NEEDS_HUGE_THREAD_STACKSIZE */ # if !defined (VXWORKS) // On VxWorks, the OS will provide a task name if the user doesn't. // So, we don't need to create a tmp_thr. If the caller of this // member function is the Thread_Manager, than thr_id will be non-zero // anyways. ACE_thread_t tmp_thr; if (thr_id == 0) thr_id = &tmp_thr; # endif /* ! VXWORKS */ ACE_hthread_t tmp_handle; if (thr_handle == 0) thr_handle = &tmp_handle; # if defined (ACE_HAS_PTHREADS) int result; pthread_attr_t attr; # if defined (ACE_HAS_PTHREADS_DRAFT4) if (::pthread_attr_create (&attr) != 0) # else /* ACE_HAS_PTHREADS_DRAFT4 */ if (::pthread_attr_init (&attr) != 0) # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; # if defined (CHORUS) // If it is a super actor, we can't set stacksize. But for the time // being we are all non-super actors. Should be fixed to take care // of super actors!!! if (stacksize == 0) stacksize = ACE_CHORUS_DEFAULT_MIN_STACK_SIZE; else if (stacksize < ACE_CHORUS_DEFAULT_MIN_STACK_SIZE) stacksize = ACE_CHORUS_DEFAULT_MIN_STACK_SIZE; # endif /*CHORUS */ # if defined (ACE_HAS_PTHREAD_SETSTACK) if ((stacksize != 0) && (stack != 0)) # else if (stacksize != 0) # endif /* ACE_HAS_PTHREAD_SETSTACK */ { size_t size = stacksize; # if defined (PTHREAD_STACK_MIN) if (size < ACE_static_cast (size_t, PTHREAD_STACK_MIN)) size = PTHREAD_STACK_MIN; # endif /* PTHREAD_STACK_MIN */ # if !defined (ACE_LACKS_THREAD_STACK_SIZE) // JCEJ 12/17/96 # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) if (::pthread_attr_setstacksize (&attr, size) != 0) # else # if defined (ACE_HAS_PTHREAD_SETSTACK) if (ACE_ADAPT_RETVAL(pthread_attr_setstack (&attr, stack, size), result) == -1) # else if (ACE_ADAPT_RETVAL(pthread_attr_setstacksize (&attr, size), result) == -1) # endif /* ACE_HAS_PTHREAD_SETSTACK */ # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } # else ACE_UNUSED_ARG (size); # endif /* !ACE_LACKS_THREAD_STACK_SIZE */ } // *** Set Stack Address # if !defined (ACE_HAS_PTHREAD_SETSTACK) # if !defined (ACE_LACKS_THREAD_STACK_ADDR) if (stack != 0) { if (::pthread_attr_setstackaddr (&attr, stack) != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } } # else ACE_UNUSED_ARG (stack); # endif /* !ACE_LACKS_THREAD_STACK_ADDR */ # endif /* ACE_HAS_PTHREAD_SETSTACK */ // *** Deal with various attributes if (flags != 0) { // *** Set Detach state # if !defined (ACE_LACKS_SETDETACH) if (ACE_BIT_ENABLED (flags, THR_DETACHED) || ACE_BIT_ENABLED (flags, THR_JOINABLE)) { int dstate = PTHREAD_CREATE_JOINABLE; if (ACE_BIT_ENABLED (flags, THR_DETACHED)) dstate = PTHREAD_CREATE_DETACHED; # if defined (ACE_HAS_PTHREADS_DRAFT4) if (::pthread_attr_setdetach_np (&attr, dstate) != 0) # else /* ACE_HAS_PTHREADS_DRAFT4 */ # if defined (ACE_HAS_PTHREADS_DRAFT6) if (::pthread_attr_setdetachstate (&attr, &dstate) != 0) # else if (ACE_ADAPT_RETVAL(::pthread_attr_setdetachstate (&attr, dstate), result) != 0) # endif /* ACE_HAS_PTHREADS_DRAFT6 */ # endif /* ACE_HAS_PTHREADS_DRAFT4 */ { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } } // Note: if ACE_LACKS_SETDETACH and THR_DETACHED is enabled, we // call ::pthread_detach () below. If THR_DETACHED is not // enabled, we call ::pthread_detach () in the Thread_Manager, // after joining with the thread. # endif /* ACE_LACKS_SETDETACH */ // *** Set Policy # if !defined (ACE_LACKS_SETSCHED) // If we wish to set the priority explicitly, we have to enable // explicit scheduling, and a policy, too. if (priority != ACE_DEFAULT_THREAD_PRIORITY) { ACE_SET_BITS (flags, THR_EXPLICIT_SCHED); if (ACE_BIT_DISABLED (flags, THR_SCHED_FIFO) && ACE_BIT_DISABLED (flags, THR_SCHED_RR) && ACE_BIT_DISABLED (flags, THR_SCHED_DEFAULT)) ACE_SET_BITS (flags, THR_SCHED_DEFAULT); } if (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO) || ACE_BIT_ENABLED (flags, THR_SCHED_RR) || ACE_BIT_ENABLED (flags, THR_SCHED_DEFAULT)) { int spolicy; # if defined (ACE_HAS_ONLY_SCHED_OTHER) // SunOS, thru version 5.6, only supports SCHED_OTHER. spolicy = SCHED_OTHER; # else // Make sure to enable explicit scheduling, in case we didn't // enable it above (for non-default priority). ACE_SET_BITS (flags, THR_EXPLICIT_SCHED); if (ACE_BIT_ENABLED (flags, THR_SCHED_DEFAULT)) spolicy = SCHED_OTHER; else if (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO)) spolicy = SCHED_FIFO; # if defined (SCHED_IO) else if (ACE_BIT_ENABLED (flags, THR_SCHED_IO)) spolicy = SCHED_IO; # else else if (ACE_BIT_ENABLED (flags, THR_SCHED_IO)) { errno = ENOSYS; return -1; } # endif /* SCHED_IO */ else spolicy = SCHED_RR; # if defined (ACE_HAS_FSU_PTHREADS) int ret; switch (spolicy) { case SCHED_FIFO: case SCHED_RR: ret = 0; break; default: ret = 22; break; } if (ret != 0) { ::pthread_attr_destroy (&attr); return -1; } # endif /* ACE_HAS_FSU_PTHREADS */ # endif /* ACE_HAS_ONLY_SCHED_OTHER */ # if defined (ACE_HAS_PTHREADS_DRAFT4) result = ::pthread_attr_setsched (&attr, spolicy); # elif defined (ACE_HAS_PTHREADS_DRAFT6) result = ::pthread_attr_setschedpolicy (&attr, spolicy); # else /* draft 7 or std */ ACE_ADAPT_RETVAL(::pthread_attr_setschedpolicy (&attr, spolicy), result); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ if (result != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } } // *** Set Priority (use reasonable default priorities) # if defined(ACE_HAS_PTHREADS_STD) // If we wish to explicitly set a scheduling policy, we also // have to specify a priority. We choose a "middle" priority as // default. Maybe this is also necessary on other POSIX'ish // implementations? if ((ACE_BIT_ENABLED (flags, THR_SCHED_FIFO) || ACE_BIT_ENABLED (flags, THR_SCHED_RR) || ACE_BIT_ENABLED (flags, THR_SCHED_DEFAULT)) && priority == ACE_DEFAULT_THREAD_PRIORITY) { if (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO)) priority = ACE_THR_PRI_FIFO_DEF; else if (ACE_BIT_ENABLED (flags, THR_SCHED_RR)) priority = ACE_THR_PRI_RR_DEF; else // THR_SCHED_DEFAULT priority = ACE_THR_PRI_OTHER_DEF; } # endif /* ACE_HAS_PTHREADS_STD */ if (priority != ACE_DEFAULT_THREAD_PRIORITY) { struct sched_param sparam; ACE_OS::memset ((void *) &sparam, 0, sizeof sparam); # if defined (ACE_HAS_IRIX62_THREADS) sparam.sched_priority = ACE_MIN (priority, (long) PTHREAD_MAX_PRIORITY); # elif defined (PTHREAD_MAX_PRIORITY) && !defined(ACE_HAS_PTHREADS_STD) /* For MIT pthreads... */ sparam.prio = ACE_MIN (priority, PTHREAD_MAX_PRIORITY); # elif defined(ACE_HAS_PTHREADS_STD) && !defined (ACE_HAS_STHREADS) // The following code forces priority into range. if (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO)) sparam.sched_priority = ACE_MIN (ACE_THR_PRI_FIFO_MAX, ACE_MAX (ACE_THR_PRI_FIFO_MIN, priority)); else if (ACE_BIT_ENABLED(flags, THR_SCHED_RR)) sparam.sched_priority = ACE_MIN (ACE_THR_PRI_RR_MAX, ACE_MAX (ACE_THR_PRI_RR_MIN, priority)); else // Default policy, whether set or not sparam.sched_priority = ACE_MIN (ACE_THR_PRI_OTHER_MAX, ACE_MAX (ACE_THR_PRI_OTHER_MIN, priority)); # elif defined (PRIORITY_MAX) sparam.sched_priority = ACE_MIN (priority, (long) PRIORITY_MAX); # else sparam.sched_priority = priority; # endif /* ACE_HAS_IRIX62_THREADS */ # if defined (ACE_HAS_FSU_PTHREADS) if (sparam.sched_priority >= PTHREAD_MIN_PRIORITY && sparam.sched_priority <= PTHREAD_MAX_PRIORITY) attr.prio = sparam.sched_priority; else { pthread_attr_destroy (&attr); errno = EINVAL; return -1; } # else { # if defined (sun) && defined (ACE_HAS_ONLY_SCHED_OTHER) // SunOS, through 5.6, POSIX only allows priorities > 0 to // ::pthread_attr_setschedparam. If a priority of 0 was // requested, set the thread priority after creating it, below. if (priority > 0) # endif /* sun && ACE_HAS_ONLY_SCHED_OTHER */ { # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) result = ::pthread_attr_setprio (&attr, sparam.sched_priority); # else /* this is draft 7 or std */ ACE_ADAPT_RETVAL(::pthread_attr_setschedparam (&attr, &sparam), result); # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ if (result != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } } } # endif /* ACE_HAS_FSU_PTHREADS */ } // *** Set scheduling explicit or inherited if (ACE_BIT_ENABLED (flags, THR_INHERIT_SCHED) || ACE_BIT_ENABLED (flags, THR_EXPLICIT_SCHED)) { # if defined (ACE_HAS_PTHREADS_DRAFT4) int sched = PTHREAD_DEFAULT_SCHED; # else /* ACE_HAS_PTHREADS_DRAFT4 */ int sched = PTHREAD_EXPLICIT_SCHED; # endif /* ACE_HAS_PTHREADS_DRAFT4 */ if (ACE_BIT_ENABLED (flags, THR_INHERIT_SCHED)) sched = PTHREAD_INHERIT_SCHED; if (::pthread_attr_setinheritsched (&attr, sched) != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } } # else /* ACE_LACKS_SETSCHED */ ACE_UNUSED_ARG (priority); # endif /* ACE_LACKS_SETSCHED */ // *** Set Scope # if !defined (ACE_LACKS_THREAD_PROCESS_SCOPING) if (ACE_BIT_ENABLED (flags, THR_SCOPE_SYSTEM) || ACE_BIT_ENABLED (flags, THR_SCOPE_PROCESS)) { # if defined (ACE_CONFIG_LINUX_H) || defined (HPUX) // LinuxThreads do not have support for PTHREAD_SCOPE_PROCESS. // Neither does HPUX (up to HP-UX 11.00, as far as I know). int scope = PTHREAD_SCOPE_SYSTEM; # else /* ACE_CONFIG_LINUX_H */ int scope = PTHREAD_SCOPE_PROCESS; # endif /* ACE_CONFIG_LINUX_H */ if (ACE_BIT_ENABLED (flags, THR_SCOPE_SYSTEM)) scope = PTHREAD_SCOPE_SYSTEM; if (::pthread_attr_setscope (&attr, scope) != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) ::pthread_attr_delete (&attr); # else /* ACE_HAS_PTHREADS_DRAFT4 */ ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; } } # endif /* !ACE_LACKS_THREAD_PROCESS_SCOPING */ if (ACE_BIT_ENABLED (flags, THR_NEW_LWP)) { // Increment the number of LWPs by one to emulate the // SunOS semantics. int lwps = ACE_OS::thr_getconcurrency (); if (lwps == -1) { if (errno == ENOTSUP) // Suppress the ENOTSUP because it's harmless. errno = 0; else // This should never happen on SunOS: // ::thr_getconcurrency () should always succeed. return -1; } else if (ACE_OS::thr_setconcurrency (lwps + 1) == -1) { if (errno == ENOTSUP) { // Unlikely: ::thr_getconcurrency () is supported but // ::thr_setconcurrency () is not? } else return -1; } } } # if defined (ACE_HAS_PTHREADS_DRAFT4) ACE_OSCALL (::pthread_create (thr_id, attr, thread_args->entry_point (), thread_args), int, -1, result); # if defined (ACE_LACKS_SETDETACH) if (ACE_BIT_ENABLED (flags, THR_DETACHED)) { # if defined (HPUX_10) // HP-UX DCE threads' pthread_detach will smash thr_id if it's // just given as an argument. This will cause // ACE_Thread_Manager (if it's doing this create) to lose track // of the new thread since the ID will be passed back equal to // 0. So give pthread_detach a junker to scribble on. ACE_thread_t junker; cma_handle_assign(thr_id, &junker); ::pthread_detach (&junker); # else ::pthread_detach (thr_id); # endif /* HPUX_10 */ } # endif /* ACE_LACKS_SETDETACH */ ::pthread_attr_delete (&attr); # elif defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL (::pthread_create (thr_id, &attr, thread_args->entry_point (), thread_args), int, -1, result); ::pthread_attr_destroy (&attr); # else /* this is draft 7 or std */ ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_create (thr_id, &attr, thread_args->entry_point (), thread_args), result), int, -1, result); ::pthread_attr_destroy (&attr); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ // This is a SunOS or POSIX implementation of pthreads, where we // assume that ACE_thread_t and ACE_hthread_t are the same. If this // *isn't* correct on some platform, please let us know. if (result != -1) *thr_handle = *thr_id; # if defined (sun) && defined (ACE_HAS_ONLY_SCHED_OTHER) // SunOS prior to 5.7: // If the priority is 0, then we might have to set it now because we // couldn't set it with ::pthread_attr_setschedparam, as noted // above. This doesn't provide strictly correct behavior, because // the thread was created (above) with the priority of its parent. // (That applies regardless of the inherit_sched attribute: if it // was PTHREAD_INHERIT_SCHED, then it certainly inherited its // parent's priority. If it was PTHREAD_EXPLICIT_SCHED, then "attr" // was initialized by the SunOS ::pthread_attr_init () to contain // NULL for the priority, which indicated to SunOS ::pthread_create // () to inherit the parent priority.) if (priority == 0) { // Check the priority of this thread, which is the parent // of the newly created thread. If it is 0, then the // newly created thread will have inherited the priority // of 0, so there's no need to explicitly set it. struct sched_param sparam; int policy = 0; ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_getschedparam (thr_self (), &policy, &sparam), result), int, -1, result); // The only policy supported by by SunOS, thru version 5.6, // is SCHED_OTHER, so that's hard-coded here. policy = ACE_SCHED_OTHER; if (sparam.sched_priority != 0) { ACE_OS::memset ((void *) &sparam, 0, sizeof sparam); // The memset to 0 sets the priority to 0, so we don't need // to explicitly set sparam.sched_priority. ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setschedparam (*thr_id, policy, &sparam), result), int, -1); } } # if defined (ACE_NEEDS_LWP_PRIO_SET) # if 0 // It would be useful if we could make this work. But, it requires // a mechanism for determining the ID of an LWP to which another // thread is bound. Is there a way to do that? Instead, just rely // on the code in ACE_Thread_Adapter::invoke () to set the LWP // priority. // If the thread is bound, then set the priority on its LWP. if (ACE_BIT_ENABLED (flags, THR_BOUND)) { ACE_Sched_Params sched_params (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO) || ACE_BIT_ENABLED (flags, THR_SCHED_RR) ? ACE_SCHED_FIFO : ACE_SCHED_OTHER, priority); result = ACE_OS::lwp_setparams (sched_params, /* ? How do we find the ID of the LWP to which *thr_id is bound? */); } # endif /* 0 */ # endif /* ACE_NEEDS_LWP_PRIO_SET */ # endif /* sun && ACE_HAS_ONLY_SCHED_OTHER */ return result; # elif defined (ACE_HAS_STHREADS) int result; int start_suspended = ACE_BIT_ENABLED (flags, THR_SUSPENDED); if (priority != ACE_DEFAULT_THREAD_PRIORITY) // If we need to set the priority, then we need to start the // thread in a suspended mode. ACE_SET_BITS (flags, THR_SUSPENDED); ACE_OSCALL (ACE_ADAPT_RETVAL (::thr_create (stack, stacksize, thread_args->entry_point (), thread_args, flags, thr_id), result), int, -1, result); if (result != -1) { // With SunOS threads, ACE_thread_t and ACE_hthread_t are the same. *thr_handle = *thr_id; if (priority != ACE_DEFAULT_THREAD_PRIORITY) { // Set the priority of the new thread and then let it // continue, but only if the user didn't start it suspended // in the first place! if ((result = ACE_OS::thr_setprio (*thr_id, priority)) != 0) { errno = result; return -1; } if (start_suspended == 0) { if ((result = ACE_OS::thr_continue (*thr_id)) != 0) { errno = result; return -1; } } } } return result; # elif defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (stack); # if defined (ACE_HAS_MFC) && (ACE_HAS_MFC != 0) if (ACE_BIT_ENABLED (flags, THR_USE_AFX)) { CWinThread *cwin_thread = ::AfxBeginThread ((AFX_THREADPROC) thread_args->entry_point (), thread_args, priority, 0, flags | THR_SUSPENDED); // Have to duplicate the handle because // CWinThread::~CWinThread() closes the original handle. # if !defined (ACE_HAS_WINCE) (void) ::DuplicateHandle (::GetCurrentProcess (), cwin_thread->m_hThread, ::GetCurrentProcess (), thr_handle, 0, TRUE, DUPLICATE_SAME_ACCESS); # endif /* ! ACE_HAS_WINCE */ *thr_id = cwin_thread->m_nThreadID; if (ACE_BIT_ENABLED (flags, THR_SUSPENDED) == 0) cwin_thread->ResumeThread (); // cwin_thread will be deleted in AfxThreadExit() // Warning: If AfxThreadExit() is called from within the // thread, ACE_TSS_Cleanup->exit() never gets called ! } else # endif /* ACE_HAS_MFC */ { int start_suspended = ACE_BIT_ENABLED (flags, THR_SUSPENDED); if (priority != ACE_DEFAULT_THREAD_PRIORITY) // If we need to set the priority, then we need to start the // thread in a suspended mode. ACE_SET_BITS (flags, THR_SUSPENDED); *thr_handle = (void *) ACE_BEGINTHREADEX (0, ACE_static_cast (u_int, stacksize), thread_args->entry_point (), thread_args, flags, thr_id); if (priority != ACE_DEFAULT_THREAD_PRIORITY && *thr_handle != 0) { // Set the priority of the new thread and then let it // continue, but only if the user didn't start it suspended // in the first place! ACE_OS::thr_setprio (*thr_handle, priority); if (start_suspended == 0) ACE_OS::thr_continue (*thr_handle); } } # if 0 *thr_handle = ::CreateThread (0, stacksize, LPTHREAD_START_ROUTINE (thread_args->entry_point ()), thread_args, flags, thr_id); # endif /* 0 */ // Close down the handle if no one wants to use it. if (thr_handle == &tmp_handle) ::CloseHandle (tmp_handle); if (*thr_handle != 0) return 0; else ACE_FAIL_RETURN (-1); /* NOTREACHED */ # elif defined (ACE_PSOS) // stack is created in the task's memory region 0 ACE_UNUSED_ARG (stack); // task creation and start flags are fixed ACE_UNUSED_ARG (flags); // lowest priority is reserved for the IDLE pSOS+ system daemon, // highest are reserved for high priority pSOS+ system daemons if (priority < PSOS_TASK_MIN_PRIORITY) { priority = PSOS_TASK_MIN_PRIORITY; } else if (priority > PSOS_TASK_MAX_PRIORITY) { priority = PSOS_TASK_MAX_PRIORITY; } // set the stacksize to a default value if no size is specified if (stacksize == 0) stacksize = ACE_PSOS_DEFAULT_STACK_SIZE; ACE_hthread_t tid; *thr_handle = 0; // create the thread if (t_create ((char *) thr_id, // task name priority, // (possibly adjusted) task priority stacksize, // passed stack size is used for supervisor stack 0, // no user stack: tasks run strictly in supervisor mode T_LOCAL, // local to the pSOS+ node (does not support pSOS+m) &tid) // receives task id != 0) { return -1; } // pSOS tasks are passed an array of 4 u_longs u_long targs[4]; targs[0] = (u_long) ACE_THREAD_ARGUMENT; targs[1] = 0; targs[2] = 0; targs[3] = 0; // start the thread if (t_start (tid, T_PREEMPT | // Task can be preempted // T_NOTSLICE | // Task is not timesliced with other tasks at same priority T_TSLICE | // Task is timesliced with other tasks at same priority T_NOASR | // Task level signals disabled T_SUPV | // Task runs strictly in supervisor mode T_ISR, // Hardware interrupts are enabled ACE_THREAD_FUNCTION, // Task entry point targs) // Task argument(s) != 0) { return -1; } // store the task id in the handle and return success *thr_handle = tid; return 0; # elif defined (VXWORKS) // The hard-coded values below are what ::sp () would use. (::sp () // hardcodes priority to 100, flags to VX_FP_TASK, and stacksize to // 20,000.) stacksize should be an even integer. If a stack is not // specified, ::taskSpawn () is used so that we can set the // priority, flags, and stacksize. If a stack is specified, // ::taskInit ()/::taskActivate() are used. // If called with thr_create() defaults, use same default values as ::sp (): if (priority == ACE_DEFAULT_THREAD_PRIORITY) priority = 100; // Assumes that there is a floating point coprocessor. As noted // above, ::sp () hardcodes this, so we should be safe with it. if (flags == 0) flags = VX_FP_TASK; if (stacksize == 0) stacksize = 20000; const u_int thr_id_provided = thr_id && *thr_id && (*thr_id)[0] != ACE_THR_ID_ALLOCATED; ACE_hthread_t tid; # if 0 /* Don't support setting of stack, because it doesn't seem to work. */ if (stack == 0) { # else ACE_UNUSED_ARG (stack); # endif /* 0 */ // The call below to ::taskSpawn () causes VxWorks to assign a // unique task name of the form: "t" + an integer, because the // first argument is 0. tid = ::taskSpawn (thr_id_provided ? *thr_id : 0, priority, (int) flags, (int) stacksize, thread_args->entry_point (), (int) thread_args, 0, 0, 0, 0, 0, 0, 0, 0, 0); # if 0 /* Don't support setting of stack, because it doesn't seem to work. */ } else { // If a task name (thr_id) was not supplied, then the task will // not have a unique name. That's VxWorks' behavior. // Carve out a TCB at the beginning of the stack space. The TCB // occupies 400 bytes with VxWorks 5.3.1/I386. WIND_TCB *tcb = (WIND_TCB *) stack; // The TID is defined to be the address of the TCB. int status = ::taskInit (tcb, thr_id_provided ? *thr_id : 0, priority, (int) flags, (char *) stack + sizeof (WIND_TCB), (int) (stacksize - sizeof (WIND_TCB)), thread_args->entry_point (), (int) thread_args, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (status == OK) { // The task was successfully initialized, now activate it. status = ::taskActivate ((ACE_hthread_t) tcb); } tid = status == OK ? (ACE_hthread_t) tcb : ERROR; } # endif /* 0 */ if (tid == ERROR) return -1; else { if (! thr_id_provided && thr_id) { if (*thr_id && (*thr_id)[0] == ACE_THR_ID_ALLOCATED) // *thr_id was allocated by the Thread_Manager. ::taskTcb // (int tid) returns the address of the WIND_TCB (task // control block). According to the ::taskSpawn() // documentation, the name of the new task is stored at // pStackBase, but is that of the current task? If so, it // might be a bit quicker than this extraction of the tcb // . . . ACE_OS::strsncpy (*thr_id + 1, ::taskTcb (tid)->name, 10); else // *thr_id was not allocated by the Thread_Manager. // Pass back the task name in the location pointed to // by thr_id. *thr_id = ::taskTcb (tid)->name; } // else if the thr_id was provided, there's no need to overwrite // it with the same value (string). If thr_id is 0, then we can't // pass the task name back. if (thr_handle) *thr_handle = tid; return 0; } # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (func); ACE_UNUSED_ARG (args); ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (thr_handle); ACE_UNUSED_ARG (priority); ACE_UNUSED_ARG (stack); ACE_UNUSED_ARG (stacksize); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_equal (  ACE_thread_t    t1, ACE_thread_t    t2 )  [static]

Definition at line 2343 of file OS.i. References ACE_thread_t, and ACE_OS_String::strcmp. Referenced by ACE_Thread_Manager::check_state, ACE_Thread_Manager::find_thread, ACE_Select_Reactor_T::handle_events, ACE_Thread_Manager::join, ACE_Thread_Descriptor_Base::operator==, ACE_Thread_ID::operator==, recursive_mutex_cond_unlock, recursive_mutex_lock, recursive_mutex_trylock, recursive_mutex_unlock, ACE_Token::renew, ACE_Token::shared_acquire, ACE_Thread_Manager::thread_within, ACE_Object_Manager_Manager::~ACE_Object_Manager_Manager, and ACE_OS_Object_Manager_Manager::~ACE_OS_Object_Manager_Manager. { #if defined (ACE_HAS_PTHREADS) # if defined (pthread_equal) // If it's a macro we can't say "::pthread_equal"... return pthread_equal (t1, t2); # else return ::pthread_equal (t1, t2); # endif /* pthread_equal */ #elif defined (VXWORKS) return ! ACE_OS::strcmp (t1, t2); #else /* For both STHREADS and WTHREADS... */ // Hum, Do we need to treat WTHREAD differently? // levine 13 oct 98 % I don't think so, ACE_thread_t is a DWORD. return t1 == t2; #endif /* ACE_HAS_PTHREADS */ }

void ACE_OS::thr_exit (  ACE_THR_FUNC_RETURN    status = 0 )  [static]

Definition at line 3422 of file OS.cpp. References ACE_BIT_ENABLED, ACE_hthread_t, ACE_OS_TRACE, cleanup_tss, ACE_OS_Thread_Descriptor::flags, ACE_Base_Thread_Adapter::thr_desc_log_msg, and thr_self. Referenced by ACE_Thread_Control::exit, and ACE_Thread::exit. { ACE_OS_TRACE ("ACE_OS::thr_exit"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) ::pthread_exit (status); # elif defined (ACE_HAS_STHREADS) ::thr_exit (status); # elif defined (ACE_HAS_WTHREADS) // Can't call it here because on NT, the thread is exited // directly by ACE_Thread_Adapter::invoke (). // ACE_TSS_Cleanup::instance ()->exit (status); # if defined (ACE_HAS_MFC) && (ACE_HAS_MFC != 0) int using_afx = -1; // An ACE_Thread_Descriptor really is an ACE_OS_Thread_Descriptor. // But without #including ace/Thread_Manager.h, we don't know that. ACE_OS_Thread_Descriptor *td = ACE_Base_Thread_Adapter::thr_desc_log_msg (); if (td) using_afx = ACE_BIT_ENABLED (td->flags (), THR_USE_AFX); # endif /* ACE_HAS_MFC && (ACE_HAS_MFC != 0) */ // Call TSS destructors. ACE_OS::cleanup_tss (0 /* not main thread */); // Exit the thread. // Allow CWinThread-destructor to be invoked from AfxEndThread. // _endthreadex will be called from AfxEndThread so don't exit the // thread now if we are running an MFC thread. # if defined (ACE_HAS_MFC) && (ACE_HAS_MFC != 0) if (using_afx != -1) { if (using_afx) ::AfxEndThread (status); else ACE_ENDTHREADEX (status); } else { // Not spawned by ACE_Thread_Manager, use the old buggy // version. You should seriously consider using // ACE_Thread_Manager to spawn threads. The following code is // know to cause some problem. CWinThread *pThread = ::AfxGetThread (); if (!pThread || pThread->m_nThreadID != ACE_OS::thr_self ()) ACE_ENDTHREADEX (status); else ::AfxEndThread (status); } # else ACE_ENDTHREADEX (status); # endif /* ACE_HAS_MFC && ACE_HAS_MFS != 0*/ # elif defined (VXWORKS) ACE_hthread_t tid; ACE_OS::thr_self (tid); *((int *) status) = ::taskDelete (tid); # elif defined (ACE_PSOS) ACE_hthread_t tid; ACE_OS::thr_self (tid); # if defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS) // Call TSS destructors. ACE_OS::cleanup_tss (0 /* not main thread */); # endif /* ACE_PSOS && ACE_PSOS_HAS_TSS */ *((u_long *) status) = ::t_delete (tid); # endif /* ACE_HAS_PTHREADS */ # else ACE_UNUSED_ARG (status); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_getconcurrency (  void    )  [static]

Definition at line 6467 of file OS.i. References ACE_OS_TRACE. Referenced by ACE_Thread::getconcurrency, and thr_create. { ACE_OS_TRACE ("ACE_OS::thr_getconcurrency"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) return ::thr_getconcurrency (); # elif defined (ACE_HAS_PTHREADS) || defined (VXWORKS) || defined (ACE_PSOS) ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_WTHREADS) ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_getprio (  ACE_hthread_t    id, int &    priority, int &    policy )  [static]

Definition at line 6484 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, and thr_getprio. { ACE_OS_TRACE ("ACE_OS::thr_getprio"); ACE_UNUSED_ARG (policy); #if defined (ACE_HAS_THREADS) # if (defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_SETSCHED)) # if defined (ACE_HAS_PTHREADS_DRAFT4) int result; result = ::pthread_getprio (id); if (result != -1) { priority = result; return 0; } else return -1; # elif defined (ACE_HAS_PTHREADS_DRAFT6) pthread_attr_t attr; if (pthread_getschedattr (id, &attr) == 0) { priority = pthread_attr_getprio(&attr); return 0; } return -1; # else struct sched_param param; int result; ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_getschedparam (id, &policy, &param), result), int, -1, result); priority = param.sched_priority; return result; # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_getprio (id, &priority), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) priority = ::GetThreadPriority (id); if (priority == THREAD_PRIORITY_ERROR_RETURN) ACE_FAIL_RETURN (-1); else return 0; # elif defined (ACE_PSOS) // passing a 0 in the second argument does not alter task priority, third arg gets existing one ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::t_setpri (id, 0, (u_long *) &priority), ace_result_), int, -1); # elif defined (VXWORKS) ACE_OSCALL_RETURN (::taskPriorityGet (id, &priority), int, -1); # else ACE_UNUSED_ARG (id); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (id); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_getprio (  ACE_hthread_t    id, int &    priority )  [static]

Definition at line 6547 of file OS.i. References ACE_hthread_t, and ACE_OS_TRACE. Referenced by ACE_Thread::getprio, ACE_OS_Thread_Adapter::invoke, ACE_Thread_Adapter::invoke_i, and thr_getprio. { ACE_OS_TRACE ("ACE_OS::thr_getprio"); int policy = 0; return ACE_OS::thr_getprio (id, priority, policy); }

ACE_INLINE int ACE_OS::thr_getspecific (  ACE_thread_key_t    key, void **    data )  [static]

Definition at line 6688 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_KEY_INDEX, ACE_thread_key_t, thr_getspecific, and thr_self. Referenced by ACE_TSS_Cleanup::exit, ACE_Thread::getspecific, thr_getspecific, and ACE_TSS_Cleanup::tss_keys. { // ACE_OS_TRACE ("ACE_OS::thr_getspecific"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_TSS_EMULATION) ACE_KEY_INDEX (key_index, key); if (key_index >= ACE_TSS_Emulation::total_keys ()) { errno = EINVAL; data = 0; return -1; } else { *data = ACE_TSS_Emulation::ts_object (key); return 0; } # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_getspecific (key, data), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) return ::pthread_getspecific (key, data); # else /* this is Draft 7 or STD */ *data = pthread_getspecific (key); return 0; # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ # elif defined (ACE_HAS_WTHREADS) // The following handling of errno is designed like this due to // ACE_Log_Msg::instance calling ACE_OS::thr_getspecific. // Basically, it is ok for a system call to reset the error to zero. // (It really shouldn't, though). However, we have to remember to // store errno *immediately* after an error is detected. Calling // ACE_ERROR_RETURN((..., errno)) did not work because errno was // cleared before being passed to the thread-specific instance of // ACE_Log_Msg. The workaround for was to make it so // thr_getspecific did not have the side effect of clearing errno. // The correct fix is for ACE_ERROR_RETURN to store errno //(actually ACE_OS::last_error) before getting the ACE_Log_Msg tss // pointer, which is how it is implemented now. However, other uses // of ACE_Log_Msg may not work correctly, so we're keeping this as // it is for now. ACE_Errno_Guard error (errno); *data = ::TlsGetValue (key); # if !defined (ACE_HAS_WINCE) if (*data == 0 && (error = ::GetLastError ()) != NO_ERROR) return -1; else # endif /* ACE_HAS_WINCE */ return 0; # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS) ACE_hthread_t tid; ACE_OS::thr_self (tid); ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::tsd_getval (key, tid, data), ace_result_), int, -1); # else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (data); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (data); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_join (  ACE_thread_t    waiter_id, ACE_thread_t *    thr_id, ACE_THR_FUNC_RETURN *    status )  [static]

Definition at line 6832 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, ACE_thread_t, and thr_join. { ACE_OS_TRACE ("ACE_OS::thr_join"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_join (waiter_id, thr_id, status), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) ACE_UNUSED_ARG (thr_id); # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) # if defined (ACE_LACKS_NULL_PTHREAD_STATUS) void *temp; ACE_OSCALL_RETURN (::pthread_join (waiter_id, status == 0 ? &temp : status), int, -1); # else ACE_OSCALL_RETURN (::pthread_join (waiter_id, status), int, -1); # endif # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_join (waiter_id, status), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ # elif defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (waiter_id); ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (status); // This could be implemented if the DLL-Main function or the // task exit base class some log the threads which have exited ACE_NOTSUP_RETURN (-1); # elif defined (ACE_PSOS) ACE_UNUSED_ARG (waiter_id); ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (status); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (waiter_id); ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (status); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_join (  ACE_hthread_t    waiter_id, ACE_THR_FUNC_RETURN *    status )  [static]

Definition at line 6760 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, ACE_thread_t, and thr_join. Referenced by ACE_Thread::join, and thr_join. { ACE_OS_TRACE ("ACE_OS::thr_join"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_join (thr_handle, 0, status), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) int ace_result; # if defined (ACE_LACKS_NULL_PTHREAD_STATUS) void *temp; ACE_OSCALL (::pthread_join (thr_handle, status == 0 ? &temp : status), int, -1, ace_result); # else ACE_OSCALL (::pthread_join (thr_handle, status), int, -1, ace_result); # endif /* ACE_LACKS_NULL_PTHREAD_STATUS */ // Joinable threads need to be detached after joining on Pthreads // draft 4 (at least) to reclaim thread storage. # if defined (ACE_HAS_PTHREADS_DRAFT4) # if defined (HPUX_10) // HP-UX DCE threads' pthread_detach will smash thr_id if it's just given // as an argument. Since the id is still needed, give pthread_detach // a junker to scribble on. ACE_thread_t junker; cma_handle_assign(&thr_handle, &junker); ::pthread_detach (&junker); # else ::pthread_detach (&thr_handle); # endif /* HPUX_10 */ # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return ace_result; # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_join (thr_handle, status), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ # elif defined (ACE_HAS_WTHREADS) ACE_THR_FUNC_RETURN local_status = 0; // Make sure that status is non-NULL. if (status == 0) status = &local_status; if (::WaitForSingleObject (thr_handle, INFINITE) == WAIT_OBJECT_0 && ::GetExitCodeThread (thr_handle, status) != FALSE) { ::CloseHandle (thr_handle); return 0; } ACE_FAIL_RETURN (-1); /* NOTREACHED */ # elif defined (ACE_PSOS) ACE_UNUSED_ARG (thr_handle); ACE_UNUSED_ARG (status); ACE_NOTSUP_RETURN (-1); # else ACE_UNUSED_ARG (thr_handle); ACE_UNUSED_ARG (status); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (thr_handle); ACE_UNUSED_ARG (status); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_key_detach (  void *    inst )  [static]

Definition at line 3862 of file OS.cpp. References ACE_TSS_Cleanup::detach, ACE_TSS_Cleanup::instance, and ACE_TSS_Cleanup::lockable. Referenced by ACE_TSS::~ACE_TSS. { # if defined (ACE_WIN32) || defined (ACE_HAS_TSS_EMULATION) || (defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS)) if (ACE_TSS_Cleanup::lockable ()) return ACE_TSS_Cleanup::instance()->detach (inst); else // We're in static constructor/destructor phase. Don't // try to use the ACE_TSS_Cleanup instance because its lock // might not have been constructed yet, or might have been // destroyed already. Just leak the key . . . return -1; # else ACE_UNUSED_ARG (inst); ACE_NOTSUP_RETURN (-1); # endif /* ACE_WIN32 || ACE_HAS_TSS_EMULATION */ }

int ACE_OS::thr_key_used (  ACE_thread_key_t    key )  [static]

Definition at line 3850 of file OS.cpp. References ACE_thread_key_t, ACE_TSS_Cleanup::instance, and ACE_TSS_Cleanup::key_used. { # if defined (ACE_WIN32) || defined (ACE_HAS_TSS_EMULATION) || (defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS)) ACE_TSS_Cleanup::instance ()->key_used (key); return 0; # else ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); # endif /* ACE_WIN32 || ACE_HAS_TSS_EMULATION || ACE_PSOS_HAS_TSS */ }

int ACE_OS::thr_keycreate (  ACE_thread_key_t *    key, ACE_THR_DEST   , void *    inst = 0 )  [static]

Definition at line 3761 of file OS.cpp. References ACE_ADAPT_RETVAL, ACE_SYSCALL_FAILED, ACE_thread_key_t, ACE_TSS_Cleanup::insert, ACE_TSS_Cleanup::instance, thr_keycreate, and unique_name. Referenced by ACE_Thread::keycreate, thr_keycreate, and ACE_TSS_Cleanup::tss_keys. { // ACE_OS_TRACE ("ACE_OS::thr_keycreate"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_TSS_EMULATION) if (ACE_TSS_Emulation::next_key (*key) == 0) { ACE_TSS_Emulation::tss_destructor (*key, dest); // Extract out the thread-specific table instance and stash away // the key and destructor so that we can free it up later on... return ACE_TSS_Cleanup::instance ()->insert (*key, dest, inst); } else { errno = EAGAIN; return -1; } # elif defined (ACE_HAS_PTHREADS) ACE_UNUSED_ARG (inst); # if defined (ACE_HAS_PTHREADS_DRAFT4) # if defined (ACE_HAS_STDARG_THR_DEST) ACE_OSCALL_RETURN (::pthread_keycreate (key, (void (*)(...)) dest), int, -1); # else /* ! ACE_HAS_STDARG_THR_DEST */ ACE_OSCALL_RETURN (::pthread_keycreate (key, dest), int, -1); # endif /* ! ACE_HAS_STDARG_THR_DEST */ # elif defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_key_create (key, dest), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_key_create (key, dest), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (inst); ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_keycreate (key, dest), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS) static u_long unique_name = 0; void *tsdanchor; ++unique_name; if (::tsd_create (ACE_reinterpret_cast (char *, &unique_name), 0, TSD_NOALLOC, (void ****) &tsdanchor, key) != 0) { return -1; } return ACE_TSS_Cleanup::instance ()->insert (*key, dest, inst); # elif defined (ACE_HAS_WTHREADS) *key = ::TlsAlloc (); if (*key != ACE_SYSCALL_FAILED) { // Extract out the thread-specific table instance and stash away // the key and destructor so that we can free it up later on... return ACE_TSS_Cleanup::instance ()->insert (*key, dest, inst); } else ACE_FAIL_RETURN (-1); /* NOTREACHED */ # else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (dest); ACE_UNUSED_ARG (inst); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_TSS_EMULATION */ # else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (dest); ACE_UNUSED_ARG (inst); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_keyfree (  ACE_thread_key_t    key )  [static]

Definition at line 3666 of file OS.cpp. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, ACE_thread_key_t, ACE_TSS_Cleanup::instance, and ACE_TSS_Cleanup::remove. Referenced by ACE_TSS_Cleanup::exit, ACE_TSS_Cleanup::free_all_keys_left, and ACE_Thread::keyfree. { ACE_OS_TRACE ("ACE_OS::thr_keyfree"); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_TSS_EMULATION) // Release the key in the TSS_Emulation administration ACE_TSS_Emulation::release_key (key); return ACE_TSS_Cleanup::instance ()->remove (key); # elif defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_PTHREADS) return ::pthread_key_delete (key); # elif defined (ACE_HAS_THR_KEYDELETE) return ::thr_keydelete (key); # elif defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_WTHREADS) // Extract out the thread-specific table instance and free up // the key and destructor. ACE_TSS_Cleanup::instance ()->remove (key); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::TlsFree (key), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS) // Extract out the thread-specific table instance and free up // the key and destructor. ACE_TSS_Cleanup::instance ()->remove (key); return (::tsd_delete (key) == 0) ? 0 : -1; # else ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_TSS_EMULATION */ # else ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_kill (  ACE_thread_t    thr_id, int    signum )  [static]

Definition at line 7187 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, ACE_thread_t, kill, and thr_kill. Referenced by ACE_Thread::kill, and thr_kill. { ACE_OS_TRACE ("ACE_OS::thr_kill"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined(ACE_LACKS_PTHREAD_KILL) ACE_UNUSED_ARG (signum); ACE_UNUSED_ARG (thr_id); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_kill (thr_id, signum), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_kill (thr_id, signum), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) || defined (ACE_PSOS) ACE_UNUSED_ARG (signum); ACE_UNUSED_ARG (thr_id); ACE_NOTSUP_RETURN (-1); # elif defined (VXWORKS) ACE_hthread_t tid; ACE_OSCALL (::taskNameToId (thr_id), int, ERROR, tid); if (tid == ERROR) return -1; else ACE_OSCALL_RETURN (::kill (tid, signum), int, -1); # else /* This should not happen! */ ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (signum); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (signum); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE size_t ACE_OS::thr_min_stack (  void    )  [static]

Definition at line 7232 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, sysconf, thr_min_stack, and thr_self. Referenced by thr_min_stack. { ACE_OS_TRACE ("ACE_OS::thr_min_stack"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) # if defined (ACE_HAS_THR_MINSTACK) // Tandem did some weirdo mangling of STHREAD names... ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_minstack (), ace_result_), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_min_stack (), ace_result_), int, -1); # endif /* !ACE_HAS_THR_MINSTACK */ # elif defined (ACE_HAS_PTHREADS) # if defined (_SC_THREAD_STACK_MIN) return (size_t) ACE_OS::sysconf (_SC_THREAD_STACK_MIN); # elif defined (PTHREAD_STACK_MIN) return PTHREAD_STACK_MIN; # else ACE_NOTSUP_RETURN (0); # endif /* _SC_THREAD_STACK_MIN */ # elif defined (ACE_HAS_WTHREADS) ACE_NOTSUP_RETURN (0); # elif defined (ACE_PSOS) // there does not appear to be a way to get the // task stack size except at task creation ACE_NOTSUP_RETURN (0); # elif defined (VXWORKS) TASK_DESC taskDesc; STATUS status; ACE_hthread_t tid; ACE_OS::thr_self (tid); ACE_OSCALL (ACE_ADAPT_RETVAL (::taskInfoGet (tid, &taskDesc), status), STATUS, -1, status); return status == OK ? taskDesc.td_stackSize : 0; # else /* Should not happen... */ ACE_NOTSUP_RETURN (0); # endif /* ACE_HAS_STHREADS */ #else ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE void ACE_OS::thr_self (  ACE_hthread_t &    )  [static]

Definition at line 2362 of file OS.i. References ACE_hthread_t, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::thr_self"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) // Note, don't use "::" here since the following call is often a macro. self = pthread_self (); # elif defined (ACE_HAS_THREAD_SELF) self = ::thread_self (); # elif defined (ACE_HAS_STHREADS) self = ::thr_self (); # elif defined (ACE_HAS_WTHREADS) self = ::GetCurrentThread (); # elif defined (ACE_PSOS) t_ident ((char *) 0, 0, &self); # elif defined (VXWORKS) self = ::taskIdSelf (); # endif /* ACE_HAS_STHREADS */ #else self = 1; // Might as well make it the main thread ;-) #endif /* ACE_HAS_THREADS */ }

ACE_INLINE ACE_thread_t ACE_OS::thr_self (  void    )  [static]

Definition at line 2386 of file OS.i. References thr_self. Referenced by ACE_Thread_Control::ACE_Thread_Control, ACE_Thread_Manager::check_state, ACE_Thread_Manager::exit, ACE_Thread_Control::insert, ACE_OS_Thread_Adapter::invoke, ACE_Thread_Adapter::invoke_i, recursive_mutex_cond_unlock, recursive_mutex_lock, recursive_mutex_trylock, recursive_mutex_unlock, sched_params, ACE_Thread::self, thr_create, thr_exit, thr_getspecific, thr_min_stack, thr_self, thr_setprio, thr_setspecific, ACE_Thread_Manager::thread_desc_self, ACE_Timeprobe::timeprobe, ACE_Object_Manager_Manager::~ACE_Object_Manager_Manager, and ACE_OS_Object_Manager_Manager::~ACE_OS_Object_Manager_Manager. { // ACE_OS_TRACE ("ACE_OS::thr_self"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) // Note, don't use "::" here since the following call is often a macro. ACE_OSCALL_RETURN (pthread_self (), int, -1); # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (::thr_self (), int, -1); # elif defined (ACE_HAS_WTHREADS) return ::GetCurrentThreadId (); # elif defined (ACE_PSOS) // there does not appear to be a way to get // a task's name other than at creation return 0; # elif defined (VXWORKS) return ::taskName (::taskIdSelf ()); # endif /* ACE_HAS_STHREADS */ #else return 1; // Might as well make it the first thread ;-) #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_setcancelstate (  int    new_state, int *    old_state )  [static]

Definition at line 6879 of file OS.i. References ACE_ADAPT_RETVAL, and ACE_OS_TRACE. Referenced by ACE_Thread::disablecancel, ACE_Thread::enablecancel, and ACE_Thread::setcancelstate. { ACE_OS_TRACE ("ACE_OS::thr_setcancelstate"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL) # if defined (ACE_HAS_PTHREADS_DRAFT4) int old; old = pthread_setcancel (new_state); if (old == -1) return -1; *old_state = old; return 0; # elif defined (ACE_HAS_PTHREADS_DRAFT6) ACE_UNUSED_ARG(old_state); ACE_OSCALL_RETURN (pthread_setintr (new_state), int, -1); # else /* this is draft 7 or std */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setcancelstate (new_state, old_state), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (new_state); ACE_UNUSED_ARG (old_state); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (new_state); ACE_UNUSED_ARG (old_state); ACE_NOTSUP_RETURN (-1); # else /* Could be ACE_HAS_PTHREADS && ACE_LACKS_PTHREAD_CANCEL */ ACE_UNUSED_ARG (new_state); ACE_UNUSED_ARG (old_state); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (new_state); ACE_UNUSED_ARG (old_state); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_setcanceltype (  int    new_type, int *    old_type )  [static]

Definition at line 6921 of file OS.i. References ACE_ADAPT_RETVAL, and ACE_OS_TRACE. Referenced by ACE_Thread::enablecancel, and ACE_Thread::setcancelstate. { ACE_OS_TRACE ("ACE_OS::thr_setcanceltype"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL) # if defined (ACE_HAS_PTHREADS_DRAFT4) int old; old = pthread_setasynccancel(new_type); if (old == -1) return -1; *old_type = old; return 0; # elif defined (ACE_HAS_PTHREADS_DRAFT6) ACE_UNUSED_ARG(old_type); ACE_OSCALL_RETURN (pthread_setintrtype (new_type), int, -1); # else /* this is draft 7 or std */ ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setcanceltype (new_type, old_type), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # else /* Could be ACE_HAS_PTHREADS && ACE_LACKS_PTHREAD_CANCEL */ ACE_UNUSED_ARG (new_type); ACE_UNUSED_ARG (old_type); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (new_type); ACE_UNUSED_ARG (old_type); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_setconcurrency (  int    hint )  [static]

Definition at line 7281 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and thr_setconcurrency. Referenced by ACE_Thread::setconcurrency, thr_create, and thr_setconcurrency. { ACE_OS_TRACE ("ACE_OS::thr_setconcurrency"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setconcurrency (hint), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) ACE_UNUSED_ARG (hint); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (hint); ACE_NOTSUP_RETURN (-1); # elif defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (hint); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (hint); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_setprio (  const ACE_Sched_Priority    prio )  [static]

Definition at line 1394 of file OS.cpp. References ACE_hthread_t, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_Sched_Priority, ACE_SCHED_RR, lwp_getparams, lwp_setparams, ACE_Sched_Params::policy, ACE_Sched_Params::priority, sched_params, thr_self, and thr_setprio. { // Set the thread priority on the current thread. ACE_hthread_t my_thread_id; ACE_OS::thr_self (my_thread_id); int status = ACE_OS::thr_setprio (my_thread_id, prio); # if defined (ACE_NEEDS_LWP_PRIO_SET) // If the thread is in the RT class, then set the priority on its // LWP. (Instead of doing this if the thread is in the RT class, it // should be done for all bound threads. But, there doesn't appear // to be an easy way to determine if the thread is bound.) if (status == 0) { // Find what scheduling class the thread's LWP is in. ACE_Sched_Params sched_params (ACE_SCHED_OTHER, 0); if (ACE_OS::lwp_getparams (sched_params) == -1) { return -1; } else if (sched_params.policy () == ACE_SCHED_FIFO || sched_params.policy () == ACE_SCHED_RR) { // This thread's LWP is in the RT class, so we need to set // its priority. sched_params.priority (prio); return ACE_OS::lwp_setparams (sched_params); } // else this is not an RT thread. Nothing more needs to be // done. } # endif /* ACE_NEEDS_LWP_PRIO_SET */ return status; }

ACE_INLINE int ACE_OS::thr_setprio (  ACE_hthread_t    id, int    priority, int    policy = -1 )  [static]

Definition at line 7307 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, ACE_OS_String::memset, and thr_setprio. Referenced by ACE_OS_Thread_Adapter::invoke, ACE_Thread_Adapter::invoke_i, sched_params, ACE_Thread::setprio, thr_create, and thr_setprio. { ACE_OS_TRACE ("ACE_OS::thr_setprio"); ACE_UNUSED_ARG (policy); #if defined (ACE_HAS_THREADS) # if (defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_SETSCHED)) # if defined (ACE_HAS_PTHREADS_DRAFT4) int result; result = ::pthread_setprio (id, priority); return (result == -1 ? -1 : 0); # elif defined (ACE_HAS_PTHREADS_DRAFT6) pthread_attr_t attr; if (pthread_getschedattr (id, &attr) == -1) return -1; if (pthread_attr_setprio (attr, priority) == -1) return -1; return pthread_setschedattr (id, attr); # else int result; struct sched_param param; memset ((void *) &param, 0, sizeof param); // If <policy> is -1, we don't want to use it for // pthread_setschedparam(). Instead, obtain policy from // pthread_getschedparam(). if (policy == -1) { ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_getschedparam (id, &policy, &param), result), int, -1, result); if (result == -1) return result; } param.sched_priority = priority; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setschedparam (id, policy, &param), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setprio (id, priority), ace_result_), int, -1); # elif defined (ACE_HAS_WTHREADS) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetThreadPriority (id, priority), ace_result_), int, -1); # elif defined (ACE_PSOS) u_long oldpriority; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::t_setpri (id, priority, &oldpriority), ace_result_), int, -1); # elif defined (VXWORKS) ACE_OSCALL_RETURN (::taskPrioritySet (id, priority), int, -1); # else // For example, platforms that support Pthreads but LACK_SETSCHED. ACE_UNUSED_ARG (id); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (id); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_setspecific (  ACE_thread_key_t    key, void *    data )  [static]

Definition at line 3600 of file OS.cpp. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_KEY_INDEX, ACE_thread_key_t, ACE_TSS_Cleanup::instance, ACE_TSS_Cleanup::key_used, thr_self, and thr_setspecific. Referenced by ACE_Thread::setspecific, thr_setspecific, and ACE_TSS_Cleanup::tss_keys. { // ACE_OS_TRACE ("ACE_OS::thr_setspecific"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_TSS_EMULATION) ACE_KEY_INDEX (key_index, key); if (key_index >= ACE_TSS_Emulation::total_keys ()) { errno = EINVAL; data = 0; return -1; } else { ACE_TSS_Emulation::ts_object (key) = data; ACE_TSS_Cleanup::instance ()->key_used (key); return 0; } # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_FSU_PTHREADS) // Call pthread_init() here to initialize threads package. FSU // threads need an initialization before the first thread constructor. // This seems to be the one; however, a segmentation fault may // indicate that another pthread_init() is necessary, perhaps in // Synch.cpp or Synch_T.cpp. FSU threads will not reinit if called // more than once, so another call to pthread_init will not adversely // affect existing threads. pthread_init (); # endif /* ACE_HAS_FSU_PTHREADS */ # if defined (ACE_HAS_PTHREADS_DRAFT4) || defined (ACE_HAS_PTHREADS_DRAFT6) ACE_OSCALL_RETURN (::pthread_setspecific (key, data), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setspecific (key, data), ace_result_), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4, 6 */ # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setspecific (key, data), ace_result_), int, -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_TSS) ACE_hthread_t tid; ACE_OS::thr_self (tid); if (::tsd_setval (key, tid, data) != 0) return -1; ACE_TSS_Cleanup::instance ()->key_used (key); return 0; # elif defined (ACE_HAS_WTHREADS) ::TlsSetValue (key, data); ACE_TSS_Cleanup::instance ()->key_used (key); return 0; # else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (data); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ # else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (data); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_sigsetmask (  int    how, const sigset_t *    nsm, sigset_t *    osm )  [static]

Definition at line 7104 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, pthread_sigmask, SIG_BLOCK, SIG_SETMASK, SIG_UNBLOCK, sigprocmask, and thr_sigsetmask. Referenced by ACE_Sig_Guard::ACE_Sig_Guard, ACE_Thread::sigsetmask, thr_sigsetmask, and ACE_Sig_Guard::~ACE_Sig_Guard. { ACE_OS_TRACE ("ACE_OS::thr_sigsetmask"); #if defined (ACE_HAS_THREADS) # if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK) // DCE threads and Solaris 2.4 have no such function. ACE_UNUSED_ARG (osm); ACE_UNUSED_ARG (nsm); ACE_UNUSED_ARG (how); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_SIGTHREADMASK) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sigthreadmask (how, nsm, osm), ace_result_), int, -1); # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_sigsetmask (how, nsm, osm), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (AIX) ACE_OSCALL_RETURN (sigthreadmask (how, nsm, osm), int, -1); // Draft 4 and 6 implementations will sometimes have a sigprocmask () that // modifies the calling thread's mask only. If this is not so for your // platform, define ACE_LACKS_PTHREAD_THR_SIGSETMASK. # elif defined(ACE_HAS_PTHREADS_DRAFT4) || \ defined (ACE_HAS_PTHREADS_DRAFT6) || (defined (_UNICOS) && _UNICOS == 9) ACE_OSCALL_RETURN (::sigprocmask (how, nsm, osm), int, -1); # elif !defined (ACE_LACKS_PTHREAD_SIGMASK) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsm, osm), ace_result_), int, -1); # endif /* AIX */ #if 0 /* Don't know if anyt platform actually needs this... */ // as far as I can tell, this is now pthread_sigaction() -- jwr ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigaction (how, nsm, osm), ace_result_), int, -1); #endif /* 0 */ # elif defined (ACE_HAS_WTHREADS) || defined (ACE_PSOS) ACE_UNUSED_ARG (osm); ACE_UNUSED_ARG (nsm); ACE_UNUSED_ARG (how); ACE_NOTSUP_RETURN (-1); # elif defined (VXWORKS) switch (how) { case SIG_BLOCK: case SIG_UNBLOCK: { // get the old mask *osm = ::sigsetmask (*nsm); // create a new mask: the following assumes that sigset_t is 4 bytes, // which it is on VxWorks 5.2, so bit operations are done simply . . . ::sigsetmask (how == SIG_BLOCK ? (*osm |= *nsm) : (*osm &= ~*nsm)); break; } case SIG_SETMASK: *osm = ::sigsetmask (*nsm); break; default: return -1; } return 0; # else /* Should not happen. */ ACE_UNUSED_ARG (how); ACE_UNUSED_ARG (nsm); ACE_UNUSED_ARG (osm); ACE_NOTSUP_RETURN (-1); # endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */ #else ACE_UNUSED_ARG (how); ACE_UNUSED_ARG (nsm); ACE_UNUSED_ARG (osm); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_suspend (  ACE_hthread_t    target_thread )  [static]

Definition at line 7377 of file OS.i. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_OS_TRACE, ACE_SYSCALL_FAILED, and thr_suspend. Referenced by ACE_Thread::suspend, and thr_suspend. { ACE_OS_TRACE ("ACE_OS::thr_suspend"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_suspend (target_thread), ace_result_), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREAD_SUSPEND) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_suspend (target_thread), ace_result_), int, -1); # else ACE_UNUSED_ARG (target_thread); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREAD_SUSPEND */ # elif defined (ACE_HAS_WTHREADS) if (::SuspendThread (target_thread) != ACE_SYSCALL_FAILED) return 0; else ACE_FAIL_RETURN (-1); /* NOTREACHED */ # elif defined (ACE_PSOS) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::t_suspend (target_thread), ace_result_), int, -1); # elif defined (VXWORKS) ACE_OSCALL_RETURN (::taskSuspend (target_thread), int, -1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (target_thread); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE void ACE_OS::thr_testcancel (  void    )  [static]

Definition at line 7083 of file OS.i. References ACE_OS_TRACE. Referenced by ACE_Thread::testcancel. { ACE_OS_TRACE ("ACE_OS::thr_testcancel"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL) #if defined(ACE_HAS_PTHREADS_DRAFT6) ::pthread_testintr (); #else /* ACE_HAS_PTHREADS_DRAFT6 */ ::pthread_testcancel (); #endif /* !ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) # elif defined (ACE_HAS_WTHREADS) # elif defined (VXWORKS) || defined (ACE_PSOS) # else // no-op: can't use ACE_NOTSUP_RETURN because there is no return value # endif /* ACE_HAS_PTHREADS */ #else #endif /* ACE_HAS_THREADS */ }

ACE_INLINE void ACE_OS::thr_yield (  void    )  [static]

Definition at line 7410 of file OS.i. References ACE_OS_TRACE. Referenced by ACE_Condition::remove, and ACE_Thread::yield. { ACE_OS_TRACE ("ACE_OS::thr_yield"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREADS_STD) // Note - this is a POSIX.4 function - not a POSIX.1c function... ::sched_yield (); # elif defined (ACE_HAS_PTHREADS_DRAFT6) ::pthread_yield (0); # else /* Draft 4 and 7 */ ::pthread_yield (); # endif /* ACE_HAS_PTHREADS_STD */ # elif defined (ACE_HAS_STHREADS) ::thr_yield (); # elif defined (ACE_HAS_WTHREADS) ::Sleep (0); # elif defined (VXWORKS) // An argument of 0 to ::taskDelay doesn't appear to yield the // current thread. // Now, it does seem to work. The context_switch_time test // works fine with task_delay set to 0. ::taskDelay (0); # endif /* ACE_HAS_STHREADS */ #else ; #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thread_mutex_destroy (  ACE_thread_mutex_t *    m )  [static]

Definition at line 1828 of file OS.i. References ACE_OS_TRACE, and mutex_destroy. Referenced by ACE_OS_Object_Manager::fini, mutex_destroy, recursive_mutex_destroy, sema_destroy, and sema_init. { ACE_OS_TRACE ("ACE_OS::thread_mutex_destroy"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_WTHREADS) ::DeleteCriticalSection (m); return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) return ACE_OS::mutex_destroy (m); # elif defined (VXWORKS) || defined (ACE_PSOS) return mutex_destroy (m); # endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thread_mutex_init (  ACE_thread_mutex_t *    m, int    type, const wchar_t *    name, ACE_mutexattr_t *    arg = 0 )  [static]

ACE_INLINE int ACE_OS::thread_mutex_init (  ACE_thread_mutex_t *    m, int    type = ACE_DEFAULT_SYNCH_TYPE, const char *    name = 0, ACE_mutexattr_t *    arg = 0 )  [static]

Definition at line 1756 of file OS.i. References mutex_init. Referenced by ACE_Thread_Mutex::ACE_Thread_Mutex, ACE_OS_Object_Manager::init, mutex_init, recursive_mutex_init, and sema_init. { // ACE_OS_TRACE ("ACE_OS::thread_mutex_init"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ::InitializeCriticalSection (m); return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) ACE_UNUSED_ARG (type); // Force the use of USYNC_THREAD! return ACE_OS::mutex_init (m, USYNC_THREAD, name, arg); # elif defined (VXWORKS) || defined (ACE_PSOS) return mutex_init (m, type, name, arg); # endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thread_mutex_lock (  ACE_thread_mutex_t *    m, const ACE_Time_Value *    timeout )  [static]

Definition at line 1898 of file OS.i. References thread_mutex_lock. { return timeout == 0 ? ACE_OS::thread_mutex_lock (m) : ACE_OS::thread_mutex_lock (m, *timeout); }

ACE_INLINE int ACE_OS::thread_mutex_lock (  ACE_thread_mutex_t *    m, const ACE_Time_Value &    timeout )  [static]

Definition at line 1871 of file OS.i. References mutex_lock. { // ACE_OS_TRACE ("ACE_OS::thread_mutex_lock"); // For all platforms, except MS Windows, this method is equivalent // to calling ACE_OS::mutex_lock() since ACE_thread_mutex_t and // ACE_mutex_t are the same type. However, those typedefs evaluate // to different types on MS Windows. The "thread mutex" // implementation in ACE for MS Windows cannot readily support // timeouts due to a lack of timeout features for this type of MS // Windows synchronization mechanism. #if defined (ACE_HAS_THREADS) && !defined (ACE_HAS_WTHREADS) # if defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) return ACE_OS::mutex_lock (m, timeout); #elif defined (VXWORKS) || defined (ACE_PSOS) return mutex_lock (m, timeout); #endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (timeout); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thread_mutex_lock (  ACE_thread_mutex_t *    m )  [static]

Definition at line 1852 of file OS.i. References mutex_lock. Referenced by ACE_Log_Msg::close, ACE_Log_Msg::instance, mutex_lock, open, recursive_mutex_cond_unlock, recursive_mutex_lock, recursive_mutex_trylock, recursive_mutex_unlock, sema_init, sema_post, sema_trywait, sema_wait, and thread_mutex_lock. { // ACE_OS_TRACE ("ACE_OS::thread_mutex_lock"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_WTHREADS) ::EnterCriticalSection (m); return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) return ACE_OS::mutex_lock (m); # elif defined (VXWORKS) || defined (ACE_PSOS) return mutex_lock (m); # endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thread_mutex_trylock (  ACE_thread_mutex_t *    m )  [static]

Definition at line 1907 of file OS.i. References ACE_OS_TRACE, EBUSY, and mutex_trylock. Referenced by mutex_trylock, and recursive_mutex_trylock. { ACE_OS_TRACE ("ACE_OS::thread_mutex_trylock"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_WTHREADS) # if defined (ACE_HAS_WIN32_TRYLOCK) BOOL result = ::TryEnterCriticalSection (m); if (result == TRUE) return 0; else { errno = EBUSY; return -1; } # else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_WIN32_TRYLOCK */ # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) return ACE_OS::mutex_trylock (m); # elif defined (VXWORKS) || defined (ACE_PSOS) return ACE_OS::mutex_trylock (m); #endif /* Threads variety case */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thread_mutex_unlock (  ACE_thread_mutex_t *    m )  [static]

Definition at line 1939 of file OS.i. References ACE_OS_TRACE, and mutex_unlock. Referenced by ACE_Log_Msg::close, ACE_Log_Msg::instance, mutex_unlock, open, recursive_mutex_cond_relock, recursive_mutex_cond_unlock, recursive_mutex_lock, recursive_mutex_trylock, recursive_mutex_unlock, sema_init, sema_post, sema_trywait, and sema_wait. { ACE_OS_TRACE ("ACE_OS::thread_mutex_unlock"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_WTHREADS) ::LeaveCriticalSection (m); return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) return ACE_OS::mutex_unlock (m); # elif defined (VXWORKS) || defined (ACE_PSOS) return ACE_OS::mutex_unlock (m); # endif /* Threads variety case */ #else ACE_UNUSED_ARG (m); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE time_t ACE_OS::time (  time_t *    tloc = 0 )  [static]

Definition at line 735 of file OS.i. References ACE_OS_TRACE, gettimeofday, ACE_Time_Value::sec, and time. Referenced by ACE_System_Time::get_local_system_time, ACE_Service_Config::reconfigure, and time. { #if !defined (ACE_HAS_WINCE) ACE_OS_TRACE ("ACE_OS::time"); # if defined (ACE_PSOS) && ! defined (ACE_PSOS_HAS_TIME) unsigned long d_date, d_time, d_tick; tm_get(&d_date, &d_time, &d_tick); // get current time if (tloc) *tloc = d_time; // set time as time_t return d_time; # else ACE_OSCALL_RETURN (::time (tloc), time_t, (time_t) -1); # endif /* ACE_PSOS && ! ACE_PSOS_HAS_TIME */ #else time_t retv = ACE_OS::gettimeofday ().sec (); if (tloc) *tloc = retv; return retv; #endif /* ACE_HAS_WINCE */ }

ACE_INLINE long ACE_OS::timezone (  void    )  [static]

Definition at line 8667 of file OS.i. References ace_timezone. { return ::ace_timezone (); }

ACE_INLINE int ACE_OS::truncate (  const ACE_TCHAR *    filename, off_t    length )  [static]

Definition at line 5754 of file OS.i. References ACE_ADAPT_RETVAL, ACE_DEFAULT_FILE_PERMS, ACE_OS_TRACE, ACE_TCHAR, open, and truncate. Referenced by truncate. { ACE_OS_TRACE ("ACE_OS::truncate"); #if defined (ACE_WIN32) ACE_HANDLE handle = ACE_OS::open (filename, O_WRONLY, ACE_DEFAULT_FILE_PERMS); if (handle == ACE_INVALID_HANDLE) ACE_FAIL_RETURN (-1); else if (::SetFilePointer (handle, offset, 0, FILE_BEGIN) != (unsigned) -1) { BOOL result = ::SetEndOfFile (handle); ::CloseHandle (handle); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (result, ace_result_), int, -1); } else { ::CloseHandle (handle); ACE_FAIL_RETURN (-1); } /* NOTREACHED */ #elif !defined (ACE_LACKS_TRUNCATE) ACE_OSCALL_RETURN (::truncate (filename, offset), int, -1); #else ACE_UNUSED_ARG (filename); ACE_UNUSED_ARG (offset); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE void ACE_OS::tzset (  void    )  [static]

Definition at line 8653 of file OS.i. References ENOTSUP. { #if !defined (ACE_HAS_WINCE) && !defined (VXWORKS) && !defined (ACE_PSOS) && ! defined(__rtems__) # if defined (ACE_WIN32) ::_tzset (); // For Win32. # else ::tzset (); // For UNIX platforms. # endif /* ACE_WIN32 */ # else errno = ENOTSUP; # endif /* ACE_HAS_WINCE && !VXWORKS && !ACE_PSOS && !__rtems__ */ }

ACE_INLINE u_int ACE_OS::ualarm (  const ACE_Time_Value &    tv, const ACE_Time_Value &    tv_interval = ACE_Time_Value::zero )  [static]

Definition at line 7931 of file OS.i. References ACE_ONE_SECOND_IN_USECS, ACE_OS_TRACE, ACE_Time_Value::sec, and ACE_Time_Value::usec. { ACE_OS_TRACE ("ACE_OS::ualarm"); #if defined (ACE_HAS_UALARM) u_int usecs = (tv.sec () * ACE_ONE_SECOND_IN_USECS) + tv.usec (); u_int interval = (tv_interval.sec () * ACE_ONE_SECOND_IN_USECS) + tv_interval.usec (); return ::ualarm (usecs, interval); #elif !defined (ACE_LACKS_UNIX_SIGNALS) ACE_UNUSED_ARG (tv_interval); return ::alarm (tv.sec ()); #else ACE_UNUSED_ARG (tv_interval); ACE_UNUSED_ARG (tv); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_UALARM */ }

ACE_INLINE u_int ACE_OS::ualarm (  u_int    usecs, u_int    interval = 0 )  [static]

Definition at line 7914 of file OS.i. References ACE_ONE_SECOND_IN_USECS, and ACE_OS_TRACE. Referenced by ACE_Async_Timer_Queue_Adapter::schedule_ualarm. { ACE_OS_TRACE ("ACE_OS::ualarm"); #if defined (ACE_HAS_UALARM) return ::ualarm (usecs, interval); #elif !defined (ACE_LACKS_UNIX_SIGNALS) ACE_UNUSED_ARG (interval); return ::alarm (usecs * ACE_ONE_SECOND_IN_USECS); #else ACE_UNUSED_ARG (usecs); ACE_UNUSED_ARG (interval); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_UALARM */ }

u_int ACE_OS::ualarm_i (  const ACE_Time_Value &    tv, const ACE_Time_Value &    tv_interval = ACE_Time_Value::zero )  [static, private]

u_int ACE_OS::ualarm_i (  u_int    usecs, u_int    interval = 0 )  [static, private]

ACE_INLINE mode_t ACE_OS::umask (  mode_t    cmask )  [static]

Definition at line 451 of file OS.i. References ACE_OS_TRACE, and mode_t. Referenced by ACE::daemonize. { ACE_OS_TRACE ("ACE_OS::umask"); # if defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (cmask); ACE_NOTSUP_RETURN (-1); # else return ::umask (cmask); // This call shouldn't fail... # endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE int ACE_OS::uname (  ACE_utsname *    name )  [static]

Definition at line 462 of file OS.cpp. References ACE_LIB_TEXT, ACE_OS_TRACE, ACE_TCHAR, ACE_utsname, hostname, sprintf, ACE_OS_String::strcat, and ACE_OS_String::strcpy. { ACE_OS_TRACE ("ACE_OS::uname"); # if defined (ACE_WIN32) size_t maxnamelen = sizeof name->nodename; ACE_OS::strcpy (name->sysname, ACE_LIB_TEXT ("Win32")); OSVERSIONINFO vinfo; vinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); ::GetVersionEx (&vinfo); SYSTEM_INFO sinfo; # if defined (ACE_HAS_PHARLAP) // PharLap doesn't do GetSystemInfo. What's really wanted is the // CPU architecture, so we can get that with EtsGetSystemInfo. Fill // in what's wanted in the SYSTEM_INFO structure, and carry on. Note // that the CPU type values in EK_KERNELINFO have the same values // are the ones defined for SYSTEM_INFO. EK_KERNELINFO ets_kern; EK_SYSTEMINFO ets_sys; EtsGetSystemInfo (&ets_kern, &ets_sys); sinfo.wProcessorLevel = ACE_static_cast (WORD, ets_kern.CpuType); sinfo.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL; sinfo.dwProcessorType = ets_kern.CpuType * 100 + 86; # else ::GetSystemInfo(&sinfo); ACE_OS::strcpy (name->sysname, ACE_LIB_TEXT ("Win32")); # endif /* ACE_HAS_PHARLAP */ const ACE_TCHAR* unknown = ACE_LIB_TEXT ("???"); if (vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT) { // Get information from the two structures ACE_OS::sprintf (name->release, # if defined (ACE_HAS_WINCE) ACE_LIB_TEXT ("Windows CE %d.%d"), # else ACE_LIB_TEXT ("Windows NT %d.%d"), # endif /* ACE_HAS_WINCE */ (int) vinfo.dwMajorVersion, (int) vinfo.dwMinorVersion); ACE_OS::sprintf (name->version, ACE_LIB_TEXT ("Build %d %s"), (int) vinfo.dwBuildNumber, vinfo.szCSDVersion); // We have to make sure that the size of (processor + subtype) // is not greater than the size of name->machine. So we give // half the space to the processor and half the space to // subtype. The -1 is necessary for because of the space // between processor and subtype in the machine name. const int bufsize = ((sizeof (name->machine) / sizeof (ACE_TCHAR)) / 2) - 1; ACE_TCHAR processor[bufsize] = ACE_LIB_TEXT ("Unknown"); ACE_TCHAR subtype[bufsize] = ACE_LIB_TEXT ("Unknown"); # if defined (ghs) WORD arch = sinfo.u.s.wProcessorArchitecture; # else WORD arch = sinfo.wProcessorArchitecture; # endif switch (arch) { case PROCESSOR_ARCHITECTURE_INTEL: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("Intel")); if (sinfo.wProcessorLevel == 3) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("80386")); else if (sinfo.wProcessorLevel == 4) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("80486")); else if (sinfo.wProcessorLevel == 5) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("Pentium")); else if (sinfo.wProcessorLevel == 6) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("Pentium Pro")); else if (sinfo.wProcessorLevel == 7) // I'm guessing here ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("Pentium II")); break; case PROCESSOR_ARCHITECTURE_MIPS: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("MIPS")); ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("R4000")); break; case PROCESSOR_ARCHITECTURE_ALPHA: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("Alpha")); ACE_OS::sprintf (subtype, ACE_LIB_TEXT ("%d"), sinfo.wProcessorLevel); break; case PROCESSOR_ARCHITECTURE_PPC: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("PPC")); if (sinfo.wProcessorLevel == 1) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("601")); else if (sinfo.wProcessorLevel == 3) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("603")); else if (sinfo.wProcessorLevel == 4) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("604")); else if (sinfo.wProcessorLevel == 6) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("603+")); else if (sinfo.wProcessorLevel == 9) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("804+")); else if (sinfo.wProcessorLevel == 20) ACE_OS::strcpy (subtype, ACE_LIB_TEXT ("620")); break; # if defined PROCESSOR_ARCHITECTURE_IA64 case PROCESSOR_ARCHITECTURE_IA64: ACE_OS_String::strcpy (processor, ACE_LIB_TEXT ("Itanium")); ACE_OS::sprintf (subtype, ACE_LIB_TEXT ("%d"), sinfo.wProcessorLevel); break; # endif case PROCESSOR_ARCHITECTURE_UNKNOWN: default: // @@ We could provide WinCE specific info here. But let's // defer that to some later point. ACE_OS::strcpy (processor, ACE_LIB_TEXT ("Unknown")); break; } ACE_OS::sprintf (name->machine, ACE_LIB_TEXT ("%s %s"), processor, subtype); } else if (vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) { if (vinfo.dwMajorVersion == 4 && vinfo.dwMinorVersion == 0) { ACE_OS::strcpy (name->release, ACE_LIB_TEXT ("Windows 95")); if (vinfo.szCSDVersion[1] == 'C') ACE_OS::strcat (name->release, ACE_LIB_TEXT (" OSR2")); } else if (vinfo.dwMajorVersion == 4 && vinfo.dwMinorVersion == 10) { ACE_OS::strcpy (name->release, ACE_LIB_TEXT ("Windows 98")); if (vinfo.szCSDVersion[1] == 'A') ACE_OS::strcat (name->release, ACE_LIB_TEXT (" SE")); } else if (vinfo.dwMajorVersion == 4 && vinfo.dwMinorVersion == 90) { ACE_OS::strcpy (name->release, ACE_LIB_TEXT ("Windows Me")); } else { ACE_OS::strcpy (name->release, unknown); } ACE_OS::sprintf (name->version, ACE_LIB_TEXT ("%d"), LOWORD (vinfo.dwBuildNumber)); if (sinfo.dwProcessorType == PROCESSOR_INTEL_386) ACE_OS::strcpy (name->machine, ACE_LIB_TEXT ("Intel 80386")); else if (sinfo.dwProcessorType == PROCESSOR_INTEL_486) ACE_OS::strcpy (name->machine, ACE_LIB_TEXT ("Intel 80486")); else if (sinfo.dwProcessorType == PROCESSOR_INTEL_PENTIUM) ACE_OS::strcpy (name->machine, ACE_LIB_TEXT ("Intel Pentium")); else ACE_OS::strcpy (name->machine, unknown); } else { // We don't know what this is! ACE_OS::strcpy (name->release, unknown); ACE_OS::strcpy (name->version, unknown); ACE_OS::strcpy (name->machine, unknown); } # if defined (ACE_LACKS_HOSTNAME) return 0; # else /* ACE_LACKS_HOSTNAME */ return ACE_OS::hostname (name->nodename, maxnamelen); # endif /* ACE_LACKS_HOSTNAME */ # elif defined (VXWORKS) size_t maxnamelen = sizeof name->nodename; ACE_OS::strcpy (name->sysname, "VxWorks"); ACE_OS::strcpy (name->release, "???"); ACE_OS::strcpy (name->version, sysBspRev ()); ACE_OS::strcpy (name->machine, sysModel ()); return ACE_OS::hostname (name->nodename, maxnamelen); # elif defined (CHORUS) size_t maxnamelen = sizeof name->nodename; ACE_OS::strcpy (name->sysname, "CHORUS/ClassiX"); ACE_OS::strcpy (name->release, "???"); ACE_OS::strcpy (name->version, "???"); ACE_OS::strcpy (name->machine, "???"); return ACE_OS::hostname (name->nodename, maxnamelen); #elif defined (ACE_PSOS) const unsigned long buflen(64); char buf[buflen]; unsigned long len; sys_info(PSOS_VERSION,(void *)buf,buflen,&len); ACE_OS::strcpy (name->sysname, "pSOS"); ACE_OS::strcpy (name->release, "???"); ACE_OS::strcpy (name->version, buf); ACE_OS::strcpy (name->machine, "PPC 405"); // a bit of a hack #endif /* ACE_WIN32 */ }

wint_t ACE_OS::ungetwc (  wint_t    c, FILE *    fp )  [static]

void ACE_OS::unique_name (  const void *    object, ACE_TCHAR *    name, size_t    length )  [static]

This method uses process id and object pointer to come up with a machine wide unique name. The process ID will provide uniqueness between processes on the same machine. The "this" pointer of the <object> will provide uniqueness between other "live" objects in the same process. The uniqueness of this name is therefore only valid for the life of <object>. Definition at line 3880 of file OS.cpp. References ACE_LIB_TEXT, ACE_TCHAR, ACE_UNIQUE_NAME_LEN, getpid, sprintf, and ACE_OS_String::strsncpy. Referenced by ACE_MEM_Acceptor::accept, ACE_DLL::set_handle, thr_keycreate, and ACE::unique_name. { // The process ID will provide uniqueness between processes on the // same machine. The "this" pointer of the <object> will provide // uniqueness between other "live" objects in the same process. The // uniqueness of this name is therefore only valid for the life of // <object>. ACE_TCHAR temp_name[ACE_UNIQUE_NAME_LEN]; ACE_OS::sprintf (temp_name, ACE_LIB_TEXT ("%p%d"), object, ACE_static_cast (int, ACE_OS::getpid ())); ACE_OS::strsncpy (name, temp_name, length); }

ACE_INLINE int ACE_OS::unlink (  const ACE_TCHAR *    path )  [static]

Definition at line 771 of file OS.i. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, ACE_TCHAR, and unlink. Referenced by ACE_MEM_Acceptor::accept, flock_destroy, ACE_Logging_Strategy::handle_timeout, ACE_Lib_Find::open_temp_file, ACE_Filecache_Object::release, ACE_SPIPE_Acceptor::remove, ACE_SPIPE::remove, ACE_Mem_Map::remove, ACE_LSOCK_Acceptor::remove, ACE_FILE::remove, ACE_FIFO::remove, shm_unlink, unlink, and ACE_FILE::unlink. { ACE_OS_TRACE ("ACE_OS::unlink"); # if defined (VXWORKS) ACE_OSCALL_RETURN (::unlink (ACE_const_cast (char *, path)), int, -1); # elif defined (ACE_PSOS) && ! defined (ACE_PSOS_LACKS_PHILE) ACE_OSCALL_RETURN (::remove_f ((char *) path), int , -1); # elif defined (ACE_PSOS) && defined (ACE_PSOS_HAS_C_LIBRARY) ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::remove ((char *) path), ace_result_), int, -1); # elif defined (ACE_HAS_WINCE) // @@ The problem is, DeleteFile is not actually equals to unlink. ;( ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFile (path), ace_result_), int, -1); # elif defined (ACE_LACKS_UNLINK) ACE_UNUSED_ARG (path); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wunlink (path), int, -1); # else ACE_OSCALL_RETURN (::unlink (path), int, -1); # endif /* VXWORKS */ }

int ACE_OS::vsprintf (  wchar_t *    buffer, const wchar_t *    format, va_list    argptr )  [static]

ACE_INLINE int ACE_OS::vsprintf (  char *    buffer, const char *    format, va_list    argptr )  [static]

Definition at line 1054 of file OS.i. References ACE_SPRINTF_ADAPTER, and vsprintf. Referenced by ACE_Process_Options::command_line, ACE_Process_Options::setenv, sprintf, and vsprintf. { return ACE_SPRINTF_ADAPTER (::vsprintf (buffer, format, argptr)); }

ACE_INLINE pid_t ACE_OS::wait (  int *    = 0 )  [static]

Calls OS <wait> function, so it's only portable to UNIX/POSIX platforms. Definition at line 10092 of file OS.i. References ACE_OS_TRACE, pid_t, and wait. { ACE_OS_TRACE ("ACE_OS::wait"); #if defined (ACE_WIN32) || defined (VXWORKS) || defined(CHORUS) || defined (ACE_PSOS) ACE_UNUSED_ARG (status); ACE_NOTSUP_RETURN (0); #else # if defined (ACE_HAS_UNION_WAIT) ACE_OSCALL_RETURN (::wait ((union wait *) status), pid_t, -1); # else ACE_OSCALL_RETURN (::wait (status), pid_t, -1); # endif /* ACE_HAS_UNION_WAIT */ #endif /* ACE_WIN32 || VXWORKS || CHORUS || ACE_PSOS */ }

ACE_INLINE pid_t ACE_OS::wait (  pid_t    pid, ACE_exitcode *    status, int    wait_options = 0, ACE_HANDLE    handle = 0 )  [static]

Calls <WaitForSingleObject> on Win32 and <ACE::waitpid> otherwise. Returns the passed in <pid_t> on success and -1 on failure. On Win32, <pid> is ignored if the <handle> is not equal to 0. Passing the process <handle> is prefer on Win32 because using <pid> to wait on the project doesn't always work correctly if the waited process has already terminated. Definition at line 10079 of file OS.i. References ACE_exitcode, ACE_OS_TRACE, pid_t, and waitpid. Referenced by sleep, ACE_Process::wait, and wait. { ACE_OS_TRACE ("ACE_OS::wait"); return ACE_OS::waitpid (pid, status, wait_options, handle); }

ACE_INLINE pid_t ACE_OS::waitpid (  pid_t    pid, ACE_exitcode *    status = 0, int    wait_options = 0, ACE_HANDLE    handle = 0 )  [static]

Calls <waitpid> on UNIX/POSIX platforms and <await> on Chorus. Does not work on Vxworks, or pSoS. On Win32, <pid> is ignored if the <handle> is not equal to 0. Passing the process <handle> is prefer on Win32 because using <pid> to wait on the project doesn't always work correctly if the waited process has already terminated. Definition at line 10007 of file OS.i. References ACE_BIT_ENABLED, ACE_exitcode, ACE_OS_TRACE, ETIME, pid_t, set_errno_to_last_error, waitpid, and WNOHANG. Referenced by ACE::fork, ACE_Process_Manager::wait, ACE_Process::wait, wait, and waitpid. { ACE_OS_TRACE ("ACE_OS::waitpid"); #if defined (VXWORKS) || defined (ACE_PSOS) ACE_UNUSED_ARG (pid); ACE_UNUSED_ARG (status); ACE_UNUSED_ARG (wait_options); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) int blocking_period = ACE_BIT_ENABLED (wait_options, WNOHANG) ? 0 /* don't hang */ : INFINITE; ACE_HANDLE phandle = handle; if (phandle == 0) { phandle = ::OpenProcess (SYNCHRONIZE, FALSE, pid); if (phandle == 0) { ACE_OS::set_errno_to_last_error (); return -1; } } pid_t result = pid; // Don't try to get the process exit status if wait failed so we can // keep the original error code intact. switch (::WaitForSingleObject (phandle, blocking_period)) { case WAIT_OBJECT_0: if (status != 0) // The error status of <GetExitCodeProcess> is nonetheless // not tested because we don't know how to return the value. ::GetExitCodeProcess (phandle, status); break; case WAIT_TIMEOUT: errno = ETIME; result = 0; break; default: ACE_OS::set_errno_to_last_error (); result = -1; } if (handle == 0) ::CloseHandle (phandle); return result; #elif defined (CHORUS) ACE_UNUSED_ARG (status); ACE_UNUSED_ARG (wait_options); ACE_UNUSED_ARG (handle); ACE_OSCALL_RETURN (::await (&ACE_OS::actorcaps_[pid]), pid_t, -1); #else ACE_UNUSED_ARG (handle); ACE_OSCALL_RETURN (::waitpid (pid, status, wait_options), pid_t, -1); #endif /* VXWORKS || ACE_PSOS */ }

ACE_INLINE ssize_t ACE_OS::write (  ACE_HANDLE    handle, const void *    buf, size_t    nbyte, ACE_OVERLAPPED *    )  [static]

Definition at line 8222 of file OS.i. References ACE_OS_TRACE, ACE_OVERLAPPED, and write. { ACE_OS_TRACE ("ACE_OS::write"); overlapped = overlapped; #if defined (ACE_WIN32) DWORD bytes_written; // This is set to 0 byte WriteFile. DWORD short_nbyte = ACE_static_cast (DWORD, nbyte); if (::WriteFile (handle, buf, short_nbyte, &bytes_written, overlapped)) return (ssize_t) bytes_written; else return -1; #else return ACE_OS::write (handle, buf, nbyte); #endif /* ACE_WIN32 */ }

ACE_INLINE ssize_t ACE_OS::write (  ACE_HANDLE    handle, const void *    buf, size_t    nbyte )  [static]

Definition at line 8183 of file OS.i. References ACE_OS_TRACE, ssize_t, and write. Referenced by ACE_MMAP_Memory_Pool::commit_backing_store_name, ACE_UPIPE_Connector::connect, ACE_Dev_Poll_Reactor::mask_ops_i, ACE_High_Res_Timer::print_ave, ACE_High_Res_Timer::print_total, putmsg, pwrite, ACE_Dev_Poll_Reactor::register_handler_i, ACE_Filecache_Object::release, ACE_Dev_Poll_Reactor::resume_handler_i, ACE_SPIPE_Stream::send, ACE_SOCK_IO::send, ACE_FILE_IO::send, ACE_FIFO_Send::send, ACE_DEV_IO::send, ACE::send_i, ACE_Dev_Poll_Reactor::suspend_handler_i, ACE_Mem_Map::unmap, write, and write_n. { ACE_OS_TRACE ("ACE_OS::write"); #if defined (ACE_WIN32) DWORD bytes_written; // This is set to 0 byte WriteFile. // Strictly correctly, we should loop writing all the data if more // than a DWORD length can hold. DWORD short_nbyte = ACE_static_cast (DWORD, nbyte); if (::WriteFile (handle, buf, short_nbyte, &bytes_written, 0)) return (ssize_t) bytes_written; else ACE_FAIL_RETURN (-1); #elif defined (ACE_PSOS) # if defined (ACE_PSOS_LACKS_PHILE) ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (nbyte); ACE_NOTSUP_RETURN (-1); # else if(::write_f (handle, (void *) buf, nbyte) == 0) return (ssize_t) nbyte; else return -1; # endif /* defined (ACE_PSOS_LACKS_PHILE) */ #else # if defined (ACE_LACKS_POSIX_PROTOTYPES) ACE_OSCALL_RETURN (::write (handle, (const char *) buf, nbyte), ssize_t, -1); # elif defined (ACE_PSOS) ACE_OSCALL_RETURN (::write_f(handle, (void *) buf, nbyte), ssize_t, -1); # elif defined (ACE_HAS_CHARPTR_SOCKOPT) ACE_OSCALL_RETURN (::write (handle, (char *) buf, nbyte), ssize_t, -1); # else ACE_OSCALL_RETURN (::write (handle, buf, nbyte), ssize_t, -1); # endif /* ACE_LACKS_POSIX_PROTOTYPES */ #endif /* ACE_WIN32 */ }

ssize_t ACE_OS::write_n (  ACE_HANDLE    handle, const void *    buf, size_t    len, size_t *    bytes_transferred = 0 )  [static]

Send <len> bytes from <buf> to <handle> (uses the <ACE_OS::write> calls, which is uses the <write> system call on UNIX and the <WriteFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been transmitted will be returned to the caller through <bytes_transferred>. Definition at line 4205 of file OS.cpp. References ssize_t, and write. Referenced by ACE::write_n. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { n = ACE_OS::write (handle, (char *) buf + bytes_transferred, len - bytes_transferred); if (n == -1 || n == 0) return n; } return bytes_transferred; }

ACE_INLINE ssize_t ACE_OS::writev (  ACE_HANDLE    handle, const iovec *    iov, int    iovcnt )  [static]

Definition at line 7483 of file OS.i. References ACE_OS_TRACE, ACE_WRITEV_TYPE, and writev. Referenced by ACE_SPIPE_Stream::send, ACE_FILE_IO::send, ACE_FIFO_Send_Msg::send, ACE_DEV_IO::send, ACE_SPIPE_Stream::sendv, sendv, ACE_FILE_IO::sendv, writev, and ACE::writev_n. { ACE_OS_TRACE ("ACE_OS::writev"); #if defined (ACE_LACKS_WRITEV) ACE_OSCALL_RETURN (ACE_OS::writev_emulation (handle, (ACE_WRITEV_TYPE *) iov, iovcnt), int, -1); #else /* ACE_LACKS_WRITEV */ ACE_OSCALL_RETURN (::writev (handle, (ACE_WRITEV_TYPE *) iov, iovcnt), int, -1); #endif /* ACE_LACKS_WRITEV */ }

ACE_INLINE int ACE_OS::wscmp (  const WChar *   , const WChar *    )  [static]

Definition at line 10547 of file OS.i. References WChar. { const WChar *scan1 = s; const WChar *scan2 = t; while (*scan1 != 0 && *scan1 == *scan2) { ++scan1; ++scan2; } return *scan1 - *scan2; }

ACE_INLINE ACE_OS::WChar * ACE_OS::wscpy (  WChar *   , const WChar *    )  [static]

Definition at line 10536 of file OS.i. References WChar. { WChar *original_dest = dest; while ((*dest++ = *src++) != 0) continue; return original_dest; }

ACE_INLINE u_int ACE_OS::wslen (  const WChar *    )  [static]

Definition at line 10525 of file OS.i. Referenced by ACE_Log_Msg::log, operator<<, operator>>, and ACE_OutputCDR::write_wstring. { u_int len = 0; while (*s++ != 0) len++; return len; }

ACE_INLINE int ACE_OS::wsncmp (  const WChar *   , const WChar *   , size_t    len )  [static]

Definition at line 10562 of file OS.i. References WChar. { const WChar *scan1 = s; const WChar *scan2 = t; while (len != 0 && *scan1 != 0 && *scan1 == *scan2) { ++scan1; ++scan2; --len; } return len == 0 ? 0 : *scan1 - *scan2; }

---

Friends And Related Function Documentation

friend class ACE_OS_Object_Manager [friend]

Allow the ACE_OS_Object_Manager to call set_exit_hook. Definition at line 6064 of file OS.h.

friend class ACE_Timeout_Manager [friend]

Definition at line 4594 of file OS.h.

---

Member Data Documentation

ACE_EXIT_HOOK ACE_OS::exit_hook_ = 0 [static, private]

Function that is called by <ACE_OS::exit>, if non-null. Definition at line 249 of file OS.cpp. Referenced by set_exit_hook.

ACE_hthread_t ACE_OS::NULL_hthread [static]

This is necessary to deal with POSIX pthreads and their use of structures for thread handles. Definition at line 1586 of file OS.cpp. Referenced by ACE_Thread_Descriptor_Base::reset.

ACE_thread_key_t ACE_OS::NULL_key [static]

This is necessary to deal with POSIX pthreads and their use of structures for TSS keys. Definition at line 1590 of file OS.cpp. Referenced by ACE_TSS_Cleanup::exit, ACE_TSS_Cleanup::free_all_keys_left, ACE_TSS_Cleanup::remove, and ACE_TSS_Cleanup::tss_keys.

ACE_thread_t ACE_OS::NULL_thread [static]

This is necessary to deal with POSIX pthreads and their use of structures for thread ids. Definition at line 1585 of file OS.cpp. Referenced by ACE_Recursive_Thread_Mutex::get_thread_id, recursive_mutex_cond_unlock, recursive_mutex_init, recursive_mutex_unlock, ACE_Thread_Descriptor_Base::reset, and ACE_Token::wakeup_next_waiter.

int ACE_OS::socket_initialized_ [static]

Keeps track of whether we've already initialized WinSock... Definition at line 1604 of file OS.cpp. Referenced by socket_fini, and socket_init.

HINSTANCE ACE_OS::win32_resource_module_ [static, private]

Definition at line 6079 of file OS.h.

OSVERSIONINFO ACE_OS::win32_versioninfo_ [static, private]

Definition at line 6077 of file OS.h. Referenced by ACE_OS_Object_Manager::init.

---

The documentation for this class was generated from the following files:

• OS.h
• OS.cpp
• OS.i

---