CurlEasyHandleWrapper.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#ifndef ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_LIBCURLUTILS_CURLEASYHANDLEWRAPPER_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_LIBCURLUTILS_CURLEASYHANDLEWRAPPER_H_

#include <chrono>
#include <curl/curl.h>
#include <fstream>
#include <string>

#include <AVSCommon/Utils/Logger/LogEntry.h>
#include <AVSCommon/Utils/Logger/LogStringFormatter.h>
#include <AVSCommon/Utils/Logger/LoggerUtils.h>

#ifdef ACSDK_EMIT_SENSITIVE_LOGS
#define ACSDK_EMIT_CURL_LOGS
#endif

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace libcurlUtils {
// Forward declaration
class CurlEasyHandleWrapper;

// This abstracts the setting of curl options from the CurlEasyHandleWrapper
class CurlEasyHandleWrapperOptionsSettingAdapter {
public:
    CurlEasyHandleWrapperOptionsSettingAdapter(CurlEasyHandleWrapper* wrapper) : m_easyHandleWrapper(wrapper) {
    }

    template <typename ParamType>
    bool setopt(CURLoption option, ParamType param);

private:
    CurlEasyHandleWrapper* m_easyHandleWrapper;
};

class CurlEasyHandleWrapper {
public:
    using CurlCallback = size_t (*)(char* buffer, size_t blockSize, size_t numBlocks, void* userData);

    using CurlDebugCallback =
        int (*)(CURL* handle, curl_infotype infoType, char* buffer, size_t blockSize, void* userData);

    enum class TransferType {
        kGET,
        kPOST,
        kPUT
    };

    CurlEasyHandleWrapper(std::string id = "");

    ~CurlEasyHandleWrapper();

    bool reset(std::string id = "");

    CURL* getCurlHandle();

    bool isValid();

    std::string getId() const;

    /*
     * Adds an HTTP Header to the current easy handle
     *
     * @param header The HTTP header to add
     * @returns true if the addition was successful
     */
    bool addHTTPHeader(const std::string& header);

    /*
     * Adds a POST Header to the list of the headers to add to the future POST request
     *
     * @param header The HTTP header to add
     * @returns true if the addition was successful
     */
    bool addPostHeader(const std::string& header);

    bool setURL(const std::string& url);

    bool setTransferType(TransferType type);

    bool setTransferTimeout(const long timeoutSeconds);

    bool setPostData(const std::string& data);

    bool setConnectionTimeout(const std::chrono::seconds timeoutSeconds);

    bool setWriteCallback(CurlCallback callback, void* userData);

    bool setHeaderCallback(CurlCallback callback, void* userData);

    bool setReadCallback(CurlCallback callback, void* userData);

    std::string urlEncode(const std::string& in) const;

    long getHTTPResponseCode();

    std::string getEffectiveUrl();

    CURLcode perform();

    CURLcode pause(int mask);

    static void setInterfaceName(const std::string& interfaceName);

    static std::string getInterfaceName();

    CurlEasyHandleWrapperOptionsSettingAdapter& curlOptionsSetter();

private:
    template <typename ParamType>
    bool setopt(CURLoption option, ParamType param);

    void cleanupResources();

    bool setDefaultOptions();

#ifdef ACSDK_EMIT_CURL_LOGS

    void initStreamLog();

    static int debugFunction(CURL* handle, curl_infotype type, char* data, size_t size, void* user);
#endif

    static void initializeNetworkInterfaceNameLocked();

    CURL* m_handle;
    curl_slist* m_requestHeaders;
    curl_slist* m_postHeaders;
    curl_httppost* m_post;
    curl_httppost* m_lastPost;
    std::string m_id;
    static std::mutex m_interfaceNameMutex;
    static bool m_isInterfaceNameInitialized;
    static std::string m_interfaceName;
    static std::atomic<uint64_t> m_idGenerator;

    CurlEasyHandleWrapperOptionsSettingAdapter m_curlOptionsSettingAdapter;

    std::unique_ptr<std::ofstream> m_streamLog;
    std::unique_ptr<std::ofstream> m_streamInDump;
    std::unique_ptr<std::ofstream> m_streamOutDump;
    avsCommon::utils::logger::LogStringFormatter m_logFormatter;

    friend class CurlEasyHandleWrapperOptionsSettingAdapter;
};

template <typename ParamType>
bool CurlEasyHandleWrapper::setopt(CURLoption option, ParamType value) {
    auto result = curl_easy_setopt(m_handle, option, value);
    if (result != CURLE_OK) {
        logger::acsdkError(logger::LogEntry("CurlEasyHandleWrapper", "setoptFailed")
                               .d("reason", "curl_easy_setopt failed")
                               .d("option", option)
                               .sensitive("value", value)
                               .d("result", result)
                               .d("error", curl_easy_strerror(result)));
        return false;
    }
    return true;
}

template <typename ParamType>
bool CurlEasyHandleWrapperOptionsSettingAdapter::setopt(CURLoption option, ParamType value) {
    return m_easyHandleWrapper->setopt(option, std::forward<ParamType>(value));
}

}  // namespace libcurlUtils
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_LIBCURLUTILS_CURLEASYHANDLEWRAPPER_H_