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