libzypp  17.25.8
UrlBase.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <zypp/url/UrlBase.h>
13 #include <zypp/base/String.h>
14 #include <zypp/base/Gettext.h>
15 #include <zypp/base/Regex.h>
16 #include <zypp/base/StringV.h>
17 
18 #include <stdexcept>
19 #include <climits>
20 #include <errno.h>
21 #include <sys/types.h>
22 #include <sys/socket.h>
23 #include <arpa/inet.h>
24 
25 #include <iostream>
26 #include <optional>
27 
28 // in the Estonian locale, a-z excludes t, for example. #302525
29 // http://en.wikipedia.org/wiki/Estonian_alphabet
30 #define a_zA_Z "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
31 
32 // ---------------------------------------------------------------
33 /*
34 ** authority = //[user [:password] @ ] host [:port]
35 **
36 ** host = hostname | IPv4 | "[" IPv6-IP "]" | "[v...]"
37 */
38 #define RX_VALID_SCHEME "^[" a_zA_Z "][" a_zA_Z "0-9\\.+-]*$"
39 
40 #define RX_VALID_PORT "^[0-9]{1,5}$"
41 
42 #define RX_VALID_HOSTNAME "^[[:alnum:]${_}]+([\\.-][[:alnum:]${_}]+)*$"
43 
44 #define RX_VALID_HOSTIPV4 \
45  "^([0-9]{1,3})\\.([0-9]{1,3})\\.([0-9]{1,3})\\.([0-9]{1,3})$"
46 
47 #define RX_VALID_HOSTIPV6 \
48  "^\\[[:a-fA-F0-9]+(:[0-9]{1,3}(\\.[0-9]{1,3}){3})?\\]$"
49 
50 
52 namespace zypp
53 {
54 
56  namespace url
57  {
58 
59 
60  // ---------------------------------------------------------------
61  /*
62  ** URL asString() view option constants:
63  */
64  const ViewOption ViewOption::WITH_SCHEME = 0x0001;
67  const ViewOption ViewOption::WITH_HOST = 0x0008;
68  const ViewOption ViewOption::WITH_PORT = 0x0010;
78  const ViewOption ViewOption::DEFAULTS = 0x07bb;
79 
81  /*
82  const ViewOption ViewOption::DEFAULTS =
83  ViewOption::WITH_SCHEME +
84  ViewOption::WITH_USERNAME +
85  ViewOption::WITH_HOST +
86  ViewOption::WITH_PORT +
87  ViewOption::WITH_PATH_NAME +
88  ViewOption::WITH_QUERY_STR +
89  ViewOption::WITH_FRAGMENT +
90  ViewOption::EMPTY_AUTHORITY +
91  ViewOption::EMPTY_PATH_NAME;
92  */
93 
94  // ---------------------------------------------------------------
96  : opt(0x07bb)
97  {}
98 
99  // ---------------------------------------------------------------
101  : opt(option)
102  {}
103 
104 
105  // ---------------------------------------------------------------
106  /*
107  ** Behaviour configuration variables.
108  */
109  typedef std::map< std::string, std::string > UrlConfig;
110 
111 
112  // ---------------------------------------------------------------
113 
122  {
123  public:
125  {}
126 
127  SafeQuerystr( std::string rhs )
128  { _assign( std::move(rhs) ); }
129 
130  SafeQuerystr & operator=( std::string rhs )
131  { _assign( std::move(rhs) ); return *this; }
132 
133 
134  operator const std::string &() const
135  { return str(); }
136 
137  const std::string & str() const
138  { return fullStr(); }
139 
140  const std::string & str( const ViewOptions & viewopts_r ) const
141  { return (viewopts_r.has( ViewOptions::WITH_PASSWORD ) || viewopts_r.has( ViewOptions::hotfix1050625 )) ? fullStr() : safeStr(); }
142 
143  const std::string & fullStr() const
144  { return _fullQuerytsr; }
145 
146  const std::string & safeStr() const
147  { return _safeQuerytsr ? _safeQuerytsr.value() : _fullQuerytsr; }
148 
149  private:
150  void _assign( std::string && rhs )
151  {
152  _fullQuerytsr = std::move(rhs);
153 
154  static constexpr std::string_view tag { "proxypass=" };
155  if ( _fullQuerytsr.find( tag ) != std::string::npos )
156  {
157  std::string safe;
158  strv::split( _fullQuerytsr, "&", [&safe]( std::string_view val ) {
159  if ( val.substr( 0, tag.size() ) != tag ) {
160  if ( ! safe.empty() )
161  safe += "&";
162  safe += val;
163  }
164  });
165  _safeQuerytsr = std::move(safe);
166  }
167  else
168  _safeQuerytsr = std::nullopt;
169  }
170  private:
171  std::string _fullQuerytsr;
172  std::optional<std::string> _safeQuerytsr;
173  };
174 
179  {
180  public:
182  {}
183 
184  UrlBaseData(const UrlConfig &conf)
185  : config(conf)
186  {}
187 
190 
191  std::string scheme;
192  std::string user;
193  std::string pass;
194  std::string host;
195  std::string port;
196  std::string pathname;
197  std::string pathparams;
199  std::string fragment;
200  };
201 
202 
203  // ---------------------------------------------------------------
204  /*
205  ** Anonymous/internal utility namespace:
206  */
207  namespace // anonymous
208  {
209 
210  // -------------------------------------------------------------
211  inline void
212  checkUrlData(const std::string &data,
213  const std::string &name,
214  const std::string &regx,
215  bool show=true)
216  {
217  if( regx.empty() || regx == "^$")
218  {
220  str::form(_("Url scheme does not allow a %s"), name.c_str())
221  ));
222  }
223  else
224  {
225  bool valid = false;
226  try
227  {
228  str::regex rex(regx);
229  valid = str::regex_match(data, rex);
230  }
231  catch( ... )
232  {}
233 
234  if( !valid)
235  {
236  if( show)
237  {
239  str::form(_("Invalid %s component '%s'"),
240  name.c_str(), data.c_str())
241  ));
242  }
243  else
244  {
246  str::form(_("Invalid %s component"), name.c_str())
247  ));
248  }
249  }
250  }
251  }
252 
253  } // namespace
254 
255 
256  // ---------------------------------------------------------------
258  {
259  delete m_data;
260  m_data = NULL;
261  }
262 
263 
264  // ---------------------------------------------------------------
266  : m_data( new UrlBaseData())
267  {
268  configure();
269  }
270 
271 
272  // ---------------------------------------------------------------
274  : m_data( new UrlBaseData( *(url.m_data)))
275  {
276  }
277 
278 
279  // ---------------------------------------------------------------
280  UrlBase::UrlBase(const std::string &scheme,
281  const std::string &authority,
282  const std::string &pathdata,
283  const std::string &querystr,
284  const std::string &fragment)
285  : m_data( new UrlBaseData())
286  {
287  configure();
288  init(scheme, authority, pathdata, querystr, fragment);
289  }
290 
291 
292  // ---------------------------------------------------------------
293  void
294  UrlBase::init(const std::string &scheme,
295  const std::string &authority,
296  const std::string &pathdata,
297  const std::string &querystr,
298  const std::string &fragment)
299  {
300  if ( scheme.empty() && *pathdata.c_str() == '/' )
301  setScheme("file");
302  else
303  setScheme(scheme);
304 
305  setAuthority(authority);
306  setPathData(pathdata);
307  setQueryString(querystr);
309  }
310 
311 
312  // ---------------------------------------------------------------
313  void
315  {
316  config("sep_pathparams", ";");
317  config("psep_pathparam", ",");
318  config("vsep_pathparam", "=");
319 
320  config("psep_querystr", "&");
321  config("vsep_querystr", "=");
322 
323  config("safe_username", "~!$&'()*+=,;");
324  config("safe_password", "~!$&'()*+=,:;");
325  config("safe_hostname", "[:]${_}");
326  config("safe_pathname", "~!$&'()*+=,:@/");
327  config("safe_pathparams", "~!$&'()*+=,:;@/");
328  config("safe_querystr", "~!$&'()*+=,:;@/?");
329  config("safe_fragment", "~!$&'()*+=,:;@/?");
330 
331  // y=yes (allowed)
332  // n=no (disallowed, exception if !empty)
333  config("with_authority", "y");
334  config("with_port", "y");
335 
336  // y=yes (required but don't throw if empty)
337  // n=no (not required, ignore if empty)
338  // m=mandatory (exception if empty)
339  config("require_host", "n");
340  config("require_pathname","n");
341 
342  // y=yes (encode 2. slash even if authority present)
343  // n=no (don't encode 2. slash if authority present)
344  config("path_encode_slash2", "n");
345 
346  config("rx_username", "^([" a_zA_Z "0-9!$&'\\(\\)*+=,;~\\._-]|%[a-fA-F0-9]{2})+$");
347  config("rx_password", "^([" a_zA_Z "0-9!$&'\\(\\)*+=,:;~\\._-]|%[a-fA-F0-9]{2})+$");
348 
349  config("rx_pathname", "^([" a_zA_Z "0-9!$&'\\(\\){}*+=,:@/~\\._-]|%[a-fA-F0-9]{2})+$");
350  config("rx_pathparams", "^([" a_zA_Z "0-9!$&'\\(\\){}*+=,:;@/~\\._-]|%[a-fA-F0-9]{2})+$");
351 
352  config("rx_querystr", "^([" a_zA_Z "0-9!$&'\\(\\){}*+=,:;@/?~\\._-]|%[a-fA-F0-9]{2})+$");
353  config("rx_fragment", "^([" a_zA_Z "0-9!$&'\\(\\){}*+=,:;@/?~\\._-]|%[a-fA-F0-9]{2})+$");
354  }
355 
356 
357  // ---------------------------------------------------------------
358  void
359  UrlBase::config(const std::string &opt, const std::string &val)
360  {
361  m_data->config[opt] = val;
362  }
363 
364 
365  // ---------------------------------------------------------------
366  std::string
367  UrlBase::config(const std::string &opt) const
368  {
369  UrlConfig::const_iterator v( m_data->config.find(opt));
370  if( v != m_data->config.end())
371  return v->second;
372  else
373  return std::string();
374  }
375 
376 
377  // ---------------------------------------------------------------
380  {
381  return m_data->vopts;
382  }
383 
384 
385  // ---------------------------------------------------------------
386  void
388  {
389  m_data->vopts = vopts;
390  }
391 
392 
393  // ---------------------------------------------------------------
394  void
396  {
399  *m_data = UrlBaseData();
400  m_data->config = config;
401  m_data->vopts = vopts;
402  }
403 
404 
405  // ---------------------------------------------------------------
406  UrlBase *
408  {
409  return new UrlBase(*this);
410  }
411 
412 
413  // ---------------------------------------------------------------
416  {
417  return UrlSchemes();
418  }
419 
420 
421  // ---------------------------------------------------------------
422  bool
423  UrlBase::isKnownScheme(const std::string &scheme) const
424  {
425  std::string lscheme( str::toLower(scheme));
426  UrlSchemes schemes( getKnownSchemes());
427  UrlSchemes::const_iterator s;
428 
429  for(s=schemes.begin(); s!=schemes.end(); ++s)
430  {
431  if( lscheme == str::toLower(*s))
432  return true;
433  }
434  return false;
435  }
436 
437 
438  // ---------------------------------------------------------------
439  bool
440  UrlBase::isValidScheme(const std::string &scheme) const
441  {
442  bool valid = false;
443  try
444  {
446  valid = str::regex_match(scheme, rex);
447  }
448  catch( ... )
449  {}
450 
451  if(valid)
452  {
453  std::string lscheme( str::toLower(scheme));
454  UrlSchemes schemes( getKnownSchemes());
455 
456  if( schemes.empty())
457  return true;
458 
459  UrlSchemes::const_iterator s;
460  for(s=schemes.begin(); s!=schemes.end(); ++s)
461  {
462  if( lscheme == str::toLower(*s))
463  return true;
464  }
465  }
466  return false;
467  }
468 
469 
470  // ---------------------------------------------------------------
471  bool
473  {
474  /*
475  ** scheme is the only mandatory component
476  ** for all url's and is already verified,
477  ** (except for empty Url instances), so
478  ** Url with empty scheme is never valid.
479  */
480  if( getScheme().empty())
481  return false;
482 
483  std::string host( getHost(zypp::url::E_ENCODED));
484  if( host.empty() && config("require_host") != "n")
485  return false;
486 
487  std::string path( getPathName(zypp::url::E_ENCODED));
488  if( path.empty() && config("require_pathname") != "n")
489  return false;
490 
491  /*
492  ** path has to begin with "/" if authority avaliable
493  ** if host is set after the pathname, we can't throw
494  */
495  if( !host.empty() && !path.empty() && path.at(0) != '/')
496  return false;
497 
498  return true;
499  }
500 
501 
502  // ---------------------------------------------------------------
503  std::string
505  {
506  return asString(getViewOptions());
507  }
508 
509  std::string UrlBase::asString1050625() const
510  {
511  // Temp. fix to keep the proxypass in the query when writing the .repo files,
512  // but otherwise hiding it, when WITH_PASSWORD is not set.
514  }
515 
516  // ---------------------------------------------------------------
517  std::string
519  {
520  std::string url;
521  UrlBaseData tmp;
522 
523  if( opts.has(ViewOptions::WITH_SCHEME))
524  {
525  tmp.scheme = getScheme();
526  if( !tmp.scheme.empty())
527  {
528  url += tmp.scheme + ":";
529 
530  if( opts.has(ViewOptions::WITH_HOST))
531  {
533  if( !tmp.host.empty())
534  {
535  url += "//";
536 
538  {
540  if( !tmp.user.empty())
541  {
542  url += tmp.user;
543 
545  {
547  if( !tmp.pass.empty())
548  {
549  url += ":" + tmp.pass;
550  }
551  }
552  url += "@";
553  }
554  }
555 
556  url += tmp.host;
557 
558  if( opts.has(ViewOptions::WITH_PORT))
559  {
560  tmp.port = getPort();
561  if( !tmp.port.empty())
562  {
563  url += ":" + tmp.port;
564  }
565  }
566  }
567  else if( opts.has(ViewOptions::EMPTY_AUTHORITY))
568  {
569  url += "//";
570  }
571  }
572  else if( opts.has(ViewOptions::EMPTY_AUTHORITY))
573  {
574  url += "//";
575  }
576  }
577  }
578 
580  {
582  if( !tmp.pathname.empty())
583  {
584  if(url.find("/") != std::string::npos)
585  {
586  // Url contains authority (that may be empty),
587  // we may need a rewrite of the encoded path.
588  tmp.pathname = cleanupPathName(tmp.pathname, true);
589  if(tmp.pathname.at(0) != '/')
590  {
591  url += "/";
592  }
593  }
594  url += tmp.pathname;
595 
597  {
598  tmp.pathparams = getPathParams();
599  if( !tmp.pathparams.empty())
600  {
601  url += ";" + tmp.pathparams;
602  }
603  else if( opts.has(ViewOptions::EMPTY_PATH_PARAMS))
604  {
605  url += ";";
606  }
607  }
608  }
609  else if( opts.has(ViewOptions::EMPTY_PATH_NAME)
610  && url.find("/") != std::string::npos)
611  {
612  url += "/";
614  {
615  url += ";";
616  }
617  }
618  }
619 
621  {
622  const std::string & querystr { getQueryString( opts ) }; // full or safe depending on opts
623  if( !querystr.empty() )
624  {
625  url += "?" + querystr;
626  }
627  else if( opts.has(ViewOptions::EMPTY_QUERY_STR))
628  {
629  url += "?";
630  }
631  }
632 
634  {
636  if( !tmp.fragment.empty())
637  {
638  url += "#" + tmp.fragment;
639  }
640  else if( opts.has(ViewOptions::EMPTY_FRAGMENT))
641  {
642  url += "#";
643  }
644  }
645 
646  return url;
647  }
648 
649 
650  // ---------------------------------------------------------------
651  std::string
653  {
654  return m_data->scheme;
655  }
656 
657 
658  // ---------------------------------------------------------------
659  std::string
661  {
662  std::string str;
663  if( !getHost(zypp::url::E_ENCODED).empty())
664  {
665  if( !getUsername(zypp::url::E_ENCODED).empty())
666  {
668  if( !getPassword(zypp::url::E_ENCODED).empty())
669  {
671  }
672  str += "@";
673  }
674 
676  if( !getPort().empty())
677  {
678  str += ":" + getPort();
679  }
680  }
681  return str;
682  }
683 
684 
685  // ---------------------------------------------------------------
686  std::string
688  {
690  config("sep_pathparams") +
691  getPathParams();
692  }
693 
694 
695  // ---------------------------------------------------------------
696  std::string
698  {
699  return m_data->querystr;
700  }
701 
702  std::string
703  UrlBase::getQueryString( const ViewOptions & viewopts_r ) const
704  {
705  return m_data->querystr.str( viewopts_r );
706  }
707 
708  // ---------------------------------------------------------------
709  std::string
711  {
712  if(eflag == zypp::url::E_DECODED)
714  else
715  return m_data->fragment;
716  }
717 
718 
719  // ---------------------------------------------------------------
720  std::string
722  {
723  if(eflag == zypp::url::E_DECODED)
724  return zypp::url::decode(m_data->user);
725  else
726  return m_data->user;
727  }
728 
729 
730  // ---------------------------------------------------------------
731  std::string
733  {
734  if(eflag == zypp::url::E_DECODED)
735  return zypp::url::decode(m_data->pass);
736  else
737  return m_data->pass;
738  }
739 
740 
741  // ---------------------------------------------------------------
742  std::string
744  {
745  if(eflag == zypp::url::E_DECODED)
746  return zypp::url::decode(m_data->host);
747  else
748  return m_data->host;
749  }
750 
751 
752  // ---------------------------------------------------------------
753  std::string
755  {
756  return m_data->port;
757  }
758 
759 
760  // ---------------------------------------------------------------
761  std::string
763  {
764  if(eflag == zypp::url::E_DECODED)
766  else
768  }
769 
770 
771  // ---------------------------------------------------------------
772  std::string
774  {
775  return m_data->pathparams;
776  }
777 
778 
779  // ---------------------------------------------------------------
782  {
783  zypp::url::ParamVec pvec;
784  if( config("psep_pathparam").empty())
785  {
786  pvec.push_back(getPathParams());
787  }
788  else
789  {
791  pvec,
792  getPathParams(),
793  config("psep_pathparam")
794  );
795  }
796  return pvec;
797  }
798 
799 
800  // ---------------------------------------------------------------
803  {
804  if( config("psep_pathparam").empty() ||
805  config("vsep_pathparam").empty())
806  {
808  "Path parameter parsing not supported for this URL"
809  ));
810  }
811  zypp::url::ParamMap pmap;
813  pmap,
814  getPathParams(),
815  config("psep_pathparam"),
816  config("vsep_pathparam"),
817  eflag
818  );
819  return pmap;
820  }
821 
822 
823  // ---------------------------------------------------------------
824  std::string
825  UrlBase::getPathParam(const std::string &param, EEncoding eflag) const
826  {
827  zypp::url::ParamMap pmap( getPathParamsMap( eflag));
828  zypp::url::ParamMap::const_iterator i( pmap.find(param));
829 
830  return i != pmap.end() ? i->second : std::string();
831  }
832 
833 
834  // ---------------------------------------------------------------
837  {
838  zypp::url::ParamVec pvec;
839  if( config("psep_querystr").empty())
840  {
841  pvec.push_back(getQueryString());
842  }
843  else
844  {
846  pvec,
847  getQueryString(),
848  config("psep_querystr")
849  );
850  }
851  return pvec;
852  }
853 
854 
855  // ---------------------------------------------------------------
858  {
859  if( config("psep_querystr").empty() ||
860  config("vsep_querystr").empty())
861  {
863  _("Query string parsing not supported for this URL")
864  ));
865  }
866  zypp::url::ParamMap pmap;
868  pmap,
869  getQueryString(),
870  config("psep_querystr"),
871  config("vsep_querystr"),
872  eflag
873  );
874  return pmap;
875  }
876 
877 
878  // ---------------------------------------------------------------
879  std::string
880  UrlBase::getQueryParam(const std::string &param, EEncoding eflag) const
881  {
882  zypp::url::ParamMap pmap( getQueryStringMap( eflag));
883  zypp::url::ParamMap::const_iterator i( pmap.find(param));
884 
885  return i != pmap.end() ? i->second : std::string();
886  }
887 
888 
889  // ---------------------------------------------------------------
890  void
891  UrlBase::setScheme(const std::string &scheme)
892  {
893  if( isValidScheme(scheme))
894  {
895  m_data->scheme = str::toLower(scheme);
896  }
897  else
898  if( scheme.empty())
899  {
901  _("Url scheme is a required component")
902  ));
903  }
904  else
905  {
907  str::form(_("Invalid Url scheme '%s'"), scheme.c_str())
908  ));
909  }
910  }
911 
912 
913  // ---------------------------------------------------------------
914  void
915  UrlBase::setAuthority(const std::string &authority)
916  {
917  std::string s = authority;
919 
920  std::string username, password, host, port;
921 
922  if ((p=s.find('@')) != std::string::npos)
923  {
924  q = s.find(':');
925  if (q != std::string::npos && q < p)
926  {
927  setUsername(s.substr(0, q), zypp::url::E_ENCODED);
928  setPassword(s.substr(q+1, p-q-1), zypp::url::E_ENCODED);
929  }
930  else
931  setUsername(s.substr(0, p), zypp::url::E_ENCODED);
932  s = s.substr(p+1);
933  }
934  if ((p = s.rfind(':')) != std::string::npos && ( (q = s.rfind(']')) == std::string::npos || q < p) )
935  {
936  setHost(s.substr(0, p));
937  setPort(s.substr(p+1));
938  }
939  else
940  setHost(s);
941  }
942 
943  // ---------------------------------------------------------------
944  void
945  UrlBase::setPathData(const std::string &pathdata)
946  {
947  size_t pos = std::string::npos;
948  std::string sep(config("sep_pathparams"));
949 
950  if( !sep.empty())
951  pos = pathdata.find(sep);
952 
953  if( pos != std::string::npos)
954  {
955  setPathName(pathdata.substr(0, pos),
957  setPathParams(pathdata.substr(pos + 1));
958  }
959  else
960  {
961  setPathName(pathdata,
963  setPathParams("");
964  }
965  }
966 
967 
968  // ---------------------------------------------------------------
969  void
970  UrlBase::setQueryString(const std::string &querystr)
971  {
972  if( querystr.empty())
973  {
974  m_data->querystr = querystr;
975  }
976  else
977  {
978  checkUrlData(querystr, "query string", config("rx_querystr"));
979 
980  m_data->querystr = querystr;
981  }
982  }
983 
984 
985  // ---------------------------------------------------------------
986  void
987  UrlBase::setFragment(const std::string &fragment,
988  EEncoding eflag)
989  {
990  if( fragment.empty())
991  {
992  m_data->fragment = fragment;
993  }
994  else
995  {
996  if(eflag == zypp::url::E_ENCODED)
997  {
998  checkUrlData(fragment, "fragment", config("rx_fragment"));
999 
1000  m_data->fragment = fragment;
1001  }
1002  else
1003  {
1005  fragment, config("safe_fragment")
1006  );
1007  }
1008  }
1009  }
1010 
1011 
1012  // ---------------------------------------------------------------
1013  void
1014  UrlBase::setUsername(const std::string &user,
1015  EEncoding eflag)
1016  {
1017  if( user.empty())
1018  {
1019  m_data->user = user;
1020  }
1021  else
1022  {
1023  if( config("with_authority") != "y")
1024  {
1026  _("Url scheme does not allow a username")
1027  ));
1028  }
1029 
1030  if(eflag == zypp::url::E_ENCODED)
1031  {
1032  checkUrlData(user, "username", config("rx_username"));
1033 
1034  m_data->user = user;
1035  }
1036  else
1037  {
1039  user, config("safe_username")
1040  );
1041  }
1042  }
1043  }
1044 
1045 
1046  // ---------------------------------------------------------------
1047  void
1048  UrlBase::setPassword(const std::string &pass,
1049  EEncoding eflag)
1050  {
1051  if( pass.empty())
1052  {
1053  m_data->pass = pass;
1054  }
1055  else
1056  {
1057  if( config("with_authority") != "y")
1058  {
1060  _("Url scheme does not allow a password")
1061  ));
1062  }
1063 
1064  if(eflag == zypp::url::E_ENCODED)
1065  {
1066  checkUrlData(pass, "password", config("rx_password"), false);
1067 
1068  m_data->pass = pass;
1069  }
1070  else
1071  {
1073  pass, config("safe_password")
1074  );
1075  }
1076  }
1077  }
1078 
1079 
1080  // ---------------------------------------------------------------
1081  void
1082  UrlBase::setHost(const std::string &host)
1083  {
1084  if( host.empty())
1085  {
1086  if(config("require_host") == "m")
1087  {
1089  _("Url scheme requires a host component")
1090  ));
1091  }
1092  m_data->host = host;
1093  }
1094  else
1095  {
1096  if( config("with_authority") != "y")
1097  {
1099  _("Url scheme does not allow a host component")
1100  ));
1101  }
1102 
1103  if( isValidHost(host))
1104  {
1105  std::string temp;
1106 
1107  // always decode in case isValidHost()
1108  // is reimplemented and supports also
1109  // the [v ... ] notation.
1110  if( host.at(0) == '[')
1111  {
1112  temp = str::toUpper(zypp::url::decode(host));
1113  }
1114  else
1115  {
1116  temp = str::toLower(zypp::url::decode(host));
1117  }
1118 
1120  temp, config("safe_hostname")
1121  );
1122  }
1123  else
1124  {
1126  str::form(_("Invalid host component '%s'"), host.c_str())
1127  ));
1128  }
1129  }
1130  }
1131 
1132 
1133  // ---------------------------------------------------------------
1134  void
1135  UrlBase::setPort(const std::string &port)
1136  {
1137  if( port.empty())
1138  {
1139  m_data->port = port;
1140  }
1141  else
1142  {
1143  if( config("with_authority") != "y" ||
1144  config("with_port") != "y")
1145  {
1147  _("Url scheme does not allow a port")
1148  ));
1149  }
1150 
1151  if( isValidPort(port))
1152  {
1153  m_data->port = port;
1154  }
1155  else
1156  {
1158  str::form(_("Invalid port component '%s'"), port.c_str())
1159  ));
1160  }
1161  }
1162  }
1163 
1164 
1165  // ---------------------------------------------------------------
1166  void
1167  UrlBase::setPathName(const std::string &path,
1168  EEncoding eflag)
1169  {
1170  if( path.empty())
1171  {
1172  if(config("require_pathname") == "m")
1173  {
1175  _("Url scheme requires path name")
1176  ));
1177  }
1178  m_data->pathname = path;
1179  }
1180  else
1181  {
1182  if(eflag == zypp::url::E_ENCODED)
1183  {
1184  checkUrlData(path, "path name", config("rx_pathname"));
1185 
1186  if( !getHost(zypp::url::E_ENCODED).empty())
1187  {
1188  // has to begin with a "/". For consistency with
1189  // setPathName while the host is empty, we allow
1190  // it in encoded ("%2f") form - cleanupPathName()
1191  // will fix / decode the first slash if needed.
1192  if(!(path.at(0) == '/' || (path.size() >= 3 &&
1193  str::toLower(path.substr(0, 3)) == "%2f")))
1194  {
1196  _("Relative path not allowed if authority exists")
1197  ));
1198  }
1199  }
1200 
1201  m_data->pathname = cleanupPathName(path);
1202  }
1203  else // zypp::url::E_DECODED
1204  {
1205  if( !getHost(zypp::url::E_ENCODED).empty())
1206  {
1207  if(path.at(0) != '/')
1208  {
1210  _("Relative path not allowed if authority exists")
1211  ));
1212  }
1213  }
1214 
1217  path, config("safe_pathname")
1218  )
1219  );
1220  }
1221  }
1222  }
1223 
1224 
1225  // ---------------------------------------------------------------
1226  void
1227  UrlBase::setPathParams(const std::string &params)
1228  {
1229  if( params.empty())
1230  {
1231  m_data->pathparams = params;
1232  }
1233  else
1234  {
1235  checkUrlData(params, "path parameters", config("rx_pathparams"));
1236 
1237  m_data->pathparams = params;
1238  }
1239  }
1240 
1241 
1242  // ---------------------------------------------------------------
1243  void
1245  {
1246  setPathParams(
1248  pvec,
1249  config("psep_pathparam")
1250  )
1251  );
1252  }
1253 
1254 
1255  // ---------------------------------------------------------------
1256  void
1258  {
1259  if( config("psep_pathparam").empty() ||
1260  config("vsep_pathparam").empty())
1261  {
1263  "Path Parameter parsing not supported for this URL"
1264  ));
1265  }
1266  setPathParams(
1268  pmap,
1269  config("psep_pathparam"),
1270  config("vsep_pathparam"),
1271  config("safe_pathparams")
1272  )
1273  );
1274  }
1275 
1276 
1277  // ---------------------------------------------------------------
1278  void
1279  UrlBase::setPathParam(const std::string &param, const std::string &value)
1280  {
1282  pmap[param] = value;
1283  setPathParamsMap(pmap);
1284  }
1285 
1286 
1287  // ---------------------------------------------------------------
1288  void
1290  {
1293  pvec,
1294  config("psep_querystr")
1295  )
1296  );
1297  }
1298 
1299 
1300  // ---------------------------------------------------------------
1301  void
1303  {
1304  if( config("psep_querystr").empty() ||
1305  config("vsep_querystr").empty())
1306  {
1308  _("Query string parsing not supported for this URL")
1309  ));
1310  }
1313  pmap,
1314  config("psep_querystr"),
1315  config("vsep_querystr"),
1316  config("safe_querystr")
1317  )
1318  );
1319  }
1320 
1321  // ---------------------------------------------------------------
1322  void
1323  UrlBase::setQueryParam(const std::string &param, const std::string &value)
1324  {
1326  pmap[param] = value;
1327  setQueryStringMap(pmap);
1328  }
1329 
1330  // ---------------------------------------------------------------
1331  void
1332  UrlBase::delQueryParam(const std::string &param)
1333  {
1335  pmap.erase(param);
1336  setQueryStringMap(pmap);
1337  }
1338 
1339 
1340  // ---------------------------------------------------------------
1341  std::string
1342  UrlBase::cleanupPathName(const std::string &path) const
1343  {
1344  bool authority = !getHost(zypp::url::E_ENCODED).empty();
1345  return cleanupPathName(path, authority);
1346  }
1347 
1348  // ---------------------------------------------------------------
1349  std::string
1350  UrlBase::cleanupPathName(const std::string &path, bool authority) const
1351  {
1352  std::string copy( path);
1353 
1354  // decode the first slash if it is encoded ...
1355  if(copy.size() >= 3 && copy.at(0) != '/' &&
1356  str::toLower(copy.substr(0, 3)) == "%2f")
1357  {
1358  copy.replace(0, 3, "/");
1359  }
1360 
1361  // if path begins with a double slash ("//"); encode the second
1362  // slash [minimal and IMO sufficient] before the first path
1363  // segment, to fulfill the path-absolute rule of RFC 3986
1364  // disallowing a "//" if no authority is present.
1365  if( authority)
1366  {
1367  //
1368  // rewrite of "//" to "/%2f" not required, use config
1369  //
1370  if(config("path_encode_slash2") == "y")
1371  {
1372  // rewrite "//" ==> "/%2f"
1373  if(copy.size() >= 2 && copy.at(0) == '/' && copy.at(1) == '/')
1374  {
1375  copy.replace(1, 1, "%2F");
1376  }
1377  }
1378  else
1379  {
1380  // rewrite "/%2f" ==> "//"
1381  if(copy.size() >= 4 && copy.at(0) == '/' &&
1382  str::toLower(copy.substr(1, 4)) == "%2f")
1383  {
1384  copy.replace(1, 4, "/");
1385  }
1386  }
1387  }
1388  else
1389  {
1390  // rewrite of "//" to "/%2f" is required (no authority)
1391  if(copy.size() >= 2 && copy.at(0) == '/' && copy.at(1) == '/')
1392  {
1393  copy.replace(1, 1, "%2F");
1394  }
1395  }
1396  return copy;
1397  }
1398 
1399 
1400  // ---------------------------------------------------------------
1401  bool
1402  UrlBase::isValidHost(const std::string &host) const
1403  {
1404  try
1405  {
1407  if( str::regex_match(host, regx))
1408  {
1409  struct in6_addr ip;
1410  std::string temp( host.substr(1, host.size()-2));
1411 
1412  return inet_pton(AF_INET6, temp.c_str(), &ip) > 0;
1413  }
1414  else
1415  {
1416  // matches also IPv4 dotted-decimal adresses...
1417  std::string temp( zypp::url::decode(host));
1419  return str::regex_match(temp, regx);
1420  }
1421  }
1422  catch( ... )
1423  {}
1424 
1425  return false;
1426  }
1427 
1428 
1429  // ---------------------------------------------------------------
1430  bool
1431  UrlBase::isValidPort(const std::string &port) const
1432  {
1433  try
1434  {
1435  str::regex regx(RX_VALID_PORT);
1436  if( str::regex_match(port, regx))
1437  {
1438  long pnum = str::strtonum<long>(port);
1439  return ( pnum >= 1 && pnum <= USHRT_MAX);
1440  }
1441  }
1442  catch( ... )
1443  {}
1444  return false;
1445  }
1446 
1447 
1449  } // namespace url
1451 
1453 } // namespace zypp
1455 /*
1456 ** vim: set ts=2 sts=2 sw=2 ai et:
1457 */
zypp::url::UrlBaseData::vopts
ViewOptions vopts
Definition: UrlBase.cc:189
zypp::url::UrlBase::getPassword
virtual std::string getPassword(EEncoding eflag) const
Returns the password from the URL authority.
Definition: UrlBase.cc:732
zypp::url::UrlBase::config
std::string config(const std::string &opt) const
Get the value of a UrlBase configuration variable.
Definition: UrlBase.cc:367
zypp::url::UrlBase::setQueryString
virtual void setQueryString(const std::string &querystr)
Set the query string in the URL.
Definition: UrlBase.cc:970
zypp::url::UrlBase::setPathName
virtual void setPathName(const std::string &path, EEncoding eflag)
Set the path name.
Definition: UrlBase.cc:1167
zypp::url::SafeQuerystr::str
const std::string & str() const
Definition: UrlBase.cc:137
zypp::url::UrlBase::setPathParam
virtual void setPathParam(const std::string &param, const std::string &value)
Set or add value for the specified path parameter.
Definition: UrlBase.cc:1279
zypp::url::UrlBase::clone
virtual UrlBase * clone() const
Returns pointer to a copy of the current object.
Definition: UrlBase.cc:407
zypp::url::UrlConfig
std::map< std::string, std::string > UrlConfig
Definition: UrlBase.cc:109
zypp::url::UrlBase::isValid
virtual bool isValid() const
Verifies the Url.
Definition: UrlBase.cc:472
zypp::url::UrlBase::getPathParam
virtual std::string getPathParam(const std::string &param, EEncoding eflag) const
Return the value for the specified path parameter.
Definition: UrlBase.cc:825
zypp::url::ViewOption::hotfix1050625
static const ViewOption hotfix1050625
Definition: UrlBase.h:233
zypp::url::UrlBase::getQueryParam
virtual std::string getQueryParam(const std::string &param, EEncoding eflag) const
Return the value for the specified query parameter.
Definition: UrlBase.cc:880
zypp::url::UrlBaseData::host
std::string host
Definition: UrlBase.cc:194
zypp::url::UrlBase::setPathParamsVec
virtual void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: UrlBase.cc:1244
zypp::url::UrlBase::getPathParams
virtual std::string getPathParams() const
Returns the encoded path parameters from the URL.
Definition: UrlBase.cc:773
zypp::url::UrlBase::setQueryStringMap
virtual void setQueryStringMap(const zypp::url::ParamMap &qmap)
Set the query parameters.
Definition: UrlBase.cc:1302
zypp::url::SafeQuerystr::_fullQuerytsr
std::string _fullQuerytsr
Definition: UrlBase.cc:171
zypp::url::UrlBaseData
Internal data used by UrlBase.
Definition: UrlBase.cc:179
zypp::url::E_DECODED
@ E_DECODED
Flag to request decoded string(s).
Definition: UrlUtils.h:54
zypp::url::UrlSchemes
std::vector< std::string > UrlSchemes
Vector of URL scheme names.
Definition: UrlBase.h:251
RX_VALID_SCHEME
#define RX_VALID_SCHEME
Definition: UrlBase.cc:38
zypp::url::UrlNotAllowedException
Thrown if scheme does not allow a component.
Definition: UrlException.h:105
zypp::url::decode
std::string decode(const std::string &str, bool allowNUL)
Decodes a URL percent encoded string.
Definition: UrlUtils.cc:87
zypp::url::UrlBase::setAuthority
virtual void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: UrlBase.cc:915
zypp::url::UrlBaseData::user
std::string user
Definition: UrlBase.cc:192
zypp::url::ViewOption::EMPTY_PATH_NAME
static const ViewOption EMPTY_PATH_NAME
Explicitely include the "/" path character.
Definition: UrlBase.h:133
zypp::url::UrlBaseData::pathparams
std::string pathparams
Definition: UrlBase.cc:197
zypp::url::UrlBase::getPort
virtual std::string getPort() const
Returns the port number from the URL authority.
Definition: UrlBase.cc:754
zypp::url::UrlBase::clear
virtual void clear()
Clears all data in the object.
Definition: UrlBase.cc:395
RX_VALID_PORT
#define RX_VALID_PORT
Definition: UrlBase.cc:40
zypp::url::ViewOption::WITH_USERNAME
static const ViewOption WITH_USERNAME
Option to include username in the URL string.
Definition: UrlBase.h:58
zypp::url::UrlBase::getKnownSchemes
virtual UrlSchemes getKnownSchemes() const
Returns scheme names known by this object.
Definition: UrlBase.cc:415
zypp::url::UrlBase::asString1050625
std::string asString1050625() const
Definition: UrlBase.cc:509
ZYPP_THROW
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
zypp::url::ViewOption::WITH_FRAGMENT
static const ViewOption WITH_FRAGMENT
Option to include fragment string in the URL string.
Definition: UrlBase.h:107
zypp::url::UrlBase::getPathData
virtual std::string getPathData() const
Returns the encoded path component of the URL.
Definition: UrlBase.cc:687
zypp::url::ViewOption::WITH_PATH_NAME
static const ViewOption WITH_PATH_NAME
Option to include path name in the URL string.
Definition: UrlBase.h:87
zypp::url::UrlBase::isKnownScheme
virtual bool isKnownScheme(const std::string &scheme) const
Returns if scheme name is known to this object.
Definition: UrlBase.cc:423
zypp::url::ViewOption::EMPTY_PATH_PARAMS
static const ViewOption EMPTY_PATH_PARAMS
Explicitely include the path parameters separator ";".
Definition: UrlBase.h:143
a_zA_Z
#define a_zA_Z
Definition: UrlBase.cc:30
zypp::url::ViewOption::ViewOption
ViewOption()
Create instance with default combination of view options.
Definition: UrlBase.cc:95
zypp::url::UrlNotSupportedException
Thrown if a feature e.g.
Definition: UrlException.h:125
zypp::url::EEncoding
EEncoding
Encoding flags.
Definition: UrlUtils.h:52
RX_VALID_HOSTIPV6
#define RX_VALID_HOSTIPV6
Definition: UrlBase.cc:47
zypp::url::UrlBase::asString
virtual std::string asString() const
Returns a default string representation of the Url object.
Definition: UrlBase.cc:504
zypp::url::UrlBase::~UrlBase
virtual ~UrlBase()
Definition: UrlBase.cc:257
zypp::url::SafeQuerystr::_safeQuerytsr
std::optional< std::string > _safeQuerytsr
Definition: UrlBase.cc:172
zypp::url::ViewOption::EMPTY_QUERY_STR
static const ViewOption EMPTY_QUERY_STR
Explicitely include the query string separator "?".
Definition: UrlBase.h:154
zypp::str::split
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \t", const Trim trim_r=NO_TRIM)
Split line_r into words.
Definition: String.h:527
zypp::url::ViewOption::EMPTY_FRAGMENT
static const ViewOption EMPTY_FRAGMENT
Explicitely include the fragment string separator "#".
Definition: UrlBase.h:165
zypp::url::ViewOption::WITH_PASSWORD
static const ViewOption WITH_PASSWORD
Option to include password in the URL string.
Definition: UrlBase.h:67
zypp::url::UrlBase::getQueryStringMap
virtual zypp::url::ParamMap getQueryStringMap(EEncoding eflag) const
Returns a string map with query parameter and their values.
Definition: UrlBase.cc:857
zypp::url::UrlBase::getPathName
virtual std::string getPathName(EEncoding eflag) const
Returns the path name from the URL.
Definition: UrlBase.cc:762
zypp::url::UrlBaseData::UrlBaseData
UrlBaseData()
Definition: UrlBase.cc:181
zypp::url::UrlBase::configure
virtual void configure()
Configures behaviour of the instance.
Definition: UrlBase.cc:314
_
#define _(MSG)
Definition: Gettext.h:37
zypp::url::ViewOption::DEFAULTS
static const ViewOption DEFAULTS
Default combination of view options.
Definition: UrlBase.h:177
zypp::url::ViewOption::has
bool has(const ViewOption &o) const
Check if specified option o is set in the current object.
Definition: UrlBase.h:228
zypp::str::form
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
zypp::url::UrlBaseData::querystr
SafeQuerystr querystr
Definition: UrlBase.cc:198
zypp::url::ViewOption::EMPTY_AUTHORITY
static const ViewOption EMPTY_AUTHORITY
Explicitely include the URL authority separator "//".
Definition: UrlBase.h:121
zypp::url::UrlBase::setUsername
virtual void setUsername(const std::string &user, EEncoding eflag)
Set the username in the URL authority.
Definition: UrlBase.cc:1014
zypp::url::UrlBase::setPathParamsMap
virtual void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: UrlBase.cc:1257
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
zypp::url::SafeQuerystr::operator=
SafeQuerystr & operator=(std::string rhs)
Definition: UrlBase.cc:130
zypp::url::UrlBase::getAuthority
virtual std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: UrlBase.cc:660
zypp::url::UrlBase::setPathData
virtual void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: UrlBase.cc:945
zypp::str::toLower
std::string toLower(const std::string &s)
Return lowercase version of s.
Definition: String.cc:177
zypp::url::UrlBaseData::pathname
std::string pathname
Definition: UrlBase.cc:196
zypp::url::UrlBase::isValidHost
virtual bool isValidHost(const std::string &host) const
Verifies specified host or IP.
Definition: UrlBase.cc:1402
zypp::url::ParamMap
std::map< std::string, std::string > ParamMap
A parameter map container.
Definition: UrlUtils.h:47
zypp::url::UrlBase::UrlBase
UrlBase()
Definition: UrlBase.cc:265
Regex.h
zypp::url::UrlBase::getHost
virtual std::string getHost(EEncoding eflag) const
Returns the hostname or IP from the URL authority.
Definition: UrlBase.cc:743
zypp::url::UrlBase::getQueryStringVec
virtual zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: UrlBase.cc:836
zypp::url::split
void split(ParamVec &pvec, const std::string &pstr, const std::string &psep)
Split into a parameter vector.
Definition: UrlUtils.cc:165
zypp::url::ViewOption::WITH_QUERY_STR
static const ViewOption WITH_QUERY_STR
Option to include query string in the URL string.
Definition: UrlBase.h:101
RX_VALID_HOSTNAME
#define RX_VALID_HOSTNAME
Definition: UrlBase.cc:42
zypp::url::UrlBase::init
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
zypp::url::UrlBase::setQueryStringVec
virtual void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: UrlBase.cc:1289
zypp::url::UrlBase::isValidScheme
virtual bool isValidScheme(const std::string &scheme) const
Verifies specified scheme name.
Definition: UrlBase.cc:440
zypp::url::join
std::string join(const ParamVec &pvec, const std::string &psep)
Join parameter vector to a string.
Definition: UrlUtils.cc:254
zypp::url::UrlBaseData::fragment
std::string fragment
Definition: UrlBase.cc:199
zypp::url::UrlBase::getPathParamsMap
virtual zypp::url::ParamMap getPathParamsMap(EEncoding eflag) const
Returns a string map with path parameter keys and values.
Definition: UrlBase.cc:802
zypp::url::UrlBaseData::pass
std::string pass
Definition: UrlBase.cc:193
zypp::url::UrlBase::getScheme
virtual std::string getScheme() const
Returns the scheme name of the URL.
Definition: UrlBase.cc:652
zypp::url::E_ENCODED
@ E_ENCODED
Flag to request encoded string(s).
Definition: UrlUtils.h:53
zypp::url::ParamVec
std::vector< std::string > ParamVec
A parameter vector container.
Definition: UrlUtils.h:40
zypp::url::UrlBase::setHost
virtual void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition: UrlBase.cc:1082
zypp::url::UrlBase::setFragment
virtual void setFragment(const std::string &fragment, EEncoding eflag)
Set the fragment string in the URL.
Definition: UrlBase.cc:987
zypp::url::SafeQuerystr::fullStr
const std::string & fullStr() const
Definition: UrlBase.cc:143
zypp::url::UrlBase::delQueryParam
virtual void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: UrlBase.cc:1332
zypp::url::UrlBaseData::config
UrlConfig config
Definition: UrlBase.cc:188
zypp::url::UrlBase::getPathParamsVec
virtual zypp::url::ParamVec getPathParamsVec() const
Returns a vector with encoded path parameter substrings.
Definition: UrlBase.cc:781
Gettext.h
Interface to gettext.
zypp::url::UrlBase::setScheme
virtual void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: UrlBase.cc:891
zypp::url::UrlBaseData::port
std::string port
Definition: UrlBase.cc:195
zypp::url::SafeQuerystr::str
const std::string & str(const ViewOptions &viewopts_r) const
Definition: UrlBase.cc:140
zypp::url::UrlBase
Generic Url base class.
Definition: UrlBase.h:271
zypp::url::UrlBase::getUsername
virtual std::string getUsername(EEncoding eflag) const
Returns the username from the URL authority.
Definition: UrlBase.cc:721
zypp::url::SafeQuerystr::safeStr
const std::string & safeStr() const
Definition: UrlBase.cc:146
zypp::iostr::copy
std::ostream & copy(std::istream &from_r, std::ostream &to_r)
Copy istream to ostream.
Definition: IOStream.h:50
zypp::url::SafeQuerystr::SafeQuerystr
SafeQuerystr(std::string rhs)
Definition: UrlBase.cc:127
zypp::url::UrlBase::setPathParams
virtual void setPathParams(const std::string &params)
Set the path parameters.
Definition: UrlBase.cc:1227
UrlBase.h
zypp::url::UrlBase::m_data
UrlBaseData * m_data
Definition: UrlBase.h:1081
String.h
zypp::url::SafeQuerystr::SafeQuerystr
SafeQuerystr()
Definition: UrlBase.cc:124
zypp::sat::detail::size_type
SolvableIdType size_type
Definition: PoolMember.h:126
zypp::url::UrlBase::setQueryParam
virtual void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: UrlBase.cc:1323
zypp::url::UrlBase::setPort
virtual void setPort(const std::string &port)
Set the port number in the URL authority.
Definition: UrlBase.cc:1135
zypp::url::UrlBaseData::scheme
std::string scheme
Definition: UrlBase.cc:191
zypp::str::regex_match
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
str
String related utilities and Regular expression matching.
zypp::url::UrlBase::cleanupPathName
virtual std::string cleanupPathName(const std::string &path, bool authority) const
Utility method to cleanup an encoded path name.
Definition: UrlBase.cc:1350
zypp::str::toUpper
std::string toUpper(const std::string &s)
Return uppercase version of s.
Definition: String.cc:200
zypp::url::encode
std::string encode(const std::string &str, const std::string &safe, EEncoding eflag)
Encodes a string using URL percent encoding.
Definition: UrlUtils.cc:32
zypp::url::UrlBase::isValidPort
virtual bool isValidPort(const std::string &port) const
Verifies specified port number.
Definition: UrlBase.cc:1431
zypp::url::UrlBase::getQueryString
virtual std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: UrlBase.cc:697
zypp::url::ViewOption
Url::asString() view options.
Definition: UrlBase.h:40
zypp::url::UrlBase::getFragment
virtual std::string getFragment(EEncoding eflag) const
Returns the encoded fragment component of the URL.
Definition: UrlBase.cc:710
url
Url url
Definition: MediaCurl.cc:66
zypp::url::ViewOption::WITH_SCHEME
static const ViewOption WITH_SCHEME
Option to include scheme name in the URL string.
Definition: UrlBase.h:51
zypp::url::ViewOption::WITH_HOST
static const ViewOption WITH_HOST
Option to include hostname in the URL string.
Definition: UrlBase.h:74
zypp::str::regex
Regular expression.
Definition: Regex.h:95
zypp::url::UrlBaseData::UrlBaseData
UrlBaseData(const UrlConfig &conf)
Definition: UrlBase.cc:184
StringV.h
c++17: std::string_view tools
zypp::url::SafeQuerystr::_assign
void _assign(std::string &&rhs)
Definition: UrlBase.cc:150
zypp::url::SafeQuerystr
Hide passwords embedded in a querystr,.
Definition: UrlBase.cc:122
zypp::url::UrlBadComponentException
Thrown if a url component is invalid.
Definition: UrlException.h:86
zypp::url::UrlBase::setViewOptions
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: UrlBase.cc:387
zypp::url::UrlBase::getViewOptions
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: UrlBase.cc:379
zypp::url::UrlBase::setPassword
virtual void setPassword(const std::string &pass, EEncoding eflag)
Set the password in the URL authority.
Definition: UrlBase.cc:1048
zypp::url::ViewOption::WITH_PORT
static const ViewOption WITH_PORT
Option to include port number in the URL string.
Definition: UrlBase.h:81
zypp::url::ViewOption::WITH_PATH_PARAMS
static const ViewOption WITH_PATH_PARAMS
Option to include path parameters in the URL string.
Definition: UrlBase.h:95