Ticket #844: hlci.patch

File hlci.patch, 10.9 KB (added by hsjo@…, 14 years ago)

High level CI patch

  • libs/libmythtv/dvbdev/dvbci.cpp

     
    14341434  capmt[infoLengthPos + 1] = l & 0xFF;
    14351435}
    14361436
    1437 // -- cCiHandler -------------------------------------------------------------
     1437// -- cLlCiHandler -------------------------------------------------------------
    14381438
    1439 cCiHandler::cCiHandler(int Fd, int NumSlots)
     1439cLlCiHandler::cLlCiHandler(int Fd, int NumSlots)
    14401440{
    14411441  numSlots = NumSlots;
    14421442  newCaSupport = false;
     
    14491449  needCaPmt = false;
    14501450}
    14511451
    1452 cCiHandler::~cCiHandler()
     1452cLlCiHandler::~cLlCiHandler()
    14531453{
    14541454  cMutexLock MutexLock(&mutex);
    14551455  for (int i = 0; i < MAX_CI_SESSION; i++)
     
    14711471            if (NumSlots > 0)
    14721472            {
    14731473                if (Caps.slot_type & CA_CI_LINK)
    1474                     return new cCiHandler(fd_ca, NumSlots);
     1474                    return new cLlCiHandler(fd_ca, NumSlots);
     1475                else if (Caps.slot_type & CA_CI)
     1476                    return new cHlCiHandler(fd_ca, NumSlots);
    14751477                else
    1476                     isyslog("CAM doesn't support link layer interface,"
     1478                    isyslog("CAM doesn't support either high or low level CI,"
    14771479                            " Caps.slot_type=%i", Caps.slot_type);
    14781480            }
    14791481            else
     
    14861488    return NULL;
    14871489}
    14881490
    1489 int cCiHandler::ResourceIdToInt(const uint8_t *Data)
     1491int cLlCiHandler::ResourceIdToInt(const uint8_t *Data)
    14901492{
    14911493  return (ntohl(*(int *)Data));
    14921494}
    14931495
    1494 bool cCiHandler::Send(uint8_t Tag, int SessionId, int ResourceId, int Status)
     1496bool cLlCiHandler::Send(uint8_t Tag, int SessionId, int ResourceId, int Status)
    14951497{
    14961498  uint8_t buffer[16];
    14971499  uint8_t *p = buffer;
     
    15091511  return tc && tc->SendData(p - buffer, buffer) == OK;
    15101512}
    15111513
    1512 cCiSession *cCiHandler::GetSessionBySessionId(int SessionId)
     1514cCiSession *cLlCiHandler::GetSessionBySessionId(int SessionId)
    15131515{
    15141516  for (int i = 0; i < MAX_CI_SESSION; i++) {
    15151517      if (sessions[i] && sessions[i]->SessionId() == SessionId)
     
    15181520  return NULL;
    15191521}
    15201522
    1521 cCiSession *cCiHandler::GetSessionByResourceId(int ResourceId, int Slot)
     1523cCiSession *cLlCiHandler::GetSessionByResourceId(int ResourceId, int Slot)
    15221524{
    15231525  for (int i = 0; i < MAX_CI_SESSION; i++) {
    15241526      if (sessions[i] && sessions[i]->Tc()->Slot() == Slot && sessions[i]->ResourceId() == ResourceId)
     
    15271529  return NULL;
    15281530}
    15291531
    1530 cCiSession *cCiHandler::CreateSession(int ResourceId)
     1532cCiSession *cLlCiHandler::CreateSession(int ResourceId)
    15311533{
    15321534  if (!GetSessionByResourceId(ResourceId, tc->Slot())) {
    15331535     for (int i = 0; i < MAX_CI_SESSION; i++) {
     
    15471549  return NULL;
    15481550}
    15491551
    1550 bool cCiHandler::OpenSession(int Length, const uint8_t *Data)
     1552bool cLlCiHandler::OpenSession(int Length, const uint8_t *Data)
    15511553{
    15521554  if (Length == 6 && *(Data + 1) == 0x04) {
    15531555     int ResourceId = ResourceIdToInt(Data + 2);
     
    15731575  return false;
    15741576}
    15751577
    1576 bool cCiHandler::CloseSession(int SessionId)
     1578bool cLlCiHandler::CloseSession(int SessionId)
    15771579{
    15781580  dbgprotocol("CloseSession %08X\n", SessionId);
    15791581  cCiSession *Session = GetSessionBySessionId(SessionId);
     
    15901592  return false;
    15911593}
    15921594
    1593 int cCiHandler::CloseAllSessions(int Slot)
     1595int cLlCiHandler::CloseAllSessions(int Slot)
    15941596{
    15951597  int result = 0;
    15961598  for (int i = 0; i < MAX_CI_SESSION; i++) {
     
    16021604  return result;
    16031605}
    16041606
    1605 bool cCiHandler::Process(void)
     1607bool cLlCiHandler::Process(void)
    16061608{
    16071609    bool result = true;
    16081610    cMutexLock MutexLock(&mutex);
     
    16881690    return result;
    16891691}
    16901692
    1691 bool cCiHandler::EnterMenu(int Slot)
     1693bool cLlCiHandler::EnterMenu(int Slot)
    16921694{
    16931695  cMutexLock MutexLock(&mutex);
    16941696  cCiApplicationInformation *api = (cCiApplicationInformation *)GetSessionByResourceId(RI_APPLICATION_INFORMATION, Slot);
    16951697  return api ? api->EnterMenu() : false;
    16961698}
    16971699
    1698 cCiMenu *cCiHandler::GetMenu(void)
     1700cCiMenu *cLlCiHandler::GetMenu(void)
    16991701{
    17001702  cMutexLock MutexLock(&mutex);
    17011703  for (int Slot = 0; Slot < numSlots; Slot++) {
     
    17061708  return NULL;
    17071709}
    17081710
    1709 cCiEnquiry *cCiHandler::GetEnquiry(void)
     1711cCiEnquiry *cLlCiHandler::GetEnquiry(void)
    17101712{
    17111713  cMutexLock MutexLock(&mutex);
    17121714  for (int Slot = 0; Slot < numSlots; Slot++) {
     
    17171719  return NULL;
    17181720}
    17191721
    1720 const unsigned short *cCiHandler::GetCaSystemIds(int Slot)
     1722const unsigned short *cLlCiHandler::GetCaSystemIds(int Slot)
    17211723 {
    17221724  cMutexLock MutexLock(&mutex);
    17231725  cCiConditionalAccessSupport *cas = (cCiConditionalAccessSupport *)GetSessionByResourceId(RI_CONDITIONAL_ACCESS_SUPPORT, Slot);
    17241726  return cas ? cas->GetCaSystemIds() : NULL;
    17251727}
    17261728
    1727 bool cCiHandler::SetCaPmt(cCiCaPmt &CaPmt, int Slot)
     1729bool cLlCiHandler::SetCaPmt(cCiCaPmt &CaPmt, int Slot)
    17281730{
    17291731  cMutexLock MutexLock(&mutex);
    17301732  cCiConditionalAccessSupport *cas = (cCiConditionalAccessSupport *)GetSessionByResourceId(RI_CONDITIONAL_ACCESS_SUPPORT, Slot);
    17311733  return cas && cas->SendPMT(CaPmt);
    17321734}
    17331735
    1734 bool cCiHandler::Reset(int Slot)
     1736bool cLlCiHandler::Reset(int Slot)
    17351737{
    17361738  cMutexLock MutexLock(&mutex);
    17371739  CloseAllSessions(Slot);
    17381740  return tpl->ResetSlot(Slot);
    17391741}
    17401742
    1741 bool cCiHandler::connected() const
     1743bool cLlCiHandler::connected() const
    17421744{
    17431745  return _connected;
    17441746}
    17451747
     1748// -- cHlCiHandler -------------------------------------------------------------
     1749
     1750cHlCiHandler::cHlCiHandler(int Fd, int NumSlots)
     1751{
     1752    numSlots = NumSlots;
     1753    numCaSystemIds = 0;
     1754    caSystemIds[0] = 0;
     1755    fdCa = Fd;
     1756    state = 0;
     1757    fprintf(stderr, "New High level CI handler\n");
     1758}
     1759
     1760cHlCiHandler::~cHlCiHandler()
     1761{
     1762    cMutexLock MutexLock(&mutex);
     1763    close(fdCa);
     1764}
     1765
     1766int cHlCiHandler::CommHL(unsigned tag, unsigned function, struct ca_msg *msg)
     1767{
     1768    if (tag) {
     1769        msg->msg[2] = tag & 0xff;
     1770        msg->msg[1] = (tag & 0xff00) >> 8;
     1771        msg->msg[0] = (tag & 0xff0000) >> 16;
     1772        fprintf(stderr, "Sending message=[%02x %02x %02x ]\n",
     1773                       msg->msg[0], msg->msg[1], msg->msg[2]);
     1774    }
     1775   
     1776    return ioctl(fdCa, function, msg);
     1777}
     1778
     1779int cHlCiHandler::GetData(unsigned tag, struct ca_msg *msg)
     1780{
     1781    return CommHL(tag, CA_GET_MSG, msg);
     1782}
     1783
     1784int cHlCiHandler::SendData(unsigned tag, struct ca_msg *msg)
     1785{
     1786    return CommHL(tag, CA_SEND_MSG, msg);
     1787}
     1788
     1789bool cHlCiHandler::Process(void)
     1790{
     1791    cMutexLock MutexLock(&mutex);
     1792
     1793    struct ca_msg msg;
     1794    switch(state) {
     1795    case 0:
     1796        // Get CA_system_ids
     1797        /*      Enquire         */
     1798        if ((SendData(AOT_CA_INFO_ENQ, &msg)) < 0) {
     1799            fprintf(stderr, "HLCI communication failed\n");
     1800        } else {
     1801            dbgprotocol("==> Ca Info Enquiry");
     1802            /*  Receive         */
     1803            if ((GetData(AOT_CA_INFO, &msg)) < 0) {
     1804                fprintf(stderr, "HLCI communication failed\n");
     1805            } else {
     1806                printf("Debug: ");
     1807                for(int i = 0; i < 20; i++) {
     1808                    printf("%d ", msg.msg[i]);
     1809                }
     1810                printf("\n");
     1811                dbgprotocol("<== Ca Info");
     1812                int l = msg.msg[3];
     1813                const uint8_t *d = &msg.msg[4];
     1814                while (l > 1) {
     1815                    unsigned short id = ((unsigned short)(*d) << 8) | *(d + 1);
     1816                    dbgprotocol(" %04X", id);
     1817                    d += 2;
     1818                    l -= 2;
     1819                    if (numCaSystemIds < MAXCASYSTEMIDS) {
     1820                        caSystemIds[numCaSystemIds++] = id;
     1821                        caSystemIds[numCaSystemIds] = 0;
     1822                    }
     1823                    else
     1824                        esyslog("ERROR: too many CA system IDs!");
     1825                }
     1826                dbgprotocol("\n");
     1827            }
     1828            state = 1;
     1829            break;
     1830        }
     1831    }
     1832
     1833    bool result = true;
     1834
     1835    return result;
     1836}
     1837
     1838bool cHlCiHandler::EnterMenu(int)
     1839{
     1840    return false;
     1841}
     1842
     1843cCiMenu *cHlCiHandler::GetMenu(void)
     1844{
     1845    return NULL;
     1846}
     1847
     1848cCiEnquiry *cHlCiHandler::GetEnquiry(void)
     1849{
     1850    return NULL;
     1851}
     1852
     1853const unsigned short *cHlCiHandler::GetCaSystemIds(int)
     1854{
     1855    return caSystemIds;
     1856}
     1857
     1858bool cHlCiHandler::SetCaPmt(cCiCaPmt &CaPmt, int)
     1859{
     1860    cMutexLock MutexLock(&mutex);
     1861    struct ca_msg msg;
     1862
     1863    fprintf(stderr, "Setting CA PMT.\n");
     1864    state = 2;
     1865
     1866    msg.msg[3] = CaPmt.length;
     1867    memcpy(&msg.msg[4], CaPmt.capmt, CaPmt.length);
     1868
     1869    if ((SendData(AOT_CA_PMT, &msg)) < 0) {
     1870        fprintf(stderr, "HLCI communication failed\n");
     1871        return false;
     1872    }
     1873   
     1874    return true;
     1875}
     1876
     1877bool cHlCiHandler::Reset(int)
     1878{
     1879    if ((ioctl(fdCa, CA_RESET)) < 0) {
     1880        fprintf(stderr, "ioctl CA_RESET failed.\n");
     1881        return false;
     1882    }
     1883    return true;
     1884}
     1885
     1886bool cHlCiHandler::NeedCaPmt(void)
     1887{
     1888    if(state == 1)
     1889        return true;
     1890
     1891    return false;
     1892}
  • libs/libmythtv/dvbdev/dvbci.h

     
    122122
    123123class cCiCaPmt {
    124124  friend class cCiConditionalAccessSupport;
     125  friend class cHlCiHandler;
    125126private:
    126127  int length;
    127128  int infoLengthPos;
     
    139140class cCiTransportConnection;
    140141
    141142class cCiHandler {
     143public:
     144  static cCiHandler *CreateCiHandler(const char *FileName);
     145  virtual int NumSlots(void) = 0;
     146  virtual bool Process(void) = 0;
     147  virtual bool HasUserIO(void) = 0;
     148  virtual bool NeedCaPmt(void) = 0;
     149  virtual bool EnterMenu(int Slot) = 0;
     150  virtual cCiMenu *GetMenu(void) = 0;
     151  virtual cCiEnquiry *GetEnquiry(void) = 0;
     152  virtual const unsigned short *GetCaSystemIds(int Slot) = 0;
     153  virtual bool SetCaPmt(cCiCaPmt &CaPmt, int Slot) = 0;
     154  };
     155
     156class cLlCiHandler : public cCiHandler {
     157  friend class cCiHandler;
    142158private:
    143159  cMutex mutex;
    144160  int fdCa;
     
    157173  bool OpenSession(int Length, const uint8_t *Data);
    158174  bool CloseSession(int SessionId);
    159175  int CloseAllSessions(int Slot);
    160   cCiHandler(int Fd, int NumSlots);
     176  cLlCiHandler(int Fd, int NumSlots);
    161177public:
    162   ~cCiHandler();
    163   static cCiHandler *CreateCiHandler(const char *FileName);
     178  virtual ~cLlCiHandler();
    164179  int NumSlots(void) { return numSlots; }
    165180  bool Process(void);
    166181  bool HasUserIO(void) { return hasUserIO; }
     
    175190  bool connected() const;
    176191  };
    177192
     193class cHlCiHandler : public cCiHandler {
     194    friend class cCiHandler;
     195  private:
     196    cMutex mutex;
     197    int fdCa;
     198    int numSlots;
     199    int state;
     200    int numCaSystemIds;
     201    unsigned short caSystemIds[MAXCASYSTEMIDS + 1]; // list is zero terminated!
     202    cHlCiHandler(int Fd, int NumSlots);
     203    int CommHL(unsigned tag, unsigned function, struct ca_msg *msg);
     204    int GetData(unsigned tag, struct ca_msg *msg);
     205    int SendData(unsigned tag, struct ca_msg *msg);
     206  public:
     207    virtual ~cHlCiHandler();
     208    int NumSlots(void) { return numSlots; }
     209    bool Process(void);
     210    bool HasUserIO(void) { return false; }//hasUserIO; }
     211    bool NeedCaPmt(void);
     212    bool EnterMenu(int Slot);
     213    cCiMenu *GetMenu(void);
     214    cCiEnquiry *GetEnquiry(void);
     215    bool SetCaPmt(cCiCaPmt &CaPmt);
     216    const unsigned short *GetCaSystemIds(int Slot);
     217    bool SetCaPmt(cCiCaPmt &CaPmt, int Slot);
     218    bool Reset(int Slot);
     219    bool connected() const;
     220};
     221
    178222int tcp_listen(struct sockaddr_in *name,int sckt,unsigned long address=INADDR_ANY);
    179223int accept_tcp(int ip_sock,struct sockaddr_in *ip_name);
    180224int udp_listen(struct sockaddr_un *name,char const * const filename);