+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <QA/Checker/IO.h>

+

+#include <iostream>

+

+std::ostream& operator<<(std::ostream& os, const Swift::ByteArray& s) {

+ std::ios::fmtflags oldFlags = os.flags();

+ os << std::hex;

+ for (Swift::ByteArray::const_iterator i = s.begin(); i != s.end(); ++i) {

+ os << "0x" << static_cast<unsigned int>(static_cast<unsigned char>(*i));

+ if (i + 1 < s.end()) {

+ os << " ";

+ }

+ }

+ os << std::endl;

+ os.flags(oldFlags);

+ return os;

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Base/ByteArray.h>

+

+std::ostream& operator<<(std::ostream& os, const Swift::ByteArray& s);

+ checker_env.Library("Checker", ["checker.cpp", "IO.cpp"])

+ readByteArrayFromFile(data, boost::filesystem::path(vcardsPath / std::string("vcard.xml")).string());

+ tester.parse(byteArrayToString(data));

+ readByteArrayFromFile(picture, picturePath.string());

+ CFDataRef cfIcon = CFDataCreate( NULL, (UInt8*) vecptr(picture), picture.size());

+ if (!jid.equals(jid_, JID::WithoutResource) || !vCard || vCard->getPhoto().empty()) {

+ file.write(reinterpret_cast<const char*>(vecptr(avatar)), static_cast<std::streamsize>(avatar.size()));

+ readByteArrayFromFile(data, getAvatarPath(hash).string());

+ readByteArrayFromFile(data, certificatePath.string());

+ file.write(reinterpret_cast<const char*>(vecptr(data)), data.size());

+ if (vCard && !vCard->getPhoto().empty()) {

+ avatarManager->avatars[user1] = createByteArray("abcdef");

+ if (!data.empty()) {

+ image.loadFromData(reinterpret_cast<const uchar*>(vecptr(data)), data.size());

+ readByteArrayFromFile(data, Q2PSTRING(fileName));

+ buffer.setData(reinterpret_cast<const char*>(vecptr(data)), data.size());

+#include <Swiften/Base/ByteArray.h>

+#include <QA/Checker/IO.h>

+ avatar1 = createByteArray("abcdefg");

+#include <QA/Checker/IO.h>

+ avatar1 = createByteArray("abcdefg");

+ if (!avatar.empty()) {

+ if (vCard->getPhoto().empty()) {

+ template<typename C>

+ void append(C& target, const C& source) {

+ target.insert(target.end(), source.begin(), source.end());

+ }

+

+void readByteArrayFromFile(ByteArray& data, const std::string& file) {

+ size_t oldSize = data.size();

+ data.resize(oldSize + BUFFER_SIZE);

+ input.read(reinterpret_cast<char*>(&data[oldSize]), BUFFER_SIZE);

+ data.resize(oldSize + input.gcount());

+std::vector<unsigned char> createByteArray(const std::string& s) {

+std::vector<unsigned char> createByteArray(const char* c) {

+std::vector<unsigned char> createByteArray(const char* c, size_t n) {

+ std::vector<unsigned char> data(n);

+ std::copy(c, c + n, data.begin());

+std::vector<unsigned char> createByteArray(const unsigned char* c, size_t n) {

+ std::vector<unsigned char> data(n);

+ std::copy(c, c + n, data.begin());

+std::string byteArrayToString(const ByteArray& b) {

+ for (i = b.size(); i > 0; --i) {

+ if (b[i - 1] != 0) {

+ return i > 0 ? std::string(reinterpret_cast<const char*>(vecptr(b)), i) : "";

+ typedef std::vector<unsigned char> ByteArray;

+ ByteArray createByteArray(const unsigned char* c, size_t n);

+ ByteArray createByteArray(const std::string& s);

+ ByteArray createByteArray(const char* c);

+ ByteArray createByteArray(const char* c, size_t n);

+ inline ByteArray createByteArray(char c) {

+ return std::vector<unsigned char>(1, c);

+ }

+ template<typename T, typename A>

+ static const T* vecptr(const std::vector<T, A>& v) {

+ return v.empty() ? NULL : &v[0];

+ }

+ template<typename T, typename A>

+ static T* vecptr(std::vector<T, A>& v) {

+ return v.empty() ? NULL : &v[0];

+ }

+ std::string byteArrayToString(const ByteArray& b);

+ void readByteArrayFromFile(ByteArray&, const std::string& file);

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+ template<typename C>

+ C concat(const C& c1, const C& c2) {

+ C result;

+ result.resize(c1.size() + c2.size());

+ std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size());

+ std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size());

+ std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size());

+ std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size());

+ std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))))));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size());

+ std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))))));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7, const C& c8) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size() + c8.size());

+ std::copy(c8.begin(), c8.end(), std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))))))));

+ return result;

+ }

+

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7, const C& c8, const C& c9) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size() + c8.size() + c9.size());

+ std::copy(c9.begin(), c9.end(), std::copy(c8.begin(), c8.end(), std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))))))));

+ return result;

+ }

+}

+ if (_NSGetExecutablePath(const_cast<char*>(reinterpret_cast<const char*>(vecptr(path))), &size) == 0) {

+ return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(path)), path.size()).c_str()).parent_path();

+ size_t size = readlink("/proc/self/exe", reinterpret_cast<char*>(vecptr(path)), path.size());

+ return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(path)), path.size()).c_str()).parent_path();

+ GetModuleFileName(NULL, reinterpret_cast<char*>(vecptr(data)), data.size());

+ return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(data)), data.size()).c_str()).parent_path();

+ CPPUNIT_ASSERT_EQUAL(reinterpret_cast<const char*>(NULL), reinterpret_cast<const char*>(vecptr(testling)));

+ ByteArray testling(createByteArray("abcde"));

+ CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));

+ ByteArray testling(createByteArray("abcde\0", 6));

+ CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));

+ ByteArray testling(createByteArray("abcde\0\0", 7));

+ CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));

+ ByteArray testling(createByteArray("\0\0", 2));

+ CPPUNIT_ASSERT_EQUAL(std::string(""), byteArrayToString(testling));

+#include <boost/smart_ptr/make_shared.hpp>

+ stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createByteArray("")));

+ stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createByteArray("")));

+ stream->writeElement(boost::make_shared<AuthResponse>(authenticator->getResponse()));

+ return Hexify::hexify(SHA1::getHash(createByteArray(concatenatedString)));

+#include <QA/Checker/IO.h>

+ ByteArray result = testling.process(createByteArray("foo"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11), result);

+ testling.process(createByteArray("foo"));

+ ByteArray result = testling.process(createByteArray("bar"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x4a\x4a\x2c\x02\x00\x00\x00\xff\xff",9), result);

+#include <QA/Checker/IO.h>

+ ByteArray result = testling.process(createByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("foo"), result);

+ testling.process(createByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11));

+ ByteArray result = testling.process(createByteArray("\x4a\x4a\x2c\x02\x00\x00\x00\xff\xff", 9));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("bar"), result);

+ CPPUNIT_ASSERT_THROW(testling.process(createByteArray("invalid")), ZLibException);

+ ByteArray original(createByteArray(&data[0], data.size()));

+ ByteArray original(createByteArray(&data[0], data.size()));

+#include <string.h>

+ stream_.avail_in = input.size();

+ stream_.next_in = reinterpret_cast<Bytef*>(const_cast<unsigned char*>(vecptr(input)));

+ stream_.next_out = reinterpret_cast<Bytef*>(vecptr(output) + outputPosition);

+ std::string version(Base64::encode(SHA1::getHash(createByteArray(serializedCaps))));

+#include <vector>

+ AuthChallenge(const std::vector<unsigned char>& value) : value(value) {

+ const boost::optional< std::vector<unsigned char> >& getValue() const {

+ void setValue(const std::vector<unsigned char>& value) {

+ this->value = boost::optional<std::vector<unsigned char> >(value);

+ boost::optional< std::vector<unsigned char> > value;

+#include <vector>

+#include <string>

+ AuthRequest(const std::string& mechanism, const std::vector<unsigned char>& message) :

+ AuthRequest(const std::string& mechanism, const boost::optional<std::vector<unsigned char> >& message) :

+ const boost::optional<std::vector<unsigned char> >& getMessage() const {

+ void setMessage(const std::vector<unsigned char>& message) {

+ message_ = boost::optional<std::vector<unsigned char> >(message);

+ boost::optional<std::vector<unsigned char> > message_;

+#include <vector>

+ AuthResponse(const std::vector<unsigned char>& value) : value(value) {

+ AuthResponse(const boost::optional<std::vector<unsigned char> >& value) : value(value) {

+ const boost::optional<std::vector<unsigned char> >& getValue() const {

+ void setValue(const std::vector<unsigned char>& value) {

+ this->value = boost::optional<std::vector<unsigned char> >(value);

+ boost::optional<std::vector<unsigned char> > value;

+#include <vector>

+ const boost::optional<std::vector<unsigned char> >& getValue() const {

+ void setValue(const std::vector<unsigned char>& value) {

+ this->value = boost::optional<std::vector<unsigned char> >(value);

+ boost::optional<std::vector<unsigned char> > value;

+ readByteArrayFromFile(data, path.string());

+ tester.parse(byteArrayToString(data));

+ return Hexify::hexify(SHA1::getHash(createByteArray(id + from.toString() + to.toString())));

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/Concat.h>

+ append(unprocessedData, data);

+ if (unprocessedData.size() >= 2) {

+ while (i < 2 + authCount && i < unprocessedData.size()) {

+ if (i != unprocessedData.size()) {

+ connection->write(createByteArray("\x05\x00", 2));

+ if (unprocessedData.size() >= 5) {

+ while (i < 5 + hostnameSize && i < unprocessedData.size()) {

+ requestID.push_back(unprocessedData[i]);

+ if (i >= unprocessedData.size()) {

+ if (i != unprocessedData.size()) {

+ bytestream = bytestreams->getBytestream(byteArrayToString(requestID));

+ ByteArray result = createByteArray("\x05", 1);

+ result.push_back(bytestream ? 0x0 : 0x4);

+ append(result, createByteArray("\x00\x03", 2));

+ result.push_back(static_cast<char>(requestID.size()));

+ append(result, concat(requestID, createByteArray("\x00\x00", 2)));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ CPPUNIT_ASSERT(createByteArray("abc") == receivedData);

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, createByteArray("def")), "foo@bar.com/baz", "id-b"));

+ CPPUNIT_ASSERT(createByteArray("abcdef") == receivedData);

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("othersession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("def")), "foo@bar.com/baz", "id-b"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, createByteArray("def")), "foo@bar.com/baz", "id-b"));

+ CPPUNIT_ASSERT(createByteArray("abcdef") == receivedData);

+ bytestream = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(createByteArray("abcdefg")));

+ CPPUNIT_ASSERT(createByteArray("abc") == ibb->getData());

+ CPPUNIT_ASSERT(createByteArray("def") == ibb->getData());

+#include <Swiften/Base/Concat.h>

+ stream1 = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(createByteArray("abcdefg")));

+ receive(createByteArray("\x05\x02\x01\x02"));

+ CPPUNIT_ASSERT(createByteArray("\x05\x00", 2) == receivedData);

+ receive(createByteArray("\x05\x02\x01"));

+ receive(createByteArray("\x01"));

+ CPPUNIT_ASSERT(createByteArray("\x05\x00", 2) == receivedData);

+ ByteArray hostname(createByteArray("abcdef"));

+ receive(concat(createByteArray("\x05\x01\x00\x03", 4), createByteArray(hostname.size()), hostname, createByteArray("\x00\x00", 2)));

+ CPPUNIT_ASSERT(createByteArray("\x05\x00\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == createByteArray(&receivedData[0], 13));

+ ByteArray hostname(createByteArray("abcdef"));

+ receive(concat(createByteArray("\x05\x01\x00\x03", 4), createByteArray(hostname.size()), hostname, createByteArray("\x00\x00", 2)));

+ CPPUNIT_ASSERT(createByteArray("\x05\x04\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == receivedData);

+ CPPUNIT_ASSERT(createByteArray("abcdefg") == receivedData);

+ CPPUNIT_ASSERT(createByteArray("abcdefg") == receivedData);

+ receive(createByteArray("\x05\x02\x01\x02"));

+ receive(concat(createByteArray("\x05\x01\x00\x03", 4), createByteArray(hostname.size()), createByteArray(hostname), createByteArray("\x00\x00", 2)));

+ receivedData = createByteArray(&receivedData[headerSize], receivedData.size() - headerSize);

+#include <Swiften/Base/ByteArray.h>

+ txtRecord.size(), vecptr(txtRecord),

+ DNSServiceUpdateRecord(sdRef, NULL, NULL, txtRecord.size(), vecptr(txtRecord), 0);

+ createByteArray(reinterpret_cast<const char*>(txtRecord), txtLen))),

+#include <Swiften/Base/ByteArray.h>

+

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/Concat.h>

+

+ append(result, getEncoded("1st=" + firstName));

+ append(result, getEncoded("last=" + lastName));

+ append(result, getEncoded("email=" + email));

+ append(result, getEncoded("jid=" + jid.toString()));

+ append(result, getEncoded("msg=" + message));

+ append(result, getEncoded("nick=" + nick));

+ append(result, getEncoded("port.p2pj=" + std::string(boost::lexical_cast<std::string>(*port))));

+ case Available: append(result, getEncoded("status=avail")); break;

+ case Away: append(result, getEncoded("status=away")); break;

+ case DND: append(result, getEncoded("status=dnd")); break;

+ return concat(sizeByte, createByteArray(s));

+ while (i < record.size()) {

+ while (i < entryEnd && i < record.size()) {

+#include <QA/Checker/IO.h>

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x09txtvers=1\x09" + std::string("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")), info.toTXTRecord());

+ LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(createByteArray("\x09txtvers=1\x09" + std::string("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")));

+ LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(createByteArray("\x10last=a"));

+#include <string>

+#include <Swiften/Base/Algorithm.h>

+ append(writeQueue_, data);

+ eventLoop->postEvent(boost::bind(boost::ref(onDataRead), createByteArray(&readBuffer_[0], bytesTransferred)), shared_from_this());

+ if (writeQueue_.empty()) {

+ connection_->write(createByteArray(connect.str()));

+ SWIFT_LOG(debug) << byteArrayToString(data) << std::endl;

+ std::vector<std::string> tmp = String::split(byteArrayToString(data), ' ');

+ SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << byteArrayToString(data) << std::endl;

+ int responseLength = res_query(const_cast<char*>(service.c_str()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(vecptr(response)), response.size());

+ HEADER* header = reinterpret_cast<HEADER*>(vecptr(response));

+ unsigned char* messageStart = vecptr(response);

+ entryLength = dn_expand(messageStart, messageEnd, currentEntry, reinterpret_cast<char*>(vecptr(entry)), entry.size());

+ record.hostname = std::string(reinterpret_cast<const char*>(vecptr(entry)));

+ socksConnect.push_back(0x05); // VER = SOCKS5 = 0x05

+ socksConnect.push_back(0x01); // Number of authentication methods after this byte.

+ socksConnect.push_back(0x00); // 0x00 == no authentication

+ 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)

+ socksConnect.push_back(static_cast<char>(uc));

+ socksConnect.push_back(static_cast<unsigned char> ((server_.getPort() >> 8) & 0xFF)); // highbyte of the port.

+ socksConnect.push_back(static_cast<unsigned char> (server_.getPort() & 0xFF)); // lowbyte of the port.

+#include <QA/Checker/IO.h>

+#include <Swiften/Base/Algorithm.h>

+ CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten);

+ connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));

+ CPPUNIT_ASSERT(dataRead.empty());

+ connectionFactory->connections[0]->onDataRead(createByteArray("FLOOP"));

+ connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 401 Unauthorized\r\n\r\n"));

+ connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));

+ connectionFactory->connections[0]->onDataRead(createByteArray("abcdef"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), dataRead);

+ connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));

+ testling->write(createByteArray("abcdef"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), connectionFactory->connections[0]->dataWritten);

+ connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));

+ append(dataRead, d);

+ append(dataWritten, d);

+ result = RegQueryValueEx(hKey, "ProxyServer", NULL, &dataType, reinterpret_cast<BYTE*>(vecptr(dataBuffer)), &dataSize);

+ std::vector<std::string> proxies = String::split(byteArrayToString(dataBuffer), ';');

+ result = RegQueryValueEx(hKey, "ProxyEnable", NULL, &dataType, reinterpret_cast<BYTE*>(vecptr(dataBuffer)), &dataSize);

+ for(size_t t = 0; t < dataBuffer.size(); t++) {

+ getPayloadInternal()->setData(Base64::decode(std::string(&data[0], data.size())));

+ CPPUNIT_ASSERT(createByteArray("abcdefgihjklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890\x0a") == ibb->getData());

+#include <QA/Checker/IO.h>

+ CPPUNIT_ASSERT_EQUAL(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), payload->getPhoto());

+#include <Swiften/Base/Algorithm.h>

+ while (receivedData.empty()) {

+ while (receivedData.empty()) {

+ testling->write(createByteArray("<stream:strea"));

+ testling->write(createByteArray("m"));

+ testling->write(createByteArray(">"));

+ while (receivedData.empty()) {

+ connection->write(createByteArray("<stream:stream>"));

+ connection->write(createByteArray("\r\n\r\n")); // Temporarily, while we don't have an xmpp server running on ipv6

+ append(receivedData, data);

+#include <QA/Checker/IO.h>

+ readByteArrayFromFile(certificateData, (pathProvider->getExecutableDir() / "jabber_org.crt").string());

+#include <vector>

+ virtual boost::optional< std::vector<unsigned char> > getResponse() const = 0;

+ virtual bool setChallenge(const boost::optional< std::vector<unsigned char> >&) = 0;

+#include <Swiften/Base/Concat.h>

+#include <Swiften/Base/Algorithm.h>

+ ByteArray A1 = concat(

+ MD5::getHash(createByteArray(getAuthenticationID() + ":" + realm + ":" + getPassword())), createByteArray(":"), createByteArray(*challenge.getValue("nonce")), createByteArray(":"), createByteArray(cnonce));

+ append(A1, createByteArray(":" + getAuthenticationID()));

+ ByteArray A2 = createByteArray("AUTHENTICATE:" + digestURI);

+

+ std::string responseValue = Hexify::hexify(MD5::getHash(createByteArray(

+ Hexify::hexify(MD5::getHash(A1)) + ":"

+ + *challenge.getValue("nonce") + ":" + nc + ":" + cnonce + ":" + qop + ":"

+ + Hexify::hexify(MD5::getHash(A2)))));

+#include <vector>

+ virtual boost::optional<std::vector<unsigned char> > getResponse() const;

+ virtual bool setChallenge(const boost::optional<std::vector<unsigned char> >&);

+#include <Swiften/Base/Algorithm.h>

+ if (v.size() == 0) {

+ else if (v.size() == 1) {

+ return v[v.size() - 1] != '"';

+ const char* data = reinterpret_cast<const char*>(vecptr(v));

+ size_t size = v.size();

+ if (v[v.size() - 1] == '"') {

+ return createByteArray(data, size);

+ for (size_t i = 0; i < data.size(); ++i) {

+ currentKey.push_back(c);

+ std::string key = byteArrayToString(currentKey);

+ result.setValue(key, byteArrayToString(stripQuotes(currentValue)));

+ result.setValue(key, byteArrayToString(currentValue));

+ currentValue.push_back(c);

+ if (!currentKey.empty()) {

+ std::string key = byteArrayToString(currentKey);

+ result.setValue(key, byteArrayToString(stripQuotes(currentValue)));

+ result.setValue(key, byteArrayToString(currentValue));

+ result.push_back(',');

+ append(result, createByteArray(i->first));

+ result.push_back('=');

+ append(result, createByteArray("\""));

+ append(result, i->second);

+ append(result, createByteArray("\""));

+ append(result, i->second);

+ return byteArrayToString(i->second);

+ properties.insert(DIGESTMD5PropertiesMap::value_type(key, createByteArray(value)));

+#include <Swiften/Base/Concat.h>

+ return concat(createByteArray(getAuthorizationID()), createByteArray('\0'), createByteArray(getAuthenticationID()), createByteArray('\0'), createByteArray(getPassword()));

+#include <Swiften/Base/ByteArray.h>

+ while (i < value.size() && value[i] != '\0') {

+ if (i == value.size()) {

+ while (i < value.size() && value[i] != '\0') {

+ if (i == value.size()) {

+ while (i < value.size()) {

+ return createByteArray(s);

+#include <Swiften/Base/Concat.h>

+ return concat(getGS2Header(), getInitialBareClientMessage());

+ ByteArray clientKey = HMACSHA1::getResult(saltedPassword, createByteArray("Client Key"));

+ for (unsigned int i = 0; i < clientProof.size(); ++i) {

+ ByteArray result = concat(getFinalMessageWithoutProof(), createByteArray(",p="), createByteArray(Base64::encode(clientProof)));

+ std::map<char, std::string> keys = parseMap(byteArrayToString(initialServerMessage));

+ serverNonce = createByteArray(clientServerNonce.substr(clientnonce.size(), clientServerNonce.npos));

+ saltedPassword = PBKDF2::encode(createByteArray(StringPrep::getPrepared(getPassword(), StringPrep::SASLPrep)), salt, iterations);

+ authMessage = concat(getInitialBareClientMessage(), createByteArray(","), initialServerMessage, createByteArray(","), getFinalMessageWithoutProof());

+ ByteArray serverKey = HMACSHA1::getResult(saltedPassword, createByteArray("Server Key"));

+ ByteArray result = concat(createByteArray("v="), createByteArray(Base64::encode(serverSignature)));

+ return createByteArray(std::string("n=" + escape(authenticationID) + ",r=" + clientnonce));

+ ByteArray channelBindingHeader(createByteArray("n"));

+ channelBindingHeader = createByteArray("p=tls-unique");

+ channelBindingHeader = createByteArray("y");

+ return concat(channelBindingHeader, createByteArray(","), (getAuthorizationID().empty() ? ByteArray() : createByteArray("a=" + escape(getAuthorizationID()))), createByteArray(","));

+ return concat(createByteArray("c=" + Base64::encode(concat(getGS2Header(), channelBindData)) + ",r=" + clientnonce), serverNonce);

+ testling.setChallenge(createByteArray(

+ CPPUNIT_ASSERT_EQUAL(std::string("charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=088891c800ecff1b842159ad6459104a,username=\"user\""), byteArrayToString(response));

+ testling.setChallenge(createByteArray(

+ CPPUNIT_ASSERT_EQUAL(std::string("authzid=\"myauthzid\",charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=4293834432b6e7889a2dee7e8fe7dd06,username=\"user\""), byteArrayToString(response));

+ DIGESTMD5Properties properties = DIGESTMD5Properties::parse(createByteArray(

+ ByteArray expected(createByteArray("authzid=\"myauthzid\",charset=utf-8,cnonce=\"mycnonce\",digest-uri=\"mydigesturi\",nc=1,nonce=\"mynonce\",qop=auth,realm=\"myrealm\",response=myresponse,username=\"myuser\""));

+ CPPUNIT_ASSERT_EQUAL(byteArrayToString(expected), byteArrayToString(result));

+#include <QA/Checker/IO.h>

+ CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), createByteArray("\0user\0pass", 10));

+ CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), createByteArray("authz\0user\0pass", 15));

+#include <QA/Checker/IO.h>

+ CPPUNIT_ASSERT_EQUAL(message.getValue(), createByteArray("\0user\0pass", 10));

+ CPPUNIT_ASSERT_EQUAL(message.getValue(), createByteArray("authz\0user\0pass", 15));

+ PLAINMessage message(createByteArray("\0user\0pass", 10));

+ PLAINMessage message(createByteArray("authz\0user\0pass", 15));

+ PLAINMessage message(createByteArray("authzid", 7));

+ PLAINMessage message(createByteArray("authzid\0authcid", 15));

+ CPPUNIT_ASSERT_EQUAL(std::string("n,,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));

+ CPPUNIT_ASSERT_EQUAL(std::string("n,,n==2Cus=3D=2Cer=3D,r=abcdefghABCDEFGH"), byteArrayToString(response));

+ CPPUNIT_ASSERT_EQUAL(std::string("n,a=auth,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));

+ CPPUNIT_ASSERT_EQUAL(std::string("n,a=a=3Du=2Cth,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ CPPUNIT_ASSERT_EQUAL(std::string("y,,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ CPPUNIT_ASSERT_EQUAL(std::string("p=tls-unique,,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ CPPUNIT_ASSERT_EQUAL(std::string("c=biws,r=abcdefghABCDEFGH,p=CZbjGDpIteIJwQNBgO0P8pKkMGY="), byteArrayToString(response));

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ CPPUNIT_ASSERT_EQUAL(std::string("c=eSws,r=abcdefghABCDEFGH,p=JNpsiFEcxZvNZ1+FFBBqrYvYxMk="), byteArrayToString(response));

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ CPPUNIT_ASSERT_EQUAL(std::string("c=cD10bHMtdW5pcXVlLCx4eXph,r=abcdefghABCDEFGH,p=i6Rghite81P1ype8XxaVAa5l7v0="), byteArrayToString(response));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("r=abcdefgiABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("r=abcdefgh,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=bla"));

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK"));

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=0"));

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=-1"));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("v=e26kI69ICb6zosapLLxrER/631A="));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ testling.setChallenge(createByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));

+#include <Swiften/Base/ByteArray.h>

+ boost::optional<std::vector<unsigned char> > message = authChallenge->getValue();

+ if ((*message).empty()) {

+ value = Base64::encode(ByteArray(*message));

+#include <Swiften/Base/ByteArray.h>

+ boost::optional<std::vector<unsigned char> > message = authRequest->getMessage();

+ if ((*message).empty()) {

+ value = Base64::encode(ByteArray(*message));

+#include <Swiften/Base/ByteArray.h>

+ boost::optional<std::vector<unsigned char> > message = authResponse->getValue();

+ if ((*message).empty()) {

+ value = Base64::encode(ByteArray(*message));

+#include <Swiften/Base/ByteArray.h>

+ boost::optional<std::vector<unsigned char> > message = authSuccess->getValue();

+ if ((*message).empty()) {

+ value = Base64::encode(ByteArray(*message));

+ vcard->setPhoto(createByteArray("abcdef"));

+ if (!vcard->getPhoto().empty() || !vcard->getPhotoType().empty()) {

+ if (!vcard->getPhoto().empty()) {

+#include <Swiften/Base/ByteArray.h>

+ authChallenge->setValue(createByteArray("foo"));

+ authChallenge->setValue(std::vector<unsigned char>());

+#include <Swiften/Base/ByteArray.h>

+ authRequest->setMessage(createByteArray("foo"));

+ authRequest->setMessage(std::vector<unsigned char>());

+#include <Swiften/Base/ByteArray.h>

+ authResponse->setValue(createByteArray("foo"));

+ authResponse->setValue(std::vector<unsigned char>());

+#include <Swiften/Base/ByteArray.h>

+ authSuccess->setValue(createByteArray("foo"));

+ authSuccess->setValue(std::vector<unsigned char>());

+ PLAINMessage plainMessage(authRequest->getMessage() ? *authRequest->getMessage() : createByteArray(""));

+#include <Swiften/Base/ByteArray.h>

+ onDataRead(byteArrayToString(data));

+ onDataWritten(byteArrayToString(data));

+#include <Swiften/Base/ByteArray.h>

+ std::cerr << byteArrayToString(data) << std::endl;

+#include <QA/Checker/IO.h>

+#include <Swiften/Base/Concat.h>

+ CPPUNIT_ASSERT_EQUAL(createByteArray("foo"), physicalStream_->data_[0]);

+ CPPUNIT_ASSERT_EQUAL(createByteArray("Xfoo"), physicalStream_->data_[0]);

+ CPPUNIT_ASSERT_EQUAL(createByteArray("XYfoo"), physicalStream_->data_[0]);

+ physicalStream_->onDataRead(createByteArray("<stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

+ physicalStream_->onDataRead(createByteArray("stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

+ physicalStream_->onDataRead(createByteArray("tream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

+ writeDataToChildLayer(concat(createByteArray(prepend_), data));

+ writeDataToParentLayer(concat(createByteArray(prepend_), data));

+ testling_->handleDataRead(createByteArray("<iq>"));

+ testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >"));

+ testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >"));

+ testling_->handleDataRead(createByteArray("<presence/>"));

+ testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>"));

+ testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>"));

+ writtenData += byteArrayToString(data);

+ writeDataToChildLayer(createByteArray(" "));

+ writeDataInternal(createByteArray(xmppSerializer_->serializeHeader(header)));

+ writeDataInternal(createByteArray(xmppSerializer_->serializeFooter()));

+ writeDataInternal(createByteArray(xmppSerializer_->serializeElement(element)));

+ writeDataInternal(createByteArray(data));

+ if (!xmppParser_->parse(byteArrayToString(data))) {

+ int len = s.size();

+#include <Swiften/Base/Algorithm.h>

+ assert(key.size() <= B);

+ for (unsigned int i = 0; i < x.size(); ++i) {

+ append(x, data);

+ for (unsigned int i = 0; i < y.size(); ++i) {

+ append(y, SHA1::getHash(x));

+ size_t xSize = B + data.size();

+ memcpy(x, key.getData(), key.size());

+ memcpy(x + B, data.getData(), data.size());

+ memcpy(y, key.getData(), key.size());

+#include <Swiften/Base/ByteArray.h>

+namespace Swift {

+ for (unsigned int i = 0; i < data.size(); ++i) {

+#include <Swiften/Base/ByteArray.h>

+#include <string.h>

+ md5_append(&state, reinterpret_cast<const md5_byte_t*>(vecptr(data)), data.size());

+ md5_finish(&state, reinterpret_cast<md5_byte_t*>(vecptr(digest)));

+#include <Swiften/Base/ByteArray.h>

+namespace Swift {

+#include <Swiften/Base/Concat.h>

+ ByteArray u = HMACSHA1::getResult(password, concat(salt, createByteArray("\0\0\0\1", 4)));

+ ByteArray result(u);

+ for (unsigned int j = 0; j < u.size(); ++j) {

+ Update(&context, (boost::uint8_t*) vecptr(inputCopy), inputCopy.size());

+ Final((boost::uint8_t*) vecptr(digest), &contextCopy);

+ std::vector<unsigned char> inputCopy(input);

+ Update(&context, (boost::uint8_t*) vecptr(inputCopy), inputCopy.size());

+ Final((boost::uint8_t*) vecptr(digest), &context);

+#include <QA/Checker/IO.h>

+ std::string result(Base64::encode(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890")));

+ std::string result(Base64::encode(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), result);

+#include <QA/Checker/IO.h>

+ ByteArray result(HMACSHA1::getResult(createByteArray("foo"), createByteArray("foobar")));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\xa4\xee\xba\x8e\x63\x3d\x77\x88\x69\xf5\x68\xd0\x5a\x1b\x3d\xc7\x2b\xfd\x4\xdd"), result);

+ CPPUNIT_ASSERT_EQUAL(std::string("4206b23ca6b0a643d20d89b04ff58cf78b8096ed"), Hexify::hexify(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));

+#include <QA/Checker/IO.h>

+ ByteArray result(MD5::getHash(createByteArray("")));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e", 16), result);

+ ByteArray result(MD5::getHash(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f", 16), result);

+#include <QA/Checker/IO.h>

+ ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 1));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6"), result);

+ ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 2));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\xea\x6c\x1\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57"), result);

+ ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 4096));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x4b\x00\x79\x1\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1", 20), result);

+#include <QA/Checker/IO.h>

+ sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

+ sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));

+ sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

+ sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

+ sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));

+ sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), sha.getHash());

+ ByteArray result(SHA1::getHash(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<")));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);

+ ByteArray input(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);

+ CPPUNIT_ASSERT_EQUAL(createByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), result);

+ for (size_t i = 0; i < hash.size(); ++i) {

+ unsigned char* p = const_cast<unsigned char*>(vecptr(der));

+ const unsigned char* p = vecptr(der);

+ cert = boost::shared_ptr<X509>(d2i_X509(NULL, &p, der.size()), X509_free);

+ unsigned char* p = vecptr(result);

+ X509_NAME_oneline(X509_get_subject_name(cert.get()), reinterpret_cast<char*>(vecptr(subjectNameData)), subjectNameData.size());

+ this->subjectName = byteArrayToString(subjectNameData);

+ commonNames.push_back(byteArrayToString(createByteArray(reinterpret_cast<const char*>(cnData->data), cnData->length)));

+ addXMPPAddress(byteArrayToString(createByteArray(reinterpret_cast<const char*>(ASN1_STRING_data(xmppAddrValue)), ASN1_STRING_length(xmppAddrValue))));

+ addSRVName(byteArrayToString(createByteArray(reinterpret_cast<const char*>(ASN1_STRING_data(srvNameValue)), ASN1_STRING_length(srvNameValue))));

+ addDNSName(byteArrayToString(createByteArray(ASN1_STRING_data(generalName->d.dNSName), ASN1_STRING_length(generalName->d.dNSName))));

+ OpenSSLCertificate cert(createByteArray(certContext->pbCertEncoded, certContext->cbCertEncoded));

+ BIO_read(writeBIO_, vecptr(data), size);

+ BIO_write(readBIO_, vecptr(data), data.size());

+ if (SSL_write(handle_, vecptr(data), data.size()) >= 0) {

+ int ret = SSL_read(handle_, vecptr(data), data.size());

+ ret = SSL_read(handle_, vecptr(data), data.size());

+ BIO_write(bio, vecptr(certificate.getData()), certificate.getData().size());

+ size_t size = SSL_get_finished(handle_, vecptr(data), data.size());

+ readByteArrayFromFile(data_, filename);

+ return data_.empty();

+ testling->setDER(createByteArray("abcdefg"));

+ if (vCard && !vCard->getPhoto().empty()) {

+ Swift::readByteArrayFromFile(data, settingsPath_.string());

+ foreach (std::string line, Swift::String::split(Swift::byteArrayToString(data), '\n')) {