ACE_OS Namespace Reference

This namespace 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...

Classes
struct	macaddr_node_t
class	ace_flock_t
	OS file locking structure. More...
Functions from <cctype>
Included are the functions defined in and their equivalents. Since they are often implemented as macros, we don't use the same name here. Instead, we change by prepending "ace_".
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isalnum (ACE_TCHAR c)
	Returns true if the character is an alphanumeric character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isalpha (ACE_TCHAR c)
	Returns true if the character is an alphabetic character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_iscntrl (ACE_TCHAR c)
	Returns true if the character is a control character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isdigit (ACE_TCHAR c)
	Returns true if the character is a decimal-digit character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isgraph (ACE_TCHAR c)
	Returns true if the character is a printable character other than a space.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_islower (ACE_TCHAR c)
	Returns true if the character is a lowercase character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isprint (ACE_TCHAR c)
	Returns true if the character is a printable character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_ispunct (ACE_TCHAR c)
	Returns true if the character is a punctuation character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isspace (ACE_TCHAR c)
	Returns true if the character is a space character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isupper (ACE_TCHAR c)
	Returns true if the character is an uppercase character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_isxdigit (ACE_TCHAR c)
	Returns true if the character is a hexadecimal-digit character.
ACE_NAMESPACE_INLINE_FUNCTION int	ace_tolower (int c)
	Converts a character to lower case (char version).
ACE_NAMESPACE_INLINE_FUNCTION wint_t	ace_towlower (wint_t c)
	Converts a character to lower case (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION int	ace_toupper (int c)
	Converts a character to upper case (char version).
ACE_NAMESPACE_INLINE_FUNCTION wint_t	ace_towupper (wint_t c)
	Converts a character to upper case (wchar_t version).
A set of wrappers for explicit dynamic linking.
ACE_NAMESPACE_INLINE_FUNCTION int	dlclose (ACE_SHLIB_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION ACE_TCHAR *	dlerror (void)
ACE_NAMESPACE_INLINE_FUNCTION ACE_SHLIB_HANDLE	dlopen (const ACE_TCHAR *filename, int mode=ACE_DEFAULT_SHLIB_MODE)
ACE_NAMESPACE_INLINE_FUNCTION void *	dlsym (ACE_SHLIB_HANDLE handle, const ACE_TCHAR *symbol)
A set of wrappers for password routines.
ACE_NAMESPACE_INLINE_FUNCTION void	endpwent (void)
ACE_NAMESPACE_INLINE_FUNCTION struct passwd *	getpwent (void)
ACE_NAMESPACE_INLINE_FUNCTION struct passwd *	getpwnam (const char *user)
ACE_NAMESPACE_INLINE_FUNCTION struct passwd *	getpwnam_r (const char *name, struct passwd *pwent, char *buffer, int buflen)
ACE_NAMESPACE_INLINE_FUNCTION void	setpwent (void)
A set of wrappers for regular expressions.
ACE_NAMESPACE_INLINE_FUNCTION char *	compile (const char *instring, char *expbuf, char *endbuf)
ACE_NAMESPACE_INLINE_FUNCTION int	step (const char *str, char *expbuf)
A set of wrappers for Signals.
ACE_NAMESPACE_INLINE_FUNCTION int	kill (pid_t pid, int signum)
ACE_NAMESPACE_INLINE_FUNCTION int	pthread_sigmask (int how, const sigset_t *nsp, sigset_t *osp)
ACE_NAMESPACE_INLINE_FUNCTION int	sigaction (int signum, const ACE_SIGACTION *nsa, ACE_SIGACTION *osa)
ACE_NAMESPACE_INLINE_FUNCTION int	sigaddset (sigset_t *s, int signum)
ACE_NAMESPACE_INLINE_FUNCTION int	sigdelset (sigset_t *s, int signum)
ACE_NAMESPACE_INLINE_FUNCTION int	sigemptyset (sigset_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	sigfillset (sigset_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	sigismember (sigset_t *s, int signum)
ACE_NAMESPACE_INLINE_FUNCTION ACE_SignalHandler	signal (int signum, ACE_SignalHandler)
ACE_NAMESPACE_INLINE_FUNCTION int	sigprocmask (int how, const sigset_t *nsp, sigset_t *osp)
ACE_NAMESPACE_INLINE_FUNCTION int	sigsuspend (const sigset_t *set)
Wrappers to obtain the current user id
ACE_NAMESPACE_INLINE_FUNCTION char *	cuserid (char *user, size_t maxlen=ACE_MAX_USERID)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	cuserid (wchar_t *user, size_t maxlen=ACE_MAX_USERID)
A set of wrappers for file locks.
ACE_NAMESPACE_INLINE_FUNCTION void	flock_adjust_params (ace_flock_t *lock, short whence, off_t &start, off_t &len)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_init (ace_flock_t *lock, int flags=0, const ACE_TCHAR *name=0, mode_t perms=0)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_destroy (ace_flock_t *lock, int unlink_file=1)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_rdlock (ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_tryrdlock (ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_trywrlock (ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_unlock (ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
ACE_NAMESPACE_INLINE_FUNCTION int	flock_wrlock (ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
Non-standard functions
These functions aren't in the standard.
ACE_NAMESPACE_INLINE_FUNCTION void	_exit (int status=0)
ACE_NAMESPACE_INLINE_FUNCTION void	abort (void)
ACE_NAMESPACE_INLINE_FUNCTION int	atexit (ACE_EXIT_HOOK func)
ACE_NAMESPACE_INLINE_FUNCTION int	atoi (const char *s)
ACE_NAMESPACE_INLINE_FUNCTION int	atoi (const wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION void *	atop (const char *s)
ACE_NAMESPACE_INLINE_FUNCTION void *	atop (const wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION void *	bsearch (const void *key, const void *base, size_t nel, size_t size, ACE_COMPARE_FUNC)
ACE_Export void *	calloc (size_t elements, size_t sizeof_elements)
ACE_Export void	exit (int status=0)
ACE_Export void	free (void *)
ACE_NAMESPACE_INLINE_FUNCTION char *	getenv (const char *symbol)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	getenv (const wchar_t *symbol)
ACE_Export ACE_TCHAR *	getenvstrings (void)
ACE_NAMESPACE_INLINE_FUNCTION char *	itoa (int value, char *string, int radix)
	Converts an integer to a string.
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	itoa (int value, wchar_t *string, int radix)
	Converts an integer to a string.
ACE_Export char *	itoa_emulation (int value, char *string, int radix)
	Emulated itoa - Converts an integer to a string.
ACE_Export wchar_t *	itow_emulation (int value, wchar_t *string, int radix)
	Emulated itow - Converts an integer to a string.
ACE_Export void *	malloc (size_t)
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	mkstemp (char *s)
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	mkstemp (wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION char *	mktemp (char *s)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	mktemp (wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	putenv (const char *string)
ACE_NAMESPACE_INLINE_FUNCTION int	putenv (const wchar_t *string)
ACE_NAMESPACE_INLINE_FUNCTION void	qsort (void *base, size_t nel, size_t width, ACE_COMPARE_FUNC)
ACE_NAMESPACE_INLINE_FUNCTION int	rand (void)
ACE_NAMESPACE_INLINE_FUNCTION int	rand_r (ACE_RANDR_TYPE &seed)
ACE_Export void *	realloc (void *, size_t)
ACE_NAMESPACE_INLINE_FUNCTION char *	realpath (const char *file_name, char *resolved_name)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	realpath (const wchar_t *file_name, wchar_t *resolved_name)
ACE_NAMESPACE_INLINE_FUNCTION ACE_EXIT_HOOK	set_exit_hook (ACE_EXIT_HOOK hook)
	For use by ACE_Object_Manager only, to register its exit hook..
ACE_NAMESPACE_INLINE_FUNCTION void	srand (u_int seed)
ACE_NAMESPACE_INLINE_FUNCTION ACE_TCHAR *	strenvdup (const ACE_TCHAR *str)
ACE_NAMESPACE_INLINE_FUNCTION double	strtod (const char *s, char **endptr)
	Converts a string to a double value (char version).
ACE_NAMESPACE_INLINE_FUNCTION double	strtod (const wchar_t *s, wchar_t **endptr)
	Converts a string to a double value (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION long	strtol (const char *s, char **ptr, int base)
	Converts a string to a long value (char version).
ACE_NAMESPACE_INLINE_FUNCTION long	strtol (const wchar_t *s, wchar_t **ptr, int base)
	Converts a string to a long value (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION unsigned long	strtoul (const char *s, char **ptr, int base)
	Converts a string to an unsigned long value (char version).
ACE_NAMESPACE_INLINE_FUNCTION unsigned long	strtoul (const wchar_t *s, wchar_t **ptr, int base)
	Converts a string to an unsigned long value (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION int	system (const ACE_TCHAR *s)
ACE_Export ACE_EXIT_HOOK	exit_hook_ = 0
	Function that is called by <ACE_OS::exit>, if non-null.
Functions from <cstring>
Included are the functions defined in and their equivalents. Todo: To be complete, we should add strcoll, and strxfrm.
ACE_NAMESPACE_INLINE_FUNCTION const void *	memchr (const void *s, int c, size_t len)
	Finds characters in a buffer (const void version).
ACE_NAMESPACE_INLINE_FUNCTION void *	memchr (void *s, int c, size_t len)
	Finds characters in a buffer (void version).
ACE_Export const void *	memchr_emulation (const void *s, int c, size_t len)
	Emulated memchr - Finds a character in a buffer.
ACE_NAMESPACE_INLINE_FUNCTION int	memcmp (const void *t, const void *s, size_t len)
	Compares two buffers.
ACE_NAMESPACE_INLINE_FUNCTION void *	memcpy (void *t, const void *s, size_t len)
	Copies one buffer to another.
ACE_NAMESPACE_INLINE_FUNCTION void *	memmove (void *t, const void *s, size_t len)
	Moves one buffer to another.
ACE_NAMESPACE_INLINE_FUNCTION void *	memset (void *s, int c, size_t len)
	Fills a buffer with a character value.
ACE_NAMESPACE_INLINE_FUNCTION char *	strcat (char *s, const char *t)
	Appends a string to another string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strcat (wchar_t *s, const wchar_t *t)
	Appends a string to another string (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION const char *	strchr (const char *s, int c)
ACE_NAMESPACE_INLINE_FUNCTION const wchar_t *	strchr (const wchar_t *s, wchar_t c)
ACE_NAMESPACE_INLINE_FUNCTION char *	strchr (char *s, int c)
	Finds the first occurance of a character in a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strchr (wchar_t *s, wchar_t c)
	Finds the first occurance of a character in a string (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION int	strcmp (const char *s, const char *t)
	Compares two strings (char version).
ACE_NAMESPACE_INLINE_FUNCTION int	strcmp (const ACE_WCHAR_T *s, const ACE_WCHAR_T *t)
	Compares two strings (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION char *	strcpy (char *s, const char *t)
	Copies a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strcpy (wchar_t *s, const wchar_t *t)
	Copies a string (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION size_t	strcspn (const char *s, const char *reject)
ACE_NAMESPACE_INLINE_FUNCTION size_t	strcspn (const wchar_t *s, const wchar_t *reject)
ACE_NAMESPACE_INLINE_FUNCTION char *	strdup (const char *s)
	Returns a malloced duplicated string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strdup (const wchar_t *s)
	Returns a malloced duplicated string (wchar_t version).
ACE_Export char *	strecpy (char *des, const char *src)
ACE_Export wchar_t *	strecpy (wchar_t *s, const wchar_t *t)
ACE_Export char *	strerror (int errnum)
	Finds characters in a buffer (const void version).
ACE_NAMESPACE_INLINE_FUNCTION size_t	strlen (const char *s)
	Finds the length of a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION size_t	strlen (const ACE_WCHAR_T *s)
	Finds the length of a string (ACE_WCHAR_T version).
ACE_NAMESPACE_INLINE_FUNCTION char *	strncat (char *s, const char *t, size_t len)
	Appends part of a string to another string (char version).
ACE_NAMESPACE_INLINE_FUNCTION ACE_WCHAR_T *	strncat (ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
	Appends part of a string to another string (wchar_t version).
ACE_Export const char *	strnchr (const char *s, int c, size_t len)
ACE_Export const ACE_WCHAR_T *	strnchr (const ACE_WCHAR_T *s, ACE_WCHAR_T c, size_t len)
ACE_NAMESPACE_INLINE_FUNCTION char *	strnchr (char *s, int c, size_t len)
	Finds the first occurance of a character in an array (char version).
ACE_NAMESPACE_INLINE_FUNCTION ACE_WCHAR_T *	strnchr (ACE_WCHAR_T *s, ACE_WCHAR_T c, size_t len)
	Finds the first occurance of a character in an array (ACE_WCHAR_T version).
ACE_NAMESPACE_INLINE_FUNCTION int	strncmp (const char *s, const char *t, size_t len)
	Compares two arrays (char version).
ACE_NAMESPACE_INLINE_FUNCTION int	strncmp (const ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
	Compares two arrays (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION char *	strncpy (char *s, const char *t, size_t len)
	Copies an array (char version).
ACE_NAMESPACE_INLINE_FUNCTION ACE_WCHAR_T *	strncpy (ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
	Copies an array (ACE_WCHAR_T version).
ACE_NAMESPACE_INLINE_FUNCTION size_t	strnlen (const char *s, size_t maxlen)
	Finds the length of a limited-length string (char version).
ACE_NAMESPACE_INLINE_FUNCTION size_t	strnlen (const ACE_WCHAR_T *s, size_t maxlen)
	Finds the length of a limited-length string (ACE_WCHAR_T version).
ACE_Export const char *	strnstr (const char *s, const char *t, size_t len)
ACE_Export const ACE_WCHAR_T *	strnstr (const ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
ACE_NAMESPACE_INLINE_FUNCTION char *	strnstr (char *s, const char *t, size_t len)
	Finds the first occurance of a substring in an array (char version).
ACE_NAMESPACE_INLINE_FUNCTION ACE_WCHAR_T *	strnstr (ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
	Finds the first occurance of a substring in an array (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION const char *	strpbrk (const char *s1, const char *s2)
	Searches for characters in a string (const char version).
ACE_NAMESPACE_INLINE_FUNCTION const wchar_t *	strpbrk (const wchar_t *s1, const wchar_t *s2)
	Searches for characters in a string (const wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION char *	strpbrk (char *s1, const char *s2)
	Searches for characters in a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strpbrk (wchar_t *s1, const wchar_t *s2)
	Searches for characters in a string (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION const char *	strrchr (const char *s, int c)
ACE_NAMESPACE_INLINE_FUNCTION const wchar_t *	strrchr (const wchar_t *s, wchar_t c)
ACE_NAMESPACE_INLINE_FUNCTION char *	strrchr (char *s, int c)
	Finds the last occurance of a character in a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strrchr (wchar_t *s, wchar_t c)
	Finds the last occurance of a character in a string (wchar_t version).
ACE_Export char *	strrchr_emulation (char *s, int c)
ACE_Export const char *	strrchr_emulation (const char *s, int c)
ACE_Export char *	strsncpy (char *dst, const char *src, size_t maxlen)
	This is a "safe" c string copy function (char version).
ACE_Export ACE_WCHAR_T *	strsncpy (ACE_WCHAR_T *dst, const ACE_WCHAR_T *src, size_t maxlen)
	This is a "safe" c string copy function (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION size_t	strspn (const char *s1, const char *s2)
ACE_NAMESPACE_INLINE_FUNCTION size_t	strspn (const wchar_t *s1, const wchar_t *s2)
ACE_NAMESPACE_INLINE_FUNCTION const char *	strstr (const char *s, const char *t)
ACE_NAMESPACE_INLINE_FUNCTION const wchar_t *	strstr (const wchar_t *s, const wchar_t *t)
ACE_NAMESPACE_INLINE_FUNCTION char *	strstr (char *s, const char *t)
	Finds the first occurance of a substring in a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strstr (wchar_t *s, const wchar_t *t)
	Finds the first occurance of a substring in a string (wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION char *	strtok (char *s, const char *tokens)
	Finds the next token in a string (char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strtok (wchar_t *s, const wchar_t *tokens)
	Finds the next token in a string (wchar_t version).
A set of wrappers for memory mapped files.
ACE_NAMESPACE_INLINE_FUNCTION int	madvise (caddr_t addr, size_t len, int map_advice)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION int	mprotect (void *addr, size_t len, int prot)
ACE_NAMESPACE_INLINE_FUNCTION int	msync (void *addr, size_t len, int sync)
ACE_NAMESPACE_INLINE_FUNCTION int	munmap (void *addr, size_t len)
A set of wrappers for System V message queues.
ACE_NAMESPACE_INLINE_FUNCTION int	msgctl (int msqid, int cmd, struct msqid_ds *)
ACE_NAMESPACE_INLINE_FUNCTION int	msgget (key_t key, int msgflg)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	msgrcv (int int_id, void *buf, size_t len, long type, int flags)
ACE_NAMESPACE_INLINE_FUNCTION int	msgsnd (int int_id, const void *buf, size_t len, int flags)
A set of wrappers for System V shared memory.
ACE_NAMESPACE_INLINE_FUNCTION void *	shmat (int int_id, const void *shmaddr, int shmflg)
ACE_NAMESPACE_INLINE_FUNCTION int	shmctl (int int_id, int cmd, struct shmid_ds *buf)
ACE_NAMESPACE_INLINE_FUNCTION int	shmdt (const void *shmaddr)
ACE_NAMESPACE_INLINE_FUNCTION int	shmget (key_t key, size_t size, int flags)
A set of wrappers for sockets.
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
	BSD-style (no QoS).
ACE_Export ACE_HANDLE	accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen, const ACE_Accept_QoS_Params &qos_params)
ACE_NAMESPACE_INLINE_FUNCTION int	bind (ACE_HANDLE s, struct sockaddr *name, int namelen)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION int	closesocket (ACE_HANDLE s)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION int	connect (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
	BSD-style (no QoS).
ACE_Export int	connect (ACE_HANDLE handle, const sockaddr *addr, int addrlen, const ACE_QoS_Params &qos_params)
ACE_NAMESPACE_INLINE_FUNCTION int	enum_protocols (int *protocols, ACE_Protocol_Info *protocol_buffer, u_long *buffer_length)
ACE_NAMESPACE_INLINE_FUNCTION int	getpeername (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION int	getsockname (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION int	getsockopt (ACE_HANDLE handle, int level, int optname, char *optval, int *optlen)
	BSD-style (no QoS).
ACE_Export 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.
ACE_NAMESPACE_INLINE_FUNCTION int	listen (ACE_HANDLE handle, int backlog)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recv (ACE_HANDLE handle, char *buf, size_t len, int flags=0)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recvfrom (ACE_HANDLE handle, char *buf, size_t len, int flags, struct sockaddr *addr, int *addrlen)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	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 (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recvv (ACE_HANDLE handle, iovec *iov, int iovlen)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	send (ACE_HANDLE handle, const char *buf, size_t len, int flags=0)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	sendto (ACE_HANDLE handle, const char *buf, size_t len, int flags, const struct sockaddr *addr, int addrlen)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	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 (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt)
	BSD-style (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION int	setsockopt (ACE_HANDLE handle, int level, int optname, const char *optval, int optlen)
	Manipulate the options associated with a socket.
ACE_NAMESPACE_INLINE_FUNCTION int	shutdown (ACE_HANDLE handle, int how)
	BSD-style (no QoS).
ACE_Export int	socket_init (int version_high=1, int version_low=1)
ACE_Export int	socket_fini (void)
	Finalize WinSock after last use (e.g., when a DLL is unloaded).
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	socket (int protocol_family, int type, int proto)
	Create a BSD-style socket (no QoS).
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	socket (int protocol_family, int type, int proto, ACE_Protocol_Info *protocolinfo, ACE_SOCK_GROUP g, u_long flags)
ACE_NAMESPACE_INLINE_FUNCTION int	socketpair (int domain, int type, int protocol, ACE_HANDLE sv[2])
	BSD-style (no QoS).
A set of wrappers for low-level file operations.
ACE_NAMESPACE_INLINE_FUNCTION ACE_LOFF_T	filesize (ACE_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION ACE_LOFF_T	filesize (const ACE_TCHAR *handle)
A set of wrappers for condition variables.
ACE_NAMESPACE_INLINE_FUNCTION int	condattr_init (ACE_condattr_t &attributes, int type=ACE_DEFAULT_SYNCH_TYPE)
ACE_NAMESPACE_INLINE_FUNCTION int	condattr_destroy (ACE_condattr_t &attributes)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_broadcast (ACE_cond_t *cv)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_destroy (ACE_cond_t *cv)
ACE_Export int	cond_init (ACE_cond_t *cv, short type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_init (ACE_cond_t *cv, ACE_condattr_t &attributes, const char *name=0, void *arg=0)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_init (ACE_cond_t *cv, short type, const wchar_t *name, void *arg=0)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_init (ACE_cond_t *cv, ACE_condattr_t &attributes, const wchar_t *name, void *arg=0)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_signal (ACE_cond_t *cv)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_timedwait (ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *)
ACE_NAMESPACE_INLINE_FUNCTION int	cond_wait (ACE_cond_t *cv, ACE_mutex_t *m)
A set of wrappers for auto-reset and manual events.
ACE_Export int	event_destroy (ACE_event_t *event)
ACE_Export 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)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_Export int	event_pulse (ACE_event_t *event)
ACE_Export int	event_reset (ACE_event_t *event)
ACE_Export int	event_signal (ACE_event_t *event)
ACE_Export int	event_timedwait (ACE_event_t *event, ACE_Time_Value *timeout, int use_absolute_time=1)
ACE_Export int	event_wait (ACE_event_t *event)
A set of wrappers for mutex locks.
ACE_Export int	mutex_destroy (ACE_mutex_t *m)
ACE_Export int	mutex_init (ACE_mutex_t *m, int lock_scope=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0, int lock_type=0)
ACE_Export int	mutex_init (ACE_mutex_t *m, int lock_scope, const wchar_t *name, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0, int lock_type=0)
ACE_Export int	mutex_lock (ACE_mutex_t *m)
ACE_Export int	mutex_lock (ACE_mutex_t *m, int &abandoned)
ACE_Export int	mutex_lock (ACE_mutex_t *m, const ACE_Time_Value &timeout)
ACE_NAMESPACE_INLINE_FUNCTION int	mutex_lock (ACE_mutex_t *m, const ACE_Time_Value *timeout)
ACE_Export void	mutex_lock_cleanup (void *mutex)
	Handle asynchronous thread cancellation cleanup.
ACE_Export int	mutex_trylock (ACE_mutex_t *m)
ACE_Export int	mutex_trylock (ACE_mutex_t *m, int &abandoned)
ACE_Export int	mutex_unlock (ACE_mutex_t *m)
A set of wrappers for recursive mutex locks.
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_cond_unlock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)
ACE_NAMESPACE_INLINE_FUNCTION void	recursive_mutex_cond_relock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_destroy (ACE_recursive_thread_mutex_t *m)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_init (ACE_recursive_thread_mutex_t *m, const ACE_TCHAR *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_lock (ACE_recursive_thread_mutex_t *m)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_lock (ACE_recursive_thread_mutex_t *m, const ACE_Time_Value &timeout)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_lock (ACE_recursive_thread_mutex_t *m, const ACE_Time_Value *timeout)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_trylock (ACE_recursive_thread_mutex_t *m)
ACE_NAMESPACE_INLINE_FUNCTION int	recursive_mutex_unlock (ACE_recursive_thread_mutex_t *m)
A set of wrappers for readers/writer locks.
ACE_NAMESPACE_INLINE_FUNCTION int	rw_rdlock (ACE_rwlock_t *rw)
ACE_NAMESPACE_INLINE_FUNCTION int	rw_tryrdlock (ACE_rwlock_t *rw)
ACE_NAMESPACE_INLINE_FUNCTION int	rw_trywrlock (ACE_rwlock_t *rw)
ACE_NAMESPACE_INLINE_FUNCTION int	rw_trywrlock_upgrade (ACE_rwlock_t *rw)
ACE_NAMESPACE_INLINE_FUNCTION int	rw_unlock (ACE_rwlock_t *rw)
ACE_NAMESPACE_INLINE_FUNCTION int	rw_wrlock (ACE_rwlock_t *rw)
ACE_NAMESPACE_INLINE_FUNCTION int	rwlock_destroy (ACE_rwlock_t *rw)
ACE_Export int	rwlock_init (ACE_rwlock_t *rw, int type=ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR *name=0, void *arg=0)
Thread scheduler interface.
ACE_Export int	sched_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
A set of wrappers for semaphores.
ACE_NAMESPACE_INLINE_FUNCTION int	sema_destroy (ACE_sema_t *s)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION int	sema_post (ACE_sema_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	sema_post (ACE_sema_t *s, u_int release_count)
ACE_NAMESPACE_INLINE_FUNCTION int	sema_trywait (ACE_sema_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	sema_wait (ACE_sema_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	sema_wait (ACE_sema_t *s, ACE_Time_Value &tv)
ACE_NAMESPACE_INLINE_FUNCTION int	sema_wait (ACE_sema_t *s, ACE_Time_Value *tv)
A set of wrappers for System V semaphores.
ACE_NAMESPACE_INLINE_FUNCTION int	semctl (int int_id, int semnum, int cmd, semun)
ACE_NAMESPACE_INLINE_FUNCTION int	semget (key_t key, int nsems, int flags)
ACE_NAMESPACE_INLINE_FUNCTION int	semop (int int_id, struct sembuf *sops, size_t nsops)
A set of wrappers for mutex locks that only work within a single process.
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_destroy (ACE_thread_mutex_t *m)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_init (ACE_thread_mutex_t *m, int lock_type=0, const char *name=0, ACE_mutexattr_t *arg=0)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_init (ACE_thread_mutex_t *m, int lock_type, const wchar_t *name, ACE_mutexattr_t *arg=0)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_lock (ACE_thread_mutex_t *m)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value &timeout)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value *timeout)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_trylock (ACE_thread_mutex_t *m)
ACE_NAMESPACE_INLINE_FUNCTION int	thread_mutex_unlock (ACE_thread_mutex_t *m)
A set of wrappers for operations on time.
ACE_NAMESPACE_INLINE_FUNCTION char *	asctime (const struct tm *tm)
ACE_NAMESPACE_INLINE_FUNCTION char *	asctime_r (const struct tm *tm, char *buf, int buflen)
ACE_NAMESPACE_INLINE_FUNCTION int	clock_gettime (clockid_t, struct timespec *)
ACE_NAMESPACE_INLINE_FUNCTION int	clock_settime (clockid_t, const struct timespec *)
ACE_NAMESPACE_INLINE_FUNCTION ACE_TCHAR *	ctime (const time_t *t)
ACE_NAMESPACE_INLINE_FUNCTION ACE_TCHAR *	ctime_r (const time_t *clock, ACE_TCHAR *buf, int buflen)
ACE_NAMESPACE_INLINE_FUNCTION double	difftime (time_t t1, time_t t0)
ACE_NAMESPACE_INLINE_FUNCTION ACE_hrtime_t	gethrtime (const ACE_HRTimer_Op=ACE_HRTIMER_GETTIME)
ACE_NAMESPACE_INLINE_FUNCTION struct tm *	gmtime (const time_t *clock)
ACE_NAMESPACE_INLINE_FUNCTION struct tm *	gmtime_r (const time_t *clock, struct tm *res)
ACE_NAMESPACE_INLINE_FUNCTION struct tm *	localtime (const time_t *clock)
ACE_Export struct tm *	localtime_r (const time_t *clock, struct tm *res)
ACE_Export time_t	mktime (struct tm *timeptr)
ACE_NAMESPACE_INLINE_FUNCTION int	nanosleep (const struct timespec *requested, struct timespec *remaining=0)
ACE_NAMESPACE_INLINE_FUNCTION size_t	strftime (char *s, size_t maxsize, const char *format, const struct tm *timeptr)
ACE_NAMESPACE_INLINE_FUNCTION char *	strptime (const char *buf, const char *format, struct tm *tm)
ACE_NAMESPACE_INLINE_FUNCTION time_t	time (time_t *tloc=0)
ACE_NAMESPACE_INLINE_FUNCTION long	timezone (void)
ACE_NAMESPACE_INLINE_FUNCTION void	tzset (void)
[NOHEADER]
ACE_NAMESPACE_INLINE_FUNCTION pid_t	fork (void)
ACE_Export pid_t	fork (const ACE_TCHAR *program_name)
ACE_Export pid_t	fork_exec (ACE_TCHAR *argv[])
A set of wrappers for threads
ACE_Export ACE_thread_t	NULL_thread
ACE_Export ACE_hthread_t	NULL_hthread
ACE_Export ACE_thread_key_t	NULL_key
Typedefs
typedef ACE_WCHAR_T	WChar
Enumerations
enum	ACE_HRTimer_Op { ACE_HRTIMER_START = 0x0, ACE_HRTIMER_INCR = 0x1, ACE_HRTIMER_STOP = 0x2, ACE_HRTIMER_GETTIME = 0xFFFF }
Functions
ACE_NAMESPACE_INLINE_FUNCTION unsigned long	inet_addr (const char *name)
ACE_Export int	inet_aton (const char *strptr, struct in_addr *addr)
ACE_NAMESPACE_INLINE_FUNCTION char *	inet_ntoa (const struct in_addr addr)
ACE_NAMESPACE_INLINE_FUNCTION const char *	inet_ntop (int family, const void *addrptr, char *strptr, size_t len)
ACE_NAMESPACE_INLINE_FUNCTION int	inet_pton (int family, const char *strptr, void *addrptr)
ACE_NAMESPACE_INLINE_FUNCTION void	closedir (ACE_DIR *)
ACE_NAMESPACE_INLINE_FUNCTION ACE_DIR *	opendir (const ACE_TCHAR *filename)
ACE_NAMESPACE_INLINE_FUNCTION struct ACE_DIRENT *	readdir (ACE_DIR *)
ACE_NAMESPACE_INLINE_FUNCTION int	readdir_r (ACE_DIR *dirp, struct ACE_DIRENT *entry, struct ACE_DIRENT **result)
ACE_NAMESPACE_INLINE_FUNCTION void	rewinddir (ACE_DIR *)
ACE_NAMESPACE_INLINE_FUNCTION int	scandir (const ACE_TCHAR *dirname, struct ACE_DIRENT **namelist[], int(*selector)(const struct ACE_DIRENT *filename), int(*comparator)(const struct ACE_DIRENT **f1, const struct ACE_DIRENT **f2))
ACE_NAMESPACE_INLINE_FUNCTION void	seekdir (ACE_DIR *, long loc)
ACE_NAMESPACE_INLINE_FUNCTION long	telldir (ACE_DIR *)
ACE_Export int	scandir_emulation (const ACE_TCHAR *dirname, ACE_DIRENT **namelist[], int(*selector)(const ACE_DIRENT *entry), int(*comparator)(const ACE_DIRENT **f1, const ACE_DIRENT **f2))
ACE_INLINE int	scandir (const ACE_TCHAR *dirname, struct ACE_DIRENT **namelist[], int(*selector)(const struct ACE_DIRENT *), int(*comparator)(const struct ACE_DIRENT **f1, const struct ACE_DIRENT **f2))
ACE_NAMESPACE_INLINE_FUNCTION int	last_error (void)
ACE_NAMESPACE_INLINE_FUNCTION void	last_error (int)
ACE_NAMESPACE_INLINE_FUNCTION int	set_errno_to_last_error (void)
ACE_NAMESPACE_INLINE_FUNCTION int	set_errno_to_wsa_last_error (void)
ACE_NAMESPACE_INLINE_FUNCTION int	fcntl (ACE_HANDLE handle, int cmd, long arg=0)
ACE_Export ACE_HANDLE	open (const char *filename, int mode, int perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
ACE_Export ACE_HANDLE	open (const wchar_t *filename, int mode, int perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
ACE_NAMESPACE_INLINE_FUNCTION double	floor (double x)
	This method computes the largest integral value not greater than x.
ACE_NAMESPACE_INLINE_FUNCTION double	ceil (double x)
	This method computes the smallest integral value not less than x.
ACE_NAMESPACE_INLINE_FUNCTION struct hostent *	gethostbyaddr (const char *addr, int length, int type)
ACE_NAMESPACE_INLINE_FUNCTION struct hostent *	gethostbyaddr_r (const char *addr, int length, int type, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
ACE_NAMESPACE_INLINE_FUNCTION struct hostent *	gethostbyname (const char *name)
ACE_NAMESPACE_INLINE_FUNCTION struct hostent *	gethostbyname_r (const char *name, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
ACE_NAMESPACE_INLINE_FUNCTION struct hostent *	getipnodebyaddr (const void *src, size_t len, int family)
ACE_NAMESPACE_INLINE_FUNCTION struct hostent *	getipnodebyname (const char *name, int family, int flags=0)
ACE_Export int	getmacaddress (struct macaddr_node_t *node)
ACE_NAMESPACE_INLINE_FUNCTION struct protoent *	getprotobyname (const char *name)
ACE_NAMESPACE_INLINE_FUNCTION struct protoent *	getprotobyname_r (const char *name, struct protoent *result, ACE_PROTOENT_DATA buffer)
ACE_NAMESPACE_INLINE_FUNCTION struct protoent *	getprotobynumber (int proto)
ACE_NAMESPACE_INLINE_FUNCTION struct protoent *	getprotobynumber_r (int proto, struct protoent *result, ACE_PROTOENT_DATA buffer)
ACE_NAMESPACE_INLINE_FUNCTION struct servent *	getservbyname (const char *svc, const char *proto)
ACE_NAMESPACE_INLINE_FUNCTION struct servent *	getservbyname_r (const char *svc, const char *proto, struct servent *result, ACE_SERVENT_DATA buf)
ACE_NAMESPACE_INLINE_FUNCTION int	poll (struct pollfd *pollfds, unsigned long len, const ACE_Time_Value *tv=0)
ACE_NAMESPACE_INLINE_FUNCTION int	poll (struct pollfd *pollfds, unsigned long len, const ACE_Time_Value &tv)
ACE_NAMESPACE_INLINE_FUNCTION void	clearerr (FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION int	fclose (FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION FILE *	fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)
ACE_NAMESPACE_INLINE_FUNCTION int	fflush (FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION int	fgetc (FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION int	fgetpos (FILE *fp, fpos_t *pos)
ACE_NAMESPACE_INLINE_FUNCTION char *	fgets (char *buf, int size, FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	fgets (wchar_t *buf, int size, FILE *fp)
ACE_Export FILE *	fopen (const char *filename, const ACE_TCHAR *mode)
ACE_Export FILE *	fopen (const wchar_t *filename, const ACE_TCHAR *mode)
ACE_NAMESPACE_INLINE_FUNCTION LPSECURITY_ATTRIBUTES	default_win32_security_attributes (LPSECURITY_ATTRIBUTES)
	Default Win32 Security Attributes definition.
ACE_NAMESPACE_INLINE_FUNCTION LPSECURITY_ATTRIBUTES	default_win32_security_attributes_r (LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, SECURITY_DESCRIPTOR *)
ACE_NAMESPACE_INLINE_FUNCTION const OSVERSIONINFO &	get_win32_versioninfo (void)
	Return the win32 OSVERSIONINFO structure.
ACE_NAMESPACE_INLINE_FUNCTION HINSTANCE	get_win32_resource_module (void)
ACE_NAMESPACE_INLINE_FUNCTION void	set_win32_resource_module (HINSTANCE)
ACE_NAMESPACE_INLINE_FUNCTION void	fopen_mode_to_open_mode_converter (ACE_TCHAR x, int &hmode)
ACE_Export int	fprintf (FILE *fp, const char *format,...)
ACE_Export int	fprintf (FILE *fp, const wchar_t *format,...)
ACE_NAMESPACE_INLINE_FUNCTION int	fputs (const char *s, FILE *stream)
ACE_NAMESPACE_INLINE_FUNCTION int	fputs (const wchar_t *s, FILE *stream)
ACE_NAMESPACE_INLINE_FUNCTION size_t	fread (void *ptr, size_t size, size_t nelems, FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION FILE *	freopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode, FILE *stream)
ACE_NAMESPACE_INLINE_FUNCTION int	fseek (FILE *fp, long offset, int ptrname)
ACE_NAMESPACE_INLINE_FUNCTION int	fsetpos (FILE *fp, fpos_t *pos)
ACE_NAMESPACE_INLINE_FUNCTION long	ftell (FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION size_t	fwrite (const void *ptr, size_t size, size_t nitems, FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION void	perror (const char *s)
ACE_NAMESPACE_INLINE_FUNCTION void	perror (const wchar_t *s)
ACE_Export int	printf (const char *format,...)
ACE_NAMESPACE_INLINE_FUNCTION int	puts (const char *s)
ACE_NAMESPACE_INLINE_FUNCTION int	puts (const wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION int	rename (const char *old_name, const char *new_name, int flags=-1)
ACE_NAMESPACE_INLINE_FUNCTION int	rename (const wchar_t *old_name, const wchar_t *new_name, int flags=-1)
ACE_NAMESPACE_INLINE_FUNCTION void	rewind (FILE *fp)
ACE_Export int	snprintf (char *buf, size_t maxlen, const char *format,...)
ACE_Export int	snprintf (wchar_t *buf, size_t maxlen, const wchar_t *format,...)
ACE_Export int	sprintf (char *buf, const char *format,...)
ACE_Export int	sprintf (wchar_t *buf, const wchar_t *format,...)
ACE_NAMESPACE_INLINE_FUNCTION char *	tempnam (const char *dir=0, const char *pfx=0)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	tempnam (const wchar_t *dir, const wchar_t *pfx=0)
ACE_NAMESPACE_INLINE_FUNCTION int	vsprintf (char *buffer, const char *format, va_list argptr)
ACE_NAMESPACE_INLINE_FUNCTION int	vsnprintf (char *buffer, size_t maxlen, const char *format, va_list argptr)
ACE_NAMESPACE_INLINE_FUNCTION int	vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr)
ACE_NAMESPACE_INLINE_FUNCTION int	vsnprintf (wchar_t *buffer, size_t maxlen, const wchar_t *format, va_list argptr)
ACE_NAMESPACE_INLINE_FUNCTION char *	strtok_r (char *s, const char *tokens, char **lasts)
	Finds the next token in a string (safe char version).
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	strtok_r (ACE_WCHAR_T *s, const ACE_WCHAR_T *tokens, ACE_WCHAR_T **lasts)
	Finds the next token in a string (wchar_t version).
ACE_Export char *	strtok_r_emulation (char *s, const char *tokens, char **lasts)
	Emulated strtok_r.
ACE_NAMESPACE_INLINE_FUNCTION int	strcasecmp (const char *s, const char *t)
	Compares two strings (case insensitive const char version).
ACE_NAMESPACE_INLINE_FUNCTION int	strcasecmp (const wchar_t *s, const wchar_t *t)
	Compares two strings (case insensitive const wchar_t version).
ACE_NAMESPACE_INLINE_FUNCTION int	strncasecmp (const char *s, const char *t, size_t len)
	Compares two arrays (case insensitive const char version).
ACE_NAMESPACE_INLINE_FUNCTION int	strncasecmp (const wchar_t *s, const wchar_t *t, size_t len)
	Compares two arrays (case insensitive const wchar_t version).
ACE_Export int	strcasecmp_emulation (const char *s, const char *t)
	Emulated strcasecmp - Performs a case insensitive comparison of strings.
ACE_Export int	strncasecmp_emulation (const char *s, const char *t, size_t len)
	Emulated strncasecmp - Performs a case insensitvie comparison of arrays.
ACE_NAMESPACE_INLINE_FUNCTION int	getmsg (ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *flags)
ACE_NAMESPACE_INLINE_FUNCTION int	getpmsg (ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *band, int *flags)
ACE_NAMESPACE_INLINE_FUNCTION int	fattach (int handle, const char *path)
ACE_NAMESPACE_INLINE_FUNCTION int	fdetach (const char *file)
ACE_NAMESPACE_INLINE_FUNCTION int	ioctl (ACE_HANDLE handle, ACE_IOCTL_TYPE_ARG2 cmd, void *=0)
	UNIX-style .
ACE_Export int	ioctl (ACE_HANDLE socket, unsigned long io_control_code, void *in_buffer_p, unsigned long in_buffer, void *out_buffer_p, unsigned long out_buffer, unsigned long *bytes_returned, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
	QoS-enabled .
ACE_Export int	ioctl (ACE_HANDLE socket, unsigned long io_control_code, ACE_QoS &ace_qos, unsigned long *bytes_returned, void *buffer_p=0, unsigned long buffer=0, ACE_OVERLAPPED *overlapped=0, ACE_OVERLAPPED_COMPLETION_FUNC func=0)
ACE_NAMESPACE_INLINE_FUNCTION int	isastream (ACE_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION int	putmsg (ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int flags)
ACE_NAMESPACE_INLINE_FUNCTION int	putpmsg (ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int band, int flags)
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	shm_open (const ACE_TCHAR *filename, int mode, int perms=0, LPSECURITY_ATTRIBUTES sa=0)
ACE_NAMESPACE_INLINE_FUNCTION int	shm_unlink (const ACE_TCHAR *path)
ACE_NAMESPACE_INLINE_FUNCTION int	getrlimit (int resource, struct rlimit *rl)
ACE_NAMESPACE_INLINE_FUNCTION int	getrusage (int who, struct rusage *rusage)
ACE_NAMESPACE_INLINE_FUNCTION int	setrlimit (int resource, const struct rlimit *rl)
ACE_NAMESPACE_INLINE_FUNCTION int	select (int width, fd_set *rfds, fd_set *wfds=0, fd_set *efds=0, const ACE_Time_Value *tv=0)
ACE_NAMESPACE_INLINE_FUNCTION int	select (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	sendfile (ACE_HANDLE out_fd, ACE_HANDLE in_fd, off_t *offset, size_t count)
	Finds the length of a string (char version).
ACE_Export ssize_t	sendfile_emulation (ACE_HANDLE out_fd, ACE_HANDLE in_fd, off_t *offset, size_t count)
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	creat (const ACE_TCHAR *filename, mode_t mode)
ACE_NAMESPACE_INLINE_FUNCTION int	fstat (ACE_HANDLE, ACE_stat *)
ACE_NAMESPACE_INLINE_FUNCTION int	lstat (const char *, ACE_stat *)
ACE_NAMESPACE_INLINE_FUNCTION int	lstat (const wchar_t *, ACE_stat *)
ACE_NAMESPACE_INLINE_FUNCTION int	mkdir (const char *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)
ACE_NAMESPACE_INLINE_FUNCTION int	mkdir (const wchar_t *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)
ACE_NAMESPACE_INLINE_FUNCTION int	mkfifo (const ACE_TCHAR *file, mode_t mode=ACE_DEFAULT_FILE_PERMS)
ACE_NAMESPACE_INLINE_FUNCTION int	stat (const char *file, ACE_stat *)
ACE_NAMESPACE_INLINE_FUNCTION int	stat (const wchar_t *file, ACE_stat *)
ACE_NAMESPACE_INLINE_FUNCTION mode_t	umask (mode_t cmask)
ACE_NAMESPACE_INLINE_FUNCTION ACE_Time_Value	gettimeofday (void)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	readv (ACE_HANDLE handle, const iovec *iov, int iovlen)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	writev (ACE_HANDLE handle, const iovec *iov, int iovcnt)
ACE_Export int	uname (ACE_utsname *name)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	wait (int *=0)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	wait (pid_t pid, ACE_exitcode *status, int wait_options=0, ACE_HANDLE handle=0)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	waitpid (pid_t pid, ACE_exitcode *status=0, int wait_options=0, ACE_HANDLE handle=0)
ACE_Export void	cleanup_tss (const u_int main_thread)
ACE_Export int	lwp_getparams (ACE_Sched_Params &)
ACE_Export int	lwp_setparams (const ACE_Sched_Params &)
ACE_NAMESPACE_INLINE_FUNCTION long	priority_control (ACE_idtype_t, ACE_id_t, int, void *)
	Low-level interface to (2).
ACE_Export int	scheduling_class (const char *class_name, ACE_id_t &)
	Find the schedling class ID that corresponds to the class name.
ACE_Export int	set_scheduling_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
	Friendly interface to (2).
ACE_NAMESPACE_INLINE_FUNCTION int	sigtimedwait (const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout)
ACE_NAMESPACE_INLINE_FUNCTION int	sigwait (sigset_t *set, int *sig=0)
ACE_NAMESPACE_INLINE_FUNCTION int	sigwaitinfo (const sigset_t *set, siginfo_t *info)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_cancel (ACE_thread_t t_id)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_cmp (ACE_hthread_t t1, ACE_hthread_t t2)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_continue (ACE_hthread_t target_thread)
ACE_Export 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)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_equal (ACE_thread_t t1, ACE_thread_t t2)
ACE_Export void	thr_exit (ACE_THR_FUNC_RETURN status=0)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_getconcurrency (void)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_getprio (ACE_hthread_t id, int &priority)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_getprio (ACE_hthread_t id, int &priority, int &policy)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_getspecific (ACE_thread_key_t key, void **data)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_join (ACE_hthread_t waiter_id, ACE_THR_FUNC_RETURN *status)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_join (ACE_thread_t waiter_id, ACE_thread_t *thr_id, ACE_THR_FUNC_RETURN *status)
ACE_Export int	thr_get_affinity (ACE_hthread_t id, size_t cpu_set_size, cpu_set_t *cpu_mask)
ACE_Export int	thr_set_affinity (ACE_hthread_t thr_id, size_t cpu_set_size, const cpu_set_t *cpu_mask)
ACE_Export int	thr_key_detach (ACE_thread_key_t key, void *inst)
ACE_Export int	thr_key_used (ACE_thread_key_t key)
ACE_Export int	thr_keycreate (ACE_thread_key_t *key, ACE_THR_DEST, void *inst=0)
ACE_Export int	thr_keyfree (ACE_thread_key_t key)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_kill (ACE_thread_t thr_id, int signum)
ACE_NAMESPACE_INLINE_FUNCTION size_t	thr_min_stack (void)
ACE_NAMESPACE_INLINE_FUNCTION ACE_thread_t	thr_self (void)
ACE_NAMESPACE_INLINE_FUNCTION void	thr_self (ACE_hthread_t &)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_setcancelstate (int new_state, int *old_state)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_setcanceltype (int new_type, int *old_type)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_setconcurrency (int hint)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_setprio (ACE_hthread_t ht_id, int priority, int policy=-1)
ACE_Export int	thr_setprio (const ACE_Sched_Priority prio)
ACE_Export int	thr_setspecific (ACE_thread_key_t key, void *data)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_sigsetmask (int how, const sigset_t *nsm, sigset_t *osm)
ACE_NAMESPACE_INLINE_FUNCTION int	thr_suspend (ACE_hthread_t target_thread)
ACE_NAMESPACE_INLINE_FUNCTION void	thr_testcancel (void)
ACE_NAMESPACE_INLINE_FUNCTION void	thr_yield (void)
ACE_Export void	unique_name (const void *object, char *name, size_t length)
ACE_NAMESPACE_INLINE_FUNCTION int	access (const char *path, int amode)
ACE_NAMESPACE_INLINE_FUNCTION int	access (const wchar_t *path, int amode)
ACE_NAMESPACE_INLINE_FUNCTION unsigned int	alarm (u_int secs)
ACE_NAMESPACE_INLINE_FUNCTION long	allocation_granularity (void)
ACE_Export int	argv_to_string (ACE_TCHAR **argv, ACE_TCHAR *&buf, bool substitute_env_args=true)
ACE_NAMESPACE_INLINE_FUNCTION int	chdir (const char *path)
ACE_NAMESPACE_INLINE_FUNCTION int	chdir (const wchar_t *path)
ACE_NAMESPACE_INLINE_FUNCTION int	rmdir (const char *path)
ACE_NAMESPACE_INLINE_FUNCTION int	rmdir (const wchar_t *path)
ACE_NAMESPACE_INLINE_FUNCTION int	close (ACE_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	dup (ACE_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION int	dup2 (ACE_HANDLE oldfd, ACE_HANDLE newfd)
ACE_Export int	execl (const char *path, const char *arg0,...)
ACE_Export int	execle (const char *path, const char *arg0,...)
ACE_Export int	execlp (const char *file, const char *arg0,...)
ACE_NAMESPACE_INLINE_FUNCTION int	execv (const char *path, char *const argv[])
ACE_NAMESPACE_INLINE_FUNCTION int	execve (const char *path, char *const argv[], char *const envp[])
ACE_NAMESPACE_INLINE_FUNCTION int	execvp (const char *file, char *const argv[])
ACE_NAMESPACE_INLINE_FUNCTION int	fsync (ACE_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION int	ftruncate (ACE_HANDLE, ACE_LOFF_T)
ACE_NAMESPACE_INLINE_FUNCTION char *	getcwd (char *, size_t)
ACE_NAMESPACE_INLINE_FUNCTION wchar_t *	getcwd (wchar_t *, size_t)
ACE_NAMESPACE_INLINE_FUNCTION gid_t	getgid (void)
ACE_NAMESPACE_INLINE_FUNCTION gid_t	getegid (void)
ACE_NAMESPACE_INLINE_FUNCTION int	getopt (int argc, char *const *argv, const char *optstring)
ACE_NAMESPACE_INLINE_FUNCTION long	getpagesize (void)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	getpgid (pid_t pid)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	getpid (void)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	getppid (void)
ACE_NAMESPACE_INLINE_FUNCTION uid_t	getuid (void)
ACE_NAMESPACE_INLINE_FUNCTION uid_t	geteuid (void)
ACE_NAMESPACE_INLINE_FUNCTION int	hostname (char *name, size_t maxnamelen)
ACE_NAMESPACE_INLINE_FUNCTION int	hostname (wchar_t *name, size_t maxnamelen)
ACE_NAMESPACE_INLINE_FUNCTION int	isatty (int handle)
ACE_NAMESPACE_INLINE_FUNCTION int	isatty (ACE_HANDLE handle)
ACE_NAMESPACE_INLINE_FUNCTION off_t	lseek (ACE_HANDLE handle, off_t offset, int whence)
ACE_Export long	num_processors (void)
	Get the number of CPUs configured in the machine.
ACE_Export long	num_processors_online (void)
	Get the number of CPUs currently online.
ACE_NAMESPACE_INLINE_FUNCTION int	pipe (ACE_HANDLE handles[])
ACE_Export ssize_t	pread (ACE_HANDLE handle, void *buf, size_t nbyte, off_t offset)
ACE_Export ssize_t	pwrite (ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_LOFF_T offset)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	read (ACE_HANDLE handle, void *buf, size_t len)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	read (ACE_HANDLE handle, void *buf, size_t len, ACE_OVERLAPPED *)
ACE_Export ssize_t	read_n (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	readlink (const char *path, char *buf, size_t bufsiz)
ACE_NAMESPACE_INLINE_FUNCTION void *	sbrk (ptrdiff_t brk)
ACE_NAMESPACE_INLINE_FUNCTION int	setgid (gid_t)
ACE_NAMESPACE_INLINE_FUNCTION int	setegid (gid_t)
ACE_NAMESPACE_INLINE_FUNCTION int	setpgid (pid_t pid, pid_t pgid)
ACE_NAMESPACE_INLINE_FUNCTION int	setregid (gid_t rgid, gid_t egid)
ACE_NAMESPACE_INLINE_FUNCTION int	setreuid (uid_t ruid, uid_t euid)
ACE_NAMESPACE_INLINE_FUNCTION pid_t	setsid (void)
ACE_NAMESPACE_INLINE_FUNCTION int	setuid (uid_t)
ACE_NAMESPACE_INLINE_FUNCTION int	seteuid (uid_t)
ACE_NAMESPACE_INLINE_FUNCTION int	sleep (u_int seconds)
ACE_NAMESPACE_INLINE_FUNCTION int	sleep (const ACE_Time_Value &tv)
ACE_Export int	string_to_argv (ACE_TCHAR *buf, int &argc, ACE_TCHAR **&argv, bool substitute_env_args=true)
ACE_NAMESPACE_INLINE_FUNCTION void	swab (const void *src, void *dest, ssize_t n)
ACE_NAMESPACE_INLINE_FUNCTION long	sysconf (int)
ACE_NAMESPACE_INLINE_FUNCTION long	sysinfo (int cmd, char *buf, long count)
ACE_NAMESPACE_INLINE_FUNCTION int	truncate (const ACE_TCHAR *filename, ACE_LOFF_T length)
ACE_NAMESPACE_INLINE_FUNCTION u_long	ualarm (u_long usecs, u_long interval=0)
ACE_NAMESPACE_INLINE_FUNCTION u_long	ualarm (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)
ACE_NAMESPACE_INLINE_FUNCTION int	unlink (const char *path)
ACE_NAMESPACE_INLINE_FUNCTION int	unlink (const wchar_t *path)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	write (ACE_HANDLE handle, const void *buf, size_t nbyte)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	write (ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_OVERLAPPED *)
ACE_Export ssize_t	write_n (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION wint_t	fgetwc (FILE *fp)
ACE_Export wchar_t *	wcscat_emulation (wchar_t *destination, const wchar_t *source)
	Emulated wcscat - Appends a string.
ACE_Export wchar_t *	wcschr_emulation (const wchar_t *string, wint_t c)
	Emulated wcschr - Finds a character in a string.
ACE_Export int	wcscmp_emulation (const ACE_WCHAR_T *string1, const ACE_WCHAR_T *string2)
	Emulated wcscmp - Compares strings.
ACE_Export wchar_t *	wcscpy_emulation (wchar_t *destination, const wchar_t *source)
	Emulated wcscpy - Copies a string.
ACE_Export size_t	wcscspn_emulation (const wchar_t *string, const wchar_t *reject)
	Emulated wcscspn.
ACE_Export int	wcsicmp_emulation (const wchar_t *string1, const wchar_t *string2)
	Emulated wcsicmp - Performs a case insensitive comparison of strings.
ACE_Export size_t	wcslen_emulation (const ACE_WCHAR_T *string)
	Emulated wcslen - Returns the length of a string.
ACE_Export ACE_WCHAR_T *	wcsncat_emulation (ACE_WCHAR_T *destination, const ACE_WCHAR_T *source, size_t count)
	Emulated wcscat - Appends a string.
ACE_Export int	wcsncmp_emulation (const ACE_WCHAR_T *string1, const ACE_WCHAR_T *string2, size_t len)
	Emulated wcsncmp - Compares two arrays.
ACE_Export ACE_WCHAR_T *	wcsncpy_emulation (ACE_WCHAR_T *destination, const ACE_WCHAR_T *source, size_t len)
	Emulated wcsncpy - Copies an array.
ACE_Export int	wcsnicmp_emulation (const wchar_t *string1, const wchar_t *string2, size_t len)
ACE_Export wchar_t *	wcspbrk_emulation (const wchar_t *string, const wchar_t *charset)
	Emulated wcspbrk - Searches for characters in a string.
ACE_Export wchar_t *	wcsrchr_emulation (wchar_t *string, wint_t c)
ACE_Export const wchar_t *	wcsrchr_emulation (const wchar_t *string, wint_t c)
ACE_Export size_t	wcsspn_emulation (const wchar_t *string, const wchar_t *charset)
	Emulated wcsspn.
ACE_Export wchar_t *	wcsstr_emulation (const wchar_t *string, const wchar_t *charset)
	Emulated wcsstr - Performs a case insensitive comparison of two strings.
ACE_NAMESPACE_INLINE_FUNCTION u_int	wslen (const WChar *)
ACE_NAMESPACE_INLINE_FUNCTION WChar *	wscpy (WChar *, const WChar *)
ACE_NAMESPACE_INLINE_FUNCTION int	wscmp (const WChar *, const WChar *)
ACE_NAMESPACE_INLINE_FUNCTION int	wsncmp (const WChar *, const WChar *, size_t len)
ACE_NAMESPACE_INLINE_FUNCTION wint_t	ungetwc (wint_t c, FILE *fp)
ACE_NAMESPACE_INLINE_FUNCTION int	t_accept (ACE_HANDLE fildes, ACE_HANDLE resfd, struct t_call *call)
ACE_NAMESPACE_INLINE_FUNCTION char *	t_alloc (ACE_HANDLE fildes, int struct_type, int fields)
ACE_NAMESPACE_INLINE_FUNCTION int	t_bind (ACE_HANDLE fildes, struct t_bind *req, struct t_bind *ret)
ACE_NAMESPACE_INLINE_FUNCTION int	t_close (ACE_HANDLE fildes)
ACE_NAMESPACE_INLINE_FUNCTION int	t_connect (ACE_HANDLE fildes, struct t_call *sndcall, struct t_call *rcvcall)
ACE_NAMESPACE_INLINE_FUNCTION void	t_error (const char *errmsg)
ACE_NAMESPACE_INLINE_FUNCTION int	t_free (char *ptr, int struct_type)
ACE_NAMESPACE_INLINE_FUNCTION int	t_getinfo (ACE_HANDLE fildes, struct t_info *info)
ACE_NAMESPACE_INLINE_FUNCTION int	t_getname (ACE_HANDLE fildes, struct netbuf *namep, int type)
ACE_NAMESPACE_INLINE_FUNCTION int	t_getstate (ACE_HANDLE fildes)
ACE_NAMESPACE_INLINE_FUNCTION int	t_listen (ACE_HANDLE fildes, struct t_call *call)
ACE_NAMESPACE_INLINE_FUNCTION int	t_look (ACE_HANDLE fildes)
ACE_NAMESPACE_INLINE_FUNCTION ACE_HANDLE	t_open (char *path, int oflag, struct t_info *info)
ACE_NAMESPACE_INLINE_FUNCTION int	t_optmgmt (ACE_HANDLE handle, ACE_TOPTMGMT *req, ACE_TOPTMGMT *ret)
ACE_NAMESPACE_INLINE_FUNCTION int	t_rcv (ACE_HANDLE fildes, char *buf, unsigned int nbytes, int *flags)
ACE_NAMESPACE_INLINE_FUNCTION int	t_rcvdis (ACE_HANDLE fildes, struct t_discon *discon)
ACE_NAMESPACE_INLINE_FUNCTION int	t_rcvrel (ACE_HANDLE fildes)
ACE_NAMESPACE_INLINE_FUNCTION int	t_rcvudata (ACE_HANDLE fildes, struct t_unitdata *unitdata, int *flags)
ACE_NAMESPACE_INLINE_FUNCTION int	t_rcvuderr (ACE_HANDLE fildes, struct t_uderr *uderr)
ACE_NAMESPACE_INLINE_FUNCTION int	t_snd (ACE_HANDLE fildes, const char *buf, unsigned int nbytes, int flags)
ACE_NAMESPACE_INLINE_FUNCTION int	t_snddis (ACE_HANDLE fildes, struct t_call *call)
ACE_NAMESPACE_INLINE_FUNCTION int	t_sndrel (ACE_HANDLE fildes)
ACE_NAMESPACE_INLINE_FUNCTION int	t_sync (ACE_HANDLE fildes)
ACE_NAMESPACE_INLINE_FUNCTION int	t_unbind (ACE_HANDLE fildes)
Variables
ACE_Export OSVERSIONINFO	win32_versioninfo_
ACE_Export HINSTANCE	win32_resource_module_
ACE_Export int	socket_initialized_
	Keeps track of whether we've already initialized WinSock...

---

Detailed Description

This namespace 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 namespace 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.

---

Typedef Documentation

typedef ACE_WCHAR_T ACE_OS::WChar

Definition at line 45 of file OS_NS_wchar.h.

---

Enumeration Type Documentation

enum ACE_OS::ACE_HRTimer_Op

Enumeration values: ACE_HRTIMER_START  ACE_HRTIMER_INCR  ACE_HRTIMER_STOP  ACE_HRTIMER_GETTIME  Definition at line 161 of file OS_NS_time.h. { 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 };

---

Function Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void ACE_OS::_exit (  int  status = 0  )

Definition at line 23 of file OS_NS_stdlib.inl. References ACE_OS_TRACE. Referenced by ACE::fork(), and ACE_Process::spawn(). { ACE_OS_TRACE ("ACE_OS::_exit"); #if defined (ACE_VXWORKS) ::exit (status); #elif !defined (ACE_HAS_WINCE) ::_exit (status); #else ::TerminateProcess (::GetCurrentProcess (), status); #endif /* ACE_VXWORKS */ }

ACE_INLINE void ACE_OS::abort (  void   )

Definition at line 37 of file OS_NS_stdlib.inl. 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 )

QoS-enabled , which passes to . If the OS platform doesn't support QoS-enabled then the are ignored and the BSD-style is called. Definition at line 19 of file OS_NS_sys_socket.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 )

BSD-style (no QoS). Definition at line 29 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and EWOULDBLOCK. Referenced by accept(), ACE_ATM_Acceptor::accept(), and ACE_POSIX_Asynch_Accept::handle_input(). { ACE_OS_TRACE ("ACE_OS::accept"); // 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 /* ACE_HAS_BROKEN_ACCEPT_ADDR */ ACE_HANDLE ace_result = ::accept ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen); # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK) // Optimize this code out if we can detect that EAGAIN == // EWOULDBLOCK at compile time. If we cannot detect equality at // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor // macros) perform the check at run-time. The goal is to avoid two // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK. if (ace_result == ACE_INVALID_HANDLE # if !defined (EAGAIN) || !defined (EWOULDBLOCK) && EAGAIN != EWOULDBLOCK # endif /* !EAGAIN || !EWOULDBLOCK */ && errno == EAGAIN) { errno = EWOULDBLOCK; } # endif /* EAGAIN != EWOULDBLOCK*/ return ace_result; #endif /* defined (ACE_WIN32) */ }

ACE_INLINE int ACE_OS::access (  const wchar_t *  path, int  amode )

Definition at line 68 of file OS_NS_unistd.inl. References access(). { #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_OSCALL_RETURN (::_waccess (path, amode), int, -1); #else /* ACE_WIN32 && !ACE_HAS_WINCE */ return ACE_OS::access (ACE_Wide_To_Ascii (path).char_rep (), amode); #endif /* ACE_WIN32 && !ACE_HAS_WINCE */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::access (  const char *  path, int  amode )

Definition at line 36 of file OS_NS_unistd.inl. References access(), ACE_LIB_TEXT, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TEXT_CHAR_TO_TCHAR, fclose(), and fopen(). Referenced by access(), ACE_Filecache_Object::ACE_Filecache_Object(), ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), ACE::ldfind(), open(), and ACE_Configuration_Heap::open(). { ACE_OS_TRACE ("ACE_OS::access"); #if defined (ACE_LACKS_ACCESS) # if defined (ACE_HAS_WINCE) || defined (ACE_VXWORKS) // @@ WINCE: There should be a Win32 API that can do this. // Hard coded read access here. ACE_UNUSED_ARG (amode); FILE* handle = ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR(path), ACE_LIB_TEXT ("r")); if (handle != 0) { ACE_OS::fclose (handle); return 0; } return (-1); # else ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (amode); ACE_NOTSUP_RETURN (-1); # endif // ACE_HAS_WINCE #elif defined(ACE_WIN32) // Windows doesn't support checking X_OK(6) ACE_OSCALL_RETURN (::access (path, amode & 6), int, -1); #else ACE_OSCALL_RETURN (::access (path, amode), int, -1); #endif /* ACE_LACKS_ACCESS */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::ace_isalnum (  ACE_TCHAR  c  )

Returns true if the character is an alphanumeric character. Definition at line 13 of file OS_NS_ctype.inl. References ACE_TCHAR. Referenced by ACE_Get_Opt::long_option(). { #if defined (ACE_USES_WCHAR) return iswalnum (c); #else /* ACE_USES_WCHAR */ return isalnum ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isalpha (  ACE_TCHAR  c  )

Returns true if the character is an alphabetic character. Definition at line 23 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswalpha (c); #else /* ACE_USES_WCHAR */ return isalpha ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_iscntrl (  ACE_TCHAR  c  )

Returns true if the character is a control character. Definition at line 33 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswcntrl (c); #else /* ACE_USES_WCHAR */ return iscntrl ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isdigit (  ACE_TCHAR  c  )

Returns true if the character is a decimal-digit character. Definition at line 43 of file OS_NS_ctype.inl. References ACE_TCHAR. Referenced by ACE_SOCK_Dgram::make_multicast_ifaddr6(), and ACE_Svc_Conf_Lexer::scan(). { #if defined (ACE_USES_WCHAR) return iswdigit (c); #else /* ACE_USES_WCHAR */ return isdigit ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isgraph (  ACE_TCHAR  c  )

Returns true if the character is a printable character other than a space. Definition at line 53 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswgraph (c); #else /* ACE_USES_WCHAR */ return isgraph ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_islower (  ACE_TCHAR  c  )

Returns true if the character is a lowercase character. Definition at line 63 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswlower (c); #else /* ACE_USES_WCHAR */ return islower ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isprint (  ACE_TCHAR  c  )

Returns true if the character is a printable character. Definition at line 73 of file OS_NS_ctype.inl. References ACE_TCHAR. Referenced by ACE::format_hexdump(). { #if defined (ACE_USES_WCHAR) return iswprint (c); #else /* ACE_USES_WCHAR */ return isprint ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_ispunct (  ACE_TCHAR  c  )

Returns true if the character is a punctuation character. Definition at line 83 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswpunct (c); #else /* ACE_USES_WCHAR */ return ispunct ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isspace (  ACE_TCHAR  c  )

Returns true if the character is a space character. Definition at line 93 of file OS_NS_ctype.inl. References ACE_TCHAR. Referenced by ACE_Base64::decode(), ACE_Base64::length(), ACE_Ini_ImpExp::squish(), and string_to_argv(). { #if defined (ACE_USES_WCHAR) return iswspace (c); #else /* ACE_USES_WCHAR */ return isspace ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isupper (  ACE_TCHAR  c  )

Returns true if the character is an uppercase character. Definition at line 103 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswupper (c); #else /* ACE_USES_WCHAR */ return isupper ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_isxdigit (  ACE_TCHAR  c  )

Returns true if the character is a hexadecimal-digit character. Definition at line 113 of file OS_NS_ctype.inl. References ACE_TCHAR. { #if defined (ACE_USES_WCHAR) return iswxdigit (c); #else /* ACE_USES_WCHAR */ return isxdigit ((unsigned char) c); #endif /* ACE_USES_WCHAR */ }

ACE_INLINE int ACE_OS::ace_tolower (  int  c  )

Converts a character to lower case (char version). Definition at line 123 of file OS_NS_ctype.inl. Referenced by equal_char(), ACE_Svc_Conf_Lexer::scan(), strcasecmp_emulation(), strncasecmp_emulation(), and wcsicmp_emulation(). { return tolower (c); }

ACE_INLINE int ACE_OS::ace_toupper (  int  c  )

Converts a character to upper case (char version). Definition at line 137 of file OS_NS_ctype.inl. { return toupper (c); }

ACE_INLINE wint_t ACE_OS::ace_towlower (  wint_t  c  )

Converts a character to lower case (wchar_t version). Definition at line 130 of file OS_NS_ctype.inl. Referenced by wcsicmp_emulation(), and wcsnicmp_emulation(). { return towlower (c); }

ACE_INLINE wint_t ACE_OS::ace_towupper (  wint_t  c  )

Converts a character to upper case (wchar_t version). Definition at line 144 of file OS_NS_ctype.inl. { return towupper (c); }

ACE_INLINE u_int ACE_OS::alarm (  u_int  secs  )

Definition at line 79 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::alarm"); #if defined (ACE_LACKS_ALARM) ACE_UNUSED_ARG (secs); ACE_NOTSUP_RETURN (0); #else return ::alarm (secs); #endif /* ACE_LACKS_ALARM */ }

ACE_INLINE long ACE_OS::allocation_granularity (  void   )

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

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::argv_to_string (  ACE_TCHAR **  argv, ACE_TCHAR *&  buf, bool  substitute_env_args = true )

Definition at line 40 of file OS_NS_unistd.cpp. References ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, getenv(), strecpy(), and strlen(). Referenced by ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T(), ACE_ARGV_T< CHAR_TYPE >::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++) { #if !defined (ACE_LACKS_ENV) // Account for environment variables. if (substitute_env_args && argv[i][0] == ACE_LIB_TEXT ('$')) { # if defined (ACE_WIN32) || !defined (ACE_HAS_WCHAR) ACE_TCHAR *temp = 0; // Win32 is the only platform with a wide-char ACE_OS::getenv(). if ((temp = ACE_OS::getenv (&argv[i][1])) != 0) buf_len += ACE_OS::strlen (temp); else buf_len += ACE_OS::strlen (argv[i]); # else // This is an ACE_HAS_WCHAR platform and not ACE_WIN32. // Convert the env variable name for getenv(), then add // the length of the returned char *string. Later, when we // actually use the returned env variable value, convert it // as well. char *ctemp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&argv[i][1])); if (ctemp == 0) buf_len += ACE_OS::strlen (argv[i]); else buf_len += ACE_OS::strlen (ctemp); # endif /* ACE_WIN32 || !ACE_HAS_WCHAR */ } else #endif /* ACE_LACKS_ENV */ buf_len += ACE_OS::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++) { #if !defined (ACE_LACKS_ENV) // Account for environment variables. if (substitute_env_args && argv[j][0] == ACE_LIB_TEXT ('$')) { # if defined (ACE_WIN32) || !defined (ACE_HAS_WCHAR) // Win32 is the only platform with a wide-char ACE_OS::getenv(). ACE_TCHAR *temp = ACE_OS::getenv (&argv[j][1]); if (temp != 0) end = ACE_OS::strecpy (end, temp); else end = ACE_OS::strecpy (end, argv[j]); # else // This is an ACE_HAS_WCHAR platform and not ACE_WIN32. // Convert the env variable name for getenv(), then convert // the returned char *string back to wchar_t. char *ctemp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&argv[j][1])); if (ctemp == 0) end = ACE_OS::strecpy (end, argv[j]); else end = ACE_OS::strecpy (end, ACE_TEXT_CHAR_TO_TCHAR (ctemp)); # endif /* ACE_WIN32 || !ACE_HAS_WCHAR */ } 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE char * ACE_OS::asctime (  const struct tm *  tm  )

Definition at line 14 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. Referenced by ctime(). { ACE_OS_TRACE ("ACE_OS::asctime"); #if defined (ACE_LACKS_ASCTIME) ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (0); #else ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::asctime (t), char *, 0); #endif /* ACE_LACKS_ASCTIME */ }

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

Definition at line 26 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, asctime_r(), and 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 (ACE_HAS_SIZET_PTR_ASCTIME_R_AND_CTIME_R) ACE_OSCALL_RETURN (::asctime_r (t, buf, reinterpret_cast<size_t*>(&buflen)), char *, 0); # else ACE_OSCALL_RETURN (::asctime_r (t, buf, buflen), char *, 0); # endif /* ACE_HAS_SIZET_PTR_ASCTIME_R_AND_CTIME_R */ # endif /* ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R */ #elif defined (ACE_LACKS_ASCTIME_R) ACE_UNUSED_ARG (t); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (buflen); ACE_NOTSUP_RETURN (0); #else char *result = 0; ACE_OSCALL (ACE_STD_NAMESPACE::asctime (t), char *, 0, result); ACE_OS::strsncpy (buf, result, buflen); return buf; #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

ACE_INLINE int ACE_OS::atexit (  ACE_EXIT_HOOK  func  )

Definition at line 48 of file OS_NS_stdlib.inl. References ACE_OS_Object_Manager::at_exit(), and ACE_OS_Object_Manager::instance(). { return ACE_OS_Object_Manager::instance ()->at_exit (func); }

ACE_INLINE int ACE_OS::atoi (  const wchar_t *  s  )

Definition at line 61 of file OS_NS_stdlib.inl. References atoi(). { #if defined (ACE_WIN32) ACE_OSCALL_RETURN (::_wtoi (s), int, -1); #else /* ACE_WIN32 */ return ACE_OS::atoi (ACE_Wide_To_Ascii(s).char_rep()); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::atoi (  const char *  s  )

Definition at line 54 of file OS_NS_stdlib.inl. References atoi(). Referenced by atoi(), atop(), ACE_High_Res_Timer::get_env_global_scale_factor(), ACE_Service_Manager::init(), ACE_SOCK_Dgram::make_multicast_ifaddr6(), ACE_Logging_Strategy::parse_args(), ACE_Service_Config::parse_args_i(), ACE_Registry_ImpExp::process_previous_line_format(), and ACE_INET_Addr::set_interface(). { ACE_OSCALL_RETURN (::atoi (s), int, -1); }

ACE_INLINE void * ACE_OS::atop (  const wchar_t *  s  )

Definition at line 94 of file OS_NS_stdlib.inl. References atoi(). { # if defined (ACE_WIN64) __int64 ip = ::_wtoi64 (s); # else int ip = ACE_OS::atoi (s); # endif /* ACE_WIN64 */ void *p = reinterpret_cast<void *> (ip); return p; }

ACE_INLINE void * ACE_OS::atop (  const char *  s  )

Definition at line 76 of file OS_NS_stdlib.inl. 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 = reinterpret_cast<void *> (ip); return p; }

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

BSD-style (no QoS). Definition at line 93 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ACE_SOCKET_LEN. Referenced by ACE::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< HANDLER >::open(), ACE_SOCK_SEQPACK_Connector::shared_connect_start(), ACE_SOCK_Connector::shared_connect_start(), ACE_SOCK_SEQPACK_Acceptor::shared_open(), ACE_SOCK_Dgram::shared_open(), ACE_SOCK_Acceptor::shared_open(), and ACE_ICMP_Socket::shared_open(). { ACE_OS_TRACE ("ACE_OS::bind"); ACE_SOCKCALL_RETURN (::bind ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN) addrlen), int, -1); }

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

Definition at line 107 of file OS_NS_stdlib.inl. References ACE_COMPARE_FUNC, and ACE_NOTSUP_RETURN. { #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 */ }

void * ACE_OS::calloc (  size_t  elements, size_t  sizeof_elements )

Definition at line 38 of file OS_NS_stdlib.cpp. References ACE_CALLOC_FUNC, and ACE_MALLOC_FUNC. { #if !defined (ACE_HAS_WINCE) return ACE_CALLOC_FUNC (elements, sizeof_elements); #else // @@ This will probably not work since it doesn't consider // alignment properly. return ACE_MALLOC_FUNC (elements * sizeof_elements); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE double ACE_OS::ceil (  double  x  )

This method computes the smallest integral value not less than x. Definition at line 22 of file OS_NS_math.inl. { // This method computes the smallest integral value not less than x. if (x < 0) return static_cast<long> (x); else if (static_cast<long> (x) == x) return x; else return static_cast<long> (x) + 1; }

ACE_INLINE int ACE_OS::chdir (  const wchar_t *  path  )

Definition at line 143 of file OS_NS_unistd.inl. References chdir(). { #if defined (ACE_WIN32) ACE_OSCALL_RETURN (::_wchdir (path), int, -1); #else /* ACE_WIN32 */ return ACE_OS::chdir (ACE_Wide_To_Ascii (path).char_rep ()); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::chdir (  const char *  path  )

Definition at line 122 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and chdir(). Referenced by chdir(), ACE::daemonize(), and ACE_Process::spawn(). { ACE_OS_TRACE ("ACE_OS::chdir"); #if defined (ACE_HAS_NONCONST_CHDIR) ACE_OSCALL_RETURN (::chdir (const_cast<char *> (path)), int, -1); #elif defined (ACE_WIN32) && defined (__IBMCPP__) && (__IBMCPP__ >= 400) ACE_OSCALL_RETURN (::_chdir (const_cast<char *> (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 /* ACE_HAS_NONCONST_CHDIR */ }

void ACE_OS::cleanup_tss (  const u_int  main_thread  )

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 1152 of file OS_NS_Thread.cpp. References ACE_Base_Thread_Adapter::close_log_msg(), and TSS_Cleanup_Instance::valid(). Referenced by DllMain(), 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) { // scope the cleanup instance // Call TSS destructors for current thread. TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { cleanup->thread_exit (); } } #endif /* ACE_HAS_TSS_EMULATION || ACE_WIN32 */ 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) // Finally, free up the ACE_TSS_Cleanup instance. This method gets // called by the ACE_Object_Manager. TSS_Cleanup_Instance cleanup(TSS_Cleanup_Instance::DESTROY); if (cleanup.valid ()) { ; // the pointer deletes the Cleanup when it goes out of scope } #endif /* WIN32 || ACE_HAS_TSS_EMULATION */ #if defined (ACE_HAS_TSS_EMULATION) ACE_TSS_Emulation::tss_close (); #endif /* ACE_HAS_TSS_EMULATION */ } }

ACE_INLINE void ACE_OS::clearerr (  FILE *  fp  )

Definition at line 369 of file OS_NS_stdio.inl. Referenced by ACE_Svc_Conf_Lexer::input(). { #if defined (__ace_clearerr_hack) __ace_clearerr(fp); #else ::clearerr(fp); #endif /* __ace_clearerr_hack */ }

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

Definition at line 60 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, clock_gettime(), and clockid_t. Referenced by clock_gettime(), and gethrtime(). { ACE_OS_TRACE ("ACE_OS::clock_gettime"); #if defined (ACE_HAS_CLOCK_GETTIME) ACE_OSCALL_RETURN (::clock_gettime (clockid, ts), int, -1); #else ACE_UNUSED_ARG (clockid); ACE_UNUSED_ARG (ts); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_CLOCK_GETTIME */ }

ACE_INLINE int ACE_OS::clock_settime (  clockid_t  , const struct timespec *  )

Definition at line 73 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, clock_settime(), and clockid_t. Referenced by clock_settime(). { #if defined (ACE_HAS_CLOCK_SETTIME) # if defined (ACE_HAS_NONCONST_CLOCK_SETTIME) ACE_OSCALL_RETURN (::clock_settime (clockid, const_cast<struct timespec *>(ts)), int, -1); # else ACE_OSCALL_RETURN (::clock_settime (clockid, ts), int, -1); # endif /* ACE_HAS_NONCONST_CLOCK_SETTIME */ #else ACE_UNUSED_ARG (clockid); ACE_UNUSED_ARG (ts); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_CLOCK_SETTIME */ }

ACE_INLINE int ACE_OS::close (  ACE_HANDLE  handle  )

Definition at line 190 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, and ACE_OS_TRACE. Referenced by ACE_Filecache_Object::ACE_Filecache_Object(), ACE_Mutex::ACE_Mutex(), ACE_WIN32_Proactor::close(), ACE_TLI_Stream::close(), ACE_SPIPE::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(), ACE_SPIPE_Connector::connect(), ACE_SPIPE_Acceptor::create_new_instance(), ACE::daemonize(), dlopen(), event_init(), filesize(), flock_destroy(), fopen(), fork_exec(), ACE_Handle_Gobbler::free_handles(), ACE::get_bcast_addr(), ACE::get_ip_interfaces(), getmacaddress(), ACE_Filecache_Object::release(), ACE_Process_Options::release_handles(), sema_destroy(), 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); #else ACE_OSCALL_RETURN (::close (handle), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE void ACE_OS::closedir (  ACE_DIR *   )

Definition at line 13 of file OS_NS_dirent.inl. References ACE_DIR. Referenced by ACE_Dirent::close(), ACE_Dirent::open(), scandir_emulation(), and ACE_Dirent::~ACE_Dirent(). { #if defined (ACE_HAS_DIRENT) # if defined (ACE_WIN32) && defined (ACE_LACKS_CLOSEDIR) ACE_OS::closedir_emulation (d); delete [] d->directory_name_; delete d; # elif defined (ACE_HAS_WCLOSEDIR) && defined (ACE_USES_WCHAR) ::wclosedir (d); # else /* ACE_WIN32 && ACE_LACKS_CLOSEDIR */ ::closedir (d); # endif /* ACE_WIN32 && ACE_LACKS_CLOSEDIR */ #else /* ACE_HAS_DIRENT */ ACE_UNUSED_ARG (d); #endif /* ACE_HAS_DIRENT */ }

ACE_INLINE int ACE_OS::closesocket (  ACE_HANDLE  s  )

BSD-style (no QoS). Definition at line 102 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SHUTDOWN_WRITE, ACE_SOCKCALL_RETURN, closesocket(), and shutdown(). 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_WIN32_Asynch_Accept_Result::complete(), ACE_Asynch_Acceptor< HANDLER >::handle_accept(), ACE_Asynch_Connector< HANDLER >::handle_connect(), ACE_POSIX_Asynch_Accept::handle_input(), ACE::ipv6_enabled(), ACE_Asynch_Acceptor< HANDLER >::open(), ACE_WIN32_Asynch_Connect::post_result(), ACE_POSIX_Asynch_Connect::post_result(), ACE_AIOCB_Notify_Pipe_Manager::~ACE_AIOCB_Notify_Pipe_Manager(), and ACE_Asynch_Acceptor< HANDLER >::~ACE_Asynch_Acceptor(). { ACE_OS_TRACE ("ACE_OS::closesocket"); #if defined (ACE_WIN32) ACE_OS::shutdown (handle, ACE_SHUTDOWN_WRITE); ACE_SOCKCALL_RETURN (::closesocket ((SOCKET) handle), int, -1); #else ACE_OSCALL_RETURN (::close (handle), int, -1); #endif /* ACE_WIN32 */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE char * ACE_OS::compile (  const char *  instring, char *  expbuf, char *  endbuf )

Definition at line 11 of file OS_NS_regex.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and compile(). Referenced by compile(), ACE_Local_Name_Space<, ACE_LOCK >::list_type_entries_i(), and ACE_Local_Name_Space<, ACE_LOCK >::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  )

Definition at line 214 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, and cond_broadcast(). Referenced by ACE_Condition_Thread_Mutex::broadcast(), ACE_Condition< MUTEX >::broadcast(), ACE_Condition< ACE_Recursive_Thread_Mutex >::broadcast(), cond_broadcast(), event_destroy(), event_pulse(), event_signal(), ACE_Condition_Thread_Mutex::remove(), ACE_Condition< MUTEX >::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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_broadcast (cv), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_broadcast (cv), 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  )

Definition at line 240 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, and cond_destroy(). Referenced by cond_destroy(), event_destroy(), recursive_mutex_destroy(), ACE_Condition_Thread_Mutex::remove(), ACE_Condition< MUTEX >::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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_destroy (cv), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_destroy (cv), 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_init (  ACE_cond_t *  cv, ACE_condattr_t &  attributes, const wchar_t *  name, void *  arg = 0 )

Definition at line 317 of file OS_NS_Thread.inl. References cond_init(). { return ACE_OS::cond_init (cv, attributes, ACE_Wide_To_Ascii (name).char_rep (), arg); }

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

Definition at line 328 of file OS_NS_Thread.inl. References cond_init(). { return ACE_OS::cond_init (cv, type, ACE_Wide_To_Ascii (name).char_rep (), arg); }

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

Definition at line 262 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, cond_init(), and memset(). { // 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 defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600) && (ACE_VXWORKS <= 0x620) /* VxWorks 6.x API reference states: * If the memory for the condition variable object has been allocated * dynamically, it is a good policy to always zero out the * block of memory so as to avoid spurious EBUSY return code * when calling this routine. */ ACE_OS::memset (cv, 0, sizeof (*cv)); # endif 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_init (cv, attributes.type, arg), result), int, -1); # endif /* ACE_HAS_PTHREADS vs. ACE_HAS_STHREADS */ # 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 */ }

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

Definition at line 1810 of file OS_NS_Thread.cpp. References condattr_destroy(), and condattr_init(). Referenced by ACE_Condition< MUTEX >::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  )

Definition at line 335 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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_Thread_Mutex::signal(), ACE_Condition< MUTEX >::signal(), and ACE_Condition< ACE_Recursive_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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_signal (cv), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_signal (cv), 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 *  )

Definition at line 384 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TIMESPEC_PTR, cond_timedwait(), cond_wait(), ETIME, ETIMEDOUT, gettimeofday(), and timespec_t. Referenced by cond_timedwait(), event_timedwait(), recursive_mutex_lock(), sema_wait(), ACE_Condition_Thread_Mutex::wait(), ACE_Condition< MUTEX >::wait(), and ACE_Condition< ACE_Recursive_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 (ACE_LYNXOS_MAJOR) && (ACE_LYNXOS_MAJOR == 3) && (ACE_LYNXOS_MINOR == 0) // 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 /* ACE_LYNXOS_MAJOR ... */ } # 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); # 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 */ }

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

Definition at line 358 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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_Thread_Mutex::wait(), ACE_Condition< MUTEX >::wait(), and ACE_Condition< ACE_Recursive_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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_wait (cv, external_mutex), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_wait (cv, external_mutex), 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  )

Definition at line 132 of file OS_NS_Thread.inl. Referenced by cond_init(), and ACE_Condition_Attributes::~ACE_Condition_Attributes(). { #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; # endif /* ACE_HAS_PTHREADS vs. ACE_HAS_STHREADS */ 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 )

Definition at line 155 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, and memset(). Referenced by ACE_Condition_Attributes::ACE_Condition_Attributes(), and cond_init(). { ACE_UNUSED_ARG (type); # if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS) int result = -1; # if defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600) && (ACE_VXWORKS <= 0x620) /* Tests show that VxWorks 6.x pthread lib does not only * require zeroing of mutex/condition objects to function correctly * but also of the attribute objects. */ ACE_OS::memset (&attributes, 0, sizeof (attributes)); # endif 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_CONDATTR_PSHARED) && ACE_ADAPT_RETVAL (pthread_condattr_setpshared (&attributes, type), result) == 0 # endif /* _POSIX_THREAD_PROCESS_SHARED && ! ACE_LACKS_CONDATTR_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; # else ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (type); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PTHREADS vs. ACE_HAS_STHREADS */ # 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 )

QoS-enabled , which passes to . If the OS platform doesn't support QoS-enabled then the are ignored and the BSD-style is called. Definition at line 41 of file OS_NS_sys_socket.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, const_cast <sockaddr *> (addr), addrlen); # endif /* ACE_HAS_WINSOCK2 */ }

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

BSD-style (no QoS). Definition at line 114 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ACE_SOCKET_LEN. Referenced by ACE_SOCK_SEQPACK_Connector::connect(), ACE_SOCK_Connector::connect(), connect(), ACE_ATM_Connector::connect(), ACE_SOCK_CODgram::open(), and ACE_Ping_Socket::send_echo_check(). { ACE_OS_TRACE ("ACE_OS::connect"); ACE_SOCKCALL_RETURN (::connect ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN) addrlen), int, -1); }

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

Definition at line 16 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, 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); #else ACE_OSCALL_RETURN (::creat (ACE_TEXT_ALWAYS_CHAR (filename), mode), ACE_HANDLE, ACE_INVALID_HANDLE); #endif /* ACE_WIN32 */ }

ACE_INLINE ACE_TCHAR * ACE_OS::ctime (  const time_t *  t  )

Definition at line 92 of file OS_NS_time.inl. References ACE_OS_TRACE, ACE_TCHAR, asctime(), ctime(), ctime_buf_size, ctime_r(), and localtime(). Referenced by ctime(), and ctime_r(). { ACE_OS_TRACE ("ACE_OS::ctime"); #if defined (ACE_HAS_BROKEN_CTIME) ACE_OSCALL_RETURN (::asctime (::localtime (t)), char *, 0); #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_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wctime (t), wchar_t *, 0); #else # if defined (ACE_USES_WCHAR) /* Not Win32, else it would do the above */ char *narrow_time; ACE_OSCALL (::ctime (t), char *, 0, narrow_time); if (narrow_time == 0) return 0; // ACE_Ascii_To_Wide::convert allocates (via new []) a wchar_t[]. If // we've done this before, free the previous one. Yes, this leaves a // small memory leak (26 characters) but there's no way around this // that I know of. (Steve Huston, 12-Feb-2003). static wchar_t *wide_time = 0; if (wide_time != 0) delete [] wide_time; wide_time = ACE_Ascii_To_Wide::convert (narrow_time); return wide_time; # else ACE_OSCALL_RETURN (::ctime (t), char *, 0); # endif /* ACE_USES_WCHAR */ # endif /* ACE_HAS_BROKEN_CTIME */ }

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

Definition at line 127 of file OS_NS_time.inl. References ACE_OS_TRACE, ACE_TCHAR, ctime(), ctime_buf_size, ctime_r(), and 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) char *bufp = 0; # if defined (ACE_USES_WCHAR) char narrow_buf[ctime_buf_size]; bufp = narrow_buf; # else bufp = buf; # endif /* ACE_USES_WCHAR */ if (buflen < ctime_buf_size) { errno = ERANGE; return 0; } # if defined (ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R) # if defined (DIGITAL_UNIX) ACE_OSCALL (::_Pctime_r (t, bufp), ACE_TCHAR *, 0, bufp); # else /* DIGITAL_UNIX */ ACE_OSCALL (::ctime_r (t, bufp), char *, 0, bufp); # endif /* DIGITAL_UNIX */ # else /* ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R */ # if defined (ACE_HAS_SIZET_PTR_ASCTIME_R_AND_CTIME_R) bufp = ::ctime_r (t, bufp, reinterpret_cast<size_t*>(&buflen)); # else /* ACE_CTIME_R_RETURNS_INT */ bufp = ::ctime_r (t, bufp, buflen); # endif /* ACE_CTIME_R_RETURNS_INT */ # endif /* ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R */ if (bufp == 0) return 0; # if defined (ACE_USES_WCHAR) ACE_Ascii_To_Wide wide_buf (bufp); ACE_OS_String::strcpy (buf, wide_buf.wchar_rep ()); return buf; # else return bufp; # endif /* ACE_USES_WCHAR */ #else /* ACE_HAS_REENTRANT_FUNCTIONS */ 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_HAS_REENTRANT_FUNCTIONS */ }

ACE_INLINE wchar_t * ACE_OS::cuserid (  wchar_t *  user, size_t  maxlen = ACE_MAX_USERID )

Definition at line 480 of file OS_NS_stdio.inl. References ACE_FAIL_RETURN, ACE_NEW_RETURN, cuserid(), and strcpy(). { # if defined (ACE_WIN32) BOOL result = GetUserNameW (user, (u_long *) &maxlen); if (result == FALSE) ACE_FAIL_RETURN (0); else return user; # else /* ACE_WIN32 */ char *char_user; wchar_t *result = 0; ACE_NEW_RETURN (char_user, char[maxlen + 1], 0); if (ACE_OS::cuserid (char_user, maxlen)) { ACE_OS::strcpy (user, ACE_Ascii_To_Wide (char_user).wchar_rep ()); result = user; } delete [] char_user; return result; # endif /* ACE_WIN32 */ }

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

Definition at line 381 of file OS_NS_stdio.inl. References ACE_FAIL_RETURN, ACE_NOTSUP_RETURN, ACE_OS_TRACE, strcpy(), and strlen(). Referenced by cuserid(). { ACE_OS_TRACE ("ACE_OS::cuserid"); #if defined (ACE_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 (__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 char 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::strlen (pw->pw_name) <= max_length) { return ACE_OS::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 /* ACE_VXWORKS */ }

ACE_NAMESPACE_INLINE_FUNCTION LPSECURITY_ATTRIBUTES default_win32_security_attributes (  LPSECURITY_ATTRIBUTES   )

Default Win32 Security Attributes definition.

ACE_NAMESPACE_INLINE_FUNCTION LPSECURITY_ATTRIBUTES default_win32_security_attributes_r (  LPSECURITY_ATTRIBUTES  , LPSECURITY_ATTRIBUTES  , SECURITY_DESCRIPTOR *  )

Referenced by mmap(), and sema_init().

ACE_INLINE double ACE_OS::difftime (  time_t  t1, time_t  t0 )

Definition at line 195 of file OS_NS_time.inl. References ace_difftime(). Referenced by ACE_Filecache_Object::update(). { return ::ace_difftime (t1, t0); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::dlclose (  ACE_SHLIB_HANDLE  handle  )

Definition at line 26 of file OS_NS_dlfcn.inl. References ACE_ADAPT_RETVAL, ACE_LIB_TEXT, ACE_NOTSUP_RETURN, 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   )

Definition at line 77 of file OS_NS_dlfcn.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_CHAR_TO_TCHAR, dlerror(), sprintf(), strerror(), and strncpy(). Referenced by dlerror(), and ACE_DLL_Handle::error(). { ACE_OS_TRACE ("ACE_OS::dlerror"); # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) const char *err; # if defined(_M_UNIX) ACE_OSCALL (::_dlerror (), const char *, 0, err); # else /* _M_UNIX */ ACE_OSCALL (::dlerror (), const char *, 0, err); # endif /* _M_UNIX */ if (err == 0) return 0; # if defined (ACE_USES_WCHAR) const size_t BufLen = 256; static wchar_t buf[BufLen]; ACE_OS::strncpy (buf, ACE_TEXT_CHAR_TO_TCHAR (err), BufLen); return buf; # else return const_cast <char *> (err); # endif /* ACE_USES_WCHAR */ # elif defined (__hpux) || defined (ACE_VXWORKS) 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 )

Definition at line 119 of file OS_NS_dlfcn.inl. References ACE_DEFAULT_FILE_PERMS, ACE_LIB_TEXT, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SHLIB_HANDLE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, close(), dlsym(), last_error(), and open(). Referenced by ACE_DLL_Strategy< SVC_HANDLER >::make_svc_handler(), and ACE_DLL_Handle::open(). { ACE_OS_TRACE ("ACE_OS::dlopen"); # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) void *handle; # if defined (ACE_HAS_SGIDLADD) ACE_OSCALL (::sgidladd (ACE_TEXT_ALWAYS_CHAR (fname), mode), void *, 0, handle); # elif defined (_M_UNIX) ACE_OSCALL (::_dlopen (ACE_TEXT_ALWAYS_CHAR (fname), mode), void *, 0, handle); # else ACE_OSCALL (::dlopen (ACE_TEXT_ALWAYS_CHAR (fname), 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 (fname), ACE_SHLIB_HANDLE, 0); # elif defined (__hpux) # if defined(__GNUC__) || __cplusplus >= 199707L ACE_OSCALL_RETURN (::shl_load(fname, mode, 0L), ACE_SHLIB_HANDLE, 0); # else ACE_OSCALL_RETURN (::cxxshl_load(fname, mode, 0L), ACE_SHLIB_HANDLE, 0); # endif /* aC++ vs. Hp C++ */ # elif defined (ACE_VXWORKS) && !defined (__RTP__) MODULE* handle = 0; // Open readonly ACE_HANDLE filehandle = ACE_OS::open (fname, O_RDONLY, ACE_DEFAULT_FILE_PERMS); if (filehandle != ACE_INVALID_HANDLE) { ACE_OS::last_error(0); ACE_OSCALL ( ::loadModule (filehandle, LOAD_GLOBAL_SYMBOLS|LOAD_COMMON_MATCH_ALL ), MODULE *, 0, handle); int loaderror = ACE_OS::last_error(); ACE_OS::close (filehandle); if ( (loaderror != 0) && (handle != 0) ) { // ouch something went wrong most likely unresolved externals if (handle) ::unldByModuleId ( handle, 0 ); handle = 0; } } else { // couldn't open file handle = 0; } return handle; # else ACE_UNUSED_ARG (fname); 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 )

Definition at line 201 of file OS_NS_dlfcn.inl. References ACE_NEW_RETURN, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SHLIB_HANDLE, ACE_SHLIB_INVALID_HANDLE, ACE_TCHAR, dlsym(), strcpy(), and strlen(). Referenced by dlclose(), dlopen(), dlsym(), ACE_DLL_Strategy< SVC_HANDLER >::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) // CE (at least thru Pocket PC 2003) offers GetProcAddressW, not ...A, so // we always need a wide-char string. const wchar_t *symbolname = 0; # if defined (ACE_USES_WCHAR) symbolname = sname; # else ACE_Ascii_To_Wide sname_xlate (sname); symbolname = sname_xlate.wchar_rep (); # endif /* ACE_USES_WCHAR */ #elif defined (ACE_USES_WCHAR) // WinCE is WCHAR always; other platforms need a char * symbol name ACE_Wide_To_Ascii w_sname (sname); char *symbolname = w_sname.char_rep (); #elif defined (ACE_VXWORKS) char *symbolname = const_cast<char *> (sname); #else const char *symbolname = sname; #endif /* ACE_HAS_WINCE */ # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) # if 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_USES_ASM_SYMBOL_IN_DLSYM */ # 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; # elif defined (ACE_VXWORKS) && !defined (__RTP__) // For now we use the VxWorks global symbol table // which resolves the most recently loaded symbols .. which resolve mostly what we want.. ACE_UNUSED_ARG (handle); SYM_TYPE symtype; void *value = 0; STATUS status; ACE_OSCALL (::symFindByName(sysSymTbl, symbolname, (char **)&value, &symtype), int, -1, status); return status == OK ? 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  )

Definition at line 201 of file OS_NS_unistd.inl. References ACE_FAIL_RETURN, ACE_NOTSUP_RETURN, ACE_OS_TRACE, and dup(). Referenced by dup(), ACE_Filecache_Handle::handle(), ACE_Process_Options::set_handles(), and ACE_Process::spawn(). { 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 (ACE_LACKS_DUP) 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 )

Definition at line 229 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and dup2(). Referenced by dup2(), and ACE_Process::spawn(). { ACE_OS_TRACE ("ACE_OS::dup2"); #if defined (ACE_LACKS_DUP2) // 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_LACKS_DUP2 */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void ACE_OS::endpwent (  void   )

Definition at line 12 of file OS_NS_pwd.inl. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) ::endpwent (); #endif /* ! ACE_LACKS_PWD_FUNCTIONS */ }

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

Retrieve information about available transport protocols installed on the local machine. Windows specific... Definition at line 125 of file OS_NS_sys_socket.inl. References ACE_NOTSUP_RETURN, and 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 */ }

int ACE_OS::event_destroy (  ACE_event_t *  event  )

Definition at line 2454 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_TEXT_CHAR_TO_TCHAR, cond_broadcast(), cond_destroy(), EBUSY, free(), munmap(), mutex_destroy(), sema_destroy(), shm_unlink(), and thr_yield(). 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) if (event->eventdata_) { // mutex_destroy()/cond_destroy() are called in a loop if the object // is BUSY. This avoids conditions where we fail to destroy these // objects because at time of destroy they were just being used in // another thread possibly causing deadlocks later on if they keep // being used after we're gone. if (event->eventdata_->type_ == USYNC_PROCESS) { if (event->name_) { // Only destroy the event data if we're the ones who initialized // it. int r1, r2; # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) // first destroy the mutex so locking after this will return errors while ((r1 = ACE_OS::mutex_destroy (&event->eventdata_->lock_)) == -1 && errno == EBUSY) { ACE_OS::thr_yield (); } # else r1 = ACE_OS::sema_destroy(&event->lock_); # endif # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) // now fix event to manual reset, raise signal and broadcast until is's // possible to destroy the condition event->eventdata_->manual_reset_ = 1; while ((r2 = ACE_OS::cond_destroy (&event->eventdata_->condition_)) == -1 && errno == EBUSY) { event->eventdata_->is_signaled_ = 1; ACE_OS::cond_broadcast (&event->eventdata_->condition_); ACE_OS::thr_yield (); } # else r2 = ACE_OS::sema_destroy(&event->semaphore_); # endif ACE_OS::munmap (event->eventdata_, sizeof (ACE_eventdata_t)); ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR(event->name_)); ACE_OS::free (event->name_); return r1 != 0 || r2 != 0 ? -1 : 0; } else { ACE_OS::munmap (event->eventdata_, sizeof (ACE_eventdata_t)); # if (!defined (ACE_HAS_PTHREADS) || !defined (_POSIX_THREAD_PROCESS_SHARED) || \ (defined (ACE_LACKS_MUTEXATTR_PSHARED) && defined (ACE_LACKS_CONDATTR_PSHARED))) && \ (defined (ACE_USES_FIFO_SEM) || \ (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_TIMEOUT) && defined (ACE_LACKS_NAMED_POSIX_SEM))) ACE_OS::sema_destroy(&event->lock_); # endif # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) return 0; # else return ACE_OS::sema_destroy(&event->semaphore_); # endif } } else { int r1, r2; // first destroy the mutex so locking after this will return errors # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) // first destroy the mutex so locking after this will return errors while ((r1 = ACE_OS::mutex_destroy (&event->eventdata_->lock_)) == -1 && errno == EBUSY) { ACE_OS::thr_yield (); } # else r1 = ACE_OS::sema_destroy(&event->lock_); # endif # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) // now fix event to manual reset, raise signal and broadcast until is's // possible to destroy the condition event->eventdata_->manual_reset_ = 1; while ((r2 = ACE_OS::cond_destroy (&event->eventdata_->condition_)) == -1 && errno == EBUSY) { event->eventdata_->is_signaled_ = 1; ACE_OS::cond_broadcast (&event->eventdata_->condition_); ACE_OS::thr_yield (); } # else r2 = ACE_OS::sema_destroy(&event->semaphore_); # endif delete event->eventdata_; return r1 != 0 || r2 != 0 ? -1 : 0; } } return 0; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

ACE_INLINE 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 )

Definition at line 469 of file OS_NS_Thread.inl. References ACE_FAIL_RETURN, and event_init(). { #if defined (ACE_WIN32) ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (arg); SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; *event = ::CreateEventW (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), manual_reset, initial_state, name); if (*event == 0) ACE_FAIL_RETURN (-1); return 0; #else /* ACE_WIN32 */ return ACE_OS::event_init (event, manual_reset, initial_state, type, ACE_Wide_To_Ascii (name).char_rep (), arg, sa); #endif /* ACE_WIN32 */ }

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 )

Definition at line 2577 of file OS_NS_Thread.cpp. References ACE_DEFAULT_FILE_PERMS, ACE_FAIL_RETURN, ACE_NEW_RETURN, ACE_NOTSUP_RETURN, ACE_TEXT_CHAR_TO_TCHAR, close(), cond_init(), ftruncate(), MAP_FAILED, MAP_SHARED, mmap(), mutex_init(), PROT_RDWR, sema_init(), sema_post(), shm_open(), shm_unlink(), strcat(), strdup(), and strncpy(). Referenced by ACE_Event::ACE_Event(), event_init(), and sema_init(). { #if defined (ACE_WIN32) ACE_UNUSED_ARG (type); ACE_UNUSED_ARG (arg); SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; # if defined (ACE_HAS_WINCE) // @@todo (brunsch) This idea should be moved into ACE_OS_Win32. *event = ::CreateEventW (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), manual_reset, initial_state, ACE_Ascii_To_Wide (name).wchar_rep ()); # else /* ACE_HAS_WINCE */ *event = ::CreateEventA (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), 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->eventdata_ = 0; ACE_eventdata_t* evtdata; if (type == USYNC_PROCESS) { int owner = 0; // Let's see if the shared memory entity already exists. ACE_HANDLE fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (name), O_RDWR | O_CREAT | O_EXCL, ACE_DEFAULT_FILE_PERMS); if (fd == ACE_INVALID_HANDLE) { if (errno == EEXIST) fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (name), O_RDWR | O_CREAT, ACE_DEFAULT_FILE_PERMS); if (fd == ACE_INVALID_HANDLE) // Still can't get it. return -1; } else { // We own this shared memory object! Let's set its size. if (ACE_OS::ftruncate (fd, sizeof (ACE_eventdata_t)) == -1) { ACE_OS::close (fd); return -1; } owner = 1; } evtdata = (ACE_eventdata_t *) ACE_OS::mmap (0, sizeof (ACE_eventdata_t), PROT_RDWR, MAP_SHARED, fd, 0); ACE_OS::close (fd); if (evtdata == MAP_FAILED) { if (owner) ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR (name)); return -1; } if (owner) { event->name_ = ACE_OS::strdup (name); if (event->name_ == 0) { ACE_OS::shm_unlink (ACE_TEXT_CHAR_TO_TCHAR (name)); return -1; } event->eventdata_ = evtdata; event->eventdata_->type_ = type; event->eventdata_->manual_reset_ = manual_reset; event->eventdata_->is_signaled_ = initial_state; event->eventdata_->auto_event_signaled_ = false; event->eventdata_->waiting_threads_ = 0; event->eventdata_->signal_count_ = 0; # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) int result = ACE_OS::cond_init (&event->eventdata_->condition_, static_cast<short> (type), name, arg); # else char sem_name[128]; ACE_OS::strncpy (sem_name, name, sizeof (sem_name) - (1 + sizeof ("._ACE_EVTSEM_"))); ACE_OS::strcat (sem_name, "._ACE_EVTSEM_"); int result = ACE_OS::sema_init (&event->semaphore_, 0, type, sem_name, arg); # endif if (result == 0) # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) result = ACE_OS::mutex_init (&event->eventdata_->lock_, type, name, (ACE_mutexattr_t *) arg); # else { char lck_name[128]; ACE_OS::strncpy (lck_name, name, sizeof (lck_name) - (1 + sizeof ("._ACE_EVTLCK_"))); ACE_OS::strcat (lck_name, "._ACE_EVTLCK_"); result = ACE_OS::sema_init (&event->lock_, 0, type, lck_name, arg); if (result == 0) result = ACE_OS::sema_post (&event->lock_); /* Initially unlock */ } # endif return result; } else { int result = 0; event->name_ = 0; event->eventdata_ = evtdata; #if (!defined (ACE_HAS_PTHREADS) || !defined (_POSIX_THREAD_PROCESS_SHARED) || defined (ACE_LACKS_CONDATTR_PSHARED)) && \ (defined (ACE_USES_FIFO_SEM) || \ (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_SEM_TIMEOUT) && !defined (ACE_LACKS_NAMED_POSIX_SEM))) char sem_name[128]; ACE_OS::strncpy (sem_name, name, sizeof (sem_name) - (1 + sizeof ("._ACE_EVTSEM_"))); ACE_OS::strcat (sem_name, "._ACE_EVTSEM_"); result = ACE_OS::sema_init(&event->semaphore_, 0, type, sem_name, arg); # endif # if (!defined (ACE_HAS_PTHREADS) || !defined (_POSIX_THREAD_PROCESS_SHARED) || \ (defined (ACE_LACKS_MUTEXATTR_PSHARED) && defined (ACE_LACKS_CONDATTR_PSHARED))) && \ (defined (ACE_USES_FIFO_SEM) || \ (defined (ACE_HAS_POSIX_SEM) && defined (ACE_HAS_POSIX_TIMEOUT) && defined (ACE_LACKS_NAMED_POSIX_SEM))) if (result == 0) { char lck_name[128]; ACE_OS::strncpy (lck_name, name, sizeof (lck_name) - (1 + sizeof ("._ACE_EVTLCK_"))); ACE_OS::strcat (lck_name, "._ACE_EVTLCK_"); result = ACE_OS::sema_init (&event->lock_, 0, type, lck_name, arg); } # endif return result; } return 0; } else { ACE_NEW_RETURN (evtdata, ACE_eventdata_t, -1); event->name_ = 0; event->eventdata_ = evtdata; event->eventdata_->type_ = type; event->eventdata_->manual_reset_ = manual_reset; event->eventdata_->is_signaled_ = initial_state; event->eventdata_->auto_event_signaled_ = false; event->eventdata_->waiting_threads_ = 0; event->eventdata_->signal_count_ = 0; # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) int result = ACE_OS::cond_init (&event->eventdata_->condition_, static_cast<short> (type), name, arg); # else int result = ACE_OS::sema_init (&event->semaphore_, 0, type, name, arg); # endif if (result == 0) # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) result = ACE_OS::mutex_init (&event->eventdata_->lock_, type, name, (ACE_mutexattr_t *) arg); # else result = ACE_OS::sema_init (&event->lock_, 0, type, name, arg); if (result == 0) result = ACE_OS::sema_post(&event->lock_); /* initially unlock */ # endif 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 */ }

int ACE_OS::event_pulse (  ACE_event_t *  event  )

Definition at line 2823 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, cond_broadcast(), cond_signal(), mutex_lock(), mutex_unlock(), sema_post(), sema_wait(), and thr_yield(). 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 (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0) # else if (ACE_OS::sema_wait (&event->lock_) == 0) # endif { if (event->eventdata_->waiting_threads_ > 0) { // Manual-reset event. if (event->eventdata_->manual_reset_ == 1) { // Wakeup all waiters. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::cond_broadcast (&event->eventdata_->condition_) != 0) { result = -1; error = errno; } if (result == 0) event->eventdata_->signal_count_ = event->eventdata_->waiting_threads_; # else event->eventdata_->signal_count_ = event->eventdata_->waiting_threads_; for (unsigned long i=0; i<event->eventdata_->signal_count_ ;++i) if (ACE_OS::sema_post(&event->semaphore_) != 0) { event->eventdata_->signal_count_ = 0; result = -1; error = errno; } if (result == 0) while(event->eventdata_->signal_count_!=0 && event->eventdata_->waiting_threads_!=0) ACE_OS::thr_yield (); # endif } // Auto-reset event: wakeup one waiter. else { # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::cond_signal (&event->eventdata_->condition_) != 0) # else if (ACE_OS::sema_post(&event->semaphore_) != 0) # endif { result = -1; error = errno; } event->eventdata_->auto_event_signaled_ = true; } } // Reset event. event->eventdata_->is_signaled_ = 0; // Now we can let go of the lock. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) ACE_OS::mutex_unlock (&event->eventdata_->lock_); # else ACE_OS::sema_post (&event->lock_); # endif 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::event_reset (  ACE_event_t *  event  )

Definition at line 2917 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, mutex_lock(), mutex_unlock(), sema_post(), and sema_wait(). 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 (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0) # else if (ACE_OS::sema_wait (&event->lock_) == 0) # endif { // Reset event. event->eventdata_->is_signaled_ = 0; event->eventdata_->auto_event_signaled_ = false; // Now we can let go of the lock. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) ACE_OS::mutex_unlock (&event->eventdata_->lock_); # else ACE_OS::sema_post (&event->lock_); # endif } else result = -1; return result; #else ACE_UNUSED_ARG (event); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 */ }

int ACE_OS::event_signal (  ACE_event_t *  event  )

Definition at line 2958 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, cond_broadcast(), cond_signal(), mutex_lock(), mutex_unlock(), sema_post(), and sema_wait(). 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 (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0) # else if (ACE_OS::sema_wait (&event->lock_) == 0) # endif { // Manual-reset event. if (event->eventdata_->manual_reset_ == 1) { // wakeup all # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::cond_broadcast (&event->eventdata_->condition_) != 0) { result = -1; error = errno; } # else if (ACE_OS::sema_post(&event->semaphore_) != 0) { result = -1; error = errno; } # endif if (result == 0) // signal event event->eventdata_->is_signaled_ = 1; } // Auto-reset event else { if (event->eventdata_->waiting_threads_ == 0) // No waiters: signal event. event->eventdata_->is_signaled_ = 1; // Waiters: wakeup one waiter. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) else if (ACE_OS::cond_signal (&event->eventdata_->condition_) != 0) # else else if (ACE_OS::sema_post(&event->semaphore_) != 0) # endif { result = -1; error = errno; } event->eventdata_->auto_event_signaled_ = true; } // Now we can let go of the lock. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) ACE_OS::mutex_unlock (&event->eventdata_->lock_); # else ACE_OS::sema_post (&event->lock_); # endif 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::event_timedwait (  ACE_event_t *  event, ACE_Time_Value *  timeout, int  use_absolute_time = 1 )

Definition at line 3047 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, cond_timedwait(), ETIME, ETIMEDOUT, gettimeofday(), ACE_Time_Value::msec(), mutex_lock(), mutex_unlock(), ACE_Time_Value::sec(), sema_post(), sema_wait(), set_errno_to_last_error(), and ACE_Time_Value::usec(). 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 (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0) # else if (ACE_OS::sema_wait (&event->lock_) == 0) # endif { if (event->eventdata_->is_signaled_ == 1) // event is currently signaled { if (event->eventdata_->manual_reset_ == 0) { // AUTO: reset state event->eventdata_->is_signaled_ = 0; event->eventdata_->auto_event_signaled_ = false; } } else // event is currently not signaled { event->eventdata_->waiting_threads_++; ACE_Time_Value absolute_timeout = *timeout; // cond_timewait() expects absolute time, check // <use_absolute_time> flag. if (use_absolute_time == 0) absolute_timeout += ACE_OS::gettimeofday (); while (event->eventdata_->is_signaled_ == 0 && event->eventdata_->auto_event_signaled_ == false) { # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::cond_timedwait (&event->eventdata_->condition_, &event->eventdata_->lock_, &absolute_timeout) != 0) { result = -1; error = errno; break; } if (event->eventdata_->signal_count_ > 0) { event->eventdata_->signal_count_--; break; } # else # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_unlock (&event->eventdata_->lock_) != 0) # else if (ACE_OS::sema_post (&event->lock_) != 0) # endif { event->eventdata_->waiting_threads_--; return -1; } if (ACE_OS::sema_wait(&event->semaphore_, absolute_timeout) !=0) { result = -1; if (errno == ETIMEDOUT) // Semaphores time out with ETIMEDOUT (POSIX) error = ETIME; else error = errno; } bool signalled = false; if (result == 0 && event->eventdata_->signal_count_ > 0) { event->eventdata_->signal_count_--; signalled = true; } # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) != 0) # else if (ACE_OS::sema_wait (&event->lock_) != 0) # endif { event->eventdata_->waiting_threads_--; // yes, I know it's not save return -1; } if (result) break; if (event->eventdata_->manual_reset_ == 1 && event->eventdata_->is_signaled_ == 1) if (ACE_OS::sema_post(&event->semaphore_) != 0) { result = -1; error = errno; break; } if (signalled) break; # endif } // Reset the auto_event_signaled_ to false now that we have // woken up. if (event->eventdata_->auto_event_signaled_ == true) event->eventdata_->auto_event_signaled_ = false; event->eventdata_->waiting_threads_--; } // Now we can let go of the lock. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) ACE_OS::mutex_unlock (&event->eventdata_->lock_); # else ACE_OS::sema_post (&event->lock_); # endif 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 */ }

int ACE_OS::event_wait (  ACE_event_t *  event  )

Definition at line 3247 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, cond_wait(), mutex_lock(), mutex_unlock(), sema_post(), sema_wait(), 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 (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) == 0) # else if (ACE_OS::sema_wait (&event->lock_) == 0) # endif { if (event->eventdata_->is_signaled_ == 1) // Event is currently signaled. { if (event->eventdata_->manual_reset_ == 0) // AUTO: reset state event->eventdata_->is_signaled_ = 0; } else // event is currently not signaled { event->eventdata_->waiting_threads_++; while (event->eventdata_->is_signaled_ == 0 && event->eventdata_->auto_event_signaled_ == false) { # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::cond_wait (&event->eventdata_->condition_, &event->eventdata_->lock_) != 0) { result = -1; error = errno; // Something went wrong... break; } if (event->eventdata_->signal_count_ > 0) { event->eventdata_->signal_count_--; break; } # else # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_unlock (&event->eventdata_->lock_) != 0) # else if (ACE_OS::sema_post (&event->lock_) != 0) # endif { event->eventdata_->waiting_threads_--; return -1; } if (ACE_OS::sema_wait(&event->semaphore_) !=0) { result = -1; error = errno; } bool signalled = false; if (result == 0 && event->eventdata_->signal_count_ > 0) { event->eventdata_->signal_count_--; signalled = true; } # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED)) || \ (!defined (ACE_USES_FIFO_SEM) && (!defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_NAMED_POSIX_SEM))) if (ACE_OS::mutex_lock (&event->eventdata_->lock_) != 0) # else if (ACE_OS::sema_wait (&event->lock_) != 0) # endif { event->eventdata_->waiting_threads_--; return -1; } if (result) break; if (event->eventdata_->manual_reset_ == 1 && event->eventdata_->is_signaled_ == 1) if (ACE_OS::sema_post(&event->semaphore_) != 0) { result = -1; error = errno; break; } if (signalled) break; # endif } // Reset it since we have woken up. if (event->eventdata_->auto_event_signaled_ == true) event->eventdata_->auto_event_signaled_ = false; event->eventdata_->waiting_threads_--; } // Now we can let go of the lock. # if (defined (ACE_HAS_PTHREADS) && defined (_POSIX_THREAD_PROCESS_SHARED) && \ (!defined (ACE_LACKS_MUTEXATTR_PSHARED) || !defined (ACE_LACKS_CONDATTR_PSHARED))) || \ (!defined (ACE_USES_FIFO_SEM) && \ (!defined (ACE_HAS_POSIX_SEM) || !defined (ACE_HAS_POSIX_TIMEOUT) || defined (ACE_LACKS_NAMED_POSIX_SEM))) ACE_OS::mutex_unlock (&event->eventdata_->lock_); # else ACE_OS::sema_post (&event->lock_); # endif 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, ...  )

Definition at line 138 of file OS_NS_unistd.cpp. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::execl"); ACE_NOTSUP_RETURN (-1); // Need to write this code. // ACE_OSCALL_RETURN (::execv (path, argv), int, -1); }

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

Definition at line 147 of file OS_NS_unistd.cpp. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::execle"); ACE_NOTSUP_RETURN (-1); // Need to write this code. // ACE_OSCALL_RETURN (::execve (path, argv, envp), int, -1); }

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

Definition at line 156 of file OS_NS_unistd.cpp. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::execlp"); ACE_NOTSUP_RETURN (-1); // Need to write this code. // ACE_OSCALL_RETURN (::execvp (file, argv), int, -1); }

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

Definition at line 243 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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 (ACE_WIN32) # if defined (__BORLANDC__) /* VSB */ return ::execv (path, argv); # elif defined (__MINGW32__) return ::_execv (path, (char *const *) argv); # else // Why this odd-looking code? If execv() returns at all, it's an error. // Windows defines this as returning an intptr_t rather than a simple int, // and the conversion triggers compile warnings. So just return -1 if // the call returns. ::_execv (path, (const char *const *) argv); return -1; # endif /* __BORLANDC__ */ #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[] )

Definition at line 271 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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 (ACE_WIN32) # if defined (__BORLANDC__) /* VSB */ return ::execve (path, argv, envp); # elif defined (__MINGW32__) return ::_execve (path, (char *const *) argv, (char *const *) envp); # else // Why this odd-looking code? If execv() returns at all, it's an error. // Windows defines this as returning an intptr_t rather than a simple int, // and the conversion triggers compile warnings. So just return -1 if // the call returns. ::_execve (path, (const char *const *) argv, (const char *const *) envp); return -1; # endif /* __BORLANDC__ */ #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[] )

Definition at line 301 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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 (ACE_WIN32) # if defined (__BORLANDC__) /* VSB */ return ::execvp (file, argv); # elif defined (__MINGW32__) return ::_execvp (file, (char *const *) argv); # else // Why this odd-looking code? If execv() returns at all, it's an error. // Windows defines this as returning an intptr_t rather than a simple int, // and the conversion triggers compile warnings. So just return -1 if // the call returns. ::_execvp (file, (const char *const *) argv); return -1; # endif /* __BORLANDC__ */ #else ACE_OSCALL_RETURN (::execvp (file, argv), int, -1); #endif /* ACE_LACKS_EXEC */ }

void ACE_OS::exit (  int  status = 0  )

Definition at line 50 of file OS_NS_stdlib.cpp. References ACE_OS_TRACE, and exit_hook_. Referenced by abort(), ACE::daemonize(), fork_exec(), ACE_Svc_Conf_Lexer::input(), 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); # 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 )

Definition at line 81 of file OS_NS_stropts.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and fattach(). Referenced by 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  )

Definition at line 509 of file OS_NS_stdio.inl. References ACE_OS_TRACE. Referenced by access(), ACE::count_interfaces(), ACE_Ini_ImpExp::export_config(), ACE_Registry_ImpExp::export_config(), ACE::get_ip_interfaces(), ACE_Capabilities::getent(), ACE_Logging_Strategy::handle_timeout(), ACE_Ini_ImpExp::import_config(), ACE_Registry_ImpExp::import_config(), ACE_Logging_Strategy::init(), ACE_Log_Msg::msg_ostream(), ACE_Service_Config::open_i(), ACE_Service_Gestalt::process_file(), ACE_Log_Msg::~ACE_Log_Msg(), and ACE_Read_Buffer::~ACE_Read_Buffer(). { ACE_OS_TRACE ("ACE_OS::fclose"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fclose (fp), int, -1); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::fcntl (  ACE_HANDLE  handle, int  cmd, long  arg = 0 )

Definition at line 10 of file OS_NS_fcntl.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and fcntl(). Referenced by ACE::clr_flags(), ACE_IPC_SAP::disable(), ACE_IO_SAP::disable(), ACE_IPC_SAP::enable(), ACE_IO_SAP::enable(), fcntl(), ACE::get_flags(), ACE_Select_Reactor_Notify::open(), ACE_Dev_Poll_Reactor_Notify::open(), sema_init(), sema_trywait(), and ACE::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  )

Definition at line 95 of file OS_NS_stropts.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 516 of file OS_NS_stdio.inl. References ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, and ACE_TEXT_ALWAYS_WCHAR. { ACE_OS_TRACE ("ACE_OS::fdopen"); # if defined (ACE_HAS_WINCE) ACE_OSCALL_RETURN (::_wfdopen (handle, ACE_TEXT_ALWAYS_WCHAR (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_LACKS_INTPTR_T) int crt_handle = ::_open_osfhandle (long (handle), 0); #else int crt_handle = ::_open_osfhandle (intptr_t (handle), 0); #endif if (crt_handle != -1) { # if defined(ACE_HAS_NONCONST_FDOPEN) && !defined (ACE_USES_WCHAR) file = ::_fdopen (crt_handle, const_cast<ACE_TCHAR *> (mode)); # elif defined (ACE_HAS_NONCONST_FDOPEN) && defined (ACE_USES_WCHAR) file = ::_wfdopen (crt_handle, const_cast<ACE_TCHAR *> (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; # else ACE_OSCALL_RETURN (::fdopen (handle, ACE_TEXT_ALWAYS_CHAR (mode)), FILE *, 0); # endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::fflush (  FILE *  fp  )

Definition at line 565 of file OS_NS_stdio.inl. References ACE_OS_TRACE. Referenced by ACE_Log_Record::print(). { ACE_OS_TRACE ("ACE_OS::fflush"); #if defined (ACE_VXWORKS) if (fp == 0) { // Do not allow fflush(0) on VxWorks return 0; } #endif /* ACE_VXWORKS */ ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fflush (fp), int, -1); }

ACE_INLINE int ACE_OS::fgetc (  FILE *  fp  )

Definition at line 580 of file OS_NS_stdio.inl. { ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetc (fp), int, -1); }

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

Definition at line 586 of file OS_NS_stdio.inl. { ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetpos (fp, pos), int, -1); }

ACE_INLINE wchar_t * ACE_OS::fgets (  wchar_t *  buf, int  size, FILE *  fp )

Definition at line 600 of file OS_NS_stdio.inl. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::fgets"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgetws (buf, size, fp), wchar_t *, 0); }

ACE_INLINE char * ACE_OS::fgets (  char *  buf, int  size, FILE *  fp )

Definition at line 592 of file OS_NS_stdio.inl. References ACE_OS_TRACE. Referenced by ACE_Ini_ImpExp::import_config(), and ACE_Registry_ImpExp::import_config(). { ACE_OS_TRACE ("ACE_OS::fgets"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fgets (buf, size, fp), char *, 0); }

ACE_NAMESPACE_INLINE_FUNCTION wint_t fgetwc (  FILE *  fp  )

ACE_INLINE ACE_LOFF_T ACE_OS::filesize (  const ACE_TCHAR *  handle  )

Definition at line 107 of file OS_NS_sys_stat.inl. References ACE_LOFF_T, 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) { ACE_LOFF_T size = ACE_OS::filesize (h); ACE_OS::close (h); return size; } else return -1; }

ACE_INLINE ACE_LOFF_T ACE_OS::filesize (  ACE_HANDLE  handle  )

Definition at line 99 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, ACE_stat, and fstat(). 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"); ACE_stat sb; return ACE_OS::fstat (handle, &sb) == -1 ? -1 : sb.st_size; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void ACE_OS::flock_adjust_params (  ace_flock_t *  lock, short  whence, off_t &  start, off_t &  len )

Definition at line 26 of file OS_NS_stdio.inl. References ACE_OS::ace_flock_t::handle_, and ACE_OS::ace_flock_t::overlapped_. Referenced by flock_rdlock(), flock_tryrdlock(), flock_trywrlock(), flock_unlock(), and flock_wrlock(). { switch (whence) { case SEEK_SET: break; case SEEK_CUR: start += SetFilePointer (lock->handle_, 0, 0, FILE_CURRENT); break; case SEEK_END: start += ::GetFileSize (lock->handle_, 0); break; } lock->overlapped_.Offset = start; if (len == 0) len = ::GetFileSize (lock->handle_, 0) - start; }

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

Definition at line 115 of file OS_NS_stdio.inl. References ACE_OS_TRACE, close(), flock_unlock(), free(), ACE_OS::ace_flock_t::handle_, ACE_OS::ace_flock_t::lockname_, 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 (lock->lockname_ != 0) { if (unlink_file) ACE_OS::unlink (lock->lockname_); ACE_OS::free ( static_cast<void *> (const_cast<ACE_TCHAR *> (lock->lockname_))); } lock->lockname_ = 0; } return 0; }

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

Definition at line 50 of file OS_NS_stdio.inl. References ACE_OS_TRACE, ACE_TCHAR, ACE_OS::ace_flock_t::handle_, ACE_OS::ace_flock_t::lockname_, mode_t, ACE_OS::ace_flock_t::overlapped_, and strdup(). Referenced by ACE_File_Lock::ACE_File_Lock(), and ACE_File_Lock::open(). { ACE_OS_TRACE ("ACE_OS::flock_init"); #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_); if (lock->handle_ != ACE_INVALID_HANDLE) lock->lockname_ = ACE_OS::strdup (name); return lock->handle_ == ACE_INVALID_HANDLE ? -1 : 0; } else return 0; }

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

Definition at line 138 of file OS_NS_stdio.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, flock_adjust_params(), ACE_OS::ace_flock_t::handle_, 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::flock_adjust_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 (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, reinterpret_cast<long> (&lock->lock_)), int, -1); #endif /* ACE_WIN32 */ }

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

Definition at line 181 of file OS_NS_stdio.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, EBUSY, flock_adjust_params(), ACE_OS::ace_flock_t::handle_, 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::flock_adjust_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 (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, reinterpret_cast<long> (&lock->lock_)), int, -1, result); if (result == -1 && (errno == EACCES || errno == EAGAIN)) errno = EBUSY; return result; #endif /* ACE_WIN32 */ }

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

Definition at line 230 of file OS_NS_stdio.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, EBUSY, flock_adjust_params(), ACE_OS::ace_flock_t::handle_, 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::flock_adjust_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 (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, reinterpret_cast<long> (&lock->lock_)), int, -1, result); if (result == -1 && (errno == EACCES || errno == EAGAIN)) errno = EBUSY; return result; #endif /* ACE_WIN32 */ }

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

Definition at line 81 of file OS_NS_stdio.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, flock_adjust_params(), ACE_OS::ace_flock_t::handle_, 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::flock_adjust_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 (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, reinterpret_cast<long> (&lock->lock_)), int, -1); #endif /* ACE_WIN32 */ }

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

Definition at line 280 of file OS_NS_stdio.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, flock_adjust_params(), ACE_OS::ace_flock_t::handle_, 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::flock_adjust_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 (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, reinterpret_cast<long> (&lock->lock_)), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE double ACE_OS::floor (  double  x  )

This method computes the largest integral value not greater than x. Definition at line 10 of file OS_NS_math.inl. { // This method computes the largest integral value not greater than x. if(x > 0) return static_cast<long> (x); else if (static_cast<long> (x) == x) return x; else return static_cast<long>(x) - 1; }

FILE * ACE_OS::fopen (  const wchar_t *  filename, const ACE_TCHAR *  mode )

Definition at line 164 of file OS_NS_stdio.cpp. References _O_TEXT, ACE_OS_TRACE, ACE_TCHAR, close(), fopen_mode_to_open_mode_converter(), and open(). { 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) { hmode &= _O_TEXT | _O_RDONLY | _O_APPEND; # if defined (ACE_LACKS_INTPTR_T) int fd = ::_open_osfhandle (long (handle), hmode); # else int fd = ::_open_osfhandle (intptr_t (handle), hmode); # endif if (fd != -1) { # if defined (__BORLANDC__) && !defined (ACE_USES_WCHAR) FILE *fp = ::_fdopen (fd, const_cast<char *> (mode)); # elif defined (__BORLANDC__) && defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, const_cast<wchar_t *> (mode)); # elif defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, mode); # else FILE *fp = ::fdopen (fd, mode); # endif /* defined(__BORLANDC__) && !defined (ACE_USES_WCHAR)) */ if (fp != 0) { # if defined (ACE_USES_WCHAR) checkUnicodeFormat(fp); # endif // ACE_USES_WCHAR return fp; } ::_close (fd); } ACE_OS::close (handle); } return 0; }

FILE * ACE_OS::fopen (  const char *  filename, const ACE_TCHAR *  mode )

Definition at line 116 of file OS_NS_stdio.cpp. References _O_TEXT, ACE_OS_TRACE, ACE_TCHAR, close(), fopen_mode_to_open_mode_converter(), and open(). Referenced by access(), ACE::count_interfaces(), ACE_Ini_ImpExp::export_config(), ACE_Registry_ImpExp::export_config(), ACE::get_ip_interfaces(), ACE_Capabilities::getent(), ACE_Logging_Strategy::handle_timeout(), ACE_Ini_ImpExp::import_config(), ACE_Registry_ImpExp::import_config(), ACE_Logging_Strategy::init(), ACE::ldopen(), ACE_Service_Config::open_i(), and ACE_Service_Gestalt::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) { hmode &= _O_TEXT | _O_RDONLY | _O_APPEND; # if defined (ACE_LACKS_INTPTR_T) int fd = ::_open_osfhandle (long (handle), hmode); # else int fd = ::_open_osfhandle (intptr_t (handle), hmode); # endif if (fd != -1) { # if defined (__BORLANDC__) && !defined (ACE_USES_WCHAR) FILE *fp = ::_fdopen (fd, const_cast<ACE_TCHAR *> (mode)); # elif defined (__BORLANDC__) && defined (ACE_USES_WCHAR) FILE *fp = ::_wfdopen (fd, const_cast<ACE_TCHAR *> (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); } ACE_OS::close (handle); } return 0; }

ACE_INLINE void ACE_OS::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. Definition at line 324 of file OS_NS_stdio.inl. References _O_BINARY, _O_TEXT, ACE_BIT_DISABLED, ACE_CLR_BITS, ACE_LIB_TEXT, ACE_SET_BITS, and ACE_TCHAR. Referenced by fopen(). { switch (x) { case ACE_LIB_TEXT ('r'): if (ACE_BIT_DISABLED (hmode, _O_RDWR)) { ACE_CLR_BITS (hmode, _O_WRONLY); ACE_SET_BITS (hmode, _O_RDONLY); } break; case ACE_LIB_TEXT ('w'): if (ACE_BIT_DISABLED (hmode, _O_RDWR)) { ACE_CLR_BITS (hmode, _O_RDONLY); ACE_SET_BITS (hmode, _O_WRONLY); } ACE_SET_BITS (hmode, _O_CREAT | _O_TRUNC); break; case ACE_LIB_TEXT ('a'): if (ACE_BIT_DISABLED (hmode, _O_RDWR)) { ACE_CLR_BITS (hmode, _O_RDONLY); ACE_SET_BITS (hmode, _O_WRONLY); } ACE_SET_BITS (hmode, _O_CREAT | _O_APPEND); break; case ACE_LIB_TEXT ('+'): ACE_CLR_BITS (hmode, _O_RDONLY | _O_WRONLY); ACE_SET_BITS (hmode, _O_RDWR); break; case ACE_LIB_TEXT ('t'): ACE_CLR_BITS (hmode, _O_BINARY); ACE_SET_BITS (hmode, _O_TEXT); break; case ACE_LIB_TEXT ('b'): ACE_CLR_BITS (hmode, _O_TEXT); ACE_SET_BITS (hmode, _O_BINARY); break; } }

pid_t ACE_OS::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. Definition at line 165 of file OS_NS_unistd.cpp. References ACE_NOTSUP_RETURN, 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   )

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 329 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and pid_t. Referenced by ACE::daemonize(), 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[]  )

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 192 of file OS_NS_unistd.cpp. References ACE_NEW_NORETURN, ACE_TCHAR, argv_to_string(), close(), execv(), exit(), fork(), 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; # else pid_t result = ACE_OS::fork (); # if defined (ACE_USES_WCHAR) // Wide-char builds need to convert the command-line args to // narrow char strings for execv(). char **cargv; int arg_count; # endif /* ACE_HAS_WCHAR */ switch (result) { case -1: // Error. return -1; case 0: // Child process. # if defined (ACE_USES_WCHAR) for (arg_count = 0; argv[arg_count] != 0; ++arg_count) ; ++arg_count; // Need a 0-pointer end-of-array marker ACE_NEW_NORETURN (cargv, char*[arg_count]); if (cargv == 0) ACE_OS::exit (errno); --arg_count; // Back to 0-indexed cargv[arg_count] = 0; while (--arg_count >= 0) cargv[arg_count] = ACE_Wide_To_Ascii::convert (argv[arg_count]); // Don't worry about freeing the cargv or the strings it points to. // Either the process will be replaced, or we'll exit. if (ACE_OS::execv (cargv[0], cargv) == -1) ACE_OS::exit (errno); # else 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); } # endif /* ACE_HAS_WCHAR */ default: // Server process. The fork succeeded. return result; } # endif /* ACE_WIN32 */ }

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

Definition at line 227 of file OS_NS_stdio.cpp. References ACE_NOTSUP_RETURN, and 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 (ACE_STD_NAMESPACE::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, ...  )

Definition at line 214 of file OS_NS_stdio.cpp. References ACE_OS_TRACE. Referenced by ACE_Service_Type::dump(), ACE_ATM_Stream::get_vpi_vci(), ACE_Svc_Conf_Lexer::input(), ACE_Service_Gestalt::insert(), ACE_Log_Msg::log(), ACE_Service_Config::open_i(), 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 wchar_t *  s, FILE *  stream )

Definition at line 645 of file OS_NS_stdio.inl. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::fputs"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fputws (s, stream), int, -1); }

ACE_INLINE int ACE_OS::fputs (  const char *  s, FILE *  stream )

Definition at line 637 of file OS_NS_stdio.inl. References ACE_OS_TRACE. Referenced by ACE_Ini_ImpExp::export_section(), and ACE_Registry_ImpExp::export_section(). { ACE_OS_TRACE ("ACE_OS::fputs"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fputs (s, stream), int, -1); }

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

Definition at line 653 of file OS_NS_stdio.inl. References ACE_OS_TRACE. Referenced by ACE_Svc_Conf_Lexer::input(). { ACE_OS_TRACE ("ACE_OS::fread"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fread (ptr, size, nelems, fp), size_t, 0); }

void ACE_OS::free (  void *   )

Definition at line 76 of file OS_NS_stdlib.cpp. References ACE_FREE_FUNC, and ACE_MALLOC_T. Referenced by ACE_ARGV_T< CHAR_TYPE >::add(), ACE_TLI_Acceptor::close(), ACE_Dirent_Selector::close(), ACE_ATM_QoS::construct_options(), ACE::count_interfaces(), ACE_Name_Options::database(), event_destroy(), flock_destroy(), ACE_ATM_Stream::get_vpi_vci(), ACE::ldfind(), ACE_Local_Name_Space<, ACE_LOCK >::list_type_entries_i(), ACE_Local_Name_Space<, ACE_LOCK >::list_types_i(), ACE_Log_Msg::local_host(), ACE_Name_Options::nameserver_host(), ACE_Name_Options::namespace_dir(), ACE_Log_Msg::open(), ACE_Name_Binding::operator=(), ACE_Name_Options::process_name(), putenv(), ACE_Mutex::remove(), ACE_Auto_String_Free::reset(), scandir_emulation(), sema_destroy(), ACE_SPIPE_Addr::set(), ACE_INET_Addr::string_to_addr(), ACE_Log_Msg::sync(), tempnam(), ACE_ARGV_T< CHAR_TYPE >::~ACE_ARGV_T(), ACE_Argv_Type_Converter::~ACE_Argv_Type_Converter(), ACE_Configuration_Section_Key_Heap::~ACE_Configuration_Section_Key_Heap(), ACE_Hash_Map_Entry< const ACE_TCHAR *, ACE_Filecache_Object * >::~ACE_Hash_Map_Entry(), ACE_Log_Msg::~ACE_Log_Msg(), ACE_Malloc_FIFO_Iterator_T<, ACE_LOCK, ACE_CB >::~ACE_Malloc_FIFO_Iterator_T(), ACE_Malloc_LIFO_Iterator_T<, ACE_LOCK, ACE_CB >::~ACE_Malloc_LIFO_Iterator_T(), ACE_Name_Binding::~ACE_Name_Binding(), ACE_Name_Options::~ACE_Name_Options(), and ACE_Strategy_Acceptor< SVC_HANDLER, >::~ACE_Strategy_Acceptor(). { ACE_FREE_FUNC (ACE_MALLOC_T (ptr)); }

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

Definition at line 662 of file OS_NS_stdio.inl. References ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, and ACE_TEXT_ALWAYS_WCHAR. { ACE_OS_TRACE ("ACE_OS::freopen"); #if defined (ACE_WIN32) && (defined(ACE_USES_WCHAR) || defined(ACE_HAS_WINCE)) ACE_OSCALL_RETURN (::_wfreopen (ACE_TEXT_ALWAYS_WCHAR (filename), ACE_TEXT_ALWAYS_WCHAR (mode), stream), FILE *, 0); #else ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::freopen (ACE_TEXT_ALWAYS_CHAR (filename), ACE_TEXT_ALWAYS_CHAR (mode), stream), FILE *, 0); #endif /* ACE_WIN32 && ACE_USES_WCHAR */ }

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

Definition at line 680 of file OS_NS_stdio.inl. Referenced by rewind(). { # 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 (ACE_STD_NAMESPACE::fseek (fp, offset, whence), int, -1); }

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

Definition at line 706 of file OS_NS_stdio.inl. References fsetpos(). Referenced by fsetpos(). { ACE_OSCALL_RETURN (::fsetpos (fp, pos), int, -1); }

ACE_INLINE int ACE_OS::fstat (  ACE_HANDLE  , ACE_stat *  )

Definition at line 51 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, ACE_Time_Value, and set_errno_to_last_error(). Referenced by ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::check_handles(), filesize(), and ACE_FILE::get_info(). { ACE_OS_TRACE ("ACE_OS::fstat"); # if 1 BY_HANDLE_FILE_INFORMATION fdata; if (::GetFileInformationByHandle (handle, &fdata) == FALSE) { 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).sec (); stp->st_mtime = ACE_Time_Value (fdata.ftLastWriteTime).sec (); stp->st_ctime = ACE_Time_Value (fdata.ftCreationTime).sec (); stp->st_nlink = static_cast<short> (fdata.nNumberOfLinks); stp->st_dev = stp->st_rdev = 0; // No equivalent conversion. stp->st_mode = S_IXOTH | S_IROTH | (fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0 : S_IWOTH) | (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? S_IFDIR : S_IFREG); } return 0; # else /* 1 */ // This implementation close the handle. int retval = -1; int fd = ::_open_osfhandle ((long) handle, 0); if (fd != -1) retval = ::_fstat (fd, stp); ::_close (fd); // Remember to close the file handle. return retval; # endif /* 1 */ }

ACE_INLINE int ACE_OS::fsync (  ACE_HANDLE  handle  )

Definition at line 340 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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); # elif defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushFileBuffers (handle), ace_result_), int, -1); # else ACE_OSCALL_RETURN (::fsync (handle), int, -1); # endif /* ACE_LACKS_FSYNC */ }

ACE_INLINE long ACE_OS::ftell (  FILE *  fp  )

Definition at line 712 of file OS_NS_stdio.inl. Referenced by ACE_Logging_Strategy::handle_timeout(). { ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::ftell (fp), long, -1); }

ACE_INLINE int ACE_OS::ftruncate (  ACE_HANDLE  , ACE_LOFF_T  )

Definition at line 354 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_FAIL_RETURN, ACE_LOFF_T, ACE_OS_TRACE, and ftruncate(). Referenced by ACE_Mutex::ACE_Mutex(), event_init(), ftruncate(), ACE_Mem_Map::remove(), sema_init(), and ACE_FILE::truncate(). { ACE_OS_TRACE ("ACE_OS::ftruncate"); #if defined (ACE_WIN32) # if !defined (ACE_LACKS_SETFILEPOINTEREX) LARGE_INTEGER loff; loff.QuadPart = offset; if (::SetFilePointerEx (handle, loff, 0, FILE_BEGIN) != (unsigned) -1) # else if (::SetFilePointer (handle, offset, 0, FILE_BEGIN) != (unsigned) -1) # endif ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetEndOfFile (handle), ace_result_), int, -1); else ACE_FAIL_RETURN (-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 )

Definition at line 718 of file OS_NS_stdio.inl. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::fwrite"); ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::fwrite (ptr, size, nitems, fp), size_t, 0); }

ACE_NAMESPACE_INLINE_FUNCTION 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.

ACE_NAMESPACE_INLINE_FUNCTION const OSVERSIONINFO& get_win32_versioninfo (  void   )

Return the win32 OSVERSIONINFO structure.

ACE_INLINE wchar_t * ACE_OS::getcwd (  wchar_t *  , size_t  )

Definition at line 390 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, getcwd(), and strsncpy(). { # if defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (size); ACE_NOTSUP_RETURN (0); # elif defined (ACE_WIN32) return ::_wgetcwd (buf, static_cast<int> (size)); # else char *narrow_buf = new char[size]; char *result = 0; result = ACE_OS::getcwd (narrow_buf, size); ACE_Ascii_To_Wide wide_buf (result); delete [] narrow_buf; if (result != 0) ACE_OS::strsncpy (buf, wide_buf.wchar_rep (), size); return result == 0 ? 0 : buf; # endif /* ACE_WIN32 */ }

ACE_INLINE char * ACE_OS::getcwd (  char *  , size_t  )

Definition at line 374 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and getcwd(). Referenced by getcwd(). { ACE_OS_TRACE ("ACE_OS::getcwd"); #if defined (ACE_LACKS_GETCWD) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (size); ACE_NOTSUP_RETURN (0); #elif defined (ACE_WIN32) return ::getcwd (buf, static_cast<int> (size)); #else ACE_OSCALL_RETURN (::getcwd (buf, size), char *, 0); #endif /* ACE_LACKS_GETCWD */ }

ACE_INLINE gid_t ACE_OS::getegid (  void   )

Definition at line 423 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, getegid(), and gid_t. Referenced by getegid(). { ACE_OS_TRACE ("ACE_OS::getegid"); #if defined (ACE_LACKS_GETEGID) ACE_NOTSUP_RETURN (static_cast<gid_t> (-1)); # else ACE_OSCALL_RETURN (::getegid (), gid_t, static_cast<gid_t> (-1)); # endif /* ACE_LACKS_GETEGID */ }

ACE_INLINE wchar_t * ACE_OS::getenv (  const wchar_t *  symbol  )

Definition at line 139 of file OS_NS_stdlib.inl. References ACE_NOTSUP_RETURN. { #if defined (ACE_LACKS_ENV) ACE_UNUSED_ARG (symbol); ACE_NOTSUP_RETURN (0); #else ACE_OSCALL_RETURN (::_wgetenv (symbol), wchar_t *, 0); #endif /* ACE_LACKS_ENV */ }

ACE_INLINE char * ACE_OS::getenv (  const char *  symbol  )

Definition at line 126 of file OS_NS_stdlib.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and getenv(). Referenced by ACE_Get_Opt::ACE_Get_Opt(), ACE_Log_Msg::ACE_Log_Msg(), argv_to_string(), ACE::debug(), ACE_Env_Value< T >::fetch_value(), ACE_High_Res_Timer::get_env_global_scale_factor(), ACE::get_temp_dir(), getenv(), ACE::ldfind(), and strenvdup(). { ACE_OS_TRACE ("ACE_OS::getenv"); #if defined (ACE_LACKS_ENV) ACE_UNUSED_ARG (symbol); ACE_NOTSUP_RETURN (0); #else /* ACE_LACKS_ENV */ ACE_OSCALL_RETURN (::getenv (symbol), char *, 0); #endif /* ACE_LACKS_ENV */ }

ACE_TCHAR * ACE_OS::getenvstrings (  void   )

Definition at line 91 of file OS_NS_stdlib.cpp. References ACE_NOTSUP_RETURN. 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 uid_t ACE_OS::geteuid (  void   )

Definition at line 501 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, geteuid(), and uid_t. Referenced by geteuid(). { ACE_OS_TRACE ("ACE_OS::geteuid"); #if defined (ACE_LACKS_GETEUID) ACE_NOTSUP_RETURN (static_cast<uid_t> (-1)); # else ACE_OSCALL_RETURN (::geteuid (), uid_t, (uid_t) -1); # endif /* ACE_LACKS_GETEUID */ }

ACE_INLINE gid_t ACE_OS::getgid (  void   )

Definition at line 412 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, getgid(), and gid_t. Referenced by getgid(), and ACE_SPIPE_Addr::set(). { ACE_OS_TRACE ("ACE_OS::getgid"); #if defined (ACE_LACKS_GETGID) ACE_NOTSUP_RETURN (static_cast<gid_t> (-1)); # else ACE_OSCALL_RETURN (::getgid (), gid_t, static_cast<gid_t> (-1)); # endif /* ACE_LACKS_GETGID */ }

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

Definition at line 48 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, and gethostbyaddr(). Referenced by ACE_INET_Addr::get_host_name_i(), gethostbyaddr(), gethostbyaddr_r(), and getipnodebyaddr(). { ACE_OS_TRACE ("ACE_OS::gethostbyaddr"); # if defined (ACE_LACKS_GETHOSTBYADDR) 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 (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 )

Definition at line 76 of file OS_NS_netdb.inl. References ACE_HOSTENT_DATA, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, gethostbyaddr(), gethostbyaddr_r(), and memset(). Referenced by ACE_INET_Addr::get_host_name_i(), and gethostbyaddr_r(). { ACE_OS_TRACE ("ACE_OS::gethostbyaddr_r"); # if defined (ACE_HAS_REENTRANT_FUNCTIONS) && !defined (UNIXWARE) # if defined (AIX) || defined (DIGITAL_UNIX) ACE_OS::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 ACE_OS::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 (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  )

Definition at line 152 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and gethostbyname(). Referenced by ACE::get_bcast_addr(), gethostbyname(), gethostbyname_r(), getipnodebyname(), getmacaddress(), ACE_SOCK_Dgram_Bcast::mk_broadcast(), and ACE_INET_Addr::set(). { ACE_OS_TRACE ("ACE_OS::gethostbyname"); # if defined (ACE_LACKS_GETHOSTBYNAME) ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (0); # elif defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::gethostbyname (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 )

Definition at line 174 of file OS_NS_netdb.inl. References ACE_HOSTENT_DATA, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, gethostbyname(), gethostbyname_r(), and memset(). Referenced by gethostbyname_r(), and ACE_INET_Addr::set(). { ACE_OS_TRACE ("ACE_OS::gethostbyname_r"); #if defined (ACE_LACKS_GETHOSTBYNAME) 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) ACE_OS::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 ACE_OS::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 (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  )

Definition at line 206 of file OS_NS_time.inl. References ACE_GETHRTIME_NAME, ACE_hrtime_t, ACE_ONE_SECOND_IN_NSECS, ACE_OS_TRACE, ACE_UINT64, clock_gettime(), CLOCK_REALTIME, gettimeofday(), 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_Metrics_Cache< ACE_LOCK, ALLOCATOR >::report_dequeue_start(), ACE_Metrics_Cache< ACE_LOCK, ALLOCATOR >::report_dequeue_stop(), ACE_Metrics_Cache< ACE_LOCK, ALLOCATOR >::report_enqueue_start(), ACE_Metrics_Cache< ACE_LOCK, ALLOCATOR >::report_enqueue_stop(), and ACE_Timeprobe_Ex< ACE_LOCK, ALLOCATOR >::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_NAME (); #elif (defined(__KCC) || defined (__GNUG__) || defined (__INTEL_COMPILER)) && !defined (ACE_WIN32) && !defined(ACE_VXWORKS) && 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, static_cast<unsigned int> (freq.u.HighPart)); return uint64_freq; # else return freq.QuadPart; # endif //ACE_LACKS_LONGLONG_T #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; #if defined (ghs) ACE_OS::readPPCTimeBase (most, least); #else u_long scratch; do { asm volatile ("mftbu %0\n" "mftb %1\n" "mftbu %2" : "=r" (most), "=r" (least), "=r" (scratch)); } while (most != scratch); #endif #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) // e.g., VxWorks (besides POWERPC && GreenHills) . . . ACE_UNUSED_ARG (op); struct timespec ts; ACE_OS::clock_gettime ( #if defined (ACE_HAS_CLOCK_GETTIME_MONOTONIC) CLOCK_MONOTONIC, #endif /* !ACE_HAS_CLOCK_GETTIME_MONOTONIC */ CLOCK_REALTIME, &ts); // Carefully create the return value to avoid arithmetic overflow // if ACE_hrtime_t is ACE_U_LongLong. return static_cast<ACE_hrtime_t> (ts.tv_sec) * ACE_U_ONE_SECOND_IN_NSECS + 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 (static_cast<ACE_hrtime_t> (now.sec ()) * (ACE_UINT32) 1000000 + 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 )

Definition at line 255 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, and gethostbyaddr(). { #if defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) # if defined (ACE_LACKS_GETIPNODEBYADDR) 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 /* ACE_LACKS_GETIPNODEBYADDR */ #else // IPv4-only implementation if (family == AF_INET) return ACE_OS::gethostbyaddr (static_cast<const char *> (src), static_cast<int> (len), family); ACE_NOTSUP_RETURN (0); # endif /* defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) */ }

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

Definition at line 284 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and gethostbyname(). { ACE_OS_TRACE ("ACE_OS::getipnodebyname"); # if defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) # if defined (ACE_LACKS_GETIPNODEBYNAME) ACE_UNUSED_ARG (flags); # if defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::gethostbyname2 (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 /* ACE_LACKS_GETIPNODEBYNAME */ # else // IPv4-only implementation ACE_UNUSED_ARG (flags); if (family == AF_INET) return ACE_OS::gethostbyname (name); ACE_NOTSUP_RETURN (0); # endif /* defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_END_VERSIONED_NAMESPACE_DECL ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::getmacaddress (  struct macaddr_node_t *  node  )

Definition at line 213 of file OS_NS_netdb.cpp. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TCHAR, close(), gethostbyname(), hostname(), ioctl(), MAXHOSTNAMELEN, memcpy(), memset(), ACE_OS::macaddr_node_t::node, socket(), sprintf(), and strcpy(). Referenced by ACE_Utils::UUID_Generator::init(). { ACE_OS_TRACE ("ACE_OS::getmacaddress"); #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) # if !defined (ACE_HAS_PHARLAP) /** Define a structure for use with the netbios routine */ struct ADAPTERSTAT { ADAPTER_STATUS adapt; NAME_BUFFER NameBuff [30]; }; NCB ncb; LANA_ENUM lenum; unsigned char result; ACE_OS::memset (&ncb, 0, sizeof(ncb)); ncb.ncb_command = NCBENUM; ncb.ncb_buffer = reinterpret_cast<unsigned char*> (&lenum); ncb.ncb_length = sizeof(lenum); result = Netbios (&ncb); for(int i = 0; i < lenum.length; i++) { ACE_OS::memset (&ncb, 0, sizeof(ncb)); ncb.ncb_command = NCBRESET; ncb.ncb_lana_num = lenum.lana [i]; /** Reset the netbios */ result = Netbios (&ncb); if (ncb.ncb_retcode != NRC_GOODRET) { return -1; } ADAPTERSTAT adapter; ACE_OS::memset (&ncb, 0, sizeof (ncb)); ACE_OS::strcpy (reinterpret_cast<char*> (ncb.ncb_callname), "*"); ncb.ncb_command = NCBASTAT; ncb.ncb_lana_num = lenum.lana[i]; ncb.ncb_buffer = reinterpret_cast<unsigned char*> (&adapter); ncb.ncb_length = sizeof (adapter); result = Netbios (&ncb); if (result == 0) { ACE_OS::memcpy (node->node, adapter.adapt.adapter_address, 6); return 0; } } return 0; # else # if defined (ACE_HAS_PHARLAP_RT) DEVHANDLE ip_dev = (DEVHANDLE)0; EK_TCPIPCFG *devp; size_t i; ACE_TCHAR dev_name[16]; for (i = 0; i < 10; i++) { // Ethernet. ACE_OS::sprintf (dev_name, "ether%d", i); ip_dev = EtsTCPGetDeviceHandle (dev_name); if (ip_dev != 0) break; } if (ip_dev == 0) return -1; devp = EtsTCPGetDeviceCfg (ip_dev); if (devp == 0) return -1; ACE_OS::memcpy (node->node, &devp->EthernetAddress[0], 6); return 0; # else ACE_UNUSED_ARG (node); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_PHARLAP_RT */ # endif /* ACE_HAS_PHARLAP */ #elif defined (sun) /** obtain the local host name */ char hostname [MAXHOSTNAMELEN]; ACE_OS::hostname (hostname, sizeof (hostname)); /** Get the hostent to use with ioctl */ struct hostent *phost = ACE_OS::gethostbyname (hostname); if (phost == 0) return -1; ACE_HANDLE handle = ACE_OS::socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP); if (handle == ACE_INVALID_HANDLE) return -1; char **paddrs = phost->h_addr_list; struct arpreq ar; struct sockaddr_in *psa = (struct sockaddr_in *)&(ar.arp_pa); ACE_OS::memset (&ar, 0, sizeof (struct arpreq)); psa->sin_family = AF_INET; ACE_OS::memcpy (&(psa->sin_addr), *paddrs, sizeof (struct in_addr)); if (ACE_OS::ioctl (handle, SIOCGARP, &ar) == -1) { ACE_OS::close (handle); return -1; } ACE_OS::close (handle); ACE_OS::memcpy (node->node, ar.arp_ha.sa_data, 6); return 0; #elif defined (linux) struct ifreq ifr; ACE_HANDLE handle = ACE_OS::socket (PF_INET, SOCK_DGRAM, 0); if (handle == ACE_INVALID_HANDLE) return -1; ACE_OS::strcpy (ifr.ifr_name, "eth0"); if (ACE_OS::ioctl (handle/*s*/, SIOCGIFHWADDR, &ifr) < 0) { ACE_OS::close (handle); return -1; } struct sockaddr* sa = (struct sockaddr *) &ifr.ifr_addr; ACE_OS::close (handle); ACE_OS::memcpy (node->node, sa->sa_data, 6); return 0; #else ACE_UNUSED_ARG (node); ACE_NOTSUP_RETURN (-1); #endif }

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

Definition at line 39 of file OS_NS_stropts.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 434 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and getopt(). Referenced by getopt(). { ACE_OS_TRACE ("ACE_OS::getopt"); #if defined (ACE_LACKS_GETOPT) ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_UNUSED_ARG (optstring); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::getopt (argc, argv, optstring), int, -1); # endif /* ACE_LACKS_GETOPT */ }

ACE_INLINE long ACE_OS::getpagesize (  void   )

Definition at line 91 of file OS_NS_unistd.inl. 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 (long) sys_info.dwPageSize; #elif defined (_SC_PAGESIZE) return ::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 )

BSD-style (no QoS). Definition at line 146 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, getpeername(), and memset(). Referenced by ACE_SOCK_SEQPACK_Connector::complete(), ACE_SOCK_Connector::complete(), ACE_ATM_Stream::get_peer_name(), ACE_SOCK::get_remote_addr(), ACE_SOCK_SEQPACK_Association::get_remote_addrs(), getpeername(), and ACE_Asynch_Connector< HANDLER >::parse_address(). { ACE_OS_TRACE ("ACE_OS::getpeername"); #if defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \ && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1) int result; ACE_SOCKCALL (::getpeername ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), int, -1, result); // Some platforms, like older versions of the Linux kernel, do not // initialize the sin_zero field since that field is generally only // used for padding/alignment purposes. On those platforms // memcmp()-based comparisons of the sockaddr_in structure, such as // the one in the ACE_INET_Addr equality operator, may fail due to // random bytes in the sin_zero field even though that field is // unused. Prevent equality comparison of two different sockaddr_in // instances that refer to the same socket from failing by // explicitly initializing the sockaddr_in::sin_zero field to a // consistent value, e.g. zero. if (result != -1 && addr->sa_family == AF_INET) { ACE_OS::memset (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero, 0, sizeof (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero)); } return result; #else ACE_SOCKCALL_RETURN (::getpeername ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #endif /* ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO */ }

ACE_INLINE pid_t ACE_OS::getpgid (  pid_t  pid  )

Definition at line 448 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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 (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_LACKS_GETPGID */ }

ACE_INLINE pid_t ACE_OS::getpid (  void   )

Definition at line 466 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN. Referenced by ACE_IPC_SAP::enable(), ACE_IO_SAP::enable(), ACE_Log_Msg::getpid(), ACE_SPIPE_Stream::recv_handle(), and ACE_Log_Msg::sync(). { // ACE_OS_TRACE ("ACE_OS::getpid"); #if defined (ACE_LACKS_GETPID) ACE_NOTSUP_RETURN (-1); #elif defined (ACE_WIN32) return ::GetCurrentProcessId (); #else ACE_OSCALL_RETURN (::getpid (), int, -1); #endif /* ACE_LACKS_GETPID */ }

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

Definition at line 59 of file OS_NS_stropts.inl. References ACE_NOTSUP_RETURN, 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   )

Definition at line 479 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, getppid(), and pid_t. Referenced by getppid(). { ACE_OS_TRACE ("ACE_OS::getppid"); #if defined (ACE_LACKS_GETPPID) ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::getppid (), pid_t, -1); #endif /* ACE_LACKS_GETPPID */ }

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

Definition at line 318 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_SOCKCALL_RETURN, and getprotobyname(). Referenced by getprotobyname(), and getprotobyname_r(). { #if defined (ACE_LACKS_GETPROTOBYNAME) ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_NONCONST_GETBY) ACE_SOCKCALL_RETURN (::getprotobyname (const_cast<char *> (name)), struct protoent *, 0); #else ACE_SOCKCALL_RETURN (::getprotobyname (name), struct protoent *, 0); #endif /* ACE_LACKS_GETPROTOBYNAME */ }

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

Definition at line 335 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_PROTOENT_DATA, ACE_SOCKCALL_RETURN, getprotobyname(), and getprotobyname_r(). Referenced by getprotobyname_r(). { #if defined (ACE_LACKS_GETPROTOBYNAME) 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) 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 (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  )

Definition at line 390 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_SOCKCALL_RETURN, and getprotobynumber(). Referenced by getprotobynumber(), and getprotobynumber_r(). { #if defined (ACE_LACKS_GETPROTOBYNUMBER) ACE_UNUSED_ARG (proto); ACE_NOTSUP_RETURN (0); #else ACE_SOCKCALL_RETURN (::getprotobynumber (proto), struct protoent *, 0); #endif /* ACE_LACKS_GETPROTOBYNUMBER */ }

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

Definition at line 402 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_PROTOENT_DATA, ACE_SOCKCALL_RETURN, getprotobynumber(), and getprotobynumber_r(). Referenced by getprotobynumber_r(). { #if defined (ACE_LACKS_GETPROTOBYNUMBER) 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) 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   )

Definition at line 20 of file OS_NS_pwd.inl. References ACE_NOTSUP_RETURN. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) return ::getpwent (); #else ACE_NOTSUP_RETURN (0); #endif /* ! ACE_LACKS_PWD_FUNCTIONS */ }

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

Definition at line 30 of file OS_NS_pwd.inl. References ACE_NOTSUP_RETURN. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) return ::getpwnam (name); # 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 )

Definition at line 41 of file OS_NS_pwd.inl. References ACE_NOTSUP_RETURN. { #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) 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::getrlimit (  int  resource, struct rlimit *  rl )

Definition at line 11 of file OS_NS_sys_resource.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 30 of file OS_NS_sys_resource.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, getrusage(), rusage::ru_stime, and rusage::ru_utime. Referenced by getrusage(), ACE_Profile_Timer::start(), and ACE_Profile_Timer::stop(). { 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 ACE_UNUSED_ARG (who); ACE_UNUSED_ARG (ru); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSCALL_GETRUSAGE */ }

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

Definition at line 448 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and getservbyname(). Referenced by getservbyname(), and getservbyname_r(). { 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 (const_cast<char *> (svc), 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 )

Definition at line 469 of file OS_NS_netdb.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SERVENT_DATA, ACE_SOCKCALL_RETURN, getservbyname(), getservbyname_r(), and memset(). Referenced by get_port_number_from_name(), and getservbyname_r(). { 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) ACE_OS::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 ACE_OS::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 (const_cast<char *> (svc), 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 )

BSD-style (no QoS). Definition at line 189 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, getsockname(), and memset(). Referenced by ACE_SOCK::get_local_addr(), ACE_ATM_Acceptor::get_local_addr(), ACE_SOCK_SEQPACK_Association::get_local_addrs(), getsockname(), ACE_Asynch_Connector< HANDLER >::parse_address(), and ACE_SOCK_SEQPACK_Connector::shared_connect_start(). { ACE_OS_TRACE ("ACE_OS::getsockname"); #if defined (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO) \ && (ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO == 1) int result; ACE_SOCKCALL (::getsockname ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), int, -1, result); // Some platforms, like older versions of the Linux kernel, do not // initialize the sin_zero field since that field is generally only // used for padding/alignment purposes. On those platforms // memcmp()-based comparisons of the sockaddr_in structure, such as // the one in the ACE_INET_Addr equality operator, may fail due to // random bytes in the sin_zero field even though that field is // unused. Prevent equality comparison of two different sockaddr_in // instances that refer to the same socket from failing by // explicitly initializing the sockaddr_in::sin_zero field to a // consistent value, e.g. zero. if (result != -1 && addr->sa_family == AF_INET) { ACE_OS::memset (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero, 0, sizeof (reinterpret_cast<struct sockaddr_in *> (addr)->sin_zero)); } return result; #else ACE_SOCKCALL_RETURN (::getsockname ((ACE_SOCKET) handle, addr, (ACE_SOCKET_LEN *) addrlen), int, -1); #endif /* ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO */ }

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

BSD-style (no QoS). Definition at line 229 of file OS_NS_sys_socket.inl. 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Time_Value ACE_OS::gettimeofday (  void   )

Definition at line 25 of file OS_NS_sys_time.inl. References ACE_Time_Value, CLOCK_REALTIME, timespec::tv_nsec, and timespec::tv_sec. Referenced by ACE_Buffered_Svc_Handler<, >::ACE_Buffered_Svc_Handler(), ACE_Dev_Poll_Reactor::Token_Guard::acquire(), ACE_Dev_Poll_Reactor::Token_Guard::acquire_quietly(), ACE_TP_Token_Guard::acquire_read_token(), 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(), ACE_Utils::UUID_Generator::get_systemtime(), gethrtime(), ACE_High_Res_Timer::gettime(), ACE_High_Res_Timer::gettimeofday(), ACE_POSIX_CB_Proactor::handle_events_i(), ACE_Buffered_Svc_Handler<, >::put(), ACE_Ping_Socket::receive_echo_reply(), ACE::recv(), ACE::recvfrom(), ACE::recvmsg(), ACE::recvv(), ACE_Dynamic_Message_Queue<>::remove_messages(), ACE_Async_Timer_Queue_Adapter< TQ >::schedule_ualarm(), sema_wait(), ACE::send(), ACE::sendmsg(), ACE::sendto(), ACE::sendv(), ACE_Countdown_Time::start(), ACE_Countdown_Time::stop(), ACE_Thread_Timer_Queue_Adapter< TQ >::svc(), time(), ACE::timestamp(), ACE_Thread_Manager::wait(), 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_VOIDPTR_GETTIMEOFDAY) || \ (defined (ACE_HAS_SVR4_GETTIMEOFDAY) && !defined (m88k) && !defined (SCO)) ACE_OSCALL (::gettimeofday (&tv, 0), int, -1, result); # elif defined (ACE_VXWORKS) // 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 ACE_Time_Value (-1); else return ACE_Time_Value (tv); #endif // !defined (ACE_HAS_WINCE)&& !defined (ACE_WIN32) }

ACE_INLINE uid_t ACE_OS::getuid (  void   )

Definition at line 490 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, getuid(), and uid_t. Referenced by getuid(), and ACE_SPIPE_Addr::set(). { ACE_OS_TRACE ("ACE_OS::getuid"); #if defined (ACE_LACKS_GETUID) ACE_NOTSUP_RETURN (static_cast<uid_t> (-1)); # else ACE_OSCALL_RETURN (::getuid (), uid_t, static_cast<uid_t> (-1)); # endif /* ACE_LACKS_GETUID*/ }

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

Definition at line 334 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and gmtime(). Referenced by gmtime(), and gmtime_r(). { ACE_OS_TRACE ("ACE_OS::gmtime"); #if defined (ACE_LACKS_GMTIME) ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (0); #else ACE_OSCALL_RETURN (::gmtime (t), struct tm *, 0); #endif /* ACE_LACKS_GMTIME */ }

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

Definition at line 346 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, gmtime(), and gmtime_r(). Referenced by gmtime_r(). { 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); # else ACE_OSCALL_RETURN (::gmtime_r (t, res), struct tm *, 0); # endif /* DIGITAL_UNIX */ #elif defined (ACE_LACKS_GMTIME_R) ACE_UNUSED_ARG (t); ACE_UNUSED_ARG (res); ACE_NOTSUP_RETURN (0); #else struct tm *result; ACE_OSCALL (::gmtime (t), struct tm *, 0, result) ; if (result != 0) *res = *result; return res; #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

ACE_NAMESPACE_INLINE_FUNCTION int hostname (  wchar_t *  name, size_t  maxnamelen )

ACE_NAMESPACE_INLINE_FUNCTION int hostname (  char *  name, size_t  maxnamelen )

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

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE unsigned long ACE_OS::inet_addr (  const char *  name  )

Definition at line 11 of file OS_NS_arpa_inet.inl. References ACE_OS_TRACE. Referenced by inet_aton(). { ACE_OS_TRACE ("ACE_OS::inet_addr"); #if defined (ACE_HAS_NONCONST_GETBY) return ::inet_addr (const_cast <char*> (name)); #else return ::inet_addr (name); #endif /* ACE_HAS_NONCONST_GETBY */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::inet_aton (  const char *  strptr, struct in_addr *  addr )

Definition at line 15 of file OS_NS_arpa_inet.cpp. References INADDR_NONE, inet_addr(), inet_aton(), and strcmp(). Referenced by inet_aton(), inet_pton(), and ACE_INET_Addr::set(). { #if defined (ACE_LACKS_INET_ATON) # if defined (ACE_WIN32) // Windows Server 2003 changed the behavior of a zero-length input // string to inet_addr(). It used to return 0 (INADDR_ANY) but now // returns -1 (INADDR_NONE). It will return INADDR_ANY for a 1-space // string, though, as do previous versions of Windows. if (host_name == 0 || host_name[0] == '\0') host_name = " "; # endif /* ACE_WIN32 */ unsigned long 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 (ACE_VXWORKS) && (ACE_VXWORKS <= 0x620) // inet_aton() returns OK (0) on success and ERROR (-1) on failure. // Must reset errno first. Refer to WindRiver SPR# 34949, SPR# 36026 ::errnoSet(0); int result = ERROR; ACE_OSCALL (::inet_aton (const_cast <char*>(host_name), addr), int, ERROR, result); return (result == ERROR) ? 0 : 1; #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  )

Definition at line 22 of file OS_NS_arpa_inet.inl. 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 )

Definition at line 31 of file OS_NS_arpa_inet.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, INET_ADDRSTRLEN, inet_ntop(), sprintf(), strcpy(), and strlen(). Referenced by ACE_INET_Addr::get_host_addr(), and inet_ntop(). { ACE_OS_TRACE ("ACE_OS::inet_ntop"); #if defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) ACE_OSCALL_RETURN (::inet_ntop (family, addrptr, strptr, len), const char *, 0); #else const u_char *p = 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 )

Definition at line 65 of file OS_NS_arpa_inet.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, inet_aton(), inet_pton(), and memcpy(). Referenced by inet_pton(). { ACE_OS_TRACE ("ACE_OS::inet_pton"); #if defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) 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, unsigned long  io_control_code, ACE_QoS &  ace_qos, unsigned long *  bytes_returned, void *  buffer_p = 0, unsigned long  buffer = 0, ACE_OVERLAPPED *  overlapped = 0, ACE_OVERLAPPED_COMPLETION_FUNC  func = 0 )

QoS-enabled when the I/O control code is either SIO_SET_QOS or SIO_GET_QOS. Definition at line 52 of file OS_NS_stropts.cpp. References ACE_NEW_RETURN, ACE_NOTSUP_RETURN, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, ACE_SOCKCALL_RETURN, iovec::iov_len, ACE_QoS::provider_specific(), ACE_QoS::receiving_flowspec(), and ACE_QoS::sending_flowspec(). { # if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) QOS qos; unsigned 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 { unsigned 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) { unsigned 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 = 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 */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::ioctl (  ACE_HANDLE  socket, unsigned long  io_control_code, void *  in_buffer_p, unsigned long  in_buffer, void *  out_buffer_p, unsigned long  out_buffer, unsigned long *  bytes_returned, ACE_OVERLAPPED *  overlapped, ACE_OVERLAPPED_COMPLETION_FUNC  func )

QoS-enabled . Definition at line 14 of file OS_NS_stropts.cpp. References ACE_NOTSUP_RETURN, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, and ACE_SOCKCALL_RETURN. { # 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, ACE_IOCTL_TYPE_ARG2  cmd, void *  = 0 )

UNIX-style . Definition at line 108 of file OS_NS_stropts.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ioctl(). Referenced by ACE_SPIPE_Acceptor::accept(), ACE::clr_flags(), ACE_TLI_Connector::connect(), ACE_IPC_SAP::control(), ACE_IO_SAP::control(), ACE::count_interfaces(), ACE_SPIPE_Acceptor::create_new_instance(), ACE_IPC_SAP::disable(), ACE_IPC_SAP::enable(), ACE::get_bcast_addr(), ACE::get_ip_interfaces(), getmacaddress(), ioctl(), ACE_SOCK_Dgram::make_multicast_ifaddr(), ACE_SOCK_Dgram_Bcast::mk_broadcast(), ACE_Pipe::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::set_flags(), 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, reinterpret_cast<unsigned long *> (val)), int, -1); #elif defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x620) ACE_OSCALL_RETURN (::ioctl (handle, cmd, reinterpret_cast<int> (val)), int, -1); #else ACE_OSCALL_RETURN (::ioctl (handle, cmd, val), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::isastream (  ACE_HANDLE  handle  )

Definition at line 126 of file OS_NS_stropts.inl. References ACE_NOTSUP_RETURN, 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 */ }

ACE_INLINE int ACE_OS::isatty (  ACE_HANDLE  handle  )

Definition at line 593 of file OS_NS_unistd.inl. { #if defined (ACE_LACKS_ISATTY) ACE_UNUSED_ARG (handle); return 0; #else # if defined (ACE_LACKS_INTPTR_T) int fd = ::_open_osfhandle (long (handle), 0); # else int fd = ::_open_osfhandle (intptr_t (handle), 0); # endif int status = ::_isatty (fd); ::_close (fd); return status; #endif /* ACE_LACKS_ISATTY */ }

ACE_INLINE int ACE_OS::isatty (  int  handle  )

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

ACE_INLINE wchar_t * ACE_OS::itoa (  int  value, wchar_t *  string, int  radix )

Converts an integer to a string. Definition at line 164 of file OS_NS_stdlib.inl. References itow_emulation(). { #if defined (ACE_LACKS_ITOW) return ACE_OS::itow_emulation (value, string, radix); #else /* ACE_LACKS_ITOW */ return ::_itow (value, string, radix); #endif /* ACE_LACKS_ITOW */ }

ACE_INLINE char * ACE_OS::itoa (  int  value, char *  string, int  radix )

Converts an integer to a string. Definition at line 151 of file OS_NS_stdlib.inl. References itoa_emulation(). { #if !defined (ACE_HAS_ITOA) return ACE_OS::itoa_emulation (value, string, radix); #elif defined (ACE_ITOA_EQUIVALENT) return ACE_ITOA_EQUIVALENT (value, string, radix); #else /* !ACE_HAS_ITOA */ return ::itoa (value, string, radix); #endif /* !ACE_HAS_ITOA */ }

char * ACE_OS::itoa_emulation (  int  value, char *  string, int  radix )

Emulated itoa - Converts an integer to a string. Definition at line 108 of file OS_NS_stdlib.cpp. Referenced by itoa(). { char *e = string; char *b = string; // Short circuit if 0 if (value == 0) { string[0] = '0'; string[1] = 0; return string; } // If negative and base 10, print a - and then do the // number. if (value < 0 && radix == 10) { string[0] = '-'; ++b; ++e; // Don't overwrite the negative sign. value = -value; // Drop negative sign so character selection is correct. } // Convert to base <radix>, but in reverse order while (value != 0) { int mod = value % radix; value = value / radix; *e++ = (mod < 10) ? '0' + mod : 'a' + mod - 10; } *e-- = 0; // Now reverse the string to get the correct result while (e > b) { char temp = *e; *e = *b; *b = temp; ++b; --e; } return string; }

wchar_t * ACE_OS::itow_emulation (  int  value, wchar_t *  string, int  radix )

Emulated itow - Converts an integer to a string. Definition at line 162 of file OS_NS_stdlib.cpp. Referenced by itoa(). { wchar_t *e = string; wchar_t *b = string; // Short circuit if 0 if (value == 0) { string[0] = '0'; string[1] = 0; return string; } // If negative and base 10, print a - and then do the // number. if (value < 0 && radix == 10) { string[0] = '-'; b++; } // Convert to base <radix>, but in reverse order while (value != 0) { int mod = value % radix; value = value / radix; *e++ = (mod < 10) ? '0' + mod : 'a' + mod - 10; } *e-- = 0; // Now reverse the string to get the correct result while (e > b) { wchar_t temp = *e; *e = *b; *b = temp; ++b; --e; } return string; }

ACE_HANDLE ACE_OS::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. Definition at line 65 of file OS_NS_sys_socket.cpp. References ACE_NOTSUP_RETURN, 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(), 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 )

Definition at line 14 of file OS_NS_signal.inl. References ACE_NOTSUP_RETURN, 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_LACKS_KILL) ACE_UNUSED_ARG (pid); ACE_UNUSED_ARG (signum); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::kill (pid, signum), int, -1); #endif /* ACE_LACKS_KILL */ }

ACE_INLINE void ACE_OS::last_error (  int   )

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

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::last_error (  void   )

Definition at line 10 of file OS_NS_errno.inl. Referenced by ACE_POSIX_Asynch_Accept::accept(), ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::connect_i(), dlopen(), ACE_Service_Repository::insert(), ACE_Log_Msg::last_error_adapter(), ACE_Service_Gestalt::process_directives_i(), set_errno_to_last_error(), set_errno_to_wsa_last_error(), set_scheduling_params(), and t_getname(). { // ACE_OS_TRACE ("ACE_OS::last_error"); #if defined (ACE_WIN32) // ACE_OS::last_error() prefers errnor since started out as a way to // avoid directly accessing errno in ACE code - particularly the ACE // C++ socket wrapper facades. On Windows, some things that would // use errno on UNIX require ::GetLastError(), so this method tries // to shield the rest of ACE from having to know about this. 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 )

BSD-style (no QoS). Definition at line 246 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and listen(). Referenced by listen(), ACE_ATM_Acceptor::open(), ACE_Asynch_Acceptor< HANDLER >::open(), ACE_SOCK_SEQPACK_Acceptor::shared_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  )

Definition at line 369 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and localtime(). Referenced by ctime(), localtime(), and localtime_r(). { ACE_OS_TRACE ("ACE_OS::localtime"); #if defined (ACE_LACKS_LOCALTIME) ACE_UNUSED_ARG (t); ACE_NOTSUP_RETURN (0); #else ACE_OSCALL_RETURN (::localtime (t), struct tm *, 0); #endif /* ACE_LACKS_LOCALTIME */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL struct tm * ACE_OS::localtime_r (  const time_t *  clock, struct tm *  res )

Definition at line 226 of file OS_NS_time.cpp. References ACE_NOTSUP_RETURN, ACE_OS_GUARD, ACE_OS_TRACE, localtime(), and localtime_r(). Referenced by localtime_r(), and 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); # else ACE_OSCALL_RETURN (::localtime_r (t, res), struct tm *, 0); # endif /* DIGITAL_UNIX */ #elif !defined (ACE_HAS_WINCE) 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; } #elif defined (ACE_HAS_WINCE) // This is really stupid, converting FILETIME to timeval back and // forth. It assumes FILETIME and DWORDLONG are the same structure // internally. TIME_ZONE_INFORMATION pTz; const unsigned short int __mon_yday[2][13] = { /* Normal years. */ { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }, /* Leap years. */ { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } }; ULARGE_INTEGER _100ns; ::GetTimeZoneInformation (&pTz); _100ns.QuadPart = (DWORDLONG) *t * 10000 * 1000 + ACE_Time_Value::FILETIME_to_timval_skew; FILETIME file_time; file_time.dwLowDateTime = _100ns.LowPart; file_time.dwHighDateTime = _100ns.HighPart; FILETIME localtime; SYSTEMTIME systime; FileTimeToLocalFileTime (&file_time, &localtime); FileTimeToSystemTime (&localtime, &systime); res->tm_hour = systime.wHour; if(pTz.DaylightBias!=0) res->tm_isdst = 1; else res->tm_isdst = 1; int iLeap; iLeap = (res->tm_year % 4 == 0 && (res->tm_year% 100 != 0 || res->tm_year % 400 == 0)); // based on leap select which group to use res->tm_mday = systime.wDay; res->tm_min = systime.wMinute; res->tm_mon = systime.wMonth - 1; res->tm_sec = systime.wSecond; res->tm_wday = systime.wDayOfWeek; res->tm_yday = __mon_yday[iLeap][systime.wMonth] + systime.wDay; res->tm_year = systime.wYear;// this the correct year but bias the value to start at the 1900 res->tm_year = res->tm_year - 1900; 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 )

Definition at line 613 of file OS_NS_unistd.inl. References ACE_FAIL_RETURN, 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 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 (static_cast<off_t> (-1)); else return result; #else ACE_OSCALL_RETURN (::lseek (handle, offset, whence), off_t, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::lstat (  const wchar_t *  , ACE_stat *  )

Definition at line 139 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, lstat(), and stat(). { ACE_OS_TRACE ("ACE_OS::lstat"); # if defined (ACE_LACKS_LSTAT) return ACE_OS::stat (file, stp); # else return ACE_OS::lstat (ACE_Wide_To_Ascii (file).char_rep (), stp); # endif /* ACE_LACKS_LSTAT */ }

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

Definition at line 123 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, lstat(), and stat(). Referenced by lstat(). { ACE_OS_TRACE ("ACE_OS::lstat"); # if defined (ACE_LACKS_LSTAT) return ACE_OS::stat (file, stp); # elif 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); # else /* !ACE_HAS_X86_STAT_MACROS */ ACE_OSCALL_RETURN (::lstat (file, stp), int, -1); # endif /* ACE_LACKS_LSTAT */ }

int ACE_OS::lwp_getparams (  ACE_Sched_Params &   )

Definition at line 3389 of file OS_NS_Thread.cpp. References ACE_id_t, ACE_NOTSUP_RETURN, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_SCOPE_THREAD, memcpy(), memset(), priority_control(), sched_params(), and scheduling_class(). 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 &   )

Definition at line 3447 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, 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  map_advice )

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

void * ACE_OS::malloc (  size_t   )

Definition at line 213 of file OS_NS_stdlib.cpp. References ACE_MALLOC_FUNC. Referenced by ACE_ATM_QoS::ACE_ATM_QoS(), ACE_Name_Options::ACE_Name_Options(), ACE_ATM_QoS::construct_options(), ACE::count_interfaces(), ACE_ATM_Stream::get_vpi_vci(), ACE_Static_Object_Lock::instance(), ACE::ldfind(), scandir_emulation(), and tempnam(). { return ACE_MALLOC_FUNC (nbytes); }

ACE_INLINE void * ACE_OS::memchr (  void *  s, int  c, size_t  len )

Finds characters in a buffer (void version). Definition at line 23 of file OS_NS_string.inl. References memchr(). { return const_cast<void *> (ACE_OS::memchr (static_cast<const void *> (s), c, len)); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE const void * ACE_OS::memchr (  const void *  s, int  c, size_t  len )

Finds characters in a buffer (const void version). Definition at line 13 of file OS_NS_string.inl. References memchr_emulation(). Referenced by memchr(). { #if defined (ACE_HAS_MEMCHR) return ::memchr (s, c, len); #else /* ACE_HAS_MEMCHR */ return ACE_OS::memchr_emulation (s, c, len); #endif /* ACE_HAS_MEMCHR */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL const void * ACE_OS::memchr_emulation (  const void *  s, int  c, size_t  len )

Emulated memchr - Finds a character in a buffer. Definition at line 27 of file OS_NS_string.cpp. Referenced by memchr(). { const unsigned char *t = (const unsigned char *) s; const unsigned char *e = (const unsigned char *) s + len; while (t < e) if (((int) *t) == c) return t; else t++; return 0; }

ACE_INLINE int ACE_OS::memcmp (  const void *  t, const void *  s, size_t  len )

Compares two buffers. Definition at line 31 of file OS_NS_string.inl. Referenced by ACE_String_Base< CHAR >::compare(), ACE_INET_Addr::get_host_name_i(), ACE_CDR::LongDouble::operator!=(), ACE_String_Base< CHAR >::operator==(), ACE_NS_String::operator==(), ACE_INET_Addr::operator==(), ACE_CDR::LongDouble::operator==(), ACE_ATM_Addr::operator==(), and strnstr(). { return ::memcmp (t, s, len); }

ACE_INLINE void * ACE_OS::memcpy (  void *  t, const void *  s, size_t  len )

Copies one buffer to another. Definition at line 37 of file OS_NS_string.inl. Referenced by ACE_TLI_Acceptor::accept(), ACE_ATM_QoS::ACE_ATM_QoS(), ACE_Handle_Set::ACE_Handle_Set(), ACE_Message_Block::ACE_Message_Block(), ACE_Metrics_Timeprobe< ACE_LOCK, ALLOCATOR >::ACE_Metrics_Timeprobe(), ACE_Name_Request::ACE_Name_Request(), ACE_NS_String::ACE_NS_String(), ACE_SString::ACE_SString(), ACE_ATM_Addr::addr_to_string(), ACE_String_Base< CHAR >::append(), ACE_Data_Block::clone(), ACE_InputCDR::clone_from(), ACE_TLI_Connector::connect(), ACE_ATM_QoS::construct_options(), ACE_Obstack_T< CHAR >::copy(), ACE_Message_Block::copy(), ACE_ARGV_T< CHAR_TYPE >::create_buf_from_queue(), ACE_Active_Map_Manager_Key::decode(), ACE_Active_Map_Manager_Key::encode(), ACE::get_bcast_addr(), ACE_Configuration_Heap::get_binary_value(), ACE_INET_Addr::get_host_name_i(), ACE_INET_Addr::get_ip_address(), ACE_ATM_Acceptor::get_local_addr(), ACE_TLI::get_option(), ACE_ATM_Stream::get_vpi_vci(), gethrtime(), getmacaddress(), ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::grow_heap(), ACE_Registry_ImpExp::import_config(), ACE_Timeprobe_Ex< ACE_LOCK, ALLOCATOR >::increase_size(), inet_pton(), ACE_Utils::UUID_Generator::init(), ACE_ATM_Addr::init(), ACE_Svc_Conf_Lexer::input(), ACE_Codeset_Registry::locale_to_registry_i(), lwp_getparams(), ACE_SOCK_Dgram::make_multicast_ifaddr6(), ACE_SOCK_Dgram_Bcast::mk_broadcast(), ACE_Name_Request::name(), ACE_Metrics_Timeprobe< ACE_LOCK, ALLOCATOR >::probe_name(), putmsg(), ACE_InputCDR::read_array(), ACE_UPIPE_Stream::recv(), ACE_SOCK_Dgram::recv(), ACE_MEM_IO::recv(), ACE_Codeset_Registry::registry_to_locale_i(), ACE_Obstack_T< CHAR >::request(), scandir_emulation(), ACE_SOCK_Dgram::send(), ACE_MEM_IO::send(), ACE_String_Base< CHAR >::set(), ACE_SPIPE_Addr::set(), ACE_Netlink_Addr::set(), ACE_INET_Addr::set(), ACE_ATM_Addr::set(), ACE_UNIX_Addr::set_addr(), ACE_SPIPE_Addr::set_addr(), ACE_ATM_Addr::set_addr(), ACE_INET_Addr::set_address(), ACE_Configuration_Heap::set_binary_value(), ACE_TLI::set_option(), set_scheduling_params(), ACE_Process_Options::setenv_i(), ACE_SOCK_SEQPACK_Connector::shared_connect_start(), ACE_SOCK_SEQPACK_Acceptor::shared_open(), ACE_Data_Block::size(), ACE_ATM_Addr::string_to_addr(), ACE_Name_Request::value(), and ACE_OutputCDR::write_array(). { #if defined (ACE_HAS_MEMCPY_LOOP_UNROLL) return fast_memcpy (t, s, len); #else return ::memcpy (t, s, len); #endif /* ACE_HAS_MEMCPY_LOOP_UNROLL */ }

ACE_INLINE void * ACE_OS::memmove (  void *  t, const void *  s, size_t  len )

Moves one buffer to another. Definition at line 47 of file OS_NS_string.inl. Referenced by ACE_Message_Block::crunch(), ACE_Svc_Conf_Lexer::scan(), and ACE_Svc_Conf_Lexer::yylex(). { return ::memmove (t, s, len); }

ACE_INLINE void * ACE_OS::memset (  void *  s, int  c, size_t  len )

Fills a buffer with a character value. Definition at line 53 of file OS_NS_string.inl. Referenced by ACE_ATM_Addr::ACE_ATM_Addr(), ACE_ATM_QoS::ACE_ATM_QoS(), ACE_DEV_Addr::ACE_DEV_Addr(), ACE_INET_Addr::ACE_INET_Addr(), ACE_Mem_Map::ACE_Mem_Map(), ACE_Ping_Socket::ACE_Ping_Socket(), ACE_Process::ACE_Process(), ACE_Process_Options::ACE_Process_Options(), ACE_Profile_Timer::ACE_Profile_Timer(), ACE_SPIPE_Addr::ACE_SPIPE_Addr(), ACE_Token_Request::ACE_Token_Request(), ACE_UNIX_Addr::ACE_UNIX_Addr(), ACE_Malloc_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_CB >::calloc(), ACE_Dynamic_Cached_Allocator< ACE_LOCK >::calloc(), ACE_Cached_Allocator< T, ACE_LOCK >::calloc(), ACE_Static_Allocator_Base::calloc(), ACE_New_Allocator::calloc(), cond_init(), condattr_init(), ACE::count_interfaces(), ACE_Thread::disablecancel(), fork_exec(), ACE::get_bcast_addr(), ACE::get_ip_interfaces(), ACE_SOCK_SEQPACK_Association::get_local_addrs(), ACE_ATM_Stream::get_peer_name(), ACE_SOCK_SEQPACK_Association::get_remote_addrs(), ACE_ATM_Stream::get_vpi_vci(), gethostbyaddr_r(), gethostbyname_r(), getmacaddress(), getpeername(), getservbyname_r(), getsockname(), ACE_Filecache_Object::init(), ACE_ATM_Addr::init(), lwp_getparams(), ACE_SOCK_Dgram::make_multicast_ifaddr6(), ACE_Dev_Poll_Reactor::mask_ops_i(), mutex_init(), ACE_ATM_Stream::open(), ACE_ATM_Acceptor::open(), ACE_Sched_Params::priority_max(), ACE_Sched_Params::priority_min(), ACE_Ping_Socket::receive_echo_reply(), ACE_Dev_Poll_Reactor::register_handler_i(), ACE_INET_Addr::reset(), ACE_String_Base< CHAR >::resize(), ACE_Dev_Poll_Reactor::resume_handler_i(), scheduling_class(), ACE_Ping_Socket::send_echo_check(), ACE_TTY_IO::Serial_Params::Serial_Params(), ACE_UNIX_Addr::set(), ACE_SPIPE_Addr::set(), ACE_Netlink_Addr::set(), ACE_INET_Addr::set(), ACE_DEV_Addr::set(), ACE_INET_Addr::set_address(), ACE_ATM_QoS::set_cbr_rate(), ACE::set_handle_limit(), set_scheduling_params(), ACE_SOCK_SEQPACK_Acceptor::shared_open(), ACE_SOCK_Acceptor::shared_open(), ACE_Dev_Poll_Reactor::suspend_handler_i(), thr_create(), and thr_setprio(). { return ::memset (s, c, len); }

ACE_INLINE int ACE_OS::mkdir (  const wchar_t *  path, mode_t  mode = ACE_DEFAULT_DIR_PERMS )

Definition at line 172 of file OS_NS_sys_stat.inl. References ACE_ADAPT_RETVAL, mkdir(), and mode_t. { #if defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (mode); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (CreateDirectoryW (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); #else return ACE_OS::mkdir (ACE_Wide_To_Ascii (path).char_rep (), mode); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::mkdir (  const char *  path, mode_t  mode = ACE_DEFAULT_DIR_PERMS )

Definition at line 151 of file OS_NS_sys_stat.inl. References ACE_ADAPT_RETVAL, ACE_TEXT_CHAR_TO_TCHAR, mkdir(), and mode_t. Referenced by mkdir(). { #if defined (ACE_WIN32) && defined (__IBMCPP__) && (__IBMCPP__ >= 400) ACE_UNUSED_ARG (mode); ACE_OSCALL_RETURN (::_mkdir (const_cast <char *> (path)), int, -1); #elif defined (ACE_HAS_WINCE) ACE_UNUSED_ARG (mode); ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CreateDirectory (ACE_TEXT_CHAR_TO_TCHAR (path), 0), ace_result_), int, -1); #elif defined (ACE_MKDIR_LACKS_MODE) ACE_UNUSED_ARG (mode); ACE_OSCALL_RETURN (::mkdir (path), int, -1); #else ACE_OSCALL_RETURN (::mkdir (path, mode), int, -1); #endif }

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

Definition at line 190 of file OS_NS_sys_stat.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, mkfifo(), and mode_t. Referenced by mkfifo(), ACE_FIFO::open(), and sema_init(). { 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 (ACE_TEXT_ALWAYS_CHAR (file), mode), int, -1); #endif /* ACE_LACKS_MKFIFO */ }

ACE_INLINE ACE_HANDLE ACE_OS::mkstemp (  wchar_t *  s  )

Definition at line 186 of file OS_NS_stdlib.inl. References ACE_TEXT_ALWAYS_CHAR, and ACE_TEXT_WCHAR_TO_TCHAR. { # if !defined (ACE_LACKS_MKSTEMP) return ::mkstemp (ACE_TEXT_WCHAR_TO_TCHAR (ACE_TEXT_ALWAYS_CHAR (s))); # else return ACE_OS::mkstemp_emulation (ACE_TEXT_WCHAR_TO_TCHAR (s)); # endif /* !ACE_LACKS_MKSTEMP */ }

ACE_INLINE ACE_HANDLE ACE_OS::mkstemp (  char *  s  )

Definition at line 175 of file OS_NS_stdlib.inl. References ACE_TEXT_CHAR_TO_TCHAR. Referenced by ACE_FILE_Connector::connect(). { #if !defined (ACE_LACKS_MKSTEMP) return ::mkstemp (s); #else return ACE_OS::mkstemp_emulation (ACE_TEXT_CHAR_TO_TCHAR (s)); #endif /* !ACE_LACKS_MKSTEMP */ }

ACE_INLINE wchar_t * ACE_OS::mktemp (  wchar_t *  s  )

Definition at line 209 of file OS_NS_stdlib.inl. References strcpy(). { # if defined (ACE_WIN32) return ::_wmktemp (s); # else // For narrow-char filesystems, we must convert the wide-char input to // a narrow-char string for mktemp(), then convert the name back to // wide-char for the caller. ACE_Wide_To_Ascii narrow_s (s); if (::mktemp (narrow_s.char_rep ()) == 0) return 0; ACE_Ascii_To_Wide wide_s (narrow_s.char_rep ()); ACE_OS::strcpy (s, wide_s.wchar_rep ()); return s; # endif }

ACE_INLINE char * ACE_OS::mktemp (  char *  s  )

Definition at line 198 of file OS_NS_stdlib.inl. Referenced by ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool(), and ACE_FILE_Addr::set(). { # if defined (ACE_WIN32) return ::_mktemp (s); # else /* ACE_WIN32 */ return ::mktemp (s); # endif /* ACE_WIN32 */ }

time_t ACE_OS::mktime (  struct tm *  timeptr  )

Definition at line 307 of file OS_NS_time.cpp. References ACE_OS_GUARD, ACE_OS_TRACE, and ACE_Time_Value::sec(). { ACE_OS_TRACE ("ACE_OS::mktime"); # if 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 (ACE_STD_NAMESPACE::mktime (t), time_t, (time_t) -1); # endif /* ACE_HAS_WINCE */ }

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 )

Definition at line 39 of file OS_NS_sys_mman.inl. References ACE_BIT_ENABLED, ACE_DEFAULT_FILE_PERMS, ACE_FAIL_RETURN, ACE_MMAP_TYPE, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TCHAR, default_win32_security_attributes_r(), filesize(), MAP_FAILED, MAP_FIXED, MAP_PRIVATE, MAP_SHARED, and sprintf(). Referenced by ACE_Mutex::ACE_Mutex(), event_init(), ACE_Mem_Map::map_it(), sema_init(), and sendfile_emulation(). { 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) */ { SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; const LPSECURITY_ATTRIBUTES attr = ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer); *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 (ACE_HAS_LYNXOS_BROKEN_MMAP) // The LynxOS 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); # if defined (ACE_OPENVMS) ::fsync(file_handle); # endif 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 )

Definition at line 246 of file OS_NS_sys_mman.inl. References ACE_MMAP_TYPE, ACE_NOTSUP_RETURN, 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::msgctl (  int  msqid, int  cmd, struct msqid_ds *  )

Definition at line 10 of file OS_NS_sys_msg.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 25 of file OS_NS_sys_msg.inl. References ACE_NOTSUP_RETURN, 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 ssize_t ACE_OS::msgrcv (  int  int_id, void *  buf, size_t  len, long  type, int  flags )

Definition at line 39 of file OS_NS_sys_msg.inl. References ACE_NOTSUP_RETURN, 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) ACE_OSCALL_RETURN (::msgrcv (int_id, buf, len, type, flags), int, -1); #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 )

Definition at line 58 of file OS_NS_sys_msg.inl. References ACE_NOTSUP_RETURN, 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, const_cast<void *> (buf), len, flags), int, -1); # else ACE_OSCALL_RETURN (::msgsnd (int_id, buf, len, flags), int, -1); # endif /* 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 )

Definition at line 263 of file OS_NS_sys_mman.inl. References ACE_ADAPT_RETVAL, ACE_MMAP_TYPE, ACE_NOTSUP_RETURN, 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 )

Definition at line 286 of file OS_NS_sys_mman.inl. References ACE_ADAPT_RETVAL, ACE_MMAP_TYPE, ACE_NOTSUP_RETURN, ACE_OS_TRACE, and munmap(). Referenced by event_destroy(), munmap(), ACE_Mutex::remove(), sendfile_emulation(), 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 */ }

int ACE_OS::mutex_destroy (  ACE_mutex_t *  m  )

Definition at line 2014 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, mutex_destroy(), and thread_mutex_destroy(). Referenced by event_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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_mutex_destroy (m), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6*/ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_destroy (m), 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_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  lock_scope, const wchar_t *  name, ACE_mutexattr_t *  arg = 0, LPSECURITY_ATTRIBUTES  sa = 0, int  lock_type = 0 )

Definition at line 2054 of file OS_NS_Thread.cpp. References ACE_FAIL_RETURN, mutex_init(), and thread_mutex_init(). { #if defined (ACE_HAS_THREADS) && defined (ACE_HAS_WTHREADS) m->type_ = lock_scope; SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; switch (lock_scope) { case USYNC_PROCESS: m->proc_mutex_ = ::CreateMutexW (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), FALSE, name); if (m->proc_mutex_ == 0) ACE_FAIL_RETURN (-1); else return 0; case USYNC_THREAD: return ACE_OS::thread_mutex_init (&m->thr_mutex_, lock_type, name, attributes); } errno = EINVAL; return -1; #else /* ACE_HAS_THREADS && ACE_HAS_WTHREADS */ return ACE_OS::mutex_init (m, lock_scope, ACE_Wide_To_Ascii (name).char_rep (), attributes, sa, lock_type); #endif /* ACE_HAS_THREADS && ACE_HAS_WTHREADS */ }

int ACE_OS::mutex_init (  ACE_mutex_t *  m, int  lock_scope = ACE_DEFAULT_SYNCH_TYPE, const char *  name = 0, ACE_mutexattr_t *  arg = 0, LPSECURITY_ATTRIBUTES  sa = 0, int  lock_type = 0 )

Definition at line 1832 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_FAIL_RETURN, ACE_NOTSUP_RETURN, memset(), mutex_init(), set_errno_to_last_error(), and thread_mutex_init(). Referenced by ACE_Mutex::ACE_Mutex(), event_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 (sa); # if defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600) && (ACE_VXWORKS <= 0x620) /* Tests show that VxWorks 6.x pthread lib does not only * require zeroing of mutex/condition objects to function correctly * but also of the attribute objects. */ pthread_mutexattr_t l_attributes = {0}; # else pthread_mutexattr_t l_attributes; # endif 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 && lock_scope != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT7) || defined (ACE_HAS_PTHREADS_STD) # if defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_MUTEXATTR_PSHARED) (void) ACE_ADAPT_RETVAL (::pthread_mutexattr_setpshared (attributes, lock_scope), result); # endif /* _POSIX_THREAD_PROCESS_SHARED && !ACE_LACKS_MUTEXATTR_PSHARED */ # else /* Pthreads draft 6 */ # if !defined (ACE_LACKS_MUTEXATTR_PSHARED) if (::pthread_mutexattr_setpshared (attributes, lock_scope) != 0) result = -1; # endif /* ACE_LACKS_MUTEXATTR_PSHARED */ # endif /* ACE_HAS_PTHREADS_DRAFT7 || ACE_HAS_PTHREADS_STD */ } if (result == 0 && lock_type != 0) { # if defined (ACE_HAS_PTHREADS_DRAFT4) # if defined (ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP) if (::pthread_mutexattr_setkind_np (attributes, lock_type) != 0) result = -1; # endif /* ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP */ # elif defined (ACE_HAS_RECURSIVE_MUTEXES) (void) ACE_ADAPT_RETVAL (::pthread_mutexattr_settype (attributes, lock_type), result); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ } if (result == 0) { # if defined (ACE_VXWORKS)&& (ACE_VXWORKS >= 0x600) && (ACE_VXWORKS <= 0x620) /* VxWorks 6.x API reference states: * If the memory for the mutex variable object has been allocated * dynamically, it is a good policy to always zero out the * block of memory so as to avoid spurious EBUSY return code * when calling this routine. * Tests shows this to be necessary. */ ACE_OS::memset (m, 0, sizeof (*m)); # endif # if defined (ACE_HAS_PTHREADS_DRAFT4) if (::pthread_mutex_init (m, *attributes) == 0) # elif defined (ACE_HAS_PTHREADS_DRAFT7) || defined (ACE_HAS_PTHREADS_STD) if (ACE_ADAPT_RETVAL (::pthread_mutex_init (m, attributes), result) == 0) # else if (::pthread_mutex_init (m, attributes) == 0) # endif /* ACE_HAS_PTHREADS_DRAFT4 */ result = 0; else result = -1; // ACE_ADAPT_RETVAL used it for intermediate status } // 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_UNUSED_ARG (lock_type); int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_init (m, lock_scope, attributes), result), int, -1); # elif defined (ACE_HAS_WTHREADS) m->type_ = lock_scope; SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; switch (lock_scope) { 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_r (sa, &sa_buffer, &sd_buffer), FALSE, ACE_Ascii_To_Wide (name).wchar_rep ()); # else /* ACE_HAS_WINCE */ m->proc_mutex_ = ::CreateMutexA (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), 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_, lock_type, name, attributes); default: errno = EINVAL; return -1; } /* NOTREACHED */ # elif defined (ACE_VXWORKS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (sa); ACE_UNUSED_ARG (lock_type); return (*m = ::semMCreate (lock_scope)) == 0 ? -1 : 0; # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (lock_scope); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (attributes); ACE_UNUSED_ARG (sa); ACE_UNUSED_ARG (lock_type); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

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

If == 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 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 since some implementations of this method don't support recursive mutexes. If you want to use a recursive mutex see the methods below. Definition at line 461 of file OS_NS_Thread.inl. References mutex_lock(). { return timeout == 0 ? ACE_OS::mutex_lock (m) : ACE_OS::mutex_lock (m, *timeout); }

int ACE_OS::mutex_lock (  ACE_mutex_t *  m, const ACE_Time_Value &  timeout )

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 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 since some implementations of this method don't support recursive mutexes. If you want to use a recursive mutex see the methods below. Definition at line 2189 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_ONE_SECOND_IN_USECS, EBUSY, ETIME, ETIMEDOUT, ACE_Time_Value::msec(), ACE_Time_Value::sec(), set_errno_to_last_error(), timespec_t, 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_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 */ }

int ACE_OS::mutex_lock (  ACE_mutex_t *  m, int &  abandoned )

This method is only implemented for Win32. For abandoned mutexes, is set to 1 and 0 is returned. Definition at line 2150 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, 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 */ }

int ACE_OS::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. Definition at line 2098 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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(), 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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_mutex_lock (m), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_lock (m), 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_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  )

Handle asynchronous thread cancellation cleanup. Definition at line 2430 of file OS_NS_Thread.cpp. References ACE_OS_TRACE, and mutex_unlock(). { 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 */ }

int ACE_OS::mutex_trylock (  ACE_mutex_t *  m, int &  abandoned )

This method is only implemented for Win32. For abandoned mutexes, is set to 1 and 0 is returned. Definition at line 2351 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, 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 */ }

int ACE_OS::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. Definition at line 2277 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, EBUSY, mutex_trylock(), set_errno_to_last_error(), and thread_mutex_trylock(). Referenced by 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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_mutex_trylock (m), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_trylock (m), 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_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 */ }

int ACE_OS::mutex_unlock (  ACE_mutex_t *  m  )

Definition at line 2390 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, mutex_unlock(), and thread_mutex_unlock(). Referenced by event_pulse(), event_reset(), event_signal(), event_timedwait(), event_wait(), 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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_mutex_unlock (m), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::mutex_unlock (m), 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_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 )

Definition at line 381 of file OS_NS_time.inl. References ACE_OS_TRACE, ACE_TIMESPEC_PTR, and sleep(). 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); #else ACE_UNUSED_ARG (remaining); // Convert into seconds and microseconds. ACE_Time_Value tv (requested->tv_sec, requested->tv_nsec / 1000); return ACE_OS::sleep (tv); #endif /* ACE_HAS_CLOCK_GETTIME */ }

long ACE_OS::num_processors (  void   )

Get the number of CPUs configured in the machine. Definition at line 293 of file OS_NS_unistd.cpp. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and num_processors(). Referenced by num_processors(), and num_processors_online(). { ACE_OS_TRACE ("ACE_OS::num_processors"); #if defined (ACE_HAS_PHARLAP) return 1; #elif defined (ACE_WIN32) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return sys_info.dwNumberOfProcessors; #elif defined (_SC_NPROCESSORS_CONF) return ::sysconf (_SC_NPROCESSORS_CONF); #elif defined (ACE_HAS_SYSCTL) int num_processors; int mib[2] = { CTL_HW, HW_NCPU }; size_t len = sizeof (num_processors); sysctl(mib, 2, &num_processors, &len, NULL, 0); return num_processors; #else ACE_NOTSUP_RETURN (-1); #endif }

long ACE_OS::num_processors_online (  void   )

Get the number of CPUs currently online. Definition at line 318 of file OS_NS_unistd.cpp. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and num_processors(). { ACE_OS_TRACE ("ACE_OS::num_processors_online"); #if defined (ACE_HAS_PHARLAP) return 1; #elif defined (ACE_WIN32) SYSTEM_INFO sys_info; ::GetSystemInfo (&sys_info); return sys_info.dwNumberOfProcessors; #elif defined (_SC_NPROCESSORS_ONLN) return ::sysconf (_SC_NPROCESSORS_ONLN); #elif defined (ACE_HAS_SYSCTL) int num_processors; int mib[2] = { CTL_HW, HW_NCPU }; size_t len = sizeof (num_processors); sysctl(mib, 2, &num_processors, &len, NULL, 0); return num_processors; #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 )

Definition at line 133 of file OS_NS_fcntl.cpp. References access(), ACE_BIT_ENABLED, ACE_FAIL_RETURN, open(), and thread_mutex_lock(). { #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 = static_cast <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; SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; ACE_HANDLE h = ::CreateFileW (filename, access, shared_mode, ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_HANDLE ACE_OS::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. Definition at line 19 of file OS_NS_fcntl.cpp. References access(), ACE_BIT_ENABLED, ACE_DEV_NULL, ACE_FAIL_RETURN, ACE_OS_TRACE, strcmp(), and thread_mutex_lock(). Referenced by ACE_Filecache_Object::ACE_Filecache_Object(), ACE_SPIPE_Connector::connect(), ACE_Handle_Gobbler::consume_handles(), creat(), dlopen(), filesize(), fopen(), ACE::get_handle(), ACE::handle_timed_open(), open(), ACE_Mem_Map::open(), ACE_FIFO_Recv::open(), ACE_Dev_Poll_Reactor::open(), ACE::open_temp_file(), ACE_Filecache_Object::release(), sema_init(), 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 = static_cast <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; SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; #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_r (sa, &sa_buffer, &sd_buffer), creation, flags, 0); #else /* ACE_HAS_WINCE */ ACE_HANDLE h = ::CreateFileA (filename, access, shared_mode, ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), 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 (INTEGRITY) ACE_UNUSED_ARG (sa); if(!strcmp(filename,ACE_DEV_NULL)) { ACE_OSCALL_RETURN (::AllocateNullConsoleDescriptor(), ACE_HANDLE, -1); } else { ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, -1); } #else ACE_UNUSED_ARG (sa); ACE_OSCALL_RETURN (::open (filename, mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE); #endif /* ACE_WIN32 */ }

ACE_INLINE ACE_DIR * ACE_OS::opendir (  const ACE_TCHAR *  filename  )

Definition at line 32 of file OS_NS_dirent.inl. References ACE_NOTSUP_RETURN, ACE_TCHAR, and ACE_TEXT_ALWAYS_CHAR. Referenced by ACE_Dirent::open(), and scandir_emulation(). { #if defined (ACE_HAS_DIRENT) # if defined (ACE_WIN32) && defined (ACE_LACKS_OPENDIR) return ::ACE_OS::opendir_emulation (filename); # elif defined (ACE_HAS_WOPENDIR) && defined (ACE_USES_WCHAR) return ::wopendir (filename); # elif defined (ACE_HAS_NONCONST_OPENDIR) return ::opendir (const_cast<char *> (filename)); # else /* ! ACE_WIN32 && ACE_LACKS_OPENDIR */ return ::opendir (ACE_TEXT_ALWAYS_CHAR (filename)); # endif /* ACE_WIN32 && ACE_LACKS_OPENDIR */ #else ACE_UNUSED_ARG (filename); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_DIRENT */ }

ACE_INLINE void ACE_OS::perror (  const wchar_t *  s  )

Definition at line 740 of file OS_NS_stdio.inl. References ACE_OS_TRACE. { 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) ::_wperror (s); #else ACE_Wide_To_Ascii n_s (s); ::perror (n_s.char_rep ()); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE void ACE_OS::perror (  const char *  s  )

Definition at line 727 of file OS_NS_stdio.inl. References ACE_OS_TRACE. 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); #else ::perror (s); #endif /* ACE_HAS_WINCE */ }

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

Definition at line 751 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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 (ACE_LACKS_PIPE) ACE_UNUSED_ARG (fds); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_WIN32) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CreatePipe (&fds[0], &fds[1], 0, 0), ace_result_), int, -1); # else ACE_OSCALL_RETURN (::pipe (fds), int, -1); # endif /* ACE_LACKS_PIPE */ }

ACE_INLINE int ACE_OS::poll (  struct pollfd *  pollfds, unsigned long  len, const ACE_Time_Value &  tv )

Definition at line 29 of file OS_NS_poll.inl. References ACE_NOTSUP_RETURN, 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::poll (  struct pollfd *  pollfds, unsigned long  len, const ACE_Time_Value *  tv = 0 )

Definition at line 11 of file OS_NS_poll.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, 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 */ }

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

Definition at line 374 of file OS_NS_unistd.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, 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, ...  )

Definition at line 253 of file OS_NS_stdio.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(), 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 long ACE_OS::priority_control (  ACE_idtype_t  , ACE_id_t  , int  , void *  )

Low-level interface to (2). Can't call the following priocntl, because that's a macro on Solaris. Definition at line 504 of file OS_NS_Thread.inl. References ACE_id_t, ACE_idtype_t, ACE_NOTSUP_RETURN, and ACE_OS_TRACE. 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, identifier, cmd, static_cast<caddr_t> (arg)), long, -1); #else /* ! ACE_HAS_PRIOCNTL*/ ACE_UNUSED_ARG (idtype); ACE_UNUSED_ARG (identifier); 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 )

Definition at line 27 of file OS_NS_signal.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsp, osp), 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 wchar_t *  string  )

Definition at line 276 of file OS_NS_stdlib.inl. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::putenv"); #if defined (ACE_HAS_WINCE) // WinCE doesn't have the concept of environment variables. ACE_UNUSED_ARG (string); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::_wputenv (string), int, -1); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::putenv (  const char *  string  )

Definition at line 236 of file OS_NS_stdlib.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, free(), strchr(), and strdup(). Referenced by ACE_Process::spawn(). { ACE_OS_TRACE ("ACE_OS::putenv"); #if defined (ACE_HAS_WINCE) // WinCE don't have the concept of environment variables. ACE_UNUSED_ARG (string); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_LACKS_PUTENV) && defined (ACE_HAS_SETENV) int result = 0; char* sp = ACE_OS::strchr (const_cast <char *> (string), '='); if (sp) { char* stmp = ACE_OS::strdup (string); if (stmp) { stmp[sp - string] = '\0'; ACE_OSCALL (::setenv(stmp, sp+sizeof(char), 1), int, -1, result); ACE_OS::free (stmp); } else { errno = ENOMEM; result = -1; } } else { ACE_OSCALL (::setenv(string, "", 1), int, -1, result); } return result; #elif defined (ACE_LACKS_ENV) || defined (ACE_LACKS_PUTENV) ACE_UNUSED_ARG (string); ACE_NOTSUP_RETURN (0); #else /* ! ACE_HAS_WINCE */ ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::putenv (const_cast <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 )

Definition at line 139 of file OS_NS_stropts.inl. References ACE_NEW_RETURN, ACE_OS_TRACE, ACE_STRBUF_TYPE, memcpy(), putmsg(), ssize_t, 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); ssize_t result; if (ctl == 0 && data == 0) { errno = EINVAL; return 0; } // Handle the two easy cases. else if (ctl != 0) { result = ACE_OS::write (handle, ctl->buf, ctl->len); return static_cast<int> (result); } else if (data != 0) { result = ACE_OS::write (handle, data->buf, data->len); return static_cast<int> (result); } 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); result = ACE_OS::write (handle, buf, ctl->len + data->len); delete [] buf; return static_cast<int> (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 )

Definition at line 182 of file OS_NS_stropts.inl. References ACE_OS_TRACE, ACE_STRBUF_TYPE, 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 wchar_t *  s  )

Definition at line 764 of file OS_NS_stdio.inl. References ACE_OS_TRACE, and puts(). { ACE_OS_TRACE ("ACE_OS::puts"); #if defined (ACE_WIN32) ACE_OSCALL_RETURN (::_putws (s), int, -1); #else /* ACE_WIN32 */ // There's no putws()... ACE_Wide_To_Ascii n_s (s); ACE_OSCALL_RETURN (::puts (n_s.char_rep ()), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::puts (  const char *  s  )

Definition at line 756 of file OS_NS_stdio.inl. References ACE_OS_TRACE, and puts(). Referenced by puts(). { ACE_OS_TRACE ("ACE_OS::puts"); ACE_OSCALL_RETURN (::puts (s), int, -1); }

ssize_t ACE_OS::pwrite (  ACE_HANDLE  handle, const void *  buf, size_t  nbyte, ACE_LOFF_T  offset )

Definition at line 499 of file OS_NS_unistd.cpp. References ACE_LOFF_T, 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 LARGE_INTEGER loffset; loffset.QuadPart = offset; DWORD altered_position = ::SetFilePointerEx (handle, loffset, 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, 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  )

Definition at line 290 of file OS_NS_stdlib.inl. References ACE_COMPARE_FUNC. Referenced by 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   )

Definition at line 306 of file OS_NS_stdlib.inl. References ACE_OS_TRACE, and rand(). Referenced by ACE_Utils::UUID_Generator::init(), and rand(). { ACE_OS_TRACE ("ACE_OS::rand"); ACE_OSCALL_RETURN (::rand (), int, -1); }

ACE_INLINE int ACE_OS::rand_r (  ACE_RANDR_TYPE &  seed  )

Definition at line 336 of file OS_NS_stdlib.inl. References ACE_OS_TRACE, and ACE_RANDR_TYPE. { ACE_OS_TRACE ("ACE_OS::rand_r"); long new_seed = (long)(seed); if (new_seed == 0) new_seed = 0x12345987; long temp = new_seed / 127773; new_seed = 16807 * (new_seed - temp * 127773) - 2836 * temp; if (new_seed < 0) new_seed += 2147483647; (seed) = (unsigned int)new_seed; return (int)(new_seed & RAND_MAX); }

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

Definition at line 714 of file OS_NS_unistd.inl. References ACE_FAIL_RETURN, ACE_OS_TRACE, ACE_OVERLAPPED, read(), and ssize_t. { ACE_OS_TRACE ("ACE_OS::read"); overlapped = overlapped; #if defined (ACE_WIN32) DWORD ok_len; DWORD short_len = 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 )

Definition at line 674 of file OS_NS_unistd.inl. References ACE_FAIL_RETURN, ACE_OS_TRACE, EWOULDBLOCK, and ssize_t. Referenced by ACE_UPIPE_Acceptor::accept(), pread(), read(), read_n(), ACE_SPIPE_Stream::recv(), ACE_SOCK_IO::recv(), ACE_Pipe::recv(), ACE_FILE_IO::recv(), ACE_FIFO_Recv_Msg::recv(), ACE_FIFO_Recv::recv(), ACE_DEV_IO::recv(), ACE::recv_i(), sema_trywait(), and sema_wait(). { ACE_OS_TRACE ("ACE_OS::read"); #if defined (ACE_WIN32) DWORD ok_len; if (::ReadFile (handle, buf, static_cast<DWORD> (len), &ok_len, 0)) return (ssize_t) ok_len; else ACE_FAIL_RETURN (-1); #else ssize_t result; # if defined (ACE_HAS_CHARPTR_SOCKOPT) ACE_OSCALL (::read (handle, static_cast <char *> (buf), len), ssize_t, -1, result); # else ACE_OSCALL (::read (handle, buf, len), ssize_t, -1, result); # endif /* ACE_HAS_CHARPTR_SOCKOPT */ # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK) // Optimize this code out if we can detect that EAGAIN == // EWOULDBLOCK at compile time. If we cannot detect equality at // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor // macros) perform the check at run-time. The goal is to avoid two // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK. if (result == -1 # if !defined (EAGAIN) || !defined (EWOULDBLOCK) && EAGAIN != EWOULDBLOCK # endif /* !EAGAIN || !EWOULDBLOCK */ && errno == EAGAIN) { errno = EWOULDBLOCK; } # endif /* EAGAIN != 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 )

Receive bytes into from (uses the <ACE_OS::read> call, which uses the system call on UNIX and the call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>. Definition at line 349 of file OS_NS_unistd.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 struct ACE_DIRENT * ACE_OS::readdir (  ACE_DIR *   )

Definition at line 52 of file OS_NS_dirent.inl. References ACE_DIR, and ACE_NOTSUP_RETURN. Referenced by ACE_Dirent::read(), readdir_r(), and scandir_emulation(). { #if defined (ACE_HAS_DIRENT) # if defined (ACE_WIN32) && defined (ACE_LACKS_READDIR) return ACE_OS::readdir_emulation (d); # elif defined (ACE_HAS_WREADDIR) && defined (ACE_USES_WCHAR) return ::wreaddir (d); # else /* ACE_WIN32 && ACE_LACKS_READDIR */ return ::readdir (d); # endif /* ACE_WIN32 && ACE_LACKS_READDIR */ #else ACE_UNUSED_ARG (d); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_DIRENT */ }

ACE_INLINE int ACE_OS::readdir_r (  ACE_DIR *  dirp, struct ACE_DIRENT *  entry, struct ACE_DIRENT **  result )

Definition at line 69 of file OS_NS_dirent.inl. References ACE_DIR, ACE_NOTSUP_RETURN, and readdir(). Referenced by ACE_Dirent::read(). { #if !defined (ACE_HAS_REENTRANT_FUNCTIONS) ACE_UNUSED_ARG (entry); // <result> has better not be 0! *result = ACE_OS::readdir (dirp); if (*result) return 0; // Keep iterating else return 1; // Oops, some type of error! #elif defined (ACE_HAS_DIRENT) && !defined (ACE_LACKS_READDIR_R) # if (defined (sun) && (defined (_POSIX_PTHREAD_SEMANTICS) || \ (_FILE_OFFSET_BITS == 64) || \ (_POSIX_C_SOURCE - 0 >= 199506L))) || \ (!defined (sun) && (defined (ACE_HAS_PTHREADS_STD) || \ defined (ACE_HAS_PTHREADS_DRAFT7) || \ defined (__USE_POSIX) || \ defined (__FreeBSD__) || \ defined (HPUX_11))) # if defined (__GNUG__) && defined (DIGITAL_UNIX) return readdir_r (dirp, entry, result); # else return ::readdir_r (dirp, entry, result); # endif /* defined (__GNUG__) && defined (DIGITAL_UNIX) */ # else /* ! POSIX.1c - this is draft 4 or draft 6 */ # if defined(__GNUC__) && defined (_AIX) return ::readdir_r (dirp, entry, result); # else // <result> had better not be 0! *result = ::readdir_r (dirp, entry); return 0; # endif /* AIX */ # endif /* ! POSIX.1c */ #else /* ! ACE_HAS_DIRENT || ACE_LACKS_READDIR_R */ ACE_UNUSED_ARG (dirp); ACE_UNUSED_ARG (entry); ACE_UNUSED_ARG (result); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_REENTRANT_FUNCTIONS */ }

ACE_INLINE ssize_t ACE_OS::readlink (  const char *  path, char *  buf, size_t  bufsiz )

Definition at line 732 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, readlink(), and ssize_t. Referenced by readlink(). { ACE_OS_TRACE ("ACE_OS::readlink"); # if defined (ACE_LACKS_READLINK) 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), ssize_t, -1); # else ACE_OSCALL_RETURN ( ::readlink (const_cast <char *>(path), buf, bufsiz), ssize_t, -1); # endif # endif /* ACE_LACKS_READLINK */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ssize_t ACE_OS::readv (  ACE_HANDLE  handle, const iovec *  iov, int  iovlen )

Definition at line 10 of file OS_NS_sys_uio.inl. References ACE_OS_TRACE, and ssize_t. Referenced by ACE::readv_n(), ACE_SPIPE_Stream::recv(), ACE_Pipe::recv(), ACE_FILE_IO::recv(), ACE_DEV_IO::recv(), recvv(), ACE_SPIPE_Stream::recvv_n(), ACE_Pipe::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 */ #if defined (ACE_HAS_NONCONST_READV) ACE_OSCALL_RETURN (::readv (handle, const_cast<iovec *>(iov), iovlen), ssize_t, -1); #else ACE_OSCALL_RETURN (::readv (handle, iov, iovlen), ssize_t, -1); #endif /* ACE_HAS_NONCONST_READV */ #endif /* ACE_LACKS_READV */ }

void * ACE_OS::realloc (  void *  , size_t  )

Definition at line 269 of file OS_NS_stdlib.cpp. References ACE_MALLOC_T, and ACE_REALLOC_FUNC. Referenced by scandir_emulation(). { return ACE_REALLOC_FUNC (ACE_MALLOC_T (ptr), nbytes); }

ACE_INLINE wchar_t * ACE_OS::realpath (  const wchar_t *  file_name, wchar_t *  resolved_name )

Definition at line 369 of file OS_NS_stdlib.inl. References PATH_MAX, realpath(), and strcpy(). { # if defined (ACE_WIN32) return ::_wfullpath (resolved_name, file_name, PATH_MAX); # else /* ACE_WIN32 */ ACE_Wide_To_Ascii n_file_name (file_name); char n_resolved[PATH_MAX]; if (0 != ACE_OS::realpath (n_file_name.char_rep (), n_resolved)) { ACE_Ascii_To_Wide w_resolved (n_resolved); ACE_OS::strcpy (resolved_name, w_resolved.wchar_rep ()); return resolved_name; } return 0; # endif /* ! ACE_WIN32 */ }

ACE_INLINE char * ACE_OS::realpath (  const char *  file_name, char *  resolved_name )

Definition at line 356 of file OS_NS_stdlib.inl. References PATH_MAX. Referenced by realpath(). { # if defined (ACE_WIN32) return ::_fullpath (resolved_name, file_name, PATH_MAX); # else /* ACE_WIN32 */ return ::realpath (file_name, resolved_name); # endif /* ! ACE_WIN32 */ }

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

Definition at line 634 of file OS_NS_Thread.inl. 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 )

Definition at line 526 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_thread_t, 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_, 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. // // For WinCE, the situation is a bit trickier. CE doesn't have // RecursionCount, and LockCount is not an indicator of recursion on WinCE; // instead, see when it's unlocked by watching the OwnerThread, which will // change to something other than the current thread when it's been // unlocked "enough" times. Note that checking for 0 (unlocked) is not // sufficient. Another thread may acquire the lock between our unlock and // checking the OwnerThread. So grab our thread ID value first, then // compare to it in the loop condition. # if defined (ACE_HAS_WINCE) ACE_thread_t me = ACE_OS::thr_self (); # endif /* ACE_HAS_WINCE */ state.relock_count_ = 0; while (m->LockCount > 0 # if defined (ACE_HAS_WINCE) // Although this is a thread ID, OwnerThread's type is HANDLE. // Not sure if this is a problem, but it appears to work. && m->OwnerThread == (HANDLE)me # else && 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  )

Definition at line 683 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, cond_destroy(), ACE_recursive_thread_mutex_t::lock_available_, ACE_recursive_thread_mutex_t::nesting_mutex_, and thread_mutex_destroy(). Referenced by 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 )

Definition at line 703 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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_, ACE_recursive_thread_mutex_t::owner_id_, and thread_mutex_init(). Referenced by ACE_Recursive_Thread_Mutex::ACE_Recursive_Thread_Mutex(). { ACE_UNUSED_ARG (sa); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_RECURSIVE_MUTEXES) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) return ACE_OS::thread_mutex_init (m, PTHREAD_MUTEX_RECURSIVE, name, arg); # else return ACE_OS::thread_mutex_init (m, 0, name, arg); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ # 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, const ACE_Time_Value *  timeout )

Definition at line 856 of file OS_NS_Thread.inl. References recursive_mutex_lock(). { return timeout == 0 ? ACE_OS::recursive_mutex_lock (m) : ACE_OS::recursive_mutex_lock (m, *timeout); }

ACE_INLINE int ACE_OS::recursive_mutex_lock (  ACE_recursive_thread_mutex_t *  m, const ACE_Time_Value &  timeout )

Definition at line 791 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_thread_t, cond_timedwait(), 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(). { #if defined (ACE_HAS_THREADS) #if defined (ACE_HAS_RECURSIVE_MUTEXES) return ACE_OS::thread_mutex_lock (m, timeout); #else ACE_thread_t t_id = ACE_OS::thr_self (); int result = 0; // Try to acquire the guard. if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_, timeout) == -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) { result = ACE_OS::cond_timedwait (&m->lock_available_, &m->nesting_mutex_, const_cast <ACE_Time_Value *> (&timeout)); // The mutex is reacquired even in the case of a timeout // release the mutex to prevent a deadlock if (result == -1) { // Save/restore errno. ACE_Errno_Guard error (errno); ACE_OS::thread_mutex_unlock (&m->nesting_mutex_); return result; } } // 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_UNUSED_ARG (timeout); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::recursive_mutex_lock (  ACE_recursive_thread_mutex_t *  m  )

Definition at line 740 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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(), recursive_mutex_cond_relock(), and recursive_mutex_lock(). { #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  )

Definition at line 865 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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  )

Definition at line 910 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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_, 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 ssize_t ACE_OS::recv (  ACE_HANDLE  handle, char *  buf, size_t  len, int  flags = 0 )

BSD-style (no QoS). Definition at line 253 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, EWOULDBLOCK, and ssize_t. Referenced by ACE_Pipe::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, static_cast<int> (len), flags), ssize_t, -1); #else ssize_t ace_result_; ace_result_ = ::recv ((ACE_SOCKET) handle, buf, len, flags); # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK) // Optimize this code out if we can detect that EAGAIN == // EWOULDBLOCK at compile time. If we cannot detect equality at // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor // macros) perform the check at run-time. The goal is to avoid two // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK. if (ace_result_ == -1 # if !defined (EAGAIN) || !defined (EWOULDBLOCK) && EAGAIN != EWOULDBLOCK # endif /* !EAGAIN || !EWOULDBLOCK */ && errno == EAGAIN) { errno = EWOULDBLOCK; } # endif /* EAGAIN != EWOULDBLOCK*/ return ace_result_; #endif /* defined (ACE_WIN32) */ }

ACE_INLINE ssize_t 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 )

BSD-style (no QoS). Definition at line 333 of file OS_NS_sys_socket.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, and set_errno_to_wsa_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_wsa_last_error (); } flags = the_flags; number_of_bytes_recvd = 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 ssize_t ACE_OS::recvfrom (  ACE_HANDLE  handle, char *  buf, size_t  len, int  flags, struct sockaddr *  addr, int *  addrlen )

BSD-style (no QoS). Definition at line 294 of file OS_NS_sys_socket.inl. References ACE_BIT_ENABLED, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, ACE_SOCKET_LEN, set_errno_to_wsa_last_error(), and ssize_t. Referenced by ACE_WIN32_Asynch_Read_Dgram::recv(), ACE_SOCK_Dgram::recv(), ACE_ICMP_Socket::recv(), and ACE::recvfrom(). { ACE_OS_TRACE ("ACE_OS::recvfrom"); #if defined (ACE_WIN32) int shortened_len = 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 */ ACE_SOCKCALL_RETURN (::recvfrom ((ACE_SOCKET) handle, buf, len, flags, addr, (ACE_SOCKET_LEN *) addrlen), ssize_t, -1); #endif /* defined (ACE_WIN32) */ }

ACE_INLINE ssize_t ACE_OS::recvmsg (  ACE_HANDLE  handle, struct msghdr *  msg, int  flags )

BSD-style (no QoS). Definition at line 378 of file OS_NS_sys_socket.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, msghdr::msg_iov, msghdr::msg_iovlen, msghdr::msg_name, msghdr::msg_namelen, set_errno_to_wsa_last_error(), and ssize_t. Referenced by 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_wsa_last_error (); return -1; } else return bytes_received; # else /* ACE_HAS_WINSOCK2 */ ACE_SOCKCALL_RETURN (::recvmsg (handle, msg, flags), ssize_t, -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 )

BSD-style (no QoS). Definition at line 415 of file OS_NS_sys_socket.inl. References iovec::iov_base, readv(), set_errno_to_wsa_last_error(), and ssize_t. Referenced by ACE_SOCK_IO::recv(), ACE_Pipe::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 wchar_t *  old_name, const wchar_t *  new_name, int  flags = -1 )

Definition at line 812 of file OS_NS_stdio.inl. References ACE_FAIL_RETURN, ACE_NOTSUP_RETURN, 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 (MoveFileW (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 (::MoveFileExW (old_name, new_name, flags) == 0) ACE_FAIL_RETURN (-1); return 0; # elif defined (ACE_WIN32) ACE_UNUSED_ARG (flags); ACE_OSCALL_RETURN (::_wrename (old_name, new_name), int, -1); # else /* ACE_LACKS_RENAME */ ACE_Wide_To_Ascii nold_name (old_name); ACE_Wide_To_Ascii nnew_name (new_name); return ACE_OS::rename (nold_name.char_rep (), nnew_name.char_rep (), flags); # endif /* ACE_LACKS_RENAME */ }

ACE_INLINE int ACE_OS::rename (  const char *  old_name, const char *  new_name, int  flags = -1 )

Definition at line 778 of file OS_NS_stdio.inl. References ACE_FAIL_RETURN, ACE_NOTSUP_RETURN, ACE_TEXT_CHAR_TO_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) // Win CE is always wide-char. ACE_UNUSED_ARG (flags); if (0 != MoveFile (ACE_TEXT_CHAR_TO_TCHAR (old_name), ACE_TEXT_CHAR_TO_TCHAR (new_name))) 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 (::MoveFileExA (old_name, new_name, flags) == 0) ACE_FAIL_RETURN (-1); return 0; # 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  )

Definition at line 848 of file OS_NS_stdio.inl. References ACE_OS_TRACE, and fseek(). { #if !defined (ACE_HAS_WINCE) ACE_OS_TRACE ("ACE_OS::rewind"); ::rewind (fp); #else // This isn't perfect since it doesn't reset EOF, but it's probably // the closest we can get on WINCE. (void) fseek (fp, 0L, SEEK_SET); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE void ACE_OS::rewinddir (  ACE_DIR *   )

Definition at line 114 of file OS_NS_dirent.inl. References ACE_DIR. Referenced by ACE_Dirent::rewind(). { #if defined (ACE_HAS_DIRENT) # if defined (ACE_LACKS_SEEKDIR) # if defined (ACE_LACKS_REWINDDIR) ACE_UNUSED_ARG (d); # elif defined (ACE_HAS_WREWINDDIR) && defined (ACE_USES_WCHAR) ::wrewinddir (d); # else /* ! defined (ACE_LACKS_REWINDDIR) */ ::rewinddir (d); # endif /* ! defined (ACE_LACKS_REWINDDIR) */ # else /* ! ACE_LACKS_SEEKDIR */ // We need to implement <rewinddir> using <seekdir> since it's often // defined as a macro... ::seekdir (d, long (0)); # endif /* ! ACE_LACKS_SEEKDIR */ #else ACE_UNUSED_ARG (d); #endif /* ACE_HAS_DIRENT */ }

ACE_INLINE int ACE_OS::rmdir (  const wchar_t *  path  )

Definition at line 170 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, and rmdir(). { #if defined (ACE_HAS_WINCE) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::RemoveDirectoryW (path), ace_result_), int, -1); #elif defined (ACE_WIN32) ACE_OSCALL_RETURN (::_wrmdir (path), int, -1); #else ACE_Wide_To_Ascii n_path (path); return ACE_OS::rmdir (n_path.char_rep ()); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::rmdir (  const char *  path  )

Definition at line 155 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_TEXT_CHAR_TO_TCHAR, and rmdir(). Referenced by rmdir(). { #if defined (ACE_WIN32) && defined (__IBMCPP__) && (__IBMCPP__ >= 400) ACE_OSCALL_RETURN (::_rmdir ((char *) path), int, -1); #elif defined (ACE_HAS_WINCE) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::RemoveDirectory (ACE_TEXT_CHAR_TO_TCHAR (path)), ace_result_), int, -1); #else ACE_OSCALL_RETURN (::rmdir (path), int, -1); #endif /* ACE_WIN32 */ }

ACE_INLINE int ACE_OS::rw_rdlock (  ACE_rwlock_t *  rw  )

Definition at line 964 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_rdlock (rw), result), int, -1); # else /* Solaris */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_rdlock (rw), 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  )

Definition at line 1015 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_tryrdlock (rw), result), int, -1); # else /* Solaris */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_tryrdlock (rw), 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  )

Definition at line 1058 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_trywrlock (rw), result), int, -1); # else /* Solaris */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_trywrlock (rw), 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  )

Definition at line 1107 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_wait(), EBUSY, mutex_lock(), and mutex_unlock(). Referenced by ACE_RW_Thread_Mutex::tryacquire_write_upgrade(), and ACE_RW_Mutex::tryacquire_write_upgrade(). { ACE_OS_TRACE ("ACE_OS::rw_trywrlock_upgrade"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) // This will probably result in -1, EDEADLK, at least on HP-UX, but let it // go - it's a more descriptive error than ENOTSUP. int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_trywrlock (rw), result), int, -1); # elif !defined (ACE_LACKS_RWLOCK_T) // Some native rwlocks, such as those on Solaris, 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  )

Definition at line 1181 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_unlock (rw), result), int, -1); # else /* Solaris */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_unlock (rw), 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  )

Definition at line 1238 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_wrlock (rw), result), int, -1); # else /* Solaris */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_wrlock (rw), 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  )

Definition at line 1291 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_destroy (rw), result), int, -1); # else /* Solaris */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rwlock_destroy (rw), 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 */ }

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

Definition at line 1320 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_TCHAR, and rwlock_init(). Referenced by ACE_RW_Mutex::ACE_RW_Mutex(), and rwlock_init(). { // ACE_OS_TRACE ("ACE_OS::rwlock_init"); # if defined (ACE_HAS_PTHREADS_UNIX98_EXT) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); int status; pthread_rwlockattr_t attr; pthread_rwlockattr_init (&attr); # if !defined (ACE_LACKS_RWLOCKATTR_PSHARED) pthread_rwlockattr_setpshared (&attr, (type == USYNC_THREAD ? PTHREAD_PROCESS_PRIVATE : PTHREAD_PROCESS_SHARED)); # else ACE_UNUSED_ARG (type); # endif /* !ACE_LACKS_RWLOCKATTR_PSHARED */ status = ACE_ADAPT_RETVAL (pthread_rwlock_init (rw, &attr), status); pthread_rwlockattr_destroy (&attr); return status; # else type = type; name = name; int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rwlock_init (rw, type, arg), result), int, -1); # endif /* ACE_HAS_PTHREADS_UNIX98_EXT */ }

ACE_INLINE void * ACE_OS::sbrk (  ptrdiff_t  brk  )

Definition at line 767 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, and sbrk(). Referenced by ACE_Sbrk_Memory_Pool::acquire(), and sbrk(). { #if defined (ACE_LACKS_SBRK) ACE_UNUSED_ARG (brk); ACE_NOTSUP_RETURN (0); #else ACE_OSCALL_RETURN (::sbrk (brk), void *, 0); #endif /* ACE_LACKS_SBRK */ }

ACE_INLINE int scandir (  const ACE_TCHAR *  dirname, struct ACE_DIRENT **  namelist[], int(*  selector)(const struct ACE_DIRENT *), int(*  comparator)(const struct ACE_DIRENT **f1, const struct ACE_DIRENT **f2) )

Definition at line 136 of file OS_NS_dirent.inl. References ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, and scandir_emulation(). { #if defined (ACE_HAS_SCANDIR) return ::scandir (ACE_TEXT_ALWAYS_CHAR (dirname), namelist, selector, # if defined (ACE_SCANDIR_CMP_USES_VOIDPTR) reinterpret_cast<int(*)(const void*, const void*)> (comparator)); # else comparator); # endif /* ACE_SCANDIR_CMP_USES_VOIDPTR */ #else /* ! defined ( ACE_HAS_SCANDIR) */ return ACE_OS::scandir_emulation (dirname, namelist, selector, comparator); #endif /* ACE_HAS_SCANDIR */ }

ACE_NAMESPACE_INLINE_FUNCTION int scandir (  const ACE_TCHAR *  dirname, struct ACE_DIRENT **  namelist[], int(*  selector)(const struct ACE_DIRENT *filename), int(*  comparator)(const struct ACE_DIRENT **f1, const struct ACE_DIRENT **f2) )

Referenced by ACE_Dirent_Selector::open().

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::scandir_emulation (  const ACE_TCHAR *  dirname, ACE_DIRENT **  namelist[], int(*  selector)(const ACE_DIRENT *entry), int(*  comparator)(const ACE_DIRENT **f1, const ACE_DIRENT **f2) )

Definition at line 186 of file OS_NS_dirent.cpp. References ACE_DIR, ACE_DIRENT, ACE_SCANDIR_COMPARATOR, ACE_TCHAR, closedir(), free(), malloc(), memcpy(), opendir(), qsort(), readdir(), realloc(), strcpy(), and strlen(). Referenced by scandir(). { ACE_DIR *dirp = ACE_OS::opendir (dirname); if (dirp == 0) return -1; // A sanity check here. "namelist" had better not be zero. else if (namelist == 0) return -1; ACE_DIRENT **vector = 0; ACE_DIRENT *dp = 0; int arena_size = 0; int nfiles = 0; int fail = 0; // @@ This code shoulduse readdir_r() rather than readdir(). for (dp = ACE_OS::readdir (dirp); dp != 0; dp = ACE_OS::readdir (dirp)) { if (selector && (*selector)(dp) == 0) continue; // If we get here, we have a dirent that the user likes. if (nfiles == arena_size) { ACE_DIRENT **newv = 0; if (arena_size == 0) arena_size = 10; else arena_size *= 2; newv = (ACE_DIRENT **) ACE_OS::realloc (vector, arena_size * sizeof (ACE_DIRENT *)); if (newv == 0) { fail = 1; break; } vector = newv; } #if defined (ACE_LACKS_STRUCT_DIR) ACE_DIRENT *newdp = (ACE_DIRENT *) ACE_OS::malloc (sizeof (ACE_DIRENT)); #else size_t dsize = sizeof (ACE_DIRENT) + ((ACE_OS::strlen (dp->d_name) + 1) * sizeof (ACE_TCHAR)); ACE_DIRENT *newdp = (ACE_DIRENT *) ACE_OS::malloc (dsize); #endif /* ACE_LACKS_STRUCT_DIR */ if (newdp == 0) { fail = 1; break; } #if defined (ACE_LACKS_STRUCT_DIR) newdp->d_name = (ACE_TCHAR*) ACE_OS::malloc ( (ACE_OS::strlen (dp->d_name) + 1) * sizeof (ACE_TCHAR)); if (newdp->d_name == 0) { fail = 1; ACE_OS::free (newdp); break; } // Don't use memcpy here since d_name is now a pointer newdp->d_ino = dp->d_ino; newdp->d_off = dp->d_off; newdp->d_reclen = dp->d_reclen; ACE_OS::strcpy (newdp->d_name, dp->d_name); vector[nfiles++] = newdp; #else vector[nfiles++] = (ACE_DIRENT *) ACE_OS::memcpy (newdp, dp, dsize); #endif /* ACE_LACKS_STRUCT_DIR */ } if (fail) { ACE_OS::closedir (dirp); while (nfiles-- > 0) { #if defined (ACE_LACKS_STRUCT_DIR) ACE_OS::free (vector[nfiles]->d_name); #endif /* ACE_LACKS_STRUCT_DIR */ ACE_OS::free (vector[nfiles]); } ACE_OS::free (vector); return -1; } ACE_OS::closedir (dirp); *namelist = vector; if (comparator) ACE_OS::qsort (*namelist, nfiles, sizeof (ACE_DIRENT *), (ACE_SCANDIR_COMPARATOR) comparator); return nfiles; }

int ACE_OS::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. Definition at line 3536 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_id_t, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SCHED_FIFO, ACE_SCHED_RR, ACE_SCOPE_LWP, ACE_SCOPE_PROCESS, ACE_SCOPE_THREAD, ACE_SELF, ACE_thread_t, sched_params(), set_errno_to_last_error(), set_scheduling_params(), thr_self(), and thr_setprio(). Referenced by lwp_getparams(), lwp_setparams(), sched_params(), ACE_Process_Manager::set_scheduler(), ACE_Process_Manager::set_scheduler_all(), set_scheduling_params(), thr_create(), and thr_setprio(). { ACE_OS_TRACE ("ACE_OS::sched_params"); #if defined (ACE_HAS_STHREADS) return ACE_OS::set_scheduling_params (sched_params, id); #elif defined (ACE_HAS_PTHREADS) && \ (!defined (ACE_LACKS_SETSCHED) || defined (ACE_TANDEM_T1248_PTHREADS) || \ defined (ACE_HAS_PTHREAD_SCHEDPARAM)) 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) { # if defined(ACE_TANDEM_T1248_PTHREADS) || defined (ACE_HAS_PTHREAD_SCHEDPARAM) ACE_NOTSUP_RETURN (-1); # else /* ! ACE_TANDEM_T1248_PTHREADS */ int result = ::sched_setscheduler (id == ACE_SELF ? 0 : id, 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 */ # endif /* ! ACE_TANDEM_T1248_PTHREADS */ } 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 if (sched_params.quantum () != ACE_Time_Value::zero) { // I don't know of a way to set the quantum on Win32. errno = EINVAL; return -1; } if (sched_params.scope () == ACE_SCOPE_THREAD) { // Setting the REALTIME_PRIORITY_CLASS on Windows is almost always // a VERY BAD THING. This include guard will allow people // to easily disable this feature in ACE. #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 || sched_params.policy () == ACE_SCHED_RR) ? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS)) { ACE_OS::set_errno_to_last_error (); return -1; } #endif /* ACE_DISABLE_WIN32_INCREASE_PRIORITY */ # endif /* ACE_HAS_PHARLAP_RT */ // Now that we have set the priority class of the process, set the // priority of the current thread to the desired value. return ACE_OS::thr_setprio (sched_params.priority ()); } else if (sched_params.scope () == ACE_SCOPE_PROCESS) { HANDLE hProcess = ::OpenProcess (PROCESS_SET_INFORMATION, FALSE, id); if (!hProcess) { ACE_OS::set_errno_to_last_error(); return -1; } // There is no way for us to set the priority of the thread when we // are setting the priority of a different process. So just ignore // the priority argument when ACE_SCOPE_PROCESS is specified. // Setting the priority class will automatically increase the base // priority of all the threads within a process while maintaining the // relative priorities of the threads within it. if (!::SetPriorityClass (hProcess, (sched_params.policy () == ACE_SCHED_FIFO || sched_params.policy () == ACE_SCHED_RR) ? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS)) { ACE_OS::set_errno_to_last_error (); ::CloseHandle (hProcess); return -1; } ::CloseHandle (hProcess); return 0; } else { errno = EINVAL; return -1; } #elif defined (ACE_VXWORKS) 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 /* ACE_HAS_STHREADS */ }

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

Find the schedling class ID that corresponds to the class name. Definition at line 3712 of file OS_NS_Thread.cpp. References ACE_id_t, ACE_NOTSUP_RETURN, memset(), priority_control(), and 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 void ACE_OS::seekdir (  ACE_DIR *  , long  loc )

Definition at line 157 of file OS_NS_dirent.inl. References ACE_DIR. Referenced by ACE_Dirent::seek(). { #if defined (ACE_HAS_DIRENT) && !defined (ACE_LACKS_SEEKDIR) ::seekdir (d, loc); #else /* ! ACE_HAS_DIRENT || ACE_LACKS_SEEKDIR */ ACE_UNUSED_ARG (d); ACE_UNUSED_ARG (loc); #endif /* ! ACE_HAS_DIRENT || ACE_LACKS_SEEKDIR */ }

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

Definition at line 52 of file OS_NS_sys_select.inl. References ___ACE_TIMEOUT, ACE_FD_SET_TYPE, ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. { 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 */ #if defined(ACE_TANDEM_T1248_PTHREADS) ACE_SOCKCALL_RETURN (::spt_select (width, (ACE_FD_SET_TYPE *) rfds, (ACE_FD_SET_TYPE *) wfds, (ACE_FD_SET_TYPE *) efds, ___ACE_TIMEOUT), int, -1); #else ACE_SOCKCALL_RETURN (::select (width, (ACE_FD_SET_TYPE *) rfds, (ACE_FD_SET_TYPE *) wfds, (ACE_FD_SET_TYPE *) efds, ___ACE_TIMEOUT), int, -1); #endif #undef ___ACE_TIMEOUT }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL 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 )

Definition at line 14 of file OS_NS_sys_select.inl. References ACE_FD_SET_TYPE, ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. Referenced by ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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< STREAM >::recv(), ACE_SOCK_IO::recvv(), ACE::select(), sema_wait(), ACE_SOCK_Dgram::send(), ACE_TkReactor::TkWaitForMultipleEvents(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wait_for_multiple_events(), ACE_FlReactor::wait_for_multiple_events(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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 = 0; 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 */ #if defined(ACE_TANDEM_T1248_PTHREADS) ACE_SOCKCALL_RETURN (::spt_select (width, (ACE_FD_SET_TYPE *) rfds, (ACE_FD_SET_TYPE *) wfds, (ACE_FD_SET_TYPE *) efds, timep), int, -1); #else ACE_SOCKCALL_RETURN (::select (width, (ACE_FD_SET_TYPE *) rfds, (ACE_FD_SET_TYPE *) wfds, (ACE_FD_SET_TYPE *) efds, timep), int, -1); #endif }

ACE_INLINE int ACE_OS::sema_destroy (  ACE_sema_t *  s  )

Definition at line 1355 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, close(), cond_destroy(), event_destroy(), free(), mutex_destroy(), sema_destroy(), shm_unlink(), thread_mutex_destroy(), and unlink(). Referenced by event_destroy(), ACE_Semaphore::remove(), and sema_destroy(). { ACE_OS_TRACE ("ACE_OS::sema_destroy"); # if defined (ACE_HAS_POSIX_SEM) int result; # if !defined (ACE_HAS_POSIX_SEM_TIMEOUT) ACE_OS::mutex_destroy (&s->lock_); ACE_OS::cond_destroy (&s->count_nonzero_); # endif /* !ACE_HAS_POSIX_SEM_TIMEOUT */ # 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_USES_FIFO_SEM) int r0 = 0; if (s->name_) { r0 = ACE_OS::unlink (s->name_); ACE_OS::free (s->name_); s->name_ = 0; } int r1 = ACE_OS::close (s->fd_[0]); /* ignore error */ int r2 = ACE_OS::close (s->fd_[1]); /* ignore error */ return r0 != 0 || r1 != 0 || r2 != 0 ? -1 : 0; # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_destroy (s), 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_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 */ }

ACE_INLINE 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 )

Definition at line 1763 of file OS_NS_Thread.inl. References ACE_FAIL_RETURN, default_win32_security_attributes_r(), event_destroy(), event_init(), sema_init(), thread_mutex_destroy(), thread_mutex_init(), thread_mutex_lock(), and thread_mutex_unlock(). { # if 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>. SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; *s = ::CreateSemaphoreW (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), 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 */ # else /* ACE_HAS_WTHREADS */ // Just call the normal char version. return ACE_OS::sema_init (s, count, type, ACE_Wide_To_Ascii (name).char_rep (), arg, max, sa); # endif /* ACE_HAS_WTHREADS */ }

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 )

Definition at line 1436 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_ALLOCATOR_RETURN, ACE_DEFAULT_FILE_PERMS, ACE_FAIL_RETURN, ACE_NEW_RETURN, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_stat, ACE_TEXT_CHAR_TO_TCHAR, ACE_UNIQUE_NAME_LEN, close(), cond_destroy(), cond_init(), default_win32_security_attributes_r(), event_destroy(), event_init(), F_GETFL, fcntl(), ftruncate(), MAP_FAILED, MAP_SHARED, MAXPATHLEN, mkfifo(), mmap(), mode_t, mutex_destroy(), mutex_init(), mutex_lock(), mutex_unlock(), O_NONBLOCK, open(), PROT_RDWR, sema_init(), shm_open(), stat(), strcat(), strcpy(), strdup(), strrchr(), thread_mutex_destroy(), thread_mutex_init(), thread_mutex_lock(), thread_mutex_unlock(), uname(), unique_name(), unlink(), and write(). Referenced by ACE_Semaphore::ACE_Semaphore(), event_init(), and sema_init(). { ACE_OS_TRACE ("ACE_OS::sema_init"); #if defined (ACE_HAS_POSIX_SEM) ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); s->name_ = 0; # if defined (ACE_HAS_POSIX_SEM_TIMEOUT) ACE_UNUSED_ARG (arg); # else int result = -1; if (ACE_OS::mutex_init (&s->lock_, type, name, (ACE_mutexattr_t *) arg) == 0 && ACE_OS::cond_init (&s->count_nonzero_, (short)type, name, arg) == 0 && ACE_OS::mutex_lock (&s->lock_) == 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; } # endif /* ACE_HAS_POSIX_SEM_TIMEOUT */ # 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 (ACE_TEXT_CHAR_TO_TCHAR (name), O_RDWR | O_CREAT | O_EXCL, ACE_DEFAULT_FILE_PERMS); if (fd == ACE_INVALID_HANDLE) { if (errno == EEXIST) fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (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_USES_FIFO_SEM) ACE_UNUSED_ARG (arg); ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); int flags = 0; mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP; if (type == USYNC_THREAD) { // Create systemwide unique name for semaphore char uname[ACE_UNIQUE_NAME_LEN]; ACE_OS::unique_name ((const void *) s, uname, ACE_UNIQUE_NAME_LEN); name = &uname[0]; } s->name_ = 0; s->fd_[0] = s->fd_[1] = ACE_INVALID_HANDLE; bool creator = false; if (ACE_OS::mkfifo (ACE_TEXT_CHAR_TO_TCHAR (name), mode) < 0) { if (errno != EEXIST) /* already exists OK else ERR */ return -1; // check if this is a real FIFO, not just some other existing file ACE_stat fs; if (ACE_OS::stat (name, &fs)) return -1; if (!S_ISFIFO (fs.st_mode)) { // existing file is not a FIFO errno = EEXIST; return -1; } } else creator = true; // remember we created it for initialization at end // for processshared semaphores remember who we are to be able to remove // the FIFO when we're done with it if (type == USYNC_PROCESS) { s->name_ = ACE_OS::strdup (name); if (s->name_ == 0) { if (creator) ACE_OS::unlink (name); return -1; } } if ((s->fd_[0] = ACE_OS::open (name, O_RDONLY | O_NONBLOCK)) == ACE_INVALID_HANDLE || (s->fd_[1] = ACE_OS::open (name, O_WRONLY | O_NONBLOCK)) == ACE_INVALID_HANDLE) return (-1); /* turn off nonblocking for fd_[0] */ if ((flags = ACE_OS::fcntl (s->fd_[0], F_GETFL, 0)) < 0) return (-1); flags &= ~O_NONBLOCK; if (ACE_OS::fcntl (s->fd_[0], F_SETFL, flags) < 0) return (-1); //if (s->name_ && count) if (creator && count) { char c = 1; for (u_int i=0; i<count ;++i) if (ACE_OS::write (s->fd_[1], &c, sizeof (char)) != 1) return (-1); } // In the case of processscope semaphores we can already unlink the FIFO now that // we completely set it up (the opened handles will keep it active until we close // thos down). This way we're protected against unexpected crashes as far as removal // is concerned. // Unfortunately this does not work for processshared FIFOs since as soon as we // have unlinked the semaphore no other process will be able to open it anymore. if (type == USYNC_THREAD) { ACE_OS::unlink (name); } return (0); #elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (max); ACE_UNUSED_ARG (sa); int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_init (s, count, type, arg), 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>. SECURITY_ATTRIBUTES sa_buffer; SECURITY_DESCRIPTOR sd_buffer; *s = ::CreateSemaphoreA (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer), 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_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 )

Definition at line 1908 of file OS_NS_Thread.inl. 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  )

Definition at line 1832 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, cond_signal(), event_signal(), mutex_lock(), mutex_unlock(), sema_post(), thread_mutex_lock(), thread_mutex_unlock(), and write(). Referenced by event_init(), event_pulse(), event_reset(), event_signal(), event_timedwait(), event_wait(), ACE_Semaphore::release(), and sema_post(). { ACE_OS_TRACE ("ACE_OS::sema_post"); # if defined (ACE_HAS_POSIX_SEM) # if defined (ACE_HAS_POSIX_SEM_TIMEOUT) ACE_OSCALL_RETURN (::sem_post (s->sema_), int, -1); # else int result = -1; if (ACE_OS::mutex_lock (&s->lock_) == 0) { if (::sem_post (s->sema_) == 0) result = ACE_OS::cond_signal (&s->count_nonzero_); ACE_OS::mutex_unlock (&s->lock_); } return result; # endif /* ACE_HAS_POSIX_SEM_TIMEOUT */ # elif defined (ACE_USES_FIFO_SEM) char c = 1; if (ACE_OS::write (s->fd_[1], &c, sizeof (char)) == sizeof (char)) return (0); return (-1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_post (s), 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_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  )

Definition at line 1931 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, EBUSY, event_reset(), F_GETFL, fcntl(), mutex_lock(), mutex_unlock(), O_NONBLOCK, read(), sema_trywait(), set_errno_to_last_error(), thread_mutex_lock(), and thread_mutex_unlock(). Referenced by sema_trywait(), sema_wait(), 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_USES_FIFO_SEM) char c; int rc, flags; /* turn on nonblocking for s->fd_[0] */ if ((flags = ACE_OS::fcntl (s->fd_[0], F_GETFL, 0)) < 0) return (-1); flags |= O_NONBLOCK; if (ACE_OS::fcntl (s->fd_[0], F_SETFL, flags) < 0) return (-1); // read sets errno to EAGAIN if no input rc = ACE_OS::read (s->fd_[0], &c, sizeof (char)); /* turn off nonblocking for fd_[0] */ if ((flags = ACE_OS::fcntl (s->fd_[0], F_GETFL, 0)) >= 0) { flags &= ~O_NONBLOCK; ACE_OS::fcntl (s->fd_[0], F_SETFL, flags); } return rc == 1 ? 0 : (-1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) // STHREADS semaphores set errno to EBUSY if trywait fails. int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_trywait (s), 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_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 )

Definition at line 2436 of file OS_NS_Thread.inl. 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 )

Definition at line 2164 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_ONE_SECOND_IN_USECS, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_timedwait(), EBUSY, ETIME, ETIMEDOUT, event_reset(), gettimeofday(), ACE_Time_Value::msec(), mutex_lock(), mutex_unlock(), ACE_Time_Value::sec(), select(), sema_trywait(), ACE_Handle_Set::set_bit(), set_errno_to_last_error(), thread_mutex_lock(), thread_mutex_unlock(), timespec_t, and ACE_Time_Value::usec(). { ACE_OS_TRACE ("ACE_OS::sema_wait"); # if defined (ACE_HAS_POSIX_SEM) # if defined (ACE_HAS_POSIX_SEM_TIMEOUT) int rc; timespec_t ts; ts = tv; // Calls ACE_Time_Value::operator timespec_t(). ACE_OSCALL (::sem_timedwait (s->sema_, &ts), int, -1, rc); if (rc == -1 && errno == ETIMEDOUT) errno = ETIME; /* POSIX returns ETIMEDOUT but we need ETIME */ return rc; # else int result = 0; bool expired = false; ACE_Errno_Guard error (errno); ACE_PTHREAD_CLEANUP_PUSH (&s->lock_); if (ACE_OS::mutex_lock (&s->lock_) != 0) result = -2; else { bool finished = true; do { result = ACE_OS::sema_trywait (s); if (result == -1 && errno == EAGAIN) expired = ACE_OS::gettimeofday () > tv; else expired = false; finished = result != -1 || expired || (result == -1 && errno != EAGAIN); if (!finished) { if (ACE_OS::cond_timedwait (&s->count_nonzero_, &s->lock_, &tv) == -1) { error = errno; result = -1; break; } } } while (!finished); if (expired) error = ETIME; # if defined (ACE_LACKS_COND_TIMEDWAIT_RESET) tv = ACE_OS::gettimeofday (); # endif /* ACE_LACKS_COND_TIMEDWAIT_RESET */ } if (result != -2) ACE_OS::mutex_unlock (&s->lock_); ACE_PTHREAD_CLEANUP_POP (0); return result < 0 ? -1 : result; # endif /* !ACE_HAS_POSIX_SEM_TIMEOUT */ # elif defined (ACE_USES_FIFO_SEM) int rc; ACE_Time_Value now = ACE_OS::gettimeofday (); while (tv > now) { ACE_Time_Value timeout = tv; timeout -= now; ACE_Handle_Set fds_; fds_.set_bit (s->fd_[0]); if ((rc = ACE_OS::select (ACE_Handle_Set::MAXSIZE, fds_, 0, 0, timeout)) != 1) { if (rc == 0 || errno != EAGAIN) { if (rc == 0) errno = ETIME; return (-1); } } // try to read the signal *but* do *not* block if (rc == 1 && ACE_OS::sema_trywait (s) == 0) return (0); // we were woken for input but someone beat us to it // so we wait again if there is still time now = ACE_OS::gettimeofday (); } // make sure errno is set right errno = ETIME; 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_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  )

Definition at line 2055 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_PTHREAD_CLEANUP_POP, ACE_PTHREAD_CLEANUP_PUSH, cond_wait(), event_reset(), mutex_lock(), mutex_unlock(), read(), sema_wait(), set_errno_to_last_error(), thread_mutex_lock(), and thread_mutex_unlock(). Referenced by ACE_Semaphore::acquire(), event_pulse(), event_reset(), event_signal(), event_timedwait(), event_wait(), 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_USES_FIFO_SEM) char c; if (ACE_OS::read (s->fd_[0], &c, sizeof (char)) == 1) return (0); return (-1); # elif defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_wait (s), 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_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 */ }

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

Definition at line 2442 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 2458 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 2473 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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 ssize_t ACE_OS::send (  ACE_HANDLE  handle, const char *  buf, size_t  len, int  flags = 0 )

BSD-style (no QoS). Definition at line 472 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, EWOULDBLOCK, and ssize_t. Referenced by ACE_Pipe::send(), ACE::send(), ACE::send_i(), ACE::send_n_i(), and sendfile_emulation(). { 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, static_cast<int> (len), flags), ssize_t, -1); #else ssize_t const ace_result_ = ::send ((ACE_SOCKET) handle, buf, len, flags); # if !(defined (EAGAIN) && defined (EWOULDBLOCK) && EAGAIN == EWOULDBLOCK) // Optimize this code out if we can detect that EAGAIN == // EWOULDBLOCK at compile time. If we cannot detect equality at // compile-time (e.g. if EAGAIN or EWOULDBLOCK are not preprocessor // macros) perform the check at run-time. The goal is to avoid two // TSS accesses in the _REENTRANT case when EAGAIN == EWOULDBLOCK. if (ace_result_ == -1 # if !defined (EAGAIN) || !defined (EWOULDBLOCK) && EAGAIN != EWOULDBLOCK # endif /* !EAGAIN || !EWOULDBLOCK */ && errno == EAGAIN) { errno = EWOULDBLOCK; } # endif /* EAGAIN != EWOULDBLOCK*/ return ace_result_; #endif /* defined (ACE_WIN32) */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ssize_t ACE_OS::sendfile (  ACE_HANDLE  out_fd, ACE_HANDLE  in_fd, off_t *  offset, size_t  count )

Finds the length of a string (char version). Definition at line 12 of file OS_NS_sys_sendfile.inl. References sendfile_emulation(). { #ifdef ACE_HAS_SENDFILE return ::sendfile (out_fd, in_fd, offset, count); #else return ACE_OS::sendfile_emulation (out_fd, in_fd, offset, count); #endif /* ACE_HAS_SENDFILE */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ssize_t ACE_OS::sendfile_emulation (  ACE_HANDLE  out_fd, ACE_HANDLE  in_fd, off_t *  offset, size_t  count )

Definition at line 20 of file OS_NS_sys_sendfile.cpp. References MAP_FAILED, MAP_SHARED, mmap(), munmap(), PROT_READ, send(), ssize_t, and write(). Referenced by sendfile(). { // @@ Is it possible to inline a call to ::TransmitFile() on // MS Windows instead of emulating here? // @@ We may want set up a signal lease (or oplock) if supported by // the platform so that we don't get a bus error if the mmap()ed // file is truncated. void * const buf = ACE_OS::mmap (0, count, PROT_READ, MAP_SHARED, in_fd, *offset); if (buf == MAP_FAILED) return -1; #if defined (ACE_WIN32) || defined (HPUX) ssize_t const r = ACE_OS::send (out_fd, static_cast<const char *> (buf), count); #else ssize_t const r = ACE_OS::write (out_fd, buf, count); #endif /* ACE_WIN32 */ (void) ACE_OS::munmap (buf, count); if (r > 0) *offset += static_cast<off_t> (r); return r; }

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

BSD-style (no QoS). Definition at line 514 of file OS_NS_sys_socket.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SOCKCALL_RETURN, msghdr::msg_iov, msghdr::msg_iovlen, msghdr::msg_name, msghdr::msg_namelen, set_errno_to_wsa_last_error(), and ssize_t. Referenced by 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_wsa_last_error (); return -1; } else return (ssize_t) bytes_sent; # elif defined (ACE_HAS_NONCONST_SENDMSG) ACE_SOCKCALL_RETURN (::sendmsg (handle, const_cast<struct msghdr *>(msg), flags), ssize_t, -1); # else ACE_SOCKCALL_RETURN (::sendmsg (handle, msg, flags), ssize_t, -1); # endif #else ACE_UNUSED_ARG (flags); ACE_UNUSED_ARG (msg); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_LACKS_SENDMSG */ }

ACE_INLINE ssize_t 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 )

BSD-style (no QoS). Definition at line 594 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_OVERLAPPED, ACE_OVERLAPPED_COMPLETION_FUNC, sendto(), set_errno_to_wsa_last_error(), and ssize_t. { 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_wsa_last_error (); } number_of_bytes_sent = static_cast<size_t> (bytes_sent); return (ssize_t) result; #else ACE_UNUSED_ARG (overlapped); ACE_UNUSED_ARG (func); number_of_bytes_sent = 0; ssize_t result = 0; for (int i = 0; i < buffer_count; ++i) { result = ACE_OS::sendto (handle, reinterpret_cast<char *> ( buffers[i].iov_base), buffers[i].iov_len, flags, addr, addrlen); if (result == -1) break; number_of_bytes_sent += static_cast<size_t> (result); } return result; #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */ }

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

BSD-style (no QoS). Definition at line 556 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL_RETURN, and ssize_t. Referenced by ACE_WIN32_Asynch_Write_Dgram::send(), ACE_SOCK_Dgram_Bcast::send(), ACE_SOCK_Dgram::send(), ACE_ICMP_Socket::send(), sendto(), and ACE::sendto(). { ACE_OS_TRACE ("ACE_OS::sendto"); #if defined (ACE_VXWORKS) ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, const_cast <char *> (buf), len, flags, const_cast<struct sockaddr *> (addr), addrlen), ssize_t, -1); #else # if defined (ACE_WIN32) ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, buf, static_cast<int> (len), flags, const_cast<struct sockaddr *> (addr), addrlen), ssize_t, -1); # else ACE_SOCKCALL_RETURN (::sendto ((ACE_SOCKET) handle, buf, len, flags, const_cast<struct sockaddr *> (addr), addrlen), ssize_t, -1); # endif /* ACE_WIN32 */ #endif /* ACE_VXWORKS */ }

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

BSD-style (no QoS). Definition at line 648 of file OS_NS_sys_socket.inl. References ACE_IOV_MAX, iovec::iov_base, iovec::iov_len, set_errno_to_wsa_last_error(), ssize_t, and writev(). Referenced by ACE_Pipe::recvv_n(), ACE_SOCK_IO::send(), ACE_Pipe::send(), ACE::send(), ACE_Pipe::sendv(), ACE::sendv(), and ACE::sendv_n_i(). { #if defined (ACE_HAS_WINSOCK2) DWORD bytes_sent = 0; ssize_t 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); if (result == SOCKET_ERROR) { ACE_OS::set_errno_to_wsa_last_error (); return -1; } # else for (int i = 0; i < n; ++i) { result = ::send ((SOCKET) handle, buffers[i].iov_base, buffers[i].iov_len, 0); if (result == SOCKET_ERROR) { // There is a subtle difference in behaviour depending on // whether or not any data was sent. If no data was sent, // then always return -1. Otherwise return bytes_sent. // This gives the caller an opportunity to keep track of // bytes that have already been sent. if (bytes_sent > 0) break; else { ACE_OS::set_errno_to_wsa_last_error (); return -1; } } else { // Gets ignored on error anyway bytes_sent += result; // If the transfer isn't complete just drop out of the loop. if (result < (int)buffers[i].iov_len) break; } } # endif /* ACE_HAS_WINSOCK2 != 0 */ return (ssize_t) bytes_sent; #elif defined (ACE_HAS_SOCK_BUF_SIZE_MAX) // Platform limits the maximum socket message size. Pare down the // iovec, if necessary, to obey the limit. iovec local_iov[ACE_IOV_MAX]; long total = 0; long new_total = 0; for (int i = 0; i < n; i++) { local_iov[i].iov_base = buffers[i].iov_base; local_iov[i].iov_len = buffers[i].iov_len; new_total = total + buffers[i].iov_len; if ( new_total >= SSIZE_MAX ) { local_iov[i].iov_len = SSIZE_MAX - total; n = i+1; break; } total = new_total; } return ACE_OS::writev (handle, local_iov, n); #else return ACE_OS::writev (handle, buffers, n); #endif /* ACE_HAS_WINSOCK2 */ }

ACE_INLINE int ACE_OS::set_errno_to_last_error (  void   )

Definition at line 39 of file OS_NS_errno.inl. 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(), fstat(), 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(), ACE_WIN32_Proactor::register_handle(), sched_params(), sema_trywait(), sema_wait(), ACE_WIN32_Asynch_Write_Dgram::send(), 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   )

Definition at line 58 of file OS_NS_errno.inl. References last_error(). Referenced by ACE_INET_Addr::get_host_addr(), recvfrom(), recvmsg(), recvv(), ACE_SPIPE_Stream::send_handle(), sendmsg(), sendto(), 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  )

For use by ACE_Object_Manager only, to register its exit hook.. Definition at line 390 of file OS_NS_stdlib.inl. References ACE_EXIT_HOOK, and 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 )

Friendly interface to (2). Definition at line 3742 of file OS_NS_Thread.cpp. References ACE_id_t, ACE_NOTSUP_RETURN, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_SCHED_RR, ACE_SCOPE_PROCESS, ACE_SCOPE_THREAD, last_error(), memcpy(), memset(), priority_control(), sched_params(), and scheduling_class(). 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 */ }

ACE_NAMESPACE_INLINE_FUNCTION 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. Referenced by DllMain().

ACE_INLINE int ACE_OS::setegid (  gid_t   )

Definition at line 790 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, gid_t, and setegid(). Referenced by setegid(). { ACE_OS_TRACE ("ACE_OS::setegid"); #if defined (ACE_LACKS_SETEGID) ACE_UNUSED_ARG (gid); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::setegid (gid), int, -1); # endif /* ACE_LACKS_SETEGID */ }

ACE_INLINE int ACE_OS::seteuid (  uid_t   )

Definition at line 864 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, seteuid(), and uid_t. Referenced by seteuid(). { ACE_OS_TRACE ("ACE_OS::seteuid"); #if defined (ACE_LACKS_SETEUID) ACE_UNUSED_ARG (uid); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::seteuid (uid), int, -1); # endif /* ACE_LACKS_SETEUID */ }

ACE_INLINE int ACE_OS::setgid (  gid_t   )

Definition at line 778 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, gid_t, and setgid(). Referenced by setgid(). { ACE_OS_TRACE ("ACE_OS::setgid"); #if defined (ACE_LACKS_SETGID) ACE_UNUSED_ARG (gid); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::setgid (gid), int, -1); # endif /* ACE_LACKS_SETGID */ }

ACE_INLINE int ACE_OS::setpgid (  pid_t  pid, pid_t  pgid )

Definition at line 802 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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); #else ACE_OSCALL_RETURN (::setpgid (pid, pgid), int, -1); #endif /* ACE_LACKS_SETPGID */ }

ACE_INLINE void ACE_OS::setpwent (  void   )

Definition at line 114 of file OS_NS_pwd.inl. { #if !defined (ACE_LACKS_PWD_FUNCTIONS) ::setpwent (); #endif /* ! ACE_LACKS_PWD_FUNCTIONS */ }

ACE_INLINE int ACE_OS::setregid (  gid_t  rgid, gid_t  egid )

Definition at line 815 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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); #else ACE_OSCALL_RETURN (::setregid (rgid, egid), int, -1); #endif /* ACE_LACKS_SETREGID */ }

ACE_INLINE int ACE_OS::setreuid (  uid_t  ruid, uid_t  euid )

Definition at line 828 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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); #else ACE_OSCALL_RETURN (::setreuid (ruid, euid), int, -1); #endif /* ACE_LACKS_SETREUID */ }

ACE_INLINE int ACE_OS::setrlimit (  int  resource, const struct rlimit *  rl )

Definition at line 65 of file OS_NS_sys_resource.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, 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) # if defined (ACE_HAS_NONCONST_SETRLIMIT) ACE_OSCALL_RETURN (::setrlimit ((ACE_HAS_RLIMIT_RESOURCE_ENUM) resource, const_cast<struct rlimit *>(rl) ), int, -1); # else ACE_OSCALL_RETURN (::setrlimit ((ACE_HAS_RLIMIT_RESOURCE_ENUM) resource, rl ), int, -1); # endif /* ACE_HAS_NONCONST_SETRLIMIT */ # else /* ACE_HAS_RLIMIT_RESOURCE_ENUM */ # if defined (ACE_HAS_NONCONST_SETRLIMIT) ACE_OSCALL_RETURN (::setrlimit (resource, const_cast<struct rlimit *>(rl) ), int, -1); # else ACE_OSCALL_RETURN (::setrlimit (resource, rl), int, -1); # endif /* ACE_HAS_NONCONST_SETRLIMIT */ # endif /* ACE_HAS_RLIMIT_RESOURCE_ENUM */ #endif /* ACE_LACKS_RLIMIT */ }

ACE_INLINE pid_t ACE_OS::setsid (  void   )

Definition at line 841 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and setsid(). Referenced by ACE::daemonize(), and setsid(). { ACE_OS_TRACE ("ACE_OS::setsid"); #if defined (ACE_LACKS_SETSID) ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::setsid (), int, -1); # endif /* ACE_LACKS_SETSID */ }

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

Manipulate the options associated with a socket. Definition at line 737 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, ACE_SOCKCALL, ACE_SOCKOPT_TYPE1, ENOTSUP, and setsockopt(). Referenced by ACE_SOCK_SEQPACK_Association::abort(), ACE_ATM_Acceptor::accept(), ACE_ATM_Connector::connect(), ACE_WIN32_Asynch_Connect::connect_i(), ACE_POSIX_Asynch_Connect::connect_i(), ACE_Asynch_Acceptor< HANDLER >::handle_accept(), ACE_SOCK_Dgram_Bcast::mk_broadcast(), ACE_Pipe::open(), ACE_ATM_Acceptor::open(), ACE_Asynch_Acceptor< HANDLER >::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 Windows 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*/ int result; ACE_SOCKCALL (::setsockopt ((ACE_SOCKET) handle, level, optname, (ACE_SOCKOPT_TYPE1) optval, optlen), int, -1, result); #if defined (WSAEOPNOTSUPP) if (result == -1 && errno == WSAEOPNOTSUPP) #else if (result == -1) #endif /* WSAEOPNOTSUPP */ errno = ENOTSUP; return result; }

ACE_INLINE int ACE_OS::setuid (  uid_t   )

Definition at line 852 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, setuid(), and uid_t. Referenced by setuid(). { ACE_OS_TRACE ("ACE_OS::setuid"); #if defined (ACE_LACKS_SETUID) ACE_UNUSED_ARG (uid); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::setuid (uid), int, -1); # endif /* ACE_LACKS_SETUID */ }

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

Definition at line 303 of file OS_NS_sys_mman.inl. References ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, open(), and shm_open(). Referenced by ACE_Mutex::ACE_Mutex(), event_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 (ACE_TEXT_ALWAYS_CHAR(filename), mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE); # elif defined (ACE_OPENVMS) ACE_OSCALL_RETURN (::open (filename, mode, perms, ACE_TEXT("shr=get,put,upd")), ACE_HANDLE, ACE_INVALID_HANDLE); # 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  )

Definition at line 321 of file OS_NS_sys_mman.inl. References ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, shm_unlink(), and unlink(). Referenced by event_destroy(), event_init(), 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 (ACE_TEXT_ALWAYS_CHAR(path)), int, -1); # else /* ! ACE_HAS_SHM_OPEN */ // Just use ::unlink. return ACE_OS::unlink (path); # endif /* ACE_HAS_SHM_OPEN */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void * ACE_OS::shmat (  int  int_id, const void *  shmaddr, int  shmflg )

Definition at line 10 of file OS_NS_sys_shm.inl. References ACE_NOTSUP_RETURN, 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_HAS_CHARPTR_SHMAT) ACE_OSCALL_RETURN (::shmat (int_id, static_cast <char*> (const_cast <void *>(shmaddr)), shmflg), void *, (void *) -1); # else ACE_OSCALL_RETURN (::shmat (int_id, shmaddr, shmflg), void *, (void *) -1); # endif /* ACE_HAS_CHARPTR_SHMAT */ #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 )

Definition at line 29 of file OS_NS_sys_shm.inl. References ACE_NOTSUP_RETURN, 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 (  const void *  shmaddr  )

Definition at line 44 of file OS_NS_sys_shm.inl. References ACE_NOTSUP_RETURN, 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) # if defined (ACE_HAS_CHARPTR_SHMDT) ACE_OSCALL_RETURN (::shmdt ( static_cast <char*> (const_cast <void *>(shmaddr))), int, -1); # else ACE_OSCALL_RETURN (::shmdt (shmaddr), int, -1); # endif /* ACE_HAS_CHARPTR_SHMDT */ #else ACE_UNUSED_ARG (shmaddr); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SYSV_IPC */ }

ACE_INLINE int ACE_OS::shmget (  key_t  key, size_t  size, int  flags )

Definition at line 62 of file OS_NS_sys_shm.inl. References ACE_NOTSUP_RETURN, 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 )

BSD-style (no QoS). Definition at line 785 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. Referenced by ACE_SOCK_Stream::close_reader(), ACE_SOCK_SEQPACK_Association::close_reader(), ACE_MEM_Stream::close_reader(), ACE_SOCK_Stream::close_writer(), ACE_SOCK_SEQPACK_Association::close_writer(), ACE_MEM_Stream::close_writer(), and closesocket(). { 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 ACE_SIGACTION *  nsa, ACE_SIGACTION *  osa )

Definition at line 44 of file OS_NS_signal.inl. References ACE_NOTSUP_RETURN, 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 (ACE_LACKS_SIGACTION) ACE_UNUSED_ARG (nsa); ACE_UNUSED_ARG (osa); ACE_NOTSUP_RETURN (-1); #elif !defined (ACE_HAS_SIGACTION_CONSTP2) ACE_OSCALL_RETURN (::sigaction (signum, const_cast<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 )

Definition at line 78 of file OS_NS_signal.inl. 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 } *s |= (1 << (signum - 1)) ; 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 )

Definition at line 100 of file OS_NS_signal.inl. 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 } *s &= ~(1 << (signum - 1)) ; 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  )

Definition at line 121 of file OS_NS_signal.inl. 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; } *s = 0 ; 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  )

Definition at line 137 of file OS_NS_signal.inl. 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; } *s = ~(sigset_t) 0; 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 )

Definition at line 153 of file OS_NS_signal.inl. 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 } return ((*s & (1 << (signum - 1))) != 0) ; #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  )

Definition at line 180 of file OS_NS_signal.inl. References ACE_NOTSUP_RETURN, and ACE_SignalHandler. Referenced by ACE::daemonize(). { if (signum == 0) return 0; else # if 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 /* defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) || !defined (ACE_LACKS_UNIX_SIGNALS) */ }

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

Definition at line 200 of file OS_NS_signal.inl. References ACE_NOTSUP_RETURN, and 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 ACE_OSCALL_RETURN (::sigprocmask (how, nsp, osp), int, -1); #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */ }

ACE_INLINE int ACE_OS::sigsuspend (  const sigset_t *  set  )

Definition at line 213 of file OS_NS_signal.inl. References ACE_NOTSUP_RETURN, 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 )

Definition at line 2488 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, sigtimedwait(), and timespec_t. 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 */ }

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

Definition at line 2516 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and 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)) ACE_UNUSED_ARG (sset); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_HAS_STHREADS) # if (_POSIX_C_SOURCE - 0 >= 199506L) || defined (_POSIX_PTHREAD_SEMANTICS) errno = ::sigwait (sset, sig); return errno == 0 ? *sig : -1; #else *sig = ::sigwait (sset); return *sig; #endif /* _POSIX_C_SOURCE - 0 >= 199506L || _POSIX_PTHREAD_SEMANTICS */ # 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 (_UNICOS) && _UNICOS == 9) *sig = ::sigwait (sset); return *sig; # elif defined (CYGWIN32) // Cygwin has sigwait definition, but it is not implemented ACE_UNUSED_ARG (sset); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_TANDEM_T1248_PTHREADS) errno = ::spt_sigwait (sset, sig); return errno == 0 ? *sig : -1; # 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 (ACE_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 )

Definition at line 2582 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, 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  )

Definition at line 894 of file OS_NS_unistd.inl. References ACE_OS_TRACE, ACE_Time_Value::msec(), nanosleep(), and timespec_t. { ACE_OS_TRACE ("ACE_OS::sleep"); #if defined (ACE_WIN32) ::Sleep (tv.msec ()); return 0; #elif defined (ACE_HAS_CLOCK_GETTIME) timespec_t rqtp = tv; ACE_OSCALL_RETURN (::nanosleep (&rqtp, 0), int, -1); #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; # if defined(ACE_TANDEM_T1248_PTHREADS) ACE_OSCALL_RETURN (::spt_select (0, 0, 0, 0, &tv_copy), int, -1); # else ACE_OSCALL_RETURN (::select (0, 0, 0, 0, &tv_copy), int, -1); # endif # 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  )

Definition at line 876 of file OS_NS_unistd.inl. References ACE_ONE_SECOND_IN_MSECS, ACE_OS_TRACE, nanosleep(), sleep(), timespec::tv_nsec, and timespec::tv_sec. Referenced by ACE_High_Res_Timer::calibrate(), ACE_SOCK_SEQPACK_Connector::complete(), ACE_SOCK_Connector::complete(), ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::initialize_svc_handler(), 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; #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); #else ACE_OSCALL_RETURN (::sleep (seconds), int, -1); #endif /* ACE_WIN32 */ }

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

Definition at line 308 of file OS_NS_stdio.cpp. References ACE_NOTSUP_RETURN, and ACE_SPRINTF_ADAPTER. { // ACE_OS_TRACE ("ACE_OS::snprintf"); #if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 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 regard a full buffer with no 0-terminate as an // overrun. if (result == static_cast <int> (maxlen)) result = -1; // 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 = 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, ...  )

Definition at line 265 of file OS_NS_stdio.cpp. References ACE_NOTSUP_RETURN, ACE_SPRINTF_ADAPTER, and vsnprintf(). Referenced by ACE_Log_Msg::log(), and ACE_Function_Node::make_func_name(). { // ACE_OS_TRACE ("ACE_OS::snprintf"); #if defined (ACE_HAS_SNPRINTF) int result; va_list ap; va_start (ap, format); # if !defined (ACE_WIN32) || (defined (__BORLANDC__) && (__BORLANDC__ >= 0x600)) ACE_OSCALL (ACE_SPRINTF_ADAPTER (::vsnprintf (buf, maxlen, format, ap)), int, -1, result); # else ACE_OSCALL (ACE_SPRINTF_ADAPTER (::_vsnprintf (buf, maxlen, format, ap)), int, -1, result); // Win32 doesn't regard a full buffer with no 0-terminate as an // overrun. if (result == static_cast <int> (maxlen)) result = -1; // Win32 doesn't 0-terminate the string if it overruns maxlen. if (result == -1) buf[maxlen-1] = '\0'; # endif /* !ACE_WIN32 || __BORLANDC__ >= 0x600 */ 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 = 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 )

Create a QoS-enabled socket. If the OS platform doesn't support QoS-enabled then the BSD-style is called. Definition at line 805 of file OS_NS_sys_socket.inl. 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 )

Create a BSD-style socket (no QoS). Definition at line 792 of file OS_NS_sys_socket.inl. References ACE_OS_TRACE, and ACE_SOCKCALL_RETURN. Referenced by ACE_WIN32_Asynch_Accept::accept(), ACE_WIN32_Asynch_Connect::connect_i(), ACE_POSIX_Asynch_Connect::connect_i(), ACE::get_bcast_addr(), ACE::get_handle(), getmacaddress(), ACE::ipv6_enabled(), ACE_ATM_Acceptor::open(), ACE_Asynch_Acceptor< HANDLER >::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   )

Finalize WinSock after last use (e.g., when a DLL is unloaded). Definition at line 135 of file OS_NS_sys_socket.cpp. References ACE_LIB_TEXT, ACE_TCHAR, fprintf(), 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) ACE_TCHAR fmt[] = ACE_LIB_TEXT ("%s failed, WSAGetLastError returned %d"); ACE_TCHAR 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 )

Initialize WinSock before first use (e.g., when a DLL is first loaded or the first use of a socket() call. Definition at line 101 of file OS_NS_sys_socket.cpp. References ACE_LIB_TEXT, ACE_TCHAR, fprintf(), and sprintf(). Referenced by ACE_OS_Object_Manager::init(). { # if defined (ACE_WIN32) && !defined(ACE_DONT_INIT_WINSOCK) 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) { ACE_TCHAR fmt[] = ACE_LIB_TEXT ("%s failed, WSAGetLastError returned %d"); ACE_TCHAR 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] )

BSD-style (no QoS). Definition at line 835 of file OS_NS_sys_socket.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and socketpair(). Referenced by ACE_Pipe::open(), and socketpair(). { ACE_OS_TRACE ("ACE_OS::socketpair"); #if 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_LACKS_SOCKETPAIR */ }

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

Definition at line 367 of file OS_NS_stdio.cpp. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::sprintf"); # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || (defined ACE_HAS_DINKUM_STL) || defined (__DMC__) // The XPG4/UNIX98/C99 signature of the wide-char sprintf has a // maxlen argument. Since this method doesn't supply one, pass in // a length that works (ULONG_MAX doesn't on all platform since some check // to see if the operation will remain in bounds). If this isn't ok, use // ACE_OS::snprintf(). int result; va_list ap; va_start (ap, format); ACE_OSCALL (ACE_STD_NAMESPACE::vswprintf (buf, 4096, 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 /* XPG5 || ACE_HAS_DINKUM_STL */ }

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

Definition at line 353 of file OS_NS_stdio.cpp. References ACE_SPRINTF_ADAPTER, and vsprintf(). Referenced by ACE_MEM_Acceptor::accept(), 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_Utils::UUID_Generator::generateUUID(), ACE_INET_Addr::get_host_addr(), ACE::get_ip_interfaces(), getmacaddress(), ACE_Logging_Strategy::handle_timeout(), inet_ntop(), ACE_Stream_Type::info(), ACE_Module_Type::info(), ACE_Service_Manager::info(), ACE_Naming_Context::info(), ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::info(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::info(), ACE_Strategy_Acceptor< SVC_HANDLER, >::info(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::info(), ACE::ldfind(), ACE_Log_Msg::log(), ACE_Log_Msg::log_hexdump(), mmap(), ACE_Token_Proxy::open(), 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(), strerror(), ACE::timestamp(), ACE_Utils::UUID::to_string(), 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  )

Definition at line 398 of file OS_NS_stdlib.inl. References ACE_OS_TRACE. { ACE_OS_TRACE ("ACE_OS::srand"); ::srand (seed); }

ACE_INLINE int ACE_OS::stat (  const wchar_t *  file, ACE_stat *  )

Definition at line 253 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, ACE_Time_Value, set_errno_to_last_error(), and stat(). { ACE_OS_TRACE ("ACE_OS::stat"); #if defined (ACE_HAS_WINCE) WIN32_FIND_DATAW fdata; HANDLE fhandle; fhandle = ::FindFirstFileW (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_mode = static_cast<unsigned short>(fdata.dwFileAttributes); 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 (__BORLANDC__) ACE_OSCALL_RETURN (::_wstati64 (file, stp), int, -1); #elif defined (ACE_WIN32) && defined _MSC_VER && _MSC_VER >= 1300 && _MSC_VER < 1400 // vc71 ACE_OSCALL_RETURN (::_wstati64 (file, stp), int, -1); #elif defined (__MINGW32__) ACE_OSCALL_RETURN (::_wstat (file, stp), int, -1); #elif defined (ACE_WIN32) ACE_OSCALL_RETURN (::_wstat64 (file, stp), int, -1); #else /* ACE_HAS_WINCE */ ACE_Wide_To_Ascii nfile (file); return ACE_OS::stat (nfile.char_rep (), stp); #endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::stat (  const char *  file, ACE_stat *  )

Definition at line 203 of file OS_NS_sys_stat.inl. References ACE_OS_TRACE, ACE_TEXT_CHAR_TO_TCHAR, ACE_Time_Value, set_errno_to_last_error(), and stat(). Referenced by ACE_Filecache_Object::ACE_Filecache_Object(), lstat(), ACE_Service_Gestalt::process_file(), ACE_Filecache_Object::release(), sema_init(), stat(), and ACE_Filecache_Object::update(). { ACE_OS_TRACE ("ACE_OS::stat"); #if defined (ACE_HAS_NONCONST_STAT) ACE_OSCALL_RETURN (::stat (const_cast <char *> (file), stp), int, -1); #elif defined (ACE_HAS_WINCE) ACE_TEXT_WIN32_FIND_DATA fdata; HANDLE fhandle; fhandle = ::FindFirstFile (ACE_TEXT_CHAR_TO_TCHAR (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_mode = static_cast<unsigned short>(fdata.dwFileAttributes); 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 (ACE_WIN32) # if defined(__IBMCPP__) || defined (__MINGW32__) ACE_OSCALL_RETURN (::_stat (file, stp), int, -1); # elif defined (__BORLANDC__) ACE_OSCALL_RETURN (::_stati64 (file, stp), int, -1); # elif defined _MSC_VER && _MSC_VER >= 1300 && _MSC_VER < 1400 // vc71 ACE_OSCALL_RETURN (::_stati64 (file, stp), int, -1); # else ACE_OSCALL_RETURN (::_stat64 (file, stp), int, -1); # endif /* __IBMCPP__ */ #else /* ACE_HAS_NONCONST_STAT */ ACE_OSCALL_RETURN (::stat (file, stp), int, -1); #endif /* ACE_HAS_NONCONST_STAT */ }

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

Definition at line 26 of file OS_NS_regex.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and step(). Referenced by ACE_Local_Name_Space<, ACE_LOCK >::list_type_entries_i(), ACE_Local_Name_Space<, ACE_LOCK >::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_NAMESPACE_INLINE_FUNCTION int strcasecmp (  const wchar_t *  s, const wchar_t *  t )

Compares two strings (case insensitive const wchar_t version).

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::strcasecmp (  const char *  s, const char *  t )

Compares two strings (case insensitive const char version). Definition at line 12 of file OS_NS_strings.inl. References strcasecmp_emulation(). Referenced by ACE_POSIX_Proactor::ACE_POSIX_Proactor(), ACE_TTY_IO::control(), ACE::execname(), ACE::ldfind(), and ACE_Name_Options::parse_args(). { #if defined (ACE_LACKS_STRCASECMP) return ACE_OS::strcasecmp_emulation (s, t); #elif defined (ACE_STRCASECMP_EQUIVALENT) return ACE_STRCASECMP_EQUIVALENT (s, t); #else /* ACE_LACKS_STRCASECMP */ return ::strcasecmp (s, t); #endif /* ACE_LACKS_STRCASECMP */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::strcasecmp_emulation (  const char *  s, const char *  t )

Emulated strcasecmp - Performs a case insensitive comparison of strings. Definition at line 19 of file OS_NS_strings.cpp. References ace_tolower(). Referenced by strcasecmp(). { const char *scan1 = s; const char *scan2 = t; while (*scan1 != 0 && ACE_OS::ace_tolower (*scan1) == ACE_OS::ace_tolower (*scan2)) { ++scan1; ++scan2; } // The following case analysis is necessary so that characters which // look negative collate low against normal characters but high // against the end-of-string NUL. if (*scan1 == '\0' && *scan2 == '\0') return 0; else if (*scan1 == '\0') return -1; else if (*scan2 == '\0') return 1; else return ACE_OS::ace_tolower (*scan1) - ACE_OS::ace_tolower (*scan2); }

ACE_INLINE wchar_t * ACE_OS::strcat (  wchar_t *  s, const wchar_t *  t )

Appends a string to another string (wchar_t version). Definition at line 66 of file OS_NS_string.inl. References wcscat_emulation(). { # if defined (ACE_LACKS_WCSCAT) return ACE_OS::wcscat_emulation (s, t); # else /* ACE_LACKS_WCSCAT */ return ::wcscat (s, t); # endif /* ACE_LACKS_WCSCAT */ }

ACE_INLINE char * ACE_OS::strcat (  char *  s, const char *  t )

Appends a string to another string (char version). Definition at line 59 of file OS_NS_string.inl. Referenced by ACE_MEM_Acceptor::accept(), ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T(), ACE_Logging_Strategy::ACE_Logging_Strategy(), ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool(), ACE_Name_Options::ACE_Name_Options(), ACE_Pagefile_Memory_Pool::ACE_Pagefile_Memory_Pool(), ACE_System_Time::ACE_System_Time(), ACE_Process_Options::command_line(), ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), event_init(), ACE_INET_Addr::get_host_addr(), ACE::get_ip_interfaces(), ACE_MT_MEM_IO::init(), ACE_NT_Service::insert(), ACE::ldfind(), ACE::ldname(), ACE_Service_Manager::list_services(), ACE_DLL_Handle::open(), sema_init(), ACE_SPIPE_Addr::set(), ACE_FILE_Addr::set(), and uname(). { return ::strcat (s, t); }

ACE_INLINE wchar_t * ACE_OS::strchr (  wchar_t *  s, wchar_t  c )

Finds the first occurance of a character in a string (wchar_t version). Definition at line 106 of file OS_NS_string.inl. References strchr(). { return const_cast<wchar_t *> (ACE_OS::strchr (const_cast<const wchar_t *> (s), c)); }

ACE_INLINE char * ACE_OS::strchr (  char *  s, int  c )

Finds the first occurance of a character in a string (char version). Definition at line 99 of file OS_NS_string.inl. { return ::strchr (s, c); }

ACE_INLINE const wchar_t * ACE_OS::strchr (  const wchar_t *  s, wchar_t  c )

Finds the first occurance of a character in a string (const wchar_t version). Definition at line 88 of file OS_NS_string.inl. References wcschr_emulation(). { # if defined (ACE_LACKS_WCSCHR) return ACE_OS::wcschr_emulation (s, c); # else /* ACE_LACKS_WCSCHR */ return ::wcschr (s, c); # endif /* ACE_LACKS_WCSCHR */ }

ACE_INLINE const char * ACE_OS::strchr (  const char *  s, int  c )

Finds the first occurance of a character in a string (const char version). Definition at line 77 of file OS_NS_string.inl. Referenced by ACE_SString::find(), ACE_Service_Manager::handle_input(), ACE_Ini_ImpExp::import_config(), ACE_Registry_ImpExp::import_config(), ACE_Get_Opt::long_option(), ACE_Configuration_Heap::open_section(), ACE_Registry_ImpExp::process_previous_line_format(), putenv(), ACE_Svc_Conf_Lexer::scan(), ACE_SPIPE_Addr::set(), ACE_Get_Opt::short_option_i(), strchr(), and ACE_INET_Addr::string_to_addr(). { #if defined (ACE_LACKS_STRCHR) return ACE_OS::strchr_emulation (s, c); #else /* ! ACE_LACKS_STRCHR */ return (const char *) ::strchr (s, c); #endif /* ACE_LACKS_STRCHR */ }

ACE_INLINE int ACE_OS::strcmp (  const ACE_WCHAR_T *  s, const ACE_WCHAR_T *  t )

Compares two strings (wchar_t version). Definition at line 121 of file OS_NS_string.inl. References wcscmp_emulation(). { # if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSCMP) return ACE_OS::wcscmp_emulation (s, t); # else /* !ACE_HAS_WCHAR || ACE_LACKS_WCSCMP */ return ::wcscmp (s, t); # endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSCMP */ }

ACE_INLINE int ACE_OS::strcmp (  const char *  s, const char *  t )

Compares two strings (char version). Definition at line 115 of file OS_NS_string.inl. Referenced by ace_get_module(), ACE_Log_Msg::ACE_Log_Msg(), ACE_Service_Gestalt::add_processed_static_svc(), ACE_Malloc_FIFO_Iterator_T<, ACE_LOCK, ACE_CB >::advance(), ACE_Malloc_LIFO_Iterator_T<, ACE_LOCK, ACE_CB >::advance(), ACE_SString::compare(), ACE_Predefined_Naming_Contexts::connect(), ACE_SOCK_Dgram_Mcast::dump(), ACE_Stream<>::find(), ACE_Stream_Type::find(), ACE_DLL_Manager::find_dll(), ACE_Service_Repository::find_i(), ACE_Service_Gestalt::find_processed_static_svc(), ACE_Service_Gestalt::find_static_svc_descriptor(), ACE::get_ip_interfaces(), inet_aton(), ACE_Stream<>::insert(), ACE_Service_Repository::insert(), ACE_Capabilities::is_entry(), ACE_Predefined_Naming_Contexts::is_local_host(), ACE::ldfind(), ACE_Local_Name_Space<, ACE_LOCK >::list_type_entries_i(), ACE_Local_Name_Space<, ACE_LOCK >::list_types_i(), ACE_Naming_Context::local(), ACE_Codeset_Registry::locale_to_registry_i(), ACE_SOCK_Dgram::make_multicast_ifaddr6(), open(), ACE_DLL_Handle::open(), ACE_Service_Config::open_i(), ACE_DLL::open_i(), ACE_Configuration_ExtId::operator!=(), ACE_Less_Than< wchar_t * >::operator()(), ACE_Less_Than< const wchar_t * >::operator()(), ACE_Equal_To< wchar_t * >::operator()(), ACE_Equal_To< const wchar_t * >::operator()(), ACE_Less_Than< char * >::operator()(), ACE_Less_Than< const char * >::operator()(), ACE_Equal_To< char * >::operator()(), ACE_Equal_To< const char * >::operator()(), ACE_SString::operator<(), ACE_SString::operator==(), ACE_SPIPE_Addr::operator==(), ACE_Static_Svc_Descriptor::operator==(), ACE_Name_Binding::operator==(), ACE_FILE_Addr::operator==(), ACE_DEV_Addr::operator==(), ACE_Configuration_ExtId::operator==(), ACE_SString::operator>(), ACE_RW_Token::owners(), ACE_Name_Options::parse_args(), ACE_Get_Opt::permute(), ACE_Logging_Strategy::priorities(), ACE_Service_Manager::process_request(), ACE_Stream<>::remove(), ACE_Framework_Repository::remove_component(), ACE_Framework_Repository::remove_dll_components_i(), ACE_Stream<>::replace(), ACE_Svc_Conf_Lexer::scan(), ACE_INET_Addr::set(), ACE_Malloc_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_CB >::shared_find(), ACE_ATM_Addr::string_to_addr(), thr_equal(), ACE_Logging_Strategy::tokenize(), and ACE_Malloc_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_CB >::unbind(). { return ::strcmp (s, t); }

ACE_INLINE wchar_t * ACE_OS::strcpy (  wchar_t *  s, const wchar_t *  t )

Copies a string (wchar_t version). Definition at line 138 of file OS_NS_string.inl. References wcscpy_emulation(). { # if defined (ACE_LACKS_WCSCPY) return ACE_OS::wcscpy_emulation (s, t); # else /* ACE_LACKS_WCSCPY */ return ::wcscpy (s, t); # endif /* ACE_LACKS_WCSCPY */ }

ACE_INLINE char * ACE_OS::strcpy (  char *  s, const char *  t )

Copies a string (char version). Definition at line 131 of file OS_NS_string.inl. Referenced by ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T(), ACE_Filecache_Object::ACE_Filecache_Object(), ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool(), ACE_PI_Control_Block::ACE_Name_Node::ACE_Name_Node(), ACE_Control_Block::ACE_Name_Node::ACE_Name_Node(), ACE_Name_Options::ACE_Name_Options(), ACE_SString::ACE_SString(), ACE_System_Time::ACE_System_Time(), ACE_Configuration_Heap::add_section(), ACE_SDM_helpers::addr_to_string(), ACE_ATM_Addr::addr_to_string(), ACE_Process_Options::command_line(), ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), cuserid(), dlsym(), ACE_SOCK_Dgram_Mcast::dump(), ACE::execname(), ACE_Log_Record::format_msg(), ACE_INET_Addr::get_host_name(), ACE_INET_Addr::get_host_name_i(), ACE_ATM_Stream::get_peer_name(), get_reg_subkeys(), ACE::get_temp_dir(), getmacaddress(), inet_ntop(), ACE_MT_MEM_IO::init(), ACE::ldfind(), ACE::ldname(), ACE_Service_Manager::list_services(), ACE_Log_Msg_UNIX_Syslog::log(), ACE_Log_Msg::log(), ACE_SOCK_Dgram::make_multicast_ifaddr(), mktemp(), ACE_Configuration_Heap::new_section(), ACE_DLL_Strategy< SVC_HANDLER >::open(), ACE_Log_Msg_NT_Event_Log::open(), ACE_SOCK_Dgram_Mcast::open_i(), ACE_SString::operator=(), ACE_Sched_Params::priority_max(), ACE_Sched_Params::priority_min(), ACE_Process_Options::process_name(), ACE_Service_Gestalt::Processed_Static_Svc::Processed_Static_Svc(), ACE_InputCDR::read_string(), realpath(), ACE_Remote_Name_Space::resolve(), scandir_emulation(), scheduling_class(), sema_init(), ACE_UNIX_Addr::set(), ACE_SPIPE_Addr::set(), ACE_FILE_Addr::set(), ACE_Configuration_Heap::set_binary_value(), ACE_Configuration_Heap::set_integer_value(), ACE_Configuration_Heap::set_string_value(), ACE_Local_Name_Space<, ACE_LOCK >::shared_bind_i(), ACE::strnew(), tempnam(), uname(), and ACE_Process_Options::working_directory(). { return ::strcpy (s, t); }

ACE_INLINE size_t ACE_OS::strcspn (  const wchar_t *  s, const wchar_t *  reject )

Searches for the first substring without any of the specified characters and returns the size of the substring (wchar_t version). Definition at line 156 of file OS_NS_string.inl. References wcscspn_emulation(). { # if defined (ACE_LACKS_WCSCSPN) return ACE_OS::wcscspn_emulation (s, reject); # else /* ACE_LACKS_WCSCSPN */ return ::wcscspn (s, reject); # endif /* ACE_LACKS_WCSCSPN */ }

ACE_INLINE size_t ACE_OS::strcspn (  const char *  s, const char *  reject )

Searches for the first substring without any of the specified characters and returns the size of the substring (char version). Definition at line 149 of file OS_NS_string.inl. Referenced by ACE_Configuration::validate_name(). { return ::strcspn (s, reject); }

ACE_INLINE wchar_t * ACE_OS::strdup (  const wchar_t *  s  )

Returns a malloced duplicated string (wchar_t version). Definition at line 183 of file OS_NS_string.inl. { # if (defined (ACE_LACKS_WCSDUP) && !defined (ACE_WCSDUP_EQUIVALENT)) \ || defined (ACE_HAS_WCSDUMP_EMULATION) return ACE_OS::strdup_emulation (s); # elif defined (ACE_WCSDUP_EQUIVALENT) return ACE_WCSDUP_EQUIVALENT (s); # elif defined (ACE_HAS_NONCONST_WCSDUP) return ::wcsdup (const_cast<wchar_t*> (s)); # else return ::wcsdup (s); # endif /* (ACE_LACKS_WCSDUP && !ACE_WCSDUP_EQUIVALENT) || ... */ }

ACE_INLINE char * ACE_OS::strdup (  const char *  s  )

Returns a malloced duplicated string (char version). Definition at line 167 of file OS_NS_string.inl. Referenced by ACE_Argv_Type_Converter::ACE_Argv_Type_Converter(), ACE_Configuration_Section_Key_Heap::ACE_Configuration_Section_Key_Heap(), ACE_Mutex::ACE_Mutex(), ACE_Name_Options::ACE_Name_Options(), ACE_Name_Options::database(), event_init(), flock_init(), ACE_Thru_Task<>::info(), ACE_Stream_Tail<>::info(), ACE_Stream_Head<>::info(), ACE_Stream_Type::info(), ACE_Module_Type::info(), ACE_Service_Manager::info(), ACE_Naming_Context::info(), ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::info(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::info(), ACE_Strategy_Acceptor< SVC_HANDLER, >::info(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::info(), ACE::ldfind(), ACE_Local_Name_Space<, ACE_LOCK >::list_type_entries_i(), ACE_Name_Options::nameserver_host(), ACE_Name_Options::namespace_dir(), ACE_Name_Binding::operator=(), ACE_Name_Options::process_name(), putenv(), sema_init(), strenvdup(), string_to_argv(), and ACE_Log_Msg::sync(). { # if (defined (ACE_LACKS_STRDUP) && !defined(ACE_STRDUP_EQUIVALENT)) \ || defined (ACE_HAS_STRDUP_EMULATION) return ACE_OS::strdup_emulation (s); # elif defined (ACE_STRDUP_EQUIVALENT) return ACE_STRDUP_EQUIVALENT (s); # elif defined (ACE_HAS_NONCONST_STRDUP) return ::strdup (const_cast<char *> (s)); #else return ::strdup (s); # endif /* (ACE_LACKS_STRDUP && !ACE_STRDUP_EQUIVALENT) || ... */ }

wchar_t * ACE_OS::strecpy (  wchar_t *  s, const wchar_t *  t )

Copies a string, but returns a pointer to the end of the copied region (wchar_t version). Definition at line 86 of file OS_NS_string.cpp. References ACE_TEXT_WIDE. { register wchar_t *dscan = s; register const wchar_t *sscan = t; while ((*dscan++ = *sscan++) != ACE_TEXT_WIDE ('\0')) continue; return dscan; }

char * ACE_OS::strecpy (  char *  des, const char *  src )

Copies a string, but returns a pointer to the end of the copied region (char version). Definition at line 73 of file OS_NS_string.cpp. Referenced by argv_to_string(), and ACE::execname(). { register char *dscan = s; register const char *sscan = t; while ((*dscan++ = *sscan++) != '\0') continue; return dscan; }

ACE_INLINE ACE_TCHAR * ACE_OS::strenvdup (  const ACE_TCHAR *  str  )

Definition at line 410 of file OS_NS_stdlib.inl. References ACE_LIB_TEXT, ACE_NOTSUP_RETURN, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, getenv(), and 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 if (str[0] == ACE_LIB_TEXT ('$')) { # if defined (ACE_WIN32) // Always use the ACE_TCHAR for Windows. ACE_TCHAR *temp = 0; if ((temp = ACE_OS::getenv (&str[1])) != 0) return ACE_OS::strdup (temp); # else // Use char * for environment on non-Windows. char *temp = 0; if ((temp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&str[1]))) != 0) return ACE_OS::strdup (ACE_TEXT_CHAR_TO_TCHAR (temp)); # endif /* ACE_WIN32 */ return ACE_OS::strdup (str); } else return ACE_OS::strdup (str); #endif /* ACE_HAS_WINCE */ }

char * ACE_OS::strerror (  int  errnum  )

Finds characters in a buffer (const void version). Definition at line 99 of file OS_NS_string.cpp. References ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, ACE::is_sock_error(), ACE::sock_error(), sprintf(), and strncpy(). Referenced by ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list(), dlerror(), and ACE_Log_Msg::log(). { static char ret_errortext[128]; if (ACE::is_sock_error (errnum)) { const ACE_TCHAR *errortext = ACE::sock_error (errnum); ACE_OS::strncpy (ret_errortext, ACE_TEXT_ALWAYS_CHAR (errortext), sizeof (ret_errortext)); return ret_errortext; } #if defined (ACE_LACKS_STRERROR) errno = EINVAL; return ACE_OS::strerror_emulation (errnum); #else /* ACE_LACKS_STRERROR */ // Adapt to the various ways that strerror() indicates a bad errnum. // Most modern systems set errno to EINVAL. Some older platforms return // a pointer to a NULL string. This code makes the behavior more consistent // across platforms. On a bad errnum, we make a string with the error number // and set errno to EINVAL. ACE_Errno_Guard g (errno); errno = 0; char *errmsg; #if defined (ACE_WIN32) if (errnum < 0 || errnum >= _sys_nerr) errno = EINVAL; #endif /* ACE_WIN32 */ errmsg = ::strerror (errnum); if (errno == EINVAL || errmsg == 0 || errmsg[0] == 0) { ACE_OS::sprintf (ret_errortext, "Unknown error %d", errnum); errmsg = ret_errortext; g = EINVAL; } return errmsg; #endif /* ACE_LACKS_STRERROR */ }

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

Definition at line 402 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN. { #if defined (ACE_LACKS_STRFTIME) ACE_UNUSED_ARG (s); ACE_UNUSED_ARG (maxsize); ACE_UNUSED_ARG (format); ACE_UNUSED_ARG (timeptr); ACE_NOTSUP_RETURN (0); #else return ACE_STD_NAMESPACE::strftime (s, maxsize, format, timeptr); #endif /* ACE_LACKS_STRFTIME */ }

int ACE_OS::string_to_argv (  ACE_TCHAR *  buf, int &  argc, ACE_TCHAR **&  argv, bool  substitute_env_args = true )

Definition at line 620 of file OS_NS_unistd.cpp. References ACE_DEFAULT_ARGV_BUFSIZ, ace_isspace(), ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_TCHAR, strdup(), and strenvdup(). Referenced by ACE_ARGV_T< CHAR_TYPE >::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 != ACE_LIB_TEXT ('\0') && *cp != ACE_LIB_TEXT ('#')) { // Skip whitespace.. while (ACE_OS::ace_isspace (*cp)) cp++; // Increment count and move to next whitespace.. if (*cp != ACE_LIB_TEXT ('\0')) argc++; while (*cp != ACE_LIB_TEXT ('\0') && !ACE_OS::ace_isspace (*cp)) { // Grok quotes.... if (*cp == ACE_LIB_TEXT ('\'') || *cp == ACE_LIB_TEXT ('"')) { ACE_TCHAR quote = *cp; // Scan past the string.. for (cp++; *cp != ACE_LIB_TEXT ('\0') && *cp != quote; cp++) continue; // '\0' implies unmatched quote.. if (*cp == ACE_LIB_TEXT ('\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 != ACE_LIB_TEXT ('\0') && !ACE_OS::ace_isspace (*ptr)) if (*ptr == ACE_LIB_TEXT ('\'') || *ptr == ACE_LIB_TEXT ('"')) { ACE_TCHAR quote = *ptr++; while (*ptr != ACE_LIB_TEXT ('\0') && *ptr != quote) *cp++ = *ptr++; if (*ptr == quote) ptr++; } else *cp++ = *ptr++; *cp = ACE_LIB_TEXT ('\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 size_t ACE_OS::strlen (  const ACE_WCHAR_T *  s  )

Finds the length of a string (ACE_WCHAR_T version). Definition at line 205 of file OS_NS_string.inl. References wcslen_emulation(). { # if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSLEN) return ACE_OS::wcslen_emulation (s); # else /* !ACE_HAS_WCHAR || ACE_LACKS_WCSLEN */ return ::wcslen (s); # endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSLEN */ }

ACE_INLINE size_t ACE_OS::strlen (  const char *  s  )

Finds the length of a string (char version). Definition at line 199 of file OS_NS_string.inl. Referenced by ACE_MEM_Acceptor::accept(), ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T(), ACE_NS_WString::ACE_NS_WString(), ACE_Pagefile_Memory_Pool::ACE_Pagefile_Memory_Pool(), ACE_SString::ACE_SString(), ACE_ARGV_T< CHAR_TYPE >::add(), ACE_INET_Addr::addr_to_string(), ACE_ATM_Addr::addr_to_string(), argv_to_string(), ACE_Remote_Name_Space::bind(), ACE_Message_Block::copy(), ACE_ARGV_T< CHAR_TYPE >::create_buf_from_queue(), ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), ACE_Arg_Shifter_T< CHAR_TYPE >::cur_arg_strncasecmp(), cuserid(), ACE_Token_Request::decode(), dlsym(), ACE::execname(), ACE_String_Base< CHAR >::find(), ACE_INET_Addr::get_host_addr(), ACE_INET_Addr::get_host_name_i(), ACE_ATM_Stream::get_peer_name(), ACE::get_temp_dir(), ACE_Logging_Strategy::handle_timeout(), ACE_Ini_ImpExp::import_config(), ACE_Registry_ImpExp::import_config(), inet_ntop(), ACE_Thru_Task<>::info(), ACE_Stream_Tail<>::info(), ACE_Stream_Head<>::info(), ACE_Stream_Type::info(), ACE_Module_Type::info(), ACE_Service_Manager::info(), ACE_Naming_Context::info(), ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::info(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::info(), ACE_Strategy_Acceptor< SVC_HANDLER, >::info(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::info(), ACE_Process_Options::inherit_environment(), ACE_Svc_Conf_Lexer::input(), ACE::ldfind(), ACE::ldname(), ACE_Service_Manager::list_services(), ACE_Log_Msg::log(), ACE_Log_Msg::log_hexdump(), ACE_Get_Opt::long_option_i(), ACE_Function_Node::make_func_name(), ACE_Registry::make_name(), ACE_Log_Record::msg_data_len(), ACE_Log_Msg_NT_Event_Log::open(), ACE_Configuration_Heap::open(), ACE_SOCK_Dgram_Mcast::open_i(), operator+(), ACE_String_Base< CHAR >::operator+=(), operator<<(), ACE_String_Base< CHAR >::operator==(), operator>>(), ACE_Log_Record::print(), ACE_Remote_Name_Space::rebind(), ACE_SString::rep(), ACE_Local_Name_Space<, ACE_LOCK >::resolve_i(), ACE_Log_Record::round_up(), scandir_emulation(), ACE_String_Base< CHAR >::set(), ACE_SPIPE_Addr::set(), ACE_DEV_Addr::set(), ACE_Local_Name_Space<, ACE_LOCK >::shared_bind_i(), ACE_Process::spawn(), ACE_Ini_ImpExp::squish(), strnstr(), strrchr_emulation(), ACE::strsplit_r(), strtok_r_emulation(), tempnam(), wcsrchr_emulation(), wcsstr_emulation(), ACE_OutputCDR::write_string(), ACE_SizeCDR::write_string(), ACE_OutputCDR::write_wstring(), and ACE_SizeCDR::write_wstring(). { return ::strlen (s); }

ACE_NAMESPACE_INLINE_FUNCTION int strncasecmp (  const wchar_t *  s, const wchar_t *  t, size_t  len )

Compares two arrays (case insensitive const wchar_t version).

ACE_INLINE int ACE_OS::strncasecmp (  const char *  s, const char *  t, size_t  len )

Compares two arrays (case insensitive const char version). Definition at line 36 of file OS_NS_strings.inl. References strncasecmp_emulation(). Referenced by ACE_Arg_Shifter_T< CHAR_TYPE >::cur_arg_strncasecmp(). { #if defined (ACE_LACKS_STRCASECMP) return ACE_OS::strncasecmp_emulation (s, t, len); #elif defined (ACE_STRNCASECMP_EQUIVALENT) return ACE_STRNCASECMP_EQUIVALENT (s, t, len); #else /* ACE_LACKS_STRCASECMP */ return ::strncasecmp (s, t, len); #endif /* ACE_LACKS_STRCASECMP */ }

int ACE_OS::strncasecmp_emulation (  const char *  s, const char *  t, size_t  len )

Emulated strncasecmp - Performs a case insensitvie comparison of arrays. Definition at line 49 of file OS_NS_strings.cpp. References ace_tolower(). Referenced by strncasecmp(). { const char *scan1 = s; const char *scan2 = t; size_t count = 0; while (count++ < len && *scan1 != 0 && ACE_OS::ace_tolower (*scan1) == ACE_OS::ace_tolower (*scan2)) { ++scan1; ++scan2; } if (count > len) return 0; // The following case analysis is necessary so that characters which // look negative collate low against normal characters but high // against the end-of-string NUL. if (*scan1 == '\0' && *scan2 == '\0') return 0; else if (*scan1 == '\0') return -1; else if (*scan2 == '\0') return 1; else return ACE_OS::ace_tolower (*scan1) - ACE_OS::ace_tolower (*scan2); }

ACE_INLINE ACE_WCHAR_T * ACE_OS::strncat (  ACE_WCHAR_T *  s, const ACE_WCHAR_T *  t, size_t  len )

Appends part of a string to another string (wchar_t version). Definition at line 221 of file OS_NS_string.inl. References wcsncat_emulation(). { # if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSNCAT) return ACE_OS::wcsncat_emulation (s, t, len); # else /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCAT */ return ::wcsncat (s, t, len); # endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCAT */ }

ACE_INLINE char * ACE_OS::strncat (  char *  s, const char *  t, size_t  len )

Appends part of a string to another string (char version). Definition at line 215 of file OS_NS_string.inl. Referenced by ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), ACE_Log_Msg_NT_Event_Log::open(), and strsncpy(). { return ::strncat (s, t, len); }

ACE_INLINE ACE_WCHAR_T * ACE_OS::strnchr (  ACE_WCHAR_T *  s, ACE_WCHAR_T  c, size_t  len )

Finds the first occurance of a character in an array (ACE_WCHAR_T version). Definition at line 239 of file OS_NS_string.inl. References strnchr(). { return const_cast<ACE_WCHAR_T *> (ACE_OS::strnchr ( const_cast<const ACE_WCHAR_T *> (s), c, len)); }

ACE_INLINE char * ACE_OS::strnchr (  char *  s, int  c, size_t  len )

Finds the first occurance of a character in an array (char version). Definition at line 231 of file OS_NS_string.inl. References strnchr(). { return const_cast<char *> (ACE_OS::strnchr (static_cast<const char *> (s), c, len)); }

const ACE_WCHAR_T * ACE_OS::strnchr (  const ACE_WCHAR_T *  s, ACE_WCHAR_T  c, size_t  len )

Finds the first occurance of a character in an array (const ACE_WCHAR_T version). Definition at line 162 of file OS_NS_string.cpp. { for (size_t i = 0; i < len; ++i) if (s[i] == c) return s + i; return 0; }

const char * ACE_OS::strnchr (  const char *  s, int  c, size_t  len )

Finds the first occurance of a character in an array (const char version). Definition at line 152 of file OS_NS_string.cpp. Referenced by ACE_String_Base< CHAR >::find(), and strnchr(). { for (size_t i = 0; i < len; ++i) if (s[i] == c) return s + i; return 0; }

ACE_INLINE int ACE_OS::strncmp (  const ACE_WCHAR_T *  s, const ACE_WCHAR_T *  t, size_t  len )

Compares two arrays (wchar_t version). Definition at line 255 of file OS_NS_string.inl. References wcsncmp_emulation(). { # if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSNCMP) return ACE_OS::wcsncmp_emulation (s, t, len); # else /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCMP */ return ::wcsncmp (s, t, len); # endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCMP */ }

ACE_INLINE int ACE_OS::strncmp (  const char *  s, const char *  t, size_t  len )

Compares two arrays (char version). Definition at line 249 of file OS_NS_string.inl. Referenced by ACE_Registry_ImpExp::import_config(), ACE_Get_Opt::long_option_i(), ACE_Function_Node::make_func_name(), ACE_UNIX_Addr::operator==(), ACE_SPIPE_Addr::set(), and wcsstr_emulation(). { return ::strncmp (s, t, len); }

ACE_INLINE ACE_WCHAR_T * ACE_OS::strncpy (  ACE_WCHAR_T *  s, const ACE_WCHAR_T *  t, size_t  len )

Copies an array (ACE_WCHAR_T version). Definition at line 271 of file OS_NS_string.inl. References wcsncpy_emulation(). { # if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSNCPY) return ACE_OS::wcsncpy_emulation (s, t, len); # else /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCPY */ return ::wcsncpy (s, t, len); # endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCPY */ }

ACE_INLINE char * ACE_OS::strncpy (  char *  s, const char *  t, size_t  len )

Copies an array (char version). Definition at line 265 of file OS_NS_string.inl. Referenced by dlerror(), event_init(), ACE_DLL_Handle::open(), ACE_Svc_Conf_Lexer::scan(), and strerror(). { return ::strncpy (s, t, len); }

ACE_INLINE size_t ACE_OS::strnlen (  const ACE_WCHAR_T *  s, size_t  maxlen )

Finds the length of a limited-length string (ACE_WCHAR_T version). Parameters: s  The character string to find the length of. maxlen  The maximum number of characters that will be scanned for the terminating nul character. Returns: The length of s, if the terminating nul character is located, else maxlen. Definition at line 295 of file OS_NS_string.inl. { #if defined (ACE_HAS_WCHAR) && defined (ACE_HAS_WCSNLEN) return wcsnlen (s, maxlen); #else /* ACE_HAS_WCSNLEN */ size_t i; for (i = 0; i < maxlen; ++i) if (s[i] == '\0') break; return i; #endif /* ACE_HAS_WCSNLEN */ }

ACE_INLINE size_t ACE_OS::strnlen (  const char *  s, size_t  maxlen )

Finds the length of a limited-length string (char version). Parameters: s  The character string to find the length of. maxlen  The maximum number of characters that will be scanned for the terminating nul character. Returns: The length of s, if the terminating nul character is located, else maxlen. Definition at line 281 of file OS_NS_string.inl. { #if defined (ACE_HAS_STRNLEN) return ::strnlen (s, maxlen); #else /* ACE_HAS_STRNLEN */ size_t i; for (i = 0; i < maxlen; ++i) if (s[i] == '\0') break; return i; #endif /* ACE_HAS_STRNLEN */ }

ACE_INLINE ACE_WCHAR_T * ACE_OS::strnstr (  ACE_WCHAR_T *  s, const ACE_WCHAR_T *  t, size_t  len )

Finds the first occurance of a substring in an array (wchar_t version). Definition at line 315 of file OS_NS_string.inl. References strnstr(). { return const_cast<ACE_WCHAR_T *> (ACE_OS::strnstr ( static_cast<const ACE_WCHAR_T *> (s), t, len)); }

ACE_INLINE char * ACE_OS::strnstr (  char *  s, const char *  t, size_t  len )

Finds the first occurance of a substring in an array (char version). Definition at line 309 of file OS_NS_string.inl. References strnstr(). { return (char *) ACE_OS::strnstr ((const char *) s, t, len); }

const ACE_WCHAR_T * ACE_OS::strnstr (  const ACE_WCHAR_T *  s, const ACE_WCHAR_T *  t, size_t  len )

Finds the first occurance of a substring in an array (const wchar_t version). Definition at line 195 of file OS_NS_string.cpp. References ACE_WCHAR_T, memcmp(), and strlen(). { // Substring length const size_t len1 = ACE_OS::strlen (s1); // Check if the substring is longer than the string being searched. if (len2 > len1) return 0; // Go upto <len> const size_t len = len1 - len2; for (size_t i = 0; i <= len; i++) { if (ACE_OS::memcmp (s1 + i, s2, len2 * sizeof (ACE_WCHAR_T)) == 0) // Found a match! Return the index. return s1 + i; } return 0; }

const char * ACE_OS::strnstr (  const char *  s, const char *  t, size_t  len )

Finds the first occurance of a substring in an array (const char version). Definition at line 172 of file OS_NS_string.cpp. References memcmp(), and strlen(). Referenced by ACE_String_Base< CHAR >::find(), and strnstr(). { // Substring length const size_t len1 = ACE_OS::strlen (s1); // Check if the substring is longer than the string being searched. if (len2 > len1) return 0; // Go upto <len> const size_t len = len1 - len2; for (size_t i = 0; i <= len; i++) { if (ACE_OS::memcmp (s1 + i, s2, len2) == 0) // Found a match! Return the index. return s1 + i; } return 0; }

ACE_INLINE wchar_t * ACE_OS::strpbrk (  wchar_t *  s1, const wchar_t *  s2 )

Searches for characters in a string (wchar_t version). Definition at line 358 of file OS_NS_string.inl. References strpbrk(). { return const_cast<wchar_t *> (ACE_OS::strpbrk ( const_cast<const wchar_t *> (s), t)); }

ACE_INLINE char * ACE_OS::strpbrk (  char *  s1, const char *  s2 )

Searches for characters in a string (char version). Definition at line 347 of file OS_NS_string.inl. { #if defined (ACE_LACKS_STRPBRK) return ACE_OS::strpbrk_emulation (s1, s2); #else /* ACE_LACKS_STRPBRK */ return ::strpbrk (s1, s2); #endif /* ACE_LACKS_STRPBRK */ }

ACE_INLINE const wchar_t * ACE_OS::strpbrk (  const wchar_t *  s1, const wchar_t *  s2 )

Searches for characters in a string (const wchar_t version). Definition at line 336 of file OS_NS_string.inl. References wcspbrk_emulation(). { # if defined (ACE_LACKS_WCSPBRK) return ACE_OS::wcspbrk_emulation (s, t); # else /* ACE_LACKS_WCSPBRK */ return ::wcspbrk (s, t); # endif /* ACE_LACKS_WCSPBRK */ }

ACE_INLINE const char * ACE_OS::strpbrk (  const char *  s1, const char *  s2 )

Searches for characters in a string (const char version). Definition at line 325 of file OS_NS_string.inl. Referenced by ACE_Registry_ImpExp::process_previous_line_format(), and strpbrk(). { #if defined (ACE_LACKS_STRPBRK) return ACE_OS::strpbrk_emulation (s1, s2); #else /* ACE_LACKS_STRPBRK */ return (const char *) ::strpbrk (s1, s2); #endif /* ACE_LACKS_STRPBRK */ }

ACE_INLINE char * ACE_OS::strptime (  const char *  buf, const char *  format, struct tm *  tm )

Definition at line 417 of file OS_NS_time.inl. References ACE_NOTSUP_RETURN. { #if defined (ACE_LACKS_STRPTIME) # if defined (ACE_REFUSE_STRPTIME_EMULATION) ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (format); ACE_UNUSED_ARG (tm); ACE_NOTSUP_RETURN (0); # else return ACE_OS::strptime_emulation (buf, format, tm); # endif /* ACE_REFUSE_STRPTIME_EMULATION */ #else return ::strptime (buf, format, tm); #endif /* ACE_LACKS_STRPTIME */ }

ACE_INLINE wchar_t * ACE_OS::strrchr (  wchar_t *  s, wchar_t  c )

Finds the last occurance of a character in a string (wchar_t version). Definition at line 399 of file OS_NS_string.inl. References strrchr(). { return const_cast<wchar_t *> (ACE_OS::strrchr ( const_cast<const wchar_t *> (s), c)); }

ACE_INLINE char * ACE_OS::strrchr (  char *  s, int  c )

Finds the last occurance of a character in a string (char version). Definition at line 388 of file OS_NS_string.inl. References strrchr_emulation(). { #if defined (ACE_LACKS_STRRCHR) return ACE_OS::strrchr_emulation (s, c); #else /* ! ACE_LACKS_STRRCHR */ return ::strrchr (s, c); #endif /* ! ACE_LACKS_STRRCHR */ }

ACE_INLINE const wchar_t * ACE_OS::strrchr (  const wchar_t *  s, wchar_t  c )

Finds the last occurance of a character in a string (const wchar_t version). Definition at line 377 of file OS_NS_string.inl. References wcsrchr_emulation(). { #if defined (ACE_LACKS_WCSRCHR) return ACE_OS::wcsrchr_emulation (s, c); #else /* ! ACE_LACKS_WCSRCHR */ return const_cast <const wchar_t *> (::wcsrchr (s, c)); #endif /* ! ACE_LACKS_WCSRCHR */ }

ACE_INLINE const char * ACE_OS::strrchr (  const char *  s, int  c )

Finds the last occurance of a character in a string (const char version). Definition at line 366 of file OS_NS_string.inl. References strrchr_emulation(). Referenced by ACE_SDM_helpers::addr_to_string(), ACE::basename(), ACE::dirname(), ACE::execname(), ACE_Ini_ImpExp::import_config(), ACE_Registry_ImpExp::import_config(), ACE::ldfind(), sema_init(), ACE_INET_Addr::string_to_addr(), and strrchr(). { #if defined (ACE_LACKS_STRRCHR) return ACE_OS::strrchr_emulation (s, c); #else /* ! ACE_LACKS_STRRCHR */ return (const char *) ::strrchr (s, c); #endif /* ! ACE_LACKS_STRRCHR */ }

const char * ACE_OS::strrchr_emulation (  const char *  s, int  c )

Emulated strrchr (const char version) - Finds the last occurance of a character in a string. Definition at line 283 of file OS_NS_string.cpp. References strlen(). { const char *p = s + ACE_OS::strlen (s); while (*p != c) if (p == s) return 0; else --p; return p; }

char * ACE_OS::strrchr_emulation (  char *  s, int  c )

Emulated strrchr (char version) - Finds the last occurance of a character in a string. Definition at line 269 of file OS_NS_string.cpp. References strlen(). Referenced by strrchr(). { char *p = s + ACE_OS::strlen (s); while (*p != c) if (p == s) return 0; else --p; return p; }

ACE_WCHAR_T * ACE_OS::strsncpy (  ACE_WCHAR_T *  dst, const ACE_WCHAR_T *  src, size_t  maxlen )

This is a "safe" c string copy function (wchar_t version). Unlike strncpy() this function will always add a terminating '' char if maxlen > 0. So the user doesn't has to provide an extra '' if the user wants a '' terminated dst. The function doesn't check for a 0 dst, because this will give problems anyway. When src is 0 an empty string is made. We do not "touch" * dst if maxlen is 0. Returns dst. Care should be taken when replacing strncpy() calls, because in some cases a strncpy() user is using the "not '\0' terminating" feature from strncpy(). This happens most when the call to strncpy() was optimized by using a maxlen which is 1 smaller than the size because there's always written a '' inside this last position. Very seldom it's possible that the '' padding feature from strncpy() is needed. Definition at line 322 of file OS_NS_string.cpp. References ACE_TEXT_WIDE, ACE_WCHAR_T, and strncat(). { register ACE_WCHAR_T *rdst = dst; register const ACE_WCHAR_T *rsrc = src; register size_t rmaxlen = maxlen; if (rmaxlen > 0) { if (rdst!=rsrc) { *rdst = ACE_TEXT_WIDE ('\0'); if (rsrc != 0) strncat (rdst, rsrc, --rmaxlen); } else { rdst += (rmaxlen - 1); *rdst = ACE_TEXT_WIDE ('\0'); } } return dst; }

char * ACE_OS::strsncpy (  char *  dst, const char *  src, size_t  maxlen )

This is a "safe" c string copy function (char version). Unlike strncpy() this function will always add a terminating '' char if maxlen > 0. So the user doesn't has to provide an extra '' if the user wants a '' terminated dst. The function doesn't check for a 0 dst, because this will give problems anyway. When src is 0 an empty string is made. We do not "touch" * dst if maxlen is 0. Returns dst. Care should be taken when replacing strncpy() calls, because in some cases a strncpy() user is using the "not '\0' terminating" feature from strncpy(). This happens most when the call to strncpy() was optimized by using a maxlen which is 1 smaller than the size because there's always written a '' inside this last position. Very seldom it's possible that the '' padding feature from strncpy() is needed. Definition at line 298 of file OS_NS_string.cpp. References strncat(). Referenced by ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool(), ACE_Mutex_Token::ACE_Mutex_Token(), ACE_Pagefile_Memory_Pool::ACE_Pagefile_Memory_Pool(), ACE_RW_Token::ACE_RW_Token(), ACE_System_Time::ACE_System_Time(), ACE_Token_Collection::ACE_Token_Collection(), ACE_UNIX_Addr::addr_to_string(), ACE_SPIPE_Addr::addr_to_string(), ACE_FILE_Addr::addr_to_string(), ACE_DEV_Addr::addr_to_string(), asctime_r(), ACE_TPQ_Entry::client_id(), ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), ctime_r(), ACE::dirname(), ACE_Log_Msg::file(), ACE_INET_Addr::get_host_addr(), getcwd(), ACE_Thru_Task<>::info(), ACE_Stream_Tail<>::info(), ACE_Stream_Head<>::info(), ACE_Stream_Type::info(), ACE_Module_Type::info(), ACE_Service_Manager::info(), ACE_Naming_Context::info(), ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::info(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::info(), ACE_Strategy_Acceptor< SVC_HANDLER, >::info(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::info(), ACE_Log_Msg::log(), ACE_Log_Msg::msg(), ACE_Log_Record::msg_data(), ACE_Mem_Map::open(), ACE_FIFO::open(), ACE_String_Base< CHAR >::rep(), ACE_Local_Name_Space<, ACE_LOCK >::resolve_i(), ACE_UNIX_Addr::set(), ACE_SPIPE_Addr::set(), ACE_FILE_Addr::set(), ACE_DEV_Addr::set(), ACE_UNIX_Addr::string_to_addr(), ACE::strndup(), ACE::strnnew(), thr_create(), ACE::timestamp(), ACE_Name_Request::type(), and unique_name(). { register char *rdst = dst; register const char *rsrc = src; register size_t rmaxlen = maxlen; if (rmaxlen > 0) { if (rdst!=rsrc) { *rdst = '\0'; if (rsrc != 0) strncat (rdst, rsrc, --rmaxlen); } else { rdst += (rmaxlen - 1); *rdst = '\0'; } } return dst; }

ACE_INLINE size_t ACE_OS::strspn (  const wchar_t *  s1, const wchar_t *  s2 )

Searches for the first substring containing only the specified characters and returns the size of the substring (wchar_t version). Definition at line 418 of file OS_NS_string.inl. References wcsspn_emulation(). { # if defined (ACE_LACKS_WCSSPN) return ACE_OS::wcsspn_emulation (s, t); # else /* ACE_LACKS_WCSSPN */ return ::wcsspn (s, t); # endif /* ACE_LACKS_WCSSPN */ }

ACE_INLINE size_t ACE_OS::strspn (  const char *  s1, const char *  s2 )

Searches for the first substring containing only the specified characters and returns the size of the substring (char version). Definition at line 407 of file OS_NS_string.inl. { #if defined (ACE_LACKS_STRSPN) return ACE_OS::strspn_emulation (s, t); #else /* ACE_LACKS_STRSPN */ return ::strspn (s, t); #endif /* ACE_LACKS_STRSPN */ }

ACE_INLINE wchar_t * ACE_OS::strstr (  wchar_t *  s, const wchar_t *  t )

Finds the first occurance of a substring in a string (wchar_t version). Definition at line 456 of file OS_NS_string.inl. References wcsstr_emulation(). { # if defined (ACE_LACKS_WCSSTR) return ACE_OS::wcsstr_emulation (s, t); # elif defined (HPUX) return ::wcswcs (s, t); # else /* ACE_LACKS_WCSSTR */ return ::wcsstr (s, t); # endif /* ACE_LACKS_WCSSTR */ }

ACE_INLINE char * ACE_OS::strstr (  char *  s, const char *  t )

Finds the first occurance of a substring in a string (char version). Definition at line 449 of file OS_NS_string.inl. { return ::strstr (s, t); }

ACE_INLINE const wchar_t * ACE_OS::strstr (  const wchar_t *  s, const wchar_t *  t )

Finds the first occurance of a substring in a string (const wchar_t version). Definition at line 436 of file OS_NS_string.inl. References wcsstr_emulation(). { # if defined (ACE_LACKS_WCSSTR) return ACE_OS::wcsstr_emulation (s, t); # elif defined (HPUX) return const_cast <const wchar_t *> (::wcswcs (s, t)); # else /* ACE_LACKS_WCSSTR */ return const_cast <const wchar_t *> (::wcsstr (s, t)); # endif /* ACE_LACKS_WCSSTR */ }

ACE_INLINE const char * ACE_OS::strstr (  const char *  s, const char *  t )

Finds the first occurance of a substring in a string (const char version). Definition at line 429 of file OS_NS_string.inl. Referenced by ACE_SString::find(), ACE_ATM_Stream::get_peer_name(), ACE_Local_Name_Space<, ACE_LOCK >::list_type_entries_i(), ACE_Local_Name_Space<, ACE_LOCK >::list_types_i(), and ACE::strsplit_r(). { return (const char *) ::strstr (s, t); }

ACE_INLINE double ACE_OS::strtod (  const wchar_t *  s, wchar_t **  endptr )

Converts a string to a double value (wchar_t version). Definition at line 449 of file OS_NS_stdlib.inl. { return ACE_WCHAR_STD_NAMESPACE::wcstod (s, endptr); }

ACE_INLINE double ACE_OS::strtod (  const char *  s, char **  endptr )

Converts a string to a double value (char version). Definition at line 441 of file OS_NS_stdlib.inl. Referenced by ACE_Convert(). { return ::strtod (s, endptr); }

ACE_INLINE wchar_t * ACE_OS::strtok (  wchar_t *  s, const wchar_t *  tokens )

Finds the next token in a string (wchar_t version). Definition at line 476 of file OS_NS_string.inl. { #if defined (ACE_HAS_3_PARAM_WCSTOK) static wchar_t *lasts; return ::wcstok (s, tokens, &lasts); #else return ::wcstok (s, tokens); #endif /* ACE_HAS_3_PARAM_WCSTOK */ }

ACE_INLINE char * ACE_OS::strtok (  char *  s, const char *  tokens )

Finds the next token in a string (char version). Definition at line 469 of file OS_NS_string.inl. { return ::strtok (s, tokens); }

ACE_INLINE wchar_t * ACE_OS::strtok_r (  ACE_WCHAR_T *  s, const ACE_WCHAR_T *  tokens, ACE_WCHAR_T **  lasts )

Finds the next token in a string (wchar_t version). Definition at line 499 of file OS_NS_string.inl. References strtok_r_emulation(). { #if defined (ACE_LACKS_WCSTOK) return ACE_OS::strtok_r_emulation (s, tokens, lasts); #else # if defined (ACE_HAS_3_PARAM_WCSTOK) return ::wcstok (s, tokens, lasts); # else /* ACE_HAS_3_PARAM_WCSTOK */ *lasts = ::wcstok (s, tokens); return *lasts; # endif /* ACE_HAS_3_PARAM_WCSTOK */ #endif /* ACE_LACKS_WCSTOK */ }

ACE_INLINE char * ACE_OS::strtok_r (  char *  s, const char *  tokens, char **  lasts )

Finds the next token in a string (safe char version). Definition at line 488 of file OS_NS_string.inl. References strtok_r_emulation(). Referenced by ACE_ATM_Stream::get_peer_name(), ACE_Log_Msg_UNIX_Syslog::log(), ACE_Logging_Strategy::priorities(), and ACE_Logging_Strategy::tokenize(). { #if defined (ACE_HAS_REENTRANT_FUNCTIONS) return ::strtok_r (s, tokens, lasts); #else return ACE_OS::strtok_r_emulation (s, tokens, lasts); #endif /* (ACE_HAS_REENTRANT_FUNCTIONS) */ }

char * ACE_OS::strtok_r_emulation (  char *  s, const char *  tokens, char **  lasts )

Emulated strtok_r. Definition at line 366 of file OS_NS_string.cpp. References strlen(). Referenced by strtok_r(). { if (s == 0) s = *lasts; else *lasts = s; if (*s == 0) // We have reached the end return 0; size_t l_org = ACE_OS::strlen (s); s = ::strtok (s, tokens); if (s == 0) return 0; const size_t l_sub = ACE_OS::strlen (s); if (s + l_sub < *lasts + l_org) *lasts = s + l_sub + 1; else *lasts = s + l_sub; return s ; }

ACE_INLINE long ACE_OS::strtol (  const wchar_t *  s, wchar_t **  ptr, int  base )

Converts a string to a long value (wchar_t version). Definition at line 467 of file OS_NS_stdlib.inl. { return ACE_WCHAR_STD_NAMESPACE::wcstol (s, ptr, base); }

ACE_INLINE long ACE_OS::strtol (  const char *  s, char **  ptr, int  base )

Converts a string to a long value (char version). Definition at line 456 of file OS_NS_stdlib.inl. Referenced by ACE_Convert(), get_port_number_from_name(), and ACE_INET_Addr::string_to_addr(). { #if defined (ACE_LACKS_STRTOL) return ACE_OS::strtol_emulation (s, ptr, base); #else /* ACE_LACKS_STRTOL */ return ::strtol (s, ptr, base); #endif /* ACE_LACKS_STRTOL */ }

ACE_INLINE unsigned long ACE_OS::strtoul (  const wchar_t *  s, wchar_t **  ptr, int  base )

Converts a string to an unsigned long value (wchar_t version). Definition at line 485 of file OS_NS_stdlib.inl. { return ACE_WCHAR_STD_NAMESPACE::wcstoul (s, ptr, base); }

ACE_INLINE unsigned long ACE_OS::strtoul (  const char *  s, char **  ptr, int  base )

Converts a string to an unsigned long value (char version). Definition at line 474 of file OS_NS_stdlib.inl. Referenced by ACE_Convert(), ACE_MEM_Addr::ACE_MEM_Addr(), ACE_Registry_ImpExp::import_config(), ACE_Logging_Strategy::parse_args(), and ACE_MEM_Addr::string_to_addr(). { #if defined (ACE_LACKS_STRTOUL) return ACE_OS::strtoul_emulation (s, ptr, base); #else /* ACE_LACKS_STRTOUL */ return ::strtoul (s, ptr, base); #endif /* ACE_LACKS_STRTOUL */ }

ACE_INLINE void ACE_OS::swab (  const void *  src, void *  dest, ssize_t  n )

Definition at line 921 of file OS_NS_unistd.inl. References ssize_t. { #if defined (ACE_LACKS_SWAB) const char *from = static_cast<const char*> (src); char *to = static_cast<char *> (dest); ssize_t ptr = 0; for (ptr = 1; ptr < length; ptr += 2) { char p = from[ptr]; char q = from[ptr-1]; to[ptr-1] = p; to[ptr ] = q; } if (ptr == length) /* I.e., if length is odd, */ to[ptr-1] = 0; /* then pad with a NUL. */ #elif defined (ACE_HAS_NONCONST_SWAB) const char *tmp = static_cast<const char*> (src); char *from = const_cast<char *> (tmp); char *to = static_cast<char *> (dest); ::swab (from, to, length); #elif defined (ACE_HAS_CONST_CHAR_SWAB) const char *from = static_cast<const char*> (src); char *to = static_cast<char *> (dest); ::swab (from, to, length); #else ::swab (src, dest, length); #endif /* ACE_LACKS_SWAB */ }

ACE_INLINE long ACE_OS::sysconf (  int   )

Definition at line 954 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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_LACKS_SYSCONF) ACE_UNUSED_ARG (name); ACE_NOTSUP_RETURN (-1); #else ACE_OSCALL_RETURN (::sysconf (name), long, -1); #endif /* ACE_LACKS_SYSCONF */ }

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

Definition at line 966 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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  )

Definition at line 492 of file OS_NS_stdlib.inl. References ACE_NOTSUP_RETURN, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, and system(). Referenced by system(). { // ACE_OS_TRACE ("ACE_OS::system"); #if defined (ACE_LACKS_SYSTEM) ACE_UNUSED_ARG (s); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_OSCALL_RETURN (::_wsystem (s), int, -1); #elif defined(ACE_TANDEM_T1248_PTHREADS) ACE_OSCALL_RETURN (::spt_system (s), int, -1); #else ACE_OSCALL_RETURN (::system (ACE_TEXT_ALWAYS_CHAR (s)), int, -1); #endif /* ACE_LACKS_SYSTEM */ }

ACE_INLINE int ACE_OS::t_accept (  ACE_HANDLE  fildes, ACE_HANDLE  resfd, struct t_call *  call )

Definition at line 12 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_accept(). Referenced by ACE_TLI_Acceptor::accept(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_accept (handle, reshandle, call), int, -1); #else ACE_UNUSED_ARG (call); ACE_UNUSED_ARG (reshandle); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE char * ACE_OS::t_alloc (  ACE_HANDLE  fildes, int  struct_type, int  fields )

Definition at line 26 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_alloc(). Referenced by ACE_TLI_Connector::connect(), ACE_TLI_Acceptor::open(), and ACE_TLI_Request_Queue::open(). { #if defined (ACE_HAS_TLI) # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) // XPG5 changes t_alloc() return from char* to void*, so ACE_OSCALL_RETURN // doesn't compile correctly. char *result; ACE_OSCALL (::t_alloc (handle, struct_type, fields), char *, 0, result); return result; # else ACE_OSCALL_RETURN (::t_alloc (handle, struct_type, fields), char *, 0); # endif /* XPG4 vs XPG5 */ #else ACE_UNUSED_ARG (fields); ACE_UNUSED_ARG (struct_type); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (0); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_bind (  ACE_HANDLE  fildes, struct t_bind *  req, struct t_bind *  ret )

Definition at line 49 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_bind(). Referenced by ACE_TLI_Connector::connect(), ACE_TLI_Acceptor::open(), and open_new_endpoint(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_bind (handle, req, ret), int, -1); #else ACE_UNUSED_ARG (ret); ACE_UNUSED_ARG (req); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_close (  ACE_HANDLE  fildes  )

Definition at line 63 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_close(). Referenced by ACE_TLI_Acceptor::accept(), ACE_TLI_Stream::close(), ACE_TLI::close(), and ACE_TLI_Request_Queue::remove(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_close (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_connect (  ACE_HANDLE  fildes, struct t_call *  sndcall, struct t_call *  rcvcall )

Definition at line 75 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_connect(). Referenced by ACE_TLI_Connector::connect(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_connect (fildes, sndcall, rcvcall), int, -1); #else ACE_UNUSED_ARG (fildes); ACE_UNUSED_ARG (sndcall); ACE_UNUSED_ARG (rcvcall); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE void ACE_OS::t_error (  const char *  errmsg  )

Definition at line 91 of file OS_TLI.inl. Referenced by ACE_ATM_QoS::construct_options(), and ACE_ATM_Stream::get_vpi_vci(). { #if defined (ACE_HAS_TLI) #if defined (ACE_HAS_BROKEN_T_ERROR) ::t_error (const_cast<char *> (errmsg)); #else ::t_error (errmsg); #endif /* ACE_HAS_BROKEN_T_ERROR */ #else ACE_UNUSED_ARG (errmsg); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_free (  char *  ptr, int  struct_type )

Definition at line 105 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_free(). Referenced by ACE_TLI_Acceptor::close(), ACE_TLI_Request_Queue::close(), and ACE_TLI_Connector::connect(). { #if defined (ACE_HAS_TLI) if (ptr == 0) return 0; ACE_OSCALL_RETURN (::t_free (ptr, struct_type), int, -1); #else ACE_UNUSED_ARG (struct_type); ACE_UNUSED_ARG (ptr); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_getinfo (  ACE_HANDLE  fildes, struct t_info *  info )

Definition at line 120 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_getinfo(). Referenced by ACE_ATM_QoS::construct_options(), and ACE_ATM_Stream::get_vpi_vci(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_getinfo (handle, info), int, -1); #else ACE_UNUSED_ARG (info); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_getname (  ACE_HANDLE  fildes, struct netbuf *  namep, int  type )

Definition at line 133 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, last_error(), t_bind(), and t_getname(). Referenced by ACE_TLI_Connector::complete(), ACE_ATM_QoS::construct_options(), ACE_TLI::get_local_addr(), ACE_ATM_Stream::get_peer_name(), and ACE_TLI_Stream::get_remote_addr(). { #if defined (ACE_HAS_XTI) struct t_bind bound, peer; // Depending on which address the caller wants, fill caller's values // into one of the t_bind netbufs. The other is set up to ignore that // address. switch (type) { case LOCALNAME: bound.addr.buf = namep->buf; bound.addr.maxlen = namep->maxlen; bound.addr.len = 0; peer.addr.buf = 0; peer.addr.maxlen = 0; peer.addr.len = 0; break; case REMOTENAME: bound.addr.buf = 0; bound.addr.maxlen = 0; bound.addr.len = 0; peer.addr.buf = namep->buf; peer.addr.maxlen = namep->maxlen; peer.addr.len = 0; break; default: ACE_OS::last_error (EINVAL); return -1; } if (t_getprotaddr (handle, &bound, &peer) == -1) return -1; // Call succeeded; put the caller's desired address length in his netbuf. if (type == LOCALNAME) namep->len = bound.addr.len; else namep->len = peer.addr.len; return 0; #elif defined (ACE_HAS_SVR4_TLI) ACE_OSCALL_RETURN (::t_getname (handle, namep, type), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (namep); ACE_UNUSED_ARG (type); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SVR4_TLI */ }

ACE_INLINE int ACE_OS::t_getstate (  ACE_HANDLE  fildes  )

Definition at line 183 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_getstate(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_getstate (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_listen (  ACE_HANDLE  fildes, struct t_call *  call )

Definition at line 195 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_listen(). Referenced by ACE_TLI_Acceptor::accept(), and ACE_TLI_Request_Queue::enqueue(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_listen (handle, call), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (call); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_look (  ACE_HANDLE  fildes  )

Definition at line 208 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_look(). Referenced by ACE_XTI_ATM_Mcast::add_leaf(), ACE_TLI_Connector::complete(), and ACE_TLI::look(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_look (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE ACE_HANDLE ACE_OS::t_open (  char *  path, int  oflag, struct t_info *  info )

Definition at line 220 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_open(). Referenced by open_new_endpoint(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_open (path, oflag, info), ACE_HANDLE, ACE_INVALID_HANDLE); #else ACE_UNUSED_ARG (path); ACE_UNUSED_ARG (oflag); ACE_UNUSED_ARG (info); ACE_NOTSUP_RETURN (ACE_INVALID_HANDLE); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_optmgmt (  ACE_HANDLE  handle, ACE_TOPTMGMT *  req, ACE_TOPTMGMT *  ret )

Definition at line 234 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_optmgmt(). Referenced by ACE_TLI::get_option(), ACE_ATM_Stream::get_vpi_vci(), and ACE_TLI::set_option(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_optmgmt (handle, req, ret), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (req); ACE_UNUSED_ARG (ret); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_rcv (  ACE_HANDLE  fildes, char *  buf, unsigned int  nbytes, int *  flags )

Definition at line 248 of file OS_TLI.inl. References ACE_NOTSUP_RETURN. Referenced by ACE::t_rcv(), and ACE::t_rcv_n_i(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_rcv (handle, buf, nbytes, flags), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (nbytes); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_rcvdis (  ACE_HANDLE  fildes, struct t_discon *  discon )

Definition at line 267 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_rcvdis(). Referenced by ACE_TLI::rcvdis(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_rcvdis (handle, discon), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (discon); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_rcvrel (  ACE_HANDLE  fildes  )

Definition at line 280 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_rcvrel(). Referenced by ACE_TLI::rcvrel(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_rcvrel (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_rcvudata (  ACE_HANDLE  fildes, struct t_unitdata *  unitdata, int *  flags )

Definition at line 292 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_rcvudata(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_rcvudata (handle, unitdata, flags), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (unitdata); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_rcvuderr (  ACE_HANDLE  fildes, struct t_uderr *  uderr )

Definition at line 309 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_rcvuderr(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_rcvuderr (handle, uderr), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (uderr); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_snd (  ACE_HANDLE  fildes, const char *  buf, unsigned int  nbytes, int  flags )

Definition at line 322 of file OS_TLI.inl. References ACE_NOTSUP_RETURN. Referenced by ACE::t_snd(), and ACE::t_snd_n_i(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_snd (handle, (char *) buf, nbytes, flags), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (buf); ACE_UNUSED_ARG (nbytes); ACE_UNUSED_ARG (flags); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_snddis (  ACE_HANDLE  fildes, struct t_call *  call )

Definition at line 340 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_snddis(). Referenced by open_new_endpoint(), and ACE_TLI::snddis(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_snddis (handle, call), int, -1); #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (call); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_sndrel (  ACE_HANDLE  fildes  )

Definition at line 353 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_sndrel(). Referenced by ACE_TLI::sndrel(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_sndrel (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_sync (  ACE_HANDLE  fildes  )

Definition at line 365 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_sync(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_sync (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE int ACE_OS::t_unbind (  ACE_HANDLE  fildes  )

Definition at line 377 of file OS_TLI.inl. References ACE_NOTSUP_RETURN, and t_unbind(). { #if defined (ACE_HAS_TLI) ACE_OSCALL_RETURN (::t_unbind (handle), int, -1); #else ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_TLI */ }

ACE_INLINE long ACE_OS::telldir (  ACE_DIR *   )

Definition at line 168 of file OS_NS_dirent.inl. References ACE_DIR, and ACE_NOTSUP_RETURN. Referenced by ACE_Dirent::tell(). { #if defined (ACE_HAS_DIRENT) && !defined (ACE_LACKS_TELLDIR) return ::telldir (d); #else /* ! ACE_HAS_DIRENT || ACE_LACKS_TELLDIR */ ACE_UNUSED_ARG (d); ACE_NOTSUP_RETURN (-1); #endif /* ! ACE_HAS_DIRENT || ACE_LACKS_TELLDIR */ }

ACE_INLINE wchar_t * ACE_OS::tempnam (  const wchar_t *  dir, const wchar_t *  pfx = 0 )

Definition at line 877 of file OS_NS_stdio.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, free(), malloc(), strcpy(), strlen(), and tempnam(). { ACE_OS_TRACE ("ACE_OS::tempnam"); #if defined (ACE_LACKS_TEMPNAM) ACE_UNUSED_ARG (dir); ACE_UNUSED_ARG (pfx); ACE_NOTSUP_RETURN (0); #elif defined(ACE_WIN32) # if defined (ACE_HAS_NONCONST_TEMPNAM) ACE_OSCALL_RETURN (::_wtempnam (const_cast <wchar_t*> (dir), const_cast <wchar_t*> (pfx)), wchar_t *, 0); # else ACE_OSCALL_RETURN (::_wtempnam (dir, pfx), wchar_t *, 0); # endif /* __BORLANDC__ */ #else /* ACE_LACKS_TEMPNAM */ // No native wide-char support; convert to narrow and call the char* variant. char *ndir = ACE_Wide_To_Ascii (dir).char_rep (); char *npfx = ACE_Wide_To_Ascii (pfx).char_rep (); char *name = ACE_OS::tempnam (ndir, npfx); // ACE_OS::tempnam returns a pointer to a malloc()-allocated space. // Convert that string to wide-char and free() the original. wchar_t *wname = 0; if (name != 0) { size_t namelen = ACE_OS::strlen (name) + 1; wname = reinterpret_cast<wchar_t *> (ACE_OS::malloc (namelen * sizeof (wchar_t))); if (wname != 0) ACE_OS::strcpy (wname, ACE_Ascii_To_Wide (name).wchar_rep ()); ACE_OS::free (name); } return wname; #endif /* ACE_LACKS_TEMPNAM */ }

ACE_INLINE char * ACE_OS::tempnam (  const char *  dir = 0, const char *  pfx = 0 )

Definition at line 861 of file OS_NS_stdio.inl. References ACE_NOTSUP_RETURN, and ACE_OS_TRACE. Referenced by tempnam(). { ACE_OS_TRACE ("ACE_OS::tempnam"); #if defined (ACE_LACKS_TEMPNAM) ACE_UNUSED_ARG (dir); ACE_UNUSED_ARG (pfx); ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_NONCONST_TEMPNAM) ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (const_cast <char *> (dir), const_cast<char *> (pfx)), char *, 0); #else /* ACE_LACKS_TEMPNAM */ ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::tempnam (dir, pfx), char *, 0); #endif /* ACE_LACKS_TEMPNAM */ }

ACE_INLINE int ACE_OS::thr_cancel (  ACE_thread_t  t_id  )

Definition at line 2599 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_NOTSUP_RETURN, and ACE_OS_TRACE. 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) # ifdef pthread_cancel // If it's a macro we can't say "pthread_cancel"... ACE_OSCALL_RETURN (pthread_cancel (thr_id), int, -1); # else ACE_OSCALL_RETURN (pthread_cancel (thr_id), int, -1); # endif /* pthread_cancel */ # else int result; # ifdef pthread_cancel // If it's a macro we can't say "pthread_cancel"... ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cancel (thr_id), result), int, -1); # else ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cancel (thr_id), result), int, -1); # endif /* pthread_cancel */ # endif /* ACE_HAS_PTHREADS_DRAFT4 || ACE_HAS_PTHREADS_DRAFT6 */ # elif defined (ACE_VXWORKS) ACE_hthread_t tid; ACE_OSCALL (::taskNameToId (thr_id), int, ERROR, tid); if (tid == ERROR) return -1; else ACE_OSCALL_RETURN (::taskDelete (tid), int, -1); # 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 )

Definition at line 2643 of file OS_NS_Thread.inl. 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  )

Definition at line 2660 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_FAIL_RETURN, ACE_hthread_t, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_continue (target_thread), result), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREAD_CONTINUE) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_continue (target_thread), result), int, -1); # elif defined (ACE_HAS_PTHREAD_CONTINUE_NP) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_continue_np (target_thread), result), int, -1); # elif defined (ACE_HAS_PTHREAD_RESUME_NP) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_resume_np (target_thread), 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_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 )

Definition at line 3837 of file OS_NS_Thread.cpp. References ACE_ADAPT_RETVAL, ACE_AUTO_PTR_RESET, ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_DEFAULT_THREAD_PRIORITY, ACE_FAIL_RETURN, ACE_hthread_t, ACE_MAX, ACE_MIN, ACE_NEW_RETURN, ACE_NOTSUP_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_ADAPTER_NAME, ACE_thread_t, ENOSYS, ENOTSUP, ACE_Base_Thread_Adapter::entry_point(), lwp_setparams(), memset(), ACE_Auto_Basic_Ptr< X >::release(), sched_params(), 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) */ # define ACE_THREAD_FUNCTION thread_args->entry_point () # define ACE_THREAD_ARGUMENT thread_args #endif /* ! defined (ACE_NO_THREAD_ADAPTER) */ ACE_Base_Thread_Adapter *thread_args = 0; 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_NAME, 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_NAME), -1); #endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ else thread_args = thread_adapter; auto_ptr <ACE_Base_Thread_Adapter> auto_thread_args; if (thread_adapter == 0) ACE_AUTO_PTR_RESET (auto_thread_args, thread_args, ACE_Base_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 (ACE_VXWORKS) && !defined (ACE_HAS_PTHREADS)) // On VxWorks, using the task API, 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 /* !(ACE_VXWORKS && !ACE_HAS_PTHREADS) */ ACE_hthread_t tmp_handle; if (thr_handle == 0) thr_handle = &tmp_handle; # if defined (ACE_HAS_PTHREADS) int result; # if defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600) && (ACE_VXWORKS <= 0x620) /* Tests show that VxWorks 6.x pthread lib does not only * require zeroing of mutex/condition objects to function correctly * but also of the attribute objects. */ pthread_attr_t attr = {0}; # else pthread_attr_t attr; # endif # if defined (ACE_HAS_PTHREADS_DRAFT4) if (ACE_ADAPT_RETVAL(::pthread_attr_create (&attr), result) != 0) # else /* ACE_HAS_PTHREADS_DRAFT4 */ if (ACE_ADAPT_RETVAL(::pthread_attr_init(&attr), result) != 0) # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return -1; if (stacksize != 0) { size_t size = stacksize; # if defined (PTHREAD_STACK_MIN) if (size < 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) int result; if (stack != 0) result = ACE_ADAPT_RETVAL (pthread_attr_setstack (&attr, stack, size), result); else result = ACE_ADAPT_RETVAL (pthread_attr_setstacksize (&attr, size), result); if (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 (ACE_ADAPT_RETVAL(::pthread_attr_setstackaddr (&attr, stack), 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; } } # 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) || defined (ACE_HAS_PTHREAD_SCHEDPARAM) // 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; # elif defined (ACE_HAS_ONLY_SCHED_FIFO) // NonStop OSS standard pthread supports only SCHED_FIFO. spolicy = SCHED_FIFO; # 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 */ (void) 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 */ (void) 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 (ACE_ADAPT_RETVAL(::pthread_attr_setinheritsched (&attr, sched), 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; } } # 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 (ACE_ADAPT_RETVAL(::pthread_attr_setscope (&attr, scope), 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_LACKS_THREAD_PROCESS_SCOPING */ # ifdef ACE_HAS_PTHREAD_ATTR_SETCREATESUSPEND_NP if (ACE_BIT_ENABLED (flags, THR_SUSPENDED)) { if (ACE_ADAPT_RETVAL(::pthread_attr_setcreatesuspend_np(&attr), 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_PTHREAD_ATTR_SETCREATESUSPEND_NP */ 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)) { ::pthread_detach (thr_id); } # 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 */ auto_thread_args.release (); 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! result = ACE_OS::thr_setprio (*thr_id, priority); if (result != 0) { errno = result; return -1; } if (start_suspended == 0) { result = ACE_OS::thr_continue (*thr_id); if (result != 0) { errno = result; return -1; } } } } auto_thread_args.release (); 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->thread_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, 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 && tmp_handle != 0) ::CloseHandle (tmp_handle); if (*thr_handle != 0) { auto_thread_args.release (); return 0; } else ACE_FAIL_RETURN (-1); /* NOTREACHED */ # elif defined (ACE_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, ::taskName (tid), 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 = ::taskName (tid); } // 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; auto_thread_args.release (); 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_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_OS::thr_equal (  ACE_thread_t  t1, ACE_thread_t  t2 )

Definition at line 107 of file OS_NS_Thread.inl. References strcmp(). Referenced by ACE_Thread_Manager::check_state(), ACE_Thread_Manager::find_thread(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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::thr_state(), 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 (ACE_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  )

Definition at line 4649 of file OS_NS_Thread.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 ()->thread_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 (ACE_VXWORKS) ACE_hthread_t tid; ACE_OS::thr_self (tid); *((int *) status) = ::taskDelete (tid); # endif /* ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (status); #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_get_affinity (  ACE_hthread_t  id, size_t  cpu_set_size, cpu_set_t *  cpu_mask )

Get the thread affinity Parameters: thr_id  For NPTL-threads, when ACE_HAS_PTHREAD_SETAFFINITY_NP defined, this is the thread-id. For linux-threads, when ACE_HAS_SCHED_SETAFFINITY defined, it expects a process-id. Since for linux-threads a thread is seen as a process, it does the job. cpu_set_size  The size of the cpu_mask cpu_mask  Is a bitmask of CPUs to bind to, e.g value 1 binds the thread to the "CPU 0", etc Definition at line 4799 of file OS_NS_Thread.cpp. References ACE_hthread_t, and ACE_NOTSUP_RETURN. { #if defined (ACE_HAS_PTHREAD_GETAFFINITY_NP) // Handle of the thread, which is NPTL thread-id, normally a big number if (::pthread_getaffinity_np (thr_id, cpu_set_size, cpu_mask) != 0) { return -1; } return 0; #elif defined (ACE_HAS_2_PARAM_SCHED_GETAFFINITY) // The process-id is expected as <thr_id>, which can be a thread-id of // linux-thread, thus making binding to cpu of that particular thread only. // If you are using this flag for NPTL-threads, however, please pass as a // thr_id process id obtained by ACE_OS::getpid () ACE_UNUSED_ARG (cpu_set_size); if (::sched_getaffinity(thr_id, cpu_mask) == -1) { return -1; } return 0; #elif defined (ACE_HAS_SCHED_GETAFFINITY) // The process-id is expected as <thr_id>, which can be a thread-id of // linux-thread, thus making binding to cpu of that particular thread only. // If you are using this flag for NPTL-threads, however, please pass as a // thr_id process id obtained by ACE_OS::getpid () if (::sched_getaffinity(thr_id, cpu_set_size, cpu_mask) == -1) { return -1; } return 0; #else ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (cpu_set_size); ACE_UNUSED_ARG (cpu_mask); ACE_NOTSUP_RETURN (-1); #endif }

ACE_INLINE int ACE_OS::thr_getconcurrency (  void   )

Definition at line 2703 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and 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 (ACE_HAS_PTHREAD_GETCONCURRENCY) return pthread_getconcurrency (); # else 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 )

Definition at line 2720 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_FAIL_RETURN, ACE_hthread_t, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_SCHED_FIFO, ACE_SCHED_OTHER, 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) || defined (ACE_HAS_PTHREAD_SCHEDPARAM))) # if defined (ACE_HAS_PTHREADS_DRAFT4) int const result = pthread_getprio (ht_id); if (result != -1) { priority = result; return 0; } else return -1; # elif defined (ACE_HAS_PTHREADS_DRAFT6) pthread_attr_t attr; if (pthread_getschedattr (ht_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 (ht_id, &policy, &param), result), int, -1, result); priority = param.sched_priority; return result; # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_getprio (ht_id, &priority), result), int, -1); # elif defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE) ACE_Errno_Guard error (errno); priority = ::GetThreadPriority (ht_id); DWORD priority_class = ::GetPriorityClass (::GetCurrentProcess ()); if (priority_class == 0 && (error = ::GetLastError ()) != NO_ERROR) ACE_FAIL_RETURN (-1); policy = (priority_class == REALTIME_PRIORITY_CLASS) ? ACE_SCHED_FIFO : ACE_SCHED_OTHER; return 0; # elif defined (ACE_VXWORKS) ACE_OSCALL_RETURN (::taskPriorityGet (ht_id, &priority), int, -1); # else ACE_UNUSED_ARG (ht_id); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (ht_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 )

Definition at line 2789 of file OS_NS_Thread.inl. 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 (ht_id, priority, policy); }

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

Definition at line 2843 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and ACE_thread_key_t. Referenced by ACE_TSS_Cleanup::find_tss_keys(), ACE_Thread::getspecific(), ACE_TSS_Cleanup::thread_release(), and ACE_TSS_Cleanup::tss_keys(). { // ACE_OS_TRACE ("ACE_OS::thr_getspecific"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_TSS_EMULATION) if (ACE_TSS_Emulation::is_key (key) == 0) { errno = EINVAL; data = 0; return -1; } else { *data = ACE_TSS_Emulation::ts_object (key); return 0; } # elif defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) return ACE_OS::thr_getspecific_native (key, data); #else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (data); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_TSS_EMULATION */ #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 )

Definition at line 2936 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, and thr_join(). { ACE_OS_TRACE ("ACE_OS::thr_join"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_join (waiter_id, thr_id, status), 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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_join (waiter_id, status), 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); # 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 )

Definition at line 2875 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_FAIL_RETURN, ACE_hthread_t, ACE_NOTSUP_RETURN, ACE_OS_TRACE, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_join (thr_handle, 0, status), 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) pthread_detach (&thr_handle); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ return ace_result; # else int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_join (thr_handle, status), 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 */ # 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 (  ACE_thread_key_t  key, void *  inst )

Note: the "inst" arg is deprecated. It will be ignored. Definition at line 4780 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, ACE_thread_key_t, and TSS_Cleanup_Instance::valid(). Referenced by ACE_TSS< TYPE >::~ACE_TSS(). { #if defined (ACE_HAS_WTHREADS) || defined (ACE_HAS_TSS_EMULATION) TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { return cleanup->thread_detach_key (key); } else { return -1; } #else ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_WTHREADS || ACE_HAS_TSS_EMULATION */ }

int ACE_OS::thr_key_used (  ACE_thread_key_t  key  )

Definition at line 4892 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, ACE_thread_key_t, and TSS_Cleanup_Instance::valid(). { #if defined (ACE_WIN32) || defined (ACE_HAS_TSS_EMULATION) TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { cleanup->thread_use_key (key); return 0; } return -1; #else ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); #endif /* ACE_WIN32 || ACE_HAS_TSS_EMULATION */ }

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

Note: the "inst" arge is deprecated. It will be ignored. Definition at line 4959 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, ACE_thread_key_t, and TSS_Cleanup_Instance::valid(). Referenced by ACE_Thread::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... TSS_Cleanup_Instance cleanup (TSS_Cleanup_Instance::CREATE); if (cleanup.valid ()) { return cleanup->insert (*key, dest); } else { return -1; } } else return -1; # elif defined (ACE_HAS_WTHREADS) if (ACE_OS::thr_keycreate_native (key, dest) == 0) { // Extract out the thread-specific table instance and stash away // the key and destructor so that we can free it up later on... TSS_Cleanup_Instance cleanup (TSS_Cleanup_Instance::CREATE); if (cleanup.valid ()) { return cleanup->insert (*key, dest); } else { return -1; } } else return -1; /* NOTREACHED */ # elif defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) return ACE_OS::thr_keycreate_native (key, dest); # else ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (dest); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_TSS_EMULATION */ # else /* ACE_HAS_THREADS */ ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (dest); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_keyfree (  ACE_thread_key_t  key  )

Definition at line 5050 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_thread_key_t, and TSS_Cleanup_Instance::valid(). Referenced by ACE_Thread::keyfree(), and ACE_TSS< TYPE >::~ACE_TSS(). { 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); TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { return cleanup->free_key (key); } return -1; # elif defined (ACE_HAS_WTHREADS) // Extract out the thread-specific table instance and free up // the key and destructor. TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { return cleanup->free_key (key); } return -1; # elif defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) return ACE_OS::thr_keyfree_native (key); # else ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_TSS_EMULATION */ # else /* ACE_HAS_THREADS */ ACE_UNUSED_ARG (key); ACE_NOTSUP_RETURN (-1); return 0; # endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thr_kill (  ACE_thread_t  thr_id, int  signum )

Definition at line 2980 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_NOTSUP_RETURN, ACE_OS_TRACE, 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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_kill (thr_id, signum), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_kill (thr_id, signum), result), int, -1); # elif defined (ACE_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 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   )

Definition at line 3022 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_NOTSUP_RETURN, ACE_OS_TRACE, sysconf(), and thr_self(). { 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... return ::thr_minstack (); # else return ::thr_min_stack (); # 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_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 &   )

Definition at line 3083 of file OS_NS_Thread.inl. 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_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   )

Definition at line 3063 of file OS_NS_Thread.inl. References thr_self(). Referenced by ACE_Thread_Control::ACE_Thread_Control(), ACE_Thread_ID::ACE_Thread_ID(), 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_min_stack(), thr_self(), thr_setprio(), ACE_Thread_Manager::thread_desc_self(), and ACE_Timeprobe_Ex< ACE_LOCK, ALLOCATOR >::timeprobe(). { // 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. return pthread_self (); # elif defined (ACE_HAS_STHREADS) ACE_OSCALL_RETURN (::thr_self (), int, -1); # elif defined (ACE_HAS_WTHREADS) return ::GetCurrentThreadId (); # elif defined (ACE_VXWORKS) return ::taskName (::taskIdSelf ()); # endif /* ACE_HAS_STHREADS */ #else return 1; // Might as well make it the first thread ;-) #endif /* ACE_HAS_THREADS */ }

int ACE_OS::thr_set_affinity (  ACE_hthread_t  thr_id, size_t  cpu_set_size, const cpu_set_t *  cpu_mask )

Set the thread affinity Parameters: thr_id  For NPTL-threads, when ACE_HAS_PTHREAD_SETAFFINITY_NP defined, this is the thread-id. For linux-threads, when ACE_HAS_SCHED_SETAFFINITY defined, it expects a process-id. Since for linux-threads a thread is seen as a process, it does the job. cpu_set_size  The size of the cpu_mask cpu_mask  Is a bitmask of CPUs to bind to, e.g value 1 binds the thread to the "CPU 0", etc Definition at line 4845 of file OS_NS_Thread.cpp. References ACE_hthread_t, and ACE_NOTSUP_RETURN. { #if defined (ACE_HAS_PTHREAD_SETAFFINITY_NP) if (::pthread_setaffinity_np (thr_id, cpu_set_size, cpu_mask) != 0) { return -1; } return 0; #elif defined (ACE_HAS_2_PARAM_SCHED_SETAFFINITY) // The process-id is expected as <thr_id>, which can be a thread-id of // linux-thread, thus making binding to cpu of that particular thread only. // If you are using this flag for NPTL-threads, however, please pass as a // thr_id process id obtained by ACE_OS::getpid (), but whole process will bind your CPUs // ACE_UNUSED_ARG (cpu_set_size); if (::sched_setaffinity (thr_id, cpu_mask) == -1) { return -1; } return 0; #elif defined (ACE_HAS_SCHED_SETAFFINITY) // The process-id is expected as <thr_id>, which can be a thread-id of // linux-thread, thus making binding to cpu of that particular thread only. // If you are using this flag for NPTL-threads, however, please pass as a // thr_id process id obtained by ACE_OS::getpid (), but whole process will bind your CPUs // if (::sched_setaffinity (thr_id, cpu_set_size, cpu_mask) == -1) { return -1; } return 0; #else ACE_UNUSED_ARG (thr_id); ACE_UNUSED_ARG (cpu_set_size); ACE_UNUSED_ARG (cpu_mask); ACE_NOTSUP_RETURN (-1); #endif }

ACE_INLINE int ACE_OS::thr_setcancelstate (  int  new_state, int *  old_state )

Definition at line 3105 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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 */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setcancelstate (new_state, old_state), 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 )

Definition at line 3148 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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 */ int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setcanceltype (new_type, old_type), 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  )

Definition at line 3183 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setconcurrency (hint), result), int, -1); # elif defined (ACE_HAS_PTHREADS) && defined (ACE_HAS_PTHREAD_SETCONCURRENCY) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setconcurrency (hint), result), int, -1); # else 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  )

Definition at line 5086 of file OS_NS_Thread.cpp. References ACE_hthread_t, ACE_SCHED_FIFO, ACE_SCHED_OTHER, ACE_Sched_Priority, ACE_SCHED_RR, lwp_getparams(), lwp_setparams(), 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  ht_id, int  priority, int  policy = -1 )

Definition at line 3208 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_hthread_t, ACE_NOTSUP_RETURN, ACE_OS_TRACE, 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) || defined (ACE_HAS_PTHREAD_SCHEDPARAM))) # if defined (ACE_HAS_PTHREADS_DRAFT4) int result; result = pthread_setprio (ht_id, priority); return (result == -1 ? -1 : 0); # elif defined (ACE_HAS_PTHREADS_DRAFT6) pthread_attr_t attr; if (pthread_getschedattr (ht_id, &attr) == -1) return -1; if (pthread_attr_setprio (attr, priority) == -1) return -1; return pthread_setschedattr (ht_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 (ht_id, &policy, &param), result), int, -1, result); if (result == -1) return result; } param.sched_priority = priority; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setschedparam (ht_id, policy, &param), result), int, -1); # endif /* ACE_HAS_PTHREADS_DRAFT4 */ # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setprio (ht_id, priority), result), int, -1); # elif defined (ACE_HAS_WTHREADS) ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetThreadPriority (ht_id, priority), ace_result_), int, -1); # elif defined (ACE_VXWORKS) ACE_OSCALL_RETURN (::taskPrioritySet (ht_id, priority), int, -1); # else // For example, platforms that support Pthreads but LACK_SETSCHED. ACE_UNUSED_ARG (ht_id); ACE_UNUSED_ARG (priority); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_STHREADS */ #else ACE_UNUSED_ARG (ht_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 )

Definition at line 5170 of file OS_NS_Thread.cpp. References ACE_NOTSUP_RETURN, ACE_thread_key_t, and TSS_Cleanup_Instance::valid(). Referenced by ACE_Thread::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) if (ACE_TSS_Emulation::is_key (key) == 0) { errno = EINVAL; data = 0; return -1; } else { ACE_TSS_Emulation::ts_object (key) = data; TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { cleanup->thread_use_key (key); // for TSS_Cleanup purposes treat stetting data to zero // like detaching. This is a consequence of POSIX allowing // deletion of a "used" key. if (data == 0) { cleanup->thread_detach_key (key); } return 0; } else { return -1; } } # elif defined (ACE_HAS_WTHREADS) if (ACE_OS::thr_setspecific_native (key, data) == 0) { TSS_Cleanup_Instance cleanup; if (cleanup.valid ()) { cleanup->thread_use_key (key); // for TSS_Cleanup purposes treat stetting data to zero // like detaching. This is a consequence of POSIX allowing // deletion of a "used" key. if (data == 0) { cleanup->thread_detach_key (key); } return 0; } return -1; } return -1; # elif defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) return ACE_OS::thr_setspecific_native (key, data); # else /* ACE_HAS_TSS_EMULATION */ ACE_UNUSED_ARG (key); ACE_UNUSED_ARG (data); ACE_NOTSUP_RETURN (-1); # endif /* ACE_HAS_TSS_EMULATION */ # else /* ACE_HAS_THREADS */ 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 )

Definition at line 3277 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sigthreadmask (how, nsm, osm), result), int, -1); # elif defined (ACE_HAS_STHREADS) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_sigsetmask (how, nsm, osm), 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsm, osm), 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 int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_sigaction (how, nsm, osm), result), int, -1); #endif /* 0 */ # elif defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (osm); ACE_UNUSED_ARG (nsm); ACE_UNUSED_ARG (how); ACE_NOTSUP_RETURN (-1); # elif defined (ACE_VXWORKS) int old_mask = 0; switch (how) { case SIG_BLOCK: case SIG_UNBLOCK: { // get the old mask old_mask = ::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 ? (old_mask |= *nsm) : (old_mask &= ~*nsm)); if (osm) *osm = old_mask; break; } case SIG_SETMASK: old_mask = ::sigsetmask (*nsm); if (osm) *osm = old_mask; 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  )

Definition at line 3369 of file OS_NS_Thread.inl. References ACE_ADAPT_RETVAL, ACE_FAIL_RETURN, ACE_hthread_t, ACE_NOTSUP_RETURN, 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) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_suspend (target_thread), result), int, -1); # elif defined (ACE_HAS_PTHREADS) # if defined (ACE_HAS_PTHREAD_SUSPEND) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_suspend (target_thread), result), int, -1); # elif defined (ACE_HAS_PTHREAD_SUSPEND_NP) int result; ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_suspend_np (target_thread), 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_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   )

Definition at line 3407 of file OS_NS_Thread.inl. 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 (ACE_VXWORKS) # 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   )

Definition at line 3428 of file OS_NS_Thread.inl. References ACE_OS_TRACE. Referenced by event_destroy(), event_pulse(), ACE_Condition_Thread_Mutex::remove(), ACE_Condition< MUTEX >::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 (ACE_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  )

Definition at line 3458 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and mutex_destroy(). Referenced by mutex_destroy(), recursive_mutex_destroy(), ACE_Thread_Mutex::remove(), 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) || defined (ACE_VXWORKS) return ACE_OS::mutex_destroy (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_init (  ACE_thread_mutex_t *  m, int  lock_type, const wchar_t *  name, ACE_mutexattr_t *  arg = 0 )

Definition at line 3513 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and mutex_init(). { // ACE_OS_TRACE ("ACE_OS::thread_mutex_init"); #if defined (ACE_HAS_THREADS) # if defined (ACE_HAS_WTHREADS) ACE_UNUSED_ARG (lock_type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ::InitializeCriticalSection (m); return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) // Force the use of USYNC_THREAD! return ACE_OS::mutex_init (m, USYNC_THREAD, name, arg, 0, lock_type); # elif defined (ACE_VXWORKS) return mutex_init (m, lock_type, name, arg); # endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (lock_type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_THREADS */ }

ACE_INLINE int ACE_OS::thread_mutex_init (  ACE_thread_mutex_t *  m, int  lock_type = 0, const char *  name = 0, ACE_mutexattr_t *  arg = 0 )

Definition at line 3479 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and mutex_init(). Referenced by ACE_Thread_Mutex::ACE_Thread_Mutex(), 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 (lock_type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); ::InitializeCriticalSection (m); return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) // Force the use of USYNC_THREAD! return ACE_OS::mutex_init (m, USYNC_THREAD, name, arg, 0, lock_type); # elif defined (ACE_VXWORKS) return mutex_init (m, lock_type, name, arg); # endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS */ #else ACE_UNUSED_ARG (m); ACE_UNUSED_ARG (lock_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 )

Definition at line 3590 of file OS_NS_Thread.inl. 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 )

Definition at line 3565 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and 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) || defined (ACE_VXWORKS) return ACE_OS::mutex_lock (m, timeout); #endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS || VXWORKS */ #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  )

Definition at line 3548 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, and mutex_lock(). Referenced by ACE_Thread_Mutex::acquire(), ACE_Thread_Mutex::acquire_read(), ACE_Thread_Mutex::acquire_write(), 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) || defined (ACE_VXWORKS) return ACE_OS::mutex_lock (m); # endif /* ACE_HAS_STHREADS || ACE_HAS_PTHREADS || VXWORKS */ #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  )

Definition at line 3599 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, EBUSY, and mutex_trylock(). Referenced by mutex_trylock(), recursive_mutex_trylock(), ACE_Thread_Mutex::tryacquire(), ACE_Thread_Mutex::tryacquire_read(), and ACE_Thread_Mutex::tryacquire_write(). { 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) || defined (ACE_VXWORKS) 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  )

Definition at line 3629 of file OS_NS_Thread.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and mutex_unlock(). Referenced by ACE_Log_Msg::close(), ACE_Log_Msg::instance(), mutex_unlock(), recursive_mutex_cond_relock(), recursive_mutex_cond_unlock(), recursive_mutex_lock(), recursive_mutex_trylock(), recursive_mutex_unlock(), ACE_Thread_Mutex::release(), 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) || defined (ACE_VXWORKS) 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  )

Definition at line 434 of file OS_NS_time.inl. 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(). { ACE_OS_TRACE ("ACE_OS::time"); #if !defined (ACE_HAS_WINCE) ACE_OSCALL_RETURN (::time (tloc), time_t, (time_t) -1); #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   )

Definition at line 458 of file OS_NS_time.inl. References ace_timezone(). { return ::ace_timezone (); }

ACE_INLINE int ACE_OS::truncate (  const ACE_TCHAR *  filename, ACE_LOFF_T  length )

Definition at line 981 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_DEFAULT_FILE_PERMS, ACE_FAIL_RETURN, ACE_LOFF_T, ACE_NOTSUP_RETURN, ACE_OS_TRACE, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, and open(). { ACE_OS_TRACE ("ACE_OS::truncate"); #if defined (ACE_WIN32) ACE_HANDLE handle = ACE_OS::open (filename, O_WRONLY, ACE_DEFAULT_FILE_PERMS); LARGE_INTEGER loffset; loffset.QuadPart = offset; if (handle == ACE_INVALID_HANDLE) ACE_FAIL_RETURN (-1); # if !defined (ACE_LACKS_SETFILEPOINTEREX) else if (::SetFilePointerEx (handle, loffset, 0, FILE_BEGIN) != (unsigned) -1) # else else if (::SetFilePointer (handle, offset, 0, FILE_BEGIN) != (unsigned) -1) # endif { 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 (ACE_TEXT_ALWAYS_CHAR (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   )

Definition at line 465 of file OS_NS_time.inl. References ENOTSUP. { #if !defined (ACE_HAS_WINCE) && !defined (ACE_VXWORKS) && !defined(__rtems__) && !defined (ACE_HAS_DINKUM_STL) # if defined (ACE_WIN32) ::_tzset (); // For Win32. # else ::tzset (); // For UNIX platforms. # endif /* ACE_WIN32 */ # else errno = ENOTSUP; # endif /* ACE_HAS_WINCE && !VXWORKS && !__rtems__ && !ACE_HAS_DINKUM_STL */ }

ACE_INLINE u_long ACE_OS::ualarm (  const ACE_Time_Value &  tv, const ACE_Time_Value &  tv_interval = ACE_Time_Value::zero )

Definition at line 1044 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, 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_long usecs = (tv.sec () * ACE_ONE_SECOND_IN_USECS) + tv.usec (); u_long 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_long ACE_OS::ualarm (  u_long  usecs, u_long  interval = 0 )

Definition at line 1027 of file OS_NS_unistd.inl. References ACE_NOTSUP_RETURN, ACE_ONE_SECOND_IN_USECS, and ACE_OS_TRACE. Referenced by ACE_Async_Timer_Queue_Adapter< TQ >::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 */ }

ACE_INLINE mode_t ACE_OS::umask (  mode_t  cmask  )

Definition at line 296 of file OS_NS_sys_stat.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and mode_t. Referenced by ACE::daemonize(). { ACE_OS_TRACE ("ACE_OS::umask"); # if defined (ACE_LACKS_UMASK) ACE_UNUSED_ARG (cmask); ACE_NOTSUP_RETURN ((mode_t)-1); # elif defined (ACE_WIN32) && !defined (__BORLANDC__) ACE_OSCALL_RETURN (::_umask (cmask), mode_t, -1); # else return ::umask (cmask); // This call shouldn't fail... # endif /* ACE_LACKS_UMASK */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::uname (  ACE_utsname *  name  )

Definition at line 19 of file OS_NS_sys_utsname.cpp. References ACE_LIB_TEXT, ACE_OS_TRACE, ACE_TCHAR, hostname(), sprintf(), strcat(), strcpy(), and uname(). Referenced by sema_init(), and uname(). { ACE_OS_TRACE ("ACE_OS::uname"); #if !defined (ACE_LACKS_UNAME) ACE_OSCALL_RETURN (::uname (name), int, -1); #elif 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 = 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 # if defined (VER_PLATFORM_WIN32_CE) || vinfo.dwPlatformId == VER_PLATFORM_WIN32_CE # endif ) { // Get information from the two structures const ACE_TCHAR *os; if (vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT) os = ACE_LIB_TEXT ("Windows NT %d.%d"); else os = ACE_LIB_TEXT ("Windows CE %d.%d"); ACE_OS::sprintf (name->release, os, (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::strcpy (processor, ACE_LIB_TEXT ("Itanium")); ACE_OS::sprintf (subtype, ACE_LIB_TEXT ("%d"), sinfo.wProcessorLevel); break; # endif # if defined PROCESSOR_ARCHITECTURE_AMD64 case PROCESSOR_ARCHITECTURE_AMD64: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("x64")); ACE_OS::sprintf (subtype, ACE_LIB_TEXT ("%d"), sinfo.wProcessorLevel); break; # endif # if defined PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("WOW64")); ACE_OS::sprintf (subtype, ACE_LIB_TEXT ("%d"), sinfo.wProcessorLevel); break; # endif # if defined PROCESSOR_ARCHITECTURE_ARM case PROCESSOR_ARCHITECTURE_ARM: ACE_OS::strcpy (processor, ACE_LIB_TEXT ("ARM")); 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 (ACE_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 (INTEGRITY) if(!name) { errno = EFAULT; return -1; } strcpy(name->sysname,"INTEGRITY"); int status = gethostname(name->nodename,_SYS_NMLN); strcpy(name->release,"4.0"); strcpy(name->version,"4.0.9"); strcpy(name->machine,"a standard name"); return status; #endif /* ACE_WIN32 */ }

ACE_NAMESPACE_INLINE_FUNCTION wint_t ungetwc (  wint_t  c, FILE *  fp )

void ACE_OS::unique_name (  const void *  object, char *  name, size_t  length )

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 will provide uniqueness between other "live" objects in the same process. The uniqueness of this name is therefore only valid for the life of . Definition at line 5236 of file OS_NS_Thread.cpp. References ACE_UNIQUE_NAME_LEN, sprintf(), and strsncpy(). Referenced by ACE_MEM_Acceptor::accept(), sema_init(), ACE_DLL::set_handle(), 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>. char temp_name[ACE_UNIQUE_NAME_LEN]; ACE_OS::sprintf (temp_name, "%p%d", object, static_cast <int> (ACE_OS::getpid ())); ACE_OS::strsncpy (name, temp_name, length); }

ACE_INLINE int ACE_OS::unlink (  const wchar_t *  path  )

Definition at line 1083 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_OS_TRACE, and unlink(). { ACE_OS_TRACE ("ACE_OS::unlink"); # if defined (ACE_HAS_WINCE) // @@ The problem is, DeleteFile is not actually equals to unlink. ;( ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFileW (path), ace_result_), int, -1); # elif defined (ACE_WIN32) ACE_OSCALL_RETURN (::_wunlink (path), int, -1); # else ACE_Wide_To_Ascii npath (path); return ACE_OS::unlink (npath.char_rep ()); # endif /* ACE_HAS_WINCE */ }

ACE_INLINE int ACE_OS::unlink (  const char *  path  )

Definition at line 1064 of file OS_NS_unistd.inl. References ACE_ADAPT_RETVAL, ACE_NOTSUP_RETURN, ACE_OS_TRACE, and ACE_TEXT_CHAR_TO_TCHAR. Referenced by ACE_MEM_Acceptor::accept(), flock_destroy(), ACE_Logging_Strategy::handle_timeout(), ACE::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(), sema_destroy(), sema_init(), shm_unlink(), unlink(), and ACE_FILE::unlink(). { ACE_OS_TRACE ("ACE_OS::unlink"); # if defined (ACE_HAS_NONCONST_UNLINK) ACE_OSCALL_RETURN (::unlink (const_cast<char *> (path)), int, -1); # elif defined (ACE_HAS_WINCE) // @@ The problem is, DeleteFile is not actually equals to unlink. ;( ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::DeleteFile (ACE_TEXT_CHAR_TO_TCHAR (path)), ace_result_), int, -1); # elif defined (ACE_LACKS_UNLINK) ACE_UNUSED_ARG (path); ACE_NOTSUP_RETURN (-1); # else ACE_OSCALL_RETURN (::unlink (path), int, -1); # endif /* ACE_HAS_NONCONST_UNLINK */ }

ACE_INLINE int ACE_OS::vsnprintf (  wchar_t *  buffer, size_t  maxlen, const wchar_t *  format, va_list  argptr )

Definition at line 985 of file OS_NS_stdio.inl. References ACE_NOTSUP_RETURN, and ACE_SPRINTF_ADAPTER. { # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || \ (defined (sun) && !(defined(_XOPEN_SOURCE) && (_XOPEN_VERSION-0==4))) || \ (defined (ACE_HAS_DINKUM_STL) || defined (__DMC__)) return vswprintf (buffer, maxlen, format, ap); # elif defined (ACE_WIN32) int result = ACE_SPRINTF_ADAPTER (::_vsnwprintf (buffer, maxlen, format, ap)); // Win32 doesn't regard a full buffer with no 0-terminate as an // overrun. if (result == static_cast<int> (maxlen)) result = -1; // Win32 doesn't 0-terminate the string if it overruns maxlen. if (result == -1) buffer[maxlen-1] = '\0'; return result; # else ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (maxlen); ACE_UNUSED_ARG (format); ACE_UNUSED_ARG (ap); ACE_NOTSUP_RETURN (-1); # endif /* platforms with a variant of vswprintf */ }

ACE_INLINE int ACE_OS::vsnprintf (  char *  buffer, size_t  maxlen, const char *  format, va_list  argptr )

Definition at line 919 of file OS_NS_stdio.inl. References ACE_NOTSUP_RETURN, ACE_SPRINTF_ADAPTER, and vsnprintf(). Referenced by ACE_Process_Options::command_line(), snprintf(), and vsnprintf(). { #if defined (ACE_HAS_SNPRINTF) # if !defined (ACE_WIN32) \ || (defined (__BORLANDC__) && (__BORLANDC__ >= 0x600)) return ACE_SPRINTF_ADAPTER (::vsnprintf (buffer, maxlen, format, ap)); # else int result = ACE_SPRINTF_ADAPTER (::_vsnprintf (buffer, maxlen, format, ap)); // Win32 doesn't regard a full buffer with no 0-terminate as an // overrun. if (result == static_cast<int> (maxlen)) result = -1; // Win32 doesn't 0-terminate the string if it overruns maxlen. if (result == -1) buffer[maxlen-1] = '\0'; return result; # endif #else ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (maxlen); ACE_UNUSED_ARG (format); ACE_UNUSED_ARG (ap); ACE_NOTSUP_RETURN (-1); #endif /* ACE_HAS_SNPRINTF */ }

ACE_INLINE int ACE_OS::vsprintf (  wchar_t *  buffer, const wchar_t *  format, va_list  argptr )

Definition at line 954 of file OS_NS_stdio.inl. References ACE_NOTSUP_RETURN. { # if (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500) || \ (defined (sun) && !(defined(_XOPEN_SOURCE) && (_XOPEN_VERSION-0==4))) || \ (defined (ACE_HAS_DINKUM_STL) || defined (__DMC__)) // The XPG4/UNIX98/C99 signature of the wide-char sprintf has a // maxlen argument. Since this method doesn't supply one, pass in // a length that works (ULONG_MAX doesn't on all platform since some check // to see if the operation will remain in bounds). If this isn't ok, use // ACE_OS::snprintf(). return vswprintf (buffer, 4096, format, argptr); # 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. return vswprintf (buffer, format, argptr); # else ACE_UNUSED_ARG (buffer); ACE_UNUSED_ARG (format); ACE_UNUSED_ARG (argptr); ACE_NOTSUP_RETURN (-1); # endif /* XPG5 || ACE_HAS_DINKUM_STL */ }

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

Definition at line 913 of file OS_NS_stdio.inl. 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 (  pid_t  pid, ACE_exitcode *  status, int  wait_options = 0, ACE_HANDLE  handle = 0 )

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 97 of file OS_NS_sys_wait.inl. References ACE_exitcode, ACE_OS_TRACE, pid_t, and waitpid(). { ACE_OS_TRACE ("ACE_OS::wait"); return ACE_OS::waitpid (pid, status, wait_options, handle); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE pid_t ACE_OS::wait (  int *  = 0  )

Calls OS wait function, so it's only portable to UNIX/POSIX platforms. Definition at line 11 of file OS_NS_sys_wait.inl. References ACE_NOTSUP_RETURN, ACE_OS_TRACE, and pid_t. Referenced by ACE_Process::wait(). { ACE_OS_TRACE ("ACE_OS::wait"); #if defined (ACE_LACKS_WAIT) 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_LACKS_WAIT */ }

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

Calls waitpid on UNIX/POSIX platforms Does not work on Vxworks 5.5.x. 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 27 of file OS_NS_sys_wait.inl. References ACE_BIT_ENABLED, ACE_exitcode, ACE_NOTSUP_RETURN, 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 (ACE_LACKS_WAITPID) 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(ACE_TANDEM_T1248_PTHREADS) ACE_UNUSED_ARG (handle); ACE_OSCALL_RETURN (::spt_waitpid (pid, status, wait_options), pid_t, -1); #else ACE_UNUSED_ARG (handle); ACE_OSCALL_RETURN (::waitpid (pid, status, wait_options), pid_t, -1); #endif /* ACE_LACKS_WAITPID */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL wchar_t * ACE_OS::wcscat_emulation (  wchar_t *  destination, const wchar_t *  source )

Emulated wcscat - Appends a string. Definition at line 57 of file OS_NS_wchar.cpp. Referenced by strcat(). { wchar_t *save = destination; for (; *destination; ++destination); while ((*destination++ = *source++)); return save; }

wchar_t * ACE_OS::wcschr_emulation (  const wchar_t *  string, wint_t  c )

Emulated wcschr - Finds a character in a string. Definition at line 70 of file OS_NS_wchar.cpp. Referenced by strchr(). { for (;*string ; ++string) if (*string == static_cast<wchar_t> (c)) return const_cast<wchar_t *> (string); return 0; }

int ACE_OS::wcscmp_emulation (  const ACE_WCHAR_T *  string1, const ACE_WCHAR_T *  string2 )

Emulated wcscmp - Compares strings. Definition at line 82 of file OS_NS_wchar.cpp. Referenced by strcmp(). { while (*string1 == *string2++) if (*string1++ == 0) return (0); return (*string1 - *--string2); }

wchar_t * ACE_OS::wcscpy_emulation (  wchar_t *  destination, const wchar_t *  source )

Emulated wcscpy - Copies a string. Definition at line 94 of file OS_NS_wchar.cpp. Referenced by strcpy(). { wchar_t *save = destination; for (; (*destination = *source); ++source, ++destination); return save; }

size_t ACE_OS::wcscspn_emulation (  const wchar_t *  string, const wchar_t *  reject )

Emulated wcscspn. Definition at line 106 of file OS_NS_wchar.cpp. Referenced by strcspn(). { const wchar_t *scan; const wchar_t *rej_scan; int count = 0; for (scan = s; *scan; scan++) { for (rej_scan = reject; *rej_scan; rej_scan++) if (*scan == *rej_scan) return count; count++; } return count; }

int ACE_OS::wcsicmp_emulation (  const wchar_t *  string1, const wchar_t *  string2 )

Emulated wcsicmp - Performs a case insensitive comparison of strings. Definition at line 128 of file OS_NS_wchar.cpp. References ace_tolower(), and ace_towlower(). { const wchar_t *scan1 = s; const wchar_t *scan2 = t; while (*scan1 != 0 && ACE_OS::ace_towlower (*scan1) == ACE_OS::ace_towlower (*scan2)) { ++scan1; ++scan2; } // The following case analysis is necessary so that characters which // look negative collate low against normal characters but high // against the end-of-string NUL. if (*scan1 == '\0' && *scan2 == '\0') return 0; else if (*scan1 == '\0') return -1; else if (*scan2 == '\0') return 1; else return ACE_OS::ace_tolower (*scan1) - ACE_OS::ace_towlower (*scan2); }

size_t ACE_OS::wcslen_emulation (  const ACE_WCHAR_T *  string  )

Emulated wcslen - Returns the length of a string. Definition at line 158 of file OS_NS_wchar.cpp. References ACE_WCHAR_T. Referenced by strlen(). { const ACE_WCHAR_T *s; for (s = string; *s; ++s) continue; return s - string; }

ACE_WCHAR_T * ACE_OS::wcsncat_emulation (  ACE_WCHAR_T *  destination, const ACE_WCHAR_T *  source, size_t  count )

Emulated wcscat - Appends a string. Definition at line 171 of file OS_NS_wchar.cpp. References ACE_WCHAR_T. Referenced by strncat(). { if (count != 0) { ACE_WCHAR_T *d = destination; const ACE_WCHAR_T *s = source; while (*d != 0) d++; do { if ((*d = *s++) == 0) break; d++; } while (--count != 0); *d = 0; } return destination; }

int ACE_OS::wcsncmp_emulation (  const ACE_WCHAR_T *  string1, const ACE_WCHAR_T *  string2, size_t  len )

Emulated wcsncmp - Compares two arrays. Definition at line 200 of file OS_NS_wchar.cpp. Referenced by strncmp(). { if (len == 0) return 0; do { if (*s1 != *s2++) return (*s1 - *--s2); if (*s1++ == 0) break; } while (--len != 0); return 0; }

ACE_WCHAR_T * ACE_OS::wcsncpy_emulation (  ACE_WCHAR_T *  destination, const ACE_WCHAR_T *  source, size_t  len )

Emulated wcsncpy - Copies an array. Definition at line 221 of file OS_NS_wchar.cpp. References ACE_WCHAR_T. Referenced by strncpy(). { if (len != 0) { ACE_WCHAR_T *d = destination; const ACE_WCHAR_T *s = source; do { if ((*d++ = *s++) == 0) { // NUL pad the remaining n-1 bytes while (--len != 0) *d++ = 0; break; } } while (--len != 0); } return destination; }

int ACE_OS::wcsnicmp_emulation (  const wchar_t *  string1, const wchar_t *  string2, size_t  len )

Emulated wcsnicmp - Performs a case insensitive comparison of two arrays Definition at line 248 of file OS_NS_wchar.cpp. References ace_towlower(). { const wchar_t *scan1 = s; const wchar_t *scan2 = t; size_t count = 0; while (count++ < len && *scan1 != 0 && ACE_OS::ace_towlower (*scan1) == ACE_OS::ace_towlower (*scan2)) { ++scan1; ++scan2; } if (count > len) return 0; // The following case analysis is necessary so that characters which // look negative collate low against normal characters but high // against the end-of-string NUL. if (*scan1 == '\0' && *scan2 == '\0') return 0; else if (*scan1 == '\0') return -1; else if (*scan2 == '\0') return 1; else return ACE_OS::ace_towlower (*scan1) - ACE_OS::ace_towlower (*scan2); }

wchar_t * ACE_OS::wcspbrk_emulation (  const wchar_t *  string, const wchar_t *  charset )

Emulated wcspbrk - Searches for characters in a string. Definition at line 285 of file OS_NS_wchar.cpp. Referenced by strpbrk(). { const wchar_t *scanp; int c, sc; while ((c = *string++) != 0) { for (scanp = charset; (sc = *scanp++) != 0;) if (sc == c) return const_cast<wchar_t *> (string - 1); } return 0; }

const wchar_t * ACE_OS::wcsrchr_emulation (  const wchar_t *  string, wint_t  c )

Emulated wcsrchr (const wchar_t version) - Finds the last occurance of a character in a string. Definition at line 304 of file OS_NS_wchar.cpp. References strlen(). { const wchar_t *p = s + ACE_OS::strlen (s); while (*p != static_cast<wchar_t> (c)) if (p == s) return 0; else p--; return p; }

wchar_t * ACE_OS::wcsrchr_emulation (  wchar_t *  string, wint_t  c )

Emulated wcsrchr (wchar_t version) - Finds the last occurance of a character in a string. Definition at line 318 of file OS_NS_wchar.cpp. References strlen(). Referenced by strrchr(). { wchar_t *p = s + ACE_OS::strlen (s); while (*p != static_cast<wchar_t> (c)) if (p == s) return 0; else p--; return p; }

size_t ACE_OS::wcsspn_emulation (  const wchar_t *  string, const wchar_t *  charset )

Emulated wcsspn. Definition at line 334 of file OS_NS_wchar.cpp. Referenced by strspn(). { const wchar_t *p = string; const wchar_t *spanp; wchar_t c, sc; // Skip any characters in charset, excluding the terminating \0. cont: c = *p++; for (spanp = charset; (sc = *spanp++) != 0;) if (sc == c) goto cont; return (p - 1 - string); }

wchar_t * ACE_OS::wcsstr_emulation (  const wchar_t *  string, const wchar_t *  charset )

Emulated wcsstr - Performs a case insensitive comparison of two strings. Definition at line 353 of file OS_NS_wchar.cpp. References strlen(), and strncmp(). Referenced by strstr(). { wchar_t c, sc; size_t len; if ((c = *charset++) != 0) { len = ACE_OS::strlen (charset); do { do { if ((sc = *string++) == 0) return 0; } while (sc != c); } while (ACE_OS::strncmp (string, charset, len) != 0); string--; } return const_cast<wchar_t *> (string); }

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

Definition at line 1123 of file OS_NS_unistd.inl. References ACE_FAIL_RETURN, ACE_OS_TRACE, ACE_OVERLAPPED, ssize_t, 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 = static_cast<DWORD> (nbyte); if (::WriteFile (handle, buf, short_nbyte, &bytes_written, overlapped)) return (ssize_t) bytes_written; else ACE_FAIL_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 )

Definition at line 1100 of file OS_NS_unistd.inl. References ACE_FAIL_RETURN, ACE_OS_TRACE, and ssize_t. 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(), sema_init(), sema_post(), ACE_SPIPE_Stream::send(), ACE_SOCK_IO::send(), ACE_Pipe::send(), ACE_FILE_IO::send(), ACE_FIFO_Send::send(), ACE_DEV_IO::send(), ACE::send_i(), sendfile_emulation(), 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 = static_cast<DWORD> (nbyte); if (::WriteFile (handle, buf, short_nbyte, &bytes_written, 0)) return (ssize_t) bytes_written; else ACE_FAIL_RETURN (-1); #else # if defined (ACE_HAS_CHARPTR_SOCKOPT) ACE_OSCALL_RETURN (::write (handle, static_cast <char *> (const_cast <void *> (buf)), nbyte), ssize_t, -1); # else ACE_OSCALL_RETURN (::write (handle, buf, nbyte), ssize_t, -1); # endif /* ACE_HAS_CHARPTR_SOCKOPT */ #endif /* ACE_WIN32 */ }

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

Send bytes from to (uses the <ACE_OS::write> calls, which is uses the system call on UNIX and the 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 . Definition at line 752 of file OS_NS_unistd.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 )

Definition at line 33 of file OS_NS_sys_uio.inl. References ACE_OS_TRACE, and ssize_t. Referenced by ACE_SPIPE_Stream::send(), ACE_Pipe::send(), ACE_FILE_IO::send(), ACE_FIFO_Send_Msg::send(), ACE_DEV_IO::send(), ACE_SPIPE_Stream::sendv(), ACE_Pipe::sendv(), sendv(), ACE_FILE_IO::sendv(), and ACE::writev_n(). { ACE_OS_TRACE ("ACE_OS::writev"); #if defined (ACE_LACKS_WRITEV) ACE_OSCALL_RETURN (ACE_OS::writev_emulation (handle, iov, iovcnt), ssize_t, -1); #else /* ACE_LACKS_WRITEV */ #if defined (ACE_HAS_NONCONST_WRITEV) ACE_OSCALL_RETURN (::writev (handle, const_cast<iovec *>(iov), iovcnt), ssize_t, -1); #else ACE_OSCALL_RETURN (::writev (handle, iov, iovcnt), ssize_t, -1); #endif /* ACE_HAS_NONCONST_WRITEV */ #endif /* ACE_LACKS_WRITEV */ }

ACE_INLINE int ACE_OS::wscmp (  const WChar *  , const WChar *  )

Definition at line 43 of file OS_NS_wchar.inl. { 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 *  )

Definition at line 32 of file OS_NS_wchar.inl. { WChar *original_dest = dest; while ((*dest++ = *src++) != 0) continue; return original_dest; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE u_int ACE_OS::wslen (  const WChar *   )

Definition at line 21 of file OS_NS_wchar.inl. Referenced by ACE_Log_Msg::log(). { u_int len = 0; while (*s++ != 0) len++; return len; }

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

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

---

Variable Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_EXIT_HOOK ACE_OS::exit_hook_ = 0

Function that is called by <ACE_OS::exit>, if non-null. Definition at line 35 of file OS_NS_stdlib.cpp. Referenced by exit(), and set_exit_hook().

ACE_hthread_t ACE_OS::NULL_hthread

This is necessary to deal with POSIX pthreads and their use of structures for thread handles. Definition at line 1142 of file OS_NS_Thread.cpp.

ACE_thread_key_t ACE_OS::NULL_key

This is necessary to deal with POSIX pthreads and their use of structures for TSS keys. Definition at line 1146 of file OS_NS_Thread.cpp.

ACE_thread_t ACE_OS::NULL_thread

This is necessary to deal with POSIX pthreads and their use of structures for thread ids. Definition at line 1141 of file OS_NS_Thread.cpp.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_OS::socket_initialized_

Keeps track of whether we've already initialized WinSock... Definition at line 14 of file OS_NS_sys_socket.cpp.

HINSTANCE ACE_OS::win32_resource_module_

Definition at line 19 of file OS_NS_stdio.cpp.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL OSVERSIONINFO ACE_OS::win32_versioninfo_

Definition at line 18 of file OS_NS_stdio.cpp.

---