libzypp  17.28.8
Url.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
13 #include <zypp-core/Url.h>
14 #include <zypp-core/Pathname.h>
15 #include <zypp-core/base/Gettext.h>
16 #include <zypp-core/base/String.h>
17 #include <zypp-core/base/Regex.h>
18 #include <stdexcept>
19 #include <iostream>
20 
21 
23 namespace zypp
24 {
25 
26 
27  using namespace zypp::url;
28 
29 
30  // -----------------------------------------------------------------
31  /*
32  * url = [scheme:] [//authority] /path [?query] [#fragment]
33  */
34  #define RX_SPLIT_URL "^([^:/?#]+:|)" \
35  "(//[^/?#]*|)" \
36  "([^?#]*)" \
37  "([?][^#]*|)" \
38  "(#.*|)"
39 
40 
42  namespace
43  {
44 
45 
46  // ---------------------------------------------------------------
47  class LDAPUrl: public UrlBase
48  {
49  public:
50  LDAPUrl(): UrlBase()
51  {
52  configure();
53  }
54 
55  LDAPUrl(const LDAPUrl &url): UrlBase(url)
56  {}
57 
58  virtual UrlBase *
59  clone() const
60  {
61  return new LDAPUrl(*this);
62  }
63 
64  virtual UrlSchemes
65  getKnownSchemes() const
66  {
67  UrlSchemes schemes(2);
68  schemes[0] = "ldap";
69  schemes[1] = "ldaps";
70  return schemes;
71  }
72 
73  virtual void
74  configure()
75  {
76  config("sep_pathparams", "");
77 
78  config("psep_querystr", "?");
79  config("vsep_querystr", "");
80 
81  // host is required (isValid=>false)
82  // but not mandatory (see RFC 2255),
83  // that is, accept empty host.
84  config("require_host", "y");
85 
86  // not allowed here
87  config("rx_username", "");
88  config("rx_password", "");
89  config("rx_fragment", "");
90  config("rx_pathparams", "");
91  }
92 
93  virtual zypp::url::ParamMap
94  getQueryStringMap(zypp::url::EEncoding eflag) const
95  {
96  static const char * const keys[] = {
97  "attrs", "scope", "filter", "exts", NULL
98  };
100  zypp::url::ParamVec pvec( getQueryStringVec());
101  if( pvec.size() <= 4)
102  {
103  for(size_t i=0; i<pvec.size(); i++)
104  {
105  if(eflag == zypp::url::E_ENCODED)
106  pmap[keys[i]] = pvec[i];
107  else
108  pmap[keys[i]] = zypp::url::decode( pvec[i]);
109  }
110  }
111  else
112  {
113  ZYPP_THROW(url::UrlNotSupportedException(
114  _("Invalid LDAP URL query string")
115  ));
116  }
117  return pmap;
118  }
119 
120  virtual void
121  setQueryStringMap(const zypp::url::ParamMap &pmap)
122  {
123  static const char * const keys[] = {
124  "attrs", "scope", "filter", "exts", NULL
125  };
126 
127  // remove psep ("?") from safe chars
128  std::string join_safe;
129  std::string safe(config("safe_querystr"));
130  std::string psep(config("psep_querystr"));
131  for(std::string::size_type i=0; i<safe.size(); i++)
132  {
133  if( psep.find(safe[i]) == std::string::npos)
134  join_safe.append(1, safe[i]);
135  }
136 
137  zypp::url::ParamVec pvec(4);
138  zypp::url::ParamMap::const_iterator p;
139  for(p=pmap.begin(); p!=pmap.end(); ++p)
140  {
141  bool found=false;
142  for(size_t i=0; i<4; i++)
143  {
144  if(p->first == keys[i])
145  {
146  found=true;
147  pvec[i] = zypp::url::encode(p->second, join_safe);
148  }
149  }
150  if( !found)
151  {
152  ZYPP_THROW(url::UrlNotSupportedException(
153  str::form(_("Invalid LDAP URL query parameter '%s'"),
154  p->first.c_str())
155  ));
156  }
157  }
158  setQueryStringVec(pvec);
159  }
160  };
161 
162 
163  // ---------------------------------------------------------------
164  // FIXME: hmm..
165  class UrlByScheme
166  {
167  private:
168  typedef std::map<std::string,UrlRef> UrlBySchemeMap;
169  UrlBySchemeMap urlByScheme;
170 
171  public:
172  UrlByScheme()
173  {
174  UrlRef ref;
175 
176  // =====================================
177  ref.reset( new LDAPUrl());
178  addUrlByScheme("ldap", ref);
179  addUrlByScheme("ldaps", ref);
180 
181 
182  // =====================================
183  ref.reset( new UrlBase());
184  // don't show empty authority
187 
188  ref->config("with_authority", "n"); // disallow host,...
189  ref->config("require_pathname", "m"); // path is mandatory
190  addUrlByScheme("hd", ref);
191  addUrlByScheme("cd", ref);
192  addUrlByScheme("dvd", ref);
193  addUrlByScheme("dir", ref);
194  addUrlByScheme("iso", ref);
195 
196  addUrlByScheme("mailto", ref);
197  addUrlByScheme("urn", ref);
198  addUrlByScheme("plugin", ref); // zypp plugable media handler:
199 
200  // RFC1738, 3.10: may contain a host
201  ref->config("with_authority", "y"); // allow host,
202  ref->config("with_port", "n"); // but no port,
203  ref->config("rx_username", ""); // username or
204  ref->config("rx_password", ""); // password ...
205  addUrlByScheme("file", ref);
206 
207  // =====================================
208  ref.reset( new UrlBase());
209  ref->config("require_host", "m"); // host is mandatory
210  addUrlByScheme("nfs", ref);
211  addUrlByScheme("nfs4", ref);
212  addUrlByScheme("smb", ref);
213  addUrlByScheme("cifs", ref);
214  addUrlByScheme("http", ref);
215  addUrlByScheme("https", ref);
216  ref->config("path_encode_slash2", "y"); // always encode 2. slash
217  addUrlByScheme("ftp", ref);
218  addUrlByScheme("sftp", ref);
219  addUrlByScheme("tftp", ref);
220  }
221 
222  bool
223  addUrlByScheme(const std::string &scheme,
224  UrlRef urlImpl)
225  {
226  if( urlImpl && urlImpl->isValidScheme(scheme))
227  {
228  UrlRef ref(urlImpl);
229  ref->clear();
230  urlByScheme[str::toLower(scheme)] = ref;
231  return true;
232  }
233  return false;
234  }
235 
236  UrlRef
237  getUrlByScheme(const std::string &scheme) const
238  {
239  UrlBySchemeMap::const_iterator i(urlByScheme.find(str::toLower(scheme)));
240  if( i != urlByScheme.end())
241  {
242  return i->second;
243  }
244  return UrlRef();
245  }
246 
247  bool
248  isRegisteredScheme(const std::string &scheme) const
249  {
250  return urlByScheme.find(str::toLower(scheme)) != urlByScheme.end();
251  }
252 
253  UrlSchemes
254  getRegisteredSchemes() const
255  {
256  UrlBySchemeMap::const_iterator i(urlByScheme.begin());
257  UrlSchemes schemes;
258 
259  schemes.reserve(urlByScheme.size());
260  for( ; i != urlByScheme.end(); ++i)
261  {
262  schemes.push_back(i->first);
263  }
264  return schemes;
265  }
266  };
267 
268 
269  // ---------------------------------------------------------------
270  UrlByScheme & g_urlSchemeRepository()
271  {
272  static UrlByScheme _v;
273  return _v;
274  }
275 
277  } // anonymous namespace
279 
280 
281  // -----------------------------------------------------------------
283  {
284  }
285 
286 
287  // -----------------------------------------------------------------
289  : m_impl( new UrlBase())
290  {
291  }
292 
293 
294  // -----------------------------------------------------------------
295  Url::Url(const Url &url)
296  : m_impl( url.m_impl)
297  {
298  if( !m_impl)
299  {
301  _("Unable to clone Url object")
302  ));
303  }
304  }
305 
306 
307  // -----------------------------------------------------------------
309  : m_impl( url)
310  {
311  if( !m_impl)
312  {
314  _("Invalid empty Url object reference")
315  ));
316  }
317  }
318 
319 
320  // -----------------------------------------------------------------
321  Url::Url(const std::string &encodedUrl)
322  : m_impl( parseUrl(encodedUrl))
323  {
324  if( !m_impl)
325  {
327  _("Unable to parse Url components")
328  ));
329  }
330  }
331 
332 
333  // -----------------------------------------------------------------
334  Url&
335  Url::operator = (const std::string &encodedUrl)
336  {
337  UrlRef url( parseUrl(encodedUrl));
338  if( !url)
339  {
341  _("Unable to parse Url components")
342  ));
343  }
344  m_impl = url;
345  return *this;
346  }
347 
348 
349  // -----------------------------------------------------------------
350  Url&
351  Url::operator = (const Url &url)
352  {
353  m_impl = url.m_impl;
354  return *this;
355  }
356 
357 
358  // -----------------------------------------------------------------
359  // static
360  bool
361  Url::registerScheme(const std::string &scheme,
362  UrlRef urlImpl)
363  {
364  return g_urlSchemeRepository().addUrlByScheme(scheme, urlImpl);
365  }
366 
367 
368  // -----------------------------------------------------------------
369  // static
370  UrlRef
371  Url::parseUrl(const std::string &encodedUrl)
372  {
373  UrlRef url;
374  str::smatch out;
375  bool ret = false;
376 
377  try
378  {
380  ret = str::regex_match(encodedUrl, out, rex);
381  }
382  catch( ... )
383  {}
384 
385  if(ret && out.size() == 6)
386  {
387  std::string scheme = out[1];
388  if (scheme.size() > 1)
389  scheme = scheme.substr(0, scheme.size()-1);
390  std::string authority = out[2];
391  if (authority.size() >= 2)
392  authority = authority.substr(2);
393  std::string query = out[4];
394  if (query.size() > 1)
395  query = query.substr(1);
396  std::string fragment = out[5];
397  if (fragment.size() > 1)
398  fragment = fragment.substr(1);
399 
400  url = g_urlSchemeRepository().getUrlByScheme(scheme);
401  if( !url)
402  {
403  url.reset( new UrlBase());
404  }
405  url->init(scheme, authority, out[3],
406  query, fragment);
407  }
408  return url;
409  }
410 
411 
412  // -----------------------------------------------------------------
413  // static
416  {
417  return g_urlSchemeRepository().getRegisteredSchemes();
418  }
419 
420 
421  // -----------------------------------------------------------------
422  // static
423  bool
424  Url::isRegisteredScheme(const std::string &scheme)
425  {
426  return g_urlSchemeRepository().isRegisteredScheme(scheme);
427  }
428 
429 
430  // -----------------------------------------------------------------
433  {
434  return m_impl->getKnownSchemes();
435  }
436 
437 
438  // -----------------------------------------------------------------
439  bool
440  Url::isValidScheme(const std::string &scheme) const
441  {
442  return m_impl->isValidScheme(scheme);
443  }
444 
445 
447  namespace
448  {
449  inline bool isInList( const char ** begin_r, const char ** end_r, const std::string & scheme_r )
450  {
451  for ( ; begin_r != end_r; ++begin_r )
452  if ( scheme_r == *begin_r )
453  return true;
454  return false;
455  }
456  }
457  bool Url::schemeIsLocal( const std::string & scheme_r )
458  {
459  static const char * val[] = { "cd", "dvd", "dir", "hd", "iso", "file" };
460  return isInList( arrayBegin(val), arrayEnd(val), scheme_r );
461  }
462 
463  bool Url::schemeIsRemote( const std::string & scheme_r )
464  {
465  static const char * val[] = { "http", "https", "nfs", "nfs4", "smb", "cifs", "ftp", "sftp", "tftp" };
466  return isInList( arrayBegin(val), arrayEnd(val), scheme_r );
467  }
468 
469  bool Url::schemeIsVolatile( const std::string & scheme_r )
470  {
471  static const char * val[] = { "cd", "dvd" };
472  return isInList( arrayBegin(val), arrayEnd(val), scheme_r );
473  }
474 
475  bool Url::schemeIsDownloading( const std::string & scheme_r )
476  {
477  static const char * val[] = { "http", "https", "ftp", "sftp", "tftp" };
478  return isInList( arrayBegin(val), arrayEnd(val), scheme_r );
479  }
480 
481  bool Url::schemeIsPlugin( const std::string & scheme_r )
482  {
483  return scheme_r == "plugin";
484  }
486 
487  // -----------------------------------------------------------------
488  bool
489  Url::isValid() const
490  {
491  return m_impl->isValid();
492  }
493 
494 
495  // -----------------------------------------------------------------
496  std::string
498  {
499  return m_impl->asString();
500  }
501 
502 
503  // -----------------------------------------------------------------
504  std::string
506  {
507  // make sure, all url components are included;
508  // regardless of the current configuration...
509  ViewOptions opts(getViewOptions() +
519  return m_impl->asString(opts);
520  }
521 
522 
523  // -----------------------------------------------------------------
524  std::string
525  Url::asString(const ViewOptions &opts) const
526  {
527  return m_impl->asString(opts);
528  }
529 
530 
531  // -----------------------------------------------------------------
532  std::string
534  {
535  return m_impl->getScheme();
536  }
537 
538 
539  // -----------------------------------------------------------------
540  std::string
542  {
543  return m_impl->getAuthority();
544  }
545 
546  // -----------------------------------------------------------------
547  std::string
549  {
550  return m_impl->getPathData();
551  }
552 
553 
554  // -----------------------------------------------------------------
555  std::string
557  {
558  return m_impl->getQueryString();
559  }
560 
561 
562  // -----------------------------------------------------------------
563  std::string
565  {
566  return m_impl->getFragment(eflag);
567  }
568 
569 
570  // -----------------------------------------------------------------
571  std::string
573  {
574  return m_impl->getUsername(eflag);
575  }
576 
577 
578  // -----------------------------------------------------------------
579  std::string
581  {
582  return m_impl->getPassword(eflag);
583  }
584 
585 
586  // -----------------------------------------------------------------
587  std::string
588  Url::getHost(EEncoding eflag) const
589  {
590  return m_impl->getHost(eflag);
591  }
592 
593 
594  // -----------------------------------------------------------------
595  std::string
596  Url::getPort() const
597  {
598  return m_impl->getPort();
599  }
600 
601 
602  // -----------------------------------------------------------------
603  std::string
605  {
606  return m_impl->getPathName(eflag);
607  }
608 
609 
610  // -----------------------------------------------------------------
611  std::string
613  {
614  return m_impl->getPathParams();
615  }
616 
617 
618  // -----------------------------------------------------------------
621  {
622  return m_impl->getPathParamsVec();
623  }
624 
625 
626  // -----------------------------------------------------------------
629  {
630  return m_impl->getPathParamsMap(eflag);
631  }
632 
633 
634  // -----------------------------------------------------------------
635  std::string
636  Url::getPathParam(const std::string &param, EEncoding eflag) const
637  {
638  return m_impl->getPathParam(param, eflag);
639  }
640 
641 
642  // -----------------------------------------------------------------
645  {
646  return m_impl->getQueryStringVec();
647  }
648 
649 
650  // -----------------------------------------------------------------
653  {
654  return m_impl->getQueryStringMap(eflag);
655  }
656 
657 
658  // -----------------------------------------------------------------
659  std::string
660  Url::getQueryParam(const std::string &param, EEncoding eflag) const
661  {
662  return m_impl->getQueryParam(param, eflag);
663  }
664 
665 
666  // -----------------------------------------------------------------
667  void
668  Url::setScheme(const std::string &scheme)
669  {
670  if(scheme == m_impl->getScheme())
671  {
672  return;
673  }
674  if( m_impl->isKnownScheme(scheme))
675  {
676  m_impl->setScheme(scheme);
677  return;
678  }
679 
680  UrlRef url = g_urlSchemeRepository().getUrlByScheme(scheme);
681  if( !url)
682  {
683  url.reset( new UrlBase());
684  }
685  url->init(
686  scheme,
687  m_impl->getAuthority(),
688  m_impl->getPathData(),
691  );
692  m_impl = url;
693  }
694 
695 
696  // -----------------------------------------------------------------
697  void
698  Url::setAuthority(const std::string &authority)
699  {
700  m_impl->setAuthority(authority);
701  }
702 
703 
704  // -----------------------------------------------------------------
705  void
706  Url::setPathData(const std::string &pathdata)
707  {
708  m_impl->setPathData(pathdata);
709  }
710 
711 
712  // -----------------------------------------------------------------
713  void
714  Url::setQueryString(const std::string &querystr)
715  {
716  m_impl->setQueryString(querystr);
717  }
718 
719 
720  // -----------------------------------------------------------------
721  void
722  Url::setFragment(const std::string &fragment, EEncoding eflag)
723  {
724  m_impl->setFragment(fragment, eflag);
725  }
726 
727 
728  // -----------------------------------------------------------------
729  void
730  Url::setUsername(const std::string &user,
731  EEncoding eflag)
732  {
733  m_impl->setUsername(user, eflag);
734  }
735 
736 
737  // -----------------------------------------------------------------
738  void
739  Url::setPassword(const std::string &pass,
740  EEncoding eflag)
741  {
742  m_impl->setPassword(pass, eflag);
743  }
744 
745 
746  // -----------------------------------------------------------------
747  void
748  Url::setHost(const std::string &host)
749  {
750  m_impl->setHost(host);
751  }
752 
753 
754  // -----------------------------------------------------------------
755  void
756  Url::setPort(const std::string &port)
757  {
758  m_impl->setPort(port);
759  }
760 
761 
762  // -----------------------------------------------------------------
763  void
764  Url::setPathName(const std::string &path,
765  EEncoding eflag)
766  {
767  m_impl->setPathName(path, eflag);
768  }
769 
770  void
772  EEncoding eflag)
773  {
774  m_impl->setPathName(path.asString(), eflag);
775  }
776 
777  void
778  Url::setPathName(const char *path,
779  EEncoding eflag)
780  {
781  m_impl->setPathName(path, eflag);
782  }
783 
784  // -----------------------------------------------------------------
785 
786  void Url::appendPathName( const Pathname & path_r, EEncoding eflag_r )
787  { if ( ! path_r.emptyOrRoot() ) setPathName( Pathname(getPathName( eflag_r )) / path_r, eflag_r ); }
788 
789  // -----------------------------------------------------------------
790  void
791  Url::setPathParams(const std::string &params)
792  {
793  m_impl->setPathParams(params);
794  }
795 
796 
797  // -----------------------------------------------------------------
798  void
800  {
801  m_impl->setPathParamsVec(pvec);
802  }
803 
804 
805  // -----------------------------------------------------------------
806  void
808  {
809  m_impl->setPathParamsMap(pmap);
810  }
811 
812 
813  // -----------------------------------------------------------------
814  void
815  Url::setPathParam(const std::string &param, const std::string &value)
816  {
817  m_impl->setPathParam(param, value);
818  }
819 
820 
821  // -----------------------------------------------------------------
822  void
824  {
825  m_impl->setQueryStringVec(pvec);
826  }
827 
828 
829  // -----------------------------------------------------------------
830  void
832  {
833  m_impl->setQueryStringMap(pmap);
834  }
835 
836  // -----------------------------------------------------------------
837  void
838  Url::setQueryParam(const std::string &param, const std::string &value)
839  {
840  m_impl->setQueryParam(param, value);
841  }
842 
843  // -----------------------------------------------------------------
844  void
845  Url::delQueryParam(const std::string &param)
846  {
847  m_impl->delQueryParam(param);
848  }
849 
850  // -----------------------------------------------------------------
853  {
854  return m_impl->getViewOptions();
855  }
856 
857  // -----------------------------------------------------------------
858  void
860  {
861  m_impl->setViewOptions(vopts);
862  }
863 
864  // -----------------------------------------------------------------
865  std::ostream & operator<<( std::ostream & str, const Url & url )
866  {
867  return str << url.asString();
868  }
869 
870  bool operator<( const Url &lhs, const Url &rhs )
871  {
872  return (lhs.asCompleteString() < rhs.asCompleteString());
873  }
874 
875  bool operator==( const Url &lhs, const Url &rhs )
876  {
877  return (lhs.asCompleteString() == rhs.asCompleteString());
878  }
879 
880  bool operator!=( const Url &lhs, const Url &rhs )
881  {
882  return (lhs.asCompleteString() != rhs.asCompleteString());
883  }
884 
885  namespace hotfix1050625 {
886  std::string asString( const Url & url_r )
887  { return url_r.m_impl->asString1050625(); }
888  }
889 
891 } // namespace zypp
893 /*
894 ** vim: set ts=2 sts=2 sw=2 ai et:
895 */
#define RX_SPLIT_URL
Definition: Url.cc:34
UrlBySchemeMap urlByScheme
Definition: Url.cc:169
Url manipulation class.
Definition: Url.h:92
bool schemeIsPlugin() const
Definition: Url.h:281
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:533
std::string asCompleteString() const
Returns a complete string representation of the Url object.
Definition: Url.cc:505
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: Url.cc:859
void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: Url.cc:698
zypp::url::ParamMap getPathParamsMap(EEncoding eflag=zypp::url::E_DECODED) const
Returns a string map with path parameter keys and values.
Definition: Url.cc:628
zypp::url::ParamVec getPathParamsVec() const
Returns a vector with path parameter substrings.
Definition: Url.cc:620
void setQueryString(const std::string &querystr)
Set the query string in the URL.
Definition: Url.cc:714
bool schemeIsRemote() const
Definition: Url.h:266
std::string getPathParams() const
Returns the path parameters from the URL.
Definition: Url.cc:612
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:497
std::string getPathData() const
Returns the encoded path component of the URL.
Definition: Url.cc:548
std::string getPathParam(const std::string &param, EEncoding eflag=zypp::url::E_DECODED) const
Return the value for the specified path parameter.
Definition: Url.cc:636
std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: Url.cc:541
std::string getUsername(EEncoding eflag=zypp::url::E_DECODED) const
Returns the username from the URL authority.
Definition: Url.cc:572
static bool isRegisteredScheme(const std::string &scheme)
Returns if scheme name is registered.
Definition: Url.cc:424
void setFragment(const std::string &fragment, EEncoding eflag=zypp::url::E_DECODED)
Set the fragment string in the URL.
Definition: Url.cc:722
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:604
void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: Url.cc:823
Url()
Definition: Url.cc:288
std::string getQueryParam(const std::string &param, EEncoding eflag=zypp::url::E_DECODED) const
Return the value for the specified query parameter.
Definition: Url.cc:660
void setPathName(const std::string &path, EEncoding eflag=zypp::url::E_DECODED)
Set the path name.
Definition: Url.cc:764
void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: Url.cc:807
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: Url.cc:852
bool schemeIsDownloading() const
Definition: Url.h:276
void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: Url.cc:706
std::string getHost(EEncoding eflag=zypp::url::E_DECODED) const
Returns the hostname or IP from the URL authority.
Definition: Url.cc:588
url::UrlRef m_impl
Definition: Url.h:834
void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition: Url.cc:748
void setPort(const std::string &port)
Set the port number in the URL authority.
Definition: Url.cc:756
~Url()
Definition: Url.cc:282
void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: Url.cc:845
void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: Url.cc:799
bool isValid() const
Verifies the Url.
Definition: Url.cc:489
std::string getFragment(EEncoding eflag=zypp::url::E_DECODED) const
Returns the encoded fragment component of the URL.
Definition: Url.cc:564
static url::UrlRef parseUrl(const std::string &encodedUrl)
Parse a percent-encoded URL string.
Definition: Url.cc:371
void setPathParam(const std::string &param, const std::string &value)
Set or add value for the specified path parameter.
Definition: Url.cc:815
void setPassword(const std::string &pass, EEncoding eflag=zypp::url::E_DECODED)
Set the password in the URL authority.
Definition: Url.cc:739
void setPathParams(const std::string &params)
Set the path parameters.
Definition: Url.cc:791
Url & operator=(const std::string &encodedUrl)
Assigns parsed percent-encoded URL string to the object.
Definition: Url.cc:335
static bool registerScheme(const std::string &scheme, url::UrlRef urlImpl)
Register a scheme-specific implementation.
Definition: Url.cc:361
std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: Url.cc:556
bool isValidScheme(const std::string &scheme) const
Verifies the specified scheme name.
Definition: Url.cc:440
void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: Url.cc:838
static zypp::url::UrlSchemes getRegisteredSchemes()
Returns all registered scheme names.
Definition: Url.cc:415
zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: Url.cc:644
bool schemeIsLocal() const
Definition: Url.h:261
void setUsername(const std::string &user, EEncoding eflag=zypp::url::E_DECODED)
Set the username in the URL authority.
Definition: Url.cc:730
zypp::url::UrlSchemes getKnownSchemes() const
Returns scheme names known to this object.
Definition: Url.cc:432
void appendPathName(const Pathname &path_r, EEncoding eflag_r=zypp::url::E_DECODED)
Extend the path name.
Definition: Url.cc:786
void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: Url.cc:668
std::string getPassword(EEncoding eflag=zypp::url::E_DECODED) const
Returns the password from the URL authority.
Definition: Url.cc:580
bool schemeIsVolatile() const
Definition: Url.h:271
zypp::url::ParamMap getQueryStringMap(EEncoding eflag=zypp::url::E_DECODED) const
Returns a string map with query parameter and their values.
Definition: Url.cc:652
std::string getPort() const
Returns the port from the URL authority.
Definition: Url.cc:596
void setQueryStringMap(const zypp::url::ParamMap &qmap)
Set the query parameters.
Definition: Url.cc:831
bool emptyOrRoot() const
Test for "" or "/".
Definition: Pathname.h:121
const std::string & asString() const
String representation.
Definition: Pathname.h:91
Regular expression.
Definition: Regex.h:95
Regular expression match result.
Definition: Regex.h:168
unsigned size() const
Definition: Regex.cc:106
Generic Url base class.
Definition: UrlBase.h:271
virtual void setQueryString(const std::string &querystr)
Set the query string in the URL.
Definition: UrlBase.cc:970
virtual std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: UrlBase.cc:697
virtual std::string getPort() const
Returns the port number from the URL authority.
Definition: UrlBase.cc:754
virtual void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: UrlBase.cc:891
virtual void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition: UrlBase.cc:1082
virtual zypp::url::ParamMap getPathParamsMap(EEncoding eflag) const
Returns a string map with path parameter keys and values.
Definition: UrlBase.cc:802
virtual zypp::url::ParamVec getPathParamsVec() const
Returns a vector with encoded path parameter substrings.
Definition: UrlBase.cc:781
virtual std::string getUsername(EEncoding eflag) const
Returns the username from the URL authority.
Definition: UrlBase.cc:721
virtual UrlSchemes getKnownSchemes() const
Returns scheme names known by this object.
Definition: UrlBase.cc:415
virtual std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: UrlBase.cc:660
virtual void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: UrlBase.cc:1323
std::string config(const std::string &opt) const
Get the value of a UrlBase configuration variable.
Definition: UrlBase.cc:367
virtual void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: UrlBase.cc:1244
virtual std::string getFragment(EEncoding eflag) const
Returns the encoded fragment component of the URL.
Definition: UrlBase.cc:710
virtual std::string getPathParams() const
Returns the encoded path parameters from the URL.
Definition: UrlBase.cc:773
virtual void setQueryStringMap(const zypp::url::ParamMap &qmap)
Set the query parameters.
Definition: UrlBase.cc:1302
virtual std::string getPassword(EEncoding eflag) const
Returns the password from the URL authority.
Definition: UrlBase.cc:732
virtual std::string getScheme() const
Returns the scheme name of the URL.
Definition: UrlBase.cc:652
virtual zypp::url::ParamMap getQueryStringMap(EEncoding eflag) const
Returns a string map with query parameter and their values.
Definition: UrlBase.cc:857
virtual void setUsername(const std::string &user, EEncoding eflag)
Set the username in the URL authority.
Definition: UrlBase.cc:1014
virtual std::string getPathParam(const std::string &param, EEncoding eflag) const
Return the value for the specified path parameter.
Definition: UrlBase.cc:825
virtual void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: UrlBase.cc:1257
virtual std::string asString() const
Returns a default string representation of the Url object.
Definition: UrlBase.cc:504
virtual bool isKnownScheme(const std::string &scheme) const
Returns if scheme name is known to this object.
Definition: UrlBase.cc:423
virtual std::string getHost(EEncoding eflag) const
Returns the hostname or IP from the URL authority.
Definition: UrlBase.cc:743
virtual void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: UrlBase.cc:945
virtual void setPathName(const std::string &path, EEncoding eflag)
Set the path name.
Definition: UrlBase.cc:1167
virtual void setPort(const std::string &port)
Set the port number in the URL authority.
Definition: UrlBase.cc:1135
virtual std::string getPathData() const
Returns the encoded path component of the URL.
Definition: UrlBase.cc:687
virtual bool isValid() const
Verifies the Url.
Definition: UrlBase.cc:472
virtual std::string getPathName(EEncoding eflag) const
Returns the path name from the URL.
Definition: UrlBase.cc:762
virtual void setFragment(const std::string &fragment, EEncoding eflag)
Set the fragment string in the URL.
Definition: UrlBase.cc:987
virtual bool isValidScheme(const std::string &scheme) const
Verifies specified scheme name.
Definition: UrlBase.cc:440
virtual zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: UrlBase.cc:836
virtual std::string getQueryParam(const std::string &param, EEncoding eflag) const
Return the value for the specified query parameter.
Definition: UrlBase.cc:880
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: UrlBase.cc:387
virtual void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: UrlBase.cc:1289
virtual void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: UrlBase.cc:1332
virtual void setPassword(const std::string &pass, EEncoding eflag)
Set the password in the URL authority.
Definition: UrlBase.cc:1048
virtual void setPathParam(const std::string &param, const std::string &value)
Set or add value for the specified path parameter.
Definition: UrlBase.cc:1279
virtual void init(const std::string &scheme, const std::string &authority, const std::string &pathdata, const std::string &querystr, const std::string &fragment)
Initializes current object with new URL components.
Definition: UrlBase.cc:294
virtual void setPathParams(const std::string &params)
Set the path parameters.
Definition: UrlBase.cc:1227
std::string asString1050625() const
Definition: UrlBase.cc:509
virtual void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: UrlBase.cc:915
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: UrlBase.cc:379
Base class for all URL exceptions.
Definition: UrlException.h:32
Thrown if the url or a component can't be parsed at all.
Definition: UrlException.h:68
String related utilities and Regular expression matching.
std::string asString(const Url &url_r)
Definition: Url.cc:886
SolvableIdType size_type
Definition: PoolMember.h:126
bool regex_match(const std::string &s, smatch &matches, const regex &regex)
\relates regex \ingroup ZYPP_STR_REGEX \relates regex \ingroup ZYPP_STR_REGEX
Definition: Regex.h:70
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
std::string toLower(const std::string &s)
Return lowercase version of s.
Definition: String.cc:177
Url details namespace.
Definition: UrlBase.cc:57
RWCOW_pointer< UrlBase > UrlRef
Copy-On-Write Url reference.
Definition: UrlBase.h:1089
std::vector< std::string > UrlSchemes
Vector of URL scheme names.
Definition: UrlBase.h:251
std::string encode(const std::string &str, const std::string &safe, EEncoding eflag)
Encodes a string using URL percent encoding.
Definition: UrlUtils.cc:32
std::map< std::string, std::string > ParamMap
A parameter map container.
Definition: UrlUtils.h:47
std::vector< std::string > ParamVec
A parameter vector container.
Definition: UrlUtils.h:40
EEncoding
Encoding flags.
Definition: UrlUtils.h:52
@ E_ENCODED
Flag to request encoded string(s).
Definition: UrlUtils.h:53
std::string decode(const std::string &str, bool allowNUL)
Decodes a URL percent encoded string.
Definition: UrlUtils.cc:87
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
Definition: StrMatcher.cc:335
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
bool operator!=(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
std::ostream & operator<<(std::ostream &str, const InputStream &obj)
Definition: InputStream.cc:166
Url::asString() view options.
Definition: UrlBase.h:40
static const ViewOption WITH_SCHEME
Option to include scheme name in the URL string.
Definition: UrlBase.h:51
static const ViewOption WITH_PORT
Option to include port number in the URL string.
Definition: UrlBase.h:81
static const ViewOption WITH_PASSWORD
Option to include password in the URL string.
Definition: UrlBase.h:67
static const ViewOption WITH_PATH_PARAMS
Option to include path parameters in the URL string.
Definition: UrlBase.h:95
static const ViewOption WITH_FRAGMENT
Option to include fragment string in the URL string.
Definition: UrlBase.h:107
static const ViewOption WITH_PATH_NAME
Option to include path name in the URL string.
Definition: UrlBase.h:87
static const ViewOption EMPTY_AUTHORITY
Explicitely include the URL authority separator "//".
Definition: UrlBase.h:121
static const ViewOption DEFAULTS
Default combination of view options.
Definition: UrlBase.h:177
static const ViewOption WITH_USERNAME
Option to include username in the URL string.
Definition: UrlBase.h:58
static const ViewOption WITH_QUERY_STR
Option to include query string in the URL string.
Definition: UrlBase.h:101
static const ViewOption WITH_HOST
Option to include hostname in the URL string.
Definition: UrlBase.h:74
#define arrayBegin(A)
Simple C-array iterator.
Definition: Easy.h:41
#define arrayEnd(A)
Definition: Easy.h:43
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
#define _(MSG)
Definition: Gettext.h:37