data.c

这是一个LINUX环境的 VDR 插件源代码,可支持Irdeto, Seca, Viaccess, Nagra, Conax & Cryptoworks等CA系统的读卡、共享等操作。

bool cEcmInfo::Compare(const cEcmInfo *e)
{
  return prgId==e->prgId && source==e->source && transponder==e->transponder &&
         caId==e->caId && ecm_pid==e->ecm_pid && provId==e->provId;
}

bool cEcmInfo::Update(const cEcmInfo *e)
{
  return (e->data && (!data || e->dataLen!=dataLen)) ? AddData(e->data,e->dataLen) : false;
}

void cEcmInfo::SetSource(int PrgId, int Source, int Transponder)
{
  prgId=PrgId;
  source=Source;
  transponder=Transponder;
}

void cEcmInfo::ClearData(void)
{
  free(data); data=0;
}

bool cEcmInfo::AddData(const unsigned char *Data, int DataLen)
{
  ClearData();
  data=MALLOC(unsigned char,DataLen);
  if(data) {
    memcpy(data,Data,DataLen);
    dataLen=DataLen;
    }
  else PRINTF(L_GEN_ERROR,"malloc failed in cEcmInfo::AddData()");
  return (data!=0);
}

void cEcmInfo::SetName(const char *Name)
{
  free(name);
  name=strdup(Name);
}

// -- cPlainKey ----------------------------------------------------------------

cPlainKey::cPlainKey(bool CanSupersede)
{
  au=del=false;
  super=CanSupersede;
}

bool cPlainKey::Set(int Type, int Id, int Keynr, void *Key, int Keylen)
{
  type=Type; id=Id; keynr=Keynr;
  return SetKey(Key,Keylen);
}

cString cPlainKey::PrintKeyNr(void)
{
  return cString::sprintf("%02X",keynr);
}

int cPlainKey::IdSize(void)
{
  return id>0xFF ? (id>0xFFFF ? 6 : 4) : 2;
}

bool cPlainKey::Save(FILE *f)
{
  fprintf(f,"%s\n",*ToString(false));
  return ferror(f)==0;
}

cString cPlainKey::ToString(bool hide)
{
  return cString::sprintf(hide ? "%c %.*X %s %.4s..." : "%c %.*X %s %s",type,IdSize(),id,*PrintKeyNr(),*Print());
}

void cPlainKey::FormatError(const char *type, const char *sline)
{
  PRINTF(L_GEN_WARN,"%s key: bad format '%.15s%s'\n",type,sline,(strlen(sline)>15)?"...":"");
}

// -- cMutableKey --------------------------------------------------------------

cMutableKey::cMutableKey(bool Super)
:cPlainKey(Super)
{
  real=0;
}

cMutableKey::~cMutableKey()
{
  delete real;
}

bool cMutableKey::SetKey(void *Key, int Keylen)
{
  delete real;
  return (real=Alloc()) && real->SetKey(Key,Keylen);
}

bool cMutableKey::SetBinKey(unsigned char *Mem, int Keylen)
{
  delete real;
  return (real=Alloc()) && real->SetBinKey(Mem,Keylen);
}

int cMutableKey::Size(void)
{
  return real->Size();
}

bool cMutableKey::Cmp(void *Key, int Keylen)
{
  return real->Cmp(Key,Keylen);
}

bool cMutableKey::Cmp(cPlainKey *k)
{
  cMutableKey *mk=dynamic_cast<cMutableKey *>(k); // high magic ;)
  return real->Cmp(mk ? mk->real : k);
}

void cMutableKey::Get(void *mem)
{
  real->Get(mem);
}

cString cMutableKey::Print(void)
{
  return real->Print();
}

// ----------------------------------------------------------------

class cPlainKeyDummy : public cPlainKey {
private:
  char *str;
  int len;
protected:
  virtual cString Print(void);
  virtual cString PrintKeyNr(void) { return ""; }
public:
  cPlainKeyDummy(void);
  ~cPlainKeyDummy();
  virtual bool Parse(const char *line);
  virtual bool Cmp(void *Key, int Keylen) { return false; }
  virtual bool Cmp(cPlainKey *k) { return false; }
  virtual void Get(void *mem) {}
  virtual int Size(void) { return len; }
  virtual bool SetKey(void *Key, int Keylen);
  virtual bool SetBinKey(unsigned char *Mem, int Keylen);
  };

cPlainKeyDummy::cPlainKeyDummy(void):
cPlainKey(false)
{
  str=0;
}

cPlainKeyDummy::~cPlainKeyDummy()
{
  free(str);
}

bool cPlainKeyDummy::SetKey(void *Key, int Keylen)
{
  len=Keylen;
  free(str);
  str=MALLOC(char,len+1);
  if(str) strn0cpy(str,(char *)Key,len+1);
  return str!=0;
}

bool cPlainKeyDummy::SetBinKey(unsigned char *Mem, int Keylen)
{
  return SetKey(Mem,Keylen);
}

cString cPlainKeyDummy::Print(void)
{
  return str;
}

bool cPlainKeyDummy::Parse(const char *line)
{
  unsigned char sid[3];
  int len;
  if(GetChar(line,&type,1) && (len=GetHex(line,sid,3,false))) {
    type=toupper(type); id=Bin2Int(sid,len);
    char *l=strdup(line);
    line=skipspace(stripspace(l));
    SetKey((void *)line,strlen(line));
    free(l);
    return true;
    }
  return false;
}

// -- cPlainKeyTypeDummy -------------------------------------------------------

class cPlainKeyTypeDummy : public cPlainKeyType {
public:
  cPlainKeyTypeDummy(int Type):cPlainKeyType(Type,false) {}
  virtual cPlainKey *Create(void) { return new cPlainKeyDummy; }
  };

// -- cPlainKeyType ------------------------------------------------------------

cPlainKeyType::cPlainKeyType(int Type, bool Super)
{
  type=Type;
  cPlainKeys::Register(this,Super);
}

// -- cPlainKeys ---------------------------------------------------------------

const char *externalAU=0;

cPlainKeys keys;

cPlainKeyType *cPlainKeys::first=0;

cPlainKeys::cPlainKeys(void)
:cLoader("KEY")
//,cThread("ExternalAU")
{
  mark=0;
}

void cPlainKeys::Register(cPlainKeyType *pkt, bool Super)
{
  PRINTF(L_CORE_DYN,"registering key type %c%s",pkt->type,Super?" (super)":"");
  pkt->next=first;
  first=pkt;
}

cPlainKey *cPlainKeys::FindKey(int Type, int Id, int Keynr, int Size, cPlainKey *key)
{
  key=FindKeyNoTrig(Type,Id,Keynr,Size,key);
  if(!key) {
    static int lastType=-1, lastId=-1, lastKeynr=-1;
    if(externalAU && (lastType!=Type || lastId!=Id || lastKeynr!=Keynr)) {
      PRINTF(L_CORE_AUEXTERN,"triggered from findkey (type=%X id=%X keynr=%X)",Type,Id,Keynr);
      lastType=Type; lastId=Id; lastKeynr=Keynr;
      }
    ExternalUpdate();
    }
  return key;
}

cPlainKey *cPlainKeys::FindKeyNoTrig(int Type, int Id, int Keynr, int Size, cPlainKey *key)
{
  Lock();
  if(key) key=Next(key); else key=First();
  while(key) {
    if(!key->IsInvalid() && key->type==Type && key->id==Id && key->keynr==Keynr && (Size<0 || key->Size()==Size)) break;
    key=Next(key);
    }
  Unlock();
  return key;
}

bool cPlainKeys::NewKey(int Type, int Id, int Keynr, void *Key, int Keylen)
{
  cPlainKey *k=0;
  while((k=FindKeyNoTrig(Type,Id,Keynr,-1,k)))
    if(k->Cmp(Key,Keylen)) return false;

  cPlainKey *nk=NewFromType(Type);
  if(nk) {
    nk->Set(Type,Id,Keynr,Key,Keylen);
    AddNewKey(nk,2,true);
    return true;
    }
  else PRINTF(L_GEN_ERROR,"no memory for new key ID %c %.2x!",Type,Id);
  return false;
}

void cPlainKeys::AddNewKey(cPlainKey *nk, int mode, bool log)
{
  if(mode>=1) {
    nk->SetAuto();
    if(log) PRINTF(L_GEN_INFO,"key update for ID %s",*nk->ToString(true));
    if(nk->CanSupersede()) {
      cPlainKey *k=0;
      while((k=FindKeyNoTrig(nk->type,nk->id,nk->keynr,nk->Size(),k))) {
        if(!k->IsInvalid()) {
          k->SetInvalid();
          if(k->IsAuto()) Modified();
          if(log) PRINTF(L_GEN_INFO,"supersedes key: %s%s",*k->ToString(true),k->IsAuto()?" (auto)":"");
          }
        }
      }
    }
  Lock();
  switch(mode) {
    case 0: Add(nk); break;
    case 1: if(!mark) Ins(nk); else Add(nk,mark);
            mark=nk;
            break;
    case 2: Ins(nk); Modified(); break;
    }
  Unlock();
}

bool cPlainKeys::Load(const char *cfgdir)
{
  Lock();
  Clear(); mark=0;
  cString cname=AddDirectory(cfgdir,KEY_FILE);
  ConfRead("keys",cname);
  int n=Count();
  PRINTF(L_CORE_LOAD,"loaded %d keys from %s",n,*cname);
  if(n && LOG(L_CORE_KEYS)) {
    cPlainKey *dat=First();
    while(dat) {
      if(!dat->IsInvalid()) PRINTF(L_CORE_KEYS,"keys %s",*dat->ToString(false));
      dat=Next(dat);
      }
    }
  Unlock();
  return (n!=0);
}

void cPlainKeys::HouseKeeping(void)
{
  cLoaders::SaveCache();
  if(trigger.TimedOut()) {
    trigger.Set(EXT_AU_INT);
    if(externalAU) PRINTF(L_CORE_AUEXTERN,"triggered from housekeeping");
    ExternalUpdate();
    }
}

void cPlainKeys::ExternalUpdate(void)
{
  if(externalAU && ScSetup.AutoUpdate>0) {
    if(last.TimedOut()) {
      Lock();
      if(!Active())
        Start();
      else PRINTF(L_CORE_AUEXTERN,"still running");
      Unlock();
      }
    else PRINTF(L_CORE_AUEXTERN,"denied, min. timeout not expired");
    }
}

void cPlainKeys::Action(void)
{
  last.Set(EXT_AU_MIN);
  PRINTF(L_CORE_AUEXTERN,"starting...");
  cTimeMs start;
  cPipe pipe;
  if(pipe.Open(externalAU,"r")) {
    char buff[1024];
    while(fgets(buff,sizeof(buff),pipe)) {
      char *line=skipspace(stripspace(buff));
      if(line[0]==0 || line[0]==';' || line[0]=='#') continue;
      cPlainKey *nk=NewFromType(toupper(line[0]));
      if(nk && nk->Parse(line)) {
        cPlainKey *k=0;
        while((k=FindKeyNoTrig(nk->type,nk->id,nk->keynr,-1,k)))
          if(k->Cmp(nk)) break;
        if(!k) {
          AddNewKey(nk,2,true);
          nk=0;
          }
        }
      delete nk;
      }
    }
  pipe.Close();
  PRINTF(L_CORE_AUEXTERN,"done (elapsed %d)",(int)start.Elapsed());
}

cPlainKey *cPlainKeys::NewFromType(int type)
{
  cPlainKeyType *pkt=first;
  while(pkt) {
    if(pkt->type==type) return pkt->Create();
    pkt=pkt->next;
    }
  PRINTF(L_CORE_LOAD,"unknown key type '%c', adding dummy",type);
  pkt=new cPlainKeyTypeDummy(type);
  return pkt->Create();
}

bool cPlainKeys::ParseLine(const char *line, bool fromCache)
{
  char *s=skipspace(line);
  cPlainKey *k=NewFromType(toupper(*s));
  if(k) {
    if(k->Parse((char *)line)) AddNewKey(k,fromCache?1:0,false);
    else delete k;
    return true;
    }
  return false;
}

bool cPlainKeys::Save(FILE *f)
{
  bool res=true;
  Lock();
  cPlainKey *dat=First();
  while(dat) {
    if(dat->IsAuto() && !dat->IsInvalid()) {
      if(!dat->Save(f)) { res=false; break; }
      }
    dat=Next(dat);
    }
  Modified(!res);
  Unlock();
  return res;
}