libzypp: zypp/media/MediaNetworkCommonHandler.cc Source File

libzypp 17.38.6

MediaNetworkCommonHandler.cc
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12
13#include "MediaNetworkCommonHandler.h"
14#include <zypp-core/ng/pipelines/transform.h>
15
16#include <zypp/ZConfig.h>
17#include <zypp-core/fs/PathInfo.h>
18#include <zypp-core/base/Regex.h>
19#include <zypp-core/base/Logger.h>
20#include <zypp-core/base/Gettext.h>
21#include <zypp/Target.h>
22#include <zypp/media/UrlResolverPlugin.h>
23#include <zypp-media/auth/CredentialManager>
24#include <zypp-curl/auth/CurlAuthData>
25#include <zypp-curl/private/curlhelper_p.h>
26
27#include <zypp/ZYppCallbacks.h>
28
29#include <fstream>
30#include <curl/curl.h>
31
32using std::endl;
33
34namespace zypp::media
35{
36 MediaNetworkCommonHandler::MediaNetworkCommonHandler( const MirroredOrigin &origin_r, const Pathname &attach_point_r, const Pathname &urlpath_below_attachpoint_r, const bool does_download_r)
37 : MediaHandler( origin_r, attach_point_r, urlpath_below_attachpoint_r, does_download_r )
38 {
39 _redirTargets.clear ();
40 std::transform ( _origin.begin(), _origin.end(), std::back_inserter(_redirTargets), []( const OriginEndpoint &url_r ) { return findGeoIPRedirect(url_r.url()); } );
41
42 // initialize default mirror order: mirrors first, then authorities
43 _mirrOrder.reserve( _origin.endpointCount() );
44 uint authCount = _origin.authorityCount();
45 for( unsigned i = authCount; i < _origin.endpointCount () ; i++ ) { _mirrOrder.push_back(i); }
46 for( unsigned i = 0; i < authCount ; i++ ) { _mirrOrder.push_back(i); }
47 }
48
49 void MediaNetworkCommonHandler::attachTo (bool next)
50 {
51 if ( next )
52 ZYPP_THROW(MediaNotSupportedException(url()));
53
54 if( !isUseableAttachPoint( attachPoint() ) ) {
55 setAttachPoint( createAttachPoint(), true );
56 }
57
58 disconnectFrom(); // clean state if needed
59
60 // here : setup TransferSettings
61 setupTransferSettings();
62
63 // FIXME: need a derived class to propelly compare url's
64 MediaSourceRef media( new MediaSource( url().getScheme(), url().asString()) );
65 setMediaSource(media);
66 }
67
68 bool MediaNetworkCommonHandler::checkAttachPoint(const Pathname &apoint) const
69 {
70 return MediaHandler::checkAttachPoint( apoint, true, true);
71 }
72
73 Url MediaNetworkCommonHandler::clearQueryString(const Url &url) const
74 {
75 return ::internal::clearQueryString(url);
76 }
77
78 zypp::Url MediaNetworkCommonHandler::findGeoIPRedirect ( const zypp::Url &url )
79 {
80 try {
81 const auto &conf = ZConfig::instance();
82 if ( !conf.geoipEnabled() ) {
83 MIL << "GeoIp rewrites disabled via ZConfig." << std::endl;
84 return Url();
85 }
86
87 if ( !( url.getQueryParam("COUNTRY").empty() && url.getQueryParam("AVOID_COUNTRY").empty() )) {
88 MIL << "GeoIp rewrites disabled since the baseurl " << url << " uses an explicit country setting." << std::endl;
89 return Url();
90 }
91
92 const auto &hostname = url.getHost();
93 auto geoipFile = conf.geoipCachePath() / hostname ;
94 if ( PathInfo( geoipFile ).isFile() ) {
95
96 MIL << "Found GeoIP file for host: " << hostname << std::endl;
97
98 std::ifstream in( geoipFile.asString() );
99 if (!in.is_open()) {
100 MIL << "Failed to open GeoIP for host: " << hostname << std::endl;
101 return Url();
102 }
103
104 try {
105 std::string newHost;
106 in >> newHost;
107
108 Url newUrl = url;
109 newUrl.setHost( newHost );
110
111 MIL << "Found GeoIP rewrite: " << hostname << " -> " << newHost << std::endl;
112
113 return newUrl;
114
115 } catch ( const zypp::Exception &e ) {
116 ZYPP_CAUGHT(e);
117 MIL << "No valid GeoIP rewrite target found for " << url << std::endl;
118 }
119 }
120 } catch ( const zypp::Exception &e ) {
121 ZYPP_CAUGHT(e);
122 MIL << "Failed to query GeoIP data, url rewriting disabled." << std::endl;
123 }
124
125 // no rewrite
126 return Url();
127 }
128
130
131 void MediaNetworkCommonHandler::getFile( const OnMediaLocation &file ) const
132 {
133 // Use absolute file name to prevent access of files outside of the
134 // hierarchy below the attach point.
135 getFileCopy( file, localPath(file.filename()).absolutename() );
136 }
137
138 void MediaNetworkCommonHandler::getDir( const Pathname & dirname, bool recurse_r ) const
139 {
140 filesystem::DirContent content;
141 getDirInfo( content, dirname, /*dots*/false );
142
143 for ( filesystem::DirContent::const_iterator it = content.begin(); it != content.end(); ++it ) {
144 Pathname filename = dirname + it->name;
145 int res = 0;
146
147 switch ( it->type ) {
148 case filesystem::FT_NOT_AVAIL: // old directory.yast contains no typeinfo at all
149 case filesystem::FT_FILE:
150 getFile( OnMediaLocation( filename ) );
151 break;
152 case filesystem::FT_DIR: // newer directory.yast contain at least directory info
153 if ( recurse_r ) {
154 getDir( filename, recurse_r );
155 } else {
156 res = assert_dir( localPath( filename ) );
157 if ( res ) {
158 WAR << "Ignore error (" << res << ") on creating local directory '" << localPath( filename ) << "'" << endl;
159 }
160 }
161 break;
162 default:
163 // don't provide devices, sockets, etc.
164 break;
165 }
166 }
167 }
168
169 void MediaNetworkCommonHandler::getDirInfo( std::list<std::string> & retlist,
170 const Pathname & dirname, bool dots ) const
171 {
172 getDirectoryYast( retlist, dirname, dots );
173 }
174
175 void MediaNetworkCommonHandler::getDirInfo( filesystem::DirContent & retlist,
176 const Pathname & dirname, bool dots ) const
177 {
178 getDirectoryYast( retlist, dirname, dots );
179 }
180
181 const char *MediaNetworkCommonHandler::anonymousIdHeader()
182 {
183 // we need to add the release and identifier to the
184 // agent string.
185 // The target could be not initialized, and then this information
186 // is guessed.
187 // bsc#1212187: HTTP/2 RFC 9113 forbids fields ending with a space
188 static const std::string _value( str::trim( str::form(
189 "X-ZYpp-AnonymousId: %s",
190 Target::anonymousUniqueId( Pathname()/*guess root*/ ).c_str()
191 )));
192 return _value.c_str();
193 }
194
195 const char *MediaNetworkCommonHandler::distributionFlavorHeader()
196 {
197 // we need to add the release and identifier to the
198 // agent string.
199 // The target could be not initialized, and then this information
200 // is guessed.
201 // bsc#1212187: HTTP/2 RFC 9113 forbids fields ending with a space
202 static const std::string _value( str::trim( str::form(
203 "X-ZYpp-DistributionFlavor: %s",
204 Target::distributionFlavor( Pathname()/*guess root*/ ).c_str()
205 )));
206 return _value.c_str();
207 }
208
209 Url MediaNetworkCommonHandler::getFileUrl( int mirrorIdx, const Pathname & filename_r ) const
210 {
211 static const zypp::str::regex invalidRewrites("^.*\\/repomd.xml(.asc|.key)?$|^\\/geoip$");
212
213 if ( mirrorIdx < 0 || mirrorIdx > _redirTargets.size() )
214 return {};
215
216 const bool canRedir = _redirTargets[mirrorIdx].isValid() && !invalidRewrites.matches(filename_r.asString());
217 const auto &baseUrl = ( canRedir ) ? _redirTargets[mirrorIdx] : _origin[mirrorIdx].url();
218
219 if ( canRedir )
220 MIL << "Redirecting " << filename_r << " request to geoip location." << std::endl;
221
222 // Simply extend the URLs pathname:
223 Url newurl { baseUrl };
224 newurl.appendPathName( filename_r );
225 return newurl;
226 }
227
228 const char *MediaNetworkCommonHandler::agentString() {
229 // we need to add the release and identifier to the
230 // agent string.
231 // The target could be not initialized, and then this information
232 // is guessed.
233 // bsc#1212187: HTTP/2 RFC 9113 forbids fields ending with a space
234 static const std::string _value(str::trim(str::form(
235 "ZYpp " LIBZYPP_VERSION_STRING " (curl %s) %s",
236 curl_version_info(CURLVERSION_NOW)->version,
237 Target::targetDistribution(Pathname() /*guess root*/).c_str())));
238 return _value.c_str();
239 }
240
241 void MediaNetworkCommonHandler::setupTransferSettings()
242 {
243 // fill some settings from url query parameters
244 try
245 {
246 clearTransferSettings();
247
248 CredentialManager cm(CredManagerOptions(ZConfig::instance().repoManagerRoot()));
249 for( OriginEndpoint &u : _origin ) {
250
251 u.setConfig( MIRR_SETTINGS_KEY.data() , std::make_any<TransferSettings>()); // init or reset to default
252
253 if ( !u.isValid() )
254 ZYPP_THROW(MediaBadUrlException(u.url()));
255
256 TransferSettings &set = u.getConfig<TransferSettings>( MIRR_SETTINGS_KEY.data() );
257
258 checkProtocol(u.url());
259
260 set.setUserAgentString(agentString());
261
262 // apply MediaUrl settings
263 if ( u.hasConfig ("http-headers") ) {
264 // Set up the handler
265 for ( const auto & el : u.getConfig<UrlResolverPlugin::HeaderList>("http-headers") ) {
266 std::string header { el.first };
267 header += ": ";
268 header += el.second;
269 MIL << "Added custom header -> " << header << std::endl;
270 set.addHeader( std::move(header) );
271 }
272 }
273
274 // add custom headers for download.opensuse.org (bsc#955801)
275 if ( u.url().getHost() == "download.opensuse.org" )
276 {
277 set.addHeader(anonymousIdHeader());
278 set.addHeader(distributionFlavorHeader());
279 }
280 set.addHeader("Pragma:");
281
282 // apply legacy Url encoded settings
283 ::internal::fillSettingsFromUrl( u.url(), set);
284
285 // if the proxy was not set (or explicitly unset) by url, then look...
286 if ( set.proxy().empty() )
287 {
288 // ...at the system proxy settings
289 ::internal::fillSettingsSystemProxy( u.url(), set);
290 }
291
292 /* Fixes bsc#1174011 "auth=basic ignored in some cases"
293 * We should proactively add the password to the request if basic auth is configured
294 * and a password is available in the credentials but not in the URL.
295 *
296 * We will be a bit paranoid here and require that the URL has a user embedded, otherwise we go the default route
297 * and ask the server first about the auth method
298 */
299 if ( set.authType() == "basic" && not set.username().empty() && set.password().empty() ) {
300 const auto cred = cm.getCred( u.url() );
301 if ( cred && cred->valid() ) {
302 set.setPassword(cred->password());
303 }
304 }
305 }
306 }
307 catch ( const MediaException &e )
308 {
309 disconnectFrom();
310 ZYPP_RETHROW(e);
311 }
312 }
313
314 void MediaNetworkCommonHandler::clearTransferSettings()
315 {
316 for( OriginEndpoint &u : _origin ) {
317 u.eraseConfigValue ( MIRR_SETTINGS_KEY.data() );
318 }
319 }
320
321
322 bool MediaNetworkCommonHandler::authenticate(const Url &url, TransferSettings &settings, const std::string & availAuthTypes, bool firstTry)
323 {
325 CredentialManager cm(CredManagerOptions(ZConfig::instance().repoManagerRoot()));
326 return authenticate( url, cm, settings, availAuthTypes, firstTry );
327 }
328
329 std::vector<unsigned int> MediaNetworkCommonHandler::mirrorOrder(const OnMediaLocation &loc) const
330 {
331 uint authCount = _origin.authorityCount();
332
333 if ( !loc.mirrorsAllowed () ) {
334 MIL << "Fetching file " << loc << " from authorities only ( " << authCount << " ): " << _origin << std::endl;
335 std::vector<unsigned> authOrder;
336 authOrder.reserve( authCount );
337 // Filter _mirrOrder to include only authority indices
338 for ( unsigned idx : _mirrOrder ) {
339 if ( idx < authCount )
340 authOrder.push_back( idx );
341 }
342 return authOrder;
343 }
344
345 return _mirrOrder;
346 }
347
348 void MediaNetworkCommonHandler::deprioritizeMirror( unsigned mirr ) const
349 {
350 auto it = std::find( _mirrOrder.begin(), _mirrOrder.end(), mirr );
351 if ( it != _mirrOrder.end() && _mirrOrder.size() > 1 )
352 {
353 // move found index to the end
354 std::rotate( it, it + 1, _mirrOrder.end() );
355 }
356 }
357
358 bool MediaNetworkCommonHandler::authenticate( const Url &url, CredentialManager &cm, TransferSettings &settings, const std::string & availAuthTypes, bool firstTry )
359 {
360 CurlAuthData_Ptr credentials;
361
362 // get stored credentials
363 AuthData_Ptr cmcred = cm.getCred(url);
364
365 if (cmcred && firstTry)
366 {
367 credentials.reset(new CurlAuthData(*cmcred));
368 DBG << "got stored credentials:" << endl << *credentials << endl;
369 }
370 // if not found, ask user
371 else
372 {
373
374 CurlAuthData_Ptr curlcred;
375 curlcred.reset(new CurlAuthData());
376 callback::SendReport<AuthenticationReport> auth_report;
377
378 // preset the username if present in current url
379 if (!url.getUsername().empty() && firstTry)
380 curlcred->setUsername(url.getUsername());
381 // if CM has found some credentials, preset the username from there
382 else if (cmcred)
383 curlcred->setUsername(cmcred->username());
384
385 // indicate we have no good credentials from CM
386 cmcred.reset();
387
388 std::string prompt_msg = str::Format(_("Authentication required for '%s'")) % url.asString();
389
390 // set available authentication types from the exception
391 // might be needed in prompt
392 curlcred->setAuthType(availAuthTypes);
393
394 // ask user
395 if (auth_report->prompt(url, prompt_msg, *curlcred))
396 {
397 DBG << "callback answer: retry" << endl
398 << "CurlAuthData: " << *curlcred << endl;
399
400 if (curlcred->valid())
401 {
402 credentials = curlcred;
403 // if (credentials->username() != _url.url().getUsername())
404 // _url.url().setUsername(credentials->username());
412 }
413 }
414 else
415 {
416 DBG << "callback answer: cancel" << endl;
417 }
418 }
419
420 // set username and password
421 if (credentials)
422 {
423 settings.setUsername(credentials->username());
424 settings.setPassword(credentials->password());
425
426 // set available authentication types from the exception
427 if (credentials->authType() == CURLAUTH_NONE)
428 credentials->setAuthType(availAuthTypes);
429
430 // set auth type (seems this must be set _after_ setting the userpwd)
431 if (credentials->authType() != CURLAUTH_NONE) {
432 settings.setAuthType(credentials->authTypeAsString());
433 }
434
435 if (!cmcred)
436 {
437 credentials->setUrl(url);
438 cm.addCred(*credentials);
439 cm.save();
440 }
441
442 return true;
443 }
444
445 return false;
446 }
447
448
449} // namespace zypp::media
ZYPP_RETHROW
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition Exception.h:479
ZYPP_CAUGHT
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition Exception.h:475
ZYPP_THROW
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition Exception.h:459
Gettext.h
_
#define _(MSG)
Definition Gettext.h:39
Logger.h
DBG
#define DBG
Definition Logger.h:102
MIL
#define MIL
Definition Logger.h:103
WAR
#define WAR
Definition Logger.h:104
MediaNetworkCommonHandler.h
Regex.h
Target.h
UrlResolverPlugin.h
ZConfig.h
ZYppCallbacks.h
zypp::Exception
Base class for Exception.
Definition Exception.h:153
zypp::MirroredOrigin
Manages a data source characterized by an authoritative URL and a list of mirror URLs.
Definition MirroredOrigin.h:170
zypp::OnMediaLocation
Describes a resource file located on a medium.
Definition onmedialocation.h:37
zypp::OnMediaLocation::filename
const Pathname & filename() const
The path to the resource on the medium.
Definition onmedialocation.cc:90
zypp::OnMediaLocation::mirrorsAllowed
bool mirrorsAllowed() const
The requested file is allowed to be fetched via mirrors ( defaults to true ).
Definition onmedialocation.cc:159
zypp::OriginEndpoint
Represents a single, configurable network endpoint, combining a URL with specific access settings.
Definition MirroredOrigin.h:41
zypp::Target::distributionFlavor
std::string distributionFlavor() const
This is flavor attribute of the installed base product but does not require the target to be loaded a...
Definition Target.cc:127
zypp::Target::anonymousUniqueId
std::string anonymousUniqueId() const
anonymous unique id
Definition Target.cc:132
zypp::Target::targetDistribution
std::string targetDistribution() const
This is register.target attribute of the installed base product.
Definition Target.cc:102
zypp::Url
Url manipulation class.
Definition Url.h:93
zypp::Url::setHost
void setHost(const std::string &host)
Set the hostname or IP in the URL authority.
Definition Url.cc:775
zypp::Url::appendPathName
void appendPathName(const Pathname &path_r, EEncoding eflag_r=zypp::url::E_DECODED)
Extend the path name.
Definition Url.cc:813
zypp::ZConfig::instance
static ZConfig & instance()
Singleton ctor.
Definition ZConfig.cc:756
zypp::filesystem::PathInfo
Wrapper class for stat/lstat.
Definition PathInfo.h:226
zypp::filesystem::Pathname
Pathname.
Definition Pathname.h:48
zypp::filesystem::Pathname::asString
const std::string & asString() const
String representation.
Definition Pathname.h:94
zypp::filesystem::Pathname::absolutename
Pathname absolutename() const
Return this path, adding a leading '/' if relative.
Definition Pathname.h:148
zypp::media::CredentialManager
Definition credentialmanager.h:64
zypp::media::CredentialManager::save
void save()
Saves any unsaved credentials added via addUserCred() or addGlobalCred() methods.
Definition credentialmanager.cc:416
zypp::media::CredentialManager::getCred
AuthData_Ptr getCred(const Url &url)
Get credentials for the specified url.
Definition credentialmanager.cc:335
zypp::media::CredentialManager::addCred
void addCred(const AuthData &cred)
Add new credentials with user callbacks.
Definition credentialmanager.cc:348
zypp::media::CurlAuthData
Curl HTTP authentication data.
Definition curlauthdata.h:22
zypp::media::MediaBadUrlException
Definition mediaexception.h:292
zypp::media::MediaException
Just inherits Exception to separate media exceptions.
Definition mediaexception.h:37
zypp::media::MediaHandler::isUseableAttachPoint
bool isUseableAttachPoint(const Pathname &path, bool mtab=true) const
Ask media manager, if the specified path is already used as attach point or if there are another atta...
Definition MediaHandler.cc:416
zypp::media::MediaHandler::MediaHandler
MediaHandler(MirroredOrigin origin_r, const Pathname &attach_point_r, Pathname urlpath_below_attachpoint_r, const bool does_download_r)
If the concrete media handler provides a nonempty attach_point, it must be an existing directory.
Definition MediaHandler.cc:55
zypp::media::MediaHandler::_origin
MirroredOrigin _origin
Contains the authority URL and mirrors.
Definition MediaHandler.h:112
zypp::media::MediaHandler::url
Url url() const
Primary Url used.
Definition MediaHandler.h:507
zypp::media::MediaHandler::checkAttachPoint
virtual bool checkAttachPoint(const Pathname &apoint) const
Verify if the specified directory as attach point (root) as requires by the particular media handler ...
Definition MediaHandler.cc:848
zypp::media::MediaHandler::disconnectFrom
virtual void disconnectFrom()
Call concrete handler to disconnect media.
Definition MediaHandler.h:321
zypp::media::MediaHandler::createAttachPoint
Pathname createAttachPoint() const
Try to create a default / temporary attach point.
Definition MediaHandler.cc:312
zypp::media::MediaHandler::getFileCopy
virtual void getFileCopy(const OnMediaLocation &file, const Pathname &targetFilename) const
Call concrete handler to provide a file under a different place in the file system (usually not under...
Definition MediaHandler.cc:1201
zypp::media::MediaHandler::setMediaSource
void setMediaSource(const MediaSourceRef &ref)
Set new media source reference.
Definition MediaHandler.cc:432
zypp::media::MediaHandler::localPath
Pathname localPath(const Pathname &pathname) const
Files provided will be available at 'localPath(filename)'.
Definition MediaHandler.cc:664
zypp::media::MediaHandler::getDirectoryYast
void getDirectoryYast(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const
Retrieve and if available scan dirname/directory.yast.
Definition MediaHandler.cc:1114
zypp::media::MediaHandler::setAttachPoint
void setAttachPoint(const Pathname &path, bool temp)
Set a new attach point.
Definition MediaHandler.cc:200
zypp::media::MediaHandler::attachPoint
Pathname attachPoint() const
Return the currently used attach point.
Definition MediaHandler.cc:185
zypp::media::MediaNetworkCommonHandler::_redirTargets
std::vector< Url > _redirTargets
Definition MediaNetworkCommonHandler.h:121
zypp::media::MediaNetworkCommonHandler::clearTransferSettings
void clearTransferSettings()
Definition MediaNetworkCommonHandler.cc:314
zypp::media::MediaNetworkCommonHandler::authenticate
bool authenticate(const Url &url, TransferSettings &settings, const std::string &availAuthTypes, bool firstTry)
Definition MediaNetworkCommonHandler.cc:322
zypp::media::MediaNetworkCommonHandler::getDir
void getDir(const Pathname &dirname, bool recurse_r) const override
Call concrete handler to provide directory content (not recursive!) below attach point.
Definition MediaNetworkCommonHandler.cc:138
zypp::media::MediaNetworkCommonHandler::checkAttachPoint
bool checkAttachPoint(const Pathname &apoint) const override
Verify if the specified directory as attach point (root) as requires by the particular media handler ...
Definition MediaNetworkCommonHandler.cc:68
zypp::media::MediaNetworkCommonHandler::_mirrOrder
std::vector< unsigned > _mirrOrder
Definition MediaNetworkCommonHandler.h:122
zypp::media::MediaNetworkCommonHandler::deprioritizeMirror
void deprioritizeMirror(unsigned mirr) const
Move mirror index mirr to the end of the attempt list.
Definition MediaNetworkCommonHandler.cc:348
zypp::media::MediaNetworkCommonHandler::mirrorOrder
std::vector< unsigned > mirrorOrder(const OnMediaLocation &loc) const
Definition MediaNetworkCommonHandler.cc:329
zypp::media::MediaNetworkCommonHandler::clearQueryString
Url clearQueryString(const Url &url) const
Definition MediaNetworkCommonHandler.cc:73
zypp::media::MediaNetworkCommonHandler::getFileUrl
Url getFileUrl(int mirrorIdx, const Pathname &filename) const
concatenate the attach url and the filename to a complete download url
Definition MediaNetworkCommonHandler.cc:209
zypp::media::MediaNetworkCommonHandler::setupTransferSettings
void setupTransferSettings()
initializes the curl easy handle with the data from the url
Definition MediaNetworkCommonHandler.cc:241
zypp::media::MediaNetworkCommonHandler::MediaNetworkCommonHandler
MediaNetworkCommonHandler(const MirroredOrigin &origin_r, const Pathname &attach_point_r, const Pathname &urlpath_below_attachpoint_r, const bool does_download_r)
Definition MediaNetworkCommonHandler.cc:36
zypp::media::MediaNetworkCommonHandler::checkProtocol
virtual void checkProtocol(const Url &url) const =0
check the url is supported by the curl library
zypp::media::MediaNetworkCommonHandler::anonymousIdHeader
static const char * anonymousIdHeader()
Definition MediaNetworkCommonHandler.cc:181
zypp::media::MediaNetworkCommonHandler::attachTo
void attachTo(bool next) override
Call concrete handler to attach the media.
Definition MediaNetworkCommonHandler.cc:49
zypp::media::MediaNetworkCommonHandler::MIRR_SETTINGS_KEY
static constexpr std::string_view MIRR_SETTINGS_KEY
Definition MediaNetworkCommonHandler.h:37
zypp::media::MediaNetworkCommonHandler::getFile
void getFile(const OnMediaLocation &file) const override
Call concrete handler to provide file below attach point.
Definition MediaNetworkCommonHandler.cc:131
zypp::media::MediaNetworkCommonHandler::getDirInfo
void getDirInfo(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const override
Call concrete handler to provide a content list of directory on media via retlist.
Definition MediaNetworkCommonHandler.cc:169
zypp::media::MediaNetworkCommonHandler::distributionFlavorHeader
static const char * distributionFlavorHeader()
Definition MediaNetworkCommonHandler.cc:195
zypp::media::MediaNetworkCommonHandler::findGeoIPRedirect
static zypp::Url findGeoIPRedirect(const zypp::Url &url)
Rewrites the baseURL to the geoIP target if one is found in the metadata cache, otherwise simply retu...
Definition MediaNetworkCommonHandler.cc:78
zypp::media::MediaNetworkCommonHandler::agentString
static const char * agentString()
Definition MediaNetworkCommonHandler.cc:228
zypp::media::MediaNotSupportedException
Definition mediaexception.h:352
zypp::media::MediaSource
Media source internally used by MediaManager and MediaHandler.
Definition MediaSource.h:38
zypp::media::TransferSettings
Holds transfer setting.
Definition transfersettings.h:34
zypp::media::TransferSettings::password
const std::string & password() const
auth password
Definition transfersettings.cc:175
zypp::media::TransferSettings::authType
const std::string & authType() const
get the allowed authentication types
Definition transfersettings.cc:326
zypp::media::TransferSettings::setUsername
void setUsername(const std::string &val_r)
sets the auth username
Definition transfersettings.cc:160
zypp::media::TransferSettings::proxy
const std::string & proxy() const
proxy host
Definition transfersettings.cc:198
zypp::media::TransferSettings::setUserAgentString
void setUserAgentString(std::string &&val_r)
sets the user agent ie: "Mozilla v3" (trims)
Definition transfersettings.cc:150
zypp::media::TransferSettings::addHeader
void addHeader(std::string &&val_r)
add a header, on the form "Foo: Bar" (trims)
Definition transfersettings.cc:138
zypp::media::TransferSettings::setPassword
void setPassword(const std::string &val_r)
sets the auth password
Definition transfersettings.cc:169
zypp::media::TransferSettings::username
const std::string & username() const
auth username
Definition transfersettings.cc:166
zypp::media::TransferSettings::setAuthType
void setAuthType(const std::string &val_r)
set the allowed authentication types
Definition transfersettings.cc:320
zypp::media::UrlResolverPlugin::HeaderList
std::multimap< std::string, std::string > HeaderList
Definition UrlResolverPlugin.h:39
zypp::str::regex
Regular expression.
Definition Regex.h:95
zypp::str::regex::matches
bool matches(const char *s, str::smatch &matches, int flags=none) const
Definition Regex.cc:57
curlhelper_p.h
internal::fillSettingsFromUrl
void fillSettingsFromUrl(const Url &url, media::TransferSettings &s)
Fills the settings structure using options passed on the url for example ?timeout=x&proxy=foo.
Definition curlhelper.cc:196
internal::fillSettingsSystemProxy
void fillSettingsSystemProxy(const Url &url, media::TransferSettings &s)
Reads the system proxy configuration and fills the settings structure proxy information.
Definition curlhelper.cc:359
zypp::filesystem::FT_DIR
@ FT_DIR
Definition PathInfo.h:64
zypp::filesystem::FT_NOT_AVAIL
@ FT_NOT_AVAIL
Definition PathInfo.h:61
zypp::filesystem::FT_FILE
@ FT_FILE
Definition PathInfo.h:63
zypp::filesystem::DirContent
std::list< DirEntry > DirContent
Returned by readdir.
Definition PathInfo.h:534
zypp::media
Definition MediaNetworkRequestExecutor.h:22
zypp::media::AuthData_Ptr
shared_ptr< AuthData > AuthData_Ptr
Definition authdata.h:81
zypp::media::MediaSourceRef
zypp::RW_pointer< MediaSource > MediaSourceRef
Definition MediaSource.h:125
zypp::media::CurlAuthData_Ptr
shared_ptr< CurlAuthData > CurlAuthData_Ptr
Definition curlauthdata.h:102
zypp::str::form
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition String.cc:39
zypp::str::trim
std::string trim(const std::string &s, const Trim trim_r)
Definition String.cc:226
zypp::asString
std::string asString(const Patch::Category &obj)
relates: Patch::Category string representation.
Definition Patch.cc:122
zypp::callback::SendReport
Definition Callback.h:237
zypp::media::CredManagerOptions
Definition credentialmanager.h:40
zypp::str::Format
Convenient building of std::string with boost::format.
Definition String.h:254
transform.h
PathInfo.h