source: osgVisual/src/cluster/dataIO_clusterUDP_Transmission.cpp @ 62

/* -*-c++-*- osgVisual - Copyright (C) 2009-2010 Torben Dannhauer
 *
 * This library is based on OpenSceneGraph, open source and may be redistributed and/or modified under 
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * osgVisual requires for some proprietary modules a license from the correspondig manufacturer.
 * You have to aquire licenses for all used proprietary modules.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/

#include "dataIO_clusterUDP_Transmission.h"

using namespace osgVisual;


Broadcaster::Broadcaster()
{
    _initialized = false;
    _destinationAddress = 0;
        requestedWSAVersion = MAKEWORD(2,0);
}

Broadcaster::~Broadcaster()
{
    closesocket( _so);
}

bool Broadcaster::init(const short port_)
{
    WSADATA wsaData;

    // First, we start up Winsock
    WSAStartup(requestedWSAVersion, &wsaData);

    if( port_ == 0 )
    {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Broadcaster::init() - port not defined: " << std::endl;
        return false;
    }

        // Create Socket
    if( (_so = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
    {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Broadcaster::init() - Unable to create socket!" << std::endl;
        return false;
    }
    const BOOL on = TRUE;

        // Set Socket options
    setsockopt( _so, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(int));
    saddr.sin_family = AF_INET; // Internetwork UDP, TCP etc.
    saddr.sin_port   = htons( port_ );  // Port festlegen
    if( _destinationAddress == 0 )      // Wenn keine Zieladresse festgelegt: Broadcasten
    {
        setsockopt( _so, SOL_SOCKET, SO_BROADCAST, (const char *) &on, sizeof(int));
        saddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    }

        // Print out destination address
    unsigned char *ptr = (unsigned char *)&saddr.sin_addr.s_addr;
        OSG_NOTIFY( osg::ALWAYS ) << "INFO: Broadcaster::init() - Broadcast address = " << (unsigned int)ptr[0] << "." << (unsigned int)ptr[1] << "." << (unsigned int)ptr[2] << "." << (unsigned int)ptr[3] << std::endl;

        // Note: Initialization finished.
    _initialized = true;
    return _initialized;
}

void Broadcaster::setDestinationHost( const char *hostname )
{
    struct hostent *h;
    if( (h = gethostbyname( hostname )) == 0L )
    {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Broadcaster::setHost() - Cannot resolve an address for " << hostname;
        _destinationAddress = 0;
    }
    else
        _destinationAddress = *(( unsigned long  *)h->h_addr);
}

void Broadcaster::transmitBuffer( const char* buffer_, const unsigned int size_ )
{
    if(!_initialized) 
        {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Broadcaster not initialized!" << std::endl;
                return;
        }

    if( buffer_ == NULL )
    {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Broadcaster::transmitBuffer() - No buffer" << std::endl;
        return;
    }

    unsigned int addrSize = sizeof( SOCKADDR_IN );
    sendto( _so, buffer_, size_, 0, (struct sockaddr *)&saddr, addrSize );
    int err = WSAGetLastError ();
    if (err!=0)
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Broadcaster::transmitBuffer() - Error #: " << err << std::endl;
}

//
//--------------------------------------------------------
//

Receiver::Receiver( void )
{
    _initialized = false;
        requestedWSAVersion = MAKEWORD(2,0);
}

Receiver::~Receiver( void )
{
    closesocket( _so);
}

bool Receiver::init( const short port_ )
{
    WSADATA wsaData;
    // First, we start up Winsock
    WSAStartup(requestedWSAVersion, &wsaData);

        if( port_ == 0 )
    {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Receiver::init() - port not defined: " << std::endl;
        return false;
    }

        // Create Socket
    if( (_so = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
    {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Receiver::init() -Could not create Socket" << std::endl;
                return false;
    }

        // Set Socket Protocolfamily and Protocoldata (IP address, port, etc.)
    //// Protokollfamilie
        saddr.sin_family = AF_INET;
    //// Port:
        saddr.sin_port   = htons( port_ );      // The htons function converts a u_short from host to TCP/IP network byte order (which is big-endian)
        //////Socketadresse. INADDR_ANY ist das Schlüsselwort für 0x00000000 und bindet den Socket auf alle lokalen IP-Adressen:
        saddr.sin_addr.s_addr =  htonl(INADDR_ANY);             // The htonl function converts a u_long from host to TCP/IP network byte order (which is big endian).
 

        // Bind socket to local address and port.
    if( bind( _so, (struct sockaddr *)&saddr, sizeof( saddr )) < 0 )
    {
        OSG_NOTIFY( osg::FATAL ) << "ERROR: Receiver::init() - Could not bind Socket" << std::endl;
        return false;
    }

        // Note: Initialization finished.
    _initialized = true;
    return _initialized;
}

void Receiver::waitBlockingforSocketData( std::stringstream& writeInto_ )
{
        if(!_initialized) 
        {
                OSG_NOTIFY( osg::FATAL ) << "ERROR: Receiver not initialized!" << std::endl;
                return;
        }

        // ?? Size des Addresspaketes ermitteln
    int size = sizeof( struct sockaddr_in );

    fd_set fdset;       // Filedescriptor Set
    FD_ZERO( &fdset );  // Initialisiert das FDS als Null
    FD_SET( _so, &fdset );      // Fügt dem FDS ein FileDescriptor hinzu

        // Set Timeintervall for select() timeout
    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 0;

        // In einer Schleife: Solange lesen bis keine Daten mehr in dem Socket warten.
    while( select( _so, &fdset, 0L, 0L, &tv ) ) // <0: error, =0 timeout, >0: socket to read
    {
        if( FD_ISSET( _so, &fdset ) )
        {
            int ret = recvfrom( _so, buffer, 65000, 0, (sockaddr*)&saddr, &size );
                        // check for size
                        if (ret > 0)
                        {
                                writeInto_.str("");
                                OSG_NOTIFY( osg::INFO ) <<  "Receiver::waitBlockingforSocketData() - Empfangene Bytes:" << ret << std::endl;
                                for(int i=0;i<ret;i++)
                                        writeInto_ << buffer[i];
                        }
                        else
                        {
                                int err = WSAGetLastError ();
                                if (err!=0) 
                                        OSG_NOTIFY( osg::FATAL ) <<  "Receiver::waitBlockingforSocketData() - Error #" << err << std::endl;
                        }
                }       // END IF_ISSET
    }
        OSG_NOTIFY( osg::INFO ) << "Socket leergelesen!" << std::endl;
}