]> git.saurik.com Git - wxWidgets.git/blob - src/common/url.cpp
Tweaks for demos on MacOSX
[wxWidgets.git] / src / common / url.cpp
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