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 #include <unistd.h>
  22 #include <fcntl.h>
  23
  24 namespace Jack
  25 {
  26     //utility *********************************************************************************************************
  27     int GetHostName ( char * name, int size )
  28     {
  29         if ( gethostname ( name, size ) == SOCKET_ERROR )
  30         {
  31             jack_error ( "Can't get 'hostname' : %s", strerror ( NET_ERROR_CODE ) );
  32             strcpy ( name, "default" );
  33             return SOCKET_ERROR;
  34         }
  35         return 0;
  36     }
  37
  38     //construct/destruct***********************************************************************************************
  39     JackNetUnixSocket::JackNetUnixSocket()
  40     {
  41         fSockfd = 0;
  42         fPort = 0;
  43         fTimeOut = 0;
  44         fSendAddr.sin_family = AF_INET;
  45         fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  46         memset ( &fSendAddr.sin_zero, 0, 8 );
  47         fRecvAddr.sin_family = AF_INET;
  48         fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  49         memset ( &fRecvAddr.sin_zero, 0, 8 );
  50     }
  51
  52     JackNetUnixSocket::JackNetUnixSocket ( const char* ip, int port )
  53     {
  54         fSockfd = 0;
  55         fPort = port;
  56         fTimeOut = 0;
  57         fSendAddr.sin_family = AF_INET;
  58         fSendAddr.sin_port = htons ( port );
  59         inet_aton ( ip, &fSendAddr.sin_addr );
  60         memset ( &fSendAddr.sin_zero, 0, 8 );
  61         fRecvAddr.sin_family = AF_INET;
  62         fRecvAddr.sin_port = htons ( port );
  63         fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  64         memset ( &fRecvAddr.sin_zero, 0, 8 );
  65     }
  66
  67     JackNetUnixSocket::JackNetUnixSocket ( const JackNetUnixSocket& socket )
  68     {
  69         fSockfd = 0;
  70         fTimeOut = 0;
  71         fPort = socket.fPort;
  72         fSendAddr = socket.fSendAddr;
  73         fRecvAddr = socket.fRecvAddr;
  74     }
  75
  76     JackNetUnixSocket::~JackNetUnixSocket()
  77     {
  78         Close();
  79     }
  80
  81     JackNetUnixSocket& JackNetUnixSocket::operator= ( const JackNetUnixSocket& socket )
  82     {
  83         if ( this != &socket )
  84         {
  85             fSockfd = 0;
  86             fPort = socket.fPort;
  87             fSendAddr = socket.fSendAddr;
  88             fRecvAddr = socket.fRecvAddr;
  89         }
  90         return *this;
  91     }
  92
  93     //socket***********************************************************************************************************
  94     int JackNetUnixSocket::NewSocket()
  95     {
  96         if ( fSockfd )
  97         {
  98             Close();
  99             Reset();
 100         }
 101         fSockfd = socket ( AF_INET, SOCK_DGRAM, 0 );
 102
 103         /* Enable address reuse */
 104         int res, on = 1;
 105         if ((res = setsockopt( fSockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))) < 0) {
 106             StrError(NET_ERROR_CODE);
 107         }
 108
 109         return fSockfd;
 110     }
 111
 112     int JackNetUnixSocket::Bind()
 113     {
 114         return bind ( fSockfd, reinterpret_cast<socket_address_t*> ( &fRecvAddr ), sizeof ( socket_address_t ) );
 115     }
 116
 117     int JackNetUnixSocket::BindWith ( const char* ip )
 118     {
 119         int addr_conv = inet_aton ( ip, &fRecvAddr.sin_addr );
 120         if ( addr_conv < 0 )
 121             return addr_conv;
 122         return Bind();
 123     }
 124
 125     int JackNetUnixSocket::BindWith ( int port )
 126     {
 127         fRecvAddr.sin_port = htons ( port );
 128         return Bind();
 129     }
 130
 131     int JackNetUnixSocket::Connect()
 132     {
 133         return connect ( fSockfd, reinterpret_cast<socket_address_t*> ( &fSendAddr ), sizeof ( socket_address_t ) );
 134     }
 135
 136     int JackNetUnixSocket::ConnectTo ( const char* ip )
 137     {
 138         int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
 139         if ( addr_conv < 0 )
 140             return addr_conv;
 141         return Connect();
 142     }
 143
 144     void JackNetUnixSocket::Close()
 145     {
 146         if ( fSockfd )
 147             close ( fSockfd );
 148         fSockfd = 0;
 149     }
 150
 151     void JackNetUnixSocket::Reset()
 152     {
 153         fSendAddr.sin_family = AF_INET;
 154         fSendAddr.sin_port = htons ( fPort );
 155         fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
 156         memset ( &fSendAddr.sin_zero, 0, 8 );
 157         fRecvAddr.sin_family = AF_INET;
 158         fRecvAddr.sin_port = htons ( fPort );
 159         fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
 160         memset ( &fRecvAddr.sin_zero, 0, 8 );
 161     }
 162
 163     bool JackNetUnixSocket::IsSocket()
 164     {
 165         return ( fSockfd ) ? true : false;
 166     }
 167
 168     //IP/PORT***********************************************************************************************************
 169     void JackNetUnixSocket::SetPort ( int port )
 170     {
 171         fPort = port;
 172         fSendAddr.sin_port = htons ( port );
 173         fRecvAddr.sin_port = htons ( port );
 174     }
 175
 176     int JackNetUnixSocket::GetPort()
 177     {
 178         return fPort;
 179     }
 180
 181     //address***********************************************************************************************************
 182     int JackNetUnixSocket::SetAddress ( const char* ip, int port )
 183     {
 184         int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
 185         if ( addr_conv < 0 )
 186             return addr_conv;
 187         fSendAddr.sin_port = htons ( port );
 188         return 0;
 189     }
 190
 191     char* JackNetUnixSocket::GetSendIP()
 192     {
 193         return inet_ntoa ( fSendAddr.sin_addr );
 194     }
 195
 196     char* JackNetUnixSocket::GetRecvIP()
 197     {
 198         return inet_ntoa ( fRecvAddr.sin_addr );
 199     }
 200
 201     //utility************************************************************************************************************
 202     int JackNetUnixSocket::GetName ( char* name )
 203     {
 204         return gethostname ( name, 255 );
 205     }
 206
 207     int JackNetUnixSocket::JoinMCastGroup ( const char* ip )
 208     {
 209         struct ip_mreq multicast_req;
 210         inet_aton ( ip, &multicast_req.imr_multiaddr );
 211         multicast_req.imr_interface.s_addr = htonl ( INADDR_ANY );
 212         return SetOption ( IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicast_req, sizeof ( multicast_req ) );
 213     }
 214
 215     //options************************************************************************************************************
 216     int JackNetUnixSocket::SetOption ( int level, int optname, const void* optval, socklen_t optlen )
 217     {
 218         return setsockopt ( fSockfd, level, optname, optval, optlen );
 219     }
 220
 221     int JackNetUnixSocket::GetOption ( int level, int optname, void* optval, socklen_t* optlen )
 222     {
 223         return getsockopt ( fSockfd, level, optname, optval, optlen );
 224     }
 225
 226     //timeout************************************************************************************************************
 227
 228 #if defined(__sun__) || defined(sun)
 229     int JackNetUnixSocket::SetTimeOut ( int us )
 230     {
 231         int     flags;
 232         fTimeOut = us;
 233
 234         if ((flags = fcntl(fSockfd, F_GETFL, 0)) < 0) {
 235                     jack_error("JackNetUnixSocket::SetTimeOut error in fcntl F_GETFL");
 236                     return -1;
 237             }
 238
 239             flags |= O_NONBLOCK;
 240             if (fcntl(fSockfd, F_SETFL, flags) < 0) {
 241                     jack_error("JackNetUnixSocket::SetTimeOut error in fcntl F_SETFL");
 242                     return 1;
 243             }
 244
 245         return 0;
 246     }
 247
 248     int JackNetUnixSocket::WaitRead()
 249     {
 250         if (fTimeOut > 0) {
 251
 252             struct timeval tv;
 253                 fd_set fdset;
 254             ssize_t     res;
 255
 256             tv.tv_sec = fTimeOut / 1000000;
 257                 tv.tv_usec = fTimeOut % 1000000;
 258
 259                 FD_ZERO(&fdset);
 260                 FD_SET(fSockfd, &fdset);
 261
 262                 do {
 263                         res = select(fSockfd + 1, &fdset, NULL, NULL, &tv);
 264                 } while (res < 0 && errno == EINTR);
 265
 266                 if (res < 0) {
 267                         return res;
 268             } else if (res == 0) {
 269                 errno = ETIMEDOUT;
 270                         return -1;
 271                 }
 272         }
 273
 274         return 0;
 275     }
 276
 277     int JackNetUnixSocket::WaitWrite()
 278     {
 279         if (fTimeOut > 0) {
 280
 281             struct timeval tv;
 282                 fd_set fdset;
 283             ssize_t     res;
 284
 285             tv.tv_sec = fTimeOut / 1000000;
 286                 tv.tv_usec = fTimeOut % 1000000;
 287
 288                 FD_ZERO(&fdset);
 289                 FD_SET(fSockfd, &fdset);
 290
 291                 do {
 292                         res = select(fSockfd + 1, NULL, &fdset, NULL, &tv);
 293                 } while (res < 0 && errno == EINTR);
 294
 295                 if (res < 0) {
 296                         return res;
 297             } else if (res == 0) {
 298                 errno = ETIMEDOUT;
 299                         return -1;
 300                 }
 301         }
 302
 303         return 0;
 304     }
 305
 306 #else
 307     int JackNetUnixSocket::SetTimeOut ( int us )
 308     {
 309         jack_log ( "JackNetUnixSocket::SetTimeout %d usecs", us );
 310
 311         //negative timeout, or exceding 10s, return
 312         if ( ( us < 0 ) || ( us > 10000000 ) )
 313             return SOCKET_ERROR;
 314         struct timeval timeout;
 315
 316         //less than 1sec
 317         if ( us < 1000000 )
 318         {
 319             timeout.tv_sec = 0;
 320             timeout.tv_usec = us;
 321         }
 322         //more than 1sec
 323         else
 324         {
 325             float sec = static_cast<float> ( us ) / 1000000.f;
 326             timeout.tv_sec = ( int ) sec;
 327             float usec = ( sec - static_cast<float> ( timeout.tv_sec ) ) * 1000000;
 328             timeout.tv_usec = ( int ) usec;
 329         }
 330         return SetOption ( SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof ( timeout ) );
 331     }
 332 #endif
 333
 334     //local loop**********************************************************************************************************
 335     int JackNetUnixSocket::SetLocalLoop()
 336     {
 337         char disable = 0;
 338         return SetOption ( IPPROTO_IP, IP_MULTICAST_LOOP, &disable, sizeof ( disable ) );
 339     }
 340
 341     //network operations**************************************************************************************************
 342     int JackNetUnixSocket::SendTo ( const void* buffer, size_t nbytes, int flags )
 343     {
 344     #if defined(__sun__) || defined(sun)
 345         if (WaitWrite() < 0)
 346             return -1;
 347     #endif
 348         return sendto ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fSendAddr ), sizeof ( socket_address_t ) );
 349     }
 350
 351     int JackNetUnixSocket::SendTo ( const void* buffer, size_t nbytes, int flags, const char* ip )
 352     {
 353         int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
 354         if ( addr_conv < 1 )
 355             return addr_conv;
 356     #if defined(__sun__) || defined(sun)
 357         if (WaitWrite() < 0)
 358             return -1;
 359     #endif
 360         return SendTo ( buffer, nbytes, flags );
 361     }
 362
 363     int JackNetUnixSocket::Send ( const void* buffer, size_t nbytes, int flags )
 364     {
 365     #if defined(__sun__) || defined(sun)
 366         if (WaitWrite() < 0)
 367             return -1;
 368     #endif
 369         return send ( fSockfd, buffer, nbytes, flags );
 370     }
 371
 372     int JackNetUnixSocket::RecvFrom ( void* buffer, size_t nbytes, int flags )
 373     {
 374         socklen_t addr_len = sizeof ( socket_address_t );
 375     #if defined(__sun__) || defined(sun)
 376         if (WaitRead() < 0)
 377             return -1;
 378     #endif
 379         return recvfrom ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fRecvAddr ), &addr_len );
 380     }
 381
 382     int JackNetUnixSocket::Recv ( void* buffer, size_t nbytes, int flags )
 383     {
 384     #if defined(__sun__) || defined(sun)
 385         if (WaitRead() < 0)
 386             return -1;
 387     #endif
 388         return recv ( fSockfd, buffer, nbytes, flags );
 389     }
 390
 391     int JackNetUnixSocket::CatchHost ( void* buffer, size_t nbytes, int flags )
 392     {
 393         socklen_t addr_len = sizeof ( socket_address_t );
 394     #if defined(__sun__) || defined(sun)
 395         if (WaitRead() < 0)
 396             return -1;
 397     #endif
 398         return recvfrom ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fSendAddr ), &addr_len );
 399     }
 400
 401     net_error_t JackNetUnixSocket::GetError()
 402     {
 403         switch ( errno )
 404         {
 405             case EAGAIN:
 406             case ETIMEDOUT:
 407                 return NET_NO_DATA;
 408
 409             case ECONNABORTED:
 410             case ECONNREFUSED:
 411             case ECONNRESET:
 412             case EINVAL:
 413             case EHOSTDOWN:
 414             case EHOSTUNREACH:
 415             case ENETDOWN:
 416             case ENETUNREACH:
 417                 return NET_CONN_ERROR;
 418
 419             default:
 420                 return NET_OP_ERROR;
 421         }
 422     }
 423 }