source: trunk/debbuild@ 170

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

/trunk

A handful of small polish tweaks.

  • Set a default buildroot to match rpm (at least as of Debian's release in wheezy)
  • Print collected messages when just building the source package
  • Skip comments in %description; mainly useful for trimming comments leading into the next section
  • Property svn:executable set to *
  • Property svn:keywords set to Date Rev Author
File size: 67.9 KB
Line 
1#!/usr/bin/perl -w
2# debbuild script
3# Shamelessly steals interface from rpm's "rpmbuild" to create
4# Debian packages. Please note that such packages are highly
5# unlikely to conform to "Debian Policy".
6###
7# SVN revision info
8# $Date: 2012-09-21 16:18:16 +0000 (Fri, 21 Sep 2012) $
9# SVN revision $Rev: 170 $
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;
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 # This really should be local-ish, but we need just the filename for the source
674 $pkgdata{main}{source} =~ s|.+/([^/]+)$|$1|;
675 # Replace some core macros
676 $pkgdata{main}{source} = expandmacros($pkgdata{main}{source},'gp');
677 next LINE;
678 } # %prep
679
680 if (/^\%build/) {
681 $stage = 'build';
682 $buildscript .= "cd $tarballdir\n";
683 next LINE;
684 } # %build
685
686 if (/^\%install/) {
687 $stage = 'install';
688 $installscript .= "cd $tarballdir\n";
689 next LINE;
690 } # %install
691
692 if (/^\%clean/) {
693 $stage = 'clean';
694 $cleanscript .= "cd $tarballdir\n";
695 next LINE;
696 } # %clean
697
698 if (/^\%(pre|post|preun|postun)\b(?:\s+(?:-n\s+)?(.+))?/i) {
699 $stage = 'prepost';
700 $scriptlet = lc $1;
701 $subname = 'main';
702 if ($2) { # Magic to add entries to the right package
703 my $tmp = expandmacros("$2", 'g');
704 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
705 }
706 next LINE;
707 } # %pre/%post/%preun/%postun
708
709 if (/^\%files(?:\s+(?:-n\s+)?(.+))?/) {
710 $stage = 'files';
711 $subname = 'main';
712 if ($1) { # Magic to add entries to the right list of files
713 my $tmp = expandmacros("$1", 'gp');
714 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
715 }
716 next LINE;
717 } # %files
718
719 if (/^\%changelog/) {
720 $stage = 'changelog';
721 $pkgdata{main}{changelog} = '';
722 next LINE;
723 }
724
725# now we handle individual lines from the various sections
726
727 if ($stage eq 'desc') {
728 next LINE if /^\s*#/;
729 $pkgdata{$subname}{desc} .= " $_";
730 } # description
731
732 if ($stage eq 'package') {
733 # gotta expand %defines here. Whee.
734# Note that we look for the Debian-specific Recommends, Suggests, and Replaces,
735# although they will have to be wrapped in '%if %{_vendor} == "debbuild"' for
736# an rpmbuild-compatible .spec file
737# NB: NOT going to support Pre-Depends, since it's a "Don't Use" (mis)feature, and
738# RPM's support for a similar tag (PreReq) has been recently dropped.
739 if (my ($dname,$dvalue) = (/^(Recommends|Suggests|Enhances|Replaces|Summary|Group|Version|Requires|Conflicts|Provides|BuildArch(?:itecture)?):\s+(.+)$/i)) {
740 $dname =~ tr/[A-Z]/[a-z]/;
741 if ($dname =~ /^BuildArch/i) {
742 $dvalue =~ s/^noarch/all/ig;
743 $buildarch = $dvalue; # Emulate rpm's behaviour to a degree
744 $dname = 'arch';
745 }
746 $pkgdata{$subname}{$dname} = expandmacros($dvalue, 'gp');
747 }
748 } # package
749
750 if ($stage eq 'prep') {
751 # Actual handling for %prep section. May have %setup macro; may
752 # include %patch tags, may be just a bare shell script.
753 if (/^\%setup/) {
754 # Parse out the %setup macro. Note that we aren't supporting
755 # many of RPM's %setup features.
756 $prepscript .= "cd $topdir/BUILD\n";
757 if ( /\s+-n\s+([^\s]+)\s+/ ) {
758 $tarballdir = $1;
759 }
760 $tarballdir = expandmacros($tarballdir,'gp');
761 $prepscript .= "rm -rf $tarballdir\n";
762 if (/\s+-c\s+/) {
763 $prepscript .= "mkdir $tarballdir\ncd $tarballdir\n";
764 }
765 $prepscript .= "tar -".
766 ( $pkgdata{main}{source} =~ /\.tar\.gz$/ ? "z" : "" ).
767 ( $pkgdata{main}{source} =~ /\.tar\.bz2$/ ? "j" : "" ).
768 ( /\s+-q\s+/ ? '' : 'vv' )."xf ".
769 "$topdir/SOURCES/$pkgdata{main}{source}\n".
770 qq(STATUS=\$?\nif [ \$STATUS -ne 0 ]; then\n exit \$STATUS\nfi\n).
771 "cd $topdir/BUILD/$tarballdir\n".
772 qq([ `/usr/bin/id -u` = '0' ] && /bin/chown -Rhf root .\n).
773 qq([ `/usr/bin/id -u` = '0' ] && /bin/chgrp -Rhf root .\n).
774 qq(/bin/chmod -Rf a+rX,g-w,o-w .\n);
775 } elsif ( my ($patchnum,$patchopts) = (/^\%patch([^\s]+)(\s+.+)?$/) ) {
776 chomp $patchnum;
777 $prepscript .= qq(echo "Patch #$patchnum ($pkgdata{main}{"patch$patchnum"}):"\n);
778 # If there are options passed, use'em.
779 # Otherwise, catch a bare %patch and ASS-U-ME it's '-p0'-able.
780 # Will break on options that don't provide -pnn, but what the hell.
781 # Need to decompress .bz2 and .gz patches on the fly. Not sure why one
782 # would ever have such things, but there they are... and rpmbuild supports 'em
783 # patch originally suggested by Lucian Cristian for .bz2
784 # reworked and expanded to support .Z/.gz as well
785 if ( $pkgdata{main}{"patch$patchnum"} =~ /\.(?:Z|gz|bz2)$/ ) {
786 my $decompressor;
787 $decompressor = 'gzip' if $pkgdata{main}{"patch$patchnum"} =~ /\.(?:Z|gz)$/;
788 $decompressor = 'bzip2' if $pkgdata{main}{"patch$patchnum"} =~ /\.bz2$/;
789 $prepscript .= qq(/bin/$decompressor -d < $topdir/SOURCES/$pkgdata{main}{"patch$patchnum"} | patch );
790 $prepscript .= $patchopts if $patchopts;
791 $prepscript .= "-p0" if !$patchopts;
792 $prepscript .= qq( -s\nSTATUS=\$?\nif [ \$STATUS -ne 0 ]; then\n exit \$STATUS\nfi\n);
793 } else {
794 $prepscript .= "patch ";
795 $prepscript .= $patchopts if $patchopts;
796 $prepscript .= "-p0" if !$patchopts;
797 $prepscript .= " -s <$topdir/SOURCES/".$pkgdata{main}{"patch$patchnum"}."\n";
798 }
799 } else {
800 $prepscript .= expandmacros($_,'gp');
801 }
802 next LINE;
803 } # prep
804
805 if ($stage eq 'build') {
806 # %build. This is pretty much just a shell script. There
807 # aren't many local macros to deal with.
808 if (/^\%configure/) {
809 $buildscript .= expandmacros($_,'cgbp');
810 } elsif (/^\%\{__make\}/) {
811 $buildscript .= expandmacros($_,'mgbp');
812 } else {
813 $buildscript .= expandmacros($_,'gp');
814 }
815 next LINE;
816 } # build
817
818 if ($stage eq 'install') {
819 if (/^\%makeinstall/) {
820 $installscript .= expandmacros($_,'igbp');
821 } else {
822 $installscript .= expandmacros($_,'gp');
823 }
824 next LINE;
825 } # install
826
827 if ($stage eq 'clean') {
828 $cleanscript .= expandmacros($_,'gp');
829 next LINE;
830 } # clean
831
832 if ($stage eq 'prepost') {
833 $pkgdata{$subname}{$scriptlet} .= expandmacros($_,'gp');
834 next LINE;
835 } # prepost
836
837 if ($stage eq 'files') {
838 # need to deal with these someday
839 next LINE if /^\%dir/;
840 next LINE if /^\%defattr/;
841 next LINE if /^\%verify/;
842 # dunno what to do with this; not sure if there's space in Debian's package structure for it.
843 next LINE if /^\%ghost/;
844 # Debian dpkg doesn't speak "%docdir". Meh.
845 next LINE if /^\%docdir/;
846# my $singleton = 0; # don't recall what this was for
847 next LINE if /^\s*#/;
848 next LINE if /^\s*$/;
849
850# create and initialize flags
851 my ($perms, $owner, $group, $conf, $filesline);
852 $perms = $owner = $group = $conf = '-';
853
854 $filesline = $_;
855
856 # strip and flag %attr constructs
857 if ($filesline =~ /\%attr\b/) {
858 # Extract %attr...
859 my ($args) = (/(\%attr\s*\(\s*[\d-]+\s*,\s*["a-zA-Z0-9-]+\s*,\s*["a-zA-Z0-9-]+\s*\))/);
860 $args =~ s/\s+//g;
861 $args =~ s/"//g; # don't think quotes are ever necessary, but they're *allowed*
862 # ... and parse it ...
863 ($perms,$owner,$group) = ($args =~ /\(([\d-]+),([a-zA-Z0-9-]+),([a-zA-Z0-9-]+)/);
864 # ... and wipe it when we're done.
865 $filesline =~ s/\%attr\s*\(\s*[\d-]+\s*,\s*["a-zA-Z0-9-]+\s*,\s*["a-zA-Z0-9-]+\s*\)//;
866 }
867
868 # Conffiles. Note that Debian and RH have similar, but not
869 # *quite* identical ideas of what constitutes a conffile. Nrgh.
870 # Note that dpkg will always ask if you want to replace the file - noreplace
871 # is more or less permanently enabled.
872##fixme
873# also need to handle missingok (file that doesn't exist, but should be removed on uninstall)
874# hmm. not sure if such is **POSSIBLE** with Debian... maybe an addition to %post?
875 if ($filesline =~ /\%config\b(?:\s*\(\s*noreplace\s*\)\s*)?/) {
876 $pkgdata{$subname}{conffiles} = 1; # Flag it for later
877 $conf = 'y';
878 $filesline =~ s/\%config\b(?:\s*\(\s*noreplace\s*\)\s*)?//;
879 }
880
881 # %doc needs extra processing, because it can be a space-separated list, and may
882 # include both full and partial pathnames. The partial pathnames must be fiddled
883 # into place in the %install script, because Debian doesn't really have the concept
884 # of "documentation file" that rpm does. (Debian "documentation files" are files
885 # in /usr/share/doc/<packagename>.)
886##fixme: unhandled case: %doc %defattr. Eeep.
887# don't really know what to do with %defattr, generally. :(
888 if ($filesline =~ /\%doc\b/) {
889 $filesline =~ s/\s*\%doc\s+//;
890
891# this could probably go elsewhere.
892 my $pkgname = $pkgdata{$subname}{name};
893 $pkgname =~ tr/_/-/;
894
895 # have to extract the partial pathnames that %doc installs automagically
896 foreach (split /\s+/, $filesline) {
897 if (! (/^\%/ or m|^/|) ) {
898 $doclist{$subname} .= " $_";
899 my ($element) = m|([^/\s]+/?)$|;
900 $filesline =~ s|$_|\%{_docdir}/$pkgname/$element|;
901 }
902 }
903 } # $filesline =~ /\%doc\b/
904
905 $filesline =~ s/^\s*//; # Just In Case. For, uh, neatness.
906
907# due to Debian's total lack of real permissions-processing in its actual package
908# handling component (dpkg-deb), this can't really be done "properly". We'll have
909# to add chown/chmod commands to the postinst instead. Feh.
910 $pkgdata{$subname}{'post'} .= "chown $owner $filesline\n" if $owner ne '-';
911 $pkgdata{$subname}{'post'} .= "chgrp $group $filesline\n" if $group ne '-';
912 $pkgdata{$subname}{'post'} .= "chmod $perms $filesline\n" if $perms ne '-';
913
914##fixme
915# need hackery to assure only one filespec per %config. NB: "*" is one filespec. <g>
916 push @{$pkgdata{$subname}{conflist}}, $filesline if $conf ne '-';
917
918 # now that we've got the specials out of the way, we can add things to the appropriate list of files.
919 # ... and finally everything else
920 $filelist{$subname} .= " $filesline";
921
922 next LINE;
923 } # files
924
925 if ($stage eq 'changelog') {
926 # this is one of the few places we do NOT generally want to replace macros...
927 $pkgdata{main}{changelog} .= $_;
928 }
929
930 if ($stage eq 'preamble') {
931 if (/^summary:\s*(.+)/i) {
932 $pkgdata{main}{summary} = $1;
933 } elsif (/^name:\s*(.+)/i) {
934 $pkgdata{main}{name} = expandmacros($1,'g');
935 } elsif (/^epoch:\s*(.+)/i) {
936 $pkgdata{main}{epoch} = expandmacros($1,'g');
937 } elsif (/^version:\s*(.+)/i) {
938 $pkgdata{main}{version} = expandmacros($1,'g');
939 } elsif (/^release:\s*(.+)/i) {
940 $pkgdata{main}{release} = expandmacros($1,'g');
941 } elsif (/^group:\s*(.+)/i) {
942 $pkgdata{main}{group} = $1;
943 } elsif (/^copyright:\s*(.+)/i) {
944 $pkgdata{main}{copyright} = $1;
945 } elsif (/^url:\s*(.+)/i) {
946 $pkgdata{main}{url} = $1;
947 } elsif (/^packager:\s*(.+)/i) {
948 $pkgdata{main}{packager} = $1;
949 } elsif (/^buildroot:\s*(.+)/i) {
950 $specglobals{buildroot} = $1;
951 } elsif (/^source0?:\s*(.+)/i) {
952 $pkgdata{main}{source} = $1;
953 # .tar, .tar.gz, .tar.bz2, .tgz
954 die "Unknown tarball format $1\n" if $1 !~ /\.(?:tar(?:\.(?:gz|bz2))?|tgz)$/;
955 } elsif (/^source([0-9]+):\s*(.+)/i) {
956 $pkgdata{sources}{$1} = $2;
957 } elsif (/^patch([^:]+):\s*(.+)$/i) {
958 my $patchname = "patch$1";
959 $pkgdata{main}{$patchname} = $2;
960 if ($pkgdata{main}{$patchname} =~ /\//) {
961 # URL-style patch. Rare but not unheard-of.
962 my @patchbits = split '/', $pkgdata{main}{$patchname};
963 $pkgdata{main}{$patchname} = $patchbits[$#patchbits];
964 }
965 chomp $pkgdata{main}{$patchname};
966 } elsif (/^buildarch(?:itecture)?:\s*(.+)/i) {
967 $pkgdata{main}{arch} = $1;
968 $pkgdata{main}{arch} =~ s/^noarch$/all/;
969 $buildarch = $pkgdata{main}{arch};
970 } elsif (/^buildrequires:\s*(.+)/i) {
971 $buildreq .= ", $1";
972 } elsif (/^requires:\s*(.+)/i) {
973 $pkgdata{main}{requires} .= ", ".expandmacros("$1", 'gp');
974 } elsif (/^provides:\s*(.+)/i) {
975 $pkgdata{main}{provides} .= ", $1";
976 } elsif (/^conflicts:\s*(.+)/i) {
977 $pkgdata{main}{conflicts} .= ", $1";
978 } elsif (/^recommends:\s*(.+)/i) {
979 $pkgdata{main}{recommends} .= ", $1";
980 warn "Warning: Debian-specific 'Recommends:' outside \%if wrapper\n" if $iflevel == 0;
981 } elsif (/^suggests:\s*(.+)/i) {
982 $pkgdata{main}{suggests} .= ", $1";
983 warn "Warning: Debian-specific 'Suggests:' outside \%if wrapper\n" if $iflevel == 0;
984 } elsif (/^enhances:\s*(.+)/i) {
985 $pkgdata{main}{enhances} .= ", $1";
986 warn "Warning: Debian-specific 'Enhances:' outside \%if wrapper\n" if $iflevel == 0;
987 } elsif (/^replaces:\s*(.+)/i) {
988 $pkgdata{main}{replaces} .= ", $1";
989 warn "Warning: Debian-specific 'Replaces:' outside \%if wrapper\n" if $iflevel == 0;
990 } elsif (/^autoreq(?:prov)?:\s*(.+)/i) {
991 # we don't handle auto-provides (yet)
992 $NoAutoReq = 1 if $1 =~ /(?:no|0)/i;
993 }
994 next LINE;
995 } # preamble
996
997 } # while <SPEC>
998
999 # Parse and replace some more macros. More will be replaced even later.
1000
1001 # Expand macros as necessary.
1002 $scriptletbase = expandmacros($scriptletbase,'gp');
1003
1004 $cleanscript = expandmacros($cleanscript,'gp');
1005
1006 $specglobals{buildroot} = $cmdbuildroot if $cmdbuildroot;
1007 $specglobals{buildroot} = expandmacros($specglobals{buildroot},'gp');
1008
1009 close SPECFILE;
1010} # end parse_spec()
1011
1012
1013## prep()
1014# Writes and executes the %prep script (mostly) built while reading the spec file.
1015sub prep {
1016 # Replace some things here just to make sure.
1017 $prepscript = expandmacros($prepscript,'gp');
1018
1019 # create script filename
1020 my $prepscriptfile = "$tmpdir/deb-tmp.prep.".int(rand(99998)+1);
1021 sysopen(PREPSCRIPT, $prepscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1022 or die "Can't open/create prep script file $prepscriptfile: $!\n";
1023 print PREPSCRIPT $scriptletbase;
1024 print PREPSCRIPT $prepscript;
1025 close PREPSCRIPT;
1026
1027 # execute
1028 print "Calling \%prep script $prepscriptfile...\n";
1029 system("/bin/sh -e $prepscriptfile") == 0
1030 or die "Can't exec: $!\n";
1031
1032 # and clean up
1033 unlink $prepscriptfile;
1034} # end prep()
1035
1036
1037## build()
1038# Writes and executes the %build script (mostly) built while reading the spec file.
1039sub build {
1040 # Expand the macros
1041 $buildscript = expandmacros($buildscript,'cgbp');
1042
1043 # create script filename
1044 my $buildscriptfile = "$tmpdir/deb-tmp.build.".int(rand(99998)+1);
1045 sysopen(BUILDSCRIPT, $buildscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1046 or die "Can't open/create build script file $buildscriptfile: $!\n";
1047 print BUILDSCRIPT $scriptletbase;
1048 print BUILDSCRIPT $buildscript;
1049 close BUILDSCRIPT;
1050
1051 # execute
1052 print "Calling \%build script $buildscriptfile...\n";
1053 system("/bin/sh -e $buildscriptfile") == 0
1054 or die "Can't exec: $!\n";
1055
1056 # and clean up
1057 unlink $buildscriptfile;
1058} # end build()
1059
1060
1061## install()
1062# Writes and executes the %install script (mostly) built while reading the spec file.
1063sub install {
1064
1065 # munge %doc entries into place
1066 # rpm handles this with a separate executed %doc script, we're not going to bother.
1067 foreach my $docpkg (keys %doclist) {
1068 my $pkgname = $pkgdata{$docpkg}{name};
1069 $pkgname =~ s/_/-/g;
1070
1071 $installscript .= "DOCDIR=\$RPM_BUILD_ROOT\%{_docdir}/$pkgname\nexport DOCDIR\n";
1072 $installscript .= "mkdir -p \$DOCDIR\n";
1073 $doclist{$docpkg} =~ s/^\s*//;
1074 foreach (split(' ',$doclist{$docpkg})) {
1075 $installscript .= "cp -pr $_ \$DOCDIR/\n";
1076 }
1077 }
1078
1079 # Expand the macros
1080 $installscript = expandmacros($installscript,'igbp');
1081
1082 # create script filename
1083 my $installscriptfile = "$tmpdir/deb-tmp.inst.".int(rand(99998)+1);
1084 sysopen(INSTSCRIPT, $installscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1085 or die "Can't open/create install script file $installscriptfile: $!\n";
1086 print INSTSCRIPT $scriptletbase;
1087 print INSTSCRIPT $installscript;
1088 close INSTSCRIPT;
1089
1090 # execute
1091 print "Calling \%install script $installscriptfile...\n";
1092 system("/bin/sh -e $installscriptfile") == 0
1093 or die "Can't exec: $!\n";
1094
1095 # and clean up
1096 unlink $installscriptfile;
1097
1098 # final bit: compress manpages if present
1099 # done here cuz I don't grok shell well
1100 # should probably error-check all kinds of things. <g>
1101 if (opendir MANROOT, "$specglobals{buildroot}/usr/share/man") {
1102 my @mansects = readdir MANROOT;
1103 closedir MANROOT;
1104 foreach my $mandir (@mansects) {
1105 next if $mandir !~ /^man/;
1106 opendir MANPAGES, "$specglobals{buildroot}/usr/share/man/$mandir";
1107 my @pagelist = readdir MANPAGES;
1108 closedir MANPAGES; # Slightly safer to to this; no accidental recursion. O_o
1109 foreach my $manpage (@pagelist) {
1110 $manpage = "$specglobals{buildroot}/usr/share/man/$mandir/$manpage";
1111 if ( -f $manpage) {
1112 if ($manpage =~ /^(.+)\.(?:Z|gz|bz2)\n?$/) {
1113 my $newpage = $1;
1114 `gunzip $manpage` if $manpage =~ /\.(?:Z|gz)$/;
1115 `bunzip2 $manpage` if $manpage =~ /\.bz2$/;
1116 $manpage = $newpage;
1117 }
1118 `gzip -9 -n $manpage`;
1119 } elsif ( -l $manpage) {
1120 my $linkdest = readlink $manpage;
1121 $linkdest =~ s/\.(?:Z|gz|bz2)//;
1122 unlink $manpage;
1123 $manpage =~ s/\.(?:Z|gz|bz2)//;
1124 symlink "$linkdest.gz", "$manpage.gz" or print "DEBUG: wibble: symlinking manpage failed: $!\n";
1125 }
1126 }
1127 }
1128 } # if opendir MANROOT
1129} # end install()
1130
1131
1132## binpackage()
1133# Creates the binary .deb package from the installed tree in $specglobals{buildroot}.
1134# Writes and executes a shell script to do so.
1135# Creates miscellaneous files required by dpkg-deb to actually build the package file.
1136# Should handle simple subpackages
1137sub binpackage {
1138
1139 foreach my $pkg (@pkglist) {
1140
1141 $pkgdata{$pkg}{arch} = $hostarch if !$pkgdata{$pkg}{arch}; # Just In Case.
1142
1143 # Make sure we have somewhere to write the .deb file
1144 if (!-e "$topdir/DEBS/$pkgdata{$pkg}{arch}") {
1145 mkdir "$topdir/DEBS/$pkgdata{$pkg}{arch}";
1146 }
1147
1148 # Skip building a package if it doesn't actually have any files. NB: This
1149 # differs slightly from rpm's behaviour where a package *will* be built -
1150 # even without any files - if %files is specified anywhere. I can think
1151 # of odd corner cases where that *may* be desireable.
1152 next if (!$filelist{$pkg} or $filelist{$pkg} =~ /^\s*$/);
1153
1154 # Gotta do this first, otherwise we don't have a place to move files from %files
1155 mkdir "$specglobals{buildroot}/$pkg";
1156
1157 # Eliminate any lingering % macros
1158 $filelist{$pkg} = expandmacros $filelist{$pkg}, 'g';
1159
1160 my @pkgfilelist = split ' ', $filelist{$pkg};
1161 foreach my $pkgfile (@pkgfilelist) {
1162 $pkgfile = expandmacros($pkgfile, 'gp');
1163
1164 # Feh. Manpages don't **NEED** to be gzipped, but rpmbuild does, and so shall we.
1165 # ... and your little info page too!
1166 if ($pkgfile =~ m{/usr/share/(?:man/man|info)}) {
1167 # need to check to see if manpage is gzipped
1168 if (-e "$specglobals{buildroot}$pkgfile") {
1169 # if we've just been pointed to a manpage section with "many" pages,
1170 # we need to gzip them all.
1171 # fortunately, we do NOT need to explicitly track each file for the
1172 # purpose of stuffing them in the package... the original %files
1173 # entry will do just fine.
1174 if ( -d "$specglobals{buildroot}$pkgfile") {
1175 foreach my $globfile (glob("$specglobals{buildroot}$pkgfile/*")) {
1176 gzip $globfile if $globfile !~ m|\.gz$|;
1177 }
1178 } else {
1179 if ($pkgfile !~ m|\.gz$|) {
1180 qx { gzip $specglobals{buildroot}$pkgfile };
1181 $pkgfile .= ".gz";
1182 }
1183 }
1184 } else {
1185 if ($pkgfile !~ m|\.gz$|) {
1186 $pkgfile .= ".gz";
1187 } else {
1188 $pkgfile =~ s/\.gz$//;
1189 qx { gzip $specglobals{buildroot}$pkgfile };
1190 $pkgfile .= ".gz";
1191 }
1192 }
1193 }
1194
1195 my ($fpath,$fname) = ($pkgfile =~ m|(.+?/?)?([^/]+/?)$|); # We don't need $fname now, but we might.
1196 qx { mkdir -p $specglobals{buildroot}/$pkg$fpath }
1197 if $fpath && $fpath ne '';
1198 qx { mv $specglobals{buildroot}$pkgfile $specglobals{buildroot}/$pkg$fpath };
1199 }
1200
1201 # Get the "Depends" (Requires) a la RPM. Ish. We strip the leading
1202 # comma and space here (if needed) in case there were "Requires" specified
1203 # in the spec file - those would precede these.
1204 $pkgdata{$pkg}{requires} .= getreqs("$specglobals{buildroot}/$pkg") if ! $NoAutoReq;
1205
1206 # magic needed to properly version dependencies...
1207 # only provided deps will really be included
1208 $pkgdata{$pkg}{requires} =~ s/^, //; # Still have to do this here.
1209 $pkgdata{$pkg}{requires} =~ s/\s+//g;
1210 my @deps = split /,/, $pkgdata{$pkg}{requires};
1211 my $tmp = '';
1212 foreach my $dep (@deps) {
1213 # Hack up the perl(Class::SubClass) deps into something dpkg can understand.
1214 # May or may not be versioned.
1215 # We do this first so the version rewriter can do its magic next.
1216 if (my ($mod,$ver) = ($dep =~ /^perl\(([A-Za-z0-9\:\-]+)\)([><=]+.+)?/) ) {
1217 $mod =~ s/^perl\(//;
1218 $mod =~ s/\)$//;
1219 $mod =~ s/::/-/g;
1220 $mod =~ tr/A-Z/a-z/;
1221 $mod = "lib$mod-perl";
1222 $mod .= $ver if $ver;
1223 $dep = $mod;
1224 }
1225 if (my ($name,$rel,$value) = ($dep =~ /^([a-zA-Z0-9._-]+)([><=]+)([a-zA-Z0-9._-]+)$/)) {
1226 $tmp .= ", $name ($rel $value)";
1227 } else {
1228 $tmp .= ", $dep";
1229 }
1230 }
1231 ($pkgdata{$pkg}{requires} = $tmp) =~ s/^, //;
1232
1233 # Do this here since we're doing {depends}...
1234 if (defined($pkgdata{$pkg}{provides})) {
1235 $pkgdata{$pkg}{provides} =~ s/^, //;
1236 $pkgdata{$pkg}{provides} = expandmacros($pkgdata{$pkg}{provides},'gp');
1237 }
1238 if (defined($pkgdata{$pkg}{conflicts})) {
1239 $pkgdata{$pkg}{conflicts} =~ s/^, //;
1240 $pkgdata{$pkg}{conflicts} = expandmacros($pkgdata{$pkg}{conflicts},'gp');
1241 }
1242
1243# These are Debian-specific!
1244 if (defined($pkgdata{$pkg}{recommends})) {
1245 $pkgdata{$pkg}{recommends} =~ s/^, //;
1246 $pkgdata{$pkg}{recommends} = expandmacros($pkgdata{$pkg}{recommends},'gp');
1247 }
1248 if (defined($pkgdata{$pkg}{suggests})) {
1249 $pkgdata{$pkg}{suggests} =~ s/^, //;
1250 $pkgdata{$pkg}{suggests} = expandmacros($pkgdata{$pkg}{suggests},'gp');
1251 }
1252 if (defined($pkgdata{$pkg}{enhances})) {
1253 $pkgdata{$pkg}{enhances} =~ s/^, //;
1254 $pkgdata{$pkg}{enhances} = expandmacros($pkgdata{$pkg}{enhances},'gp');
1255 }
1256 if (defined($pkgdata{$pkg}{replaces})) {
1257 $pkgdata{$pkg}{replaces} =~ s/^, //;
1258 $pkgdata{$pkg}{replaces} = expandmacros($pkgdata{$pkg}{replaces},'gp');
1259 }
1260
1261 # Gotta do this next, otherwise the control file has nowhere to go. >:(
1262 mkdir "$specglobals{buildroot}/$pkg/DEBIAN";
1263
1264 # Hack the filename for the package into a Debian-tool-compatible format. GRRRRRR!!!!!
1265 # Have I mentioned I hate Debian Policy?
1266 $pkgdata{$pkg}{name} =~ tr/_/-/;
1267
1268 # create script filename
1269 my $debscriptfile = "$tmpdir/deb-tmp.pkg.".int(rand(99998)+1);
1270 sysopen(DEBSCRIPT, $debscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1271 or die "Can't open/create package-creation script file $debscriptfile: $!\n";
1272 print DEBSCRIPT $scriptletbase;
1273 print DEBSCRIPT "fakeroot -- dpkg-deb -b $specglobals{buildroot}/$pkg $topdir/DEBS/$pkgdata{$pkg}{arch}/".
1274 "$pkgdata{$pkg}{name}_".
1275 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1276 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb\n";
1277 # %$&$%@#@@#%@@@ Debian and their horrible ugly package names. >:(
1278 close DEBSCRIPT;
1279
1280 my $control = "Package: $pkgdata{$pkg}{name}\n".
1281 "Version: ".
1282 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1283 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}\n".
1284 "Section: $pkgdata{$pkg}{group}\n".
1285 "Priority: optional\n".
1286 "Architecture: $pkgdata{$pkg}{arch}\n".
1287 "Maintainer: $pkgdata{main}{packager}\n".
1288 ( $pkgdata{$pkg}{requires} ne '' ? "Depends: $pkgdata{$pkg}{requires}\n" : '' ).
1289 ( defined($pkgdata{$pkg}{provides}) ? "Provides: $pkgdata{$pkg}{provides}\n" : '' ).
1290 ( defined($pkgdata{$pkg}{conflicts}) ? "Conflicts: $pkgdata{$pkg}{conflicts}\n" : '' ).
1291 ( defined($pkgdata{$pkg}{recommends}) ? "Recommends: $pkgdata{$pkg}{recommends}\n" : '' ).
1292 ( defined($pkgdata{$pkg}{suggests}) ? "Suggests: $pkgdata{$pkg}{suggests}\n" : '' ).
1293 ( defined($pkgdata{$pkg}{enhances}) ? "Enhances: $pkgdata{$pkg}{enhances}\n" : '' ).
1294 ( defined($pkgdata{$pkg}{replaces}) ? "Replaces: $pkgdata{$pkg}{replaces}\n" : '' ).
1295 "Description: $pkgdata{$pkg}{summary}\n";
1296 # Munge things so that Debian tools don't choke on errant blank lines
1297 $pkgdata{$pkg}{desc} =~ s/\s+$//g; # Trim trailing blanks
1298 $pkgdata{$pkg}{desc} =~ s/^ $/ ./mg; # Replace lines consisting of " \n" with " .\n"
1299 $control .= "$pkgdata{$pkg}{desc}\n";
1300
1301 open CONTROL, ">$specglobals{buildroot}/$pkg/DEBIAN/control";
1302 print CONTROL $control;
1303 close CONTROL;
1304
1305 # Iff there are conffiles (as specified in the %files list(s), add'em
1306 # in so dpkg-deb can tag them.
1307 if ($pkgdata{$pkg}{conffiles}) {
1308 open CONFLIST, ">$specglobals{buildroot}/$pkg/DEBIAN/conffiles";
1309 foreach my $conffile (@{$pkgdata{$pkg}{conflist}}) {
1310 $conffile = expandmacros($conffile, 'g');
1311 my @tmp = glob "$specglobals{buildroot}/$pkg/$conffile";
1312 foreach (@tmp) {
1313 s|$specglobals{buildroot}/$pkg/||g; # nrgl. gotta be a better way to do this...
1314 s/\s+/\n/g; # Not gonna support spaces in filenames. Ewww.
1315 print CONFLIST "$_\n";
1316 }
1317 }
1318 close CONFLIST;
1319 }
1320
1321 # found the point of scripts on subpackages.
1322 if ($pkgdata{$pkg}{'pre'}) {
1323 $pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'pre'},'gp');
1324 open PREINST, ">$specglobals{buildroot}/$pkg/DEBIAN/preinst";
1325 print PREINST "#!/bin/sh\nset -e\n\n";
1326 print PREINST $pkgdata{$pkg}{'pre'};
1327 close PREINST;
1328 chmod 0755, "$specglobals{buildroot}/$pkg/DEBIAN/preinst";
1329 }
1330 if ($pkgdata{$pkg}{'post'}) {
1331 $pkgdata{$pkg}{'post'} = expandmacros($pkgdata{$pkg}{'post'},'gp');
1332 open POSTINST, ">$specglobals{buildroot}/$pkg/DEBIAN/postinst";
1333 print POSTINST "#!/bin/sh\nset -e\n\n";
1334 print POSTINST $pkgdata{$pkg}{'post'};
1335 close POSTINST;
1336 chmod 0755, "$specglobals{buildroot}/$pkg/DEBIAN/postinst";
1337 }
1338 if ($pkgdata{$pkg}{'preun'}) {
1339 $pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'preun'},'gp');
1340 open PREUNINST, ">$specglobals{buildroot}/$pkg/DEBIAN/prerm";
1341 print PREUNINST "#!/bin/sh\nset -e\n\n";
1342 print PREUNINST $pkgdata{$pkg}{'preun'};
1343 close PREUNINST;
1344 chmod 0755, "$specglobals{buildroot}/$pkg/DEBIAN/prerm";
1345 }
1346 if ($pkgdata{$pkg}{'postun'}) {
1347 $pkgdata{$pkg}{'postun'} = expandmacros($pkgdata{$pkg}{'postun'},'gp');
1348 open POSTUNINST, ">$specglobals{buildroot}/$pkg/DEBIAN/postrm";
1349 print POSTUNINST "#!/bin/sh\nset -e\n\n";
1350 print POSTUNINST $pkgdata{$pkg}{'postun'};
1351 close POSTUNINST;
1352 chmod 0755, "$specglobals{buildroot}/$pkg/DEBIAN/postrm";
1353 }
1354
1355 # execute
1356 print "Calling package creation script $debscriptfile for $pkgdata{$pkg}{name}...\n";
1357 system("/bin/sh -e $debscriptfile") == 0
1358 or die "Can't exec: $!\n";
1359
1360 $finalmessages .= "Wrote binary package ".
1361 "$pkgdata{$pkg}{name}_".
1362 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1363 "$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb".
1364 " in $topdir/DEBS/$pkgdata{$pkg}{arch}\n";
1365 # and clean up
1366 unlink $debscriptfile;
1367
1368 } # subpackage loop
1369
1370} # end binpackage()
1371
1372
1373## srcpackage()
1374# Builds a .src.deb source package. Note that Debian's idea of
1375# a "source package" is seriously flawed IMO, because you can't
1376# easily copy it as-is.
1377# Not quite identical to RPM, but Good Enough (TM).
1378sub srcpackage {
1379 # In case we were called with -bs.
1380 $pkgdata{main}{name} =~ tr/_/-/;
1381 my $pkgsrcname = "$pkgdata{main}{name}-".
1382 (defined($pkgdata{main}{epoch}) ? "$pkgdata{main}{epoch}:" : '').
1383 "$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb";
1384
1385 my $paxcmd;
1386
1387 # We'll definitely need this later, and *may* need it sooner.
1388 (my $barespec = $specfile) =~ s|.+/([^/]+)$|$1|;
1389
1390 # Copy the specfile to the build tree, but only if it's not there already.
1391##buglet: need to deal with silly case where silly user has put the spec
1392# file in a subdir of %{_topdir}/SPECS. Ewww. Silly user!
1393 if (abs_path($specfile) !~ /^$topdir\/SPECS/) {
1394 $paxcmd .= "cp $specfile %{_topdir}/SPECS/; \n"
1395 }
1396
1397 # use pax -w [file] [file] ... >outfile.sdeb
1398 $paxcmd = "cd $topdir; pax -w ";
1399
1400# tweak source entry into usable form. Need it locally somewhere along the line.
1401 (my $pkgsrc = $pkgdata{main}{source}) =~ s|.+/([^/]+)$|$1|;
1402 $paxcmd .= "SOURCES/$pkgsrc ";
1403
1404 # create file list: Source[nn], Patch[nn]
1405 foreach my $specbit (keys %{$pkgdata{main}} ) {
1406 next if $specbit eq 'source';
1407 $paxcmd .= "SOURCES/$pkgdata{main}{$specbit} " if $specbit =~ /^patch/;
1408##buglet: need to deal with case where patches are listed as URLs?
1409# or other extended pathnames? Silly !@$%^&!%%!%!! user!
1410 }
1411
1412 foreach my $source (keys %{$pkgdata{sources}}) {
1413 $paxcmd .= "SOURCES/$pkgdata{sources}{$source} ";
1414 }
1415
1416 # add the spec file, source package destination, and cd back where we came from.
1417 $paxcmd .= "SPECS/$barespec > $topdir/SDEBS/$pkgsrcname; cd -";
1418
1419 # In case of %-macros...
1420 $paxcmd = expandmacros($paxcmd,'gp');
1421
1422 system "$paxcmd";
1423 $finalmessages .= "Wrote source package $pkgsrcname in $topdir/SDEBS.\n";
1424} # end srcpackage()
1425
1426
1427## clean()
1428# Writes and executes the %clean script (mostly) built while reading the spec file.
1429sub clean {
1430 # Replace some things here just to make sure.
1431 $cleanscript = expandmacros($cleanscript,'gp');
1432
1433 # create script filename
1434 my $cleanscriptfile = "$tmpdir/deb-tmp.clean.".int(rand(99998)+1);
1435 sysopen(CLEANSCRIPT, $cleanscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
1436 or die $!;
1437 print CLEANSCRIPT $scriptletbase;
1438 print CLEANSCRIPT $cleanscript;
1439 close CLEANSCRIPT;
1440
1441 # execute
1442 print "Calling \%clean script $cleanscriptfile...\n";
1443 system("/bin/sh -e $cleanscriptfile") == 0
1444 or die "Can't exec: $!\n";
1445
1446 # and clean up
1447 unlink $cleanscriptfile;
1448} # end clean()
1449
1450
1451## checkbuildreq()
1452# Checks the build requirements (if any)
1453# Spits out a rude warning and returns a true-false error if any
1454# requirements are not met.
1455sub checkbuildreq {
1456 return 1 if $buildreq eq ''; # No use doing extra work.
1457
1458 if ( ! -e "/usr/bin/dpkg-query" ) {
1459 print "**WARNING** dpkg-query not found. Can't check build-deps.\n".
1460 " Required for sucessful build:\n".$buildreq."\n".
1461 " Continuing anyway.\n";
1462 return 1;
1463 }
1464
1465 my $reqflag = 1; # unset iff a buildreq is missing
1466
1467 $buildreq =~ s/^, //; # Strip the leading comma and space
1468 my @reqlist = split /,\s+/, $buildreq;
1469
1470 foreach my $req (@reqlist) {
1471 # from rpmbuild error message
1472 # Dependency tokens must begin with alpha-numeric, '_' or '/'
1473##fixme: check for suitable whitespace around $rel
1474 my ($pkg,$rel,$ver);
1475
1476 # We have two classes of requirements - versioned and unversioned.
1477 if ($req =~ /[><=]/) {
1478 # Pick up the details of versioned buildreqs
1479 ($pkg,$rel,$ver) = ($req =~ /([a-z0-9._-]+)\s+([><=]+)\s+([a-z0-9._-]+)/);
1480 } else {
1481 # And the unversioned ones.
1482 $pkg = $req;
1483 $rel = '>=';
1484 $ver = 0;
1485 }
1486
1487 my @pkglist = qx { dpkg-query --showformat '\${status}\t\${version}\n' -W $pkg };
1488 if (!$pkglist[0]) {
1489 print " * Missing build-dependency $pkg!\n";
1490 $reqflag = 0;
1491 } else {
1492# real package, installed
1493#kdeugau:~$ dpkg-query --showformat '${status}\t${version}\n' -W libc-client2007e-dev 2>&1
1494#install ok installed 8:2007f~dfsg-1
1495# virtual package, provided by ???
1496#kdeugau:~$ dpkg-query --showformat '${status}\t${version}\n' -W libc-client-dev 2>&1
1497#unknown ok not-installed
1498# real package or virtual package not installed or provided
1499#kdeugau:~$ dpkg-query --showformat '${status}\t${version}\n' -W libdb4.8-dbg 2>&1
1500#dpkg-query: no packages found matching libdb4.8-dbg
1501
1502 my ($reqstat,undef,undef,$reqver) = split /\s+/, $pkglist[0];
1503 if ($reqstat =~ /^unknown/) {
1504 # this seems to be a virtual package.
1505 print " * Warning: $pkg is probably installed but seems to be a virtual package.\n";
1506 } elsif ($reqstat =~ /^install/) {
1507 my ($resp) = qx { dpkg --compare-versions $reqver '$rel' $ver && echo "ok" };
1508 if ($resp !~ /^ok/) {
1509 $reqflag = 0;
1510 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n"
1511 }
1512 } else {
1513 # whatever state it's in, it's not completely installed, therefore it's missing.
1514 print " * Missing build-dependency $pkg!\n";
1515 $reqflag = 0;
1516 } # end not installed/installed check
1517 }
1518 } # end req loop
1519
1520 return $reqflag;
1521} # end checkbuildreq()
1522
1523
1524## getreqs()
1525# Find out which libraries/packages are required for any
1526# executables and libs in a given file tree.
1527# (Debian doesn't have soname-level deps; just package-level)
1528# Returns an empty string if the tree contains no binaries.
1529# Doesn't work well on shell scripts. but those *should* be
1530# fine anyway. (Yeah, right...)
1531sub getreqs() {
1532 my $pkgtree = $_[0];
1533
1534 print "Checking library requirements...\n";
1535 my @binlist = qx { find $pkgtree -type f -perm 755 };
1536
1537 if (scalar(@binlist) == 0) {
1538 return '';
1539 }
1540
1541 my @reqlist;
1542 foreach (@binlist) {
1543 push @reqlist, qx { LANG=C ldd $_ };
1544 }
1545
1546 # Get the list of libs provided by this package. Still doesn't
1547 # handle the case where the lib gets stuffed into a subpackage. :/
1548 my @intprovlist = qx { find $pkgtree -type f -name "*.so*" };
1549 my $provlist = '';
1550 foreach (@intprovlist) {
1551 s/$pkgtree//;
1552 $provlist .= "$_";
1553 }
1554
1555 my %reqs;
1556 my $reqlibs = '';
1557
1558 foreach (@reqlist) {
1559 next if /^$pkgtree/;
1560 next if /not a dynamic executable/;
1561 next if m|/lib(?:64)?/ld-linux|; # Hack! Hack! PTHBTT! (libc suxx0rz)
1562 next if /linux-gate.so/; # Kernel hackery for teh W1n!!1!1eleventy-one!1 (Don't ask. Feh.)
1563 next if /linux-vdso.so/; # More kernel hackery. Whee!
1564
1565 my ($req) = (m|=\>\s+([a-zA-Z0-9._/+-]+)|); # dig out the actual library (so)name.
1566 # And feh, we need the *path*, since I've discovered a new edge case where
1567 # the same libnnn.1.2.3 *file*name is found across *several* lib dirs. >:(
1568
1569 # Ignore libs provided by this package. Note that we don't match
1570 # on word-boundary at the *end* of the lib we're looking for, as the
1571 # looked-for lib may not have the full soname version. (ie, it may
1572 # "just" point to one of the symlinks that get created somewhere.)
1573 next if $provlist =~ /\b$req/;
1574
1575 $reqlibs .= " $req";
1576 }
1577
1578 if ($reqlibs ne '') {
1579 foreach (qx { dpkg -S $reqlibs }) {
1580 my ($libpkg,undef) = split /:/;
1581 $reqs{$libpkg} = 1;
1582 }
1583 }
1584
1585 my $deplist = '';
1586 foreach (keys %reqs) {
1587 $deplist .= ", $_";
1588 }
1589
1590# For now, we're done. We're not going to meddle with versions yet.
1591# Among other things, it's messier than handling "simple" yes/no "do
1592# we have this lib?" deps. >:(
1593
1594 return $deplist;
1595} # end getreqs()
1596
1597
1598## install_sdeb()
1599# Extracts .sdeb contents to %_topdir as appropriate
1600sub install_sdeb {
1601 $srcpkg = abs_path($srcpkg);
1602
1603 my $paxcmd = "cd $topdir; pax -r <$srcpkg; cd -";
1604
1605 # In case of %-macros...
1606 $paxcmd = expandmacros($paxcmd,'gp');
1607
1608 system "$paxcmd";
1609 print "Extracted source package $srcpkg to $topdir.\n";
1610} # end install_sdeb()
1611
1612
1613## expandmacros()
1614# Expands all %{blah} macros in the passed string
1615# Split up a bit with some sections so we don't spend time trying to
1616# expand macros that are only used in a few specific places.
1617sub expandmacros {
1618 my $macrostring = shift;
1619 my $section = shift;
1620
1621 # To allow the FHS-ish %configure and %makeinstall to work The Right Way.
1622 # (Without clobbering the global $specglobals{buildroot}.)
1623 my $prefix = '';
1624
1625 if ($section =~ /c/) {
1626 # %configure macro
1627# Don't know what it's for, don't have a useful default replacement
1628# --program-prefix=%{_program_prefix} \
1629 $macrostring =~ s'%configure'./configure --host=$DEB_HOST_GNU_TYPE \
1630 --build=$DEB_BUILD_GNU_TYPE \
1631 --prefix=%{_prefix} \
1632 --exec-prefix=%{_exec_prefix} \
1633 --bindir=%{_bindir} \
1634 --sbindir=%{_sbindir} \
1635 --sysconfdir=%{_sysconfdir} \
1636 --datadir=%{_datadir} \
1637 --includedir=%{_includedir} \
1638 --libdir=%{_libdir} \
1639 --libexecdir=%{_libexecdir} \
1640 --localstatedir=%{_localstatedir} \
1641 --sharedstatedir=%{_sharedstatedir} \
1642 --mandir=%{_mandir} \
1643 --infodir=%{_infodir} ';
1644 } # done %configure
1645
1646 if ($section =~ /m/) {
1647 $macrostring =~ s'%{__make}'make ';
1648 } # done make
1649
1650# %makeinstall expands with recursive macros in rpm. whee.
1651 if ($section =~ /i/) {
1652 # This is where we need to mangle $prefix.
1653 $macrostring =~ s'%makeinstall'make \
1654 prefix=%{?buildroot:%{buildroot}}%{_prefix} \
1655 exec_prefix=%{?buildroot:%{buildroot}}%{_exec_prefix} \
1656 bindir=%{?buildroot:%{buildroot}}%{_bindir} \
1657 sbindir=%{?buildroot:%{buildroot}}%{_sbindir} \
1658 sysconfdir=%{?buildroot:%{buildroot}}%{_sysconfdir} \
1659 datadir=%{?buildroot:%{buildroot}}%{_datadir} \
1660 includedir=%{?buildroot:%{buildroot}}%{_includedir} \
1661 libdir=%{?buildroot:%{buildroot}}%{_libdir} \
1662 libexecdir=%{?buildroot:%{buildroot}}%{_libexecdir} \
1663 localstatedir=%{?buildroot:%{buildroot}}%{_localstatedir} \
1664 sharedstatedir=%{?buildroot:%{buildroot}}%{_sharedstatedir} \
1665 mandir=%{?buildroot:%{buildroot}}%{_mandir} \
1666 infodir=%{?buildroot:%{buildroot}}%{_infodir} \
1667 install ';
1668 $prefix = $specglobals{buildroot};
1669 } # done %install and/or %makeinstall
1670
1671 # Build data
1672 # Note that these are processed in reverse order to get the substitution order right
1673 if ($section =~ /b/) {
1674# $macrostring =~ s'%{fhs}'host=$DEB_HOST_GNU_TYPE \
1675# build=$DEB_BUILD_GNU_TYPE \
1676 $macrostring =~ s'%{fhs}'prefix=%{_prefix} \
1677 exec-prefix=%{_exec_prefix} \
1678 bindir=%{_bindir} \
1679 sbindir=%{_sbindir} \
1680 sysconfdir=%{_sysconfdir} \
1681 datadir=%{_datadir} \
1682 includedir=%{_includedir} \
1683 libdir=%{_libdir} \
1684 libexecdir=%{_libexecdir} \
1685 localstatedir=%{_localstatedir} \
1686 sharedstatedir=%{_sharedstatedir} \
1687 mandir=%{_mandir} \
1688 infodir=%{_infodir} \
1689';
1690
1691 # Note that the above regex terminates with the extra space
1692 # "Just In Case" of user additions, which will then get neatly
1693 # tagged on the end where they take precedence (supposedly)
1694 # over the "default" ones.
1695
1696 # Now we cascade the macros introduced above. >_<
1697 # Wot ot to go theah:
1698 $macrostring =~ s|%{_mandir}|%{_datadir}/man|g; #/usr/share/man
1699 $macrostring =~ s|%{_infodir}|%{_datadir}/info|g; #/usr/share/info
1700 $macrostring =~ s|%{_oldincludedir}|/usr/include|g; #/usr/include
1701 $macrostring =~ s|%{_includedir}|%{_prefix}/include|g; #/usr/include
1702 $macrostring =~ s|%{_libdir}|%{_exec_prefix}/%{_lib}|g; #/usr/lib
1703 $macrostring =~ s|%{_lib}|lib|g; #?
1704 $macrostring =~ s|%{_localstatedir}|/var|g; #/var
1705 $macrostring =~ s|%{_sharedstatedir}|%{_prefix}/com|g; #/usr/com WTF?
1706 $macrostring =~ s|%{_sysconfdir}|/etc|g; #/etc
1707 $macrostring =~ s|%{_datadir}|%{_prefix}/share|g; #/usr/share
1708 $macrostring =~ s|%{_libexecdir}|%{_exec_prefix}/libexec|g; #/usr/libexec
1709 $macrostring =~ s|%{_sbindir}|%{_exec_prefix}/sbin|g; #/usr/sbin
1710 $macrostring =~ s|%{_bindir}|%{_exec_prefix}/bin|g; #/usr/bin
1711 $macrostring =~ s|%{_exec_prefix}|%{_prefix}|g; #/usr
1712 $macrostring =~ s|%{_prefix}|/usr|g; #/usr
1713 } # done with config section
1714
1715 # Package data
1716 if ($section =~ /p/) {
1717 $macrostring =~ s/\%\{buildroot\}/$specglobals{buildroot}/gi;
1718 $macrostring =~ s/\%\{source0?}/$topdir\/SOURCES\/$pkgdata{main}{source}/gi;
1719 foreach my $source (keys %{$pkgdata{sources}}) {
1720 $macrostring =~ s/\%\{source$source\}/$topdir\/SOURCES\/$pkgdata{sources}{$source}/gi;
1721 }
1722 $macrostring =~ s/\%\{name\}/$pkgdata{main}{name}/gi;
1723 $macrostring =~ s/\%\{version\}/$pkgdata{main}{version}/gi;
1724 $macrostring =~ s/\%\{release\}/$pkgdata{main}{release}/gi;
1725 }
1726
1727 # Globals, and not-so-globals
1728 if ($section =~ /g/) {
1729
1730 $macrostring =~ s|%{_builddir}|%{_topdir}/BUILD|g;
1731 $macrostring =~ s|%{buildsubdir}|$tarballdir|g;
1732 $macrostring =~ s|%{_topdir}|$topdir|g;
1733 $macrostring =~ s|%{_tmppath}|$tmpdir|g;
1734 $macrostring =~ s'%{_docdir}'%{_datadir}/doc'g;
1735
1736 # Standard FHS locations. More or less.
1737 $macrostring =~ s'%{_bindir}'/usr/bin'g;
1738 $macrostring =~ s'%{_sbindir}'/usr/sbin'g;
1739 $macrostring =~ s'%{_mandir}'%{_datadir}/man'g;
1740 $macrostring =~ s'%{_infodir}'%{_datadir}/info'g;
1741 $macrostring =~ s'%{_includedir}'/usr/include'g;
1742 $macrostring =~ s'%{_libdir}'/usr/lib'g;
1743 $macrostring =~ s'%{_sysconfdir}'/etc'g;
1744 $macrostring =~ s'%{_localstatedir}'/var'g;
1745
1746 # FHS-ish locations that aren't quite actually FHS-specified.
1747 $macrostring =~ s'%{_datadir}'/usr/share'g;
1748
1749 # special %define's. Handle the general case where we eval anything.
1750 # Even more general: %(...) is a spec-parse-time shell code wrapper.
1751 # Prime example:
1752 #%define perl_vendorlib %(eval "`perl -V:installvendorlib`"; echo $installvendorlib)
1753 if ($macrostring =~ /\%\((.+)\)/) {
1754 my $shellstr = $1;
1755 # Oy vey this gets silly for the perl bits. Executing a shell to
1756 # call Perl to get the vendorlib/sitelib/whatever "core" globals.
1757 # This can do more, but... eww.
1758 $shellstr = qx { /bin/sh -c '$shellstr' }; # Yay! ' characters apparently get properly exscapededed.
1759 $macrostring =~ s/\%\(.+\)/$shellstr/;
1760 }
1761
1762 # support for **some** %if constructs. Note that this breaks somewhat if
1763 # there's no value specified... but so does rpm.
1764
1765 my $tmpcount = 0; # runaway shutdown. Not really sure how else to avoid getting stuck.
1766 while ($macrostring =~ m/\%\{([?!]+)([a-z0-9_.-]+)(?:\:([a-z0-9_.\/\-\\]+)?)?\}/g) { #Whew....
1767 my $qex = $1;
1768 my $macro = $2;
1769 my $value = (defined($3) ? $3 : '');
1770
1771 my $neg = '1' if $qex =~ /\!/;
1772 if ($specglobals{$macro}) {
1773 $value = '' if $neg;
1774 } else {
1775 $value = '' if !$neg;
1776 }
1777 $macrostring =~ s/\%\{[?!]+[a-z0-9_.-]+(?:\:([a-z0-9_.\/\-\\]+)?)?\}/$value/;
1778
1779# not certain about this, but I don't want to run away. It *can* happen if planned carefully. :/
1780$tmpcount++;
1781# %makeinstall has 13 occurrences. D'Oh!
1782die "excessive recursive macro replacement; dying.\n" if $tmpcount > 14;
1783
1784 } # while()
1785
1786 # Misc expansions
1787 $macrostring =~ s|%{_arch}|$hostarch|g;
1788 $macrostring =~ s|%{optflags}|$optflags{$hostarch}|g;
1789 $macrostring =~ s|%{_vendor}|$specglobals{'_vendor'}|g;
1790
1791 # system programs. RPM uses a global config file for these; we'll just
1792 # ASS-U-ME and make life a little simpler.
1793 if ($macrostring =~ /\%\{\_\_([a-z0-9_-]+)\}/) {
1794 $macrostring =~ s|%{__([a-z0-9_-]+)}|$1|g;
1795 }
1796
1797# should probably stick a "no runaway" flag in here... Just In Case...
1798 # %define's
1799# note to self: find out valid chars for %define name/label so we can parse them
1800 while (my ($key) = ($macrostring =~ /%{([a-z0-9_]+)}/i) ) {
1801# hrm. This needs thinking.
1802#die "A horrible death! \%{$key}, '$macrostring'\n" if !$specglobals{$key};
1803 $macrostring =~ s|%{$key}|$specglobals{$key}|g;
1804 # wanna limit this to "... if $specglobals{$key}", but need more magic
1805 }
1806
1807 # Perl @INC/...lib locations, and other related bits.
1808 $macrostring =~ s|%{perl_archlib}|$Config{installarchlib}|g;
1809 $macrostring =~ s|%{perl_sitelib}|$Config{installsitelib}|g;
1810 $macrostring =~ s|%{perl_sitearch}|$Config{installsitearch}|g;
1811 $macrostring =~ s|%{perl_vendorlib}|$Config{installvendorlib}|g;
1812 $macrostring =~ s|%{perl_vendorarch}|$Config{installvendorarch}|g;
1813
1814 } # done with globals section
1815
1816 return $macrostring;
1817} # end expandmacros()
1818
1819
1820
1821__END__
1822
1823
1824
1825=head1 NAME
1826
1827debbuild - Build Debian-compatible .deb packages from RPM .spec files
1828
1829=head1 SYNOPSIS
1830
1831 debbuild {-ba|-bb|-bp|-bc|-bi|-bl|-bs} [build-options] file.spec
1832
1833 debbuild {-ta|-tb|-tp|-tc|-ti|-tl|-ts} [build-options] file.tar.{gz|bz2}
1834
1835 debbuild --rebuild file.{src.rpm|sdeb}
1836
1837 debbuild --showpkgs
1838
1839=head1 DESCRIPTION
1840
1841debbuild attempts to build Debian-friendly semi-native packages from RPM spec files,
1842RPM-friendly tarballs, and RPM source packages (.src.rpm files). It accepts I<most> of the
1843options rpmbuild does, and should be able to interpret most spec files usefully. Perl
1844modules should be handled via CPAN+dh-make-perl instead as it's simpler than even tweaking
1845a .spec template.
1846
1847As far as possible, the command-line options are identical to those from rpmbuild, although
1848several rpmbuild options are not supported:
1849
1850 --recompile
1851 --showrc
1852 --buildroot
1853 --clean
1854 --nobuild
1855 --rmsource
1856 --rmspec
1857 --sign
1858 --target
1859
1860Some of these could probably be trivially added. Feel free to send me a patch. ;)
1861
1862Complex spec files will most likely not work well, if at all. Rewrite them from scratch -
1863you'll have to make heavy modifications anyway.
1864
1865If you see something you don't like, mail me. Send a patch if you feel inspired. I don't
1866promise I'll do anything other than say "Yup, that's broken" or "Got your message".
1867
1868=head1 ASSUMPTIONS
1869
1870As with rpmbuild, debbuild makes some assumptions about your system.
1871
1872=over 4
1873
1874=item *
1875
1876Either you have rights to do as you please under /usr/src/debian, or you have created a file
1877~/.debmacros containing a suitable %_topdir definition.
1878
1879Both rpmbuild and debbuild require the directories %_topdir/{BUILD,SOURCES,SPECS}. However,
1880where rpmbuild requires the %_topdir/{RPMS,SRPMS} directories, debbuild
1881requires %_topdir/{DEBS,SDEBS} instead. Create them in advance;
1882some subdirectories are created automatically as needed, but most are not.
1883
1884=item *
1885
1886/var/tmp must allow script execution - rpmbuild and debbuild both rely on creating and
1887executing shell scripts for much of their functionality. By default, debbuild also creates
1888install trees under /var/tmp - however this is (almost) entirely under the control of the
1889package's .spec file.
1890
1891=item *
1892
1893If you wish to --rebuild a .src.rpm, your %_topdir for both debbuild and rpmbuild must either
1894match, or be suitably symlinked one direction or another so that both programs are effectively
1895working in the same tree. (Or you could just manually wrestle files around your system.)
1896
1897You could symlink ~/.rpmmacros to ~/.debmacros (or vice versa) and save yourself some hassle
1898if you need to rebuild .src.rpm packages on a regular basis. Currently debbuild only uses the
1899%_topdir macro definition, although there are many more things that rpmbuild can use from
1900~/.rpmmacros.
1901
1902=back
1903
1904=head1 ERRATA
1905
1906debbuild deliberately does a few things differently from rpm.
1907
1908=head2 BuildArch or BuildArchitecture
1909
1910rpm takes the last BuildArch entry it finds in the .spec file, whatever it is, and runs with
1911that for all packages. Debian's repository system is fairly heavily designed around the
1912assumption that a single source package may generate small binary (executable) packages
1913for each arch, and large binary arch-all packages containing shared data.
1914
1915debbuild allows this by using the architecture specified by (in order of preference):
1916
1917=over 4
1918
1919=item * Host architecture
1920
1921=item * BuildArch specified in .spec file preamble
1922
1923=item * "Last specified" BuildArch for packages with several subpackages
1924
1925=item * BuildArch specified in the %package section for that subpackage
1926
1927=back
1928
1929=head2 Finding out what packages should be built (--showpkgs)
1930
1931rpmbuild does not include any convenient method I know of to list the packages a spec file
1932will produce. Since I needed this ability for another tool, I added it.
1933
1934It requires the .spec file for the package, and produces a list of full package filenames
1935(without path data) that would be generated by one of --rebuild, -ta, -tb, -ba, or -bb.
1936This includes the .sdeb source package.
1937
1938=head1 AUTHOR
1939
1940debbuild was written by Kris Deugau <kdeugau@deepnet.cx>. A version that approximates
1941current is available at http://www.deepnet.cx/debbuild/.
1942
1943=head1 BUGS
1944
1945Funky Things Happen if you forget a command-line option or two. I've been too lazy to bother
1946fixing this.
1947
1948Many macro expansions are unsupported or incompletely supported.
1949
1950The generated scriptlets don't quite match those from rpmbuild exactly. There are extra
1951environment variables and preprocessing that I haven't needed (yet).
1952
1953Dcumentation, such as it is, will likely remain perpetually out of date.
1954
1955%_topdir and the five "working" directories under %_topdir could arguably be created by
1956debbuild. However, rpmbuild doesn't create these directories either.
1957
1958=head1 SEE ALSO
1959
1960rpm(8), rpmbuild(8), and pretty much any document describing how to write a .spec file.
1961
1962=cut
Note: See TracBrowser for help on using the repository browser.