DiscoveryUdpKernelName.cpp

Go to the documentation of this file.

/** @file    DiscoveryUdpKernelName.cpp
 *  @author  Alessandro Polo
 *  @version $Id: DiscoveryUdpKernelName.cpp 3775 2011-01-01 16:38:17Z alex $
 *  @brief
 * File containing methods for the wosh::bundles::DiscoveryUdpKernelName class.
 * The header for this class can be found in DiscoveryUdpKernelName.h, check that file
 * for class description.
 ****************************************************************************/
/* Copyright (c) 2007-2011, WOSH - Wide Open Smart Home 
 * by Alessandro Polo - OpenSmartHome.com
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the OpenSmartHome.com WOSH nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY Alessandro Polo ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Alessandro Polo BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ****************************************************************************/

 #include "DiscoveryUdpKernelName.h"
 #include <core/Thread.h>
 #include <core/Utilities.h>
 #include <core/WoshKernel.h>
 #include <framework/network/NetworkUtilities.h>
 #ifndef DiscoveryUdpKernelName_DynamicSocket
 # ifdef WOSH_NETWORK_CSOCKETS
 #  include <framework/network/csockets/SocketUdpCS.h>
 # endif
 #else
 # include <core/ObjectFactory.h>
 #endif

 
using namespace std;
namespace wosh {
 namespace bundles {

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////// CONSTRUCTORS

DiscoveryUdpKernelName::DiscoveryUdpKernelName() {
    this->timeout = 5000;
    this->bind_addressport = _DiscoveryUdpKernelName_DEFAULT_BindAddressPort;
    this->target_addresses.push_back(_DiscoveryUdpKernelName_DEFAULT_BroadcastAddressPort);

    Log.setContext( "DiscoveryUdpKernelName" );
    Log.setIndent( 2 );
    Log.setLevel( LOG_INFO );
    
 }

DiscoveryUdpKernelName::~DiscoveryUdpKernelName() {
 }

//////////////////////////////////////////////////////////////////////////////////////////////// CONSTRUCTORS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void DiscoveryUdpKernelName::setBaseKernelName( const std::string& name ) {
    this->name_base = name;
    WoshKernel::fixName( this->name_base );
    Log(LOG_VERBOSE, ":setBaseKernelName(%s) Configured %s", name.c_str(), this->name_base.c_str() );
 }

int DiscoveryUdpKernelName::setTargetAddresses( const std::string& addresses ) {
    std::vector<std::string> destinations;
    wosh::String::split(destinations, addresses, ";", _String_SPLIT_OPTION_NOT_EMPTY | _String_SPLIT_OPTION_TRIM | _String_SPLIT_OPTION_UNIQUE );
    return setTargetAddresses(destinations);
 }

int DiscoveryUdpKernelName::setTargetAddresses( const std::vector<std::string>& destinations ) {
    this->target_addresses.clear();
    int errors = 0;
    std::vector<std::string>::const_iterator it;
    for ( it=destinations.begin(); it!=destinations.end(); it++ ) {
        if ( wosh::network::NetworkUtilities::isAddressPortValid(*it, true) )
            this->target_addresses.push_back(*it, true);
        else
            ++errors;
     }
    if ( errors != 0 ) {
        Log(LOG_WARNING, ":setTargetAddresses(%s) Configured %d targets [%d errors]", this->target_addresses.size(), errors );
        return -errors;
     }
    Log(LOG_VERBOSE, ":setTargetAddresses(%s) Configured %d targets", this->target_addresses.size() );
    return this->target_addresses.size();
 }


//////////////////////////////////////////////////////////////////////////////////////////////////////////////

WRESULT DiscoveryUdpKernelName::validateNetworkKernelName() {
    wosh::network::SocketUdp* socket = NULL;

#ifdef DiscoveryUdpKernelName_DynamicSocket
    Log(LOG_DEBUG, ":validateNetworkKernelName() : Creating 'wosh::network::SocketUdp'" );
    socket = ObjectFactory::createTypeOf<wosh::network::SocketUdp>(false);
#elif WOSH_NETWORK_CSOCKETS
    Log(LOG_DEBUG, ":validateNetworkKernelName() : Using 'wosh::network::csockets::SocketUdpCS'" );
    socket = new wosh::network::csockets::SocketUdpCS();
#endif

    if ( socket == NULL ) {
        return WRET_ERR_INTERNAL;
     }
    socket->setListener(this);
    Log(LOG_DEBUG, ":validateNetworkKernelName() : Binding Socket to %s", this->bind_addressport.c_str() );
    WRESULT bound = socket->bindSocket(this->bind_addressport, 30000 );
    if ( WFAILED(bound) ) {
        return WRET_ERR_INTERNAL;
     }
    Log(LOG_INFO, ":validateNetworkKernelName() : Discovering Neighbours.." );
    long timet = this->timeout/500; int ret = 0; int send_cnt = 5;
    VectorT<std::string>::ConstIterator it;
    while( --timet > 0 ) {
        if ( --send_cnt > 0 ) {
            for( it=target_addresses.begin(); it!=target_addresses.end(); ++it ) {
                Log(LOG_DEBUG, ":validateNetworkKernelName() : Broadcasting to %s", (*it).c_str() );
                ret = socket->sendDatagram( *it, this->request.data(), this->request.size() );
             }
         }
        ThreadImpl::sleepForMSec(500);
     }
    socket->unbindSocket();

#ifdef DiscoveryUdpKernelName_DynamicSocket
    ObjectFactory::destroy(socket); socket = NULL;
#else
    delete socket; socket = NULL;
#endif

    Log(LOG_DEBUG, ":validateNetworkKernelName() : Validating name %s against %d known hosts", this->name_base.c_str(), this->names_found.size() );
    this->name_final = this->name_base; int i = 0;
    while( this->names_found.exists(this->name_final) ) {
        this->name_final = this->name_base + String::toString(++i);
     }

    if ( this->names_found.exists(this->name_final) ) {
        Log(LOG_WARNING, ":validateNetworkKernelName() : NOT Validated name %s against %d known hosts", this->name_final.c_str(), this->names_found.size() );
        return WRET_ERR_INTERNAL;
     }
    Log(LOG_INFO, ":validateNetworkKernelName() : Validated name %s", this->name_final.c_str() );
    return WRET_OK;
 }

///////////////////////////////////////////////////////////////////////////////////////////////////// METHODS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void DiscoveryUdpKernelName::udpIncomingDatagram( const char* data, int maxSize, const std::string& source, wosh::network::SocketUdp* ) {
    if ( maxSize == this->request.size() ) {
        // unprotected access to this->request is ok since noone is supposed to edit the object
        if ( strncmp(data, this->request.data(), maxSize) == 0 )
            return;
     }
/*
    DiscoveryUdpMessage message;
    // parse the datagram into temporary representation
    WRESULT loaded = message.loadFrom(data, maxSize);
    if ( WFAILED(loaded) ) {
        Log(LOG_WARNING, ":validateNetworkKernelName() : FAILED#%d loading message from %s [%d bytes]", loaded, source.c_str(), maxSize );
        return;
     }

    Log(LOG_DEBUG, ":validateNetworkKernelName() : Adding Neighbours of %s..", message.getKernelName().c_str() );
    this->names_found.push_back( message.getKernelName(), true );
    std::map<std::string, long> neighb;
    message.getNeighbours(neighb);
    std::map<std::string, long>::const_iterator it;
    for ( it=neighb.begin(); it!=neighb.end(); ++it )
        this->names_found.push_back(it->first, true );
*/
 }

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

WRESULT DiscoveryUdpKernelName::doNameDiscovery( std::string& woshName ) {

    DiscoveryUdpKernelName dkn;
    dkn.setBaseKernelName(woshName);
    dkn.validateNetworkKernelName();
    woshName = dkn.getNameFinal();

    return WRET_OK;
 }

 }; // namespace bundles
}; // namespace wosh