ACE Namespace Reference

The namespace containing the ACE framework itself. More...

Classes
struct	If_Then_Else< true, Ta, Tb >
struct	If_Then_Else< false, Ta, Tb >
struct	VP_traits
	Value_Ptr traits template structure. More...
class	Value_Ptr
	Smart pointer implementation designed for use as a class member. More...
struct	If_Then_Else
	Compile-time selection of type based on a boolean value. More...
I/O operations
Notes on common parameters: handle is the connected endpoint that will be used for I/O. buf is the buffer to write from or receive into. len is the number of bytes to transfer. The timeout parameter in the following methods indicates how long to blocking trying to transfer data. If timeout == 0, then the call behaves as a normal send/recv call, i.e., for blocking sockets, the call will block until action is possible; for non-blocking sockets, EWOULDBLOCK will be returned if no action is immediately possible. If timeout != 0, the call will wait until the relative time specified in *timeout elapses. The "_n()" I/O methods keep looping until all the data has been transferred. These methods also work for sockets in non-blocking mode i.e., they keep looping on EWOULDBLOCK. timeout is used to make sure we keep making progress, i.e., the same timeout value is used for every I/O operation in the loop and the timeout is not counted down. The return values for the "*_n()" methods match the return values from the non "_n()" methods and are specified as follows: On complete transfer, the number of bytes transferred is returned. On timeout, -1 is returned, errno == ETIME. On error, -1 is returned, errno is set to appropriate error. On EOF, 0 is returned, errno is irrelevant. On partial transfers, i.e., if any data is transferred before timeout / error / EOF, bytes_transferred> will contain the number of bytes transferred. Methods with iovec parameter are I/O vector variants of the I/O operations. Methods with the extra flags argument will always result in send getting called. Methods without the extra flags argument will result in send getting called on Win32 platforms, and write getting called on non-Win32 platforms.
ACE_Export ssize_t	recv (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	t_rcv (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	recv (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	recvfrom (ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recv_n (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	t_rcv_n (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recv_n (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t	recv (ACE_HANDLE handle, size_t n,...)
	Receive into a variable number of pieces.
ACE_Export ssize_t	recvv (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recvv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t	recv_n (ACE_HANDLE handle, ACE_Message_Block *message_block, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t	send (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	t_snd (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	send (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t	sendto (ACE_HANDLE handle, const char *buf, int len, int flags, const struct sockaddr *addr, int addrlen, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	send_n (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	t_snd_n (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	send_n (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t	send (ACE_HANDLE handle, size_t n,...)
	Varargs variant.
ACE_Export ssize_t	sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	sendv_n (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t	send_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	read_n (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	write_n (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred=0)
ACE_Export ssize_t	write_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, size_t *bytes_transferred=0)
ACE_Export ssize_t	readv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bytes_transferred=0)
ACE_Export ssize_t	writev_n (ACE_HANDLE handle, const iovec *iov, int iovcnt, size_t *bytes_transferred=0)
Functions
ACE_Export u_int	major_version (void)
	e.g., the "5" in ACE 5.1.12.
ACE_Export u_int	minor_version (void)
	e.g., the "1" in ACE 5.1.12.
ACE_Export u_int	beta_version (void)
ACE_Export const ACE_TCHAR *	compiler_name (void)
	E.g., the "SunPro C++" in SunPro C++ 4.32.0.
ACE_Export u_int	compiler_major_version (void)
	E.g., the "4" in SunPro C++ 4.32.0.
ACE_Export u_int	compiler_minor_version (void)
	E.g., the "32" in SunPro C++ 4.32.0.
ACE_Export u_int	compiler_beta_version (void)
	E.g., the "0" in SunPro C++ 4.32.0.
ACE_Export int	out_of_handles (int error)
ACE_Export bool	wild_match (const char *s, const char *pattern, bool case_sensitive=true)
ACE_Export int	handle_timed_accept (ACE_HANDLE listener, ACE_Time_Value *timeout, int restart)
ACE_Export ACE_HANDLE	handle_timed_complete (ACE_HANDLE listener, const ACE_Time_Value *timeout, int is_tli=0)
ACE_Export int	set_handle_limit (int new_limit=-1, int increase_limit_only=0)
ACE_Export int	max_handles (void)
ACE_Export ACE_TCHAR *	strenvdup (const ACE_TCHAR *str)
ACE_Export const char *	strend (const char *s)
ACE_Export char *	strnew (const char *s)
ACE_NAMESPACE_INLINE_FUNCTION void	strdelete (char *s)
	Delete the memory allocated by strnew.
ACE_Export char *	strndup (const char *str, size_t n)
ACE_Export char *	strnnew (const char *str, size_t n)
ACE_Export const wchar_t *	strend (const wchar_t *s)
ACE_Export wchar_t *	strnew (const wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION void	strdelete (wchar_t *s)
ACE_Export wchar_t *	strndup (const wchar_t *str, size_t n)
ACE_Export wchar_t *	strnnew (const wchar_t *str, size_t n)
ACE_Export const ACE_TCHAR *	execname (const ACE_TCHAR *pathname)
ACE_Export const ACE_TCHAR *	basename (const ACE_TCHAR *pathname, ACE_TCHAR delim=ACE_DIRECTORY_SEPARATOR_CHAR)
ACE_Export const ACE_TCHAR *	dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim=ACE_DIRECTORY_SEPARATOR_CHAR)
ACE_Export ACE_TCHAR *	timestamp (ACE_TCHAR date_and_time[], int time_len, int return_pointer_to_first_digit=0)
ACE_Export pid_t	fork (const ACE_TCHAR *program_name=ACE_TEXT("< unknown >"), int avoid_zombies=0)
ACE_Export int	daemonize (const ACE_TCHAR pathname[]=ACE_TEXT("/"), bool close_all_handles=ACE_DEFAULT_CLOSE_ALL_HANDLES, const ACE_TCHAR program_name[]=ACE_TEXT("< unknown >"))
ACE_Export size_t	round_to_pagesize (size_t len)
	Rounds the request to a multiple of the page size.
ACE_Export size_t	round_to_allocation_granularity (size_t len)
	Rounds the request to a multiple of the allocation granularity.
ACE_Export size_t	format_hexdump (const char *buffer, size_t size, ACE_TCHAR *obuf, size_t obuf_sz)
ACE_Export u_long	hash_pjw (const char *str)
	Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export u_long	hash_pjw (const char *str, size_t len)
	Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export u_long	hash_pjw (const wchar_t *str)
	Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export u_long	hash_pjw (const wchar_t *str, size_t len)
	Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export ACE_UINT16	crc_ccitt (const char *str)
	Computes CRC-CCITT for the string.
ACE_Export ACE_UINT16	crc_ccitt (const void *buf, size_t len, ACE_UINT16 crc=0)
	Computes CRC-CCITT for the buffer.
ACE_Export ACE_UINT16	crc_ccitt (const iovec *iov, int len, ACE_UINT16 crc=0)
	Computes CRC-CCITT for the @ len iovec buffers.
ACE_Export ACE_UINT32	crc32 (const char *str)
	Computes the ISO 8802-3 standard 32 bits CRC for the string.
ACE_Export ACE_UINT32	crc32 (const void *buf, size_t len, ACE_UINT32 crc=0)
	Computes the ISO 8802-3 standard 32 bits CRC for the buffer.
ACE_Export ACE_UINT32	crc32 (const iovec *iov, int len, ACE_UINT32 crc=0)
ACE_Export u_long	gcd (u_long x, u_long y)
	Euclid's greatest common divisor algorithm.
ACE_Export u_long	minimum_frame_size (u_long period1, u_long period2)
	Calculates the minimum enclosing frame size for the given values.
ACE_Export u_long	is_prime (const u_long n, const u_long min_factor, const u_long max_factor)
ACE_Export int	map_errno (int error)
ACE_Export const ACE_TCHAR *	sock_error (int error)
ACE_Export bool	is_sock_error (int error)
ACE_Export int	process_active (pid_t pid)
ACE_Export int	terminate_process (pid_t pid)
ACE_NAMESPACE_INLINE_FUNCTION void	unique_name (const void *object, ACE_TCHAR *name, size_t length)
ACE_NAMESPACE_INLINE_FUNCTION u_long	log2 (u_long num)
	Computes the base 2 logarithm of {num}.
ACE_NAMESPACE_INLINE_FUNCTION ACE_TCHAR	nibble2hex (u_int n)
	Hex conversion utility.
ACE_NAMESPACE_INLINE_FUNCTION u_char	hex2byte (ACE_TCHAR c)
	Convert a hex character to its byte representation.
ACE_Export bool	debug (void)
ACE_Export void	debug (bool onoff)
ACE_Export int	select (int width, ACE_Handle_Set *readfds, ACE_Handle_Set *writefds=0, ACE_Handle_Set *exceptfds=0, const ACE_Time_Value *timeout=0)
	Wrapper facade for select that uses ACE_Handle_Sets.
ACE_Export int	select (int width, ACE_Handle_Set &readfds, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION int	handle_read_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
	Timed wait for handle to get read ready.
ACE_NAMESPACE_INLINE_FUNCTION int	handle_write_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
	Timed wait for handle to get write ready.
ACE_NAMESPACE_INLINE_FUNCTION int	handle_exception_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
	Timed wait for handle to get exception ready.
ACE_Export int	handle_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout, int read_ready, int write_ready, int exception_ready)
	Timed wait for handle to get read, write, or exception ready.
ACE_Export int	enter_recv_timedwait (ACE_HANDLE handle, const ACE_Time_Value *timeout, int &val)
ACE_Export int	enter_send_timedwait (ACE_HANDLE handle, const ACE_Time_Value *timeout, int &val)
ACE_Export void	record_and_set_non_blocking_mode (ACE_HANDLE handle, int &val)
ACE_Export void	restore_non_blocking_mode (ACE_HANDLE handle, int val)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	recv_i (ACE_HANDLE handle, void *buf, size_t len)
ACE_Export ssize_t	recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, size_t *bytes_transferred)
ACE_Export ssize_t	recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t	t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, size_t *bytes_transferred)
ACE_Export ssize_t	t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t	recv_n_i (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred)
ACE_Export ssize_t	recv_n_i (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t	recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bytes_transferred)
ACE_Export ssize_t	recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t	send_i (ACE_HANDLE handle, const void *buf, size_t len)
ACE_Export ssize_t	send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bytes_transferred)
ACE_Export ssize_t	send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t	t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bytes_transferred)
ACE_Export ssize_t	t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t	send_n_i (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred)
ACE_Export ssize_t	send_n_i (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t	sendv_n_i (ACE_HANDLE handle, const iovec *iov, int iovcnt, size_t *bytes_transferred)
ACE_Export ssize_t	sendv_n_i (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export int	set_flags (ACE_HANDLE handle, int flags)
	Set flags associated with handle.
ACE_Export int	clr_flags (ACE_HANDLE handle, int flags)
	Clear flags associated with handle.
ACE_NAMESPACE_INLINE_FUNCTION int	get_flags (ACE_HANDLE handle)
	Return the current setting of flags associated with handle.
ACE_Export ACE_HANDLE	handle_timed_open (ACE_Time_Value *timeout, const ACE_TCHAR *name, int flags, int perms, LPSECURITY_ATTRIBUTES sa=0)
ACE_Export int	init (void)
ACE_Export int	fini (void)
ACE_Export int	ldfind (const ACE_TCHAR *filename, ACE_TCHAR pathname[], size_t maxpathnamelen)
ACE_Export FILE *	ldopen (const ACE_TCHAR *filename, const ACE_TCHAR *type)
ACE_Export ACE_TCHAR *	ldname (const ACE_TCHAR *entry_point)
ACE_Export int	get_temp_dir (ACE_TCHAR *buffer, size_t buffer_len)
ACE_Export ACE_HANDLE	open_temp_file (const ACE_TCHAR *name, int mode, int perm=0)
ACE_Export size_t	strrepl (char *s, char search, char replace)
ACE_Export char *	strsplit_r (char *s, const char *token, char *&next_start)
ACE_Export size_t	strrepl (wchar_t *s, wchar_t search, wchar_t replace)
	As strrepl, but for wide characters.
ACE_Export wchar_t *	strsplit_r (wchar_t *s, const wchar_t *token, wchar_t *&next_start)
	As strsplit_r, but for wide characters.
ACE_Export int	bind_port (ACE_HANDLE handle, ACE_UINT32 ip_addr=INADDR_ANY, int address_family=AF_UNSPEC)
	Bind a new unused port to handle.
ACE_Export int	get_bcast_addr (ACE_UINT32 &bcast_addr, const ACE_TCHAR *hostname=0, ACE_UINT32 host_addr=0, ACE_HANDLE handle=ACE_INVALID_HANDLE)
ACE_Export int	get_fqdn (ACE_INET_Addr const &addr, char hostname[], size_t len)
	Get fully qualified host/domain name.
ACE_Export int	get_ip_interfaces (size_t &count, ACE_INET_Addr *&addr_array)
ACE_Export int	count_interfaces (ACE_HANDLE handle, size_t &how_many)
ACE_Export ACE_HANDLE	get_handle (void)
ACE_Export bool	ipv4_enabled (void)
ACE_Export int	ipv6_enabled (void)
Variables
size_t	allocation_granularity_ = 0
size_t	pagesize_ = 0
char	debug_
unsigned int	init_fini_count_ = 0

---

Detailed Description

The namespace containing the ACE framework itself.

The ACE namespace contains all types (classes, structures, typedefs, etc), and global functions and variables in the ACE framework.

---

Function Documentation

const ACE_TCHAR * ACE::basename (  const ACE_TCHAR *  pathname, ACE_TCHAR  delim = ACE_DIRECTORY_SEPARATOR_CHAR )

Returns the "basename" of a pathname separated by delim. For instance, the basename of "/tmp/foo.cpp" is "foo.cpp" when delim is '/'. Definition at line 406 of file ACE.cpp. References ACE_TCHAR, ACE_TRACE, and ACE_OS::strrchr(). Referenced by ACE_Name_Options::process_name(). { ACE_TRACE ("ACE::basename"); const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim); if (temp == 0) return pathname; else return temp + 1; }

u_int ACE::beta_version (  void   )

e.g., the "12" in ACE 5.1.12. Returns 0 for "stable" (non-beta) releases. Definition at line 119 of file ACE.cpp. References ACE_BETA_VERSION. { return ACE_BETA_VERSION; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE::bind_port (  ACE_HANDLE  handle, ACE_UINT32  ip_addr = INADDR_ANY, int  address_family = AF_UNSPEC )

Bind a new unused port to handle. Definition at line 170 of file Sock_Connect.cpp. References ACE_INET_Addr, ACE_MAX_DEFAULT_PORT, ACE_TRACE, ACE_OS::bind(), EADDRINUSE, ACE_INET_Addr::get_addr(), ACE_Addr::get_size(), INADDR_ANY, IPPORT_RESERVED, and ACE_INET_Addr::set(). Referenced by ACE_SOCK_CODgram::open(), ACE_SOCK_SEQPACK_Acceptor::shared_open(), ACE_SOCK_Dgram::shared_open(), and ACE_SOCK_Acceptor::shared_open(). { ACE_TRACE ("ACE::bind_port"); ACE_INET_Addr addr; #if defined (ACE_HAS_IPV6) if (address_family != PF_INET6) // What do we do if it is PF_"INET6? Since it's 4 bytes, it must be an // IPV4 address. Is there a difference? Why is this test done? dhinton #else /* ACE_HAS_IPV6 */ ACE_UNUSED_ARG (address_family); #endif /* !ACE_HAS_IPV6 */ addr = ACE_INET_Addr ((u_short)0, ip_addr); #if defined (ACE_HAS_IPV6) else if (ip_addr != INADDR_ANY) // address_family == PF_INET6 and a non default IP address means to bind // to the IPv4-mapped IPv6 address addr.set ((u_short)0, ip_addr, 1, 1); #endif /* ACE_HAS_IPV6 */ #if !defined (ACE_LACKS_WILDCARD_BIND) // The OS kernel should select a free port for us. return ACE_OS::bind (handle, (sockaddr*)addr.get_addr(), addr.get_size()); #else static u_short upper_limit = ACE_MAX_DEFAULT_PORT; int round_trip = upper_limit; int lower_limit = IPPORT_RESERVED; // We have to select the port explicitly. for (;;) { addr.set((u_short)upper_limit,ip_addr); if (ACE_OS::bind (handle, (sockaddr*)addr.get_addr() addr.get_size()) >= 0) { #if defined (ACE_WIN32) upper_limit--; #endif /* ACE_WIN32 */ return 0; } else if (errno != EADDRINUSE) return -1; else { upper_limit--; // Wrap back around when we reach the bottom. if (upper_limit <= lower_limit) upper_limit = ACE_MAX_DEFAULT_PORT; // See if we have already gone around once! if (upper_limit == round_trip) { errno = EAGAIN; return -1; } } } #endif /* ACE_HAS_WILDCARD_BIND */ }

int ACE::clr_flags (  ACE_HANDLE  handle, int  flags )

Clear flags associated with handle. Definition at line 62 of file Flag_Manip.cpp. References ACE_CLR_BITS, ACE_NONBLOCK, ACE_NOTSUP_RETURN, ACE_TRACE, F_GETFL, ACE_OS::fcntl(), and ACE_OS::ioctl(). Referenced by ACE_IPC_SAP::disable(), ACE_IO_SAP::disable(), restore_non_blocking_mode(), ACE_SOCK_SEQPACK_Acceptor::shared_accept_finish(), ACE_SOCK_Acceptor::shared_accept_finish(), and ACE_MEM_Acceptor::shared_accept_finish(). { ACE_TRACE ("ACE::clr_flags"); #if defined (ACE_LACKS_FCNTL) switch (flags) { case ACE_NONBLOCK: // nonblocking argument (1) // blocking: (0) { int nonblock = 0; return ACE_OS::ioctl (handle, FIONBIO, &nonblock); } default: ACE_NOTSUP_RETURN (-1); } #else int val = ACE_OS::fcntl (handle, F_GETFL, 0); if (val == -1) return -1; // Turn flags off. ACE_CLR_BITS (val, flags); if (ACE_OS::fcntl (handle, F_SETFL, val) == -1) return -1; else return 0; #endif /* ACE_LACKS_FCNTL */ }

u_int ACE::compiler_beta_version (  void   )

E.g., the "0" in SunPro C++ 4.32.0. Definition at line 155 of file ACE.cpp. { #ifdef ACE_CC_BETA_VERSION return ACE_CC_BETA_VERSION; #else return 0; #endif }

u_int ACE::compiler_major_version (  void   )

E.g., the "4" in SunPro C++ 4.32.0. Definition at line 135 of file ACE.cpp. { #ifdef ACE_CC_MAJOR_VERSION return ACE_CC_MAJOR_VERSION; #else return 0; #endif }

u_int ACE::compiler_minor_version (  void   )

E.g., the "32" in SunPro C++ 4.32.0. Definition at line 145 of file ACE.cpp. { #ifdef ACE_CC_MINOR_VERSION return ACE_CC_MINOR_VERSION; #else return 0; #endif }

const ACE_TCHAR * ACE::compiler_name (  void   )

E.g., the "SunPro C++" in SunPro C++ 4.32.0. Definition at line 125 of file ACE.cpp. References ACE_TEXT. { #ifdef ACE_CC_NAME return ACE_CC_NAME; #else return ACE_TEXT (""); #endif }

int ACE::count_interfaces (  ACE_HANDLE  handle, size_t &  how_many )

Helper routine for get_ip_interfaces, differs by UNIX platform so put into own subroutine. perform some ioctls to retrieve ifconf list of ifreq structs. Definition at line 1444 of file Sock_Connect.cpp. References ACE_ERROR_RETURN, ACE_NOTSUP_RETURN, ACE_TEXT, AF_UNSPEC, caddr_t, ACE_OS::fclose(), ACE_OS::fopen(), ACE_OS::free(), ACE_OS::ioctl(), LM_ERROR, ACE_OS::malloc(), ACE_OS::memset(), and SIOCGIFCONF_CMD. Referenced by get_ip_interfaces(). { #if defined (ACE_WIN32) || defined (ACE_HAS_GETIFADDRS) || defined (__hpux) || defined (_AIX) || (defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x600)) // none of these platforms make use of count_interfaces ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (how_many); ACE_NOTSUP_RETURN (-1); // no implementation #elif defined (SIOCGIFNUM) # if defined (SIOCGLIFNUM) int cmd = SIOCGLIFNUM; struct lifnum if_num = {AF_UNSPEC,0,0}; # else int cmd = SIOCGIFNUM; int if_num = 0; # endif /* SIOCGLIFNUM */ if (ACE_OS::ioctl (handle, cmd, (caddr_t)&if_num) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::count_interfaces:") ACE_TEXT ("ioctl - SIOCGLIFNUM failed")), -1); # if defined (SIOCGLIFNUM) how_many = if_num.lifn_count; # else how_many = if_num; # endif /* SIOCGLIFNUM */ return 0; #elif (defined (__unix) || defined (__unix__) || defined (__Lynx__) || defined (ACE_OPENVMS) || defined (ACE_HAS_RTEMS)) && !defined (ACE_LACKS_NETWORKING) // Note: DEC CXX doesn't define "unix". BSD compatible OS: HP UX, // AIX, SunOS 4.x perform some ioctls to retrieve ifconf list of // ifreq structs no SIOCGIFNUM on SunOS 4.x, so use guess and scan // algorithm // Probably hard to put this many ifs in a unix box.. const int MAX_IF = 50; // HACK - set to an unreasonable number int num_ifs = MAX_IF; struct ifconf ifcfg; size_t ifreq_size = num_ifs * sizeof (struct ifreq); struct ifreq *p_ifs = (struct ifreq *) ACE_OS::malloc (ifreq_size); if (!p_ifs) { errno = ENOMEM; return -1; } ACE_OS::memset (p_ifs, 0, ifreq_size); ACE_OS::memset (&ifcfg, 0, sizeof (struct ifconf)); ifcfg.ifc_req = p_ifs; ifcfg.ifc_len = ifreq_size; if (ACE_OS::ioctl (handle, SIOCGIFCONF_CMD, (caddr_t) &ifcfg) == -1) { ACE_OS::free (ifcfg.ifc_req); ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::count_interfaces:") ACE_TEXT ("ioctl - SIOCGIFCONF failed")), -1); } int if_count = 0, i; // get if address out of ifreq buffers. ioctl puts a blank-named // interface to mark the end of the returned interfaces. for (i = 0; i < num_ifs; i++) { /* In OpenBSD, the length of the list is returned. */ ifcfg.ifc_len -= sizeof (struct ifreq); if (ifcfg.ifc_len < 0) break; ++if_count; #if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_HAS_RTEMS) ++p_ifs; #else if (p_ifs->ifr_addr.sa_len <= sizeof (struct sockaddr)) { ++p_ifs; } else { p_ifs = (struct ifreq *) (p_ifs->ifr_addr.sa_len + (caddr_t) &p_ifs->ifr_addr); } #endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) */ } ACE_OS::free (ifcfg.ifc_req); # if defined (ACE_HAS_IPV6) FILE* fp = 0; if ((fp = ACE_OS::fopen (ACE_TEXT ("/proc/net/if_inet6"), ACE_TEXT ("r"))) != 0) { // Scan the lines according to the expected format but don't really read any input while (fscanf (fp, "%*32s %*02x %*02x %*02x %*02x %*8s\n") != EOF) { ++if_count; } ACE_OS::fclose (fp); } # endif /* ACE_HAS_IPV6 */ how_many = if_count; return 0; #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (how_many); ACE_NOTSUP_RETURN (-1); // no implementation #endif /* sparc && SIOCGIFNUM */ }

ACE_UINT32 ACE::crc32 (  const iovec *  iov, int  len, ACE_UINT32  crc = 0 )

Computes the ISO 8802-3 standard 32 bits CRC for the @ len iovec buffers. Definition at line 142 of file ACE_crc32.cpp. References COMPUTE. { crc = ~crc; for (int i = 0; i < len; ++i) { for (const char *p = (const char *) iov[i].iov_base, *e = (const char *) iov[i].iov_base + iov[i].iov_len; p != e; ++p) COMPUTE (crc, *p); } return ~crc; }

ACE_UINT32 ACE::crc32 (  const void *  buf, size_t  len, ACE_UINT32  crc = 0 )

Computes the ISO 8802-3 standard 32 bits CRC for the buffer. Definition at line 126 of file ACE_crc32.cpp. References COMPUTE. { crc = ~crc; for (const char *p = (const char *) buffer, *e = (const char *) buffer + len; p != e; ++p) { COMPUTE (crc, *p); } return ~crc; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_UINT32 ACE::crc32 (  const char *  str  )

Computes the ISO 8802-3 standard 32 bits CRC for the string. Definition at line 111 of file ACE_crc32.cpp. References COMPUTE. Referenced by ACE_Shared_Memory_Pool::ACE_Shared_Memory_Pool(), and ACE_SV_Semaphore_Simple::name_2_key(). { ACE_UINT32 crc = 0xFFFFFFFF; for (const char *p = string; *p != 0; ++p) { COMPUTE (crc, *p); } return ~crc; }

ACE_UINT16 ACE::crc_ccitt (  const iovec *  iov, int  len, ACE_UINT16  crc = 0 )

Computes CRC-CCITT for the @ len iovec buffers. Definition at line 109 of file ACE_crc_ccitt.cpp. References COMPUTE. { crc = ~crc; for (int i = 0; i < len; ++i) { for (const char *p = (const char *) iov[i].iov_base, *e = (const char *) iov[i].iov_base + iov[i].iov_len; p != e; ++p) COMPUTE (crc, *p); } return ~crc; }

ACE_UINT16 ACE::crc_ccitt (  const void *  buf, size_t  len, ACE_UINT16  crc = 0 )

Computes CRC-CCITT for the buffer. Definition at line 93 of file ACE_crc_ccitt.cpp. References COMPUTE. { crc = ~crc; for (const char *p = (const char *) buffer, *e = (const char *) buffer + len; p != e; ++p) { COMPUTE (crc, *p); } return ~crc; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_UINT16 ACE::crc_ccitt (  const char *  str  )

Computes CRC-CCITT for the string. Definition at line 78 of file ACE_crc_ccitt.cpp. References COMPUTE. { ACE_UINT16 crc = 0xFFFF; for (const char *p = string; *p != 0; ++p) { COMPUTE (crc, *p); } return ~crc; }

int ACE::daemonize (  const ACE_TCHAR  pathname[] = ACE_TEXT("/"), bool  close_all_handles = ACE_DEFAULT_CLOSE_ALL_HANDLES, const ACE_TCHAR  program_name[] = ACE_TEXT("< unknown >") )

Become a daemon process using the algorithm in Richard Stevens "Advanced Programming in the UNIX Environment." If close_all_handles is non-zero then all open file handles are closed. Definition at line 2742 of file ACE.cpp. References ACE_NOTSUP_RETURN, ACE_TCHAR, ACE_TRACE, ACE_OS::chdir(), ACE_OS::close(), ACE_OS::exit(), ACE_OS::fork(), max_handles(), pid_t, ACE_OS::setsid(), SIG_IGN, SIGHUP, ACE_OS::signal(), and ACE_OS::umask(). Referenced by ACE_Service_Config::open_i(). { ACE_TRACE ("ACE::daemonize"); #if !defined (ACE_LACKS_FORK) pid_t pid = ACE_OS::fork (); if (pid == -1) return -1; else if (pid != 0) ACE_OS::exit (0); // Parent exits. // 1st child continues. ACE_OS::setsid (); // Become session leader. ACE_OS::signal (SIGHUP, SIG_IGN); pid = ACE_OS::fork (program_name); if (pid != 0) ACE_OS::exit (0); // First child terminates. // Second child continues. if (pathname != 0) // change working directory. ACE_OS::chdir (pathname); ACE_OS::umask (0); // clear our file mode creation mask. // Close down the I/O handles. if (close_all_handles) for (int i = ACE::max_handles () - 1; i >= 0; i--) ACE_OS::close (i); return 0; #else ACE_UNUSED_ARG (pathname); ACE_UNUSED_ARG (close_all_handles); ACE_UNUSED_ARG (program_name); ACE_NOTSUP_RETURN (-1); #endif /* ACE_LACKS_FORK */ }

void ACE::debug (  bool  onoff  )

Definition at line 172 of file ACE.cpp. { ACE::debug_ = onoff; }

bool ACE::debug (  void   )

Definition at line 165 of file ACE.cpp. References debug(), and ACE_OS::getenv(). Referenced by ACE_DLL::ACE_DLL(), ACE_DLL_Manager::ACE_DLL_Manager(), ACE_Service_Config_Guard::ACE_Service_Config_Guard(), ACE_Service_Gestalt::ACE_Service_Gestalt(), ACE_Service_Type_Dynamic_Guard::ACE_Service_Type_Dynamic_Guard(), ACE_Service_Gestalt::add_processed_static_svc(), ACE_Service_Repository::close(), ACE_Service_Gestalt::close(), ACE_DLL_Handle::close(), ACE_Local_Name_Space<, ACE_LOCK >::create_manager_i(), debug(), ACE_Service_Type_Impl::fini(), ACE_Service_Repository::fini(), ACE_Naming_Context::fini(), ACE_Service_Config::fini_svcs(), get_fqdn(), ACE_DLL_Handle::get_handle(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::handle_input(), ACE_Naming_Context::init(), ACE_Dynamic_Service_Dependency::init(), ACE_Service_Gestalt::init_svc_conf_file_queue(), ACE_Service_Gestalt::initialize(), ACE_Service_Gestalt::initialize_i(), ACE_Service_Repository::insert(), ACE_Dynamic_Service_Base::instance(), ACE_SOCK_Dgram_Bcast::mk_broadcast(), ACE_DLL_Handle::open(), ACE_DLL_Manager::open_dll(), ACE_Service_Gestalt::open_i(), ACE_Service_Config::open_i(), ACE_DLL::open_i(), ACE_Service_Gestalt::parse_args_i(), ACE_Service_Gestalt::process_directive(), ACE_Service_Gestalt::process_directive_i(), ACE_Service_Gestalt::process_directives_i(), ACE_Service_Gestalt::process_file(), ACE_Service_Config::reconfigure(), ACE_Service_Repository::relocate_i(), ACE_Framework_Repository::remove_dll_components_i(), ACE_DLL_Handle::symbol(), ACE_DLL_Manager::unload_dll(), ACE_DLL_Manager::~ACE_DLL_Manager(), ACE_Dynamic_Service_Dependency::~ACE_Dynamic_Service_Dependency(), ACE_Service_Config_Guard::~ACE_Service_Config_Guard(), ACE_Service_Gestalt::~ACE_Service_Gestalt(), ACE_Service_Repository::~ACE_Service_Repository(), and ACE_Service_Type_Dynamic_Guard::~ACE_Service_Type_Dynamic_Guard(). { static const char* debug = ACE_OS::getenv ("ACE_DEBUG"); return (ACE::debug_ != 0) ? ACE::debug_ : (debug != 0 ? (*debug != '0'): false); }

const ACE_TCHAR * ACE::dirname (  const ACE_TCHAR *  pathname, ACE_TCHAR  delim = ACE_DIRECTORY_SEPARATOR_CHAR )

Returns the "dirname" of a pathname. For instance, the dirname of "/tmp/foo.cpp" is "/tmp" when delim is '/'. If pathname has no delim ".\0" is returned. This method does not modify pathname and is not reentrant. Definition at line 418 of file ACE.cpp. References ACE_TCHAR, ACE_TRACE, MAXPATHLEN, ACE_OS::strrchr(), and ACE_OS::strsncpy(). { ACE_TRACE ("ACE::dirname"); static ACE_TCHAR return_dirname[MAXPATHLEN + 1]; const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim); if (temp == 0) { return_dirname[0] = '.'; return_dirname[1] = '\0'; return return_dirname; } else { // When the len is truncated, there are problems! This should // not happen in normal circomstances size_t len = temp - pathname + 1; if (len > (sizeof return_dirname / sizeof (ACE_TCHAR))) len = sizeof return_dirname / sizeof (ACE_TCHAR); ACE_OS::strsncpy (return_dirname, pathname, len); return return_dirname; } }

int ACE::enter_recv_timedwait (  ACE_HANDLE  handle, const ACE_Time_Value *  timeout, int &  val )

Wait for timeout before proceeding to a recv operation. val keeps track of whether we're in non-blocking mode or not. Definition at line 2230 of file ACE.cpp. References handle_read_ready(), and record_and_set_non_blocking_mode(). Referenced by recv(), recvfrom(), recvmsg(), recvv(), and t_rcv(). { int result = ACE::handle_read_ready (handle, timeout); if (result == -1) return -1; ACE::record_and_set_non_blocking_mode (handle, val); return result; }

int ACE::enter_send_timedwait (  ACE_HANDLE  handle, const ACE_Time_Value *  timeout, int &  val )

Wait for timeout before proceeding to a send operation. val keeps track of whether we're in non-blocking mode or not. Definition at line 2247 of file ACE.cpp. References handle_write_ready(), and record_and_set_non_blocking_mode(). Referenced by send(), sendmsg(), sendto(), sendv(), and t_snd(). { int result = ACE::handle_write_ready (handle, timeout); if (result == -1) return -1; ACE::record_and_set_non_blocking_mode (handle, val); return result; }

const ACE_TCHAR * ACE::execname (  const ACE_TCHAR *  pathname  )

On Windows, determines if a specified pathname ends with ".exe" (not case sensitive). If on Windows and there is no ".exe" suffix, a new ACE_TCHAR array is allocated and a copy of pathname with the ".exe" suffix is copied into it. In this case, the caller is responsible for calling delete [] on the returned pointer. Parameters: pathname  The name to check for a proper suffix. Return values: @c  pathname if there is a proper suffix for Windows. This is always the return value for non-Windows platforms. If  a suffix needs to be added, returns a pointer to new[] allocated memory containing the original pathname plus a ".exe" suffix. The caller is responsible for freeing the memory using delete []. Definition at line 287 of file ACE.cpp. References ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT, ACE_OS::strcasecmp(), ACE_OS::strcpy(), ACE_OS::strecpy(), ACE_OS::strlen(), and ACE_OS::strrchr(). { #if defined (ACE_WIN32) const ACE_TCHAR *suffix = ACE_OS::strrchr (old_name, ACE_TEXT ('.')); if (suffix == 0 || ACE_OS::strcasecmp (suffix, ACE_TEXT (".exe")) != 0) { ACE_TCHAR *new_name; size_t size = ACE_OS::strlen (old_name) + ACE_OS::strlen (ACE_TEXT (".exe")) + 1; ACE_NEW_RETURN (new_name, ACE_TCHAR[size], 0); ACE_TCHAR *end = new_name; end = ACE_OS::strecpy (new_name, old_name); // Concatenate the .exe suffix onto the end of the executable. // end points _after_ the terminating nul. ACE_OS::strcpy (end - 1, ACE_TEXT (".exe")); return new_name; } #endif /* ACE_WIN32 */ return old_name; }

int ACE::fini (  void   )

Shut down ACE library services. Can be called only once per program invocation. Returns: Returns 0 on success, -1 on failure, and 1 if it had already been called. Definition at line 27 of file Init_ACE.cpp. References ACE_TRACE, ACE_Object_Manager::fini(), and ACE_Object_Manager::instance(). { ACE_TRACE ("ACE::fini"); if (ACE::init_fini_count_ > 0) { if (--ACE::init_fini_count_ == 0) return ACE_Object_Manager::instance ()->fini (); else // Wait for remaining fini () calls. return 1; } else // More ACE::fini () calls than ACE::init () calls. Bad // application! return -1; }

pid_t ACE::fork (  const ACE_TCHAR *  program_name = ACE_TEXT("< unknown >"), int  avoid_zombies = 0 )

if avoid_zombies == 0 call ACE_OS::fork directly, else create an orphan process that's inherited by the init process; init cleans up when the orphan process terminates so we don't create zombies. Returns -1 on failure and either the child PID on success if avoid_zombies == 0 or 1 on success if avoid_zombies != 0 (this latter behavior is a known bug that needs to be fixed). Definition at line 2789 of file ACE.cpp. References ACE_OS::_exit(), ACE_exitcode, ACE_TCHAR, ACE_OS::fork(), pid_t, ACE_OS::waitpid(), WEXITSTATUS, and WIFEXITED. Referenced by ACE_Process_Strategy< SVC_HANDLER >::activate_svc_handler(), and ACE_Process::spawn(). { if (avoid_zombies == 0) return ACE_OS::fork (program_name); else { // This algorithm is adapted from an example in the Stevens book // "Advanced Programming in the Unix Environment" and an item in // Andrew Gierth's Unix Programming FAQ. It creates an orphan // process that's inherited by the init process; init cleans up // when the orphan process terminates. // // Another way to avoid zombies is to ignore or catch the // SIGCHLD signal; we don't use that approach here. pid_t pid = ACE_OS::fork (); if (pid == 0) { // The child process forks again to create a grandchild. switch (ACE_OS::fork (program_name)) { case 0: // grandchild returns 0. return 0; case -1: // assumes all errnos are < 256 ACE_OS::_exit (errno); default: // child terminates, orphaning grandchild ACE_OS::_exit (0); } } // Parent process waits for child to terminate. ACE_exitcode status; if (pid < 0 || ACE_OS::waitpid (pid, &status, 0) < 0) return -1; // child terminated by calling exit()? if (WIFEXITED ((status))) { // child terminated normally? if (WEXITSTATUS ((status)) == 0) return 1; else errno = WEXITSTATUS ((status)); } else // child didn't call exit(); perhaps it received a signal? errno = EINTR; return -1; } }

size_t ACE::format_hexdump (  const char *  buffer, size_t  size, ACE_TCHAR *  obuf, size_t  obuf_sz )

Format buffer into printable format. This is useful for debugging. Definition at line 2298 of file ACE.cpp. References ACE_OS::ace_isprint(), ACE_TCHAR, ACE_TEXT, ACE_TRACE, and ACE_OS::sprintf(). { ACE_TRACE ("ACE::format_hexdump"); u_char c; ACE_TCHAR textver[16 + 1]; // We can fit 16 bytes output in text mode per line, 4 chars per byte. size_t maxlen = (obuf_sz / 68) * 16; if (size > maxlen) size = maxlen; size_t i; size_t lines = size / 16; for (i = 0; i < lines; i++) { size_t j; for (j = 0 ; j < 16; j++) { c = (u_char) buffer[(i << 4) + j]; // or, buffer[i*16+j] ACE_OS::sprintf (obuf, ACE_TEXT ("%02x "), c); obuf += 3; if (j == 7) { ACE_OS::sprintf (obuf, ACE_TEXT (" ")); ++obuf; } textver[j] = ACE_OS::ace_isprint (c) ? c : '.'; } textver[j] = 0; ACE_OS::sprintf (obuf, ACE_TEXT (" %s\n"), textver); while (*obuf != '\0') ++obuf; } if (size % 16) { for (i = 0 ; i < size % 16; i++) { c = (u_char) buffer[size - size % 16 + i]; ACE_OS::sprintf (obuf, ACE_TEXT ("%02x "), c); obuf += 3; if (i == 7) { ACE_OS::sprintf (obuf, ACE_TEXT (" ")); ++obuf; } textver[i] = ACE_OS::ace_isprint (c) ? c : '.'; } for (i = size % 16; i < 16; i++) { ACE_OS::sprintf (obuf, ACE_TEXT (" ")); obuf += 3; if (i == 7) { ACE_OS::sprintf (obuf, ACE_TEXT (" ")); ++obuf; } textver[i] = ' '; } textver[i] = 0; ACE_OS::sprintf (obuf, ACE_TEXT (" %s\n"), textver); } return size; }

u_long ACE::gcd (  u_long  x, u_long  y )

Euclid's greatest common divisor algorithm. Definition at line 2933 of file ACE.cpp. Referenced by minimum_frame_size(), and ACE_Get_Opt::permute_args(). { while (y != 0) { u_long r = x % y; x = y; y = r; } return x; }

int ACE::get_bcast_addr (  ACE_UINT32 &  bcast_addr, const ACE_TCHAR *  hostname = 0, ACE_UINT32  host_addr = 0, ACE_HANDLE  handle = ACE_INVALID_HANDLE )

Get our broadcast address based on our host_addr. If hostname is non-0 we'll use it to determine our IP address. If handle is not ACE_INVALID_HANDLE then we'll use this to determine our broadcast address, otherwise we'll have to create a socket internally (and free it). Returns -1 on failure and 0 on success. Definition at line 238 of file Sock_Connect.cpp. References ACE_BIT_DISABLED, ACE_BIT_ENABLED, ACE_ERROR, ACE_ERROR_RETURN, ACE_NOTSUP_RETURN, ACE_TCHAR, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TRACE, ACE_UINT64, AF_INET, caddr_t, ACE_OS::close(), ACE_OS::gethostbyname(), IFF_BROADCAST, IFF_LOOPBACK, IFF_UP, ACE_OS::ioctl(), LM_ERROR, ACE_OS::memcpy(), ACE_OS::memset(), SIOCGIFBRDADDR, SIOCGIFCONF_CMD, SOCK_STREAM, and ACE_OS::socket(). { ACE_TRACE ("ACE::get_bcast_addr"); #if defined (ACE_LACKS_GET_BCAST_ADDR) ACE_UNUSED_ARG (bcast_addr); ACE_UNUSED_ARG (host_name); ACE_UNUSED_ARG (host_addr); ACE_UNUSED_ARG (handle); ACE_NOTSUP_RETURN (-1); #elif !defined(ACE_WIN32) && !defined(__INTERIX) ACE_HANDLE s = handle; if (s == ACE_INVALID_HANDLE) s = ACE_OS::socket (AF_INET, SOCK_STREAM, 0); if (s == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_OS::socket")), -1); struct ifconf ifc; char buf[BUFSIZ]; ifc.ifc_len = sizeof buf; ifc.ifc_buf = buf; // Get interface structure and initialize the addresses using UNIX // techniques if (ACE_OS::ioctl (s, SIOCGIFCONF_CMD, (char *) &ifc) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_bcast_addr:") ACE_TEXT ("ioctl (get interface configuration)")), -1); struct ifreq *ifr = ifc.ifc_req; struct sockaddr_in ip_addr; // Get host ip address if necessary. if (host_name) { hostent *hp = ACE_OS::gethostbyname (ACE_TEXT_ALWAYS_CHAR (host_name)); if (hp == 0) return -1; else #if !defined(_UNICOS) ACE_OS::memcpy ((char *) &ip_addr.sin_addr.s_addr, (char *) hp->h_addr, hp->h_length); #else /* _UNICOS */ { ACE_UINT64 haddr; // a place to put the address char * haddrp = (char *) &haddr; // convert to char pointer ACE_OS::memcpy(haddrp,(char *) hp->h_addr,hp->h_length); ip_addr.sin_addr.s_addr = haddr; } #endif /* ! _UNICOS */ } else { ACE_OS::memset ((void *) &ip_addr, 0, sizeof ip_addr); #if !defined(_UNICOS) ACE_OS::memcpy ((void *) &ip_addr.sin_addr, (void*) &host_addr, sizeof ip_addr.sin_addr); #else /* _UNICOS */ ip_addr.sin_addr.s_addr = host_addr; // just copy to the bitfield #endif /* ! _UNICOS */ } #if !defined(AIX) && !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) for (int n = ifc.ifc_len / sizeof (struct ifreq) ; n > 0; n--, ifr++) #else // see mk_broadcast@SOCK_Dgram_Bcast.cpp for (int nbytes = ifc.ifc_len; nbytes >= (int) sizeof (struct ifreq) && ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ? (nbytes >= (int) sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len) : 1); ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ? (nbytes -= sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len, ifr = (struct ifreq *) ((caddr_t) &ifr->ifr_addr + ifr->ifr_addr.sa_len)) : (nbytes -= sizeof (struct ifreq), ifr++))) #endif /* !defined(AIX) && !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) */ { struct sockaddr_in if_addr; // Compare host ip address with interface ip address. ACE_OS::memcpy (&if_addr, &ifr->ifr_addr, sizeof if_addr); if (ip_addr.sin_addr.s_addr != if_addr.sin_addr.s_addr) continue; if (ifr->ifr_addr.sa_family != AF_INET) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_bcast_addr:") ACE_TEXT ("Not AF_INET"))); continue; } struct ifreq flags = *ifr; struct ifreq if_req = *ifr; if (ACE_OS::ioctl (s, SIOCGIFFLAGS, (char *) &flags) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_bcast_addr:") ACE_TEXT (" ioctl (get interface flags)"))); continue; } if (ACE_BIT_DISABLED (flags.ifr_flags, IFF_UP)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_bcast_addr:") ACE_TEXT ("Network interface is not up"))); continue; } if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_LOOPBACK)) continue; if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_BROADCAST)) { if (ACE_OS::ioctl (s, SIOCGIFBRDADDR, (char *) &if_req) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_bcast_addr:") ACE_TEXT ("ioctl (get broadaddr)"))); else { ACE_OS::memcpy (&ip_addr, &if_req.ifr_broadaddr, sizeof if_req.ifr_broadaddr); ACE_OS::memcpy ((void *) &host_addr, (void *) &ip_addr.sin_addr, sizeof host_addr); if (handle == ACE_INVALID_HANDLE) ACE_OS::close (s); bcast_addr = host_addr; return 0; } } else ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_bcast_addr:") ACE_TEXT ("Broadcast is not enable for this interface."))); if (handle == ACE_INVALID_HANDLE) ACE_OS::close (s); bcast_addr = host_addr; return 0; } return 0; #else ACE_UNUSED_ARG (handle); ACE_UNUSED_ARG (host_addr); ACE_UNUSED_ARG (host_name); bcast_addr = (ACE_UINT32 (INADDR_BROADCAST)); return 0; #endif /* !ACE_WIN32 && !__INTERIX */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE::get_flags (  ACE_HANDLE  handle  )

Return the current setting of flags associated with handle. Definition at line 11 of file Flag_Manip.inl. References ACE_TRACE, F_GETFL, and ACE_OS::fcntl(). Referenced by record_and_set_non_blocking_mode(). { ACE_TRACE ("ACE::get_flags"); #if defined (ACE_LACKS_FCNTL) // ACE_OS::fcntl is not supported. It // would be better to store ACE's notion of the flags // associated with the handle, but this works for now. ACE_UNUSED_ARG (handle); return 0; #else return ACE_OS::fcntl (handle, F_GETFL, 0); #endif /* ACE_LACKS_FCNTL */ }

int ACE::get_fqdn (  ACE_INET_Addr const &  addr, char  hostname[], size_t  len )

Get fully qualified host/domain name. Definition at line 423 of file Sock_Connect.cpp. References ACE_DEBUG, ACE_HOSTENT_DATA, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, AF_INET, debug(), ACE_INET_Addr::get_addr(), ACE_Addr::get_type(), ACE_OS::gethostbyaddr_r(), LM_DEBUG, ACE_OS::strchr(), ACE_OS::strcpy(), and ACE_OS::strlen(). { int h_error; // Not the same as errno! hostent hentry; ACE_HOSTENT_DATA buf; char * ip_addr = 0; int ip_addr_size = 0; if (addr.get_type () == AF_INET) { sockaddr_in * const sock_addr = reinterpret_cast<sockaddr_in *> (addr.get_addr ()); ip_addr_size = sizeof sock_addr->sin_addr; ip_addr = (char*) &sock_addr->sin_addr; } #ifdef ACE_HAS_IPV6 else { sockaddr_in6 * sock_addr = reinterpret_cast<sockaddr_in6 *> (addr.get_addr ()); ip_addr_size = sizeof sock_addr->sin6_addr; ip_addr = (char*) &sock_addr->sin6_addr; } #endif /* ACE_HAS_IPV6 */ // get the host entry for the address in question hostent * const hp = ACE_OS::gethostbyaddr_r (ip_addr, ip_addr_size, addr.get_type (), &hentry, buf, &h_error); // if it's not found in the host file or the DNS datase, there is nothing // much we can do. embed the IP address if (hp == 0 || hp->h_name == 0) return -1; if (ACE::debug()) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ") ACE_TEXT ("canonical host name is %s\n"), ACE_TEXT_CHAR_TO_TCHAR (hp->h_name))); // check if the canonical name is the FQDN if (!ACE_OS::strchr(hp->h_name, '.')) { // list of address char** p; // list of aliases char** q; // for every address and for every alias within the address, check and // see if we can locate a FQDN for (p = hp->h_addr_list; *p != 0; ++p) { for (q = hp->h_aliases; *q != 0; ++q) { if (ACE_OS::strchr(*q, '.')) { // we got an FQDN from an alias. use this if (ACE_OS::strlen (*q) >= len) // the hostname is too huge to fit into a // buffer of size MAXHOSTNAMELEN // should we check other aliases as well // before bailing out prematurely? // for right now, let's do it. this (short name) // is atleast better than embedding the IP // address in the profile continue; if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ") ACE_TEXT ("found fqdn within alias as %s\n"), ACE_TEXT_CHAR_TO_TCHAR(*q))); ACE_OS::strcpy (hostname, *q); return 0; } } } } // The canonical name may be an FQDN when we reach here. // Alternatively, the canonical name (a non FQDN) may be the best // we can do. if (ACE_OS::strlen (hp->h_name) >= len) { // The hostname is too large to fit into a buffer of size // MAXHOSTNAMELEN. return -2; } else { ACE_OS::strcpy (hostname, hp->h_name); } return 0; }

ACE_HANDLE ACE::get_handle (  void   )

Routine to return a handle from which ioctl requests can be made. Caller must close the handle. Definition at line 1572 of file Sock_Connect.cpp. References ACE_OS::open(), PF_INET, SOCK_DGRAM, and ACE_OS::socket(). Referenced by get_ip_interfaces(). { // Solaris 2.x ACE_HANDLE handle = ACE_INVALID_HANDLE; #if defined (sparc) handle = ACE_OS::open ("/dev/udp", O_RDONLY); #elif defined (__unix) || defined (__unix__) || defined (__Lynx__) || defined (_AIX) || defined (__hpux) || (defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600)) || defined (ACE_OPENVMS) || defined (ACE_HAS_RTEMS) // Note: DEC CXX doesn't define "unix" BSD compatible OS: HP UX, // AIX, SunOS 4.x handle = ACE_OS::socket (PF_INET, SOCK_DGRAM, 0); #endif /* sparc */ return handle; }

int ACE::get_ip_interfaces (  size_t &  count, ACE_INET_Addr *&  addr_array )

Return count and array of all configured IP interfaces on this host, rc = 0 on success (count == number of interfaces else -1). Caller is responsible for calling delete [] on addr_array. Definition at line 1220 of file Sock_Connect.cpp. References ACE_ERROR_RETURN, ACE_NEW_RETURN, ACE_NOTSUP_RETURN, ACE_TEXT, ACE_TRACE, AF_INET, AF_UNSPEC, caddr_t, ACE_OS::close(), count_interfaces(), ACE_OS::fclose(), ACE_OS::fopen(), ACE_Auto_Basic_Array_Ptr< X >::get(), get_handle(), get_ip_interfaces_win32(), IFCONF, IFREQ, ACE_OS::ioctl(), LM_ERROR, ACE_OS::memset(), ACE_INET_Addr::set(), SIOCGIFCONF_CMD, and ACE_OS::sprintf(). Referenced by ACE_SOCK_Dgram_Mcast::subscribe_ifs(), and ACE_SOCK_Dgram_Mcast::unsubscribe_ifs(). { ACE_TRACE ("ACE::get_ip_interfaces"); count = 0; addrs = 0; #if defined (ACE_WIN32) return get_ip_interfaces_win32 (count, addrs); #elif defined (ACE_HAS_GETIFADDRS) return get_ip_interfaces_getifaddrs (count, addrs); #elif defined (__hpux) return get_ip_interfaces_hpux (count, addrs); #elif defined (_AIX) return get_ip_interfaces_aix (count, addrs); #elif defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x600) return get_ip_interfaces_vxworks_lt600 (count, addrs); #elif (defined (__unix) || defined (__unix__) || defined (__Lynx__) || defined (ACE_OPENVMS) || (defined (ACE_VXWORKS) && (ACE_VXWORKS == 0x650)) || defined (ACE_HAS_RTEMS)) && !defined (ACE_LACKS_NETWORKING) // COMMON (SVR4 and BSD) UNIX CODE // Call specific routine as necessary. ACE_HANDLE handle = ACE::get_handle(); if (handle == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_ip_interfaces:open")), -1); size_t num_ifs, num_ifs_found; if (ACE::count_interfaces (handle, num_ifs)) { ACE_OS::close (handle); return -1; } // ioctl likes to have an extra ifreq structure to mark the end of // what it returned, so increase the num_ifs by one. ++num_ifs; struct IFREQ *ifs = 0; ACE_NEW_RETURN (ifs, struct IFREQ[num_ifs], -1); ACE_OS::memset (ifs, 0, num_ifs * sizeof (struct IFREQ)); ACE_Auto_Array_Ptr<struct IFREQ> p_ifs (ifs); if (p_ifs.get() == 0) { ACE_OS::close (handle); errno = ENOMEM; return -1; } struct IFCONF ifcfg; ACE_OS::memset (&ifcfg, 0, sizeof (struct IFCONF)); # ifdef SETFAMILY ifcfg.IFC_FAMILY = AF_UNSPEC; // request all families be returned ifcfg.IFC_FLAGS = 0; # endif ifcfg.IFC_REQ = p_ifs.get (); ifcfg.IFC_LEN = num_ifs * sizeof (struct IFREQ); if (ACE_OS::ioctl (handle, SIOCGIFCONF_CMD, (caddr_t) &ifcfg) == -1) { ACE_OS::close (handle); ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE::get_ip_interfaces:") ACE_TEXT ("ioctl - SIOCGIFCONF failed")), -1); } ACE_OS::close (handle); // Now create and initialize output array. ACE_NEW_RETURN (addrs, ACE_INET_Addr[num_ifs], -1); // caller must free struct IFREQ *pcur = p_ifs.get (); num_ifs_found = ifcfg.IFC_LEN / sizeof (struct IFREQ); // get the number of returned ifs // Pull the address out of each INET interface. Not every interface // is for IP, so be careful to count properly. When setting the // INET_Addr, note that the 3rd arg (0) says to leave the byte order // (already in net byte order from the interface structure) as is. count = 0; for (size_t i = 0; i < num_ifs_found; i++) { if (pcur->IFR_ADDR.SA_FAMILY == AF_INET # if defined (ACE_HAS_IPV6) || pcur->IFR_ADDR.SA_FAMILY == AF_INET6 # endif ) { # if !defined(_UNICOS) struct sockaddr_in *addr = reinterpret_cast<sockaddr_in *> (&pcur->IFR_ADDR); // Sometimes the kernel returns 0.0.0.0 as an IPv4 interface // address; skip those... if (addr->sin_addr.s_addr != 0 # if defined (ACE_HAS_IPV6) || (addr->sin_family == AF_INET6 && !IN6_IS_ADDR_UNSPECIFIED(&reinterpret_cast<sockaddr_in6 *>(addr)->sin6_addr)) # endif ) { int addrlen = static_cast<int> (sizeof (struct sockaddr_in)); # if defined (ACE_HAS_IPV6) if (addr->sin_family == AF_INET6) addrlen = static_cast<int> (sizeof (struct sockaddr_in6)); # endif addrs[count].set (addr, addrlen); ++count; } # else /* ! _UNICOS */ // need to explicitly copy on the Cray, since the bitfields kinda // screw things up here struct sockaddr_in inAddr; inAddr.sin_len = pcur->IFR_ADDR.sa_len; inAddr.sin_family = pcur->IFR_ADDR.sa_family; memcpy((void *)&(inAddr.sin_addr), (const void *)&(pcur->IFR_ADDR.sa_data[8]), sizeof(struct in_addr)); if (inAddr.sin_addr.s_addr != 0) { addrs[count].set(&inAddr, sizeof(struct sockaddr_in)); ++count; } # endif /* ! _UNICOS */ } #if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_HAS_RTEMS) ++pcur; #else if (pcur->ifr_addr.sa_len <= sizeof (struct sockaddr)) { ++pcur; } else { pcur = (struct ifreq *) (pcur->ifr_addr.sa_len + (caddr_t) &pcur->ifr_addr); } #endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) */ } # if defined (ACE_HAS_IPV6) // Retrieve IPv6 local interfaces by scanning /proc/net/if_inet6 if // it exists. If we cannot open it then ignore possible IPv6 // interfaces, we did our best;-) FILE* fp; char addr_p[8][5]; char s_ipaddr[64]; int scopeid; struct addrinfo hints, *res0; int error; ACE_OS::memset (&hints, 0, sizeof (hints)); hints.ai_flags = AI_NUMERICHOST; hints.ai_family = AF_INET6; if ((fp = ACE_OS::fopen (ACE_TEXT ("/proc/net/if_inet6"), ACE_TEXT ("r"))) != 0) { while (fscanf (fp, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %*02x %*02x %*02x %*8s\n", addr_p[0], addr_p[1], addr_p[2], addr_p[3], addr_p[4], addr_p[5], addr_p[6], addr_p[7], &scopeid) != EOF) { // Format the address intoa proper IPv6 decimal address specification and // resolve the resulting text using getaddrinfo(). const char* ip_fmt = "%s:%s:%s:%s:%s:%s:%s:%s%%%d"; ACE_OS::sprintf (s_ipaddr, ip_fmt, addr_p[0], addr_p[1], addr_p[2], addr_p[3], addr_p[4], addr_p[5], addr_p[6], addr_p[7], scopeid); error = getaddrinfo (s_ipaddr, 0, &hints, &res0); if (error) continue; if (res0->ai_family == AF_INET6 && !IN6_IS_ADDR_UNSPECIFIED (&reinterpret_cast<sockaddr_in6 *> (res0->ai_addr)->sin6_addr)) { addrs[count].set(reinterpret_cast<sockaddr_in *> (res0->ai_addr), res0->ai_addrlen); ++count; } freeaddrinfo (res0); } ACE_OS::fclose (fp); } # endif /* ACE_HAS_IPV6 */ return 0; #else ACE_UNUSED_ARG (count); ACE_UNUSED_ARG (addrs); ACE_NOTSUP_RETURN (-1); // no implementation #endif /* ACE_WIN32 */ }

int ACE::get_temp_dir (  ACE_TCHAR *  buffer, size_t  buffer_len )

Returns the temporary directory including the trailing slash in buffer. Returns -1 for an error or if the buffer_len is not long enough. Definition at line 593 of file Lib_Find.cpp. References ACE_TCHAR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TEXT_GetTempPath, ACE_OS::getenv(), ACE_OS::strcpy(), and ACE_OS::strlen(). Referenced by ACE_MEM_Acceptor::accept(), ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool(), ACE_Name_Options::ACE_Name_Options(), ACE_System_Time::ACE_System_Time(), and ACE_FILE_Addr::set(). { int result; #if defined (ACE_WIN32) result = ACE_TEXT_GetTempPath (static_cast<DWORD> (buffer_len), buffer); // Make sure to return -1 if there is an error if (result == 0 && ::GetLastError () != ERROR_SUCCESS || result > static_cast<int> (buffer_len)) result = -1; #else /* ACE_WIN32 */ // NOTE! Non-Windows platforms don't deal with wide chars for env. // variables, so do this narrow-char and convert to wide for the // caller if necessary. // On non-win32 platforms, check to see what the TMPDIR environment // variable is defined to be. If it doesn't exist, just use /tmp const char *tmpdir = ACE_OS::getenv ("TMPDIR"); if (tmpdir == 0) tmpdir = "/tmp"; size_t len = ACE_OS::strlen (tmpdir); // Check to see if the buffer is large enough for the string, // another /, and its null character (hence the + 2) if ((len + 2) > buffer_len) { result = -1; } else { ACE_OS::strcpy (buffer, ACE_TEXT_CHAR_TO_TCHAR (tmpdir)); // Add a trailing slash because we cannot assume there is already one // at the end. And having an extra one should not cause problems. buffer[len] = ACE_TEXT ('/'); buffer[len + 1] = 0; result = 0; } #endif /* ACE_WIN32 */ return result; }

ACE_INLINE int ACE::handle_exception_ready (  ACE_HANDLE  handle, const ACE_Time_Value *  timeout )

Timed wait for handle to get exception ready. Definition at line 263 of file ACE.inl. References handle_ready(). { return ACE::handle_ready (handle, timeout, 0, 0, 1); }

ACE_INLINE int ACE::handle_read_ready (  ACE_HANDLE  handle, const ACE_Time_Value *  timeout )

Timed wait for handle to get read ready. Definition at line 241 of file ACE.inl. References handle_ready(). Referenced by enter_recv_timedwait(), recv_n_i(), recvv_n_i(), and t_rcv_n_i(). { return ACE::handle_ready (handle, timeout, 1, 0, 0); }

int ACE::handle_ready (  ACE_HANDLE  handle, const ACE_Time_Value *  timeout, int  read_ready, int  write_ready, int  exception_ready )

Timed wait for handle to get read, write, or exception ready. Definition at line 2176 of file ACE.cpp. References ETIME, ACE_Handle_Set::fdset(), ACE_OS::poll(), ACE_OS::select(), and ACE_Handle_Set::set_bit(). Referenced by handle_exception_ready(), handle_read_ready(), and handle_write_ready(). { #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) ACE_UNUSED_ARG (write_ready); ACE_UNUSED_ARG (exception_ready); struct pollfd fds; fds.fd = handle; fds.events = read_ready ? POLLIN : POLLOUT; fds.revents = 0; int result = ACE_OS::poll (&fds, 1, timeout); #else ACE_Handle_Set handle_set; handle_set.set_bit (handle); // Wait for data or for the timeout to elapse. int select_width; # if defined (ACE_WIN32) // This arg is ignored on Windows and causes pointer truncation // warnings on 64-bit compiles. select_width = 0; # else select_width = int (handle) + 1; # endif /* ACE_WIN64 */ int result = ACE_OS::select (select_width, read_ready ? handle_set.fdset () : 0, // read_fds. write_ready ? handle_set.fdset () : 0, // write_fds. exception_ready ? handle_set.fdset () : 0, // exception_fds. timeout); #endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ switch (result) { case 0: // Timer expired. errno = ETIME; /* FALLTHRU */ case -1: // we got here directly - select() returned -1. return -1; case 1: // Handle has data. /* FALLTHRU */ default: // default is case result > 0; return a // ACE_ASSERT (result == 1); return result; } }

int ACE::handle_timed_accept (  ACE_HANDLE  listener, ACE_Time_Value *  timeout, int  restart )

Wait up to timeout amount of time to passively establish a connection. This method doesn't perform the accept, it just does the timed wait. Definition at line 2665 of file ACE.cpp. References ACE_TRACE, ETIMEDOUT, EWOULDBLOCK, ACE_OS::poll(), ACE_Time_Value::sec(), ACE_OS::select(), ACE_Handle_Set::set_bit(), and ACE_Time_Value::usec(). Referenced by ACE_TLI_Acceptor::accept(), ACE_SPIPE_Acceptor::accept(), ACE_SOCK_SEQPACK_Acceptor::shared_accept_start(), and ACE_SOCK_Acceptor::shared_accept_start(). { ACE_TRACE ("ACE::handle_timed_accept"); // Make sure we don't bomb out on erroneous values. if (listener == ACE_INVALID_HANDLE) return -1; #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) struct pollfd fds; fds.fd = listener; fds.events = POLLIN; fds.revents = 0; #else // Use the select() implementation rather than poll(). ACE_Handle_Set rd_handle; rd_handle.set_bit (listener); #endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ // We need a loop here if <restart> is enabled. for (;;) { #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) int n = ACE_OS::poll (&fds, 1, timeout); #else int select_width; # if defined (ACE_WIN32) // This arg is ignored on Windows and causes pointer truncation // warnings on 64-bit compiles. select_width = 0; # else select_width = int (listener) + 1; # endif /* ACE_WIN32 */ int n = ACE_OS::select (select_width, rd_handle, 0, 0, timeout); #endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ switch (n) { case -1: if (errno == EINTR && restart) continue; else return -1; /* NOTREACHED */ case 0: if (timeout != 0 && timeout->sec () == 0 && timeout->usec () == 0) errno = EWOULDBLOCK; else errno = ETIMEDOUT; return -1; /* NOTREACHED */ case 1: return 0; /* NOTREACHED */ default: errno = EINVAL; return -1; /* NOTREACHED */ } } }

ACE_HANDLE ACE::handle_timed_complete (  ACE_HANDLE  listener, const ACE_Time_Value *  timeout, int  is_tli = 0 )

Wait up to timeout amount of time to complete an actively established non-blocking connection. If is_tli is non-0 then we are being called by a TLI wrapper (which behaves slightly differently from a socket wrapper). Definition at line 2507 of file ACE.cpp. References ACE_TRACE, ECONNREFUSED, ETIME, EWOULDBLOCK, ACE_OS::getsockopt(), ACE_Handle_Set::is_set(), MSG_PEEK, ACE_OS::poll(), recv(), ACE_OS::select(), ACE_Handle_Set::set_bit(), SO_ERROR, and SOL_SOCKET. Referenced by ACE_TLI_Connector::complete(), ACE_SOCK_SEQPACK_Connector::complete(), ACE_SOCK_Connector::complete(), and ACE_SOCK_Connector::shared_connect_finish(). { ACE_TRACE ("ACE::handle_timed_complete"); #if !defined (ACE_WIN32) && defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) struct pollfd fds; fds.fd = h; fds.events = POLLIN | POLLOUT; fds.revents = 0; #else ACE_Handle_Set rd_handles; ACE_Handle_Set wr_handles; rd_handles.set_bit (h); wr_handles.set_bit (h); #endif /* !ACE_WIN32 && ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ #if defined (ACE_WIN32) // Winsock is different - it sets the exception bit for failed connect, // unlike other platforms, where the read bit is set. ACE_Handle_Set ex_handles; ex_handles.set_bit (h); #endif /* ACE_WIN32 */ bool need_to_check = false; bool known_failure = false; #if defined (ACE_WIN32) int n = ACE_OS::select (0, // Ignored on Windows: int (h) + 1, 0, wr_handles, ex_handles, timeout); #else # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) int n = ACE_OS::poll (&fds, 1, timeout); # else int n = ACE_OS::select (int (h) + 1, rd_handles, wr_handles, 0, timeout); # endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ #endif /* ACE_WIN32 */ // If we failed to connect within the time period allocated by the // caller, then we fail (e.g., the remote host might have been too // busy to accept our call). if (n <= 0) { if (n == 0 && timeout != 0) errno = ETIME; return ACE_INVALID_HANDLE; } // Usually, a ready-for-write handle is successfully connected, and // ready-for-read (exception on Win32) is a failure. On fails, we // need to grab the error code via getsockopt. On possible success for // any platform where we can't tell just from select() (e.g. AIX), // we also need to check for success/fail. #if defined (ACE_WIN32) ACE_UNUSED_ARG (is_tli); // On Win32, ex_handle set indicates a failure. We'll do the check // to try and get an errno value, but the connect failed regardless of // what getsockopt says about the error. if (ex_handles.is_set (h)) { need_to_check = true; known_failure = true; } #elif defined (ACE_VXWORKS) ACE_UNUSED_ARG (is_tli); // Force the check on VxWorks. The read handle for "h" is not set, // so "need_to_check" is false at this point. The write handle is // set, for what it's worth. need_to_check = true; #else if (is_tli) # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) need_to_check = (fds.revents & POLLIN) && !(fds.revents & POLLOUT); # else need_to_check = rd_handles.is_set (h) && !wr_handles.is_set (h); # endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ else #if defined(AIX) // AIX is broken... both success and failed connect will set the // write handle only, so always check. need_to_check = true; #else # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT) need_to_check = (fds.revents & POLLIN); # else need_to_check = rd_handles.is_set (h); # endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */ #endif /* AIX */ #endif /* ACE_WIN32 */ if (need_to_check) { #if defined (SOL_SOCKET) && defined (SO_ERROR) int sock_err = 0; int sock_err_len = sizeof (sock_err); int sockopt_ret = ACE_OS::getsockopt (h, SOL_SOCKET, SO_ERROR, (char *)&sock_err, &sock_err_len); if (sockopt_ret < 0) { h = ACE_INVALID_HANDLE; } if (sock_err != 0 || known_failure) { h = ACE_INVALID_HANDLE; errno = sock_err; } #else char dummy; // The following recv() won't block provided that the // ACE_NONBLOCK flag has not been turned off . n = ACE::recv (h, &dummy, 1, MSG_PEEK); // If no data was read/peeked at, check to see if it's because // of a non-connected socket (and therefore an error) or there's // just no data yet. if (n <= 0) { if (n == 0) { errno = ECONNREFUSED; h = ACE_INVALID_HANDLE; } else if (errno != EWOULDBLOCK && errno != EAGAIN) h = ACE_INVALID_HANDLE; } #endif } // 1. The HANDLE is ready for writing and doesn't need to be checked or // 2. recv() returned an indication of the state of the socket - if there is // either data present, or a recv is legit but there's no data yet, // the connection was successfully established. return h; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_HANDLE ACE::handle_timed_open (  ACE_Time_Value *  timeout, const ACE_TCHAR *  name, int  flags, int  perms, LPSECURITY_ATTRIBUTES  sa = 0 )

Wait up to timeout> amount of time to actively open a device. This method doesn't perform the connect, it just does the timed wait. Definition at line 17 of file Handle_Ops.cpp. References ACE_NONBLOCK, ACE_TCHAR, ACE_TRACE, ETIMEDOUT, EWOULDBLOCK, ACE_OS::open(), ACE_Time_Value::sec(), and ACE_Time_Value::usec(). Referenced by ACE_UPIPE_Connector::connect(), ACE_SPIPE_Connector::connect(), ACE_FILE_Connector::connect(), and ACE_DEV_Connector::connect(). { ACE_TRACE ("ACE::handle_timed_open"); if (timeout != 0) { #if !defined (ACE_WIN32) // On Win32, ACE_NONBLOCK gets recognized as O_WRONLY so we // don't use it there flags |= ACE_NONBLOCK; #endif /* ACE_WIN32 */ // Open the named pipe or file using non-blocking mode... ACE_HANDLE const handle = ACE_OS::open (name, flags, perms, sa); if (handle == ACE_INVALID_HANDLE && (errno == EWOULDBLOCK && (timeout->sec () > 0 || timeout->usec () > 0))) // This expression checks if we were polling. errno = ETIMEDOUT; return handle; } else return ACE_OS::open (name, flags, perms, sa); }

ACE_INLINE int ACE::handle_write_ready (  ACE_HANDLE  handle, const ACE_Time_Value *  timeout )

Timed wait for handle to get write ready. Definition at line 252 of file ACE.inl. References handle_ready(). Referenced by enter_send_timedwait(), send_n_i(), sendv_n_i(), and t_snd_n_i(). { return ACE::handle_ready (handle, timeout, 0, 1, 0); }

u_long ACE::hash_pjw (  const wchar_t *  str, size_t  len )

Computes the hash value of {str} using the "Hash PJW" routine. Definition at line 347 of file ACE.cpp. { u_long hash = 0; for (size_t i = 0; i < len; i++) { // @@ UNICODE: Does this function do the correct thing with wchar's? const wchar_t temp = str[i]; hash = (hash << 4) + (temp * 13); u_long g = hash & 0xf0000000; if (g) { hash ^= (g >> 24); hash ^= g; } } return hash; }

u_long ACE::hash_pjw (  const wchar_t *  str  )

Computes the hash value of {str} using the "Hash PJW" routine. Definition at line 371 of file ACE.cpp. References hash_pjw(). { return ACE::hash_pjw (str, ACE_OS::strlen (str)); }

u_long ACE::hash_pjw (  const char *  str, size_t  len )

Computes the hash value of {str} using the "Hash PJW" routine. Definition at line 318 of file ACE.cpp. { u_long hash = 0; for (size_t i = 0; i < len; i++) { const char temp = str[i]; hash = (hash << 4) + (temp * 13); u_long g = hash & 0xf0000000; if (g) { hash ^= (g >> 24); hash ^= g; } } return hash; }

u_long ACE::hash_pjw (  const char *  str  )

Computes the hash value of {str} using the "Hash PJW" routine. Definition at line 340 of file ACE.cpp. Referenced by ACE_Filecache::create(), ACE_Filecache::fetch(), ACE_Filecache::finish(), ACE_UNIX_Addr::hash(), ACE_String_Base< CHAR >::hash(), ACE_SString::hash(), hash_pjw(), ACE_Hash< wchar_t * >::operator()(), ACE_Hash< const wchar_t * >::operator()(), ACE_Hash< char * >::operator()(), ACE_Hash< const char * >::operator()(), and ACE_Filecache::remove(). { return ACE::hash_pjw (str, ACE_OS::strlen (str)); }

ACE_INLINE u_char ACE::hex2byte (  ACE_TCHAR  c  )

Convert a hex character to its byte representation. Definition at line 339 of file ACE.inl. References ACE_OS::ace_isdigit(), ACE_OS::ace_islower(), ACE_TCHAR, and ACE_TEXT. { if (ACE_OS::ace_isdigit (c)) return (u_char) (c - ACE_TEXT ('0')); else if (ACE_OS::ace_islower (c)) return (u_char) (10 + c - ACE_TEXT ('a')); else return (u_char) (10 + c - ACE_TEXT ('A')); }

int ACE::init (  void   )

This class implements the functions for the initialization and shutting down ACE. These functions are called only once per ACE invokation. Returns: Returns 0 on success, -1 on failure, and 1 if it had already been called. Definition at line 15 of file Init_ACE.cpp. References ACE_Object_Manager::init(), and ACE_Object_Manager::instance(). { // Don't use ACE_TRACE, because Object_Manager might not have been // instantiated yet. // ACE_TRACE ("ACE::init"); ++ACE::init_fini_count_; return ACE_Object_Manager::instance ()->init (); }

bool ACE::ipv4_enabled (  void   )

This is an execution-time check. If ACE has not been compiled with ACE_HAS_IPV6, it always returns true. This function tries to create a PF_INET socket, returning true if it succeeds, and false if it fails. Caches the result so it only gets checked once. Definition at line 1617 of file Sock_Connect.cpp. References ace_ipv4_enabled, and PF_INET. { #if defined (ACE_HAS_IPV6) return static_cast<bool> (ace_ipv4_enabled == -1 ? ::ip_check (ace_ipv4_enabled, PF_INET) : ace_ipv4_enabled); #else // Assume it's always enabled since ACE requires some version of // TCP/IP to exist. return true; #endif /* ACE_HAS_IPV6*/ }

int ACE::ipv6_enabled (  void   )

Returns 1 if IPv6 is enabled on the current host; 0 if not. This is an execution-time check. If ACE has not been compiled with ACE_HAS_IPV6, it always returns 0. If ACE_HAS_IPV6 is enabled, this function tries to create a PF_INET6 socket, returning 1 if it succeeds, and 0 if it fails. Caches the result so it only gets checked once. Definition at line 1631 of file Sock_Connect.cpp. References ace_ipv6_enabled. Referenced by ACE_INET_Addr::determine_type(), ACE_SOCK_SEQPACK_Acceptor::open(), ACE_SOCK_Dgram::open(), ACE_SOCK_Acceptor::open(), and ACE_INET_Addr::set(). { #if defined (ACE_HAS_IPV6) return ace_ipv6_enabled == -1 ? ::ip_check (ace_ipv6_enabled, PF_INET6) : ace_ipv6_enabled; #else /* ACE_HAS_IPV6 */ return 0; #endif /* !ACE_HAS_IPV6 */ }

u_long ACE::is_prime (  const u_long  n, const u_long  min_factor, const u_long  max_factor )

Function that can burn up noticeable CPU time: brute-force determination of whether number n is prime. Returns 0 if it is prime, or the smallest factor if it is not prime. min_factor and max_factor can be used to partition the work among threads. For just one thread, typical values are 2 and n/2. Definition at line 2991 of file ACE.cpp. { if (n > 3) for (u_long factor = min_factor; factor <= max_factor; ++factor) if (n / factor * factor == n) return factor; return 0; }

bool ACE::is_sock_error (  int  error  )

Determins whether the given error code corresponds to to a WinSock error. If so returns true, false otherwise. For internal use only. Definition at line 3158 of file ACE.cpp. Referenced by ACE_OS::strerror(). { #if defined (ACE_WIN32) switch (error) { case WSAVERNOTSUPPORTED: case WSASYSNOTREADY: case WSAEINVAL: case WSAHOST_NOT_FOUND: case WSATRY_AGAIN: case WSANO_RECOVERY: case WSANO_DATA: /* case WSANO_ADDRESS: */ case WSANOTINITIALISED: case WSAENETDOWN: case WSAEINPROGRESS: case WSAEINTR: case WSAEAFNOSUPPORT: case WSAEMFILE: case WSAENOBUFS: case WSAEPROTONOSUPPORT: case WSAEPROTOTYPE: case WSAESOCKTNOSUPPORT: case WSAENOTSOCK: case WSAEWOULDBLOCK: case WSAEADDRINUSE: case WSAECONNABORTED: case WSAECONNRESET: case WSAENOTCONN: case WSAETIMEDOUT: case WSAECONNREFUSED: case WSAEHOSTDOWN: case WSAEHOSTUNREACH: case WSAEADDRNOTAVAIL: case WSAEISCONN: case WSAENETRESET: case WSAEMSGSIZE: case WSAENETUNREACH: case WSAEFAULT: case WSAEDISCON: case WSAEACCES: case WSAESHUTDOWN: case WSAEPROCLIM: case WSAEALREADY: case WSAEPFNOSUPPORT: case WSAENOPROTOOPT: case WSATYPE_NOT_FOUND: case WSAEOPNOTSUPP: return true; } #else ACE_UNUSED_ARG (error); #endif /* ACE_WIN32 */ return false; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE::ldfind (  const ACE_TCHAR *  filename, ACE_TCHAR  pathname[], size_t  maxpathnamelen )

Finds the file filename either using an absolute path or using a relative path in conjunction with ACE_LD_SEARCH_PATH (e.g., $LD_LIBRARY_PATH on UNIX or the directories scaned by Win32 API SearchPath on Win32). This function will add appropriate suffix (e.g., .dll on Win32 or .so on UNIX) according to the OS platform. In addition, this function will apply the appropriate prefix (e.g., "lib" on UNIX and "" on Win32) if the filename doesn't match directly. Definition at line 121 of file Lib_Find.cpp. References ACE_OS::access(), ACE_DIRECTORY_SEPARATOR_CHAR, ACE_DLL_PREFIX, ACE_DLL_SUFFIX, ACE_ERROR, ACE_LD_SEARCH_PATH, ACE_LD_SEARCH_PATH_SEPARATOR_STR, ACE_TCHAR, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_ExpandEnvironmentStrings, ACE_TEXT_SearchPath, ACE_TRACE, F_OK, ACE_OS::free(), ACE_OS::getenv(), LM_WARNING, ACE_OS::malloc(), MAXPATHLEN, ACE_OS::sprintf(), ACE_OS::strcasecmp(), ACE_OS::strcat(), ACE_OS::strcmp(), ACE_OS::strcpy(), ACE_OS::strdup(), ACE_OS::strlen(), ACE_OS::strrchr(), strrepl(), and strsplit_r(). Referenced by ldopen(), and ACE_DLL_Handle::open(). { ACE_TRACE ("ACE::ldfind"); #if defined (ACE_OPENVMS) if (ACE_OS::strlen(filename) >= maxpathnamelen) { errno = ENOMEM; return -1; } dsc$descriptor nameDsc; nameDsc.dsc$b_class = DSC$K_CLASS_S; nameDsc.dsc$b_dtype = DSC$K_DTYPE_T; nameDsc.dsc$w_length = ACE_OS::strlen(filename); nameDsc.dsc$a_pointer = (char*)filename; char symbol[] = "NULL"; dsc$descriptor symbolDsc; symbolDsc.dsc$b_class = DSC$K_CLASS_S; symbolDsc.dsc$b_dtype = DSC$K_DTYPE_T; symbolDsc.dsc$w_length = ACE_OS::strlen(symbol); symbolDsc.dsc$a_pointer = symbol; int symbolValue; int result; try { result = LIB$FIND_IMAGE_SYMBOL(&nameDsc, &symbolDsc, &symbolValue, 0, 0); } catch (chf$signal_array& sig) { result = sig.chf$l_sig_name; } int severity = result & STS$M_SEVERITY; int conditionId = result & STS$M_COND_ID; if (severity == STS$K_SUCCESS || severity == STS$K_WARNING || severity == STS$K_INFO || (severity == STS$K_ERROR && conditionId == (LIB$_KEYNOTFOU & STS$M_COND_ID))) { ACE_OS::strcpy(pathname, filename); return 0; } if (ACE_OS::strlen(filename) + ACE_OS::strlen(ACE_DLL_PREFIX) >= maxpathnamelen) { errno = ENOMEM; return -1; } ACE_OS::strcpy(pathname, ACE_DLL_PREFIX); ACE_OS::strcat(pathname, filename); nameDsc.dsc$w_length = ACE_OS::strlen(pathname); nameDsc.dsc$a_pointer = pathname; try { result = LIB$FIND_IMAGE_SYMBOL(&nameDsc, &symbolDsc, &symbolValue, 0, 0); } catch (chf$signal_array& sig) { result = sig.chf$l_sig_name; } severity = result & STS$M_SEVERITY; conditionId = result & STS$M_COND_ID; if (severity == STS$K_SUCCESS || severity == STS$K_WARNING || severity == STS$K_INFO || (severity == STS$K_ERROR && conditionId == (LIB$_KEYNOTFOU & STS$M_COND_ID))) { return 0; } errno = ENOENT; return -1; #endif /* ACE_OPENVMS */ #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) && \ !defined (ACE_HAS_PHARLAP) ACE_TCHAR expanded_filename[MAXPATHLEN]; if (ACE_TEXT_ExpandEnvironmentStrings (filename, expanded_filename, sizeof expanded_filename / sizeof (ACE_TCHAR))) filename = expanded_filename; #endif /* ACE_WIN32 && !ACE_HAS_WINCE && !ACE_HAS_PHARLAP */ ACE_TCHAR tempcopy[MAXPATHLEN + 1]; ACE_TCHAR searchpathname[MAXPATHLEN + 1]; #if defined (ACE_WIN32) && defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) ACE_TCHAR decorator[] = ACE_LD_DECORATOR_STR; ACE_TCHAR searchfilename[MAXPATHLEN + sizeof(decorator) / sizeof (ACE_TCHAR)]; #else ACE_TCHAR searchfilename[MAXPATHLEN + 1]; #endif /* ACE_WIN32 && ACE_LD_DECORATOR_STR && !ACE_DISABLE_DEBUG_DLL_CHECK */ // Create a copy of filename to work with. if (ACE_OS::strlen (filename) + 1 > (sizeof tempcopy / sizeof (ACE_TCHAR))) { errno = ENOMEM; return -1; } else ACE_OS::strcpy (tempcopy, filename); // Insert canonical directory separators. ACE_TCHAR *separator_ptr; #if (ACE_DIRECTORY_SEPARATOR_CHAR != '/') // Make all the directory separators "canonical" to simplify // subsequent code. ACE::strrepl (tempcopy, ACE_DIRECTORY_SEPARATOR_CHAR, '/'); #endif /* ACE_DIRECTORY_SEPARATOR_CHAR */ // Separate filename from pathname. separator_ptr = ACE_OS::strrchr (tempcopy, '/'); // This is a relative path. if (separator_ptr == 0) { searchpathname[0] = '\0'; ACE_OS::strcpy (searchfilename, tempcopy); } else // This is an absolute path. { ACE_OS::strcpy (searchfilename, separator_ptr + 1); separator_ptr[1] = '\0'; ACE_OS::strcpy (searchpathname, tempcopy); } bool has_suffix = false; // Check to see if this has an appropriate DLL suffix for the OS // platform. ACE_TCHAR *s = ACE_OS::strrchr (searchfilename, '.'); const ACE_TCHAR *dll_suffix = ACE_DLL_SUFFIX; if (s != 0) { // If we have a dot, we have a suffix has_suffix = true; // Check whether this matches the appropriate platform-specific // suffix. #if defined (ACE_WIN32) // Use <ACE_OS::strcasecmp> on any platform with // case-insensitive filenames. if (ACE_OS::strcasecmp (s, dll_suffix) != 0) #else if (ACE_OS::strcmp (s, dll_suffix) != 0) #endif /* ACE_WIN32 */ { ACE_ERROR ((LM_WARNING, ACE_TEXT ("Warning: improper suffix for a ") ACE_TEXT ("shared library on this platform: %s\n"), s)); } } // Make sure we've got enough space in searchfilename. if (ACE_OS::strlen (searchfilename) + ACE_OS::strlen (ACE_DLL_PREFIX) + (has_suffix ? 0 : ACE_OS::strlen (dll_suffix)) >= (sizeof searchfilename / sizeof (ACE_TCHAR))) { errno = ENOMEM; return -1; } #if defined (ACE_WIN32) && defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) size_t len_searchfilename = ACE_OS::strlen (searchfilename); if (! has_suffix) ACE_OS::strcpy (searchfilename + len_searchfilename, decorator); for (int tag = 1; tag >= 0; tag --) { if (tag == 0) searchfilename [len_searchfilename] = 0; #endif /* ACE_WIN32 && ACE_LD_DECORATOR_STR && !ACE_DISABLE_DEBUG_DLL_CHECK */ // Use absolute pathname if there is one. if (ACE_OS::strlen (searchpathname) > 0) { if (ACE_OS::strlen (searchfilename) + ACE_OS::strlen (searchpathname) >= maxpathnamelen) { errno = ENOMEM; return -1; } else { #if (ACE_DIRECTORY_SEPARATOR_CHAR != '/') // Revert to native path name separators. ACE::strrepl (searchpathname, '/', ACE_DIRECTORY_SEPARATOR_CHAR); #endif /* ACE_DIRECTORY_SEPARATOR_CHAR */ // First, try matching the filename *without* adding a // prefix. ACE_OS::sprintf (pathname, ACE_TEXT ("%s%s%s"), searchpathname, searchfilename, has_suffix ? ACE_TEXT ("") : dll_suffix); if (ACE_OS::access (pathname, F_OK) == 0) return 0; // Second, try matching the filename *with* adding a prefix. ACE_OS::sprintf (pathname, ACE_TEXT ("%s%s%s%s"), searchpathname, ACE_DLL_PREFIX, searchfilename, has_suffix ? ACE_TEXT ("") : dll_suffix); if (ACE_OS::access (pathname, F_OK) == 0) return 0; } } // Use relative filenames via LD_LIBRARY_PATH or PATH (depending on // OS platform). else { #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_TCHAR *file_component = 0; DWORD pathlen = ACE_TEXT_SearchPath (0, searchfilename, dll_suffix, static_cast<DWORD> (maxpathnamelen), pathname, &file_component); if (pathlen >= maxpathnamelen) { errno = ENOMEM; return -1; } else if (pathlen > 0) return 0; // In case not found we should try again with the ACE_DLL_PREFIX // prefixed ACE_OS::strcpy (searchfilename, ACE_DLL_PREFIX); ACE_OS::strcat (searchfilename, tempcopy); pathlen = ACE_TEXT_SearchPath (0, searchfilename, dll_suffix, static_cast<DWORD> (maxpathnamelen), pathname, &file_component); if (pathlen >= maxpathnamelen) { errno = ENOMEM; return -1; } else if (pathlen > 0) return 0; #else ACE_TCHAR *ld_path; # if defined ACE_DEFAULT_LD_SEARCH_PATH ld_path = ACE_DEFAULT_LD_SEARCH_PATH; # else # if defined (ACE_WIN32) || !defined (ACE_USES_WCHAR) ld_path = ACE_OS::getenv (ACE_LD_SEARCH_PATH); # else // Wide-char, non-Windows only offers char * getenv. So capture // it, translate to wide-char, and continue. ACE_Ascii_To_Wide wide_ldpath (ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (ACE_LD_SEARCH_PATH))); ld_path = wide_ldpath.wchar_rep (); # endif /* ACE_WIN32 || !ACE_USES_WCHAR */ # endif /* ACE_DEFAULT_LD_SEARCH_PATH */ #if defined (ACE_HAS_WINCE) ACE_TCHAR *ld_path_temp = 0; if (ld_path != 0) { ld_path_temp = (ACE_TCHAR *) ACE_OS::malloc ((ACE_OS::strlen (ld_path) + 2) * sizeof (ACE_TCHAR)); if (ld_path_temp != 0) { ACE_OS::strcpy (ld_path_temp, ACE_LD_SEARCH_PATH_SEPARATOR_STR); ACE_OS::strcat (ld_path_temp, ld_path); ld_path = ld_path_temp; } else { ACE_OS::free ((void *) ld_path_temp); ld_path = ld_path_temp = 0; } } #endif /* ACE_HAS_WINCE */ if (ld_path != 0 && (ld_path = ACE_OS::strdup (ld_path)) != 0) { // strtok has the strange behavior of not separating the // string ":/foo:/bar" into THREE tokens. One would expect // that the first iteration the token would be an empty // string, the second iteration would be "/foo", and the // third iteration would be "/bar". However, this is not // the case; one only gets two iterations: "/foo" followed // by "/bar". // This is especially a problem in parsing Unix paths // because it is permissible to specify 'the current // directory' as an empty entry. So, we introduce the // following special code to cope with this: // Look at each dynamic lib directory in the search path. ACE_TCHAR *nextholder = 0; const ACE_TCHAR *path_entry = ACE::strsplit_r (ld_path, ACE_LD_SEARCH_PATH_SEPARATOR_STR, nextholder); int result = 0; for (;;) { // Check if at end of search path. if (path_entry == 0) { errno = ENOENT; result = -1; break; } else if (ACE_OS::strlen (path_entry) + 1 + ACE_OS::strlen (searchfilename) >= maxpathnamelen) { errno = ENOMEM; result = -1; break; } // This works around the issue where a path might have // an empty component indicating 'current directory'. // We need to do it here rather than anywhere else so // that the loop condition will still work. else if (path_entry[0] == '\0') path_entry = ACE_TEXT ("."); // First, try matching the filename *without* adding a // prefix. ACE_OS::sprintf (pathname, ACE_TEXT ("%s%c%s%s"), path_entry, ACE_DIRECTORY_SEPARATOR_CHAR, searchfilename, has_suffix ? ACE_TEXT ("") : dll_suffix); if (ACE_OS::access (pathname, F_OK) == 0) break; // Second, try matching the filename *with* adding a // prefix. ACE_OS::sprintf (pathname, ACE_TEXT ("%s%c%s%s%s"), path_entry, ACE_DIRECTORY_SEPARATOR_CHAR, ACE_DLL_PREFIX, searchfilename, has_suffix ? ACE_TEXT ("") : dll_suffix); if (ACE_OS::access (pathname, F_OK) == 0) break; // Fetch the next item in the path path_entry = ACE::strsplit_r (0, ACE_LD_SEARCH_PATH_SEPARATOR_STR, nextholder); } #if defined (ACE_HAS_WINCE) if (ld_path_temp != 0) ACE_OS::free (ld_path_temp); #endif /* ACE_HAS_WINCE */ ACE_OS::free ((void *) ld_path); #if defined (ACE_HAS_WINCE) && defined (ACE_LD_DECORATOR_STR) && \ !defined (ACE_DISABLE_DEBUG_DLL_CHECK) if (result == 0 || tag == 0) #endif /* ACE_HAS_WINCE && ACE_LD_DECORATOR_STR && !ACE_DISABLE_DEBUG_DLL_CHECK */ return result; } #endif /* ACE_WIN32 && !ACE_HAS_WINCE */ } #if defined (ACE_WIN32) && defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) } #endif /* ACE_WIN32 && ACE_LD_DECORATOR_STR && !ACE_DISABLE_DEBUG_DLL_CHECK */ errno = ENOENT; return -1; }

ACE_TCHAR * ACE::ldname (  const ACE_TCHAR *  entry_point  )

Transforms entry_point into a form that can be located in a dynamic library using . For example, with Win32/Borland extern "C" functions which use the default calling convention have a '_' prepended. Always returns a buffer that has been dynamically allocated using . Definition at line 537 of file Lib_Find.cpp. References ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT, ACE_TRACE, ACE_OS::strcat(), ACE_OS::strcpy(), and ACE_OS::strlen(). { ACE_TRACE ("ACE::ldname"); #if defined(ACE_NEEDS_DL_UNDERSCORE) size_t size = 1 // leading '_' + ACE_OS::strlen (entry_point) + 1; ACE_TCHAR *new_name; ACE_NEW_RETURN (new_name, ACE_TCHAR[size], 0); ACE_OS::strcpy (new_name, ACE_TEXT ("_")); ACE_OS::strcat (new_name, entry_point); return new_name; #else /* ACE_NEEDS_DL_UNDERSCORE */ size_t size = ACE_OS::strlen (entry_point) + 1; ACE_TCHAR *new_name; ACE_NEW_RETURN (new_name, ACE_TCHAR[size], 0); ACE_OS::strcpy (new_name, entry_point); return new_name; #endif /* ACE_NEEDS_DL_UNDERSCORE */ }

FILE * ACE::ldopen (  const ACE_TCHAR *  filename, const ACE_TCHAR *  type )

Uses ldfind to locate and open the appropriate filename and returns a pointer to the file, else it returns a NULL pointer. type specifies how the file should be open. Definition at line 522 of file Lib_Find.cpp. References ACE_TCHAR, ACE_TRACE, ACE_OS::fopen(), ldfind(), and MAXPATHLEN. { ACE_TRACE ("ACE::ldopen"); ACE_TCHAR buf[MAXPATHLEN + 1]; if (ACE::ldfind (filename, buf, sizeof (buf) /sizeof (ACE_TCHAR)) == -1) return 0; else return ACE_OS::fopen (buf, type); }

ACE_INLINE u_long ACE::log2 (  u_long  num  )

Computes the base 2 logarithm of {num}. Definition at line 296 of file ACE.inl. Referenced by ACE_Log_Record::priority(), and ACE_Log_Record::priority_name(). { u_long log = 0; for (; num > 1; ++log) num >>= 1; return log; }

u_int ACE::major_version (  void   )

e.g., the "5" in ACE 5.1.12. Definition at line 107 of file ACE.cpp. References ACE_MAJOR_VERSION. { return ACE_MAJOR_VERSION; }

ACE_INLINE int ACE::map_errno (  int  error  )

Map troublesome win32 errno values to values that standard C strerr function understands. Thank you Microsoft. Definition at line 325 of file ACE.inl. Referenced by ACE_Log_Msg::log(). { #if defined (ACE_WIN32) switch (error) { case WSAEWOULDBLOCK: return EAGAIN; // Same as UNIX errno EWOULDBLOCK. } #endif /* ACE_WIN32 */ return error; }

int ACE::max_handles (  void   )

Returns the maximum number of open handles currently permitted in this process. This maximum may be extended using ACE::set_handle_limit. Definition at line 2843 of file ACE.cpp. References ACE_NOTSUP_RETURN, ACE_TRACE, ACE_OS::getrlimit(), and ACE_OS::sysconf(). Referenced by daemonize(), and set_handle_limit(). { ACE_TRACE ("ACE::max_handles"); #if defined (RLIMIT_NOFILE) && !defined (ACE_LACKS_RLIMIT) rlimit rl; int r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl); # if !defined (RLIM_INFINITY) if (r == 0) return rl.rlim_cur; #else if (r == 0 && rl.rlim_cur != RLIM_INFINITY) return rl.rlim_cur; // If == RLIM_INFINITY, fall through to the ACE_LACKS_RLIMIT sections # endif /* RLIM_INFINITY */ #endif /* RLIMIT_NOFILE && !ACE_LACKS_RLIMIT */ #if defined (_SC_OPEN_MAX) return ACE_OS::sysconf (_SC_OPEN_MAX); #elif defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x620) return maxFiles; #elif defined (FD_SETSIZE) return FD_SETSIZE; #else ACE_NOTSUP_RETURN (-1); #endif /* _SC_OPEN_MAX */ }

u_long ACE::minimum_frame_size (  u_long  period1, u_long  period2 )

Calculates the minimum enclosing frame size for the given values. Definition at line 2948 of file ACE.cpp. References gcd(). { // if one of the periods is zero, treat it as though it as // uninitialized and return the other period as the frame size if (0 == period1) { return period2; } if (0 == period2) { return period1; } // if neither is zero, find the greatest common divisor of the two periods u_long greatest_common_divisor = ACE::gcd (period1, period2); // explicitly consider cases to reduce risk of possible overflow errors if (greatest_common_divisor == 1) { // periods are relative primes: just multiply them together return period1 * period2; } else if (greatest_common_divisor == period1) { // the first period divides the second: return the second return period2; } else if (greatest_common_divisor == period2) { // the second period divides the first: return the first return period1; } else { // the current frame size and the entry's effective period // have a non-trivial greatest common divisor: return the // product of factors divided by those in their gcd. return (period1 * period2) / greatest_common_divisor; } }

u_int ACE::minor_version (  void   )

e.g., the "1" in ACE 5.1.12. Definition at line 113 of file ACE.cpp. References ACE_MINOR_VERSION. { return ACE_MINOR_VERSION; }

ACE_INLINE ACE_TCHAR ACE::nibble2hex (  u_int  n  )

Hex conversion utility. Definition at line 307 of file ACE.inl. References ACE_TCHAR, and ACE_TEXT. { // Hexadecimal characters. #if defined (ACE_VXWORKS) && !defined (__DCPLUSPLUS__) // temporary solution to prevent Windriver GNU toolchains from spewing // loads of warnings when inlining. // problem (incorrect warning leftover from older GNU) has been reported as // TSR to Windriver. const ACE_TCHAR hex_chars[] = ACE_TEXT ("0123456789abcdef"); #else static const ACE_TCHAR hex_chars[] = ACE_TEXT ("0123456789abcdef"); #endif // Yes, this works for UNICODE return hex_chars[n & 0x0f]; }

ACE_HANDLE ACE::open_temp_file (  const ACE_TCHAR *  name, int  mode, int  perm = 0 )

Opening the temp file. File is automagically unlinked when it is closed. This is useful for have temp files. Definition at line 641 of file Lib_Find.cpp. References ACE_TCHAR, ACE_OS::open(), and ACE_OS::unlink(). { #if defined (ACE_WIN32) ACE_UNUSED_ARG (perm); ACE_HANDLE handle = ACE_OS::open (name, mode, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE); #else // Open it. ACE_HANDLE handle = ACE_OS::open (name, mode, perm); #endif /* ACE_WIN32 */ if (handle == ACE_INVALID_HANDLE) return ACE_INVALID_HANDLE; // Unlink it so that the file will be removed automatically when the // process goes away. if (ACE_OS::unlink (name) == -1) return ACE_INVALID_HANDLE; else // Return the handle. return handle; }

int ACE::out_of_handles (  int  error  )

Check if error indicates the process being out of handles (file descriptors). Definition at line 65 of file ACE.cpp. References EADDRNOTAVAIL, ENFILE, ENOBUFS, ENOSYS, ENOTSUP, and EOPNOTSUPP. Referenced by ACE_Handle_Gobbler::consume_handles(). { // EMFILE is common to all platforms. if (error == EMFILE || #if defined (ACE_WIN32) // On Win32, we need to check for ENOBUFS also. error == ENOBUFS || #elif defined (HPUX) // On HPUX, we need to check for EADDRNOTAVAIL also. error == EADDRNOTAVAIL || #elif defined (linux) // On linux, we need to check for ENOENT also. error == ENOENT || // For RedHat5.2, need to check for EINVAL too. error == EINVAL || // Without threads check for EOPNOTSUPP error == EOPNOTSUPP || #elif defined (sun) // On sun, we need to check for ENOSR also. error == ENOSR || // Without threads check for ENOTSUP error == ENOTSUP || #elif defined (__FreeBSD__) // On FreeBSD we need to check for EOPNOTSUPP (LinuxThreads) or // ENOSYS (libc_r threads) also. error == EOPNOTSUPP || error == ENOSYS || #elif defined (__OpenBSD__) // OpenBSD appears to return EBADF. error == EBADF || #elif defined (__sgi) // irix error == ENOTSUP || #elif defined (DIGITAL_UNIX) // osf1 error == ENOTSUP || #endif /* ACE_WIN32 */ error == ENFILE) return 1; else return 0; }

int ACE::process_active (  pid_t  pid  )

Checks if process with {pid} is still alive. Returns 1 if it is still alive, 0 if it isn't alive, and -1 if something weird happened. Definition at line 253 of file ACE.cpp. References ACE_OS::kill(), and pid_t. { #if !defined(ACE_WIN32) int retval = ACE_OS::kill (pid, 0); if (retval == 0) return 1; else if (errno == ESRCH) return 0; else return -1; #else // Create a handle for the given process id. ACE_HANDLE process_handle = ::OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, pid); if (process_handle == ACE_INVALID_HANDLE || process_handle == 0) return 0; else { DWORD status; int result = 1; if (::GetExitCodeProcess (process_handle, &status) == 0 || status != STILL_ACTIVE) result = 0; ::CloseHandle (process_handle); return result; } #endif /* !ACE_WIN32 */ }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ssize_t ACE::read_n (  ACE_HANDLE  handle, void *  buf, size_t  len, size_t *  bytes_transferred = 0 )

Definition at line 17 of file ACE.inl. References ACE_OS::read_n(). Referenced by ACE_SPIPE_Stream::recv_n(), ACE_Pipe::recv_n(), ACE_FILE_IO::recv_n(), and ACE_DEV_IO::recv_n(). { return ACE_OS::read_n (handle, buf, len, bytes_transferred); }

ssize_t ACE::readv_n (  ACE_HANDLE  handle, iovec *  iov, int  iovcnt, size_t *  bytes_transferred = 0 )

Definition at line 2099 of file ACE.cpp. References ACE_OS::readv(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; for (int s = 0; s < iovcnt; ) { ssize_t n = ACE_OS::readv (handle, iov + s, iovcnt - s); if (n == -1 || n == 0) return n; for (bytes_transferred += n; s < iovcnt && n >= static_cast<ssize_t> (iov[s].iov_len); s++) n -= iov[s].iov_len; if (n != 0) { char *base = reinterpret_cast<char *> (iov[s].iov_base); iov[s].iov_base = base + n; iov[s].iov_len = iov[s].iov_len - n; } } return bytes_transferred; }

void ACE::record_and_set_non_blocking_mode (  ACE_HANDLE  handle, int &  val )

This makes sure that handle is set into non-blocking mode. val keeps track of whether were in non-blocking mode or not. Definition at line 2264 of file ACE.cpp. References ACE_BIT_DISABLED, ACE_NONBLOCK, get_flags(), and set_flags(). Referenced by enter_recv_timedwait(), enter_send_timedwait(), recv_n_i(), recvv_n_i(), send_n_i(), sendv_n_i(), t_rcv_n_i(), and t_snd_n_i(). { // We need to record whether we are already *in* nonblocking mode, // so that we can correctly reset the state when we're done. val = ACE::get_flags (handle); if (ACE_BIT_DISABLED (val, ACE_NONBLOCK)) // Set the handle into non-blocking mode if it's not already in // it. ACE::set_flags (handle, ACE_NONBLOCK); }

ssize_t ACE::recv (  ACE_HANDLE  handle, size_t  n, ...  )

Receive into a variable number of pieces. Accepts a variable, caller-specified, number of pointer/length pairs. Arguments following n are char *, size_t pairs. Parameters: handle  The I/O handle to receive on n  The total number of char *, size_t pairs following n. Returns: -1 on error, else total number of bytes received. Definition at line 931 of file ACE.cpp. References ACE_NEW_RETURN, ACE_OS::recvv(), and ssize_t. { va_list argp; int total_tuples = static_cast<int> (n / 2); iovec *iovp; #if defined (ACE_HAS_ALLOCA) iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); #else ACE_NEW_RETURN (iovp, iovec[total_tuples], -1); #endif /* !defined (ACE_HAS_ALLOCA) */ va_start (argp, n); for (int i = 0; i < total_tuples; i++) { iovp[i].iov_base = va_arg (argp, char *); iovp[i].iov_len = va_arg (argp, int); } ssize_t result = ACE_OS::recvv (handle, iovp, total_tuples); #if !defined (ACE_HAS_ALLOCA) delete [] iovp; #endif /* !defined (ACE_HAS_ALLOCA) */ va_end (argp); return result; }

ssize_t ACE::recv (  ACE_HANDLE  handle, void *  buf, size_t  len, const ACE_Time_Value *  timeout = 0 )

Definition at line 500 of file ACE.cpp. References enter_recv_timedwait(), recv_i(), restore_non_blocking_mode(), and ssize_t. { if (timeout == 0) return ACE::recv_i (handle, buf, n); else { int val = 0; if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE::recv_i (handle, buf, n); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ssize_t ACE::recv (  ACE_HANDLE  handle, void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout = 0 )

Definition at line 448 of file ACE.cpp. References enter_recv_timedwait(), ACE_OS::recv(), restore_non_blocking_mode(), and ssize_t. Referenced by ACE_MEM_Acceptor::accept(), handle_timed_complete(), ACE_Select_Reactor_Notify::read_notify_pipe(), ACE_TLI_Stream::recv(), ACE_SOCK_IO::recv(), ACE_SOCK_Stream::recv_urg(), and ACE_SOCK_SEQPACK_Association::recv_urg(). { if (timeout == 0) return ACE_OS::recv (handle, (char *) buf, len, flags); else { int val = 0; if (ACE::enter_recv_timedwait (handle, timeout, val) ==-1) return -1; else { ssize_t bytes_transferred = ACE_OS::recv (handle, (char *) buf, len, flags); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ACE_INLINE ssize_t ACE::recv_i (  ACE_HANDLE  handle, void *  buf, size_t  len )

Definition at line 231 of file ACE.inl. References ACE_OS::read(), and ACE_OS::recv(). Referenced by recv(), and recv_n_i(). { #if defined (ACE_WIN32) || defined (ACE_OPENVMS) || defined (ACE_TANDEM_T1248_PTHREADS) return ACE_OS::recv (handle, (char *) buf, len); #else return ACE_OS::read (handle, (char *) buf, len); #endif /* ACE_WIN32 */ }

ssize_t ACE::recv_n (  ACE_HANDLE  handle, ACE_Message_Block *  message_block, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 1123 of file ACE.cpp. References ACE_IOV_MAX, ACE_Message_Block::cont(), ACE_Message_Block::length(), ACE_Message_Block::next(), ACE_Message_Block::rd_ptr(), recvv_n(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; iovec iov[ACE_IOV_MAX]; int iovcnt = 0; while (message_block != 0) { // Our current message block chain. const ACE_Message_Block *current_message_block = message_block; while (current_message_block != 0) { size_t current_message_block_length = current_message_block->length (); char *this_rd_ptr = current_message_block->rd_ptr (); // Check if this block has any space for incoming data. while (current_message_block_length > 0) { u_long this_chunk_length; if (current_message_block_length > ULONG_MAX) this_chunk_length = ULONG_MAX; else this_chunk_length = static_cast<u_long> (current_message_block_length); // Collect the data in the iovec. iov[iovcnt].iov_base = this_rd_ptr; iov[iovcnt].iov_len = this_chunk_length; current_message_block_length -= this_chunk_length; this_rd_ptr += this_chunk_length; // Increment iovec counter. ++iovcnt; // The buffer is full make a OS call. @@ TODO find a way to // find ACE_IOV_MAX for platforms that do not define it rather // than simply setting ACE_IOV_MAX to some arbitrary value such // as 16. if (iovcnt == ACE_IOV_MAX) { size_t current_transfer = 0; ssize_t result = ACE::recvv_n (handle, iov, iovcnt, timeout, &current_transfer); // Add to total bytes transferred. bytes_transferred += current_transfer; // Errors. if (result == -1 || result == 0) return result; // Reset iovec counter. iovcnt = 0; } } // Select the next message block in the chain. current_message_block = current_message_block->cont (); } // Selection of the next message block chain. message_block = message_block->next (); } // Check for remaining buffers to be sent. This will happen when // ACE_IOV_MAX is not a multiple of the number of message blocks. if (iovcnt != 0) { size_t current_transfer = 0; ssize_t result = ACE::recvv_n (handle, iov, iovcnt, timeout, &current_transfer); // Add to total bytes transferred. bytes_transferred += current_transfer; // Errors. if (result == -1 || result == 0) return result; } // Return total bytes transferred. return bytes_transferred; }

ACE_INLINE ssize_t ACE::recv_n (  ACE_HANDLE  handle, void *  buf, size_t  len, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 91 of file ACE.inl. References recv_n_i(). { if (timeout == 0) return ACE::recv_n_i (handle, buf, len, bytes_transferred); else return ACE::recv_n_i (handle, buf, len, timeout, bytes_transferred); }

ACE_INLINE ssize_t ACE::recv_n (  ACE_HANDLE  handle, void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 41 of file ACE.inl. References recv_n_i(). Referenced by ACE_TLI_Stream::recv_n(), ACE_SOCK_Stream::recv_n(), ACE_SOCK_SEQPACK_Association::recv_n(), ACE_Pipe::recv_n(), ACE_FIFO_Recv::recv_n(), and ACE_DEV_IO::recv_n(). { if (timeout == 0) return ACE::recv_n_i (handle, buf, len, flags, bytes_transferred); else return ACE::recv_n_i (handle, buf, len, flags, timeout, bytes_transferred); }

ssize_t ACE::recv_n_i (  ACE_HANDLE  handle, void *  buf, size_t  len, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 860 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), record_and_set_non_blocking_mode(), recv_i(), restore_non_blocking_mode(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. n = ACE::recv_i (handle, static_cast <char *> (buf) + bytes_transferred, len - bytes_transferred); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_read_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return static_cast<ssize_t> (bytes_transferred); }

ssize_t ACE::recv_n_i (  ACE_HANDLE  handle, void *  buf, size_t  len, size_t *  bytes_transferred )

Definition at line 810 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), recv_i(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. n = ACE::recv_i (handle, static_cast <char *> (buf) + bytes_transferred, len - bytes_transferred); // Check EOF. if (n == 0) { return 0; } // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK) { // Wait for the blocking to subside. int result = ACE::handle_read_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } } return static_cast<ssize_t> (bytes_transferred); }

ssize_t ACE::recv_n_i (  ACE_HANDLE  handle, void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 621 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), record_and_set_non_blocking_mode(), ACE_OS::recv(), restore_non_blocking_mode(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. n = ACE_OS::recv (handle, static_cast <char *> (buf) + bytes_transferred, len - bytes_transferred, flags); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_read_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return static_cast<ssize_t> (bytes_transferred); }

ssize_t ACE::recv_n_i (  ACE_HANDLE  handle, void *  buf, size_t  len, int  flags, size_t *  bytes_transferred )

Definition at line 570 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), ACE_OS::recv(), and ssize_t. Referenced by recv_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) { // Try to transfer as much of the remaining data as possible. n = ACE_OS::recv (handle, static_cast <char *> (buf) + bytes_transferred, len - bytes_transferred, flags); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK) { // Wait for the blocking to subside. int result = ACE::handle_read_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } } return static_cast<ssize_t> (bytes_transferred); }

ssize_t ACE::recvfrom (  ACE_HANDLE  handle, char *  buf, int  len, int  flags, struct sockaddr *  addr, int *  addrlen, const ACE_Time_Value *  timeout = 0 )

Definition at line 544 of file ACE.cpp. References enter_recv_timedwait(), ACE_OS::recvfrom(), restore_non_blocking_mode(), and ssize_t. { if (timeout == 0) return ACE_OS::recvfrom (handle, buf, len, flags, addr, addrlen); else { int val = 0; if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::recvfrom (handle, buf, len, flags, addr, addrlen); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ssize_t ACE::recvmsg (  ACE_HANDLE  handle, struct msghdr *  msg, int  flags, const ACE_Time_Value *  timeout = 0 )

Definition at line 522 of file ACE.cpp. References enter_recv_timedwait(), ACE_OS::recvmsg(), restore_non_blocking_mode(), and ssize_t. { if (timeout == 0) return ACE_OS::recvmsg (handle, msg, flags); else { int val = 0; if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::recvmsg (handle, msg, flags); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ssize_t ACE::recvv (  ACE_HANDLE  handle, iovec *  iov, int  iovcnt, const ACE_Time_Value *  timeout = 0 )

Definition at line 961 of file ACE.cpp. References enter_recv_timedwait(), ACE_OS::recvv(), restore_non_blocking_mode(), and ssize_t. Referenced by ACE_Pipe::recv(), and ACE_SOCK_IO::recvv(). { if (timeout == 0) return ACE_OS::recvv (handle, iov, iovcnt); else { int val = 0; if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::recvv (handle, iov, iovcnt); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ACE_INLINE ssize_t ACE::recvv_n (  ACE_HANDLE  handle, iovec *  iov, int  iovcnt, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 111 of file ACE.inl. References recvv_n_i(). Referenced by recv_n(), ACE_SOCK_Stream::recvv_n(), and ACE_SOCK_SEQPACK_Association::recvv_n(). { if (timeout == 0) return ACE::recvv_n_i (handle, iov, iovcnt, bytes_transferred); else return ACE::recvv_n_i (handle, iov, iovcnt, timeout, bytes_transferred); }

ssize_t ACE::recvv_n_i (  ACE_HANDLE  handle, iovec *  iov, int  iovcnt, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 1045 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), record_and_set_non_blocking_mode(), ACE_OS::recvv(), restore_non_blocking_mode(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (int s = 0; s < iovcnt; ) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. ssize_t n = ACE_OS::recvv (handle, iov + s, iovcnt - s); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_read_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } for (bytes_transferred += n; s < iovcnt && n >= static_cast<ssize_t> (iov[s].iov_len); s++) n -= iov[s].iov_len; if (n != 0) { char *base = reinterpret_cast<char *> (iov[s].iov_base); iov[s].iov_base = base + n; iov[s].iov_len = iov[s].iov_len - n; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return bytes_transferred; }

ssize_t ACE::recvv_n_i (  ACE_HANDLE  handle, iovec *  iov, int  iovcnt, size_t *  bytes_transferred )

Definition at line 983 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), ACE_OS::recvv(), and ssize_t. Referenced by recvv_n(). { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; for (int s = 0; s < iovcnt; ) { // Try to transfer as much of the remaining data as possible. ssize_t n = ACE_OS::recvv (handle, iov + s, iovcnt - s); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK) { // Wait for the blocking to subside. int result = ACE::handle_read_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } for (bytes_transferred += n; s < iovcnt && n >= static_cast<ssize_t> (iov[s].iov_len); s++) n -= iov[s].iov_len; if (n != 0) { char *base = static_cast<char *> (iov[s].iov_base); iov[s].iov_base = base + n; iov[s].iov_len = iov[s].iov_len - n; } } return bytes_transferred; }

void ACE::restore_non_blocking_mode (  ACE_HANDLE  handle, int  val )

Cleanup after a timed operation, restore the appropriate non-blocking status of handle. Definition at line 2278 of file ACE.cpp. References ACE_BIT_DISABLED, ACE_NONBLOCK, and clr_flags(). Referenced by recv(), recv_n_i(), recvfrom(), recvmsg(), recvv(), recvv_n_i(), send(), send_n_i(), sendmsg(), sendto(), sendv(), sendv_n_i(), t_rcv(), t_rcv_n_i(), t_snd(), and t_snd_n_i(). { if (ACE_BIT_DISABLED (val, ACE_NONBLOCK)) { // Save/restore errno. ACE_Errno_Guard error (errno); // Only disable ACE_NONBLOCK if we weren't in non-blocking mode // originally. ACE::clr_flags (handle, ACE_NONBLOCK); } }

size_t ACE::round_to_allocation_granularity (  size_t  len  )

Rounds the request to a multiple of the allocation granularity. Definition at line 2496 of file ACE.cpp. References ACE_TRACE, and ACE_OS::allocation_granularity(). { ACE_TRACE ("ACE::round_to_allocation_granularity"); if (ACE::allocation_granularity_ == 0) ACE::allocation_granularity_ = ACE_OS::allocation_granularity (); return (len + (ACE::allocation_granularity_ - 1)) & ~(ACE::allocation_granularity_ - 1); }

size_t ACE::round_to_pagesize (  size_t  len  )

Rounds the request to a multiple of the page size. Definition at line 2485 of file ACE.cpp. References ACE_TRACE, and ACE_OS::getpagesize(). Referenced by ACE_Shared_Memory_Pool::init_acquire(), ACE_Shared_Memory_Pool::round_up(), ACE_Sbrk_Memory_Pool::round_up(), ACE_MMAP_Memory_Pool::round_up(), and ACE_Local_Memory_Pool::round_up(). { ACE_TRACE ("ACE::round_to_pagesize"); if (ACE::pagesize_ == 0) ACE::pagesize_ = ACE_OS::getpagesize (); return (len + (ACE::pagesize_ - 1)) & ~(ACE::pagesize_ - 1); }

int ACE::select (  int  width, ACE_Handle_Set &  readfds, const ACE_Time_Value *  timeout = 0 )

Wrapper facade for the most common use of select that uses ACE_Handle_Sets. Definition at line 205 of file ACE.cpp. References ACE_Handle_Set::fdset(), ACE_OS::select(), and ACE_Handle_Set::sync(). { int result = ACE_OS::select (width, readfds.fdset (), 0, 0, timeout); #if !defined (ACE_WIN32) if (result > 0) readfds.sync ((ACE_HANDLE) width); #endif /* ACE_WIN32 */ return result; }

int ACE::select (  int  width, ACE_Handle_Set *  readfds, ACE_Handle_Set *  writefds = 0, ACE_Handle_Set *  exceptfds = 0, const ACE_Time_Value *  timeout = 0 )

Wrapper facade for select that uses ACE_Handle_Sets. Definition at line 178 of file ACE.cpp. References ACE_Handle_Set::fdset(), ACE_OS::select(), and ACE_Handle_Set::sync(). { int result = ACE_OS::select (width, readfds ? readfds->fdset () : 0, writefds ? writefds->fdset () : 0, exceptfds ? exceptfds->fdset () : 0, timeout); if (result > 0) { # if !defined (ACE_WIN32) // This isn't needed for Windows... it's a no-op anyway. if (readfds) readfds->sync ((ACE_HANDLE) width); if (writefds) writefds->sync ((ACE_HANDLE) width); if (exceptfds) exceptfds->sync ((ACE_HANDLE) width); #endif /* ACE_WIN32 */ } return result; }

ssize_t ACE::send (  ACE_HANDLE  handle, size_t  n, ...  )

Varargs variant. Definition at line 1706 of file ACE.cpp. References ACE_NEW_RETURN, ACE_OS::sendv(), and ssize_t. { va_list argp; int total_tuples = static_cast<int> (n / 2); iovec *iovp; #if defined (ACE_HAS_ALLOCA) iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); #else ACE_NEW_RETURN (iovp, iovec[total_tuples], -1); #endif /* !defined (ACE_HAS_ALLOCA) */ va_start (argp, n); for (int i = 0; i < total_tuples; i++) { iovp[i].iov_base = va_arg (argp, char *); iovp[i].iov_len = va_arg (argp, int); } ssize_t result = ACE_OS::sendv (handle, iovp, total_tuples); #if !defined (ACE_HAS_ALLOCA) delete [] iovp; #endif /* !defined (ACE_HAS_ALLOCA) */ va_end (argp); return result; }

ssize_t ACE::send (  ACE_HANDLE  handle, const void *  buf, size_t  len, const ACE_Time_Value *  timeout = 0 )

Definition at line 1273 of file ACE.cpp. References enter_send_timedwait(), restore_non_blocking_mode(), send_i(), and ssize_t. { if (timeout == 0) return ACE::send_i (handle, buf, n); else { int val = 0; if (ACE::enter_send_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE::send_i (handle, buf, n); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ssize_t ACE::send (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout = 0 )

Definition at line 1223 of file ACE.cpp. References enter_send_timedwait(), restore_non_blocking_mode(), ACE_OS::send(), and ssize_t. Referenced by ACE_MEM_Acceptor::accept(), ACE_Select_Reactor_Notify::dispatch_notify(), ACE_Select_Reactor_Notify::notify(), ACE_TLI_Stream::send(), ACE_SOCK_IO::send(), ACE_SOCK_Stream::send_urg(), and ACE_SOCK_SEQPACK_Association::send_urg(). { if (timeout == 0) return ACE_OS::send (handle, (const char *) buf, n, flags); else { int val = 0; if (ACE::enter_send_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::send (handle, (const char *) buf, n, flags); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ACE_INLINE ssize_t ACE::send_i (  ACE_HANDLE  handle, const void *  buf, size_t  len )

Definition at line 221 of file ACE.inl. References ACE_OS::send(), and ACE_OS::write(). Referenced by send(), and send_n_i(). { #if defined (ACE_WIN32) || defined (HPUX) return ACE_OS::send (handle, (const char *) buf, len); #else return ACE_OS::write (handle, (const char *) buf, len); #endif /* ACE_WIN32 */ }

ssize_t ACE::send_n (  ACE_HANDLE  handle, const ACE_Message_Block *  message_block, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Send all the message_blocks chained through their next and cont pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty. Definition at line 1999 of file ACE.cpp. References ACE_IOV_MAX, ACE_Message_Block::cont(), ACE_Message_Block::length(), ACE_Message_Block::next(), ACE_Message_Block::rd_ptr(), sendv_n(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; iovec iov[ACE_IOV_MAX]; int iovcnt = 0; while (message_block != 0) { // Our current message block chain. const ACE_Message_Block *current_message_block = message_block; while (current_message_block != 0) { char *this_block_ptr = current_message_block->rd_ptr (); size_t current_message_block_length = current_message_block->length (); // Check if this block has any data to be sent. while (current_message_block_length > 0) { u_long this_chunk_length; if (current_message_block_length > ULONG_MAX) this_chunk_length = ULONG_MAX; else this_chunk_length = static_cast<u_long> (current_message_block_length); // Collect the data in the iovec. iov[iovcnt].iov_base = this_block_ptr; iov[iovcnt].iov_len = this_chunk_length; current_message_block_length -= this_chunk_length; this_block_ptr += this_chunk_length; // Increment iovec counter. ++iovcnt; // The buffer is full make a OS call. @@ TODO find a way to // find ACE_IOV_MAX for platforms that do not define it rather // than simply setting ACE_IOV_MAX to some arbitrary value such // as 16. if (iovcnt == ACE_IOV_MAX) { size_t current_transfer = 0; ssize_t result = ACE::sendv_n (handle, iov, iovcnt, timeout, &current_transfer); // Add to total bytes transferred. bytes_transferred += current_transfer; // Errors. if (result == -1 || result == 0) return result; // Reset iovec counter. iovcnt = 0; } } // Select the next message block in the chain. current_message_block = current_message_block->cont (); } // Selection of the next message block chain. message_block = message_block->next (); } // Check for remaining buffers to be sent. This will happen when // ACE_IOV_MAX is not a multiple of the number of message blocks. if (iovcnt != 0) { size_t current_transfer = 0; ssize_t result = ACE::sendv_n (handle, iov, iovcnt, timeout, &current_transfer); // Add to total bytes transferred. bytes_transferred += current_transfer; // Errors. if (result == -1 || result == 0) return result; } // Return total bytes transferred. return bytes_transferred; }

ACE_INLINE ssize_t ACE::send_n (  ACE_HANDLE  handle, const void *  buf, size_t  len, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 181 of file ACE.inl. References send_n_i(). { if (timeout == 0) return ACE::send_n_i (handle, buf, len, bytes_transferred); else return ACE::send_n_i (handle, buf, len, timeout, bytes_transferred); }

ACE_INLINE ssize_t ACE::send_n (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 131 of file ACE.inl. References send_n_i(). Referenced by ACE_TLI_Stream::send_n(), ACE_SOCK_Stream::send_n(), ACE_SOCK_SEQPACK_Association::send_n(), ACE_Pipe::send_n(), and ACE_FIFO_Send::send_n(). { if (timeout == 0) return ACE::send_n_i (handle, buf, len, flags, bytes_transferred); else return ACE::send_n_i (handle, buf, len, flags, timeout, bytes_transferred); }

ssize_t ACE::send_n_i (  ACE_HANDLE  handle, const void *  buf, size_t  len, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 1636 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), record_and_set_non_blocking_mode(), restore_non_blocking_mode(), send_i(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. n = ACE::send_i (handle, (char *) buf + bytes_transferred, len - bytes_transferred); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_write_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return bytes_transferred; }

ssize_t ACE::send_n_i (  ACE_HANDLE  handle, const void *  buf, size_t  len, size_t *  bytes_transferred )

Definition at line 1587 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), send_i(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. n = ACE::send_i (handle, (char *) buf + bytes_transferred, len - bytes_transferred); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait for the blocking to subside. int result = ACE::handle_write_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } } return bytes_transferred; }

ssize_t ACE::send_n_i (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 1398 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), record_and_set_non_blocking_mode(), restore_non_blocking_mode(), ACE_OS::send(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. n = ACE_OS::send (handle, (char *) buf + bytes_transferred, len - bytes_transferred, flags); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_write_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return bytes_transferred; }

ssize_t ACE::send_n_i (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, size_t *  bytes_transferred )

Definition at line 1343 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), ACE_OS::send(), and ssize_t. Referenced by send_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) { // Try to transfer as much of the remaining data as possible. n = ACE_OS::send (handle, (char *) buf + bytes_transferred, len - bytes_transferred, flags); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. #if defined (ACE_WIN32) if (errno == EWOULDBLOCK) // If enobufs no need to loop #else if (errno == EWOULDBLOCK || errno == ENOBUFS) #endif /* ACE_WIN32 */ { // Wait for the blocking to subside. int result = ACE::handle_write_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } } return bytes_transferred; }

ssize_t ACE::sendmsg (  ACE_HANDLE  handle, const struct msghdr *  msg, int  flags, const ACE_Time_Value *  timeout = 0 )

Definition at line 1295 of file ACE.cpp. References enter_send_timedwait(), restore_non_blocking_mode(), ACE_OS::sendmsg(), and ssize_t. { if (timeout == 0) return ACE_OS::sendmsg (handle, msg, flags); else { int val = 0; if (ACE::enter_send_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::sendmsg (handle, msg, flags); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ssize_t ACE::sendto (  ACE_HANDLE  handle, const char *  buf, int  len, int  flags, const struct sockaddr *  addr, int  addrlen, const ACE_Time_Value *  timeout = 0 )

Definition at line 1317 of file ACE.cpp. References enter_send_timedwait(), restore_non_blocking_mode(), ACE_OS::sendto(), and ssize_t. { if (timeout == 0) return ACE_OS::sendto (handle, buf, len, flags, addr, addrlen); else { int val = 0; if (ACE::enter_send_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::sendto (handle, buf, len, flags, addr, addrlen); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ssize_t ACE::sendv (  ACE_HANDLE  handle, const iovec *  iov, int  iovcnt, const ACE_Time_Value *  timeout = 0 )

Definition at line 1736 of file ACE.cpp. References enter_send_timedwait(), restore_non_blocking_mode(), ACE_OS::sendv(), and ssize_t. Referenced by ACE_Pipe::send(), and ACE_SOCK_IO::sendv(). { if (timeout == 0) return ACE_OS::sendv (handle, iov, iovcnt); else { int val = 0; if (ACE::enter_send_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::sendv (handle, iov, iovcnt); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ACE_INLINE ssize_t ACE::sendv_n (  ACE_HANDLE  handle, const iovec *  iov, int  iovcnt, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 201 of file ACE.inl. References sendv_n_i(). Referenced by send_n(), ACE_SOCK_Stream::sendv_n(), ACE_SOCK_SEQPACK_Association::sendv_n(), and ACE_Pipe::sendv_n(). { if (timeout == 0) return ACE::sendv_n_i (handle, iov, iovcnt, bytes_transferred); else return ACE::sendv_n_i (handle, iov, iovcnt, timeout, bytes_transferred); }

ssize_t ACE::sendv_n_i (  ACE_HANDLE  handle, const iovec *  iov, int  iovcnt, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 1822 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), record_and_set_non_blocking_mode(), restore_non_blocking_mode(), ACE_OS::sendv(), and ssize_t. { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); iovec *iov = const_cast<iovec *> (i); for (int s = 0; s < iovcnt; ) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. ssize_t n = ACE_OS::sendv (handle, iov + s, iovcnt - s); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_write_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } for (bytes_transferred += n; s < iovcnt && n >= static_cast<ssize_t> (iov[s].iov_len); s++) n -= iov[s].iov_len; if (n != 0) { char *base = reinterpret_cast<char *> (iov[s].iov_base); iov[s].iov_base = base + n; iov[s].iov_len = iov[s].iov_len - n; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return bytes_transferred; }

ssize_t ACE::sendv_n_i (  ACE_HANDLE  handle, const iovec *  iov, int  iovcnt, size_t *  bytes_transferred )

Definition at line 1758 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), ACE_OS::sendv(), and ssize_t. Referenced by sendv_n(). { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; iovec *iov = const_cast<iovec *> (i); for (int s = 0; s < iovcnt; ) { // Try to transfer as much of the remaining data as possible. ssize_t n = ACE_OS::sendv (handle, iov + s, iovcnt - s); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait for the blocking to subside. int result = ACE::handle_write_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } for (bytes_transferred += n; s < iovcnt && n >= static_cast<ssize_t> (iov[s].iov_len); s++) n -= iov[s].iov_len; if (n != 0) { char *base = reinterpret_cast<char *> (iov[s].iov_base); iov[s].iov_base = base + n; iov[s].iov_len = iov[s].iov_len - n; } } return bytes_transferred; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE::set_flags (  ACE_HANDLE  handle, int  flags )

Set flags associated with handle. Definition at line 27 of file Flag_Manip.cpp. References ACE_NONBLOCK, ACE_NOTSUP_RETURN, ACE_SET_BITS, ACE_TRACE, F_GETFL, ACE_OS::fcntl(), and ACE_OS::ioctl(). Referenced by ACE_IPC_SAP::enable(), ACE_IO_SAP::enable(), ACE_Select_Reactor_Notify::open(), record_and_set_non_blocking_mode(), ACE_SOCK_SEQPACK_Acceptor::shared_accept_start(), and ACE_SOCK_Acceptor::shared_accept_start(). { ACE_TRACE ("ACE::set_flags"); #if defined (ACE_LACKS_FCNTL) switch (flags) { case ACE_NONBLOCK: // nonblocking argument (1) // blocking: (0) { int nonblock = 1; return ACE_OS::ioctl (handle, FIONBIO, &nonblock); } default: ACE_NOTSUP_RETURN (-1); } #else int val = ACE_OS::fcntl (handle, F_GETFL, 0); if (val == -1) return -1; // Turn on flags. ACE_SET_BITS (val, flags); if (ACE_OS::fcntl (handle, F_SETFL, val) == -1) return -1; else return 0; #endif /* ACE_LACKS_FCNTL */ }

int ACE::set_handle_limit (  int  new_limit = -1, int  increase_limit_only = 0 )

Reset the limit on the number of open handles. If new_limit == -1 set the limit to the maximum allowable. Otherwise, set the limit value to new_limit. If increase_limit_only is non-0 then only allow increases to the limit. Definition at line 2876 of file ACE.cpp. References ACE_NOTSUP_RETURN, ACE_TRACE, ACE_OS::getrlimit(), max_handles(), ACE_OS::memset(), and ACE_OS::setrlimit(). { ACE_TRACE ("ACE::set_handle_limit"); int cur_limit = ACE::max_handles (); int max_limit = cur_limit; if (cur_limit == -1) return -1; #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE) struct rlimit rl; ACE_OS::memset ((void *) &rl, 0, sizeof rl); int r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl); if (r == 0) max_limit = rl.rlim_max; #endif /* ACE_LACKS_RLIMIT */ if (new_limit == -1) new_limit = max_limit; if (new_limit < 0) { errno = EINVAL; return -1; } else if (new_limit > cur_limit) { // Increase the limit. #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE) rl.rlim_cur = new_limit; return ACE_OS::setrlimit (RLIMIT_NOFILE, &rl); #else // Must return EINVAL errno. ACE_NOTSUP_RETURN (-1); #endif /* ACE_LACKS_RLIMIT */ } else if (increase_limit_only == 0) { // Decrease the limit. #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE) rl.rlim_cur = new_limit; return ACE_OS::setrlimit (RLIMIT_NOFILE, &rl); #else // We give a chance to platforms without RLIMIT to work. // Instead of ACE_NOTSUP_RETURN (0), just return 0 because // new_limit is <= cur_limit, so it's a no-op. return 0; #endif /* ACE_LACKS_RLIMIT */ } return 0; }

const ACE_TCHAR * ACE::sock_error (  int  error  )

Returns a string containing the error message corresponding to a WinSock error. This works around an omission in the Win32 API. For internal use only. Definition at line 3006 of file ACE.cpp. References ACE_NOTSUP_RETURN, ACE_TCHAR, ACE_TEXT, and ACE_OS::sprintf(). Referenced by ACE_Log_Msg::log(), and ACE_OS::strerror(). { #if defined (ACE_WIN32) static ACE_TCHAR unknown_msg[64]; switch (error) { case WSAVERNOTSUPPORTED: return ACE_TEXT ("version of WinSock not supported"); /* NOTREACHED */ case WSASYSNOTREADY: return ACE_TEXT ("WinSock not present or not responding"); /* NOTREACHED */ case WSAEINVAL: return ACE_TEXT ("app version not supported by DLL"); /* NOTREACHED */ case WSAHOST_NOT_FOUND: return ACE_TEXT ("Authoritive: Host not found"); /* NOTREACHED */ case WSATRY_AGAIN: return ACE_TEXT ("Non-authoritive: host not found or server failure"); /* NOTREACHED */ case WSANO_RECOVERY: return ACE_TEXT ("Non-recoverable: refused or not implemented"); /* NOTREACHED */ case WSANO_DATA: return ACE_TEXT ("Valid name, no data record for type"); /* NOTREACHED */ /* case WSANO_ADDRESS: return "Valid name, no MX record"; */ case WSANOTINITIALISED: return ACE_TEXT ("WSA Startup not initialized"); /* NOTREACHED */ case WSAENETDOWN: return ACE_TEXT ("Network subsystem failed"); /* NOTREACHED */ case WSAEINPROGRESS: return ACE_TEXT ("Blocking operation in progress"); /* NOTREACHED */ case WSAEINTR: return ACE_TEXT ("Blocking call cancelled"); /* NOTREACHED */ case WSAEAFNOSUPPORT: return ACE_TEXT ("address family not supported"); /* NOTREACHED */ case WSAEMFILE: return ACE_TEXT ("no file handles available"); /* NOTREACHED */ case WSAENOBUFS: return ACE_TEXT ("no buffer space available"); /* NOTREACHED */ case WSAEPROTONOSUPPORT: return ACE_TEXT ("specified protocol not supported"); /* NOTREACHED */ case WSAEPROTOTYPE: return ACE_TEXT ("protocol wrong type for this socket"); /* NOTREACHED */ case WSAESOCKTNOSUPPORT: return ACE_TEXT ("socket type not supported for address family"); /* NOTREACHED */ case WSAENOTSOCK: return ACE_TEXT ("handle is not a socket"); /* NOTREACHED */ case WSAEWOULDBLOCK: return ACE_TEXT ("resource temporarily unavailable"); /* NOTREACHED */ case WSAEADDRINUSE: return ACE_TEXT ("address already in use"); /* NOTREACHED */ case WSAECONNABORTED: return ACE_TEXT ("connection aborted"); /* NOTREACHED */ case WSAECONNRESET: return ACE_TEXT ("connection reset"); /* NOTREACHED */ case WSAENOTCONN: return ACE_TEXT ("not connected"); /* NOTREACHED */ case WSAETIMEDOUT: return ACE_TEXT ("connection timed out"); /* NOTREACHED */ case WSAECONNREFUSED: return ACE_TEXT ("connection refused"); /* NOTREACHED */ case WSAEHOSTDOWN: return ACE_TEXT ("host down"); /* NOTREACHED */ case WSAEHOSTUNREACH: return ACE_TEXT ("host unreachable"); /* NOTREACHED */ case WSAEADDRNOTAVAIL: return ACE_TEXT ("address not available"); /* NOTREACHED */ case WSAEISCONN: return ACE_TEXT ("socket is already connected"); /* NOTREACHED */ case WSAENETRESET: return ACE_TEXT ("network dropped connection on reset"); /* NOTREACHED */ case WSAEMSGSIZE: return ACE_TEXT ("message too long"); /* NOTREACHED */ case WSAENETUNREACH: return ACE_TEXT ("network is unreachable"); /* NOTREACHED */ case WSAEFAULT: return ACE_TEXT ("bad address"); /* NOTREACHED */ case WSAEDISCON: return ACE_TEXT ("graceful shutdown in progress"); /* NOTREACHED */ case WSAEACCES: return ACE_TEXT ("permission denied"); /* NOTREACHED */ case WSAESHUTDOWN: return ACE_TEXT ("cannot send after socket shutdown"); /* NOTREACHED */ case WSAEPROCLIM: return ACE_TEXT ("too many processes"); /* NOTREACHED */ case WSAEALREADY: return ACE_TEXT ("operation already in progress"); /* NOTREACHED */ case WSAEPFNOSUPPORT: return ACE_TEXT ("protocol family not supported"); /* NOTREACHED */ case WSAENOPROTOOPT: return ACE_TEXT ("bad protocol option"); /* NOTREACHED */ case WSATYPE_NOT_FOUND: return ACE_TEXT ("class type not found"); /* NOTREACHED */ case WSAEOPNOTSUPP: return ACE_TEXT ("operation not supported"); /* NOTREACHED */ case WSAEDESTADDRREQ: return ACE_TEXT ("destination address required"); /* NOTREACHED */ default: ACE_OS::sprintf (unknown_msg, ACE_TEXT ("unknown error: %d"), error); return unknown_msg; /* NOTREACHED */ } #else ACE_UNUSED_ARG (error); ACE_NOTSUP_RETURN (0); #endif /* ACE_WIN32 */ }

ACE_INLINE void ACE::strdelete (  wchar_t *  s  )

Definition at line 281 of file ACE.inl. { delete [] s; }

ACE_INLINE void ACE::strdelete (  char *  s  )

Delete the memory allocated by strnew. Definition at line 274 of file ACE.inl. Referenced by ACE_Process_Options::command_line_argv(), ACE_Service_Type_Impl::name(), ACE_Framework_Component::~ACE_Framework_Component(), and ACE_Process_Options::~ACE_Process_Options(). { delete [] s; }

const wchar_t * ACE::strend (  const wchar_t *  s  )

Definition at line 3316 of file ACE.cpp. References ACE_TEXT_WIDE. { while (*s++ != ACE_TEXT_WIDE ('\0')) continue; return s; }

const char * ACE::strend (  const char *  s  )

Returns a pointer to the "end" of the string, i.e., the character past the ''. Definition at line 3306 of file ACE.cpp. { while (*s++ != '\0') continue; return s; }

ACE_TCHAR * ACE::strenvdup (  const ACE_TCHAR *  str  )

Return a dynamically allocated duplicate of str, substituting the environment variable if str[0] == '$'. Note that the pointer is allocated with ACE_OS::malloc and must be freed by ACE_OS::free. Definition at line 379 of file ACE.cpp. References ACE_TCHAR, ACE_TRACE, and ACE_OS::strenvdup(). { ACE_TRACE ("ACE::strenvdup"); return ACE_OS::strenvdup (str); }

wchar_t * ACE::strndup (  const wchar_t *  str, size_t  n )

Definition at line 3239 of file ACE.cpp. References ACE_ALLOCATOR_RETURN, and ACE_OS::strsncpy(). { const wchar_t *t = str; size_t len; // Figure out how long this string is (remember, it might not be // NUL-terminated). for (len = 0; len < n && *t++ != '\0'; len++) continue; wchar_t *s; ACE_ALLOCATOR_RETURN (s, static_cast<wchar_t *> ( ACE_OS::malloc ((len + 1) * sizeof (wchar_t))), 0); return ACE_OS::strsncpy (s, str, len + 1); }

char * ACE::strndup (  const char *  str, size_t  n )

Create a fresh new copy of str, up to n chars long. Uses ACE_OS::malloc to allocate the new string. Definition at line 3217 of file ACE.cpp. References ACE_ALLOCATOR_RETURN, and ACE_OS::strsncpy(). { const char *t = str; size_t len; // Figure out how long this string is (remember, it might not be // NUL-terminated). for (len = 0; len < n && *t++ != '\0'; len++) continue; char *s; ACE_ALLOCATOR_RETURN (s, (char *) ACE_OS::malloc (len + 1), 0); return ACE_OS::strsncpy (s, str, len + 1); }

wchar_t * ACE::strnew (  const wchar_t *  s  )

Definition at line 3342 of file ACE.cpp. References ACE_NEW_RETURN, and ACE_OS::strcpy(). { if (s == 0) return 0; wchar_t *t = 0; ACE_NEW_RETURN (t, wchar_t[ACE_OS::strlen (s) + 1], 0); if (t == 0) return 0; else return ACE_OS::strcpy (t, s); }

char * ACE::strnew (  const char *  s  )

This method is just like strdup, except that it uses operator new rather than malloc. If s is NULL returns NULL rather than segfaulting. Definition at line 3326 of file ACE.cpp. References ACE_NEW_RETURN, and ACE_OS::strcpy(). Referenced by ACE_Logging_Strategy::ACE_Logging_Strategy(), ACE_Process_Options::command_line_argv(), ACE_MEM_Acceptor::mmap_prefix(), ACE_Service_Type_Impl::name(), ACE_Service_Type::name(), ACE_DLL_Handle::open(), ACE_DLL::open_i(), and ACE_Logging_Strategy::parse_args(). { if (s == 0) return 0; char *t = 0; ACE_NEW_RETURN (t, char [ACE_OS::strlen (s) + 1], 0); if (t == 0) return 0; else return ACE_OS::strcpy (t, s); }

wchar_t * ACE::strnnew (  const wchar_t *  str, size_t  n )

Definition at line 3284 of file ACE.cpp. References ACE_NEW_RETURN, ACE_TEXT_WIDE, and ACE_OS::strsncpy(). { const wchar_t *t = str; size_t len; // Figure out how long this string is (remember, it might not be // NUL-terminated). for (len = 0; len < n && *t++ != ACE_TEXT_WIDE ('\0'); len++) continue; wchar_t *s; ACE_NEW_RETURN (s, wchar_t[len + 1], 0); return ACE_OS::strsncpy (s, str, len + 1); }

char * ACE::strnnew (  const char *  str, size_t  n )

Create a fresh new copy of str, up to n chars long. Uses ACE_OS::malloc to allocate the new string. Definition at line 3262 of file ACE.cpp. References ACE_NEW_RETURN, and ACE_OS::strsncpy(). { const char *t = str; size_t len; // Figure out how long this string is (remember, it might not be // NUL-terminated). for (len = 0; len < n && *t++ != L'\0'; len++) continue; char *s; ACE_NEW_RETURN (s, char[len + 1], 0); return ACE_OS::strsncpy (s, str, len + 1); }

size_t ACE::strrepl (  wchar_t *  s, wchar_t  search, wchar_t  replace )

As strrepl, but for wide characters. Definition at line 756 of file Lib_Find.cpp. References ACE_TRACE. { ACE_TRACE ("ACE::strrepl"); size_t replaced = 0; for (size_t i = 0; s[i] != '\0'; i++) if (s[i] == search) { s[i] = replace; replaced++; } return replaced; }

size_t ACE::strrepl (  char *  s, char  search, char  replace )

Replace all instances of search in s with replace. Returns the number of replacements made. Definition at line 668 of file Lib_Find.cpp. References ACE_TRACE. Referenced by ldfind(). { ACE_TRACE ("ACE::strrepl"); size_t replaced = 0; for (size_t i = 0; s[i] != '\0'; i++) if (s[i] == search) { s[i] = replace; replaced++; } return replaced; }

wchar_t * ACE::strsplit_r (  wchar_t *  s, const wchar_t *  token, wchar_t *&  next_start )

As strsplit_r, but for wide characters. Definition at line 723 of file Lib_Find.cpp. References ACE_OS::strlen(), and ACE_OS::strstr(). { wchar_t *result = 0; if (str != 0) next_start = str; if (next_start != 0) { wchar_t *tok_loc = ACE_OS::strstr (next_start, token); if (tok_loc != 0) { // Return the beginning of the string. result = next_start; // Insure it's terminated. *tok_loc = '\0'; next_start = tok_loc + ACE_OS::strlen (token); } else { result = next_start; next_start = (wchar_t *) 0; } } return result; }

char * ACE::strsplit_r (  char *  s, const char *  token, char *&  next_start )

Splits string into pieces separated by the string . is an opaque cookie handed back by the call to store its state for the next invocation, thus making it re-entrant. This operates very similar to Perl's function except that it returns pieces one at a time instead of into an array. Definition at line 689 of file Lib_Find.cpp. References ACE_OS::strlen(), and ACE_OS::strstr(). Referenced by ldfind(). { char *result = 0; if (str != 0) next_start = str; if (next_start != 0) { char *tok_loc = ACE_OS::strstr (next_start, token); if (tok_loc != 0) { // Return the beginning of the string. result = next_start; // Insure it's terminated. *tok_loc = '\0'; next_start = tok_loc + ACE_OS::strlen (token); } else { result = next_start; next_start = (char *) 0; } } return result; }

ssize_t ACE::t_rcv (  ACE_HANDLE  handle, void *  buf, size_t  len, int *  flags, const ACE_Time_Value *  timeout = 0 )

Definition at line 474 of file ACE.cpp. References enter_recv_timedwait(), restore_non_blocking_mode(), ssize_t, and ACE_OS::t_rcv(). Referenced by ACE_TLI_Stream::recv(). { if (timeout == 0) return ACE_OS::t_rcv (handle, (char *) buf, len, flags); else { int val = 0; if (ACE::enter_recv_timedwait (handle, timeout, val) ==-1) return -1; else { ssize_t bytes_transferred = ACE_OS::t_rcv (handle, (char *) buf, len, flags); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ACE_INLINE ssize_t ACE::t_rcv_n (  ACE_HANDLE  handle, void *  buf, size_t  len, int *  flags, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 66 of file ACE.inl. References t_rcv_n_i(). Referenced by ACE_TLI_Stream::recv_n(). { if (timeout == 0) return ACE::t_rcv_n_i (handle, buf, len, flags, bytes_transferred); else return ACE::t_rcv_n_i (handle, buf, len, flags, timeout, bytes_transferred); }

ssize_t ACE::t_rcv_n_i (  ACE_HANDLE  handle, void *  buf, size_t  len, int *  flags, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 741 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), record_and_set_non_blocking_mode(), restore_non_blocking_mode(), ssize_t, and ACE_OS::t_rcv(). { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. n = ACE_OS::t_rcv (handle, (char *) buf + bytes_transferred, len - bytes_transferred, flags); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_read_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return bytes_transferred; }

ssize_t ACE::t_rcv_n_i (  ACE_HANDLE  handle, void *  buf, size_t  len, int *  flags, size_t *  bytes_transferred )

Definition at line 690 of file ACE.cpp. References EWOULDBLOCK, handle_read_ready(), ssize_t, and ACE_OS::t_rcv(). Referenced by t_rcv_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) { // Try to transfer as much of the remaining data as possible. n = ACE_OS::t_rcv (handle, (char *) buf + bytes_transferred, len - bytes_transferred, flags); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK) { // Wait for the blocking to subside. int result = ACE::handle_read_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } } return bytes_transferred; }

ssize_t ACE::t_snd (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout = 0 )

Definition at line 1248 of file ACE.cpp. References enter_send_timedwait(), restore_non_blocking_mode(), ssize_t, and ACE_OS::t_snd(). Referenced by ACE_TLI_Stream::send(). { if (timeout == 0) return ACE_OS::t_snd (handle, (const char *) buf, n, flags); else { int val = 0; if (ACE::enter_send_timedwait (handle, timeout, val) == -1) return -1; else { ssize_t bytes_transferred = ACE_OS::t_snd (handle, (const char *) buf, n, flags); ACE::restore_non_blocking_mode (handle, val); return bytes_transferred; } } }

ACE_INLINE ssize_t ACE::t_snd_n (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout = 0, size_t *  bytes_transferred = 0 )

Definition at line 156 of file ACE.inl. References t_snd_n_i(). Referenced by ACE_TLI_Stream::send_n(). { if (timeout == 0) return ACE::t_snd_n_i (handle, buf, len, flags, bytes_transferred); else return ACE::t_snd_n_i (handle, buf, len, flags, timeout, bytes_transferred); }

ssize_t ACE::t_snd_n_i (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, const ACE_Time_Value *  timeout, size_t *  bytes_transferred )

Definition at line 1518 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), record_and_set_non_blocking_mode(), restore_non_blocking_mode(), ssize_t, and ACE_OS::t_snd(). { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; ssize_t n; ssize_t result = 0; int error = 0; int val = 0; ACE::record_and_set_non_blocking_mode (handle, val); for (bytes_transferred = 0; bytes_transferred < len; bytes_transferred += n) { // Try to transfer as much of the remaining data as possible. // Since the socket is in non-blocking mode, this call will not // block. n = ACE_OS::t_snd (handle, (char *) buf + bytes_transferred, len - bytes_transferred, flags); // Check for errors. if (n == 0 || n == -1) { // Check for possible blocking. if (n == -1 && errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait upto <timeout> for the blocking to subside. int rtn = ACE::handle_write_ready (handle, timeout); // Did select() succeed? if (rtn != -1) { // Blocking subsided in <timeout> period. Continue // data transfer. n = 0; continue; } } // Wait in select() timed out or other data transfer or // select() failures. error = 1; result = n; break; } } ACE::restore_non_blocking_mode (handle, val); if (error) return result; else return bytes_transferred; }

ssize_t ACE::t_snd_n_i (  ACE_HANDLE  handle, const void *  buf, size_t  len, int  flags, size_t *  bytes_transferred )

Definition at line 1467 of file ACE.cpp. References ENOBUFS, EWOULDBLOCK, handle_write_ready(), ssize_t, and ACE_OS::t_snd(). Referenced by t_snd_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) { // Try to transfer as much of the remaining data as possible. n = ACE_OS::t_snd (handle, (char *) buf + bytes_transferred, len - bytes_transferred, flags); // Check EOF. if (n == 0) return 0; // Check for other errors. if (n == -1) { // Check for possible blocking. if (errno == EWOULDBLOCK || errno == ENOBUFS) { // Wait for the blocking to subside. int result = ACE::handle_write_ready (handle, 0); // Did select() succeed? if (result != -1) { // Blocking subsided. Continue data transfer. n = 0; continue; } } // Other data transfer or select() failures. return -1; } } return bytes_transferred; }

int ACE::terminate_process (  pid_t  pid  )

Terminate the process abruptly with id pid. On Win32 platforms this uses {TerminateProcess} and on POSIX platforms is uses {kill} with the -9 (SIGKILL) signal, which cannot be caught or ignored. Note that this call is potentially dangerous to use since the process being terminated may not have a chance to cleanup before it shuts down. Definition at line 223 of file ACE.cpp. References ACE_NOTSUP_RETURN, ACE_OS::close(), ACE_OS::kill(), and pid_t. Referenced by ACE_Process_Manager::terminate(), and ACE_Process::terminate(). { #if defined (ACE_HAS_PHARLAP) ACE_UNUSED_ARG (pid); ACE_NOTSUP_RETURN (-1); #elif defined (ACE_WIN32) // Create a handle for the given process id. ACE_HANDLE process_handle = ::OpenProcess (PROCESS_TERMINATE, FALSE, // New handle is not inheritable. pid); if (process_handle == ACE_INVALID_HANDLE || process_handle == 0) return -1; else { // Kill the process associated with process_handle. BOOL terminate_result = ::TerminateProcess (process_handle, 0); // Free up the kernel resources. ACE_OS::close (process_handle); return terminate_result ? 0 : -1; } #else return ACE_OS::kill (pid, 9); #endif /* ACE_HAS_PHARLAP */ }

ACE_TCHAR * ACE::timestamp (  ACE_TCHAR  date_and_time[], int  time_len, int  return_pointer_to_first_digit = 0 )

Returns the current timestamp in the form "hour:minute:second:microsecond." The month, day, and year are also stored in the beginning of the date_and_time array, which is a user-supplied array of size time_len> ACE_TCHARs. Returns 0 if unsuccessful, else returns pointer to beginning of the "time" portion of date_and_time. If return_pointer_to_first_digit is 0 then return a pointer to the space before the time, else return a pointer to the beginning of the time portion. Definition at line 2392 of file ACE.cpp. References ACE_TCHAR, ACE_TEXT, ACE_OS::ctime_r(), ACE_OS::gettimeofday(), ACE_Time_Value::sec(), ACE_OS::sprintf(), ACE_OS::strsncpy(), and ACE_Time_Value::usec(). Referenced by ACE_Log_Msg_UNIX_Syslog::log(), and ACE_Log_Msg::log(). { //ACE_TRACE ("ACE::timestamp"); if (date_and_timelen < 35) { errno = EINVAL; return 0; } #if defined (WIN32) // Emulate Unix. Win32 does NOT support all the UNIX versions // below, so DO we need this ifdef. static const ACE_TCHAR *day_of_week_name[] = { ACE_TEXT ("Sun"), ACE_TEXT ("Mon"), ACE_TEXT ("Tue"), ACE_TEXT ("Wed"), ACE_TEXT ("Thu"), ACE_TEXT ("Fri"), ACE_TEXT ("Sat") }; static const ACE_TCHAR *month_name[] = { ACE_TEXT ("Jan"), ACE_TEXT ("Feb"), ACE_TEXT ("Mar"), ACE_TEXT ("Apr"), ACE_TEXT ("May"), ACE_TEXT ("Jun"), ACE_TEXT ("Jul"), ACE_TEXT ("Aug"), ACE_TEXT ("Sep"), ACE_TEXT ("Oct"), ACE_TEXT ("Nov"), ACE_TEXT ("Dec") }; SYSTEMTIME local; ::GetLocalTime (&local); ACE_OS::sprintf (date_and_time, ACE_TEXT ("%3s %3s %2d %04d %02d:%02d:%02d.%06d"), day_of_week_name[local.wDayOfWeek], month_name[local.wMonth - 1], (int) local.wDay, (int) local.wYear, (int) local.wHour, (int) local.wMinute, (int) local.wSecond, (int) (local.wMilliseconds * 1000)); return &date_and_time[15 + (return_pointer_to_first_digit != 0)]; #else /* UNIX */ ACE_TCHAR timebuf[26]; // This magic number is based on the ctime(3c) man page. ACE_Time_Value cur_time = ACE_OS::gettimeofday (); time_t secs = cur_time.sec (); ACE_OS::ctime_r (&secs, timebuf, sizeof timebuf); // date_and_timelen > sizeof timebuf! ACE_OS::strsncpy (date_and_time, timebuf, date_and_timelen); ACE_TCHAR yeartmp[5]; ACE_OS::strsncpy (yeartmp, &date_and_time[20], 5); ACE_TCHAR timetmp[9]; ACE_OS::strsncpy (timetmp, &date_and_time[11], 9); ACE_OS::sprintf (&date_and_time[11], # if defined (ACE_USES_WCHAR) ACE_TEXT ("%ls %ls.%06ld"), # else ACE_TEXT ("%s %s.%06ld"), # endif /* ACE_USES_WCHAR */ yeartmp, timetmp, cur_time.usec ()); date_and_time[33] = '\0'; return &date_and_time[15 + (return_pointer_to_first_digit != 0)]; #endif /* WIN32 */ }

ACE_INLINE void ACE::unique_name (  const void *  object, ACE_TCHAR *  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 {object} will provide uniqueness between other "live" objects in the same process. The uniqueness of this name is therefore only valid for the life of {object}. Definition at line 288 of file ACE.inl. References ACE_TCHAR, and ACE_OS::unique_name(). Referenced by ACE_Semaphore::ACE_Semaphore(), ACE_RW_Process_Mutex::unique_name(), and ACE_Process_Mutex::unique_name(). { ACE_OS::unique_name (object, name, length); }

bool ACE::wild_match (  const char *  s, const char *  pattern, bool  case_sensitive = true )

Simple wildcard matching function supporting '*' and '?' return true if string s matches pattern. Definition at line 3365 of file ACE.cpp. References equal_char(). { if (str == pat) return true; if (pat == 0 || str == 0) return false; bool star = false; const char* s = str; const char* p = pat; while (*s != '\0') { if (*p == '*') { star = true; pat = p; while (*++pat == '*'); if (*pat == '\0') return true; p = pat; } else if (*p == '?') { ++s; ++p; } else if (! equal_char(*s, *p, case_sensitive)) { if (!star) return false; s = ++str; p = pat; } else { ++s; ++p; } } if (*p == '*') while (*++p == '*'); return *p == '\0'; }

ssize_t ACE::write_n (  ACE_HANDLE  handle, const ACE_Message_Block *  message_block, size_t *  bytes_transferred = 0 )

Write all the message_blocks chained through their next and cont pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty. Definition at line 1902 of file ACE.cpp. References ACE_IOV_MAX, ACE_Message_Block::cont(), ACE_Message_Block::length(), ACE_Message_Block::next(), ACE_Message_Block::rd_ptr(), ssize_t, and writev_n(). { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; iovec iov[ACE_IOV_MAX]; int iovcnt = 0; while (message_block != 0) { // Our current message block chain. const ACE_Message_Block *current_message_block = message_block; while (current_message_block != 0) { size_t current_message_block_length = current_message_block->length (); char *this_block_ptr = current_message_block->rd_ptr (); // Check if this block has any data to be sent. while (current_message_block_length > 0) { u_long this_chunk_length; if (current_message_block_length > ULONG_MAX) this_chunk_length = ULONG_MAX; else this_chunk_length = static_cast<u_long> (current_message_block_length); // Collect the data in the iovec. iov[iovcnt].iov_base = this_block_ptr; iov[iovcnt].iov_len = this_chunk_length; current_message_block_length -= this_chunk_length; this_block_ptr += this_chunk_length; // Increment iovec counter. ++iovcnt; // The buffer is full make a OS call. @@ TODO find a way to // find ACE_IOV_MAX for platforms that do not define it rather // than simply setting ACE_IOV_MAX to some arbitrary value such // as 16. if (iovcnt == ACE_IOV_MAX) { size_t current_transfer = 0; ssize_t result = ACE::writev_n (handle, iov, iovcnt, &current_transfer); // Add to total bytes transferred. bytes_transferred += current_transfer; // Errors. if (result == -1 || result == 0) return result; // Reset iovec counter. iovcnt = 0; } } // Select the next message block in the chain. current_message_block = current_message_block->cont (); } // Selection of the next message block chain. message_block = message_block->next (); } // Check for remaining buffers to be sent. This will happen when // ACE_IOV_MAX is not a multiple of the number of message blocks. if (iovcnt != 0) { size_t current_transfer = 0; ssize_t result = ACE::writev_n (handle, iov, iovcnt, &current_transfer); // Add to total bytes transferred. bytes_transferred += current_transfer; // Errors. if (result == -1 || result == 0) return result; } // Return total bytes transferred. return bytes_transferred; }

ACE_INLINE ssize_t ACE::write_n (  ACE_HANDLE  handle, const void *  buf, size_t  len, size_t *  bytes_transferred = 0 )

Definition at line 29 of file ACE.inl. References ACE_OS::write_n(). Referenced by ACE_SPIPE_Stream::send_n(), ACE_Pipe::send_n(), ACE_FILE_IO::send_n(), and ACE_DEV_IO::send_n(). { return ACE_OS::write_n (handle, buf, len, bytes_transferred); }

ssize_t ACE::writev_n (  ACE_HANDLE  handle, const iovec *  iov, int  iovcnt, size_t *  bytes_transferred = 0 )

Definition at line 2137 of file ACE.cpp. References ssize_t, and ACE_OS::writev(). Referenced by ACE_SPIPE_Stream::sendv_n(), ACE_Pipe::sendv_n(), ACE_FILE_IO::sendv_n(), and write_n(). { size_t temp; size_t &bytes_transferred = bt == 0 ? temp : *bt; bytes_transferred = 0; iovec *iov = const_cast<iovec *> (i); for (int s = 0; s < iovcnt; ) { ssize_t n = ACE_OS::writev (handle, iov + s, iovcnt - s); if (n == -1 || n == 0) return n; for (bytes_transferred += n; s < iovcnt && n >= static_cast<ssize_t> (iov[s].iov_len); s++) n -= iov[s].iov_len; if (n != 0) { char *base = reinterpret_cast<char *> (iov[s].iov_base); iov[s].iov_base = base + n; iov[s].iov_len = iov[s].iov_len - n; } } return bytes_transferred; }

---

Variable Documentation

size_t ACE::allocation_granularity_ = 0

Definition at line 53 of file ACE.cpp.

char ACE::debug_

Definition at line 60 of file ACE.cpp.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL unsigned int ACE::init_fini_count_ = 0

Counter to match <init()>/<fini()> calls. <init()> must increment it; <fini()> must decrement it. <fini()> then does nothing until it reaches 0. Definition at line 12 of file Init_ACE.cpp.

size_t ACE::pagesize_ = 0

Definition at line 56 of file ACE.cpp.

---