Context Navigation

source: trunk/debbuild@ 153

Last change on this file since 153 was 153, checked in by kdeugau, 14 years ago

/trunk

Misc bugfixes and don't-cut-the-corner-case-ing

Expand package data macros as well as 'globals' at a couple of points (may prove simpler to merge these two)
gzip info pages as well as man pages
expand manpage-directory references in %files so that we properly gzip them without having to specify Every. Last. Bloody. Page. when there are "many" in the set. NB: applies only to .../man/man<n>/, not .../man/
make sure to expand %{_infodir} as "global data"

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

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

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

Download in other formats: