libzypp  17.16.0
Url.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
13 #include "zypp/Url.h"
14 #include "zypp/Pathname.h"
15 #include "zypp/base/Gettext.h"
16 #include "zypp/base/String.h"
17 #include "zypp/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&
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  }
481 
482  // -----------------------------------------------------------------
483  bool
484  Url::isValid() const
485  {
486  return m_impl->isValid();
487  }
488 
489 
490  // -----------------------------------------------------------------
491  std::string
493  {
494  return m_impl->asString();
495  }
496 
497 
498  // -----------------------------------------------------------------
499  std::string
501  {
502  // make sure, all url components are included;
503  // regardless of the current configuration...
504  ViewOptions opts(getViewOptions() +
514  return m_impl->asString(opts);
515  }
516 
517 
518  // -----------------------------------------------------------------
519  std::string
520  Url::asString(const ViewOptions &opts) const
521  {
522  return m_impl->asString(opts);
523  }
524 
525 
526  // -----------------------------------------------------------------
527  std::string
529  {
530  return m_impl->getScheme();
531  }
532 
533 
534  // -----------------------------------------------------------------
535  std::string
537  {
538  return m_impl->getAuthority();
539  }
540 
541  // -----------------------------------------------------------------
542  std::string
544  {
545  return m_impl->getPathData();
546  }
547 
548 
549  // -----------------------------------------------------------------
550  std::string
552  {
553  return m_impl->getQueryString();
554  }
555 
556 
557  // -----------------------------------------------------------------
558  std::string
560  {
561  return m_impl->getFragment(eflag);
562  }
563 
564 
565  // -----------------------------------------------------------------
566  std::string
568  {
569  return m_impl->getUsername(eflag);
570  }
571 
572 
573  // -----------------------------------------------------------------
574  std::string
576  {
577  return m_impl->getPassword(eflag);
578  }
579 
580 
581  // -----------------------------------------------------------------
582  std::string
583  Url::getHost(EEncoding eflag) const
584  {
585  return m_impl->getHost(eflag);
586  }
587 
588 
589  // -----------------------------------------------------------------
590  std::string
591  Url::getPort() const
592  {
593  return m_impl->getPort();
594  }
595 
596 
597  // -----------------------------------------------------------------
598  std::string
600  {
601  return m_impl->getPathName(eflag);
602  }
603 
604 
605  // -----------------------------------------------------------------
606  std::string
608  {
609  return m_impl->getPathParams();
610  }
611 
612 
613  // -----------------------------------------------------------------
616  {
617  return m_impl->getPathParamsVec();
618  }
619 
620 
621  // -----------------------------------------------------------------
624  {
625  return m_impl->getPathParamsMap(eflag);
626  }
627 
628 
629  // -----------------------------------------------------------------
630  std::string
631  Url::getPathParam(const std::string &param, EEncoding eflag) const
632  {
633  return m_impl->getPathParam(param, eflag);
634  }
635 
636 
637  // -----------------------------------------------------------------
640  {
641  return m_impl->getQueryStringVec();
642  }
643 
644 
645  // -----------------------------------------------------------------
648  {
649  return m_impl->getQueryStringMap(eflag);
650  }
651 
652 
653  // -----------------------------------------------------------------
654  std::string
655  Url::getQueryParam(const std::string &param, EEncoding eflag) const
656  {
657  return m_impl->getQueryParam(param, eflag);
658  }
659 
660 
661  // -----------------------------------------------------------------
662  void
663  Url::setScheme(const std::string &scheme)
664  {
665  if(scheme == m_impl->getScheme())
666  {
667  return;
668  }
669  if( m_impl->isKnownScheme(scheme))
670  {
671  m_impl->setScheme(scheme);
672  return;
673  }
674 
675  UrlRef url = g_urlSchemeRepository().getUrlByScheme(scheme);
676  if( !url)
677  {
678  url.reset( new UrlBase());
679  }
680  url->init(
681  scheme,
682  m_impl->getAuthority(),
683  m_impl->getPathData(),
686  );
687  m_impl = url;
688  }
689 
690 
691  // -----------------------------------------------------------------
692  void
693  Url::setAuthority(const std::string &authority)
694  {
695  m_impl->setAuthority(authority);
696  }
697 
698 
699  // -----------------------------------------------------------------
700  void
701  Url::setPathData(const std::string &pathdata)
702  {
703  m_impl->setPathData(pathdata);
704  }
705 
706 
707  // -----------------------------------------------------------------
708  void
709  Url::setQueryString(const std::string &querystr)
710  {
711  m_impl->setQueryString(querystr);
712  }
713 
714 
715  // -----------------------------------------------------------------
716  void
717  Url::setFragment(const std::string &fragment, EEncoding eflag)
718  {
719  m_impl->setFragment(fragment, eflag);
720  }
721 
722 
723  // -----------------------------------------------------------------
724  void
725  Url::setUsername(const std::string &user,
726  EEncoding eflag)
727  {
728  m_impl->setUsername(user, eflag);
729  }
730 
731 
732  // -----------------------------------------------------------------
733  void
734  Url::setPassword(const std::string &pass,
735  EEncoding eflag)
736  {
737  m_impl->setPassword(pass, eflag);
738  }
739 
740 
741  // -----------------------------------------------------------------
742  void
743  Url::setHost(const std::string &host)
744  {
745  m_impl->setHost(host);
746  }
747 
748 
749  // -----------------------------------------------------------------
750  void
751  Url::setPort(const std::string &port)
752  {
753  m_impl->setPort(port);
754  }
755 
756 
757  // -----------------------------------------------------------------
758  void
759  Url::setPathName(const std::string &path,
760  EEncoding eflag)
761  {
762  m_impl->setPathName(path, eflag);
763  }
764 
765  void
767  EEncoding eflag)
768  {
769  m_impl->setPathName(path.asString(), eflag);
770  }
771 
772  void
773  Url::setPathName(const char *path,
774  EEncoding eflag)
775  {
776  m_impl->setPathName(path, eflag);
777  }
778 
779  // -----------------------------------------------------------------
780 
781  void Url::appendPathName( const Pathname & path_r, EEncoding eflag_r )
782  { if ( ! path_r.emptyOrRoot() ) setPathName( Pathname(getPathName( eflag_r )) / path_r, eflag_r ); }
783 
784  // -----------------------------------------------------------------
785  void
786  Url::setPathParams(const std::string &params)
787  {
788  m_impl->setPathParams(params);
789  }
790 
791 
792  // -----------------------------------------------------------------
793  void
795  {
796  m_impl->setPathParamsVec(pvec);
797  }
798 
799 
800  // -----------------------------------------------------------------
801  void
803  {
804  m_impl->setPathParamsMap(pmap);
805  }
806 
807 
808  // -----------------------------------------------------------------
809  void
810  Url::setPathParam(const std::string &param, const std::string &value)
811  {
812  m_impl->setPathParam(param, value);
813  }
814 
815 
816  // -----------------------------------------------------------------
817  void
819  {
820  m_impl->setQueryStringVec(pvec);
821  }
822 
823 
824  // -----------------------------------------------------------------
825  void
827  {
828  m_impl->setQueryStringMap(pmap);
829  }
830 
831  // -----------------------------------------------------------------
832  void
833  Url::setQueryParam(const std::string &param, const std::string &value)
834  {
835  m_impl->setQueryParam(param, value);
836  }
837 
838  // -----------------------------------------------------------------
839  void
840  Url::delQueryParam(const std::string &param)
841  {
842  m_impl->delQueryParam(param);
843  }
844 
845  // -----------------------------------------------------------------
848  {
849  return m_impl->getViewOptions();
850  }
851 
852  // -----------------------------------------------------------------
853  void
855  {
856  m_impl->setViewOptions(vopts);
857  }
858 
859  // -----------------------------------------------------------------
860  std::ostream & operator<<( std::ostream & str, const Url & url )
861  {
862  return str << url.asString();
863  }
864 
865  bool operator<( const Url &lhs, const Url &rhs )
866  {
867  return (lhs.asCompleteString() < rhs.asCompleteString());
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 
881 } // namespace zypp
883 /*
884 ** vim: set ts=2 sts=2 sw=2 ai et:
885 */
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:528
void setPassword(const std::string &pass, EEncoding eflag=zypp::url::E_DECODED)
Set the password in the URL authority.
Definition: Url.cc:734
virtual std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: UrlBase.cc:588
Interface to gettext.
zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: Url.cc:639
static const ViewOption WITH_USERNAME
Option to include username in the URL string.
Definition: UrlBase.h:58
unsigned size() const
Definition: Regex.cc:95
virtual std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: UrlBase.cc:625
std::vector< std::string > ParamVec
A parameter vector container.
Definition: UrlUtils.h:40
static const ViewOption WITH_FRAGMENT
Option to include fragment string in the URL string.
Definition: UrlBase.h:107
std::map< std::string, std::string > ParamMap
A parameter map container.
Definition: UrlUtils.h:47
void setPathParam(const std::string &param, const std::string &value)
Set or add value for the specified path parameter.
Definition: Url.cc:810
void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: Url.cc:833
virtual void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: UrlBase.cc:1246
virtual zypp::url::ParamMap getQueryStringMap(EEncoding eflag) const
Returns a string map with query parameter and their values.
Definition: UrlBase.cc:780
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
virtual UrlSchemes getKnownSchemes() const
Returns scheme names known by this object.
Definition: UrlBase.cc:349
Regular expression.
Definition: Regex.h:86
std::vector< std::string > UrlSchemes
Vector of URL scheme names.
Definition: UrlBase.h:250
Flag to request encoded string(s).
Definition: UrlUtils.h:53
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: Url.cc:854
static zypp::url::UrlSchemes getRegisteredSchemes()
Returns all registered scheme names.
Definition: Url.cc:415
Url details namespace.
Definition: UrlBase.cc:54
void appendPathName(const Pathname &path_r, EEncoding eflag_r=zypp::url::E_DECODED)
Extend the path name.
Definition: Url.cc:781
std::string getFragment(EEncoding eflag=zypp::url::E_DECODED) const
Returns the encoded fragment component of the URL.
Definition: Url.cc:559
virtual zypp::url::ParamVec getPathParamsVec() const
Returns a vector with encoded path parameter substrings.
Definition: UrlBase.cc:704
virtual void setUsername(const std::string &user, EEncoding eflag)
Set the username in the URL authority.
Definition: UrlBase.cc:937
virtual std::string getPathName(EEncoding eflag) const
Returns the path name from the URL.
Definition: UrlBase.cc:685
static const ViewOption WITH_SCHEME
Option to include scheme name in the URL string.
Definition: UrlBase.h:51
static const ViewOption WITH_HOST
Option to include hostname in the URL string.
Definition: UrlBase.h:74
virtual void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: UrlBase.cc:868
String related utilities and Regular expression matching.
void setPathParams(const std::string &params)
Set the path parameters.
Definition: Url.cc:786
std::string encode(const std::string &str, const std::string &safe, EEncoding eflag)
Encodes a string using URL percent encoding.
Definition: UrlUtils.cc:32
Base class for all URL exceptions.
Definition: UrlException.h:31
void setPort(const std::string &port)
Set the port number in the URL authority.
Definition: Url.cc:751
zypp::url::ParamVec getPathParamsVec() const
Returns a vector with path parameter substrings.
Definition: Url.cc:615
Url url
Definition: MediaCurl.cc:180
void setUsername(const std::string &user, EEncoding eflag=zypp::url::E_DECODED)
Set the username in the URL authority.
Definition: Url.cc:725
void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition: Url.cc:743
zypp::url::ParamMap getQueryStringMap(EEncoding eflag=zypp::url::E_DECODED) const
Returns a string map with query parameter and their values.
Definition: Url.cc:647
static bool registerScheme(const std::string &scheme, url::UrlRef urlImpl)
Register a scheme-specific implementation.
Definition: Url.cc:361
virtual void setPort(const std::string &port)
Set the port number in the URL authority.
Definition: UrlBase.cc:1058
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: Url.cc:818
static const ViewOption WITH_PATH_NAME
Option to include path name in the URL string.
Definition: UrlBase.h:87
Url::asString() view options.
Definition: UrlBase.h:39
void setFragment(const std::string &fragment, EEncoding eflag=zypp::url::E_DECODED)
Set the fragment string in the URL.
Definition: Url.cc:717
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: UrlBase.cc:321
virtual void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: UrlBase.cc:838
void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: Url.cc:693
virtual void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition: UrlBase.cc:1005
virtual void setPathParams(const std::string &params)
Set the path parameters.
Definition: UrlBase.cc:1150
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: Url.cc:847
virtual std::string getPassword(EEncoding eflag) const
Returns the password from the URL authority.
Definition: UrlBase.cc:655
virtual void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: UrlBase.cc:1167
UrlBySchemeMap urlByScheme
Definition: Url.cc:169
virtual std::string getQueryParam(const std::string &param, EEncoding eflag) const
Return the value for the specified query parameter.
Definition: UrlBase.cc:803
bool emptyOrRoot() const
Test for "" or "/".
Definition: Pathname.h:120
Thrown if the url or a component can't be parsed at all.
Definition: UrlException.h:67
void setPathName(const std::string &path, EEncoding eflag=zypp::url::E_DECODED)
Set the path name.
Definition: Url.cc:759
std::string getPathData() const
Returns the encoded path component of the URL.
Definition: Url.cc:543
zypp::url::UrlSchemes getKnownSchemes() const
Returns scheme names known to this object.
Definition: Url.cc:432
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:492
virtual std::string getPathParam(const std::string &param, EEncoding eflag) const
Return the value for the specified path parameter.
Definition: UrlBase.cc:748
std::string getPathParams() const
Returns the path parameters from the URL.
Definition: Url.cc:607
virtual void setFragment(const std::string &fragment, EEncoding eflag)
Set the fragment string in the URL.
Definition: UrlBase.cc:910
virtual void setPassword(const std::string &pass, EEncoding eflag)
Set the password in the URL authority.
Definition: UrlBase.cc:971
static bool isRegisteredScheme(const std::string &scheme)
Returns if scheme name is registered.
Definition: Url.cc:424
virtual std::string getHost(EEncoding eflag) const
Returns the hostname or IP from the URL authority.
Definition: UrlBase.cc:666
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:655
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: Url.cc:663
const std::string & asString() const
String representation.
Definition: Pathname.h:90
virtual std::string getPathParams() const
Returns the encoded path parameters from the URL.
Definition: UrlBase.cc:696
virtual void setQueryStringMap(const zypp::url::ParamMap &qmap)
Set the query parameters.
Definition: UrlBase.cc:1225
virtual std::string getPort() const
Returns the port number from the URL authority.
Definition: UrlBase.cc:677
static url::UrlRef parseUrl(const std::string &encodedUrl)
Parse a percent-encoded URL string.
Definition: Url.cc:371
std::string asCompleteString() const
Returns a complete string representation of the Url object.
Definition: Url.cc:500
static const ViewOption EMPTY_AUTHORITY
Explicitely include the URL authority separator "//".
Definition: UrlBase.h:121
bool schemeIsVolatile() const
Definition: Url.h:267
std::string getPort() const
Returns the port from the URL authority.
Definition: Url.cc:591
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: UrlBase.cc:313
void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: Url.cc:701
virtual std::string getFragment(EEncoding eflag) const
Returns the encoded fragment component of the URL.
Definition: UrlBase.cc:633
static const ViewOption WITH_PATH_PARAMS
Option to include path parameters in the URL string.
Definition: UrlBase.h:95
Url & operator=(const std::string &encodedUrl)
Assigns parsed percent-encoded URL string to the object.
Definition: Url.cc:335
virtual void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: UrlBase.cc:814
Url()
Definition: Url.cc:288
zypp::url::ParamMap getPathParamsMap(EEncoding eflag=zypp::url::E_DECODED) const
Returns a string map with path parameter keys and values.
Definition: Url.cc:623
#define _(MSG)
Definition: Gettext.h:37
virtual void setQueryString(const std::string &querystr)
Set the query string in the URL.
Definition: UrlBase.cc:893
bool isValid() const
Verifies the Url.
Definition: Url.cc:484
virtual bool isKnownScheme(const std::string &scheme) const
Returns if scheme name is known to this object.
Definition: UrlBase.cc:357
std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: Url.cc:536
std::string toLower(const std::string &s)
Return lowercase version of s.
Definition: String.cc:177
SolvableIdType size_type
Definition: PoolMember.h:126
std::string config(const std::string &opt) const
Get the value of a UrlBase configuration variable.
Definition: UrlBase.cc:301
bool operator!=(const SetRelation::Enum &lhs, const SetCompare &rhs)
virtual void setPathName(const std::string &path, EEncoding eflag)
Set the path name.
Definition: UrlBase.cc:1090
#define arrayEnd(A)
Definition: Easy.h:43
#define arrayBegin(A)
Simple C-array iterator.
Definition: Easy.h:41
static const ViewOption WITH_QUERY_STR
Option to include query string in the URL string.
Definition: UrlBase.h:101
Regular expression match result.
Definition: Regex.h:145
bool schemeIsRemote() const
Definition: Url.h:262
bool schemeIsDownloading() const
Definition: Url.h:272
void setQueryString(const std::string &querystr)
Set the query string in the URL.
Definition: Url.cc:709
static const ViewOption WITH_PASSWORD
Option to include password in the URL string.
Definition: UrlBase.h:67
bool isValidScheme(const std::string &scheme) const
Verifies the specified scheme name.
Definition: Url.cc:440
~Url()
Definition: Url.cc:282
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:599
std::string getHost(EEncoding eflag=zypp::url::E_DECODED) const
Returns the hostname or IP from the URL authority.
Definition: Url.cc:583
Generic Url base class.
Definition: UrlBase.h:269
virtual void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: UrlBase.cc:1180
virtual zypp::url::ParamMap getPathParamsMap(EEncoding eflag) const
Returns a string map with path parameter keys and values.
Definition: UrlBase.cc:725
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
static const ViewOption DEFAULTS
Default combination of view options.
Definition: UrlBase.h:177
url::UrlRef m_impl
Definition: Url.h:824
virtual zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: UrlBase.cc:759
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:631
virtual std::string getPathData() const
Returns the encoded path component of the URL.
Definition: UrlBase.cc:615
EEncoding
Encoding flags.
Definition: UrlUtils.h:52
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
Definition: StrMatcher.cc:335
static const ViewOption WITH_PORT
Option to include port number in the URL string.
Definition: UrlBase.h:81
virtual void setPathParam(const std::string &param, const std::string &value)
Set or add value for the specified path parameter.
Definition: UrlBase.cc:1202
virtual bool isValidScheme(const std::string &scheme) const
Verifies specified scheme name.
Definition: UrlBase.cc:374
void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: Url.cc:794
void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: Url.cc:802
void setQueryStringMap(const zypp::url::ParamMap &qmap)
Set the query parameters.
Definition: Url.cc:826
virtual void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: UrlBase.cc:1212
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
virtual bool isValid() const
Verifies the Url.
Definition: UrlBase.cc:406
virtual std::string asString() const
Returns a default string representation of the Url object.
Definition: UrlBase.cc:438
virtual std::string getUsername(EEncoding eflag) const
Returns the username from the URL authority.
Definition: UrlBase.cc:644
std::string getPassword(EEncoding eflag=zypp::url::E_DECODED) const
Returns the password from the URL authority.
Definition: Url.cc:575
virtual std::string getScheme() const
Returns the scheme name of the URL.
Definition: UrlBase.cc:580
RWCOW_pointer< UrlBase > UrlRef
Copy-On-Write Url reference.
Definition: UrlBase.h:1084
std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: Url.cc:551
Url manipulation class.
Definition: Url.h:87
virtual void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: UrlBase.cc:1255
std::string decode(const std::string &str, bool allowNUL)
Decodes a URL percent encoded string.
Definition: UrlUtils.cc:87
#define RX_SPLIT_URL
Definition: Url.cc:34
void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: Url.cc:840
std::string getUsername(EEncoding eflag=zypp::url::E_DECODED) const
Returns the username from the URL authority.
Definition: Url.cc:567
bool schemeIsLocal() const
Definition: Url.h:257