Zoltan Hudak / HTTPServer

HTTP Server library for Mbed OS-5. A fork of Henry Leinen's [[https://os.mbed.com/users/leihen/code/HTTPServer/]] library.

Dependents:   STM32F407VET6_HTTPServer

HTTPServer.cpp

Committer:
hudakz
Date:
2019-10-06
Revision:
17:8bcc62289a07
Parent:
16:cc3f5c53d0d5

File content as of revision 17:8bcc62289a07:

#include "mbed.h"
#include "HTTPServer.h"
#define DEBUG
#include "hl_debug.h"



/* Constructor */
/* initialize all members and set the standard error handler. */
HTTPServer::HTTPServer()
    : m_pEthernet(NULL)
{
    m_pErrorHandler = StdErrorHandler;
}

HTTPServer::~HTTPServer()
{
    if (m_pEthernet == NULL) {
        INFO("Deleting EthernetInterface Object.\n");
        delete m_pEthernet;
    }
}

static const char* szStdErrorPage = "<HTML><HEAD><META content=\"text/html\" http-equiv=Content-Type></HEAD><BODY><h1>Error 404</h1><P>This resource is not available<P></BODY></HTML>\r\n\r\n";

void HTTPServer::StdErrorHandler(HTTPConnection::HTTPMessage& msg, TCPSocket* tcp)
{
    char echoHeader[256];
    tcp->set_blocking(false);
    sprintf(echoHeader,"HTTP/1.0 404 Fail\r\nConnection: close\r\nContent-Length: %d\r\nContent-Type: text/html\r\nServer: mbed embedded\r\n\n\r",strlen(szStdErrorPage));
    tcp->send(echoHeader, strlen(echoHeader));
    tcp->send((char*)szStdErrorPage, strlen(szStdErrorPage));
}


bool HTTPServer::start(int port, EthernetInterface* pEthernet)
{
    //  If no ethernet interface is provided, instantiate own on the heap. This has to be deleted later in the destructor.
    //  If a valid pointer to an thernet interface is proveded, we can simply use it. 
    if (pEthernet == NULL) {
        ERR("Socket is not opened!!\r\n");
        
    } else {
        //  In the case that the ethernet interface is provided, it is assumed that a connection has already been created.
        INFO("Using connection IP %s", pEthernet->get_ip_address());
    }
    
    nsapi_error_t r;
    const char* ip = pEthernet->get_ip_address();

    /* Open the server on ethernet stack */
    INFO("Opening server on the Ethernet stack ...");
    r = m_Svr.open(pEthernet);
    if (r != 0) {
        INFO("Error! Opening server returned: %d\n", r);
        error("Opening server");
        return false;
    }

    INFO("Binding to port %d...", port);
    if (m_Svr.bind(ip, port) < 0) {
        ERR("Failed to bind to port !\n");
        error("Binding");
        return false;
    }

    if (m_Svr.listen(1) < 0) {
        ERR("Failed to listen !\n");
        error("Listening");
        return false;
    }

    INFO("Listening ...");
    //  set into non blocking operation after timeout
    m_Svr.set_timeout(1500);
    
    return true;
}


int HTTPServer::poll(bool blocking)
{
    //  This thread basically checks if there is a new incoming connection.
    //  If so , a new HTTPConnection is created and the connection thread is started.
    nsapi_error_t   error;
    SocketAddress   clntAddress;
    TCPSocket*      clnt = m_Svr.accept(&error);
    
    if (clnt == NULL) {
        return -1;
    }
    
    if (error != 0) {
        clnt->close();
        return error;
    }  

    //   a new connection was received
    clnt->getpeername(&clntAddress);
    INFO("Client (IP=%s) is connected !\n", clntAddress.get_ip_address());
    HTTPConnection con(clnt);
    int c = con.poll();
    if (c == 0) {
        //  Handle the request
        INFO("Handling request !");
        HandleRequest(con.m_Msg, clnt);
    }
    if (c == -1) {
//        break;
    }

    INFO("Leaving polling thread");
    return 0;
}

void HTTPServer::HandleRequest(HTTPConnection::HTTPMessage& msg, TCPSocket* tcp)
{
    std::string localPath;
    std::map<std::string, HTTPRequestHandler*(*)(const char*, const char*, HTTPConnection::HTTPMessage&, TCPSocket*), handlersComp>::const_iterator it;

    //  Iterate through registered handlers and check if the handler's path is a subset of the requested uri.
    for (it = m_lpHandlers.begin() ; it != m_lpHandlers.end() ; it++) {
        //  check if this entries' path is fully contained at the beginning of the requested path
        std::string curpth = it->first;

        if (msg.uri.find(curpth) == 0) {
            // firts matching handler found, we just take it and we'll be happy
            localPath = msg.uri.substr(curpth.length());
            break;
        }
    }

    if (it == m_lpHandlers.end()) {
        //  There is no such handler, so return invalid

        m_pErrorHandler(msg, tcp);
        INFO("Webrequest left unhandled.");
    } else {
        //  Valid handler was found
        INFO("Routing webrequest !");
        //  Instantiate the handler object (handling will be done from withing the object's constructor
        HTTPRequestHandler *phdl = (*it->second)(it->first.c_str(), localPath.c_str(), msg, tcp);
        //  now we can delete the object, because handling is completed.
        if (phdl != NULL)
            delete phdl;
    }
}