projects/smsdaemon/SmsToolTransceiver.cpp

#include "SmsToolTransceiver.h"

#include "Logger.h"
#include "Util.h"
#include "Common.h"
#include "ConfigFile.h"

#include <stdexcept>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include <cstring>
#include <errno.h>
#include <time.h>
#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>

using namespace std;

string appendSlash(string& str)
{
        if (str.at(str.length()-1) != '/');
                str += "/";
        return str;
}

SmsToolTransceiver::SmsToolTransceiver()
{
        Common* cmn = Common::instance();

        try
        {
                inboxdir = cmn->GetConfigfile()->GetValue("smstools","inboxdir").StringValue();
        } catch (...) {
                Logger::logMessage("Config error> smstools::inboxdir not specified");
                exit(1);
        }
        try
        {
                outgoingdir = cmn->GetConfigfile()->GetValue("smstools","outgoingdir").StringValue();
        } catch (...) {
                Logger::logMessage("Config error> smstools::outgoingdir not specified");
                exit(1);
        }

        inboxdir = appendSlash(inboxdir);
        outgoingdir = appendSlash(outgoingdir);
        
}


void SmsToolTransceiver::SendSms(std::string to, std::string message, bool allowMultipart)
{
        std::string filename = CreateFilename();
        Logger::logMessage( std::string("Sending sms to: ") + to);

        string tempfile = outgoingdir + filename + ".LOCK";

        string destfile = outgoingdir + filename;

        ofstream out( tempfile.c_str() );
        if (!out )
        {
                Logger::logMessage("SmsToolTransceiver:: could not create temp file");
                return;
        }
        out << "To: " << to << "\n\n" << message ;
        out.close();

        Common::instance()->smsCounter.outgoing++;
        
        int result = rename(tempfile.c_str(), destfile.c_str());

        if (result)
                Logger::logMessage( string("SmsToolTransceiver could not spool file: ") + strerror(errno) );
}

std::string SmsToolTransceiver::CreateFilename()
{
        std::stringstream ss;
        ss << "smsdaemon_";
        ss << std::setw(8) << std::setfill('0') << std::uppercase  << std::hex << time(0) << "_";
        ss << std::setw(8) << std::setfill('0') << std::uppercase  << std::hex << rand();
        ss << std::setw(8) << std::setfill('0') << std::uppercase  << std::hex << rand();
        return ss.str();
}

std::vector<SMS> SmsToolTransceiver::ReadSms(bool readAll)
{
        std::vector<SMS> vec;
        DIR* dir = opendir( inboxdir.c_str() );

        if (dir != 0) 
        {
                dirent* entry;
                while ( (entry = readdir(dir)) != 0)
                {
                        if (entry->d_name[0] == '.')
                                continue;
                        Logger::logMessage( string("SmsTool::ReadSms >") +entry->d_name);

                        try
                        {
                                SMS sms = ParseFile( inboxdir + entry->d_name);
                                vec.push_back(sms);
                        } 
                        catch (std::exception& e) 
                        {
                                Logger::logMessage(e.what());
                        }

                        if (!readAll)
                                break;
                }
        }
        else
        {
                Logger::logMessage( string("SmsToolTransceiver could open inbox dir ") + strerror(errno) );
        }
        closedir(dir);

        return vec;
}

void SmsToolTransceiver::DeleteSms(std::string smsIndex)
{
}

SMS SmsToolTransceiver::ParseFile(std::string path)
{
        SMS sms;
        
        string file = Util::readfile(path);
        int result = ::unlink(path.c_str());
        if (result) 
        {
                string message = "SmsTool> unlink ";
                message += path; 
                message += " failed: ";
                message += strerror(errno);
                throw std::runtime_error( message );
        }


        unsigned int pos = file.find("\n\n");

        if (pos != string::npos) {
                string header = file.substr(0,pos);
                string body = file.substr(pos+2,1024);

                sms.SetIndex(path);
                sms.SetMessage(body);

                ParseHeaders(header, sms);

        } else {
                throw std::runtime_error("SmsTool: invalid incomming file");
        }

        return sms;
}

void SmsToolTransceiver::ParseHeaders(std::string& headerstring, SMS& sms)
{
        std::vector<std::string> headers = Util::str_split(headerstring, "\n");

        for (unsigned int i=0; i<headers.size(); i++) 
        {
                unsigned int  pos = headers[i].find(":");
                if (pos != string::npos)
                {
                        string key = Util::str_trim( headers[i].substr(0,pos) );
                        string val = Util::str_trim( headers[i].substr(pos+1) );

                        if (key == "From")
                                sms.SetSender(val);

                        if (key == "Received")
                                sms.SetTimestamp(val);
                }
                else
                {
                        Logger::logMessage(string("SmsTool: Invalid sms file header> ") + headers[i]);
                }
        }

}

int SmsToolTransceiver::DeleteAllSms()
{
        return 0;
}
1	#include "SmsToolTransceiver.h"
2
3	#include "Logger.h"
4	#include "Util.h"
5	#include "Common.h"
6	#include "ConfigFile.h"
7
8	#include <stdexcept>
9	#include <iostream>
10	#include <fstream>
11	#include <sstream>
12	#include <iomanip>
13
14	#include <cstring>
15	#include <errno.h>
16	#include <time.h>
17	#include <stdlib.h>
18	#include <sys/types.h>
19	#include <dirent.h>
20
21	using namespace std;
22
23	string appendSlash(string& str)
24	{
25	if (str.at(str.length()-1) != '/');
26	str += "/";
27	return str;
28	}
29
30	SmsToolTransceiver::SmsToolTransceiver()
31	{
32	Common* cmn = Common::instance();
33
34	try
35	{
36	inboxdir = cmn->GetConfigfile()->GetValue("smstools","inboxdir").StringValue();
37	} catch (...) {
38	Logger::logMessage("Config error> smstools::inboxdir not specified");
39	exit(1);
40	}
41	try
42	{
43	outgoingdir = cmn->GetConfigfile()->GetValue("smstools","outgoingdir").StringValue();
44	} catch (...) {
45	Logger::logMessage("Config error> smstools::outgoingdir not specified");
46	exit(1);
47	}
48
49	inboxdir = appendSlash(inboxdir);
50	outgoingdir = appendSlash(outgoingdir);
51
52	}
53
54
55	void SmsToolTransceiver::SendSms(std::string to, std::string message, bool allowMultipart)
56	{
57	std::string filename = CreateFilename();
58	Logger::logMessage( std::string("Sending sms to: ") + to);
59
60	string tempfile = outgoingdir + filename + ".LOCK";
61
62	string destfile = outgoingdir + filename;
63
64	ofstream out( tempfile.c_str() );
65	if (!out )
66	{
67	Logger::logMessage("SmsToolTransceiver:: could not create temp file");
68	return;
69	}
70	out << "To: " << to << "\n\n" << message ;
71	out.close();
72
73	Common::instance()->smsCounter.outgoing++;
74
75	int result = rename(tempfile.c_str(), destfile.c_str());
76
77	if (result)
78	Logger::logMessage( string("SmsToolTransceiver could not spool file: ") + strerror(errno) );
79	}
80
81	std::string SmsToolTransceiver::CreateFilename()
82	{
83	std::stringstream ss;
84	ss << "smsdaemon_";
85	ss << std::setw(8) << std::setfill('0') << std::uppercase << std::hex << time(0) << "_";
86	ss << std::setw(8) << std::setfill('0') << std::uppercase << std::hex << rand();
87	ss << std::setw(8) << std::setfill('0') << std::uppercase << std::hex << rand();
88	return ss.str();
89	}
90
91	std::vector<SMS> SmsToolTransceiver::ReadSms(bool readAll)
92	{
93	std::vector<SMS> vec;
94	DIR* dir = opendir( inboxdir.c_str() );
95
96	if (dir != 0)
97	{
98	dirent* entry;
99	while ( (entry = readdir(dir)) != 0)
100	{
101	if (entry->d_name[0] == '.')
102	continue;
103	Logger::logMessage( string("SmsTool::ReadSms >") +entry->d_name);
104
105	try
106	{
107	SMS sms = ParseFile( inboxdir + entry->d_name);
108	vec.push_back(sms);
109	}
110	catch (std::exception& e)
111	{
112	Logger::logMessage(e.what());
113	}
114
115	if (!readAll)
116	break;
117	}
118	}
119	else
120	{
121	Logger::logMessage( string("SmsToolTransceiver could open inbox dir ") + strerror(errno) );
122	}
123	closedir(dir);
124
125	return vec;
126	}
127
128	void SmsToolTransceiver::DeleteSms(std::string smsIndex)
129	{
130	}
131
132	SMS SmsToolTransceiver::ParseFile(std::string path)
133	{
134	SMS sms;
135
136	string file = Util::readfile(path);
137	int result = ::unlink(path.c_str());
138	if (result)
139	{
140	string message = "SmsTool> unlink ";
141	message += path;
142	message += " failed: ";
143	message += strerror(errno);
144	throw std::runtime_error( message );
145	}
146
147
148	unsigned int pos = file.find("\n\n");
149
150	if (pos != string::npos) {
151	string header = file.substr(0,pos);
152	string body = file.substr(pos+2,1024);
153
154	sms.SetIndex(path);
155	sms.SetMessage(body);
156
157	ParseHeaders(header, sms);
158
159	} else {
160	throw std::runtime_error("SmsTool: invalid incomming file");
161	}
162
163	return sms;
164	}
165
166	void SmsToolTransceiver::ParseHeaders(std::string& headerstring, SMS& sms)
167	{
168	std::vector<std::string> headers = Util::str_split(headerstring, "\n");
169
170	for (unsigned int i=0; i<headers.size(); i++)
171	{
172	unsigned int pos = headers[i].find(":");
173	if (pos != string::npos)
174	{
175	string key = Util::str_trim( headers[i].substr(0,pos) );
176	string val = Util::str_trim( headers[i].substr(pos+1) );
177
178	if (key == "From")
179	sms.SetSender(val);
180
181	if (key == "Received")
182	sms.SetTimestamp(val);
183	}
184	else
185	{
186	Logger::logMessage(string("SmsTool: Invalid sms file header> ") + headers[i]);
187	}
188	}
189
190	}
191
192	int SmsToolTransceiver::DeleteAllSms()
193	{
194	return 0;
195	}