source: soft/build_system/build_system/mkcd/tags/V4_0_6_1mdk/pm/Mkcd/Functions.pm @ 1

Last change on this file since 1 was 1, checked in by fasma, 12 years ago

Initial Import from Mandriva's soft revision 224062 and package revision 45733

File size: 79.7 KB
Line 
1#
2# Copyright (C) 2000,2001,2002,2003,2004 Mandrakesoft
3#
4# Author: Florent Villard <warly@mandraesoft.com>
5#
6# This program is free software; you can redistribute it and/or modify
7# it under the terms of the GNU General Public License as published by
8# the Free Software Foundation; either version 2, or (at your option)
9# any later version.
10#
11# This program is distributed in the hope that it will be useful,
12# but WITHOUT ANY WARRANTY; without even the implied warranty of
13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14# GNU General Public License for more details.
15#
16# You should have received a copy of the GNU General Public License
17# along with this program; if not, write to the Free Software
18# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19#
20# to prepare, create and burn iso images
21#
22
23package Mkcd::Functions;
24
25our $VERSION = '1.3.0';
26
27use strict;
28use File::Path;
29use MDK::Common qw(substInFile);
30use File::NCopy qw(copy);       
31use Mkcd::Tools qw(cpal du checkDiscs imageSize printDiscsFile config readBatchFile log_ convert_size compute_files_md5 fix_dir);
32use Mkcd::Package qw(mkcd_build_hdlist get_sorted_packages);
33
34=head1 NAME
35
36Functions - mkcd module
37
38=head1 SYNOPSYS
39
40    require Mkcd::Functions;
41
42=head1 DESCRIPTION
43
44<Mkcd::Functions> include the disc building standard functions.
45
46=head1 SEE ALSO
47
48mkcd
49
50=head1 COPYRIGHT
51
52Copyright (C) 2000,2001,2002,2003,2004 Mandrakesoft <warly@mandrakesoft.com>
53
54This program is free software; you can redistribute it and/or modify
55it under the terms of the GNU General Public License as published by
56the Free Software Foundation; either version 2, or (at your option)
57any later version.
58
59This program is distributed in the hope that it will be useful,
60but WITHOUT ANY WARRANTY; without even the implied warranty of
61MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
62GNU General Public License for more details.
63
64You should have received a copy of the GNU General Public License
65along with this program; if not, write to the Free Software
66Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
67
68=cut
69my (%functions, $config);
70
71# need to do it to have its address
72#my %functions = ();
73# [ function name, matching regexp, [arguments list (same as above)]]
74
75$functions{disc} = [ 
76    [ "", "disc", 5, "[options] <disc config number> <size> <serial> <longname> <label>", "disc configuration file parameters", 
77    sub { my ($cd, $name, $size, $serial, $longname, $label) = @_;
78        $size = convert_size($size);
79        log_("disc: disc $cd size $size\n", $config->{verbose}, $config->{LOG},3);
80        $config->{disc}[$cd]{size} = $size;
81        $config->{disc}[$cd]{serial} = substr $serial, 0, 128;
82        $config->{disc}[$cd]{longname} = $longname;
83        $config->{disc}[$cd]{label} = substr $label, 0, 32;
84        if (!$config->{disc}[$cd]{appname}) { $config->{disc}[$cd]{appname} = substr $longname, 0, 128 }
85        1
86    }, "Setting disc configuration" ],
87    [ "d", "discnumber", 1 , "<disc real number>", "Set the real disc number", 
88    sub { my ($cd, $discnb) = @_;
89        log_("disc: disc $cd setting real disc number to $discnb\n", $config->{verbose}, $config->{LOG},3);
90        $config->{disc}[$cd]{name} = $discnb;
91    }, "Setting the real disc number" ],
92    [ "p", "publisher", 1 , "<disc publisher id>", "Set the disc publisher", 
93    sub { my ($cd, $publisher) = @_;
94        log_("disc: disc $cd setting publisher as $publisher\n", $config->{verbose}, $config->{LOG},3);
95        $config->{disc}[$cd]{Publisher} = substr $publisher, 0, 128;
96    }, "Setting the publisher ID flag" ]
97];
98
99$functions{list} = [ 
100    [ "", "list", -1, "[options] <list config number> <list config file 1> <list config file 2> ... <list config file n>", "list configuration file parameters", 
101    sub { 
102        my ($list, undef, @list_file) = @_;
103        log_("list: list $list file list @list_file\n", $config->{verbose}, $config->{LOG},3);
104        push @{$config->{list}[$list]{filelist}}, @list_file;
105        1
106    }, "Setting list configuration" ],
107    [ "k", "key", 1 , "<pubkey file>", "Select public key file associated with this list", 
108    sub { my ($list, $keyfile) = @_;
109        log_("list: list $list setting pubkey file $keyfile\n", $config->{verbose}, $config->{LOG},3);
110        push @{$config->{list}[$list]{keyfiles}}, $keyfile;
111        1
112    }, "Setting pubkey file" ],
113];
114
115$functions{rpmlist} = [ 
116   [ "", "rpmlist", 0, "[options]", "rpm list associated with a list", 
117   sub { 
118       my ($list) = @_;
119       push @{$config->{list}[$list]{packages}}, { };
120       log_("rpmlist: main\n", $config->{verbose}, $config->{LOG}, 1);
121       $config->{list}[$list]{arg}{update} = 0;
122       1 
123   }, "Setting rpm list" ],
124   [ "b", "binaries", -1, "<rpm path 1> <rpm path 2> ... <rpm path n>", "rpm list associated with a list", 
125   sub { 
126       my ($list, undef, @rpms) = @_;
127       my $idx = $#{$config->{list}[$list]{packages}};
128       push @{$config->{list}[$list]{packages}[$idx]{rpm}}, @rpms;
129       log_("rpmlist: main (update $config->{list}[$list]{update})\n", $config->{verbose}, $config->{LOG}, 1);
130       if ($config->{list}[$list]{arg}{update}) {
131           foreach my $dir (@rpms) {
132               log_("rpmlist: adding for list $list update rep $dir\n", $config->{verbose}, $config->{LOG}, 1);
133               push @{$config->{list}[$list]{prelist}},  map { s/\.rpm//; [ $_, { regexp => 1 } ] } all $dir
134           }
135           push @{$config->{list}[$list]{prelist}},  [ "basesystem", { regexp => 1 } ]
136       }
137
138       1 
139   }, "Setting rpm list" ],
140   [ "d", "dynamic", -1, "<disc1/dir1> <disc2/dir2> ... <discn/dirn>", "dynamic rpm list based on disc generated by this config file", 
141   sub { 
142       my ($list, undef, @rpms) = @_;
143       foreach my $l (@rpms) {
144           my ($cd, $rep) = $l =~ m,(\d+)/(\S+), or do { log_("ERROR rpmlist: $l is not a valid <disc>/<rep> dynamic list definition\n", $config->{verbose}, $config->{LOG}, 1); next };
145           #$config->{list}[$list]{prelist} = [ [ ".*", { regexp => 1 } ] ];
146           push @{$config->{list}[$list]{virtual}}, { disc => $cd, repname => $rep };
147       }
148       1
149   }, "Setting dynamic rpm list" ],
150   [ "s", "sources", -1, "<source path 1> <source path 2> ... <source path n>", "rpm list associated with a list",
151   sub {
152       my ($list, undef, @srpms) = @_;
153       my $idx = $#{$config->{list}[$list]{packages}};
154       push @{$config->{list}[$list]{packages}[$idx]{srpm}}, @srpms;
155       1
156   }, "Setting source rpm list" ],
157   [ "u", "update", 0, "", "select all the rpm in these directories to be in the filelist",
158   sub {
159       my ($list, undef) = @_;
160       log_("rpmlist: update\n", $config->{verbose}, $config->{LOG}, 1);
161       $config->{list}[$list]{arg}{update} = 1;
162       1
163   }, "Setting update mode" ],
164
165];
166
167$functions{dir} =
168        [
169            #0
170            [ "", "dir",2, "<directory name> <directory location>", "Set directory name",
171            sub {       my ($cd, $fn, $repname, $reploc) = @_;
172                my @a = ("dir", { repname => $repname, reploc => $reploc });
173                $config->{disc}[$cd]{function}{data}{dir}{$repname} and log_("WARNING: disc $cd: duplicate directory $repname ($reploc)\n", $config->{verbose}, $config->{LOG}, 3);
174                $config->{disc}[$cd]{function}{list}[$fn] = \@a;
175                $config->{disc}[$cd]{function}{data}{dir}{$repname} = \@a;
176                log_("dir: disc $cd rep $repname ($reploc)\n", $config->{verbose}, $config->{LOG}, 3);
177                push @{$config->{disc}[$cd]{steps}}, \@a;
178                1
179            }, "Setting directory" ],
180            # 1
181            [ "", "sep_arch", 0, "", "Create separate subdirs for each architecture", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{sep_arch} = 1 }, "Setting separate architecture flag for this dir" ]
182];
183#
184# generic options
185#
186# source => source dir
187#
188# done  => done
189#
190
191$functions{generic} =
192        [
193            # 0
194            ["", "generic", -2, "<directory name> <list1 name> <list2 name> ... <listn name>", "Copy rpms from one list or several lists to a directory. List is either a predefined list number of the configuration file or an other disc directory (e.g. 13/rpms2)",
195                sub {   
196                    my ($cd, $fn, $repname, @lists) = @_;
197                    $config->{disc}[$cd]{function}{data}{dir}{$repname} or log_("ERROR: disc $cd: $repname not defined\n", $config->{verbose}, $config->{LOG}, 0);
198                    my @a = ("generic", { repname => $repname });
199                    foreach my $list (@lists) {
200                        if ($list =~ /^\d+$/) {
201                            if (!$config->{list}[$list]) { log_("ERROR: lists $list does not exist, ignoring\n", $config->{verbose}, $config->{LOG}, 0); next }
202                            push @{$a[1]{lists}}, $list;
203                        } else {
204                            log_("ERROR generic: $list is not a valid list name for rep $cd/$repname\n", $config->{verbose}, $config->{LOG}, 0);
205                            next
206                        }
207                    }
208                    log_("generic: disc $cd repname $repname lists @lists\n", $config->{verbose}, $config->{LOG}, 3);
209                    if (!ref $a[1]{lists}) { log_("ERROR generic: $cd/$repname has no valid list, ignoring\n", $config->{verbose}, $config->{LOG}, 0); return }
210                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
211                    push @{$config->{disc}[$cd]{function}{data}{generic}{$repname}}, \@a;
212                    push @{$config->{disc}[$cd]{fastgeneric}}, \@a;
213                    push @{$config->{disc}[$cd]{steps}}, \@a;
214                    1
215                }, "Copying rpms to directory"],
216            # 1
217            ["s", "source", [
218            [ "", "source", 0, "", "Source mode configuration",
219                sub {   my ($tmp) = @_;
220                    $tmp->[0]{source} = 1;
221                }, "Source mode" ],
222# 2002 03 14 deprecated
223#           [ "p", "priority", 1, "<priority>", "Set the repository priority", sub { my ($tmp, $prio) = @_; $tmp->[0]{priority} = $prio}, "Setting source repository priority"]
224            ], "[options]", "Source mode setting",
225                sub { my ($cd, $fn, $options) = @_;
226                    foreach (keys %$options) { $config->{disc}[$cd]{function}{list}[$fn][1]{$_} = $options->{$_} }
227                    1
228                }, "Source mode option configuration"],
229            # 2
230            [ "", "synthesis", 0, "", "Add synthesis file in the repository", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{synthesis} = 1 }, "Setting synthesis tag" ],
231            # 3
232            [ "", "hdlist", 0, "", "Add hdlist file in the repository", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{hdlist} = 1 }, "Setting hdlist tag" ],
233            # 4
234            [ "l", "limit", [
235                [ "", "limit", 1, "<limit>", "Limit repository size",
236                    sub {       my ($tmp, $limit) = @_;
237                        $tmp->[0]{limit} = 1;
238                        $tmp->[0]{value} = $limit;
239                        1
240                    }, "Limit mode" ],
241                [ "s", "soft",0, "", "Soft mode, do not limit size if disc is not full", sub { my ($tmp) = @_; $tmp->[0]{soft} = 1 } , "Setting soft limit flag" ]
242           
243            ], "[options] <limit>", "Limit the space of this directory on the disc",
244                sub { my ($cd, $fn, $options) = @_;
245                    $config->{disc}[$cd]{function}{list}[$fn][1]{limit} = $options
246                }, "Setting limit option" ],
247            # 5
248            [ "", "nodeps", 0, "", "Do not include deps", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{nodeps} = 1 }, "Setting nodeps flag for this generic rep" ]
249        ];
250           
251           
252#
253# installation data
254#
255$functions{installation} =
256        [
257        # 0
258            [ "", "installation", 0, "", "Preparing the installation directory and dependencies files",
259                sub {   my ($cd, $fn) = @_;
260                    my @a = ('installation', { });
261                    if (ref $config->{disc}[$cd]{function}{data}{installation}) { log_("ERROR: disc $cd: duplicate installation procedure, ignored\n", $config->{verbose}, $config->{LOG}); return 0 };
262                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
263                    $config->{disc}[$cd]{function}{data}{installation} = \@a;
264                    push @{$config->{disc}[$cd]{steps}}, \@a;
265                    1
266                }, "Setting up installation files" ],
267    # 1
268            [ "b", "bootimg", 1, "<boot image>", "boot image for the cd", sub { my ($cd, $fn, $img) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{bootimg} = $img; 1 }, "Setting boot image" ],
269    # 2
270            [ "c", "compss", 1, "<compsUser file>", "Choose alternative compssUser file", sub { my ($cd, $fn, $compss) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{compssUsers} = $compss; 1 }, "Setting alternative compssUser file" ],
271    # 3
272            [ "f", "fixed", [
273                ["", "fixed", -1, "<repository> <extra RPMS directory 1> <extra RPMS directory 2> ... <extra RPMS directory n>", "Fixed repository option configuration",
274                    sub {       my ($tmp, @arg) = @_;
275                        $tmp->[0]{fixed} = 1;
276                        push @$tmp, @arg;
277                        1
278                    }, "Setting fixed option arguments"],
279                ["d", "dup", 0, "", "Duplicate mode, accept to put package present in already done discs",
280                        sub {
281                            my ($tmp) = @_;
282                            $tmp->[0]{dup} = 1; 1
283                        }, "Setting duplicate mode"],
284                ["", "noprovide", 0, "", "Do not handle other discs dependencies",
285                        sub {
286                            my ($tmp) = @_;
287                            $tmp->[0]{noprovide} = 1; 1
288                        }, "Setting noprovide mode"],
289                ["", "relocatable", 0, "", "Create virtual rep to save as much space as possible on updates discs",
290                        sub {
291                            my ($tmp) = @_;
292                            $tmp->[0]{relocatable} = 1; 1
293                        }, "Setting relocatable mode"],
294                ["", "update", 0, "", "Update mode, update already done packages",
295                        sub {
296                            my ($tmp) = @_;
297                            $tmp->[0]{update} = 1; 1 }, "Setting update mode"],
298                ["", "nodupkernel", 0, "", "Remove old kernel from hdlists",
299                        sub {
300                            my ($tmp) = @_;
301                            $tmp->[0]{nodupkernel} = 1; 1 }, "Setting nodupkernel mode"],
302                ], "[options] <fixed dir 1> <fixed dir 2> ... <fixed dir n>", "repositories that must not be computed but integrated in the installation group",
303                    sub { my ($cd, $fn, $options, @fixed) = @_;
304                        get_rpmsdir('rpmsdir', $cd, $fn, \@fixed, $options);
305                        $config->{disc}[$cd]{function}{list}[$fn][1]{fixed} = 1;
306                    1 }, "Setting fixed option" ],
307            # 4 
308            [ "l", "lang", 1, "<languages to include>", "languages that are conisdered by the install", sub { my ($cd, $fn, $lang) = @_; my @l = split ',', $lang; push @{$config->{disc}[$cd]{function}{list}[$fn][1]{lang}},  @l; 1 }, "Setting language supported" ],
309            # 5
310            [ "i", "installdir", 1, "<installation directory source>", "Installation directory source", sub { my ($cd, $fn, $dir) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{install} = $dir; 1 }, "Setting install source directory" ],
311            # 6
312            [ "", "nosources", 0, "", "Do not add source rpm for this installation group", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{nosources} = 1; 1 }, "Setting nosources tag for this installation group" ],
313            # 7
314            [ "", "nosrcfit", 0, "", "Do not stop if sources discs are full", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{nosrcfit} = 1; 1 }, "Setting nosourcefit tag for this installation group" ],
315            # 8
316            [ "o", "sortweight", 1, "<list of respective ordering weight (size,dependencies,rpmsrate)>", "Set the weight for automatic sorting rules", sub { my ($cd, $fn, $weight) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{score} = [split ',', $weight]; 1 }, "Setting sorting weights" ],
317            # 9
318            [ "r", "rpmsrate", 1, "<rpmsrate file>", "Choose alternative rpmsrate", sub { my ($cd, $fn, $rpmsrate) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{rpmsrate} = $rpmsrate }, "Setting alternative rpmsrate file" ],
319            # 10
320            [ "t", "tag name", 1, "<tag name>", "Tag added to the VERSION file", sub { my ($cd, $fn, $tag) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{tag} = $tag }, "Setting the tag name" ],
321            # 11
322            [ "", "dup", 0, "", "Authorize duplicate version for this install", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{dup} = 1 }, "Setting the tag name" ],
323            # 12
324            [ "", "nodeps", 0, "", "Do not include deps", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{nodeps} = 1 }, "Setting nodeps flag for this installation" ],
325            # 13
326            [ "", "isolinux", 0, "", "Isolinux mode", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{isolinux} = 1 }, "Build an isolinux install" ],
327            # 14
328            [ "", "synthesis", 0, "", "Add synthesis file in the repository", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{synthesis} = 1 }, "Setting synthesis tag" ],
329            # 15
330            [ "", "sequential", 0, "", "Build disc in a sequential way", sub { my ($cd, $fn) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{sequential} = 1 }, "Setting sequential tag" ],
331            # 16
332            # FIXME oem mode never tested nor debugged
333            [ "", "oem", [
334                ["", "oem", 1, "[options] <rpms dir>", "OEM mode configuration",
335                    sub {       my ($tmp, @arg) = @_;
336                        $tmp->[0]{oem} = 1;
337                        push @$tmp, @arg;
338                        1
339                    }, "Setting oem option arguments"],
340                ["d", "dir", -1, "<installation dir> <root dir 1> ... <root dir n>", "Create OEM disc based on existing directories list",
341                    sub {
342                        my ($tmp, $instdir, @dir) = @_;
343                        if ($tmp->[0]{file}) {
344                            log_("ERROR installation oem: could not use file and dir option in the same time, ignoring dir\n", $config->{verbose}, $config->{LOG});
345                            return 0 }
346                        log_("dir $instdir @dir\n", $config->{verbose}, $config->{LOG}, 3);
347                        $tmp->[0]{instdir} = $instdir;
348                        $tmp->[0]{dir} = \@dir;
349                        1 }, "Selecting directories"],
350                ["h", "hdlists", 1, "<hdlists to include>", "Select hdlists to include (all if omitted)", sub { my ($tmp, $hdlists) = @_; $tmp->[0]{hdlists} = $hdlists; 1 }, "Selecting hdlists to include"],
351                ["f", "file", 2, "<script file> <installation disc>", "Script file describing the discs (generated with printscript)",
352                    sub {
353                        my ($tmp, $file, $instdisc) = @_;
354                        if ($tmp->[0]{dir}) {
355                            log_("ERROR installation oem: could not use file and dir option in the same time, ignoring file\n", $config->{verbose}, $config->{LOG});
356                            return 0 }
357                        $tmp->[0]{file} = $file;
358                        $tmp->[0]{instdisc} = $instdisc; 1
359                    }, "Setting update mode"],
360                ["l", "listfile", 1, "<list of package to choose>", "Choose an alternative method to select package to select in OEM mode (default is to use packages with rate greater than 2 in rpmsrate ", sub { my ($tmp, $file) = @_; $tmp->[0]{file} = $file; 1 }, "Selecting list file"],
361                ["n", "norebuild", 0, "", "Do not rebuild hdlists", sub { my ($tmp, $file) = @_; $tmp->[0]{norebuild} = 1; 1 }, "Setting no rebuilding flag"],
362                ["r", "rpmsrate", 1, "<rpmsrate file>", "Rpmsrate file to use for OEM mode (use the installation one if omitted)", sub { my ($tmp, $rpmsrate) = @_; $tmp->[0]{rpmsrate} = $rpmsrate; 1 }, "Setting rpmsrate file OEM file"]
363                ], "[options] <rpms dir>", "OEM mode",
364                    sub { my ($cd, $fn, $options, $rpmsdir) = @_;
365                    $config->{disc}[$cd]{function}{list}[$fn][1]{oem}{oem} = 1;
366                    $config->{disc}[$cd]{function}{list}[$fn][1]{oem} = $options;
367                    if ($options->{dir}) {
368                        my $list = @{$config->{list}};
369                        $config->{list}[$list]{prelist} = [
370                                [ "INSTALL", { section => 1, force => 1 } ],
371                                [ "SERVER", { section => 1, regexp => 1, exclude => 1 } ],
372                                [ ".*", { section => 4, regexp => 1 } ]
373                                        ];
374                        log_("installation oem: adding list $list for OEM mode\n", $config->{verbose}, $config->{LOG}, 3);
375                        my $struct_v = $config->{struct_version};
376                        my $install_dir = $config->{struct}{$struct_v}{media_info};
377                        my $hdlists = "$options->{instdir}/$install_dir/hdlists";
378                        local *A; open A, $hdlists or die "ERROR oem: could not open hdlists $hdlists file";
379                        my $i;
380                        while (<A>) {
381                            my ($hdlist, $rep, $mname) = /(\S+)\s+(\S+)\s+(.*)/ or next;
382                            log_("$i -- $hdlist -- $rep -- $options->{dir}[$i]\n", $config->{verbose}, $config->{LOG}, 4);
383                            $options->{dir}[$i] or last;
384                            push @{$options->{hdlist}}, [ "$options->{instdir}/$install_dir/", $hdlist, $rep, $mname ];
385                            push @{$config->{list}[$list]{packages}}, [ { rpm => [ "$options->{dir}[$i]/$rep" ] } ];
386                            $i++
387                        }
388                        for ($rpmsdir) {
389                            my ($cdrep, $repname) = m,^(\d+)/([^/]+)$,;
390                            my $gfn = @{$config->{disc}[$cdrep]{function}{list}};
391                            log_("installation oem: adding function $gfn for generic oem packages on cd $cdrep\n", $config->{verbose}, $config->{LOG}, 4);
392                            $functions{generic}[0][5]($cdrep, $gfn, $repname, $list);
393                            if ($cd == $cdrep) {
394                                # FIXME trick to have this generic function done before the installation
395                                my $a = pop @{$config->{disc}[$cdrep]{steps}};
396                                unshift @{$config->{disc}[$cdrep]{steps}}, $a
397                            }
398                            push @{$config->{disc}[$cd]{function}{list}[$fn][1]{rpmsdir}}, [ $list, $cdrep, $repname, { oem => 1 } ];
399                        }
400                    } elsif ($options->{file}) {
401                        my $oemconfig;
402                        config($options->{file}, $oemconfig, \%functions);
403                        my ($discsFiles) = readBatchFile($options->{file}) or do { log_("ERROR installation oem: cannot read script file $options->{file}\n", $config->{verbose}, $config->{LOG}); return 0 };
404                        my $list = @{$config->{list}};
405                        log_("installation oem: adding list $list for OEM mode\n", $config->{verbose}, $config->{LOG}, 3);
406                        foreach (@{$config->{list}}) {
407                            $_ or next;
408                            push @{$config->{list}[$list]{packages}}, @{$_->{packages}}
409                        }
410                        my $gfn = @{$config->{disc}[$cd]{function}{list}};
411                        $config->{list}[$list]{prelist} = [[ ".*", { section => 3, regexp => 1 } ]];
412                        log_("installation oem: adding function $gfn for generic oem packages\n", $config->{verbose}, $config->{LOG}, 3);
413                        $functions{generic}[0][5]($cd, $gfn, "rpms", $list);
414                    } else {
415                        log_("ERROR installation oem: no disc to build OEM on (either file or dir option are needed)\n", $config->{verbose}, $config->{LOG});
416                        $config->{disc}[$cd]{function}{list}[$fn][1]{oem} = 0;
417                        return 0
418                    }
419                    1 }, "Setting oem option" ],
420            # 17
421            [ "s", "sources", -1, "<srpms directory name 1> <srpms directory name 2> ... <srpms directory name n>", "Select the sources list where to put packages",
422                sub { my ($cd, $fn, @sources) = @_;
423                    get_rpmsdir('srpmsdir', $cd, $fn, \@sources);
424                    $config->{disc}[$cd]{function}{list}[$fn][1]{sources} = 1;
425                    1 }, "Setting fixed option" ],
426            # 18
427            [ "d", "rpmsdir", -1, "<rpms directory 1 cd/rpms directory 1 name/rpms directory 1 list> <rpms directory 2 cd/rpms directory 2 name/rpms directory 2 list> ... <rpms directory n cd/rpms directory n name/rpms directory n list>", "Select rpms dir to take into account",
428                sub {   my ($cd, $fn, @rpms) = @_;
429                    get_rpmsdir('rpmsdir', $cd, $fn, \@rpms);
430                    1
431                }, "Setting rpms dir" ],
432            # 19
433            [ "", "boot_medium", 1, "<boot medium number>", "select alternatives boot medium",
434                sub {   my ($cd, $fn, $nb) = @_;
435                    $config->{disc}[$cd]{function}{list}[$fn][1]{boot_medium} = $nb;
436                    1
437                }, "Setting rpms dir" ],
438            # 20
439            [ "", "suppl", 0, "", "ask for new media during installation",
440                sub {   my ($cd, $fn) = @_;
441                    $config->{disc}[$cd]{function}{list}[$fn][1]{suppl} = 1;
442                    1
443                }, "Setting the suppl switch in hdlists" ],
444            # 21
445            [ "", "suppl_cd", 0, "", "to create a extra packages disc",
446                sub {   my ($cd, $fn) = @_;
447                    $config->{disc}[$cd]{function}{list}[$fn][1]{suppl_cd} = 1;
448                    1
449                }, "Setting the suppl_cd for this disk" ],
450            # 22
451            [ "", "askmedia", 0, "", "to ask which media are configured during installation",
452                sub {   my ($cd, $fn) = @_;
453                    $config->{disc}[$cd]{function}{list}[$fn][1]{askmedia} = 1;
454                    1
455                }, "Setting the askmedia for this disk" ],
456        ];
457#
458#
459# advertising option
460#
461#    img
462#    lang (new advertising mode in 8.2 deprecates this option)
463#   
464
465$functions{advertising} =
466        [
467            [ "", "advertising", -1, "<picture 1> <picture 2> ... <picture n>", "Setting the advertising pictures used by the installation",
468                sub { my ($cd, $fn, @img) = @_;
469                    my @a = ('advertising', { img => \@img }); 
470                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
471                    push @{$config->{disc}[$cd]{function}{data}{advertising}}, \@a;
472                    push @{$config->{disc}[$cd]{steps}}, \@a
473                }, "Setting the advertising pictures" ],
474         [ "l", "lang", 1, "<language>", "Set the advertising picture language", sub { my ($cd, $fn, $lang) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{lang} = $lang; 1 }, "Setting the picture language" ]
475];
476
477#
478# cdcom data
479#
480#      dir
481#
482#      source
483#
484$functions{cdcom} =
485         [
486         #0
487            [ "", "cdcom", 2, "<directory name> <disc directory location>", "Commercial disc",
488                sub { my ($cd, $fn, $dir, $source, @list_files) = @_;
489                    my @a = ('cdcom', { dir => $dir, source => $source });
490                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
491                    push @{$config->{disc}[$cd]{function}{data}{cdcom}}, \@a;
492                    my $list = @{$config->{list}};
493                    $a[1]{list} = $list;
494                    my $struct_v = $config->{struct_version};
495                    my $media = $config->{struct}{$struct_v}{media};
496                    log_("cdcom: disc $cd adding list $list for $source/$media\n", $config->{verbose}, $config->{LOG}, 3);
497                    $config->{list}[$list]{packages} = [ { rpm => [ "$source/$media" ] } ];
498                    # $config->{list}[$list]{prelist} = [[ ".*", { regexp => 1 }]];
499                    $config->{list}[$list]{done} = 1;
500                    $config->{list}[$list]{nosize} = 1;
501                    push @{$config->{disc}[$cd]{fastgeneric}}, [ '', { repname => $dir , lists => [ $list ] } ];
502                    push @{$config->{disc}[$cd]{steps}}, \@a;
503                    1
504                }, "Configuring a commercial disc" ],
505        #1
506           [ "d", "dest", 1, "<destination on the disc>", "Select the destination directory on the disc", sub { my ($cd, $fn, $dest) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{dest} = $dest; 1 }, "Selecting destination directory" ],
507        #2
508           [ "k", "key", 1 , "<pubkey file>", "Select public key file associated with this list",
509           sub {
510               my ($cd, $fn, $keyfile) = @_;
511               my $list = $config->{disc}[$cd]{function}{list}[$fn][1]{list};
512               log_("cdcom: list $list setting pubkey file $keyfile\n", $config->{verbose}, $config->{LOG},3);
513               push @{$config->{list}[$list]{keyfiles}}, $keyfile;
514               1
515           }, "Setting pubkey file" ],
516         # 3
517            [ "", "synthesis", 0, "", "Add synthesis file in the repository",
518                sub {
519                    my ($cd, $fn) = @_;
520                    $config->{disc}[$cd]{function}{list}[$fn][1]{synthesis} = 1
521                }, "Setting synthesis tag" ],
522         # 4
523            [ "", "hdlist", 0, "", "Add hdlist file in the repository",
524                sub {
525                    my ($cd, $fn) = @_;
526                    $config->{disc}[$cd]{function}{list}[$fn][1]{hdlist} = 1
527                }, "Setting hdlist tag" ],
528];
529#
530# fixed
531#
532$functions{fixed} =
533         [
534         #0
535            [ "", "fixed", -2, "<directory name> <disc directory location> <filter list 1> <filter list 2> ... <filter list n>", "Commercial disc",
536                sub { my ($cd, $fn, $dir, $source, @list_files) = @_;
537                    my @a = ('fixed', { dir => $dir, source => $source });
538                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
539                    push @{$config->{disc}[$cd]{function}{data}{fixed}}, \@a;
540                    my $list = @{$config->{list}};
541                    $a[1]{list} = $list;
542                    log_("fixed: disc $cd adding list $list for $source\n", $config->{verbose}, $config->{LOG}, 3);
543                    $config->{list}[$list]{packages} = [ { rpm => [ $source ] } ];
544                    # $config->{list}[$list]{prelist} = [[ ".*", { regexp => 1 }]];
545                    $config->{list}[$list]{pseudo_done} = 1;
546                    $config->{list}[$list]{nosize} = 1;
547                    push @{$config->{list}[$list]{filelist}}, @list_files;
548                    push @{$config->{disc}[$cd]{fastgeneric}}, [ '', { repname => $dir , lists => [ $list ] } ];
549                    push @{$config->{disc}[$cd]{steps}}, \@a;
550                    1
551                }, "Configuring a commercial disc" ],
552        #1
553           [ "d", "dest", 1, "<destination on the disc>", "Select the destination directory on the disc", sub { my ($cd, $fn, $dest) = @_; $config->{disc}[$cd]{function}{list}[$fn][1]{dest} = $dest; 1 }, "Selecting destination directory" ],
554        #2
555           [ "k", "key", 1 , "<pubkey file>", "Select public key file associated with this list",
556           sub {
557               my ($cd, $fn, $keyfile) = @_;
558               my $list = $config->{disc}[$cd]{function}{list}[$fn][1]{list};
559               log_("fixed: list $list setting pubkey file $keyfile\n", $config->{verbose}, $config->{LOG},3);
560               push @{$config->{list}[$list]{keyfiles}}, $keyfile;
561               1
562           }, "Setting pubkey file" ],
563         # 3
564            [ "", "synthesis", 0, "", "Add synthesis file in the repository",
565                sub {
566                    my ($cd, $fn) = @_;
567                    $config->{disc}[$cd]{function}{list}[$fn][1]{synthesis} = 1
568                }, "Setting synthesis tag" ],
569         # 4
570            [ "", "hdlist", 0, "", "Add hdlist file in the repository",
571                sub {
572                    my ($cd, $fn) = @_;
573                    $config->{disc}[$cd]{function}{list}[$fn][1]{hdlist} = 1
574                }, "Setting hdlist tag" ],
575];
576#
577# cp
578#
579$functions{cp} =
580        [
581            [ "", "cp", 2, "<file source> <file destination>", "Copy",
582                sub { my ($cd, $fn, $src, $dest) = @_;
583                    my @a = ('cp', { src => $src, dest => $dest });
584                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
585                    push @{$config->{disc}[$cd]{function}{data}{cp}}, \@a;
586                    push @{$config->{disc}[$cd]{steps}}, \@a;
587                    1
588        }, "Copying files" ],
589     # 1
590        [ "", "first", 0, "", "Remove files in the files copied with first option",
591            sub {
592                my ($cd, $fn) = @_;
593                $config->{disc}[$cd]{function}{list}[$fn][1]{first} = 1;
594                1
595            }, "Setting first flag"
596        ],
597];
598 #
599 # boot
600 #
601$functions{boot} =
602    [
603    # 0
604        [ "", "boot", 0, "<options> <files or dir to copy 1> <files or dir to copy 2> .. <files or dir to copy 3>", "Boot parameters and files",
605            sub {   my ($cd, $fn) = @_;
606                    my @a = ('boot', { });
607                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
608                    push @{$config->{disc}[$cd]{function}{data}{boot}}, \@a;
609                    push @{$config->{disc}[$cd]{steps}}, \@a;
610                    1
611          }, "Setting boot parameters"
612        ],
613          # 1
614        [ "", "isolinux", [
615                ["", "isolinux", 0, "", "Create an isolinux bootable disc",
616                    sub {       
617                        my ($tmp, @args) = @_;
618                        $tmp->[0]{isolinux} = 1;
619                        push @$tmp, @args
620                    }, "Setting an isolinux boot disc"],
621                ], "<options>", "isolinux boot disc",
622                    sub { my ($cd, $fn, $options) = @_;
623                        foreach (@{ $config->{disc}[$cd]{function}{data}{boot} }) {
624                                if (ref $_->[1]{isolinux}) { log_("ERROR: disc $cd: duplicate isolinux boot image, ignored\n", $config->{verbose}, $config->{LOG}); return 0 }
625                        }
626                        $config->{disc}[$cd]{function}{list}[$fn][1]{isolinux} = [ $options ]
627                    }, "Setting isolinux image"
628        ],
629          #2
630        [ "b", "bootimg", [
631            [ "", "bootimg", 1, "<boot image name>", "set boot image name",
632                    sub { my ($tmp, @args) = @_;
633                        $tmp->[0]{bootimg} = 1;
634                        push @$tmp, @args
635                    }, "setting boot image name"
636            ],
637            [ "d", "dir", 1, "<directory>", "duplicate the boot image in directory and put it first in the ISO",
638               sub { my ($tmp, $dir) = @_; $tmp->[0]{dir} = $dir }, "" 
639            ]
640                ], "<options> <boot image>", "Create a bootable iso with given image",
641                    sub { my ($cd, $fn, $options, $img) = @_;
642                        foreach (@{ $config->{disc}[$cd]{function}{data}{boot} }) {
643                                if (ref $_->[1]{bootimg}) { log_("ERROR: disc $cd: duplicate boot image, ignored\n", $config->{verbose}, $config->{LOG}); return 0 }
644                        }
645                        $config->{disc}[$cd]{function}{list}[$fn][1]{bootimg} = [ $img, $options ]
646                    }, "Setting boot image options"
647        ],
648          #3
649        [ "f", "files", [
650                [ "", "files", -1, "<file 1> <file 2> .. <file n>", "Set options for files copied",
651                    sub {
652                        my ($tmp, @args) = @_;
653                        $tmp->[0] = {};
654                        push @$tmp, @args
655                    }, "Setting files options" ],
656                [ "", "first", 0 , "", "Put this files first in the ISO",
657                        sub {
658                            my ($tmp) = @_;
659                            $tmp->[0]{first} = 1;
660                            1
661                        }, "Setting first flag for files" ],
662                [ "d", "dest", 1 , "<destination on the targe disc>", "Choose where to copy the files",
663                        sub {
664                            my ($tmp, $dest) = @_;
665                            $tmp->[0]{dest} = $dest;
666                            1
667                        }, "Setting destination location for files" ],
668            ], "[options] <files 1> <files 2> .. <files n>", "Setting files to copy",
669                sub { my ($cd, $fn, $options, @files) = @_;
670                    foreach (fix_dir(@files)) {
671                        log_("boot: file $_ (to $options->{dest})\n", $config->{verbose}, $config->{LOG});
672                        push @{$config->{disc}[$cd]{function}{list}[$fn][1]{files}}, [ $_, $options ]
673                    }
674                    1
675                },
676            "Setting files to copy"
677            ],
678        #4
679        [ "", "oem", 0, "", "Set default boot to oem mode",
680            sub { my ($cd, $fn) = @_;
681                $config->{disc}[$cd]{function}{list}[$fn][1]{oem} = 1
682            }, "Setting oem boot mode"
683        ],
684
685];
686
687#
688# clone
689#
690$functions{clone} =
691    [
692    # 0
693        [ "", "clone", 1, "<disc to clone>", "Clone the given disc",
694            sub {   my ($cd, $fn, $disc) = @_;
695                    my @a = ('clone', { disc => $disc });
696                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
697                    push @{$config->{disc}[$cd]{function}{data}{clone}}, \@a;
698                    push @{$config->{disc}[$cd]{steps}}, \@a;
699                    1
700          }, "Setting clone parameters"
701        ],
702          # 1
703        [ "i", "include", -2, "<directory name 1> <directory path 1> <directory name 2> <directory path 2> ... <directory name n> <directory path n>", "include declaration of copied directory",
704            sub {   my ($cd, $fn, @dir) = @_;
705                    my $list = @{$config->{list}};
706                    while (@dir) {
707                        my $rpmdir = shift @dir;
708                        my $path = shift @dir or last;
709                        $config->{disc}[$cd]{function}{data}{dir}{$rpmdir} = [ "clone_dir", { reploc => $path } ];
710                        $config->{disc}[$cd]{function}{list}[$fn][1]{rpmsdir} = $path;
711                        log_("clone: disc $cd adding list $list for virtual rep $rpmdir path $path\n", $config->{verbose}, $config->{LOG},3);
712                        $config->{list}[$list]{virtual} = [ { disc => $cd, repname => $rpmdir } ];
713                        push @{$config->{disc}[$cd]{fastgeneric}}, [ '', { repname => $rpmdir, lists => [ $list ] } ];
714                    }
715                    $config->{list}[$list]{done} = 1;
716                    1
717            }, "Setting directory name and path parameters"
718        ]
719#       [ "d", "delete", -1, "<function 1 nb to delete> <function 1 nb to delete> ... <function n nb to delete>", "delete these functions in the cloned disc",
720#           sub {   my ($cd, $fn,@to_del) = @_;
721#                   $config->{disc}[$cd]{function}{list}[$fn][1]{to_del} = \@to_del;
722#                   1
723#           }, "Setting delete parametes"
724#       ]
725];
726
727#
728# rm
729#
730$functions{rm} =
731    [
732     # 0
733        [ "", "rm", -1, "<disc to rm>", "Delete the given file or directory on the disc image",
734            sub {   my ($cd, $fn, @files) = @_;
735                    my @a = ('rm', { files => \@files });
736                    $config->{disc}[$cd]{function}{list}[$fn] = \@a;
737                    push @{$config->{disc}[$cd]{function}{data}{files}}, \@a;
738                    push @{$config->{disc}[$cd]{steps}}, \@a;
739                    1
740          }, "Setting rm parameters"
741        ],
742     # 1
743        [ "", "first", 0, "", "Remove files in the files copied with first option",
744            sub {
745                my ($cd, $fn) = @_;
746                $config->{disc}[$cd]{function}{list}[$fn][1]{first} = 1;
747                1
748            }, "Setting first flag"
749        ],
750];
751
752sub new {
753    my ($class, $conf) = @_;
754    $config = $conf;
755    bless {
756        config       => $conf,
757        functions    => \%functions
758    }, $class;
759}
760
761sub get_rpmsdir {
762    my ($type, $cd, $fn, $rpms, $opts) = @_;
763    my $options = '(?:(noauto):)?';
764    # FIXME taken from Tools.pm
765    my $match_val2 = q(((?:[^"\s]*(?:[^"\s]+|"[^\"]+")[^"\s]*)+));
766    foreach (@$rpms)  {
767        log_("get_rpmsdir: $_\n", $config->{verbose}, $config->{LOG}, 3);
768        my %options;
769        foreach (keys %$opts)  { $options{$_} = $opts->{$_} }
770        if (my ($opt, $hdlist, $hdlist_path, $hdlist_name, $pubkey) = m/${options}hdlist:([^,]+),([^,]+),$match_val2(?:,(.*))?/) {
771            if (!$config->{disc}[$cd]{function}{list}[$fn][1]{fixed}) {
772                $config->{disc}[$cd]{function}{list}[$fn][1]{fixed} = 1;
773                log_("WARNING get_rpmsdir: hdlist rpmsdir could only be fixed, forcing fixed flag\n", $config->{verbose}, $config->{LOG}, 0);
774            }
775            my $list = add_list($cd, "hdlist_rpm", $hdlist, $pubkey);
776            my $new_cd = @{$config->{disc}};
777            log_("get_rpmsdir: adding virtual disc $new_cd for hdlist $hdlist (path $hdlist_path disc_name $hdlist_name)\n", $config->{verbose}, $config->{LOG}, 3);
778            push @{$config->{virtual_disc}}, $new_cd;
779            $functions{disc}[0][5]->($new_cd, $hdlist_name, 0, 0, $hdlist_name, 0);
780            $functions{dir}[0][5]->($new_cd, 1, "rpms", $hdlist_path);
781            $functions{generic}[0][5]->($new_cd, 2, "rpms", $list);
782            $options{hdlist} = $hdlist;
783            foreach (split ',', $opt)  { $options{$_} = 1 }
784            push @{$config->{disc}[$cd]{function}{list}[$fn][1]{$type}}, [ $list, $new_cd, 'rpms', \%options ]
785        } elsif (my ($opt, $cdrep, $repname, $list) = m,$options(\d+)/([^/]+)(?:/(\d+))?,) {
786            foreach (split ',', $opt)  { $options{$_} = 1 }
787            push @{$config->{disc}[$cd]{function}{list}[$fn][1]{$type}}, [ $list, $cdrep, $repname, \%options ]
788        } else {
789            log_("ERROR get_rpmsdir: could not parse rpmsdir value $_\n", $config->{verbose}, $config->{LOG}, 0);
790        }
791    }
792}
793
794sub add_list {
795    my ($cd, $type, $pkg_list, $pubkey) = @_;
796    my $list = @{$config->{list}};
797    log_("add_list: disc $cd adding list $list for $type $pkg_list\n", $config->{verbose}, $config->{LOG}, 3);
798    $config->{list}[$list]{packages} = [ { $type => [ $pkg_list ] } ];
799    $config->{list}[$list]{done} = 1;
800    $config->{list}[$list]{nosize} = 1;
801    if ($pubkey) {
802        log_("add_list: adding pubkey file $pubkey for list $list\n", $config->{verbose}, $config->{LOG}, 3);
803        push @{$config->{list}[$list]{keyfiles}}, $pubkey;
804    }
805    $list
806}
807
808sub template {
809    my ($class, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFiles) = @_;
810    if (!$fixed) {
811        my $size;
812        if ($nolive) {
813            return $size
814        } else {
815
816        }
817    } elsif ($fixed == 1) {
818        my $mkiso;
819        if ($nolive) {
820        } else {
821           
822        }
823    } elsif ($fixed == 2) {
824        my $mkiso;
825        if ($nolive) {
826        } else {
827           
828        }
829    }   
830}
831
832sub clone {
833    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFiles) = @_;
834    my $graft = $totgraft->{$cdnum};
835    my $disc_src = $fct->[1]{disc};
836    if ($fixed == 0) {
837        if ($nolive) {
838            if ($fct->[1]{full_copy}) {
839                log_("clone: full copy of disc $disc_src nolive mode\n", $config->{verbose}, $config->{LOG},2);
840                if ($totgraft->{$disc_src}) {
841                    log_("clone: getting disc from current build\n", $config->{verbose}, $config->{LOG},3);
842                    $graft = $totgraft->{$disc_src}
843                } elsif (-d "$dir/$disc_src") {
844                    log_("clone: getting disc from filesystem\n", $config->{verbose}, $config->{LOG},3);
845                    $graft->{"/"}{"$dir/$disc_src"} = 1
846                } else {
847                    log_("ERROR clone: source disc not available\n", $config->{verbose}, $config->{LOG},3);
848                }
849            }
850        } else {
851            if ($fct->[1]{full_copy}) {
852                log_("clone: full copy of disc $disc_src\n", $config->{verbose}, $config->{LOG},2);
853                if (-d "$dir/$disc_src") {
854                    log_("clone: getting disc from filesystem\n", $config->{verbose}, $config->{LOG},3);
855                    $graft->{"/"}{"$dir/$disc_src"} = undef;
856                    cpal("$dir/$disc_src/", "$dir/$cdnum");
857                } else {
858                    log_("ERROR clone: source disc not available\n", $config->{verbose}, $config->{LOG},3);
859                }
860            }
861        }
862    }
863    1
864}
865
866sub rm {
867    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFiles) = @_;
868    my $graft = $totgraft->{$cdnum};
869    my $files = $fct->[1]{files};
870#    use File::Find;
871    if ($fixed == 0) {
872        if ($nolive) {
873            # FIXME this does not really works in no live mode (exclude files does not work with mkisofs properly)
874            my $size;
875            foreach my $r (@$files) {
876                log_("rm: trying $r\n", $config->{verbose}, $config->{LOG},2);
877                $r = "/$r" if $r !~ m,^/,;
878                #$graft->{$r} = 3;
879                $r =~ s/\*/.+/;
880                foreach my $g (keys %$graft) {
881                    ref $graft->{$g} or next;
882                    log_("rm: graft $g ($r)\n", $config->{verbose}, $config->{LOG},3);
883                    if ($g =~ m,^/?$r/?$,) {
884                        foreach my $f (keys %{$graft->{$g}}) {
885                             $size -= du $f
886                        }
887                        $g =~ m,^/, and $g = "/$g";
888                        $graft->{$g} = 0;
889                        log_("rm: deleting $g (size $size)\n", $config->{verbose}, $config->{LOG},4);
890                    }
891                }
892                my @up = grep { $_ } split '/', $r;
893                my $last = pop @up;
894                while (@up) {
895                    my $uppath = join '/', @up;
896                    $uppath = "/$uppath";
897                    log_("rm: testing $uppath\n", $config->{verbose}, $config->{LOG},4);
898                    $uppath = $graft->{$uppath} ? $uppath : $graft->{"/$uppath"} ? "/$uppath" : $graft->{"$uppath/"} ? "$uppath/" : "/$uppath/";
899                    log_("rm: graft $graft->{$uppath}\n", $config->{verbose}, $config->{LOG},4);
900                    if (ref $graft->{$uppath}) {
901                        foreach (keys %{$graft->{$uppath}}) {
902                            log_("rm: testing $uppath ($_)\n", $config->{verbose}, $config->{LOG},4);
903                            if (-d $_) {
904                                log_("rm: opening $_\n", $config->{verbose}, $config->{LOG},4);
905                                opendir my $dir, $_ or next;
906                                foreach my $first (readdir $dir) {
907                                    $first =~ /^\.{1,2}$/ and next;
908                                    log_("rm: FIRST 2 $first in $uppath$first ($r) " . $graft->{"$uppath$first"} . "\n", $config->{verbose}, $config->{LOG},4);
909                                    if ("$uppath$first" ne $r) {
910                                        log_("rm: adding $_/$first in $uppath\n", $config->{verbose}, $config->{LOG},4);
911                                        $graft->{"$uppath$first"} ||= {};
912                                        $graft->{"$uppath$first"}{"$_/$first"} = 1;
913                                    }
914                                }
915                                delete $graft->{$uppath}{$_}
916                            }
917                        }
918                        last
919                    }
920                    $last = pop @up;
921                }
922            }
923#           my @find;
924#           foreach my $k (keys %$graft){
925#               ref $graft->{$k} or next;
926#               foreach my $f (keys %{$graft->{$k}}){
927#                   $f =~ s|/{2,}|/|g;
928#                   find({ wanted => sub { s,/?\Q$f,,; $_ = "$k/$_"; s|/{2,}|/|g; push @find, [ $f, $_ ] }, no_chdir => 1 }, $f);
929#               }
930#           }
931#           foreach (@$files) { s|/{2,}|/|g }
932#           foreach my $t (@find){
933#               my ($k, $f) = @$t;
934#               foreach my $r (@$files){
935#                   next if $f =~ m,^/?$r/[^/]+,;
936#                   if ($f =~ m,^/?$r/?$,){
937#                       log_("rm: deleting $f (path $k regexp $r)\n", $config->{verbose}, $config->{LOG});
938#                       $graft->{$f} = 0;
939#                       $size -= du $k;
940#                       $size -= du "$k/$f";
941#                   }
942#               }
943#           }
944            return $size
945        } else {
946            my $first = "first/" if $fct->[1]{first};
947            foreach (@$files) {
948                my @file = glob "$dir/$first$cdnum/$_";
949                foreach my $f (@file) {
950                    if (-d $f) {
951                        log_("rm: deleting directory $f\n", $config->{verbose}, $config->{LOG}, 2);
952                        my $err = rmtree $f;
953                        if (!$err) { log_("ERROR rm: deleting $f failed: $!,\n", $config->{verbose}, $config->{LOG}) }
954                    } else {
955                        log_("rm: deleting file $f\n", $config->{verbose}, $config->{LOG},2);
956                        my $err = unlink $f;
957                        if (!$err) { log_("ERROR rm: deleting $f failed: $!,\n", $config->{verbose}, $config->{LOG}) }
958                    }
959                }
960            }
961            return 
962        }
963    }
964    1
965}
966
967sub cp {
968    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFiles, $sort) = @_;
969    my $graft = $totgraft->{$cdnum};
970    if (!$fixed) {
971        my $size;
972        my $source = $fct->[1]{src};
973        my $dest = $fct->[1]{dest};
974        if ($nolive) {
975            $size += du($source, $inode);
976            log_("cp: copying $source => $dest (size $size)\n", $config->{verbose}, $config->{LOG},1);
977            $graft->{"/$dest"}{$source} = 1;
978            return $size
979        } else {
980            my $first = "first/" if $fct->[1]{first};
981            cpal($source, "$dir/$first$cdnum/$dest");
982            $graft->{"$dir/$cdnum/$dest"}{$source} = 1;
983            push @{$sort->{$cdnum}}, [ "$dir/$first$cdnum/$dest" ] if $fct->[1]{first};
984            return
985        }
986    }
987}
988
989sub fixed {
990    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discs_file) = @_;
991    my $graft = $totgraft->{$cdnum};
992    my $destination = $fct->[1]{dest};
993    my ($fdest, $nocopy);
994    my $rep = $fct->[1]{dir}; 
995    my $dest_dir = $cd->{function}{data}{dir}{$rep}[1];
996    my $reploc = $dest_dir->{reploc};
997    my $reploc_full = "$dir/$cdnum/$reploc/";
998    if ($destination) {
999        $fdest = "$dir/$cdnum/$destination";
1000    } else {
1001        $fdest = "$dir/$cdnum/$reploc";
1002        $nocopy = 1
1003    }
1004    my $size;
1005    if (!$fixed) {
1006        my $source = $fct->[1]{source};
1007        my $uppath = $destination;
1008        $uppath =~ s,([^/]+),../,g;
1009        $uppath =~ s,/+,/,g;
1010        log_("DEST: $destination uppath $uppath dest $reploc_full\n", $config->{verbose}, $config->{LOG},3);
1011        -d $fdest or mkpath $fdest;
1012        if ($nolive) {
1013            -d $reploc_full or mkpath $reploc_full;
1014            opendir my $A, $source;
1015            log_("fixed: $source\n", $config->{verbose}, $config->{LOG},3);
1016            my $struct_v = $config->{struct_version};
1017            my $media = $config->{struct}{$struct_v}{media};
1018            my $install_dir = $config->{struct}{$struct_v}{install};
1019            foreach (readdir $A) {
1020                /^\.{1,2}$/ and next;
1021                if (! /^$install_dir$/) {
1022                    $size += du("$source/$_", $inode);
1023                    log_("fixed: adding $_ (size $size)\n", $config->{verbose}, $config->{LOG},4);
1024                    $graft->{"/$destination/$_/"}{"$source/$_"} = 1
1025                } else {
1026                    $graft->{"/$reploc/"}{"$source/$media/"} = 1
1027                }
1028            }
1029            log_("fixed: creating symlink $uppath$reploc => $fdest/RPMS\n", $config->{verbose}, $config->{LOG}, 4);
1030            my $err = symlink "$uppath$reploc", "$fdest/RPMS";                                           
1031            !$err and log_("ERROR fixed: $!\n", $config->{verbose}, $config->{LOG});
1032            $graft->{"/"}{"$fdest/RPMS"} = 1;
1033        } else {
1034            log_("fixed: copying $source to $fdest\n", $config->{verbose}, $config->{LOG});
1035            cpal($source, $fdest);
1036            if (!$nocopy) {
1037                log_("fixed: creating symlink $uppath$reploc => $fdest/RPMS\n", $config->{verbose}, $config->{LOG});
1038                my $err = symlink "$uppath$reploc", "$fdest/RPMS";                                           
1039                !$err and log_("ERROR fixed: $!\n", $config->{verbose}, $config->{LOG});
1040            }
1041        }
1042        return $size
1043    } else {
1044        # there is only one (virtual) list for fixed
1045        my $list = $fct->[1]{list};
1046        log_("fixed: list $list\n", $config->{verbose}, $config->{LOG});
1047        my $rep = $fct->[1]{dir}; 
1048        my $sep_arch = $dest_dir->{sep_arch};
1049        my $nolive_rep = $reploc;
1050        if ($nolive) {
1051            if (!$nocopy) {
1052                foreach my $src (keys %{$cdfile->[$cdnum]{$rep}{$list}}) {
1053                    log_("fixed: src $src\n", $config->{verbose}, $config->{LOG});
1054                    foreach (@{$cdfile->[$cdnum]{$rep}{$list}{$src}}) {
1055                        $graft->{"$nolive_rep/$_->[1]"}{"$src/$_->[1]"} = 1
1056                    }
1057                }
1058            }
1059        } else {
1060            if (!$nocopy) {
1061                foreach my $src (keys %{$cdfile->[$cdnum]{$rep}{$list}}) {
1062                    log_("fixed: src $src\n", $config->{verbose}, $config->{LOG});
1063                    foreach (@{$cdfile->[$cdnum]{$rep}{$list}{$src}}) {
1064                        link("$fdest/$_->[1]", "$reploc_full/$_->[1]") 
1065                    }
1066                }
1067            }
1068        }
1069        $size += process_hdlist_flags($nolive, $fct->[1]{synthesis}, $fct->[1]{hdlist}, $discs_file->[$cdnum]{$rep}{$list}, $dir, $cdnum, $fct, $rep, $reploc_full, $sep_arch, $graft, $list, $reploc);
1070        $size
1071    }
1072}
1073
1074sub cdcom {
1075    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discs_file) = @_;
1076    my $graft = $totgraft->{$cdnum};
1077    if (!$fixed) {
1078        my $size;
1079        my $source = $fct->[1]{source};
1080        my $dest = $config->{disc}[$cdnum]{function}{data}{dir}{$fct->[1]{dir}}[1]{reploc};
1081        my $destination = $fct->[1]{dest};
1082        my $uppath = $destination;
1083        $uppath =~ s,([^/]+),../,g;
1084        $uppath =~ s,/+,/,g;
1085        log_("DEST: $destination uppath $uppath dest $dest\n", $config->{verbose}, $config->{LOG},3);
1086        my $fdest = "$dir/$cdnum/$destination";
1087        my $struct_v = $config->{struct_version};
1088        my $media = $config->{struct}{$struct_v}{media};
1089        my $install_dir = $config->{struct}{$struct_v}{install};
1090        if ($nolive) {
1091            my $path = "$dir/$cdnum/$dest";
1092            -d $path or mkpath $path;
1093            opendir my $A, $source;
1094            log_("cdcom: $source\n", $config->{verbose}, $config->{LOG},3);
1095            foreach (readdir $A) {
1096                /^\.{1,2}$/ and next;
1097                if (! /^$install_dir$/) {
1098                    $size += du("$source/$_", $inode);
1099                    log_("cdcom: adding $_ (size $size)\n", $config->{verbose}, $config->{LOG},4);
1100                    $graft->{"/$destination/$_/"}{"$source/$_"} = 1
1101                } else {
1102                    $graft->{"/$dest/"}{"$source/$media/"} = 1
1103                }
1104            }
1105            #local *A; opendir A, "$source/Mandrake/RPMS";
1106            #foreach (readdir A){
1107            #    /^\.{1,2}$/ and next;
1108            #    my $newdest = readlink "$source/Mandrake/RPMS/$_";
1109            #    $newdest =~ s,((?:../))*(.*), $1/$destination/$2,;
1110            #    log_("cdcom: creating symlink $dest/$_ => $newdest\n", $config->{verbose}, $config->{LOG});
1111            #    my $err = symlink $newdest, "$dir/$cdnum/$dest/$_";
1112            #    !$err and log_("ERROR cdcom: $!\n", $config->{verbose}, $config->{LOG}) and next;
1113            #    $graft->{"/$dest/"}{"$dir/$cdnum/$dest/$_"} = 1
1114            #}
1115            #$graft->{"/$dest/"}{"$source/Mandrake/RPMS"} = 1;
1116            log_("cdcom: creating symlink $uppath$dest => $fdest/RPMS\n", $config->{verbose}, $config->{LOG}, 4);
1117            -d $fdest or mkpath $fdest;
1118            my $err = symlink "$uppath$dest", "$fdest/RPMS";                                           
1119            !$err and log_("ERROR cdcom: $!\n", $config->{verbose}, $config->{LOG});
1120            $graft->{"/"}{"$fdest/RPMS"} = 1;
1121            return $size
1122        } else {
1123            -f $fdest or mkpath $fdest;
1124            cpal($source, $fdest, $media);
1125            local *A; opendir A, "$source/$media";
1126            foreach (readdir A) {
1127                /^\.{1,2}$/ and next;
1128                my $newdest = readlink "$source/$media/$_";
1129                $newdest =~ s,((?:../)*)(.*),$1$destination/$2,;
1130                log_("cdcom: creating symlink $dir/$cdnum/$dest/$_ => $dir/$cdnum/$dest/$newdest\n", $config->{verbose}, $config->{LOG},2);
1131                my $err = link "$dir/$cdnum/$dest/$newdest", "$dir/$cdnum/$dest/$_";
1132                # should be OK with new du with inode checking
1133                #$size -= du("$dir/$cdnum/$dest/$newdest");
1134                !$err and log_("ERROR cdcom: $!\n", $config->{verbose}, $config->{LOG})
1135            }
1136            log_("cdcom: creating symlink $uppath$dest => $fdest/RPMS\n", $config->{verbose}, $config->{LOG});
1137            my $err = symlink "$uppath$dest", "$fdest/RPMS";                                           
1138            !$err and log_("ERROR cdcom: $!\n", $config->{verbose}, $config->{LOG});
1139               
1140            return $size
1141        }
1142        my $rep = $fct->[1]{dir}; 
1143        my $lists = $fct->[1]{lists};
1144        my $dest_dir = $cd->{function}{data}{dir}{$rep}[1];
1145        my $reploc = "$dir/$cdnum/$dest_dir->{reploc}/";
1146        my $sep_arch = $dest_dir->{sep_arch};
1147        foreach my $list (@$lists) {
1148            $size += process_hdlist_flags($nolive, $fct->[1]{synthesis}, $fct->[1]{hdlist}, $discs_file->[$cdnum]{$rep}{$list}, $dir, $cdnum, $fct, $rep, $reploc, $sep_arch, $graft, $list, $dest_dir->{reploc});
1149        }
1150        return $size
1151    }
1152}
1153
1154sub process_hdlist_flags {
1155    my ($nolive, $synthesis, $hdlist, $discs_files, $dir, $cdnum, $fct, $rep, $reploc, $sep_arch, $graft, $list, $nolive_rep) = @_;
1156    my $size;
1157    log_("process_hdlist_flags: synthesis $synthesis hdlist $hdlist disc $cdnum reploc $reploc\n", $config->{verbose}, $config->{LOG});
1158    my $media_hdlist = $config->{struct}{$config->{struct_version}}{media_hdlist};
1159    if ($nolive) {
1160        if ($synthesis || $hdlist) {
1161            if (ref $discs_files) {
1162                my (undef, $path) = buildGenericHdlist($dir, $cdnum, $fct, $rep, "$reploc/$media_hdlist", $discs_files, $sep_arch);
1163                if ($fct->[1]{hdlist})  {
1164                    $size += du("$reploc/$media_hdlist/hdlist.cz");
1165                    $graft->{"$nolive_rep/$media_hdlist/hdlist.cz"}{"$reploc/$media_hdlist/hdlist.cz"} = 1
1166                }
1167                if ($fct->[1]{synthesis}) {
1168                    $size += du("$reploc/$media_hdlist/synthesis.hdlist.cz");
1169                    $graft->{"$nolive_rep/$media_hdlist/synthesis.hdlist.cz"}{"$reploc/$media_hdlist/synthesis.hdlist.cz"} = 1
1170                }
1171            } else {
1172                log_("WARNING process_hdlist_flags: disc $cdnum rep $rep list $list is empty, no hdlist or synthesis created\n", $config->{verbose}, $config->{LOG});
1173            }
1174        }
1175    } else {
1176        if ($synthesis || $hdlist) {
1177            if (ref $discs_files) {
1178                buildGenericHdlist($dir, $cdnum, $fct, $rep, $reploc, $discs_files, $sep_arch);
1179            } else {
1180                log_("WARNING process_hdlist_flags: disc $cdnum rep $rep list $list is empty, no hdlist or synthesis created\n", $config->{verbose}, $config->{LOG});
1181            }
1182        }
1183    }
1184    $size
1185}
1186
1187sub printSize {
1188    my ($img, $file) = @_;
1189    local *A; open A, ">$file";
1190    my $size = imageSize($img);
1191    log_("printSize: creating $file for $img\n", $config->{verbose}, $config->{LOG});
1192    if ($size) {
1193        print A <<EOF
1194#!/usr/bin/perl
1195
1196\$width = $size->[0];
1197\$height = $size->[1];
1198\@data = ()
1199EOF
1200    } else {
1201        print "ERROR advertising: $size/n";
1202        return 0
1203    }
1204}
1205
1206sub advertising {
1207    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode) = @_;
1208    my $graft = $totgraft->{$cdnum};
1209    if (!$fixed) {
1210        my $size;
1211        my $struct_v = $config->{struct_version};
1212        my $extra = $config->{struct}{$struct_v}{extra};
1213        if ($nolive) {
1214            log_("Getting advertising images size\n", $config->{verbose}, $config->{LOG});
1215            my $addir = "$extra/advertising" . ($fct->[1]{lang} ? ".$fct->[1]{lang}" : "");
1216            my $rep = "$dir/$cdnum/$addir";
1217            -d $rep or mkpath $rep;
1218            local *L; open L, ">$rep/list";
1219            foreach (@{$fct->[1]{img}}) {
1220                s/\.png$//;
1221                my ($name) = m,([^/]*)$,;
1222                $size += du($_, $inode);
1223                print L "$name\n";
1224                if (-f "$_.png") { $graft->{"$addir/$name.png"}{"$_.png"} = 1 } else { next }
1225                if (-f "$_.pl") { $graft->{"$addir/$name.pl"}{"$_.pl"} = 1
1226                } else {
1227                    printSize("$_.png", "$rep/$name.pl");
1228                    $graft->{"$addir/$name.pl"}{"$_.pl"} = 1
1229                }
1230                -f "${_}_icon.png" and $graft->{"$addir/$name-icon.png"}{"${_}_icon.png"} = 1
1231            } 
1232            close L;
1233            $graft->{"$addir/list"}{"$rep/list"} = 1;
1234            $size += du("$rep/list");
1235            return $size
1236        } else {
1237            my $rep = "$dir/$cdnum/$extra/advertising" . ($fct->[1]{lang} ? ".$fct->[1]{lang}" : "");
1238            log_("Creating advertising images directory ($rep)\n", $config->{verbose}, $config->{LOG});
1239            -d $rep or mkpath $rep;
1240            local *L; open L, ">$rep/list";
1241            foreach (@{$fct->[1]{img}}) {
1242                s/\.png$//;
1243                my ($name) = m,([^/]*)$,;
1244                if (-f "$_.png") { cpal("$_.png", "$rep/$name.png") } else { next }
1245                if (-f "$_.pl") { cpal("$_.pl", "$rep/$name.pl") } else { printSize("$_.png", "$rep/$name.pl") }
1246                -f "${_}_icon.png" and cpal("${_}_icon.png", "$rep/${name}_icon.png");
1247                print L "$name.png\n"
1248            }
1249            close L;
1250            return
1251        }
1252    }
1253}
1254
1255sub dir {
1256    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd) = @_;
1257    if (!$fixed) {
1258        if ($nolive) {
1259            return 0
1260        } else {
1261            my $reploc = "$dir/$cdnum/$fct->[1]{reploc}";
1262            log_("dir: creating $reploc\n", $config->{verbose}, $config->{LOG});
1263            -d $reploc or mkpath $reploc;
1264            return 0   
1265        }
1266    }
1267}
1268
1269sub generic {
1270    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFile) = @_;
1271    my $graft = $totgraft->{$cdnum};
1272    my $size;
1273    my $rep = $fct->[1]{repname};
1274    my $dest_dir = $cd->{function}{data}{dir}{$rep}[1];
1275    my $nolive_rep = $dest_dir->{reploc};
1276    if ($fixed) {
1277        my $lists = $fct->[1]{lists};
1278        log_("generic: rep $rep\n", $config->{verbose}, $config->{LOG});
1279        my $reploc = "$dir/$cdnum/$dest_dir->{reploc}/";
1280        my $sep_arch = $dest_dir->{sep_arch};
1281        my %list;
1282        if ($sep_arch) {
1283            if (-f "$reploc/list") {
1284                open my $list_file, "$reploc/list";
1285                while (<$list_file>) {
1286                    chomp;
1287                    $list{$_} = 1
1288                }
1289            }
1290        }
1291        if ($nolive) {
1292            if ($fixed > 0) {
1293                foreach my $list (@$lists) {
1294                    log_("generic: list $list\n", $config->{verbose}, $config->{LOG});
1295                    foreach my $src (keys %{$cdfile->[$cdnum]{$rep}{$list}}) {
1296                        log_("generic: src $src\n", $config->{verbose}, $config->{LOG});
1297                        foreach (@{$cdfile->[$cdnum]{$rep}{$list}{$src}}) {
1298                            if ($_->[0] == 1) {
1299                                my $d = $nolive_rep;
1300                                if ($sep_arch) {
1301                                    $_->[1] =~ /([^.]+)\.rpm$/  or log_("WARNING generic: could not find arch of $_\n", $config->{verbose}, $config->{LOG});
1302                                    $d .= "/$1"
1303                                }
1304                                $graft->{"$d/$_->[1]"}{"$src/$_->[1]"} = 1
1305                            } elsif ($_->[0] == 2) {
1306                                my $d = $nolive_rep;
1307                                if ($sep_arch) {
1308                                    $_->[1] =~ /([^.]+)\.rpm$/  or log_("WARNING generic: could not find arch of $_\n", $config->{verbose}, $config->{LOG});
1309                                    $d .= "/$1"
1310                                }
1311                                delete $graft->{"$d/$_->[1]"}{"$src/$_->[1]"} 
1312                            }
1313                        }
1314                    }
1315                    $size += process_hdlist_flags($nolive, $fct->[1]{synthesis}, $fct->[1]{hdlist}, $discsFile->[$cdnum]{$rep}{$list}, $dir, $cdnum, $fct, $rep, $reploc, $sep_arch, $graft, $list, $nolive_rep);
1316                }
1317            }
1318            if ($sep_arch) {
1319                open my $list_file, ">$reploc/list";
1320                foreach (sort keys %list) { print $list_file "$_\n" if $list{$_} }
1321                close $list_file;
1322                $size += du("$dir/$cdnum/$reploc/list");
1323                $graft->{"$nolive_rep/list"}{"$reploc/list"} = 1
1324            }
1325            return $size
1326        } else {
1327            foreach my $list (@$lists) {
1328                log_("generic: list $list\n", $config->{verbose}, $config->{LOG});
1329                foreach my $src (keys %{$cdfile->[$cdnum]{$rep}{$list}}) {
1330                    log_("generic: src $src\n", $config->{verbose}, $config->{LOG});
1331                    foreach (@{$cdfile->[$cdnum]{$rep}{$list}{$src}}) {
1332                        if ($_->[0] == 1) {
1333                            my $d = $reploc;
1334                            if ($sep_arch) {
1335                                $_->[1] =~ /([^.]+)\.rpm$/ or log_("WARNING generic: could not find arch of $_\n", $config->{verbose}, $config->{LOG});
1336                                $d .= "/$1";
1337                                $list{"$1/$_->[1]"} = 1;
1338                                -d $d or mkdir $d;
1339                            }
1340                            cpal("$src/$_->[1]", $d)   
1341                        }  elsif ($_->[0] == 2) {
1342                            log_("generic: deleting $reploc/$_->[1]\n", $config->{verbose}, $config->{LOG});
1343                            my $d = $reploc;
1344                            if ($sep_arch) {
1345                                $_->[1] =~ /([^.]+)\.rpm$/ or log_("WARNING generic: could not find arch of $_\n", $config->{verbose}, $config->{LOG});
1346                                $list{"$1/$_->[1]"} = 0;
1347                                $d = "$reploc/$1";
1348                            }
1349                            unlink "$d/$_->[1]";
1350                        }
1351                    }
1352                }
1353                $size += process_hdlist_flags($nolive, $fct->[1]{synthesis}, $fct->[1]{hdlist}, $discsFile->[$cdnum]{$rep}{$list}, $dir, $cdnum, $fct, $rep, $reploc, $sep_arch, $graft, $list, $nolive_rep);
1354            }
1355            if ($sep_arch) {
1356                open my $list_file, ">$reploc/list";
1357                foreach (sort keys %list) { print $list_file "$_\n" if $list{$_} }
1358                close $list_file;
1359            }
1360            return 0
1361        }
1362       
1363    }
1364}
1365
1366sub printVERSION {
1367    my ($name, $file, $tag) = @_;
1368    open my $VERSION, ">$file";
1369    my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime(time());
1370    $year += 1900;
1371    printf $VERSION "Mandrakelinux $name $tag %04d%02d%02d $hour:%02d\n", $year, $mon+1, $mday, $min;
1372}
1373
1374sub buildGenericHdlist {
1375    my ($dir, $cdnum, $fct, $rep, $reploc, $discsFilescdrep, $sep_arch) = @_;
1376    my @rpm = map { "$discsFilescdrep->{$_}/$_.rpm" } keys %$discsFilescdrep;
1377   
1378    if ($fct->[1]{synthesis}) {
1379        -d $reploc or mkpath $reploc;
1380    }
1381    # $hdlist = "$reploc/hdlist$cdnum$rep.cz" if $fct->[1]{hdlist};
1382    # my $synthesis = "$reploc/synthesis.hdlist$cdnum$rep.cz" if $fct->[1]{synthesis};
1383    my $hdlist = "$reploc/hdlist.cz" if $fct->[1]{hdlist};
1384    my $synthesis = "$reploc/synthesis.hdlist.cz" if $fct->[1]{synthesis};
1385    my $urpm = mkcd_build_hdlist(1, [ 0, { hdlist => $hdlist, rpms => \@rpm , synthesis => $synthesis } ], "$config->{tmp}/.mkcd_build_hdlist");
1386    $urpm, $reploc
1387}
1388
1389sub buildInstallHdlist {
1390    my ($dir, $cdnum, $inst, $list, $discsFiles, $sort, $nolive) = @_;
1391    my (@hdlist, @hdlist_list);
1392    my $struct_v = $config->{struct_version};
1393    my $media_info = $config->{struct}{$struct_v}{media_info};
1394    -d "$dir/$cdnum/$media_info" or mkpath "$dir/$cdnum/$media_info";
1395    open my $HDLISTS, ">$dir/$cdnum/$media_info/hdlists";
1396    my (%rpmdone, %cd_rep);
1397    my %kerneldone;
1398    my $repnum = 1;
1399    my (@thisInstallRep, @check, @md5files);
1400    my $headers_dir = "$config->{tmp}/.mkcd_build_hdlist";
1401    my $path = "$dir/$cdnum/$media_info";
1402    my $suppl_cd = $inst->[1]{suppl_cd};
1403    my $suppl_postfix = 's' if $suppl_cd && $struct_v eq '10.0';
1404    log_("buildInstallHdlist: suppl_postfix is '$suppl_postfix' ($suppl_cd && $struct_v)\n", $config->{verbose}, $config->{LOG});
1405    foreach my $rd (@{$inst->[1]{tmp_rpmsdir}}) {
1406        my ($ls, $cdrep, $repname, $opts) = @$rd;
1407        log_("buildInstallHdlist: suppl_cd $suppl_cd cd $cdrep repname $repname fixed $opts->{fixed}\n", $config->{verbose}, $config->{LOG});
1408        next if $suppl_cd && $opts->{fixed};
1409        if (!$list->{$cdrep}) { log_("WARNING buildInstallHdlist: disc $cdrep not in list, ignoring\n", $config->{verbose}, $config->{LOG}); next }
1410        my $a = $discsFiles->[$cdrep]{$repname};
1411        if (!(ref($a) && %$a)) { log_("WARNING buildInstallHdlist: $cdrep/$repname is empty\n", $config->{verbose}, $config->{LOG}); next }
1412        my $realcd = $config->{disc}[$cdrep]{name};
1413        my $rpmdir = $config->{disc}[$cdrep]{function}{data}{dir}{$repname}[1]{reploc};
1414        $rpmdir .= "/%{ARCH}" if $config->{disc}[$cdrep]{function}{data}{dir}{$repname}[1]{sep_arch};
1415        if (!$rpmdir) { log_("ERROR buildInstallHdlist: disc $cdrep: $repname not defined\n", $config->{verbose}, $config->{LOG}); next }
1416        $hdlist[$repnum]{rpms} = [];
1417        if ($opts->{oem}) {
1418            log_("buildInstallHdlist: oem mode for $cdrep/$repname ($rpmdir)\n", $config->{verbose}, $config->{LOG});
1419            foreach (@{$inst->[1]{oem}{hdlist}}) {
1420                my ($oemdir, $hl, $rep, $name) = @$_;
1421                print $HDLISTS "noauto:" if $opts->{noauto};
1422                print $HDLISTS "$hl $rep $name\n";
1423                my $hdlist = "$path/$hl";
1424                log_("buildInstallHdlist: adding oem hdlist $hdlist from $dir\n", $config->{verbose}, $config->{LOG});
1425                if ($inst->[1]{oem}{norebuild}) {
1426                    cpal("$oemdir/$hl", $hdlist)
1427                }
1428                $hdlist[$repnum]{hdlist} = $hdlist;
1429                $hdlist_list[$repnum] = $hdlist;
1430                $hdlist[$repnum]{synthesis} = "$path/synthesis.$hl";
1431                push @md5files, ($hdlist, "$path/synthesis.$hl");
1432                $repnum++
1433            }
1434        } else {
1435            #
1436            # even for live sources rpm are taken, this may lead to errors in some special case, where
1437            # the sources change after the live is created, but this could help in combined live/nolive
1438            # situation
1439            #
1440            log_("installation: $cdrep - $repname - list $ls\n", $config->{verbose}, $config->{LOG});
1441            foreach my $list (keys %{$discsFiles->[$cdrep]{$repname}}) {
1442                next if $ls && $ls != $list;
1443                $thisInstallRep[$cdrep]{$repname}{$list} = $discsFiles->[$cdrep]{$repname}{$list};
1444                push @{$check[$repnum]}, [$cdrep, $repname, $list];
1445                log_("installation: list $list\n", $config->{verbose}, $config->{LOG});
1446                my $cdsfilesrpms = $discsFiles->[$cdrep]{$repname}{$list};
1447                my %localdone;
1448                my %localkerneldone;
1449                # FIXME taken from tools
1450                my $kernel_like = "((?:(?:NVIDIA_)?kernel.*)|NVIDIA_nforce.*|cm2020.*)";
1451                #
1452                log_("buildInstallHdlist: update ($opts->{update}) nodupkernel ($opts->{nodupkernel}) mode for $cdrep/$repname list $list\n", $config->{verbose}, $config->{LOG}, 3);
1453                push @{$hdlist[$repnum]{rpms}}, map {
1454                    if (/$kernel_like-[^.]+(?:\.[^.]+){3,5}mdk-[^-]+-[^-]+\.[^.]+$/) {
1455                        $kerneldone{$1} = 1;
1456                    }
1457                    if (/(.*)-[^-]+-[^-]+\.[^.]+$/) {
1458                        $rpmdone{$_} = 1;
1459                        $rpmdone{$1} = 1;
1460                        "$cdsfilesrpms->{$_}/$_.rpm" }
1461                    } grep {
1462                        if ($opts->{nodupkernel} && /($kernel_like-[^.]+(?:\.[^.]+){3,5}mdk)-[^-]+-[^-]+\.[^.]+$/) {
1463                            if ($localdone{$1} || $localkerneldone{$2}) { 0 }
1464                            else {
1465                                $localkerneldone{$2} = 1;
1466                                $localdone{$1} = 1;
1467                                ! ($kerneldone{$2} || $rpmdone{$_} || !$opts->{update} && $rpmdone{$1})
1468                            }
1469                        } elsif (/(.*)-[^-]+-[^-]+\.[^.]+$/) {
1470                            if ($localdone{$1}) { $inst->[1]{dup} }
1471                            else {
1472                                $localdone{$1} = 1;
1473                                $inst->[1]{dup} || ! ($rpmdone{$_} || !$opts->{update} && $rpmdone{$1})
1474                            } } } keys %$cdsfilesrpms;
1475                $hdlist[$repnum]{callback} = sub {
1476                       my ($urpm, $id) = @_;
1477                       my $pkg = $urpm->{depslist}[$id];
1478                       my $filename = $pkg->filename;
1479                       $urpm->{id}{$filename} = $id;
1480                       $pkg->pack_header
1481                   }
1482            }
1483            if (@{$hdlist[$repnum]{rpms}}) {
1484                print $HDLISTS "noauto:" if $opts->{noauto};
1485                my $num_name = $suppl_cd && $struct_v eq '10.0' ? "${repnum}s" : $repnum; 
1486                if ($realcd) {
1487                    print $HDLISTS "hdlist$repnum$suppl_postfix.cz $rpmdir disc $realcd $config->{disc}[$cdrep]{longname}\n";
1488                } else {
1489                    print $HDLISTS "hdlist$repnum$suppl_postfix.cz $rpmdir $config->{disc}[$cdrep]{longname}\n";
1490                }
1491                $cd_rep{$repnum} = [ $cdrep, $rpmdir ];
1492                my %keys;
1493                my $text;
1494                foreach my $list (keys %{$discsFiles->[$cdrep]{$repname}}) {
1495                    foreach my $keyfile (@{$config->{list}[$list]{keyfiles}}) {
1496                        if (-f $keyfile) {
1497                            log_("buildInstallHdlist: dumping $keyfile in $dir/$cdnum/$media_info/pubkey$repnum$suppl_postfix\n", $config->{verbose}, $config->{LOG}, 3);
1498                            open my $KF, $keyfile;
1499                            my $key;
1500                            while (<$KF>) {
1501                                $key .= $_;
1502                                if (/^-----END PGP PUBLIC KEY BLOCK-----/) {
1503                                    if (! $keys{$key}) {
1504                                        $keys{$key} = 1;
1505                                        $text .= $key
1506                                    }
1507                                    $key = ''
1508                                }
1509                            }
1510                            close $KF
1511                        } else { 
1512                            log_("ERROR buildInstallHdlist: $keyfile file does not exist\n", $config->{verbose}, $config->{LOG}, 0);
1513                        }
1514                    }
1515                }
1516                if ($text) {
1517                    open my $KEY, ">$dir/$cdnum/$media_info/pubkey$repnum$suppl_postfix";
1518                    print $KEY $text;
1519                    close $KEY;
1520                }
1521                $hdlist_list[$repnum] = "$path/hdlist$repnum$suppl_postfix.cz";
1522                $hdlist[$repnum]{hdlist} = $hdlist_list[$repnum];
1523                push @md5files, $hdlist_list[$repnum];
1524                if ($inst->[1]{synthesis}) { 
1525                    $hdlist[$repnum]{synthesis} = "$path/synthesis.hdlist$repnum$suppl_postfix.cz";
1526                    push @md5files, $hdlist[$repnum]{synthesis}
1527                }
1528                $repnum++
1529            } else {
1530                log_("WARNING installation: $cdrep $repname is empty, ignoring\n", $config->{verbose}, $config->{LOG});
1531            }
1532        }
1533    }
1534    # FIXME OEM mode not tested, moreover this norebuild test is wrong, new URPM need to rebuild hdlist.
1535    if (!$inst->[1]{oem}{norebuild}) {
1536        my $urpm = mkcd_build_hdlist($repnum - 1, \@hdlist, $headers_dir, "$path/depslist.ordered", "$path/provides", "$path/compss");
1537        get_sorted_packages($urpm, \@hdlist, $sort, \%cd_rep, "$dir/$cdnum", $nolive, $config->{verbose}, $config->{LOG});
1538    }
1539    log_("installation: compute_files_md5 @md5files\n", $config->{verbose}, $config->{LOG});
1540    compute_files_md5("$dir/$cdnum/$media_info/MD5SUM", \@md5files);
1541
1542    log_("installation: oem ($inst->[1]{oem})\n", $config->{verbose}, $config->{LOG});
1543    if (!$inst->[1]{oem}{oem}) {
1544        log_("installation: checkDiscs\n", $config->{verbose}, $config->{LOG});
1545        checkDiscs(\@hdlist_list, "$path/depslist.ordered", \@thisInstallRep, \@check, $config->{LOG}) or die "depslist.ordered, hdlists and RPMS mismatch\n";
1546    }
1547# Add sources
1548    foreach my $rd (@{$inst->[1]{srpmsdir}}) {
1549        my ($ls, $cdrep, $repname, $opts) = @$rd;
1550        if (!$list->{$cdrep}) { log_("WARNING buildInstallHdlist: disc $cdrep not in list, ignoring\n", $config->{verbose}, $config->{LOG}); next }
1551        foreach my $list (keys %{$discsFiles->[$cdrep]{$repname}}) {
1552            next if $ls && $ls == $list;
1553            $thisInstallRep[$cdrep]{$repname}{$list} = $discsFiles->[$cdrep]{$repname}{$list};
1554        }
1555    }
1556    if ($inst->[1]{suppl}) {
1557        print $HDLISTS "suppl\n"
1558    }
1559    if ($inst->[1]{askmedia}) {
1560        print $HDLISTS "askmedia\n"
1561    }
1562    my $pfile = "$dir/$cdnum/pkg-$config->{name}" . ($inst->[1]{tag} ? "-$inst->[1]{tag}" : "") . ".idx";
1563    printDiscsFile($config, \@thisInstallRep, $pfile);
1564    return $repnum, $path, $pfile, $suppl_postfix
1565}
1566
1567sub boot {
1568    my ($class, $fct, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFiles, $sort) = @_;
1569    my $graft = $totgraft->{$cdnum};
1570    my $isolinux = $fct->[1]{isolinux};
1571    my $bootimg = $fct->[1]{bootimg};
1572    log_("Boot: $fixed nolive $nolive\n", $config->{verbose}, $config->{LOG});
1573    my $struct_v = $config->{struct_version};
1574    my $isolinux_dir = $fct->[1]{isolinux_dir} || $config->{struct}{$struct_v}{isolinux};
1575    if (!$fixed) {
1576        my $size;
1577        my (@chunk_first, @chunk);
1578        if ($nolive) {
1579            my $mkiso;
1580            my $img;
1581            my $dir;
1582            my $path;
1583            if ($isolinux) {
1584                log_("boot: isolinux mode (bootimg $bootimg)\n", $config->{verbose}, $config->{LOG});
1585                my $img = $bootimg ? $bootimg->[0] : "$isolinux_dir/isolinux.bin"; 
1586                $mkiso = qq( -b $img -c $isolinux_dir/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table);
1587                $graft->{"$isolinux_dir/boot.cat"} = 0;
1588                $graft->{"$isolinux_dir/isolinux.bin"} = 0;
1589            } elsif ($bootimg) {
1590                log_("boot: el torito mode (bootimg $bootimg)\n", $config->{verbose}, $config->{LOG});
1591                $img = $bootimg->[0];
1592                $dir = $bootimg->[1]{dir};
1593                $img =~ s,(.*)/([^/]+)$,$2,;
1594                $dir or ($dir) = $1;
1595                $mkiso = qq( -b $dir/$img -c ${dir}/boot.cat);
1596                $graft->{"$dir/boot.cat"} = 0;
1597            }
1598            foreach (@{$fct->[1]{files}}) {
1599                my ($files, $opt) = @$_;
1600                my $dest = $opt->{dest};
1601                $size += du($files);
1602                my ($dirname) = $files =~ m,([^/]*)$,;
1603                log_("boot: files $files dest $dest dirname $dirname\n", $config->{verbose}, $config->{LOG});
1604                if ($img) { 
1605                    my $bimg = $bootimg->[0];
1606                    $bimg =~ s/^$dest\/$dirname//;
1607                    log_("boot: boot image $files/$bimg in $dir/$img (" . (stat "$files/$bimg")[7] . ")\n", $config->{verbose}, $config->{LOG});
1608                    if (-f "$files/$bimg") { 
1609                        if ((stat "$files/$bimg")[7] > 3000000) { 
1610                            $mkiso .= qq( -no-emul-boot)
1611                        }
1612                        # $mkiso .= qq( $dir/$img=$files/$bimg)
1613                        $graft->{"$dir/$img"}{"$files/$bimg"} = 1
1614                    }
1615                }
1616               
1617                # if (-d "$files") { $mkiso .= " $dest/$dirname/=$files"; next }
1618                # $mkiso .= " $dest/=$files";
1619                if (-d $files) { 
1620                    $graft->{"$dest/$dirname/"}{$files} = 1 
1621                } else { 
1622                    $graft->{"$dest/"}{$files} = 1 
1623                }
1624                $dest =~ s,/+,/,g;
1625                if ($opt->{first}) {
1626                    push @chunk_first, $dest
1627                } else {
1628                    unshift @chunk, $dest 
1629                }
1630                push @chunk_first, "$dir/boot.cat"
1631            }
1632            # it is = and not .= because mkcdisos->[$cdnum] has been added already at the beginning
1633            $mkisos->[$cdnum] = "$mkiso $mkisos->[$cdnum]";
1634        } else {
1635            log_("FILES $fct->[1]{files}\n", $config->{verbose}, $config->{LOG});
1636            foreach (@{$fct->[1]{files}}) {
1637                my ($files, $opt) = @$_;
1638                my $dest = "$config->{topdir}/build/$config->{name}/" . ($opt->{first} ? "first/" : "") . "$cdnum/";
1639                # FIXME first should ne obsolete, however it appears in several place, and the removal must be done with care
1640                -d $dest or mkpath $dest;
1641                my $odest = $opt->{dest};
1642                log_("boot: file $files (first $opt->{first} to $dest odest $odest)\n", $config->{verbose}, $config->{LOG});
1643                if ($odest) {
1644                    $dest .= "/$odest";
1645                    if ($odest =~ m,/$,) { mkpath $dest }
1646                } else {
1647                    my ($dirname) = $files =~ m,([^/]*)$,;
1648                    $dest .= "/$dirname"
1649                }
1650                $dest =~ s,/+,/,g;
1651                log_("boot: file $files (to $dest odest $odest)\n", $config->{verbose}, $config->{LOG});
1652                cpal($files, $dest, "(rr_moved|boot.cat)");
1653                if ($opt->{first}) {
1654                    push @chunk_first, $dest
1655                } else {
1656                    unshift @chunk, $dest 
1657                }
1658                push @chunk_first, "$dir/boot.cat"
1659            }
1660            if ($fct->[1]{oem}) {
1661                log_("boot: setting default boot to oem\n", $config->{verbose}, $config->{LOG});
1662                my $dest = "$config->{topdir}/build/$config->{name}/first/$cdnum/$isolinux_dir";
1663                -d $dest or mkpath $dest;
1664                my $old = "$dest/isolinux.cfg";
1665                my $new = "$dest/isolinux.cfg.new";
1666                copy $old, $new;
1667                unlink $old;
1668                link $new, $old;
1669                unlink $new;
1670                substInFile { s/default linux/default oem/ } $old
1671            }
1672            $graft->{"/"}{"$dir/first/$cdnum/"} = 1;
1673            $size = du("$dir/first/$cdnum/", $inode);
1674        }
1675        push @{$sort->{$cdnum}}, \@chunk_first;
1676        unshift @{$sort->{$cdnum}}, \@chunk;
1677        return $size
1678    } elsif ($fixed == 1) {
1679        if (!$nolive) {
1680            if ($isolinux) {
1681                my $dir = $isolinux->[0];
1682                my $img = $bootimg ? $bootimg->[0] : "$isolinux_dir/isolinux.bin"; 
1683                $mkisos->[$cdnum] .= qq( -b $img -c $isolinux_dir/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table "$config->{topdir}/build/$config->{name}/first/$cdnum");
1684                $graft->{"/$isolinux_dir/isolinux.bin"} = 0;
1685                $graft->{"$dir/boot.cat"} = 0
1686            } elsif ($bootimg) {
1687                my $img = $bootimg->[0];
1688                my $sdir = $bootimg->[1]{dir};
1689                $img =~ s,(.*/)([^/]+)$,$2,;
1690                $sdir or ($sdir) = $1;
1691                $sdir =~ s,//+,/,g;
1692                $sdir =~ s,/$,,g;
1693                log_("boot: boot image $sdir/$img\n", $config->{verbose}, $config->{LOG});
1694                $mkisos->[$cdnum] .= qq(-b $sdir/$img);
1695                my $cdimages = "$dir/$cdnum/";
1696                if ((stat "$cdimages/$bootimg->[0]")[7] > 3000000) { 
1697                    $mkisos->[$cdnum] .= qq( -no-emul-boot)
1698                }
1699                my $Bootdir;
1700                log_("boot: try to find boot image in $cdimages/$bootimg->[0] and $dir/first/$cdnum/$bootimg->[0]\n", $config->{verbose}, $config->{LOG});
1701                if (-f "$dir/$cdimages/$bootimg->[0]") {
1702                    $Bootdir = "$dir/$cdnum/$sdir/";
1703                } elsif (-f "$dir/first/$cdnum/$bootimg->[0]") {
1704                    $Bootdir = "$dir/first/$cdnum/$sdir/";
1705                } else {
1706                    die "FATAL boot: could not find boot image\n";
1707                }
1708                $Bootdir =~ s,//+,/,g;
1709                $Bootdir =~ s,/$,,g;
1710                if (! -f "$Bootdir/$img") {
1711                    if (! -d $Bootdir) { mkpath $Bootdir or die "cannot create $Bootdir\n" }
1712                    my $err = link "$cdimages/$bootimg->[0]", "$Bootdir/$img";
1713                    if (!$err) { log_("Linking failed $cdimages/$bootimg->[0]: $!\n", $config->{verbose}, $config->{LOG}) };
1714                }
1715                $mkisos->[$cdnum] .= qq( -c $sdir/boot.cat $dir/first/$cdnum);
1716                $graft->{"$sdir/boot.cat"} = 0;
1717                log_("BOOT $mkisos->[$cdnum]\n", $config->{verbose}, $config->{LOG});
1718            }
1719        }
1720    }
1721}
1722
1723sub installation {
1724    my ($class, $inst, $dir, $fixed, $nolive, $cdnum, $cd, $cdfile, $list, $mkisos, $totgraft, $inode, $discsFiles, $sort) = @_;
1725    my $graft = $totgraft->{$cdnum};
1726    my $install = $inst->[1]{install};
1727    my $struct_v = $config->{struct_version};
1728    my $struct = $config->{struct}{$struct_v};
1729    my ($isolinux_dir, $images_dir, $media_base, $extra_dir, $media_info, $install_dir, $compss_name) = ($struct->{isolinux}, $struct->{images}, $struct->{media_base}, $struct->{extra}, $struct->{media_info}, $struct->{install}, $struct->{compssUsers});
1730    if (!$fixed) {
1731        my $size;
1732        my $media_dir = $struct->{media};
1733        my $compss = $cd->{function}{data}{installation}[1]{compssUsers};
1734        $compss = "$install/$media_info/$compss_name" if !$compss && $install;
1735        if ($nolive) {
1736            if ($install) {
1737                opendir my $A, $install;
1738                foreach (readdir $A) {
1739                    /~$/ and next;
1740                    /^(\.{1,2}|$install_dir|LICENSE-APPS\.txt|$isolinux_dir|$images_dir|VERSION|boot\.cat|rr_moved|$media_base)$/ and next;
1741                    $size += du("$install/$_");
1742                    if (-d "$install/$_") { $graft->{"/$_/"}{"$install/$_"} = 1; next }
1743                    $graft->{"/"}{"$install/$_"} = 1
1744                }
1745
1746                local *A; opendir A, "$install/$install_dir";
1747                foreach (readdir A) {
1748                    log_("$install_dir -- $_\n", $config->{verbose}, $config->{LOG}, 3);
1749                    /~$/ and next;
1750                    # FIXME both old and new structure detailed
1751                    "$install_dir/$_" =~ m{^($install_dir/(\.{1,2}|$media_base))$|$media_dir|$extra_dir|$images_dir|$isolinux_dir} and next;
1752                    $size += du("$install/$install_dir/$_");
1753                    # if (-d "$install/Mandrake/$_") { $mkiso .= " Mandrake/$_/=$install/Mandrake/$_"; next }
1754                    # $graft->{"Mandrake/"}{"$install/Mandrake/$_"} = 1;
1755                    if (-d "$install/$install_dir/$_") { $graft->{"$install_dir/$_/"}{"$install/$install_dir/$_"} = 1; next }
1756                    $graft->{"$install_dir/"}{"$install/$install_dir/$_"} = 1;
1757                }
1758
1759                local *A; opendir A, "$install/$media_info";
1760                foreach (readdir A) {
1761                    /~$/ and next; 
1762                    /(^(\.{1,2}|compss|provides|depslist.ordered|MD5SUM|pubkey.*|synthesis|$compss_name|rpmsrate|rpmslist|filelist|Serial|hashfile)|hdlist|cooker)/ and next;
1763                    $size += du("$install/$media_info/$_");
1764                    # if (-d "$install/Mandrake/base/$_") { $mkiso .= " Mandrake/base/$_/=$install/Mandrake/base/$_"; next}
1765                    # $mkiso .= " Mandrake/base/=$install/Mandrake/base/$_";
1766                    if (-d "$install/$media_info/$_") { $graft->{"$media_info/$_/"}{"$install/$media_info/$_"} = 1; next }
1767                    $graft->{"$media_info/"}{"$install/$media_info/$_"} = 1
1768                }
1769            }
1770            if (-f $compss) { 
1771                log_("installation: $compss_name $compss\n", $config->{verbose}, $config->{LOG}, 2);
1772                $size += du($compss);
1773                $graft->{"$media_info/$compss_name"}{$compss} = 1
1774            } else { log_("ERROR installation: $compss file does not exist", $config->{verbose}, $config->{LOG}, 0) }
1775        } else {
1776            if ($install) {
1777                cpal("$install/$install_dir","$dir/$cdnum/$install_dir","$install/*($extra_dir|$images_dir|($install_dir/*)?$isolinux_dir|$media_dir|$media_info)");
1778                cpal("$install/","$dir/$cdnum/","$install/*($install_dir|$images_dir|$isolinux_dir|$media_base|tutorial|misc|doc|LICENSE-APPS.txt|boot.cat|rr_moved)");
1779                cpal("$install/$media_info","$dir/$cdnum/$media_info","$install/*$media_info/*(hdlist|MD5SUM|pubkey|depslist|synthesis|rpmslist|filelist|Serial|hashfile|$compss_name|rpmsrate)");
1780
1781                #cpal("$install/", "$dir/$cdnum", "($install/+(media/+|install/+(extra|images|isolinux)|(Mandrake/+base|media/+media_info)/+(hdlist|MD5SUM|pubkey|depslist|synthesis|rpmslist|filelist|Serial|hashfile|compssUsers|rpmsrate)|Mandrake/+RPMS|Mandrake/+share|isolinux|images|tutorial|misc|doc|LICENSE-APPS.txt|boot.cat|rr_moved))");
1782                if (!$inst->[1]{oem}) {
1783                    cpal("$install/tutorial", "$dir/$cdnum/tutorial") if -d "$install/tutorial";
1784                    cpal("$install/misc", "$dir/$cdnum/misc") if -d "$install/misc";
1785                    cpal("$install/doc", "$dir/$cdnum/doc") if -d "$install/doc";
1786                }
1787
1788            }
1789            if (-f $compss) {
1790                my $path = "$dir/$cdnum/$media_info";
1791                -d $path or mkpath $path;
1792                log_("installation: $compss_name $compss\n", $config->{verbose}, $config->{LOG}, 2);
1793                cpal($compss, "$path/$compss_name");
1794            } else { log_("ERROR installation: $compss file does not exist", $config->{verbose}, $config->{LOG}, 0) }
1795        }
1796        return $size
1797    } else {
1798        my $patch_dir = $struct->{patch};
1799        my $stage2 = $struct->{stage2};
1800        if ($nolive) {
1801            my $size;
1802            if ($inst->[1]{boot_medium}) {
1803                -d "$dir/$cdnum/$patch_dir" or mkpath "$dir/$cdnum/$patch_dir";
1804                my $file = "$dir/$cdnum/$patch_dir/patch-oem.pl";
1805                my $A;
1806                if (-f "$install/$patch_dir/patch-oem.pl") {
1807                    copy "$install/$patch_dir/patch-oem.pl", $file;
1808                    open $A, ">>$file" or print "ERROR installation: could not open $file for writing\n";
1809                } else {
1810                    open $A, ">$file" or print "ERROR installation: could not open $file for writing\n";
1811                }
1812                print $A "use install_any;
1813package install_any;
1814
1815\$current_medium = $inst->[1]{boot_medium};
1816\$asked_medium = $inst->[1]{boot_medium};
1817                ";
1818                $graft->{"$patch_dir/"}{$file} = 1;
1819                $size += du($file, $inode)
1820            }
1821            my ($repnum, $path, $pfile, $suppl_postfix) = buildInstallHdlist($dir, $cdnum, $inst, $list, $discsFiles, $sort, $nolive);
1822            if ($install && $fixed == 1) {
1823                my $rpmsrate = $cd->{function}{data}{installation}[1]{rpmsrate} || "$install/$media_info/base/rpmsrate";
1824                # $mkiso = " Mandrake/base/=$path/compss Mandrake/base/=$path/depslist.ordered Mandrake/base/=$path/provides Mandrake/base/=$path/hdlists /=$pfile";
1825                $graft->{"$media_info/"}{"$path/compss"} = 1;
1826                $graft->{"$media_info/"}{"$path/depslist.ordered"} = 1; 
1827                $graft->{"$media_info/"}{"$path/provides"} = 1;
1828                $graft->{"$media_info/"}{"$path/hdlists"} = 1;
1829                $graft->{"$media_info/"}{"$path/MD5SUM"} = 1;
1830                $graft->{"/"}{$pfile} = 1;
1831                if (-f $rpmsrate) {
1832                    $size += du($rpmsrate);
1833                    # $mkiso .= " Mandrake/base/rpmsrate=$rpmsrate"
1834                    $graft->{"$media_info/rpmsrate"}{$rpmsrate} = 1
1835                } else { log_("ERROR installation: $rpmsrate file does not exist", $config->{verbose}, $config->{LOG}, 0); return 0 }
1836                $size += du("$path/compss", $inode);
1837                $size += du("$path/depslist.ordered");
1838                $size += du("$path/provides");
1839                $size += du($pfile, $inode);
1840                unshift @{$sort->{$cdnum}}, [ "$path/", "$install/$stage2" ]
1841            }
1842            my $version = "$dir/$cdnum/VERSION";
1843            $size += du("$path/hdlists");
1844            printVERSION($config->{name}, $version, $inst->[1]{tag});
1845            $graft->{VERSION}{$version} = 1;
1846            $size += du($version);     
1847            foreach my $n (1 .. $repnum - 1) {
1848                # $mkiso .= " Mandrake/base/=$path/hdlist$n.cz";
1849                $graft->{"$media_info/"}{"$path/hdlist$n$suppl_postfix.cz"} = 1;
1850                # FIXME This is wrong, previous hdlist size must be deduced in iterative rebuild mode
1851                $size += du("$path/hdlist$n$suppl_postfix.cz");
1852                if (-f "$path/pubkey$n") { 
1853                    $graft->{"$media_info/"}{"$path/pubkey$n$suppl_postfix"} = 1;
1854                    $size += du("$path/pubkey$n$suppl_postfix");
1855                }
1856                if ($inst->[1]{synthesis}) {
1857                    # $mkiso .= " Mandrake/base/=$path/synthesis.hdlist$n.cz";
1858                    $graft->{"$media_info/"}{"$path/synthesis.hdlist$n$suppl_postfix.cz"} = 1;
1859                    $size += du("$path/synthesys.hdlist$n$suppl_postfix.cz")
1860                }
1861            }
1862            return $size;
1863        } else {
1864            if (!$install) { mkpath "$dir/$cdnum/$media_info/" ; mkpath "$dir/$cdnum/$install_dir" }
1865            if ($inst->[1]{boot_medium}) {
1866                log_("installation: boot_medium defined to $inst->[1]{boot_medium}\n", $config->{verbose}, $config->{LOG}, 2);
1867                my $file = "$dir/$cdnum/$patch_dir/patch-oem.pl";
1868                my $A;
1869                if (-f $file) {
1870                    unlink $file;
1871                    copy "$install/$patch_dir/patch-oem.pl", $file;
1872                    open $A, ">>$file" or print "ERROR installation: could not open $file for writing\n";
1873                } else {
1874                    open $A, ">$file" or print "ERROR installation: could not open $file for writing\n";
1875                }
1876                print $A "use install_any;
1877package install_any;
1878
1879\$current_medium = $inst->[1]{boot_medium};
1880\$asked_medium = $inst->[1]{boot_medium};
1881";
1882            } 
1883            unlink "$dir/$cdnum/$media_info/hdlists";
1884            buildInstallHdlist($dir, $cdnum, $inst, $list, $discsFiles, $sort);
1885            if ($fixed == 1) {
1886                my $rpmsrate = $cd->{function}{data}{installation}[1]{rpmsrate} || "$install/$media_info/rpmsrate";
1887                if (-f $rpmsrate) {
1888                    log_("installation: rpmsrate: $rpmsrate\n", $config->{verbose}, $config->{LOG}, 2);
1889                    cpal($rpmsrate, "$dir/$cdnum/$media_info/rpmsrate");
1890                } else { log_("ERROR installation: $rpmsrate file does not exist", $config->{verbose}, $config->{LOG}, 0); return 0 }
1891                if ($install) {
1892                    unshift @{$sort->{$cdnum}}, [ "$dir/$cdnum/$media_info/", "$dir/$cdnum/$stage2" ]
1893                }
1894            }
1895            my $version = "$dir/$cdnum/VERSION";
1896            unlink $version;
1897            printVERSION($config->{name}, $version, $inst->[1]{tag});
1898        }
1899    }
1900}
1901
19021
1903
1904#
1905# Changeloh
1906#
1907# 2002 03 15
1908# new sources handling in installation
1909#
1910# 2002 03 19
1911# cdcom are now build as normal ones not to force deps, use standard list
1912#
1913# 2002 03 29
1914# fix a bug in nolive mode that prevent rpmsrate to be put on discs
1915#
1916# 2002 05 13
1917# finish md5 check
1918# fix commented du in sub installation
1919#
1920# 2002 08 01
1921# add noauto options for rpmsdir
1922#
1923# 2002 08 14
1924# fix little bug in buildGenericHdlists
1925#
1926# 2002 10 02
1927# allow glob in rm function for live mode (need to do it for nolive mode)
1928#
1929# 20030401
1930# get_rpmsdir now manages hdlist dir
Note: See TracBrowser for help on using the repository browser.