Context Navigation

source: trunk/debbuild@ 66

Last change on this file since 66 was 66, checked in by kdeugau, 18 years ago

/trunk

Fix buglet where Patchnn: and %patch macro expansion didn't quite
work - corner case where no options to patch were supplied

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

File size: 41.4 KB

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

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

Download in other formats: