cabal_os_bsd.h

/*
   CABAL PROTOCOL
   CAched BAlanced LAN

   OS specific cabal extensions

   $Id: cabal_os_bsd.h,v 1.5 2004/03/29 02:15:52 jonnymind Exp $
---------------------------------------------
   Begin      :
   Author     : Giancarlo Niccolai

   Last modified because:

*/

#ifndef CABAL_OS_BSD_H
#define CABAL_OS_BSD_H

#include <netdb.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h> 
#include <unistd.h>
#include <fcntl.h>
#include <string.h> //memcmp

#include <list>

#include <cabal_error.h>

#define CABAL_INVALID_ADDR INADDR_ANY
#define CABAL_MAX_IP_SIZE INET_ADDRSTRLEN

namespace Cabal 
{
   typedef int RawSocket;
   typedef struct sockaddr_in SockAddrInet;
   typedef struct sockaddr SockAddr;
   
   typedef u_int16_t NetPort;
   typedef u_int32_t NetAddr;
   
   inline bool operator <( const SockAddrInet &in1, const SockAddrInet &in2 )
   {
      return ( memcmp( &in1, &in2, sizeof(in2) ) < 0 );
   }
   
   inline bool operator ==( const SockAddrInet &in1, const SockAddrInet &in2 )
   {
      return ( memcmp( &in1, &in2, sizeof(in2) ) == 0 );
   }   
}

#include <cabal_netbase.h>

namespace Cabal
{

class Net_BSD: public NetBase
{
public:
   static bool init() throw( InitError )
   {
      return true;
   }

   static bool exit() throw( DataIncompleteError )
   {
      return true;
   }

   static RawSocket createTCPSocket() { return ::socket( PF_INET, SOCK_STREAM , 0); }
   static RawSocket createUDPSocket() { return ::socket( PF_INET, SOCK_DGRAM , 0); }

   static int closeSocket( RawSocket s ) { return ::close(s); }

   static bool bind( const RawSocket s, const SockAddrInet &addr )
   {
      return ( ::bind( s, reinterpret_cast<const SockAddr *>( &addr ), sizeof( SockAddrInet ) ) != -1 );
   }
   
   static bool connect( const RawSocket s, const SockAddrInet &addr )
   {
      return ( ::connect( s, reinterpret_cast<const SockAddr *>( &addr ), sizeof( SockAddrInet ) ) != -1 );
   }

   static bool listen( const RawSocket s, const int incomingMax )
   {
      return ( ::listen( s, incomingMax ) == 0 );
   }
   
   static RawSocket accept( const RawSocket s, SockAddrInet *in )
   {
      socklen_t len = sizeof( SockAddrInet );
      return ::accept( s, reinterpret_cast<SockAddr *>(in), &len );
   }
   
   static void initSockAddr( SockAddrInet &attr ) { 
      attr.sin_family = AF_INET;
      attr.sin_port = 0;
      attr.sin_addr.s_addr = 0; 
   }
   
   static void initSockAddr( SockAddrInet &attr, const char *ip ) { 
      attr.sin_family = AF_INET;
      attr.sin_port = 0;
      inet_pton( AF_INET, ip, &attr.sin_addr );
   }
   
   static void initSockAddr( SockAddrInet &attr, const char *ip, const NetPort port ) {
      attr.sin_family = AF_INET;
      attr.sin_port = hostToNetPort( port );
      inet_pton( AF_INET, ip, &attr.sin_addr );
   }

   static void initSockAddr( SockAddrInet &attr, const NetAddr address, const NetPort port ) {
      attr.sin_family = AF_INET;
      attr.sin_port = hostToNetPort( port );
      attr.sin_addr.s_addr = hostToNetAddr( address );
   };
   
   static bool SockAddrIsZero( const SockAddrInet &addr ) { return (addr.sin_addr.s_addr == 0); }
   static bool SockAddrIsSame( const SockAddrInet &addr, const SockAddrInet &addr1 ) {
      if ( addr.sin_addr.s_addr == addr1.sin_addr.s_addr  && addr.sin_port == addr1.sin_port )
         return true;
      return false;
   }
   
   static void SockAddrSetPort( SockAddrInet &addr, NetPort port ) { 
      addr.sin_port = hostToNetPort( port ); 
   }
   static NetPort SockAddrGetPort( const SockAddrInet &addr ) { return netToHostPort( addr.sin_port ); }

   static bool getHostList(
      const std::string &name,
      std::string &real_name,
      char *real_ip,
      NetAddr *other_addrs, int na_count );

   static bool addrToString( const SockAddrInet &addr, char *buf )
   {
      return ( inet_ntop( AF_INET, &(addr.sin_addr.s_addr), buf, CABAL_MAX_IP_SIZE ) != 0);
   }
   
   static bool addrToString( const NetAddr addr, char *buf )
   {
      return ( inet_ntop( AF_INET, &addr, buf, CABAL_MAX_IP_SIZE ) != 0);
   }
   static bool stringToAddr( const char *source, SockAddrInet &addr )
   {
      return ( inet_pton( AF_INET, source, &addr.sin_addr ) != 0 );
   }

   static bool isAddressString( const char *source ) {
      SockAddrInet addr;
      return stringToAddr( source, addr  );
   }

   static int errorCode() { return errno; }
   static void resetError() { errno = 0; }
   
   static std::string errorDescription( const int osCode ) { return strerror( osCode ); }


   static RawSocket dup( RawSocket s )
   {
      return ::dup( s );
   }

   static bool inProgress() { return errno == EINPROGRESS; }
   static bool errorAgain() { return errno == EAGAIN; }
   static bool errorAgain( const int error) { return error == EAGAIN; }
   static bool errorPipe() { return errno == EPIPE; }

   static void setNonBlocking( RawSocket s )
   {
      int flags;
      flags = fcntl( s , F_GETFL );
      flags |= O_NONBLOCK;
      fcntl( s, F_SETFL, (long) flags );
   }

   static void setBlocking( RawSocket s )
   {
      int flags;
      flags = fcntl( s , F_GETFL );
      flags &= ~O_NONBLOCK;
      fcntl( s, F_SETFL, (long) flags );
   }
   
   static void setTCPDefaults( const RawSocket s )
   {
      int iOpt;
      setsockopt( s, SOL_SOCKET, SO_KEEPALIVE,
               (const char *) &iOpt , sizeof( iOpt ));
      setsockopt( s, SOL_SOCKET, SO_REUSEADDR,
               (const char *) &iOpt, sizeof( iOpt ));
   }


   static bool validSocket( const RawSocket s ) { return (s >= 0); }
   static void invalidate( RawSocket &s ) { s = -1; }

   static int getSocketOption( const RawSocket s, const int level, int &iErrval )
   {
      socklen_t iErrvalLen = sizeof( int );
      return getsockopt( s,
         SOL_SOCKET,
         level,
         reinterpret_cast<void *>( &iErrval ),
         &iErrvalLen
         );
   }


   static int send( const RawSocket s, const void *buffer, const int len, const int params=0 ) {
      return ::send( s, static_cast<const void *>(buffer), len, params | MSG_NOSIGNAL );
   }

   static int recv( const RawSocket s, void *buffer, const int len, const int params=0 ) {
      return ::recv( s, static_cast<void *>(buffer), len, params | MSG_NOSIGNAL );
   }

   static int sendto(const RawSocket s, const void *buffer, const int len, const int params,
            const SockAddrInet *remote, const int remsize )
   {
      return ::sendto( s, static_cast<const void *>(buffer), len, params| MSG_NOSIGNAL, 
         reinterpret_cast<const struct sockaddr *>(remote), remsize );
   }

   static int recvfrom(const RawSocket s, void *buffer, const int len, const int params,
             SockAddrInet *remote, int *remsize )
   {
      socklen_t lent = static_cast<socklen_t>(*remsize);
      int ret = ::recvfrom( s, static_cast<void *>(buffer), len, params| MSG_NOSIGNAL, 
         reinterpret_cast<struct sockaddr *>(remote), &lent );
      *remsize = static_cast<int>(lent);
      return ret;
   }

   static void shutdown( const RawSocket s ) {
      ::shutdown( s, SHUT_RDWR );
   }

   static void sleep ( const int msecs ) { usleep( msecs * 1000 ); }
      
   static NetPort hostToNetPort( const NetPort data ) { return htons( data ) ; }
   static NetAddr hostToNetAddr( const NetAddr data ) { return htonl( data ) ; } 
   static NetPort netToHostPort( const NetPort data ) { return ntohs( data ) ; }
   static NetAddr netToHostAddr( const NetAddr data ) { return ntohl( data ) ; }
   
   static MSECS timeOfDay() {
      struct timeval tv;
      gettimeofday( &tv, 0 );
      return (MSECS) ( (tv.tv_sec%86400) * 1000 ) + ( tv.tv_usec / 1000 );
   }
};


typedef Net_BSD Net;

};

// being INT, RawSocket's "<" operator is defined, and less<int> is defined.

#endif

---