+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <SwifTools/URIHandler/URIHandler.h>

+

+namespace Swift {

+ class MacOSXURIHandler : public URIHandler {

+ public:

+ MacOSXURIHandler();

+ virtual ~MacOSXURIHandler();

+

+ virtual void start();

+ virtual void stop();

+

+ private:

+ class Private;

+ Private* p;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <SwifTools/URIHandler/MacOSXURIHandler.h>

+

+#include <Cocoa/Cocoa.h>

+#include <iostream>

+

+using namespace Swift;

+

+@interface MacOSXURIEventHandler : NSObject {

+ URIHandler* handler;

+}

+- (id) initWithHandler: (URIHandler*) handler;

+- (void) getUrl: (NSAppleEventDescriptor*) event withReplyEvent: (NSAppleEventDescriptor*) replyEvent;

+

+@end

+@implementation MacOSXURIEventHandler

+ - (id) initWithHandler: (URIHandler*) h {

+ if ([super init]) {

+ handler = h;

+ }

+ return self;

+ }

+

+ - (void) getUrl: (NSAppleEventDescriptor*) event withReplyEvent: (NSAppleEventDescriptor*) replyEvent {

+ (void) replyEvent;

+ NSString* url = [[event paramDescriptorForKeyword:keyDirectObject] stringValue];

+ handler->onURI(std::string([url UTF8String]));

+ }

+@end

+

+class MacOSXURIHandler::Private {

+ public:

+ MacOSXURIEventHandler* eventHandler;

+};

+

+MacOSXURIHandler::MacOSXURIHandler() {

+ p = new Private();

+ p->eventHandler = [[MacOSXURIEventHandler alloc] initWithHandler: this];

+}

+

+MacOSXURIHandler::~MacOSXURIHandler() {

+ [p->eventHandler release];

+ delete p;

+}

+

+void MacOSXURIHandler::start() {

+ [[NSAppleEventManager sharedAppleEventManager] setEventHandler:p->eventHandler andSelector:@selector(getUrl:withReplyEvent:) forEventClass:kInternetEventClass andEventID:kAEGetURL];

+ NSString* bundleID = [[NSBundle mainBundle] bundleIdentifier];

+ LSSetDefaultHandlerForURLScheme((CFStringRef)@"xmpp", (CFStringRef)bundleID);

+}

+

+void MacOSXURIHandler::stop() {

+ [[NSAppleEventManager sharedAppleEventManager] removeEventHandlerForEventClass:kInternetEventClass andEventID:kAEGetURL];

+}

+/*

+ * 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 {

+ void registerAppAsDefaultXMPPURIHandler();

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <SwifTools/URIHandler/MacOSXURIHandlerHelpers.h>

+

+#include <Cocoa/Cocoa.h>

+

+namespace Swift {

+ void registerAppAsDefaultXMPPURIHandler() {

+ NSString* bundleID = [[NSBundle mainBundle] bundleIdentifier];

+ LSSetDefaultHandlerForURLScheme((CFStringRef)@"xmpp", (CFStringRef)bundleID);

+ }

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <SwifTools/URIHandler/URIHandler.h>

+

+namespace Swift {

+ class NullURIHandler : public URIHandler {

+ public:

+ virtual void start() {

+ }

+

+ virtual void stop() {

+ }

+ };

+}

+Import("swiftools_env", "env")

+

+sources = [

+ "XMPPURI.cpp",

+ "URIHandler.cpp",

+ ]

+

+if swiftools_env["PLATFORM"] == "darwin" and swiftools_env["target"] == "native" :

+ sources += [

+ "MacOSXURIHandler.mm",

+ "MacOSXURIHandlerHelpers.mm",

+ ]

+elif swiftools_env["PLATFORM"] == "win32" :

+ sources += []

+else :

+ sources += []

+

+objects = swiftools_env.StaticObject(sources)

+swiftools_env.Append(SWIFTOOLS_OBJECTS = [objects])

+

+env.Append(UNITTEST_SOURCES = [

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

+ ])

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <SwifTools/URIHandler/URIHandler.h>

+

+using namespace Swift;

+

+URIHandler::URIHandler() {

+}

+

+URIHandler::~URIHandler() {

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

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

+

+namespace Swift {

+ class URIHandler {

+ public:

+ URIHandler();

+ virtual ~URIHandler();

+

+ boost::signal<void (const std::string&)> onURI;

+ };

+}

+/*

+ * Copyright (c) 2011 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 <SwifTools/URIHandler/XMPPURI.h>

+

+using namespace Swift;

+

+class XMPPURITest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(XMPPURITest);

+ CPPUNIT_TEST(testFromString_Authority);

+ CPPUNIT_TEST(testFromString_AuthorityWithPath);

+ CPPUNIT_TEST(testFromString_AuthorityWithFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithPathAndFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithIntlChars);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithoutParameters);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithParameters);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithoutParametersWithFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithParametersWithFragment);

+ CPPUNIT_TEST(testFromString_Path);

+ CPPUNIT_TEST(testFromString_PathWithFragment);

+ CPPUNIT_TEST(testFromString_PathWithIntlChars);

+ CPPUNIT_TEST(testFromString_PathWithInvalidEscapedChar);

+ CPPUNIT_TEST(testFromString_PathWithIncompleteEscapedChar);

+ CPPUNIT_TEST(testFromString_PathWithIncompleteEscapedChar2);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithoutParameters);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithParameters);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithoutParametersWithFragment);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithParametersWithFragment);

+ CPPUNIT_TEST(testFromString_NoPrefix);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testFromString_Authority() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ }

+

+ void testFromString_AuthorityWithPath() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com/baz@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ }

+

+ void testFromString_AuthorityWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithPathAndFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com/baz@example.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithIntlChars() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://nasty!%23$%25()*+,-.;=\%3F\%5B\%5C\%5D\%5E_\%60\%7B\%7C\%7D~node@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("nasty!#$\%()*+,-.;=?[\\]^_`{|}~node@example.com"), testling.getAuthority());

+ }

+

+ void testFromString_AuthorityWithQueryWithoutParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ }

+

+ void testFromString_AuthorityWithQueryWithParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ }

+

+ void testFromString_AuthorityWithQueryWithoutParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithQueryWithParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_Path() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:baz@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ }

+

+ void testFromString_PathWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:baz@example.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_PathWithIntlChars() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:nasty!%23$%25()*+,-.;=\%3F\%5B\%5C\%5D\%5E_\%60\%7B\%7C\%7D~node@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("nasty!#$\%()*+,-.;=?[\\]^_`{|}~node@example.com"), testling.getPath());

+ }

+

+ void testFromString_PathWithInvalidEscapedChar() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test%%@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+

+ void testFromString_PathWithIncompleteEscapedChar() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com%");

+

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+

+ void testFromString_PathWithIncompleteEscapedChar2() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com%1");

+

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+

+ void testFromString_PathWithQueryWithoutParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ }

+

+ void testFromString_PathWithQueryWithParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ }

+

+ void testFromString_PathWithQueryWithoutParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_PathWithQueryWithParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_NoPrefix() {

+ XMPPURI testling = XMPPURI::fromString("baz@example.com");

+

+ CPPUNIT_ASSERT(testling.isNull());

+ }

+

+ private:

+ std::string get(const std::map<std::string, std::string>& m, const std::string& k) {

+ std::map<std::string, std::string>::const_iterator i = m.find(k);

+ return i == m.end() ? "" : i->second;

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(XMPPURITest);

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <SwifTools/URIHandler/XMPPURI.h>

+

+#include <boost/algorithm/string/predicate.hpp>

+#include <boost/algorithm/string/find_format.hpp>

+#include <boost/algorithm/string/formatter.hpp>

+#include <boost/algorithm/string/find_iterator.hpp>

+#include <boost/algorithm/string/split.hpp>

+#include <boost/algorithm/string/classification.hpp>

+#include <sstream>

+#include <stdexcept>

+#include <vector>

+

+using namespace Swift;

+

+namespace {

+

+ struct PercentEncodedCharacterFinder {

+ template<typename Iterator>

+ boost::iterator_range<Iterator> operator()(Iterator begin, Iterator end) {

+ boost::iterator_range<Iterator> r = boost::first_finder("%")(begin, end);

+ if (r.end() == end) {

+ return r;

+ }

+ else {

+ if (r.end() + 1 == end || r.end() + 2 == end) {

+ throw std::runtime_error("Incomplete escape character");

+ }

+ else {

+ r.advance_end(2);

+ return r;

+ }

+ }

+ }

+ };

+

+ struct PercentUnencodeFormatter {

+ template<typename FindResult>

+ std::string operator()(const FindResult& match) const {

+ std::stringstream s;

+ s << std::hex << std::string(match.begin() + 1, match.end());

+ unsigned int value;

+ s >> value;

+ if (s.fail() || s.bad()) {

+ throw std::runtime_error("Invalid escape character");

+ }

+ return std::string(reinterpret_cast<const char*>(&value), 1);

+ }

+ };

+

+

+ std::string unescape(const std::string& s) {

+ try {

+ return boost::find_format_all_copy(s, PercentEncodedCharacterFinder(), PercentUnencodeFormatter());

+ }

+ catch (const std::exception&) {

+ return "";

+ }

+ }

+}

+

+XMPPURI::XMPPURI() {

+}

+

+XMPPURI XMPPURI::fromString(const std::string& s) {

+ XMPPURI result;

+ if (boost::starts_with(s, "xmpp:")) {

+ std::string uri = s.substr(5, s.npos);

+ bool parsePath = true;

+ bool parseQuery = true;

+ bool parseFragment = true;

+

+ // Parse authority

+ if (boost::starts_with(uri, "//")) {

+ size_t i = uri.find_first_of("/#?", 2);

+ result.setAuthority(JID(unescape(uri.substr(2, i - 2))));

+ if (i == uri.npos) {

+ uri = "";

+ parsePath = parseQuery = parseFragment = false;

+ }

+ else {

+ if (uri[i] == '?') {

+ parsePath = false;

+ }

+ else if (uri[i] == '#') {

+ parseQuery = parsePath = false;

+ }

+ uri = uri.substr(i + 1, uri.npos);

+ }

+ }

+

+ // Parse path

+ if (parsePath) {

+ size_t i = uri.find_first_of("#?");

+ result.setPath(JID(unescape(uri.substr(0, i))));

+ if (i == uri.npos) {

+ uri = "";

+ parseQuery = parseFragment = false;

+ }

+ else {

+ if (uri[i] == '#') {

+ parseQuery = false;

+ }

+ uri = uri.substr(i + 1, uri.npos);

+ }

+ }

+

+ // Parse query

+ if (parseQuery) {

+ size_t end = uri.find_first_of("#");

+ std::string query = uri.substr(0, end);

+ bool haveType = false;

+ typedef boost::split_iterator<std::string::iterator> split_iterator;

+ for (split_iterator it = boost::make_split_iterator(query, boost::first_finder(";")); it != split_iterator(); ++it) {

+ if (haveType) {

+ std::vector<std::string> keyValue;

+ boost::split(keyValue, *it, boost::is_any_of("="));

+ if (keyValue.size() == 1) {

+ result.addQueryParameter(unescape(keyValue[0]), "");

+ }

+ else if (keyValue.size() >= 2) {

+ result.addQueryParameter(unescape(keyValue[0]), unescape(keyValue[1]));

+ }

+ }

+ else {

+ result.setQueryType(unescape(boost::copy_range<std::string>(*it)));

+ haveType = true;

+ }

+ }

+ uri = (end == uri.npos ? "" : uri.substr(end + 1, uri.npos));

+ }

+

+ // Parse fragment

+ if (parseFragment) {

+ result.setFragment(unescape(uri));

+ }

+ }

+ return result;

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+#include <map>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class XMPPURI {

+ public:

+ XMPPURI();

+

+ const JID& getAuthority() const {

+ return authority;

+ }

+

+ void setAuthority(const JID& j) {

+ authority = j;

+ }

+

+ const JID& getPath() const {

+ return path;

+ }

+

+ void setPath(const JID& j) {

+ path = j;

+ }

+

+ const std::string& getQueryType() const {

+ return queryType;

+ }

+

+ void setQueryType(const std::string& q) {

+ queryType = q;

+ }

+

+ const std::map<std::string, std::string>& getQueryParameters() const {

+ return queryParameters;

+ }

+

+ void addQueryParameter(const std::string& key, const std::string& path) {

+ queryParameters[key] = path;

+ }

+

+ const std::string& getFragment() const {

+ return fragment;

+ }

+

+ void setFragment(const std::string& f) {

+ fragment = f;

+ }

+

+ bool isNull() const {

+ return !authority.isValid() && !path.isValid();

+ }

+

+ static XMPPURI fromString(const std::string&);

+

+ private:

+ JID authority;

+ JID path;

+ std::string fragment;

+ std::string queryType;

+ std::map<std::string, std::string> queryParameters;

+ };

+}