CUDPSocketAsync Class Reference

#include <UDPSocketAsync.h>

Inheritance diagram for CUDPSocketAsync:

Collaboration diagram for CUDPSocketAsync:


Public Types
enum	_SocketShutdown { ssReceive, ssSend, ssBoth }
typedef enum CSocket::_SocketShutdown	SocketShutdown
Public Member Functions
virtual BOOL	Send (IP aDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned short usBufferLength)
virtual BOOL	Send (const std::string &rDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned short usBufferLength)
virtual BOOL	Close ()
virtual BOOL	Listen ()
virtual BOOL	Create ()
	CUDPSocketAsync (BOOL bRawSocket=false)
virtual	~CUDPSocketAsync ()
BOOL	Create (int iProtocol)
virtual int	Receive (char *pBuffer, unsigned long ulBufferLength)
virtual int	Receive (char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort)
virtual int	Send (IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0)
virtual int	Send (const std::string &rDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0)
unsigned char	GetProtocol () const
void	SetProtocol (unsigned char iProtocol)
BOOL	IsRaw () const
BOOL	SetReceiveTimeout (unsigned long ulMS)
SOCKET	GetHandle () const
virtual SOCKET	Detach ()
BOOL	SetBroadcast (BOOL bBroadcast)
BOOL	IsCreated () const
BOOL	CanWrite () const
BOOL	CanRead () const
unsigned short	GetPeerPort () const
BOOL	Shutdown (SocketShutdown eHow)
long	GetPeerAddress () const
virtual int	Peek (char *pBuffer, unsigned long ulBufferLength)
void	SetTTL (unsigned char ucTTL)
virtual void	SetSourceAddress (IP aSourceAddress)
virtual void	SetSourceAddress (const std::string &rSourceAddress)
virtual IP	GetBindAddress () const
virtual unsigned short	GetBindPort () const
virtual BOOL	Bind (const std::string &rSourceAddress, unsigned short usPort)
virtual BOOL	Bind (IP aSourceAddress, unsigned short usPort)
bool	operator== (const CSocket &rSocket) const
bool	operator< (const CSocket &rSocket) const
int	GetLastError () const
void	SetLocalLog (CErrorLog *pLog)
void	WriteError (const std::string &rClass, const std::string &rMethod, const std::string &rError) const
void	WriteMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage) const
void	DetachedSocketThread ()
void	DisableBlockingSend ()
BOOL	SetLocalThreadManager (CSocketThreadManagerImp *pManager)
CSocketThreadManagerImp *	GetThreadManager () const
CSocketThreadManager::TimerID	RegisterTimeout (int iMS, CSocketThreadManagerImp::LPTimeoutProc pProc, LPVOID pData, BOOL bClearTimeout=FALSE, CSocketThreadManagerImp::TimerID *pTimer=NULL)
BOOL	HasTimeout () const
void	DisableEvents (unsigned char ucEvents)
BOOL	IsDeleting () const
void	SetDeleting ()
BOOL	IsClosing () const
void	ForceReceiveEvent ()
virtual void	DeleteSocketFromThread ()
virtual void	DeleteSocketFromThread (DWORD dwTimeToWait)
virtual void	DeleteSocketFromThreadWait ()
void	AllowBlockedBuffer (BOOL bAllow)
virtual BOOL	ReAsync ()
virtual BOOL	ReBlock ()
void	FreezeThread ()
BOOL	DisableAsync ()
BOOL	KillTimer ()
BOOL	SetTimeout (int iMs)
Static Public Member Functions
static int	GetErrorCode ()
static int	GetSystemLastError ()
static BOOL	IsInitialized ()
static unsigned long	StringToLong (const std::string &rAddress)
static char FAR *	LongToString (unsigned long ulAddr)
static std::string	LongToStdString (unsigned long ulAddr)
static BOOL	InitializeSockets (BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10)
static BOOL	ShutdownSockets ()
static unsigned long	GetNumberOfThreads ()
static BOOL	IsMultiThreaded ()
static CGenericCriticalSection *	GetGlobalCriticalSection ()
static unsigned long	ResolveDNS (const std::string &rAddress)
static BOOL	ValidAddress (const std::string &rAddress)
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	RegisterError (DWORD dwErrorCode, const std::string &rDescription)
static void	SetLog (CErrorLog *pLog)
static void	WriteStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rError)
static std::string	FormatData (const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)
static CSocketThreadManagerImp *	CloneThreadManager (unsigned long ulThreads)
static void	SimpleMessageMap ()
static void	SimpleMessageMap (DWORD dwRunTimeMS)
static void	SimpleMessageMap (LPMapProc pProc, BOOL bStopWhenTRUE, DWORD dwSleep)
static char	SimpleMessageMapKey (DWORD dwSleep)
static void	Initialize ()
static void	Shutdown ()
static void	SetInstance (HINSTANCE hInst)
Protected Member Functions
virtual BOOL	SetAsync ()
virtual BOOL	OnSocketConnect (int iErrorCode)
virtual SOCKET	GetAsyncHandle () const
void	SetConnectedTo (const sockaddr_in &rAddress)
IP	GetSourceAddress () const
unsigned char	GetTTL () const
BOOL	CheckSocketValid () const
void	AssignSocket (SOCKET aNewSocket, unsigned char ucProtocol=IPPROTO_TCP)
BOOL	ValidSocket () const
virtual void	InitializeIP ()
virtual int	ReceiveFrom (char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort)
virtual void	NotifyShutdown ()
void	RegisterShutdown (CSocketBase *pBase)
void	SetLastError (const std::string &rMethod) const
void	SetLastError (const std::string &, int iErrorCode) const
const std::string &	GetClassName () const
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, const std::string &rAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
virtual BOOL	OnSocketTimeout ()=0
virtual BOOL	OnSocketAccept (int iErrorCode)=0
virtual BOOL	OnSocketClose (int iErrorCode)=0
virtual BOOL	OnSocketOOB (int iErrorCode)=0
virtual BOOL	OnSocketWrite (int iErrorCode)=0
virtual BOOL	OnSocketReceive (int iErrorCode)=0
BOOL	IsBlocking () const
int	InternalWSAAsyncSelect (unsigned int wMsg, long lEvent)
void	SocketClosing ()
int	GetSocketID () const
HWND	GetWindowHandle () const
void	RemoveSocketFromList ()
void	AddSocketToList ()
BOOL	IsTimeout () const
BOOL	Block ()
virtual BOOL	SendBlockedBuffer (const CBlockedBuffer::CBlockedData &rData)
CBlockedBuffer *	GetBlockedBuffer () const
virtual BOOL	SocketConnected (int iErrorCode, BOOL bNoEvent=FALSE)
virtual BOOL	SocketClosed (int iErrorCode, BOOL bNoEvent=FALSE)
virtual BOOL	SocketWrite (int iErrorCode)
virtual BOOL	SocketReceive (int iErrorCode, BOOL bNoEvent=FALSE)
virtual BOOL	SocketAccept (int iErrorCode, BOOL bNoEvent=FALSE)
virtual void	SystemTimeout ()
BOOL	SetSystemTimeout (int iMS)
BOOL	KillSystemTimer ()
BOOL	HasSystemTimer () const
virtual void	OnSocketDelete (CGenericEvent *pEvent=NULL)
virtual void	SocketCreated ()
virtual BOOL	ClearEvents ()
BOOL	IsBlockSend () const
BOOL	IsInThread () const
BOOL	WaitForBlockEvent () const
void	ResetEvent ()
Static Protected Member Functions
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)
static void	ReportStaticErrorOS (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static CSocketThreadManagerImp *	GetSocketThreadManager ()
Static Protected Attributes
static CGenericCriticalSection *	m_pCSection = NULL
Friends
class	CIPCrafter

Detailed Description

Definition at line 48 of file UDPSocketAsync.h.

Member Typedef Documentation

typedef enum CAsyncSocket::_AsyncEvents CAsyncSocket::AsyncEvents [inherited]

typedef MapProc CAsyncSocket::LPMapProc [inherited]

Definition at line 93 of file AsyncSocket.h.

typedef BOOL(* CAsyncSocket::MapProc)() [inherited]

typedef enum CSocket::_SocketShutdown CSocket::SocketShutdown [inherited]

Member Enumeration Documentation

enum CAsyncSocket::_AsyncEvents [inherited]

Enumerator:

aeReceive
aeSend
aeOOB
aeClose

Definition at line 83 of file AsyncSocket.h.

00084     {
00085         aeReceive=1,
00086         aeSend=2,
00087         aeOOB=4,
00088         aeClose=8
00089     } AsyncEvents;

enum CSocket::_SocketShutdown [inherited]

Enumerator:

ssReceive
ssSend
ssBoth

Definition at line 51 of file Socket.h.

00052     {
00053         ssReceive,
00054         ssSend,
00055         ssBoth
00056     } SocketShutdown;

Constructor & Destructor Documentation

CUDPSocketAsync::CUDPSocketAsync ( BOOL bRawSocket = false )

Definition at line 51 of file UDPSocketAsync.cpp.

00051                                                 : CUDPSocket(bRawSocket), 
00052                                                     CAsyncSocket()
00053 {
00054     try
00055     {
00056         //Set our name
00057         SetName(CUDPSocketAsync_Class);
00058     }
00059     ERROR_HANDLER("CUDPSocketAsync")
00060 }

CUDPSocketAsync::~CUDPSocketAsync ( ) [virtual]

Definition at line 62 of file UDPSocketAsync.cpp.

00063 {
00064     try
00065     {
00066         //We need to close it here
00067         Close();
00068     }
00069     ERROR_HANDLER("~CUDPSocketAsync")
00070 }

Member Function Documentation

void CAsyncSocket::AddSocketToList ( ) [protected, inherited]

Definition at line 233 of file AsyncSocket.cpp.

00234 {
00235     try
00236     {
00237         //Allocate our window
00238         AllocateHandle();
00239 
00240         //We are in the list
00241         m_bList=TRUE;
00242     }
00243     ERROR_HANDLER("AddSocketToList")
00244 }

void CAsyncSocket::AllowBlockedBuffer ( BOOL bAllow ) [inherited]

Definition at line 681 of file AsyncSocket.cpp.

00682 {
00683     try
00684     {
00685         //Do we have a buffer
00686         if (bAllow && 
00687             !m_pBlockedBuffer)
00688             m_pBlockedBuffer=new CBlockedBuffer(this);
00689         else if (!bAllow && 
00690                  m_pBlockedBuffer)
00691         {
00692             //Delete and reset the blocked buffer
00693             delete m_pBlockedBuffer;
00694             m_pBlockedBuffer=NULL;
00695         }
00696     }
00697     ERROR_HANDLER("AllowBlockedBuffer")
00698 }

void CSocket::AssignSocket	(	SOCKET	aNewSocket,
		unsigned char	ucProtocol = `IPPROTO_TCP`
	)			`[protected, inherited]`

Definition at line 500 of file Socket.cpp.

00502 {
00503     try
00504     {
00505         //Sets the protocol
00506         m_ucProtocol=ucProtocol;
00507 
00508         //Binds to a socket
00509         m_aSocket=aNewSocket;
00510     }
00511     ERROR_HANDLER("AssignSocket")
00512 }

BOOL CSocket::Bind	(	IP	aSourceAddress,
		unsigned short	usPort
	)			`[virtual, inherited]`

Reimplemented in CTCPSocketAsync.

Definition at line 269 of file Socket.cpp.

00271 {
00272     try
00273     {
00274         //Quit if not ok
00275         if (!CheckSocketValid())
00276             return FALSE;
00277 
00278         //Create the local address
00279         sockaddr_in soSrc;
00280 
00281         //Set to 0
00282         memset(&soSrc,0,sizeof(soSrc));
00283         soSrc.sin_family=AF_INET;
00284 
00285         //Populate the connection data
00286         if (aSourceAddress)
00287             soSrc.sin_addr.s_addr=aSourceAddress;
00288         else
00289             soSrc.sin_addr.s_addr=ADDR_ANY ;
00290 
00291         soSrc.sin_port=htons(usPort);
00292 
00293         //Now we need to bind it
00294         if (bind(GetHandle(),
00295                  (sockaddr*)&soSrc,
00296                  sizeof(soSrc)))
00297         {
00298             //Error
00299             SetLastError("Bind");
00300 
00301             //Exit
00302             return FALSE;
00303         }
00304         else
00305             //Save the address
00306             m_aConnectedTo=soSrc;
00307 
00308         //Save new addresses
00309         if (aSourceAddress &&
00310             !m_ulSourceAddress)
00311             m_ulSourceAddress=aSourceAddress;
00312 
00313         return TRUE;
00314     }
00315     ERROR_HANDLER_RETURN("Bind",FALSE)
00316 }

BOOL CSocket::Bind	(	const std::string &	rSourceAddress,
		unsigned short	usPort
	)			`[virtual, inherited]`

Definition at line 318 of file Socket.cpp.

00320 {
00321     try
00322     {
00323         //Quit if not ok
00324         if (!CheckSocketValid())
00325             return FALSE;
00326 
00327         if (rSourceAddress.empty())
00328             return Bind((IP)0,
00329                         usPort);
00330         else
00331             return Bind(inet_addr(rSourceAddress.c_str()),
00332                         usPort);
00333     }
00334     ERROR_HANDLER_RETURN("Bind",FALSE)
00335 }

BOOL CAsyncSocket::Block ( ) [protected, inherited]

Definition at line 634 of file AsyncSocket.cpp.

00635 {
00636     try
00637     {
00638         //First disable the events
00639         int iResult;
00640         iResult=WSAAsyncSelect(GetAsyncHandle(),
00641                                GetWindowHandle(),
00642                                0,
00643                                0);
00644 
00645         if (iResult)
00646         {
00647             //Report it
00648             SetLastError("Block");
00649 
00650             //Exit
00651             return FALSE;
00652         }
00653 
00654         unsigned long ulBlocking;
00655         ulBlocking=0;
00656 
00657         //And return to non-blocking
00658         iResult=ioctlsocket(GetAsyncHandle(),
00659                             FIONBIO,
00660                             &ulBlocking);
00661 
00662         if (iResult)
00663         {
00664             //Report it
00665             SetLastError("Block");
00666 
00667             //Exit
00668             return FALSE;
00669         }
00670 
00671         return TRUE;
00672     }
00673     ERROR_HANDLER_RETURN("Block",FALSE)
00674 }

BOOL CSocket::CanRead ( ) const [inherited]

Definition at line 721 of file Socket.cpp.

00722 {
00723     try
00724     {
00725         //Quit if not ok
00726         if (!CheckSocketValid())
00727             return FALSE;
00728 
00729         //Create our structure
00730         fd_set aDescriptor;
00731         FD_ZERO(&aDescriptor);
00732 
00733         //Add our socket
00734         FD_SET(GetHandle(),
00735                &aDescriptor);
00736 
00737         //And create the timeval
00738         timeval aTime;
00739         aTime.tv_sec=0;
00740         aTime.tv_usec=0;
00741 
00742         //And run the select
00743         int iRetVal;
00744         iRetVal=select(NULL,
00745                        &aDescriptor,
00746                        NULL,
00747                        NULL,
00748                        &aTime);
00749 
00750         //Check if we had an error
00751         if (iRetVal==GetErrorCode())
00752         {
00753             //Report it
00754             SetLastError("CanRead");
00755 
00756             //Exit
00757             return FALSE;
00758         }
00759         else
00760             //Check is our socket set
00761             return FD_ISSET(GetHandle(),
00762                             &aDescriptor);
00763     }
00764     ERROR_HANDLER_RETURN("CanRead",FALSE)
00765 }

BOOL CSocket::CanWrite ( ) const [inherited]

Definition at line 767 of file Socket.cpp.

00768 {
00769     try
00770     {
00771         //Quit if not ok
00772         if (!CheckSocketValid())
00773             return FALSE;
00774 
00775         //Create our structure
00776         fd_set aDescriptor;
00777         FD_ZERO(&aDescriptor);
00778 
00779         //Add our socket
00780         FD_SET(GetHandle(),
00781                &aDescriptor);
00782 
00783         //And create the timeval
00784         timeval aTime;
00785         aTime.tv_sec=0;
00786         aTime.tv_usec=0;
00787 
00788         //And run the select
00789         int iRetVal;
00790         iRetVal=select(NULL,
00791                        NULL,
00792                        &aDescriptor,
00793                        NULL,
00794                        &aTime);
00795 
00796         //Check if we had an error
00797         if (iRetVal==GetErrorCode())
00798         {
00799             //Report it
00800             SetLastError("CanWrite");
00801 
00802             //Exit
00803             return FALSE;
00804         }
00805         else
00806             //Check is our socket set
00807             return FD_ISSET(GetHandle(),
00808                             &aDescriptor);
00809     }
00810     ERROR_HANDLER_RETURN("CanWrite",FALSE)
00811 }

BOOL CSocket::CheckSocketValid ( ) const [protected, inherited]

Definition at line 387 of file Socket.cpp.

00388 {
00389     try
00390     {
00391         //Check if socket is invalid
00392         if (!ValidSocket())
00393         {
00394             //Report it
00395             ReportError("CheckSocketValid","Operation made on non existant socket!");
00396 
00397             //Exit
00398             return FALSE;
00399         }   
00400 
00401         //OK
00402         return TRUE;
00403     }
00404     ERROR_HANDLER_RETURN("CheckSocketValid",FALSE)
00405 }

BOOL CAsyncSocket::ClearEvents ( ) [protected, virtual, inherited]

Definition at line 584 of file AsyncSocket.cpp.

00585 {
00586     try
00587     {
00588         //Quit if not ok
00589         if (!CheckAsyncSocketValid())
00590             return FALSE;
00591 
00592         //Do it
00593         return !InternalWSAAsyncSelect(0,0);
00594     }
00595     ERROR_HANDLER_RETURN("ClearEvents",FALSE)
00596 }

CSocketThreadManagerImp * CAsyncSocket::CloneThreadManager ( unsigned long ulThreads ) [static, inherited]

Definition at line 1269 of file AsyncSocket.cpp.

01270 {
01271     try
01272     {
01273         //Do we have a thread manager?
01274         if (!m_pThreadManager ||
01275             !m_pThreadManager->IsInitialized())
01276         {
01277             //Report it
01278             ReportStaticError(CAsyncSocket_Class,"SetLocalThreadManager","Manager is either null or not initialized!");
01279 
01280             //Exit
01281             return NULL;
01282         }
01283 
01284         //Which thread count
01285         unsigned long ulThreadCount;
01286         if (!ulThreads)
01287             ulThreadCount=m_pThreadManager->GetNumberOfThreads();
01288         else
01289             ulThreadCount=ulThreads;
01290 
01291         //Clone it
01292         CSocketThreadManagerImp* pManager;
01293         pManager=new CSocketThreadManagerImp(m_hInstance);
01294         if (!pManager->Initialize(ulThreads))
01295         {
01296             //Report it
01297             ReportStaticError(CAsyncSocket_Class,"CloneThreadManager","Failed to initialize the thread manager!");
01298 
01299             //Delete it
01300             delete pManager;
01301 
01302             //Exit
01303             return NULL;
01304         }
01305         else
01306             return pManager;
01307     }
01308     ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"CloneThreadManager",NULL)
01309 }

BOOL CUDPSocketAsync::Close ( ) [virtual]

Reimplemented from CSocket.

Definition at line 170 of file UDPSocketAsync.cpp.

00171 {
00172     try
00173     {
00174         //Quit if not ok
00175         if (!ValidSocket())
00176             return FALSE;
00177 
00178         //Kill the timer
00179         CAsyncSocket::SocketClosing();
00180 
00181         //Remove from socket list
00182         RemoveSocketFromList();
00183 
00184         //Delegate call
00185         return CUDPSocket::Close();
00186     }
00187     ERROR_HANDLER_RETURN("Close",FALSE)
00188 }

BOOL CSocket::Create ( int iProtocol ) [inherited]

Definition at line 98 of file Socket.cpp.

00099 {
00100     //Close the socket if open
00101     if (ValidSocket())
00102         Close();
00103 
00104     try
00105     {
00106         //Are we overlapped
00107         if (!m_bOverlapped)
00108         {
00109             //Here we create the raw socket
00110             if (m_bRaw || iProtocol==IPPROTO_ICMP)
00111                 m_aSocket=socket(AF_INET,
00112                                       SOCK_RAW,
00113                                       iProtocol);
00114             else
00115                 if (iProtocol==IPPROTO_TCP)
00116                     m_aSocket=socket(AF_INET,
00117                                           SOCK_STREAM,
00118                                           iProtocol);
00119                 else if (iProtocol==IPPROTO_UDP)
00120                     m_aSocket=socket(AF_INET,
00121                                           SOCK_DGRAM,
00122                                           iProtocol);
00123         }
00124         else
00125         {
00126             //Here we create the raw socket
00127             if (m_bRaw || iProtocol==IPPROTO_ICMP)
00128                 m_aSocket=WSASocket(AF_INET,
00129                                          SOCK_RAW,
00130                                          iProtocol,
00131                                          NULL,
00132                                          NULL,
00133                                          WSA_FLAG_OVERLAPPED);
00134             else
00135                 if (iProtocol==IPPROTO_TCP)
00136                     m_aSocket=WSASocket(AF_INET,
00137                                              SOCK_STREAM,
00138                                              iProtocol,
00139                                              NULL,
00140                                              NULL,
00141                                              WSA_FLAG_OVERLAPPED);
00142                 else if (iProtocol==IPPROTO_UDP)
00143                     m_aSocket=WSASocket(AF_INET,
00144                                              SOCK_DGRAM,
00145                                              iProtocol,
00146                                              NULL,
00147                                              NULL,
00148                                              WSA_FLAG_OVERLAPPED);
00149         }
00150 
00151         //Check for socket validity
00152         if (m_aSocket==INVALID_SOCKET)
00153         {
00154             //Error
00155             SetLastError("Create");
00156 
00157             //Done
00158             return FALSE;
00159         }
00160 
00161         if (m_bRaw)
00162         {
00163             //Set that the application will send the IP header
00164             unsigned int iTrue=1;
00165 
00166             if(setsockopt(m_aSocket,
00167                           IPPROTO_IP,
00168                           IP_HDRINCL,
00169                           (char*)&iTrue,
00170                           sizeof(iTrue))==GetErrorCode())
00171             {
00172                 //Check for options error
00173                 SetLastError("Create");
00174 
00175                 //Exit
00176                 return FALSE;
00177             }
00178         }
00179 
00180         //Done
00181         return TRUE;
00182     }
00183     ERROR_HANDLER_RETURN("Create",FALSE)
00184 }

BOOL CUDPSocketAsync::Create ( ) [virtual]

Reimplemented from CUDPSocket.

Definition at line 152 of file UDPSocketAsync.cpp.

00153 {
00154     try
00155     {
00156         if (!CUDPSocket::Create())
00157             return FALSE;
00158         else
00159         {
00160             //Add the socket to a list
00161             AddSocketToList();
00162 
00163             //Exit
00164             return TRUE;
00165         }
00166     }
00167     ERROR_HANDLER_RETURN("Create",FALSE)
00168 }

void CAsyncSocket::DeleteSocketFromThread ( DWORD dwTimeToWait ) [virtual, inherited]

Definition at line 1100 of file AsyncSocket.cpp.

01101 {
01102     try
01103     {
01104         if (!dwTimeToWait)
01105             DeleteSocketFromThread();
01106         else
01107         {
01108             //We are closing
01109             SocketClosing();
01110 
01111             //Are we valid ?
01112             //And do we have a window
01113             if (!m_bList)
01114                 OnSocketDelete();
01115             else
01116             {
01117                 //Create a timer
01118                 m_aDeleteTimerID=GetThreadManager()->RegisterTimeout(dwTimeToWait,
01119                                                                      DeleteTimerProc,
01120                                                                      (LPVOID)this,
01121                                                                      TRUE,
01122                                                                      GetWindowHandle(),
01123                                                                      &m_aDeleteTimerID);
01124 
01125                 //Do we have the timer ?
01126                 if (!m_aDeleteTimerID.iTimerID)
01127                 {
01128                     //Report it
01129                     ReportError("DeleteSocketFromThread","Failed to create timeout!");
01130 
01131                     //Run regular delete
01132                     DeleteSocketFromThread();
01133                 }
01134             }
01135         }
01136     }
01137     ERROR_HANDLER("OnSocketDelete")
01138 }

void CAsyncSocket::DeleteSocketFromThread ( ) [virtual, inherited]

Definition at line 1080 of file AsyncSocket.cpp.

01081 {
01082     try
01083     {
01084         //We are closing
01085         SocketClosing();
01086 
01087         //Are we valid ?
01088         //And do we have a window
01089         if (!m_bList)
01090             OnSocketDelete();
01091         else
01092             PostMessage(GetWindowHandle(),
01093                         WM_SOCKET_DELETE,
01094                         (WPARAM)GetAsyncHandle(),
01095                         0);
01096     }
01097     ERROR_HANDLER("OnSocketDelete")
01098 }

void CAsyncSocket::DeleteSocketFromThreadWait ( ) [virtual, inherited]

Definition at line 1140 of file AsyncSocket.cpp.

01141 {
01142     try
01143     {
01144         //We are closing
01145         SocketClosing();
01146 
01147         //Are we valid ?
01148         //And do we have a window
01149         if (!m_bList)
01150             OnSocketDelete();
01151         else
01152         {
01153             //Create the event
01154             CGenericEvent* pEvent;
01155             pEvent=COSManager::CreateEvent();
01156 
01157             //Post the message
01158             PostMessage(GetWindowHandle(),
01159                         WM_SOCKET_DELETE,
01160                         (WPARAM)GetAsyncHandle(),
01161                         (LPARAM)pEvent);
01162 
01163             //Wait for the event
01164             if (pEvent->Wait(15000))
01165                 //Report it
01166                 ReportStaticError(CAsyncSocket_Class,"DeleteSocketFromThreadWait","Timeout waiting for event!");
01167             else
01168                 delete pEvent;
01169         }
01170     }
01171     ERROR_HANDLER("OnSocketDelete")
01172 }

SOCKET CSocket::Detach ( ) [virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 374 of file Socket.cpp.

00375 {
00376     //Save the socket
00377     SOCKET aTmp;
00378     aTmp=m_aSocket;
00379 
00380     //Erase it
00381     m_aSocket=INVALID_SOCKET;
00382 
00383     //Return the original
00384     return aTmp;
00385 }

void CAsyncSocket::DetachedSocketThread ( ) [inherited]

Definition at line 165 of file AsyncSocket.cpp.

00166 {
00167     try
00168     {
00169         //Create a new socket imp
00170         CSocketThreadManagerImp* pClone;
00171         pClone=CloneThreadManager(1);
00172 
00173         //Do we have it?
00174         if (!pClone)
00175             //Report it
00176             ReportError("DetachedSocketThread","Failed to create detach manager, will resume as normal!");
00177         else
00178         {
00179             //Set it as local
00180             if (!SetLocalThreadManager(pClone))
00181                 ReportError("DetachedSocketThread","Failed to set manager!");
00182             else
00183                 //Set we are detahced
00184                 m_bDetached=TRUE;
00185         }
00186     }
00187     ERROR_HANDLER("DetachedSocketThread")
00188 }

BOOL CAsyncSocket::DisableAsync ( ) [inherited]

Definition at line 426 of file AsyncSocket.cpp.

00427 {
00428     try
00429     {
00430         //Quit if not ok
00431         if (!CheckAsyncSocketValid())
00432             return FALSE;
00433 
00434         //Set event to read / write / close / oob
00435         int iResult;
00436 
00437         iResult=WSAAsyncSelect(GetAsyncHandle(),
00438                                GetWindowHandle(),
00439                                0,
00440                                0);
00441         if (iResult)
00442         {
00443             //Report it
00444             SetLastError("DisableAsync");
00445 
00446             //Exit
00447             return FALSE;
00448         }
00449         
00450         return TRUE;
00451     }
00452     ERROR_HANDLER_RETURN("DisableAsync",FALSE)
00453 }

void CAsyncSocket::DisableBlockingSend ( ) [inherited]

Definition at line 1343 of file AsyncSocket.cpp.

01344 {
01345     m_bBlockSend=FALSE;
01346 }

void CAsyncSocket::DisableEvents ( unsigned char ucEvents ) [inherited]

Definition at line 1205 of file AsyncSocket.cpp.

01206 {
01207     try
01208     {
01209         //Save the events
01210         m_ucEvents=ucEvents;
01211     }
01212     ERROR_HANDLER("DisableEvents")
01213 }

std::string CErrorHandler::ErrorCodeToString ( DWORD dwErrorCode ) [static, inherited]

Definition at line 218 of file ErrorHandler.cpp.

00219 {
00220     try
00221     {
00222         //Try to look it in the errors
00223         if (!CErrorsRepository::GetInstance().GetErrorsMap().empty())
00224         {
00225             //Search
00226             CErrorsRepository::ErrorMap::const_iterator aIterator;
00227             aIterator=CErrorsRepository::GetInstance().GetErrorsMap().find(dwErrorCode);
00228 
00229             //Do we have it
00230             if (aIterator!=CErrorsRepository::GetInstance().GetErrorsMap().end())
00231                 return aIterator->second;
00232         }
00233 
00234         //Get the error string
00235         LPVOID lpMsgBuf;
00236         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
00237                       FORMAT_MESSAGE_FROM_SYSTEM | 
00238                       FORMAT_MESSAGE_IGNORE_INSERTS,
00239                       NULL,
00240                       dwErrorCode,
00241                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
00242                       (LPTSTR) &lpMsgBuf,
00243                       0,
00244                       NULL);
00245 
00246         //Save it
00247         std::string sMessage;
00248 
00249         //Do we have the message?
00250         if (lpMsgBuf)
00251         {
00252             //Save it
00253             sMessage=(char*)lpMsgBuf;
00254             
00255             //Release the buffer
00256             LocalFree(lpMsgBuf);
00257         }
00258         else
00259             //Failed to find
00260             sMessage="No error description found!";
00261 
00262         //Done
00263         return sMessage;
00264     }
00265     catch (...)
00266     {
00267         return "Unknown";
00268     }
00269 }

void CAsyncSocket::ForceReceiveEvent ( ) [inherited]

Definition at line 1063 of file AsyncSocket.cpp.

01064 {
01065     try
01066     {
01067         //Are we valid ?
01068         //And do we have a window
01069         if (!m_bList)
01070             OnSocketDelete();
01071         else
01072             PostMessage(GetWindowHandle(),
01073                         WM_SOCKET_FORCED,
01074                         (WPARAM)GetAsyncHandle(),
01075                         0);
01076     }
01077     ERROR_HANDLER("ForceReceiveEvent")
01078 }

std::string CErrorHandler::FormatData	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMsgOrError,
		bool	bError = `true`
	)			`[static, inherited]`

Definition at line 140 of file ErrorHandler.cpp.

00144 {
00145     //Our message
00146     std::string sMsg;
00147 
00148     //Is it an error?
00149     if (bError)
00150         sMsg="*** Error *** ";
00151     else
00152         sMsg="###  Msg  ### ";
00153 
00154     //Add the data now
00155     sMsg+="in "+rClass;
00156     sMsg+=":"+rMethod;
00157     sMsg+=" - " + rMsgOrError;
00158 
00159     //Done
00160     return sMsg;
00161 }

void CAsyncSocket::FreezeThread ( ) [inherited]

Definition at line 512 of file AsyncSocket.cpp.

00513 {
00514     m_bFreeze=TRUE;
00515 }

SOCKET CUDPSocketAsync::GetAsyncHandle ( ) const [protected, virtual]

Implements CAsyncSocket.

Definition at line 147 of file UDPSocketAsync.cpp.

00148 {
00149     return GetHandle();
00150 }

IP CSocket::GetBindAddress ( ) const [virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 902 of file Socket.cpp.

00903 {
00904     return m_ulSourceAddress;
00905 }

unsigned short CSocket::GetBindPort ( ) const [virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 337 of file Socket.cpp.

00338 {
00339     try
00340     {
00341         //Quit if not ok
00342         if (!CheckSocketValid())
00343             return FALSE;
00344 
00345         //Create the local address
00346         sockaddr_in soSrc;
00347 
00348         //Buffer size
00349         int iSize;
00350         iSize=sizeof(soSrc);
00351 
00352         //Try to get it
00353         if (getsockname(GetHandle(),
00354                         (sockaddr*)&soSrc,
00355                         &iSize))
00356         {
00357             //Error
00358             SetLastError("Bind");
00359 
00360             //Exit
00361             return 0;
00362         }
00363         else
00364             return htons(soSrc.sin_port);
00365     }
00366     ERROR_HANDLER_RETURN("GetBindPort",0)
00367 }

CBlockedBuffer * CAsyncSocket::GetBlockedBuffer ( ) const [protected, inherited]

Definition at line 700 of file AsyncSocket.cpp.

00701 {
00702     return m_pBlockedBuffer;
00703 }

const std::string & CErrorHandler::GetClassName ( ) const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 567 of file ErrorHandler.cpp.

00568 {
00569     return m_sClassName;
00570 }

std::string CErrorHandler::GetCurrentDateTime ( ) [static, inherited]

Definition at line 572 of file ErrorHandler.cpp.

00573 {
00574     try
00575     {
00576         //Our string
00577         std::string sDate;
00578 
00579         //Our tmp buf
00580         char cTmp[128];
00581 
00582         //Get date
00583         _strdate(cTmp);
00584         sDate=cTmp;
00585         sDate+=' ';
00586 
00587         //Get time
00588         _strtime(cTmp);
00589         sDate+=cTmp;
00590 
00591         //Done
00592         return sDate;
00593     }
00594     ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
00595 }

int CSocketBase::GetErrorCode ( ) [static, inherited]

Definition at line 368 of file SocketBase.cpp.

00369 {
00370     return SOCKET_ERROR;
00371 }

CGenericCriticalSection * CSocketBase::GetGlobalCriticalSection ( ) [static, inherited]

Definition at line 363 of file SocketBase.cpp.

00364 {
00365     return m_pCSection;
00366 }

SOCKET CSocket::GetHandle ( ) const [inherited]

Definition at line 369 of file Socket.cpp.

00370 {
00371     return m_aSocket;
00372 }

int CSocketBase::GetLastError ( ) const [inherited]

Definition at line 141 of file SocketBase.cpp.

00142 {
00143     return m_iLastError;
00144 }

unsigned long CSocketBase::GetNumberOfThreads ( ) [static, inherited]

Definition at line 334 of file SocketBase.cpp.

00335 {
00336     return m_ulNumberOfThreads;
00337 }

long CSocket::GetPeerAddress ( ) const [inherited]

Definition at line 677 of file Socket.cpp.

00678 {
00679     //Get the address we are connected to
00680     return m_aConnectedTo.sin_addr.S_un.S_addr;
00681 }

unsigned short CSocket::GetPeerPort ( ) const [inherited]

Definition at line 716 of file Socket.cpp.

00717 {
00718     return htons(m_aConnectedTo.sin_port);
00719 }

unsigned char CSocket::GetProtocol ( ) const [inherited]

Definition at line 855 of file Socket.cpp.

00856 {
00857     return m_ucProtocol;
00858 }

int CAsyncSocket::GetSocketID ( ) const [protected, inherited]

Definition at line 246 of file AsyncSocket.cpp.

00247 {
00248     return m_iSocketID;
00249 }

CSocketThreadManagerImp * CAsyncSocket::GetSocketThreadManager ( ) [static, protected, inherited]

Definition at line 711 of file AsyncSocket.cpp.

00712 {
00713     return m_pThreadManager;
00714 }

IP CSocket::GetSourceAddress ( ) const [protected, inherited]

Definition at line 850 of file Socket.cpp.

00851 {
00852     return m_ulSourceAddress;
00853 }

int CSocketBase::GetSystemLastError ( ) [static, inherited]

Definition at line 358 of file SocketBase.cpp.

00359 {
00360     return WSAGetLastError();
00361 }

CSocketThreadManagerImp * CAsyncSocket::GetThreadManager ( ) const [inherited]

Definition at line 393 of file AsyncSocket.cpp.

00394 {
00395     if (!m_pLocalThreadManager)
00396         return m_pThreadManager;
00397     else
00398         return m_pLocalThreadManager;
00399 }

unsigned char CSocket::GetTTL ( ) const [protected, inherited]

Definition at line 845 of file Socket.cpp.

00846 {
00847     return m_ucTTL;
00848 }

HWND CAsyncSocket::GetWindowHandle ( ) const [protected, inherited]

Definition at line 256 of file AsyncSocket.cpp.

00257 {
00258     //Check if we are multithreaded ?
00259     return m_hLocalWindowHandle;
00260 }

BOOL CAsyncSocket::HasSystemTimer ( ) const [protected, inherited]

Definition at line 1044 of file AsyncSocket.cpp.

01045 {
01046     return m_aTimerID.iTimerID!=0;
01047 }

BOOL CAsyncSocket::HasTimeout ( ) const [inherited]

Definition at line 1215 of file AsyncSocket.cpp.

01216 {
01217     return m_bTimeout;
01218 }

void CAsyncSocket::Initialize ( ) [static, inherited]

Definition at line 361 of file AsyncSocket.cpp.

00362 {
00363     try
00364     {
00365         //Initialize all data
00366         if (!m_bInitialized && 
00367             CSocketBase::IsInitialized())
00368         {
00369             //Create the CS
00370             m_pCSection=COSManager::CreateCriticalSection();
00371 
00372             //Create handlers
00373             if (!SetHandlers())
00374             {
00375                 //Report it
00376                 ReportStaticError(CAsyncSocket_Class,"CAsyncSocket","Failed to init handlers!");
00377 
00378                 //Exit
00379                 return;
00380             }
00381 
00382             //Create a new socket to do the shutdown
00383             CAsyncShutdown* pShutdown;
00384             pShutdown=new CAsyncShutdown;
00385 
00386             //The class registers itself
00387             m_bInitialized=TRUE;
00388         }
00389     }
00390     ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Initialize")
00391 }

void CSocket::InitializeIP ( ) [protected, virtual, inherited]

Definition at line 476 of file Socket.cpp.

00477 {
00478     try
00479     {
00480         //Invalid the socket
00481         m_aSocket=INVALID_SOCKET;
00482 
00483         //More invalids
00484         m_ulSourceAddress=0;
00485 
00486         //Some defaults
00487         m_ucTTL=64;
00488 
00489         //We are not overlapped
00490         m_bOverlapped=FALSE;
00491 
00492         //Not connected
00493         memset(&m_aConnectedTo,
00494                0,
00495                sizeof(m_aConnectedTo));
00496     }
00497     ERROR_HANDLER("InitializeIP")
00498 }

BOOL CSocketBase::InitializeSockets	(	BOOL	bMultiThreaded = `TRUE`,
		unsigned long	ulNumberOfThreads = `10`
	)			`[static, inherited]`

Definition at line 146 of file SocketBase.cpp.

00148 {
00149     //To avoid double initialize
00150     if (m_bInitialized)
00151     {
00152         //Report it
00153         ReportStaticError(CSocketBase_Class,"InitializeSockets","Already initialized!");
00154 
00155         //Exit
00156         return TRUE;
00157     }
00158 
00159     //Check that the number of threads are OK?
00160     if (ulNumberOfThreads>CLibConfig::GetInstance().GetMaxThreads())
00161     {
00162         //Report it
00163         ReportStaticError(CSocketBase_Class,"InitializeSockets","Too many threads!");
00164 
00165         //Exit
00166         return FALSE;
00167     }
00168 
00169     //Do we have threads at all
00170     if (bMultiThreaded &&
00171         !ulNumberOfThreads)
00172     {
00173         //Report it
00174         ReportStaticError(CSocketBase_Class,"InitializeSockets","Didn't receive any threads!");
00175 
00176         //Exit
00177         return FALSE;
00178     }
00179 
00180     try
00181     {
00182         //Initialize the sockets
00183         WORD wVersionRequested;
00184         wVersionRequested=MAKEWORD(2,2);
00185  
00186         //Try to initialize
00187         WSADATA wsaData;
00188         int iErr;
00189         iErr=WSAStartup(wVersionRequested, 
00190                         &wsaData);
00191 
00192         //Did we succeed?
00193         if (iErr!=0)
00194             /* Tell the user that we could not find a usable */
00195             /* WinSock DLL.                                  */
00196             return FALSE;
00197  
00198         /* Confirm that the WinSock DLL supports 2.2.*/
00199         /* Note that if the DLL supports versions greater    */
00200         /* than 2.2 in addition to 2.2, it will still return */
00201         /* 2.2 in wVersion since that is the version we      */
00202         /* requested.                                        */
00203  
00204         if (LOBYTE(wsaData.wVersion)!=2 || 
00205             HIBYTE(wsaData.wVersion)!=2)
00206         {
00207             /* Tell the user that we could not find a usable */
00208             /* WinSock DLL.                                  */
00209             WSACleanup();
00210 
00211             //Exit
00212             return FALSE;
00213         }
00214 
00215         //Save the threading information
00216         m_bMultiThreaded=bMultiThreaded;
00217         m_ulNumberOfThreads=ulNumberOfThreads;
00218 
00219         //Create the critical section
00220         m_pCSection=COSManager::CreateCriticalSection();
00221         m_pCSectionDNS=COSManager::CreateCriticalSection();
00222 
00223         //And we are initialized
00224         m_bInitialized=TRUE;
00225 
00226         return TRUE;
00227     }
00228     ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"InitializeSockets",FALSE)
00229 }

int CAsyncSocket::InternalWSAAsyncSelect	(	unsigned int	wMsg,
		long	lEvent
	)			`[protected, inherited]`

Definition at line 538 of file AsyncSocket.cpp.

00540 {
00541     try
00542     {
00543         //Cache the values
00544         m_iMsg=wMsg;
00545         m_lEvent=lEvent;
00546 
00547         //Message pairs
00548         typedef struct _MsgPair
00549         {
00550             unsigned int    uiMsg;
00551             AsyncEvents     aEvents;
00552         } MsgPair;
00553 
00554         //Our max events
00555         static const int iMaxEvents=4;
00556 
00557         //Our events data
00558         static const MsgPair aMsgPair[iMaxEvents]={{FD_READ,aeReceive},
00559                                                    {FD_WRITE,aeSend},
00560                                                    {FD_OOB,aeOOB},
00561                                                    {FD_CLOSE,aeClose}};
00562 
00563         //Check if the messages are allowed
00564         for (int iCounter=0;
00565              iCounter<iMaxEvents;
00566              ++iCounter)
00567             if ((m_lEvent & aMsgPair[iCounter].uiMsg) &&
00568                 (m_ucEvents & ((unsigned char)aMsgPair[iCounter].aEvents)))
00569                 //Remove it
00570                 m_lEvent^=aMsgPair[iCounter].uiMsg;
00571 
00572         if (m_bBlocking)
00573             return 0;
00574         else
00575             //And call the async select
00576             return WSAAsyncSelect(GetAsyncHandle(),
00577                                   GetWindowHandle(),
00578                                   wMsg,
00579                                   lEvent);
00580     }
00581     ERROR_HANDLER_RETURN("InternalWSAAsyncSelect",GetErrorCode())
00582 }

BOOL CAsyncSocket::IsBlocking ( ) const [protected, inherited]

Definition at line 676 of file AsyncSocket.cpp.

00677 {
00678     return m_bBlocking;
00679 }

BOOL CAsyncSocket::IsBlockSend ( ) const [protected, inherited]

Definition at line 1311 of file AsyncSocket.cpp.

01312 {
01313     return m_bBlockSend;
01314 }

BOOL CAsyncSocket::IsClosing ( ) const [inherited]

Definition at line 1200 of file AsyncSocket.cpp.

01201 {
01202     return m_bClosing;
01203 }

BOOL CSocket::IsCreated ( ) const [inherited]

Definition at line 813 of file Socket.cpp.

00814 {
00815     return ValidSocket();
00816 }

BOOL CAsyncSocket::IsDeleting ( ) const [inherited]

Definition at line 1348 of file AsyncSocket.cpp.

01349 {
01350     return m_bDeleting;
01351 }

BOOL CSocketBase::IsInitialized ( ) [static, inherited]

Definition at line 339 of file SocketBase.cpp.

00340 {
00341     return m_bInitialized;
00342 }

BOOL CAsyncSocket::IsInThread ( ) const [protected, inherited]

Definition at line 1316 of file AsyncSocket.cpp.

01317 {
01318     try
01319     {
01320         //Do we have the thread?
01321         if (m_pThread)
01322             return m_pThread->IsInThread();
01323         else
01324             return FALSE;
01325     }
01326     ERROR_HANDLER_RETURN("IsInThread",FALSE)
01327 }

BOOL CSocketBase::IsMultiThreaded ( ) [static, inherited]

Definition at line 329 of file SocketBase.cpp.

00330 {
00331     return m_bMultiThreaded;
00332 }

BOOL CSocket::IsRaw ( ) const [inherited]

Definition at line 471 of file Socket.cpp.

00472 {
00473     return m_bRaw;
00474 }

BOOL CAsyncSocket::IsTimeout ( ) const [protected, inherited]

Definition at line 356 of file AsyncSocket.cpp.

00357 {
00358     return m_bTimeout;
00359 }

BOOL CAsyncSocket::KillSystemTimer ( ) [protected, inherited]

Definition at line 993 of file AsyncSocket.cpp.

00994 {
00995     try
00996     {
00997         //Only if we have one
00998         if (!m_aTimerID.iTimerID)
00999             return TRUE;
01000 
01001         return GetThreadManager()->RemoveTimeout(m_aTimerID);
01002     }
01003     ERROR_HANDLER_RETURN("KillSystemTimer",FALSE)
01004 }

BOOL CAsyncSocket::KillTimer ( ) [inherited]

Definition at line 303 of file AsyncSocket.cpp.

00304 {
00305     try
00306     {
00307         //Get the handle
00308         HWND hWindowHandle;
00309         hWindowHandle=GetWindowHandle();
00310 
00311         if (!hWindowHandle || 
00312             !m_bTimeout)
00313             return FALSE;
00314 
00315         //No timer in any case
00316         m_bTimeout=FALSE;
00317 
00318         //Try to kill the timer
00319         BOOL bResult;
00320         bResult=::KillTimer(hWindowHandle,
00321                             GetAsyncHandle());
00322 
00323         if (!bResult)
00324             //Fire an error
00325             ReportError("KillTimer");
00326 
00327         return bResult;
00328     }
00329     ERROR_HANDLER_RETURN("KillTimer",FALSE)
00330 }

BOOL CUDPSocketAsync::Listen ( ) [virtual]

Definition at line 72 of file UDPSocketAsync.cpp.

00073 {
00074     try
00075     {
00076         //Quit if not ok
00077         if (!CheckSocketValid())
00078             return FALSE;
00079 
00080         //Set async mode
00081         int iResult;
00082         iResult=InternalWSAAsyncSelect(WM_SOCKET_GENERAL,
00083                                        FD_READ);
00084 
00085         //Check result
00086         if (iResult)
00087         {
00088             //Report it
00089             SetLastError("Listen");
00090 
00091             //Exit
00092             return FALSE;
00093         }
00094         else
00095             return TRUE;
00096     }
00097     ERROR_HANDLER_RETURN("Listen",FALSE)
00098 }

std::string CSocketBase::LongToStdString ( unsigned long ulAddr ) [static, inherited]

Definition at line 291 of file SocketBase.cpp.

00292 {
00293     try
00294     {
00295         //First create the address
00296         in_addr addr;
00297 
00298         //Assign it
00299         addr.S_un.S_addr=ulAddr;
00300 
00301         //Enter the critical section
00302         CCriticalAutoRelease aRelease(m_pCSection);
00303 
00304         //Return the value
00305         return inet_ntoa(addr);
00306     }
00307     ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"LongToStdString","0.0.0.0")
00308 }

char FAR * CSocketBase::LongToString ( unsigned long ulAddr ) [static, inherited]

Definition at line 310 of file SocketBase.cpp.

00311 {
00312     try
00313     {
00314         //First create the address
00315         in_addr addr;
00316 
00317         //Assign it
00318         addr.S_un.S_addr=ulAddr;
00319 
00320         //Enter the critical section
00321         CCriticalAutoRelease aRelease(m_pCSection);
00322 
00323         //Return the value
00324         return inet_ntoa(addr);
00325     }
00326     ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"LongToString",NULL)
00327 }

void CSocketBase::NotifyShutdown ( ) [protected, virtual, inherited]

Definition at line 273 of file SocketBase.cpp.

00274 {
00275 }

virtual BOOL CAsyncSocket::OnSocketAccept ( int iErrorCode ) [protected, pure virtual, inherited]

virtual BOOL CAsyncSocket::OnSocketClose ( int iErrorCode ) [protected, pure virtual, inherited]

Implemented in CWhoisSocket, and CSocketPoolSocket.

BOOL CUDPSocketAsync::OnSocketConnect ( int iErrorCode ) [protected, virtual]

Implements CAsyncSocket.

Definition at line 128 of file UDPSocketAsync.cpp.

00129 {
00130     //First set async again
00131     return SetAsync();
00132 }

void CAsyncSocket::OnSocketDelete ( CGenericEvent * pEvent = NULL ) [protected, virtual, inherited]

Definition at line 1049 of file AsyncSocket.cpp.

01050 {
01051     try
01052     {
01053         //Delete ourselves
01054         delete this;
01055 
01056         //Do we have an event?
01057         if (pEvent)
01058             pEvent->Set();
01059     }
01060     ERROR_HANDLER_STATIC(CAsyncSocket_Class,"OnSocketDelete")
01061 }

virtual BOOL CAsyncSocket::OnSocketOOB ( int iErrorCode ) [protected, pure virtual, inherited]

virtual BOOL CAsyncSocket::OnSocketReceive ( int iErrorCode ) [protected, pure virtual, inherited]

Implemented in CWhoisSocket.

virtual BOOL CAsyncSocket::OnSocketTimeout ( ) [protected, pure virtual, inherited]

Implemented in CWhoisSocket.

virtual BOOL CAsyncSocket::OnSocketWrite ( int iErrorCode ) [protected, pure virtual, inherited]

bool CSocket::operator< ( const CSocket & rSocket ) const [inherited]

Definition at line 892 of file Socket.cpp.

00893 {
00894     return m_aSocket<rSocket.m_aSocket;
00895 }

bool CSocket::operator== ( const CSocket & rSocket ) const [inherited]

Definition at line 887 of file Socket.cpp.

00888 {
00889     return m_aSocket==rSocket.m_aSocket;
00890 }

int CSocket::Peek	(	char *	pBuffer,
		unsigned long	ulBufferLength
	)			`[virtual, inherited]`

Reimplemented in CTCPSocketAsync.

Definition at line 665 of file Socket.cpp.

00667 {
00668     try
00669     {
00670         return LocalReceive(pBuffer,
00671                             ulBufferLength,
00672                             TRUE);
00673     }
00674     ERROR_HANDLER_RETURN("Peek",GetErrorCode())
00675 }

BOOL CAsyncSocket::ReAsync ( ) [virtual, inherited]

Definition at line 598 of file AsyncSocket.cpp.

00599 {
00600     if (!m_bBlocking)
00601         return TRUE;
00602 
00603     try
00604     {
00605         //Quit if not ok
00606         if (!CheckAsyncSocketValid())
00607             return FALSE;
00608 
00609         //First disable the events
00610         int iResult;
00611         iResult=WSAAsyncSelect(GetAsyncHandle(),
00612                                GetWindowHandle(),
00613                                m_iMsg,
00614                                m_lEvent);
00615 
00616         if (iResult)
00617         {
00618             //Report it
00619             SetLastError("ReAsync");
00620 
00621             //Exit
00622             return FALSE;
00623         }
00624 
00625         //Set to async
00626         m_bBlocking=FALSE;
00627 
00628         //And quit
00629         return TRUE;
00630     }
00631     ERROR_HANDLER_RETURN("ReAsync",FALSE)
00632 }

BOOL CAsyncSocket::ReBlock ( ) [virtual, inherited]

Definition at line 517 of file AsyncSocket.cpp.

00518 {
00519     if (m_bBlocking)
00520         return TRUE;
00521 
00522     try
00523     {
00524         //Quit if not ok
00525         if (!CheckAsyncSocketValid())
00526             return FALSE;
00527 
00528         if (Block())
00529             //Set to reblock
00530             m_bBlocking=TRUE;
00531 
00532         //And quit
00533         return TRUE;
00534     }
00535     ERROR_HANDLER_RETURN("ReBlock",FALSE)
00536 }

int CUDPSocket::Receive	(	char *	pBuffer,
		unsigned long	ulBufferLength,
		IP &	rIP,
		unsigned short &	rSourcePort
	)			`[virtual, inherited]`

Definition at line 125 of file UDPSocket.cpp.

00129 {
00130     try
00131     {
00132         //Delegate call
00133         return ReceiveFrom(pBuffer,
00134                            ulBufferLength,
00135                            rIP,
00136                            rSourcePort);
00137     }
00138     ERROR_HANDLER_RETURN("Receive",GetErrorCode())
00139 }

int CUDPSocket::Receive	(	char *	pBuffer,
		unsigned long	ulBufferLength
	)			`[virtual, inherited]`

Reimplemented from CSocket.

Definition at line 113 of file UDPSocket.cpp.

00115 {
00116     try
00117     {
00118         //Delegate call
00119         return CSocket::Receive(pBuffer,
00120                                 ulBufferLength);
00121     }
00122     ERROR_HANDLER_RETURN("Receive",GetErrorCode())
00123 }

int CSocket::ReceiveFrom	(	char *	pBuffer,
		unsigned long	ulBufferLength,
		IP &	rIP,
		unsigned short &	rSourcePort
	)			`[protected, virtual, inherited]`

Definition at line 514 of file Socket.cpp.

00518 {
00519     try
00520     {
00521         if (!ValidSocket() ||
00522             !pBuffer ||
00523             !ulBufferLength)
00524             return GetErrorCode();
00525 
00526         //Receive data
00527         int iResult;
00528 
00529         //Receive
00530         if (m_ucProtocol!=IPPROTO_TCP)
00531         {
00532             //Get the remote address
00533             sockaddr saConnected;
00534 
00535             int iTmp;
00536             iTmp=sizeof(saConnected);
00537 
00538             //Accept it
00539             iResult=recvfrom(GetHandle(),
00540                              pBuffer,
00541                              ulBufferLength,
00542                              NULL,
00543                              &saConnected,
00544                              &iTmp);
00545 
00546             //If OK set it
00547             if (iResult!=GetErrorCode())
00548             {
00549                 //Address
00550                 rIP=((sockaddr_in*)&saConnected)->sin_addr.S_un.S_addr;
00551 
00552                 //Port
00553                 rSourcePort=htons(((sockaddr_in*)&saConnected)->sin_port);
00554 
00555                 //Done
00556                 return iResult;
00557             }
00558             else
00559             {
00560                 //Error
00561                 SetLastError("Receive");
00562 
00563                 //Reset the data
00564                 rIP=0;
00565                 rSourcePort=0;
00566 
00567                 //Done
00568                 return iResult;
00569             }
00570         }
00571         else
00572         {
00573             //Report it
00574             ReportError("Receive","Can't run on TCP socket!");
00575 
00576             //Exit
00577             return GetErrorCode();
00578         }
00579     }
00580     ERROR_HANDLER_RETURN("Receive",GetErrorCode())
00581 }

void CErrorHandler::RegisterError	(	DWORD	dwErrorCode,
		const std::string &	rDescription
	)			`[static, inherited]`

Definition at line 597 of file ErrorHandler.cpp.

00599 {
00600     try
00601     {
00602         //Add the error
00603         CErrorsRepository::GetInstance().GetErrorsMap().insert(CErrorsRepository::ErrorMap::value_type(dwErrorCode,rDescription));
00604     }
00605     ERROR_HANDLER_STATIC(CErrorHandler_Class,"RegisterError")
00606 }

void CSocketBase::RegisterShutdown ( CSocketBase * pBase ) [protected, inherited]

Definition at line 277 of file SocketBase.cpp.

00278 {
00279     try
00280     {
00281         //Check if we already have a class
00282         if (m_pShutdownClass)
00283             delete m_pShutdownClass;
00284 
00285         //Take it
00286         m_pShutdownClass=pBase;
00287     }
00288     ERROR_HANDLER("RegisterShutdown")
00289 }

CSocketThreadManagerImp::TimerID CAsyncSocket::RegisterTimeout	(	int	iMS,
		CSocketThreadManagerImp::LPTimeoutProc	pProc,
		LPVOID	pData,
		BOOL	bClearTimeout = `FALSE`,
		CSocketThreadManagerImp::TimerID *	pTimer = `NULL`
	)			`[inherited]`

Definition at line 1220 of file AsyncSocket.cpp.

01225 {
01226     //Delegate the call
01227     return GetThreadManager()->RegisterTimeout(iMS,
01228                                                pProc,
01229                                                pData,
01230                                                bClearTimeout,
01231                                                GetWindowHandle(),
01232                                                pTimer);
01233 }

void CAsyncSocket::RemoveSocketFromList ( ) [protected, inherited]

Definition at line 262 of file AsyncSocket.cpp.

00263 {
00264     try
00265     {
00266         if (m_bList)
00267         {
00268             //Remove from thread manager
00269             GetThreadManager()->RemoveSocket(this);
00270 
00271             //Not in list
00272             m_bList=FALSE;
00273 
00274             //Deallocate the handle
00275             DeAllocateHandle();
00276         }
00277     }
00278     ERROR_HANDLER("RemoveSocketFromList")
00279 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		int	iErrorCode
	)			const `[protected, virtual, inherited]`

Definition at line 271 of file ErrorHandler.cpp.

00274 {
00275     if (!GetLog())
00276         return;
00277 
00278     try
00279     {
00280         //Convert the error code
00281         char aTmp[11];
00282         sprintf(aTmp,"%d",iErrorCode);
00283 
00284         //Get the string for it
00285         std::string sError;
00286         sError=rMessage;
00287         sError+=", and Socket error: ";
00288         sError+=aTmp;
00289         sError+=", ";
00290         sError+=ErrorCodeToString(iErrorCode);
00291 
00292         //Report to the log
00293         WriteError(m_sClassName,
00294                    rMethod,
00295                    sError);
00296     }
00297     ERROR_UNKNOWN("ReportError")
00298 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		int	iErrorCode
	)			const `[protected, virtual, inherited]`

Definition at line 300 of file ErrorHandler.cpp.

00302 {
00303     if (!GetLog())
00304         return;
00305 
00306     try
00307     {
00308         //Convert the error code
00309         char aTmp[11];
00310         sprintf(aTmp,"%d",iErrorCode);
00311 
00312         //Get the string for it
00313         std::string sError;
00314         sError="Socket error: ";
00315         sError+=aTmp;
00316         sError+=", ";
00317         sError+=ErrorCodeToString(iErrorCode);
00318 
00319         //Report to the log
00320         WriteError(m_sClassName,
00321                    rMethod,
00322                    sError);
00323     }
00324     ERROR_UNKNOWN("ReportError")
00325 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		const std::string &	rAdditionalData
	)			const `[protected, virtual, inherited]`

Definition at line 416 of file ErrorHandler.cpp.

00419 {
00420     if (!GetLog())
00421         return;
00422 
00423     try
00424     {
00425         //Create the new message
00426         std::string sNewMessage(rMessage);
00427         sNewMessage+=", Additional data: ";
00428         sNewMessage+=rAdditionalData;
00429 
00430         //Report to the log
00431         WriteError(m_sClassName,
00432                    rMethod,
00433                    sNewMessage);
00434     }
00435     ERROR_UNKNOWN("ReportError")
00436 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			const `[protected, virtual, inherited]`

Definition at line 438 of file ErrorHandler.cpp.

00441 {
00442     if (!GetLog())
00443         return;
00444 
00445     try
00446     {
00447         //Convert the number
00448         char aTmp[11];
00449         ltoa(dwAdditionalData,aTmp,10);
00450 
00451         //Create the new message
00452         std::string sNewMessage(rMessage);
00453         sNewMessage+=", Additional data: ";
00454         sNewMessage+=aTmp;
00455 
00456         //Report to the log
00457         WriteError(m_sClassName,
00458                    rMethod,
00459                    sNewMessage);
00460     }
00461     ERROR_UNKNOWN("ReportError")
00462 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[protected, virtual, inherited]`

Definition at line 327 of file ErrorHandler.cpp.

00329 {
00330     if (!GetLog())
00331         return;
00332 
00333     try
00334     {
00335         //Report to the log
00336         WriteError(m_sClassName,
00337                    rMethod,
00338                    rMessage);
00339     }
00340     ERROR_UNKNOWN("ReportError")
00341 }

void CErrorHandler::ReportError ( const std::string & rMethod ) const [protected, virtual, inherited]

Definition at line 470 of file ErrorHandler.cpp.

00471 {
00472     if (!GetLog())
00473         return;
00474 
00475     try
00476     {
00477         //Get the last error
00478         DWORD dwLastError;
00479         dwLastError=GetLastError();
00480 
00481         //Report the error
00482         WriteError(m_sClassName,
00483                    rMethod,
00484                    ErrorCodeToString(dwLastError));
00485     }
00486     ERROR_UNKNOWN("ReportError")
00487 }

void CErrorHandler::ReportErrorOS	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[protected, virtual, inherited]`

Definition at line 378 of file ErrorHandler.cpp.

00380 {
00381     if (!GetLog())
00382         return;
00383 
00384     try
00385     {
00386         //Get the last error
00387         DWORD dwLastError;
00388         dwLastError=GetLastError();
00389 
00390         //Format the message
00391         std::string sMessage;
00392         sMessage=rMessage;
00393         sMessage+=", with error code: ";
00394 
00395         //Convert the error code
00396         char aTmp[11];
00397         itoa(dwLastError,aTmp,10);
00398 
00399         //Add it again
00400         sMessage+=aTmp;
00401         sMessage+=" ";
00402         sMessage+=ErrorCodeToString(dwLastError);
00403         
00404         //Get the log
00405         CErrorLog* pLog;
00406         pLog=GetLog();
00407 
00408         //Report to the log
00409         WriteError(m_sClassName,
00410                    rMethod,
00411                    sMessage);
00412     }
00413     ERROR_UNKNOWN("ReportErrorOS")
00414 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			`[static, protected, inherited]`

Definition at line 540 of file ErrorHandler.cpp.

00544 {
00545     if (!m_pLog)
00546         return;
00547 
00548     try
00549     {
00550         //Convert the number
00551         char aTmp[11];
00552         ltoa(dwAdditionalData,aTmp,10);
00553 
00554         //Create the new message
00555         std::string sNewMessage(rMessage);
00556         sNewMessage+=", Additional data: ";
00557         sNewMessage+=aTmp;
00558 
00559         //Report to the log
00560         WriteStaticError(rClass,
00561                          rMethod,
00562                          sNewMessage);
00563     }
00564     ERROR_UNKNOWN("ReportStaticError")
00565 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			`[static, protected, inherited]`

Definition at line 523 of file ErrorHandler.cpp.

00526 {
00527     if (!m_pLog)
00528         return;
00529 
00530     try
00531     {
00532         //Report to the log
00533         WriteStaticError(rClass,
00534                          rMethod,
00535                          rMessage);
00536     }
00537     ERROR_UNKNOWN("ReportStaticError")
00538 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod
	)			`[static, protected, inherited]`

Definition at line 503 of file ErrorHandler.cpp.

00505 {
00506     if (!m_pLog)
00507         return;
00508 
00509     try
00510     {
00511         //Get the last error
00512         DWORD dwLastError;
00513         dwLastError=GetLastError();
00514 
00515         //Report the error
00516         WriteStaticError(rClass,
00517                           rMethod,
00518                           ErrorCodeToString(dwLastError));
00519     }
00520     ERROR_UNKNOWN("ReportStaticError")
00521 }

void CErrorHandler::ReportStaticErrorOS	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			`[static, protected, inherited]`

Definition at line 343 of file ErrorHandler.cpp.

00346 {
00347     if (!m_pLog)
00348         return;
00349 
00350     try
00351     {
00352         //Get the last error
00353         DWORD dwLastError;
00354         dwLastError=GetLastError();
00355 
00356         //Format the message
00357         std::string sMessage;
00358         sMessage=rMessage;
00359         sMessage+=", with error code: ";
00360 
00361         //Convert the error code
00362         char aTmp[11];
00363         itoa(dwLastError,aTmp,10);
00364 
00365         //Add it again
00366         sMessage+=aTmp;
00367         sMessage+=" ";
00368         sMessage+=ErrorCodeToString(dwLastError);
00369         
00370         //Report to the log
00371         WriteStaticError(rClass,
00372                          rMethod,
00373                          sMessage);
00374     }
00375     ERROR_UNKNOWN("ReportStaticError")
00376 }

void CAsyncSocket::ResetEvent ( ) [protected, inherited]

Definition at line 1338 of file AsyncSocket.cpp.

01339 {
01340     m_pSendEvent->Reset();
01341 }

unsigned long CSocketBase::ResolveDNS ( const std::string & rAddress ) [static, inherited]

Definition at line 431 of file SocketBase.cpp.

00432 {
00433     try
00434     {
00435         //Resolve the DNS
00436         sockaddr_in aAddr;
00437         aAddr=InternalResolveDNS(rAddress.c_str());
00438 
00439         //Check if valid
00440         if (aAddr.sin_addr.S_un.S_addr==0)
00441             //Error
00442             return 0;
00443         else
00444             return aAddr.sin_addr.S_un.S_addr;
00445     }
00446     ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"ResolveDNS",0)
00447 }

int CSocket::Send	(	const std::string &	rDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned short	usDestinationPort = `0`
	)			`[virtual, inherited]`

Definition at line 245 of file Socket.cpp.

00249 {
00250     try
00251     {
00252         //Quit if not ok
00253         if (!CheckSocketValid())
00254             return GetErrorCode();
00255 
00256         return Send(inet_addr(rDestinationAddress.c_str()),
00257                     pBuffer,
00258                     ulBufferLength,
00259                     usDestinationPort);
00260     }
00261     ERROR_HANDLER_RETURN("Send",GetErrorCode())
00262 }

int CSocket::Send	(	IP	aDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned short	usDestinationPort = `0`
	)			`[virtual, inherited]`

Definition at line 191 of file Socket.cpp.

00195 {
00196     try
00197     {
00198         //Quit if not ok
00199         if (!CheckSocketValid())
00200             return GetErrorCode();
00201 
00202         //Is it a valid size
00203         if (ulBufferLength &&
00204             !pBuffer)
00205             return GetErrorCode();
00206 
00207         //Define the target address
00208         sockaddr_in aTargetAddress;
00209         memset(&aTargetAddress,
00210                0,
00211                sizeof(aTargetAddress));
00212 
00213         aTargetAddress.sin_family=AF_INET;
00214         aTargetAddress.sin_addr.s_addr=aDestinationAddress;
00215         aTargetAddress.sin_port=htons(usDestinationPort);
00216 
00217         //packet send status ?
00218         int iResult;
00219 
00220         //Set to no error
00221         iResult=!GetErrorCode();
00222 
00223         //Check if we had an error
00224         if (iResult!=GetErrorCode())
00225             //Use regular send !!!
00226             iResult=sendto(GetHandle(),
00227                            (const char*)pBuffer,
00228                            ulBufferLength,
00229                            0,
00230                            (sockaddr*)&aTargetAddress,
00231                            sizeof(aTargetAddress));
00232         
00233         //Is all OK?
00234         if (iResult==GetErrorCode() &&
00235             GetSystemLastError()!=WSAEWOULDBLOCK)
00236             //Set the error
00237             SetLastError("Send");
00238         
00239         //Done
00240         return iResult;
00241     }
00242     ERROR_HANDLER_RETURN("Send",GetErrorCode())
00243 }

BOOL CUDPSocketAsync::Send	(	const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned short	usBufferLength
	)			`[virtual]`

Reimplemented from CUDPSocket.

Definition at line 206 of file UDPSocketAsync.cpp.

00210 {
00211     try
00212     {
00213         //Delegate call
00214         return CUDPSocket::Send(rDestinationAddress,
00215                                 usDestinationPort,
00216                                 pBuffer,
00217                                 usBufferLength);
00218     }
00219     ERROR_HANDLER_RETURN("Send",GetErrorCode())
00220 }

BOOL CUDPSocketAsync::Send	(	IP	aDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned short	usBufferLength
	)			`[virtual]`

Reimplemented from CUDPSocket.

Definition at line 190 of file UDPSocketAsync.cpp.

00194 {
00195     try
00196     {
00197         //Delegate call
00198         return CUDPSocket::Send(aDestinationAddress,
00199                                 usDestinationPort,
00200                                 pBuffer,
00201                                 usBufferLength);
00202     }
00203     ERROR_HANDLER_RETURN("Send",GetErrorCode())
00204 }

BOOL CAsyncSocket::SendBlockedBuffer ( const CBlockedBuffer::CBlockedData & rData ) [protected, virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 705 of file AsyncSocket.cpp.

00706 {
00707     //No implemented at this level
00708     return FALSE;
00709 }

BOOL CUDPSocketAsync::SetAsync ( ) [protected, virtual]

Implements CAsyncSocket.

Definition at line 100 of file UDPSocketAsync.cpp.

00101 {
00102     try
00103     {
00104         //Quit if not ok
00105         if (!CheckSocketValid())
00106             return FALSE;
00107 
00108         //Set event to read / write 
00109         int iResult;
00110         iResult=InternalWSAAsyncSelect(WM_SOCKET_GENERAL,
00111                                        FD_WRITE | FD_READ);
00112 
00113         //Check result
00114         if (iResult)
00115         {
00116             //Report it
00117             SetLastError("SetAsync");
00118 
00119             //Exit
00120             return FALSE;
00121         }
00122         else
00123             return TRUE;
00124     }
00125     ERROR_HANDLER_RETURN("SetAsync",FALSE)
00126 }

BOOL CSocket::SetBroadcast ( BOOL bBroadcast ) [inherited]

Definition at line 818 of file Socket.cpp.

00819 {
00820     try
00821     {
00822         //Quit if not ok
00823         if (!CheckSocketValid())
00824             return FALSE;
00825 
00826         //Set broadcast option
00827         if(setsockopt(GetHandle(),
00828                       SOL_SOCKET,
00829                       SO_BROADCAST,
00830                       (char*)&bBroadcast,
00831                       sizeof(bBroadcast))==GetErrorCode())
00832         {
00833             //Check for options error
00834             SetLastError("SetBroadcast");
00835 
00836             //Exit
00837             return FALSE;
00838         }   
00839 
00840         return TRUE;
00841     }
00842     ERROR_HANDLER_RETURN("SetBroadcast",FALSE)
00843 }

void CSocket::SetConnectedTo ( const sockaddr_in & rAddress ) [protected, inherited]

Definition at line 897 of file Socket.cpp.

00898 {
00899     m_aConnectedTo=rAddress;
00900 }

void CAsyncSocket::SetDeleting ( ) [inherited]

Definition at line 1353 of file AsyncSocket.cpp.

01354 {
01355     m_bDeleting=TRUE;
01356 }

void CAsyncSocket::SetInstance ( HINSTANCE hInst ) [static, inherited]

Definition at line 251 of file AsyncSocket.cpp.

00252 {
00253     m_hInstance=hInst;
00254 }

void CSocketBase::SetLastError	(	const std::string &	rMethod,
		int	iErrorCode
	)			const `[protected, inherited]`

Definition at line 124 of file SocketBase.cpp.

00126 {
00127     try
00128     {
00129         //First set the error
00130         m_iLastError=iErrorCode;
00131 
00132         //Check if there is an error
00133         if (m_iLastError)
00134             ReportError(rMethod,
00135                         "Through SetLastError",
00136                         m_iLastError);
00137     }
00138     ERROR_HANDLER("SetLastError")
00139 }

void CSocketBase::SetLastError ( const std::string & rMethod ) const [protected, inherited]

Definition at line 104 of file SocketBase.cpp.

00105 {
00106     try
00107     {
00108 #ifdef WIN32
00109         //First set the error
00110         m_iLastError=WSAGetLastError();
00111 #else
00112         m_iLastError=errno();
00113 #endif
00114 
00115         //Check if there is an error
00116         if (m_iLastError)
00117             ReportError(rMethod,
00118                         "Through SetLastError",
00119                         m_iLastError);
00120     }
00121     ERROR_HANDLER("SetLastError")
00122 }

void CErrorHandler::SetLocalLog ( CErrorLog * pLog ) [inherited]

Definition at line 498 of file ErrorHandler.cpp.

00499 {
00500     m_pLocalLog=pLog;
00501 }

BOOL CAsyncSocket::SetLocalThreadManager ( CSocketThreadManagerImp * pManager ) [inherited]

Definition at line 1235 of file AsyncSocket.cpp.

01236 {
01237     try
01238     {
01239         //We can do it only if we are not created
01240         if (GetAsyncHandle()!=INVALID_SOCKET)
01241         {
01242             //Report it
01243             ReportError("SetLocalThreadManager","Can't switch after socket is created!");
01244 
01245             //Exit
01246             return FALSE;
01247         }
01248 
01249         //Is it a legal manager
01250         if (!pManager ||
01251             !pManager->IsInitialized())
01252         {
01253             //Report it
01254             ReportError("SetLocalThreadManager","Manager is either null or not initialized!");
01255 
01256             //Exit
01257             return FALSE;
01258         }
01259 
01260         //Save the new manager
01261         m_pLocalThreadManager=pManager;
01262 
01263         //Done
01264         return TRUE;
01265     }
01266     ERROR_HANDLER_RETURN("SetLocalThreadManager",FALSE)
01267 }

void CErrorHandler::SetLog ( CErrorLog * pLog ) [static, inherited]

Definition at line 464 of file ErrorHandler.cpp.

00465 {
00466     //Save the new log
00467     m_pLog=pLog;
00468 }

void CErrorHandler::SetName ( const std::string & rName ) const [protected, inherited]

Definition at line 134 of file ErrorHandler.cpp.

00135 {
00136     //Save the class name
00137     m_sClassName=rName;
00138 }

void CSocket::SetProtocol ( unsigned char iProtocol ) [inherited]

Definition at line 186 of file Socket.cpp.

00187 {
00188     m_ucProtocol=ucProtocol;
00189 }

BOOL CSocket::SetReceiveTimeout ( unsigned long ulMS ) [inherited]

Definition at line 860 of file Socket.cpp.

00861 {
00862     try
00863     {
00864         //Quit if not ok
00865         if (!CheckSocketValid())
00866             return FALSE;
00867 
00868         //Set it
00869         if(setsockopt(GetHandle(),
00870                       SOL_SOCKET,
00871                       SO_RCVTIMEO,
00872                       (char*)&ulMS,
00873                       sizeof(ulMS))==GetErrorCode())
00874         {
00875             //Check for options error
00876             SetLastError("SetReceiveTimeout");
00877 
00878             //Exit
00879             return FALSE;
00880         }
00881         else
00882             return TRUE;
00883     }
00884     ERROR_HANDLER_RETURN("SetReceiveTimeout",FALSE)
00885 }

void CSocket::SetSourceAddress ( const std::string & rSourceAddress ) [virtual, inherited]

Definition at line 440 of file Socket.cpp.

00441 {
00442     try
00443     {
00444         //Set the source address, in case we want to spoof it
00445         if (rSourceAddress.empty())
00446             m_ulSourceAddress=0;
00447         else
00448             m_ulSourceAddress=inet_addr(rSourceAddress.c_str());
00449     }
00450     ERROR_HANDLER("SetSourceAddress")
00451 }

void CSocket::SetSourceAddress ( IP aSourceAddress ) [virtual, inherited]

Definition at line 435 of file Socket.cpp.

00436 {
00437     m_ulSourceAddress=aSourceAddress;
00438 }

BOOL CAsyncSocket::SetSystemTimeout ( int iMS ) [protected, inherited]

Definition at line 956 of file AsyncSocket.cpp.

00957 {
00958     try
00959     {
00960         //Do we have a timeout
00961         if (m_aTimerID.iTimerID)
00962         {
00963             //Report it
00964             ReportError("SetSystemTimeout","Please kill previous timer!");
00965 
00966             //Exit
00967             return FALSE;
00968         }
00969 
00970         //Create the timer
00971         m_aTimerID=GetThreadManager()->RegisterTimeout(iMS,
00972                                                        SystemTimerProc,
00973                                                        this,
00974                                                        TRUE,
00975                                                        GetWindowHandle(),
00976                                                        &m_aTimerID);
00977 
00978         //Do we have it
00979         if (!m_aTimerID.iTimerID)
00980         {
00981             //Report it
00982             ReportError("SetSystemTimeout","Failed creating the timer!");
00983 
00984             //Exit
00985             return FALSE;
00986         }
00987         else
00988             return TRUE;
00989     }
00990     ERROR_HANDLER_RETURN("SetSystemTimeout",FALSE)
00991 }

BOOL CAsyncSocket::SetTimeout ( int iMs ) [inherited]

Definition at line 281 of file AsyncSocket.cpp.

00282 {
00283     try
00284     {
00285         //Get the window handle
00286         HWND hWindowHandle;
00287         hWindowHandle=GetWindowHandle();
00288 
00289         if (!hWindowHandle)
00290             return FALSE;
00291 
00292         //Set the timer
00293         m_bTimeout=SetTimer(hWindowHandle,
00294                             GetAsyncHandle(),
00295                             iMs,
00296                             NULL);
00297 
00298         return m_bTimeout;
00299     }
00300     ERROR_HANDLER_RETURN("SetTimeout",FALSE)
00301 }

void CSocket::SetTTL ( unsigned char ucTTL ) [inherited]

Definition at line 453 of file Socket.cpp.

00454 {
00455     try
00456     {
00457         //Quit if not ok
00458         if (!CheckSocketValid())
00459             return;
00460 
00461         if(setsockopt(GetHandle(),
00462                       IPPROTO_IP,
00463                       IP_TTL,
00464                       (const char*)&ucTTL,
00465                       sizeof(ucTTL)))
00466             SetLastError("SetTTL");
00467     }
00468     ERROR_HANDLER("SetTTL")
00469 }

void CAsyncSocket::Shutdown ( ) [static, inherited]

Definition at line 332 of file AsyncSocket.cpp.

00333 {
00334     try
00335     {
00336         //Only if initialized
00337         if (!m_bInitialized)
00338             return;
00339 
00340         //Indicate we're shutting down
00341         m_bShuttingDown=TRUE;
00342 
00343         //Delete the thread manager
00344         if (m_pThreadManager)
00345         {
00346             delete m_pThreadManager;
00347             m_pThreadManager=NULL;
00348         }
00349 
00350         //Not initialized anymore
00351         m_bInitialized=FALSE;
00352     }
00353     ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown")
00354 }

BOOL CSocket::Shutdown ( SocketShutdown eHow ) [inherited]

Definition at line 683 of file Socket.cpp.

00684 {
00685     if (!CheckSocketValid())
00686         return FALSE;
00687 
00688     try
00689     {
00690         int iHow;
00691 
00692         //Convert the how to a real flag
00693         if (eHow==ssReceive)
00694             iHow=SD_RECEIVE;
00695         else if (eHow==ssSend)
00696             iHow=SD_SEND;
00697         else
00698             iHow=SD_BOTH;
00699 
00700         //Do it
00701         if (shutdown(GetHandle(),iHow))
00702         {
00703             //Report it
00704             SetLastError("Shutdown");
00705 
00706             //Exit
00707             return FALSE;
00708         }
00709 
00710         //Done
00711         return TRUE;
00712     }
00713     ERROR_HANDLER_RETURN("Shutdown",FALSE)
00714 }

BOOL CSocketBase::ShutdownSockets ( ) [static, inherited]

Definition at line 231 of file SocketBase.cpp.

00232 {
00233     //Only if initialized
00234     if (!m_bInitialized)
00235         return TRUE;
00236 
00237     try
00238     {
00239         //Delete the CS
00240         delete m_pCSection;
00241         m_pCSection=NULL;
00242 
00243         //Delete the DNS CS
00244         delete m_pCSectionDNS;
00245         m_pCSectionDNS=NULL;
00246 
00247         //Clear the DNS map
00248         m_aDNSMap.clear();
00249 
00250         //Notify shutdown class
00251         if (m_pShutdownClass)
00252         {
00253             //Notify we are shuting down
00254             m_pShutdownClass->NotifyShutdown();
00255 
00256             //Delete it
00257             delete m_pShutdownClass;
00258             m_pShutdownClass=NULL;
00259         }
00260 
00261         //Not initialized anymore
00262         m_bInitialized=FALSE;
00263 
00264         if (WSACleanup()==GetErrorCode())
00265             return FALSE;
00266 
00267         //Done
00268         return TRUE;
00269     }
00270     ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"ShutdownSockets",FALSE)
00271 }

void CAsyncSocket::SimpleMessageMap	(	LPMapProc	pProc,
		BOOL	bStopWhenTRUE,
		DWORD	dwSleep
	)			`[static, inherited]`

Definition at line 866 of file AsyncSocket.cpp.

00869 {
00870     try
00871     {
00872         //Check if we have the proc
00873         if (!pProc)
00874         {
00875             //Report it
00876             ReportStaticError(CAsyncSocket_Class,"SimpleMessageMap","Recieved null proc!");
00877 
00878             //Exit
00879             return;
00880         }
00881 
00882         //If there is no message map, then receive won't work
00883         MSG msg;
00884 
00885         //Set the message map to zeros
00886         memset(&msg,
00887                0,
00888                sizeof(msg));
00889 
00890         //Stop flag
00891         BOOL bStop;
00892         bStop=FALSE;
00893 
00894         //Start the loop
00895         while (!bStop &&
00896                (*pProc)()!=bStopWhenTRUE)
00897         {
00898             while (!(bStop=(*pProc)()==bStopWhenTRUE) &&
00899                    PeekMessage(&msg, 
00900                                NULL, 
00901                                0, 
00902                                0, 
00903                                PM_REMOVE))
00904             {
00905                 TranslateMessage(&msg);
00906                 DispatchMessage(&msg); 
00907             }
00908 
00909             //Do we need to sleep?
00910             if (!bStop)
00911                 //No messages
00912                 Sleep(dwSleep);
00913         }
00914     }
00915     ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
00916 }

void CAsyncSocket::SimpleMessageMap ( DWORD dwRunTimeMS ) [static, inherited]

Definition at line 830 of file AsyncSocket.cpp.

00831 {
00832     try
00833     {
00834         //If there is no message map, then receive won't work
00835         MSG msg;
00836 
00837         //Set the message map to zeros
00838         memset(&msg,
00839                0,
00840                sizeof(msg));
00841 
00842         //Start loop
00843         DWORD dwLoopStart;
00844         dwLoopStart=GetTickCount();
00845 
00846         //Until a key was hit
00847         while (GetTickCount()-dwLoopStart<dwRunTimeMS)
00848         {
00849             while (PeekMessage(&msg, 
00850                                NULL, 
00851                                0, 
00852                                0, 
00853                                PM_REMOVE))
00854             {
00855                 TranslateMessage(&msg);
00856                 DispatchMessage(&msg); 
00857             }
00858 
00859             //Sleep so wont be hanged
00860             Sleep(1);
00861         }
00862     }
00863     ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
00864 }

void CAsyncSocket::SimpleMessageMap ( ) [static, inherited]

Definition at line 805 of file AsyncSocket.cpp.

00806 {
00807     try
00808     {
00809         //If there is no message map, then receive won't work
00810         MSG msg;
00811 
00812         //Set the message map to zeros
00813         memset(&msg,
00814                0,
00815                sizeof(msg));
00816 
00817         while (GetMessage(&msg,
00818                           NULL,
00819                           0,
00820                           0))
00821         {
00822             //Dispatch the message
00823             TranslateMessage(&msg);
00824             DispatchMessage(&msg);
00825         }
00826     }
00827     ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
00828 }

char CAsyncSocket::SimpleMessageMapKey ( DWORD dwSleep ) [static, inherited]

Definition at line 918 of file AsyncSocket.cpp.

00919 {
00920     try
00921     {
00922         //If there is no message map, then receive won't work
00923         MSG msg;
00924 
00925         //Set the message map to zeros
00926         memset(&msg,
00927                0,
00928                sizeof(msg));
00929 
00930         //Until a key was hit
00931         while (!kbhit())
00932         {
00933             while (!kbhit() &&
00934                    PeekMessage(&msg, 
00935                                NULL, 
00936                                0, 
00937                                0, 
00938                                PM_REMOVE))
00939             {
00940                 TranslateMessage(&msg);
00941                 DispatchMessage(&msg); 
00942             }
00943 
00944             //Do we need to sleep
00945             if (!kbhit())
00946                 //Sleep so wont be hanged
00947                 Sleep(dwSleep);
00948         }
00949         
00950         //Return the char
00951         return getch();
00952     }
00953     ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"SimpleMessageMapKey",0)
00954 }

BOOL CAsyncSocket::SocketAccept	(	int	iErrorCode,
		BOOL	bNoEvent = `FALSE`
	)			`[protected, virtual, inherited]`

Definition at line 758 of file AsyncSocket.cpp.

00760 {
00761     try
00762     {
00763         //Do we need to call event?
00764         if (!bNoEvent)
00765             return OnSocketAccept(iErrorCode);
00766         else
00767             return FALSE;
00768     }
00769     ERROR_HANDLER_RETURN("SocketConnected",FALSE)
00770 }

BOOL CAsyncSocket::SocketClosed	(	int	iErrorCode,
		BOOL	bNoEvent = `FALSE`
	)			`[protected, virtual, inherited]`

Definition at line 772 of file AsyncSocket.cpp.

00774 {
00775     try
00776     {
00777         //Kill the timer
00778         CAsyncSocket::SocketClosing();
00779 
00780         //Remove from socket list
00781         RemoveSocketFromList();
00782 
00783         //Call user data
00784         if (!bNoEvent)
00785             return OnSocketClose(iErrorCode);
00786         else
00787             return TRUE;
00788     }
00789     ERROR_HANDLER_RETURN("SocketClosed",FALSE)
00790 }

void CAsyncSocket::SocketClosing ( ) [protected, inherited]

Definition at line 475 of file AsyncSocket.cpp.

00476 {
00477     try
00478     {
00479         //Are we valid
00480         if (m_bClosing ||
00481             GetAsyncHandle()==INVALID_SOCKET)
00482             return;
00483 
00484         //Indicate we are closing
00485         m_bClosing=TRUE;
00486 
00487         //Signal the event
00488         m_pSendEvent->Set();
00489 
00490         //Do we have a regular timer
00491         if (m_bTimeout)
00492             KillTimer();
00493 
00494         //Do we have a system timer ?
00495         if (m_aTimerID.iTimerID)
00496             KillSystemTimer();
00497 
00498         //Kill all the messages
00499         m_iMsg=0;
00500         m_lEvent=0;
00501 
00502         //Set it
00503         if (WSAAsyncSelect(GetAsyncHandle(),
00504                            GetWindowHandle(),
00505                            0,
00506                            0))
00507             SetLastError("SocketClosing");
00508     }
00509     ERROR_HANDLER("SocketClosing")
00510 }

BOOL CAsyncSocket::SocketConnected	(	int	iErrorCode,
		BOOL	bNoEvent = `FALSE`
	)			`[protected, virtual, inherited]`

Reimplemented in CTCPSocketAsync.

Definition at line 716 of file AsyncSocket.cpp.

00718 {
00719     try
00720     {
00721         //Did we have an error
00722         if (iErrorCode)
00723             if (!bNoEvent)
00724                 return OnSocketConnect(iErrorCode);
00725             else
00726                 return FALSE;
00727 
00728         //Save the connect value
00729         BOOL bConnectValue;
00730         if (!bNoEvent)
00731             bConnectValue=OnSocketConnect(0);
00732         else
00733             bConnectValue=TRUE;
00734 
00735         //Try to set it to async
00736         if (!SetAsync())
00737             return FALSE;
00738         else
00739             return bConnectValue;
00740     }
00741     ERROR_HANDLER_RETURN("SocketConnected",FALSE)
00742 }

void CAsyncSocket::SocketCreated ( ) [protected, virtual, inherited]

Definition at line 1174 of file AsyncSocket.cpp.

01175 {
01176     try
01177     {
01178         //No timer
01179         memset(&m_aTimerID,
01180                0,
01181                sizeof(m_aTimerID));
01182 
01183         //No delete timer
01184         memset(&m_aDeleteTimerID,
01185                0,
01186                sizeof(m_aDeleteTimerID));
01187 
01188         //Set values for new socket
01189         m_iSocketID=0;
01190         m_bBlocking=FALSE;
01191         m_bFreeze=FALSE;
01192         m_lEvent=0;
01193         m_hLocalWindowHandle=0;
01194         m_bList=FALSE;
01195         m_bClosing=FALSE;
01196     }
01197     ERROR_HANDLER("SocketCreated")
01198 }

BOOL CAsyncSocket::SocketReceive	(	int	iErrorCode,
		BOOL	bNoEvent = `FALSE`
	)			`[protected, virtual, inherited]`

Reimplemented in CTCPSocketAsync.

Definition at line 744 of file AsyncSocket.cpp.

00746 {
00747     try
00748     {
00749         //Do we need to call event?
00750         if (!bNoEvent)
00751             return OnSocketReceive(iErrorCode);
00752         else
00753             return FALSE;
00754     }
00755     ERROR_HANDLER_RETURN("SocketConnected",FALSE)
00756 }

BOOL CAsyncSocket::SocketWrite ( int iErrorCode ) [protected, virtual, inherited]

Definition at line 792 of file AsyncSocket.cpp.

00793 {
00794     try
00795     {
00796         //Notify the event
00797         m_pSendEvent->Set();
00798 
00799         //Call user data
00800         return OnSocketWrite(iErrorCode);
00801     }
00802     ERROR_HANDLER_RETURN("SocketWrite",FALSE)
00803 }

unsigned long CSocketBase::StringToLong ( const std::string & rAddress ) [static, inherited]

Definition at line 344 of file SocketBase.cpp.

00345 {
00346     //Try to convert it
00347     unsigned long ulAddress;
00348     ulAddress=inet_addr(rAddress.c_str());
00349 
00350     //Is it valid
00351     if (ulAddress!=INADDR_NONE)
00352         return ulAddress;
00353     else
00354         //Try to resolve it
00355         return ResolveDNS(rAddress);
00356 }

void CAsyncSocket::SystemTimeout ( ) [protected, virtual, inherited]

Definition at line 1006 of file AsyncSocket.cpp.

01007 {
01008     //Nothing to do
01009 }

BOOL CSocketBase::ValidAddress ( const std::string & rAddress ) [static, inherited]

Definition at line 373 of file SocketBase.cpp.

00374 {
00375     try
00376     {
00377         return inet_addr(rAddress.c_str())!=INADDR_NONE;
00378     }
00379     ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"ValidAddress",FALSE)
00380 }

BOOL CSocket::ValidSocket ( ) const [protected, inherited]

Definition at line 264 of file Socket.cpp.

00265 {
00266     return m_aSocket!=INVALID_SOCKET;
00267 }

BOOL CAsyncSocket::WaitForBlockEvent ( ) const [protected, inherited]

Definition at line 1329 of file AsyncSocket.cpp.

01330 {
01331     //Wait for the event
01332     if (m_pSendEvent->Wait(5000))
01333         return TRUE;
01334     else
01335         return IsClosing();
01336 }

void CErrorHandler::WriteError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			const `[inherited]`

Definition at line 163 of file ErrorHandler.cpp.

00166 {
00167     //Do we have a log?
00168     if (!GetLog())
00169         return;
00170 
00171     //Format the msg
00172     std::string sError;
00173     sError=FormatData(rClass,
00174                       rMethod,
00175                       rError);
00176 
00177     //Write it
00178     GetLog()->WriteError(sError);
00179 }

void CErrorHandler::WriteMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[inherited]`

Definition at line 199 of file ErrorHandler.cpp.

00202 {
00203     //Do we have a log?
00204     if (!GetLog())
00205         return;
00206 
00207     //Format the msg
00208     std::string sMsg;
00209     sMsg=FormatData(rClass,
00210                     rMethod,
00211                     rMessage,
00212                     true);
00213 
00214     //Write it
00215     GetLog()->WriteMessage(sMsg);
00216 }

void CErrorHandler::WriteStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			`[static, inherited]`

Definition at line 181 of file ErrorHandler.cpp.

00184 {
00185     //Do we have a log?
00186     if (!m_pLog)
00187         return;
00188 
00189     //Format the msg
00190     std::string sError;
00191     sError=FormatData(rClass,
00192                       rMethod,
00193                       rError);
00194 
00195     //Write it
00196     m_pLog->WriteError(sError);
00197 }

Friends And Related Function Documentation

friend class CIPCrafter [friend, inherited]

Definition at line 59 of file Socket.h.

Member Data Documentation

CGenericCriticalSection * CSocketBase::m_pCSection = NULL [static, protected, inherited]

Definition at line 122 of file SocketBase.h.

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

Retail products

Documentation

CUDPSocketAsync Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Static Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation