services.h

Go to the documentation of this file.

/*
    Ishtar - A network transparent read/write interface with
    probing and enumeration support.
    service part : network transparent access to generic services
    Copyright (C) 2003-2005 Stephane Magnenat <nct@ysagoon.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/*
    Services defintion

    All things to have services working
*/

#ifndef __ISHTAR_SERVICES_H
#define __ISHTAR_SERVICES_H

#include <ishtar/network.h>

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <assert.h>


namespace Ishtar
{
    const UInt32 PROTOCOL_VERSION = 2;
    
    // Vector value handling
    // =====================
    
    struct ValueVector
    {
        enum Type
        {
            INT=0,
            UINT,
            SHORT,
            USHORT,
            CHAR,
            UCHAR,
            FLOAT,
            DOUBLE,
            BOOL
        };
    
        virtual ~ValueVector() { }
    
        virtual void serialize(OutputStream *stream) const = 0;
        virtual void serializeSpecified(OutputStream *stream) const = 0;
        virtual void deserializeSpecified(InputStream *stream) = 0;
    
        virtual std::string toString(unsigned index) const = 0;
        virtual void fromString(unsigned index, const std::string &s) = 0;
    
        virtual Type getType(void) const = 0;
        virtual Size size(void) const = 0;
    
        static ValueVector *newOfType(Type type, Size size = 0);
        static ValueVector *deserialize(InputStream *stream);
    };
    
    template<typename ST>
    struct TypeSerializer
    {
        template<typename T>
        static void writeToStream(OutputStream *stream, T v)
        {
            ST sv = static_cast<ST>(v);
            stream->writeEndianIndependant(sv);
        }
        
        template<typename T>
        static void readFromStream(InputStream *stream, T *vRef)
        {
            ST sv = stream->readEndianIndependant<ST>();
            *vRef = static_cast<T>(sv);
        }
    };


    template<>
    struct TypeSerializer<double>
    {
        template<typename T>
        static void writeToStream(OutputStream *stream, T v)
        {
            double sv = static_cast<double>(v);
            stream->writeDouble(sv);
        }
        
        template<typename T>
        static void readFromStream(InputStream *stream, T *vRef)
        {
            double sv = stream->readDouble();
            *vRef = static_cast<T>(sv);
        }
    };
        
    template<typename T> struct TypeResolver { };
    template<> struct TypeResolver<Int32> : public TypeSerializer<Int32> { static const ValueVector::Type type = ValueVector::INT; };
    template<> struct TypeResolver<UInt32> : public TypeSerializer<UInt32> { static const ValueVector::Type type = ValueVector::UINT; };
    template<> struct TypeResolver<Int16> : public TypeSerializer<Int16> { static const ValueVector::Type type = ValueVector::SHORT; };
    template<> struct TypeResolver<UInt16> : public TypeSerializer<UInt16> { static const ValueVector::Type type = ValueVector::USHORT; };
    template<> struct TypeResolver<Int8> : public TypeSerializer<Int8> { static const ValueVector::Type type = ValueVector::CHAR; };
    template<> struct TypeResolver<UInt8> : public TypeSerializer<UInt8> { static const ValueVector::Type type = ValueVector::UCHAR; };
    template<> struct TypeResolver<float> : public TypeSerializer<float> { static const ValueVector::Type type = ValueVector::FLOAT; };
    template<> struct TypeResolver<double> : public TypeSerializer<double> { static const ValueVector::Type type = ValueVector::DOUBLE; };
    template<> struct TypeResolver<bool> : public TypeSerializer<UInt8> { static const ValueVector::Type type = ValueVector::BOOL; };
    
    template<typename T>
    struct ValueVectorTemplate: public ValueVector
    {
    public:
        std::vector<T> value;
    
        ValueVectorTemplate(Size size) { value.resize(size); }
    
        virtual void serialize(OutputStream *stream) const
        {
            stream->writeUInt32(TypeResolver<T>::type);
            serializeSpecified(stream);
        }
    
        virtual void serializeSpecified(OutputStream *stream) const
        {
            stream->writeUInt32(static_cast<UInt32>(value.size()));
            for (size_t i=0; i<value.size(); i++)
            {
                TypeResolver<T>::writeToStream(stream, value[i]);
            }
        }
    
        virtual void deserializeSpecified(InputStream *stream)
        {
            size_t size = stream->readUInt32();
            value.resize(size);
            for (size_t i=0; i<size; i++)
            {
                T v;
                TypeResolver<T>::readFromStream(stream, &v);
                value[i] = v;
            }
        }
    
        virtual std::string toString(unsigned index) const
        {
            std::ostringstream oss; oss << value.at(index);
            return oss.str();
        }
    
        virtual void fromString(unsigned index, const std::string &s)
        {
            std::istringstream iss(s);
            T v;
            iss >> v;
            value.at(index) = v;
        }
    
        virtual Size size(void) const
        {
            return value.size();
        }
        
        virtual Type getType(void) const
        {
            return TypeResolver<T>::type;
        }
    };
    
    typedef ValueVectorTemplate<Int32> IntValueVector;
    typedef ValueVectorTemplate<float> FloatValueVector;
    
    struct CharValueVector: public ValueVectorTemplate<UInt8>
    {
        CharValueVector(Size size = 0):ValueVectorTemplate<UInt8>(size) { }
        CharValueVector(const std::string &s);
        CharValueVector(const char *s);
        operator std::string() const;
    };
    
    
    // Base service handling
    // =====================
    
    class ServiceDescription
    {
    public:
        enum Flags
        {
            READ_ONLY=0x1,
            NAMED_VALUES=0x2,
            CONSTRAINT_VALUES=0x4,
        };
    
        CharValueVector name;
        ValueVector::Type type;
        UInt32 flags;
        UInt32 length;
        std::vector<CharValueVector> subnames;
        ValueVector *mins;
        ValueVector *maxs;
    
    public:
        ServiceDescription();
        ~ServiceDescription();
        void serialize(OutputStream *stream);
        void deserialize(InputStream *stream);
    };
    
    class Service
    {
    public:
        ServiceDescription description;
    
    public:
        Service() { }
        virtual ~Service() { }
    
        virtual ValueVector *getValues(void) { return NULL; }
        virtual void setValues(ValueVector *values) { }
    };
    
    class ServicesContainer
    {
    public:
        std::map<UInt32, Service *> services;
        std::map<Service *, UInt32> reverseServices;
        std::map<std::string, Service *> namedServices;
        UInt32 maxUID;
    
    public:
        ServicesContainer();
        virtual ~ServicesContainer();
        void addService(Service *s);
        void eraseService(Service *s);
        Service *findService(const std::string &name);
    };
    
    class ServicesServer: public NetworkServer, public ServicesContainer
    {
    protected:
        void incomingData(Socket *socket);
        void connectionClosed(Socket *socket);
        void incomingConnection(Socket *socket);
        
    public:
        ServicesServer(UInt16 port);
        virtual ~ServicesServer();
    };
    
    
    // Network access handling
    // =======================
    
    class Answer
    {
    public:
        enum Type
        {
            ERROR,
            SERVICE_LIST,
            VALUES
        };
    
    public:
        virtual ~Answer() { }
        virtual void serialize(OutputStream *stream) = 0;
        virtual void deserializeSpecified(InputStream *stream) = 0;
        static Answer *deserialize(InputStream *stream);
    };
    
    class Call
    {
    public:
        enum Type
        {
            HELLO=0,
            GET_SERVICE_LIST,
            GET_VALUES,
            SET_VALUES
        };
    
    public:
        virtual ~Call() { }
        virtual void serialize(OutputStream *stream) = 0;
        virtual void deserializeSpecified(InputStream *stream) = 0;
        static Call *deserialize(InputStream *stream);
        virtual Answer *execute(ServicesContainer *registrar) { return NULL; }
    };
    
    class HelloCall : public Call
    {
    public:
        enum NodeType
        {
            SERVER=0,
            CLIENT
        } nodeType;
        UInt32 version;
    
    public:
        HelloCall() { }
        HelloCall(NodeType t) { nodeType = t; version=PROTOCOL_VERSION; }
        virtual ~HelloCall() { }
        virtual void serialize(OutputStream *stream);
        virtual void deserializeSpecified(InputStream *stream);
    };
    
    class ErrorAnswer: public Answer
    {
    public:
        enum ErrorTypes
        {
            SERVICE_DOES_NOT_EXISTS = 0,
        } errorType;
    
    public:
        ErrorAnswer() { }
        ErrorAnswer(ErrorTypes error) { this->errorType = error; }
        virtual ~ErrorAnswer() { }
        virtual void serialize(OutputStream *stream);
        virtual void deserializeSpecified(InputStream *stream);
    };
    
    class GetServicesCall : public Call
    {
    public:
        virtual ~GetServicesCall() { }
        virtual void serialize(OutputStream *stream) { stream->writeUInt32(GET_SERVICE_LIST); }
        virtual void deserializeSpecified(InputStream *stream) { }
    
        virtual Answer *execute(ServicesContainer *registrar);
    };
    
    class ServiceAnswer: public Answer
    {
    public:
        typedef std::map<UInt32, ServiceDescription *> DescriptionMap;
        DescriptionMap descriptions;
    
    public:
        virtual ~ServiceAnswer();
        void deleteDescriptions(void);
        virtual void serialize(OutputStream *stream);
        virtual void deserializeSpecified(InputStream *stream);
    };
    
    class GetValuesCall : public Call
    {
    public:
        Int32 requestID;
        std::vector<UInt32> services;
    
    public:
        GetValuesCall() { requestID=0; }
        virtual ~GetValuesCall() { }
        virtual void serialize(OutputStream *stream);
        virtual void deserializeSpecified(InputStream *stream);
    
        virtual Answer *execute(ServicesContainer *registrar);
    };
    
    class ValuesAnswer: public Answer
    {
    public:
        Int32 requestID;
        typedef std::map<UInt32, ValueVector *> ValueVectorMap;
        ValueVectorMap values;
    
    public:
        virtual ~ValuesAnswer();
        void deleteValues(void);
        virtual void serialize(OutputStream *stream);
        virtual void deserializeSpecified(InputStream *stream);
    };
    
    class SetValuesCall : public Call
    {
    public:
        std::map<UInt32, ValueVector *> values;
    
    public:
        virtual~SetValuesCall();
    
        void deleteValues(void);
        virtual void serialize(OutputStream *stream);
        virtual void deserializeSpecified(InputStream *stream);
    
        virtual Answer *execute(ServicesContainer *registrar);
    };
}

#endif

---