void CSocket::Create()
{
m_nSocket = ::socket(AF_INET,
SOCK_STREAM,
0);
if ( !isValid() )
{
std::cout << "errno == " << errno << " in CSocket::Receive\n";
throw CSocketException( "Could not create socket in CSocket::Create()." );
}
int on = 1;
int nResult = ::setsockopt( m_nSocket,
SOL_SOCKET,
SO_REUSEADDR,
(void*)&on,
sizeof(on));
if ( nResult == -1 )
{
throw CSocketException( "Could not 'setsockopt' SO_REUSEADDR in CSocket::Create()." );
}
/*
int off = 0;
nResult = ::setsockopt( m_nSocket,
IPPROTO_TCP,
TCP_NODELAY,
(void*) &off,
sizeof(on) );
if ( nResult == -1 )
{
throw CSocketException( "Could not 'setsockopt' TCP_NODELAY in CSocket::Create()." );
}
*/
} // void CSocket::Create()
CSocket::CSocket( const CSocket& src )
{
if ( !src.isValid() )
{
throw CSocketException( "Source Socket is invalid, so new socket can't be better" );
}
socklen_t addr_length = m_otAddr.SizeGet();
m_nSocket = ::accept( src.m_nSocket,
src.m_otAddr,
&addr_length );
if ( m_nSocket <= 0 )
{
throw CSocketException( "Could not 'accept', new socket is invalid" );
}
timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 1000; // looks like this value is ignored
int nResult = ::setsockopt( m_nSocket,
SOL_SOCKET,
SO_RCVTIMEO,
(const char*)&timeout,
sizeof(timeout) );
if ( nResult == -1 )
{
throw CSocketException( "Could not set SO_RCVTIMEO, new socket is invalid" );
} // if ( result == -1 )
} // CSocket::CSocket( const CSocket& src )
/**
* Initialisation common to all constructors
*/
void CSocket::Reset( unsigned int iPort)
{
// Initialize winsock
if( WSAStartup( MAKEWORD(2,0), &m_WSAData) != 0)
throw CSocketException( "WSAStartup() failed");
// Actually create the socket
m_Socket = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP);
if( m_Socket == INVALID_SOCKET)
throw CSocketException( "socket() failed");
// *** ADDED SO THAT WE CAN COMMUNICATE WITH LINUX - Ed ***
int val=1;
int n=setsockopt(m_Socket, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
if(n==SOCKET_ERROR)
{
val = WSAGetLastError();
printf("socket error: %i\n",val);
}
// sockaddr initialisation
memset( &m_sockaddr, 0, sizeof( sockaddr));
m_sockaddr.sin_family = AF_INET;
m_sockaddr.sin_port = htons( iPort);
m_sockaddr.sin_addr.s_addr = INADDR_ANY;
}
size_t CSocket::Send(const void* pBuffer, size_t nBufSize)
{
ASSERT(pBuffer != nullptr);
// Ignore, if nothing to send.
if (nBufSize == 0)
return 0;
// Socket closed?
if (m_hSocket == INVALID_SOCKET)
throw CSocketException(CSocketException::E_SEND_FAILED, WSAENOTCONN);
int nResult = 0;
// Blocking socket?
if (m_eMode == BLOCK)
{
// Send the entire buffer.
nResult = send(m_hSocket, static_cast<const char*>(pBuffer), static_cast<int>(nBufSize), 0);
if (nResult == SOCKET_ERROR)
throw CSocketException(CSocketException::E_SEND_FAILED, CWinSock::LastError());
ASSERT(static_cast<size_t>(nResult) == nBufSize);
}
// Async socket.
else // (eMode == ASYNC)
{
// Allocate send buffer, on first call.
if (m_pSendBuffer.get() == nullptr)
m_pSendBuffer = NetBufferPtr(new CNetBuffer());
// Append new data to existing send data.
if (m_pSendBuffer->Append(pBuffer, nBufSize) > 0)
{
// Try and send the entire buffer.
nResult = send(m_hSocket, static_cast<const char*>(m_pSendBuffer->Ptr()), static_cast<int>(m_pSendBuffer->Size()), 0);
if (nResult != SOCKET_ERROR)
{
// Remove amount sent.
m_pSendBuffer->Discard(nResult);
}
else // (nResult == SOCKET_ERROR)
{
int nLastErr = CWinSock::LastError();
// Only an error, if not because of lack of buffer space.
if (nLastErr != WSAEWOULDBLOCK)
throw CSocketException(CSocketException::E_SEND_FAILED, nLastErr);
}
}
}
return nResult;
}
/**
* @param iPort local listenning port
* @throws CSocketException is server socket could not be created
*/
CSocket::CSocket( int iPort)
{
Reset( iPort);
//printf("constructor\n");
if( bind( m_Socket, ( SOCKADDR *)&m_sockaddr, sizeof( sockaddr)) != 0)
throw CSocketException( "bind() failed");
if( listen( m_Socket, 0) != 0)
throw CSocketException( "accept() failed");
}
void CSocket::Listen() const
{
if ( !isValid() )
{
throw CSocketException( "Socket is invalid in CSocket::Listen()." );
}
int result = ::listen( m_nSocket,
CLIENT_BACKLOG );
if ( result == -1 )
{
throw CSocketException( "Could not listen to socket in CSocket::Listen()." );
}
} // void CSocket::Listen() const
void CSocket::SetReadBufferSize( unsigned int nSize ) throw(CSocketException)
{
if (setsockopt(m_sockDesc, SOL_SOCKET, SO_RCVBUF, &nSize, sizeof(nSize)) == -1)
{
throw CSocketException("Error in setting socket buffer size ", true);
}
}
size_t CSocket::Peek(void* pBuffer, size_t nBufSize)
{
ASSERT(m_hSocket != INVALID_SOCKET);
ASSERT(pBuffer != nullptr);
int nResult = 0;
// Blocking socket?
if (m_eMode == BLOCK)
{
nResult = recv(m_hSocket, static_cast<char*>(pBuffer), static_cast<int>(nBufSize), MSG_PEEK);
if (nResult == SOCKET_ERROR)
throw CSocketException(CSocketException::E_PEEK_FAILED, CWinSock::LastError());
}
// Async socket.
else // (eMode == ASYNC)
{
if (m_pRecvBuffer.get() != nullptr)
{
nBufSize = std::min(nBufSize, m_pRecvBuffer->Size());
if (nBufSize != 0)
memcpy(pBuffer, m_pRecvBuffer->Ptr(), nBufSize);
nResult = static_cast<int>(nBufSize);
}
}
return nResult;
}
CSocket::CSocket( SocketType type, NetworkLayerProtocol protocol ) throw(CSocketException):m_sockDesc(-1)
{
m_sockDesc = socket(protocol, type, 0);
if (m_sockDesc < 0)
{
throw CSocketException("Socket creation failed (socket())", true);
}
}
unsigned short CSocket::GetLocalPort() throw(CSocketException)
{
sockaddr_in addr;
unsigned int addr_len = sizeof(addr);
if (getsockname(m_sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
throw CSocketException("Fetch of local port failed (getsockname())", true);
}
return ntohs(addr.sin_port);
}
std::string CSocket::GetLocalAddress() throw(CSocketException)
{
sockaddr_in addr;
unsigned int addr_len = sizeof(addr);
if (getsockname(m_sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
throw CSocketException("Fetch of local address failed (getsockname())", true);
}
return inet_ntoa(addr.sin_addr);
}
int CSocket::Recv( void *buffer, int bufferLen ) throw(CSocketException)
{
int nBytes;
if ((nBytes = ::recv(m_sockDesc, (void *) buffer, bufferLen, 0)) < 0) {
throw CSocketException("Received failed (recv())", true);
}
char* sData = static_cast<char *>(buffer);
sData[nBytes] = '\0';
return nBytes;
}
void CSocket::Bind ( const int nPort )
{
if ( !isValid() )
{
throw CSocketException( "Socket is invalid in CSocket::Bind()." );
}
m_otAddr.sin_family = AF_INET;
m_otAddr.sin_addr.s_addr = INADDR_ANY; // inet_addr("127.0.0.1"); // INADDR_ANY;
m_otAddr.sin_port = htons ( nPort );
int result = ::bind( m_nSocket,
m_otAddr,
m_otAddr.SizeGet() );
if ( result == -1 )
{
throw CSocketException( "Could not bind to port in CSocket::Bind." );
}
} // void CSocket::Bind ( const int nPort )
void CSocket::Create(int nAF, int nType, int nProtocol)
{
ASSERT(m_hSocket == INVALID_SOCKET);
// Allocate the socket.
m_hSocket = socket(nAF, nType, nProtocol);
if (m_hSocket == INVALID_SOCKET)
throw CSocketException(CSocketException::E_CREATE_FAILED, CWinSock::LastError());
}
void CSocket::Close( )
{
if ( !isValid() ) return;
if ( ::close( m_nSocket ) == -1 )
{
throw CSocketException( "Could not 'close' in CSocket::Close()." );
}
m_nSocket = INVALID_SOCKET;
} // void CSocket::Close( )
void CSocket::BindLocalAddressAndPort( const string &localAddress, unsigned short localPort /*= 0*/ )
throw(CSocketException)
{
// Get the address of the requested host
sockaddr_in localAddr;
FillAddr(localAddress, localPort, localAddr);
if (bind(m_sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
throw CSocketException("Set of local address and port failed (bind())", true);
}
}
size_t CSocket::Available()
{
ASSERT(m_hSocket != INVALID_SOCKET);
u_long lAvailable = 0;
// Blocking socket?
if (m_eMode == BLOCK)
{
fd_set aoSockets;
TIMEVAL oWaitTime = { 0 };
FD_ZERO(&aoSockets);
FD_SET(m_hSocket, &aoSockets);
// Check for readability on the socket.
if (select(1, &aoSockets, nullptr, nullptr, &oWaitTime) == SOCKET_ERROR)
throw CSocketException(CSocketException::E_SELECT_FAILED, CWinSock::LastError());
// Anything to read?
if (FD_ISSET(m_hSocket, &aoSockets))
{
// How much data is available?
int nResult = ::ioctlsocket(m_hSocket, FIONREAD, &lAvailable);
if (nResult == SOCKET_ERROR)
throw CSocketException(CSocketException::E_PEEK_FAILED, CWinSock::LastError());
if (lAvailable == 0)
throw CSocketException(CSocketException::E_DISCONNECTED, WSAESHUTDOWN);
}
}
// Async socket.
else // (eMode == ASYNC)
{
if (m_pRecvBuffer.get() != nullptr)
lAvailable = static_cast<u_long>(m_pRecvBuffer->Size());
}
return lAvailable;
}
/**
* @param szRemoteAddr Remote Machine Address
* @param iRemotePort Server Listenning Port
* @throws CSocketException if client socket could not be created
*/
CSocket::CSocket( char *szRemoteAddr, int iPort)
{
if( !szRemoteAddr)
throw CSocketException( "Invalid parameters");
Reset( iPort);
// first guess => try to resolve it as IP@
m_sockaddr.sin_addr.s_addr = inet_addr( szRemoteAddr);
if( m_sockaddr.sin_addr.s_addr == INADDR_NONE)
{ // screwed => try to resolve it as name
LPHOSTENT lpHost = gethostbyname( szRemoteAddr);
if( !lpHost)
throw CSocketException( "Unable to solve this address");
m_sockaddr.sin_addr.s_addr = **(int**)(lpHost->h_addr_list);
}
// actually performs connection
if( connect( m_Socket, ( SOCKADDR*)&m_sockaddr, sizeof( sockaddr)) != 0)
throw CSocketException( "connect() failed");
}
void CSocket::Connect(const tchar* pszHost, uint nPort)
{
ASSERT(m_hSocket == INVALID_SOCKET);
ASSERT(pszHost != nullptr);
ASSERT(nPort <= USHRT_MAX);
// Save parameters.
m_strHost = pszHost;
m_nPort = nPort;
sockaddr_in addr = { 0 };
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(T2A(pszHost));
addr.sin_port = htons(static_cast<ushort>(nPort));
// Host name isn't an IP Address?
if (addr.sin_addr.s_addr == INADDR_NONE)
{
// Resolve host name.
hostent* pHost = gethostbyname(T2A(pszHost));
if (pHost == nullptr)
throw CSocketException(CSocketException::E_RESOLVE_FAILED, CWinSock::LastError());
memcpy(&addr.sin_addr, pHost->h_addr_list[0], pHost->h_length);
}
// Create the socket.
Create(AF_INET, Type(), Protocol());
// Connect to host.
if (connect(m_hSocket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR)
throw CSocketException(CSocketException::E_CONNECT_FAILED, CWinSock::LastError());
// If async mode, do select.
if (m_eMode == ASYNC)
CWinSock::BeginAsyncSelect(this, (FD_READ | FD_WRITE | FD_CLOSE));
}
void CSocket::BindLocalPort( unsigned short localPort ) throw(CSocketException)
{
// Bind the socket to its port
sockaddr_in localAddr;
memset(&localAddr, 0, sizeof(localAddr));
localAddr.sin_family = AF_INET;
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
localAddr.sin_port = htons(localPort);
if (bind(m_sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
throw CSocketException("Set of local port failed (bind())", true);
}
}
size_t CSocket::Recv(void* pBuffer, size_t nBufSize)
{
ASSERT(pBuffer != nullptr);
// Socket closed?
if (m_hSocket == INVALID_SOCKET)
throw CSocketException(CSocketException::E_RECV_FAILED, WSAENOTCONN);
int nResult = 0;
// Blocking socket?
if (m_eMode == BLOCK)
{
nResult = recv(m_hSocket, static_cast<char*>(pBuffer), static_cast<int>(nBufSize), 0);
if (nResult == SOCKET_ERROR)
throw CSocketException(CSocketException::E_RECV_FAILED, CWinSock::LastError());
}
// Async socket.
else // (eMode == ASYNC)
{
if (m_pRecvBuffer.get() != nullptr)
{
nBufSize = std::min(nBufSize, m_pRecvBuffer->Size());
if (nBufSize != 0)
{
memcpy(pBuffer, m_pRecvBuffer->Ptr(), nBufSize);
m_pRecvBuffer->Discard(nBufSize);
}
nResult = static_cast<int>(nBufSize);
}
}
return nResult;
}
void CSocket::ConnectToHost( const string &foreignAddress, unsigned short foreignPort ) throw(CSocketException)
{
//cout<<"\nstart Connect to host";
// Get the address of the requested host
sockaddr_in destAddr;
//cout<<"\ninside Connect to host";
FillAddr(foreignAddress, foreignPort, destAddr);
//cout<<"trying to connect to host";
// Try to connect to the given port
if (::connect(m_sockDesc, (sockaddr *) &destAddr, sizeof(destAddr)) < 0) {
throw CSocketException("Connect failed (connect())", true);
}
//cout<<"\n after connecting";
}
void CSocket::FillAddr( const string & localAddress, unsigned short localPort, sockaddr_in& localAddr )
{
////cout<<"\n Inside Fille addr:"<<localAddress <<" port:"<<localPort;
memset(&localAddr, 0, sizeof(localAddr)); // Zero out address structure
localAddr.sin_family = AF_INET; // Internet address
hostent *host; // Resolve name
if ((host = gethostbyname(localAddress.c_str())) == NULL) {
// strerror() will not work for gethostbyname() and hstrerror()
// is supposedly obsolete
throw CSocketException("Failed to resolve name (gethostbyname())");
}
localAddr.sin_addr.s_addr = *((unsigned long *) host->h_addr_list[0]);
localAddr.sin_port = htons(localPort); // Assign port in network byte order
////cout<<"\n returning from Fille addr";
}
CString CSocket::ResolveStr(const tchar* pszHost)
{
// Is already an IP address?
if (IsAddress(pszHost))
return pszHost;
in_addr addr;
// Resolve host name.
hostent* pHost = gethostbyname(T2A(pszHost));
if (pHost == nullptr)
throw CSocketException(CSocketException::E_RESOLVE_FAILED, CWinSock::LastError());
memcpy(&addr, pHost->h_addr_list[0], pHost->h_length);
return A2T(inet_ntoa(addr));
}
in_addr CSocket::Resolve(const tchar* pszHost)
{
in_addr addr;
// Is already an IP address?
addr.s_addr = inet_addr(T2A(pszHost));
if (addr.s_addr == INADDR_NONE)
{
// Resolve host name.
hostent* pHost = gethostbyname(T2A(pszHost));
if (pHost == nullptr)
throw CSocketException(CSocketException::E_RESOLVE_FAILED, CWinSock::LastError());
memcpy(&addr, pHost->h_addr_list[0], pHost->h_length);
}
return addr;
}
void CSocket::Send( const void *buffer, int bufferLen ) throw(CSocketException)
{
if (::send(m_sockDesc, (void *) buffer, bufferLen, 0) < 0) {
throw CSocketException("Send failed (send())", true);
}
}
