+vars.Add(PackageVariable("icu", "ICU library location", "no"))

+################################################################################

+# IDN library

+################################################################################

+

+# ICU

+icu_env = conf_env.Clone()

+use_icu = bool(env["icu"])

+icu_prefix = env["icu"] if isinstance(env["icu"], str) else ""

+icu_flags = {}

+if icu_prefix :

+ icu_flags = { "CPPPATH": [os.path.join(icu_prefix, "include")] }

+ icu_flags["LIBPATH"] = [os.path.join(icu_prefix, "lib")]

+ icu_env.MergeFlags(icu_flags)

+

+icu_conf = Configure(icu_env)

+if use_icu and icu_conf.CheckCHeader("unicode/usprep.h") :

+ env["HAVE_ICU"] = 1

+ env["ICU_FLAGS"] = icu_flags

+ env["ICU_FLAGS"]["LIBS"] = ["icuuc"]

+icu_conf.Finish()

+

+if not env.get("HAVE_ICU") and conf.CheckCHeader("idna.h") and conf.CheckLib(env["libidn_libname"]) :

+# Fallback to bundled LibIDN

+if not env.get("HAVE_ICU", False) and not env.get("HAVE_LIBIDN", False) :

+ env["LIBIDN_BUNDLED"] = 1

+

+ myenv.UseFlags(env["SWIFTEN_DEP_FLAGS"])

+ myenv.UseFlags(env.get("SWIFTEN_DEP_FLAGS", ""))

+ if myenv["PLATFORM"] == "darwin" :

+ myenv["ENV"]["DYLD_LIBRARY_PATH"] = ":".join(map(lambda x : str(x), myenv.get("LIBPATH", [])))

+myenv.UseFlags(env["SWIFTEN_DEP_FLAGS"])

+myenv.MergeFlags(env["SWIFTEN_DEP_FLAGS"])

+myenv.MergeFlags(myenv["SWIFTEN_DEP_FLAGS"])

+myenv.MergeFlags(myenv["SWIFTEN_DEP_FLAGS"])

+/*

+ * Copyright (c) 2012 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#pragma GCC diagnostic ignored "-Wold-style-cast"

+

+#include <unicode/ucnv.h>

+#include <cassert>

+#include <string>

+#include <vector>

+#include <boost/shared_ptr.hpp>

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

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

+

+namespace Swift {

+

+ class ICUConverter {

+ public:

+ typedef std::vector<UChar, SafeAllocator<UChar> > ICUString;

+

+ ICUConverter() {

+ UErrorCode status = U_ZERO_ERROR;

+ icuConverter.reset(ucnv_open("utf-8", &status), ucnv_close);

+ assert(U_SUCCESS(status));

+ }

+

+ template<typename T>

+ ICUString convertToICUString(const T& s) {

+ ICUString result;

+ result.resize(s.size());

+ UErrorCode status = U_ZERO_ERROR;

+ int icuResultLength = ucnv_toUChars(icuConverter.get(), vecptr(result), result.size(), toConstCharArray(s), s.size(), &status);

+ if (status == U_BUFFER_OVERFLOW_ERROR) {

+ status = U_ZERO_ERROR;

+ result.resize(icuResultLength);

+ icuResultLength = ucnv_toUChars(icuConverter.get(), vecptr(result), result.size(), toConstCharArray(s), s.size(), &status);

+ }

+ assert(U_SUCCESS(status));

+ result.resize(icuResultLength);

+ return result;

+ }

+

+ std::string convertToString(const ICUString& input) {

+ return std::string(vecptr(convertToArray(input)));

+ }

+

+ std::vector<char, SafeAllocator<char> > convertToArray(const ICUString& input) {

+ std::vector<char, SafeAllocator<char> > result;

+ result.resize(input.size());

+ UErrorCode status = U_ZERO_ERROR;

+ int inputLength = ucnv_fromUChars(icuConverter.get(), vecptr(result), result.size(), vecptr(input), input.size(), &status);

+ if (status == U_BUFFER_OVERFLOW_ERROR) {

+ status = U_ZERO_ERROR;

+ result.resize(inputLength);

+ inputLength = ucnv_fromUChars(icuConverter.get(), vecptr(result), result.size(), vecptr(input), input.size(), &status);

+ }

+ assert(U_SUCCESS(status));

+

+ result.resize(inputLength + 1);

+ result[result.size() - 1] = '\0';

+ return result;

+ }

+

+ private:

+ static const char* toConstCharArray(const std::string& input) {

+ return input.c_str();

+ }

+

+ static const char* toConstCharArray(const std::vector<unsigned char, SafeAllocator<unsigned char> >& input) {

+ return reinterpret_cast<const char*>(vecptr(input));

+ }

+

+ private:

+ boost::shared_ptr<UConverter> icuConverter;

+ };

+

+}

+ * Copyright (c) 2010-2012 Remko Tronçon

+#if defined(HAVE_ICU)

+#pragma GCC diagnostic ignored "-Wold-style-cast"

+#include <Swiften/IDN/ICUConverter.h>

+#include <unicode/uidna.h>

+#elif defined(HAVE_LIBIDN)

+#include <stringprep.h>

+#endif

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

+#include <boost/shared_ptr.hpp>

+#if defined(HAVE_ICU)

+ UErrorCode status = U_ZERO_ERROR;

+ ICUConverter converter;

+

+ ICUConverter::ICUString icuInput = converter.convertToICUString(domain);

+ ICUConverter::ICUString icuResult;

+ icuResult.resize(icuInput.size());

+ UParseError parseError;

+ int icuResultLength = uidna_IDNToASCII(vecptr(icuInput), icuInput.size(), vecptr(icuResult), icuResult.size(), UIDNA_DEFAULT, &parseError, &status);

+ if (status == U_BUFFER_OVERFLOW_ERROR) {

+ status = U_ZERO_ERROR;

+ icuResult.resize(icuResultLength);

+ icuResultLength = uidna_IDNToASCII(vecptr(icuInput), icuInput.size(), vecptr(icuResult), icuResult.size(), UIDNA_DEFAULT, &parseError, &status);

+ }

+ if (U_FAILURE(status)) {

+ return domain;

+ }

+ icuResult.resize(icuResultLength);

+

+ return converter.convertToString(icuResult);

+

+#elif defined(HAVE_LIBIDN)

+

+

+#endif

+if myenv.get("HAVE_ICU") :

+ myenv.MergeFlags(swiften_env["ICU_FLAGS"])

+ myenv.Append(CPPDEFINES = ["HAVE_ICU"])

+elif myenv.get("HAVE_LIBIDN") :

+ myenv.MergeFlags(swiften_env["LIBIDN_FLAGS"])

+ myenv.Append(CPPDEFINES = ["HAVE_LIBIDN"])

+ File("UnitTest/IDNATest.cpp"),

+ * Copyright (c) 2010-2012 Remko Tronçon

+#if defined(HAVE_ICU)

+#pragma GCC diagnostic ignored "-Wold-style-cast"

+#include <Swiften/IDN/ICUConverter.h>

+#include <unicode/usprep.h>

+#include <unicode/ucnv.h>

+#elif defined(HAVE_LIBIDN)

+extern "C" {

+#endif

+#include <boost/shared_ptr.hpp>

+#if defined(HAVE_ICU)

+

+namespace {

+ static UStringPrepProfileType getICUProfileType(StringPrep::Profile profile) {

+ switch(profile) {

+ case StringPrep::NamePrep: return USPREP_RFC3491_NAMEPREP; break;

+ case StringPrep::XMPPNodePrep: return USPREP_RFC3920_NODEPREP; break;

+ case StringPrep::XMPPResourcePrep: return USPREP_RFC3920_RESOURCEPREP; break;

+ case StringPrep::SASLPrep: return USPREP_RFC4013_SASLPREP; break;

+ }

+ assert(false);

+ return USPREP_RFC3491_NAMEPREP;

+ }

+

+ template<typename StringType>

+ std::vector<char, SafeAllocator<char> > getStringPrepared(const StringType& s, StringPrep::Profile profile) {

+ UErrorCode status = U_ZERO_ERROR;

+ ICUConverter converter;

+

+ boost::shared_ptr<UStringPrepProfile> icuProfile(usprep_openByType(getICUProfileType(profile), &status), usprep_close);

+ assert(U_SUCCESS(status));

+

+ ICUConverter::ICUString icuInput = converter.convertToICUString(s);

+ ICUConverter::ICUString icuResult;

+ UParseError parseError;

+ icuResult.resize(icuInput.size());

+ int icuResultLength = usprep_prepare(icuProfile.get(), vecptr(icuInput), icuInput.size(), vecptr(icuResult), icuResult.size(), USPREP_ALLOW_UNASSIGNED, &parseError, &status); icuResult.resize(icuResultLength);

+ if (status == U_BUFFER_OVERFLOW_ERROR) {

+ status = U_ZERO_ERROR;

+ icuResult.resize(icuResultLength);

+ icuResultLength = usprep_prepare(icuProfile.get(), vecptr(icuInput), icuInput.size(), vecptr(icuResult), icuResult.size(), USPREP_ALLOW_UNASSIGNED, &parseError, &status); icuResult.resize(icuResultLength);

+ }

+ if (U_FAILURE(status)) {

+ return std::vector<char, SafeAllocator<char> >();

+ }

+ icuResult.resize(icuResultLength);

+

+ return converter.convertToArray(icuResult);

+ }

+}

+

+namespace Swift {

+

+std::string StringPrep::getPrepared(const std::string& s, Profile profile) {

+ if (s.empty()) {

+ return "";

+ }

+ std::vector<char, SafeAllocator<char> > preparedData = getStringPrepared(s, profile);

+ if (preparedData.empty()) {

+ throw std::exception();

+ }

+ return std::string(vecptr(preparedData));

+}

+

+SafeByteArray StringPrep::getPrepared(const SafeByteArray& s, Profile profile) {

+ if (s.empty()) {

+ return SafeByteArray();

+ }

+ std::vector<char, SafeAllocator<char> > preparedData = getStringPrepared(s, profile);

+ if (preparedData.empty()) {

+ throw std::exception();

+ }

+ return createSafeByteArray(reinterpret_cast<const char*>(vecptr(preparedData)));

+}

+

+}

+

+////////////////////////////////////////////////////////////////////////////////

+

+#elif defined(HAVE_LIBIDN)

+

+namespace {

+

+#endif

+

+/*

+ * Copyright (c) 2012 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/IDN/IDNA.h>

+

+using namespace Swift;

+

+class IDNATest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(IDNATest);

+ CPPUNIT_TEST(testGetEncoded);

+ CPPUNIT_TEST(testGetEncoded_International);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testGetEncoded() {

+ std::string result = IDNA::getEncoded("www.swift.im");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("www.swift.im"), result);

+ }

+

+ void testGetEncoded_International() {

+ std::string result = IDNA::getEncoded("www.tron\xc3\x87on.com");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("www.xn--tronon-zua.com"), result);

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(IDNATest);

+

+ myenv.MergeFlags(myenv["SWIFTEN_DEP_FLAGS"])

+ myenv.MergeFlags(myenv["SWIFTEN_DEP_FLAGS"])

+swiften_dep_modules = ["BOOST", "GCONF", "ICU", "LIBIDN", "ZLIB", "OPENSSL", "LIBXML", "EXPAT", "AVAHI", "LIBMINIUPNPC", "LIBNATPMP"]