po/bs.po


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781

# Translators:
# Adnan Hodzic <AbsintheSyringe@gmail.com>, 2007
# Dimitris Glezos <glezos@indifex.com>, 2011
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE\n"
"PO-Revision-Date: 2015-03-13 03:00+0000\n"
"Last-Translator: Copied by Zanata <copied-by-zanata@zanata.org>\n"
"Language-Team: Bosnian (http://www.transifex.com/projects/p/fedora/language/"
"bs/)\n"
"Language: bs\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Generator: Zanata 4.6.2\n"

#: ../network-scripts/ifdown:15 ../network-scripts/ifdown:22
msgid "usage: ifdown <configuration>"
msgstr "Upotreba: ifdown <naziv uređaja>"

#: ../network-scripts/ifdown:33 ../network-scripts/ifup:49
msgid "Users cannot control this device."
msgstr "Korisnici ne mogu upravljati ovim uređajem."

#: ../network-scripts/ifdown:40
msgid ""
"You are using 'ifdown' script provided by 'network-scripts', which are now "
"deprecated."
msgstr ""

#: ../network-scripts/ifdown:41 ../network-scripts/ifup:57
#: ../etc/rc.d/init.d/network:53
msgid "'network-scripts' will be removed from distribution in near future."
msgstr ""

#: ../network-scripts/ifdown:42 ../network-scripts/ifup:58
msgid ""
"It is advised to switch to 'NetworkManager' instead - it provides 'ifup/"
"ifdown' scripts as well."
msgstr ""

#: ../network-scripts/ifdown-eth:46 ../network-scripts/ifdown-eth:52
msgid ""
"Device ${DEVICE} has MAC address ${FOUNDMACADDR}, instead of configured "
"address ${HWADDR}. Ignoring."
msgstr ""
"Uređaj ${DEVICE} ima MAC adresu ${FOUNDMACADDR}, umjesto konfigurirane "
"adrese ${HWADDR}. Bit će ignoriran."

#: ../network-scripts/ifdown-routes:6
#, fuzzy
msgid "usage: ifdown-routes <net-device> [<nickname>]"
msgstr "Upotreba: ifup-routes <mrežni uređaj> [<nadimak>]"

#: ../network-scripts/ifdown-sit:40 ../network-scripts/ifup-sit:58
msgid ""
"Device '$DEVICE' isn't supported here, use IPV6_AUTOTUNNEL setting and "
"restart (IPv6) networking"
msgstr ""
"Uređaj '$DEVICE' ovdje nije podržan. Upotrijebite postavke IPV6_AUTOTUNNEL "
"ponovo pokrenite (IPv6) mrežu."

#: ../network-scripts/ifdown-tunnel:36 ../network-scripts/ifup-tunnel:68
msgid "Device '$DEVICE' isn't supported as a valid GRE device name."
msgstr ""

#: ../network-scripts/ifup:30 ../network-scripts/ifup:38
msgid "Usage: ifup <configuration>"
msgstr "Upotreba: ifup <naziv uređaja>"

#: ../network-scripts/ifup:37
msgid "$0: configuration for ${1} not found."
msgstr "$0: konfiguracija za ${1} nije pronađena."

#: ../network-scripts/ifup:56
msgid ""
"You are using 'ifup' script provided by 'network-scripts', which are now "
"deprecated."
msgstr ""

#: ../network-scripts/ifup:87 ../network-scripts/ifup:102
msgid "PHYSDEV should be set for device ${DEVICE}"
msgstr "PHYSDEV ne bi trebao biti postavljen za uređaj ${DEVICE}"

#: ../network-scripts/ifup:110
msgid "No 802.1Q VLAN support available in kernel for device ${DEVICE}"
msgstr "U kernelu ne postoji 802.1Q VLAN podrška za uređaj ${DEVICE}"

#: ../network-scripts/ifup:117 ../network-scripts/ifup-eth:123
msgid ""
"$alias device ${DEVICE} does not seem to be present, delaying initialization."
msgstr ""
"Izgleda da $alias uređaj ${DEVICE} nije prisutan. Inicijalizacija će biti "
"odgođena."

#: ../network-scripts/ifup:138 ../network-scripts/ifup:139
msgid "ERROR: could not add vlan ${VID} as ${DEVICE} on dev ${PHYSDEV}"
msgstr ""
"POGREŠKA: Nije moguće dodati vlan ${VID} kao ${DEVICE} na uređaju ${PHYSDEV}"

#: ../network-scripts/ifup-aliases:67
msgid "usage: ifup-aliases <net-device> [<parent-config>]\n"
msgstr "Upotreba: ifup-aliases <mrežni uređaj> [<parent-config>]\n"

#: ../network-scripts/ifup-aliases:119
msgid "Missing config file $PARENTCONFIG."
msgstr "Nedostaje konfiguracijska datoteka $PARENTCONFIG."

#: ../network-scripts/ifup-aliases:169
msgid "error in $FILE: invalid alias number"
msgstr "pogreška u $FILE: neispravan broj pseudonima"

#: ../network-scripts/ifup-aliases:179
msgid "error in $FILE: already seen ipaddr $IPADDR in $ipseen"
msgstr "pogreška u $FILE: ip adresa $IPADDR već postoji u $ipseen"

#: ../network-scripts/ifup-aliases:184
msgid "error in $FILE: already seen device $parent_device:$DEVNUM in $devseen"
msgstr ""
"pogreška pri $FILE: uređaj $parent_device:$DEVNUM već je primijećen pri "
"$devseen"

#: ../network-scripts/ifup-aliases:193
msgid "error in $FILE: didn't specify device or ipaddr"
msgstr "Pogreška pri $FILE: uređaj ili IP adresa nisu određeni"

#: ../network-scripts/ifup-aliases:198
#, fuzzy
msgid "error iN $FILE: didn't specify netmask or prefix"
msgstr "Pogreška pri $FILE: uređaj ili IP adresa nisu određeni"

#: ../network-scripts/ifup-aliases:238 ../network-scripts/ifup-aliases:249
msgid "error in ifcfg-${parent_device}: files"
msgstr "Pogreška u ifcfg-${parent_device}: datoteke"

#: ../network-scripts/ifup-aliases:269
msgid ""
"Determining if ip address ${IPADDR} is already in use for device "
"${parent_device}..."
msgstr ""

#: ../network-scripts/ifup-aliases:273
msgid "Error, some other host ($ARPINGMAC) already uses address ${IPADDR}."
msgstr ""

#: ../network-scripts/ifup-aliases:334
msgid "error in $FILE: IPADDR_START and IPADDR_END don't agree"
msgstr "pogreška pri $FILE: IPADDR_START i IPADDR_END ne slažu se"

#: ../network-scripts/ifup-aliases:339
msgid "error in $FILE: IPADDR_START greater than IPADDR_END"
msgstr "pogreška pri $FILE: IPADDR_START veći je od IPADDR_END"

#: ../network-scripts/ifup-ctc:36
msgid "ERROR: ${DEVICE} did not come up!"
msgstr ""

#: ../network-scripts/ifup-eth:43
msgid "Device ${DEVICE} has different MAC address than expected, ignoring."
msgstr ""
"MAC adresa uređaja ${DEVICE} razlikuje se od očekivane. Bit će ignoriran."

#: ../network-scripts/ifup-eth:116
#, fuzzy
#| msgid ""
#| "Device ${DEVICE} does not seem to be present, delaying initialization."
msgid "Device name does not seem to be present."
msgstr ""
"Izgleda da uređaj ${DEVICE} nije prisutan. Inicijalizacija će biti odgođena."

#: ../network-scripts/ifup-eth:125
msgid "Device ${DEVICE} does not seem to be present, delaying initialization."
msgstr ""
"Izgleda da uređaj ${DEVICE} nije prisutan. Inicijalizacija će biti odgođena."

#: ../network-scripts/ifup-eth:221
msgid "Determining IP information for ${DEVICE}..."
msgstr "Određivanje IP podataka za ${DEVICE}..."

#: ../network-scripts/ifup-eth:223
msgid " failed; no link present.  Check cable?"
msgstr " nije uspjelo; veza nije prisutna. Provjerite kabel."

#: ../network-scripts/ifup-eth:230 ../network-scripts/ifup-eth:378
msgid " done."
msgstr " izvršeno."

#: ../network-scripts/ifup-eth:233 ../network-scripts/ifup-eth:380
msgid " failed."
msgstr " nije uspjelo."

#: ../network-scripts/ifup-eth:257
msgid "Failed to bring up ${DEVICE}."
msgstr "Pokretanje uređaja ${DEVICE} nije uspjelo."

#: ../network-scripts/ifup-eth:288
msgid ""
"Error, some other host ($ARPINGMAC) already uses address ${ipaddr[$idx]}."
msgstr ""

#: ../network-scripts/ifup-eth:295
#, fuzzy
msgid "Error adding address ${ipaddr[$idx]} for ${DEVICE}."
msgstr "Pogreška pri dodavanju adrese ${IPADDR} za ${DEVICE}."

#: ../network-scripts/ifup-eth:322
#, fuzzy
msgid "Error adding default gateway ${GATEWAY} for ${DEVICE}."
msgstr "Pogreška pri dodavanju adrese ${IPADDR} za ${DEVICE}."

#: ../network-scripts/ifup-eth:327
msgid "Error adding default gateway for ${REALDEVICE}."
msgstr ""

#: ../network-scripts/ifup-eth:365
#, fuzzy
msgid "Determining IPv6 information for ${DEVICE}..."
msgstr "Određivanje IP podataka za ${DEVICE}..."

#: ../network-scripts/ifup-ippp:55
msgid "$*"
msgstr "$*"

#: ../network-scripts/ifup-ippp:374
msgid ""
"Warning: ipppd (kernel 2.4.x and below) doesn't support IPv6 using "
"encapsulation 'syncppp'"
msgstr ""
"Upozorenje: ipppd (kernel 2.4.x i stariji) ne podržava IPv6 upotrebom "
"'syncppp' enkapsulacije"

#: ../network-scripts/ifup-ippp:376
msgid "Warning: link doesn't support IPv6 using encapsulation 'rawip'"
msgstr "Upozorenje: Veza ne podržava IPv6 upotrebom enkapsulacije 'rawip'"

#: ../network-scripts/ifup-ipv6:99
msgid ""
"Global IPv6 forwarding is enabled in configuration, but not currently "
"enabled in kernel"
msgstr ""
"Opće IPv6 prosljeđivanje omogućeno je u konfiguraciji, ali trenutno nije "
"omogućeno u kernelu."

#: ../network-scripts/ifup-ipv6:100 ../network-scripts/ifup-ipv6:119
msgid "Please restart network with '/sbin/service network restart'"
msgstr "Ponovo pokrenite mrežu pomoću naredbe '/sbin/service network restart'"

#: ../network-scripts/ifup-ipv6:118
msgid ""
"Global IPv6 forwarding is disabled in configuration, but not currently "
"disabled in kernel"
msgstr ""
"Opće IPv6 prosljeđivanje onemogućeno je u konfiguraciji, ali trenutno nije "
"onemogućeno u kernelu."

#: ../network-scripts/ifup-ipv6:157
msgid ""
"Cannot enable IPv6 privacy method '$IPV6_PRIVACY', not supported by kernel"
msgstr ""
"Nije moguće omogućiti IPv6 načine privatnosti '$IPV6_PRIVACY'. Nema "
"kernelske podrške."

#: ../network-scripts/ifup-ipv6:182
msgid "Device 'tun6to4' (from '$DEVICE') is already up, shutdown first"
msgstr "Uređaj 'tun6to4' (od '$DEVICE') već je pokrenut. Prvo ga isključite."

#: ../network-scripts/ifup-ipv6:209
msgid "Given IPv4 address '$ipv4addr' is not globally usable"
msgstr "Dana IPv4 adresa '$ipv4addr' nije opće upotrebljiva"

#: ../network-scripts/ifup-ipv6:222
msgid ""
"IPv6to4 configuration needs an IPv4 address on related interface or "
"otherwise specified"
msgstr ""
"IPv6to4 konfiguracija potražuje IPv4 adresu za pridruženo sučelje ili "
"određenu na drugi način"

#: ../network-scripts/ifup-ipv6:237
msgid ""
"Warning: configured MTU '$IPV6TO4_MTU' for 6to4 exceeds maximum limit of "
"'$tunnelmtu', ignored"
msgstr ""
"Upozorenje: Konfigurirani MTU '$IPV6TO4_MTU' za 6to4 nadmašuje ograničenje "
"kod '$tunnelmtu'. Bit će ignorirano."

#: ../network-scripts/ifup-ipv6:251
msgid "Warning: interface 'tun6to4' does not support 'IPV6_DEFAULTGW', ignored"
msgstr ""
"Upozorenje: Sučelje 'tun6to4' ne podržava 'IPV6_DEFAULTGW'. Bit će "
"ignorirano."

#: ../network-scripts/ifup-ipv6:287
msgid ""
"Using 6to4 and RADVD IPv6 forwarding usually should be enabled, but it isn't"
msgstr ""
"Upotreba 6to4 i RADVD IPv6 prosljeđivanja obično je omogućena, ali trenutno "
"nije."

#: ../network-scripts/ifup-ipv6:300
msgid "Error occurred while calculating the IPv6to4 prefix"
msgstr "Tijekom izračunavanja IPv6to4 prefiksa došlo je do pogreške"

#: ../network-scripts/ifup-ipv6:303
msgid "radvd control enabled, but config is not complete"
msgstr "radvd kontrola je omogućena, ali konfiguriranje nije potpuno"

#: ../network-scripts/ifup-ipv6:310
msgid "6to4 configuration is not valid"
msgstr "6to4 konfiguracija nije valjana"

#: ../network-scripts/ifup-post:114
msgid "/etc/resolv.conf was not updated: failed to create temporary file"
msgstr ""

#: ../network-scripts/ifup-routes:6
msgid "usage: ifup-routes <net-device> [<nickname>]"
msgstr "Upotreba: ifup-routes <mrežni uređaj> [<nadimak>]"

#: ../network-scripts/ifup-sit:63
msgid "Missing remote IPv4 address of tunnel, configuration is not valid"
msgstr "Nedostaje udaljena IPv4 adresa tunela. Konfiguracija nije valjana."

#: ../network-scripts/ifup-sit:71
msgid "Device '$DEVICE' is already up, please shutdown first"
msgstr "Uređaj '$DEVICE' već je uključen. Prvo ga ugasite."

#: ../network-scripts/ifup-tunnel:61
msgid "Invalid tunnel type $TYPE"
msgstr ""

#: ../network-scripts/init.ipv6-global:161
msgid "Usage: $0 {start|stop|reload|restart|showsysctl}"
msgstr "Upotreba: $0 {start|stop|reload|restart|showsysctl}"

#: ../network-scripts/network-functions:401
msgid ""
"Both 'DHCP_HOSTNAME=${DHCP_HOSTNAME}' and 'DHCP_FQDN=${DHCP_FQDN}' are "
"configured... Using DHCP_FQDN."
msgstr ""

#: ../network-scripts/network-functions:569
msgid "Failed to set value '$value' [mode] to ${DEVICE} bonding device"
msgstr ""

#: ../network-scripts/network-functions:575
msgid "Failed to set value '$value' [miimon] to ${DEVICE} bonding device"
msgstr ""

#: ../network-scripts/network-functions:595
msgid ""
"Failed to set '$arp_ip' value [arp_ip_target] to ${DEVICE} bonding device"
msgstr ""

#: ../network-scripts/network-functions:603
msgid ""
"Failed to set '$value' value [arp_ip_target] to ${DEVICE} bonding device"
msgstr ""

#: ../network-scripts/network-functions:608
msgid "Failed to set '$value' value [$key] to ${DEVICE} bonding device"
msgstr ""

#: ../network-scripts/network-functions:681
msgid "DEBUG     "
msgstr ""

#: ../network-scripts/network-functions:684
msgid "ERROR     "
msgstr ""

#: ../network-scripts/network-functions:687
msgid "WARN      "
msgstr ""

#: ../network-scripts/network-functions:690
msgid "INFO      "
msgstr ""

#: ../network-scripts/network-functions-ipv6:56
msgid "Missing parameter 'IPv6-network' (arg 1)"
msgstr "Nedostaje parametar 'IPv6-network' (arg 1)"

#: ../network-scripts/network-functions-ipv6:61
msgid "Missing parameter 'IPv6-gateway' (arg 2)"
msgstr "Nedostaje parametar 'IPv6-gateway' (arg 2)"

#: ../network-scripts/network-functions-ipv6:86
msgid ""
"'No route to host' adding route '$networkipv6' via gateway '$gatewayipv6' "
"through device '$device'"
msgstr ""
"'No route to host' dodavanje putanje '$networkipv6' putem pristupnika "
"'$gatewayipv6' kroz uređaj '$device'"

#: ../network-scripts/network-functions-ipv6:89
msgid "Unknown error"
msgstr "Nepoznata pogreška"

#: ../network-scripts/network-functions-ipv6:114
msgid "Tunnel device 'sit0' enabling didn't work"
msgstr "Omogućavanje tunelskog uređaja 'sit0' nije funkcioniralo"

#: ../network-scripts/network-functions-ipv6:140
#: ../network-scripts/network-functions-ipv6:203
#: ../network-scripts/network-functions-ipv6:232
#: ../network-scripts/network-functions-ipv6:312
#: ../network-scripts/network-functions-ipv6:427
#: ../network-scripts/network-functions-ipv6:489
#: ../network-scripts/network-functions-ipv6:523
#: ../network-scripts/network-functions-ipv6:565
#: ../network-scripts/network-functions-ipv6:643
#: ../network-scripts/network-functions-ipv6:701
#: ../network-scripts/network-functions-ipv6:754
#: ../network-scripts/network-functions-ipv6:793
#: ../network-scripts/network-functions-ipv6:921
#: ../network-scripts/network-functions-ipv6:1054
msgid "Missing parameter 'device' (arg 1)"
msgstr "Nedostaje parametar 'device' (arg 1)"

#: ../network-scripts/network-functions-ipv6:145
msgid "Missing parameter 'IPv6-address' (arg 2)"
msgstr "Nedostaje parametar 'IPv6-address' (arg 2)"

#: ../network-scripts/network-functions-ipv6:159
msgid "Device '$device' doesn't exist"
msgstr "Uređaj '$device' ne postoji"

#: ../network-scripts/network-functions-ipv6:165
msgid "Device '$device' enabling didn't work"
msgstr "Omogućavanje uređaja '$device' nije funkcioniralo."

#: ../network-scripts/network-functions-ipv6:186
msgid "Cannot add IPv6 address '$address' on dev '$device'"
msgstr "Dodavanje IPv6 adrese '$address' uređaju '$device' nije moguće."

#: ../network-scripts/network-functions-ipv6:343
msgid "Missing parameter 'IPv4 address' (arg 1)"
msgstr "Nedostaje parametar 'IPv4 address' (arg 1)"

#: ../network-scripts/network-functions-ipv6:383
msgid "Missing parameter 'address' (arg 1)"
msgstr "Nedostaje parametar 'address' (arg 1)"

#: ../network-scripts/network-functions-ipv6:394
msgid "Given address '$addr' is not a global IPv4 one (arg 1)"
msgstr "Dana adresa '$ipv4addr' nije opća IPv4 adresa (arg 1)"

#: ../network-scripts/network-functions-ipv6:398
msgid "Given address '$addr' is not a valid IPv4 one (arg 1)"
msgstr "Dana adresa '$addr' nije IPv4 valjana (argument 1)"

#: ../network-scripts/network-functions-ipv6:432
msgid "Missing parameter 'global IPv4 address' (arg 2)"
msgstr "Nedostaje parametar 'global IPv4 address' (arg 2)"

#: ../network-scripts/network-functions-ipv6:438
#: ../network-scripts/network-functions-ipv6:495
#: ../network-scripts/network-functions-ipv6:534
msgid "Given device '$device' is not supported (arg 1)"
msgstr "Dani uređaj '$device' nije podržan (arg 1)"

#: ../network-scripts/network-functions-ipv6:528
msgid "Missing parameter 'local IPv4 address' (arg 2)"
msgstr "Nedostaje parametar 'local IPv4 address' (arg 2)"

#: ../network-scripts/network-functions-ipv6:570
msgid "Missing parameter 'IPv4-tunnel address' (arg 2)"
msgstr "Nedostaje parametar 'IPv4-tunnel address' (arg 2)"

#: ../network-scripts/network-functions-ipv6:590
msgid ""
"Given remote address '$addressipv4tunnel' on tunnel device '$device' is "
"already configured on device '$devnew'"
msgstr ""
"Dana udaljena adresa '$addressipv4tunnel' na tunelskom uređaju '$device' već "
"je konfigurirana na uređaju '$devnew'"

#: ../network-scripts/network-functions-ipv6:603
msgid "Tunnel device '$device' creation didn't work"
msgstr "Izrada tunelskog uređaja '$device' nije funkcionirala"

#: ../network-scripts/network-functions-ipv6:610
msgid "Tunnel device '$device' bringing up didn't work"
msgstr "Spuštanje tunelskog uređaja '$device' nije funkcioniralo"

#: ../network-scripts/network-functions-ipv6:706
msgid "Missing parameter 'selection' (arg 2)"
msgstr "Nedostaje parametar 'selection' (arg 2)"

#: ../network-scripts/network-functions-ipv6:710
msgid "Unsupported selection '$selection' specified (arg 2)"
msgstr "Određen je nepodržani odabir '$selection' (arg 2)"

#: ../network-scripts/network-functions-ipv6:798
msgid "Missing parameter 'IPv6 MTU' (arg 2)"
msgstr "Nedostaje parametar 'IPv6 MTU' (arg 2)"

#: ../network-scripts/network-functions-ipv6:804
msgid "Given IPv6 MTU '$ipv6_mtu' is out of range"
msgstr "Dani IPv6 MTU '$ipv6_mtu' izvan je raspona"

#: ../network-scripts/network-functions-ipv6:841
msgid "Given IPv6 default gateway '$address' is not in proper format"
msgstr "Dani IPv6 zadani pristupnik '$address' nije pravilnog oblika"

#: ../network-scripts/network-functions-ipv6:847
msgid ""
"Given IPv6 default gateway '$address' has scope '$device_scope' defined, "
"given default gateway device '$device' will be not used"
msgstr ""
"Dani IPv6 zadani pristupnik '$address' ima definiran scope '$device_scope'. "
"Dani zadani pristupnik '$device' neće se upotrebljavati."

#: ../network-scripts/network-functions-ipv6:855
msgid ""
"Given IPv6 default gateway '$address' is link-local, but no scope or gateway "
"device is specified"
msgstr ""
"Dani IPv6 zadani pristupnik '$address' je lokalno vezan, ali nije određen "
"nikakav pristupnik ili scope"

#: ../network-scripts/network-functions-ipv6:895
msgid "Given IPv6 default device '$device' requires an explicit nexthop"
msgstr "Dani IPv6 zadani uređaj '$device' zahtjeva eksplicitan nexthop"

#: ../network-scripts/network-functions-ipv6:898
msgid "Given IPv6 default device '$device' doesn't exist or isn't up"
msgstr "Dani IPv6 zadani uređaj '$device' ne postoji ili nije pokrenut"

#: ../network-scripts/network-functions-ipv6:904
msgid "No parameters given to setup a default route"
msgstr "Za postavljanje zadanog smjera nisu dani parametri"

#: ../network-scripts/network-functions-ipv6:959
msgid "No reason given for sending trigger to radvd"
msgstr "Nije dat razlog za slanje okidača prema radvd"

#: ../network-scripts/network-functions-ipv6:964
msgid "Unsupported reason '$reason' for sending trigger to radvd"
msgstr "Nepodržani razlog '$reason' za slanje okidača prema radvd."

#: ../network-scripts/network-functions-ipv6:993
msgid "Unsupported mechanism '$mechanism' for sending trigger to radvd"
msgstr "Mehanizam '$mechanism' nije podržan za slanje okidača prema radvd"

#: ../network-scripts/network-functions-ipv6:1005
msgid "Given pidfile '$pidfile' doesn't exist, cannot send trigger to radvd"
msgstr ""
"Dana pid datoteka '$pidfile' ne postoji. Nije moguće poslati okidač prema "
"radvd."

#: ../network-scripts/network-functions-ipv6:1014
msgid "Pidfile '$pidfile' is empty, cannot send trigger to radvd"
msgstr ""
"Pid datoteka '$pidfile' je prazna. Nije moguće poslati okidač prema radvd."

#: ../network-scripts/network-functions-ipv6:1031
msgid "radvd not (properly) installed, triggering failed"
msgstr "radvd nije (ispravno) instaliran. okidanje nije uspjelo."

#: ../network-scripts/network-functions-ipv6:1066
msgid "Duplicate Address Detection: Duplicate addresses detected"
msgstr ""

#: ../network-scripts/network-functions-ipv6:1067
msgid "Duplicate Address Detection: Please, fix your network configuration"
msgstr ""

#: ../network-scripts/network-functions-ipv6:1071
msgid ""
"Waiting for interface ${device} IPv6 address(es) to leave the 'tentative' "
"state"
msgstr ""

#: ../network-scripts/network-functions-ipv6:1079
msgid "Some IPv6 address(es) of ${device} remain still in 'tentative' state"
msgstr ""

#: ../network-scripts/network-functions-ipv6:1080
msgid "Run 'ip -6 addr show dev ${device} scope global tentative' to see more"
msgstr ""

#: ../usr/sbin/service:95
msgid ""
"Redirecting to /bin/systemctl ${ACTION}${OPTIONS:+ }${OPTIONS} "
"${SERVICE_MANGLED}"
msgstr ""

#: ../usr/sbin/service:98
msgid ""
"The service command supports only basic LSB actions (start, stop, restart, "
"try-restart, reload, force-reload, status). For other actions, please try to "
"use systemctl."
msgstr ""

#: ../etc/rc.d/init.d/functions:33
#, fuzzy
msgid "Starting $prog (via systemctl): "
msgstr "Pokretanje demona $prog: "

#: ../etc/rc.d/init.d/functions:36
#, fuzzy
msgid "Stopping $prog (via systemctl): "
msgstr "Zaustavljanje demona $prog: "

#: ../etc/rc.d/init.d/functions:39
#, fuzzy
msgid "Reloading $prog configuration (via systemctl): "
msgstr "Ponovno čitanje konfiguracije $prog: "

#: ../etc/rc.d/init.d/functions:42
#, fuzzy
msgid "Restarting $prog (via systemctl): "
msgstr "Ponovno pokretanje $prog:"

#: ../etc/rc.d/init.d/functions:52
msgid "Reloading systemd: "
msgstr ""

#: ../etc/rc.d/init.d/functions:236 ../etc/rc.d/init.d/functions:274
msgid "$0: Usage: daemon [+/-nicelevel] {program}"
msgstr "$0: Upotreba: demon [+/-razina pristojnosti] {program}"

#: ../etc/rc.d/init.d/functions:304
msgid "$base startup"
msgstr "$base pokretanje"

#: ../etc/rc.d/init.d/functions:314 ../etc/rc.d/init.d/functions:333
msgid "Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]"
msgstr "Upotreba: killproc [-p pid_datoteka] [ -d odgoda] {program} [-signal]"

#: ../etc/rc.d/init.d/functions:323 ../etc/rc.d/init.d/functions:450
msgid "-b option can be used only with -p"
msgstr ""

#: ../etc/rc.d/init.d/functions:324
#, fuzzy
#| msgid "Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]"
msgid "Usage: killproc -p pidfile -b binary program"
msgstr "Upotreba: killproc [-p pid_datoteka] [ -d odgoda] {program} [-signal]"

#: ../etc/rc.d/init.d/functions:353 ../etc/rc.d/init.d/functions:363
#: ../etc/rc.d/init.d/functions:378
msgid "$base shutdown"
msgstr "$base gašenje"

#: ../etc/rc.d/init.d/functions:369
msgid "$base $killlevel"
msgstr "$base $killlevel"

#: ../etc/rc.d/init.d/functions:396
msgid "Usage: pidfileofproc {program}"
msgstr "Upotreba: pidfileofproc {program}"

#: ../etc/rc.d/init.d/functions:411
msgid "Usage: pidofproc [-p pidfile] {program}"
msgstr "Upotreba: pidofproc [-p pidfile] {program}"

#: ../etc/rc.d/init.d/functions:437
msgid "Usage: status [-p pidfile] {program}"
msgstr "Upotreba: status [-p pidfile] {program}"

#: ../etc/rc.d/init.d/functions:451
#, fuzzy
#| msgid "Usage: status [-p pidfile] {program}"
msgid "Usage: status -p pidfile -b binary program"
msgstr "Upotreba: status [-p pidfile] {program}"

#: ../etc/rc.d/init.d/functions:478 ../etc/rc.d/init.d/functions:484
msgid "${base} (pid $pid) is running..."
msgstr "${base} (pid $pid) je pokrenut..."

#: ../etc/rc.d/init.d/functions:488
msgid "${base} dead but pid file exists"
msgstr "${base} je mrtav, ali pid datoteka postoji"

#: ../etc/rc.d/init.d/functions:492
msgid "${base} status unknown due to insufficient privileges."
msgstr ""

#: ../etc/rc.d/init.d/functions:501
msgid "${base} dead but subsys locked"
msgstr "${base} mrtav, ali je subsys zaključan"

#: ../etc/rc.d/init.d/functions:504
msgid "${base} is stopped"
msgstr "${base} je zaustavljen"

#: ../etc/rc.d/init.d/functions:512
msgid "  OK  "
msgstr "  U redu  "

#: ../etc/rc.d/init.d/functions:523
msgid "FAILED"
msgstr "NEUSPJELO"

#: ../etc/rc.d/init.d/functions:534
msgid "PASSED"
msgstr "U REDU"

#: ../etc/rc.d/init.d/functions:545
msgid "WARNING"
msgstr "UPOZORENJE"

#: ../etc/rc.d/init.d/functions:595
msgid "$STRING"
msgstr "$STRING"

#: ../etc/rc.d/init.d/network:52
msgid ""
"You are using 'network' service provided by 'network-scripts', which are now "
"deprecated."
msgstr ""

#: ../etc/rc.d/init.d/network:54
msgid ""
"It is advised to switch to 'NetworkManager' instead for network management."
msgstr ""

#: ../etc/rc.d/init.d/network:77
msgid "Bringing up loopback interface: "
msgstr "Pokretanje sučelja povratne veze: "

#: ../etc/rc.d/init.d/network:81
msgid "No 802.1Q VLAN support available in kernel."
msgstr "U kernelu nema podrške za 802.1Q VLAN"

#: ../etc/rc.d/init.d/network:132 ../etc/rc.d/init.d/network:139
msgid "Bringing up interface $i: "
msgstr "Pokretanje sučelja $i: "

#: ../etc/rc.d/init.d/network:151
#, fuzzy
msgid "Legacy static-route support not available: /sbin/route not found"
msgstr "Podrške za premošćivanje nije raspoloživa: brctl nije pronađen"

#: ../etc/rc.d/init.d/network:178
msgid ""
"Target is not reachable, but timeout was already reached. Continuing anyway."
msgstr ""

#: ../etc/rc.d/init.d/network:189
msgid "rootfs or /usr is on network filesystem, leaving network up"
msgstr ""

#: ../etc/rc.d/init.d/network:199
msgid "system is shutting down, leaving interfaces up as requested"
msgstr ""

#: ../etc/rc.d/init.d/network:249
msgid "Shutting down interface $i: "
msgstr "Gašenje sučelja $i: "

#: ../etc/rc.d/init.d/network:255
msgid "Shutting down loopback interface: "
msgstr "Gašenje sučelja povratne veze: "

#: ../etc/rc.d/init.d/network:267
msgid "Configured devices:"
msgstr "Konfigurirani uređaji:"

#: ../etc/rc.d/init.d/network:270
msgid "Currently active devices:"
msgstr "Trenutno aktivni uređaji:"

#: ../etc/rc.d/init.d/network:280
#, fuzzy
#| msgid "Usage: $0 {start|stop|status|restart|reload|force-reload}"
msgid "Usage: $0 {start|stop|status|restart|force-reload}"
msgstr "Upotreba: $0 {start|stop|status|restart|reload|force-reload}"

#~ msgid "Usage: $0 {start|stop|status|restart|condrestart}"
#~ msgstr "Upotreba: $0 {start|stop|status|restart|condrestart}"

#~ msgid "Bridge support not available: brctl not found"
#~ msgstr "Podrške za premošćivanje nije raspoloživa: brctl nije pronađen"
package urpm;

# $Id$

no warnings 'utf8';
use strict;
use File::Find ();
use urpm::msg;
use urpm::download;
use urpm::util;
use urpm::sys;
use urpm::cfg;
use MDV::Distribconf;

our $VERSION = '4.8.23';
our @ISA = qw(URPM);

use URPM;
use URPM::Resolve;

BEGIN {
    # this doesn't work for perls >= 5.9.4
    if ($ENV{DEBUG_URPMI}) {
	require encoding::warnings;
	encoding::warnings->import;
    }
}

#- this violently overrides is_arch_compat() to always return true.
sub shunt_ignorearch {
    eval q( sub URPM::Package::is_arch_compat { 1 } );
}

#- create a new urpm object.
sub new {
    my ($class) = @_;
    my $self;
    $self = bless {
	# from URPM
	depslist   => [],
	provides   => {},

	config     => "/etc/urpmi/urpmi.cfg",
	skiplist   => "/etc/urpmi/skip.list",
	instlist   => "/etc/urpmi/inst.list",
	statedir   => "/var/lib/urpmi",
	cachedir   => "/var/cache/urpmi",
	media      => undef,
	options    => {},

	#- sync: first argument is options hashref, others are urls to fetch.
	sync       => sub { $self->sync_webfetch(@_) },
	fatal      => sub { printf STDERR "%s\n", $_[1]; exit($_[0]) },
	error      => sub { printf STDERR "%s\n", $_[0] },
	log        => sub { printf "%s\n", $_[0] },
	ui_msg     => sub {
	    $self->{log}($_[0]);
	    ref $self->{ui} && ref $self->{ui}{msg} and $self->{ui}{msg}->($_[1]);
	},
    }, $class;
    $self->set_nofatal(1);
    $self;
}

#- syncing algorithms.
sub sync_webfetch {
    my $urpm = shift;
    my $options = shift;
    my %files;
    #- currently ftp and http protocols are managed by curl or wget,
    #- ssh and rsync protocols are managed by rsync *AND* ssh.
    foreach (@_) {
	/^([^:_]*)[^:]*:/ or die N("unknown protocol defined for %s", $_);
	push @{$files{$1}}, $_;
    }
    if ($files{removable} || $files{file}) {
	eval {
	    sync_file($options, @{$files{removable} || []}, @{$files{file} || []});
	};
	$urpm->{fatal}(10, $@) if $@;
	delete @files{qw(removable file)};
    }
    for my $cpt (qw(wget-options curl-options rsync-options)) {
	$options->{$cpt} = $urpm->{options}{$cpt} if defined $urpm->{options}{$cpt};
    }
    if ($files{ftp} || $files{http} || $files{https}) {
	my @webfetch = qw(curl wget);
	my @available_webfetch = grep { -x "/usr/bin/$_" || -x "/bin/$_" } @webfetch;
	#- use user default downloader if provided and available
	my $option_downloader = $urpm->{options}{downloader}; #- cmd-line switch
	if (!$option_downloader && $options->{media}) { #- per-media config
	    (my $m) = grep { $_->{name} eq $options->{media} } @{$urpm->{media}};
	    ref $m && $m->{downloader} and $option_downloader = $m->{downloader};
	}
	#- global config
	!$option_downloader && exists $urpm->{global_config}{downloader}
	    and $option_downloader = $urpm->{global_config}{downloader};
	my ($preferred) = grep { $_ eq $option_downloader } @available_webfetch;
	#- else first downloader of @webfetch is the default one
	$preferred ||= $available_webfetch[0];
	if ($option_downloader ne $preferred && $option_downloader && !our $webfetch_not_available) {
	    $urpm->{log}(N("%s is not available, falling back on %s", $option_downloader, $preferred));
	    $webfetch_not_available = 1;
	}
	if ($preferred eq 'curl') {
	    sync_curl($options, @{$files{ftp} || []}, @{$files{http} || []}, @{$files{https} || []});
	} elsif ($preferred eq 'wget') {
	    sync_wget($options, @{$files{ftp} || []}, @{$files{http} || []}, @{$files{https} || []});
	} else {
	    die N("no webfetch found, supported webfetch are: %s\n", join(", ", @webfetch));
	}
	delete @files{qw(ftp http https)};
    }
    if ($files{rsync}) {
	sync_rsync($options, @{$files{rsync} || []});
	delete $files{rsync};
    }
    if ($files{ssh}) {
	my @ssh_files;
	foreach (@{$files{ssh} || []}) {
	    m|^ssh://([^/]*)(.*)| and push @ssh_files, "$1:$2";
	}
	sync_ssh($options, @ssh_files);
	delete $files{ssh};
    }
    %files and die N("unable to handle protocol: %s", join ', ', keys %files);
}

our @PER_MEDIA_OPT = qw(
    downloader
    hdlist
    ignore
    key-ids
    list
    md5sum
    noreconfigure
    priority
    removable
    static
    synthesis
    update
    verify-rpm
    virtual
    with_hdlist
);

#- Loads /etc/urpmi/urpmi.cfg and performs basic checks.
#- Does not handle old format: <name> <url> [with <path_hdlist>]
#- options :
#-    - nocheck_access : don't check presence of hdlist and other files
sub read_config {
    my ($urpm, %options) = @_;
    return if $urpm->{media}; #- media already loaded
    $urpm->{media} = [];
    my $config = urpm::cfg::load_config($urpm->{config})
	or $urpm->{fatal}(6, $urpm::cfg::err);

    #- global options
    if ($config->{''}) {
	foreach my $opt (qw(
	    allow-force
	    allow-nodeps
	    auto
	    compress
	    downloader
	    default-media
	    excludedocs
	    excludepath
	    fuzzy
	    ignoresize
	    keep
	    key-ids
	    limit-rate
	    nopubkey
	    norebuild
	    post-clean
	    pre-clean
	    priority-upgrade
	    prohibit-remove
	    repackage
	    resume
	    retry
	    split-length
	    split-level
	    strict-arch
	    verify-rpm
	    curl-options
	    rsync-options
	    wget-options
	)) {
	    if (defined $config->{''}{$opt} && !exists $urpm->{options}{$opt}) {
		$urpm->{options}{$opt} = $config->{''}{$opt};
	    }
	}
    }
    #- per-media options
    foreach my $m (grep { $_ ne '' } keys %$config) {
	my $medium = { name => $m, clear_url => $config->{$m}{url} };
	foreach my $opt (@PER_MEDIA_OPT) {
	    defined $config->{$m}{$opt} and $medium->{$opt} = $config->{$m}{$opt};
	}
	$urpm->probe_medium($medium, %options) and push @{$urpm->{media}}, $medium;
    }

    eval { require urpm::ldap; urpm::ldap::load_ldap_media($urpm, %options) };

    #- load default values
    foreach (qw(post-clean verify-rpm)) {
	exists $urpm->{options}{$_} or $urpm->{options}{$_} = 1;
    }

    $urpm->{media} = [ sort { $a->{priority} <=> $b->{priority} } @{$urpm->{media}} ];

    #- remember if an hdlist or list file is already used
    my %filelists;
    foreach (@{$urpm->{media}}) {
	foreach my $filetype (qw(hdlist list)) {
	    if ($_->{$filetype}) {
		exists($filelists{$filetype}{$_->{$filetype}})
		    and $_->{ignore} = 1,
		    $urpm->{error}(
			$filetype eq 'hdlist'
			    ? N("medium \"%s\" trying to use an already used hdlist, medium ignored", $_->{name})
			    : N("medium \"%s\" trying to use an already used list, medium ignored",   $_->{name})
		    );
		$filelists{$filetype}{$_->{$filetype}} = undef;
	    }
	}
    }

    #- check the presence of hdlist and list files if necessary.
    unless ($options{nocheck_access}) {
	foreach (@{$urpm->{media}}) {
	    $_->{ignore} and next;
	    -r "$urpm->{statedir}/$_->{hdlist}" || -r "$urpm->{statedir}/synthesis.$_->{hdlist}" && $_->{synthesis}
		or $_->{ignore} = 1,
		$urpm->{error}(N("unable to access hdlist file of \"%s\", medium ignored", $_->{name}));
	    $_->{list} && -r "$urpm->{statedir}/$_->{list}" || defined $_->{url}
		or $_->{ignore} = 1,
		$urpm->{error}(N("unable to access list file of \"%s\", medium ignored", $_->{name}));
	}
    }

    #- read MD5 sums (usually not in urpmi.cfg but in a separate file)
    my $md5sum = $urpm->open_safe("<", "$urpm->{statedir}/MD5SUM");
    if ($md5sum) {
	local $_;
	while (<$md5sum>) {
	    my ($md5sum, $file) = /(\S*)\s+(.*)/;
	    foreach (@{$urpm->{media}}) {
		($_->{synthesis} ? "synthesis." : "") . $_->{hdlist} eq $file
		    and $_->{md5sum} = $md5sum, last;
	    }
	}
	close $md5sum;
    }

    #- remember global options for write_config
    $urpm->{global_config} = $config->{''};
}

#- probe medium to be used, take old medium into account too.
sub probe_medium {
    my ($urpm, $medium, %options) = @_;
    local $_;

    foreach (@{$urpm->{media}}) {
	if ($_->{name} eq $medium->{name}) {
	    $urpm->{error}(N("trying to override existing medium \"%s\", skipping", $medium->{name}));
	    return;
	}
    }

    $medium->{url} ||= $medium->{clear_url};

    if ($medium->{virtual}) {
	#- a virtual medium needs to have an url available without using a list file.
	if ($medium->{hdlist} || $medium->{list}) {
	    $medium->{ignore} = 1;
	    $urpm->{error}(N("virtual medium \"%s\" should not have defined hdlist or list file, medium ignored",
			     $medium->{name}));
	}
	unless ($medium->{url}) {
	    $medium->{ignore} = 1;
	    $urpm->{error}(N("virtual medium \"%s\" should have a clear url, medium ignored",
			     $medium->{name}));
	}
    } else {
	unless ($medium->{ignore} || $medium->{hdlist}) {
	    $medium->{hdlist} = "hdlist.$medium->{name}.cz";
	    -e "$urpm->{statedir}/$medium->{hdlist}" or $medium->{hdlist} = "hdlist.$medium->{name}.cz2";
	    -e "$urpm->{statedir}/$medium->{hdlist}" or
	      $medium->{ignore} = 1,
		$urpm->{error}(N("unable to find hdlist file for \"%s\", medium ignored", $medium->{name}));
	}
	unless ($medium->{ignore} || $medium->{list}) {
	    unless (defined $medium->{url}) {
		$medium->{list} = "list.$medium->{name}";
		unless (-e "$urpm->{statedir}/$medium->{list}") {
		    $medium->{ignore} = 1,
		      $urpm->{error}(N("unable to find list file for \"%s\", medium ignored", $medium->{name}));
		}
	    }
	}

	#- there is a little more to do at this point as url is not known, inspect directly list file for it.
	unless ($medium->{url}) {
	    my %probe;
	    if (-r "$urpm->{statedir}/$medium->{list}") {
		my $listfile = $urpm->open_safe("<", "$urpm->{statedir}/$medium->{list}");
		if ($listfile) {
		    while (<$listfile>) {
			#- /./ is end of url marker in list file (typically generated by a
			#- find . -name "*.rpm" > list
			#- for exportable list file.
			m|^(.*)/\./| and $probe{$1} = undef;
			m|^(.*)/[^/]*$| and $probe{$1} = undef;
		    }
		    close $listfile;
		}
	    }
	    foreach (sort { length($a) <=> length($b) } keys %probe) {
		if ($medium->{url}) {
		    if ($medium->{url} ne substr($_, 0, length($medium->{url}))) {
			$medium->{ignore} or $urpm->{error}(N("inconsistent list file for \"%s\", medium ignored", $medium->{name}));
			$medium->{ignore} = 1;
			last;
		    }
		} else {
		    $medium->{url} = $_;
		}
	    }
	    unless ($options{nocheck_access}) {
		unless ($medium->{url}) {
		    $medium->{ignore} or $urpm->{error}(N("unable to inspect list file for \"%s\", medium ignored", $medium->{name}));
		    $medium->{ignore} = 1;
		}
	    }
	}
    }

    #- probe removable device.
    $urpm->probe_removable_device($medium);

    #- clear URLs for trailing /es.
    $medium->{url} and $medium->{url} =~ s|(.*?)/*$|$1|;
    $medium->{clear_url} and $medium->{clear_url} =~ s|(.*?)/*$|$1|;

    $medium;
}

#- returns the removable device name if it corresponds to an iso image, '' otherwise
sub is_iso {
    my ($removable_dev) = @_;
    $removable_dev && $removable_dev =~ /\.iso$/i ? $removable_dev : '';
}

#- probe device associated with a removable device.
sub probe_removable_device {
    my ($urpm, $medium) = @_;

    #- try to find device name in url scheme
    if ($medium->{url} && $medium->{url} =~ /^removable_?([^_:]*)(?:_[^:]*)?:/) {
	$medium->{removable} ||= $1 && "/dev/$1";
    } else {
	delete $medium->{removable};
    }

    #- try to find device to open/close for removable medium.
    if (exists($medium->{removable})) {
	if (my ($dir) = $medium->{url} =~ m!^(?:(?:file|removable)[^:]*:/)?(/.*)!) {
	    my %infos;
	    my @mntpoints = urpm::sys::find_mntpoints($dir, \%infos);
	    if (@mntpoints > 1) { #- return value is suitable for an hash.
		$urpm->{log}(N("too many mount points for removable medium \"%s\"", $medium->{name}));
		$urpm->{log}(N("taking removable device as \"%s\"", join ',', map { $infos{$_}{device} } @mntpoints));
	    }
	    if (is_iso($medium->{removable})) {
		$urpm->{log}(N("Medium \"%s\" is an ISO image, will be mounted on-the-fly", $medium->{name}));
	    } elsif (@mntpoints) {
		if ($medium->{removable} && $medium->{removable} ne $infos{$mntpoints[-1]}{device}) {
		    $urpm->{log}(N("using different removable device [%s] for \"%s\"",
				   $infos{$mntpoints[-1]}{device}, $medium->{name}));
		}
		$medium->{removable} = $infos{$mntpoints[-1]}{device};
	    } else {
		$urpm->{error}(N("unable to retrieve pathname for removable medium \"%s\"", $medium->{name}));
	    }
	} else {
	    $urpm->{error}(N("unable to retrieve pathname for removable medium \"%s\"", $medium->{name}));
	}
    }
}

#- Writes the urpmi.cfg file.
sub write_config {
    my ($urpm) = @_;

    #- avoid trashing exiting configuration if it wasn't loaded
    $urpm->{media} or return;

    my $config = {
	#- global config options found in the config file, without the ones
	#- set from the command-line
	'' => $urpm->{global_config},
    };
    foreach my $medium (@{$urpm->{media}}) {
	next if $medium->{external};
	my $medium_name = $medium->{name};
	$config->{$medium_name}{url} = $medium->{clear_url};
	foreach (qw(hdlist with_hdlist list removable key-ids priority priority-upgrade update noreconfigure static ignore synthesis virtual)) {
	    defined $medium->{$_} and $config->{$medium_name}{$_} = $medium->{$_};
	}
    }
    urpm::cfg::dump_config($urpm->{config}, $config)
	or $urpm->{fatal}(6, N("unable to write config file [%s]", $urpm->{config}));

    #- write MD5SUM file
    my $md5sum = $urpm->open_safe('>', "$urpm->{statedir}/MD5SUM") or return 0;
    foreach my $medium (@{$urpm->{media}}) {
	$medium->{md5sum}
	    and print $md5sum "$medium->{md5sum}  " . ($medium->{synthesis} && "synthesis.") . $medium->{hdlist} . "\n";
    }
    close $md5sum;

    $urpm->{log}(N("wrote config file [%s]", $urpm->{config}));

    #- everything should be synced now.
    delete $urpm->{modified};
}

#- read urpmi.cfg file as well as necessary synthesis files
#- options :
#-	callback
#-	call_back_only_once
#-	excludemedia
#-	hdlist
#-	media
#-	nodepslist
#-	noinstalling
#-	noskipping
#-	parallel
#-	root
#-	searchmedia
#-	skip
#-	sortmedia
#-	update
#-	usedistrib
sub configure {
    my ($urpm, %options) = @_;

    $urpm->clean;

    $options{parallel} && $options{usedistrib} and $urpm->{fatal}(1, N("Can't use parallel mode with use-distrib mode"));

    if ($options{parallel}) {
	my ($parallel_options, $parallel_handler);
	#- read parallel configuration
	local $_;
	my $parallel = $urpm->open_safe("<", "/etc/urpmi/parallel.cfg");
	if ($parallel) {
	    while (<$parallel>) {
		chomp; s/#.*$//; s/^\s*//; s/\s*$//;
		/\s*([^:]*):(.*)/ or $urpm->{error}(N("unable to parse \"%s\" in file [%s]", $_, "/etc/urpmi/parallel.cfg")), next;
		$1 eq $options{parallel} and $parallel_options = ($parallel_options && "\n") . $2;
	    }
	    close $parallel;
	}
	#- if a configuration option has been found, use it; else fatal error.
	if ($parallel_options) {
	    foreach my $dir (grep { -d $_ } map { "$_/urpm" } @INC) {
		my $dh = $urpm->opendir_safe($dir);
		if ($dh) {
		    while (defined ($_ = readdir $dh)) { #- load parallel modules
			/parallel.*\.pm$/ && -f "$dir/$_" or next;
			$urpm->{log}->(N("examining parallel handler in file [%s]", "$dir/$_"));
			eval { require "$dir/$_"; $parallel_handler = $urpm->handle_parallel_options($parallel_options) };
			$parallel_handler and last;
		    }
		    closedir $dh;
		}
		$parallel_handler and last;
	    }
	}
	if ($parallel_handler) {
	    if ($parallel_handler->{nodes}) {
		$urpm->{log}->(N("found parallel handler for nodes: %s", join(', ', keys %{$parallel_handler->{nodes}})));
	    }
	    if (!$options{media} && $parallel_handler->{media}) {
		$options{media} = $parallel_handler->{media};
		$urpm->{log}->(N("using associated media for parallel mode: %s", $options{media}));
	    }
	    $urpm->{parallel_handler} = $parallel_handler;
	} else {
	    $urpm->{fatal}(1, N("unable to use parallel option \"%s\"", $options{parallel}));
	}
    } else {
	#- parallel is exclusive against root options.
	$urpm->{root} = $options{root};
    }

    $urpm->{root} && ! -c "$urpm->{root}/dev/null"
	and $urpm->{error}(N("there doesn't seem to be devices in the chroot in \"%s\"", $urpm->{root}));

    if ($options{synthesis}) {
	if ($options{synthesis} ne 'none') {
	    #- synthesis take precedence over media, update options.
	    $options{media} || $options{excludemedia} || $options{sortmedia} || $options{update} || $options{parallel} and
	      $urpm->{fatal}(1, N("--synthesis cannot be used with --media, --excludemedia, --sortmedia, --update or --parallel"));
	    $urpm->parse_synthesis($options{synthesis});
	    #- synthesis disables the split of transaction (too risky and not useful).
	    $urpm->{options}{'split-length'} = 0;
	}
    } else {
        if ($options{usedistrib}) {
            $urpm->{media} = [];
            $urpm->add_distrib_media("Virtual", $options{usedistrib}, %options, 'virtual' => 1);
        } else {
	    $urpm->read_config(%options);
	    if (!$options{media} && $urpm->{options}{'default-media'}) {
		$options{media} = $urpm->{options}{'default-media'};
	    }
        }
	if ($options{media}) {
	    delete $_->{modified} foreach @{$urpm->{media} || []};
	    $urpm->select_media(split /,/, $options{media});
	    foreach (grep { !$_->{modified} } @{$urpm->{media} || []}) {
		#- this is only a local ignore that will not be saved.
		$_->{ignore} = 1;
	    }
	}
	if ($options{searchmedia}) {
	   $urpm->select_media($options{searchmedia}); #- Ensure this media has been selected
	   foreach (grep { !$_->{ignore} } @{$urpm->{media} || []}) {
		$_->{name} eq $options{searchmedia} and do {
			$_->{searchmedia} = 1;
			last;
		};
	   }
	}
	if ($options{excludemedia}) {
	    delete $_->{modified} foreach @{$urpm->{media} || []};
	    $urpm->select_media(split /,/, $options{excludemedia});
	    foreach (grep { $_->{modified} } @{$urpm->{media} || []}) {
		#- this is only a local ignore that will not be saved.
		$_->{ignore} = 1;
	    }
	}
	if ($options{sortmedia}) {
	    delete $_->{modified} foreach @{$urpm->{media} || []};
	    my @oldmedia = @{$urpm->{media} || []};
	    my @newmedia;
	    foreach (split /,/, $options{sortmedia}) {
		$urpm->select_media($_);
		push @newmedia, grep { $_->{modified} } @oldmedia;
		@oldmedia = grep { !$_->{modified} } @oldmedia;
	    }
	    #- anything not selected should be added here, as it's after the selected ones.
	    $urpm->{media} = [ @newmedia, @oldmedia ];
	    #- forget remaining modified flags.
	    delete $_->{modified} foreach @{$urpm->{media} || []};
	}
	unless ($options{nodepslist}) {
	    my $second_pass;
	    do {
		foreach (grep { !$_->{ignore} && (!$options{update} || $_->{update}) } @{$urpm->{media} || []}) {
		    our $currentmedia = $_; #- hack for urpmf
		    delete @$_{qw(start end)};
		    if ($_->{virtual}) {
			my $path = $_->{url} =~ m!^(?:file:/*)?(/[^/].*[^/])/*\Z! && $1;
			if ($path) {
			    if ($_->{synthesis}) {
				$urpm->{log}(N("examining synthesis file [%s]", "$path/$_->{with_hdlist}"));
				($_->{start}, $_->{end}) = $urpm->parse_synthesis(
				    "$path/$_->{with_hdlist}", callback => $options{callback});
			    } else {
				$urpm->{log}(N("examining hdlist file [%s]", "$path/$_->{with_hdlist}"));
				#- we'll need a second pass
				defined $second_pass or $second_pass = 1;
				($_->{start}, $_->{end}) = $urpm->parse_hdlist(
				    "$path/$_->{with_hdlist}",
				    packing => 1,
				    callback => $options{call_back_only_once} && $second_pass ? undef : $options{callback},
				);
			    }
			} else {
			    $urpm->{error}(N("virtual medium \"%s\" is not local, medium ignored", $_->{name}));
			    $_->{ignore} = 1;
			}
		    } else {
			if ($options{hdlist} && -e "$urpm->{statedir}/$_->{hdlist}" && -s _ > 32) {
			    $urpm->{log}(N("examining hdlist file [%s]", "$urpm->{statedir}/$_->{hdlist}"));
			    ($_->{start}, $_->{end}) = $urpm->parse_hdlist(
				"$urpm->{statedir}/$_->{hdlist}",
				packing => 1,
				callback => $options{callback},
			    );
			} else {
			    $urpm->{log}(N("examining synthesis file [%s]", "$urpm->{statedir}/synthesis.$_->{hdlist}"));
			    ($_->{start}, $_->{end}) = $urpm->parse_synthesis(
				"$urpm->{statedir}/synthesis.$_->{hdlist}",
				callback => $options{callback},
			    );
			    unless (defined $_->{start} && defined $_->{end}) {
				$urpm->{log}(N("examining hdlist file [%s]", "$urpm->{statedir}/$_->{hdlist}"));
				($_->{start}, $_->{end}) = $urpm->parse_hdlist("$urpm->{statedir}/$_->{hdlist}",
				    packing => 1,
				    callback => $options{callback},
				);
			    }
			}
		    }
		    unless ($_->{ignore}) {
			if (defined $_->{start} && defined $_->{end}) {
			    if ($_->{searchmedia}) {
			        ($urpm->{searchmedia}{start}, $urpm->{searchmedia}{end}) = ($_->{start}, $_->{end});
				$urpm->{log}(N("Search start: %s end: %s",
					$urpm->{searchmedia}{start}, $urpm->{searchmedia}{end}));
				delete $_->{searchmedia};
			    }
			} else {
			    $urpm->{error}(N("problem reading hdlist or synthesis file of medium \"%s\"", $_->{name}));
			    $_->{ignore} = 1;
			}
		    }
		}
	    } while $second_pass && do {
		require URPM::Build;
		$urpm->{log}(N("performing second pass to compute dependencies\n"));
		$urpm->unresolved_provides_clean;
		$second_pass--;
	    };
	}
    }
    #- determine package to withdraw (from skip.list file) only if something should be withdrawn.
    unless ($options{noskipping}) {
	my %uniq;
	$urpm->compute_flags(
	    get_packages_list($urpm->{skiplist}, $options{skip}),
	    skip => 1,
	    callback => sub {
		my ($urpm, $pkg) = @_;
		$pkg->is_arch_compat && ! exists $uniq{$pkg->fullname} or return;
		$uniq{$pkg->fullname} = undef;
		$urpm->{log}(N("skipping package %s", scalar($pkg->fullname)));
	    },
	);
    }
    unless ($options{noinstalling}) {
	my %uniq;
	$urpm->compute_flags(
	    get_packages_list($urpm->{instlist}),
	    disable_obsolete => 1,
	    callback => sub {
		my ($urpm, $pkg) = @_;
		$pkg->is_arch_compat && ! exists $uniq{$pkg->fullname} or return;
		$uniq{$pkg->fullname} = undef;
		$urpm->{log}(N("would install instead of upgrade package %s", scalar($pkg->fullname)));
	    },
	);
    }
    if ($options{bug}) {
	#- and a dump of rpmdb itself as synthesis file.
	my $db = URPM::DB::open($options{root});
	my $sig_handler = sub { undef $db; exit 3 };
	local $SIG{INT} = $sig_handler;
	local $SIG{QUIT} = $sig_handler;

	$db or $urpm->{fatal}(9, N("unable to open rpmdb"));
	open my $rpmdb, "| " . ($ENV{LD_LOADER} || '') . " gzip -9 >'$options{bug}/rpmdb.cz'"
	    or $urpm->syserror("Can't fork", "gzip");
	$db->traverse(sub {
			  my ($p) = @_;
			  #- this is not right but may be enough.
			  my $files = join '@', grep { exists($urpm->{provides}{$_}) } $p->files;
			  $p->pack_header;
			  $p->build_info(fileno $rpmdb, $files);
		      });
	close $rpmdb;
    }
}

#- add a new medium, sync the config file accordingly.
#- returns the new medium's name. (might be different from the requested
#- name if index_name was specified)
sub add_medium {
    my ($urpm, $name, $url, $with_hdlist, %options) = @_;

    #- make sure configuration has been read.
    $urpm->{media} or $urpm->read_config;
    $options{nolock} or $urpm->exlock_urpmi_db;

    #- if a medium with that name has already been found, we have to exit now
    my $medium;
    if (defined $options{index_name}) {
	my $i = $options{index_name};
	do {
	    ++$i;
	    undef $medium;
	    foreach (@{$urpm->{media}}) {
		$_->{name} eq $name . $i and $medium = $_;
	    }
	} while $medium;
	$name .= $i;
    } else {
	foreach (@{$urpm->{media}}) {
	    $_->{name} eq $name and $medium = $_;
	}
    }
    $medium and $urpm->{fatal}(5, N("medium \"%s\" already exists", $medium->{name}));

    $url =~ s,/*$,,; #- clear URLs for trailing /es.

    #- creating the medium info.
    $medium = { name => $name, url => $url, update => $options{update}, modified => 1, ignore => $options{ignore} };
    if ($options{virtual}) {
	$url =~ m!^(?:file:)?/! or $urpm->{fatal}(1, N("virtual medium needs to be local"));
	$medium->{virtual} = 1;
    } else {
	$medium->{hdlist} = "hdlist.$name.cz";
	$medium->{list} = "list.$name";
	#- check if the medium is using a local or a removable medium.
	$url =~ m!^(?:(removable[^:]*|file):/)?(/.*)! and $urpm->probe_removable_device($medium);
    }

    #- local media have priority, other are added at the end.
    if ($url =~ m!^(?:file:)?/!) {
	$medium->{priority} = 0.5;
    } else {
	$medium->{priority} = 1 + @{$urpm->{media}};
    }

    #- check whether a password is visible, if not, set clear_url.
    my $has_password = $url =~ m|([^:]*://[^/:\@]*:)[^/:\@]*(\@.*)|;
    $medium->{clear_url} = $url unless $has_password;

    $with_hdlist and $medium->{with_hdlist} = $with_hdlist;

    #- create an entry in media list.
    push @{$urpm->{media}}, $medium;

    $urpm->{log}(N("added medium %s", $name));

    #- we need to reload the config, since some string substitutions may have occured
    unless ($options{no_reload_config}) {
	$urpm->write_config;
	delete $urpm->{media};
	$urpm->read_config(nocheck_access => 1);
	#- Remember that the database has been modified and base files need to
	#- be updated. This will be done automatically by transferring the
	#- "modified" flag from medium to global.
	$_->{name} eq $name and $_->{modified} = 1 foreach @{$urpm->{media}};
	$urpm->{modified} = 1;
    }
    if ($has_password) {
	foreach (grep { $_->{name} eq $name } @{$urpm->{media}}) {
	    $_->{url} = $url;
	}
    }

    $options{nolock} or $urpm->unlock_urpmi_db;
    $name;
}

#- add distribution media, according to url given.
#- returns the list of names of added media.
#- options :
#- - limit_rate, compress : for downloading files
#- - initial_number : when adding several numbered media, start with this number
#- - probe_with : if eq 'synthesis', use synthesis instead of hdlists
#- - ask_media : callback to know whether each media should be added
#- other options are passed to add_medium()
sub add_distrib_media {
    my ($urpm, $name, $url, %options) = @_;

    #- make sure configuration has been read.
    # (Olivier Thauvin): Is this a workaround ?
    $urpm->{media} or $urpm->read_config;

    my $distribconf = MDV::Distribconf->new($url);

    if (my ($dir) = $url =~ m!^(?:removable[^:]*:/|file:/)?(/.*)!) {

	$urpm->try_mounting($url)
	    or $urpm->{error}(N("unable to access first installation medium")), return ();

    $distribconf->load() or $urpm->{error}(N("this url seems to not contains any distrib")), return ();

    } else {
	unlink "$urpm->{cachedir}/partial/media.cfg";

	$distribconf->settree('mandriva');

	eval {
	    $urpm->{log}(N("retrieving media.cfg file..."));
	    $urpm->{sync}(
		{
		    dir => "$urpm->{cachedir}/partial",
		    quiet => 1,
		    limit_rate => $options{limit_rate},
		    compress => $options{compress},
		    retry => $urpm->{options}{retry},
		    proxy => get_proxy(),
		},
		reduce_pathname($distribconf->getfullpath(undef, 'infodir') .'/media.cfg'),
	    );
	    $urpm->{log}(N("...retrieving done"));
	};
	$@ and $urpm->{error}(N("...retrieving failed: %s", $@));
	if (-e "$urpm->{cachedir}/partial/media.cfg") {
	    $distribconf->parse_mediacfg("$urpm->{cachedir}/partial/media.cfg")
		or $urpm->{error}(N("unable to parse media.cfg")), return();
	} else {
	    $urpm->{error}(N("unable to access first installation medium (no hdlists file found)"));
	    return ();
	}
    }

    #- cosmetic update of name if it contains spaces.
    $name =~ /\s/ and $name .= ' ';

    my @newnames;
    #- at this point, we have found a media.cfg file, so parse it
    #- and create all necessary media according to it.
    my $medium = $options{initial_number} || 1;
    my @media_list_toadd;

    foreach my $media ($distribconf->listmedia()) {
        my $skip = 0;
	# if one of those values is set, by default, we skip adding the media
	foreach (qw(suppl askmedia noauto)) {
	    $distribconf->getvalue($media, $_) and do {
		$skip = 1;
		last;
	    };
	}
        if ($options{ask_media}) {
            if ($options{ask_media}->(
                $distribconf->getvalue($media, 'name'),
                !$skip,
            )) {
                $skip = 0;
            } else {
                $skip = 1;
            }
        }
        $skip and next;

        my $media_name = $distribconf->getvalue($media, 'name') || '';

        push @newnames, $urpm->add_medium(
            $name ? "$media_name ($name$medium)" : $media_name,
            reduce_pathname($distribconf->getfullpath($media, 'path')),
            offset_pathname(
                $url,
                $distribconf->getpath($media, 'path')
	    ) . '/' . $distribconf->getpath($media,
                ($options{probe_with} eq 'synthesis' ? 'synthesis' : 'hdlist')
            ),
            index_name => $name ? undef : 0,
            no_reload_config => 1, #- no need to reload config each time, since we don't update the media
            %options,
        );
        ++$medium;
    }
	return @newnames;
}

sub select_media {
    my $urpm = shift;
    my $options = {};
    if (ref $_[0]) { $options = shift }
    my %media; @media{@_} = ();

    foreach (@{$urpm->{media}}) {
	if (exists($media{$_->{name}})) {
	    $media{$_->{name}} = 1; #- keep in mind this one has been selected.
	    #- select medium by setting the modified flag, do not check ignore.
	    $_->{modified} = 1;
	}
    }

    #- check if some arguments don't correspond to the medium name.
    #- in such case, try to find the unique medium (or list candidate
    #- media found).
    foreach (keys %media) {
	unless ($media{$_}) {
	    my $q = quotemeta;
	    my (@found, @foundi);
	    my $regex  = $options->{strict_match} ? qr/^$q$/  : qr/$q/;
	    my $regexi = $options->{strict_match} ? qr/^$q$/i : qr/$q/i;
	    foreach my $medium (@{$urpm->{media}}) {
		$medium->{name} =~ $regex  and push @found, $medium;
		$medium->{name} =~ $regexi and push @foundi, $medium;
	    }
	    if (@found == 1) {
		$found[0]{modified} = 1;
	    } elsif (@foundi == 1) {
		$foundi[0]{modified} = 1;
	    } elsif (@found == 0 && @foundi == 0) {
		$urpm->{error}(N("trying to select nonexistent medium \"%s\"", $_));
	    } else { #- several elements in found and/or foundi lists.
		$urpm->{log}(N("selecting multiple media: %s", join(", ", map { qq("$_->{name}") } (@found ? @found : @foundi))));
		#- changed behaviour to select all occurences by default.
		foreach (@found ? @found : @foundi) {
		    $_->{modified} = 1;
		}
	    }
	}
    }
}

sub remove_selected_media {
    my ($urpm) = @_;
    my @result;

    foreach (@{$urpm->{media}}) {
	if ($_->{modified}) {
	    $urpm->{log}(N("removing medium \"%s\"", $_->{name}));

	    #- mark to re-write configuration.
	    $urpm->{modified} = 1;

	    #- remove files associated with this medium.
	    foreach ($_->{hdlist}, $_->{list}, "synthesis.$_->{hdlist}", "descriptions.$_->{name}", "names.$_->{name}",
		     "$_->{name}.cache") {
		$_ and unlink "$urpm->{statedir}/$_";
	    }

	    #- remove proxy settings for this media
	    urpm::download::remove_proxy_media($_->{name});
	} else {
	    push @result, $_; #- not removed so keep it
	}
    }

    #- restore newer media list.
    $urpm->{media} = \@result;
}

#- return list of synthesis or hdlist reference to probe.
sub _probe_with_try_list {
    my ($suffix, $probe_with) = @_;
    my @probe = (
	"media_info/synthesis.hdlist.cz",
	"../media_info/synthesis.hdlist_$suffix.cz",
	"synthesis.hdlist.cz",
    );
    my @probe_hdlist = (
	"media_info/hdlist.cz",
	"../media_info/hdlist_$suffix.cz",
	"hdlist.cz",
    );
    if ($probe_with =~ /synthesis/) {
	push @probe, @probe_hdlist;
    } else {
	unshift @probe, @probe_hdlist;
    }
    @probe;
}

#- read a reconfiguration file for urpmi, and reconfigure media accordingly
#- $rfile is the reconfiguration file (local), $name is the media name
sub reconfig_urpmi {
    my ($urpm, $rfile, $name) = @_;
    my @replacements;
    my @reconfigurable = qw(url with_hdlist clear_url);
    my $reconfigured = 0;
    my $fh = $urpm->open_safe("<", $rfile) or return undef;
    $urpm->{log}(N("reconfiguring urpmi for media \"%s\"", $name));
    #- the first line of reconfig.urpmi must be magic, to be sure it's not an error file
    my $magic = <$fh>;
    $magic =~ /^# this is an urpmi reconfiguration file/ or return undef;
    local $_;
    while (<$fh>) {
	chomp;
	s/^\s*//; s/#.*$//; s/\s*$//;
	$_ or next;
	my ($p, $r, $f) = split /\s+/, $_, 3;
	$f ||= 1;
	push @replacements, [ quotemeta $p, $r, $f ];
    }
  MEDIA:
    foreach my $medium (grep { $_->{name} eq $name } @{$urpm->{media}}) {
        my %orig = map { $_ => $medium->{$_} } @reconfigurable;
      URLS:
	foreach my $k (@reconfigurable) {
	    foreach my $r (@replacements) {
		if ($medium->{$k} =~ s/$r->[0]/$r->[1]/) {
		    $reconfigured = 1;
		    #- Flags stolen from mod_rewrite: L(ast), N(ext)
		    last if $r->[2] =~ /L/;
		    redo URLS if $r->[2] =~ /N/;
		}
	    }
	    #- check that the new url exists before committing changes (local mirrors)
	    if ($medium->{$k} =~ m!^(?:file:/*)?(/[^/].*[^/])/*\Z! && !-e $1) {
		$medium->{$k} = $orig{$k} foreach @reconfigurable;
		$reconfigured = 0;
		$urpm->{log}(N("...reconfiguration failed"));
		last MEDIA;
	    }
	}
    }
    close $fh;
    if ($reconfigured) {
	$urpm->{log}(N("reconfiguration done"));
	$urpm->write_config;
    }
    $reconfigured;
}

sub _guess_hdlist_suffix {
    my ($dir) = @_;
    my ($suffix) = $dir =~ m!\bmedia/(\w+)/*\Z!;
    $suffix;
}

sub _guess_pubkey_name {
    my ($medium) = @_;
    return $medium->{with_hdlist} =~ /hdlist(.*?)(?:\.src)?\.cz2?$/ ? "pubkey$1" : 'pubkey';
}

#- Update the urpmi database w.r.t. the current configuration.
#- Takes care of modifications, and tries some tricks to bypass
#- the recomputation of base files.
#- Recognized options :
#-   all         : all medias are being rebuilt
#-   callback    : UI callback
#-   compress    : use compressed download (for rsync)
#-   forcekey    : force retrieval of pubkey
#-   force       : try to force rebuilding base files (1) or hdlist from rpm files (2)
#-   limit_rate  : download limit rate
#-   noclean     : keep old files in the header cache directory
#-   nolock      : don't lock the urpmi database
#-   nomd5sum    : don't verify MD5SUM of retrieved files
#-   nopubkey    : don't use rpm pubkeys
#-   norebuild   : don't try to rebuild hdlists from rpm headers
#-   probe_with  : probe synthesis or hdlist (or none)
#-   quiet       : download hdlists quietly
#-   ratio       : use this compression ratio (with gzip, default is 4)
sub update_media {
    my ($urpm, %options) = @_;
    my $clean_cache = !$options{noclean};
    my $second_pass;

    $urpm->{media} or return; # verify that configuration has been read

    my $nopubkey = $options{nopubkey} || $urpm->{options}{nopubkey};
    #- get gpg-pubkey signature.
    if (!$nopubkey) {
	$urpm->exlock_rpm_db;
	$urpm->{keys} or $urpm->parse_pubkeys(root => $urpm->{root});
    }
    #- lock database if allowed.
    $options{nolock} or $urpm->exlock_urpmi_db;

    #- examine each medium to see if one of them needs to be updated.
    #- if this is the case and if not forced, try to use a pre-calculated
    #- hdlist file, else build it from rpm files.
    $urpm->clean;

    my %media_redone;
  MEDIA:
    foreach my $medium (@{$urpm->{media}}) {
	$medium->{ignore} and next MEDIA;

	$options{forcekey} and delete $medium->{'key-ids'};

	#- we should create the associated synthesis file if it does not already exist...
	-e "$urpm->{statedir}/synthesis.$medium->{hdlist}" && -s _ > 32
	    or $medium->{modified_synthesis} = 1;

	#- if we're rebuilding all media, mark them as modified (except removable ones)
	$medium->{modified} ||= $options{all} && $medium->{url} !~ m!^removable://!;
	#- don't ever update static media
	$medium->{static} and $medium->{modified} = 0;

	unless ($medium->{modified}) {
	    #- the medium is not modified, but to compute dependencies,
	    #- we still need to read it and all synthesis will be written if
	    #- an unresolved provides is found.
	    #- to speed up the process, we only read the synthesis at the beginning.
	    delete @$medium{qw(start end)};
	    if ($medium->{virtual}) {
		my ($path) = $medium->{url} =~ m!^(?:file:)?/*(/[^/].*[^/])/*\Z!;
		if ($path) {
		    my $with_hdlist_file = "$path/$medium->{with_hdlist}";
		    if ($medium->{synthesis}) {
			$urpm->{log}(N("examining synthesis file [%s]", $with_hdlist_file));
			($medium->{start}, $medium->{end}) = $urpm->parse_synthesis($with_hdlist_file);
		    } else {
			$urpm->{log}(N("examining hdlist file [%s]", $with_hdlist_file));
			($medium->{start}, $medium->{end}) = $urpm->parse_hdlist($with_hdlist_file, packing => 1);
		    }
		} else {
		    $urpm->{error}(N("virtual medium \"%s\" is not local, medium ignored", $medium->{name}));
		    $_->{ignore} = 1;
		}
	    } else {
		$urpm->{log}(N("examining synthesis file [%s]", "$urpm->{statedir}/synthesis.$medium->{hdlist}"));
		($medium->{start}, $medium->{end}) = $urpm->parse_synthesis("$urpm->{statedir}/synthesis.$medium->{hdlist}");
		unless (defined $medium->{start} && defined $medium->{end}) {
		    $urpm->{log}(N("examining hdlist file [%s]", "$urpm->{statedir}/$medium->{hdlist}"));
		    ($medium->{start}, $medium->{end}) = $urpm->parse_hdlist("$urpm->{statedir}/$medium->{hdlist}", packing => 1);
		}
	    }
	    unless ($medium->{ignore}) {
		unless (defined $medium->{start} && defined $medium->{end}) {
		    #- this is almost a fatal error, ignore it by default?
		    $urpm->{error}(N("problem reading hdlist or synthesis file of medium \"%s\"", $medium->{name}));
		    $medium->{ignore} = 1;
		}
	    }
	    next;
	}

	#- list of rpm files for this medium, only available for local medium where
	#- the source hdlist is not used (use force).
	my ($prefix, $dir, $error, $retrieved_md5sum, @files);

	#- always delete a remaining list file or pubkey file in cache.
	foreach (qw(list pubkey)) {
	    unlink "$urpm->{cachedir}/partial/$_";
	}

	#- check if the medium is using a local or a removable medium.
	if (($prefix, $dir) = $medium->{url} =~ m!^(?:(removable[^:]*|file):/)?(/.*)!) {
	    $prefix ||= 'file';
	    #- check for a reconfig.urpmi file (if not already reconfigured)
	    if (!$media_redone{$medium->{name}} && !$medium->{noreconfigure}) {
		my $reconfig_urpmi = reduce_pathname("$dir/reconfig.urpmi");
		if (-s $reconfig_urpmi && $urpm->reconfig_urpmi($reconfig_urpmi, $medium->{name})) {
		    $media_redone{$medium->{name}} = 1;
		    redo MEDIA;
		}
	    }

	    #- try to figure a possible hdlist_path (or parent directory of searched directory).
	    #- this is used to probe for a possible hdlist file.
	    my $with_hdlist_dir = reduce_pathname($dir . ($medium->{with_hdlist} ? "/$medium->{with_hdlist}" : "/.."));

	    #- the directory given does not exist and may be accessible
	    #- by mounting some other directory. Try to figure it out and mount
	    #- everything that might be necessary.
	    -d $dir or $urpm->try_mounting(
		$options{force} < 2 && ($options{probe_with} || $medium->{with_hdlist})
		    ? $with_hdlist_dir : $dir,
		#- in case of an iso image, pass its name
		is_iso($medium->{removable}),
	    ) or $urpm->{error}(N("unable to access medium \"%s\",
this could happen if you mounted manually the directory when creating the medium.", $medium->{name})), next;

	    #- try to probe for possible with_hdlist parameter, unless
	    #- it is already defined (and valid).
	    if ($options{probe_with} && (!$medium->{with_hdlist} || ! -e "$dir/$medium->{with_hdlist}")) {
		foreach (_probe_with_try_list(_guess_hdlist_suffix($dir), $options{probe_with})) {
		    if (-e "$dir/$_" && -s _ > 32) {
			$medium->{with_hdlist} = $_;
			last;
		    }
		}
		#- redo...
		$with_hdlist_dir = reduce_pathname($dir . ($medium->{with_hdlist} ? "/$medium->{with_hdlist}" : "/.."));
	    }

	    if ($medium->{virtual}) {
		#- syncing a virtual medium is very simple, just try to read the file in order to
		#- determine its type, once a with_hdlist has been found (but is mandatory).
		if ($medium->{with_hdlist} && -e $with_hdlist_dir) {
		    delete @$medium{qw(start end)};
		    if ($medium->{synthesis}) {
			$urpm->{log}(N("examining synthesis file [%s]", $with_hdlist_dir));
			($medium->{start}, $medium->{end}) = $urpm->parse_synthesis($with_hdlist_dir);
			delete $medium->{modified};
			$medium->{synthesis} = 1;
			$urpm->{modified} = 1;
			unless (defined $medium->{start} && defined $medium->{end}) {
			    $urpm->{log}(N("examining hdlist file [%s]", $with_hdlist_dir));
			    ($medium->{start}, $medium->{end}) = $urpm->parse_hdlist($with_hdlist_dir, packing => 1);
			    delete @$medium{qw(modified synthesis)};
			    $urpm->{modified} = 1;
			}
		    } else {
			$urpm->{log}(N("examining hdlist file [%s]", $with_hdlist_dir));
			($medium->{start}, $medium->{end}) = $urpm->parse_hdlist($with_hdlist_dir, packing => 1);
			delete @$medium{qw(modified synthesis)};
			$urpm->{modified} = 1;
			unless (defined $medium->{start} && defined $medium->{end}) {
			    $urpm->{log}(N("examining synthesis file [%s]", $with_hdlist_dir));
			    ($medium->{start}, $medium->{end}) = $urpm->parse_synthesis($with_hdlist_dir);
			    delete $medium->{modified};
			    $medium->{synthesis} = 1;
			    $urpm->{modified} = 1;
			}
		    }
		    unless (defined $medium->{start} && defined $medium->{end}) {
			$urpm->{error}(N("problem reading hdlist or synthesis file of medium \"%s\"", $medium->{name}));
			$medium->{ignore} = 1;
		    }
		} else {
		    $urpm->{error}(N("virtual medium \"%s\" should have valid source hdlist or synthesis, medium ignored",
				     $medium->{name}));
		    $medium->{ignore} = 1;
		}
	    }
	    #- try to get the description if it has been found.
	    unlink "$urpm->{statedir}/descriptions.$medium->{name}";
	    my $description_file = "$dir/media_info/descriptions"; #- new default location
	    -e $description_file or $description_file = "$dir/../descriptions";
	    if (-e $description_file) {
		$urpm->{log}(N("copying description file of \"%s\"...", $medium->{name}));
		urpm::util::copy($description_file, "$urpm->{statedir}/descriptions.$medium->{name}")
		    ? $urpm->{log}(N("...copying done"))
		    : do { $urpm->{error}(N("...copying failed")); $medium->{ignore} = 1 };
		chown 0, 0, "$urpm->{statedir}/descriptions.$medium->{name}";
	    }

	    #- examine if a distant MD5SUM file is available.
	    #- this will only be done if $with_hdlist is not empty in order to use
	    #- an existing hdlist or synthesis file, and to check if download was good.
	    #- if no MD5SUM is available, do it as before...
	    #- we can assume at this point a basename is existing, but it needs
	    #- to be checked for being valid, nothing can be deduced if no MD5SUM
	    #- file is present.
	    my $basename = urpm::download::basename($with_hdlist_dir);

	    unless ($medium->{virtual}) {
		if ($medium->{with_hdlist}) {
		    if (!$options{nomd5sum} && -s reduce_pathname("$with_hdlist_dir/../MD5SUM") > 32) {
			recompute_local_md5sum($urpm, $medium, $options{force});
			if ($medium->{md5sum}) {
			    $retrieved_md5sum = parse_md5sum($urpm, reduce_pathname("$with_hdlist_dir/../MD5SUM"), $basename);
			    #- If an existing hdlist or synthesis file has the same md5sum, we assume
			    #- the files are the same.
			    #- If the local md5sum is the same as the distant md5sum, this means
			    #- that there is no need to download the hdlist or synthesis file again.
			    if (defined $retrieved_md5sum && $medium->{md5sum} eq $retrieved_md5sum) {
				unlink "$urpm->{cachedir}/partial/$basename";
				#- the medium is now considered not modified.
				$medium->{modified} = 0;
				#- XXX we could link the new hdlist to the old one.
				#- (However links need to be managed. see bug #12391.)
				#- as previously done, just read synthesis file here, this is enough.
				$urpm->{log}(N("examining synthesis file [%s]",
				    "$urpm->{statedir}/synthesis.$medium->{hdlist}"));
				($medium->{start}, $medium->{end}) =
				    $urpm->parse_synthesis("$urpm->{statedir}/synthesis.$medium->{hdlist}");
				unless (defined $medium->{start} && defined $medium->{end}) {
				    $urpm->{log}(N("examining hdlist file [%s]", "$urpm->{statedir}/$medium->{hdlist}"));
				    ($medium->{start}, $medium->{end}) =
					$urpm->parse_hdlist("$urpm->{statedir}/$medium->{hdlist}", packing => 1);
				    unless (defined $medium->{start} && defined $medium->{end}) {
					$urpm->{error}(N("problem reading hdlist or synthesis file of medium \"%s\"",
					    $medium->{name}));
					$medium->{ignore} = 1;
				    }
				}
			    }
			    $medium->{modified} or next MEDIA;
			}
		    }

		    #- if the source hdlist is present and we are not forcing using rpm files
		    if ($options{force} < 2 && -e $with_hdlist_dir) {
			unlink "$urpm->{cachedir}/partial/$medium->{hdlist}";
			$urpm->{log}(N("copying source hdlist (or synthesis) of \"%s\"...", $medium->{name}));
			$options{callback} and $options{callback}('copy', $medium->{name});
			if (urpm::util::copy($with_hdlist_dir, "$urpm->{cachedir}/partial/$medium->{hdlist}")) {
			    $options{callback} and $options{callback}('done', $medium->{name});
			    $urpm->{log}(N("...copying done"));
			    chown 0, 0, "$urpm->{cachedir}/partial/$medium->{hdlist}";
			} else {
			    $options{callback} and $options{callback}('failed', $medium->{name});
			    #- force error, reported afterwards
			    unlink "$urpm->{cachedir}/partial/$medium->{hdlist}";
			}
		    }

		    -e "$urpm->{cachedir}/partial/$medium->{hdlist}" && -s _ > 32 or
		      $error = 1, $urpm->{error}(N("copy of [%s] failed (file is suspiciously small)",
                                             "$urpm->{cachedir}/partial/$medium->{hdlist}"));

		    #- keep checking md5sum of file just copied ! (especially on nfs or removable device).
		    if (!$error && $retrieved_md5sum) {
			$urpm->{log}(N("computing md5sum of copied source hdlist (or synthesis)"));
			md5sum("$urpm->{cachedir}/partial/$medium->{hdlist}") eq $retrieved_md5sum or
			  $error = 1, $urpm->{error}(N("copy of [%s] failed (md5sum mismatch)", $with_hdlist_dir));
		    }

		    #- check if the files are equal... and no force copy...
		    if (!$error && !$options{force} && -e "$urpm->{statedir}/synthesis.$medium->{hdlist}") {
			my @sstat = stat "$urpm->{cachedir}/partial/$medium->{hdlist}";
			my @lstat = stat "$urpm->{statedir}/$medium->{hdlist}";
			if ($sstat[7] == $lstat[7] && $sstat[9] == $lstat[9]) {
			    #- the two files are considered equal here, the medium is so not modified.
			    $medium->{modified} = 0;
			    unlink "$urpm->{cachedir}/partial/$medium->{hdlist}";
			    #- as previously done, just read synthesis file here, this is enough, but only
			    #- if synthesis exists, else it needs to be recomputed.
			    $urpm->{log}(N("examining synthesis file [%s]", "$urpm->{statedir}/synthesis.$medium->{hdlist}"));
			    ($medium->{start}, $medium->{end}) =
				$urpm->parse_synthesis("$urpm->{statedir}/synthesis.$medium->{hdlist}");
			    unless (defined $medium->{start} && defined $medium->{end}) {
				$urpm->{log}(N("examining hdlist file [%s]", "$urpm->{statedir}/$medium->{hdlist}"));
				($medium->{start}, $medium->{end}) =
				    $urpm->parse_hdlist("$urpm->{statedir}/$medium->{hdlist}", packing => 1);
				unless (defined $medium->{start} && defined $medium->{end}) {
				    $urpm->{error}(N("problem reading synthesis file of medium \"%s\"", $medium->{name}));
				    $medium->{ignore} = 1;
				}
			    }
			    next MEDIA;
			}
		    }
		} else {
		    if ($urpm->{options}{norebuild}) {
			$urpm->{error}(N("unable to access hdlist file of \"%s\", medium ignored", $medium->{name}));
			$medium->{ignore} = 1;
		    } else {
			$options{force} < 2 and $options{force} = 2;
		    }
		}

		#- if copying hdlist has failed, try to build it directly.
		if ($error) {
		    if ($urpm->{options}{norebuild}) {
			$urpm->{error}(N("unable to access hdlist file of \"%s\", medium ignored", $_->{name}));
			$medium->{ignore} = 1;
		    } else {
			$options{force} < 2 and $options{force} = 2;
			#- clear error state now.
			$error = undef;
		    }
		}

		if ($options{force} < 2) {
		    #- examine if a local list file is available (always probed according to with_hdlist)
		    #- and check hdlist wasn't named very strangely...
		    if ($medium->{hdlist} ne 'list') {
			my $local_list = $medium->{with_hdlist} =~ /hd(list.*)\.cz2?$/ ? $1 : 'list';
			my $path_list = reduce_pathname("$with_hdlist_dir/../$local_list");
			-e $path_list or $path_list = "$dir/list";
			if (-e $path_list) {
			    urpm::util::copy($path_list, "$urpm->{cachedir}/partial/list")
				or do { $urpm->{error}(N("...copying failed")); $error = 1 };
			    chown 0, 0, "$urpm->{cachedir}/partial/list";
			}
		    }
		} else {
		    {
			my %f;
			File::Find::find(
			    {
				wanted => sub { -f $_ && /\.rpm$/ and $f{"$File::Find::dir/$_"} = 1 },
				follow_skip => 2,
				follow_fast => 1,
			    },
			    $dir,
			);
			push @files, keys %f;
		    }

		    #- check files contains something good!
		    if (@files > 0) {
			#- we need to rebuild from rpm files the hdlist.
			eval {
			    $urpm->{log}(N("reading rpm files from [%s]", $dir));
			    my @unresolved_before = grep {
				! defined $urpm->{provides}{$_};
			    } keys %{$urpm->{provides} || {}};
			    $medium->{start} = @{$urpm->{depslist}};
			    $medium->{headers} = [ $urpm->parse_rpms_build_headers(
				dir   => "$urpm->{cachedir}/headers",
				rpms  => \@files,
				clean => $clean_cache,
			    ) ];
			    $medium->{end} = $#{$urpm->{depslist}};
			    if ($medium->{start} > $medium->{end}) {
				#- an error occured (provided there are files in input.)
				delete $medium->{start};
				delete $medium->{end};
				$urpm->{fatal}(9, N("no rpms read"));
			    } else {
				#- make sure the headers will not be removed for another media.
				$clean_cache = 0;
				my @unresolved = grep {
				    ! defined $urpm->{provides}{$_};
				} keys %{$urpm->{provides} || {}};
				@unresolved_before == @unresolved or $second_pass = 1;
			    }
			};
			$@ and $error = 1, $urpm->{error}(N("unable to read rpm files from [%s]: %s", $dir, $@));
			$error and delete $medium->{headers}; #- do not propagate these.
			$error or delete $medium->{synthesis}; #- when building hdlist by ourself, drop synthesis property.
		    } else {
			$error = 1;
			$urpm->{error}(N("no rpm files found from [%s]", $dir));
			$medium->{ignore} = 1;
		    }
		}
	    }

	    #- examine if a local pubkey file is available.
	    if (!$nopubkey && $medium->{hdlist} ne 'pubkey' && !$medium->{'key-ids'}) {
		my $path_pubkey = reduce_pathname("$with_hdlist_dir/../" . _guess_pubkey_name($medium));
		-e $path_pubkey or $path_pubkey = "$dir/pubkey";
		if ($path_pubkey) {
		    urpm::util::copy($path_pubkey, "$urpm->{cachedir}/partial/pubkey")
			or do { $urpm->{error}(N("...copying failed")) };
		}
		chown 0, 0, "$urpm->{cachedir}/partial/pubkey";
	    }
	} else {
	    #- check for a reconfig.urpmi file (if not already reconfigured)
	    if (!$media_redone{$medium->{name}} && !$medium->{noreconfigure}) {
		my $reconfig_urpmi_url = "$medium->{url}/reconfig.urpmi";
		unlink(my $reconfig_urpmi = "$urpm->{cachedir}/partial/reconfig.urpmi");
		eval {
		    $urpm->{sync}(
			{
			    dir => "$urpm->{cachedir}/partial",
			    quiet => 1,
			    limit_rate => $options{limit_rate},
			    compress => $options{compress},
			    proxy => get_proxy($medium->{name}),
			    media => $medium->{name},
			    retry => $urpm->{options}{retry},
			},
			reduce_pathname("$medium->{url}/reconfig.urpmi"),
		    );
		};
		if (-s $reconfig_urpmi && $urpm->reconfig_urpmi($reconfig_urpmi, $medium->{name})) {
		    $media_redone{$medium->{name}} = 1, redo MEDIA unless $media_redone{$medium->{name}};
		}
		unlink $reconfig_urpmi;
	    }

	    my $basename;

	    #- try to get the description if it has been found.
	    unlink "$urpm->{cachedir}/partial/descriptions";
	    if (-e "$urpm->{statedir}/descriptions.$medium->{name}") {
		urpm::util::move("$urpm->{statedir}/descriptions.$medium->{name}", "$urpm->{cachedir}/partial/descriptions");
	    }
	    my $syncopts = {
		dir => "$urpm->{cachedir}/partial",
		quiet => 1,
		limit_rate => $options{limit_rate},
		compress => $options{compress},
		proxy => get_proxy($medium->{name}),
		retry => $urpm->{options}{retry},
		media => $medium->{name},
	    };
	    eval { $urpm->{sync}($syncopts, reduce_pathname("$medium->{url}/media_info/descriptions")) };
	    #- It is possible that the original fetch of the descriptions
	    #- failed, but the file still remains in partial/ because it was
	    #- moved from $urpm->{statedir} earlier. So we need to check if
	    #- the previous download failed.
	    if ($@ || (! -e "$urpm->{cachedir}/partial/descriptions")) {
		eval {
		    #- try older location
		    $urpm->{sync}($syncopts, reduce_pathname("$medium->{url}/../descriptions"));
		};
	    }
	    if (-e "$urpm->{cachedir}/partial/descriptions") {
		urpm::util::move("$urpm->{cachedir}/partial/descriptions", "$urpm->{statedir}/descriptions.$medium->{name}");
	    }

	    #- examine if a distant MD5SUM file is available.
	    #- this will only be done if $with_hdlist is not empty in order to use
	    #- an existing hdlist or synthesis file, and to check if download was good.
	    #- if no MD5SUM is available, do it as before...
	    if ($medium->{with_hdlist}) {
		#- we can assume at this point a basename is existing, but it needs
		#- to be checked for being valid, nothing can be deduced if no MD5SUM
		#- file is present.
		$basename = urpm::download::basename($medium->{with_hdlist});

		unlink "$urpm->{cachedir}/partial/MD5SUM";
		eval {
		    if (!$options{nomd5sum}) {
			$urpm->{sync}(
			    {
				dir => "$urpm->{cachedir}/partial",
				quiet => 1,
				limit_rate => $options{limit_rate},
				compress => $options{compress},
				proxy => get_proxy($medium->{name}),
				media => $medium->{name},
				retry => $urpm->{options}{retry},
			    },
			    reduce_pathname("$medium->{url}/$medium->{with_hdlist}/../MD5SUM"),
			);
		    }
		};
		if (!$@ && -e "$urpm->{cachedir}/partial/MD5SUM" && -s _ > 32) {
		    recompute_local_md5sum($urpm, $medium, $options{force} >= 2);
		    if ($medium->{md5sum}) {
			$retrieved_md5sum = parse_md5sum($urpm, "$urpm->{cachedir}/partial/MD5SUM", $basename);
			#- if an existing hdlist or synthesis file has the same md5sum, we assume the
			#- files are the same.
			#- if local md5sum is the same as distant md5sum, this means there is no need to
			#- download hdlist or synthesis file again.
			if (defined $retrieved_md5sum && $medium->{md5sum} eq $retrieved_md5sum) {
			    unlink "$urpm->{cachedir}/partial/$basename";
			    #- the medium is now considered not modified.
			    $medium->{modified} = 0;
			    #- XXX we could link the new hdlist to the old one.
			    #- (However links need to be managed. see bug #12391.)
			    #- as previously done, just read synthesis file here, this is enough.
			    $urpm->{log}(N("examining synthesis file [%s]", "$urpm->{statedir}/synthesis.$medium->{hdlist}"));
			    ($medium->{start}, $medium->{end}) =
				$urpm->parse_synthesis("$urpm->{statedir}/synthesis.$medium->{hdlist}");
			    unless (defined $medium->{start} && defined $medium->{end}) {
				$urpm->{log}(N("examining hdlist file [%s]", "$urpm->{statedir}/$medium->{hdlist}"));