libzypp  17.31.31
transfersettings.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
13 #include "transfersettings.h"
14 #include <iostream>
15 #include <sstream>
16 
17 #include <zypp-core/base/String.h>
18 #include <zypp-core/base/Logger.h>
19 #include <zypp-core/fs/WatchFile>
20 #include <zypp-core/base/ReferenceCounted.h>
21 #include <zypp-core/base/NonCopyable.h>
22 #include <zypp-core/ExternalProgram.h>
23 #include <zypp-media/MediaConfig>
24 
25 #include <zypp/APIConfig.h>
26 
27 using std::endl;
28 
29 #define CURL_BINARY "/usr/bin/curl"
30 
31 namespace zypp
32 {
33  namespace media
34  {
36  {
37  public:
38  Impl() : _useproxy( false ),
39  _timeout( MediaConfig::instance().download_transfer_timeout() ),
40  _connect_timeout( MediaConfig::instance().download_connect_timeout() ),
41  _maxConcurrentConnections( MediaConfig::instance().download_max_concurrent_connections() ),
42  _minDownloadSpeed(MediaConfig::instance().download_min_download_speed()),
43  _maxDownloadSpeed(MediaConfig::instance().download_max_download_speed()),
44  _maxSilentTries(MediaConfig::instance().download_max_silent_tries() ),
45  _verify_host(false),
46  _verify_peer(false),
47  _ca_path("/etc/ssl/certs"),
49  {}
50 
51  virtual ~Impl()
52  {}
53 
55  static shared_ptr<Impl> nullimpl()
56  {
57  static shared_ptr<Impl> _nullimpl( new Impl );
58  return _nullimpl;
59  }
60 
61  private:
62  friend Impl * rwcowClone<Impl>( const Impl * rhs );
64  Impl * clone() const
65  { return new Impl( *this ); }
66 
67  public:
68  void safeAddHeader( std::string val_r ) {
69  // bsc#1212187: HTTP/2 RFC 9113 forbids fields ending with a space.
70  // Trim and discard empty header.
71  val_r = str::trim( std::move(val_r) );
72  if ( not val_r.empty() )
73  _headers.push_back( std::move(val_r) );
74  else
75  WAR << "Discard empty header" << endl;
76  }
77 
78  public:
79  std::vector<std::string> _headers;
80  std::string _useragent;
81  std::string _username;
82  std::string _password;
83  bool _useproxy;
84  std::string _proxy;
85  std::string _proxy_username;
86  std::string _proxy_password;
87  std::string _authtype;
88  long _timeout;
92 
97 
103 
104  // workarounds
106  };
107 
109  : _impl(new TransferSettings::Impl())
110  {}
111 
114 
115 
116  void TransferSettings::addHeader( const std::string & val_r )
117  { _impl->safeAddHeader( val_r ); }
118  void TransferSettings::addHeader( std::string && val_r )
119  { _impl->safeAddHeader( std::move(val_r) ); }
120 
122  {
123  //@TODO check if we could use a vector of std::string_view here
124  return _impl->_headers;
125  }
126 
127  void TransferSettings::setUserAgentString( const std::string &val_r )
128  { _impl->_useragent = str::trim( val_r ); } // bsc#1212187: HTTP/2 RFC 9113 forbids fields ending with a space
129 
130  void TransferSettings::setUserAgentString( std::string && val_r )
131  { _impl->_useragent = str::trim( std::move(val_r) ); } // bsc#1212187: HTTP/2 RFC 9113 forbids fields ending with a space
132 
133  const std::string &TransferSettings::userAgentString() const
134  { return _impl->_useragent; }
135 
136 
137  void TransferSettings::setUsername( const std::string &val_r )
138  { _impl->_username = val_r; }
139 
140  void TransferSettings::setUsername( std::string && val_r )
141  { _impl->_username = std::move(val_r); }
142 
143  const std::string &TransferSettings::username() const
144  { return _impl->_username; }
145 
146  void TransferSettings::setPassword( const std::string & val_r )
147  { _impl->_password = val_r; }
148 
149  void TransferSettings::setPassword( std::string && val_r )
150  { _impl->_password = std::move(val_r); }
151 
152  const std::string &TransferSettings::password() const
153  { return _impl->_password; }
154 
155  std::string TransferSettings::userPassword() const
156  {
157  std::string userpwd = username();
158  if ( password().size() ) {
159  userpwd += ":" + password();
160  }
161  return userpwd;
162  }
163 
165  {
166  setUsername("anonymous");
168  }
169 
170 
172  { _impl->_useproxy = enabled; }
173 
175  { return _impl->_useproxy; }
176 
177 
178  void TransferSettings::setProxy( const std::string &val_r )
179  { _impl->_proxy = val_r; }
180 
181  void TransferSettings::setProxy( std::string && val_r )
182  { _impl->_proxy = std::move(val_r); }
183 
184  const std::string &TransferSettings::proxy() const
185  { return _impl->_proxy; }
186 
187 
188  void TransferSettings::setProxyUsername( const std::string &val_r )
189  { _impl->_proxy_username = val_r; }
190 
191  void TransferSettings::setProxyUsername( std::string && val_r )
192  { _impl->_proxy_username = std::move(val_r); }
193 
194  const std::string &TransferSettings::proxyUsername() const
195  { return _impl->_proxy_username; }
196 
197  void TransferSettings::setProxyPassword( const std::string &val_r )
198  { _impl->_proxy_password = val_r; }
199 
200  void TransferSettings::setProxyPassword( std::string && val_r )
201  { _impl->_proxy_password = std::move(val_r); }
202 
203  const std::string &TransferSettings::proxyPassword() const
204  { return _impl->_proxy_password; }
205 
207  {
208  std::string userpwd = proxyUsername();
209  if ( proxyPassword().size() ) {
210  userpwd += ":" + proxyPassword();
211  }
212  return userpwd;
213  }
214 
215 
217  { _impl->_timeout = (t); }
218 
220  { return _impl->_timeout; }
221 
222 
224  { _impl->_connect_timeout = (t); }
225 
227  { return _impl->_connect_timeout; }
228 
229 
231  { _impl->_maxConcurrentConnections = (v); }
232 
234  { return _impl->_maxConcurrentConnections; }
235 
236 
238  { _impl->_minDownloadSpeed = (v); }
239 
241  { return _impl->_minDownloadSpeed; }
242 
243 
245  { _impl->_maxDownloadSpeed = (v); }
246 
248  { return _impl->_maxDownloadSpeed; }
249 
250 
252  { _impl->_maxSilentTries = (v); }
253 
255  { return _impl->_maxSilentTries; }
256 
257 
259  { _impl->_verify_host = (enabled); }
260 
262  { return _impl->_verify_host; }
263 
264 
266  { _impl->_verify_peer = enabled; }
267 
269  { return _impl->_verify_peer; }
270 
272  { _impl->_client_cert_path = val_r; }
273 
275  { _impl->_client_cert_path = std::move( val_r ); }
276 
278  { return _impl->_client_cert_path; }
279 
280 
282  { _impl->_client_key_path = val_r; }
283 
285  { _impl->_client_key_path = std::move( val_r ); }
286 
288  { return _impl->_client_key_path; }
289 
290 
292  { _impl->_ca_path = val_r; }
293 
295  { _impl->_ca_path = std::move(val_r.asString()); }
296 
298  { return _impl->_ca_path; }
299 
300 
301  void TransferSettings::setAuthType( const std::string &val_r )
302  { _impl->_authtype = val_r; }
303 
304  void TransferSettings::setAuthType( std::string && val_r )
305  { _impl->_authtype = std::move(val_r); }
306 
307  const std::string &TransferSettings::authType() const
308  { return _impl->_authtype; }
309 
310 
312  { _impl->_head_requests_allowed = allowed; }
313 
315  { return _impl->_head_requests_allowed; }
316 
317  } // namespace media
318 } // namespace zypp
long timeout() const
transfer timeout
const Pathname & certificateAuthoritiesPath() const
SSL certificate authorities path ( default: /etc/ssl/certs )
const Pathname & clientCertificatePath() const
SSL client certificate file.
void addHeader(std::string &&val_r)
add a header, on the form "Foo: Bar" (trims)
std::string proxyUserPassword() const
returns the proxy user and password as a user:pass string
const std::string & proxyPassword() const
proxy auth password
void setPassword(const std::string &val_r)
sets the auth password
long maxDownloadSpeed() const
Maximum download speed (bytes per second)
Holds transfer setting.
const std::string & authType() const
get the allowed authentication types
bool verifyHostEnabled() const
Whether to verify host for ssl.
const std::string & proxyUsername() const
proxy auth username
void setUsername(const std::string &val_r)
sets the auth username
void setHeadRequestsAllowed(bool allowed)
set whether HEAD requests are allowed
void setConnectTimeout(long t)
set the connect timeout
const std::string & password() const
auth password
const std::string & username() const
auth username
const Headers & headers() const
returns a list of all added headers (trimmed)
void setAnonymousAuth()
sets anonymous authentication (ie: for ftp)
bool verifyPeerEnabled() const
Whether to verify peer for ssl.
long maxSilentTries() const
Maximum silent retries.
void setAuthType(const std::string &val_r)
set the allowed authentication types
void setProxy(const std::string &val_r)
proxy to use if it is enabled
std::string trim(const std::string &s, const Trim trim_r)
Definition: String.cc:223
static shared_ptr< Impl > nullimpl()
Offer default Impl.
long connectTimeout() const
connection timeout
Provides API related macros.
#define WAR
Definition: Logger.h:97
std::vector< std::string > _headers
std::vector< std::string > Headers
TransferSettings()
Constructs a transfer program cmd line access.
void setMaxSilentTries(long v)
Set maximum silent retries.
void setTimeout(long t)
set the transfer timeout
void safeAddHeader(std::string val_r)
const Pathname & clientKeyPath() const
SSL client key file.
RWCOW_pointer< Impl > _impl
void setMaxDownloadSpeed(long v)
Set max download speed (bytes per second)
long minDownloadSpeed() const
Minimum download speed (bytes per second) until the connection is dropped.
Impl * clone() const
clone for RWCOW_pointer
bool proxyEnabled() const
proxy is enabled
#define LIBZYPP_VERSION_STRING
Definition: APIConfig.h:15
void setProxyPassword(const std::string &val_r)
sets the proxy password
void reset()
reset the settings to the defaults
void setMaxConcurrentConnections(long v)
Set maximum number of concurrent connections for a single transfer.
long maxConcurrentConnections() const
Maximum number of concurrent connections for a single transfer.
void setUserAgentString(std::string &&val_r)
sets the user agent ie: "Mozilla v3" (trims)
void setClientCertificatePath(const Pathname &val_r)
Sets the SSL client certificate file.
void setProxyUsername(const std::string &val_r)
sets the proxy user
std::string userPassword() const
returns the user and password as a user:pass string
void setCertificateAuthoritiesPath(const Pathname &val_r)
Sets the SSL certificate authorities path.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
void setMinDownloadSpeed(long v)
Set minimum download speed (bytes per second) until the connection is dropped.
const std::string & proxy() const
proxy host
void setVerifyPeerEnabled(bool enabled)
Sets whether to verify host for ssl.
void setClientKeyPath(const Pathname &val_r)
Sets the SSL client key file.
void setVerifyHostEnabled(bool enabled)
Sets whether to verify host for ssl.
const std::string & userAgentString() const
user agent string (trimmed)
Url manipulation class.
Definition: Url.h:91
bool headRequestsAllowed() const
whether HEAD requests are allowed
void setProxyEnabled(bool enabled)
whether the proxy is used or not