UrlDecode.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_NETWORK_UTILITIES__URL_DECODE
#define COM_BORA_SOFTWARE__BALAU_NETWORK_UTILITIES__URL_DECODE

#include <Balau/Exception/NetworkExceptions.hpp>
#include <Balau/Util/Strings.hpp>

#include <map>

namespace Balau::Network {

struct UrlDecode {
    static std::unordered_map<std::string, std::string> splitAndDecode(const std::string_view & data,
                                                                       bool validateUtf8 = true,
                                                                       bool throwOnError = false) {
        std::unordered_map<std::string, std::string> decodedParameters;

        const auto parameters = split(data);

        for (auto iter = parameters.begin(); iter != parameters.end(); ++iter) {
            auto decodedKey = decode(iter->first, validateUtf8, throwOnError);
            auto decodedValue = decode(iter->second, validateUtf8, throwOnError);

            decodedParameters.insert(std::make_pair(std::move(decodedKey), std::move(decodedValue)));
        }

        return decodedParameters;
    }

    static std::unordered_map<std::string_view, std::string_view> split(const std::string_view data) {
        std::unordered_map<std::string_view, std::string_view> keysAndValues;
        std::vector<std::string_view> parameters = Util::Strings::split(data, "&");

        for (auto parameter : parameters) {
            std::vector<std::string_view> keyAndValue = Util::Strings::split(parameter, "=");

            if (keyAndValue.size() == 1) {
                // No value supplied.
                keysAndValues.emplace(keyAndValue[0], "");
            } else if (keyAndValue.size() != 2) {
                ThrowBalauException(Exception::NetworkException, "Invalid parameter list");
            } else {
                keysAndValues.emplace(keyAndValue[0], keyAndValue[1]);
            }
        }

        return keysAndValues;
    }

    static std::string decode(const std::string_view input, bool validateUtf8 = true, bool throwOnError = false) {
        std::string output;
        size_t index = 0;

        while (index < input.length()) {
            switch (input[index]) {
                case '+': {
                    output += ' ';
                    ++index;
                    break;
                }

                case '%': {
                    std::string thisOutput;

                    while (input[index] == '%') {
                        ++index;

                        if (index == input.length()) {
                            // Illegal input.. % character on its own at the end.
                            if (throwOnError) {
                                ThrowBalauException(Exception::NetworkException, "Invalid percent encoded string");
                            }

                            continue;
                        }

                        const size_t x = index;
                        ++index;

                        if (index == input.length()) {
                            // Illegal input.. % character with single following character at the end.
                            if (throwOnError) {
                                ThrowBalauException(Exception::NetworkException, "Invalid percent encoded string");
                            }

                            continue;
                        }

                        // Try to convert the hex character pair into an unsigned byte.
                        std::string_view v = input.substr(x, 2);
                        unsigned char b;
                        fromString(b, v, 16);
                        thisOutput += (char) b;
                        ++index;
                    }

                    bool valid = true;

                    if (validateUtf8) {
                        int offset = 0;

                        while (offset != (int) thisOutput.length()) {
                            Character::getNextUtf8Safe(thisOutput, offset);

                            if (offset < 0) {
                                // Not valid UTF-8.
                                if (throwOnError) {
                                    ThrowBalauException(Exception::NetworkException, "Invalid percent encoded string");
                                }

                                valid = false;
                                break;
                            }
                        }
                    }

                    if (valid) {
                        output += thisOutput;
                    }

                    break;
                }

                default: {
                    output += input[index];
                    ++index;
                    break;
                }
            }
        }

        return output;
    }


    UrlDecode() = delete;
    UrlDecode(const UrlDecode &) = delete;
    UrlDecode & operator = (const UrlDecode &) = delete;
};

} // namespace Balau::Network

#endif // COM_BORA_SOFTWARE__BALAU_NETWORK_UTILITIES__URL_DECODE