boost-asio

I have an application that uses asio deadline timers. The rest of the application uses std::chrono constructs for its time values, and it feels awkward to use boost::posix_time for only the stuff that touches asio. I'd like to use std::chrono throughout the application if I can, for consistency, readability, etc. It seems to me that the answer would involve using the timer's template: typedef boost::asio::basic_deadline_timer<std::chrono::system_clock::time_point> my_deadline_timer_type; my_deadline_timer_type a_timer(io_service); Except this blows up badly at compile time...many lines of

I'm trying to implement a very simple proxy server with the following code. You set your browser's proxy to 192.168.1.x:8080 and web pages are accessible through the proxy. #include <ctime> #include <iostream> #include <string> #include <boost/bind.hpp> #include <boost/shared_ptr.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/asio.hpp> #include <boost/algorithm/string.hpp> #include <curl/curl.h> #include <cstdlib> using boost::asio::ip::tcp; int port=8080; //CURL *curl; //CURLcode res; static size_t write_to_string(void *ptr, size_t size, size_t count, void *stream) { ((std:

Possible Duplicate: How to check if socket is closed in Boost.Asio? Is there an established way to determine whether the other end of a TCP connection is closed in the asio framework without sending any data? Using Boost.asio for a server process, if the client times out or otherwise disconnects before the server has responded to a request, the server doesn't find this out until it has finished the request and generated a response to send, when the send immediately generates a connection-aborted error. For some long-running requests, this can lead to clients canceling and retrying over and

As known, we can use multiple acceptors in boost::asio. boost::asio::io_service io_service_acceptors; std::vector<boost::thread> thr_grp_acceptors; unsigned int thread_num_acceptors = 2; for(size_t i = 0; i < thread_num_acceptors; ++i) { thr_grp_acceptors.emplace_back( boost::bind(&boost::asio::io_service::run, &io_service_acceptors)); But is there any sense in doing io_service_acceptors more than 1? Boost.ASIO uses optimal non-blocking demultiplexing mechanism (epoll, IOCP, ...). Also even if network error will occur after epoll and before accept then accept will not been blocked , because we

The code: In thread 1: boost::async_read(socket, buffer, strand.wrap(read_handler)); In thread 2: strand.post([](){socket.async_write_some(buffer, strand.wrap(write_handler))}); It is clear that read_handler , async_write_some , write_handler protected by strand, they will not concurrent. However, async_read is an composed operation, it will call zero or more times to async_read_some, those async_read_some also need protect by strand or else they might concurrent with async_write_some in thread 2. But from the code, strand only wrap read_handler , how asio make all intermediate operations