source: trunk/debbuild@ 149

Last change on this file since 149 was 149, checked in by kdeugau, 15 years ago

/trunk

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