source: trunk/debbuild@ 169

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

/trunk

Light tweak on the .spec to reflect the GPL2+ header
Add bash as a dependency in the .spec file, so we can use /bin/bash

in scriptlets. Debian's migration of /bin/sh -> /bin/dash has
turned out to have some very unfortunate effects on scriptlets...

Trim empty lines and comment lines from %files sections
Typofix a warning
Tighten up build-dependency checking:

  • add a ##fixme to ponder regarding the exact syntax for the entries
  • find a workable way to detect if virtual packages are installed, at least for this week

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