Asio:UDS

#include <iostream>
#include <string>
#include <cctype>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>
#include <boost/array.hpp>
#include <boost/bind.hpp>

#if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)

using boost::asio::local::stream_protocol;

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

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

    void start()
    {
        // Wait for request.
        socket_.async_read_some(boost::asio::buffer(data_),
                boost::bind(&uppercase_filter::handle_read,
                        this, boost::asio::placeholders::error,
                        boost::asio::placeholders::bytes_transferred));
    }

private:
    void handle_read(const boost::system::error_code& ec, std::size_t size)
    {
        if (!ec)
        {
            // Compute result.
            for (std::size_t i = 0; i < size; ++i)
            data_[i] = std::toupper(data_[i]);

            // Send result.
            boost::asio::async_write(socket_, boost::asio::buffer(data_, size),
                    boost::bind(&uppercase_filter::handle_write,
                            this, boost::asio::placeholders::error));
        }
        else
        {
            throw boost::system::system_error(ec);
        }
    }

    void handle_write(const boost::system::error_code& ec)
    {
        if (!ec)
        {
            // Wait for request.
            socket_.async_read_some(boost::asio::buffer(data_),
                    boost::bind(&uppercase_filter::handle_read,
                            this, boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
        }
        else
        {
            throw boost::system::system_error(ec);
        }
    }

    stream_protocol::socket socket_;
    boost::array<char, 512> data_;
};

void run(boost::asio::io_service* io_service)
{
    try
    {
        io_service->run();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception in thread: " << e.what() << "\n";
        std::exit(1);
    }
}

int main()
{
    try
    {
        boost::asio::io_service io_service;

        // Create filter and establish a connection to it.
        uppercase_filter filter(io_service);
        stream_protocol::socket socket(io_service);
        boost::asio::local::connect_pair(socket, filter.socket());
        filter.start();

        // The io_service runs in a background thread to perform filtering.
        boost::thread thread(boost::bind(run, &io_service));

        for (;;)
        {
            // Collect request from user.
            std::cout << "Enter a string: ";
            std::string request;
            std::getline(std::cin, request);

            // Send request to filter.
            boost::asio::write(socket, boost::asio::buffer(request));

            // Wait for reply from filter.
            std::vector<char> reply(request.size());
            boost::asio::read(socket, boost::asio::buffer(reply));

            // Show reply to user.
            std::cout << "Result: ";
            std::cout.write(&reply[0], request.size());
            std::cout << std::endl;
        }
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
        std::exit(1);
    }
}

#else
# error "Local sockets not available on this platform."
#endif

#include <cstdio>
#include <iostream>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/asio.hpp>

#if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)

using boost::asio::local::stream_protocol;

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

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

    void start()
    {
        socket_.async_read_some(boost::asio::buffer(data_),
                boost::bind(&session::handle_read,
                        shared_from_this(),
                        boost::asio::placeholders::error,
                        boost::asio::placeholders::bytes_transferred));
    }

    void handle_read(const boost::system::error_code& error,
            size_t bytes_transferred)
    {
        if (!error)
        {
            boost::asio::async_write(socket_,
                    boost::asio::buffer(data_, bytes_transferred),
                    boost::bind(&session::handle_write,
                            shared_from_this(),
                            boost::asio::placeholders::error));
        }
    }

    void handle_write(const boost::system::error_code& error)
    {
        if (!error)
        {
            socket_.async_read_some(boost::asio::buffer(data_),
                    boost::bind(&session::handle_read,
                            shared_from_this(),
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
        }
    }

private:
    // The socket used to communicate with the client.
    stream_protocol::socket socket_;

    // Buffer used to store data received from the client.
    boost::array<char, 1024> data_;
};

typedef boost::shared_ptr<session> session_ptr;

class server
{
public:
    server(boost::asio::io_service& io_service, const std::string& file)
    : io_service_(io_service),
    acceptor_(io_service, stream_protocol::endpoint(file))
    {
        session_ptr 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_ptr new_session,
            const boost::system::error_code& error)
    {
        if (!error)
        {
            new_session->start();
        }

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

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

int main(int argc, char* argv[])
{
    try
    {
        if (argc != 2)
        {
            std::cerr << "Usage: stream_server <file>\n";
            std::cerr << "*** WARNING: existing file is removed ***\n";
            return 1;
        }

        boost::asio::io_service io_service;

        std::remove(argv[1]);
        server s(io_service, argv[1]);

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

    return 0;
}

#else // defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
# error "Local sockets not available on this platform."
#endif // defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)

#include <cstdlib>
#include <cstring>
#include <iostream>
#include <boost/asio.hpp>

#if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)

using boost::asio::local::stream_protocol;

enum {max_length = 1024};

int main(int argc, char* argv[])
{
    try
    {
        if (argc != 2)
        {
            std::cerr << "Usage: stream_client <file>\n";
            return 1;
        }

        boost::asio::io_service io_service;

        stream_protocol::socket s(io_service);
        s.connect(stream_protocol::endpoint(argv[1]));

        using namespace std; // For strlen.
        std::cout << "Enter message: ";
        char request[max_length];
        std::cin.getline(request, max_length);
        size_t request_length = strlen(request);
        boost::asio::write(s, boost::asio::buffer(request, request_length));

        char reply[max_length];
        size_t reply_length = boost::asio::read(s,
                boost::asio::buffer(reply, request_length));
        std::cout << "Reply is: ";
        std::cout.write(reply, reply_length);
        std::cout << "\n";
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}

#else // defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
# error "Local sockets not available on this platform."
#endif // defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)