CASocket Class Reference

#include <CASocket.hpp>

Inheritance diagram for CASocket:

Collaboration diagram for CASocket:

Public Member Functions
	CASocket (bool bIsReserved=false)
	~CASocket ()
virtual SINT32	create ()
virtual SINT32	create (bool a_bShowTypicalError)
virtual SINT32	create (SINT32 type)
virtual SINT32	listen (const CASocketAddr &psa)
	Starts listening on address psa. More...
virtual SINT32	listen (UINT16 port)
virtual SINT32	accept (CASocket &s)
	Accepts a new connection. More...
virtual SINT32	connect (const CASocketAddr &psa)
virtual SINT32	connect (const CASocketAddr &psa, UINT32 retry, UINT32 sWaitTime)
	Tries to connect to the peer described by psa. More...
virtual SINT32	connect (const CASocketAddr &psa, UINT32 msTimeOut)
	Tries to connect to peer psa. More...
virtual SINT32	close ()
virtual SINT32	send (const UINT8 *buff, UINT32 len)
	Sends some data over the network. More...
virtual SINT32	sendFully (const UINT8 *buff, UINT32 len)
	Sends all data over the network. More...
virtual SINT32	sendFullyTimeOut (const UINT8 *buff, UINT32 len, UINT32 msTimeOut, UINT32 msTimeOutSingleSend)
	Sends all data over the network. More...
virtual SINT32	sendTimeOut (const UINT8 *buff, UINT32 len, UINT32 msTimeOut)
	Sends some data over the network. More...
virtual SINT32	receive (UINT8 *buff, UINT32 len)
	Will receive some bytes from the socket. More...
virtual SINT32	receiveFullyT (UINT8 *buff, UINT32 len, UINT32 msTimeOut)
	Trys to receive all bytes. More...
virtual SINT32	receiveLine (UINT8 *line, UINT32 maxLen, UINT32 msTimeOut)
virtual SINT32	peek (UINT8 *buff, UINT32 len)
	Will peek some bytes from the socket read queue. More...
SOCKET	getSocket ()
	Returns the number of the Socket used. More...
virtual SINT32	getLocalIP (UINT8 r_Ip[4])
	LERNGRUPPE Returns the source address of the socket. More...
virtual SINT32	getLocalPort ()
virtual SINT32	getPeerIP (UINT8 ip[4])
virtual SINT32	getPeerPort ()
virtual SINT32	setReuseAddr (bool b)
virtual SINT32	setSendTimeOut (UINT32 msTimeOut)
virtual SINT32	getSendTimeOut ()
virtual SINT32	setRecvBuff (UINT32 r)
virtual SINT32	getRecvBuff ()
virtual SINT32	setSendBuff (SINT32 r)
	Returns < 0 on error, otherwise the new sendbuffersize (which may be less than r) More...
virtual SINT32	getSendBuff ()
virtual SINT32	setKeepAlive (bool b)
	Enables/disables the socket keep-alive option. More...
virtual SINT32	setKeepAlive (UINT32 sec)
	Enables the socket keep-alive option with a given ping time (in seconds). More...
virtual SINT32	setNonBlocking (bool b)
virtual SINT32	getNonBlocking (bool *b)
virtual bool	isClosed ()
Public Member Functions inherited from CAClientSocket
virtual	~CAClientSocket ()
SINT32	receiveFully (UINT8 *buff, UINT32 len)
	Receives all len bytes. More...

Static Public Member Functions
static SINT32	init ()
static SINT32	cleanup ()
static SINT32	setMaxNormalSockets (UINT32 u)
	Sets the max number of allowed "normal" sockets. More...
static SINT32	getMaxOpenSockets ()
	Tries to find out how many socket we can open by open as many socket as possible witthout errors. More...
static UINT32	countOpenSockets ()

Protected Attributes
volatile bool	m_bSocketIsClosed
	check More...
SOCKET	m_Socket
CASingleSocketGroup *	m_pSingleSocketGroupRead

Private Member Functions
virtual SINT32	setSocket (SOCKET s)
virtual SINT32	create (SINT32 type, bool a_bShowTypicalError)

Private Attributes
bool	m_bIsReservedSocket

Static Private Attributes
static CAMutex *	m_pcsClose =NULL
static volatile UINT32	m_u32NormalSocketsOpen =0
	The following two variables are use to realise "reserved" sockets. More...
static UINT32	m_u32MaxNormalSockets =0xFFFFFFFF

Detailed Description

Definition at line 37 of file CASocket.hpp.

Constructor & Destructor Documentation

CASocket()

CASocket::CASocket

(

bool

bIsReserved = false

)

Definition at line 49 of file CASocket.cpp.

  {
    m_Socket=0;
    m_bSocketIsClosed=true;
    m_bIsReservedSocket=bIsReservedSocket;
    m_pSingleSocketGroupRead = NULL;
  }

References m_bIsReservedSocket, m_bSocketIsClosed, m_pSingleSocketGroupRead, and m_Socket.

~CASocket()

CASocket::~CASocket ( )

inline

Definition at line 41 of file CASocket.hpp.

{close();}

References close().

Here is the call graph for this function:

Member Function Documentation

accept()

SINT32 CASocket::accept ( CASocket &  s )

virtual

Accepts a new connection.

The new socket is returned in s.

Return values

E_SUCCESS	if successful
E_SOCKETCLOSED	if the listening socket was closed
E_SOCKET_LIMIT	if the could not create a new socket for the new connection
E_UNKNOWN	otherwise

Definition at line 192 of file CASocket.cpp.

  {
    if(m_bSocketIsClosed) //the accept socket should not be closed!!
      return E_SOCKETCLOSED;
    if(!s.m_bSocketIsClosed) //but the new socket should be closed!!!
      return E_UNKNOWN;
    if(m_u32NormalSocketsOpen>=m_u32MaxNormalSockets)
      {
        CAMsg::printMsg(LOG_CRIT,"CASocket::accept() -- Could not create a new normal Socket -- allowed number of normal sockets exeded!\n");
        return E_SOCKET_LIMIT;
      }
    SOCKET sock=::accept(m_Socket,NULL,NULL);
    if (sock == SOCKET_ERROR)
      {
        s.setSocket(0);
        if(GET_NET_ERROR==ERR_INTERN_SOCKET_CLOSED)
          return E_SOCKETCLOSED;
        return E_UNKNOWN;
      }
    s.setSocket(sock);
    m_pcsClose->lock();
    m_u32NormalSocketsOpen++;
    s.m_bSocketIsClosed=false;
    m_pcsClose->unlock();
    //CAMsg::printMsg(LOG_DEBUG,"Opened socket: %d\n", s.m_Socket);
 
    return E_SUCCESS;
  }

References E_SOCKET_LIMIT, E_SOCKETCLOSED, E_SUCCESS, E_UNKNOWN, ERR_INTERN_SOCKET_CLOSED, GET_NET_ERROR, CAMutex::lock(), m_bSocketIsClosed, m_pcsClose, m_Socket, m_u32MaxNormalSockets, m_u32NormalSocketsOpen, CAMsg::printMsg(), setSocket(), SOCKET, SOCKET_ERROR, and CAMutex::unlock().

Referenced by CAMuxSocket::accept(), and CALocalProxy::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup()

static SINT32 CASocket::cleanup ( )

inlinestatic

Definition at line 49 of file CASocket.hpp.

        {
          delete m_pcsClose;
          m_pcsClose=NULL;
          return E_SUCCESS;
        }

References E_SUCCESS, and m_pcsClose.

Referenced by CALibProxytest::cleanup().

Here is the caller graph for this function:

close()

SINT32 CASocket::close ( )

virtual

Reimplemented in CATLSClientSocket.

Definition at line 351 of file CASocket.cpp.

  {
    SINT32 ret;
 
    if(m_bSocketIsClosed)
    {
      return E_SUCCESS;
    }
 
    ret = m_pcsClose->lock();
    if (ret != E_SUCCESS)
    {
      CAMsg::printMsg(LOG_CRIT,
        "Could not get lock for closing socket! Error code: %d\n", ret);
      return ret;
    }
 
    if (!m_bSocketIsClosed)
    {
      shutdown(m_Socket,SHUT_RDWR); //call shutdown here because some OSes seems to ned it to
      //wakeup other threads which block in read() or write()
      ret=::closesocket(m_Socket);
      if(!m_bIsReservedSocket)
      {
        m_u32NormalSocketsOpen--;
      }
      //CAMsg::printMsg(LOG_DEBUG,"Open Sockets: %d\n", m_u32NormalSocketsOpen);
      //CAMsg::printMsg(LOG_DEBUG,"Closed socket: %d\n", m_Socket);
      setSocket(0);
      m_bSocketIsClosed=true;
    }
 
    if (ret != E_SUCCESS)
    {
      ret = GET_NET_ERROR;
    }
 
    m_pcsClose->unlock();
    return ret;
  }

References closesocket, E_SUCCESS, GET_NET_ERROR, CAMutex::lock(), m_bIsReservedSocket, m_bSocketIsClosed, m_pcsClose, m_Socket, m_u32NormalSocketsOpen, CAMsg::printMsg(), setSocket(), and CAMutex::unlock().

Referenced by CAMuxSocket::accept(), CAFirstMix::clean(), CALastMix::clean(), CALocalProxy::clean(), CAMuxSocket::close(), CATLSClientSocket::close(), CAChain::closeChainInternal(), connect(), CATLSClientSocket::connect(), getMaxOpenSockets(), CAInfoService::getPaymentInstance(), listen(), CALocalProxy::loop(), CALastMixA::loop(), CALastMixB::loop(), CAInfoService::sendCascadeHelo(), CAInfoService::sendMixHelo(), CAInfoService::sendStatus(), CACmdLnOptions::setListenerInterfaces(), CACmdLnOptions::setTargetInterfaces(), CAChain::~CAChain(), and ~CASocket().

Here is the call graph for this function:

Here is the caller graph for this function:

connect() [1/3]

virtual SINT32 CASocket::connect ( const CASocketAddr &  psa )

inlinevirtual

Definition at line 64 of file CASocket.hpp.

      {
        return connect(psa,1,0);
      }

Referenced by CAMuxSocket::connect(), CATLSClientSocket::connect(), connect(), CAInfoService::getPaymentInstance(), CALastMixA::loop(), CALastMixB::loop(), CAInfoService::sendCascadeHelo(), CAInfoService::sendMixHelo(), CAInfoService::sendStatus(), and CACmdLnOptions::setTargetInterfaces().

Here is the caller graph for this function:

connect() [2/3]

SINT32 CASocket::connect ( const CASocketAddr &  psa, UINT32  msTimeOut  )

virtual

Tries to connect to peer psa.

Parameters

psa	- peer
msTimeOut	- abort after msTimeOut milli seconds

Reimplemented in CATLSClientSocket.

Definition at line 270 of file CASocket.cpp.

  {
    if(m_bSocketIsClosed&&create(psa.getType())!=E_SUCCESS)
      {
        return E_UNKNOWN;
      }
#ifdef _DEBUG
    sockets++;
#endif
    bool bWasNonBlocking=false;
    getNonBlocking(&bWasNonBlocking);
    setNonBlocking(true);
    int err=0;
    const LPSOCKADDR addr=(const LPSOCKADDR)psa.LPSOCKADDR();
    int addr_len=psa.getSize();
 
    err=::connect(m_Socket,addr,addr_len);
    if(err==0)
      return E_SUCCESS;
    err=GET_NET_ERROR;
#ifdef _WIN32
    if(err!=WSAEWOULDBLOCK)
      return E_SOCKET_CONNECT;
#else
    if(err!=EINPROGRESS)
    {
      return E_SOCKET_CONNECT;
    }
#endif
 
#ifndef HAVE_POLL
    struct timeval tval;
    tval.tv_sec=msTimeOut/1000;
    tval.tv_usec=(msTimeOut%1000)*1000;
    fd_set readSet,writeSet;
    FD_ZERO(&readSet);
    FD_ZERO(&writeSet);
    #pragma warning( push )
    #pragma warning( disable : 4127 ) //Disable: Bedingter Ausdruck ist konstant
    FD_SET(m_Socket,&readSet);
    FD_SET(m_Socket,&writeSet);
    #pragma warning( pop )
    err=::select(m_Socket+1,&readSet,&writeSet,NULL,&tval);
#else
    struct pollfd opollfd;
    opollfd.fd=m_Socket;
    opollfd.events=POLLIN|POLLOUT;
    err=::poll(&opollfd,1,msTimeOut);
#endif
    if (err<1) //timeout or error Note: we do not check for !=1 here because for some strange reasons FreeBSD 8.0-rc2 returns: 2 - Why?
    {
      err = GET_NET_ERROR;
      close();
      SET_NET_ERROR(err);
      
      if (GET_NET_ERROR == EINPROGRESS)
      {
        return E_UNKNOWN;
      }
      
      return E_SOCKET_CONNECT;
    }
    socklen_t len=sizeof(err);
    err=0;
    if (::getsockopt(m_Socket,SOL_SOCKET,SO_ERROR,(char*)&err,&len)<0||err!=0) //error by connect
    {
      err = GET_NET_ERROR;
      close();
      SET_NET_ERROR(err);
      
      if (GET_NET_ERROR == EINPROGRESS)
      {
        return E_UNKNOWN;
      }
      
      return E_SOCKET_CONNECT;
    }
    setNonBlocking(bWasNonBlocking);
    return E_SUCCESS;
  }

References close(), connect(), create(), E_SOCKET_CONNECT, E_SUCCESS, E_UNKNOWN, GET_NET_ERROR, getNonBlocking(), CASocketAddr::getSize(), CASocketAddr::getType(), len, CASocketAddr::LPSOCKADDR(), m_bSocketIsClosed, m_Socket, SET_NET_ERROR, and setNonBlocking().

Here is the call graph for this function:

connect() [3/3]

SINT32 CASocket::connect ( const CASocketAddr &  psa, UINT32  retry, UINT32  time  )

virtual

Tries to connect to the peer described by psa.

Parameters

psa	- peer
retry	- number of retries
time	- time between retries in seconds

Definition at line 227 of file CASocket.cpp.

  {
//    CAMsg::printMsg(LOG_DEBUG,"Socket:connect\n");
    if(m_bSocketIsClosed&&create()!=E_SUCCESS)
      {
        return E_UNKNOWN;
      }
#ifdef _DEBUG
    sockets++;
#endif
    int err=0;
    const SOCKADDR* addr=psa.LPSOCKADDR();
    int addr_len=psa.getSize();
    for(UINT32 i=0;i<retry;i++)
      {
//        CAMsg::printMsg(LOG_DEBUG,"Socket:connect-connect\n");
        err=::connect(m_Socket,addr,addr_len);
//        CAMsg::printMsg(LOG_DEBUG,"Socket:connect-connect-finished err: %i\n",err);
        if(err!=0)
          {
            err=GET_NET_ERROR;
            #ifdef _DEBUG
             CAMsg::printMsg(LOG_DEBUG,"Con-Error: %i\n",err);
            #endif
            if(err!=ERR_INTERN_TIMEDOUT&&err!=ERR_INTERN_CONNREFUSED)
              return E_UNKNOWN; //Should be better.....
            #ifdef _DEBUG
              CAMsg::printMsg(LOG_DEBUG,"Cannot connect... retrying\n");
            #endif
            sSleep((UINT16)time);
          }
        else
            return E_SUCCESS;
      }
    return err;
  }

References connect(), create(), E_SUCCESS, E_UNKNOWN, ERR_INTERN_CONNREFUSED, ERR_INTERN_TIMEDOUT, GET_NET_ERROR, CASocketAddr::getSize(), CASocketAddr::LPSOCKADDR(), m_bSocketIsClosed, m_Socket, CAMsg::printMsg(), and sSleep().

Here is the call graph for this function:

countOpenSockets()

static UINT32 CASocket::countOpenSockets ( )

inlinestatic

Definition at line 128 of file CASocket.hpp.

      {
        return m_u32NormalSocketsOpen;
      }

References m_u32NormalSocketsOpen.

create() [1/4]

SINT32 CASocket::create ( )

virtual

Definition at line 73 of file CASocket.cpp.

  {
    return create(AF_INET, true);
  }

Referenced by CAMuxSocket::accept(), connect(), create(), CACmdLnOptions::createSockets(), getMaxOpenSockets(), CAFirstMix::init(), CALocalProxy::init(), CAMiddleMix::init(), listen(), CALastMixA::loop(), CALastMixB::loop(), CACmdLnOptions::parse(), and CAFirstMixChannelList::test().

Here is the caller graph for this function:

create() [2/4]

SINT32 CASocket::create ( bool  a_bShowTypicalError )

virtual

Definition at line 83 of file CASocket.cpp.

{
  return create(AF_INET, a_bShowTypicalError);
}

References create().

Here is the call graph for this function:

create() [3/4]

SINT32 CASocket::create ( SINT32  type )

virtual

Definition at line 78 of file CASocket.cpp.

{
  return create(type, true);
}

References create(), and type.

Here is the call graph for this function:

create() [4/4]

SINT32 CASocket::create ( SINT32  type, bool  a_bShowTypicalError  )

privatevirtual

Todo:

Not thread safe!

Definition at line 89 of file CASocket.cpp.

  {
    SOCKET s = INVALID_SOCKET;
    if(m_bSocketIsClosed)
    {
      if(m_bIsReservedSocket||m_u32NormalSocketsOpen<m_u32MaxNormalSockets)
      {
        s=::socket(type,SOCK_STREAM,0);
        //CAMsg::printMsg(LOG_DEBUG,"Opened socket: %d\n", m_Socket);
      }
      else
      {
        CAMsg::printMsg(LOG_CRIT,"Could not create a new normal Socket -- allowed number of normal sockets exceeded!\n");
        return E_SOCKET_LIMIT;
      }
    }
    else
      return E_UNKNOWN;
    if(s==INVALID_SOCKET)
      {
        setSocket(0);
        int er=GET_NET_ERROR;
        if (a_bShowTypicalError)
        {
          if(er==EMFILE)
          {
            CAMsg::printMsg(LOG_CRIT,"Could not create a new Socket!\n");
          }
          else
          {
            CAMsg::printMsg(LOG_CRIT,"Could not create a new Socket! - Error: %s (%i)\n",
              GET_NET_ERROR_STR(er), er);
          }
        }
        return E_SOCKET_CREATE;
      }
    m_bSocketIsClosed=false;
    m_pcsClose->lock();
    if(!m_bIsReservedSocket)
    {
      m_u32NormalSocketsOpen++;
    }
    m_pcsClose->unlock();
    setSocket(s);
    return E_SUCCESS;
  }

References E_SOCKET_CREATE, E_SOCKET_LIMIT, E_SUCCESS, E_UNKNOWN, GET_NET_ERROR, GET_NET_ERROR_STR, INVALID_SOCKET, CAMutex::lock(), m_bIsReservedSocket, m_bSocketIsClosed, m_pcsClose, m_u32MaxNormalSockets, m_u32NormalSocketsOpen, CAMsg::printMsg(), setSocket(), SOCKET, type, and CAMutex::unlock().

Here is the call graph for this function:

getLocalIP()

SINT32 CASocket::getLocalIP ( UINT8  r_Ip[4] )

virtual

LERNGRUPPE Returns the source address of the socket.

Returns

r_Ip the source IP address

Return values

E_SUCCESS	upon success
SOCKET_ERROR	otherwise

Todo:

: Question: Correct for Unix domain sockets?

Definition at line 801 of file CASocket.cpp.

{
      struct sockaddr_in addr;
      socklen_t namelen=sizeof(struct sockaddr_in);
      if(getsockname(m_Socket,(struct sockaddr*)&addr,&namelen)==SOCKET_ERROR)
         return SOCKET_ERROR;
      memcpy(r_Ip,&addr.sin_addr,4);
      return E_SUCCESS;
}

References E_SUCCESS, m_Socket, and SOCKET_ERROR.

Referenced by CALastMixA::loop().

Here is the caller graph for this function:

getLocalPort()

SINT32 CASocket::getLocalPort ( )

virtual

Definition at line 811 of file CASocket.cpp.

  {
    struct sockaddr_in addr;
    socklen_t namelen=sizeof(struct sockaddr_in);
    if(getsockname(m_Socket,(struct sockaddr*)&addr,&namelen)==SOCKET_ERROR)
      return SOCKET_ERROR;
    return ntohs(addr.sin_port);
  }

References m_Socket, and SOCKET_ERROR.

Referenced by CALocalProxy::loop(), and CALastMixA::loop().

Here is the caller graph for this function:

getMaxOpenSockets()

SINT32 CASocket::getMaxOpenSockets ( )

static

Tries to find out how many socket we can open by open as many socket as possible witthout errors.

If we can open more than 10.000 sockets we stop the test and return 10000.

Return values

max	numbers of sockets we can have open at the same time
E_UNKNOWN	in case of some unexpected error

Definition at line 983 of file CASocket.cpp.

{
  CASocket* parSocket=new CASocket[10001];
  UINT32 maxSocket=0;
  for(UINT32 t=0;t<10001;t++)
    {
    if(parSocket[t].create(false)!=E_SUCCESS)
      {
      maxSocket=t;
      break;
      }
    }
  for(UINT32 t=0;t<maxSocket;t++)
    {
    parSocket[t].close();
    }
  delete []parSocket;
  parSocket = NULL;
  return maxSocket;
}

References close(), create(), and E_SUCCESS.

Here is the call graph for this function:

getNonBlocking()

SINT32 CASocket::getNonBlocking ( bool *  b )

virtual

Definition at line 972 of file CASocket.cpp.

  {
    #ifndef _WIN32
        int flags=fcntl(m_Socket,F_GETFL,0);
        *b=((flags&O_NONBLOCK)==O_NONBLOCK);
        return E_SUCCESS;
    #else
        return SOCKET_ERROR;
    #endif
  }

References E_SUCCESS, flags, m_Socket, and SOCKET_ERROR.

Referenced by connect(), CAHttpClient::parseHTTPHeader(), sendFullyTimeOut(), and sendTimeOut().

Here is the caller graph for this function:

getPeerIP()

SINT32 CASocket::getPeerIP ( UINT8  ip[4] )

virtual

Definition at line 820 of file CASocket.cpp.

  {
    struct sockaddr_in addr;
    socklen_t namelen=sizeof(struct sockaddr_in);
    if(getpeername(m_Socket,(struct sockaddr*)&addr,&namelen)==SOCKET_ERROR)
      return SOCKET_ERROR;
    memcpy(ip,&addr.sin_addr,4);
    return E_SUCCESS;
  }

References E_SUCCESS, m_Socket, and SOCKET_ERROR.

Referenced by isAllowedToPassRestrictions().

Here is the caller graph for this function:

getPeerPort()

SINT32 CASocket::getPeerPort ( )

virtual

Definition at line 830 of file CASocket.cpp.

  {
    struct sockaddr_in addr;
    socklen_t namelen=sizeof(struct sockaddr_in);
    if(getpeername(m_Socket,(struct sockaddr*)&addr,&namelen)==SOCKET_ERROR)
      return SOCKET_ERROR;
    return ntohs(addr.sin_port);
  }

References m_Socket, and SOCKET_ERROR.

Referenced by CAFirstMixChannelList::add().

Here is the caller graph for this function:

getRecvBuff()

SINT32 CASocket::getRecvBuff ( )

virtual

Definition at line 852 of file CASocket.cpp.

  {
    int val;
    socklen_t size=sizeof(val);
    if(getsockopt(m_Socket,SOL_SOCKET,SO_RCVBUF,(char*)&val,&size)==SOCKET_ERROR)
      return E_UNKNOWN;
    else
      return val;
  }

References E_UNKNOWN, m_Socket, and SOCKET_ERROR.

Referenced by CAFirstMix::init().

Here is the caller graph for this function:

getSendBuff()

SINT32 CASocket::getSendBuff ( )

virtual

Definition at line 873 of file CASocket.cpp.

  {
    SINT32 val;
    socklen_t size=sizeof(val);
    if(getsockopt(m_Socket,SOL_SOCKET,SO_SNDBUF,(char*)&val,&size)==SOCKET_ERROR)
      return E_UNKNOWN;
    else
      return val;
  }

References E_UNKNOWN, m_Socket, and SOCKET_ERROR.

Referenced by CAFirstMix::init(), and setSendBuff().

Here is the caller graph for this function:

getSendTimeOut()

SINT32 CASocket::getSendTimeOut ( )

virtual

Definition at line 891 of file CASocket.cpp.

  {
    timeval val;
    socklen_t size=sizeof(val);
    if(getsockopt(m_Socket,SOL_SOCKET,SO_SNDTIMEO,(char*)&val,&size)==SOCKET_ERROR)
      return E_UNKNOWN;
    else
      return val.tv_sec*1000+val.tv_usec/1000;
  }

References E_UNKNOWN, m_Socket, and SOCKET_ERROR.

Referenced by sendFullyTimeOut(), and sendTimeOut().

Here is the caller graph for this function:

getSocket()

SOCKET CASocket::getSocket ( )

inlinevirtual

Returns the number of the Socket used.

Which will be always the same number, even after close(), until the Socket is recreated using create()

Returns

number of the associated socket

Implements CAClientSocket.

Definition at line 87 of file CASocket.hpp.

        {
          return m_Socket;
        }

References m_Socket.

Referenced by CASocketGroup::add(), CASocketGroupEpoll::add(), CAMuxSocket::getSocket(), CASocketGroup::isSignaled(), CASocketGroupEpoll::isSignaled(), CASocketGroup::remove(), CASocketGroupEpoll::remove(), and CASingleSocketGroup::select_once().

Here is the caller graph for this function:

init()

static SINT32 CASocket::init ( )

inlinestatic

Definition at line 43 of file CASocket.hpp.

        {
          m_pcsClose=new CAMutex();
          return E_SUCCESS;
        }

References E_SUCCESS, and m_pcsClose.

Referenced by CALibProxytest::init().

Here is the caller graph for this function:

isClosed()

virtual bool CASocket::isClosed ( )

inlinevirtual

Definition at line 132 of file CASocket.hpp.

      {
        return m_bSocketIsClosed;
      }

References m_bSocketIsClosed.

Referenced by CAFirstMix::doUserLogin_internal(), and CAMuxSocket::receive().

Here is the caller graph for this function:

listen() [1/2]

SINT32 CASocket::listen ( const CASocketAddr &  psa )

virtual

Starts listening on address psa.

Return values

E_SUCCESS,if	successful
E_SOCKET_LISTEN,if	call to listen() returns an error
E_SOCKET_BIND,if	call to bind() returns an error
E_UNKNOWN,otherwise

Definition at line 142 of file CASocket.cpp.

  {
    UINT32 iError;
    SINT32 type=psa.getType();
    if(m_bSocketIsClosed&&create(type)!=E_SUCCESS)
      return E_UNKNOWN;
#ifdef HAVE_UNIX_DOMAIN_PROTOCOL
    //we have to delete the file before...
    if(psa.getType()==AF_LOCAL)
      {
        UINT8* path=((CASocketAddrUnix&)psa).getPath();
        if(path!=NULL)
          {
            SINT32 ret=::unlink((char*)path);
            if(ret!=0)
              CAMsg::printMsg(LOG_ERR,"CASocket::listen() -- could not unlink unix domain socket file name %s -- a call to bind or listen may fail...\n",path);
            delete[] path;
            path = NULL;
          }
      }
#endif
    if(::bind(m_Socket,psa.LPSOCKADDR(),psa.getSize())==SOCKET_ERROR)
      {
        iError = GET_NET_ERROR;
        close();
        SET_NET_ERROR(iError);
        return E_SOCKET_BIND;
      }
    if(::listen(m_Socket,SOMAXCONN)==SOCKET_ERROR)
      {
        iError = GET_NET_ERROR;
        close();
        SET_NET_ERROR(iError);
        return E_SOCKET_LISTEN;
      }
    return E_SUCCESS;
  }

References AF_LOCAL, close(), create(), E_SOCKET_BIND, E_SOCKET_LISTEN, E_SUCCESS, E_UNKNOWN, GET_NET_ERROR, CASocketAddr::getSize(), CASocketAddr::getType(), CASocketAddr::LPSOCKADDR(), m_bSocketIsClosed, m_Socket, CAMsg::printMsg(), SET_NET_ERROR, SOCKET_ERROR, and type.

Referenced by CAMuxSocket::accept(), CACmdLnOptions::createSockets(), CALocalProxy::init(), and listen().

Here is the call graph for this function:

Here is the caller graph for this function:

listen() [2/2]

SINT32 CASocket::listen ( UINT16  port )

virtual

Definition at line 180 of file CASocket.cpp.

  {
    CASocketAddrINet oSocketAddrINet(port);
    return listen(oSocketAddrINet);
  }

References listen().

Here is the call graph for this function:

peek()

SINT32 CASocket::peek ( UINT8 *  buff, UINT32  len  )

virtual

Will peek some bytes from the socket read queue.

May block or not depending on whatever this socket was set to blocking or non-blocking mode. Warning: If socket is in blocking mode and peek() is called, peek() will block until some data is available, EVEN IF AN OTHER THREAD WILL CLOSE THIS SOCKET!

Parameters

buff	the buffer which get the peeked data
len	size of buff

Returns

SOCKET_ERROR if an error occured

Return values

E_AGAIN,if	socket was in non-blocking mode and receive would block or a timeout was reached
0	if socket was gracefully closed

Returns

the number of bytes received (always >0)

Definition at line 770 of file CASocket.cpp.

  {
    int ret;
    int ef=0;
    do
      {
        ret=::recv(m_Socket,(char*)buff,len,MSG_NOSIGNAL|MSG_PEEK);
      }
    while(ret==SOCKET_ERROR&&(ef=GET_NET_ERROR)==EINTR);
    if(ret==SOCKET_ERROR)
      {
        if(ef==ERR_INTERN_WOULDBLOCK)
          return E_AGAIN;
      }
#ifdef _DEBUG
    if(ret==SOCKET_ERROR)
        CAMsg::printMsg(LOG_DEBUG,"CASocket peek() error %d (%s)\n",ef,GET_NET_ERROR_STR(ef));
#endif
    return ret;
  }

References E_AGAIN, ERR_INTERN_WOULDBLOCK, GET_NET_ERROR, GET_NET_ERROR_STR, len, m_Socket, MSG_NOSIGNAL, CAMsg::printMsg(), and SOCKET_ERROR.

Here is the call graph for this function:

receive()

SINT32 CASocket::receive ( UINT8 *  buff, UINT32  len  )

virtual

Will receive some bytes from the socket.

May block or not depending on whatever this socket was set to blocking or non-blocking mode. Warning: If socket is in blocking mode and receive is called, receive will block until some data is available, EVEN IF AN OTHER THREAD WILL CLOSE THIS SOCKET!

Parameters

buff	the buffer which get the received data
len	size of buff

Returns

SOCKET_ERROR if an error occured

Return values

E_AGAIN,if	socket was in non-blocking mode and receive would block or a timeout was reached
0	if socket was gracefully closed

Returns

the number of bytes received (always >0)

Implements CAClientSocket.

Reimplemented in CATLSClientSocket.

Definition at line 645 of file CASocket.cpp.

  {
    int ret;
    int ef=0;
    do
      {
        ret=::recv(m_Socket,(char*)buff,len,MSG_NOSIGNAL);
      }
    while(ret==SOCKET_ERROR&&(ef=GET_NET_ERROR)==EINTR);
    if(ret==SOCKET_ERROR)
      {
        if(ef==ERR_INTERN_WOULDBLOCK)
          return E_AGAIN;
      }
#ifdef _DEBUG
    if(ret==SOCKET_ERROR)
        CAMsg::printMsg(LOG_DEBUG,"CASocket Receive error %d (%s)\n",ef,GET_NET_ERROR_STR(ef));
#endif
    return ret;
  }

References E_AGAIN, ERR_INTERN_WOULDBLOCK, GET_NET_ERROR, GET_NET_ERROR_STR, len, m_Socket, MSG_NOSIGNAL, CAMsg::printMsg(), and SOCKET_ERROR.

Referenced by CAHttpClient::getContent(), CALocalProxy::loop(), CALastMixA::loop(), CAHttpClient::parseHTTPHeader(), CAChain::processDownstream(), CAMuxSocket::receive(), receiveFullyT(), and receiveLine().

Here is the call graph for this function:

Here is the caller graph for this function:

receiveFullyT()

SINT32 CASocket::receiveFullyT ( UINT8 *  buff, UINT32  len, UINT32  msTimeOut  )

virtual

Trys to receive all bytes.

If after the timeout value has elapsed, not all bytes are received the error E_TIMEDOUT is returned.

Parameters

buff	byte array, where the received bytes would be stored
len	on input holds the number of bytes which should be read,
msTimeOut	the timout in milli seconds

Return values

E_TIMEDOUT	if not all byts could be read
E_UNKNOWN	if an error occured
E_SUCCESS	if all bytes could be read

Definition at line 677 of file CASocket.cpp.

  {
    SINT32 ret;
    UINT32 pos=0;
    UINT64 currentTime,endTime;
    getcurrentTimeMillis(currentTime);
    set64(endTime,currentTime);
    add64(endTime,msTimeOut);
//    CASingleSocketGroup oSG(false);
//    oSG.add(*this);
    for(;;)
      {
        ret = m_pSingleSocketGroupRead->select(msTimeOut);
        if(ret==1)
          {
            ret=receive(buff+pos,len);
            if(ret<=0)
              return E_UNKNOWN;
            pos+=ret;
            len-=ret;
          }
        else if(ret==E_TIMEDOUT)
        {
          return E_TIMEDOUT;
        }
        if(len==0)
          return E_SUCCESS;
        getcurrentTimeMillis(currentTime);
        if(!isLesser64(currentTime,endTime))
        {
          SET_NET_ERROR(E_TIMEDOUT);
          return E_TIMEDOUT;
        }
        msTimeOut=diff64(endTime,currentTime);
      }
  }

References add64(), diff64(), E_SUCCESS, E_TIMEDOUT, E_UNKNOWN, getcurrentTimeMillis(), isLesser64(), len, m_pSingleSocketGroupRead, receive(), CASocketGroup::select(), set64(), and SET_NET_ERROR.

Referenced by CAFirstMix::doUserLogin_internal(), CAMuxSocket::receiveFully(), CAInfoService::sendCascadeHelo(), CAInfoService::sendMixHelo(), CAAccountingBIInterface::settle(), and CAAccountingBIInterface::settleAll().

Here is the call graph for this function:

Here is the caller graph for this function:

receiveLine()

SINT32 CASocket::receiveLine ( UINT8 *  line, UINT32  maxLen, UINT32  msTimeOut  )

virtual

Definition at line 714 of file CASocket.cpp.

{
  UINT32 i = 0;
  UINT8 byte = 0;
  SINT32 ret = 0;
  UINT64 currentTime, endTime;
  getcurrentTimeMillis(currentTime);
  set64(endTime,currentTime);
  add64(endTime,msTimeOut);
//  CASingleSocketGroup oSG(false);
//  oSG.add(*this);
  do
  {
      ret = m_pSingleSocketGroupRead->select(msTimeOut);
    if(ret == 1)
    {
      ret = receive(&byte, 1);
      if(byte == '\r' || byte == '\n')
      {
        line[i++] = 0;
      }
      else
      {
        line[i++] = byte;
      }
    }
    else if(ret == E_TIMEDOUT)
    {
      return E_TIMEDOUT;
    }
    getcurrentTimeMillis(currentTime);
    if(!isLesser64(currentTime,endTime))
    {
      SET_NET_ERROR(E_TIMEDOUT);
      return E_TIMEDOUT;
    }
    msTimeOut=diff64(endTime,currentTime);
  }
  while(byte != '\n' && i<maxLen && ret > 0);
 
  return ret;
}

References add64(), diff64(), E_TIMEDOUT, getcurrentTimeMillis(), isLesser64(), m_pSingleSocketGroupRead, receive(), CASocketGroup::select(), set64(), and SET_NET_ERROR.

Here is the call graph for this function:

send()

SINT32 CASocket::send ( const UINT8 *  buff, UINT32  len  )

virtual

Sends some data over the network.

This may block, if socket is in blocking mode.

Parameters

buff	the buffer of data to send
len	content length

Return values

E_AGAIN	if non blocking socket would block or a timeout was reached
E_UNKNOWN	if an error occured

Returns

number of bytes send

Reimplemented in CATLSClientSocket.

Definition at line 400 of file CASocket.cpp.

  {
    if(len==0)
      return 0; //nothing to send
    int ret;
    SINT32 ef=0;
    do
      {
        ret=::send(m_Socket,(char*)buff,len,MSG_NOSIGNAL);
        #ifdef _DEBUG
          if(ret==SOCKET_ERROR)
            CAMsg::printMsg(LOG_DEBUG,"Fehler beim Socket-send: %i (Socket: %i)\n",GET_NET_ERROR,m_Socket);
        #endif
      }
    while(ret==SOCKET_ERROR&&(ef=GET_NET_ERROR)==EINTR);
    if(ret==SOCKET_ERROR)
      {
        if(ef==ERR_INTERN_WOULDBLOCK)
          {
            #ifdef _DEBUG
              CAMsg::printMsg(LOG_DEBUG,"Fehler beim Socket-send: E_AGAIN\n");
            #endif
            return E_AGAIN;
          }
        #ifdef _DEBUG
          CAMsg::printMsg(LOG_DEBUG,"Fehler beim Socket-send:E_UNKNOWN (ef=%i)\n",ef);
        #endif
        return E_UNKNOWN;
      }
    return ret;
  }

References E_AGAIN, E_UNKNOWN, ERR_INTERN_WOULDBLOCK, GET_NET_ERROR, len, m_Socket, MSG_NOSIGNAL, CAMsg::printMsg(), and SOCKET_ERROR.

Referenced by CALocalProxy::loop(), CALastMixA::loop(), CAFirstMixB::loop(), CALastMix::processKeyExchange(), CAMiddleMix::processKeyExchange(), sendFully(), sendFullyTimeOut(), sendTimeOut(), CAFirstMixA::sendToUsers(), and CAChain::sendUpstreamDataInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

sendFully()

SINT32 CASocket::sendFully ( const UINT8 *  buff, UINT32  len  )

virtual

Sends all data over the network.

This may block until all data is send.

Parameters

buff	- the buffer of data to send
len	- content length

Return values

E_UNKNOWN,if	an error occured
E_SUCCESS,if	successful

Implements CAClientSocket.

Reimplemented in CATLSClientSocket.

Definition at line 587 of file CASocket.cpp.

  {
    if(len==0)
      return E_SUCCESS; //nothing to send
    SINT32 ret;
    CASingleSocketGroup* pSingleSocketGroup = NULL;
    SINT32 retval = E_UNKNOWN;
    for(;;)
      {
        ret=send(buff,len);
        if((UINT32)ret==len)
          return E_SUCCESS;
        else if(ret==E_AGAIN)
          {
            if (pSingleSocketGroup == NULL)
            {
              pSingleSocketGroup = new CASingleSocketGroup(true);
              pSingleSocketGroup->add(*this);
            }
 
            ret= pSingleSocketGroup->select(1000);
            if(ret>=0||ret==E_TIMEDOUT)
              continue;
            #ifdef _DEBUG
              CAMsg::printMsg(LOG_DEBUG,"CASocket::sendFully() - error near select_once() ret=%i\n",ret);
            #endif
            retval=E_UNKNOWN;
            break;
          }
        else if(ret<0)
          {
            #ifdef _DEBUG
              CAMsg::printMsg(LOG_DEBUG,"CASocket::sendFully() - send returned %i\n",ret);
            #endif
            retval=E_UNKNOWN;
            break;
          }
        len-=ret;
        buff+=ret;
      }
    if (pSingleSocketGroup != NULL)
      delete pSingleSocketGroup;
    return retval;
}

References CASocketGroup::add(), E_AGAIN, E_SUCCESS, E_TIMEDOUT, E_UNKNOWN, len, CAMsg::printMsg(), CASocketGroup::select(), and send().

Referenced by CALocalProxy::processKeyExchange(), CAMuxSocket::send(), and sendFullyTimeOut().

Here is the call graph for this function:

Here is the caller graph for this function:

sendFullyTimeOut()

SINT32 CASocket::sendFullyTimeOut ( const UINT8 *  buff, UINT32  len, UINT32  msTimeOut, UINT32  msTimeOutSingleSend  )

virtual

Sends all data over the network.

This may block until all data is send.

Parameters

buff	- the buffer of data to send
len	- content length

Return values

E_UNKNOWN,if	an error occured
E_TIMEDOUT	if the timeout was reached
E_SUCCESS,if	successful

Definition at line 488 of file CASocket.cpp.

{
  if(len==0)
  {
    return E_SUCCESS; //nothing to send
  }
 
  SINT32 ret;
  SINT32 aktTimeOut=0;
  UINT64 startupTime, currentMillis;
  CASingleSocketGroup* pSingleSocketGroup = NULL;
 
  bool bWasNonBlocking;
  getNonBlocking(&bWasNonBlocking);
  aktTimeOut=getSendTimeOut();
  getcurrentTimeMillis(startupTime);
 
  if(bWasNonBlocking)
  {
    //we are in non-blocking mode
#ifdef _DEBUG
    CAMsg::printMsg(LOG_DEBUG, "CASocket::sendFullyTimeOut() -->non-blocking case\n");
#endif
    return sendFully(buff, len);
  }
  else if (setSendTimeOut(msTimeOutSingleSend)!=E_SUCCESS)
  {
    // it is not possible to set the socket timeout
    CAMsg::printMsg(LOG_ERR,"CASocket::sendFullyTimeOut() - could not set socket timeout!\n");
    return sendFully(buff, len);
  }
  else
  {
    SINT32 retval = E_UNKNOWN;
    for(;;)
    {
      getcurrentTimeMillis(currentMillis);
      if (currentMillis >= (startupTime + msTimeOut))
      {
        #ifdef DEBUG
        CAMsg::printMsg(LOG_DEBUG,"CASocket::sendFullyTimeOut() - timed out!\n");
        #endif
        setSendTimeOut(aktTimeOut);
        SET_NET_ERROR(E_TIMEDOUT);
        retval=E_TIMEDOUT;
        break;
      }
 
      ret=send(buff,len);
#ifdef DEBUG
      CAMsg::printMsg(LOG_DEBUG, "CASocket::sendFullyTimeOut() - send returned %i (expected: %u)!\n",ret,len);
#endif
      if((UINT32)ret==len)
      {
        setSendTimeOut(aktTimeOut);
        retval=E_SUCCESS;
        break;
      }
      else if(ret==E_AGAIN)
      {
        if (pSingleSocketGroup == NULL)
        {
          pSingleSocketGroup = new CASingleSocketGroup(true);
          pSingleSocketGroup->add(*this);
        }
        ret= pSingleSocketGroup->select(1000);
        if(ret>=0||ret==E_TIMEDOUT)
          continue;
        #ifdef _DEBUG
          CAMsg::printMsg(LOG_DEBUG,"CASocket::sendTimeOutFully() - error near select_once() ret=%i\n",ret);
        #endif
        setSendTimeOut(aktTimeOut);
        retval=E_UNKNOWN;
        break;
      }
      else if(ret<0)
      {
        #ifdef _DEBUG
          CAMsg::printMsg(LOG_DEBUG,"CASocket::sendTimeOutFully() - send returned %i\n",ret);
        #endif
        setSendTimeOut(aktTimeOut);
        retval=E_UNKNOWN;
        break;
      }
      len-=ret;
      buff+=ret;
    }
    if (pSingleSocketGroup != NULL)
      delete pSingleSocketGroup;
    return retval;
  }
}

References CASocketGroup::add(), E_AGAIN, E_SUCCESS, E_TIMEDOUT, E_UNKNOWN, getcurrentTimeMillis(), getNonBlocking(), getSendTimeOut(), len, CAMsg::printMsg(), CASocketGroup::select(), send(), sendFully(), SET_NET_ERROR, and setSendTimeOut().

Referenced by CAFirstMix::doUserLogin_internal(), CAInfoService::sendCascadeHelo(), CAHttpClient::sendGetRequest(), CAInfoService::sendMixHelo(), CAHttpClient::sendPostRequest(), and CAInfoService::sendStatus().

Here is the call graph for this function:

Here is the caller graph for this function:

sendTimeOut()

SINT32 CASocket::sendTimeOut ( const UINT8 *  buff, UINT32  len, UINT32  msTimeOut  )

virtual

Sends some data over the network.

Using a Timeout if socket is in blocking mode. Otherwise E_AGAIN may returned

Parameters

buff	the buffer to send
len	content length
msTimeOut	Maximum MilliSeconds to wait

Return values

E_AGAIN	if Operation would block on a non-blocking socket
E_TIMEDOUT	if the timeout was reached

Returns

number of bytes send, or -1 in case of an error /FIXME really buggy!!!!

Definition at line 442 of file CASocket.cpp.

{
  SINT32 ret;
  SINT32 aktTimeOut=0;
  bool bWasNonBlocking;
  getNonBlocking(&bWasNonBlocking);
  if(bWasNonBlocking) //we are in non-blocking mode
  {
    ret=send(buff,len);
  }
  else
  {
    aktTimeOut=getSendTimeOut();
    if(aktTimeOut>0&&(UINT32)aktTimeOut==msTimeOut) //we already have the right timeout
    {
      ret=send(buff,len);
    }
    else if(aktTimeOut<0||setSendTimeOut(msTimeOut)!=E_SUCCESS)
    {//do it complicate but still to simple!!!! more work TODO
      setNonBlocking(true);
      ret=send(buff,len);
      if(ret==E_AGAIN)
        {
          CAMsg::printMsg(LOG_DEBUG,"Send again...\n");
          msSleep((UINT16)msTimeOut);
          ret=send(buff,len);
        }
      setNonBlocking(bWasNonBlocking);
    }
    else
    {
      ret=send(buff,len);
      setSendTimeOut(aktTimeOut);
    }
  }
  return ret;
}

References E_AGAIN, E_SUCCESS, getNonBlocking(), getSendTimeOut(), len, msSleep(), CAMsg::printMsg(), send(), setNonBlocking(), and setSendTimeOut().

Referenced by CALastMixA::loop(), and CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

setKeepAlive() [1/2]

SINT32 CASocket::setKeepAlive ( bool  b )

virtual

Enables/disables the socket keep-alive option.

Parameters

b	true if option should be enabled, false otherwise

Returns

E_SUCCESS if no error occured

E_UNKOWN otherwise

Definition at line 906 of file CASocket.cpp.

  {
    int val=0;
    if(b) val=1;
    if(setsockopt(m_Socket,SOL_SOCKET,SO_KEEPALIVE,(char*)&val,sizeof(val))==SOCKET_ERROR)
    {
      int errnum=GET_NET_ERROR;
      CAMsg::printMsg(LOG_ERR, "Could not set KEEP_ALIVE options. Reason: %s (%i)\n", GET_NET_ERROR_STR(errnum), errnum);
      return E_UNKNOWN;
    }
    return E_SUCCESS;
  }

References E_SUCCESS, E_UNKNOWN, GET_NET_ERROR, GET_NET_ERROR_STR, m_Socket, CAMsg::printMsg(), and SOCKET_ERROR.

Referenced by CAFirstMix::doUserLogin_internal(), CAFirstMix::init(), CALastMix::init(), CAMiddleMix::init(), and setKeepAlive().

Here is the call graph for this function:

Here is the caller graph for this function:

setKeepAlive() [2/2]

SINT32 CASocket::setKeepAlive ( UINT32  sec )

virtual

Enables the socket keep-alive option with a given ping time (in seconds).

Parameters

sec	the time intervall(in seconds) of a keep-alive message

Returns

E_SUCCESS if no error occured

E_UNKOWN otherwise

Definition at line 924 of file CASocket.cpp.

  {
    if(setKeepAlive(true)!=E_SUCCESS)
    {
      return E_UNKNOWN;
    }
 
#ifdef HAVE_TCP_KEEPALIVE
    int val=sec;
    if(setsockopt(m_Socket,IPPROTO_TCP,TCP_KEEPALIVE,(char*)&val,sizeof(val))==SOCKET_ERROR)
    {
      CAMsg::printMsg(LOG_ERR,"Socket option TCP-KEEP-ALIVE was not set! Reason: %s (%i)\n",
          GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
      return E_UNKNOWN;
    }
    return E_SUCCESS;
#else
    CAMsg::printMsg(LOG_INFO,"Socket option TCP-KEEP-ALIVE was not set as it is not available on this machine.\n");
    return E_UNKNOWN;
#endif
  }

References E_SUCCESS, E_UNKNOWN, GET_NET_ERROR, GET_NET_ERROR_STR, m_Socket, CAMsg::printMsg(), setKeepAlive(), and SOCKET_ERROR.

Here is the call graph for this function:

setMaxNormalSockets()

static SINT32 CASocket::setMaxNormalSockets ( UINT32  u )

inlinestatic

Sets the max number of allowed "normal" sockets.

Return values

E_SUCCESS	if call was successful
E_UNKNOWN	otherwise

Definition at line 116 of file CASocket.hpp.

        {
        m_u32MaxNormalSockets=u;
        return E_SUCCESS;
        }

References E_SUCCESS, and m_u32MaxNormalSockets.

Referenced by main().

Here is the caller graph for this function:

setNonBlocking()

SINT32 CASocket::setNonBlocking ( bool  b )

virtual

Definition at line 947 of file CASocket.cpp.

  {
    if(b)
      {
        #ifndef _WIN32
            int flags=fcntl(m_Socket,F_GETFL,0);
            fcntl(m_Socket,F_SETFL,flags|O_NONBLOCK);
        #else
            unsigned long flags=1;
            ioctlsocket(m_Socket,FIONBIO,&flags);
        #endif
      }
    else
      {
        #ifndef _WIN32
            int flags=fcntl(m_Socket,F_GETFL,0);
            fcntl(m_Socket,F_SETFL,flags&~O_NONBLOCK);
        #else
            unsigned long flags=0;
            ioctlsocket(m_Socket,FIONBIO,&flags);
        #endif
      }
    return E_SUCCESS;
  }

References E_SUCCESS, flags, ioctlsocket, and m_Socket.

Referenced by connect(), CAFirstMix::doUserLogin_internal(), CAFirstMix::init(), CALastMix::init(), CALastMixA::loop(), CALastMixB::loop(), CAHttpClient::parseHTTPHeader(), sendTimeOut(), CAAccountingBIInterface::settle(), and CAAccountingBIInterface::settleAll().

Here is the caller graph for this function:

setRecvBuff()

SINT32 CASocket::setRecvBuff ( UINT32  r )

virtual

Definition at line 846 of file CASocket.cpp.

  {
    int val=r;
    return setsockopt(m_Socket,SOL_SOCKET,SO_RCVBUF,(char*)&val,sizeof(val));
  }

References m_Socket.

Referenced by CAFirstMix::init(), CALastMix::init(), CALocalProxy::init(), CAMiddleMix::init(), CALastMixA::loop(), CALastMixB::loop(), CAInfoService::sendMixHelo(), and CACmdLnOptions::setTargetInterfaces().

Here is the caller graph for this function:

setReuseAddr()

SINT32 CASocket::setReuseAddr ( bool  b )

virtual

Definition at line 839 of file CASocket.cpp.

  {
    int val=0;
    if(b) val=1;
    return setsockopt(m_Socket,SOL_SOCKET,SO_REUSEADDR,(char*)&val,sizeof(val));
  }

References m_Socket.

Referenced by CAMuxSocket::accept(), CACmdLnOptions::createSockets(), and CALocalProxy::init().

Here is the caller graph for this function:

setSendBuff()

SINT32 CASocket::setSendBuff ( SINT32  r )

virtual

Returns < 0 on error, otherwise the new sendbuffersize (which may be less than r)

Definition at line 862 of file CASocket.cpp.

  {
    if(r<0)
      return E_UNKNOWN;
    SINT32 val=r;
    SINT32 ret=setsockopt(m_Socket,SOL_SOCKET,SO_SNDBUF,(char*)&val,sizeof(val));
    if(ret!=0)
      return E_UNKNOWN;
    return getSendBuff();
  }

References E_UNKNOWN, getSendBuff(), and m_Socket.

Referenced by CAFirstMix::init(), CALastMix::init(), CALocalProxy::init(), CAMiddleMix::init(), CALastMixA::loop(), CALastMixB::loop(), and CACmdLnOptions::setTargetInterfaces().

Here is the call graph for this function:

Here is the caller graph for this function:

setSendTimeOut()

SINT32 CASocket::setSendTimeOut ( UINT32  msTimeOut )

virtual

Definition at line 883 of file CASocket.cpp.

  {
    timeval t;
    t.tv_sec=msTimeOut/1000;
    t.tv_usec=(msTimeOut%1000)*1000;
    return setsockopt(m_Socket,SOL_SOCKET,SO_SNDTIMEO,(char*)&t,sizeof(t));
  }

References m_Socket.

Referenced by sendFullyTimeOut(), and sendTimeOut().

Here is the caller graph for this function:

setSocket()

SINT32 CASocket::setSocket ( SOCKET  s )

privatevirtual

Definition at line 57 of file CASocket.cpp.

  {
    delete m_pSingleSocketGroupRead;
    m_Socket = s;
    if (s != 0)
      {
        m_pSingleSocketGroupRead = new CASingleSocketGroup(false);
        m_pSingleSocketGroupRead->add(m_Socket);
      }
    else
      {
        m_pSingleSocketGroupRead = NULL;
      }
    return E_SUCCESS;
  }

References CASocketGroup::add(), E_SUCCESS, m_pSingleSocketGroupRead, and m_Socket.

Referenced by accept(), close(), and create().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_bIsReservedSocket

bool CASocket::m_bIsReservedSocket

private

Definition at line 164 of file CASocket.hpp.

Referenced by CASocket(), close(), and create().

m_bSocketIsClosed

volatile bool CASocket::m_bSocketIsClosed

protected

check

end check

Definition at line 145 of file CASocket.hpp.

Referenced by accept(), CASocket(), close(), connect(), create(), isClosed(), and listen().

m_pcsClose

CAMutex * CASocket::m_pcsClose =NULL

staticprivate

Definition at line 159 of file CASocket.hpp.

Referenced by accept(), cleanup(), close(), create(), and init().

m_pSingleSocketGroupRead

CASingleSocketGroup* CASocket::m_pSingleSocketGroupRead

protected

Definition at line 151 of file CASocket.hpp.

Referenced by CASocket(), receiveFullyT(), receiveLine(), and setSocket().

m_Socket

SOCKET CASocket::m_Socket

protected

Definition at line 150 of file CASocket.hpp.

Referenced by accept(), CASocket(), close(), connect(), CATLSClientSocket::doTLSConnect(), getLocalIP(), getLocalPort(), getNonBlocking(), getPeerIP(), getPeerPort(), getRecvBuff(), getSendBuff(), getSendTimeOut(), getSocket(), listen(), peek(), receive(), send(), setKeepAlive(), setNonBlocking(), setRecvBuff(), setReuseAddr(), setSendBuff(), setSendTimeOut(), and setSocket().

m_u32MaxNormalSockets

UINT32 CASocket::m_u32MaxNormalSockets =0xFFFFFFFF

staticprivate

Definition at line 163 of file CASocket.hpp.

Referenced by accept(), create(), and setMaxNormalSockets().

m_u32NormalSocketsOpen

volatile UINT32 CASocket::m_u32NormalSocketsOpen =0

staticprivate

The following two variables are use to realise "reserved" sockets.

The rational behind is to ensure that we could allway crate "reserved" socket why we may fail to create normal sockets because of to many open files related restrictions

Definition at line 162 of file CASocket.hpp.

Referenced by accept(), close(), countOpenSockets(), and create().

---

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

• CASocket.hpp
• CASocket.cpp