DiscoveryUdpMessage.cpp

Go to the documentation of this file.

/** @file    DiscoveryUdpMessage.cpp
 *  @author  Alessandro Polo
 *  @version $Id: DiscoveryUdpMessage.cpp 3775 2011-01-01 16:38:17Z alex $
 *  @brief
 * File containing methods for the DiscoveryUdpMessage class.
 * The header for this class can be found in DiscoveryUdpMessage.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 "DiscoveryUdpMessage.h"
 #include <core/Utilities.h>
 #include <string.h>


using namespace std;
using namespace wosh;


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

long DiscoveryUdpFormat::isValidPacket( const char* data, int maxSize ) {
    if ( data == NULL) return 0;
    static const int len = strlen(_DiscoveryUdpFormat_PacketHeader);
    if ( maxSize < len ) return 0;
    if ( strncmp(_DiscoveryUdpFormat_PacketHeader, data, len) != 0 ) return 0;
    data += len;
    data += sizeof(char)*2;
    int32 proto = 0;
    memcpy( &proto, data, sizeof(int32) );
    return proto;
 }

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

int DiscoveryUdpFormat::writeHeader( char* out_data, int maxSize ) const {
    if ( out_data == NULL ) return 0;
    static const int len = strlen(_DiscoveryUdpFormat_PacketHeader);
    if ( maxSize < (int)(len+sizeof(char)*2+sizeof(int32)) ) return 0;
    strcpy(out_data, _DiscoveryUdpFormat_PacketHeader);
    out_data += len;
    memset( out_data, 0, sizeof(char)*2 );
    out_data += sizeof(char)*2;
    int32 proto = getProtocolVersion();
    memcpy( out_data, &proto, sizeof(int32) );
    return len + sizeof(char)*2 + sizeof(int32);
 }

int DiscoveryUdpFormat::headerSize() const {
    return strlen(_DiscoveryUdpFormat_PacketHeader) + sizeof(char)*2 + sizeof(int32);
 }

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

char* DiscoveryUdpFormat::putInt( long value, char* data, int maxSize ) {
    if ( maxSize < (int)sizeof(int32) ) return data;
    int32 tmpInteger = value;
    memcpy( data, &tmpInteger, sizeof(int32) );
    memset( data+sizeof(char)*2, 0, sizeof(char)*2 );
    return data + sizeof(char)*2 + sizeof(int32);
 }

const char* DiscoveryUdpFormat::popInt( long& value, const char* data, int maxSize ) {
    if ( maxSize < (int)sizeof(int32) ) return data;
    int32 tmpInteger = value;
    memcpy( &tmpInteger, data, sizeof(int32) );
    value = tmpInteger;
    return data + sizeof(char)*2 + sizeof(int32);
 }

char* DiscoveryUdpFormat::putString( const std::string& value, char* data, int maxSize ) {
    if ( maxSize < (int)value.size() ) return data;
    memcpy( data, value.c_str(), value.size() );
    memset( data+value.size()+sizeof(char), 0, sizeof(char)*2 );
    return data + value.size() + sizeof(char)*2;
 }

const char* DiscoveryUdpFormat::popString( std::string& value, const char* data, int maxSize ) {
        if ( maxSize < (int)sizeof(char)*2 ) return data;
    value.assign(data);
    return data + value.size() + sizeof(char)*2;
 }

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

bool DiscoveryUdpFormat_84::isRequest( const char* data, int maxSize ) {
    if ( data == NULL) return false;
    int offset = headerSize();
    if ( offset >= maxSize ) return false;
    if ( strcmp(data+offset, _DiscoveryUdpFormat_PacketRequest) == 0 ) return true;
    return false;
 }

WRESULT DiscoveryUdpFormat_84::encode( wosh::WoshDiscoveryInfo& d_info, wosh::WoshDiscoveryData& d_data, char* out_data, int& out_size, int buffer_size ) {
    if ( out_data == NULL) return WRET_ERR_PARAM;
    char* outp = out_data + writeHeader(out_data, buffer_size);

    outp = putString( d_data.getKernelName(), outp, buffer_size-(outp-out_data) );
    outp = putInt( d_data.getKernelState(), outp, buffer_size-(outp-out_data) );
    outp = putInt( d_info.getNotifyFrequency(), outp, buffer_size-(outp-out_data) );
    outp = putString( d_info.getLocalProtocol(), outp, buffer_size-(outp-out_data) );
    
    string protocols; String::join(protocols, d_data.protocols, ";;");
    outp = putString( protocols, outp, buffer_size-(outp-out_data) );

    string neighbours; String::join(neighbours, d_data.neighbours, ";");
    outp = putString( neighbours, outp, buffer_size-(outp-out_data) );

    memset(outp, 0, sizeof(char)*2);
    out_size = outp - out_data + sizeof(char)*2;
    return WRET_OK;
 }

WRESULT DiscoveryUdpFormat_84::decode( wosh::WoshDiscoveryInfo& d_info, wosh::WoshDiscoveryData& d_data, const char* data, int maxSize ) {
    if ( data == NULL) return WRET_ERR_PARAM;
    const char* inp = data + headerSize();
    string bufferStr; long bufferLong;
    bufferStr.clear();
    inp = popString(bufferStr, inp, maxSize-(inp-data) ); d_data.setKernelName(bufferStr);
    bufferStr.clear();
    inp = popInt(bufferLong, inp, maxSize-(inp-data) ); d_data.setKernelState(bufferLong);
    bufferStr.clear();
    inp = popInt(bufferLong, inp, maxSize-(inp-data) ); d_info.setNotifyFrequency(bufferLong);
    bufferStr.clear();
    inp = popString(bufferStr, inp, maxSize-(inp-data) ); d_info.setLocalProtocol(bufferStr);
    bufferStr.clear();
    d_data.protocols.clear();
    inp = popString(bufferStr, inp, maxSize-(inp-data) );
    wosh::String::split(d_data.protocols, bufferStr, ";;", _String_SPLIT_OPTION_NOT_EMPTY | _String_SPLIT_OPTION_TRIM | _String_SPLIT_OPTION_UNIQUE );
    bufferStr.clear();
    d_data.neighbours.clear();
    inp = popString(bufferStr, inp, maxSize-(inp-data) );
    wosh::String::split(d_data.neighbours, bufferStr, ";", _String_SPLIT_OPTION_NOT_EMPTY | _String_SPLIT_OPTION_TRIM | _String_SPLIT_OPTION_UNIQUE );
    return WRET_OK;
 }

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

bool DiscoveryUdpFormat_85::isRequest( const char* data, int maxSize ) {
    if ( data == NULL) return false;
    (void)maxSize;
    return false;
 }

WRESULT DiscoveryUdpFormat_85::encode( wosh::WoshDiscoveryInfo& d_info, wosh::WoshDiscoveryData& d_data, char* out_data, int& out_size, int buffer_size ) {
    if ( out_data == NULL) return WRET_ERR_PARAM;
    (void)d_info; (void)d_data; (void)out_size; (void)buffer_size;
    return WRET_NOT_IMPLEMENTED;
 }

WRESULT DiscoveryUdpFormat_85::decode( wosh::WoshDiscoveryInfo& d_info, wosh::WoshDiscoveryData& d_data, const char* data, int maxSize ) {
    if ( data == NULL) return WRET_ERR_PARAM;
    (void)d_info; (void)d_data; (void)maxSize;
    return WRET_NOT_IMPLEMENTED;
 }

///////////////////////////////////////////////////////////////////////////////////////////////////// SETTERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////// GETTERS


///////////////////////////////////////////////////////////////////////////////////////////////////// GETTERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

DiscoveryUdpMessageRequest::DiscoveryUdpMessageRequest() {
    this->buffer_size = strlen(_DiscoveryUdpFormat_PacketHeader);
    this->buffer = new char[this->buffer_size+1];
    memset(this->buffer, 0, this->buffer_size+1);
    memcpy(this->buffer, _DiscoveryUdpFormat_PacketHeader, this->buffer_size);
 }

DiscoveryUdpMessageRequest::~DiscoveryUdpMessageRequest() {
    delete this->buffer; this->buffer = NULL;
 }

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