zypp/url/UrlBase.cc

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