boost-asio

I tried the example , but it does not work. Apparently it does not set IPPROTO_IP/IP_MULTICAST_IF option. I can only find boost::asio::ip::multicast::outbound_interface for IPPROTO_IP/IP_MULTICAST_IF, I tried but failed. Is there any way to make boost::asio::ip::multicast work without calling c-level setsockopt? boost::asio::ip::udp::endpoint listen_endpoint( listen_address, multicast_port); socket_.open(listen_endpoint.protocol()); socket_.set_option(boost::asio::ip::udp::socket::reuse_address(true)); socket_.bind(listen_endpoint); // Join the multicast group. socket_.set_option( boost::asio:

I expected the code below to print Hello, world! every 5 seconds, but what happens is that the program pauses for 5 seconds and then prints the message over and over with no subsequent pauses. What am I missing? #include <iostream> #include <boost/asio.hpp> #include <boost/date_time/posix_time/posix_time.hpp> using namespace boost::asio; using namespace std; io_service io; void print(const boost::system::error_code& /*e*/) { cout << "Hello, world!\n"; deadline_timer t(io, boost::posix_time::seconds(5)); t.async_wait(print); } int main() { deadline_timer t(io, boost::posix_time::seconds(5)); t

This is a follow-on from a previous question ( here ), but I'm working on a multithreaded application and I would like to post a Boost packaged_task to a threaded io_service. I'm stuck using a C++03 compiler (so std::move is out), and the packaged_task is not copyable. I've tried wrapping it in a shared_ptr and passing that, and a lot of other things. Here is my current attempt and the subsequent compiler errors. Any idea how to get this to work? boost::asio::io_service io_service; boost::thread_group threads; boost::asio::io_service::work work(io_service); for (int i = 0; i < maxNumThreads; +

When the async_read_some() returns an exception of EOF does it mean the server stopped sending data or does it mean the connection is closed. I'm having this confusion as I cant find a method to know if the client has received all data from server. It indicates the connection has closed. Although documented elswhere it is still applicable: An error code of boost::asio::error::eof indicates that the connection was closed by the peer. If a client needs to know that all data has been received from the server, then consider supporting framing in the communication protocol. Boost.Asio provides

I want to remove all handlers from an IO_service right before I reuse it. Is this possible? I'm writing unit tests that involve an asio::io_service . In between each test case I want to clear the handlers from the global io_service . I thought that io_service::reset would to that but it doesn't. reset() only allows the io_service to be resumed. All of the handlers from the last test case are still queued up. I only need to do this for unit testing so any crazy hack would work. More info: The io_service is from a deadline_timer member variable. The deadline_timer is part of the code I'm testing

I get the following error message when I'm trying to use std::string with boost::asio::buffer: boost/asio/detail/consuming_buffers.hpp: In constructor 'boost::asio::detail::consuming_buffers< boost::asio::mutable_buffer, boost::asio::const_buffers_1 ::consuming_buffers(const boost::asio::const_buffers_1 &)': boost/asio/impl/read.hpp:140:25: instantiated from 'boost::asio::detail::read_op< boost::asio::basic_stream_socket, boost::asio::const_buffers_1 , boost::asio::detail::transfer_all_t , boost::_bi::bind_t< void, boost::_mfi::mf1 , boost::_bi::list2, boost::arg<1> (*)()> ::read_op( boost:

I was just going over the asio chat server example . My question is about their usage of the io_service.run() function. The documentation for the io_service.run() function says: The run() function blocks until all work has finished and there are no more handlers to be dispatched, or until the io_service has been stopped. Multiple threads may call the run() function to set up a pool of threads from which the io_service may execute handlers. All threads that are waiting in the pool are equivalent and the io_service may choose any one of them to invoke a handler. The run() function may be safely