eventlist.cpp

SNMP++程序源码 for ll .8snmp++2_8.tar.Z 嵌入式linux环境下的SNMP开发代码

//    and return that as a unsigned long.
// 25-Jan-96 TM

  sendTime = now;
  status = eventList.GetNextTimeout(sendTime);
  if (sendTime.IsInfinite()) {
    return (MAX_UINT32);
  }
  else {

    // Kludge: When this was first designed the units were millisecs
    // However, later on the units for the target class were changed
    // to hundreths of secs.  Divide millisecs by 10 to create the
    // hundreths of secs which the rest of the objects use.  
    // 25-Jan-96 TM

    sendTime -= now;
    return (((unsigned long) sendTime) / 10);
  }
}


#ifdef SNMPX11
// Required for integration with X11

int SNMPX11Initialize( const XtAppContext app_context)
{

  // Save the app_context for future Xt calls.
  global_app_context = app_context;

  return SNMP_CLASS_SUCCESS;

}

void SnmpX11TimerCallback(XtPointer /*client_data*/, XtIntervalId */*id*/)
{ 
  // We have been called because one of our timers popped
  // The timer is automatically unregistered from X11 after it is fired
  global_interval_id = TIMER_NOT_SET;

  // Handle the event and any timeouts
  SNMPProcessPendingEvents();

  // Set a timer for the next retransmission
  SnmpX11SetTimer();
}

void SnmpX11InputCallback(XtPointer /*client_data*/, 
			  int */*source*/, XtInputId */*id*/)
{
  // We have been called because there is activity on one of our fds
  // Handle the event and any timeouts
  SNMPProcessPendingEvents();

  // Set a timer for the next retransmission
  SnmpX11SetTimer();
}

void SnmpX11SetTimer()
{
  msec nextTimeout;

  // if they have not yet initialized there is nothing we can do
  if (global_app_context == CONTEXT_NOT_SET)
    return;

  // Before returning control set a timer with X11 in case we
  // don't get any input before the next retransmission time
  eventList.GetNextTimeout(nextTimeout);
  if (global_interval_id != TIMER_NOT_SET) {
    // we already have a timer set
    if (global_next_timeout != nextTimeout) {
      // The timeout registered with X11 is no longer what we want
      XtRemoveTimeOut(global_interval_id);
    }
    else {
      // The current timeout is still valid
      return;
    }
  }
  if (nextTimeout.IsInfinite()) {
    // nothing left to wait for
    global_interval_id = TIMER_NOT_SET;
  }
  else {
    timeval alarm;
    msec now;
    unsigned long millisec;
    // calcuate and set the next timer
    now.GetDelta(nextTimeout, alarm);
    millisec = (alarm.tv_sec * 1000) + (alarm.tv_usec / 1000);
    global_next_timeout = nextTimeout;
    global_interval_id = XtAppAddTimeOut(global_app_context, millisec,
					 (XtTimerCallbackProc)SnmpX11TimerCallback, 0);
  }
  return;  
}

int SnmpX11AddInput(int inputFd, XtInputId &inputId)
{
  if (global_app_context == CONTEXT_NOT_SET) {
    // They have not called SnmpX11Initialize yet!
//TM: Need better error define
    return SNMP_CLASS_ERROR;
  }
  // Tell X11 to call us back for any activity on our file descriptor
  inputId = XtAppAddInput(global_app_context, inputFd,
			  (XtPointer) (XtInputReadMask | XtInputExceptMask),
			  (XtInputCallbackProc)SnmpX11InputCallback, 0);
  SnmpX11SetTimer();
  return SNMP_CLASS_SUCCESS;
}

int SnmpX11RemoveInput(XtInputId &inputId)
{ 
  // Tell X11 to stop watching our file descriptor
  XtRemoveInput(inputId);
  SnmpX11SetTimer();
  return SNMP_CLASS_SUCCESS;
}
#endif // SNMPX11

//----[ CSNMPMessageQueueElt class ]--------------------------------------

CEventListElt::CEventListElt(CEvents *events,
			     CEventListElt *next,
			     CEventListElt *previous):
  m_events(events), m_next(next), m_previous(previous)
{
    /*------------------------------------------*/
    /* Finish insertion into doubly linked list */
    /*------------------------------------------*/
  if (m_next)
    m_next->m_previous = this;
  if (m_previous)
    m_previous->m_next = this;
}

CEventListElt::~CEventListElt(){
    /*-------------------------------------*/
    /* Do deletion form doubly linked list */
    /*-------------------------------------*/
  if (m_next)
    m_next->m_previous = m_previous;
  if (m_previous)
    m_previous->m_next = m_next;

  if (m_events)
    delete m_events;
}

CEventListElt *CEventListElt::GetNext() {
  return(m_next);
}

CEvents *CEventListElt::GetEvents() {
  return(m_events);
}



//----[ CEventList class ]--------------------------------------

CEventList::CEventList():
  m_head(NULL,NULL,NULL), m_msgCount(0), m_done(0)
{

  // Automaticly add the SNMP message queue
  snmpEventList = new CSNMPMessageQueue;
  AddEntry((CEvents *)snmpEventList);

  // Automatically add the SNMP notification queue
  notifyEventList = new CNotifyEventQueue;
  AddEntry((CEvents *)notifyEventList);

  // Automaticly add the user-defined event queue
  udEventList = new CUDEventQueue;
  AddEntry((CEvents *)udEventList);

  // Automaticly add the user-defined timeout queue
  utEventList = new CUTEventQueue;
  AddEntry((CEvents *)utEventList);

}

CEventList::~CEventList(){
  CEventListElt *leftOver;
    /*--------------------------------------------------------*/
    /* walk the list deleting any elements still on the queue */
    /*--------------------------------------------------------*/
  while (leftOver = m_head.GetNext())
    delete leftOver;
}

CEvents * CEventList::AddEntry(CEvents *events) {

    /*---------------------------------------------------------*/
    /* Insert entry at head of list, done automagically by the */
    /* constructor function, so don't use the return value.    */
    /*---------------------------------------------------------*/
  (void) new CEventListElt(events, m_head.GetNext(), &m_head);
  m_msgCount++;
  return(events);
}

void CEventList::SetDone() {
  m_done += 1;
}

int CEventList::GetDone() {
  return m_done;
}

int CEventList::GetNextTimeout(msec &sendTime) {
  CEventListElt *msgEltPtr = m_head.GetNext();
  msec tmpTime = sendTime;

  sendTime.SetInfinite();	// set sendtime out into future
  while (msgEltPtr) {
    if (msgEltPtr->GetEvents()->GetCount() &&
	!msgEltPtr->GetEvents()->GetNextTimeout(tmpTime)) {
      if (sendTime > tmpTime)
	sendTime = tmpTime;
    }

    msgEltPtr = msgEltPtr->GetNext();
  }

  return 0;
}


void CEventList::GetFdSets(int &maxfds, fd_set &readfds, fd_set &writefds,
			   fd_set &exceptfds) {
  CEventListElt *msgEltPtr = m_head.GetNext();

  maxfds = 0;
  FD_ZERO(&readfds);
  FD_ZERO(&writefds);
  FD_ZERO(&exceptfds);
  while (msgEltPtr) {
    if (msgEltPtr->GetEvents()->GetCount()) {
      msgEltPtr->GetEvents()->GetFdSets(maxfds, readfds, writefds, exceptfds);
    }
    msgEltPtr = msgEltPtr->GetNext();
  }
}


int CEventList::GetCount() {
  return m_msgCount;
}


int CEventList::HandleEvents(const int maxfds,
			     const fd_set &readfds,
			     const fd_set &writefds,
			     const fd_set &exceptfds) {
  CEventListElt *msgEltPtr = m_head.GetNext();
  int status = SNMP_CLASS_SUCCESS;
  while (msgEltPtr){
    if (msgEltPtr->GetEvents()->GetCount()) {
      status = msgEltPtr->GetEvents()->HandleEvents(maxfds, readfds, writefds,
						    exceptfds);
    }
    msgEltPtr = msgEltPtr->GetNext();
  }
  return status;
}

int CEventList::DoRetries(const msec &sendtime) {
  CEventListElt *msgEltPtr = m_head.GetNext();
  int status = SNMP_CLASS_SUCCESS;
  while (msgEltPtr){
    if (msgEltPtr->GetEvents()->GetCount()) {
      status = msgEltPtr->GetEvents()->DoRetries(sendtime);
    }
    msgEltPtr = msgEltPtr->GetNext();
  }
  return status;
}

int CEventList::Done() {
  CEventListElt *msgEltPtr = m_head.GetNext();
  int status = SNMP_CLASS_SUCCESS;

  if (m_done) {
    m_done--;
    return 1;
  }

  while (msgEltPtr){
    if (msgEltPtr->GetEvents()->GetCount()) {
      status = msgEltPtr->GetEvents()->Done();
      if (status)
	break;
    }
    msgEltPtr = msgEltPtr->GetNext();
  }
  return status;
}