Ticket #3131: async_dccp_echo_server.cpp

//
// async_dccp_echo_server.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/program_options.hpp>

#include "dccp.hpp"

using boost::asio::ip::dccp;
using namespace std;

class session
{
public:
        session(boost::asio::io_service& io_service)
                : socket_(io_service)
        {
        }

        dccp::socket& socket()
        {
                return socket_;
        }

        void start()
        {
                {
                        boost::asio::dccp_option::cur_mps option;
                        socket_.get_option(option);
                        cout << "got mps: " << option.value() << endl;
                        data_.resize(option.value());
                }

                {
                        boost::asio::dccp_option::service option;
                        socket_.get_option(option);
                        cout << "got service: " << option[0] << endl;
                }

                socket_.async_receive(boost::asio::buffer(data_),
                boost::bind(&session::handle_receive, this,
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
        }

        void handle_receive(const boost::system::error_code& error,
                            size_t bytes_transferred)
        {
                if (!error) {
                        socket_.async_send(boost::asio::buffer(data_, bytes_transferred),
                                           boost::bind(&session::handle_send,
                                                       this,
                                                       boost::asio::placeholders::error));
                } else
                        delete this;
        }

        void handle_send(const boost::system::error_code& error)
        {
                if (!error) {
                        socket_.async_receive(boost::asio::buffer(data_),
                                              boost::bind(&session::handle_receive,
                                                          this,
                                                          boost::asio::placeholders::error,
                                                          boost::asio::placeholders::bytes_transferred));
                } else
                        delete this;
        }

private:
        dccp::socket socket_;
        vector<char> data_;
};

class server
{
public:
        server(boost::asio::io_service& io_service, short port,
               const vector<unsigned int> &srv_codes = vector<unsigned int>())
                : io_service_(io_service),
                  acceptor_(io_service,
                            dccp::endpoint(dccp::v4(), port, srv_codes))
        {
                session *new_session = new session(io_service_);

                acceptor_.async_accept(new_session->socket(),
                                       boost::bind(&server::handle_accept, this, new_session,
                                       boost::asio::placeholders::error));
        }

        void handle_accept(session* new_session,
                           const boost::system::error_code& error)
        {
                if (!error) {
                        new_session->start();
                        new_session = new session(io_service_);
                        acceptor_.async_accept(new_session->socket(),
                                               boost::bind(&server::handle_accept,
                                                           this, new_session,
                                                           boost::asio::placeholders::error));
                } else
                        delete new_session;
        }

private:
        boost::asio::io_service& io_service_;
        dccp::acceptor acceptor_;
};

int main(int argc, char* argv[])
{
        using namespace boost::program_options;

        options_description desc;
        desc.add_options()
                ("help", "produce help message")
                ("port", value<unsigned short>()->default_value(7777),
                 "Port number to listen on")
                ("sc", value<vector<unsigned int> >(),
                 "Service code(s) to listen on");

        variables_map vm;

        try {
                store(parse_command_line(argc, argv, desc), vm);
        } catch (error &err) {
                cout << err.what() << endl;
                return 1;
        }

        notify(vm);

        if (vm.count("help")) {
                cout << desc;
                return 0;
        }

        try {
                vector<unsigned int> s_codes;
                try {
                        s_codes = vm["sc"].as<vector<unsigned int> >();
                } catch (boost::bad_any_cast &e) {
                        cerr << e.what() << endl;
                        s_codes.push_back(0x30304953);
                }

                boost::asio::io_service io_service;
                server s(io_service, vm["port"].as<unsigned short>(), s_codes);

            io_service.run();
        } catch (std::exception &e) {
                cerr << "Exception: " << e.what() << "\n";
        }

        return 0;
}