source: trunk/debbuild@ 87

Last change on this file since 87 was 87, checked in by kdeugau, 17 years ago

/trunk

Handle BuildArch (more or less), and allow debbuild to run "correctly"
without modification on any arch.
  • Property svn:executable set to *
  • Property svn:keywords set to Date Rev Author
File size: 46.0 KB
Line 
1#!/usr/bin/perl
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: 2007-04-17 20:16:29 +0000 (Tue, 17 Apr 2007) $
9# SVN revision $Rev: 87 $
10# Last update by $Author: kdeugau $
11###
12# Copyright 2005-2007 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
32
33# regex debugger
34#use re "debug";
35
36# Program flow:
37# -> Parse/execute "system" config/macros (if any - should be rare)
38# -> Parse/execute "user" config/macros (if any - *my* requirement is %_topdir)
39# -> Parse command line for options, spec file/tarball/.src.deb (NB - also accept .src.rpm)
40
41sub expandmacros;
42
43# User's prefs for dirs, environment, etc,etc,etc.
44# config file ~/.debmacros
45# Default ordered search paths for config/macros:
46# /usr/lib/rpm/rpmrc /usr/lib/rpm/redhat/rpmrc /etc/rpmrc ~/.rpmrc
47# /usr/lib/rpm/macros /usr/lib/rpm/redhat/macros /etc/rpm/macros ~/.rpmmacros
48# **NOTE: May be possible to (ab)use bits of debhelper
49
50# Build tree
51# default is /usr/src/debian/{BUILD,SOURCES,SPECS,DEBS,SDEBS}
52
53# Globals
54my $finalmessages = ''; # A place to stuff messages that I want printed at the *very* end of any processing.
55my $specfile;
56my $tarball;
57my $srcpkg;
58my $cmdbuildroot;
59my $tarballdir; # This should really be initialized, but the coding makes it, um, ugly.
60my %specglobals; # For %define's in specfile, among other things.
61
62# Initialized globals
63my $verbosity = 0;
64my %cmdopts = (type => '',
65 stage => 'a',
66 short => 'n'
67 );
68my $topdir = "/usr/src/debian";
69my $buildroot = "%{_tmppath}/%{name}-%{version}-%{release}.root".int(rand(99998)+1);
70
71# "Constants"
72my %targets = ('p' => 'Prep',
73 'c' => 'Compile',
74 'i' => 'Install',
75 'l' => 'Verify %files',
76 'a' => 'Build binary and source',
77 'b' => 'Build binary',
78 's' => 'Build source'
79 );
80# Ah, the joys of multiple architectures. :( Feh.
81# As copied from rpm
82my %optflags = ( 'i386' => '-O2 -g -march=i386 -mcpu=i686',
83 'amd64' => '-O2 -g'
84 );
85my $hostarch; # we set this later...
86my $scriptletbase =
87q(#!/bin/sh
88
89 RPM_SOURCE_DIR="%{_topdir}/SOURCES"
90 RPM_BUILD_DIR="%{_topdir}/BUILD"
91 RPM_OPT_FLAGS="%{optflags}"
92 RPM_ARCH="%{_arch}"
93 RPM_OS="linux"
94 export RPM_SOURCE_DIR RPM_BUILD_DIR RPM_OPT_FLAGS RPM_ARCH RPM_OS
95 RPM_DOC_DIR="/usr/share/doc"
96 export RPM_DOC_DIR
97 RPM_PACKAGE_NAME="%{name}"
98 RPM_PACKAGE_VERSION="%{version}"
99 RPM_PACKAGE_RELEASE="%{release}"
100 export RPM_PACKAGE_NAME RPM_PACKAGE_VERSION RPM_PACKAGE_RELEASE
101 RPM_BUILD_ROOT="%{buildroot}"
102 export RPM_BUILD_ROOT
103);
104foreach (`dpkg-architecture`) {
105 s/=(.+)/="$1"/;
106 $scriptletbase .= " $_";
107 ($hostarch) = (/^DEB_HOST_ARCH="(.+)"$/) if /DEB_HOST_ARCH/;
108}
109$scriptletbase .=
110q(
111 set -x
112 umask 022
113 cd %{_topdir}/BUILD
114);
115
116# Package data
117# This is the form of $pkgdata{pkgname}{meta}
118# meta includes Summary, Name, Version, Release, Group, Copyright,
119# Source, URL, Packager, BuildRoot, Description, BuildReq(uires),
120# Requires, Provides
121# 10/31/2005 Maybe this should be flatter? -kgd
122my %pkgdata;
123my @pkglist = ('main'); #sigh
124# Files listing. Embedding this in %pkgdata would be, um, messy.
125my %filelist;
126my $buildreq = '';
127
128# Scriptlets
129my $prepscript = '';
130my $buildscript = '';
131# %install doesn't need the full treatment from %clean; just an empty place to install to.
132# NB - rpm doesn't do this; is it really necessary?
133my $installscript = '[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT'."\n";
134my $cleanscript = '';
135
136die "Not enough arguments\n" if #$argv == 0;
137
138# Snag some environment data
139my $tmpdir;
140if (defined $ENV{TMP} && $ENV{TMP} =~ /^(\/var)?\/tmp$/) {
141 $tmpdir = $ENV{TMP};
142} else {
143 $tmpdir = "/var/tmp";
144}
145
146##main
147
148load_userconfig();
149parse_cmd();
150
151if ($cmdopts{install}) {
152 install_sdeb();
153 exit 0;
154}
155
156# output stage of --showpkgs
157if ($cmdopts{type} eq 'd') {
158 parse_spec();
159 foreach my $pkg (@pkglist) {
160 $pkgdata{$pkg}{name} =~ tr/_/-/;
161
162 my $pkgfullname = "$pkgdata{$pkg}{name}_$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb";
163
164 print "$pkgfullname\n" if $filelist{$pkg};
165
166 }
167 # Source package
168 print "$pkgdata{main}{name}-$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb\n";
169 exit 0;
170}
171
172# Stick --rebuild handling in here - basically install_sdeb()
173# followed by tweaking options to run with -ba
174if ($cmdopts{type} eq 's') {
175 if ($srcpkg =~ /\.src\.rpm$/) {
176 my @srclist = qx { rpm -qlp $srcpkg };
177 foreach (@srclist) {
178 chomp;
179 $specfile = "$topdir/SPECS/$_" if /\.spec$/;
180 }
181 qx { rpm -i $srcpkg };
182 } else {
183 install_sdeb();
184 my @srclist = qx { pax < $srcpkg };
185 foreach (@srclist) {
186 chomp;
187 $specfile = "$topdir/$_" if /SPECS/;
188 }
189 }
190 $cmdopts{type} = 'b';
191 $cmdopts{stage} = 'a';
192}
193
194if ($cmdopts{type} eq 'b') {
195 # Need to read the spec file to find the tarball. Note that
196 # this also generates most of the shell script required.
197 parse_spec();
198 die "Can't build $pkgdata{main}{name}: build requirements not met.\n"
199 if !checkbuildreq();
200}
201
202if ($cmdopts{type} eq 't') {
203 # Need to unpack the tarball to find the spec file. Sort of the inverse of -b above.
204 # zcat $tarball |tar -t |grep .spec
205 # collect some info about the tarball
206 $specfile = "$topdir/BUILD/". qx { zcat $tarball |tar -t |grep .spec\$ };
207 chomp $specfile;
208 my ($fileonly, $dirname) = ($tarball =~ /(([a-zA-Z0-9._-]+)\.tar\.(?:gz|bz2))$/);
209
210 $tarball = abs_path($tarball);
211 my $unpackcmd = "cd $topdir/BUILD; tar -".
212 ( $tarball =~ /\.tar\.gz$/ ? "z" : "" ).
213 ( $tarball =~ /\.tar\.bz2$/ ? "j" : "" ). "xf $tarball";
214 system "$unpackcmd";
215 system "cp $tarball $topdir/SOURCES/$fileonly";
216 system "cp $specfile $topdir/SPECS/";
217 parse_spec();
218 die "Can't build $pkgdata{main}{name}: build requirements not met.\n"
219 if !checkbuildreq();
220}
221
222# -> srcpkg if -.s
223if ($cmdopts{stage} eq 's') {
224 srcpackage();
225 exit 0;
226}
227
228# Hokay. Need to:
229# -> prep if -.p OR (-.[cilabs] AND !--short-circuit)
230if ($cmdopts{stage} eq 'p' || ($cmdopts{stage} =~ /[cilabs]/ && $cmdopts{short} ne 'y')) {
231 prep();
232}
233# -> build if -.c OR (-.[ilabs] AND !--short-circuit)
234if ($cmdopts{stage} eq 'c' || ($cmdopts{stage} =~ /[ilabs]/ && $cmdopts{short} ne 'y')) {
235 build();
236}
237# -> install if -.[ilabs]
238#if ($cmdopts{stage} eq 'i' || ($cmdopts{stage} =~ /[labs]/ && $cmdopts{short} ne 'y')) {
239if ($cmdopts{stage} =~ /[ilabs]/) {
240 install();
241#foreach my $pkg (@pkglist) {
242# print "files in $pkg:\n ".$filelist{$pkg}."\n";
243#}
244
245}
246# -> binpkg and srcpkg if -.a
247if ($cmdopts{stage} eq 'a') {
248 binpackage();
249 srcpackage();
250}
251# -> binpkg if -.b
252if ($cmdopts{stage} eq 'b') {
253 binpackage();
254}
255
256# Spit out any closing remarks
257print $finalmessages;
258
259# Just in case.
260exit 0;
261
262
263## load_userconfig()
264# Loads user configuration (if any)
265# Currently only handles .debmacros
266# Needs to handle "other files"
267sub load_userconfig {
268 my (undef,undef,undef,undef,undef,undef,undef,$homedir,undef) = getpwuid($<);
269 if (-e "$homedir/.debmacros") {
270 open USERMACROS,"<$homedir/.debmacros";
271 while (<USERMACROS>) {
272 # And we also only handle a few macros at the moment.
273 if (/^\%_topdir/) {
274 my (undef,$tmp) = split /\s+/, $_;
275 $topdir = $tmp;
276 }
277 }
278 }
279} # end load_userconfig()
280
281
282## parse_cmd()
283# Parses command line into global hash %cmdopts, other globals
284# Options based on rpmbuild's options
285sub parse_cmd {
286 # Don't feel like coding my own option parser...
287 #use Getopt::Long;
288 # ... but I may have to: (OTOH, rpm uses popt, so maybe we can too.)
289 #use Getopt::Popt qw(:all);
290 # Or not. >:( Stupid Debian lack of findable Perl module names in packages.
291
292 # Stuff it.
293 my $prevopt = '';
294 foreach (@ARGV) {
295 chomp;
296
297 # Is it an option?
298 if (/^-/) {
299
300 # Is it a long option?
301 if (/^--/) {
302 if (/^--short-circuit/) {
303 $cmdopts{short} = 'y';
304 } elsif (/^--rebuild/) {
305 $cmdopts{type} = 's';
306 } elsif (/^--showpkgs/) {
307 $cmdopts{type} = 'd'; # d for 'diagnostic' or 'debug' or 'dump'
308 } else {
309 print "Long opt $_\n";
310 }
311 } else {
312 # Not a long option
313 if (/^-[bt]/) {
314 if ($cmdopts{stage} eq 's') {
315 # Mutually exclusive options.
316 die "Can't use $_ with --rebuild\n";
317 } else {
318 # Capture the type (from "bare" files or tarball) and the stage (prep, build, etc)
319 ($cmdopts{stage}) = (/^-[bt]([pcilabs])/);
320 ($cmdopts{type}) = (/^-([bt])[pcilabs]/);
321 }
322 } elsif (/^-v/) {
323 # bump verbosity. Not sure what I'll actually do here...
324 } elsif (/^-i/) {
325 $cmdopts{install} = 1;
326 $prevopt = '-i';
327 } else {
328 die "Bad option $_\n";
329 }
330 }
331
332 } else { # Not an option argument
333
334 # --buildroot is the only option that takes an argument
335 # Therefore, any *other* bare arguments are the spec file,
336 # tarball, or source package we're operating on - depending
337 # on which one we meet.
338 if ($prevopt eq '--buildroot') {
339 $cmdbuildroot = $_;
340 } elsif ($prevopt eq '-i') {
341 $srcpkg = $_;
342 } else {
343 if ($cmdopts{type} eq 's') {
344 # Source package
345 if (!/(sdeb|\.src\.rpm)$/) {
346 die "Can't --rebuild with $_\n";
347 }
348 $srcpkg = $_;
349 } elsif ($cmdopts{type} eq 'b' || $cmdopts{type} eq 'd') {
350 # Spec file
351 $specfile = $_;
352 } else {
353 # Tarball build. Need to extract tarball to find spec file. Whee.
354 $tarball = $_;
355 }
356 }
357 }
358 $prevopt = $_;
359 } # foreach @ARGV
360
361 # Some cross-checks. rpmbuild limits --short-circuit to just
362 # the "compile" and "install" targets - with good reason IMO.
363 # Note that --short-circuit with -.p is not really an error, just redundant.
364 # NB - this is NOT fatal, just ignored!
365 if ($cmdopts{short} eq 'y' && $cmdopts{stage} =~ /[labs]/) {
366 warn "Can't use --short-circuit for $targets{$cmdopts{stage}} stage. Ignoring.\n";
367 $cmdopts{short} = 'n';
368 }
369
370 # Valid options, with example arguments (if any):
371# Build from .spec file; mutually exclusive:
372 # -bp
373 # -bc
374 # -bi
375 # -bl
376 # -ba
377 # -bb
378 # -bs
379# Build from tarball; mutually exclusive:
380 # -tp
381 # -tc
382 # -ti
383 # -ta
384 # -tb
385 # -ts
386# Build from .src.(deb|rpm)
387 # --rebuild
388 # --recompile
389
390# General options
391 # --buildroot=DIRECTORY
392 # --clean
393 # --nobuild
394 # --nodeps
395 # --nodirtokens
396 # --rmsource
397 # --rmspec
398 # --short-circuit
399 # --target=CPU-VENDOR-OS
400
401 #my $popt = new Getopt::Popt(argv => \@ARGV, options => \@optionsTable);
402
403} # end parse_cmd()
404
405
406## parse_spec()
407# Parse the .spec file.
408sub parse_spec {
409 open SPECFILE,"<$specfile" or die "specfile ($specfile) barfed: $!";
410
411 my $buildarch = $hostarch;
412
413LINE: while (<SPECFILE>) {
414 next if /^#/; # Ignore comments...
415 next if /^\s+$/; # ... and blank lines.
416
417 if (/^\%/) {
418 # A macro that needs further processing.
419
420 if (my ($key, $def) = (/^\%define\s+([^\s]+)\s+(.+)$/) ) {
421 $specglobals{$key} = expandmacros($def,'g');
422 }
423
424 if (/^\%description(?:\s+(?:-n\s+)?(.+))?/) {
425 my $subname = "main";
426 if ($1) {
427 my $tmp = expandmacros("$1", 'g');
428 if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
429 }
430 while (<SPECFILE>) {
431 next if /^#/; # Messy. Should be possible to do better. :/
432 redo LINE if /^\%/;
433 $pkgdata{$subname}{desc} .= " $_";
434 }
435 }
436 if (/^\%package\s+(?:-n\s+)?(.+)/) {
437 # gotta expand %defines here. Whee.
438 my $subname = expandmacros("$1", 'g');
439 if (! /-n/) { $subname = "$pkgdata{main}{name}-$1"; }
440 push @pkglist, $subname;
441 $pkgdata{$subname}{name} = $subname;
442 $pkgdata{$subname}{version} = $pkgdata{main}{version};
443 # Build "same arch as previous package found" by default. Where rpm just picks the
444 # *very* last one, we want to allow arch<native>+arch-all
445 # (eg, Apache is i386, but apache-manual is all)
446 $pkgdata{$subname}{arch} = $buildarch; # Since it's likely subpackages will NOT have a BuildArch line...
447 while (<SPECFILE>) {
448 redo LINE if /^\%/;
449 if (my ($dname,$dvalue) = (/^(Summary|Group|Version|Requires|Provides|BuildArch(?:itecture)?):\s+(.+)$/i)) {
450 $dname =~ tr/[A-Z]/[a-z]/;
451 if ($dname =~ /^BuildArch/i) {
452 $buildarch = $dvalue; # Emulate rpm's behaviour to a degree
453 $dname = 'arch';
454 }
455 $pkgdata{$subname}{$dname} = expandmacros($dvalue, 'gp');
456 }
457 }
458 }
459
460 if (/^\%prep/) {
461 # %prep section. May have %setup macro; may include %patch tags,
462 # may be just a bare shell script.
463
464 # This really should be local-ish, but we need just the filename for the source
465 $pkgdata{main}{source} =~ s|.+/([^/]+)$|$1|;
466
467 # Replace some core macros
468 $pkgdata{main}{source} = expandmacros($pkgdata{main}{source},'gp');
469
470PREPSCRIPT: while (<SPECFILE>) {
471 if (/^\%setup/) {
472 # Parse out the %setup macro. Note that we aren't supporting
473 # many of RPM's %setup features.
474 $prepscript .= "cd $topdir/BUILD\n";
475 if ( /\s+-n\s+([^\s]+)\s+/ ) {
476 $tarballdir = $1;
477 } else {
478 $tarballdir = "$pkgdata{main}{name}-$pkgdata{main}{version}";
479 }
480 $tarballdir = expandmacros($tarballdir,'gp');
481 $prepscript .= "rm -rf $tarballdir\n";
482 if (/\s+-c\s+/) {
483 $prepscript .= "mkdir $tarballdir\ncd $tarballdir\n";
484 }
485 $prepscript .= "tar -".
486 ( $pkgdata{main}{source} =~ /\.tar\.gz$/ ? "z" : "" ).
487 ( $pkgdata{main}{source} =~ /\.tar\.bz2$/ ? "j" : "" ).
488 ( /\s+-q\s+/ ? '' : 'vv' )."xf ".
489 "$topdir/SOURCES/$pkgdata{main}{source}\n".
490 qq(STATUS=\$?\nif [ \$STATUS -ne 0 ]; then\n exit \$STATUS\nfi\n).
491 "cd $topdir/BUILD/$tarballdir\n".
492 qq([ `/usr/bin/id -u` = '0' ] && /bin/chown -Rhf root .\n).
493 qq([ `/usr/bin/id -u` = '0' ] && /bin/chgrp -Rhf root .\n).
494 qq(/bin/chmod -Rf a+rX,g-w,o-w .\n);
495 } elsif ( my ($patchnum,$patchopts) = (/^\%patch([^\s]+)(\s+.+)?$/) ) {
496 chomp $patchnum;
497 $prepscript .= qq(echo "Patch #$patchnum ($pkgdata{main}{"patch$patchnum"}):"\n).
498 "patch ";
499 # If there are options passed, use'em.
500 # Otherwise, catch a bare %patch and ASS-U-ME it's '-p0'-able.
501 # Will break on options that don't provide -pnn, but what the hell.
502 $prepscript .= $patchopts if $patchopts;
503 $prepscript .= "-p0" if !$patchopts;
504 $prepscript .= " -s <$topdir/SOURCES/".$pkgdata{main}{"patch$patchnum"}."\n";
505 } else {
506 last PREPSCRIPT if /^\%/;
507 $prepscript .= $_;
508 }
509 }
510 redo LINE;
511 }
512 if (/^\%build/) {
513 # %build. This is pretty much just a shell script. There
514 # *are* a few macros, but we're not going to deal with them yet.
515 $buildscript .= "cd $tarballdir\n";
516BUILDSCRIPT: while (<SPECFILE>) {
517 if (/^\%configure/) {
518 $buildscript .= expandmacros($_,'cgbp');
519 } elsif (/^\%\{__make\}/) {
520 $buildscript .= expandmacros($_,'mgbp');
521 } else {
522 last BUILDSCRIPT if /^\%[^{]/;
523 $buildscript .= $_;
524 }
525 }
526 redo LINE;
527 }
528 if (/^\%install/) {
529 $installscript .= "cd $tarballdir\n";
530INSTALLSCRIPT: while (<SPECFILE>) {
531 if (/^\%makeinstall/) {
532 $installscript .= expandmacros($_,'igbp');
533 } else {
534 last INSTALLSCRIPT if /^\%/;
535 $installscript .= $_;
536 }
537 }
538 redo LINE;
539 }
540 if (/^\%clean/) {
541 while (<SPECFILE>) {
542 redo LINE if /^\%/;
543 $cleanscript .= $_;
544 }
545 $cleanscript = expandmacros($cleanscript,'gp');
546 }
547
548 # pre/post (un)install scripts. Note that we expand macros later anyway, so we'll leave them unexpanded here.
549 if (/^\%(pre|post|preun|postun)\b(?:\s+(?:-n\s+)?(.+))?/i) {
550 my $scriptlet = lc $1;
551 my $pkgname = 'main';
552 if ($2) { # Magic to add entries to the right list of files
553 my $tmp = expandmacros("$2", 'g');
554 if (/-n/) { $pkgname = $tmp; } else { $pkgname = "$pkgdata{main}{name}-$tmp"; }
555 }
556 while (<SPECFILE>) {
557 redo LINE if /^\%/;
558 $pkgdata{$pkgname}{$scriptlet} .= $_;
559 }
560 }
561 # done %pre/%post scripts
562
563 if (/^\%files(?:\s+(?:-n\s+)?(.+))?/) {
564 my $pkgname = 'main';
565 if ($1) { # Magic to add entries to the right list of files
566 my $tmp = expandmacros("$1", 'g');
567 if (/-n/) { $pkgname = $tmp; } else { $pkgname = "$pkgdata{main}{name}-$tmp"; }
568 }
569
570 # Set this now, so it can be flipped a bit later, and used much later.
571 #$pkgdata{$pkgname}{conffiles} = 0;
572
573 while (<SPECFILE>) {
574 chomp;
575 next if /^#/;
576 # need to update this to deal (properly) with %dir, %attr, etc
577 next if /^\%dir/;
578 next if /^\%defattr/;
579
580 # Debian dpkg doesn't speak "%docdir". Meh.
581 next if /^\%docdir/;
582
583##fixme
584# Note that big chunks of this section don't match rpm's behaviour; among other things,
585# rpm accepts more than one %-directive on one line for a file or set of files.
586 # make sure files get suitable permissions and so on
587 if (/^\%attr/) {
588 # We're going to collapse whitespace before processing. PTHBT.
589 # While this breaks pathnames with spaces, anyone expecting command-line
590 # tools with spaces to work (never mind work *properly* or *well*) under
591 # any *nix has their head so far up their ass they can see out their mouth.
592 my ($args,$filelist) = split /\)/;
593 $filelist{$pkgname} .= " $filelist";
594 $args =~ s/\s+//g;
595 $args =~ s/"//g; # don't think quotes are ever necessary, but they're *allowed*
596 my ($perms,$owner,$group) = ($args =~ /\(([\d-]+),([a-zA-Z0-9-]+),([a-zA-Z0-9-]+)/);
597# due to Debian's total lack of real permissions-processing in its actual package
598# handling component (dpkg-deb), this can't really be done "properly". We'll have
599# to add chown/chmod commands to the postinst instead. Feh.
600 $pkgdata{$pkgname}{'post'} .= "chown $owner $filelist\n" if $owner ne '-';
601 $pkgdata{$pkgname}{'post'} .= "chgrp $group $filelist\n" if $group ne '-';
602 $pkgdata{$pkgname}{'post'} .= "chmod $perms $filelist\n" if $perms ne '-';
603 next;
604 }
605
606 # %doc needs extra processing, because it can be a space-separated list.
607 if (/^\%doc/) {
608 s/^\%doc\s+//;
609 foreach (split()) {
610 $filelist{$pkgname} .= " %{_docdir}/$_";
611 }
612 next;
613 }
614
615 # Conffiles. Note that Debian and RH have similar, but not
616 # *quite* identical ideas of what constitutes a conffile. Nrgh.
617 if (/^\%config\s+(.+)$/) {
618 $pkgdata{$pkgname}{conffiles} = 1; # Flag it for later
619 my $tmp = $1; # Now we can mangleificationate it. And we probably need to. :/
620 $tmp = expandmacros($tmp, 'gp'); # Expand common macros
621 if ($tmp !~ /\s+/) {
622 # Simplest case, just a file. Whew.
623 push @{$pkgdata{$pkgname}{conflist}}, $tmp;
624 $filelist{$pkgname} .= " $tmp";
625 } else {
626 # Wot? Spaces? That means extra %-macros. Which, for the most part, can be ignored.
627 ($tmp) = ($tmp =~ /.+\s([^\s]+)/); # Strip everything before the last space
628 push @{$pkgdata{$pkgname}{conflist}}, $tmp;
629 $filelist{$pkgname} .= " $tmp";
630 }
631 next;
632 }
633
634 # and finally we can fall through %{_<FHS>}-prefixed locations...
635 if (/^\%\{_/) {
636 $filelist{$pkgname} .= " $_";
637 next;
638 }
639 # EW. Necessary to clear up %define expansions before we exit with redo.
640 $_ = expandmacros $_, 'g';
641
642 # ... unknown or "next section" % directives ...
643 redo LINE if /^\%/;
644
645 # ... and "normal" files
646 $filelist{$pkgname} .= " $_";
647 }
648 } # done %file section
649
650 if (/^\%changelog/) {
651 $pkgdata{main}{changelog} = '';
652 while (<SPECFILE>) {
653 redo LINE if /^\%/;
654 $pkgdata{main}{changelog} .= $_;
655 }
656 }
657
658 } else { # Data from the spec file "header"
659
660 if (/^summary:\s+(.+)/i) {
661 $pkgdata{main}{summary} = $1;
662 } elsif (/^name:\s+(.+)/i) {
663 $pkgdata{main}{name} = expandmacros($1,'g');
664 } elsif (/^version:\s+(.+)/i) {
665 $pkgdata{main}{version} = expandmacros($1,'g');
666 } elsif (/^release:\s+(.+)/i) {
667 $pkgdata{main}{release} = expandmacros($1,'g');
668 } elsif (/^group:\s+(.+)/i) {
669 $pkgdata{main}{group} = $1;
670 } elsif (/^copyright:\s+(.+)/i) {
671 $pkgdata{main}{copyright} = $1;
672 } elsif (/^url:\s+(.+)/i) {
673 $pkgdata{main}{url} = $1;
674 } elsif (/^packager:\s+(.+)/i) {
675 $pkgdata{main}{packager} = $1;
676 } elsif (/^buildroot:\s+(.+)/i) {
677 $buildroot = $1;
678 } elsif (/^source0?:\s+(.+)/i) {
679 $pkgdata{main}{source} = $1;
680 die "Unknown tarball format $1\n" if $1 !~ /\.tar\.(?:gz|bz2)$/;
681 } elsif (/^source([0-9]+):\s+(.+)/i) {
682 $pkgdata{sources}{$1} = $2;
683 } elsif (/^patch([^:]+):\s+(.+)$/i) {
684 my $patchname = "patch$1";
685 $pkgdata{main}{$patchname} = $2;
686 if ($pkgdata{main}{$patchname} =~ /\//) {
687 # URL-style patch. Rare but not unheard-of.
688 my @patchbits = split '/', $pkgdata{main}{$patchname};
689 $pkgdata{main}{$patchname} = $patchbits[$#patchbits];
690 }
691 chomp $pkgdata{main}{$patchname};
692 } elsif (/^buildarch(?:itecture)?:\s+(.+)/i) {
693 $pkgdata{main}{arch} = $1;
694 $buildarch = $pkgdata{main}{arch};
695 } elsif (/^buildreq(?:uires)?:\s+(.+)/i) {
696 $buildreq .= ", $1";
697 } elsif (/^requires:\s+(.+)/i) {
698 $pkgdata{main}{requires} .= ", ".expandmacros("$1", 'gp');
699 } elsif (/^provides:\s+(.+)/i) {
700 $pkgdata{main}{provides} .= ", $1";
701 } elsif (/^conflicts:\s+(.+)/i) {
702 $pkgdata{main}{conflicts} .= ", $1";
703 }
704#Name: suwrap
705#Version: 0.04
706#Release: 3
707#Group: Applications/System
708#Copyright: WebHart internal ONLY. :(
709#BuildArchitectures: i386
710#BuildRoot: /tmp/%{name}-%{version}
711#Url: http://virtual.webhart.net
712#Packager: Kris Deugau <kdeugau@deepnet.cx>
713#Source: ftp://virtual.webhart.net/%{name}-%{version}.tar.gz
714
715 }
716 }
717
718 # Parse and replace some more macros. More will be replaced even later.
719
720 # Expand macros as necessary.
721 $scriptletbase = expandmacros($scriptletbase,'gp');
722
723 $buildroot = $cmdbuildroot if $cmdbuildroot;
724 $buildroot = expandmacros($buildroot,'gp');
725
726 close SPECFILE;
727} # end parse_spec()
728
729
730## prep()
731# Writes and executes the %prep script (mostly) built while reading the spec file.
732sub prep {
733 # Replace some things here just to make sure.
734 $prepscript = expandmacros($prepscript,'gp');
735
736#print $prepscript; exit 0;
737
738 # create script filename
739 my $prepscriptfile = "$tmpdir/deb-tmp.prep.".int(rand(99998)+1);
740 sysopen(PREPSCRIPT, $prepscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
741 or die $!;
742 print PREPSCRIPT $scriptletbase;
743 print PREPSCRIPT $prepscript;
744 close PREPSCRIPT;
745
746 # execute
747 print "Calling \%prep script $prepscriptfile...\n";
748 system("/bin/sh -e $prepscriptfile") == 0
749 or die "Can't exec: $!\n";
750
751 # and clean up
752 unlink $prepscriptfile;
753} # end prep()
754
755
756## build()
757# Writes and executes the %build script (mostly) built while reading the spec file.
758sub build {
759 # Expand the macros
760 $buildscript = expandmacros($buildscript,'cgbp');
761
762 # create script filename
763 my $buildscriptfile = "$tmpdir/deb-tmp.build.".int(rand(99998)+1);
764 sysopen(BUILDSCRIPT, $buildscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
765 or die $!;
766 print BUILDSCRIPT $scriptletbase;
767 print BUILDSCRIPT $buildscript;
768 close BUILDSCRIPT;
769
770 # execute
771 print "Calling \%build script $buildscriptfile...\n";
772 system("/bin/sh -e $buildscriptfile") == 0
773 or die "Can't exec: $!\n";
774
775 # and clean up
776 unlink $buildscriptfile;
777} # end build()
778
779
780## install()
781# Writes and executes the %install script (mostly) built while reading the spec file.
782sub install {
783 # Expand the macros
784 $installscript = expandmacros($installscript,'igbp');
785
786 # create script filename
787 my $installscriptfile = "$tmpdir/deb-tmp.inst.".int(rand(99998)+1);
788 sysopen(INSTSCRIPT, $installscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
789 or die $!;
790 print INSTSCRIPT $scriptletbase;
791# print INSTSCRIPT $cleanscript; # Clean up our install target before installing into it.
792 print INSTSCRIPT $installscript;
793 close INSTSCRIPT;
794
795 # execute
796 print "Calling \%install script $installscriptfile...\n";
797 system("/bin/sh -e $installscriptfile") == 0
798 or die "Can't exec: $!\n";
799
800 # and clean up
801 unlink $installscriptfile;
802} # end install()
803
804
805## binpackage()
806# Creates the binary .deb package from the installed tree in $buildroot.
807# Writes and executes a shell script to do so.
808# Creates miscellaneous files required by dpkg-deb to actually build the package file.
809# Should handle simple subpackages
810sub binpackage {
811
812 foreach my $pkg (@pkglist) {
813
814 $pkgdata{$pkg}{arch} = $hostarch if !$pkgdata{$pkg}{arch}; # Just In Case.
815 $pkgdata{$pkg}{arch} =~ s/^noarch/all/ig;
816
817 # Make sure we have somewhere to write the .deb file
818 if (!-e "$topdir/DEBS/$pkgdata{$pkg}{arch}") {
819 mkdir "$topdir/DEBS/$pkgdata{$pkg}{arch}";
820 }
821
822 # Skip building a package if it doesn't actually have any files. NB: This
823 # differs slightly from rpm's behaviour where a package *will* be built -
824 # even without any files - if %files is specified anywhere. I can think
825 # of odd corner cases where that *may* be desireable.
826 next if (!$filelist{$pkg} or $filelist{$pkg} =~ /^\s*$/);
827
828 # Gotta do this first, otherwise we don't have a place to move files from %files
829 mkdir "$buildroot/$pkg";
830
831 # Eliminate any lingering % macros
832 $filelist{$pkg} = expandmacros $filelist{$pkg}, 'g';
833
834 my @pkgfilelist = split ' ', $filelist{$pkg};
835 foreach my $pkgfile (@pkgfilelist) {
836 $pkgfile = expandmacros($pkgfile, 'gp');
837 my ($fpath,$fname) = ($pkgfile =~ m|(.+?/?)?([^/]+)$|); # We don't need $fname now, but we might.
838 qx { mkdir -p $buildroot/$pkg$fpath }
839 if $fpath && $fpath ne '';
840 qx { mv $buildroot$pkgfile $buildroot/$pkg$fpath };
841 }
842
843 # Get the "Depends" (Requires) a la RPM. Ish. We strip the leading
844 # comma and space here (if needed) in case there were "Requires" specified
845 # in the spec file - those would precede these.
846 $pkgdata{$pkg}{requires} .= getreqs("$buildroot/$pkg");
847
848 # magic needed to properly version dependencies...
849 # only provided deps will really be included
850 $pkgdata{$pkg}{requires} =~ s/^, //; # Still have to do this here.
851 $pkgdata{$pkg}{requires} =~ s/\s+//g;
852 my @deps = split /,/, $pkgdata{$pkg}{requires};
853 my $tmp = '';
854 foreach my $dep (@deps) {
855 # Hack up the perl(Class::SubClass) deps into something dpkg can understand.
856 # May or may not be versioned.
857 # We do this first so the version rewriter can do its magic next.
858 if (my ($mod,$ver) = ($dep =~ /^perl\(([A-Za-z0-9\:\-]+)\)([><=]+.+)?/) ) {
859 $mod =~ s/^perl\(//;
860 $mod =~ s/\)$//;
861 $mod =~ s/::/-/g;
862 $mod =~ tr/A-Z/a-z/;
863 $mod = "lib$mod-perl";
864 $mod .= $ver if $ver;
865 $dep = $mod;
866 }
867 if (my ($name,$rel,$value) = ($dep =~ /^([a-zA-Z0-9._-]+)([><=]+)([a-zA-Z0-9._-]+)$/)) {
868 $tmp .= ", $name ($rel $value)";
869 } else {
870 $tmp .= ", $dep";
871 }
872 }
873 ($pkgdata{$pkg}{requires} = $tmp) =~ s/^, //;
874
875 # Do this here since we're doing {depends}...
876 if (defined($pkgdata{$pkg}{provides})) {
877 $pkgdata{$pkg}{provides} =~ s/^, //;
878 $pkgdata{$pkg}{provides} = expandmacros($pkgdata{$pkg}{provides},'gp');
879 }
880 if (defined($pkgdata{$pkg}{conflicts})) {
881 $pkgdata{$pkg}{conflicts} =~ s/^, //;
882 $pkgdata{$pkg}{conflicts} = expandmacros($pkgdata{$pkg}{conflicts},'gp');
883 }
884
885 # Gotta do this next, otherwise the control file has nowhere to go. >:(
886 mkdir "$buildroot/$pkg/DEBIAN";
887
888 # Hack the filename for the package into a Debian-tool-compatible format. GRRRRRR!!!!!
889 # Have I mentioned I hate Debian Policy?
890 $pkgdata{$pkg}{name} =~ tr/_/-/;
891
892 # create script filename
893 my $debscriptfile = "$tmpdir/deb-tmp.pkg.".int(rand(99998)+1);
894 sysopen(DEBSCRIPT, $debscriptfile, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW)
895 or die $!;
896 print DEBSCRIPT $scriptletbase;
897 print DEBSCRIPT "fakeroot dpkg-deb -b $buildroot/$pkg $topdir/DEBS/$pkgdata{$pkg}{arch}/".
898 "$pkgdata{$pkg}{name}_$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb\n";
899 # %$&$%@#@@#%@@@ Debian and their horrible ugly package names. >:(
900 close DEBSCRIPT;
901
902 my $control = "Package: $pkgdata{$pkg}{name}\n".
903 "Version: $pkgdata{$pkg}{version}-$pkgdata{main}{release}\n".
904 "Section: $pkgdata{$pkg}{group}\n".
905 "Priority: optional\n".
906 "Architecture: $pkgdata{$pkg}{arch}\n".
907 "Maintainer: $pkgdata{main}{packager}\n".
908 ( $pkgdata{$pkg}{requires} ne '' ? "Depends: $pkgdata{$pkg}{requires}\n" : '' ).
909 ( defined($pkgdata{$pkg}{provides}) ? "Provides: $pkgdata{$pkg}{provides}\n" : '' ).
910 ( defined($pkgdata{$pkg}{conflicts}) ? "Conflicts: $pkgdata{$pkg}{conflicts}\n" : '' ).
911 "Description: $pkgdata{$pkg}{summary}\n";
912 $control .= "$pkgdata{$pkg}{desc}\n";
913
914 open CONTROL, ">$buildroot/$pkg/DEBIAN/control";
915 print CONTROL $control;
916 close CONTROL;
917
918 # Iff there are conffiles (as specified in the %files list(s), add'em
919 # in so dpkg-deb can tag them.
920 if ($pkgdata{$pkg}{conffiles}) {
921 open CONFLIST, ">$buildroot/$pkg/DEBIAN/conffiles";
922 foreach my $conffile (@{$pkgdata{$pkg}{conflist}}) {
923 print CONFLIST "$conffile\n";
924 }
925 close CONFLIST;
926 }
927
928 # found the point of scripts on subpackages.
929 if ($pkgdata{$pkg}{'pre'}) {
930 $pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'pre'},'gp');
931 open PREINST, ">$buildroot/$pkg/DEBIAN/preinst";
932 print PREINST "#!/bin/sh\nset -e\n\n";
933 print PREINST $pkgdata{$pkg}{'pre'};
934 close PREINST;
935 `chmod 0755 $buildroot/$pkg/DEBIAN/preinst`;
936 }
937 if ($pkgdata{$pkg}{'post'}) {
938 $pkgdata{$pkg}{'post'} = expandmacros($pkgdata{$pkg}{'post'},'gp');
939 open PREINST, ">$buildroot/$pkg/DEBIAN/postinst";
940 print PREINST "#!/bin/sh\nset -e\n\n";
941 print PREINST $pkgdata{$pkg}{'post'};
942 close PREINST;
943 `chmod 0755 $buildroot/$pkg/DEBIAN/postinst`;
944 }
945 if ($pkgdata{$pkg}{'preun'}) {
946 $pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'preun'},'gp');
947 open PREINST, ">$buildroot/$pkg/DEBIAN/prerm";
948 print PREINST "#!/bin/sh\nset -e\n\n";
949 print PREINST $pkgdata{$pkg}{'preun'};
950 close PREINST;
951 `chmod 0755 $buildroot/$pkg/DEBIAN/prerm`;
952 }
953 if ($pkgdata{$pkg}{'postun'}) {
954 $pkgdata{$pkg}{'postun'} = expandmacros($pkgdata{$pkg}{'postun'},'gp');
955 open PREINST, ">$buildroot/$pkg/DEBIAN/postrm";
956 print PREINST "#!/bin/sh\nset -e\n\n";
957 print PREINST $pkgdata{$pkg}{'postun'};
958 close PREINST;
959 `chmod 0755 $buildroot/$pkg/DEBIAN/postrm`;
960 }
961
962 # execute
963 print "Calling package creation script $debscriptfile for $pkgdata{$pkg}{name}...\n";
964 system("/bin/sh -e $debscriptfile") == 0
965 or die "Can't exec: $!\n";
966
967 $finalmessages .= "Wrote binary package ".
968 "$pkgdata{$pkg}{name}_$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb".
969 " in $topdir/DEBS/$pkgdata{$pkg}{arch}\n";
970 # and clean up
971 unlink $debscriptfile;
972
973 } # subpackage loop
974
975} # end binpackage()
976
977
978## srcpackage()
979# Builds a .src.deb source package. Note that Debian's idea of
980# a "source package" is seriously flawed IMO, because you can't
981# easily copy it as-is.
982# Not quite identical to RPM, but Good Enough (TM).
983sub srcpackage {
984 # In case we were called with -bs.
985 $pkgdata{main}{name} =~ tr/_/-/;
986 my $pkgsrcname = "$pkgdata{main}{name}-$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb";
987
988 my $paxcmd;
989
990 # We'll definitely need this later, and *may* need it sooner.
991 (my $barespec = $specfile) =~ s|.+/([^/]+)$|$1|;
992
993 # Copy the specfile to the build tree, but only if it's not there already.
994##buglet: need to deal with silly case where silly user has put the spec
995# file in a subdir of %{_topdir}/SPECS. Ewww. Silly user!
996 if (abs_path($specfile) !~ /^$topdir\/SPECS/) {
997 $paxcmd .= "cp $specfile %{_topdir}/SPECS/; \n"
998 }
999
1000 # use pax -w [file] [file] ... >outfile.sdeb
1001 $paxcmd = "cd $topdir; pax -w ";
1002
1003# tweak source entry into usable form. Need it locally somewhere along the line.
1004 (my $pkgsrc = $pkgdata{main}{source}) =~ s|.+/([^/]+)$|$1|;
1005 $paxcmd .= "SOURCES/$pkgsrc ";
1006
1007 # create file list: Source[nn], Patch[nn]
1008 foreach my $specbit (keys %{$pkgdata{main}} ) {
1009 next if $specbit eq 'source';
1010 $paxcmd .= "SOURCES/$pkgdata{main}{$specbit} " if $specbit =~ /^patch/;
1011##buglet: need to deal with case where patches are listed as URLs?
1012# or other extended pathnames? Silly !@$%^&!%%!%!! user!
1013 }
1014
1015 foreach my $source (keys %{$pkgdata{sources}}) {
1016 $paxcmd .= "SOURCES/$pkgdata{sources}{$source} ";
1017 }
1018
1019 # add the spec file, source package destination, and cd back where we came from.
1020 $paxcmd .= "SPECS/$barespec > $topdir/SDEBS/$pkgsrcname; cd -";
1021
1022 # In case of %-macros...
1023 $paxcmd = expandmacros($paxcmd,'gp');
1024
1025 system "$paxcmd";
1026 $finalmessages .= "Wrote source package $pkgsrcname in $topdir/SDEBS.\n";
1027}
1028
1029
1030## checkbuildreq()
1031# Checks the build requirements (if any)
1032# Spits out a rude warning and returns a true-false error if any
1033# requirements are not met.
1034sub checkbuildreq {
1035 return 1 if $buildreq eq ''; # No use doing extra work.
1036
1037 if ( ! -e "/usr/bin/dpkg-query" ) {
1038 print "**WARNING** dpkg-query not found. Can't check build-deps.\n".
1039 " Required for sucessful build:\n".$buildreq."\n".
1040 " Continuing anyway.\n";
1041 return 1;
1042 }
1043
1044 my $reqflag = 1; # unset iff a buildreq is missing
1045
1046 $buildreq =~ s/^, //; # Strip the leading comma and space
1047 my @reqlist = split /,\s+/, $buildreq;
1048
1049 foreach my $req (@reqlist) {
1050 my ($pkg,$rel,$ver);
1051
1052 # We have two classes of requirements - versioned and unversioned.
1053 if ($req =~ /[><=]/) {
1054 # Pick up the details of versioned buildreqs
1055 ($pkg,$rel,$ver) = ($req =~ /([a-z0-9._-]+)\s+([><=]+)\s+([a-z0-9._-]+)/);
1056 } else {
1057 # And the unversioned ones.
1058 $pkg = $req;
1059 $rel = '>=';
1060 $ver = 0;
1061 }
1062
1063 my @pkglist = qx { dpkg-query --showformat '\${status}\t\${version}\n' -W $pkg };
1064# need to check if no lines returned - means a bad buildreq
1065 my ($reqstat,undef,undef,$reqver) = split /\s+/, $pkglist[0];
1066 if ($reqstat !~ /install/) {
1067 print " * Missing build-dependency $pkg!\n";
1068 $reqflag = 0;
1069 } else {
1070# gotta be a better way to do this... :/
1071 if ($rel eq '>=' && !($reqver ge $ver)) {
1072 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1073 $reqflag = 0;
1074 }
1075 if ($rel eq '>' && !($reqver gt $ver)) {
1076 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1077 $reqflag = 0;
1078 }
1079 if ($rel eq '<=' && !($reqver le $ver)) {
1080 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1081 $reqflag = 0;
1082 }
1083 if ($rel eq '<' && !($reqver lt $ver)) {
1084 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1085 $reqflag = 0;
1086 }
1087 if ($rel eq '=' && !($reqver eq $ver)) {
1088 print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
1089 $reqflag = 0;
1090 }
1091 } # end not installed/installed check
1092 } # end req loop
1093
1094 return $reqflag;
1095} # end checkbuildreq()
1096
1097
1098## getreqs()
1099# Find out which libraries/packages are required for any
1100# executables and libs in a given file tree.
1101# (Debian doesn't have soname-level deps; just package-level)
1102# Returns an empty string if the tree contains no binaries.
1103# Doesn't work well on shell scripts. but those *should* be
1104# fine anyway. (Yeah, right...)
1105sub getreqs() {
1106 my $pkgtree = $_[0];
1107
1108 print "Checking library requirements...\n";
1109 my @binlist = qx { find $pkgtree -type f -perm 755 };
1110
1111 if (scalar(@binlist) == 0) {
1112 return '';
1113 }
1114
1115 my @reqlist;
1116 foreach (@binlist) {
1117 push @reqlist, qx { ldd $_ };
1118 }
1119
1120 # Get the list of libs provided by this package. Still doesn't
1121 # handle the case where the lib gets stuffed into a subpackage. :/
1122 my @intprovlist = qx { find $pkgtree -type f -name "*.so*" };
1123 my $provlist = '';
1124 foreach (@intprovlist) {
1125 s/$pkgtree//;
1126 $provlist .= "$_";
1127 }
1128
1129 my %reqs;
1130 my $reqlibs = '';
1131
1132 foreach (@reqlist) {
1133 next if /^$pkgtree/;
1134 next if /not a dynamic executable/;
1135 next if m|/lib/ld-linux.so|; # Hack! Hack! PTHBTT! (libc suxx0rz)
1136
1137 my ($req) = (/^\s+([a-z0-9._-]+)/); # dig out the actual library (so)name
1138
1139 # Ignore libs provided by this package. Note that we don't match
1140 # on word-boundary at the *end* of the lib we're looking for, as the
1141 # looked-for lib may not have the full soname version. (ie, it may
1142 # "just" point to one of the symlinks that get created somewhere.)
1143 next if $provlist =~ /\b$req/;
1144
1145 $reqlibs .= " $req";
1146 }
1147
1148 if ($reqlibs ne '') {
1149 foreach (qx { dpkg -S $reqlibs }) {
1150 my ($libpkg,undef) = split /:\s+/;
1151 $reqs{$libpkg} = 1;
1152 }
1153 }
1154
1155 my $deplist = '';
1156 foreach (keys %reqs) {
1157 $deplist .= ", $_";
1158 }
1159
1160# For now, we're done. We're not going to meddle with versions yet.
1161# Among other things, it's messier than handling "simple" yes/no "do
1162# we have this lib?" deps. >:(
1163
1164 return $deplist;
1165} # end getreqs()
1166
1167
1168## install_sdeb()
1169# Extracts .sdeb contents to %_topdir as appropriate
1170sub install_sdeb {
1171 my $paxcmd = "cd $topdir; pax -r <$srcpkg; cd -";
1172
1173 # In case of %-macros...
1174 $paxcmd = expandmacros($paxcmd,'gp');
1175
1176 system "$paxcmd";
1177 print "Extracted source package $srcpkg to $topdir.\n";
1178} # end install_sdeb()
1179
1180
1181## expandmacros()
1182# Expands all %{blah} macros in the passed string
1183# Split up a bit with some sections so we don't spend time trying to
1184# expand macros that are only used in a few specific places.
1185sub expandmacros {
1186 my $macrostring = shift;
1187 my $section = shift;
1188
1189 # To allow the FHS-ish %configure and %makeinstall to work The Right Way.
1190 # (Without clobbering the global $buildroot.)
1191 my $prefix = '';
1192
1193 if ($section =~ /c/) {
1194 # %configure macro
1195# Don't know what it's for, don't have a useful default replacement
1196# --program-prefix=%{_program_prefix} \
1197 $macrostring =~ s'%configure'./configure --host=$DEB_HOST_GNU_TYPE \
1198 --build=$DEB_BUILD_GNU_TYPE \
1199 --prefix=%{_prefix} \
1200 --exec-prefix=%{_exec_prefix} \
1201 --bindir=%{_bindir} \
1202 --sbindir=%{_sbindir} \
1203 --sysconfdir=%{_sysconfdir} \
1204 --datadir=%{_datadir} \
1205 --includedir=%{_includedir} \
1206 --libdir=%{_libdir} \
1207 --libexecdir=%{_libexecdir} \
1208 --localstatedir=%{_localstatedir} \
1209 --sharedstatedir=%{_sharedstatedir} \
1210 --mandir=%{_mandir} \
1211 --infodir=%{_infodir} ';
1212 } # done %configure
1213
1214 if ($section =~ /m/) {
1215 $macrostring =~ s'%{__make}'make ';
1216 } # done make
1217
1218 if ($section =~ /i/) {
1219 # This is where we need to mangle $prefix.
1220 $macrostring =~ s'%makeinstall'make %{fhs} install';
1221 $prefix = $buildroot;
1222 } # done %install and/or %makeinstall
1223
1224 # Build data
1225 # Note that these are processed in reverse order to get the substitution order right
1226 if ($section =~ /b/) {
1227# $macrostring =~ s'%{fhs}'host=$DEB_HOST_GNU_TYPE \
1228# build=$DEB_BUILD_GNU_TYPE \
1229 $macrostring =~ s'%{fhs}'prefix=%{_prefix} \
1230 exec-prefix=%{_exec_prefix} \
1231 bindir=%{_bindir} \
1232 sbindir=%{_sbindir} \
1233 sysconfdir=%{_sysconfdir} \
1234 datadir=%{_datadir} \
1235 includedir=%{_includedir} \
1236 libdir=%{_libdir} \
1237 libexecdir=%{_libexecdir} \
1238 localstatedir=%{_localstatedir} \
1239 sharedstatedir=%{_sharedstatedir} \
1240 mandir=%{_mandir} \
1241 infodir=%{_infodir} \
1242';
1243
1244 # Note that the above regex terminates with the extra space
1245 # "Just In Case" of user additions, which will then get neatly
1246 # tagged on the end where they take precedence (supposedly)
1247 # over the "default" ones.
1248
1249 # Now we cascade the macros introduced above. >_<
1250 # Wot ot to go theah:
1251 $macrostring =~ s|%{_mandir}|%{_datadir}/man|g; #/usr/share/man
1252 $macrostring =~ s|%{_infodir}|%{_datadir}/info|g; #/usr/share/info
1253 $macrostring =~ s|%{_oldincludedir}|/usr/include|g; #/usr/include
1254 $macrostring =~ s|%{_includedir}|%{_prefix}/include|g; #/usr/include
1255 $macrostring =~ s|%{_libdir}|%{_exec_prefix}/%{_lib}|g; #/usr/lib
1256 $macrostring =~ s|%{_lib}|lib|g; #?
1257 $macrostring =~ s|%{_localstatedir}|/var|g; #/var
1258 $macrostring =~ s|%{_sharedstatedir}|%{_prefix}/com|g; #/usr/com WTF?
1259 $macrostring =~ s|%{_sysconfdir}|/etc|g; #/etc
1260 $macrostring =~ s|%{_datadir}|%{_prefix}/share|g; #/usr/share
1261 $macrostring =~ s|%{_libexecdir}|%{_exec_prefix}/libexec|g; #/usr/libexec
1262 $macrostring =~ s|%{_sbindir}|%{_exec_prefix}/sbin|g; #/usr/sbin
1263 $macrostring =~ s|%{_bindir}|%{_exec_prefix}/bin|g; #/usr/bin
1264 $macrostring =~ s|%{_exec_prefix}|%{_prefix}|g; #/usr
1265 $macrostring =~ s|%{_prefix}|/usr|g; #/usr
1266 } # done with config section
1267
1268 # Package data
1269 if ($section =~ /p/) {
1270 $macrostring =~ s/\%\{buildroot\}/$buildroot/gi;
1271 foreach my $source (keys %{$pkgdata{sources}}) {
1272 $macrostring =~ s/\%\{source$source\}/$topdir\/SOURCES\/$pkgdata{sources}{$source}/gi;
1273 }
1274 $macrostring =~ s/\%\{name\}/$pkgdata{main}{name}/gi;
1275 $macrostring =~ s/\%\{version\}/$pkgdata{main}{version}/gi;
1276 $macrostring =~ s/\%\{release\}/$pkgdata{main}{release}/gi;
1277 }
1278
1279 # Globals, and not-so-globals
1280 if ($section =~ /g/) {
1281
1282 # special %define's. Handle the general case where we eval anything.
1283 # Prime example:
1284 #%define perl_vendorlib %(eval "`perl -V:installvendorlib`"; echo $installvendorlib)
1285 if ($macrostring =~ /^\%\(eval.+\)$/) {
1286 $macrostring =~ s/^\%\(//;
1287 $macrostring =~ s/\)$//;
1288 # Oy vey this gets silly for the perl bits. Executing a shell to
1289 # call Perl to get the vendorlib/sitelib/whatever "core" globals.
1290 # This can do more, but... eww.
1291 # Next line is non-optimal - what if $macrostring contains ' characters?
1292 $macrostring = qx { /bin/sh -c '$macrostring' };
1293 }
1294
1295 $macrostring =~ s|%{_builddir}|%{_topdir}/BUILD|g;
1296 $macrostring =~ s|%{_topdir}|$topdir|g;
1297 $macrostring =~ s|%{_tmppath}|$tmpdir|g;
1298 $macrostring =~ s'%{_docdir}'%{_datadir}/doc'g;
1299
1300 # Standard FHS locations. More or less.
1301 $macrostring =~ s'%{_bindir}'/usr/bin'g;
1302 $macrostring =~ s'%{_sbindir}'/usr/sbin'g;
1303 $macrostring =~ s'%{_mandir}'%{_datadir}/man'g;
1304 $macrostring =~ s'%{_includedir}'/usr/include'g;
1305 $macrostring =~ s'%{_libdir}'/usr/lib'g;
1306 $macrostring =~ s'%{_sysconfdir}'/etc'g;
1307 $macrostring =~ s'%{_localstatedir}'/var'g;
1308
1309 # FHS-ish locations that aren't quite actually FHS-specified.
1310 $macrostring =~ s'%{_datadir}'/usr/share'g;
1311
1312 # %define's
1313 foreach my $key (keys %specglobals) {
1314 $macrostring =~ s|%{$key}|$specglobals{$key}|g;
1315 }
1316
1317 # system programs. RPM uses a global config file for these; we'll just
1318 # ASS-U-ME and make life a little simpler.
1319 if ($macrostring =~ /\%\{\_\_([a-z0-9_-]+)\}/) {
1320 $macrostring =~ s|%{__([a-z0-9_-]+)}|$1|g;
1321 }
1322
1323 # Misc expansions
1324 $macrostring =~ s|%{_arch}|$hostarch|g;
1325 $macrostring =~ s|%{optflags}|$optflags{$hostarch}|g;
1326
1327 } # done with globals section
1328
1329 return $macrostring;
1330} # end expandmacros()
1331
1332
1333
1334__END__
1335
1336
1337
1338=head1 NAME
1339
1340debbuild - Build Debian-compatible packages from RPM spec files
1341
1342=head1 SYNOPSIS
1343
1344 debbuild {-ba|-bb|-bp|-bc|-bi|-bl|-bs} [build-options] file.spec
1345
1346 debbuild {-ta|-tb|-tp|-tc|-ti|-tl|-ts} [build-options] file.tar.{gz|bz2}
1347
1348 debbuild --rebuild file.{src.rpm|sdeb}
1349
1350=head1 DESCRIPTION
1351
1352This script attempts to build Debian-friendly semi-native packages from RPM spec files,
1353RPM-friendly tarballs, and RPM source packages (.src.rpm files). It accepts I<most> of the
1354options rpmbuild does, and should be able to interpret most spec files usefully. Perl
1355modules should be handled via CPAN+dh-make-perl instead; Debian's conventions for such
1356things do not lend themselves to automated conversion.
1357
1358As far as possible, the command-line options are identical to those from rpmbuild, although
1359several rpmbuild options are not supported:
1360
1361 --recompile
1362 --showrc
1363 --buildroot
1364 --clean
1365 --nobuild
1366 --rmsource
1367 --rmspec
1368 --sign
1369 --target
1370
1371Some of these could probably be trivially added. Feel free to send me a patch. ;)
1372
1373Complex spec files will most likely not work well, if at all. Rewrite them from scratch -
1374you'll have to make heavy modifications anyway.
1375
1376If you see something you don't like, mail me. Send a patch if you feel inspired. I don't
1377promise I'll do anything other than say "Yup, that's broken" or "Got your message".
1378
1379=head1 ASSUMPTIONS
1380
1381As with rpmbuild, debbuild makes some assumptions about your system.
1382
1383=over 4
1384
1385=item *
1386
1387Either you have rights to do as you please under /usr/src/debian, or you have created a file
1388~/.debmacros containing a suitable %_topdir definition.
1389
1390Both rpmbuild and debbuild require the directories %_topdir/{BUILD,SOURCES,SPECS}. However,
1391where rpmbuild requires the %_topdir/{RPMS,SRPMS} directories, debbuild
1392requires %_topdir/{DEBS,SDEBS} instead. Create them in advance;
1393some subdirectories are created automatically as needed, but most are not.
1394
1395=item *
1396
1397/var/tmp must allow script execution - rpmbuild and debbuild both rely on creating and
1398executing shell scripts for much of their functionality. By default, debbuild also creates
1399install trees under /var/tmp - however this is (almost) entirely under the control of the
1400package's .spec file.
1401
1402=item *
1403
1404If you wish to --rebuild a .src.rpm, your %_topdir for both debbuild and rpmbuild must either
1405match, or be suitably symlinked one direction or another so that both programs are effectively
1406working in the same tree. (Or you could just manually wrestle files around your system.)
1407
1408You could symlink ~/.rpmmacros to ~/.debmacros (or vice versa) and save yourself some hassle
1409if you need to rebuild .src.rpm packages on a regular basis. Currently debbuild only uses the
1410%_topdir macro definition, although there are many more things that rpmbuild can use from
1411~/.rpmmacros.
1412
1413=back
1414
1415=head1 AUTHOR
1416
1417debbuild was written by Kris Deugau <kdeugau@deepnet.cx>. A version that approximates
1418current is available at http://www.deepnet.cx/debbuild/.
1419
1420=head1 BUGS
1421
1422Funky Things Happen if you forget a command-line option or two. I've been too lazy to bother
1423fixing this.
1424
1425Many macro expansions are unsupported or incompletely supported.
1426
1427The generated scriptlets don't quite match those from rpmbuild exactly. There are extra
1428environment variables and preprocessing that I haven't needed (yet).
1429
1430Dcumentation, such as it is, will likely remain perpetually out of date.
1431
1432%_topdir and the five "working" directories under %_topdir could arguably be created by
1433debbuild. However, rpmbuild doesn't create these directories either.
1434
1435=head1 SEE ALSO
1436
1437rpm(8), rpmbuild(8), and pretty much any document describing how to write a .spec file.
1438
1439=cut
Note: See TracBrowser for help on using the repository browser.