C++ Sockets Library documentation

#ifndef _BASE64_H

#define _BASE64_H

#ifndef _SOCKETS_Base64_H

#define _SOCKETS_Base64_H

#endif // _BASE64_H

#endif // _SOCKETS_Base64_H

#ifndef _CTCPSOCKET_H

#define _CTCPSOCKET_H

#ifndef _SOCKETS_CTcpSocket_H

#define _SOCKETS_CTcpSocket_H

#endif // _CTCPSOCKET_H

#endif // _SOCKETS_CTcpSocket_H

#ifndef _CIRCULARBUFFER_H

#define _CIRCULARBUFFER_H

#ifndef _SOCKETS_CircularBuffer_H

#define _SOCKETS_CircularBuffer_H

#endif // _CIRCULARBUFFER_H

#endif // _SOCKETS_CircularBuffer_H

#ifndef _EVENT_H

#define _EVENT_H

#ifndef _SOCKETS_Event_H

#define _SOCKETS_Event_H

#endif // _EVENT_H

#endif // _SOCKETS_Event_H

#include "EventSocket.h"

#include "TcpSocket.h"

ListenSocket<EventSocket> *l = new ListenSocket<EventSocket>(*this);

m_socket = new EventSocket( *this );

ListenSocket<TcpSocket> *l = new ListenSocket<TcpSocket>(*this);

m_socket = new TcpSocket( *this );

#ifndef _EVENTHANDLER_H

#define _EVENTHANDLER_H

#ifndef _SOCKETS_EventHandler_H

#define _SOCKETS_EventHandler_H

class EventSocket;

class TcpSocket;

EventSocket *m_socket;

TcpSocket *m_socket;

#endif // _EVENTHANDLER_H

#endif // _SOCKETS_EventHandler_H

#ifndef _SOCKETS_EVENTTIME_H

#define _SOCKETS_EVENTTIME_H

#ifndef _SOCKETS_EventTime_H

#define _SOCKETS_EventTime_H

#endif // _SOCKETS_EVENTTIME_H

#endif // _SOCKETS_EventTime_H

#ifndef _SOCKETS_FILE_H

#define _SOCKETS_FILE_H

#ifndef _SOCKETS_File_H

#define _SOCKETS_File_H

#endif // _SOCKETS_FILE_H

#endif // _SOCKETS_File_H

#ifndef _HTTPSOCKET_H

#define _HTTPSOCKET_H

#ifndef _SOCKETS_HTTPSocket_H

#define _SOCKETS_HTTPSocket_H

#endif // _HTTPSOCKET_H

#endif // _SOCKETS_HTTPSocket_H

#ifndef _HTTPCLIENTSOCKET_H

#define _HTTPCLIENTSOCKET_H

#ifndef _SOCKETS_HttpClientSocket_H

#define _SOCKETS_HttpClientSocket_H

#endif // _HTTPCLIENTSOCKET_H

#endif // _SOCKETS_HttpClientSocket_H

#ifndef _HttpDebugSocket_H

#define _HttpDebugSocket_H

#ifndef _SOCKETS_HttpDebugSocket_H

#define _SOCKETS_HttpDebugSocket_H

#endif // _HttpDebugSocket_H

#endif // _SOCKETS_HttpDebugSocket_H

#ifndef _HTTPGETSOCKET_H

#define _HTTPGETSOCKET_H

#ifndef _SOCKETS_HttpGetSocket_H

#define _SOCKETS_HttpGetSocket_H

#endif // _HTTPGETSOCKET_H

#endif // _SOCKETS_HttpGetSocket_H

#ifndef _HTTPPOSTSOCKET_H

#define _HTTPPOSTSOCKET_H

#ifndef _SOCKETS_HttpPostSocket_H

#define _SOCKETS_HttpPostSocket_H

#endif // _HTTPPOSTSOCKET_H

#endif // _SOCKETS_HttpPostSocket_H

#ifndef _HTTPPUTSOCKET_H

#define _HTTPPUTSOCKET_H

#ifndef _SOCKETS_HttpPutSocket_H

#define _SOCKETS_HttpPutSocket_H

#endif // _HTTPPUTSOCKET_H

#endif // _SOCKETS_HttpPutSocket_H

#ifndef _COOKIES_H

#define _COOKIES_H

#ifndef _SOCKETS_HttpdCookies_H

#define _SOCKETS_HttpdCookies_H

#endif // _COOKIES_H

#endif // _SOCKETS_HttpdCookies_H

#ifndef _FORM_H

#define _FORM_H

#ifndef _SOCKETS_HttpdForm_H

#define _SOCKETS_HttpdForm_H

#endif // _FORM_H

#endif // _SOCKETS_HttpdForm_H

#ifndef _HTTPDSOCKET_H

#define _HTTPDSOCKET_H

#ifndef _SOCKETS_HttpdSocket_H

#define _SOCKETS_HttpdSocket_H

#endif // _HTTPDSOCKET_H

#endif // _SOCKETS_HttpdSocket_H

#ifndef _ICRYPT_H

#define _ICRYPT_H

#ifndef _SOCKETS_ICrypt_H

#define _SOCKETS_ICrypt_H

#endif // _ICRYPT_H

#endif // _SOCKETS_ICrypt_H

#ifndef _IEVENTHANDLER_H

#define _IEVENTHANDLER_H

#ifndef _SOCKETS_IEventHandler_H

#define _SOCKETS_IEventHandler_H

#endif // _IEVENTHANDLER_H

#endif // _SOCKETS_IEventHandler_H

IEventOwner::IEventOwner(IEventHandler& h) : m_event_handler(h)

IEventOwner::IEventOwner(IEventHandler& h) : m_event_handler(h), m_handler_invalid(false), m_events(0)

#ifndef _IEVENTOWNER_H

#define _IEVENTOWNER_H

#ifndef _SOCKETS_IEventOwner_H

#define _SOCKETS_IEventOwner_H

#endif // _IEVENTOWNER_H

#endif // _SOCKETS_IEventOwner_H

#ifndef _IFILE_H

#define _IFILE_H

#ifndef _SOCKETS_IFile_H

#define _SOCKETS_IFile_H

#endif // _IFILE_H

#endif // _SOCKETS_IFile_H

#ifndef _ISOCKETHANDLER_H

#define _ISOCKETHANDLER_H

#ifndef _SOCKETS_ISocketHandler_H

#define _SOCKETS_ISocketHandler_H

virtual PoolSocket *FindConnection(int type,const std::string& protocol,SocketAddress&) {

virtual ISocketHandler::PoolSocket *FindConnection(int type,const std::string& protocol,SocketAddress&) {

#endif // _ISOCKETHANDLER_H

#endif // _SOCKETS_ISocketHandler_H

#ifndef _IPV4ADDRESS_H

#define _IPV4ADDRESS_H

#ifndef _SOCKETS_Ipv4Address_H

#define _SOCKETS_Ipv4Address_H

#endif // _IPV4ADDRESS_H

#endif // _SOCKETS_Ipv4Address_H

#ifndef _IPV6ADDRESS_H

#define _IPV6ADDRESS_H

#ifndef _SOCKETS_Ipv6Address_H

#define _SOCKETS_Ipv6Address_H

#endif // _IPV6ADDRESS_H

#endif // _SOCKETS_Ipv6Address_H

#ifndef _LISTENSOCKET_H

#define _LISTENSOCKET_H

#ifndef _SOCKETS_ListenSocket_H

#define _SOCKETS_ListenSocket_H

#endif // _LISTENSOCKET_H

#endif // _SOCKETS_ListenSocket_H

#ifndef _SOCKETS_LOCK_H

#define _SOCKETS_LOCK_H

#ifndef _SOCKETS_Lock_H

#define _SOCKETS_Lock_H

#endif // _SOCKETS_LOCK_H

#endif // _SOCKETS_Lock_H

VERSION = 2.1.3

DIFF_VERSION = 2.1.2

VERSION = 2.1.4

DIFF_VERSION = 2.1.3

Thread.o SocketThread.o \

Thread.o \

EventSocket.o \

SSLInitializer.o

SSLInitializer.o \

SmtpdSocket.o

#ifndef _MEMFILE_H

#define _MEMFILE_H

#ifndef _SOCKETS_MemFile_H

#define _SOCKETS_MemFile_H

#endif // _MEMFILE_H

#endif // _SOCKETS_MemFile_H

#ifndef _MINION_MINDERHANDLER_H

#define _MINION_MINDERHANDLER_H

#ifndef _MINION_MinderHandler_H

#define _MINION_MinderHandler_H

#endif // _MINION_MINDERHANDLER_H

#endif // _MINION_MinderHandler_H

#ifndef _MINDERSOCKET_H

#define _MINDERSOCKET_H

#ifndef _SOCKETS_MinderSocket_H

#define _SOCKETS_MinderSocket_H

#endif // _MINDERSOCKET_H

#endif // _SOCKETS_MinderSocket_H

#ifndef _MINIONSOCKET_H

#define _MINIONSOCKET_H

#ifndef _SOCKETS_MinionSocket_H

#define _SOCKETS_MinionSocket_H

#endif // _MINIONSOCKET_H

#endif // _SOCKETS_MinionSocket_H

#ifndef _SOCKETS_MUTEX_H

#define _SOCKETS_MUTEX_H

#ifndef _SOCKETS_Mutex_H

#define _SOCKETS_Mutex_H

#endif // _SOCKETS_MUTEX_H

#endif // _SOCKETS_Mutex_H

#ifndef _NULLCRYPT_H

#define _NULLCRYPT_H

#ifndef _SOCKETS_NullCrypt_H

#define _SOCKETS_NullCrypt_H

#endif // _NULLCRYPT_H

#endif // _SOCKETS_NullCrypt_H

#ifndef _PARSE_H

#define _PARSE_H

#ifndef _SOCKETS_Parse_H

#define _SOCKETS_Parse_H

#endif // _PARSE_H

#endif // _SOCKETS_Parse_H

#ifndef RANDOM_NUMBER_H

#define RANDOM_NUMBER_H

#ifndef _SOCKET_RandomNumber_H

#define _SOCKET_RandomNumber_H

#endif

#endif // _SOCKETS_RandomNumber_H

#ifndef _RESOLVSERVER_H

#define _RESOLVSERVER_H

#ifndef _SOCKETS_ResolvServer_H

#define _SOCKETS_ResolvServer_H

#endif // _RESOLVSERVER_H

#endif // _SOCKETS_ResolvServer_H

#ifndef _RESOLVSOCKET_H

#define _RESOLVSOCKET_H

#ifndef _SOCKETS_ResolvSocket_H

#define _SOCKETS_ResolvSocket_H

#endif // _RESOLVSOCKET_H

#endif // _SOCKETS_ResolvSocket_H

#ifndef _SSLINITIALIZER_H

#define _SSLINITIALIZER_H

#ifndef __SOCKETS_SSLInitializer_H

#define __SOCKETS_SSLInitializer_H

#endif // _SSLINITIALIZER_H

#endif // __SOCKETS_SSLInitializer_H

#ifndef _SOCKETS_NAMESPACE_SCTPSOCKET_H

#define _SOCKETS_NAMESPACE_SCTPSOCKET_H

#ifndef _SOCKETS_SctpSocket_H

#define _SOCKETS_SctpSocket_H

#endif // _SOCKETS_NAMESPACE_SCTPSOCKET_H

#endif // _SOCKETS_SctpSocket_H

#ifndef _SOCKETS_SEMAPHORE_H

#define _SOCKETS_SEMAPHORE_H

#ifndef _SOCKETS_Semaphore_H

#define _SOCKETS_Semaphore_H

#endif // _SOCKETS_SEMAPHORE_H

#endif // _SOCKETS_Semaphore_H

if (IsConnected())

if (IsConnected() && !(GetShutdown() & SHUT_WR))

#ifdef ENABLE_POOL

void Socket::CopyConnection(Socket *sock)

{

Attach( sock -> GetSocket() );

#ifdef ENABLE_IPV6

SetIpv6( sock -> IsIpv6() );

#endif

SetSocketType( sock -> GetSocketType() );

SetSocketProtocol( sock -> GetSocketProtocol() );

/*

SocketAddress *client = sock -> GetClientRemoteAddress();

if (client)

{

SetClientRemoteAddress( *client );

}

*/

SetClientRemoteAddress( *sock -> GetClientRemoteAddress() );

/*

SocketAddress *remote = GetRemoteSocketAddress();

if (remote)

SetRemoteAddress(*remote);

}

*/

SetRemoteAddress( *sock -> GetRemoteSocketAddress() );

#ifdef ENABLE_RESOLVER

int Socket::Resolve(const std::string& host,port_t port)

return Handler().Resolve(this, host, port);

#ifdef ENABLE_IPV6

int Socket::Resolve6(const std::string& host,port_t port)

int Socket::Resolve(ipaddr_t a)

return Handler().Resolve(this, a);

int Socket::Resolve(in6_addr& a)

return Handler().Resolve(this, a);

#ifdef ENABLE_SOCKS4

void Socket::OnSocks4Connect()

Handler().LogError(this, "OnSocks4Connect", 0, "Use with TcpSocket only");

void Socket::OnSocks4ConnectFailed()

Handler().LogError(this, "OnSocks4ConnectFailed", 0, "Use with TcpSocket only");

bool Socket::OnSocks4Read()

Handler().LogError(this, "OnSocks4Read", 0, "Use with TcpSocket only");

return true;

void Socket::SetSocks4Host(const std::string& host)

Utility::u2ip(host, m_socks4_host);

/*

void Socket::OnWriteComplete()

#ifdef ENABLE_RESOLVER

void Socket::OnResolved(int,ipaddr_t,port_t)

#ifdef ENABLE_IPV6

void Socket::OnResolved(int,in6_addr&,port_t)

void Socket::OnReverseResolved(int,const std::string&)

void Socket::OnResolveFailed(int)

Socket *Socket::Create()

return NULL;

#ifdef HAVE_OPENSSL

void Socket::OnSSLConnect()

void Socket::OnSSLAccept()

bool Socket::OnConnectRetry()

#ifdef ENABLE_RECONNECT

void Socket::OnReconnect()

#ifdef HAVE_OPENSSL

bool Socket::SSLNegotiate()

return false;

time_t Socket::Uptime()

return time(NULL) - m_tCreate;

#ifdef ENABLE_DETACH

void Socket::OnDetached()

void Socket::SetDetach(bool x)

Handler().AddList(m_socket, LIST_DETACH, x);

m_detach = x;

bool Socket::IsDetach()

return m_detach;

void Socket::SetDetached(bool x)

m_detached = x;

const bool Socket::IsDetached() const

return m_detached;

#ifdef ENABLE_IPV6

void Socket::SetIpv6(bool x)

m_ipv6 = x;

bool Socket::IsIpv6()

#ifdef ENABLE_POOL

void Socket::SetIsClient()

m_bClient = true;

void Socket::SetSocketType(int x)

m_socket_type = x;

int Socket::GetSocketType()

return m_socket_type;

void Socket::SetSocketProtocol(const std::string& x)

m_socket_protocol = x;

const std::string& Socket::GetSocketProtocol()

return m_socket_protocol;

void Socket::SetRetain()

if (m_bClient) m_bRetain = true;

bool Socket::Retain()

return m_bRetain;

void Socket::SetLost()

m_bLost = true;

bool Socket::Lost()

return m_bLost;

void Socket::SetCallOnConnect(bool x)

Handler().AddList(m_socket, LIST_CALLONCONNECT, x);

m_call_on_connect = x;

bool Socket::CallOnConnect()

void Socket::SetReuse(bool x)

void Socket::SetKeepalive(bool x)

m_opt_keepalive = x;

#ifdef ENABLE_SOCKS4

bool Socket::Socks4()

return m_bSocks4;

void Socket::SetSocks4(bool x)

m_bSocks4 = x;

void Socket::SetSocks4Host(ipaddr_t a)

m_socks4_host = a;

void Socket::SetSocks4Port(port_t p)

m_socks4_port = p;

void Socket::SetSocks4Userid(const std::string& x)

m_socks4_userid = x;

ipaddr_t Socket::GetSocks4Host()

return m_socks4_host;

port_t Socket::GetSocks4Port()

const std::string& Socket::GetSocks4Userid()

void Socket::SetConnectTimeout(int x)

m_connect_timeout = x;

int Socket::GetConnectTimeout()

return m_connect_timeout;

#ifdef HAVE_OPENSSL

bool Socket::IsSSL()

return m_b_enable_ssl;

void Socket::EnableSSL(bool x)

m_b_enable_ssl = x;

bool Socket::IsSSLNegotiate()

return m_b_ssl;

void Socket::SetSSLNegotiate(bool x)

m_b_ssl = x;

bool Socket::IsSSLServer()

return m_b_ssl_server;

void Socket::SetSSLServer(bool x)

m_b_ssl_server = x;

void Socket::DisableRead(bool x)

m_b_disable_read = x;

bool Socket::IsDisableRead()

return m_b_disable_read;

void Socket::SetRetryClientConnect(bool x)

Handler().AddList(m_socket, LIST_RETRY, x);

m_b_retry_connect = x;

bool Socket::RetryClientConnect()

return m_b_retry_connect;

void Socket::SendBuf(const char *,size_t,int)

void Socket::Send(const std::string&,int)

void Socket::SetConnected(bool x)

m_connected = x;

bool Socket::IsConnected()

return m_connected;

void Socket::SetFlushBeforeClose(bool x)

m_flush_before_close = x;

bool Socket::GetFlushBeforeClose()

return m_flush_before_close;

#ifdef HAVE_OPENSSL

void Socket::OnSSLConnectFailed()

void Socket::OnSSLAcceptFailed()

int Socket::GetConnectionRetry()

return m_connection_retry;

void Socket::SetConnectionRetry(int x)

m_connection_retry = x;

int Socket::GetConnectionRetries()

return m_retries;

void Socket::IncreaseConnectionRetries()

void Socket::ResetConnectionRetries()

m_retries = 0;

#ifdef ENABLE_RECONNECT

void Socket::OnDisconnect()

void Socket::SetErasedByHandler(bool x)

m_b_erased_by_handler = x;

bool Socket::ErasedByHandler()

return m_b_erased_by_handler;

time_t Socket::TimeSinceClose()

return time(NULL) - m_tClose;

void Socket::SetShutdown(int x)

m_shutdown = x;

int Socket::GetShutdown()

return m_shutdown;

void Socket::SetClientRemoteAddress(SocketAddress& ad)

{

if (!ad.IsValid())

Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);

m_client_remote_address = ad.GetCopy();

std::auto_ptr<SocketAddress> Socket::GetClientRemoteAddress()

if (!m_client_remote_address.get())

Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);

return std::auto_ptr<SocketAddress>(m_client_remote_address -> GetCopy());

uint64_t Socket::GetBytesSent(bool)

uint64_t Socket::GetBytesReceived(bool)

unsigned long int Socket::Random()

Socket *Socket::Create()

return NULL;

bool Socket::OnConnectRetry()

return true;

#ifdef ENABLE_RECONNECT

void Socket::OnReconnect()

time_t Socket::Uptime()

return time(NULL) - m_tCreate;

void Socket::SetIpv6(bool x)

m_ipv6 = x;

bool Socket::IsIpv6()

return m_ipv6;

void Socket::SetCallOnConnect(bool x)

Handler().AddList(m_socket, LIST_CALLONCONNECT, x);

m_call_on_connect = x;

bool Socket::CallOnConnect()

return m_call_on_connect;

void Socket::SetReuse(bool x)

m_opt_reuse = x;

void Socket::SetKeepalive(bool x)

void Socket::SetConnectTimeout(int x)

int Socket::GetConnectTimeout()

void Socket::DisableRead(bool x)

bool Socket::IsDisableRead()

void Socket::SetRetryClientConnect(bool x)

Handler().AddList(m_socket, LIST_RETRY, x);

m_b_retry_connect = x;

bool Socket::RetryClientConnect()

void Socket::SendBuf(const char *,size_t,int)

void Socket::Send(const std::string&,int)

void Socket::SetConnected(bool x)

bool Socket::IsConnected()

return m_connected;

void Socket::SetFlushBeforeClose(bool x)

m_flush_before_close = x;

bool Socket::GetFlushBeforeClose()

int Socket::GetConnectionRetry()

return m_connection_retry;

void Socket::SetConnectionRetry(int x)

m_connection_retry = x;

int Socket::GetConnectionRetries()

return m_retries;

void Socket::IncreaseConnectionRetries()

m_retries++;

void Socket::ResetConnectionRetries()

m_retries = 0;

#ifdef ENABLE_RECONNECT

void Socket::OnDisconnect()

void Socket::SetErasedByHandler(bool x)

m_b_erased_by_handler = x;

bool Socket::ErasedByHandler()

return m_b_erased_by_handler;

time_t Socket::TimeSinceClose()

return time(NULL) - m_tClose;

void Socket::SetShutdown(int x)

m_shutdown = x;

int Socket::GetShutdown()

return m_shutdown;

void Socket::SetClientRemoteAddress(SocketAddress& ad)

if (!ad.IsValid())

{

Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);

}

m_client_remote_address = ad.GetCopy();

std::auto_ptr<SocketAddress> Socket::GetClientRemoteAddress()

if (!m_client_remote_address.get())

{

Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);

}

return std::auto_ptr<SocketAddress>(m_client_remote_address -> GetCopy());

uint64_t Socket::GetBytesSent(bool)

return 0;

uint64_t Socket::GetBytesReceived(bool)

return 0;

unsigned long int Socket::Random()

return m_prng.next();

#ifdef HAVE_OPENSSL

void Socket::OnSSLConnect()

void Socket::OnSSLAccept()

bool Socket::SSLNegotiate()

return false;

bool Socket::IsSSL()

return m_b_enable_ssl;

void Socket::EnableSSL(bool x)

m_b_enable_ssl = x;

bool Socket::IsSSLNegotiate()

return m_b_ssl;

void Socket::SetSSLNegotiate(bool x)

m_b_ssl = x;

bool Socket::IsSSLServer()

return m_b_ssl_server;

void Socket::SetSSLServer(bool x)

m_b_ssl_server = x;

void Socket::OnSSLConnectFailed()

void Socket::OnSSLAcceptFailed()

void Socket::SetIsClient()

m_bClient = true;

void Socket::SetSocketType(int x)

m_socket_type = x;

int Socket::GetSocketType()

return m_socket_type;

void Socket::SetSocketProtocol(const std::string& x)

m_socket_protocol = x;

const std::string& Socket::GetSocketProtocol()

return m_socket_protocol;

void Socket::SetRetain()

if (m_bClient) m_bRetain = true;

bool Socket::Retain()

return m_bRetain;

void Socket::SetLost()

m_bLost = true;

bool Socket::Lost()

return m_bLost;

#ifdef ENABLE_SOCKS4

void Socket::OnSocks4Connect()

Handler().LogError(this, "OnSocks4Connect", 0, "Use with TcpSocket only");

void Socket::OnSocks4ConnectFailed()

Handler().LogError(this, "OnSocks4ConnectFailed", 0, "Use with TcpSocket only");

bool Socket::OnSocks4Read()

Handler().LogError(this, "OnSocks4Read", 0, "Use with TcpSocket only");

return true;

void Socket::SetSocks4Host(const std::string& host)

bool Socket::Socks4()

void Socket::SetSocks4(bool x)

m_bSocks4 = x;

void Socket::SetSocks