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