module-cccam-cacheex.c

   1 #define MODULE_LOG_PREFIX "cccam"
   2
   3 #include "globals.h"
   4 #include "oscam-array.h"
   5
   6 #if defined(CS_CACHEEX) && defined(MODULE_CCCAM)
   7
   8 #include "module-cacheex.h"
   9 #include "module-cccam-data.h"
  10 #include "module-cccam-cacheex.h"
  11 #include "oscam-cache.h"
  12 #include "oscam-client.h"
  13 #include "oscam-ecm.h"
  14 #include "oscam-string.h"
  15 #include "oscam-chk.h"
  16 #include "oscam-reader.h"
  17
  18 #define CSP_HASH_SWAP(n) (((((uint32_t)(n) & 0xFF)) << 24) | \
  19                   ((((uint32_t)(n) & 0xFF00)) << 8) | \
  20                   ((((uint32_t)(n) & 0xFF0000)) >> 8) | \
  21                   ((((uint32_t)(n) & 0xFF000000)) >> 24))
  22
  23 extern int32_t cc_cli_connect(struct s_client *cl);
  24 extern int32_t cc_cmd_send(struct s_client *cl, uint8_t *buf, int32_t len, cc_msg_type_t cmd);
  25
  26 void cc_cacheex_filter_out(struct s_client *cl)
  27 {
  28         struct s_reader *rdr = (cl->typ == 'c') ? NULL : cl->reader;
  29         int i = 0, j;
  30         CECSPVALUETAB *filter;
  31         //minimal size, keep it <= 512 for max UDP packet size without fragmentation
  32         int32_t size = 482;
  33         uint8_t buf[482];
  34         memset(buf, 0, sizeof(buf));
  35
  36         //mode==2 send filters from rdr
  37         if(rdr && rdr->cacheex.mode == 2)
  38         {
  39                 filter = &rdr->cacheex.filter_caidtab;
  40         }
  41         //mode==3 send filters from acc
  42         else if(cl->typ == 'c' && cl->account && cl->account->cacheex.mode == 3)
  43         {
  44                 filter = &cl->account->cacheex.filter_caidtab;
  45         }
  46         else {
  47                 return;
  48         }
  49
  50         i2b_buf(2, filter->cevnum, buf + i);
  51         i += 2;
  52
  53         int32_t max_filters = 30;
  54         for(j=0; j<max_filters; j++)
  55         {
  56                 if(filter->cevnum > j){
  57                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
  58                         i2b_buf(4, d->caid, buf + i);
  59                 }
  60                 i += 4;
  61         }
  62
  63         for(j=0; j<max_filters; j++)
  64         {
  65                 if(filter->cevnum > j){
  66                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
  67                         i2b_buf(4, d->cmask, buf + i);
  68                 }
  69                 i += 4;
  70         }
  71
  72         for(j=0; j<max_filters; j++)
  73         {
  74                 if(filter->cevnum > j){
  75                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
  76                         i2b_buf(4, d->prid, buf + i);
  77                 }
  78                 i += 4;
  79         }
  80
  81         for(j=0; j<max_filters; j++)
  82         {
  83                 if(filter->cevnum > j){
  84                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
  85                         i2b_buf(4, d->srvid, buf + i);
  86                 }
  87                 i += 4;
  88         }
  89
  90         cs_log_dbg(D_CACHEEX, "cacheex: sending push filter request to %s", username(cl));
  91         cc_cmd_send(cl, buf, size, MSG_CACHE_FILTER);
  92 }
  93
  94 void cc_cacheex_filter_in(struct s_client *cl, uchar *buf)
  95 {
  96         struct s_reader *rdr = (cl->typ == 'c') ? NULL : cl->reader;
  97         int i = 0, j;
  98         int32_t caid, cmask, provid, srvid;
  99         CECSPVALUETAB *filter;
 100
 101         //mode==2 write filters to acc
 102         if(cl->typ == 'c' && cl->account && cl->account->cacheex.mode == 2
 103                 && cl->account->cacheex.allow_filter == 1)
 104         {
 105                 filter = &cl->account->cacheex.filter_caidtab;
 106         }
 107         //mode==3 write filters to rdr
 108         else if(rdr && rdr->cacheex.mode == 3 && rdr->cacheex.allow_filter == 1)
 109         {
 110                 filter = &rdr->cacheex.filter_caidtab;
 111         }
 112         else {
 113                 return;
 114         }
 115
 116         cecspvaluetab_clear(filter);
 117         i += 2;
 118
 119         int32_t max_filters = 30;
 120         for(j=0; j<max_filters; j++)
 121         {
 122                 caid = b2i(4, buf + i);
 123                 if(caid > 0){
 124                         CECSPVALUETAB_DATA d;
 125                         memset(&d, 0, sizeof(d));
 126                         d.caid = b2i(4, buf + i);
 127                         cecspvaluetab_add(filter, &d);
 128                 }
 129                 i += 4;
 130         }
 131
 132         for(j=0; j<max_filters; j++)
 133         {
 134                 cmask = b2i(4, buf + i);
 135                 if(j<filter->cevnum){
 136                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
 137                         d->cmask = cmask;
 138                 }
 139                 i += 4;
 140         }
 141
 142         for(j=0; j<max_filters; j++)
 143         {
 144                 provid = b2i(4, buf + i);
 145                 if(j<filter->cevnum){
 146                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
 147                         d->prid = provid;
 148                 }
 149                 i += 4;
 150         }
 151
 152         for(j=0; j<max_filters; j++)
 153         {
 154                 srvid = b2i(4, buf + i);
 155                 if(j<filter->cevnum){
 156                         CECSPVALUETAB_DATA *d = &filter->cevdata[j];
 157                         d->srvid = srvid;
 158                 }
 159                 i += 4;
 160         }
 161
 162         cs_log_dbg(D_CACHEEX, "cacheex: received push filter request from %s", username(cl));
 163 }
 164
 165 static int32_t cc_cacheex_push_chk(struct s_client *cl, struct ecm_request_t *er)
 166 {
 167         struct cc_data *cc = cl->cc;
 168         if(chk_is_null_nodeid(cc->peer_node_id,8))
 169         {
 170                 cs_log_dbg(D_CACHEEX, "cacheex: NO peer_node_id got yet, skip!");
 171                 return 0;
 172         }
 173
 174         if(ll_count(er->csp_lastnodes) >= cacheex_maxhop(cl))    //check max 10 nodes to push:
 175         {
 176                 cs_log_dbg(D_CACHEEX, "cacheex: nodelist reached %d nodes, no push", cacheex_maxhop(cl));
 177                 return 0;
 178         }
 179
 180         uint8_t *remote_node = cc->peer_node_id;
 181
 182         //search existing peer nodes:
 183         LL_LOCKITER *li = ll_li_create(er->csp_lastnodes, 0);
 184         uint8_t *node;
 185         while((node = ll_li_next(li)))
 186         {
 187                 cs_log_dbg(D_CACHEEX, "cacheex: check node %" PRIu64 "X == %" PRIu64 "X ?", cacheex_node_id(node), cacheex_node_id(remote_node));
 188                 if(memcmp(node, remote_node, 8) == 0)
 189                 {
 190                         break;
 191                 }
 192         }
 193         ll_li_destroy(li);
 194
 195         //node found, so we got it from there, do not push:
 196         if(node)
 197         {
 198                 cs_log_dbg(D_CACHEEX,
 199                                           "cacheex: node %" PRIu64 "X found in list => skip push!", cacheex_node_id(node));
 200                 return 0;
 201         }
 202
 203         if(!cl->cc)
 204         {
 205                 if(cl->reader && !cl->reader->tcp_connected)
 206                 {
 207                         cc_cli_connect(cl);
 208                 }
 209         }
 210
 211         if(!cc || !cl->udp_fd)
 212         {
 213                 cs_log_dbg(D_CACHEEX, "cacheex: not connected %s -> no push", username(cl));
 214                 return 0;
 215         }
 216
 217         //check if cw is already pushed
 218         if(check_is_pushed(er->cw_cache, cl))
 219                 { return 0; }
 220
 221         return 1;
 222 }
 223
 224 static int32_t cc_cacheex_push_out(struct s_client *cl, struct ecm_request_t *er)
 225 {
 226         int8_t rc = (er->rc < E_NOTFOUND) ? E_FOUND : er->rc;
 227         if(rc != E_FOUND && rc != E_UNHANDLED) { return -1; }  //Maybe later we could support other rcs
 228
 229         if(cl->reader)
 230         {
 231                 if(!cl->reader->tcp_connected)
 232                         { cc_cli_connect(cl); }
 233         }
 234
 235         struct cc_data *cc = cl->cc;
 236         if(!cc || !cl->udp_fd)
 237         {
 238                 cs_log_dbg(D_CACHEEX, "cacheex: not connected %s -> no push", username(cl));
 239                 return (-1);
 240         }
 241
 242         uint32_t size = sizeof(er->ecmd5) + sizeof(er->csp_hash) + sizeof(er->cw) + sizeof(uint8_t) +
 243                                         (ll_count(er->csp_lastnodes) + 1) * 8;
 244
 245         unsigned char *buf;
 246         if(!cs_malloc(&buf, size + 20))  //camd35_send() adds +20
 247                 { return -1; }
 248
 249         // build ecm message
 250         //buf[0] = er->caid >> 8;
 251         //buf[1] = er->caid & 0xff;
 252         //buf[2] = er->prid >> 24;
 253         //buf[3] = er->prid >> 16;
 254         //buf[4] = er->prid >> 8;
 255         //buf[5] = er->prid & 0xff;
 256         //buf[10] = er->srvid >> 8;
 257         //buf[11] = er->srvid & 0xff;
 258         buf[12] = (sizeof(er->ecmd5) + sizeof(er->csp_hash) + sizeof(er->cw)) & 0xff;
 259         buf[13] = (sizeof(er->ecmd5) + sizeof(er->csp_hash) + sizeof(er->cw)) >> 8;
 260         //buf[12] = 0;
 261         //buf[13] = 0;
 262         buf[14] = rc;
 263
 264         i2b_buf(2, er->caid, buf + 0);
 265         i2b_buf(4, er->prid, buf + 2);
 266         i2b_buf(2, er->srvid, buf + 10);
 267
 268         if(er->cwc_cycletime && er->cwc_next_cw_cycle < 2)
 269         {
 270                 buf[18] = er->cwc_cycletime; // contains cwc stage3 cycletime
 271                 if(er->cwc_next_cw_cycle == 1)
 272                 { buf[18] = (buf[18] | 0x80); } // set bit 8 to high
 273
 274                 if(cl->typ == 'c' && cl->account && cl->account->cacheex.mode)
 275                         { cl->account->cwc_info++; }
 276                 else if((cl->typ == 'p' || cl->typ == 'r') && (cl->reader && cl->reader->cacheex.mode))
 277                         { cl->cwc_info++; }
 278                 cs_log_dbg(D_CWC, "CWC (CE) push to %s cycletime: %isek - nextcwcycle: CW%i for %04X@%06X:%04X", username(cl), er->cwc_cycletime, er->cwc_next_cw_cycle, er->caid, er->prid, er->srvid);
 279         }
 280
 281         buf[19] = er->ecm[0] != 0x80 && er->ecm[0] != 0x81 ? 0 : er->ecm[0];
 282
 283         uint8_t *ofs = buf + 20;
 284
 285         //write oscam ecmd5:
 286         memcpy(ofs, er->ecmd5, sizeof(er->ecmd5)); //16
 287         ofs += sizeof(er->ecmd5);
 288
 289         //write csp hashcode:
 290         i2b_buf(4, CSP_HASH_SWAP(er->csp_hash), ofs);
 291         ofs += 4;
 292
 293         //write cw:
 294         memcpy(ofs, er->cw, sizeof(er->cw)); //16
 295         ofs += sizeof(er->cw);
 296
 297         //write node count:
 298         *ofs = ll_count(er->csp_lastnodes) + 1;
 299         ofs++;
 300
 301         //write own node:
 302         memcpy(ofs, cc->node_id, 8);
 303         ofs += 8;
 304
 305         //write other nodes:
 306         LL_LOCKITER *li = ll_li_create(er->csp_lastnodes, 0);
 307         uint8_t *node;
 308         while((node = ll_li_next(li)))
 309         {
 310                 memcpy(ofs, node, 8);
 311                 ofs += 8;
 312         }
 313         ll_li_destroy(li);
 314
 315         int32_t res = cc_cmd_send(cl, buf, size + 20, MSG_CACHE_PUSH);
 316         if(res > 0)   // cache-ex is pushing out, so no receive but last_g should be updated otherwise disconnect!
 317         {
 318                 if(cl->reader)
 319                         { cl->reader->last_s = cl->reader->last_g = time((time_t *)0); } // correct
 320                 if(cl) { cl->last = time(NULL); }
 321         }
 322         NULLFREE(buf);
 323         return res;
 324 }
 325
 326 void cc_cacheex_push_in(struct s_client *cl, uchar *buf)
 327 {
 328         struct cc_data *cc = cl->cc;
 329         ECM_REQUEST *er;
 330         if(!cc) { return; }
 331
 332         if(cl->reader)
 333                 { cl->reader->last_s = cl->reader->last_g = time((time_t *)0); }
 334         if(cl) { cl->last = time(NULL); }
 335
 336         int8_t rc = buf[14];
 337         if(rc != E_FOUND && rc != E_UNHANDLED)  //Maybe later we could support other rcs
 338                 { return; }
 339         uint16_t size = buf[12] | (buf[13] << 8);
 340         if(size != sizeof(er->ecmd5) + sizeof(er->csp_hash) + sizeof(er->cw))
 341         {
 342                 cs_log_dbg(D_CACHEEX, "cacheex: %s received old cash-push format! data ignored!", username(cl));
 343                 return;
 344         }
 345         if(!(er = get_ecmtask()))
 346                 { return; }
 347
 348         er->caid = b2i(2, buf + 0);
 349         er->prid = b2i(4, buf + 2);
 350         er->srvid = b2i(2, buf + 10);
 351         er->ecm[0] = buf[19]!=0x80 && buf[19]!=0x81 ? 0 : buf[19]; //odd/even byte, usefull to send it over CSP and to check cw for swapping
 352         er->rc = rc;
 353
 354         er->ecmlen = 0;
 355
 356         if(buf[18])
 357         {
 358                 if(buf[18] & (0x01 << 7))
 359                 {
 360                         er->cwc_cycletime = (buf[18] & 0x7F); // remove bit 8 to get cycletime
 361                         er->cwc_next_cw_cycle = 1;
 362                 }
 363                 else
 364                 {
 365                         er->cwc_cycletime = buf[18];
 366                         er->cwc_next_cw_cycle = 0;
 367                 }
 368         }
 369
 370         if (er->cwc_cycletime && er->cwc_next_cw_cycle < 2)
 371         {
 372                 if(cl->typ == 'c' && cl->account && cl->account->cacheex.mode)
 373                         { cl->account->cwc_info++; }
 374                 else if((cl->typ == 'p' || cl->typ == 'r') && (cl->reader && cl->reader->cacheex.mode))
 375                         { cl->cwc_info++; }
 376                 cs_log_dbg(D_CWC, "CWC (CE) received from %s cycletime: %isek - nextcwcycle: CW%i for %04X@%06X:%04X", username(cl), er->cwc_cycletime, er->cwc_next_cw_cycle, er->caid, er->prid, er->srvid);
 377         }
 378
 379         uint8_t *ofs = buf + 20;
 380
 381         //Read ecmd5
 382         memcpy(er->ecmd5, ofs, sizeof(er->ecmd5)); //16
 383         ofs += sizeof(er->ecmd5);
 384
 385         if(!check_cacheex_filter(cl, er))
 386                 { return; }
 387
 388         //Read csp_hash:
 389         er->csp_hash = CSP_HASH_SWAP(b2i(4, ofs));
 390         ofs += 4;
 391
 392         //Read cw:
 393         memcpy(er->cw, ofs, sizeof(er->cw)); //16
 394         ofs += sizeof(er->cw);
 395
 396         //Read lastnode count:
 397         uint8_t count = *ofs;
 398         ofs++;
 399
 400         //check max nodes:
 401         if(count > cacheex_maxhop(cl))
 402         {
 403                         cs_log_dbg(D_CACHEEX, "cacheex: received %d nodes (max=%d), ignored! %s", (int32_t)count, cacheex_maxhop(cl), username(cl));
 404                 NULLFREE(er);
 405                 return;
 406         }
 407         cs_log_dbg(D_CACHEEX, "cacheex: received %d nodes %s", (int32_t)count, username(cl));
 408         //Read lastnodes:
 409         uint8_t *data;
 410         if (er){
 411                 er->csp_lastnodes = ll_create("csp_lastnodes");
 412         }
 413         while(count)
 414         {
 415                 if(!cs_malloc(&data, 8))
 416                         { break; }
 417                 memcpy(data, ofs, 8);
 418                 ofs += 8;
 419                 ll_append(er->csp_lastnodes, data);
 420                 count--;
 421                 cs_log_dbg(D_CACHEEX, "cacheex: received node %" PRIu64 "X %s", cacheex_node_id(data), username(cl));
 422         }
 423
 424         //for compatibility: add peer node if no node received:
 425         if(!ll_count(er->csp_lastnodes))
 426         {
 427                 if(!cs_malloc(&data, 8))
 428                         { return; }
 429                 memcpy(data, cc->peer_node_id, 8);
 430                 ll_append(er->csp_lastnodes, data);
 431                 cs_log_dbg(D_CACHEEX, "cacheex: added missing remote node id %" PRIu64 "X", cacheex_node_id(data));
 432         }
 433
 434         cacheex_add_to_cache(cl, er);
 435 }
 436
 437 void cc_cacheex_module_init(struct s_module *ph)
 438 {
 439         ph->c_cache_push = cc_cacheex_push_out;
 440         ph->c_cache_push_chk = cc_cacheex_push_chk;
 441 }
 442
 443 #endif