libzypp: zypp/Url.cc Source File

libzypp 17.25.10

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 };
99 zypp::url::ParamMap pmap;
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
185 ref->setViewOptions( zypp::url::ViewOption::DEFAULTS -
186 zypp::url::ViewOption::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 // -----------------------------------------------------------------
282 Url::~Url()
283 {
284 }
285
286
287 // -----------------------------------------------------------------
288 Url::Url()
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 {
300 ZYPP_THROW(url::UrlException(
301 _("Unable to clone Url object")
302 ));
303 }
304 }
305
306
307 // -----------------------------------------------------------------
308 Url::Url(const zypp::url::UrlRef &url)
309 : m_impl( url)
310 {
311 if( !m_impl)
312 {
313 ZYPP_THROW(url::UrlException(
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 {
326 ZYPP_THROW(url::UrlParsingException(
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 {
340 ZYPP_THROW(url::UrlParsingException(
341 _("Unable to parse Url components")
342 ));
343 }
344 m_impl = url;
345 return *this;
346 }
347
348
349 // -----------------------------------------------------------------
350 Url&
351 Url::operator = (const Url &url)
352 {
353 m_impl = url.m_impl;
354 return *this;
355 }
356
357
358 // -----------------------------------------------------------------
359 // static
360 bool
361 Url::registerScheme(const std::string &scheme,
362 UrlRef urlImpl)
363 {
364 return g_urlSchemeRepository().addUrlByScheme(scheme, urlImpl);
365 }
366
367
368 // -----------------------------------------------------------------
369 // static
370 UrlRef
371 Url::parseUrl(const std::string &encodedUrl)
372 {
373 UrlRef url;
374 str::smatch out;
375 bool ret = false;
376
377 try
378 {
379 str::regex rex(RX_SPLIT_URL);
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
414 zypp::url::UrlSchemes
415 Url::getRegisteredSchemes()
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 // -----------------------------------------------------------------
431 zypp::url::UrlSchemes
432 Url::getKnownSchemes() const
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
492 Url::asString() const
493 {
494 return m_impl->asString();
495 }
496
497
498 // -----------------------------------------------------------------
499 std::string
500 Url::asCompleteString() const
501 {
502 // make sure, all url components are included;
503 // regardless of the current configuration...
504 ViewOptions opts(getViewOptions() +
505 ViewOption::WITH_SCHEME +
506 ViewOption::WITH_USERNAME +
507 ViewOption::WITH_PASSWORD +
508 ViewOption::WITH_HOST +
509 ViewOption::WITH_PORT +
510 ViewOption::WITH_PATH_NAME +
511 ViewOption::WITH_PATH_PARAMS +
512 ViewOption::WITH_QUERY_STR +
513 ViewOption::WITH_FRAGMENT);
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
528 Url::getScheme() const
529 {
530 return m_impl->getScheme();
531 }
532
533
534 // -----------------------------------------------------------------
535 std::string
536 Url::getAuthority() const
537 {
538 return m_impl->getAuthority();
539 }
540
541 // -----------------------------------------------------------------
542 std::string
543 Url::getPathData() const
544 {
545 return m_impl->getPathData();
546 }
547
548
549 // -----------------------------------------------------------------
550 std::string
551 Url::getQueryString() const
552 {
553 return m_impl->getQueryString();
554 }
555
556
557 // -----------------------------------------------------------------
558 std::string
559 Url::getFragment(zypp::url::EEncoding eflag) const
560 {
561 return m_impl->getFragment(eflag);
562 }
563
564
565 // -----------------------------------------------------------------
566 std::string
567 Url::getUsername(EEncoding eflag) const
568 {
569 return m_impl->getUsername(eflag);
570 }
571
572
573 // -----------------------------------------------------------------
574 std::string
575 Url::getPassword(EEncoding eflag) const
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
599 Url::getPathName(EEncoding eflag) const
600 {
601 return m_impl->getPathName(eflag);
602 }
603
604
605 // -----------------------------------------------------------------
606 std::string
607 Url::getPathParams() const
608 {
609 return m_impl->getPathParams();
610 }
611
612
613 // -----------------------------------------------------------------
614 zypp::url::ParamVec
615 Url::getPathParamsVec() const
616 {
617 return m_impl->getPathParamsVec();
618 }
619
620
621 // -----------------------------------------------------------------
622 zypp::url::ParamMap
623 Url::getPathParamsMap(EEncoding eflag) const
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 // -----------------------------------------------------------------
638 zypp::url::ParamVec
639 Url::getQueryStringVec() const
640 {
641 return m_impl->getQueryStringVec();
642 }
643
644
645 // -----------------------------------------------------------------
646 zypp::url::ParamMap
647 Url::getQueryStringMap(EEncoding eflag) const
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(),
684 m_impl->getQueryString(),
685 m_impl->getFragment(zypp::url::E_ENCODED)
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
766 Url::setPathName(const Pathname &path,
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
794 Url::setPathParamsVec(const zypp::url::ParamVec &pvec)
795 {
796 m_impl->setPathParamsVec(pvec);
797 }
798
799
800 // -----------------------------------------------------------------
801 void
802 Url::setPathParamsMap(const zypp::url::ParamMap &pmap)
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
818 Url::setQueryStringVec(const zypp::url::ParamVec &pvec)
819 {
820 m_impl->setQueryStringVec(pvec);
821 }
822
823
824 // -----------------------------------------------------------------
825 void
826 Url::setQueryStringMap(const zypp::url::ParamMap &pmap)
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 // -----------------------------------------------------------------
846 ViewOptions
847 Url::getViewOptions() const
848 {
849 return m_impl->getViewOptions();
850 }
851
852 // -----------------------------------------------------------------
853 void
854 Url::setViewOptions(const ViewOptions &vopts)
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
880 namespace hotfix1050625 {
881 std::string asString( const Url & url_r )
882 { return url_r.m_impl->asString1050625(); }
883 }
884
886 } // namespace zypp
888 /*
889 ** vim: set ts=2 sts=2 sw=2 ai et:
890 */
arrayBegin
#define arrayBegin(A)
Simple C-array iterator.
Definition: Easy.h:41
arrayEnd
#define arrayEnd(A)
Definition: Easy.h:43
ZYPP_THROW
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
Gettext.h
Interface to gettext.
_
#define _(MSG)
Definition: Gettext.h:37
url
Url url
Definition: MediaCurl.cc:66
Pathname.h
Regex.h
String.h
RX_SPLIT_URL
#define RX_SPLIT_URL
Definition: Url.cc:34
urlByScheme
UrlBySchemeMap urlByScheme
Definition: Url.cc:169
Url.h
zypp::Url
Url manipulation class.
Definition: Url.h:92
zypp::Url::getScheme
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:528
zypp::Url::asCompleteString
std::string asCompleteString() const
Returns a complete string representation of the Url object.
Definition: Url.cc:500
zypp::Url::setViewOptions
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: Url.cc:854
zypp::Url::setAuthority
void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: Url.cc:693
zypp::Url::getPathParamsMap
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
zypp::Url::getPathParamsVec
zypp::url::ParamVec getPathParamsVec() const
Returns a vector with path parameter substrings.
Definition: Url.cc:615
zypp::Url::setQueryString
void setQueryString(const std::string &querystr)
Set the query string in the URL.
Definition: Url.cc:709
zypp::Url::schemeIsRemote
bool schemeIsRemote() const
Definition: Url.h:266
zypp::Url::getPathParams
std::string getPathParams() const
Returns the path parameters from the URL.
Definition: Url.cc:607
zypp::Url::asString
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:492
zypp::Url::getPathData
std::string getPathData() const
Returns the encoded path component of the URL.
Definition: Url.cc:543
zypp::Url::getPathParam
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
zypp::Url::getAuthority
std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: Url.cc:536
zypp::Url::getUsername
std::string getUsername(EEncoding eflag=zypp::url::E_DECODED) const
Returns the username from the URL authority.
Definition: Url.cc:567
zypp::Url::isRegisteredScheme
static bool isRegisteredScheme(const std::string &scheme)
Returns if scheme name is registered.
Definition: Url.cc:424
zypp::Url::setFragment
void setFragment(const std::string &fragment, EEncoding eflag=zypp::url::E_DECODED)
Set the fragment string in the URL.
Definition: Url.cc:717
zypp::Url::getPathName
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:599
zypp::Url::setQueryStringVec
void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: Url.cc:818
zypp::Url::Url
Url()
Definition: Url.cc:288
zypp::Url::getQueryParam
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
zypp::Url::setPathName
void setPathName(const std::string &path, EEncoding eflag=zypp::url::E_DECODED)
Set the path name.
Definition: Url.cc:759
zypp::Url::setPathParamsMap
void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: Url.cc:802
zypp::Url::getViewOptions
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: Url.cc:847
zypp::Url::schemeIsDownloading
bool schemeIsDownloading() const
Definition: Url.h:276
zypp::Url::setPathData
void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: Url.cc:701
zypp::Url::getHost
std::string getHost(EEncoding eflag=zypp::url::E_DECODED) const
Returns the hostname or IP from the URL authority.
Definition: Url.cc:583
zypp::Url::m_impl
url::UrlRef m_impl
Definition: Url.h:829
zypp::Url::setHost
void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition: Url.cc:743
zypp::Url::setPort
void setPort(const std::string &port)
Set the port number in the URL authority.
Definition: Url.cc:751
zypp::Url::~Url
~Url()
Definition: Url.cc:282
zypp::Url::delQueryParam
void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: Url.cc:840
zypp::Url::setPathParamsVec
void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: Url.cc:794
zypp::Url::isValid
bool isValid() const
Verifies the Url.
Definition: Url.cc:484
zypp::Url::getFragment
std::string getFragment(EEncoding eflag=zypp::url::E_DECODED) const
Returns the encoded fragment component of the URL.
Definition: Url.cc:559
zypp::Url::parseUrl
static url::UrlRef parseUrl(const std::string &encodedUrl)
Parse a percent-encoded URL string.
Definition: Url.cc:371
zypp::Url::setPathParam
void setPathParam(const std::string &param, const std::string &value)
Set or add value for the specified path parameter.
Definition: Url.cc:810
zypp::Url::setPassword
void setPassword(const std::string &pass, EEncoding eflag=zypp::url::E_DECODED)
Set the password in the URL authority.
Definition: Url.cc:734
zypp::Url::setPathParams
void setPathParams(const std::string &params)
Set the path parameters.
Definition: Url.cc:786
zypp::Url::operator=
Url & operator=(const std::string &encodedUrl)
Assigns parsed percent-encoded URL string to the object.
Definition: Url.cc:335
zypp::Url::registerScheme
static bool registerScheme(const std::string &scheme, url::UrlRef urlImpl)
Register a scheme-specific implementation.
Definition: Url.cc:361
zypp::Url::getQueryString
std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: Url.cc:551
zypp::Url::isValidScheme
bool isValidScheme(const std::string &scheme) const
Verifies the specified scheme name.
Definition: Url.cc:440
zypp::Url::setQueryParam
void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: Url.cc:833
zypp::Url::getRegisteredSchemes
static zypp::url::UrlSchemes getRegisteredSchemes()
Returns all registered scheme names.
Definition: Url.cc:415
zypp::Url::getQueryStringVec
zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: Url.cc:639
zypp::Url::schemeIsLocal
bool schemeIsLocal() const
Definition: Url.h:261
zypp::Url::setUsername
void setUsername(const std::string &user, EEncoding eflag=zypp::url::E_DECODED)
Set the username in the URL authority.
Definition: Url.cc:725
zypp::Url::getKnownSchemes
zypp::url::UrlSchemes getKnownSchemes() const
Returns scheme names known to this object.
Definition: Url.cc:432
zypp::Url::appendPathName
void appendPathName(const Pathname &path_r, EEncoding eflag_r=zypp::url::E_DECODED)
Extend the path name.
Definition: Url.cc:781
zypp::Url::setScheme
void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: Url.cc:663
zypp::Url::getPassword
std::string getPassword(EEncoding eflag=zypp::url::E_DECODED) const
Returns the password from the URL authority.
Definition: Url.cc:575
zypp::Url::schemeIsVolatile
bool schemeIsVolatile() const
Definition: Url.h:271
zypp::Url::getQueryStringMap
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
zypp::Url::getPort
std::string getPort() const
Returns the port from the URL authority.
Definition: Url.cc:591
zypp::Url::setQueryStringMap
void setQueryStringMap(const zypp::url::ParamMap &qmap)
Set the query parameters.
Definition: Url.cc:826
zypp::filesystem::Pathname
Pathname.
Definition: Pathname.h:45
zypp::filesystem::Pathname::emptyOrRoot
bool emptyOrRoot() const
Test for "" or "/".
Definition: Pathname.h:121
zypp::filesystem::Pathname::asString
const std::string & asString() const
String representation.
Definition: Pathname.h:91
zypp::str::regex
Regular expression.
Definition: Regex.h:95
zypp::str::smatch
Regular expression match result.
Definition: Regex.h:163
zypp::str::smatch::size
unsigned size() const
Definition: Regex.cc:106
zypp::url::UrlBase
Generic Url base class.
Definition: UrlBase.h:271
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::getQueryString
virtual std::string getQueryString() const
Returns the encoded query string component of the URL.
Definition: UrlBase.cc:697
zypp::url::UrlBase::getPort
virtual std::string getPort() const
Returns the port number from the URL authority.
Definition: UrlBase.cc:754
zypp::url::UrlBase::setScheme
virtual void setScheme(const std::string &scheme)
Set the scheme name in the URL.
Definition: UrlBase.cc:891
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::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::UrlBase::getPathParamsVec
virtual zypp::url::ParamVec getPathParamsVec() const
Returns a vector with encoded path parameter substrings.
Definition: UrlBase.cc:781
zypp::url::UrlBase::getUsername
virtual std::string getUsername(EEncoding eflag) const
Returns the username from the URL authority.
Definition: UrlBase.cc:721
zypp::url::UrlBase::getKnownSchemes
virtual UrlSchemes getKnownSchemes() const
Returns scheme names known by this object.
Definition: UrlBase.cc:415
zypp::url::UrlBase::getAuthority
virtual std::string getAuthority() const
Returns the encoded authority component of the URL.
Definition: UrlBase.cc:660
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::config
std::string config(const std::string &opt) const
Get the value of a UrlBase configuration variable.
Definition: UrlBase.cc:367
zypp::url::UrlBase::setPathParamsVec
virtual void setPathParamsVec(const zypp::url::ParamVec &pvec)
Set the path parameters.
Definition: UrlBase.cc:1244
zypp::url::UrlBase::getFragment
virtual std::string getFragment(EEncoding eflag) const
Returns the encoded fragment component of the URL.
Definition: UrlBase.cc:710
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::UrlBase::getPassword
virtual std::string getPassword(EEncoding eflag) const
Returns the password from the URL authority.
Definition: UrlBase.cc:732
zypp::url::UrlBase::getScheme
virtual std::string getScheme() const
Returns the scheme name of the URL.
Definition: UrlBase.cc:652
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::setUsername
virtual void setUsername(const std::string &user, EEncoding eflag)
Set the username in the URL authority.
Definition: UrlBase.cc:1014
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::UrlBase::setPathParamsMap
virtual void setPathParamsMap(const zypp::url::ParamMap &pmap)
Set the path parameters.
Definition: UrlBase.cc:1257
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::isKnownScheme
virtual bool isKnownScheme(const std::string &scheme) const
Returns if scheme name is known to this object.
Definition: UrlBase.cc:423
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::setPathData
virtual void setPathData(const std::string &pathdata)
Set the path data component in the URL.
Definition: UrlBase.cc:945
zypp::url::UrlBase::setPathName
virtual void setPathName(const std::string &path, EEncoding eflag)
Set the path name.
Definition: UrlBase.cc:1167
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::UrlBase::getPathData
virtual std::string getPathData() const
Returns the encoded path component of the URL.
Definition: UrlBase.cc:687
zypp::url::UrlBase::isValid
virtual bool isValid() const
Verifies the Url.
Definition: UrlBase.cc:472
zypp::url::UrlBase::getPathName
virtual std::string getPathName(EEncoding eflag) const
Returns the path name from the URL.
Definition: UrlBase.cc:762
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::UrlBase::isValidScheme
virtual bool isValidScheme(const std::string &scheme) const
Verifies specified scheme name.
Definition: UrlBase.cc:440
zypp::url::UrlBase::getQueryStringVec
virtual zypp::url::ParamVec getQueryStringVec() const
Returns a vector with query string parameter substrings.
Definition: UrlBase.cc:836
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::UrlBase::setViewOptions
void setViewOptions(const ViewOptions &vopts)
Change the view options of the current object.
Definition: UrlBase.cc:387
zypp::url::UrlBase::setQueryStringVec
virtual void setQueryStringVec(const zypp::url::ParamVec &qvec)
Set the query parameters.
Definition: UrlBase.cc:1289
zypp::url::UrlBase::delQueryParam
virtual void delQueryParam(const std::string &param)
remove the specified query parameter.
Definition: UrlBase.cc:1332
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::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::setPathParams
virtual void setPathParams(const std::string &params)
Set the path parameters.
Definition: UrlBase.cc:1227
zypp::url::UrlBase::asString1050625
std::string asString1050625() const
Definition: UrlBase.cc:509
zypp::url::UrlBase::setAuthority
virtual void setAuthority(const std::string &authority)
Set the authority component in the URL.
Definition: UrlBase.cc:915
zypp::url::UrlBase::getViewOptions
ViewOptions getViewOptions() const
Return the view options of the current object.
Definition: UrlBase.cc:379
zypp::url::UrlException
Base class for all URL exceptions.
Definition: UrlException.h:32
zypp::url::UrlParsingException
Thrown if the url or a component can't be parsed at all.
Definition: UrlException.h:68
str
String related utilities and Regular expression matching.
zypp::hotfix1050625::asString
std::string asString(const Url &url_r)
Definition: Url.cc:881
zypp::sat::detail::size_type
SolvableIdType size_type
Definition: PoolMember.h:126
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
zypp::str::form
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
zypp::str::toLower
std::string toLower(const std::string &s)
Return lowercase version of s.
Definition: String.cc:177
zypp::url
Url details namespace.
Definition: UrlBase.cc:57
zypp::url::UrlRef
RWCOW_pointer< UrlBase > UrlRef
Copy-On-Write Url reference.
Definition: UrlBase.h:1089
zypp::url::UrlSchemes
std::vector< std::string > UrlSchemes
Vector of URL scheme names.
Definition: UrlBase.h:251
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::ParamMap
std::map< std::string, std::string > ParamMap
A parameter map container.
Definition: UrlUtils.h:47
zypp::url::ParamVec
std::vector< std::string > ParamVec
A parameter vector container.
Definition: UrlUtils.h:40
zypp::url::EEncoding
EEncoding
Encoding flags.
Definition: UrlUtils.h:52
zypp::url::E_ENCODED
@ E_ENCODED
Flag to request encoded string(s).
Definition: UrlUtils.h:53
zypp::url::decode
std::string decode(const std::string &str, bool allowNUL)
Decodes a URL percent encoded string.
Definition: UrlUtils.cc:87
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
zypp::operator<
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
Definition: StrMatcher.cc:335
zypp::operator==
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: SetRelationMixin.h:84
zypp::operator<<
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
zypp::operator!=
bool operator!=(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: SetRelationMixin.h:109
zypp::RWCOW_pointer< UrlBase >
zypp::RWCOW_pointer::reset
void reset()
Definition: PtrTypes.h:482
zypp::url::ViewOption
Url::asString() view options.
Definition: UrlBase.h:40
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_PORT
static const ViewOption WITH_PORT
Option to include port number in the URL string.
Definition: UrlBase.h:81
zypp::url::ViewOption::WITH_PASSWORD
static const ViewOption WITH_PASSWORD
Option to include password in the URL string.
Definition: UrlBase.h:67
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
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::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::ViewOption::EMPTY_AUTHORITY
static const ViewOption EMPTY_AUTHORITY
Explicitely include the URL authority separator "//".
Definition: UrlBase.h:121
zypp::url::ViewOption::DEFAULTS
static const ViewOption DEFAULTS
Default combination of view options.
Definition: UrlBase.h:177
zypp::url::ViewOption::WITH_USERNAME
static const ViewOption WITH_USERNAME
Option to include username in the URL string.
Definition: UrlBase.h:58
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
zypp::url::ViewOption::WITH_HOST
static const ViewOption WITH_HOST
Option to include hostname in the URL string.
Definition: UrlBase.h:74