comunika_gsm 0.1.5 → 0.1.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (5) hide show
  1. checksums.yaml +4 -4
  2. data/lib/comunika_gsm/js/pdu.js +902 -1068
  3. data/lib/comunika_gsm/js/pdu.min.js +1 -1
  4. data/lib/comunika_gsm/version.rb +1 -1
  5. metadata +2 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 727a63fec3c94764ac403145b10b204ab2357e7d
4
- data.tar.gz: c173efb5048795226fcb12bbf01f728668192c37
3
+ metadata.gz: 9cf966b6250fb4add1fe67c47b7e5f3a19f99121
4
+ data.tar.gz: 1ed0b6c13643695666b2fda7b927ff02642a2e30
5
5
  SHA512:
6
- metadata.gz: 20b8fec77258c98d7ad3e99283649fad7c23652e49de074258571fdc57ae697c6cfe08bfe02cf44c067c34f017b735a927a14632486a740f559be8a2bb42ed78
7
- data.tar.gz: efc247d2b75cd2d8b0c434e4a62218724affa035722b2180b73c90bb5918be529c64c647444f85c03d533bdd8b13149778ce06fb77961f5177b1c9e8ea0e5a6a
6
+ metadata.gz: f8e26fa8198c01b1fc8d97f26368ebf2b83a5ac0db257171a424b3f5d553dcbf52e09d37716e620f974bcc9d58b9ab30447ad767698b223e88083c3a64757ac7
7
+ data.tar.gz: 2cdbaea565bafca2491344bca17e7d3404bcd7851da3c438f9de2e44101ed88c6b692ec4272d4639495a267f21b44c6e530d7f3a9ccafc2b31b042ade8339643
data/lib/comunika_gsm/js/pdu.js CHANGED
@@ -1,5 +1,3 @@
1
-
2
-
3
1
  /* Script written by Swen-Peter Ekkebus, edited by Ing. Milan Chudik.
4
2
  *
5
3
  * Further fixes and functionality by Andrew Alexander:
@@ -18,10 +16,8 @@
18
16
  *
19
17
  * (c) BPS & co, 2003
20
18
  */
21
-
22
-
23
19
  //Array with "The 7 bit defaultalphabet"
24
- sevenbitdefault = new Array('@', '£', '$', '¥', 'è', 'é', 'ù', 'ì', 'ò', 'Ç', '\n', 'Ø', 'ø', '\r','Å', 'å','\u0394', '_', '\u03a6', '\u0393', '\u039b', '\u03a9', '\u03a0','\u03a8', '\u03a3', '\u0398', '\u039e','€', 'Æ', 'æ', 'ß', 'É', ' ', '!', '"', '#', '¤', '%', '&', '\'', '(', ')','*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7','8', '9', ':', ';', '<', '=', '>', '?', '¡', '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', 'Ä', 'Ö', 'Ñ', 'Ü', '§', '¿', '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', 'ä', 'ö', 'ñ','ü', 'à', 'á');
20
+ sevenbitdefault = new Array('@', '£', '$', '¥', 'è', 'é', 'ù', 'ì', 'ò', 'Ç', '\n', 'Ø', 'ø', '\r', 'Å', 'å', '\u0394', '_', '\u03a6', '\u0393', '\u039b', '\u03a9', '\u03a0', '\u03a8', '\u03a3', '\u0398', '\u039e', '€', 'Æ', 'æ', 'ß', 'É', ' ', '!', '"', '#', '¤', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '¡', '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', 'Ä', 'Ö', 'Ñ', 'Ü', '§', '¿', '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', 'ä', 'ö', 'ñ', 'ü', 'à', 'á');
25
21
 
26
22
 
27
23
 
@@ -39,79 +35,78 @@ var alerted = false;
39
35
 
40
36
 
41
37
  // function te convert a bit string into a integer
42
- function binToInt(x)//sp
38
+ function binToInt(x) //sp
43
39
  {
44
- var total = 0;
45
- var power = parseInt(x.length)-1;
40
+ var total = 0;
41
+ var power = parseInt(x.length) - 1;
46
42
 
47
43
 
48
44
 
49
45
 
50
- for(var i=0;i<x.length;i++)
51
- {
52
- if(x.charAt(i) == '1')
53
- {
54
- total = total +Math.pow(2,power);
55
- }
56
- power --;
57
- }
58
- return total;
46
+ for (var i = 0; i < x.length; i++) {
47
+ if (x.charAt(i) == '1') {
48
+ total = total + Math.pow(2, power);
49
+ }
50
+ power--;
51
+ }
52
+ return total;
59
53
  }
60
54
 
61
55
 
62
56
 
63
57
 
64
58
  // function to convert a integer into a bit String
65
- function intToBin(x,size) //sp
59
+ function intToBin(x, size) //sp
66
60
  {
67
- var base = 2;
68
- var num = parseInt(x);
69
- var bin = num.toString(base);
70
- for(var i=bin.length;i<size;i++)
71
- {
72
- bin = "0" + bin;
73
- }
74
- return bin;
61
+ var base = 2;
62
+ var num = parseInt(x);
63
+ var bin = num.toString(base);
64
+ for (var i = bin.length; i < size; i++) {
65
+ bin = "0" + bin;
66
+ }
67
+ return bin;
75
68
  }
76
69
 
77
70
 
78
71
 
79
72
 
80
73
  // function to convert a Hexnumber into a 10base number
81
- function HexToNum(numberS)
82
- {
83
- var tens = MakeNum(numberS.substring(0,1));
84
-
85
- var ones = 0;
86
- if(numberS.length > 1) // means two characters entered
87
- ones=MakeNum(numberS.substring(1,2));
88
- if(ones == 'X')
89
- {
90
- return "00";
91
- }
92
- return (tens * 16) + (ones * 1);
74
+ function HexToNum(numberS) {
75
+ var tens = MakeNum(numberS.substring(0, 1));
76
+
77
+ var ones = 0;
78
+ if (numberS.length > 1) // means two characters entered
79
+ ones = MakeNum(numberS.substring(1, 2));
80
+ if (ones == 'X') {
81
+ return "00";
82
+ }
83
+ return (tens * 16) + (ones * 1);
93
84
  }
94
85
 
95
86
 
96
87
 
97
88
 
98
89
  // helper function for HexToNum
99
- function MakeNum(str)
100
- {
101
- if((str >= '0') && (str <= '9'))
102
- return str;
103
- switch(str.toUpperCase())
104
- {
105
- case "A": return 10;
106
- case "B": return 11;
107
- case "C": return 12;
108
- case "D": return 13;
109
- case "E": return 14;
110
- case "F": return 15;
111
- default:
112
- return 16;
113
- }
114
- return 16;
90
+ function MakeNum(str) {
91
+ if ((str >= '0') && (str <= '9'))
92
+ return str;
93
+ switch (str.toUpperCase()) {
94
+ case "A":
95
+ return 10;
96
+ case "B":
97
+ return 11;
98
+ case "C":
99
+ return 12;
100
+ case "D":
101
+ return 13;
102
+ case "E":
103
+ return 14;
104
+ case "F":
105
+ return 15;
106
+ default:
107
+ return 16;
108
+ }
109
+ return 16;
115
110
  }
116
111
 
117
112
 
@@ -123,125 +118,114 @@ function MakeNum(str)
123
118
 
124
119
 
125
120
  function intToHex(i) //sp
126
- {
127
- var sHex = "0123456789ABCDEF";
128
- h = "";
129
- i = parseInt(i);
130
- for(j = 0; j <= 3; j++)
131
- {
132
- h += sHex.charAt((i >> (j * 8 + 4)) & 0x0F) +
133
- sHex.charAt((i >> (j * 8)) & 0x0F);
134
- }
135
- return h.substring(0,2);
121
+ {
122
+ var sHex = "0123456789ABCDEF";
123
+ h = "";
124
+ i = parseInt(i);
125
+ for (j = 0; j <= 3; j++) {
126
+ h += sHex.charAt((i >> (j * 8 + 4)) & 0x0F) +
127
+ sHex.charAt((i >> (j * 8)) & 0x0F);
128
+ }
129
+ return h.substring(0, 2);
136
130
  }
137
131
 
138
132
 
139
133
 
140
134
 
141
- function ToHex(i)
142
- {
143
- var sHex = "0123456789ABCDEF";
144
- var Out = "";
135
+ function ToHex(i) {
136
+ var sHex = "0123456789ABCDEF";
137
+ var Out = "";
145
138
 
146
139
 
147
140
 
148
141
 
149
- Out = sHex.charAt(i&0xf);
150
- i>>=4;
151
- Out = sHex.charAt(i&0xf) + Out;
142
+ Out = sHex.charAt(i & 0xf);
143
+ i >>= 4;
144
+ Out = sHex.charAt(i & 0xf) + Out;
152
145
 
153
146
 
154
147
 
155
148
 
156
- return Out;
149
+ return Out;
157
150
  }
158
151
 
159
152
 
160
153
 
161
154
 
162
-
163
-
164
-
165
-
166
155
  function getSevenBit(character) //sp
167
156
  {
168
- for(var i=0;i<sevenbitdefault.length;i++)
169
- {
170
- if(sevenbitdefault[i] == character)
171
- {
172
- return i;
173
- }
174
- }
175
- //alert("No 7 bit char for " + character);
176
- return 0;
157
+ for (var i = 0; i < sevenbitdefault.length; i++) {
158
+ if (sevenbitdefault[i] == character) {
159
+ return i;
160
+ }
161
+ }
162
+ //alert("No 7 bit char for " + character);
163
+ return 0;
177
164
  }
178
165
 
179
166
 
180
167
 
181
168
 
182
- function getEightBit(character)
183
- {
184
- return character;
169
+ function getEightBit(character) {
170
+ return character;
185
171
  }
186
172
 
187
173
 
188
174
 
189
175
 
190
- function get16Bit(character)
191
- {
192
- return character;
176
+ function get16Bit(character) {
177
+ return character;
193
178
  }
194
179
 
195
180
 
196
181
 
197
182
 
198
- function phoneNumberMap(character)
199
- {
200
- // return character;
201
- if((character >= '0') && (character <= '9'))
202
- {
203
- return character;
204
- }
205
- switch(character.toUpperCase())
206
- {
207
- case '*':
208
- return 'A';
209
- case '#':
210
- return 'B';
211
- case 'A':
212
- return 'C';
213
- case 'B':
214
- return 'D';
215
- case 'C':
216
- return 'E';
217
- // case '+':
218
- // return '+'; // An exception to fit with current processing ...
219
- default:
220
- return 'F';
221
- }
222
- return 'F';
183
+ function phoneNumberMap(character) {
184
+ // return character;
185
+ if ((character >= '0') && (character <= '9')) {
186
+ return character;
187
+ }
188
+ switch (character.toUpperCase()) {
189
+ case '*':
190
+ return 'A';
191
+ case '#':
192
+ return 'B';
193
+ case 'A':
194
+ return 'C';
195
+ case 'B':
196
+ return 'D';
197
+ case 'C':
198
+ return 'E';
199
+ // case '+':
200
+ // return '+'; // An exception to fit with current processing ...
201
+ default:
202
+ return 'F';
203
+ }
204
+ return 'F';
223
205
  }
224
206
 
225
207
 
226
208
 
227
209
 
228
- function phoneNumberUnMap(chararacter)
229
- {
230
- if((chararacter >= '0') && (chararacter <= '9'))
231
- {
232
- return chararacter;
233
- }
234
- switch(chararacter)
235
- {
236
- case 10: return '*';
237
- case 11: return '#';
238
- case 12: return 'A';
239
- case 13: return 'B';
240
- case 14: return 'C';
241
- default:
242
- return 'F';
243
- }
244
- return 'F';
210
+ function phoneNumberUnMap(chararacter) {
211
+ if ((chararacter >= '0') && (chararacter <= '9')) {
212
+ return chararacter;
213
+ }
214
+ switch (chararacter) {
215
+ case 10:
216
+ return '*';
217
+ case 11:
218
+ return '#';
219
+ case 12:
220
+ return 'A';
221
+ case 13:
222
+ return 'B';
223
+ case 14:
224
+ return 'C';
225
+ default:
226
+ return 'F';
227
+ }
228
+ return 'F';
245
229
  }
246
230
 
247
231
 
@@ -250,955 +234,845 @@ function phoneNumberUnMap(chararacter)
250
234
  // function to convert semioctets to a string
251
235
  function semiOctetToString(inp) //sp
252
236
  {
253
- var out = "";
254
- for(var i=0;i<inp.length;i=i+2)
255
- {
256
- var temp = inp.substring(i,i+2);
257
- out = out + phoneNumberMap(temp.charAt(1)) + phoneNumberMap(temp.charAt(0));
258
- }
237
+ var out = "";
238
+ for (var i = 0; i < inp.length; i = i + 2) {
239
+ var temp = inp.substring(i, i + 2);
240
+ out = out + phoneNumberMap(temp.charAt(1)) + phoneNumberMap(temp.charAt(0));
241
+ }
259
242
 
260
243
 
261
244
 
262
245
 
263
- return out;
246
+ return out;
264
247
  }
265
248
 
266
249
 
267
250
 
268
251
 
269
-
270
-
271
-
272
-
273
252
  //Main function to translate the input to a "human readable" string
274
- function getUserMessage(input,truelength) // Add truelength AJA
253
+ function getUserMessage(input, truelength) // Add truelength AJA
275
254
  {
276
- var byteString = "";
277
- octetArray = new Array();
278
- restArray = new Array();
279
- septetsArray = new Array();
280
- var s=1;
281
- var count = 0;
282
- var matchcount = 0; // AJA
283
- var smsMessage = "";
284
-
285
- var calculation1 = "<table border=1 ><tr><td align=center width=75><b>Hex</b></td>";
286
- var calculation2 = "<tr><td align=center width=75> <b>&nbsp;&nbsp;&nbsp;Octets&nbsp;&nbsp;&nbsp;</b></td>";
287
- var calculation3 = "<table border=1 ><tr><td align=center width=75><b>septets</b></td>";
288
- var calculation4 = "<tr><td align=center width=75><b>Character</b></td>";
289
- calculation = "";
290
-
291
-
292
-
293
-
294
- //Cut the input string into pieces of2 (just get the hex octets)
295
- for(var i=0;i<input.length;i=i+2)
296
- {
297
- var hex = input.substring(i,i+2);
298
- byteString = byteString + intToBin(HexToNum(hex),8);
299
- if((i%14 == 0 && i!=0))
300
- {
301
- calculation1 = calculation1 + "<td align=center width=75>+++++++</td>";
302
- }
303
- calculation1 = calculation1 + "<td align=center width=75>" + hex + "</td>";
304
-
305
- }
306
- calculation1 = calculation1 + "<td align=center width=75>+++++++</td>";
307
-
308
- // make two array's these are nessesery to
309
- for(var i=0;i<byteString.length;i=i+8)
310
- {
311
- octetArray[count] = byteString.substring(i,i+8);
312
- restArray[count] = octetArray[count].substring(0,(s%8));
313
- septetsArray[count] = octetArray[count].substring((s%8),8);
314
- if((i%56 == 0 && i!=0))
315
- {
316
- calculation2 = calculation2 + "<td align=center width=75>&nbsp;</td>";
317
- }
318
- calculation2 = calculation2 + "<td align=center width=75><span style='background-color: #FFFF00'>" + restArray[count] + "</span>"+ septetsArray[count]+"</td>";
319
-
320
-
321
-
322
-
323
-
324
- s++;
325
- count++;
326
- if(s == 8)
327
- {
328
- s = 1;
329
- }
330
- }
331
- calculation2 = calculation2 + "<td align=center width=75>&nbsp;</td>";
332
-
333
- // put the right parts of the array's together to make the sectets
334
- for(var i=0;i<restArray.length;i++)
335
- {
336
-
337
- if(i%7 == 0)
338
- {
339
- if(i != 0)
340
- {
341
- smsMessage = smsMessage + sevenbitdefault[binToInt(restArray[i-1])];
342
- calculation3 = calculation3 + "<td align=center width=75><span style='background-color: #FFFF00'>&nbsp;" + restArray[i-1] + "</span>&nbsp;</td>";
343
- calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(restArray[i-1])] + "&nbsp;</td>";
344
- matchcount ++; // AJA
345
- }
346
- smsMessage = smsMessage + sevenbitdefault[binToInt(septetsArray[i])];
347
- calculation3 = calculation3 + "<td align=center width=75>&nbsp;" +septetsArray[i] + "&nbsp;</td>";
348
- calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(septetsArray[i])] + "&nbsp;</td>";
349
- matchcount ++; // AJA
350
- }
351
- else
352
- {
353
- smsMessage = smsMessage + sevenbitdefault[binToInt(septetsArray[i]+restArray[i-1])];
354
- calculation3 = calculation3 + "<td align=center width=75>&nbsp;" +septetsArray[i]+ "<span style='background-color: #FFFF00'>" +restArray[i-1] + "&nbsp;</span>" + "</td>"
355
- calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(septetsArray[i]+restArray[i-1])] + "&nbsp;</td>";
356
- matchcount ++; // AJA
357
- }
358
-
359
- }
360
- if(matchcount != truelength) // Don't forget trailing characters!! AJA
361
- {
362
- smsMessage = smsMessage + sevenbitdefault[binToInt(restArray[i-1])];
363
- calculation3 = calculation3 + "<td align=center width=75><span style='background-color: #FFFF00'>&nbsp;" + restArray[i-1] + "</span>&nbsp;</td>";
364
- calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(restArray[i-1])] + "&nbsp;</td>";
365
- }
366
- else // Blank Filler
367
- {
368
- calculation3 = calculation3 + "<td align=center width=75>+++++++</td>";
369
- calculation4 = calculation4 + "<td align=center width=75>&nbsp;</td>";
370
- }
371
-
372
- //Put all the calculation info together
373
- calculation = "Conversion of 8-bit octets to 7-bit default alphabet<br><br>"+calculation1 + "</tr>" + calculation2 + "</tr></table>" + calculation3 + "</tr>"+ calculation4 + "</tr></table>";
374
-
375
-
376
-
377
-
378
- return smsMessage;
255
+ var byteString = "";
256
+ octetArray = new Array();
257
+ restArray = new Array();
258
+ septetsArray = new Array();
259
+ var s = 1;
260
+ var count = 0;
261
+ var matchcount = 0; // AJA
262
+ var smsMessage = "";
263
+
264
+ var calculation1 = "<table border=1 ><tr><td align=center width=75><b>Hex</b></td>";
265
+ var calculation2 = "<tr><td align=center width=75> <b>&nbsp;&nbsp;&nbsp;Octets&nbsp;&nbsp;&nbsp;</b></td>";
266
+ var calculation3 = "<table border=1 ><tr><td align=center width=75><b>septets</b></td>";
267
+ var calculation4 = "<tr><td align=center width=75><b>Character</b></td>";
268
+ calculation = "";
269
+
270
+
271
+
272
+
273
+ //Cut the input string into pieces of2 (just get the hex octets)
274
+ for (var i = 0; i < input.length; i = i + 2) {
275
+ var hex = input.substring(i, i + 2);
276
+ byteString = byteString + intToBin(HexToNum(hex), 8);
277
+ if ((i % 14 == 0 && i != 0)) {
278
+ calculation1 = calculation1 + "<td align=center width=75>+++++++</td>";
279
+ }
280
+ calculation1 = calculation1 + "<td align=center width=75>" + hex + "</td>";
281
+
282
+ }
283
+ calculation1 = calculation1 + "<td align=center width=75>+++++++</td>";
284
+
285
+ // make two array's these are nessesery to
286
+ for (var i = 0; i < byteString.length; i = i + 8) {
287
+ octetArray[count] = byteString.substring(i, i + 8);
288
+ restArray[count] = octetArray[count].substring(0, (s % 8));
289
+ septetsArray[count] = octetArray[count].substring((s % 8), 8);
290
+ if ((i % 56 == 0 && i != 0)) {
291
+ calculation2 = calculation2 + "<td align=center width=75>&nbsp;</td>";
292
+ }
293
+ calculation2 = calculation2 + "<td align=center width=75><span style='background-color: #FFFF00'>" + restArray[count] + "</span>" + septetsArray[count] + "</td>";
294
+
295
+
296
+
297
+
298
+ s++;
299
+ count++;
300
+ if (s == 8) {
301
+ s = 1;
302
+ }
303
+ }
304
+ calculation2 = calculation2 + "<td align=center width=75>&nbsp;</td>";
305
+
306
+ // put the right parts of the array's together to make the sectets
307
+ for (var i = 0; i < restArray.length; i++) {
308
+
309
+ if (i % 7 == 0) {
310
+ if (i != 0) {
311
+ smsMessage = smsMessage + sevenbitdefault[binToInt(restArray[i - 1])];
312
+ calculation3 = calculation3 + "<td align=center width=75><span style='background-color: #FFFF00'>&nbsp;" + restArray[i - 1] + "</span>&nbsp;</td>";
313
+ calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(restArray[i - 1])] + "&nbsp;</td>";
314
+ matchcount++; // AJA
315
+ }
316
+ smsMessage = smsMessage + sevenbitdefault[binToInt(septetsArray[i])];
317
+ calculation3 = calculation3 + "<td align=center width=75>&nbsp;" + septetsArray[i] + "&nbsp;</td>";
318
+ calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(septetsArray[i])] + "&nbsp;</td>";
319
+ matchcount++; // AJA
320
+ } else {
321
+ smsMessage = smsMessage + sevenbitdefault[binToInt(septetsArray[i] + restArray[i - 1])];
322
+ calculation3 = calculation3 + "<td align=center width=75>&nbsp;" + septetsArray[i] + "<span style='background-color: #FFFF00'>" + restArray[i - 1] + "&nbsp;</span>" + "</td>"
323
+ calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(septetsArray[i] + restArray[i - 1])] + "&nbsp;</td>";
324
+ matchcount++; // AJA
325
+ }
326
+
327
+ }
328
+ if (matchcount != truelength) // Don't forget trailing characters!! AJA
329
+ {
330
+ smsMessage = smsMessage + sevenbitdefault[binToInt(restArray[i - 1])];
331
+ calculation3 = calculation3 + "<td align=center width=75><span style='background-color: #FFFF00'>&nbsp;" + restArray[i - 1] + "</span>&nbsp;</td>";
332
+ calculation4 = calculation4 + "<td align=center width=75>&nbsp;" + sevenbitdefault[binToInt(restArray[i - 1])] + "&nbsp;</td>";
333
+ } else // Blank Filler
334
+ {
335
+ calculation3 = calculation3 + "<td align=center width=75>+++++++</td>";
336
+ calculation4 = calculation4 + "<td align=center width=75>&nbsp;</td>";
337
+ }
338
+
339
+ //Put all the calculation info together
340
+ calculation = "Conversion of 8-bit octets to 7-bit default alphabet<br><br>" + calculation1 + "</tr>" + calculation2 + "</tr></table>" + calculation3 + "</tr>" + calculation4 + "</tr></table>";
341
+
342
+
343
+
344
+
345
+ return smsMessage;
379
346
  }
380
347
 
381
348
 
382
349
 
383
350
 
384
- function getUserMessage16(input,truelength)
385
- {
386
- var smsMessage = "";
387
- calculation = "Not implemented";
351
+ function getUserMessage16(input, truelength) {
352
+ var smsMessage = "";
353
+ calculation = "Not implemented";
388
354
 
389
355
 
390
356
 
391
357
 
392
- // Cut the input string into pieces of 4
393
- for(var i=0;i<input.length;i=i+4)
394
- {
395
- var hex1 = input.substring(i,i+2);
396
- var hex2 = input.substring(i+2,i+4);
397
- smsMessage += "" + String.fromCharCode(HexToNum(hex1)*256+HexToNum(hex2));
398
- }
358
+ // Cut the input string into pieces of 4
359
+ for (var i = 0; i < input.length; i = i + 4) {
360
+ var hex1 = input.substring(i, i + 2);
361
+ var hex2 = input.substring(i + 2, i + 4);
362
+ smsMessage += "" + String.fromCharCode(HexToNum(hex1) * 256 + HexToNum(hex2));
363
+ }
399
364
 
400
- return smsMessage;
365
+ return smsMessage;
401
366
  }
402
367
 
403
368
 
404
369
 
405
370
 
406
- function getUserMessage8(input,truelength)
407
- {
408
- var smsMessage = "";
409
- calculation = "Not implemented";
371
+ function getUserMessage8(input, truelength) {
372
+ var smsMessage = "";
373
+ calculation = "Not implemented";
410
374
 
411
375
 
412
376
 
413
377
 
414
- // Cut the input string into pieces of 2 (just get the hex octets)
415
- for(var i=0;i<input.length;i=i+2)
416
- {
417
- var hex = input.substring(i,i+2);
418
- smsMessage += "" + String.fromCharCode(HexToNum(hex));
419
- }
378
+ // Cut the input string into pieces of 2 (just get the hex octets)
379
+ for (var i = 0; i < input.length; i = i + 2) {
380
+ var hex = input.substring(i, i + 2);
381
+ smsMessage += "" + String.fromCharCode(HexToNum(hex));
382
+ }
420
383
 
421
- return smsMessage;
384
+ return smsMessage;
422
385
  }
423
386
 
424
387
  // Function to get SMSmeta info information from PDU String
425
- function getPDUMetaInfo(inp)
426
- {
427
- var PDUString = inp;
428
- var start = 0;
429
- var out="";
430
-
431
-
432
-
433
-
434
- // Silently Strip leading AT command
435
- if (PDUString.substr(0,2)=="AT")
436
- {
437
- for(var i=0;i<PDUString.length;i++)
438
- {
439
- if(PDUString.charCodeAt(i)==10)
440
- {
441
- PDUString = PDUString.substr(i+1);
442
- break;
443
- }
444
- }
445
- }
446
-
447
-
388
+ function getPDUMetaInfo(inp) {
389
+ var PDUString = inp;
390
+ var start = 0;
391
+ var out = "";
392
+
448
393
 
449
394
 
450
- // Silently strip whitespace
451
- var NewPDU="";
452
- for(var i=0;i<PDUString.length;i++)
453
- {
454
- if (MakeNum(PDUString.substr(i,1))!=16)
455
- {
456
- NewPDU = NewPDU + PDUString.substr(i,1);
457
- }
458
- }
459
- PDUString = NewPDU;
460
395
 
396
+ // Silently Strip leading AT command
397
+ if (PDUString.substr(0, 2) == "AT") {
398
+ for (var i = 0; i < PDUString.length; i++) {
399
+ if (PDUString.charCodeAt(i) == 10) {
400
+ PDUString = PDUString.substr(i + 1);
401
+ break;
402
+ }
403
+ }
404
+ }
461
405
 
462
406
 
463
407
 
464
- var SMSC_lengthInfo = HexToNum(PDUString.substring(0,2));
465
- var SMSC_info = PDUString.substring(2,2+(SMSC_lengthInfo*2));
466
- var SMSC_TypeOfAddress = SMSC_info.substring(0,2);
467
- var SMSC_Number = SMSC_info.substring(2,2+(SMSC_lengthInfo*2));
468
408
 
409
+ // Silently strip whitespace
410
+ var NewPDU = "";
411
+ for (var i = 0; i < PDUString.length; i++) {
412
+ if (MakeNum(PDUString.substr(i, 1)) != 16) {
413
+ NewPDU = NewPDU + PDUString.substr(i, 1);
414
+ }
415
+ }
416
+ PDUString = NewPDU;
469
417
 
470
418
 
471
419
 
472
- if (SMSC_lengthInfo != 0)
473
- {
474
- SMSC_Number = semiOctetToString(SMSC_Number);
475
420
 
476
- // if the length is odd remove the trailing F
477
- if((SMSC_Number.substr(SMSC_Number.length-1,1) == 'F') || (SMSC_Number.substr(SMSC_Number.length-1,1) == 'f'))
478
- {
479
- SMSC_Number = SMSC_Number.substring(0,SMSC_Number.length-1);
480
- }
481
- if (SMSC_TypeOfAddress == 91)
482
- {
483
- SMSC_Number = "+" + SMSC_Number;
484
- }
485
- }
421
+ var SMSC_lengthInfo = HexToNum(PDUString.substring(0, 2));
422
+ var SMSC_info = PDUString.substring(2, 2 + (SMSC_lengthInfo * 2));
423
+ var SMSC_TypeOfAddress = SMSC_info.substring(0, 2);
424
+ var SMSC_Number = SMSC_info.substring(2, 2 + (SMSC_lengthInfo * 2));
486
425
 
487
- var start_SMSDeleivery = (SMSC_lengthInfo*2)+2;
488
426
 
489
- start = start_SMSDeleivery;
490
- var firstOctet_SMSDeliver = PDUString.substr(start,2);
491
- start = start + 2;
492
- if ((HexToNum(firstOctet_SMSDeliver) & 0x20) == 0x20)
493
- {
494
- out += "Type::::Receipt requested\n";
495
- }
496
- var DataHeader = 0;
497
- if ((HexToNum(firstOctet_SMSDeliver) & 0x40) == 0x40)
498
- {
499
- DataHeader = 1;
500
- out += "Type::::Data Header\n";
501
- }
502
427
 
503
- // bit1 bit0 Message type
504
- // 0 0 SMS DELIVER (in the direction SC to MS)
505
- // 0 0 SMS DELIVER REPORT (in the direction MS to SC)
506
- // 1 0 SMS STATUS REPORT (in the direction SC to MS)
507
- // 1 0 SMS COMMAND (in the direction MS to SC)
508
- // 0 1 SMS SUBMIT (in the direction MS to SC)
509
- // 0 1 SMS SUBMIT REPORT (in the direction SC to MS)
510
- // 1 1 Reserved
511
428
 
512
- // This needs tidying up!! AJA
429
+ if (SMSC_lengthInfo != 0) {
430
+ SMSC_Number = semiOctetToString(SMSC_Number);
513
431
 
514
- if ((HexToNum(firstOctet_SMSDeliver) & 0x03) == 1 || (HexToNum(firstOctet_SMSDeliver) & 0x03) == 3) // Transmit Message
515
- {
516
- if ((HexToNum(firstOctet_SMSDeliver) & 0x03) == 3)
517
- {
518
- out = "Type::::Unknown Message\nTreat as Deliver\n";
519
- }
520
- var MessageReference = HexToNum(PDUString.substr(start,2));
521
- start = start + 2;
432
+ // if the length is odd remove the trailing F
433
+ if ((SMSC_Number.substr(SMSC_Number.length - 1, 1) == 'F') || (SMSC_Number.substr(SMSC_Number.length - 1, 1) == 'f')) {
434
+ SMSC_Number = SMSC_Number.substring(0, SMSC_Number.length - 1);
435
+ }
436
+ if (SMSC_TypeOfAddress == 91) {
437
+ SMSC_Number = "+" + SMSC_Number;
438
+ }
439
+ }
522
440
 
523
- // length in decimals
524
- var sender_addressLength = HexToNum(PDUString.substr(start,2));
525
- if(sender_addressLength%2 != 0)
526
- {
527
- sender_addressLength +=1;
528
- }
529
- start = start + 2;
441
+ var start_SMSDeleivery = (SMSC_lengthInfo * 2) + 2;
530
442
 
531
- var sender_typeOfAddress = PDUString.substr(start,2);
532
- start = start + 2
443
+ start = start_SMSDeleivery;
444
+ var firstOctet_SMSDeliver = PDUString.substr(start, 2);
445
+ start = start + 2;
446
+ if ((HexToNum(firstOctet_SMSDeliver) & 0x20) == 0x20) {
447
+ out += "Type::::Receipt requested\n";
448
+ }
449
+ var DataHeader = 0;
450
+ if ((HexToNum(firstOctet_SMSDeliver) & 0x40) == 0x40) {
451
+ DataHeader = 1;
452
+ out += "Type::::Data Header\n";
453
+ }
533
454
 
534
- var sender_number = semiOctetToString(PDUString.substring(start,start+sender_addressLength));
455
+ // bit1 bit0 Message type
456
+ // 0 0 SMS DELIVER (in the direction SC to MS)
457
+ // 0 0 SMS DELIVER REPORT (in the direction MS to SC)
458
+ // 1 0 SMS STATUS REPORT (in the direction SC to MS)
459
+ // 1 0 SMS COMMAND (in the direction MS to SC)
460
+ // 0 1 SMS SUBMIT (in the direction MS to SC)
461
+ // 0 1 SMS SUBMIT REPORT (in the direction SC to MS)
462
+ // 1 1 Reserved
535
463
 
536
- if((sender_number.substr(sender_number.length-1,1) == 'F') || (sender_number.substr(sender_number.length-1,1) == 'f' ))
537
- {
538
- sender_number = sender_number.substring(0,sender_number.length-1);
539
- }
540
- if (sender_typeOfAddress == 91)
541
- {
542
- sender_number = "+" + sender_number;
543
- }
544
- start +=sender_addressLength;
464
+ // This needs tidying up!! AJA
545
465
 
466
+ if ((HexToNum(firstOctet_SMSDeliver) & 0x03) == 1 || (HexToNum(firstOctet_SMSDeliver) & 0x03) == 3) // Transmit Message
467
+ {
468
+ if ((HexToNum(firstOctet_SMSDeliver) & 0x03) == 3) {
469
+ out = "Type::::Unknown Message\nTreat as Deliver\n";
470
+ }
471
+ var MessageReference = HexToNum(PDUString.substr(start, 2));
472
+ start = start + 2;
546
473
 
474
+ // length in decimals
475
+ var sender_addressLength = HexToNum(PDUString.substr(start, 2));
476
+ if (sender_addressLength % 2 != 0) {
477
+ sender_addressLength += 1;
478
+ }
479
+ start = start + 2;
547
480
 
481
+ var sender_typeOfAddress = PDUString.substr(start, 2);
482
+ start = start + 2
548
483
 
549
- var tp_PID = PDUString.substr(start,2);
550
- start +=2;
484
+ var sender_number = semiOctetToString(PDUString.substring(start, start + sender_addressLength));
551
485
 
486
+ if ((sender_number.substr(sender_number.length - 1, 1) == 'F') || (sender_number.substr(sender_number.length - 1, 1) == 'f')) {
487
+ sender_number = sender_number.substring(0, sender_number.length - 1);
488
+ }
489
+ if (sender_typeOfAddress == 91) {
490
+ sender_number = "+" + sender_number;
491
+ }
492
+ start += sender_addressLength;
552
493
 
553
494
 
554
495
 
555
- var tp_DCS = PDUString.substr(start,2);
556
- var tp_DCS_desc = tpDCSMeaning(tp_DCS);
557
- start +=2;
558
496
 
497
+ var tp_PID = PDUString.substr(start, 2);
498
+ start += 2;
559
499
 
560
500
 
561
501
 
562
- var ValidityPeriod;
563
- switch( (HexToNum(firstOctet_SMSDeliver) & 0x18) )
564
- {
565
- case 0: // Not Present
566
- ValidityPeriod = "Not Present";
567
- break;
568
- case 0x10: // Relative
569
- ValidityPeriod = "Rel " + cValid(HexToNum(PDUString.substr(start,2)));
570
- start +=2;
571
- break;
572
- case 0x08: // Enhanced
573
- ValidityPeriod = "Enhanced - Not Decoded";
574
- start +=14;
575
- break;
576
- case 0x18: // Absolute
577
- ValidityPeriod = "Absolute - Not Decoded";
578
- start +=14;
579
- break;
580
- }
581
502
 
503
+ var tp_DCS = PDUString.substr(start, 2);
504
+ var tp_DCS_desc = tpDCSMeaning(tp_DCS);
505
+ start += 2;
582
506
 
583
507
 
584
508
 
585
- // Commonish...
586
- var messageLength = HexToNum(PDUString.substr(start,2));
587
509
 
588
- start += 2;
510
+ var ValidityPeriod;
511
+ switch ((HexToNum(firstOctet_SMSDeliver) & 0x18)) {
512
+ case 0: // Not Present
513
+ ValidityPeriod = "Not Present";
514
+ break;
515
+ case 0x10: // Relative
516
+ ValidityPeriod = "Rel " + cValid(HexToNum(PDUString.substr(start, 2)));
517
+ start += 2;
518
+ break;
519
+ case 0x08: // Enhanced
520
+ ValidityPeriod = "Enhanced - Not Decoded";
521
+ start += 14;
522
+ break;
523
+ case 0x18: // Absolute
524
+ ValidityPeriod = "Absolute - Not Decoded";
525
+ start += 14;
526
+ break;
527
+ }
589
528
 
590
- var bitSize = DCS_Bits(tp_DCS);
591
- var userData = "Undefined format";
592
- if (bitSize==7)
593
- {
594
- userData = getUserMessage(PDUString.substr(start,PDUString.length-start),messageLength);
595
- }
596
- else if (bitSize==8)
597
- {
598
- userData = getUserMessage8(PDUString.substr(start,PDUString.length-start),messageLength);
599
- }
600
- else if (bitSize==16)
601
- {
602
- userData = getUserMessage16(PDUString.substr(start,PDUString.length-start),messageLength);
603
- }
604
529
 
605
530
 
606
531
 
532
+ // Commonish...
533
+ var messageLength = HexToNum(PDUString.substr(start, 2));
607
534
 
608
- userData = userData.substr(0,messageLength);
609
- if (bitSize==16)
610
- {
611
- messageLength/=2;
612
- }
535
+ start += 2;
613
536
 
537
+ var bitSize = DCS_Bits(tp_DCS);
538
+ var userData = "Undefined format";
539
+ if (bitSize == 7) {
540
+ userData = getUserMessage(PDUString.substr(start, PDUString.length - start), messageLength);
541
+ } else if (bitSize == 8) {
542
+ userData = getUserMessage8(PDUString.substr(start, PDUString.length - start), messageLength);
543
+ } else if (bitSize == 16) {
544
+ userData = getUserMessage16(PDUString.substr(start, PDUString.length - start), messageLength);
545
+ }
614
546
 
615
- if (out.length == 0)
616
- {
617
- out = "Type::::Message:\n";
618
- }
619
547
 
620
- out += "SMSC::::"+SMSC_Number+"\nReceipient::::"+sender_number+"\nValidity::::" + ValidityPeriod + "\nTP_PID::::"+tp_PID+"\nTP_DCS::::"+tp_DCS+"\nTP_DCS-popis::::"+tp_DCS_desc+"Message::::"+userData+"\nLength::::"+messageLength;
621
- }
622
- else // Receive Message
623
- if ((HexToNum(firstOctet_SMSDeliver) & 0x03) == 0) // Receive Message
624
- {
625
- // length in decimals
626
- //out += "Type: Receive Message\n";
627
- var sender_addressLength = HexToNum(PDUString.substr(start,2));
628
548
 
629
549
 
550
+ userData = userData.substr(0, messageLength);
551
+ if (bitSize == 16) {
552
+ messageLength /= 2;
553
+ }
630
554
 
631
555
 
632
- start = start + 2;
556
+ if (out.length == 0) {
557
+ out = "Type::::Message:\n";
558
+ }
633
559
 
560
+ out += "SMSC::::" + SMSC_Number + "\nReceipient::::" + sender_number + "\nValidity::::" + ValidityPeriod + "\nTP_PID::::" + tp_PID + "\nTP_DCS::::" + tp_DCS + "\nTP_DCS-popis::::" + tp_DCS_desc + "Message::::" + userData + "\nLength::::" + messageLength;
561
+ } else // Receive Message
562
+ if ((HexToNum(firstOctet_SMSDeliver) & 0x03) == 0) // Receive Message
563
+ {
564
+ // length in decimals
565
+ out = "Type: Receive Message::::";
566
+ var sender_addressLength = HexToNum(PDUString.substr(start, 2));
634
567
 
635
568
 
636
569
 
637
- var sender_typeOfAddress = PDUString.substr(start,2);
638
- start = start + 2
639
570
 
571
+ start = start + 2;
640
572
 
641
573
 
642
574
 
643
- var sender_number;
644
- if (sender_typeOfAddress == "D0")
645
- {
646
- _sl = sender_addressLength;
647
575
 
576
+ var sender_typeOfAddress = PDUString.substr(start, 2);
577
+ start = start + 2
648
578
 
649
579
 
650
580
 
651
- if(sender_addressLength%2 != 0)
652
- {
653
- sender_addressLength +=1;
654
- }
655
581
 
582
+ var sender_number;
583
+ if (sender_typeOfAddress == "D0") {
584
+ _sl = sender_addressLength;
656
585
 
657
586
 
658
587
 
659
- //alert(sender_addressLength);
660
- //alert(_sl);
661
588
 
589
+ if (sender_addressLength % 2 != 0) {
590
+ sender_addressLength += 1;
591
+ }
662
592
 
663
593
 
664
594
 
665
- //alert(parseInt(sender_addressLength/2*8/7));
666
- //alert(parseInt(_sl/2*8/7));
667
595
 
596
+ //alert(sender_addressLength);
597
+ //alert(_sl);
668
598
 
669
599
 
670
600
 
671
- //alert(PDUString.substring(start,start+sender_addressLength));
672
- //alert(PDUString.substring(start,start+_sl));
673
601
 
602
+ //alert(parseInt(sender_addressLength/2*8/7));
603
+ //alert(parseInt(_sl/2*8/7));
674
604
 
675
605
 
676
606
 
677
- // sender_number = getUserMessage(PDUString.substring(start,start+sender_addressLength),parseInt(sender_addressLength/2*8/7));
678
- sender_number = getUserMessage(PDUString.substring(start,start+sender_addressLength),parseInt(_sl/2*8/7));
679
- //alert(sender_number);
680
- }
681
- else
682
- {
683
607
 
608
+ //alert(PDUString.substring(start,start+sender_addressLength));
609
+ //alert(PDUString.substring(start,start+_sl));
684
610
 
685
611
 
686
612
 
687
- if(sender_addressLength%2 != 0)
688
- {
689
- sender_addressLength +=1;
690
- }
691
613
 
614
+ // sender_number = getUserMessage(PDUString.substring(start,start+sender_addressLength),parseInt(sender_addressLength/2*8/7));
615
+ sender_number = getUserMessage(PDUString.substring(start, start + sender_addressLength), parseInt(_sl / 2 * 8 / 7));
616
+ //alert(sender_number);
617
+ } else {
692
618
 
693
619
 
694
620
 
695
- sender_number = semiOctetToString(PDUString.substring(start,start+sender_addressLength));
696
621
 
697
- if((sender_number.substr(sender_number.length-1,1) == 'F') || (sender_number.substr(sender_number.length-1,1) == 'f' ))
698
- {
699
- sender_number = sender_number.substring(0,sender_number.length-1);
700
- }
701
- if (sender_typeOfAddress == 91)
702
- {
703
- sender_number = "+" + sender_number;
704
- }
705
- }
706
- start +=sender_addressLength;
622
+ if (sender_addressLength % 2 != 0) {
623
+ sender_addressLength += 1;
624
+ }
707
625
 
708
626
 
709
627
 
710
628
 
711
- var tp_PID = PDUString.substr(start,2);
712
- start +=2;
629
+ sender_number = semiOctetToString(PDUString.substring(start, start + sender_addressLength));
713
630
 
631
+ if ((sender_number.substr(sender_number.length - 1, 1) == 'F') || (sender_number.substr(sender_number.length - 1, 1) == 'f')) {
632
+ sender_number = sender_number.substring(0, sender_number.length - 1);
633
+ }
634
+ if (sender_typeOfAddress == 91) {
635
+ sender_number = "+" + sender_number;
636
+ }
637
+ }
638
+ start += sender_addressLength;
714
639
 
715
640
 
716
641
 
717
- var tp_DCS = PDUString.substr(start,2);
718
- var tp_DCS_desc = tpDCSMeaning(tp_DCS);
719
- start +=2;
720
642
 
643
+ var tp_PID = PDUString.substr(start, 2);
644
+ start += 2;
721
645
 
722
646
 
723
647
 
724
- var timeStamp = semiOctetToString(PDUString.substr(start,14));
725
648
 
726
- // get date
727
- var year = timeStamp.substring(0,2);
728
- var month = timeStamp.substring(2,4);
729
- var day = timeStamp.substring(4,6);
730
- var hours = timeStamp.substring(6,8);
731
- var minutes = timeStamp.substring(8,10);
732
- var seconds = timeStamp.substring(10,12);
649
+ var tp_DCS = PDUString.substr(start, 2);
650
+ var tp_DCS_desc = tpDCSMeaning(tp_DCS);
651
+ start += 2;
733
652
 
734
653
 
735
654
 
736
655
 
737
- timeStamp = day + "/" + month + "/" + year + " " + hours + ":" + minutes + ":" + seconds + " GMT ?"; //+" + timezone/4;
656
+ var timeStamp = semiOctetToString(PDUString.substr(start, 14));
738
657
 
658
+ // get date
659
+ var year = timeStamp.substring(0, 2);
660
+ var month = timeStamp.substring(2, 4);
661
+ var day = timeStamp.substring(4, 6);
662
+ var hours = timeStamp.substring(6, 8);
663
+ var minutes = timeStamp.substring(8, 10);
664
+ var seconds = timeStamp.substring(10, 12);
739
665
 
740
666
 
741
667
 
742
- /*
743
- var timezone = MakeNum(timeStamp.substring(12,13)); // timeStamp.substring(12,14);
744
- if (timezone >= 8)
745
- {
746
- timezone -= 8;
747
- timezone = timezone + timeStamp.substring(13,14); // Concats :: yeuck
748
- timezone = -timezone;
749
- timeStamp += "-";
750
668
 
669
+ timeStamp = day + "/" + month + "/" + year + " " + hours + ":" + minutes + ":" + seconds + " GMT ?"; //+" + timezone/4;
751
670
 
752
671
 
753
672
 
754
- }
755
- else
756
- {
757
- timezone = timezone + timeStamp.substring(13,14); // Concats :: yeuck
758
- timeStamp += "+";
759
- }
760
673
 
761
- timeStamp += timezone/4;
762
- */
763
- start +=14;
674
+ /*
675
+ var timezone = MakeNum(timeStamp.substring(12,13)); // timeStamp.substring(12,14);
676
+ if (timezone >= 8)
677
+ {
678
+ timezone -= 8;
679
+ timezone = timezone + timeStamp.substring(13,14); // Concats :: yeuck
680
+ timezone = -timezone;
681
+ timeStamp += "-";
764
682
 
765
683
 
766
684
 
767
685
 
768
- // Commonish...
769
- var messageLength = HexToNum(PDUString.substr(start,2));
770
- start += 2;
686
+ }
687
+ else
688
+ {
689
+ timezone = timezone + timeStamp.substring(13,14); // Concats :: yeuck
690
+ timeStamp += "+";
691
+ }
771
692
 
693
+ timeStamp += timezone/4;
694
+ */
695
+ start += 14;
772
696
 
773
697
 
774
698
 
775
- var bitSize = DCS_Bits(tp_DCS);
776
- var userData = "Undefined format";
777
- if (bitSize==7)
778
- {
779
- userData = getUserMessage(PDUString.substr(start,PDUString.length-start),messageLength);
780
- }
781
- else if (bitSize==8)
782
- {
783
- userData = getUserMessage8(PDUString.substr(start,PDUString.length-start),messageLength);
784
- }
785
- else if (bitSize==16)
786
- {
787
- userData = getUserMessage16(PDUString.substr(start,PDUString.length-start),messageLength);
788
- }
789
699
 
700
+ // Commonish...
701
+ var messageLength = HexToNum(PDUString.substr(start, 2));
702
+ start += 2;
790
703
 
791
704
 
792
705
 
793
- userData = userData.substr(0,messageLength);
794
706
 
795
- userData = userData.replace(/\n/g,"")
796
- userData = userData.replace("::::","")
707
+ var bitSize = DCS_Bits(tp_DCS);
708
+ var userData = "Undefined format";
709
+ if (bitSize == 7) {
710
+ userData = getUserMessage(PDUString.substr(start, PDUString.length - start), messageLength);
711
+ } else if (bitSize == 8) {
712
+ userData = getUserMessage8(PDUString.substr(start, PDUString.length - start), messageLength);
713
+ } else if (bitSize == 16) {
714
+ userData = getUserMessage16(PDUString.substr(start, PDUString.length - start), messageLength);
715
+ }
797
716
 
798
717
 
799
- if (bitSize==16)
800
- {
801
- messageLength/=2;
802
- }
803
718
 
804
- out += "SMSC::::"+SMSC_Number+"\nSender::::"+sender_number+"\nTimeStamp::::"+timeStamp+"\nTP_PID::::"+tp_PID+"\nTP_DCS::::"+tp_DCS+"\nTP_DCS-popis::::"+tp_DCS_desc+"Message::::"+userData+"\nLength::::"+messageLength;
805
- }
806
- else
807
- {
808
- out = "Type::::Status Report\n";
809
719
 
720
+ userData = userData.substr(0, messageLength);
810
721
 
722
+ userData = userData.replace(/\n/g, "")
723
+ userData = userData.replace("::::", "")
811
724
 
812
725
 
813
- var MessageReference = HexToNum(PDUString.substr(start,2)); // ??? Correct this name
814
- start = start + 2;
726
+ if (bitSize == 16) {
727
+ messageLength /= 2;
728
+ }
815
729
 
730
+ out += "SMSC::::" + SMSC_Number + "\nSender::::" + sender_number + "\nTimeStamp::::" + timeStamp + "\nTP_PID::::" + tp_PID + "\nTP_DCS::::" + tp_DCS + "\nTP_DCS-popis::::" + tp_DCS_desc + "Message::::" + userData + "\nLength::::" + messageLength;
731
+ } else {
732
+ out = "Type::::Status Report\n";
816
733
 
817
734
 
818
735
 
819
- // length in decimals
820
- var sender_addressLength = HexToNum(PDUString.substr(start,2));
821
- if(sender_addressLength%2 != 0)
822
- {
823
- sender_addressLength +=1;
824
- }
825
- start = start + 2;
826
736
 
737
+ var MessageReference = HexToNum(PDUString.substr(start, 2)); // ??? Correct this name
738
+ start = start + 2;
827
739
 
828
740
 
829
741
 
830
- var sender_typeOfAddress = PDUString.substr(start,2);
831
- start = start + 2
832
742
 
743
+ // length in decimals
744
+ var sender_addressLength = HexToNum(PDUString.substr(start, 2));
745
+ if (sender_addressLength % 2 != 0) {
746
+ sender_addressLength += 1;
747
+ }
748
+ start = start + 2;
833
749
 
834
750
 
835
751
 
836
- var sender_number = semiOctetToString(PDUString.substring(start,start+sender_addressLength));
837
752
 
838
- if((sender_number.substr(sender_number.length-1,1) == 'F') || (sender_number.substr(sender_number.length-1,1) == 'f' ))
839
- {
840
- sender_number = sender_number.substring(0,sender_number.length-1);
841
- }
842
- if (sender_typeOfAddress == 91)
843
- {
844
- sender_number = "+" + sender_number;
845
- }
846
- start +=sender_addressLength;
753
+ var sender_typeOfAddress = PDUString.substr(start, 2);
754
+ start = start + 2
847
755
 
848
756
 
849
757
 
850
758
 
851
- var timeStamp = semiOctetToString(PDUString.substr(start,14));
759
+ var sender_number = semiOctetToString(PDUString.substring(start, start + sender_addressLength));
852
760
 
853
- // get date
854
- var year = timeStamp.substring(0,2);
855
- var month = timeStamp.substring(2,4);
856
- var day = timeStamp.substring(4,6);
857
- var hours = timeStamp.substring(6,8);
858
- var minutes = timeStamp.substring(8,10);
859
- var seconds = timeStamp.substring(10,12);
860
- var timezone = timeStamp.substring(12,14);
761
+ if ((sender_number.substr(sender_number.length - 1, 1) == 'F') || (sender_number.substr(sender_number.length - 1, 1) == 'f')) {
762
+ sender_number = sender_number.substring(0, sender_number.length - 1);
763
+ }
764
+ if (sender_typeOfAddress == 91) {
765
+ sender_number = "+" + sender_number;
766
+ }
767
+ start += sender_addressLength;
861
768
 
862
- timeStamp = day + "/" + month + "/" + year + " " + hours + ":" + minutes + ":" + seconds + " GMT +" + timezone/4;
863
- start +=14;
864
769
 
865
770
 
866
771
 
772
+ var timeStamp = semiOctetToString(PDUString.substr(start, 14));
867
773
 
868
- var timeStamp2 = semiOctetToString(PDUString.substr(start,14));
774
+ // get date
775
+ var year = timeStamp.substring(0, 2);
776
+ var month = timeStamp.substring(2, 4);
777
+ var day = timeStamp.substring(4, 6);
778
+ var hours = timeStamp.substring(6, 8);
779
+ var minutes = timeStamp.substring(8, 10);
780
+ var seconds = timeStamp.substring(10, 12);
781
+ var timezone = timeStamp.substring(12, 14);
869
782
 
870
- // get date
871
- var year2 = timeStamp2.substring(0,2);
872
- var month2 = timeStamp2.substring(2,4);
873
- var day2 = timeStamp2.substring(4,6);
874
- var hours2 = timeStamp2.substring(6,8);
875
- var minutes2 = timeStamp2.substring(8,10);
876
- var seconds2 = timeStamp2.substring(10,12);
877
- var timezone2 = timeStamp.substring(12,14);
783
+ timeStamp = day + "/" + month + "/" + year + " " + hours + ":" + minutes + ":" + seconds + " GMT +" + timezone / 4;
784
+ start += 14;
878
785
 
879
- timeStamp2 = day2 + "/" + month2 + "/" + year2 + " " + hours2 + ":" + minutes2 + ":" + seconds2 + " GMT +" + timezone2/4;
880
- start +=14;
881
786
 
882
787
 
883
788
 
789
+ var timeStamp2 = semiOctetToString(PDUString.substr(start, 14));
884
790
 
885
- var mStatus = PDUString.substr(start,2);
791
+ // get date
792
+ var year2 = timeStamp2.substring(0, 2);
793
+ var month2 = timeStamp2.substring(2, 4);
794
+ var day2 = timeStamp2.substring(4, 6);
795
+ var hours2 = timeStamp2.substring(6, 8);
796
+ var minutes2 = timeStamp2.substring(8, 10);
797
+ var seconds2 = timeStamp2.substring(10, 12);
798
+ var timezone2 = timeStamp.substring(12, 14);
886
799
 
800
+ timeStamp2 = day2 + "/" + month2 + "/" + year2 + " " + hours2 + ":" + minutes2 + ":" + seconds2 + " GMT +" + timezone2 / 4;
801
+ start += 14;
887
802
 
888
803
 
889
804
 
890
- out += "SMSC::::"+SMSC_Number+"\nSender::::"+sender_number+"\nMessageRef::::"+MessageReference+"\nTimeStamp::::"+timeStamp+"\nTimeStamp2::::"+timeStamp2 + "\nStatus Byte::::" + mStatus;
891
- }
892
805
 
893
- return out;
806
+ var mStatus = PDUString.substr(start, 2);
807
+
808
+
809
+
810
+
811
+ out += "SMSC::::" + SMSC_Number + "\nSender::::" + sender_number + "\nMessageRef::::" + MessageReference + "\nTimeStamp::::" + timeStamp + "\nTimeStamp2::::" + timeStamp2 + "\nStatus Byte::::" + mStatus;
812
+ }
813
+
814
+ return out;
894
815
  }
895
816
 
896
817
 
897
- function change (what)
898
- {
899
- var keysSoFar = what.value.length;
818
+ function change(what) {
819
+ var keysSoFar = what.value.length;
900
820
 
901
821
 
902
822
 
903
823
 
904
- if (keysSoFar > maxkeys)
905
- {
906
- if (!alerted)
907
- {
908
- //alert ('Max length '+ maxkeys + '!');
909
- }
910
- what.value = what.value.substring (0, maxkeys); //chop
911
- alerted = true;
912
- keysSoFar = maxkeys;
913
- }
914
- window.status = "Characters left : " + (maxkeys - keysSoFar);
824
+ if (keysSoFar > maxkeys) {
825
+ if (!alerted) {
826
+ //alert ('Max length '+ maxkeys + '!');
827
+ }
828
+ what.value = what.value.substring(0, maxkeys); //chop
829
+ alerted = true;
830
+ keysSoFar = maxkeys;
831
+ }
832
+ window.status = "Characters left : " + (maxkeys - keysSoFar);
915
833
  }
916
834
 
917
835
 
918
836
 
919
837
 
920
- function DCS_Bits(tp_DCS)
921
- {
922
- var AlphabetSize=7; // Set Default
923
- //alert(tp_DCS);
924
- var pomDCS = HexToNum(tp_DCS);
925
- //alert(pomDCS);
926
- switch(pomDCS & 192)
927
- {
928
- case 0: if(pomDCS & 32)
929
- {
930
- // tp_DCS_desc="Compressed Text\n";
931
- }
932
- else
933
- {
934
- // tp_DCS_desc="Uncompressed Text\n";
935
- }
936
- switch(pomDCS & 12)
937
- {
938
- case 4:
939
- AlphabetSize=8;
940
- break;
941
- case 8:
942
- AlphabetSize=16;
943
- break;
944
- }
945
- break;
946
- case 192:
947
- switch(pomDCS & 0x30)
948
- {
949
- case 0x20:
950
- AlphabetSize=16;
951
- break;
952
- case 0x30:
953
- if (pomDCS & 0x4)
954
- {
955
- ;
956
- }
957
- else
958
- {
959
- AlphabetSize=8;
960
- }
961
- break;
962
- }
963
- break;
964
-
965
- }
966
-
967
-
968
-
969
-
970
- return(AlphabetSize);
838
+ function DCS_Bits(tp_DCS) {
839
+ var AlphabetSize = 7; // Set Default
840
+ //alert(tp_DCS);
841
+ var pomDCS = HexToNum(tp_DCS);
842
+ //alert(pomDCS);
843
+ switch (pomDCS & 192) {
844
+ case 0:
845
+ if (pomDCS & 32) {
846
+ // tp_DCS_desc="Compressed Text\n";
847
+ } else {
848
+ // tp_DCS_desc="Uncompressed Text\n";
849
+ }
850
+ switch (pomDCS & 12) {
851
+ case 4:
852
+ AlphabetSize = 8;
853
+ break;
854
+ case 8:
855
+ AlphabetSize = 16;
856
+ break;
857
+ }
858
+ break;
859
+ case 192:
860
+ switch (pomDCS & 0x30) {
861
+ case 0x20:
862
+ AlphabetSize = 16;
863
+ break;
864
+ case 0x30:
865
+ if (pomDCS & 0x4) {;
866
+ } else {
867
+ AlphabetSize = 8;
868
+ }
869
+ break;
870
+ }
871
+ break;
872
+
873
+ }
874
+
875
+
876
+
877
+
878
+ return (AlphabetSize);
971
879
  }
972
880
 
973
881
 
974
882
 
975
883
 
976
- function tpDCSMeaning(tp_DCS)
977
- {
978
- var tp_DCS_desc=tp_DCS;
979
- var pomDCS = HexToNum(tp_DCS);
980
- switch(pomDCS & 192)
981
- {
982
- case 0: if(pomDCS & 32)
983
- {
984
- tp_DCS_desc="Compressed Text\n";
985
- }
986
- else
987
- {
988
- tp_DCS_desc="Uncompressed Text\n";
989
- }
990
- if(!(pomDCS & 16)) // AJA
991
- {
992
- tp_DCS_desc+="MClass::No class\n";
993
- }
994
- else
995
- {
996
- tp_DCS_desc+="MClass::";
997
-
998
-
999
-
1000
-
1001
- switch(pomDCS & 3)
1002
- {
1003
- case 0:
1004
- tp_DCS_desc+="0\n";
1005
- break;
1006
- case 1:
1007
- tp_DCS_desc+="1\n";
1008
- break;
1009
- case 2:
1010
- tp_DCS_desc+="2\n";
1011
- break;
1012
- case 3:
1013
- tp_DCS_desc+="3\n";
1014
- break;
1015
- }
1016
- }
1017
- tp_DCS_desc+="Alphabet::::";
1018
- switch(pomDCS & 12)
1019
- {
1020
- case 0:
1021
- tp_DCS_desc+="Default\n";
1022
- break;
1023
- case 4:
1024
- tp_DCS_desc+="8bit\n";
1025
- break;
1026
- case 8:
1027
- tp_DCS_desc+="UCS2(16)bit\n";
1028
- break;
1029
- case 12:
1030
- tp_DCS_desc+="Reserved\n";
1031
- break;
1032
- }
1033
- break;
1034
- case 64:
1035
- case 128:
1036
- tp_DCS_desc ="Reserved coding group\n";
1037
- break;
1038
- case 192:
1039
- switch(pomDCS & 0x30)
1040
- {
1041
- case 0:
1042
- tp_DCS_desc ="Message waiting group\n";
1043
- tp_DCS_desc+="Discard\n";
1044
- break;
1045
- case 0x10:
1046
- tp_DCS_desc ="Message waiting group\n";
1047
- tp_DCS_desc+="Store Message. Default Alphabet\n";
1048
- break;
1049
- case 0x20:
1050
- tp_DCS_desc ="Message waiting group\n";
1051
- tp_DCS_desc+="Store Message. UCS2 Alphabet\n";
1052
- break;
1053
- case 0x30:
1054
- tp_DCS_desc ="Data coding message class\n";
1055
- if (pomDCS & 0x4)
1056
- {
1057
- tp_DCS_desc+="Default Alphabet\n";
1058
- }
1059
- else
1060
- {
1061
- tp_DCS_desc+="8 bit Alphabet\n";
1062
- }
1063
- break;
1064
- }
1065
- break;
1066
-
1067
- }
1068
-
1069
-
1070
-
1071
-
1072
- //alert(tp_DCS.valueOf());
1073
-
1074
- return(tp_DCS_desc);
884
+ function tpDCSMeaning(tp_DCS) {
885
+ var tp_DCS_desc = tp_DCS;
886
+ var pomDCS = HexToNum(tp_DCS);
887
+ switch (pomDCS & 192) {
888
+ case 0:
889
+ if (pomDCS & 32) {
890
+ tp_DCS_desc = "Compressed Text\n";
891
+ } else {
892
+ tp_DCS_desc = "Uncompressed Text\n";
893
+ }
894
+ if (!(pomDCS & 16)) // AJA
895
+ {
896
+ tp_DCS_desc += "MClass::No class\n";
897
+ } else {
898
+ tp_DCS_desc += "MClass::";
899
+
900
+
901
+
902
+
903
+ switch (pomDCS & 3) {
904
+ case 0:
905
+ tp_DCS_desc += "0\n";
906
+ break;
907
+ case 1:
908
+ tp_DCS_desc += "1\n";
909
+ break;
910
+ case 2:
911
+ tp_DCS_desc += "2\n";
912
+ break;
913
+ case 3:
914
+ tp_DCS_desc += "3\n";
915
+ break;
916
+ }
917
+ }
918
+ tp_DCS_desc += "Alphabet::::";
919
+ switch (pomDCS & 12) {
920
+ case 0:
921
+ tp_DCS_desc += "Default\n";
922
+ break;
923
+ case 4:
924
+ tp_DCS_desc += "8bit\n";
925
+ break;
926
+ case 8:
927
+ tp_DCS_desc += "UCS2(16)bit\n";
928
+ break;
929
+ case 12:
930
+ tp_DCS_desc += "Reserved\n";
931
+ break;
932
+ }
933
+ break;
934
+ case 64:
935
+ case 128:
936
+ tp_DCS_desc = "Reserved coding group\n";
937
+ break;
938
+ case 192:
939
+ switch (pomDCS & 0x30) {
940
+ case 0:
941
+ tp_DCS_desc = "Message waiting group\n";
942
+ tp_DCS_desc += "Discard\n";
943
+ break;
944
+ case 0x10:
945
+ tp_DCS_desc = "Message waiting group\n";
946
+ tp_DCS_desc += "Store Message. Default Alphabet\n";
947
+ break;
948
+ case 0x20:
949
+ tp_DCS_desc = "Message waiting group\n";
950
+ tp_DCS_desc += "Store Message. UCS2 Alphabet\n";
951
+ break;
952
+ case 0x30:
953
+ tp_DCS_desc = "Data coding message class\n";
954
+ if (pomDCS & 0x4) {
955
+ tp_DCS_desc += "Default Alphabet\n";
956
+ } else {
957
+ tp_DCS_desc += "8 bit Alphabet\n";
958
+ }
959
+ break;
960
+ }
961
+ break;
962
+
963
+ }
964
+
965
+
966
+
967
+
968
+ //alert(tp_DCS.valueOf());
969
+
970
+ return (tp_DCS_desc);
1075
971
  }
1076
972
 
1077
973
 
1078
974
 
1079
975
 
1080
- function checkFlag(valid)
1081
- {
1082
- if (valid.checked)
1083
- {
1084
- document.pduToStringForm.valid.disabled = false;
1085
- document.pduToStringForm.valid.value = "170";
1086
- document.getElementById('validy').innerHTML=cValid("170");
1087
- }
1088
- else
1089
- {
1090
- document.pduToStringForm.valid.disabled = true;
1091
- document.pduToStringForm.valid.value = "";
1092
- document.getElementById('validy').innerHTML="";
1093
- }
976
+ function checkFlag(valid) {
977
+ if (valid.checked) {
978
+ document.pduToStringForm.valid.disabled = false;
979
+ document.pduToStringForm.valid.value = "170";
980
+ document.getElementById('validy').innerHTML = cValid("170");
981
+ } else {
982
+ document.pduToStringForm.valid.disabled = true;
983
+ document.pduToStringForm.valid.value = "";
984
+ document.getElementById('validy').innerHTML = "";
985
+ }
1094
986
  }
1095
987
 
1096
988
 
1097
989
 
1098
990
 
1099
- function Validity(valid)
1100
- {
1101
- var byValidityPeriod = 0;
1102
-
1103
-
1104
-
1105
-
1106
- if (isNaN(parseInt(valid)))
1107
- {
1108
- valid = 0;
1109
- document.pduToStringForm.valid.value = valid;
1110
- }
1111
- else
1112
- {
1113
- valid=parseInt(valid);
1114
- if (valid <0)
1115
- {
1116
- valid = 0;
1117
- document.pduToStringForm.valid.value = valid;
1118
- }
1119
- if (valid>255)
1120
- {
1121
- valid = 255;
1122
- document.pduToStringForm.valid.value = valid;
1123
- }
1124
- }
1125
- return cValid(valid);
991
+ function Validity(valid) {
992
+ var byValidityPeriod = 0;
993
+
994
+
995
+
996
+
997
+ if (isNaN(parseInt(valid))) {
998
+ valid = 0;
999
+ document.pduToStringForm.valid.value = valid;
1000
+ } else {
1001
+ valid = parseInt(valid);
1002
+ if (valid < 0) {
1003
+ valid = 0;
1004
+ document.pduToStringForm.valid.value = valid;
1005
+ }
1006
+ if (valid > 255) {
1007
+ valid = 255;
1008
+ document.pduToStringForm.valid.value = valid;
1009
+ }
1010
+ }
1011
+ return cValid(valid);
1126
1012
  }
1127
1013
 
1128
1014
 
1129
1015
 
1130
1016
 
1131
- function cValid(valid)
1132
- {
1133
- var value,out="";
1134
- // if (isNaN(parseInt(valid)))
1135
- // {
1136
- // alert("No text please we're British!");
1137
- // }
1138
- valid=parseInt(valid);
1139
- if (valid <= 143)
1140
- {
1141
- value = (valid+1)*5; // Minutes
1142
- }
1143
- else if (valid <= 167)
1144
- {
1145
- value = ((valid-143) / 2 + 12); // Hours
1146
- value *= 60; // Convert to Minutes
1147
- }
1148
- else if (valid <= 196)
1149
- {
1150
- value = valid-166; // days
1151
- value *= 60*24; // Convert to Minutes
1152
- }
1153
- else
1154
- {
1155
- value = valid-192; // Weeks
1156
- value *= 7*60*24; // Convert to Minutes
1157
- }
1158
- var mins,hours,days,weeks;
1017
+ function cValid(valid) {
1018
+ var value, out = "";
1019
+ // if (isNaN(parseInt(valid)))
1020
+ // {
1021
+ // alert("No text please we're British!");
1022
+ // }
1023
+ valid = parseInt(valid);
1024
+ if (valid <= 143) {
1025
+ value = (valid + 1) * 5; // Minutes
1026
+ } else if (valid <= 167) {
1027
+ value = ((valid - 143) / 2 + 12); // Hours
1028
+ value *= 60; // Convert to Minutes
1029
+ } else if (valid <= 196) {
1030
+ value = valid - 166; // days
1031
+ value *= 60 * 24; // Convert to Minutes
1032
+ } else {
1033
+ value = valid - 192; // Weeks
1034
+ value *= 7 * 60 * 24; // Convert to Minutes
1035
+ }
1036
+ var mins, hours, days, weeks;
1159
1037
 
1160
1038
 
1161
1039
 
1162
1040
 
1163
- mins = value % 60;
1164
- hours = value / 60;
1165
- days = hours / 24;
1166
- weeks = days / 7;
1167
- hours %= 24;
1168
- days %= 7;
1041
+ mins = value % 60;
1042
+ hours = value / 60;
1043
+ days = hours / 24;
1044
+ weeks = days / 7;
1045
+ hours %= 24;
1046
+ days %= 7;
1169
1047
 
1170
1048
 
1171
1049
 
1172
1050
 
1173
- if (parseInt(weeks) != 0)
1174
- {
1175
- out += parseInt(weeks) + "w ";
1176
- }
1051
+ if (parseInt(weeks) != 0) {
1052
+ out += parseInt(weeks) + "w ";
1053
+ }
1177
1054
 
1178
1055
 
1179
1056
 
1180
1057
 
1181
- if (parseInt(days) != 0)
1182
- {
1183
- out += parseInt(days) + "d ";
1184
- }
1058
+ if (parseInt(days) != 0) {
1059
+ out += parseInt(days) + "d ";
1060
+ }
1185
1061
 
1186
1062
 
1187
1063
 
1188
1064
 
1189
- if (parseInt(hours) != 0)
1190
- {
1191
- out += parseInt(hours) + "h ";
1192
- }
1193
- if (mins != 0)
1194
- {
1195
- out += mins + "m ";
1196
- }
1065
+ if (parseInt(hours) != 0) {
1066
+ out += parseInt(hours) + "h ";
1067
+ }
1068
+ if (mins != 0) {
1069
+ out += mins + "m ";
1070
+ }
1197
1071
 
1198
1072
 
1199
1073
 
1200
1074
 
1201
- return out;
1075
+ return out;
1202
1076
  }
1203
1077
 
1204
1078
  /* Script written by Swen-Peter Ekkebus, edited by Ing. Milan Chudik.
@@ -1223,12 +1097,8 @@ function cValid(valid)
1223
1097
 
1224
1098
 
1225
1099
 
1226
-
1227
-
1228
-
1229
-
1230
1100
  //Array with "The 7 bit defaultalphabet"
1231
- sevenbitdefault = new Array('@', '£', '$', '¥', 'è', 'é', 'ù', 'ì', 'ò', 'Ç', '\n', 'Ø', 'ø', '\r','Å', 'å','\u0394', '_', '\u03a6', '\u0393', '\u039b', '\u03a9', '\u03a0','\u03a8', '\u03a3', '\u0398', '\u039e','€', 'Æ', 'æ', 'ß', 'É', ' ', '!', '"', '#', '¤', '%', '&', '\'', '(', ')','*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7','8', '9', ':', ';', '<', '=', '>', '?', '¡', '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', 'Ä', 'Ö', 'Ñ', 'Ü', '§', '¿', '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', 'ä', 'ö', 'ñ','ü', 'à');
1101
+ sevenbitdefault = new Array('@', '£', '$', '¥', 'è', 'é', 'ù', 'ì', 'ò', 'Ç', '\n', 'Ø', 'ø', '\r', 'Å', 'å', '\u0394', '_', '\u03a6', '\u0393', '\u039b', '\u03a9', '\u03a0', '\u03a8', '\u03a3', '\u0398', '\u039e', '€', 'Æ', 'æ', 'ß', 'É', ' ', '!', '"', '#', '¤', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '¡', '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', 'Ä', 'Ö', 'Ñ', 'Ü', '§', '¿', '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', 'ä', 'ö', 'ñ', 'ü', 'à');
1232
1102
 
1233
1103
 
1234
1104
 
@@ -1246,79 +1116,78 @@ var alerted = false;
1246
1116
 
1247
1117
 
1248
1118
  // function te convert a bit string into a integer
1249
- function binToInt(x)//sp
1119
+ function binToInt(x) //sp
1250
1120
  {
1251
- var total = 0;
1252
- var power = parseInt(x.length)-1;
1121
+ var total = 0;
1122
+ var power = parseInt(x.length) - 1;
1253
1123
 
1254
1124
 
1255
1125
 
1256
1126
 
1257
- for(var i=0;i<x.length;i++)
1258
- {
1259
- if(x.charAt(i) == '1')
1260
- {
1261
- total = total +Math.pow(2,power);
1262
- }
1263
- power --;
1264
- }
1265
- return total;
1127
+ for (var i = 0; i < x.length; i++) {
1128
+ if (x.charAt(i) == '1') {
1129
+ total = total + Math.pow(2, power);
1130
+ }
1131
+ power--;
1132
+ }
1133
+ return total;
1266
1134
  }
1267
1135
 
1268
1136
 
1269
1137
 
1270
1138
 
1271
1139
  // function to convert a integer into a bit String
1272
- function intToBin(x,size) //sp
1140
+ function intToBin(x, size) //sp
1273
1141
  {
1274
- var base = 2;
1275
- var num = parseInt(x);
1276
- var bin = num.toString(base);
1277
- for(var i=bin.length;i<size;i++)
1278
- {
1279
- bin = "0" + bin;
1280
- }
1281
- return bin;
1142
+ var base = 2;
1143
+ var num = parseInt(x);
1144
+ var bin = num.toString(base);
1145
+ for (var i = bin.length; i < size; i++) {
1146
+ bin = "0" + bin;
1147
+ }
1148
+ return bin;
1282
1149
  }
1283
1150
 
1284
1151
 
1285
1152
 
1286
1153
 
1287
1154
  // function to convert a Hexnumber into a 10base number
1288
- function HexToNum(numberS)
1289
- {
1290
- var tens = MakeNum(numberS.substring(0,1));
1291
-
1292
- var ones = 0;
1293
- if(numberS.length > 1) // means two characters entered
1294
- ones=MakeNum(numberS.substring(1,2));
1295
- if(ones == 'X')
1296
- {
1297
- return "00";
1298
- }
1299
- return (tens * 16) + (ones * 1);
1155
+ function HexToNum(numberS) {
1156
+ var tens = MakeNum(numberS.substring(0, 1));
1157
+
1158
+ var ones = 0;
1159
+ if (numberS.length > 1) // means two characters entered
1160
+ ones = MakeNum(numberS.substring(1, 2));
1161
+ if (ones == 'X') {
1162
+ return "00";
1163
+ }
1164
+ return (tens * 16) + (ones * 1);
1300
1165
  }
1301
1166
 
1302
1167
 
1303
1168
 
1304
1169
 
1305
1170
  // helper function for HexToNum
1306
- function MakeNum(str)
1307
- {
1308
- if((str >= '0') && (str <= '9'))
1309
- return str;
1310
- switch(str.toUpperCase())
1311
- {
1312
- case "A": return 10;
1313
- case "B": return 11;
1314
- case "C": return 12;
1315
- case "D": return 13;
1316
- case "E": return 14;
1317
- case "F": return 15;
1318
- default:
1319
- return 16;
1320
- }
1321
- return 16;
1171
+ function MakeNum(str) {
1172
+ if ((str >= '0') && (str <= '9'))
1173
+ return str;
1174
+ switch (str.toUpperCase()) {
1175
+ case "A":
1176
+ return 10;
1177
+ case "B":
1178
+ return 11;
1179
+ case "C":
1180
+ return 12;
1181
+ case "D":
1182
+ return 13;
1183
+ case "E":
1184
+ return 14;
1185
+ case "F":
1186
+ return 15;
1187
+ default:
1188
+ return 16;
1189
+ }
1190
+ return 16;
1322
1191
  }
1323
1192
 
1324
1193
 
@@ -1330,272 +1199,237 @@ function MakeNum(str)
1330
1199
 
1331
1200
 
1332
1201
  function intToHex(i) //sp
1333
- {
1334
- var sHex = "0123456789ABCDEF";
1335
- h = "";
1336
- i = parseInt(i);
1337
- for(j = 0; j <= 3; j++)
1338
- {
1339
- h += sHex.charAt((i >> (j * 8 + 4)) & 0x0F) +
1340
- sHex.charAt((i >> (j * 8)) & 0x0F);
1341
- }
1342
- return h.substring(0,2);
1202
+ {
1203
+ var sHex = "0123456789ABCDEF";
1204
+ h = "";
1205
+ i = parseInt(i);
1206
+ for (j = 0; j <= 3; j++) {
1207
+ h += sHex.charAt((i >> (j * 8 + 4)) & 0x0F) +
1208
+ sHex.charAt((i >> (j * 8)) & 0x0F);
1209
+ }
1210
+ return h.substring(0, 2);
1343
1211
  }
1344
1212
 
1345
1213
 
1346
1214
 
1347
1215
 
1348
- function ToHex(i)
1349
- {
1350
- var sHex = "0123456789ABCDEF";
1351
- var Out = "";
1216
+ function ToHex(i) {
1217
+ var sHex = "0123456789ABCDEF";
1218
+ var Out = "";
1352
1219
 
1353
1220
 
1354
1221
 
1355
1222
 
1356
- Out = sHex.charAt(i&0xf);
1357
- i>>=4;
1358
- Out = sHex.charAt(i&0xf) + Out;
1223
+ Out = sHex.charAt(i & 0xf);
1224
+ i >>= 4;
1225
+ Out = sHex.charAt(i & 0xf) + Out;
1359
1226
 
1360
1227
 
1361
1228
 
1362
1229
 
1363
- return Out;
1230
+ return Out;
1364
1231
  }
1365
1232
 
1366
- function stringToPDU(inpString,phoneNumber,smscNumber,size,mclass,valid,receipt,vFlag) // AJA fixed SMSC processing
1233
+ function stringToPDU(inpString, phoneNumber, smscNumber, size, mclass, valid, receipt, vFlag) // AJA fixed SMSC processing
1367
1234
  {
1368
- var bitSize = size;
1235
+ var bitSize = size;
1369
1236
 
1370
1237
 
1371
1238
 
1372
1239
 
1373
- var octetFirst = "";
1374
- var octetSecond = "";
1375
- var output = "";
1240
+ var octetFirst = "";
1241
+ var octetSecond = "";
1242
+ var output = "";
1376
1243
 
1377
1244
 
1378
1245
 
1379
1246
 
1380
- //Make header
1381
- var SMSC_INFO_LENGTH = 0;
1382
- var SMSC_LENGTH = 0;
1383
- var SMSC_NUMBER_FORMAT = "";
1384
- var SMSC = "";
1385
- if (smscNumber != 0)
1386
- {
1387
- SMSC_NUMBER_FORMAT = "81"; // national
1247
+ //Make header
1248
+ var SMSC_INFO_LENGTH = 0;
1249
+ var SMSC_LENGTH = 0;
1250
+ var SMSC_NUMBER_FORMAT = "";
1251
+ var SMSC = "";
1252
+ if (smscNumber != 0) {
1253
+ SMSC_NUMBER_FORMAT = "81"; // national
1388
1254
 
1389
1255
 
1390
1256
 
1391
1257
 
1392
- if (smscNumber.substr(0,1) == '+')
1393
- {
1394
- SMSC_NUMBER_FORMAT = "91"; // international
1395
- smscNumber = smscNumber.substr(1);
1396
- }
1397
- else if (smscNumber.substr(0,1) !='0')
1398
- {
1399
- SMSC_NUMBER_FORMAT = "91"; // international
1400
- }
1258
+ if (smscNumber.substr(0, 1) == '+') {
1259
+ SMSC_NUMBER_FORMAT = "91"; // international
1260
+ smscNumber = smscNumber.substr(1);
1261
+ } else if (smscNumber.substr(0, 1) != '0') {
1262
+ SMSC_NUMBER_FORMAT = "91"; // international
1263
+ }
1401
1264
 
1402
1265
 
1403
1266
 
1404
1267
 
1405
- if(smscNumber.length%2 != 0)
1406
- {
1407
- // add trailing F
1408
- smscNumber += "F";
1409
- }
1268
+ if (smscNumber.length % 2 != 0) {
1269
+ // add trailing F
1270
+ smscNumber += "F";
1271
+ }
1410
1272
 
1411
- SMSC = semiOctetToString(smscNumber);
1412
- SMSC_INFO_LENGTH = ((SMSC_NUMBER_FORMAT + "" + SMSC).length)/2;
1413
- SMSC_LENGTH = SMSC_INFO_LENGTH;
1273
+ SMSC = semiOctetToString(smscNumber);
1274
+ SMSC_INFO_LENGTH = ((SMSC_NUMBER_FORMAT + "" + SMSC).length) / 2;
1275
+ SMSC_LENGTH = SMSC_INFO_LENGTH;
1414
1276
 
1415
- }
1416
- if(SMSC_INFO_LENGTH < 10)
1417
- {
1418
- SMSC_INFO_LENGTH = "0" + SMSC_INFO_LENGTH;
1419
- }
1420
- var firstOctet; // = "1100";
1277
+ }
1278
+ if (SMSC_INFO_LENGTH < 10) {
1279
+ SMSC_INFO_LENGTH = "0" + SMSC_INFO_LENGTH;
1280
+ }
1281
+ var firstOctet; // = "1100";
1421
1282
 
1422
- if (receipt)
1423
- {
1424
- if (vFlag)
1425
- {
1426
- firstOctet = "3100"; // 18 is mask for validity period // 10 indicates relative
1427
- }
1428
- else
1429
- {
1430
- firstOctet = "2100";
1431
- }
1283
+ if (receipt) {
1284
+ if (vFlag) {
1285
+ firstOctet = "3100"; // 18 is mask for validity period // 10 indicates relative
1286
+ } else {
1287
+ firstOctet = "2100";
1288
+ }
1432
1289
 
1433
1290
 
1434
1291
 
1435
1292
 
1436
- }
1437
- else
1438
- {
1439
- if (vFlag)
1440
- {
1441
- firstOctet = "1100";
1442
- }
1443
- else
1444
- {
1445
- firstOctet = "0100";
1446
- }
1447
- }
1293
+ } else {
1294
+ if (vFlag) {
1295
+ firstOctet = "1100";
1296
+ } else {
1297
+ firstOctet = "0100";
1298
+ }
1299
+ }
1448
1300
 
1449
- var REIVER_NUMBER_FORMAT = "81"; // national
1450
- if (phoneNumber.substr(0,1) == '+')
1451
- {
1452
- REIVER_NUMBER_FORMAT = "91"; // international
1453
- phoneNumber = phoneNumber.substr(1); //,phoneNumber.length-1);
1454
- }
1455
- else if (phoneNumber.substr(0,1) !='0')
1456
- {
1457
- REIVER_NUMBER_FORMAT = "91"; // international
1458
- }
1301
+ var REIVER_NUMBER_FORMAT = "81"; // national
1302
+ if (phoneNumber.substr(0, 1) == '+') {
1303
+ REIVER_NUMBER_FORMAT = "91"; // international
1304
+ phoneNumber = phoneNumber.substr(1); //,phoneNumber.length-1);
1305
+ } else if (phoneNumber.substr(0, 1) != '0') {
1306
+ REIVER_NUMBER_FORMAT = "91"; // international
1307
+ }
1459
1308
 
1460
1309
 
1461
1310
 
1462
1311
 
1463
- var REIVER_NUMBER_LENGTH = intToHex(phoneNumber.length);
1312
+ var REIVER_NUMBER_LENGTH = intToHex(phoneNumber.length);
1464
1313
 
1465
1314
 
1466
1315
 
1467
1316
 
1468
- if(phoneNumber.length%2 != 0)
1469
- {
1470
- // add trailing F
1471
- phoneNumber += "F";
1472
- }
1317
+ if (phoneNumber.length % 2 != 0) {
1318
+ // add trailing F
1319
+ phoneNumber += "F";
1320
+ }
1473
1321
 
1474
1322
 
1475
1323
 
1476
1324
 
1477
- var REIVER_NUMBER = semiOctetToString(phoneNumber);
1478
- var PROTO_ID = "00";
1479
- var DCS=0;
1480
- if (mclass != -1) // AJA
1481
- {
1482
- DCS = mclass | 0x10;
1483
- }
1484
- switch(bitSize)
1485
- {
1486
- case 7:
1487
- break;
1488
- case 8:
1489
- DCS = DCS | 4;
1490
- break;
1491
- case 16:
1492
- DCS = DCS | 8;
1493
- break;
1494
- }
1495
- var DATA_ENCODING = intToHex(DCS);
1496
- // var DATA_ENCODING = "00"; // Default
1497
- // if (bitSize == 8)
1498
- // {
1499
- // DATA_ENCODING = "04";
1500
- // }
1501
- // else if (bitSize == 16)
1502
- // {
1503
- // DATA_ENCODING = "08";
1504
- // }
1325
+ var REIVER_NUMBER = semiOctetToString(phoneNumber);
1326
+ var PROTO_ID = "00";
1327
+ var DCS = 0;
1328
+ if (mclass != -1) // AJA
1329
+ {
1330
+ DCS = mclass | 0x10;
1331
+ }
1332
+ switch (bitSize) {
1333
+ case 7:
1334
+ break;
1335
+ case 8:
1336
+ DCS = DCS | 4;
1337
+ break;
1338
+ case 16:
1339
+ DCS = DCS | 8;
1340
+ break;
1341
+ }
1342
+ var DATA_ENCODING = intToHex(DCS);
1343
+ // var DATA_ENCODING = "00"; // Default
1344
+ // if (bitSize == 8)
1345
+ // {
1346
+ // DATA_ENCODING = "04";
1347
+ // }
1348
+ // else if (bitSize == 16)
1349
+ // {
1350
+ // DATA_ENCODING = "08";
1351
+ // }
1505
1352
 
1506
1353
 
1507
1354
 
1508
1355
 
1509
- var VALID_PERIOD = ""; // AA
1510
- if (vFlag)
1511
- {
1512
- VALID_PERIOD = intToHex(valid); // AA
1513
- }
1514
- var userDataSize;
1515
- if (bitSize == 7)
1516
- {
1517
- userDataSize = intToHex(inpString.length);
1356
+ var VALID_PERIOD = ""; // AA
1357
+ if (vFlag) {
1358
+ VALID_PERIOD = intToHex(valid); // AA
1359
+ }
1360
+ var userDataSize;
1361
+ if (bitSize == 7) {
1362
+ userDataSize = intToHex(inpString.length);
1518
1363
 
1519
1364
 
1520
1365
 
1521
1366
 
1522
- for(var i=0;i<=inpString.length;i++)
1523
- {
1524
- if(i==inpString.length)
1525
- {
1526
- if (octetSecond != "") // AJA Fix overshoot
1527
- {
1528
- output = output + "" + (intToHex(binToInt(octetSecond)));
1529
- }
1530
- break;
1531
- }
1532
- var current = intToBin(getSevenBit(inpString.charAt(i)),7);
1367
+ for (var i = 0; i <= inpString.length; i++) {
1368
+ if (i == inpString.length) {
1369
+ if (octetSecond != "") // AJA Fix overshoot
1370
+ {
1371
+ output = output + "" + (intToHex(binToInt(octetSecond)));
1372
+ }
1373
+ break;
1374
+ }
1375
+ var current = intToBin(getSevenBit(inpString.charAt(i)), 7);
1533
1376
 
1534
- var currentOctet;
1535
- if(i!=0 && i%8!=0)
1536
- {
1537
- octetFirst = current.substring(7-(i)%8);
1538
- currentOctet = octetFirst + octetSecond; //put octet parts together
1377
+ var currentOctet;
1378
+ if (i != 0 && i % 8 != 0) {
1379
+ octetFirst = current.substring(7 - (i) % 8);
1380
+ currentOctet = octetFirst + octetSecond; //put octet parts together
1539
1381
 
1540
- output = output + "" + (intToHex(binToInt(currentOctet)));
1541
- octetSecond = current.substring(0,7-(i)%8); //set net second octet
1542
- }
1543
- else
1544
- {
1545
- octetSecond = current.substring(0,7-(i)%8);
1546
- }
1547
- }
1548
- }
1549
- else if (bitSize == 8)
1550
- {
1551
- userDataSize = intToHex(inpString.length);
1382
+ output = output + "" + (intToHex(binToInt(currentOctet)));
1383
+ octetSecond = current.substring(0, 7 - (i) % 8); //set net second octet
1384
+ } else {
1385
+ octetSecond = current.substring(0, 7 - (i) % 8);
1386
+ }
1387
+ }
1388
+ } else if (bitSize == 8) {
1389
+ userDataSize = intToHex(inpString.length);
1552
1390
 
1553
1391
 
1554
1392
 
1555
1393
 
1556
- var CurrentByte = 0;
1557
- for(var i=0;i<inpString.length;i++)
1558
- {
1559
- CurrentByte = getEightBit(inpString.charCodeAt(i));
1560
- output = output + "" + ( ToHex( CurrentByte ) );
1561
- }
1562
- }
1563
- else if (bitSize == 16)
1564
- {
1565
- userDataSize = intToHex(inpString.length * 2);
1394
+ var CurrentByte = 0;
1395
+ for (var i = 0; i < inpString.length; i++) {
1396
+ CurrentByte = getEightBit(inpString.charCodeAt(i));
1397
+ output = output + "" + (ToHex(CurrentByte));
1398
+ }
1399
+ } else if (bitSize == 16) {
1400
+ userDataSize = intToHex(inpString.length * 2);
1566
1401
 
1567
1402
 
1568
1403
 
1569
1404
 
1570
- var myChar=0;
1571
- for(var i=0;i<inpString.length;i++)
1572
- {
1573
- myChar = get16Bit( inpString.charCodeAt(i) );
1574
- output = output + "" + ( ToHex( (myChar&0xff00)>>8 )) + ( ToHex( myChar&0xff ) );
1575
- }
1576
- }
1577
- var header = SMSC_INFO_LENGTH + SMSC_NUMBER_FORMAT + SMSC + firstOctet + REIVER_NUMBER_LENGTH + REIVER_NUMBER_FORMAT + REIVER_NUMBER + PROTO_ID + DATA_ENCODING + VALID_PERIOD + userDataSize;
1405
+ var myChar = 0;
1406
+ for (var i = 0; i < inpString.length; i++) {
1407
+ myChar = get16Bit(inpString.charCodeAt(i));
1408
+ output = output + "" + (ToHex((myChar & 0xff00) >> 8)) + (ToHex(myChar & 0xff));
1409
+ }
1410
+ }
1411
+ var header = SMSC_INFO_LENGTH + SMSC_NUMBER_FORMAT + SMSC + firstOctet + REIVER_NUMBER_LENGTH + REIVER_NUMBER_FORMAT + REIVER_NUMBER + PROTO_ID + DATA_ENCODING + VALID_PERIOD + userDataSize;
1578
1412
 
1579
1413
 
1580
1414
 
1581
1415
 
1582
- var PDU = header + output;
1416
+ var PDU = header + output;
1583
1417
 
1584
1418
 
1585
1419
 
1586
1420
 
1587
- var AT = (PDU.length/2 - SMSC_LENGTH - 1) ; // Add /2 for PDU length AJA - I think the SMSC information should also be excluded
1421
+ var AT = (PDU.length / 2 - SMSC_LENGTH - 1); // Add /2 for PDU length AJA - I think the SMSC information should also be excluded
1588
1422
 
1589
1423
 
1590
- // var bStep=18;
1591
- // for(var breakUp=1;breakUp*bStep < PDU.length;breakUp++)
1592
- // {
1593
- // PDU = PDU.substr(0,breakUp*bStep+breakUp-1) + " " + PDU.substr(breakUp*bStep+breakUp-1);
1594
- // }
1424
+ // var bStep=18;
1425
+ // for(var breakUp=1;breakUp*bStep < PDU.length;breakUp++)
1426
+ // {
1427
+ // PDU = PDU.substr(0,breakUp*bStep+breakUp-1) + " " + PDU.substr(breakUp*bStep+breakUp-1);
1428
+ // }
1595
1429
 
1596
1430
 
1597
1431
 
1598
1432
 
1599
- //CMGW
1600
- return AT + "\n" + PDU;
1433
+ //CMGW
1434
+ return AT + "\n" + PDU;
1601
1435
  }