ci.h

Go to the documentation of this file.

/*
 * ci.h: Common Interface
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: ci.h 4.12 2018/03/17 12:17:37 kls Exp $
 */

#ifndef __CI_H
#define __CI_H

#include <stdint.h>
#include <stdio.h>
#include "channels.h"
#include "ringbuffer.h"
#include "thread.h"
#include "tools.h"

#define MAX_CAM_SLOTS_PER_ADAPTER    16 // maximum possible value is 255 (same value as MAXDEVICES!)
#define MAX_CONNECTIONS_PER_CAM_SLOT  8 // maximum possible value is 254
#define CAM_READ_TIMEOUT  50 // ms

class cCiTransportConnection;
class cCamSlot;

// VDR's Common Interface functions implement only the features that are absolutely
// necessary to control a CAM. If a plugin wants to implement additional functionality
// (i.e. "resources"), it can do so by deriving from cCiResourceHandler, cCiSession
// and (if necessary) from cCiApplicationInformation.

class cCiSession {
private:
  uint16_t sessionId;
  uint32_t resourceId;
  cCiTransportConnection *tc;
protected:
  void SetTsPostProcessor(void);
  void SetResourceId(uint32_t Id);
  int GetTag(int &Length, const uint8_t **Data);
  const uint8_t *GetData(const uint8_t *Data, int &Length);
  void SendData(int Tag, int Length = 0, const uint8_t *Data = NULL);
  cCiTransportConnection *Tc(void) { return tc; }
public:
  cCiSession(uint16_t SessionId, uint32_t ResourceId, cCiTransportConnection *Tc);
  virtual ~cCiSession();
  uint16_t SessionId(void) { return sessionId; }
  uint32_t ResourceId(void) { return resourceId; }
  cCamSlot *CamSlot(void);
  virtual bool HasUserIO(void) { return false; }
  virtual void Process(int Length = 0, const uint8_t *Data = NULL);
  virtual bool TsPostProcess(uint8_t *TsPacket) { return false; }
  };

class cCiApplicationInformation : public cCiSession {
protected:
  int state;
  uint8_t applicationType;
  uint16_t applicationManufacturer;
  uint16_t manufacturerCode;
  char *menuString;
public:
  cCiApplicationInformation(uint16_t SessionId, cCiTransportConnection *Tc);
  virtual ~cCiApplicationInformation();
  virtual void Process(int Length = 0, const uint8_t *Data = NULL);
  bool EnterMenu(void);
  const char *GetMenuString(void) { return menuString; }
  };

class cCiResourceHandler : public cListObject {
public:
  cCiResourceHandler(void);
  virtual ~cCiResourceHandler();
  virtual const uint32_t *ResourceIds(void) const = 0;
  virtual cCiSession *GetNewCiSession(uint32_t ResourceId, uint16_t SessionId, cCiTransportConnection *Tc) = 0;
  };

class cCiResourceHandlers : public cList<cCiResourceHandler> {
private:
  cVector<uint32_t> resourceIds;
public:
  cCiResourceHandlers(void);
  void Register(cCiResourceHandler *ResourceHandler);
  const uint32_t *Ids(void) { return &resourceIds[0]; }
  int NumIds(void) { return resourceIds.Size(); }
  cCiSession *GetNewCiSession(uint32_t ResourceId, uint16_t SessionId, cCiTransportConnection *Tc);
  };

extern cCiResourceHandlers CiResourceHandlers;

class cCiMMI;

class cCiMenu {
  friend class cCamSlot;
  friend class cCiMMI;
private:
  enum { MAX_CIMENU_ENTRIES = 64 }; 
  cCiMMI *mmi;
  cMutex *mutex;
  bool selectable;
  char *titleText;
  char *subTitleText;
  char *bottomText;
  char *entries[MAX_CIMENU_ENTRIES];
  int numEntries;
  bool AddEntry(char *s);
  cCiMenu(cCiMMI *MMI, bool Selectable);
public:
  ~cCiMenu();
  const char *TitleText(void) { return titleText; }
  const char *SubTitleText(void) { return subTitleText; }
  const char *BottomText(void) { return bottomText; }
  const char *Entry(int n) { return n < numEntries ? entries[n] : NULL; }
  int NumEntries(void) { return numEntries; }
  bool Selectable(void) { return selectable; }
  void Select(int Index);
  void Cancel(void);
  void Abort(void);
  bool HasUpdate(void);
  };

class cCiEnquiry {
  friend class cCamSlot;
  friend class cCiMMI;
private:
  cCiMMI *mmi;
  cMutex *mutex;
  char *text;
  bool blind;
  int expectedLength;
  cCiEnquiry(cCiMMI *MMI);
public:
  ~cCiEnquiry();
  const char *Text(void) { return text; }
  bool Blind(void) { return blind; }
  int ExpectedLength(void) { return expectedLength; }
  void Reply(const char *s);
  void Cancel(void);
  void Abort(void);
  };

class cDevice;

enum eModuleStatus { msNone, msReset, msPresent, msReady };

class cCiAdapter : public cThread {
  friend class cCamSlot;
private:
  cCamSlot *camSlots[MAX_CAM_SLOTS_PER_ADAPTER];
  void AddCamSlot(cCamSlot *CamSlot);
protected:
  cCamSlot *ItCamSlot(int &Iter);
  virtual void Action(void);
  virtual int Read(uint8_t *Buffer, int MaxLength) { return 0; }
  virtual void Write(const uint8_t *Buffer, int Length) {}
  virtual bool Reset(int Slot) { return false; }
  virtual eModuleStatus ModuleStatus(int Slot) { return msNone; }
  virtual bool Assign(cDevice *Device, bool Query = false) { return false; }
public:
  cCiAdapter(void);
  virtual ~cCiAdapter();
  };

class cTPDU;
class cCiTransportConnection;
class cCiSession;
class cCiCaProgramData;
class cCaPidReceiver;
class cCaActivationReceiver;
class cMtdHandler;
class cMtdMapper;
class cMtdCamSlot;
class cCiCaPmt;

struct cCiCaPmtList {
  cVector<cCiCaPmt *> caPmts;
  ~cCiCaPmtList();
  cCiCaPmt *Add(uint8_t CmdId, int Source, int Transponder, int ProgramNumber, const int *CaSystemIds);
  void Del(cCiCaPmt *CaPmt);
  };

class cCamSlot : public cListObject {
  friend class cCiAdapter;
  friend class cCiTransportConnection;
  friend class cCiConditionalAccessSupport;
  friend class cMtdCamSlot;
private:
  cMutex mutex;
  cCondVar processed;
  cCiAdapter *ciAdapter;
  cCamSlot *masterSlot;
  cDevice *assignedDevice;
  cCaPidReceiver *caPidReceiver;
  cCaActivationReceiver *caActivationReceiver;
  int slotIndex;
  int slotNumber;
  cCiTransportConnection *tc[MAX_CONNECTIONS_PER_CAM_SLOT + 1];  // connection numbering starts with 1
  eModuleStatus lastModuleStatus;
  time_t resetTime;
  cTimeMs moduleCheckTimer;
  bool resendPmt;
  int source;
  int transponder;
  cList<cCiCaProgramData> caProgramList;
  bool mtdAvailable;
  cMtdHandler *mtdHandler;
  void NewConnection(void);
  void DeleteAllConnections(void);
  void Process(cTPDU *TPDU = NULL);
  void Write(cTPDU *TPDU);
  cCiSession *GetSessionByResourceId(uint32_t ResourceId);
  void MtdActivate(bool On);
protected:
  virtual const int *GetCaSystemIds(void);
  virtual void SendCaPmt(uint8_t CmdId);
  virtual bool RepliesToQuery(void);
  void BuildCaPmts(uint8_t CmdId, cCiCaPmtList &CaPmtList, cMtdMapper *MtdMapper = NULL);
  void SendCaPmts(cCiCaPmtList &CaPmtList);
  void MtdEnable(void);
  int MtdPutData(uchar *Data, int Count);
public:
  bool McdAvailable(void) { return RepliesToQuery(); }
  bool MtdAvailable(void) { return mtdAvailable; }
  bool MtdActive(void) { return mtdHandler != NULL; }
public:
  cCamSlot(cCiAdapter *CiAdapter, bool WantsTsData = false, cCamSlot *MasterSlot = NULL);
  virtual ~cCamSlot();
  bool IsMasterSlot(void) { return !masterSlot; }
  cCamSlot *MasterSlot(void) { return masterSlot ? masterSlot : this; }
  cCamSlot *MtdSpawn(void);
  void TriggerResendPmt(void) { resendPmt = true; }
  virtual bool Assign(cDevice *Device, bool Query = false);
  cDevice *Device(void) { return assignedDevice; }
  bool Devices(cVector<int> &CardIndexes);
  bool WantsTsData(void) const { return caPidReceiver != NULL; }
  int SlotIndex(void) { return slotIndex; }
  int SlotNumber(void) { return slotNumber; }
  int MasterSlotNumber(void) { return masterSlot ? masterSlot->SlotNumber() : slotNumber; }
  virtual bool Reset(void);
  virtual bool CanActivate(void);
  virtual void StartActivation(void);
  virtual void CancelActivation(void);
  virtual bool IsActivating(void);
  virtual eModuleStatus ModuleStatus(void);
  virtual const char *GetCamName(void);
  virtual bool Ready(void);
  virtual bool HasMMI(void);
  virtual bool HasUserIO(void);
  virtual bool EnterMenu(void);
  virtual cCiMenu *GetMenu(void);
  virtual cCiEnquiry *GetEnquiry(void);
  int Priority(void);
  virtual bool ProvidesCa(const int *CaSystemIds);
  virtual void AddPid(int ProgramNumber, int Pid, int StreamType);
  virtual void SetPid(int Pid, bool Active);
  virtual void AddChannel(const cChannel *Channel);
  virtual bool CanDecrypt(const cChannel *Channel, cMtdMapper *MtdMapper = NULL);
  virtual void StartDecrypting(void);
  virtual void StopDecrypting(void);
  virtual bool IsDecrypting(void);
  virtual uchar *Decrypt(uchar *Data, int &Count);
  virtual bool TsPostProcess(uchar *Data);
  virtual bool Inject(uchar *Data, int Count);
  virtual void InjectEit(int Sid);
  };

class cCamSlots : public cList<cCamSlot> {
public:
  int NumReadyMasterSlots(void);
  bool WaitForAllCamSlotsReady(int Timeout = 0);
  };

extern cCamSlots CamSlots;

class cChannelCamRelation;

class cChannelCamRelations : public cList<cChannelCamRelation> {
private:
  cMutex mutex;
  cString fileName;
  cChannelCamRelation *GetEntry(tChannelID ChannelID);
  cChannelCamRelation *AddEntry(tChannelID ChannelID);
  time_t lastCleanup;
  void Cleanup(void);
public:
  cChannelCamRelations(void);
  void Reset(int CamSlotNumber);
  bool CamChecked(tChannelID ChannelID, int CamSlotNumber);
  bool CamDecrypt(tChannelID ChannelID, int CamSlotNumber);
  void SetChecked(tChannelID ChannelID, int CamSlotNumber);
  void SetDecrypt(tChannelID ChannelID, int CamSlotNumber);
  void ClrChecked(tChannelID ChannelID, int CamSlotNumber);
  void ClrDecrypt(tChannelID ChannelID, int CamSlotNumber);
  void Load(const char *FileName);
  void Save(void);
  };

extern cChannelCamRelations ChannelCamRelations;

bool CamResponsesLoad(const char *FileName, bool AllowComments = false, bool MustExist = false);

#endif //__CI_H