daemon/src/Configuration.h

Go to the documentation of this file.

#ifndef CONFIGURATION_H_
#define CONFIGURATION_H_

#include "ibrcommon/data/ConfigFile.h"
#include "core/Node.h"
#include "routing/StaticRoutingExtension.h"
#include <ibrcommon/Exceptions.h>
#include <ibrcommon/net/vinterface.h>

using namespace dtn::net;
using namespace dtn::core;
using namespace dtn::data;

namespace dtn
{
        namespace daemon
        {
                class Configuration
                {
                private:
                        Configuration();
                        virtual ~Configuration();

                public:
                        class NetConfig
                        {
                        public:
                                enum NetType
                                {
                                        NETWORK_UNKNOWN = 0,
                                        NETWORK_TCP = 1,
                                        NETWORK_UDP = 2,
                                        NETWORK_HTTP = 3,
                                        NETWORK_LOWPAN = 4
                                };

                                NetConfig(std::string name, NetType type, const std::string &url, bool discovery = true);
                                NetConfig(std::string name, NetType type, const ibrcommon::vaddress &address, int port, bool discovery = true);
                                NetConfig(std::string name, NetType type, const ibrcommon::vinterface &iface, int port, bool discovery = true);
                                NetConfig(std::string name, NetType type, int port, bool discovery = true);
                                virtual ~NetConfig();

                                std::string name;
                                NetType type;
                                std::string url;
                                ibrcommon::vinterface interface;
                                ibrcommon::vaddress address;
                                int port;
                                bool discovery;
                        };

                        class ParameterNotSetException : ibrcommon::Exception
                        {
                        };

                        class ParameterNotFoundException : ibrcommon::Exception
                        {
                        };

                        static Configuration &getInstance();

                        void load();
                        void load(string filename);

                        void params(int argc, char *argv[]);

                        string getNodename();

                        int getTimezone();

                        ibrcommon::File getPath(string name);

                        unsigned int getUID();

                        unsigned int getGID();

                        bool doAPI();

                        Configuration::NetConfig getAPIInterface();
                        ibrcommon::File getAPISocket();

                        std::string version();

                        std::string getNotifyCommand();

                        std::string getStorage() const;

                        enum RoutingExtension
                        {
                                DEFAULT_ROUTING = 0,
                                EPIDEMIC_ROUTING = 1,
                                FLOOD_ROUTING = 2
                        };

                        size_t getLimit(std::string);

                        class Extension
                        {
                        protected:
                                virtual void load(const ibrcommon::ConfigFile &conf) = 0;
                        };

                        class Discovery : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Discovery();
                                virtual ~Discovery();
                                void load(const ibrcommon::ConfigFile &conf);

                                bool _enabled;
                                unsigned int _timeout;

                        public:
                                bool enabled() const;
                                bool announce() const;
                                bool shortbeacon() const;
                                char version() const;
                                const ibrcommon::vaddress address() const throw (ParameterNotFoundException);
                                int port() const;
                                unsigned int timeout() const;
                        };

                        class Statistic : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Statistic();
                                virtual ~Statistic();
                                void load(const ibrcommon::ConfigFile &conf);

                        public:
                                bool enabled() const;

                                ibrcommon::File logfile() const throw (ParameterNotSetException);

                                std::string type() const;

                                unsigned int interval() const;

                                std::string address() const;

                                unsigned int port() const;
                        };

                        class Debug : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Debug();
                                virtual ~Debug();
                                void load(const ibrcommon::ConfigFile &conf);

                                bool _enabled;
                                bool _quiet;
                                int _level;

                        public:
                                int level() const;

                                bool enabled() const;

                                bool quiet() const;
                        };

                        class Logger : public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Logger();
                                virtual ~Logger();
                                void load(const ibrcommon::ConfigFile &conf);

                                bool _quiet;
                                unsigned int _options;
                                bool _timestamps;

                        public:
                                bool quiet() const;

                                unsigned int options() const;

                                std::ostream &output() const;

                                bool display_timestamps() const;
                        };

                        class Network :  public Configuration::Extension
                        {
                                friend class Configuration;
                        protected:
                                Network();
                                virtual ~Network();
                                void load(const ibrcommon::ConfigFile &conf);

                                std::list<dtn::routing::StaticRoutingExtension::StaticRoute> _static_routes;
                                std::list<Node> _nodes;
                                std::list<NetConfig> _interfaces;
                                std::string _routing;
                                bool _forwarding;
                                bool _tcp_nodelay;
                                size_t _tcp_chunksize;
                                ibrcommon::vinterface _default_net;
                                bool _use_default_net;

                        public:
                                const std::list<NetConfig>& getInterfaces() const;

                                const std::list<Node>& getStaticNodes() const;

                                const list<dtn::routing::StaticRoutingExtension::StaticRoute>& getStaticRoutes() const;

                                RoutingExtension getRoutingExtension() const;

                                bool doForwarding() const;

                                bool getTCPOptionNoDelay() const;

                                size_t getTCPChunkSize() const;
                        };

                        class Security : public Configuration::Extension
                        {
                                friend class Configuration;
                        private:
                                bool _enabled;

                        protected:
                                Security();
                                virtual ~Security();
                                void load(const ibrcommon::ConfigFile &conf);

                        public:
                                bool enabled() const;

#ifdef WITH_BUNDLE_SECURITY
                                enum Level
                                {
                                        SECURITY_LEVEL_NONE = 0,
                                        SECURITY_LEVEL_AUTHENTICATED = 1,
                                        SECURITY_LEVEL_ENCRYPTED = 2
                                };

                                Level getLevel() const;

                                const ibrcommon::File& getPath() const;

                                const ibrcommon::File& getCA() const;

                                const ibrcommon::File& getKey() const;

                                const ibrcommon::File& getBABDefaultKey() const;

                        private:
                                ibrcommon::File _path;
                                Level _level;
                                ibrcommon::File _ca;
                                ibrcommon::File _key;
                                ibrcommon::File _bab_default_key;
#endif
                        };

                        class Daemon : public Configuration::Extension
                        {
                                friend class Configuration;
                        private:
                                bool _daemonize;
                                ibrcommon::File _pidfile;
                                bool _kill;

                        protected:
                                Daemon();
                                virtual ~Daemon();
                                void load(const ibrcommon::ConfigFile &conf);

                        public:
                                bool daemonize() const;
                                const ibrcommon::File& getPidFile() const;
                                bool kill_daemon() const;
                        };

                        const Configuration::Discovery& getDiscovery() const;
                        const Configuration::Statistic& getStatistic() const;
                        const Configuration::Debug& getDebug() const;
                        const Configuration::Logger& getLogger() const;
                        const Configuration::Network& getNetwork() const;
                        const Configuration::Security& getSecurity() const;
                        const Configuration::Daemon& getDaemon() const;

                private:
                        ibrcommon::ConfigFile _conf;
                        Configuration::Discovery _disco;
                        Configuration::Statistic _stats;
                        Configuration::Debug _debug;
                        Configuration::Logger _logger;
                        Configuration::Network _network;
                        Configuration::Security _security;
                        Configuration::Daemon _daemon;

                        std::string _filename;
                        bool _doapi;
                };
        }
}

#endif /*CONFIGURATION_H_*/