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 buf;
                stringstream ss(input);
                vector<string> tokens;
                while (ss >> buf)
                        tokens.push_back(buf);
                return tokens;
        }


        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);
                str = str_replace(str, "&Aring;", rep);

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

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


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

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

                rep.at(0) = 248;
                str = str_replace(str, "&#248;", rep);
                str = str_replace(str, "&oslash;", 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;
        }

        /* deprecated, use HttpClient instead
        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	185
150			vector<string> str_split(string input)
151			{
152			string buf;
153			stringstream ss(input);
154			vector<string> tokens;
155			while (ss >> buf)
156			tokens.push_back(buf);
157			return tokens;
158			}
159
160
161	torben	26	vector<string> str_split(string input, string delimiter)
162			{
163	torben	141	vector<string> retval;
164	torben	26
165			while ( 1 )
166			{
167			unsigned int endpos = input.find(delimiter);
168
169			string entry = input.substr(0,endpos);
170			retval.push_back( entry );
171
172
173			if (endpos == string::npos)
174			break;
175
176			endpos += delimiter.length();
177			input = input.substr(endpos, input.length() - endpos);
178			}
179
180			return retval;
181			}
182
183	torben	183	char danish_map[3][2] = { {198,230}, {216,248}, {197,229} }; // aelig, oslash, aring
184
185			unsigned char my_toupper(unsigned char ch)
186	torben	108	{
187	torben	183	if (ch == 230)
188			return 198;
189			if (ch == 248)
190			return 216;
191			if (ch == 229)
192			return 197;
193	torben	43
194	torben	108	return ::toupper(ch);
195			}
196
197	torben	183	unsigned char my_tolower(unsigned char ch)
198	torben	108	{
199	torben	183	if (ch == 198)
200			return 230;
201			if (ch == 216)
202			return 248;
203			if (ch == 197)
204			return 229;
205	torben	108
206			return ::tolower(ch);
207			}
208	torben	141	string str_toupper(string str)
209	torben	43	{
210			for (unsigned i=0; i<str.length(); ++i)
211			{
212	torben	108	str.replace(i, 1 ,1, my_toupper(str.at(i)));
213	torben	43	}
214			return str;
215			}
216
217			string str_tolower(string str)
218			{
219			for (unsigned i=0; i<str.length(); ++i)
220			{
221	torben	108	str.replace(i, 1 ,1, my_tolower(str.at(i)));
222	torben	43	}
223			return str;
224			}
225
226
227	torben	59	string str_formatint(int i)
228			{
229			std::ostringstream os;
230			os << i;
231			return os.str();
232			}
233
234
235	torben	38	string str_characters(string str)
236			{
237			string rep;
238			rep.append(1,197);
239			str = str_replace(str, "Å", rep);
240	torben	186	str = str_replace(str, "Å", rep);
241	torben	38
242			rep.at(0) = 198;
243			str = str_replace(str, "Æ", rep);
244	torben	186	str = str_replace(str, "Æ", rep);
245	torben	38
246			rep.at(0) = 216;
247			str = str_replace(str, "Ø", rep);
248	torben	186	str = str_replace(str, "Ø", rep);
249	torben	38
250
251			rep.at(0) = 229;
252			str = str_replace(str, "å", rep);
253	torben	186	str = str_replace(str, "å", rep);
254	torben	38
255			rep.at(0) = 230;
256			str = str_replace(str, "æ", rep);
257	torben	186	str = str_replace(str, "æ", rep);
258	torben	38
259			rep.at(0) = 248;
260			str = str_replace(str, "ø", rep);
261	torben	186	str = str_replace(str, "ø", rep);
262	torben	38
263			return str;
264			}
265
266	torben	42
267	torben	43	string str_gsm2latin(string str)
268	torben	42	{
269	torben	196	for (unsigned i=0; i<str.size(); i++)
270			{
271	torben	141	str.at(i) = char_def_alphabet_decode(str.at(i));
272			}
273	torben	42	return str;
274			}
275
276	torben	43	string str_latin2gsm(string str)
277			{
278	torben	196	for (unsigned i=0; i<str.size(); i++)
279			{
280	torben	141	str.at(i) = char_def_alphabet_encode(str.at(i));
281			}
282	torben	43	return str;
283			}
284
285	torben	193	/* deprecated, use HttpClient instead
286	torben	26	string readUrl(string url, string tempfile)
287			{
288			char buf[128000];
289			string document;
290	torben	141
291	torben	26	ostringstream command;
292	torben	49	command << "wget -O " << tempfile << " --tries=1 --timeout=15 -o /dev/null \"" << url << "\"";
293	torben	86	int res = my_system( command.str().c_str() );
294	torben	79
295	torben	86	if (res<0)
296			{
297			throw( std::runtime_error("Error retrieving document"));
298			}
299
300	torben	141	if (res>0)
301	torben	79	{
302	torben	86	throw std::runtime_error("Command time out or document not found");
303	torben	80	}
304	torben	26
305			ifstream in( tempfile.c_str() );
306
307			if (!in)
308			return "";
309
310			while (!in.eof() )
311			{
312			in.getline(buf,128000-1);
313			document += buf;
314			document += "\n";
315			}
316			in.close();
317			unlink(tempfile.c_str());
318	torben	141
319	torben	26	return document;
320	torben	193	}*/
321	torben	26
322	torben	42
323	torben	141
324	torben	42	string iconv_wrapper(string _input, string to_format, string from_format)
325	torben	26	{
326			char* input,output,input_ptr, *output_ptr;
327			input = input_ptr = (char*) malloc(_input.size()+1);
328			strcpy(input, _input.c_str());
329	torben	141
330	torben	26	output = output_ptr = (char) malloc(_input.size()2);
331
332
333	torben	141
334	torben	26	unsigned int realinsize,insize,outsize,realsize;
335	torben	141
336	torben	42	iconv_t icv = iconv_open(to_format.c_str(), from_format.c_str());
337	torben	26	if (icv == (iconv_t)-1)
338			{
339			perror(0);
340			return "";
341			}
342
343	torben	141
344	torben	26	realsize = outsize = _input.size()*2;
345			realinsize = insize = _input.size();
346	torben	141
347	torben	26	iconv(icv,
348	torben	141	&input_ptr,
349			&insize,
350			&output_ptr,
351			&outsize);
352	torben	26
353
354			perror(0);
355	torben	141	/* cout << "len=" << len << endl;
356			cout << "outsize=" << outsize << endl;
357			cout << "realsize=" << realsize << endl;
358			cout << "insize=" << insize << endl;
359			cout << "realinsize=" << realinsize << endl;*/
360	torben	26	iconv_close(icv);
361
362			string returnstr;
363			for (unsigned int i=0; i<realsize - outsize; i++)
364			{
365			//cout << i << ":" << (unsigned short) output[i] << "\|" << (unsigned short) input[i];
366			//cout << " (" << output[i] << ")" << endl;
367			returnstr += output[i];
368			}
369	torben	141	return returnstr;
370	torben	26	}
371
372	torben	42	std::string convertToUnicode(std::string str)
373			{
374			return iconv_wrapper(str, "UTF-8", "ISO8859-1");
375			}
376
377			std::string convertFromUnicode(std::string str)
378			{
379			return iconv_wrapper(str, "ISO8859-1", "UTF-8");
380			}
381
382	torben	26	int uTimeDiff(const timeval& then, const timeval& now)
383			{
384			return ( (now.tv_sec - then.tv_sec)*1000000) + (now.tv_usec-then.tv_usec);
385			}
386
387			int mTimeDiff(const timeval& then, const timeval& now)
388			{
389	torben	84	return ( (now.tv_sec - then.tv_sec)*1000) +
390	torben	141	((now.tv_usec-then.tv_usec)/1000);
391	torben	26	}
392
393	torben	89
394			timeval GetTimeOfDay()
395			{
396			timeval now;
397			gettimeofday(&now,0);
398			return now;
399			}
400
401	torben	107	int my_system(const char* cmd, std::string* response)
402	torben	86	{
403			FILE* p;
404	torben	107	if ((p = popen(cmd,"r")) == NULL)
405	torben	86	return (-1);
406	torben	107
407			if (response)
408			{
409			std::string output;
410			char buf[256];
411	torben	141	while (!feof(p))
412	torben	107	{
413			int len = fread(buf,1,255, p);
414			buf[len] = 0;
415			output += buf;
416			}
417			*response = output;
418			}
419
420	torben	86	return (pclose(p));
421			}
422
423	torben	132	string readfile(string filename)
424			{
425			string str;
426	torben	141	ifstream in(filename.c_str());
427			if (in)
428			{
429	torben	151	char buffer[4096];
430			in.read(buffer, 4095);
431	torben	132	buffer[ in.gcount() ] = 0;
432	torben	141	str = string(buffer);
433			in.close();
434			}
435			else
436			{
437	torben	151	string message = "Could not open ";
438	torben	141	message += filename;
439			throw std::runtime_error(message);
440			}
441			return str;
442	torben	132	}
443
444
445
446	torben	26	}