source: trunk/debbuild@ 121

Last change on this file since 121 was 121, checked in by kdeugau, 17 years ago

/trunk

Massive cleanup of %files handling. Still not "complete", but much better.
%attr + %config + %doc (in all possible combinations) should be handled
about as close as I can get to rpmbuild's behaviour.
  • Property svn:executable set to *
  • Property svn:keywords set to Date Rev Author
File size: 56.9 KB
Line 
1#!/usr/bin/perl -w
2# debbuild script
3# Shamelessly steals interface from rpm's "rpmbuild" to create
4# Debian packages. Please note that such packages are highly
5# unlikely to conform to "Debian Policy".
6###
7# SVN revision info
8# $Date: 2007-08-01 19:10:37 +0000 (Wed, 01 Aug 2007) $
9# SVN revision $Rev: 121 $
10# Last update by $Author: kdeugau $
11###
12# Copyright 2005-2007 Kris Deugau <kdeugau@deepnet.cx>
13#
14# This program is free software; you can redistribute it and/or modify
15# it under the terms of the GNU General Public License as published by
16# the Free Software Foundation; either version 2 of the License, or
17# (at your option) any later version.
18#
19# This program is distributed in the hope that it will be useful,
20# but WITHOUT ANY WARRANTY; without even the implied warranty of
21# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22# GNU General Public License for more details.
23#
24# You should have received a copy of the GNU General Public License
25# along with this program; if not, write to the Free Software
26# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
27
28use strict;
29use warnings;
30use Fcntl; # for sysopen flags
31use Cwd 'abs_path'; # for finding where files really are
32use Config;
33
34# regex debugger
35#use re "debug";
36
37# Program flow:
38# -> Parse/execute "system" config/macros (if any - should be rare)
39# -> Parse/execute "user" config/macros (if any - *my* requirement is %_topdir)
40# -> Parse command line for options, spec file/tarball/.src.deb (NB - also accept .src.rpm)
41
42sub expandmacros;
43
44# User's prefs for dirs, environment, etc,etc,etc.
45# config file ~/.debmacros
46# Default ordered search paths for config/macros:
47# /usr/lib/rpm/rpmrc /usr/lib/rpm/redhat/rpmrc /etc/rpmrc ~/.rpmrc
48# /usr/lib/rpm/macros /usr/lib/rpm/redhat/macros /etc/rpm/macros ~/.rpmmacros
49# **NOTE: May be possible to (ab)use bits of debhelper
50
51# Build tree
52# default is /usr/src/debian/{BUILD,SOURCES,SPECS,DEBS,SDEBS}
53
54# Globals
55my $finalmessages = ''; # A place to stuff messages that I want printed at the *very* end of any processing.
56my $specfile;
57my $tarball;
58my $srcpkg;
59my $cmdbuildroot;
60my $tarballdir = '%{name}-%{version}'; # We do this in case of a spec file not using %setup...
61my %specglobals; # For %define's in specfile, among other things.
62
63$specglobals{'_vendor'} = 'debbuild';
64
65# Initialized globals
66my $verbosity = 0;
67my $NoAutoReq = 0;
68my %cmdopts = (type => '',
69 stage => 'a',
70 short => 'n'
71 );
72my $topdir = "/usr/src/debian";
73my $buildroot = "%{_tmppath}/%{name}-%{version}-%{release}.root".int(rand(99998)+1);
74
75# "Constants"
76my %targets = ('p' => 'Prep',
77 'c' => 'Compile',
78 'i' => 'Install',
79 'l' => 'Verify %files',
80 'a' => 'Build binary and source',
81 'b' => 'Build binary',
82 's' => 'Build source'
83 );
84# Ah, the joys of multiple architectures. :( Feh.
85# As copied from rpm
86my %optflags = ( 'i386' => '-O2 -g -march=i386 -mcpu=i686',
87 'amd64' => '-O2 -g'
88 );
89my $hostarch; # we set this later...
90my $scriptletbase =
91q(#!/bin/sh
92
93 RPM_SOURCE_DIR="%{_topdir}/SOURCES"
94 RPM_BUILD_DIR="%{_topdir}/BUILD"
95 RPM_OPT_FLAGS="%{optflags}"
96 RPM_ARCH="%{_arch}"
97 RPM_OS="linux"
98 export RPM_SOURCE_DIR RPM_BUILD_DIR RPM_OPT_FLAGS RPM_ARCH RPM_OS
99 RPM_DOC_DIR="/usr/share/doc"
100 export RPM_DOC_DIR
101 RPM_PACKAGE_NAME="%{name}"
102 RPM_PACKAGE_VERSION="%{version}"
103 RPM_PACKAGE_RELEASE="%{release}"
104 export RPM_PACKAGE_NAME RPM_PACKAGE_VERSION RPM_PACKAGE_RELEASE
105 RPM_BUILD_ROOT="%{buildroot}"
106 export RPM_BUILD_ROOT
107);
108foreach (`dpkg-architecture`) {
109 s/=(.+)/="$1"/;
110 $scriptletbase .= " $_";
111 ($hostarch) = (/^DEB_HOST_ARCH="(.+)"$/) if /DEB_HOST_ARCH=/;
112}
113$scriptletbase .=
114q(
115 set -x
116 umask 022
117 cd %{_topdir}/BUILD
118);
119
120# Hackery to try to bring some semblance of sanity to packages built for more
121# than one Debian version at the same time. Whee.
122# /etc/debian-version
123my %distmap = (
124 "3.1.9ubuntu7.1" => "dapper",
125 "4ubuntu2" => "feisty",
126 "3.0" => "woody",
127 "3.1" => "sarge",
128 "4" => "etch",
129 "4.0" => "lenny",
130 "4.0.0" => "sid");
131# Enh. There doesn't seem to be any better way to do this... :(
132{
133 my $basever = qx { dpkg-query --showformat '\${version}' -W base-files };
134 if ($basever =~ /^\d\.\d\.(\d)$/) {
135 $basever =~ s/\.\d$// if $1 ne '0';
136 }
137# want to do something with this... erm, what was I going to do? O_o
138 my $releasever = qx { cat /etc/debian_version };
139 chomp $releasever;
140
141 $specglobals{"debdist"} = $distmap{$basever};
142 $specglobals{"debver"} = $basever; # this may have trouble with Ubuntu versions?
143}
144
145# Package data
146# This is the form of $pkgdata{pkgname}{meta}
147# meta includes Summary, Name, Version, Release, Group, Copyright,
148# Source, URL, Packager, BuildRoot, Description, BuildReq(uires),
149# Requires, Provides
150# 10/31/2005 Maybe this should be flatter? -kgd
151my %pkgdata;
152my @pkglist = ('main'); #sigh
153# Files listing. Embedding this in %pkgdata would be, um, messy.
154my %filelist;
155my %doclist;
156my $buildreq = '';
157
158# Scriptlets
159my $prepscript = '';
160my $buildscript = '';
161# %install doesn't need the full treatment from %clean; just an empty place to install to.
162# NB - rpm doesn't do this; is it really necessary?
163my $installscript = '[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT'."\n";
164my $cleanscript = '';
165
166die "Not enough arguments\n" if #$argv == 0;
167
168# Snag some environment data
169my $tmpdir;
170if (defined $ENV{TMP} && $ENV{TMP} =~ /^(\/var)?\/tmp$/) {
171 $tmpdir = $ENV{TMP};
172} else {
173 $tmpdir = "/var/tmp";
174}
175
176##main
177
178load_userconfig();
179parse_cmd();
180
181if ($cmdopts{install}) {
182 install_sdeb();
183 exit 0;
184}
185
186# output stage of --showpkgs
187if ($cmdopts{type} eq 'd') {
188 parse_spec();
189 foreach my $pkg (@pkglist) {
190 $pkgdata{$pkg}{name} =~ tr/_/-/;
191
192 my $pkgfullname = "$pkgdata{$pkg}{name}_".
193 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
194 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb";
195
196 print "$pkgfullname\n" if $filelist{$pkg};
197
198 }
199 # Source package
200 print "$pkgdata{main}{name}-".
201 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
202 "$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb\n";
203 exit 0;
204}
205
206# Stick --rebuild handling in here - basically install_sdeb()
207# followed by tweaking options to run with -ba
208if ($cmdopts{type} eq 's') {
209 if ($srcpkg =~ /\.src\.rpm$/) {
210 my @srclist = qx { rpm -qlp $srcpkg };
211 foreach (@srclist) {
212 chomp;
213 $specfile = "$topdir/SPECS/$_" if /\.spec$/;
214 }
215 qx { rpm -i $srcpkg };
216 } else {
217 install_sdeb();
218 my @srclist = qx { pax < $srcpkg };
219 foreach (@srclist) {
220 chomp;
221 $specfile = "$topdir/$_" if /SPECS/;
222 }
223 }
224 $cmdopts{type} = 'b';
225 $cmdopts{stage} = 'a';
226}
227
228if ($cmdopts{type} eq 'b') {
229 # Need to read the spec file to find the tarball. Note that
230 # this also generates most of the shell script required.
231 parse_spec();
232 die "Can't build $pkgdata{main}{name}: build requirements not met.\n"
233 if !checkbuildreq();
234}
235
236if ($cmdopts{type} eq 't') {
237 # Need to unpack the tarball to find the spec file. Sort of the inverse of -b above.
238 # zcat $tarball |tar -t |grep .spec
239 # collect some info about the tarball
240 $specfile = "$topdir/BUILD/". qx { zcat $tarball |tar -t |grep -e '[\.]spec\$' };
241 chomp $specfile;
242 my ($fileonly, $dirname) = ($tarball =~ /(([a-zA-Z0-9._-]+)\.tar\.(?:gz|bz2))$/);
243
244 $tarball = abs_path($tarball);
245 my $unpackcmd = "cd $topdir/BUILD; tar -".
246 ( $tarball =~ /\.tar\.gz$/ ? "z" : "" ).
247 ( $tarball =~ /\.tar\.bz2$/ ? "j" : "" ). "xf $tarball";
248 system "$unpackcmd";
249 system "cp $tarball $topdir/SOURCES/$fileonly";
250 system "cp $specfile $topdir/SPECS/";
251 parse_spec();
252 die "Can't build $pkgdata{main}{name}: build requirements not met.\n"
253 if !checkbuildreq();
254}
255
256# -> srcpkg if -.s
257if ($cmdopts{stage} eq 's') {
258 srcpackage();
259 exit 0;
260}
261
262# Hokay. Need to:
263# -> prep if -.p OR (-.[cilabs] AND !--short-circuit)
264if ($cmdopts{stage} eq 'p' || ($cmdopts{stage} =~ /[cilabs]/ && $cmdopts{short} ne 'y')) {
265 prep();
266}
267# -> build if -.c OR (-.[ilabs] AND !--short-circuit)
268if ($cmdopts{stage} eq 'c' || ($cmdopts{stage} =~ /[ilabs]/ && $cmdopts{short} ne 'y')) {
269 build();
270}
271# -> install if -.[ilabs]
272#if ($cmdopts{stage} eq 'i' || ($cmdopts{stage} =~ /[labs]/ && $cmdopts{short} ne 'y')) {
273if ($cmdopts{stage} =~ /[ilabs]/) {
274 install();
275#foreach my $pkg (@pkglist) {
276# print "files in $pkg:\n ".$filelist{$pkg}."\n";
277#}
278
279}
280# -> binpkg and srcpkg if -.a
281if ($cmdopts{stage} eq 'a') {
282 binpackage();
283 srcpackage();
284 clean();
285}
286# -> binpkg if -.b
287if ($cmdopts{stage} eq 'b') {
288 binpackage();
289 clean();
290}
291
292# Spit out any closing remarks
293print $finalmessages;
294
295# Just in case.
296exit 0;
297
298
299## load_userconfig()
300# Loads user configuration (if any)
301# Currently only handles .debmacros
302# Needs to handle "other files"
303sub load_userconfig {
304 my $homedir = (getpwuid($<))[7];
305 if (-e "$homedir/.debmacros") {
306 open USERMACROS,"<$homedir/.debmacros";
307 while (<USERMACROS>) {
308 # And we also only handle a few macros at the moment.
309 if (/^\%_topdir/) {
310 my (undef,$tmp) = split /\s+/, $_;
311 $topdir = $tmp;
312 }
313 next if /^\%_/;
314 # Allow arbitrary definitions. Note that we're only doing simple defs here for now.
315 if (/^\%([a-z0-9]+)\s+(.+)$/) {
316 $specglobals{$1} = $2;
317 }
318 }
319 }
320} # end load_userconfig()
321
322
323## parse_cmd()
324# Parses command line into global hash %cmdopts, other globals
325# Options based on rpmbuild's options
326sub parse_cmd {
327 # Don't feel like coding my own option parser...
328 #use Getopt::Long;
329 # ... but I may have to: (OTOH, rpm uses popt, so maybe we can too.)
330 #use Getopt::Popt qw(:all);
331 # Or not. >:( Stupid Debian lack of findable Perl module names in packages.
332
333 # Stuff it.
334 my $prevopt = '';
335 foreach (@ARGV) {
336 chomp;
337
338 # Is it an option?
339 if (/^-/) {
340
341 # Is it a long option?
342 if (/^--/) {
343 if (/^--short-circuit/) {
344 $cmdopts{short} = 'y';
345 } elsif (/^--rebuild/) {
346 $cmdopts{type} = 's';
347 } elsif (/^--showpkgs/) {
348 $cmdopts{type} = 'd'; # d for 'diagnostic' or 'debug' or 'dump'
349 } elsif (/^--define/) {
350 # nothing to do? Can't see anything needed, we handle the actual definition later.
351 } else {
352 print "Long option $_ not handled\n";
353 }
354 } else {
355 # Not a long option
356 if (/^-[bt]/) {
357 if ($cmdopts{stage} eq 's') {
358 # Mutually exclusive options.
359 die "Can't use $_ with --rebuild\n";
360 } else {
361 # Capture the type (from "bare" files or tarball) and the stage (prep, build, etc)
362 ($cmdopts{stage}) = (/^-[bt]([pcilabs])/);
363 ($cmdopts{type}) = (/^-([bt])[pcilabs]/);
364 }
365 } elsif (/^-v/) {
366 # bump verbosity. Not sure what I'll actually do here...
367 } elsif (/^-i/) {
368 $cmdopts{install} = 1;
369 $prevopt = '-i';
370 } else {
371 die "Bad option $_\n";
372 }
373 }
374
375 } else { # Not an option argument
376
377 # --buildroot is the only option that takes an argument
378 # Therefore, any *other* bare arguments are the spec file,
379 # tarball, or source package we're operating on - depending
380 # on which one we meet.
381 if ($prevopt eq '--buildroot') {
382 $cmdbuildroot = $_;
383 } elsif ($prevopt eq '--define') {
384 my ($macro,$value) = (/([a-z0-9_.-]+)(?:\s+(.+))?/i);
385 if ($value) {
386 $specglobals{$macro} = $value;
387 } else {
388 warn "WARNING: missing value for macro $macro in --define! Ignoring.\n";
389 }
390 } elsif ($prevopt eq '-i') {
391 $srcpkg = $_;
392 } else {
393 if ($cmdopts{type} eq 's') {
394 # Source package
395 if (!/(sdeb|\.src\.rpm)$/) {
396 die "Can't --rebuild with $_\n";
397 }
398 $srcpkg = $_;
399 } elsif ($cmdopts{type} eq 'b' || $cmdopts{type} eq 'd') {
400 # Spec file
401 $specfile = $_;
402 } else {
403 # Tarball build. Need to extract tarball to find spec file. Whee.
404 $tarball = $_;
405 }
406 }
407 }
408 $prevopt = $_;
409 } # foreach @ARGV
410
411 # Some cross-checks. rpmbuild limits --short-circuit to just
412 # the "compile" and "install" targets - with good reason IMO.
413 # Note that --short-circuit with -.p is not really an error, just redundant.
414 # NB - this is NOT fatal, just ignored!
415 if ($cmdopts{short} eq 'y' && $cmdopts{stage} =~ /[labs]/) {
416 warn "Can't use --short-circuit for $targets{$cmdopts{stage}} stage. Ignoring.\n";
417 $cmdopts{short} = 'n';
418 }
419
420 # Valid options, with example arguments (if any):
421# Build from .spec file; mutually exclusive:
422 # -bp
423 # -bc
424 # -bi
425 # -bl
426 # -ba
427 # -bb
428 # -bs
429# Build from tarball; mutually exclusive:
430 # -tp
431 # -tc
432 # -ti
433 # -ta
434 # -tb
435 # -ts
436# Build from .src.(deb|rpm)
437 # --rebuild
438 # --recompile
439
440# General options
441 # --buildroot=DIRECTORY
442 # --clean
443 # --nobuild
444 # --nodeps
445 # --nodirtokens
446 # --rmsource
447 # --rmspec
448 # --short-circuit
449 # --target=CPU-VENDOR-OS
450
451 #my $popt = new Getopt::Popt(argv => \@ARGV, options => \@optionsTable);
452
453} # end parse_cmd()
454
455
456## parse_spec()
457# Parse the .spec file.
458sub parse_spec {
459 open SPECFILE,"<$specfile" or die "specfile ($specfile) barfed: $!";
460
461 my $iflevel = 0;
462 my $buildarch = $hostarch;
463 $pkgdata{main}{arch} = $hostarch;
464
465 my $stage = 'preamble';
466 my $subname = 'main';
467 my $scriptlet;
468
469# Basic algorithm:
470# For each line
471# if it's a member of an %if construct, branch and see which segment of the
472# spec file we need to parse and which one gets discarded, then
473# short-circuit back to the top of the loop.
474# if it's a %section, bump the stage. Preparse addons to the %section line
475# (eg subpackage) and stuff them in suitable loop-global variables, then
476# short-circuit back to the top of the loop.
477# Otherwise, parse the line according to which section we're supposedly
478# parsing right now
479
480LINE: while (<SPECFILE>) {
481 next if /^#/ && $stage eq 'preamble'; # Ignore comments...
482 next if /^\s*$/ && $stage eq 'preamble'; # ... and blank lines.
483
484# no sense in continuing if we find something we don't grok
485 # Yes, this is really horribly fugly. But it's a cheap crosscheck against invalid
486 # %-tags which also make rpmbuild barf. In theory.
487# notes: some of these are not *entirely* case-sensitive (%ifxxx), but most are.
488 # Extracted from the Maximum RPM online doc via:
489 # grep -h %[a-z] *|perl -e 'while (<>) { /\%([a-z0-9]+)\b/; print "$1|\n"; }'|sort -u
490 if (/^%[a-z]/ &&
491 $_ !~ /^%(?:attr|build|changelog|check|clean|config|configure|defattr|define|description|
492 dir|doc|docdir|else|endif|files|ghost|if|ifarch|ifn|ifnarch|ifnos|ifnxxx|fos|ifxxx|
493 install|package|patch|post|postun|pre|prep|preun|readme|setup|
494 triggerin|triggerpostun|triggerun|verify|verifyscript)\b/x
495 ) {
496 my ($badtag) = (/^%([a-z]+)/i);
497 die "Unknown tag \%$badtag at line $. of $specfile\n";
498 }
499
500# preprocess %define's
501 if (my ($key, $def) = (/^\%define\s+([^\s]+)\s+(.+)$/) ) {
502 $specglobals{$key} = expandmacros($def,'g');
503 }
504
505 if (/^\%if/) {
506 s/^\%if//;
507 chomp;
508 my $expr = expandmacros($_, 'g');
509 $iflevel++;
510
511 if ($expr !~ /^\s*\d+\s*$/) {
512 # gots a logic statement we want to turn into a 1 or a 0. most likely by eval'ing it.
513
514 $expr =~ s/\s+//g;
515
516# For Great w00tness! New and Improved multilayered logic handling.
517
518 my @bits = split /\b/, $expr;
519 $expr = '';
520 foreach my $bit (@bits) {
521 next if $bit eq '"';
522 $bit =~ s/"//g;
523 $expr .= qq("$bit") if $bit =~ /^\w+$/;
524 $expr .= $bit if $bit !~ /^\w+$/;
525 }
526
527 # Done in this order so we don't cascade incorrectly. Yes, those spaces ARE correct in the replacements!
528 $expr =~ s/==/ eq /g;
529 $expr =~ s/!=/ ne /g;
530 $expr =~ s/<=>/ cmp /g;
531 $expr =~ s/<=/ le /g;
532 $expr =~ s/>=/ ge /g;
533 $expr =~ s/</ lt /g;
534 $expr =~ s/>/ gt /g;
535
536 # Turn it into something that eval's to a number. Maybe not needed? O_o
537 #$expr = "( $expr ? 1 : 0 )";
538
539 $expr = eval $expr;
540 }
541
542 next LINE if $expr != 0; # This appears to be the only case we call false.
543 while (<SPECFILE>) {
544 if (/^\%endif/) {
545 $iflevel--;
546 next LINE;
547 } elsif (/^\%else/) {
548 next LINE;
549 }
550 }
551 }
552 if (/^\%else/) {
553 while (<SPECFILE>) {
554 if (/^\%endif/) {
555 $iflevel--;
556 next LINE;
557 }
558 }
559 }
560 if (/^\%endif/) {
561 $iflevel--;
562 next LINE;
563 } # %if/%else/%endif
564
565# now we pick out the sections and set "state" to parse that section. Fugly but I can't see a better way. >:(
566
567 if (/^\%description(?:\s+(?:-n\s+)?(.+))?/) {
568 $stage = 'desc';
569 $subname = "main";
570 if ($1) { # Magic to add entries to the right package
571 my $tmp = expandmacros("$1", 'g');
572 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
573 }
574 next LINE;
575 } # %description
576
577 if (/^\%package\s+(?:-n\s+)?(.+)/) {
578 $stage = 'package';
579 if ($1) { # Magic to add entries to the right package
580 my $tmp = expandmacros("$1", 'g');
581 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
582 }
583 push @pkglist, $subname;
584 $pkgdata{$subname}{name} = $subname;
585 $pkgdata{$subname}{version} = $pkgdata{main}{version};
586 # Build "same arch as previous package found" by default. Where rpm just picks the
587 # *very* last one, we want to allow arch<native>+arch-all
588 # (eg, Apache is i386, but apache-manual is all)
589 $pkgdata{$subname}{arch} = $buildarch; # Since it's likely subpackages will NOT have a BuildArch line...
590 next LINE;
591 } # %package
592
593 if (/^\%prep/) {
594 $stage = 'prep';
595 # This really should be local-ish, but we need just the filename for the source
596 $pkgdata{main}{source} =~ s|.+/([^/]+)$|$1|;
597 # Replace some core macros
598 $pkgdata{main}{source} = expandmacros($pkgdata{main}{source},'gp');
599 next LINE;
600 } # %prep
601
602 if (/^\%build/) {
603 $stage = 'build';
604 $buildscript .= "cd $tarballdir\n";
605 next LINE;
606 } # %build
607
608 if (/^\%install/) {
609 $stage = 'install';
610 $installscript .= "cd $tarballdir\n";
611 next LINE;
612 } # %install
613
614 if (/^\%clean/) {
615 $stage = 'clean';
616 $cleanscript .= "cd $tarballdir\n";
617 next LINE;
618 } # %clean
619
620 if (/^\%(pre|post|preun|postun)\b(?:\s+(?:-n\s+)?(.+))?/i) {
621 $stage = 'prepost';
622 $scriptlet = lc $1;
623 $subname = 'main';
624 if ($2) { # Magic to add entries to the right package
625 my $tmp = expandmacros("$2", 'g');
626 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
627 }
628 next LINE;
629 } # %pre/%post/%preun/%postun
630
631 if (/^\%files(?:\s+(?:-n\s+)?(.+))?/) {
632 $stage = 'files';
633 $subname = 'main';
634 if ($1) { # Magic to add entries to the right list of files
635 my $tmp = expandmacros("$1", 'g');
636 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
637 }
638 next LINE;
639 } # %files
640
641 if (/^\%changelog/) {
642 $stage = 'changelog';
643 $pkgdata{main}{changelog} = '';
644 next LINE;
645 }
646
647# now we handle individual lines from the various sections
648
649 if ($stage eq 'desc') {
650 $pkgdata{$subname}{desc} .= " $_";
651 } # description
652
653 if ($stage eq 'package') {
654 # gotta expand %defines here. Whee.
655 if (my ($dname,$dvalue) = (/^(Summary|Group|Version|Requires|Provides|BuildArch(?:itecture)?):\s+(.+)$/i)) {
656 $dname =~ tr/[A-Z]/[a-z]/;
657 if ($dname =~ /^BuildArch/i) {
658 $dvalue =~ s/^noarch/all/ig;
659 $buildarch = $dvalue; # Emulate rpm's behaviour to a degree
660 $dname = 'arch';
661 }
662 $pkgdata{$subname}{$dname} = expandmacros($dvalue, 'gp');
663 }
664 } # package
665
666 if ($stage eq 'prep') {
667 # Actual handling for %prep section. May have %setup macro; may
668 # include %patch tags, may be just a bare shell script.
669 if (/^\%setup/) {
670 # Parse out the %setup macro. Note that we aren't supporting
671 # many of RPM's %setup features.
672 $prepscript .= "cd $topdir/BUILD\n";
673 if ( /\s+-n\s+([^\s]+)\s+/ ) {
674 $tarballdir = $1;
675 }
676 $tarballdir = expandmacros($tarballdir,'gp');
677 $prepscript .= "rm -rf $tarballdir\n";
678 if (/\s+-c\s+/) {
679 $prepscript .= "mkdir $tarballdir\ncd $tarballdir\n";
680 }
681 $prepscript .= "tar -".
682 ( $pkgdata{main}{source} =~ /\.tar\.gz$/ ? "z" : "" ).
683 ( $pkgdata{main}{source} =~ /\.tar\.bz2$/ ? "j" : "" ).
684 ( /\s+-q\s+/ ? '' : 'vv' )."xf ".
685 "$topdir/SOURCES/$pkgdata{main}{source}\n".
686 qq(STATUS=\$?\nif [ \$STATUS -ne 0 ]; then\n exit \$STATUS\nfi\n).
687 "cd $topdir/BUILD/$tarballdir\n".
688 qq([ `/usr/bin/id -u` = '0' ] && /bin/chown -Rhf root .\n).
689 qq([ `/usr/bin/id -u` = '0' ] && /bin/chgrp -Rhf root .\n).
690 qq(/bin/chmod -Rf a+rX,g-w,o-w .\n);
691 } elsif ( my ($patchnum,$patchopts) = (/^\%patch([^\s]+)(\s+.+)?$/) ) {
692 chomp $patchnum;
693 $prepscript .= qq(echo "Patch #$patchnum ($pkgdata{main}{"patch$patchnum"}):"\n).
694 "patch ";
695 # If there are options passed, use'em.
696 # Otherwise, catch a bare %patch and ASS-U-ME it's '-p0'-able.
697 # Will break on options that don't provide -pnn, but what the hell.
698 $prepscript .= $patchopts if $patchopts;
699 $prepscript .= "-p0" if !$patchopts;
700 $prepscript .= " -s <$topdir/SOURCES/".$pkgdata{main}{"patch$patchnum"}."\n";
701 } else {
702 $prepscript .= expandmacros($_,'gp');
703 }
704 next LINE;
705 } # prep
706
707 if ($stage eq 'build') {
708 # %build. This is pretty much just a shell script. There
709 # aren't many local macros to deal with.
710 if (/^\%configure/) {
711 $buildscript .= expandmacros($_,'cgbp');
712 } elsif (/^\%\{__make\}/) {
713 $buildscript .= expandmacros($_,'mgbp');
714 } else {
715 $buildscript .= expandmacros($_,'gp');
716 }
717 next LINE;
718 } # build
719
720 if ($stage eq 'install') {
721 if (/^\%makeinstall/) {
722 $installscript .= expandmacros($_,'igbp');
723 } else {
724 $installscript .= expandmacros($_,'gp');
725 }
726 next LINE;
727 } # install
728
729 if ($stage eq 'clean') {
730 $cleanscript .= expandmacros($_,'gp');
731 next LINE;
732 } # clean
733
734 if ($stage eq 'prepost') {
735 $pkgdata{$subname}{$scriptlet} .= expandmacros($_,'gp');
736 next LINE;
737 } # prepost
738
739 if ($stage eq 'files') {
740 # need to deal with these someday
741 next LINE if /^\%dir/;
742 next LINE if /^\%defattr/;
743 next LINE if /^\%verify/;
744 # dunno what to do with this; not sure if there's space in Debian's package structure for it.
745 next LINE if /^\%ghost/;
746 # Debian dpkg doesn't speak "%docdir". Meh.
747 next LINE if /^\%docdir/;
748# my $singleton = 0; # don't recall what this was for
749
750# create and initialize flags
751 my ($perms, $owner, $group, $conf, $filesline);
752 $perms = $owner = $group = $conf = '-';
753
754 $filesline = $_;
755
756 # strip and flag %attr constructs
757 if ($filesline =~ /\%attr\b/) {
758 # Extract %attr...
759 my ($args) = (/(\%attr\s*\(\s*[\d-]+\s*,\s*["a-zA-Z0-9-]+\s*,\s*["a-zA-Z0-9-]+\s*\))/);
760 $args =~ s/\s+//g;
761 $args =~ s/"//g; # don't think quotes are ever necessary, but they're *allowed*
762 # ... and parse it ...
763 ($perms,$owner,$group) = ($args =~ /\(([\d-]+),([a-zA-Z0-9-]+),([a-zA-Z0-9-]+)/);
764 # ... and wipe it when we're done.
765 $filesline =~ s/\%attr\s*\(\s*[\d-]+\s*,\s*["a-zA-Z0-9-]+\s*,\s*["a-zA-Z0-9-]+\s*\)//;
766 }
767
768 # Conffiles. Note that Debian and RH have similar, but not
769 # *quite* identical ideas of what constitutes a conffile. Nrgh.
770 # Note that dpkg will always ask if you want to replace the file - noreplace
771 # is more or less permanently enabled.
772##fixme
773# also need to handle missingok (file that doesn't exist, but should be removed on uninstall)
774# hmm. not sure if such is **POSSIBLE** with Debian... maybe an addition to %post?
775 if ($filesline =~ /\%config\b(?:\s*\(\s*noreplace\s*\)\s*)?/) {
776 $pkgdata{$subname}{conffiles} = 1; # Flag it for later
777 $conf = 'y';
778 $filesline =~ s/\%config\b(?:\s*\(\s*noreplace\s*\)\s*)?//;
779 }
780
781 # %doc needs extra processing, because it can be a space-separated list, and may
782 # include both full and partial pathnames. The partial pathnames must be fiddled
783 # into place in the %install script, because Debian doesn't really have the concept
784 # of "documentation file" that rpm does. (Debian "documentation files" are files
785 # in /usr/share/doc/<packagename>.)
786##fixme: unhandled case: %doc %defattr. Eeep.
787# don't really know what to do with %defattr, generally. :(
788 if ($filesline =~ /\%doc\b/) {
789 $filesline =~ s/\s*\%doc\s+//;
790
791# this could probably go elsewhere.
792 my $pkgname = $pkgdata{$subname}{name};
793 $pkgname =~ tr/_/-/;
794
795 # have to extract the partial pathnames that %doc installs automagically
796 foreach (split /\s+/, $filesline) {
797 if (! (/^\%/ or m|^/|) ) {
798 $doclist{$subname} .= " $_";
799 my ($element) = m|([^/\s]+/?)$|;
800 $filesline =~ s|$_|\%{_docdir}/$pkgname/$element|;
801 }
802 }
803 } # $filesline =~ /\%doc\b/
804
805 $filesline =~ s/^\s*//; # Just In Case. For, uh, neatness.
806
807# due to Debian's total lack of real permissions-processing in its actual package
808# handling component (dpkg-deb), this can't really be done "properly". We'll have
809# to add chown/chmod commands to the postinst instead. Feh.
810 $pkgdata{$subname}{'post'} .= "chown $owner $filesline\n" if $owner ne '-';
811 $pkgdata{$subname}{'post'} .= "chgrp $group $filesline\n" if $group ne '-';
812 $pkgdata{$subname}{'post'} .= "chmod $perms $filesline\n" if $perms ne '-';
813
814##fixme
815# need hackery to assure only one filespec per %config. NB: "*" is one filespec. <g>
816 push @{$pkgdata{$subname}{conflist}}, $filesline if $conf ne '-';
817
818 # now that we've got the specials out of the way, we can add things to the appropriate list of files.
819 # ... and finally everything else
820 $filelist{$subname} .= " $filesline";
821
822 next LINE;
823 } # files
824
825 if ($stage eq 'changelog') {
826 # this is one of the few places we do NOT generally want to replace macros...
827 $pkgdata{main}{changelog} .= $_;
828 }
829
830 if ($stage eq 'preamble') {
831 if (/^summary:\s+(.+)/i) {
832 $pkgdata{main}{summary} = $1;
833 } elsif (/^name:\s+(.+)/i) {
834 $pkgdata{main}{name} = expandmacros($1,'g');
835 } elsif (/^epoch:\s+(.+)/i) {
836 $pkgdata{main}{epoch} = expandmacros($1,'g');
837 } elsif (/^version:\s+(.+)/i) {
838 $pkgdata{main}{version} = expandmacros($1,'g');
839 } elsif (/^release:\s+(.+)/i) {
840 $pkgdata{main}{release} = expandmacros($1,'g');
841 } elsif (/^group:\s+(.+)/i) {
842 $pkgdata{main}{group} = $1;
843 } elsif (/^copyright:\s+(.+)/i) {
844 $pkgdata{main}{copyright} = $1;
845 } elsif (/^url:\s+(.+)/i) {
846 $pkgdata{main}{url} = $1;
847 } elsif (/^packager:\s+(.+)/i) {
848 $pkgdata{main}{packager} = $1;
849 } elsif (/^buildroot:\s+(.+)/i) {
850 $buildroot = $1;
851 } elsif (/^source0?:\s+(.+)/i) {
852 $pkgdata{main}{source} = $1;
853 die "Unknown tarball format $1\n" if $1 !~ /\.tar\.(?:gz|bz2)$/;
854 } elsif (/^source([0-9]+):\s+(.+)/i) {
855 $pkgdata{sources}{$1} = $2;
856 } elsif (/^patch([^:]+):\s+(.+)$/i) {
857 my $patchname = "patch$1";
858 $pkgdata{main}{$patchname} = $2;
859 if ($pkgdata{main}{$patchname} =~ /\//) {
860 # URL-style patch. Rare but not unheard-of.
861 my @patchbits = split '/', $pkgdata{main}{$patchname};
862 $pkgdata{main}{$patchname} = $patchbits[$#patchbits];
863 }
864 chomp $pkgdata{main}{$patchname};
865 } elsif (/^buildarch(?:itecture)?:\s+(.+)/i) {
866 $pkgdata{main}{arch} = $1;
867 $pkgdata{main}{arch} =~ s/^noarch$/all/;
868 $buildarch = $pkgdata{main}{arch};
869 } elsif (/^buildreq(?:uires)?:\s+(.+)/i) {
870 $buildreq .= ", $1";
871 } elsif (/^requires:\s+(.+)/i) {
872 $pkgdata{main}{requires} .= ", ".expandmacros("$1", 'gp');
873 } elsif (/^provides:\s+(.+)/i) {
874 $pkgdata{main}{provides} .= ", $1";
875 } elsif (/^conflicts:\s+(.+)/i) {
876 $pkgdata{main}{conflicts} .= ", $1";
877 } elsif (/^autoreq(?:prov)?:\s+(.+)/i) {
878 # we don't handle auto-provides (yet)
879 $NoAutoReq = 1 if $1 =~ /(?:no|0)/i;
880 }
881 next LINE;
882 } # preamble
883
884 } # while <SPEC>
885
886 # Parse and replace some more macros. More will be replaced even later.
887
888 # Expand macros as necessary.
889 $scriptletbase = expandmacros($scriptletbase,'gp');
890
891 $cleanscript = expandmacros($cleanscript,'gp');
892
893 $buildroot = $cmdbuildroot if $cmdbuildroot;
894 $buildroot = expandmacros($buildroot,'gp');
895
896 close SPECFILE;
897} # end parse_spec()
898
899
900## prep()
901# Writes and executes the %prep script (mostly) built while reading the spec file.
902sub prep {
903 # Replace some things here just to make sure.
904 $prepscript = expandmacros($prepscript,'gp');
905
906 # create script filename
907 my $prepscriptfile = "$tmpdir/deb-tmp.prep.".int(rand(99998)+1);
908 sysopen(PREPSCRIPT, $prepscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
909 or die $!;
910 print PREPSCRIPT $scriptletbase;
911 print PREPSCRIPT $prepscript;
912 close PREPSCRIPT;
913
914 # execute
915 print "Calling \%prep script $prepscriptfile...\n";
916 system("/bin/sh -e $prepscriptfile") == 0
917 or die "Can't exec: $!\n";
918
919 # and clean up
920 unlink $prepscriptfile;
921} # end prep()
922
923
924## build()
925# Writes and executes the %build script (mostly) built while reading the spec file.
926sub build {
927 # Expand the macros
928 $buildscript = expandmacros($buildscript,'cgbp');
929
930 # create script filename
931 my $buildscriptfile = "$tmpdir/deb-tmp.build.".int(rand(99998)+1);
932 sysopen(BUILDSCRIPT, $buildscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
933 or die $!;
934 print BUILDSCRIPT $scriptletbase;
935 print BUILDSCRIPT $buildscript;
936 close BUILDSCRIPT;
937
938 # execute
939 print "Calling \%build script $buildscriptfile...\n";
940 system("/bin/sh -e $buildscriptfile") == 0
941 or die "Can't exec: $!\n";
942
943 # and clean up
944 unlink $buildscriptfile;
945} # end build()
946
947
948## install()
949# Writes and executes the %install script (mostly) built while reading the spec file.
950sub install {
951
952 # munge %doc entries into place
953 # rpm handles this with a separate executed %doc script, we're not going to bother.
954 foreach my $docpkg (keys %doclist) {
955 my $pkgname = $pkgdata{$docpkg}{name};
956 $pkgname =~ s/_/-/g;
957
958 $installscript .= "DOCDIR=\$RPM_BUILD_ROOT\%{_docdir}/$pkgname\nexport DOCDIR\n";
959 $installscript .= "mkdir -p \$DOCDIR\n";
960 $doclist{$docpkg} =~ s/^\s*//;
961 foreach (split(' ',$doclist{$docpkg})) {
962 $installscript .= "cp -pr $_ \$DOCDIR/\n";
963 }
964 }
965
966 # Expand the macros
967 $installscript = expandmacros($installscript,'igbp');
968
969 # create script filename
970 my $installscriptfile = "$tmpdir/deb-tmp.inst.".int(rand(99998)+1);
971 sysopen(INSTSCRIPT, $installscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
972 or die $!;
973 print INSTSCRIPT $scriptletbase;
974 print INSTSCRIPT $installscript;
975 close INSTSCRIPT;
976
977 # execute
978 print "Calling \%install script $installscriptfile...\n";
979 system("/bin/sh -e $installscriptfile") == 0
980 or die "Can't exec: $!\n";
981
982 # and clean up
983 unlink $installscriptfile;
984} # end install()
985
986
987## binpackage()
988# Creates the binary .deb package from the installed tree in $buildroot.
989# Writes and executes a shell script to do so.
990# Creates miscellaneous files required by dpkg-deb to actually build the package file.
991# Should handle simple subpackages
992sub binpackage {
993
994 foreach my $pkg (@pkglist) {
995
996 $pkgdata{$pkg}{arch} = $hostarch if !$pkgdata{$pkg}{arch}; # Just In Case.
997
998 # Make sure we have somewhere to write the .deb file
999 if (!-e "$topdir/DEBS/$pkgdata{$pkg}{arch}") {
1000 mkdir "$topdir/DEBS/$pkgdata{$pkg}{arch}";
1001 }
1002
1003 # Skip building a package if it doesn't actually have any files. NB: This
1004 # differs slightly from rpm's behaviour where a package *will* be built -
1005 # even without any files - if %files is specified anywhere. I can think
1006 # of odd corner cases where that *may* be desireable.
1007 next if (!$filelist{$pkg} or $filelist{$pkg} =~ /^\s*$/);
1008
1009 # Gotta do this first, otherwise we don't have a place to move files from %files
1010 mkdir "$buildroot/$pkg";
1011
1012 # Eliminate any lingering % macros
1013 $filelist{$pkg} = expandmacros $filelist{$pkg}, 'g';
1014
1015 my @pkgfilelist = split ' ', $filelist{$pkg};
1016 foreach my $pkgfile (@pkgfilelist) {
1017 $pkgfile = expandmacros($pkgfile, 'gp');
1018
1019 # Feh. Manpages don't **NEED** to be gzipped, but rpmbuild does, and so shall we.
1020 if ($pkgfile =~ m|/usr/share/man/man|) {
1021 # need to check to see if manpage is gzipped
1022 if (-e "$buildroot$pkgfile") {
1023 if ($pkgfile !~ m|\.gz$|) {
1024 qx { gzip $buildroot$pkgfile };
1025 $pkgfile .= ".gz";
1026 }
1027 } else {
1028 if ($pkgfile !~ m|\.gz$|) {
1029 $pkgfile .= ".gz";
1030 } else {
1031 $pkgfile =~ s/\.gz$//;
1032 qx { gzip $buildroot$pkgfile };
1033 $pkgfile .= ".gz";
1034 }
1035 }
1036 }
1037
1038 my ($fpath,$fname) = ($pkgfile =~ m|(.+?/?)?([^/]+)$|); # We don't need $fname now, but we might.
1039 qx { mkdir -p $buildroot/$pkg$fpath }
1040 if $fpath && $fpath ne '';
1041 qx { mv $buildroot$pkgfile $buildroot/$pkg$fpath };
1042 }
1043
1044 # Get the "Depends" (Requires) a la RPM. Ish. We strip the leading
1045 # comma and space here (if needed) in case there were "Requires" specified
1046 # in the spec file - those would precede these.
1047 $pkgdata{$pkg}{requires} .= getreqs("$buildroot/$pkg") if ! $NoAutoReq;
1048
1049 # magic needed to properly version dependencies...
1050 # only provided deps will really be included
1051 $pkgdata{$pkg}{requires} =~ s/^, //; # Still have to do this here.
1052 $pkgdata{$pkg}{requires} =~ s/\s+//g;
1053 my @deps = split /,/, $pkgdata{$pkg}{requires};
1054 my $tmp = '';
1055 foreach my $dep (@deps) {
1056 # Hack up the perl(Class::SubClass) deps into something dpkg can understand.
1057 # May or may not be versioned.
1058 # We do this first so the version rewriter can do its magic next.
1059 if (my ($mod,$ver) = ($dep =~ /^perl\(([A-Za-z0-9\:\-]+)\)([><=]+.+)?/) ) {
1060 $mod =~ s/^perl\(//;
1061 $mod =~ s/\)$//;
1062 $mod =~ s/::/-/g;
1063 $mod =~ tr/A-Z/a-z/;
1064 $mod = "lib$mod-perl";
1065 $mod .= $ver if $ver;
1066 $dep = $mod;
1067 }
1068 if (my ($name,$rel,$value) = ($dep =~ /^([a-zA-Z0-9._-]+)([><=]+)([a-zA-Z0-9._-]+)$/)) {
1069 $tmp .= ", $name ($rel $value)";
1070 } else {
1071 $tmp .= ", $dep";
1072 }
1073 }
1074 ($pkgdata{$pkg}{requires} = $tmp) =~ s/^, //;
1075
1076 # Do this here since we're doing {depends}...
1077 if (defined($pkgdata{$pkg}{provides})) {
1078 $pkgdata{$pkg}{provides} =~ s/^, //;
1079 $pkgdata{$pkg}{provides} = expandmacros($pkgdata{$pkg}{provides},'gp');
1080 }
1081 if (defined($pkgdata{$pkg}{conflicts})) {
1082 $pkgdata{$pkg}{conflicts} =~ s/^, //;
1083 $pkgdata{$pkg}{conflicts} = expandmacros($pkgdata{$pkg}{conflicts},'gp');
1084 }
1085
1086 # Gotta do this next, otherwise the control file has nowhere to go. >:(
1087 mkdir "$buildroot/$pkg/DEBIAN";
1088
1089 # Hack the filename for the package into a Debian-tool-compatible format. GRRRRRR!!!!!
1090 # Have I mentioned I hate Debian Policy?
1091 $pkgdata{$pkg}{name} =~ tr/_/-/;
1092
1093 # create script filename
1094 my $debscriptfile = "$tmpdir/deb-tmp.pkg.".int(rand(99998)+1);
1095 sysopen(DEBSCRIPT, $debscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1096 or die $!;
1097 print DEBSCRIPT $scriptletbase;
1098 print DEBSCRIPT "fakeroot dpkg-deb -b $buildroot/$pkg $topdir/DEBS/$pkgdata{$pkg}{arch}/".
1099 "$pkgdata{$pkg}{name}_".
1100 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1101 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb\n";
1102 # %$&$%@#@@#%@@@ Debian and their horrible ugly package names. >:(
1103 close DEBSCRIPT;
1104
1105 my $control = "Package: $pkgdata{$pkg}{name}\n".
1106 "Version: ".
1107 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1108 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}\n".
1109 "Section: $pkgdata{$pkg}{group}\n".
1110 "Priority: optional\n".
1111 "Architecture: $pkgdata{$pkg}{arch}\n".
1112 "Maintainer: $pkgdata{main}{packager}\n".
1113 ( $pkgdata{$pkg}{requires} ne '' ? "Depends: $pkgdata{$pkg}{requires}\n" : '' ).
1114 ( defined($pkgdata{$pkg}{provides}) ? "Provides: $pkgdata{$pkg}{provides}\n" : '' ).
1115 ( defined($pkgdata{$pkg}{conflicts}) ? "Conflicts: $pkgdata{$pkg}{conflicts}\n" : '' ).
1116 "Description: $pkgdata{$pkg}{summary}\n";
1117 $control .= "$pkgdata{$pkg}{desc}\n";
1118
1119 open CONTROL, ">$buildroot/$pkg/DEBIAN/control";
1120 print CONTROL $control;
1121 close CONTROL;
1122
1123 # Iff there are conffiles (as specified in the %files list(s), add'em
1124 # in so dpkg-deb can tag them.
1125 if ($pkgdata{$pkg}{conffiles}) {
1126 open CONFLIST, ">$buildroot/$pkg/DEBIAN/conffiles";
1127 foreach my $conffile (@{$pkgdata{$pkg}{conflist}}) {
1128 my @tmp = glob "$buildroot/$pkg/$conffile";
1129 foreach (@tmp) {
1130 s|$buildroot/$pkg/||g; # nrgl. gotta be a better way to do this...
1131 s/\s+/\n/g; # Not gonna support spaces in filenames. Ewww.
1132 print CONFLIST "$_\n";
1133 }
1134 }
1135 close CONFLIST;
1136 }
1137
1138 # found the point of scripts on subpackages.
1139 if ($pkgdata{$pkg}{'pre'}) {
1140 $pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'pre'},'gp');
1141 open PREINST, ">$buildroot/$pkg/DEBIAN/preinst";
1142 print PREINST "#!/bin/sh\nset -e\n\n";
1143 print PREINST $pkgdata{$pkg}{'pre'};
1144 close PREINST;
1145 `chmod 0755 $buildroot/$pkg/DEBIAN/preinst`;
1146 }
1147 if ($pkgdata{$pkg}{'post'}) {
1148 $pkgdata{$pkg}{'post'} = expandmacros($pkgdata{$pkg}{'post'},'gp');
1149 open PREINST, ">$buildroot/$pkg/DEBIAN/postinst";
1150 print PREINST "#!/bin/sh\nset -e\n\n";
1151 print PREINST $pkgdata{$pkg}{'post'};
1152 close PREINST;
1153 `chmod 0755 $buildroot/$pkg/DEBIAN/postinst`;
1154 }
1155 if ($pkgdata{$pkg}{'preun'}) {
1156 $pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'preun'},'gp');
1157 open PREINST, ">$buildroot/$pkg/DEBIAN/prerm";
1158 print PREINST "#!/bin/sh\nset -e\n\n";
1159 print PREINST $pkgdata{$pkg}{'preun'};
1160 close PREINST;
1161 `chmod 0755 $buildroot/$pkg/DEBIAN/prerm`;
1162 }
1163 if ($pkgdata{$pkg}{'postun'}) {
1164 $pkgdata{$pkg}{'postun'} = expandmacros($pkgdata{$pkg}{'postun'},'gp');
1165 open PREINST, ">$buildroot/$pkg/DEBIAN/postrm";
1166 print PREINST "#!/bin/sh\nset -e\n\n";
1167 print PREINST $pkgdata{$pkg}{'postun'};
1168 close PREINST;
1169 `chmod 0755 $buildroot/$pkg/DEBIAN/postrm`;
1170 }
1171
1172 # execute
1173 print "Calling package creation script $debscriptfile for $pkgdata{$pkg}{name}...\n";
1174 system("/bin/sh -e $debscriptfile") == 0
1175 or die "Can't exec: $!\n";
1176
1177 $finalmessages .= "Wrote binary package ".
1178 "$pkgdata{$pkg}{name}_".
1179 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1180 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb".
1181 " in $topdir/DEBS/$pkgdata{$pkg}{arch}\n";
1182 # and clean up
1183 unlink $debscriptfile;
1184
1185 } # subpackage loop
1186
1187} # end binpackage()
1188
1189
1190## srcpackage()
1191# Builds a .src.deb source package. Note that Debian's idea of
1192# a "source package" is seriously flawed IMO, because you can't
1193# easily copy it as-is.
1194# Not quite identical to RPM, but Good Enough (TM).
1195sub srcpackage {
1196 # In case we were called with -bs.
1197 $pkgdata{main}{name} =~ tr/_/-/;
1198 my $pkgsrcname = "$pkgdata{main}{name}-".
1199 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1200 "$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb";
1201
1202 my $paxcmd;
1203
1204 # We'll definitely need this later, and *may* need it sooner.
1205 (my $barespec = $specfile) =~ s|.+/([^/]+)$|$1|;
1206
1207 # Copy the specfile to the build tree, but only if it's not there already.
1208##buglet: need to deal with silly case where silly user has put the spec
1209# file in a subdir of %{_topdir}/SPECS. Ewww. Silly user!
1210 if (abs_path($specfile) !~ /^$topdir\/SPECS/) {
1211 $paxcmd .= "cp $specfile %{_topdir}/SPECS/; \n"
1212 }
1213
1214 # use pax -w [file] [file] ... >outfile.sdeb
1215 $paxcmd = "cd $topdir; pax -w ";
1216
1217# tweak source entry into usable form. Need it locally somewhere along the line.
1218 (my $pkgsrc = $pkgdata{main}{source}) =~ s|.+/([^/]+)$|$1|;
1219 $paxcmd .= "SOURCES/$pkgsrc ";
1220
1221 # create file list: Source[nn], Patch[nn]
1222 foreach my $specbit (keys %{$pkgdata{main}} ) {
1223 next if $specbit eq 'source';
1224 $paxcmd .= "SOURCES/$pkgdata{main}{$specbit} " if $specbit =~ /^patch/;
1225##buglet: need to deal with case where patches are listed as URLs?
1226# or other extended pathnames? Silly !@$%^&!%%!%!! user!
1227 }
1228
1229 foreach my $source (keys %{$pkgdata{sources}}) {
1230 $paxcmd .= "SOURCES/$pkgdata{sources}{$source} ";
1231 }
1232
1233 # add the spec file, source package destination, and cd back where we came from.
1234 $paxcmd .= "SPECS/$barespec > $topdir/SDEBS/$pkgsrcname; cd -";
1235
1236 # In case of %-macros...
1237 $paxcmd = expandmacros($paxcmd,'gp');
1238
1239 system "$paxcmd";
1240 $finalmessages .= "Wrote source package $pkgsrcname in $topdir/SDEBS.\n";
1241} # end srcpackage()
1242
1243
1244## clean()
1245# Writes and executes the %clean script (mostly) built while reading the spec file.
1246sub clean {
1247 # Replace some things here just to make sure.
1248 $cleanscript = expandmacros($cleanscript,'gp');
1249
1250 # create script filename
1251 my $cleanscriptfile = "$tmpdir/deb-tmp.clean.".int(rand(99998)+1);
1252 sysopen(CLEANSCRIPT, $cleanscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1253 or die $!;
1254 print CLEANSCRIPT $scriptletbase;
1255 print CLEANSCRIPT $cleanscript;
1256 close CLEANSCRIPT;
1257
1258 # execute
1259 print "Calling \%clean script $cleanscriptfile...\n";
1260 system("/bin/sh -e $cleanscriptfile") == 0
1261 or die "Can't exec: $!\n";
1262
1263 # and clean up
1264 unlink $cleanscriptfile;
1265} # end clean()
1266
1267
1268## checkbuildreq()
1269# Checks the build requirements (if any)
1270# Spits out a rude warning and returns a true-false error if any
1271# requirements are not met.
1272sub checkbuildreq {
1273 return 1 if $buildreq eq ''; # No use doing extra work.
1274
1275 if ( ! -e "/usr/bin/dpkg-query" ) {
1276 print "**WARNING** dpkg-query not found. Can't check build-deps.\n".
1277 " Required for sucessful build:\n".$buildreq."\n".
1278 " Continuing anyway.\n";
1279 return 1;
1280 }
1281
1282 my $reqflag = 1; # unset iff a buildreq is missing
1283
1284 $buildreq =~ s/^, //; # Strip the leading comma and space
1285 my @reqlist = split /,\s+/, $buildreq;
1286
1287 foreach my $req (@reqlist) {
1288 my ($pkg,$rel,$ver);
1289
1290 # We have two classes of requirements - versioned and unversioned.
1291 if ($req =~ /[><=]/) {
1292 # Pick up the details of versioned buildreqs
1293 ($pkg,$rel,$ver) = ($req =~ /([a-z0-9._-]+)\s+([><=]+)\s+([a-z0-9._-]+)/);
1294 } else {
1295 # And the unversioned ones.
1296 $pkg = $req;
1297 $rel = '>=';
1298 $ver = 0;
1299 }
1300
1301 my @pkglist = qx { dpkg-query --showformat '\${status}\t\${version}\n' -W $pkg };
1302# need to check if no lines returned - means a bad buildreq
1303 my ($reqstat,undef,undef,$reqver) = split /\s+/, $pkglist[0];
1304 if ($reqstat !~ /install/) {
1305 print " * Missing build-dependency $pkg!\n";
1306 $reqflag = 0;
1307 } else {
1308# gotta be a better way to do this... :/
1309 if ($rel eq '>=' && !($reqver ge $ver)) {
1310 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1311 $reqflag = 0;
1312 }
1313 if ($rel eq '>' && !($reqver gt $ver)) {
1314 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1315 $reqflag = 0;
1316 }
1317 if ($rel eq '<=' && !($reqver le $ver)) {
1318 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1319 $reqflag = 0;
1320 }
1321 if ($rel eq '<' && !($reqver lt $ver)) {
1322 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1323 $reqflag = 0;
1324 }
1325 if ($rel eq '=' && !($reqver eq $ver)) {
1326 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1327 $reqflag = 0;
1328 }
1329 } # end not installed/installed check
1330 } # end req loop
1331
1332 return $reqflag;
1333} # end checkbuildreq()
1334
1335
1336## getreqs()
1337# Find out which libraries/packages are required for any
1338# executables and libs in a given file tree.
1339# (Debian doesn't have soname-level deps; just package-level)
1340# Returns an empty string if the tree contains no binaries.
1341# Doesn't work well on shell scripts. but those *should* be
1342# fine anyway. (Yeah, right...)
1343sub getreqs() {
1344 my $pkgtree = $_[0];
1345
1346 print "Checking library requirements...\n";
1347 my @binlist = qx { find $pkgtree -type f -perm 755 };
1348
1349 if (scalar(@binlist) == 0) {
1350 return '';
1351 }
1352
1353 my @reqlist;
1354 foreach (@binlist) {
1355 push @reqlist, qx { ldd $_ };
1356 }
1357
1358 # Get the list of libs provided by this package. Still doesn't
1359 # handle the case where the lib gets stuffed into a subpackage. :/
1360 my @intprovlist = qx { find $pkgtree -type f -name "*.so*" };
1361 my $provlist = '';
1362 foreach (@intprovlist) {
1363 s/$pkgtree//;
1364 $provlist .= "$_";
1365 }
1366
1367 my %reqs;
1368 my $reqlibs = '';
1369
1370 foreach (@reqlist) {
1371 next if /^$pkgtree/;
1372 next if /not a dynamic executable/;
1373 next if m|/lib/ld-linux.so|; # Hack! Hack! PTHBTT! (libc suxx0rz)
1374 next if /linux-gate.so/; # Kernel hackery for teh W1n!!1!1eleventy-one!1 (Don't ask. Feh.)
1375
1376 my ($req) = (/^\s+([a-z0-9._-]+)/); # dig out the actual library (so)name
1377
1378 # Ignore libs provided by this package. Note that we don't match
1379 # on word-boundary at the *end* of the lib we're looking for, as the
1380 # looked-for lib may not have the full soname version. (ie, it may
1381 # "just" point to one of the symlinks that get created somewhere.)
1382 next if $provlist =~ /\b$req/;
1383
1384 $reqlibs .= " $req";
1385 }
1386
1387 if ($reqlibs ne '') {
1388 foreach (qx { dpkg -S $reqlibs }) {
1389 my ($libpkg,undef) = split /:\s+/;
1390 $reqs{$libpkg} = 1;
1391 }
1392 }
1393
1394 my $deplist = '';
1395 foreach (keys %reqs) {
1396 $deplist .= ", $_";
1397 }
1398
1399# For now, we're done. We're not going to meddle with versions yet.
1400# Among other things, it's messier than handling "simple" yes/no "do
1401# we have this lib?" deps. >:(
1402
1403 return $deplist;
1404} # end getreqs()
1405
1406
1407## install_sdeb()
1408# Extracts .sdeb contents to %_topdir as appropriate
1409sub install_sdeb {
1410 $srcpkg = abs_path($srcpkg);
1411
1412 my $paxcmd = "cd $topdir; pax -r <$srcpkg; cd -";
1413
1414 # In case of %-macros...
1415 $paxcmd = expandmacros($paxcmd,'gp');
1416
1417 system "$paxcmd";
1418 print "Extracted source package $srcpkg to $topdir.\n";
1419} # end install_sdeb()
1420
1421
1422## expandmacros()
1423# Expands all %{blah} macros in the passed string
1424# Split up a bit with some sections so we don't spend time trying to
1425# expand macros that are only used in a few specific places.
1426sub expandmacros {
1427 my $macrostring = shift;
1428 my $section = shift;
1429
1430 # To allow the FHS-ish %configure and %makeinstall to work The Right Way.
1431 # (Without clobbering the global $buildroot.)
1432 my $prefix = '';
1433
1434 if ($section =~ /c/) {
1435 # %configure macro
1436# Don't know what it's for, don't have a useful default replacement
1437# --program-prefix=%{_program_prefix} \
1438 $macrostring =~ s'%configure'./configure --host=$DEB_HOST_GNU_TYPE \
1439 --build=$DEB_BUILD_GNU_TYPE \
1440 --prefix=%{_prefix} \
1441 --exec-prefix=%{_exec_prefix} \
1442 --bindir=%{_bindir} \
1443 --sbindir=%{_sbindir} \
1444 --sysconfdir=%{_sysconfdir} \
1445 --datadir=%{_datadir} \
1446 --includedir=%{_includedir} \
1447 --libdir=%{_libdir} \
1448 --libexecdir=%{_libexecdir} \
1449 --localstatedir=%{_localstatedir} \
1450 --sharedstatedir=%{_sharedstatedir} \
1451 --mandir=%{_mandir} \
1452 --infodir=%{_infodir} ';
1453 } # done %configure
1454
1455 if ($section =~ /m/) {
1456 $macrostring =~ s'%{__make}'make ';
1457 } # done make
1458
1459 if ($section =~ /i/) {
1460 # This is where we need to mangle $prefix.
1461 $macrostring =~ s'%makeinstall'make %{fhs} install';
1462 $prefix = $buildroot;
1463 } # done %install and/or %makeinstall
1464
1465 # Build data
1466 # Note that these are processed in reverse order to get the substitution order right
1467 if ($section =~ /b/) {
1468# $macrostring =~ s'%{fhs}'host=$DEB_HOST_GNU_TYPE \
1469# build=$DEB_BUILD_GNU_TYPE \
1470 $macrostring =~ s'%{fhs}'prefix=%{_prefix} \
1471 exec-prefix=%{_exec_prefix} \
1472 bindir=%{_bindir} \
1473 sbindir=%{_sbindir} \
1474 sysconfdir=%{_sysconfdir} \
1475 datadir=%{_datadir} \
1476 includedir=%{_includedir} \
1477 libdir=%{_libdir} \
1478 libexecdir=%{_libexecdir} \
1479 localstatedir=%{_localstatedir} \
1480 sharedstatedir=%{_sharedstatedir} \
1481 mandir=%{_mandir} \
1482 infodir=%{_infodir} \
1483';
1484
1485 # Note that the above regex terminates with the extra space
1486 # "Just In Case" of user additions, which will then get neatly
1487 # tagged on the end where they take precedence (supposedly)
1488 # over the "default" ones.
1489
1490 # Now we cascade the macros introduced above. >_<
1491 # Wot ot to go theah:
1492 $macrostring =~ s|%{_mandir}|%{_datadir}/man|g; #/usr/share/man
1493 $macrostring =~ s|%{_infodir}|%{_datadir}/info|g; #/usr/share/info
1494 $macrostring =~ s|%{_oldincludedir}|/usr/include|g; #/usr/include
1495 $macrostring =~ s|%{_includedir}|%{_prefix}/include|g; #/usr/include
1496 $macrostring =~ s|%{_libdir}|%{_exec_prefix}/%{_lib}|g; #/usr/lib
1497 $macrostring =~ s|%{_lib}|lib|g; #?
1498 $macrostring =~ s|%{_localstatedir}|/var|g; #/var
1499 $macrostring =~ s|%{_sharedstatedir}|%{_prefix}/com|g; #/usr/com WTF?
1500 $macrostring =~ s|%{_sysconfdir}|/etc|g; #/etc
1501 $macrostring =~ s|%{_datadir}|%{_prefix}/share|g; #/usr/share
1502 $macrostring =~ s|%{_libexecdir}|%{_exec_prefix}/libexec|g; #/usr/libexec
1503 $macrostring =~ s|%{_sbindir}|%{_exec_prefix}/sbin|g; #/usr/sbin
1504 $macrostring =~ s|%{_bindir}|%{_exec_prefix}/bin|g; #/usr/bin
1505 $macrostring =~ s|%{_exec_prefix}|%{_prefix}|g; #/usr
1506 $macrostring =~ s|%{_prefix}|/usr|g; #/usr
1507 } # done with config section
1508
1509 # Package data
1510 if ($section =~ /p/) {
1511 $macrostring =~ s/\%\{buildroot\}/$buildroot/gi;
1512 foreach my $source (keys %{$pkgdata{sources}}) {
1513 $macrostring =~ s/\%\{source$source\}/$topdir\/SOURCES\/$pkgdata{sources}{$source}/gi;
1514 }
1515 $macrostring =~ s/\%\{name\}/$pkgdata{main}{name}/gi;
1516 $macrostring =~ s/\%\{version\}/$pkgdata{main}{version}/gi;
1517 $macrostring =~ s/\%\{release\}/$pkgdata{main}{release}/gi;
1518 }
1519
1520 # Globals, and not-so-globals
1521 if ($section =~ /g/) {
1522
1523 $macrostring =~ s|%{_builddir}|%{_topdir}/BUILD|g;
1524 $macrostring =~ s|%{_topdir}|$topdir|g;
1525 $macrostring =~ s|%{_tmppath}|$tmpdir|g;
1526 $macrostring =~ s'%{_docdir}'%{_datadir}/doc'g;
1527
1528 # Standard FHS locations. More or less.
1529 $macrostring =~ s'%{_bindir}'/usr/bin'g;
1530 $macrostring =~ s'%{_sbindir}'/usr/sbin'g;
1531 $macrostring =~ s'%{_mandir}'%{_datadir}/man'g;
1532 $macrostring =~ s'%{_includedir}'/usr/include'g;
1533 $macrostring =~ s'%{_libdir}'/usr/lib'g;
1534 $macrostring =~ s'%{_sysconfdir}'/etc'g;
1535 $macrostring =~ s'%{_localstatedir}'/var'g;
1536
1537 # FHS-ish locations that aren't quite actually FHS-specified.
1538 $macrostring =~ s'%{_datadir}'/usr/share'g;
1539
1540 # special %define's. Handle the general case where we eval anything.
1541 # Even more general: %(...) is a spec-parse-time shell code wrapper.
1542 # Prime example:
1543 #%define perl_vendorlib %(eval "`perl -V:installvendorlib`"; echo $installvendorlib)
1544 if ($macrostring =~ /\%\((.+)\)/) {
1545 my $shellstr = $1;
1546 # Oy vey this gets silly for the perl bits. Executing a shell to
1547 # call Perl to get the vendorlib/sitelib/whatever "core" globals.
1548 # This can do more, but... eww.
1549 $shellstr = qx { /bin/sh -c '$shellstr' }; # Yay! ' characters apparently get properly exscapededed.
1550 $macrostring =~ s/\%\(.+\)/$shellstr/;
1551 }
1552
1553 # support for **some** %if constructs. Note that this breaks somewhat if
1554 # there's no value specified... but so does rpm.
1555my $tmpcount = 0;
1556 while ($macrostring =~ /\%\{(!\?|\?!|\?)([a-z0-9_.-]+)(?:\:([a-z0-9_.-]+))?\}/g) { #Whew....
1557 my $qex = $1;
1558 my $macro = $2;
1559 my $value = $3;
1560
1561 my $neg = '1' if $qex =~ /\!/;
1562 if ($specglobals{$macro}) {
1563 $value = '' if $neg;
1564 } else {
1565 $value = '' if !$neg;
1566 }
1567 $macrostring =~ s/\%\{!?\?\!?[a-z0-9_.-]+(?:\:[a-z0-9_.-]+)?\}/$value/;
1568
1569# not certain about this, but I don't want to run away. It *can* happen if planned carefully. :/
1570$tmpcount++;
1571die "excessive recursive macro replacement; dying.\n" if $tmpcount > 6;
1572
1573 } # while()
1574
1575# should probably stick a "no runaway" flag in here... Just In Case...
1576 # %define's
1577 while (my ($key) = ($macrostring =~ /%{([a-z0-9]+)}/i) ) {
1578 $macrostring =~ s|%{$key}|$specglobals{$key}|g;
1579 # wanna limit this to "... if $specglobals{$key}", but need more magic
1580 }
1581
1582 # system programs. RPM uses a global config file for these; we'll just
1583 # ASS-U-ME and make life a little simpler.
1584 if ($macrostring =~ /\%\{\_\_([a-z0-9_-]+)\}/) {
1585 $macrostring =~ s|%{__([a-z0-9_-]+)}|$1|g;
1586 }
1587
1588 # Misc expansions
1589 $macrostring =~ s|%{_arch}|$hostarch|g;
1590 $macrostring =~ s|%{optflags}|$optflags{$hostarch}|g;
1591
1592 # Perl @INC/...lib locations, and other related bits.
1593 $macrostring =~ s|%{perl_archlib}|$Config{installarchlib}|g;
1594 $macrostring =~ s|%{perl_sitelib}|$Config{installsitelib}|g;
1595 $macrostring =~ s|%{perl_sitearch}|$Config{installsitearch}|g;
1596 $macrostring =~ s|%{perl_vendorlib}|$Config{installvendorlib}|g;
1597 $macrostring =~ s|%{perl_vendorarch}|$Config{installvendorarch}|g;
1598
1599 } # done with globals section
1600
1601 return $macrostring;
1602} # end expandmacros()
1603
1604
1605
1606__END__
1607
1608
1609
1610=head1 NAME
1611
1612debbuild - Build Debian-compatible packages from RPM spec files
1613
1614=head1 SYNOPSIS
1615
1616 debbuild {-ba|-bb|-bp|-bc|-bi|-bl|-bs} [build-options] file.spec
1617
1618 debbuild {-ta|-tb|-tp|-tc|-ti|-tl|-ts} [build-options] file.tar.{gz|bz2}
1619
1620 debbuild --rebuild file.{src.rpm|sdeb}
1621
1622 debbuild --showpkgs
1623
1624=head1 DESCRIPTION
1625
1626This script attempts to build Debian-friendly semi-native packages from RPM spec files,
1627RPM-friendly tarballs, and RPM source packages (.src.rpm files). It accepts I<most> of the
1628options rpmbuild does, and should be able to interpret most spec files usefully. Perl
1629modules should be handled via CPAN+dh-make-perl instead; Debian's conventions for such
1630things do not lend themselves to automated conversion.
1631
1632As far as possible, the command-line options are identical to those from rpmbuild, although
1633several rpmbuild options are not supported:
1634
1635 --recompile
1636 --showrc
1637 --buildroot
1638 --clean
1639 --nobuild
1640 --rmsource
1641 --rmspec
1642 --sign
1643 --target
1644
1645Some of these could probably be trivially added. Feel free to send me a patch. ;)
1646
1647Complex spec files will most likely not work well, if at all. Rewrite them from scratch -
1648you'll have to make heavy modifications anyway.
1649
1650If you see something you don't like, mail me. Send a patch if you feel inspired. I don't
1651promise I'll do anything other than say "Yup, that's broken" or "Got your message".
1652
1653=head1 ASSUMPTIONS
1654
1655As with rpmbuild, debbuild makes some assumptions about your system.
1656
1657=over 4
1658
1659=item *
1660
1661Either you have rights to do as you please under /usr/src/debian, or you have created a file
1662~/.debmacros containing a suitable %_topdir definition.
1663
1664Both rpmbuild and debbuild require the directories %_topdir/{BUILD,SOURCES,SPECS}. However,
1665where rpmbuild requires the %_topdir/{RPMS,SRPMS} directories, debbuild
1666requires %_topdir/{DEBS,SDEBS} instead. Create them in advance;
1667some subdirectories are created automatically as needed, but most are not.
1668
1669=item *
1670
1671/var/tmp must allow script execution - rpmbuild and debbuild both rely on creating and
1672executing shell scripts for much of their functionality. By default, debbuild also creates
1673install trees under /var/tmp - however this is (almost) entirely under the control of the
1674package's .spec file.
1675
1676=item *
1677
1678If you wish to --rebuild a .src.rpm, your %_topdir for both debbuild and rpmbuild must either
1679match, or be suitably symlinked one direction or another so that both programs are effectively
1680working in the same tree. (Or you could just manually wrestle files around your system.)
1681
1682You could symlink ~/.rpmmacros to ~/.debmacros (or vice versa) and save yourself some hassle
1683if you need to rebuild .src.rpm packages on a regular basis. Currently debbuild only uses the
1684%_topdir macro definition, although there are many more things that rpmbuild can use from
1685~/.rpmmacros.
1686
1687=back
1688
1689=head1 ERRATA
1690
1691debbuild deliberately does a few things differently from rpm.
1692
1693=head2 BuildArch or BuildArchitecture
1694
1695rpm takes the last BuildArch entry it finds in the .spec file, whatever it is, and runs with
1696that for all packages. Debian's repository system is fairly heavily designed around the
1697assumption that a single source package may generate small binary (executable) packages
1698for each arch, and large binary arch-all packages containing shared data.
1699
1700debbuild allows this by using the architecture specified by (in order of preference):
1701
1702=over 4
1703
1704=item * Host architecture
1705
1706=item * BuildArch specified in .spec file preamble
1707
1708=item * "Last specified" BuildArch for packages with several subpackages
1709
1710=item * BuildArch specified in the %package section for that subpackage
1711
1712=back
1713
1714=head2 Finding out what packages should be built (--showpkgs)
1715
1716rpmbuild does not include any convenient method I know of to list the packages a spec file
1717will produce. Since I needed this ability for another tool, I added it.
1718
1719It requires the .spec file for the package, and produces a list of full package filenames
1720(without path data) that would be generated by one of --rebuild, -ta, -tb, -ba, or -bb.
1721This includes the .sdeb source package.
1722
1723=head1 AUTHOR
1724
1725debbuild was written by Kris Deugau <kdeugau@deepnet.cx>. A version that approximates
1726current is available at http://www.deepnet.cx/debbuild/.
1727
1728=head1 BUGS
1729
1730Funky Things Happen if you forget a command-line option or two. I've been too lazy to bother
1731fixing this.
1732
1733Many macro expansions are unsupported or incompletely supported.
1734
1735The generated scriptlets don't quite match those from rpmbuild exactly. There are extra
1736environment variables and preprocessing that I haven't needed (yet).
1737
1738Dcumentation, such as it is, will likely remain perpetually out of date.
1739
1740%_topdir and the five "working" directories under %_topdir could arguably be created by
1741debbuild. However, rpmbuild doesn't create these directories either.
1742
1743=head1 SEE ALSO
1744
1745rpm(8), rpmbuild(8), and pretty much any document describing how to write a .spec file.
1746
1747=cut
Note: See TracBrowser for help on using the repository browser.