Retail products


Traffic interception SDK

Control every TCP/IP network connection

  • Route connections via proxy
  • Redirect connections and modify the data
  • Block connections and applications
SSL interception SDK

View SSL in plaintext and modify it

  • View the SSL stream decrypted in plaintext
  • Redirect SSL connection and modify decrypted data
  • Browser shows "SSL lock" without warnings

Documentation


CTCPSocketAsyncSSL Member List

This is the complete list of members for CTCPSocketAsyncSSL, including all inherited members.

_AsyncEvents enum nameCAsyncSocket
_SocketShutdown enum nameCSocket
_SSLEvents enum nameCTCPSocketAsyncSSL [protected]
Accept(CTCPSocket *pNewSocket)CTCPSocketAsyncSSL [virtual]
CTCPSocket::Accept()CTCPSocket
AddSocketToList()CAsyncSocket [protected]
aeClose enum valueCAsyncSocket
aeOOB enum valueCAsyncSocket
aeReceive enum valueCAsyncSocket
aeSend enum valueCAsyncSocket
AllowBlockedBuffer(BOOL bAllow)CAsyncSocket
AssignSocket(SOCKET aNewSocket, unsigned char ucProtocol=IPPROTO_TCP)CSocket [protected]
AsyncEvents typedefCAsyncSocket
Bind(IP aSourceAddress, unsigned short usPort)CTCPSocketAsync [virtual]
CTCPSocket::Bind(const std::string &rSourceAddress, unsigned short usPort)CSocket [virtual]
Block()CAsyncSocket [protected]
CanRead() const CSocket
CanWrite() const CSocket
CAsyncSocket()CAsyncSocket
CErrorHandler()CErrorHandler
CErrorHandler(const CErrorHandler &rHandler)CErrorHandler
CheckSocketValid() const CSocket [protected]
CIPCrafter classCSocket [friend]
ClearEvents()CAsyncSocket [protected, virtual]
ClearStaticLogs()CErrorHandler [static]
CloneThreadManager(unsigned long ulThreads)CAsyncSocket [static]
Close()CTCPSocketAsync [virtual]
Connect(IP aDestinationAddress, unsigned short usDestinationPort, BOOL bDisableAsync=FALSE, BOOL bForceErrorEvent=FALSE)CTCPSocketAsyncSSL [virtual]
Connect(const std::string &rDestinationAddress, unsigned short usDestinationPort, BOOL bDisableAsync=FALSE, BOOL bForceErrorEvent=FALSE)CTCPSocketAsyncSSL [virtual]
Connect(unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort, BOOL bDisableAsync=FALSE, BOOL bForceErrorEvent=FALSE)CTCPSocketAsyncSSL [virtual]
Connect(unsigned short usSourcePort, const std::string &rDestinationAddress, unsigned short usDestinationPort, BOOL bDisableAsync=FALSE, BOOL bForceErrorEvent=FALSE)CTCPSocketAsyncSSL [virtual]
CTCPSocket::Connect(unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort)CTCPSocket [virtual]
CTCPSocket::Connect(unsigned short usSourcePort, const std::string &rDestinationAddress, unsigned short usDestinationPort)CTCPSocket [virtual]
CTCPSocket::Connect(IP aDestinationAddress, unsigned short usDestinationPort)CTCPSocket [virtual]
CTCPSocket::Connect(const std::string &rDestinationAddress, unsigned short usDestinationPort)CTCPSocket [virtual]
Create()CTCPSocketAsyncSSL [virtual]
CSocket::Create(int iProtocol)CSocket
CSocket(BOOL bRawSocket=false)CSocket
CSocket(SOCKET aSocket)CSocket [protected]
CSocketBase()CSocketBase
CSocketBase(const CSocketBase &rBase)CSocketBase
CTCPSocket(BOOL bRawSocket=false)CTCPSocket
CTCPSocketAsync(BOOL bRawSocket=false)CTCPSocketAsync
CTCPSocketAsyncSSL(bool bDisableSSL=false)CTCPSocketAsyncSSL
DeleteSocketFromThread()CAsyncSocket [virtual]
DeleteSocketFromThread(DWORD dwTimeToWait)CAsyncSocket [virtual]
DeleteSocketFromThreadWait()CAsyncSocket [virtual]
Detach()CTCPSocketAsync [virtual]
DetachedSocketThread()CAsyncSocket
DisableAsync()CAsyncSocket
DisableBlockingSend()CAsyncSocket
DisableEvents(unsigned char ucEvents)CAsyncSocket
DisableSSL()CTCPSocketAsyncSSL
DontQueue()CTCPSocketAsyncSSL
ErrorCodeToString(DWORD dwErrorCode)CErrorHandler [static]
ForceReceiveEvent()CAsyncSocket
FormatData(const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)CErrorHandler [static]
FreezeThread()CAsyncSocket
GetAsyncHandle() const CTCPSocketAsync [protected, virtual]
GetBindAddress() const CTCPSocketAsync [virtual]
GetBindPort() const CTCPSocketAsync [virtual]
GetBlockedBuffer() const CAsyncSocket [protected]
GetClassName() const CErrorHandler [protected]
GetConnectionTimeout() const CTCPSocketAsync
GetCurrentDateTime()CErrorHandler [static]
GetErrorCode()CSocketBase [static]
GetGlobalCriticalSection()CSocketBase [static]
GetHandle() const CSocket
GetLastError() const CSocketBase
GetNumberOfThreads()CSocketBase [static]
GetOverider() const CTCPSocketAsync
GetPeerAddress() const CSocket
GetPeerPort() const CSocket
GetProtocol() const CSocket
GetSecondaryLog()CErrorHandler [static]
GetSocketID() const CAsyncSocket [protected]
GetSocketThreadManager()CAsyncSocket [protected, static]
GetSourceAddress() const CSocket [protected]
GetSystemLastError()CSocketBase [static]
GetThirdLog()CErrorHandler [static]
GetThreadManager() const CAsyncSocket
GetTTL() const CSocket [protected]
GetWindowHandle() const CAsyncSocket [protected]
HasSystemTimer() const CAsyncSocket [protected]
HasTimeout() const CAsyncSocket
Initialize()CAsyncSocket [static]
InitializeIP()CSocket [protected, virtual]
InitializeSockets(BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10)CSocketBase [static]
InitializeSSL()CTCPSocketAsyncSSL [static]
InternalWSAAsyncSelect(unsigned int wMsg, long lEvent)CAsyncSocket [protected]
IsAsyncClass() const CTCPSocketAsync [protected, virtual]
IsBlocking() const CAsyncSocket [protected]
IsBlockSend() const CAsyncSocket [protected]
IsClosing() const CAsyncSocket
IsConnected() const CTCPSocket
IsCreated() const CSocket
IsDeleting() const CAsyncSocket
IsHandshakeComplete() const CTCPSocketAsyncSSL
IsInitialized()CSocketBase [static]
IsInThread() const CAsyncSocket [protected]
IsMultiThreaded()CSocketBase [static]
IsRaw() const CSocket
IsReadyForSend() const CTCPSocketAsyncSSL
IsTimeout() const CAsyncSocket [protected]
KillSystemTimer()CAsyncSocket [protected]
KillTimer()CAsyncSocket
Listen(unsigned long ulBackLog=5)CTCPSocketAsync [virtual]
LoadCertificatesForServer(const std::string &rPublicKey, const std::string &rPrivateKey)CTCPSocketAsyncSSL
LoadCertificateStore(const std::string &rPEMPath)CTCPSocketAsyncSSL
LocalAccept(CTCPSocket *pNewSocket)CTCPSocketAsync [protected]
LocalBind(IP aSourceAddress, unsigned short usPort)CTCPSocketAsync [protected]
LocalConnect(unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort, BOOL bDisableAsync, BOOL bForceErrorEvent)CTCPSocketAsync [protected]
LocalGetBindAddress() const CTCPSocketAsync [protected]
LocalGetBindPort() const CTCPSocketAsync [protected]
LocalListen(unsigned long ulBackLog)CTCPSocketAsync [protected]
LocalSocketAccept(int iErrorCode, BOOL bNoEvent)CTCPSocketAsync [protected]
LocalSocketClose(int iErrorCode, BOOL bNoEvent)CTCPSocketAsync [protected]
LocalSocketConnect(int iErrorCode, BOOL bNoEvent)CTCPSocketAsync [protected]
LocalSocketReceive(int iErrorCode, BOOL bNoEvent)CTCPSocketAsync [protected]
LongToStdString(unsigned long ulAddr)CSocketBase [static]
LongToString(unsigned long ulAddr)CSocketBase [static]
LPMapProc typedefCAsyncSocket
m_pCSectionCSocketBase [protected, static]
MapProc typedefCAsyncSocket
NotifyShutdown()CSocketBase [protected, virtual]
OnSocketAccept(int iErrorCode)=0CAsyncSocket [protected, pure virtual]
OnSocketClose(int iErrorCode)=0CAsyncSocket [protected, pure virtual]
OnSocketConnect(int iErrorCode)=0CAsyncSocket [protected, pure virtual]
OnSocketDelete(CGenericEvent *pEvent=NULL)CAsyncSocket [protected, virtual]
OnSocketOOB(int iErrorCode)=0CAsyncSocket [protected, pure virtual]
OnSocketReceive(int iErrorCode)=0CAsyncSocket [protected, pure virtual]
OnSocketTimeout()=0CAsyncSocket [protected, pure virtual]
OnSocketWrite(int iErrorCode)=0CAsyncSocket [protected, pure virtual]
OnSSLError(const std::string &rMethod, const std::string &rMessage, const std::string &rSSLError) const CTCPSocketAsyncSSL [protected, virtual]
OnSSLEvent(SSLEvents) const CTCPSocketAsyncSSL [protected, virtual]
operator const CTCPSocketOverider *() const CTCPSocketAsync
operator<(const CSocket &rSocket) const CSocket
operator==(const CSocket &rSocket) const CSocket
Peek(char *pBuffer, unsigned long ulBufferLength)CTCPSocketAsyncSSL [virtual]
ReAsync()CAsyncSocket [virtual]
ReBlock()CAsyncSocket [virtual]
Receive(char *pBuffer, unsigned long ulBufferLength)CTCPSocketAsyncSSL [virtual]
ReceiveFrom(char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort)CSocket [protected, virtual]
RegisterError(DWORD dwErrorCode, const std::string &rDescription)CErrorHandler [static]
RegisterShutdown(CSocketBase *pBase)CSocketBase [protected]
RegisterTimeout(int iMS, CSocketThreadManagerImp::LPTimeoutProc pProc, LPVOID pData, BOOL bClearTimeout=FALSE, CSocketThreadManagerImp::TimerID *pTimer=NULL)CAsyncSocket
RemoveSocketFromList()CAsyncSocket [protected]
ReportError(const std::string &rMethod) const CErrorHandler [protected, virtual]
ReportError(const std::string &rMethod, const std::string &rMessage) const CErrorHandler [protected, virtual]
ReportError(const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const CErrorHandler [protected, virtual]
ReportError(const std::string &rMethod, const std::string &rMessage, const std::string &rAdditionalData) const CErrorHandler [protected, virtual]
ReportError(const std::string &rMethod, int iErrorCode) const CErrorHandler [protected, virtual]
ReportError(const std::string &rMethod, const std::string &rMessage, int iErrorCode) const CErrorHandler [protected, virtual]
ReportErrorOS(const std::string &rMethod, const std::string &rMessage) const CErrorHandler [protected, virtual]
ReportStaticError(const std::string &rClass, const std::string &rMethod)CErrorHandler [protected, static]
ReportStaticError(const std::string &rClass, const std::string &rMethod, const std::string &rMessage)CErrorHandler [protected, static]
ReportStaticError(const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)CErrorHandler [protected, static]
ReportStaticErrorOS(const std::string &rClass, const std::string &rMethod, const std::string &rMessage)CErrorHandler [protected, static]
ResetEvent()CAsyncSocket [protected]
ResolveDNS(const std::string &rAddress)CSocketBase [static]
seBadCertificate enum valueCTCPSocketAsyncSSL [protected]
seHandshakeFinished enum valueCTCPSocketAsyncSSL [protected]
Send(const char *pBuffer, unsigned long ulBufferLength)CTCPSocketAsyncSSL [virtual]
CSocket::Send(IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0)CSocket [virtual]
CSocket::Send(const std::string &rDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0)CSocket [virtual]
SendBlockedBuffer(const CBlockedBuffer::CBlockedData &rData)CTCPSocketAsync [protected, virtual]
SendNoAdd(const char *pBuffer, unsigned long ulBufferLength)CTCPSocketAsync [protected, virtual]
SetAcceptance(CTCPSocket *pNewSocket, SOCKET aSocket, sockaddr_in aAddress) const CTCPSocket [protected]
SetAsync()CTCPSocketAsync [protected, virtual]
SetBroadcast(BOOL bBroadcast)CSocket
SetCleanTimeout(DWORD dwTimeout)CAsyncSocket [static]
SetConnectedTo(const sockaddr_in &rAddress)CSocket [protected]
SetConnectionStatus(BOOL bConnected)CTCPSocket [protected]
SetConnectionTimeout(unsigned long ulMS)CTCPSocketAsync
SetDeleting()CAsyncSocket
SetInstance(HINSTANCE hInst)CAsyncSocket [static]
SetLastError(const std::string &rMethod) const CSocketBase [protected]
SetLastError(const std::string &, int iErrorCode) const CSocketBase [protected]
SetLinkedSocket(CTCPSocketAsync *pSocket, CTCPSocketOverider *pOverider)CTCPSocketAsync
SetLocalLog(CErrorLog *pLog, bool bWriteToMain=false)CErrorHandler
SetLocalThreadManager(CSocketThreadManagerImp *pManager)CAsyncSocket
SetLog(CErrorLog *pLog)CErrorHandler [static]
SetNagle(BOOL bNagle)CTCPSocket
SetName(const std::string &rName) const CErrorHandler [protected]
SetProtocol(unsigned char iProtocol)CSocket
SetReceiveTimeout(unsigned long ulMS)CSocket
SetSourceAddress(IP aSourceAddress)CSocket [virtual]
SetSourceAddress(const std::string &rSourceAddress)CSocket [virtual]
SetSystemTimeout(int iMS)CAsyncSocket [protected]
SetTimeout(int iMs)CAsyncSocket
SetTTL(unsigned char ucTTL)CSocket
CTCPSocket::Shutdown(SocketShutdown eHow)CSocket
CAsyncSocket::Shutdown()CAsyncSocket [static]
ShutdownSockets()CSocketBase [static]
SimpleMessageMap()CAsyncSocket [static]
SimpleMessageMap(DWORD dwRunTimeMS)CAsyncSocket [static]
SimpleMessageMap(LPMapProc pProc, BOOL bStopWhenTRUE, DWORD dwSleep)CAsyncSocket [static]
SimpleMessageMapKey(DWORD dwSleep)CAsyncSocket [static]
SocketAccept(int iErrorCode, BOOL bNoEvent=FALSE)CAsyncSocket [protected, virtual]
SocketClosed(int iErrorCode, BOOL bNoEvent)CTCPSocketAsync [protected, virtual]
SocketClosing()CAsyncSocket [protected]
SocketConnected(int iErrorCode, BOOL bNoEvent)CTCPSocketAsyncSSL [protected, virtual]
SocketCreated()CAsyncSocket [protected, virtual]
SocketReceive(int iErrorCode, BOOL bNoEvent)CTCPSocketAsyncSSL [protected, virtual]
SocketShutdown typedefCSocket
SocketWrite(int iErrorCode)CTCPSocketAsyncSSL [protected, virtual]
ssBoth enum valueCSocket
SSLEvents typedefCTCPSocketAsyncSSL [protected]
ssReceive enum valueCSocket
ssSend enum valueCSocket
StringToLong(const std::string &rAddress)CSocketBase [static]
UninitializeSSL()CTCPSocketAsyncSSL [static]
ValidAddress(const std::string &rAddress)CSocketBase [static]
ValidSocket() const CSocket [protected]
WaitForBlockEvent() const CAsyncSocket [protected]
WriteError(const std::string &rClass, const std::string &rMethod, const std::string &rError) const CErrorHandler
WriteMessage(const std::string &rClass, const std::string &rMethod, const std::string &rMessage) const CErrorHandler
WriteMessage(const std::string &rMethod, const std::string &rMessage) const CErrorHandler [protected]
WriteStaticError(const std::string &rClass, const std::string &rMethod, const std::string &rError)CErrorHandler [static]
WriteStaticMessage(const std::string &rClass, const std::string &rMethod, const std::string &rMessage)CErrorHandler [static]
~CAsyncSocket()CAsyncSocket [virtual]
~CErrorHandler()CErrorHandler [virtual]
~CSocket()CSocket [virtual]
~CSocketBase()CSocketBase [virtual]
~CTCPSocket()CTCPSocket [virtual]
~CTCPSocketAsync()CTCPSocketAsync [virtual]
~CTCPSocketAsyncSSL()CTCPSocketAsyncSSL [virtual]