cabal_os_wsa.h

/*
   CABAL PROTOCOL
   CAched BAlanced LAN

   OS specific cabal extensions (WIN*OWS WSA)

   $Id: cabal_os_wsa.h,v 1.8 2004/03/31 16:29:37 jonnymind Exp $
---------------------------------------------
   Begin      :
   Author     : Giancarlo Niccolai

   Last modified because:

*/

#ifndef CABAL_OS_WSA_H
#define CABAL_OS_WSA_H

#include <string.h> //memcmp
#include <winsock2.h>
#include <cabal_error.h>
#include <string>

#define CABAL_INVALID_ADDR INADDR_ANY
#define CABAL_MAX_IP_SIZE 21

namespace Cabal {
   typedef SOCKET RawSocket;
   typedef struct sockaddr_in SockAddrInet;
   typedef struct sockaddr SockAddr;
   typedef int socklen_t;
   
   typedef unsigned short NetPort;
   typedef unsigned long  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>

// Ignore MSG_NOSIGNAL under windows.
#define MSG_NOSIGNAL 0

namespace Cabal {

class Net_WSA: public NetBase
{
   static int m_count;

public:
   static bool init() throw(InitError);
   static bool exit() throw(DataIncompleteError);
   
   static RawSocket createTCPSocket() { return ::socket( AF_INET, SOCK_STREAM , 0); }
   static RawSocket createUDPSocket() { return ::socket( AF_INET, SOCK_DGRAM , 0); }
   
   static int closeSocket( RawSocket s ) { return ::closesocket(s); }
   
   static int 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 );
      RawSocket ret =  ::accept( s, reinterpret_cast<SockAddr *>(in), &len );
      if ( ret == -1 ) return INVALID_SOCKET;
      return ret;
   }
   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;
      attr.sin_addr.s_addr = inet_addr( ip ); 
   }
   
   static void initSockAddr( SockAddrInet &attr, const char *ip, const NetPort port ) {
      attr.sin_family = AF_INET;
      attr.sin_port = htons(port);
      attr.sin_addr.s_addr = inet_addr( ip );
   }

   static void initSockAddr( SockAddrInet &attr, const NetAddr address, const NetPort port ) {
      attr.sin_family = AF_INET;
      attr.sin_port = htons(port);
      attr.sin_addr.s_addr = htonl( address );
   };
   
   static bool SockAddrIsZero( const SockAddrInet &addr ) { return (addr.sin_addr.s_addr == 0); }
   static void SockAddrSetPort( SockAddrInet &addr, NetPort port ) { 
      addr.sin_port = hostToNetPort( port ); 
   }
   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 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 *dest );
   static bool stringToAddr( const char *source, SockAddrInet &addr )
   {
      int size = CABAL_MAX_IP_SIZE;
      return (WSAStringToAddress(
         const_cast<char *>(source),
         AF_INET,
         NULL,
         reinterpret_cast<SockAddr *>(&addr),
         &size
      ) == 0);
   }

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

   
   static int errorCode() { return  WSAGetLastError(); }    
   static std::string errorDescription( const int osCode );
   static void resetError() {}

   
   static RawSocket dup( RawSocket s )
   {
      WSAPROTOCOL_INFO proto_inf;
      if ( WSADuplicateSocket( s, GetCurrentProcessId(), &proto_inf ) == 0 ) 
      {
         s = WSASocket( 
            FROM_PROTOCOL_INFO,
            FROM_PROTOCOL_INFO,
            FROM_PROTOCOL_INFO,
            &proto_inf,
            0,
            0 );
         if ( s == INVALID_SOCKET ) return static_cast<RawSocket>( -1 );
         return s;
      }
      return static_cast<RawSocket>(-1);
   } 
   
   static bool inProgress() { return WSAGetLastError() == WSAEWOULDBLOCK; }
   static bool errorAgain() { return WSAGetLastError() == WSAEWOULDBLOCK; }
   static bool errorAgain(int error) { return error == WSAEWOULDBLOCK; }
   static bool errorPipe() { return false; }
 
   static void setNonBlocking( RawSocket s )
   {
      unsigned long mode = 1;
      ioctlsocket( s,  FIONBIO, &mode );
   }
   
   static void setBlocking( RawSocket s )
   {
      unsigned long mode = 0;
      ioctlsocket( s,  FIONBIO, &mode );
   }
   
   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 != INVALID_SOCKET; }
   static void invalidate( RawSocket &s ) { s = INVALID_SOCKET; }
  
   static int getSocketOption( const RawSocket s, const int level, int &iErrval ) 
   {
      int iErrvalLen = sizeof( int );
      return getsockopt( s,
         SOL_SOCKET,
         level,
         reinterpret_cast<char *>( &iErrval ),
         &iErrvalLen
         );
   }
   

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

   static int recv( const RawSocket s, void *buffer, const int len, const int params=0 ) {
      return ::recv( s, static_cast<char *>(buffer), len, params );
   }
   
   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 char *>(buffer), len, params, 
               reinterpret_cast<const SockAddr *>(remote), remsize );
   }
   
   static int recvfrom(const RawSocket s, void *buffer, const int len, const int params,
            SockAddrInet *remote, int *remsize )
   {
      return ::recvfrom( s, static_cast<char *>(buffer), len, params, 
               reinterpret_cast<SockAddr *>(remote), remsize );
   }
   
   static void shutdown( const RawSocket s ) { 
      setBlocking( s );
      ::shutdown( s, SD_SEND ); 
   }
   
   
   static void sleep ( const int msecs ) { Sleep( msecs ); }
   
   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();

};

typedef Net_WSA Net;

};

// being scalar (int, dword or long),
// RawSocket's "<" operator is defined, and less<int> is defined.
#endif

/* End of cabal_os_wsa.h */

---