event.c

PPPoE在Linux上的源代码

    if (t.tv_usec >= 1000000) {
	t.tv_usec -= 1000000;
	t.tv_sec++;
    }

    eh->fd = fd;
    eh->flags = flags;
    eh->tmout = t;
    eh->fn = fn;
    eh->data = data;

    /* Add immediately.  This is safe even if we are in a handler. */
    eh->next = es->handlers;
    es->handlers = eh;

    EVENT_DEBUG(("Event_AddHandlerWithTimeout(es=%p, fd=%d, flags=%u, t=%d/%d) -> %p\n", es, fd, flags, t.tv_sec, t.tv_usec, eh));
    return eh;
}


/**********************************************************************
* %FUNCTION: Event_AddTimerHandler
* %ARGUMENTS:
*  es -- event selector
*  t -- time interval after which to trigger event
*  fn -- callback function to call when event is triggered
*  data -- extra data to pass to callback function
* %RETURNS:
*  A newly-allocated EventHandler, or NULL.
***********************************************************************/
EventHandler *
Event_AddTimerHandler(EventSelector *es,
		      struct timeval t,
		      EventCallbackFunc fn,
		      void *data)
{
    EventHandler *eh;
    struct timeval now;

    /* Check time interval for validity */
    if (t.tv_sec < 0 || t.tv_usec < 0 || t.tv_usec >= 1000000) {
	errno = EINVAL;
	return NULL;
    }

    eh = malloc(sizeof(EventHandler));
    if (!eh) return NULL;

    /* Convert time interval to absolute time */
    gettimeofday(&now, NULL);

    t.tv_sec += now.tv_sec;
    t.tv_usec += now.tv_usec;
    if (t.tv_usec >= 1000000) {
	t.tv_usec -= 1000000;
	t.tv_sec++;
    }

    eh->fd = -1;
    eh->flags = EVENT_FLAG_TIMER;
    eh->tmout = t;
    eh->fn = fn;
    eh->data = data;

    /* Add immediately.  This is safe even if we are in a handler. */
    eh->next = es->handlers;
    es->handlers = eh;

    EVENT_DEBUG(("Event_AddTimerHandler(es=%p, t=%d/%d) -> %p\n", es, t.tv_sec,t.tv_usec, eh));
    return eh;
}

/**********************************************************************
* %FUNCTION: Event_DelHandler
* %ARGUMENTS:
*  es -- event selector
*  eh -- event handler
* %RETURNS:
*  0 if OK, non-zero if there is an error
* %DESCRIPTION:
*  Deletes the event handler eh
***********************************************************************/
int
Event_DelHandler(EventSelector *es,
		 EventHandler *eh)
{
    /* Scan the handlers list */
    EventHandler *cur, *prev;
    EVENT_DEBUG(("Event_DelHandler(es=%p, eh=%p)\n", es, eh));
    for (cur=es->handlers, prev=NULL; cur; prev=cur, cur=cur->next) {
	if (cur == eh) {
	    if (es->nestLevel) {
		eh->flags |= EVENT_FLAG_DELETED;
		es->opsPending = 1;
		return 0;
	    } else {
		if (prev) prev->next = cur->next;
		else      es->handlers = cur->next;

		DestroyHandler(cur);
		return 0;
	    }
	}
    }

    /* Handler not found */
    return 1;
}

/**********************************************************************
* %FUNCTION: DestroySelector
* %ARGUMENTS:
*  es -- an event selector
* %RETURNS:
*  Nothing
* %DESCRIPTION:
*  Destroys selector and all associated handles.
***********************************************************************/
void
DestroySelector(EventSelector *es)
{
    EventHandler *cur, *next;
    for (cur=es->handlers; cur; cur=next) {
	next = cur->next;
	DestroyHandler(cur);
    }

    free(es);
}

/**********************************************************************
* %FUNCTION: DestroyHandler
* %ARGUMENTS:
*  eh -- an event handler
* %RETURNS:
*  Nothing
* %DESCRIPTION:
*  Destroys handler
***********************************************************************/
void
DestroyHandler(EventHandler *eh)
{
    EVENT_DEBUG(("DestroyHandler(eh=%p)\n", eh));
    free(eh);
}

/**********************************************************************
* %FUNCTION: DoPendingChanges
* %ARGUMENTS:
*  es -- an event selector
* %RETURNS:
*  Nothing
* %DESCRIPTION:
*  Makes all pending insertions and deletions happen.
***********************************************************************/
void
DoPendingChanges(EventSelector *es)
{
    EventHandler *cur, *prev, *next;

    es->opsPending = 0;

    /* If selector is to be deleted, do it and skip everything else */
    if (es->destroyPending) {
	DestroySelector(es);
	return;
    }

    /* Do deletions */
    cur = es->handlers;
    prev = NULL;
    while(cur) {
	if (!(cur->flags & EVENT_FLAG_DELETED)) {
	    prev = cur;
	    cur = cur->next;
	    continue;
	}

	/* Unlink from list */
	if (prev) {
	    prev->next = cur->next;
	} else {
	    es->handlers = cur->next;
	}
	next = cur->next;
	DestroyHandler(cur);
	cur = next;
    }
}

/**********************************************************************
* %FUNCTION: Event_GetCallback
* %ARGUMENTS:
*  eh -- the event handler
* %RETURNS:
*  The callback function
***********************************************************************/
EventCallbackFunc
Event_GetCallback(EventHandler *eh)
{
    return eh->fn;
}

/**********************************************************************
* %FUNCTION: Event_GetData
* %ARGUMENTS:
*  eh -- the event handler
* %RETURNS:
*  The "data" field.
***********************************************************************/
void *
Event_GetData(EventHandler *eh)
{
    return eh->data;
}

/**********************************************************************
* %FUNCTION: Event_SetCallbackAndData
* %ARGUMENTS:
*  eh -- the event handler
*  fn -- new callback function
*  data -- new data value
* %RETURNS:
*  Nothing
* %DESCRIPTION:
*  Sets the callback function and data fields.
***********************************************************************/
void
Event_SetCallbackAndData(EventHandler *eh,
			 EventCallbackFunc fn,
			 void *data)
{
    eh->fn = fn;
    eh->data = data;
}

#ifdef DEBUG_EVENT
#include <stdarg.h>
#include <stdio.h>
FILE *Event_DebugFP = NULL;
/**********************************************************************
* %FUNCTION: Event_DebugMsg
* %ARGUMENTS:
*  fmt, ... -- format string
* %RETURNS:
*  Nothing
* %DESCRIPTION:
*  Writes a debug message to the debug file.
***********************************************************************/
void
Event_DebugMsg(char const *fmt, ...)
{
    va_list ap;
    struct timeval now;

    if (!Event_DebugFP) return;

    gettimeofday(&now, NULL);

    fprintf(Event_DebugFP, "%03d.%03d ", (int) now.tv_sec % 1000,
	    (int) now.tv_usec / 1000);

    va_start(ap, fmt);
    vfprintf(Event_DebugFP, fmt, ap);
    va_end(ap);
    fflush(Event_DebugFP);
}

#endif

/**********************************************************************
* %FUNCTION: Event_EnableDebugging
* %ARGUMENTS:
*  fname -- name of file to log debug messages to
* %RETURNS:
*  1 if debugging was enabled; 0 otherwise.
***********************************************************************/
int
Event_EnableDebugging(char const *fname)
{
#ifndef DEBUG_EVENT
    return 0;
#else
    Event_DebugFP = fopen(fname, "w");
    return (Event_DebugFP != NULL);
#endif
}

/**********************************************************************
* %FUNCTION: Event_ChangeTimeout
* %ARGUMENTS:
*  h -- event handler
*  t -- new timeout
* %RETURNS:
*  Nothing
* %DESCRIPTION:
*  Changes timeout of event handler to be "t" seconds in the future.
***********************************************************************/
void
Event_ChangeTimeout(EventHandler *h, struct timeval t)
{
    struct timeval now;

    /* Check time interval for validity */
    if (t.tv_sec < 0 || t.tv_usec < 0 || t.tv_usec >= 1000000) {
	return;
    }
    /* Convert time interval to absolute time */
    gettimeofday(&now, NULL);

    t.tv_sec += now.tv_sec;
    t.tv_usec += now.tv_usec;
    if (t.tv_usec >= 1000000) {
	t.tv_usec -= 1000000;
	t.tv_sec++;
    }

    h->tmout = t;
}