diff options
19 files changed, 81 insertions, 57 deletions
diff --git a/QA/Checker/SConscript b/QA/Checker/SConscript index 96479db..ed17be5 100644 --- a/QA/Checker/SConscript +++ b/QA/Checker/SConscript @@ -4,11 +4,12 @@ if env["TEST"] : if env["SCONS_STAGE"] == "flags" : env["CHECKER_FLAGS"] = { "LIBS": ["Checker"], "LIBPATH": [Dir(".")], "LINKFLAGS": ["/SUBSYSTEM:CONSOLE"] if env["PLATFORM"] == "win32" else [] } if env["SCONS_STAGE"] == "build" : checker_env = env.Clone() + checker_env.MergeFlags(env["BOOST_FLAGS"]) checker_env.MergeFlags(env["CPPUNIT_FLAGS"]) checker_env.Library("Checker", ["checker.cpp", "IO.cpp"]) diff --git a/Swiften/Base/SafeByteArray.h b/Swiften/Base/SafeByteArray.h index 032a6d5..1ef1d84 100644 --- a/Swiften/Base/SafeByteArray.h +++ b/Swiften/Base/SafeByteArray.h @@ -4,42 +4,55 @@ * See Documentation/Licenses/GPLv3.txt for more information. */ #pragma once #include <vector> #include <Swiften/Base/SafeAllocator.h> #include <Swiften/Base/ByteArray.h> +#include <boost/smart_ptr/make_shared.hpp> namespace Swift { typedef std::vector<unsigned char, SafeAllocator<unsigned char> > SafeByteArray; inline SafeByteArray createSafeByteArray(const ByteArray& a) { return SafeByteArray(a.begin(), a.end()); } SafeByteArray createSafeByteArray(const char* c); inline SafeByteArray createSafeByteArray(const std::string& s) { return SafeByteArray(s.begin(), s.end()); } + inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const std::string& s) { + return boost::make_shared<SafeByteArray>(s.begin(), s.end()); + } + inline SafeByteArray createSafeByteArray(char c) { return SafeByteArray(1, c); } inline SafeByteArray createSafeByteArray(const char* c, size_t n) { return SafeByteArray(c, c + n); } + inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const char* c, size_t n) { + return boost::make_shared<SafeByteArray>(c, c + n); + } + inline SafeByteArray createSafeByteArray(const unsigned char* c, size_t n) { return SafeByteArray(c, c + n); } + inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const unsigned char* c, size_t n) { + return boost::make_shared<SafeByteArray>(c, c + n); + } + /* WARNING! This breaks the safety of the data in the safe byte array. * Do not use in modes that require data safety. */ inline std::string safeByteArrayToString(const SafeByteArray& b) { return byteArrayToString(ByteArray(b.begin(), b.end())); } } diff --git a/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp b/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp index a18b998..db3d83f 100644 --- a/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp +++ b/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp @@ -203,27 +203,27 @@ void SOCKS5BytestreamClientSession::handleConnectFinished(bool error) { finish(true); } else { SWIFT_LOG(debug) << "Successfully connected via TCP" << addressPort.toString() << "." << std::endl; weFailedTimeout->start(); connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSession::handleDataRead, this, _1)); process(); } } -void SOCKS5BytestreamClientSession::handleDataRead(const SafeByteArray& data) { - SWIFT_LOG(debug) << "state: " << state << " data.size() = " << data.size() << std::endl; +void SOCKS5BytestreamClientSession::handleDataRead(boost::shared_ptr<SafeByteArray> data) { + SWIFT_LOG(debug) << "state: " << state << " data.size() = " << data->size() << std::endl; if (state != Reading) { - append(unprocessedData, data); + append(unprocessedData, *data); process(); } else { - writeBytestream->write(createByteArray(vecptr(data), data.size())); - onBytesReceived(data.size()); + writeBytestream->write(createByteArray(vecptr(*data), data->size())); + onBytesReceived(data->size()); } } void SOCKS5BytestreamClientSession::handleDisconnected(const boost::optional<Connection::Error>& error) { SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl; if (error) { finish(true); } } diff --git a/Swiften/FileTransfer/SOCKS5BytestreamClientSession.h b/Swiften/FileTransfer/SOCKS5BytestreamClientSession.h index 894e977..ea45955 100644 --- a/Swiften/FileTransfer/SOCKS5BytestreamClientSession.h +++ b/Swiften/FileTransfer/SOCKS5BytestreamClientSession.h @@ -60,19 +60,19 @@ public: boost::signal<void (int)> onBytesSent; boost::signal<void (int)> onBytesReceived; private: void process(); void hello(); void authenticate(); void handleConnectFinished(bool error); - void handleDataRead(const SafeByteArray&); + void handleDataRead(boost::shared_ptr<SafeByteArray>); void handleDisconnected(const boost::optional<Connection::Error>&); void handleWeFailedTimeout(); void finish(bool error); void sendData(); private: boost::shared_ptr<Connection> connection; HostAddressPort addressPort; diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp index fa7e054..def9e33 100644 --- a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp +++ b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp @@ -59,25 +59,25 @@ void SOCKS5BytestreamServerSession::startTransfer() { } else { SWIFT_LOG(debug) << "Not ready for transfer!" << std::endl; } } HostAddressPort SOCKS5BytestreamServerSession::getAddressPort() const { return connection->getLocalAddress(); } -void SOCKS5BytestreamServerSession::handleDataRead(const SafeByteArray& data) { +void SOCKS5BytestreamServerSession::handleDataRead(boost::shared_ptr<SafeByteArray> data) { if (state != ReadingData) { - append(unprocessedData, data); + append(unprocessedData, *data); process(); } else { - writeBytestream->write(createByteArray(vecptr(data), data.size())); - onBytesReceived(data.size()); + writeBytestream->write(createByteArray(vecptr(*data), data->size())); + onBytesReceived(data->size()); } } void SOCKS5BytestreamServerSession::handleDisconnected(const boost::optional<Connection::Error>& error) { SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl; if (error) { finish(true); } } diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.h b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.h index 3e1018f..4557a36 100644 --- a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.h +++ b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.h @@ -46,19 +46,19 @@ namespace Swift { HostAddressPort getAddressPort() const; boost::signal<void (boost::optional<FileTransferError>)> onFinished; boost::signal<void (int)> onBytesSent; boost::signal<void (int)> onBytesReceived; private: void finish(bool error); void process(); - void handleDataRead(const SafeByteArray&); + void handleDataRead(boost::shared_ptr<SafeByteArray>); void handleDisconnected(const boost::optional<Connection::Error>&); void sendData(); private: boost::shared_ptr<Connection> connection; SOCKS5BytestreamRegistry* bytestreams; ByteArray unprocessedData; State state; int chunkSize; diff --git a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp index 75b9faf..527e0ca 100644 --- a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp +++ b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp @@ -158,19 +158,19 @@ public: serverRespondRequestOK(); eventLoop->processEvents(); CPPUNIT_ASSERT_EQUAL(true, helper.sessionReadyCalled); CPPUNIT_ASSERT_EQUAL(false, helper.sessionReadyError); boost::shared_ptr<ByteArrayWriteBytestream> output = boost::make_shared<ByteArrayWriteBytestream>(); clientSession->startReceiving(output); ByteArray transferData = generateRandomByteArray(1024); - connection->onDataRead(createSafeByteArray(transferData.data(), transferData.size())); + connection->onDataRead(createSafeByteArrayRef(transferData.data(), transferData.size())); CPPUNIT_ASSERT_EQUAL(transferData, output->getData()); } void testReadBytestream() { TestHelper helper; connection->onDataSent.connect(boost::bind(&TestHelper::handleConnectionDataWritten, &helper, _1)); SOCKS5BytestreamClientSession::ref clientSession = boost::make_shared<SOCKS5BytestreamClientSession>(connection, destinationAddressPort, destination, timerFactory); clientSession->onSessionReady.connect(boost::bind(&TestHelper::handleSessionReady, &helper, _1)); @@ -206,47 +206,47 @@ private: ByteArray result(len); for (size_t i=0; i < len; ++i ) { result[i] = randomByte(); } return result; } // Server responses void serverRespondHelloOK() { - connection->onDataRead(createSafeByteArray("\x05\00", 2)); + connection->onDataRead(createSafeByteArrayRef("\x05\00", 2)); } void serverRespondHelloAuthFail() { - connection->onDataRead(createSafeByteArray("\x05\xFF", 2)); + connection->onDataRead(createSafeByteArrayRef("\x05\xFF", 2)); } void serverRespondRequestOK() { - SafeByteArray dataToSend = createSafeByteArray("\x05\x00\x00\x03", 4); - append(dataToSend, createSafeByteArray(destination.size())); - append(dataToSend, createSafeByteArray(destination)); - append(dataToSend, createSafeByteArray("\x00", 1)); + boost::shared_ptr<SafeByteArray> dataToSend = createSafeByteArrayRef("\x05\x00\x00\x03", 4); + append(*dataToSend, createSafeByteArray(destination.size())); + append(*dataToSend, createSafeByteArray(destination)); + append(*dataToSend, createSafeByteArray("\x00", 1)); connection->onDataRead(dataToSend); } void serverRespondRequestFail() { - SafeByteArray correctData = createSafeByteArray("\x05\x00\x00\x03", 4); - append(correctData, createSafeByteArray(destination.size())); - append(correctData, createSafeByteArray(destination)); - append(correctData, createSafeByteArray("\x00", 1)); + boost::shared_ptr<SafeByteArray> correctData = createSafeByteArrayRef("\x05\x00\x00\x03", 4); + append(*correctData, createSafeByteArray(destination.size())); + append(*correctData, createSafeByteArray(destination)); + append(*correctData, createSafeByteArray("\x00", 1)); - SafeByteArray dataToSend; + boost::shared_ptr<SafeByteArray> dataToSend; //ByteArray failingData = Hexify::unhexify("8417947d1d305c72c11520ea7d2c6e787396705e72c312c6ccc3f66613d7cae1b91b7ab48e8b59a17d559c15fb51"); //append(dataToSend, failingData); //SWIFT_LOG(debug) << "hexed: " << Hexify::hexify(failingData) << std::endl; do { - ByteArray rndArray = generateRandomByteArray(correctData.size()); - dataToSend = createSafeByteArray(rndArray.data(), rndArray.size()); - } while (dataToSend == correctData); + ByteArray rndArray = generateRandomByteArray(correctData->size()); + dataToSend = createSafeByteArrayRef(rndArray.data(), rndArray.size()); + } while (*dataToSend == *correctData); connection->onDataRead(dataToSend); } private: struct TestHelper { TestHelper() : sessionReadyCalled(false), sessionReadyError(false) {} ByteArray unprocessedInput; bool sessionReadyCalled; bool sessionReadyError; diff --git a/Swiften/Network/BoostConnection.cpp b/Swiften/Network/BoostConnection.cpp index ac3b444..043743e 100644 --- a/Swiften/Network/BoostConnection.cpp +++ b/Swiften/Network/BoostConnection.cpp @@ -7,18 +7,19 @@ #include <Swiften/Network/BoostConnection.h> #include <iostream> #include <string> #include <algorithm> #include <boost/bind.hpp> #include <boost/thread.hpp> #include <boost/asio/placeholders.hpp> #include <boost/asio/write.hpp> +#include <boost/smart_ptr/make_shared.hpp> #include <Swiften/Base/Log.h> #include <Swiften/Base/Algorithm.h> #include <Swiften/EventLoop/EventLoop.h> #include <Swiften/Base/ByteArray.h> #include <Swiften/Network/HostAddressPort.h> #include <Swiften/Base/sleep.h> #include <Swiften/Base/SafeAllocator.h> @@ -44,19 +45,19 @@ class SharedBuffer { private: boost::shared_ptr< std::vector<char, SafeAllocator<char> > > data_; boost::asio::const_buffer buffer_; }; // ----------------------------------------------------------------------------- BoostConnection::BoostConnection(boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : - eventLoop(eventLoop), ioService(ioService), socket_(*ioService), readBuffer_(BUFFER_SIZE), writing_(false) { + eventLoop(eventLoop), ioService(ioService), socket_(*ioService), writing_(false) { } BoostConnection::~BoostConnection() { } void BoostConnection::listen() { doRead(); } @@ -102,28 +103,29 @@ void BoostConnection::handleConnectFinished(const boost::system::error_code& err eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), false), shared_from_this()); doRead(); } else if (error != boost::asio::error::operation_aborted) { eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), true), shared_from_this()); } } void BoostConnection::doRead() { + readBuffer_ = boost::make_shared<SafeByteArray>(BUFFER_SIZE); socket_.async_read_some( - boost::asio::buffer(readBuffer_), + boost::asio::buffer(*readBuffer_), boost::bind(&BoostConnection::handleSocketRead, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } void BoostConnection::handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred) { SWIFT_LOG(debug) << "Socket read " << error << std::endl; if (!error) { - eventLoop->postEvent(boost::bind(boost::ref(onDataRead), createSafeByteArray(&readBuffer_[0], bytesTransferred)), shared_from_this()); - std::fill(readBuffer_.begin(), readBuffer_.end(), 0); + readBuffer_->resize(bytesTransferred); + eventLoop->postEvent(boost::bind(boost::ref(onDataRead), readBuffer_), shared_from_this()); doRead(); } else if (/*error == boost::asio::error::eof ||*/ error == boost::asio::error::operation_aborted) { eventLoop->postEvent(boost::bind(boost::ref(onDisconnected), boost::optional<Error>()), shared_from_this()); } else { eventLoop->postEvent(boost::bind(boost::ref(onDisconnected), ReadError), shared_from_this()); } } diff --git a/Swiften/Network/BoostConnection.h b/Swiften/Network/BoostConnection.h index 259fcec..7d5ec60 100644 --- a/Swiften/Network/BoostConnection.h +++ b/Swiften/Network/BoostConnection.h @@ -53,15 +53,15 @@ namespace Swift { void handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred); void handleDataWritten(const boost::system::error_code& error); void doRead(); void doWrite(const SafeByteArray& data); private: EventLoop* eventLoop; boost::shared_ptr<boost::asio::io_service> ioService; boost::asio::ip::tcp::socket socket_; - SafeByteArray readBuffer_; + boost::shared_ptr<SafeByteArray> readBuffer_; boost::mutex writeMutex_; bool writing_; SafeByteArray writeQueue_; }; } diff --git a/Swiften/Network/Connection.h b/Swiften/Network/Connection.h index 1b9977f..6ad2999 100644 --- a/Swiften/Network/Connection.h +++ b/Swiften/Network/Connection.h @@ -30,13 +30,13 @@ namespace Swift { virtual void connect(const HostAddressPort& address) = 0; virtual void disconnect() = 0; virtual void write(const SafeByteArray& data) = 0; virtual HostAddressPort getLocalAddress() const = 0; public: boost::signal<void (bool /* error */)> onConnectFinished; boost::signal<void (const boost::optional<Error>&)> onDisconnected; - boost::signal<void (const SafeByteArray&)> onDataRead; + boost::signal<void (boost::shared_ptr<SafeByteArray>)> onDataRead; boost::signal<void ()> onDataWritten; }; } diff --git a/Swiften/Network/DummyConnection.cpp b/Swiften/Network/DummyConnection.cpp index 9a9d138..09bd06d 100644 --- a/Swiften/Network/DummyConnection.cpp +++ b/Swiften/Network/DummyConnection.cpp @@ -1,27 +1,28 @@ /* * Copyright (c) 2010 Remko Tronçon * Licensed under the GNU General Public License v3. * See Documentation/Licenses/GPLv3.txt for more information. */ #include <Swiften/Network/DummyConnection.h> #include <boost/bind.hpp> +#include <boost/smart_ptr/make_shared.hpp> #include <cassert> namespace Swift { DummyConnection::DummyConnection(EventLoop* eventLoop) : eventLoop(eventLoop) { } void DummyConnection::receive(const SafeByteArray& data) { - eventLoop->postEvent(boost::bind(boost::ref(onDataRead), SafeByteArray(data)), shared_from_this()); + eventLoop->postEvent(boost::bind(boost::ref(onDataRead), boost::make_shared<SafeByteArray>(data)), shared_from_this()); } void DummyConnection::listen() { assert(false); } void DummyConnection::connect(const HostAddressPort&) { assert(false); } diff --git a/Swiften/Network/HTTPConnectProxiedConnection.cpp b/Swiften/Network/HTTPConnectProxiedConnection.cpp index 20819ff..e05a933 100644 --- a/Swiften/Network/HTTPConnectProxiedConnection.cpp +++ b/Swiften/Network/HTTPConnectProxiedConnection.cpp @@ -67,31 +67,31 @@ void HTTPConnectProxiedConnection::handleConnectionConnectFinished(bool error) { std::stringstream connect; connect << "CONNECT " << server_.getAddress().toString() << ":" << server_.getPort() << " HTTP/1.1\r\n\r\n"; connection_->write(createSafeByteArray(connect.str())); } else { onConnectFinished(true); } } -void HTTPConnectProxiedConnection::handleDataRead(const SafeByteArray& data) { +void HTTPConnectProxiedConnection::handleDataRead(boost::shared_ptr<SafeByteArray> data) { if (!connected_) { - SWIFT_LOG(debug) << byteArrayToString(ByteArray(data.begin(), data.end())) << std::endl; - std::vector<std::string> tmp = String::split(byteArrayToString(ByteArray(data.begin(), data.end())), ' '); + SWIFT_LOG(debug) << byteArrayToString(ByteArray(data->begin(), data->end())) << std::endl; + std::vector<std::string> tmp = String::split(byteArrayToString(ByteArray(data->begin(), data->end())), ' '); if(tmp.size() > 1) { int status = boost::lexical_cast<int> (tmp[1].c_str()); SWIFT_LOG(debug) << "Proxy Status: " << status << std::endl; if (status / 100 == 2) { // all 2XX states are OK connected_ = true; onConnectFinished(false); return; } - SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << byteArrayToString(ByteArray(data.begin(), data.end())) << std::endl; + SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << byteArrayToString(ByteArray(data->begin(), data->end())) << std::endl; } disconnect(); onConnectFinished(true); } else { onDataRead(data); } } diff --git a/Swiften/Network/HTTPConnectProxiedConnection.h b/Swiften/Network/HTTPConnectProxiedConnection.h index 96c6be8..d3f5b7a 100644 --- a/Swiften/Network/HTTPConnectProxiedConnection.h +++ b/Swiften/Network/HTTPConnectProxiedConnection.h @@ -35,19 +35,19 @@ namespace Swift { virtual void connect(const HostAddressPort& address); virtual void disconnect(); virtual void write(const SafeByteArray& data); virtual HostAddressPort getLocalAddress() const; private: HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy); void handleConnectionConnectFinished(bool error); - void handleDataRead(const SafeByteArray& data); + void handleDataRead(boost::shared_ptr<SafeByteArray> data); void handleDisconnected(const boost::optional<Error>& error); private: bool connected_; ConnectionFactory* connectionFactory_; HostAddressPort proxy_; HostAddressPort server_; boost::shared_ptr<Connection> connection_; }; diff --git a/Swiften/Network/SOCKS5ProxiedConnection.cpp b/Swiften/Network/SOCKS5ProxiedConnection.cpp index f8084ab..163e23a 100644 --- a/Swiften/Network/SOCKS5ProxiedConnection.cpp +++ b/Swiften/Network/SOCKS5ProxiedConnection.cpp @@ -80,27 +80,27 @@ void SOCKS5ProxiedConnection::handleConnectionConnectFinished(bool error) { // buffer.push_back(0x02); // 0x02 == Username/Password // rest see RFC 1928 (http://tools.ietf.org/html/rfc1928) connection_->write(socksConnect); } else { onConnectFinished(true); } } -void SOCKS5ProxiedConnection::handleDataRead(const SafeByteArray& data) { +void SOCKS5ProxiedConnection::handleDataRead(boost::shared_ptr<SafeByteArray> data) { SafeByteArray socksConnect; boost::asio::ip::address rawAddress = server_.getAddress().getRawAddress(); assert(rawAddress.is_v4() || rawAddress.is_v6()); if (!connected_) { if (proxyState_ == ProxyAuthenticating) { SWIFT_LOG(debug) << "ProxyAuthenticating response received, reply with the connect BYTEs" << std::endl; - unsigned char choosenMethod = static_cast<unsigned char> (data[1]); - if (data[0] == 0x05 && choosenMethod != 0xFF) { + unsigned char choosenMethod = static_cast<unsigned char> ((*data)[1]); + if ((*data)[0] == 0x05 && choosenMethod != 0xFF) { switch(choosenMethod) { // use the correct Method case 0x00: try { proxyState_ = ProxyConnecting; socksConnect.push_back(0x05); // VER = SOCKS5 = 0x05 socksConnect.push_back(0x01); // Construct a TCP connection. (CMD) socksConnect.push_back(0x00); // reserved. socksConnect.push_back(rawAddress.is_v4() ? 0x01 : 0x04); // IPv4 == 0x01, Hostname == 0x02, IPv6 == 0x04. (ATYP) size_t size = rawAddress.is_v4() ? rawAddress.to_v4().to_bytes().size() : rawAddress.to_v6().to_bytes().size(); @@ -128,41 +128,41 @@ void SOCKS5ProxiedConnection::handleDataRead(const SafeByteArray& data) { default: onConnectFinished(true); break; } return; } } else if (proxyState_ == ProxyConnecting) { SWIFT_LOG(debug) << "Connect response received, check if successfully." << std::endl; - SWIFT_LOG(debug) << "Errorbyte: 0x" << std::hex << static_cast<int> (data[1]) << std::dec << std::endl; + SWIFT_LOG(debug) << "Errorbyte: 0x" << std::hex << static_cast<int> ((*data)[1]) << std::dec << std::endl; /* data.at(1) can be one of the following: 0x00 succeeded 0x01 general SOCKS server failure 0x02 connection not allowed by ruleset 0x03 Network unreachable 0x04 Host unreachable 0x05 Connection refused 0x06 TTL expired 0x07 Command not supported (CMD) 0x08 Address type not supported (ATYP) 0x09 bis 0xFF unassigned */ - if (data[0] == 0x05 && data[1] == 0x0) { + if ((*data)[0] == 0x05 && (*data)[1] == 0x0) { SWIFT_LOG(debug) << "Successfully connected the server via the proxy." << std::endl; connected_ = true; onConnectFinished(false); return; } else { - std::cerr << "SOCKS Proxy returned an error: " << std::hex << data[1] << std::endl; + std::cerr << "SOCKS Proxy returned an error: " << std::hex << (*data)[1] << std::endl; } return; } } else { onDataRead(data); return; } disconnect(); diff --git a/Swiften/Network/SOCKS5ProxiedConnection.h b/Swiften/Network/SOCKS5ProxiedConnection.h index 942b6ce..592ce7d 100644 --- a/Swiften/Network/SOCKS5ProxiedConnection.h +++ b/Swiften/Network/SOCKS5ProxiedConnection.h @@ -36,19 +36,19 @@ namespace Swift { virtual void disconnect(); virtual void write(const SafeByteArray& data); virtual HostAddressPort getLocalAddress() const; private: SOCKS5ProxiedConnection(ConnectionFactory* connectionFactory, const HostAddressPort& proxy); void handleConnectionConnectFinished(bool error); - void handleDataRead(const SafeByteArray& data); + void handleDataRead(boost::shared_ptr<SafeByteArray> data); void handleDisconnected(const boost::optional<Error>& error); private: enum { ProxyAuthenticating = 0, ProxyConnecting, } proxyState_; bool connected_; ConnectionFactory* connectionFactory_; diff --git a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp index 48189ab..133773f 100644 --- a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp +++ b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp @@ -70,69 +70,69 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture { CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten); } void testConnect_ReceiveConnectResponse() { HTTPConnectProxiedConnection::ref testling(createTestling()); testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345)); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("HTTP/1.0 200 Connection established\r\n\r\n")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n")); eventLoop->processEvents(); CPPUNIT_ASSERT(connectFinished); CPPUNIT_ASSERT(!connectFinishedWithError); CPPUNIT_ASSERT(dataRead.empty()); } void testConnect_ReceiveMalformedConnectResponse() { HTTPConnectProxiedConnection::ref testling(createTestling()); testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345)); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("FLOOP")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("FLOOP")); eventLoop->processEvents(); CPPUNIT_ASSERT(connectFinished); CPPUNIT_ASSERT(connectFinishedWithError); CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected); } void testConnect_ReceiveErrorConnectResponse() { HTTPConnectProxiedConnection::ref testling(createTestling()); testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345)); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("HTTP/1.0 401 Unauthorized\r\n\r\n")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 401 Unauthorized\r\n\r\n")); eventLoop->processEvents(); CPPUNIT_ASSERT(connectFinished); CPPUNIT_ASSERT(connectFinishedWithError); CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected); } void testConnect_ReceiveDataAfterConnect() { HTTPConnectProxiedConnection::ref testling(createTestling()); testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345)); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("HTTP/1.0 200 Connection established\r\n\r\n")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n")); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("abcdef")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("abcdef")); CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), dataRead); } void testWrite_AfterConnect() { HTTPConnectProxiedConnection::ref testling(createTestling()); testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345)); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("HTTP/1.0 200 Connection established\r\n\r\n")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n")); eventLoop->processEvents(); connectionFactory->connections[0]->dataWritten.clear(); testling->write(createSafeByteArray("abcdef")); CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), connectionFactory->connections[0]->dataWritten); } void testDisconnect_AfterConnectRequest() { @@ -145,19 +145,19 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture { CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected); CPPUNIT_ASSERT(disconnected); CPPUNIT_ASSERT(!disconnectedError); } void testDisconnect_AfterConnect() { HTTPConnectProxiedConnection::ref testling(createTestling()); testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345)); eventLoop->processEvents(); - connectionFactory->connections[0]->onDataRead(createSafeByteArray("HTTP/1.0 200 Connection established\r\n\r\n")); + connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n")); eventLoop->processEvents(); testling->disconnect(); CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected); CPPUNIT_ASSERT(disconnected); CPPUNIT_ASSERT(!disconnectedError); } @@ -174,20 +174,20 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture { connectFinished = true; connectFinishedWithError = error; } void handleDisconnected(const boost::optional<Connection::Error>& e) { disconnected = true; disconnectedError = e; } - void handleDataRead(const SafeByteArray& d) { - append(dataRead, d); + void handleDataRead(boost::shared_ptr<SafeByteArray> d) { + append(dataRead, *d); } struct MockConnection : public Connection { public: MockConnection(const std::vector<HostAddressPort>& failingPorts, EventLoop* eventLoop) : eventLoop(eventLoop), failingPorts(failingPorts), disconnected(false) { } void listen() { assert(false); } diff --git a/Swiften/QA/NetworkTest/BoostConnectionTest.cpp b/Swiften/QA/NetworkTest/BoostConnectionTest.cpp index 31d5d82..335f2d2 100644 --- a/Swiften/QA/NetworkTest/BoostConnectionTest.cpp +++ b/Swiften/QA/NetworkTest/BoostConnectionTest.cpp @@ -125,20 +125,20 @@ class BoostConnectionTest : public CppUnit::TestFixture { eventLoop_->processEvents(); } } void doWrite(BoostConnection* connection) { connection->write(createSafeByteArray("<stream:stream>")); connection->write(createSafeByteArray("\r\n\r\n")); // Temporarily, while we don't have an xmpp server running on ipv6 } - void handleDataRead(const SafeByteArray& data) { - append(receivedData, data); + void handleDataRead(boost::shared_ptr<SafeByteArray> data) { + append(receivedData, *data); } void handleDisconnected() { disconnected = true; } void handleConnectFinished() { connectFinished = true; } diff --git a/Swiften/StreamStack/ConnectionLayer.cpp b/Swiften/StreamStack/ConnectionLayer.cpp index 00b4289..5ea06eb 100644 --- a/Swiften/StreamStack/ConnectionLayer.cpp +++ b/Swiften/StreamStack/ConnectionLayer.cpp @@ -4,18 +4,22 @@ * See Documentation/Licenses/GPLv3.txt for more information. */ #include <Swiften/StreamStack/ConnectionLayer.h> #include <boost/bind.hpp> namespace Swift { ConnectionLayer::ConnectionLayer(boost::shared_ptr<Connection> connection) : connection(connection) { - connection->onDataRead.connect(boost::bind(&ConnectionLayer::writeDataToParentLayer, this, _1)); + connection->onDataRead.connect(boost::bind(&ConnectionLayer::handleDataRead, this, _1)); } ConnectionLayer::~ConnectionLayer() { connection->onDataRead.disconnect(boost::bind(&ConnectionLayer::writeDataToParentLayer, this, _1)); } +void ConnectionLayer::handleDataRead(boost::shared_ptr<SafeByteArray> data) { + writeDataToParentLayer(*data); +} + } diff --git a/Swiften/StreamStack/ConnectionLayer.h b/Swiften/StreamStack/ConnectionLayer.h index 8ccd33c..6776751 100644 --- a/Swiften/StreamStack/ConnectionLayer.h +++ b/Swiften/StreamStack/ConnectionLayer.h @@ -16,12 +16,15 @@ namespace Swift { public: ConnectionLayer(boost::shared_ptr<Connection> connection); ~ConnectionLayer(); void writeData(const SafeByteArray& data) { connection->write(data); } private: + void handleDataRead(boost::shared_ptr<SafeByteArray>); + + private: boost::shared_ptr<Connection> connection; }; } |