TcpSocket Class Reference
[Basic sockets]

Socket implementation for TCP. More...

#include <TcpSocket.h>

Inheritance diagram for TcpSocket:

[legend]

Collaboration diagram for TcpSocket:

[legend]

List of all members.

Public Member Functions
	TcpSocket (ISocketHandler &)
	Constructor with standard values on input/output buffers.
	TcpSocket (ISocketHandler &h, size_t isize, size_t osize)
	Constructor with custom values for i/o buffer.
	~TcpSocket ()
bool	Open (ipaddr_t ip, port_t port, bool skip_socks=false)
	Open a connection to a remote server.
bool	Open (SocketAddress &, bool skip_socks=false)
bool	Open (SocketAddress &, SocketAddress &bind_address, bool skip_socks=false)
bool	Open (const std::string &host, port_t port)
	Open connection.
void	OnConnectTimeout ()
	Connect timeout callback.
int	Close ()
	Close file descriptor - internal use only.
void	Send (const std::string &s, int f=0)
	Send a string.
void	Sendf (const char *format,...)
	Send string using printf formatting.
void	SendBuf (const char *buf, size_t len, int f=0)
	Send buffer of bytes.
virtual void	OnRawData (const char *buf, size_t len)
	This callback is executed after a successful read from the socket.
virtual void	OnWriteComplete ()
	Called when output buffer has been sent.
size_t	GetInputLength ()
	Number of bytes in input buffer.
size_t	GetOutputLength ()
	Number of bytes in output buffer.
void	OnLine (const std::string &line)
	Callback fires when a socket in line protocol has read one full line.
uint64_t	GetBytesReceived (bool clear=false)
	Get counter of number of bytes received.
uint64_t	GetBytesSent (bool clear=false)
	Get counter of number of bytes sent.
void	OnSocks4Connect ()
	Socks4 specific callback.
void	OnSocks4ConnectFailed ()
	Socks4 specific callback.
bool	OnSocks4Read ()
	Socks4 specific callback.
void	OnResolved (int id, ipaddr_t a, port_t port)
	Callback executed when resolver thread has finished a resolve request.
void	OnSSLConnect ()
	Callback for 'New' ssl support - replaces SSLSocket.
void	OnSSLAccept ()
	Callback for 'New' ssl support - replaces SSLSocket.
virtual void	InitSSLClient ()
	This method must be implemented to initialize the ssl context for an outgoing connection.
virtual void	InitSSLServer ()
	This method must be implemented to initialize the ssl context for an incoming connection.
void	SetReconnect (bool=true)
	Flag that says a broken connection will try to reconnect.
bool	Reconnect ()
	Check reconnect on lost connection flag status.
void	SetIsReconnect (bool x=true)
	Flag to determine if a reconnect is in progress.
bool	IsReconnect ()
	Socket is reconnecting.
void	DisableInputBuffer (bool=true)
void	OnOptions (int, int, int, SOCKET)
	Called when a client socket is created, to set socket options.
void	SetLineProtocol (bool=true)
	Called after OnRead if socket is in line protocol mode.
bool	SetTcpNodelay (bool=true)
virtual int	Protocol ()
	Returns IPPROTO_TCP or IPPROTO_SCTP.
void	SetTransferLimit (size_t sz)
	Trigger limit for callback OnTransferLimit.
virtual void	OnTransferLimit ()
	This callback fires when the output buffer drops below the value set by SetTransferLimit.
Protected Types
typedef std::list< OUTPUT * >	output_l
Protected Member Functions
	TcpSocket (const TcpSocket &)
void	OnRead ()
	Called when there is something to be read from the file descriptor.
void	OnRead (char *buf, size_t n)
void	OnWrite ()
	Called when there is room for another write on the file descriptor.
void	InitializeContext (const std::string &context, SSL_METHOD *meth_in=NULL)
	SSL; Initialize ssl context for a client socket.
void	InitializeContext (const std::string &context, const std::string &keyfile, const std::string &password, SSL_METHOD *meth_in=NULL)
	SSL; Initialize ssl context for a server socket.
void	InitializeContext (const std::string &context, const std::string &certfile, const std::string &keyfile, const std::string &password, SSL_METHOD *meth_in=NULL)
	SSL; Initialize ssl context for a server socket.
virtual SSL_CTX *	GetSslContext ()
	SSL; Get pointer to ssl context structure.
virtual SSL *	GetSsl ()
	SSL; Get pointer to ssl structure.
bool	SSLNegotiate ()
	ssl; still negotiating connection.
const std::string &	GetPassword ()
	SSL; Get ssl password.
Static Protected Member Functions
static int	SSL_password_cb (char *buf, int num, int rwflag, void *userdata)
	SSL; Password callback method.
Protected Attributes
CircularBuffer	ibuf
	Circular input buffer.
Private Member Functions
TcpSocket &	operator= (const TcpSocket &)
int	TryWrite (const char *buf, size_t len)
	the actual send()
void	Buffer (const char *buf, size_t len)
	add data to output buffer top
Private Attributes
bool	m_b_input_buffer_disabled
uint64_t	m_bytes_sent
uint64_t	m_bytes_received
bool	m_skip_c
	Skip second char of CRLF or LFCR sequence in OnRead.
char	m_c
	First char in CRLF or LFCR sequence.
std::string	m_line
	Current line in line protocol mode.
char *	m_buf
	temporary read buffer
output_l	m_obuf
	output buffer
OUTPUT *	m_obuf_top
	output buffer on top
size_t	m_transfer_limit
size_t	m_output_length
SSL_CTX *	m_ssl_ctx
	ssl context
SSL *	m_ssl
	ssl 'socket'
BIO *	m_sbio
	ssl bio
std::string	m_password
	ssl password
int	m_socks4_state
	socks4 support
char	m_socks4_vn
	socks4 support, temporary variable
char	m_socks4_cd
	socks4 support, temporary variable
unsigned short	m_socks4_dstport
	socks4 support
unsigned long	m_socks4_dstip
	socks4 support
int	m_resolver_id
	Resolver id (if any) for current Open call.
bool	m_b_reconnect
	Reconnect on lost connection flag.
bool	m_b_is_reconnect
	Trying to reconnect.
Static Private Attributes
static SSLInitializer	m_ssl_init
static Mutex	m_server_ssl_mutex
static std::map< std::string, SSL_CTX * >	m_client_contexts
static std::map< std::string, SSL_CTX * >	m_server_contexts
Classes
class	CircularBuffer
	Buffer class containing one read/write circular buffer. More...
struct	OUTPUT
	Output buffer struct. More...

---

Detailed Description

Socket implementation for TCP.

Definition at line 60 of file TcpSocket.h.

---

Member Typedef Documentation

typedef std::list<OUTPUT *> TcpSocket::output_l [protected]

Definition at line 119 of file TcpSocket.h.

---

Constructor & Destructor Documentation

TcpSocket::TcpSocket

(

ISocketHandler &

h

)

Constructor with standard values on input/output buffers.

Definition at line 80 of file TcpSocket.cpp.

                                      : StreamSocket(h)
,ibuf(TCP_BUFSIZE_READ)
,m_b_input_buffer_disabled(false)
,m_bytes_sent(0)
,m_bytes_received(0)
,m_skip_c(false)
#ifdef SOCKETS_DYNAMIC_TEMP
,m_buf(new char[TCP_BUFSIZE_READ + 1])
#endif
,m_obuf_top(NULL)
,m_transfer_limit(0)
,m_output_length(0)
#ifdef HAVE_OPENSSL
,m_ssl_ctx(NULL)
,m_ssl(NULL)
,m_sbio(NULL)
#endif
#ifdef ENABLE_SOCKS4
,m_socks4_state(0)
#endif
#ifdef ENABLE_RESOLVER
,m_resolver_id(0)
#endif
#ifdef ENABLE_RECONNECT
,m_b_reconnect(false)
,m_b_is_reconnect(false)
#endif
{
}

TcpSocket::TcpSocket	(	ISocketHandler &	h,
		size_t	isize,
		size_t	osize
	)

Constructor with custom values for i/o buffer.

Parameters:

	h	ISocketHandler reference
	isize	Input buffer size
	osize	Output buffer size

Definition at line 117 of file TcpSocket.cpp.

                                                                : StreamSocket(h)
,ibuf(isize)
,m_b_input_buffer_disabled(false)
,m_bytes_sent(0)
,m_bytes_received(0)
,m_skip_c(false)
#ifdef SOCKETS_DYNAMIC_TEMP
,m_buf(new char[TCP_BUFSIZE_READ + 1])
#endif
,m_obuf_top(NULL)
,m_transfer_limit(0)
,m_output_length(0)
#ifdef HAVE_OPENSSL
,m_ssl_ctx(NULL)
,m_ssl(NULL)
,m_sbio(NULL)
#endif
#ifdef ENABLE_SOCKS4
,m_socks4_state(0)
#endif
#ifdef ENABLE_RESOLVER
,m_resolver_id(0)
#endif
#ifdef ENABLE_RECONNECT
,m_b_reconnect(false)
,m_b_is_reconnect(false)
#endif
{
}

TcpSocket::~TcpSocket

(

)

Definition at line 151 of file TcpSocket.cpp.

References m_buf, m_obuf, and m_ssl.

{
#ifdef SOCKETS_DYNAMIC_TEMP
        delete[] m_buf;
#endif
        // %! empty m_obuf
        while (m_obuf.size())
        {
                output_l::iterator it = m_obuf.begin();
                OUTPUT *p = *it;
                delete p;
                m_obuf.erase(it);
        }
#ifdef HAVE_OPENSSL
        if (m_ssl)
        {
                SSL_free(m_ssl);
        }
#endif
}

TcpSocket::TcpSocket

(

const TcpSocket &

s

)

[protected]

Definition at line 903 of file TcpSocket.cpp.

:StreamSocket(s)
,ibuf(0)
{
}

---

Member Function Documentation

bool TcpSocket::Open	(	ipaddr_t	ip,
		port_t	port,
		bool	skip_socks = false
	)

Open a connection to a remote server.

If you want your socket to connect to a server, always call Open before Add'ing a socket to the sockethandler. If not, the connection attempt will not be monitored by the socket handler...

Parameters:

	ip	IP address
	port	Port number
	skip_socks	Do not use socks4 even if configured

Definition at line 173 of file TcpSocket.cpp.

Referenced by HttpGetSocket::HttpGetSocket(), OnResolved(), Open(), HttpPutSocket::Open(), and HttpPostSocket::Open().

{
        Ipv4Address ad(ip, port);
        Ipv4Address local;
        return Open(ad, local, skip_socks);
}

bool TcpSocket::Open	(	SocketAddress &	ad,
		bool	skip_socks = false
	)

Definition at line 192 of file TcpSocket.cpp.

References Open().

{
        Ipv4Address bind_ad("0.0.0.0", 0);
        return Open(ad, bind_ad, skip_socks);
}

bool TcpSocket::Open	(	SocketAddress &	ad,
		SocketAddress &	bind_address,
		bool	skip_socks = false
	)

Connecting();

Definition at line 199 of file TcpSocket.cpp.

References Socket::Attach(), closesocket, Socket::CopyConnection(), Socket::CreateSocket(), Errno, ISocketHandler::FindConnection(), SocketAddress::GetFamily(), SocketAddress::GetPort(), Socket::GetSocks4Host(), Socket::GetSocks4Port(), Socket::Handler(), INVALID_SOCKET, SocketAddress::IsValid(), Utility::l2ip(), Utility::l2string(), LOG_LEVEL_FATAL, LOG_LEVEL_INFO, ISocketHandler::LogError(), Open(), Reconnect(), StreamSocket::SetCallOnConnect(), Socket::SetClientRemoteAddress(), Socket::SetCloseAndDelete(), StreamSocket::SetConnecting(), Socket::SetIsClient(), Socket::SetNonblocking(), Socket::SetRemoteAddress(), Socket::SetSocks4(), Socket::Socks4(), and StrError.

{
        if (!ad.IsValid())
        {
                Handler().LogError(this, "Open", 0, "Invalid SocketAddress", LOG_LEVEL_FATAL);
                SetCloseAndDelete();
                return false;
        }
        if (Handler().GetCount() >= FD_SETSIZE)
        {
                Handler().LogError(this, "Open", 0, "no space left in fd_set", LOG_LEVEL_FATAL);
                SetCloseAndDelete();
                return false;
        }
        SetConnecting(false);
#ifdef ENABLE_SOCKS4
        SetSocks4(false);
#endif
        // check for pooling
#ifdef ENABLE_POOL
        if (Handler().PoolEnabled())
        {
                ISocketHandler::PoolSocket *pools = Handler().FindConnection(SOCK_STREAM, "tcp", ad);
                if (pools)
                {
                        CopyConnection( pools );
                        delete pools;

                        SetIsClient();
                        SetCallOnConnect(); // ISocketHandler must call OnConnect
                        Handler().LogError(this, "SetCallOnConnect", 0, "Found pooled connection", LOG_LEVEL_INFO);
                        return true;
                }
        }
#endif
        // if not, create new connection
        SOCKET s = CreateSocket(ad.GetFamily(), SOCK_STREAM, "tcp");
        if (s == INVALID_SOCKET)
        {
                return false;
        }
        // socket must be nonblocking for async connect
        if (!SetNonblocking(true, s))
        {
                SetCloseAndDelete();
                closesocket(s);
                return false;
        }
#ifdef ENABLE_POOL
        SetIsClient(); // client because we connect
#endif
        SetClientRemoteAddress(ad);
        int n = 0;
        if (bind_ad.GetPort() != 0)
        {
                bind(s, bind_ad, bind_ad);
        }
#ifdef ENABLE_SOCKS4
        if (!skip_socks && GetSocks4Host() && GetSocks4Port())
        {
                Ipv4Address sa(GetSocks4Host(), GetSocks4Port());
                {
                        std::string sockshost;
                        Utility::l2ip(GetSocks4Host(), sockshost);
                        Handler().LogError(this, "Open", 0, "Connecting to socks4 server @ " + sockshost + ":" +
                                Utility::l2string(GetSocks4Port()), LOG_LEVEL_INFO);
                }
                SetSocks4();
                n = connect(s, sa, sa);
                SetRemoteAddress(sa);
        }
        else
#endif
        {
                n = connect(s, ad, ad);
                SetRemoteAddress(ad);
        }
        if (n == -1)
        {
                // check error code that means a connect is in progress
#ifdef _WIN32
                if (Errno == WSAEWOULDBLOCK)
#else
                if (Errno == EINPROGRESS)
#endif
                {
                        Attach(s);
                        SetConnecting( true ); // this flag will control fd_set's
                }
                else
#ifdef ENABLE_SOCKS4
                if (Socks4() && Handler().Socks4TryDirect() ) // retry
                {
                        closesocket(s);
                        return Open(ad, true);
                }
                else
#endif
#ifdef ENABLE_RECONNECT
                if (Reconnect())
                {
                        Handler().LogError(this, "connect: failed, reconnect pending", Errno, StrError(Errno), LOG_LEVEL_INFO);
                        Attach(s);
                        SetConnecting( true ); // this flag will control fd_set's
                }
                else
#endif
                {
                        Handler().LogError(this, "connect: failed", Errno, StrError(Errno), LOG_LEVEL_FATAL);
                        SetCloseAndDelete();
                        closesocket(s);
                        return false;
                }
        }
        else
        {
                Attach(s);
                SetCallOnConnect(); // ISocketHandler must call OnConnect
        }

        // 'true' means connected or connecting(not yet connected)
        // 'false' means something failed
        return true; 
}

bool TcpSocket::Open	(	const std::string &	host,
		port_t	port
	)

Open connection.

Parameters:

	host	Hostname
	port	Port number

Definition at line 325 of file TcpSocket.cpp.

References Socket::Handler(), Utility::isipv4(), Utility::isipv6(), m_resolver_id, Open(), Socket::Resolve(), Socket::SetCloseAndDelete(), and Utility::u2ip().

{
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
        if (IsIpv6())
        {
#ifdef ENABLE_RESOLVER
                if (!Handler().ResolverEnabled() || Utility::isipv6(host) )
                {
#endif
                        in6_addr a;
                        if (!Utility::u2ip(host, a))
                        {
                                SetCloseAndDelete();
                                return false;
                        }
                        Ipv6Address ad(a, port);
                        Ipv6Address local;
                        return Open(ad, local);
#ifdef ENABLE_RESOLVER
                }
                m_resolver_id = Resolve6(host, port);
                return true;
#endif
        }
#endif
#endif
#ifdef ENABLE_RESOLVER
        if (!Handler().ResolverEnabled() || Utility::isipv4(host) )
        {
#endif
                ipaddr_t l;
                if (!Utility::u2ip(host,l))
                {
                        SetCloseAndDelete();
                        return false;
                }
                Ipv4Address ad(l, port);
                Ipv4Address local;
                return Open(ad, local);
#ifdef ENABLE_RESOLVER
        }
        // resolve using async resolver thread
        m_resolver_id = Resolve(host, port);
        return true;
#endif
}

void TcpSocket::OnConnectTimeout

(

)

[virtual]

Connect timeout callback.

Todo:

state reason why connect failed

Todo:

state reason why connect failed

Reimplemented from Socket.

Definition at line 1645 of file TcpSocket.cpp.

References StreamSocket::GetConnectionRetries(), StreamSocket::GetConnectionRetry(), Socket::Handler(), StreamSocket::IncreaseConnectionRetries(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), Socket::OnConnectFailed(), Socket::OnConnectRetry(), OnSocks4ConnectFailed(), Socket::SetCloseAndDelete(), StreamSocket::SetConnecting(), StreamSocket::SetRetryClientConnect(), and Socket::Socks4().

{
        Handler().LogError(this, "connect", -1, "connect timeout", LOG_LEVEL_FATAL);
#ifdef ENABLE_SOCKS4
        if (Socks4())
        {
                OnSocks4ConnectFailed();
                // retry direct connection
        }
        else
#endif
        if (GetConnectionRetry() == -1 ||
                (GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
        {
                IncreaseConnectionRetries();
                // ask socket via OnConnectRetry callback if we should continue trying
                if (OnConnectRetry())
                {
                        SetRetryClientConnect();
                }
                else
                {
                        SetCloseAndDelete( true );
                        OnConnectFailed();
                }
        }
        else
        {
                SetCloseAndDelete(true);
                OnConnectFailed();
        }
        //
        SetConnecting(false);
}

int TcpSocket::Close

(

)

[virtual]

Close file descriptor - internal use only.

See also:

SetCloseAndDelete

Reimplemented from Socket.

Definition at line 1337 of file TcpSocket.cpp.

References Socket::Close(), Errno, StreamSocket::GetShutdown(), Socket::GetSocket(), Socket::Handler(), INVALID_SOCKET, Socket::IsConnected(), Socket::IsSSL(), LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, ISocketHandler::LogError(), Socket::Lost(), m_ssl, Socket::SetNonblocking(), and StrError.

{
        if (GetSocket() == INVALID_SOCKET) // this could happen
        {
                Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
                return 0;
        }
        int n;
        SetNonblocking(true);
        if (!Lost() && IsConnected() && !(GetShutdown() & SHUT_WR))
        {
                if (shutdown(GetSocket(), SHUT_WR) == -1)
                {
                        // failed...
                        Handler().LogError(this, "shutdown", Errno, StrError(Errno), LOG_LEVEL_ERROR);
                }
        }
        //
        char tmp[1000];
        if (!Lost() && (n = recv(GetSocket(),tmp,1000,0)) >= 0)
        {
                if (n)
                {
                        Handler().LogError(this, "read() after shutdown", n, "bytes read", LOG_LEVEL_WARNING);
                }
        }
#ifdef HAVE_OPENSSL
        if (IsSSL() && m_ssl)
                SSL_shutdown(m_ssl);
        if (m_ssl)
        {
                SSL_free(m_ssl);
                m_ssl = NULL;
        }
#endif
        return Socket::Close();
}

void TcpSocket::Send	(	const std::string &	s,
		int	f = 0
	)			[virtual]

Send a string.

Parameters:

	s	String to send
	f	Dummy flags -- not used

Reimplemented from Socket.

Definition at line 838 of file TcpSocket.cpp.

References SendBuf().

Referenced by HttpPostSocket::DoMultipartPost(), SmtpdSocket::OnAccept(), ResolvSocket::OnConnect(), HttpPostSocket::OnConnect(), HttpDebugSocket::OnData(), HttpDebugSocket::OnDataComplete(), ResolvSocket::OnDetached(), HttpDebugSocket::OnFirst(), HttpDebugSocket::OnHeader(), HttpDebugSocket::OnHeaderComplete(), SmtpdSocket::OnLine(), ResolvSocket::OnLine(), Sendf(), HTTPSocket::SendRequest(), and HTTPSocket::SendResponse().

{
        SendBuf(str.c_str(),str.size(),i);
}

void TcpSocket::Sendf	(	const char *	format,
			...
	)

Send string using printf formatting.

Definition at line 1024 of file TcpSocket.cpp.

References Send().

Referenced by HttpDebugSocket::OnFirst().

{
        va_list ap;
        va_start(ap, format);
        char slask[5000]; // vsprintf / vsnprintf temporary
#ifdef _WIN32
        vsprintf(slask, format, ap);
#else
        vsnprintf(slask, 5000, format, ap);
#endif
        va_end(ap);
        Send( slask );
}

void TcpSocket::SendBuf	(	const char *	buf,
		size_t	len,
		int	f = 0
	)			[virtual]

Send buffer of bytes.

Parameters:

	buf	Buffer pointer
	len	Length of data
	f	Dummy flags -- not used

Reimplemented from Socket.

Definition at line 844 of file TcpSocket.cpp.

References Buffer(), Socket::CloseAndDelete(), StreamSocket::Connecting(), ISocketHandler::Get(), Socket::GetSocket(), Socket::Handler(), INVALID_SOCKET, Socket::IsConnected(), LOG_LEVEL_INFO, ISocketHandler::LogError(), m_obuf, m_obuf_top, StreamSocket::Ready(), Socket::Set(), and TryWrite().

Referenced by HttpPostSocket::DoMultipartPost(), HttpPutSocket::OnConnect(), HttpDebugSocket::OnData(), OnSocks4Connect(), HttpBaseSocket::OnTransferLimit(), Ajp13Socket::OnTransferLimit(), Ajp13Socket::ReceiveBody(), Ajp13Socket::Respond(), Send(), and HttpdSocket::Send64().

{
        if (!Ready() && !Connecting())
        {
                Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-ready socket" ); // warning
                if (GetSocket() == INVALID_SOCKET)
                        Handler().LogError(this, "SendBuf", 0, " * GetSocket() == INVALID_SOCKET", LOG_LEVEL_INFO);
                if (Connecting())
                        Handler().LogError(this, "SendBuf", 0, " * Connecting()", LOG_LEVEL_INFO);
                if (CloseAndDelete())
                        Handler().LogError(this, "SendBuf", 0, " * CloseAndDelete()", LOG_LEVEL_INFO);
                return;
        }
        if (!IsConnected())
        {
                Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-connected socket, will be sent on connect" ); // warning
                Buffer(buf, len);
                return;
        }
        if (m_obuf_top)
        {
                Buffer(buf, len);
                return;
        }
        int n = TryWrite(buf, len);
        if (n >= 0 && n < (int)len)
        {
                Buffer(buf + n, len - n);
        }
        // if ( data in buffer || !IsConnected )
        // {
        //   add to buffer
        // }
        // else