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