zypp/media/TransferSettings.cc

   1 #include <iostream>
   2 #include <sstream>
   3
   4 #include "zypp/base/String.h"
   5 #include "zypp/base/Logger.h"
   6 #include "zypp/base/WatchFile.h"
   7 #include "zypp/base/ReferenceCounted.h"
   8 #include "zypp/base/NonCopyable.h"
   9 #include "zypp/ExternalProgram.h"
  10 #include "zypp/media/TransferSettings.h"
  11 #include "zypp/ZConfig.h"
  12
  13 using namespace std;
  14
  15 #define CURL_BINARY "/usr/bin/curl"
  16
  17 namespace zypp
  18 {
  19 namespace media
  20 {
  21
  22 class TransferSettings::Impl
  23 {
  24 public:
  25     Impl()
  26         : _useproxy(false)
  27         , _timeout(0)
  28         , _connect_timeout(0)
  29         , _maxConcurrentConnections(ZConfig::instance().download_max_concurrent_connections())
  30         , _minDownloadSpeed(ZConfig::instance().download_min_download_speed())
  31         , _maxDownloadSpeed(ZConfig::instance().download_max_download_speed())
  32         , _maxSilentTries(ZConfig::instance().download_max_silent_tries())
  33         , _verify_host(false)
  34         , _verify_peer(false)
  35         , _ca_path("/etc/ssl/certs")
  36         , _head_requests_allowed(true)
  37     {}
  38
  39     virtual ~Impl()
  40     {}
  41
  42     /** Offer default Impl. */
  43     static shared_ptr<Impl> nullimpl()
  44     {
  45       static shared_ptr<Impl> _nullimpl( new Impl );
  46       return _nullimpl;
  47     }
  48
  49 private:
  50     friend Impl * rwcowClone<Impl>( const Impl * rhs );
  51     /** clone for RWCOW_pointer */
  52     Impl * clone() const
  53     { return new Impl( *this ); }
  54
  55 public:
  56     vector<string> _headers;
  57     string _useragent;
  58     string _username;
  59     string _password;
  60     bool _useproxy;
  61     string _proxy;
  62     string _proxy_username;
  63     string _proxy_password;
  64     string _authtype;
  65     long _timeout;
  66     long _connect_timeout;
  67     Url _url;
  68     Pathname _targetdir;
  69
  70     long _maxConcurrentConnections;
  71     long _minDownloadSpeed;
  72     long _maxDownloadSpeed;
  73     long _maxSilentTries;
  74
  75     bool _verify_host;
  76     bool _verify_peer;
  77     Pathname _ca_path;
  78     Pathname _client_cert_path;
  79
  80     // workarounds
  81     bool _head_requests_allowed;
  82 };
  83
  84 TransferSettings::TransferSettings()
  85     : _impl(new TransferSettings::Impl())
  86 {
  87
  88 }
  89
  90 void TransferSettings::reset()
  91 {
  92     _impl.reset(new TransferSettings::Impl());
  93 }
  94
  95 void TransferSettings::addHeader( const std::string &header )
  96 {
  97     _impl->_headers.push_back(header);
  98 }
  99
 100 TransferSettings::Headers::const_iterator TransferSettings::headersBegin() const
 101 {
 102     return _impl->_headers.begin();
 103 }
 104
 105 TransferSettings::Headers::const_iterator TransferSettings::headersEnd() const
 106 {
 107     return _impl->_headers.end();
 108 }
 109
 110 void TransferSettings::setUserAgentString( const std::string &agent )
 111 {
 112     _impl->_useragent = agent;
 113 }
 114
 115 std::string TransferSettings::userAgentString() const
 116 {
 117     return _impl->_useragent;
 118 }
 119
 120 void TransferSettings::setUsername( const std::string &username )
 121 {
 122     _impl->_username = username;
 123 }
 124
 125 std::string TransferSettings::username() const
 126 {
 127     return _impl->_username;
 128 }
 129
 130 void TransferSettings::setPassword( const std::string &password )
 131 {
 132     _impl->_password = password;
 133 }
 134
 135 void TransferSettings::setAnonymousAuth()
 136 {
 137     setUsername("anonymous");
 138     string id = "yast@";
 139     setPassword(id + VERSION);
 140 }
 141
 142 std::string TransferSettings::password() const
 143 {
 144     return _impl->_password;
 145 }
 146
 147 std::string TransferSettings::userPassword() const
 148 {
 149     string userpwd = username();
 150     if ( password().size() ) {
 151         userpwd += ":" + password();
 152     }
 153     return userpwd;
 154 }
 155
 156 void TransferSettings::setProxyEnabled( bool enabled )
 157 {
 158     _impl->_useproxy = enabled;
 159 }
 160
 161 bool TransferSettings::proxyEnabled() const
 162 {
 163     return _impl->_useproxy;
 164 }
 165
 166 void TransferSettings::setProxy( const std::string &proxy )
 167 {
 168     _impl->_proxy = proxy;
 169 }
 170
 171 std::string TransferSettings::proxy() const
 172 {
 173     return _impl->_proxy;
 174 }
 175
 176 void TransferSettings::setProxyUsername( const std::string &proxyuser )
 177 {
 178     _impl->_proxy_username = proxyuser;
 179 }
 180
 181 std::string TransferSettings::proxyUsername() const
 182 {
 183     return _impl->_proxy_username;
 184 }
 185
 186 void TransferSettings::setProxyPassword( const std::string &proxypass )
 187 {
 188     _impl->_proxy_password = proxypass;
 189 }
 190
 191 std::string TransferSettings::proxyPassword() const
 192 {
 193     return _impl->_proxy_password;
 194 }
 195
 196 std::string TransferSettings::proxyUserPassword() const
 197 {
 198     string userpwd = proxyUsername();
 199     if ( proxyPassword().size() ) {
 200         userpwd += ":" + proxyPassword();
 201     }
 202     return userpwd;
 203 }
 204
 205 void TransferSettings::setTimeout( long t )
 206 {
 207     _impl->_timeout = t;
 208 }
 209
 210 long TransferSettings::timeout() const
 211 {
 212     return _impl->_timeout;
 213 }
 214
 215 void TransferSettings::setConnectTimeout( long t )
 216 {
 217     _impl->_connect_timeout = t;
 218 }
 219
 220 long TransferSettings::connectTimeout() const
 221 {
 222     return _impl->_connect_timeout;
 223 }
 224
 225 long TransferSettings::maxConcurrentConnections() const
 226 {
 227     return _impl->_maxConcurrentConnections;
 228 }
 229
 230 void TransferSettings::setMaxConcurrentConnections(long v)
 231 {
 232     _impl->_maxConcurrentConnections = v;
 233 }
 234
 235 long TransferSettings::minDownloadSpeed() const
 236 {
 237     return _impl->_minDownloadSpeed;
 238 }
 239
 240 void TransferSettings::setMinDownloadSpeed(long v)
 241 {
 242     _impl->_minDownloadSpeed = v;
 243 }
 244
 245 long TransferSettings::maxDownloadSpeed() const
 246 {
 247     return _impl->_maxDownloadSpeed;
 248 }
 249
 250 void TransferSettings::setMaxDownloadSpeed(long v)
 251 {
 252     _impl->_maxDownloadSpeed = v;
 253 }
 254
 255 long TransferSettings::maxSilentTries() const
 256 {
 257     return _impl->_maxSilentTries;
 258 }
 259
 260 void TransferSettings::setMaxSilentTries(long v)
 261 {
 262     _impl->_maxSilentTries = v;
 263 }
 264
 265 bool TransferSettings::verifyHostEnabled() const
 266 {
 267     return _impl->_verify_host;
 268 }
 269
 270 void TransferSettings::setVerifyHostEnabled( bool enabled )
 271 {
 272     _impl->_verify_host = enabled;
 273 }
 274
 275 bool TransferSettings::verifyPeerEnabled() const
 276 {
 277     return _impl->_verify_peer;
 278 }
 279
 280 Pathname TransferSettings::clientCertificatePath() const
 281 {
 282     return _impl->_client_cert_path;
 283 }
 284
 285 void TransferSettings::setClientCertificatePath( const zypp::Pathname &path )
 286 {
 287     _impl->_client_cert_path = path;
 288 }
 289
 290
 291 void TransferSettings::setVerifyPeerEnabled( bool enabled )
 292 {
 293     _impl->_verify_peer = enabled;
 294 }
 295
 296 Pathname TransferSettings::certificateAuthoritiesPath() const
 297 {
 298     return _impl->_ca_path;
 299 }
 300
 301 void TransferSettings::setCertificateAuthoritiesPath( const zypp::Pathname &path )
 302 {
 303     _impl->_ca_path = path;
 304 }
 305
 306 void TransferSettings::setAuthType( const std::string &authtype)
 307 {
 308     _impl->_authtype = authtype;
 309 }
 310
 311 std::string TransferSettings::authType() const
 312 {
 313     return _impl->_authtype;
 314 }
 315
 316 void TransferSettings::setHeadRequestsAllowed(bool allowed)
 317 {
 318     _impl->_head_requests_allowed = allowed;
 319 }
 320
 321 bool TransferSettings::headRequestsAllowed() const
 322 {
 323     return _impl->_head_requests_allowed;
 324 }
 325
 326 } // ns media
 327 } // ns zypp
 328