external_libraries/oscpack/ip/win32/UdpSocket.cpp

   1 /*
   2         oscpack -- Open Sound Control packet manipulation library
   3         http://www.audiomulch.com/~rossb/oscpack
   4
   5         Copyright (c) 2004-2005 Ross Bencina <rossb@audiomulch.com>
   6
   7         Permission is hereby granted, free of charge, to any person obtaining
   8         a copy of this software and associated documentation files
   9         (the "Software"), to deal in the Software without restriction,
  10         including without limitation the rights to use, copy, modify, merge,
  11         publish, distribute, sublicense, and/or sell copies of the Software,
  12         and to permit persons to whom the Software is furnished to do so,
  13         subject to the following conditions:
  14
  15         The above copyright notice and this permission notice shall be
  16         included in all copies or substantial portions of the Software.
  17
  18         Any person wishing to distribute modifications to the Software is
  19         requested to send the modifications to the original developer so that
  20         they can be incorporated into the canonical version.
  21
  22         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23         EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24         MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25         IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  26         ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  27         CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28         WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 */
  30 #include "ip/UdpSocket.h"
  31
  32 #include <winsock2.h>   // this must come first to prevent errors with MSVC7
  33 #include <windows.h>
  34 #include <mmsystem.h>   // for timeGetTime()
  35
  36 #include <vector>
  37 #include <algorithm>
  38 #include <stdexcept>
  39 #include <assert.h>
  40
  41 #ifndef WINCE
  42 #include <signal.h>
  43 #endif
  44
  45 #include "ip/NetworkingUtils.h"
  46 #include "ip/PacketListener.h"
  47 #include "ip/TimerListener.h"
  48
  49
  50 typedef int socklen_t;
  51
  52
  53 static void SockaddrFromIpEndpointName( struct sockaddr_in& sockAddr, const IpEndpointName& endpoint )
  54 {
  55     memset( (char *)&sockAddr, 0, sizeof(sockAddr ) );
  56     sockAddr.sin_family = AF_INET;
  57
  58         sockAddr.sin_addr.s_addr =
  59                 (endpoint.address == IpEndpointName::ANY_ADDRESS)
  60                 ? INADDR_ANY
  61                 : htonl( endpoint.address );
  62
  63         sockAddr.sin_port =
  64                 (endpoint.port == IpEndpointName::ANY_PORT)
  65                 ? (short)0
  66                 : htons( (short)endpoint.port );
  67 }
  68
  69
  70 static IpEndpointName IpEndpointNameFromSockaddr( const struct sockaddr_in& sockAddr )
  71 {
  72         return IpEndpointName(
  73                 (sockAddr.sin_addr.s_addr == INADDR_ANY)
  74                         ? IpEndpointName::ANY_ADDRESS
  75                         : ntohl( sockAddr.sin_addr.s_addr ),
  76                 (sockAddr.sin_port == 0)
  77                         ? IpEndpointName::ANY_PORT
  78                         : ntohs( sockAddr.sin_port )
  79                 );
  80 }
  81
  82
  83 class UdpSocket::Implementation{
  84     NetworkInitializer networkInitializer_;
  85
  86         bool isBound_;
  87         bool isConnected_;
  88
  89         SOCKET socket_;
  90         struct sockaddr_in connectedAddr_;
  91         struct sockaddr_in sendToAddr_;
  92
  93 public:
  94
  95         Implementation()
  96                 : isBound_( false )
  97                 , isConnected_( false )
  98                 , socket_( INVALID_SOCKET )
  99         {
 100                 if( (socket_ = socket( AF_INET, SOCK_DGRAM, 0 )) == INVALID_SOCKET ){
 101             throw std::runtime_error("unable to create udp socket\n");
 102         }
 103
 104                 memset( &sendToAddr_, 0, sizeof(sendToAddr_) );
 105         sendToAddr_.sin_family = AF_INET;
 106         }
 107
 108         ~Implementation()
 109         {
 110                 if (socket_ != INVALID_SOCKET) closesocket(socket_);
 111         }
 112
 113         IpEndpointName LocalEndpointFor( const IpEndpointName& remoteEndpoint ) const
 114         {
 115                 assert( isBound_ );
 116
 117                 // first connect the socket to the remote server
 118
 119         struct sockaddr_in connectSockAddr;
 120                 SockaddrFromIpEndpointName( connectSockAddr, remoteEndpoint );
 121
 122         if (connect(socket_, (struct sockaddr *)&connectSockAddr, sizeof(connectSockAddr)) < 0) {
 123             throw std::runtime_error("unable to connect udp socket\n");
 124         }
 125
 126         // get the address
 127
 128         struct sockaddr_in sockAddr;
 129         memset( (char *)&sockAddr, 0, sizeof(sockAddr ) );
 130         socklen_t length = sizeof(sockAddr);
 131         if (getsockname(socket_, (struct sockaddr *)&sockAddr, &length) < 0) {
 132             throw std::runtime_error("unable to getsockname\n");
 133         }
 134
 135                 if( isConnected_ ){
 136                         // reconnect to the connected address
 137
 138                         if (connect(socket_, (struct sockaddr *)&connectedAddr_, sizeof(connectedAddr_)) < 0) {
 139                                 throw std::runtime_error("unable to connect udp socket\n");
 140                         }
 141
 142                 }else{
 143                         // unconnect from the remote address
 144
 145                         struct sockaddr_in unconnectSockAddr;
 146                         SockaddrFromIpEndpointName( unconnectSockAddr, IpEndpointName() );
 147
 148                         if( connect(socket_, (struct sockaddr *)&unconnectSockAddr, sizeof(unconnectSockAddr)) < 0
 149                                         && WSAGetLastError() != WSAEADDRNOTAVAIL ){
 150                                 throw std::runtime_error("unable to un-connect udp socket\n");
 151                         }
 152                 }
 153
 154                 return IpEndpointNameFromSockaddr( sockAddr );
 155         }
 156
 157         void Connect( const IpEndpointName& remoteEndpoint )
 158         {
 159                 SockaddrFromIpEndpointName( connectedAddr_, remoteEndpoint );
 160
 161         if (connect(socket_, (struct sockaddr *)&connectedAddr_, sizeof(connectedAddr_)) < 0) {
 162             throw std::runtime_error("unable to connect udp socket\n");
 163         }
 164
 165                 isConnected_ = true;
 166         }
 167
 168         void Send( const char *data, int size )
 169         {
 170                 assert( isConnected_ );
 171
 172         send( socket_, data, size, 0 );
 173         }
 174
 175     void SendTo( const IpEndpointName& remoteEndpoint, const char *data, int size )
 176         {
 177                 sendToAddr_.sin_addr.s_addr = htonl( remoteEndpoint.address );
 178         sendToAddr_.sin_port = htons( (short)remoteEndpoint.port );
 179
 180         sendto( socket_, data, size, 0, (sockaddr*)&sendToAddr_, sizeof(sendToAddr_) );
 181         }
 182
 183         void Bind( const IpEndpointName& localEndpoint )
 184         {
 185                 struct sockaddr_in bindSockAddr;
 186                 SockaddrFromIpEndpointName( bindSockAddr, localEndpoint );
 187
 188         if (bind(socket_, (struct sockaddr *)&bindSockAddr, sizeof(bindSockAddr)) < 0) {
 189             throw std::runtime_error("unable to bind udp socket\n");
 190         }
 191
 192                 isBound_ = true;
 193         }
 194
 195         bool IsBound() const { return isBound_; }
 196
 197     int ReceiveFrom( IpEndpointName& remoteEndpoint, char *data, int size )
 198         {
 199                 assert( isBound_ );
 200
 201                 struct sockaddr_in fromAddr;
 202         socklen_t fromAddrLen = sizeof(fromAddr);
 203
 204         int result = recvfrom(socket_, data, size, 0,
 205                     (struct sockaddr *) &fromAddr, (socklen_t*)&fromAddrLen);
 206                 if( result < 0 )
 207                         return 0;
 208
 209                 remoteEndpoint.address = ntohl(fromAddr.sin_addr.s_addr);
 210                 remoteEndpoint.port = ntohs(fromAddr.sin_port);
 211
 212                 return result;
 213         }
 214
 215         SOCKET& Socket() { return socket_; }
 216 };
 217
 218 UdpSocket::UdpSocket()
 219 {
 220         impl_ = new Implementation();
 221 }
 222
 223 UdpSocket::~UdpSocket()
 224 {
 225         delete impl_;
 226 }
 227
 228 IpEndpointName UdpSocket::LocalEndpointFor( const IpEndpointName& remoteEndpoint ) const
 229 {
 230         return impl_->LocalEndpointFor( remoteEndpoint );
 231 }
 232
 233 void UdpSocket::Connect( const IpEndpointName& remoteEndpoint )
 234 {
 235         impl_->Connect( remoteEndpoint );
 236 }
 237
 238 void UdpSocket::Send( const char *data, int size )
 239 {
 240         impl_->Send( data, size );
 241 }
 242
 243 void UdpSocket::SendTo( const IpEndpointName& remoteEndpoint, const char *data, int size )
 244 {
 245         impl_->SendTo( remoteEndpoint, data, size );
 246 }
 247
 248 void UdpSocket::Bind( const IpEndpointName& localEndpoint )
 249 {
 250         impl_->Bind( localEndpoint );
 251 }
 252
 253 bool UdpSocket::IsBound() const
 254 {
 255         return impl_->IsBound();
 256 }
 257
 258 int UdpSocket::ReceiveFrom( IpEndpointName& remoteEndpoint, char *data, int size )
 259 {
 260         return impl_->ReceiveFrom( remoteEndpoint, data, size );
 261 }
 262
 263
 264 struct AttachedTimerListener{
 265         AttachedTimerListener( int id, int p, TimerListener *tl )
 266                 : initialDelayMs( id )
 267                 , periodMs( p )
 268                 , listener( tl ) {}
 269         int initialDelayMs;
 270         int periodMs;
 271         TimerListener *listener;
 272 };
 273
 274
 275 static bool CompareScheduledTimerCalls(
 276                 const std::pair< double, AttachedTimerListener > & lhs, const std::pair< double, AttachedTimerListener > & rhs )
 277 {
 278         return lhs.first < rhs.first;
 279 }
 280
 281
 282 SocketReceiveMultiplexer *multiplexerInstanceToAbortWithSigInt_ = 0;
 283
 284 extern "C" /*static*/ void InterruptSignalHandler( int );
 285 /*static*/ void InterruptSignalHandler( int )
 286 {
 287         multiplexerInstanceToAbortWithSigInt_->AsynchronousBreak();
 288 #ifndef WINCE
 289     signal( SIGINT, SIG_DFL );
 290 #endif
 291 }
 292
 293
 294 class SocketReceiveMultiplexer::Implementation{
 295     NetworkInitializer networkInitializer_;
 296
 297         std::vector< std::pair< PacketListener*, UdpSocket* > > socketListeners_;
 298         std::vector< AttachedTimerListener > timerListeners_;
 299
 300         volatile bool break_;
 301         HANDLE breakEvent_;
 302
 303         double GetCurrentTimeMs() const
 304         {
 305 #ifndef WINCE
 306                 return timeGetTime(); // FIXME: bad choice if you want to run for more than 40 days
 307 #else
 308         return 0;
 309 #endif
 310     }
 311
 312 public:
 313     Implementation()
 314         {
 315                 breakEvent_ = CreateEvent( NULL, FALSE, FALSE, NULL );
 316         }
 317
 318     ~Implementation()
 319         {
 320                 CloseHandle( breakEvent_ );
 321         }
 322
 323     void AttachSocketListener( UdpSocket *socket, PacketListener *listener )
 324         {
 325                 assert( std::find( socketListeners_.begin(), socketListeners_.end(), std::make_pair(listener, socket) ) == socketListeners_.end() );
 326                 // we don't check that the same socket has been added multiple times, even though this is an error
 327                 socketListeners_.push_back( std::make_pair( listener, socket ) );
 328         }
 329
 330     void DetachSocketListener( UdpSocket *socket, PacketListener *listener )
 331         {
 332                 std::vector< std::pair< PacketListener*, UdpSocket* > >::iterator i =
 333                                 std::find( socketListeners_.begin(), socketListeners_.end(), std::make_pair(listener, socket) );
 334                 assert( i != socketListeners_.end() );
 335
 336                 socketListeners_.erase( i );
 337         }
 338
 339     void AttachPeriodicTimerListener( int periodMilliseconds, TimerListener *listener )
 340         {
 341                 timerListeners_.push_back( AttachedTimerListener( periodMilliseconds, periodMilliseconds, listener ) );
 342         }
 343
 344         void AttachPeriodicTimerListener( int initialDelayMilliseconds, int periodMilliseconds, TimerListener *listener )
 345         {
 346                 timerListeners_.push_back( AttachedTimerListener( initialDelayMilliseconds, periodMilliseconds, listener ) );
 347         }
 348
 349     void DetachPeriodicTimerListener( TimerListener *listener )
 350         {
 351                 std::vector< AttachedTimerListener >::iterator i = timerListeners_.begin();
 352                 while( i != timerListeners_.end() ){
 353                         if( i->listener == listener )
 354                                 break;
 355                         ++i;
 356                 }
 357
 358                 assert( i != timerListeners_.end() );
 359
 360                 timerListeners_.erase( i );
 361         }
 362
 363     void Run()
 364         {
 365                 break_ = false;
 366
 367                 // prepare the window events which we use to wake up on incoming data
 368                 // we use this instead of select() primarily to support the AsyncBreak()
 369                 // mechanism.
 370
 371                 std::vector<HANDLE> events( socketListeners_.size() + 1, 0 );
 372                 int j=0;
 373                 for( std::vector< std::pair< PacketListener*, UdpSocket* > >::iterator i = socketListeners_.begin();
 374                                 i != socketListeners_.end(); ++i, ++j ){
 375
 376                         HANDLE event = CreateEvent( NULL, FALSE, FALSE, NULL );
 377                         WSAEventSelect( i->second->impl_->Socket(), event, FD_READ ); // note that this makes the socket non-blocking which is why we can safely call RecieveFrom() on all sockets below
 378                         events[j] = event;
 379                 }
 380
 381
 382                 events[ socketListeners_.size() ] = breakEvent_; // last event in the collection is the break event
 383
 384
 385                 // configure the timer queue
 386                 double currentTimeMs = GetCurrentTimeMs();
 387
 388                 // expiry time ms, listener
 389                 std::vector< std::pair< double, AttachedTimerListener > > timerQueue_;
 390                 for( std::vector< AttachedTimerListener >::iterator i = timerListeners_.begin();
 391                                 i != timerListeners_.end(); ++i )
 392                         timerQueue_.push_back( std::make_pair( currentTimeMs + i->initialDelayMs, *i ) );
 393                 std::sort( timerQueue_.begin(), timerQueue_.end(), CompareScheduledTimerCalls );
 394
 395                 const int MAX_BUFFER_SIZE = 4098;
 396                 char *data = new char[ MAX_BUFFER_SIZE ];
 397                 IpEndpointName remoteEndpoint;
 398
 399                 while( !break_ ){
 400
 401                         double currentTimeMs = GetCurrentTimeMs();
 402
 403             DWORD waitTime = INFINITE;
 404             if( !timerQueue_.empty() ){
 405
 406                 waitTime = (DWORD)( timerQueue_.front().first >= currentTimeMs
 407                             ? timerQueue_.front().first - currentTimeMs
 408                             : 0 );
 409             }
 410
 411                         DWORD waitResult = WaitForMultipleObjects( (DWORD)socketListeners_.size() + 1, &events[0], FALSE, waitTime );
 412                         if( break_ )
 413                                 break;
 414
 415                         if( waitResult != WAIT_TIMEOUT ){
 416                                 for( int i = waitResult - WAIT_OBJECT_0; i < (int)socketListeners_.size(); ++i ){
 417                                         int size = socketListeners_[i].second->ReceiveFrom( remoteEndpoint, data, MAX_BUFFER_SIZE );
 418                                         if( size > 0 ){
 419                                                 socketListeners_[i].first->ProcessPacket( data, size, remoteEndpoint );
 420                                                 if( break_ )
 421                                                         break;
 422                                         }
 423                                 }
 424                         }
 425
 426                         // execute any expired timers
 427                         currentTimeMs = GetCurrentTimeMs();
 428                         bool resort = false;
 429                         for( std::vector< std::pair< double, AttachedTimerListener > >::iterator i = timerQueue_.begin();
 430                                         i != timerQueue_.end() && i->first <= currentTimeMs; ++i ){
 431
 432                                 i->second.listener->TimerExpired();
 433                                 if( break_ )
 434                                         break;
 435
 436                                 i->first += i->second.periodMs;
 437                                 resort = true;
 438                         }
 439                         if( resort )
 440                                 std::sort( timerQueue_.begin(), timerQueue_.end(), CompareScheduledTimerCalls );
 441                 }
 442
 443                 delete [] data;
 444
 445                 // free events
 446                 j = 0;
 447                 for( std::vector< std::pair< PacketListener*, UdpSocket* > >::iterator i = socketListeners_.begin();
 448                                 i != socketListeners_.end(); ++i, ++j ){
 449
 450                         WSAEventSelect( i->second->impl_->Socket(), events[j], 0 ); // remove association between socket and event
 451                         CloseHandle( events[j] );
 452                         unsigned long enableNonblocking = 0;
 453                         ioctlsocket( i->second->impl_->Socket(), FIONBIO, &enableNonblocking );  // make the socket blocking again
 454                 }
 455         }
 456
 457     void Break()
 458         {
 459                 break_ = true;
 460         }
 461
 462     void AsynchronousBreak()
 463         {
 464                 break_ = true;
 465                 SetEvent( breakEvent_ );
 466         }
 467 };
 468
 469
 470
 471 SocketReceiveMultiplexer::SocketReceiveMultiplexer()
 472 {
 473         impl_ = new Implementation();
 474 }
 475
 476 SocketReceiveMultiplexer::~SocketReceiveMultiplexer()
 477 {
 478         delete impl_;
 479 }
 480
 481 void SocketReceiveMultiplexer::AttachSocketListener( UdpSocket *socket, PacketListener *listener )
 482 {
 483         impl_->AttachSocketListener( socket, listener );
 484 }
 485
 486 void SocketReceiveMultiplexer::DetachSocketListener( UdpSocket *socket, PacketListener *listener )
 487 {
 488         impl_->DetachSocketListener( socket, listener );
 489 }
 490
 491 void SocketReceiveMultiplexer::AttachPeriodicTimerListener( int periodMilliseconds, TimerListener *listener )
 492 {
 493         impl_->AttachPeriodicTimerListener( periodMilliseconds, listener );
 494 }
 495
 496 void SocketReceiveMultiplexer::AttachPeriodicTimerListener( int initialDelayMilliseconds, int periodMilliseconds, TimerListener *listener )
 497 {
 498         impl_->AttachPeriodicTimerListener( initialDelayMilliseconds, periodMilliseconds, listener );
 499 }
 500
 501 void SocketReceiveMultiplexer::DetachPeriodicTimerListener( TimerListener *listener )
 502 {
 503         impl_->DetachPeriodicTimerListener( listener );
 504 }
 505
 506 void SocketReceiveMultiplexer::Run()
 507 {
 508         impl_->Run();
 509 }
 510
 511 void SocketReceiveMultiplexer::RunUntilSigInt()
 512 {
 513         assert( multiplexerInstanceToAbortWithSigInt_ == 0 ); /* at present we support only one multiplexer instance running until sig int */
 514         multiplexerInstanceToAbortWithSigInt_ = this;
 515 #ifndef WINCE
 516     signal( SIGINT, InterruptSignalHandler );
 517 #endif
 518         impl_->Run();
 519 #ifndef WINCE
 520         signal( SIGINT, SIG_DFL );
 521 #endif
 522         multiplexerInstanceToAbortWithSigInt_ = 0;
 523 }
 524
 525 void SocketReceiveMultiplexer::Break()
 526 {
 527         impl_->Break();
 528 }
 529
 530 void SocketReceiveMultiplexer::AsynchronousBreak()
 531 {
 532         impl_->AsynchronousBreak();
 533 }
 534