moritzruth/void-packages
1
0
Fork 0
Code Releases Activity Actions 2

Merge xbps-src code to make it usable in a standalone mode.

Browse source 
The new xbps-src configuration file is `etc/conf` where you can
add your local overrides from defaults set via `etc/defaults.conf`.

To use this xbps-src, run these steps:

	$ make
	$ sudo make setup (to make chroot helper setgid)
	$ ./xbps-src ...
This commit is contained in:
Juan RP 2014-03-22 12:31:42 +01:00
parent 49e9dc0df8
commit 0b95cb8f5d
20 changed files with 2825 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

32
Makefile Normal file
View file

@ -0,0 +1,32 @@
# xbps-packages top-level Makefile.
#
# MUTABLE VARIABLES
PRIVILEGED_GROUP ?= xbuilder
# INMUTABLE VARIABLES
VERSION = 112
GITVER := $(shell git rev-parse --short HEAD)
SHAREDIR = common/xbps-src/shutils
LIBEXECDIR = common/xbps-src/libexec
CHROOT_C = uchroot.c
CHROOT_BIN = xbps-src-chroot-helper
CFLAGS += -O2 -Wall -Werror
.PHONY: all setup clean
all:
sed -e "s|@@XBPS_SRC_VERSION@@|$(VERSION) ($(GITVER))|g" \
${CURDIR}/common/xbps-src/xbps-src.sh > ${CURDIR}/xbps-src
$(CC) $(CFLAGS) ${LIBEXECDIR}/$(CHROOT_C) -o ${LIBEXECDIR}/$(CHROOT_BIN)
chmod 755 xbps-src
@echo
@echo "The chroot helper must be a setgid binary (4750) for the group '$(PRIVILEGED_GROUP)'."
@echo "Please run 'sudo make setup' to set appropiate permissions."
setup:
chown root:$(PRIVILEGED_GROUP) $(LIBEXECDIR)/$(CHROOT_BIN)
chmod 4750 $(LIBEXECDIR)/$(CHROOT_BIN)
clean:
rm -f xbps-src $(LIBEXECDIR)/$(CHROOT_BIN)

3
common/xbps-src/chroot/repos-local.conf Normal file
View file

@ -0,0 +1,3 @@
# Local repositories
repository=/host/binpkgs
repository=/host/binpkgs/nonfree

3
common/xbps-src/chroot/repos-remote.conf Normal file
View file

@ -0,0 +1,3 @@
# Remote repositories
repository=http://repo.voidlinux.eu/current
repository=http://repo.voidlinux.eu/current/nonfree

68
common/xbps-src/chroot/xbps.conf Normal file
View file

@ -0,0 +1,68 @@
# Configuration file for XBPS.
#
# - Lines starting with # are ignored.
# - Values are set after the equal sign, and don't accept blanks nor newlines.
# Set root directory, by default set to /. This expects an absolute path.
#rootdir=/
# Set cache directory, if starts with / it's an absolute path,
# otherwise it's relative to rootdir.
cachedir=/host/repocache
# comment it out to disable syslog logging.
#syslog=true
## REPOSITORIES
#
# Local or remote repositories are accepted.
#
# - Local repositories expect an absolute path to the directory that stores
# the <arch>-repodata file.
# - Accepted protocols for remote repositories: ftp, http or https.
# - Repositories are added in the order in which are specified (top->bottom).
#
#repository=http://repo.voidlinux.eu/current
# Uncomment this one for "non-free" packages.
#repository=http://repo.voidlinux.eu/current/nonfree
# REPOSITORY MIRRORS
#repository=http://repo2.voidlinux.eu/current
#repository=http://repo2.voidlinux.eu/current/nonfree
#
#repository=http://xbps.nopcode.org/repos/current
#repository=http://xbps.nopcode.org/repos/current/nonfree
## VIRTUAL PACKAGES
#
# Virtual package overrides. You can set your own list of preferred virtual
# packages in your system. This expects two arguments separated by a colon:
# <vpkgver>:<realpkgname>.
#
# - <vpkgver> means "virtual package name" and "version/revision"
# separated by a dash, i.e 'foo-1.0_1".
# - <realpkgname> means a real package name (without any version).
#
# By default we prefer the `dcron` package as default cron daemon.
#virtualpkg=cron-daemon-0_1:dcron
# Sets the virtual package directory looking for .vpkg files with
# virtual package settings (by using the `virtualpkg' keyword).
#
# If starts with / it's an absolute path, otherwise it's relative to rootdir.
# By default it's set to <rootdir>/etc/xbps/virtualpkg.d.
#virtualpkgdir=etc/xbps/virtualpkg.d
# You can also include additional files by using the "include" keyword.
# This expects an absolute path to a file.
#include=/path/to/another/file.conf
#
# Alternative repos
include=/etc/xbps/repos/alternative.conf
# Local repos
include=/etc/xbps/repos/local.conf
# Remote repos
include=/etc/xbps/repos/remote.conf

273
common/xbps-src/libexec/uchroot.c Normal file
View file

@ -0,0 +1,273 @@
/*-
* Copyright (c) 2014 Juan Romero Pardines.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This is based on linux-user-chroot by Colin Walters, but has been adapted
* specifically for xbps-src use:
*
* - This bind mounts exactly what we need, no support for additional mounts.
* - This uses IPC/PID/mount namespaces, nothing more.
* - Disables namespace features if running in OpenVZ containers.
*/
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/prctl.h>
#include <sys/fsuid.h>
#include <sys/mount.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <sched.h>
#include <limits.h> /* PATH_MAX */
#ifndef SECBIT_NOROOT
#define SECBIT_NOROOT (1 << 0)
#endif
#ifndef SECBIT_NOROOT_LOCKED
#define SECBIT_NOROOT_LOCKED (1 << 1)
#endif
#ifndef PR_SET_NO_NEW_PRIVS
#define PR_SET_NO_NEW_PRIVS 38
#endif
static void
die(const char *fmt, ...)
{
va_list ap;
int save_errno = errno;
va_start(ap, fmt);
fprintf(stderr, "ERROR ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, " (%s)\n", strerror(save_errno));
va_end(ap);
exit(EXIT_FAILURE);
}
static void
usage(const char *p)
{
printf("Usage: %s [-D dir] [-H dir] [-S dir] <chrootdir> <command>\n\n"
"-D <distdir> Directory to be bind mounted at <chrootdir>/xbps-packages\n"
"-H <hostdir> Directory to be bind mounted at <chrootdir>/host\n"
"-S <shmdir> Directory to be bind mounted at <chrootdir>/<shmdir>\n", p);
exit(EXIT_FAILURE);
}
static int
fsuid_chdir(uid_t uid, const char *path)
{
int saveerrno, rv;
(void)setfsuid(uid);
rv = chdir(path);
saveerrno = errno;
(void)setfsuid(0);
errno = saveerrno;
return rv;
}
static int
openvz_container(void)
{
if ((!access("/proc/vz/vzaquota", R_OK)) &&
(!access("/proc/user_beancounters", R_OK)))
return 1;
return 0;
}
static void
bindmount(uid_t ruid, const char *chrootdir, const char *dir, const char *dest)
{
char mountdir[PATH_MAX-1];
snprintf(mountdir, sizeof(mountdir), "%s/%s", chrootdir, dest ? dest : dir);
if (fsuid_chdir(ruid, dir) == -1)
die("Couldn't chdir to %s", dir);
if (mount(".", mountdir, NULL, MS_BIND|MS_PRIVATE, NULL) == -1)
die("Failed to bind mount %s at %s", dir, mountdir);
}
int
main(int argc, char **argv)
{
uid_t ruid, euid, suid;
gid_t rgid, egid, sgid;
const char *chrootdir, *distdir, *hostdir, *shmdir, *cmd, *argv0;
char **cmdargs, mountdir[PATH_MAX-1];
int aidx = 0, clone_flags, child_status = 0;
pid_t child;
chrootdir = distdir = hostdir = shmdir = cmd = NULL;
argv0 = argv[0];
argc--;
argv++;
if (argc < 2)
usage(argv0);
while (aidx < argc) {
if (strcmp(argv[aidx], "-D") == 0) {
/* distdir */
distdir = argv[aidx+1];
aidx += 2;
} else if (strcmp(argv[aidx], "-H") == 0) {
/* hostdir */
hostdir = argv[aidx+1];
aidx += 2;
} else if (strcmp(argv[aidx], "-S") == 0) {
/* shmdir */
shmdir = argv[aidx+1];
aidx += 2;
} else {
break;
}
}
if ((argc - aidx) < 2)
usage(argv0);
chrootdir = argv[aidx];
cmd = argv[aidx+1];
cmdargs = argv + aidx + 1;
/* Never allow chrootdir == / */
if (strcmp(chrootdir, "/") == 0)
die("/ is not allowed to be used as chrootdir");
if (getresgid(&rgid, &egid, &sgid) == -1)
die("getresgid");
if (getresuid(&ruid, &euid, &suid) == -1)
die("getresuid");
if (rgid == 0)
rgid = ruid;
clone_flags = (SIGCHLD|CLONE_NEWNS|CLONE_NEWIPC|CLONE_NEWUTS|CLONE_NEWPID);
if (openvz_container()) {
/*
* If running in a OpenVZ container simply disable all namespace
* features.
*/
clone_flags &= ~(CLONE_NEWNS|CLONE_NEWIPC|CLONE_NEWUTS|CLONE_NEWPID);
}
/* Issue the clone(2) syscall with our settings */
if ((child = syscall(__NR_clone, clone_flags, NULL)) == -1)
die("clone");
if (child == 0) {
/*
* Restrict privileges on the child.
*/
if (prctl(PR_SET_NO_NEW_PRIVS, 1) == -1 && errno != EINVAL) {
die("prctl PR_SET_NO_NEW_PRIVS");
} else if (prctl (PR_SET_SECUREBITS,
SECBIT_NOROOT|SECBIT_NOROOT_LOCKED) == -1) {
die("prctl SECBIT_NOROOT");
}
if (!openvz_container()) {
/* Make / a private mount */
if (mount(NULL, "/", "none", MS_PRIVATE|MS_REC, NULL) == -1)
die("mount(/, MS_PRIVATE|MS_REC)");
/* Remount / with nosuid just in case */
if (mount (NULL, "/", "none", MS_PRIVATE|MS_REMOUNT|MS_NOSUID, NULL) == -1)
die("mount(/, MS_PRIVATE|MS_REMOUNT|MS_NOSUID");
}
/* mount /proc */
snprintf(mountdir, sizeof(mountdir), "%s/proc", chrootdir);
if (mount("proc", mountdir, "proc", MS_MGC_VAL|MS_PRIVATE, NULL) == -1)
die("Failed to mount %s", mountdir);
/* bind mount /sys */
bindmount(ruid, chrootdir, "/sys", NULL);
/* bind mount /dev */
bindmount(ruid, chrootdir, "/dev", NULL);
/* bind mount hostdir if set */
if (hostdir)
bindmount(ruid, chrootdir, hostdir, "/host");
/* bind mount distdir (if set) */
if (distdir)
bindmount(ruid, chrootdir, distdir, "/xbps-packages");
/* bind mount shmdir (if set) */
if (shmdir)
bindmount(ruid, chrootdir, shmdir, NULL);
/* move chrootdir to / and chroot to it */
if (fsuid_chdir(ruid, chrootdir) == -1)
die("Failed to chdir to %s", chrootdir);
if (mount(".", ".", NULL, MS_BIND|MS_PRIVATE, NULL) == -1)
die("Failed to bind mount %s", chrootdir);
if (mount(chrootdir, "/", NULL, MS_MOVE, NULL) == -1)
die("Failed to move %s as rootfs", chrootdir);
if (chroot(".") == -1)
die("Failed to chroot to %s", chrootdir);
/* Switch back to the gid/uid of invoking process */
if (setgid(rgid) == -1)
die("setgid child");
if (setuid(ruid) == -1)
die("setuid child");
if (execvp(cmd, cmdargs) == -1)
die("Failed to execute command %s", cmd);
}
/* Switch back to the gid/uid of invoking process also in the parent */
if (setgid(rgid) == -1)
die("setgid child");
if (setuid(ruid) == -1)
die("setuid child");
/* Wait until the child terminates */
while (waitpid(child, &child_status, 0) < 0) {
if (errno != EINTR)
die("waitpid");
}
if (!WIFEXITED(child_status))
return -1;
return WEXITSTATUS(child_status);
}

89
common/xbps-src/libexec/xbps-src-dobuild.sh Executable file
View file

@ -0,0 +1,89 @@
#!/bin/bash
#
# Passed arguments:
# $1 - pkgname to build [REQUIRED]
# $2 - cross target [OPTIONAL]
if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$(basename $0): invalid number of arguments: pkgname [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_CROSS_BUILD="$2"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/build/*.sh; do
source_file "$f"
done
if [ -z $pkgname -o -z $version ]; then
msg_error "$1: pkgname/version not set in pkg template!\n"
exit 1
fi
XBPS_BUILD_DONE="$wrksrc/.xbps_${XBPS_CROSS_BUILD}_build_done"
XBPS_PRE_BUILD_DONE="$wrksrc/.xbps_${XBPS_CROSS_BUILD}_pre_build_done"
XBPS_POST_BUILD_DONE="$wrksrc/.xbps_${XBPS_CROSS_BUILD}_post_build_done"
if [ -f "$XBPS_BUILD_DONE" ]; then
exit 0
fi
cd $wrksrc || msg_error "$pkgver: cannot access wrksrc directory [$wrksrc]\n"
if [ -n "$build_wrksrc" ]; then
cd $build_wrksrc || \
msg_error "$pkgver: cannot access build_wrksrc directory [$build_wrksrc]\n"
fi
run_pkg_hooks pre-build
# Run pre_build()
if [ ! -f $XBPS_PRE_BUILD_DONE ]; then
cd $wrksrc
[ -n "$build_wrksrc" ] && cd $build_wrksrc
if declare -f pre_build >/dev/null; then
run_func pre_build
touch -f $XBPS_PRE_BUILD_DONE
fi
fi
# Run do_build()
cd $wrksrc
[ -n "$build_wrksrc" ] && cd $build_wrksrc
if declare -f do_build >/dev/null; then
run_func do_build
else
if [ -n "$build_style" ]; then
if [ ! -r $XBPS_BUILDSTYLEDIR/${build_style}.sh ]; then
msg_error "$pkgver: cannot find build helper $XBPS_BUILDSTYLEDIR/${build_style}.sh!\n"
fi
. $XBPS_BUILDSTYLEDIR/${build_style}.sh
if declare -f do_build >/dev/null; then
run_func do_build
fi
fi
fi
touch -f $XBPS_BUILD_DONE
# Run post_build()
if [ ! -f $XBPS_POST_BUILD_DONE ]; then
cd $wrksrc
[ -n "$build_wrksrc" ] && cd $build_wrksrc
if declare -f post_build >/dev/null; then
run_func post_build
touch -f $XBPS_POST_BUILD_DONE
fi
fi
run_pkg_hooks post-build
exit 0

90
common/xbps-src/libexec/xbps-src-doconfigure.sh Executable file
View file

@ -0,0 +1,90 @@
#!/bin/bash
#
# Passed arguments:
# $1 - pkgname to configure [REQUIRED]
# $2 - cross target [OPTIONAL]
if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$(basename $0): invalid number of arguments: pkgname [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_CROSS_BUILD="$2"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/configure/*.sh; do
source_file "$f"
done
XBPS_CONFIGURE_DONE="$wrksrc/.xbps_${XBPS_CROSS_BUILD}_configure_done"
XBPS_PRECONFIGURE_DONE="$wrksrc/.xbps_${XBPS_CROSS_BUILD}_pre_configure_done"
XBPS_POSTCONFIGURE_DONE="$wrksrc/.xbps_${XBPS_CROSS_BUILD}_post_configure_done"
if [ -f "$XBPS_CONFIGURE_DONE" ]; then
exit 0
fi
cd $wrksrc || msg_error "$pkgver: cannot access wrksrc directory [$wrksrc].\n"
if [ -n "$build_wrksrc" ]; then
cd $build_wrksrc || \
msg_error "$pkgver: cannot access build_wrksrc directory [$build_wrksrc].\n"
fi
run_pkg_hooks pre-configure
# Run pre_configure()
if [ ! -f $XBPS_PRECONFIGURE_DONE ]; then
cd $wrksrc
if [ -n "$build_wrksrc" ]; then
cd $build_wrksrc
fi
if declare -f pre_configure >/dev/null; then
run_func pre_configure
touch -f $XBPS_PRECONFIGURE_DONE
fi
fi
# Run do_configure()
cd $wrksrc
if [ -n "$build_wrksrc" ]; then
cd $build_wrksrc
fi
if declare -f do_configure >/dev/null; then
run_func do_configure
else
if [ -n "$build_style" ]; then
if [ ! -r $XBPS_BUILDSTYLEDIR/${build_style}.sh ]; then
msg_error "$pkgver: cannot find build helper $XBPS_BUILDSTYLEDIR/${build_style}.sh!\n"
fi
. $XBPS_BUILDSTYLEDIR/${build_style}.sh
if declare -f do_configure >/dev/null; then
run_func do_configure
fi
fi
fi
touch -f $XBPS_CONFIGURE_DONE
# Run post_configure()
if [ ! -f $XBPS_POSTCONFIGURE_DONE ]; then
cd $wrksrc
if [ -n "$build_wrksrc" ]; then
cd $build_wrksrc
fi
if declare -f post_configure >/dev/null; then
run_func post_configure
touch -f $XBPS_POSTCONFIGURE_DONE
fi
fi
run_pkg_hooks post-configure
exit 0

61
common/xbps-src/libexec/xbps-src-doextract.sh Executable file
View file

@ -0,0 +1,61 @@
#!/bin/bash
#
# Passed arguments:
# $1 - pkgname [REQUIRED]
# $2 - cross target [OPTIONAL]
if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$(basename $0): invalid number of arguments: pkgname [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_CROSS_BUILD="$2"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/extract/*.sh; do
source_file "$f"
done
XBPS_EXTRACT_DONE="$wrksrc/.xbps_extract_done"
if [ -f $XBPS_EXTRACT_DONE ]; then
exit 0
fi
# Run pre-extract hooks
run_pkg_hooks pre-extract
# If template defines pre_extract(), use it.
if declare -f pre_extract >/dev/null; then
run_func pre_extract
fi
# If template defines do_extract() use it rather than the hooks.
if declare -f do_extract >/dev/null; then
[ ! -d "$wrksrc" ] && mkdir -p $wrksrc
cd $wrksrc
run_func do_extract
else
# Run do-extract hooks
run_pkg_hooks "do-extract"
fi
touch -f $XBPS_EXTRACT_DONE
# If template defines post_extract(), use it.
if declare -f post_extract >/dev/null; then
run_func post_extract
fi
# Run post-extract hooks
run_pkg_hooks post-extract
exit 0

60
common/xbps-src/libexec/xbps-src-dofetch.sh Executable file
View file

@ -0,0 +1,60 @@
#!/bin/bash
#
# Passed arguments:
# $1 - pkgname [REQUIRED]
# $2 - cross target [OPTIONAL]
if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$(basename $0): invalid number of arguments: pkgname [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_CROSS_BUILD="$2"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/fetch/*.sh; do
source_file "$f"
done
XBPS_FETCH_DONE="$wrksrc/.xbps_fetch_done"
if [ -f "$XBPS_FETCH_DONE" ]; then
exit 0
fi
# Run pre-fetch hooks.
run_pkg_hooks pre-fetch
# If template defines pre_fetch(), use it.
if declare -f pre_fetch >/dev/null; then
run_func pre_fetch
fi
# If template defines do_fetch(), use it rather than the hooks.
if declare -f do_fetch >/dev/null; then
cd ${XBPS_BUILDDIR}
[ -n "$build_wrksrc" ] && mkdir -p "$wrksrc"
run_func do_fetch
touch -f $XBPS_FETCH_DONE
else
# Run do-fetch hooks.
run_pkg_hooks "do-fetch"
fi
# if templates defines post_fetch(), use it.
if declare -f post_fetch >/dev/null; then
run_func post_fetch
fi
# Run post-fetch hooks.
run_pkg_hooks post-fetch
exit 0

79
common/xbps-src/libexec/xbps-src-doinstall.sh Executable file
View file

@ -0,0 +1,79 @@
#!//bin/bash
#
# Passed arguments:
# $1 - pkgname [REQUIRED]
# $2 - cross target [OPTIONAL]
if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$(basename $0): invalid number of arguments: pkgname [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_CROSS_BUILD="$2"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/install/*.sh; do
source_file "$f"
done
XBPS_INSTALL_DONE="$wrksrc/.xbps_${pkgname}_${XBPS_CROSS_BUILD}_install_done"
XBPS_PRE_INSTALL_DONE="$wrksrc/.xbps_${pkgname}_${XBPS_CROSS_BUILD}_pre_install_done"
XBPS_POST_INSTALL_DONE="$wrksrc/.xbps_${pkgname}_${XBPS_CROSS_BUILD}_post_install_done"
if [ -f $XBPS_INSTALL_DONE ]; then
exit 0
fi
mkdir -p $XBPS_DESTDIR/$XBPS_CROSS_TRIPLET/$pkgname-$version
cd $wrksrc || msg_error "$pkgver: cannot access to wrksrc [$wrksrc]\n"
if [ -n "$build_wrksrc" ]; then
cd $build_wrksrc \
|| msg_error "$pkgver: cannot access to build_wrksrc [$build_wrksrc]\n"
fi
run_pkg_hooks pre-install
# Run pre_install()
if [ ! -f $XBPS_PRE_INSTALL_DONE ]; then
if declare -f pre_install >/dev/null; then
run_func pre_install
touch -f $XBPS_PRE_INSTALL_DONE
fi
fi
# Run do_install()
if [ ! -f $XBPS_INSTALL_DONE ]; then
cd $wrksrc
[ -n "$build_wrksrc" ] && cd $build_wrksrc
if declare -f do_install >/dev/null; then
run_func do_install
else
if [ ! -r $XBPS_BUILDSTYLEDIR/${build_style}.sh ]; then
msg_error "$pkgver: cannot find build helper $XBPS_BUILDSTYLEDIR/${build_style}.sh!\n"
fi
. $XBPS_BUILDSTYLEDIR/${build_style}.sh
run_func do_install
fi
touch -f $XBPS_INSTALL_DONE
fi
# Run post_install()
if [ ! -f $XBPS_POST_INSTALL_DONE ]; then
cd $wrksrc
[ -n "$build_wrksrc" ] && cd $build_wrksrc
if declare -f post_install >/dev/null; then
run_func post_install
touch -f $XBPS_POST_INSTALL_DONE
fi
fi
exit 0

62
common/xbps-src/libexec/xbps-src-dopkg.sh Executable file
View file

@ -0,0 +1,62 @@
#!//bin/bash
#
# Passed arguments:
# $1 - pkgname [REQUIRED]
# $2 - cross target [OPTIONAL]
if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$(basename $0): invalid number of arguments: pkgname [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_CROSS_BUILD="$2"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/install/*.sh; do
source_file "$f"
done
XBPS_PKG_DONE="$wrksrc/.xbps_${PKGNAME}_${XBPS_CROSS_BUILD}_pkg_done"
if [ -f $XBPS_PKG_DONE ]; then
exit 0
fi
#
# Always remove metadata files generated in a previous installation.
#
for f in INSTALL REMOVE files.plist props.plist rdeps shlib-provides shlib-requires; do
[ -f ${PKGDESTDIR}/${f} ] && rm -f ${PKGDESTDIR}/${f}
done
# If it's a subpkg execute the pkg_install() function.
if [ "$sourcepkg" != "$PKGNAME" ]; then
# Source all subpkg environment setup snippets.
for f in ${XBPS_COMMONDIR}/environment/setup-subpkg/*.sh; do
source_file "$f"
done
${PKGNAME}_package
pkgname=$PKGNAME
install -d $PKGDESTDIR
if declare -f pkg_install >/dev/null; then
export XBPS_PKGDESTDIR=1
run_func pkg_install
fi
fi
setup_pkg_depends $pkgname
run_pkg_hooks post-install
touch -f $XBPS_PKG_DONE
exit 0

52
common/xbps-src/libexec/xbps-src-genpkg.sh Executable file
View file

@ -0,0 +1,52 @@
#!/bin/bash
#
# Passed arguments:
# $1 - pkgname [REQUIRED]
# $2 - path to local repository [REQUIRED]
# $3 - cross-target [OPTIONAL]
if [ $# -lt 2 -o $# -gt 3 ]; then
echo "$(basename $0): invalid number of arguments: pkgname repository [cross-target]"
exit 1
fi
PKGNAME="$1"
XBPS_REPOSITORY="$2"
XBPS_CROSS_BUILD="$3"
. $XBPS_SHUTILSDIR/common.sh
for f in $XBPS_COMMONDIR/helpers/*.sh; do
source_file "$f"
done
setup_pkg "$PKGNAME" $XBPS_CROSS_BUILD
for f in $XBPS_COMMONDIR/environment/pkg/*.sh; do
source_file "$f"
done
if [ "$sourcepkg" != "$PKGNAME" ]; then
# Source all subpkg environment setup snippets.
for f in ${XBPS_COMMONDIR}/environment/setup-subpkg/*.sh; do
source_file "$f"
done
${PKGNAME}_package
pkgname=$PKGNAME
fi
if [ -s $XBPS_MASTERDIR/.xbps_chroot_init ]; then
export XBPS_ARCH=$(cat $XBPS_MASTERDIR/.xbps_chroot_init)
fi
# Run pre-pkg hooks.
run_pkg_hooks pre-pkg
# Run do-pkg hooks.
run_pkg_hooks "do-pkg"
# Run post-pkg hooks.
run_pkg_hooks post-pkg
exit 0

248
common/xbps-src/shutils/build_dependencies.sh Normal file
View file

@ -0,0 +1,248 @@
# -*-* shell *-*-
#
# Install a required package dependency, like:
#
# xbps-install -Ay <pkgname>
#
# Returns 0 if package already installed or installed successfully.
# Any other error number otherwise.
#
install_pkg_from_repos() {
local pkg="$1" cross="$2" rval= tmplogf=
tmplogf=$(mktemp)
if [ -n "$cross" ]; then
$FAKEROOT_CMD $XBPS_INSTALL_XCMD -Ayd "$pkg" >$tmplogf 2>&1
else
$FAKEROOT_CMD $XBPS_INSTALL_CMD -Ayd "$pkg" >$tmplogf 2>&1
fi
rval=$?
if [ $rval -ne 0 -a $rval -ne 17 ]; then
# xbps-install can return:
#
# SUCCESS (0): package installed successfully.
# ENOENT (2): package missing in repositories.
# EEXIST (17): package already installed.
# ENODEV (19): package depends on missing dependencies.
# ENOTSUP (95): no repositories registered.
#
[ -z "$XBPS_KEEP_ALL" ] && remove_pkg_autodeps
msg_red "$pkgver: failed to install '$1' dependency! (error $rval)\n"
cat $tmplogf && rm -f $tmplogf
msg_error "Please see above for the real error, exiting...\n"
fi
rm -f $tmplogf
[ $rval -eq 17 ] && rval=0
return $rval
}
#
# Returns 0 if pkgpattern in $1 is matched against current installed
# package, 1 if no match and 2 if not installed.
#
check_pkgdep_matched() {
local pkg="$1" cross="$2" uhelper= pkgn= iver=
[ "$build_style" = "meta" ] && return 2
[ -z "$pkg" ] && return 255
pkgn="$($XBPS_UHELPER_CMD getpkgdepname ${pkg})"
if [ -z "$pkgn" ]; then
pkgn="$($XBPS_UHELPER_CMD getpkgname ${pkg})"
fi
[ -z "$pkgn" ] && return 255
if [ -n "$cross" ]; then
uhelper="$XBPS_UHELPER_XCMD"
else
uhelper="$XBPS_UHELPER_CMD"
fi
iver="$($uhelper version $pkgn)"
if [ $? -eq 0 -a -n "$iver" ]; then
$XBPS_UHELPER_CMD pkgmatch "${pkgn}-${iver}" "${pkg}"
[ $? -eq 1 ] && return 0
else
return 2
fi
return 1
}
#
# Installs all dependencies required by a package.
#
install_pkg_deps() {
local pkg="$1" cross="$2" i rval _realpkg curpkgdepname pkgn iver _props _exact
local -a host_binpkg_deps binpkg_deps
local -a host_missing_deps missing_deps
[ -z "$pkgname" ] && return 2
setup_pkg_depends
if [ -z "$build_depends" -a -z "$host_build_depends" ]; then
return 0
fi
msg_normal "$pkgver: required dependencies:\n"
#
# Host build dependencies.
#
for i in ${host_build_depends}; do
_realpkg="${i%\?*}"
pkgn=$($XBPS_UHELPER_CMD getpkgdepname "${_realpkg}")
if [ -z "$pkgn" ]; then
pkgn=$($XBPS_UHELPER_CMD getpkgname "${_realpkg}")
if [ -z "$pkgn" ]; then
msg_error "$pkgver: invalid build dependency: ${i}\n"
fi
_exact=1
fi
check_pkgdep_matched "${_realpkg}"
local rval=$?
if [ $rval -eq 0 ]; then
iver=$($XBPS_UHELPER_CMD version "${pkgn}")
if [ $? -eq 0 -a -n "$iver" ]; then
echo " [host] ${_realpkg}: found '$pkgn-$iver'."
continue
fi
elif [ $rval -eq 1 ]; then
iver=$($XBPS_UHELPER_CMD version "${pkgn}")
if [ $? -eq 0 -a -n "$iver" ]; then
echo " [host] ${_realpkg}: installed ${iver} (unresolved) removing..."
$FAKEROOT_CMD $XBPS_REMOVE_CMD -iyf $pkgn >/dev/null 2>&1
fi
else
if [ -n "${_exact}" ]; then
unset _exact
_props=$($XBPS_QUERY_CMD -R -ppkgver,repository "${pkgn}" 2>/dev/null)
else
_props=$($XBPS_QUERY_CMD -R -ppkgver,repository "${_realpkg}" 2>/dev/null)
fi
if [ -n "${_props}" ]; then
set -- ${_props}
$XBPS_UHELPER_CMD pkgmatch ${1} "${_realpkg}"
if [ $? -eq 1 ]; then
echo " [host] ${_realpkg}: found $1 in $2."
host_binpkg_deps+=("$1")
shift 2
continue
else
echo " [host] ${_realpkg}: not found."
fi
shift 2
else
echo " [host] ${_realpkg}: not found."
fi
fi
host_missing_deps+=("${_realpkg}")
done
#
# Target build dependencies.
#
for i in ${build_depends}; do
_realpkg="${i%\?*}"
pkgn=$($XBPS_UHELPER_CMD getpkgdepname "${_realpkg}")
if [ -z "$pkgn" ]; then
pkgn=$($XBPS_UHELPER_CMD getpkgname "${_realpkg}")
if [ -z "$pkgn" ]; then
msg_error "$pkgver: invalid build dependency: ${_realpkg}\n"
fi
_exact=1
fi
check_pkgdep_matched "${_realpkg}" $cross
local rval=$?
if [ $rval -eq 0 ]; then
iver=$($XBPS_UHELPER_XCMD version "${pkgn}")
if [ $? -eq 0 -a -n "$iver" ]; then
echo " [target] ${_realpkg}: found '$pkgn-$iver'."
continue
fi
elif [ $rval -eq 1 ]; then
iver=$($XBPS_UHELPER_XCMD version "${pkgn}")
if [ $? -eq 0 -a -n "$iver" ]; then
echo " [target] ${_realpkg}: installed ${iver} (unresolved) removing..."
$XBPS_REMOVE_XCMD -iyf $pkgn >/dev/null 2>&1
fi
else
if [ -n "${_exact}" ]; then
unset _exact
_props=$($XBPS_QUERY_XCMD -R -ppkgver,repository "${pkgn}" 2>/dev/null)
else
_props=$($XBPS_QUERY_XCMD -R -ppkgver,repository "${_realpkg}" 2>/dev/null)
fi
if [ -n "${_props}" ]; then
set -- ${_props}
$XBPS_UHELPER_CMD pkgmatch ${1} "${_realpkg}"
if [ $? -eq 1 ]; then
echo " [target] ${_realpkg}: found $1 in $2."
binpkg_deps+=("$1")
shift 2
continue
else
echo " [target] ${_realpkg}: not found."
fi
shift 2
else
echo " [target] ${_realpkg}: not found."
fi
fi
missing_deps+=("${_realpkg}")
done
# Host missing dependencies, build from srcpkgs.
for i in ${host_missing_deps[@]}; do
curpkgdepname=$($XBPS_UHELPER_CMD getpkgdepname "$i")
setup_pkg $curpkgdepname
${XBPS_UHELPER_CMD} pkgmatch "$pkgver" "$i"
if [ $? -eq 0 ]; then
setup_pkg $XBPS_TARGET_PKG
msg_error_nochroot "$pkgver: required host dependency '$i' cannot be resolved!\n"
fi
install_pkg full
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
install_pkg_deps $sourcepkg $XBPS_CROSS_BUILD
done
# Target missing dependencies, build from srcpkgs.
for i in ${missing_deps[@]}; do
# packages not found in repos, install from source.
curpkgdepname=$($XBPS_UHELPER_CMD getpkgdepname "$i")
setup_pkg $curpkgdepname $cross
# Check if version in srcpkg satisfied required dependency,
# and bail out if doesn't.
$XBPS_UHELPER_CMD pkgmatch "$pkgver" "$i"
if [ $? -eq 0 ]; then
setup_pkg $XBPS_TARGET_PKG $cross
msg_error_nochroot "$pkgver: required target dependency '$i' cannot be resolved!\n"
fi
install_pkg full $cross
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
install_pkg_deps $sourcepkg $XBPS_CROSS_BUILD
done
if [ "$TARGETPKG_PKGDEPS_DONE" ]; then
return 0
fi
for i in ${host_binpkg_deps[@]}; do
msg_normal "$pkgver: installing host dependency '$i' ...\n"
install_pkg_from_repos "${i}"
done
for i in ${binpkg_deps[@]}; do
if [ -n "$CHROOT_READY" -a "$build_style" = "meta" ]; then
continue
fi
msg_normal "$pkgver: installing target dependency '$i' ...\n"
install_pkg_from_repos "$i" $cross
done
if [ "$XBPS_TARGET_PKG" = "$sourcepkg" ]; then
TARGETPKG_PKGDEPS_DONE=1
fi
}

204
common/xbps-src/shutils/chroot.sh Normal file
View file

@ -0,0 +1,204 @@
# -*-* shell *-*-
chroot_init() {
XBPSSRC_CF=$XBPS_MASTERDIR/etc/xbps/xbps-src.conf
cat > $XBPSSRC_CF <<_EOF
# Generated configuration file by xbps-src, DO NOT EDIT!
XBPS_MASTERDIR=/
XBPS_CFLAGS="$XBPS_CFLAGS"
XBPS_CXXFLAGS="$XBPS_CXXFLAGS"
XBPS_CPPFLAGS="$XBPS_CPPFLAGS"
XBPS_LDFLAGS="$XBPS_LDFLAGS"
_EOF
if [ -n "$XBPS_MAKEJOBS" ]; then
echo "XBPS_MAKEJOBS=$XBPS_MAKEJOBS" >> $XBPSSRC_CF
fi
if [ -n "$XBPS_HOSTDIR" ]; then
echo "XBPS_HOSTDIR=/host" >> $XBPSSRC_CF
fi
if [ -n "$XBPS_CCACHE" ]; then
echo "XBPS_CCACHE=$XBPS_CCACHE" >> $XBPSSRC_CF
fi
if [ -n "$XBPS_DISTCC" ]; then
echo "XBPS_DISTCC=$XBPS_DISTCC" >> $XBPSSRC_CF
echo "XBPS_DISTCC_HOSTS=\"${XBPS_DISTCC_HOSTS}\"" >> $XBPSSRC_CF
fi
if [ -n "$XBPS_USE_GIT_REVS" ]; then
echo "XBPS_USE_GIT_REVS=yes" >> $XBPSSRC_CF
fi
if [ -n "$XBPS_DEBUG_PKGS" ]; then
echo "XBPS_DEBUG_PKGS=yes" >> $XBPSSRC_CF
fi
echo "# End of configuration file." >> $XBPSSRC_CF
# Create custom script to start the chroot bash shell.
cat > $XBPS_MASTERDIR/bin/xbps-shell <<_EOF
#!/bin/sh
XBPS_SRC_VERSION="$XBPS_SRC_VERSION"
. /etc/xbps/xbps-src.conf
PATH=/usr/bin:/usr/sbin:/xbps-packages
exec env -i PATH="\$PATH" DISTCC_HOSTS="\$XBPS_DISTCC_HOSTS" DISTCC_DIR="/distcc" @@XARCH@@ \
CCACHE_DIR="/ccache" IN_CHROOT=1 LANG=en_US.UTF-8 TERM=linux HOME="/tmp" \
PS1="[\u@$XBPS_MASTERDIR \W]$ " /bin/bash +h
_EOF
if [ -n "$XBPS_ARCH" ]; then
sed -e "s,@@XARCH@@,XBPS_ARCH=${XBPS_ARCH},g" -i $XBPS_MASTERDIR/bin/xbps-shell
else
sed -e 's,@@XARCH@@,,g' -i $XBPS_MASTERDIR/bin/xbps-shell
fi
chmod 755 $XBPS_MASTERDIR/bin/xbps-shell
cp -f /etc/resolv.conf $XBPS_MASTERDIR/etc
# Update xbps alternative repository if set.
mkdir -p $XBPS_MASTERDIR/etc/xbps/repos
if [ -n "$XBPS_ALT_REPOSITORY" ]; then
( \
echo "repository=/host/binpkgs/${XBPS_ALT_REPOSITORY}"; \
echo "repository=/host/binpkgs/${XBPS_ALT_REPOSITORY}/nonfree"; \
) > $XBPS_MASTERDIR/etc/xbps/repos/alternative.conf
else
: > $XBPS_MASTERDIR/etc/xbps/repos/alternative.conf
fi
}
chroot_prepare() {
local f=
if [ -f $XBPS_MASTERDIR/.xbps_chroot_init ]; then
return 0
elif [ ! -f $XBPS_MASTERDIR/bin/bash ]; then
msg_error "Bootstrap not installed in $XBPS_MASTERDIR, can't continue.\n"
fi
# Create some required files.
cp -f /etc/services $XBPS_MASTERDIR/etc
[ -f /etc/localtime ] && cp -f /etc/localtime $XBPS_MASTERDIR/etc
for f in dev sys proc host boot; do
[ ! -d $XBPS_MASTERDIR/$f ] && mkdir -p $XBPS_MASTERDIR/$f
done
# Copy /etc/passwd and /etc/group from base-files.
cp -f $XBPS_SRCPKGDIR/base-files/files/passwd $XBPS_MASTERDIR/etc
echo "$(whoami):x:$(id -u):$(id -g):$(whoami) user:/tmp:/bin/xbps-shell" \
>> $XBPS_MASTERDIR/etc/passwd
cp -f $XBPS_SRCPKGDIR/base-files/files/group $XBPS_MASTERDIR/etc
echo "$(whoami):x:$(id -g):" >> $XBPS_MASTERDIR/etc/group
# Copy /etc/hosts from base-files.
cp -f $XBPS_SRCPKGDIR/base-files/files/hosts $XBPS_MASTERDIR/etc
rm -f $XBPS_MASTERDIR/etc/xbps/xbps.conf
# Prepare default locale: en_US.UTF-8.
if [ -s ${XBPS_MASTERDIR}/etc/default/libc-locales ]; then
echo 'en_US.UTF-8 UTF-8' >> ${XBPS_MASTERDIR}/etc/default/libc-locales
$XBPS_RECONFIGURE_CMD -f glibc-locales
fi
touch -f $XBPS_MASTERDIR/.xbps_chroot_init
[ -n "$1" ] && echo $1 >> $XBPS_MASTERDIR/.xbps_chroot_init
return 0
}
chroot_sync_repos() {
local f=
# Copy xbps configuration files to the masterdir.
if [ ! -f ${XBPS_MASTERDIR}/etc/xbps/xbps.conf ]; then
install -Dm644 ${XBPS_COMMONDIR}/xbps-src/chroot/xbps.conf \
${XBPS_MASTERDIR}/etc/xbps/xbps.conf
fi
if [ ! -f ${XBPS_MASTERDIR}/etc/xbps/repos/local.conf ]; then
install -Dm644 ${XBPS_COMMONDIR}/xbps-src/chroot/repos-local.conf \
${XBPS_MASTERDIR}/etc/xbps/repos/local.conf
fi
if [ ! -f ${XBPS_MASTERDIR}/etc/xbps/repos/remote.conf ]; then
install -Dm644 ${XBPS_COMMONDIR}/xbps-src/chroot/repos-remote.conf \
${XBPS_MASTERDIR}/etc/xbps/repos/remote.conf
fi
# if -N is set, comment out remote repositories from xbps.conf.
if [ -n "$XBPS_SKIP_REMOTEREPOS" ]; then
sed -e 's,^.*\(include=/etc/xbps/repos/remote.conf$\),#\1,' \
-i ${XBPS_MASTERDIR}/etc/xbps/xbps.conf
else
sed -e 's,^#.*\(include=/etc/xbps/repos/remote.conf$\),\1,' \
-i ${XBPS_MASTERDIR}/etc/xbps/xbps.conf
# Make sure to sync index for remote repositories.
$CHROOT_CMD $XBPS_MASTERDIR /usr/sbin/xbps-install -S
if [ -n "$XBPS_CROSS_BUILD" ]; then
# Copy host keys to the target rootdir.
if [ ! -d $XBPS_MASTERDIR/usr/$XBPS_CROSS_TRIPLET/var/db/xbps/keys ]; then
mkdir -p $XBPS_MASTERDIR/usr/$XBPS_CROSS_TRIPLET/var/db/xbps/keys
fi
cp -a $XBPS_MASTERDIR/var/db/xbps/keys/*.plist \
$XBPS_MASTERDIR/usr/$XBPS_CROSS_TRIPLET/var/db/xbps/keys
env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH \
$CHROOT_CMD $XBPS_MASTERDIR /usr/sbin/xbps-install \
-r /usr/$XBPS_CROSS_TRIPLET -S
fi
fi
return 0
}
chroot_handler() {
local action="$1" pkg="$2" rv=0 arg= _envargs= _chargs=
# Debian uses /run/shm instead...
if [ -d /run/shm ]; then
mkdir -p ${XBPS_MASTERDIR}/run/shm
_chargs+=" -S /run/shm"
elif [ -d /dev/shm ]; then
mkdir -p ${XBPS_MASTERDIR}/dev/shm
_chargs+=" -S /dev/shm"
fi
if [ -n "$XBPS_HOSTDIR" ]; then
_chargs+=" -H $XBPS_HOSTDIR"
fi
if [ ! -d $XBPS_MASTERDIR/xbps-packages ]; then
mkdir -p $XBPS_MASTERDIR/xbps-packages
fi
_chargs+=" -D ${XBPS_DISTDIR}"
[ -z "$action" -a -z "$pkg" ] && return 1
case "$action" in
fetch|extract|build|configure|install-destdir|build-pkg|bootstrap-update|chroot)
chroot_prepare || return $?
chroot_init || return $?
chroot_sync_repos || return $?
;;
esac
if [ "$action" = "chroot" ]; then
$CHROOT_CMD ${_chargs} $XBPS_MASTERDIR /bin/xbps-shell || rv=$?
else
[ -n "$XBPS_BUILD_OPTS" ] && arg="$arg -o $XBPS_BUILD_OPTS"
[ -n "$XBPS_CROSS_BUILD" ] && arg="$arg -a $XBPS_CROSS_BUILD"
[ -n "$XBPS_KEEP_ALL" ] && arg="$arg -C"
[ -n "$NOCOLORS" ] && arg="$arg -L"
[ -n "$XBPS_BUILD_FORCEMODE" ] && arg="$arg -f"
[ -n "$XBPS_MAKEJOBS" ] && arg="$arg -j$XBPS_MAKEJOBS"
[ -n "$XBPS_DEBUG_PKGS" ] && arg="$arg -g"
[ -n "$XBPS_SKIP_DEPS" ] && arg="$arg -I"
[ -n "$XBPS_ALT_REPOSITORY" ] && arg="$arg -r $XBPS_ALT_REPOSITORY"
action="$arg $action"
env -i PATH=/bin:/sbin:/usr/bin:/usr/sbin HOME=/tmp IN_CHROOT=1 LANG=en_US.UTF-8 \
$CHROOT_CMD ${_chargs} $XBPS_MASTERDIR /xbps-packages/xbps-src $action $pkg || rv=$?
fi
return $rv
}

566
common/xbps-src/shutils/common.sh Normal file
View file

@ -0,0 +1,566 @@
# -*-* shell *-*-
run_func() {
local func="$1" desc="$2" restoretrap= logpipe= logfile= teepid=
if [ -d "${wrksrc}" ]; then
logpipe=$(mktemp -u --tmpdir=${wrksrc} .xbps_${XBPS_CROSS_BUILD}_XXXXXXXX.logpipe)
logfile=${wrksrc}/.xbps_${XBPS_CROSS_BUILD}_${func}.log
else
logpipe=$(mktemp -t -u .xbps_${XBPS_CROSS_BUILD}_${func}_${pkgname}_logpipe.XXXXXXX)
logfile=$(mktemp -t .xbps_${XBPS_CROSS_BUILD}_${func}_${pkgname}.log.XXXXXXXX)
fi
msg_normal "${pkgver:-xbps-src}: running ${desc:-${func}} ...\n"
set -E
restoretrap=$(trap -p ERR)
trap 'error_func $func $LINENO' ERR
mkfifo "$logpipe"
tee "$logfile" < "$logpipe" &
teepid=$!
$func &>"$logpipe"
wait $teepid
rm "$logpipe"
eval "$restoretrap"
set +E
}
error_func() {
if [ -n "$1" -a -n "$2" ]; then
msg_red "$pkgver: failed to run $1() at line $2.\n"
fi
exit 2
}
msg_red() {
# error messages in bold/red
[ -n "$NOCOLORS" ] || printf >&2 "\033[1m\033[31m"
printf >&2 "=> ERROR: $@"
[ -n "$NOCOLORS" ] || printf >&2 "\033[m"
}
msg_red_nochroot() {
[ -n "$NOCOLORS" ] || printf >&2 "\033[1m\033[31m"
printf >&2 "$@"
[ -n "$NOCOLORS" ] || printf >&2 "\033[m"
}
msg_error() {
msg_red "$@"
kill -INT $$; exit 1
}
msg_error_nochroot() {
[ -n "$NOCOLORS" ] || printf >&2 "\033[1m\033[31m"
printf >&2 "=> ERROR: $@"
[ -n "$NOCOLORS" ] || printf >&2 "\033[m"
exit 1
}
msg_warn() {
# warn messages in bold/yellow
[ -n "$NOCOLORS" ] || printf >&2 "\033[1m\033[33m"
printf >&2 "=> WARNING: $@"
[ -n "$NOCOLORS" ] || printf >&2 "\033[m"
}
msg_warn_nochroot() {
[ -n "$NOCOLORS" ] || printf >&2 "\033[1m\033[33m"
printf >&2 "=> WARNING: $@"
[ -n "$NOCOLORS" ] || printf >&2 "\033[m"
}
msg_normal() {
# normal messages in bold
[ -n "$NOCOLORS" ] || printf "\033[1m"
printf "=> $@"
[ -n "$NOCOLORS" ] || printf "\033[m"
}
msg_normal_append() {
[ -n "$NOCOLORS" ] || printf "\033[1m"
printf "$@"
[ -n "$NOCOLORS" ] || printf "\033[m"
}
set_build_options() {
local f j opt optval _optsset
local -A options
if [ -z "$build_options" ]; then
return 0
fi
for f in ${build_options}; do
OIFS="$IFS"; IFS=','
for j in ${XBPS_BUILD_OPTS}; do
opt=${j#\~}
opt_disabled=${j:0:1}
if [ "$opt" = "$f" ]; then
if [ "$opt_disabled" != "~" ]; then
options[$opt]=1
else
options[$opt]=0
fi
fi
done
IFS="$OIFS"
done
for f in ${build_options_default}; do
optval=${options[$f]}
if [[ -z "$optval" ]] || [[ $optval -eq 1 ]]; then
options[$f]=1
fi
done
# Prepare final options.
for f in ${!options[@]}; do
optval=${options[$f]}
if [[ $optval -eq 1 ]]; then
eval build_option_${f}=1
fi
done
# Re-read pkg template to get conditional vars.
if [ -z "$XBPS_BUILD_OPTIONS_PARSED" ]; then
source_file $XBPS_SRCPKGDIR/$pkgname/template
XBPS_BUILD_OPTIONS_PARSED=1
unset PKG_BUILD_OPTIONS
set_build_options
return 0
fi
for f in ${build_options}; do
optval=${options[$f]}
if [[ $optval -eq 1 ]]; then
_optsset="${_optsset} ${f}"
else
_optsset="${_optsset} ~${f}"
fi
done
for f in ${_optsset}; do
if [ -z "$PKG_BUILD_OPTIONS" ]; then
PKG_BUILD_OPTIONS="$f"
else
PKG_BUILD_OPTIONS="$PKG_BUILD_OPTIONS $f"
fi
done
# Sort pkg build options alphabetically.
export PKG_BUILD_OPTIONS="$(echo "$PKG_BUILD_OPTIONS"|tr ' ' '\n'|sort|tr '\n' ' ')"
}
source_file() {
local f="$1"
if [ ! -f "$f" -o ! -r "$f" ]; then
return 0
fi
if ! source "$f"; then
msg_error "xbps-src: failed to read $f!\n"
fi
}
run_pkg_hooks() {
local phase="$1" hookn
eval unset -f hook
for f in ${XBPS_COMMONDIR}/hooks/${phase}/*.sh; do
[ ! -r $f ] && continue
hookn=$(basename $f)
hookn=${hookn%.sh}
. $f
run_func hook "$phase hook: $hookn"
done
}
get_subpkgs() {
local args list
args="$(typeset -F|grep -E '_package$')"
set -- ${args}
while [ $# -gt 0 ]; do
list+=" ${3%_package}"; shift 3
done
for f in ${list}; do
echo "$f"
done
}
setup_pkg() {
local pkg="$1" cross="$2"
local val _vars f
[ -z "$pkg" ] && return 1
# Start with a sane environment
unset -v PKG_BUILD_OPTIONS XBPS_CROSS_CFLAGS XBPS_CROSS_CXXFLAGS XBPS_CROSS_CPPFLAGS XBPS_CROSS_LDFLAGS
unset -v run_depends build_depends host_build_depends
for f in ${subpackages}; do
eval unset -f ${f}_package
done
if [ -n "$cross" ]; then
source_file $XBPS_CROSSPFDIR/${cross}.sh
REQ_VARS="TARGET_ARCH CROSS_TRIPLET CROSS_CFLAGS CROSS_CXXFLAGS"
for f in ${REQ_VARS}; do
eval val="\$XBPS_$f"
if [ -z "$val" ]; then
echo "ERROR: XBPS_$f is not defined!"
exit 1
fi
done
export XBPS_TARGET_MACHINE=$XBPS_TARGET_ARCH
export XBPS_CROSS_BASE=/usr/$XBPS_CROSS_TRIPLET
XBPS_INSTALL_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH $XBPS_INSTALL_CMD -c /host/repocache -r $XBPS_CROSS_BASE"
XBPS_QUERY_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH $XBPS_QUERY_CMD -c /host/repocache -r $XBPS_CROSS_BASE"
XBPS_RECONFIGURE_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH $XBPS_RECONFIGURE_CMD -r $XBPS_CROSS_BASE"
XBPS_REMOVE_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH $XBPS_REMOVE_CMD -r $XBPS_CROSS_BASE"
XBPS_RINDEX_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH $XBPS_RINDEX_CMD"
XBPS_UHELPER_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH xbps-uhelper -r $XBPS_CROSS_BASE"
else
export XBPS_TARGET_MACHINE=${XBPS_ARCH:-$XBPS_MACHINE}
unset XBPS_CROSS_BASE XBPS_CROSS_LDFLAGS
unset XBPS_CROSS_CFLAGS XBPS_CROSS_CXXFLAGS XBPS_CROSS_CPPFLAGS
XBPS_INSTALL_XCMD="$XBPS_INSTALL_CMD"
XBPS_QUERY_XCMD="$XBPS_QUERY_CMD"
XBPS_RECONFIGURE_XCMD="$XBPS_RECONFIGURE_CMD"
XBPS_REMOVE_XCMD="$XBPS_REMOVE_CMD"
XBPS_RINDEX_XCMD="$XBPS_RINDEX_CMD"
XBPS_UHELPER_XCMD="$XBPS_UHELPER_CMD"
fi
export XBPS_INSTALL_XCMD XBPS_QUERY_XCMD XBPS_RECONFIGURE_XCMD \
XBPS_REMOVE_XCMD XBPS_RINDEX_XCMD XBPS_UHELPER_XCMD
# Source all sourcepkg environment setup snippets.
for f in ${XBPS_COMMONDIR}/environment/setup/*.sh; do
source_file "$f"
done
# Source all subpkg environment setup snippets.
for f in ${XBPS_COMMONDIR}/environment/setup-subpkg/*.sh; do
source_file "$f"
done
if [ ! -f ${XBPS_SRCPKGDIR}/${pkg}/template ]; then
msg_error "xbps-src: unexistent file: ${XBPS_SRCPKGDIR}/${pkg}/template\n"
fi
if [ -n "$cross" ]; then
export CROSS_BUILD="$cross"
source_file ${XBPS_SRCPKGDIR}/${pkg}/template
else
unset CROSS_BUILD
source_file ${XBPS_SRCPKGDIR}/${pkg}/template
fi
# Check if required vars weren't set.
_vars="pkgname version short_desc revision homepage license"
for f in ${_vars}; do
eval val="\$$f"
if [ -z "$val" -o -z "$f" ]; then
msg_error "\"$f\" not set on $pkgname template.\n"
fi
done
# Check if base-chroot is already installed.
if [ -z "$bootstrap" ]; then
check_installed_pkg base-chroot-0.1_1
if [ $? -ne 0 ]; then
msg_red "${pkg} is not a bootstrap package and cannot be built without it.\n"
msg_error "Please install bootstrap packages and try again.\n"
fi
fi
sourcepkg="${pkgname}"
subpackages="$(get_subpkgs)"
if [ -h $XBPS_SRCPKGDIR/$pkg ]; then
# Source all subpkg environment setup snippets.
for f in ${XBPS_COMMONDIR}/environment/setup-subpkg/*.sh; do
source_file "$f"
done
pkgname=$pkg
if ! declare -f ${pkg}_package >/dev/null; then
msg_error "$pkgname: missing ${pkg}_package() function!\n"
fi
fi
pkgver="${pkg}-${version}_${revision}"
# If build_style() unset, a do_install() function must be defined.
if [ -z "$build_style" ]; then
# Check that at least do_install() is defined.
if ! declare -f do_install >/dev/null; then
msg_error "$pkgver: missing do_install() function!\n"
fi
fi
# Setup some specific package vars.
if [ -z "$wrksrc" ]; then
wrksrc="$XBPS_BUILDDIR/${sourcepkg}-${version}"
else
wrksrc="$XBPS_BUILDDIR/$wrksrc"
fi
FILESDIR=$XBPS_SRCPKGDIR/$sourcepkg/files
PATCHESDIR=$XBPS_SRCPKGDIR/$sourcepkg/patches
DESTDIR=$XBPS_DESTDIR/$XBPS_CROSS_TRIPLET/${sourcepkg}-${version}
PKGDESTDIR=$XBPS_DESTDIR/$XBPS_CROSS_TRIPLET/${pkg}-${version}
if [ -n "$XBPS_MAKEJOBS" -a -z "$disable_parallel_build" ]; then
makejobs="-j$XBPS_MAKEJOBS"
fi
# For nonfree/bootstrap pkgs there's no point in building -dbg pkgs, disable them.
if [ -z "$XBPS_DEBUG_PKGS" -o -n "$nonfree" -o -n "$bootstrap" ]; then
disable_debug=yes
fi
# If a package sets force_debug_pkgs, always build -dbg pkgs.
if [ -n "$force_debug_pkgs" ]; then
unset disable_debug
fi
# -g is required to build -dbg packages.
if [ -z "$disable_debug" ]; then
dbgflags="-g"
fi
export CFLAGS="$XBPS_CFLAGS $XBPS_CROSS_CFLAGS $CFLAGS $dbgflags"
export CXXFLAGS="$XBPS_CXXFLAGS $XBPS_CROSS_CXXFLAGS $CXXFLAGS $dbgflags"
export CPPFLAGS="$XBPS_CPPFLAGS $XBPS_CROSS_CPPFLAGS $CPPFLAGS"
export LDFLAGS="$LDFLAGS $XBPS_LDFLAGS $XBPS_CROSS_LDFLAGS"
export BUILD_CC="cc"
export BUILD_CFLAGS="$XBPS_CFLAGS"
if [ -n "$cross" ]; then
export CC="${XBPS_CROSS_TRIPLET}-gcc"
export CXX="${XBPS_CROSS_TRIPLET}-c++"
export CPP="${XBPS_CROSS_TRIPLET}-cpp"
export GCC="$CC"
export LD="${XBPS_CROSS_TRIPLET}-ld"
export AR="${XBPS_CROSS_TRIPLET}-ar"
export AS="${XBPS_CROSS_TRIPLET}-as"
export RANLIB="${XBPS_CROSS_TRIPLET}-ranlib"
export STRIP="${XBPS_CROSS_TRIPLET}-strip"
export OBJDUMP="${XBPS_CROSS_TRIPLET}-objdump"
export OBJCOPY="${XBPS_CROSS_TRIPLET}-objcopy"
export NM="${XBPS_CROSS_TRIPLET}-nm"
export READELF="${XBPS_CROSS_TRIPLET}-readelf"
else
export CC="cc"
export CXX="g++"
export CPP="cpp"
export GCC="$CC"
export LD="ld"
export AR="ar"
export AS="as"
export RANLIB="ranlib"
export STRIP="strip"
export OBJDUMP="objdump"
export OBJCOPY="objcopy"
export NM="nm"
export READELF="readelf"
fi
set_build_options
}
setup_pkg_depends() {
local pkg="$1" j _pkgdepname _pkgdep _depname
if [ -n "$pkg" ]; then
# subpkg
if declare -f ${pkg}_package >/dev/null; then
${pkg}_package
fi
fi
for j in ${depends}; do
_depname="${j#*\?}"
_pkgdepname="$($XBPS_UHELPER_CMD getpkgdepname ${_depname} 2>/dev/null)"
if [ -z "${_pkgdepname}" ]; then
_pkgdepname="$($XBPS_UHELPER_CMD getpkgname ${_depname} 2>/dev/null)"
fi
if [ -z "${_pkgdepname}" ]; then
_pkgdep="${_depname}>=0"
else
_pkgdep="${_depname}"
fi
run_depends+=" ${_pkgdep}"
done
for j in ${hostmakedepends}; do
_depname="${j%\?*}"
_pkgdepname="$($XBPS_UHELPER_CMD getpkgdepname ${_depname} 2>/dev/null)"
if [ -z "${_pkgdepname}" ]; then
_pkgdepname="$($XBPS_UHELPER_CMD getpkgname ${_depname} 2>/dev/null)"
fi
if [ -z "${_pkgdepname}" ]; then
_pkgdep="${_depname}>=0"
else
_pkgdep="${_depname}"
fi
host_build_depends+=" ${_pkgdep}"
done
for j in ${makedepends}; do
_depname="${j%\?*}"
_pkgdepname="$($XBPS_UHELPER_CMD getpkgdepname ${_depname} 2>/dev/null)"
if [ -z "${_pkgdepname}" ]; then
_pkgdepname="$($XBPS_UHELPER_CMD getpkgname ${_depname} 2>/dev/null)"
fi
if [ -z "${_pkgdepname}" ]; then
_pkgdep="${_depname}>=0"
else
_pkgdep="${_depname}"
fi
build_depends+=" ${_pkgdep}"
done
}
_remove_pkg_cross_deps() {
local rval= tmplogf=
[ -z "$XBPS_CROSS_BUILD" ] && return 0
cd $XBPS_MASTERDIR || return 1
msg_normal "${pkgver:-xbps-src}: removing autocrossdeps, please wait...\n"
tmplogf=$(mktemp)
if [ -z "$XBPS_REMOVE_XCMD" ]; then
source_file $XBPS_CROSSPFDIR/${XBPS_CROSS_BUILD}.sh
XBPS_REMOVE_XCMD="env XBPS_TARGET_ARCH=$XBPS_TARGET_ARCH xbps-remove -r /usr/$XBPS_CROSS_TRIPLET"
fi
$FAKEROOT_CMD $XBPS_REMOVE_XCMD -Ryo > $tmplogf 2>&1
if [ $? -ne 0 ]; then
msg_red "${pkgver:-xbps-src}: failed to remove autocrossdeps:\n"
cat $tmplogf && rm -f $tmplogf
msg_error "${pkgver:-xbps-src}: cannot continue!\n"
fi
rm -f $tmplogf
}
remove_pkg_autodeps() {
local rval= tmplogf=
[ -z "$CHROOT_READY" ] && return 0
cd $XBPS_MASTERDIR || return 1
msg_normal "${pkgver:-xbps-src}: removing autodeps, please wait...\n"
tmplogf=$(mktemp)
_remove_pkg_cross_deps
$FAKEROOT_CMD xbps-reconfigure -a >> $tmplogf 2>&1
$FAKEROOT_CMD xbps-remove -Ryo >> $tmplogf 2>&1
if [ $? -ne 0 ]; then
msg_red "${pkgver:-xbps-src}: failed to remove autodeps:\n"
cat $tmplogf && rm -f $tmplogf
msg_error "${pkgver:-xbps-src}: cannot continue!\n"
fi
rm -f $tmplogf
}
install_cross_pkg() {
local cross="$1" rval
[ -z "$cross" -o "$cross" = "" ] && return 0
source_file ${XBPS_CROSSPFDIR}/${cross}.sh
if [ -z "$CHROOT_READY" ]; then
echo "ERROR: chroot mode not activated (install a bootstrap)."
exit 1
elif [ -z "$IN_CHROOT" ]; then
return 0
fi
# Install required pkgs for cross building.
if [ "$XBPS_TARGET" != "remove-autodeps" ]; then
check_installed_pkg cross-${XBPS_CROSS_TRIPLET}-0.1_1
if [ $? -ne 0 ]; then
msg_normal "Installing cross pkg: cross-${XBPS_CROSS_TRIPLET} ...\n"
$XBPS_INSTALL_CMD -y cross-${XBPS_CROSS_TRIPLET} &>/dev/null
rval=$?
if [ $rval -ne 0 ]; then
msg_error "failed to install cross-${XBPS_CROSS_TRIPLET} (error $rval)\n"
fi
fi
if [ ! -d ${XBPS_CROSS_BASE}/var/db/xbps/keys ]; then
mkdir -p ${XBPS_CROSS_BASE}/var/db/xbps/keys
cp ${XBPS_MASTERDIR}/var/db/xbps/keys/*.plist \
${XBPS_CROSS_BASE}/var/db/xbps/keys
fi
$XBPS_INSTALL_CMD --repository=http://repo.voidlinux.eu/current \
-r ${XBPS_CROSS_BASE} -SAy cross-vpkg-dummy &>/dev/null
rval=$?
if [ $rval -ne 0 -a $rval -ne 17 ]; then
msg_error "failed to install cross-vpkg-dummy (error $rval)\n"
fi
fi
}
remove_cross_pkg() {
local cross="$1" rval
[ -z "$cross" -o "$cross" = "" ] && return 0
source_file ${XBPS_CROSSPFDIR}/${cross}.sh
if [ -z "$CHROOT_READY" ]; then
echo "ERROR: chroot mode not activated (install a bootstrap)."
exit 1
elif [ -z "$IN_CHROOT" ]; then
return 0
fi
msg_normal "Removing cross pkg: cross-${XBPS_CROSS_TRIPLET} ...\n"
$XBPS_REMOVE_CMD -y cross-${XBPS_CROSS_TRIPLET} &>/dev/null
rval=$?
if [ $rval -ne 0 ]; then
msg_error "failed to remove cross-${XBPS_CROSS_TRIPLET} (error $rval)\n"
fi
}
#
# Returns 0 if pkgpattern in $1 is installed and greater than current
# installed package, otherwise 1.
#
check_installed_pkg() {
local pkg="$1" cross="$2" uhelper= pkgn= iver=
[ -z "$pkg" ] && return 2
pkgn="$($XBPS_UHELPER_CMD getpkgname ${pkg})"
[ -z "$pkgn" ] && return 2
if [ -n "$cross" ]; then
uhelper="$XBPS_UHELPER_XCMD"
else
uhelper="$XBPS_UHELPER_CMD"
fi
iver="$($uhelper version $pkgn)"
if [ $? -eq 0 -a -n "$iver" ]; then
$XBPS_CMPVER_CMD "${pkgn}-${iver}" "${pkg}"
[ $? -eq 0 -o $? -eq 1 ] && return 0
fi
return 1
}

174
common/xbps-src/shutils/pkgtarget.sh Normal file
View file

@ -0,0 +1,174 @@
# -*-* shell *-*-
show_build_options() {
local f opt desc
[ -z "$PKG_BUILD_OPTIONS" ] && return 0
msg_normal "$pkgver: the following build options are set:\n"
for f in ${PKG_BUILD_OPTIONS}; do
opt="${f#\~}"
eval desc="\${desc_option_${opt}}"
if [[ ${f:0:1} == '~' ]]; then
echo " $opt: $desc (OFF)"
else
printf " "
msg_normal_append "$opt: "
printf "$desc (ON)\n"
fi
done
}
check_pkg_arch() {
local cross="$1"
if [ -n "$BEGIN_INSTALL" -a -n "$only_for_archs" ]; then
if [ -n "$cross" ]; then
_arch="$XBPS_TARGET_MACHINE"
elif [ -n "$XBPS_ARCH" ]; then
_arch="$XBPS_ARCH"
else
_arch="$XBPS_MACHINE"
fi
for f in ${only_for_archs}; do
if [ "$f" = "${_arch}" ]; then
found=1
break
fi
done
if [ -z "$found" ]; then
msg_red "$pkgname: this package cannot be built for ${_arch}.\n"
exit 0
fi
fi
}
install_pkg() {
local target="$1" cross="$2" lrepo subpkg opkg
[ -z "$pkgname" ] && return 1
show_build_options
check_pkg_arch $cross
install_cross_pkg $cross
if [ -z "$XBPS_SKIP_DEPS" ]; then
install_pkg_deps $sourcepkg $cross || return 1
if [ "$TARGETPKG_PKGDEPS_DONE" ]; then
setup_pkg $XBPS_TARGET_PKG $cross
unset TARGETPKG_PKGDEPS_DONE
install_cross_pkg $cross
fi
fi
# Fetch distfiles after installing required dependencies,
# because some of them might be required for do_fetch().
$XBPS_LIBEXECDIR/xbps-src-dofetch.sh $sourcepkg $cross || exit 1
[ "$target" = "fetch" ] && return 0
# Fetch, extract, build and install into the destination directory.
$XBPS_LIBEXECDIR/xbps-src-doextract.sh $sourcepkg $cross || exit 1
[ "$target" = "extract" ] && return 0
# Run configure phase
$XBPS_LIBEXECDIR/xbps-src-doconfigure.sh $sourcepkg $cross || exit 1
[ "$target" = "configure" ] && return 0
# Run build phase
$XBPS_LIBEXECDIR/xbps-src-dobuild.sh $sourcepkg $cross || exit 1
[ "$target" = "build" ] && return 0
# Install sourcepkg into destdir.
$FAKEROOT_CMD $XBPS_LIBEXECDIR/xbps-src-doinstall.sh $sourcepkg $cross || exit 1
for subpkg in ${subpackages} ${sourcepkg}; do
# Run subpkg pkg_install func.
$FAKEROOT_CMD $XBPS_LIBEXECDIR/xbps-src-dopkg.sh $subpkg $cross || exit 1
done
if [ "$XBPS_TARGET_PKG" = "$sourcepkg" ]; then
[ "$target" = "install-destdir" ] && return 0
fi
# If install went ok generate the binpkgs.
for subpkg in ${sourcepkg} ${subpackages}; do
$FAKEROOT_CMD $XBPS_LIBEXECDIR/xbps-src-genpkg.sh $subpkg "$XBPS_REPOSITORY" "$cross" || exit 1
done
# pkg cleanup
if declare -f do_clean >/dev/null; then
run_func do_clean
fi
opkg=$pkgver
if [ -z "$XBPS_KEEP_ALL" ]; then
remove_pkg_autodeps
remove_pkg_wrksrc
setup_pkg $sourcepkg $cross
remove_pkg $cross
fi
# If base-chroot not installed, install binpkg into masterdir
# from local repository.
if [ -z "$CHROOT_READY" ]; then
msg_normal "Installing $opkg into masterdir...\n"
local _log=$(mktemp --tmpdir|| exit 1)
if [ -n "$XBPS_BUILD_FORCEMODE" ]; then
local _flags="-f"
fi
$XBPS_INSTALL_CMD ${_flags} -y $opkg >${_log} 2>&1
if [ $? -ne 0 ]; then
msg_red "Failed to install $opkg into masterdir, see below for errors:\n"
cat ${_log}
rm -f ${_log}
msg_error "Cannot continue!"
fi
rm -f ${_log}
fi
if [ "$XBPS_TARGET_PKG" = "$sourcepkg" ]; then
# Package built successfully. Exit directly due to nested install_pkg
# and install_pkg_deps functions.
remove_cross_pkg $cross
exit 0
fi
}
remove_pkg_wrksrc() {
if [ -d "$wrksrc" ]; then
msg_normal "$pkgver: cleaning build directory...\n"
rm -rf $wrksrc
fi
}
remove_pkg() {
local cross="$1" _destdir f
[ -z $pkgname ] && msg_error "unexistent package, aborting.\n"
if [ -n "$cross" ]; then
_destdir="$XBPS_DESTDIR/$XBPS_CROSS_TRIPLET"
else
_destdir="$XBPS_DESTDIR"
fi
for f in ${sourcepkg} ${subpackages}; do
if [ -d "${_destdir}/${f}-${version}" ]; then
msg_normal "$f: removing files from destdir...\n"
rm -rf ${_destdir}/${f}-${version}
fi
if [ -d "${_destdir}/${f}-dbg-${version}" ]; then
msg_normal "$f: removing dbg files from destdir...\n"
rm -rf ${_destdir}/${f}-dbg-${version}
fi
if [ -d "${_destdir}/${f}-32bit-${version}" ]; then
msg_normal "$f: removing 32bit files from destdir...\n"
rm -rf ${_destdir}/${f}-32bit-${version}
fi
rm -f $wrksrc/.xbps_${f}_${cross}_pre_install_done
rm -f $wrksrc/.xbps_${f}_${cross}_install_done
rm -f $wrksrc/.xbps_${f}_${cross}_post_install_done
rm -f $wrksrc/.xbps_${f}_${cross}_pkg_done
rm -f $wrksrc/.xbps_${f}_${cross}_strip_done
done
}

85
common/xbps-src/shutils/show.sh Normal file
View file

@ -0,0 +1,85 @@
# -*-* shell *-*-
show_pkg() {
local i=
echo "pkgname: $pkgname"
echo "version: $version"
echo "revision: $revision"
for i in ${distfiles}; do
[ -n "$i" ] && echo "distfiles: $i"
done
for i in ${checksum}; do
[ -n "$i" ] && echo "checksum: $i"
done
[ -n "$noarch" ] && echo "noarch: yes"
echo "maintainer: $maintainer"
[ -n "$homepage" ] && echo "Upstream URL: $homepage"
[ -n "$license" ] && echo "License(s): $license"
[ -n "$build_style" ] && echo "build_style: $build_style"
for i in ${configure_args}; do
[ -n "$i" ] && echo "configure_args: $i"
done
echo "short_desc: $short_desc"
for i in ${subpackages}; do
[ -n "$i" ] && echo "subpackages: $i"
done
for i in ${conf_files}; do
[ -n "$i" ] && echo "conf_files: $i"
done
for i in ${replaces}; do
[ -n "$i" ] && echo "replaces: $i"
done
for i in ${provides}; do
[ -n "$i" ] && echo "provides: $i"
done
for i in ${conflicts}; do
[ -n "$i" ] && echo "conflicts: $i"
done
[ -n "$long_desc" ] && echo "long_desc: $long_desc"
}
show_pkg_deps() {
[ -f "${PKGDESTDIR}/rdeps" ] && cat ${PKGDESTDIR}/rdeps
}
show_pkg_files() {
[ -d ${PKGDESTDIR} ] && find ${PKGDESTDIR} -print
}
show_pkg_build_deps() {
local f=
# build time deps
for f in ${hostmakedepends} ${makedepends}; do
echo "$f"
done
}
show_pkg_options() {
local f= j= state= desc= enabled=
for f in ${build_options}; do
for j in ${build_options_default}; do
if [ "$f" = "$j" ]; then
enabled=1
break
fi
done
state="OFF"
if [ -n "$enabled" ]; then
state="ON"
unset enabled
fi
eval desc="\$desc_option_$f"
printf "$f: $desc [$state]\n"
done
}
show_pkg_shlib_provides() {
[ -f "${PKGDESTDIR}/shlib-provides" ] && cat ${PKGDESTDIR}/shlib-provides
}
show_pkg_shlib_requires() {
[ -f "${PKGDESTDIR}/shlib-requires" ] && cat ${PKGDESTDIR}/shlib-requires
}

573
common/xbps-src/xbps-src.sh Normal file
View file

@ -0,0 +1,573 @@
#!/bin/bash
# vim: set ts=4 sw=4 et:
usage() {
cat << _EOF
$(basename $0): [options] <target> [arguments]
Targets: (only one may be specified)
binary-bootstrap [arch]
Install bootstrap packages from host repositories into <masterdir>.
If the optional 'arch' argument is set, it will install bootstrap packages
from this architecture, and its required xbps utilities. The <masterdir>
will be initialized for chroot operations.
bootstrap
Build and install from source the bootstrap packages into <masterdir>.
bootstrap-update
Updates bootstrap packages with latest versions available from registered
repositories in the XBPS configuration file.
build <pkgname>
Build package source (fetch + extract + configure + build).
build-pkg <pkgname>
Build binary package for <pkgname> and all required dependencies.
chroot
Enter to the chroot in <masterdir>.
clean <pkgname>
Remove <pkgname> build directory.
remove-autodeps
Removes all package dependencies installed automatically.
configure <pkgname>
Configure a package (fetch + extract + configure).
extract <pkgname>
Extract package source distribution file(s) into the build directory.
By default set to <masterdir>/builddir.
fetch <pkgname>
Download package source distribution file(s).
install-destdir <pkgname>
Install target package into <destdir> but not building the binary package
and not removing build directory for inspection purposes.
remove-destdir <pkgname>
Remove target package from <destdir>. If <pkgname>-<version> is not matched
from build template nothing is removed.
show <pkgname>
Show information for the specified package.
show-build-deps <pkgname>
Show required build dependencies for <pkgname>.
show-deps <pkgname>
Show required run-time dependencies for <pkgname>. Package must be
installed into destdir.
show-files <pkgname>
Show files installed by <pkgname>. Package must be installed into destdir.
show-options <pkgname>
Show available build options by <pkgname>.
show-shlib-provides <pkgname>
Show list of provided shlibs for <pkgname>. Package must be installed into destdir.
show-shlib-requires <pkgname>
Show list of required shlibs for <pkgname>. Package must be installed into destdir.
zap
Removes a masterdir but preserving ccache, distcc and host directories.
Options:
-a <profile>
Cross compile packages for this profile. Supported values:
armv6hf-musl - for ARMv6 EABI (LE Hard Float) Musl/Linux
armv6hf - for ARMv6 EABI (LE Hard Float) GNU/Linux
armv7hf-musl - for ARMv7 EABI (LE Hard Float) Musl/Linux
armv7hf - for ARMv7 EABI (LE Hard Float) GNU/Linux
i686-musl - for i686 Musl/Linux
i686 - for i686 GNU/Linux
mips - for MIPS o32 (BE Soft Float) GNU/Linux
mipsel - for MIPS o32 (LE Soft Float) GNU/Linux
x86_64-musl - for x86_64 Musl/Linux
-C Do not remove build directory, automatic dependencies and
package destdir after successful install.
-f Force building and registering binary packages into the local repository,
even if same version is already registered.
-g Enable building -dbg packages with debugging symbols.
-H <hostdir>
Absolute path to a directory to be bind mounted at <masterdir>/host.
The host directory stores binary packages, sources and package dependencies
downloaded from remote repositories.
-h Usage output.
-I Ignore required dependencies, useful for extracting/fetching sources.
-j Number of parallel build jobs to use when building packages.
-L Disable ASCII colors.
-m <masterdir>
Absolute path to a directory to be used as masterdir.
The masterdir is the main directory to build/store/compile packages.
-N Disable use of remote repositories to resolve dependencies.
-o <opt,~opt2,...>
Enable or disable (prefixed with ~) package build options.
Supported options can be shown with the 'show-options' target.
-r <repo>
Use an alternative local repository to store generated binary packages.
If unset defaults to <masterdir>/host/binpkgs. If set the binpkgs will
be stored into <masterdir>/host/binpkgs/<repo>.
This alternative repository will also be used to resolve dependencies.
_EOF
}
check_reqhost_utils() {
local broken
[ -n "$IN_CHROOT" ] && return 0
for f in ${REQHOST_UTILS}; do
if ! command -v ${f} &>/dev/null; then
echo "${f} is missing in your system, can't continue!"
broken=1
fi
done
[ -n "$broken" ] && exit 1
[ -z "$1" ] && return 0
for f in ${REQHOST_UTILS_BOOTSTRAP}; do
if ! command -v ${f} &>/dev/null; then
echo "${f} is missing in your system, can't continue!"
broken=1
fi
done
[ -n "$broken" ] && exit 1
}
check_config_vars() {
if [ -s "$XBPS_CONFIG_FILE" ]; then
. $XBPS_CONFIG_FILE &>/dev/null
fi
if [ -z "$XBPS_MASTERDIR" ]; then
export XBPS_MASTERDIR="${XBPS_DISTDIR}/masterdir"
fi
if [ -d "$XBPS_MASTERDIR" -a ! -w "$XBPS_MASTERDIR" ]; then
echo "ERROR: not enough perms for masterdir $XBPS_MASTERDIR."
exit 1
fi
}
check_build_requirements() {
local found
for f in $XBPS_SHUTILSDIR/*.sh; do
[ -r $f ] && . $f
done
for f in $XBPS_COMMONDIR/environment/setup/*.sh; do
[ -r $f ] && . $f
done
if [ -z "$XBPS_SRC_REQ" -o -z "$XBPS_UTILS_REQ" -o -z "$XBPS_UTILS_API_REQ" ]; then
echo "ERROR: cannot satisfy xbps requirements!"
exit 1
fi
case "$XBPS_TARGET" in
*bootstrap*) found=1;;
*) ;;
esac
if [ -z "$found" ]; then
xbps-uhelper cmpver $(echo "$XBPS_SRC_VERSION"|awk '{print $1}') "$XBPS_SRC_REQ"
if [ $? -eq 255 ]; then
echo "ERROR: this xbps-src version is outdated! (>=$XBPS_SRC_REQ is required)"
echo "Bootstrap packages must be updated with 'xbps-src bootstrap-update'"
exit 1
fi
xbps-uhelper cmpver "$XBPS_VERSION" "$XBPS_UTILS_REQ"
if [ $? -eq 255 ]; then
echo "ERROR: requires xbps-$XBPS_UTILS_REQ API: $XBPS_UTILS_API_REQ"
echo "Bootstrap packages must be updated with 'xbps-src bootstrap-update'"
exit 1
fi
xbps-uhelper cmpver "$XBPS_APIVER" "$XBPS_UTILS_API_REQ"
if [ $? -eq 255 ]; then
echo "ERROR: requires xbps-$XBPS_UTILS_REQ API: $XBPS_UTILS_API_REQ"
echo "Bootstrap packages must be updated with 'xbps-src bootstrap-update'"
exit 1
fi
fi
# Set XBPS_REPOSITORY to our current branch.
if [ -z "$XBPS_ALT_REPOSITORY" ]; then
pushd "$PWD" &>/dev/null
cd $XBPS_DISTDIR
_gitbranch="$(git symbolic-ref --short HEAD 2>/dev/null)"
if [ -n "${_gitbranch}" -a "${_gitbranch}" != "master" ]; then
export XBPS_REPOSITORY="${XBPS_REPOSITORY}/${_gitbranch}"
msg_normal "Using \`$XBPS_REPOSITORY\' as local repository.\n"
fi
popd &>/dev/null
else
export XBPS_REPOSITORY="${XBPS_REPOSITORY}/${XBPS_ALT_REPOSITORY}"
msg_normal "Using \`$XBPS_REPOSITORY\' as local repository.\n"
fi
}
install_bbotstrap() {
[ -n "$CHROOT_READY" ] && return
# binary bootstrap
msg_normal "Installing bootstrap from binary package repositories...\n"
# XBPS_TARGET_PKG == arch
if [ -n "$XBPS_TARGET_PKG" ]; then
_bootstrap_arch="env XBPS_TARGET_ARCH=$XBPS_TARGET_PKG"
if [ "${XBPS_TARGET_PKG}" != "${XBPS_TARGET_PKG#*-}" ]; then
_subarch="-${XBPS_TARGET_PKG#*-}"
fi
fi
${_bootstrap_arch} xbps-install -S ${XBPS_INSTALL_ARGS} -c host/repocache -r $XBPS_MASTERDIR -y base-chroot${_subarch}
if [ $? -ne 0 ]; then
msg_error "Failed to install bootstrap packages!\n"
fi
# Reconfigure base-directories.
xbps-reconfigure -r $XBPS_MASTERDIR -f base-directories &>/dev/null
msg_normal "Installed bootstrap successfully!\n"
chroot_prepare $XBPS_TARGET_PKG || msg_error "Failed to initialize chroot!\n"
}
masterdir_zap() {
for f in bin boot builddir destdir dev etc home lib lib32 lib64 mnt \
opt proc root run sbin sys tmp usr var xbps .xbps_chroot_init; do
if [ -d "$XBPS_MASTERDIR/$f" ]; then
echo "Removing directory $XBPS_MASTERDIR/$f ..."
rm -rf $XBPS_MASTERDIR/$f
elif [ -h "$XBPS_MASTERDIR/$f" ]; then
echo "Removing link $XBPS_MASTERDIR/$f ..."
rm -f $XBPS_MASTERDIR/$f
elif [ -f "$XBPS_MASTERDIR/$f" ]; then
echo "Removing file $XBPS_MASTERDIR/$f ..."
rm -f $XBPS_MASTERDIR/$f
fi
done
echo "$XBPS_MASTERDIR masterdir cleaned up."
}
exit_func() {
if [ -z "$XBPS_KEEP_ALL" ]; then
if [ -n "$IN_CHROOT" ]; then
remove_pkg_autodeps
fi
fi
if [ -n "$sourcepkg" ]; then
remove_pkg $XBPS_CROSS_BUILD
remove_pkg_wrksrc
fi
if [ -z "$IN_CHROOT" ]; then
msg_red "xbps-src: a failure has ocurred! exiting...\n"
fi
exit 2
}
#
# main()
#
while getopts "a:CfghH:Ij:Lm:No:r:V" opt; do
case $opt in
a) readonly XBPS_CROSS_BUILD="$OPTARG";;
C) readonly XBPS_KEEP_ALL=1;;
f) readonly XBPS_BUILD_FORCEMODE=1;;
g) readonly XBPS_DEBUG_PKGS=1;;
H) readonly XBPS_HOSTDIR="$(readlink -m $OPTARG 2>/dev/null)";;
h) usage && exit 0;;
I) readonly XBPS_SKIP_DEPS=1;;
j) readonly XBPS_MAKEJOBS="$OPTARG";;
L) export NOCOLORS=1;;
m) readonly XBPS_MASTERDIR=$(readlink -m $OPTARG 2>/dev/null);;
N) readonly XBPS_SKIP_REMOTEREPOS=1;;
o) readonly XBPS_BUILD_OPTS="$OPTARG";;
r) readonly XBPS_ALT_REPOSITORY="$OPTARG";;
V) echo $XBPS_SRC_VERSION && exit 0;;
--) shift; break;;
esac
done
shift $(($OPTIND - 1))
[ $# -eq 0 -o $# -gt 3 ] && usage && exit 1
umask 022
#
# Check for required utilities in host system.
#
# Required utilities in host system for the bootstrap target.
readonly REQHOST_UTILS_BOOTSTRAP="awk bash bison sed gcc g++ msgfmt makeinfo \
perl fakeroot tar xz gzip bzip2 patch flex"
# Required utilities in host system for chroot ops.
readonly REQHOST_UTILS="xbps-install xbps-query xbps-rindex xbps-uhelper \
xbps-reconfigure xbps-remove xbps-create git"
check_reqhost_utils
if [ -n "$IN_CHROOT" ]; then
readonly XBPS_CONFIG_FILE=/etc/xbps/xbps-src.conf
readonly XBPS_DISTDIR=/xbps-packages
else
_distdir="$(dirname $0)"
if [ "${_distdir}" = "." ]; then
readonly XBPS_DISTDIR="$(pwd -P)"
else
readonly XBPS_DISTDIR="${_distdir}"
fi
readonly XBPS_CONFIG_FILE=$XBPS_DISTDIR/etc/conf
fi
#
# Check configuration vars before anyting else, and set defaults vars.
#
check_config_vars
if [ -n "$IN_CHROOT" ]; then
readonly XBPS_UHELPER_CMD="xbps-uhelper"
readonly XBPS_INSTALL_CMD="xbps-install"
readonly XBPS_QUERY_CMD="xbps-query"
readonly XBPS_RINDEX_CMD="xbps-rindex"
readonly XBPS_RECONFIGURE_CMD="xbps-reconfigure"
readonly XBPS_REMOVE_CMD="xbps-remove"
else
readonly XBPS_UHELPER_CMD="xbps-uhelper -r $XBPS_MASTERDIR"
readonly XBPS_INSTALL_CMD="xbps-install -C _empty.conf_ --repository=$XBPS_REPOSITORY -r $XBPS_MASTERDIR"
readonly XBPS_QUERY_CMD="xbps-query -C _empty.conf_ --repository=$XBPS_REPOSITORY -r $XBPS_MASTERDIR"
readonly XBPS_RINDEX_CMD="xbps-rindex"
readonly XBPS_RECONFIGURE_CMD="xbps-reconfigure -r $XBPS_MASTERDIR"
readonly XBPS_REMOVE_CMD="xbps-remove -r $XBPS_MASTERDIR"
fi
if [ -n "$XBPS_HOSTDIR" ]; then
export XBPS_REPOSITORY=$XBPS_HOSTDIR/binpkgs
readonly XBPS_SRCDISTDIR=$XBPS_HOSTDIR/sources
else
export XBPS_REPOSITORY=$XBPS_MASTERDIR/host/binpkgs
readonly XBPS_SRCDISTDIR=$XBPS_MASTERDIR/host/sources
fi
readonly XBPS_SRCPKGDIR=$XBPS_DISTDIR/srcpkgs
readonly XBPS_COMMONDIR=$XBPS_DISTDIR/common
readonly XBPS_SHUTILSDIR=$XBPS_COMMONDIR/xbps-src/shutils
readonly XBPS_DESTDIR=$XBPS_MASTERDIR/destdir
readonly XBPS_BUILDDIR=$XBPS_MASTERDIR/builddir
readonly XBPS_TRIGGERSDIR=$XBPS_SRCPKGDIR/xbps-triggers/files
readonly XBPS_CROSSPFDIR=$XBPS_COMMONDIR/cross-profiles
readonly XBPS_BUILDSTYLEDIR=$XBPS_COMMONDIR/build_style
readonly XBPS_LIBEXECDIR=$XBPS_COMMONDIR/xbps-src/libexec
readonly CHROOT_CMD=$XBPS_LIBEXECDIR/xbps-src-chroot-helper
# XBPS_FETCH_CMD can be overriden
export XBPS_FETCH_CMD="xbps-uhelper fetch"
readonly XBPS_DIGEST_CMD="xbps-uhelper digest"
readonly XBPS_CMPVER_CMD="xbps-uhelper cmpver"
readonly XBPS_VERSION=$(xbps-uhelper -V|awk '{print $2}')
readonly XBPS_APIVER=$(xbps-uhelper -V|awk '{print $4}')
readonly XBPS_SRC_VERSION="@@XBPS_SRC_VERSION@@"
readonly FAKEROOT_CMD="fakeroot --"
readonly XBPS_MACHINE=$(uname -m)
XBPS_TARGET="$1"
XBPS_TARGET_PKG="$2"
# Check if stdout is a tty; if false disable colors.
test -t 1 || export NOCOLORS=1
if [ "$(id -u)" -eq 0 ]; then
echo "ERROR: root cannot use xbps-src, switch to a regular user."
exit 1
fi
if [ -f $XBPS_MASTERDIR/.xbps_chroot_init ]; then
export CHROOT_READY=1
fi
if [ -s $XBPS_MASTERDIR/.xbps_chroot_init ]; then
export XBPS_ARCH=$(cat $XBPS_MASTERDIR/.xbps_chroot_init)
fi
export XBPS_SHUTILSDIR XBPS_CROSSPFDIR XBPS_TRIGGERSDIR \
XBPS_SRCPKGDIR XBPS_COMMONDIR XBPS_BUILDDIR \
XBPS_REPOSITORY XBPS_ALT_REPOSITORY XBPS_SRCDISTDIR XBPS_DIGEST_CMD \
XBPS_UHELPER_CMD XBPS_INSTALL_CMD XBPS_QUERY_CMD \
XBPS_RINDEX_CMD XBPS_RECONFIGURE_CMD XBPS_REMOVE_CMD \
XBPS_CMPVER_CMD XBPS_FETCH_CMD XBPS_VERSION XBPS_APIVER \
XBPS_BUILDSTYLEDIR XBPS_CFLAGS XBPS_CXXFLAGS XBPS_LDFLAGS \
XBPS_MAKEJOBS XBPS_BUILD_FORCEMODE XBPS_USE_GIT_REVS XBPS_DEBUG_PKGS \
XBPS_CCACHE XBPS_DISTCC XBPS_DISTCC_HOSTS XBPS_SKIP_DEPS \
XBPS_SKIP_REMOTEREPOS XBPS_CROSS_BUILD XBPS_BUILD_OPTS \
XBPS_CONFIG_FILE XBPS_KEEP_ALL XBPS_HOSTDIR XBPS_MASTERDIR \
XBPS_SRC_VERSION XBPS_DESTDIR FAKEROOT_CMD CHROOT_CMD XBPS_MACHINE
for i in REPOSITORY DESTDIR BUILDDIR SRCDISTDIR; do
eval val="\$XBPS_$i"
if [ ! -d "$val" ]; then
mkdir -p $val
fi
unset val
done
#
# Sanitize PATH.
#
if [ -z "$IN_CHROOT" ]; then
# In non chroot case always prefer host tools.
MYPATH="$XBPS_MASTERDIR/usr/bin:$XBPS_MASTERDIR/usr/sbin"
export PATH="$PATH:$MYPATH"
else
MYPATH="/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin"
export PATH="$MYPATH"
if [ -n "$XBPS_CCACHE" ]; then
CCACHEPATH="/usr/lib/ccache/bin"
if [ -n "$XBPS_HOSTDIR" -a -d "$XBPS_HOSTDIR/ccache" ]; then
export CCACHE_DIR="$XBPS_HOSTDIR/ccache"
else
if [ ! -d "$XBPS_MASTERDIR/ccache" ]; then
mkdir -p $XBPS_MASTERDIR/ccache
fi
export CCACHE_DIR="$XBPS_MASTERDIR/ccache"
fi
export PATH="$CCACHEPATH:$PATH"
fi
if [ -n "$XBPS_DISTCC" ]; then
DISTCCPATH="/usr/lib/distcc/bin"
if [ -n "$XBPS_HOSTDIR" -a -d "$XBPS_HOSTDIR/distcc" ]; then
export DISTCC_DIR="$XBPS_HOSTDIR/distcc"
else
if [ ! -d "$XBPS_MASTERDIR/distcc" ]; then
mkdir -p $XBPS_MASTERDIR/distcc
fi
export DISTCC_DIR="$XBPS_MASTERDIR/distcc"
fi
export DISTCC_HOSTS="$XBPS_DISTCC_HOSTS"
export PATH="$DISTCCPATH:$PATH"
fi
fi
if [ -z "$CHROOT_READY" ]; then
if [ -n "$BASE_CHROOT_REQ" ]; then
check_installed_pkg base-chroot-$BASE_CHROOT_REQ
if [ $? -eq 0 ]; then
# Prepare chroot if required base-chroot pkg is installed.
msg_normal "Preparing chroot on $XBPS_MASTERDIR...\n"
chroot_prepare || return $?
export CHROOT_READY=1
fi
fi
fi
check_build_requirements
trap 'exit_func' INT TERM HUP
#
# Main switch.
#
case "$XBPS_TARGET" in
binary-bootstrap)
install_bbotstrap
;;
bootstrap)
# bootstrap from sources
# check for required host utils
check_reqhost_utils bootstrap
[ ! -d $XBPS_SRCPKGDIR/base-chroot ] && \
msg_error "Cannot find $XBPS_SRCPKGDIR/base-chroot directory!\n"
XBPS_TARGET_PKG="base-chroot"
setup_pkg $XBPS_TARGET_PKG && install_pkg $XBPS_TARGET
;;
bootstrap-update)
if [ -n "$CHROOT_READY" -a -z "$IN_CHROOT" ]; then
chroot_handler ${XBPS_TARGET} dummy
else
${FAKEROOT_CMD} ${XBPS_INSTALL_CMD} -yu
fi
;;
chroot)
chroot_handler chroot dummy
;;
clean)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
if [ -n "$CHROOT_READY" -a -z "$IN_CHROOT" ]; then
chroot_handler $XBPS_TARGET $XBPS_TARGET_PKG || exit $?
else
remove_pkg_wrksrc $wrksrc
if declare -f do_clean >/dev/null; then
run_func do_clean
fi
fi
;;
remove-autodeps)
if [ -n "$CHROOT_READY" -a -z "$IN_CHROOT" ]; then
chroot_handler remove-autodeps
else
pkgver=xbps-src
remove_pkg_autodeps
fi
;;
fetch|extract|build|configure|install-destdir|build-pkg)
BEGIN_INSTALL=1
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
if [ -n "$CHROOT_READY" -a -z "$IN_CHROOT" ]; then
chroot_handler $XBPS_TARGET $XBPS_TARGET_PKG
else
install_pkg $XBPS_TARGET $XBPS_CROSS_BUILD
fi
;;
remove-destdir)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
remove_pkg $XBPS_CROSS_BUILD
;;
list)
$XBPS_QUERY_CMD -l
;;
show)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg
;;
show-files)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg_files
;;
show-deps)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg_deps
;;
show-build-deps)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg_build_deps
;;
show-options)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg_options
;;
show-shlib-provides)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg_shlib_provides
;;
show-shlib-requires)
setup_pkg $XBPS_TARGET_PKG $XBPS_CROSS_BUILD
show_pkg_shlib_requires
;;
zap)
masterdir_zap
;;
*)
msg_red "xbps-src: invalid target $target.\n"
usage && exit 1
;;
esac
# Agur
exit $?

11
etc/conf Normal file
View file

@ -0,0 +1,11 @@
# Configuration file for xbps-src.
#
# Load the defaults in from defaults.conf (if it's readable).
# These can be overridden below.
#
if [ -r ${XBPS_DISTDIR}/etc/defaults.conf ]; then
. ${XBPS_DISTDIR}/etc/defaults.conf
fi
# Add your local overrides below
#

92
etc/defaults.conf Normal file
View file

@ -0,0 +1,92 @@
# --*-- shell --*--
#
# etc/defaults.conf
# default configuration of etc/conf
#
# DO NOT EDIT THIS FILE DIRECTLY; IT MAY BE REPLACED DURING UPDATES,
# EDIT etc/conf INSTEAD.
#
# To disable an option comment it out, don't set it to another value i.e:
# FOO=no -> wrong
# #FOO=yes -> correct
#
# Please also use ${FOO} style for shell variables because some parsers
# rely on this to work properly.
#
# [REQUIRED]
# Master directory. This is where the packages are built and installed.
# By default set to xbps-packages/masterdir.
#
#XBPS_MASTERDIR=${HOME}/masterdir
# [OPTIONAL]
# Host directory to be (bind) mounted into the chroot (masterdir) containing
# directories for downloaded cached packages from xbps-install(8), packages
# created by xbps-src, downloaded source distribution tarballs, etc.
#
# Basically your directory will contain this structure:
#
# /masterdir
# |
# |-----/HOSTDIR
# |- /binpkgs <- local repository
# |- /repocache <- cachedir for dependencies
# |- /sources <- source tarballs
#
# When created, those names are constants, so you cannot change them, even
# they are case sensitive.
#
# NOTE: You must create your toplevel /dir yourself
#
#XBPS_HOSTDIR=/path/to/your/host/directory
# [OPTIONAL]
# Enable optional arguments to xbps-install. This is useful when you use
# static binaries and when you need to specify arguments.
# NOTE: This is only used with the binary-bootstrap target!
#XBPS_INSTALL_ARGS="--repository=http://repo.voidlinux.eu/current"
# [OPTIONAL]
# Compilation flags for C and C++.
#
XBPS_CFLAGS="-O2 -pipe"
XBPS_CXXFLAGS="${XBPS_CFLAGS}"
# [OPTIONAL]
# Linker flags passed to the compiler. By default we use --as-needed to
# avoid linking extra libraries into binaries. See the following link
# for info: http://www.gentoo.org/proj/en/qa/asneeded.xml
#
XBPS_LDFLAGS="-Wl,--as-needed"
# [OPTIONAL]
# Enable or disable ccache when building packages.
#
#XBPS_CCACHE=yes
# [OPTIONAL]
# Enable or disable distcc when building packages.
#
#XBPS_DISTCC=yes
#XBPS_DISTCC_HOSTS=""
# [OPTIONAL]
# Number of parallel jobs to execute when building packages that
# use make(1) or alike commands.
#
#XBPS_MAKEJOBS=4
# [OPTIONAL]
# Enable recording git revisions in final binary packages; enable this
# if you are sure the package you are building is available in the
# xbps-packages git repository.
#
#XBPS_USE_GIT_REVS=yes
# [OPTIONAL]
# Disable building -dbg subpackages with debugging symbols. Please note
# that building with debugging symbols make take a long while in some
# packages even on computers with a fast CPU; as well as needs lots of
# RAM to build properly some packages.
#
#XBPS_DEBUG_PKGS=yes