code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb_ci/dvbci.cpp

   1 #include <fcntl.h>
   2 #include <sys/ioctl.h>
   3
   4 #include <lib/base/init.h>
   5 #include <lib/base/init_num.h>
   6 #include <lib/base/ebase.h>
   7
   8 #include <lib/base/eerror.h>
   9 #include <lib/base/nconfig.h> // access to python config
  10 #include <lib/dvb/db.h>
  11 #include <lib/dvb/pmt.h>
  12 #include <lib/dvb_ci/dvbci.h>
  13 #include <lib/dvb_ci/dvbci_session.h>
  14 #include <lib/dvb_ci/dvbci_camgr.h>
  15 #include <lib/dvb_ci/dvbci_ui.h>
  16 #include <lib/dvb_ci/dvbci_appmgr.h>
  17 #include <lib/dvb_ci/dvbci_mmi.h>
  18
  19 #include <dvbsi++/ca_program_map_section.h>
  20
  21 eDVBCIInterfaces *eDVBCIInterfaces::instance = 0;
  22
  23 eDVBCIInterfaces::eDVBCIInterfaces()
  24 {
  25         int num_ci = 0;
  26
  27         instance = this;
  28
  29         eDebug("scanning for common interfaces..");
  30
  31         while (1)
  32         {
  33                 struct stat s;
  34                 char filename[128];
  35                 sprintf(filename, "/dev/ci%d", num_ci);
  36
  37                 if (stat(filename, &s))
  38                         break;
  39
  40                 ePtr<eDVBCISlot> cislot;
  41
  42                 cislot = new eDVBCISlot(eApp, num_ci);
  43                 m_slots.push_back(cislot);
  44
  45                 ++num_ci;
  46         }
  47
  48         if (num_ci > 1) // // FIXME .. we force DM8000 when more than one CI Slot is avail
  49         {
  50                 setInputSource(0, TUNER_A);
  51                 setInputSource(1, TUNER_B);
  52                 setInputSource(2, TUNER_C);
  53                 setInputSource(3, TUNER_D);
  54         }
  55         else
  56         {
  57                 setInputSource(0, TUNER_A);
  58                 setInputSource(1, TUNER_B);
  59         }
  60
  61         eDebug("done, found %d common interface slots", num_ci);
  62 }
  63
  64 eDVBCIInterfaces::~eDVBCIInterfaces()
  65 {
  66 }
  67
  68 eDVBCIInterfaces *eDVBCIInterfaces::getInstance()
  69 {
  70         return instance;
  71 }
  72
  73 eDVBCISlot *eDVBCIInterfaces::getSlot(int slotid)
  74 {
  75         for(eSmartPtrList<eDVBCISlot>::iterator i(m_slots.begin()); i != m_slots.end(); ++i)
  76                 if(i->getSlotID() == slotid)
  77                         return i;
  78
  79         eDebug("FIXME: request for unknown slot");
  80
  81         return 0;
  82 }
  83
  84 int eDVBCIInterfaces::getSlotState(int slotid)
  85 {
  86         eDVBCISlot *slot;
  87
  88         if( (slot = getSlot(slotid)) == 0 )
  89                 return eDVBCISlot::stateInvalid;
  90
  91         return slot->getState();
  92 }
  93
  94 int eDVBCIInterfaces::reset(int slotid)
  95 {
  96         eDVBCISlot *slot;
  97
  98         if( (slot = getSlot(slotid)) == 0 )
  99                 return -1;
 100
 101         eDVBCISession::deleteSessions(slot);
 102         ciRemoved(slot);
 103
 104         return slot->reset();
 105 }
 106
 107 int eDVBCIInterfaces::initialize(int slotid)
 108 {
 109         eDVBCISlot *slot;
 110
 111         if( (slot = getSlot(slotid)) == 0 )
 112                 return -1;
 113
 114         slot->removeService();
 115
 116         return sendCAPMT(slotid);
 117 }
 118
 119 int eDVBCIInterfaces::sendCAPMT(int slotid)
 120 {
 121         eDVBCISlot *slot;
 122
 123         if( (slot = getSlot(slotid)) == 0 )
 124                 return -1;
 125
 126         PMTHandlerList::iterator it = m_pmt_handlers.begin();
 127         while (it != m_pmt_handlers.end())
 128         {
 129                 eDVBCISlot *tmp = it->cislot;
 130                 while (tmp && tmp != slot)
 131                         tmp = tmp->linked_next;
 132                 if (tmp)
 133                 {
 134                         tmp->sendCAPMT(it->pmthandler);  // send capmt
 135                         break;
 136                 }
 137                 ++it;
 138         }
 139
 140         return 0;
 141 }
 142
 143 int eDVBCIInterfaces::startMMI(int slotid)
 144 {
 145         eDVBCISlot *slot;
 146
 147         if( (slot = getSlot(slotid)) == 0 )
 148                 return -1;
 149
 150         return slot->startMMI();
 151 }
 152
 153 int eDVBCIInterfaces::stopMMI(int slotid)
 154 {
 155         eDVBCISlot *slot;
 156
 157         if( (slot = getSlot(slotid)) == 0 )
 158                 return -1;
 159
 160         return slot->stopMMI();
 161 }
 162
 163 int eDVBCIInterfaces::answerText(int slotid, int answer)
 164 {
 165         eDVBCISlot *slot;
 166
 167         if( (slot = getSlot(slotid)) == 0 )
 168                 return -1;
 169
 170         return slot->answerText(answer);
 171 }
 172
 173 int eDVBCIInterfaces::answerEnq(int slotid, char *value)
 174 {
 175         eDVBCISlot *slot;
 176
 177         if( (slot = getSlot(slotid)) == 0 )
 178                 return -1;
 179
 180         return slot->answerEnq(value);
 181 }
 182
 183 int eDVBCIInterfaces::cancelEnq(int slotid)
 184 {
 185         eDVBCISlot *slot;
 186
 187         if( (slot = getSlot(slotid)) == 0 )
 188                 return -1;
 189
 190         return slot->cancelEnq();
 191 }
 192
 193 void eDVBCIInterfaces::ciRemoved(eDVBCISlot *slot)
 194 {
 195         for (PMTHandlerList::iterator it(m_pmt_handlers.begin());
 196                 it != m_pmt_handlers.end(); ++it)
 197         {
 198                 eServiceReferenceDVB ref;
 199                 it->pmthandler->getServiceReference(ref);
 200                 slot->removeService(ref.getServiceID().get());
 201                 if (slot->use_count && !--slot->use_count)
 202                 {
 203                         if (slot->linked_next)
 204                                 slot->linked_next->setSource(slot->current_source);
 205                         else
 206                                 setInputSource(slot->current_tuner, slot->current_source);
 207
 208                         if (it->cislot == slot) // remove the base slot
 209                                 it->cislot = slot->linked_next;
 210                         else
 211                         {
 212                                 if (slot->linked_next)
 213                                 {
 214                                         eDVBCISlot *tmp = it->cislot;
 215                                         while(tmp->linked_next != slot)
 216                                                 tmp = tmp->linked_next;
 217                                         ASSERT(tmp);
 218                                         tmp->linked_next = slot->linked_next;
 219                                 }
 220                         }
 221                         slot->linked_next=0;
 222                 }
 223         }
 224 }
 225
 226 static bool canDescrambleMultipleServices(int slotid)
 227 {
 228         char configStr[255];
 229         snprintf(configStr, 255, "config.ci.%d.canDescrambleMultipleServices", slotid);
 230         std::string str;
 231         ePythonConfigQuery::getConfigValue(configStr, str);
 232         if ( str == "auto" )
 233         {
 234                 std::string appname = eDVBCI_UI::getInstance()->getAppName(slotid);
 235                 if (appname.find("AlphaCrypt") != std::string::npos)
 236                         return true;
 237         }
 238         else if (str == "yes")
 239                 return true;
 240         return false;
 241 }
 242
 243 void eDVBCIInterfaces::recheckPMTHandlers()
 244 {
 245 //      eDebug("recheckPMTHAndlers()");
 246         for (PMTHandlerList::iterator it(m_pmt_handlers.begin());
 247                 it != m_pmt_handlers.end(); ++it)
 248         {
 249                 CAID_LIST caids;
 250                 ePtr<eDVBService> service;
 251                 eServiceReferenceDVB ref;
 252                 eDVBServicePMTHandler *pmthandler = it->pmthandler;
 253                 eDVBServicePMTHandler::program p;
 254
 255                 pmthandler->getServiceReference(ref);
 256                 pmthandler->getService(service);
 257                 if (!pmthandler->getProgramInfo(p))
 258                 {
 259                         int cnt=0;
 260                         for (std::set<uint16_t>::reverse_iterator x(p.caids.rbegin()); x != p.caids.rend(); ++x, ++cnt)
 261                                 caids.push_front(*x);
 262                         if (service && cnt)
 263                                 service->m_ca = caids;
 264                 }
 265
 266                 if (service)
 267                         caids = service->m_ca;
 268
 269                 if (caids.empty())
 270                         continue; // unscrambled service
 271
 272                 for (eSmartPtrList<eDVBCISlot>::iterator ci_it(m_slots.begin()); ci_it != m_slots.end(); ++ci_it)
 273                 {
 274                         bool useThis=false;
 275                         eDVBCICAManagerSession *ca_manager = ci_it->getCAManager();
 276                         if (ca_manager)
 277                         {
 278                                 int mask=0;
 279                                 if (!ci_it->possible_services.empty())
 280                                 {
 281                                         mask |= 1;
 282                                         std::set<eServiceReference>::iterator it = ci_it->possible_services.find(ref);
 283                                         if (it != ci_it->possible_services.end())
 284                                         {
 285                                                 eDebug("'%s' is in service list of slot %d... so use it", ref.toString().c_str(), ci_it->getSlotID());
 286                                                 useThis = true;
 287                                         }
 288                                 }
 289                                 if (!useThis && !ci_it->possible_providers.empty())
 290                                 {
 291                                         bool parent=false;
 292                                         mask |= 2;
 293                                         if (!service) // subservice?
 294                                         {
 295                                                 eServiceReferenceDVB parent_ref = ref.getParentServiceReference();
 296                                                 eDVBDB::getInstance()->getService(parent_ref, service);
 297                                                 parent=true;
 298                                         }
 299                                         if (service)
 300                                         {
 301                                                 std::set<std::string>::iterator it = ci_it->possible_providers.find(service->m_provider_name);
 302                                                 if (it != ci_it->possible_providers.end())
 303                                                 {
 304                                                         eDebug("'%s' is in provider list of slot %d... so use it", service->m_provider_name.c_str(), ci_it->getSlotID());
 305                                                         useThis = true;
 306                                                 }
 307                                         }
 308                                 }
 309                                 if (!useThis && !ci_it->possible_caids.empty())
 310                                 {
 311                                         for (CAID_LIST::iterator ca(caids.begin()); ca != caids.end(); ++ca)
 312                                         {
 313                                                 std::set<uint16_t>::iterator it = ci_it->possible_caids.find(*ca);
 314                                                 if (it != ci_it->possible_caids.end())
 315                                                 {
 316                                                         eDebug("caid '%04x' is in caid list of slot %d... so use it", *ca, ci_it->getSlotID());
 317                                                         useThis=true;
 318                                                         break;
 319                                                 }
 320                                         }
 321                                 }
 322                                 if (!useThis && !mask)
 323                                 {
 324                                         const std::vector<uint16_t> &ci_caids = ca_manager->getCAIDs();
 325                                         for (CAID_LIST::iterator ca(caids.begin()); ca != caids.end(); ++ca)
 326                                         {
 327                                                 std::vector<uint16_t>::const_iterator z =
 328                                                         std::lower_bound(ci_caids.begin(), ci_caids.end(), *ca);
 329                                                 if ( z != ci_caids.end() && *z == *ca )
 330                                                 {
 331                                                         eDebug("The CI in Slot %d has said it can handle caid %04x... so use it", ci_it->getSlotID(), *z);
 332                                                         useThis=true;
 333                                                         break;
 334                                                 }
 335                                         }
 336                                 }
 337                         }
 338
 339                         if (useThis)
 340                         {
 341                                 if (ci_it->use_count)  // check if this CI can descramble more than one service
 342                                 {
 343                                         useThis = false;
 344                                         PMTHandlerList::iterator tmp = m_pmt_handlers.begin();
 345                                         while (tmp != m_pmt_handlers.end())
 346                                         {
 347                                                 if ( tmp->cislot == ci_it && it != tmp )
 348                                                 {
 349                                                         eServiceReferenceDVB ref2;
 350                                                         tmp->pmthandler->getServiceReference(ref2);
 351                                                         eDVBChannelID s1, s2;
 352                                                         if (ref != ref2)
 353                                                         {
 354                                                                 ref.getChannelID(s1);
 355                                                                 ref2.getChannelID(s2);
 356                                                         }
 357                                                         if (ref == ref2 || (s1 == s2 && canDescrambleMultipleServices(ci_it->getSlotID())))
 358                                                         {
 359                                                                 useThis = true;
 360                                                                 break;
 361                                                         }
 362                                                 }
 363                                                 ++tmp;
 364                                         }
 365                                 }
 366                                 if (useThis)
 367                                 {
 368                                         // check if this CI is already assigned to this pmthandler
 369                                         eDVBCISlot *tmp = it->cislot;
 370                                         while(tmp)
 371                                         {
 372                                                 if (tmp == ci_it)
 373                                                         break;
 374                                                 tmp=tmp->linked_next;
 375                                         }
 376
 377                                         if (tmp) // ignore already assigned cislots...
 378                                                 continue;
 379
 380                                         ++ci_it->use_count;
 381 //                                      eDebug("usecount now %d", ci_it->use_count);
 382
 383                                         data_source ci_source=CI_A;
 384                                         switch(ci_it->getSlotID())
 385                                         {
 386                                                 case 0: ci_source = CI_A; break;
 387                                                 case 1: ci_source = CI_B; break;
 388                                                 case 2: ci_source = CI_C; break;
 389                                                 case 3: ci_source = CI_D; break;
 390                                                 default:
 391                                                         eDebug("try to get source for CI %d!!\n", ci_it->getSlotID());
 392                                                         break;
 393                                         }
 394
 395                                         if (!it->cislot)
 396                                         {
 397                                                 int tunernum = -1;
 398                                                 eUsePtr<iDVBChannel> channel;
 399                                                 if (!pmthandler->getChannel(channel))
 400                                                 {
 401                                                         ePtr<iDVBFrontend> frontend;
 402                                                         if (!channel->getFrontend(frontend))
 403                                                         {
 404                                                                 eDVBFrontend *fe = (eDVBFrontend*) &(*frontend);
 405                                                                 tunernum = fe->getID();
 406                                                         }
 407                                                 }
 408                                                 ASSERT(tunernum != -1);
 409                                                 data_source tuner_source = TUNER_A;
 410                                                 switch (tunernum)
 411                                                 {
 412                                                         case 0: tuner_source = TUNER_A; break;
 413                                                         case 1: tuner_source = TUNER_B; break;
 414                                                         case 2: tuner_source = TUNER_C; break;
 415                                                         case 3: tuner_source = TUNER_D; break;
 416                                                         default:
 417                                                                 eDebug("try to get source for tuner %d!!\n", tunernum);
 418                                                                 break;
 419                                                 }
 420                                                 ci_it->current_tuner = tunernum;
 421                                                 setInputSource(tunernum, ci_source);
 422                                                 ci_it->setSource(tuner_source);
 423                                         }
 424                                         else
 425                                         {
 426                                                 ci_it->current_tuner = it->cislot->current_tuner;
 427                                                 ci_it->linked_next = it->cislot;
 428                                                 ci_it->setSource(ci_it->linked_next->current_source);
 429                                                 ci_it->linked_next->setSource(ci_source);
 430                                         }
 431                                         it->cislot = ci_it;
 432                                         gotPMT(pmthandler);
 433                                 }
 434                         }
 435                 }
 436         }
 437 }
 438
 439 void eDVBCIInterfaces::addPMTHandler(eDVBServicePMTHandler *pmthandler)
 440 {
 441         // check if this pmthandler is already registered
 442         PMTHandlerList::iterator it = m_pmt_handlers.begin();
 443         while (it != m_pmt_handlers.end())
 444         {
 445                 if ( *it++ == pmthandler )
 446                         return;
 447         }
 448
 449         eServiceReferenceDVB ref;
 450         pmthandler->getServiceReference(ref);
 451         eDebug("[eDVBCIInterfaces] addPMTHandler %s", ref.toString().c_str());
 452
 453         m_pmt_handlers.push_back(CIPmtHandler(pmthandler));
 454         recheckPMTHandlers();
 455 }
 456
 457 void eDVBCIInterfaces::removePMTHandler(eDVBServicePMTHandler *pmthandler)
 458 {
 459         PMTHandlerList::iterator it=std::find(m_pmt_handlers.begin(),m_pmt_handlers.end(),pmthandler);
 460         if (it != m_pmt_handlers.end())
 461         {
 462                 eDVBCISlot *slot = it->cislot;
 463                 eDVBServicePMTHandler *pmthandler = it->pmthandler;
 464                 m_pmt_handlers.erase(it);
 465
 466                 eServiceReferenceDVB service_to_remove;
 467                 pmthandler->getServiceReference(service_to_remove);
 468
 469                 bool sameServiceExist=false;
 470                 for (PMTHandlerList::iterator i=m_pmt_handlers.begin(); i != m_pmt_handlers.end(); ++i)
 471                 {
 472                         if (i->cislot)
 473                         {
 474                                 eServiceReferenceDVB ref;
 475                                 i->pmthandler->getServiceReference(ref);
 476                                 if ( ref == service_to_remove )
 477                                 {
 478                                         sameServiceExist=true;
 479                                         break;
 480                                 }
 481                         }
 482                 }
 483
 484                 while(slot)
 485                 {
 486                         if (!sameServiceExist)
 487                         {
 488                                 if (slot->getNumOfServices() > 1)
 489                                 {
 490                                         eDebug("[eDVBCIInterfaces] remove last pmt handler for service %s send empty capmt",
 491                                                 service_to_remove.toString().c_str());
 492                                                 std::vector<uint16_t> caids;
 493                                         caids.push_back(0xFFFF);
 494                                         slot->sendCAPMT(pmthandler, caids);  // send a capmt without caids to remove a running service
 495                                 }
 496                                 slot->removeService(service_to_remove.getServiceID().get());
 497                         }
 498
 499                         eDVBCISlot *next = slot->linked_next;
 500                         if (!--slot->use_count)
 501                         {
 502                                 if (slot->linked_next)
 503                                         slot->linked_next->setSource(slot->current_source);
 504                                 else
 505                                         setInputSource(slot->current_tuner, slot->current_source);
 506
 507                                 if (it->cislot == slot) // remove the base slot
 508                                         it->cislot = slot->linked_next;
 509                                 else
 510                                 {
 511                                         if (slot->linked_next)
 512                                         {
 513                                                 eDVBCISlot *tmp = it->cislot;
 514                                                 while(tmp->linked_next != slot)
 515                                                         tmp = tmp->linked_next;
 516                                                 ASSERT(tmp);
 517                                                 tmp->linked_next = slot->linked_next;
 518                                         }
 519                                 }
 520                                 slot->linked_next=0;
 521                         }
 522 //                      eDebug("use_count is now %d", slot->use_count);
 523                         slot = next;
 524                 }
 525         }
 526         // check if another service is waiting for the CI
 527         recheckPMTHandlers();
 528 }
 529
 530 void eDVBCIInterfaces::gotPMT(eDVBServicePMTHandler *pmthandler)
 531 {
 532         eDebug("[eDVBCIInterfaces] gotPMT");
 533         PMTHandlerList::iterator it=std::find(m_pmt_handlers.begin(), m_pmt_handlers.end(), pmthandler);
 534         if (it != m_pmt_handlers.end() && it->cislot)
 535         {
 536                 eDVBCISlot *tmp = it->cislot;
 537                 while(tmp)
 538                 {
 539                         tmp->sendCAPMT(pmthandler);
 540                         tmp = tmp->linked_next;
 541                 }
 542         }
 543 }
 544
 545 int eDVBCIInterfaces::getMMIState(int slotid)
 546 {
 547         eDVBCISlot *slot;
 548
 549         if( (slot = getSlot(slotid)) == 0 )
 550                 return -1;
 551
 552         return slot->getMMIState();
 553 }
 554
 555 int eDVBCIInterfaces::setInputSource(int tuner_no, data_source source)
 556 {
 557 //      eDebug("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 558 //      eDebug("eDVBCIInterfaces::setInputSource(%d %d)", tuner_no, (int)source);
 559         if (getNumOfSlots() > 1) // FIXME .. we force DM8000 when more than one CI Slot is avail
 560         {
 561                 char buf[64];
 562                 snprintf(buf, 64, "/proc/stb/tsmux/input%d", tuner_no);
 563
 564                 FILE *input=0;
 565                 if((input = fopen(buf, "wb")) == NULL) {
 566                         eDebug("cannot open %s", buf);
 567                         return 0;
 568                 }
 569
 570                 if (tuner_no > 3)
 571                         eDebug("setInputSource(%d, %d) failed... dm8000 just have four inputs", tuner_no, (int)source);
 572
 573                 switch(source)
 574                 {
 575                         case CI_A:
 576                                 fprintf(input, "CI0");
 577                                 break;
 578                         case CI_B:
 579                                 fprintf(input, "CI1");
 580                                 break;
 581                         case CI_C:
 582                                 fprintf(input, "CI2");
 583                         break;
 584                         case CI_D:
 585                                 fprintf(input, "CI3");
 586                                 break;
 587                         case TUNER_A:
 588                                 fprintf(input, "A");
 589                                 break;
 590                         case TUNER_B:
 591                                 fprintf(input, "B");
 592                                 break;
 593                         case TUNER_C:
 594                                 fprintf(input, "C");
 595                                 break;
 596                         case TUNER_D:
 597                                 fprintf(input, "D");
 598                                 break;
 599                         default:
 600                                 eDebug("setInputSource for input %d failed!!!\n", (int)source);
 601                                 break;
 602                 }
 603
 604                 fclose(input);
 605         }
 606         else  // DM7025
 607         {
 608                 char buf[64];
 609                 snprintf(buf, 64, "/proc/stb/tsmux/input%d", tuner_no);
 610
 611                 if (tuner_no > 1)
 612                         eDebug("setInputSource(%d, %d) failed... dm7025 just have two inputs", tuner_no, (int)source);
 613
 614                 FILE *input=0;
 615                 if((input = fopen(buf, "wb")) == NULL) {
 616                         eDebug("cannot open %s", buf);
 617                         return 0;
 618                 }
 619
 620                 switch(source)
 621                 {
 622                         case CI_A:
 623                                 fprintf(input, "CI");
 624                                 break;
 625                         case TUNER_A:
 626                                 fprintf(input, "A");
 627                                 break;
 628                         case TUNER_B:
 629                                 fprintf(input, "B");
 630                                 break;
 631                         default:
 632                                 eDebug("setInputSource for input %d failed!!!\n", (int)source);
 633                                 break;
 634                 }
 635
 636                 fclose(input);
 637         }
 638         eDebug("eDVBCIInterfaces->setInputSource(%d, %d)", tuner_no, (int)source);
 639         return 0;
 640 }
 641
 642 PyObject *eDVBCIInterfaces::getDescrambleRules(int slotid)
 643 {
 644         eDVBCISlot *slot = getSlot(slotid);
 645         if (!slot)
 646         {
 647                 char tmp[255];
 648                 snprintf(tmp, 255, "eDVBCIInterfaces::getDescrambleRules try to get rules for CI Slot %d... but just %d slots are available", slotid, m_slots.size());
 649                 PyErr_SetString(PyExc_StandardError, tmp);
 650                 return 0;
 651         }
 652         ePyObject tuple = PyTuple_New(3);
 653         int caids = slot->possible_caids.size();
 654         int services = slot->possible_services.size();
 655         int providers = slot->possible_providers.size();
 656         ePyObject caid_list = PyList_New(caids);
 657         ePyObject service_list = PyList_New(services);
 658         ePyObject provider_list = PyList_New(providers);
 659         std::set<uint16_t>::iterator caid_it(slot->possible_caids.begin());
 660         while(caids)
 661         {
 662                 --caids;
 663                 PyTuple_SET_ITEM(caid_list, caids, PyLong_FromLong(*caid_it));
 664                 ++caid_it;
 665         }
 666         std::set<eServiceReference>::iterator ref_it(slot->possible_services.begin());
 667         while(services)
 668         {
 669                 --services;
 670                 PyTuple_SET_ITEM(service_list, services, PyString_FromString(ref_it->toString().c_str()));
 671                 ++ref_it;
 672         }
 673         std::set<std::string>::iterator provider_it(slot->possible_providers.begin());
 674         while(providers)
 675         {
 676                 --providers;
 677                 PyTuple_SET_ITEM(provider_list, providers, PyString_FromString(provider_it->c_str()));
 678                 ++provider_it;
 679         }
 680         PyTuple_SET_ITEM(tuple, 0, service_list);
 681         PyTuple_SET_ITEM(tuple, 1, provider_list);
 682         PyTuple_SET_ITEM(tuple, 2, caid_list);
 683         return tuple;
 684 }
 685
 686 const char *PyObject_TypeStr(PyObject *o)
 687 {
 688         return o->ob_type && o->ob_type->tp_name ? o->ob_type->tp_name : "unknown object type";
 689 }
 690
 691 RESULT eDVBCIInterfaces::setDescrambleRules(int slotid, SWIG_PYOBJECT(ePyObject) obj )
 692 {
 693         eDVBCISlot *slot = getSlot(slotid);
 694         if (!slot)
 695         {
 696                 char tmp[255];
 697                 snprintf(tmp, 255, "eDVBCIInterfaces::setDescrambleRules try to set rules for CI Slot %d... but just %d slots are available", slotid, m_slots.size());
 698                 PyErr_SetString(PyExc_StandardError, tmp);
 699                 return -1;
 700         }
 701         if (!PyTuple_Check(obj))
 702         {
 703                 char tmp[255];
 704                 snprintf(tmp, 255, "2nd argument of setDescrambleRules is not a tuple.. it is a '%s'!!", PyObject_TypeStr(obj));
 705                 PyErr_SetString(PyExc_StandardError, tmp);
 706                 return -1;
 707         }
 708         if (PyTuple_Size(obj) != 3)
 709         {
 710                 const char *errstr = "eDVBCIInterfaces::setDescrambleRules not enough entrys in argument tuple!!\n"
 711                         "first argument should be a pythonlist with possible services\n"
 712                         "second argument should be a pythonlist with possible providers\n"
 713                         "third argument should be a pythonlist with possible caids";
 714                 PyErr_SetString(PyExc_StandardError, errstr);
 715                 return -1;
 716         }
 717         ePyObject service_list = PyTuple_GET_ITEM(obj, 0);
 718         ePyObject provider_list = PyTuple_GET_ITEM(obj, 1);
 719         ePyObject caid_list = PyTuple_GET_ITEM(obj, 2);
 720         if (!PyList_Check(service_list) || !PyList_Check(provider_list) || !PyList_Check(caid_list))
 721         {
 722                 char errstr[512];
 723                 snprintf(errstr, 512, "eDVBCIInterfaces::setDescrambleRules incorrect data types in argument tuple!!\n"
 724                         "first argument(%s) should be a pythonlist with possible services (reference strings)\n"
 725                         "second argument(%s) should be a pythonlist with possible providers (providername strings)\n"
 726                         "third argument(%s) should be a pythonlist with possible caids (ints)",
 727                         PyObject_TypeStr(service_list), PyObject_TypeStr(provider_list), PyObject_TypeStr(caid_list));
 728                 PyErr_SetString(PyExc_StandardError, errstr);
 729                 return -1;
 730         }
 731         slot->possible_caids.clear();
 732         slot->possible_services.clear();
 733         slot->possible_providers.clear();
 734         int size = PyList_Size(service_list);
 735         while(size)
 736         {
 737                 --size;
 738                 ePyObject refstr = PyList_GET_ITEM(service_list, size);
 739                 if (!PyString_Check(refstr))
 740                 {
 741                         char buf[255];
 742                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules entry in service list is not a string.. it is '%s'!!", PyObject_TypeStr(refstr));
 743                         PyErr_SetString(PyExc_StandardError, buf);
 744                         return -1;
 745                 }
 746                 char *tmpstr = PyString_AS_STRING(refstr);
 747                 eServiceReference ref(tmpstr);
 748                 if (ref.valid())
 749                         slot->possible_services.insert(ref);
 750                 else
 751                         eDebug("eDVBCIInterfaces::setDescrambleRules '%s' is not a valid service reference... ignore!!", tmpstr);
 752         };
 753         size = PyList_Size(provider_list);
 754         while(size)
 755         {
 756                 --size;
 757                 ePyObject str = PyList_GET_ITEM(provider_list, size);
 758                 if (!PyString_Check(str))
 759                 {
 760                         char buf[255];
 761                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules entry in provider list is not a string it is '%s'!!", PyObject_TypeStr(str));
 762                         PyErr_SetString(PyExc_StandardError, buf);
 763                         return -1;
 764                 }
 765                 char *tmpstr = PyString_AS_STRING(str);
 766                 if (strlen(tmpstr))
 767                         slot->possible_providers.insert(tmpstr);
 768                 else
 769                         eDebug("eDVBCIInterfaces::setDescrambleRules ignore invalid entry in provider name list!!");
 770         };
 771         size = PyList_Size(caid_list);
 772         while(size)
 773         {
 774                 --size;
 775                 ePyObject caid = PyList_GET_ITEM(caid_list, size);
 776                 if (!PyInt_Check(caid))
 777                 {
 778                         char buf[255];
 779                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules entry in caid list is not a long it is '%s'!!", PyObject_TypeStr(caid));
 780                         PyErr_SetString(PyExc_StandardError, buf);
 781                         return -1;
 782                 }
 783                 int tmpcaid = PyInt_AsLong(caid);
 784                 if (tmpcaid > 0 && tmpcaid < 0x10000)
 785                         slot->possible_caids.insert(tmpcaid);
 786                 else
 787                         eDebug("eDVBCIInterfaces::setDescrambleRules %d is not a valid caid... ignore!!", tmpcaid);
 788         };
 789         return 0;
 790 }
 791
 792 int eDVBCISlot::send(const unsigned char *data, size_t len)
 793 {
 794         int res=0;
 795         //int i;
 796         //eDebugNoNewLine("< ");
 797         //for(i=0;i<len;i++)
 798         //      eDebugNoNewLine("%02x ",data[i]);
 799         //eDebug("");
 800
 801         if (sendqueue.empty())
 802                 res = ::write(fd, data, len);
 803
 804         if (res < 0 || (unsigned int)res != len)
 805         {
 806                 unsigned char *d = new unsigned char[len];
 807                 memcpy(d, data, len);
 808                 sendqueue.push( queueData(d, len) );
 809                 notifier->setRequested(eSocketNotifier::Read | eSocketNotifier::Priority | eSocketNotifier::Write);
 810         }
 811
 812         return res;
 813 }
 814
 815 void eDVBCISlot::data(int what)
 816 {
 817         if(what == eSocketNotifier::Priority) {
 818                 if(state != stateRemoved) {
 819                         state = stateRemoved;
 820                         eDebug("ci removed");
 821                         while(sendqueue.size())
 822                         {
 823                                 delete [] sendqueue.top().data;
 824                                 sendqueue.pop();
 825                         }
 826                         eDVBCIInterfaces::getInstance()->ciRemoved(this);
 827                         eDVBCISession::deleteSessions(this);
 828                         notifier->setRequested(eSocketNotifier::Read);
 829                         eDVBCI_UI::getInstance()->setState(getSlotID(),0);
 830                 }
 831                 return;
 832         }
 833
 834         if (state == stateInvalid)
 835                 reset();
 836
 837         if(state != stateInserted) {
 838                 eDebug("ci inserted");
 839                 state = stateInserted;
 840                 eDVBCI_UI::getInstance()->setState(getSlotID(),1);
 841                 notifier->setRequested(eSocketNotifier::Read|eSocketNotifier::Priority);
 842                 /* enable PRI to detect removal or errors */
 843         }
 844
 845         if (what & eSocketNotifier::Read) {
 846                 __u8 data[4096];
 847                 int r;
 848                 r = ::read(fd, data, 4096);
 849                 if(r > 0) {
 850 //                      int i;
 851 //                      eDebugNoNewLine("> ");
 852 //                      for(i=0;i<r;i++)
 853 //                              eDebugNoNewLine("%02x ",data[i]);
 854 //                      eDebug("");
 855                         eDVBCISession::receiveData(this, data, r);
 856                         eDVBCISession::pollAll();
 857                         return;
 858                 }
 859         }
 860         else if (what & eSocketNotifier::Write) {
 861                 if (!sendqueue.empty()) {
 862                         const queueData &qe = sendqueue.top();
 863                         int res = ::write(fd, qe.data, qe.len);
 864                         if (res >= 0 && (unsigned int)res == qe.len)
 865                         {
 866                                 delete [] qe.data;
 867                                 sendqueue.pop();
 868                         }
 869                 }
 870                 else
 871                         notifier->setRequested(eSocketNotifier::Read|eSocketNotifier::Priority);
 872         }
 873 }
 874
 875 DEFINE_REF(eDVBCISlot);
 876
 877 eDVBCISlot::eDVBCISlot(eMainloop *context, int nr)
 878 {
 879         char filename[128];
 880
 881         application_manager = 0;
 882         mmi_session = 0;
 883         ca_manager = 0;
 884         use_count = 0;
 885         linked_next = 0;
 886
 887         slotid = nr;
 888
 889         sprintf(filename, "/dev/ci%d", nr);
 890
 891         fd = ::open(filename, O_RDWR | O_NONBLOCK);
 892
 893         eDebug("eDVBCISlot has fd %d", fd);
 894         state = stateInvalid;
 895
 896         if (fd >= 0)
 897         {
 898                 notifier = new eSocketNotifier(context, fd, eSocketNotifier::Read | eSocketNotifier::Priority | eSocketNotifier::Write);
 899                 CONNECT(notifier->activated, eDVBCISlot::data);
 900         } else
 901         {
 902                 perror(filename);
 903         }
 904         setSource(TUNER_A);
 905 }
 906
 907 eDVBCISlot::~eDVBCISlot()
 908 {
 909 }
 910
 911 void eDVBCISlot::setAppManager( eDVBCIApplicationManagerSession *session )
 912 {
 913         application_manager=session;
 914 }
 915
 916 void eDVBCISlot::setMMIManager( eDVBCIMMISession *session )
 917 {
 918         mmi_session = session;
 919 }
 920
 921 void eDVBCISlot::setCAManager( eDVBCICAManagerSession *session )
 922 {
 923         ca_manager = session;
 924 }
 925
 926 int eDVBCISlot::getSlotID()
 927 {
 928         return slotid;
 929 }
 930
 931 int eDVBCISlot::reset()
 932 {
 933         eDebug("edvbcislot: reset requested");
 934
 935         if (state == stateInvalid)
 936         {
 937                 unsigned char buf[256];
 938                 eDebug("ci flush");
 939                 while(::read(fd, buf, 256)>0);
 940                 state = stateResetted;
 941         }
 942
 943         while(sendqueue.size())
 944         {
 945                 delete [] sendqueue.top().data;
 946                 sendqueue.pop();
 947         }
 948
 949         ioctl(fd, 0);
 950
 951         return 0;
 952 }
 953
 954 int eDVBCISlot::startMMI()
 955 {
 956         eDebug("edvbcislot: startMMI()");
 957
 958         if(application_manager)
 959                 application_manager->startMMI();
 960
 961         return 0;
 962 }
 963
 964 int eDVBCISlot::stopMMI()
 965 {
 966         eDebug("edvbcislot: stopMMI()");
 967
 968         if(mmi_session)
 969                 mmi_session->stopMMI();
 970
 971         return 0;
 972 }
 973
 974 int eDVBCISlot::answerText(int answer)
 975 {
 976         eDebug("edvbcislot: answerText(%d)", answer);
 977
 978         if(mmi_session)
 979                 mmi_session->answerText(answer);
 980
 981         return 0;
 982 }
 983
 984 int eDVBCISlot::getMMIState()
 985 {
 986         if(mmi_session)
 987                 return 1;
 988
 989         return 0;
 990 }
 991
 992 int eDVBCISlot::answerEnq(char *value)
 993 {
 994         eDebug("edvbcislot: answerENQ(%s)", value);
 995
 996         if(mmi_session)
 997                 mmi_session->answerEnq(value);
 998
 999         return 0;
1000 }
1001
1002 int eDVBCISlot::cancelEnq()
1003 {
1004         eDebug("edvbcislot: cancelENQ");
1005
1006         if(mmi_session)
1007                 mmi_session->cancelEnq();
1008
1009         return 0;
1010 }
1011
1012 int eDVBCISlot::sendCAPMT(eDVBServicePMTHandler *pmthandler, const std::vector<uint16_t> &ids)
1013 {
1014         if (!ca_manager)
1015         {
1016                 eDebug("no ca_manager (no CI plugged?)");
1017                 return -1;
1018         }
1019         const std::vector<uint16_t> &caids = ids.empty() ? ca_manager->getCAIDs() : ids;
1020         ePtr<eTable<ProgramMapSection> > ptr;
1021         if (pmthandler->getPMT(ptr))
1022                 return -1;
1023         else
1024         {
1025                 eDVBTableSpec table_spec;
1026                 ptr->getSpec(table_spec);
1027                 int pmt_version = table_spec.version & 0x1F; // just 5 bits
1028
1029                 eServiceReferenceDVB ref;
1030                 pmthandler->getServiceReference(ref);
1031                 uint16_t program_number = ref.getServiceID().get();
1032                 std::map<uint16_t, uint8_t>::iterator it =
1033                         running_services.find(program_number);
1034
1035                 if ( it != running_services.end() &&
1036                         (pmt_version == it->second) &&
1037                         !(caids.size() == 1 && caids[0] == 0xFFFF) )
1038                 {
1039                         eDebug("[eDVBCISlot] dont send self capmt version twice");
1040                         return -1;
1041                 }
1042
1043                 std::vector<ProgramMapSection*>::const_iterator i=ptr->getSections().begin();
1044                 if ( i == ptr->getSections().end() )
1045                         return -1;
1046                 else
1047                 {
1048                         unsigned char raw_data[2048];
1049
1050 //                      eDebug("send %s capmt for service %04x to slot %d",
1051 //                              it != running_services.end() ? "UPDATE" : running_services.empty() ? "ONLY" : "ADD",
1052 //                              program_number, slotid);
1053
1054                         CaProgramMapSection capmt(*i++,
1055                                 it != running_services.end() ? 0x05 /*update*/ : running_services.empty() ? 0x03 /*only*/ : 0x04 /*add*/, 0x01, caids );
1056                         while( i != ptr->getSections().end() )
1057                         {
1058                 //                      eDebug("append");
1059                                 capmt.append(*i++);
1060                         }
1061                         capmt.writeToBuffer(raw_data);
1062 #if 1
1063 // begin calc capmt length
1064                         int wp=0;
1065                         int hlen;
1066                         if ( raw_data[3] & 0x80 )
1067                         {
1068                                 int i=0;
1069                                 int lenbytes = raw_data[3] & ~0x80;
1070                                 while(i < lenbytes)
1071                                         wp = (wp << 8) | raw_data[4 + i++];
1072                                 wp+=4;
1073                                 wp+=lenbytes;
1074                                 hlen = 4 + lenbytes;
1075                         }
1076                         else
1077                         {
1078                                 wp = raw_data[3];
1079                                 wp+=4;
1080                                 hlen = 4;
1081                         }
1082 // end calc capmt length
1083 //                      eDebug("ca_manager %p dump capmt:", ca_manager);
1084 //                      for(int i=0;i<wp;i++)
1085 //                              eDebugNoNewLine("%02x ", raw_data[i]);
1086 //                      eDebug("");
1087 #endif
1088                         if (caids.size() == 1 && caids[0] == 0xFFFF)
1089                         {
1090 //                              eDebugNoNewLine("SEND EMPTY CAPMT.. old version is %02x", raw_data[hlen+3]);
1091                                 raw_data[hlen+3] &= ~0x3E;
1092                                 raw_data[hlen+3] |= ((pmt_version+1) & 0x1F) << 1;
1093 //                              eDebug(" new version is %02x", raw_data[hlen+3]);
1094                         }
1095
1096                         //dont need tag and lenfield
1097                         ca_manager->sendCAPMT(raw_data + hlen, wp - hlen);
1098                         running_services[program_number] = pmt_version;
1099                 }
1100         }
1101         return 0;
1102 }
1103
1104 void eDVBCISlot::removeService(uint16_t program_number)
1105 {
1106         if (program_number == 0xFFFF)
1107                 running_services.clear();  // remove all
1108         else
1109                 running_services.erase(program_number);  // remove single service
1110 }
1111
1112 int eDVBCISlot::setSource(data_source source)
1113 {
1114         current_source = source;
1115         if (eDVBCIInterfaces::getInstance()->getNumOfSlots() > 1) // FIXME .. we force DM8000 when more than one CI Slot is avail
1116         {
1117                 char buf[64];
1118                 snprintf(buf, 64, "/proc/stb/tsmux/ci%d_input", slotid);
1119                 FILE *ci = fopen(buf, "wb");
1120                 switch(source)
1121                 {
1122                         case CI_A:
1123                                 fprintf(ci, "CI0");
1124                                 break;
1125                         case CI_B:
1126                                 fprintf(ci, "CI1");
1127                                 break;
1128                         case CI_C:
1129                                 fprintf(ci, "CI2");
1130                                 break;
1131                         case CI_D:
1132                                 fprintf(ci, "CI3");
1133                                 break;
1134                         case TUNER_A:
1135                                 fprintf(ci, "A");
1136                                 break;
1137                         case TUNER_B:
1138                                 fprintf(ci, "B");
1139                                 break;
1140                         case TUNER_C:
1141                                 fprintf(ci, "C");
1142                                 break;
1143                                 case TUNER_D:
1144                                 fprintf(ci, "D");
1145                                 break;
1146                         default:
1147                                 eDebug("setSource %d failed!!!\n", (int)source);
1148                                 break;
1149                 }
1150                 fclose(ci);
1151         }
1152         else // DM7025
1153         {
1154 //              eDebug("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
1155 //              eDebug("eDVBCISlot::enableTS(%d %d)", enable, (int)source);
1156                 FILE *ci = fopen("/proc/stb/tsmux/input2", "wb");
1157                 if(ci == NULL) {
1158                         eDebug("cannot open /proc/stb/tsmux/input2");
1159                         return 0;
1160                 }
1161                 if (source != TUNER_A && source != TUNER_B)
1162                         eDebug("setSource %d failed!!!\n", (int)source);
1163                 else
1164                         fprintf(ci, "%s", source==TUNER_A ? "A" : "B");  // configure CI data source (TunerA, TunerB)
1165                 fclose(ci);
1166         }
1167         eDebug("eDVBCISlot->setSource(%d)", (int)source);
1168         return 0;
1169 }
1170
1171 eAutoInitP0<eDVBCIInterfaces> init_eDVBCIInterfaces(eAutoInitNumbers::dvb, "CI Slots");