http_listener.h

/***
* ==++==
*
* Copyright (c) Microsoft Corporation. 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.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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.
*
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* HTTP Library: HTTP listener (server-side) APIs
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/
#pragma once

#ifndef _CASA_HTTP_LISTENER_H
#define _CASA_HTTP_LISTENER_H

#include <limits>
#include <functional>

#if !defined(_WIN32) && !defined(__cplusplus_winrt)
#include <boost/asio/ssl.hpp>
#endif

#include "cpprest/http_msg.h"

#if !defined(_WIN32) || (_WIN32_WINNT >= _WIN32_WINNT_VISTA && !defined(__cplusplus_winrt))

namespace web
{
namespace http
{
namespace experimental
{
namespace listener
{

class http_listener_config
{
public:

    http_listener_config()
        : m_timeout(utility::seconds(120))
    {}

    http_listener_config(const http_listener_config &other)
        : m_timeout(other.m_timeout)
#ifndef _WIN32
        , m_ssl_context_callback(other.m_ssl_context_callback)
#endif
    {}

    http_listener_config(http_listener_config &&other)
        : m_timeout(std::move(other.m_timeout))
#ifndef _WIN32
        , m_ssl_context_callback(std::move(other.m_ssl_context_callback))
#endif
    {}

    http_listener_config & operator=(const http_listener_config &rhs)
    {
        if(this != &rhs)
        {
            m_timeout = rhs.m_timeout;
#ifndef _WIN32
            m_ssl_context_callback = rhs.m_ssl_context_callback;
#endif
        }
        return *this;
    }

    http_listener_config & operator=(http_listener_config &&rhs)
    {
        if(this != &rhs)
        {
            m_timeout = std::move(rhs.m_timeout);
#ifndef _WIN32
            m_ssl_context_callback = std::move(rhs.m_ssl_context_callback);
#endif
        }
        return *this;
    }

    utility::seconds timeout() const
    {
        return m_timeout;
    }

    void set_timeout(utility::seconds timeout)
    {
        m_timeout = std::move(timeout);
    }

#ifndef _WIN32
    const std::function<void(boost::asio::ssl::context&)>& get_ssl_context_callback() const
    {
        return m_ssl_context_callback;
    }

    void set_ssl_context_callback(const std::function<void(boost::asio::ssl::context&)> &ssl_context_callback)
    {
        m_ssl_context_callback = ssl_context_callback;
    }
#endif

private:

    utility::seconds m_timeout;
#ifndef _WIN32
    std::function<void(boost::asio::ssl::context&)> m_ssl_context_callback;
#endif
};

namespace details
{

class http_listener_impl
{
public:

    http_listener_impl()
        : m_closed(true)
        , m_close_task(pplx::task_from_result())
    {
    }

    _ASYNCRTIMP http_listener_impl(http::uri address);
    _ASYNCRTIMP http_listener_impl(http::uri address, http_listener_config config);

    _ASYNCRTIMP pplx::task<void> open();
    _ASYNCRTIMP pplx::task<void> close();

    _ASYNCRTIMP void handle_request(http::http_request msg);

    const http::uri & uri() const { return m_uri; }

    const http_listener_config & configuration() const { return m_config; }

    // Handlers
    std::function<void(http::http_request)> m_all_requests;
    std::map<http::method, std::function<void(http::http_request)>> m_supported_methods;

private:

    // Default implementation for TRACE and OPTIONS.
    void handle_trace(http::http_request message);
    void handle_options(http::http_request message);

    // Gets a comma separated string containing the methods supported by this listener.
    utility::string_t get_supported_methods() const;

    http::uri m_uri;
    http_listener_config m_config;

    // Used to record that the listener is closed.
    bool m_closed;
    pplx::task<void> m_close_task;
};

} // namespace details

class http_listener
{
public:

    http_listener(http::uri address)
        : m_impl(utility::details::make_unique<details::http_listener_impl>(std::move(address)))
    {
    }

    http_listener(http::uri address, http_listener_config config)
        : m_impl(utility::details::make_unique<details::http_listener_impl>(std::move(address), std::move(config)))
    {
    }

    http_listener()
        : m_impl(utility::details::make_unique<details::http_listener_impl>())
    {
    }

    _ASYNCRTIMP ~http_listener();

    pplx::task<void> open()
    {
        return m_impl->open();
    }

    pplx::task<void> close()
    {
        return m_impl->close();
    }

    void support(const std::function<void(http_request)> &handler)
    {
        m_impl->m_all_requests = handler;
    }

    void support(const http::method &method, const std::function<void(http_request)> &handler)
    {
        m_impl->m_supported_methods[method] = handler;
    }

    const http::uri & uri() const { return m_impl->uri(); }

    const http_listener_config & configuration() const { return m_impl->configuration(); }

    http_listener(http_listener &&other)
        : m_impl(std::move(other.m_impl))
    {
    }

    http_listener &operator=(http_listener &&other)
    {
        if(this != &other)
        {
            m_impl = std::move(other.m_impl);
        }
        return *this;
    }

private:

    // No copying of listeners.
    http_listener(const http_listener &other);
    http_listener &operator=(const http_listener &other);

    std::unique_ptr<details::http_listener_impl> m_impl;
};

}}}}

#endif
#endif