Single instance HTTP Server using new Ethernet Interface.

Dependents:   EthHTTPServer if201410_section5 _PE2E_12-04_EthernetInterfaceServer MGAS_GR_Peach ... more

Fork of WiFlyHTTPServer by Henry Leinen

Desciprtion of the library

Overview

This is an HTTPServer library using the new MBED EthernetInterface library. It allows you to :

  • serve files from any file System
  • use Remote procedure calls
  • extend the HTTPServer functionality according to your needs, using the provided handler classes or writing new classes. The following sections will give you a brief overview of how to use the library.

Usage description

You can use the library as file server, as RPC server or a combination of both. You can even define your own behaviour by deriving from one of the classes provided.

Use as file server

You may want to look at my sample application which allows you to serve files from the internal local storage of the mbed with no modifcation of the code :

Very simple example application

#include "mbed.h"
#include "HTTPServer.h"
#include "FsHandler.h"
#include "LocalFileSystem.h"

//  Use LED1 to indicate that the main loop is still executing
DigitalOut myled(LED1);
//  Use the serial connection 'pc' to dump debug information
Serial pc(USBTX, USBRX, "pc");
//  Instantiate a HTTPServer to handle incoming requests
HTTPServer  svr;
//  Instantiate a local file system handler named 'local' which will be used later to access files on the mbed.
LocalFileSystem local("local");


int main() {

    pc.baud(460800);
    HTTPFsRequestHandler::mount("/local/", "/");
    svr.addHandler<HTTPFsRequestHandler>("/");

    if (!svr.start()) {
       error("Server not starting !");
        exit(0);
    }
    
    while(1) {
        svr.poll();
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

Another alternative is to provide the EthernetInterface library to the HTTPServer library. This may be useful in case you need to perform other tasks with your internet connection. In this case it is necessary that you initialize the EthernetInterface and perform the connection prior to calling the start() method. Here is the example :

Sample application with re-use of existing EthernetInterface object

#include "mbed.h"
#include "HTTPServer.h"
#include "FsHandler.h"
#include "LocalFileSystem.h"
#include "EthernetInterface.h"


//  Use LED1 to indicate that the main loop is still executing
DigitalOut myled(LED1);
//  Use the serial connection 'pc' to dump debug information
Serial pc(USBTX, USBRX, "pc");
//  Instantiate a HTTPServer to handle incoming requests
HTTPServer  svr;
//  Instantiate a local file system handler named 'local' which will be used later to access files on the mbed.
LocalFileSystem local("local");
//  Create the EthernetInterface. This is optional, please see the documentation of HTTP Server's start method.
EthernetInterface eth;


int main() {

    pc.baud(460800);
    HTTPFsRequestHandler::mount("/local/", "/");
    svr.addHandler<HTTPFsRequestHandler>("/");

    //  Initialize the EthernetInterface and initiate a connection using DHCP.
    eth.init();
    eth.connect();

    // ***
    // TODO: Perform other Tasks using the ethernet connection here.
    // ****
    
    // Now start the server on port 80.
    if (!svr.start(80, &eth)) {
        error("Server not starting !");
        exit(0);
    }
    
    // The whole server activity is performed in this Loop. You can also put it into a separate RTOS Task and let it run there all the time.
    while(1) {
        svr.poll();
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

Use as remote procedure call (RPC) server

To access objects or resources via HTTP you can make use of the RPC functionality. Each object that shall be accessible via HTTP needs to be registered before use. Here is an example which Registers the DigitalOut class for use over RPC :

RPC usage over HTTPServer

#include "mbed.h"
#include "HTTPServer.h"
#include "RpcHandler.h"
#include "mbed_rpc.h"

//  Use LED1 to indicate that the main loop is still executing
DigitalOut myled(LED1);
//  Use the serial connection 'pc' to dump debug information
Serial pc(USBTX, USBRX, "pc");
//  Instantiate a HTTPServer to handle incoming requests
HTTPServer  svr;


int main() {

    pc.baud(460800);
    RPC::add_rpc_class<RpcDigitalOut>();
    svr.addHandler<HTTPRpcRequestHandler>("/RPC");
    
    if (!svr.start()) {
        error("Server not starting !");
        exit(0);
    }
    
    while(1) {
        svr.poll();
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

And using the above code, enter the following in the address field of your browser :

http://<your_mbed_ip>/RPC/DigitalOut/new LED4 myled4 - - > to create a new object of type DigitalOut on pin LED4 which can be referred to as 'myled4'.

and

http://<your_mbed_ip>/RPC/myled4/write 1 - - > to switch on the LED4.

Of course it is possible to Register your own objects with the standard MBED RPC functionality.

All the above Scenarios are implemented in a sample application, which will allow you to try out the functionality with basically no changes. If you want to try out the HTTP file Server, it is of course helpful to upload an html file to your MBED local storage.

Here is the sample application :

Import programEthHTTPServer

Working sample implementation for the EthernetInterface HTTPServer.

Future plans

Currently I am not considering to further extend this library. However, if someone needs extensions to this library, I will consider implementing them. Of course I will be taking care of bugfixes.

Known issues

Please note that the current implementation of the EthernetInterface seems to have an issue which results in unresponsive behaviour of the Sockets in some situations. This odd behaviour has not only been reported on my HTTPServer but also on other components using the EthernetInterface library.

Committer:
leihen
Date:
Sat Jun 01 16:49:17 2013 +0000
Revision:
6:fe661fa9d18a
Parent:
4:d065642c32cc
Child:
7:cb7fec1265b5
Added DEBUG preprocessor constant to each file.
; Added non-blocking polling function.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
leihen 1:6b7472d5e9ee 1 /* HTTPRequestHandler.cpp */
leihen 1:6b7472d5e9ee 2 #include "mbed.h"
leihen 1:6b7472d5e9ee 3 #include "HTTPRequestHandler.h"
leihen 1:6b7472d5e9ee 4
leihen 6:fe661fa9d18a 5 #define _DEBUG 0
leihen 6:fe661fa9d18a 6
leihen 6:fe661fa9d18a 7 #if (_DEBUG && !defined(TARGET_LPC11U24))
leihen 3:d6224049b3bf 8 #define INFO(x, ...) std::printf("[HTTPRequestHandler : DBG]"x"\r\n", ##__VA_ARGS__);
leihen 3:d6224049b3bf 9 #define WARN(x, ...) std::printf("[HTTPRequestHandler : DBG]"x"\r\n", ##__VA_ARGS__);
leihen 3:d6224049b3bf 10 #define ERR(x, ...) std::printf("[HTTPRequestHandler : DBG]"x"\r\n", ##__VA_ARGS__);
leihen 3:d6224049b3bf 11 #else
leihen 3:d6224049b3bf 12 #define INFO(x, ...)
leihen 3:d6224049b3bf 13 #define WARN(x, ...)
leihen 3:d6224049b3bf 14 #define ERR(x, ...)
leihen 3:d6224049b3bf 15 #endif
leihen 1:6b7472d5e9ee 16
leihen 3:d6224049b3bf 17 static char buffer[128];
leihen 3:d6224049b3bf 18
leihen 3:d6224049b3bf 19 HTTPRequestHandler::HTTPRequestHandler(HTTPConnection::HTTPMessage& Msg, TCPSocketConnection& Tcp)
leihen 3:d6224049b3bf 20 : msg(Msg), tcp(Tcp)
leihen 1:6b7472d5e9ee 21 {
leihen 3:d6224049b3bf 22 msg = Msg;
leihen 3:d6224049b3bf 23 tcp = Tcp;
leihen 1:6b7472d5e9ee 24 }
leihen 1:6b7472d5e9ee 25
leihen 1:6b7472d5e9ee 26 HTTPRequestHandler::~HTTPRequestHandler()
leihen 1:6b7472d5e9ee 27 {
leihen 3:d6224049b3bf 28 }
leihen 3:d6224049b3bf 29
leihen 3:d6224049b3bf 30 void HTTPRequestHandler::handleRequest()
leihen 3:d6224049b3bf 31 {
leihen 3:d6224049b3bf 32 int err = 0;
leihen 3:d6224049b3bf 33
leihen 3:d6224049b3bf 34 switch (msg.request) {
leihen 3:d6224049b3bf 35 case HTTP_RT_GET:
leihen 3:d6224049b3bf 36 INFO("Dispatching GET Request.");
leihen 3:d6224049b3bf 37 err = handleGetRequest();
leihen 3:d6224049b3bf 38 break;
leihen 3:d6224049b3bf 39
leihen 4:d065642c32cc 40 case HTTP_RT_POST:
leihen 4:d065642c32cc 41 INFO("Dispatching POST request.");
leihen 4:d065642c32cc 42 err = handlePostRequest();
leihen 4:d065642c32cc 43 break;
leihen 3:d6224049b3bf 44
leihen 4:d065642c32cc 45 case HTTP_RT_PUT:
leihen 4:d065642c32cc 46 INFO("Dispatching PUT request.");
leihen 4:d065642c32cc 47 err = handlePutRequest();
leihen 4:d065642c32cc 48 break;
leihen 3:d6224049b3bf 49
leihen 3:d6224049b3bf 50 default:
leihen 3:d6224049b3bf 51 INFO("Error in handleRequest, unhandled request type.");
leihen 3:d6224049b3bf 52 err = 404;
leihen 3:d6224049b3bf 53 break;
leihen 3:d6224049b3bf 54 }
leihen 3:d6224049b3bf 55
leihen 3:d6224049b3bf 56 // if any of these functions returns a negative number, call the error handler
leihen 3:d6224049b3bf 57 if (err > 0) {
leihen 3:d6224049b3bf 58 handleError(err);
leihen 3:d6224049b3bf 59 }
leihen 3:d6224049b3bf 60 }
leihen 3:d6224049b3bf 61
leihen 3:d6224049b3bf 62 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";
leihen 3:d6224049b3bf 63
leihen 3:d6224049b3bf 64 void HTTPRequestHandler::handleError(int errorCode, HTTPHeaders* header)
leihen 3:d6224049b3bf 65 {
leihen 3:d6224049b3bf 66 INFO("Handling error !");
leihen 3:d6224049b3bf 67 tcp.set_blocking(true, 1500);
leihen 3:d6224049b3bf 68 sprintf(buffer,"HTTP/1.1 %d Error\r\n", errorCode);
leihen 3:d6224049b3bf 69 tcp.send(buffer, strlen(buffer));
leihen 3:d6224049b3bf 70 sprintf(buffer, "Content-Length: %d\r\n", strlen(szErrorPage));
leihen 3:d6224049b3bf 71 tcp.send(buffer, strlen(buffer));
leihen 3:d6224049b3bf 72 if (header == NULL) {
leihen 3:d6224049b3bf 73 sprintf(buffer, "Content-Type: text/html\r\nServer: mbed embedded\r\n\n\r");
leihen 3:d6224049b3bf 74 tcp.send(buffer, strlen(buffer));
leihen 3:d6224049b3bf 75 }
leihen 3:d6224049b3bf 76 else {
leihen 3:d6224049b3bf 77 for ( map<const char*, const char*>::iterator cIter = header->begin() ; cIter != header->end() ; cIter ++) {
leihen 3:d6224049b3bf 78 tcp.send((char*)cIter->first, strlen(cIter->first));
leihen 3:d6224049b3bf 79 tcp.send(": ", 2);
leihen 3:d6224049b3bf 80 tcp.send((char*)cIter->second, strlen(cIter->second));
leihen 3:d6224049b3bf 81 tcp.send("\r\n",2);
leihen 3:d6224049b3bf 82 }
leihen 3:d6224049b3bf 83 tcp.send("\r\n",2);
leihen 3:d6224049b3bf 84 }
leihen 3:d6224049b3bf 85 tcp.send((char*)szErrorPage, strlen(szErrorPage));
leihen 3:d6224049b3bf 86 }
leihen 3:d6224049b3bf 87
leihen 3:d6224049b3bf 88
leihen 3:d6224049b3bf 89 void HTTPRequestHandler::startResponse(int returnCode, int nLen, HTTPHeaders* header)
leihen 3:d6224049b3bf 90 {
leihen 3:d6224049b3bf 91 INFO("Starting response !");
leihen 3:d6224049b3bf 92 tcp.set_blocking(true, 1500);
leihen 3:d6224049b3bf 93 sprintf(buffer, "HTTP/1.1 %d OK\r\n", returnCode);
leihen 3:d6224049b3bf 94 tcp.send(buffer, strlen(buffer));
leihen 3:d6224049b3bf 95 sprintf(buffer, "Content-Length: %d\r\n", nLen + 2); // Add 2 chars for the terminating CR+LF
leihen 3:d6224049b3bf 96 tcp.send(buffer, strlen(buffer));
leihen 3:d6224049b3bf 97 if (header == NULL) {
leihen 3:d6224049b3bf 98 sprintf(buffer, "Content-Type: text/html\r\nServer: mbed embedded\r\n\r\n");
leihen 3:d6224049b3bf 99 tcp.send(buffer, strlen(buffer));
leihen 3:d6224049b3bf 100 }
leihen 3:d6224049b3bf 101 else {
leihen 3:d6224049b3bf 102 for ( map<const char*, const char*>::iterator cIter = header->begin() ; cIter != header->end() ; cIter ++) {
leihen 3:d6224049b3bf 103 tcp.send((char*)cIter->first, strlen(cIter->first));
leihen 3:d6224049b3bf 104 tcp.send(": ", 2);
leihen 3:d6224049b3bf 105 tcp.send((char*)cIter->second, strlen(cIter->second));
leihen 3:d6224049b3bf 106 tcp.send("\r\n\r\n",2);
leihen 3:d6224049b3bf 107 }
leihen 3:d6224049b3bf 108 tcp.send("\r\n", 2);
leihen 3:d6224049b3bf 109 }
leihen 3:d6224049b3bf 110 // other content must be sent using the 'processResponse' function
leihen 3:d6224049b3bf 111 }
leihen 3:d6224049b3bf 112
leihen 3:d6224049b3bf 113 void HTTPRequestHandler::processResponse(int nLen, char* body)
leihen 3:d6224049b3bf 114 {
leihen 3:d6224049b3bf 115 INFO("Processing Response !");
leihen 3:d6224049b3bf 116 tcp.send(body, nLen);
leihen 3:d6224049b3bf 117 }
leihen 3:d6224049b3bf 118
leihen 3:d6224049b3bf 119 void HTTPRequestHandler::endResponse()
leihen 3:d6224049b3bf 120 {
leihen 3:d6224049b3bf 121 INFO("Ending Response !");
leihen 3:d6224049b3bf 122 tcp.send("\r\n", 2);
leihen 3:d6224049b3bf 123 }