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	ReadInput (char *buf, size_t sz)
	Read from 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)
	Use this if you only use OnRawData to process received data.
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.
const std::string	GetLine () const
	Get the unfinished line when using SetLineProtocol = true.
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, const 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, const 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, const SSL_METHOD *meth_in=NULL)
	SSL; Initialize ssl context for a server socket.
void	UseCertificateChainFile (const std::string &filename)
	SSL; load certificate chain from file.
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 &)
void	SendFromOutputBuffer ()
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::vector< char >	m_line
	Current line in line protocol mode.
size_t	m_line_ptr
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
size_t	m_repeat_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 62 of file TcpSocket.h.

---

Member Typedef Documentation

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

Definition at line 121 of file TcpSocket.h.

---

Constructor & Destructor Documentation

TcpSocket::TcpSocket

(

ISocketHandler &

h

)

Constructor with standard values on input/output buffers.

Definition at line 86 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)
,m_line(Handler().MaxTcpLineSize())
,m_line_ptr(0)
#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)
,m_repeat_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 126 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)
,m_line(Handler().MaxTcpLineSize())
,m_line_ptr(0)
#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)
,m_repeat_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 163 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 958 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 185 of file TcpSocket.cpp.

Referenced by HttpGetSocket::DoConnect(), 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 204 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 211 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(), Socket::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() >= Handler().MaxCount())
        {
                Handler().LogError(this, "Open", 0, "no space left for more sockets", 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 337 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 1724 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(), Socket::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();
                        //
                        SetConnecting(false);
                }
        }
        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 1400 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 888 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 1083 of file TcpSocket.cpp.

References Send().

Referenced by HttpDebugSocket::OnFirst().

{
        va_list ap;
        va_start(ap, format);
        char slask[5000]; // vsprintf / vsnprintf temporary
        vsnprintf(slask, sizeof(slask), format, ap);
        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 894 of file TcpSocket.cpp.

References Buffer(), Socket::CloseAndDelete(), StreamSocket::Connecting(), Socket::GetSocket(), Socket::Handler(), INVALID_SOCKET, Socket::IsConnected(), Socket::IsDisableRead(), ISocketHandler::ISocketHandler_Mod(), Socket::IsSSL(), LOG_LEVEL_INFO, ISocketHandler::LogError(), m_obuf, m_obuf_top, StreamSocket::Ready(), SendFromOutputBuffer(), and TryWrite().

Referenced by HttpPostSocket::DoMultipartPost(), Ajp13Socket::IHttpServer_Respond(), HttpPutSocket::OnConnect(), HttpDebugSocket::OnData(), OnSocks4Connect(), HttpBaseSocket::OnTransferLimit(), Ajp13Socket::OnTransferLimit(), Ajp13Socket::ReceiveBody(), Ajp13Socket::ReceiveCPing(), 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;
        }
#ifdef HAVE_OPENSSL
        if (IsSSL())
        {
                Buffer(buf, len);
                SendFromOutputBuffer();
                return;
        }
#endif
        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
        // try_send
        // if any data is unsent, buffer it and set m_wfds

        // check output buffer set, set/reset m_wfds accordingly
        {
                bool br = !IsDisableRead();
                if (m_obuf.size())
                        Handler().ISocketHandler_Mod(this, br, true);
                else
                        Handler().ISocketHandler_Mod(this, br, false);
        }
}

void TcpSocket::OnRawData	(	const char *	buf,
		size_t	len
	)			[virtual]

This callback is executed after a successful read from the socket.

Parameters:

	buf	Pointer to the data
	len	Length of the data

Reimplemented in AjpBaseSocket, and HTTPSocket.

Definition at line 1464 of file TcpSocket.cpp.

Referenced by OnRead().

{
}

void TcpSocket::OnWriteComplete

(

)

[virtual]

Called when output buffer has been sent.

Note: Will only be called IF the output buffer has been used. Send's that was successful without needing the output buffer will not generate a call to this method.

Definition at line 672 of file TcpSocket.cpp.

Referenced by SendFromOutputBuffer().

{
}

size_t TcpSocket::GetInputLength

(

)

Number of bytes in input buffer.

Definition at line 1469 of file TcpSocket.cpp.

References TcpSocket::CircularBuffer::GetLength(), and ibuf.

Referenced by OnRead(), OnSocks4Read(), and ReadInput().

{
        return ibuf.GetLength();
}

size_t TcpSocket::ReadInput	(	char *	buf,
		size_t	sz
	)

Read from input buffer.

Definition at line 1475 of file TcpSocket.cpp.

References GetInputLength(), ibuf, and TcpSocket::CircularBuffer::Read().

{
        size_t sz = max_sz < GetInputLength() ? max_sz : GetInputLength();
        ibuf.Read(buf, sz);
        return sz;
}

size_t TcpSocket::GetOutputLength

(

)

Number of bytes in output buffer.

Definition at line 1483 of file TcpSocket.cpp.

References m_output_length.

Referenced by HttpBaseSocket::OnTransferLimit(), Ajp13Socket::OnTransferLimit(), SendFromOutputBuffer(), and SSLNegotiate().

{
        return m_output_length;
}

void TcpSocket::OnLine

(

const std::string &

line

)

[virtual]

Callback fires when a socket in line protocol has read one full line.

Parameters:

line

Line read

Reimplemented from Socket.

Reimplemented in HTTPSocket, ResolvSocket, and SmtpdSocket.

Definition at line 950 of file TcpSocket.cpp.

Referenced by OnRead().

{
}

uint64_t TcpSocket::GetBytesReceived

(

bool

clear = false

)

[virtual]

Get counter of number of bytes received.

Reimplemented from Socket.

Definition at line 1489 of file TcpSocket.cpp.

References m_bytes_received.

{
        uint64_t z = m_bytes_received;
        if (clear)
                m_bytes_received = 0;
        return z;
}

uint64_t TcpSocket::GetBytesSent

(

bool

clear = false

)

[virtual]

Get counter of number of bytes sent.

Reimplemented from Socket.

Definition at line 1498 of file TcpSocket.cpp.

References m_bytes_sent.

{
        uint64_t z = m_bytes_sent;
        if (clear)
                m_bytes_sent = 0;
        return z;
}

void TcpSocket::OnSocks4Connect

(

)

[virtual]

Socks4 specific callback.

Todo:

warn

Todo:

warn

Reimplemented from Socket.

Definition at line 969 of file TcpSocket.cpp.

References Socket::GetClientRemoteAddress(), Socket::GetSocks4Userid(), m_socks4_state, and SendBuf().

{
        char request[1000];
        memset(request, 0, sizeof(request));
        request[0] = 4; // socks v4
        request[1] = 1; // command code: CONNECT
        {
                std::auto_ptr<SocketAddress> ad = GetClientRemoteAddress();
                if (ad.get())
                {
                        struct sockaddr *p0 = (struct sockaddr *)*ad;
                        struct sockaddr_in *p = (struct sockaddr_in *)p0;
                        if (p -> sin_family == AF_INET)
                        {
                                memcpy(request + 2, &p -> sin_port, 2); // nwbo is ok here
                                memcpy(request + 4, &p -> sin_addr, sizeof(struct in_addr));
                        }
                        else
                        {
                        }
                }
                else
                {
                }
        }
#if defined( _WIN32) && !defined(__CYGWIN__)
        strcpy_s(request + 8, sizeof(request) - 8, GetSocks4Userid().c_str());
#else
        strcpy(request + 8, GetSocks4Userid().c_str());
#endif
        size_t length = GetSocks4Userid().size() + 8 + 1;
        SendBuf(request, length);
        m_socks4_state = 0;
}

void TcpSocket::OnSocks4ConnectFailed

(

)

[virtual]

Socks4 specific callback.

Reimplemented from Socket.

Definition at line 1007 of file TcpSocket.cpp.

References Socket::Handler(), LOG_LEVEL_WARNING, ISocketHandler::LogError(), Socket::OnConnectFailed(), Socket::SetCloseAndDelete(), StreamSocket::SetConnecting(), and Socket::SetRetryClientConnect().

Referenced by OnConnectTimeout(), and OnWrite().

{
        Handler().LogError(this,"OnSocks4ConnectFailed",0,"connection to socks4 server failed, trying direct connection",LOG_LEVEL_WARNING);
        if (!Handler().Socks4TryDirect())
        {
                SetConnecting(false);
                SetCloseAndDelete();
                OnConnectFailed(); // just in case
        }
        else
        {
                SetRetryClientConnect();
        }
}

bool TcpSocket::OnSocks4Read

(

)

[virtual]

Socks4 specific callback.

Returns:

'need_more'

Reimplemented from Socket.

Definition at line 1023 of file TcpSocket.cpp.

References GetInputLength(), Socket::Handler(), ibuf, LOG_LEVEL_FATAL, LOG_LEVEL_INFO, ISocketHandler::LogError(), m_socks4_cd, m_socks4_dstip, m_socks4_dstport, m_socks4_state, m_socks4_vn, Socket::OnConnect(), Socket::OnConnectFailed(), TcpSocket::CircularBuffer::Read(), Socket::SetCloseAndDelete(), StreamSocket::SetConnecting(), and Socket::SetSocks4().

Referenced by OnRead().

{
        switch (m_socks4_state)
        {
        case 0:
                ibuf.Read(&m_socks4_vn, 1);
                m_socks4_state = 1;
                break;
        case 1:
                ibuf.Read(&m_socks4_cd, 1);
                m_socks4_state = 2;
                break;
        case 2:
                if (GetInputLength() > 1)
                {
                        ibuf.Read( (char *)&m_socks4_dstport, 2);
                        m_socks4_state = 3;
                }
                else
                {
                        return true;
                }
                break;
        case 3:
                if (GetInputLength() > 3)
                {
                        ibuf.Read( (char *)&m_socks4_dstip, 4);
                        SetSocks4(false);
                        
                        switch (m_socks4_cd)
                        {
                        case 90:
                                OnConnect();
                                Handler().LogError(this, "OnSocks4Read", 0, "Connection established", LOG_LEVEL_INFO);
                                break;
                        case 91:
                        case 92:
                        case 93:
                                Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server reports connect failed",LOG_LEVEL_FATAL);
                                SetConnecting(false);
                                SetCloseAndDelete();
                                OnConnectFailed();
                                break;
                        default:
                                Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server unrecognized response",LOG_LEVEL_FATAL);
                                SetCloseAndDelete();
                                break;
                        }
                }
                else
                {
                        return true;
                }
                break;
        }
        return false;
}

void TcpSocket::OnResolved	(	int	id,
		ipaddr_t	a,
		port_t	port
	)			[virtual]

Callback executed when resolver thread has finished a resolve request.

Reimplemented from Socket.

Definition at line 387 of file TcpSocket.cpp.

References ISocketHandler::Add(), DEB, Socket::Handler(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), m_resolver_id, Open(), and Socket::SetCloseAndDelete().

Referenced by ResolvSocket::OnLine().

{
DEB(    fprintf(stderr, "TcpSocket::OnResolved id %d addr %x port %d\n", id, a, port);)
        if (id == m_resolver_id)
        {
                if (a && port)
                {
                        Ipv4Address ad(a, port);
                        Ipv4Address local;
                        if (Open(ad, local))
                        {
                                if (!Handler().Valid(this))
                                {
                                        Handler().Add(this);
                                }
                        }
                }
                else
                {
                        Handler().LogError(this, "OnResolved", 0, "Resolver failed", LOG_LEVEL_FATAL);
                        SetCloseAndDelete();
                }
        }
        else
        {
                Handler().LogError(this, "OnResolved", id, "Resolver returned wrong job id", LOG_LEVEL_FATAL);
                SetCloseAndDelete();
        }
}

void TcpSocket::OnSSLConnect

(

)

[virtual]

Callback for 'New' ssl support - replaces SSLSocket.

Internal use.

Reimplemented from Socket.

Definition at line 1095 of file TcpSocket.cpp.

References DEB, Socket::GetSocket(), InitSSLClient(), m_sbio, m_ssl, m_ssl_ctx, Socket::SetCloseAndDelete(), Socket::SetNonblocking(), Socket::SetSSLNegotiate(), and SSLNegotiate().

{
        SetNonblocking(true);
        {
                if (m_ssl_ctx)
                {
DEB(                    fprintf(stderr, "SSL Context already initialized - closing socket\n");)
                        SetCloseAndDelete(true);
                        return;
                }
                InitSSLClient();
        }
        if (m_ssl_ctx)
        {
                /* Connect the SSL socket */
                m_ssl = SSL_new(m_ssl_ctx);
                if (!m_ssl)
                {
DEB(                    fprintf(stderr, " m_ssl is NULL\n");)
                        SetCloseAndDelete(true);
                        return;
                }
                m_sbio = BIO_new_socket((int)GetSocket(), BIO_NOCLOSE);
                if (!m_sbio)
                {
DEB(                    fprintf(stderr, " m_sbio is NULL\n");)
                        SetCloseAndDelete(true);
                        return;
                }
                SSL_set_bio(m_ssl, m_sbio, m_sbio);
                if (!SSLNegotiate())
                {
                        SetSSLNegotiate();
                }
        }
        else
        {
                SetCloseAndDelete();
        }
}

void TcpSocket::OnSSLAccept

(

)

[virtual]

Callback for 'New' ssl support - replaces SSLSocket.

Internal use.

Reimplemented from Socket.

Definition at line 1137 of file TcpSocket.cpp.

References DEB, Socket::GetSocket(), InitSSLServer(), m_sbio, m_ssl, m_ssl_ctx, Socket::SetCloseAndDelete(), Socket::SetNonblocking(), Socket::SetSSLNegotiate(), and Socket::SetSSLServer().

{
        SetNonblocking(true);
        {
                if (m_ssl_ctx)
                {
DEB(                    fprintf(stderr, "SSL Context already initialized - closing socket\n");)
                        SetCloseAndDelete(true);
                        return;
                }
                InitSSLServer();
                SetSSLServer();
        }
        if (m_ssl_ctx)
        {
                m_ssl = SSL_new(m_ssl_ctx);
                if (!m_ssl)
                {
DEB(                    fprintf(stderr, " m_ssl is NULL\n");)
                        SetCloseAndDelete(true);
                        return;
                }
                m_sbio = BIO_new_socket((int)GetSocket(), BIO_NOCLOSE);
                if (!m_sbio)
                {
DEB(                    fprintf(stderr, " m_sbio is NULL\n");)
                        SetCloseAndDelete(true);
                        return;
                }
                SSL_set_bio(m_ssl, m_sbio, m_sbio);
//              if (!SSLNegotiate())
                {
                        SetSSLNegotiate();
                }
        }
}

void TcpSocket::InitSSLClient

(

)

[virtual]

This method must be implemented to initialize the ssl context for an outgoing connection.

Definition at line 1266 of file TcpSocket.cpp.

References InitializeContext().

Referenced by OnSSLConnect().

{
        InitializeContext("", SSLv23_method());
}

void TcpSocket::InitSSLServer

(

)

[virtual]

This method must be implemented to initialize the ssl context for an incoming connection.

Definition at line 1272 of file TcpSocket.cpp.

References Socket::Handler(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), and Socket::SetCloseAndDelete().

Referenced by OnSSLAccept().

{
        Handler().LogError(this, "InitSSLServer", 0, "You MUST implement your own InitSSLServer method", LOG_LEVEL_FATAL);
        SetCloseAndDelete();
}

void TcpSocket::SetReconnect

(

bool

x = true

)

Flag that says a broken connection will try to reconnect.

Definition at line 1457 of file TcpSocket.cpp.

References m_b_reconnect.

{
        m_b_reconnect = x;
}

bool TcpSocket::Reconnect

(

)

Check reconnect on lost connection flag status.

Definition at line 1508 of file TcpSocket.cpp.

References m_b_reconnect.

Referenced by Open().

{
        return m_b_reconnect;
}

void TcpSocket::SetIsReconnect

(

bool

x = true

)

Flag to determine if a reconnect is in progress.

Definition at line 1514 of file TcpSocket.cpp.

References m_b_is_reconnect.

{
        m_b_is_reconnect = x;
}

bool TcpSocket::IsReconnect

(

)

Socket is reconnecting.

Definition at line 1520 of file TcpSocket.cpp.

References m_b_is_reconnect.

Referenced by SSLNegotiate().

{
        return m_b_is_reconnect;
}

void TcpSocket::DisableInputBuffer

(

bool

x = true

)

Use this if you only use OnRawData to process received data.

Definition at line 1535 of file TcpSocket.cpp.

References m_b_input_buffer_disabled.

Referenced by HTTPSocket::HTTPSocket(), and SetLineProtocol().

{
        m_b_input_buffer_disabled = x;
}

void TcpSocket::OnOptions	(	int	family,
		int	type,
		int	protocol,
		SOCKET	s
	)			[virtual]

Called when a client socket is created, to set socket options.

Parameters:

	family	AF_INET, AF_INET6, etc
	type	SOCK_STREAM, SOCK_DGRAM, etc
	protocol	Protocol number (tcp, udp, sctp, etc)
	s	Socket file descriptor

Implements Socket.

Definition at line 1541 of file TcpSocket.cpp.

References DEB, Socket::SetSoKeepalive(), and Socket::SetSoReuseaddr().

{
DEB(    fprintf(stderr, "Socket::OnOptions()\n");)
#ifdef SO_NOSIGPIPE
        SetSoNosigpipe(true);
#endif
        SetSoReuseaddr(true);
        SetSoKeepalive(true);
}

void TcpSocket::SetLineProtocol

(

bool

x = true

)

[virtual]

Called after OnRead if socket is in line protocol mode.

See also:

SetLineProtocol Enable the OnLine callback. Do not create your own OnRead callback when using this.

Reimplemented from StreamSocket.

Definition at line 1552 of file TcpSocket.cpp.

References DisableInputBuffer(), and StreamSocket::SetLineProtocol().

Referenced by HTTPSocket::HTTPSocket(), HTTPSocket::OnLine(), HTTPSocket::OnRawData(), HTTPSocket::Reset(), ResolvSocket::ResolvSocket(), and SmtpdSocket::SmtpdSocket().

{
        StreamSocket::SetLineProtocol(x);
        DisableInputBuffer(x);
}

const std::string TcpSocket::GetLine

(

)

const

Get the unfinished line when using SetLineProtocol = true.

The finished line will always be reported with a call to OnLine.

Definition at line 1559 of file TcpSocket.cpp.

References m_line, and m_line_ptr.

{
        if (!m_line_ptr)
                return "";
        return std::string(&m_line[0], m_line_ptr);
}

bool TcpSocket::SetTcpNodelay

(

bool

x = true

)

Definition at line 1567 of file TcpSocket.cpp.

References Errno, Socket::GetSocket(), Socket::Handler(), LOG_LEVEL_FATAL, LOG_LEVEL_INFO, ISocketHandler::LogError(), and StrError.

{
#ifdef TCP_NODELAY
        int optval = x ? 1 : 0;
        if (setsockopt(GetSocket(), IPPROTO_TCP, TCP_NODELAY, (char *)&optval, sizeof(optval)) == -1)
        {
                Handler().LogError(this, "setsockopt(IPPROTO_TCP, TCP_NODELAY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
                return false;
        }
        return true;
#else
        Handler().LogError(this, "socket option not available", 0, "TCP_NODELAY", LOG_LEVEL_INFO);
        return false;
#endif
}

int TcpSocket::Protocol

(

)

[virtual]

Returns IPPROTO_TCP or IPPROTO_SCTP.

Implements StreamSocket.

Definition at line 1800 of file TcpSocket.cpp.

{
        return IPPROTO_TCP;
}

void TcpSocket::SetTransferLimit

(

size_t

sz

)

Trigger limit for callback OnTransferLimit.

Definition at line 1806 of file TcpSocket.cpp.

References m_transfer_limit.

Referenced by HttpBaseSocket::OnTransferLimit(), and Ajp13Socket::OnTransferLimit().

{
        m_transfer_limit = sz;
}

void TcpSocket::OnTransferLimit

(

)

[virtual]

This callback fires when the output buffer drops below the value set by SetTransferLimit.

Default: 0 (disabled).

Reimplemented in Ajp13Socket, and HttpBaseSocket.

Definition at line 1812 of file TcpSocket.cpp.

Referenced by SendFromOutputBuffer().

{
}

void TcpSocket::OnRead

(

)

[protected, virtual]

Called when there is something to be read from the file descriptor.

Reimplemented from Socket.

Definition at line 446 of file TcpSocket.cpp.

References DEB, Errno, Socket::GetSocket(), Socket::GetTrafficMonitor(), Socket::Handler(), ibuf, Socket::IsSSL(), LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, LOG_LEVEL_WARNING, ISocketHandler::LogError(), m_b_input_buffer_disabled, m_buf, m_bytes_received, m_ssl, Socket::OnDisconnect(), StreamSocket::Ready(), Socket::SetCloseAndDelete(), StreamSocket::SetFlushBeforeClose(), Socket::SetLost(), StreamSocket::SetShutdown(), StrError, TCP_BUFSIZE_READ, TCP_DISCONNECT_ERROR, TCP_DISCONNECT_SSL, and TcpSocket::CircularBuffer::Write().

Referenced by HTTPSocket::OnRawData().

{
        int n = 0;
#ifdef SOCKETS_DYNAMIC_TEMP
        char *buf = m_buf;
#else
        char buf[TCP_BUFSIZE_READ];
#endif
#ifdef HAVE_OPENSSL
        if (IsSSL())
        {
                if (!Ready())
                        return;
                n = SSL_read(m_ssl, buf, TCP_BUFSIZE_READ);
                if (n == -1)
                {
                        n = SSL_get_error(m_ssl, n);
                        switch (n)
                        {
                        case SSL_ERROR_NONE:
                        case SSL_ERROR_WANT_READ:
                        case SSL_ERROR_WANT_WRITE:
                                break;
                        case SSL_ERROR_ZERO_RETURN:
DEB(                            fprintf(stderr, "SSL_read() returns zero - closing socket\n");)
                                OnDisconnect();
                                OnDisconnect(TCP_DISCONNECT_SSL|TCP_DISCONNECT_ERROR, n);
                                SetCloseAndDelete(true);
                                SetFlushBeforeClose(false);
                                SetLost();
                                break;
                        default:
DEB(                            fprintf(stderr, "SSL read problem, errcode = %d\n",n);)
                                OnDisconnect();
                                OnDisconnect(TCP_DISCONNECT_SSL|TCP_DISCONNECT_ERROR, n);
                                SetCloseAndDelete(true);
                                SetFlushBeforeClose(false);
                                SetLost();
                        }
                        return;
                }
                else
                if (!n)
                {
DEB(                    n = SSL_get_error(m_ssl, n);
                        fprintf(stderr, "SSL_read returns 0, SSL_get_error: %d\n", n);
                        if (n == SSL_ERROR_SYSCALL)
                        {
                                fprintf(stderr, "ERR_get_error() returns %ld\n", ERR_get_error());
                                perror("errno: SSL_read");
                        })
                        OnDisconnect();
                        OnDisconnect(TCP_DISCONNECT_SSL, 0);
                        SetCloseAndDelete(true);
                        SetFlushBeforeClose(false);
                        SetLost();
                        SetShutdown(SHUT_WR);
                        return;
                }
                else
                if (n > 0 && n <= TCP_BUFSIZE_READ)
                {
                        m_bytes_received += n;
                        if (GetTrafficMonitor())
                        {
                                GetTrafficMonitor() -> fwrite(buf, 1, n);
                        }
                        if (!m_b_input_buffer_disabled && !ibuf.Write(buf,n))
                        {
                                Handler().LogError(this, "OnRead(ssl)", 0, "ibuf overflow", LOG_LEVEL_WARNING);
                        }
                }
                else
                {
                        Handler().LogError(this, "OnRead(ssl)", n, "abnormal value from SSL_read", LOG_LEVEL_ERROR);
                }
        }
        else
#endif // HAVE_OPENSSL
        {
                n = recv(GetSocket(), buf, TCP_BUFSIZE_READ, MSG_NOSIGNAL);
                if (n == -1)
                {
                        Handler().LogError(this, "read", Errno, StrError(Errno), LOG_LEVEL_FATAL);
                        OnDisconnect();
                        OnDisconnect(TCP_DISCONNECT_ERROR, Errno);
                        SetCloseAndDelete(true);
                        SetFlushBeforeClose(false);
                        SetLost();
                        return;
                }
                else
                if (!n)
                {
                        OnDisconnect();
                        OnDisconnect(0, 0);
                        SetCloseAndDelete(true);
                        SetFlushBeforeClose(false);
                        SetLost();
                        SetShutdown(SHUT_WR);
                        return;
                }
                else
                if (n > 0 && n <= TCP_BUFSIZE_READ)
                {
                        m_bytes_received += n;
                        if (GetTrafficMonitor())
                        {
                                GetTrafficMonitor() -> fwrite(buf, 1, n);
                        }
                        if (!m_b_input_buffer_disabled && !ibuf.Write(buf,n))
                        {
                                Handler().LogError(this, "OnRead", 0, "ibuf overflow", LOG_LEVEL_WARNING);
                        }
                }
                else
                {
                        Handler().LogError(this, "OnRead", n, "abnormal value from recv", LOG_LEVEL_ERROR);
                }
        }
        //
        OnRead( buf, n );
}

void TcpSocket::OnRead	(	char *	buf,
		size_t	n
	)			[protected]

Definition at line 571 of file TcpSocket.cpp.

References Socket::CloseAndDelete(), GetInputLength(), Socket::Handler(), StreamSocket::LineProtocol(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), m_b_input_buffer_disabled, m_c, m_line, m_line_ptr, m_skip_c, OnLine(), OnRawData(), OnSocks4Read(), Socket::SetCloseAndDelete(), Socket::Socks4(), and TCP_BUFSIZE_READ.

{
        // unbuffered
        if (n > 0 && n <= TCP_BUFSIZE_READ)
        {
                if (LineProtocol())
                {
                        buf[n] = 0;
                        size_t i = 0;
                        if (m_skip_c && (buf[i] == 13 || buf[i] == 10) && buf[i] != m_c)
                        {
                                m_skip_c = false;
                                i++;
                        }
                        size_t x = i;
                        for (; i < n && LineProtocol(); i++)
                        {
                                while ((buf[i] == 13 || buf[i] == 10) && LineProtocol())
                                {
                                        char c = buf[i];
                                        buf[i] = 0;
                                        if (buf[x])
                                        {
                                                size_t sz = strlen(&buf[x]);
                                                if (m_line_ptr + sz < Handler().MaxTcpLineSize())
                                                {
                                                        memcpy(&m_line[m_line_ptr], &buf[x], sz);
                                                        m_line_ptr += sz;
                                                }
                                                else
                                                {
                                                        Handler().LogError(this, "TcpSocket::OnRead", (int)(m_line_ptr + sz), "maximum tcp_line_size exceeded, connection closed", LOG_LEVEL_FATAL);
                                                        SetCloseAndDelete();
                                                }
                                        }
                                        if (m_line_ptr > 0)
                                                OnLine( std::string(&m_line[0], m_line_ptr) );
                                        else
                                                OnLine( "" );
                                        i++;
                                        m_skip_c = true;
                                        m_c = c;
                                        if (i < n && (buf[i] == 13 || buf[i] == 10) && buf[i] != c)
                                        {
                                                m_skip_c = false;
                                                i++;
                                        }
                                        x = i;
                                        m_line_ptr = 0;
                                }
                                if (!LineProtocol())
                                {
                                        break;
                                }
                        }
                        if (!LineProtocol())
                        {
                                if (i < n)
                                {
                                        OnRawData(buf + i, n - i);
                                }
                        }
                        else
                        if (buf[x])
                        {
                                size_t sz = strlen(&buf[x]);
                                if (m_line_ptr + sz < Handler().MaxTcpLineSize())
                                {
                                        memcpy(&m_line[m_line_ptr], &buf[x], sz);
                                        m_line_ptr += sz;
                                }
                                else
                                {
                                        Handler().LogError(this, "TcpSocket::OnRead", (int)(m_line_ptr + sz), "maximum tcp_line_size exceeded, connection closed", LOG_LEVEL_FATAL);
                                        SetCloseAndDelete();
                                }
                        }
                }
                else
                {
                        OnRawData(buf, n);
                }
        }
        if (m_b_input_buffer_disabled)
        {
                return;
        }
        // further processing: socks4
#ifdef ENABLE_SOCKS4
        if (Socks4())
        {
                bool need_more = false;
                while (GetInputLength() && !need_more && !CloseAndDelete())
                {
                        need_more = OnSocks4Read();
                }
        }
#endif
}

void TcpSocket::OnWrite

(

)

[protected, virtual]

Called when there is room for another write on the file descriptor.

Reimplemented from Socket.

Definition at line 677 of file TcpSocket.cpp.

References StreamSocket::Connecting(), StreamSocket::GetConnectionRetries(), StreamSocket::GetConnectionRetry(), Socket::Handler(), Socket::IsDisableRead(), ISocketHandler::ISocketHandler_Mod(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), Socket::OnConnectFailed(), OnSocks4ConnectFailed(), SendFromOutputBuffer(), Socket::SetCallOnConnect(), Socket::SetCloseAndDelete(), StreamSocket::SetConnecting(), Socket::Socks4(), Socket::SoError(), and StrError.

Referenced by SSLNegotiate().

{
        if (Connecting())
        {
                int err = SoError();

                // don't reset connecting flag on error here, we want the OnConnectFailed timeout later on
                if (!err) // ok
                {
                        Handler().ISocketHandler_Mod(this, !IsDisableRead(), false);
                        SetConnecting(false);
                        SetCallOnConnect();
                        return;
                }
                Handler().LogError(this, "tcp: connect failed", err, StrError(err), LOG_LEVEL_FATAL);
                Handler().ISocketHandler_Mod(this, false, false); // no more monitoring because connection failed

                // failed
#ifdef ENABLE_SOCKS4
                if (Socks4())
                {
                        // %! leave 'Connecting' flag set?
                        OnSocks4ConnectFailed();
                        return;
                }
#endif
                if (GetConnectionRetry() == -1 ||
                        (GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
                {
                        // even though the connection failed at once, only retry after
                        // the connection timeout.
                        // should we even try to connect again, when CheckConnect returns
                        // false it's because of a connection error - not a timeout...
                        return;
                }
                SetConnecting(false);
                SetCloseAndDelete( true );
                OnConnectFailed();
                return;
        }

        SendFromOutputBuffer();
}

void TcpSocket::InitializeContext	(	const std::string &	context,
		const SSL_METHOD *	meth_in = NULL
	)			[protected]

SSL; Initialize ssl context for a client socket.

Parameters:

meth_in

SSL method

Definition at line 1279 of file TcpSocket.cpp.

References m_client_contexts, and m_ssl_ctx.

Referenced by InitializeContext(), and InitSSLClient().

{
        static Mutex mutex;
        Lock lock(mutex);
        /* Create our context*/
        if (m_client_contexts.find(context) == m_client_contexts.end())
        {
                const SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
                m_ssl_ctx = m_client_contexts[context] = SSL_CTX_new(const_cast<SSL_METHOD *>(meth));
                SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY|SSL_MODE_ENABLE_PARTIAL_WRITE);
        }
        else
        {
                m_ssl_ctx = m_client_contexts[context];
        }
}

void TcpSocket::InitializeContext	(	const std::string &	context,
		const std::string &	keyfile,
		const std::string &	password,
		const SSL_METHOD *	meth_in = NULL
	)			[protected]

SSL; Initialize ssl context for a server socket.

Parameters:

	keyfile	Combined private key/certificate file
	password	Password for private key
	meth_in	SSL method

Definition at line 1297 of file TcpSocket.cpp.

References InitializeContext().

{
        InitializeContext(context, keyfile, keyfile, password, meth_in);
/*
        Lock lock(m_server_ssl_mutex);
        // Create our context
        if (m_server_contexts.find(context) == m_server_contexts.end())
        {
                const SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
                m_ssl_ctx = m_server_contexts[context] = SSL_CTX_new(const_cast<SSL_METHOD *>(meth));
                SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY|SSL_MODE_ENABLE_PARTIAL_WRITE);
                // session id
                if (context.size())
                        SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)context.c_str(), (unsigned int)context.size());
                else
                        SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)"--empty--", 9);
        }
        else
        {
                m_ssl_ctx = m_server_contexts[context];
        }

        // Load our keys and certificates
        if (!(SSL_CTX_use_certificate_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
        {
                Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read certificate file " + keyfile, LOG_LEVEL_FATAL);
        }

        m_password = password;
        SSL_CTX_set_default_passwd_cb(m_ssl_ctx, SSL_password_cb);
        SSL_CTX_set_default_passwd_cb_userdata(m_ssl_ctx, this);
        if (!(SSL_CTX_use_PrivateKey_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
        {
                Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read private key file " + keyfile, LOG_LEVEL_FATAL);
        }
*/
}

void TcpSocket::InitializeContext	(	const std::string &	context,
		const std::string &	certfile,
		const std::string &	keyfile,
		const std::string &	password,
		const SSL_METHOD *	meth_in = NULL
	)			[protected]

SSL; Initialize ssl context for a server socket.

Parameters:

	certfile	Separate certificate file
	keyfile	Combined private key/certificate file
	password	Password for private key
	meth_in	SSL method

Definition at line 1336 of file TcpSocket.cpp.

References Socket::Handler(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), m_password, m_server_contexts, m_server_ssl_mutex, m_ssl_ctx, and SSL_password_cb().

{
        Lock lock(m_server_ssl_mutex);
        /* Create our context*/
        if (m_server_contexts.find(context) == m_server_contexts.end())
        {
                const SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
                m_ssl_ctx = m_server_contexts[context] = SSL_CTX_new(const_cast<SSL_METHOD *>(meth));
                SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY|SSL_MODE_ENABLE_PARTIAL_WRITE);
                // session id
                if (context.size())
                        SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)context.c_str(), (unsigned int)context.size());
                else
                        SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)"--empty--", 9);
        }
        else
        {
                m_ssl_ctx = m_server_contexts[context];
        }

        /* Load our keys and certificates*/
        if (!(SSL_CTX_use_certificate_file(m_ssl_ctx, certfile.c_str(), SSL_FILETYPE_PEM)))
        {
                Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read certificate file " + keyfile, LOG_LEVEL_FATAL);
        }

        m_password = password;
        SSL_CTX_set_default_passwd_cb(m_ssl_ctx, SSL_password_cb);
        SSL_CTX_set_default_passwd_cb_userdata(m_ssl_ctx, this);
        if (!(SSL_CTX_use_PrivateKey_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
        {
                Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read private key file " + keyfile, LOG_LEVEL_FATAL);
        }
}

void TcpSocket::UseCertificateChainFile

(

const std::string &

filename

)

[protected]

SSL; load certificate chain from file.

Definition at line 1372 of file TcpSocket.cpp.

References Socket::Handler(), LOG_LEVEL_ERROR, ISocketHandler::LogError(), and m_ssl_ctx.

{
        if (!(SSL_CTX_use_certificate_chain_file(m_ssl_ctx, filename.c_str())))
        {
                Handler().LogError(this, "TcpSocket UseCertificateChainFile", 0, "Couldn't read certificate file " + filename, LOG_LEVEL_ERROR);
        }
}

int TcpSocket::SSL_password_cb	(	char *	buf,
		int	num,
		int	rwflag,
		void *	userdata
	)			[static, protected]

SSL; Password callback method.

Definition at line 1381 of file TcpSocket.cpp.

References GetPassword().

Referenced by InitializeContext().

{
        Socket *p0 = static_cast<Socket *>(userdata);
        TcpSocket *p = dynamic_cast<TcpSocket *>(p0);
        std::string pw = p ? p -> GetPassword() : "";
        if ( (size_t)num < pw.size() + 1)
        {
                return 0;
        }
#if defined( _WIN32) && !defined(__CYGWIN__)
        strcpy_s(buf, num, pw.c_str());
#else
        strcpy(buf,pw.c_str());
#endif
        return (int)pw.size();
}

SSL_CTX * TcpSocket::GetSslContext

(

)

[protected, virtual]

SSL; Get pointer to ssl context structure.

Reimplemented from Socket.

Definition at line 1440 of file TcpSocket.cpp.

References Socket::Handler(), LOG_LEVEL_WARNING, ISocketHandler::LogError(), and m_ssl_ctx.

{
        if (!m_ssl_ctx)
                Handler().LogError(this, "GetSslContext", 0, "SSL Context is NULL; check InitSSLServer/InitSSLClient", LOG_LEVEL_WARNING);
        return m_ssl_ctx;
}

SSL * TcpSocket::GetSsl

(

)

[protected, virtual]

SSL; Get pointer to ssl structure.

Reimplemented from Socket.

Definition at line 1447 of file TcpSocket.cpp.

References Socket::Handler(), LOG_LEVEL_WARNING, ISocketHandler::LogError(), and m_ssl.

{
        if (!m_ssl)
                Handler().LogError(this, "GetSsl", 0, "SSL is NULL; check InitSSLServer/InitSSLClient", LOG_LEVEL_WARNING);
        return m_ssl;
}

bool TcpSocket::SSLNegotiate

(

)

[protected, virtual]

ssl; still negotiating connection.

Todo:

: resurrect certificate check... client

Todo:

: resurrect certificate check... server

Reimplemented from Socket.

Definition at line 1175 of file TcpSocket.cpp.

References DEB, GetOutputLength(), Socket::Handler(), IsReconnect(), Socket::IsSSLServer(), LOG_LEVEL_INFO, ISocketHandler::LogError(), m_ssl, Socket::OnAccept(), Socket::OnConnect(), Socket::OnReconnect(), Socket::OnSSLAcceptFailed(), Socket::OnSSLConnectFailed(), OnWrite(), Socket::SetCloseAndDelete(), Socket::SetConnected(), and Socket::SetSSLNegotiate().

Referenced by OnSSLConnect().

{
        if (!IsSSLServer()) // client
        {
                int r = SSL_connect(m_ssl);
                if (r > 0)
                {
                        SetSSLNegotiate(false);
//                      CheckCertificateChain( "");//ServerHOST);
                        SetConnected();
                        if (GetOutputLength())
                        {
                                OnWrite();
                        }
#ifdef ENABLE_RECONNECT
                        if (IsReconnect())
                        {
                                OnReconnect();
                        }
                        else
#endif
                        {
                                OnConnect();
                        }
                        Handler().LogError(this, "SSLNegotiate/SSL_connect", 0, "Connection established", LOG_LEVEL_INFO);
                        return true;
                }
                else
                if (!r)
                {
                        Handler().LogError(this, "SSLNegotiate/SSL_connect", 0, "Connection failed", LOG_LEVEL_INFO);
                        SetSSLNegotiate(false);
                        SetCloseAndDelete();
                        OnSSLConnectFailed();
                }
                else
                {
                        r = SSL_get_error(m_ssl, r);
                        if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
                        {
                                Handler().LogError(this, "SSLNegotiate/SSL_connect", -1, "Connection failed", LOG_LEVEL_INFO);
DEB(                            fprintf(stderr, "SSL_connect() failed - closing socket, return code: %d\n",r);)
                                SetSSLNegotiate(false);
                                SetCloseAndDelete(true);
                                OnSSLConnectFailed();
                        }
                }
        }
        else // server
        {
                int r = SSL_accept(m_ssl);
                if (r > 0)
                {
                        SetSSLNegotiate(false);
//                      CheckCertificateChain( "");//ClientHOST);
                        SetConnected();
                        if (GetOutputLength())
                        {
                                OnWrite();
                        }
                        OnAccept();
                        Handler().LogError(this, "SSLNegotiate/SSL_accept", 0, "Connection established", LOG_LEVEL_INFO);
                        return true;
                }
                else
                if (!r)
                {
                        Handler().LogError(this, "SSLNegotiate/SSL_accept", 0, "Connection failed", LOG_LEVEL_INFO);
                        SetSSLNegotiate(false);
                        SetCloseAndDelete();
                        OnSSLAcceptFailed();
                }
                else
                {
                        r = SSL_get_error(m_ssl, r);
                        if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
                        {
                                Handler().LogError(this, "SSLNegotiate/SSL_accept", -1, "Connection failed", LOG_LEVEL_INFO);
DEB(                            fprintf(stderr, "SSL_accept() failed - closing socket, return code: %d\n",r);)
                                SetSSLNegotiate(false);
                                SetCloseAndDelete(true);
                                OnSSLAcceptFailed();
                        }
                }
        }
        return false;
}

const std::string & TcpSocket::GetPassword

(

)

[protected]

SSL; Get ssl password.

Definition at line 1528 of file TcpSocket.cpp.

References m_password.

Referenced by SSL_password_cb().

{
        return m_password;
}

TcpSocket& TcpSocket::operator=

(

const TcpSocket &

)

[inline, private]

Definition at line 305 of file TcpSocket.h.

{ return *this; }

void TcpSocket::SendFromOutputBuffer

(

)

[private]

Definition at line 723 of file TcpSocket.cpp.

References GetOutputLength(), Socket::Handler(), Socket::IsDisableRead(), ISocketHandler::ISocketHandler_Mod(), LOG_LEVEL_ERROR, ISocketHandler::LogError(), m_obuf, m_obuf_top, m_output_length, m_transfer_limit, OnTransferLimit(), OnWriteComplete(), and TryWrite().

Referenced by OnWrite(), and SendBuf().

{
        // try send next block in buffer
        // if full block is sent, repeat
        // if all blocks are sent, reset m_wfds

        bool repeat = false;
        size_t sz = m_transfer_limit ? GetOutputLength() : 0;
        do
        {
                if (m_obuf.empty())
                {
                        Handler().LogError(this, "OnWrite", (int)m_output_length, "Empty output buffer in OnWrite", LOG_LEVEL_ERROR);
                        break;
                }
                output_l::iterator it = m_obuf.begin();
                OUTPUT *p = *it;
                repeat = false;
                int n = TryWrite(p -> Buf(), p -> Len());
                if (n > 0)
                {
                        size_t left = p -> Remove(n);
                        m_output_length -= n;
                        if (!left)
                        {
                                delete p;
                                m_obuf.erase(it);
                                if (!m_obuf.size())
                                {
                                        m_obuf_top = NULL;
                                        OnWriteComplete();
                                }
                                else
                                {
                                        repeat = true;
                                }
                        }
                }
        } while (repeat);

        if (m_transfer_limit && sz > m_transfer_limit && GetOutputLength() < m_transfer_limit)
        {
                OnTransferLimit();
        }

        // check output buffer set, set/reset m_wfds accordingly
        {
                bool br = !IsDisableRead();
                if (m_obuf.size())
                        Handler().ISocketHandler_Mod(this, br, true);
                else
                        Handler().ISocketHandler_Mod(this, br, false);
        }
}

int TcpSocket::TryWrite	(	const char *	buf,
		size_t	len
	)			[private]

the actual send()

Definition at line 779 of file TcpSocket.cpp.

References Errno, Socket::GetSocket(), Socket::GetTrafficMonitor(), Socket::Handler(), Socket::IsSSL(), LOG_LEVEL_FATAL, ISocketHandler::LogError(), m_bytes_sent, m_repeat_length, m_ssl, Socket::OnDisconnect(), Socket::SetCloseAndDelete(), StreamSocket::SetFlushBeforeClose(), Socket::SetLost(), StrError, TCP_DISCONNECT_ERROR, TCP_DISCONNECT_SSL, and TCP_DISCONNECT_WRITE.

Referenced by SendBuf(), and SendFromOutputBuffer().

{
        int n = 0;
#ifdef HAVE_OPENSSL
        if (IsSSL())
        {
                n = SSL_write(m_ssl, buf, (int)(m_repeat_length ? m_repeat_length : len));
                if (n == -1)
                {
                        int errnr = SSL_get_error(m_ssl, n);
                        if ( errnr == SSL_ERROR_WANT_READ || errnr == SSL_ERROR_WANT_WRITE )
                        {
                                m_repeat_length = m_repeat_length ? m_repeat_length : len;
                        }
                        else
                        {
                                OnDisconnect();
                                OnDisconnect(TCP_DISCONNECT_WRITE|TCP_DISCONNECT_ERROR|TCP_DISCONNECT_SSL, errnr);
                                SetCloseAndDelete(true);
                                SetFlushBeforeClose(false);
                                SetLost();
                                {
                                        char errbuf[256];
                                        ERR_error_string_n(errnr, errbuf, 256);
                                        Handler().LogError(this, "OnWrite/SSL_write", errnr, errbuf, LOG_LEVEL_FATAL);
                                }
                        }
                        return 0;
                }
                else
                if (!n)
                {
                        OnDisconnect();
                        OnDisconnect(TCP_DISCONNECT_WRITE|TCP_DISCONNECT_SSL, 0);
                        SetCloseAndDelete(true);
                        SetFlushBeforeClose(false);
                        SetLost();
                }
                m_repeat_length = 0;
        }
        else
#endif // HAVE_OPENSSL
        {
                n = send(GetSocket(), buf, (int)len, MSG_NOSIGNAL);
                if (n == -1)
                {
                // normal error codes:
                // WSAEWOULDBLOCK
                //       EAGAIN or EWOULDBLOCK
#ifdef _WIN32
                        if (Errno != WSAEWOULDBLOCK)
#else
                        if (Errno != EWOULDBLOCK)
#endif
                        {       
                                Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_FATAL);
                                OnDisconnect();
                                OnDisconnect(TCP_DISCONNECT_WRITE|TCP_DISCONNECT_ERROR, Errno);
                                SetCloseAndDelete(true);
                                SetFlushBeforeClose(false);
                                SetLost();
                        }
                        return 0;
                }
        }
        if (n > 0)
        {
                m_bytes_sent += n;
                if (GetTrafficMonitor())
                {
                        GetTrafficMonitor() -> fwrite(buf, 1, n);
                }
        }
        return n;
}

void TcpSocket::Buffer	(	const char *	buf,
		size_t	len
	)			[private]

add data to output buffer top

Definition at line 856 of file TcpSocket.cpp.

References m_obuf, m_obuf_top, and m_output_length.

Referenced by SendBuf().

{
        size_t ptr = 0;
        m_output_length += len;
        while (ptr < len)
        {
                // buf/len => pbuf/sz
                size_t space = 0;
                if ((space = m_obuf_top ? m_obuf_top -> Space() : 0) > 0)
                {
                        const char *pbuf = buf + ptr;
                        size_t sz = len - ptr;
                        if (space >= sz)
                        {
                                m_obuf_top -> Add(pbuf, sz);
                                ptr += sz;
                        }
                        else
                        {
                                m_obuf_top -> Add(pbuf, space);
                                ptr += space;
                        }
                }
                else
                {
                        m_obuf_top = new OUTPUT;
                        m_obuf.push_back( m_obuf_top );
                }
        }
}

---

Member Data Documentation

CircularBuffer TcpSocket::ibuf [protected]

Circular input buffer.

Definition at line 302 of file TcpSocket.h.

Referenced by GetInputLength(), OnRead(), OnSocks4Read(), and ReadInput().

bool TcpSocket::m_b_input_buffer_disabled [private]

Definition at line 315 of file TcpSocket.h.

Referenced by DisableInputBuffer(), and OnRead().

uint64_t TcpSocket::m_bytes_sent [private]

Definition at line 316 of file TcpSocket.h.

Referenced by GetBytesSent(), and TryWrite().

uint64_t TcpSocket::m_bytes_received [private]

Definition at line 317 of file TcpSocket.h.

Referenced by GetBytesReceived(), and OnRead().

bool TcpSocket::m_skip_c [private]

Skip second char of CRLF or LFCR sequence in OnRead.

Definition at line 318 of file TcpSocket.h.

Referenced by OnRead().

char TcpSocket::m_c [private]

First char in CRLF or LFCR sequence.

Definition at line 319 of file TcpSocket.h.

Referenced by OnRead().

std::vector<char> TcpSocket::m_line [private]

Current line in line protocol mode.

Reimplemented in HTTPSocket.

Definition at line 320 of file TcpSocket.h.

Referenced by GetLine(), and OnRead().

size_t TcpSocket::m_line_ptr [private]

Definition at line 321 of file TcpSocket.h.

Referenced by GetLine(), and OnRead().

char* TcpSocket::m_buf [private]

temporary read buffer

Definition at line 323 of file TcpSocket.h.

Referenced by OnRead(), and ~TcpSocket().

output_l TcpSocket::m_obuf [private]

output buffer

Definition at line 325 of file TcpSocket.h.

Referenced by Buffer(), SendBuf(), SendFromOutputBuffer(), and ~TcpSocket().

OUTPUT* TcpSocket::m_obuf_top [private]

output buffer on top

Definition at line 326 of file TcpSocket.h.

Referenced by Buffer(), SendBuf(), and SendFromOutputBuffer().

size_t TcpSocket::m_transfer_limit [private]

Definition at line 327 of file TcpSocket.h.

Referenced by SendFromOutputBuffer(), and SetTransferLimit().

size_t TcpSocket::m_output_length [private]

Definition at line 328 of file TcpSocket.h.

Referenced by Buffer(), GetOutputLength(), and SendFromOutputBuffer().

size_t TcpSocket::m_repeat_length [private]

Definition at line 329 of file TcpSocket.h.

Referenced by TryWrite().

SSLInitializer TcpSocket::m_ssl_init [static, private]

Definition at line 332 of file TcpSocket.h.

SSL_CTX* TcpSocket::m_ssl_ctx [private]

ssl context

Definition at line 333 of file TcpSocket.h.

Referenced by GetSslContext(), InitializeContext(), OnSSLAccept(), OnSSLConnect(), and UseCertificateChainFile().

SSL* TcpSocket::m_ssl [private]

ssl 'socket'

Definition at line 334 of file TcpSocket.h.

Referenced by Close(), GetSsl(), OnRead(), OnSSLAccept(), OnSSLConnect(), SSLNegotiate(), TryWrite(), and ~TcpSocket().

BIO* TcpSocket::m_sbio [private]

ssl bio

Definition at line 335 of file TcpSocket.h.

Referenced by OnSSLAccept(), and OnSSLConnect().

std::string TcpSocket::m_password [private]

ssl password

Definition at line 336 of file TcpSocket.h.

Referenced by GetPassword(), and InitializeContext().

Mutex TcpSocket::m_server_ssl_mutex [static, private]

Definition at line 337 of file TcpSocket.h.

Referenced by InitializeContext().

std::map< std::string, SSL_CTX * > TcpSocket::m_client_contexts [static, private]

Definition at line 338 of file TcpSocket.h.

Referenced by InitializeContext().

std::map< std::string, SSL_CTX * > TcpSocket::m_server_contexts [static, private]

Definition at line 339 of file TcpSocket.h.

Referenced by InitializeContext().

int TcpSocket::m_socks4_state [private]

socks4 support

Definition at line 343 of file TcpSocket.h.

Referenced by OnSocks4Connect(), and OnSocks4Read().

char TcpSocket::m_socks4_vn [private]

socks4 support, temporary variable

Definition at line 344 of file TcpSocket.h.

Referenced by OnSocks4Read().

char TcpSocket::m_socks4_cd [private]

socks4 support, temporary variable

Definition at line 345 of file TcpSocket.h.

Referenced by OnSocks4Read().

unsigned short TcpSocket::m_socks4_dstport [private]

socks4 support

Definition at line 346 of file TcpSocket.h.

Referenced by OnSocks4Read().

unsigned long TcpSocket::m_socks4_dstip [private]

socks4 support

Definition at line 347 of file TcpSocket.h.

Referenced by OnSocks4Read().

int TcpSocket::m_resolver_id [private]

Resolver id (if any) for current Open call.

Definition at line 351 of file TcpSocket.h.

Referenced by OnResolved(), and Open().

bool TcpSocket::m_b_reconnect [private]

Reconnect on lost connection flag.

Definition at line 355 of file TcpSocket.h.

Referenced by Reconnect(), and SetReconnect().

bool TcpSocket::m_b_is_reconnect [private]

Trying to reconnect.

Definition at line 356 of file TcpSocket.h.

Referenced by IsReconnect(), and SetIsReconnect().

---

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

• TcpSocket.h
• TcpSocket.cpp