boost-asio

I am trying to enumerate ipv4 and ipv6 addresses of all the network cards(I have 2 cards) my pc. I am using the following code to do that. using boost::asio::ip::tcp; boost::asio::io_service io_service; tcp::resolver resolver(io_service); tcp::resolver::query query(boost::asio::ip::host_name(),""); tcp::resolver::iterator it=resolver.resolve(query); while(it!=tcp::resolver::iterator()) { boost::asio::ip::address addr=(it++)->endpoint().address(); if(addr.is_v6()) { std::cout<<"ipv6 address: "; } else std::cout<<"ipv4 address: "; std::cout<<addr.to_string()<<std::endl; } The code displays

Single-threaded application. It happens not every time, only after 1.5 hours of high load. tcp::socket::async_connect tcp::socket::close (by deadline_timer) async_connect_handler gives success error_code (one of a million times), but socket is closed by(2). 99.999% of time it gives errno=125 (ECANCELED). Is it possible that socket implementation or boost asio somehow do this: async_connect async success posted to io_service close by timer async success handled by me, not affected by close Right now solved by saving state in my variables, ignoring accept success. Linux 2.6 (fedora). Boost 1.46

I'm having a hard time understand the correct way I should structure a tcp client when using async_read and async_write. The examples seem to do a async_read after connecting and then have async_write in the handler. In the case of my client and sever, when the client connects it needs to check a queue of messages to write and check to see if anything needs to be read. One of the things I'm having a hard time with is understanding how this would work asynchronously. What I envision is in the async_connect handler, the thread would call async_write if anything is in the sendQueue and call async

Asio (without Boost) is supposed to be usable with just the headers only right? By default, Asio is a header-only library. ( http://think-async.com ) I understand that internally Asio still depends on Boost. This is my setup. Android.mk LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := gatelib LOCAL_SRC_FILES := gatelib.cpp LOCAL_C_INCLUDES += /cygdrive/l/asio-1.5.3/include LOCAL_C_INCLUDES += /cygdrive/l/boost/boost_1_49_0 include $(BUILD_SHARED_LIBRARY) Application.mk APP_STL := stlport_static APP_CFLAGS += -DBOOST_DATE_TIME_NO_LIB -DBOOST_REGEX_NO_LIB gatelib.cpp #include

I have an UDP socket that will receive some packets, of potentially different sizes, and I handle this asynchronously: socket.async_receive_from(boost::asio::buffer(buffer, 65536), senderEndpoint, handler); The problem here is that to handle the different sizes I have a big buffer, something that could be addressed with variable size buffers. To my understanding, when using async_receive_from , the handler is called with only one packet at a time, because the packet boundaries are preserved in UDP. So, is there a way to give an empty buffer to async_receive_from that Asio will grow to fit the

The boost docs say that cancelled async connect, send and receive finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation_aborted error. I would like to find out if the cancelled handler gets to run (and see the operation_aborted error) before other (non-cancelled, and newly scheduled) completion handlers run. Here is the timeline that concerns me: acceptHandler and readHandler are running on the same event loop and the same thread. time t0 - readHandler is running on oldConnectionSocket time t1 - acceptHandler runs time t2 - acceptHandler