abiword-asio.patch

   1 --- abiword-3.0.1/plugins/collab/backends/service/xp/AsioRealmProtocol.h.orig   2012-05-25 18:12:56.000000000 +0200
   2 +++ abiword-3.0.1/plugins/collab/backends/service/xp/AsioRealmProtocol.h        2016-05-15 18:45:59.357036926 +0200
   3 @@ -8,48 +8,48 @@ namespace realm {
   4  namespace protocolv1 {
   5
   6         template <typename WriteHandler>
   7 -       static void send(const RoutingPacket& p, asio::ip::tcp::socket& socket, WriteHandler handler) {
   8 -               std::vector<asio::const_buffer> bufs(4);
   9 -               bufs.push_back(asio::buffer(&p.type(), 1));
  10 -               bufs.push_back(asio::buffer(&p.getPayloadSize(), 4)); // FIXME: not Big Endian safe!
  11 -               bufs.push_back(asio::buffer(&p.getAddressCount(), 1));
  12 -               bufs.push_back(asio::buffer(&(p.getConnectionIds()[0]), p.getConnectionIds().size()));
  13 -               bufs.push_back(asio::buffer(*p.getMessage()));
  14 -               asio::async_write(socket, bufs, handler);
  15 +       static void send(const RoutingPacket& p, boost::asio::ip::tcp::socket& socket, WriteHandler handler) {
  16 +               std::vector<boost::asio::const_buffer> bufs(4);
  17 +               bufs.push_back(boost::asio::buffer(&p.type(), 1));
  18 +               bufs.push_back(boost::asio::buffer(&p.getPayloadSize(), 4)); // FIXME: not Big Endian safe!
  19 +               bufs.push_back(boost::asio::buffer(&p.getAddressCount(), 1));
  20 +               bufs.push_back(boost::asio::buffer(&(p.getConnectionIds()[0]), p.getConnectionIds().size()));
  21 +               bufs.push_back(boost::asio::buffer(*p.getMessage()));
  22 +               boost::asio::async_write(socket, bufs, handler);
  23         }
  24
  25         template <typename WriteHandler>
  26 -       static void send(const DeliverPacket& p, asio::ip::tcp::socket& socket, WriteHandler handler) {
  27 -               std::vector<asio::const_buffer> bufs(4);
  28 -               bufs.push_back(asio::buffer(&p.type(), 1));
  29 -               bufs.push_back(asio::buffer(&p.getPayloadSize(), 4)); // FIXME: not Big Endian safe!
  30 -               bufs.push_back(asio::buffer(&p.getConnectionId(), 1));
  31 -               bufs.push_back(asio::buffer(*p.getMessage()));
  32 -               asio::async_write(socket, bufs, handler);
  33 +       static void send(const DeliverPacket& p, boost::asio::ip::tcp::socket& socket, WriteHandler handler) {
  34 +               std::vector<boost::asio::const_buffer> bufs(4);
  35 +               bufs.push_back(boost::asio::buffer(&p.type(), 1));
  36 +               bufs.push_back(boost::asio::buffer(&p.getPayloadSize(), 4)); // FIXME: not Big Endian safe!
  37 +               bufs.push_back(boost::asio::buffer(&p.getConnectionId(), 1));
  38 +               bufs.push_back(boost::asio::buffer(*p.getMessage()));
  39 +               boost::asio::async_write(socket, bufs, handler);
  40         }
  41
  42         template <typename WriteHandler>
  43 -       static void send(const UserJoinedPacket& p, asio::ip::tcp::socket& socket, WriteHandler handler) {
  44 -               std::vector<asio::const_buffer> bufs(4);
  45 -               bufs.push_back(asio::buffer(&p.type(), 1));
  46 -               bufs.push_back(asio::buffer(&p.getPayloadSize(), 4)); // FIXME: not Big Endian safe!
  47 -               bufs.push_back(asio::buffer(&p.getConnectionId(), 1));
  48 -               bufs.push_back(asio::buffer(&p.isMaster(), 1));
  49 -               bufs.push_back(asio::buffer(*p.getUserInfo()));
  50 -               asio::async_write(socket, bufs, handler);
  51 +       static void send(const UserJoinedPacket& p, boost::asio::ip::tcp::socket& socket, WriteHandler handler) {
  52 +               std::vector<boost::asio::const_buffer> bufs(4);
  53 +               bufs.push_back(boost::asio::buffer(&p.type(), 1));
  54 +               bufs.push_back(boost::asio::buffer(&p.getPayloadSize(), 4)); // FIXME: not Big Endian safe!
  55 +               bufs.push_back(boost::asio::buffer(&p.getConnectionId(), 1));
  56 +               bufs.push_back(boost::asio::buffer(&p.isMaster(), 1));
  57 +               bufs.push_back(boost::asio::buffer(*p.getUserInfo()));
  58 +               boost::asio::async_write(socket, bufs, handler);
  59         }
  60
  61         template <typename WriteHandler>
  62 -       static void send(const UserLeftPacket& p, asio::ip::tcp::socket& socket, WriteHandler handler) {
  63 -               std::vector<asio::const_buffer> bufs(2);
  64 -               bufs.push_back(asio::buffer(&p.type(), 1));
  65 -               bufs.push_back(asio::buffer(&p.getConnectionId(), 1));
  66 -               asio::async_write(socket, bufs, handler);
  67 +       static void send(const UserLeftPacket& p, boost::asio::ip::tcp::socket& socket, WriteHandler handler) {
  68 +               std::vector<boost::asio::const_buffer> bufs(2);
  69 +               bufs.push_back(boost::asio::buffer(&p.type(), 1));
  70 +               bufs.push_back(boost::asio::buffer(&p.getConnectionId(), 1));
  71 +               boost::asio::async_write(socket, bufs, handler);
  72         }
  73
  74         template <typename WriteHandler>
  75 -       static void send(const SessionTakeOverPacket& p, asio::ip::tcp::socket& socket, WriteHandler handler) {
  76 -               asio::async_write(socket, asio::buffer(&p.type(), 1), handler);
  77 +       static void send(const SessionTakeOverPacket& p, boost::asio::ip::tcp::socket& socket, WriteHandler handler) {
  78 +               boost::asio::async_write(socket, boost::asio::buffer(&p.type(), 1), handler);
  79         }
  80
  81  }
  82 --- abiword-3.0.1/plugins/collab/backends/service/xp/AsyncWorker.h.orig 2013-04-07 15:53:03.000000000 +0200
  83 +++ abiword-3.0.1/plugins/collab/backends/service/xp/AsyncWorker.h      2016-05-15 18:57:50.997154789 +0200
  84 @@ -19,7 +19,7 @@
  85  #ifndef __ASYNC_WORKER__
  86  #define __ASYNC_WORKER__
  87
  88 -#include <asio.hpp>
  89 +#include <boost/thread.hpp>
  90  #include <boost/bind.hpp>
  91  #include <boost/function.hpp>
  92  #include <boost/noncopyable.hpp>
  93 @@ -50,7 +50,7 @@ public:
  94                 m_synchronizer.reset(new Synchronizer(boost::bind(&AsyncWorker<T>::_signal,
  95                                                                                                 boost::enable_shared_from_this<AsyncWorker<T> >::shared_from_this())));
  96                 m_thread_ptr.reset(
  97 -                               new asio::thread(
  98 +                               new boost::thread(
  99                                         boost::bind(&AsyncWorker::_thread_func,
 100                                                                 AsyncWorker<T>::shared_from_this())
 101                                 )
 102 @@ -75,7 +75,7 @@ private:
 103         boost::function<T ()>                                   m_async_func;
 104         boost::function<void (T)>                               m_async_callback;
 105         boost::shared_ptr<Synchronizer>                 m_synchronizer;
 106 -       boost::shared_ptr<asio::thread>                 m_thread_ptr;
 107 +       boost::shared_ptr<boost::thread>                        m_thread_ptr;
 108         T                                                                               m_func_result;
 109  };
 110
 111 --- abiword-3.0.1/plugins/collab/backends/service/xp/RealmConnection.cpp.orig   2013-07-05 03:51:21.000000000 +0200
 112 +++ abiword-3.0.1/plugins/collab/backends/service/xp/RealmConnection.cpp        2016-05-15 19:03:12.877133249 +0200
 113 @@ -19,6 +19,7 @@
 114  #include <boost/function.hpp>
 115  #include <boost/bind.hpp>
 116  #include <boost/lexical_cast.hpp>
 117 +#include <boost/thread.hpp>
 118  #include "ut_assert.h"
 119  #include "ut_debugmsg.h"
 120  #include "ServiceAccountHandler.h"
 121 @@ -68,7 +69,7 @@ bool RealmConnection::connect()
 122                         // setup our local TLS tunnel to the realm
 123                         m_tls_tunnel_ptr.reset(new tls_tunnel::ClientProxy(m_address, m_port, m_ca_file, false));
 124                         m_tls_tunnel_ptr->setup();
 125 -                       asio::thread thread(boost::bind(&tls_tunnel::ClientProxy::run, m_tls_tunnel_ptr));
 126 +                       boost::thread thread(boost::bind(&tls_tunnel::ClientProxy::run, m_tls_tunnel_ptr));
 127
 128                         // make sure we connect to the tunnel, and not directly to the realm
 129                         address = m_tls_tunnel_ptr->local_address();
 130 @@ -76,13 +77,13 @@ bool RealmConnection::connect()
 131                 }
 132
 133                 // connect!
 134 -               asio::ip::tcp::resolver::query query(address, boost::lexical_cast<std::string>(port));
 135 -               asio::ip::tcp::resolver resolver(m_io_service);
 136 -               asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
 137 +               boost::asio::ip::tcp::resolver::query query(address, boost::lexical_cast<std::string>(port));
 138 +               boost::asio::ip::tcp::resolver resolver(m_io_service);
 139 +               boost::asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
 140
 141                 bool connected = false;
 142 -               asio::error_code error_code;
 143 -               while (iterator != asio::ip::tcp::resolver::iterator())
 144 +               boost::system::error_code error_code;
 145 +               while (iterator != boost::asio::ip::tcp::resolver::iterator())
 146                 {
 147                         try
 148                         {
 149 @@ -90,7 +91,7 @@ bool RealmConnection::connect()
 150                                 connected = true;
 151                                 break;
 152                         }
 153 -                       catch (asio::system_error se)
 154 +                       catch (boost::system::system_error se)
 155                         {
 156                                 error_code = se.code();
 157                                 try { m_socket.close(); } catch(...) {}
 158 @@ -99,7 +100,7 @@ bool RealmConnection::connect()
 159                 }
 160                 if (!connected)
 161                 {
 162 -                       UT_DEBUGMSG(("Error connecting to realm: %s", asio::system_error(error_code).what()));
 163 +                       UT_DEBUGMSG(("Error connecting to realm: %s", boost::system::system_error(error_code).what()));
 164                         return false;
 165                 }
 166         }
 167 @@ -108,7 +109,7 @@ bool RealmConnection::connect()
 168                 UT_DEBUGMSG(("tls_tunnel exception connecting to realm: %s\n", e.message().c_str()));
 169                 return false;
 170         }
 171 -       catch (asio::system_error& se)
 172 +       catch (boost::system::system_error& se)
 173         {
 174                 UT_DEBUGMSG(("Error connecting to realm: %s\n", se.what()));
 175                 return false;
 176 @@ -131,7 +132,7 @@ bool RealmConnection::connect()
 177         // start reading realm messages
 178         _receive();
 179
 180 -       m_thread_ptr.reset(new asio::thread(boost::bind(&asio::io_service::run, &m_io_service)));
 181 +       m_thread_ptr.reset(new boost::thread(boost::bind(&boost::asio::io_service::run, &m_io_service)));
 182         return true;
 183  }
 184
 185 @@ -145,8 +146,8 @@ void RealmConnection::disconnect()
 186         // the complete disconnect
 187         if (m_socket.is_open())
 188         {
 189 -               asio::error_code ac;
 190 -               m_socket.shutdown(asio::ip::tcp::socket::shutdown_both, ac);
 191 +               boost::system::error_code ac;
 192 +               m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ac);
 193                 m_socket.close(ac);
 194         }
 195  }
 196 @@ -217,8 +218,8 @@ void RealmConnection::_disconnect()
 197
 198         if (m_socket.is_open())
 199         {
 200 -               asio::error_code ac;
 201 -               m_socket.shutdown(asio::ip::tcp::socket::shutdown_both, ac);
 202 +               boost::system::error_code ac;
 203 +               m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ac);
 204                 m_socket.close(ac);
 205         }
 206
 207 @@ -266,13 +267,13 @@ bool RealmConnection::_login()
 208         {
 209                 // send the login credententials
 210                 // TODO: we should check the number of bytes written
 211 -               asio::write(m_socket, asio::buffer(header));
 212 +               boost::asio::write(m_socket, boost::asio::buffer(header));
 213
 214                 // read the login response
 215                 // TODO: we should check the number of bytes read
 216 -               asio::read(m_socket, asio::buffer(&response[0], response.size()));
 217 +               boost::asio::read(m_socket, boost::asio::buffer(&response[0], response.size()));
 218         }
 219 -       catch (asio::system_error e)
 220 +       catch (boost::system::system_error e)
 221         {
 222                 UT_DEBUGMSG(("Error while writing/writing protocol header: %s\n", e.what()));
 223                 return false;
 224 @@ -315,7 +316,7 @@ UserJoinedPacketPtr RealmConnection::_re
 225  {
 226         // receive the packet type
 227         std::string msg(1, '\0');
 228 -       asio::read(m_socket, asio::buffer(&msg[0], msg.size()));
 229 +       boost::asio::read(m_socket, boost::asio::buffer(&msg[0], msg.size()));
 230         rpv1::packet_type packet_type = static_cast<rpv1::packet_type>(msg[0]);
 231         if (packet_type != rpv1::PACKET_USERJOINED)
 232                 return UserJoinedPacketPtr();
 233 @@ -326,17 +327,17 @@ UserJoinedPacketPtr RealmConnection::_re
 234                 uint8_t conn_id = 0;
 235                 uint8_t m = 0;
 236
 237 -               boost::array<asio::mutable_buffer, 3> buf = {{
 238 -                       asio::buffer(&payload_size, sizeof(payload_size)),
 239 -                       asio::buffer(&conn_id, sizeof(conn_id)),
 240 -                       asio::buffer(&m, sizeof(m)) }};
 241 -               asio::read(m_socket, buf);
 242 +               boost::array<boost::asio::mutable_buffer, 3> buf = {{
 243 +                       boost::asio::buffer(&payload_size, sizeof(payload_size)),
 244 +                       boost::asio::buffer(&conn_id, sizeof(conn_id)),
 245 +                       boost::asio::buffer(&m, sizeof(m)) }};
 246 +               boost::asio::read(m_socket, buf);
 247
 248                 boost::shared_ptr<std::string> userinfo_ptr(new std::string(payload_size - 2, '\0'));
 249 -               asio::read(m_socket, asio::buffer(&(*userinfo_ptr)[0], userinfo_ptr->size()));
 250 +               boost::asio::read(m_socket, boost::asio::buffer(&(*userinfo_ptr)[0], userinfo_ptr->size()));
 251
 252                 return UserJoinedPacketPtr(new rpv1::UserJoinedPacket(conn_id, static_cast<bool>(m), userinfo_ptr));
 253 -       } catch (asio::system_error se) {
 254 +       } catch (boost::system::system_error se) {
 255                 return UserJoinedPacketPtr();
 256         }
 257  }
 258 @@ -346,12 +347,12 @@ void RealmConnection::_receive()
 259         UT_DEBUGMSG(("RealmConnection::_receive()\n"));
 260         m_buf.clear();
 261         boost::shared_ptr<std::string> msg_ptr(new std::string(1, '\0'));
 262 -       asio::async_read(m_socket, asio::buffer(&(*msg_ptr)[0], msg_ptr->size()),
 263 +       boost::asio::async_read(m_socket, boost::asio::buffer(&(*msg_ptr)[0], msg_ptr->size()),
 264                 boost::bind(&RealmConnection::_message, shared_from_this(),
 265 -                       asio::placeholders::error, asio::placeholders::bytes_transferred, msg_ptr));
 266 +                       boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, msg_ptr));
 267  }
 268
 269 -void RealmConnection::_message(const asio::error_code& e, std::size_t /*bytes_transferred*/, boost::shared_ptr<std::string> msg_ptr)
 270 +void RealmConnection::_message(const boost::system::error_code& e, std::size_t /*bytes_transferred*/, boost::shared_ptr<std::string> msg_ptr)
 271  {
 272         UT_DEBUGMSG(("RealmConnection::_message()\n"));
 273         if (e)
 274 @@ -390,15 +391,15 @@ void RealmConnection::_complete_packet(r
 275                         UT_DEBUGMSG(("Need more data (%d bytes) for this packet...\n", bytes_needed));
 276                         // read the needed number of bytes
 277                         char* ptr = m_buf.prepare(bytes_needed);
 278 -                       asio::async_read(m_socket, asio::buffer(ptr, bytes_needed),
 279 +                       boost::asio::async_read(m_socket, boost::asio::buffer(ptr, bytes_needed),
 280                                                         boost::bind(&RealmConnection::_complete, shared_from_this(),
 281 -                                                               asio::placeholders::error, asio::placeholders::bytes_transferred, packet_ptr)
 282 +                                                               boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, packet_ptr)
 283                                                         );
 284                         break;
 285         }
 286  }
 287
 288 -void RealmConnection::_complete(const asio::error_code& e, std::size_t bytes_transferred, realm::protocolv1::PacketPtr packet_ptr)
 289 +void RealmConnection::_complete(const boost::system::error_code& e, std::size_t bytes_transferred, realm::protocolv1::PacketPtr packet_ptr)
 290  {
 291         UT_DEBUGMSG(("RealmConnection::_complete()\n"));
 292         if (e)
 293 --- abiword-3.0.1/plugins/collab/backends/service/xp/RealmConnection.h.orig     2013-07-05 03:51:21.000000000 +0200
 294 +++ abiword-3.0.1/plugins/collab/backends/service/xp/RealmConnection.h  2016-05-15 18:58:28.419089961 +0200
 295 @@ -21,7 +21,8 @@
 296
 297  #include <boost/shared_ptr.hpp>
 298  #include <boost/enable_shared_from_this.hpp>
 299 -#include <asio.hpp>
 300 +#include <boost/asio.hpp>
 301 +#include <boost/thread.hpp>
 302  #include <vector>
 303  #include <string>
 304  #include "ut_types.h"
 305 @@ -90,7 +91,7 @@ public:
 306                 { m_pDoc = pDoc; }
 307         SynchronizedQueue<realm::protocolv1::PacketPtr>&                queue()
 308                 { return m_packet_queue; }
 309 -       asio::ip::tcp::socket&                          socket()
 310 +       boost::asio::ip::tcp::socket&                           socket()
 311                 { return m_socket; }
 312
 313         void                                                            loadDocumentStart(AP_Dialog_GenericProgress* pDlg,
 314 @@ -113,21 +114,21 @@ private:
 315         bool                                                            _login();
 316         UserJoinedPacketPtr                                     _receiveUserJoinedPacket();
 317         void                                                            _receive();
 318 -       void                                                            _message(const asio::error_code& e,
 319 +       void                                                            _message(const boost::system::error_code& e,
 320                                                                                                 std::size_t bytes_transferred,
 321                                                                                                 boost::shared_ptr<std::string> msg_ptr);
 322
 323         void                                                            _complete_packet(realm::protocolv1::PacketPtr packet_ptr);
 324 -       void                                                            _complete(const asio::error_code& e, std::size_t bytes_transferred,
 325 +       void                                                            _complete(const boost::system::error_code& e, std::size_t bytes_transferred,
 326                                                                                                 realm::protocolv1::PacketPtr packet_ptr);
 327
 328 -       asio::io_service                                        m_io_service;
 329 +       boost::asio::io_service                                 m_io_service;
 330         std::string                                                     m_ca_file;
 331         std::string                                                     m_address;
 332         int                                                                     m_port;
 333         int                                                                     m_tls;
 334 -       asio::ip::tcp::socket                           m_socket;
 335 -       boost::shared_ptr<asio::thread>         m_thread_ptr;
 336 +       boost::asio::ip::tcp::socket                            m_socket;
 337 +       boost::shared_ptr<boost::thread>                m_thread_ptr;
 338         std::string                                                     m_cookie;
 339         UT_uint64                                                       m_user_id; // only valid after login
 340         UT_uint8                                                        m_connection_id; // only valid after login
 341 --- abiword-3.0.1/plugins/collab/backends/service/xp/RealmProtocol.h.orig       2012-05-25 18:12:56.000000000 +0200
 342 +++ abiword-3.0.1/plugins/collab/backends/service/xp/RealmProtocol.h    2016-05-15 18:43:04.911353671 +0200
 343 @@ -9,7 +9,7 @@
 344  #include <stdint.h>
 345  #endif
 346  #include <boost/shared_ptr.hpp>
 347 -#include <asio.hpp>
 348 +#include <boost/asio.hpp>
 349
 350  namespace realm {
 351
 352 @@ -29,7 +29,7 @@ namespace protocolv1 {
 353
 354  class Packet;
 355  typedef boost::shared_ptr<Packet> PacketPtr;
 356 -typedef boost::shared_ptr<asio::streambuf> StreamPtr;
 357 +typedef boost::shared_ptr<boost::asio::streambuf> StreamPtr;
 358
 359  // the packet type values must match up the corresponding body_size in
 360  // RealmProtocol.cpp (ugly, but it's fast)!
 361 --- abiword-3.0.1/plugins/collab/backends/service/xp/ServiceAccountHandler.cpp.orig     2013-07-05 03:51:21.000000000 +0200
 362 +++ abiword-3.0.1/plugins/collab/backends/service/xp/ServiceAccountHandler.cpp  2016-05-15 19:03:33.601538287 +0200
 363 @@ -437,7 +437,7 @@ bool ServiceAccountHandler::send(const P
 364         return true;
 365  }
 366
 367 -void ServiceAccountHandler::_write_handler(const asio::error_code& e, std::size_t /*bytes_transferred*/,
 368 +void ServiceAccountHandler::_write_handler(const boost::system::error_code& e, std::size_t /*bytes_transferred*/,
 369                                                                                         boost::shared_ptr<const RealmBuddy> /*recipient*/, boost::shared_ptr<realm::protocolv1::Packet> packet)
 370  {
 371         if (e)
 372 @@ -453,7 +453,7 @@ void ServiceAccountHandler::_write_handl
 373         }
 374  }
 375
 376 -void ServiceAccountHandler::_write_result(const asio::error_code& e, std::size_t /*bytes_transferred*/,
 377 +void ServiceAccountHandler::_write_result(const boost::system::error_code& e, std::size_t /*bytes_transferred*/,
 378                                                                                                         ConnectionPtr /*connection*/, boost::shared_ptr<realm::protocolv1::Packet> packet)
 379  {
 380         if (e)
 381 @@ -1709,7 +1709,7 @@ void ServiceAccountHandler::_handleMessa
 382                                                         boost::shared_ptr<rpv1::SessionTakeOverPacket> stop(new rpv1::SessionTakeOverPacket());
 383                                                         rpv1::send(*stop, connection->socket(),
 384                                                                         boost::bind(&ServiceAccountHandler::_write_result, this,
 385 -                                                                               asio::placeholders::error, asio::placeholders::bytes_transferred, connection,
 386 +                                                                               boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, connection,
 387                                                                                         boost::static_pointer_cast<rpv1::Packet>(stop))
 388                                                                 );
 389
 390 --- abiword-3.0.1/plugins/collab/backends/service/xp/ServiceAccountHandler.h.orig       2013-04-07 15:53:03.000000000 +0200
 391 +++ abiword-3.0.1/plugins/collab/backends/service/xp/ServiceAccountHandler.h    2016-05-15 18:58:43.736548728 +0200
 392 @@ -149,14 +149,14 @@ private:
 393         {
 394                 realm::protocolv1::send(*packet, recipient->connection()->socket(),
 395                         boost::bind(&ServiceAccountHandler::_write_handler, this,
 396 -                                                       asio::placeholders::error, asio::placeholders::bytes_transferred, recipient,
 397 +                                                       boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, recipient,
 398                                                         boost::static_pointer_cast<rpv1::Packet>(packet)));
 399         }
 400
 401 -       void                                                                    _write_handler(const asio::error_code& e, std::size_t bytes_transferred,
 402 +       void                                                                    _write_handler(const boost::system::error_code& e, std::size_t bytes_transferred,
 403                                                                                                         boost::shared_ptr<const RealmBuddy> recipient, boost::shared_ptr<rpv1::Packet> packet);
 404
 405 -       void                                                                    _write_result(const asio::error_code& e, std::size_t bytes_transferred,
 406 +       void                                                                    _write_result(const boost::system::error_code& e, std::size_t bytes_transferred,
 407                                                                                                         ConnectionPtr connection, boost::shared_ptr<rpv1::Packet> packet);
 408
 409         bool                                                                    _listDocuments(soa::function_call_ptr fc_ptr,
 410 --- abiword-3.0.1/plugins/collab/backends/service/xp/tls_tunnel.cpp.orig        2014-11-04 02:12:14.000000000 +0100
 411 +++ abiword-3.0.1/plugins/collab/backends/service/xp/tls_tunnel.cpp     2016-05-15 19:12:18.015323548 +0200
 412 @@ -45,7 +45,7 @@ namespace tls_tunnel {
 413  #define TLS_VERIFY_HOSTNAME_ERROR "Error verifying hostname"
 414  #define TLS_CANT_GET_PEER_CERT_ERROR "Failed to get peer certificate"
 415
 416 -typedef boost::shared_ptr<asio::ip::tcp::socket> socket_ptr_t;
 417 +typedef boost::shared_ptr<boost::asio::ip::tcp::socket> socket_ptr_t;
 418  typedef boost::shared_ptr<gnutls_session_t> session_ptr_t;
 419  typedef boost::shared_ptr< std::vector<char> > buffer_ptr_t;
 420
 421 @@ -79,12 +79,12 @@ public:
 422         }
 423  };
 424
 425 -asio::io_service& Transport::io_service() {
 426 +boost::asio::io_service& Transport::io_service() {
 427         return io_service_;
 428  }
 429
 430  void Transport::run() {
 431 -       asio::error_code ec;
 432 +       boost::system::error_code ec;
 433         io_service_.run(ec);
 434  }
 435
 436 @@ -112,17 +112,17 @@ ClientTransport::ClientTransport(const s
 437  }
 438
 439  void ClientTransport::connect() {
 440 -       asio::ip::tcp::resolver resolver(io_service());
 441 -       asio::ip::tcp::resolver::query query(host_, boost::lexical_cast<std::string>(port_));
 442 -       asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
 443 -       socket_ptr_t socket_ptr(new asio::ip::tcp::socket(io_service()));
 444 +       boost::asio::ip::tcp::resolver resolver(io_service());
 445 +       boost::asio::ip::tcp::resolver::query query(host_, boost::lexical_cast<std::string>(port_));
 446 +       boost::asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
 447 +       socket_ptr_t socket_ptr(new boost::asio::ip::tcp::socket(io_service()));
 448
 449 -       if (iterator == asio::ip::tcp::resolver::iterator())
 450 -               throw asio::system_error(asio::error::host_not_found);
 451 +       if (iterator == boost::asio::ip::tcp::resolver::iterator())
 452 +               throw boost::system::system_error(boost::asio::error::host_not_found);
 453
 454         bool connected = false;
 455 -       asio::error_code error_code;
 456 -       while (iterator != asio::ip::tcp::resolver::iterator())
 457 +       boost::system::error_code error_code;
 458 +       while (iterator != boost::asio::ip::tcp::resolver::iterator())
 459         {
 460                 try
 461                 {
 462 @@ -130,7 +130,7 @@ void ClientTransport::connect() {
 463                         connected = true;
 464                         break;
 465                 }
 466 -               catch (asio::system_error se)
 467 +               catch (boost::system::system_error se)
 468                 {
 469                         error_code = se.code();
 470                         try { socket_ptr->close(); } catch(...) {}
 471 @@ -138,24 +138,24 @@ void ClientTransport::connect() {
 472                 iterator++;
 473         }
 474         if (!connected)
 475 -               throw asio::system_error(error_code); // throw the last error on failure
 476 +               throw boost::system::system_error(error_code); // throw the last error on failure
 477         on_connect_(shared_from_this(), socket_ptr);
 478  }
 479
 480  ServerTransport::ServerTransport(const std::string& ip, unsigned short port,
 481                 boost::function<void (transport_ptr_t, socket_ptr_t)> on_connect)
 482         : Transport(),
 483 -       acceptor_(io_service(), asio::ip::tcp::endpoint(asio::ip::address_v4::from_string(ip), port)),
 484 +       acceptor_(io_service(), boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4::from_string(ip), port)),
 485         on_connect_(on_connect)
 486  {
 487  }
 488
 489  void ServerTransport::accept() {
 490 -       socket_ptr_t socket_ptr(new asio::ip::tcp::socket(io_service()));
 491 -       acceptor_.async_accept(*socket_ptr, boost::bind(&ServerTransport::on_accept, this, asio::placeholders::error, socket_ptr));
 492 +       socket_ptr_t socket_ptr(new boost::asio::ip::tcp::socket(io_service()));
 493 +       acceptor_.async_accept(*socket_ptr, boost::bind(&ServerTransport::on_accept, this, boost::asio::placeholders::error, socket_ptr));
 494  }
 495
 496 -void ServerTransport::on_accept(const asio::error_code& error, socket_ptr_t socket_ptr) {
 497 +void ServerTransport::on_accept(const boost::system::error_code& error, socket_ptr_t socket_ptr) {
 498         if (error) {
 499                 return;
 500         }
 501 @@ -164,19 +164,19 @@ void ServerTransport::on_accept(const as
 502  }
 503
 504  static ssize_t read(gnutls_transport_ptr_t ptr, void* buffer, size_t size) {
 505 -       asio::ip::tcp::socket* socket = reinterpret_cast<asio::ip::tcp::socket*>(ptr);
 506 +       boost::asio::ip::tcp::socket* socket = reinterpret_cast<boost::asio::ip::tcp::socket*>(ptr);
 507         try {
 508 -               return asio::read(*socket, asio::buffer(buffer, size));
 509 -       } catch (asio::system_error& /*se*/) {
 510 +               return boost::asio::read(*socket, boost::asio::buffer(buffer, size));
 511 +       } catch (boost::system::system_error& /*se*/) {
 512                 return -1;
 513         }
 514  }
 515
 516  static ssize_t write(gnutls_transport_ptr_t ptr, const void* buffer, size_t size) {
 517 -       asio::ip::tcp::socket* socket = reinterpret_cast<asio::ip::tcp::socket*>(ptr);
 518 +       boost::asio::ip::tcp::socket* socket = reinterpret_cast<boost::asio::ip::tcp::socket*>(ptr);
 519         try {
 520 -               return asio::write(*socket, asio::buffer(buffer, size));
 521 -       } catch (asio::system_error& /*se*/) {
 522 +               return boost::asio::write(*socket, boost::asio::buffer(buffer, size));
 523 +       } catch (boost::system::system_error& /*se*/) {
 524                 return -1;
 525         }
 526  }
 527 @@ -223,7 +223,7 @@ Proxy::Proxy(const std::string& ca_file)
 528                 throw Exception(TLS_SETUP_ERROR);
 529  }
 530
 531 -void Proxy::on_local_read(const asio::error_code& error, std::size_t bytes_transferred,
 532 +void Proxy::on_local_read(const boost::system::error_code& error, std::size_t bytes_transferred,
 533                 transport_ptr_t transport_ptr, session_ptr_t session_ptr, socket_ptr_t local_socket_ptr,
 534                 buffer_ptr_t local_buffer_ptr, socket_ptr_t remote_socket_ptr)
 535  {
 536 @@ -240,8 +240,8 @@ void Proxy::on_local_read(const asio::er
 537         }
 538
 539         local_socket_ptr->async_receive(
 540 -                       asio::buffer(&(*local_buffer_ptr)[0], local_buffer_ptr->size()),
 541 -                       boost::bind(&Proxy::on_local_read, this, asio::placeholders::error, asio::placeholders::bytes_transferred,
 542 +                       boost::asio::buffer(&(*local_buffer_ptr)[0], local_buffer_ptr->size()),
 543 +                       boost::bind(&Proxy::on_local_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred,
 544                                         transport_ptr, session_ptr, local_socket_ptr, local_buffer_ptr, remote_socket_ptr)
 545                 );
 546  }
 547 @@ -250,7 +250,7 @@ void Proxy::tunnel(transport_ptr_t trans
 548                 socket_ptr_t local_socket_ptr, socket_ptr_t remote_socket_ptr)
 549  {
 550         buffer_ptr_t local_buffer_ptr(new std::vector<char>(LOCAL_BUFFER_SIZE));
 551 -       t = new asio::thread(boost::bind(&Proxy::tunnel_, this, transport_ptr,
 552 +       t = new boost::thread(boost::bind(&Proxy::tunnel_, this, transport_ptr,
 553                                                         session_ptr, local_socket_ptr, local_buffer_ptr, remote_socket_ptr));
 554  }
 555
 556 @@ -262,14 +262,14 @@ void Proxy::disconnect_(transport_ptr_t
 557                 gnutls_bye(*session_ptr, GNUTLS_SHUT_RDWR);
 558
 559         // shutdown the sockets belonging to this tunnel
 560 -       asio::error_code ec;
 561 +       boost::system::error_code ec;
 562         if (local_socket_ptr && local_socket_ptr->is_open()) {
 563 -               local_socket_ptr->shutdown(asio::ip::tcp::socket::shutdown_both, ec);
 564 +               local_socket_ptr->shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
 565                 local_socket_ptr->close(ec);
 566         }
 567
 568         if (remote_socket_ptr && remote_socket_ptr->is_open()) {
 569 -               remote_socket_ptr->shutdown(asio::ip::tcp::socket::shutdown_both, ec);
 570 +               remote_socket_ptr->shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
 571                 remote_socket_ptr->close(ec);
 572         }
 573  }
 574 @@ -278,8 +278,8 @@ void Proxy::tunnel_(transport_ptr_t tran
 575                 buffer_ptr_t local_buffer_ptr, socket_ptr_t remote_socket_ptr)
 576  {
 577         local_socket_ptr->async_receive(
 578 -                       asio::buffer(&(*local_buffer_ptr)[0], local_buffer_ptr->size()),
 579 -                       boost::bind(&Proxy::on_local_read, this, asio::placeholders::error, asio::placeholders::bytes_transferred,
 580 +                       boost::asio::buffer(&(*local_buffer_ptr)[0], local_buffer_ptr->size()),
 581 +                       boost::bind(&Proxy::on_local_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred,
 582                                         transport_ptr, session_ptr, local_socket_ptr, local_buffer_ptr, remote_socket_ptr)
 583                 );
 584
 585 @@ -297,8 +297,8 @@ void Proxy::tunnel_(transport_ptr_t tran
 586
 587                 // forward the data over the local connection
 588                 try {
 589 -                       asio::write(*local_socket_ptr, asio::buffer(&tunnel_buffer[0], bytes_transferred));
 590 -               } catch (asio::system_error& /*se*/) {
 591 +                       boost::asio::write(*local_socket_ptr, boost::asio::buffer(&tunnel_buffer[0], bytes_transferred));
 592 +               } catch (boost::system::system_error& /*se*/) {
 593                         break;
 594                 }
 595         }
 596 @@ -333,15 +333,15 @@ void ClientProxy::setup()
 597                 for (unsigned short port = MIN_CLIENT_PORT; port <= MAX_CLIENT_PORT; port++) {
 598                         try {
 599                                 acceptor_ptr.reset(
 600 -                                               new asio::ip::tcp::acceptor(transport_ptr_->io_service(),
 601 -                                                                                                               asio::ip::tcp::endpoint(asio::ip::address_v4::from_string(local_address_),
 602 +                                               new boost::asio::ip::tcp::acceptor(transport_ptr_->io_service(),
 603 +                                                                                                               boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4::from_string(local_address_),
 604                                                                                                                 port), false));
 605                                 local_port_ = port;
 606                                 break;
 607 -                       } catch (asio::system_error& se) {
 608 +                       } catch (boost::system::system_error& se) {
 609                                 if (port == MAX_CLIENT_PORT)
 610                                         throw se;
 611 -                               if (se.code() != asio::error::address_in_use)
 612 +                               if (se.code() != boost::asio::error::address_in_use)
 613                                         throw se;
 614                                 // this port is already in use, try another one
 615                                 continue;
 616 @@ -350,7 +350,7 @@ void ClientProxy::setup()
 617
 618                 // connect the transport
 619                 boost::static_pointer_cast<ClientTransport>(transport_ptr_)->connect();
 620 -       } catch (asio::system_error& se) {
 621 +       } catch (boost::system::system_error& se) {
 622                 throw Exception(std::string(TRANSPORT_ERROR) + se.what());
 623         }
 624  }
 625 @@ -378,12 +378,12 @@ void ClientProxy::on_transport_connect(t
 626         }
 627
 628         // start accepting connections on the local socket
 629 -       socket_ptr_t local_socket_ptr(new asio::ip::tcp::socket(transport_ptr->io_service()));
 630 +       socket_ptr_t local_socket_ptr(new boost::asio::ip::tcp::socket(transport_ptr->io_service()));
 631         acceptor_ptr->async_accept(*local_socket_ptr, boost::bind(&ClientProxy::on_client_connect, this,
 632 -                       asio::placeholders::error, transport_ptr, session_ptr, local_socket_ptr, remote_socket_ptr));
 633 +                       boost::asio::placeholders::error, transport_ptr, session_ptr, local_socket_ptr, remote_socket_ptr));
 634  }
 635
 636 -void ClientProxy::on_client_connect(const asio::error_code& error,
 637 +void ClientProxy::on_client_connect(const boost::system::error_code& error,
 638                 transport_ptr_t transport_ptr, session_ptr_t session_ptr,
 639                 socket_ptr_t local_socket_ptr, socket_ptr_t remote_socket_ptr) {
 640         if (error) {
 641 @@ -456,7 +456,7 @@ try
 642                 throw Exception(TLS_SETUP_ERROR);
 643
 644         gnutls_certificate_set_dh_params(x509cred, dh_params);
 645 -} catch (asio::system_error& se) {
 646 +} catch (boost::system::system_error& se) {
 647         throw Exception(std::string(TRANSPORT_ERROR) + se.what());
 648  }
 649
 650 @@ -477,14 +477,14 @@ void ServerProxy::on_transport_connect(t
 651                 return;
 652         }
 653
 654 -       socket_ptr_t local_socket_ptr(new asio::ip::tcp::socket(transport_ptr->io_service()));
 655 +       socket_ptr_t local_socket_ptr(new boost::asio::ip::tcp::socket(transport_ptr->io_service()));
 656         try {
 657 -               asio::ip::tcp::resolver resolver(transport_ptr->io_service());
 658 -               asio::ip::tcp::resolver::query query("127.0.0.1", boost::lexical_cast<std::string>(local_port_));
 659 -               asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
 660 +               boost::asio::ip::tcp::resolver resolver(transport_ptr->io_service());
 661 +               boost::asio::ip::tcp::resolver::query query("127.0.0.1", boost::lexical_cast<std::string>(local_port_));
 662 +               boost::asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
 663
 664                 bool connected = false;
 665 -               while (iterator != asio::ip::tcp::resolver::iterator())
 666 +               while (iterator != boost::asio::ip::tcp::resolver::iterator())
 667                 {
 668                         try
 669                         {
 670 @@ -492,7 +492,7 @@ void ServerProxy::on_transport_connect(t
 671                                 connected = true;
 672                                 break;
 673                         }
 674 -                       catch (asio::system_error /*se*/)
 675 +                       catch (boost::system::system_error /*se*/)
 676                         {
 677                                 // make sure we close the socket after a failed attempt, as it
 678                                 // may have been opened by the connect() call.
 679 @@ -505,7 +505,7 @@ void ServerProxy::on_transport_connect(t
 680                         disconnect_(transport_ptr, session_ptr, local_socket_ptr, remote_socket_ptr);
 681                         return;
 682                 }
 683 -       } catch (asio::system_error& /*se*/) {
 684 +       } catch (boost::system::system_error& /*se*/) {
 685                 disconnect_(transport_ptr, session_ptr, local_socket_ptr, remote_socket_ptr);
 686                 return;
 687         }
 688 --- abiword-3.0.1/plugins/collab/backends/service/xp/tls_tunnel.h.orig  2014-11-04 02:12:14.000000000 +0100
 689 +++ abiword-3.0.1/plugins/collab/backends/service/xp/tls_tunnel.h       2016-05-15 18:59:24.148638527 +0200
 690 @@ -33,7 +33,8 @@
 691  #include <boost/function.hpp>
 692  #include <boost/lexical_cast.hpp>
 693  #include <boost/enable_shared_from_this.hpp>
 694 -#include <asio.hpp>
 695 +#include <boost/asio.hpp>
 696 +#include <boost/thread.hpp>
 697  #include <string>
 698  #include <vector>
 699  #ifdef _MSC_VER
 700 @@ -45,7 +46,7 @@ typedef int pid_t;
 701
 702  namespace tls_tunnel {
 703
 704 -typedef boost::shared_ptr<asio::ip::tcp::socket> socket_ptr_t;
 705 +typedef boost::shared_ptr<boost::asio::ip::tcp::socket> socket_ptr_t;
 706  typedef boost::shared_ptr<gnutls_session_t> session_ptr_t;
 707  typedef boost::shared_ptr< std::vector<char> > buffer_ptr_t;
 708
 709 @@ -59,7 +60,7 @@ private:
 710
 711  class Transport : public boost::enable_shared_from_this<Transport> {
 712  public:
 713 -       asio::io_service& io_service();
 714 +       boost::asio::io_service& io_service();
 715         void run();
 716         void stop();
 717
 718 @@ -68,8 +69,8 @@ protected:
 719         virtual ~Transport();
 720
 721  private:
 722 -       asio::io_service io_service_;
 723 -       asio::io_service::work work_;
 724 +       boost::asio::io_service io_service_;
 725 +       boost::asio::io_service::work work_;
 726  };
 727
 728  typedef boost::shared_ptr<Transport> transport_ptr_t;
 729 @@ -92,9 +93,9 @@ public:
 730                         boost::function<void (transport_ptr_t, socket_ptr_t)> on_connect);
 731         void accept();
 732  private:
 733 -       void on_accept(const asio::error_code& error, socket_ptr_t socket_ptr);
 734 +       void on_accept(const boost::system::error_code& error, socket_ptr_t socket_ptr);
 735
 736 -       asio::ip::tcp::acceptor acceptor_;
 737 +       boost::asio::ip::tcp::acceptor acceptor_;
 738         boost::function<void (transport_ptr_t, socket_ptr_t)> on_connect_;
 739  };
 740
 741 @@ -110,7 +111,7 @@ public:
 742  protected:
 743         Proxy(const std::string& ca_file);
 744
 745 -       void on_local_read(const asio::error_code& error, std::size_t bytes_transferred,
 746 +       void on_local_read(const boost::system::error_code& error, std::size_t bytes_transferred,
 747                         transport_ptr_t transport_ptr, session_ptr_t session_ptr, socket_ptr_t local_socket_ptr,
 748                         buffer_ptr_t local_buffer_ptr, socket_ptr_t remote_socket_ptr);
 749         void tunnel(transport_ptr_t transport_ptr, session_ptr_t session_ptr,
 750 @@ -127,7 +128,7 @@ private:
 751                         socket_ptr_t local_socket_ptr, buffer_ptr_t local_buffer_ptr,
 752                         socket_ptr_t remote_socket);
 753
 754 -       asio::thread* t;
 755 +       boost::thread* t;
 756  };
 757
 758  // FIXME: this clientproxy can only handle 1 SSL connection at the same time
 759 @@ -144,7 +145,7 @@ public:
 760
 761  private:
 762         void on_transport_connect(transport_ptr_t transport_ptr, socket_ptr_t remote_socket_ptr);
 763 -       void on_client_connect(const asio::error_code& error, transport_ptr_t transport_ptr,
 764 +       void on_client_connect(const boost::system::error_code& error, transport_ptr_t transport_ptr,
 765                         session_ptr_t session_ptr, socket_ptr_t local_socket_ptr, socket_ptr_t remote_socket_ptr);
 766         session_ptr_t setup_tls_session(socket_ptr_t remote_socket_ptr);
 767
 768 @@ -152,7 +153,7 @@ private:
 769         unsigned short local_port_;
 770         std::string connect_address_;
 771         unsigned short connect_port_;
 772 -       boost::shared_ptr<asio::ip::tcp::acceptor> acceptor_ptr;
 773 +       boost::shared_ptr<boost::asio::ip::tcp::acceptor> acceptor_ptr;
 774         bool check_hostname_;
 775  };
 776
 777 --- abiword-3.0.1/plugin-configure.m4.orig      2014-12-23 06:13:14.000000000 +0100
 778 +++ abiword-3.0.1/plugin-configure.m4   2016-05-15 19:15:04.470598705 +0200
 779 @@ -565,7 +565,7 @@
 780         enable_collab_backend_tcp=$enableval
 781         if test "$enable_collab_backend_tcp" != "no"; then
 782                 AC_LANG_PUSH(C++)
 783 -               AC_CHECK_HEADERS([asio.hpp], [],
 784 +               AC_CHECK_HEADERS([boost/asio.hpp], [],
 785                 [
 786                         AC_MSG_ERROR([collab plugin: asio is required for the collab plugin TCP backend, see http://think-async.com/])
 787                 ])
 788 @@ -573,7 +573,7 @@
 789         fi
 790  ], [
 791         AC_LANG_PUSH(C++)
 792 -       AC_CHECK_HEADERS([asio.hpp],
 793 +       AC_CHECK_HEADERS([boost/asio.hpp],
 794         [
 795                 enable_collab_backend_tcp="yes"
 796         ])
 797 @@ -604,7 +604,7 @@
 798         enable_collab_backend_service=$enableval
 799         if test "$enable_collab_backend_service" != "no"; then
 800                 AC_LANG_PUSH(C++)
 801 -               AC_CHECK_HEADERS([asio.hpp], [],
 802 +               AC_CHECK_HEADERS([boost/asio.hpp], [],
 803                 [
 804                         AC_MSG_ERROR([collab plugin: asio is required for the the abicollab.net backend, see http://think-async.com/])
 805                 ])
 806 @@ -612,7 +612,7 @@
 807         fi
 808  ], [
 809         AC_LANG_PUSH(C++)
 810 -       AC_CHECK_HEADERS([asio.hpp],
 811 +       AC_CHECK_HEADERS([boost/asio.hpp],
 812         [
 813                 enable_collab_backend_service="yes"
 814         ])
 815 --- abiword-3.0.1/plugins/collab/backends/tcp/xp/IOServerHandler.h.orig 2013-07-05 03:51:21.000000000 +0200
 816 +++ abiword-3.0.1/plugins/collab/backends/tcp/xp/IOServerHandler.h      2016-05-16 18:14:49.934309134 +0200
 817 @@ -23,7 +23,7 @@
 818
 819  #include <boost/bind.hpp>
 820  #include <boost/function.hpp>
 821 -#include <asio.hpp>
 822 +#include <boost/asio.hpp>
 823
 824  #include <sync/xp/Synchronizer.h>
 825  #include "Session.h"
 826 @@ -34,7 +34,7 @@ class IOServerHandler
 827  {
 828  public:
 829         IOServerHandler(int port, boost::function<void (IOServerHandler*, boost::shared_ptr<Session>)> af,
 830 -                                       boost::function<void (boost::shared_ptr<Session>)> ef, asio::io_service& io_service_)
 831 +                                       boost::function<void (boost::shared_ptr<Session>)> ef, boost::asio::io_service& io_service_)
 832         :       accept_synchronizer(boost::bind(&IOServerHandler::_signal, this)),
 833                 io_service(io_service_),
 834                 m_pAcceptor(NULL),
 835 @@ -43,7 +43,7 @@ public:
 836                 m_ef(ef)
 837         {
 838                 UT_DEBUGMSG(("IOServerHandler()\n"));
 839 -               m_pAcceptor = new asio::ip::tcp::acceptor(io_service, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port));
 840 +               m_pAcceptor = new boost::asio::ip::tcp::acceptor(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
 841         }
 842
 843         virtual ~IOServerHandler()
 844 @@ -76,7 +76,7 @@ public:
 845                 session_ptr.reset(new Session(io_service, m_ef));
 846                 m_pAcceptor->async_accept(session_ptr->getSocket(),
 847                         boost::bind(&IOServerHandler::handleAsyncAccept,
 848 -                               this, asio::placeholders::error));
 849 +                               this, boost::asio::placeholders::error));
 850         }
 851
 852  private:
 853 @@ -88,7 +88,7 @@ private:
 854                 m_af(this, session_ptr);
 855         }
 856
 857 -       void handleAsyncAccept(const asio::error_code& ec)
 858 +       void handleAsyncAccept(const boost::system::error_code& ec)
 859         {
 860                 UT_DEBUGMSG(("IOServerHandler::handleAsyncAccept()\n"));
 861                 if (ec)
 862 @@ -100,8 +100,8 @@ private:
 863         }
 864
 865         Synchronizer                            accept_synchronizer;
 866 -       asio::io_service&                       io_service;
 867 -       asio::ip::tcp::acceptor*        m_pAcceptor;
 868 +       boost::asio::io_service&                        io_service;
 869 +       boost::asio::ip::tcp::acceptor* m_pAcceptor;
 870         boost::shared_ptr<Session>      session_ptr;
 871
 872         boost::function<void (IOServerHandler*, boost::shared_ptr<Session>)> m_af;
 873 --- abiword-3.0.1/plugins/collab/backends/tcp/xp/Session.h.orig 2014-02-06 02:12:15.000000000 +0100
 874 +++ abiword-3.0.1/plugins/collab/backends/tcp/xp/Session.h      2016-05-16 18:30:27.198273019 +0200
 875 @@ -35,7 +35,7 @@ class TCPAccountHandler;
 876  class Session : public Synchronizer, public boost::noncopyable, public boost::enable_shared_from_this<Session>
 877  {
 878  public:
 879 -       Session(asio::io_service& io_service, boost::function<void (boost::shared_ptr<Session>)> ef)
 880 +       Session(boost::asio::io_service& io_service, boost::function<void (boost::shared_ptr<Session>)> ef)
 881                 : Synchronizer(boost::bind(&Session::_signal, this)),
 882                 socket(io_service),
 883                 queue_protector(),
 884 @@ -43,13 +43,13 @@ public:
 885         {
 886         }
 887
 888 -       void connect(asio::ip::tcp::resolver::iterator& iterator)
 889 +       void connect(boost::asio::ip::tcp::resolver::iterator& iterator)
 890         {
 891                 socket.connect(*iterator);
 892         }
 893
 894         // TODO: don't expose this
 895 -       asio::ip::tcp::socket& getSocket()
 896 +       boost::asio::ip::tcp::socket& getSocket()
 897         {
 898                 return socket;
 899         }
 900 @@ -94,9 +94,9 @@ public:
 901         {
 902                 UT_DEBUGMSG(("Session::asyncReadHeader()\n"));
 903                 packet_data = 0; // just to be sure we'll never touch a datablock we might have read before
 904 -               asio::async_read(socket,
 905 -                       asio::buffer(&packet_size, 4),
 906 -                       boost::bind(&Session::asyncReadHeaderHandler, shared_from_this(), asio::placeholders::error, asio::placeholders::bytes_transferred));
 907 +               boost::asio::async_read(socket,
 908 +                       boost::asio::buffer(&packet_size, 4),
 909 +                       boost::bind(&Session::asyncReadHeaderHandler, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
 910         }
 911
 912         void asyncWrite(int size, const char* data)
 913 @@ -115,9 +115,9 @@ public:
 914                         packet_data_write = store_data;
 915
 916                         UT_DEBUGMSG(("sending datablock of length: %d\n", packet_size_write));
 917 -                       asio::async_write(socket,
 918 -                               asio::buffer(&packet_size_write, 4),
 919 -                               boost::bind(&Session::asyncWriteHeaderHandler, shared_from_this(), asio::placeholders::error));
 920 +                       boost::asio::async_write(socket,
 921 +                               boost::asio::buffer(&packet_size_write, 4),
 922 +                               boost::bind(&Session::asyncWriteHeaderHandler, shared_from_this(), boost::asio::placeholders::error));
 923                 }
 924         }
 925
 926 @@ -134,12 +134,12 @@ public:
 927                 UT_DEBUGMSG(("Session::disconnect()\n"));
 928                 if (socket.is_open())
 929                 {
 930 -                       asio::error_code ecs;
 931 -                       socket.shutdown(asio::ip::tcp::socket::shutdown_both, ecs);
 932 +                       boost::system::error_code ecs;
 933 +                       socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ecs);
 934                         if (ecs) {
 935                                 UT_DEBUGMSG(("Error shutting down socket: %s\n", ecs.message().c_str()));
 936                         }
 937 -                       asio::error_code ecc;
 938 +                       boost::system::error_code ecc;
 939                         socket.close(ecc);
 940                         if (ecc) {
 941                                 UT_DEBUGMSG(("Error closing socket: %s\n", ecc.message().c_str()));
 942 @@ -156,7 +156,7 @@ private:
 943                 m_ef(shared_from_this());
 944         }
 945
 946 -       void asyncReadHeaderHandler(const asio::error_code& error,
 947 +       void asyncReadHeaderHandler(const boost::system::error_code& error,
 948                 std::size_t bytes_transferred)
 949         {
 950                 if (error)
 951 @@ -183,12 +183,12 @@ private:
 952                 UT_DEBUGMSG(("going to read datablock of length: %d\n", packet_size));
 953                 // now continue reading the packet data
 954                 packet_data = reinterpret_cast<char*>(g_malloc(packet_size));
 955 -               asio::async_read(socket,
 956 -                       asio::buffer(packet_data, packet_size),
 957 -                       boost::bind(&Session::asyncReadHandler, shared_from_this(), asio::placeholders::error, asio::placeholders::bytes_transferred));
 958 +               boost::asio::async_read(socket,
 959 +                       boost::asio::buffer(packet_data, packet_size),
 960 +                       boost::bind(&Session::asyncReadHandler, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
 961         }
 962
 963 -       void asyncReadHandler(const asio::error_code& error,
 964 +       void asyncReadHandler(const boost::system::error_code& error,
 965                 std::size_t bytes_transferred)
 966         {
 967                 if (error)
 968 @@ -210,7 +210,7 @@ private:
 969                 asyncReadHeader();
 970         }
 971
 972 -       void asyncWriteHeaderHandler(const asio::error_code& ec)
 973 +       void asyncWriteHeaderHandler(const boost::system::error_code& ec)
 974         {
 975                 UT_DEBUGMSG(("Session::asyncWriteHeaderHandler()\n"));
 976                 if (ec)
 977 @@ -221,12 +221,12 @@ private:
 978                 }
 979
 980                 // write the packet body
 981 -               asio::async_write(socket,
 982 -                       asio::buffer(packet_data_write, packet_size_write),
 983 -                       boost::bind(&Session::asyncWriteHandler, shared_from_this(), asio::placeholders::error));
 984 +               boost::asio::async_write(socket,
 985 +                       boost::asio::buffer(packet_data_write, packet_size_write),
 986 +                       boost::bind(&Session::asyncWriteHandler, shared_from_this(), boost::asio::placeholders::error));
 987         }
 988
 989 -       void asyncWriteHandler(const asio::error_code& ec)
 990 +       void asyncWriteHandler(const boost::system::error_code& ec)
 991         {
 992                 UT_DEBUGMSG(("Session::asyncWriteHandler()\n"));
 993                 FREEP(packet_data_write);
 994 @@ -247,13 +247,13 @@ private:
 995
 996                         UT_DEBUGMSG(("sending datablock of length: %d\n", packet_size_write));
 997
 998 -                       asio::async_write(socket,
 999 -                               asio::buffer(&packet_size_write, 4),
1000 -                               boost::bind(&Session::asyncWriteHeaderHandler, shared_from_this(), asio::placeholders::error));
1001 +                       boost::asio::async_write(socket,
1002 +                               boost::asio::buffer(&packet_size_write, 4),
1003 +                               boost::bind(&Session::asyncWriteHeaderHandler, shared_from_this(), boost::asio::placeholders::error));
1004                 }
1005         }
1006
1007 -       asio::ip::tcp::socket                                   socket;
1008 +       boost::asio::ip::tcp::socket                                    socket;
1009         abicollab::mutex                                                queue_protector;
1010         std::deque< std::pair<int, char*> >             incoming;
1011         std::deque< std::pair<int, char*> >             outgoing;
1012 --- abiword-3.0.1/plugins/collab/backends/tcp/xp/TCPAccountHandler.cpp.orig     2013-07-05 03:51:21.000000000 +0200
1013 +++ abiword-3.0.1/plugins/collab/backends/tcp/xp/TCPAccountHandler.cpp  2016-05-16 18:39:44.224203554 +0200
1014 @@ -80,7 +80,7 @@ ConnectResult TCPAccountHandler::connect
1015         UT_return_val_if_fail(!m_bConnected, CONNECT_ALREADY_CONNECTED);
1016         UT_return_val_if_fail(!m_thread, CONNECT_INTERNAL_ERROR);
1017         m_io_service.reset();
1018 -       m_thread = new asio::thread(boost::bind(&asio::io_service::run, &m_io_service));
1019 +       m_thread = new boost::thread(boost::bind(&boost::asio::io_service::run, &m_io_service));
1020
1021         // set up the connection
1022         if (getProperty("server") == "")
1023 @@ -97,7 +97,7 @@ ConnectResult TCPAccountHandler::connect
1024                         m_bConnected = true; // todo: ask it to the acceptor
1025                         pDelegator->run();
1026                 }
1027 -               catch (asio::system_error se)
1028 +               catch (boost::system::system_error se)
1029                 {
1030                         UT_DEBUGMSG(("Failed to start accepting connections: %s\n", se.what()));
1031                         _teardownAndDestroyHandler();
1032 @@ -116,13 +116,13 @@ ConnectResult TCPAccountHandler::connect
1033
1034                 try
1035                 {
1036 -                       asio::ip::tcp::resolver resolver(m_io_service);
1037 -                       asio::ip::tcp::resolver::query query(getProperty("server"), getProperty("port"));
1038 -                       asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
1039 +                       boost::asio::ip::tcp::resolver resolver(m_io_service);
1040 +                       boost::asio::ip::tcp::resolver::query query(getProperty("server"), getProperty("port"));
1041 +                       boost::asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
1042
1043                         bool connected = false;
1044                         boost::shared_ptr<Session> session_ptr(new Session(m_io_service, boost::bind(&TCPAccountHandler::handleEvent, this, _1)));
1045 -                       while (iterator != asio::ip::tcp::resolver::iterator())
1046 +                       while (iterator != boost::asio::ip::tcp::resolver::iterator())
1047                         {
1048                                 try
1049                                 {
1050 @@ -132,7 +132,7 @@ ConnectResult TCPAccountHandler::connect
1051                                         connected = true;
1052                                         break;
1053                                 }
1054 -                               catch (asio::system_error se)
1055 +                               catch (boost::system::system_error se)
1056                                 {
1057                                         UT_DEBUGMSG(("Connection attempt failed: %s\n", se.what()));
1058                                         // make sure we close the socket after a failed attempt, as it
1059 @@ -158,7 +158,7 @@ ConnectResult TCPAccountHandler::connect
1060                         addBuddy(pBuddy);
1061                         m_clients.insert(std::pair<TCPBuddyPtr, boost::shared_ptr<Session> >(pBuddy, session_ptr));
1062                 }
1063 -               catch (asio::system_error se)
1064 +               catch (boost::system::system_error se)
1065                 {
1066                         UT_DEBUGMSG(("Failed to resolve %s:%d: %s\n", getProperty("server").c_str(), _getPort(getProperties()), se.what()));
1067                         _teardownAndDestroyHandler();
1068 --- abiword-3.0.1/plugins/collab/backends/tcp/xp/TCPAccountHandler.h.orig       2013-04-07 15:53:03.000000000 +0200
1069 +++ abiword-3.0.1/plugins/collab/backends/tcp/xp/TCPAccountHandler.h    2016-05-16 18:37:26.453612079 +0200
1070 @@ -20,6 +20,7 @@
1071  #define __TCPACCOUNTHANDLER__
1072
1073  #include <boost/shared_ptr.hpp>
1074 +#include <boost/thread.hpp>
1075  #include <core/account/xp/AccountHandler.h>
1076
1077  #include "IOServerHandler.h"
1078 @@ -84,9 +85,9 @@ private:
1079         virtual UT_sint32                                               _getPort(const PropertyMap& props);
1080         void                                                                    _handleAccept(IOServerHandler* pHandler, boost::shared_ptr<Session> session);
1081
1082 -       asio::io_service                                                m_io_service;
1083 -       asio::io_service::work                                  m_work;
1084 -       asio::thread*                                                   m_thread;
1085 +       boost::asio::io_service                                         m_io_service;
1086 +       boost::asio::io_service::work                                   m_work;
1087 +       boost::thread*                                                  m_thread;
1088         bool                                                                    m_bConnected; // TODO: drop this, ask the IO handler
1089         IOServerHandler*                                                m_pDelegator;
1090