urpm/media.pm

filter: Statementstmt 66.6% 4 / 6 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 2 / 2 Podpod n/a totaltotal 75.0% 6 / 8 CC 1 SCAR 1.4
CC
1
Cov
67%
BEGIN
1.3
BEGIN
1.0
CRAP 1.1
« urpm/main_loop.pm ↑ Summary urpm/parallel.pm »
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
« urpm/main_loop.pm ↑ Summary urpm/parallel.pm »