projects/smsdaemon/Common.cpp

#include "Common.h"


#include "version.h"

#include <stdlib.h>
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <time.h>

#include "TaskManager.h"
#include "PluginManager.h"
#include "ConfigFile.h"
#include "Util.h"
#include "Logger.h"

using namespace std;

Common* Common::instance()
{
        static Common store;
        return &store;
}


Common::Common()
                : _pluginManager(0), _taskManager(0)
{
        _pluginManager = new PluginManager();
        _taskManager = new TaskManager();
        configFilePath = "/etc/smsdaemon.conf";
        _configFile = new ConfigFile();

        daemonized = false;
        reloadConfig = false;
}


Common::~Common()
{
        if (_pluginManager)
                delete _pluginManager;

        if (_taskManager)
                delete _taskManager;
}

PluginManager* Common::GetPluginManager()
{
        return _pluginManager;
}

TaskManager* Common::GetTaskManager()
{
        return _taskManager;
}

ConfigFile* Common::GetConfigfile()
{
        return _configFile;
}


void Common::printUsage()
{
        cout << VERSION << endl;
        cout << SVNVERSION << endl << endl;
        cout << "Usage --daemon|--debug [arguments]" << endl;
        cout << "Commandline arguments :" << endl;
        cout << "  --daemon :       Run in daemon (background) mode" << endl;
        cout << "  --debug :        Run as normal (frontground) process," << endl;
        cout << "                   with all messages written to std out" << endl;
        cout << "  --config <file>: Specify which config file to use " << endl;
        cout << "                   default" << configFilePath << endl;
        cout << "  --help :         Show this help screen" << endl;

        exit(0);
}

void Common::loadConfig(int argc, char* argv[])
{
        isDaemon = false;
        isDebug = false;

        for (int i = 1; i< argc; i++)
        {
                string current(argv[i]);
                if (current == "--daemon")
                {
                        isDaemon = true;
                        isDebug = false;

                }
                else if (current == "--debug")
                {
                        isDaemon = false;
                        isDebug = true;
                }
                else if (current == "--config")
                {
                        i++;
                        if ( i<argc)
                        {
                                configFilePath = argv[i];
                        }
                        else
                        {
                                printUsage();
                                exit(1);
                        }

                }
                else if (current == "-h" || current == "--help")
                {
                        printUsage();
                }
                else
                {
                        cout << "Unknown argument : " << current << endl << endl;
                }
        }

        if (! ( isDaemon || isDebug))
                printUsage();
}


std::string Common::getStatusMessage()
{
        long int now = time(0);

        long int diff = now - this->daemonStart;


        std::ostringstream out;
        out << "Uptime " << diff << " seconds. ";
        out << "Messages received:" << this->smsCounter.incomming << ". ";
        out << "Messages sent:" << this->smsCounter.outgoing << ".";

        return out.str();
}

void Common::LoadWorker(std::set<std::string>& set, std::string config)
{
        set.clear();

        std::vector<std::string> items = Util::str_split(
                                                        _configFile->GetValue("smsdaemon",config,""),
                                                        ",");

        std::ostringstream log;
        log << "Loaded list '" << config << "': ";
        for (unsigned i=0; i<items.size(); i++)
        {
                set.insert( Util::str_trim(items[i]) );
                log << items[i] << " ";
        }
        Logger::logMessage(log.str());
}

void Common::LoadLists()
{
        LoadWorker(_blacklist, "blacklist");
        LoadWorker(_privileged, "privileged");
}


bool Common::IsBlacklisted(const std::string& phone)
{
        std::set<std::string>::iterator it = _blacklist.find(phone);
        return ( it != _blacklist.end() );
}

bool Common::IsPrivileged(const std::string& phone)
{
        std::set<std::string>::iterator it = _privileged.find(phone);
        return ( it != _privileged.end() );
}
1	#include "Common.h"
2
3
4	#include "version.h"
5
6	#include <stdlib.h>
7	#include <string>
8	#include <iostream>
9	#include <iomanip>
10	#include <sstream>
11	#include <time.h>
12
13	#include "TaskManager.h"
14	#include "PluginManager.h"
15	#include "ConfigFile.h"
16	#include "Util.h"
17	#include "Logger.h"
18
19	using namespace std;
20
21	Common* Common::instance()
22	{
23	static Common store;
24	return &store;
25	}
26
27
28	Common::Common()
29	: _pluginManager(0), _taskManager(0)
30	{
31	_pluginManager = new PluginManager();
32	_taskManager = new TaskManager();
33	configFilePath = "/etc/smsdaemon.conf";
34	_configFile = new ConfigFile();
35
36	daemonized = false;
37	reloadConfig = false;
38	}
39
40
41	Common::~Common()
42	{
43	if (_pluginManager)
44	delete _pluginManager;
45
46	if (_taskManager)
47	delete _taskManager;
48	}
49
50	PluginManager* Common::GetPluginManager()
51	{
52	return _pluginManager;
53	}
54
55	TaskManager* Common::GetTaskManager()
56	{
57	return _taskManager;
58	}
59
60	ConfigFile* Common::GetConfigfile()
61	{
62	return _configFile;
63	}
64
65
66	void Common::printUsage()
67	{
68	cout << VERSION << endl;
69	cout << SVNVERSION << endl << endl;
70	cout << "Usage --daemon\|--debug [arguments]" << endl;
71	cout << "Commandline arguments :" << endl;
72	cout << " --daemon : Run in daemon (background) mode" << endl;
73	cout << " --debug : Run as normal (frontground) process," << endl;
74	cout << " with all messages written to std out" << endl;
75	cout << " --config <file>: Specify which config file to use " << endl;
76	cout << " default" << configFilePath << endl;
77	cout << " --help : Show this help screen" << endl;
78
79	exit(0);
80	}
81
82	void Common::loadConfig(int argc, char* argv[])
83	{
84	isDaemon = false;
85	isDebug = false;
86
87	for (int i = 1; i< argc; i++)
88	{
89	string current(argv[i]);
90	if (current == "--daemon")
91	{
92	isDaemon = true;
93	isDebug = false;
94
95	}
96	else if (current == "--debug")
97	{
98	isDaemon = false;
99	isDebug = true;
100	}
101	else if (current == "--config")
102	{
103	i++;
104	if ( i<argc)
105	{
106	configFilePath = argv[i];
107	}
108	else
109	{
110	printUsage();
111	exit(1);
112	}
113
114	}
115	else if (current == "-h" \|\| current == "--help")
116	{
117	printUsage();
118	}
119	else
120	{
121	cout << "Unknown argument : " << current << endl << endl;
122	}
123	}
124
125	if (! ( isDaemon \|\| isDebug))
126	printUsage();
127	}
128
129
130	std::string Common::getStatusMessage()
131	{
132	long int now = time(0);
133
134	long int diff = now - this->daemonStart;
135
136
137	std::ostringstream out;
138	out << "Uptime " << diff << " seconds. ";
139	out << "Messages received:" << this->smsCounter.incomming << ". ";
140	out << "Messages sent:" << this->smsCounter.outgoing << ".";
141
142	return out.str();
143	}
144
145	void Common::LoadWorker(std::set<std::string>& set, std::string config)
146	{
147	set.clear();
148
149	std::vector<std::string> items = Util::str_split(
150	_configFile->GetValue("smsdaemon",config,""),
151	",");
152
153	std::ostringstream log;
154	log << "Loaded list '" << config << "': ";
155	for (unsigned i=0; i<items.size(); i++)
156	{
157	set.insert( Util::str_trim(items[i]) );
158	log << items[i] << " ";
159	}
160	Logger::logMessage(log.str());
161	}
162
163	void Common::LoadLists()
164	{
165	LoadWorker(_blacklist, "blacklist");
166	LoadWorker(_privileged, "privileged");
167	}
168
169
170	bool Common::IsBlacklisted(const std::string& phone)
171	{
172	std::set<std::string>::iterator it = _blacklist.find(phone);
173	return ( it != _blacklist.end() );
174	}
175
176	bool Common::IsPrivileged(const std::string& phone)
177	{
178	std::set<std::string>::iterator it = _privileged.find(phone);
179	return ( it != _privileged.end() );
180	}