9370b9d2b9870b3df1bcd8527043be2568401fac
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / osclib / 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 #include <signal.h>
41
42 #include "ip/NetworkingUtils.h"
43 #include "ip/PacketListener.h"
44 #include "ip/TimerListener.h"
45
46
47 typedef int socklen_t;
48
49
50 static void SockaddrFromIpEndpointName( struct sockaddr_in& sockAddr, const IpEndpointName& endpoint )
51 {
52 memset( (char *)&sockAddr, 0, sizeof(sockAddr ) );
53 sockAddr.sin_family = AF_INET;
54
55 sockAddr.sin_addr.s_addr =
56 (endpoint.address == IpEndpointName::ANY_ADDRESS)
57 ? INADDR_ANY
58 : htonl( endpoint.address );
59
60 sockAddr.sin_port =
61 (endpoint.port == IpEndpointName::ANY_PORT)
62 ? (short)0
63 : htons( (short)endpoint.port );
64 }
65
66
67 static IpEndpointName IpEndpointNameFromSockaddr( const struct sockaddr_in& sockAddr )
68 {
69 return IpEndpointName(
70 (sockAddr.sin_addr.s_addr == INADDR_ANY)
71 ? IpEndpointName::ANY_ADDRESS
72 : ntohl( sockAddr.sin_addr.s_addr ),
73 (sockAddr.sin_port == 0)
74 ? IpEndpointName::ANY_PORT
75 : ntohs( sockAddr.sin_port )
76 );
77 }
78
79
80 class UdpSocket::Implementation{
81 NetworkInitializer networkInitializer_;
82
83 bool isBound_;
84 bool isConnected_;
85
86 SOCKET socket_;
87 struct sockaddr_in connectedAddr_;
88 struct sockaddr_in sendToAddr_;
89
90 public:
91
92 Implementation()
93 : isBound_( false )
94 , isConnected_( false )
95 , socket_( INVALID_SOCKET )
96 {
97 if( (socket_ = socket( AF_INET, SOCK_DGRAM, 0 )) == INVALID_SOCKET ){
98 throw std::runtime_error("unable to create udp socket\n");
99 }
100
101 memset( &sendToAddr_, 0, sizeof(sendToAddr_) );
102 sendToAddr_.sin_family = AF_INET;
103 }
104
105 ~Implementation()
106 {
107 if (socket_ != INVALID_SOCKET) closesocket(socket_);
108 }
109
110 IpEndpointName LocalEndpointFor( const IpEndpointName& remoteEndpoint ) const
111 {
112 assert( isBound_ );
113
114 // first connect the socket to the remote server
115
116 struct sockaddr_in connectSockAddr;
117 SockaddrFromIpEndpointName( connectSockAddr, remoteEndpoint );
118
119 if (connect(socket_, (struct sockaddr *)&connectSockAddr, sizeof(connectSockAddr)) < 0) {
120 throw std::runtime_error("unable to connect udp socket\n");
121 }
122
123 // get the address
124
125 struct sockaddr_in sockAddr;
126 memset( (char *)&sockAddr, 0, sizeof(sockAddr ) );
127 socklen_t length = sizeof(sockAddr);
128 if (getsockname(socket_, (struct sockaddr *)&sockAddr, &length) < 0) {
129 throw std::runtime_error("unable to getsockname\n");
130 }
131
132 if( isConnected_ ){
133 // reconnect to the connected address
134
135 if (connect(socket_, (struct sockaddr *)&connectedAddr_, sizeof(connectedAddr_)) < 0) {
136 throw std::runtime_error("unable to connect udp socket\n");
137 }
138
139 }else{
140 // unconnect from the remote address
141
142 struct sockaddr_in unconnectSockAddr;
143 SockaddrFromIpEndpointName( unconnectSockAddr, IpEndpointName() );
144
145 if( connect(socket_, (struct sockaddr *)&unconnectSockAddr, sizeof(unconnectSockAddr)) < 0
146 && WSAGetLastError() != WSAEADDRNOTAVAIL ){
147 throw std::runtime_error("unable to un-connect udp socket\n");
148 }
149 }
150
151 return IpEndpointNameFromSockaddr( sockAddr );
152 }
153
154 void Connect( const IpEndpointName& remoteEndpoint )
155 {
156 SockaddrFromIpEndpointName( connectedAddr_, remoteEndpoint );
157
158 if (connect(socket_, (struct sockaddr *)&connectedAddr_, sizeof(connectedAddr_)) < 0) {
159 throw std::runtime_error("unable to connect udp socket\n");
160 }
161
162 isConnected_ = true;
163 }
164
165 void Send( const char *data, int size )
166 {
167 assert( isConnected_ );
168
169 send( socket_, data, size, 0 );
170 }
171
172 void SendTo( const IpEndpointName& remoteEndpoint, const char *data, int size )
173 {
174 sendToAddr_.sin_addr.s_addr = htonl( remoteEndpoint.address );
175 sendToAddr_.sin_port = htons( (short)remoteEndpoint.port );
176
177 sendto( socket_, data, size, 0, (sockaddr*)&sendToAddr_, sizeof(sendToAddr_) );
178 }
179
180 void Bind( const IpEndpointName& localEndpoint )
181 {
182 struct sockaddr_in bindSockAddr;
183 SockaddrFromIpEndpointName( bindSockAddr, localEndpoint );
184
185 if (bind(socket_, (struct sockaddr *)&bindSockAddr, sizeof(bindSockAddr)) < 0) {
186 throw std::runtime_error("unable to bind udp socket\n");
187 }
188
189 isBound_ = true;
190 }
191
192 bool IsBound() const { return isBound_; }
193
194 int ReceiveFrom( IpEndpointName& remoteEndpoint, char *data, int size )
195 {
196 assert( isBound_ );
197
198 struct sockaddr_in fromAddr;
199 socklen_t fromAddrLen = sizeof(fromAddr);
200
201 int result = recvfrom(socket_, data, size, 0,
202 (struct sockaddr *) &fromAddr, (socklen_t*)&fromAddrLen);
203 if( result < 0 )
204 return 0;
205
206 remoteEndpoint.address = ntohl(fromAddr.sin_addr.s_addr);
207 remoteEndpoint.port = ntohs(fromAddr.sin_port);
208
209 return result;
210 }
211
212 SOCKET& Socket() { return socket_; }
213 };
214
215 UdpSocket::UdpSocket()
216 {
217 impl_ = new Implementation();
218 }
219
220 UdpSocket::~UdpSocket()
221 {
222 delete impl_;
223 }
224
225 IpEndpointName UdpSocket::LocalEndpointFor( const IpEndpointName& remoteEndpoint ) const
226 {
227 return impl_->LocalEndpointFor( remoteEndpoint );
228 }
229
230 void UdpSocket::Connect( const IpEndpointName& remoteEndpoint )
231 {
232 impl_->Connect( remoteEndpoint );
233 }
234
235 void UdpSocket::Send( const char *data, int size )
236 {
237 impl_->Send( data, size );
238 }
239
240 void UdpSocket::SendTo( const IpEndpointName& remoteEndpoint, const char *data, int size )
241 {
242 impl_->SendTo( remoteEndpoint, data, size );
243 }
244
245 void UdpSocket::Bind( const IpEndpointName& localEndpoint )
246 {
247 impl_->Bind( localEndpoint );
248 }
249
250 bool UdpSocket::IsBound() const
251 {
252 return impl_->IsBound();
253 }
254
255 int UdpSocket::ReceiveFrom( IpEndpointName& remoteEndpoint, char *data, int size )
256 {
257 return impl_->ReceiveFrom( remoteEndpoint, data, size );
258 }
259
260
261 struct AttachedTimerListener{
262 AttachedTimerListener( int id, int p, TimerListener *tl )
263 : initialDelayMs( id )
264 , periodMs( p )
265 , listener( tl ) {}
266 int initialDelayMs;
267 int periodMs;
268 TimerListener *listener;
269 };
270
271
272 static bool CompareScheduledTimerCalls(
273 const std::pair< double, AttachedTimerListener > & lhs, const std::pair< double, AttachedTimerListener > & rhs )
274 {
275 return lhs.first < rhs.first;
276 }
277
278
279 SocketReceiveMultiplexer *multiplexerInstanceToAbortWithSigInt_ = 0;
280
281 extern "C" /*static*/ void InterruptSignalHandler( int );
282 /*static*/ void InterruptSignalHandler( int )
283 {
284 multiplexerInstanceToAbortWithSigInt_->AsynchronousBreak();
285 signal( SIGINT, SIG_DFL );
286 }
287
288
289 class SocketReceiveMultiplexer::Implementation{
290 NetworkInitializer networkInitializer_;
291
292 std::vector< std::pair< PacketListener*, UdpSocket* > > socketListeners_;
293 std::vector< AttachedTimerListener > timerListeners_;
294
295 volatile bool break_;
296 HANDLE breakEvent_;
297
298 double GetCurrentTimeMs() const
299 {
300 return timeGetTime(); // FIXME: bad choice if you want to run for more than 40 days
301 }
302
303 public:
304 Implementation()
305 {
306 breakEvent_ = CreateEvent( NULL, FALSE, FALSE, NULL );
307 }
308
309 ~Implementation()
310 {
311 CloseHandle( breakEvent_ );
312 }
313
314 void AttachSocketListener( UdpSocket *socket, PacketListener *listener )
315 {
316 assert( std::find( socketListeners_.begin(), socketListeners_.end(), std::make_pair(listener, socket) ) == socketListeners_.end() );
317 // we don't check that the same socket has been added multiple times, even though this is an error
318 socketListeners_.push_back( std::make_pair( listener, socket ) );
319 }
320
321 void DetachSocketListener( UdpSocket *socket, PacketListener *listener )
322 {
323 std::vector< std::pair< PacketListener*, UdpSocket* > >::iterator i =
324 std::find( socketListeners_.begin(), socketListeners_.end(), std::make_pair(listener, socket) );
325 assert( i != socketListeners_.end() );
326
327 socketListeners_.erase( i );
328 }
329
330 void AttachPeriodicTimerListener( int periodMilliseconds, TimerListener *listener )
331 {
332 timerListeners_.push_back( AttachedTimerListener( periodMilliseconds, periodMilliseconds, listener ) );
333 }
334
335 void AttachPeriodicTimerListener( int initialDelayMilliseconds, int periodMilliseconds, TimerListener *listener )
336 {
337 timerListeners_.push_back( AttachedTimerListener( initialDelayMilliseconds, periodMilliseconds, listener ) );
338 }
339
340 void DetachPeriodicTimerListener( TimerListener *listener )
341 {
342 std::vector< AttachedTimerListener >::iterator i = timerListeners_.begin();
343 while( i != timerListeners_.end() ){
344 if( i->listener == listener )
345 break;
346 ++i;
347 }
348
349 assert( i != timerListeners_.end() );
350
351 timerListeners_.erase( i );
352 }
353
354 void Run()
355 {
356 break_ = false;
357
358 // prepare the window events which we use to wake up on incoming data
359 // we use this instead of select() primarily to support the AsyncBreak()
360 // mechanism.
361
362 std::vector<HANDLE> events( socketListeners_.size() + 1, 0 );
363 int j=0;
364 for( std::vector< std::pair< PacketListener*, UdpSocket* > >::iterator i = socketListeners_.begin();
365 i != socketListeners_.end(); ++i, ++j ){
366
367 HANDLE event = CreateEvent( NULL, FALSE, FALSE, NULL );
368 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
369 events[j] = event;
370 }
371
372
373 events[ socketListeners_.size() ] = breakEvent_; // last event in the collection is the break event
374
375
376 // configure the timer queue
377 double currentTimeMs = GetCurrentTimeMs();
378
379 // expiry time ms, listener
380 std::vector< std::pair< double, AttachedTimerListener > > timerQueue_;
381 for( std::vector< AttachedTimerListener >::iterator i = timerListeners_.begin();
382 i != timerListeners_.end(); ++i )
383 timerQueue_.push_back( std::make_pair( currentTimeMs + i->initialDelayMs, *i ) );
384 std::sort( timerQueue_.begin(), timerQueue_.end(), CompareScheduledTimerCalls );
385
386 const int MAX_BUFFER_SIZE = 4098;
387 char *data = new char[ MAX_BUFFER_SIZE ];
388 IpEndpointName remoteEndpoint;
389
390 while( !break_ ){
391
392 double currentTimeMs = GetCurrentTimeMs();
393
394 DWORD waitTime = INFINITE;
395 if( !timerQueue_.empty() ){
396
397 waitTime = (DWORD)( timerQueue_.front().first >= currentTimeMs
398 ? timerQueue_.front().first - currentTimeMs
399 : 0 );
400 }
401
402 DWORD waitResult = WaitForMultipleObjects( (DWORD)socketListeners_.size() + 1, &events[0], FALSE, waitTime );
403 if( break_ )
404 break;
405
406 if( waitResult != WAIT_TIMEOUT ){
407 for( int i = waitResult - WAIT_OBJECT_0; i < (int)socketListeners_.size(); ++i ){
408 int size = socketListeners_[i].second->ReceiveFrom( remoteEndpoint, data, MAX_BUFFER_SIZE );
409 if( size > 0 ){
410 socketListeners_[i].first->ProcessPacket( data, size, remoteEndpoint );
411 if( break_ )
412 break;
413 }
414 }
415 }
416
417 // execute any expired timers
418 currentTimeMs = GetCurrentTimeMs();
419 bool resort = false;
420 for( std::vector< std::pair< double, AttachedTimerListener > >::iterator i = timerQueue_.begin();
421 i != timerQueue_.end() && i->first <= currentTimeMs; ++i ){
422
423 i->second.listener->TimerExpired();
424 if( break_ )
425 break;
426
427 i->first += i->second.periodMs;
428 resort = true;
429 }
430 if( resort )
431 std::sort( timerQueue_.begin(), timerQueue_.end(), CompareScheduledTimerCalls );
432 }
433
434 delete [] data;
435
436 // free events
437 j = 0;
438 for( std::vector< std::pair< PacketListener*, UdpSocket* > >::iterator i = socketListeners_.begin();
439 i != socketListeners_.end(); ++i, ++j ){
440
441 WSAEventSelect( i->second->impl_->Socket(), events[j], 0 ); // remove association between socket and event
442 CloseHandle( events[j] );
443 unsigned long enableNonblocking = 0;
444 ioctlsocket( i->second->impl_->Socket(), FIONBIO, &enableNonblocking ); // make the socket blocking again
445 }
446 }
447
448 void Break()
449 {
450 break_ = true;
451 }
452
453 void AsynchronousBreak()
454 {
455 break_ = true;
456 SetEvent( breakEvent_ );
457 }
458 };
459
460
461
462 SocketReceiveMultiplexer::SocketReceiveMultiplexer()
463 {
464 impl_ = new Implementation();
465 }
466
467 SocketReceiveMultiplexer::~SocketReceiveMultiplexer()
468 {
469 delete impl_;
470 }
471
472 void SocketReceiveMultiplexer::AttachSocketListener( UdpSocket *socket, PacketListener *listener )
473 {
474 impl_->AttachSocketListener( socket, listener );
475 }
476
477 void SocketReceiveMultiplexer::DetachSocketListener( UdpSocket *socket, PacketListener *listener )
478 {
479 impl_->DetachSocketListener( socket, listener );
480 }
481
482 void SocketReceiveMultiplexer::AttachPeriodicTimerListener( int periodMilliseconds, TimerListener *listener )
483 {
484 impl_->AttachPeriodicTimerListener( periodMilliseconds, listener );
485 }
486
487 void SocketReceiveMultiplexer::AttachPeriodicTimerListener( int initialDelayMilliseconds, int periodMilliseconds, TimerListener *listener )
488 {
489 impl_->AttachPeriodicTimerListener( initialDelayMilliseconds, periodMilliseconds, listener );
490 }
491
492 void SocketReceiveMultiplexer::DetachPeriodicTimerListener( TimerListener *listener )
493 {
494 impl_->DetachPeriodicTimerListener( listener );
495 }
496
497 void SocketReceiveMultiplexer::Run()
498 {
499 impl_->Run();
500 }
501
502 void SocketReceiveMultiplexer::RunUntilSigInt()
503 {
504 assert( multiplexerInstanceToAbortWithSigInt_ == 0 ); /* at present we support only one multiplexer instance running until sig int */
505 multiplexerInstanceToAbortWithSigInt_ = this;
506 signal( SIGINT, InterruptSignalHandler );
507 impl_->Run();
508 signal( SIGINT, SIG_DFL );
509 multiplexerInstanceToAbortWithSigInt_ = 0;
510 }
511
512 void SocketReceiveMultiplexer::Break()
513 {
514 impl_->Break();
515 }
516
517 void SocketReceiveMultiplexer::AsynchronousBreak()
518 {
519 impl_->AsynchronousBreak();
520 }
521