posix/JackNetUnixSocket.cpp

   1 /*
   2 Copyright (C) 2008 Romain Moret at Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackNetUnixSocket.h"
  21
  22 namespace Jack
  23 {
  24     //utility *********************************************************************************************************
  25     int GetHostName ( char * name, int size )
  26     {
  27         if ( gethostname ( name, size ) == SOCKET_ERROR )
  28         {
  29             jack_error ( "Can't get 'hostname' : %s", strerror ( NET_ERROR_CODE ) );
  30             strcpy ( name, "default" );
  31             return SOCKET_ERROR;
  32         }
  33         return 0;
  34     }
  35
  36     //construct/destruct***********************************************************************************************
  37     JackNetUnixSocket::JackNetUnixSocket()
  38     {
  39         fSockfd = 0;
  40         fPort = 0;
  41         fSendAddr.sin_family = AF_INET;
  42         fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  43         memset ( &fSendAddr.sin_zero, 0, 8 );
  44         fRecvAddr.sin_family = AF_INET;
  45         fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  46         memset ( &fRecvAddr.sin_zero, 0, 8 );
  47     }
  48
  49     JackNetUnixSocket::JackNetUnixSocket ( const char* ip, int port )
  50     {
  51         fSockfd = 0;
  52         fPort = port;
  53         fSendAddr.sin_family = AF_INET;
  54         fSendAddr.sin_port = htons ( port );
  55         inet_aton ( ip, &fSendAddr.sin_addr );
  56         memset ( &fSendAddr.sin_zero, 0, 8 );
  57         fRecvAddr.sin_family = AF_INET;
  58         fRecvAddr.sin_port = htons ( port );
  59         fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  60         memset ( &fRecvAddr.sin_zero, 0, 8 );
  61     }
  62
  63     JackNetUnixSocket::JackNetUnixSocket ( const JackNetUnixSocket& socket )
  64     {
  65         fSockfd = 0;
  66         fPort = socket.fPort;
  67         fSendAddr = socket.fSendAddr;
  68         fRecvAddr = socket.fRecvAddr;
  69     }
  70
  71     JackNetUnixSocket::~JackNetUnixSocket()
  72     {
  73         Close();
  74     }
  75
  76     JackNetUnixSocket& JackNetUnixSocket::operator= ( const JackNetUnixSocket& socket )
  77     {
  78         if ( this != &socket )
  79         {
  80             fSockfd = 0;
  81             fPort = socket.fPort;
  82             fSendAddr = socket.fSendAddr;
  83             fRecvAddr = socket.fRecvAddr;
  84         }
  85         return *this;
  86     }
  87
  88     //socket***********************************************************************************************************
  89     int JackNetUnixSocket::NewSocket()
  90     {
  91         if ( fSockfd )
  92         {
  93             Close();
  94             Reset();
  95         }
  96         fSockfd = socket ( AF_INET, SOCK_DGRAM, 0 );
  97         return fSockfd;
  98     }
  99
 100     int JackNetUnixSocket::Bind()
 101     {
 102         return bind ( fSockfd, reinterpret_cast<socket_address_t*> ( &fRecvAddr ), sizeof ( socket_address_t ) );
 103     }
 104
 105     int JackNetUnixSocket::BindWith ( const char* ip )
 106     {
 107         int addr_conv = inet_aton ( ip, &fRecvAddr.sin_addr );
 108         if ( addr_conv < 0 )
 109             return addr_conv;
 110         return Bind();
 111     }
 112
 113     int JackNetUnixSocket::BindWith ( int port )
 114     {
 115         fRecvAddr.sin_port = htons ( port );
 116         return Bind();
 117     }
 118
 119     int JackNetUnixSocket::Connect()
 120     {
 121         return connect ( fSockfd, reinterpret_cast<socket_address_t*> ( &fSendAddr ), sizeof ( socket_address_t ) );
 122     }
 123
 124     int JackNetUnixSocket::ConnectTo ( const char* ip )
 125     {
 126         int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
 127         if ( addr_conv < 0 )
 128             return addr_conv;
 129         return Connect();
 130     }
 131
 132     void JackNetUnixSocket::Close()
 133     {
 134         if ( fSockfd )
 135             close ( fSockfd );
 136         fSockfd = 0;
 137     }
 138
 139     void JackNetUnixSocket::Reset()
 140     {
 141         fSendAddr.sin_family = AF_INET;
 142         fSendAddr.sin_port = htons ( fPort );
 143         fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
 144         memset ( &fSendAddr.sin_zero, 0, 8 );
 145         fRecvAddr.sin_family = AF_INET;
 146         fRecvAddr.sin_port = htons ( fPort );
 147         fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
 148         memset ( &fRecvAddr.sin_zero, 0, 8 );
 149     }
 150
 151     bool JackNetUnixSocket::IsSocket()
 152     {
 153         return ( fSockfd ) ? true : false;
 154     }
 155
 156     //IP/PORT***********************************************************************************************************
 157     void JackNetUnixSocket::SetPort ( int port )
 158     {
 159         fPort = port;
 160         fSendAddr.sin_port = htons ( port );
 161         fRecvAddr.sin_port = htons ( port );
 162     }
 163
 164     int JackNetUnixSocket::GetPort()
 165     {
 166         return fPort;
 167     }
 168
 169     //address***********************************************************************************************************
 170     int JackNetUnixSocket::SetAddress ( const char* ip, int port )
 171     {
 172         int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
 173         if ( addr_conv < 0 )
 174             return addr_conv;
 175         fSendAddr.sin_port = htons ( port );
 176         return 0;
 177     }
 178
 179     char* JackNetUnixSocket::GetSendIP()
 180     {
 181         return inet_ntoa ( fSendAddr.sin_addr );
 182     }
 183
 184     char* JackNetUnixSocket::GetRecvIP()
 185     {
 186         return inet_ntoa ( fRecvAddr.sin_addr );
 187     }
 188
 189     //utility************************************************************************************************************
 190     int JackNetUnixSocket::GetName ( char* name )
 191     {
 192         return gethostname ( name, 255 );
 193     }
 194
 195     int JackNetUnixSocket::JoinMCastGroup ( const char* ip )
 196     {
 197         struct ip_mreq multicast_req;
 198         inet_aton ( ip, &multicast_req.imr_multiaddr );
 199         multicast_req.imr_interface.s_addr = htonl ( INADDR_ANY );
 200         return SetOption ( IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicast_req, sizeof ( multicast_req ) );
 201     }
 202
 203     //options************************************************************************************************************
 204     int JackNetUnixSocket::SetOption ( int level, int optname, const void* optval, socklen_t optlen )
 205     {
 206         return setsockopt ( fSockfd, level, optname, optval, optlen );
 207     }
 208
 209     int JackNetUnixSocket::GetOption ( int level, int optname, void* optval, socklen_t* optlen )
 210     {
 211         return getsockopt ( fSockfd, level, optname, optval, optlen );
 212     }
 213
 214     //timeout************************************************************************************************************
 215     int JackNetUnixSocket::SetTimeOut ( int us )
 216     {
 217         jack_log ( "JackNetUnixSocket::SetTimeout %d usecs", us );
 218
 219         //negative timeout, or exceding 10s, return
 220         if ( ( us < 0 ) || ( us > 10000000 ) )
 221             return SOCKET_ERROR;
 222         struct timeval timeout;
 223
 224         //less than 1sec
 225         if ( us < 1000000 )
 226         {
 227             timeout.tv_sec = 0;
 228             timeout.tv_usec = us;
 229         }
 230         //more than 1sec
 231         else
 232         {
 233             float sec = static_cast<float> ( us ) / 1000000.f;
 234             timeout.tv_sec = ( int ) sec;
 235             float usec = ( sec - static_cast<float> ( timeout.tv_sec ) ) * 1000000;
 236             timeout.tv_usec = ( int ) usec;
 237         }
 238         return SetOption ( SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof ( timeout ) );
 239     }
 240
 241     //local loop**********************************************************************************************************
 242     int JackNetUnixSocket::SetLocalLoop()
 243     {
 244         char disable = 0;
 245         return SetOption ( IPPROTO_IP, IP_MULTICAST_LOOP, &disable, sizeof ( disable ) );
 246     }
 247
 248     //network operations**************************************************************************************************
 249     int JackNetUnixSocket::SendTo ( const void* buffer, size_t nbytes, int flags )
 250     {
 251         return sendto ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fSendAddr ), sizeof ( socket_address_t ) );
 252     }
 253
 254     int JackNetUnixSocket::SendTo ( const void* buffer, size_t nbytes, int flags, const char* ip )
 255     {
 256         int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
 257         if ( addr_conv < 1 )
 258             return addr_conv;
 259         return SendTo ( buffer, nbytes, flags );
 260     }
 261
 262     int JackNetUnixSocket::Send ( const void* buffer, size_t nbytes, int flags )
 263     {
 264         return send ( fSockfd, buffer, nbytes, flags );
 265     }
 266
 267     int JackNetUnixSocket::RecvFrom ( void* buffer, size_t nbytes, int flags )
 268     {
 269         socklen_t addr_len = sizeof ( socket_address_t );
 270         return recvfrom ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fRecvAddr ), &addr_len );
 271     }
 272
 273     int JackNetUnixSocket::Recv ( void* buffer, size_t nbytes, int flags )
 274     {
 275         return recv ( fSockfd, buffer, nbytes, flags );
 276     }
 277
 278     int JackNetUnixSocket::CatchHost ( void* buffer, size_t nbytes, int flags )
 279     {
 280         socklen_t addr_len = sizeof ( socket_address_t );
 281         return recvfrom ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fSendAddr ), &addr_len );
 282     }
 283
 284     net_error_t JackNetUnixSocket::GetError()
 285     {
 286         switch ( errno )
 287         {
 288             case EAGAIN:
 289                 return NET_NO_DATA;
 290             case ECONNABORTED:
 291                 return NET_CONN_ERROR;
 292             case EINVAL:
 293                 return NET_CONN_ERROR;
 294             case ECONNREFUSED:
 295                 return NET_CONN_ERROR;
 296             case ECONNRESET:
 297                 return NET_CONN_ERROR;
 298             case EHOSTDOWN:
 299                 return NET_CONN_ERROR;
 300             case EHOSTUNREACH:
 301                 return NET_CONN_ERROR;
 302             default:
 303                 return NET_OP_ERROR;
 304         }
 305     }
 306 }