make.sh

   1 #!/bin/bash
   2 ############################################################################
   3 #                                                                          #
   4 # This file is part of the IPFire Firewall.                                #
   5 #                                                                          #
   6 # IPFire is free software; you can redistribute it and/or modify           #
   7 # it under the terms of the GNU General Public License as published by     #
   8 # the Free Software Foundation; either version 2 of the License, or        #
   9 # (at your option) any later version.                                      #
  10 #                                                                          #
  11 # IPFire is distributed in the hope that it will be useful,                #
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of           #
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
  14 # GNU General Public License for more details.                             #
  15 #                                                                          #
  16 # You should have received a copy of the GNU General Public License        #
  17 # along with IPFire; if not, write to the Free Software                    #
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA #
  19 #                                                                          #
  20 # Copyright (C) 2007-2022 IPFire Team <info@ipfire.org>.                   #
  21 #                                                                          #
  22 ############################################################################
  23 #
  24
  25 NAME="IPFire"                                                   # Software name
  26 SNAME="ipfire"                                                  # Short name
  27 # If you update the version don't forget to update backupiso and add it to core update
  28 VERSION="2.27"                                                  # Version number
  29 CORE="165"                                                      # Core Level (Filename)
  30 SLOGAN="www.ipfire.org"                                         # Software slogan
  31 CONFIG_ROOT=/var/ipfire                                         # Configuration rootdir
  32 MAX_RETRIES=1                                                   # prefetch/check loop
  33 BUILD_IMAGES=1                                                  # Flash and Xen Downloader
  34 KVER=`grep --max-count=1 VER lfs/linux | awk '{ print $3 }'`
  35
  36 # Information from Git
  37 GIT_BRANCH="$(git rev-parse --abbrev-ref HEAD)"                 # Git Branch
  38 GIT_TAG="$(git tag | tail -1)"                                  # Git Tag
  39 GIT_LASTCOMMIT="$(git rev-parse --verify HEAD)"                 # Last commit
  40
  41 TOOLCHAINVER=20220203
  42
  43 # use multicore and max compression
  44 ZSTD_OPT="-T0 --ultra -22"
  45
  46 ###############################################################################
  47 #
  48 # Beautifying variables & presentation & input output interface
  49 #
  50 ###############################################################################
  51
  52 # Remember if the shell is interactive or not
  53 if [ -t 0 ] && [ -t 1 ]; then
  54         INTERACTIVE=true
  55 else
  56         INTERACTIVE=false
  57 fi
  58
  59 # Sets or adjusts pretty formatting variables
  60 resize_terminal() {
  61         ## Screen Dimentions
  62         # Find current screen size
  63         COLUMNS=$(tput cols)
  64
  65         # When using remote connections, such as a serial port, stty size returns 0
  66         if ! ${INTERACTIVE} || [ "${COLUMNS}" = "0" ]; then
  67                 COLUMNS=80
  68         fi
  69
  70         # Measurements for positioning result messages
  71         OPTIONS_WIDTH=20
  72         TIME_WIDTH=12
  73         STATUS_WIDTH=8
  74         NAME_WIDTH=$(( COLUMNS - OPTIONS_WIDTH - TIME_WIDTH - STATUS_WIDTH ))
  75         LINE_WIDTH=$(( COLUMNS - STATUS_WIDTH ))
  76
  77         TIME_COL=$(( NAME_WIDTH + OPTIONS_WIDTH ))
  78         STATUS_COL=$(( TIME_COL + TIME_WIDTH ))
  79 }
  80
  81 # Initially setup terminal
  82 resize_terminal
  83
  84 # Call resize_terminal when terminal is being resized
  85 trap "resize_terminal" WINCH
  86
  87 # Define color for messages
  88 BOLD="\\033[1;39m"
  89 DONE="\\033[1;32m"
  90 SKIP="\\033[1;34m"
  91 WARN="\\033[1;35m"
  92 FAIL="\\033[1;31m"
  93 NORMAL="\\033[0;39m"
  94
  95 # New architecture variables
  96 HOST_ARCH="$(uname -m)"
  97
  98 PWD=$(pwd)
  99 BASENAME=$(basename $0)
 100
 101 # Debian specific settings
 102 if [ ! -e /etc/debian_version ]; then
 103         FULLPATH=`which $0`
 104 else
 105         if [ -x /usr/bin/realpath ]; then
 106                 FULLPATH=`/usr/bin/realpath $0`
 107         else
 108                 echo "ERROR: Need to do apt-get install realpath"
 109                 exit 1
 110         fi
 111 fi
 112
 113 # This is the directory where make.sh is in
 114 export BASEDIR=$(echo $FULLPATH | sed "s/\/$BASENAME//g")
 115
 116 LOGFILE=$BASEDIR/log/_build.preparation.log
 117 export LOGFILE
 118 DIR_CHK=$BASEDIR/cache/check
 119 mkdir $BASEDIR/log/ 2>/dev/null
 120
 121 system_processors() {
 122         getconf _NPROCESSORS_ONLN 2>/dev/null || echo "1"
 123 }
 124
 125 system_memory() {
 126         local key val unit
 127
 128         while read -r key val unit; do
 129                 case "${key}" in
 130                         MemTotal:*)
 131                                 # Convert to MB
 132                                 echo "$(( ${val} / 1024 ))"
 133                                 break
 134                                 ;;
 135                 esac
 136         done < /proc/meminfo
 137 }
 138
 139 configure_build() {
 140         local build_arch="${1}"
 141
 142         if [ "${build_arch}" = "default" ]; then
 143                 build_arch="$(configure_build_guess)"
 144         fi
 145
 146         case "${build_arch}" in
 147                 x86_64)
 148                         BUILDTARGET="${build_arch}-pc-linux-gnu"
 149                         CROSSTARGET="${build_arch}-cross-linux-gnu"
 150                         BUILD_PLATFORM="x86"
 151                         CFLAGS_ARCH="-m64 -mtune=generic -fstack-clash-protection -fcf-protection"
 152                         ;;
 153
 154                 aarch64)
 155                         BUILDTARGET="${build_arch}-pc-linux-gnu"
 156                         CROSSTARGET="${build_arch}-cross-linux-gnu"
 157                         BUILD_PLATFORM="arm"
 158                         CFLAGS_ARCH="-fstack-clash-protection"
 159                         ;;
 160
 161                 armv7hl)
 162                         BUILDTARGET="${build_arch}-pc-linux-gnueabi"
 163                         CROSSTARGET="${build_arch}-cross-linux-gnueabi"
 164                         BUILD_PLATFORM="arm"
 165                         CFLAGS_ARCH="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard"
 166                         ;;
 167
 168                 armv6l)
 169                         BUILDTARGET="${build_arch}-pc-linux-gnueabi"
 170                         CROSSTARGET="${build_arch}-cross-linux-gnueabi"
 171                         BUILD_PLATFORM="arm"
 172                         CFLAGS_ARCH="-march=armv6zk+fp -mfpu=vfp -mfloat-abi=softfp -fomit-frame-pointer"
 173                         ;;
 174
 175                 riscv64)
 176                         BUILDTARGET="${build_arch}-pc-linux-gnu"
 177                         CROSSTARGET="${build_arch}-cross-linux-gnu"
 178                         BUILD_PLATFORM="riscv"
 179                         CFLAGS_ARCH="-fstack-clash-protection"
 180                         ;;
 181
 182                 *)
 183                         exiterror "Cannot build for architure ${build_arch}"
 184                         ;;
 185         esac
 186
 187         # Check if the QEMU helper is available if needed.
 188         if qemu_is_required "${build_arch}"; then
 189                 local qemu_build_helper="$(qemu_find_build_helper_name "${build_arch}")"
 190
 191                 if [ -n "${qemu_build_helper}" ]; then
 192                         QEMU_TARGET_HELPER="${qemu_build_helper}"
 193                 else
 194                         exiterror "Could not find a binfmt_misc helper entry for ${build_arch}"
 195                 fi
 196         fi
 197
 198         BUILD_ARCH="${build_arch}"
 199         TOOLS_DIR="/tools_${BUILD_ARCH}"
 200
 201         # Enables hardening
 202         HARDENING_CFLAGS="-Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong"
 203
 204         CFLAGS="-O2 -pipe -Wall -fexceptions -fPIC ${CFLAGS_ARCH}"
 205         CXXFLAGS="${CFLAGS}"
 206
 207         RUSTFLAGS="-Copt-level=3 -Clink-arg=-Wl,-z,relro,-z,now -Ccodegen-units=1 --cap-lints=warn ${RUSTFLAGS_ARCH}"
 208
 209         # Determine parallelism
 210         # We assume that each process consumes about
 211         # 128MB of memory. Therefore we find out how
 212         # many processes fit into memory.
 213         local mem_max=$(( ${SYSTEM_MEMORY} / 128 ))
 214         local cpu_max=$(( ${SYSTEM_PROCESSORS} ))
 215
 216         local parallelism
 217         if [ ${mem_max} -lt ${cpu_max} ]; then
 218                 parallelism=${mem_max}
 219         else
 220                 parallelism=${cpu_max}
 221         fi
 222
 223         # Use this as default PARALLELISM
 224         DEFAULT_PARALLELISM="${parallelism}"
 225
 226         # Limit lauched ninja build jobs to computed parallel value.
 227         NINJAJOBS="${parallelism}"
 228
 229         # Compression parameters
 230         # We use mode 8 for reasonable memory usage when decompressing
 231         # but with overall good compression
 232         XZ_OPT="-8"
 233
 234         # We try to use as many cores as possible
 235         XZ_OPT="${XZ_OPT} -T0"
 236
 237         # We need to limit memory because XZ uses too much when running
 238         # in parallel and it isn't very smart in limiting itself.
 239         # We allow XZ to use up to 70% of all system memory.
 240         local xz_memory=$(( SYSTEM_MEMORY * 7 / 10 ))
 241
 242         # XZ memory cannot be larger than 2GB on 32 bit systems
 243         case "${build_arch}" in
 244                 armv*)
 245                         if [ ${xz_memory} -gt 2048 ]; then
 246                                 xz_memory=2048
 247                         fi
 248                         ;;
 249         esac
 250
 251         XZ_OPT="${XZ_OPT} --memory=${xz_memory}MiB"
 252 }
 253
 254 configure_build_guess() {
 255         case "${HOST_ARCH}" in
 256                 x86_64)
 257                         echo "x86_64"
 258                         ;;
 259
 260                 aarch64)
 261                         echo "aarch64"
 262                         ;;
 263
 264                 armv7*|armv6*)
 265                         echo "armv6l"
 266                         ;;
 267
 268                 riscv64)
 269                         echo "riscv64"
 270                         ;;
 271
 272                 *)
 273                         exiterror "Cannot guess build architecture"
 274                         ;;
 275         esac
 276 }
 277
 278 stdumount() {
 279         umount $BASEDIR/build/sys                       2>/dev/null;
 280         umount $BASEDIR/build/dev/shm           2>/dev/null;
 281         umount $BASEDIR/build/dev/pts           2>/dev/null;
 282         umount $BASEDIR/build/dev                       2>/dev/null;
 283         umount $BASEDIR/build/proc                      2>/dev/null;
 284         umount $BASEDIR/build/install/mnt               2>/dev/null;
 285         umount $BASEDIR/build/usr/src/cache     2>/dev/null;
 286         umount $BASEDIR/build/usr/src/ccache    2>/dev/null;
 287         umount $BASEDIR/build/usr/src/config    2>/dev/null;
 288         umount $BASEDIR/build/usr/src/doc               2>/dev/null;
 289         umount $BASEDIR/build/usr/src/html              2>/dev/null;
 290         umount $BASEDIR/build/usr/src/langs     2>/dev/null;
 291         umount $BASEDIR/build/usr/src/lfs               2>/dev/null;
 292         umount $BASEDIR/build/usr/src/log               2>/dev/null;
 293         umount $BASEDIR/build/usr/src/src               2>/dev/null;
 294         umount $BASEDIR/build/usr/src           2>/dev/null;
 295         umount $BASEDIR/build/tmp               2>/dev/null;
 296 }
 297
 298 format_runtime() {
 299         local seconds=${1}
 300
 301         if [ ${seconds} -ge 3600 ]; then
 302                 printf "%d:%02d:%02d\n" \
 303                         "$(( seconds / 3600 ))" \
 304                         "$(( seconds % 3600 / 60 ))" \
 305                         "$(( seconds % 3600 % 60 ))"
 306         elif [ ${seconds} -ge 60 ]; then
 307                 printf "%d:%02d\n" \
 308                         "$(( seconds / 60 ))" \
 309                         "$(( seconds % 60 ))"
 310         else
 311                 printf "%d\n" "${seconds}"
 312         fi
 313 }
 314
 315 print_line() {
 316         local line="$@"
 317
 318         printf "%-${LINE_WIDTH}s" "${line}"
 319 }
 320
 321 _print_line() {
 322         local status="${1}"
 323         shift
 324
 325         if ${INTERACTIVE}; then
 326                 printf "${!status}"
 327         fi
 328
 329         print_line "$@"
 330
 331         if ${INTERACTIVE}; then
 332                 printf "${NORMAL}"
 333         fi
 334 }
 335
 336 print_headline() {
 337         _print_line BOLD "$@"
 338 }
 339
 340 print_error() {
 341         _print_line FAIL "$@"
 342 }
 343
 344 print_package() {
 345         local name="${1}"
 346         shift
 347
 348         local version="$(grep -E "^VER |^VER=|^VER      " $BASEDIR/lfs/${name} | awk '{ print $3 }')"
 349         local options="$@"
 350
 351         local string="${name}"
 352         if [ -n "${version}" ] && [ "${version}" != "ipfire" ]; then
 353                 string="${string} (${version})"
 354         fi
 355
 356         printf "%-$(( ${NAME_WIDTH} - 1 ))s " "${string}"
 357         printf "%$(( ${OPTIONS_WIDTH} - 1 ))s " "${options}"
 358 }
 359
 360 print_runtime() {
 361         local runtime=$(format_runtime $@)
 362
 363         if ${INTERACTIVE}; then
 364                 printf "\\033[${TIME_COL}G[ ${BOLD}%$(( ${TIME_WIDTH} - 4 ))s${NORMAL} ]" "${runtime}"
 365         else
 366                 printf "[ %$(( ${TIME_WIDTH} - 4 ))s ]" "${runtime}"
 367         fi
 368 }
 369
 370 print_status() {
 371         local status="${1}"
 372
 373         local color="${!status}"
 374
 375         if ${INTERACTIVE}; then
 376                 printf "\\033[${STATUS_COL}G[${color-${BOLD}} %-$(( ${STATUS_WIDTH} - 4 ))s ${NORMAL}]\n" "${status}"
 377         else
 378                 printf "[ %-$(( ${STATUS_WIDTH} - 4 ))s ]\n" "${status}"
 379         fi
 380 }
 381
 382 print_build_stage() {
 383         print_headline "$@"
 384
 385         # end line
 386         printf "\n"
 387 }
 388
 389 print_build_summary() {
 390         local runtime=$(format_runtime $@)
 391
 392         print_line "*** Build finished in ${runtime}"
 393         print_status DONE
 394 }
 395
 396 exiterror() {
 397         stdumount
 398         for i in `seq 0 7`; do
 399                 if ( losetup /dev/loop${i} 2>/dev/null | grep -q "/install/images" ); then
 400                 losetup -d /dev/loop${i} 2>/dev/null
 401                 fi;
 402         done
 403
 404         # Dump logfile
 405         if [ -n "${LOGFILE}" ] && [ -e "${LOGFILE}" ]; then
 406                 echo # empty line
 407
 408                 local line
 409                 while read -r line; do
 410                         echo "    ${line}"
 411                 done <<< "$(tail -n30 ${LOGFILE})"
 412         fi
 413
 414         echo # empty line
 415
 416         local line
 417         for line in "ERROR: $@" "    Check ${LOGFILE} for errors if applicable"; do
 418                 print_error "${line}"
 419                 print_status FAIL
 420         done
 421
 422         exit 1
 423 }
 424
 425 prepareenv() {
 426         # Are we running the right shell?
 427         if [ -z "${BASH}" ]; then
 428                 exiterror "BASH environment variable is not set.  You're probably running the wrong shell."
 429         fi
 430
 431         if [ -z "${BASH_VERSION}" ]; then
 432                 exiterror "Not running BASH shell."
 433         fi
 434
 435         # Trap on emergency exit
 436         trap "exiterror 'Build process interrupted'" SIGINT SIGTERM SIGQUIT
 437
 438         # Checking if running as root user
 439         if [ $(id -u) -ne 0 ]; then
 440                         exiterror "root privileges required for building"
 441         fi
 442
 443         # Checking for necessary temporary space
 444         print_line "Checking for necessary space on disk $BASE_DEV"
 445         BASE_DEV=`df -P -k $BASEDIR | tail -n 1 | awk '{ print $1 }'`
 446         BASE_ASPACE=`df -P -k $BASEDIR | tail -n 1 | awk '{ print $4 }'`
 447         if (( 2048000 > $BASE_ASPACE )); then
 448                         BASE_USPACE=`du -skx $BASEDIR | awk '{print $1}'`
 449                         if (( 2048000 - $BASE_USPACE > $BASE_ASPACE )); then
 450                                 print_status FAIL
 451                                 exiterror "Not enough temporary space available, need at least 2GB on $BASE_DEV"
 452                         fi
 453         else
 454                         print_status DONE
 455         fi
 456
 457         # Set umask
 458         umask 022
 459
 460         # Set LFS Directory
 461         LFS=$BASEDIR/build
 462
 463         # Setup environment
 464         set +h
 465         LC_ALL=POSIX
 466         export LFS LC_ALL CFLAGS CXXFLAGS DEFAULT_PARALLELISM RUSTFLAGS NINJAJOBS
 467         unset CC CXX CPP LD_LIBRARY_PATH LD_PRELOAD
 468
 469         # Make some extra directories
 470         mkdir -p "${BASEDIR}/build${TOOLS_DIR}" 2>/dev/null
 471         mkdir -p $BASEDIR/build/{etc,usr/src} 2>/dev/null
 472         mkdir -p $BASEDIR/build/{dev/{shm,pts},proc,sys}
 473         mkdir -p $BASEDIR/{cache,ccache/${BUILD_ARCH}/${TOOLCHAINVER}} 2>/dev/null
 474
 475         if [ "${ENABLE_RAMDISK}" = "on" ]; then
 476                 mkdir -p $BASEDIR/build/usr/src
 477                 mount -t tmpfs tmpfs -o size=8G,nr_inodes=1M,mode=1777 $BASEDIR/build/usr/src
 478
 479                 mkdir -p ${BASEDIR}/build/tmp
 480                 mount -t tmpfs tmpfs -o size=4G,nr_inodes=1M,mode=1777 ${BASEDIR}/build/tmp
 481         fi
 482
 483         mkdir -p $BASEDIR/build/usr/src/{cache,config,doc,html,langs,lfs,log,src,ccache}
 484
 485         mknod -m 600 $BASEDIR/build/dev/console c 5 1 2>/dev/null
 486         mknod -m 666 $BASEDIR/build/dev/null c 1 3 2>/dev/null
 487
 488         # Make all sources and proc available under lfs build
 489         mount --bind /dev            $BASEDIR/build/dev
 490         mount --bind /dev/pts        $BASEDIR/build/dev/pts
 491         mount --bind /dev/shm        $BASEDIR/build/dev/shm
 492         mount --bind /proc           $BASEDIR/build/proc
 493         mount --bind /sys            $BASEDIR/build/sys
 494         mount --bind $BASEDIR/cache  $BASEDIR/build/usr/src/cache
 495         mount --bind $BASEDIR/ccache/${BUILD_ARCH}/${TOOLCHAINVER} $BASEDIR/build/usr/src/ccache
 496         mount --bind $BASEDIR/config $BASEDIR/build/usr/src/config
 497         mount --bind $BASEDIR/doc    $BASEDIR/build/usr/src/doc
 498         mount --bind $BASEDIR/html   $BASEDIR/build/usr/src/html
 499         mount --bind $BASEDIR/langs  $BASEDIR/build/usr/src/langs
 500         mount --bind $BASEDIR/lfs    $BASEDIR/build/usr/src/lfs
 501         mount --bind $BASEDIR/log    $BASEDIR/build/usr/src/log
 502         mount --bind $BASEDIR/src    $BASEDIR/build/usr/src/src
 503
 504         # Run LFS static binary creation scripts one by one
 505         export CCACHE_DIR=$BASEDIR/ccache
 506         export CCACHE_TEMPDIR="/tmp"
 507         export CCACHE_COMPILERCHECK="string:toolchain-${TOOLCHAINVER} ${BUILD_ARCH}"
 508
 509         # Remove pre-install list of installed files in case user erase some files before rebuild
 510         rm -f $BASEDIR/build/usr/src/lsalr 2>/dev/null
 511
 512         # Prepare string for /etc/system-release.
 513         local system_release="${NAME} ${VERSION} (${BUILD_ARCH})"
 514
 515         case "${GIT_BRANCH}" in
 516                 core*|beta?|rc?)
 517                         system_release="${system_release} - ${GIT_BRANCH}"
 518                         ;;
 519                 *)
 520                         system_release="${system_release} - core${CORE} Development Build: ${GIT_BRANCH}/${GIT_LASTCOMMIT:0:8}"
 521                         ;;
 522         esac
 523
 524         # Append -dirty tag for local changes
 525         if [ "$(git status -s | wc -l)" != "0" ]; then
 526                 system_release="${system_release}-dirty"
 527         fi
 528
 529         # Export variable
 530         SYSTEM_RELEASE="${system_release}"
 531
 532         # Decide on PAKFIRE_TREE
 533         case "${GIT_BRANCH}" in
 534                 core*)
 535                         PAKFIRE_TREE="stable"
 536                         ;;
 537                 master)
 538                         PAKFIRE_TREE="testing"
 539                         ;;
 540                 *)
 541                         PAKFIRE_TREE="unstable"
 542                         ;;
 543         esac
 544
 545         # Setup ccache cache size
 546         enterchroot ccache --max-size="${CCACHE_CACHE_SIZE}"
 547 }
 548
 549 enterchroot() {
 550         # Install QEMU helper, if needed
 551         qemu_install_helper
 552
 553         local PATH="${TOOLS_DIR}/ccache/bin:/bin:/usr/bin:/sbin:/usr/sbin:${TOOLS_DIR}/sbin:${TOOLS_DIR}/bin"
 554
 555         # Prepend any custom changes to PATH
 556         if [ -n "${CUSTOM_PATH}" ]; then
 557                 PATH="${CUSTOM_PATH}:${PATH}"
 558         fi
 559
 560         PATH="${PATH}" chroot ${LFS} env -i \
 561                 HOME="/root" \
 562                 TERM="${TERM}" \
 563                 PS1="${PS1}" \
 564                 PATH="${PATH}" \
 565                 SYSTEM_RELEASE="${SYSTEM_RELEASE}" \
 566                 PAKFIRE_TREE="${PAKFIRE_TREE}" \
 567                 NAME="${NAME}" \
 568                 SNAME="${SNAME}" \
 569                 VERSION="${VERSION}" \
 570                 CORE="${CORE}" \
 571                 SLOGAN="${SLOGAN}" \
 572                 TOOLS_DIR="${TOOLS_DIR}" \
 573                 CONFIG_ROOT="${CONFIG_ROOT}" \
 574                 CFLAGS="${CFLAGS} ${HARDENING_CFLAGS}" \
 575                 CXXFLAGS="${CXXFLAGS} ${HARDENING_CFLAGS}" \
 576                 RUSTFLAGS="${RUSTFLAGS}" \
 577                 BUILDTARGET="${BUILDTARGET}" \
 578                 CROSSTARGET="${CROSSTARGET}" \
 579                 BUILD_ARCH="${BUILD_ARCH}" \
 580                 BUILD_PLATFORM="${BUILD_PLATFORM}" \
 581                 CCACHE_DIR=/usr/src/ccache \
 582                 CCACHE_TEMPDIR="${CCACHE_TEMPDIR}" \
 583                 CCACHE_COMPILERCHECK="${CCACHE_COMPILERCHECK}" \
 584                 GOCACHE="/usr/src/ccache/go" \
 585                 KVER="${KVER}" \
 586                 XZ_OPT="${XZ_OPT}" \
 587                 DEFAULT_PARALLELISM="${DEFAULT_PARALLELISM}" \
 588                 SYSTEM_PROCESSORS="${SYSTEM_PROCESSORS}" \
 589                 SYSTEM_MEMORY="${SYSTEM_MEMORY}" \
 590                 $(fake_environ) \
 591                 $(qemu_environ) \
 592                 "$@"
 593 }
 594
 595 entershell() {
 596         if [ ! -e $BASEDIR/build/usr/src/lfs/ ]; then
 597                 exiterror "No such file or directory: $BASEDIR/build/usr/src/lfs/"
 598         fi
 599
 600         echo "Entering to a shell inside LFS chroot, go out with exit"
 601         local PS1="ipfire build chroot (${BUILD_ARCH}) \u:\w\$ "
 602
 603         if enterchroot bash -i; then
 604                 stdumount
 605         else
 606                 print_status FAIL
 607                 exiterror "chroot error"
 608         fi
 609 }
 610
 611 lfsmakecommoncheck() {
 612         # Script present?
 613         if [ ! -f $BASEDIR/lfs/$1 ]; then
 614                 exiterror "No such file or directory: $BASEDIR/$1"
 615         fi
 616
 617         # Print package name and version
 618         print_package $@
 619
 620         # Check if this package is supported by our architecture.
 621         # If no SUP_ARCH is found, we assume the package can be built for all.
 622         if grep "^SUP_ARCH" ${BASEDIR}/lfs/${1} >/dev/null; then
 623                 # Check if package supports ${BUILD_ARCH} or all architectures.
 624                 if ! grep -E "^SUP_ARCH.*${BUILD_ARCH}|^SUP_ARCH.*all" ${BASEDIR}/lfs/${1} >/dev/null; then
 625                         print_runtime 0
 626                         print_status SKIP
 627                         return 1
 628                 fi
 629         fi
 630
 631         # Script slipped?
 632         local i
 633         for i in $SKIP_PACKAGE_LIST
 634         do
 635                 if [ "$i" == "$1" ]; then
 636                         print_status SKIP
 637                         return 1;
 638                 fi
 639         done
 640
 641         echo -ne "`date -u '+%b %e %T'`: Building $* " >> $LOGFILE
 642
 643         cd $BASEDIR/lfs && make -s -f $* LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
 644                 MESSAGE="$1\t " download  >> $LOGFILE 2>&1
 645         if [ $? -ne 0 ]; then
 646                 exiterror "Download error in $1"
 647         fi
 648
 649         cd $BASEDIR/lfs && make -s -f $* LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
 650                 MESSAGE="$1\t md5sum" md5  >> $LOGFILE 2>&1
 651         if [ $? -ne 0 ]; then
 652                 exiterror "md5sum error in $1, check file in cache or signature"
 653         fi
 654
 655         return 0        # pass all!
 656 }
 657
 658 lfsmake1() {
 659         lfsmakecommoncheck $*
 660         [ $? == 1 ] && return 0
 661
 662         # Set PATH to use the toolchain tools first and then whatever the host has set
 663         local PATH="${TOOLS_DIR}/ccache/bin:${TOOLS_DIR}/sbin:${TOOLS_DIR}/bin:${PATH}"
 664
 665         if [ -n "${CUSTOM_PATH}" ]; then
 666                 PATH="${CUSTOM_PATH}:${PATH}"
 667         fi
 668
 669         cd $BASEDIR/lfs && env -i \
 670                 PATH="${PATH}" \
 671                 CCACHE_DIR="${CCACHE_DIR}"/${BUILD_ARCH}/${TOOLCHAINVER} \
 672                 CCACHE_TEMPDIR="${CCACHE_TEMPDIR}" \
 673                 CCACHE_COMPILERCHECK="${CCACHE_COMPILERCHECK}" \
 674                 CFLAGS="${CFLAGS}" \
 675                 CXXFLAGS="${CXXFLAGS}" \
 676                 DEFAULT_PARALLELISM="${DEFAULT_PARALLELISM}" \
 677                 SYSTEM_PROCESSORS="${SYSTEM_PROCESSORS}" \
 678                 SYSTEM_MEMORY="${SYSTEM_MEMORY}" \
 679                 make -f $* \
 680                         TOOLCHAIN=1 \
 681                         TOOLS_DIR="${TOOLS_DIR}" \
 682                         CROSSTARGET="${CROSSTARGET}" \
 683                         BUILDTARGET="${BUILDTARGET}" \
 684                         BUILD_ARCH="${BUILD_ARCH}" \
 685                         BUILD_PLATFORM="${BUILD_PLATFORM}" \
 686                         LFS_BASEDIR="${BASEDIR}" \
 687                         ROOT="${LFS}" \
 688                         KVER="${KVER}" \
 689                         install >> $LOGFILE 2>&1 &
 690
 691         if ! wait_until_finished $!; then
 692                 print_status FAIL
 693                 exiterror "Building $*"
 694         fi
 695
 696         print_status DONE
 697 }
 698
 699 lfsmake2() {
 700         lfsmakecommoncheck $*
 701         [ $? == 1 ] && return 0
 702
 703         local PS1='\u:\w$ '
 704
 705         enterchroot \
 706                 bash -x -c "cd /usr/src/lfs && \
 707                         make -f $* \
 708                         LFS_BASEDIR=/usr/src install" \
 709                 >> ${LOGFILE} 2>&1 &
 710
 711         if ! wait_until_finished $!; then
 712                 print_status FAIL
 713                 exiterror "Building $*"
 714         fi
 715
 716         print_status DONE
 717 }
 718
 719 ipfiredist() {
 720         lfsmakecommoncheck $*
 721         [ $? == 1 ] && return 0
 722
 723         local PS1='\u:\w$ '
 724
 725         enterchroot \
 726                 bash -x -c "cd /usr/src/lfs && make -f $* LFS_BASEDIR=/usr/src dist" \
 727                 >> ${LOGFILE} 2>&1 &
 728
 729         if ! wait_until_finished $!; then
 730                 print_status FAIL
 731                 exiterror "Packaging $*"
 732         fi
 733
 734         print_status DONE
 735 }
 736
 737 wait_until_finished() {
 738         local pid=${1}
 739
 740         local start_time="${SECONDS}"
 741
 742         # Show progress
 743         if ${INTERACTIVE}; then
 744                 # Wait a little just in case the process
 745                 # has finished very quickly.
 746                 sleep 0.1
 747
 748                 local runtime
 749                 while kill -0 ${pid} 2>/dev/null; do
 750                         print_runtime $(( SECONDS - start_time ))
 751
 752                         # Wait a little
 753                         sleep 1
 754                 done
 755         fi
 756
 757         # Returns the exit code of the child process
 758         wait ${pid}
 759         local ret=$?
 760
 761         if ! ${INTERACTIVE}; then
 762                 print_runtime $(( SECONDS - start_time ))
 763         fi
 764
 765         return ${ret}
 766 }
 767
 768 fake_environ() {
 769         [ -e "${BASEDIR}/build${TOOLS_DIR}/lib/libpakfire_preload.so" ] || return
 770
 771         local env="LD_PRELOAD=${TOOLS_DIR}/lib/libpakfire_preload.so"
 772
 773         # Fake kernel version, because some of the packages do not compile
 774         # with kernel 3.0 and later.
 775         env="${env} UTS_RELEASE=${KVER}-ipfire"
 776
 777         # Fake machine version.
 778         env="${env} UTS_MACHINE=${BUILD_ARCH}"
 779
 780         echo "${env}"
 781 }
 782
 783 qemu_environ() {
 784         local env
 785
 786         # Don't add anything if qemu is not used.
 787         if ! qemu_is_required; then
 788                 return
 789         fi
 790
 791         # Set default qemu options
 792         case "${BUILD_ARCH}" in
 793                 arm*)
 794                         QEMU_CPU="${QEMU_CPU:-cortex-a9}"
 795
 796                         env="${env} QEMU_CPU=${QEMU_CPU}"
 797                         ;;
 798         esac
 799
 800         # Enable QEMU strace
 801         #env="${env} QEMU_STRACE=1"
 802
 803         echo "${env}"
 804 }
 805
 806 qemu_is_required() {
 807         local build_arch="${1}"
 808
 809         if [ -z "${build_arch}" ]; then
 810                 build_arch="${BUILD_ARCH}"
 811         fi
 812
 813         case "${HOST_ARCH},${build_arch}" in
 814                 x86_64,arm*|x86_64,aarch64|x86_64,riscv64|i?86,arm*|i?86,aarch64|i?86,x86_64)
 815                         return 0
 816                         ;;
 817                 *)
 818                         return 1
 819                         ;;
 820         esac
 821 }
 822
 823 qemu_install_helper() {
 824         # Do nothing, if qemu is not required
 825         if ! qemu_is_required; then
 826                 return 0
 827         fi
 828
 829         if [ ! -e /proc/sys/fs/binfmt_misc/status ]; then
 830                 exiterror "binfmt_misc not mounted. QEMU_TARGET_HELPER not useable."
 831         fi
 832
 833         if [ ! $(cat /proc/sys/fs/binfmt_misc/status) = 'enabled' ]; then
 834                 exiterror "binfmt_misc not enabled. QEMU_TARGET_HELPER not useable."
 835         fi
 836
 837
 838         if [ -z "${QEMU_TARGET_HELPER}" ]; then
 839                 exiterror "QEMU_TARGET_HELPER not set"
 840         fi
 841
 842         # Check if the helper is already installed.
 843         if [ -x "${LFS}${QEMU_TARGET_HELPER}" ]; then
 844                 return 0
 845         fi
 846
 847         # Try to find a suitable binary that we can install
 848         # to the build environment.
 849         local file
 850         for file in "${QEMU_TARGET_HELPER}" "${QEMU_TARGET_HELPER}-static"; do
 851                 # file must exist and be executable.
 852                 [ -x "${file}" ] || continue
 853
 854                 # Must be static.
 855                 file_is_static "${file}" || continue
 856
 857                 local dirname="${LFS}$(dirname "${file}")"
 858                 mkdir -p "${dirname}"
 859
 860                 install -m 755 "${file}" "${LFS}${QEMU_TARGET_HELPER}"
 861                 return 0
 862         done
 863
 864         exiterror "Could not find a statically-linked QEMU emulator: ${QEMU_TARGET_HELPER}"
 865 }
 866
 867 qemu_find_build_helper_name() {
 868         local build_arch="${1}"
 869
 870         local magic
 871         case "${build_arch}" in
 872                 aarch64)
 873                         magic="7f454c460201010000000000000000000200b700"
 874                         ;;
 875                 arm*)
 876                         magic="7f454c4601010100000000000000000002002800"
 877                         ;;
 878                 riscv64)
 879                         magic="7f454c460201010000000000000000000200f300"
 880                         ;;
 881                 x86_64)
 882                         magic="7f454c4602010100000000000000000002003e00"
 883                         ;;
 884         esac
 885
 886         [ -z "${magic}" ] && return 1
 887
 888         local file
 889         for file in /proc/sys/fs/binfmt_misc/*; do
 890                 # skip write only register entry
 891                 [ $(basename "${file}") = "register" ] && continue
 892                 # Search for the file with the correct magic value.
 893                 grep -qE "^magic ${magic}$" "${file}" || continue
 894
 895                 local interpreter="$(grep "^interpreter" "${file}" | awk '{ print $2 }')"
 896
 897                 [ -n "${interpreter}" ] || continue
 898                 [ "${interpreter:0:1}" = "/" ] || continue
 899                 [ -x "${interpreter}" ] || continue
 900
 901                 echo "${interpreter}"
 902                 return 0
 903         done
 904
 905         return 1
 906 }
 907
 908 file_is_static() {
 909         local file="${1}"
 910
 911         file -L "${file}" 2>/dev/null | grep -q "statically linked"
 912 }
 913
 914 update_language_list() {
 915         local path="${1}"
 916
 917         local lang
 918         for lang in ${path}/*.po; do
 919                 lang="$(basename "${lang}")"
 920                 echo "${lang%*.po}"
 921         done | sort -u > "${path}/LINGUAS"
 922 }
 923
 924 contributors() {
 925         local commits name
 926
 927         git shortlog --summary --numbered | while read -r commits name; do
 928                 echo "${name}"
 929         done | grep -vE -e "^(alpha197|morlix|root|ummeegge)$" -e "via Development$" -e "@" -e "#$"
 930 }
 931
 932 update_contributors() {
 933         echo -n "Updating list of contributors"
 934
 935         local contributors="$(contributors | paste -sd , - | sed -e "s/,/&\\\\n/g")"
 936
 937         # Edit contributors into credits.cgi
 938         local tmp="$(mktemp)"
 939
 940         awk "/<!-- CONTRIBUTORS -->/{ p=1; print; printf \"${contributors}\n\"}/<!-- END -->/{ p=0 } !p" \
 941                 < "${BASEDIR}/html/cgi-bin/credits.cgi" > "${tmp}"
 942
 943         # Copy back modified content
 944         cat "${tmp}" > "${BASEDIR}/html/cgi-bin/credits.cgi"
 945         unlink "${tmp}"
 946
 947         print_status DONE
 948         return 0
 949 }
 950
 951 # Default settings
 952 CCACHE_CACHE_SIZE="4G"
 953 ENABLE_RAMDISK="auto"
 954
 955 # Load configuration file
 956 if [ -f .config ]; then
 957         . .config
 958 fi
 959
 960 # TARGET_ARCH is BUILD_ARCH now
 961 if [ -n "${TARGET_ARCH}" ]; then
 962         BUILD_ARCH="${TARGET_ARCH}"
 963         unset TARGET_ARCH
 964 fi
 965
 966 # Get some information about the host system
 967 SYSTEM_PROCESSORS="$(system_processors)"
 968 SYSTEM_MEMORY="$(system_memory)"
 969
 970 if [ -n "${BUILD_ARCH}" ]; then
 971         configure_build "${BUILD_ARCH}"
 972 else
 973         configure_build "default"
 974 fi
 975
 976 # Automatically enable/disable ramdisk usage
 977 if [ "${ENABLE_RAMDISK}" = "auto" ]; then
 978         # Enable only when the host system has 4GB of RAM or more
 979         if [ ${SYSTEM_MEMORY} -ge 3900 ]; then
 980                 ENABLE_RAMDISK="on"
 981         fi
 982 fi
 983
 984 buildtoolchain() {
 985         local error=false
 986         case "${BUILD_ARCH}:${HOST_ARCH}" in
 987                 # x86_64
 988                 x86_64:x86_64)
 989                          # This is working.
 990                          ;;
 991
 992                 # ARM
 993                 arvm7hl:armv7hl|armv7hl:armv7l)
 994                         # These are working.
 995                         ;;
 996
 997                 armv6l:armv6l|armv6l:armv7l|armv6l:aarch64)
 998                         # These are working.
 999                         ;;
1000                 armv6l:*)
1001                         error=true
1002                         ;;
1003         esac
1004
1005         ${error} && \
1006                 exiterror "Cannot build ${BUILD_ARCH} toolchain on $(uname -m). Please use the download if any."
1007
1008         local gcc=$(type -p gcc)
1009         if [ -z "${gcc}" ]; then
1010                 exiterror "Could not find GCC. You will need a working build enviroment in order to build the toolchain."
1011         fi
1012
1013         # Check ${TOOLS_DIR} symlink
1014         if [ -h "${TOOLS_DIR}" ]; then
1015                 rm -f "${TOOLS_DIR}"
1016         fi
1017
1018         if [ ! -e "${TOOLS_DIR}" ]; then
1019                 ln -s "${BASEDIR}/build${TOOLS_DIR}" "${TOOLS_DIR}"
1020         fi
1021
1022         if [ ! -h "${TOOLS_DIR}" ]; then
1023                 exiterror "Could not create ${TOOLS_DIR} symbolic link"
1024         fi
1025
1026         LOGFILE="$BASEDIR/log/_build.toolchain.log"
1027         export LOGFILE
1028
1029         lfsmake1 stage1
1030         lfsmake1 binutils                       PASS=1
1031         lfsmake1 gcc                    PASS=1
1032         lfsmake1 linux                  KCFG="-headers"
1033         lfsmake1 glibc
1034         lfsmake1 libxcrypt
1035         lfsmake1 gcc                    PASS=L
1036         lfsmake1 zlib
1037         lfsmake1 binutils                       PASS=2
1038         lfsmake1 gcc                    PASS=2
1039         lfsmake1 zstd
1040         lfsmake1 ccache
1041         lfsmake1 tcl
1042         lfsmake1 expect
1043         lfsmake1 dejagnu
1044         lfsmake1 pkg-config
1045         lfsmake1 ncurses
1046         lfsmake1 bash
1047         lfsmake1 bzip2
1048         lfsmake1 automake
1049         lfsmake1 coreutils
1050         lfsmake1 diffutils
1051         lfsmake1 findutils
1052         lfsmake1 gawk
1053         lfsmake1 gettext
1054         lfsmake1 grep
1055         lfsmake1 gzip
1056         lfsmake1 m4
1057         lfsmake1 make
1058         lfsmake1 patch
1059         lfsmake1 perl
1060         lfsmake1 python3
1061         lfsmake1 sed
1062         lfsmake1 tar
1063         lfsmake1 texinfo
1064         lfsmake1 xz
1065         lfsmake1 bison
1066         lfsmake1 flex
1067         lfsmake1 fake-environ
1068         CUSTOM_PATH="${PATH}" lfsmake1 strip
1069         lfsmake1 cleanup-toolchain
1070 }
1071
1072 buildbase() {
1073         LOGFILE="$BASEDIR/log/_build.base.log"
1074         export LOGFILE
1075         lfsmake2 stage2
1076         lfsmake2 linux                  KCFG="-headers"
1077         lfsmake2 man-pages
1078         lfsmake2 glibc
1079         lfsmake2 tzdata
1080         lfsmake2 cleanup-toolchain
1081         lfsmake2 zlib
1082         lfsmake2 zstd
1083         lfsmake2 autoconf
1084         lfsmake2 automake
1085         lfsmake2 libtool
1086         lfsmake2 binutils
1087         lfsmake2 gmp
1088         lfsmake2 mpfr
1089         lfsmake2 libmpc
1090         lfsmake2 libxcrypt
1091         lfsmake2 file
1092         lfsmake2 gcc
1093         lfsmake2 sed
1094         lfsmake2 berkeley
1095         lfsmake2 coreutils
1096         lfsmake2 iana-etc
1097         lfsmake2 m4
1098         lfsmake2 bison
1099         lfsmake2 ncurses
1100         lfsmake2 perl
1101         lfsmake2 readline
1102         lfsmake2 bzip2
1103         lfsmake2 xz
1104         lfsmake2 lzip
1105         lfsmake2 pcre
1106         lfsmake2 pcre2
1107         lfsmake2 gettext
1108         lfsmake2 attr
1109         lfsmake2 acl
1110         lfsmake2 bash
1111         lfsmake2 diffutils
1112         lfsmake2 ed
1113         lfsmake2 findutils
1114         lfsmake2 flex
1115         lfsmake2 gawk
1116         lfsmake2 go
1117         lfsmake2 grep
1118         lfsmake2 groff
1119         lfsmake2 gperf
1120         lfsmake2 gzip
1121         lfsmake2 hostname
1122         lfsmake2 whois
1123         lfsmake2 kbd
1124         lfsmake2 less
1125         lfsmake2 pkg-config
1126         lfsmake2 procps
1127         lfsmake2 make
1128         lfsmake2 man
1129         lfsmake2 net-tools
1130         lfsmake2 patch
1131         lfsmake2 psmisc
1132         lfsmake2 shadow
1133         lfsmake2 sysklogd
1134         lfsmake2 sysvinit
1135         lfsmake2 tar
1136         lfsmake2 texinfo
1137         lfsmake2 util-linux
1138         lfsmake2 vim
1139         lfsmake2 e2fsprogs
1140         lfsmake2 jq
1141 }
1142
1143 buildipfire() {
1144   LOGFILE="$BASEDIR/log/_build.ipfire.log"
1145   export LOGFILE
1146   lfsmake2 configroot
1147   lfsmake2 initscripts
1148   lfsmake2 backup
1149   lfsmake2 rust
1150   lfsmake2 openssl
1151   lfsmake2 kmod
1152   lfsmake2 udev
1153   lfsmake2 popt
1154   lfsmake2 libedit
1155   lfsmake2 libusb
1156   lfsmake2 libusb-compat
1157   lfsmake2 libpcap
1158   lfsmake2 ppp
1159   lfsmake2 pptp
1160   lfsmake2 unzip
1161   lfsmake2 which
1162   lfsmake2 linux-firmware
1163   lfsmake2 dvb-firmwares
1164   lfsmake2 xr819-firmware
1165   lfsmake2 zd1211-firmware
1166   lfsmake2 rpi-firmware
1167   lfsmake2 intel-microcode
1168   lfsmake2 pcengines-apu-firmware
1169   lfsmake2 bc
1170   lfsmake2 u-boot MKIMAGE=1
1171   lfsmake2 cpio
1172   lfsmake2 mdadm
1173   lfsmake2 dracut
1174   lfsmake2 libaio
1175   lfsmake2 lvm2
1176   lfsmake2 multipath-tools
1177   lfsmake2 freetype
1178   lfsmake2 libmnl
1179   lfsmake2 libnfnetlink
1180   lfsmake2 libnetfilter_queue
1181   lfsmake2 libnetfilter_conntrack
1182   lfsmake2 libnetfilter_cthelper
1183   lfsmake2 libnetfilter_cttimeout
1184   lfsmake2 iptables
1185   lfsmake2 iproute2
1186   lfsmake2 screen
1187   lfsmake2 elfutils
1188
1189   # Kernelbuild ... current we have no platform that need
1190   # multi kernel builds so KCFG is empty
1191   lfsmake2 linux                KCFG=""
1192   lfsmake2 rtl8189es            KCFG=""
1193   lfsmake2 rtl8812au            KCFG=""
1194   lfsmake2 rtl8822bu            KCFG=""
1195   lfsmake2 xradio               KCFG=""
1196   lfsmake2 linux-initrd         KCFG=""
1197
1198   lfsmake2 libgpg-error
1199   lfsmake2 libgcrypt
1200   lfsmake2 libassuan
1201   lfsmake2 nettle
1202   lfsmake2 json-c
1203   lfsmake2 libconfig
1204   lfsmake2 libevent
1205   lfsmake2 libevent2
1206   lfsmake2 expat
1207   lfsmake2 apr
1208   lfsmake2 aprutil
1209   lfsmake2 unbound
1210   lfsmake2 gnutls
1211   lfsmake2 libuv
1212   lfsmake2 bind
1213   lfsmake2 dhcp
1214   lfsmake2 dhcpcd
1215   lfsmake2 boost
1216   lfsmake2 linux-atm
1217   lfsmake2 gdbm
1218   lfsmake2 pam
1219   lfsmake2 c-ares
1220   lfsmake2 curl
1221   lfsmake2 tcl
1222   lfsmake2 sqlite
1223   lfsmake2 libffi
1224   lfsmake2 python3
1225   lfsmake2 rust
1226   lfsmake2 rust-dissimilar
1227   lfsmake2 rust-cfg-if
1228   lfsmake2 rust-libc
1229   lfsmake2 rust-getrandom
1230   lfsmake2 rust-typenum
1231   lfsmake2 rust-version-check
1232   lfsmake2 rust-generic-array
1233   lfsmake2 rust-cipher
1234   lfsmake2 rust-hex
1235   lfsmake2 rust-unicode-xid
1236   lfsmake2 rust-proc-macro2
1237   lfsmake2 rust-quote
1238   lfsmake2 rust-syn
1239   lfsmake2 rust-home
1240   lfsmake2 rust-lazy-static
1241   lfsmake2 rust-memchr
1242   lfsmake2 rust-aho-corasick
1243   lfsmake2 rust-regex-syntax
1244   lfsmake2 rust-regex
1245   lfsmake2 rust-ucd-trie
1246   lfsmake2 rust-pest
1247   lfsmake2 rust-semver-parser
1248   lfsmake2 rust-semver
1249   lfsmake2 rust-same-file
1250   lfsmake2 rust-walkdir
1251   lfsmake2 rust-dirs
1252   lfsmake2 rust-toolchain_find
1253   lfsmake2 rust-serde
1254   lfsmake2 rust-itoa
1255   lfsmake2 rust-ryu
1256   lfsmake2 rust-serde_json
1257   lfsmake2 rust-synstructure
1258   lfsmake2 rust-block-buffer
1259   lfsmake2 rust-crypto-common
1260   lfsmake2 rust-digest
1261   lfsmake2 rust-ppv-lite86
1262   lfsmake2 rust-rand_core
1263   lfsmake2 rust-rand_core-0.4.2
1264   lfsmake2 rust-rand_core-0.3.1
1265   lfsmake2 rust-rand_chacha
1266   lfsmake2 rust-rand_hc
1267   lfsmake2 rust-rand
1268   lfsmake2 rust-rdrand
1269   lfsmake2 rust-rand-0.4
1270   lfsmake2 rust-log
1271   lfsmake2 rust-num_cpus
1272   lfsmake2 rust-crossbeam-utils
1273   lfsmake2 rust-autocfg
1274   lfsmake2 rust-memoffset
1275   lfsmake2 rust-scopeguard
1276   lfsmake2 rust-crossbeam-epoch
1277   lfsmake2 rust-crossbeam-deque
1278   lfsmake2 rust-either
1279   lfsmake2 rust-crossbeam-channel
1280   lfsmake2 rust-rayon-core
1281   lfsmake2 rust-rayon
1282   lfsmake2 rust-remove_dir_all
1283   lfsmake2 rust-tempdir
1284   lfsmake2 rust-glob
1285   lfsmake2 rust-once_cell
1286   lfsmake2 rust-termcolor
1287   lfsmake2 rust-toml
1288   lfsmake2 rust-serde_derive
1289   lfsmake2 rust-trybuild
1290   lfsmake2 rust-unindent
1291   lfsmake2 rust-proc-macro-hack
1292   lfsmake2 rust-indoc-impl
1293   lfsmake2 rust-indoc
1294   lfsmake2 rust-instant
1295   lfsmake2 rust-lock_api
1296   lfsmake2 rust-smallvec
1297   lfsmake2 rust-parking_lot_core
1298   lfsmake2 rust-parking_lot
1299   lfsmake2 rust-paste-impl
1300   lfsmake2 rust-paste
1301   lfsmake2 rust-ctor
1302   lfsmake2 rust-ghost
1303   lfsmake2 rust-inventory-impl
1304   lfsmake2 rust-inventory
1305   lfsmake2 rust-pyo3-build-config
1306   lfsmake2 rust-pyo3-macros-backend
1307   lfsmake2 rust-pyo3-macros
1308   lfsmake2 rust-pyo3
1309   lfsmake2 gdb
1310   lfsmake2 grub
1311   lfsmake2 efivar
1312   lfsmake2 efibootmgr
1313   lfsmake2 libtasn1
1314   lfsmake2 p11-kit
1315   lfsmake2 ca-certificates
1316   lfsmake2 fireinfo
1317   lfsmake2 libnet
1318   lfsmake2 libnl
1319   lfsmake2 libnl-3
1320   lfsmake2 libidn
1321   lfsmake2 nasm
1322   lfsmake2 libarchive
1323   lfsmake2 cmake
1324   lfsmake2 ninja
1325   lfsmake2 meson
1326   lfsmake2 libjpeg
1327   lfsmake2 openjpeg
1328   lfsmake2 libexif
1329   lfsmake2 libpng
1330   lfsmake2 libtiff
1331   lfsmake2 libart
1332   lfsmake2 gd
1333   lfsmake2 slang
1334   lfsmake2 newt
1335   lfsmake2 libsmooth
1336   lfsmake2 libcap
1337   lfsmake2 libcap-ng
1338   lfsmake2 pciutils
1339   lfsmake2 usbutils
1340   lfsmake2 libxml2
1341   lfsmake2 libxslt
1342   lfsmake2 perl-BerkeleyDB
1343   lfsmake2 cyrus-sasl
1344   lfsmake2 openldap
1345   lfsmake2 apache2
1346   lfsmake2 web-user-interface
1347   lfsmake2 flag-icons
1348   lfsmake2 jquery
1349   lfsmake2 bootstrap
1350   lfsmake2 arping
1351   lfsmake2 beep
1352   lfsmake2 libssh
1353   lfsmake2 libinih
1354   lfsmake2 cdrkit
1355   lfsmake2 dosfstools
1356   lfsmake2 exfatprogs
1357   lfsmake2 reiserfsprogs
1358   lfsmake2 liburcu
1359   lfsmake2 xfsprogs
1360   lfsmake2 sysfsutils
1361   lfsmake2 fuse
1362   lfsmake2 ntfs-3g
1363   lfsmake2 ethtool
1364   lfsmake2 fcron
1365   lfsmake2 perl-ExtUtils-PkgConfig
1366   lfsmake2 perl-GD
1367   lfsmake2 perl-GD-Graph
1368   lfsmake2 perl-GD-TextUtil
1369   lfsmake2 perl-Device-SerialPort
1370   lfsmake2 perl-Device-Modem
1371   lfsmake2 perl-Apache-Htpasswd
1372   lfsmake2 perl-Parse-Yapp
1373   lfsmake2 perl-Data-UUID
1374   lfsmake2 perl-Try-Tiny
1375   lfsmake2 perl-HTTP-Message
1376   lfsmake2 perl-HTTP-Date
1377   lfsmake2 gnupg
1378   lfsmake2 hdparm
1379   lfsmake2 sdparm
1380   lfsmake2 whatmask
1381   lfsmake2 libtirpc
1382   lfsmake2 conntrack-tools
1383   lfsmake2 iputils
1384   lfsmake2 l7-protocols
1385   lfsmake2 hwdata
1386   lfsmake2 logrotate
1387   lfsmake2 logwatch
1388   lfsmake2 misc-progs
1389   lfsmake2 nano
1390   lfsmake2 perl-URI
1391   lfsmake2 perl-CGI
1392   lfsmake2 perl-Switch
1393   lfsmake2 perl-HTML-Tagset
1394   lfsmake2 perl-HTML-Parser
1395   lfsmake2 perl-HTML-Template
1396   lfsmake2 perl-Compress-Zlib
1397   lfsmake2 perl-Digest
1398   lfsmake2 perl-Digest-SHA1
1399   lfsmake2 perl-Digest-HMAC
1400   lfsmake2 perl-libwww
1401         lfsmake2 perl-LWP-Protocol-https
1402   lfsmake2 perl-Net-HTTP
1403   lfsmake2 perl-Net-DNS
1404   lfsmake2 perl-Net-IPv4Addr
1405   lfsmake2 perl-Net_SSLeay
1406   lfsmake2 perl-IO-Stringy
1407   lfsmake2 perl-IO-Socket-SSL
1408   lfsmake2 perl-Unix-Syslog
1409   lfsmake2 perl-Mail-Tools
1410   lfsmake2 perl-MIME-Tools
1411   lfsmake2 perl-Net-Server
1412   lfsmake2 perl-Canary-Stability
1413   lfsmake2 perl-Convert-TNEF
1414   lfsmake2 perl-Convert-UUlib
1415   lfsmake2 perl-Archive-Tar
1416   lfsmake2 perl-Archive-Zip
1417   lfsmake2 perl-Text-Tabs+Wrap
1418   lfsmake2 perl-XML-Parser
1419   lfsmake2 perl-Crypt-PasswdMD5
1420   lfsmake2 perl-Net-Telnet
1421   lfsmake2 python3-setuptools
1422   lfsmake2 python3-inotify
1423   lfsmake2 python3-docutils
1424   lfsmake2 python3-daemon
1425   lfsmake2 glib
1426   lfsmake2 ntp
1427   lfsmake2 openssh
1428   lfsmake2 fontconfig
1429   lfsmake2 dejavu-fonts-ttf
1430   lfsmake2 ubuntu-font-family
1431   lfsmake2 freefont
1432   lfsmake2 pixman
1433   lfsmake2 cairo
1434   lfsmake2 harfbuzz
1435   lfsmake2 fribidi
1436   lfsmake2 pango
1437   lfsmake2 rrdtool
1438   lfsmake2 setup
1439   lfsmake2 libdnet
1440   lfsmake2 jansson
1441   lfsmake2 yaml
1442   lfsmake2 libhtp
1443   lfsmake2 colm
1444   lfsmake2 ragel
1445   lfsmake2 hyperscan
1446   lfsmake2 suricata
1447   lfsmake2 oinkmaster
1448   lfsmake2 ids-ruleset-sources
1449   lfsmake2 squid
1450   lfsmake2 squidguard
1451   lfsmake2 calamaris
1452   lfsmake2 tcpdump
1453   lfsmake2 traceroute
1454   lfsmake2 vlan
1455   lfsmake2 wireless
1456   lfsmake2 pakfire
1457   lfsmake2 spandsp
1458   lfsmake2 lz4
1459   lfsmake2 lzo
1460   lfsmake2 openvpn
1461   lfsmake2 mpage
1462   lfsmake2 dbus
1463   lfsmake2 intltool
1464   lfsmake2 libdaemon
1465   lfsmake2 avahi
1466   lfsmake2 cups
1467   lfsmake2 lcms2
1468   lfsmake2 ghostscript
1469   lfsmake2 qpdf
1470   lfsmake2 poppler
1471   lfsmake2 poppler-data
1472   lfsmake2 cups-filters
1473   lfsmake2 epson-inkjet-printer-escpr
1474   lfsmake2 foomatic
1475   lfsmake2 hplip
1476   lfsmake2 cifs-utils
1477   lfsmake2 krb5
1478   lfsmake2 rpcsvc-proto
1479   lfsmake2 samba
1480   lfsmake2 netatalk
1481   lfsmake2 sudo
1482   lfsmake2 mc
1483   lfsmake2 wget
1484   lfsmake2 bridge-utils
1485   lfsmake2 smartmontools
1486   lfsmake2 htop
1487   lfsmake2 chkconfig
1488   lfsmake2 postfix
1489   lfsmake2 fetchmail
1490   lfsmake2 clamav
1491   lfsmake2 perl-NetAddr-IP
1492   lfsmake2 dma
1493   lfsmake2 alsa
1494   lfsmake2 mpfire
1495   lfsmake2 guardian
1496   lfsmake2 libid3tag
1497   lfsmake2 libmad
1498   lfsmake2 libogg
1499   lfsmake2 libvorbis
1500   lfsmake2 flac
1501   lfsmake2 lame
1502   lfsmake2 sox
1503   lfsmake2 soxr
1504   lfsmake2 libshout
1505   lfsmake2 xvid
1506   lfsmake2 libmpeg2
1507   lfsmake2 gnump3d
1508   lfsmake2 rsync
1509   lfsmake2 rpcbind
1510   lfsmake2 keyutils
1511   lfsmake2 nfs
1512   lfsmake2 gnu-netcat
1513   lfsmake2 ncat
1514   lfsmake2 nmap
1515   lfsmake2 etherwake
1516   lfsmake2 bwm-ng
1517   lfsmake2 sysstat
1518   lfsmake2 strongswan
1519   lfsmake2 rng-tools
1520   lfsmake2 lsof
1521   lfsmake2 br2684ctl
1522   lfsmake2 pcmciautils
1523   lfsmake2 lm_sensors
1524   lfsmake2 libstatgrab
1525   lfsmake2 liboping
1526   lfsmake2 collectd
1527   lfsmake2 elinks
1528   lfsmake2 igmpproxy
1529   lfsmake2 opus
1530   lfsmake2 python3-pyparsing
1531   lfsmake2 spice-protocol
1532   lfsmake2 spice
1533   lfsmake2 sdl2
1534   lfsmake2 libusbredir
1535   lfsmake2 libseccomp
1536   lfsmake2 qemu
1537   lfsmake2 netpbm
1538   lfsmake2 netsnmpd
1539   lfsmake2 nagios_nrpe
1540   lfsmake2 nagios-plugins
1541   lfsmake2 icinga
1542   lfsmake2 observium-agent
1543   lfsmake2 ebtables
1544   lfsmake2 faad2
1545   lfsmake2 alac
1546   lfsmake2 ffmpeg
1547   lfsmake2 vdr
1548   lfsmake2 vdr_streamdev
1549   lfsmake2 vdr_epgsearch
1550   lfsmake2 vdr_dvbapi
1551   lfsmake2 vdr_eepg
1552   lfsmake2 w_scan
1553   lfsmake2 mpd
1554   lfsmake2 libmpdclient
1555   lfsmake2 mpc
1556   lfsmake2 perl-Net-CIDR-Lite
1557   lfsmake2 perl-Net-SMTP-SSL
1558   lfsmake2 perl-MIME-Base64
1559   lfsmake2 perl-Authen-SASL
1560   lfsmake2 perl-MIME-Lite
1561   lfsmake2 perl-Email-Date-Format
1562   lfsmake2 git
1563   lfsmake2 squidclamav
1564   lfsmake2 vnstat
1565   lfsmake2 iw
1566   lfsmake2 wpa_supplicant
1567   lfsmake2 hostapd
1568   lfsmake2 syslinux
1569   lfsmake2 tftpd
1570   lfsmake2 cpufrequtils
1571   lfsmake2 gutenprint
1572   lfsmake2 apcupsd
1573   lfsmake2 fireperf
1574   lfsmake2 iperf
1575   lfsmake2 iperf3
1576   lfsmake2 7zip
1577   lfsmake2 lynis
1578   lfsmake2 sshfs
1579   lfsmake2 taglib
1580   lfsmake2 sslh
1581   lfsmake2 perl-gettext
1582   lfsmake2 perl-Sort-Naturally
1583   lfsmake2 vdradmin
1584   lfsmake2 perl-DBI
1585   lfsmake2 perl-DBD-SQLite
1586   lfsmake2 perl-File-ReadBackwards
1587   lfsmake2 openvmtools
1588   lfsmake2 joe
1589   lfsmake2 monit
1590   lfsmake2 nut
1591   lfsmake2 watchdog
1592   lfsmake2 libpri
1593   lfsmake2 usb_modeswitch
1594   lfsmake2 usb_modeswitch_data
1595   lfsmake2 zerofree
1596   lfsmake2 minicom
1597   lfsmake2 ddrescue
1598   lfsmake2 powertop
1599   lfsmake2 parted
1600   lfsmake2 swig
1601   lfsmake2 dtc
1602   lfsmake2 u-boot
1603   lfsmake2 u-boot-friendlyarm
1604   lfsmake2 wireless-regdb
1605   lfsmake2 libsolv
1606   lfsmake2 ddns
1607   lfsmake2 python3-pycparser
1608   lfsmake2 python3-charset-normalizer
1609   lfsmake2 python3-certifi
1610   lfsmake2 python3-idna
1611   lfsmake2 python3-requests
1612   lfsmake2 python3-toml
1613   lfsmake2 python3-pyproject2setuppy
1614   lfsmake2 python3-tomli
1615   lfsmake2 python3-pep517
1616   lfsmake2 python3-build
1617   lfsmake2 python3-install
1618   lfsmake2 python3-urllib3
1619   lfsmake2 python3-flit
1620   lfsmake2 python3-packaging
1621   lfsmake2 python3-typing-extensions
1622   lfsmake2 python3-semantic-version
1623   lfsmake2 python3-setuptools-scm
1624   lfsmake2 python3-setuptools-rust
1625   lfsmake2 python3-six
1626   lfsmake2 python3-dateutil
1627   lfsmake2 python3-jmespath
1628   lfsmake2 python3-colorama
1629   lfsmake2 python3-yaml
1630   lfsmake2 python3-s3transfer
1631   lfsmake2 python3-rsa
1632   lfsmake2 python3-pyasn1
1633   lfsmake2 python3-botocore
1634   lfsmake2 python3-cffi
1635   lfsmake2 python3-cryptography
1636   lfsmake2 python3-circuitbreaker
1637   lfsmake2 python3-pytz
1638   lfsmake2 python3-click
1639   lfsmake2 python3-arrow
1640   lfsmake2 python3-terminaltables
1641   lfsmake2 aws-cli
1642   lfsmake2 oci-python-sdk
1643   lfsmake2 oci-cli
1644   lfsmake2 transmission
1645   lfsmake2 mtr
1646   lfsmake2 minidlna
1647   lfsmake2 acpid
1648   lfsmake2 fping
1649   lfsmake2 telnet
1650   lfsmake2 xinetd
1651   lfsmake2 stress
1652   lfsmake2 sarg
1653   lfsmake2 nginx
1654   lfsmake2 sysbench
1655   lfsmake2 strace
1656   lfsmake2 ltrace
1657   lfsmake2 ipfire-netboot
1658   lfsmake2 lcdproc
1659   lfsmake2 keepalived
1660   lfsmake2 ipvsadm
1661   lfsmake2 perl-Carp-Clan
1662   lfsmake2 perl-Date-Calc
1663   lfsmake2 perl-Date-Manip
1664   lfsmake2 perl-File-Tail
1665   lfsmake2 perl-TimeDate
1666   lfsmake2 swatch
1667   lfsmake2 tor
1668   lfsmake2 wavemon
1669   lfsmake2 iptraf-ng
1670   lfsmake2 iotop
1671   lfsmake2 stunnel
1672   lfsmake2 bacula
1673   lfsmake2 perl-Font-TTF
1674   lfsmake2 perl-IO-String
1675   lfsmake2 perl-PDF-API2
1676   lfsmake2 proxy-accounting
1677   lfsmake2 pigz
1678   lfsmake2 tmux
1679   lfsmake2 perl-Text-CSV_XS
1680   lfsmake2 lua
1681   lfsmake2 haproxy
1682   lfsmake2 ipset
1683   lfsmake2 dnsdist
1684   lfsmake2 bird
1685   lfsmake2 libyang
1686   lfsmake2 frr
1687   lfsmake2 dmidecode
1688   lfsmake2 mcelog
1689   lfsmake2 libpciaccess
1690   lfsmake2 libyajl
1691   lfsmake2 libvirt
1692   lfsmake2 libtalloc
1693   lfsmake2 freeradius
1694   lfsmake2 perl-common-sense
1695   lfsmake2 perl-inotify2
1696   lfsmake2 perl-Net-IP
1697   lfsmake2 wio
1698   lfsmake2 iftop
1699   lfsmake2 mdns-repeater
1700   lfsmake2 i2c-tools
1701   lfsmake2 nss-myhostname
1702   lfsmake2 dehydrated
1703   lfsmake2 shairport-sync
1704   lfsmake2 borgbackup
1705   lfsmake2 lmdb
1706   lfsmake2 knot
1707   lfsmake2 spectre-meltdown-checker
1708   lfsmake2 zabbix_agentd
1709   lfsmake2 flashrom
1710   lfsmake2 firmware-update
1711   lfsmake2 tshark
1712   lfsmake2 speedtest-cli
1713   lfsmake2 rfkill
1714   lfsmake2 amazon-ssm-agent
1715   lfsmake2 libloc
1716   lfsmake2 ncdu
1717   lfsmake2 lshw
1718   lfsmake2 socat
1719   lfsmake2 libcdada
1720   lfsmake2 pmacct
1721   lfsmake2 squid-asnbl
1722   lfsmake2 qemu-ga
1723         lfsmake2 gptfdisk
1724 }
1725
1726 buildinstaller() {
1727   # Run installer scripts one by one
1728   LOGFILE="$BASEDIR/log/_build.installer.log"
1729   export LOGFILE
1730   lfsmake2 memtest
1731   lfsmake2 installer
1732   # use toolchain bash for chroot to strip
1733   CUSTOM_PATH="${TOOLS_DIR}/bin" lfsmake2 strip
1734 }
1735
1736 buildpackages() {
1737   LOGFILE="$BASEDIR/log/_build.packages.log"
1738   export LOGFILE
1739   echo "... see detailed log in _build.*.log files" >> $LOGFILE
1740
1741
1742   # Generating list of packages used
1743   print_line "Generating packages list from logs"
1744   rm -f $BASEDIR/doc/packages-list
1745   for i in `ls -1tr $BASEDIR/log/[^_]*`; do
1746         if [ "$i" != "$BASEDIR/log/FILES" -a -n $i ]; then
1747                 echo "* `basename $i`" >>$BASEDIR/doc/packages-list
1748         fi
1749   done
1750   echo "== List of softwares used to build $NAME Version: $VERSION ==" > $BASEDIR/doc/packages-list.txt
1751   grep -v 'configroot$\|img$\|initrd$\|initscripts$\|installer$\|install$\|setup$\|pakfire$\|stage2$\|smp$\|tools$\|tools1$\|tools2$\|.tgz$\|-config$\|_missing_rootfile$\|install1$\|install2$\|pass1$\|pass2$\|pass3$' \
1752         $BASEDIR/doc/packages-list | sort >> $BASEDIR/doc/packages-list.txt
1753   rm -f $BASEDIR/doc/packages-list
1754   # packages-list.txt is ready to be displayed for wiki page
1755   print_status DONE
1756
1757   # Update changelog
1758   cd $BASEDIR
1759   [ -z $GIT_TAG ]  || LAST_TAG=$GIT_TAG
1760   [ -z $LAST_TAG ] || EXT="$LAST_TAG..HEAD"
1761   git log -n 500 --no-merges --pretty=medium --shortstat $EXT > $BASEDIR/doc/ChangeLog
1762
1763   # Create images for install
1764   lfsmake2 cdrom
1765
1766   # Check if there is a loop device for building in virtual environments
1767   modprobe loop 2>/dev/null
1768   if [ $BUILD_IMAGES == 1 ] && ([ -e /dev/loop/0 ] || [ -e /dev/loop0 ] || [ -e "/dev/loop-control" ]); then
1769         lfsmake2 flash-images
1770   fi
1771
1772   mv $LFS/install/images/{*.iso,*.img.xz,*.bz2} $BASEDIR >> $LOGFILE 2>&1
1773
1774   ipfirepackages
1775
1776   cd $BASEDIR
1777
1778   # remove not useable iso on armv6l (needed to build flash images)
1779   [ "${BUILD_ARCH}" = "armv6l" ] && rm -rf *.iso
1780
1781   for i in $(ls *.bz2 *.img.xz *.iso 2>/dev/null); do
1782         md5sum $i > $i.md5
1783   done
1784   cd $PWD
1785
1786   # Cleanup
1787   stdumount
1788   rm -rf $BASEDIR/build/tmp/*
1789
1790   cd $PWD
1791 }
1792
1793 ipfirepackages() {
1794         lfsmake2 core-updates
1795
1796         local i
1797         for i in $(find $BASEDIR/config/rootfiles/packages{/${BUILD_ARCH},} -maxdepth 1 -type f); do
1798                 i=$(basename ${i})
1799                 if [ -e $BASEDIR/lfs/$i ]; then
1800                         ipfiredist $i
1801                 else
1802                         echo -n $i
1803                         print_status SKIP
1804                 fi
1805         done
1806   test -d $BASEDIR/packages || mkdir $BASEDIR/packages
1807   mv -f $LFS/install/packages/* $BASEDIR/packages >> $LOGFILE 2>&1
1808   rm -rf  $BASEDIR/build/install/packages/*
1809 }
1810
1811 while [ $# -gt 0 ]; do
1812         case "${1}" in
1813                 --target=*)
1814                         configure_build "${1#--target=}"
1815                         ;;
1816                 -*)
1817                         exiterror "Unknown configuration option: ${1}"
1818                         ;;
1819                 *)
1820                         # Found a command, so exit options parsing.
1821                         break
1822                         ;;
1823         esac
1824         shift
1825 done
1826
1827 # See what we're supposed to do
1828 case "$1" in
1829 build)
1830         START_TIME="${SECONDS}"
1831
1832         # Clear screen
1833         ${INTERACTIVE} && clear
1834
1835         PACKAGE="$BASEDIR/cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst"
1836         #only restore on a clean disk
1837         if [ ! -e "${BASEDIR}/build${TOOLS_DIR}/.toolchain-successful" ]; then
1838                 if [ ! -n "$PACKAGE" ]; then
1839                         print_build_stage "Full toolchain compilation"
1840                         prepareenv
1841                         buildtoolchain
1842                 else
1843                         PACKAGENAME=${PACKAGE%.tar.zst}
1844                         print_build_stage "Packaged toolchain compilation"
1845                         if [ `md5sum $PACKAGE | awk '{print $1}'` == `cat $PACKAGENAME.md5 | awk '{print $1}'` ]; then
1846                                 zstd -d < "${PACKAGE}" | tar x
1847                                 prepareenv
1848                         else
1849                                 exiterror "$PACKAGENAME md5 did not match, check downloaded package"
1850                         fi
1851                 fi
1852         else
1853                 prepareenv
1854         fi
1855
1856         print_build_stage "Building LFS"
1857         buildbase
1858
1859         print_build_stage "Building IPFire"
1860         buildipfire
1861
1862         print_build_stage "Building installer"
1863         buildinstaller
1864
1865         print_build_stage "Building packages"
1866         buildpackages
1867
1868         print_build_stage "Checking Logfiles for new Files"
1869
1870         cd $BASEDIR
1871         tools/checknewlog.pl
1872         tools/checkrootfiles
1873         cd $PWD
1874
1875         print_build_summary $(( SECONDS - START_TIME ))
1876         ;;
1877 shell)
1878         # enter a shell inside LFS chroot
1879         # may be used to changed kernel settings
1880         prepareenv
1881         entershell
1882         ;;
1883 clean)
1884         print_line "Cleaning build directory..."
1885
1886         for i in `mount | grep $BASEDIR | sed 's/^.*loop=\(.*\))/\1/'`; do
1887                 $LOSETUP -d $i 2>/dev/null
1888         done
1889         #for i in `mount | grep $BASEDIR | cut -d " " -f 1`; do
1890         #       umount $i
1891         #done
1892         stdumount
1893         for i in `seq 0 7`; do
1894                 if ( losetup /dev/loop${i} 2>/dev/null | grep -q "/install/images" ); then
1895                 umount /dev/loop${i}     2>/dev/null;
1896                 losetup -d /dev/loop${i} 2>/dev/null;
1897                 fi;
1898         done
1899         rm -rf $BASEDIR/build
1900         rm -rf $BASEDIR/cdrom
1901         rm -rf $BASEDIR/packages
1902         rm -rf $BASEDIR/log
1903         if [ -h "${TOOLS_DIR}" ]; then
1904                 rm -f "${TOOLS_DIR}"
1905         fi
1906         rm -f $BASEDIR/ipfire-*
1907         print_status DONE
1908         ;;
1909 docker)
1910         # Build the docker image if it does not exist, yet
1911         if ! docker images -a | grep -q ^ipfire-builder; then
1912                 if docker build -t ipfire-builder ${BASEDIR}/tools/docker; then
1913                         print_status DONE
1914                 else
1915                         print_status FAIL
1916                         exit 1
1917                 fi
1918         fi
1919
1920         # Run the container and enter a shell
1921         docker run -it --privileged -v "${BASEDIR}:/build" -w "/build" ipfire-builder bash -l
1922         ;;
1923 downloadsrc)
1924         if [ ! -d $BASEDIR/cache ]; then
1925                 mkdir $BASEDIR/cache
1926         fi
1927         mkdir -p $BASEDIR/log
1928         echo -e "${BOLD}Preload all source files${NORMAL}" | tee -a $LOGFILE
1929         FINISHED=0
1930         cd $BASEDIR/lfs
1931         for c in `seq $MAX_RETRIES`; do
1932                 if (( FINISHED==1 )); then
1933                         break
1934                 fi
1935                 FINISHED=1
1936                 cd $BASEDIR/lfs
1937                 for i in *; do
1938                         if [ -f "$i" -a "$i" != "Config" ]; then
1939                                 lfsmakecommoncheck ${i} || continue
1940
1941                                 make -s -f $i LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
1942                                         MESSAGE="$i\t ($c/$MAX_RETRIES)" download >> $LOGFILE 2>&1
1943                                 if [ $? -ne 0 ]; then
1944                                         print_status FAIL
1945                                         FINISHED=0
1946                                 else
1947                                         if [ $c -eq 1 ]; then
1948                                         print_status DONE
1949                                         fi
1950                                 fi
1951                         fi
1952                 done
1953         done
1954         echo -e "${BOLD}***Verifying md5sums${NORMAL}"
1955         ERROR=0
1956         for i in *; do
1957                 if [ -f "$i" -a "$i" != "Config" ]; then
1958                         lfsmakecommoncheck ${i} > /dev/null || continue
1959                         make -s -f $i LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
1960                                 MESSAGE="$i\t " md5 >> $LOGFILE 2>&1
1961                         if [ $? -ne 0 ]; then
1962                                 echo -ne "MD5 difference in lfs/$i"
1963                                 print_status FAIL
1964                                 ERROR=1
1965                         fi
1966                 fi
1967         done
1968         if [ $ERROR -eq 0 ]; then
1969                 echo -ne "${BOLD}all files md5sum match${NORMAL}"
1970                 print_status DONE
1971         else
1972                 echo -ne "${BOLD}not all files were correctly download${NORMAL}"
1973                 print_status FAIL
1974         fi
1975         cd - >/dev/null 2>&1
1976         ;;
1977 toolchain)
1978         # Clear screen
1979         ${INTERACTIVE} && clear
1980
1981         prepareenv
1982         print_build_stage "Toolchain compilation (${BUILD_ARCH})"
1983         buildtoolchain
1984         echo "`date -u '+%b %e %T'`: Create toolchain image for ${BUILD_ARCH}" | tee -a $LOGFILE
1985         test -d $BASEDIR/cache/toolchains || mkdir -p $BASEDIR/cache/toolchains
1986         cd $BASEDIR && tar -cf- --exclude='log/_build.*.log' build/${TOOLS_DIR} build/bin/sh log \
1987                 | zstd ${ZSTD_OPT} > cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst
1988         md5sum cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst \
1989                 > cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.md5
1990         stdumount
1991         ;;
1992 gettoolchain)
1993         # arbitrary name to be updated in case of new toolchain package upload
1994         PACKAGE=$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}
1995         if [ ! -f $BASEDIR/cache/toolchains/$PACKAGE.tar.zst ]; then
1996                 URL_TOOLCHAIN=`grep URL_TOOLCHAIN lfs/Config | awk '{ print $3 }'`
1997                 test -d $BASEDIR/cache/toolchains || mkdir -p $BASEDIR/cache/toolchains
1998                 echo "`date -u '+%b %e %T'`: Load toolchain image for ${BUILD_ARCH}" | tee -a $LOGFILE
1999                 cd $BASEDIR/cache/toolchains
2000                 wget -U "IPFireSourceGrabber/2.x" $URL_TOOLCHAIN/$PACKAGE.tar.zst $URL_TOOLCHAIN/$PACKAGE.md5 >& /dev/null
2001                 if [ $? -ne 0 ]; then
2002                         echo "`date -u '+%b %e %T'`: error downloading $PACKAGE toolchain for ${BUILD_ARCH} machine" | tee -a $LOGFILE
2003                 else
2004                         if [ "`md5sum $PACKAGE.tar.zst | awk '{print $1}'`" = "`cat $PACKAGE.md5 | awk '{print $1}'`" ]; then
2005                                 echo "`date -u '+%b %e %T'`: toolchain md5 ok" | tee -a $LOGFILE
2006                         else
2007                                 exiterror "$PACKAGE.md5 did not match, check downloaded package"
2008                         fi
2009                 fi
2010         else
2011                 echo "Toolchain is already downloaded. Exiting..."
2012         fi
2013         ;;
2014 uploadsrc)
2015         if [ -z $IPFIRE_USER ]; then
2016                 echo -n "You have to setup IPFIRE_USER first. See .config for details."
2017                 print_status FAIL
2018                 exit 1
2019         fi
2020
2021         URL_SOURCE="$(awk '/^URL_SOURCE/ { print $3 }' lfs/Config)"
2022
2023         rsync \
2024                 --recursive \
2025                 --update \
2026                 --ignore-existing \
2027                 --progress \
2028                 --human-readable \
2029                 --exclude="toolchains/" \
2030                 "${BASEDIR}/cache/" \
2031                 "${IPFIRE_USER}@${URL_SOURCE}"
2032
2033         exit 0
2034         ;;
2035 lang)
2036         echo -ne "Checking the translations for missing or obsolete strings..."
2037         chmod 755 $BASEDIR/tools/{check_strings.pl,sort_strings.pl,check_langs.sh}
2038         $BASEDIR/tools/sort_strings.pl en
2039         $BASEDIR/tools/sort_strings.pl de
2040         $BASEDIR/tools/sort_strings.pl fr
2041         $BASEDIR/tools/sort_strings.pl es
2042         $BASEDIR/tools/sort_strings.pl pl
2043         $BASEDIR/tools/sort_strings.pl ru
2044         $BASEDIR/tools/sort_strings.pl nl
2045         $BASEDIR/tools/sort_strings.pl tr
2046         $BASEDIR/tools/sort_strings.pl it
2047         $BASEDIR/tools/check_strings.pl en > $BASEDIR/doc/language_issues.en
2048         $BASEDIR/tools/check_strings.pl de > $BASEDIR/doc/language_issues.de
2049         $BASEDIR/tools/check_strings.pl fr > $BASEDIR/doc/language_issues.fr
2050         $BASEDIR/tools/check_strings.pl es > $BASEDIR/doc/language_issues.es
2051         $BASEDIR/tools/check_strings.pl pl > $BASEDIR/doc/language_issues.pl
2052         $BASEDIR/tools/check_strings.pl ru > $BASEDIR/doc/language_issues.ru
2053         $BASEDIR/tools/check_strings.pl nl > $BASEDIR/doc/language_issues.nl
2054         $BASEDIR/tools/check_strings.pl tr > $BASEDIR/doc/language_issues.tr
2055         $BASEDIR/tools/check_strings.pl it > $BASEDIR/doc/language_issues.it
2056         $BASEDIR/tools/check_langs.sh > $BASEDIR/doc/language_missings
2057         print_status DONE
2058
2059         echo -ne "Updating language lists..."
2060         update_language_list ${BASEDIR}/src/installer/po
2061         update_language_list ${BASEDIR}/src/setup/po
2062         print_status DONE
2063         ;;
2064 update-contributors)
2065         update_contributors
2066         ;;
2067 find-dependencies)
2068         shift
2069         exec "${BASEDIR}/tools/find-dependencies" "${BASEDIR}/build" "$@"
2070         ;;
2071 check-manualpages)
2072         echo "Checking the manual pages for broken links..."
2073
2074         chmod 755 $BASEDIR/tools/check_manualpages.pl
2075         if $BASEDIR/tools/check_manualpages.pl; then
2076                 print_status DONE
2077         else
2078                 print_status FAIL
2079         fi
2080         ;;
2081 *)
2082         echo "Usage: $0 [OPTIONS] {build|changelog|clean|gettoolchain|downloadsrc|shell|sync|toolchain|update-contributors|find-dependencies|check-manualpages}"
2083         cat doc/make.sh-usage
2084         ;;
2085 esac