Single instance HTTP Server using WiFly Interface.

Dependents:   WiFlyHTTPServerSample MultiThreadingHTTPServer

This is my implementation for a HTTP Server using the WiFly Interface. Please note that this is still under development.

It may still contain several bugs. I have tested it using a 1768 on an application board plus RN-XV board.

Currently there is only a FileSystem implemented. Also it is limited to GET request.

I try to extend it further so it will be more useful.

Btw, it does NOT work with RTOS, which seems not to be the Problem of my library.

Do not Forget to Import the WiFly Interface into your Project when using this library.

Change History:

REV5: - added support for basic RPC GET request functionality.

REV4: - added argument parsing from the request uri. - documentation extended and updated.

HTTPRequestHandler.cpp

Committer:
leihen
Date:
2013-06-05
Revision:
12:ba81cc117fb6
Parent:
11:3943841e1798
Child:
13:93ff322420b0

File content as of revision 12:ba81cc117fb6:

/* HTTPRequestHandler.cpp */
#include "mbed.h"
#include "HTTPRequestHandler.h"
#include <ctype.h>

#define _DEBUG 0

#if (_DEBUG && !defined(TARGET_LPC11U24))
#define INFO(x, ...) std::printf("[HTTPRequestHandler : DBG]"x"\r\n", ##__VA_ARGS__);
#define WARN(x, ...) std::printf("[HTTPRequestHandler : DBG]"x"\r\n", ##__VA_ARGS__);
#define ERR(x, ...) std::printf("[HTTPRequestHandler : DBG]"x"\r\n", ##__VA_ARGS__);
#else
#define INFO(x, ...)
#define WARN(x, ...)
#define ERR(x, ...)
#endif

static char buffer[128];


const char hdrDNT[] = "DNT: 1\r\n";
const char hdrMaxAge[] = "MaxAge: 0\r\n";
const char hdrConClose[] = "Connection: Keep-Alive\r\n";
//const char hdrTrsfrEnc[] = "Transfer-Encoding: Chunked\r\n";
const char hdrContent[] = "Content-Type: text/html\r\n";
const char hdrServer[] = "Server: mbed embedded\r\n";
const char hdrEndl[] = "\r\n";


static int _stricmp(const char* a, const char* b)
{
    int la = strlen(a);
    int lb = strlen(b);
    for (int i = 0 ; i < min(la, lb) ; i++) {
        if (tolower((int)a[i]) != tolower((int)b[i]))
            return i;
    }
    return 0;
}


static const struct mapping_t {
    const char* key;
    const char* value;
} fileTypeMapping[]  = {
        {".gif", "Content-Type: image/gif\r\n"   },
    {".jpg", "Content-Type: image/jpeg\r\n"  },
    {".jpeg","Content-Type: image/jpeg\r\n"  },
    {".ico", "Content-Type: image/x-icon\r\n"},
    {".png", "Content-Type: image/png\r\n"   },
    {".zip", "Content-Type: image/zip\r\n"   },
    {".gz",  "Content-Type: image/gz\r\n"    },
    {".tar", "Content-Type: image/tar\r\n"   },
    {".txt", "Content-Type: plain/text\r\n"  },
    {".pdf", "Content-Type: application/pdf\r\n" },
    {".htm", "Content-Type: text/html\r\n"   },
    {".html","Content-Type: text/html\r\n"   }};
    
HTTPRequestHandler::HTTPRequestHandler(HTTPConnection::HTTPMessage& Msg, TCPSocketConnection& Tcp)
    : msg(Msg), tcp(Tcp)
{
    msg = Msg;
    tcp = Tcp;

}

HTTPRequestHandler::~HTTPRequestHandler()
{
}

void HTTPRequestHandler::getStandardHeaders(HTTPHeaders& header, const char* fext)
{
    header.clear();
    header["DNT"] = "1";
    header["MaxAge"] = "0";
    header["Connection"] = "Keep-Alive";
    header["Server"] = "mbed Embedded";
    if (fext == NULL)
        header["Content-Type"] = "text/html";
    else {
        for (int i = 0 ; i < sizeof(fileTypeMapping)/sizeof(struct mapping_t) ;i++) {
            if (_stricmp(fileTypeMapping[i].key, fext) == 0) {
                header["Content-Type"] = fileTypeMapping[i].value;
                break;
            }
        }
    }
}

void HTTPRequestHandler::handleRequest()
{
    int err = 0;
    
    switch (msg.request) {
        case HTTP_RT_GET:
            INFO("Dispatching GET Request.");
            err = handleGetRequest();
            break;
            
        case HTTP_RT_POST:
            INFO("Dispatching POST request.");
            err = handlePostRequest();
            break;
            
        case HTTP_RT_PUT:
            INFO("Dispatching PUT request.");
            err = handlePutRequest();
            break;
            
        default:
            INFO("Error in handleRequest, unhandled request type.");
            err = HTTP_NotImplemented;
            break;
    }
    
    //  if any of these functions returns a negative number, call the error handler
    if (err > 0) {
        handleError(err);
    }        
}

static const char* szErrorPage = "<HTML><HEAD><META content=\"text/html\" http-equiv=Content-Type></HEAD><BODY><h1>Error %d</h1><P>HTTPServer Error<P></BODY></HTML>\r\n\r\n";

void HTTPRequestHandler::handleError(int errorCode, HTTPHeaders* header)
{
    INFO("Handling error !");
    tcp.set_blocking(true, 1500);
    sprintf(buffer,"HTTP/1.1 %d Error\r\n", errorCode);
    tcp.send(buffer, strlen(buffer));
    sprintf(buffer, "Content-Length: %d\r\n", strlen(szErrorPage));
    tcp.send(buffer, strlen(buffer));
    if (header == NULL) {
        sprintf(buffer, "Content-Type: text/html\r\nServer: mbed embedded\r\n\n\r");
        tcp.send(buffer, strlen(buffer));
    }
    else {
        for ( map<const char*, const char*>::iterator cIter = header->begin() ; cIter != header->end() ; cIter ++) {
            tcp.send((char*)cIter->first, strlen(cIter->first));
            tcp.send(": ", 2);
            tcp.send((char*)cIter->second, strlen(cIter->second));
            tcp.send("\r\n",2);
        }
        tcp.send("\r\n",2);
    }
    tcp.send((char*)szErrorPage, strlen(szErrorPage));
}


void HTTPRequestHandler::startResponse(int returnCode, long nLen, HTTPHeaders* header)
{
    INFO("Starting response (%ld bytes in total)!", nLen);
    tcp.set_blocking(true, 1500);
    sprintf(buffer, "HTTP/1.1 %d OK\r\n", returnCode);
    tcp.send_all(buffer, strlen(buffer));
    tcp.send_all((char*)hdrConClose, strlen(hdrConClose));
    sprintf(buffer, "Content-Length: %ld\r\n", nLen);    //  Add 2 chars for the terminating CR+LF
    tcp.send_all(buffer, strlen(buffer));
    if (header == NULL) {
        tcp.send_all((char*)hdrDNT, strlen(hdrDNT));
        tcp.send_all((char*)hdrMaxAge, strlen(hdrMaxAge));
        tcp.send_all((char*)hdrContent, strlen(hdrContent));
//        tcp.send_all((char*)hdrTrsfrEnc, strlen(hdrTrsfrEnc));
        tcp.send_all((char*)hdrServer, strlen(hdrServer));
        tcp.send_all((char*)hdrEndl, strlen(hdrEndl));
    }
    else {
        for ( map<const char*, const char*>::iterator cIter = header->begin() ; cIter != header->end() ; cIter ++) {
            tcp.send((char*)cIter->first, strlen(cIter->first));
            tcp.send(": ", 2);
            tcp.send((char*)cIter->second, strlen(cIter->second));
            tcp.send("\r\n\r\n",2);
        }
        tcp.send_all("\r\n", 2);
    }
    //  other content must be sent using the 'processResponse' function
}

void HTTPRequestHandler::processResponse(int nLen, char* body)
{
    INFO("Processing Response (%d bytes)!\n",nLen);
    tcp.send_all(body, nLen);
}

void HTTPRequestHandler::endResponse()
{
    INFO("Ending Response !");
//    tcp.send("\r\n\r\n", 4);
}