webport.c

/*
 * Copyright (C) 2002 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgement:
 *
 *    This product includes software developed by egnite Software GmbH
 *    and its contributors.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 */

/*
 * $Log$
 */

#define MYMAC   0x00, 0x06, 0x98, 0x00, 0x00, 0x00
#define MYIP    "192.168.192.100"
#define MYMASK  "255.255.255.0"


#include <string.h>
#include <stdio.h>
#include <io.h>

#ifdef ETHERNUT2
#include <dev/lanc111.h>
#else
#include <dev/nicrtl.h>
#endif
#include <dev/debug.h>
#include <dev/urom.h>

#include <sys/version.h>
#include <sys/confnet.h>
#include <sys/thread.h>
#include <sys/timer.h>
#include <sys/heap.h>

#include <dev/nicrtl.h>
#include <netinet/sostream.h>
#include <arpa/inet.h>

#include <pro/dhcp.h>
#include <pro/httpd.h>

#include "webport.h"

#define NUTDEBUG

#ifdef NUTDEBUG
#include <sys/osdebug.h>
#include <net/netdebug.h>
#endif

/*!
 * \addtogroup xgWebPort
 */
/*@{*/

/*!
 * \brief CPU reset macro.
 *
 * Start all over on fatal initialization errors.
 */
#define JUMP_RESET asm volatile("cli\n\tcall 0\n\t" ::)

/*!
 * \brief Process a single HTTP request.
 *
 * This routine performs the whole cycle of a HTTP request.
 *
 * - Creating a socket.
 * - Listening on the defined port.
 * - Processing the request.
 * - Closing the socket.
 */
void Service(void)
{
    TCPSOCKET *sock;    /* TCP socket pointer. */
    FILE *stream;       /* TCP stream. */

    /*
     * Let the Nut/OS library create a TCP socket for us.
     */
    if((sock = NutTcpCreateSocket()) != 0) {

        /*
         * Listen on the port defined in webport.h.
         */
        if(NutTcpAccept(sock, HTTP_PORT) == 0) {

            /*
             * The Nut/OS memory manager dynamically allocates
             * and releases SRAM space. In this application
             * most memory is used by incoming telegrams and
             * the socket interface. If the available space
             * becomes low, we sleep for 200 milliseconds and
             * try again. This way we will always leave some
             * RAM for more important parts of the system.
             * The watermark is defined in webport.h.
             */
            while(NutHeapAvailable() < LOW_MEM_MARK)
                NutSleep(200);

            /*
             * Create a stream from the socket, so we can use stdio.
             */
            if((stream = _fdopen((int) sock, "r+b")) != 0) {
                /*
                 * Process http request and close the stream when done.
                 */
                NutHttpProcessRequest(stream);
                fclose(stream);
            }
        }

        /*
         * Close the socket.
         */
        NutTcpCloseSocket(sock);
    }
}

/*! \fn ServiceThread(void *arg)
 * \brief Background thread to process HTTP requests.
 *
 * This thread calls Service() in an endless loop.
 */
THREAD(ServiceThread, arg)
{
    /*
     * Loop endless for connections.
     */
    for(;;) 
        Service();
}

/*!
 * \brief Main entry of our application.
 *
 * Nut/OS automatically calls this entry after initialization.
 * 
 * This routine will do all required initialization, start some
 * background threads and then process incoming HTTP requests together 
 * with the concurrently running background threads.
 */
int main(void)
{
    u_char i;
    u_char mac[] = { MYMAC };

#ifdef NUTDEBUG
    u_long baud = 115200;

    /*
     * Initialize the uart device.
     */
    NutRegisterDevice(&devDebug0, 0, 0);
    freopen("uart0", "w", stdout);
    _ioctl(_fileno(stdout), UART_SETSPEED, &baud);
    printf("\n\nNut/OS %s Webport Daemon...", NutVersionString());

    NutTraceTcp(stdout, 0);
    NutTraceOs(stdout, 0);
    NutTraceHeap(stdout, 0);
    NutSleep(2000);
#endif

    /*
     * Register Ethernet controller.
     */
    if(NutRegisterDevice(&DEV_ETHER, 0x8300, 5)) {
#ifdef NUTDEBUG
        puts("registering NIC failed");
#endif
    }

    /*
     * LAN configuration using EEPROM values or DHCP/ARP method.
     * If it fails, use fixed values.
     */
    if (NutDhcpIfConfig("eth0", mac, 60000)) {
        u_long ip_addr = inet_addr(MYIP);
        u_long ip_mask = inet_addr(MYMASK);

#ifdef NUTDEBUG
        puts("No DHCP");
#endif
        NutNetIfConfig("eth0", mac, ip_addr, ip_mask);
    }
#ifdef NUTDEBUG
    puts("started");
    if(confnet.cdn_cip_addr)
        printf("ip addr %s\n", inet_ntoa(confnet.cdn_cip_addr));
    else
        printf("ip addr %s\n", inet_ntoa(confnet.cdn_ip_addr));
    printf("ip mask %s\n", inet_ntoa(confnet.cdn_ip_mask));
    printf("ip gate %s\n", inet_ntoa(confnet.cdn_gateway));
#endif

    /*
     * Register our device for the file system.
     */
    NutRegisterDevice(&devUrom, 0, 0);

    /*
     * Register our CGI routines.
     */
    if(NutRegisterCgi(PORT_CONTROL_CGI, CpuPortControl))
        JUMP_RESET;
    if(NutRegisterCgi(PORT_STATUS_CGI, CpuPortStatus))
        JUMP_RESET;
    if(NutRegisterCgi(RELAY_CONTROL_CGI, SpiRelayControl))
        JUMP_RESET;
    if(NutRegisterCgi(OPTO_STATUS_CGI, SpiOptoStatus))
        JUMP_RESET;

    /*
     * Start a defined number of concurrent background
     * threads. The more threads we have running, the
     * more connections we can handle concurrently.
     * However, each thread occupies some additional
     * RAM.
     */
    for(i = 0; i < NUM_HTTP_THREADS - 1; i++) {
        char *thname = "httpd0";
        thname[5] = '0' + i;
        NutThreadCreate(thname, ServiceThread, 0, HTTP_THREAD_STACK);
    }

    /*
     * Loop endless for connections.
     */
    for(;;) 
        Service();
}

/*@}*/

---