util.hpp

#ifndef XXHR_UTIL_H
#define XXHR_UTIL_H

#include <cctype>
#include <cstdint>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>

#include <boost/xpressive/xpressive.hpp>
#include <boost/archive/iterators/binary_from_base64.hpp>
#include <boost/archive/iterators/base64_from_binary.hpp>
#include <boost/archive/iterators/transform_width.hpp>
#include <boost/algorithm/string.hpp>

#include "xxhrtypes.hpp"


namespace xxhr {
namespace util {
 
  inline Header parseHeader(const std::string& headers);
  inline size_t writeFunction(void* ptr, size_t size, size_t nmemb, std::string* data);
  inline std::vector<std::string> split(const std::string& to_split, char delimiter);

  inline std::string urlEncode(const std::string& response);
  inline std::string decode64(const std::string &val);
  inline std::string encode64(const std::string &val);

  struct url_parts {

    std::string protocol;

    std::string host;

    std::string port;

    std::string path;

    std::string parameters;

    std::string fragment;

    bool https() const {
      return protocol == "https";
    }
  };

  inline url_parts parse_url(const std::string &url);

} // namespace util
} // namespace xxhr


/*
 * Implementation
 */

namespace xxhr { 
namespace util {

  inline Header parseHeader(const std::string& headers) {
    Header header;
    std::vector<std::string> lines;
    std::istringstream stream(headers);
    {
        std::string line;
        while (std::getline(stream, line, '\n')) {
            lines.push_back(line);
        }
    }

    for (auto& line : lines) {
        if (line.substr(0, 5) == "HTTP/") {
            header.clear();
        }

        if (line.length() > 0) {
            auto found = line.find(":");
            if (found != std::string::npos) {
                auto value = line.substr(found + 2, line.length() - 1);
                if (value.back() == '\r') {
                    value = value.substr(0, value.length() - 1);
                }
                header[line.substr(0, found)] = value;
            }
        }
    }

    return header;
  }

  std::vector<std::string> split(const std::string& to_split, char delimiter) {
    std::vector<std::string> tokens;

    std::stringstream stream(to_split);
    std::string item;
    while (std::getline(stream, item, delimiter)) {
        tokens.push_back(item);
    }

    return tokens;
  }

  inline size_t writeFunction(void* ptr, size_t size, size_t nmemb, std::string* data) {
    data->append((char*) ptr, size * nmemb);
    return size * nmemb;
  }

  inline std::string urlEncode(const std::string& value) {
    std::ostringstream escaped;
    escaped.fill('0');
    escaped << std::hex;

    for (auto i = value.cbegin(), n = value.cend(); i != n; ++i) {
        std::string::value_type c = (*i);
        // Keep alphanumeric and other accepted characters intact
        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
            escaped << c;
            continue;
        }
        // Any other characters are percent-encoded
        escaped << '%' << std::setw(2) << std::int32_t((unsigned char) c);
    }

    return escaped.str();
  }

  inline std::string decode64(const std::string &val) {
      using namespace boost::archive::iterators;
      using It = transform_width<binary_from_base64<std::string::const_iterator>, 8, 6>;
      return boost::algorithm::trim_right_copy_if(std::string(It(std::begin(val)), It(std::end(val))), [](char c) {
          return c == '\0';
      });
  }

  inline std::string encode64(const std::string &val) {
      using namespace boost::archive::iterators;
      using It = base64_from_binary<transform_width<std::string::const_iterator, 6, 8>>;
      auto tmp = std::string(It(std::begin(val)), It(std::end(val)));
      return tmp.append((3 - val.size() % 3) % 3, '=');
  }


  const boost::xpressive::sregex url_regex = 
    boost::xpressive::sregex::compile("(http|https)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)");

  inline url_parts parse_url(const std::string &url) {
    url_parts ret;
    
    // Way too slow on MSVC (55 seconds in avg for an URI, less than one ms on Gcc / clang )
    //std::regex ex("(http|https)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)");
    //std::smatch what;
    //if (regex_match(url, what, ex)) {
    using namespace boost::xpressive;
    smatch what;
    if( regex_match( url, what, url_regex ) ) {

        ret.protocol = what[1];
        ret.host   = what[2];
        ret.port     = what[3];

        if (ret.port.empty()) {
          ret.port = (ret.protocol == "https") ? "443" : "80";
        }

        ret.path     = what[4];
        ret.parameters    = what[5];
        ret.fragment = what[6];
    }

    return ret;
  }


} // namespace util
} // namespace xxhr 

#endif