Context Navigation

source: trunk/debbuild@ 193

Last change on this file since 193 was 193, checked in by kdeugau, 9 years ago

/trunk

A rollup of trivial bits.

Prod copyright dates
Remove [ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT leadin on %install scriptlet; rpmbuild either never did this (possible) or it doesn't do it any more (more likely)
Fix subtle brokenness in boolean macro %{?foo}/%{?!foo}; it was producing output when it shouldn't have.

Property svn:executable set to *
Property svn:keywords set to Date Rev Author

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: