Context Navigation

source: trunk/debbuild@ 106

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

/trunk

Add glob handling to %config lines in the %files section. It needs to
be explicit so that we can actually stuff all of the real filenames
into the DEBIAN/conffiles .deb metadata block. :/

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

File size: 52.5 KB

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

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

Download in other formats: