boost-asio

I've got a C++ application that is using ZeroMQ for some messaging. But it also has to provide a SGCI connection for an AJAX / Comet based web service. For this I need a normal TCP socket. I could do that by normal Posix sockets, but to stay cross platform portable and make my life easier (I hope...) I was thinking of using Boost::ASIO. But now I have the clash of ZMQ wanting to use it's own zmq_poll() and ASIO it's io_service.run() ... Is there a way to get ASIO to work together with the 0MQ zmq_poll() ? Or is there an other recommended way to achieve such a setup? Note: I could solve that by

I'm writing a server in C++ using Boost ASIO library. I'd like to get the string representation of client IP to be shown in my server's logs. Does anyone know how to do it? 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

( This is a simplified version of my original question ) I have several threads that write to a boost asio socket. This seems to work very well, with no problems. The documentation says a shared socket is not thread safe( here , way down at the bottom ) so I am wondering if I should protect the socket with mutex, or something. This question insists that protection is necessary, but gives no advice on how to do so. All the answers to my original question also insisted that what I was doing dangerous, and most urged me to replace my writes with async_writes or even more complicated things.

I have my application in which listen and process messages from both internet sockets and unix domain sockets. Now I need to add SSL to the internet sockets, I was using a single io_service object for all the sockets in the application. It seems now I need to add separate io_service objects for network sockets and unix domain sockets. I don't have any threads in my application and I use async_send and async_recieve and async_accept to process data and connections. Please point me to any examples using multiple io_service objects with async handlers. The question has a degree of uncertainty as

boost::asio::io_service::run() throws a boost::system::system_error exception in case of error. Should I handle this exception? If so, how? my main.cpp code is something like this: main() { boost::asio::io_service queue; boost::asio::io_service::work work(queue); { // set some handlers... **queue.run();** } // join some workers... return 0; } 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

On Windows, I am observing that if an async_read operation successfully completes on a serial port, and I immediately initiate another async_read operation to read n bytes, the second async_read operation immediately completes unexpectedly with success and 0 bytes transferred. after the second async_read operation, if a third async_read operation is initiated to read n bytes, then it will complete with success and n bytes transferred // where buffer_size(buffer) and n are both greater than 1 async_read(serial, buffer, transfer_exactly(n), [](error, bytes_transferred) { // completes with error

I am working on a boost.asio based HTTP server. It is supposed to be stopped externally. We use asio signal handling, and it works well for ctrl-c, but does not handle WM_CLOSE, so there is no straightforward way to gracefully close the application externally, e.g. via taskkill. Terminating the process forcibly is not an option. Is there a known approach to this? Update Just use any IPC method you would "normally" use Write a simple process control utility that uses e.g. named_condition to signal your asio process to shutdown. Note that named_codition is somewhat equivalent to a Win32 Named

What is the easiest way to check if a socket was closed on the remote side of the connection? socket::is_open() returns true even if it is closed on the remote side (I'm using boost::asio::ip::tcp::socket ). I could try to read from the stream and see if it succeeds, but I'd have to change the logic of my program to make it work this way (I do not want data to be extracted from the stream at the point of the check). If the connection has been cleanly closed by the peer you should get an EOF while reading. Otherwise I generally ping in order to figure out if the connection is really alive. Just

I'd like to create an asynchronous function which takes as it's last argument boost::asio::yield_context. E.g.: int async_meaning_of_life(asio::yield_context yield); I'd also like to be consistent with how Asio returns error codes. That is, if the user does: int result = async_meaning_of_life(yield); and the function fails, then it throws the system_error exception. But if the user does: boost::error_code ec; int result = async_meaning_of_life(yield[ec]); Then - instead of throwing - the error is returned in ec . The problem is that when implementing the function, I can't seem to find a clean