#include <filter.h>

Inheritance diagram for cAction:

Public Member Functions
	cAction (const char Id, cDevice Device, const char *DevId)
virtual	~cAction ()
Protected Member Functions
virtual void	Process (cPidFilter filter, unsigned char data, int len)=0
virtual void	Action (void)
virtual cPidFilter *	CreateFilter (int Num, int IdleTime)
cPidFilter *	NewFilter (int IdleTime)
cPidFilter *	IdleFilter (void)
void	DelFilter (cPidFilter *filter)
void	DelAllFilter (void)
void	Priority (int Pri)
Protected Attributes
cDevice *	device
char *	id

Detailed Description

Definition at line 33 of file filter.h.

Constructor & Destructor Documentation

cAction::cAction	(	const char *	Id,
		cDevice *	Device,
		const char *	DevId
	)

Definition at line 125 of file filter.c.

References bprintf(), device, and cThread::SetDescription().

{
  device=Device; devId=DevId;
  id=bprintf("%s %s",Id,DevId);
  unique=0; pri=-1;
  SetDescription("%s filter",id);
}

cAction::~cAction ( ) [virtual]

Definition at line 133 of file filter.c.

References cThread::Cancel(), DelAllFilter(), free, L_CORE_ACTION, and PRINTF.

{
  Cancel(2);
  DelAllFilter();
  PRINTF(L_CORE_ACTION,"%s: stopped",id);
  free(id);
}

Member Function Documentation

void cAction::Action ( void ) [protected, virtual]

A derived cThread class must implement the code it wants to execute as a separate thread in this function. If this is a loop, it must check Running() repeatedly to see whether it's time to stop.

Implements cThread.

Definition at line 193 of file filter.c.

References cPidFilter::Active(), cSimpleListBase::Count(), cTimeMs::Elapsed(), cPidFilter::fd, cPidFilter::Flush(), cPidFilter::id, L_GEN_ERROR, cThread::Lock(), MAX_SECT_SIZE, cSimpleItem::Next(), PRINTF, Process(), cThread::Running(), cTimeMs::Set(), cThread::SetPriority(), cCondWait::SleepMs(), and cThread::Unlock().

{
  if(pri>0) SetPriority(pri);
  struct pollfd *pfd=0;
  while(Running()) {
    if(filters.Count()<=0) {
      cCondWait::SleepMs(100);
      }
    else {
      // first build pfd data
      Lock();
      delete[] pfd; pfd=new struct pollfd[filters.Count()];
      if(!pfd) {
        PRINTF(L_GEN_ERROR,"action %s: pollfd: out of memory",id);
        break;
        }
      int num=0;
      cPidFilter *filter;
      for(filter=filters.First(); filter; filter=filters.Next(filter))
        if(filter->Active()) {
          memset(&pfd[num],0,sizeof(struct pollfd));
          pfd[num].fd=filter->fd;
          pfd[num].events=POLLIN;
          num++;
          }
      Unlock();

      // now poll for data
      int r=poll(pfd,num,60);
      if(r<0 && errno!=EINTR) {
        PRINTF(L_GEN_ERROR,"action %s poll: %s",id,strerror(errno));
        break;
        }
      if(r>0) {
        for(r=0 ; r<num ; r++)
          if(pfd[r].revents&POLLIN) {
            Lock();
            for(filter=filters.First(); filter; filter=filters.Next(filter)) {
              if(filter->fd==pfd[r].fd) {
                unsigned char buff[MAX_SECT_SIZE];
                int n=read(filter->fd,buff,sizeof(buff));
                if(n<0 && errno!=EAGAIN) {
                  if(errno==EOVERFLOW) {
                    filter->Flush();
                    //PRINTF(L_GEN_ERROR,"action %s read: Buffer overflow",filter->id);
                    }
                  else PRINTF(L_GEN_ERROR,"action %s read: %s",filter->id,strerror(errno));
                  }
                if(n>0) {
                  filter->lastTime.Set(); filter->forceRun=false;
                  Process(filter,buff,n);
                  // don't make any assumption about data-structs here
                  // Process() may have changed them
                  }
                break;
                }
              }
            Unlock();
            }
        }

      // call filters which are idle too long
      Lock();
      do {
        r=0;
        for(filter=filters.First(); filter; filter=filters.Next(filter)) {
          if(filter->forceRun || (filter->idleTime && filter->lastTime.Elapsed()>filter->idleTime)) {
            filter->lastTime.Set(); filter->forceRun=false;
            Process(filter,0,0);
            // don't make any assumption about data-structs here
            // Process() may have changed them
            r=1; break;
            }
          }
        } while(r);
      Unlock();
      }
    }
  delete[] pfd;
}

cPidFilter * cAction::CreateFilter	(	int	Num,
		int	IdleTime
	)		`[protected, virtual]`

Definition at line 141 of file filter.c.

References device.

Referenced by NewFilter().

{
  return new cPidFilter(id,Num,device,IdleTime);
}

void cAction::DelAllFilter ( void ) [protected]

Definition at line 180 of file filter.c.

References cSimpleListBase::Clear(), cThread::Lock(), and cThread::Unlock().

Referenced by cLogger::Down(), cHookManager::Down(), ~cAction(), and cEcmHandler::~cEcmHandler().

{
  Lock();
  filters.Clear();
  unique=0;
  Unlock();
}

void cAction::DelFilter ( cPidFilter * filter ) [protected]

Definition at line 173 of file filter.c.

References cSimpleListBase::Del(), cThread::Lock(), and cThread::Unlock().

{
  Lock();
  filters.Del(filter);
  Unlock();
}

cPidFilter * cAction::IdleFilter ( void ) [protected]

Definition at line 163 of file filter.c.

References cPidFilter::Active(), cSimpleList< T >::First(), cThread::Lock(), cSimpleList< T >::Next(), and cThread::Unlock().

{
  Lock();
  cPidFilter *filter;
  for(filter=filters.First(); filter; filter=filters.Next(filter))
    if(!filter->Active()) break;
  Unlock();
  return filter;
}

cPidFilter * cAction::NewFilter ( int IdleTime ) [protected]

Definition at line 146 of file filter.c.

References cThread::Active(), cSimpleListBase::Add(), CreateFilter(), L_CORE_ACTION, cThread::Lock(), PRINTF, cThread::Start(), and cThread::Unlock().

Referenced by cEcmHandler::SetPrg().

{
  Lock();
  cPidFilter *filter=CreateFilter(unique++,IdleTime);
  if(filter) {
    if(!Active()) {
      Start();
      PRINTF(L_CORE_ACTION,"%s: started",id);
      }
    filters.Add(filter);
    }
  else
    PRINTF(L_CORE_ACTION,"%s: failed to create filter",id);
  Unlock();
  return filter;
}