source: rtems/cpukit/httpd/websuemf.c @ a6b4c0df

/*
 * websuemf.c -- GoAhead Micro Embedded Management Framework
 *
 * Copyright (c) GoAhead Software Inc., 1995-2000. All Rights Reserved.
 *
 * See the file "license.txt" for usage and redistribution license requirements
 */

/********************************** Description *******************************/

/*
 *      This modules provides compatibility with the full GoAhead EMF.
 */

/*********************************** Includes *********************************/

#include        "ejIntrn.h"
#include        "wsIntrn.h"

/*********************************** Defines **********************************/

/*
 *      This structure stores scheduled events.
 */
typedef struct {
        void    (*routine)(void *arg, int id);
        void    *arg;
        time_t  at;
        int             schedid;
} sched_t;

/*********************************** Locals ***********************************/

static sched_t          **sched;
static int                      schedMax;

/************************************* Code ***********************************/
/*
 *      Evaluate a script
 */

int scriptEval(int engine, char_t *cmd, char_t **result, int chan)
{
        int             ejid;

        if (engine == EMF_SCRIPT_EJSCRIPT) {
                ejid = (int) chan;
                if (ejEval(ejid, cmd, NULL) ) {
                        return 0;
                } else {
                        return -1;
                }
        }
        return -1;
}

/******************************************************************************/
/*
 * Compare strings, ignoring case:  normal strcmp return codes.
 *
 *      WARNING: It is not good form to increment or decrement pointers inside a
 *      "call" to tolower et al. These can be MACROS, and have undesired side
 *      effects.
 */

int strcmpci(char_t *s1, char_t *s2)
{
        int             rc;

        a_assert(s1 && s2);
        if (s1 == NULL || s2 == NULL) {
                return 0;
        }

        if (s1 == s2) {
                return 0;
        }

        do {
                rc = gtolower(*s1) - gtolower(*s2);
                if (*s1 == '\0') {
                        break;
                }
                s1++;
                s2++;
        } while (rc == 0);
        return rc;
}

/******************************************************************************/
/*
 *      This function is called when a scheduled process time has come.
 */

void TimerProc(int schedid)
{
        sched_t *s;

        a_assert(0 <= schedid && schedid < schedMax);
        s = sched[schedid];
        a_assert(s);

        (s->routine)(s->arg, s->schedid);
}

/******************************************************************************/
/*
 *      Schedule an event in delay milliseconds time. We will use 1 second
 *      granularity for webServer.
 */

int emfSchedCallback(int delay, emfSchedProc *proc, void *arg)
{
        sched_t *s;
        int             schedid;

        if ((schedid = hAllocEntry((void***) &sched, &schedMax,
                sizeof(sched_t))) < 0) {
                return -1;
        }
        s = sched[schedid];
        s->routine = proc;
        s->arg = arg;
        s->schedid = schedid;

/*
 *      Round the delay up to seconds.
 */
        s->at = ((delay + 500) / 1000) + time(0);

        return schedid;
}

/******************************************************************************/
/*
 *      Reschedule to a new delay.
 */

void emfReschedCallback(int schedid, int delay)
{
        sched_t *s;

        if (sched == NULL || schedid == -1 || schedid >= schedMax || 
                (s = sched[schedid]) == NULL) {
                return;
        }
        s->at = ((delay + 500) / 1000) + time(0);
}

/******************************************************************************/

void emfUnschedCallback(int schedid)
{
        sched_t *s;

        if (sched == NULL || schedid == -1 || schedid >= schedMax || 
                (s = sched[schedid]) == NULL) {
                return;
        }
        bfree(B_L, s);
        schedMax = hFree((void***) &sched, schedid);
}

/******************************************************************************/
/*
 *      Take the tasks off the queue in a round robin fashion.
 */

void emfSchedProcess()
{
        sched_t         *s;
        int                     schedid;
        static int      next = 0;       

/*
 *      If schedMax is 0, there are no tasks scheduled, so just return.
 */
        if (schedMax <= 0) {
                return;
        }

/*
 *      If next >= schedMax, the schedule queue was reduced in our absence
 *      so reset next to 0 to start from the begining of the queue again.
 */
        if (next >= schedMax) {
                next = 0;
        }

        schedid = next;
        for (;;) {
                if ((s = sched[schedid]) != NULL &&     (int)s->at <= (int)time(0)) {
                        TimerProc(schedid);
                        next = schedid + 1;
                        return;
                }
                if (++schedid >= schedMax) {
                        schedid = 0;
                }
                if (schedid == next) {
/*
 *                      We've gone all the way through the queue without finding 
 *                      anything to do so just return.
 */
                        return;
                }
        }
}

/******************************************************************************/