1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
2  *
3  * This library is open source and may be redistributed and/or modified under
4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5  * (at your option) any later version.  The full license is in LICENSE file
6  * included with this distribution, and on the openscenegraph.org website.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * OpenSceneGraph Public License for more details.
12 */
13 
14 #include "Cluster.h"
15 
16 #include <stdio.h>
17 #include <fcntl.h>
18 #include <sys/types.h>
19 #include <errno.h>
20 
21 #if !defined (WIN32) || defined(__CYGWIN__)
22 #include <sys/ioctl.h>
23 #include <sys/uio.h>
24 #include <sys/socket.h>
25 #include <netinet/in.h>
26 #include <netdb.h>
27 #include <arpa/inet.h>
28 #include <sys/time.h>
29 #include <net/if.h>
30 #include <netdb.h>
31 #endif
32 
33 #include <string.h>
34 
35 #if defined(__linux)
36     #include <unistd.h>
37     #include <linux/sockios.h>
38 #elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
39     #include <unistd.h>
40     #include <sys/sockio.h>
41 #elif defined(__sgi)
42     #include <unistd.h>
43     #include <net/soioctl.h>
44 #elif defined(__CYGWIN__)
45     #include <unistd.h>
46 #elif defined (__GNU__)
47     #include <unistd.h>
48 #elif defined(__sun)
49     #include <unistd.h>
50     #include <sys/sockio.h>
51 #elif defined (__APPLE__)
52     #include <unistd.h>
53     #include <sys/sockio.h>
54 #elif defined (WIN32)
55     #include <winsock.h>
56     #include <stdio.h>
57 #elif defined (__hpux)
58     #include <unistd.h>
59 #else
60     #error Teach me how to build on this system
61 #endif
62 
63 #include <stdio.h>
64 #include <fcntl.h>
65 #include <sys/types.h>
66 #if defined (WIN32) && !defined(__CYGWIN__)
67 #include <winsock.h>
68 #else
69 #include <unistd.h>
70 #include <sys/uio.h>
71 #include <sys/socket.h>
72 #include <netinet/in.h>
73 #include <netdb.h>
74 #include <arpa/inet.h>
75 #include <sys/time.h>
76 #endif
77 #include <string.h>
78 
79 #include <osg/io_utils>
80 #include <iostream>
81 
82 const unsigned int CameraPacket::MAX_NUM_EVENTS = 10;
83 const unsigned int CameraPacket::SWAP_BYTES_COMPARE = 0x12345678;
84 
write(const osg::FrameStamp & fs)85 void DataConverter::write(const osg::FrameStamp& fs)
86 {
87     osg::notify(osg::NOTICE)<<"writeFramestamp = "<<fs.getFrameNumber()<<" "<<fs.getReferenceTime()<<std::endl;
88 
89     writeUInt(fs.getFrameNumber());
90     writeDouble(fs.getReferenceTime());
91 }
92 
read(osg::FrameStamp & fs)93 void DataConverter::read(osg::FrameStamp& fs)
94 {
95     fs.setFrameNumber(readUInt());
96     fs.setReferenceTime(readDouble());
97 
98     osg::notify(osg::NOTICE)<<"readFramestamp = "<<fs.getFrameNumber()<<" "<<fs.getReferenceTime()<<std::endl;
99 }
100 
write(const osg::Matrix & matrix)101 void DataConverter::write(const osg::Matrix& matrix)
102 {
103     writeDouble(matrix(0,0));
104     writeDouble(matrix(0,1));
105     writeDouble(matrix(0,2));
106     writeDouble(matrix(0,3));
107 
108     writeDouble(matrix(1,0));
109     writeDouble(matrix(1,1));
110     writeDouble(matrix(1,2));
111     writeDouble(matrix(1,3));
112 
113     writeDouble(matrix(2,0));
114     writeDouble(matrix(2,1));
115     writeDouble(matrix(2,2));
116     writeDouble(matrix(2,3));
117 
118     writeDouble(matrix(3,0));
119     writeDouble(matrix(3,1));
120     writeDouble(matrix(3,2));
121     writeDouble(matrix(3,3));
122 
123     osg::notify(osg::NOTICE)<<"writeMatrix = "<<matrix<<std::endl;
124 
125 }
126 
read(osg::Matrix & matrix)127 void DataConverter::read(osg::Matrix& matrix)
128 {
129     matrix(0,0) = readDouble();
130     matrix(0,1) = readDouble();
131     matrix(0,2) = readDouble();
132     matrix(0,3) = readDouble();
133 
134     matrix(1,0) = readDouble();
135     matrix(1,1) = readDouble();
136     matrix(1,2) = readDouble();
137     matrix(1,3) = readDouble();
138 
139     matrix(2,0) = readDouble();
140     matrix(2,1) = readDouble();
141     matrix(2,2) = readDouble();
142     matrix(2,3) = readDouble();
143 
144     matrix(3,0) = readDouble();
145     matrix(3,1) = readDouble();
146     matrix(3,2) = readDouble();
147     matrix(3,3) = readDouble();
148 
149     osg::notify(osg::NOTICE)<<"readMatrix = "<<matrix<<std::endl;
150 
151 }
152 
write(const osgGA::GUIEventAdapter & event)153 void DataConverter::write(const osgGA::GUIEventAdapter& event)
154 {
155     writeUInt(event.getEventType());
156     writeUInt(event.getKey());
157     writeUInt(event.getButton());
158     writeInt(event.getWindowX());
159     writeInt(event.getWindowY());
160     writeUInt(event.getWindowWidth());
161     writeUInt(event.getWindowHeight());
162     writeFloat(event.getXmin());
163     writeFloat(event.getYmin());
164     writeFloat(event.getXmax());
165     writeFloat(event.getYmax());
166     writeFloat(event.getX());
167     writeFloat(event.getY());
168     writeUInt(event.getButtonMask());
169     writeUInt(event.getModKeyMask());
170     writeDouble(event.getTime());
171 }
172 
read(osgGA::GUIEventAdapter & event)173 void DataConverter::read(osgGA::GUIEventAdapter& event)
174 {
175     event.setEventType((osgGA::GUIEventAdapter::EventType)readUInt());
176     event.setKey(readUInt());
177     event.setButton(readUInt());
178     int x = readInt();
179     int y = readInt();
180     int width = readUInt();
181     int height = readUInt();
182     event.setWindowRectangle(x,y,width,height);
183     float xmin = readFloat();
184     float ymin = readFloat();
185     float xmax = readFloat();
186     float ymax = readFloat();
187     event.setInputRange(xmin,ymin,xmax,ymax);
188     event.setX(readFloat());
189     event.setY(readFloat());
190     event.setButtonMask(readUInt());
191     event.setModKeyMask(readUInt());
192     event.setTime(readDouble());
193 }
194 
write(CameraPacket & cameraPacket)195 void DataConverter::write(CameraPacket& cameraPacket)
196 {
197     writeUInt(cameraPacket._byte_order);
198 
199     writeUInt(cameraPacket._masterKilled);
200 
201     write(cameraPacket._matrix);
202     write(cameraPacket._frameStamp);
203 
204     writeUInt(cameraPacket._events.size());
205     for(osgGA::EventQueue::Events::iterator itr = cameraPacket._events.begin();
206         itr != cameraPacket._events.end();
207         ++itr)
208     {
209         osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter();
210         if (event) write(*(event));
211     }
212 }
213 
read(CameraPacket & cameraPacket)214 void DataConverter::read(CameraPacket& cameraPacket)
215 {
216     cameraPacket._byte_order = readUInt();
217     if (cameraPacket._byte_order != CameraPacket::SWAP_BYTES_COMPARE)
218     {
219         _swapBytes = !_swapBytes;
220     }
221 
222     cameraPacket._masterKilled = readUInt()!=0;
223 
224     read(cameraPacket._matrix);
225     read(cameraPacket._frameStamp);
226 
227     cameraPacket._events.clear();
228     unsigned int numEvents = readUInt();
229     for(unsigned int i=0;i<numEvents;++i)
230     {
231         osgGA::GUIEventAdapter* event = new osgGA::GUIEventAdapter;
232         read(*(event));
233         cameraPacket._events.push_back(event);
234     }
235 }
236 
readEventQueue(osgViewer::Viewer & viewer)237 void CameraPacket::readEventQueue(osgViewer::Viewer& viewer)
238 {
239     _events.clear();
240 
241     viewer.getEventQueue()->copyEvents(_events);
242 
243     osg::notify(osg::INFO)<<"written events = "<<_events.size()<<std::endl;
244 }
245 
writeEventQueue(osgViewer::Viewer & viewer)246 void CameraPacket::writeEventQueue(osgViewer::Viewer& viewer)
247 {
248     osg::notify(osg::INFO)<<"received events = "<<_events.size()<<std::endl;
249 
250     // copy the events to osgProducer style events.
251     viewer.getEventQueue()->appendEvents(_events);
252 }
253 
254 
255 //////////////////////////////////////////////////////////////////////////////
256 //
257 //  Receiver
258 //
Receiver(void)259 Receiver::Receiver( void )
260 {
261     _port = 0;
262     _initialized = false;
263     _buffer = 0L;
264 }
265 
~Receiver(void)266 Receiver::~Receiver( void )
267 {
268 #if defined (WIN32) && !defined(__CYGWIN__)
269     closesocket( _so);
270 #else
271     close( _so );
272 #endif
273 }
274 
init(void)275 bool Receiver::init( void )
276 {
277 #if defined(WIN32) && !defined(__CYGWIN__)
278     WORD version = MAKEWORD(1,1);
279     WSADATA wsaData;
280     // First, we start up Winsock
281     WSAStartup(version, &wsaData);
282 #endif
283 
284     if( _port == 0 )
285     {
286     fprintf( stderr, "Receiver::init() - port not defined\n" );
287     return false;
288     }
289 
290     if( (_so = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
291     {
292         perror( "Socket" );
293     return false;
294     }
295 
296     int result = 0;
297 
298 #if defined (WIN32) && !defined(__CYGWIN__)
299 //    const BOOL on = TRUE;
300 //    setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, (const char*) &on, sizeof(int));
301 #else
302     int on = 1;
303     result = setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
304 #endif
305 
306     if (result)
307     {
308         OSG_NOTICE<<"Warning: Reciever::init() setsockopt(..) failed, errno="<<errno<<std::endl;
309         return false;
310     }
311 
312 //    struct sockaddr_in saddr;
313     saddr.sin_family = AF_INET;
314     saddr.sin_port   = htons( _port );
315 #if defined (WIN32) && !defined(__CYGWIN__)
316     saddr.sin_addr.s_addr =  htonl(INADDR_ANY);
317 #else
318     saddr.sin_addr.s_addr =  0;
319 #endif
320 
321     if( bind( _so, (struct sockaddr *)&saddr, sizeof( saddr )) < 0 )
322     {
323         perror( "bind" );
324         return false;
325     }
326 
327     _initialized = true;
328     return _initialized;
329 }
330 
331 
setPort(const short port)332 void Receiver::setPort( const short port )
333 {
334     _port = port;
335 }
336 
setBuffer(void * buffer,const unsigned int size)337 void Receiver::setBuffer( void *buffer, const unsigned int size )
338 {
339     _buffer = buffer;
340     _buffer_size = size;
341 }
342 
sync(void)343 void Receiver::sync( void )
344 {
345     if(!_initialized) init();
346 
347     if( _buffer == 0L )
348     {
349         fprintf( stderr, "Receiver::sync() - No buffer\n" );
350         return;
351     }
352 
353 #if defined(__linux) || defined(__FreeBSD__) || defined( __APPLE__ ) || \
354     defined(__DragonFly__) || defined(__FreeBSD_kernel__) || defined(__GNU__)
355     socklen_t
356 #else
357     int
358 #endif
359         size = sizeof( struct sockaddr_in );
360 
361     fd_set fdset;
362     FD_ZERO( &fdset );
363     FD_SET( _so, &fdset );
364 
365     struct timeval tv;
366     tv.tv_sec = 0;
367     tv.tv_usec = 0;
368 
369 #if defined (WIN32) && !defined(__CYGWIN__)
370 //    saddr.sin_port   = htons( _port );
371     int result = recvfrom( _so, (char *)_buffer, _buffer_size, 0, (sockaddr*)&saddr, &size );
372 //    recvfrom(sock_Receive, szMessage, 256, 0, (sockaddr*)&addr_Cli, &clilen)
373     //int err = WSAGetLastError ();
374     //int *dum = (int*) _buffer;
375 
376     if (result<0)
377     {
378         OSG_NOTICE<<"Warning: Receiver::sync() recvfrom(..) failed, errno="<<errno<<std::endl;
379         return;
380     }
381 
382     while( select( _so+1, &fdset, 0L, 0L, &tv ) )
383     {
384         if( FD_ISSET( _so, &fdset ) )
385         {
386             recvfrom( _so, (char *)_buffer, _buffer_size, 0, (sockaddr*)&saddr, &size );
387         }
388     }
389 #else
390     int result = recvfrom( _so, (caddr_t)_buffer, _buffer_size, 0, 0, &size );
391     if (result<0)
392     {
393         OSG_NOTICE<<"Warning: Receiver::sync() recvfrom(..) failed, errno="<<errno<<std::endl;
394         return;
395     }
396 
397     while( select( _so+1, &fdset, 0L, 0L, &tv ) )
398     {
399         if( FD_ISSET( _so, &fdset ) )
400         {
401             recvfrom( _so, (caddr_t)_buffer, _buffer_size, 0, 0, &size );
402         }
403     }
404 #endif
405 }
406 
407 
408 //////////////////////////////////////////////////////////////////////////////
409 //
410 //  Broadcaster
411 //
Broadcaster(void)412 Broadcaster::Broadcaster( void )
413 {
414     _port = 0;
415     _initialized = false;
416     _buffer = 0L;
417     _address = 0;
418 }
419 
~Broadcaster(void)420 Broadcaster::~Broadcaster( void )
421 {
422 #if defined (WIN32) && !defined(__CYGWIN__)
423     closesocket( _so);
424 #else
425     close( _so );
426 #endif
427 }
428 
init(void)429 bool Broadcaster::init( void )
430 {
431 #if defined (WIN32) && !defined(__CYGWIN__)
432     WORD version = MAKEWORD(1,1);
433     WSADATA wsaData;
434     // First, we start up Winsock
435     WSAStartup(version, &wsaData);
436 #endif
437 
438     if( _port == 0 )
439     {
440         fprintf( stderr, "Broadcaster::init() - port not defined\n" );
441         return false;
442     }
443 
444     if( (_so = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
445     {
446         perror( "Socket" );
447         return false;
448     }
449 #if defined (WIN32) && !defined(__CYGWIN__)
450     const BOOL on = TRUE;
451 #else
452     int on = 1;
453 #endif
454 
455     int result = 0;
456 
457 #if defined (WIN32) && !defined(__CYGWIN__)
458     result = setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(int));
459 #else
460     result = setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
461 #endif
462 
463     if (result) return false;
464 
465     saddr.sin_family = AF_INET;
466     saddr.sin_port   = htons( _port );
467     if( _address == 0 )
468     {
469 #if defined (WIN32) && !defined(__CYGWIN__)
470         result = setsockopt( _so, SOL_SOCKET, SO_BROADCAST, (const char *) &on, sizeof(int));
471 #else
472         result = setsockopt( _so, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
473 #endif
474         if (result) return false;
475 
476 #if !defined (WIN32) || defined(__CYGWIN__)
477         struct ifreq ifr;
478 #endif
479 #if defined (__linux) || defined(__CYGWIN__)
480         strcpy( ifr.ifr_name, "eth0" );
481 #elif defined(__sun)
482         strcpy( ifr.ifr_name, "hme0" );
483 #elif !defined (WIN32)
484         strcpy( ifr.ifr_name, "ef0" );
485 #endif
486 #if defined (WIN32) // get the server address
487         saddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
488     }
489 #else
490         if( (ioctl( _so, SIOCGIFBRDADDR, &ifr)) < 0 )
491         {
492             perror( "Broadcaster::init() Cannot get Broadcast Address" );
493             return false;
494         }
495             saddr.sin_addr.s_addr = (((sockaddr_in *)&ifr.ifr_broadaddr)->sin_addr.s_addr);
496         }
497         else
498         {
499             saddr.sin_addr.s_addr = _address;
500         }
501 #endif
502 #define _VERBOSE 1
503 #ifdef _VERBOSE
504     unsigned char *ptr = (unsigned char *)&saddr.sin_addr.s_addr;
505     printf( "Broadcast address : %u.%u.%u.%u\n", ptr[0], ptr[1], ptr[2], ptr[3] );
506 #endif
507 
508     _initialized = true;
509     return _initialized;
510 }
511 
setHost(const char * hostname)512 void Broadcaster::setHost( const char *hostname )
513 {
514     struct hostent *h;
515     if( (h = gethostbyname( hostname )) == 0L )
516     {
517         fprintf( stderr, "Broadcaster::setHost() - Cannot resolv an address for \"%s\".\n", hostname );
518         _address = 0;
519     }
520     else
521         _address = *(( unsigned long  *)h->h_addr);
522 }
523 
setPort(const short port)524 void Broadcaster::setPort( const short port )
525 {
526     _port = port;
527 }
528 
setBuffer(void * buffer,const unsigned int size)529 void Broadcaster::setBuffer( void *buffer, const unsigned int size )
530 {
531     _buffer = buffer;
532     _buffer_size = size;
533 }
534 
sync(void)535 void Broadcaster::sync( void )
536 {
537     if(!_initialized) init();
538 
539     if( _buffer == 0L )
540     {
541         fprintf( stderr, "Broadcaster::sync() - No buffer\n" );
542         return;
543     }
544 
545     int result = 0;
546 #if defined (WIN32) && !defined(__CYGWIN__)
547     unsigned int size = sizeof( SOCKADDR_IN );
548     result = sendto( _so, (const char *)_buffer, _buffer_size, 0, (struct sockaddr *)&saddr, size );
549     // int err = WSAGetLastError ();
550     // int *dum = (int*) _buffer;
551 #else
552     unsigned int size = sizeof( struct sockaddr_in );
553     result = sendto( _so, (const void *)_buffer, _buffer_size, 0, (struct sockaddr *)&saddr, size );
554 #endif
555 
556     if (result)
557     {
558         OSG_NOTICE<<"Warning: sentTo(...) failed : errno="<<errno<<std::endl;
559     }
560 }
561