git.sur5r.net Git - openldap/blob - contrib/ldapc++/src/LDAPUrl.cpp

   1 // $OpenLDAP$
   2 /*
   3  * Copyright 2000-2018 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6
   7
   8 #include "LDAPUrl.h"
   9 #include <sstream>
  10 #include <iomanip>
  11 #include "debug.h"
  12
  13 using namespace std;
  14
  15 #define PCT_ENCFLAG_NONE 0x0000U
  16 #define PCT_ENCFLAG_COMMA 0x0001U
  17 #define PCT_ENCFLAG_SLASH 0x0002U
  18
  19 #define LDAP_DEFAULT_PORT 389
  20 #define LDAPS_DEFAULT_PORT 636
  21
  22 LDAPUrl::LDAPUrl(const std::string &url)
  23 {
  24     DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPUrl::LDAPUrl()" << endl);
  25     DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER,
  26             "   url:" << url << endl);
  27     m_urlString = url;
  28     m_Filter = "";
  29     m_Scheme = "ldap";
  30     m_Scope = 0;
  31     m_Port = 0;
  32     regenerate = false;
  33     if (url != "") {
  34         this->parseUrl();
  35     }
  36 }
  37
  38 LDAPUrl::~LDAPUrl()
  39 {
  40     DEBUG(LDAP_DEBUG_DESTROY, "LDAPUrl::~LDAPUrl()" << endl);
  41     m_Attrs.clear();
  42 }
  43
  44 int LDAPUrl::getPort() const
  45 {
  46     return m_Port;
  47 }
  48
  49 void LDAPUrl::setPort(int port)
  50 {
  51     m_Port = port;
  52     regenerate = true;
  53 }
  54
  55 int LDAPUrl::getScope() const
  56 {
  57     return m_Scope;
  58 }
  59
  60 void LDAPUrl::setScope( const std::string &scope )
  61 {
  62     if (scope == "base" || scope == "" ) {
  63         m_Scope = 0;
  64     } else if (scope == "one" ) {
  65         m_Scope = 1;
  66     } else if (scope == "sub" ) {
  67         m_Scope = 2;
  68     } else {
  69         throw LDAPUrlException(LDAPUrlException::INVALID_SCOPE,
  70                 "Scope was:" + scope);
  71     }
  72     regenerate = true;
  73 }
  74
  75 const string& LDAPUrl::getURLString() const
  76 {
  77     if (regenerate){
  78         this->components2Url();
  79         regenerate=false;
  80     }
  81     return m_urlString;
  82 }
  83
  84 void LDAPUrl::setURLString( const std::string &url )
  85 {
  86     m_urlString = url;
  87     if (url != "") {
  88         this->parseUrl();
  89     }
  90     regenerate = false;
  91 }
  92
  93 const string& LDAPUrl::getHost() const
  94 {
  95     return m_Host;
  96 }
  97
  98 void LDAPUrl::setHost( const std::string &host )
  99 {
 100     m_Host = host;
 101     regenerate = true;
 102 }
 103
 104 const string& LDAPUrl::getDN() const
 105 {
 106     return m_DN;
 107 }
 108 void LDAPUrl::setDN( const std::string &dn )
 109 {
 110     m_DN = dn;
 111     regenerate = true;
 112 }
 113
 114 const string& LDAPUrl::getFilter() const
 115 {
 116     return m_Filter;
 117 }
 118 void LDAPUrl::setFilter( const std::string &filter )
 119 {
 120     m_Filter = filter;
 121     regenerate = true;
 122 }
 123
 124 const StringList& LDAPUrl::getAttrs() const
 125 {
 126     return m_Attrs;
 127 }
 128 void LDAPUrl::setAttrs( const StringList &attrs )
 129 {
 130     m_Attrs = attrs;
 131     regenerate = true;
 132 }
 133
 134 const StringList& LDAPUrl::getExtensions() const
 135 {
 136     return m_Extensions;
 137 }
 138
 139 void LDAPUrl::setExtensions( const StringList &ext )
 140 {
 141     m_Extensions = ext;
 142     regenerate = true;
 143 }
 144
 145 const std::string& LDAPUrl::getScheme() const
 146 {
 147     return m_Scheme;
 148 }
 149
 150 void LDAPUrl::setScheme( const std::string &scheme )
 151 {
 152     if (scheme == "ldap" || scheme == "ldaps" ||
 153             scheme == "ldapi" || scheme == "cldap" )
 154     {
 155         m_Scheme = scheme;
 156         regenerate = true;
 157     } else {
 158         throw LDAPUrlException(LDAPUrlException::INVALID_SCHEME,
 159                 "Unknown URL scheme: \"" + scheme + "\"");
 160     }
 161 }
 162
 163 void LDAPUrl::parseUrl()
 164 {
 165     DEBUG(LDAP_DEBUG_TRACE, "LDAPUrl::parseUrl()" << std::endl);
 166     // reading Scheme
 167     std::string::size_type pos = m_urlString.find(':');
 168     std::string::size_type startpos = pos;
 169     if (pos == std::string::npos) {
 170         throw LDAPUrlException(LDAPUrlException::INVALID_URL,
 171                 "No colon found in URL");
 172     }
 173     std::string scheme = m_urlString.substr(0, pos);
 174     DEBUG(LDAP_DEBUG_TRACE, "    scheme is <" << scheme << ">" << std::endl);
 175
 176     if ( scheme == "ldap" ) {
 177         m_Scheme = scheme;
 178     } else if ( scheme == "ldaps" ) {
 179         m_Scheme = scheme;
 180     } else if ( scheme == "ldapi" ) {
 181         m_Scheme = scheme;
 182     } else if ( scheme == "cldap" ) {
 183         m_Scheme = scheme;
 184     } else {
 185         throw LDAPUrlException(LDAPUrlException::INVALID_SCHEME,
 186                 "Unknown URL Scheme: \"" + scheme + "\"");
 187     }
 188
 189     if ( m_urlString[pos+1] != '/' || m_urlString[pos+2] != '/' ) {
 190         throw LDAPUrlException(LDAPUrlException::INVALID_URL);
 191     } else {
 192         startpos = pos + 3;
 193     }
 194     if ( m_urlString[startpos] == '/' ) {
 195         // no hostname and port
 196         startpos++;
 197     } else {
 198         std::string::size_type hostend, portstart=0;
 199         pos = m_urlString.find('/', startpos);
 200
 201         // IPv6 Address?
 202         if ( m_urlString[startpos] == '[' ) {
 203             // skip
 204             startpos++;
 205             hostend =  m_urlString.find(']', startpos);
 206             if ( hostend == std::string::npos ){
 207                 throw LDAPUrlException(LDAPUrlException::INVALID_URL);
 208             }
 209             portstart = hostend + 1;
 210         } else {
 211             hostend = m_urlString.find(':', startpos);
 212             if ( hostend == std::string::npos || portstart > pos ) {
 213                 hostend = pos;
 214             }
 215             portstart = hostend;
 216         }
 217         std::string host = m_urlString.substr(startpos, hostend - startpos);
 218         DEBUG(LDAP_DEBUG_TRACE, "    host: <" << host << ">" << std::endl);
 219         percentDecode(host, m_Host);
 220
 221         if (portstart >= m_urlString.length() || portstart >= pos ) {
 222             if ( m_Scheme == "ldap" || m_Scheme == "cldap" ) {
 223                 m_Port = LDAP_DEFAULT_PORT;
 224             } else if ( m_Scheme == "ldaps" ) {
 225                 m_Port = LDAPS_DEFAULT_PORT;
 226             }
 227         } else {
 228             std::string port = m_urlString.substr(portstart+1,
 229                     (pos == std::string::npos ? pos : pos-portstart-1) );
 230             if ( port.length() > 0 ) {
 231                 std::istringstream i(port);
 232                 i >> m_Port;
 233                 if ( i.fail() ){
 234                     throw LDAPUrlException(LDAPUrlException::INVALID_PORT);
 235                 }
 236             }
 237             DEBUG(LDAP_DEBUG_TRACE, "    Port: <" << m_Port << ">"
 238                     << std::endl);
 239         }
 240         startpos = pos + 1;
 241     }
 242     int parserMode = base;
 243     while ( pos != std::string::npos ) {
 244         pos = m_urlString.find('?', startpos);
 245         std::string actComponent = m_urlString.substr(startpos,
 246                 pos - startpos);
 247         DEBUG(LDAP_DEBUG_TRACE, "    ParserMode:" << parserMode << std::endl);
 248         DEBUG(LDAP_DEBUG_TRACE, "    ActComponent: <" << actComponent << ">"
 249                 << std::endl);
 250         std::string s_scope = "";
 251         std::string s_ext = "";
 252         switch(parserMode) {
 253             case base :
 254                 percentDecode(actComponent, m_DN);
 255                 DEBUG(LDAP_DEBUG_TRACE, "    BaseDN:" << m_DN << std::endl);
 256                 break;
 257             case attrs :
 258                 DEBUG(LDAP_DEBUG_TRACE, "    reading Attributes" << std::endl);
 259                 if (actComponent.length() != 0 ) {
 260                     string2list(actComponent,m_Attrs, true);
 261                 }
 262                 break;
 263             case scope :
 264                 percentDecode(actComponent, s_scope);
 265                 if (s_scope == "base" || s_scope == "" ) {
 266                     m_Scope = 0;
 267                 } else if (s_scope == "one" ) {
 268                     m_Scope = 1;
 269                 } else if (s_scope == "sub" ) {
 270                     m_Scope = 2;
 271                 } else {
 272                     throw LDAPUrlException(LDAPUrlException::INVALID_SCOPE);
 273                 }
 274                 DEBUG(LDAP_DEBUG_TRACE, "    Scope: <" << s_scope << ">"
 275                         << std::endl);
 276                 break;
 277             case filter :
 278                 percentDecode(actComponent, m_Filter);
 279                 DEBUG(LDAP_DEBUG_TRACE, "    filter: <" << m_Filter << ">"
 280                         << std::endl);
 281                 break;
 282             case extensions :
 283                 DEBUG(LDAP_DEBUG_TRACE, "    reading Extensions" << std::endl);
 284                 string2list(actComponent, m_Extensions, true);
 285                 break;
 286             default :
 287                 DEBUG(LDAP_DEBUG_TRACE, "    unknown state" << std::endl);
 288                 break;
 289         }
 290         startpos = pos + 1;
 291         parserMode++;
 292     }
 293 }
 294
 295 void LDAPUrl::percentDecode(const std::string& src, std::string &out)
 296 {
 297     DEBUG(LDAP_DEBUG_TRACE, "LDAPUrl::percentDecode()" << std::endl);
 298     std::string::size_type pos = 0;
 299     std::string::size_type startpos = 0;
 300     pos = src.find('%', startpos);
 301     while ( pos != std::string::npos ) {
 302         out += src.substr(startpos, pos - startpos);
 303         std::string istr(src.substr(pos+1, 2));
 304         std::istringstream i(istr);
 305         i.setf(std::ios::hex, std::ios::basefield);
 306         i.unsetf(std::ios::showbase);
 307         int hex;
 308         i >> hex;
 309         if ( i.fail() ){
 310             throw LDAPUrlException(LDAPUrlException::URL_DECODING_ERROR,
 311                     "Invalid percent encoding");
 312         }
 313         char j = hex;
 314         out.push_back(j);
 315         startpos = pos+3;
 316         pos = src.find('%', startpos);
 317     }
 318     out += src.substr(startpos, pos - startpos);
 319 }
 320
 321 void LDAPUrl::string2list(const std::string &src, StringList& sl,
 322             bool percentDecode)
 323 {
 324     std::string::size_type comma_startpos = 0;
 325     std::string::size_type comma_pos = 0;
 326     std::string actItem;
 327     while ( comma_pos != std::string::npos ) {
 328         comma_pos = src.find(',', comma_startpos);
 329         actItem = src.substr(comma_startpos, comma_pos - comma_startpos);
 330         if (percentDecode){
 331             std::string decoded;
 332             this->percentDecode(actItem,decoded);
 333             actItem = decoded;
 334         }
 335         sl.add(actItem);
 336         comma_startpos = comma_pos + 1;
 337     }
 338 }
 339
 340
 341 void LDAPUrl::components2Url() const
 342 {
 343     std::ostringstream url;
 344     std::string encoded = "";
 345
 346     url << m_Scheme << "://";
 347     // IPv6 ?
 348     if ( m_Host.find( ':', 0 ) != std::string::npos ) {
 349         url <<  "[" << this->percentEncode(m_Host, encoded) <<  "]";
 350     } else {
 351         url << this->percentEncode(m_Host, encoded, PCT_ENCFLAG_SLASH);
 352     }
 353
 354     if ( m_Port != 0 ) {
 355         url << ":" << m_Port;
 356     }
 357
 358     url << "/";
 359     encoded = "";
 360     if ( m_DN != "" ) {
 361         this->percentEncode( m_DN, encoded );
 362         url << encoded;
 363     }
 364     string qm = "";
 365     if ( ! m_Attrs.empty() ){
 366         url << "?";
 367         bool first = true;
 368         for ( StringList::const_iterator i = m_Attrs.begin();
 369                 i != m_Attrs.end(); i++)
 370         {
 371             this->percentEncode( *i, encoded );
 372             if ( ! first ) {
 373                 url << ",";
 374             } else {
 375                 first = false;
 376             }
 377             url << encoded;
 378         }
 379     } else {
 380         qm.append("?");
 381     }
 382     if ( m_Scope == 1 ) {
 383         url << qm << "?one";
 384         qm = "";
 385     } else if ( m_Scope == 2 ) {
 386         url << qm << "?sub";
 387         qm = "";
 388     } else {
 389         qm.append("?");
 390     }
 391     if (m_Filter != "" ){
 392         this->percentEncode( m_Filter, encoded );
 393         url << qm << "?" << encoded;
 394         qm = "";
 395     } else {
 396         qm.append("?");
 397     }
 398
 399     if ( ! m_Extensions.empty() ){
 400         url << qm << "?";
 401         bool first = true;
 402         for ( StringList::const_iterator i = m_Extensions.begin();
 403                 i != m_Extensions.end(); i++)
 404         {
 405             this->percentEncode( *i, encoded, 1);
 406             if ( ! first ) {
 407                 url << ",";
 408             } else {
 409                 first = false;
 410             }
 411             url << encoded;
 412         }
 413     }
 414     m_urlString=url.str();
 415 }
 416
 417
 418 std::string& LDAPUrl::percentEncode( const std::string &src,
 419         std::string &dest,
 420         int flags) const
 421 {
 422     std::ostringstream o;
 423     o.setf(std::ios::hex, std::ios::basefield);
 424     o.setf(std::ios::uppercase);
 425     o.unsetf(std::ios::showbase);
 426     bool escape=false;
 427     for ( std::string::const_iterator i = src.begin(); i != src.end(); i++ ){
 428         switch(*i){
 429             /* reserved */
 430             case '?' :
 431                 escape = true;
 432             break;
 433             case ',' :
 434                 if ( flags & PCT_ENCFLAG_COMMA ) {
 435                     escape = true;
 436                 } else {
 437                     escape = false;
 438                 }
 439             break;
 440             case ':' :
 441             case '/' :
 442                 if ( flags & PCT_ENCFLAG_SLASH ) {
 443                     escape = true;
 444                 } else {
 445                     escape = false;
 446                 }
 447             break;
 448             case '#' :
 449             case '[' :
 450             case ']' :
 451             case '@' :
 452             case '!' :
 453             case '$' :
 454             case '&' :
 455             case '\'' :
 456             case '(' :
 457             case ')' :
 458             case '*' :
 459             case '+' :
 460             case ';' :
 461             case '=' :
 462             /* unreserved */
 463             case '-' :
 464             case '.' :
 465             case '_' :
 466             case '~' :
 467                 escape = false;
 468             break;
 469             default :
 470                 if (  std::isalnum(*i) ) {
 471                     escape = false;
 472                 } else {
 473                     escape = true;
 474                 }
 475             break;
 476         }
 477         if ( escape ) {
 478             o << "%" << std::setw(2) << std::setfill('0') << (int)(unsigned char)*i ;
 479         } else {
 480             o.put(*i);
 481         }
 482     }
 483     dest = o.str();
 484     return dest;
 485 }
 486
 487 const code2string_s LDAPUrlException::code2string[] = {
 488    { INVALID_SCHEME,            "Invalid URL Scheme" },
 489    { INVALID_PORT,              "Invalid Port in Url" },
 490    { INVALID_SCOPE,             "Invalid Search Scope in Url" },
 491    { INVALID_URL,               "Invalid LDAP Url" },
 492    { URL_DECODING_ERROR,        "Url-decoding Error" },
 493    { 0, 0 }
 494 };
 495
 496 LDAPUrlException::LDAPUrlException( int code, const std::string &msg) :
 497     m_code(code), m_addMsg(msg) {}
 498
 499 int LDAPUrlException::getCode() const
 500 {
 501     return m_code;
 502 }
 503
 504 const std::string LDAPUrlException::getAdditionalInfo() const
 505 {
 506     return m_addMsg;
 507 }
 508
 509 const std::string LDAPUrlException::getErrorMessage() const
 510 {
 511     for ( int i = 0; code2string[i].string != 0; i++ ) {
 512         if ( code2string[i].code == m_code ) {
 513             return std::string(code2string[i].string);
 514         }
 515     }
 516     return "";
 517
 518 }