source: trunk/debbuild@ 147

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

/trunk

Fix a new edge case in library dependency autodetection where a given
file-soname is in fact provided by *several* packages, in several different
lib dirs:

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