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