]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: url.cpp | |
3 | // Purpose: URL parser | |
4 | // Author: Guilhem Lavaux | |
5 | // Modified by: | |
6 | // Created: 20/07/1997 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1997, 1998 Guilhem Lavaux | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // For compilers that support precompilation, includes "wx.h". | |
13 | #include "wx/wxprec.h" | |
14 | ||
15 | #ifdef __BORLANDC__ | |
16 | #pragma hdrstop | |
17 | #endif | |
18 | ||
19 | #if wxUSE_URL | |
20 | ||
21 | #include "wx/string.h" | |
22 | #include "wx/list.h" | |
23 | #include "wx/utils.h" | |
24 | #include "wx/module.h" | |
25 | #include "wx/url.h" | |
26 | ||
27 | #include <string.h> | |
28 | #include <ctype.h> | |
29 | ||
30 | IMPLEMENT_CLASS(wxProtoInfo, wxObject) | |
31 | IMPLEMENT_CLASS(wxURL, wxURI) | |
32 | ||
33 | // Protocols list | |
34 | wxProtoInfo *wxURL::ms_protocols = NULL; | |
35 | ||
36 | // Enforce linking of protocol classes: | |
37 | USE_PROTOCOL(wxFileProto) | |
38 | ||
39 | #if wxUSE_PROTOCOL_HTTP | |
40 | USE_PROTOCOL(wxHTTP) | |
41 | ||
42 | wxHTTP *wxURL::ms_proxyDefault = NULL; | |
43 | bool wxURL::ms_useDefaultProxy = false; | |
44 | #endif | |
45 | ||
46 | #if wxUSE_PROTOCOL_FTP | |
47 | USE_PROTOCOL(wxFTP) | |
48 | #endif | |
49 | ||
50 | // -------------------------------------------------------------- | |
51 | // | |
52 | // wxURL | |
53 | // | |
54 | // -------------------------------------------------------------- | |
55 | ||
56 | // -------------------------------------------------------------- | |
57 | // Construction | |
58 | // -------------------------------------------------------------- | |
59 | ||
60 | wxURL::wxURL(const wxString& url) : wxURI(url) | |
61 | { | |
62 | Init(url); | |
63 | ParseURL(); | |
64 | } | |
65 | ||
66 | wxURL::wxURL(const wxURI& url) : wxURI(url) | |
67 | { | |
68 | Init(url.BuildURI()); | |
69 | ParseURL(); | |
70 | } | |
71 | ||
72 | void wxURL::Init(const wxString& url) | |
73 | { | |
74 | m_protocol = NULL; | |
75 | m_error = wxURL_NOERR; | |
76 | m_url = url; | |
77 | #if wxUSE_URL_NATIVE | |
78 | m_nativeImp = CreateNativeImpObject(); | |
79 | #endif | |
80 | ||
81 | #if wxUSE_PROTOCOL_HTTP | |
82 | if ( ms_useDefaultProxy && !ms_proxyDefault ) | |
83 | { | |
84 | SetDefaultProxy( wxGetenv(wxT("HTTP_PROXY")) ); | |
85 | ||
86 | if ( !ms_proxyDefault ) | |
87 | { | |
88 | // don't try again | |
89 | ms_useDefaultProxy = false; | |
90 | } | |
91 | } | |
92 | ||
93 | m_useProxy = ms_proxyDefault != NULL; | |
94 | m_proxy = ms_proxyDefault; | |
95 | #endif // wxUSE_PROTOCOL_HTTP | |
96 | ||
97 | } | |
98 | ||
99 | // -------------------------------------------------------------- | |
100 | // Assignment | |
101 | // -------------------------------------------------------------- | |
102 | ||
103 | wxURL& wxURL::operator = (const wxURI& url) | |
104 | { | |
105 | wxURI::operator = (url); | |
106 | Init(url.BuildURI()); | |
107 | ParseURL(); | |
108 | return *this; | |
109 | } | |
110 | wxURL& wxURL::operator = (const wxString& url) | |
111 | { | |
112 | wxURI::operator = (url); | |
113 | Init(url); | |
114 | ParseURL(); | |
115 | return *this; | |
116 | } | |
117 | ||
118 | // -------------------------------------------------------------- | |
119 | // ParseURL | |
120 | // | |
121 | // Builds the URL and takes care of the old protocol stuff | |
122 | // -------------------------------------------------------------- | |
123 | ||
124 | bool wxURL::ParseURL() | |
125 | { | |
126 | // If the URL was already parsed (m_protocol != NULL), pass this section. | |
127 | if (!m_protocol) | |
128 | { | |
129 | // Clean up | |
130 | CleanData(); | |
131 | ||
132 | // Make sure we have a protocol/scheme | |
133 | if (!HasScheme()) | |
134 | { | |
135 | m_error = wxURL_SNTXERR; | |
136 | return false; | |
137 | } | |
138 | ||
139 | // Find and create the protocol object | |
140 | if (!FetchProtocol()) | |
141 | { | |
142 | m_error = wxURL_NOPROTO; | |
143 | return false; | |
144 | } | |
145 | ||
146 | // Do we need a host name ? | |
147 | if (m_protoinfo->m_needhost) | |
148 | { | |
149 | // Make sure we have one, then | |
150 | if (!HasServer()) | |
151 | { | |
152 | m_error = wxURL_SNTXERR; | |
153 | return false; | |
154 | } | |
155 | } | |
156 | } | |
157 | ||
158 | #if wxUSE_PROTOCOL_HTTP | |
159 | if (m_useProxy) | |
160 | { | |
161 | // Third, we rebuild the URL. | |
162 | m_url = m_scheme + wxT(":"); | |
163 | if (m_protoinfo->m_needhost) | |
164 | m_url = m_url + wxT("//") + m_server; | |
165 | ||
166 | // We initialize specific variables. | |
167 | m_protocol = m_proxy; // FIXME: we should clone the protocol | |
168 | } | |
169 | #endif // wxUSE_PROTOCOL_HTTP | |
170 | ||
171 | m_error = wxURL_NOERR; | |
172 | return true; | |
173 | } | |
174 | ||
175 | // -------------------------------------------------------------- | |
176 | // Destruction/Cleanup | |
177 | // -------------------------------------------------------------- | |
178 | ||
179 | void wxURL::CleanData() | |
180 | { | |
181 | #if wxUSE_PROTOCOL_HTTP | |
182 | if (!m_useProxy) | |
183 | #endif // wxUSE_PROTOCOL_HTTP | |
184 | delete m_protocol; | |
185 | } | |
186 | ||
187 | wxURL::~wxURL() | |
188 | { | |
189 | CleanData(); | |
190 | #if wxUSE_PROTOCOL_HTTP | |
191 | if (m_proxy && m_proxy != ms_proxyDefault) | |
192 | delete m_proxy; | |
193 | #endif // wxUSE_PROTOCOL_HTTP | |
194 | #if wxUSE_URL_NATIVE | |
195 | delete m_nativeImp; | |
196 | #endif | |
197 | } | |
198 | ||
199 | // -------------------------------------------------------------- | |
200 | // FetchProtocol | |
201 | // -------------------------------------------------------------- | |
202 | ||
203 | bool wxURL::FetchProtocol() | |
204 | { | |
205 | wxProtoInfo *info = ms_protocols; | |
206 | ||
207 | while (info) | |
208 | { | |
209 | if (m_scheme == info->m_protoname) | |
210 | { | |
211 | if (m_port.IsNull()) | |
212 | m_port = info->m_servname; | |
213 | m_protoinfo = info; | |
214 | m_protocol = (wxProtocol *)m_protoinfo->m_cinfo->CreateObject(); | |
215 | return true; | |
216 | } | |
217 | info = info->next; | |
218 | } | |
219 | return false; | |
220 | } | |
221 | ||
222 | // -------------------------------------------------------------- | |
223 | // GetInputStream | |
224 | // -------------------------------------------------------------- | |
225 | ||
226 | wxInputStream *wxURL::GetInputStream() | |
227 | { | |
228 | if (!m_protocol) | |
229 | { | |
230 | m_error = wxURL_NOPROTO; | |
231 | return NULL; | |
232 | } | |
233 | ||
234 | m_error = wxURL_NOERR; | |
235 | if (HasUserInfo()) | |
236 | { | |
237 | size_t dwPasswordPos = m_userinfo.find(':'); | |
238 | ||
239 | if (dwPasswordPos == wxString::npos) | |
240 | m_protocol->SetUser(m_userinfo); | |
241 | else | |
242 | { | |
243 | m_protocol->SetUser(m_userinfo(0, dwPasswordPos)); | |
244 | m_protocol->SetPassword(m_userinfo(dwPasswordPos+1, m_userinfo.length() + 1)); | |
245 | } | |
246 | } | |
247 | ||
248 | #if wxUSE_URL_NATIVE | |
249 | // give the native implementation to return a better stream | |
250 | // such as the native WinINet functionality under MS-Windows | |
251 | if (m_nativeImp) | |
252 | { | |
253 | wxInputStream *rc; | |
254 | rc = m_nativeImp->GetInputStream(this); | |
255 | if (rc != 0) | |
256 | return rc; | |
257 | } | |
258 | // else use the standard behaviour | |
259 | #endif // wxUSE_URL_NATIVE | |
260 | ||
261 | #if wxUSE_SOCKETS | |
262 | wxIPV4address addr; | |
263 | ||
264 | // m_protoinfo is NULL when we use a proxy | |
265 | if (!m_useProxy && m_protoinfo->m_needhost) | |
266 | { | |
267 | if (!addr.Hostname(m_server)) | |
268 | { | |
269 | m_error = wxURL_NOHOST; | |
270 | return NULL; | |
271 | } | |
272 | ||
273 | addr.Service(m_port); | |
274 | ||
275 | if (!m_protocol->Connect(addr, true)) // Watcom needs the 2nd arg for some reason | |
276 | { | |
277 | m_error = wxURL_CONNERR; | |
278 | return NULL; | |
279 | } | |
280 | } | |
281 | #endif | |
282 | ||
283 | wxString fullPath; | |
284 | ||
285 | // When we use a proxy, we have to pass the whole URL to it. | |
286 | if (m_useProxy) | |
287 | fullPath += m_url; | |
288 | ||
289 | if(m_path.empty()) | |
290 | fullPath += wxT("/"); | |
291 | else | |
292 | fullPath += m_path; | |
293 | ||
294 | if (HasQuery()) | |
295 | fullPath += wxT("?") + m_query; | |
296 | ||
297 | if (HasFragment()) | |
298 | fullPath += wxT("#") + m_fragment; | |
299 | ||
300 | wxInputStream *the_i_stream = m_protocol->GetInputStream(fullPath); | |
301 | ||
302 | if (!the_i_stream) | |
303 | { | |
304 | m_error = wxURL_PROTOERR; | |
305 | return NULL; | |
306 | } | |
307 | ||
308 | return the_i_stream; | |
309 | } | |
310 | ||
311 | #if wxUSE_PROTOCOL_HTTP | |
312 | void wxURL::SetDefaultProxy(const wxString& url_proxy) | |
313 | { | |
314 | if ( !url_proxy ) | |
315 | { | |
316 | if ( ms_proxyDefault ) | |
317 | { | |
318 | ms_proxyDefault->Close(); | |
319 | delete ms_proxyDefault; | |
320 | ms_proxyDefault = NULL; | |
321 | } | |
322 | } | |
323 | else | |
324 | { | |
325 | wxString tmp_str = url_proxy; | |
326 | int pos = tmp_str.Find(wxT(':')); | |
327 | if (pos == wxNOT_FOUND) | |
328 | return; | |
329 | ||
330 | wxString hostname = tmp_str(0, pos), | |
331 | port = tmp_str(pos+1, tmp_str.Length()-pos); | |
332 | wxIPV4address addr; | |
333 | ||
334 | if (!addr.Hostname(hostname)) | |
335 | return; | |
336 | if (!addr.Service(port)) | |
337 | return; | |
338 | ||
339 | if (ms_proxyDefault) | |
340 | // Finally, when all is right, we connect the new proxy. | |
341 | ms_proxyDefault->Close(); | |
342 | else | |
343 | ms_proxyDefault = new wxHTTP(); | |
344 | ms_proxyDefault->Connect(addr, true); // Watcom needs the 2nd arg for some reason | |
345 | } | |
346 | } | |
347 | ||
348 | void wxURL::SetProxy(const wxString& url_proxy) | |
349 | { | |
350 | if ( !url_proxy ) | |
351 | { | |
352 | if ( m_proxy && m_proxy != ms_proxyDefault ) | |
353 | { | |
354 | m_proxy->Close(); | |
355 | delete m_proxy; | |
356 | } | |
357 | ||
358 | m_useProxy = false; | |
359 | } | |
360 | else | |
361 | { | |
362 | wxString tmp_str; | |
363 | wxString hostname, port; | |
364 | int pos; | |
365 | wxIPV4address addr; | |
366 | ||
367 | tmp_str = url_proxy; | |
368 | pos = tmp_str.Find(wxT(':')); | |
369 | // This is an invalid proxy name. | |
370 | if (pos == wxNOT_FOUND) | |
371 | return; | |
372 | ||
373 | hostname = tmp_str(0, pos); | |
374 | port = tmp_str(pos+1, tmp_str.Length()-pos); | |
375 | ||
376 | addr.Hostname(hostname); | |
377 | addr.Service(port); | |
378 | ||
379 | // Finally, create the whole stuff. | |
380 | if (m_proxy && m_proxy != ms_proxyDefault) | |
381 | delete m_proxy; | |
382 | m_proxy = new wxHTTP(); | |
383 | m_proxy->Connect(addr, true); // Watcom needs the 2nd arg for some reason | |
384 | ||
385 | CleanData(); | |
386 | // Reparse url. | |
387 | m_useProxy = true; | |
388 | ParseURL(); | |
389 | } | |
390 | } | |
391 | #endif // wxUSE_PROTOCOL_HTTP | |
392 | ||
393 | // ---------------------------------------------------------------------- | |
394 | // wxURLModule | |
395 | // | |
396 | // A module which deletes the default proxy if we created it | |
397 | // ---------------------------------------------------------------------- | |
398 | ||
399 | #if wxUSE_SOCKETS | |
400 | ||
401 | class wxURLModule : public wxModule | |
402 | { | |
403 | public: | |
404 | virtual bool OnInit(); | |
405 | virtual void OnExit(); | |
406 | ||
407 | private: | |
408 | DECLARE_DYNAMIC_CLASS(wxURLModule) | |
409 | }; | |
410 | ||
411 | IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule) | |
412 | ||
413 | bool wxURLModule::OnInit() | |
414 | { | |
415 | #if wxUSE_PROTOCOL_HTTP | |
416 | // env var HTTP_PROXY contains the address of the default proxy to use if | |
417 | // set, but don't try to create this proxy right now because it will slow | |
418 | // down the program startup (especially if there is no DNS server | |
419 | // available, in which case it may take up to 1 minute) | |
420 | ||
421 | if ( wxGetenv(_T("HTTP_PROXY")) ) | |
422 | { | |
423 | wxURL::ms_useDefaultProxy = true; | |
424 | } | |
425 | #endif // wxUSE_PROTOCOL_HTTP | |
426 | return true; | |
427 | } | |
428 | ||
429 | void wxURLModule::OnExit() | |
430 | { | |
431 | #if wxUSE_PROTOCOL_HTTP | |
432 | delete wxURL::ms_proxyDefault; | |
433 | wxURL::ms_proxyDefault = NULL; | |
434 | #endif // wxUSE_PROTOCOL_HTTP | |
435 | } | |
436 | ||
437 | #endif // wxUSE_SOCKETS | |
438 | ||
439 | // --------------------------------------------------------------------------- | |
440 | // | |
441 | // wxURL Compatibility | |
442 | // | |
443 | // --------------------------------------------------------------------------- | |
444 | ||
445 | #if WXWIN_COMPATIBILITY_2_4 | |
446 | ||
447 | #include "wx/url.h" | |
448 | ||
449 | wxString wxURL::GetProtocolName() const | |
450 | { | |
451 | return m_scheme; | |
452 | } | |
453 | ||
454 | wxString wxURL::GetHostName() const | |
455 | { | |
456 | return m_server; | |
457 | } | |
458 | ||
459 | wxString wxURL::GetPath() const | |
460 | { | |
461 | return m_path; | |
462 | } | |
463 | ||
464 | //Note that this old code really doesn't convert to a URI that well and looks | |
465 | //more like a dirty hack than anything else... | |
466 | ||
467 | wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* delims) | |
468 | { | |
469 | wxString out_str; | |
470 | wxString hexa_code; | |
471 | size_t i; | |
472 | ||
473 | for (i = 0; i < uri.Len(); i++) | |
474 | { | |
475 | wxChar c = uri.GetChar(i); | |
476 | ||
477 | if (c == wxT(' ')) | |
478 | { | |
479 | // GRG, Apr/2000: changed to "%20" instead of '+' | |
480 | ||
481 | out_str += wxT("%20"); | |
482 | } | |
483 | else | |
484 | { | |
485 | // GRG, Apr/2000: modified according to the URI definition (RFC 2396) | |
486 | // | |
487 | // - Alphanumeric characters are never escaped | |
488 | // - Unreserved marks are never escaped | |
489 | // - Delimiters must be escaped if they appear within a component | |
490 | // but not if they are used to separate components. Here we have | |
491 | // no clear way to distinguish between these two cases, so they | |
492 | // are escaped unless they are passed in the 'delims' parameter | |
493 | // (allowed delimiters). | |
494 | ||
495 | static const wxChar marks[] = wxT("-_.!~*()'"); | |
496 | ||
497 | if ( !wxIsalnum(c) && !wxStrchr(marks, c) && !wxStrchr(delims, c) ) | |
498 | { | |
499 | hexa_code.Printf(wxT("%%%02X"), c); | |
500 | out_str += hexa_code; | |
501 | } | |
502 | else | |
503 | { | |
504 | out_str += c; | |
505 | } | |
506 | } | |
507 | } | |
508 | ||
509 | return out_str; | |
510 | } | |
511 | ||
512 | wxString wxURL::ConvertFromURI(const wxString& uri) | |
513 | { | |
514 | return wxURI::Unescape(uri); | |
515 | } | |
516 | ||
517 | #endif //WXWIN_COMPATIBILITY_2_4 | |
518 | ||
519 | #endif // wxUSE_URL |