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
2	#include <string>
3	#include <sstream>
4	#include <vector>
5	#include <cctype>
6
7	#include <iostream>
8	#include <fstream>
9	#include <iconv.h>
10	#include <stdexcept>
11	#include <time.h>
12	#include <sys/time.h>
13	#include <stdlib.h>
14
15	#include <cstring>
16	#include "Util.h"
17
18	using namespace std;
19
20	namespace Util
21	{
22	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	void str_dump(const string& str)
84	{
85	for (unsigned i=0; i<str.length(); ++i)
86	{
87	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	string str_replace(string str, string search, string replace)
98	{
99	unsigned int pos = 0;
100
101	while ( (pos = str.find(search,pos)) != string::npos)
102	{
103	str.replace(pos, search.size(), replace);
104	pos += replace.size();
105	}
106	return str;
107	}
108
109	std::string str_replace_char(std::string str, char search, char replace)
110	{
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	bool my_isspace(char ch)
121	{
122	return (isspace(ch) \|\| ch == 0);
123	}
124
125	string str_trim(string str)
126	{
127	while (str.length() > 0 && my_isspace(str.at(0)))
128	str.erase(0,1);
129	while (str.length() > 0 && my_isspace(str.at(str.length()-1)))
130	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
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	vector<string> str_split(string input, string delimiter)
162	{
163	vector<string> retval;
164
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	char danish_map[3][2] = { {198,230}, {216,248}, {197,229} }; // aelig, oslash, aring
184
185	unsigned char my_toupper(unsigned char ch)
186	{
187	if (ch == 230)
188	return 198;
189	if (ch == 248)
190	return 216;
191	if (ch == 229)
192	return 197;
193
194	return ::toupper(ch);
195	}
196
197	unsigned char my_tolower(unsigned char ch)
198	{
199	if (ch == 198)
200	return 230;
201	if (ch == 216)
202	return 248;
203	if (ch == 197)
204	return 229;
205
206	return ::tolower(ch);
207	}
208	string str_toupper(string str)
209	{
210	for (unsigned i=0; i<str.length(); ++i)
211	{
212	str.replace(i, 1 ,1, my_toupper(str.at(i)));
213	}
214	return str;
215	}
216
217	string str_tolower(string str)
218	{
219	for (unsigned i=0; i<str.length(); ++i)
220	{
221	str.replace(i, 1 ,1, my_tolower(str.at(i)));
222	}
223	return str;
224	}
225
226
227	string str_formatint(int i)
228	{
229	std::ostringstream os;
230	os << i;
231	return os.str();
232	}
233
234
235	string str_characters(string str)
236	{
237	string rep;
238	rep.append(1,197);
239	str = str_replace(str, "Å", rep);
240	str = str_replace(str, "Å", rep);
241
242	rep.at(0) = 198;
243	str = str_replace(str, "Æ", rep);
244	str = str_replace(str, "Æ", rep);
245
246	rep.at(0) = 216;
247	str = str_replace(str, "Ø", rep);
248	str = str_replace(str, "Ø", rep);
249
250
251	rep.at(0) = 229;
252	str = str_replace(str, "å", rep);
253	str = str_replace(str, "å", rep);
254
255	rep.at(0) = 230;
256	str = str_replace(str, "æ", rep);
257	str = str_replace(str, "æ", rep);
258
259	rep.at(0) = 248;
260	str = str_replace(str, "ø", rep);
261	str = str_replace(str, "ø", rep);
262
263	return str;
264	}
265
266
267	string str_gsm2latin(string str)
268	{
269	for (unsigned i=0; i<str.size(); i++) {
270	str.at(i) = char_def_alphabet_decode(str.at(i));
271	}
272	return str;
273	}
274
275	string str_latin2gsm(string str)
276	{
277	for (unsigned i=0; i<str.size(); i++) {
278	str.at(i) = char_def_alphabet_encode(str.at(i));
279	}
280	return str;
281	}
282
283	/* deprecated, use HttpClient instead
284	string readUrl(string url, string tempfile)
285	{
286	char buf[128000];
287	string document;
288
289	ostringstream command;
290	command << "wget -O " << tempfile << " --tries=1 --timeout=15 -o /dev/null \"" << url << "\"";
291	int res = my_system( command.str().c_str() );
292
293	if (res<0)
294	{
295	throw( std::runtime_error("Error retrieving document"));
296	}
297
298	if (res>0)
299	{
300	throw std::runtime_error("Command time out or document not found");
301	}
302
303	ifstream in( tempfile.c_str() );
304
305	if (!in)
306	return "";
307
308	while (!in.eof() )
309	{
310	in.getline(buf,128000-1);
311	document += buf;
312	document += "\n";
313	}
314	in.close();
315	unlink(tempfile.c_str());
316
317	return document;
318	}*/
319
320
321
322	string iconv_wrapper(string _input, string to_format, string from_format)
323	{
324	char* input,output,input_ptr, *output_ptr;
325	input = input_ptr = (char*) malloc(_input.size()+1);
326	strcpy(input, _input.c_str());
327
328	output = output_ptr = (char) malloc(_input.size()2);
329
330
331
332	unsigned int realinsize,insize,outsize,realsize;
333
334	iconv_t icv = iconv_open(to_format.c_str(), from_format.c_str());
335	if (icv == (iconv_t)-1)
336	{
337	perror(0);
338	return "";
339	}
340
341
342	realsize = outsize = _input.size()*2;
343	realinsize = insize = _input.size();
344
345	iconv(icv,
346	&input_ptr,
347	&insize,
348	&output_ptr,
349	&outsize);
350
351
352	perror(0);
353	/* cout << "len=" << len << endl;
354	cout << "outsize=" << outsize << endl;
355	cout << "realsize=" << realsize << endl;
356	cout << "insize=" << insize << endl;
357	cout << "realinsize=" << realinsize << endl;*/
358	iconv_close(icv);
359
360	string returnstr;
361	for (unsigned int i=0; i<realsize - outsize; i++)
362	{
363	//cout << i << ":" << (unsigned short) output[i] << "\|" << (unsigned short) input[i];
364	//cout << " (" << output[i] << ")" << endl;
365	returnstr += output[i];
366	}
367	return returnstr;
368	}
369
370	std::string convertToUnicode(std::string str)
371	{
372	return iconv_wrapper(str, "UTF-8", "ISO8859-1");
373	}
374
375	std::string convertFromUnicode(std::string str)
376	{
377	return iconv_wrapper(str, "ISO8859-1", "UTF-8");
378	}
379
380	int uTimeDiff(const timeval& then, const timeval& now)
381	{
382	return ( (now.tv_sec - then.tv_sec)*1000000) + (now.tv_usec-then.tv_usec);
383	}
384
385	int mTimeDiff(const timeval& then, const timeval& now)
386	{
387	return ( (now.tv_sec - then.tv_sec)*1000) +
388	((now.tv_usec-then.tv_usec)/1000);
389	}
390
391
392	timeval GetTimeOfDay()
393	{
394	timeval now;
395	gettimeofday(&now,0);
396	return now;
397	}
398
399	int my_system(const char* cmd, std::string* response)
400	{
401	FILE* p;
402	if ((p = popen(cmd,"r")) == NULL)
403	return (-1);
404
405	if (response)
406	{
407	std::string output;
408	char buf[256];
409	while (!feof(p))
410	{
411	int len = fread(buf,1,255, p);
412	buf[len] = 0;
413	output += buf;
414	}
415	*response = output;
416	}
417
418	return (pclose(p));
419	}
420
421	string readfile(string filename)
422	{
423	string str;
424	ifstream in(filename.c_str());
425	if (in)
426	{
427	char buffer[4096];
428	in.read(buffer, 4095);
429	buffer[ in.gcount() ] = 0;
430	str = string(buffer);
431	in.close();
432	}
433	else
434	{
435	string message = "Could not open ";
436	message += filename;
437	throw std::runtime_error(message);
438	}
439	return str;
440	}
441
442
443
444	}