]> git.saurik.com Git - wxWidgets.git/blob - src/common/url.cpp
Don't use "Cancel" button in the about dialog of the listctrl sample.
[wxWidgets.git] / src / common / url.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/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/url.h"
22
23 #ifndef WX_PRECOMP
24 #include "wx/list.h"
25 #include "wx/string.h"
26 #include "wx/utils.h"
27 #include "wx/module.h"
28 #endif
29
30 #include <string.h>
31 #include <ctype.h>
32
33 IMPLEMENT_CLASS(wxURL, wxURI)
34
35 // Protocols list
36 wxProtoInfo *wxURL::ms_protocols = NULL;
37
38 // Enforce linking of protocol classes:
39 USE_PROTOCOL(wxFileProto)
40
41 #if wxUSE_PROTOCOL_HTTP
42 USE_PROTOCOL(wxHTTP)
43
44 wxHTTP *wxURL::ms_proxyDefault = NULL;
45 bool wxURL::ms_useDefaultProxy = false;
46 #endif
47
48 #if wxUSE_PROTOCOL_FTP
49 USE_PROTOCOL(wxFTP)
50 #endif
51
52 // --------------------------------------------------------------
53 //
54 // wxURL
55 //
56 // --------------------------------------------------------------
57
58 // --------------------------------------------------------------
59 // Construction
60 // --------------------------------------------------------------
61
62 wxURL::wxURL(const wxString& url) : wxURI(url)
63 {
64 Init(url);
65 ParseURL();
66 }
67
68 wxURL::wxURL(const wxURI& uri) : wxURI(uri)
69 {
70 Init(uri.BuildURI());
71 ParseURL();
72 }
73
74 wxURL::wxURL(const wxURL& url) : wxURI(url)
75 {
76 Init(url.GetURL());
77 ParseURL();
78 }
79
80 void wxURL::Init(const wxString& url)
81 {
82 m_protocol = NULL;
83 m_error = wxURL_NOERR;
84 m_url = url;
85 #if wxUSE_URL_NATIVE
86 m_nativeImp = CreateNativeImpObject();
87 #endif
88
89 #if wxUSE_PROTOCOL_HTTP
90 if ( ms_useDefaultProxy && !ms_proxyDefault )
91 {
92 SetDefaultProxy( wxGetenv(wxT("HTTP_PROXY")) );
93
94 if ( !ms_proxyDefault )
95 {
96 // don't try again
97 ms_useDefaultProxy = false;
98 }
99 }
100
101 m_useProxy = ms_proxyDefault != NULL;
102 m_proxy = ms_proxyDefault;
103 #endif // wxUSE_PROTOCOL_HTTP
104
105 }
106
107 // --------------------------------------------------------------
108 // Assignment
109 // --------------------------------------------------------------
110
111 wxURL& wxURL::operator = (const wxString& url)
112 {
113 wxURI::operator = (url);
114 Free();
115 Init(url);
116 ParseURL();
117
118 return *this;
119 }
120
121 wxURL& wxURL::operator = (const wxURI& uri)
122 {
123 if (&uri != this)
124 {
125 wxURI::operator = (uri);
126 Free();
127 Init(uri.BuildURI());
128 ParseURL();
129 }
130
131 return *this;
132 }
133
134 wxURL& wxURL::operator = (const wxURL& url)
135 {
136 if (&url != this)
137 {
138 wxURI::operator = (url);
139 Free();
140 Init(url.GetURL());
141 ParseURL();
142 }
143
144 return *this;
145 }
146
147 // --------------------------------------------------------------
148 // ParseURL
149 //
150 // Builds the URL and takes care of the old protocol stuff
151 // --------------------------------------------------------------
152
153 bool wxURL::ParseURL()
154 {
155 // If the URL was already parsed (m_protocol != NULL), pass this section.
156 if (!m_protocol)
157 {
158 // Clean up
159 CleanData();
160
161 // Make sure we have a protocol/scheme
162 if (!HasScheme())
163 {
164 m_error = wxURL_SNTXERR;
165 return false;
166 }
167
168 // Find and create the protocol object
169 if (!FetchProtocol())
170 {
171 m_error = wxURL_NOPROTO;
172 return false;
173 }
174
175 // Do we need a host name ?
176 if (m_protoinfo->m_needhost)
177 {
178 // Make sure we have one, then
179 if (!HasServer())
180 {
181 m_error = wxURL_SNTXERR;
182 return false;
183 }
184 }
185 }
186
187 #if wxUSE_PROTOCOL_HTTP
188 if (m_useProxy)
189 {
190 // Third, we rebuild the URL.
191 m_url = m_scheme + wxT(":");
192 if (m_protoinfo->m_needhost)
193 m_url = m_url + wxT("//") + m_server;
194
195 // We initialize specific variables.
196 if (m_protocol)
197 m_protocol->Destroy();
198 m_protocol = m_proxy; // FIXME: we should clone the protocol
199 }
200 #endif // wxUSE_PROTOCOL_HTTP
201
202 m_error = wxURL_NOERR;
203 return true;
204 }
205
206 // --------------------------------------------------------------
207 // Destruction/Cleanup
208 // --------------------------------------------------------------
209
210 void wxURL::CleanData()
211 {
212 #if wxUSE_PROTOCOL_HTTP
213 if (!m_useProxy)
214 #endif // wxUSE_PROTOCOL_HTTP
215 {
216 if (m_protocol)
217 {
218 // Need to safely delete the socket (pending events)
219 m_protocol->Destroy();
220 m_protocol = NULL;
221 }
222 }
223 }
224
225 void wxURL::Free()
226 {
227 CleanData();
228 #if wxUSE_PROTOCOL_HTTP
229 if (m_proxy && m_proxy != ms_proxyDefault)
230 delete m_proxy;
231 #endif // wxUSE_PROTOCOL_HTTP
232 #if wxUSE_URL_NATIVE
233 delete m_nativeImp;
234 #endif
235 }
236
237 wxURL::~wxURL()
238 {
239 Free();
240 }
241
242 // --------------------------------------------------------------
243 // FetchProtocol
244 // --------------------------------------------------------------
245
246 bool wxURL::FetchProtocol()
247 {
248 wxProtoInfo *info = ms_protocols;
249
250 while (info)
251 {
252 if (m_scheme == info->m_protoname)
253 {
254 if ( m_port.empty() )
255 m_port = info->m_servname;
256 m_protoinfo = info;
257 m_protocol = (wxProtocol *)m_protoinfo->m_cinfo->CreateObject();
258 return true;
259 }
260 info = info->next;
261 }
262 return false;
263 }
264
265 // --------------------------------------------------------------
266 // GetInputStream
267 // --------------------------------------------------------------
268
269 wxInputStream *wxURL::GetInputStream()
270 {
271 if (!m_protocol)
272 {
273 m_error = wxURL_NOPROTO;
274 return NULL;
275 }
276
277 m_error = wxURL_NOERR;
278 if (HasUserInfo())
279 {
280 size_t dwPasswordPos = m_userinfo.find(':');
281
282 if (dwPasswordPos == wxString::npos)
283 m_protocol->SetUser(Unescape(m_userinfo));
284 else
285 {
286 m_protocol->SetUser(Unescape(m_userinfo(0, dwPasswordPos)));
287 m_protocol->SetPassword(Unescape(m_userinfo(dwPasswordPos+1, m_userinfo.length() + 1)));
288 }
289 }
290
291 #if wxUSE_URL_NATIVE
292 // give the native implementation to return a better stream
293 // such as the native WinINet functionality under MS-Windows
294 if (m_nativeImp)
295 {
296 wxInputStream *rc;
297 rc = m_nativeImp->GetInputStream(this);
298 if (rc != 0)
299 return rc;
300 }
301 // else use the standard behaviour
302 #endif // wxUSE_URL_NATIVE
303
304 #if wxUSE_SOCKETS
305 wxIPV4address addr;
306
307 // m_protoinfo is NULL when we use a proxy
308 if (
309 #if wxUSE_PROTOCOL_HTTP
310 !m_useProxy &&
311 #endif // wxUSE_PROTOCOL_HTTP
312 m_protoinfo->m_needhost )
313 {
314 if (!addr.Hostname(m_server))
315 {
316 m_error = wxURL_NOHOST;
317 return NULL;
318 }
319
320 addr.Service(m_port);
321
322 if (!m_protocol->Connect(addr, true)) // Watcom needs the 2nd arg for some reason
323 {
324 m_error = wxURL_CONNERR;
325 return NULL;
326 }
327 }
328 #endif // wxUSE_SOCKETS
329
330 wxString fullPath;
331
332 #if wxUSE_PROTOCOL_HTTP
333 // When we use a proxy, we have to pass the whole URL to it.
334 if (m_useProxy)
335 fullPath += m_url;
336 #endif // wxUSE_PROTOCOL_HTTP
337
338 if(m_path.empty())
339 fullPath += wxT("/");
340 else
341 fullPath += m_path;
342
343 if (HasQuery())
344 fullPath += wxT("?") + m_query;
345
346 if (HasFragment())
347 fullPath += wxT("#") + m_fragment;
348
349 wxInputStream *the_i_stream = m_protocol->GetInputStream(fullPath);
350
351 if (!the_i_stream)
352 {
353 m_error = wxURL_PROTOERR;
354 return NULL;
355 }
356
357 return the_i_stream;
358 }
359
360 #if wxUSE_PROTOCOL_HTTP
361 void wxURL::SetDefaultProxy(const wxString& url_proxy)
362 {
363 if ( !url_proxy )
364 {
365 if ( ms_proxyDefault )
366 {
367 ms_proxyDefault->Close();
368 wxDELETE(ms_proxyDefault);
369 }
370 }
371 else
372 {
373 wxString tmp_str = url_proxy;
374 int pos = tmp_str.Find(wxT(':'));
375 if (pos == wxNOT_FOUND)
376 return;
377
378 wxString hostname = tmp_str(0, pos),
379 port = tmp_str(pos+1, tmp_str.length()-pos);
380 wxIPV4address addr;
381
382 if (!addr.Hostname(hostname))
383 return;
384 if (!addr.Service(port))
385 return;
386
387 if (ms_proxyDefault)
388 // Finally, when all is right, we connect the new proxy.
389 ms_proxyDefault->Close();
390 else
391 ms_proxyDefault = new wxHTTP();
392 ms_proxyDefault->Connect(addr, true); // Watcom needs the 2nd arg for some reason
393 }
394 }
395
396 void wxURL::SetProxy(const wxString& url_proxy)
397 {
398 if ( !url_proxy )
399 {
400 if ( m_proxy && m_proxy != ms_proxyDefault )
401 {
402 m_proxy->Close();
403 delete m_proxy;
404 }
405
406 m_useProxy = false;
407 }
408 else
409 {
410 wxString tmp_str;
411 wxString hostname, port;
412 int pos;
413 wxIPV4address addr;
414
415 tmp_str = url_proxy;
416 pos = tmp_str.Find(wxT(':'));
417 // This is an invalid proxy name.
418 if (pos == wxNOT_FOUND)
419 return;
420
421 hostname = tmp_str(0, pos);
422 port = tmp_str(pos+1, tmp_str.length()-pos);
423
424 addr.Hostname(hostname);
425 addr.Service(port);
426
427 // Finally, create the whole stuff.
428 if (m_proxy && m_proxy != ms_proxyDefault)
429 delete m_proxy;
430 m_proxy = new wxHTTP();
431 m_proxy->Connect(addr, true); // Watcom needs the 2nd arg for some reason
432
433 CleanData();
434 // Reparse url.
435 m_useProxy = true;
436 ParseURL();
437 }
438 }
439 #endif // wxUSE_PROTOCOL_HTTP
440
441 // ----------------------------------------------------------------------
442 // wxURLModule
443 //
444 // A module which deletes the default proxy if we created it
445 // ----------------------------------------------------------------------
446
447 #if wxUSE_SOCKETS
448
449 class wxURLModule : public wxModule
450 {
451 public:
452 wxURLModule();
453
454 virtual bool OnInit();
455 virtual void OnExit();
456
457 private:
458 DECLARE_DYNAMIC_CLASS(wxURLModule)
459 };
460
461 IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule)
462
463 wxURLModule::wxURLModule()
464 {
465 // we must be cleaned up before wxSocketModule as otherwise deleting
466 // ms_proxyDefault from our OnExit() won't work (and can actually crash)
467 AddDependency(wxClassInfo::FindClass(wxT("wxSocketModule")));
468 }
469
470 bool wxURLModule::OnInit()
471 {
472 #if wxUSE_PROTOCOL_HTTP
473 // env var HTTP_PROXY contains the address of the default proxy to use if
474 // set, but don't try to create this proxy right now because it will slow
475 // down the program startup (especially if there is no DNS server
476 // available, in which case it may take up to 1 minute)
477
478 if ( wxGetenv(wxT("HTTP_PROXY")) )
479 {
480 wxURL::ms_useDefaultProxy = true;
481 }
482 #endif // wxUSE_PROTOCOL_HTTP
483 return true;
484 }
485
486 void wxURLModule::OnExit()
487 {
488 #if wxUSE_PROTOCOL_HTTP
489 wxDELETE(wxURL::ms_proxyDefault);
490 #endif // wxUSE_PROTOCOL_HTTP
491 }
492
493 #endif // wxUSE_SOCKETS
494
495
496 #endif // wxUSE_URL