]> git.saurik.com Git - wxWidgets.git/blob - src/common/url.cpp
Added def files for making OpenGL DLLs (Mingw32); added comment to wxHTML format
[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 license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "url.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #include <string.h>
24 #include <ctype.h>
25
26 #include "wx/string.h"
27 #include "wx/list.h"
28 #include "wx/utils.h"
29 #include "wx/module.h"
30 #include "wx/url.h"
31
32 IMPLEMENT_CLASS(wxProtoInfo, wxObject)
33 IMPLEMENT_CLASS(wxURL, wxObject)
34
35 // Protocols list
36 wxProtoInfo *wxURL::ms_protocols = NULL;
37
38 #if wxUSE_SOCKETS
39 wxHTTP *wxURL::ms_proxyDefault = NULL;
40 bool wxURL::ms_useDefaultProxy = FALSE;
41 #endif
42
43 // --------------------------------------------------------------
44 // wxURL
45 // --------------------------------------------------------------
46
47 // --------------------------------------------------------------
48 // --------- wxURL CONSTRUCTOR DESTRUCTOR -----------------------
49 // --------------------------------------------------------------
50
51 wxURL::wxURL(const wxString& url)
52 {
53 m_protocol = NULL;
54 m_error = wxURL_NOERR;
55 m_url = url;
56
57 #if wxUSE_SOCKETS
58 if ( ms_useDefaultProxy && !ms_proxyDefault )
59 {
60 SetDefaultProxy(getenv("HTTP_PROXY"));
61
62 if ( !ms_proxyDefault )
63 {
64 // don't try again
65 ms_useDefaultProxy = FALSE;
66 }
67 }
68
69 m_useProxy = ms_proxyDefault != NULL;
70 m_proxy = ms_proxyDefault;
71 #endif // wxUSE_SOCKETS
72
73 ParseURL();
74 }
75
76 bool wxURL::ParseURL()
77 {
78 wxString last_url = m_url;
79
80 // If the URL was already parsed (so m_protocol != NULL), we pass this section.
81 if (!m_protocol) {
82
83 // Clean up
84 CleanData();
85
86 // Extract protocol name
87 if (!PrepProto(last_url)) {
88 m_error = wxURL_SNTXERR;
89 return FALSE;
90 }
91
92 // Find and create the protocol object
93 if (!FetchProtocol()) {
94 m_error = wxURL_NOPROTO;
95 return FALSE;
96 }
97
98 // Do we need a host name ?
99 if (m_protoinfo->m_needhost) {
100 // Extract it
101 if (!PrepHost(last_url)) {
102 m_error = wxURL_SNTXERR;
103 return FALSE;
104 }
105 }
106
107 // Extract full path
108 if (!PrepPath(last_url)) {
109 m_error = wxURL_NOPATH;
110 return FALSE;
111 }
112 }
113 // URL parse finished.
114
115 #if wxUSE_SOCKETS
116 if (m_useProxy) {
117 // We destroy the newly created protocol.
118 CleanData();
119
120 // Third, we rebuild the URL.
121 m_url = m_protoname + wxT(":");
122 if (m_protoinfo->m_needhost)
123 m_url = m_url + wxT("//") + m_hostname;
124
125 m_url += m_path;
126
127 // We initialize specific variables.
128 m_protocol = m_proxy; // FIXME: we should clone the protocol
129 }
130 #endif
131
132 m_error = wxURL_NOERR;
133 return TRUE;
134 }
135
136 void wxURL::CleanData()
137 {
138 #if wxUSE_SOCKETS
139 if (!m_useProxy)
140 #endif
141 delete m_protocol;
142 }
143
144 wxURL::~wxURL()
145 {
146 CleanData();
147 #if wxUSE_SOCKETS
148 if (m_proxy && m_proxy != ms_proxyDefault)
149 delete m_proxy;
150 #endif
151 }
152
153 // --------------------------------------------------------------
154 // --------- wxURL urls decoders --------------------------------
155 // --------------------------------------------------------------
156
157 bool wxURL::PrepProto(wxString& url)
158 {
159 int pos;
160
161 // Find end
162 pos = url.Find(wxT(':'));
163 if (pos == -1)
164 return FALSE;
165
166 m_protoname = url(0, pos);
167
168 url = url(pos+1, url.Length());
169
170 return TRUE;
171 }
172
173 bool wxURL::PrepHost(wxString& url)
174 {
175 wxString temp_url;
176 int pos, pos2;
177
178 if ((url.GetChar(0) != wxT('/')) || (url.GetChar(1) != wxT('/')))
179 return FALSE;
180
181 url = url(2, url.Length());
182
183 pos = url.Find(wxT('/'));
184 if (pos == -1)
185 pos = url.Length();
186
187 if (pos == 0)
188 return FALSE;
189
190 temp_url = url(0, pos);
191 url = url(url.Find(wxT('/')), url.Length());
192
193 // Retrieve service number
194 pos2 = temp_url.Find(wxT(':'), TRUE);
195 if (pos2 != -1 && pos2 < pos) {
196 m_servname = temp_url(pos2+1, pos);
197 if (!m_servname.IsNumber())
198 return FALSE;
199 temp_url = temp_url(0, pos2);
200 }
201
202 // Retrieve user and password.
203 pos2 = temp_url.Find(wxT('@'));
204 // Even if pos2 equals -1, this code is right.
205 m_hostname = temp_url(pos2+1, temp_url.Length());
206
207 m_user = wxT("");
208 m_password = wxT("");
209
210 if (pos2 == -1)
211 return TRUE;
212
213 temp_url = temp_url(0, pos2);
214 pos2 = temp_url.Find(wxT(':'));
215
216 if (pos2 == -1)
217 return FALSE;
218
219 m_user = temp_url(0, pos2);
220 m_password = temp_url(pos2+1, url.Length());
221
222 return TRUE;
223 }
224
225 bool wxURL::PrepPath(wxString& url)
226 {
227 if (url.Length() != 0)
228 m_path = ConvertToValidURI(url);
229 else
230 m_path = wxT("/");
231 return TRUE;
232 }
233
234 bool wxURL::FetchProtocol()
235 {
236 wxProtoInfo *info = ms_protocols;
237
238 while (info) {
239 if (m_protoname == info->m_protoname) {
240 if (m_servname.IsNull())
241 m_servname = info->m_servname;
242
243 m_protoinfo = info;
244 m_protocol = (wxProtocol *)m_protoinfo->m_cinfo->CreateObject();
245 return TRUE;
246 }
247 info = info->next;
248 }
249 return FALSE;
250 }
251
252 // --------------------------------------------------------------
253 // --------- wxURL get ------------------------------------------
254 // --------------------------------------------------------------
255
256 wxInputStream *wxURL::GetInputStream()
257 {
258 wxInputStream *the_i_stream = NULL;
259
260 if (!m_protocol) {
261 m_error = wxURL_NOPROTO;
262 return NULL;
263 }
264
265 m_error = wxURL_NOERR;
266 if (m_user != wxT("")) {
267 m_protocol->SetUser(m_user);
268 m_protocol->SetPassword(m_password);
269 }
270
271 #if wxUSE_SOCKETS
272 wxIPV4address addr;
273
274 // m_protoinfo is NULL when we use a proxy
275 if (!m_useProxy && m_protoinfo->m_needhost) {
276 if (!addr.Hostname(m_hostname)) {
277 m_error = wxURL_NOHOST;
278 return NULL;
279 }
280
281 addr.Service(m_servname);
282
283 if (!m_protocol->Connect(addr, TRUE)) // Watcom needs the 2nd arg for some reason
284 {
285 m_error = wxURL_CONNERR;
286 return NULL;
287 }
288 }
289 #endif
290
291 // When we use a proxy, we have to pass the whole URL to it.
292 if (m_useProxy)
293 the_i_stream = m_protocol->GetInputStream(m_url);
294 else
295 the_i_stream = m_protocol->GetInputStream(m_path);
296
297 if (!the_i_stream) {
298 m_error = wxURL_PROTOERR;
299 return NULL;
300 }
301
302 return the_i_stream;
303 }
304
305 #if wxUSE_SOCKETS
306 void wxURL::SetDefaultProxy(const wxString& url_proxy)
307 {
308 if ( !url_proxy )
309 {
310 if ( ms_proxyDefault )
311 {
312 ms_proxyDefault->Close();
313 delete ms_proxyDefault;
314 ms_proxyDefault = NULL;
315 }
316 }
317 else
318 {
319 wxString tmp_str = url_proxy;
320 int pos = tmp_str.Find(wxT(':'));
321 if (pos == -1)
322 return;
323
324 wxString hostname = tmp_str(0, pos),
325 port = tmp_str(pos+1, tmp_str.Length()-pos);
326 wxIPV4address addr;
327
328 if (!addr.Hostname(hostname))
329 return;
330 if (!addr.Service(port))
331 return;
332
333 if (ms_proxyDefault)
334 // Finally, when all is right, we connect the new proxy.
335 ms_proxyDefault->Close();
336 else
337 ms_proxyDefault = new wxHTTP();
338 ms_proxyDefault->Connect(addr, TRUE); // Watcom needs the 2nd arg for some reason
339 }
340 }
341
342 void wxURL::SetProxy(const wxString& url_proxy)
343 {
344 if ( !url_proxy )
345 {
346 if ( m_proxy && m_proxy != ms_proxyDefault )
347 {
348 m_proxy->Close();
349 delete m_proxy;
350 }
351
352 m_useProxy = FALSE;
353 }
354 else
355 {
356 wxString tmp_str;
357 wxString hostname, port;
358 int pos;
359 wxIPV4address addr;
360
361 tmp_str = url_proxy;
362 pos = tmp_str.Find(wxT(':'));
363 // This is an invalid proxy name.
364 if (pos == -1)
365 return;
366
367 hostname = tmp_str(0, pos);
368 port = tmp_str(pos, tmp_str.Length()-pos);
369
370 addr.Hostname(hostname);
371 addr.Service(port);
372
373 // Finally, create the whole stuff.
374 if (m_proxy && m_proxy != ms_proxyDefault)
375 delete m_proxy;
376 m_proxy = new wxHTTP();
377 m_proxy->Connect(addr, TRUE); // Watcom needs the 2nd arg for some reason
378
379 CleanData();
380 // Reparse url.
381 m_useProxy = TRUE;
382 ParseURL();
383 }
384 }
385 #endif // wxUSE_SOCKETS
386
387 wxString wxURL::ConvertToValidURI(const wxString& uri)
388 {
389 wxString out_str;
390 wxString hexa_code;
391 size_t i;
392
393 for (i=0;i<uri.Len();i++) {
394 wxChar c = uri.GetChar(i);
395
396 if (c == wxT(' '))
397 out_str += wxT('+');
398 else {
399 if (!isalpha(c) && c != wxT('.') && c != wxT('+') && c != wxT('/')) {
400 hexa_code.Printf(wxT("%%%02X"), c);
401 out_str += hexa_code;
402 } else
403 out_str += c;
404 }
405 }
406
407 return out_str;
408 }
409
410 wxString wxURL::ConvertFromURI(const wxString& uri)
411 {
412 wxString new_uri;
413
414 size_t i = 0;
415 while (i<uri.Len()) {
416 int code;
417 if (uri[i] == wxT('%')) {
418 i++;
419 if (uri[i] >= wxT('A') && uri[i] <= wxT('F'))
420 code = (uri[i] - wxT('A') + 10) * 16;
421 else
422 code = (uri[i] - wxT('0')) * 16;
423 i++;
424 if (uri[i] >= wxT('A') && uri[i] <= wxT('F'))
425 code += (uri[i] - wxT('A')) + 10;
426 else
427 code += (uri[i] - wxT('0'));
428 i++;
429 new_uri += (wxChar)code;
430 continue;
431 }
432 new_uri += uri[i];
433 i++;
434 }
435 return new_uri;
436 }
437
438 // ----------------------------------------------------------------------
439 // A module which deletes the default proxy if we created it
440 // ----------------------------------------------------------------------
441
442 #if wxUSE_SOCKETS
443
444 class wxURLModule : public wxModule
445 {
446 public:
447 virtual bool OnInit();
448 virtual void OnExit();
449
450 private:
451 DECLARE_DYNAMIC_CLASS(wxURLModule)
452 };
453
454 IMPLEMENT_DYNAMIC_CLASS(wxURLModule, wxModule)
455
456 bool wxURLModule::OnInit()
457 {
458 // env var HTTP_PROXY contains the address of the default proxy to use if
459 // set, but don't try to create this proxy right now because it will slow
460 // down the program startup (especially if there is no DNS server
461 // available, in which case it may take up to 1 minute)
462 if ( getenv("HTTP_PROXY") )
463 {
464 wxURL::ms_useDefaultProxy = TRUE;
465 }
466
467 return TRUE;
468 }
469
470 void wxURLModule::OnExit()
471 {
472 delete wxURL::ms_proxyDefault;
473 wxURL::ms_proxyDefault = NULL;
474 }
475
476 #endif // wxUSE_SOCKETS