source: trunk/debbuild@ 172

Last change on this file since 172 was 172, checked in by kdeugau, 12 years ago

/trunk

Handle multiple recommends/suggests/enhances/replaces/requires/conflicts/provides
lines in subpackages correctly by appending instead of overwriting any previous entries.

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