1 | #define MODULE_LOG_PREFIX "gbox/sms"
|
---|
2 |
|
---|
3 | #include "globals.h"
|
---|
4 |
|
---|
5 | #ifdef MODULE_GBOX
|
---|
6 | #include "module-gbox.h"
|
---|
7 | #include "module-gbox-sms.h"
|
---|
8 | #include "oscam-string.h"
|
---|
9 | #include "oscam-files.h"
|
---|
10 | #include "oscam-string.h"
|
---|
11 | #include "oscam-client.h"
|
---|
12 | #include "oscam-time.h"
|
---|
13 | #include "oscam-lock.h"
|
---|
14 |
|
---|
15 | static int32_t poll_gsms_data(uint16_t *boxid, uint8_t *num, char *text)
|
---|
16 | {
|
---|
17 | char *fext= FILE_GSMS_TXT;
|
---|
18 | char *fname = get_gbox_tmp_fname(fext);
|
---|
19 |
|
---|
20 | FILE *fhandle = fopen(fname, "r");
|
---|
21 | if(!fhandle)
|
---|
22 | {
|
---|
23 | //cs_log("Couldn't open %s: %s", fname, strerror(errno));
|
---|
24 | return -2;
|
---|
25 | }
|
---|
26 |
|
---|
27 | uint32_t length1;
|
---|
28 | uint8_t length;
|
---|
29 | char buffer[140];
|
---|
30 | char *tail;
|
---|
31 |
|
---|
32 | memset(buffer, 0, sizeof(buffer));
|
---|
33 | fseek(fhandle, 0, SEEK_END);
|
---|
34 | length1 = ftell(fhandle);
|
---|
35 | fseek(fhandle, 0, SEEK_SET);
|
---|
36 |
|
---|
37 | if(length1 < 13)
|
---|
38 | {
|
---|
39 | cs_log("GSMS failed. Min msg char in %s = 6, actual = %d", fname, length1 - 7);
|
---|
40 | fclose(fhandle);
|
---|
41 | unlink(fname);
|
---|
42 | return -1;
|
---|
43 | }
|
---|
44 |
|
---|
45 | if(fgets(buffer, 140, fhandle) != NULL)
|
---|
46 | {
|
---|
47 | *boxid = strtol(buffer, &tail, 16);
|
---|
48 | *num = atoi(tail);
|
---|
49 | }
|
---|
50 |
|
---|
51 | fclose(fhandle);
|
---|
52 | unlink(fname);
|
---|
53 |
|
---|
54 | if(length1 > 127 + 7)
|
---|
55 | {
|
---|
56 | length = 127 + 7;
|
---|
57 | }
|
---|
58 | else
|
---|
59 | {
|
---|
60 | length = length1;
|
---|
61 | }
|
---|
62 |
|
---|
63 | cs_log_dbg(D_READER, "total msg length taken from %s = %d, limited to %d", fname, length1, length);
|
---|
64 | cs_strncpy(text, buffer + 7, sizeof(buffer));
|
---|
65 |
|
---|
66 | return 0;
|
---|
67 | }
|
---|
68 |
|
---|
69 | static void write_gsms_to_osd_file(struct s_client *cli, uint8_t *gsms)
|
---|
70 | {
|
---|
71 | char *fext= FILE_OSD_MSG;
|
---|
72 | char *fname = get_gbox_tmp_fname(fext);
|
---|
73 |
|
---|
74 | if(file_exists(fname))
|
---|
75 | {
|
---|
76 | char gsms_buf[150];
|
---|
77 | uint8_t i;
|
---|
78 |
|
---|
79 | // allow only alphanumerical characters in osd gsms due to safety reasons
|
---|
80 | for(i = 0; i < cs_strlen((char *)gsms); i++)
|
---|
81 | {
|
---|
82 | if(!isalnum(gsms[i]) && gsms[i] != ' ')
|
---|
83 | {
|
---|
84 | gsms[i] = '_';
|
---|
85 | }
|
---|
86 | }
|
---|
87 |
|
---|
88 | memset(gsms_buf, 0, sizeof(gsms_buf));
|
---|
89 | snprintf(gsms_buf, sizeof(gsms_buf), "%s %s:%s %s", fname, username(cli), cli->reader->device, gsms);
|
---|
90 | cs_log_dbg(D_READER, "found OSD 'driver' %s - write gsms to OSD", fname);
|
---|
91 |
|
---|
92 | char *cmd = gsms_buf;
|
---|
93 | FILE *p;
|
---|
94 | if((p = popen(cmd, "w")) == NULL)
|
---|
95 | {
|
---|
96 | cs_log("Error %s", fname);
|
---|
97 | return;
|
---|
98 | }
|
---|
99 |
|
---|
100 | pclose(p);
|
---|
101 | }
|
---|
102 |
|
---|
103 | return;
|
---|
104 | }
|
---|
105 |
|
---|
106 | void write_gsms_ack(struct s_client *cli)
|
---|
107 | {
|
---|
108 | char tsbuf[28];
|
---|
109 | time_t walltime = cs_time();
|
---|
110 | cs_ctime_r(&walltime, tsbuf);
|
---|
111 | struct gbox_peer *peer = cli->gbox;
|
---|
112 | char *fext = FILE_GSMS_ACK;
|
---|
113 | char *fname = get_gbox_tmp_fname(fext);
|
---|
114 |
|
---|
115 | FILE *fhandle = fopen(fname, "a+");
|
---|
116 | if(!fhandle)
|
---|
117 | {
|
---|
118 | cs_log("Couldn't open %s: %s", fname, strerror(errno));
|
---|
119 | return;
|
---|
120 | }
|
---|
121 |
|
---|
122 | fprintf(fhandle, "Peer %04X (%s) confirmed receipt of GSMS on %s", peer->gbox.id, cli->reader->device, tsbuf);
|
---|
123 | fclose(fhandle);
|
---|
124 | return;
|
---|
125 | }
|
---|
126 |
|
---|
127 | static void write_gsms_nack(struct s_client *cl, uint8_t inf)
|
---|
128 | {
|
---|
129 | char tsbuf[28];
|
---|
130 | time_t walltime = cs_time();
|
---|
131 | cs_ctime_r(&walltime, tsbuf);
|
---|
132 | struct gbox_peer *peer = cl->gbox;
|
---|
133 | char *fext = FILE_GSMS_NACK;
|
---|
134 | char *fname = get_gbox_tmp_fname(fext);
|
---|
135 |
|
---|
136 | FILE *fhandle = fopen(fname, "a+");
|
---|
137 | if(!fhandle)
|
---|
138 | {
|
---|
139 | cs_log("Couldn't open %s: %s", fname, strerror(errno));
|
---|
140 | return;
|
---|
141 | }
|
---|
142 |
|
---|
143 | if(inf)
|
---|
144 | {
|
---|
145 | fprintf(fhandle, "INFO: GSMS to all: Peer %04X (%s) was OFFLINE %s",
|
---|
146 | peer->gbox.id, cl->reader->device,tsbuf);
|
---|
147 | }
|
---|
148 | else
|
---|
149 | {
|
---|
150 | fprintf(fhandle, "WARNING: Private GSMS to Peer %04X (%s) failed - was OFFLINE %s",
|
---|
151 | peer->gbox.id, cl->reader->device,tsbuf);
|
---|
152 | }
|
---|
153 |
|
---|
154 | fclose(fhandle);
|
---|
155 | return;
|
---|
156 | }
|
---|
157 |
|
---|
158 | void write_gsms_msg(struct s_client *cli, uint8_t *gsms, uint16_t type, uint16_t UNUSED(msglen))
|
---|
159 | {
|
---|
160 | char tsbuf[28];
|
---|
161 | time_t walltime = cs_time();
|
---|
162 | cs_ctime_r(&walltime, tsbuf);
|
---|
163 | struct gbox_peer *peer = cli->gbox;
|
---|
164 | struct s_reader *rdr = cli->reader;
|
---|
165 | char *fext = FILE_GSMS_MSG;
|
---|
166 | char *fname = get_gbox_tmp_fname(fext);
|
---|
167 |
|
---|
168 | FILE *fhandle = fopen(fname, "a+");
|
---|
169 | if(!fhandle)
|
---|
170 | {
|
---|
171 | cs_log("Couldn't open %s: %s", fname, strerror(errno));
|
---|
172 | return;
|
---|
173 | }
|
---|
174 |
|
---|
175 | if(type == 0x30)
|
---|
176 | {
|
---|
177 | fprintf(fhandle, "Normal message received from %04X %s on %s%s\n\n", peer->gbox.id, cli->reader->device, tsbuf, gsms);
|
---|
178 | rdr->gbox_gsms_peer = peer->gbox.id;
|
---|
179 | snprintf(rdr->last_gsms, sizeof(rdr->last_gsms), "%s %s", gsms, tsbuf); // for easy handling of gsms by webif
|
---|
180 | }
|
---|
181 | else if(type == 0x31)
|
---|
182 | {
|
---|
183 | fprintf(fhandle, "OSD message received from %04X %s on %s%s\n\n", peer->gbox.id, cli->reader->device, tsbuf, gsms);
|
---|
184 | write_gsms_to_osd_file(cli, gsms);
|
---|
185 | rdr->gbox_gsms_peer = peer->gbox.id;
|
---|
186 | snprintf(rdr->last_gsms, sizeof(rdr->last_gsms), "%s %s", gsms, tsbuf); // for easy handling of gsms by webif
|
---|
187 | }
|
---|
188 | else
|
---|
189 | {
|
---|
190 | fprintf(fhandle, "Corrupted message received from %04X %s on %s%s\n\n", peer->gbox.id, cli->reader->device, tsbuf, gsms);
|
---|
191 | }
|
---|
192 |
|
---|
193 | fclose(fhandle);
|
---|
194 | return;
|
---|
195 | }
|
---|
196 |
|
---|
197 | void gsms_unavail(void)
|
---|
198 | {
|
---|
199 | cs_log("INFO: GSMS feature disabled by conf");
|
---|
200 | }
|
---|
201 |
|
---|
202 | static void gbox_send_gsms2peer(struct s_client *cl, char *gsms, uint8_t msg_type, int8_t gsms_len)
|
---|
203 | {
|
---|
204 | uint8_t outbuf[150];
|
---|
205 | struct gbox_peer *peer = cl->gbox;
|
---|
206 | uint16_t local_gbox_id = gbox_get_local_gbox_id();
|
---|
207 | uint32_t local_gbox_pw = gbox_get_local_gbox_password();
|
---|
208 | struct s_reader *rdr = cl->reader;
|
---|
209 |
|
---|
210 | gbox_message_header(outbuf, MSG_GSMS, peer->gbox.password, local_gbox_pw);
|
---|
211 |
|
---|
212 | outbuf[10] = (peer->gbox.id >> 8) & 0xff;
|
---|
213 | outbuf[11] = peer->gbox.id & 0xff;
|
---|
214 | outbuf[12] = (local_gbox_id >> 8) & 0xff;
|
---|
215 | outbuf[13] = local_gbox_id & 0xff;
|
---|
216 | outbuf[14] = msg_type;
|
---|
217 | outbuf[15] = gsms_len;
|
---|
218 | memcpy(outbuf + 16, gsms, gsms_len);
|
---|
219 | outbuf[16 + gsms_len] = 0;
|
---|
220 |
|
---|
221 | cs_log("<-[gbx] send GSMS to %s:%d id: %04X", rdr->device, rdr->r_port, peer->gbox.id);
|
---|
222 | gbox_send(cl, outbuf, gsms_len + 17);
|
---|
223 | return;
|
---|
224 | }
|
---|
225 | int gbox_direct_send_gsms(uint16_t boxid, uint8_t num, char *gsms)
|
---|
226 | {
|
---|
227 | uint8_t msg_type = 0, gsms_len = 0;
|
---|
228 | int peer_found = 0;
|
---|
229 | char text[GBOX_MAX_MSG_TXT + 1];
|
---|
230 |
|
---|
231 | memset(text, 0, sizeof(text));
|
---|
232 |
|
---|
233 | if(cfg.gsms_dis)
|
---|
234 | {
|
---|
235 | gsms_unavail();
|
---|
236 | return 0;
|
---|
237 | }
|
---|
238 |
|
---|
239 | gsms_len = cs_strlen(gsms);
|
---|
240 | if(gsms_len < 6)
|
---|
241 | {
|
---|
242 | cs_log("GBOX: message to send to peer is too short 6 chars expected and %d received text[%s]", gsms_len, gsms);
|
---|
243 | }
|
---|
244 | else if(gsms_len > GBOX_MAX_MSG_TXT)
|
---|
245 | {
|
---|
246 | gsms_len = GBOX_MAX_MSG_TXT;
|
---|
247 | cs_log("GBOX message is too long so it will be truncated to max. [%d]", GBOX_MAX_MSG_TXT);
|
---|
248 | }
|
---|
249 |
|
---|
250 | cs_strncpy(text, gsms, sizeof(text));
|
---|
251 |
|
---|
252 | switch(num)
|
---|
253 | {
|
---|
254 | case 0:
|
---|
255 | msg_type = 0x30;
|
---|
256 | break;
|
---|
257 |
|
---|
258 | case 1:
|
---|
259 | msg_type = 0x31;
|
---|
260 | break;
|
---|
261 |
|
---|
262 | //case 2:
|
---|
263 | // gsms_prot = 2;
|
---|
264 | // msg_type = 0x30;
|
---|
265 | // break;
|
---|
266 |
|
---|
267 | //case 3:
|
---|
268 | // gsms_prot = 2;
|
---|
269 | // msg_type = 0x31;
|
---|
270 | // break;
|
---|
271 |
|
---|
272 | default:
|
---|
273 | cs_log("ERROR unknown gsms protocol");
|
---|
274 | return 0;
|
---|
275 | }
|
---|
276 |
|
---|
277 | cs_log_dbg(D_READER,"init gsms_length=%d msg_type=%02X ", gsms_len, msg_type);
|
---|
278 | struct s_client *cl;
|
---|
279 | cs_readlock(__func__, &clientlist_lock);
|
---|
280 |
|
---|
281 | for(cl = first_client; cl; cl = cl->next)
|
---|
282 | {
|
---|
283 | peer_found=0;
|
---|
284 | if(cl->gbox && cl->typ == 'p')
|
---|
285 | {
|
---|
286 | struct gbox_peer *peer = cl->gbox;
|
---|
287 | if(peer->online && boxid == 0xFFFF) // send gsms to all peers online
|
---|
288 | {
|
---|
289 | gbox_send_gsms2peer(cl, text, msg_type, gsms_len);
|
---|
290 | peer_found=1;
|
---|
291 | }
|
---|
292 |
|
---|
293 | if(!peer->online && boxid == 0xFFFF)
|
---|
294 | {
|
---|
295 | cs_log("GBOX Info: peer %04X is OFFLINE", peer->gbox.id);
|
---|
296 | write_gsms_nack( cl, 1);
|
---|
297 | }
|
---|
298 |
|
---|
299 | if(peer->online && boxid == peer->gbox.id)
|
---|
300 | {
|
---|
301 | gbox_send_gsms2peer(cl, text, msg_type, gsms_len);
|
---|
302 | peer_found=1;
|
---|
303 | }
|
---|
304 |
|
---|
305 | if(!peer->online && boxid == peer->gbox.id)
|
---|
306 | {
|
---|
307 | cs_log("GBOX WARNING: send GSMS failed - peer %04X is OFFLINE", peer->gbox.id);
|
---|
308 | write_gsms_nack( cl, 0);
|
---|
309 | }
|
---|
310 | }
|
---|
311 | }
|
---|
312 |
|
---|
313 | cs_readunlock(__func__, &clientlist_lock);
|
---|
314 | return peer_found;
|
---|
315 | }
|
---|
316 |
|
---|
317 | void gbox_get_online_peers(void)
|
---|
318 | {
|
---|
319 | int n = 0, i;
|
---|
320 | struct s_client *cl;
|
---|
321 |
|
---|
322 | for(i = 0; i < GBOX_MAX_DEST_PEERS; i++)
|
---|
323 | {
|
---|
324 | cfg.gbox_dest_peers[i] = '\0';
|
---|
325 | }
|
---|
326 |
|
---|
327 | cfg.gbox_dest_peers_num = 0;
|
---|
328 | cs_readlock(__func__, &clientlist_lock);
|
---|
329 |
|
---|
330 | for(cl = first_client; cl; cl = cl->next)
|
---|
331 | {
|
---|
332 | if(cl->gbox && cl->typ == 'p' && n < GBOX_MAX_DEST_PEERS)
|
---|
333 | {
|
---|
334 | struct gbox_peer *peer = cl->gbox;
|
---|
335 | if(peer->online) // peer is online
|
---|
336 | {
|
---|
337 | cfg.gbox_dest_peers[n++] = peer->gbox.id;
|
---|
338 | }
|
---|
339 | }
|
---|
340 | }
|
---|
341 |
|
---|
342 | cs_readunlock(__func__, &clientlist_lock);
|
---|
343 | cfg.gbox_dest_peers_num = n;
|
---|
344 | return;
|
---|
345 | }
|
---|
346 |
|
---|
347 | void gbox_init_send_gsms(void)
|
---|
348 | {
|
---|
349 | uint16_t boxid = 0;
|
---|
350 | uint8_t num = 0;
|
---|
351 | uint8_t msg_type = 0;
|
---|
352 | int32_t poll_result = 0;
|
---|
353 | char text[150];
|
---|
354 | memset(text, 0, sizeof(text));
|
---|
355 | char *fext = FILE_GSMS_TXT;
|
---|
356 | char *fname = get_gbox_tmp_fname(fext);
|
---|
357 |
|
---|
358 | if(cfg.gsms_dis)
|
---|
359 | {
|
---|
360 | unlink(fname);
|
---|
361 | gsms_unavail();
|
---|
362 | return;
|
---|
363 | }
|
---|
364 |
|
---|
365 | poll_result = poll_gsms_data( &boxid, &num, text);
|
---|
366 | if(poll_result)
|
---|
367 | {
|
---|
368 | if(poll_result != -2)
|
---|
369 | {
|
---|
370 | cs_log("ERROR polling file %s", fname);
|
---|
371 | }
|
---|
372 |
|
---|
373 | return;
|
---|
374 | }
|
---|
375 |
|
---|
376 | int8_t gsms_len = cs_strlen(text);
|
---|
377 | cs_log_dbg(D_READER,"got from %s: box_ID = %04X num = %d gsms_length = %d txt = %s", fname, boxid, num, gsms_len, text);
|
---|
378 |
|
---|
379 | switch(num)
|
---|
380 | {
|
---|
381 | case 0:
|
---|
382 | msg_type = 0x30;
|
---|
383 | break;
|
---|
384 |
|
---|
385 | case 1:
|
---|
386 | msg_type = 0x31;
|
---|
387 | break;
|
---|
388 |
|
---|
389 | //case 2:
|
---|
390 | // gsms_prot = 2;
|
---|
391 | // msg_type = 0x30;
|
---|
392 | // break;
|
---|
393 |
|
---|
394 | //case 3:
|
---|
395 | // gsms_prot = 2;
|
---|
396 | // msg_type = 0x31;
|
---|
397 | // break;
|
---|
398 |
|
---|
399 | default:
|
---|
400 | cs_log("ERROR unknown gsms protocol");
|
---|
401 | return;
|
---|
402 | }
|
---|
403 |
|
---|
404 | cs_log_dbg(D_READER,"init gsms to boxid= %04X length= %d msg_type= %02X ", boxid, gsms_len, msg_type);
|
---|
405 |
|
---|
406 | uint8_t id_valid = 0;
|
---|
407 | struct s_client *cl;
|
---|
408 | cs_readlock(__func__, &clientlist_lock);
|
---|
409 |
|
---|
410 | for(cl = first_client; cl; cl = cl->next)
|
---|
411 | {
|
---|
412 | if(cl->gbox && cl->typ == 'p')
|
---|
413 | {
|
---|
414 | struct gbox_peer *peer = cl->gbox;
|
---|
415 |
|
---|
416 | if(peer->online && boxid == 0xFFFF) // send gsms to all peers online
|
---|
417 | {
|
---|
418 | gbox_send_gsms2peer(cl, text, msg_type, gsms_len);
|
---|
419 | id_valid = 1;
|
---|
420 | }
|
---|
421 |
|
---|
422 | if(!peer->online && boxid == 0xFFFF)
|
---|
423 | {
|
---|
424 | cs_log("Info: peer %04X is OFFLINE", peer->gbox.id);
|
---|
425 | write_gsms_nack( cl, 1);
|
---|
426 | id_valid = 1;
|
---|
427 | }
|
---|
428 |
|
---|
429 | if(peer->online && boxid == peer->gbox.id)
|
---|
430 | {
|
---|
431 | gbox_send_gsms2peer(cl, text, msg_type, gsms_len);
|
---|
432 | id_valid = 1;
|
---|
433 | }
|
---|
434 |
|
---|
435 | if(!peer->online && boxid == peer->gbox.id)
|
---|
436 | {
|
---|
437 | cs_log("WARNING: send GSMS failed - peer %04X is OFFLINE", peer->gbox.id);
|
---|
438 | write_gsms_nack( cl, 0);
|
---|
439 | id_valid = 1;
|
---|
440 | }
|
---|
441 | }
|
---|
442 | }
|
---|
443 |
|
---|
444 | cs_readunlock(__func__, &clientlist_lock);
|
---|
445 |
|
---|
446 | if(!id_valid)
|
---|
447 | {
|
---|
448 | cs_log("WARNING: send GSMS failed - peer_id unknown");
|
---|
449 | }
|
---|
450 |
|
---|
451 | return;
|
---|
452 | }
|
---|
453 |
|
---|
454 | void gbox_send_gsms_ack(struct s_client *cli)
|
---|
455 | {
|
---|
456 | uint8_t outbuf[20];
|
---|
457 | struct gbox_peer *peer = cli->gbox;
|
---|
458 | uint16_t local_gbox_id = gbox_get_local_gbox_id();
|
---|
459 | uint32_t local_gbox_pw = gbox_get_local_gbox_password();
|
---|
460 | struct s_reader *rdr = cli->reader;
|
---|
461 |
|
---|
462 | if(peer->online)
|
---|
463 | {
|
---|
464 | gbox_message_header(outbuf, MSG_GSMS_ACK, peer->gbox.password, local_gbox_pw);
|
---|
465 |
|
---|
466 | outbuf[10] = 0;
|
---|
467 | outbuf[11] = 0;
|
---|
468 | outbuf[12] = (local_gbox_id >> 8) & 0xff;
|
---|
469 | outbuf[13] = local_gbox_id & 0xff;
|
---|
470 | outbuf[14] = 0x1;
|
---|
471 | outbuf[15] = 0;
|
---|
472 |
|
---|
473 | cs_log_dbg(D_READER,"<-[gbx] send GSMS_ACK to %s:%d id: %04X", rdr->device, rdr->r_port, peer->gbox.id);
|
---|
474 | gbox_send(cli, outbuf, 16);
|
---|
475 | }
|
---|
476 | }
|
---|
477 |
|
---|
478 | #endif
|
---|