From 85770ab12e7f94f223692938230d2d49aa0f8612 Mon Sep 17 00:00:00 2001
From: Daniel Sawka <daniel.sawka@phoenix-rtos.com>
Date: Thu, 25 Jul 2024 23:49:27 +0200
Subject: [PATCH] build: Adapt ports to a new common definitions of paths
 (prefixes)

JIRA: NIL-595, CI-339
---
 azure_sdk/build.sh      | 18 +++++++-----------
 busybox/build.sh        | 37 +++++++++++++++++--------------------
 coremark/build.sh       | 29 +++++++++++++----------------
 curl/build.sh           | 25 +++++++++++--------------
 dropbear/build.sh       | 31 ++++++++++++++-----------------
 fs_mark/build.sh        | 23 ++++++++++-------------
 jansson/build.sh        | 23 ++++++++++-------------
 libevent/build.sh       | 21 +++++++++------------
 lighttpd/build.sh       | 29 +++++++++++++----------------
 lua/build.sh            | 17 +++++++----------
 lzo/build.sh            | 21 +++++++++------------
 mbedtls/build.sh        | 27 ++++++++++++---------------
 micropython/build.sh    | 24 ++++++++++--------------
 openiked/build.sh       | 21 +++++++++------------
 openssl/build.sh        | 31 ++++++++++++++-----------------
 openvpn/build.sh        | 27 ++++++++++++---------------
 pcre/build.sh           | 23 ++++++++++-------------
 picocom/build.sh        | 20 ++++++++------------
 sscep/build.sh          | 21 +++++++++------------
 wpa_supplicant/build.sh | 21 +++++++++------------
 zlib/build.sh           | 19 ++++++++-----------
 21 files changed, 221 insertions(+), 287 deletions(-)

diff --git a/azure_sdk/build.sh b/azure_sdk/build.sh
index 099ad132..e57da516 100755
--- a/azure_sdk/build.sh
+++ b/azure_sdk/build.sh
@@ -13,16 +13,12 @@ install_binary () {
 AZURE_VER="lts_01_2022"
 AZURE="azure-iot-sdk-c"
 
-PREFIX_AZURE="${PREFIX_PROJECT}/phoenix-rtos-ports/azure_sdk"
-PREFIX_AZURE_BUILD="${PREFIX_BUILD}/azure_sdk"
-PREFIX_AZURE_SRC="${PREFIX_AZURE_BUILD}/${AZURE}-${AZURE_VER}"
-PREFIX_AZURE_MARKERS="${PREFIX_AZURE_BUILD}/markers"
-PREFIX_AZURE_ROOT="${PREFIX_AZURE_BUILD}/root"
+PREFIX_AZURE_SRC="${PREFIX_PORT_BUILD}/${AZURE}-${AZURE_VER}"
+PREFIX_AZURE_MARKERS="${PREFIX_PORT_BUILD}/markers"
+PREFIX_AZURE_ROOT="${PREFIX_PORT_BUILD}/root"
 PREFIX_AZURE_LIB="${PREFIX_AZURE_ROOT}/lib"
 PREFIX_AZURE_INC="${PREFIX_AZURE_ROOT}/include"
-PREFIX_AZURE_PATCHES="${PREFIX_AZURE}/patches"
-
-b_log "Building azure iot sdk"
+PREFIX_AZURE_PATCHES="${PREFIX_PORT}/patches"
 
 update_options=(--init)
 if [ "${LONG_TEST}" = "y" ]; then
@@ -30,7 +26,7 @@ if [ "${LONG_TEST}" = "y" ]; then
 fi
 
 # Download in the specified version, it can't be done via wget, because tar.gz does not include submodules
-mkdir -p "${PREFIX_AZURE_BUILD}" "${PREFIX_AZURE_MARKERS}"
+mkdir -p "${PREFIX_PORT_BUILD}" "${PREFIX_AZURE_MARKERS}"
 if ! [ -d "${PREFIX_AZURE_SRC}" ]; then
 	git clone -b "${AZURE_VER}" https://github.com/Azure/azure-iot-sdk-c.git "${PREFIX_AZURE_SRC}"
 	# Get the extended version only if the LONG_TEST option was set
@@ -47,7 +43,7 @@ for patchfile in "${PREFIX_AZURE_PATCHES}"/*.patch; do
 			grep -q "armv7m7-imxrt106x" <<< "${TARGET}" || continue
 		fi
 		echo "applying patch: $patchfile"
-		patch -d "${PREFIX_AZURE_BUILD}" -p0 -i "$patchfile" && touch "${PREFIX_AZURE_MARKERS}/${PATCH_NAME}.applied"
+		patch -d "${PREFIX_PORT_BUILD}" -p0 -i "$patchfile" && touch "${PREFIX_AZURE_MARKERS}/${PATCH_NAME}.applied"
 	fi
 	# There are some cpp sources, which is currently not supported in Phoenix-RTOS
 	[ "${LONG_TEST}" = "y" ] && rm -rf "${PREFIX_AZURE_SRC}/c-utility/testtools/micromock"
@@ -70,7 +66,7 @@ export PHOENIX_COMPILER_CMD PHOENIX_SYSROOT
 # Build (http and amqp protocols are currently not supported yet)
 # Treat Phoenix-RTOS as Linux and providing toolchain file was the most suitable solution
 (cd "${PREFIX_AZURE_SRC}/build_all/linux" && ./build.sh \
---toolchain-file "${PREFIX_AZURE}/toolchain-phoenix.cmake" -cl --sysroot="${PHOENIX_SYSROOT}" \
+--toolchain-file "${PREFIX_PORT}/toolchain-phoenix.cmake" -cl --sysroot="${PHOENIX_SYSROOT}" \
 --no-http --no-amqp)
 
 # Create azure root directory with provided libs, includes and binaries
diff --git a/busybox/build.sh b/busybox/build.sh
index 7780843a..ced7e460 100755
--- a/busybox/build.sh
+++ b/busybox/build.sh
@@ -6,29 +6,26 @@ BUSYBOX=busybox-1.27.2
 PKG_URL="https://busybox.net/downloads/${BUSYBOX}.tar.bz2"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${BUSYBOX}.tar.bz2"
 
-b_log "Building busybox"
-PREFIX_BUSYBOX="${PREFIX_PROJECT}/phoenix-rtos-ports/busybox"
-PREFIX_BUSYBOX_BUILD="$PREFIX_BUILD/busybox/"
-PREFIX_BUSYBOX_SRC="$PREFIX_BUSYBOX_BUILD/${BUSYBOX}/"
-PREFIX_BUSYBOX_MARKERS="$PREFIX_BUSYBOX_BUILD/markers/"
-: "${BUSYBOX_CONFIG:="${PREFIX_BUSYBOX}/config"}"
+PREFIX_BUSYBOX_SRC="$PREFIX_PORT_BUILD/${BUSYBOX}/"
+PREFIX_BUSYBOX_MARKERS="$PREFIX_PORT_BUILD/markers/"
+: "${BUSYBOX_CONFIG:="${PREFIX_PORT}/config"}"
 
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_BUSYBOX_BUILD" "$PREFIX_BUSYBOX_MARKERS"
-if [ ! -f "$PREFIX_BUSYBOX/${BUSYBOX}.tar.bz2" ]; then
-	if ! wget -T 10 "$PKG_URL" -P "${PREFIX_BUSYBOX}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_BUSYBOX}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_BUSYBOX_MARKERS"
+if [ ! -f "$PREFIX_PORT/${BUSYBOX}.tar.bz2" ]; then
+	if ! wget -T 10 "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_BUSYBOX_SRC" ] || ( tar jxf "$PREFIX_BUSYBOX/${BUSYBOX}.tar.bz2" -C "$PREFIX_BUSYBOX_BUILD" && rm -rf "${PREFIX_BUSYBOX_MARKERS:?}/*")
+[ -d "$PREFIX_BUSYBOX_SRC" ] || ( tar jxf "$PREFIX_PORT/${BUSYBOX}.tar.bz2" -C "$PREFIX_PORT_BUILD" && rm -rf "${PREFIX_BUSYBOX_MARKERS:?}/*")
 
 #
 # Apply patches
 #
-for patchfile in "$PREFIX_BUSYBOX"/*.patch; do
+for patchfile in "$PREFIX_PORT"/*.patch; do
 	if [ ! -f "$PREFIX_BUSYBOX_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_BUSYBOX_SRC" -p1 < "$patchfile"
@@ -39,13 +36,13 @@ done
 #
 # Configure
 #
-if [ ! -f "${PREFIX_BUSYBOX_BUILD}/.config" ] || [ "${BUSYBOX_CONFIG}" -nt "${PREFIX_BUSYBOX_BUILD}/.config" ]; then
-	cp -a "${BUSYBOX_CONFIG}" "${PREFIX_BUSYBOX_BUILD}"/.config
-	make -C "${PREFIX_BUSYBOX_BUILD}" KBUILD_SRC="$PREFIX_BUSYBOX_SRC" -f "${PREFIX_BUSYBOX_SRC}"/Makefile CROSS_COMPILE="$CROSS" CONFIG_PREFIX="$PREFIX_FS/root" clean
+if [ ! -f "${PREFIX_PORT_BUILD}/.config" ] || [ "${BUSYBOX_CONFIG}" -nt "${PREFIX_PORT_BUILD}/.config" ]; then
+	cp -a "${BUSYBOX_CONFIG}" "${PREFIX_PORT_BUILD}"/.config
+	make -C "${PREFIX_PORT_BUILD}" KBUILD_SRC="$PREFIX_BUSYBOX_SRC" -f "${PREFIX_BUSYBOX_SRC}"/Makefile CROSS_COMPILE="$CROSS" CONFIG_PREFIX="$PREFIX_FS/root" clean
 fi
 
 # hackish: remove the final binary to re-link potential libc changes
-rm -rf "$PREFIX_BUSYBOX_BUILD/busybox_unstripped" "$PREFIX_BUSYBOX_BUILD/busybox"
+rm -rf "$PREFIX_PORT_BUILD/busybox_unstripped" "$PREFIX_PORT_BUILD/busybox"
 
 # For MacOS
 export LC_CTYPE=C
@@ -55,13 +52,13 @@ else
 	UNSTRIPPED=n
 fi
 
-make -C "${PREFIX_BUSYBOX_BUILD}" KBUILD_SRC="$PREFIX_BUSYBOX_SRC" -f "${PREFIX_BUSYBOX_SRC}"/Makefile CROSS_COMPILE="$CROSS" CONFIG_PREFIX="$PREFIX_FS/root" SKIP_STRIP="$UNSTRIPPED" all
-make -C "${PREFIX_BUSYBOX_BUILD}" KBUILD_SRC="$PREFIX_BUSYBOX_SRC" -f "${PREFIX_BUSYBOX_SRC}"/Makefile CROSS_COMPILE="$CROSS" CONFIG_PREFIX="$PREFIX_FS/root" SKIP_STRIP="$UNSTRIPPED" install
-cp -a "$PREFIX_BUSYBOX_BUILD/busybox_unstripped" "$PREFIX_PROG"
+make -C "${PREFIX_PORT_BUILD}" KBUILD_SRC="$PREFIX_BUSYBOX_SRC" -f "${PREFIX_BUSYBOX_SRC}"/Makefile CROSS_COMPILE="$CROSS" CONFIG_PREFIX="$PREFIX_FS/root" SKIP_STRIP="$UNSTRIPPED" all
+make -C "${PREFIX_PORT_BUILD}" KBUILD_SRC="$PREFIX_BUSYBOX_SRC" -f "${PREFIX_BUSYBOX_SRC}"/Makefile CROSS_COMPILE="$CROSS" CONFIG_PREFIX="$PREFIX_FS/root" SKIP_STRIP="$UNSTRIPPED" install
+cp -a "$PREFIX_PORT_BUILD/busybox_unstripped" "$PREFIX_PROG"
 
 if [ "$LONG_TEST" = "y" ]; then
 	mkdir -p "$PREFIX_ROOTFS/usr/test/busybox"
 	cp -a "$PREFIX_BUSYBOX_SRC/testsuite" "$PREFIX_ROOTFS/usr/test/busybox"
 	# busybox test suite requires .config file and busybox binary in the same bin directory
-	cp "$PREFIX_BUSYBOX_BUILD/.config" "$PREFIX_ROOTFS/bin"
+	cp "$PREFIX_PORT_BUILD/.config" "$PREFIX_ROOTFS/bin"
 fi
diff --git a/coremark/build.sh b/coremark/build.sh
index 7e243a75..91b2fbbd 100755
--- a/coremark/build.sh
+++ b/coremark/build.sh
@@ -8,24 +8,21 @@ COREMARK_COMMIT="d5fad6bd094899101a4e5fd53af7298160ced6ab"
 PKG_URL="https://github.com/eembc/coremark/archive/${COREMARK_COMMIT}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${COREMARK}.tar.gz"
 
-b_log "Building coremark"
-PREFIX_COREMARK="${PREFIX_PROJECT}/phoenix-rtos-ports/coremark"
-PREFIX_COREMARK_BUILD="${PREFIX_BUILD}/coremark"
-PREFIX_COREMARK_SRC="${PREFIX_COREMARK_BUILD}/${COREMARK}"
-PREFIX_COREMARK_MARKERS="${PREFIX_COREMARK_BUILD}/markers"
+PREFIX_COREMARK_SRC="${PREFIX_PORT_BUILD}/${COREMARK}"
+PREFIX_COREMARK_MARKERS="${PREFIX_PORT_BUILD}/markers"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_COREMARK_BUILD"
-if ! [ -f "${PREFIX_COREMARK}/${COREMARK}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -O "${PREFIX_COREMARK}/${COREMARK}.tar.gz" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_COREMARK}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD"
+if ! [ -f "${PREFIX_PORT}/${COREMARK}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -O "${PREFIX_PORT}/${COREMARK}.tar.gz" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
 
 if ! [ -d "${PREFIX_COREMARK_SRC}" ]; then
-	tar xzf "${PREFIX_COREMARK}/${COREMARK}.tar.gz" -C "${PREFIX_COREMARK_BUILD}" && mv "${PREFIX_COREMARK_BUILD}"/coremark-"${COREMARK_COMMIT}" "${PREFIX_COREMARK_BUILD}"/${COREMARK}
+	tar xzf "${PREFIX_PORT}/${COREMARK}.tar.gz" -C "${PREFIX_PORT_BUILD}" && mv "${PREFIX_PORT_BUILD}"/coremark-"${COREMARK_COMMIT}" "${PREFIX_PORT_BUILD}"/${COREMARK}
 fi
 
 #
@@ -33,8 +30,8 @@ fi
 #
 mkdir -p "$PREFIX_COREMARK_MARKERS"
 
-for patchfile in "$PREFIX_COREMARK"/*.patch; do
-	if [ ! -f "$PREFIX_COREMARK_BUILD/markers/$(basename "$patchfile").applied" ]; then
+for patchfile in "$PREFIX_PORT"/*.patch; do
+	if [ ! -f "$PREFIX_PORT_BUILD/markers/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_COREMARK_SRC" -p1 < "$patchfile"
 		touch "$PREFIX_COREMARK_MARKERS/$(basename "$patchfile").applied"
@@ -44,10 +41,10 @@ done
 #
 # Configure
 #
-mkdir -p "${PREFIX_COREMARK_BUILD}/${COREMARK}/phoenix"
-cp -a "$PREFIX_COREMARK/core-portme.mak" "$PREFIX_COREMARK_BUILD/${COREMARK}/phoenix/core_portme.mak"
+mkdir -p "${PREFIX_PORT_BUILD}/${COREMARK}/phoenix"
+cp -a "$PREFIX_PORT/core-portme.mak" "$PREFIX_PORT_BUILD/${COREMARK}/phoenix/core_portme.mak"
 
-cd "${PREFIX_COREMARK_BUILD}/${COREMARK}"
+cd "${PREFIX_PORT_BUILD}/${COREMARK}"
 
 if [ -z ${PORTS_COREMARK_THREADS+x} ]; then
 	PORTS_COREMARK_THREADS="1"
@@ -58,6 +55,6 @@ export XCFLAGS="${CFLAGS} -DUSE_PTHREAD -DMULTITHREAD=${PORTS_COREMARK_THREADS}
 # Build coremark
 PORT_DIR=phoenix make compile
 
-cp -a "$PREFIX_COREMARK_BUILD/${COREMARK}/coremark" "$PREFIX_PROG/coremark"
+cp -a "$PREFIX_PORT_BUILD/${COREMARK}/coremark" "$PREFIX_PROG/coremark"
 $STRIP -o "${PREFIX_PROG_STRIPPED}/coremark" "${PREFIX_PROG}/coremark"
 b_install "$PREFIX_PORTS_INSTALL/coremark" /bin
diff --git a/curl/build.sh b/curl/build.sh
index 2a2d79ec..3c135256 100755
--- a/curl/build.sh
+++ b/curl/build.sh
@@ -6,29 +6,26 @@ CURL=curl-7.64.1
 PKG_URL="https://curl.haxx.se/download/${CURL}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${CURL}.tar.gz"
 
-b_log "Building curl"
-PREFIX_CURL="${PREFIX_PROJECT}/phoenix-rtos-ports/curl"
-PREFIX_CURL_BUILD="${PREFIX_BUILD}/curl"
-PREFIX_CURL_SRC="${PREFIX_CURL_BUILD}/${CURL}"
-PREFIX_CURL_INSTALL="$PREFIX_CURL_BUILD/install"
+PREFIX_CURL_SRC="${PREFIX_PORT_BUILD}/${CURL}"
+PREFIX_CURL_INSTALL="$PREFIX_PORT_BUILD/install"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_CURL_BUILD" "$PREFIX_CURL_INSTALL"
-if [ ! -f "$PREFIX_CURL/${CURL}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_CURL}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_CURL}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_CURL_INSTALL"
+if [ ! -f "$PREFIX_PORT/${CURL}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_CURL_SRC" ] || tar zxf "$PREFIX_CURL/${CURL}.tar.gz" -C "$PREFIX_CURL_BUILD"
+[ -d "$PREFIX_CURL_SRC" ] || tar zxf "$PREFIX_PORT/${CURL}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 
 #
 # Configure
 #
-if [ ! -f "$PREFIX_CURL_BUILD/config.status" ]; then
-	( cd "$PREFIX_CURL_BUILD" && PKG_CONFIG="" "$PREFIX_CURL_SRC/configure" CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" \
+if [ ! -f "$PREFIX_PORT_BUILD/config.status" ]; then
+	( cd "$PREFIX_PORT_BUILD" && PKG_CONFIG="" "$PREFIX_CURL_SRC/configure" CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" \
 		--host="${HOST}" --sbindir="$PREFIX_PROG" --disable-pthreads --disable-threaded-resolver \
 		--disable-ipv6 --prefix="$PREFIX_CURL_INSTALL" --disable-ntlm-wb --without-zlib )
 fi
@@ -36,8 +33,8 @@ fi
 #
 # Make
 #
-make -C "$PREFIX_CURL_BUILD"
-make -C "$PREFIX_CURL_BUILD" install
+make -C "$PREFIX_PORT_BUILD"
+make -C "$PREFIX_PORT_BUILD" install
 
 cp -a "$PREFIX_CURL_INSTALL/include/curl" "$PREFIX_H"
 cp -a "$PREFIX_CURL_INSTALL/lib/"* "$PREFIX_A"
diff --git a/dropbear/build.sh b/dropbear/build.sh
index 67992d3c..48c7ca00 100755
--- a/dropbear/build.sh
+++ b/dropbear/build.sh
@@ -6,27 +6,24 @@ DROPBEAR=dropbear-2018.76
 PKG_URL="https://matt.ucc.asn.au/dropbear/releases/${DROPBEAR}.tar.bz2"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${DROPBEAR}.tar.bz2"
 
-b_log "Building dropbear"
-PREFIX_DROPBEAR="${PREFIX_PROJECT}/phoenix-rtos-ports/dropbear"
-PREFIX_DROPBEAR_BUILD="${PREFIX_BUILD}/dropbear"
-PREFIX_DROPBEAR_SRC="${PREFIX_DROPBEAR_BUILD}/${DROPBEAR}"
-PREFIX_DROPBEAR_MARKERS="${PREFIX_DROPBEAR_BUILD}/markers"
+PREFIX_DROPBEAR_SRC="${PREFIX_PORT_BUILD}/${DROPBEAR}"
+PREFIX_DROPBEAR_MARKERS="${PREFIX_PORT_BUILD}/markers"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_DROPBEAR_BUILD" "$PREFIX_DROPBEAR_MARKERS"
-if [ ! -f "$PREFIX_DROPBEAR/${DROPBEAR}.tar.bz2" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_DROPBEAR}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_DROPBEAR}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_DROPBEAR_MARKERS"
+if [ ! -f "$PREFIX_PORT/${DROPBEAR}.tar.bz2" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_DROPBEAR_SRC" ] || ( tar jxf "$PREFIX_DROPBEAR/${DROPBEAR}.tar.bz2" -C "${PREFIX_DROPBEAR_BUILD}" && rm -rf "${PREFIX_DROPBEAR_MARKERS:?}/*" )
+[ -d "$PREFIX_DROPBEAR_SRC" ] || ( tar jxf "$PREFIX_PORT/${DROPBEAR}.tar.bz2" -C "${PREFIX_PORT_BUILD}" && rm -rf "${PREFIX_DROPBEAR_MARKERS:?}/*" )
 
 #
 # Apply patches
 #
-for patchfile in "$PREFIX_DROPBEAR"/patch/*; do
+for patchfile in "$PREFIX_PORT"/patch/*; do
 	if [ ! -f "$PREFIX_DROPBEAR_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_DROPBEAR_SRC" -p1 < "$patchfile"
@@ -37,15 +34,15 @@ done
 #
 # Configure
 #
-if [ ! -f "$PREFIX_DROPBEAR_BUILD/config.h" ]; then
-	cp -a "$PREFIX_DROPBEAR/localoptions.h" "$PREFIX_DROPBEAR_BUILD"
+if [ ! -f "$PREFIX_PORT_BUILD/config.h" ]; then
+	cp -a "$PREFIX_PORT/localoptions.h" "$PREFIX_PORT_BUILD"
 
 	DROPBEAR_CFLAGS="-DENDIAN_LITTLE -DUSE_DEV_PTMX ${DROPBEAR_CUSTOM_CFLAGS}"
 	DROPBEAR_LDFLAGS=""
 	ENABLE_ZLIB="no" && [ "$PORTS_ZLIB" = "y" ] && ENABLE_ZLIB="yes"
 	export OLDCFLAGS="-v"  # HACKISH: fix ./configure script not detecting externally-provided CFLAGS
 
-	( cd "${PREFIX_DROPBEAR_BUILD}" && "${PREFIX_DROPBEAR_SRC}/configure" CFLAGS="${CFLAGS} ${DROPBEAR_CFLAGS}" \
+	( cd "${PREFIX_PORT_BUILD}" && "${PREFIX_DROPBEAR_SRC}/configure" CFLAGS="${CFLAGS} ${DROPBEAR_CFLAGS}" \
 		LDFLAGS="${CFLAGS} ${LDFLAGS} ${DROPBEAR_LDFLAGS}" ARFLAGS="-r" \
 		--host="${HOST}" --includedir="${PREFIX_H}"  \
 		--prefix="${PREFIX_PROG}" --program-prefix="${PREFIX_PROG}" --libdir="${PREFIX_A}" --bindir="${PREFIX_PROG}" --enable-zlib="$ENABLE_ZLIB" --enable-static \
@@ -56,10 +53,10 @@ fi
 # Make
 #
 # create multi-binary and hardlinks
-make PROGRAMS="dropbear dbclient dropbearkey scp" -C "${PREFIX_DROPBEAR_BUILD}" CROSS_COMPILE="$CROSS" MULTI=1 NO_ADDTL_WARNINGS=1
+make PROGRAMS="dropbear dbclient dropbearkey scp" -C "${PREFIX_PORT_BUILD}" CROSS_COMPILE="$CROSS" MULTI=1 NO_ADDTL_WARNINGS=1
 
-$STRIP -o "$PREFIX_PROG_STRIPPED/dropbearmulti" "$PREFIX_DROPBEAR_BUILD/dropbearmulti"
-cp -a "$PREFIX_DROPBEAR_BUILD/dropbearmulti" "$PREFIX_PROG/dropbearmulti"
+$STRIP -o "$PREFIX_PROG_STRIPPED/dropbearmulti" "$PREFIX_PORT_BUILD/dropbearmulti"
+cp -a "$PREFIX_PORT_BUILD/dropbearmulti" "$PREFIX_PROG/dropbearmulti"
 
 b_install "$PREFIX_PORTS_INSTALL/dropbearmulti" /usr/bin
 mkdir -p "$PREFIX_ROOTFS/usr/sbin"
diff --git a/fs_mark/build.sh b/fs_mark/build.sh
index af4c61e4..e7e16ef9 100755
--- a/fs_mark/build.sh
+++ b/fs_mark/build.sh
@@ -8,30 +8,27 @@ FS_MARK_COMMIT="2628be58146de63a13260ff64550f84275556c0e"
 PKG_URL="https://github.com/josefbacik/fs_mark/archive/${FS_MARK_COMMIT}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${FS_MARK}.tar.gz"
 
-b_log "Building fs_mark"
-PREFIX_FS_MARK=${PREFIX_PROJECT}/phoenix-rtos-ports/fs_mark
-PREFIX_FS_MARK_BUILD="${PREFIX_BUILD}/fs_mark"
-PREFIX_FS_MARK_SRC="${PREFIX_FS_MARK_BUILD}/${FS_MARK}"
-PREFIX_FS_MARK_MARKERS="${PREFIX_FS_MARK_BUILD}/markers"
+PREFIX_FS_MARK_SRC="${PREFIX_PORT_BUILD}/${FS_MARK}"
+PREFIX_FS_MARK_MARKERS="${PREFIX_PORT_BUILD}/markers"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_FS_MARK_BUILD" "$PREFIX_FS_MARK_MARKERS"
-if ! [ -f "${PREFIX_FS_MARK}/${FS_MARK}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -O "${PREFIX_FS_MARK}/${FS_MARK}.tar.gz" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_FS_MARK}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_FS_MARK_MARKERS"
+if ! [ -f "${PREFIX_PORT}/${FS_MARK}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -O "${PREFIX_PORT}/${FS_MARK}.tar.gz" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
 
 if ! [ -d "${PREFIX_FS_MARK_SRC}" ]; then
-	tar xzf "${PREFIX_FS_MARK}/${FS_MARK}.tar.gz" -C "${PREFIX_FS_MARK_BUILD}" && mv "${PREFIX_FS_MARK_BUILD}"/fs_mark-"${FS_MARK_COMMIT}" "${PREFIX_FS_MARK_BUILD}"/${FS_MARK}
+	tar xzf "${PREFIX_PORT}/${FS_MARK}.tar.gz" -C "${PREFIX_PORT_BUILD}" && mv "${PREFIX_PORT_BUILD}"/fs_mark-"${FS_MARK_COMMIT}" "${PREFIX_PORT_BUILD}"/${FS_MARK}
 fi
 
 #
 # Apply patches
 #
-for patchfile in "$PREFIX_FS_MARK"/patch/*; do
+for patchfile in "$PREFIX_PORT"/patch/*; do
 	if [ ! -f "$PREFIX_FS_MARK_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_FS_MARK_SRC" -p1 < "$patchfile"
@@ -40,8 +37,8 @@ for patchfile in "$PREFIX_FS_MARK"/patch/*; do
 done
 
 # Build fs_mark
-cd "${PREFIX_FS_MARK_BUILD}/${FS_MARK}" && make
+cd "${PREFIX_PORT_BUILD}/${FS_MARK}" && make
 
-cp -a "$PREFIX_FS_MARK_BUILD/${FS_MARK}/fs_mark" "$PREFIX_PROG/fs_mark"
+cp -a "$PREFIX_PORT_BUILD/${FS_MARK}/fs_mark" "$PREFIX_PROG/fs_mark"
 $STRIP -o "${PREFIX_PROG_STRIPPED}/fs_mark" "${PREFIX_PROG}/fs_mark"
 b_install "$PREFIX_PORTS_INSTALL/fs_mark" /bin
diff --git a/jansson/build.sh b/jansson/build.sh
index f22d0353..2f031718 100755
--- a/jansson/build.sh
+++ b/jansson/build.sh
@@ -6,21 +6,18 @@ JANSSON=jansson-2.12
 PKG_URL="http://www.digip.org/jansson/releases/${JANSSON}.tar.bz2"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${JANSSON}.tar.bz2"
 
-b_log "Building jansson"
-PREFIX_JANSSON="${PREFIX_PROJECT}/phoenix-rtos-ports/jansson"
-PREFIX_JANSSON_BUILD="${PREFIX_BUILD}/jansson"
-PREFIX_JANSSON_SRC="${PREFIX_JANSSON_BUILD}/${JANSSON}"
+PREFIX_JANSSON_SRC="${PREFIX_PORT_BUILD}/${JANSSON}"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_JANSSON_BUILD"
-if [ ! -f "$PREFIX_JANSSON/${JANSSON}.tar.bz2" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_JANSSON}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_JANSSON}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD"
+if [ ! -f "$PREFIX_PORT/${JANSSON}.tar.bz2" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_JANSSON_SRC" ] || tar jxf "$PREFIX_JANSSON/${JANSSON}.tar.bz2" -C "$PREFIX_JANSSON_BUILD"
+[ -d "$PREFIX_JANSSON_SRC" ] || tar jxf "$PREFIX_PORT/${JANSSON}.tar.bz2" -C "$PREFIX_PORT_BUILD"
 
 
 #
@@ -29,10 +26,10 @@ fi
 # hacks for incremental build:
 # - use "install -p" to preserve timestamps in headers
 # - use "echo" instead of "ranlib" to not overwrite static lib with every recompile (note: using ar -s while linking instead)
-if [ ! -f "$PREFIX_JANSSON_BUILD/config.status" ]; then
-	( cd "${PREFIX_JANSSON_BUILD}" && "${PREFIX_JANSSON_SRC}/configure" CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" ARFLAGS="\"-r -s\"" RANLIB="echo" INSTALL="$(which install) -p" \
+if [ ! -f "$PREFIX_PORT_BUILD/config.status" ]; then
+	( cd "${PREFIX_PORT_BUILD}" && "${PREFIX_JANSSON_SRC}/configure" CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" ARFLAGS="\"-r -s\"" RANLIB="echo" INSTALL="$(which install) -p" \
 		--enable-static --disable-shared --host="$HOST" \
-		--prefix="${PREFIX_JANSSON_BUILD}" --libdir="${PREFIX_BUILD}/lib" \
+		--prefix="${PREFIX_PORT_BUILD}" --libdir="${PREFIX_BUILD}/lib" \
 		--includedir="${PREFIX_BUILD}/include" )
 
 fi
@@ -40,4 +37,4 @@ fi
 #
 # Make
 #
-make -C "$PREFIX_JANSSON_BUILD" install
+make -C "$PREFIX_PORT_BUILD" install
diff --git a/libevent/build.sh b/libevent/build.sh
index 9140d1d2..88f79909 100755
--- a/libevent/build.sh
+++ b/libevent/build.sh
@@ -6,31 +6,28 @@ LIBEVENT=libevent-2.1.12-stable
 PKG_URL="https://github.com/libevent/libevent/releases/download/release-2.1.12-stable/${LIBEVENT}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${LIBEVENT}.tar.gz"
 
-b_log "Building libevent"
-PREFIX_LIBEVENT="${PREFIX_PROJECT}/phoenix-rtos-ports/libevent"
-PREFIX_LIBEVENT_BUILD="${PREFIX_BUILD}/libevent"
-PREFIX_LIBEVENT_SRC="${PREFIX_LIBEVENT_BUILD}/${LIBEVENT}"
-PREFIX_LIBEVENT_MARKERS="${PREFIX_LIBEVENT_BUILD}/markers"
-PREFIX_LIBEVENT_INSTALL="${PREFIX_LIBEVENT_BUILD}/install"
+PREFIX_LIBEVENT_SRC="${PREFIX_PORT_BUILD}/${LIBEVENT}"
+PREFIX_LIBEVENT_MARKERS="${PREFIX_PORT_BUILD}/markers"
+PREFIX_LIBEVENT_INSTALL="${PREFIX_PORT_BUILD}/install"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_LIBEVENT_BUILD"
+mkdir -p "$PREFIX_PORT_BUILD"
 
-if [ ! -f "${PREFIX_LIBEVENT}/${LIBEVENT}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_LIBEVENT}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_LIBEVENT}" --no-check-certificate
+if [ ! -f "${PREFIX_PORT}/${LIBEVENT}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_LIBEVENT_SRC" ] || tar zxf "${PREFIX_LIBEVENT}/${LIBEVENT}.tar.gz" -C "$PREFIX_LIBEVENT_BUILD"
+[ -d "$PREFIX_LIBEVENT_SRC" ] || tar zxf "${PREFIX_PORT}/${LIBEVENT}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
 mkdir -p "$PREFIX_LIBEVENT_MARKERS"
 
-for patchfile in "${PREFIX_LIBEVENT}"/patches/*.patch; do
+for patchfile in "${PREFIX_PORT}"/patches/*.patch; do
 	if [ ! -f "${PREFIX_LIBEVENT_MARKERS}/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_LIBEVENT_SRC" -p1 < "$patchfile"
diff --git a/lighttpd/build.sh b/lighttpd/build.sh
index eee26fcc..ffd09ea7 100755
--- a/lighttpd/build.sh
+++ b/lighttpd/build.sh
@@ -6,11 +6,8 @@ LIGHTTPD="lighttpd-1.4.53"
 PKG_URL="https://download.lighttpd.net/lighttpd/releases-1.4.x/${LIGHTTPD}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${LIGHTTPD}.tar.gz"
 
-b_log "Building lighttpd"
-PREFIX_LIGHTTPD="${PREFIX_PROJECT}/phoenix-rtos-ports/lighttpd"
-PREFIX_LIGHTTPD_BUILD="${PREFIX_BUILD}/lighttpd"
-PREFIX_LIGHTTPD_SRC="${PREFIX_LIGHTTPD_BUILD}/${LIGHTTPD}"
-PREFIX_LIGHTTPD_MARKERS="$PREFIX_LIGHTTPD_BUILD/markers/"
+PREFIX_LIGHTTPD_SRC="${PREFIX_PORT_BUILD}/${LIGHTTPD}"
+PREFIX_LIGHTTPD_MARKERS="$PREFIX_PORT_BUILD/markers/"
 
 PREFIX_OPENSSL=${PREFIX_BUILD}
 PREFIX_PCRE=${PREFIX_BUILD}
@@ -18,18 +15,18 @@ PREFIX_PCRE=${PREFIX_BUILD}
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_LIGHTTPD_BUILD" "$PREFIX_LIGHTTPD_MARKERS"
-if [ ! -f "$PREFIX_LIGHTTPD/${LIGHTTPD}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_LIGHTTPD}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_LIGHTTPD}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_LIGHTTPD_MARKERS"
+if [ ! -f "$PREFIX_PORT/${LIGHTTPD}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_LIGHTTPD_SRC" ] || tar zxf "$PREFIX_LIGHTTPD/${LIGHTTPD}.tar.gz" -C "$PREFIX_LIGHTTPD_BUILD"
+[ -d "$PREFIX_LIGHTTPD_SRC" ] || tar zxf "$PREFIX_PORT/${LIGHTTPD}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
-for patchfile in "${PREFIX_LIGHTTPD}"/patches/*.patch; do
+for patchfile in "${PREFIX_PORT}"/patches/*.patch; do
 	if [ ! -f "$PREFIX_LIGHTTPD_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_LIGHTTPD_SRC" -p1 < "$patchfile"
@@ -40,7 +37,7 @@ done
 #
 # Configure
 #
-if [ ! -f "$PREFIX_LIGHTTPD_BUILD/config.h" ]; then
+if [ ! -f "$PREFIX_PORT_BUILD/config.h" ]; then
 	# FIXME: take into account commented-out modules
 	CONFIGFILE=$(find "${PREFIX_ROOTFS:?PREFIX_ROOTFS not set!}/etc" -name "lighttpd.conf")
 	grep mod_ "$CONFIGFILE" | cut -d'"' -f2 | xargs -L1 -I{} echo "PLUGIN_INIT({})" > "$PREFIX_LIGHTTPD_SRC"/src/plugin-static.h
@@ -48,14 +45,14 @@ if [ ! -f "$PREFIX_LIGHTTPD_BUILD/config.h" ]; then
 	LIGHTTPD_CFLAGS="-DLIGHTTPD_STATIC -DPHOENIX"
 	WITH_ZLIB="no" && [ "$PORTS_ZLIB" = "y" ] && WITH_ZLIB="yes"
 
-	( cd "$PREFIX_LIGHTTPD_BUILD" && "$PREFIX_LIGHTTPD_SRC/configure" LIGHTTPD_STATIC=yes CFLAGS="${LIGHTTPD_CFLAGS} ${CFLAGS}" CPPFLAGS="" LDFLAGS="${LDFLAGS}" AR_FLAGS="-r" \
+	( cd "$PREFIX_PORT_BUILD" && "$PREFIX_LIGHTTPD_SRC/configure" LIGHTTPD_STATIC=yes CFLAGS="${LIGHTTPD_CFLAGS} ${CFLAGS}" CPPFLAGS="" LDFLAGS="${LDFLAGS}" AR_FLAGS="-r" \
 		-C --disable-ipv6 --disable-mmap --with-bzip2=no \
 		--with-zlib="$WITH_ZLIB" --enable-shared=no --enable-static=yes --disable-shared  --host="$HOST" --with-openssl="${PREFIX_OPENSSL}" --with-pcre="${PREFIX_PCRE}" \
-		--prefix="$PREFIX_LIGHTTPD_BUILD" --sbindir="$PREFIX_PROG")
+		--prefix="$PREFIX_PORT_BUILD" --sbindir="$PREFIX_PROG")
 
 	set +e
 	ex "+/HAVE_MMAP 1/d" "+/HAVE_MUNMAP 1/d" "+/HAVE_GETRLIMIT 1/d" "+/HAVE_SYS_POLL_H 1/d" \
-	   "+/HAVE_SIGACTION 1/d" "+/HAVE_DLFCN_H 1/d" -cwq "$PREFIX_LIGHTTPD_BUILD/config.h"
+	   "+/HAVE_SIGACTION 1/d" "+/HAVE_DLFCN_H 1/d" -cwq "$PREFIX_PORT_BUILD/config.h"
 	set -e
 fi
 
@@ -63,7 +60,7 @@ fi
 # Make
 #
 
-make -C "${PREFIX_LIGHTTPD_BUILD}" install
+make -C "${PREFIX_PORT_BUILD}" install
 
 $STRIP -o "$PREFIX_PROG_STRIPPED/lighttpd" "$PREFIX_PROG/lighttpd"
 b_install "$PREFIX_PORTS_INSTALL/lighttpd" /usr/sbin
diff --git a/lua/build.sh b/lua/build.sh
index ba90e820..f903b8a1 100755
--- a/lua/build.sh
+++ b/lua/build.sh
@@ -6,21 +6,18 @@ LUA=lua-5.3.5
 PKG_URL="https://www.lua.org/ftp/${LUA}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${LUA}.tar.gz"
 
-b_log "Building lua"
-PREFIX_LUA="${PREFIX_PROJECT}/phoenix-rtos-ports/lua"
-PREFIX_LUA_BUILD="${PREFIX_BUILD}/lua"
-PREFIX_LUA_SRC="${PREFIX_LUA_BUILD}/${LUA}"
+PREFIX_LUA_SRC="${PREFIX_PORT_BUILD}/${LUA}"
 
 
-mkdir -p "$PREFIX_LUA_BUILD"
-if [ ! -f "$PREFIX_LUA/${LUA}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_LUA}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_LUA}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD"
+if [ ! -f "$PREFIX_PORT/${LUA}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
 if [ ! -d "$PREFIX_LUA_SRC" ]; then
-	tar zxf "$PREFIX_LUA/${LUA}.tar.gz" -C "$PREFIX_LUA_BUILD"
-	cp "$PREFIX_LUA/Makefile" "$PREFIX_LUA_SRC/src/"
+	tar zxf "$PREFIX_PORT/${LUA}.tar.gz" -C "$PREFIX_PORT_BUILD"
+	cp "$PREFIX_PORT/Makefile" "$PREFIX_LUA_SRC/src/"
 fi
 
 # FIXME: no out-of-tree building
diff --git a/lzo/build.sh b/lzo/build.sh
index a1ffa65f..5566f37f 100755
--- a/lzo/build.sh
+++ b/lzo/build.sh
@@ -6,28 +6,25 @@ LZO=lzo-2.10
 PKG_URL="http://www.oberhumer.com/opensource/lzo/download/${LZO}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${LZO}.tar.gz"
 
-b_log "Building lzo"
-PREFIX_LZO="${PREFIX_PROJECT}/phoenix-rtos-ports/lzo"
-PREFIX_LZO_BUILD="${PREFIX_BUILD}/lzo"
-PREFIX_LZO_SRC="${PREFIX_LZO_BUILD}/${LZO}"
+PREFIX_LZO_SRC="${PREFIX_PORT_BUILD}/${LZO}"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_LZO_BUILD"
-if [ ! -f "$PREFIX_LZO/${LZO}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_LZO}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_LZO}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD"
+if [ ! -f "$PREFIX_PORT/${LZO}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_LZO_SRC" ] || tar zxf "$PREFIX_LZO/${LZO}.tar.gz" -C "$PREFIX_LZO_BUILD"
+[ -d "$PREFIX_LZO_SRC" ] || tar zxf "$PREFIX_PORT/${LZO}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Configure
 #
-if [ ! -f "$PREFIX_LZO_BUILD/config.h" ]; then
-	 ( cd "$PREFIX_LZO_BUILD" && "$PREFIX_LZO_SRC/configure" --prefix="$PREFIX_LZO_BUILD" --exec-prefix="$PREFIX_LZO_BUILD" --libdir="$PREFIX_A" --includedir="$PREFIX_H" \
+if [ ! -f "$PREFIX_PORT_BUILD/config.h" ]; then
+	 ( cd "$PREFIX_PORT_BUILD" && "$PREFIX_LZO_SRC/configure" --prefix="$PREFIX_PORT_BUILD" --exec-prefix="$PREFIX_PORT_BUILD" --libdir="$PREFIX_A" --includedir="$PREFIX_H" \
 		 --host="${HOST}"  CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" )
 fi
 
-make -C "$PREFIX_LZO_BUILD" install
+make -C "$PREFIX_PORT_BUILD" install
diff --git a/mbedtls/build.sh b/mbedtls/build.sh
index aa4e0c8c..896aba8b 100755
--- a/mbedtls/build.sh
+++ b/mbedtls/build.sh
@@ -8,32 +8,29 @@ MBEDTLS="mbedtls-${MBEDTLS_VER}"
 PKG_URL="https://github.com/Mbed-TLS/mbedtls/archive/v${MBEDTLS_VER}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${MBEDTLS}.tar.gz"
 
-PREFIX_MBEDTLS="${PREFIX_PROJECT}/phoenix-rtos-ports/mbedtls"
-PREFIX_MBEDTLS_BUILD="${PREFIX_BUILD}/mbedtls"
-PREFIX_MBEDTLS_SRC="${PREFIX_MBEDTLS_BUILD}/${MBEDTLS}"
-PREFIX_MBEDTLS_PATCHES="${PREFIX_MBEDTLS}/patches"
-PREFIX_MBEDTLS_MARKERS="${PREFIX_MBEDTLS_BUILD}/markers/"
-PREFIX_MBEDTLS_DESTDIR="${PREFIX_MBEDTLS_BUILD}/root/"
+PREFIX_MBEDTLS_SRC="${PREFIX_PORT_BUILD}/${MBEDTLS}"
+PREFIX_MBEDTLS_PATCHES="${PREFIX_PORT}/patches"
+PREFIX_MBEDTLS_MARKERS="${PREFIX_PORT_BUILD}/markers/"
+PREFIX_MBEDTLS_DESTDIR="${PREFIX_PORT_BUILD}/root/"
 PREFIX_MBEDTLS_TESTS="${PREFIX_MBEDTLS_SRC}/tests"
-b_log "Building mbedtls"
 
 # Download and unpack
-mkdir -p "${PREFIX_MBEDTLS_BUILD}" "${PREFIX_MBEDTLS_MARKERS}"
-if ! [ -f "${PREFIX_MBEDTLS}/${MBEDTLS}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -O "${PREFIX_MBEDTLS}/${MBEDTLS}.tar.gz" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_MBEDTLS}" --no-check-certificate
+mkdir -p "${PREFIX_PORT_BUILD}" "${PREFIX_MBEDTLS_MARKERS}"
+if ! [ -f "${PREFIX_PORT}/${MBEDTLS}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -O "${PREFIX_PORT}/${MBEDTLS}.tar.gz" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
 
 if ! [ -d "${PREFIX_MBEDTLS_SRC}" ]; then
-	tar xf "${PREFIX_MBEDTLS}/${MBEDTLS}.tar.gz" -C "${PREFIX_MBEDTLS_BUILD}"
+	tar xf "${PREFIX_PORT}/${MBEDTLS}.tar.gz" -C "${PREFIX_PORT_BUILD}"
 fi
 
 # Apply patches
 for patchfile in "${PREFIX_MBEDTLS_PATCHES}"/*.patch; do
 	if ! [ -f "${PREFIX_MBEDTLS_MARKERS}/$(basename "${patchfile}").applied" ]; then
 		echo "applying patch: ${patchfile}"
-		patch -d "${PREFIX_MBEDTLS_BUILD}" -p0 -i "${patchfile}" && touch "${PREFIX_MBEDTLS_MARKERS}/$(basename "${patchfile}").applied"
+		patch -d "${PREFIX_PORT_BUILD}" -p0 -i "${patchfile}" && touch "${PREFIX_MBEDTLS_MARKERS}/$(basename "${patchfile}").applied"
 	fi
 done
 
@@ -41,11 +38,11 @@ done
 export phoenix=1
 
 # Build mbedtls without tests
-(cd "${PREFIX_MBEDTLS_BUILD}/${MBEDTLS}" && make install no_test DESTDIR="$PREFIX_MBEDTLS_DESTDIR")
+(cd "${PREFIX_PORT_BUILD}/${MBEDTLS}" && make install no_test DESTDIR="$PREFIX_MBEDTLS_DESTDIR")
 
 # Build and install tests if needed
 if [ "${LONG_TEST}" = "y" ]; then
-	(cd "${PREFIX_MBEDTLS_BUILD}/${MBEDTLS}" && make tests)
+	(cd "${PREFIX_PORT_BUILD}/${MBEDTLS}" && make tests)
 
 	mkdir -p "${PREFIX_FS}/root/mbedtls_test_configs/"
 
diff --git a/micropython/build.sh b/micropython/build.sh
index a059052e..0bba2f82 100755
--- a/micropython/build.sh
+++ b/micropython/build.sh
@@ -7,11 +7,9 @@ UPYTH="micropython-${UPYTH_VER}"
 PKG_URL="https://github.com/micropython/micropython/releases/download/v${UPYTH_VER}/${UPYTH}.tar.xz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${UPYTH}.tar.xz"
 
-PREFIX_UPYTH="${PREFIX_PROJECT}/phoenix-rtos-ports/micropython"
-PREFIX_UPYTH_BUILD="${PREFIX_BUILD}/micropython"
-PREFIX_UPYTH_SRC=${PREFIX_UPYTH_BUILD}/${UPYTH}
-PREFIX_UPYTH_CONFIG="${PREFIX_UPYTH}/${UPYTH}-config/"
-PREFIX_UPYTH_MARKERS="$PREFIX_UPYTH_BUILD/markers/"
+PREFIX_UPYTH_SRC=${PREFIX_PORT_BUILD}/${UPYTH}
+PREFIX_UPYTH_CONFIG="${PREFIX_PORT}/${UPYTH}-config/"
+PREFIX_UPYTH_MARKERS="$PREFIX_PORT_BUILD/markers/"
 
 # Prefixes for micropython tests
 PREFIX_UPYTH_TESTS_SRC="${PREFIX_UPYTH_SRC}/tests"
@@ -20,18 +18,16 @@ PREFIX_UPYTH_TESTS_DES="${PREFIX_ROOTFS}/usr/test/micropython"
 # Directories in micropython test/ directory from which tests are sourced
 UPYTH_TESTS_DIRS="basics micropython float import io misc unicode extmod unix cmdline"
 
-b_log "Building micropython"
-
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_UPYTH_BUILD" "$PREFIX_UPYTH_MARKERS"
-if [ ! -f "$PREFIX_UPYTH/${UPYTH}.tar.xz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_UPYTH}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_UPYTH}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_UPYTH_MARKERS"
+if [ ! -f "$PREFIX_PORT/${UPYTH}.tar.xz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "${PREFIX_UPYTH_SRC}" ] || tar xf "$PREFIX_UPYTH/${UPYTH}.tar.xz" -C "$PREFIX_UPYTH_BUILD"
+[ -d "${PREFIX_UPYTH_SRC}" ] || tar xf "$PREFIX_PORT/${UPYTH}.tar.xz" -C "$PREFIX_PORT_BUILD"
 
 
 #
@@ -86,7 +82,7 @@ export CFLAGS=""
 #
 # Build and install micropython binary
 #
-(cd "${PREFIX_UPYTH_SRC}/mpy-cross" && make all BUILD="${PREFIX_UPYTH_BUILD}" CROSS_COMPILE="${CROSS}")
+(cd "${PREFIX_UPYTH_SRC}/mpy-cross" && make all BUILD="${PREFIX_PORT_BUILD}" CROSS_COMPILE="${CROSS}")
 (cd "${PREFIX_UPYTH_SRC}/ports/unix" && make all CROSS_COMPILE="${CROSS}")
 
 cp -a "${PREFIX_UPYTH_SRC}/ports/unix/micropython" "$PREFIX_PROG_STRIPPED"
@@ -109,5 +105,5 @@ if [ "$LONG_TEST" = "y" ]; then
 	done
 
 	# Copying expected outputs for tests, which differs from these generated by CPython
-	cp -r "$PREFIX_UPYTH/exp_prefabs/." "$PREFIX_UPYTH_TESTS_DES"
+	cp -r "$PREFIX_PORT/exp_prefabs/." "$PREFIX_UPYTH_TESTS_DES"
 fi
diff --git a/openiked/build.sh b/openiked/build.sh
index 8efac44f..c3cc52d7 100755
--- a/openiked/build.sh
+++ b/openiked/build.sh
@@ -7,31 +7,28 @@ OPENIKED="openiked-portable-${OPENIKED_VER}"
 PKG_URL="https://github.com/openiked/openiked-portable/archive/refs/tags/v${OPENIKED_VER}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${OPENIKED}.tar.gz"
 
-b_log "Building openiked"
-PREFIX_OPENIKED="${PREFIX_PROJECT}/phoenix-rtos-ports/openiked"
-PREFIX_OPENIKED_BUILD=${PREFIX_BUILD}/openiked
-PREFIX_OPENIKED_SRC="${PREFIX_OPENIKED_BUILD}/${OPENIKED}"
-PREFIX_OPENIKED_MARKERS="${PREFIX_OPENIKED_BUILD}/markers"
-PREFIX_OPENIKED_INSTALL="${PREFIX_OPENIKED_BUILD}/install"
+PREFIX_OPENIKED_SRC="${PREFIX_PORT_BUILD}/${OPENIKED}"
+PREFIX_OPENIKED_MARKERS="${PREFIX_PORT_BUILD}/markers"
+PREFIX_OPENIKED_INSTALL="${PREFIX_PORT_BUILD}/install"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_OPENIKED_BUILD"
+mkdir -p "$PREFIX_PORT_BUILD"
 
-if [ ! -f "${PREFIX_OPENIKED}/${OPENIKED}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -O "${PREFIX_OPENIKED}/${OPENIKED}.tar.gz" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_OPENIKED}" --no-check-certificate
+if [ ! -f "${PREFIX_PORT}/${OPENIKED}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -O "${PREFIX_PORT}/${OPENIKED}.tar.gz" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_OPENIKED_SRC" ] || tar zxf "${PREFIX_OPENIKED}/${OPENIKED}.tar.gz" -C "$PREFIX_OPENIKED_BUILD"
+[ -d "$PREFIX_OPENIKED_SRC" ] || tar zxf "${PREFIX_PORT}/${OPENIKED}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
 mkdir -p "$PREFIX_OPENIKED_MARKERS"
 
-for patchfile in "${PREFIX_OPENIKED}"/patches/*.patch; do
+for patchfile in "${PREFIX_PORT}"/patches/*.patch; do
     if [ ! -f "${PREFIX_OPENIKED_MARKERS}/$(basename "$patchfile").applied" ]; then
         echo "applying patch: $patchfile"
         patch -d "$PREFIX_OPENIKED_SRC" -p1 < "$patchfile"
diff --git a/openssl/build.sh b/openssl/build.sh
index c1eb1f7b..57a0f79c 100755
--- a/openssl/build.sh
+++ b/openssl/build.sh
@@ -6,28 +6,25 @@ OPENSSL=openssl-1.1.1a
 PKG_URL="https://www.openssl.org/source/${OPENSSL}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${OPENSSL}.tar.gz"
 
-b_log "Building openssl"
-PREFIX_OPENSSL="${PREFIX_PROJECT}/phoenix-rtos-ports/openssl"
-PREFIX_OPENSSL_BUILD="${PREFIX_BUILD}/openssl"
-PREFIX_OPENSSL_SRC="${PREFIX_OPENSSL_BUILD}/${OPENSSL}"
-PREFIX_OPENSSL_INSTALL="$PREFIX_OPENSSL_BUILD/install"
-PREFIX_OPENSSL_MARKERS="$PREFIX_OPENSSL_BUILD/markers/"
+PREFIX_OPENSSL_SRC="${PREFIX_PORT_BUILD}/${OPENSSL}"
+PREFIX_OPENSSL_INSTALL="$PREFIX_PORT_BUILD/install"
+PREFIX_OPENSSL_MARKERS="$PREFIX_PORT_BUILD/markers/"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_OPENSSL_BUILD" "$PREFIX_OPENSSL_INSTALL" "$PREFIX_OPENSSL_MARKERS"
-if [ ! -f "$PREFIX_OPENSSL/${OPENSSL}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_OPENSSL}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_OPENSSL}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_OPENSSL_INSTALL" "$PREFIX_OPENSSL_MARKERS"
+if [ ! -f "$PREFIX_PORT/${OPENSSL}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_OPENSSL_SRC" ] || tar zxf "$PREFIX_OPENSSL/${OPENSSL}.tar.gz" -C "$PREFIX_OPENSSL_BUILD"
+[ -d "$PREFIX_OPENSSL_SRC" ] || tar zxf "$PREFIX_PORT/${OPENSSL}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
-for patchfile in "$PREFIX_OPENSSL"/*.patch; do
+for patchfile in "$PREFIX_PORT"/*.patch; do
 	if [ ! -f "$PREFIX_OPENSSL_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_OPENSSL_SRC" -p1 < "$patchfile"
@@ -38,17 +35,17 @@ done
 #
 # Configure
 #
-if [ ! -f "${PREFIX_OPENSSL_BUILD}/Makefile" ]; then
-	cp "$PREFIX_OPENSSL/30-phoenix.conf" "$PREFIX_OPENSSL_SRC/Configurations/"
-	(cd "${PREFIX_OPENSSL_BUILD}" && "${PREFIX_OPENSSL_SRC}/Configure" "phoenix-${TARGET_FAMILY}-${TARGET_SUBFAMILY}" --prefix="$PREFIX_OPENSSL_INSTALL" --openssldir="/etc/ssl")
+if [ ! -f "${PREFIX_PORT_BUILD}/Makefile" ]; then
+	cp "$PREFIX_PORT/30-phoenix.conf" "$PREFIX_OPENSSL_SRC/Configurations/"
+	(cd "${PREFIX_PORT_BUILD}" && "${PREFIX_OPENSSL_SRC}/Configure" "phoenix-${TARGET_FAMILY}-${TARGET_SUBFAMILY}" --prefix="$PREFIX_OPENSSL_INSTALL" --openssldir="/etc/ssl")
 fi
 
 
 #
 # Make
 #
-make -C "$PREFIX_OPENSSL_BUILD" all
-make -C "$PREFIX_OPENSSL_BUILD" install_sw
+make -C "$PREFIX_PORT_BUILD" all
+make -C "$PREFIX_PORT_BUILD" install_sw
 
 cp -a "$PREFIX_OPENSSL_INSTALL/include/openssl" "$PREFIX_H"
 cp -a "$PREFIX_OPENSSL_INSTALL/lib/libcrypto.a" "$PREFIX_A"
diff --git a/openvpn/build.sh b/openvpn/build.sh
index 7e2de398..13a13e1c 100755
--- a/openvpn/build.sh
+++ b/openvpn/build.sh
@@ -6,27 +6,24 @@ OPENVPN=openvpn-2.4.7
 PKG_URL="https://swupdate.openvpn.org/community/releases/${OPENVPN}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${OPENVPN}.tar.gz"
 
-b_log "Building openvpn"
-PREFIX_OPENVPN="${PREFIX_PROJECT}/phoenix-rtos-ports/openvpn"
-PREFIX_OPENVPN_BUILD="${PREFIX_BUILD}/openvpn"
-PREFIX_OPENVPN_SRC="${PREFIX_OPENVPN_BUILD}/${OPENVPN}"
-PREFIX_OPENVPN_MARKERS="${PREFIX_OPENVPN_BUILD}/markers"
+PREFIX_OPENVPN_SRC="${PREFIX_PORT_BUILD}/${OPENVPN}"
+PREFIX_OPENVPN_MARKERS="${PREFIX_PORT_BUILD}/markers"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_OPENVPN_BUILD" "$PREFIX_OPENVPN_MARKERS"
-if [ ! -f "$PREFIX_OPENVPN/${OPENVPN}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_OPENVPN}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_OPENVPN}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_OPENVPN_MARKERS"
+if [ ! -f "$PREFIX_PORT/${OPENVPN}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_OPENVPN_SRC" ] || tar zxf "$PREFIX_OPENVPN/${OPENVPN}.tar.gz" -C "$PREFIX_OPENVPN_BUILD"
+[ -d "$PREFIX_OPENVPN_SRC" ] || tar zxf "$PREFIX_PORT/${OPENVPN}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 #  Apply patches
 #
-for patchfile in "$PREFIX_OPENVPN"/*.patch; do
+for patchfile in "$PREFIX_PORT"/*.patch; do
 	if [ ! -f "$PREFIX_OPENVPN_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_OPENVPN_SRC" -p1 < "$patchfile"
@@ -37,17 +34,17 @@ done
 #
 # Configure
 #
-if [ ! -f "$PREFIX_OPENVPN_BUILD/config.h" ]; then
+if [ ! -f "$PREFIX_PORT_BUILD/config.h" ]; then
 	OPENVPN_CFLAGS="-std=gnu99 -I${PREFIX_H}"
 	(cd "$PREFIX_OPENVPN_SRC" && autoreconf -i -v -f)
-	(cd "$PREFIX_OPENVPN_BUILD" && PKG_CONFIG="" "$PREFIX_OPENVPN_SRC/configure" CFLAGS="$CFLAGS $OPENVPN_CFLAGS" LDFLAGS="$LDFLAGS" --host="${HOST}" --sbindir="$PREFIX_PROG")
+	(cd "$PREFIX_PORT_BUILD" && PKG_CONFIG="" "$PREFIX_OPENVPN_SRC/configure" CFLAGS="$CFLAGS $OPENVPN_CFLAGS" LDFLAGS="$LDFLAGS" --host="${HOST}" --sbindir="$PREFIX_PROG")
 fi
 
 #
 # Make
 #
-make -C "$PREFIX_OPENVPN_BUILD"
-make -C "$PREFIX_OPENVPN_BUILD" install-exec
+make -C "$PREFIX_PORT_BUILD"
+make -C "$PREFIX_PORT_BUILD" install-exec
 
 $STRIP -o "$PREFIX_PROG_STRIPPED/openvpn" "$PREFIX_PROG/openvpn"
 b_install "$PREFIX_PORTS_INSTALL/openvpn" /sbin/
diff --git a/pcre/build.sh b/pcre/build.sh
index 34d5a660..1443aab9 100755
--- a/pcre/build.sh
+++ b/pcre/build.sh
@@ -6,33 +6,30 @@ PCRE=pcre-8.42
 PKG_URL="http://ftp.exim.org/pub/pcre/${PCRE}.tar.bz2"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${PCRE}.tar.bz2"
 
-b_log "Building pcre"
-PREFIX_PCRE="${PREFIX_PROJECT}/phoenix-rtos-ports/pcre"
-PREFIX_PCRE_BUILD="${PREFIX_BUILD}/pcre"
-PREFIX_PCRE_SRC="${PREFIX_PCRE_BUILD}/${PCRE}"
+PREFIX_PCRE_SRC="${PREFIX_PORT_BUILD}/${PCRE}"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_PCRE_BUILD"
-if [ ! -f "$PREFIX_PCRE/${PCRE}.tar.bz2" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_PCRE}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_PCRE}" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD"
+if [ ! -f "$PREFIX_PORT/${PCRE}.tar.bz2" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_PCRE_SRC" ] || tar jxf "$PREFIX_PCRE/${PCRE}.tar.bz2" -C "$PREFIX_PCRE_BUILD"
+[ -d "$PREFIX_PCRE_SRC" ] || tar jxf "$PREFIX_PORT/${PCRE}.tar.bz2" -C "$PREFIX_PORT_BUILD"
 
 
 #
 # Configure
 #
-if [ ! -f "${PREFIX_PCRE_BUILD}/config.h" ]; then
-	( cd "${PREFIX_PCRE_BUILD}" && "${PREFIX_PCRE_SRC}/configure" CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" ARFLAGS="-r" --enable-static --disable-shared --host="$HOST" \
-		--disable-cpp --prefix="${PREFIX_PCRE_BUILD}" --libdir="${PREFIX_A}"  \
+if [ ! -f "${PREFIX_PORT_BUILD}/config.h" ]; then
+	( cd "${PREFIX_PORT_BUILD}" && "${PREFIX_PCRE_SRC}/configure" CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" ARFLAGS="-r" --enable-static --disable-shared --host="$HOST" \
+		--disable-cpp --prefix="${PREFIX_PORT_BUILD}" --libdir="${PREFIX_A}"  \
 		--includedir="${PREFIX_H}" )
 fi
 
 #
 # Make
 #
-make -C "$PREFIX_PCRE_BUILD" install
+make -C "$PREFIX_PORT_BUILD" install
diff --git a/picocom/build.sh b/picocom/build.sh
index 57b15ba2..3fe3fc47 100755
--- a/picocom/build.sh
+++ b/picocom/build.sh
@@ -2,35 +2,31 @@
 
 set -e
 
-b_log "Building picocom"
-
 PCOM_VER="3.1"
 PCOM="picocom-${PCOM_VER}"
 PKG_URL="https://github.com/npat-efault/picocom/archive/refs/tags/${PCOM_VER}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${PCOM}.tar.gz"
 
-PREFIX_PCOM="${PREFIX_PROJECT}/phoenix-rtos-ports/picocom"
-PREFIX_PCOM_BUILD="${PREFIX_BUILD}/picocom"
-PREFIX_PCOM_SRC=${PREFIX_PCOM_BUILD}/${PCOM}
-PREFIX_PCOM_MARKERS="$PREFIX_PCOM_BUILD/markers"
+PREFIX_PCOM_SRC=${PREFIX_PORT_BUILD}/${PCOM}
+PREFIX_PCOM_MARKERS="$PREFIX_PORT_BUILD/markers"
 
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_PCOM_BUILD" "$PREFIX_PCOM_MARKERS"
-if [ ! -f "$PREFIX_PCOM/${PCOM}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_PCOM}" -O "$PREFIX_PCOM/${PCOM}.tar.gz" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_PCOM}" -O "$PREFIX_PCOM/${PCOM}.tar.gz" --no-check-certificate
+mkdir -p "$PREFIX_PORT_BUILD" "$PREFIX_PCOM_MARKERS"
+if [ ! -f "$PREFIX_PORT/${PCOM}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" -O "$PREFIX_PORT/${PCOM}.tar.gz" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" -O "$PREFIX_PORT/${PCOM}.tar.gz" --no-check-certificate
 	fi
 fi
-[ -d "${PREFIX_PCOM_SRC}" ] || tar xf "$PREFIX_PCOM/${PCOM}.tar.gz" -C "$PREFIX_PCOM_BUILD"
+[ -d "${PREFIX_PCOM_SRC}" ] || tar xf "$PREFIX_PORT/${PCOM}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 
 #
 # Apply patches and copy files
 #
-for patchfile in "$PREFIX_PCOM"/*.patch; do
+for patchfile in "$PREFIX_PORT"/*.patch; do
 	if [ ! -f "$PREFIX_PCOM_MARKERS/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_PCOM_SRC" -p1 < "$patchfile"
diff --git a/sscep/build.sh b/sscep/build.sh
index 18b29939..864d2f61 100755
--- a/sscep/build.sh
+++ b/sscep/build.sh
@@ -7,31 +7,28 @@ SSCEP="sscep-${SSCEP_VER}"
 PKG_URL="https://github.com/certnanny/sscep/archive/refs/tags/v${SSCEP_VER}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${SSCEP}.tar.gz"
 
-b_log "Building sscep"
-PREFIX_SSCEP=${PREFIX_PROJECT}/phoenix-rtos-ports/sscep
-PREFIX_SSCEP_BUILD=${PREFIX_BUILD}/sscep
-PREFIX_SSCEP_SRC="${PREFIX_SSCEP_BUILD}/${SSCEP}"
-PREFIX_SSCEP_MARKERS="${PREFIX_SSCEP_BUILD}/markers"
-PREFIX_SSCEP_INSTALL="${PREFIX_SSCEP_BUILD}/install"
+PREFIX_SSCEP_SRC="${PREFIX_PORT_BUILD}/${SSCEP}"
+PREFIX_SSCEP_MARKERS="${PREFIX_PORT_BUILD}/markers"
+PREFIX_SSCEP_INSTALL="${PREFIX_PORT_BUILD}/install"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_SSCEP_BUILD"
+mkdir -p "$PREFIX_PORT_BUILD"
 
-if [ ! -f "$PREFIX_SSCEP/${SSCEP}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -O "${PREFIX_SSCEP}/${SSCEP}.tar.gz" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_SSCEP}" --no-check-certificate
+if [ ! -f "$PREFIX_PORT/${SSCEP}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -O "${PREFIX_PORT}/${SSCEP}.tar.gz" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_SSCEP_SRC" ] || tar zxf "$PREFIX_SSCEP/${SSCEP}.tar.gz" -C "$PREFIX_SSCEP_BUILD"
+[ -d "$PREFIX_SSCEP_SRC" ] || tar zxf "$PREFIX_PORT/${SSCEP}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
 mkdir -p "$PREFIX_SSCEP_MARKERS"
 
-for patchfile in "${PREFIX_SSCEP}"/patches/*.patch; do
+for patchfile in "${PREFIX_PORT}"/patches/*.patch; do
 	if [ ! -f "${PREFIX_SSCEP_MARKERS}/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_SSCEP_SRC" -p1 < "$patchfile"
diff --git a/wpa_supplicant/build.sh b/wpa_supplicant/build.sh
index 60416bbe..9da8d414 100755
--- a/wpa_supplicant/build.sh
+++ b/wpa_supplicant/build.sh
@@ -6,31 +6,28 @@ WPA_SUPPLICANT=wpa_supplicant-2.9
 PKG_URL="https://w1.fi/releases/${WPA_SUPPLICANT}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${WPA_SUPPLICANT}.tar.gz"
 
-b_log "Building wpa_supplicant"
-PREFIX_WPA_SUPPLICANT="${PREFIX_PROJECT}/phoenix-rtos-ports/wpa_supplicant"
-PREFIX_WPA_SUPPLICANT_BUILD="${PREFIX_BUILD}/wpa_supplicant"
 PREFIX_WPA_SUPPLICANT_SRC="${PREFIX_BUILD}/wpa_supplicant/${WPA_SUPPLICANT}"
-PREFIX_WPA_SUPPLICANT_MARKERS="${PREFIX_WPA_SUPPLICANT_BUILD}/markers"
-PREFIX_WPA_SUPPLICANT_INSTALL="${PREFIX_WPA_SUPPLICANT_BUILD}/install"
+PREFIX_WPA_SUPPLICANT_MARKERS="${PREFIX_PORT_BUILD}/markers"
+PREFIX_WPA_SUPPLICANT_INSTALL="${PREFIX_PORT_BUILD}/install"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_WPA_SUPPLICANT_BUILD"
+mkdir -p "$PREFIX_PORT_BUILD"
 
-if [ ! -f "$PREFIX_WPA_SUPPLICANT/${WPA_SUPPLICANT}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_WPA_SUPPLICANT}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_WPA_SUPPLICANT}" --no-check-certificate
+if [ ! -f "$PREFIX_PORT/${WPA_SUPPLICANT}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_WPA_SUPPLICANT_SRC" ] || tar zxf "${PREFIX_WPA_SUPPLICANT}/${WPA_SUPPLICANT}.tar.gz" -C "$PREFIX_WPA_SUPPLICANT_BUILD"
+[ -d "$PREFIX_WPA_SUPPLICANT_SRC" ] || tar zxf "${PREFIX_PORT}/${WPA_SUPPLICANT}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
 mkdir -p "$PREFIX_WPA_SUPPLICANT_MARKERS"
 
-for patchfile in "${PREFIX_WPA_SUPPLICANT}"/patches/*.patch; do
+for patchfile in "${PREFIX_PORT}"/patches/*.patch; do
 	if [ ! -f "${PREFIX_WPA_SUPPLICANT_MARKERS}/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_WPA_SUPPLICANT_SRC" -p1 < "$patchfile"
@@ -44,7 +41,7 @@ done
 mkdir -p "$PREFIX_WPA_SUPPLICANT_INSTALL"
 
 pushd "${PREFIX_WPA_SUPPLICANT_SRC}/wpa_supplicant"
-cp -a "$PREFIX_WPA_SUPPLICANT/config" .config
+cp -a "$PREFIX_PORT/config" .config
 make install DESTDIR="$PREFIX_WPA_SUPPLICANT_INSTALL" LIBDIR="/lib" INCDIR="/include" BINDIR="/bin"
 popd
 
diff --git a/zlib/build.sh b/zlib/build.sh
index 7dd0f911..004a52df 100755
--- a/zlib/build.sh
+++ b/zlib/build.sh
@@ -6,30 +6,27 @@ ZLIB=zlib-1.2.11
 PKG_URL="https://zlib.net/fossils/${ZLIB}.tar.gz"
 PKG_MIRROR_URL="https://files.phoesys.com/ports/${ZLIB}.tar.gz"
 
-b_log "Building zlib"
-PREFIX_ZLIB="${PREFIX_PROJECT}/phoenix-rtos-ports/zlib"
-PREFIX_ZLIB_BUILD="${PREFIX_BUILD}/zlib"
-PREFIX_ZLIB_SRC="${PREFIX_ZLIB_BUILD}/${ZLIB}"
-PREFIX_ZLIB_MARKERS="${PREFIX_ZLIB_BUILD}/markers"
+PREFIX_ZLIB_SRC="${PREFIX_PORT_BUILD}/${ZLIB}"
+PREFIX_ZLIB_MARKERS="${PREFIX_PORT_BUILD}/markers"
 
 #
 # Download and unpack
 #
-mkdir -p "$PREFIX_ZLIB_BUILD"
+mkdir -p "$PREFIX_PORT_BUILD"
 
-if [ ! -f "$PREFIX_ZLIB/${ZLIB}.tar.gz" ]; then
-	if ! wget "$PKG_URL" -P "${PREFIX_ZLIB}" --no-check-certificate; then
-		wget "$PKG_MIRROR_URL" -P "${PREFIX_ZLIB}" --no-check-certificate
+if [ ! -f "$PREFIX_PORT/${ZLIB}.tar.gz" ]; then
+	if ! wget "$PKG_URL" -P "${PREFIX_PORT}" --no-check-certificate; then
+		wget "$PKG_MIRROR_URL" -P "${PREFIX_PORT}" --no-check-certificate
 	fi
 fi
-[ -d "$PREFIX_ZLIB_SRC" ] || tar zxf "${PREFIX_ZLIB}/${ZLIB}.tar.gz" -C "$PREFIX_ZLIB_BUILD"
+[ -d "$PREFIX_ZLIB_SRC" ] || tar zxf "${PREFIX_PORT}/${ZLIB}.tar.gz" -C "$PREFIX_PORT_BUILD"
 
 #
 # Apply patches
 #
 mkdir -p "$PREFIX_ZLIB_MARKERS"
 
-for patchfile in "${PREFIX_ZLIB}"/patches/*.patch; do
+for patchfile in "${PREFIX_PORT}"/patches/*.patch; do
 	if [ ! -f "${PREFIX_ZLIB_MARKERS}/$(basename "$patchfile").applied" ]; then
 		echo "applying patch: $patchfile"
 		patch -d "$PREFIX_ZLIB_SRC" -p1 < "$patchfile"