FlashPolicyServer.hpp

#pragma once
#include <samchon/API.hpp>

#include <boost/asio.hpp>
#include <thread>
#include <samchon/library/XML.hpp>

namespace samchon
{
namespace library
{
    class XML;
};
namespace protocol
{
    class FlashPolicyServer
    {
    private:
        std::shared_ptr<library::XML> policy;

    public:
        FlashPolicyServer()
            : FlashPolicyServer
                (
                    std::make_shared<library::XML>
                    (
                        std::string() +
                            "<cross-domain-policy>\n" +
                            "   <allow-access-from domain='*' to-ports='*' />\n" +
                            "</cross-domain-policy>"
                        )
                )
        {
        };

        FlashPolicyServer(std::shared_ptr<library::XML> policy)
        {
            this->policy = policy;
        };

        void open(int port = 843)
        {
            boost::asio::io_service ioService;
            boost::asio::ip::tcp::endpoint endPoint(boost::asio::ip::tcp::v4(), port);
            boost::asio::ip::tcp::acceptor acceptor(ioService, endPoint);

            while (true)
            {
                auto socket = std::make_shared<boost::asio::ip::tcp::socket>(ioService);
                acceptor.accept(*socket);

                std::thread(&FlashPolicyServer::accept, this, socket).detach();
            }
        };

        auto getPolicy() const -> std::shared_ptr<library::XML>
        {
            return policy;
        };

        void setPolicy(std::shared_ptr<library::XML> xml)
        {
            this->policy = xml;
        };

    private:
        void accept(std::shared_ptr<boost::asio::ip::tcp::socket> socket)
        {
            std::string data = "<?xml version=\"1.0\"?>\n" + policy->toString();
            std::vector<unsigned char> piece;
            boost::system::error_code error;

            while (true)
            {
                piece.assign(1000, NULL);
                socket->read_some(boost::asio::buffer(piece), error);

                boost::system::error_code error;
                socket->write_some(boost::asio::buffer(data), error);

                break;
            }
            socket->close();
        };
    };
};
};