Context Navigation

source: trunk/debbuild@ 161

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

/trunk

Fix handling of long descriptions with blank (or "blank") lines
Thanks to Andreas Itzchak Rehberg for pointing it out

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

File size: 64.4 KB

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

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

Download in other formats: