summaryrefslogtreecommitdiffstats
blob: 8b8b81c1bdf3854a96cdfe940f004521eec01ddc (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/*
 * Copyright (c) 2011-2016 Isode Limited.
 * All rights reserved.
 * See the COPYING file for more information.
 */

#include <SwifTools/URIHandler/XMPPURI.h>

#include <sstream>
#include <stdexcept>
#include <vector>

#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/find_format.hpp>
#include <boost/algorithm/string/find_iterator.hpp>
#include <boost/algorithm/string/formatter.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/split.hpp>

#include <Swiften/Base/URL.h>

using namespace Swift;


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(URL::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(URL::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(URL::unescape(keyValue[0]), "");
                }
                else if (keyValue.size() >= 2) {
                    result.addQueryParameter(URL::unescape(keyValue[0]), URL::unescape(keyValue[1]));
                }
            }
            else {
                result.setQueryType(URL::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(URL::unescape(uri));
        }
    }
    return result;
}