sockset.h File Reference

Socket Sets services definitions. More...

#include <sys/time.h>
#include <sys/select.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/sock.h"

Go to the source code of this file.

Classes
struct	SockSetIter_T

Macros
#define	SOCK_SET_ONHOLD   0
	on-hold socket descriptor set
#define	SOCK_SET_ACTIVE   1
	active socket descriptor set
#define	SOCK_SET_SELECTED   2
	post select() selected socket desc. set
#define	SOCK_SET_NUMOF   3
	number of managed socket descriptor sets
#define	SOCK_SET_CHK_SET(set, ...)   CHKEXPR_INT(set, ((set) >= 0) && ((set) < SOCK_SET_NUMOF), __VA_ARGS__)
	Check socket set enum. More...

Typedefs
typedef struct sockset_t	SockSet_T

Functions
SockSet_T *	SockSetNew ()
	Allocate a new SockSet. More...
void	SockSetDelete (SockSet_T *pSockSet)
	Delete an allocated SockSet. More...
int	SockSetAdd (SockSet_T *pSockSet, Socket_T *pSocket, bool_t bActivateRead, bool_t bActivateWrite)
	Add a Socket to a SockSet. More...
int	SockSetRemove (SockSet_T *pSockSet, Socket_T *pSocket)
	Remove Socket from SockSet. More...
int	SockSetActivate (SockSet_T *pSockSet, Socket_T *pSocket, bool_t bActivateRead, bool_t bActivateWrite)
	Activate Socket read/write operations in SockSet. More...
int	SockSetPutOnHold (SockSet_T *pSockSet, Socket_T *pSocket, bool_t bHoldRead, bool_t bHoldWrite)
	Put Socket read/write operations in SockSet on hold. More...
int	SockSetSelect (SockSet_T *pSockSet, struct timeval *pTimeOut)
	Perform select() on SockSet's Active sets. More...
Socket_T *	SockSetIterFirst (SockSet_T *pSockSet, int eSet, int eIO, SockSetIter_T *pIter)
	Start iteration of Sockets in the given set in SockSet. More...
Socket_T *	SockSetIterNext (SockSetIter_T *pIter)
	Next Socket in iteration over the initialized socket set of SockSet. More...

Detailed Description

Socket Sets services definitions.

Note

These socket functions were inspired by the camserv socket.c functions written by Jon Travis (jtrav.nosp@m.is@p.nosp@m.00p.o.nosp@m.rg)

Package

RoadNarrows Robotics Common Library 1

Library

librnr

File

rnr/sockset.h

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2005-2018. RoadNarrows LLC..
http://www.roadnarrows.com
All Rights Reserved

License

MIT

EULA

See the README and EULA files for any copyright and licensing information.

—

Definition in file sockset.h.

Macro Definition Documentation

#define SOCK_SET_CHK_SET	(		set,
			...
	)		CHKEXPR_INT(set, ((set) >= 0) && ((set) < SOCK_SET_NUMOF), __VA_ARGS__)

Check socket set enum.

Parameters

set	Socket descriptor set enum.

Definition at line 72 of file sockset.h.

Referenced by SockSetIterFirst().

Typedef Documentation

typedef struct sockset_t SockSet_T

The Socket Set Structure

Definition at line 46 of file sockset.h.

Function Documentation

int SockSetActivate	(	SockSet_T *	pSockSet,
		Socket_T *	pSocket,
		bool_t	bActivateRead,
		bool_t	bActivateWrite
	)

Activate Socket read/write operations in SockSet.

Socket is already part of the SockSet.

Parameters

pSockSet	Pointer to SockSet.
pSocket	Pointer to Socket.
bActivateRead	Do [not] add to active read set.
bActivateWrite	Do [not] add to active write set.

Returns

Returns OK(0) on success, ≤ 0 on error.

Definition at line 377 of file sockset.c.

References CHKPTR, fdclr_nowarn(), fdset_nowarn(), sockset_t::m_sdHighest, sockset_t::m_sdSetActive, sockset_t::m_sdSetOnHold, OK, SOCK_IO_READ, SOCK_IO_WRITE, SOCK_RC_EBADSOCK, SockSetChkSd(), and SockSetFindHighestSd().

{
  int   sd;   // socket descriptor

  CHKPTR(pSockSet, SOCK_RC_EBADSOCK);

  // Check data and return socket descriptor
  if( (sd = SockSetChkSd(pSocket)) < 0 )
  {
    return sd;
  }

  if( bActivateRead )
  {
    fdclr_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_READ]));
    fdset_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_READ]));
    if( sd > pSockSet->m_sdHighest )
    {
      pSockSet->m_sdHighest = sd;
    }
  }

  if( bActivateWrite )
  {
    fdclr_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_WRITE]));
    fdset_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_WRITE]));
    if( sd > pSockSet->m_sdHighest )
    {
      pSockSet->m_sdHighest = sd;
    }
  }

  pSockSet->m_sdHighest = SockSetFindHighestSd(pSockSet);

  return OK;
}

int SockSetAdd	(	SockSet_T *	pSockSet,
		Socket_T *	pSocket,
		bool_t	bActivateRead,
		bool_t	bActivateWrite
	)

Add a Socket to a SockSet.

Socket is added to either the on-hold or active socket set, depending on the given boolean value.

Parameters

pSockSet	Pointer to SockSet.
pSocket	Pointer to Socket.
bActivateRead	Do [not] add to active read set.
bActivateWrite	Do [not] add to active write set.

Returns

Returns OK(0) on success, ≤ 0 on error.

Definition at line 272 of file sockset.c.

References _TBOOL, _TPTR, _TSTR, CHKPTR, fdset_nowarn(), LOGDIAG4CALL, sockset_t::m_pSocket, sockset_t::m_sdHighest, sockset_t::m_sdSetActive, sockset_t::m_sdSetOnHold, OK, SOCK_IO_READ, SOCK_IO_WRITE, SOCK_RC_EBADSOCK, SocketAttrGetLocalName(), and SockSetChkSd().

{
  int   sd;   // socket descriptor

  CHKPTR(pSockSet, SOCK_RC_EBADSOCK);

  // Check data and return socket descriptor
  if( (sd = SockSetChkSd(pSocket)) < 0 )
  {
    return sd;
  }

  LOGDIAG4CALL(_TPTR(pSockSet), _TSTR(SocketAttrGetLocalName(pSocket)),
      _TBOOL(bActivateRead), _TBOOL(bActivateWrite));

  //
  // Add sd to appropriate read socket descriptor set
  //
  if( bActivateRead ) // place read in the active set
  {
    fdset_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_READ]));
    if( pSockSet->m_sdHighest < sd )
    {
      pSockSet->m_sdHighest = sd;
    }
  }
  else  // place read in the on-hold set
  {
    fdset_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_READ]));
  }

  //
  // Add sd to appropriate write socket descriptor set
  //
  if( bActivateWrite ) // place write in the active set
  {
    fdset_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_WRITE]));
    if( pSockSet->m_sdHighest < sd )
    {
      pSockSet->m_sdHighest = sd;
    }
  }
  else  // place write in the on-hold set
  {
    fdset_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_WRITE]));
  }

  // add socket 
  pSockSet->m_pSocket[sd] = pSocket;

  return OK;
}

void SockSetDelete

(

SockSet_T *

pSockSet

)

Delete an allocated SockSet.

Parameters

pSockSet

Pointer to SockSet.

Definition at line 250 of file sockset.c.

References NULL.

{
  if( pSockSet == NULL )
  {
    return;
  }
  delete(pSockSet);
}

Socket_T* SockSetIterFirst	(	SockSet_T *	pSockSet,
		int	eSet,
		int	eIO,
		SockSetIter_T *	pIter
	)

Start iteration of Sockets in the given set in SockSet.

Parameters

pSockSet	Pointer to SockSet.
eSet	One of: SOCK_SET_ONHOLD SOCK_SET_ACTIVE SOCK_SET_SELECTED.
eIO	One of: SOCK_IO_READ SOCK_IO_WRITE.
pIter	SockSet interator.

Returns

Pointer to first Socket if found, else NULL.

Definition at line 548 of file sockset.c.

References CHKPTR, SockSetIter_T::m_eIO, SockSetIter_T::m_eSet, SockSetIter_T::m_pSockSet, SockSetIter_T::m_sdCur, SockSetIter_T::m_sdSet, sockset_t::m_sdSetActive, sockset_t::m_sdSetOnHold, sockset_t::m_sdSetSelect, NULL, SOCK_CHK_IO, SOCK_SET_ACTIVE, SOCK_SET_CHK_SET, SOCK_SET_ONHOLD, SOCK_SET_SELECTED, and SockSetIterNext().

{
  CHKPTR(pSockSet, NULL);
  SOCK_SET_CHK_SET(eSet, NULL);
  SOCK_CHK_IO(eIO, NULL);
  CHKPTR(pIter, NULL);

  pIter->m_pSockSet = pSockSet;
  pIter->m_eSet     = eSet;
  pIter->m_eIO      = eIO;
  pIter->m_sdCur    = -1;

  switch(eSet)
  {
    case SOCK_SET_ONHOLD:
      pIter->m_sdSet = pSockSet->m_sdSetOnHold[eIO];
      break;
    case SOCK_SET_ACTIVE:
      pIter->m_sdSet = pSockSet->m_sdSetActive[eIO];
      break;
    case SOCK_SET_SELECTED:
    default:
      pIter->m_sdSet = pSockSet->m_sdSetSelect[eIO];
      break;
  }

  return SockSetIterNext(pIter);
}

Socket_T* SockSetIterNext

(

SockSetIter_T *

pIter

)

Next Socket in iteration over the initialized socket set of SockSet.

Parameters

pIter

SockSet interator.

Returns

Pointer to next Socket if found, else NULL.

Definition at line 587 of file sockset.c.

References CHKPTR, fdisset_nowarn(), sockset_t::m_pSocket, SockSetIter_T::m_pSockSet, SockSetIter_T::m_sdCur, SockSetIter_T::m_sdSet, and NULL.

Referenced by SockSetIterFirst().

{
  int   sd;

  CHKPTR(pIter, NULL);
  CHKPTR(pIter->m_pSockSet, NULL);

  for(sd = pIter->m_sdCur + 1; sd <= pIter->m_pSockSet->m_sdHighest; ++sd)
  {
    if( fdisset_nowarn(sd, &(pIter->m_sdSet)) )
    {
      pIter->m_sdCur = sd;
      return pIter->m_pSockSet->m_pSocket[sd];
    }
  }

  // no more selected sockets found
  pIter->m_sdCur = sd;

  return NULL;
}

SockSet_T* SockSetNew

(

)

Allocate a new SockSet.

Returns

Pointer to allocated SockSet.

Definition at line 229 of file sockset.c.

References sockset_t::m_sdHighest, sockset_t::m_sdSetActive, sockset_t::m_sdSetOnHold, sockset_t::m_sdSetSelect, NEW, SOCK_IO_READ, and SOCK_IO_WRITE.

{
  SockSet_T *pSockSet = NEW(SockSet_T);

  pSockSet->m_sdHighest = -1;

  FD_ZERO(&(pSockSet->m_sdSetSelect[SOCK_IO_READ]));
  FD_ZERO(&(pSockSet->m_sdSetSelect[SOCK_IO_WRITE]));
  FD_ZERO(&(pSockSet->m_sdSetActive[SOCK_IO_READ]));
  FD_ZERO(&(pSockSet->m_sdSetActive[SOCK_IO_WRITE]));
  FD_ZERO(&(pSockSet->m_sdSetOnHold[SOCK_IO_READ]));
  FD_ZERO(&(pSockSet->m_sdSetOnHold[SOCK_IO_WRITE]));

  return pSockSet;
}

int SockSetPutOnHold	(	SockSet_T *	pSockSet,
		Socket_T *	pSocket,
		bool_t	bHoldRead,
		bool_t	bHoldWrite
	)

Put Socket read/write operations in SockSet on hold.

Socket is already part of the SockSet.

Parameters

pSockSet	Pointer to SockSet.
pSocket	Pointer to Socket.
bHoldRead	Do [not] add to hold read set.
bHoldWrite	Do [not] add to hold write set.

Returns

Returns OK(0) on success, ≤ 0 on error.

Definition at line 429 of file sockset.c.

References CHKPTR, fdclr_nowarn(), fdset_nowarn(), sockset_t::m_sdHighest, sockset_t::m_sdSetActive, sockset_t::m_sdSetOnHold, OK, SOCK_IO_READ, SOCK_IO_WRITE, SOCK_RC_EBADSOCK, SockSetChkSd(), and SockSetFindHighestSd().

{
  int   sd;   // socket descriptor

  CHKPTR(pSockSet, SOCK_RC_EBADSOCK);

  // Check data and return socket descriptor
  if( (sd = SockSetChkSd(pSocket)) < 0 )
  {
    return sd;
  }

  if( bHoldRead )
  {
    fdclr_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_READ]));
    fdset_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_READ]));
  }

  if( bHoldWrite )
  {
    fdclr_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_WRITE]));
    fdset_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_WRITE]));
  }

  pSockSet->m_sdHighest = SockSetFindHighestSd(pSockSet);

  return OK;
}

int SockSetRemove	(	SockSet_T *	pSockSet,
		Socket_T *	pSocket
	)

Remove Socket from SockSet.

Parameters

pSockSet	Pointer to SockSet.
pSocket	Pointer to Socket.

Returns

Returns OK(0) on success, ≤ 0 on error.

Definition at line 336 of file sockset.c.

References _TPTR, _TSTR, CHKPTR, fdclr_nowarn(), LOGDIAG4CALL, sockset_t::m_pSocket, sockset_t::m_sdHighest, sockset_t::m_sdSetActive, sockset_t::m_sdSetOnHold, NULL, OK, SOCK_IO_READ, SOCK_IO_WRITE, SOCK_RC_EBADSOCK, SocketAttrGetLocalName(), SockSetChkSd(), and SockSetFindHighestSd().

{
  int   sd;   // socket descriptor

  CHKPTR(pSockSet, SOCK_RC_EBADSOCK);

  // Check data and return socket descriptor
  if( (sd = SockSetChkSd(pSocket)) < 0 )
  {
    return sd;
  }

  LOGDIAG4CALL(_TPTR(pSockSet), _TSTR(SocketAttrGetLocalName(pSocket)));

  // remove socket descriptor from all sets
  fdclr_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_READ]));
  fdclr_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_READ]));
  fdclr_nowarn(sd, &(pSockSet->m_sdSetActive[SOCK_IO_WRITE]));
  fdclr_nowarn(sd, &(pSockSet->m_sdSetOnHold[SOCK_IO_WRITE]));

  // remove socket
  pSockSet->m_pSocket[sd] = NULL;

  // find new highest socket descriptor
  pSockSet->m_sdHighest = SockSetFindHighestSd(pSockSet);

  return OK;
}

int SockSetSelect	(	SockSet_T *	pSockSet,
		struct timeval *	pTimeOut
	)

Perform select() on SockSet's Active sets.

Parameters

pSockSet	Pointer to SockSet.
pTimeOut	Select time out.

Returns

On success, returns number of socket descriptors found in the active state.
On time out, returns 0.
On error, returns ≤ 0.

Definition at line 472 of file sockset.c.

References CHKPTR, LOGERROR, LOGSYSERROR, sockset_t::m_sdHighest, sockset_t::m_sdSetActive, sockset_t::m_sdSetSelect, NULL, SOCK_IO_READ, SOCK_IO_WRITE, SOCK_RC_EBADSOCK, SOCK_RC_EFAIL, and SOCK_RC_ESYSERR.

{
  struct timeval  tvSave = {0, 0};  // saved timeout value
  int             nSd;              // number of socket descriptors selected
  int             nTries = 0;       // number of tries when interrupted

  CHKPTR(pSockSet, SOCK_RC_EBADSOCK);

  // save timeout value - can get munged by select()
  if( pTimeOut != NULL )
  {
    tvSave = *pTimeOut;
  }

  //
  // Try at most three times to select.
  //
  while(nTries++ < 3)
  {
    // build select read/write sets
    pSockSet->m_sdSetSelect[SOCK_IO_READ] = 
                                      pSockSet->m_sdSetActive[SOCK_IO_READ];
    pSockSet->m_sdSetSelect[SOCK_IO_WRITE] = 
                                      pSockSet->m_sdSetActive[SOCK_IO_WRITE];

    //
    // Wait with timeout (optional) for read/write availability
    //
    nSd = select(pSockSet->m_sdHighest+1,
                 &(pSockSet->m_sdSetSelect[SOCK_IO_READ]),
                 &(pSockSet->m_sdSetSelect[SOCK_IO_WRITE]),
                 NULL,
                 pTimeOut);

    // restore mangled time out
    if( pTimeOut != NULL )
    {
      *pTimeOut = tvSave;
    }

    // system error occurred
    if( nSd < 0 )
    {
      switch(errno)
      {
        case EINTR: // interrupted - try again
          break;
        default:
          LOGSYSERROR("select()");
          return SOCK_RC_ESYSERR;
      }
    }

    // read/write sets available or timeout
    else
    {
      return nSd;
    }
  }

  LOGERROR("Failed %d times to select()", nTries);

  return SOCK_RC_EFAIL;
}