http_svr.c

Analog公司的ADSP_BF532上面实现以太网接口的源码

//##############################################################
//#
//# HTTP_SVR.C
//#
//# ADSP-21535 Embedded Web Server Project
//#
//# (c) ANALOG DEVICES 2002
//#     eDSP Division
//#     Stefan Hacker
//#     03-JAN-2003
//#
//# History:
//#     03-JAN-2003 initial document
//#     06-JAN-2003 fixed for any size document
//#     10-JAN-2003 provisions for multiple pages
//#     15-JAN-2003 support for CGI
//#     24-JAN-2003 CompactFLASH directory listing
//#     16-APR-2003 HS  release 1.0
//#

#include "ez_lan_types.h"
#include "http_svr.h"
#include "tcp_ip.h"
#include "globals.h"
#include "string.h"
#include "stdlib.h"
#include "stdio.h"
#include "defBF533.h"
#include "io_sprt.h"
#include "cf_ide.h"

#include "set_time.c"
#include "webside.c"

#define MC section("L1_code")

/******************************************************************************
 * HTTP_SVR: HTTPServer()
 *
 * Purpose:
 *  main function of simple HTTP server
 *
 * Actions:
 *
 *****************************************************************************/
MC void HTTPServer()
{
    BYTE    pagename[40];
    BYTE    cginame[20];
    BYTE    *TCP_buffer = (BYTE*)TCP_RxTCPBuffer;
    WORD    wtmp;
    int     i;

    // check if somebody has connected to our TCP
    if (!(TCP_SocketStatus & TCP_SOCK_CONNECTED))
    {
        // reset flags if not connected
        HTTP_Status &= ~(HTTP_SEND_PAGE|HTTP_CGI_INSERT|HTTP_DYN_INSERT|HTTP_FILE_SEND);
        return;
    }
    else
    {
        // check if remote TCP sent data
        if (!(HTTP_Status & HTTP_SEND_PAGE))

            // what to send
            if (!(TCP_SocketStatus & TCP_SOCK_DATA_AVAILABLE))
                // nothing, so
                return;

        // check if buffer is free for TX
        if (TCP_SocketStatus & TCP_SOCK_TX_BUF_RELEASED)
        {
            // if called for the first time, parse what to do
            if (!(HTTP_Status & HTTP_SEND_PAGE))
            {
                // currently flag error
                HTTP_BytesToSend = sizeof(error404)-1;
                HTTP_WebSide = error404;

                // HTTP request: what needs to be sent?
                if (!memcmp(&TCP_RxTCPBuffer, "GET ", 4))
                {
                    // move TCP_buffer past "GET "
                    TCP_buffer +=4;

                    // extract pagename
                    for(i=0; i < sizeof(pagename); i++ )
                    {
                        pagename[i] = *TCP_buffer;
                        if (*TCP_buffer == 0x20) break;
                        TCP_buffer++;
                    }

                    // parse pagename
                    if (!memcmp(&pagename, "/ ",2) | !memcmp(&pagename, "/index.html",11))
                    {
                        // get the length page and pointer
                        HTTP_BytesToSend = sizeof(WebSide)-1;
                        HTTP_WebSide = WebSide;
                    }
                    else if (!memcmp(&pagename, "/time.html ",10))
                    {
                        // get the length page and pointer
                        HTTP_BytesToSend = sizeof(set_time_html)-1;
                        HTTP_WebSide = set_time_html;
                    }
                    else if (!memcmp(&pagename, "/dtime.html ",11))
                    {
                        // get the length page and pointer
                        HTTP_BytesToSend = sizeof(dtime_html)-1;
                        HTTP_WebSide = dtime_html;

                        // insert dynamic values
                        HTTP_insert_dynamic(dtime_html, HTTP_BytesToSend);
                    }
                    else if (!memcmp(&pagename, "/cfdir/",7))
                    {
                        HTTP_WebSide = (BYTE*) HTTP_Buffer;
                        HTTP_BytesToSend = HTTP_parse_cf();
                    }
                    else if (!memcmp(&pagename, "/cf/",4))
                    {
                        HTTP_send_cffile(pagename+4);
                        if (ATA_CurFileSize != 0)
                        {
                            HTTP_WebSide = (BYTE*) HTTP_Buffer;
                            HTTP_BytesToSend = ATA_CurFileSize;
                        }
                    }
                }

                // CGI Bin request: which CGI to start?
                if (!memcmp(&TCP_RxTCPBuffer, "POST ", 5))
                {
                    // flag we're additionally doing CGI
                    HTTP_Status |= HTTP_CGI_INSERT;

                    // move TCP_buffer past "POST "
                    TCP_buffer +=5;

                    // extract cginame
                    for(i=0; i < sizeof(cginame); i++ )
                    {
                        cginame[i] = *TCP_buffer;
                        if (*TCP_buffer == 0x20) break;
                        TCP_buffer++;
                    }
                    // now check for the list of CGIs and react upon
                    if (!memcmp(cginame, "/set_time.pl", 12))
                    {
                        HTTP_parse_cgi_buffer(TCP_buffer, TCP_Rx_Data_Count-5-sizeof(cginame));

                        // set clock new
                        sys_time = sys_day<<24 | sys_hour<<16 | sys_min<<8 | sys_sec;
                        _outpd(RTC_STAT, sys_time);

                        // get the length page and pointer
                        HTTP_BytesToSend = sizeof(dtime_html)-1;
                        HTTP_WebSide = dtime_html;
                    }
                }

                // send header accordingly
                if (HTTP_Status & HTTP_FILE_SEND)
                {
                    switch(HTTP_FileType)
                    {
                        case PDF :
                        {
                            // copy GetResponse to transmit
                            memcpy(TCP_TX_BUF, GetPDFFile, GetPDFFileSize-1);

                            // set length of buffer
                            TCP_Tx_Data_Count = GetPDFFileSize-1;
                            break;
                        }
                        case JPEG :
                        {
                            // copy GetResponse to transmit
                            memcpy(TCP_TX_BUF, GetJPEGFile, GetJPEGFileSize-1);

                            // set length of buffer
                            TCP_Tx_Data_Count = GetJPEGFileSize-1;
                            break;
                        }
                        case HTML :
                        {
                            // copy GetResponse to transmit
                            memcpy(TCP_TX_BUF, GetResponse, GetResponseSize-1);

                            // set length of buffer
                            TCP_Tx_Data_Count = GetResponseSize-1;
                        }
                    }
                }
                else
                {
                    // copy GetResponse to transmit
                    memcpy(TCP_TX_BUF, GetResponse, GetResponseSize-1);

                    // set length of buffer
                    TCP_Tx_Data_Count = GetResponseSize-1;
                }
                // schedule buffer for transfer
                TCP_TransmitTxBuffer();

                // flag we're sending a page
                HTTP_Status |= HTTP_SEND_PAGE;
            }
            //////////////////////////////////////////////
            // the header is done, now let's send the body
            else
            {
                // now, depending on the page size either chunk or all
                if (HTTP_BytesToSend > MAX_TCP_TX_SIZE)
                {
                    if (HTTP_Status & HTTP_FILE_SEND)
                    {
                        // copy the buffer with cluster size
                        memcpy(TCP_TX_BUF, HTTP_WebSide, MAX_TCP_TX_SIZE);

                        // set the length accordingly
                        HTTP_BytesToSend -= MAX_TCP_TX_SIZE;

                        // bytes to transmit
                        TCP_Tx_Data_Count = MAX_TCP_TX_SIZE;

                        // schedule buffer for transfer
                        TCP_TransmitTxBuffer();
                        
                        for (i=0; i< 375; i++)
                            HTTP_Buffer[i] = 0;

                        // read new cluster
                        ATA_read_cluster(ATA_CurFilePtr, HTTP_Buffer);

                        // check for next cluster pointer
                        // is the FAT sector present?
                        if ((ATA_CurFilePtr>>8) != ATA_CurFATPtr)
                        {
                            ATA_CurFATPtr = ATA_CurFilePtr>>8;
                            ATA_read_fat_sector(ATA_CurFATPtr);
                        }
                        ATA_CurFilePtr = ATA_CurFATBuffer[(ATA_CurFilePtr&0xff)];
                    }
                    else
                    {
                        // copy the buffer with max_size
                        memcpy(TCP_TX_BUF, HTTP_WebSide, MAX_TCP_TX_SIZE);

                        // set the length accordingly
                        HTTP_BytesToSend -= MAX_TCP_TX_SIZE;

                        // move pointer in page
                        HTTP_WebSide += MAX_TCP_TX_SIZE;

                        // bytes to transmit
                        TCP_Tx_Data_Count = MAX_TCP_TX_SIZE;

                        // schedule buffer for transfer
                        TCP_TransmitTxBuffer();
                    }
                }
                else
                {