comunika_gsm 0.1.5 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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
@@ -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
  }