oscam-client.c

   1 #define MODULE_LOG_PREFIX "client"
   2
   3 #include "globals.h"
   4
   5 #include "cscrypt/md5.h"
   6 #include "module-anticasc.h"
   7 #include "module-cccam.h"
   8 #include "module-webif.h"
   9 #include "oscam-array.h"
  10 #include "oscam-conf-chk.h"
  11 #include "oscam-client.h"
  12 #include "oscam-ecm.h"
  13 #include "oscam-failban.h"
  14 #include "oscam-garbage.h"
  15 #include "oscam-lock.h"
  16 #include "oscam-net.h"
  17 #include "oscam-reader.h"
  18 #include "oscam-string.h"
  19 #include "oscam-time.h"
  20 #include "oscam-work.h"
  21 #include "reader-common.h"
  22 #include "oscam-chk.h"
  23
  24 extern CS_MUTEX_LOCK fakeuser_lock;
  25
  26 static char *processUsername;
  27 static struct s_client *first_client_hashed[CS_CLIENT_HASHBUCKETS]; // Alternative hashed client list
  28
  29 /* Gets the unique thread number from the client. Used in monitor and newcamd. */
  30 int32_t get_threadnum(struct s_client *client)
  31 {
  32         struct s_client *cl;
  33         int32_t count = 0;
  34
  35         for(cl = first_client->next; cl; cl = cl->next)
  36         {
  37                 if(cl->typ == client->typ)
  38                 {
  39                         count++;
  40                 }
  41
  42                 if(cl == client)
  43                 {
  44                         return count;
  45                 }
  46         }
  47         return 0;
  48 }
  49
  50 struct s_auth *get_account_by_name(char *name)
  51 {
  52         struct s_auth *account;
  53         for(account = cfg.account; (account); account = account->next)
  54         {
  55                 if(streq(name, account->usr))
  56                 {
  57                         return account;
  58                 }
  59         }
  60         return NULL;
  61 }
  62
  63 int8_t is_valid_client(struct s_client *client)
  64 {
  65         struct s_client *cl;
  66         int32_t bucket = (uintptr_t)client / 16 % CS_CLIENT_HASHBUCKETS;
  67
  68         for(cl = first_client_hashed[bucket]; cl; cl = cl->nexthashed)
  69         {
  70                 if(cl == client)
  71                 {
  72                         return 1;
  73                 }
  74         }
  75         return 0;
  76 }
  77
  78 const char *remote_txt(void)
  79 {
  80         return cur_client()->typ == 'c' ? "client" : "remote server";
  81 }
  82
  83 const char *client_get_proto(struct s_client *cl)
  84 {
  85         const char *ctyp;
  86         switch(cl->typ)
  87         {
  88                 case 's':
  89                         ctyp = "server";
  90                         break;
  91
  92                 case 'h':
  93                         ctyp = "http";
  94                         break;
  95
  96                 case 'p':
  97                 case 'r':
  98                         ctyp = reader_get_type_desc(cl->reader, 1);
  99                         break;
 100
 101 #ifdef CS_ANTICASC
 102                 case 'a':
 103                         ctyp = "anticascader";
 104                         break;
 105
 106 #endif
 107                 case 'c':
 108                         if(cccam_client_extended_mode(cl))
 109                         {
 110                                 ctyp = "cccam_ext";
 111                                 break;
 112                         } /* fallthrough */
 113
 114                 default:
 115                         ctyp = get_module(cl)->desc;
 116         }
 117         return ctyp;
 118 }
 119
 120 static void cs_fake_client(struct s_client *client, char *usr, int32_t uniq, IN_ADDR_T ip)
 121 {
 122         /* Uniq = 1: only one connection per user
 123          *
 124          * Uniq = 2: set (new connected) user only to fake if source
 125          *           ip is different (e.g. for newcamd clients with
 126          *           different CAID's -> Ports)
 127          *
 128          * Uniq = 3: only one connection per user, but only the last
 129          *           login will survive (old mpcs behavior)
 130          *
 131          * Uniq = 4: set user only to fake if source ip is
 132          *           different, but only the last login will survive
 133          */
 134
 135         struct s_client *cl;
 136         struct s_auth *account;
 137         uint32_t con_count = 1;
 138         cs_writelock(__func__, &fakeuser_lock);
 139
 140         for(cl = first_client->next; cl; cl = cl->next)
 141         {
 142                 account = cl->account;
 143                 if(cl != client && cl->typ == 'c' && !cl->dup && account && streq(account->usr, usr)
 144                         && uniq < 5 && ((uniq % 2) || !IP_EQUAL(cl->ip, ip)))
 145                 {
 146                         char buf[20];
 147
 148                         con_count++;
 149                         if(con_count <= account->max_connections)
 150                         {
 151                                 continue;
 152                         }
 153
 154                         if(uniq == 3 || uniq == 4)
 155                         {
 156                                 cl->dup = 1;
 157                                 cl->aureader_list = NULL;
 158                                 cs_strncpy(buf, cs_inet_ntoa(cl->ip), sizeof(buf));
 159                                 cs_log("client(%8lX) duplicate user '%s' from %s (prev %s) set to fake (uniq=%d)",
 160                                                 (unsigned long)cl->thread, usr, cs_inet_ntoa(ip), buf, uniq);
 161
 162                                 if(cl->failban & BAN_DUPLICATE)
 163                                 {
 164                                         cs_add_violation(cl, usr);
 165                                 }
 166
 167                                 if(cfg.dropdups)
 168                                 {
 169                                         cs_writeunlock(__func__, &fakeuser_lock);
 170                                         cs_sleepms(120); // sleep a bit to prevent against saturation from fast reconnecting clients
 171                                         kill_thread(cl);
 172                                         cs_writelock(__func__, &fakeuser_lock);
 173                                 }
 174                         }
 175                         else
 176                         {
 177                                 client->dup = 1;
 178                                 client->aureader_list = NULL;
 179                                 cs_strncpy(buf, cs_inet_ntoa(ip), sizeof(buf));
 180                                 cs_log("client(%8lX) duplicate user '%s' from %s (current %s) set to fake (uniq=%d)",
 181                                                 (unsigned long)pthread_self(), usr, cs_inet_ntoa(cl->ip), buf, uniq);
 182
 183                                 if(client->failban & BAN_DUPLICATE)
 184                                 {
 185                                         cs_add_violation_by_ip(ip, get_module(client)->ptab.ports[client->port_idx].s_port, usr);
 186                                 }
 187
 188                                 if(cfg.dropdups)
 189                                 {
 190                                         cs_writeunlock(__func__, &fakeuser_lock); // we need to unlock here as cs_disconnect_client kills the current thread!
 191                                         cs_sleepms(120); // sleep a bit to prevent against saturation from fast reconnecting clients
 192                                         cs_disconnect_client(client);
 193                                         cs_writelock(__func__, &fakeuser_lock);
 194                                 }
 195                                 break;
 196                         }
 197                 }
 198         }
 199         cs_writeunlock(__func__, &fakeuser_lock);
 200 }
 201
 202 /* Resolves the ip of the hostname of the specified account and saves it in account->dynip.
 203    If the hostname is not configured, the ip is set to 0. */
 204 static void cs_user_resolve(struct s_auth *account)
 205 {
 206         if(account->dyndns)
 207         {
 208                 IN_ADDR_T lastip;
 209                 IP_ASSIGN(lastip, account->dynip);
 210                 cs_resolve(account->dyndns, &account->dynip, NULL, NULL);
 211
 212                 if(!IP_EQUAL(lastip, account->dynip))
 213                 {
 214                         cs_log("%s: resolved ip=%s", account->dyndns, cs_inet_ntoa(account->dynip));
 215                 }
 216         }
 217         else
 218         {
 219                 set_null_ip(&account->dynip);
 220         }
 221 }
 222
 223 /* Returns the username from the client. You will always get a char reference back (no NULLs but it may be string containting "NULL")
 224    which you should never modify and not free()! */
 225 const char *username(struct s_client *client)
 226 {
 227         if(!check_client(client))
 228         {
 229                 return "NULL";
 230         }
 231
 232         if(client->typ == 's' || client->typ == 'h' || client->typ == 'a')
 233         {
 234                 return processUsername ? processUsername : "NULL";
 235         }
 236
 237         if(client->typ == 'c' || client->typ == 'm')
 238         {
 239                 struct s_auth *acc = client->account;
 240                 if(acc)
 241                 {
 242                         if(acc->usr[0])
 243                         {
 244                                 return acc->usr;
 245                         }
 246                         else
 247                         {
 248                                 return "anonymous";
 249                         }
 250                 }
 251                 else
 252                 {
 253                         return "NULL";
 254                 }
 255         }
 256         else if(client->typ == 'r' || client->typ == 'p')
 257         {
 258                 struct s_reader *rdr = client->reader;
 259                 if(rdr)
 260                 {
 261                         return rdr->label;
 262                 }
 263         }
 264         return "NULL";
 265 }
 266
 267
 268 struct s_client *create_client(IN_ADDR_T ip)
 269 {
 270         struct s_client *cl;
 271         if(!cs_malloc(&cl, sizeof(struct s_client)))
 272         {
 273                 cs_log("max connections reached (out of memory) -> reject client %s",
 274                                 IP_ISSET(ip) ? cs_inet_ntoa(ip) : "with null address");
 275
 276                 return NULL;
 277         }
 278
 279         //client part
 280         IP_ASSIGN(cl->ip, ip);
 281         cl->account = first_client->account;
 282
 283         //master part
 284         SAFE_MUTEX_INIT(&cl->thread_lock, NULL);
 285         cl->login = cl->last = time(NULL);
 286         cl->tid = (uint32_t)rand();
 287
 288         //Now add new client to the list:
 289         struct s_client *last;
 290         cs_writelock(__func__, &clientlist_lock);
 291
 292         for(last = first_client; last && last->next; last = last->next)
 293                 { ; } //ends with cl on last client
 294
 295         if (last)
 296         {
 297                 last->next = cl;
 298         }
 299
 300         int32_t bucket = (uintptr_t)cl / 16 % CS_CLIENT_HASHBUCKETS;
 301         cl->nexthashed = first_client_hashed[bucket];
 302         first_client_hashed[bucket] = cl;
 303
 304         cs_writeunlock(__func__, &clientlist_lock);
 305
 306         return cl;
 307 }
 308
 309 /* Creates the master client of OSCam and inits some global variables/mutexes. */
 310 void init_first_client(void)
 311 {
 312         // get username OScam is running under
 313         struct passwd pwd;
 314         struct passwd *pwdbuf;
 315
 316 #ifdef __ANDROID__
 317         pwdbuf = getpwuid(getuid()); // This is safe
 318         if(pwdbuf)
 319         {
 320                 memcpy(&pwd, pwdbuf, sizeof(pwd));
 321                 processUsername = cs_strdup(pwd.pw_name);
 322         }
 323 #else
 324         char buf[256];
 325         if(getpwuid_r(getuid(), &pwd, buf, sizeof(buf), &pwdbuf) == 0)
 326         {
 327                 processUsername = cs_strdup(pwd.pw_name);
 328         }
 329 #endif
 330
 331         if(!cs_malloc(&first_client, sizeof(struct s_client)))
 332         {
 333                 fprintf(stderr, "Could not allocate memory for master client, exiting...");
 334                 exit(1);
 335         }
 336
 337         memset(first_client_hashed, 0, sizeof(first_client_hashed));
 338         int32_t bucket = (uintptr_t)first_client / 16 % CS_CLIENT_HASHBUCKETS;
 339         first_client_hashed[bucket] = first_client;
 340
 341         first_client->next = NULL; // terminate clients list with NULL
 342         first_client->login = time(NULL);
 343         first_client->typ = 's';
 344         first_client->thread = pthread_self();
 345         set_localhost_ip(&first_client->ip);
 346
 347         struct s_auth *null_account;
 348         if(!cs_malloc(&null_account, sizeof(struct s_auth)))
 349         {
 350                 fprintf(stderr, "Could not allocate memory for master account, exiting...");
 351                 exit(1);
 352         }
 353
 354         first_client->account = null_account;
 355         if(pthread_setspecific(getclient, first_client))
 356         {
 357                 fprintf(stderr, "Could not setspecific getclient in master process, exiting...");
 358                 exit(1);
 359         }
 360 }
 361
 362 int32_t cs_auth_client(struct s_client *client, struct s_auth *account, const char *e_txt)
 363 {
 364         int32_t rc = 0;
 365         uint8_t md5tmp[MD5_DIGEST_LENGTH];
 366         uint8_t i;
 367         uint8_t j;
 368         char buf[32];
 369         char *t_crypt = "encrypted";
 370         char *t_plain = "plain";
 371         char *t_grant = " granted";
 372         char *t_reject = " rejected";
 373         char *t_msg[] = { buf, "invalid access", "invalid ip", "unknown reason", "protocol not allowed" };
 374         struct s_module *module = get_module(client);
 375
 376         memset(&client->grp, 0xff, sizeof(uint64_t));
 377         //client->grp=0xffffffffffffff;
 378         if((intptr_t)account != 0 && (intptr_t)account != -1 && account->disabled)
 379         {
 380                 cs_add_violation(client, account->usr);
 381                 cs_log("%s %s-client %s%s (%s%sdisabled account)",
 382                                 client->crypted ? t_crypt : t_plain,
 383                                 module->desc,
 384                                 IP_ISSET(client->ip) ? cs_inet_ntoa(client->ip) : "",
 385                                 IP_ISSET(client->ip) ? t_reject : t_reject + 1,
 386                                 e_txt ? e_txt : "",
 387                                 e_txt ? " " : "");
 388                 return 1;
 389         }
 390
 391         // check whether client comes in over allowed protocol
 392         if((intptr_t)account != 0 && (intptr_t)account != -1 && (intptr_t)account->allowedprotocols &&
 393                         (((intptr_t)account->allowedprotocols & module->listenertype) != module->listenertype))
 394         {
 395                 cs_add_violation(client, account->usr);
 396                 cs_log("%s %s-client %s%s (%s%sprotocol not allowed)",
 397                                 client->crypted ? t_crypt : t_plain,
 398                                 module->desc,
 399                                 IP_ISSET(client->ip) ? cs_inet_ntoa(client->ip) : "",
 400                                 IP_ISSET(client->ip) ? t_reject : t_reject + 1,
 401                                 e_txt ? e_txt : "",
 402                                 e_txt ? " " : "");
 403                 return 1;
 404         }
 405
 406         client->account = first_client->account;
 407         switch((intptr_t)account)
 408         {
 409                 case 0: // reject access
 410                 {
 411                         rc = 1;
 412                         cs_add_violation(client, NULL);
 413                         cs_log("%s %s-client %s%s (%s)",
 414                                         client->crypted ? t_crypt : t_plain,
 415                                         module->desc,
 416                                         IP_ISSET(client->ip) ? cs_inet_ntoa(client->ip) : "",
 417                                         IP_ISSET(client->ip) ? t_reject : t_reject + 1,
 418                                         e_txt ? e_txt : t_msg[rc]);
 419                         break;
 420                 }
 421
 422                 default: // grant/check access
 423                 {
 424                         if(IP_ISSET(client->ip) && account->dyndns)
 425                         {
 426                                 if(!IP_EQUAL(client->ip, account->dynip))
 427                                         { cs_user_resolve(account); }
 428                                 if(!IP_EQUAL(client->ip, account->dynip))
 429                                 {
 430                                         cs_add_violation(client, account->usr);
 431                                         rc = 2;
 432                                 }
 433                         }
 434
 435                         client->monlvl = account->monlvl;
 436                         client->account = account;
 437
 438                         if(!rc)
 439                         {
 440                                 client->dup = 0;
 441                                 if(client->typ == 'c' || client->typ == 'm')
 442                                 {
 443                                         client->pcrc = crc32(0L, MD5((uint8_t *)(ESTR(account->pwd)), strlen(ESTR(account->pwd)), md5tmp), MD5_DIGEST_LENGTH);
 444                                 }
 445
 446                                 if(client->typ == 'c')
 447                                 {
 448                                         client->last_caid = NO_CAID_VALUE;
 449                                         client->last_provid = NO_PROVID_VALUE;
 450                                         client->last_srvid = NO_SRVID_VALUE;
 451                                         client->expirationdate = account->expirationdate;
 452                                         client->disabled = account->disabled;
 453                                         client->allowedtimeframe_set=account->allowedtimeframe_set;
 454
 455                                         for(i = 0; i < SIZE_SHORTDAY; i++)
 456                                         {
 457                                                 for(j = 0; j < 24; j++)
 458                                                 {
 459                                                         client->allowedtimeframe[i][j][0] = account->allowedtimeframe[i][j][0];
 460                                                         client->allowedtimeframe[i][j][1] = account->allowedtimeframe[i][j][1];
 461                                                 }
 462                                         }
 463
 464                                         if(account->firstlogin == 0)
 465                                         {
 466                                                 account->firstlogin = time((time_t *)0);
 467                                         }
 468
 469                                         client->failban = account->failban;
 470                                         client->c35_suppresscmd08 = account->c35_suppresscmd08;
 471                                         client->ncd_keepalive = account->ncd_keepalive;
 472                                         client->grp = account->grp;
 473                                         client->aureader_list = account->aureader_list;
 474                                         client->autoau = account->autoau;
 475                                         client->tosleep = (60 * account->tosleep);
 476                                         client->c35_sleepsend = account->c35_sleepsend;
 477                                         caidtab_clone(&account->ctab, &client->ctab);
 478
 479                                         if(account->uniq)
 480                                         {
 481                                                 cs_fake_client(client, account->usr, account->uniq, client->ip);
 482                                         }
 483
 484                                         client->cltab = account->cltab; // CLASS filter
 485                                         ftab_clone(&account->ftab, &client->ftab); // IDENT filter
 486                                         ftab_clone(&account->fchid, &client->fchid); // CHID filter
 487                                         client->sidtabs.ok = account->sidtabs.ok; // services
 488                                         client->sidtabs.no = account->sidtabs.no; // services
 489                                         tuntab_clone(&account->ttab, &client->ttab);
 490                                         ac_init_client(client, account);
 491                                 }
 492                         }
 493                 } /* fallthrough */
 494
 495                 case -1: // anonymous grant access
 496                 {
 497                         if(rc)
 498                         {
 499                                 t_grant = t_reject;
 500                         }
 501                         else
 502                         {
 503                                 if(client->typ == 'm')
 504                                 {
 505                                         snprintf(t_msg[0], sizeof(buf), "lvl=%d", client->monlvl);
 506                                 }
 507                                 else
 508                                 {
 509                                         int32_t rcount = ll_count(client->aureader_list);
 510                                         snprintf(buf, sizeof(buf), "au=");
 511
 512                                         if(!rcount)
 513                                         {
 514                                                 snprintf(buf + 3, sizeof(buf) - 3, "off");
 515                                         }
 516                                         else
 517                                         {
 518                                                 if(client->autoau)
 519                                                 {
 520                                                         snprintf(buf + 3, sizeof(buf) - 3, "auto (%d reader)", rcount);
 521                                                 }
 522                                                 else
 523                                                 {
 524                                                         snprintf(buf + 3, sizeof(buf) - 3, "on (%d reader)", rcount);
 525                                                 }
 526                                         }
 527                                 }
 528                         }
 529
 530                         cs_log("%s %s-client %s%s (%s, %s)",
 531                                         client->crypted ? t_crypt : t_plain,
 532                                         e_txt ? e_txt : module->desc,
 533                                         IP_ISSET(client->ip) ? cs_inet_ntoa(client->ip) : "",
 534                                         IP_ISSET(client->ip) ? t_grant : t_grant + 1,
 535                                         username(client), t_msg[rc]);
 536
 537                         break;
 538                 }
 539         }
 540         return rc;
 541 }
 542
 543 void cs_disconnect_client(struct s_client *client)
 544 {
 545         char buf[32] = { 0 };
 546
 547         if(IP_ISSET(client->ip))
 548         {
 549                 snprintf(buf, sizeof(buf), " from %s", cs_inet_ntoa(client->ip));
 550         }
 551
 552         cs_log("%s disconnected%s", username(client), buf);
 553
 554         if(client == cur_client())
 555         {
 556                 cs_exit(0);
 557         }
 558         else
 559         {
 560                 kill_thread(client);
 561         }
 562 }
 563
 564 void kill_all_clients(void)
 565 {
 566         struct s_client *cl;
 567         for(cl = first_client->next; cl; cl = cl->next)
 568         {
 569                 if(cl->typ == 'c' || cl->typ == 'm')
 570                 {
 571                         if(cl->account)
 572                         {
 573                                 cs_log("killing client %s", cl->account->usr);
 574                         }
 575                         kill_thread(cl);
 576                 }
 577         }
 578         NULLFREE(processUsername);
 579 }
 580
 581 void cs_reinit_clients(struct s_auth *new_accounts)
 582 {
 583         struct s_auth *account;
 584         uint8_t md5tmp[MD5_DIGEST_LENGTH];
 585         uint8_t i;
 586         uint8_t j;
 587
 588         struct s_client *cl;
 589         for(cl = first_client->next; cl; cl = cl->next)
 590         {
 591                 if((cl->typ == 'c' || cl->typ == 'm') && cl->account)
 592                 {
 593                         for(account = new_accounts; (account) ; account = account->next)
 594                         {
 595                                 if(!strcmp(cl->account->usr, account->usr))
 596                                 {
 597                                         break;
 598                                 }
 599                         }
 600
 601                         if(account && !account->disabled && cl->pcrc == crc32(0L, MD5((uint8_t *)ESTR(account->pwd), strlen(ESTR(account->pwd)), md5tmp), MD5_DIGEST_LENGTH))
 602                         {
 603                                 cl->account = account;
 604                                 if(cl->typ == 'c')
 605                                 {
 606                                         cl->grp = account->grp;
 607                                         cl->aureader_list = account->aureader_list;
 608                                         cl->autoau = account->autoau;
 609                                         cl->expirationdate = account->expirationdate;
 610                                         cl->allowedtimeframe_set = account->allowedtimeframe_set;
 611
 612                                         for(i = 0; i < SIZE_SHORTDAY; i++)
 613                                         {
 614                                                 for(j = 0; j < 24; j++)
 615                                                 {
 616                                                         cl->allowedtimeframe[i][j][0] = account->allowedtimeframe[i][j][0];
 617                                                         cl->allowedtimeframe[i][j][1] = account->allowedtimeframe[i][j][1];
 618                                                 }
 619                                         }
 620
 621                                         cl->ncd_keepalive = account->ncd_keepalive;
 622                                         cl->c35_suppresscmd08 = account->c35_suppresscmd08;
 623                                         cl->tosleep = (60 * account->tosleep);
 624                                         cl->c35_sleepsend = account->c35_sleepsend;
 625                                         cl->monlvl = account->monlvl;
 626                                         cl->disabled = account->disabled;
 627                                         cl->cltab = account->cltab; // Class
 628
 629                                         // newcamd module doesn't like ident reloading
 630                                         if(!cl->ncd_server)
 631                                         {
 632                                                 ftab_clone(&account->ftab, &cl->ftab); // IDENT filter
 633                                                 ftab_clone(&account->fchid, &cl->fchid); // CHID filter
 634                                         }
 635
 636                                         cl->sidtabs.ok = account->sidtabs.ok; // services
 637                                         cl->sidtabs.no = account->sidtabs.no; // services
 638                                         cl->failban = account->failban;
 639
 640                                         caidtab_clone(&account->ctab, &cl->ctab);
 641                                         tuntab_clone(&account->ttab, &cl->ttab);
 642
 643                                         webif_client_reset_lastresponsetime(cl);
 644
 645                                         if(account->uniq)
 646                                         {
 647                                                 cs_fake_client(cl, account->usr, (account->uniq == 1 || account->uniq == 2) ? account->uniq + 2 : account->uniq, cl->ip);
 648                                         }
 649
 650                                         ac_init_client(cl, account);
 651                                 }
 652                         }
 653                         else
 654                         {
 655                                 if(get_module(cl)->type & MOD_CONN_NET)
 656                                 {
 657                                         cs_log_dbg(D_TRACE, "client '%s', thread=%8lX not found in db (or password changed)", cl->account->usr, (unsigned long)cl->thread);
 658                                         kill_thread(cl);
 659                                 }
 660                                 else
 661                                 {
 662                                         cl->account = first_client->account;
 663                                 }
 664                         }
 665                 }
 666                 else
 667                 {
 668                         cl->account = NULL;
 669                 }
 670         }
 671 }
 672
 673 void client_check_status(struct s_client *cl)
 674 {
 675         if(!cl || cl->kill || !cl->init_done)
 676         {
 677                 return;
 678         }
 679
 680         switch(cl->typ)
 681         {
 682                 case 'm':
 683                 case 'c':
 684                         if((get_module(cl)->listenertype & LIS_CCCAM) && cl->last && (time(NULL) - cl->last) > (time_t)12)
 685                         {
 686                                 add_job(cl, ACTION_CLIENT_IDLE, NULL, 0);
 687                         }
 688
 689                         // Check umaxidle to avoid client is killed for inactivity, it has priority than cmaxidle
 690                         if(!cl->account->umaxidle)
 691                         {
 692                                 break;
 693                         }
 694
 695                         // Check user for exceeding umaxidle by checking cl->last, except Newcamd & Gbox
 696                         if(!(cl->ncd_keepalive && (get_module(cl)->listenertype & LIS_NEWCAMD)) && !(get_module(cl)->listenertype & LIS_GBOX) && cl->account->umaxidle>0 && cl->last && (time(NULL) - cl->last) > (time_t)cl->account->umaxidle)
 697                         {
 698                                 add_job(cl, ACTION_CLIENT_IDLE, NULL, 0);
 699                         }
 700
 701                         // Check clients for exceeding cmaxidle by checking cl->last, except Newcamd & Gbox
 702                         if(!(cl->ncd_keepalive && (get_module(cl)->listenertype & LIS_NEWCAMD)) && !(get_module(cl)->listenertype & LIS_GBOX) && cl->last && cl->account->umaxidle==-1 && cfg.cmaxidle && (time(NULL) - cl->last) > (time_t)cfg.cmaxidle)
 703                         {
 704                                 add_job(cl, ACTION_CLIENT_IDLE, NULL, 0);
 705                         }
 706
 707 #ifdef MODULE_GBOX
 708                         if((get_module(cl)->listenertype & LIS_GBOX) && cl->last && (time(NULL) - cl->last) > (time_t)cfg.gbox_reconnect)
 709                         {
 710                                 add_job(cl, ACTION_PEER_IDLE, NULL, 0);
 711                         }
 712 #endif
 713                         break;
 714
 715                 case 'r':
 716                         cardreader_checkhealth(cl, cl->reader);
 717                         break;
 718
 719                 case 'p':
 720                 {
 721                         struct s_reader *rdr = cl->reader;
 722                         if(!rdr || !rdr->enable || !rdr->active) // reader is disabled or restarting at this moment
 723                         {
 724                                 break;
 725                         }
 726
 727                         // execute reader do idle on proxy reader after a certain time (rdr->tcp_ito = inactivitytimeout)
 728                         // disconnect when no keepalive available
 729                         if((rdr->tcp_ito && is_cascading_reader(rdr)) || (rdr->typ == R_CCCAM) || (rdr->typ == R_CAMD35) || (rdr->typ == R_CS378X) || (rdr->typ == R_SCAM) || (rdr->tcp_ito != 0 && rdr->typ == R_RADEGAST))
 730                         {
 731                                 time_t now = time(NULL);
 732                                 int32_t time_diff = llabs(now - rdr->last_check);
 733
 734                                 if(time_diff > 60 || (time_diff > 12 && (rdr->typ == R_CCCAM || rdr->typ == R_CAMD35 || rdr->typ == R_CS378X)) || ((time_diff > (rdr->tcp_rto?rdr->tcp_rto:60)) && rdr->typ == R_RADEGAST))     //check 1x per minute or every 10s for cccam/camd35 or reconnecttimeout radegast if 0 defaut 60s
 735                                 {
 736                                         add_job(rdr->client, ACTION_READER_IDLE, NULL, 0);
 737                                         rdr->last_check = now;
 738                                 }
 739                         }
 740                         break;
 741                 }
 742         }
 743 }
 744
 745 void free_client(struct s_client *cl)
 746 {
 747         if(!cl)
 748         {
 749                 return;
 750         }
 751
 752         struct s_reader *rdr = cl->reader;
 753
 754         // Remove client from client list. kill_thread also removes this client, so here just if client exits itself...
 755         struct s_client *prev, *cl2;
 756         cs_writelock(__func__, &clientlist_lock);
 757
 758         if(!cl->kill_started)
 759         {
 760                 cl->kill_started = 1;
 761         }
 762         else
 763         {
 764                 cs_writeunlock(__func__, &clientlist_lock);
 765                 cs_log("[free_client] ERROR: free already started!");
 766                 return;
 767         }
 768         cl->kill = 1;
 769
 770         for(prev = first_client, cl2 = first_client->next; prev->next != NULL; prev = prev->next, cl2 = cl2->next)
 771         {
 772                 if(cl == cl2)
 773                 {
 774                         break;
 775                 }
 776         }
 777
 778         if(cl == cl2) // Remove client from list
 779         {
 780                 prev->next = cl2->next;
 781         }
 782
 783         int32_t bucket = (uintptr_t)cl / 16 % CS_CLIENT_HASHBUCKETS;
 784
 785         // Remove client from hashed list
 786         if(first_client_hashed[bucket] == cl)
 787         {
 788                 first_client_hashed[bucket] = cl->nexthashed;
 789         }
 790         else
 791         {
 792                 for(prev = first_client_hashed[bucket], cl2 = first_client_hashed[bucket]->nexthashed;
 793                         prev->nexthashed != NULL; prev = prev->nexthashed, cl2 = cl2->nexthashed)
 794                 {
 795                         if(cl == cl2)
 796                         {
 797                                 break;
 798                         }
 799                 }
 800
 801                 if(cl == cl2)
 802                 {
 803                         prev->nexthashed = cl2->nexthashed;
 804                 }
 805         }
 806
 807         cs_writeunlock(__func__, &clientlist_lock);
 808         cleanup_ecmtasks(cl);
 809
 810         // Clean reader. The cleaned structures should be only used by the reader thread, so we should be save without waiting
 811         if(rdr)
 812         {
 813                 ll_destroy_data(&rdr->emmstat);
 814                 remove_reader_from_active(rdr);
 815
 816                 cs_sleepms(1000); // just wait a bit that really really nobody is accessing client data
 817
 818                 if(rdr->ph.cleanup)
 819                 {
 820                         rdr->ph.cleanup(cl);
 821                 }
 822
 823                 if(cl->typ == 'r')
 824                 {
 825                         cardreader_close(rdr);
 826                 }
 827
 828                 if(cl->typ == 'p')
 829                 {
 830                         network_tcp_connection_close(rdr, "cleanup");
 831                 }
 832
 833                 cl->reader = NULL;
 834         }
 835
 836         // Clean client specific data
 837         if(cl->typ == 'c')
 838         {
 839                 cs_statistics(cl);
 840                 cl->last_caid = NO_CAID_VALUE;
 841                 cl->last_provid = NO_PROVID_VALUE;
 842                 cl->last_srvid = NO_SRVID_VALUE;
 843                 cs_statistics(cl);
 844
 845                 cs_sleepms(1000); // just wait a bit that really really nobody is accessing client data
 846         }
 847
 848         struct s_module *module = get_module(cl);
 849         if(module->cleanup)
 850         {
 851                 module->cleanup(cl);
 852         }
 853
 854         // Close network socket if not already cleaned by previous cleanup functions
 855         if(cl->pfd)
 856         {
 857                 close(cl->pfd);
 858         }
 859
 860         // Clean all remaining structures
 861         free_joblist(cl);
 862         NULLFREE(cl->work_mbuf);
 863
 864         if(cl->ecmtask)
 865         {
 866                 add_garbage(cl->ecmtask);
 867                 cl->ecmtask = NULL;
 868         }
 869
 870         ll_destroy_data(&cl->cascadeusers);
 871
 872         ftab_clear(&cl->ftab);
 873         ftab_clear(&cl->fchid);
 874         tuntab_clear(&cl->ttab);
 875         caidtab_clear(&cl->ctab);
 876
 877         NULLFREE(cl->cltab.aclass);
 878         NULLFREE(cl->cltab.bclass);
 879
 880         NULLFREE(cl->cw_rass);
 881         ll_destroy_data(&cl->ra_buf);
 882         NULLFREE(cl->aes_keys);
 883
 884 #ifdef MODULE_CCCAM
 885         add_garbage(cl->cc);
 886 #endif
 887 #ifdef MODULE_SERIAL
 888         add_garbage(cl->serialdata);
 889 #endif
 890         add_garbage(cl);
 891 }