projects/smsdaemon/Util.cpp


#include <string>
#include <sstream>
#include <vector>
#include <cctype>

#include <iostream>
#include <fstream>
#include <iconv.h>
#include <stdexcept>
#include <time.h>
#include <sys/time.h>
#include <stdlib.h>

#include <cstring>
#include "Util.h"

using namespace std;

namespace Util
{
        const int GN_CHAR_ALPHABET_SIZE = 128;
        unsigned char gsm_default_alphabet[GN_CHAR_ALPHABET_SIZE] =
        {

                /* ETSI GSM 03.38, version 6.0.1, section 6.2.1; Default alphabet */
                /* Characters in hex position 10, [12 to 1a] and 24 are not present on
                *        latin1 charset, so we cannot reproduce on the screen, however they are
                *               greek symbol not present even on my Nokia */

                '@',  0xa3, '$',  0xa5, 0xe8, 0xe9, 0xf9, 0xec,
                0xf2, 0xc7, '\n', 0xd8, 0xf8, '\r', 0xc5, 0xe5,
                '?',  '_',  '?',  '?',  '?',  '?',  '?',  '?',
                '?',  '?',  '?',  '?',  0xc6, 0xe6, 0xdf, 0xc9,
                ' ',  '!',  '\"', '#',  0xa4,  '%',  '&',  '\'',
                '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
                '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
                '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
                0xa1, 'A',  'B',  'C',  'D',  'E',  'F',  'G',
                'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
                'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
                'X',  'Y',  'Z',  0xc4, 0xd6, 0xd1, 0xdc, 0xa7,
                0xbf, 'a',  'b',  'c',  'd',  'e',  'f',  'g',
                'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
                'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
                'x',  'y',  'z',  0xe4, 0xf6, 0xf1, 0xfc, 0xe0
        };

        static unsigned char gsm_reverse_default_alphabet[256];
        static bool reversed = false;

        static void tbl_setup_reverse()
        {
                int i;

                if (reversed) return;
                memset(gsm_reverse_default_alphabet, 0x3f, 256);
                for (i = GN_CHAR_ALPHABET_SIZE - 1; i >= 0; i--)
                        gsm_reverse_default_alphabet[ gsm_default_alphabet[i] ] = i;
                gsm_reverse_default_alphabet['?'] = 0x3f;
                reversed = true;
        }

        unsigned char char_def_alphabet_encode(unsigned char value)
        {
                tbl_setup_reverse();
                return gsm_reverse_default_alphabet[value];
        }

        unsigned char char_def_alphabet_decode(unsigned char value)
        {
                if (value < GN_CHAR_ALPHABET_SIZE)
                {
                        return gsm_default_alphabet[value];
                }
                else
                {
                        return '?';
                }
        }


        void str_dump(const string& str)
        {
                for (unsigned i=0; i<str.length(); ++i)
                {
                        cout.width(2);
                        cout.fill('0');
                        cout << hex << static_cast<int>(str.at(i)) << " ";
                }
                cout.width(1);
                cout << dec <<  endl;
        }


        string str_replace(string str, string search, string replace)
        {
                unsigned int pos = 0;

                while ( (pos = str.find(search,pos)) != string::npos)
                {
                        str.replace(pos, search.size(), replace);
                        pos += replace.size();
                }
                return str;
        }

        std::string str_replace_char(std::string str, char search, char replace)
        {
                unsigned int pos = 0;

                while ( (pos = str.find(search,pos)) != string::npos)
                {
                        str.replace(pos, 1, 1, replace);
                }
                return str;
        }

        bool my_isspace(char ch)
        {
                return (isspace(ch) || ch == 0);
        }

        string str_trim(string str)
        {
                while (str.length() > 0 && my_isspace(str.at(0)))
                        str.erase(0,1);
                while (str.length() > 0 && my_isspace(str.at(str.length()-1)))
                        str.erase(str.length()-1,1);
                return str;
        }

        string str_striptags(string str)
        {
                unsigned int pos=0;

                while ( (pos=str.find("<",pos)) != string::npos)
                {
                        unsigned int endpos = str.find(">",pos);
                        if (endpos == string::npos)
                                break;
                        str.erase(pos, (endpos-pos)+1);
                }

                return str;
        }

        vector<string> str_split(string input, string delimiter)
        {
                vector<string> retval;

                while ( 1 )
                {
                        unsigned int endpos = input.find(delimiter);

                        string entry = input.substr(0,endpos);
                        retval.push_back( entry );


                        if (endpos == string::npos)
                                break;

                        endpos += delimiter.length();
                        input = input.substr(endpos, input.length() - endpos);
                }

                return retval;
        }

        char danish_map[3][2] = { {198,230}, {216,248}, {197,229} }; // aelig, oslash, aring

        unsigned char my_toupper(unsigned char ch)
        {
                if (ch == 230)
                        return 198;
                if (ch == 248)
                        return 216;
                if (ch == 229)
                        return 197;

                return ::toupper(ch);
        }

        unsigned char my_tolower(unsigned char ch)
        {
                if (ch == 198)
                        return 230;
                if (ch == 216)
                        return 248;
                if (ch == 197)
                        return 229;

                return ::tolower(ch);
        }
        string str_toupper(string str)
        {
                for (unsigned i=0; i<str.length(); ++i)
                {
                        str.replace(i, 1 ,1, my_toupper(str.at(i)));
                }
                return str;
        }

        string str_tolower(string str)
        {
                for (unsigned i=0; i<str.length(); ++i)
                {
                        str.replace(i, 1 ,1, my_tolower(str.at(i)));
                }
                return str;
        }


        string str_formatint(int i)
        {
                std::ostringstream os;
                os << i;
                return os.str();
        }


        string str_characters(string str)
        {
                string rep;
                rep.append(1,197);
                str = str_replace(str, "&#197;", rep);

                rep.at(0) = 198;
                str = str_replace(str, "&#198;", rep);

                rep.at(0) = 216;
                str = str_replace(str, "&#216;", rep);


                rep.at(0) = 229;
                str = str_replace(str, "&#229;", rep);

                rep.at(0) = 230;
                str = str_replace(str, "&#230;", rep);

                rep.at(0) = 248;
                str = str_replace(str, "&#248;", rep);

                return str;
        }


        string str_gsm2latin(string str)
        {
                for (unsigned i=0; i<str.size(); i++) {
                        str.at(i) = char_def_alphabet_decode(str.at(i));
                }
                return str;
        }

        string str_latin2gsm(string str)
        {
                for (unsigned i=0; i<str.size(); i++) {
                        str.at(i) = char_def_alphabet_encode(str.at(i));
                }
                return str;
        }

        string readUrl(string url, string tempfile)
        {
                char buf[128000];
                string document;

                ostringstream command;
                command << "wget -O " << tempfile << " --tries=1 --timeout=15 -o /dev/null  \"" << url << "\"";
                int res = my_system( command.str().c_str() );

                if (res<0)
                {
                        throw( std::runtime_error("Error retrieving document"));
                }

                if (res>0)
                {
                        throw std::runtime_error("Command time out or document not found");
                }

                ifstream in( tempfile.c_str() );

                if (!in)
                        return "";

                while (!in.eof() )
                {
                        in.getline(buf,128000-1);
                        document += buf;
                        document += "\n";
                }
                in.close();
                unlink(tempfile.c_str());

                return document;
        }


        string iconv_wrapper(string _input, string to_format, string from_format)
        {
                char* input,*output,*input_ptr, *output_ptr;
                input = input_ptr = (char*) malloc(_input.size()+1);
                strcpy(input, _input.c_str());

                output = output_ptr = (char*) malloc(_input.size()*2);


                unsigned int realinsize,insize,outsize,realsize;

                iconv_t icv = iconv_open(to_format.c_str(), from_format.c_str());
                if (icv == (iconv_t)-1)
                {
                        perror(0);
                        return "";
                }


                realsize = outsize = _input.size()*2;
                realinsize = insize = _input.size();

                iconv(icv,
                      &input_ptr,
                      &insize,
                      &output_ptr,
                      &outsize);


                perror(0);
                /*              cout << "len=" << len << endl;
                                cout << "outsize=" <<  outsize << endl;
                                cout << "realsize=" << realsize << endl;
                                cout << "insize=" << insize << endl;
                                cout << "realinsize=" << realinsize << endl;*/
                iconv_close(icv);

                string returnstr;
                for (unsigned int i=0; i<realsize - outsize; i++)
                {
                        //cout << i << ":" << (unsigned short) output[i] << "|" << (unsigned short) input[i];
                        //cout << " (" << output[i] << ")" << endl;
                        returnstr += output[i];
                }
                return returnstr;
        }

        std::string convertToUnicode(std::string str)
        {
                return iconv_wrapper(str, "UTF-8", "ISO8859-1");
        }

        std::string convertFromUnicode(std::string str)
        {
                return iconv_wrapper(str, "ISO8859-1", "UTF-8");
        }

        int uTimeDiff(const timeval& then, const timeval& now)
        {
                return ( (now.tv_sec - then.tv_sec)*1000000) + (now.tv_usec-then.tv_usec);
        }

        int mTimeDiff(const timeval& then, const timeval& now)
        {
                return ( (now.tv_sec - then.tv_sec)*1000) +
                       ((now.tv_usec-then.tv_usec)/1000);
        }


        timeval GetTimeOfDay()
        {
                timeval now;
                gettimeofday(&now,0);
                return now;
        }

        int my_system(const char* cmd, std::string* response)
        {
                FILE* p;
                if ((p = popen(cmd,"r")) == NULL)
                        return (-1);

                if (response)
                {
                        std::string output;
                        char buf[256];
                        while (!feof(p))
                        {
                                int len = fread(buf,1,255, p);
                                buf[len] = 0;
                                output += buf;
                        }
                        *response = output;
                }

                return (pclose(p));
        }

        string readfile(string filename)
        {
                string str;
                ifstream in(filename.c_str());
                if (in)
                {
                        char buffer[4096];
                        in.read(buffer, 4095);
                        buffer[ in.gcount() ] = 0;
                        str = string(buffer);
                        in.close();
                }
                else
                {
                        string message =  "Could not open ";
                        message +=  filename;
                        throw std::runtime_error(message);
                }
                return str;
        }


}
1	torben	26
2			#include <string>
3			#include <sstream>
4			#include <vector>
5	torben	38	#include <cctype>
6
7	torben	26	#include <iostream>
8			#include <fstream>
9			#include <iconv.h>
10	torben	49	#include <stdexcept>
11	torben	26	#include <time.h>
12	torben	89	#include <sys/time.h>
13	torben	114	#include <stdlib.h>
14	torben	26
15	torben	114	#include <cstring>
16	torben	158	#include "Util.h"
17	torben	26
18			using namespace std;
19
20			namespace Util
21			{
22	torben	141	const int GN_CHAR_ALPHABET_SIZE = 128;
23			unsigned char gsm_default_alphabet[GN_CHAR_ALPHABET_SIZE] =
24			{
25
26			/* ETSI GSM 03.38, version 6.0.1, section 6.2.1; Default alphabet */
27			/* Characters in hex position 10, [12 to 1a] and 24 are not present on
28			* latin1 charset, so we cannot reproduce on the screen, however they are
29			* greek symbol not present even on my Nokia */
30
31			'@', 0xa3, '$', 0xa5, 0xe8, 0xe9, 0xf9, 0xec,
32			0xf2, 0xc7, '\n', 0xd8, 0xf8, '\r', 0xc5, 0xe5,
33			'?', '_', '?', '?', '?', '?', '?', '?',
34			'?', '?', '?', '?', 0xc6, 0xe6, 0xdf, 0xc9,
35			' ', '!', '\"', '#', 0xa4, '%', '&', '\'',
36			'(', ')', '*', '+', ',', '-', '.', '/',
37			'0', '1', '2', '3', '4', '5', '6', '7',
38			'8', '9', ':', ';', '<', '=', '>', '?',
39			0xa1, 'A', 'B', 'C', 'D', 'E', 'F', 'G',
40			'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
41			'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
42			'X', 'Y', 'Z', 0xc4, 0xd6, 0xd1, 0xdc, 0xa7,
43			0xbf, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
44			'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
45			'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
46			'x', 'y', 'z', 0xe4, 0xf6, 0xf1, 0xfc, 0xe0
47			};
48
49			static unsigned char gsm_reverse_default_alphabet[256];
50			static bool reversed = false;
51
52			static void tbl_setup_reverse()
53			{
54			int i;
55
56			if (reversed) return;
57			memset(gsm_reverse_default_alphabet, 0x3f, 256);
58			for (i = GN_CHAR_ALPHABET_SIZE - 1; i >= 0; i--)
59			gsm_reverse_default_alphabet[ gsm_default_alphabet[i] ] = i;
60			gsm_reverse_default_alphabet['?'] = 0x3f;
61			reversed = true;
62			}
63
64			unsigned char char_def_alphabet_encode(unsigned char value)
65			{
66			tbl_setup_reverse();
67			return gsm_reverse_default_alphabet[value];
68			}
69
70			unsigned char char_def_alphabet_decode(unsigned char value)
71			{
72			if (value < GN_CHAR_ALPHABET_SIZE)
73			{
74			return gsm_default_alphabet[value];
75			}
76			else
77			{
78			return '?';
79			}
80			}
81
82
83	torben	26	void str_dump(const string& str)
84			{
85	torben	141	for (unsigned i=0; i<str.length(); ++i)
86			{
87	torben	26	cout.width(2);
88			cout.fill('0');
89			cout << hex << static_cast<int>(str.at(i)) << " ";
90			}
91			cout.width(1);
92			cout << dec << endl;
93			}
94
95
96
97	torben	38	string str_replace(string str, string search, string replace)
98	torben	26	{
99			unsigned int pos = 0;
100	torben	141
101	torben	38	while ( (pos = str.find(search,pos)) != string::npos)
102	torben	26	{
103	torben	38	str.replace(pos, search.size(), replace);
104	torben	26	pos += replace.size();
105			}
106	torben	38	return str;
107	torben	26	}
108
109	torben	141	std::string str_replace_char(std::string str, char search, char replace)
110	torben	42	{
111			unsigned int pos = 0;
112
113			while ( (pos = str.find(search,pos)) != string::npos)
114			{
115			str.replace(pos, 1, 1, replace);
116			}
117			return str;
118			}
119
120	torben	78	bool my_isspace(char ch)
121			{
122			return (isspace(ch) \|\| ch == 0);
123			}
124	torben	38
125			string str_trim(string str)
126			{
127	torben	78	while (str.length() > 0 && my_isspace(str.at(0)))
128	torben	38	str.erase(0,1);
129	torben	78	while (str.length() > 0 && my_isspace(str.at(str.length()-1)))
130	torben	38	str.erase(str.length()-1,1);
131			return str;
132			}
133
134			string str_striptags(string str)
135			{
136			unsigned int pos=0;
137
138			while ( (pos=str.find("<",pos)) != string::npos)
139			{
140			unsigned int endpos = str.find(">",pos);
141			if (endpos == string::npos)
142			break;
143			str.erase(pos, (endpos-pos)+1);
144			}
145
146			return str;
147			}
148
149	torben	26	vector<string> str_split(string input, string delimiter)
150			{
151	torben	141	vector<string> retval;
152	torben	26
153			while ( 1 )
154			{
155			unsigned int endpos = input.find(delimiter);
156
157			string entry = input.substr(0,endpos);
158			retval.push_back( entry );
159
160
161			if (endpos == string::npos)
162			break;
163
164			endpos += delimiter.length();
165			input = input.substr(endpos, input.length() - endpos);
166			}
167
168			return retval;
169			}
170
171	torben	183	char danish_map[3][2] = { {198,230}, {216,248}, {197,229} }; // aelig, oslash, aring
172
173			unsigned char my_toupper(unsigned char ch)
174	torben	108	{
175	torben	183	if (ch == 230)
176			return 198;
177			if (ch == 248)
178			return 216;
179			if (ch == 229)
180			return 197;
181	torben	43
182	torben	108	return ::toupper(ch);
183			}
184
185	torben	183	unsigned char my_tolower(unsigned char ch)
186	torben	108	{
187	torben	183	if (ch == 198)
188			return 230;
189			if (ch == 216)
190			return 248;
191			if (ch == 197)
192			return 229;
193	torben	108
194			return ::tolower(ch);
195			}
196	torben	141	string str_toupper(string str)
197	torben	43	{
198			for (unsigned i=0; i<str.length(); ++i)
199			{
200	torben	108	str.replace(i, 1 ,1, my_toupper(str.at(i)));
201	torben	43	}
202			return str;
203			}
204
205			string str_tolower(string str)
206			{
207			for (unsigned i=0; i<str.length(); ++i)
208			{
209	torben	108	str.replace(i, 1 ,1, my_tolower(str.at(i)));
210	torben	43	}
211			return str;
212			}
213
214
215	torben	59	string str_formatint(int i)
216			{
217			std::ostringstream os;
218			os << i;
219			return os.str();
220			}
221
222
223	torben	38	string str_characters(string str)
224			{
225			string rep;
226			rep.append(1,197);
227			str = str_replace(str, "Å", rep);
228
229			rep.at(0) = 198;
230			str = str_replace(str, "Æ", rep);
231
232			rep.at(0) = 216;
233			str = str_replace(str, "Ø", rep);
234
235
236			rep.at(0) = 229;
237			str = str_replace(str, "å", rep);
238
239			rep.at(0) = 230;
240			str = str_replace(str, "æ", rep);
241
242			rep.at(0) = 248;
243			str = str_replace(str, "ø", rep);
244
245			return str;
246			}
247
248	torben	42
249	torben	43	string str_gsm2latin(string str)
250	torben	42	{
251	torben	141	for (unsigned i=0; i<str.size(); i++) {
252			str.at(i) = char_def_alphabet_decode(str.at(i));
253			}
254	torben	42	return str;
255			}
256
257	torben	43	string str_latin2gsm(string str)
258			{
259	torben	141	for (unsigned i=0; i<str.size(); i++) {
260			str.at(i) = char_def_alphabet_encode(str.at(i));
261			}
262	torben	43	return str;
263			}
264
265	torben	26	string readUrl(string url, string tempfile)
266			{
267			char buf[128000];
268			string document;
269	torben	141
270	torben	26	ostringstream command;
271	torben	49	command << "wget -O " << tempfile << " --tries=1 --timeout=15 -o /dev/null \"" << url << "\"";
272	torben	86	int res = my_system( command.str().c_str() );
273	torben	79
274	torben	86	if (res<0)
275			{
276			throw( std::runtime_error("Error retrieving document"));
277			}
278
279	torben	141	if (res>0)
280	torben	79	{
281	torben	86	throw std::runtime_error("Command time out or document not found");
282	torben	80	}
283	torben	26
284			ifstream in( tempfile.c_str() );
285
286			if (!in)
287			return "";
288
289			while (!in.eof() )
290			{
291			in.getline(buf,128000-1);
292			document += buf;
293			document += "\n";
294			}
295			in.close();
296			unlink(tempfile.c_str());
297	torben	141
298	torben	26	return document;
299			}
300
301	torben	42
302	torben	141
303	torben	42	string iconv_wrapper(string _input, string to_format, string from_format)
304	torben	26	{
305			char* input,output,input_ptr, *output_ptr;
306			input = input_ptr = (char*) malloc(_input.size()+1);
307			strcpy(input, _input.c_str());
308	torben	141
309	torben	26	output = output_ptr = (char) malloc(_input.size()2);
310
311
312	torben	141
313	torben	26	unsigned int realinsize,insize,outsize,realsize;
314	torben	141
315	torben	42	iconv_t icv = iconv_open(to_format.c_str(), from_format.c_str());
316	torben	26	if (icv == (iconv_t)-1)
317			{
318			perror(0);
319			return "";
320			}
321
322	torben	141
323	torben	26	realsize = outsize = _input.size()*2;
324			realinsize = insize = _input.size();
325	torben	141
326	torben	26	iconv(icv,
327	torben	141	&input_ptr,
328			&insize,
329			&output_ptr,
330			&outsize);
331	torben	26
332
333			perror(0);
334	torben	141	/* cout << "len=" << len << endl;
335			cout << "outsize=" << outsize << endl;
336			cout << "realsize=" << realsize << endl;
337			cout << "insize=" << insize << endl;
338			cout << "realinsize=" << realinsize << endl;*/
339	torben	26	iconv_close(icv);
340
341			string returnstr;
342			for (unsigned int i=0; i<realsize - outsize; i++)
343			{
344			//cout << i << ":" << (unsigned short) output[i] << "\|" << (unsigned short) input[i];
345			//cout << " (" << output[i] << ")" << endl;
346			returnstr += output[i];
347			}
348	torben	141	return returnstr;
349	torben	26	}
350
351	torben	42	std::string convertToUnicode(std::string str)
352			{
353			return iconv_wrapper(str, "UTF-8", "ISO8859-1");
354			}
355
356			std::string convertFromUnicode(std::string str)
357			{
358			return iconv_wrapper(str, "ISO8859-1", "UTF-8");
359			}
360
361	torben	26	int uTimeDiff(const timeval& then, const timeval& now)
362			{
363			return ( (now.tv_sec - then.tv_sec)*1000000) + (now.tv_usec-then.tv_usec);
364			}
365
366			int mTimeDiff(const timeval& then, const timeval& now)
367			{
368	torben	84	return ( (now.tv_sec - then.tv_sec)*1000) +
369	torben	141	((now.tv_usec-then.tv_usec)/1000);
370	torben	26	}
371
372	torben	89
373			timeval GetTimeOfDay()
374			{
375			timeval now;
376			gettimeofday(&now,0);
377			return now;
378			}
379
380	torben	107	int my_system(const char* cmd, std::string* response)
381	torben	86	{
382			FILE* p;
383	torben	107	if ((p = popen(cmd,"r")) == NULL)
384	torben	86	return (-1);
385	torben	107
386			if (response)
387			{
388			std::string output;
389			char buf[256];
390	torben	141	while (!feof(p))
391	torben	107	{
392			int len = fread(buf,1,255, p);
393			buf[len] = 0;
394			output += buf;
395			}
396			*response = output;
397			}
398
399	torben	86	return (pclose(p));
400			}
401
402	torben	132	string readfile(string filename)
403			{
404			string str;
405	torben	141	ifstream in(filename.c_str());
406			if (in)
407			{
408	torben	151	char buffer[4096];
409			in.read(buffer, 4095);
410	torben	132	buffer[ in.gcount() ] = 0;
411	torben	141	str = string(buffer);
412			in.close();
413			}
414			else
415			{
416	torben	151	string message = "Could not open ";
417	torben	141	message += filename;
418			throw std::runtime_error(message);
419			}
420			return str;
421	torben	132	}
422
423
424
425	torben	26	}