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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
/**
* @file lluri.h
* @author Phoenix
* @date 2006-02-05
* @brief Declaration of the URI class.
*
* $LicenseInfo:firstyear=2006&license=viewergpl$
*
* Copyright (c) 2006-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLURI_H
#define LL_LLURI_H
#include <string>
class LLSD;
class LLUUID;
class LLApp;
/**
*
* LLURI instances are immutable
* See: http://www.ietf.org/rfc/rfc3986.txt
*
*/
class LLURI
{
public:
LLURI();
LLURI(const std::string& escaped_str);
LLURI(const std::string& scheme,
const std::string& userName,
const std::string& password,
const std::string& hostName,
U16 hostPort,
const std::string& escapedPath,
const std::string& escapedQuery);
// construct from escaped string, as would be transmitted on the net
~LLURI();
static LLURI buildHTTP(
const std::string& prefix,
const LLSD& path);
static LLURI buildHTTP(
const std::string& prefix,
const LLSD& path,
const LLSD& query);
///< prefix is either a full URL prefix of the form
/// "http://example.com:8080", or it can be simply a host and
/// optional port like "example.com" or "example.com:8080", in
/// these cases, the "http://" will be added
static LLURI buildHTTP(
const std::string& host,
const U32& port,
const LLSD& path);
static LLURI buildHTTP(
const std::string& host,
const U32& port,
const LLSD& path,
const LLSD& query);
std::string asString() const;
///< the whole URI, escaped as needed
/** @name Parts of a URI */
//@{
// These functions return parts of the decoded URI. The returned
// strings are un-escaped as needed
// for all schemes
std::string scheme() const; ///< ex.: "http", note lack of colon
std::string opaque() const; ///< everything after the colon
// for schemes that follow path like syntax (http, https, ftp)
std::string authority() const; // ex.: "host.com:80"
std::string hostName() const; // ex.: "host.com"
std::string userName() const;
std::string password() const;
U16 hostPort() const; // ex.: 80, will include implicit port
BOOL defaultPort() const; // true if port is default for scheme
const std::string& escapedPath() const { return mEscapedPath; }
std::string path() const; // ex.: "/abc/def", includes leading slash
LLSD pathArray() const; // above decoded into an array of strings
std::string query() const; // ex.: "x=34", section after "?"
const std::string& escapedQuery() const { return mEscapedQuery; }
LLSD queryMap() const; // above decoded into a map
static LLSD queryMap(std::string escaped_query_string);
/**
* @brief given a name value map, return a serialized query string.
*
* @param query_map a map of name value. every value must be
* representable as a string.
* @return Returns an url query string of '?n1=v1&n2=v2&...'
*/
static std::string mapToQueryString(const LLSD& query_map);
/** @name Escaping Utilities */
//@{
/**
* @brief Escape a raw url with a reasonable set of allowed characters.
*
* The default set was chosen to match HTTP urls and general
* guidelines for naming resources. Passing in a raw url does not
* produce well defined results because you really need to know
* which segments are path parts because path parts are supposed
* to be escaped individually. The default set chosen is:
*
* ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
* 0123456789
* -._~
* :@!$'()*+,=/?&#;
*
* *NOTE: This API is basically broken because it does not
* allow you to specify significant path characters. For example,
* if the filename actually contained a /, then you cannot use
* this function to generate the serialized url for that
* resource.
*
* @param str The raw URI to escape.
* @return Returns the escaped uri or an empty string.
*/
static std::string escape(const std::string& str);
/**
* @brief Escape a string with a specified set of allowed characters.
*
* Escape a string by urlencoding all the characters that aren't
* in the allowed string.
* @param str The raw URI to escape.
* @param allowed Character array of allowed characters
* @param is_allowed_sorted Optimization hint if allowed array is sorted.
* @return Returns the escaped uri or an empty string.
*/
static std::string escape(
const std::string& str,
const std::string& allowed,
bool is_allowed_sorted = false);
/**
* @brief unescape an escaped URI string.
*
* @param str The escped URI to unescape.
* @return Returns the unescaped uri or an empty string.
*/
static std::string unescape(const std::string& str);
//@}
private:
// only "http", "https", "ftp", and "secondlife" schemes are parsed
// secondlife scheme parses authority as "" and includes it as part of
// the path. See lluri_tut.cpp
// i.e. secondlife://app/login has mAuthority = "" and mPath = "/app/login"
void parseAuthorityAndPathUsingOpaque();
std::string mScheme;
std::string mEscapedOpaque;
std::string mEscapedAuthority;
std::string mEscapedPath;
std::string mEscapedQuery;
};
// this operator required for tut
bool operator!=(const LLURI& first, const LLURI& second);
#endif // LL_LLURI_H
|
