Has boost.asio any kind of file support? Starting with (I think) Boost 1.36 (which contains Asio 1.2.0) you can use [boost::asio::]windows::stream_handle or windows::random_access_handle to wrap a HANDLE and perform asynchronous read and write methods on it that use the OVERLAPPED structure internally. User Lazin also mentions boost::asio::windows::random_access_handle that can be used for async operations (e.g. … Read more
Got reply from boost community Yes. These platforms are not officially supported because no one has volunteered to run regression tests regularly for them. It is not possible for a Boost developer to test on all platforms. So developers depend on the test results of regression tests run by volunteers. For example, see http://beta.boost.org/development/tests/trunk/developer/summary.html If … 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
The other day somebody recommended this on another thread: http://cpp-netlib.github.com/ I think this is as high-level as you will find, but I’m not sure if it’s mature enough yet (I would say it probably is since they’ve proposed it for Boost inclusion).
The socket has a function that will retrieve the remote endpoint. I’d give this (long-ish) chain of commands a go, they should retrieve the string representation of the remote end IP address: asio::ip::tcp::socket socket(io_service); // Do all your accepting and other stuff here. asio::ip::tcp::endpoint remote_ep = socket.remote_endpoint(); asio::ip::address remote_ad = remote_ep.address(); std::string s = remote_ad.to_string(); … 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
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
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
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!
Scope Boost.Asio is a C++ library that started with a focus on networking, but its asynchronous I/O capabilities have been extended to other resources. Additionally, with Boost.Asio being part of the Boost libraries, its scope is slightly narrowed to prevent duplication with other Boost libraries. For example, Boost.Asio will not provide a thread abstraction, as … Read more