HttpParameters.h

Go to the documentation of this file.

#pragma once
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
 
#include "Stream.h"
#include "basic/Logger.h"
#include "basic/Str.h"
#include "basic/Vector.h"
 
namespace tiny_dlna {
 
class HttpParameters {
  struct HttpParameterEntry {
    HttpParameterEntry() = default;
    Str key = nullptr;
    Str value = nullptr;
    void clear() {
      key.clear();
      value.clear();
    }
  };
 
 public:
  HttpParameters(const int maxLen = 256) { max_len = maxLen; };
 
  ~HttpParameters() { clear(); }
 
  void parse(Stream &in) {
    char buffer[max_len];
    while (in.available() > 0) {
      memset(buffer, 0, max_len);
      in.readBytesUntil('&', buffer, max_len);
      StrView str(buffer);
      DlnaLogger.log(DlnaLogLevel::Info, "parameter: %s", buffer);
      urldecode2(buffer, buffer);
      DlnaLogger.log(DlnaLogLevel::Info, "parameter decoded: %s", buffer);
      int pos = str.indexOf("=");
      if (pos > 0) {
        buffer[pos] = 0;  // delimit key
        const char *key = buffer;
        const char *value = buffer + pos + 1;
        DlnaLogger.log(DlnaLogLevel::Debug, "key: %s", key);
        DlnaLogger.log(DlnaLogLevel::Debug, "value: %s", value);
        HttpParameterEntry *entry = getParameter(key);
        if (entry != nullptr) {
          entry->value = value;
        } else {
          entry = new HttpParameterEntry();
          entry->key = key;
          entry->value = value;
          parameters.push_back(entry);
        }
      }
    }
  }
 
  void parse(Stream &in, void (*callback)(const char *key, const char *value)) {
    char buffer[max_len];
    while (in.available() > 0) {
      memset(buffer, 0, max_len);
      in.readBytesUntil('&', buffer, max_len);
      StrView str(buffer);
      DlnaLogger.log(DlnaLogLevel::Info, "parameter: %s", buffer);
      urldecode2(buffer, buffer);
      DlnaLogger.log(DlnaLogLevel::Info, "parameter decoded: %s", buffer);
      int pos = str.indexOf("=");
      if (pos > 0) {
        buffer[pos] = 0;  // delimit key
        const char *key = buffer;
        const char *value = buffer + pos + 1;
        callback(key, value);
      }
    }
  }
 
  bool hasKey(const char *key) {
    for (auto &entry : parameters) {
      if (entry->key.equals(key)) {
        return true;
      }
    }
    return false;
  }
 
  HttpParameterEntry *getParameter(const char *key) {
    for (auto &entry : parameters) {
      if (entry->key.equals(key)) {
        return entry;
      }
    }
    return nullptr;
  }
 
  const char *getValue(const char *key) {
    for (auto &entry : parameters) {
      if (entry->key.equals(key)) {
        return entry->value.c_str();
      }
    }
    return nullptr;
  }
 
  float getFloat(const char *key) {
    for (auto &entry : parameters) {
      if (entry->key.equals(key)) {
        return entry->value.toFloat();
      }
    }
    return 0;
  }
 
  int getInt(const char *key) {
    for (auto &entry : parameters) {
      if (entry->key.equals(key)) {
        return entry->value.toInt();
      }
    }
    return 0;
  }
 
  void clear() {
    for (auto entry : parameters) {
      delete entry;
    }
    parameters.clear();
  }
 
 protected:
  Vector<HttpParameterEntry *> parameters;
  int max_len;
 
  void urldecode2(char *dst, const char *src) {
    char a, b;
    while (*src) {
      if ((*src == '%') && ((a = src[1]) && (b = src[2])) &&
          (isxdigit(a) && isxdigit(b))) {
        if (a >= 'a') a -= 'a' - 'A';
        if (a >= 'A')
          a -= ('A' - 10);
        else
          a -= '0';
        if (b >= 'a') b -= 'a' - 'A';
        if (b >= 'A')
          b -= ('A' - 10);
        else
          b -= '0';
        *dst++ = 16 * a + b;
        src += 3;
      } else if (*src == '+') {
        *dst++ = ' ';
        src++;
      } else {
        *dst++ = *src++;
      }
    }
    *dst++ = '\0';
  }
};
 
}  // namespace tiny_dlna