TL;DR socket.set_option(boost::asio::detail::socket_option::integer<SOL_SOCKET, SO_RCVTIMEO>{ 200 }); FULL ANSWER This question keep being asked over and over again for many years. Answers I saw so far are quite poor. I’ll add this info right here in one of the first occurrences of this question. Everybody trying to use ASIO to simplify their networking code would be perfectly … Read more
Some nice documentation on boost including a chapter on asio can be found in a (free) boost book at http://en.highscore.de/cpp/boost/index.html. The chapter on asio provides a general overview and then goes as far as how to develop your own custom asio extensions. Really fantastic effort by Boris Schäling!
To bind a UDP socket when receiving multicast means to specify an address and port from which to receive data (NOT a local interface, as is the case for TCP acceptor bind). The address specified in this case has a filtering role, i.e. the socket will only receive datagrams sent to that multicast address & … Read more
Yes. It is documented that exceptions thrown from completion handlers are propagated. So you need to handle them as appropriate for your application. In many cases, this would be looping and repeating the run() until it exits without an error. In our code base I have something like static void m_asio_event_loop(boost::asio::io_service& svc, std::string name) { … Read more
Foundation Lets start with a simplified example and examine the relevant Boost.Asio pieces: void handle_async_receive(…) { … } void print() { … } … boost::asio::io_service io_service; boost::asio::ip::tcp::socket socket(io_service); … io_service.post(&print); // 1 socket.connect(endpoint); // 2 socket.async_receive(buffer, &handle_async_receive); // 3 io_service.post(&print); // 4 io_service.run(); // 5 What Is A Handler? A handler is nothing more than … Read more
The process is pretty simple. First create an asio::io_service and a thread_group. Fill the thread_group with threads linked to the io_service. Assign tasks to the threads using the boost::bind function. To stop the threads (usually when you are exiting your program) just stop the io_service and join all threads. You should only need these headers: … Read more
Is there a simple way to avoid this problem ? Yes, maintain an outgoing queue for each client. Inspect the queue size in the async_write completion handler, if non-zero, start another async_write operation. Here is a sample #include <boost/asio.hpp> #include <boost/bind.hpp> #include <deque> #include <iostream> #include <string> class Connection { public: Connection( boost::asio::io_service& io_service ) … Read more
It enables you to get a valid shared_ptr instance to this, when all you have is this. Without it, you would have no way of getting a shared_ptr to this, unless you already had one as a member. This example from the boost documentation for enable_shared_from_this: class Y: public enable_shared_from_this<Y> { public: shared_ptr<Y> f() { … Read more
The documentation is correct. With a half duplex protocol implementation, such as HTTP Server 3, the strand is not necessary. The call chains can be illustrated as follows: void connection::start() { socket.async_receive_from(…, &handle_read); —-. } | .————————————————‘ | .—————————————–. V V | void connection::handle_read(…) | { | if (result) | boost::asio::async_write(…, &handle_write); —|–. else if … Read more
In the real world, dynamic allocation is slower than automatic allocation. That’s true — at least in general. That doesn’t mean that dynamic allocation is too slow. The only way to determine that is to profile your code. Until you have done that, it is impossible to say that you should abandon dynamic allocation because … Read more