From d485c8e76758c68ce55e9554d339eaf715ae7bca Mon Sep 17 00:00:00 2001 From: Tatsuhiro Tsujikawa Date: Wed, 26 Jun 2013 21:45:29 +0900 Subject: Rewrite AuthConfig objects using std::unique_ptr --- src/AuthConfigFactory.cc | 162 ++++++++++++++++++++++------------------------- 1 file changed, 75 insertions(+), 87 deletions(-) (limited to 'src/AuthConfigFactory.cc') diff --git a/src/AuthConfigFactory.cc b/src/AuthConfigFactory.cc index 802ad367..784e9ba4 100644 --- a/src/AuthConfigFactory.cc +++ b/src/AuthConfigFactory.cc @@ -56,33 +56,32 @@ AuthConfigFactory::AuthConfigFactory() {} AuthConfigFactory::~AuthConfigFactory() {} -std::shared_ptr +std::unique_ptr AuthConfigFactory::createAuthConfig (const std::shared_ptr& request, const Option* op) { if(request->getProtocol() == "http" || request->getProtocol() == "https") { - if(op->getAsBool(PREF_HTTP_AUTH_CHALLENGE)) { if(!request->getUsername().empty()) { - std::shared_ptr bc(new BasicCred(request->getUsername(), - request->getPassword(), - request->getHost(), - request->getPort(), - request->getDir(), true)); - updateBasicCred(bc); - return createAuthConfig(request->getUsername(), request->getPassword()); + updateBasicCred(make_unique(request->getUsername(), + request->getPassword(), + request->getHost(), + request->getPort(), + request->getDir(), true)); + return AuthConfig::create(request->getUsername(), + request->getPassword()); } - BasicCredSet::iterator i = - findBasicCred(request->getHost(), request->getPort(), - request->getDir()); - if(i == basicCreds_.end()) { - return std::shared_ptr(); + auto i = findBasicCred(request->getHost(), request->getPort(), + request->getDir()); + if(i == std::end(basicCreds_)) { + return std::unique_ptr(); } else { - return createAuthConfig((*i)->user_, (*i)->password_); + return AuthConfig::create((*i)->user_, (*i)->password_); } } else { if(!request->getUsername().empty()) { - return createAuthConfig(request->getUsername(), request->getPassword()); + return AuthConfig::create(request->getUsername(), + request->getPassword()); } else { return createHttpAuthResolver(op)->resolveAuthConfig(request->getHost()); @@ -91,93 +90,80 @@ AuthConfigFactory::createAuthConfig } else if(request->getProtocol() == "ftp") { if(!request->getUsername().empty()) { if(request->hasPassword()) { - return createAuthConfig(request->getUsername(), request->getPassword()); + return AuthConfig::create(request->getUsername(), + request->getPassword()); } else { if(!op->getAsBool(PREF_NO_NETRC)) { // First, check we have password corresponding to host and // username NetrcAuthResolver authResolver; - authResolver.setNetrc(netrc_); + authResolver.setNetrc(netrc_.get()); - std::shared_ptr ac = - authResolver.resolveAuthConfig(request->getHost()); + auto ac = authResolver.resolveAuthConfig(request->getHost()); if(ac && ac->getUser() == request->getUsername()) { return ac; } } // We don't have password for host and username. Return // password specified by --ftp-passwd - return - createAuthConfig(request->getUsername(), op->get(PREF_FTP_PASSWD)); + return AuthConfig::create(request->getUsername(), + op->get(PREF_FTP_PASSWD)); } } else { return createFtpAuthResolver(op)->resolveAuthConfig(request->getHost()); } } else { - return std::shared_ptr(); - } -} - -std::shared_ptr -AuthConfigFactory::createAuthConfig(const std::string& user, const std::string& password) const -{ - std::shared_ptr ac; - if(!user.empty()) { - ac.reset(new AuthConfig(user, password)); + return std::unique_ptr(); } - return ac; } -std::shared_ptr AuthConfigFactory::createHttpAuthResolver +std::unique_ptr AuthConfigFactory::createHttpAuthResolver (const Option* op) const { - AbstractAuthResolver* resolver; + std::unique_ptr resolver; if(op->getAsBool(PREF_NO_NETRC)) { - resolver = new DefaultAuthResolver(); + resolver.reset(new DefaultAuthResolver()); } else { - NetrcAuthResolver* authResolver(new NetrcAuthResolver()); - authResolver->setNetrc(netrc_); + auto authResolver = make_unique(); + authResolver->setNetrc(netrc_.get()); authResolver->ignoreDefault(); - resolver = authResolver; + resolver = std::move(authResolver); } - resolver->setUserDefinedAuthConfig - (createAuthConfig(op->get(PREF_HTTP_USER), op->get(PREF_HTTP_PASSWD))); - return std::shared_ptr(resolver); + resolver->setUserDefinedCred(op->get(PREF_HTTP_USER), + op->get(PREF_HTTP_PASSWD)); + return std::move(resolver); } -std::shared_ptr AuthConfigFactory::createFtpAuthResolver +std::unique_ptr AuthConfigFactory::createFtpAuthResolver (const Option* op) const { - AbstractAuthResolver* resolver; + std::unique_ptr resolver; if(op->getAsBool(PREF_NO_NETRC)) { - resolver = new DefaultAuthResolver(); + resolver.reset(new DefaultAuthResolver()); } else { - NetrcAuthResolver* authResolver(new NetrcAuthResolver()); - authResolver->setNetrc(netrc_); - resolver = authResolver; + auto authResolver = make_unique(); + authResolver->setNetrc(netrc_.get()); + resolver = std::move(authResolver); } - resolver->setUserDefinedAuthConfig - (createAuthConfig(op->get(PREF_FTP_USER), op->get(PREF_FTP_PASSWD))); - std::shared_ptr defaultAuthConfig - (new AuthConfig(AUTH_DEFAULT_USER, AUTH_DEFAULT_PASSWD)); - resolver->setDefaultAuthConfig(defaultAuthConfig); - return std::shared_ptr(resolver); + resolver->setUserDefinedCred(op->get(PREF_FTP_USER), + op->get(PREF_FTP_PASSWD)); + resolver->setDefaultCred(AUTH_DEFAULT_USER, AUTH_DEFAULT_PASSWD); + return std::move(resolver); } -void AuthConfigFactory::setNetrc(const std::shared_ptr& netrc) +void AuthConfigFactory::setNetrc(std::unique_ptr netrc) { - netrc_ = netrc; + netrc_ = std::move(netrc); } -void AuthConfigFactory::updateBasicCred -(const std::shared_ptr& basicCred) +void AuthConfigFactory::updateBasicCred(std::unique_ptr basicCred) { - BasicCredSet::iterator i = basicCreds_.lower_bound(basicCred); - if(i != basicCreds_.end() && *(*i) == *basicCred) { - *(*i) = *basicCred; + auto i = basicCreds_.lower_bound(basicCred); + if(i != std::end(basicCreds_) && *i == basicCred) { + *(*i) = std::move(*basicCred); } else { - basicCreds_.insert(i, basicCred); + basicCreds_.insert(i, std::move(basicCred)); } } @@ -187,17 +173,15 @@ bool AuthConfigFactory::activateBasicCred const std::string& path, const Option* op) { - BasicCredSet::iterator i = findBasicCred(host, port, path); - if(i == basicCreds_.end()) { - std::shared_ptr authConfig = - createHttpAuthResolver(op)->resolveAuthConfig(host); + auto i = findBasicCred(host, port, path); + if(i == std::end(basicCreds_)) { + auto authConfig = createHttpAuthResolver(op)->resolveAuthConfig(host); if(!authConfig) { return false; } else { - std::shared_ptr bc - (new BasicCred(authConfig->getUser(), authConfig->getPassword(), - host, port, path, true)); - basicCreds_.insert(bc); + basicCreds_.insert(make_unique(authConfig->getUser(), + authConfig->getPassword(), + host, port, path, true)); return true; } } else { @@ -206,55 +190,59 @@ bool AuthConfigFactory::activateBasicCred } } -AuthConfigFactory::BasicCred::BasicCred -(const std::string& user, const std::string& password, - const std::string& host, uint16_t port, const std::string& path, - bool activated): - user_(user), password_(password), - host_(host), port_(port), path_(path), activated_(activated) +BasicCred::BasicCred +(std::string user, std::string password, + std::string host, uint16_t port, std::string path, + bool activated) + : user_(std::move(user)), + password_(std::move(password)), + host_(std::move(host)), + port_(port), + path_(std::move(path)), + activated_(activated) { if(path_.empty() || path_[path_.size()-1] != '/') { path_ += "/"; } } -void AuthConfigFactory::BasicCred::activate() +void BasicCred::activate() { activated_ = true; } -bool AuthConfigFactory::BasicCred::isActivated() const +bool BasicCred::isActivated() const { return activated_; } -bool AuthConfigFactory::BasicCred::operator==(const BasicCred& cred) const +bool BasicCred::operator==(const BasicCred& cred) const { return host_ == cred.host_ && port_ == cred.port_ && path_ == cred.path_; } -bool AuthConfigFactory::BasicCred::operator<(const BasicCred& cred) const +bool BasicCred::operator<(const BasicCred& cred) const { return host_ < cred.host_ || (!(cred.host_ < host_) && (port_ < cred.port_ || (!(cred.port_ < port_) && path_ > cred.path_))); } -AuthConfigFactory::BasicCredSet::iterator -AuthConfigFactory::findBasicCred +AuthConfigFactory::BasicCredSet::iterator AuthConfigFactory::findBasicCred (const std::string& host, uint16_t port, const std::string& path) { - std::shared_ptr bc(new BasicCred("", "", host, port, path)); - BasicCredSet::iterator i = basicCreds_.lower_bound(bc); - for(; i != basicCreds_.end() && (*i)->host_ == host && (*i)->port_ == port; - ++i) { + auto bc = make_unique("", "", host, port, path); + auto i = basicCreds_.lower_bound(bc); + for(; i != std::end(basicCreds_) && + (*i)->host_ == host && + (*i)->port_ == port; ++i) { if(util::startsWith(bc->path_, (*i)->path_)) { return i; } } - return basicCreds_.end(); + return std::end(basicCreds_); } } // namespace aria2 -- cgit