module-gbox-sms.c

   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("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 < 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 = 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 = 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 static pthread_t sms_sender_thread;
 479 static int32_t sms_sender_active = 0;
 480 static pthread_cond_t sleep_cond;
 481 static pthread_mutex_t sleep_cond_mutex;
 482 static pthread_mutex_t sms_mutex;
 483
 484 static void sms_mutex_init(void)
 485 {
 486         static int8_t mutex_init = 0;
 487         if(!mutex_init)
 488         {
 489                 SAFE_MUTEX_INIT(&sms_mutex, NULL);
 490                 cs_pthread_cond_init(__func__, &sleep_cond_mutex, &sleep_cond);
 491                 mutex_init = 1;
 492         }
 493 }
 494
 495 static void sms_sender(void)
 496 {
 497         char *fext= FILE_GSMS_TXT;
 498         char *fname = get_gbox_tmp_fname(fext);
 499
 500         while(sms_sender_active)
 501         {
 502                 if(file_exists(fname))
 503                 {
 504                         gbox_init_send_gsms();
 505                 }
 506
 507                 sleepms_on_cond(__func__, &sleep_cond_mutex, &sleep_cond, 1000);
 508         }
 509
 510         pthread_exit(NULL);
 511 }
 512
 513 void start_sms_sender(void)
 514 {
 515         int32_t is_active;
 516
 517         sms_mutex_init();
 518         SAFE_MUTEX_LOCK(&sms_mutex);
 519
 520         is_active = sms_sender_active;
 521         if(!sms_sender_active)
 522         {
 523                 sms_sender_active = 1;
 524         }
 525
 526         if(is_active || cfg.gsms_dis)
 527         {
 528                 SAFE_MUTEX_UNLOCK(&sms_mutex);
 529                 return;
 530         }
 531
 532         int32_t ret = start_thread("sms sender", (void *)&sms_sender, NULL, &sms_sender_thread, 0, 1);
 533         if(ret)
 534         {
 535                 sms_sender_active = 0;
 536         }
 537
 538         SAFE_MUTEX_UNLOCK(&sms_mutex);
 539 }
 540
 541 void stop_sms_sender(void)
 542 {
 543         sms_mutex_init();
 544         SAFE_MUTEX_LOCK(&sms_mutex);
 545
 546         if(sms_sender_active)
 547         {
 548                 sms_sender_active = 0;
 549                 SAFE_COND_SIGNAL(&sleep_cond);
 550                 SAFE_THREAD_JOIN(sms_sender_thread, NULL);
 551         }
 552
 553         SAFE_MUTEX_UNLOCK(&sms_mutex);
 554 }
 555
 556 #endif