author | Michael Krelin <hacker@klever.net> | 2008-03-02 23:52:14 (UTC) |
---|---|---|
committer | Michael Krelin <hacker@klever.net> | 2008-03-02 23:52:14 (UTC) |
commit | 5fd5ecad8c2bd1e8846c11fa9b281f0f4ab8a4a7 (patch) (unidiff) | |
tree | 76ba24c589d0ce7de6cab113787cf7a70572f994 /lib | |
parent | f6482fb9003e4953f838ba4ef2c110190355622f (diff) | |
download | libopkele-5fd5ecad8c2bd1e8846c11fa9b281f0f4ab8a4a7.zip libopkele-5fd5ecad8c2bd1e8846c11fa9b281f0f4ab8a4a7.tar.gz libopkele-5fd5ecad8c2bd1e8846c11fa9b281f0f4ab8a4a7.tar.bz2 |
aded util::url_decode()
Signed-off-by: Michael Krelin <hacker@klever.net>
-rw-r--r-- | lib/util.cc | 28 |
1 files changed, 28 insertions, 0 deletions
diff --git a/lib/util.cc b/lib/util.cc index a6e08e2..3e7f3aa 100644 --- a/lib/util.cc +++ b/lib/util.cc | |||
@@ -3,384 +3,412 @@ | |||
3 | #include <cctype> | 3 | #include <cctype> |
4 | #include <cstring> | 4 | #include <cstring> |
5 | #include <vector> | 5 | #include <vector> |
6 | #include <string> | 6 | #include <string> |
7 | #include <stack> | 7 | #include <stack> |
8 | #include <algorithm> | 8 | #include <algorithm> |
9 | #include <openssl/bio.h> | 9 | #include <openssl/bio.h> |
10 | #include <openssl/evp.h> | 10 | #include <openssl/evp.h> |
11 | #include <openssl/sha.h> | 11 | #include <openssl/sha.h> |
12 | #include <openssl/hmac.h> | 12 | #include <openssl/hmac.h> |
13 | #include <opkele/util.h> | 13 | #include <opkele/util.h> |
14 | #include <opkele/exception.h> | 14 | #include <opkele/exception.h> |
15 | #include <opkele/data.h> | 15 | #include <opkele/data.h> |
16 | #include <opkele/debug.h> | 16 | #include <opkele/debug.h> |
17 | 17 | ||
18 | #include <config.h> | 18 | #include <config.h> |
19 | #ifdef HAVE_DEMANGLE | 19 | #ifdef HAVE_DEMANGLE |
20 | # include <cxxabi.h> | 20 | # include <cxxabi.h> |
21 | #endif | 21 | #endif |
22 | 22 | ||
23 | namespace opkele { | 23 | namespace opkele { |
24 | using namespace std; | 24 | using namespace std; |
25 | 25 | ||
26 | namespace util { | 26 | namespace util { |
27 | 27 | ||
28 | /* | 28 | /* |
29 | * base64 | 29 | * base64 |
30 | */ | 30 | */ |
31 | string encode_base64(const void *data,size_t length) { | 31 | string encode_base64(const void *data,size_t length) { |
32 | BIO *b64 = 0, *bmem = 0; | 32 | BIO *b64 = 0, *bmem = 0; |
33 | try { | 33 | try { |
34 | b64 = BIO_new(BIO_f_base64()); | 34 | b64 = BIO_new(BIO_f_base64()); |
35 | if(!b64) | 35 | if(!b64) |
36 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new() base64 encoder"); | 36 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new() base64 encoder"); |
37 | BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL); | 37 | BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL); |
38 | bmem = BIO_new(BIO_s_mem()); | 38 | bmem = BIO_new(BIO_s_mem()); |
39 | BIO_set_flags(b64,BIO_CLOSE); | 39 | BIO_set_flags(b64,BIO_CLOSE); |
40 | if(!bmem) | 40 | if(!bmem) |
41 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new() memory buffer"); | 41 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new() memory buffer"); |
42 | BIO_push(b64,bmem); | 42 | BIO_push(b64,bmem); |
43 | if(((size_t)BIO_write(b64,data,length))!=length) | 43 | if(((size_t)BIO_write(b64,data,length))!=length) |
44 | throw exception_openssl(OPKELE_CP_ "failed to BIO_write()"); | 44 | throw exception_openssl(OPKELE_CP_ "failed to BIO_write()"); |
45 | if(BIO_flush(b64)!=1) | 45 | if(BIO_flush(b64)!=1) |
46 | throw exception_openssl(OPKELE_CP_ "failed to BIO_flush()"); | 46 | throw exception_openssl(OPKELE_CP_ "failed to BIO_flush()"); |
47 | char *rvd; | 47 | char *rvd; |
48 | long rvl = BIO_get_mem_data(bmem,&rvd); | 48 | long rvl = BIO_get_mem_data(bmem,&rvd); |
49 | string rv(rvd,rvl); | 49 | string rv(rvd,rvl); |
50 | BIO_free_all(b64); | 50 | BIO_free_all(b64); |
51 | return rv; | 51 | return rv; |
52 | }catch(...) { | 52 | }catch(...) { |
53 | if(b64) BIO_free_all(b64); | 53 | if(b64) BIO_free_all(b64); |
54 | throw; | 54 | throw; |
55 | } | 55 | } |
56 | } | 56 | } |
57 | 57 | ||
58 | void decode_base64(const string& data,vector<unsigned char>& rv) { | 58 | void decode_base64(const string& data,vector<unsigned char>& rv) { |
59 | BIO *b64 = 0, *bmem = 0; | 59 | BIO *b64 = 0, *bmem = 0; |
60 | rv.clear(); | 60 | rv.clear(); |
61 | try { | 61 | try { |
62 | bmem = BIO_new_mem_buf((void*)data.data(),data.size()); | 62 | bmem = BIO_new_mem_buf((void*)data.data(),data.size()); |
63 | if(!bmem) | 63 | if(!bmem) |
64 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new_mem_buf()"); | 64 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new_mem_buf()"); |
65 | b64 = BIO_new(BIO_f_base64()); | 65 | b64 = BIO_new(BIO_f_base64()); |
66 | if(!b64) | 66 | if(!b64) |
67 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new() base64 decoder"); | 67 | throw exception_openssl(OPKELE_CP_ "failed to BIO_new() base64 decoder"); |
68 | BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL); | 68 | BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL); |
69 | BIO_push(b64,bmem); | 69 | BIO_push(b64,bmem); |
70 | unsigned char tmp[512]; | 70 | unsigned char tmp[512]; |
71 | size_t rb = 0; | 71 | size_t rb = 0; |
72 | while((rb=BIO_read(b64,tmp,sizeof(tmp)))>0) | 72 | while((rb=BIO_read(b64,tmp,sizeof(tmp)))>0) |
73 | rv.insert(rv.end(),tmp,&tmp[rb]); | 73 | rv.insert(rv.end(),tmp,&tmp[rb]); |
74 | BIO_free_all(b64); | 74 | BIO_free_all(b64); |
75 | }catch(...) { | 75 | }catch(...) { |
76 | if(b64) BIO_free_all(b64); | 76 | if(b64) BIO_free_all(b64); |
77 | throw; | 77 | throw; |
78 | } | 78 | } |
79 | } | 79 | } |
80 | 80 | ||
81 | /* | 81 | /* |
82 | * big numerics | 82 | * big numerics |
83 | */ | 83 | */ |
84 | 84 | ||
85 | BIGNUM *base64_to_bignum(const string& b64) { | 85 | BIGNUM *base64_to_bignum(const string& b64) { |
86 | vector<unsigned char> bin; | 86 | vector<unsigned char> bin; |
87 | decode_base64(b64,bin); | 87 | decode_base64(b64,bin); |
88 | BIGNUM *rv = BN_bin2bn(&(bin.front()),bin.size(),0); | 88 | BIGNUM *rv = BN_bin2bn(&(bin.front()),bin.size(),0); |
89 | if(!rv) | 89 | if(!rv) |
90 | throw failed_conversion(OPKELE_CP_ "failed to BN_bin2bn()"); | 90 | throw failed_conversion(OPKELE_CP_ "failed to BN_bin2bn()"); |
91 | return rv; | 91 | return rv; |
92 | } | 92 | } |
93 | 93 | ||
94 | BIGNUM *dec_to_bignum(const string& dec) { | 94 | BIGNUM *dec_to_bignum(const string& dec) { |
95 | BIGNUM *rv = 0; | 95 | BIGNUM *rv = 0; |
96 | if(!BN_dec2bn(&rv,dec.c_str())) | 96 | if(!BN_dec2bn(&rv,dec.c_str())) |
97 | throw failed_conversion(OPKELE_CP_ "failed to BN_dec2bn()"); | 97 | throw failed_conversion(OPKELE_CP_ "failed to BN_dec2bn()"); |
98 | return rv; | 98 | return rv; |
99 | } | 99 | } |
100 | 100 | ||
101 | string bignum_to_base64(const BIGNUM *bn) { | 101 | string bignum_to_base64(const BIGNUM *bn) { |
102 | vector<unsigned char> bin(BN_num_bytes(bn)+1); | 102 | vector<unsigned char> bin(BN_num_bytes(bn)+1); |
103 | unsigned char *binptr = &(bin.front())+1; | 103 | unsigned char *binptr = &(bin.front())+1; |
104 | int l = BN_bn2bin(bn,binptr); | 104 | int l = BN_bn2bin(bn,binptr); |
105 | if(l && (*binptr)&0x80){ | 105 | if(l && (*binptr)&0x80){ |
106 | (*(--binptr)) = 0; ++l; | 106 | (*(--binptr)) = 0; ++l; |
107 | } | 107 | } |
108 | return encode_base64(binptr,l); | 108 | return encode_base64(binptr,l); |
109 | } | 109 | } |
110 | 110 | ||
111 | /* | 111 | /* |
112 | * w3c times | 112 | * w3c times |
113 | */ | 113 | */ |
114 | 114 | ||
115 | string time_to_w3c(time_t t) { | 115 | string time_to_w3c(time_t t) { |
116 | struct tm tm_t; | 116 | struct tm tm_t; |
117 | if(!gmtime_r(&t,&tm_t)) | 117 | if(!gmtime_r(&t,&tm_t)) |
118 | throw failed_conversion(OPKELE_CP_ "failed to BN_dec2bn()"); | 118 | throw failed_conversion(OPKELE_CP_ "failed to BN_dec2bn()"); |
119 | char rv[25]; | 119 | char rv[25]; |
120 | if(!strftime(rv,sizeof(rv)-1,"%Y-%m-%dT%H:%M:%SZ",&tm_t)) | 120 | if(!strftime(rv,sizeof(rv)-1,"%Y-%m-%dT%H:%M:%SZ",&tm_t)) |
121 | throw failed_conversion(OPKELE_CP_ "failed to strftime()"); | 121 | throw failed_conversion(OPKELE_CP_ "failed to strftime()"); |
122 | return rv; | 122 | return rv; |
123 | } | 123 | } |
124 | 124 | ||
125 | time_t w3c_to_time(const string& w) { | 125 | time_t w3c_to_time(const string& w) { |
126 | int fraction; | 126 | int fraction; |
127 | struct tm tm_t; | 127 | struct tm tm_t; |
128 | memset(&tm_t,0,sizeof(tm_t)); | 128 | memset(&tm_t,0,sizeof(tm_t)); |
129 | if( ( | 129 | if( ( |
130 | sscanf( | 130 | sscanf( |
131 | w.c_str(), | 131 | w.c_str(), |
132 | "%04d-%02d-%02dT%02d:%02d:%02dZ", | 132 | "%04d-%02d-%02dT%02d:%02d:%02dZ", |
133 | &tm_t.tm_year,&tm_t.tm_mon,&tm_t.tm_mday, | 133 | &tm_t.tm_year,&tm_t.tm_mon,&tm_t.tm_mday, |
134 | &tm_t.tm_hour,&tm_t.tm_min,&tm_t.tm_sec | 134 | &tm_t.tm_hour,&tm_t.tm_min,&tm_t.tm_sec |
135 | ) != 6 | 135 | ) != 6 |
136 | ) && ( | 136 | ) && ( |
137 | sscanf( | 137 | sscanf( |
138 | w.c_str(), | 138 | w.c_str(), |
139 | "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", | 139 | "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", |
140 | &tm_t.tm_year,&tm_t.tm_mon,&tm_t.tm_mday, | 140 | &tm_t.tm_year,&tm_t.tm_mon,&tm_t.tm_mday, |
141 | &tm_t.tm_hour,&tm_t.tm_min,&tm_t.tm_sec, | 141 | &tm_t.tm_hour,&tm_t.tm_min,&tm_t.tm_sec, |
142 | &fraction | 142 | &fraction |
143 | ) != 7 | 143 | ) != 7 |
144 | ) ) | 144 | ) ) |
145 | throw failed_conversion(OPKELE_CP_ "failed to sscanf()"); | 145 | throw failed_conversion(OPKELE_CP_ "failed to sscanf()"); |
146 | tm_t.tm_mon--; | 146 | tm_t.tm_mon--; |
147 | tm_t.tm_year-=1900; | 147 | tm_t.tm_year-=1900; |
148 | time_t rv = mktime(&tm_t); | 148 | time_t rv = mktime(&tm_t); |
149 | if(rv==(time_t)-1) | 149 | if(rv==(time_t)-1) |
150 | throw failed_conversion(OPKELE_CP_ "failed to mktime()"); | 150 | throw failed_conversion(OPKELE_CP_ "failed to mktime()"); |
151 | return rv-timezone; | 151 | return rv-timezone; |
152 | } | 152 | } |
153 | 153 | ||
154 | /* | 154 | /* |
155 | * | 155 | * |
156 | */ | 156 | */ |
157 | 157 | ||
158 | static inline bool isrfc3986unreserved(int c) { | 158 | static inline bool isrfc3986unreserved(int c) { |
159 | if(c<'-') return false; | 159 | if(c<'-') return false; |
160 | if(c<='.') return true; | 160 | if(c<='.') return true; |
161 | if(c<'0') return false; if(c<='9') return true; | 161 | if(c<'0') return false; if(c<='9') return true; |
162 | if(c<'A') return false; if(c<='Z') return true; | 162 | if(c<'A') return false; if(c<='Z') return true; |
163 | if(c<'_') return false; | 163 | if(c<'_') return false; |
164 | if(c=='_') return true; | 164 | if(c=='_') return true; |
165 | if(c<'a') return false; if(c<='z') return true; | 165 | if(c<'a') return false; if(c<='z') return true; |
166 | if(c=='~') return true; | 166 | if(c=='~') return true; |
167 | return false; | 167 | return false; |
168 | } | 168 | } |
169 | 169 | ||
170 | struct __url_encoder : public unary_function<char,void> { | 170 | struct __url_encoder : public unary_function<char,void> { |
171 | public: | 171 | public: |
172 | string& rv; | 172 | string& rv; |
173 | 173 | ||
174 | __url_encoder(string& r) : rv(r) { } | 174 | __url_encoder(string& r) : rv(r) { } |
175 | 175 | ||
176 | result_type operator()(argument_type c) { | 176 | result_type operator()(argument_type c) { |
177 | if(isrfc3986unreserved(c)) | 177 | if(isrfc3986unreserved(c)) |
178 | rv += c; | 178 | rv += c; |
179 | else{ | 179 | else{ |
180 | char tmp[4]; | 180 | char tmp[4]; |
181 | snprintf(tmp,sizeof(tmp),"%%%02X", | 181 | snprintf(tmp,sizeof(tmp),"%%%02X", |
182 | (c&0xff)); | 182 | (c&0xff)); |
183 | rv += tmp; | 183 | rv += tmp; |
184 | } | 184 | } |
185 | } | 185 | } |
186 | }; | 186 | }; |
187 | 187 | ||
188 | string url_encode(const string& str) { | 188 | string url_encode(const string& str) { |
189 | string rv; | 189 | string rv; |
190 | for_each(str.begin(),str.end(), | 190 | for_each(str.begin(),str.end(), |
191 | __url_encoder(rv)); | 191 | __url_encoder(rv)); |
192 | return rv; | 192 | return rv; |
193 | } | 193 | } |
194 | 194 | ||
195 | string url_decode(const string& str) { | ||
196 | string rv; | ||
197 | back_insert_iterator<string> ii(rv); | ||
198 | for(string::const_iterator i=str.begin(),ie=str.end(); | ||
199 | i!=ie;++i) { | ||
200 | switch(*i) { | ||
201 | case '+': | ||
202 | *(ii++) = ' '; break; | ||
203 | case '%': | ||
204 | ++i; | ||
205 | static char tmp[3] = {0,0,0}; | ||
206 | if(i==ie) | ||
207 | throw failed_conversion(OPKELE_CP_ "trailing percent in the url-encoded string"); | ||
208 | tmp[0] == *(i++); | ||
209 | if(i==ie) | ||
210 | throw failed_conversion(OPKELE_CP_ "not enough hexadecimals after the percent sign in url-encoded string"); | ||
211 | tmp[1] == *i; | ||
212 | if(!(isxdigit(tmp[0]) && isxdigit(tmp[1]))) | ||
213 | throw failed_conversion(OPKELE_CP_ "non-hex follows percent in url-encoded string"); | ||
214 | *(ii++) = strtol(tmp,0,16); | ||
215 | break; | ||
216 | default: | ||
217 | *(ii++) = *i; break; | ||
218 | } | ||
219 | } | ||
220 | return rv; | ||
221 | } | ||
222 | |||
195 | string attr_escape(const string& str) { | 223 | string attr_escape(const string& str) { |
196 | static const char *unsafechars = "<>&\n\"'"; | 224 | static const char *unsafechars = "<>&\n\"'"; |
197 | string rv; | 225 | string rv; |
198 | string::size_type p=0; | 226 | string::size_type p=0; |
199 | while(true) { | 227 | while(true) { |
200 | string::size_type us = str.find_first_of(unsafechars,p); | 228 | string::size_type us = str.find_first_of(unsafechars,p); |
201 | if(us==string::npos) { | 229 | if(us==string::npos) { |
202 | if(p!=str.length()) | 230 | if(p!=str.length()) |
203 | rv.append(str,p,str.length()-p); | 231 | rv.append(str,p,str.length()-p); |
204 | return rv; | 232 | return rv; |
205 | } | 233 | } |
206 | rv.append(str,p,us-p); | 234 | rv.append(str,p,us-p); |
207 | rv += "&#"; | 235 | rv += "&#"; |
208 | rv += long_to_string((long)str[us]); | 236 | rv += long_to_string((long)str[us]); |
209 | rv += ';'; | 237 | rv += ';'; |
210 | p = us+1; | 238 | p = us+1; |
211 | } | 239 | } |
212 | } | 240 | } |
213 | 241 | ||
214 | string long_to_string(long l) { | 242 | string long_to_string(long l) { |
215 | char rv[32]; | 243 | char rv[32]; |
216 | int r=snprintf(rv,sizeof(rv),"%ld",l); | 244 | int r=snprintf(rv,sizeof(rv),"%ld",l); |
217 | if(r<0 || r>=(int)sizeof(rv)) | 245 | if(r<0 || r>=(int)sizeof(rv)) |
218 | throw failed_conversion(OPKELE_CP_ "failed to snprintf()"); | 246 | throw failed_conversion(OPKELE_CP_ "failed to snprintf()"); |
219 | return rv; | 247 | return rv; |
220 | } | 248 | } |
221 | 249 | ||
222 | long string_to_long(const string& s) { | 250 | long string_to_long(const string& s) { |
223 | char *endptr = 0; | 251 | char *endptr = 0; |
224 | long rv = strtol(s.c_str(),&endptr,10); | 252 | long rv = strtol(s.c_str(),&endptr,10); |
225 | if((!endptr) || endptr==s.c_str()) | 253 | if((!endptr) || endptr==s.c_str()) |
226 | throw failed_conversion(OPKELE_CP_ "failed to strtol()"); | 254 | throw failed_conversion(OPKELE_CP_ "failed to strtol()"); |
227 | return rv; | 255 | return rv; |
228 | } | 256 | } |
229 | 257 | ||
230 | /* | 258 | /* |
231 | * Normalize URL according to the rules, described in rfc 3986, section 6 | 259 | * Normalize URL according to the rules, described in rfc 3986, section 6 |
232 | * | 260 | * |
233 | * - uppercase hex triplets (e.g. %ab -> %AB) | 261 | * - uppercase hex triplets (e.g. %ab -> %AB) |
234 | * - lowercase scheme and host | 262 | * - lowercase scheme and host |
235 | * - decode %-encoded characters, specified as unreserved in rfc 3986, section 2.3, | 263 | * - decode %-encoded characters, specified as unreserved in rfc 3986, section 2.3, |
236 | * that is - [:alpha:][:digit:]._~- | 264 | * that is - [:alpha:][:digit:]._~- |
237 | * - remove dot segments | 265 | * - remove dot segments |
238 | * - remove empty and default ports | 266 | * - remove empty and default ports |
239 | * - if there's no path component, add '/' | 267 | * - if there's no path component, add '/' |
240 | */ | 268 | */ |
241 | string rfc_3986_normalize_uri(const string& uri) { | 269 | string rfc_3986_normalize_uri(const string& uri) { |
242 | string rv; | 270 | string rv; |
243 | string::size_type ns = uri.find_first_not_of(data::_whitespace_chars); | 271 | string::size_type ns = uri.find_first_not_of(data::_whitespace_chars); |
244 | if(ns==string::npos) | 272 | if(ns==string::npos) |
245 | throw bad_input(OPKELE_CP_ "Can't normalize empty URI"); | 273 | throw bad_input(OPKELE_CP_ "Can't normalize empty URI"); |
246 | string::size_type colon = uri.find(':',ns); | 274 | string::size_type colon = uri.find(':',ns); |
247 | if(colon==string::npos) | 275 | if(colon==string::npos) |
248 | throw bad_input(OPKELE_CP_ "No scheme specified in URI"); | 276 | throw bad_input(OPKELE_CP_ "No scheme specified in URI"); |
249 | transform( | 277 | transform( |
250 | uri.begin()+ns, uri.begin()+colon+1, | 278 | uri.begin()+ns, uri.begin()+colon+1, |
251 | back_inserter(rv), ::tolower ); | 279 | back_inserter(rv), ::tolower ); |
252 | bool s; | 280 | bool s; |
253 | string::size_type ul = uri.find_last_not_of(data::_whitespace_chars)+1; | 281 | string::size_type ul = uri.find_last_not_of(data::_whitespace_chars)+1; |
254 | if(ul <= (colon+3)) | 282 | if(ul <= (colon+3)) |
255 | throw bad_input(OPKELE_CP_ "Unexpected end of URI being normalized encountered"); | 283 | throw bad_input(OPKELE_CP_ "Unexpected end of URI being normalized encountered"); |
256 | if(uri[colon+1]!='/' || uri[colon+2]!='/') | 284 | if(uri[colon+1]!='/' || uri[colon+2]!='/') |
257 | throw bad_input(OPKELE_CP_ "Unexpected input in URI being normalized after scheme component"); | 285 | throw bad_input(OPKELE_CP_ "Unexpected input in URI being normalized after scheme component"); |
258 | if(rv=="http:") | 286 | if(rv=="http:") |
259 | s = false; | 287 | s = false; |
260 | else if(rv=="https:") | 288 | else if(rv=="https:") |
261 | s = true; | 289 | s = true; |
262 | else{ | 290 | else{ |
263 | /* TODO: support more schemes. e.g. xri. How do we normalize | 291 | /* TODO: support more schemes. e.g. xri. How do we normalize |
264 | * xri? | 292 | * xri? |
265 | */ | 293 | */ |
266 | rv.append(uri,colon+1,ul-colon-1); | 294 | rv.append(uri,colon+1,ul-colon-1); |
267 | return rv; | 295 | return rv; |
268 | } | 296 | } |
269 | rv += "//"; | 297 | rv += "//"; |
270 | string::size_type interesting = uri.find_first_of(":/#?",colon+3); | 298 | string::size_type interesting = uri.find_first_of(":/#?",colon+3); |
271 | if(interesting==string::npos) { | 299 | if(interesting==string::npos) { |
272 | transform( | 300 | transform( |
273 | uri.begin()+colon+3,uri.begin()+ul, | 301 | uri.begin()+colon+3,uri.begin()+ul, |
274 | back_inserter(rv), ::tolower ); | 302 | back_inserter(rv), ::tolower ); |
275 | rv += '/'; return rv; | 303 | rv += '/'; return rv; |
276 | } | 304 | } |
277 | transform( | 305 | transform( |
278 | uri.begin()+colon+3,uri.begin()+interesting, | 306 | uri.begin()+colon+3,uri.begin()+interesting, |
279 | back_inserter(rv), ::tolower ); | 307 | back_inserter(rv), ::tolower ); |
280 | bool qf = false; | 308 | bool qf = false; |
281 | char ic = uri[interesting]; | 309 | char ic = uri[interesting]; |
282 | if(ic==':') { | 310 | if(ic==':') { |
283 | string::size_type ni = uri.find_first_of("/#?%",interesting+1); | 311 | string::size_type ni = uri.find_first_of("/#?%",interesting+1); |
284 | const char *nptr = uri.data()+interesting+1; | 312 | const char *nptr = uri.data()+interesting+1; |
285 | char *eptr = 0; | 313 | char *eptr = 0; |
286 | long port = strtol(nptr,&eptr,10); | 314 | long port = strtol(nptr,&eptr,10); |
287 | if( (port>0) && (port<65535) && port!=(s?443:80) ) { | 315 | if( (port>0) && (port<65535) && port!=(s?443:80) ) { |
288 | char tmp[8]; | 316 | char tmp[8]; |
289 | snprintf(tmp,sizeof(tmp),":%ld",port); | 317 | snprintf(tmp,sizeof(tmp),":%ld",port); |
290 | rv += tmp; | 318 | rv += tmp; |
291 | } | 319 | } |
292 | if(ni==string::npos) { | 320 | if(ni==string::npos) { |
293 | rv += '/'; return rv; | 321 | rv += '/'; return rv; |
294 | } | 322 | } |
295 | interesting = ni; | 323 | interesting = ni; |
296 | }else if(ic!='/') { | 324 | }else if(ic!='/') { |
297 | rv += '/'; rv += ic; | 325 | rv += '/'; rv += ic; |
298 | qf = true; | 326 | qf = true; |
299 | ++interesting; | 327 | ++interesting; |
300 | } | 328 | } |
301 | string::size_type n = interesting; | 329 | string::size_type n = interesting; |
302 | char tmp[3] = { 0,0,0 }; | 330 | char tmp[3] = { 0,0,0 }; |
303 | stack<string::size_type> psegs; psegs.push(rv.length()); | 331 | stack<string::size_type> psegs; psegs.push(rv.length()); |
304 | string pseg; | 332 | string pseg; |
305 | for(;n<ul;) { | 333 | for(;n<ul;) { |
306 | string::size_type unsafe = uri.find_first_of(qf?"%":"%/?#",n); | 334 | string::size_type unsafe = uri.find_first_of(qf?"%":"%/?#",n); |
307 | if(unsafe==string::npos) { | 335 | if(unsafe==string::npos) { |
308 | pseg.append(uri,n,ul-n-1); n = ul-1; | 336 | pseg.append(uri,n,ul-n-1); n = ul-1; |
309 | }else{ | 337 | }else{ |
310 | pseg.append(uri,n,unsafe-n); | 338 | pseg.append(uri,n,unsafe-n); |
311 | n = unsafe; | 339 | n = unsafe; |
312 | } | 340 | } |
313 | char c = uri[n++]; | 341 | char c = uri[n++]; |
314 | if(c=='%') { | 342 | if(c=='%') { |
315 | if((n+1)>=ul) | 343 | if((n+1)>=ul) |
316 | throw bad_input(OPKELE_CP_ "Unexpected end of URI encountered while parsing percent-encoded character"); | 344 | throw bad_input(OPKELE_CP_ "Unexpected end of URI encountered while parsing percent-encoded character"); |
317 | tmp[0] = uri[n++]; | 345 | tmp[0] = uri[n++]; |
318 | tmp[1] = uri[n++]; | 346 | tmp[1] = uri[n++]; |
319 | if(!( isxdigit(tmp[0]) && isxdigit(tmp[1]) )) | 347 | if(!( isxdigit(tmp[0]) && isxdigit(tmp[1]) )) |
320 | throw bad_input(OPKELE_CP_ "Invalid percent-encoded character in URI being normalized"); | 348 | throw bad_input(OPKELE_CP_ "Invalid percent-encoded character in URI being normalized"); |
321 | int cc = strtol(tmp,0,16); | 349 | int cc = strtol(tmp,0,16); |
322 | if( isalpha(cc) || isdigit(cc) || strchr("._~-",cc) ) | 350 | if( isalpha(cc) || isdigit(cc) || strchr("._~-",cc) ) |
323 | pseg += cc; | 351 | pseg += cc; |
324 | else{ | 352 | else{ |
325 | pseg += '%'; | 353 | pseg += '%'; |
326 | pseg += toupper(tmp[0]); pseg += toupper(tmp[1]); | 354 | pseg += toupper(tmp[0]); pseg += toupper(tmp[1]); |
327 | } | 355 | } |
328 | }else if(qf) { | 356 | }else if(qf) { |
329 | rv += pseg; rv += c; | 357 | rv += pseg; rv += c; |
330 | pseg.clear(); | 358 | pseg.clear(); |
331 | }else if(n>=ul || strchr("?/#",c)) { | 359 | }else if(n>=ul || strchr("?/#",c)) { |
332 | if(pseg.empty() || pseg==".") { | 360 | if(pseg.empty() || pseg==".") { |
333 | }else if(pseg=="..") { | 361 | }else if(pseg=="..") { |
334 | if(psegs.size()>1) { | 362 | if(psegs.size()>1) { |
335 | rv.resize(psegs.top()); psegs.pop(); | 363 | rv.resize(psegs.top()); psegs.pop(); |
336 | } | 364 | } |
337 | }else{ | 365 | }else{ |
338 | psegs.push(rv.length()); | 366 | psegs.push(rv.length()); |
339 | if(c!='/') { | 367 | if(c!='/') { |
340 | pseg += c; | 368 | pseg += c; |
341 | qf = true; | 369 | qf = true; |
342 | } | 370 | } |
343 | rv += '/'; rv += pseg; | 371 | rv += '/'; rv += pseg; |
344 | } | 372 | } |
345 | if(c=='/' && (n>=ul || strchr("?#",uri[n])) ) { | 373 | if(c=='/' && (n>=ul || strchr("?#",uri[n])) ) { |
346 | rv += '/'; | 374 | rv += '/'; |
347 | if(n<ul) | 375 | if(n<ul) |
348 | qf = true; | 376 | qf = true; |
349 | }else if(strchr("?#",c)) { | 377 | }else if(strchr("?#",c)) { |
350 | if(psegs.size()==1 && psegs.top()==rv.length()) | 378 | if(psegs.size()==1 && psegs.top()==rv.length()) |
351 | rv += '/'; | 379 | rv += '/'; |
352 | if(pseg.empty()) | 380 | if(pseg.empty()) |
353 | rv += c; | 381 | rv += c; |
354 | qf = true; | 382 | qf = true; |
355 | } | 383 | } |
356 | pseg.clear(); | 384 | pseg.clear(); |
357 | }else{ | 385 | }else{ |
358 | pseg += c; | 386 | pseg += c; |
359 | } | 387 | } |
360 | } | 388 | } |
361 | if(!pseg.empty()) { | 389 | if(!pseg.empty()) { |
362 | if(!qf) rv += '/'; | 390 | if(!qf) rv += '/'; |
363 | rv += pseg; | 391 | rv += pseg; |
364 | } | 392 | } |
365 | return rv; | 393 | return rv; |
366 | } | 394 | } |
367 | 395 | ||
368 | string& strip_uri_fragment_part(string& u) { | 396 | string& strip_uri_fragment_part(string& u) { |
369 | string::size_type q = u.find('?'), f = u.find('#'); | 397 | string::size_type q = u.find('?'), f = u.find('#'); |
370 | if(q==string::npos) { | 398 | if(q==string::npos) { |
371 | if(f!=string::npos) | 399 | if(f!=string::npos) |
372 | u.erase(f); | 400 | u.erase(f); |
373 | }else{ | 401 | }else{ |
374 | if(f!=string::npos) { | 402 | if(f!=string::npos) { |
375 | if(f<q) | 403 | if(f<q) |
376 | u.erase(f,q-f); | 404 | u.erase(f,q-f); |
377 | else | 405 | else |
378 | u.erase(f); | 406 | u.erase(f); |
379 | } | 407 | } |
380 | } | 408 | } |
381 | return u; | 409 | return u; |
382 | } | 410 | } |
383 | 411 | ||
384 | bool uri_matches_realm(const string& uri,const string& realm) { | 412 | bool uri_matches_realm(const string& uri,const string& realm) { |
385 | string nrealm = opkele::util::rfc_3986_normalize_uri(realm); | 413 | string nrealm = opkele::util::rfc_3986_normalize_uri(realm); |
386 | string nu = opkele::util::rfc_3986_normalize_uri(uri); | 414 | string nu = opkele::util::rfc_3986_normalize_uri(uri); |