| 1 | package urpm::media; | ||
| 2 | |||
| 3 | |||
| 4 | 1 | ▶ | use strict; |
|
Subroutine
BEGIN: called CC=1 SCAR=0.0
| |||
| 5 | 0 | ▶ | use urpm qw(file_from_local_medium is_local_medium); |
|
Subroutine
BEGIN: called CC=1 SCAR=2.6
| |||
| 6 | use urpm::msg; | ||
| 7 | use urpm::util qw(any append_to_file basename cat_ difference2 dirname intersection member output_safe begins_with copy_and_own file_size offset_pathname reduce_pathname uefi_type); | ||
| 8 | use urpm::removable; | ||
| 9 | use urpm::lock; | ||
| 10 | use urpm::md5sum; | ||
| 11 | use MDV::Distribconf; | ||
| 12 | |||
| 13 | |||
| 14 | our @PER_MEDIA_OPT = qw( | ||
| 15 | disable-certificate-check | ||
| 16 | downloader | ||
| 17 | ignore | ||
| 18 | key-ids | ||
| 19 | list | ||
| 20 | media_info_dir | ||
| 21 | mirrorlist | ||
| 22 | name | ||
| 23 | no-media-info | ||
| 24 | noreconfigure | ||
| 25 | priority-upgrade | ||
| 26 | removable | ||
| 27 | static | ||
| 28 | synthesis | ||
| 29 | update | ||
| 30 | url | ||
| 31 | verify-rpm | ||
| 32 | virtual | ||
| 33 | with-dir | ||
| 34 | with_hdlist | ||
| 35 | with_synthesis | ||
| 36 | xml-info | ||
| 37 | ); | ||
| 38 | |||
| 39 | my @xml_media_info = ('info', 'files', 'changelog'); | ||
| 40 | |||
| 41 | my @media_info_prefix_suffix = ( | ||
| 42 | [ 'synthesis.hdlist', '.cz' ], | ||
| 43 | [ 'hdlist', '.cz' ], | ||
| 44 | [ 'descriptions', '' ], | ||
| 45 | [ 'names', '' ], | ||
| 46 | [ 'MD5SUM', '' ], | ||
| 47 | (map { [ $_, '.xml.lzma' ] } @xml_media_info), | ||
| 48 | ); | ||
| 49 | |||
| 50 | =head1 NAME | ||
| 51 | |||
| 52 | urpm::media - Media routines for urpmi | ||
| 53 | |||
| 54 | =head1 SYNOPSIS | ||
| 55 | |||
| 56 | =head1 DESCRIPTION | ||
| 57 | |||
| 58 | =over | ||
| 59 | |||
| 60 | =cut | ||
| 61 | |||
| 62 | |||
| 63 | sub get_medium_option { | ||
| 64 | my ($urpm, $medium, $option_name) = @_; | ||
| 65 | |||
| 66 | defined $medium->{$option_name} ? $medium->{$option_name} : $urpm->{options}{$option_name}; | ||
| 67 | } | ||
| 68 | |||
| 69 | sub _is_iso { | ||
| 70 | my ($removable_dev) = @_; | ||
| 71 | $removable_dev && $removable_dev =~ /\.iso$/i; | ||
| 72 | } | ||
| 73 | |||
| 74 | sub only_media_opts { | ||
| 75 | my ($m) = @_; | ||
| 76 | my %m = map { $_ => $m->{$_} } grep { defined $m->{$_} } @PER_MEDIA_OPT; | ||
| 77 | \%m; | ||
| 78 | } | ||
| 79 | sub _only_media_opts_read { | ||
| 80 | my ($m) = @_; | ||
| 81 | my $c = only_media_opts($m); | ||
| 82 | $c->{media_info_dir} ||= 'media_info'; | ||
| 83 | $c->{iso} = delete $c->{removable} if $c->{removable} && _is_iso($c->{removable}); | ||
| 84 | $c; | ||
| 85 | } | ||
| 86 | sub _only_media_opts_write { | ||
| 87 | my ($m) = @_; | ||
| 88 | my $c = only_media_opts($m); | ||
| 89 | delete $c->{media_info_dir} if $c->{media_info_dir} eq 'media_info'; | ||
| 90 | delete $c->{url} if $c->{mirrorlist}; | ||
| 91 | $c->{removable} = delete $c->{iso} if $c->{iso}; | ||
| 92 | $c; | ||
| 93 | } | ||
| 94 | |||
| 95 | sub read_private_netrc { | ||
| 96 | my ($urpm) = @_; | ||
| 97 | |||
| 98 | my @words = split(/\s+/, scalar cat_($urpm->{private_netrc})); | ||
| 99 | my @l; | ||
| 100 | my $e; | ||
| 101 | while (@words) { | ||
| 102 | my $keyword = shift @words; | ||
| 103 | if ($keyword eq 'machine') { | ||
| 104 | push @l, $e = { machine => shift(@words) }; | ||
| 105 | } elsif ($keyword eq 'default') { | ||
| 106 | push @l, $e = { default => '' }; | ||
| 107 | } elsif ($keyword eq 'login' || $keyword eq 'password' || $keyword eq 'account') { | ||
| 108 | $e->{$keyword} = shift(@words); | ||
| 109 | } else { | ||
| 110 | $urpm->{error}("unknown netrc command $keyword"); | ||
| 111 | } | ||
| 112 | } | ||
| 113 | @l; | ||
| 114 | } | ||
| 115 | |||
| 116 | sub read_config_add_passwords { | ||
| 117 | my ($urpm, $config) = @_; | ||
| 118 | |||
| 119 | my @netrc = read_private_netrc($urpm) or return; | ||
| 120 | foreach (grep { $_->{url} } @{$config->{media}}) { | ||
| 121 | my $u = urpm::download::parse_url_with_login($_->{url}) or next; | ||
| 122 | if (my ($e) = grep { ($_->{default} || $_->{machine} eq $u->{machine}) && $_->{login} eq $u->{login} } @netrc) { | ||
| 123 | $_->{url} = sprintf('%s://%s:%s@%s%s', $u->{proto}, $u->{login}, $e->{password}, $u->{machine}, $u->{dir}); | ||
| 124 | } else { | ||
| 125 | $urpm->{log}(sprintf('no password found for %s@%s', $u->{login}, $u->{machine})); | ||
| 126 | } | ||
| 127 | } | ||
| 128 | } | ||
| 129 | |||
| 130 | sub remove_passwords_and_write_private_netrc { | ||
| 131 | my ($urpm, $config) = @_; | ||
| 132 | |||
| 133 | my @l; | ||
| 134 | foreach (grep { $_->{url} } @{$config->{media}}) { | ||
| 135 | my $u = urpm::download::parse_url_with_login($_->{url}) or next; | ||
| 136 | #- check whether a password is visible | ||
| 137 | $u->{password} or next; | ||
| 138 | |||
| 139 | push @l, $u; | ||
| 140 | $_->{url} = sprintf('%s://%s@%s%s', $u->{proto}, $u->{login}, $u->{machine}, $u->{dir}); | ||
| 141 | } | ||
| 142 | { | ||
| 143 | my $fh = urpm::sys::open_safe($urpm, '>', $urpm->{private_netrc}) or return; | ||
| 144 | foreach my $u (@l) { | ||
| 145 | printf $fh "machine %s login %s password %s\n", $u->{machine}, $u->{login}, $u->{password}; | ||
| 146 | } | ||
| 147 | } | ||
| 148 | chmod 0600, $urpm->{private_netrc}; | ||
| 149 | } | ||
| 150 | |||
| 151 | #- handle deprecated way of saving passwords | ||
| 152 | sub recover_url_from_list { | ||
| 153 | my ($urpm, $medium) = @_; | ||
| 154 | |||
| 155 | my $list = delete $medium->{list} or return; | ||
| 156 | my $statedir_list = "$urpm->{statedir}/$list"; | ||
| 157 | |||
| 158 | #- /./ is end of url marker in list file (typically generated by a | ||
| 159 | #- find . -name "*.rpm" > list | ||
| 160 | #- for exportable list file. | ||
| 161 | if (my @probe = map { m!^(.*)/\./! || m!^(.*)/[^/]*$! } cat_($statedir_list)) { | ||
| 162 | $urpm->{log}("recovering url from $statedir_list"); | ||
| 163 | ($medium->{url}) = sort { length($a) <=> length($b) } @probe; | ||
| 164 | $urpm->{modified} = 1; #- ensure urpmi.cfg is handled using only partially hidden url + netrc, since file list won't be generated anymore | ||
| 165 | unlink $statedir_list; | ||
| 166 | } | ||
| 167 | } | ||
| 168 | |||
| 169 | sub _read_config__read_media_info { | ||
| 170 | my ($urpm) = @_; | ||
| 171 | |||
| 172 | require File::Glob; | ||
| 173 | # we can't use perl's glob() because there could be spaces in | ||
| 174 | # $urpm->{mediacfgdir} | ||
| 175 | my %url2mediamap; | ||
| 176 | my %mirrorlist2mediamap; | ||
| 177 | foreach my $media_dir (File::Glob::bsd_glob("$urpm->{mediacfgdir}/*")) { | ||
| 178 | next if !-d $media_dir; | ||
| 179 | |||
| 180 | $urpm->{debug} and $urpm->{debug}("parsing: $media_dir"); | ||
| 181 | |||
| 182 | my $media_cfg = $media_dir . '/media.cfg'; | ||
| 183 | my $distribconf = MDV::Distribconf->new($media_cfg, undef) or next; | ||
| 184 | $distribconf->settree('mageia'); | ||
| 185 | $distribconf->parse_mediacfg($media_cfg) or next; | ||
| 186 | |||
| 187 | foreach (cat_($media_dir . '/url')) { | ||
| 188 | chomp($_); | ||
| 189 | foreach my $medium ($distribconf->listmedia) { | ||
| 190 | my $medium_path = reduce_pathname($_ . '/' . $distribconf->getpath($medium, 'path')); | ||
| 191 | $url2mediamap{$medium_path} = [$distribconf, $medium]; | ||
| 192 | } | ||
| 193 | } | ||
| 194 | |||
| 195 | foreach my $mirrorlist (cat_($media_dir . '/mirrorlist')) { | ||
| 196 | chomp($mirrorlist); | ||
| 197 | foreach my $medium ($distribconf->listmedia) { | ||
| 198 | my $medium_path = $distribconf->getpath($medium, 'path'); | ||
| 199 | $mirrorlist2mediamap{$mirrorlist}{$medium_path} = [ $distribconf, $medium ]; | ||
| 200 | } | ||
| 201 | } | ||
| 202 | } | ||
| 203 | (\%url2mediamap, \%mirrorlist2mediamap); | ||
| 204 | } | ||
| 205 | |||
| 206 | sub _associate_media_with_mediacfg { | ||
| 207 | my ($urpm, $media) = @_; | ||
| 208 | |||
| 209 | my ($url2mediamap, $mirrorlist2mediamap) = _read_config__read_media_info($urpm); | ||
| 210 | foreach my $medium (@$media) { | ||
| 211 | if ($medium->{mirrorlist}) { | ||
| 212 | $medium->{mediacfg} = $mirrorlist2mediamap->{$medium->{mirrorlist}}{$medium->{'with-dir'}}; | ||
| 213 | } elsif ($medium->{url}) { | ||
| 214 | $medium->{mediacfg} = $url2mediamap->{$medium->{url}}; | ||
| 215 | } | ||
| 216 | } | ||
| 217 | } | ||
| 218 | |||
| 219 | =item read_config($urpm, $nocheck) | ||
| 220 | |||
| 221 | Loads /etc/urpmi/urpmi.cfg and performs basic checks. | ||
| 222 | It does not handle old format: <name> <url> [with <path_hdlist>] | ||
| 223 | |||
| 224 | =cut | ||
| 225 | |||
| 226 | sub read_config { | ||
| 227 | my ($urpm, $nocheck) = @_; | ||
| 228 | return if $urpm->{media}; #- media already loaded | ||
| 229 | $urpm->{media} = []; | ||
| 230 | my $config = urpm::cfg::load_config($urpm->{config}) | ||
| 231 | or $urpm->{fatal}(6, $urpm::cfg::err); | ||
| 232 | |||
| 233 | #- per-media options | ||
| 234 | read_config_add_passwords($urpm, $config); | ||
| 235 | |||
| 236 | my @media; | ||
| 237 | foreach my $m (@{$config->{media}}) { | ||
| 238 | my $medium = _only_media_opts_read($m); | ||
| 239 | |||
| 240 | if (!$medium->{url} && !$medium->{mirrorlist}) { | ||
| 241 | #- recover the url the old deprecated way... | ||
| 242 | #- only useful for migration, new urpmi.cfg will use netrc | ||
| 243 | recover_url_from_list($urpm, $medium); | ||
| 244 | $medium->{url} or $urpm->{error}("unable to find url in list file $medium->{name}, medium ignored"); | ||
| 245 | } | ||
| 246 | push @media, $medium; | ||
| 247 | } | ||
| 248 | |||
| 249 | # associate medias read from the config file with their description in a | ||
| 250 | # media.cfg file | ||
| 251 | # @media content will be modified and then add_existing medium will take | ||
| 252 | # care of copying the media to $urpm | ||
| 253 | _associate_media_with_mediacfg($urpm, \@media); | ||
| 254 | |||
| 255 | add_existing_medium($urpm, $_, $nocheck) foreach @media; | ||
| 256 | |||
| 257 | eval { require urpm::ldap; urpm::ldap::load_ldap_media($urpm) }; | ||
| 258 | } | ||
| 259 | |||
| 260 | #- if invalid, set {ignore} | ||
| 261 | sub check_existing_medium { | ||
| 262 | my ($urpm, $medium) = @_; | ||
| 263 | |||
| 264 | my $err; | ||
| 265 | if (!$medium->{url} && !$medium->{mirrorlist}) { | ||
| 266 | $err = $medium->{virtual} ? | ||
| 267 | N("virtual medium \"%s\" should have a clear url, medium ignored", | ||
| 268 | $medium->{name}) : | ||
| 269 | N("unable to access list file of \"%s\", medium ignored", $medium->{name}); | ||
| 270 | } elsif (!$medium->{ignore} | ||
| 271 | && !-r any_synthesis($urpm, $medium)) { | ||
| 272 | $err = N("unable to access synthesis file of \"%s\", medium ignored", $medium->{name}); | ||
| 273 | } | ||
| 274 | if ($err) { | ||
| 275 | $medium->{ignore} = 1; | ||
| 276 | $urpm->{error}($err); | ||
| 277 | } | ||
| 278 | } | ||
| 279 | |||
| 280 | sub _migrate__with_synthesis { | ||
| 281 | my ($medium, $with_synthesis) = @_; | ||
| 282 | |||
| 283 | #- try to migrate to media_info_dir | ||
| 284 | my $b = basename($with_synthesis); | ||
| 285 | if ($b eq 'synthesis.hdlist.cz' || $b eq 'hdlist.cz') { | ||
| 286 | $medium->{media_info_dir} = dirname($with_synthesis); | ||
| 287 | } else { | ||
| 288 | $with_synthesis =~ s/(synthesis\.)?(hdlist.*\.cz)$/synthesis.$2/; | ||
| 289 | $medium->{with_synthesis} = $with_synthesis; | ||
| 290 | } | ||
| 291 | } | ||
| 292 | |||
| 293 | #- probe medium to be used, take old medium into account too. | ||
| 294 | sub add_existing_medium { | ||
| 295 | my ($urpm, $medium, $nocheck) = @_; | ||
| 296 | |||
| 297 | if (name2medium($urpm, $medium->{name})) { | ||
| 298 | $urpm->{error}(N("trying to override existing medium \"%s\", skipping", $medium->{name})); | ||
| 299 | return; | ||
| 300 | } | ||
| 301 | |||
| 302 | if ($medium->{with_hdlist}) { | ||
| 303 | _migrate__with_synthesis($medium, delete $medium->{with_hdlist}); | ||
| 304 | $urpm->{modified} = 1; | ||
| 305 | } | ||
| 306 | |||
| 307 | check_existing_medium($urpm, $medium) if !$nocheck; | ||
| 308 | |||
| 309 | _migrate_removable_device($urpm, $medium); | ||
| 310 | |||
| 311 | #- clear URLs for trailing /es. | ||
| 312 | $medium->{url} and $medium->{url} =~ s|(.*?)/*$|$1|; | ||
| 313 | |||
| 314 | push @{$urpm->{media}}, $medium; | ||
| 315 | } | ||
| 316 | |||
| 317 | sub file_from_file_url { | ||
| 318 | my ($url) = @_; | ||
| 319 | $url =~ m!^(?:file:/)?(/.*)! && $1; | ||
| 320 | } | ||
| 321 | |||
| 322 | sub _local_file { | ||
| 323 | my ($medium) = @_; | ||
| 324 | $medium->{url} && file_from_file_url($medium->{url}); | ||
| 325 | } | ||
| 326 | |||
| 327 | sub _is_local_virtual { | ||
| 328 | my ($medium) = @_; | ||
| 329 | $medium->{virtual} && _local_file($medium); | ||
| 330 | } | ||
| 331 | sub _is_remote_virtual { | ||
| 332 | my ($medium) = @_; | ||
| 333 | $medium->{virtual} && !_local_file($medium); | ||
| 334 | } | ||
| 335 | |||
| 336 | sub _url_with_synthesis_basename { | ||
| 337 | my ($medium) = @_; | ||
| 338 | |||
| 339 | $medium->{with_synthesis} | ||
| 340 | ? basename($medium->{with_synthesis}) | ||
| 341 | : 'synthesis.hdlist.cz'; | ||
| 342 | } | ||
| 343 | sub _synthesis_dir_rel { | ||
| 344 | my ($medium) = @_; | ||
| 345 | $medium->{'no-media-info'} || $medium->{unknown_media_info} and return; | ||
| 346 | |||
| 347 | $medium->{with_synthesis} | ||
| 348 | ? "$medium->{with_synthesis}/.." | ||
| 349 | : $medium->{media_info_dir}; | ||
| 350 | } | ||
| 351 | sub _synthesis_dir { | ||
| 352 | my ($medium) = @_; | ||
| 353 | my $rel = _synthesis_dir_rel($medium) or return; | ||
| 354 | |||
| 355 | my $base = file_from_local_medium($medium) || $medium->{url}; | ||
| 356 | reduce_pathname("$base/$rel"); | ||
| 357 | } | ||
| 358 | |||
| 359 | # the difference between _valid_synthesis_dir and _synthesis_dir | ||
| 360 | # is only to handle upgrades from older urpmi.cfg where no {media_info_dir} | ||
| 361 | # meant no-media-info | ||
| 362 | sub _valid_synthesis_dir { | ||
| 363 | my ($medium) = @_; | ||
| 364 | my $dir = _synthesis_dir($medium); | ||
| 365 | $dir && -d $dir; | ||
| 366 | } | ||
| 367 | |||
| 368 | sub _url_with_synthesis_rel { | ||
| 369 | my ($medium) = @_; | ||
| 370 | |||
| 371 | $medium->{with_synthesis} || | ||
| 372 | "$medium->{media_info_dir}/synthesis.hdlist.cz"; | ||
| 373 | |||
| 374 | } | ||
| 375 | sub _url_with_synthesis { | ||
| 376 | my ($medium) = @_; | ||
| 377 | my $rel = _url_with_synthesis_rel($medium) or return; | ||
| 378 | |||
| 379 | my $base = file_from_local_medium($medium) || $medium->{url}; | ||
| 380 | reduce_pathname("$base/$rel"); | ||
| 381 | } | ||
| 382 | |||
| 383 | sub synthesis { | ||
| 384 | my ($medium) = @_; | ||
| 385 | statedir_media_info_basename($medium, 'synthesis.hdlist', '.cz'); | ||
| 386 | } | ||
| 387 | |||
| 388 | sub statedir_media_info_basename { | ||
| 389 | my ($medium, $prefix, $suffix) = @_; | ||
| 390 | $medium->{name} && "$prefix.$medium->{name}$suffix"; | ||
| 391 | } | ||
| 392 | |||
| 393 | sub statedir_media_info_dir { | ||
| 394 | my ($urpm, $medium) = @_; | ||
| 395 | $medium->{name} && "$urpm->{statedir}/$medium->{name}"; | ||
| 396 | } | ||
| 397 | |||
| 398 | sub old_statedir_media_info_file { | ||
| 399 | my ($urpm, $medium, $prefix, $suffix) = @_; | ||
| 400 | $medium->{name} && "$urpm->{statedir}/" . statedir_media_info_basename($medium, $prefix, $suffix); | ||
| 401 | } | ||
| 402 | sub new_statedir_media_info_file { | ||
| 403 | my ($urpm, $medium, $prefix, $suffix) = @_; | ||
| 404 | my $dir = statedir_media_info_dir($urpm, $medium); | ||
| 405 | $dir && "$dir/$prefix$suffix"; | ||
| 406 | } | ||
| 407 | sub statedir_media_info_file { | ||
| 408 | my ($urpm, $medium, $prefix, $suffix) = @_; | ||
| 409 | my $dir = statedir_media_info_dir($urpm, $medium); | ||
| 410 | -d $dir ? "$dir/$prefix$suffix" : old_statedir_media_info_file($urpm, $medium, $prefix, $suffix); | ||
| 411 | } | ||
| 412 | sub statedir_synthesis { | ||
| 413 | my ($urpm, $medium) = @_; | ||
| 414 | statedir_media_info_file($urpm, $medium, 'synthesis.hdlist', '.cz'); | ||
| 415 | } | ||
| 416 | sub statedir_descriptions { | ||
| 417 | my ($urpm, $medium) = @_; | ||
| 418 | statedir_media_info_file($urpm, $medium, 'descriptions', ''); | ||
| 419 | } | ||
| 420 | sub statedir_names { | ||
| 421 | my ($urpm, $medium) = @_; | ||
| 422 | old_statedir_media_info_file($urpm, $medium, 'names', ''); | ||
| 423 | } | ||
| 424 | sub statedir_MD5SUM { | ||
| 425 | my ($urpm, $medium) = @_; | ||
| 426 | statedir_media_info_file($urpm, $medium, 'MD5SUM', ''); | ||
| 427 | } | ||
| 428 | sub statedir_hdlist { | ||
| 429 | my ($urpm, $medium) = @_; | ||
| 430 | statedir_media_info_file($urpm, $medium, 'hdlist', '.cz'); | ||
| 431 | } | ||
| 432 | sub statedir_xml_info { | ||
| 433 | my ($urpm, $medium, $xml_info) = @_; | ||
| 434 | statedir_media_info_file($urpm, $medium, $xml_info, '.xml.lzma'); | ||
| 435 | } | ||
| 436 | sub cachedir_with_synthesis { | ||
| 437 | my ($urpm, $medium) = @_; | ||
| 438 | _url_with_synthesis($medium) && "$urpm->{cachedir}/partial/synthesis.hdlist.cz"; | ||
| 439 | } | ||
| 440 | sub any_synthesis { | ||
| 441 | my ($urpm, $medium) = @_; | ||
| 442 | my $f = _is_local_virtual($medium) ? _url_with_synthesis($medium) | ||
| 443 | : statedir_synthesis($urpm, $medium); | ||
| 444 | -e $f && $f; | ||
| 445 | } | ||
| 446 | sub any_media_info_file { | ||
| 447 | my ($urpm, $medium, $prefix, $suffix, $quiet, $o_callback) = @_; | ||
| 448 | |||
| 449 | if (my $base = _local_file($medium)) { | ||
| 450 | my $f = $medium->{with_synthesis} | ||
| 451 | ? reduce_pathname("$base/$prefix." . _synthesis_suffix($medium) . $suffix) | ||
| 452 | : _synthesis_dir($medium) . "/$prefix$suffix"; | ||
| 453 | |||
| 454 | if (! -e $f) { | ||
| 455 | # in some weird cases (iso on disk), the hdlist is not available where it should be, | ||
| 456 | # but we can use the statedir copy | ||
| 457 | $f = statedir_media_info_file($urpm, $medium, $prefix, $suffix); | ||
| 458 | } | ||
| 459 | |||
| 460 | -e $f && $f; | ||
| 461 | } else { | ||
| 462 | _any_media_info__or_download($urpm, $medium, $prefix, $suffix, $quiet, $o_callback); | ||
| 463 | } | ||
| 464 | } | ||
| 465 | sub any_hdlist { | ||
| 466 | my ($urpm, $medium, $quiet) = @_; | ||
| 467 | any_media_info_file($urpm, $medium, 'hdlist', '.cz', $quiet, \&urpm::download::sync_logger); | ||
| 468 | } | ||
| 469 | sub any_xml_info { | ||
| 470 | my ($urpm, $medium, $xml_info, $quiet, $o_callback) = @_; | ||
| 471 | any_media_info_file($urpm, $medium, $xml_info, '.xml.lzma', $quiet, $o_callback || \&urpm::download::sync_logger); | ||
| 472 | } | ||
| 473 | |||
| 474 | sub name2medium { | ||
| 475 | my ($urpm, $name) = @_; | ||
| 476 | my ($medium) = grep { $_->{name} eq $name } @{$urpm->{media}}; | ||
| 477 | $medium; | ||
| 478 | } | ||
| 479 | |||
| 480 | sub userdirs { | ||
| 481 | my ($urpm) = @_; | ||
| 482 | my $prefix = urpm::userdir_prefix($urpm); | ||
| 483 | grep { m!^\Q$prefix\E\d+$! && -d $_ && ! -l $_ } glob("$prefix*"); | ||
| 484 | } | ||
| 485 | |||
| 486 | sub remove_user_media_info_files { | ||
| 487 | my ($urpm, $medium) = @_; | ||
| 488 | |||
| 489 | foreach my $dir (userdirs($urpm)) { | ||
| 490 | require File::Glob; | ||
| 491 | # we can't use perl's glob() because $medium->{name} can contain spaces | ||
| 492 | my @files = map { File::Glob::bsd_glob("$dir/*.$medium->{name}.$_") } 'cz', 'xml.lzma' or next; | ||
| 493 | |||
| 494 | $urpm->{log}("cleaning $dir"); | ||
| 495 | foreach (@files) { | ||
| 496 | unlink $_ or $urpm->{error}("removing $_ failed"); | ||
| 497 | } | ||
| 498 | } | ||
| 499 | } | ||
| 500 | |||
| 501 | #- probe device associated with a removable device. | ||
| 502 | sub _migrate_removable_device { | ||
| 503 | my ($urpm, $medium) = @_; | ||
| 504 | |||
| 505 | $medium->{url} or return; | ||
| 506 | |||
| 507 | # always drop {removable}, it is obsolete | ||
| 508 | # (nb: for iso files, {removable} has already been renamed into {iso} internally) | ||
| 509 | delete $medium->{removable}; | ||
| 510 | |||
| 511 | if (my $url = _migrate_removable_url($medium->{url})) { | ||
| 512 | $medium->{url} = $url; | ||
| 513 | } else { | ||
| 514 | $urpm->{error}(N("failed to migrate removable device, ignoring media")); | ||
| 515 | $medium->{ignore} = 1; | ||
| 516 | } | ||
| 517 | } | ||
| 518 | |||
| 519 | sub _migrate_removable_url { | ||
| 520 | my ($url) = @_; | ||
| 521 | |||
| 522 | if ($url =~ /^removable/) { | ||
| 523 | $url =~ s!^removable(.*?)://!/!; | ||
| 524 | if ($url =~ s!/(mnt|media)/cd\w+/?!cdrom://!i) { | ||
| 525 | # success! | ||
| 526 | } else { | ||
| 527 | return; | ||
| 528 | } | ||
| 529 | } | ||
| 530 | $url; | ||
| 531 | } | ||
| 532 | |||
| 533 | |||
| 534 | =item write_urpmi_cfg($urpm) | ||
| 535 | |||
| 536 | Writes the urpmi.cfg file. | ||
| 537 | |||
| 538 | =cut | ||
| 539 | |||
| 540 | sub write_urpmi_cfg { | ||
| 541 | my ($urpm) = @_; | ||
| 542 | |||
| 543 | #- avoid trashing exiting configuration if it wasn't loaded | ||
| 544 | $urpm->{media} or return; | ||
| 545 | |||
| 546 | my $config = { | ||
| 547 | #- global config options found in the config file, without the ones | ||
| 548 | #- set from the command-line | ||
| 549 | global => $urpm->{global_config}, | ||
| 550 | media => [ map { _only_media_opts_write($_) } grep { !$_->{external} } @{$urpm->{media}} ], | ||
| 551 | }; | ||
| 552 | remove_passwords_and_write_private_netrc($urpm, $config); | ||
| 553 | |||
| 554 | #- urpmi.cfg must be world-readable, else mgaapplet and urpm* commands run as | ||
| 555 | #- a normal user won't be able to read it. We enforce umask here in the case | ||
| 556 | #- where the msec security level is set to 'secure' (which means umask 077) | ||
| 557 | #- or where we are run from a gdm-x-session (mga#24636) | ||
| 558 | my $old_umask = umask 0022; | ||
| 559 | urpm::cfg::dump_config($urpm->{config}, $config) | ||
| 560 | or $urpm->{fatal}(6, N("unable to write config file [%s]", $urpm->{config})); | ||
| 561 | umask $old_umask; | ||
| 562 | |||
| 563 | $urpm->{log}(N("wrote config file [%s]", $urpm->{config})); | ||
| 564 | |||
| 565 | #- everything should be synced now. | ||
| 566 | delete $urpm->{modified}; | ||
| 567 | } | ||
| 568 | |||
| 569 | sub write_config { | ||
| 570 | my ($urpm) = @_; | ||
| 571 | |||
| 572 | write_urpmi_cfg($urpm); | ||
| 573 | } | ||
| 574 | |||
| 575 | |||
| 576 | sub _tempignore { | ||
| 577 | my ($medium, $ignore) = @_; | ||
| 578 | $medium->{ignore} = $ignore; | ||
| 579 | } | ||
| 580 | |||
| 581 | =item configure($urpm, %options) | ||
| 582 | |||
| 583 | Read urpmi.cfg file as well as necessary synthesis files. | ||
| 584 | |||
| 585 | Options : | ||
| 586 | |||
| 587 | =over | ||
| 588 | |||
| 589 | =item * | ||
| 590 | |||
| 591 | root (deprecated, set directly $urpm->{root}) | ||
| 592 | |||
| 593 | =item * | ||
| 594 | |||
| 595 | cmdline_skiplist | ||
| 596 | |||
| 597 | =item * | ||
| 598 | |||
| 599 | download_callback (used by _auto_update_media) | ||
| 600 | |||
| 601 | =item * | ||
| 602 | |||
| 603 | callback (urpmf) | ||
| 604 | |||
| 605 | =item * | ||
| 606 | |||
| 607 | nodepslist (for urpmq, urpmf: when we don't need the synthesis) | ||
| 608 | |||
| 609 | =item * | ||
| 610 | |||
| 611 | no_skiplist (urpmf) | ||
| 612 | |||
| 613 | =item * | ||
| 614 | |||
| 615 | synthesis (use this synthesis file, and only this synthesis file) | ||
| 616 | |||
| 617 | =item * | ||
| 618 | |||
| 619 | parallel | ||
| 620 | |||
| 621 | =item * | ||
| 622 | |||
| 623 | usedistrib (otherwise uses urpmi.cfg) | ||
| 624 | |||
| 625 | =item * | ||
| 626 | |||
| 627 | media | ||
| 628 | |||
| 629 | =item * | ||
| 630 | |||
| 631 | excludemedia | ||
| 632 | |||
| 633 | =item * | ||
| 634 | |||
| 635 | sortmedia | ||
| 636 | |||
| 637 | =item * | ||
| 638 | |||
| 639 | update | ||
| 640 | |||
| 641 | =item * | ||
| 642 | |||
| 643 | searchmedia | ||
| 644 | |||
| 645 | =back | ||
| 646 | |||
| 647 | =cut | ||
| 648 | |||
| 649 | sub configure { | ||
| 650 | my ($urpm, %options) = @_; | ||
| 651 | |||
| 652 | clean($urpm); | ||
| 653 | |||
| 654 | $options{parallel} && $options{usedistrib} and $urpm->{fatal}(1, N("Can't use parallel mode with use-distrib mode")); | ||
| 655 | |||
| 656 | if ($options{parallel}) { | ||
| 657 | require urpm::parallel; | ||
| 658 | urpm::parallel::configure($urpm, $options{parallel}); | ||
| 659 | |||
| 660 | if (!$options{media} && $urpm->{parallel_handler}{media}) { | ||
| 661 | $options{media} = $urpm->{parallel_handler}{media}; | ||
| 662 | $urpm->{log}->(N("using associated media for parallel mode: %s", $options{media})); | ||
| 663 | } | ||
| 664 | } else { | ||
| 665 | #- nb: can't have both parallel and root | ||
| 666 | $urpm->{root} = $options{root} if $options{root}; | ||
| 667 | } | ||
| 668 | |||
| 669 | if ($urpm->{root} && ! -c "$urpm->{root}/dev/null") { | ||
| 670 | mkdir "$urpm->{root}/dev"; | ||
| 671 | system("/bin/cp", "-a", '/dev/null', "$urpm->{root}/dev"); | ||
| 672 | } | ||
| 673 | |||
| 674 | if ($options{synthesis}) { | ||
| 675 | if ($options{synthesis} ne 'none') { | ||
| 676 | #- synthesis take precedence over media, update options. | ||
| 677 | $options{media} || $options{excludemedia} || $options{sortmedia} || $options{update} || $options{usedistrib} || $options{parallel} and | ||
| 678 | $urpm->{fatal}(1, N("--synthesis cannot be used with --media, --excludemedia, --sortmedia, --update, --use-distrib or --parallel")); | ||
| 679 | |||
| 680 | my $synthesis = $options{synthesis}; | ||
| 681 | if ($synthesis !~ m!^/!) { | ||
| 682 | require Cwd; | ||
| 683 | $synthesis = Cwd::getcwd() . '/' . $synthesis; | ||
| 684 | } | ||
| 685 | my ($url, $with) = $synthesis =~ m!(.*)/+(media_info/+synthesis\.hdlist\.cz)$! ? ($1, $2) : | ||
| 686 | (dirname($synthesis), basename($synthesis)); | ||
| 687 | |||
| 688 | $urpm->{media} = []; | ||
| 689 | add_medium($urpm, 'Virtual', $url, $with, %options, virtual => 1, on_the_fly => 1); | ||
| 690 | } | ||
| 691 | } elsif ($options{usedistrib}) { | ||
| 692 | $urpm->{media} = []; | ||
| 693 | add_distrib_media($urpm, "Virtual", $options{usedistrib}, %options, virtual => 1, on_the_fly => 1); | ||
| 694 | } else { | ||
| 695 | read_config($urpm, ''); | ||
| 696 | if (!$options{media} && $urpm->{options}{'default-media'}) { | ||
| 697 | $options{media} = $urpm->{options}{'default-media'}; | ||
| 698 | } | ||
| 699 | } | ||
| 700 | |||
| 701 | if ($options{media}) { | ||
| 702 | delete $_->{modified} foreach @{$urpm->{media} || []}; | ||
| 703 | select_media($urpm, split /,/, $options{media}); | ||
| 704 | foreach (@{$urpm->{media} || []}) { | ||
| 705 | _tempignore($_, !$_->{modified}); | ||
| 706 | } | ||
| 707 | } | ||
| 708 | if ($options{searchmedia}) { | ||
| 709 | foreach (select_media_by_name($urpm, [ split /,/, $options{searchmedia} ])) { | ||
| 710 | #- Ensure this media is selected | ||
| 711 | $_->{modified} = 1; | ||
| 712 | _tempignore($_, 0); | ||
| 713 | $_->{searchmedia} = 1; | ||
| 714 | } | ||
| 715 | } | ||
| 716 | if ($options{update}) { | ||
| 717 | foreach (grep { !$_->{ignore} && $_->{update} } @{$urpm->{media} || []}) { | ||
| 718 | #- Ensure update media are selected | ||
| 719 | $_->{modified} = 1; | ||
| 720 | _tempignore($_, 0); | ||
| 721 | $_->{searchmedia} = 1; | ||
| 722 | } | ||
| 723 | } | ||
| 724 | if ($options{excludemedia}) { | ||
| 725 | delete $_->{modified} foreach @{$urpm->{media} || []}; | ||
| 726 | foreach (select_media_by_name($urpm, [ split /,/, $options{excludemedia} ])) { | ||
| 727 | $_->{modified} = 1; | ||
| 728 | #- this is only a local ignore that will not be saved. | ||
| 729 | _tempignore($_, 1); | ||
| 730 | } | ||
| 731 | } | ||
| 732 | if ($options{sortmedia}) { | ||
| 733 | my @sorted_media = map { select_media_by_name($urpm, [$_]) } split(/,/, $options{sortmedia}); | ||
| 734 | my @remaining = difference2($urpm->{media}, \@sorted_media); | ||
| 735 | $urpm->{media} = [ @sorted_media, @remaining ]; | ||
| 736 | } | ||
| 737 | _auto_update_media($urpm, %options); | ||
| 738 | |||
| 739 | _pick_mirror_if_needed($urpm, $_, '') foreach non_ignored_media($urpm); | ||
| 740 | |||
| 741 | if (!$options{nodepslist}) { | ||
| 742 | parse_media($urpm, \%options); | ||
| 743 | |||
| 744 | #- determine package to withdraw (from skip.list file) only if something should be withdrawn. | ||
| 745 | _compute_flags_for_skiplist($urpm, $options{cmdline_skiplist}) if !$options{no_skiplist}; | ||
| 746 | _compute_flags_for_instlist($urpm); | ||
| 747 | } | ||
| 748 | } | ||
| 749 | |||
| 750 | #- for remote "virtual" media | ||
| 751 | #- options: download_callback, nomd5sum, quiet, nopubkey | ||
| 752 | sub _auto_update_media { | ||
| 753 | my ($urpm, %options) = @_; | ||
| 754 | |||
| 755 | $options{callback} = delete $options{download_callback}; | ||
| 756 | |||
| 757 | foreach (grep { _is_remote_virtual($_) || $urpm->{options}{'auto-update'} } | ||
| 758 | non_ignored_media($urpm)) { | ||
| 759 | _update_medium($urpm, $_, %options); | ||
| 760 | } | ||
| 761 | } | ||
| 762 | |||
| 763 | |||
| 764 | =item needed_extra_media($urpm) | ||
| 765 | |||
| 766 | Return 3 booleans telling whether nonfree & tainted & i?86 packages are installed respectively. | ||
| 767 | |||
| 768 | =cut | ||
| 769 | |||
| 770 | sub needed_extra_media { | ||
| 771 | my ($urpm) = @_; | ||
| 772 | my $db = urpm::db_open_or_die_($urpm); | ||
| 773 | my ($nonfree, $tainted, $add32bit); | ||
| 774 | $db->traverse(sub { | ||
| 775 | my ($pkg) = @_; | ||
| 776 | return if $nonfree && $tainted && $add32bit; | ||
| 777 | my $rel = $pkg->release; | ||
| 778 | $nonfree ||= $rel =~ /nonfree$/; | ||
| 779 | $tainted ||= $rel =~ /tainted$/; | ||
| 780 | $add32bit ||= $pkg->arch =~ /i.86/; | ||
| 781 | }); | ||
| 782 | ($nonfree, $tainted, $add32bit); | ||
| 783 | } | ||
| 784 | |||
| 785 | sub is_media_to_add_by_default { | ||
| 786 | my ($urpm, $distribconf, $medium, $product_id, $nonfree, $tainted, $add32bit) = @_; | ||
| 787 | my $add_by_default = !$distribconf->getvalue($medium, 'noauto'); | ||
| 788 | my @media_types = split(':', $distribconf->getvalue($medium, 'media_type')); | ||
| 789 | return $add_by_default if !@media_types; | ||
| 790 | my $non_regular_medium = intersection(\@media_types, [ qw(backports debug source testing) ]); | ||
| 791 | if ($product_id->{product} eq 'Free') { | ||
| 792 | if (member('non-free', @media_types)) { | ||
| 793 | $urpm->{log}(N("ignoring non-free medium `%s'", $medium)); | ||
| 794 | $add_by_default = 0; | ||
| 795 | } | ||
| 796 | } else { | ||
| 797 | if (!$add_by_default && !$non_regular_medium) { | ||
| 798 | my $medium_name = $distribconf->getvalue($medium, 'name') || ''; | ||
| 799 | # Don't enable 32-bit media by default on 64-bit systems (mga#24376). '32bit' only appears | ||
| 800 | # in the medium name in the 64-bit media info, so we can simply filter on that. | ||
| 801 | if ($medium_name =~ /Nonfree/ && ($add32bit || $medium_name !~ /32bit/) && $nonfree) { | ||
| 802 | $add_by_default = 1; | ||
| 803 | $urpm->{log}(N("un-ignoring non-free medium `%s' b/c nonfree packages are installed", $medium_name)); | ||
| 804 | } | ||
| 805 | if ($medium_name =~ /Tainted/ && ($add32bit || $medium_name !~ /32bit/) && $tainted) { | ||
| 806 | $add_by_default = 1; | ||
| 807 | $urpm->{log}(N("un-ignoring tainted medium `%s' b/c tainted packages are installed", $medium_name)); | ||
| 808 | } | ||
| 809 | } | ||
| 810 | } | ||
| 811 | if ($add32bit) { | ||
| 812 | if (!$add_by_default && !$non_regular_medium) { | ||
| 813 | my $medium_name = $distribconf->getvalue($medium, 'name') || ''; | ||
| 814 | if ($medium_name =~ /Core/ && $medium_name =~ /32bit/) { | ||
| 815 | $add_by_default = 1; | ||
| 816 | $urpm->{log}(N("un-ignoring 32bit medium `%s' b/c 32-bit packages are installed or system is 32-bit EFI", $medium_name)); | ||
| 817 | } | ||
| 818 | } | ||
| 819 | } | ||
| 820 | $add_by_default; | ||
| 821 | } | ||
| 822 | |||
| 823 | sub non_ignored_media { | ||
| 824 | my ($urpm, $b_only_marked_update) = @_; | ||
| 825 | |||
| 826 | grep { !$_->{ignore} && (!$b_only_marked_update || $_->{update}) } @{$urpm->{media} || []}; | ||
| 827 | } | ||
| 828 | |||
| 829 | sub all_media_to_update { | ||
| 830 | my ($urpm, $b_only_marked_update) = @_; | ||
| 831 | |||
| 832 | grep { !$_->{static} && !urpm::is_cdrom_url($_->{url}) && !$_->{iso} } non_ignored_media($urpm, $b_only_marked_update); | ||
| 833 | } | ||
| 834 | |||
| 835 | sub parse_media { | ||
| 836 | my ($urpm, $options) = @_; | ||
| 837 | |||
| 838 | foreach (non_ignored_media($urpm)) { | ||
| 839 | delete @$_{qw(start end)}; | ||
| 840 | _parse_synthesis_or_ignore($urpm, $_, $options->{callback}); | ||
| 841 | |||
| 842 | if ($_->{searchmedia}) { | ||
| 843 | $urpm->{searchmedia} = 1; | ||
| 844 | $urpm->{debug} and $urpm->{debug}(N("Search start: %s end: %s", $_->{start}, $_->{end})); | ||
| 845 | } | ||
| 846 | |||
| 847 | $< == 0 and _generate_medium_names($urpm, $_); | ||
| 848 | } | ||
| 849 | } | ||
| 850 | |||
| 851 | sub _compute_flags_for_skiplist { | ||
| 852 | my ($urpm, $cmdline_skiplist) = @_; | ||
| 853 | my %uniq; | ||
| 854 | $urpm->compute_flags( | ||
| 855 | urpm::sys::get_packages_list($urpm->{skiplist}, $cmdline_skiplist), | ||
| 856 | skip => 1, | ||
| 857 | callback => sub { | ||
| 858 | my ($urpm, $pkg) = @_; | ||
| 859 | $pkg->is_arch_compat && ! exists $uniq{$pkg->fullname} or return; | ||
| 860 | $uniq{$pkg->fullname} = undef; | ||
| 861 | $urpm->{debug} and $urpm->{debug}(N("skipping package %s", scalar($pkg->fullname))); | ||
| 862 | }, | ||
| 863 | ); | ||
| 864 | } | ||
| 865 | |||
| 866 | sub _compute_flags_for_instlist { | ||
| 867 | my ($urpm) = @_; | ||
| 868 | |||
| 869 | my %uniq; | ||
| 870 | $urpm->compute_flags( | ||
| 871 | urpm::sys::get_packages_list($urpm->{instlist}), | ||
| 872 | disable_obsolete => 1, | ||
| 873 | callback => sub { | ||
| 874 | my ($urpm, $pkg) = @_; | ||
| 875 | $pkg->is_arch_compat && ! exists $uniq{$pkg->fullname} or return; | ||
| 876 | $uniq{$pkg->fullname} = undef; | ||
| 877 | $urpm->{log}(N("would install instead of upgrade package %s", scalar($pkg->fullname))); | ||
| 878 | }, | ||
| 879 | ); | ||
| 880 | |||
| 881 | } | ||
| 882 | |||
| 883 | sub maybe_find_zeroconf { | ||
| 884 | my ($urpm, $url, $options) = @_; | ||
| 885 | if (delete $options->{zeroconf}) { | ||
| 886 | $url and die "unexpected url $url together with zeroconf\n"; | ||
| 887 | $url = find_zeroconf_repository($urpm); | ||
| 888 | if ($url) { | ||
| 889 | $url = urpm::mirrors::_add__with_dir($url, delete $options->{"with-dir"}); | ||
| 890 | delete $options->{mirrorlist}; | ||
| 891 | } | ||
| 892 | } | ||
| 893 | return $url; | ||
| 894 | } | ||
| 895 | |||
| 896 | sub find_zeroconf_repository { | ||
| 897 | my ($urpm) = @_; | ||
| 898 | |||
| 899 | my $zeroconf_timeout = 10; | ||
| 900 | my $res; | ||
| 901 | eval { | ||
| 902 | local $SIG{ALRM} = sub { die "timeout" }; | ||
| 903 | alarm($zeroconf_timeout); | ||
| 904 | |||
| 905 | $urpm->{debug} and $urpm->{debug}("trying to find a zeroconf repository"); | ||
| 906 | require Net::Bonjour; | ||
| 907 | $res = Net::Bonjour->new('mdv_urpmi'); | ||
| 908 | |||
| 909 | alarm(0); | ||
| 910 | }; | ||
| 911 | |||
| 912 | if ($@) { | ||
| 913 | $urpm->{error}("zeroconf error: $@"), return; | ||
| 914 | } | ||
| 915 | |||
| 916 | require urpm::mirrors; | ||
| 917 | my $product_id = urpm::mirrors::parse_LDAP_namespace_structure(cat_('/etc/product.id')); | ||
| 918 | my $path_suffix = join('/', lc($product_id->{branch}), $product_id->{version}, $product_id->{arch}); | ||
| 919 | |||
| 920 | foreach my $entry ($res->entries) { | ||
| 921 | my $base_url = $entry->attribute('protocol') . '://' . $entry->address . ':' . $entry->port . $entry->attribute('path'); | ||
| 922 | my $url = $base_url . '/' . $path_suffix; | ||
| 923 | my $distribconf = _new_distribconf_and_download($urpm, { url => $url }); | ||
| 924 | if ($distribconf) { | ||
| 925 | $urpm->{log}(sprintf("found zeroconf repository: %s", $url)); | ||
| 926 | return $url; | ||
| 927 | } | ||
| 928 | } | ||
| 929 | |||
| 930 | $urpm->{debug} and $urpm->{debug}("unable to find zeroconf repository"); | ||
| 931 | return; | ||
| 932 | } | ||
| 933 | |||
| 934 | =item add_medium($urpm, $name, $url, $with_synthesis, %options) | ||
| 935 | |||
| 936 | Add a new medium and sync the config file accordingly. | ||
| 937 | |||
| 938 | It returns the new medium's name (might be different from the requested | ||
| 939 | name if index_name was specified). | ||
| 940 | |||
| 941 | Options: ignore, index_name, nolock, update, virtual, media_info_dir, mirrorlist, zeroconf, with-dir, xml-info, on_the_fly | ||
| 942 | |||
| 943 | =cut | ||
| 944 | |||
| 945 | sub add_medium { | ||
| 946 | my ($urpm, $name, $url, $with_synthesis, %options) = @_; | ||
| 947 | |||
| 948 | #- make sure configuration has been read. | ||
| 949 | $urpm->{media} or die "caller should have used ->read_config or ->configure first"; | ||
| 950 | |||
| 951 | #- if a medium with that name has already been found, we have to exit now | ||
| 952 | if (defined $options{index_name}) { | ||
| 953 | my ($i, $basename) = ($options{index_name}, $name); | ||
| 954 | while (1) { | ||
| 955 | ++$i; | ||
| 956 | $name = $basename . ($i == 1 ? '' : $i); | ||
| 957 | last if !name2medium($urpm, $name); | ||
| 958 | } | ||
| 959 | } else { | ||
| 960 | name2medium($urpm, $name) and $urpm->{fatal}(5, N("medium \"%s\" already exists", $name)); | ||
| 961 | } | ||
| 962 | |||
| 963 | $url = maybe_find_zeroconf($urpm, $url, \%options); | ||
| 964 | |||
| 965 | $url =~ s,/*$,,; #- clear URLs for trailing /es. | ||
| 966 | |||
| 967 | #- creating the medium info. | ||
| 968 | my $medium = { name => $name, | ||
| 969 | url => $url, | ||
| 970 | modified => !$options{ignore}, | ||
| 971 | (defined $options{'verify-rpm'} ? ('verify-rpm' => $options{'verify-rpm'}) : ()), | ||
| 972 | }; | ||
| 973 | foreach (qw(downloader update ignore media_info_dir mirrorlist with-dir xml-info)) { | ||
| 974 | $medium->{$_} = $options{$_} if exists $options{$_}; | ||
| 975 | } | ||
| 976 | |||
| 977 | #- The medium files must be world-readable, else mgaapplet and urpm* commands run | ||
| 978 | #- as a normal user won't be able to read them. We enforce umask here in the case | ||
| 979 | #- where the msec security level is set to 'secure' (which means umask 077) or | ||
| 980 | #- where we are run from a gdm-x-session (mga#24636) | ||
| 981 | my $old_umask = umask 0022; | ||
| 982 | #- those files must not be there (cf mdvbz#36267) | ||
| 983 | _clean_statedir_medium_files($urpm, $medium); | ||
| 984 | if (!($options{virtual} && _local_file($medium)) | ||
| 985 | && !$urpm->{urpmi_root}) { # with --urpmi-root, we do not use statedir_media_info_file to allow compatibility with older urpmi | ||
| 986 | mkdir statedir_media_info_dir($urpm, $medium), 0755; | ||
| 987 | } | ||
| 988 | umask $old_umask; | ||
| 989 | |||
| 990 | if ($options{virtual}) { | ||
| 991 | $medium->{virtual} = 1; | ||
| 992 | } else { | ||
| 993 | _migrate_removable_device($urpm, $medium); | ||
| 994 | } | ||
| 995 | |||
| 996 | if ($with_synthesis) { | ||
| 997 | _migrate__with_synthesis($medium, $with_synthesis); | ||
| 998 | } elsif (!$medium->{media_info_dir}) { | ||
| 999 | if (!is_local_medium($medium)) { | ||
| 1000 | $medium->{media_info_dir} = 'media_info'; | ||
| 1001 | } else { | ||
| 1002 | $medium->{unknown_media_info} = 1; | ||
| 1003 | } | ||
| 1004 | } | ||
| 1005 | |||
| 1006 | #- local media have priority, other are added at the end. | ||
| 1007 | my $inserted; | ||
| 1008 | my $ignore_text = $medium->{ignore} ? ' ' . N("(ignored by default)") : ''; | ||
| 1009 | if (_local_file($medium)) { | ||
| 1010 | #- insert before first remote medium | ||
| 1011 | @{$urpm->{media}} = map { | ||
| 1012 | if (!_local_file($_) && !$inserted) { | ||
| 1013 | $inserted = 1; | ||
| 1014 | $urpm->{$options{on_the_fly} ? 'log' : 'info'}(N("adding medium \"%s\" before remote medium \"%s\"", $name, $_->{name}) . $ignore_text); | ||
| 1015 | $medium, $_; | ||
| 1016 | } else { $_ } | ||
| 1017 | } @{$urpm->{media}}; | ||
| 1018 | } | ||
| 1019 | if (!$inserted) { | ||
| 1020 | $urpm->{$options{on_the_fly} ? 'log' : 'info'}(N("adding medium \"%s\"", $name) . $ignore_text); | ||
| 1021 | push @{$urpm->{media}}, $medium; | ||
| 1022 | } | ||
| 1023 | |||
| 1024 | $urpm->{modified} = 1; | ||
| 1025 | |||
| 1026 | $name; | ||
| 1027 | } | ||
| 1028 | |||
| 1029 | sub _register_media_cfg { | ||
| 1030 | my ($urpm, $url, $mirrorlist, $distribconf, $media_cfg) = @_; | ||
| 1031 | |||
| 1032 | my $arch = $distribconf->getvalue('media_info', 'arch') || ''; | ||
| 1033 | my $branch = $distribconf->getvalue('media_info', 'branch') || ''; | ||
| 1034 | my $product = $distribconf->getvalue('media_info', 'product') || ''; | ||
| 1035 | my $version = $distribconf->getvalue('media_info', 'version') || ''; | ||
| 1036 | #official mirrors define $branch but not $product, other RPM repos do the | ||
| 1037 | #opposite :-/ | ||
| 1038 | my $media_dir = (($branch || $product) . '-' . $version . '-' . $arch); | ||
| 1039 | $media_dir =~ tr!/!-!; | ||
| 1040 | my $media_path = $urpm->{mediacfgdir} . '/' . $media_dir; | ||
| 1041 | require File::Path; | ||
| 1042 | File::Path::mkpath($media_path); | ||
| 1043 | copy_and_own($media_cfg, $media_path . '/media.cfg') | ||
| 1044 | or $urpm->{info}(1, N("failed to copy media.cfg to %s (%d)", $media_path, $? >> 8)); | ||
| 1045 | if ($url) { | ||
| 1046 | my $filename = $media_path . "/url"; | ||
| 1047 | my @urls = split(/\n/, scalar cat_($filename)); | ||
| 1048 | if (!member($url, @urls)) { | ||
| 1049 | append_to_file($filename, $url . "\n"); | ||
| 1050 | } | ||
| 1051 | } | ||
| 1052 | if ($mirrorlist) { | ||
| 1053 | if ($mirrorlist ne '$MIRRORLIST') { | ||
| 1054 | require urpm::cfg; | ||
| 1055 | $mirrorlist = urpm::cfg::expand_line($mirrorlist); | ||
| 1056 | } | ||
| 1057 | my $filename = $media_path . "/mirrorlist"; | ||
| 1058 | my @mirrorlists = split(/\n/, scalar cat_($filename)); | ||
| 1059 | if (!member($mirrorlist, @mirrorlists)) { | ||
| 1060 | append_to_file($filename, $mirrorlist . "\n"); | ||
| 1061 | } | ||
| 1062 | } | ||
| 1063 | } | ||
| 1064 | |||
| 1065 | =item add_distrib_media($urpm, $name, $url, %options) | ||
| 1066 | |||
| 1067 | Add distribution media, according to url given. | ||
| 1068 | Returns the list of names of added media. | ||
| 1069 | |||
| 1070 | Options : | ||
| 1071 | |||
| 1072 | =over | ||
| 1073 | |||
| 1074 | =item * | ||
| 1075 | |||
| 1076 | initial_number : when adding several numbered media, start with this number | ||
| 1077 | |||
| 1078 | =item * | ||
| 1079 | |||
| 1080 | probe_with : force use of rpms instead of using synthesis | ||
| 1081 | |||
| 1082 | =item * | ||
| 1083 | |||
| 1084 | ask_media : callback to know whether each media should be added | ||
| 1085 | |||
| 1086 | =item * | ||
| 1087 | |||
| 1088 | only_updates : only add "update" media (used by rpmdrake) | ||
| 1089 | |||
| 1090 | =item * | ||
| 1091 | |||
| 1092 | ignorearch : add media even if the arch is not compatible with current one, for example to create a chroot | ||
| 1093 | |||
| 1094 | =item * | ||
| 1095 | |||
| 1096 | mirrorlist | ||
| 1097 | |||
| 1098 | =item * | ||
| 1099 | |||
| 1100 | zeroconf | ||
| 1101 | |||
| 1102 | =back | ||
| 1103 | |||
| 1104 | Other options are passed to add_medium(): ignore, nolock, virtual | ||
| 1105 | |||
| 1106 | =cut | ||
| 1107 | |||
| 1108 | sub add_distrib_media { | ||
| 1109 | my ($urpm, $name, $url, %options) = @_; | ||
| 1110 | |||
| 1111 | #- make sure configuration has been read. | ||
| 1112 | $urpm->{media} or die "caller should have used ->read_config or ->configure first"; | ||
| 1113 | |||
| 1114 | my $distribconf; | ||
| 1115 | |||
| 1116 | if ($url && urpm::is_local_url($url)) { | ||
| 1117 | $url = _migrate_removable_url($url) or return(); | ||
| 1118 | my $m = { url => $url }; | ||
| 1119 | urpm::removable::try_mounting_medium_($urpm, $m) or $urpm->{error}(N("directory %s does not exist", $url)); | ||
| 1120 | |||
| 1121 | $distribconf = MDV::Distribconf->new(file_from_file_url($url) || $url, undef); | ||
| 1122 | $distribconf->settree('mageia'); | ||
| 1123 | |||
| 1124 | my $dir = file_from_local_medium($m); | ||
| 1125 | my $media_cfg = reduce_pathname("$dir/" . $distribconf->getpath(undef, 'infodir') . '/media.cfg'); | ||
| 1126 | $distribconf->parse_mediacfg($media_cfg) | ||
| 1127 | or $urpm->{error}(N("this location doesn't seem to contain any distribution")), return (); | ||
| 1128 | if (!$options{virtual}) { | ||
| 1129 | _register_media_cfg($urpm, $dir, undef, $distribconf, $media_cfg); | ||
| 1130 | } | ||
| 1131 | } else { | ||
| 1132 | $url = maybe_find_zeroconf($urpm, $url, \%options); | ||
| 1133 | if ($options{mirrorlist}) { | ||
| 1134 | $url and die "unexpected url $url together with mirrorlist $options{mirrorlist}\n"; | ||
| 1135 | } | ||
| 1136 | |||
| 1137 | my $m = { mirrorlist => $options{mirrorlist}, url => $url }; | ||
| 1138 | my $parse_ok; | ||
| 1139 | try__maybe_mirrorlist($urpm, $m, 'probe', sub { | ||
| 1140 | my $media_cfg = "$urpm->{cachedir}/partial/media.cfg"; | ||
| 1141 | $distribconf = _new_distribconf_and_download($urpm, $m); | ||
| 1142 | $parse_ok = $distribconf && $distribconf->parse_mediacfg($media_cfg); | ||
| 1143 | if ($parse_ok && !$options{virtual}) { | ||
| 1144 | _register_media_cfg($urpm, urpm::cfg::expand_line($m->{url}), $options{mirrorlist}, $distribconf, $media_cfg); | ||
| 1145 | } | ||
| 1146 | $parse_ok; | ||
| 1147 | }); | ||
| 1148 | $url = $m->{url}; | ||
| 1149 | |||
| 1150 | if ($distribconf) { | ||
| 1151 | $parse_ok or $urpm->{error}(N("unable to parse media.cfg")), return(); | ||
| 1152 | } else { | ||
| 1153 | $urpm->{error}(N("...retrieving failed: %s", $@)); | ||
| 1154 | $urpm->{error}(N("unable to access the distribution medium (no media.cfg file found)")); | ||
| 1155 | return (); | ||
| 1156 | } | ||
| 1157 | } | ||
| 1158 | |||
| 1159 | #- cosmetic update of name if it contains spaces. | ||
| 1160 | $name =~ /\s/ and $name .= ' '; | ||
| 1161 | |||
| 1162 | my @newnames; | ||
| 1163 | #- at this point, we have found a media.cfg file, so parse it | ||
| 1164 | #- and create all necessary media according to it. | ||
| 1165 | my $medium_index = $options{initial_number} || 1; | ||
| 1166 | |||
| 1167 | require urpm::mirrors; | ||
| 1168 | my $product_id = urpm::mirrors::parse_LDAP_namespace_structure(cat_('/etc/product.id')); | ||
| 1169 | my ($nonfree, $tainted, $add32bit) = needed_extra_media($urpm); | ||
| 1170 | |||
| 1171 | # On 32-bit UEFI systems, enable 32-bit media to allow 32-bit grub2-efi to be installed/updated. | ||
| 1172 | $add32bit ||= $distribconf->getvalue('media_info', 'arch') eq 'x86_64' && uefi_type() eq 'ia32'; | ||
| 1173 | |||
| 1174 | if (!$add32bit) { | ||
| 1175 | # If the 'Core 32bit Release' medium is automatically enabled, allow the 32bit nonfree | ||
| 1176 | # and tainted media to be enabled as well (mga#24438). | ||
| 1177 | foreach my $medium ($distribconf->listmedia) { | ||
| 1178 | next if $distribconf->getvalue($medium, 'name') ne 'Core 32bit Release'; | ||
| 1179 | $add32bit ||= !$distribconf->getvalue($medium, 'noauto'); | ||
| 1180 | } | ||
| 1181 | } | ||
| 1182 | |||
| 1183 | foreach my $media ($distribconf->listmedia) { | ||
| 1184 | my $media_name = $distribconf->getvalue($media, 'name') || ''; | ||
| 1185 | |||
| 1186 | if (my $media_arch = $distribconf->getvalue($media, 'arch')) { | ||
| 1187 | if (!$options{ignorearch} && !URPM::archscore($media_arch)) { | ||
| 1188 | $urpm->{log}(N("skipping non compatible media `%s' (for %s)", | ||
| 1189 | $media, $media_arch)); | ||
| 1190 | next; | ||
| 1191 | } | ||
| 1192 | } | ||
| 1193 | |||
| 1194 | my $is_update_media = $distribconf->getvalue($media, 'updates_for'); | ||
| 1195 | if ($options{only_updates}) { | ||
| 1196 | $is_update_media or next; | ||
| 1197 | } | ||
| 1198 | |||
| 1199 | my $add_by_default = is_media_to_add_by_default($urpm, $distribconf, $media, $product_id, $nonfree, $tainted, $add32bit); | ||
| 1200 | |||
| 1201 | my $ignore; | ||
| 1202 | if ($options{ask_media}) { | ||
| 1203 | $options{ask_media}->($media_name, $add_by_default) or next; | ||
| 1204 | } else { | ||
| 1205 | my $simple_rpms = !$distribconf->getvalue($media, 'rpms'); | ||
| 1206 | $add_by_default || $simple_rpms or next; | ||
| 1207 | $ignore = !$add_by_default; | ||
| 1208 | } | ||
| 1209 | |||
| 1210 | my $use_copied_synthesis = urpm::is_cdrom_url($url) || $urpm->{options}{use_copied_hdlist} || $distribconf->getvalue($media, 'use_copied_hdlist'); | ||
| 1211 | my $with_synthesis = $use_copied_synthesis && offset_pathname( | ||
| 1212 | $url, | ||
| 1213 | $distribconf->getpath($media, 'path'), | ||
| 1214 | ) . '/' . $distribconf->getpath($media, 'synthesis'); | ||
| 1215 | |||
| 1216 | push @newnames, add_medium($urpm, | ||
| 1217 | $name ? "$media_name ($name$medium_index)" : $media_name, | ||
| 1218 | reduce_pathname($distribconf->getfullpath($media, 'path')), | ||
| 1219 | $with_synthesis, | ||
| 1220 | !$use_copied_synthesis ? (media_info_dir => 'media_info') : @{[]}, | ||
| 1221 | !$use_copied_synthesis && $options{probe_with} ? ($options{probe_with} => 1) : (), | ||
| 1222 | index_name => $name ? undef : 0, | ||
| 1223 | $ignore ? (ignore => 1) : @{[]}, | ||
| 1224 | %options, | ||
| 1225 | # the following override %options | ||
| 1226 | $options{mirrorlist} ? ('with-dir' => $distribconf->getpath($media, 'path')) : (), | ||
| 1227 | update => $is_update_media ? 1 : undef, | ||
| 1228 | ); | ||
| 1229 | ++$medium_index; | ||
| 1230 | } | ||
| 1231 | |||
| 1232 | # associate newly added medias with their description in a media.cfg file | ||
| 1233 | # @media content will be modified and then add_existing medium will take | ||
| 1234 | # care of copying the media to $urpm | ||
| 1235 | _associate_media_with_mediacfg($urpm, [ map { name2medium($urpm, $_) } @newnames ]); | ||
| 1236 | |||
| 1237 | return @newnames; | ||
| 1238 | } | ||
| 1239 | |||
| 1240 | sub _new_distribconf_and_download { | ||
| 1241 | my ($urpm, $medium) = @_; | ||
| 1242 | |||
| 1243 | my $distribconf = MDV::Distribconf->new($medium->{url}, undef); | ||
| 1244 | $distribconf->settree('mageia'); | ||
| 1245 | |||
| 1246 | $urpm->{log}(N("retrieving media.cfg file...")); | ||
| 1247 | my $url = $medium->{url}; | ||
| 1248 | $medium->{url} = urpm::cfg::expand_line($url); | ||
| 1249 | urpm::download::sync_rel_one($urpm, $medium, $distribconf->getpath(undef, 'infodir') . '/media.cfg', | ||
| 1250 | quiet => 1, preclean => 1) or return; | ||
| 1251 | $medium->{url} = urpm::cfg::substitute_back($medium->{url}, $url); | ||
| 1252 | $distribconf; | ||
| 1253 | } | ||
| 1254 | |||
| 1255 | #- deprecated, use select_media_by_name instead | ||
| 1256 | sub select_media { | ||
| 1257 | my $urpm = shift; | ||
| 1258 | my $options = {}; | ||
| 1259 | if (ref $_[0]) { $options = shift } | ||
| 1260 | foreach (select_media_by_name($urpm, [ @_ ], $options->{strict_match})) { | ||
| 1261 | #- select medium by setting the modified flag, do not check ignore. | ||
| 1262 | $_->{modified} = 1; | ||
| 1263 | } | ||
| 1264 | } | ||
| 1265 | |||
| 1266 | sub select_media_by_name { | ||
| 1267 | my ($urpm, $names, $b_strict_match) = @_; | ||
| 1268 | |||
| 1269 | my %wanted = map { $_ => 1 } @$names; | ||
| 1270 | |||
| 1271 | #- first the exact matches | ||
| 1272 | my @l = grep { delete $wanted{$_->{name}} } @{$urpm->{media}}; | ||
| 1273 | |||
| 1274 | #- check if some arguments don't correspond to the medium name. | ||
| 1275 | #- in such case, try to find the unique medium (or list candidate | ||
| 1276 | #- media found). | ||
| 1277 | foreach (keys %wanted) { | ||
| 1278 | my $q = quotemeta; | ||
| 1279 | my (@found, @foundi); | ||
| 1280 | my $regex = $b_strict_match ? qr/^$q$/ : qr/$q/; | ||
| 1281 | my $regexi = $b_strict_match ? qr/^$q$/i : qr/$q/i; | ||
| 1282 | foreach my $medium (@{$urpm->{media}}) { | ||
| 1283 | $medium->{name} =~ $regex and push @found, $medium; | ||
| 1284 | $medium->{name} =~ $regexi and push @foundi, $medium; | ||
| 1285 | } | ||
| 1286 | @found = @foundi if !@found; | ||
| 1287 | |||
| 1288 | if (@found == 0) { | ||
| 1289 | $urpm->{error}(N("trying to select nonexistent medium \"%s\"", $_)); | ||
| 1290 | } else { | ||
| 1291 | if (@found > 1) { | ||
| 1292 | $urpm->{log}(N("selecting multiple media: %s", join(", ", map { qq("$_->{name}") } @found))); | ||
| 1293 | } | ||
| 1294 | #- changed behaviour to select all occurences by default. | ||
| 1295 | push @l, @found; | ||
| 1296 | } | ||
| 1297 | } | ||
| 1298 | @l; | ||
| 1299 | } | ||
| 1300 | |||
| 1301 | #- deprecated, use remove_media instead | ||
| 1302 | sub remove_selected_media { | ||
| 1303 | my ($urpm) = @_; | ||
| 1304 | |||
| 1305 | remove_media($urpm, [ grep { $_->{modified} } @{$urpm->{media}} ]); | ||
| 1306 | } | ||
| 1307 | |||
| 1308 | sub _remove_medium_from_mediacfg { | ||
| 1309 | my ($urpm, $mediacfg_dir, $url, $is_mirrorlist) = @_; | ||
| 1310 | |||
| 1311 | my $filename = $mediacfg_dir; | ||
| 1312 | $filename .= $is_mirrorlist ? "/mirrorlist" : "/url"; | ||
| 1313 | |||
| 1314 | my @urls = split(/\n/, scalar cat_($filename)); | ||
| 1315 | $urpm->{debug} and $urpm->{debug}("removing $url from $filename"); | ||
| 1316 | output_safe($filename, join('\n', grep { $url ne $_ } @urls)); | ||
| 1317 | } | ||
| 1318 | |||
| 1319 | sub _cleanup_mediacfg_dir { | ||
| 1320 | my ($urpm, $to_remove) = @_; | ||
| 1321 | |||
| 1322 | foreach my $medium (@$to_remove) { | ||
| 1323 | $medium->{mediacfg} or next; | ||
| 1324 | #this should never happen but dirname(undef) returns . on which we call | ||
| 1325 | #clean_dir so better be safe than sorry | ||
| 1326 | $medium->{mediacfg}[0]{root} or next; | ||
| 1327 | my $dir = reduce_pathname(dirname($medium->{mediacfg}[0]{root})); | ||
| 1328 | begins_with($medium->{mediacfg}[0]{root}, $dir) or next; | ||
| 1329 | if (!any { $_->{mediacfg}[0]{root} == $medium->{mediacfg}[0]{root} } @{$urpm->{media}}) { | ||
| 1330 | $urpm->{debug} and $urpm->{debug}("removing no longer used $dir"); | ||
| 1331 | -d $dir and urpm::sys::clean_dir($dir); | ||
| 1332 | next; | ||
| 1333 | } | ||
| 1334 | |||
| 1335 | if ($medium->{mirrorlist}) { | ||
| 1336 | if (!any { $_->{mirrorlist} eq $medium->{mirrorlist} } @{$urpm->{media}}) { | ||
| 1337 | _remove_medium_from_mediacfg($urpm, $dir, $medium->{mirrorlist}, 1); | ||
| 1338 | } | ||
| 1339 | } elsif ($medium->{url}) { | ||
| 1340 | if (!any { $_->{url} eq $medium->{url} } @{$urpm->{media}}) { | ||
| 1341 | _remove_medium_from_mediacfg($urpm, $dir, $medium->{url}, 0); | ||
| 1342 | } | ||
| 1343 | } | ||
| 1344 | } | ||
| 1345 | } | ||
| 1346 | |||
| 1347 | sub remove_media { | ||
| 1348 | my ($urpm, $to_remove) = @_; | ||
| 1349 | |||
| 1350 | foreach my $medium (@$to_remove) { | ||
| 1351 | $urpm->{info}(N("removing medium \"%s\"", $medium->{name})); | ||
| 1352 | |||
| 1353 | #- mark to re-write configuration. | ||
| 1354 | $urpm->{modified} = 1; | ||
| 1355 | |||
| 1356 | _clean_statedir_medium_files($urpm, $medium); | ||
| 1357 | |||
| 1358 | #- remove proxy settings for this media | ||
| 1359 | urpm::download::remove_proxy_media($medium->{name}); | ||
| 1360 | } | ||
| 1361 | $urpm->{media} = [ difference2($urpm->{media}, $to_remove) ]; | ||
| 1362 | _cleanup_mediacfg_dir($urpm, $to_remove); | ||
| 1363 | } | ||
| 1364 | |||
| 1365 | sub _clean_statedir_medium_files { | ||
| 1366 | my ($urpm, $medium) = @_; | ||
| 1367 | |||
| 1368 | #- remove files associated with this medium. | ||
| 1369 | unlink grep { $_ } map { old_statedir_media_info_file($urpm, $medium, $_->[0], $_->[1]) } @media_info_prefix_suffix; | ||
| 1370 | |||
| 1371 | my $dir = statedir_media_info_dir($urpm, $medium); | ||
| 1372 | -d $dir and urpm::sys::clean_dir($dir); | ||
| 1373 | |||
| 1374 | remove_user_media_info_files($urpm, $medium); | ||
| 1375 | } | ||
| 1376 | |||
| 1377 | sub _probe_with_try_list { | ||
| 1378 | my ($urpm, $medium, $f) = @_; | ||
| 1379 | |||
| 1380 | $medium->{mirrorlist} and die "_probe_with_try_list does not handle mirrorlist\n"; | ||
| 1381 | |||
| 1382 | my @media_info_dirs = ('media_info', '.'); | ||
| 1383 | |||
| 1384 | my $base = file_from_local_medium($medium) || $medium->{url}; | ||
| 1385 | |||
| 1386 | foreach my $media_info_dir (@media_info_dirs) { | ||
| 1387 | my $file = "$media_info_dir/synthesis.hdlist.cz"; | ||
| 1388 | my $url = reduce_pathname("$base/$file"); | ||
| 1389 | if ($f->($url, $file)) { | ||
| 1390 | $urpm->{debug} and $urpm->{debug}("found synthesis: $url"); | ||
| 1391 | $medium->{media_info_dir} = $media_info_dir; | ||
| 1392 | delete $medium->{unknown_media_info}; | ||
| 1393 | return 1; | ||
| 1394 | } | ||
| 1395 | } | ||
| 1396 | undef; | ||
| 1397 | } | ||
| 1398 | |||
| 1399 | sub may_reconfig_urpmi { | ||
| 1400 | my ($urpm, $medium) = @_; | ||
| 1401 | |||
| 1402 | $medium->{url} && !urpm::is_cdrom_url($medium->{url}) or return; # we should handle mirrorlist? | ||
| 1403 | |||
| 1404 | my $f; | ||
| 1405 | if (my $dir = file_from_file_url($medium->{url})) { | ||
| 1406 | $f = reduce_pathname("$dir/reconfig.urpmi"); | ||
| 1407 | } else { | ||
| 1408 | $f = urpm::download::sync_rel_one($urpm, $medium, 'reconfig.urpmi', | ||
| 1409 | quiet => 1, preclean => 1) or return; | ||
| 1410 | } | ||
| 1411 | my $reconfigured = -s $f && reconfig_urpmi($urpm, $f, $medium); | ||
| 1412 | unlink $f if !is_local_medium($medium); | ||
| 1413 | $reconfigured; | ||
| 1414 | } | ||
| 1415 | |||
| 1416 | =item reconfig_urpmi($urpm, $rfile, $medium) | ||
| 1417 | |||
| 1418 | Read a reconfiguration file for urpmi, and reconfigure media accordingly. | ||
| 1419 | $rfile is the reconfiguration file (local), $name is the media name | ||
| 1420 | |||
| 1421 | the format is similar to the RewriteRule of mod_rewrite, so: | ||
| 1422 | |||
| 1423 | PATTERN REPLACEMENT [FLAG] | ||
| 1424 | |||
| 1425 | where FLAG can be L or N | ||
| 1426 | |||
| 1427 | example of reconfig.urpmi: | ||
| 1428 | |||
| 1429 | # this is an urpmi reconfiguration file | ||
| 1430 | /cauldron /cauldron/$ARCH | ||
| 1431 | |||
| 1432 | =cut | ||
| 1433 | |||
| 1434 | sub reconfig_urpmi { | ||
| 1435 | my ($urpm, $rfile, $medium) = @_; | ||
| 1436 | -r $rfile or return; | ||
| 1437 | |||
| 1438 | my ($magic, @lines) = cat_($rfile); | ||
| 1439 | #- the first line of reconfig.urpmi must be magic, to be sure it's not an error file | ||
| 1440 | $magic =~ /^# this is an urpmi reconfiguration file/ or return undef; | ||
| 1441 | |||
| 1442 | $urpm->{info}(N("reconfiguring urpmi for media \"%s\"", $medium->{name})); | ||
| 1443 | |||
| 1444 | my @replacements; | ||
| 1445 | foreach (@lines) { | ||
| 1446 | chomp; | ||
| 1447 | s/^\s*//; s/#.*$//; s/\s*$//; | ||
| 1448 | $_ or next; | ||
| 1449 | my ($p, $r, $f) = split /\s+/, $_, 3; | ||
| 1450 | push @replacements, [ quotemeta $p, $r, $f || 1 ]; | ||
| 1451 | } | ||
| 1452 | |||
| 1453 | my $reconfigured = 0; | ||
| 1454 | my @reconfigurable = qw(url with_synthesis media_info_dir); | ||
| 1455 | |||
| 1456 | my %orig = %$medium; | ||
| 1457 | |||
| 1458 | URLS: | ||
| 1459 | foreach my $k (@reconfigurable) { | ||
| 1460 | foreach my $r (@replacements) { | ||
| 1461 | if ($medium->{$k} =~ s/$r->[0]/$r->[1]/) { | ||
| 1462 | $reconfigured = 1; | ||
| 1463 | #- Flags stolen from mod_rewrite: L(ast), N(ext) | ||
| 1464 | if ($r->[2] =~ /L/) { | ||
| 1465 | last; | ||
| 1466 | } elsif ($r->[2] =~ /N/) { #- dangerous option | ||
| 1467 | redo URLS; | ||
| 1468 | } | ||
| 1469 | } | ||
| 1470 | } | ||
| 1471 | #- check that the new url exists before committing changes (local mirrors) | ||
| 1472 | my $file = urpm::file_from_local_url($medium->{$k}); | ||
| 1473 | if ($file && !-e $file) { | ||
| 1474 | %$medium = %orig; | ||
| 1475 | $reconfigured = 0; | ||
| 1476 | $urpm->{log}(N("...reconfiguration failed")); | ||
| 1477 | return; | ||
| 1478 | } | ||
| 1479 | } | ||
| 1480 | |||
| 1481 | if ($reconfigured) { | ||
| 1482 | $urpm->{log}(N("reconfiguration done")); | ||
| 1483 | $urpm->{modified} = 1; | ||
| 1484 | } | ||
| 1485 | $reconfigured; | ||
| 1486 | } | ||
| 1487 | |||
| 1488 | #- names.<media_name> is used by external progs (namely for bash-completion) | ||
| 1489 | sub _generate_medium_names { | ||
| 1490 | my ($urpm, $medium) = @_; | ||
| 1491 | |||
| 1492 | -e statedir_names($urpm, $medium) and return; | ||
| 1493 | |||
| 1494 | my $fh = urpm::sys::open_safe($urpm, ">", statedir_names($urpm, $medium)) or return; | ||
| 1495 | |||
| 1496 | foreach ($medium->{start} .. $medium->{end}) { | ||
| 1497 | my $pkg = $urpm->{depslist}[$_] or | ||
| 1498 | $urpm->{error}(N("Error generating names file: dependency %d not found", $_)), return; | ||
| 1499 | |||
| 1500 | print $fh $pkg->name . "\n"; | ||
| 1501 | } | ||
| 1502 | } | ||
| 1503 | |||
| 1504 | sub _guess_synthesis_suffix { | ||
| 1505 | my ($url) = @_; | ||
| 1506 | $url =~ m!\bmedia/(\w+)/*\Z! && $1; | ||
| 1507 | } | ||
| 1508 | |||
| 1509 | sub _synthesis_suffix { | ||
| 1510 | my ($medium) = @_; | ||
| 1511 | $medium->{with_synthesis} =~ /synthesis\.hdlist(.*?)(?:\.src)?\.cz$/ ? $1 : ''; | ||
| 1512 | } | ||
| 1513 | |||
| 1514 | sub _medium_is_up_to_date { | ||
| 1515 | my ($urpm, $medium) = @_; | ||
| 1516 | |||
| 1517 | unlink cachedir_with_synthesis($urpm, $medium); | ||
| 1518 | |||
| 1519 | $urpm->{info}(N("medium \"%s\" is up-to-date", $medium->{name})); | ||
| 1520 | |||
| 1521 | #- the medium is now considered not modified. | ||
| 1522 | $medium->{modified} = 0; | ||
| 1523 | } | ||
| 1524 | |||
| 1525 | sub _parse_synthesis { | ||
| 1526 | my ($urpm, $medium, $synthesis_file, $o_callback) = @_; | ||
| 1527 | |||
| 1528 | -e $synthesis_file or return; | ||
| 1529 | |||
| 1530 | $urpm->{log}(N("examining synthesis file [%s]", $synthesis_file)); | ||
| 1531 | ($medium->{start}, $medium->{end}) = | ||
| 1532 | $urpm->parse_synthesis($synthesis_file, $o_callback ? (callback => $o_callback) : @{[]}); | ||
| 1533 | } | ||
| 1534 | |||
| 1535 | sub _parse_synthesis_or_ignore { | ||
| 1536 | my ($urpm, $medium, $o_callback) = @_; | ||
| 1537 | |||
| 1538 | _parse_synthesis($urpm, $medium, any_synthesis($urpm, $medium), $o_callback) or | ||
| 1539 | _ignore_medium_on_parse_error($urpm, $medium); | ||
| 1540 | } | ||
| 1541 | |||
| 1542 | sub is_valid_medium { | ||
| 1543 | my ($medium) = @_; | ||
| 1544 | defined $medium->{start} && defined $medium->{end}; | ||
| 1545 | } | ||
| 1546 | |||
| 1547 | sub _ignore_medium_on_parse_error { | ||
| 1548 | my ($urpm, $medium) = @_; | ||
| 1549 | |||
| 1550 | $urpm->{error}(N("problem reading synthesis file of medium \"%s\"", $medium->{name})); | ||
| 1551 | $medium->{ignore} = 1; | ||
| 1552 | } | ||
| 1553 | |||
| 1554 | sub _copy_media_info_file { | ||
| 1555 | my ($urpm, $medium, $prefix, $suffix) = @_; | ||
| 1556 | |||
| 1557 | my $name = "$prefix$suffix"; | ||
| 1558 | my $path = _synthesis_dir($medium) . "/$prefix" . _synthesis_suffix($medium) . $suffix; | ||
| 1559 | -e $path or $path = file_from_local_medium($medium) . "/media_info/$name"; | ||
| 1560 | |||
| 1561 | my $result_file = "$urpm->{cachedir}/partial/$name"; | ||
| 1562 | if (-e $path) { | ||
| 1563 | $urpm->{log}(N("copying [%s] for medium \"%s\"...", $path, $medium->{name})); | ||
| 1564 | copy_and_own($path, $result_file) | ||
| 1565 | or $urpm->{error}(N("...copying failed")), return; | ||
| 1566 | } | ||
| 1567 | -s $result_file && $result_file; | ||
| 1568 | } | ||
| 1569 | |||
| 1570 | sub _get_pubkey__local { | ||
| 1571 | my ($urpm, $medium) = @_; | ||
| 1572 | |||
| 1573 | _copy_media_info_file($urpm, $medium, 'pubkey', ''); | ||
| 1574 | } | ||
| 1575 | |||
| 1576 | sub _download_pubkey { | ||
| 1577 | my ($urpm, $medium) = @_; | ||
| 1578 | |||
| 1579 | _download_media_info_file($urpm, $medium, 'pubkey', '', { quiet => 1 }); | ||
| 1580 | } | ||
| 1581 | |||
| 1582 | # known options: quiet, callback | ||
| 1583 | sub _download_media_info_file { | ||
| 1584 | my ($urpm, $medium, $prefix, $suffix, $options) = @_; | ||
| 1585 | |||
| 1586 | my $versioned_prefix = do { | ||
| 1587 | my $version = urpm::md5sum::versioned_media_info_file($urpm, $medium, "$prefix$suffix"); | ||
| 1588 | $version and $options->{is_versioned} = 1; | ||
| 1589 | $version ? "$version-$prefix" : $prefix; | ||
| 1590 | }; | ||
| 1591 | |||
| 1592 | my $tmp = _download_media_info_file_raw($urpm, $medium, | ||
| 1593 | $versioned_prefix, $suffix, $options) or return; | ||
| 1594 | my $result = dirname($tmp) . "/$prefix$suffix"; | ||
| 1595 | $tmp eq $result or rename($tmp, $result) or return; | ||
| 1596 | $result; | ||
| 1597 | } | ||
| 1598 | |||
| 1599 | sub _download_media_info_file_raw { | ||
| 1600 | my ($urpm, $medium, $prefix, $suffix, $options) = @_; | ||
| 1601 | |||
| 1602 | my $name = "$prefix$suffix"; | ||
| 1603 | my $result_file = "$urpm->{cachedir}/partial/$name"; | ||
| 1604 | my $found; | ||
| 1605 | if (_synthesis_suffix($medium)) { | ||
| 1606 | my $local_name = $prefix . _synthesis_suffix($medium) . $suffix; | ||
| 1607 | |||
| 1608 | if (urpm::download::sync_rel_to($urpm, $medium, | ||
| 1609 | _synthesis_dir_rel($medium) . "/$local_name", $result_file, | ||
| 1610 | %$options)) { | ||
| 1611 | $found = 1; | ||
| 1612 | } | ||
| 1613 | } | ||
| 1614 | if (!$found) { | ||
| 1615 | urpm::download::sync_rel_one($urpm, $medium, _synthesis_dir_rel($medium) . "/$name", | ||
| 1616 | %$options); | ||
| 1617 | } | ||
| 1618 | -s $result_file && $result_file; | ||
| 1619 | } | ||
| 1620 | |||
| 1621 | sub get_descriptions_local { | ||
| 1622 | my ($urpm, $medium) = @_; | ||
| 1623 | |||
| 1624 | unlink statedir_descriptions($urpm, $medium); | ||
| 1625 | |||
| 1626 | my $dir = file_from_local_medium($medium); | ||
| 1627 | my $description_file = "$dir/media_info/descriptions"; #- new default location | ||
| 1628 | -e $description_file or $description_file = "$dir/../descriptions"; | ||
| 1629 | -e $description_file or return; | ||
| 1630 | |||
| 1631 | $urpm->{log}(N("copying description file of \"%s\"...", $medium->{name})); | ||
| 1632 | if (copy_and_own($description_file, statedir_descriptions($urpm, $medium))) { | ||
| 1633 | $urpm->{log}(N("...copying done")); | ||
| 1634 | } else { | ||
| 1635 | $urpm->{error}(N("...copying failed")); | ||
| 1636 | $medium->{ignore} = 1; | ||
| 1637 | } | ||
| 1638 | } | ||
| 1639 | #- not handling different mirrors since the file is not always available | ||
| 1640 | sub get_descriptions_remote { | ||
| 1641 | my ($urpm, $medium) = @_; | ||
| 1642 | |||
| 1643 | if (-e statedir_descriptions($urpm, $medium)) { | ||
| 1644 | unlink "$urpm->{cachedir}/partial/descriptions"; | ||
| 1645 | urpm::sys::move_or_die($urpm, statedir_descriptions($urpm, $medium), "$urpm->{cachedir}/partial/descriptions"); | ||
| 1646 | } | ||
| 1647 | my $result = urpm::download::sync_rel_one($urpm, $medium, 'media_info/descriptions', quiet => 1, preclean => 1); | ||
| 1648 | |||
| 1649 | if ($result) { | ||
| 1650 | urpm::sys::move_or_die($urpm, $result, statedir_descriptions($urpm, $medium)); | ||
| 1651 | } | ||
| 1652 | } | ||
| 1653 | sub get_synthesis__local { | ||
| 1654 | my ($urpm, $medium, $callback) = @_; | ||
| 1655 | |||
| 1656 | my $f = cachedir_with_synthesis($urpm, $medium); | ||
| 1657 | unlink $f; | ||
| 1658 | $urpm->{log}(N("copying [%s] for medium \"%s\"...", _url_with_synthesis($medium), $medium->{name})); | ||
| 1659 | $callback and $callback->('copy', $medium->{name}); | ||
| 1660 | if (copy_and_own(_url_with_synthesis($medium), $f)) { | ||
| 1661 | $callback and $callback->('done', $medium->{name}); | ||
| 1662 | $urpm->{log}(N("...copying done")); | ||
| 1663 | if (file_size($f) < 20) { | ||
| 1664 | $urpm->{error}(N("copy of [%s] failed (file is suspiciously small)", $f)); | ||
| 1665 | 0; | ||
| 1666 | } else { | ||
| 1667 | 1; | ||
| 1668 | } | ||
| 1669 | } else { | ||
| 1670 | $callback and $callback->('failed', $medium->{name}); | ||
| 1671 | #- force error, reported afterwards | ||
| 1672 | unlink $f; | ||
| 1673 | 0; | ||
| 1674 | } | ||
| 1675 | } | ||
| 1676 | sub get_synthesis__remote { | ||
| 1677 | my ($urpm, $medium, $is_a_probe, $options) = @_; | ||
| 1678 | |||
| 1679 | my $ok = try__maybe_mirrorlist($urpm, $medium, $is_a_probe, sub { | ||
| 1680 | _download_media_info_file($urpm, $medium, 'synthesis.hdlist', '.cz', | ||
| 1681 | $options) | ||
| 1682 | && _check_synthesis(cachedir_with_synthesis($urpm, $medium)); | ||
| 1683 | }); | ||
| 1684 | if (!$ok) { | ||
| 1685 | chomp(my $err = $@); | ||
| 1686 | $urpm->{error}(N("...retrieving failed: %s", $err)); | ||
| 1687 | } | ||
| 1688 | |||
| 1689 | $ok &&= check_synthesis_md5sum($urpm, $medium) if !$options->{force} && !$options->{nomd5sum}; | ||
| 1690 | |||
| 1691 | $ok; | ||
| 1692 | } | ||
| 1693 | |||
| 1694 | sub _check_synthesis { | ||
| 1695 | my ($synthesis_file) = @_; | ||
| 1696 | |||
| 1697 | file_size($synthesis_file) >= 20 or return; | ||
| 1698 | |||
| 1699 | # check first 2 lines do not contain typical html code | ||
| 1700 | # this is useful for servers not returning a valid HTTP error (#39918) | ||
| 1701 | open(my $F, '<', $synthesis_file) or return; | ||
| 1702 | my $s = <$F>; $s .= <$F>; | ||
| 1703 | $s !~ /<html>|<!DOCTYPE\s/i; | ||
| 1704 | } | ||
| 1705 | |||
| 1706 | #- check copied/downloaded file has right signature. | ||
| 1707 | sub check_synthesis_md5sum { | ||
| 1708 | my ($urpm, $medium) = @_; | ||
| 1709 | |||
| 1710 | my $wanted_md5sum = urpm::md5sum::from_MD5SUM__or_warn($urpm, $medium->{parsed_md5sum}, 'synthesis.hdlist.cz'); | ||
| 1711 | if ($wanted_md5sum) { | ||
| 1712 | $urpm->{log}(N("computing md5sum of retrieved source synthesis")); | ||
| 1713 | urpm::md5sum::compute(cachedir_with_synthesis($urpm, $medium)) eq $wanted_md5sum or | ||
| 1714 | $urpm->{error}(N("retrieval of [%s] failed (md5sum mismatch)", _url_with_synthesis($medium))), return; | ||
| 1715 | } | ||
| 1716 | 1; | ||
| 1717 | } | ||
| 1718 | |||
| 1719 | sub _call_genhdlist2 { | ||
| 1720 | my ($urpm, $medium) = @_; | ||
| 1721 | |||
| 1722 | !$medium->{with_synthesis} or $urpm->{fatal}(1, 'with_synthesis not handled with --probe-rpms'); | ||
| 1723 | |||
| 1724 | my $dir = file_from_local_medium($medium); | ||
| 1725 | |||
| 1726 | system('genhdlist2', | ||
| 1727 | $urpm->{debug} ? '--verbose' : @{[]}, '--no-hdlist', | ||
| 1728 | '--media_info-dir', "$urpm->{cachedir}/partial", $dir) == 0 | ||
| 1729 | or $urpm->{error}(N("genhdlist2 failed on %s", $dir)), return; | ||
| 1730 | |||
| 1731 | 1; | ||
| 1732 | } | ||
| 1733 | |||
| 1734 | sub _is_statedir_MD5SUM_uptodate { | ||
| 1735 | my ($urpm, $medium, $new_MD5SUM) = @_; | ||
| 1736 | |||
| 1737 | my $current_MD5SUM = statedir_MD5SUM($urpm, $medium); | ||
| 1738 | |||
| 1739 | $urpm->{log}(N("comparing %s and %s", $new_MD5SUM, $current_MD5SUM)); | ||
| 1740 | |||
| 1741 | cat_($new_MD5SUM) eq cat_($current_MD5SUM); | ||
| 1742 | } | ||
| 1743 | |||
| 1744 | #- options: callback, force, nomd5sum, probe_with | ||
| 1745 | sub _update_medium__parse_if_unmodified__local { | ||
| 1746 | my ($urpm, $medium, $options) = @_; | ||
| 1747 | |||
| 1748 | if ($options->{probe_with} ne 'rpms') { | ||
| 1749 | #- the directory given does not exist and may be accessible | ||
| 1750 | #- by mounting some other directory. Try to figure it out and mount | ||
| 1751 | #- everything that might be necessary. | ||
| 1752 | urpm::removable::try_mounting_medium($urpm, $medium) or return; | ||
| 1753 | } | ||
| 1754 | |||
| 1755 | #- check for a reconfig.urpmi file (if not already reconfigured) | ||
| 1756 | if (!$medium->{noreconfigure}) { | ||
| 1757 | may_reconfig_urpmi($urpm, $medium); | ||
| 1758 | } | ||
| 1759 | |||
| 1760 | #- try to probe for possible with_synthesis parameter, unless | ||
| 1761 | #- it is already defined (and valid). | ||
| 1762 | if (!_valid_synthesis_dir($medium) && $options->{probe_with} ne 'rpms') { | ||
| 1763 | _probe_with_try_list($urpm, $medium, sub { | ||
| 1764 | my ($url) = @_; | ||
| 1765 | -e $url or return; | ||
| 1766 | if (file_size($url) >= 20) { | ||
| 1767 | 1; | ||
| 1768 | } else { | ||
| 1769 | $urpm->{error}(N("invalid hdlist file %s for medium \"%s\"", $url, $medium->{name})); | ||
| 1770 | 0; | ||
| 1771 | } | ||
| 1772 | }); | ||
| 1773 | } | ||
| 1774 | |||
| 1775 | if (_is_local_virtual($medium)) { | ||
| 1776 | #- syncing a local virtual medium is very simple :) | ||
| 1777 | 1; | ||
| 1778 | } elsif ($options->{probe_with} eq 'rpms' || !_valid_synthesis_dir($medium)) { | ||
| 1779 | _call_genhdlist2($urpm, $medium) or return ''; | ||
| 1780 | if (!$medium->{'no-media-info'}) { | ||
| 1781 | $medium->{'no-media-info'} = 1; | ||
| 1782 | $urpm->{modified} = 1; | ||
| 1783 | } | ||
| 1784 | 1; | ||
| 1785 | } elsif (_valid_synthesis_dir($medium)) { | ||
| 1786 | my $new_MD5SUM = _synthesis_dir($medium) . '/MD5SUM'; | ||
| 1787 | unlink "$urpm->{cachedir}/partial/MD5SUM"; | ||
| 1788 | |||
| 1789 | if (!$options->{nomd5sum} && file_size($new_MD5SUM) > 32) { | ||
| 1790 | if (!$options->{force} && _is_statedir_MD5SUM_uptodate($urpm, $medium, $new_MD5SUM)) { | ||
| 1791 | _medium_is_up_to_date($urpm, $medium); | ||
| 1792 | return 'unmodified'; | ||
| 1793 | } | ||
| 1794 | |||
| 1795 | $urpm->{log}(N("copying MD5SUM file of \"%s\"...", $medium->{name})); | ||
| 1796 | copy_and_own($new_MD5SUM, "$urpm->{cachedir}/partial/MD5SUM"); | ||
| 1797 | $medium->{parsed_md5sum} = urpm::md5sum::parse($new_MD5SUM); | ||
| 1798 | } | ||
| 1799 | |||
| 1800 | my $ok = get_synthesis__local($urpm, $medium, $options->{callback}); | ||
| 1801 | $ok &&= check_synthesis_md5sum($urpm, $medium) if !$options->{force} && !$options->{nomd5sum}; | ||
| 1802 | |||
| 1803 | if ($ok) { | ||
| 1804 | 1; | ||
| 1805 | } elsif ($urpm->{options}{'build-hdlist-on-error'}) { | ||
| 1806 | #- if copying synthesis has failed, try to build it directly. | ||
| 1807 | _call_genhdlist2($urpm, $medium) or return ''; | ||
| 1808 | 1; | ||
| 1809 | } else { | ||
| 1810 | _ignore_medium_on_parse_error($urpm, $medium); | ||
| 1811 | ''; | ||
| 1812 | } | ||
| 1813 | } | ||
| 1814 | } | ||
| 1815 | |||
| 1816 | sub _download_MD5SUM { | ||
| 1817 | my ($urpm, $medium) = @_; | ||
| 1818 | |||
| 1819 | urpm::download::sync_rel_one($urpm, $medium, | ||
| 1820 | _synthesis_dir_rel($medium) . '/MD5SUM', | ||
| 1821 | quiet => 1, preclean => 1); | ||
| 1822 | } | ||
| 1823 | |||
| 1824 | sub _download_MD5SUM_and_check { | ||
| 1825 | my ($urpm, $medium, $is_a_probe) = @_; | ||
| 1826 | |||
| 1827 | my ($err, $cachedir_MD5SUM); | ||
| 1828 | require urpm::mirrors; | ||
| 1829 | try__maybe_mirrorlist($urpm, $medium, $is_a_probe, sub { | ||
| 1830 | $cachedir_MD5SUM = _download_MD5SUM($urpm, $medium) or $err = $@; | ||
| 1831 | $cachedir_MD5SUM && urpm::md5sum::check_file($cachedir_MD5SUM); | ||
| 1832 | }) and return $cachedir_MD5SUM; | ||
| 1833 | |||
| 1834 | if ($cachedir_MD5SUM) { | ||
| 1835 | $urpm->{error}(N("invalid MD5SUM file (downloaded from %s)", _synthesis_dir($medium))); | ||
| 1836 | } else { | ||
| 1837 | $urpm->{error}(N("...retrieving failed: %s", $err)); | ||
| 1838 | $is_a_probe and $urpm->{error}(N("no metadata found for medium \"%s\"", $medium->{name})); | ||
| 1839 | } | ||
| 1840 | undef; | ||
| 1841 | } | ||
| 1842 | |||
| 1843 | #- options: callback, ask_retry, force, nomd5sum, probe_with, quiet | ||
| 1844 | sub _update_medium__parse_if_unmodified__remote { | ||
| 1845 | my ($urpm, $medium, $options) = @_; | ||
| 1846 | |||
| 1847 | my $updating = -e statedir_synthesis($urpm, $medium); | ||
| 1848 | |||
| 1849 | #- examine if a distant MD5SUM file is available. | ||
| 1850 | if (!$options->{nomd5sum}) { | ||
| 1851 | my $new_MD5SUM = _download_MD5SUM_and_check($urpm, $medium, !$updating); | ||
| 1852 | |||
| 1853 | if (!$new_MD5SUM) { | ||
| 1854 | #- check for a reconfig.urpmi file (if not already reconfigured) | ||
| 1855 | if (!$medium->{noreconfigure}) { | ||
| 1856 | may_reconfig_urpmi($urpm, $medium) | ||
| 1857 | and goto &_update_medium__parse_if_unmodified__remote; | ||
| 1858 | } | ||
| 1859 | return; | ||
| 1860 | } | ||
| 1861 | if (($options->{force} || 0) < 2 && _is_statedir_MD5SUM_uptodate($urpm, $medium, $new_MD5SUM)) { | ||
| 1862 | _medium_is_up_to_date($urpm, $medium); | ||
| 1863 | return 'unmodified'; | ||
| 1864 | } | ||
| 1865 | $medium->{parsed_md5sum} = urpm::md5sum::parse($new_MD5SUM); | ||
| 1866 | } | ||
| 1867 | |||
| 1868 | #- try to probe for possible with_synthesis parameter, unless | ||
| 1869 | #- it is already defined (and valid). | ||
| 1870 | $urpm->{log}(N("retrieving source synthesis of \"%s\"...", $medium->{name})); | ||
| 1871 | $options->{callback} and $options->{callback}('retrieve', $medium->{name}); | ||
| 1872 | my $error = sub { | ||
| 1873 | my ($msg) = @_; | ||
| 1874 | $urpm->{error}($msg); | ||
| 1875 | unlink cachedir_with_synthesis($urpm, $medium); | ||
| 1876 | $options->{callback} and $options->{callback}('failed', $medium->{name}); | ||
| 1877 | }; | ||
| 1878 | |||
| 1879 | if ($options->{force}) { | ||
| 1880 | unlink cachedir_with_synthesis($urpm, $medium); | ||
| 1881 | } else { | ||
| 1882 | #- for rsync, try to sync (copy if needed) local copy after restored the previous one. | ||
| 1883 | my $previous_synthesis = statedir_synthesis($urpm, $medium); | ||
| 1884 | if (-e $previous_synthesis && urpm::protocol_from_url($medium->{url}) eq 'rsync') { | ||
| 1885 | copy_and_own( | ||
| 1886 | $previous_synthesis, | ||
| 1887 | cachedir_with_synthesis($urpm, $medium), | ||
| 1888 | ) or $error->(N("...copying failed")), return; | ||
| 1889 | } | ||
| 1890 | } | ||
| 1891 | my $ok = get_synthesis__remote($urpm, $medium, !$updating, $options); | ||
| 1892 | |||
| 1893 | $options->{callback} and $options->{callback}('done', $medium->{name}); | ||
| 1894 | |||
| 1895 | if (!$ok) { | ||
| 1896 | _ignore_medium_on_parse_error($urpm, $medium); | ||
| 1897 | return; | ||
| 1898 | } | ||
| 1899 | 1; | ||
| 1900 | } | ||
| 1901 | |||
| 1902 | sub _get_pubkey { | ||
| 1903 | my ($urpm, $medium, $b_wait_lock) = @_; | ||
| 1904 | |||
| 1905 | my $local = file_from_local_medium($medium); | ||
| 1906 | |||
| 1907 | #- examine if a pubkey file is available. | ||
| 1908 | ($local ? \&_get_pubkey__local : \&_download_pubkey)->($urpm, $medium); | ||
| 1909 | |||
| 1910 | $medium->{'key-ids'} = _read_cachedir_pubkey($urpm, $medium, $b_wait_lock); | ||
| 1911 | $urpm->{modified} = 1; | ||
| 1912 | } | ||
| 1913 | |||
| 1914 | sub _get_descriptions { | ||
| 1915 | my ($urpm, $medium) = @_; | ||
| 1916 | |||
| 1917 | my $local = file_from_local_medium($medium); | ||
| 1918 | |||
| 1919 | # do not get "descriptions" on non "update" media since it's useless and potentially slow | ||
| 1920 | if ($medium->{update}) { | ||
| 1921 | ($local ? \&get_descriptions_local : \&get_descriptions_remote)->($urpm, $medium); | ||
| 1922 | } | ||
| 1923 | } | ||
| 1924 | |||
| 1925 | # options: wait_lock, nopubkey, forcekey | ||
| 1926 | sub _may_get_pubkey { | ||
| 1927 | my ($urpm, $medium, %options) = @_; | ||
| 1928 | |||
| 1929 | _get_pubkey($urpm, $medium, $options{wait_lock}) if !$options{nopubkey} && (!$medium->{'key-ids'} || $options{forcekey}); | ||
| 1930 | } | ||
| 1931 | |||
| 1932 | sub _read_cachedir_pubkey { | ||
| 1933 | my ($urpm, $medium, $b_wait_lock) = @_; | ||
| 1934 | -s "$urpm->{cachedir}/partial/pubkey" or return; | ||
| 1935 | |||
| 1936 | $urpm->{log}(N("examining pubkey file of \"%s\"...", $medium->{name})); | ||
| 1937 | |||
| 1938 | my $_rpm_lock = urpm::lock::rpm_db($urpm, 'exclusive', wait => $b_wait_lock); | ||
| 1939 | my $db = urpm::db_open_or_die_($urpm, 'rw'); | ||
| 1940 | |||
| 1941 | my %key_ids; | ||
| 1942 | URPM::import_needed_pubkeys_from_file($db, | ||
| 1943 | "$urpm->{cachedir}/partial/pubkey", | ||
| 1944 | sub { | ||
| 1945 | my ($id, $imported) = @_; | ||
| 1946 | if ($id) { | ||
| 1947 | $key_ids{$id} = undef; | ||
| 1948 | $imported and $urpm->{log}(N("...imported key %s from pubkey file of \"%s\"", | ||
| 1949 | $id, $medium->{name})); | ||
| 1950 | $imported or $urpm->{debug}("pubkey $id already imported") if $urpm->{debug}; | ||
| 1951 | } else { | ||
| 1952 | $urpm->{error}(N("unable to import pubkey file of \"%s\"", $medium->{name})); | ||
| 1953 | } | ||
| 1954 | }); | ||
| 1955 | |||
| 1956 | unlink "$urpm->{cachedir}/partial/pubkey"; | ||
| 1957 | |||
| 1958 | join(',', keys %key_ids); | ||
| 1959 | } | ||
| 1960 | |||
| 1961 | #- options: callback, ask_retry, force, nomd5sum, probe_with, quiet, forcekey, nopubkey, wait_lock | ||
| 1962 | #- (from _update_medium__parse_if_unmodified__local and _update_medium__parse_if_unmodified__remote) | ||
| 1963 | sub _update_medium_ { | ||
| 1964 | my ($urpm, $medium, %options) = @_; | ||
| 1965 | |||
| 1966 | #- always delete a remaining list file or pubkey file in cache. | ||
| 1967 | foreach (qw(list pubkey)) { | ||
| 1968 | unlink "$urpm->{cachedir}/partial/$_"; | ||
| 1969 | } | ||
| 1970 | |||
| 1971 | _pick_mirror_if_needed($urpm, $medium, 'allow-cache-update'); | ||
| 1972 | |||
| 1973 | { | ||
| 1974 | my $rc = | ||
| 1975 | is_local_medium($medium) | ||
| 1976 | ? _update_medium__parse_if_unmodified__local($urpm, $medium, \%options) | ||
| 1977 | : _update_medium__parse_if_unmodified__remote($urpm, $medium, \%options); | ||
| 1978 | |||
| 1979 | if ($options{forcekey} && $rc eq 'unmodified') { | ||
| 1980 | _get_pubkey($urpm, $medium, $options{wait_lock}); # we must do it now, quite hackish... | ||
| 1981 | return 1; | ||
| 1982 | } | ||
| 1983 | |||
| 1984 | if (!$rc || $rc eq 'unmodified') { | ||
| 1985 | return $rc; | ||
| 1986 | } | ||
| 1987 | } | ||
| 1988 | |||
| 1989 | my $is_updating = -e statedir_synthesis($urpm, $medium); | ||
| 1990 | |||
| 1991 | if (!_is_local_virtual($medium)) { | ||
| 1992 | if (file_size(cachedir_with_synthesis($urpm, $medium)) < 20) { | ||
| 1993 | $urpm->{error}(N("no synthesis file found for medium \"%s\"", $medium->{name})); | ||
| 1994 | return; | ||
| 1995 | } | ||
| 1996 | |||
| 1997 | #- use new files | ||
| 1998 | |||
| 1999 | unlink statedir_synthesis($urpm, $medium); | ||
| 2000 | urpm::sys::move_or_die($urpm, cachedir_with_synthesis($urpm, $medium), | ||
| 2001 | statedir_synthesis($urpm, $medium)); | ||
| 2002 | |||
| 2003 | unlink statedir_MD5SUM($urpm, $medium); | ||
| 2004 | if (!$medium->{with_synthesis}) { # no MD5SUM when using with_synthesis, urpmi.update will update everytime! | ||
| 2005 | urpm::sys::move_or_die($urpm, "$urpm->{cachedir}/partial/MD5SUM", | ||
| 2006 | statedir_MD5SUM($urpm, $medium)) if -e "$urpm->{cachedir}/partial/MD5SUM"; | ||
| 2007 | } | ||
| 2008 | |||
| 2009 | # we never download hdlist by default. urpmf will download it via any_hdlist() if really needed | ||
| 2010 | unlink statedir_hdlist($urpm, $medium); | ||
| 2011 | |||
| 2012 | remove_user_media_info_files($urpm, $medium); | ||
| 2013 | |||
| 2014 | if (!_local_file($medium)) { | ||
| 2015 | _retrieve_xml_media_info_or_remove($urpm, $medium, $options{quiet}) or return; | ||
| 2016 | } | ||
| 2017 | } | ||
| 2018 | $medium->{modified} = 0; | ||
| 2019 | |||
| 2020 | # generated on first _parse_media() | ||
| 2021 | unlink statedir_names($urpm, $medium); | ||
| 2022 | |||
| 2023 | _get_descriptions($urpm, $medium); | ||
| 2024 | _may_get_pubkey($urpm, $medium, %options); | ||
| 2025 | |||
| 2026 | $is_updating and $urpm->{info}(N("updated medium \"%s\"", $medium->{name})); | ||
| 2027 | |||
| 2028 | 1; | ||
| 2029 | } | ||
| 2030 | |||
| 2031 | sub _update_medium { | ||
| 2032 | my ($urpm, $medium, %options) = @_; | ||
| 2033 | |||
| 2034 | my $rc = _update_medium_($urpm, $medium, %options); | ||
| 2035 | |||
| 2036 | if (!$rc && !_is_local_virtual($medium)) { | ||
| 2037 | #- an error has occured for updating the medium, we have to remove temporary files. | ||
| 2038 | unlink(glob("$urpm->{cachedir}/partial/*")); | ||
| 2039 | } | ||
| 2040 | $rc; | ||
| 2041 | } | ||
| 2042 | |||
| 2043 | =item update_media($urpm, %options) | ||
| 2044 | |||
| 2045 | Update the urpmi database w.r.t. the current configuration. | ||
| 2046 | Takes care of modifications, and tries some tricks to bypass | ||
| 2047 | the recomputation of base files. | ||
| 2048 | |||
| 2049 | Recognized options : | ||
| 2050 | |||
| 2051 | =over | ||
| 2052 | |||
| 2053 | =item * | ||
| 2054 | |||
| 2055 | all : all medias are being rebuilt | ||
| 2056 | |||
| 2057 | =item * | ||
| 2058 | |||
| 2059 | allow_failures: whereas failing to update a medium is non fatal | ||
| 2060 | |||
| 2061 | =item * | ||
| 2062 | |||
| 2063 | ask_retry : function called when a download fails. if it returns true, the download is retried | ||
| 2064 | |||
| 2065 | =item * | ||
| 2066 | |||
| 2067 | callback : UI callback | ||
| 2068 | |||
| 2069 | =item * | ||
| 2070 | |||
| 2071 | forcekey : force retrieval of pubkey | ||
| 2072 | |||
| 2073 | =item * | ||
| 2074 | |||
| 2075 | force : try to force rebuilding base files | ||
| 2076 | |||
| 2077 | =item * | ||
| 2078 | |||
| 2079 | nomd5sum : don't verify MD5SUM of retrieved files | ||
| 2080 | |||
| 2081 | =item * | ||
| 2082 | |||
| 2083 | nopubkey : don't use rpm pubkeys | ||
| 2084 | |||
| 2085 | =item * | ||
| 2086 | |||
| 2087 | probe_with : probe synthesis or rpms | ||
| 2088 | |||
| 2089 | =item * | ||
| 2090 | |||
| 2091 | quiet : download synthesis quietly | ||
| 2092 | |||
| 2093 | =item * | ||
| 2094 | |||
| 2095 | wait_lock : block until lock can be acquired | ||
| 2096 | |||
| 2097 | =back | ||
| 2098 | |||
| 2099 | =cut | ||
| 2100 | |||
| 2101 | sub update_media { | ||
| 2102 | my ($urpm, %options) = @_; | ||
| 2103 | |||
| 2104 | $urpm->{media} or return; # verify that configuration has been read | ||
| 2105 | |||
| 2106 | if ($options{all}) { | ||
| 2107 | $_->{modified} ||= 1 foreach all_media_to_update($urpm); | ||
| 2108 | } | ||
| 2109 | |||
| 2110 | update_those_media($urpm, [ grep { $_->{modified} } non_ignored_media($urpm) ], %options); | ||
| 2111 | } | ||
| 2112 | |||
| 2113 | sub update_those_media { | ||
| 2114 | my ($urpm, $media, %options) = @_; | ||
| 2115 | |||
| 2116 | $options{nopubkey} ||= $urpm->{options}{nopubkey}; | ||
| 2117 | |||
| 2118 | #- examine each medium to see if one of them needs to be updated. | ||
| 2119 | #- if this is the case and if not forced, try to use a pre-calculated | ||
| 2120 | #- synthesis file, else build it from rpm files. | ||
| 2121 | clean($urpm); | ||
| 2122 | |||
| 2123 | my %updates_result; | ||
| 2124 | foreach my $medium (@$media) { | ||
| 2125 | |||
| 2126 | #- don't ever update static media | ||
| 2127 | $medium->{static} and next; | ||
| 2128 | |||
| 2129 | my $unsubstituted_url = $medium->{url}; | ||
| 2130 | $medium->{url} = urpm::cfg::expand_line($medium->{url}) if $medium->{url}; | ||
| 2131 | my $rc = _update_medium($urpm, $medium, %options); | ||
| 2132 | $medium->{url} = urpm::cfg::substitute_back($medium->{url}, $unsubstituted_url); | ||
| 2133 | $rc or return if !$options{allow_failures}; | ||
| 2134 | $updates_result{$rc || 'error'}++; | ||
| 2135 | } | ||
| 2136 | |||
| 2137 | $urpm->{debug} and $urpm->{debug}('update_medium: ' . join(' ', map { "$_=$updates_result{$_}" } keys %updates_result)); | ||
| 2138 | |||
| 2139 | if ($updates_result{1} == 0) { | ||
| 2140 | #- only errors/unmodified, leave now | ||
| 2141 | #- (this ensures buggy added medium is not added to urpmi.cfg) | ||
| 2142 | return $updates_result{error} == 0; | ||
| 2143 | } | ||
| 2144 | |||
| 2145 | if ($urpm->{modified}) { | ||
| 2146 | #- write config files in any case | ||
| 2147 | write_config($urpm); | ||
| 2148 | urpm::download::dump_proxy_config(); | ||
| 2149 | } | ||
| 2150 | |||
| 2151 | $updates_result{error} == 0; | ||
| 2152 | } | ||
| 2153 | |||
| 2154 | sub _maybe_in_statedir_MD5SUM { | ||
| 2155 | my ($urpm, $medium, $file) = @_; | ||
| 2156 | |||
| 2157 | my $md5sum_file = statedir_MD5SUM($urpm, $medium); | ||
| 2158 | -e $md5sum_file && urpm::md5sum::parse($md5sum_file)->{$file}; | ||
| 2159 | } | ||
| 2160 | |||
| 2161 | sub _retrieve_xml_media_info_or_remove { | ||
| 2162 | my ($urpm, $medium, $quiet) = @_; | ||
| 2163 | |||
| 2164 | my $ok = 1; | ||
| 2165 | |||
| 2166 | foreach my $xml_info (@xml_media_info) { | ||
| 2167 | my $f = statedir_xml_info($urpm, $medium, $xml_info); | ||
| 2168 | |||
| 2169 | my $get_it = urpm::is_cdrom_url($medium->{url}) || | ||
| 2170 | get_medium_option($urpm, $medium, 'xml-info') eq 'always' || | ||
| 2171 | get_medium_option($urpm, $medium, 'xml-info') eq 'update-only' && -e $f; | ||
| 2172 | if ($get_it && _maybe_in_statedir_MD5SUM($urpm, $medium, "$xml_info.xml.lzma")) { | ||
| 2173 | $ok &&= _retrieve_media_info_file_and_check_MD5SUM($urpm, $medium, $xml_info, '.xml.lzma', $quiet); | ||
| 2174 | $ok = 1 if urpm::is_cdrom_url($medium->{url}); | ||
| 2175 | } else { | ||
| 2176 | #- "on-demand" | ||
| 2177 | unlink $f; | ||
| 2178 | } | ||
| 2179 | } | ||
| 2180 | $ok; | ||
| 2181 | } | ||
| 2182 | |||
| 2183 | sub _retrieve_media_info_file_and_check_MD5SUM { | ||
| 2184 | my ($urpm, $medium, $prefix, $suffix, $quiet) = @_; | ||
| 2185 | |||
| 2186 | my $name = "$prefix$suffix"; | ||
| 2187 | my $cachedir_file = | ||
| 2188 | is_local_medium($medium) ? | ||
| 2189 | _copy_media_info_file($urpm, $medium, $prefix, $suffix) : | ||
| 2190 | _download_media_info_file($urpm, $medium, $prefix, $suffix, { quiet => $quiet, callback => \&urpm::download::sync_logger }) or | ||
| 2191 | $urpm->{error}(N("retrieval of [%s] failed", _synthesis_dir($medium) . "/$name")), return; | ||
| 2192 | |||
| 2193 | my $wanted_md5sum = urpm::md5sum::from_MD5SUM__or_warn($urpm, $medium->{parsed_md5sum}, $name); | ||
| 2194 | if ($wanted_md5sum) { | ||
| 2195 | $urpm->{debug}("computing md5sum of retrieved $name") if $urpm->{debug}; | ||
| 2196 | urpm::md5sum::compute($cachedir_file) eq $wanted_md5sum or | ||
| 2197 | $urpm->{error}(N("retrieval of [%s] failed (md5sum mismatch)", _synthesis_dir($medium) . "/$name")), return; | ||
| 2198 | |||
| 2199 | urpm::util::move($cachedir_file, statedir_media_info_file($urpm, $medium, $prefix, $suffix)) or return; | ||
| 2200 | } | ||
| 2201 | 1; | ||
| 2202 | } | ||
| 2203 | |||
| 2204 | sub _download_temp_md5sum_and_parse { | ||
| 2205 | my ($urpm, $medium) = @_; | ||
| 2206 | |||
| 2207 | $urpm->{debug}("downloading MD5SUM to know updated versioned metadata filename") if $urpm->{debug}; | ||
| 2208 | my $md5sum_file = _download_MD5SUM($urpm, $medium); | ||
| 2209 | urpm::md5sum::parse($md5sum_file); | ||
| 2210 | } | ||
| 2211 | |||
| 2212 | sub _any_media_info__or_download { | ||
| 2213 | my ($urpm, $medium, $prefix, $suffix, $quiet, $o_callback) = @_; | ||
| 2214 | |||
| 2215 | my $f = statedir_media_info_file($urpm, $medium, $prefix, $suffix); | ||
| 2216 | -s $f and return $f; | ||
| 2217 | |||
| 2218 | if ($<) { | ||
| 2219 | urpm::ensure_valid_cachedir($urpm); | ||
| 2220 | $f = "$urpm->{cachedir}/" . statedir_media_info_basename($medium, $prefix, $suffix); | ||
| 2221 | -s $f and return $f; | ||
| 2222 | } | ||
| 2223 | |||
| 2224 | get_medium_option($urpm, $medium, 'xml-info') ne 'never' or return; | ||
| 2225 | |||
| 2226 | _maybe_in_statedir_MD5SUM($urpm, $medium, "$prefix$suffix") or return; | ||
| 2227 | |||
| 2228 | $medium->{parsed_md5sum} ||= _download_temp_md5sum_and_parse($urpm, $medium); | ||
| 2229 | |||
| 2230 | my $file_in_partial = | ||
| 2231 | _download_media_info_file($urpm, $medium, $prefix, $suffix, | ||
| 2232 | { quiet => $quiet, callback => $o_callback }) or return; | ||
| 2233 | |||
| 2234 | urpm::util::move($file_in_partial, $f) or return; | ||
| 2235 | |||
| 2236 | $f; | ||
| 2237 | } | ||
| 2238 | |||
| 2239 | #- side-effects: | ||
| 2240 | #- + those of urpm::mirrors::pick_one ($urpm->{mirrors_cache}, $medium->{url}) | ||
| 2241 | sub _pick_mirror_if_needed { | ||
| 2242 | my ($urpm, $medium, $allow_cache_update) = @_; | ||
| 2243 | |||
| 2244 | $medium->{mirrorlist} && !$medium->{url} or return; | ||
| 2245 | |||
| 2246 | require urpm::mirrors; | ||
| 2247 | urpm::mirrors::pick_one($urpm, $medium, $allow_cache_update); | ||
| 2248 | } | ||
| 2249 | |||
| 2250 | #- side-effects: | ||
| 2251 | #- + those of urpm::mirrors::try ($urpm->{mirrors_cache}, $medium->{url}) | ||
| 2252 | sub try__maybe_mirrorlist { | ||
| 2253 | my ($urpm, $medium, $is_a_probe, $try) = @_; | ||
| 2254 | |||
| 2255 | if ($medium->{mirrorlist}) { | ||
| 2256 | if (urpm::download::use_metalink($urpm, $medium)) { | ||
| 2257 | #- help things... | ||
| 2258 | _pick_mirror_if_needed($urpm, $medium, 'allow-cache-update'); | ||
| 2259 | |||
| 2260 | $try->(); | ||
| 2261 | } else { | ||
| 2262 | require urpm::mirrors; | ||
| 2263 | $is_a_probe | ||
| 2264 | ? urpm::mirrors::try_probe($urpm, $medium, $try) | ||
| 2265 | : urpm::mirrors::try($urpm, $medium, $try); | ||
| 2266 | } | ||
| 2267 | } else { | ||
| 2268 | $try->(); | ||
| 2269 | } | ||
| 2270 | } | ||
| 2271 | |||
| 2272 | =item clean($urpm) | ||
| 2273 | |||
| 2274 | Clean params and depslist computation zone. | ||
| 2275 | |||
| 2276 | =cut | ||
| 2277 | |||
| 2278 | sub clean { | ||
| 2279 | my ($urpm) = @_; | ||
| 2280 | |||
| 2281 | $urpm->{depslist} = []; | ||
| 2282 | $urpm->{provides} = {}; | ||
| 2283 | |||
| 2284 | foreach (@{$urpm->{media} || []}) { | ||
| 2285 | delete $_->{start}; | ||
| 2286 | delete $_->{end}; | ||
| 2287 | } | ||
| 2288 | } | ||
| 2289 | |||
| 2290 | 1; | ||
| 2291 | |||
| 2292 | |||
| 2293 | =back | ||
| 2294 | |||
| 2295 | =head1 COPYRIGHT | ||
| 2296 | |||
| 2297 | Copyright (C) 2005 MandrakeSoft SA | ||
| 2298 | |||
| 2299 | Copyright (C) 2005-2010 Mandriva SA | ||
| 2300 | |||
| 2301 | Copyright (C) 2011-2020 Mageia | ||
| 2302 | |||
| 2303 | =cut | ||