Настройка удалённой сборки проекта на linux, использующего boost

#include <cstdio>
#include <iostream>
#include <vector>
#include <ctime>
#include <string>
#include <boost/date_time.hpp>
#include <boost/locale.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
 
using namespace boost::asio;
using namespace boost::posix_time;
using namespace boost::local_time;
 
io_service service;
 
class talk_to_client;
typedef boost::shared_ptr<talk_to_client> client_ptr;
typedef std::vector<client_ptr> array;
array clients;
 
#define MEM_FN(x)       boost::bind(&self_type::x, shared_from_this())
#define MEM_FN1(x,y)    boost::bind(&self_type::x, shared_from_this(),y)
#define MEM_FN2(x,y,z)  boost::bind(&self_type::x, shared_from_this(),y,z)
 
void update_clients_changed();
 
class talk_to_client : public boost::enable_shared_from_this<talk_to_client>, boost::noncopyable
{
    typedef talk_to_client self_type;
    talk_to_client() : sock_(service), started_(false), timer_(service), clients_changed_(false) {  }
 
public:
    typedef boost::system::error_code error_code;
    typedef boost::shared_ptr<talk_to_client> ptr;
 
    void start()
    {
        started_ = true;
        clients.push_back(shared_from_this());
        last_ping = boost::posix_time::microsec_clock::local_time();
        // first, we wait for client to login
        do_read();
    }
    static ptr new_()
    {
        ptr new_(new talk_to_client);
        return new_;
    }
    void stop()
    {
        if (!started_) return;
        started_ = false;
        sock_.close();
 
        ptr self = shared_from_this();
        array::iterator it = std::find(clients.begin(), clients.end(), self);
        clients.erase(it);
        update_clients_changed();
    }
    bool started() const { return started_; }
    ip::tcp::socket & sock() { return sock_; }
    std::string time_zone_name() const { return tzn; }
    void set_clients_changed() { clients_changed_ = true; }
private:
    void on_read(const error_code & err, size_t bytes)
    {
        if (err) stop();
        if (!started()) return;
        // process the msg
        std::string msg(read_buffer_, bytes);
        if (msg.find("Africa/Cairo") == 0) send_time(msg);
        else
        {
            //std::cerr << "invalid msg " << msg << std::endl;
            //stop();
            send_time(msg);
        }
    }
 
    void send_time(const std::string & msg)
    {
        std::istringstream in(msg);
        std::ostringstream ss;
        in >> tzn;
 
 
        tz_database tzDB;
        tzDB.load_from_file("C:/date_time_zonespec.csv");
 
        std::string ms = msg.substr(0, msg.length() - 2);
 
        //ptime timeUTC = second_clock::universal_time();
 
        time_zone_ptr time_zone = tzDB.time_zone_from_region(ms);
 
        //boost::gregorian::date dateObj = timeUTC.date();
 
        //ptime timeUTC = second_clock::universal_time();
 
        local_date_time local_time = local_sec_clock::local_time(time_zone);
 
        ss << local_time.date().day_of_week() << ' '
            << local_time.date().month() << ' '
            << local_time.date().day() << ' '
            << local_time.local_time().time_of_day().hours() << ':'
            << local_time.local_time().time_of_day().minutes() << ':'
            << local_time.local_time().time_of_day().seconds() << ' '
            << ms << ' '
            << local_time.date().year() << std::endl;
 
        std::string c = ss.str();
 
        do_write(c);
 
        stop();
 
        update_clients_changed();
    }
 
    void on_check_ping() {
        boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time();
        if ((now - last_ping).total_milliseconds() > 100000)
        {
            std::cout << "stopping " << tzn << " - no ping in time" << std::endl;
            stop();
        }
        last_ping = boost::posix_time::microsec_clock::local_time();
    }
    void post_check_ping()
    {
        timer_.expires_from_now(boost::posix_time::millisec(100000));
        timer_.async_wait(MEM_FN(on_check_ping));
    }
 
 
 
    void on_write(const error_code & err, size_t bytes)
    {
        do_read();
    }
    void do_read() {
        async_read(sock_, buffer(read_buffer_),
            MEM_FN2(read_complete, _1, _2), MEM_FN2(on_read, _1, _2));
        post_check_ping();
    }
    void do_write(const std::string & msg)
    {
        if (!started()) return;
        std::copy(msg.begin(), msg.end(), write_buffer_);
        sock_.async_write_some(buffer(write_buffer_, msg.size()),
            MEM_FN2(on_write, _1, _2));
    }
    size_t read_complete(const boost::system::error_code & err, size_t bytes)
    {
        if (err) return 0;
        bool found = std::find(read_buffer_, read_buffer_ + bytes, '\n') < read_buffer_ + bytes;
        // we read one-by-one until we get to enter, no buffering
        return found ? 0 : 1;
    }
private:
    ip::tcp::socket sock_;
    enum { max_msg = 1024 };
    enum {};
    char read_buffer_[max_msg];
    char write_buffer_[max_msg];
    bool started_;
    std::string tzn;
    deadline_timer timer_;
    boost::posix_time::ptime last_ping;
    bool clients_changed_;
    long long int ltime;
    struct tm newtime;
};
 
void update_clients_changed()
{
    for (array::iterator b = clients.begin(), e = clients.end(); b != e; ++b)
        (*b)->set_clients_changed();
}
 
ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(), 8001));
 
void handle_accept(talk_to_client::ptr client, const boost::system::error_code & err)
{
    client->start();
    talk_to_client::ptr new_client = talk_to_client::new_();
    acceptor.async_accept(new_client->sock(), boost::bind(handle_accept, new_client, _1));
}
 
 
int main()
{
    talk_to_client::ptr client = talk_to_client::new_(); // присваиваем указателю новый обьект talk_to_client
    acceptor.async_accept(client->sock(), boost::bind(handle_accept, client, _1));
    service.run();
}