HttpServer.h

Go to the documentation of this file.

#pragma once
 
#include <stdlib.h>
 
#include "Client.h"
#include "HardwareSerial.h"
#include "HttpChunkWriter.h"
#include "HttpHeader.h"
#include "HttpRequestHandlerLine.h"
#include "HttpRequestRewrite.h"
#include "IHttpServer.h"
#include "Server.h"
#include "basic/IPAddressAndPort.h"  // for toStr
#include "basic/List.h"
#include "basic/StrPrint.h"
 
namespace tiny_dlna {
 
template <typename ClientType, typename ServerType>
class HttpServer : public IHttpServer {
 public:
  HttpServer(ServerType& server, int bufferSize = 1024) {
    DlnaLogger.log(DlnaLogLevel::Info, "HttpServer");
    this->server_ptr = &server;
    this->buffer.resize(bufferSize);
  }
 
  ~HttpServer() override {
    DlnaLogger.log(DlnaLogLevel::Info, "~HttpServer");
    handler_collection.clear();
    request_header.clear(false);
    reply_header.clear(false);
    rewrite_collection.clear();
  }
 
  IPAddress& localIP() override {
    static IPAddress address;
    address = WiFi.localIP();
    return address;
  }
 
  bool begin() override {
    DlnaLogger.log(DlnaLogLevel::Info, "HttpServer begin");
    is_active = true;
    server_ptr->begin();
    return true;
  }
 
  void end() override {
    DlnaLogger.log(DlnaLogLevel::Info, "HttpServer %s", "stop");
    is_active = false;
  }
 
  void rewrite(const char* from, const char* to) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Rewriting %s to %s", from, to);
    HttpRequestRewrite* line = new HttpRequestRewrite(from, to);
    rewrite_collection.push_back(line);
  }
 
  void on(const char* url, TinyMethodID method, web_callback_fn fn,
          void* ctx[] = nullptr, int ctxCount = 0) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Serving at %s", url);
    HttpRequestHandlerLine* hl = new HttpRequestHandlerLine(ctxCount);
    hl->path = url;
    hl->fn = fn;
    hl->method = method;
    // hl->context = ctx;
    memmove(hl->context, ctx, ctxCount * sizeof(void*));
    hl->contextCount = ctxCount;
    addHandler(hl);
  }
 
  void on(const char* url, TinyMethodID method, const char* mime,
          web_callback_fn fn) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Serving at %s", url);
    HttpRequestHandlerLine* hl = new HttpRequestHandlerLine();
    hl->path = url;
    hl->fn = fn;
    hl->method = method;
    hl->mime = mime;
    addHandler(hl);
  }
 
  void on(const char* url, TinyMethodID method, const char* mime,
          const char* result) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Serving at %s", url);
 
    auto lambda = [](IHttpServer* server_ptr, const char* requestPath,
                     HttpRequestHandlerLine* hl) {
      DlnaLogger.log(DlnaLogLevel::Info, "on-strings %s", "lambda");
      if (hl->contextCount < 2) {
        DlnaLogger.log(DlnaLogLevel::Error, "The context is not available");
        return;
      }
      const char* mime = (const char*)hl->context[0];
      const char* msg = (const char*)hl->context[1];
      server_ptr->reply(mime, msg, 200);
    };
    HttpRequestHandlerLine* hl = new HttpRequestHandlerLine(2);
    hl->context[0] = (void*)mime;
    hl->context[1] = (void*)result;
    hl->path = url;
    hl->fn = lambda;
    hl->method = method;
    addHandler(hl);
  }
 
  void on(const char* url, TinyMethodID method, const char* mime,
          const uint8_t* data, int len) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Serving at %s", url);
 
    auto lambda = [](IHttpServer* server_ptr, const char* requestPath,
                     HttpRequestHandlerLine* hl) {
      DlnaLogger.log(DlnaLogLevel::Info, "on-strings %s", "lambda");
      if (hl->contextCount < 3) {
        DlnaLogger.log(DlnaLogLevel::Error, "The context is not available");
        return;
      }
      const char* mime = static_cast<char*>(hl->context[0]);
      const uint8_t* data = static_cast<uint8_t*>(hl->context[1]);
      int* p_len = (int*)hl->context[2];
      int len = *p_len;
      DlnaLogger.log(DlnaLogLevel::Debug, "Mime %d - Len: %d", mime, len);
      server_ptr->reply(mime, data, len, 200);
    };
    HttpRequestHandlerLine* hl = new HttpRequestHandlerLine(3);
    hl->context[0] = (void*)mime;
    hl->context[1] = (void*)data;
    hl->context[2] = new int(len);
    hl->path = url;
    hl->fn = lambda;
    hl->method = method;
    addHandler(hl);
  }
 
  void on(const char* url, TinyMethodID method, Url& redirect) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Serving at %s", url);
    auto lambda = [](IHttpServer* server_ptr, const char* requestPath,
                     HttpRequestHandlerLine* hl) {
      if (hl->contextCount < 1) {
        DlnaLogger.log(DlnaLogLevel::Error, "The context is not available");
        return;
      }
      DlnaLogger.log(DlnaLogLevel::Info, "on-redirect %s", "lambda");
      HttpReplyHeader reply_header;
      Url* url = static_cast<Url*>(hl->context[0]);
      reply_header.setValues(301, "Moved");
      reply_header.put(LOCATION, url->url());
      reply_header.put("X-Forwarded-Host", (const char*)hl->context[1]);
      reply_header.write(server_ptr->client());
      server_ptr->endClient();
    };
 
    HttpRequestHandlerLine* hl = new HttpRequestHandlerLine(2);
    const char* lh = localHost();
    hl->context[0] = new Url(redirect);
    hl->context[1] = (void*)lh;
    hl->path = url;
    hl->fn = lambda;
    hl->method = method;
    addHandler(hl);
  }
 
  bool onRequest(const char* path) override {
    DlnaLogger.log(DlnaLogLevel::Info, "Serving at %s", path);
 
    bool result = false;
    // check in registered handlers
    StrView pathStr = StrView(path);
    pathStr.replace("//", "/");  // TODO investiage why we get //
    for (auto handler_line_ptr : handler_collection) {
      DlnaLogger.log(DlnaLogLevel::Debug, "onRequest: %s %s vs: %s %s %s", path,
                     methods[request_header.method()],
                     nullstr(handler_line_ptr->path.c_str()),
                     methods[handler_line_ptr->method],
                     nullstr(handler_line_ptr->mime));
 
      if (pathStr.matches(handler_line_ptr->path.c_str()) &&
          request_header.method() == handler_line_ptr->method &&
          matchesMime(nullstr(handler_line_ptr->mime),
                      nullstr(request_header.accept()))) {
        // call registed handler function
        DlnaLogger.log(DlnaLogLevel::Debug, "onRequest %s", "->found",
                       nullstr(handler_line_ptr->path.c_str()));
        handler_line_ptr->fn(this, path, handler_line_ptr);
        result = true;
        break;
      }
    }
 
    if (!result) {
      DlnaLogger.log(DlnaLogLevel::Error, "Request %s not available", path);
    }
 
    return result;
  }
 
  void replyChunked(const char* contentType, Stream& inputStream,
                    int status = 200, const char* msg = SUCCESS) override {
    replyChunked(contentType, status, msg);
    HttpChunkWriter chunk_writer;
    while (inputStream.available()) {
      int len = inputStream.readBytes(buffer.data(), buffer.size());
      chunk_writer.writeChunk(*client_ptr, (const char*)buffer.data(), len);
    }
    // final chunk
    chunk_writer.writeEnd(*client_ptr);
    endClient();
  }
 
  void replyChunked(const char* contentType, int status = 200,
                    const char* msg = SUCCESS) override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s", "replyChunked");
    reply_header.setValues(status, msg);
    reply_header.put(TRANSFER_ENCODING, CHUNKED);
    reply_header.put(CONTENT_TYPE, contentType);
    reply_header.put(CONNECTION, CON_KEEP_ALIVE);
    reply_header.write(this->client());
  }
 
  void reply(const char* contentType, Stream& inputStream, int size,
             int status = 200, const char* msg = SUCCESS) override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s", "stream");
    reply_header.setValues(status, msg);
    reply_header.put(CONTENT_LENGTH, size);
    reply_header.put(CONTENT_TYPE, contentType);
    reply_header.put(CONNECTION, CON_KEEP_ALIVE);
    reply_header.write(this->client());
 
    while (inputStream.available()) {
      int len = inputStream.readBytes(buffer.data(), buffer.size());
      int written = client_ptr->write((const uint8_t*)buffer.data(), len);
    }
    // inputStream.close();
    endClient();
  }
 
  void reply(const char* contentType, size_t (*callback)(Print& out, void* ref),
             int status = 200, const char* msg = SUCCESS,
             void* ref = nullptr) override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s", "via callback");
    NullPrint nop;
    size_t size = callback(nop, ref);
    reply_header.setValues(status, msg);
    reply_header.put(CONTENT_TYPE, contentType);
    reply_header.put(CONTENT_LENGTH, size);
    reply_header.put(CONNECTION, CON_KEEP_ALIVE);
    reply_header.write(this->client());
    callback(*client_ptr, ref);
#if DLNA_LOG_XML
    callback(Serial, ref);
#endif
#if DLNA_CHECK_XML_LENGTH
    StrPrint test;
    size_t test_len = callback(test, ref);
    if (strlen(test.c_str()) != size) {
      DlnaLogger.log(DlnaLogLevel::Error,
                      "HttpServer wrote %d bytes: expected %d / strlen: %d", test_len, size, strlen(test.c_str()));
    }   
#endif      
 
    endClient();
  }
 
  void reply(const char* contentType, const char* str, int status = 200,
             const char* msg = SUCCESS) override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s", str);
    int len = strlen(str);
    reply_header.setValues(status, msg);
    reply_header.put(CONTENT_LENGTH, len);
    reply_header.put(CONTENT_TYPE, contentType);
    reply_header.put(CONNECTION, CON_KEEP_ALIVE);
    reply_header.write(this->client());
    client_ptr->write((const uint8_t*)str, len);
    endClient();
  }
 
  void reply(const char* contentType, const uint8_t* str, int len,
             int status = 200, const char* msg = SUCCESS) override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s: %d bytes", contentType, len);
    reply_header.setValues(status, msg);
    reply_header.put(CONTENT_LENGTH, len);
    reply_header.put(CONTENT_TYPE, contentType);
    reply_header.put(CONNECTION, CON_KEEP_ALIVE);
    reply_header.write(this->client());
    client_ptr->write((const uint8_t*)str, len);
    endClient();
  }
 
  void replyOK() override { reply(200, SUCCESS); }
 
  void replyNotFound() override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s", "404");
    reply(404, "Page Not Found");
  }
 
  void replyError(int err, const char* msg = "Internal Server Error") override {
    DlnaLogger.log(DlnaLogLevel::Info, "reply %s", "error");
    reply(err, msg);
  }
 
  HttpRequestHeader& requestHeader() override { return request_header; }
 
  HttpReplyHeader& replyHeader() override { return reply_header; }
 
  void endClient() override {
    DlnaLogger.log(DlnaLogLevel::Info, "HttpServer %s", "endClient");
    // client_ptr->flush();
    client_ptr->stop();
  }
 
  void crlf() override {
    client_ptr->print("\r\n");
    // client_ptr->flush();
  }
 
  void addHandler(HttpRequestHandlerLine* handlerLinePtr) override {
    handler_collection.push_back(handlerLinePtr);
  }
 
  bool doLoop() override { return copy(); }
 
  bool copy() override {
    bool result = false;
    if (!is_active) {
      delay(no_connect_delay);
      return false;
    }
 
    // Accept new client and add to list if connected
    ClientType client = server_ptr->accept();
    if (client.connected()) {
      DlnaLogger.log(DlnaLogLevel::Info, "copy: accepted new client");
      client.setTimeout(DLNA_HTTP_REQUEST_TIMEOUT_MS);
      open_clients.push_back(client);
    }
 
    // Stop when nothing to process
    if (open_clients.empty()) {
      // delay(no_connect_delay);
      return false;
    }
 
    if (current_client_iterator == open_clients.end()) {
      current_client_iterator = open_clients.begin();
      if (current_client_iterator == open_clients.end()) {
        delay(no_connect_delay);
        return false;
      }
    }
 
    client_ptr = &(*current_client_iterator);
    if (!client_ptr->connected()) {
      DlnaLogger.log(DlnaLogLevel::Debug, "copy: removing disconnected client");
      current_client_iterator = open_clients.erase(current_client_iterator);
      // Do not advance iterator here; erase returns the next valid iterator
      return false;
    }
 
    processRequest();
    result = true;
    ++current_client_iterator;
    if (current_client_iterator == open_clients.end() &&
        !open_clients.empty()) {
      current_client_iterator = open_clients.begin();
    }
 
    // cleanup clients
    removeClosedClients();
 
    return result;
  }
 
  ClientType& client() override { return *client_ptr; }
 
  operator bool() override { return is_active; }
 
  bool isActive() override { return is_active; }
 
  const char* localHost() override {
    if (local_host == nullptr) {
      local_host = toStr(WiFi.localIP());
    }
    return local_host;
  }
 
  void setNoConnectDelay(int delay) override { no_connect_delay = delay; }
 
  Str contentStr() override {
    uint8_t buffer[1024];
    Str result;
    while (client_ptr->available()) {
      int len = client_ptr->readBytes(buffer, sizeof(buffer));
      result.add((const uint8_t*)buffer, len);
    }
    result.add("\0");
    return result;
  }
 
  void setReference(void* reference) override { ref = reference; }
 
  void* getReference() override { return ref; }
 
 protected:
  // data
  HttpRequestHeader request_header;
  HttpReplyHeader reply_header;
  List<HttpRequestHandlerLine*> handler_collection;
  List<HttpRequestRewrite*> rewrite_collection;
  List<ClientType> open_clients;
  typename List<ClientType>::Iterator current_client_iterator =
      open_clients.begin();
  ClientType* client_ptr = nullptr;
  ServerType* server_ptr = nullptr;
  bool is_active;
  Vector<char> buffer{0};
  const char* local_host = nullptr;
  int no_connect_delay = 5;
  void* ref = nullptr;
 
  /* Remove all closed/disconnected clients from the open_clients list.
   * This also keeps `current_client_iterator` valid by advancing it to
   * the next element when the erased element equals the current iterator.
   */
  void removeClosedClients() {
    auto it = open_clients.begin();
    while (it != open_clients.end()) {
      if ((!(*it).connected())) {
        auto next = open_clients.erase(it);
        if (current_client_iterator == it) {
          current_client_iterator = next;
        }
        it = next;
      } else {
        ++it;
      }
    }
    if (open_clients.empty()) {
      current_client_iterator = open_clients.begin();
    }
  }
 
  void reply(int status, const char* msg) {
    reply_header.setValues(status, msg);
    reply_header.write(this->client());
    endClient();
  }
 
  const char* nullstr(const char* in) { return in == nullptr ? "" : in; }
 
  // process a full request and send the reply
  void processRequest() {
    DlnaLogger.log(DlnaLogLevel::Info, "processRequest");
    request_header.read(this->client());
    // provide reply with empty header
    reply_header.clear();
    // determine the path
    const char* path = request_header.urlPath();
    path = resolveRewrite(path);
    bool processed = onRequest(path);
    if (!processed) {
      replyNotFound();
    }
  }
 
  const char* resolveRewrite(const char* from) {
    for (auto i = rewrite_collection.begin(); i != rewrite_collection.end();
         ++i) {
      HttpRequestRewrite* rewrite = (*i);
      if (rewrite->from.matches(from)) {
        return rewrite->to.c_str();
      }
    }
    return from;
  }
 
  bool matchesMime(const char* handler_mime, const char* request_mime) {
    DlnaLogger.log(DlnaLogLevel::Debug, "matchesMime: %s vs %s", handler_mime,
                   request_mime);
    if (StrView(handler_mime).isEmpty() || StrView(request_mime).isEmpty()) {
      return true;
    }
    bool result = StrView(request_mime).contains(handler_mime);
    return result;
  }
};
 
using WiFiHttpServer = HttpServer<WiFiClient, WiFiServer>;
 
}  // namespace tiny_dlna