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
  14 static int32_t poll_gsms_data (uint16_t *boxid, uint8_t *num, char *text)
  15 {
  16         char *fext= FILE_GSMS_TXT;
  17         char *fname = get_gbox_tmp_fname(fext);
  18         FILE *fhandle = fopen(fname, "r");
  19         if(!fhandle)
  20                 {
  21                 //cs_log("Couldn't open %s: %s", fname, strerror(errno));
  22                 return -2;
  23                 }
  24         uint32_t length1;
  25         uint8_t length;
  26         char buffer[140];
  27         char *tail;
  28         memset(buffer, 0, sizeof(buffer));
  29         fseek (fhandle,0L,SEEK_END);
  30         length1 = ftell(fhandle);
  31         fseek (fhandle,0L,SEEK_SET);
  32         if (length1 < 13)
  33                 {
  34                 cs_log("min msg char in %s = 6, actual = %d",fname, length1-7);
  35                 fclose(fhandle);
  36                 unlink(fname);
  37                 return -1;
  38                 }
  39         if(fgets(buffer,140,fhandle) != NULL)
  40                 {
  41                 *boxid = strtol (buffer, &tail, 16);
  42                 *num = atoi (tail);
  43                 }
  44         fclose(fhandle);
  45         unlink(fname);
  46         if (length1 > (127+7))
  47                 {
  48                 length = 127+7;
  49                 }
  50         else
  51                 {
  52                 length = length1;
  53                 }
  54         cs_log_dbg(D_READER, "total msg length taken from %s = %d, limitted to %d",fname, length1, length);
  55         strncpy(text, &(buffer[7]),length-7);
  56         return 0;
  57 }
  58 static void write_gsms_to_osd_file(struct s_client *cli, unsigned char *gsms)
  59 {
  60 #ifdef GBOX_ENABLE_UNSAFE_OSD
  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         memset(gsms_buf, 0, sizeof(gsms_buf));
  67         snprintf(gsms_buf, sizeof(gsms_buf), "%s %s:%s %s", fname, username(cli), cli->reader->device, gsms);
  68         cs_log_dbg(D_READER, "found OSD 'driver' %s - write gsms to OSD", fname);
  69         char *cmd = gsms_buf;
  70               FILE *p;
  71               if ((p = popen(cmd, "w")) == NULL)
  72                 {
  73                 cs_log("Error %s",fname);
  74                 return;
  75                 }
  76               pclose(p);
  77         }
  78 #else
  79         cs_log("OSD: username=%s dev=%s msg=%s", username(cli), cli->reader->device, gsms);
  80         cs_log_dbg(D_READER, "OSD is disabled because it is a security risk, to enable it recompile OSCAM.");
  81 #endif
  82         return;
  83 }
  84
  85 void write_gsms_ack (struct s_client *cli, uint8_t gsms_prot)
  86 {
  87         char tsbuf[28];
  88         time_t walltime = cs_time();
  89         cs_ctime_r(&walltime, tsbuf);
  90         struct gbox_peer *peer = cli->gbox;
  91         char *fext= FILE_GSMS_ACK;
  92         char *fname = get_gbox_tmp_fname(fext);
  93         FILE *fhandle = fopen(fname, "a+");
  94         if(!fhandle)
  95         {
  96                 cs_log("Couldn't open %s: %s", fname, strerror(errno));
  97                 return;
  98         }
  99         fprintf(fhandle, "Peer %04X (%s) confirmed receipt of GSMS_%d on %s",peer->gbox.id, cli->reader->device, gsms_prot, tsbuf);
 100         fclose(fhandle);
 101         return;
 102 }
 103
 104 static void write_gsms_nack (struct s_client *cl, uint8_t gsms_prot, uint8_t inf)
 105 {
 106         char tsbuf[28];
 107         time_t walltime = cs_time();
 108         cs_ctime_r(&walltime, tsbuf);
 109         struct gbox_peer *peer = cl->gbox;
 110         char *fext= FILE_GSMS_NACK;
 111         char *fname = get_gbox_tmp_fname(fext);
 112         FILE *fhandle = fopen(fname, "a+");
 113         if(!fhandle)
 114         {
 115                 cs_log("Couldn't open %s: %s", fname, strerror(errno));
 116                 return;
 117         }
 118         if(inf)
 119         {
 120         fprintf(fhandle, "INFO: GSMS_%d to all: Peer %04X (%s) was OFFLINE %s",gsms_prot,peer->gbox.id, cl->reader->device,tsbuf);
 121         }
 122         else
 123         {
 124         fprintf(fhandle, "WARNING: GSMS_%d private to Peer %04X (%s) failed - was OFFLINE %s",gsms_prot,peer->gbox.id, cl->reader->device,tsbuf);
 125         }
 126         fclose(fhandle);
 127         return;
 128 }
 129
 130 void write_gsms_msg (struct s_client *cli, uchar *gsms, uint16_t type, uint16_t UNUSED(msglen))
 131 {
 132         char tsbuf[28];
 133         time_t walltime = cs_time();
 134         cs_ctime_r(&walltime, tsbuf);
 135         struct gbox_peer *peer = cli->gbox;
 136         struct s_reader *rdr = cli->reader;
 137         char *fext= FILE_GSMS_MSG;
 138         char *fname = get_gbox_tmp_fname(fext);
 139         FILE *fhandle = fopen(fname, "a+");
 140         if(!fhandle)
 141         {
 142                 cs_log("Couldn't open %s: %s", fname, strerror(errno));
 143                 return;
 144         }
 145         if(type == 0x30)
 146                 {
 147                 fprintf(fhandle, "Normal message received from %04X %s on %s%s\n\n",peer->gbox.id, cli->reader->device, tsbuf, gsms);
 148                 snprintf(rdr->last_gsms, sizeof(rdr->last_gsms), "%s %s", gsms, tsbuf); //added for easy handling of gsms by webif
 149                 }
 150         else if(type == 0x31)
 151                 {
 152                 fprintf(fhandle, "OSD message received from %04X %s on %s%s\n\n",peer->gbox.id, cli->reader->device, tsbuf, gsms);
 153                 write_gsms_to_osd_file(cli, gsms);
 154                 snprintf(rdr->last_gsms, sizeof(rdr->last_gsms), "%s %s", gsms, tsbuf); //added for easy handling of gsms by webif
 155                 }
 156         else
 157                 {fprintf(fhandle, "Corrupted message received from %04X %s on %s%s\n\n",peer->gbox.id, cli->reader->device, tsbuf, gsms);}
 158                 fclose(fhandle);
 159         return;
 160 }
 161
 162 void gsms_unavail(void)
 163 {
 164         cs_log("INFO: GSMS feature disabled by conf");
 165 }
 166
 167 static void gbox_send_gsms2peer(struct s_client *cl, char *gsms, uint8_t msg_type, uint8_t gsms_prot, int8_t gsms_len)
 168 {
 169         uchar outbuf[150];
 170         struct gbox_peer *peer = cl->gbox;
 171         uint16_t local_gbox_id = gbox_get_local_gbox_id();
 172         uint32_t local_gbox_pw = gbox_get_local_gbox_password();
 173         struct s_reader *rdr = cl->reader;
 174
 175                         if (gsms_prot == 1)
 176                         {
 177                                 gbox_message_header(outbuf, MSG_GSMS_1, 0, 0);
 178                                 outbuf[2] = gsms_len; // gsms len
 179                                 outbuf[3] = msg_type;  //msg type
 180                                 memcpy(&outbuf[4], gsms,gsms_len);
 181                                 cs_log("<-[gbx] send GSMS_1 to %s:%d id: %04X", rdr->device, rdr->r_port, peer->gbox.id);
 182                                 gbox_send(cl, outbuf, gsms_len + 4);
 183                         }
 184                         if (gsms_prot == 2)
 185                         {
 186                                 gbox_message_header(outbuf, MSG_GSMS_2, peer->gbox.password, local_gbox_pw);
 187                                 outbuf[10] = (peer->gbox.id >> 8) & 0xff;
 188                                 outbuf[11] = peer->gbox.id & 0xff;
 189                                 outbuf[12] = (local_gbox_id >> 8) & 0xff;
 190                                 outbuf[13] = local_gbox_id & 0xff;
 191                                 outbuf[14] = msg_type; //msg type
 192                                 outbuf[15] = gsms_len; // gsms length
 193                                 memcpy(&outbuf[16], gsms,gsms_len);
 194                                 outbuf[16 + gsms_len] = 0; //last byte 0x00
 195                                 cs_log("<-[gbx] send GSMS_2 to %s:%d id: %04X", rdr->device, rdr->r_port, peer->gbox.id);
 196                                 gbox_send(cl, outbuf, gsms_len + 17);
 197                         }
 198         return;
 199 }
 200
 201 void gbox_init_send_gsms(void)
 202 {
 203         uint16_t boxid = 0;
 204         uint8_t num = 0;
 205         uint8_t gsms_prot = 0;
 206         uint8_t msg_type = 0;
 207         int32_t poll_result = 0;
 208         char text[150];
 209         memset(text, 0, sizeof(text));
 210         char *fext= FILE_GSMS_TXT;
 211         char *fname = get_gbox_tmp_fname(fext);
 212         if(cfg.gsms_dis)
 213         {
 214         unlink(fname);
 215         gsms_unavail();
 216         return;
 217         }
 218         poll_result = poll_gsms_data( &boxid, &num, text);
 219         if(poll_result)
 220         {
 221         if(poll_result != -2)
 222                 { cs_log("ERROR polling file %s", fname); }
 223         return;
 224         }
 225         int8_t gsms_len = strlen(text);
 226         cs_log_dbg(D_READER,"got from %s: box_ID = %04X  num = %d  gsms_length = %d  txt = %s",fname, boxid, num, gsms_len, text);
 227
 228         switch(num)
 229         {
 230         case 0: {gsms_prot = 1; msg_type = 0x30; break;}
 231         case 1: {gsms_prot = 1; msg_type = 0x31; break;}
 232         case 2: {gsms_prot = 2; msg_type = 0x30; break;}
 233         case 3: {gsms_prot = 2; msg_type = 0x31; break;}
 234         default:{cs_log("ERROR unknown gsms protocol"); return;}
 235         }
 236         cs_log_dbg(D_READER,"init gsms_length=%d  msg_type=%02X msg_prot=%d",gsms_len, msg_type, gsms_prot);
 237
 238         struct s_client *cl;
 239         for (cl = first_client; cl; cl = cl->next)
 240         {
 241                 if(cl->gbox && cl->typ == 'p')
 242                 {
 243
 244                         struct gbox_peer *peer = cl->gbox;
 245                         if (peer->online && boxid == 0xFFFF) //send gsms to all peers online
 246                         {
 247                         gbox_send_gsms2peer(cl, text, msg_type, gsms_prot, gsms_len);
 248                         }
 249                         if (!peer->online && boxid == 0xFFFF)
 250                         {
 251                         cs_log("Info: peer %04X is OFFLINE",peer->gbox.id);
 252                         write_gsms_nack( cl, gsms_prot, 1);
 253                         }
 254                         if (peer->online && boxid == peer->gbox.id)
 255                         {
 256                         gbox_send_gsms2peer(cl, text, msg_type, gsms_prot, gsms_len);
 257                         }
 258                         if (!peer->online && boxid == peer->gbox.id)
 259                         {
 260                         cs_log("WARNING: send GSMS failed - peer %04X is OFFLINE",peer->gbox.id);
 261                         write_gsms_nack( cl, gsms_prot, 0);
 262                         }
 263                 }
 264         }
 265         return;
 266 }
 267
 268 void gbox_send_gsms_ack(struct s_client *cli, uint8_t gsms_prot)
 269 {
 270         uchar outbuf[20];
 271         struct gbox_peer *peer = cli->gbox;
 272         uint16_t local_gbox_id = gbox_get_local_gbox_id();
 273         uint32_t local_gbox_pw = gbox_get_local_gbox_password();
 274         struct s_reader *rdr = cli->reader;
 275                 if (peer->online && gsms_prot == 1)
 276                 {
 277                 gbox_message_header(outbuf, MSG_GSMS_ACK_1, 0x90989098, 0x90989098);
 278                 gbox_send(cli, outbuf, 10);
 279                 cs_log_dbg(D_READER,"<-[gbx] send GSMS_ACK_1 to %s:%d id: %04X",rdr->device, rdr->r_port, peer->gbox.id);
 280                 }
 281                 if (peer->online && gsms_prot == 2)
 282                 {
 283                 gbox_message_header(outbuf, MSG_GSMS_ACK_2, peer->gbox.password, local_gbox_pw);
 284                 outbuf[10] = 0;
 285                 outbuf[11] = 0;
 286                 outbuf[12] = (local_gbox_id >> 8) & 0xff;
 287                 outbuf[13] = local_gbox_id & 0xff;
 288                 outbuf[14] = 0x1;
 289                 outbuf[15] = 0;
 290                 cs_log_dbg(D_READER,"<-[gbx] send GSMS_ACK_2 to %s:%d id: %04X",rdr->device, rdr->r_port, peer->gbox.id);
 291                 gbox_send(cli, outbuf, 16);
 292                 }
 293 }
 294
 295 static pthread_t sms_sender_thread;
 296 static int32_t sms_sender_active = 0;
 297 static pthread_cond_t sleep_cond;
 298 static pthread_mutex_t sleep_cond_mutex;
 299 static pthread_mutex_t sms_mutex;
 300
 301 static void sms_mutex_init(void)
 302 {
 303         static int8_t mutex_init = 0;
 304
 305         if(!mutex_init)
 306         {
 307                 SAFE_MUTEX_INIT(&sms_mutex, NULL);
 308                 cs_pthread_cond_init(__func__, &sleep_cond_mutex, &sleep_cond);
 309                 mutex_init = 1;
 310         }
 311 }
 312
 313 static void sms_sender(void)
 314 {
 315         char *fext= FILE_GSMS_TXT;
 316         char *fname = get_gbox_tmp_fname(fext);
 317
 318         while(sms_sender_active)
 319         {
 320         if (file_exists(fname))
 321         {
 322                         gbox_init_send_gsms();
 323         }
 324
 325                 sleepms_on_cond(__func__, &sleep_cond_mutex, &sleep_cond, 1000);
 326         }
 327         pthread_exit(NULL);
 328 }
 329
 330 void start_sms_sender(void)
 331 {
 332         int32_t is_active;
 333
 334         sms_mutex_init();
 335
 336         SAFE_MUTEX_LOCK(&sms_mutex);
 337         is_active = sms_sender_active;
 338         if(!sms_sender_active)
 339         {
 340                 sms_sender_active = 1;
 341         }
 342
 343         if(is_active || cfg.gsms_dis)
 344         {
 345                 SAFE_MUTEX_UNLOCK(&sms_mutex);
 346                 return;
 347         }
 348
 349         int32_t ret = start_thread("sms sender", (void *)&sms_sender, NULL, &sms_sender_thread, 0, 1);
 350         if(ret)
 351         {
 352                 sms_sender_active = 0;
 353         }
 354
 355         SAFE_MUTEX_UNLOCK(&sms_mutex);
 356 }
 357
 358 void stop_sms_sender(void)
 359 {
 360         sms_mutex_init();
 361
 362         SAFE_MUTEX_LOCK(&sms_mutex);
 363
 364         if(sms_sender_active)
 365         {
 366                 sms_sender_active = 0;
 367                 SAFE_COND_SIGNAL(&sleep_cond);
 368                 SAFE_THREAD_JOIN(sms_sender_thread, NULL);
 369         }
 370
 371         SAFE_MUTEX_UNLOCK(&sms_mutex);
 372 }
 373
 374
 375 #endif