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