#include <SOCK_Stream.h>
Inheritance diagram for ACE_SOCK_Stream:
Public Types | |
typedef ACE_INET_Addr | PEER_ADDR |
Public Member Functions | |
ACE_SOCK_Stream (void) | |
Constructor. | |
ACE_SOCK_Stream (ACE_HANDLE h) | |
Constructor (sets the underlying ACE_HANDLE with h). | |
~ACE_SOCK_Stream (void) | |
Destructor. | |
ssize_t | send_urg (const void *ptr, size_t len=sizeof(char), const ACE_Time_Value *timeout=0) const |
ssize_t | recv_urg (void *ptr, size_t len=sizeof(char), const ACE_Time_Value *timeout=0) const |
int | close_reader (void) |
Close down the reader. | |
int | close_writer (void) |
Close down the writer. | |
int | close (void) |
void | dump (void) const |
Dump the state of an object. | |
Counted send/receive methods | |
The counted send/receive methods attempt to send a specified number of bytes even if they must block and retry the operation in order to transfer the entire amount. The time spent blocking for the entire transfer can be limited by a specified ACE_Time_Value object which is a relative time (i.e., a fixed amount of time, not an absolute time of day). These methods return the count of transferred bytes, or -1 if an error occurs or the operation times out. In error or timeout situations it's possible that some data was transferred before the error or timeout. The bytes_transferred parameter is used to obtain the count of bytes transferred before the error or timeout occurred. If the total specified number of bytes is transferred without error, the method return value should equal the value of bytes_transferred . | |
ssize_t | recv_n (void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
Try to recv exactly len bytes into buf from the connected socket. | |
ssize_t | recv_n (void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
Try to recv exactly len bytes into buf from the connected socket. | |
ssize_t | recvv_n (iovec iov[], int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
Receive an iovec of size iovcnt from the connected socket. | |
ssize_t | send_n (const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
Try to send exactly len bytes from buf>to the connection socket. | |
ssize_t | send_n (const void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
Try to send exactly len bytes from buf to the connected socket. | |
ssize_t | send_n (const ACE_Message_Block *message_block, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
ssize_t | sendv_n (const iovec iov[], int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0) const |
Send an iovec of size iovcnt to the connected socket. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. |
This adds additional wrapper methods atop the ACE_SOCK_IO class.
is the buffer to write from or receive into. is the number of bytes to transfer. The parameter in the following methods indicates how long to blocking trying to transfer data. If == 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 != 0, the call will wait for data to arrive no longer than the relative time specified in *. 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. 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 partial transfers, i.e., if any data is transferred before timeout/error/EOF, will contain the number of bytes transferred. Methods with parameter are I/O vector variants of the I/O operations. Methods with the extra argument will always result in getting called. Methods without the extra argument will result in getting called on Win32 platforms, and getting called on non-Win32 platforms.
Definition at line 71 of file SOCK_Stream.h.
|
Reimplemented in ACE_LSOCK_Stream. Definition at line 171 of file SOCK_Stream.h. |
|
Constructor.
Definition at line 11 of file SOCK_Stream.inl.
00012 {
00013 // ACE_TRACE ("ACE_SOCK_Stream::ACE_SOCK_Stream");
00014 }
|
|
Constructor (sets the underlying ACE_HANDLE with h).
Definition at line 17 of file SOCK_Stream.inl. References ACE_IPC_SAP::set_handle().
00018 { 00019 // ACE_TRACE ("ACE_SOCK_Stream::ACE_SOCK_Stream"); 00020 this->set_handle (h); 00021 } |
|
Destructor.
Definition at line 24 of file SOCK_Stream.inl.
00025 {
00026 // ACE_TRACE ("ACE_SOCK_Stream::~ACE_SOCK_Stream");
00027 }
|
|
Close down the socket (we need this to make things work correctly on Win32, which requires use to do a close_writer() before doing the close to avoid losing data). Reimplemented from ACE_SOCK. Definition at line 24 of file SOCK_Stream.cpp. References ACE_SOCK::close(). Referenced by ACE_SOCK_Connector::complete(), ACE_Service_Manager::handle_input(), ACE_Pipe::open(), ACE_SOCK_Connector::shared_connect_finish(), ACE_SOCK_Connector::shared_connect_start(), and ACE_Name_Proxy::~ACE_Name_Proxy().
00025 { 00026 // Close down the socket. 00027 return ACE_SOCK::close (); 00028 } |
|
Close down the reader.
Definition at line 30 of file SOCK_Stream.inl. References ACE_SHUTDOWN_READ, ACE_TRACE, ACE_IPC_SAP::get_handle(), and ACE_OS::shutdown().
00031 { 00032 ACE_TRACE ("ACE_SOCK_Stream::close_reader"); 00033 if (this->get_handle () != ACE_INVALID_HANDLE) 00034 return ACE_OS::shutdown (this->get_handle (), ACE_SHUTDOWN_READ); 00035 else 00036 return 0; 00037 } |
|
Close down the writer.
Definition at line 42 of file SOCK_Stream.inl. References ACE_SHUTDOWN_WRITE, ACE_TRACE, ACE_IPC_SAP::get_handle(), and ACE_OS::shutdown().
00043 { 00044 ACE_TRACE ("ACE_SOCK_Stream::close_writer"); 00045 if (this->get_handle () != ACE_INVALID_HANDLE) 00046 return ACE_OS::shutdown (this->get_handle (), ACE_SHUTDOWN_WRITE); 00047 else 00048 return 0; 00049 } |
|
Dump the state of an object.
Reimplemented from ACE_SOCK_IO. Reimplemented in ACE_LSOCK_Stream. Definition at line 16 of file SOCK_Stream.cpp. References ACE_TRACE. Referenced by ACE_Name_Proxy::dump(), and ACE_LSOCK_Stream::dump().
00017 { 00018 #if defined (ACE_HAS_DUMP) 00019 ACE_TRACE ("ACE_SOCK_Stream::dump"); 00020 #endif /* ACE_HAS_DUMP */ 00021 } |
|
Try to recv exactly len bytes into buf from the connected socket.
Definition at line 68 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::recv_n().
00072 { 00073 ACE_TRACE ("ACE_SOCK_Stream::recv_n"); 00074 return ACE::recv_n (this->get_handle (), 00075 buf, 00076 len, 00077 timeout, 00078 bytes_transferred); 00079 } |
|
Try to recv exactly len bytes into buf from the connected socket.
Definition at line 52 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::recv_n(). Referenced by ACE_Name_Proxy::request_reply().
00057 { 00058 ACE_TRACE ("ACE_SOCK_Stream::recv_n"); 00059 return ACE::recv_n (this->get_handle (), 00060 buf, 00061 len, 00062 flags, 00063 timeout, 00064 bytes_transferred); 00065 } |
|
Definition at line 165 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::recv().
|
|
Receive an
Definition at line 82 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::recvv_n().
00086 { 00087 ACE_TRACE ("ACE_SOCK_Stream::recvv_n"); 00088 return ACE::recvv_n (this->get_handle (), 00089 iov, 00090 n, 00091 timeout, 00092 bytes_transferred); 00093 } |
|
Send all the Definition at line 140 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::send_n().
00143 { 00144 ACE_TRACE ("ACE_SOCK_Stream::send_n"); 00145 return ACE::send_n (this->get_handle (), 00146 message_block, 00147 timeout, 00148 bytes_transferred); 00149 } |
|
Try to send exactly len bytes from buf to the connected socket.
Definition at line 112 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::send_n().
00116 { 00117 ACE_TRACE ("ACE_SOCK_Stream::send_n"); 00118 return ACE::send_n (this->get_handle (), 00119 buf, 00120 len, 00121 timeout, 00122 bytes_transferred); 00123 } |
|
Try to send exactly len bytes from buf>to the connection socket.
Definition at line 96 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::send_n(). Referenced by ACE_Service_Manager::list_services(), ACE_Service_Manager::reconfigure_services(), ACE_Remote_Token_Proxy::request_reply(), ACE_Name_Proxy::request_reply(), and ACE_Name_Proxy::send_request().
00101 { 00102 ACE_TRACE ("ACE_SOCK_Stream::send_n"); 00103 return ACE::send_n (this->get_handle (), 00104 buf, 00105 len, 00106 flags, 00107 timeout, 00108 bytes_transferred); 00109 } |
|
Definition at line 152 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::send().
|
|
Send an
Definition at line 126 of file SOCK_Stream.inl. References ACE_TRACE, and ACE::sendv_n().
00130 { 00131 ACE_TRACE ("ACE_SOCK_Stream::sendv_n"); 00132 return ACE::sendv_n (this->get_handle (), 00133 iov, 00134 n, 00135 timeout, 00136 bytes_transferred); 00137 } |
|
Declare the dynamic allocation hooks.
Reimplemented from ACE_SOCK_IO. Reimplemented in ACE_LSOCK_Stream. Definition at line 177 of file SOCK_Stream.h. |