projects/smsdaemon/SmsPdu.cpp

/* using http://sourceforge.net/projects/libserial/
 */


#include "SmsPdu.h"

#include <string>
#include <sstream>

#include <time.h>
#include <stdlib.h> 

#include "common.h"
#include "util.h"


using namespace std;


namespace SmsPdu
{


vector<unsigned char> BcdEncode(string input)
{
        char buf[2] = " ";
        vector<unsigned char> result;

        unsigned char current;
        for (unsigned int i=0; i<input.length(); ++i)
        {
                buf[0] = input.at(i);
                unsigned char tmp = atoi(buf);

                if ( (i%2) == 0)
                {
                        current = tmp;
                }
                else
                {
                        current |= (tmp<<4);
                        result.push_back(current);
                }
        }

        if ((input.length() % 2) == 1)
        {
                current |= 0xF0;
                result.push_back(current);
        }

        return result;
}

string HexformatVector(vector<unsigned char> vec)
{
        ostringstream os;

        for (unsigned int i=0; i<vec.size(); ++i)
        {
                os.width(2);
                os.fill('0');
                os << hex << uppercase << static_cast<unsigned int>(vec.at(i));
        }


        return os.str();
}

std::string Encode8to7bit(vector<unsigned char> vec)
{
        string result;

        return result;
}

vector<unsigned char> Encode7to8bit(std::string str)
{
        vector<unsigned char> buf;

        int shift = 0;
        for (unsigned int i=0; i<str.size(); ++i)
        {
                unsigned char current = str.at(i) & 0x7F;
                unsigned char next = ( (i+1)<str.size()) ? str.at(i+1) : 0;
                next &= 0x7F;

                current >>= shift;
                next <<= (7-shift);

                unsigned char byte = current | next;
                buf.push_back(byte);

                if (shift == 6)
                        i++;

                shift = (shift+1) % 7;

        }

        return buf;
}

vector<PduInfo> CreateSmsPdu(string to, string message, bool allowMultipart)
{
        bool multipart = allowMultipart && message.length() > 160;

        const unsigned char UDHI = multipart ? 0x40 : 0;

        srand(time(0));
        unsigned char csms_ref = rand() % 128;

        int part_count;

        const int PDU_LEN = 153;

        if (multipart)
        {
                if (message.length() > 800)
                {
                        Common::instance()->logMessage("Trying to send multipart sms > 800 bytes !!!");
                        message = message.substr(0,800);
                }

                part_count = message.length() / PDU_LEN;
                if (message.length() % PDU_LEN)
                        part_count++;
        }
        else
        {
                part_count = 1;
        }

        vector<PduInfo> result;
        for (int partnr = 0; partnr < part_count; ++partnr)
        {
                vector<unsigned char> pdu;

                pdu.push_back(0x00); // use SMSC from phone
                pdu.push_back( 0x01|UDHI ); // first octet -- no timeout
                pdu.push_back(0x00); // TP-MR message reference
                pdu.push_back(to.length() ); //length of phone nr
                pdu.push_back(0x91); // type of address (international nr  + ISDN/telephone range) - else try 0x81

                vector<unsigned char> phone = BcdEncode(to);
                pdu.insert( pdu.end(), phone.begin(), phone.end());

                pdu.push_back(0x00); // Protocol identifier
                pdu.push_back(0x00); // Data coding scheme 

                string message_part;
                if (multipart)
                {
                        message_part = message.substr(0, PDU_LEN);
                        message.erase(0, PDU_LEN);

                        pdu.push_back( message_part.length()+ 7 );  //UserDataLength
                        pdu.push_back( 0x06 ); // UDH Len
                        pdu.push_back( 0x00 ); // UDH Element Identifier
                        pdu.push_back( 0x03 ); // UDH element length
                        pdu.push_back( csms_ref ); // csms_ref reference
                        pdu.push_back( part_count );
                        pdu.push_back( partnr+1 );
                        pdu.push_back( 0x00);

                }
                else
                {
                        if (message.length() > 160)
                        {
                                message_part = message.substr(0,160); //truncate to 160
                                Common::instance()->logMessage("Truncated message");
                        }
                        else
                        {
                                message_part = message;
                        }

                        pdu.push_back( message_part.length() ); //UserDataLength
                }

                vector<unsigned char> userData = Encode7to8bit(message_part);

                pdu.insert( pdu.end(), userData.begin(), userData.end());

                PduInfo info;
                info.len = pdu.size()-1;
                info.pdu = HexformatVector(pdu);
                result.push_back(info);

        }
        return result;
}

}
1	/* using http://sourceforge.net/projects/libserial/
2	*/
3
4
5	#include "SmsPdu.h"
6
7	#include <string>
8	#include <sstream>
9
10	#include <time.h>
11	#include <stdlib.h>
12
13	#include "common.h"
14	#include "util.h"
15
16
17	using namespace std;
18
19
20	namespace SmsPdu
21	{
22
23
24	vector<unsigned char> BcdEncode(string input)
25	{
26	char buf[2] = " ";
27	vector<unsigned char> result;
28
29	unsigned char current;
30	for (unsigned int i=0; i<input.length(); ++i)
31	{
32	buf[0] = input.at(i);
33	unsigned char tmp = atoi(buf);
34
35	if ( (i%2) == 0)
36	{
37	current = tmp;
38	}
39	else
40	{
41	current \|= (tmp<<4);
42	result.push_back(current);
43	}
44	}
45
46	if ((input.length() % 2) == 1)
47	{
48	current \|= 0xF0;
49	result.push_back(current);
50	}
51
52	return result;
53	}
54
55	string HexformatVector(vector<unsigned char> vec)
56	{
57	ostringstream os;
58
59	for (unsigned int i=0; i<vec.size(); ++i)
60	{
61	os.width(2);
62	os.fill('0');
63	os << hex << uppercase << static_cast<unsigned int>(vec.at(i));
64	}
65
66
67	return os.str();
68	}
69
70	std::string Encode8to7bit(vector<unsigned char> vec)
71	{
72	string result;
73
74	return result;
75	}
76
77	vector<unsigned char> Encode7to8bit(std::string str)
78	{
79	vector<unsigned char> buf;
80
81	int shift = 0;
82	for (unsigned int i=0; i<str.size(); ++i)
83	{
84	unsigned char current = str.at(i) & 0x7F;
85	unsigned char next = ( (i+1)<str.size()) ? str.at(i+1) : 0;
86	next &= 0x7F;
87
88	current >>= shift;
89	next <<= (7-shift);
90
91	unsigned char byte = current \| next;
92	buf.push_back(byte);
93
94	if (shift == 6)
95	i++;
96
97	shift = (shift+1) % 7;
98
99	}
100
101	return buf;
102	}
103
104	vector<PduInfo> CreateSmsPdu(string to, string message, bool allowMultipart)
105	{
106	bool multipart = allowMultipart && message.length() > 160;
107
108	const unsigned char UDHI = multipart ? 0x40 : 0;
109
110	srand(time(0));
111	unsigned char csms_ref = rand() % 128;
112
113	int part_count;
114
115	const int PDU_LEN = 153;
116
117	if (multipart)
118	{
119	if (message.length() > 800)
120	{
121	Common::instance()->logMessage("Trying to send multipart sms > 800 bytes !!!");
122	message = message.substr(0,800);
123	}
124
125	part_count = message.length() / PDU_LEN;
126	if (message.length() % PDU_LEN)
127	part_count++;
128	}
129	else
130	{
131	part_count = 1;
132	}
133
134	vector<PduInfo> result;
135	for (int partnr = 0; partnr < part_count; ++partnr)
136	{
137	vector<unsigned char> pdu;
138
139	pdu.push_back(0x00); // use SMSC from phone
140	pdu.push_back( 0x01\|UDHI ); // first octet -- no timeout
141	pdu.push_back(0x00); // TP-MR message reference
142	pdu.push_back(to.length() ); //length of phone nr
143	pdu.push_back(0x91); // type of address (international nr + ISDN/telephone range) - else try 0x81
144
145	vector<unsigned char> phone = BcdEncode(to);
146	pdu.insert( pdu.end(), phone.begin(), phone.end());
147
148	pdu.push_back(0x00); // Protocol identifier
149	pdu.push_back(0x00); // Data coding scheme
150
151	string message_part;
152	if (multipart)
153	{
154	message_part = message.substr(0, PDU_LEN);
155	message.erase(0, PDU_LEN);
156
157	pdu.push_back( message_part.length()+ 7 ); //UserDataLength
158	pdu.push_back( 0x06 ); // UDH Len
159	pdu.push_back( 0x00 ); // UDH Element Identifier
160	pdu.push_back( 0x03 ); // UDH element length
161	pdu.push_back( csms_ref ); // csms_ref reference
162	pdu.push_back( part_count );
163	pdu.push_back( partnr+1 );
164	pdu.push_back( 0x00);
165
166	}
167	else
168	{
169	if (message.length() > 160)
170	{
171	message_part = message.substr(0,160); //truncate to 160
172	Common::instance()->logMessage("Truncated message");
173	}
174	else
175	{
176	message_part = message;
177	}
178
179	pdu.push_back( message_part.length() ); //UserDataLength
180	}
181
182	vector<unsigned char> userData = Encode7to8bit(message_part);
183
184	pdu.insert( pdu.end(), userData.begin(), userData.end());
185
186	PduInfo info;
187	info.len = pdu.size()-1;
188	info.pdu = HexformatVector(pdu);
189	result.push_back(info);
190
191	}
192	return result;
193	}
194
195	}