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 Aug 17 16:17:55 2013 +0000
Revision:
16:cc3f5c53d0d5
Parent:
13:aa5338a5e452
- Removed old Debug message helper macros and replaced them with new hl_debug.h macros.
; - Renamed debug.h file to hl_debug.h to avoid conflict with EthernetInterface.
; - Fixed incorrectly used debug macro where an ERR was used instead of an INFO

Who changed what in which revision?

UserRevisionLine numberNew contents of line
leihen 0:7a2421e63e74 1 /* HTTPConnection.h */
leihen 3:d6224049b3bf 2 /*
leihen 3:d6224049b3bf 3 Copyright (c) 2013 Henry Leinen (henry[dot]leinen [at] online [dot] de)
leihen 3:d6224049b3bf 4
leihen 3:d6224049b3bf 5 Permission is hereby granted, free of charge, to any person obtaining a copy
leihen 3:d6224049b3bf 6 of this software and associated documentation files (the "Software"), to deal
leihen 3:d6224049b3bf 7 in the Software without restriction, including without limitation the rights
leihen 3:d6224049b3bf 8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
leihen 3:d6224049b3bf 9 copies of the Software, and to permit persons to whom the Software is
leihen 3:d6224049b3bf 10 furnished to do so, subject to the following conditions:
leihen 3:d6224049b3bf 11
leihen 3:d6224049b3bf 12 The above copyright notice and this permission notice shall be included in
leihen 3:d6224049b3bf 13 all copies or substantial portions of the Software.
leihen 3:d6224049b3bf 14
leihen 3:d6224049b3bf 15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
leihen 3:d6224049b3bf 16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
leihen 3:d6224049b3bf 17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
leihen 3:d6224049b3bf 18 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
leihen 3:d6224049b3bf 19 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
leihen 3:d6224049b3bf 20 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
leihen 3:d6224049b3bf 21 THE SOFTWARE.
leihen 3:d6224049b3bf 22 */
leihen 0:7a2421e63e74 23 #ifndef __HTTPConnection_H__
leihen 0:7a2421e63e74 24 #define __HTTPConnection_H__
leihen 0:7a2421e63e74 25
leihen 0:7a2421e63e74 26 #include "mbed.h"
leihen 0:7a2421e63e74 27 #include "TCPSocketConnection.h"
leihen 0:7a2421e63e74 28
leihen 0:7a2421e63e74 29 #include <string>
leihen 0:7a2421e63e74 30 #include <map>
leihen 0:7a2421e63e74 31
leihen 1:6b7472d5e9ee 32 class HTTPServer;
leihen 1:6b7472d5e9ee 33
leihen 3:d6224049b3bf 34 /** Type HTTPRequestType enumerates request types
leihen 3:d6224049b3bf 35 */
leihen 3:d6224049b3bf 36 typedef enum
leihen 0:7a2421e63e74 37 {
leihen 3:d6224049b3bf 38 HTTP_RT_GET, /*!< GET request */
leihen 3:d6224049b3bf 39 HTTP_RT_POST, /*!< POST request */
leihen 3:d6224049b3bf 40 HTTP_RT_PUT, /*!< PUT request */
leihen 3:d6224049b3bf 41 HTTP_RT_OPTIONS, /*!< OPTIONS request */
leihen 3:d6224049b3bf 42 HTTP_RT_HEAD, /*!< HEAD request */
leihen 3:d6224049b3bf 43 HTTP_RT_DELETE, /*!< DELETE request */
leihen 3:d6224049b3bf 44 HTTP_RT_TRACE, /*!< TRACE request */
leihen 3:d6224049b3bf 45 HTTP_RT_CONNECT /*!< CONNECT request */
leihen 3:d6224049b3bf 46 } HTTPRequestType;
leihen 0:7a2421e63e74 47
leihen 0:7a2421e63e74 48 /** class HTTPConnection, encapsulates one connection being made throught the HTTPServer
leihen 0:7a2421e63e74 49 *
leihen 0:7a2421e63e74 50 */
leihen 0:7a2421e63e74 51 class HTTPConnection {
leihen 0:7a2421e63e74 52 public:
leihen 3:d6224049b3bf 53
leihen 3:d6224049b3bf 54 /** HTTPMessage contains all the details of the request received by external HTTP client.
leihen 3:d6224049b3bf 55 */
leihen 3:d6224049b3bf 56 typedef struct
leihen 3:d6224049b3bf 57 {
leihen 3:d6224049b3bf 58 /** Specifies the request type received
leihen 3:d6224049b3bf 59 */
leihen 4:d065642c32cc 60 HTTPRequestType request;
leihen 3:d6224049b3bf 61 /** The uri associated with the request.
leihen 3:d6224049b3bf 62 */
leihen 4:d065642c32cc 63 std::string uri;
leihen 3:d6224049b3bf 64 /** Contains the HTTP/1.1 or HTTP/1.0 version requested by client.
leihen 3:d6224049b3bf 65 */
leihen 4:d065642c32cc 66 std::string version;
leihen 3:d6224049b3bf 67 /** Map of headers provided by the client in the form <HeaderName>:<HeaderValue>
leihen 3:d6224049b3bf 68 */
leihen 4:d065642c32cc 69 std::map<std::string, std::string> headers;
leihen 4:d065642c32cc 70 /** Map of arguments that came with the uri string
leihen 4:d065642c32cc 71 */
leihen 4:d065642c32cc 72 std::map<std::string, std::string> args;
leihen 3:d6224049b3bf 73 } HTTPMessage;
leihen 4:d065642c32cc 74
leihen 3:d6224049b3bf 75 /** Public constructor for HTTPConnection objects.
leihen 3:d6224049b3bf 76 *
leihen 3:d6224049b3bf 77 */
leihen 13:aa5338a5e452 78 HTTPConnection (TCPSocketConnection& clnt);
leihen 3:d6224049b3bf 79
leihen 3:d6224049b3bf 80 /** Destructor for HTTPConnection objects.
leihen 3:d6224049b3bf 81 *
leihen 3:d6224049b3bf 82 */
leihen 3:d6224049b3bf 83 ~HTTPConnection();
leihen 3:d6224049b3bf 84
leihen 3:d6224049b3bf 85 /** Query if this connection is already closed and can be deleted.
leihen 3:d6224049b3bf 86 @returns true, if connection is closed.
leihen 3:d6224049b3bf 87 */
leihen 3:d6224049b3bf 88 bool is_closed();
leihen 3:d6224049b3bf 89
leihen 3:d6224049b3bf 90 /** Polling function for the connection.
leihen 3:d6224049b3bf 91 * @returns -1 if connection is not required anymore. In the current version of this library this should be the normal case. This may change in future versions.
leihen 3:d6224049b3bf 92 */
leihen 3:d6224049b3bf 93 int poll();
leihen 0:7a2421e63e74 94
leihen 0:7a2421e63e74 95 protected:
leihen 3:d6224049b3bf 96
leihen 3:d6224049b3bf 97 /** Function to close this connection. To be called from internally.
leihen 3:d6224049b3bf 98 */
leihen 3:d6224049b3bf 99 void close();
leihen 3:d6224049b3bf 100
leihen 1:6b7472d5e9ee 101 friend class HTTPServer;
leihen 1:6b7472d5e9ee 102
leihen 0:7a2421e63e74 103 TCPSocketConnection m_Tcp;
leihen 1:6b7472d5e9ee 104 HTTPMessage m_Msg;
leihen 4:d065642c32cc 105
leihen 4:d065642c32cc 106 /** parse a HTTP request line from the content of the buffer.
leihen 4:d065642c32cc 107 * @param buffer : the request received from the client in the form <RequestType> <uri> <Http Version>
leihen 4:d065642c32cc 108 * @returns -1 if the request is invalid or 0 if the request is valid
leihen 4:d065642c32cc 109 */
leihen 2:8653bbcf7e58 110 int parse(char *buffer);
leihen 4:d065642c32cc 111
leihen 4:d065642c32cc 112 /** parses the received string in \c buffer for HTTP request headers.
leihen 4:d065642c32cc 113 * @param buffer : buffer which contains the string to parse for headers.
leihen 4:d065642c32cc 114 * @returns -1 in case of an error, otherwise returns 0
leihen 4:d065642c32cc 115 */
leihen 3:d6224049b3bf 116 int parseHeader(char *buffer);
leihen 0:7a2421e63e74 117 int receiveHeaders(const char* buffer, int nBuffSize);
leihen 4:d065642c32cc 118
leihen 4:d065642c32cc 119 /** Function which receives a line from the current Socket
leihen 4:d065642c32cc 120 * @param szline : will contain one line received from the socket
leihen 4:d065642c32cc 121 * @param nMaxLen : the size of the buffer. If the line is longer than the buffer the line is cropped at the end.
leihen 4:d065642c32cc 122 * @param nTimeout : if the timeout elapses, only the portion that has been received within this time will be returned.
leihen 4:d065642c32cc 123 * @param szLineTerm : the \c end-of-line character to be used to detect the end of the line.
leihen 4:d065642c32cc 124 * @returns -1 in case of an error or timeout, -2 in case of an empty line or the number of received characters.
leihen 4:d065642c32cc 125 */
leihen 0:7a2421e63e74 126 int receiveLine(char* szLine, int nMaxLen, int nTimeout = -1, char szLineTerm = '\n');
leihen 0:7a2421e63e74 127
leihen 4:d065642c32cc 128
leihen 4:d065642c32cc 129 /** parse the receoved \c uri_string for arguments which will be stored in the \c args map.
leihen 4:d065642c32cc 130 * @parse uri_string : the uri string which was received from the client.
leihen 4:d065642c32cc 131 * @parse args : the args map which will receive the argument:value touples from the \c uri_string.
leihen 4:d065642c32cc 132 * @returns -1 if an error occured, otherwise returns 0.
leihen 4:d065642c32cc 133 */
leihen 4:d065642c32cc 134 int parseUriArgs(char *uri_string, map<string,string>& args);
leihen 4:d065642c32cc 135
leihen 0:7a2421e63e74 136 };
leihen 0:7a2421e63e74 137
leihen 0:7a2421e63e74 138 #endif // __HTTPConnection_H__