Subversion Repositories or1k

/*

 * main.c -- Main program for the GoAhead WebServer (RTEMS version)

 *

 * Copyright (c) Go Ahead Software Inc., 1995-1999. All Rights Reserved.

 *

 * See the file "license.txt" for usage and redistribution license requirements

 *

 *  webmain.c,v 1.5 2000/09/22 20:38:57 joel Exp

 */

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

/*

 *      Main program for for the GoAhead WebServer. This is a demonstration

 *      main program to initialize and configure the web server.

 */

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

#include        "uemf.h"

#include        "wsIntrn.h"

#include        <signal.h>

#include        <sys/time.h>

#include        <pthread.h>

#include        <rtems.h>

#include        <rtems/error.h>

#ifdef WEBS_SSL_SUPPORT

#include        "websSSL.h"

#endif

#ifdef USER_MANAGEMENT_SUPPORT

#include        "um.h"

void    formDefineUserMgmt(void);

#endif

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

/*

 *      Change configuration here

 */

extern const char *tftpServer;

static char_t           *rootWeb = T("goahead");                        /* Root web directory */

static char_t           *password = T("");                              /* Security password */

static int                      port = 80;                                              /* Server port */

static int                      retries = 5;                                    /* Server port retries */

static int                      finished;                                               /* Finished flag */

/*

 *      Structure to hold timer events

 */

typedef struct {

        void    (*routine)(long arg);   /* Timer routine */

        long    arg;                                    /* Argument to routine */

} websTimer_t;

/* The following holds the pointer to an allocated websTimer_t structure .

 * Using this method only one timer can be active at a time, but

 * for the WebServer, this should be OK.

 */

websTimer_t *tp;

/****************************** Forward Declarations **************************/

static int      initWebs();

static int      aspTest(int eid, webs_t wp, int argc, char_t **argv);

static void formTest(webs_t wp, char_t *path, char_t *query);

static int  websHomePageHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,

                                int arg, char_t* url, char_t* path, char_t* query);

static void timerProc(int signo);

#if B_STATS

static void printMemStats(int handle, char_t *fmt, ...);

static void memLeaks();

#endif

static timer_t timer_id;

static void rtems_httpd_daemon();

/*********************************** Code *************************************/

/*

 *      Main -- entry point from RTEMS

 */

int rtems_initialize_webserver()

{

  rtems_status_code   sc;

  rtems_id            tid;

  int                 priority;

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

   * Default HTTPD priority.

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

  priority = 40;

  sc = rtems_task_create(rtems_build_name('H', 'T', 'P', 'D'),

                         priority, 8*1024,

                         RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR |

                         RTEMS_INTERRUPT_LEVEL(0),

                         RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,

                         &tid);

   if (sc != RTEMS_SUCCESSFUL)

   {

      return(RTEMS_UNSATISFIED);

   }

   sc = rtems_task_start(tid, rtems_httpd_daemon, 0);

   if (sc != RTEMS_SUCCESSFUL)

   {

      return(RTEMS_UNSATISFIED);

   }

   return(RTEMS_SUCCESSFUL);

}

static void

rtems_httpd_daemon()

{

/*

 *      Initialize the memory allocator. Allow use of malloc and start with a

 *      10K heap.

 */

        bopen(NULL, (10 * 1024), B_USE_MALLOC);

/*

 *      Initialize the web server

 */

        if (initWebs() < 0) {

          rtems_panic("Unable to initialize Web server !!\n");

        }

#ifdef WEBS_SSL_SUPPORT

        websSSLOpen();

#endif

/*

 *      Basic event loop. SocketReady returns true when a socket is ready for

 *      service. SocketSelect will block until an event occurs. SocketProcess

 *      will actually do the servicing.

 */

        while (!finished) {

          if (socketReady(-1) || socketSelect(-1, 2000)) {

                        socketProcess(-1);

          }

          /*websCgiCleanup();*/

          emfSchedProcess();

        }

#ifdef WEBS_SSL_SUPPORT

        websSSLClose();

#endif

#ifdef USER_MANAGEMENT_SUPPORT

        umClose();

#endif

/*

 *      Close the socket module, report memory leaks and close the memory allocator

 */

        websCloseServer();

        websDefaultClose();

        socketClose();

        symSubClose();

#if B_STATS

        memLeaks();

#endif

        bclose();

        rtems_task_delete( RTEMS_SELF );

}

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

/*

 *      Initialize the web server.

 */

static int initWebs()

{

        struct hostent* hp;

        struct in_addr  intaddr;

        char                    host[128], dir[128], webdir[128];

        char                    *cp;

        char_t                  wbuf[128];

/*

 *      Initialize the socket subsystem

 */

        socketOpen();

/*

 *      Define the local Ip address, host name, default home page and the

 *      root web directory.

 */

        if (gethostname(host, sizeof(host)) < 0) {

                error(E_L, E_LOG, T("Can't get hostname"));

                return -1;

                }

/*      intaddr.s_addr = (unsigned long) hostGetByName(host); */

        if ((hp = gethostbyname(host)) == NULL) {

                error(E_L, E_LOG, T("Can't get host address"));

                return -1;

        }

        memcpy((char *) &intaddr, (char *) hp->h_addr_list[0],

                (size_t) hp->h_length);

#if 0

/*

 *      Set /TFTP/x.y.z.w/goahead as the root web. Modify to suit your needs

 */

        sprintf(webdir, "/TFTP/%s/%s", tftpServer, rootWeb);

#else

        sprintf(webdir, "/");

#endif

/*

 *      Configure the web server options before opening the web server

 */

        websSetDefaultDir(webdir);

        ascToUni(wbuf, inet_ntoa(intaddr), sizeof(wbuf));

        websSetIpaddr(wbuf);

        ascToUni(wbuf, host, sizeof(wbuf));

        websSetHost(wbuf);

/*

 *      Configure the web server options before opening the web server

 */

#if 0

        websSetDefaultPage(T("default.asp"));

#else

        websSetDefaultPage(T("index.html"));

#endif

        websSetPassword(password);

/*

 *      Open the web server on the given port. If that port is taken, try

 *      the next sequential port for up to "retries" attempts.

 */

        websOpenServer(port, retries);

/*

 *      First create the URL handlers. Note: handlers are called in sorted order

 *      with the longest path handler examined first. Here we define the security

 *      handler, forms handler and the default web page handler.

 */

        websUrlHandlerDefine(T(""), NULL, 0, websSecurityHandler,

                WEBS_HANDLER_FIRST);

        websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);

        websUrlHandlerDefine(T(""), NULL, 0, websDefaultHandler,

                WEBS_HANDLER_LAST);

/*

 *      Now define two test procedures. Replace these with your application

 *      relevant ASP script procedures and form functions.

 */

        websAspDefine(T("aspTest"), aspTest);

        websFormDefine(T("formTest"), formTest);

/*

 *      Create a handler for the default home page

 */

        websUrlHandlerDefine(T("/"), NULL, 0, websHomePageHandler, 0);

        return 0;

}

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

/*

 *      Test Javascript binding for ASP. This will be invoked when "aspTest" is

 *      embedded in an ASP page. See web/asp.asp for usage. Set browser to

 *      "localhost/asp.asp" to test.

 */

static int aspTest(int eid, webs_t wp, int argc, char_t **argv)

{

        char_t  *name, *address;

        if (ejArgs(argc, argv, T("%s %s"), &name, &address) < 2) {

                websError(wp, 400, T("Insufficient args\n"));

                return -1;

        }

        return websWrite(wp, T("Name: %s, Address %s"), name, address);

}

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

/*

 *      Test form for posted data (in-memory CGI). This will be called when the

 *      form in web/asp.asp is invoked. Set browser to "localhost/asp.asp" to test.

 */

static void formTest(webs_t wp, char_t *path, char_t *query)

{

        char_t  *name, *address;

        name = websGetVar(wp, T("name"), T("Joe Smith"));

        address = websGetVar(wp, T("address"), T("1212 Milky Way Ave."));

        websHeader(wp);

        websWrite(wp, T("<body><h2>Name: %s, Address: %s</h2>\n"), name, address);

        websFooter(wp);

        websDone(wp, 200);

}

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

/*

 *      Create a timer to invoke the routine in "delay" milliseconds.

 */

void *emfCreateTimer(int delay, void (*routine)(long arg),      long arg)

{

/* this variable is only used in the if'ed 0 section below */

#if 0

        struct sigaction        act;

#endif

        struct itimerspec its = { {0,0}, {0,0} };

        struct sigevent se;

        int     status;

        if ((tp = balloc(B_L, sizeof(websTimer_t)))) {

                tp->routine = routine;

                tp->arg = arg;

        }

        else {

                return NULL;

        }

        se.sigev_notify = SIGEV_THREAD;

        se.sigev_value.sival_ptr = tp;

        se.sigev_notify_function = (void (*)(union sigval)) timerProc;

        /*

         * NOT POSIX?

         * se.sigev_notify_attributes = NULL;

         */

        status = timer_create(CLOCK_REALTIME, &se, &timer_id);

        if (status != 0) {

                bfree(B_L, tp);

                return NULL;

        }

        /* convert delay millisecs to secs and usecs required by struct */

        its.it_value.tv_sec = delay / 1000;

        its.it_value.tv_nsec = (delay % 1000) * 1000000;

        status = timer_settime(timer_id, 0, &its, 0);

        if (status != 0) {

                bfree(B_L, tp);

                return NULL;

        }

#if 0

        act.sa_flags = 0;

        sigemptyset(&act.sa_mask);

        act.sa_handler = timerProc;

        sigaction(SIGALRM, &act, NULL);

        /* convert delay millisecs to secs and usecs required by struct */

        its.it_value.tv_sec = delay / 1000;

        its.it_value.tv_usec = (delay % 1000) * 1000;

        if (setitimer(ITIMER_REAL, &its, NULL) ==  -1) {

                bfree(B_L, tp);

                return NULL;

        }

#endif

        return tp;

}

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

/*

 *      Delete a timer

 */

void emfDeleteTimer(void * id)

{

        websTimer_t *wtp;

        /*struct itimerval its = { {0,0}, {0,0} };*/

        wtp = (websTimer_t *)id;

        /*      setitimer(ITIMER_REAL, &its, NULL);*/

        timer_delete(timer_id);

        bfree(B_L, wtp);

}

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

/*

 *      Timer handler

 */

static void timerProc(int signo)

{

        websTimer_t wtp = *tp;

/* Copy the timer structure to a local first and delete it before calling

 * the function, since the function could create another timer.  In this

 * implementation, only one timer can be allocated at a time.

 */

        bfree(B_L, tp);

        (wtp.routine)(wtp.arg);

}

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

/*

 *      Home page handler

 */

static int websHomePageHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,

        int arg, char_t* url, char_t* path, char_t* query)

{

/*

 *      If the empty or "/" URL is invoked, redirect default URLs to the home page

 */

        if (*url == '\0' || gstrcmp(url, T("/")) == 0) {

#if 0

                websRedirect(wp, T("home.asp"));

#else

                websRedirect(wp, T("index.html"));

#endif

                return 1;

        }

        return 0;

}

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

#if B_STATS

static void memLeaks()

{

        int             fd=1;

        /* if ((fd = gopen(T("leak.txt"), O_CREAT | O_TRUNC | O_WRONLY)) >= 0) { */

                bstats(fd, printMemStats);

                /*

                close(fd);

        }

                */

}

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

/*

 *      Print memory usage / leaks

 */

static void printMemStats(int handle, char_t *fmt, ...)

{

        va_list         args;

        char_t          buf[256];

        va_start(args, fmt);

        vsprintf(buf, fmt, args);

        va_end(args);

        write(handle, buf, strlen(buf));

}

#endif

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

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

/*

 *      Default error handler.  The developer should insert code to handle

 *      error messages in the desired manner.

 */

void defaultErrorHandler(int etype, char_t *msg)

{

#if 1

        write(1, msg, gstrlen(msg));

#endif

}

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

/*

 *      Trace log. Customize this function to log trace output

 */

void defaultTraceHandler(int level, char_t *buf)

{

/*

 *      The following code would write all trace regardless of level

 *      to stdout.

 */

#if 1

        if (buf) {

                write(1, buf, gstrlen(buf));

        }

#endif

}

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

/*

 *      Returns a pointer to an allocated qualified unique temporary file name.

 *      This filename must eventually be deleted with bfree();

 */

char_t *websGetCgiCommName()

{

        char_t  *pname1, *pname2;

        pname1 = tempnam(NULL, T("cgi"));

        pname2 = bstrdup(B_L, pname1);

        free(pname1);

        return pname2;

}